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
;
350 info
= &ctx
->Shader
.CurrentVertexProgram
->LinkedTransformFeedback
;
359 _mesa_error(ctx
, GL_INVALID_ENUM
, "glBeginTransformFeedback(mode)");
364 _mesa_error(ctx
, GL_INVALID_OPERATION
,
365 "glBeginTransformFeedback(already active)");
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
);
378 FLUSH_VERTICES(ctx
, _NEW_TRANSFORM_FEEDBACK
);
379 obj
->Active
= GL_TRUE
;
380 ctx
->TransformFeedback
.Mode
= mode
;
382 assert(ctx
->Driver
.BeginTransformFeedback
);
383 ctx
->Driver
.BeginTransformFeedback(ctx
, mode
, obj
);
388 _mesa_EndTransformFeedback(void)
390 struct gl_transform_feedback_object
*obj
;
391 GET_CURRENT_CONTEXT(ctx
);
393 obj
= ctx
->TransformFeedback
.CurrentObject
;
396 _mesa_error(ctx
, GL_INVALID_OPERATION
,
397 "glEndTransformFeedback(not active)");
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
;
406 assert(ctx
->Driver
.EndTransformFeedback
);
407 ctx
->Driver
.EndTransformFeedback(ctx
, obj
);
412 * Helper used by BindBufferRange() and BindBufferBase().
415 bind_buffer_range(struct gl_context
*ctx
, GLuint index
,
416 struct gl_buffer_object
*bufObj
,
417 GLintptr offset
, GLsizeiptr size
)
419 struct gl_transform_feedback_object
*obj
=
420 ctx
->TransformFeedback
.CurrentObject
;
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
427 /* The general binding point */
428 _mesa_reference_buffer_object(ctx
,
429 &ctx
->TransformFeedback
.CurrentBuffer
,
432 /* The per-attribute binding point */
433 _mesa_reference_buffer_object(ctx
,
434 &obj
->Buffers
[index
],
437 obj
->BufferNames
[index
] = bufObj
->Name
;
439 obj
->Offset
[index
] = offset
;
440 obj
->Size
[index
] = size
;
445 * Specify a buffer object to receive vertex shader results. Plus,
446 * specify the starting offset to place the results, and max size.
449 _mesa_BindBufferRange(GLenum target
, GLuint index
,
450 GLuint buffer
, GLintptr offset
, GLsizeiptr size
)
452 struct gl_transform_feedback_object
*obj
;
453 struct gl_buffer_object
*bufObj
;
454 GET_CURRENT_CONTEXT(ctx
);
456 if (target
!= GL_TRANSFORM_FEEDBACK_BUFFER
) {
457 _mesa_error(ctx
, GL_INVALID_ENUM
, "glBindBufferRange(target)");
461 obj
= ctx
->TransformFeedback
.CurrentObject
;
464 _mesa_error(ctx
, GL_INVALID_OPERATION
,
465 "glBindBufferRange(transform feedback active)");
469 if (index
>= ctx
->Const
.MaxTransformFeedbackSeparateAttribs
) {
470 _mesa_error(ctx
, GL_INVALID_VALUE
, "glBindBufferRange(index=%d)", index
);
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
);
481 /* must be multiple of four */
482 _mesa_error(ctx
, GL_INVALID_VALUE
,
483 "glBindBufferRange(offset=%d)", (int) offset
);
487 bufObj
= _mesa_lookup_bufferobj(ctx
, buffer
);
489 _mesa_error(ctx
, GL_INVALID_OPERATION
,
490 "glBindBufferRange(invalid buffer=%u)", buffer
);
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
));
501 bind_buffer_range(ctx
, index
, bufObj
, offset
, size
);
506 * Specify a buffer object to receive vertex shader results.
507 * As above, but start at offset = 0.
510 _mesa_BindBufferBase(GLenum target
, GLuint index
, GLuint buffer
)
512 struct gl_transform_feedback_object
*obj
;
513 struct gl_buffer_object
*bufObj
;
515 GET_CURRENT_CONTEXT(ctx
);
517 if (target
!= GL_TRANSFORM_FEEDBACK_BUFFER
) {
518 _mesa_error(ctx
, GL_INVALID_ENUM
, "glBindBufferBase(target)");
522 obj
= ctx
->TransformFeedback
.CurrentObject
;
525 _mesa_error(ctx
, GL_INVALID_OPERATION
,
526 "glBindBufferBase(transform feedback active)");
530 if (index
>= ctx
->Const
.MaxTransformFeedbackSeparateAttribs
) {
531 _mesa_error(ctx
, GL_INVALID_VALUE
, "glBindBufferBase(index=%d)", index
);
535 bufObj
= _mesa_lookup_bufferobj(ctx
, buffer
);
537 _mesa_error(ctx
, GL_INVALID_OPERATION
,
538 "glBindBufferBase(invalid buffer=%u)", buffer
);
542 /* default size is the buffer size rounded down to nearest
545 size
= bufObj
->Size
& ~0x3;
547 bind_buffer_range(ctx
, index
, bufObj
, 0, size
);
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.
557 _mesa_BindBufferOffsetEXT(GLenum target
, GLuint index
, GLuint buffer
,
560 struct gl_transform_feedback_object
*obj
;
561 struct gl_buffer_object
*bufObj
;
562 GET_CURRENT_CONTEXT(ctx
);
565 if (target
!= GL_TRANSFORM_FEEDBACK_BUFFER
) {
566 _mesa_error(ctx
, GL_INVALID_ENUM
, "glBindBufferOffsetEXT(target)");
570 obj
= ctx
->TransformFeedback
.CurrentObject
;
573 _mesa_error(ctx
, GL_INVALID_OPERATION
,
574 "glBindBufferOffsetEXT(transform feedback active)");
578 if (index
>= ctx
->Const
.MaxTransformFeedbackSeparateAttribs
) {
579 _mesa_error(ctx
, GL_INVALID_VALUE
,
580 "glBindBufferOffsetEXT(index=%d)", index
);
584 bufObj
= _mesa_lookup_bufferobj(ctx
, buffer
);
586 _mesa_error(ctx
, GL_INVALID_OPERATION
,
587 "glBindBufferOffsetEXT(invalid buffer=%u)", buffer
);
591 /* default size is the buffer size rounded down to nearest
594 size
= (bufObj
->Size
- offset
) & ~0x3;
596 bind_buffer_range(ctx
, index
, bufObj
, offset
, size
);
601 * This function specifies the vertex shader outputs to be written
602 * to the feedback buffer(s), and in what order.
605 _mesa_TransformFeedbackVaryings(GLuint program
, GLsizei count
,
606 const GLchar
**varyings
, GLenum bufferMode
)
608 struct gl_shader_program
*shProg
;
610 GET_CURRENT_CONTEXT(ctx
);
612 switch (bufferMode
) {
613 case GL_INTERLEAVED_ATTRIBS
:
615 case GL_SEPARATE_ATTRIBS
:
618 _mesa_error(ctx
, GL_INVALID_ENUM
,
619 "glTransformFeedbackVaryings(bufferMode)");
624 (bufferMode
== GL_SEPARATE_ATTRIBS
&&
625 (GLuint
) count
> ctx
->Const
.MaxTransformFeedbackSeparateAttribs
)) {
626 _mesa_error(ctx
, GL_INVALID_VALUE
,
627 "glTransformFeedbackVaryings(count=%d)", count
);
631 shProg
= _mesa_lookup_shader_program(ctx
, program
);
633 _mesa_error(ctx
, GL_INVALID_VALUE
,
634 "glTransformFeedbackVaryings(program=%u)", program
);
638 /* free existing varyings, if any */
639 for (i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++) {
640 free(shProg
->TransformFeedback
.VaryingNames
[i
]);
642 free(shProg
->TransformFeedback
.VaryingNames
);
644 /* allocate new memory for varying names */
645 shProg
->TransformFeedback
.VaryingNames
=
646 (GLchar
**) malloc(count
* sizeof(GLchar
*));
648 if (!shProg
->TransformFeedback
.VaryingNames
) {
649 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glTransformFeedbackVaryings()");
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
]);
657 shProg
->TransformFeedback
.NumVarying
= count
;
659 shProg
->TransformFeedback
.BufferMode
= bufferMode
;
661 /* No need to set _NEW_TRANSFORM_FEEDBACK (or invoke FLUSH_VERTICES) since
662 * the varyings won't be used until shader link time.
668 * Get info about the vertex shader's outputs which are to be written
669 * to the feedback buffer(s).
672 _mesa_GetTransformFeedbackVarying(GLuint program
, GLuint index
,
673 GLsizei bufSize
, GLsizei
*length
,
674 GLsizei
*size
, GLenum
*type
, GLchar
*name
)
676 const struct gl_shader_program
*shProg
;
677 const GLchar
*varyingName
;
679 GET_CURRENT_CONTEXT(ctx
);
681 shProg
= _mesa_lookup_shader_program(ctx
, program
);
683 _mesa_error(ctx
, GL_INVALID_VALUE
,
684 "glGetTransformFeedbackVaryings(program=%u)", program
);
688 if (index
>= shProg
->TransformFeedback
.NumVarying
) {
689 _mesa_error(ctx
, GL_INVALID_VALUE
,
690 "glGetTransformFeedbackVaryings(index=%u)", index
);
694 varyingName
= shProg
->TransformFeedback
.VaryingNames
[index
];
696 v
= _mesa_lookup_parameter_index(shProg
->Varying
, -1, varyingName
);
698 struct gl_program_parameter
*param
= &shProg
->Varying
->Parameters
[v
];
700 /* return the varying's name and length */
701 _mesa_copy_string(name
, bufSize
, length
, varyingName
);
703 /* return the datatype and value's size (in datatype units) */
705 *type
= param
->DataType
;
722 struct gl_transform_feedback_object
*
723 _mesa_lookup_transform_feedback_object(struct gl_context
*ctx
, GLuint name
)
726 return ctx
->TransformFeedback
.DefaultObject
;
729 return (struct gl_transform_feedback_object
*)
730 _mesa_HashLookup(ctx
->TransformFeedback
.Objects
, name
);
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.
741 _mesa_GenTransformFeedbacks(GLsizei n
, GLuint
*names
)
744 GET_CURRENT_CONTEXT(ctx
);
746 ASSERT_OUTSIDE_BEGIN_END(ctx
);
749 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGenTransformFeedbacks(n < 0)");
756 /* we don't need contiguous IDs, but this might be faster */
757 first
= _mesa_HashFindFreeKeyBlock(ctx
->TransformFeedback
.Objects
, n
);
760 for (i
= 0; i
< n
; i
++) {
761 struct gl_transform_feedback_object
*obj
762 = ctx
->Driver
.NewTransformFeedback(ctx
, first
+ i
);
764 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glGenTransformFeedbacks");
767 names
[i
] = first
+ i
;
768 _mesa_HashInsert(ctx
->TransformFeedback
.Objects
, first
+ i
, obj
);
772 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glGenTransformFeedbacks");
778 * Is the given ID a transform feedback object?
779 * Part of GL_ARB_transform_feedback2.
782 _mesa_IsTransformFeedback(GLuint name
)
784 GET_CURRENT_CONTEXT(ctx
);
786 ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx
, GL_FALSE
);
788 if (name
&& _mesa_lookup_transform_feedback_object(ctx
, name
))
796 * Bind the given transform feedback object.
797 * Part of GL_ARB_transform_feedback2.
800 _mesa_BindTransformFeedback(GLenum target
, GLuint name
)
802 struct gl_transform_feedback_object
*obj
;
803 GET_CURRENT_CONTEXT(ctx
);
805 if (target
!= GL_TRANSFORM_FEEDBACK
) {
806 _mesa_error(ctx
, GL_INVALID_ENUM
, "glBindTransformFeedback(target)");
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)");
817 obj
= _mesa_lookup_transform_feedback_object(ctx
, name
);
819 _mesa_error(ctx
, GL_INVALID_OPERATION
,
820 "glBindTransformFeedback(name=%u)", name
);
824 reference_transform_feedback_object(&ctx
->TransformFeedback
.CurrentObject
,
830 * Delete the given transform feedback objects.
831 * Part of GL_ARB_transform_feedback2.
834 _mesa_DeleteTransformFeedbacks(GLsizei n
, const GLuint
*names
)
837 GET_CURRENT_CONTEXT(ctx
);
839 ASSERT_OUTSIDE_BEGIN_END(ctx
);
842 _mesa_error(ctx
, GL_INVALID_VALUE
, "glDeleteTransformFeedbacks(n < 0)");
849 for (i
= 0; i
< n
; i
++) {
851 struct gl_transform_feedback_object
*obj
852 = _mesa_lookup_transform_feedback_object(ctx
, names
[i
]);
855 _mesa_error(ctx
, GL_INVALID_OPERATION
,
856 "glDeleteTransformFeedbacks(object %u is active)",
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
);
870 * Pause transform feedback.
871 * Part of GL_ARB_transform_feedback2.
874 _mesa_PauseTransformFeedback(void)
876 struct gl_transform_feedback_object
*obj
;
877 GET_CURRENT_CONTEXT(ctx
);
879 obj
= ctx
->TransformFeedback
.CurrentObject
;
881 if (!obj
->Active
|| obj
->Paused
) {
882 _mesa_error(ctx
, GL_INVALID_OPERATION
,
883 "glPauseTransformFeedback(feedback not active or already paused)");
887 FLUSH_VERTICES(ctx
, _NEW_TRANSFORM_FEEDBACK
);
888 obj
->Paused
= GL_TRUE
;
890 assert(ctx
->Driver
.PauseTransformFeedback
);
891 ctx
->Driver
.PauseTransformFeedback(ctx
, obj
);
896 * Resume transform feedback.
897 * Part of GL_ARB_transform_feedback2.
900 _mesa_ResumeTransformFeedback(void)
902 struct gl_transform_feedback_object
*obj
;
903 GET_CURRENT_CONTEXT(ctx
);
905 obj
= ctx
->TransformFeedback
.CurrentObject
;
907 if (!obj
->Active
|| !obj
->Paused
) {
908 _mesa_error(ctx
, GL_INVALID_OPERATION
,
909 "glResumeTransformFeedback(feedback not active or not paused)");
913 FLUSH_VERTICES(ctx
, _NEW_TRANSFORM_FEEDBACK
);
914 obj
->Paused
= GL_FALSE
;
916 assert(ctx
->Driver
.ResumeTransformFeedback
);
917 ctx
->Driver
.ResumeTransformFeedback(ctx
, obj
);
920 #endif /* FEATURE_EXT_transform_feedback */