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 if the given primitive mode (as in glBegin(mode)) is compatible
  93  * with the current transform feedback mode (if it's enabled).
  94  * This is to be called from glBegin(), glDrawArrays(), glDrawElements(), etc.
  95  *
  96  * \return GL_TRUE if the mode is OK, GL_FALSE otherwise.
  97  */
  98 GLboolean
  99 _mesa_validate_primitive_mode(struct gl_context *ctx, GLenum mode)
 100 {
 101    if (ctx->TransformFeedback.CurrentObject->Active &&
 102        !ctx->TransformFeedback.CurrentObject->Paused) {
 103       switch (mode) {
 104       case GL_POINTS:
 105          return ctx->TransformFeedback.Mode == GL_POINTS;
 106       case GL_LINES:
 107       case GL_LINE_STRIP:
 108       case GL_LINE_LOOP:
 109          return ctx->TransformFeedback.Mode == GL_LINES;
 110       default:
 111          return ctx->TransformFeedback.Mode == GL_TRIANGLES;
 112       }
 113    }
 114    return GL_TRUE;
 115 }
 116
 117
 118 /**
 119  * Check that all the buffer objects currently bound for transform
 120  * feedback actually exist.  Raise a GL_INVALID_OPERATION error if
 121  * any buffers are missing.
 122  * \return GL_TRUE for success, GL_FALSE if error
 123  */
 124 GLboolean
 125 _mesa_validate_transform_feedback_buffers(struct gl_context *ctx)
 126 {
 127    /* XXX to do */
 128    return GL_TRUE;
 129 }
 130
 131
 132
 133 /**
 134  * Per-context init for transform feedback.
 135  */
 136 void
 137 _mesa_init_transform_feedback(struct gl_context *ctx)
 138 {
 139    /* core mesa expects this, even a dummy one, to be available */
 140    ASSERT(ctx->Driver.NewTransformFeedback);
 141
 142    ctx->TransformFeedback.DefaultObject =
 143       ctx->Driver.NewTransformFeedback(ctx, 0);
 144
 145    assert(ctx->TransformFeedback.DefaultObject->RefCount == 1);
 146
 147    reference_transform_feedback_object(&ctx->TransformFeedback.CurrentObject,
 148                                        ctx->TransformFeedback.DefaultObject);
 149
 150    assert(ctx->TransformFeedback.DefaultObject->RefCount == 2);
 151
 152    ctx->TransformFeedback.Objects = _mesa_NewHashTable();
 153
 154    _mesa_reference_buffer_object(ctx,
 155                                  &ctx->TransformFeedback.CurrentBuffer,
 156                                  ctx->Shared->NullBufferObj);
 157 }
 158
 159
 160
 161 /**
 162  * Callback for _mesa_HashDeleteAll().
 163  */
 164 static void
 165 delete_cb(GLuint key, void *data, void *userData)
 166 {
 167    struct gl_context *ctx = (struct gl_context *) userData;
 168    struct gl_transform_feedback_object *obj =
 169       (struct gl_transform_feedback_object *) data;
 170
 171    ctx->Driver.DeleteTransformFeedback(ctx, obj);
 172 }
 173
 174
 175 /**
 176  * Per-context free/clean-up for transform feedback.
 177  */
 178 void
 179 _mesa_free_transform_feedback(struct gl_context *ctx)
 180 {
 181    /* core mesa expects this, even a dummy one, to be available */
 182    ASSERT(ctx->Driver.NewTransformFeedback);
 183
 184    _mesa_reference_buffer_object(ctx,
 185                                  &ctx->TransformFeedback.CurrentBuffer,
 186                                  NULL);
 187
 188    /* Delete all feedback objects */
 189    _mesa_HashDeleteAll(ctx->TransformFeedback.Objects, delete_cb, ctx);
 190    _mesa_DeleteHashTable(ctx->TransformFeedback.Objects);
 191
 192    /* Delete the default feedback object */
 193    assert(ctx->Driver.DeleteTransformFeedback);
 194    ctx->Driver.DeleteTransformFeedback(ctx,
 195                                        ctx->TransformFeedback.DefaultObject);
 196
 197    ctx->TransformFeedback.CurrentObject = NULL;
 198 }
 199
 200
 201 #else /* FEATURE_EXT_transform_feedback */
 202
 203 /* forward declarations */
 204 static struct gl_transform_feedback_object *
 205 new_transform_feedback(struct gl_context *ctx, GLuint name);
 206
 207 static void
 208 delete_transform_feedback(struct gl_context *ctx,
 209                           struct gl_transform_feedback_object *obj);
 210
 211 /* dummy per-context init/clean-up for transform feedback */
 212 void
 213 _mesa_init_transform_feedback(struct gl_context *ctx)
 214 {
 215    ctx->TransformFeedback.DefaultObject = new_transform_feedback(ctx, 0);
 216    ctx->TransformFeedback.CurrentObject = ctx->TransformFeedback.DefaultObject;
 217    _mesa_reference_buffer_object(ctx,
 218                                  &ctx->TransformFeedback.CurrentBuffer,
 219                                  ctx->Shared->NullBufferObj);
 220 }
 221
 222 void
 223 _mesa_free_transform_feedback(struct gl_context *ctx)
 224 {
 225    _mesa_reference_buffer_object(ctx,
 226                                  &ctx->TransformFeedback.CurrentBuffer,
 227                                  NULL);
 228    ctx->TransformFeedback.CurrentObject = NULL;
 229    delete_transform_feedback(ctx, ctx->TransformFeedback.DefaultObject);
 230 }
 231
 232 #endif /* FEATURE_EXT_transform_feedback */
 233
 234
 235 /** Default fallback for ctx->Driver.NewTransformFeedback() */
 236 static struct gl_transform_feedback_object *
 237 new_transform_feedback(struct gl_context *ctx, GLuint name)
 238 {
 239    struct gl_transform_feedback_object *obj;
 240    obj = CALLOC_STRUCT(gl_transform_feedback_object);
 241    if (obj) {
 242       obj->Name = name;
 243       obj->RefCount = 1;
 244    }
 245    return obj;
 246 }
 247
 248 /** Default fallback for ctx->Driver.DeleteTransformFeedback() */
 249 static void
 250 delete_transform_feedback(struct gl_context *ctx,
 251                           struct gl_transform_feedback_object *obj)
 252 {
 253    GLuint i;
 254
 255    for (i = 0; i < Elements(obj->Buffers); i++) {
 256       _mesa_reference_buffer_object(ctx, &obj->Buffers[i], NULL);
 257    }
 258
 259    free(obj);
 260 }
 261
 262
 263 #if FEATURE_EXT_transform_feedback
 264
 265
 266 /** Default fallback for ctx->Driver.BeginTransformFeedback() */
 267 static void
 268 begin_transform_feedback(struct gl_context *ctx, GLenum mode,
 269                          struct gl_transform_feedback_object *obj)
 270 {
 271    /* nop */
 272 }
 273
 274 /** Default fallback for ctx->Driver.EndTransformFeedback() */
 275 static void
 276 end_transform_feedback(struct gl_context *ctx,
 277                        struct gl_transform_feedback_object *obj)
 278 {
 279    /* nop */
 280 }
 281
 282 /** Default fallback for ctx->Driver.PauseTransformFeedback() */
 283 static void
 284 pause_transform_feedback(struct gl_context *ctx,
 285                          struct gl_transform_feedback_object *obj)
 286 {
 287    /* nop */
 288 }
 289
 290 /** Default fallback for ctx->Driver.ResumeTransformFeedback() */
 291 static void
 292 resume_transform_feedback(struct gl_context *ctx,
 293                           struct gl_transform_feedback_object *obj)
 294 {
 295    /* nop */
 296 }
 297
 298
 299 /**
 300  * Plug in default device driver functions for transform feedback.
 301  * Most drivers will override some/all of these.
 302  */
 303 void
 304 _mesa_init_transform_feedback_functions(struct dd_function_table *driver)
 305 {
 306    driver->NewTransformFeedback = new_transform_feedback;
 307    driver->DeleteTransformFeedback = delete_transform_feedback;
 308    driver->BeginTransformFeedback = begin_transform_feedback;
 309    driver->EndTransformFeedback = end_transform_feedback;
 310    driver->PauseTransformFeedback = pause_transform_feedback;
 311    driver->ResumeTransformFeedback = resume_transform_feedback;
 312 }
 313
 314
 315 void
 316 _mesa_init_transform_feedback_dispatch(struct _glapi_table *disp)
 317 {
 318    /* EXT_transform_feedback */
 319    SET_BeginTransformFeedbackEXT(disp, _mesa_BeginTransformFeedback);
 320    SET_EndTransformFeedbackEXT(disp, _mesa_EndTransformFeedback);
 321    SET_BindBufferRangeEXT(disp, _mesa_BindBufferRange);
 322    SET_BindBufferBaseEXT(disp, _mesa_BindBufferBase);
 323    SET_BindBufferOffsetEXT(disp, _mesa_BindBufferOffsetEXT);
 324    SET_TransformFeedbackVaryingsEXT(disp, _mesa_TransformFeedbackVaryings);
 325    SET_GetTransformFeedbackVaryingEXT(disp, _mesa_GetTransformFeedbackVarying);
 326    /* ARB_transform_feedback2 */
 327    SET_BindTransformFeedback(disp, _mesa_BindTransformFeedback);
 328    SET_DeleteTransformFeedbacks(disp, _mesa_DeleteTransformFeedbacks);
 329    SET_GenTransformFeedbacks(disp, _mesa_GenTransformFeedbacks);
 330    SET_IsTransformFeedback(disp, _mesa_IsTransformFeedback);
 331    SET_PauseTransformFeedback(disp, _mesa_PauseTransformFeedback);
 332    SET_ResumeTransformFeedback(disp, _mesa_ResumeTransformFeedback);
 333 }
 334
 335
 336 /**
 337  ** Begin API functions
 338  **/
 339
 340
 341 void GLAPIENTRY
 342 _mesa_BeginTransformFeedback(GLenum mode)
 343 {
 344    struct gl_transform_feedback_object *obj;
 345    struct gl_transform_feedback_info *info;
 346    int i;
 347    GET_CURRENT_CONTEXT(ctx);
 348
 349    obj = ctx->TransformFeedback.CurrentObject;
 350    info = &ctx->Shader.CurrentVertexProgram->LinkedTransformFeedback;
 351
 352    switch (mode) {
 353    case GL_POINTS:
 354    case GL_LINES:
 355    case GL_TRIANGLES:
 356       /* legal */
 357       break;
 358    default:
 359       _mesa_error(ctx, GL_INVALID_ENUM, "glBeginTransformFeedback(mode)");
 360       return;
 361    }
 362
 363    if (obj->Active) {
 364       _mesa_error(ctx, GL_INVALID_OPERATION,
 365                   "glBeginTransformFeedback(already active)");
 366       return;
 367    }
 368
 369    for (i = 0; i < info->NumBuffers; ++i) {
 370       if (obj->BufferNames[i] == 0) {
 371          _mesa_error(ctx, GL_INVALID_OPERATION,
 372                      "glBeginTransformFeedback(binding point %d does not have "
 373                      "a buffer object bound)", i);
 374          return;
 375       }
 376    }
 377
 378    FLUSH_VERTICES(ctx, _NEW_TRANSFORM_FEEDBACK);
 379    obj->Active = GL_TRUE;
 380    ctx->TransformFeedback.Mode = mode;
 381
 382    assert(ctx->Driver.BeginTransformFeedback);
 383    ctx->Driver.BeginTransformFeedback(ctx, mode, obj);
 384 }
 385
 386
 387 void GLAPIENTRY
 388 _mesa_EndTransformFeedback(void)
 389 {
 390    struct gl_transform_feedback_object *obj;
 391    GET_CURRENT_CONTEXT(ctx);
 392
 393    obj = ctx->TransformFeedback.CurrentObject;
 394
 395    if (!obj->Active) {
 396       _mesa_error(ctx, GL_INVALID_OPERATION,
 397                   "glEndTransformFeedback(not active)");
 398       return;
 399    }
 400
 401    FLUSH_VERTICES(ctx, _NEW_TRANSFORM_FEEDBACK);
 402    ctx->TransformFeedback.CurrentObject->Active = GL_FALSE;
 403    ctx->TransformFeedback.CurrentObject->Paused = GL_FALSE;
 404    ctx->TransformFeedback.CurrentObject->EndedAnytime = GL_TRUE;
 405
 406    assert(ctx->Driver.EndTransformFeedback);
 407    ctx->Driver.EndTransformFeedback(ctx, obj);
 408 }
 409
 410
 411 /**
 412  * Helper used by BindBufferRange() and BindBufferBase().
 413  */
 414 static void
 415 bind_buffer_range(struct gl_context *ctx, GLuint index,
 416                   struct gl_buffer_object *bufObj,
 417                   GLintptr offset, GLsizeiptr size)
 418 {
 419    struct gl_transform_feedback_object *obj =
 420       ctx->TransformFeedback.CurrentObject;
 421
 422    /* Note: no need to FLUSH_VERTICES or flag _NEW_TRANSFORM_FEEDBACK, because
 423     * transform feedback buffers can't be changed while transform feedback is
 424     * active.
 425     */
 426
 427    /* The general binding point */
 428    _mesa_reference_buffer_object(ctx,
 429                                  &ctx->TransformFeedback.CurrentBuffer,
 430                                  bufObj);
 431
 432    /* The per-attribute binding point */
 433    _mesa_reference_buffer_object(ctx,
 434                                  &obj->Buffers[index],
 435                                  bufObj);
 436
 437    obj->BufferNames[index] = bufObj->Name;
 438
 439    obj->Offset[index] = offset;
 440    obj->Size[index] = size;
 441 }
 442
 443
 444 /**
 445  * Specify a buffer object to receive vertex shader results.  Plus,
 446  * specify the starting offset to place the results, and max size.
 447  */
 448 void GLAPIENTRY
 449 _mesa_BindBufferRange(GLenum target, GLuint index,
 450                       GLuint buffer, GLintptr offset, GLsizeiptr size)
 451 {
 452    struct gl_transform_feedback_object *obj;
 453    struct gl_buffer_object *bufObj;
 454    GET_CURRENT_CONTEXT(ctx);
 455
 456    if (target != GL_TRANSFORM_FEEDBACK_BUFFER) {
 457       _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferRange(target)");
 458       return;
 459    }
 460
 461    obj = ctx->TransformFeedback.CurrentObject;
 462
 463    if (obj->Active) {
 464       _mesa_error(ctx, GL_INVALID_OPERATION,
 465                   "glBindBufferRange(transform feedback active)");
 466       return;
 467    }
 468
 469    if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs) {
 470       _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(index=%d)", index);
 471       return;
 472    }
 473
 474    if ((size <= 0) || (size & 0x3)) {
 475       /* must be positive and multiple of four */
 476       _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(size=%d)", (int) size);
 477       return;
 478    }
 479
 480    if (offset & 0x3) {
 481       /* must be multiple of four */
 482       _mesa_error(ctx, GL_INVALID_VALUE,
 483                   "glBindBufferRange(offset=%d)", (int) offset);
 484       return;
 485    }
 486
 487    bufObj = _mesa_lookup_bufferobj(ctx, buffer);
 488    if (!bufObj) {
 489       _mesa_error(ctx, GL_INVALID_OPERATION,
 490                   "glBindBufferRange(invalid buffer=%u)", buffer);
 491       return;
 492    }
 493
 494    if (offset + size > bufObj->Size) {
 495       _mesa_error(ctx, GL_INVALID_VALUE,
 496                   "glBindBufferRange(offset + size %d > buffer size %d)",
 497                   (int) (offset + size), (int) (bufObj->Size));
 498       return;
 499    }
 500
 501    bind_buffer_range(ctx, index, bufObj, offset, size);
 502 }
 503
 504
 505 /**
 506  * Specify a buffer object to receive vertex shader results.
 507  * As above, but start at offset = 0.
 508  */
 509 void GLAPIENTRY
 510 _mesa_BindBufferBase(GLenum target, GLuint index, GLuint buffer)
 511 {
 512    struct gl_transform_feedback_object *obj;
 513    struct gl_buffer_object *bufObj;
 514    GLsizeiptr size;
 515    GET_CURRENT_CONTEXT(ctx);
 516
 517    if (target != GL_TRANSFORM_FEEDBACK_BUFFER) {
 518       _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferBase(target)");
 519       return;
 520    }
 521
 522    obj = ctx->TransformFeedback.CurrentObject;
 523
 524    if (obj->Active) {
 525       _mesa_error(ctx, GL_INVALID_OPERATION,
 526                   "glBindBufferBase(transform feedback active)");
 527       return;
 528    }
 529
 530    if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs) {
 531       _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferBase(index=%d)", index);
 532       return;
 533    }
 534
 535    bufObj = _mesa_lookup_bufferobj(ctx, buffer);
 536    if (!bufObj) {
 537       _mesa_error(ctx, GL_INVALID_OPERATION,
 538                   "glBindBufferBase(invalid buffer=%u)", buffer);
 539       return;
 540    }
 541
 542    /* default size is the buffer size rounded down to nearest
 543     * multiple of four.
 544     */
 545    size = bufObj->Size & ~0x3;
 546
 547    bind_buffer_range(ctx, index, bufObj, 0, size);
 548 }
 549
 550
 551 /**
 552  * Specify a buffer object to receive vertex shader results, plus the
 553  * offset in the buffer to start placing results.
 554  * This function is part of GL_EXT_transform_feedback, but not GL3.
 555  */
 556 void GLAPIENTRY
 557 _mesa_BindBufferOffsetEXT(GLenum target, GLuint index, GLuint buffer,
 558                           GLintptr offset)
 559 {
 560    struct gl_transform_feedback_object *obj;
 561    struct gl_buffer_object *bufObj;
 562    GET_CURRENT_CONTEXT(ctx);
 563    GLsizeiptr size;
 564
 565    if (target != GL_TRANSFORM_FEEDBACK_BUFFER) {
 566       _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferOffsetEXT(target)");
 567       return;
 568    }
 569
 570    obj = ctx->TransformFeedback.CurrentObject;
 571
 572    if (obj->Active) {
 573       _mesa_error(ctx, GL_INVALID_OPERATION,
 574                   "glBindBufferOffsetEXT(transform feedback active)");
 575       return;
 576    }
 577
 578    if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs) {
 579       _mesa_error(ctx, GL_INVALID_VALUE,
 580                   "glBindBufferOffsetEXT(index=%d)", index);
 581       return;
 582    }
 583
 584    bufObj = _mesa_lookup_bufferobj(ctx, buffer);
 585    if (!bufObj) {
 586       _mesa_error(ctx, GL_INVALID_OPERATION,
 587                   "glBindBufferOffsetEXT(invalid buffer=%u)", buffer);
 588       return;
 589    }
 590
 591    /* default size is the buffer size rounded down to nearest
 592     * multiple of four.
 593     */
 594    size = (bufObj->Size - offset) & ~0x3;
 595
 596    bind_buffer_range(ctx, index, bufObj, offset, size);
 597 }
 598
 599
 600 /**
 601  * This function specifies the vertex shader outputs to be written
 602  * to the feedback buffer(s), and in what order.
 603  */
 604 void GLAPIENTRY
 605 _mesa_TransformFeedbackVaryings(GLuint program, GLsizei count,
 606                                 const GLchar **varyings, GLenum bufferMode)
 607 {
 608    struct gl_shader_program *shProg;
 609    GLuint i;
 610    GET_CURRENT_CONTEXT(ctx);
 611
 612    switch (bufferMode) {
 613    case GL_INTERLEAVED_ATTRIBS:
 614       break;
 615    case GL_SEPARATE_ATTRIBS:
 616       break;
 617    default:
 618       _mesa_error(ctx, GL_INVALID_ENUM,
 619                   "glTransformFeedbackVaryings(bufferMode)");
 620       return;
 621    }
 622
 623    if (count < 0 ||
 624        (bufferMode == GL_SEPARATE_ATTRIBS &&
 625         (GLuint) count > ctx->Const.MaxTransformFeedbackSeparateAttribs)) {
 626       _mesa_error(ctx, GL_INVALID_VALUE,
 627                   "glTransformFeedbackVaryings(count=%d)", count);
 628       return;
 629    }
 630
 631    shProg = _mesa_lookup_shader_program(ctx, program);
 632    if (!shProg) {
 633       _mesa_error(ctx, GL_INVALID_VALUE,
 634                   "glTransformFeedbackVaryings(program=%u)", program);
 635       return;
 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 GLchar *varyingName;
 678    GLint v;
 679    GET_CURRENT_CONTEXT(ctx);
 680
 681    shProg = _mesa_lookup_shader_program(ctx, program);
 682    if (!shProg) {
 683       _mesa_error(ctx, GL_INVALID_VALUE,
 684                   "glGetTransformFeedbackVaryings(program=%u)", program);
 685       return;
 686    }
 687
 688    if (index >= shProg->TransformFeedback.NumVarying) {
 689       _mesa_error(ctx, GL_INVALID_VALUE,
 690                   "glGetTransformFeedbackVaryings(index=%u)", index);
 691       return;
 692    }
 693
 694    varyingName = shProg->TransformFeedback.VaryingNames[index];
 695
 696    v = _mesa_lookup_parameter_index(shProg->Varying, -1, varyingName);
 697    if (v >= 0) {
 698       struct gl_program_parameter *param = &shProg->Varying->Parameters[v];
 699
 700       /* return the varying's name and length */
 701       _mesa_copy_string(name, bufSize, length, varyingName);
 702
 703       /* return the datatype and value's size (in datatype units) */
 704       if (type)
 705          *type = param->DataType;
 706       if (size)
 707          *size = param->Size;
 708    }
 709    else {
 710       name[0] = 0;
 711       if (length)
 712          *length = 0;
 713       if (type)
 714          *type = 0;
 715       if (size)
 716          *size = 0;
 717    }
 718 }
 719
 720
 721
 722 struct gl_transform_feedback_object *
 723 _mesa_lookup_transform_feedback_object(struct gl_context *ctx, GLuint name)
 724 {
 725    if (name == 0) {
 726       return ctx->TransformFeedback.DefaultObject;
 727    }
 728    else
 729       return (struct gl_transform_feedback_object *)
 730          _mesa_HashLookup(ctx->TransformFeedback.Objects, name);
 731 }
 732
 733
 734 /**
 735  * Create new transform feedback objects.   Transform feedback objects
 736  * encapsulate the state related to transform feedback to allow quickly
 737  * switching state (and drawing the results, below).
 738  * Part of GL_ARB_transform_feedback2.
 739  */
 740 void GLAPIENTRY
 741 _mesa_GenTransformFeedbacks(GLsizei n, GLuint *names)
 742 {
 743    GLuint first;
 744    GET_CURRENT_CONTEXT(ctx);
 745
 746    ASSERT_OUTSIDE_BEGIN_END(ctx);
 747
 748    if (n < 0) {
 749       _mesa_error(ctx, GL_INVALID_VALUE, "glGenTransformFeedbacks(n < 0)");
 750       return;
 751    }
 752
 753    if (!names)
 754       return;
 755
 756    /* we don't need contiguous IDs, but this might be faster */
 757    first = _mesa_HashFindFreeKeyBlock(ctx->TransformFeedback.Objects, n);
 758    if (first) {
 759       GLsizei i;
 760       for (i = 0; i < n; i++) {
 761          struct gl_transform_feedback_object *obj
 762             = ctx->Driver.NewTransformFeedback(ctx, first + i);
 763          if (!obj) {
 764             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenTransformFeedbacks");
 765             return;
 766          }
 767          names[i] = first + i;
 768          _mesa_HashInsert(ctx->TransformFeedback.Objects, first + i, obj);
 769       }
 770    }
 771    else {
 772       _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenTransformFeedbacks");
 773    }
 774 }
 775
 776
 777 /**
 778  * Is the given ID a transform feedback object?
 779  * Part of GL_ARB_transform_feedback2.
 780  */
 781 GLboolean GLAPIENTRY
 782 _mesa_IsTransformFeedback(GLuint name)
 783 {
 784    GET_CURRENT_CONTEXT(ctx);
 785
 786    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 787
 788    if (name && _mesa_lookup_transform_feedback_object(ctx, name))
 789       return GL_TRUE;
 790    else
 791       return GL_FALSE;
 792 }
 793
 794
 795 /**
 796  * Bind the given transform feedback object.
 797  * Part of GL_ARB_transform_feedback2.
 798  */
 799 void GLAPIENTRY
 800 _mesa_BindTransformFeedback(GLenum target, GLuint name)
 801 {
 802    struct gl_transform_feedback_object *obj;
 803    GET_CURRENT_CONTEXT(ctx);
 804
 805    if (target != GL_TRANSFORM_FEEDBACK) {
 806       _mesa_error(ctx, GL_INVALID_ENUM, "glBindTransformFeedback(target)");
 807       return;
 808    }
 809
 810    if (ctx->TransformFeedback.CurrentObject->Active &&
 811        !ctx->TransformFeedback.CurrentObject->Paused) {
 812       _mesa_error(ctx, GL_INVALID_OPERATION,
 813               "glBindTransformFeedback(transform is active, or not paused)");
 814       return;
 815    }
 816
 817    obj = _mesa_lookup_transform_feedback_object(ctx, name);
 818    if (!obj) {
 819       _mesa_error(ctx, GL_INVALID_OPERATION,
 820                   "glBindTransformFeedback(name=%u)", name);
 821       return;
 822    }
 823
 824    reference_transform_feedback_object(&ctx->TransformFeedback.CurrentObject,
 825                                        obj);
 826 }
 827
 828
 829 /**
 830  * Delete the given transform feedback objects.
 831  * Part of GL_ARB_transform_feedback2.
 832  */
 833 void GLAPIENTRY
 834 _mesa_DeleteTransformFeedbacks(GLsizei n, const GLuint *names)
 835 {
 836    GLint i;
 837    GET_CURRENT_CONTEXT(ctx);
 838
 839    ASSERT_OUTSIDE_BEGIN_END(ctx);
 840
 841    if (n < 0) {
 842       _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteTransformFeedbacks(n < 0)");
 843       return;
 844    }
 845
 846    if (!names)
 847       return;
 848
 849    for (i = 0; i < n; i++) {
 850       if (names[i] > 0) {
 851          struct gl_transform_feedback_object *obj
 852             = _mesa_lookup_transform_feedback_object(ctx, names[i]);
 853          if (obj) {
 854             if (obj->Active) {
 855                _mesa_error(ctx, GL_INVALID_OPERATION,
 856                            "glDeleteTransformFeedbacks(object %u is active)",
 857                            names[i]);
 858                return;
 859             }
 860             _mesa_HashRemove(ctx->TransformFeedback.Objects, names[i]);
 861             /* unref, but object may not be deleted until later */
 862             reference_transform_feedback_object(&obj, NULL);
 863          }
 864       }
 865    }
 866 }
 867
 868
 869 /**
 870  * Pause transform feedback.
 871  * Part of GL_ARB_transform_feedback2.
 872  */
 873 void GLAPIENTRY
 874 _mesa_PauseTransformFeedback(void)
 875 {
 876    struct gl_transform_feedback_object *obj;
 877    GET_CURRENT_CONTEXT(ctx);
 878
 879    obj = ctx->TransformFeedback.CurrentObject;
 880
 881    if (!obj->Active || obj->Paused) {
 882       _mesa_error(ctx, GL_INVALID_OPERATION,
 883            "glPauseTransformFeedback(feedback not active or already paused)");
 884       return;
 885    }
 886
 887    FLUSH_VERTICES(ctx, _NEW_TRANSFORM_FEEDBACK);
 888    obj->Paused = GL_TRUE;
 889
 890    assert(ctx->Driver.PauseTransformFeedback);
 891    ctx->Driver.PauseTransformFeedback(ctx, obj);
 892 }
 893
 894
 895 /**
 896  * Resume transform feedback.
 897  * Part of GL_ARB_transform_feedback2.
 898  */
 899 void GLAPIENTRY
 900 _mesa_ResumeTransformFeedback(void)
 901 {
 902    struct gl_transform_feedback_object *obj;
 903    GET_CURRENT_CONTEXT(ctx);
 904
 905    obj = ctx->TransformFeedback.CurrentObject;
 906
 907    if (!obj->Active || !obj->Paused) {
 908       _mesa_error(ctx, GL_INVALID_OPERATION,
 909                "glResumeTransformFeedback(feedback not active or not paused)");
 910       return;
 911    }
 912
 913    FLUSH_VERTICES(ctx, _NEW_TRANSFORM_FEEDBACK);
 914    obj->Paused = GL_FALSE;
 915
 916    assert(ctx->Driver.ResumeTransformFeedback);
 917    ctx->Driver.ResumeTransformFeedback(ctx, obj);
 918 }
 919
 920 #endif /* FEATURE_EXT_transform_feedback */