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 _mesa_is_desktop_gl(ctx
) && 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 if (!sh
->DeletePending
) {
350 sh
->DeletePending
= GL_TRUE
;
352 /* effectively, decr sh's refcount */
353 _mesa_reference_shader(ctx
, &sh
, NULL
);
359 detach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
361 struct gl_shader_program
*shProg
;
365 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
369 n
= shProg
->NumShaders
;
371 for (i
= 0; i
< n
; i
++) {
372 if (shProg
->Shaders
[i
]->Name
== shader
) {
374 struct gl_shader
**newList
;
377 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
379 /* alloc new, smaller array */
380 newList
= (struct gl_shader
**)
381 malloc((n
- 1) * sizeof(struct gl_shader
*));
383 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
386 for (j
= 0; j
< i
; j
++) {
387 newList
[j
] = shProg
->Shaders
[j
];
390 newList
[j
++] = shProg
->Shaders
[i
];
391 free(shProg
->Shaders
);
393 shProg
->Shaders
= newList
;
394 shProg
->NumShaders
= n
- 1;
399 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
400 assert(shProg
->Shaders
[j
]->Type
== GL_VERTEX_SHADER
||
401 shProg
->Shaders
[j
]->Type
== GL_FRAGMENT_SHADER
);
402 assert(shProg
->Shaders
[j
]->RefCount
> 0);
414 if (is_shader(ctx
, shader
))
415 err
= GL_INVALID_OPERATION
;
416 else if (is_program(ctx
, shader
))
417 err
= GL_INVALID_OPERATION
;
419 err
= GL_INVALID_VALUE
;
420 _mesa_error(ctx
, err
, "glDetachProgram(shader)");
427 * Return list of shaders attached to shader program.
430 get_attached_shaders(struct gl_context
*ctx
, GLuint program
, GLsizei maxCount
,
431 GLsizei
*count
, GLuint
*obj
)
433 struct gl_shader_program
*shProg
=
434 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
437 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
438 obj
[i
] = shProg
->Shaders
[i
]->Name
;
447 * glGetHandleARB() - return ID/name of currently bound shader program.
450 get_handle(struct gl_context
*ctx
, GLenum pname
)
452 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
453 if (ctx
->Shader
.ActiveProgram
)
454 return ctx
->Shader
.ActiveProgram
->Name
;
459 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
466 * glGetProgramiv() - get shader program state.
467 * Note that this is for GLSL shader programs, not ARB vertex/fragment
468 * programs (see glGetProgramivARB).
471 get_programiv(struct gl_context
*ctx
, GLuint program
, GLenum pname
, GLint
*params
)
473 struct gl_shader_program
*shProg
474 = _mesa_lookup_shader_program(ctx
, program
);
476 #if FEATURE_EXT_transform_feedback
477 /* Is transform feedback available in this context?
480 (ctx
->API
== API_OPENGL
&& ctx
->Extensions
.EXT_transform_feedback
)
481 || ctx
->API
== API_OPENGL_CORE
482 || _mesa_is_gles3(ctx
);
485 #if FEATURE_ARB_geometry_shader4
486 /* Are geometry shaders available in this context?
489 _mesa_is_desktop_gl(ctx
) && ctx
->Extensions
.ARB_geometry_shader4
;
492 /* Are uniform buffer objects available in this context?
495 (ctx
->API
== API_OPENGL
&& ctx
->Extensions
.ARB_uniform_buffer_object
)
496 || ctx
->API
== API_OPENGL_CORE
497 || _mesa_is_gles3(ctx
);
500 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramiv(program)");
505 case GL_DELETE_STATUS
:
506 *params
= shProg
->DeletePending
;
509 *params
= shProg
->LinkStatus
;
511 case GL_VALIDATE_STATUS
:
512 *params
= shProg
->Validated
;
514 case GL_INFO_LOG_LENGTH
:
515 *params
= shProg
->InfoLog
? strlen(shProg
->InfoLog
) + 1 : 0;
517 case GL_ATTACHED_SHADERS
:
518 *params
= shProg
->NumShaders
;
520 case GL_ACTIVE_ATTRIBUTES
:
521 *params
= _mesa_count_active_attribs(shProg
);
523 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
524 *params
= _mesa_longest_attribute_name_length(shProg
);
526 case GL_ACTIVE_UNIFORMS
:
527 *params
= shProg
->NumUserUniformStorage
;
529 case GL_ACTIVE_UNIFORM_MAX_LENGTH
: {
533 for (i
= 0; i
< shProg
->NumUserUniformStorage
; i
++) {
534 /* Add one for the terminating NUL character.
536 const GLint len
= strlen(shProg
->UniformStorage
[i
].name
) + 1;
545 #if FEATURE_EXT_transform_feedback
546 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
549 *params
= shProg
->TransformFeedback
.NumVarying
;
551 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
:
554 *params
= longest_feedback_varying_name(shProg
) + 1;
556 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
559 *params
= shProg
->TransformFeedback
.BufferMode
;
562 #if FEATURE_ARB_geometry_shader4
563 case GL_GEOMETRY_VERTICES_OUT_ARB
:
566 *params
= shProg
->Geom
.VerticesOut
;
568 case GL_GEOMETRY_INPUT_TYPE_ARB
:
571 *params
= shProg
->Geom
.InputType
;
573 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
576 *params
= shProg
->Geom
.OutputType
;
579 case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH
: {
586 for (i
= 0; i
< shProg
->NumUniformBlocks
; i
++) {
587 /* Add one for the terminating NUL character.
589 const GLint len
= strlen(shProg
->UniformBlocks
[i
].Name
) + 1;
598 case GL_ACTIVE_UNIFORM_BLOCKS
:
602 *params
= shProg
->NumUniformBlocks
;
608 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname=%s)",
609 _mesa_lookup_enum_by_nr(pname
));
614 * glGetShaderiv() - get GLSL shader state
617 get_shaderiv(struct gl_context
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
619 struct gl_shader
*shader
=
620 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
628 *params
= shader
->Type
;
630 case GL_DELETE_STATUS
:
631 *params
= shader
->DeletePending
;
633 case GL_COMPILE_STATUS
:
634 *params
= shader
->CompileStatus
;
636 case GL_INFO_LOG_LENGTH
:
637 *params
= shader
->InfoLog
? strlen(shader
->InfoLog
) + 1 : 0;
639 case GL_SHADER_SOURCE_LENGTH
:
640 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
643 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
650 get_program_info_log(struct gl_context
*ctx
, GLuint program
, GLsizei bufSize
,
651 GLsizei
*length
, GLchar
*infoLog
)
653 struct gl_shader_program
*shProg
654 = _mesa_lookup_shader_program(ctx
, program
);
656 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(program)");
659 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->InfoLog
);
664 get_shader_info_log(struct gl_context
*ctx
, GLuint shader
, GLsizei bufSize
,
665 GLsizei
*length
, GLchar
*infoLog
)
667 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
669 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(shader)");
672 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
677 * Return shader source code.
680 get_shader_source(struct gl_context
*ctx
, GLuint shader
, GLsizei maxLength
,
681 GLsizei
*length
, GLchar
*sourceOut
)
683 struct gl_shader
*sh
;
684 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
688 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
693 * Set/replace shader source code. A helper function used by
694 * glShaderSource[ARB] and glCreateShaderProgramEXT.
697 shader_source(struct gl_context
*ctx
, GLuint shader
, const GLchar
*source
)
699 struct gl_shader
*sh
;
701 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glShaderSource");
705 /* free old shader source string and install new one */
707 free((void *) sh
->Source
);
710 sh
->CompileStatus
= GL_FALSE
;
712 sh
->SourceChecksum
= _mesa_str_checksum(sh
->Source
);
721 compile_shader(struct gl_context
*ctx
, GLuint shaderObj
)
723 struct gl_shader
*sh
;
724 struct gl_shader_compiler_options
*options
;
726 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glCompileShader");
730 options
= &ctx
->ShaderCompilerOptions
[_mesa_shader_type_to_index(sh
->Type
)];
732 /* set default pragma state for shader */
733 sh
->Pragmas
= options
->DefaultPragmas
;
735 /* this call will set the sh->CompileStatus field to indicate if
736 * compilation was successful.
738 _mesa_glsl_compile_shader(ctx
, sh
);
740 if (sh
->CompileStatus
== GL_FALSE
&&
741 (ctx
->Shader
.Flags
& GLSL_REPORT_ERRORS
)) {
742 _mesa_debug(ctx
, "Error compiling shader %u:\n%s\n",
743 sh
->Name
, sh
->InfoLog
);
749 * Link a program's shaders.
752 link_program(struct gl_context
*ctx
, GLuint program
)
754 struct gl_shader_program
*shProg
;
755 struct gl_transform_feedback_object
*obj
=
756 ctx
->TransformFeedback
.CurrentObject
;
758 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glLinkProgram");
763 && (shProg
== ctx
->Shader
.CurrentVertexProgram
764 || shProg
== ctx
->Shader
.CurrentGeometryProgram
765 || shProg
== ctx
->Shader
.CurrentFragmentProgram
)) {
766 _mesa_error(ctx
, GL_INVALID_OPERATION
,
767 "glLinkProgram(transform feedback active)");
771 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
773 _mesa_glsl_link_shader(ctx
, shProg
);
775 if (shProg
->LinkStatus
== GL_FALSE
&&
776 (ctx
->Shader
.Flags
& GLSL_REPORT_ERRORS
)) {
777 _mesa_debug(ctx
, "Error linking program %u:\n%s\n",
778 shProg
->Name
, shProg
->InfoLog
);
785 printf("Link %u shaders in program %u: %s\n",
786 shProg
->NumShaders
, shProg
->Name
,
787 shProg
->LinkStatus
? "Success" : "Failed");
789 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
790 printf(" shader %u, type 0x%x\n",
791 shProg
->Shaders
[i
]->Name
,
792 shProg
->Shaders
[i
]->Type
);
799 * Print basic shader info (for debug).
802 print_shader_info(const struct gl_shader_program
*shProg
)
806 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
807 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
809 switch (shProg
->Shaders
[i
]->Type
) {
810 case GL_VERTEX_SHADER
:
813 case GL_FRAGMENT_SHADER
:
816 case GL_GEOMETRY_SHADER
:
822 printf(" %s shader %u, checksum %u\n", s
,
823 shProg
->Shaders
[i
]->Name
,
824 shProg
->Shaders
[i
]->SourceChecksum
);
826 if (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
])
827 printf(" vert prog %u\n",
828 shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
]->Program
->Id
);
829 if (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
])
830 printf(" frag prog %u\n",
831 shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
->Id
);
832 if (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
])
833 printf(" geom prog %u\n",
834 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->Program
->Id
);
839 * Use the named shader program for subsequent glUniform calls
842 _mesa_active_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
845 if ((shProg
!= NULL
) && !shProg
->LinkStatus
) {
846 _mesa_error(ctx
, GL_INVALID_OPERATION
,
847 "%s(program %u not linked)", caller
, shProg
->Name
);
851 if (ctx
->Shader
.ActiveProgram
!= shProg
) {
852 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, shProg
);
859 use_shader_program(struct gl_context
*ctx
, GLenum type
,
860 struct gl_shader_program
*shProg
)
862 struct gl_shader_program
**target
;
865 #if FEATURE_ARB_vertex_shader
866 case GL_VERTEX_SHADER
:
867 target
= &ctx
->Shader
.CurrentVertexProgram
;
869 || (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
] == NULL
)) {
874 #if FEATURE_ARB_geometry_shader4
875 case GL_GEOMETRY_SHADER_ARB
:
876 target
= &ctx
->Shader
.CurrentGeometryProgram
;
878 || (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
] == NULL
)) {
883 #if FEATURE_ARB_fragment_shader
884 case GL_FRAGMENT_SHADER
:
885 target
= &ctx
->Shader
.CurrentFragmentProgram
;
887 || (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
] == NULL
)) {
896 if (*target
!= shProg
) {
897 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
899 /* If the shader is also bound as the current rendering shader, unbind
900 * it from that binding point as well. This ensures that the correct
901 * semantics of glDeleteProgram are maintained.
904 #if FEATURE_ARB_vertex_shader
905 case GL_VERTEX_SHADER
:
909 #if FEATURE_ARB_geometry_shader4
910 case GL_GEOMETRY_SHADER_ARB
:
914 #if FEATURE_ARB_fragment_shader
915 case GL_FRAGMENT_SHADER
:
916 if (*target
== ctx
->Shader
._CurrentFragmentProgram
) {
917 _mesa_reference_shader_program(ctx
,
918 &ctx
->Shader
._CurrentFragmentProgram
,
925 _mesa_reference_shader_program(ctx
, target
, shProg
);
933 * Use the named shader program for subsequent rendering.
936 _mesa_use_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
938 use_shader_program(ctx
, GL_VERTEX_SHADER
, shProg
);
939 use_shader_program(ctx
, GL_GEOMETRY_SHADER_ARB
, shProg
);
940 use_shader_program(ctx
, GL_FRAGMENT_SHADER
, shProg
);
941 _mesa_active_program(ctx
, shProg
, "glUseProgram");
943 if (ctx
->Driver
.UseProgram
)
944 ctx
->Driver
.UseProgram(ctx
, shProg
);
949 * Do validation of the given shader program.
950 * \param errMsg returns error message if validation fails.
951 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
954 validate_shader_program(const struct gl_shader_program
*shProg
,
957 if (!shProg
->LinkStatus
) {
961 /* From the GL spec, a program is invalid if any of these are true:
963 any two active samplers in the current program object are of
964 different types, but refer to the same texture image unit,
966 any active sampler in the current program object refers to a texture
967 image unit where fixed-function fragment processing accesses a
968 texture target that does not match the sampler type, or
970 the sum of the number of active samplers in the program and the
971 number of texture image units enabled for fixed-function fragment
972 processing exceeds the combined limit on the total number of texture
978 * Check: any two active samplers in the current program object are of
979 * different types, but refer to the same texture image unit,
981 if (!_mesa_sampler_uniforms_are_valid(shProg
, errMsg
, 100))
989 * Called via glValidateProgram()
992 validate_program(struct gl_context
*ctx
, GLuint program
)
994 struct gl_shader_program
*shProg
;
995 char errMsg
[100] = "";
997 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1002 shProg
->Validated
= validate_shader_program(shProg
, errMsg
);
1003 if (!shProg
->Validated
) {
1004 /* update info log */
1005 if (shProg
->InfoLog
) {
1006 ralloc_free(shProg
->InfoLog
);
1008 shProg
->InfoLog
= ralloc_strdup(shProg
, errMsg
);
1015 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1017 GET_CURRENT_CONTEXT(ctx
);
1018 attach_shader(ctx
, program
, shader
);
1023 _mesa_AttachShader(GLuint program
, GLuint shader
)
1025 GET_CURRENT_CONTEXT(ctx
);
1026 attach_shader(ctx
, program
, shader
);
1031 _mesa_CompileShaderARB(GLhandleARB shaderObj
)
1033 GET_CURRENT_CONTEXT(ctx
);
1034 if (MESA_VERBOSE
& VERBOSE_API
)
1035 _mesa_debug(ctx
, "glCompileShader %u\n", shaderObj
);
1036 compile_shader(ctx
, shaderObj
);
1041 _mesa_CreateShader(GLenum type
)
1043 GET_CURRENT_CONTEXT(ctx
);
1044 if (MESA_VERBOSE
& VERBOSE_API
)
1045 _mesa_debug(ctx
, "glCreateShader %s\n", _mesa_lookup_enum_by_nr(type
));
1046 return create_shader(ctx
, type
);
1050 GLhandleARB GLAPIENTRY
1051 _mesa_CreateShaderObjectARB(GLenum type
)
1053 GET_CURRENT_CONTEXT(ctx
);
1054 return create_shader(ctx
, type
);
1059 _mesa_CreateProgram(void)
1061 GET_CURRENT_CONTEXT(ctx
);
1062 if (MESA_VERBOSE
& VERBOSE_API
)
1063 _mesa_debug(ctx
, "glCreateProgram\n");
1064 return create_shader_program(ctx
);
1068 GLhandleARB GLAPIENTRY
1069 _mesa_CreateProgramObjectARB(void)
1071 GET_CURRENT_CONTEXT(ctx
);
1072 return create_shader_program(ctx
);
1077 _mesa_DeleteObjectARB(GLhandleARB obj
)
1079 if (MESA_VERBOSE
& VERBOSE_API
) {
1080 GET_CURRENT_CONTEXT(ctx
);
1081 _mesa_debug(ctx
, "glDeleteObjectARB(%u)\n", obj
);
1085 GET_CURRENT_CONTEXT(ctx
);
1086 FLUSH_VERTICES(ctx
, 0);
1087 if (is_program(ctx
, obj
)) {
1088 delete_shader_program(ctx
, obj
);
1090 else if (is_shader(ctx
, obj
)) {
1091 delete_shader(ctx
, obj
);
1101 _mesa_DeleteProgram(GLuint name
)
1104 GET_CURRENT_CONTEXT(ctx
);
1105 FLUSH_VERTICES(ctx
, 0);
1106 delete_shader_program(ctx
, name
);
1112 _mesa_DeleteShader(GLuint name
)
1115 GET_CURRENT_CONTEXT(ctx
);
1116 FLUSH_VERTICES(ctx
, 0);
1117 delete_shader(ctx
, name
);
1123 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1125 GET_CURRENT_CONTEXT(ctx
);
1126 detach_shader(ctx
, program
, shader
);
1131 _mesa_DetachShader(GLuint program
, GLuint shader
)
1133 GET_CURRENT_CONTEXT(ctx
);
1134 detach_shader(ctx
, program
, shader
);
1139 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1140 GLsizei
* count
, GLhandleARB
* obj
)
1142 GET_CURRENT_CONTEXT(ctx
);
1143 get_attached_shaders(ctx
, container
, maxCount
, count
, obj
);
1148 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1149 GLsizei
*count
, GLuint
*obj
)
1151 GET_CURRENT_CONTEXT(ctx
);
1152 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
);
1157 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1158 GLcharARB
* infoLog
)
1160 GET_CURRENT_CONTEXT(ctx
);
1161 if (is_program(ctx
, object
)) {
1162 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1164 else if (is_shader(ctx
, object
)) {
1165 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1168 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1174 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1176 GET_CURRENT_CONTEXT(ctx
);
1177 /* Implement in terms of GetProgramiv, GetShaderiv */
1178 if (is_program(ctx
, object
)) {
1179 if (pname
== GL_OBJECT_TYPE_ARB
) {
1180 *params
= GL_PROGRAM_OBJECT_ARB
;
1183 get_programiv(ctx
, object
, pname
, params
);
1186 else if (is_shader(ctx
, object
)) {
1187 if (pname
== GL_OBJECT_TYPE_ARB
) {
1188 *params
= GL_SHADER_OBJECT_ARB
;
1191 get_shaderiv(ctx
, object
, pname
, params
);
1195 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1201 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1204 GLint iparams
[1]; /* XXX is one element enough? */
1205 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1206 params
[0] = (GLfloat
) iparams
[0];
1211 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1213 GET_CURRENT_CONTEXT(ctx
);
1214 get_programiv(ctx
, program
, pname
, params
);
1219 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1221 GET_CURRENT_CONTEXT(ctx
);
1222 get_shaderiv(ctx
, shader
, pname
, params
);
1227 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1228 GLsizei
*length
, GLchar
*infoLog
)
1230 GET_CURRENT_CONTEXT(ctx
);
1231 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1236 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1237 GLsizei
*length
, GLchar
*infoLog
)
1239 GET_CURRENT_CONTEXT(ctx
);
1240 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1245 _mesa_GetShaderSourceARB(GLhandleARB shader
, GLsizei maxLength
,
1246 GLsizei
*length
, GLcharARB
*sourceOut
)
1248 GET_CURRENT_CONTEXT(ctx
);
1249 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1253 GLhandleARB GLAPIENTRY
1254 _mesa_GetHandleARB(GLenum pname
)
1256 GET_CURRENT_CONTEXT(ctx
);
1257 return get_handle(ctx
, pname
);
1261 GLboolean GLAPIENTRY
1262 _mesa_IsProgram(GLuint name
)
1264 GET_CURRENT_CONTEXT(ctx
);
1265 return is_program(ctx
, name
);
1269 GLboolean GLAPIENTRY
1270 _mesa_IsShader(GLuint name
)
1272 GET_CURRENT_CONTEXT(ctx
);
1273 return is_shader(ctx
, name
);
1278 _mesa_LinkProgramARB(GLhandleARB programObj
)
1280 GET_CURRENT_CONTEXT(ctx
);
1281 link_program(ctx
, programObj
);
1287 * Read shader source code from a file.
1288 * Useful for debugging to override an app's shader.
1291 read_shader(const char *fname
)
1293 const int max
= 50*1000;
1294 FILE *f
= fopen(fname
, "r");
1295 GLcharARB
*buffer
, *shader
;
1302 buffer
= (char *) malloc(max
);
1303 len
= fread(buffer
, 1, max
, f
);
1308 shader
= _mesa_strdup(buffer
);
1316 * Called via glShaderSource() and glShaderSourceARB() API functions.
1317 * Basically, concatenate the source code strings into one long string
1318 * and pass it to _mesa_shader_source().
1321 _mesa_ShaderSourceARB(GLhandleARB shaderObj
, GLsizei count
,
1322 const GLcharARB
** string
, const GLint
* length
)
1324 GET_CURRENT_CONTEXT(ctx
);
1326 GLsizei i
, totalLength
;
1330 if (!shaderObj
|| string
== NULL
) {
1331 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
1336 * This array holds offsets of where the appropriate string ends, thus the
1337 * last element will be set to the total length of the source code.
1339 offsets
= (GLint
*) malloc(count
* sizeof(GLint
));
1340 if (offsets
== NULL
) {
1341 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1345 for (i
= 0; i
< count
; i
++) {
1346 if (string
[i
] == NULL
) {
1347 free((GLvoid
*) offsets
);
1348 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1349 "glShaderSourceARB(null string)");
1352 if (length
== NULL
|| length
[i
] < 0)
1353 offsets
[i
] = strlen(string
[i
]);
1355 offsets
[i
] = length
[i
];
1356 /* accumulate string lengths */
1358 offsets
[i
] += offsets
[i
- 1];
1361 /* Total length of source string is sum off all strings plus two.
1362 * One extra byte for terminating zero, another extra byte to silence
1363 * valgrind warnings in the parser/grammer code.
1365 totalLength
= offsets
[count
- 1] + 2;
1366 source
= (GLcharARB
*) malloc(totalLength
* sizeof(GLcharARB
));
1367 if (source
== NULL
) {
1368 free((GLvoid
*) offsets
);
1369 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1373 for (i
= 0; i
< count
; i
++) {
1374 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
1375 memcpy(source
+ start
, string
[i
],
1376 (offsets
[i
] - start
) * sizeof(GLcharARB
));
1378 source
[totalLength
- 1] = '\0';
1379 source
[totalLength
- 2] = '\0';
1382 /* Compute the shader's source code checksum then try to open a file
1383 * named newshader_<CHECKSUM>. If it exists, use it in place of the
1384 * original shader source code. For debugging.
1387 GLcharARB
*newSource
;
1389 checksum
= _mesa_str_checksum(source
);
1391 _mesa_snprintf(filename
, sizeof(filename
), "newshader_%d", checksum
);
1393 newSource
= read_shader(filename
);
1395 fprintf(stderr
, "Mesa: Replacing shader %u chksum=%d with %s\n",
1396 shaderObj
, checksum
, filename
);
1402 shader_source(ctx
, shaderObj
, source
);
1405 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shaderObj
);
1407 sh
->SourceChecksum
= checksum
; /* save original checksum */
1415 _mesa_UseProgramObjectARB(GLhandleARB program
)
1417 GET_CURRENT_CONTEXT(ctx
);
1418 struct gl_shader_program
*shProg
;
1419 struct gl_transform_feedback_object
*obj
=
1420 ctx
->TransformFeedback
.CurrentObject
;
1422 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1424 if (obj
->Active
&& !obj
->Paused
) {
1425 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1426 "glUseProgram(transform feedback active)");
1431 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
1435 if (!shProg
->LinkStatus
) {
1436 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1437 "glUseProgram(program %u not linked)", program
);
1442 if (ctx
->Shader
.Flags
& GLSL_USE_PROG
) {
1443 print_shader_info(shProg
);
1450 _mesa_use_program(ctx
, shProg
);
1455 _mesa_ValidateProgramARB(GLhandleARB program
)
1457 GET_CURRENT_CONTEXT(ctx
);
1458 validate_program(ctx
, program
);
1464 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
1465 GLint
* range
, GLint
* precision
)
1467 const struct gl_program_constants
*limits
;
1468 const struct gl_precision
*p
;
1469 GET_CURRENT_CONTEXT(ctx
);
1471 switch (shadertype
) {
1472 case GL_VERTEX_SHADER
:
1473 limits
= &ctx
->Const
.VertexProgram
;
1475 case GL_FRAGMENT_SHADER
:
1476 limits
= &ctx
->Const
.FragmentProgram
;
1479 _mesa_error(ctx
, GL_INVALID_ENUM
,
1480 "glGetShaderPrecisionFormat(shadertype)");
1484 switch (precisiontype
) {
1486 p
= &limits
->LowFloat
;
1488 case GL_MEDIUM_FLOAT
:
1489 p
= &limits
->MediumFloat
;
1492 p
= &limits
->HighFloat
;
1495 p
= &limits
->LowInt
;
1498 p
= &limits
->MediumInt
;
1501 p
= &limits
->HighInt
;
1504 _mesa_error(ctx
, GL_INVALID_ENUM
,
1505 "glGetShaderPrecisionFormat(precisiontype)");
1509 range
[0] = p
->RangeMin
;
1510 range
[1] = p
->RangeMax
;
1511 precision
[0] = p
->Precision
;
1516 _mesa_ReleaseShaderCompiler(void)
1518 _mesa_destroy_shader_compiler_caches();
1523 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
1524 const void* binary
, GLint length
)
1526 GET_CURRENT_CONTEXT(ctx
);
1529 (void) binaryformat
;
1532 _mesa_error(ctx
, GL_INVALID_OPERATION
, __FUNCTION__
);
1535 #endif /* FEATURE_ES2 */
1538 #if FEATURE_ARB_geometry_shader4
1541 _mesa_ProgramParameteriARB(GLuint program
, GLenum pname
, GLint value
)
1543 struct gl_shader_program
*shProg
;
1544 GET_CURRENT_CONTEXT(ctx
);
1546 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1548 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
1549 "glProgramParameteri");
1554 case GL_GEOMETRY_VERTICES_OUT_ARB
:
1556 (unsigned) value
> ctx
->Const
.MaxGeometryOutputVertices
) {
1557 _mesa_error(ctx
, GL_INVALID_VALUE
,
1558 "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",
1562 shProg
->Geom
.VerticesOut
= value
;
1564 case GL_GEOMETRY_INPUT_TYPE_ARB
:
1568 case GL_LINES_ADJACENCY_ARB
:
1570 case GL_TRIANGLES_ADJACENCY_ARB
:
1571 shProg
->Geom
.InputType
= value
;
1574 _mesa_error(ctx
, GL_INVALID_VALUE
,
1575 "glProgramParameteri(geometry input type = %s",
1576 _mesa_lookup_enum_by_nr(value
));
1580 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
1584 case GL_TRIANGLE_STRIP
:
1585 shProg
->Geom
.OutputType
= value
;
1588 _mesa_error(ctx
, GL_INVALID_VALUE
,
1589 "glProgramParameteri(geometry output type = %s",
1590 _mesa_lookup_enum_by_nr(value
));
1595 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteriARB(pname=%s)",
1596 _mesa_lookup_enum_by_nr(pname
));
1604 _mesa_use_shader_program(struct gl_context
*ctx
, GLenum type
,
1605 struct gl_shader_program
*shProg
)
1607 use_shader_program(ctx
, type
, shProg
);
1609 if (ctx
->Driver
.UseProgram
)
1610 ctx
->Driver
.UseProgram(ctx
, shProg
);
1615 * For GL_EXT_separate_shader_objects
1618 _mesa_UseShaderProgramEXT(GLenum type
, GLuint program
)
1620 GET_CURRENT_CONTEXT(ctx
);
1621 struct gl_shader_program
*shProg
= NULL
;
1623 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1625 if (!validate_shader_target(ctx
, type
)) {
1626 _mesa_error(ctx
, GL_INVALID_ENUM
, "glUseShaderProgramEXT(type)");
1630 if (ctx
->TransformFeedback
.CurrentObject
->Active
&&
1631 !ctx
->TransformFeedback
.CurrentObject
->Paused
) {
1632 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1633 "glUseShaderProgramEXT(transform feedback is active)");
1638 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
1639 "glUseShaderProgramEXT");
1643 if (!shProg
->LinkStatus
) {
1644 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1645 "glUseShaderProgramEXT(program not linked)");
1650 _mesa_use_shader_program(ctx
, type
, shProg
);
1655 * For GL_EXT_separate_shader_objects
1658 _mesa_ActiveProgramEXT(GLuint program
)
1660 GET_CURRENT_CONTEXT(ctx
);
1661 struct gl_shader_program
*shProg
= (program
!= 0)
1662 ? _mesa_lookup_shader_program_err(ctx
, program
, "glActiveProgramEXT")
1665 _mesa_active_program(ctx
, shProg
, "glActiveProgramEXT");
1671 * For GL_EXT_separate_shader_objects
1674 _mesa_CreateShaderProgramEXT(GLenum type
, const GLchar
*string
)
1676 GET_CURRENT_CONTEXT(ctx
);
1677 const GLuint shader
= create_shader(ctx
, type
);
1681 shader_source(ctx
, shader
, _mesa_strdup(string
));
1682 compile_shader(ctx
, shader
);
1684 program
= create_shader_program(ctx
);
1686 struct gl_shader_program
*shProg
;
1687 struct gl_shader
*sh
;
1688 GLint compiled
= GL_FALSE
;
1690 shProg
= _mesa_lookup_shader_program(ctx
, program
);
1691 sh
= _mesa_lookup_shader(ctx
, shader
);
1693 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
1695 attach_shader(ctx
, program
, shader
);
1696 link_program(ctx
, program
);
1697 detach_shader(ctx
, program
, shader
);
1701 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
1702 append
-error
-to
-info
-log
;
1703 shProg
->LinkStatus
= GL_FALSE
;
1708 ralloc_strcat(&shProg
->InfoLog
, sh
->InfoLog
);
1711 delete_shader(ctx
, shader
);
1718 * Plug in shader-related functions into API dispatch table.
1721 _mesa_init_shader_dispatch(struct _glapi_table
*exec
)
1724 /* GL_ARB_vertex/fragment_shader */
1725 SET_DeleteObjectARB(exec
, _mesa_DeleteObjectARB
);
1726 SET_GetHandleARB(exec
, _mesa_GetHandleARB
);
1727 SET_DetachObjectARB(exec
, _mesa_DetachObjectARB
);
1728 SET_CreateShaderObjectARB(exec
, _mesa_CreateShaderObjectARB
);
1729 SET_ShaderSourceARB(exec
, _mesa_ShaderSourceARB
);
1730 SET_CompileShaderARB(exec
, _mesa_CompileShaderARB
);
1731 SET_CreateProgramObjectARB(exec
, _mesa_CreateProgramObjectARB
);
1732 SET_AttachObjectARB(exec
, _mesa_AttachObjectARB
);
1733 SET_LinkProgramARB(exec
, _mesa_LinkProgramARB
);
1734 SET_UseProgramObjectARB(exec
, _mesa_UseProgramObjectARB
);
1735 SET_ValidateProgramARB(exec
, _mesa_ValidateProgramARB
);
1736 SET_GetObjectParameterfvARB(exec
, _mesa_GetObjectParameterfvARB
);
1737 SET_GetObjectParameterivARB(exec
, _mesa_GetObjectParameterivARB
);
1738 SET_GetInfoLogARB(exec
, _mesa_GetInfoLogARB
);
1739 SET_GetAttachedObjectsARB(exec
, _mesa_GetAttachedObjectsARB
);
1740 SET_GetShaderSourceARB(exec
, _mesa_GetShaderSourceARB
);
1743 SET_AttachShader(exec
, _mesa_AttachShader
);
1744 SET_CreateProgram(exec
, _mesa_CreateProgram
);
1745 SET_CreateShader(exec
, _mesa_CreateShader
);
1746 SET_DeleteProgram(exec
, _mesa_DeleteProgram
);
1747 SET_DeleteShader(exec
, _mesa_DeleteShader
);
1748 SET_DetachShader(exec
, _mesa_DetachShader
);
1749 SET_GetAttachedShaders(exec
, _mesa_GetAttachedShaders
);
1750 SET_GetProgramiv(exec
, _mesa_GetProgramiv
);
1751 SET_GetProgramInfoLog(exec
, _mesa_GetProgramInfoLog
);
1752 SET_GetShaderiv(exec
, _mesa_GetShaderiv
);
1753 SET_GetShaderInfoLog(exec
, _mesa_GetShaderInfoLog
);
1754 SET_IsProgram(exec
, _mesa_IsProgram
);
1755 SET_IsShader(exec
, _mesa_IsShader
);
1757 #if FEATURE_ARB_vertex_shader
1758 SET_BindAttribLocationARB(exec
, _mesa_BindAttribLocationARB
);
1759 SET_GetActiveAttribARB(exec
, _mesa_GetActiveAttribARB
);
1760 SET_GetAttribLocationARB(exec
, _mesa_GetAttribLocationARB
);
1763 #if FEATURE_ARB_geometry_shader4
1764 SET_ProgramParameteriARB(exec
, _mesa_ProgramParameteriARB
);
1767 SET_UseShaderProgramEXT(exec
, _mesa_UseShaderProgramEXT
);
1768 SET_ActiveProgramEXT(exec
, _mesa_ActiveProgramEXT
);
1769 SET_CreateShaderProgramEXT(exec
, _mesa_CreateShaderProgramEXT
);
1771 /* GL_EXT_gpu_shader4 / GL 3.0 */
1772 SET_BindFragDataLocationEXT(exec
, _mesa_BindFragDataLocation
);
1773 SET_GetFragDataLocationEXT(exec
, _mesa_GetFragDataLocation
);
1775 /* GL_ARB_ES2_compatibility */
1776 SET_ReleaseShaderCompiler(exec
, _mesa_ReleaseShaderCompiler
);
1777 SET_GetShaderPrecisionFormat(exec
, _mesa_GetShaderPrecisionFormat
);
1779 /* GL_ARB_blend_func_extended */
1780 SET_BindFragDataLocationIndexed(exec
, _mesa_BindFragDataLocationIndexed
);
1781 SET_GetFragDataIndex(exec
, _mesa_GetFragDataIndex
);
1782 #endif /* FEATURE_GL */