src/mesa/main/transformfeedback.c

   1 /*
   2  * Mesa 3-D graphics library
   3  *
   4  * Copyright (C) 2010  VMware, Inc.  All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included
  14  * in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  20  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  21  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  */
  23
  24
  25 /*
  26  * Vertex transform feedback support.
  27  *
  28  * Authors:
  29  *   Brian Paul
  30  */
  31
  32
  33 #include "buffers.h"
  34 #include "bufferobj.h"
  35 #include "context.h"
  36 #include "hash.h"
  37 #include "mfeatures.h"
  38 #include "mtypes.h"
  39 #include "transformfeedback.h"
  40 #include "shaderapi.h"
  41 #include "shaderobj.h"
  42 #include "main/dispatch.h"
  43
  44 #include "program/prog_parameter.h"
  45
  46
  47 #if FEATURE_EXT_transform_feedback
  48
  49
  50 /**
  51  * Do reference counting of transform feedback buffers.
  52  */
  53 static void
  54 reference_transform_feedback_object(struct gl_transform_feedback_object **ptr,
  55                                     struct gl_transform_feedback_object *obj)
  56 {
  57    if (*ptr == obj)
  58       return;
  59
  60    if (*ptr) {
  61       /* Unreference the old object */
  62       struct gl_transform_feedback_object *oldObj = *ptr;
  63
  64       ASSERT(oldObj->RefCount > 0);
  65       oldObj->RefCount--;
  66
  67       if (oldObj->RefCount == 0) {
  68          GET_CURRENT_CONTEXT(ctx);
  69          if (ctx)
  70             ctx->Driver.DeleteTransformFeedback(ctx, oldObj);
  71       }
  72
  73       *ptr = NULL;
  74    }
  75    ASSERT(!*ptr);
  76
  77    if (obj) {
  78       /* reference new object */
  79       if (obj->RefCount == 0) {
  80          _mesa_problem(NULL, "referencing deleted transform feedback object");
  81          *ptr = NULL;
  82       }
  83       else {
  84          obj->RefCount++;
  85          *ptr = obj;
  86       }
  87    }
  88 }
  89
  90
  91 /**
  92  * Check that all the buffer objects currently bound for transform
  93  * feedback actually exist.  Raise a GL_INVALID_OPERATION error if
  94  * any buffers are missing.
  95  * \return GL_TRUE for success, GL_FALSE if error
  96  */
  97 GLboolean
  98 _mesa_validate_transform_feedback_buffers(struct gl_context *ctx)
  99 {
 100    /* XXX to do */
 101    return GL_TRUE;
 102 }
 103
 104
 105
 106 /**
 107  * Per-context init for transform feedback.
 108  */
 109 void
 110 _mesa_init_transform_feedback(struct gl_context *ctx)
 111 {
 112    /* core mesa expects this, even a dummy one, to be available */
 113    ASSERT(ctx->Driver.NewTransformFeedback);
 114
 115    ctx->TransformFeedback.DefaultObject =
 116       ctx->Driver.NewTransformFeedback(ctx, 0);
 117
 118    assert(ctx->TransformFeedback.DefaultObject->RefCount == 1);
 119
 120    reference_transform_feedback_object(&ctx->TransformFeedback.CurrentObject,
 121                                        ctx->TransformFeedback.DefaultObject);
 122
 123    assert(ctx->TransformFeedback.DefaultObject->RefCount == 2);
 124
 125    ctx->TransformFeedback.Objects = _mesa_NewHashTable();
 126
 127    _mesa_reference_buffer_object(ctx,
 128                                  &ctx->TransformFeedback.CurrentBuffer,
 129                                  ctx->Shared->NullBufferObj);
 130 }
 131
 132
 133
 134 /**
 135  * Callback for _mesa_HashDeleteAll().
 136  */
 137 static void
 138 delete_cb(GLuint key, void *data, void *userData)
 139 {
 140    struct gl_context *ctx = (struct gl_context *) userData;
 141    struct gl_transform_feedback_object *obj =
 142       (struct gl_transform_feedback_object *) data;
 143
 144    ctx->Driver.DeleteTransformFeedback(ctx, obj);
 145 }
 146
 147
 148 /**
 149  * Per-context free/clean-up for transform feedback.
 150  */
 151 void
 152 _mesa_free_transform_feedback(struct gl_context *ctx)
 153 {
 154    /* core mesa expects this, even a dummy one, to be available */
 155    ASSERT(ctx->Driver.NewTransformFeedback);
 156
 157    _mesa_reference_buffer_object(ctx,
 158                                  &ctx->TransformFeedback.CurrentBuffer,
 159                                  NULL);
 160
 161    /* Delete all feedback objects */
 162    _mesa_HashDeleteAll(ctx->TransformFeedback.Objects, delete_cb, ctx);
 163    _mesa_DeleteHashTable(ctx->TransformFeedback.Objects);
 164
 165    /* Delete the default feedback object */
 166    assert(ctx->Driver.DeleteTransformFeedback);
 167    ctx->Driver.DeleteTransformFeedback(ctx,
 168                                        ctx->TransformFeedback.DefaultObject);
 169
 170    ctx->TransformFeedback.CurrentObject = NULL;
 171 }
 172
 173
 174 #else /* FEATURE_EXT_transform_feedback */
 175
 176 /* forward declarations */
 177 static struct gl_transform_feedback_object *
 178 new_transform_feedback(struct gl_context *ctx, GLuint name);
 179
 180 static void
 181 delete_transform_feedback(struct gl_context *ctx,
 182                           struct gl_transform_feedback_object *obj);
 183
 184 /* dummy per-context init/clean-up for transform feedback */
 185 void
 186 _mesa_init_transform_feedback(struct gl_context *ctx)
 187 {
 188    ctx->TransformFeedback.DefaultObject = new_transform_feedback(ctx, 0);
 189    ctx->TransformFeedback.CurrentObject = ctx->TransformFeedback.DefaultObject;
 190    _mesa_reference_buffer_object(ctx,
 191                                  &ctx->TransformFeedback.CurrentBuffer,
 192                                  ctx->Shared->NullBufferObj);
 193 }
 194
 195 void
 196 _mesa_free_transform_feedback(struct gl_context *ctx)
 197 {
 198    _mesa_reference_buffer_object(ctx,
 199                                  &ctx->TransformFeedback.CurrentBuffer,
 200                                  NULL);
 201    ctx->TransformFeedback.CurrentObject = NULL;
 202    delete_transform_feedback(ctx, ctx->TransformFeedback.DefaultObject);
 203 }
 204
 205 #endif /* FEATURE_EXT_transform_feedback */
 206
 207
 208 /** Default fallback for ctx->Driver.NewTransformFeedback() */
 209 static struct gl_transform_feedback_object *
 210 new_transform_feedback(struct gl_context *ctx, GLuint name)
 211 {
 212    struct gl_transform_feedback_object *obj;
 213    obj = CALLOC_STRUCT(gl_transform_feedback_object);
 214    if (obj) {
 215       obj->Name = name;
 216       obj->RefCount = 1;
 217    }
 218    return obj;
 219 }
 220
 221 /** Default fallback for ctx->Driver.DeleteTransformFeedback() */
 222 static void
 223 delete_transform_feedback(struct gl_context *ctx,
 224                           struct gl_transform_feedback_object *obj)
 225 {
 226    GLuint i;
 227
 228    for (i = 0; i < Elements(obj->Buffers); i++) {
 229       _mesa_reference_buffer_object(ctx, &obj->Buffers[i], NULL);
 230    }
 231
 232    free(obj);
 233 }
 234
 235
 236 #if FEATURE_EXT_transform_feedback
 237
 238
 239 /** Default fallback for ctx->Driver.BeginTransformFeedback() */
 240 static void
 241 begin_transform_feedback(struct gl_context *ctx, GLenum mode,
 242                          struct gl_transform_feedback_object *obj)
 243 {
 244    /* nop */
 245 }
 246
 247 /** Default fallback for ctx->Driver.EndTransformFeedback() */
 248 static void
 249 end_transform_feedback(struct gl_context *ctx,
 250                        struct gl_transform_feedback_object *obj)
 251 {
 252    /* nop */
 253 }
 254
 255 /** Default fallback for ctx->Driver.PauseTransformFeedback() */
 256 static void
 257 pause_transform_feedback(struct gl_context *ctx,
 258                          struct gl_transform_feedback_object *obj)
 259 {
 260    /* nop */
 261 }
 262
 263 /** Default fallback for ctx->Driver.ResumeTransformFeedback() */
 264 static void
 265 resume_transform_feedback(struct gl_context *ctx,
 266                           struct gl_transform_feedback_object *obj)
 267 {
 268    /* nop */
 269 }
 270
 271
 272 /**
 273  * Plug in default device driver functions for transform feedback.
 274  * Most drivers will override some/all of these.
 275  */
 276 void
 277 _mesa_init_transform_feedback_functions(struct dd_function_table *driver)
 278 {
 279    driver->NewTransformFeedback = new_transform_feedback;
 280    driver->DeleteTransformFeedback = delete_transform_feedback;
 281    driver->BeginTransformFeedback = begin_transform_feedback;
 282    driver->EndTransformFeedback = end_transform_feedback;
 283    driver->PauseTransformFeedback = pause_transform_feedback;
 284    driver->ResumeTransformFeedback = resume_transform_feedback;
 285 }
 286
 287
 288 void
 289 _mesa_init_transform_feedback_dispatch(struct _glapi_table *disp)
 290 {
 291    /* EXT_transform_feedback */
 292    SET_BeginTransformFeedbackEXT(disp, _mesa_BeginTransformFeedback);
 293    SET_EndTransformFeedbackEXT(disp, _mesa_EndTransformFeedback);
 294    SET_BindBufferOffsetEXT(disp, _mesa_BindBufferOffsetEXT);
 295    SET_TransformFeedbackVaryingsEXT(disp, _mesa_TransformFeedbackVaryings);
 296    SET_GetTransformFeedbackVaryingEXT(disp, _mesa_GetTransformFeedbackVarying);
 297    /* ARB_transform_feedback2 */
 298    SET_BindTransformFeedback(disp, _mesa_BindTransformFeedback);
 299    SET_DeleteTransformFeedbacks(disp, _mesa_DeleteTransformFeedbacks);
 300    SET_GenTransformFeedbacks(disp, _mesa_GenTransformFeedbacks);
 301    SET_IsTransformFeedback(disp, _mesa_IsTransformFeedback);
 302    SET_PauseTransformFeedback(disp, _mesa_PauseTransformFeedback);
 303    SET_ResumeTransformFeedback(disp, _mesa_ResumeTransformFeedback);
 304 }
 305
 306
 307 /**
 308  ** Begin API functions
 309  **/
 310
 311
 312 void GLAPIENTRY
 313 _mesa_BeginTransformFeedback(GLenum mode)
 314 {
 315    struct gl_transform_feedback_object *obj;
 316    struct gl_transform_feedback_info *info;
 317    int i;
 318    GET_CURRENT_CONTEXT(ctx);
 319
 320    obj = ctx->TransformFeedback.CurrentObject;
 321
 322    if (ctx->Shader.CurrentVertexProgram == NULL) {
 323       _mesa_error(ctx, GL_INVALID_OPERATION,
 324                   "glBeginTransformFeedback(no program active)");
 325       return;
 326    }
 327
 328    info = &ctx->Shader.CurrentVertexProgram->LinkedTransformFeedback;
 329
 330    if (info->NumOutputs == 0) {
 331       _mesa_error(ctx, GL_INVALID_OPERATION,
 332                   "glBeginTransformFeedback(no varyings to record)");
 333       return;
 334    }
 335
 336    switch (mode) {
 337    case GL_POINTS:
 338    case GL_LINES:
 339    case GL_TRIANGLES:
 340       /* legal */
 341       break;
 342    default:
 343       _mesa_error(ctx, GL_INVALID_ENUM, "glBeginTransformFeedback(mode)");
 344       return;
 345    }
 346
 347    if (obj->Active) {
 348       _mesa_error(ctx, GL_INVALID_OPERATION,
 349                   "glBeginTransformFeedback(already active)");
 350       return;
 351    }
 352
 353    for (i = 0; i < info->NumBuffers; ++i) {
 354       if (obj->BufferNames[i] == 0) {
 355          _mesa_error(ctx, GL_INVALID_OPERATION,
 356                      "glBeginTransformFeedback(binding point %d does not have "
 357                      "a buffer object bound)", i);
 358          return;
 359       }
 360    }
 361
 362    FLUSH_VERTICES(ctx, _NEW_TRANSFORM_FEEDBACK);
 363    obj->Active = GL_TRUE;
 364    ctx->TransformFeedback.Mode = mode;
 365
 366    assert(ctx->Driver.BeginTransformFeedback);
 367    ctx->Driver.BeginTransformFeedback(ctx, mode, obj);
 368 }
 369
 370
 371 void GLAPIENTRY
 372 _mesa_EndTransformFeedback(void)
 373 {
 374    struct gl_transform_feedback_object *obj;
 375    GET_CURRENT_CONTEXT(ctx);
 376
 377    obj = ctx->TransformFeedback.CurrentObject;
 378
 379    if (!obj->Active) {
 380       _mesa_error(ctx, GL_INVALID_OPERATION,
 381                   "glEndTransformFeedback(not active)");
 382       return;
 383    }
 384
 385    FLUSH_VERTICES(ctx, _NEW_TRANSFORM_FEEDBACK);
 386    ctx->TransformFeedback.CurrentObject->Active = GL_FALSE;
 387    ctx->TransformFeedback.CurrentObject->Paused = GL_FALSE;
 388    ctx->TransformFeedback.CurrentObject->EndedAnytime = GL_TRUE;
 389
 390    assert(ctx->Driver.EndTransformFeedback);
 391    ctx->Driver.EndTransformFeedback(ctx, obj);
 392 }
 393
 394
 395 /**
 396  * Helper used by BindBufferRange() and BindBufferBase().
 397  */
 398 static void
 399 bind_buffer_range(struct gl_context *ctx, GLuint index,
 400                   struct gl_buffer_object *bufObj,
 401                   GLintptr offset, GLsizeiptr size)
 402 {
 403    struct gl_transform_feedback_object *obj =
 404       ctx->TransformFeedback.CurrentObject;
 405
 406    /* Note: no need to FLUSH_VERTICES or flag _NEW_TRANSFORM_FEEDBACK, because
 407     * transform feedback buffers can't be changed while transform feedback is
 408     * active.
 409     */
 410
 411    /* The general binding point */
 412    _mesa_reference_buffer_object(ctx,
 413                                  &ctx->TransformFeedback.CurrentBuffer,
 414                                  bufObj);
 415
 416    /* The per-attribute binding point */
 417    _mesa_reference_buffer_object(ctx,
 418                                  &obj->Buffers[index],
 419                                  bufObj);
 420
 421    obj->BufferNames[index] = bufObj->Name;
 422
 423    obj->Offset[index] = offset;
 424    obj->Size[index] = size;
 425 }
 426
 427
 428 /**
 429  * Specify a buffer object to receive vertex shader results.  Plus,
 430  * specify the starting offset to place the results, and max size.
 431  * Called from the glBindBufferRange() function.
 432  */
 433 void
 434 _mesa_bind_buffer_range_transform_feedback(struct gl_context *ctx,
 435                                            GLuint index,
 436                                            struct gl_buffer_object *bufObj,
 437                                            GLintptr offset,
 438                                            GLsizeiptr size)
 439 {
 440    struct gl_transform_feedback_object *obj;
 441
 442    obj = ctx->TransformFeedback.CurrentObject;
 443
 444    if (obj->Active) {
 445       _mesa_error(ctx, GL_INVALID_OPERATION,
 446                   "glBindBufferRange(transform feedback active)");
 447       return;
 448    }
 449
 450    if (index >= ctx->Const.MaxTransformFeedbackBuffers) {
 451       _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(index=%d)", index);
 452       return;
 453    }
 454
 455    if (size & 0x3) {
 456       /* must a multiple of four */
 457       _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(size=%d)", (int) size);
 458       return;
 459    }
 460
 461    if (offset & 0x3) {
 462       /* must be multiple of four */
 463       _mesa_error(ctx, GL_INVALID_VALUE,
 464                   "glBindBufferRange(offset=%d)", (int) offset);
 465       return;
 466    }
 467
 468    bind_buffer_range(ctx, index, bufObj, offset, size);
 469 }
 470
 471
 472 /**
 473  * Specify a buffer object to receive vertex shader results.
 474  * As above, but start at offset = 0.
 475  * Called from the glBindBufferBase() function.
 476  */
 477 void
 478 _mesa_bind_buffer_base_transform_feedback(struct gl_context *ctx,
 479                                           GLuint index,
 480                                           struct gl_buffer_object *bufObj)
 481 {
 482    struct gl_transform_feedback_object *obj;
 483    GLsizeiptr size;
 484
 485    obj = ctx->TransformFeedback.CurrentObject;
 486
 487    if (obj->Active) {
 488       _mesa_error(ctx, GL_INVALID_OPERATION,
 489                   "glBindBufferBase(transform feedback active)");
 490       return;
 491    }
 492
 493    if (index >= ctx->Const.MaxTransformFeedbackBuffers) {
 494       _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferBase(index=%d)", index);
 495       return;
 496    }
 497
 498    /* default size is the buffer size rounded down to nearest
 499     * multiple of four.
 500     */
 501    size = bufObj->Size & ~0x3;
 502
 503    bind_buffer_range(ctx, index, bufObj, 0, size);
 504 }
 505
 506
 507 /**
 508  * Specify a buffer object to receive vertex shader results, plus the
 509  * offset in the buffer to start placing results.
 510  * This function is part of GL_EXT_transform_feedback, but not GL3.
 511  */
 512 void GLAPIENTRY
 513 _mesa_BindBufferOffsetEXT(GLenum target, GLuint index, GLuint buffer,
 514                           GLintptr offset)
 515 {
 516    struct gl_transform_feedback_object *obj;
 517    struct gl_buffer_object *bufObj;
 518    GET_CURRENT_CONTEXT(ctx);
 519    GLsizeiptr size;
 520
 521    if (target != GL_TRANSFORM_FEEDBACK_BUFFER) {
 522       _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferOffsetEXT(target)");
 523       return;
 524    }
 525
 526    obj = ctx->TransformFeedback.CurrentObject;
 527
 528    if (obj->Active) {
 529       _mesa_error(ctx, GL_INVALID_OPERATION,
 530                   "glBindBufferOffsetEXT(transform feedback active)");
 531       return;
 532    }
 533
 534    if (index >= ctx->Const.MaxTransformFeedbackBuffers) {
 535       _mesa_error(ctx, GL_INVALID_VALUE,
 536                   "glBindBufferOffsetEXT(index=%d)", index);
 537       return;
 538    }
 539
 540    if (offset & 0x3) {
 541       /* must be multiple of four */
 542       _mesa_error(ctx, GL_INVALID_VALUE,
 543                   "glBindBufferOffsetEXT(offset=%d)", (int) offset);
 544       return;
 545    }
 546
 547    if (buffer == 0) {
 548       bufObj = ctx->Shared->NullBufferObj;
 549    } else {
 550       bufObj = _mesa_lookup_bufferobj(ctx, buffer);
 551    }
 552
 553    if (!bufObj) {
 554       _mesa_error(ctx, GL_INVALID_OPERATION,
 555                   "glBindBufferOffsetEXT(invalid buffer=%u)", buffer);
 556       return;
 557    }
 558
 559    /* default size is the buffer size rounded down to nearest
 560     * multiple of four.
 561     */
 562    size = (bufObj->Size - offset) & ~0x3;
 563
 564    bind_buffer_range(ctx, index, bufObj, offset, size);
 565 }
 566
 567
 568 /**
 569  * This function specifies the vertex shader outputs to be written
 570  * to the feedback buffer(s), and in what order.
 571  */
 572 void GLAPIENTRY
 573 _mesa_TransformFeedbackVaryings(GLuint program, GLsizei count,
 574                                 const GLchar **varyings, GLenum bufferMode)
 575 {
 576    struct gl_shader_program *shProg;
 577    GLuint i;
 578    GET_CURRENT_CONTEXT(ctx);
 579
 580    switch (bufferMode) {
 581    case GL_INTERLEAVED_ATTRIBS:
 582       break;
 583    case GL_SEPARATE_ATTRIBS:
 584       break;
 585    default:
 586       _mesa_error(ctx, GL_INVALID_ENUM,
 587                   "glTransformFeedbackVaryings(bufferMode)");
 588       return;
 589    }
 590
 591    if (count < 0 ||
 592        (bufferMode == GL_SEPARATE_ATTRIBS &&
 593         (GLuint) count > ctx->Const.MaxTransformFeedbackBuffers)) {
 594       _mesa_error(ctx, GL_INVALID_VALUE,
 595                   "glTransformFeedbackVaryings(count=%d)", count);
 596       return;
 597    }
 598
 599    shProg = _mesa_lookup_shader_program(ctx, program);
 600    if (!shProg) {
 601       _mesa_error(ctx, GL_INVALID_VALUE,
 602                   "glTransformFeedbackVaryings(program=%u)", program);
 603       return;
 604    }
 605
 606    if (ctx->Extensions.ARB_transform_feedback3) {
 607       if (bufferMode == GL_INTERLEAVED_ATTRIBS) {
 608          unsigned buffers = 1;
 609
 610          for (i = 0; i < count; i++) {
 611             if (strcmp(varyings[i], "gl_NextBuffer") == 0)
 612                buffers++;
 613          }
 614
 615          if (buffers > ctx->Const.MaxTransformFeedbackBuffers) {
 616             _mesa_error(ctx, GL_INVALID_OPERATION,
 617                         "glTransformFeedbackVaryings(too many gl_NextBuffer "
 618                         "occurences)");
 619             return;
 620          }
 621       } else {
 622          for (i = 0; i < count; i++) {
 623             if (strcmp(varyings[i], "gl_NextBuffer") == 0 ||
 624                 strcmp(varyings[i], "gl_SkipComponents1") == 0 ||
 625                 strcmp(varyings[i], "gl_SkipComponents2") == 0 ||
 626                 strcmp(varyings[i], "gl_SkipComponents3") == 0 ||
 627                 strcmp(varyings[i], "gl_SkipComponents4") == 0) {
 628                _mesa_error(ctx, GL_INVALID_OPERATION,
 629                            "glTransformFeedbackVaryings(SEPARATE_ATTRIBS,"
 630                            "varying=%s)",
 631                            varyings[i]);
 632                return;
 633             }
 634          }
 635       }
 636    }
 637
 638    /* free existing varyings, if any */
 639    for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {
 640       free(shProg->TransformFeedback.VaryingNames[i]);
 641    }
 642    free(shProg->TransformFeedback.VaryingNames);
 643
 644    /* allocate new memory for varying names */
 645    shProg->TransformFeedback.VaryingNames =
 646       (GLchar **) malloc(count * sizeof(GLchar *));
 647
 648    if (!shProg->TransformFeedback.VaryingNames) {
 649       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTransformFeedbackVaryings()");
 650       return;
 651    }
 652
 653    /* Save the new names and the count */
 654    for (i = 0; i < (GLuint) count; i++) {
 655       shProg->TransformFeedback.VaryingNames[i] = _mesa_strdup(varyings[i]);
 656    }
 657    shProg->TransformFeedback.NumVarying = count;
 658
 659    shProg->TransformFeedback.BufferMode = bufferMode;
 660
 661    /* No need to set _NEW_TRANSFORM_FEEDBACK (or invoke FLUSH_VERTICES) since
 662     * the varyings won't be used until shader link time.
 663     */
 664 }
 665
 666
 667 /**
 668  * Get info about the vertex shader's outputs which are to be written
 669  * to the feedback buffer(s).
 670  */
 671 void GLAPIENTRY
 672 _mesa_GetTransformFeedbackVarying(GLuint program, GLuint index,
 673                                   GLsizei bufSize, GLsizei *length,
 674                                   GLsizei *size, GLenum *type, GLchar *name)
 675 {
 676    const struct gl_shader_program *shProg;
 677    const struct gl_transform_feedback_info *linked_xfb_info;
 678    GET_CURRENT_CONTEXT(ctx);
 679
 680    shProg = _mesa_lookup_shader_program(ctx, program);
 681    if (!shProg) {
 682       _mesa_error(ctx, GL_INVALID_VALUE,
 683                   "glGetTransformFeedbackVaryings(program=%u)", program);
 684       return;
 685    }
 686
 687    linked_xfb_info = &shProg->LinkedTransformFeedback;
 688    if (index >= linked_xfb_info->NumVarying) {
 689       _mesa_error(ctx, GL_INVALID_VALUE,
 690                   "glGetTransformFeedbackVaryings(index=%u)", index);
 691       return;
 692    }
 693
 694    /* return the varying's name and length */
 695    _mesa_copy_string(name, bufSize, length,
 696                      linked_xfb_info->Varyings[index].Name);
 697
 698    /* return the datatype and value's size (in datatype units) */
 699    if (type)
 700       *type = linked_xfb_info->Varyings[index].Type;
 701    if (size)
 702       *size = linked_xfb_info->Varyings[index].Size;
 703 }
 704
 705
 706
 707 struct gl_transform_feedback_object *
 708 _mesa_lookup_transform_feedback_object(struct gl_context *ctx, GLuint name)
 709 {
 710    if (name == 0) {
 711       return ctx->TransformFeedback.DefaultObject;
 712    }
 713    else
 714       return (struct gl_transform_feedback_object *)
 715          _mesa_HashLookup(ctx->TransformFeedback.Objects, name);
 716 }
 717
 718
 719 /**
 720  * Create new transform feedback objects.   Transform feedback objects
 721  * encapsulate the state related to transform feedback to allow quickly
 722  * switching state (and drawing the results, below).
 723  * Part of GL_ARB_transform_feedback2.
 724  */
 725 void GLAPIENTRY
 726 _mesa_GenTransformFeedbacks(GLsizei n, GLuint *names)
 727 {
 728    GLuint first;
 729    GET_CURRENT_CONTEXT(ctx);
 730
 731    ASSERT_OUTSIDE_BEGIN_END(ctx);
 732
 733    if (n < 0) {
 734       _mesa_error(ctx, GL_INVALID_VALUE, "glGenTransformFeedbacks(n < 0)");
 735       return;
 736    }
 737
 738    if (!names)
 739       return;
 740
 741    /* we don't need contiguous IDs, but this might be faster */
 742    first = _mesa_HashFindFreeKeyBlock(ctx->TransformFeedback.Objects, n);
 743    if (first) {
 744       GLsizei i;
 745       for (i = 0; i < n; i++) {
 746          struct gl_transform_feedback_object *obj
 747             = ctx->Driver.NewTransformFeedback(ctx, first + i);
 748          if (!obj) {
 749             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenTransformFeedbacks");
 750             return;
 751          }
 752          names[i] = first + i;
 753          _mesa_HashInsert(ctx->TransformFeedback.Objects, first + i, obj);
 754       }
 755    }
 756    else {
 757       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenTransformFeedbacks");
 758    }
 759 }
 760
 761
 762 /**
 763  * Is the given ID a transform feedback object?
 764  * Part of GL_ARB_transform_feedback2.
 765  */
 766 GLboolean GLAPIENTRY
 767 _mesa_IsTransformFeedback(GLuint name)
 768 {
 769    GET_CURRENT_CONTEXT(ctx);
 770
 771    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 772
 773    if (name && _mesa_lookup_transform_feedback_object(ctx, name))
 774       return GL_TRUE;
 775    else
 776       return GL_FALSE;
 777 }
 778
 779
 780 /**
 781  * Bind the given transform feedback object.
 782  * Part of GL_ARB_transform_feedback2.
 783  */
 784 void GLAPIENTRY
 785 _mesa_BindTransformFeedback(GLenum target, GLuint name)
 786 {
 787    struct gl_transform_feedback_object *obj;
 788    GET_CURRENT_CONTEXT(ctx);
 789
 790    if (target != GL_TRANSFORM_FEEDBACK) {
 791       _mesa_error(ctx, GL_INVALID_ENUM, "glBindTransformFeedback(target)");
 792       return;
 793    }
 794
 795    if (ctx->TransformFeedback.CurrentObject->Active &&
 796        !ctx->TransformFeedback.CurrentObject->Paused) {
 797       _mesa_error(ctx, GL_INVALID_OPERATION,
 798               "glBindTransformFeedback(transform is active, or not paused)");
 799       return;
 800    }
 801
 802    obj = _mesa_lookup_transform_feedback_object(ctx, name);
 803    if (!obj) {
 804       _mesa_error(ctx, GL_INVALID_OPERATION,
 805                   "glBindTransformFeedback(name=%u)", name);
 806       return;
 807    }
 808
 809    reference_transform_feedback_object(&ctx->TransformFeedback.CurrentObject,
 810                                        obj);
 811 }
 812
 813
 814 /**
 815  * Delete the given transform feedback objects.
 816  * Part of GL_ARB_transform_feedback2.
 817  */
 818 void GLAPIENTRY
 819 _mesa_DeleteTransformFeedbacks(GLsizei n, const GLuint *names)
 820 {
 821    GLint i;
 822    GET_CURRENT_CONTEXT(ctx);
 823
 824    ASSERT_OUTSIDE_BEGIN_END(ctx);
 825
 826    if (n < 0) {
 827       _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteTransformFeedbacks(n < 0)");
 828       return;
 829    }
 830
 831    if (!names)
 832       return;
 833
 834    for (i = 0; i < n; i++) {
 835       if (names[i] > 0) {
 836          struct gl_transform_feedback_object *obj
 837             = _mesa_lookup_transform_feedback_object(ctx, names[i]);
 838          if (obj) {
 839             if (obj->Active) {
 840                _mesa_error(ctx, GL_INVALID_OPERATION,
 841                            "glDeleteTransformFeedbacks(object %u is active)",
 842                            names[i]);
 843                return;
 844             }
 845             _mesa_HashRemove(ctx->TransformFeedback.Objects, names[i]);
 846             /* unref, but object may not be deleted until later */
 847             reference_transform_feedback_object(&obj, NULL);
 848          }
 849       }
 850    }
 851 }
 852
 853
 854 /**
 855  * Pause transform feedback.
 856  * Part of GL_ARB_transform_feedback2.
 857  */
 858 void GLAPIENTRY
 859 _mesa_PauseTransformFeedback(void)
 860 {
 861    struct gl_transform_feedback_object *obj;
 862    GET_CURRENT_CONTEXT(ctx);
 863
 864    obj = ctx->TransformFeedback.CurrentObject;
 865
 866    if (!obj->Active || obj->Paused) {
 867       _mesa_error(ctx, GL_INVALID_OPERATION,
 868            "glPauseTransformFeedback(feedback not active or already paused)");
 869       return;
 870    }
 871
 872    FLUSH_VERTICES(ctx, _NEW_TRANSFORM_FEEDBACK);
 873    obj->Paused = GL_TRUE;
 874
 875    assert(ctx->Driver.PauseTransformFeedback);
 876    ctx->Driver.PauseTransformFeedback(ctx, obj);
 877 }
 878
 879
 880 /**
 881  * Resume transform feedback.
 882  * Part of GL_ARB_transform_feedback2.
 883  */
 884 void GLAPIENTRY
 885 _mesa_ResumeTransformFeedback(void)
 886 {
 887    struct gl_transform_feedback_object *obj;
 888    GET_CURRENT_CONTEXT(ctx);
 889
 890    obj = ctx->TransformFeedback.CurrentObject;
 891
 892    if (!obj->Active || !obj->Paused) {
 893       _mesa_error(ctx, GL_INVALID_OPERATION,
 894                "glResumeTransformFeedback(feedback not active or not paused)");
 895       return;
 896    }
 897
 898    FLUSH_VERTICES(ctx, _NEW_TRANSFORM_FEEDBACK);
 899    obj->Paused = GL_FALSE;
 900
 901    assert(ctx->Driver.ResumeTransformFeedback);
 902    ctx->Driver.ResumeTransformFeedback(ctx, obj);
 903 }
 904
 905 #endif /* FEATURE_EXT_transform_feedback */