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/shaderapi.h"
45 #include "main/shaderobj.h"
46 #include "program/program.h"
47 #include "program/prog_parameter.h"
48 #include "program/prog_uniform.h"
52 /** Define this to enable shader substitution (see below) */
53 #define SHADER_SUBST 0
57 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
60 get_shader_flags(void)
62 GLbitfield flags
= 0x0;
63 const char *env
= _mesa_getenv("MESA_GLSL");
66 if (strstr(env
, "dump"))
68 if (strstr(env
, "log"))
70 if (strstr(env
, "nopvert"))
71 flags
|= GLSL_NOP_VERT
;
72 if (strstr(env
, "nopfrag"))
73 flags
|= GLSL_NOP_FRAG
;
74 if (strstr(env
, "nopt"))
76 else if (strstr(env
, "opt"))
78 if (strstr(env
, "uniform"))
79 flags
|= GLSL_UNIFORMS
;
80 if (strstr(env
, "useprog"))
81 flags
|= GLSL_USE_PROG
;
89 * Initialize context's shader state.
92 _mesa_init_shader_state(GLcontext
*ctx
)
94 /* Device drivers may override these to control what kind of instructions
95 * are generated by the GLSL compiler.
97 ctx
->Shader
.EmitHighLevelInstructions
= GL_TRUE
;
98 ctx
->Shader
.EmitContReturn
= GL_TRUE
;
99 ctx
->Shader
.EmitCondCodes
= GL_FALSE
;
100 ctx
->Shader
.EmitComments
= GL_FALSE
;
101 ctx
->Shader
.EmitNoIfs
= GL_FALSE
;
102 ctx
->Shader
.Flags
= get_shader_flags();
104 /* Default pragma settings */
105 ctx
->Shader
.DefaultPragmas
.IgnoreOptimize
= GL_FALSE
;
106 ctx
->Shader
.DefaultPragmas
.IgnoreDebug
= GL_FALSE
;
107 ctx
->Shader
.DefaultPragmas
.Optimize
= GL_TRUE
;
108 ctx
->Shader
.DefaultPragmas
.Debug
= GL_FALSE
;
113 * Free the per-context shader-related state.
116 _mesa_free_shader_state(GLcontext
*ctx
)
118 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
, NULL
);
123 * Return the size of the given GLSL datatype, in floats (components).
126 _mesa_sizeof_glsl_type(GLenum type
)
135 case GL_SAMPLER_CUBE
:
136 case GL_SAMPLER_1D_SHADOW
:
137 case GL_SAMPLER_2D_SHADOW
:
138 case GL_SAMPLER_2D_RECT_ARB
:
139 case GL_SAMPLER_2D_RECT_SHADOW_ARB
:
140 case GL_SAMPLER_1D_ARRAY_EXT
:
141 case GL_SAMPLER_2D_ARRAY_EXT
:
142 case GL_SAMPLER_1D_ARRAY_SHADOW_EXT
:
143 case GL_SAMPLER_2D_ARRAY_SHADOW_EXT
:
144 case GL_SAMPLER_CUBE_SHADOW_EXT
:
148 case GL_UNSIGNED_INT_VEC2
:
153 case GL_UNSIGNED_INT_VEC3
:
158 case GL_UNSIGNED_INT_VEC4
:
162 case GL_FLOAT_MAT2x3
:
163 case GL_FLOAT_MAT2x4
:
164 return 8; /* two float[4] vectors */
166 case GL_FLOAT_MAT3x2
:
167 case GL_FLOAT_MAT3x4
:
168 return 12; /* three float[4] vectors */
170 case GL_FLOAT_MAT4x2
:
171 case GL_FLOAT_MAT4x3
:
172 return 16; /* four float[4] vectors */
174 _mesa_problem(NULL
, "Invalid type in _mesa_sizeof_glsl_type()");
181 * Copy string from <src> to <dst>, up to maxLength characters, returning
182 * length of <dst> in <length>.
183 * \param src the strings source
184 * \param maxLength max chars to copy
185 * \param length returns number of chars copied
186 * \param dst the string destination
189 _mesa_copy_string(GLchar
*dst
, GLsizei maxLength
,
190 GLsizei
*length
, const GLchar
*src
)
193 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
204 * Find the length of the longest transform feedback varying name
205 * which was specified with glTransformFeedbackVaryings().
208 longest_feedback_varying_name(const struct gl_shader_program
*shProg
)
212 for (i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++) {
213 GLint len
= strlen(shProg
->TransformFeedback
.VaryingNames
[i
]);
223 is_program(GLcontext
*ctx
, GLuint name
)
225 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
226 return shProg
? GL_TRUE
: GL_FALSE
;
231 is_shader(GLcontext
*ctx
, GLuint name
)
233 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
234 return shader
? GL_TRUE
: GL_FALSE
;
239 * Attach shader to a shader program.
242 attach_shader(GLcontext
*ctx
, GLuint program
, GLuint shader
)
244 struct gl_shader_program
*shProg
;
245 struct gl_shader
*sh
;
248 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glAttachShader");
252 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glAttachShader");
257 n
= shProg
->NumShaders
;
258 for (i
= 0; i
< n
; i
++) {
259 if (shProg
->Shaders
[i
] == sh
) {
260 /* The shader is already attched to this program. The
261 * GL_ARB_shader_objects spec says:
263 * "The error INVALID_OPERATION is generated by AttachObjectARB
264 * if <obj> is already attached to <containerObj>."
266 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glAttachShader");
272 shProg
->Shaders
= (struct gl_shader
**)
273 _mesa_realloc(shProg
->Shaders
,
274 n
* sizeof(struct gl_shader
*),
275 (n
+ 1) * sizeof(struct gl_shader
*));
276 if (!shProg
->Shaders
) {
277 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
282 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
283 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
284 shProg
->NumShaders
++;
289 get_attrib_location(GLcontext
*ctx
, GLuint program
, const GLchar
*name
)
291 struct gl_shader_program
*shProg
292 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttribLocation");
298 if (!shProg
->LinkStatus
) {
299 _mesa_error(ctx
, GL_INVALID_OPERATION
,
300 "glGetAttribLocation(program not linked)");
307 if (shProg
->VertexProgram
) {
308 const struct gl_program_parameter_list
*attribs
=
309 shProg
->VertexProgram
->Base
.Attributes
;
311 GLint i
= _mesa_lookup_parameter_index(attribs
, -1, name
);
313 return attribs
->Parameters
[i
].StateIndexes
[0];
322 bind_attrib_location(GLcontext
*ctx
, GLuint program
, GLuint index
,
325 struct gl_shader_program
*shProg
;
326 const GLint size
= -1; /* unknown size */
328 GLenum datatype
= GL_FLOAT_VEC4
;
330 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
331 "glBindAttribLocation");
339 if (strncmp(name
, "gl_", 3) == 0) {
340 _mesa_error(ctx
, GL_INVALID_OPERATION
,
341 "glBindAttribLocation(illegal name)");
345 if (index
>= ctx
->Const
.VertexProgram
.MaxAttribs
) {
346 _mesa_error(ctx
, GL_INVALID_VALUE
, "glBindAttribLocation(index)");
350 if (shProg
->LinkStatus
) {
351 /* get current index/location for the attribute */
352 oldIndex
= get_attrib_location(ctx
, program
, name
);
358 /* this will replace the current value if it's already in the list */
359 i
= _mesa_add_attribute(shProg
->Attributes
, name
, size
, datatype
, index
);
361 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glBindAttribLocation");
366 * Note that this attribute binding won't go into effect until
367 * glLinkProgram is called again.
373 create_shader(GLcontext
*ctx
, GLenum type
)
375 struct gl_shader
*sh
;
378 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
381 case GL_FRAGMENT_SHADER
:
382 case GL_VERTEX_SHADER
:
383 case GL_GEOMETRY_SHADER_ARB
:
384 sh
= ctx
->Driver
.NewShader(ctx
, name
, type
);
387 _mesa_error(ctx
, GL_INVALID_ENUM
, "CreateShader(type)");
391 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, sh
);
398 create_shader_program(GLcontext
*ctx
)
401 struct gl_shader_program
*shProg
;
403 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
405 shProg
= ctx
->Driver
.NewShaderProgram(ctx
, name
);
407 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, shProg
);
409 assert(shProg
->RefCount
== 1);
416 * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
420 delete_shader_program(GLcontext
*ctx
, GLuint name
)
423 * NOTE: deleting shaders/programs works a bit differently than
424 * texture objects (and buffer objects, etc). Shader/program
425 * handles/IDs exist in the hash table until the object is really
426 * deleted (refcount==0). With texture objects, the handle/ID is
427 * removed from the hash table in glDeleteTextures() while the tex
428 * object itself might linger until its refcount goes to zero.
430 struct gl_shader_program
*shProg
;
432 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
436 shProg
->DeletePending
= GL_TRUE
;
438 /* effectively, decr shProg's refcount */
439 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
444 delete_shader(GLcontext
*ctx
, GLuint shader
)
446 struct gl_shader
*sh
;
448 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
452 sh
->DeletePending
= GL_TRUE
;
454 /* effectively, decr sh's refcount */
455 _mesa_reference_shader(ctx
, &sh
, NULL
);
460 detach_shader(GLcontext
*ctx
, GLuint program
, GLuint shader
)
462 struct gl_shader_program
*shProg
;
466 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
470 n
= shProg
->NumShaders
;
472 for (i
= 0; i
< n
; i
++) {
473 if (shProg
->Shaders
[i
]->Name
== shader
) {
475 struct gl_shader
**newList
;
478 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
480 /* alloc new, smaller array */
481 newList
= (struct gl_shader
**)
482 malloc((n
- 1) * sizeof(struct gl_shader
*));
484 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
487 for (j
= 0; j
< i
; j
++) {
488 newList
[j
] = shProg
->Shaders
[j
];
491 newList
[j
++] = shProg
->Shaders
[i
];
492 free(shProg
->Shaders
);
494 shProg
->Shaders
= newList
;
495 shProg
->NumShaders
= n
- 1;
500 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
501 assert(shProg
->Shaders
[j
]->Type
== GL_VERTEX_SHADER
||
502 shProg
->Shaders
[j
]->Type
== GL_FRAGMENT_SHADER
);
503 assert(shProg
->Shaders
[j
]->RefCount
> 0);
515 if (is_shader(ctx
, shader
))
516 err
= GL_INVALID_OPERATION
;
517 else if (is_program(ctx
, shader
))
518 err
= GL_INVALID_OPERATION
;
520 err
= GL_INVALID_VALUE
;
521 _mesa_error(ctx
, err
, "glDetachProgram(shader)");
528 get_active_attrib(GLcontext
*ctx
, GLuint program
, GLuint index
,
529 GLsizei maxLength
, GLsizei
*length
, GLint
*size
,
530 GLenum
*type
, GLchar
*nameOut
)
532 const struct gl_program_parameter_list
*attribs
= NULL
;
533 struct gl_shader_program
*shProg
;
535 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetActiveAttrib");
539 if (shProg
->VertexProgram
)
540 attribs
= shProg
->VertexProgram
->Base
.Attributes
;
542 if (!attribs
|| index
>= attribs
->NumParameters
) {
543 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetActiveAttrib(index)");
547 _mesa_copy_string(nameOut
, maxLength
, length
,
548 attribs
->Parameters
[index
].Name
);
551 *size
= attribs
->Parameters
[index
].Size
552 / _mesa_sizeof_glsl_type(attribs
->Parameters
[index
].DataType
);
555 *type
= attribs
->Parameters
[index
].DataType
;
560 * Return list of shaders attached to shader program.
563 get_attached_shaders(GLcontext
*ctx
, GLuint program
, GLsizei maxCount
,
564 GLsizei
*count
, GLuint
*obj
)
566 struct gl_shader_program
*shProg
=
567 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
570 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
571 obj
[i
] = shProg
->Shaders
[i
]->Name
;
580 * glGetHandleARB() - return ID/name of currently bound shader program.
583 get_handle(GLcontext
*ctx
, GLenum pname
)
585 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
586 if (ctx
->Shader
.CurrentProgram
)
587 return ctx
->Shader
.CurrentProgram
->Name
;
592 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
599 * glGetProgramiv() - get shader program state.
600 * Note that this is for GLSL shader programs, not ARB vertex/fragment
601 * programs (see glGetProgramivARB).
604 get_programiv(GLcontext
*ctx
, GLuint program
, GLenum pname
, GLint
*params
)
606 const struct gl_program_parameter_list
*attribs
;
607 struct gl_shader_program
*shProg
608 = _mesa_lookup_shader_program(ctx
, program
);
611 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramiv(program)");
615 if (shProg
->VertexProgram
)
616 attribs
= shProg
->VertexProgram
->Base
.Attributes
;
621 case GL_DELETE_STATUS
:
622 *params
= shProg
->DeletePending
;
625 *params
= shProg
->LinkStatus
;
627 case GL_VALIDATE_STATUS
:
628 *params
= shProg
->Validated
;
630 case GL_INFO_LOG_LENGTH
:
631 *params
= shProg
->InfoLog
? strlen(shProg
->InfoLog
) + 1 : 0;
633 case GL_ATTACHED_SHADERS
:
634 *params
= shProg
->NumShaders
;
636 case GL_ACTIVE_ATTRIBUTES
:
637 *params
= attribs
? attribs
->NumParameters
: 0;
639 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
640 *params
= _mesa_longest_parameter_name(attribs
, PROGRAM_INPUT
) + 1;
642 case GL_ACTIVE_UNIFORMS
:
643 *params
= shProg
->Uniforms
? shProg
->Uniforms
->NumUniforms
: 0;
645 case GL_ACTIVE_UNIFORM_MAX_LENGTH
:
646 *params
= _mesa_longest_uniform_name(shProg
->Uniforms
);
648 case GL_PROGRAM_BINARY_LENGTH_OES
:
651 #if FEATURE_EXT_transform_feedback
652 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
653 *params
= shProg
->TransformFeedback
.NumVarying
;
655 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
:
656 *params
= longest_feedback_varying_name(shProg
) + 1;
658 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
659 *params
= shProg
->TransformFeedback
.BufferMode
;
662 #if FEATURE_ARB_geometry_shader4
663 case GL_GEOMETRY_VERTICES_OUT_ARB
:
664 *params
= shProg
->Geom
.VerticesOut
;
666 case GL_GEOMETRY_INPUT_TYPE_ARB
:
667 *params
= shProg
->Geom
.InputType
;
669 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
670 *params
= shProg
->Geom
.OutputType
;
674 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname)");
681 * glGetShaderiv() - get GLSL shader state
684 get_shaderiv(GLcontext
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
686 struct gl_shader
*shader
=
687 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
695 *params
= shader
->Type
;
697 case GL_DELETE_STATUS
:
698 *params
= shader
->DeletePending
;
700 case GL_COMPILE_STATUS
:
701 *params
= shader
->CompileStatus
;
703 case GL_INFO_LOG_LENGTH
:
704 *params
= shader
->InfoLog
? strlen(shader
->InfoLog
) + 1 : 0;
706 case GL_SHADER_SOURCE_LENGTH
:
707 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
710 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
717 get_program_info_log(GLcontext
*ctx
, GLuint program
, GLsizei bufSize
,
718 GLsizei
*length
, GLchar
*infoLog
)
720 struct gl_shader_program
*shProg
721 = _mesa_lookup_shader_program(ctx
, program
);
723 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(program)");
726 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->InfoLog
);
731 get_shader_info_log(GLcontext
*ctx
, GLuint shader
, GLsizei bufSize
,
732 GLsizei
*length
, GLchar
*infoLog
)
734 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
736 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(shader)");
739 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
744 * Return shader source code.
747 get_shader_source(GLcontext
*ctx
, GLuint shader
, GLsizei maxLength
,
748 GLsizei
*length
, GLchar
*sourceOut
)
750 struct gl_shader
*sh
;
751 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
755 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
760 * Set/replace shader source code.
763 shader_source(GLcontext
*ctx
, GLuint shader
, const GLchar
*source
)
765 struct gl_shader
*sh
;
767 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glShaderSource");
771 /* free old shader source string and install new one */
773 free((void *) sh
->Source
);
776 sh
->CompileStatus
= GL_FALSE
;
778 sh
->SourceChecksum
= _mesa_str_checksum(sh
->Source
);
787 compile_shader(GLcontext
*ctx
, GLuint shaderObj
)
789 struct gl_shader
*sh
;
791 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glCompileShader");
795 /* set default pragma state for shader */
796 sh
->Pragmas
= ctx
->Shader
.DefaultPragmas
;
798 /* this call will set the sh->CompileStatus field to indicate if
799 * compilation was successful.
801 _mesa_glsl_compile_shader(ctx
, sh
);
806 * Link a program's shaders.
809 link_program(GLcontext
*ctx
, GLuint program
)
811 struct gl_shader_program
*shProg
;
812 struct gl_transform_feedback_object
*obj
=
813 ctx
->TransformFeedback
.CurrentObject
;
815 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glLinkProgram");
819 if (obj
->Active
&& shProg
== ctx
->Shader
.CurrentProgram
) {
820 _mesa_error(ctx
, GL_INVALID_OPERATION
,
821 "glLinkProgram(transform feedback active");
825 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
827 _mesa_glsl_link_shader(ctx
, shProg
);
833 printf("Link %u shaders in program %u: %s\n",
834 shProg
->NumShaders
, shProg
->Name
,
835 shProg
->LinkStatus
? "Success" : "Failed");
837 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
838 printf(" shader %u, type 0x%x\n",
839 shProg
->Shaders
[i
]->Name
,
840 shProg
->Shaders
[i
]->Type
);
847 * Print basic shader info (for debug).
850 print_shader_info(const struct gl_shader_program
*shProg
)
854 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
855 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
857 switch (shProg
->Shaders
[i
]->Type
) {
858 case GL_VERTEX_SHADER
:
861 case GL_FRAGMENT_SHADER
:
864 case GL_GEOMETRY_SHADER
:
870 printf(" %s shader %u, checksum %u\n", s
,
871 shProg
->Shaders
[i
]->Name
,
872 shProg
->Shaders
[i
]->SourceChecksum
);
874 if (shProg
->VertexProgram
)
875 printf(" vert prog %u\n", shProg
->VertexProgram
->Base
.Id
);
876 if (shProg
->FragmentProgram
)
877 printf(" frag prog %u\n", shProg
->FragmentProgram
->Base
.Id
);
882 * Use the named shader program for subsequent rendering.
885 _mesa_use_program(GLcontext
*ctx
, GLuint program
)
887 struct gl_shader_program
*shProg
;
888 struct gl_transform_feedback_object
*obj
=
889 ctx
->TransformFeedback
.CurrentObject
;
892 _mesa_error(ctx
, GL_INVALID_OPERATION
,
893 "glUseProgram(transform feedback active)");
897 if (ctx
->Shader
.CurrentProgram
&&
898 ctx
->Shader
.CurrentProgram
->Name
== program
) {
904 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
908 if (!shProg
->LinkStatus
) {
909 _mesa_error(ctx
, GL_INVALID_OPERATION
,
910 "glUseProgram(program %u not linked)", program
);
915 if (ctx
->Shader
.Flags
& GLSL_USE_PROG
) {
916 print_shader_info(shProg
);
923 if (ctx
->Shader
.CurrentProgram
!= shProg
) {
924 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
925 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
, shProg
);
928 if (ctx
->Driver
.UseProgram
)
929 ctx
->Driver
.UseProgram(ctx
, shProg
);
934 * Validate a program's samplers.
935 * Specifically, check that there aren't two samplers of different types
936 * pointing to the same texture unit.
937 * \return GL_TRUE if valid, GL_FALSE if invalid
940 validate_samplers(GLcontext
*ctx
, const struct gl_program
*prog
, char *errMsg
)
942 static const char *targetName
[] = {
951 GLint targetUsed
[MAX_TEXTURE_IMAGE_UNITS
];
952 GLbitfield samplersUsed
= prog
->SamplersUsed
;
955 assert(Elements(targetName
) == NUM_TEXTURE_TARGETS
);
957 if (samplersUsed
== 0x0)
960 for (i
= 0; i
< Elements(targetUsed
); i
++)
963 /* walk over bits which are set in 'samplers' */
964 while (samplersUsed
) {
966 gl_texture_index target
;
967 GLint sampler
= _mesa_ffs(samplersUsed
) - 1;
968 assert(sampler
>= 0);
969 assert(sampler
< MAX_TEXTURE_IMAGE_UNITS
);
970 unit
= prog
->SamplerUnits
[sampler
];
971 target
= prog
->SamplerTargets
[sampler
];
972 if (targetUsed
[unit
] != -1 && targetUsed
[unit
] != target
) {
973 _mesa_snprintf(errMsg
, 100,
974 "Texture unit %d is accessed both as %s and %s",
975 unit
, targetName
[targetUsed
[unit
]], targetName
[target
]);
978 targetUsed
[unit
] = target
;
979 samplersUsed
^= (1 << sampler
);
987 * Do validation of the given shader program.
988 * \param errMsg returns error message if validation fails.
989 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
992 validate_shader_program(GLcontext
*ctx
,
993 const struct gl_shader_program
*shProg
,
996 const struct gl_vertex_program
*vp
= shProg
->VertexProgram
;
997 const struct gl_fragment_program
*fp
= shProg
->FragmentProgram
;
999 if (!shProg
->LinkStatus
) {
1003 /* From the GL spec, a program is invalid if any of these are true:
1005 any two active samplers in the current program object are of
1006 different types, but refer to the same texture image unit,
1008 any active sampler in the current program object refers to a texture
1009 image unit where fixed-function fragment processing accesses a
1010 texture target that does not match the sampler type, or
1012 the sum of the number of active samplers in the program and the
1013 number of texture image units enabled for fixed-function fragment
1014 processing exceeds the combined limit on the total number of texture
1015 image units allowed.
1020 * Check: any two active samplers in the current program object are of
1021 * different types, but refer to the same texture image unit,
1023 if (vp
&& !validate_samplers(ctx
, &vp
->Base
, errMsg
)) {
1026 if (fp
&& !validate_samplers(ctx
, &fp
->Base
, errMsg
)) {
1035 * Called via glValidateProgram()
1038 validate_program(GLcontext
*ctx
, GLuint program
)
1040 struct gl_shader_program
*shProg
;
1043 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1048 shProg
->Validated
= validate_shader_program(ctx
, shProg
, errMsg
);
1049 if (!shProg
->Validated
) {
1050 /* update info log */
1051 if (shProg
->InfoLog
) {
1052 talloc_free(shProg
->InfoLog
);
1054 shProg
->InfoLog
= talloc_strdup(shProg
, errMsg
);
1061 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1063 GET_CURRENT_CONTEXT(ctx
);
1064 attach_shader(ctx
, program
, shader
);
1069 _mesa_AttachShader(GLuint program
, GLuint shader
)
1071 GET_CURRENT_CONTEXT(ctx
);
1072 attach_shader(ctx
, program
, shader
);
1077 _mesa_BindAttribLocationARB(GLhandleARB program
, GLuint index
,
1078 const GLcharARB
*name
)
1080 GET_CURRENT_CONTEXT(ctx
);
1081 bind_attrib_location(ctx
, program
, index
, name
);
1086 _mesa_CompileShaderARB(GLhandleARB shaderObj
)
1088 GET_CURRENT_CONTEXT(ctx
);
1089 compile_shader(ctx
, shaderObj
);
1094 _mesa_CreateShader(GLenum type
)
1096 GET_CURRENT_CONTEXT(ctx
);
1097 return create_shader(ctx
, type
);
1101 GLhandleARB GLAPIENTRY
1102 _mesa_CreateShaderObjectARB(GLenum type
)
1104 GET_CURRENT_CONTEXT(ctx
);
1105 return create_shader(ctx
, type
);
1110 _mesa_CreateProgram(void)
1112 GET_CURRENT_CONTEXT(ctx
);
1113 return create_shader_program(ctx
);
1117 GLhandleARB GLAPIENTRY
1118 _mesa_CreateProgramObjectARB(void)
1120 GET_CURRENT_CONTEXT(ctx
);
1121 return create_shader_program(ctx
);
1126 _mesa_DeleteObjectARB(GLhandleARB obj
)
1129 GET_CURRENT_CONTEXT(ctx
);
1130 if (is_program(ctx
, obj
)) {
1131 delete_shader_program(ctx
, obj
);
1133 else if (is_shader(ctx
, obj
)) {
1134 delete_shader(ctx
, obj
);
1144 _mesa_DeleteProgram(GLuint name
)
1147 GET_CURRENT_CONTEXT(ctx
);
1148 delete_shader_program(ctx
, name
);
1154 _mesa_DeleteShader(GLuint name
)
1157 GET_CURRENT_CONTEXT(ctx
);
1158 delete_shader(ctx
, name
);
1164 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1166 GET_CURRENT_CONTEXT(ctx
);
1167 detach_shader(ctx
, program
, shader
);
1172 _mesa_DetachShader(GLuint program
, GLuint shader
)
1174 GET_CURRENT_CONTEXT(ctx
);
1175 detach_shader(ctx
, program
, shader
);
1180 _mesa_GetActiveAttribARB(GLhandleARB program
, GLuint index
,
1181 GLsizei maxLength
, GLsizei
* length
, GLint
* size
,
1182 GLenum
* type
, GLcharARB
* name
)
1184 GET_CURRENT_CONTEXT(ctx
);
1185 get_active_attrib(ctx
, program
, index
, maxLength
, length
, size
, type
, name
);
1190 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1191 GLsizei
* count
, GLhandleARB
* obj
)
1193 GET_CURRENT_CONTEXT(ctx
);
1194 get_attached_shaders(ctx
, container
, maxCount
, count
, obj
);
1199 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1200 GLsizei
*count
, GLuint
*obj
)
1202 GET_CURRENT_CONTEXT(ctx
);
1203 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
);
1208 _mesa_GetAttribLocationARB(GLhandleARB program
, const GLcharARB
* name
)
1210 GET_CURRENT_CONTEXT(ctx
);
1211 return get_attrib_location(ctx
, program
, name
);
1216 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1217 GLcharARB
* infoLog
)
1219 GET_CURRENT_CONTEXT(ctx
);
1220 if (is_program(ctx
, object
)) {
1221 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1223 else if (is_shader(ctx
, object
)) {
1224 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1227 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1233 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1235 GET_CURRENT_CONTEXT(ctx
);
1236 /* Implement in terms of GetProgramiv, GetShaderiv */
1237 if (is_program(ctx
, object
)) {
1238 if (pname
== GL_OBJECT_TYPE_ARB
) {
1239 *params
= GL_PROGRAM_OBJECT_ARB
;
1242 get_programiv(ctx
, object
, pname
, params
);
1245 else if (is_shader(ctx
, object
)) {
1246 if (pname
== GL_OBJECT_TYPE_ARB
) {
1247 *params
= GL_SHADER_OBJECT_ARB
;
1250 get_shaderiv(ctx
, object
, pname
, params
);
1254 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1260 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1263 GLint iparams
[1]; /* XXX is one element enough? */
1264 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1265 params
[0] = (GLfloat
) iparams
[0];
1270 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1272 GET_CURRENT_CONTEXT(ctx
);
1273 get_programiv(ctx
, program
, pname
, params
);
1278 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1280 GET_CURRENT_CONTEXT(ctx
);
1281 get_shaderiv(ctx
, shader
, pname
, params
);
1286 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1287 GLsizei
*length
, GLchar
*infoLog
)
1289 GET_CURRENT_CONTEXT(ctx
);
1290 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1295 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1296 GLsizei
*length
, GLchar
*infoLog
)
1298 GET_CURRENT_CONTEXT(ctx
);
1299 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1304 _mesa_GetShaderSourceARB(GLhandleARB shader
, GLsizei maxLength
,
1305 GLsizei
*length
, GLcharARB
*sourceOut
)
1307 GET_CURRENT_CONTEXT(ctx
);
1308 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1312 GLhandleARB GLAPIENTRY
1313 _mesa_GetHandleARB(GLenum pname
)
1315 GET_CURRENT_CONTEXT(ctx
);
1316 return get_handle(ctx
, pname
);
1320 GLboolean GLAPIENTRY
1321 _mesa_IsProgram(GLuint name
)
1323 GET_CURRENT_CONTEXT(ctx
);
1324 return is_program(ctx
, name
);
1328 GLboolean GLAPIENTRY
1329 _mesa_IsShader(GLuint name
)
1331 GET_CURRENT_CONTEXT(ctx
);
1332 return is_shader(ctx
, name
);
1337 _mesa_LinkProgramARB(GLhandleARB programObj
)
1339 GET_CURRENT_CONTEXT(ctx
);
1340 link_program(ctx
, programObj
);
1346 * Read shader source code from a file.
1347 * Useful for debugging to override an app's shader.
1350 read_shader(const char *fname
)
1352 const int max
= 50*1000;
1353 FILE *f
= fopen(fname
, "r");
1354 GLcharARB
*buffer
, *shader
;
1361 buffer
= (char *) malloc(max
);
1362 len
= fread(buffer
, 1, max
, f
);
1367 shader
= _mesa_strdup(buffer
);
1375 * Called via glShaderSource() and glShaderSourceARB() API functions.
1376 * Basically, concatenate the source code strings into one long string
1377 * and pass it to _mesa_shader_source().
1380 _mesa_ShaderSourceARB(GLhandleARB shaderObj
, GLsizei count
,
1381 const GLcharARB
** string
, const GLint
* length
)
1383 GET_CURRENT_CONTEXT(ctx
);
1385 GLsizei i
, totalLength
;
1389 if (!shaderObj
|| string
== NULL
) {
1390 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
1395 * This array holds offsets of where the appropriate string ends, thus the
1396 * last element will be set to the total length of the source code.
1398 offsets
= (GLint
*) malloc(count
* sizeof(GLint
));
1399 if (offsets
== NULL
) {
1400 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1404 for (i
= 0; i
< count
; i
++) {
1405 if (string
[i
] == NULL
) {
1406 free((GLvoid
*) offsets
);
1407 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glShaderSourceARB(null string)");
1410 if (length
== NULL
|| length
[i
] < 0)
1411 offsets
[i
] = strlen(string
[i
]);
1413 offsets
[i
] = length
[i
];
1414 /* accumulate string lengths */
1416 offsets
[i
] += offsets
[i
- 1];
1419 /* Total length of source string is sum off all strings plus two.
1420 * One extra byte for terminating zero, another extra byte to silence
1421 * valgrind warnings in the parser/grammer code.
1423 totalLength
= offsets
[count
- 1] + 2;
1424 source
= (GLcharARB
*) malloc(totalLength
* sizeof(GLcharARB
));
1425 if (source
== NULL
) {
1426 free((GLvoid
*) offsets
);
1427 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1431 for (i
= 0; i
< count
; i
++) {
1432 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
1433 memcpy(source
+ start
, string
[i
],
1434 (offsets
[i
] - start
) * sizeof(GLcharARB
));
1436 source
[totalLength
- 1] = '\0';
1437 source
[totalLength
- 2] = '\0';
1440 /* Compute the shader's source code checksum then try to open a file
1441 * named newshader_<CHECKSUM>. If it exists, use it in place of the
1442 * original shader source code. For debugging.
1445 GLcharARB
*newSource
;
1447 checksum
= _mesa_str_checksum(source
);
1449 _mesa_snprintf(filename
, sizeof(filename
), "newshader_%d", checksum
);
1451 newSource
= read_shader(filename
);
1453 fprintf(stderr
, "Mesa: Replacing shader %u chksum=%d with %s\n",
1454 shaderObj
, checksum
, filename
);
1460 shader_source(ctx
, shaderObj
, source
);
1463 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shaderObj
);
1465 sh
->SourceChecksum
= checksum
; /* save original checksum */
1473 _mesa_UseProgramObjectARB(GLhandleARB program
)
1475 GET_CURRENT_CONTEXT(ctx
);
1476 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1477 _mesa_use_program(ctx
, program
);
1482 _mesa_ValidateProgramARB(GLhandleARB program
)
1484 GET_CURRENT_CONTEXT(ctx
);
1485 validate_program(ctx
, program
);
1491 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
1492 GLint
* range
, GLint
* precision
)
1494 GET_CURRENT_CONTEXT(ctx
);
1495 _mesa_error(ctx
, GL_INVALID_OPERATION
, __FUNCTION__
);
1500 _mesa_ReleaseShaderCompiler(void)
1502 GET_CURRENT_CONTEXT(ctx
);
1503 _mesa_error(ctx
, GL_INVALID_OPERATION
, __FUNCTION__
);
1508 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
1509 const void* binary
, GLint length
)
1511 GET_CURRENT_CONTEXT(ctx
);
1512 _mesa_error(ctx
, GL_INVALID_OPERATION
, __FUNCTION__
);
1515 #endif /* FEATURE_ES2 */
1518 #if FEATURE_ARB_geometry_shader4
1521 _mesa_ProgramParameteriARB(GLuint program
, GLenum pname
,
1524 struct gl_shader_program
*shProg
;
1525 GET_CURRENT_CONTEXT(ctx
);
1527 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1529 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
1530 "glProgramParameteri");
1535 case GL_GEOMETRY_VERTICES_OUT_ARB
:
1537 value
> ctx
->Const
.GeometryProgram
.MaxGeometryOutputVertices
) {
1538 _mesa_error(ctx
, GL_INVALID_VALUE
,
1539 "glProgramParameteri(GL_GEOMETRY_VERTICES_OUT_ARB=%d",
1543 shProg
->Geom
.VerticesOut
= value
;
1545 case GL_GEOMETRY_INPUT_TYPE_ARB
:
1549 case GL_LINES_ADJACENCY_ARB
:
1551 case GL_TRIANGLES_ADJACENCY_ARB
:
1552 shProg
->Geom
.InputType
= value
;
1555 _mesa_error(ctx
, GL_INVALID_VALUE
,
1556 "glProgramParameteri(geometry input type = %s",
1557 _mesa_lookup_enum_by_nr(value
));
1561 case GL_GEOMETRY_OUTPUT_TYPE_ARB
:
1565 case GL_TRIANGLE_STRIP
:
1566 shProg
->Geom
.OutputType
= value
;
1569 _mesa_error(ctx
, GL_INVALID_VALUE
,
1570 "glProgramParameteri(geometry output type = %s",
1571 _mesa_lookup_enum_by_nr(value
));
1576 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteriARB(pname=%s)",
1577 _mesa_lookup_enum_by_nr(pname
));
1586 * Plug in shader-related functions into API dispatch table.
1589 _mesa_init_shader_dispatch(struct _glapi_table
*exec
)
1592 /* GL_ARB_vertex/fragment_shader */
1593 SET_DeleteObjectARB(exec
, _mesa_DeleteObjectARB
);
1594 SET_GetHandleARB(exec
, _mesa_GetHandleARB
);
1595 SET_DetachObjectARB(exec
, _mesa_DetachObjectARB
);
1596 SET_CreateShaderObjectARB(exec
, _mesa_CreateShaderObjectARB
);
1597 SET_ShaderSourceARB(exec
, _mesa_ShaderSourceARB
);
1598 SET_CompileShaderARB(exec
, _mesa_CompileShaderARB
);
1599 SET_CreateProgramObjectARB(exec
, _mesa_CreateProgramObjectARB
);
1600 SET_AttachObjectARB(exec
, _mesa_AttachObjectARB
);
1601 SET_LinkProgramARB(exec
, _mesa_LinkProgramARB
);
1602 SET_UseProgramObjectARB(exec
, _mesa_UseProgramObjectARB
);
1603 SET_ValidateProgramARB(exec
, _mesa_ValidateProgramARB
);
1604 SET_GetObjectParameterfvARB(exec
, _mesa_GetObjectParameterfvARB
);
1605 SET_GetObjectParameterivARB(exec
, _mesa_GetObjectParameterivARB
);
1606 SET_GetInfoLogARB(exec
, _mesa_GetInfoLogARB
);
1607 SET_GetAttachedObjectsARB(exec
, _mesa_GetAttachedObjectsARB
);
1608 SET_GetShaderSourceARB(exec
, _mesa_GetShaderSourceARB
);
1611 SET_AttachShader(exec
, _mesa_AttachShader
);
1612 SET_CreateProgram(exec
, _mesa_CreateProgram
);
1613 SET_CreateShader(exec
, _mesa_CreateShader
);
1614 SET_DeleteProgram(exec
, _mesa_DeleteProgram
);
1615 SET_DeleteShader(exec
, _mesa_DeleteShader
);
1616 SET_DetachShader(exec
, _mesa_DetachShader
);
1617 SET_GetAttachedShaders(exec
, _mesa_GetAttachedShaders
);
1618 SET_GetProgramiv(exec
, _mesa_GetProgramiv
);
1619 SET_GetProgramInfoLog(exec
, _mesa_GetProgramInfoLog
);
1620 SET_GetShaderiv(exec
, _mesa_GetShaderiv
);
1621 SET_GetShaderInfoLog(exec
, _mesa_GetShaderInfoLog
);
1622 SET_IsProgram(exec
, _mesa_IsProgram
);
1623 SET_IsShader(exec
, _mesa_IsShader
);
1625 #if FEATURE_ARB_vertex_shader
1626 SET_BindAttribLocationARB(exec
, _mesa_BindAttribLocationARB
);
1627 SET_GetActiveAttribARB(exec
, _mesa_GetActiveAttribARB
);
1628 SET_GetAttribLocationARB(exec
, _mesa_GetAttribLocationARB
);
1631 #if FEATURE_ARB_geometry_shader4
1632 SET_ProgramParameteriARB(exec
, _mesa_ProgramParameteriARB
);
1634 #endif /* FEATURE_GL */