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 #if FEATURE_ARB_fragment_shader
171 case GL_FRAGMENT_SHADER
:
172 return ctx
->Extensions
.ARB_fragment_shader
;
174 #if FEATURE_ARB_vertex_shader
175 case GL_VERTEX_SHADER
:
176 return ctx
->Extensions
.ARB_vertex_shader
;
178 #if FEATURE_ARB_geometry_shader4
179 case GL_GEOMETRY_SHADER_ARB
:
180 return ctx
->Extensions
.ARB_geometry_shader4
;
189 * Find the length of the longest transform feedback varying name
190 * which was specified with glTransformFeedbackVaryings().
193 longest_feedback_varying_name(const struct gl_shader_program
*shProg
)
197 for (i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++) {
198 GLint len
= strlen(shProg
->TransformFeedback
.VaryingNames
[i
]);
208 is_program(struct gl_context
*ctx
, GLuint name
)
210 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
211 return shProg
? GL_TRUE
: GL_FALSE
;
216 is_shader(struct gl_context
*ctx
, GLuint name
)
218 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
219 return shader
? GL_TRUE
: GL_FALSE
;
224 * Attach shader to a shader program.
227 attach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
229 struct gl_shader_program
*shProg
;
230 struct gl_shader
*sh
;
233 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glAttachShader");
237 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glAttachShader");
242 n
= shProg
->NumShaders
;
243 for (i
= 0; i
< n
; i
++) {
244 if (shProg
->Shaders
[i
] == sh
) {
245 /* The shader is already attched to this program. The
246 * GL_ARB_shader_objects spec says:
248 * "The error INVALID_OPERATION is generated by AttachObjectARB
249 * if <obj> is already attached to <containerObj>."
251 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glAttachShader");
257 shProg
->Shaders
= (struct gl_shader
**)
258 _mesa_realloc(shProg
->Shaders
,
259 n
* sizeof(struct gl_shader
*),
260 (n
+ 1) * sizeof(struct gl_shader
*));
261 if (!shProg
->Shaders
) {
262 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
267 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
268 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
269 shProg
->NumShaders
++;
274 create_shader(struct gl_context
*ctx
, GLenum type
)
276 struct gl_shader
*sh
;
279 if (!validate_shader_target(ctx
, type
)) {
280 _mesa_error(ctx
, GL_INVALID_ENUM
, "CreateShader(type)");
284 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
285 sh
= ctx
->Driver
.NewShader(ctx
, name
, type
);
286 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, sh
);
293 create_shader_program(struct gl_context
*ctx
)
296 struct gl_shader_program
*shProg
;
298 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
300 shProg
= ctx
->Driver
.NewShaderProgram(ctx
, name
);
302 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, shProg
);
304 assert(shProg
->RefCount
== 1);
311 * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
315 delete_shader_program(struct gl_context
*ctx
, GLuint name
)
318 * NOTE: deleting shaders/programs works a bit differently than
319 * texture objects (and buffer objects, etc). Shader/program
320 * handles/IDs exist in the hash table until the object is really
321 * deleted (refcount==0). With texture objects, the handle/ID is
322 * removed from the hash table in glDeleteTextures() while the tex
323 * object itself might linger until its refcount goes to zero.
325 struct gl_shader_program
*shProg
;
327 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
331 if (!shProg
->DeletePending
) {
332 shProg
->DeletePending
= GL_TRUE
;
334 /* effectively, decr shProg's refcount */
335 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
341 delete_shader(struct gl_context
*ctx
, GLuint shader
)
343 struct gl_shader
*sh
;
345 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
349 sh
->DeletePending
= GL_TRUE
;
351 /* effectively, decr sh's refcount */
352 _mesa_reference_shader(ctx
, &sh
, NULL
);
357 detach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
359 struct gl_shader_program
*shProg
;
363 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
367 n
= shProg
->NumShaders
;
369 for (i
= 0; i
< n
; i
++) {
370 if (shProg
->Shaders
[i
]->Name
== shader
) {
372 struct gl_shader
**newList
;
375 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
377 /* alloc new, smaller array */
378 newList
= (struct gl_shader
**)
379 malloc((n
- 1) * sizeof(struct gl_shader
*));
381 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
384 for (j
= 0; j
< i
; j
++) {
385 newList
[j
] = shProg
->Shaders
[j
];
388 newList
[j
++] = shProg
->Shaders
[i
];
389 free(shProg
->Shaders
);
391 shProg
->Shaders
= newList
;
392 shProg
->NumShaders
= n
- 1;
397 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
398 assert(shProg
->Shaders
[j
]->Type
== GL_VERTEX_SHADER
||
399 shProg
->Shaders
[j
]->Type
== GL_FRAGMENT_SHADER
);
400 assert(shProg
->Shaders
[j
]->RefCount
> 0);
412 if (is_shader(ctx
, shader
))
413 err
= GL_INVALID_OPERATION
;
414 else if (is_program(ctx
, shader
))
415 err
= GL_INVALID_OPERATION
;
417 err
= GL_INVALID_VALUE
;
418 _mesa_error(ctx
, err
, "glDetachProgram(shader)");
425 * Return list of shaders attached to shader program.
428 get_attached_shaders(struct gl_context
*ctx
, GLuint program
, GLsizei maxCount
,
429 GLsizei
*count
, GLuint
*obj
)
431 struct gl_shader_program
*shProg
=
432 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
435 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
436 obj
[i
] = shProg
->Shaders
[i
]->Name
;
445 * glGetHandleARB() - return ID/name of currently bound shader program.
448 get_handle(struct gl_context
*ctx
, GLenum pname
)
450 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
451 if (ctx
->Shader
.ActiveProgram
)
452 return ctx
->Shader
.ActiveProgram
->Name
;
457 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
464 * glGetProgramiv() - get shader program state.
465 * Note that this is for GLSL shader programs, not ARB vertex/fragment
466 * programs (see glGetProgramivARB).
469 get_programiv(struct gl_context
*ctx
, GLuint program
, GLenum pname
, GLint
*params
)
471 struct gl_shader_program
*shProg
472 = _mesa_lookup_shader_program(ctx
, program
);
475 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramiv(program)");
480 case GL_DELETE_STATUS
:
481 *params
= shProg
->DeletePending
;
484 *params
= shProg
->LinkStatus
;
486 case GL_VALIDATE_STATUS
:
487 *params
= shProg
->Validated
;
489 case GL_INFO_LOG_LENGTH
:
490 *params
= shProg
->InfoLog
? strlen(shProg
->InfoLog
) + 1 : 0;
492 case GL_ATTACHED_SHADERS
:
493 *params
= shProg
->NumShaders
;
495 case GL_ACTIVE_ATTRIBUTES
:
496 *params
= _mesa_count_active_attribs(shProg
);
498 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
499 *params
= _mesa_longest_attribute_name_length(shProg
);
501 case GL_ACTIVE_UNIFORMS
:
502 *params
= shProg
->NumUserUniformStorage
;
504 case GL_ACTIVE_UNIFORM_MAX_LENGTH
: {
508 for (i
= 0; i
< shProg
->NumUserUniformStorage
; i
++) {
509 /* Add one for the terminating NUL character.
511 const GLint len
= strlen(shProg
->UniformStorage
[i
].name
) + 1;
520 case GL_PROGRAM_BINARY_LENGTH_OES
:
523 #if FEATURE_EXT_transform_feedback
524 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
525 *params
= shProg
->TransformFeedback
.NumVarying
;
527 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
:
528 *params
= longest_feedback_varying_name(shProg
) + 1;
530 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
531 *params
= shProg
->TransformFeedback
.BufferMode
;
534 #if FEATURE_ARB_geometry_shader4
535 case GL_GEOMETRY_VERTICES_OUT_ARB
:
536 *params
= shProg
->Geom
.VerticesOut
;
538 case GL_GEOMETRY_INPUT_TYPE_ARB
:
539 *params
= shProg
->Geom
.InputType
;
541 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
542 *params
= shProg
->Geom
.OutputType
;
546 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname)");
553 * glGetShaderiv() - get GLSL shader state
556 get_shaderiv(struct gl_context
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
558 struct gl_shader
*shader
=
559 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
567 *params
= shader
->Type
;
569 case GL_DELETE_STATUS
:
570 *params
= shader
->DeletePending
;
572 case GL_COMPILE_STATUS
:
573 *params
= shader
->CompileStatus
;
575 case GL_INFO_LOG_LENGTH
:
576 *params
= shader
->InfoLog
? strlen(shader
->InfoLog
) + 1 : 0;
578 case GL_SHADER_SOURCE_LENGTH
:
579 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
582 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
589 get_program_info_log(struct gl_context
*ctx
, GLuint program
, GLsizei bufSize
,
590 GLsizei
*length
, GLchar
*infoLog
)
592 struct gl_shader_program
*shProg
593 = _mesa_lookup_shader_program(ctx
, program
);
595 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(program)");
598 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->InfoLog
);
603 get_shader_info_log(struct gl_context
*ctx
, GLuint shader
, GLsizei bufSize
,
604 GLsizei
*length
, GLchar
*infoLog
)
606 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
608 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(shader)");
611 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
616 * Return shader source code.
619 get_shader_source(struct gl_context
*ctx
, GLuint shader
, GLsizei maxLength
,
620 GLsizei
*length
, GLchar
*sourceOut
)
622 struct gl_shader
*sh
;
623 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
627 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
632 * Set/replace shader source code. A helper function used by
633 * glShaderSource[ARB] and glCreateShaderProgramEXT.
636 shader_source(struct gl_context
*ctx
, GLuint shader
, const GLchar
*source
)
638 struct gl_shader
*sh
;
640 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glShaderSource");
644 /* free old shader source string and install new one */
646 free((void *) sh
->Source
);
649 sh
->CompileStatus
= GL_FALSE
;
651 sh
->SourceChecksum
= _mesa_str_checksum(sh
->Source
);
660 compile_shader(struct gl_context
*ctx
, GLuint shaderObj
)
662 struct gl_shader
*sh
;
663 struct gl_shader_compiler_options
*options
;
665 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glCompileShader");
669 options
= &ctx
->ShaderCompilerOptions
[_mesa_shader_type_to_index(sh
->Type
)];
671 /* set default pragma state for shader */
672 sh
->Pragmas
= options
->DefaultPragmas
;
674 /* this call will set the sh->CompileStatus field to indicate if
675 * compilation was successful.
677 _mesa_glsl_compile_shader(ctx
, sh
);
679 if (sh
->CompileStatus
== GL_FALSE
&&
680 (ctx
->Shader
.Flags
& GLSL_REPORT_ERRORS
)) {
681 _mesa_debug(ctx
, "Error compiling shader %u:\n%s\n",
682 sh
->Name
, sh
->InfoLog
);
688 * Link a program's shaders.
691 link_program(struct gl_context
*ctx
, GLuint program
)
693 struct gl_shader_program
*shProg
;
694 struct gl_transform_feedback_object
*obj
=
695 ctx
->TransformFeedback
.CurrentObject
;
697 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glLinkProgram");
702 && (shProg
== ctx
->Shader
.CurrentVertexProgram
703 || shProg
== ctx
->Shader
.CurrentGeometryProgram
704 || shProg
== ctx
->Shader
.CurrentFragmentProgram
)) {
705 _mesa_error(ctx
, GL_INVALID_OPERATION
,
706 "glLinkProgram(transform feedback active)");
710 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
712 _mesa_glsl_link_shader(ctx
, shProg
);
714 if (shProg
->LinkStatus
== GL_FALSE
&&
715 (ctx
->Shader
.Flags
& GLSL_REPORT_ERRORS
)) {
716 _mesa_debug(ctx
, "Error linking program %u:\n%s\n",
717 shProg
->Name
, shProg
->InfoLog
);
724 printf("Link %u shaders in program %u: %s\n",
725 shProg
->NumShaders
, shProg
->Name
,
726 shProg
->LinkStatus
? "Success" : "Failed");
728 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
729 printf(" shader %u, type 0x%x\n",
730 shProg
->Shaders
[i
]->Name
,
731 shProg
->Shaders
[i
]->Type
);
738 * Print basic shader info (for debug).
741 print_shader_info(const struct gl_shader_program
*shProg
)
745 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
746 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
748 switch (shProg
->Shaders
[i
]->Type
) {
749 case GL_VERTEX_SHADER
:
752 case GL_FRAGMENT_SHADER
:
755 case GL_GEOMETRY_SHADER
:
761 printf(" %s shader %u, checksum %u\n", s
,
762 shProg
->Shaders
[i
]->Name
,
763 shProg
->Shaders
[i
]->SourceChecksum
);
765 if (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
])
766 printf(" vert prog %u\n",
767 shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
]->Program
->Id
);
768 if (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
])
769 printf(" frag prog %u\n",
770 shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
->Id
);
771 if (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
])
772 printf(" geom prog %u\n",
773 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->Program
->Id
);
778 * Use the named shader program for subsequent glUniform calls
781 _mesa_active_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
784 if ((shProg
!= NULL
) && !shProg
->LinkStatus
) {
785 _mesa_error(ctx
, GL_INVALID_OPERATION
,
786 "%s(program %u not linked)", caller
, shProg
->Name
);
790 if (ctx
->Shader
.ActiveProgram
!= shProg
) {
791 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, shProg
);
798 use_shader_program(struct gl_context
*ctx
, GLenum type
,
799 struct gl_shader_program
*shProg
)
801 struct gl_shader_program
**target
;
804 #if FEATURE_ARB_vertex_shader
805 case GL_VERTEX_SHADER
:
806 target
= &ctx
->Shader
.CurrentVertexProgram
;
808 || (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
] == NULL
)) {
813 #if FEATURE_ARB_geometry_shader4
814 case GL_GEOMETRY_SHADER_ARB
:
815 target
= &ctx
->Shader
.CurrentGeometryProgram
;
817 || (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
] == NULL
)) {
822 #if FEATURE_ARB_fragment_shader
823 case GL_FRAGMENT_SHADER
:
824 target
= &ctx
->Shader
.CurrentFragmentProgram
;
826 || (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
] == NULL
)) {
835 if (*target
!= shProg
) {
836 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
838 /* If the shader is also bound as the current rendering shader, unbind
839 * it from that binding point as well. This ensures that the correct
840 * semantics of glDeleteProgram are maintained.
843 #if FEATURE_ARB_vertex_shader
844 case GL_VERTEX_SHADER
:
848 #if FEATURE_ARB_geometry_shader4
849 case GL_GEOMETRY_SHADER_ARB
:
853 #if FEATURE_ARB_fragment_shader
854 case GL_FRAGMENT_SHADER
:
855 if (*target
== ctx
->Shader
._CurrentFragmentProgram
) {
856 _mesa_reference_shader_program(ctx
,
857 &ctx
->Shader
._CurrentFragmentProgram
,
864 _mesa_reference_shader_program(ctx
, target
, shProg
);
872 * Use the named shader program for subsequent rendering.
875 _mesa_use_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
877 use_shader_program(ctx
, GL_VERTEX_SHADER
, shProg
);
878 use_shader_program(ctx
, GL_GEOMETRY_SHADER_ARB
, shProg
);
879 use_shader_program(ctx
, GL_FRAGMENT_SHADER
, shProg
);
880 _mesa_active_program(ctx
, shProg
, "glUseProgram");
882 if (ctx
->Driver
.UseProgram
)
883 ctx
->Driver
.UseProgram(ctx
, shProg
);
888 * Do validation of the given shader program.
889 * \param errMsg returns error message if validation fails.
890 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
893 validate_shader_program(const struct gl_shader_program
*shProg
,
896 if (!shProg
->LinkStatus
) {
900 /* From the GL spec, a program is invalid if any of these are true:
902 any two active samplers in the current program object are of
903 different types, but refer to the same texture image unit,
905 any active sampler in the current program object refers to a texture
906 image unit where fixed-function fragment processing accesses a
907 texture target that does not match the sampler type, or
909 the sum of the number of active samplers in the program and the
910 number of texture image units enabled for fixed-function fragment
911 processing exceeds the combined limit on the total number of texture
917 * Check: any two active samplers in the current program object are of
918 * different types, but refer to the same texture image unit,
920 if (!_mesa_sampler_uniforms_are_valid(shProg
, errMsg
, 100))
928 * Called via glValidateProgram()
931 validate_program(struct gl_context
*ctx
, GLuint program
)
933 struct gl_shader_program
*shProg
;
934 char errMsg
[100] = "";
936 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
941 shProg
->Validated
= validate_shader_program(shProg
, errMsg
);
942 if (!shProg
->Validated
) {
943 /* update info log */
944 if (shProg
->InfoLog
) {
945 ralloc_free(shProg
->InfoLog
);
947 shProg
->InfoLog
= ralloc_strdup(shProg
, errMsg
);
954 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
956 GET_CURRENT_CONTEXT(ctx
);
957 attach_shader(ctx
, program
, shader
);
962 _mesa_AttachShader(GLuint program
, GLuint shader
)
964 GET_CURRENT_CONTEXT(ctx
);
965 attach_shader(ctx
, program
, shader
);
970 _mesa_CompileShaderARB(GLhandleARB shaderObj
)
972 GET_CURRENT_CONTEXT(ctx
);
973 if (MESA_VERBOSE
& VERBOSE_API
)
974 _mesa_debug(ctx
, "glCompileShader %u\n", shaderObj
);
975 compile_shader(ctx
, shaderObj
);
980 _mesa_CreateShader(GLenum type
)
982 GET_CURRENT_CONTEXT(ctx
);
983 if (MESA_VERBOSE
& VERBOSE_API
)
984 _mesa_debug(ctx
, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type
));
985 return create_shader(ctx
, type
);
989 GLhandleARB GLAPIENTRY
990 _mesa_CreateShaderObjectARB(GLenum type
)
992 GET_CURRENT_CONTEXT(ctx
);
993 return create_shader(ctx
, type
);
998 _mesa_CreateProgram(void)
1000 GET_CURRENT_CONTEXT(ctx
);
1001 if (MESA_VERBOSE
& VERBOSE_API
)
1002 _mesa_debug(ctx
, "glCreateProgram\n");
1003 return create_shader_program(ctx
);
1007 GLhandleARB GLAPIENTRY
1008 _mesa_CreateProgramObjectARB(void)
1010 GET_CURRENT_CONTEXT(ctx
);
1011 return create_shader_program(ctx
);
1016 _mesa_DeleteObjectARB(GLhandleARB obj
)
1018 if (MESA_VERBOSE
& VERBOSE_API
) {
1019 GET_CURRENT_CONTEXT(ctx
);
1020 _mesa_debug(ctx
, "glDeleteObjectARB(%u)\n", obj
);
1024 GET_CURRENT_CONTEXT(ctx
);
1025 FLUSH_VERTICES(ctx
, 0);
1026 if (is_program(ctx
, obj
)) {
1027 delete_shader_program(ctx
, obj
);
1029 else if (is_shader(ctx
, obj
)) {
1030 delete_shader(ctx
, obj
);
1040 _mesa_DeleteProgram(GLuint name
)
1043 GET_CURRENT_CONTEXT(ctx
);
1044 FLUSH_VERTICES(ctx
, 0);
1045 delete_shader_program(ctx
, name
);
1051 _mesa_DeleteShader(GLuint name
)
1054 GET_CURRENT_CONTEXT(ctx
);
1055 FLUSH_VERTICES(ctx
, 0);
1056 delete_shader(ctx
, name
);
1062 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1064 GET_CURRENT_CONTEXT(ctx
);
1065 detach_shader(ctx
, program
, shader
);
1070 _mesa_DetachShader(GLuint program
, GLuint shader
)
1072 GET_CURRENT_CONTEXT(ctx
);
1073 detach_shader(ctx
, program
, shader
);
1078 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1079 GLsizei
* count
, GLhandleARB
* obj
)
1081 GET_CURRENT_CONTEXT(ctx
);
1082 get_attached_shaders(ctx
, container
, maxCount
, count
, obj
);
1087 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1088 GLsizei
*count
, GLuint
*obj
)
1090 GET_CURRENT_CONTEXT(ctx
);
1091 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
);
1096 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1097 GLcharARB
* infoLog
)
1099 GET_CURRENT_CONTEXT(ctx
);
1100 if (is_program(ctx
, object
)) {
1101 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1103 else if (is_shader(ctx
, object
)) {
1104 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1107 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1113 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1115 GET_CURRENT_CONTEXT(ctx
);
1116 /* Implement in terms of GetProgramiv, GetShaderiv */
1117 if (is_program(ctx
, object
)) {
1118 if (pname
== GL_OBJECT_TYPE_ARB
) {
1119 *params
= GL_PROGRAM_OBJECT_ARB
;
1122 get_programiv(ctx
, object
, pname
, params
);
1125 else if (is_shader(ctx
, object
)) {
1126 if (pname
== GL_OBJECT_TYPE_ARB
) {
1127 *params
= GL_SHADER_OBJECT_ARB
;
1130 get_shaderiv(ctx
, object
, pname
, params
);
1134 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1140 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1143 GLint iparams
[1]; /* XXX is one element enough? */
1144 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1145 params
[0] = (GLfloat
) iparams
[0];
1150 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1152 GET_CURRENT_CONTEXT(ctx
);
1153 get_programiv(ctx
, program
, pname
, params
);
1158 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1160 GET_CURRENT_CONTEXT(ctx
);
1161 get_shaderiv(ctx
, shader
, pname
, params
);
1166 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1167 GLsizei
*length
, GLchar
*infoLog
)
1169 GET_CURRENT_CONTEXT(ctx
);
1170 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1175 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1176 GLsizei
*length
, GLchar
*infoLog
)
1178 GET_CURRENT_CONTEXT(ctx
);
1179 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1184 _mesa_GetShaderSourceARB(GLhandleARB shader
, GLsizei maxLength
,
1185 GLsizei
*length
, GLcharARB
*sourceOut
)
1187 GET_CURRENT_CONTEXT(ctx
);
1188 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1192 GLhandleARB GLAPIENTRY
1193 _mesa_GetHandleARB(GLenum pname
)
1195 GET_CURRENT_CONTEXT(ctx
);
1196 return get_handle(ctx
, pname
);
1200 GLboolean GLAPIENTRY
1201 _mesa_IsProgram(GLuint name
)
1203 GET_CURRENT_CONTEXT(ctx
);
1204 return is_program(ctx
, name
);
1208 GLboolean GLAPIENTRY
1209 _mesa_IsShader(GLuint name
)
1211 GET_CURRENT_CONTEXT(ctx
);
1212 return is_shader(ctx
, name
);
1217 _mesa_LinkProgramARB(GLhandleARB programObj
)
1219 GET_CURRENT_CONTEXT(ctx
);
1220 link_program(ctx
, programObj
);
1226 * Read shader source code from a file.
1227 * Useful for debugging to override an app's shader.
1230 read_shader(const char *fname
)
1232 const int max
= 50*1000;
1233 FILE *f
= fopen(fname
, "r");
1234 GLcharARB
*buffer
, *shader
;
1241 buffer
= (char *) malloc(max
);
1242 len
= fread(buffer
, 1, max
, f
);
1247 shader
= _mesa_strdup(buffer
);
1255 * Called via glShaderSource() and glShaderSourceARB() API functions.
1256 * Basically, concatenate the source code strings into one long string
1257 * and pass it to _mesa_shader_source().
1260 _mesa_ShaderSourceARB(GLhandleARB shaderObj
, GLsizei count
,
1261 const GLcharARB
** string
, const GLint
* length
)
1263 GET_CURRENT_CONTEXT(ctx
);
1265 GLsizei i
, totalLength
;
1269 if (!shaderObj
|| string
== NULL
) {
1270 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
1275 * This array holds offsets of where the appropriate string ends, thus the
1276 * last element will be set to the total length of the source code.
1278 offsets
= (GLint
*) malloc(count
* sizeof(GLint
));
1279 if (offsets
== NULL
) {
1280 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1284 for (i
= 0; i
< count
; i
++) {
1285 if (string
[i
] == NULL
) {
1286 free((GLvoid
*) offsets
);
1287 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1288 "glShaderSourceARB(null string)");
1291 if (length
== NULL
|| length
[i
] < 0)
1292 offsets
[i
] = strlen(string
[i
]);
1294 offsets
[i
] = length
[i
];
1295 /* accumulate string lengths */
1297 offsets
[i
] += offsets
[i
- 1];
1300 /* Total length of source string is sum off all strings plus two.
1301 * One extra byte for terminating zero, another extra byte to silence
1302 * valgrind warnings in the parser/grammer code.
1304 totalLength
= offsets
[count
- 1] + 2;
1305 source
= (GLcharARB
*) malloc(totalLength
* sizeof(GLcharARB
));
1306 if (source
== NULL
) {
1307 free((GLvoid
*) offsets
);
1308 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1312 for (i
= 0; i
< count
; i
++) {
1313 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
1314 memcpy(source
+ start
, string
[i
],
1315 (offsets
[i
] - start
) * sizeof(GLcharARB
));
1317 source
[totalLength
- 1] = '\0';
1318 source
[totalLength
- 2] = '\0';
1321 /* Compute the shader's source code checksum then try to open a file
1322 * named newshader_<CHECKSUM>. If it exists, use it in place of the
1323 * original shader source code. For debugging.
1326 GLcharARB
*newSource
;
1328 checksum
= _mesa_str_checksum(source
);
1330 _mesa_snprintf(filename
, sizeof(filename
), "newshader_%d", checksum
);
1332 newSource
= read_shader(filename
);
1334 fprintf(stderr
, "Mesa: Replacing shader %u chksum=%d with %s\n",
1335 shaderObj
, checksum
, filename
);
1341 shader_source(ctx
, shaderObj
, source
);
1344 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shaderObj
);
1346 sh
->SourceChecksum
= checksum
; /* save original checksum */
1354 _mesa_UseProgramObjectARB(GLhandleARB program
)
1356 GET_CURRENT_CONTEXT(ctx
);
1357 struct gl_shader_program
*shProg
;
1358 struct gl_transform_feedback_object
*obj
=
1359 ctx
->TransformFeedback
.CurrentObject
;
1361 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1363 if (obj
->Active
&& !obj
->Paused
) {
1364 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1365 "glUseProgram(transform feedback active)");
1370 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
1374 if (!shProg
->LinkStatus
) {
1375 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1376 "glUseProgram(program %u not linked)", program
);
1381 if (ctx
->Shader
.Flags
& GLSL_USE_PROG
) {
1382 print_shader_info(shProg
);
1389 _mesa_use_program(ctx
, shProg
);
1394 _mesa_ValidateProgramARB(GLhandleARB program
)
1396 GET_CURRENT_CONTEXT(ctx
);
1397 validate_program(ctx
, program
);
1403 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
1404 GLint
* range
, GLint
* precision
)
1406 const struct gl_program_constants
*limits
;
1407 const struct gl_precision
*p
;
1408 GET_CURRENT_CONTEXT(ctx
);
1410 switch (shadertype
) {
1411 case GL_VERTEX_SHADER
:
1412 limits
= &ctx
->Const
.VertexProgram
;
1414 case GL_FRAGMENT_SHADER
:
1415 limits
= &ctx
->Const
.FragmentProgram
;
1418 _mesa_error(ctx
, GL_INVALID_ENUM
,
1419 "glGetShaderPrecisionFormat(shadertype)");
1423 switch (precisiontype
) {
1425 p
= &limits
->LowFloat
;
1427 case GL_MEDIUM_FLOAT
:
1428 p
= &limits
->MediumFloat
;
1431 p
= &limits
->HighFloat
;
1434 p
= &limits
->LowInt
;
1437 p
= &limits
->MediumInt
;
1440 p
= &limits
->HighInt
;
1443 _mesa_error(ctx
, GL_INVALID_ENUM
,
1444 "glGetShaderPrecisionFormat(precisiontype)");
1448 range
[0] = p
->RangeMin
;
1449 range
[1] = p
->RangeMax
;
1450 precision
[0] = p
->Precision
;
1455 _mesa_ReleaseShaderCompiler(void)
1457 _mesa_destroy_shader_compiler_caches();
1462 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
1463 const void* binary
, GLint length
)
1465 GET_CURRENT_CONTEXT(ctx
);
1468 (void) binaryformat
;
1471 _mesa_error(ctx
, GL_INVALID_OPERATION
, __FUNCTION__
);
1474 #endif /* FEATURE_ES2 */
1477 #if FEATURE_ARB_geometry_shader4
1480 _mesa_ProgramParameteriARB(GLuint program
, GLenum pname
, GLint value
)
1482 struct gl_shader_program
*shProg
;
1483 GET_CURRENT_CONTEXT(ctx
);
1485 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1487 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
1488 "glProgramParameteri");
1493 case GL_GEOMETRY_VERTICES_OUT_ARB
:
1495 (unsigned) value
> ctx
->Const
.MaxGeometryOutputVertices
) {
1496 _mesa_error(ctx
, GL_INVALID_VALUE
,
1497 "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",
1501 shProg
->Geom
.VerticesOut
= value
;
1503 case GL_GEOMETRY_INPUT_TYPE_ARB
:
1507 case GL_LINES_ADJACENCY_ARB
:
1509 case GL_TRIANGLES_ADJACENCY_ARB
:
1510 shProg
->Geom
.InputType
= value
;
1513 _mesa_error(ctx
, GL_INVALID_VALUE
,
1514 "glProgramParameteri(geometry input type = %s",
1515 _mesa_lookup_enum_by_nr(value
));
1519 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
1523 case GL_TRIANGLE_STRIP
:
1524 shProg
->Geom
.OutputType
= value
;
1527 _mesa_error(ctx
, GL_INVALID_VALUE
,
1528 "glProgramParameteri(geometry output type = %s",
1529 _mesa_lookup_enum_by_nr(value
));
1534 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteriARB(pname=%s)",
1535 _mesa_lookup_enum_by_nr(pname
));
1543 _mesa_use_shader_program(struct gl_context
*ctx
, GLenum type
,
1544 struct gl_shader_program
*shProg
)
1546 use_shader_program(ctx
, type
, shProg
);
1548 if (ctx
->Driver
.UseProgram
)
1549 ctx
->Driver
.UseProgram(ctx
, shProg
);
1554 * For GL_EXT_separate_shader_objects
1557 _mesa_UseShaderProgramEXT(GLenum type
, GLuint program
)
1559 GET_CURRENT_CONTEXT(ctx
);
1560 struct gl_shader_program
*shProg
= NULL
;
1562 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1564 if (!validate_shader_target(ctx
, type
)) {
1565 _mesa_error(ctx
, GL_INVALID_ENUM
, "glUseShaderProgramEXT(type)");
1569 if (ctx
->TransformFeedback
.CurrentObject
->Active
&&
1570 !ctx
->TransformFeedback
.CurrentObject
->Paused
) {
1571 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1572 "glUseShaderProgramEXT(transform feedback is active)");
1577 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
1578 "glUseShaderProgramEXT");
1582 if (!shProg
->LinkStatus
) {
1583 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1584 "glUseShaderProgramEXT(program not linked)");
1589 _mesa_use_shader_program(ctx
, type
, shProg
);
1594 * For GL_EXT_separate_shader_objects
1597 _mesa_ActiveProgramEXT(GLuint program
)
1599 GET_CURRENT_CONTEXT(ctx
);
1600 struct gl_shader_program
*shProg
= (program
!= 0)
1601 ? _mesa_lookup_shader_program_err(ctx
, program
, "glActiveProgramEXT")
1604 _mesa_active_program(ctx
, shProg
, "glActiveProgramEXT");
1610 * For GL_EXT_separate_shader_objects
1613 _mesa_CreateShaderProgramEXT(GLenum type
, const GLchar
*string
)
1615 GET_CURRENT_CONTEXT(ctx
);
1616 const GLuint shader
= create_shader(ctx
, type
);
1620 shader_source(ctx
, shader
, _mesa_strdup(string
));
1621 compile_shader(ctx
, shader
);
1623 program
= create_shader_program(ctx
);
1625 struct gl_shader_program
*shProg
;
1626 struct gl_shader
*sh
;
1627 GLint compiled
= GL_FALSE
;
1629 shProg
= _mesa_lookup_shader_program(ctx
, program
);
1630 sh
= _mesa_lookup_shader(ctx
, shader
);
1632 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
1634 attach_shader(ctx
, program
, shader
);
1635 link_program(ctx
, program
);
1636 detach_shader(ctx
, program
, shader
);
1640 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
1641 append
-error
-to
-info
-log
;
1642 shProg
->LinkStatus
= GL_FALSE
;
1647 ralloc_strcat(&shProg
->InfoLog
, sh
->InfoLog
);
1650 delete_shader(ctx
, shader
);
1657 * Plug in shader-related functions into API dispatch table.
1660 _mesa_init_shader_dispatch(struct _glapi_table
*exec
)
1663 /* GL_ARB_vertex/fragment_shader */
1664 SET_DeleteObjectARB(exec
, _mesa_DeleteObjectARB
);
1665 SET_GetHandleARB(exec
, _mesa_GetHandleARB
);
1666 SET_DetachObjectARB(exec
, _mesa_DetachObjectARB
);
1667 SET_CreateShaderObjectARB(exec
, _mesa_CreateShaderObjectARB
);
1668 SET_ShaderSourceARB(exec
, _mesa_ShaderSourceARB
);
1669 SET_CompileShaderARB(exec
, _mesa_CompileShaderARB
);
1670 SET_CreateProgramObjectARB(exec
, _mesa_CreateProgramObjectARB
);
1671 SET_AttachObjectARB(exec
, _mesa_AttachObjectARB
);
1672 SET_LinkProgramARB(exec
, _mesa_LinkProgramARB
);
1673 SET_UseProgramObjectARB(exec
, _mesa_UseProgramObjectARB
);
1674 SET_ValidateProgramARB(exec
, _mesa_ValidateProgramARB
);
1675 SET_GetObjectParameterfvARB(exec
, _mesa_GetObjectParameterfvARB
);
1676 SET_GetObjectParameterivARB(exec
, _mesa_GetObjectParameterivARB
);
1677 SET_GetInfoLogARB(exec
, _mesa_GetInfoLogARB
);
1678 SET_GetAttachedObjectsARB(exec
, _mesa_GetAttachedObjectsARB
);
1679 SET_GetShaderSourceARB(exec
, _mesa_GetShaderSourceARB
);
1682 SET_AttachShader(exec
, _mesa_AttachShader
);
1683 SET_CreateProgram(exec
, _mesa_CreateProgram
);
1684 SET_CreateShader(exec
, _mesa_CreateShader
);
1685 SET_DeleteProgram(exec
, _mesa_DeleteProgram
);
1686 SET_DeleteShader(exec
, _mesa_DeleteShader
);
1687 SET_DetachShader(exec
, _mesa_DetachShader
);
1688 SET_GetAttachedShaders(exec
, _mesa_GetAttachedShaders
);
1689 SET_GetProgramiv(exec
, _mesa_GetProgramiv
);
1690 SET_GetProgramInfoLog(exec
, _mesa_GetProgramInfoLog
);
1691 SET_GetShaderiv(exec
, _mesa_GetShaderiv
);
1692 SET_GetShaderInfoLog(exec
, _mesa_GetShaderInfoLog
);
1693 SET_IsProgram(exec
, _mesa_IsProgram
);
1694 SET_IsShader(exec
, _mesa_IsShader
);
1696 #if FEATURE_ARB_vertex_shader
1697 SET_BindAttribLocationARB(exec
, _mesa_BindAttribLocationARB
);
1698 SET_GetActiveAttribARB(exec
, _mesa_GetActiveAttribARB
);
1699 SET_GetAttribLocationARB(exec
, _mesa_GetAttribLocationARB
);
1702 #if FEATURE_ARB_geometry_shader4
1703 SET_ProgramParameteriARB(exec
, _mesa_ProgramParameteriARB
);
1706 SET_UseShaderProgramEXT(exec
, _mesa_UseShaderProgramEXT
);
1707 SET_ActiveProgramEXT(exec
, _mesa_ActiveProgramEXT
);
1708 SET_CreateShaderProgramEXT(exec
, _mesa_CreateShaderProgramEXT
);
1710 /* GL_EXT_gpu_shader4 / GL 3.0 */
1711 SET_BindFragDataLocationEXT(exec
, _mesa_BindFragDataLocation
);
1712 SET_GetFragDataLocationEXT(exec
, _mesa_GetFragDataLocation
);
1714 /* GL_ARB_ES2_compatibility */
1715 SET_ReleaseShaderCompiler(exec
, _mesa_ReleaseShaderCompiler
);
1716 SET_GetShaderPrecisionFormat(exec
, _mesa_GetShaderPrecisionFormat
);
1718 /* GL_ARB_blend_func_extended */
1719 SET_BindFragDataLocationIndexed(exec
, _mesa_BindFragDataLocationIndexed
);
1720 SET_GetFragDataIndex(exec
, _mesa_GetFragDataIndex
);
1721 #endif /* FEATURE_GL */