2 * Mesa 3-D graphics library
4 * Copyright (C) 2010 VMware, Inc. All Rights Reserved.
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:
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
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.
26 * Vertex transform feedback support.
34 #include "bufferobj.h"
37 #include "mfeatures.h"
39 #include "transformfeedback.h"
40 #include "shaderapi.h"
41 #include "shaderobj.h"
42 #include "main/dispatch.h"
44 #include "program/prog_parameter.h"
47 #if FEATURE_EXT_transform_feedback
51 * Do reference counting of transform feedback buffers.
54 reference_transform_feedback_object(struct gl_transform_feedback_object **ptr,
55 struct gl_transform_feedback_object *obj)
61 /* Unreference the old object */
62 struct gl_transform_feedback_object *oldObj = *ptr;
64 ASSERT(oldObj->RefCount > 0);
67 if (oldObj->RefCount == 0) {
68 GET_CURRENT_CONTEXT(ctx);
70 ctx->Driver.DeleteTransformFeedback(ctx, oldObj);
78 /* reference new object */
79 if (obj->RefCount == 0) {
80 _mesa_problem(NULL, "referencing deleted transform feedback object");
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.
96 * \return GL_TRUE if the mode is OK, GL_FALSE otherwise.
99 _mesa_validate_primitive_mode(struct gl_context *ctx, GLenum mode)
101 if (ctx->TransformFeedback.CurrentObject->Active &&
102 !ctx->TransformFeedback.CurrentObject->Paused) {
105 return ctx->TransformFeedback.Mode == GL_POINTS;
109 return ctx->TransformFeedback.Mode == GL_LINES;
111 return ctx->TransformFeedback.Mode == GL_TRIANGLES;
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
125 _mesa_validate_transform_feedback_buffers(struct gl_context *ctx)
134 * Per-context init for transform feedback.
137 _mesa_init_transform_feedback(struct gl_context *ctx)
139 /* core mesa expects this, even a dummy one, to be available */
140 ASSERT(ctx->Driver.NewTransformFeedback);
142 ctx->TransformFeedback.DefaultObject =
143 ctx->Driver.NewTransformFeedback(ctx, 0);
145 assert(ctx->TransformFeedback.DefaultObject->RefCount == 1);
147 reference_transform_feedback_object(&ctx->TransformFeedback.CurrentObject,
148 ctx->TransformFeedback.DefaultObject);
150 assert(ctx->TransformFeedback.DefaultObject->RefCount == 2);
152 ctx->TransformFeedback.Objects = _mesa_NewHashTable();
154 _mesa_reference_buffer_object(ctx,
155 &ctx->TransformFeedback.CurrentBuffer,
156 ctx->Shared->NullBufferObj);
162 * Callback for _mesa_HashDeleteAll().
165 delete_cb(GLuint key, void *data, void *userData)
167 struct gl_context *ctx = (struct gl_context *) userData;
168 struct gl_transform_feedback_object *obj =
169 (struct gl_transform_feedback_object *) data;
171 ctx->Driver.DeleteTransformFeedback(ctx, obj);
176 * Per-context free/clean-up for transform feedback.
179 _mesa_free_transform_feedback(struct gl_context *ctx)
181 /* core mesa expects this, even a dummy one, to be available */
182 ASSERT(ctx->Driver.NewTransformFeedback);
184 _mesa_reference_buffer_object(ctx,
185 &ctx->TransformFeedback.CurrentBuffer,
188 /* Delete all feedback objects */
189 _mesa_HashDeleteAll(ctx->TransformFeedback.Objects, delete_cb, ctx);
190 _mesa_DeleteHashTable(ctx->TransformFeedback.Objects);
192 /* Delete the default feedback object */
193 assert(ctx->Driver.DeleteTransformFeedback);
194 ctx->Driver.DeleteTransformFeedback(ctx,
195 ctx->TransformFeedback.DefaultObject);
197 ctx->TransformFeedback.CurrentObject = NULL;
201 #else /* FEATURE_EXT_transform_feedback */
203 /* forward declarations */
204 static struct gl_transform_feedback_object *
205 new_transform_feedback(struct gl_context *ctx, GLuint name);
208 delete_transform_feedback(struct gl_context *ctx,
209 struct gl_transform_feedback_object *obj);
211 /* dummy per-context init/clean-up for transform feedback */
213 _mesa_init_transform_feedback(struct gl_context *ctx)
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);
223 _mesa_free_transform_feedback(struct gl_context *ctx)
225 _mesa_reference_buffer_object(ctx,
226 &ctx->TransformFeedback.CurrentBuffer,
228 ctx->TransformFeedback.CurrentObject = NULL;
229 delete_transform_feedback(ctx, ctx->TransformFeedback.DefaultObject);
232 #endif /* FEATURE_EXT_transform_feedback */
235 /** Default fallback for ctx->Driver.NewTransformFeedback() */
236 static struct gl_transform_feedback_object *
237 new_transform_feedback(struct gl_context *ctx, GLuint name)
239 struct gl_transform_feedback_object *obj;
240 obj = CALLOC_STRUCT(gl_transform_feedback_object);
248 /** Default fallback for ctx->Driver.DeleteTransformFeedback() */
250 delete_transform_feedback(struct gl_context *ctx,
251 struct gl_transform_feedback_object *obj)
255 for (i = 0; i < Elements(obj->Buffers); i++) {
256 _mesa_reference_buffer_object(ctx, &obj->Buffers[i], NULL);
263 #if FEATURE_EXT_transform_feedback
266 /** Default fallback for ctx->Driver.BeginTransformFeedback() */
268 begin_transform_feedback(struct gl_context *ctx, GLenum mode,
269 struct gl_transform_feedback_object *obj)
274 /** Default fallback for ctx->Driver.EndTransformFeedback() */
276 end_transform_feedback(struct gl_context *ctx,
277 struct gl_transform_feedback_object *obj)
282 /** Default fallback for ctx->Driver.PauseTransformFeedback() */
284 pause_transform_feedback(struct gl_context *ctx,
285 struct gl_transform_feedback_object *obj)
290 /** Default fallback for ctx->Driver.ResumeTransformFeedback() */
292 resume_transform_feedback(struct gl_context *ctx,
293 struct gl_transform_feedback_object *obj)
300 * Plug in default device driver functions for transform feedback.
301 * Most drivers will override some/all of these.
304 _mesa_init_transform_feedback_functions(struct dd_function_table *driver)
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;
316 _mesa_init_transform_feedback_dispatch(struct _glapi_table *disp)
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);
337 ** Begin API functions
342 _mesa_BeginTransformFeedback(GLenum mode)
344 struct gl_transform_feedback_object *obj;
345 struct gl_transform_feedback_info *info;
347 GET_CURRENT_CONTEXT(ctx);
349 obj = ctx->TransformFeedback.CurrentObject;
351 if (ctx->Shader.CurrentVertexProgram == NULL) {
352 _mesa_error(ctx, GL_INVALID_OPERATION,
353 "glBeginTransformFeedback(no program active)");
357 info = &ctx->Shader.CurrentVertexProgram->LinkedTransformFeedback;
359 if (info->NumOutputs == 0) {
360 _mesa_error(ctx, GL_INVALID_OPERATION,
361 "glBeginTransformFeedback(no varyings to record)");
372 _mesa_error(ctx, GL_INVALID_ENUM, "glBeginTransformFeedback(mode)");
377 _mesa_error(ctx, GL_INVALID_OPERATION,
378 "glBeginTransformFeedback(already active)");
382 for (i = 0; i < info->NumBuffers; ++i) {
383 if (obj->BufferNames[i] == 0) {
384 _mesa_error(ctx, GL_INVALID_OPERATION,
385 "glBeginTransformFeedback(binding point %d does not have "
386 "a buffer object bound)", i);
391 FLUSH_VERTICES(ctx, _NEW_TRANSFORM_FEEDBACK);
392 obj->Active = GL_TRUE;
393 ctx->TransformFeedback.Mode = mode;
395 assert(ctx->Driver.BeginTransformFeedback);
396 ctx->Driver.BeginTransformFeedback(ctx, mode, obj);
401 _mesa_EndTransformFeedback(void)
403 struct gl_transform_feedback_object *obj;
404 GET_CURRENT_CONTEXT(ctx);
406 obj = ctx->TransformFeedback.CurrentObject;
409 _mesa_error(ctx, GL_INVALID_OPERATION,
410 "glEndTransformFeedback(not active)");
414 FLUSH_VERTICES(ctx, _NEW_TRANSFORM_FEEDBACK);
415 ctx->TransformFeedback.CurrentObject->Active = GL_FALSE;
416 ctx->TransformFeedback.CurrentObject->Paused = GL_FALSE;
417 ctx->TransformFeedback.CurrentObject->EndedAnytime = GL_TRUE;
419 assert(ctx->Driver.EndTransformFeedback);
420 ctx->Driver.EndTransformFeedback(ctx, obj);
425 * Helper used by BindBufferRange() and BindBufferBase().
428 bind_buffer_range(struct gl_context *ctx, GLuint index,
429 struct gl_buffer_object *bufObj,
430 GLintptr offset, GLsizeiptr size)
432 struct gl_transform_feedback_object *obj =
433 ctx->TransformFeedback.CurrentObject;
435 /* Note: no need to FLUSH_VERTICES or flag _NEW_TRANSFORM_FEEDBACK, because
436 * transform feedback buffers can't be changed while transform feedback is
440 /* The general binding point */
441 _mesa_reference_buffer_object(ctx,
442 &ctx->TransformFeedback.CurrentBuffer,
445 /* The per-attribute binding point */
446 _mesa_reference_buffer_object(ctx,
447 &obj->Buffers[index],
450 obj->BufferNames[index] = bufObj->Name;
452 obj->Offset[index] = offset;
453 obj->Size[index] = size;
458 * Specify a buffer object to receive vertex shader results. Plus,
459 * specify the starting offset to place the results, and max size.
462 _mesa_BindBufferRange(GLenum target, GLuint index,
463 GLuint buffer, GLintptr offset, GLsizeiptr size)
465 struct gl_transform_feedback_object *obj;
466 struct gl_buffer_object *bufObj;
467 GET_CURRENT_CONTEXT(ctx);
469 if (target != GL_TRANSFORM_FEEDBACK_BUFFER) {
470 _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferRange(target)");
474 obj = ctx->TransformFeedback.CurrentObject;
477 _mesa_error(ctx, GL_INVALID_OPERATION,
478 "glBindBufferRange(transform feedback active)");
482 if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs) {
483 _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(index=%d)", index);
487 if ((size <= 0) || (size & 0x3)) {
488 /* must be positive and multiple of four */
489 _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferRange(size=%d)", (int) size);
494 /* must be multiple of four */
495 _mesa_error(ctx, GL_INVALID_VALUE,
496 "glBindBufferRange(offset=%d)", (int) offset);
500 bufObj = _mesa_lookup_bufferobj(ctx, buffer);
502 _mesa_error(ctx, GL_INVALID_OPERATION,
503 "glBindBufferRange(invalid buffer=%u)", buffer);
507 if (offset + size > bufObj->Size) {
508 _mesa_error(ctx, GL_INVALID_VALUE,
509 "glBindBufferRange(offset + size %d > buffer size %d)",
510 (int) (offset + size), (int) (bufObj->Size));
514 bind_buffer_range(ctx, index, bufObj, offset, size);
519 * Specify a buffer object to receive vertex shader results.
520 * As above, but start at offset = 0.
523 _mesa_BindBufferBase(GLenum target, GLuint index, GLuint buffer)
525 struct gl_transform_feedback_object *obj;
526 struct gl_buffer_object *bufObj;
528 GET_CURRENT_CONTEXT(ctx);
530 if (target != GL_TRANSFORM_FEEDBACK_BUFFER) {
531 _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferBase(target)");
535 obj = ctx->TransformFeedback.CurrentObject;
538 _mesa_error(ctx, GL_INVALID_OPERATION,
539 "glBindBufferBase(transform feedback active)");
543 if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs) {
544 _mesa_error(ctx, GL_INVALID_VALUE, "glBindBufferBase(index=%d)", index);
548 bufObj = _mesa_lookup_bufferobj(ctx, buffer);
550 _mesa_error(ctx, GL_INVALID_OPERATION,
551 "glBindBufferBase(invalid buffer=%u)", buffer);
555 /* default size is the buffer size rounded down to nearest
558 size = bufObj->Size & ~0x3;
560 bind_buffer_range(ctx, index, bufObj, 0, size);
565 * Specify a buffer object to receive vertex shader results, plus the
566 * offset in the buffer to start placing results.
567 * This function is part of GL_EXT_transform_feedback, but not GL3.
570 _mesa_BindBufferOffsetEXT(GLenum target, GLuint index, GLuint buffer,
573 struct gl_transform_feedback_object *obj;
574 struct gl_buffer_object *bufObj;
575 GET_CURRENT_CONTEXT(ctx);
578 if (target != GL_TRANSFORM_FEEDBACK_BUFFER) {
579 _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferOffsetEXT(target)");
583 obj = ctx->TransformFeedback.CurrentObject;
586 _mesa_error(ctx, GL_INVALID_OPERATION,
587 "glBindBufferOffsetEXT(transform feedback active)");
591 if (index >= ctx->Const.MaxTransformFeedbackSeparateAttribs) {
592 _mesa_error(ctx, GL_INVALID_VALUE,
593 "glBindBufferOffsetEXT(index=%d)", index);
598 /* must be multiple of four */
599 _mesa_error(ctx, GL_INVALID_VALUE,
600 "glBindBufferOffsetEXT(offset=%d)", (int) offset);
604 bufObj = _mesa_lookup_bufferobj(ctx, buffer);
606 _mesa_error(ctx, GL_INVALID_OPERATION,
607 "glBindBufferOffsetEXT(invalid buffer=%u)", buffer);
611 /* default size is the buffer size rounded down to nearest
614 size = (bufObj->Size - offset) & ~0x3;
616 bind_buffer_range(ctx, index, bufObj, offset, size);
621 * This function specifies the vertex shader outputs to be written
622 * to the feedback buffer(s), and in what order.
625 _mesa_TransformFeedbackVaryings(GLuint program, GLsizei count,
626 const GLchar **varyings, GLenum bufferMode)
628 struct gl_shader_program *shProg;
630 GET_CURRENT_CONTEXT(ctx);
632 switch (bufferMode) {
633 case GL_INTERLEAVED_ATTRIBS:
635 case GL_SEPARATE_ATTRIBS:
638 _mesa_error(ctx, GL_INVALID_ENUM,
639 "glTransformFeedbackVaryings(bufferMode)");
644 (bufferMode == GL_SEPARATE_ATTRIBS &&
645 (GLuint) count > ctx->Const.MaxTransformFeedbackSeparateAttribs)) {
646 _mesa_error(ctx, GL_INVALID_VALUE,
647 "glTransformFeedbackVaryings(count=%d)", count);
651 shProg = _mesa_lookup_shader_program(ctx, program);
653 _mesa_error(ctx, GL_INVALID_VALUE,
654 "glTransformFeedbackVaryings(program=%u)", program);
658 /* free existing varyings, if any */
659 for (i = 0; i < shProg->TransformFeedback.NumVarying; i++) {
660 free(shProg->TransformFeedback.VaryingNames[i]);
662 free(shProg->TransformFeedback.VaryingNames);
664 /* allocate new memory for varying names */
665 shProg->TransformFeedback.VaryingNames =
666 (GLchar **) malloc(count * sizeof(GLchar *));
668 if (!shProg->TransformFeedback.VaryingNames) {
669 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glTransformFeedbackVaryings()");
673 /* Save the new names and the count */
674 for (i = 0; i < (GLuint) count; i++) {
675 shProg->TransformFeedback.VaryingNames[i] = _mesa_strdup(varyings[i]);
677 shProg->TransformFeedback.NumVarying = count;
679 shProg->TransformFeedback.BufferMode = bufferMode;
681 /* No need to set _NEW_TRANSFORM_FEEDBACK (or invoke FLUSH_VERTICES) since
682 * the varyings won't be used until shader link time.
688 * Get info about the vertex shader's outputs which are to be written
689 * to the feedback buffer(s).
692 _mesa_GetTransformFeedbackVarying(GLuint program, GLuint index,
693 GLsizei bufSize, GLsizei *length,
694 GLsizei *size, GLenum *type, GLchar *name)
696 const struct gl_shader_program *shProg;
697 const struct gl_transform_feedback_info *linked_xfb_info;
698 GET_CURRENT_CONTEXT(ctx);
700 shProg = _mesa_lookup_shader_program(ctx, program);
702 _mesa_error(ctx, GL_INVALID_VALUE,
703 "glGetTransformFeedbackVaryings(program=%u)", program);
707 linked_xfb_info = &shProg->LinkedTransformFeedback;
708 if (index >= linked_xfb_info->NumVarying) {
709 _mesa_error(ctx, GL_INVALID_VALUE,
710 "glGetTransformFeedbackVaryings(index=%u)", index);
714 /* return the varying's name and length */
715 _mesa_copy_string(name, bufSize, length,
716 linked_xfb_info->Varyings[index].Name);
718 /* return the datatype and value's size (in datatype units) */
720 *type = linked_xfb_info->Varyings[index].Type;
722 *size = linked_xfb_info->Varyings[index].Size;
727 struct gl_transform_feedback_object *
728 _mesa_lookup_transform_feedback_object(struct gl_context *ctx, GLuint name)
731 return ctx->TransformFeedback.DefaultObject;
734 return (struct gl_transform_feedback_object *)
735 _mesa_HashLookup(ctx->TransformFeedback.Objects, name);
740 * Create new transform feedback objects. Transform feedback objects
741 * encapsulate the state related to transform feedback to allow quickly
742 * switching state (and drawing the results, below).
743 * Part of GL_ARB_transform_feedback2.
746 _mesa_GenTransformFeedbacks(GLsizei n, GLuint *names)
749 GET_CURRENT_CONTEXT(ctx);
751 ASSERT_OUTSIDE_BEGIN_END(ctx);
754 _mesa_error(ctx, GL_INVALID_VALUE, "glGenTransformFeedbacks(n < 0)");
761 /* we don't need contiguous IDs, but this might be faster */
762 first = _mesa_HashFindFreeKeyBlock(ctx->TransformFeedback.Objects, n);
765 for (i = 0; i < n; i++) {
766 struct gl_transform_feedback_object *obj
767 = ctx->Driver.NewTransformFeedback(ctx, first + i);
769 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenTransformFeedbacks");
772 names[i] = first + i;
773 _mesa_HashInsert(ctx->TransformFeedback.Objects, first + i, obj);
777 _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenTransformFeedbacks");
783 * Is the given ID a transform feedback object?
784 * Part of GL_ARB_transform_feedback2.
787 _mesa_IsTransformFeedback(GLuint name)
789 GET_CURRENT_CONTEXT(ctx);
791 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
793 if (name && _mesa_lookup_transform_feedback_object(ctx, name))
801 * Bind the given transform feedback object.
802 * Part of GL_ARB_transform_feedback2.
805 _mesa_BindTransformFeedback(GLenum target, GLuint name)
807 struct gl_transform_feedback_object *obj;
808 GET_CURRENT_CONTEXT(ctx);
810 if (target != GL_TRANSFORM_FEEDBACK) {
811 _mesa_error(ctx, GL_INVALID_ENUM, "glBindTransformFeedback(target)");
815 if (ctx->TransformFeedback.CurrentObject->Active &&
816 !ctx->TransformFeedback.CurrentObject->Paused) {
817 _mesa_error(ctx, GL_INVALID_OPERATION,
818 "glBindTransformFeedback(transform is active, or not paused)");
822 obj = _mesa_lookup_transform_feedback_object(ctx, name);
824 _mesa_error(ctx, GL_INVALID_OPERATION,
825 "glBindTransformFeedback(name=%u)", name);
829 reference_transform_feedback_object(&ctx->TransformFeedback.CurrentObject,
835 * Delete the given transform feedback objects.
836 * Part of GL_ARB_transform_feedback2.
839 _mesa_DeleteTransformFeedbacks(GLsizei n, const GLuint *names)
842 GET_CURRENT_CONTEXT(ctx);
844 ASSERT_OUTSIDE_BEGIN_END(ctx);
847 _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteTransformFeedbacks(n < 0)");
854 for (i = 0; i < n; i++) {
856 struct gl_transform_feedback_object *obj
857 = _mesa_lookup_transform_feedback_object(ctx, names[i]);
860 _mesa_error(ctx, GL_INVALID_OPERATION,
861 "glDeleteTransformFeedbacks(object %u is active)",
865 _mesa_HashRemove(ctx->TransformFeedback.Objects, names[i]);
866 /* unref, but object may not be deleted until later */
867 reference_transform_feedback_object(&obj, NULL);
875 * Pause transform feedback.
876 * Part of GL_ARB_transform_feedback2.
879 _mesa_PauseTransformFeedback(void)
881 struct gl_transform_feedback_object *obj;
882 GET_CURRENT_CONTEXT(ctx);
884 obj = ctx->TransformFeedback.CurrentObject;
886 if (!obj->Active || obj->Paused) {
887 _mesa_error(ctx, GL_INVALID_OPERATION,
888 "glPauseTransformFeedback(feedback not active or already paused)");
892 FLUSH_VERTICES(ctx, _NEW_TRANSFORM_FEEDBACK);
893 obj->Paused = GL_TRUE;
895 assert(ctx->Driver.PauseTransformFeedback);
896 ctx->Driver.PauseTransformFeedback(ctx, obj);
901 * Resume transform feedback.
902 * Part of GL_ARB_transform_feedback2.
905 _mesa_ResumeTransformFeedback(void)
907 struct gl_transform_feedback_object *obj;
908 GET_CURRENT_CONTEXT(ctx);
910 obj = ctx->TransformFeedback.CurrentObject;
912 if (!obj->Active || !obj->Paused) {
913 _mesa_error(ctx, GL_INVALID_OPERATION,
914 "glResumeTransformFeedback(feedback not active or not paused)");
918 FLUSH_VERTICES(ctx, _NEW_TRANSFORM_FEEDBACK);
919 obj->Paused = GL_FALSE;
921 assert(ctx->Driver.ResumeTransformFeedback);
922 ctx->Driver.ResumeTransformFeedback(ctx, obj);
925 #endif /* FEATURE_EXT_transform_feedback */