2 * Mesa 3-D graphics library
4 * Copyright (C) 2004-2008 Brian Paul All Rights Reserved.
5 * Copyright (C) 2009-2010 VMware, Inc. All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
29 * Implementation of GLSL-related API functions.
30 * The glUniform* functions are in uniforms.c
34 * 1. Check that the right error code is generated for all _mesa_error() calls.
35 * 2. Insert FLUSH_VERTICES calls in various places
39 #include "main/glheader.h"
40 #include "main/context.h"
41 #include "main/dispatch.h"
42 #include "main/enums.h"
43 #include "main/hash.h"
44 #include "main/mfeatures.h"
45 #include "main/mtypes.h"
46 #include "main/shaderapi.h"
47 #include "main/shaderobj.h"
48 #include "main/uniforms.h"
49 #include "program/program.h"
50 #include "program/prog_parameter.h"
53 #include "../glsl/glsl_parser_extras.h"
54 #include "../glsl/ir_uniform.h"
56 /** Define this to enable shader substitution (see below) */
57 #define SHADER_SUBST 0
61 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
64 get_shader_flags(void)
66 GLbitfield flags
= 0x0;
67 const char *env
= _mesa_getenv("MESA_GLSL");
70 if (strstr(env
, "dump"))
72 if (strstr(env
, "log"))
74 if (strstr(env
, "nopvert"))
75 flags
|= GLSL_NOP_VERT
;
76 if (strstr(env
, "nopfrag"))
77 flags
|= GLSL_NOP_FRAG
;
78 if (strstr(env
, "nopt"))
80 else if (strstr(env
, "opt"))
82 if (strstr(env
, "uniform"))
83 flags
|= GLSL_UNIFORMS
;
84 if (strstr(env
, "useprog"))
85 flags
|= GLSL_USE_PROG
;
86 if (strstr(env
, "errors"))
87 flags
|= GLSL_REPORT_ERRORS
;
95 * Initialize context's shader state.
98 _mesa_init_shader_state(struct gl_context
*ctx
)
100 /* Device drivers may override these to control what kind of instructions
101 * are generated by the GLSL compiler.
103 struct gl_shader_compiler_options options
;
106 memset(&options
, 0, sizeof(options
));
107 options
.MaxUnrollIterations
= 32;
109 /* Default pragma settings */
110 options
.DefaultPragmas
.Optimize
= GL_TRUE
;
112 for (sh
= 0; sh
< MESA_SHADER_TYPES
; ++sh
)
113 memcpy(&ctx
->ShaderCompilerOptions
[sh
], &options
, sizeof(options
));
115 ctx
->Shader
.Flags
= get_shader_flags();
120 * Free the per-context shader-related state.
123 _mesa_free_shader_state(struct gl_context
*ctx
)
125 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentVertexProgram
, NULL
);
126 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentGeometryProgram
,
128 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentFragmentProgram
,
130 _mesa_reference_shader_program(ctx
, &ctx
->Shader
._CurrentFragmentProgram
,
132 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, NULL
);
137 * Copy string from <src> to <dst>, up to maxLength characters, returning
138 * length of <dst> in <length>.
139 * \param src the strings source
140 * \param maxLength max chars to copy
141 * \param length returns number of chars copied
142 * \param dst the string destination
145 _mesa_copy_string(GLchar
*dst
, GLsizei maxLength
,
146 GLsizei
*length
, const GLchar
*src
)
149 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
160 * Confirm that the a shader type is valid and supported by the implementation
162 * \param ctx Current GL context
163 * \param type Shader target
167 validate_shader_target(const struct gl_context
*ctx
, GLenum type
)
170 case GL_FRAGMENT_SHADER
:
171 return ctx
->Extensions
.ARB_fragment_shader
;
172 case GL_VERTEX_SHADER
:
173 return ctx
->Extensions
.ARB_vertex_shader
;
174 case GL_GEOMETRY_SHADER_ARB
:
175 return _mesa_is_desktop_gl(ctx
) && ctx
->Extensions
.ARB_geometry_shader4
;
183 * Find the length of the longest transform feedback varying name
184 * which was specified with glTransformFeedbackVaryings().
187 longest_feedback_varying_name(const struct gl_shader_program
*shProg
)
191 for (i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++) {
192 GLint len
= strlen(shProg
->TransformFeedback
.VaryingNames
[i
]);
202 is_program(struct gl_context
*ctx
, GLuint name
)
204 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
205 return shProg
? GL_TRUE
: GL_FALSE
;
210 is_shader(struct gl_context
*ctx
, GLuint name
)
212 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
213 return shader
? GL_TRUE
: GL_FALSE
;
218 * Attach shader to a shader program.
221 attach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
223 struct gl_shader_program
*shProg
;
224 struct gl_shader
*sh
;
227 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glAttachShader");
231 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glAttachShader");
236 n
= shProg
->NumShaders
;
237 for (i
= 0; i
< n
; i
++) {
238 if (shProg
->Shaders
[i
] == sh
) {
239 /* The shader is already attched to this program. The
240 * GL_ARB_shader_objects spec says:
242 * "The error INVALID_OPERATION is generated by AttachObjectARB
243 * if <obj> is already attached to <containerObj>."
245 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glAttachShader");
251 shProg
->Shaders
= (struct gl_shader
**)
252 _mesa_realloc(shProg
->Shaders
,
253 n
* sizeof(struct gl_shader
*),
254 (n
+ 1) * sizeof(struct gl_shader
*));
255 if (!shProg
->Shaders
) {
256 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
261 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
262 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
263 shProg
->NumShaders
++;
268 create_shader(struct gl_context
*ctx
, GLenum type
)
270 struct gl_shader
*sh
;
273 if (!validate_shader_target(ctx
, type
)) {
274 _mesa_error(ctx
, GL_INVALID_ENUM
, "CreateShader(type)");
278 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
279 sh
= ctx
->Driver
.NewShader(ctx
, name
, type
);
280 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, sh
);
287 create_shader_program(struct gl_context
*ctx
)
290 struct gl_shader_program
*shProg
;
292 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
294 shProg
= ctx
->Driver
.NewShaderProgram(ctx
, name
);
296 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, shProg
);
298 assert(shProg
->RefCount
== 1);
305 * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
309 delete_shader_program(struct gl_context
*ctx
, GLuint name
)
312 * NOTE: deleting shaders/programs works a bit differently than
313 * texture objects (and buffer objects, etc). Shader/program
314 * handles/IDs exist in the hash table until the object is really
315 * deleted (refcount==0). With texture objects, the handle/ID is
316 * removed from the hash table in glDeleteTextures() while the tex
317 * object itself might linger until its refcount goes to zero.
319 struct gl_shader_program
*shProg
;
321 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
325 if (!shProg
->DeletePending
) {
326 shProg
->DeletePending
= GL_TRUE
;
328 /* effectively, decr shProg's refcount */
329 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
335 delete_shader(struct gl_context
*ctx
, GLuint shader
)
337 struct gl_shader
*sh
;
339 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
343 if (!sh
->DeletePending
) {
344 sh
->DeletePending
= GL_TRUE
;
346 /* effectively, decr sh's refcount */
347 _mesa_reference_shader(ctx
, &sh
, NULL
);
353 detach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
355 struct gl_shader_program
*shProg
;
359 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
363 n
= shProg
->NumShaders
;
365 for (i
= 0; i
< n
; i
++) {
366 if (shProg
->Shaders
[i
]->Name
== shader
) {
368 struct gl_shader
**newList
;
371 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
373 /* alloc new, smaller array */
375 malloc((n
- 1) * sizeof(struct gl_shader
*));
377 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
380 for (j
= 0; j
< i
; j
++) {
381 newList
[j
] = shProg
->Shaders
[j
];
384 newList
[j
++] = shProg
->Shaders
[i
];
385 free(shProg
->Shaders
);
387 shProg
->Shaders
= newList
;
388 shProg
->NumShaders
= n
- 1;
393 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
394 assert(shProg
->Shaders
[j
]->Type
== GL_VERTEX_SHADER
||
395 shProg
->Shaders
[j
]->Type
== GL_FRAGMENT_SHADER
);
396 assert(shProg
->Shaders
[j
]->RefCount
> 0);
408 if (is_shader(ctx
, shader
))
409 err
= GL_INVALID_OPERATION
;
410 else if (is_program(ctx
, shader
))
411 err
= GL_INVALID_OPERATION
;
413 err
= GL_INVALID_VALUE
;
414 _mesa_error(ctx
, err
, "glDetachProgram(shader)");
421 * Return list of shaders attached to shader program.
424 get_attached_shaders(struct gl_context
*ctx
, GLuint program
, GLsizei maxCount
,
425 GLsizei
*count
, GLuint
*obj
)
427 struct gl_shader_program
*shProg
=
428 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
431 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
432 obj
[i
] = shProg
->Shaders
[i
]->Name
;
441 * glGetHandleARB() - return ID/name of currently bound shader program.
444 get_handle(struct gl_context
*ctx
, GLenum pname
)
446 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
447 if (ctx
->Shader
.ActiveProgram
)
448 return ctx
->Shader
.ActiveProgram
->Name
;
453 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
460 * glGetProgramiv() - get shader program state.
461 * Note that this is for GLSL shader programs, not ARB vertex/fragment
462 * programs (see glGetProgramivARB).
465 get_programiv(struct gl_context
*ctx
, GLuint program
, GLenum pname
, GLint
*params
)
467 struct gl_shader_program
*shProg
468 = _mesa_lookup_shader_program(ctx
, program
);
470 /* Is transform feedback available in this context?
473 (ctx
->API
== API_OPENGL
&& ctx
->Extensions
.EXT_transform_feedback
)
474 || ctx
->API
== API_OPENGL_CORE
475 || _mesa_is_gles3(ctx
);
477 /* Are geometry shaders available in this context?
480 _mesa_is_desktop_gl(ctx
) && ctx
->Extensions
.ARB_geometry_shader4
;
482 /* Are uniform buffer objects available in this context?
485 (ctx
->API
== API_OPENGL
&& ctx
->Extensions
.ARB_uniform_buffer_object
)
486 || ctx
->API
== API_OPENGL_CORE
487 || _mesa_is_gles3(ctx
);
490 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramiv(program)");
495 case GL_DELETE_STATUS
:
496 *params
= shProg
->DeletePending
;
499 *params
= shProg
->LinkStatus
;
501 case GL_VALIDATE_STATUS
:
502 *params
= shProg
->Validated
;
504 case GL_INFO_LOG_LENGTH
:
505 *params
= shProg
->InfoLog
? strlen(shProg
->InfoLog
) + 1 : 0;
507 case GL_ATTACHED_SHADERS
:
508 *params
= shProg
->NumShaders
;
510 case GL_ACTIVE_ATTRIBUTES
:
511 *params
= _mesa_count_active_attribs(shProg
);
513 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
514 *params
= _mesa_longest_attribute_name_length(shProg
);
516 case GL_ACTIVE_UNIFORMS
:
517 *params
= shProg
->NumUserUniformStorage
;
519 case GL_ACTIVE_UNIFORM_MAX_LENGTH
: {
523 for (i
= 0; i
< shProg
->NumUserUniformStorage
; i
++) {
524 /* Add one for the terminating NUL character.
526 const GLint len
= strlen(shProg
->UniformStorage
[i
].name
) + 1;
535 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
538 *params
= shProg
->TransformFeedback
.NumVarying
;
540 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
:
543 *params
= longest_feedback_varying_name(shProg
) + 1;
545 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
548 *params
= shProg
->TransformFeedback
.BufferMode
;
550 case GL_GEOMETRY_VERTICES_OUT_ARB
:
553 *params
= shProg
->Geom
.VerticesOut
;
555 case GL_GEOMETRY_INPUT_TYPE_ARB
:
558 *params
= shProg
->Geom
.InputType
;
560 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
563 *params
= shProg
->Geom
.OutputType
;
565 case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH
: {
572 for (i
= 0; i
< shProg
->NumUniformBlocks
; i
++) {
573 /* Add one for the terminating NUL character.
575 const GLint len
= strlen(shProg
->UniformBlocks
[i
].Name
) + 1;
584 case GL_ACTIVE_UNIFORM_BLOCKS
:
588 *params
= shProg
->NumUniformBlocks
;
594 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname=%s)",
595 _mesa_lookup_enum_by_nr(pname
));
600 * glGetShaderiv() - get GLSL shader state
603 get_shaderiv(struct gl_context
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
605 struct gl_shader
*shader
=
606 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
614 *params
= shader
->Type
;
616 case GL_DELETE_STATUS
:
617 *params
= shader
->DeletePending
;
619 case GL_COMPILE_STATUS
:
620 *params
= shader
->CompileStatus
;
622 case GL_INFO_LOG_LENGTH
:
623 *params
= shader
->InfoLog
? strlen(shader
->InfoLog
) + 1 : 0;
625 case GL_SHADER_SOURCE_LENGTH
:
626 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
629 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
636 get_program_info_log(struct gl_context
*ctx
, GLuint program
, GLsizei bufSize
,
637 GLsizei
*length
, GLchar
*infoLog
)
639 struct gl_shader_program
*shProg
640 = _mesa_lookup_shader_program(ctx
, program
);
642 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(program)");
645 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->InfoLog
);
650 get_shader_info_log(struct gl_context
*ctx
, GLuint shader
, GLsizei bufSize
,
651 GLsizei
*length
, GLchar
*infoLog
)
653 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
655 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(shader)");
658 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
663 * Return shader source code.
666 get_shader_source(struct gl_context
*ctx
, GLuint shader
, GLsizei maxLength
,
667 GLsizei
*length
, GLchar
*sourceOut
)
669 struct gl_shader
*sh
;
670 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
674 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
679 * Set/replace shader source code. A helper function used by
680 * glShaderSource[ARB] and glCreateShaderProgramEXT.
683 shader_source(struct gl_context
*ctx
, GLuint shader
, const GLchar
*source
)
685 struct gl_shader
*sh
;
687 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glShaderSource");
691 /* free old shader source string and install new one */
692 free((void *)sh
->Source
);
694 sh
->CompileStatus
= GL_FALSE
;
696 sh
->SourceChecksum
= _mesa_str_checksum(sh
->Source
);
705 compile_shader(struct gl_context
*ctx
, GLuint shaderObj
)
707 struct gl_shader
*sh
;
708 struct gl_shader_compiler_options
*options
;
710 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glCompileShader");
714 options
= &ctx
->ShaderCompilerOptions
[_mesa_shader_type_to_index(sh
->Type
)];
716 /* set default pragma state for shader */
717 sh
->Pragmas
= options
->DefaultPragmas
;
719 /* this call will set the sh->CompileStatus field to indicate if
720 * compilation was successful.
722 _mesa_glsl_compile_shader(ctx
, sh
);
724 if (sh
->CompileStatus
== GL_FALSE
&&
725 (ctx
->Shader
.Flags
& GLSL_REPORT_ERRORS
)) {
726 _mesa_debug(ctx
, "Error compiling shader %u:\n%s\n",
727 sh
->Name
, sh
->InfoLog
);
733 * Link a program's shaders.
736 link_program(struct gl_context
*ctx
, GLuint program
)
738 struct gl_shader_program
*shProg
;
739 struct gl_transform_feedback_object
*obj
=
740 ctx
->TransformFeedback
.CurrentObject
;
742 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glLinkProgram");
747 && (shProg
== ctx
->Shader
.CurrentVertexProgram
748 || shProg
== ctx
->Shader
.CurrentGeometryProgram
749 || shProg
== ctx
->Shader
.CurrentFragmentProgram
)) {
750 _mesa_error(ctx
, GL_INVALID_OPERATION
,
751 "glLinkProgram(transform feedback active)");
755 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
757 _mesa_glsl_link_shader(ctx
, shProg
);
759 if (shProg
->LinkStatus
== GL_FALSE
&&
760 (ctx
->Shader
.Flags
& GLSL_REPORT_ERRORS
)) {
761 _mesa_debug(ctx
, "Error linking program %u:\n%s\n",
762 shProg
->Name
, shProg
->InfoLog
);
769 printf("Link %u shaders in program %u: %s\n",
770 shProg
->NumShaders
, shProg
->Name
,
771 shProg
->LinkStatus
? "Success" : "Failed");
773 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
774 printf(" shader %u, type 0x%x\n",
775 shProg
->Shaders
[i
]->Name
,
776 shProg
->Shaders
[i
]->Type
);
783 * Print basic shader info (for debug).
786 print_shader_info(const struct gl_shader_program
*shProg
)
790 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
791 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
793 switch (shProg
->Shaders
[i
]->Type
) {
794 case GL_VERTEX_SHADER
:
797 case GL_FRAGMENT_SHADER
:
800 case GL_GEOMETRY_SHADER
:
806 printf(" %s shader %u, checksum %u\n", s
,
807 shProg
->Shaders
[i
]->Name
,
808 shProg
->Shaders
[i
]->SourceChecksum
);
810 if (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
])
811 printf(" vert prog %u\n",
812 shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
]->Program
->Id
);
813 if (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
])
814 printf(" frag prog %u\n",
815 shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
->Id
);
816 if (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
])
817 printf(" geom prog %u\n",
818 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->Program
->Id
);
823 * Use the named shader program for subsequent glUniform calls
826 _mesa_active_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
829 if ((shProg
!= NULL
) && !shProg
->LinkStatus
) {
830 _mesa_error(ctx
, GL_INVALID_OPERATION
,
831 "%s(program %u not linked)", caller
, shProg
->Name
);
835 if (ctx
->Shader
.ActiveProgram
!= shProg
) {
836 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, shProg
);
843 use_shader_program(struct gl_context
*ctx
, GLenum type
,
844 struct gl_shader_program
*shProg
)
846 struct gl_shader_program
**target
;
849 case GL_VERTEX_SHADER
:
850 target
= &ctx
->Shader
.CurrentVertexProgram
;
852 || (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
] == NULL
)) {
856 case GL_GEOMETRY_SHADER_ARB
:
857 target
= &ctx
->Shader
.CurrentGeometryProgram
;
859 || (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
] == NULL
)) {
863 case GL_FRAGMENT_SHADER
:
864 target
= &ctx
->Shader
.CurrentFragmentProgram
;
866 || (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
] == NULL
)) {
874 if (*target
!= shProg
) {
875 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
877 /* If the shader is also bound as the current rendering shader, unbind
878 * it from that binding point as well. This ensures that the correct
879 * semantics of glDeleteProgram are maintained.
882 case GL_VERTEX_SHADER
:
885 case GL_GEOMETRY_SHADER_ARB
:
888 case GL_FRAGMENT_SHADER
:
889 if (*target
== ctx
->Shader
._CurrentFragmentProgram
) {
890 _mesa_reference_shader_program(ctx
,
891 &ctx
->Shader
._CurrentFragmentProgram
,
897 _mesa_reference_shader_program(ctx
, target
, shProg
);
905 * Use the named shader program for subsequent rendering.
908 _mesa_use_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
910 use_shader_program(ctx
, GL_VERTEX_SHADER
, shProg
);
911 use_shader_program(ctx
, GL_GEOMETRY_SHADER_ARB
, shProg
);
912 use_shader_program(ctx
, GL_FRAGMENT_SHADER
, shProg
);
913 _mesa_active_program(ctx
, shProg
, "glUseProgram");
915 if (ctx
->Driver
.UseProgram
)
916 ctx
->Driver
.UseProgram(ctx
, shProg
);
921 * Do validation of the given shader program.
922 * \param errMsg returns error message if validation fails.
923 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
926 validate_shader_program(const struct gl_shader_program
*shProg
,
929 if (!shProg
->LinkStatus
) {
933 /* From the GL spec, a program is invalid if any of these are true:
935 any two active samplers in the current program object are of
936 different types, but refer to the same texture image unit,
938 any active sampler in the current program object refers to a texture
939 image unit where fixed-function fragment processing accesses a
940 texture target that does not match the sampler type, or
942 the sum of the number of active samplers in the program and the
943 number of texture image units enabled for fixed-function fragment
944 processing exceeds the combined limit on the total number of texture
950 * Check: any two active samplers in the current program object are of
951 * different types, but refer to the same texture image unit,
953 if (!_mesa_sampler_uniforms_are_valid(shProg
, errMsg
, 100))
961 * Called via glValidateProgram()
964 validate_program(struct gl_context
*ctx
, GLuint program
)
966 struct gl_shader_program
*shProg
;
967 char errMsg
[100] = "";
969 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
974 shProg
->Validated
= validate_shader_program(shProg
, errMsg
);
975 if (!shProg
->Validated
) {
976 /* update info log */
977 if (shProg
->InfoLog
) {
978 ralloc_free(shProg
->InfoLog
);
980 shProg
->InfoLog
= ralloc_strdup(shProg
, errMsg
);
987 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
989 GET_CURRENT_CONTEXT(ctx
);
990 attach_shader(ctx
, program
, shader
);
995 _mesa_AttachShader(GLuint program
, GLuint shader
)
997 GET_CURRENT_CONTEXT(ctx
);
998 attach_shader(ctx
, program
, shader
);
1003 _mesa_CompileShaderARB(GLhandleARB shaderObj
)
1005 GET_CURRENT_CONTEXT(ctx
);
1006 if (MESA_VERBOSE
& VERBOSE_API
)
1007 _mesa_debug(ctx
, "glCompileShader %u\n", shaderObj
);
1008 compile_shader(ctx
, shaderObj
);
1013 _mesa_CreateShader(GLenum type
)
1015 GET_CURRENT_CONTEXT(ctx
);
1016 if (MESA_VERBOSE
& VERBOSE_API
)
1017 _mesa_debug(ctx
, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type
));
1018 return create_shader(ctx
, type
);
1022 GLhandleARB GLAPIENTRY
1023 _mesa_CreateShaderObjectARB(GLenum type
)
1025 GET_CURRENT_CONTEXT(ctx
);
1026 return create_shader(ctx
, type
);
1031 _mesa_CreateProgram(void)
1033 GET_CURRENT_CONTEXT(ctx
);
1034 if (MESA_VERBOSE
& VERBOSE_API
)
1035 _mesa_debug(ctx
, "glCreateProgram\n");
1036 return create_shader_program(ctx
);
1040 GLhandleARB GLAPIENTRY
1041 _mesa_CreateProgramObjectARB(void)
1043 GET_CURRENT_CONTEXT(ctx
);
1044 return create_shader_program(ctx
);
1049 _mesa_DeleteObjectARB(GLhandleARB obj
)
1051 if (MESA_VERBOSE
& VERBOSE_API
) {
1052 GET_CURRENT_CONTEXT(ctx
);
1053 _mesa_debug(ctx
, "glDeleteObjectARB(%u)\n", obj
);
1057 GET_CURRENT_CONTEXT(ctx
);
1058 FLUSH_VERTICES(ctx
, 0);
1059 if (is_program(ctx
, obj
)) {
1060 delete_shader_program(ctx
, obj
);
1062 else if (is_shader(ctx
, obj
)) {
1063 delete_shader(ctx
, obj
);
1073 _mesa_DeleteProgram(GLuint name
)
1076 GET_CURRENT_CONTEXT(ctx
);
1077 FLUSH_VERTICES(ctx
, 0);
1078 delete_shader_program(ctx
, name
);
1084 _mesa_DeleteShader(GLuint name
)
1087 GET_CURRENT_CONTEXT(ctx
);
1088 FLUSH_VERTICES(ctx
, 0);
1089 delete_shader(ctx
, name
);
1095 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1097 GET_CURRENT_CONTEXT(ctx
);
1098 detach_shader(ctx
, program
, shader
);
1103 _mesa_DetachShader(GLuint program
, GLuint shader
)
1105 GET_CURRENT_CONTEXT(ctx
);
1106 detach_shader(ctx
, program
, shader
);
1111 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1112 GLsizei
* count
, GLhandleARB
* obj
)
1114 GET_CURRENT_CONTEXT(ctx
);
1115 get_attached_shaders(ctx
, container
, maxCount
, count
, obj
);
1120 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1121 GLsizei
*count
, GLuint
*obj
)
1123 GET_CURRENT_CONTEXT(ctx
);
1124 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
);
1129 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1130 GLcharARB
* infoLog
)
1132 GET_CURRENT_CONTEXT(ctx
);
1133 if (is_program(ctx
, object
)) {
1134 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1136 else if (is_shader(ctx
, object
)) {
1137 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1140 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1146 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1148 GET_CURRENT_CONTEXT(ctx
);
1149 /* Implement in terms of GetProgramiv, GetShaderiv */
1150 if (is_program(ctx
, object
)) {
1151 if (pname
== GL_OBJECT_TYPE_ARB
) {
1152 *params
= GL_PROGRAM_OBJECT_ARB
;
1155 get_programiv(ctx
, object
, pname
, params
);
1158 else if (is_shader(ctx
, object
)) {
1159 if (pname
== GL_OBJECT_TYPE_ARB
) {
1160 *params
= GL_SHADER_OBJECT_ARB
;
1163 get_shaderiv(ctx
, object
, pname
, params
);
1167 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1173 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1176 GLint iparams
[1]; /* XXX is one element enough? */
1177 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1178 params
[0] = (GLfloat
) iparams
[0];
1183 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1185 GET_CURRENT_CONTEXT(ctx
);
1186 get_programiv(ctx
, program
, pname
, params
);
1191 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1193 GET_CURRENT_CONTEXT(ctx
);
1194 get_shaderiv(ctx
, shader
, pname
, params
);
1199 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1200 GLsizei
*length
, GLchar
*infoLog
)
1202 GET_CURRENT_CONTEXT(ctx
);
1203 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1208 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1209 GLsizei
*length
, GLchar
*infoLog
)
1211 GET_CURRENT_CONTEXT(ctx
);
1212 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1217 _mesa_GetShaderSourceARB(GLhandleARB shader
, GLsizei maxLength
,
1218 GLsizei
*length
, GLcharARB
*sourceOut
)
1220 GET_CURRENT_CONTEXT(ctx
);
1221 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1225 GLhandleARB GLAPIENTRY
1226 _mesa_GetHandleARB(GLenum pname
)
1228 GET_CURRENT_CONTEXT(ctx
);
1229 return get_handle(ctx
, pname
);
1233 GLboolean GLAPIENTRY
1234 _mesa_IsProgram(GLuint name
)
1236 GET_CURRENT_CONTEXT(ctx
);
1237 return is_program(ctx
, name
);
1241 GLboolean GLAPIENTRY
1242 _mesa_IsShader(GLuint name
)
1244 GET_CURRENT_CONTEXT(ctx
);
1245 return is_shader(ctx
, name
);
1250 _mesa_LinkProgramARB(GLhandleARB programObj
)
1252 GET_CURRENT_CONTEXT(ctx
);
1253 link_program(ctx
, programObj
);
1259 * Read shader source code from a file.
1260 * Useful for debugging to override an app's shader.
1263 read_shader(const char *fname
)
1265 const int max
= 50*1000;
1266 FILE *f
= fopen(fname
, "r");
1267 GLcharARB
*buffer
, *shader
;
1274 buffer
= malloc(max
);
1275 len
= fread(buffer
, 1, max
, f
);
1280 shader
= _mesa_strdup(buffer
);
1288 * Called via glShaderSource() and glShaderSourceARB() API functions.
1289 * Basically, concatenate the source code strings into one long string
1290 * and pass it to _mesa_shader_source().
1293 _mesa_ShaderSourceARB(GLhandleARB shaderObj
, GLsizei count
,
1294 const GLcharARB
** string
, const GLint
* length
)
1296 GET_CURRENT_CONTEXT(ctx
);
1298 GLsizei i
, totalLength
;
1302 if (!shaderObj
|| string
== NULL
) {
1303 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
1308 * This array holds offsets of where the appropriate string ends, thus the
1309 * last element will be set to the total length of the source code.
1311 offsets
= malloc(count
* sizeof(GLint
));
1312 if (offsets
== NULL
) {
1313 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1317 for (i
= 0; i
< count
; i
++) {
1318 if (string
[i
] == NULL
) {
1319 free((GLvoid
*) offsets
);
1320 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1321 "glShaderSourceARB(null string)");
1324 if (length
== NULL
|| length
[i
] < 0)
1325 offsets
[i
] = strlen(string
[i
]);
1327 offsets
[i
] = length
[i
];
1328 /* accumulate string lengths */
1330 offsets
[i
] += offsets
[i
- 1];
1333 /* Total length of source string is sum off all strings plus two.
1334 * One extra byte for terminating zero, another extra byte to silence
1335 * valgrind warnings in the parser/grammer code.
1337 totalLength
= offsets
[count
- 1] + 2;
1338 source
= malloc(totalLength
* sizeof(GLcharARB
));
1339 if (source
== NULL
) {
1340 free((GLvoid
*) offsets
);
1341 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1345 for (i
= 0; i
< count
; i
++) {
1346 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
1347 memcpy(source
+ start
, string
[i
],
1348 (offsets
[i
] - start
) * sizeof(GLcharARB
));
1350 source
[totalLength
- 1] = '\0';
1351 source
[totalLength
- 2] = '\0';
1354 /* Compute the shader's source code checksum then try to open a file
1355 * named newshader_<CHECKSUM>. If it exists, use it in place of the
1356 * original shader source code. For debugging.
1359 GLcharARB
*newSource
;
1361 checksum
= _mesa_str_checksum(source
);
1363 _mesa_snprintf(filename
, sizeof(filename
), "newshader_%d", checksum
);
1365 newSource
= read_shader(filename
);
1367 fprintf(stderr
, "Mesa: Replacing shader %u chksum=%d with %s\n",
1368 shaderObj
, checksum
, filename
);
1374 shader_source(ctx
, shaderObj
, source
);
1377 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shaderObj
);
1379 sh
->SourceChecksum
= checksum
; /* save original checksum */
1387 _mesa_UseProgramObjectARB(GLhandleARB program
)
1389 GET_CURRENT_CONTEXT(ctx
);
1390 struct gl_shader_program
*shProg
;
1391 struct gl_transform_feedback_object
*obj
=
1392 ctx
->TransformFeedback
.CurrentObject
;
1394 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1396 if (obj
->Active
&& !obj
->Paused
) {
1397 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1398 "glUseProgram(transform feedback active)");
1403 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
1407 if (!shProg
->LinkStatus
) {
1408 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1409 "glUseProgram(program %u not linked)", program
);
1414 if (ctx
->Shader
.Flags
& GLSL_USE_PROG
) {
1415 print_shader_info(shProg
);
1422 _mesa_use_program(ctx
, shProg
);
1427 _mesa_ValidateProgramARB(GLhandleARB program
)
1429 GET_CURRENT_CONTEXT(ctx
);
1430 validate_program(ctx
, program
);
1434 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
1435 GLint
* range
, GLint
* precision
)
1437 const struct gl_program_constants
*limits
;
1438 const struct gl_precision
*p
;
1439 GET_CURRENT_CONTEXT(ctx
);
1441 switch (shadertype
) {
1442 case GL_VERTEX_SHADER
:
1443 limits
= &ctx
->Const
.VertexProgram
;
1445 case GL_FRAGMENT_SHADER
:
1446 limits
= &ctx
->Const
.FragmentProgram
;
1449 _mesa_error(ctx
, GL_INVALID_ENUM
,
1450 "glGetShaderPrecisionFormat(shadertype)");
1454 switch (precisiontype
) {
1456 p
= &limits
->LowFloat
;
1458 case GL_MEDIUM_FLOAT
:
1459 p
= &limits
->MediumFloat
;
1462 p
= &limits
->HighFloat
;
1465 p
= &limits
->LowInt
;
1468 p
= &limits
->MediumInt
;
1471 p
= &limits
->HighInt
;
1474 _mesa_error(ctx
, GL_INVALID_ENUM
,
1475 "glGetShaderPrecisionFormat(precisiontype)");
1479 range
[0] = p
->RangeMin
;
1480 range
[1] = p
->RangeMax
;
1481 precision
[0] = p
->Precision
;
1486 _mesa_ReleaseShaderCompiler(void)
1488 _mesa_destroy_shader_compiler_caches();
1493 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
1494 const void* binary
, GLint length
)
1496 GET_CURRENT_CONTEXT(ctx
);
1499 (void) binaryformat
;
1502 _mesa_error(ctx
, GL_INVALID_OPERATION
, __FUNCTION__
);
1507 _mesa_ProgramParameteriARB(GLuint program
, GLenum pname
, GLint value
)
1509 struct gl_shader_program
*shProg
;
1510 GET_CURRENT_CONTEXT(ctx
);
1512 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1514 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
1515 "glProgramParameteri");
1520 case GL_GEOMETRY_VERTICES_OUT_ARB
:
1522 (unsigned) value
> ctx
->Const
.MaxGeometryOutputVertices
) {
1523 _mesa_error(ctx
, GL_INVALID_VALUE
,
1524 "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",
1528 shProg
->Geom
.VerticesOut
= value
;
1530 case GL_GEOMETRY_INPUT_TYPE_ARB
:
1534 case GL_LINES_ADJACENCY_ARB
:
1536 case GL_TRIANGLES_ADJACENCY_ARB
:
1537 shProg
->Geom
.InputType
= value
;
1540 _mesa_error(ctx
, GL_INVALID_VALUE
,
1541 "glProgramParameteri(geometry input type = %s",
1542 _mesa_lookup_enum_by_nr(value
));
1546 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
1550 case GL_TRIANGLE_STRIP
:
1551 shProg
->Geom
.OutputType
= value
;
1554 _mesa_error(ctx
, GL_INVALID_VALUE
,
1555 "glProgramParameteri(geometry output type = %s",
1556 _mesa_lookup_enum_by_nr(value
));
1561 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteriARB(pname=%s)",
1562 _mesa_lookup_enum_by_nr(pname
));
1568 _mesa_use_shader_program(struct gl_context
*ctx
, GLenum type
,
1569 struct gl_shader_program
*shProg
)
1571 use_shader_program(ctx
, type
, shProg
);
1573 if (ctx
->Driver
.UseProgram
)
1574 ctx
->Driver
.UseProgram(ctx
, shProg
);
1579 * For GL_EXT_separate_shader_objects
1582 _mesa_UseShaderProgramEXT(GLenum type
, GLuint program
)
1584 GET_CURRENT_CONTEXT(ctx
);
1585 struct gl_shader_program
*shProg
= NULL
;
1587 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1589 if (!validate_shader_target(ctx
, type
)) {
1590 _mesa_error(ctx
, GL_INVALID_ENUM
, "glUseShaderProgramEXT(type)");
1594 if (ctx
->TransformFeedback
.CurrentObject
->Active
&&
1595 !ctx
->TransformFeedback
.CurrentObject
->Paused
) {
1596 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1597 "glUseShaderProgramEXT(transform feedback is active)");
1602 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
1603 "glUseShaderProgramEXT");
1607 if (!shProg
->LinkStatus
) {
1608 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1609 "glUseShaderProgramEXT(program not linked)");
1614 _mesa_use_shader_program(ctx
, type
, shProg
);
1619 * For GL_EXT_separate_shader_objects
1622 _mesa_ActiveProgramEXT(GLuint program
)
1624 GET_CURRENT_CONTEXT(ctx
);
1625 struct gl_shader_program
*shProg
= (program
!= 0)
1626 ? _mesa_lookup_shader_program_err(ctx
, program
, "glActiveProgramEXT")
1629 _mesa_active_program(ctx
, shProg
, "glActiveProgramEXT");
1635 * For GL_EXT_separate_shader_objects
1638 _mesa_CreateShaderProgramEXT(GLenum type
, const GLchar
*string
)
1640 GET_CURRENT_CONTEXT(ctx
);
1641 const GLuint shader
= create_shader(ctx
, type
);
1645 shader_source(ctx
, shader
, _mesa_strdup(string
));
1646 compile_shader(ctx
, shader
);
1648 program
= create_shader_program(ctx
);
1650 struct gl_shader_program
*shProg
;
1651 struct gl_shader
*sh
;
1652 GLint compiled
= GL_FALSE
;
1654 shProg
= _mesa_lookup_shader_program(ctx
, program
);
1655 sh
= _mesa_lookup_shader(ctx
, shader
);
1657 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
1659 attach_shader(ctx
, program
, shader
);
1660 link_program(ctx
, program
);
1661 detach_shader(ctx
, program
, shader
);
1665 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
1666 append
-error
-to
-info
-log
;
1667 shProg
->LinkStatus
= GL_FALSE
;
1672 ralloc_strcat(&shProg
->InfoLog
, sh
->InfoLog
);
1675 delete_shader(ctx
, shader
);
1682 * Plug in shader-related functions into API dispatch table.
1685 _mesa_init_shader_dispatch(struct _glapi_table
*exec
)
1688 /* GL_ARB_vertex/fragment_shader */
1689 SET_DeleteObjectARB(exec
, _mesa_DeleteObjectARB
);
1690 SET_GetHandleARB(exec
, _mesa_GetHandleARB
);
1691 SET_DetachObjectARB(exec
, _mesa_DetachObjectARB
);
1692 SET_CreateShaderObjectARB(exec
, _mesa_CreateShaderObjectARB
);
1693 SET_ShaderSourceARB(exec
, _mesa_ShaderSourceARB
);
1694 SET_CompileShaderARB(exec
, _mesa_CompileShaderARB
);
1695 SET_CreateProgramObjectARB(exec
, _mesa_CreateProgramObjectARB
);
1696 SET_AttachObjectARB(exec
, _mesa_AttachObjectARB
);
1697 SET_LinkProgramARB(exec
, _mesa_LinkProgramARB
);
1698 SET_UseProgramObjectARB(exec
, _mesa_UseProgramObjectARB
);
1699 SET_ValidateProgramARB(exec
, _mesa_ValidateProgramARB
);
1700 SET_GetObjectParameterfvARB(exec
, _mesa_GetObjectParameterfvARB
);
1701 SET_GetObjectParameterivARB(exec
, _mesa_GetObjectParameterivARB
);
1702 SET_GetInfoLogARB(exec
, _mesa_GetInfoLogARB
);
1703 SET_GetAttachedObjectsARB(exec
, _mesa_GetAttachedObjectsARB
);
1704 SET_GetShaderSourceARB(exec
, _mesa_GetShaderSourceARB
);
1707 SET_AttachShader(exec
, _mesa_AttachShader
);
1708 SET_CreateProgram(exec
, _mesa_CreateProgram
);
1709 SET_CreateShader(exec
, _mesa_CreateShader
);
1710 SET_DeleteProgram(exec
, _mesa_DeleteProgram
);
1711 SET_DeleteShader(exec
, _mesa_DeleteShader
);
1712 SET_DetachShader(exec
, _mesa_DetachShader
);
1713 SET_GetAttachedShaders(exec
, _mesa_GetAttachedShaders
);
1714 SET_GetProgramiv(exec
, _mesa_GetProgramiv
);
1715 SET_GetProgramInfoLog(exec
, _mesa_GetProgramInfoLog
);
1716 SET_GetShaderiv(exec
, _mesa_GetShaderiv
);
1717 SET_GetShaderInfoLog(exec
, _mesa_GetShaderInfoLog
);
1718 SET_IsProgram(exec
, _mesa_IsProgram
);
1719 SET_IsShader(exec
, _mesa_IsShader
);
1721 /* GL_ARB_vertex_shader */
1722 SET_BindAttribLocationARB(exec
, _mesa_BindAttribLocationARB
);
1723 SET_GetActiveAttribARB(exec
, _mesa_GetActiveAttribARB
);
1724 SET_GetAttribLocationARB(exec
, _mesa_GetAttribLocationARB
);
1726 SET_ProgramParameteriARB(exec
, _mesa_ProgramParameteriARB
);
1728 SET_UseShaderProgramEXT(exec
, _mesa_UseShaderProgramEXT
);
1729 SET_ActiveProgramEXT(exec
, _mesa_ActiveProgramEXT
);
1730 SET_CreateShaderProgramEXT(exec
, _mesa_CreateShaderProgramEXT
);
1732 /* GL_EXT_gpu_shader4 / GL 3.0 */
1733 SET_BindFragDataLocationEXT(exec
, _mesa_BindFragDataLocation
);
1734 SET_GetFragDataLocationEXT(exec
, _mesa_GetFragDataLocation
);
1736 /* GL_ARB_ES2_compatibility */
1737 SET_ReleaseShaderCompiler(exec
, _mesa_ReleaseShaderCompiler
);
1738 SET_GetShaderPrecisionFormat(exec
, _mesa_GetShaderPrecisionFormat
);
1740 /* GL_ARB_blend_func_extended */
1741 SET_BindFragDataLocationIndexed(exec
, _mesa_BindFragDataLocationIndexed
);
1742 SET_GetFragDataIndex(exec
, _mesa_GetFragDataIndex
);
1743 #endif /* FEATURE_GL */