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 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
23 * OTHER DEALINGS IN THE SOFTWARE.
30 * Implementation of GLSL-related API functions.
31 * The glUniform* functions are in uniforms.c
35 * 1. Check that the right error code is generated for all _mesa_error() calls.
36 * 2. Insert FLUSH_VERTICES calls in various places
41 #include "main/glheader.h"
42 #include "main/context.h"
43 #include "main/dispatch.h"
44 #include "main/enums.h"
45 #include "main/hash.h"
46 #include "main/mtypes.h"
47 #include "main/pipelineobj.h"
48 #include "main/program_binary.h"
49 #include "main/shaderapi.h"
50 #include "main/shaderobj.h"
51 #include "main/transformfeedback.h"
52 #include "main/uniforms.h"
53 #include "compiler/glsl/glsl_parser_extras.h"
54 #include "compiler/glsl/ir.h"
55 #include "compiler/glsl/ir_uniform.h"
56 #include "compiler/glsl/program.h"
57 #include "program/program.h"
58 #include "program/prog_print.h"
59 #include "program/prog_parameter.h"
60 #include "util/ralloc.h"
61 #include "util/hash_table.h"
62 #include "util/mesa-sha1.h"
63 #include "util/crc32.h"
66 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
69 _mesa_get_shader_flags(void)
71 GLbitfield flags
= 0x0;
72 const char *env
= getenv("MESA_GLSL");
75 if (strstr(env
, "dump_on_error"))
76 flags
|= GLSL_DUMP_ON_ERROR
;
77 else if (strstr(env
, "dump"))
79 if (strstr(env
, "log"))
81 if (strstr(env
, "cache_fb"))
82 flags
|= GLSL_CACHE_FALLBACK
;
83 if (strstr(env
, "cache_info"))
84 flags
|= GLSL_CACHE_INFO
;
85 if (strstr(env
, "nopvert"))
86 flags
|= GLSL_NOP_VERT
;
87 if (strstr(env
, "nopfrag"))
88 flags
|= GLSL_NOP_FRAG
;
89 if (strstr(env
, "uniform"))
90 flags
|= GLSL_UNIFORMS
;
91 if (strstr(env
, "useprog"))
92 flags
|= GLSL_USE_PROG
;
93 if (strstr(env
, "errors"))
94 flags
|= GLSL_REPORT_ERRORS
;
101 * Memoized version of getenv("MESA_SHADER_CAPTURE_PATH").
104 _mesa_get_shader_capture_path(void)
106 static bool read_env_var
= false;
107 static const char *path
= NULL
;
110 path
= getenv("MESA_SHADER_CAPTURE_PATH");
118 * Initialize context's shader state.
121 _mesa_init_shader_state(struct gl_context
*ctx
)
123 /* Device drivers may override these to control what kind of instructions
124 * are generated by the GLSL compiler.
126 struct gl_shader_compiler_options options
;
130 memset(&options
, 0, sizeof(options
));
131 options
.MaxUnrollIterations
= 32;
132 options
.MaxIfDepth
= UINT_MAX
;
134 for (sh
= 0; sh
< MESA_SHADER_STAGES
; ++sh
)
135 memcpy(&ctx
->Const
.ShaderCompilerOptions
[sh
], &options
, sizeof(options
));
137 ctx
->Shader
.Flags
= _mesa_get_shader_flags();
139 if (ctx
->Shader
.Flags
!= 0)
140 ctx
->Const
.GenerateTemporaryNames
= true;
142 /* Extended for ARB_separate_shader_objects */
143 ctx
->Shader
.RefCount
= 1;
144 ctx
->TessCtrlProgram
.patch_vertices
= 3;
145 for (i
= 0; i
< 4; ++i
)
146 ctx
->TessCtrlProgram
.patch_default_outer_level
[i
] = 1.0;
147 for (i
= 0; i
< 2; ++i
)
148 ctx
->TessCtrlProgram
.patch_default_inner_level
[i
] = 1.0;
153 * Free the per-context shader-related state.
156 _mesa_free_shader_state(struct gl_context
*ctx
)
158 for (int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
159 _mesa_reference_program(ctx
, &ctx
->Shader
.CurrentProgram
[i
], NULL
);
161 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, NULL
);
163 /* Extended for ARB_separate_shader_objects */
164 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, NULL
);
166 assert(ctx
->Shader
.RefCount
== 1);
171 * Copy string from <src> to <dst>, up to maxLength characters, returning
172 * length of <dst> in <length>.
173 * \param src the strings source
174 * \param maxLength max chars to copy
175 * \param length returns number of chars copied
176 * \param dst the string destination
179 _mesa_copy_string(GLchar
*dst
, GLsizei maxLength
,
180 GLsizei
*length
, const GLchar
*src
)
183 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
194 * Confirm that the a shader type is valid and supported by the implementation
196 * \param ctx Current GL context
197 * \param type Shader target
201 _mesa_validate_shader_target(const struct gl_context
*ctx
, GLenum type
)
203 /* Note: when building built-in GLSL functions, this function may be
204 * invoked with ctx == NULL. In that case, we can only validate that it's
205 * a shader target we recognize, not that it's supported in the current
206 * context. But that's fine--we don't need any further validation than
207 * that when building built-in GLSL functions.
211 case GL_FRAGMENT_SHADER
:
212 return ctx
== NULL
|| ctx
->Extensions
.ARB_fragment_shader
;
213 case GL_VERTEX_SHADER
:
214 return ctx
== NULL
|| ctx
->Extensions
.ARB_vertex_shader
;
215 case GL_GEOMETRY_SHADER_ARB
:
216 return ctx
== NULL
|| _mesa_has_geometry_shaders(ctx
);
217 case GL_TESS_CONTROL_SHADER
:
218 case GL_TESS_EVALUATION_SHADER
:
219 return ctx
== NULL
|| _mesa_has_tessellation(ctx
);
220 case GL_COMPUTE_SHADER
:
221 return ctx
== NULL
|| _mesa_has_compute_shaders(ctx
);
229 is_program(struct gl_context
*ctx
, GLuint name
)
231 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
232 return shProg
? GL_TRUE
: GL_FALSE
;
237 is_shader(struct gl_context
*ctx
, GLuint name
)
239 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
240 return shader
? GL_TRUE
: GL_FALSE
;
245 * Attach shader to a shader program.
248 attach_shader(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
249 struct gl_shader
*sh
)
251 GLuint n
= shProg
->NumShaders
;
253 shProg
->Shaders
= realloc(shProg
->Shaders
,
254 (n
+ 1) * sizeof(struct gl_shader
*));
255 if (!shProg
->Shaders
) {
256 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
261 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
262 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
263 shProg
->NumShaders
++;
267 attach_shader_err(struct gl_context
*ctx
, GLuint program
, GLuint shader
,
270 struct gl_shader_program
*shProg
;
271 struct gl_shader
*sh
;
274 const bool same_type_disallowed
= _mesa_is_gles(ctx
);
276 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, caller
);
280 sh
= _mesa_lookup_shader_err(ctx
, shader
, caller
);
285 n
= shProg
->NumShaders
;
286 for (i
= 0; i
< n
; i
++) {
287 if (shProg
->Shaders
[i
] == sh
) {
288 /* The shader is already attched to this program. The
289 * GL_ARB_shader_objects spec says:
291 * "The error INVALID_OPERATION is generated by AttachObjectARB
292 * if <obj> is already attached to <containerObj>."
294 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", caller
);
296 } else if (same_type_disallowed
&&
297 shProg
->Shaders
[i
]->Stage
== sh
->Stage
) {
298 /* Shader with the same type is already attached to this program,
299 * OpenGL ES 2.0 and 3.0 specs say:
301 * "Multiple shader objects of the same type may not be attached
302 * to a single program object. [...] The error INVALID_OPERATION
303 * is generated if [...] another shader object of the same type
304 * as shader is already attached to program."
306 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", caller
);
311 attach_shader(ctx
, shProg
, sh
);
315 attach_shader_no_error(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
317 struct gl_shader_program
*shProg
;
318 struct gl_shader
*sh
;
320 shProg
= _mesa_lookup_shader_program(ctx
, program
);
321 sh
= _mesa_lookup_shader(ctx
, shader
);
323 attach_shader(ctx
, shProg
, sh
);
327 create_shader(struct gl_context
*ctx
, GLenum type
)
329 struct gl_shader
*sh
;
332 _mesa_HashLockMutex(ctx
->Shared
->ShaderObjects
);
333 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
334 sh
= _mesa_new_shader(name
, _mesa_shader_enum_to_shader_stage(type
));
336 _mesa_HashInsertLocked(ctx
->Shared
->ShaderObjects
, name
, sh
);
337 _mesa_HashUnlockMutex(ctx
->Shared
->ShaderObjects
);
344 create_shader_err(struct gl_context
*ctx
, GLenum type
, const char *caller
)
346 if (!_mesa_validate_shader_target(ctx
, type
)) {
347 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s(%s)",
348 caller
, _mesa_enum_to_string(type
));
352 return create_shader(ctx
, type
);
357 create_shader_program(struct gl_context
*ctx
)
360 struct gl_shader_program
*shProg
;
362 _mesa_HashLockMutex(ctx
->Shared
->ShaderObjects
);
364 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
366 shProg
= _mesa_new_shader_program(name
);
368 _mesa_HashInsertLocked(ctx
->Shared
->ShaderObjects
, name
, shProg
);
370 assert(shProg
->RefCount
== 1);
372 _mesa_HashUnlockMutex(ctx
->Shared
->ShaderObjects
);
379 * Delete a shader program. Actually, just decrement the program's
380 * reference count and mark it as DeletePending.
381 * Used to implement glDeleteProgram() and glDeleteObjectARB().
384 delete_shader_program(struct gl_context
*ctx
, GLuint name
)
387 * NOTE: deleting shaders/programs works a bit differently than
388 * texture objects (and buffer objects, etc). Shader/program
389 * handles/IDs exist in the hash table until the object is really
390 * deleted (refcount==0). With texture objects, the handle/ID is
391 * removed from the hash table in glDeleteTextures() while the tex
392 * object itself might linger until its refcount goes to zero.
394 struct gl_shader_program
*shProg
;
396 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
400 if (!shProg
->DeletePending
) {
401 shProg
->DeletePending
= GL_TRUE
;
403 /* effectively, decr shProg's refcount */
404 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
410 delete_shader(struct gl_context
*ctx
, GLuint shader
)
412 struct gl_shader
*sh
;
414 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
418 if (!sh
->DeletePending
) {
419 sh
->DeletePending
= GL_TRUE
;
421 /* effectively, decr sh's refcount */
422 _mesa_reference_shader(ctx
, &sh
, NULL
);
427 static ALWAYS_INLINE
void
428 detach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
,
431 struct gl_shader_program
*shProg
;
436 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
440 shProg
= _mesa_lookup_shader_program(ctx
, program
);
443 n
= shProg
->NumShaders
;
445 for (i
= 0; i
< n
; i
++) {
446 if (shProg
->Shaders
[i
]->Name
== shader
) {
448 struct gl_shader
**newList
;
451 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
453 /* alloc new, smaller array */
454 newList
= malloc((n
- 1) * sizeof(struct gl_shader
*));
456 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
459 /* Copy old list entries to new list, skipping removed entry at [i] */
460 for (j
= 0; j
< i
; j
++) {
461 newList
[j
] = shProg
->Shaders
[j
];
464 newList
[j
++] = shProg
->Shaders
[i
];
467 /* Free old list and install new one */
468 free(shProg
->Shaders
);
469 shProg
->Shaders
= newList
;
470 shProg
->NumShaders
= n
- 1;
473 /* sanity check - make sure the new list's entries are sensible */
474 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
475 assert(shProg
->Shaders
[j
]->Stage
== MESA_SHADER_VERTEX
||
476 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_TESS_CTRL
||
477 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_TESS_EVAL
||
478 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_GEOMETRY
||
479 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_FRAGMENT
);
480 assert(shProg
->Shaders
[j
]->RefCount
> 0);
491 if (is_shader(ctx
, shader
) || is_program(ctx
, shader
))
492 err
= GL_INVALID_OPERATION
;
494 err
= GL_INVALID_VALUE
;
495 _mesa_error(ctx
, err
, "glDetachShader(shader)");
502 detach_shader_error(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
504 detach_shader(ctx
, program
, shader
, false);
509 detach_shader_no_error(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
511 detach_shader(ctx
, program
, shader
, true);
516 * Return list of shaders attached to shader program.
517 * \param objOut returns GLuint ids
518 * \param handleOut returns GLhandleARB handles
521 get_attached_shaders(struct gl_context
*ctx
, GLuint program
, GLsizei maxCount
,
522 GLsizei
*countOut
, GLuint
*objOut
, GLhandleARB
*handleOut
)
524 struct gl_shader_program
*shProg
;
527 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetAttachedShaders(maxCount < 0)");
532 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
536 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
538 objOut
[i
] = shProg
->Shaders
[i
]->Name
;
542 handleOut
[i
] = (GLhandleARB
) shProg
->Shaders
[i
]->Name
;
552 * glGetHandleARB() - return ID/name of currently bound shader program.
555 get_handle(struct gl_context
*ctx
, GLenum pname
)
557 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
558 if (ctx
->_Shader
->ActiveProgram
)
559 return ctx
->_Shader
->ActiveProgram
->Name
;
564 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
571 * Check if a geometry shader query is valid at this time. If not, report an
572 * error and return false.
574 * From GL 3.2 section 6.1.16 (Shader and Program Queries):
576 * "If GEOMETRY_VERTICES_OUT, GEOMETRY_INPUT_TYPE, or GEOMETRY_OUTPUT_TYPE
577 * are queried for a program which has not been linked successfully, or
578 * which does not contain objects to form a geometry shader, then an
579 * INVALID_OPERATION error is generated."
582 check_gs_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
584 if (shProg
->data
->LinkStatus
&&
585 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
] != NULL
) {
589 _mesa_error(ctx
, GL_INVALID_OPERATION
,
590 "glGetProgramv(linked geometry shader required)");
596 * Check if a tessellation control shader query is valid at this time.
597 * If not, report an error and return false.
599 * From GL 4.0 section 6.1.12 (Shader and Program Queries):
601 * "If TESS_CONTROL_OUTPUT_VERTICES is queried for a program which has
602 * not been linked successfully, or which does not contain objects to
603 * form a tessellation control shader, then an INVALID_OPERATION error is
607 check_tcs_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
609 if (shProg
->data
->LinkStatus
&&
610 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
] != NULL
) {
614 _mesa_error(ctx
, GL_INVALID_OPERATION
,
615 "glGetProgramv(linked tessellation control shader required)");
621 * Check if a tessellation evaluation shader query is valid at this time.
622 * If not, report an error and return false.
624 * From GL 4.0 section 6.1.12 (Shader and Program Queries):
626 * "If any of the pname values in this paragraph are queried for a program
627 * which has not been linked successfully, or which does not contain
628 * objects to form a tessellation evaluation shader, then an
629 * INVALID_OPERATION error is generated."
633 check_tes_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
635 if (shProg
->data
->LinkStatus
&&
636 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
] != NULL
) {
640 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramv(linked tessellation "
641 "evaluation shader required)");
647 * glGetProgramiv() - get shader program state.
648 * Note that this is for GLSL shader programs, not ARB vertex/fragment
649 * programs (see glGetProgramivARB).
652 get_programiv(struct gl_context
*ctx
, GLuint program
, GLenum pname
,
655 struct gl_shader_program
*shProg
656 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramiv(program)");
658 /* Is transform feedback available in this context?
661 (ctx
->API
== API_OPENGL_COMPAT
&& ctx
->Extensions
.EXT_transform_feedback
)
662 || ctx
->API
== API_OPENGL_CORE
663 || _mesa_is_gles3(ctx
);
665 /* True if geometry shaders (of the form that was adopted into GLSL 1.50
666 * and GL 3.2) are available in this context
668 const bool has_core_gs
= _mesa_has_geometry_shaders(ctx
);
669 const bool has_tess
= _mesa_has_tessellation(ctx
);
671 /* Are uniform buffer objects available in this context?
674 (ctx
->API
== API_OPENGL_COMPAT
&&
675 ctx
->Extensions
.ARB_uniform_buffer_object
)
676 || ctx
->API
== API_OPENGL_CORE
677 || _mesa_is_gles3(ctx
);
684 case GL_DELETE_STATUS
:
685 *params
= shProg
->DeletePending
;
688 *params
= shProg
->data
->LinkStatus
? GL_TRUE
: GL_FALSE
;
690 case GL_VALIDATE_STATUS
:
691 *params
= shProg
->data
->Validated
;
693 case GL_INFO_LOG_LENGTH
:
694 *params
= (shProg
->data
->InfoLog
&& shProg
->data
->InfoLog
[0] != '\0') ?
695 strlen(shProg
->data
->InfoLog
) + 1 : 0;
697 case GL_ATTACHED_SHADERS
:
698 *params
= shProg
->NumShaders
;
700 case GL_ACTIVE_ATTRIBUTES
:
701 *params
= _mesa_count_active_attribs(shProg
);
703 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
704 *params
= _mesa_longest_attribute_name_length(shProg
);
706 case GL_ACTIVE_UNIFORMS
: {
708 const unsigned num_uniforms
=
709 shProg
->data
->NumUniformStorage
- shProg
->data
->NumHiddenUniforms
;
710 for (*params
= 0, i
= 0; i
< num_uniforms
; i
++) {
711 if (!shProg
->data
->UniformStorage
[i
].is_shader_storage
)
716 case GL_ACTIVE_UNIFORM_MAX_LENGTH
: {
719 const unsigned num_uniforms
=
720 shProg
->data
->NumUniformStorage
- shProg
->data
->NumHiddenUniforms
;
722 for (i
= 0; i
< num_uniforms
; i
++) {
723 if (shProg
->data
->UniformStorage
[i
].is_shader_storage
)
726 /* Add one for the terminating NUL character for a non-array, and
727 * 4 for the "[0]" and the NUL for an array.
729 const GLint len
= strlen(shProg
->data
->UniformStorage
[i
].name
) + 1 +
730 ((shProg
->data
->UniformStorage
[i
].array_elements
!= 0) ? 3 : 0);
739 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
742 *params
= shProg
->TransformFeedback
.NumVarying
;
744 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
: {
750 for (i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++) {
751 /* Add one for the terminating NUL character.
754 strlen(shProg
->TransformFeedback
.VaryingNames
[i
]) + 1;
763 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
766 *params
= shProg
->TransformFeedback
.BufferMode
;
768 case GL_GEOMETRY_VERTICES_OUT
:
771 if (check_gs_query(ctx
, shProg
)) {
772 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
773 Program
->info
.gs
.vertices_out
;
776 case GL_GEOMETRY_SHADER_INVOCATIONS
:
777 if (!has_core_gs
|| !ctx
->Extensions
.ARB_gpu_shader5
)
779 if (check_gs_query(ctx
, shProg
)) {
780 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
781 Program
->info
.gs
.invocations
;
784 case GL_GEOMETRY_INPUT_TYPE
:
787 if (check_gs_query(ctx
, shProg
)) {
788 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
789 Program
->info
.gs
.input_primitive
;
792 case GL_GEOMETRY_OUTPUT_TYPE
:
795 if (check_gs_query(ctx
, shProg
)) {
796 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
797 Program
->info
.gs
.output_primitive
;
800 case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH
: {
807 for (i
= 0; i
< shProg
->data
->NumUniformBlocks
; i
++) {
808 /* Add one for the terminating NUL character.
810 const GLint len
= strlen(shProg
->data
->UniformBlocks
[i
].Name
) + 1;
819 case GL_ACTIVE_UNIFORM_BLOCKS
:
823 *params
= shProg
->data
->NumUniformBlocks
;
825 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
826 /* This enum isn't part of the OES extension for OpenGL ES 2.0. It is
827 * only available with desktop OpenGL 3.0+ with the
828 * GL_ARB_get_program_binary extension or OpenGL ES 3.0.
830 * On desktop, we ignore the 3.0+ requirement because it is silly.
832 if (!_mesa_is_desktop_gl(ctx
) && !_mesa_is_gles3(ctx
))
835 *params
= shProg
->BinaryRetreivableHint
;
837 case GL_PROGRAM_BINARY_LENGTH
:
838 if (ctx
->Const
.NumProgramBinaryFormats
== 0) {
841 _mesa_get_program_binary_length(ctx
, shProg
, params
);
844 case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS
:
845 if (!ctx
->Extensions
.ARB_shader_atomic_counters
)
848 *params
= shProg
->data
->NumAtomicBuffers
;
850 case GL_COMPUTE_WORK_GROUP_SIZE
: {
852 if (!_mesa_has_compute_shaders(ctx
))
854 if (!shProg
->data
->LinkStatus
) {
855 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(program not "
859 if (shProg
->_LinkedShaders
[MESA_SHADER_COMPUTE
] == NULL
) {
860 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(no compute "
864 for (i
= 0; i
< 3; i
++)
865 params
[i
] = shProg
->_LinkedShaders
[MESA_SHADER_COMPUTE
]->
866 Program
->info
.cs
.local_size
[i
];
869 case GL_PROGRAM_SEPARABLE
:
870 /* If the program has not been linked, return initial value 0. */
871 *params
= (shProg
->data
->LinkStatus
== linking_failure
) ? 0 : shProg
->SeparateShader
;
874 /* ARB_tessellation_shader */
875 case GL_TESS_CONTROL_OUTPUT_VERTICES
:
878 if (check_tcs_query(ctx
, shProg
)) {
879 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->
880 Program
->info
.tess
.tcs_vertices_out
;
883 case GL_TESS_GEN_MODE
:
886 if (check_tes_query(ctx
, shProg
)) {
887 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
888 Program
->info
.tess
.primitive_mode
;
891 case GL_TESS_GEN_SPACING
:
894 if (check_tes_query(ctx
, shProg
)) {
895 const struct gl_linked_shader
*tes
=
896 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
];
897 switch (tes
->Program
->info
.tess
.spacing
) {
898 case TESS_SPACING_EQUAL
:
901 case TESS_SPACING_FRACTIONAL_ODD
:
902 *params
= GL_FRACTIONAL_ODD
;
904 case TESS_SPACING_FRACTIONAL_EVEN
:
905 *params
= GL_FRACTIONAL_EVEN
;
907 case TESS_SPACING_UNSPECIFIED
:
913 case GL_TESS_GEN_VERTEX_ORDER
:
916 if (check_tes_query(ctx
, shProg
)) {
917 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
918 Program
->info
.tess
.ccw
? GL_CCW
: GL_CW
;
921 case GL_TESS_GEN_POINT_MODE
:
924 if (check_tes_query(ctx
, shProg
)) {
925 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
926 Program
->info
.tess
.point_mode
? GL_TRUE
: GL_FALSE
;
933 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname=%s)",
934 _mesa_enum_to_string(pname
));
939 * glGetShaderiv() - get GLSL shader state
942 get_shaderiv(struct gl_context
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
944 struct gl_shader
*shader
=
945 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
953 *params
= shader
->Type
;
955 case GL_DELETE_STATUS
:
956 *params
= shader
->DeletePending
;
958 case GL_COMPILE_STATUS
:
959 *params
= shader
->CompileStatus
? GL_TRUE
: GL_FALSE
;
961 case GL_INFO_LOG_LENGTH
:
962 *params
= (shader
->InfoLog
&& shader
->InfoLog
[0] != '\0') ?
963 strlen(shader
->InfoLog
) + 1 : 0;
965 case GL_SHADER_SOURCE_LENGTH
:
966 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
969 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
976 get_program_info_log(struct gl_context
*ctx
, GLuint program
, GLsizei bufSize
,
977 GLsizei
*length
, GLchar
*infoLog
)
979 struct gl_shader_program
*shProg
;
981 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
982 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
984 * "If a negative number is provided where an argument of type sizei or
985 * sizeiptr is specified, an INVALID_VALUE error is generated."
988 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(bufSize < 0)");
992 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
993 "glGetProgramInfoLog(program)");
998 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->data
->InfoLog
);
1003 get_shader_info_log(struct gl_context
*ctx
, GLuint shader
, GLsizei bufSize
,
1004 GLsizei
*length
, GLchar
*infoLog
)
1006 struct gl_shader
*sh
;
1008 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
1009 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
1011 * "If a negative number is provided where an argument of type sizei or
1012 * sizeiptr is specified, an INVALID_VALUE error is generated."
1015 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(bufSize < 0)");
1019 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderInfoLog(shader)");
1024 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
1029 * Return shader source code.
1032 get_shader_source(struct gl_context
*ctx
, GLuint shader
, GLsizei maxLength
,
1033 GLsizei
*length
, GLchar
*sourceOut
)
1035 struct gl_shader
*sh
;
1037 if (maxLength
< 0) {
1038 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderSource(bufSize < 0)");
1042 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
1046 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
1051 * Set/replace shader source code. A helper function used by
1052 * glShaderSource[ARB].
1055 set_shader_source(struct gl_shader
*sh
, const GLchar
*source
)
1059 if (sh
->CompileStatus
== compile_skipped
&& !sh
->FallbackSource
) {
1060 /* If shader was previously compiled back-up the source in case of cache
1063 sh
->FallbackSource
= sh
->Source
;
1064 sh
->Source
= source
;
1066 /* free old shader source string and install new one */
1067 free((void *)sh
->Source
);
1068 sh
->Source
= source
;
1072 sh
->SourceChecksum
= util_hash_crc32(sh
->Source
, strlen(sh
->Source
));
1081 _mesa_compile_shader(struct gl_context
*ctx
, struct gl_shader
*sh
)
1087 /* If the user called glCompileShader without first calling
1088 * glShaderSource, we should fail to compile, but not raise a GL_ERROR.
1090 sh
->CompileStatus
= compile_failure
;
1092 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1093 _mesa_log("GLSL source for %s shader %d:\n",
1094 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1095 _mesa_log("%s\n", sh
->Source
);
1098 /* this call will set the shader->CompileStatus field to indicate if
1099 * compilation was successful.
1101 _mesa_glsl_compile_shader(ctx
, sh
, false, false, false);
1103 if (ctx
->_Shader
->Flags
& GLSL_LOG
) {
1104 _mesa_write_shader_to_file(sh
);
1107 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1108 if (sh
->CompileStatus
) {
1110 _mesa_log("GLSL IR for shader %d:\n", sh
->Name
);
1111 _mesa_print_ir(_mesa_get_log_file(), sh
->ir
, NULL
);
1113 _mesa_log("No GLSL IR for shader %d (shader may be from "
1114 "cache)\n", sh
->Name
);
1118 _mesa_log("GLSL shader %d failed to compile.\n", sh
->Name
);
1120 if (sh
->InfoLog
&& sh
->InfoLog
[0] != 0) {
1121 _mesa_log("GLSL shader %d info log:\n", sh
->Name
);
1122 _mesa_log("%s\n", sh
->InfoLog
);
1127 if (!sh
->CompileStatus
) {
1128 if (ctx
->_Shader
->Flags
& GLSL_DUMP_ON_ERROR
) {
1129 _mesa_log("GLSL source for %s shader %d:\n",
1130 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1131 _mesa_log("%s\n", sh
->Source
);
1132 _mesa_log("Info Log:\n%s\n", sh
->InfoLog
);
1135 if (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
) {
1136 _mesa_debug(ctx
, "Error compiling shader %u:\n%s\n",
1137 sh
->Name
, sh
->InfoLog
);
1144 * Link a program's shaders.
1146 static ALWAYS_INLINE
void
1147 link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1154 /* From the ARB_transform_feedback2 specification:
1155 * "The error INVALID_OPERATION is generated by LinkProgram if <program>
1156 * is the name of a program being used by one or more transform feedback
1157 * objects, even if the objects are not currently bound or are paused."
1159 if (_mesa_transform_feedback_is_using_program(ctx
, shProg
)) {
1160 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1161 "glLinkProgram(transform feedback is using the program)");
1166 unsigned programs_in_use
= 0;
1168 for (unsigned stage
= 0; stage
< MESA_SHADER_STAGES
; stage
++) {
1169 if (ctx
->_Shader
->CurrentProgram
[stage
] &&
1170 ctx
->_Shader
->CurrentProgram
[stage
]->Id
== shProg
->Name
) {
1171 programs_in_use
|= 1 << stage
;
1175 FLUSH_VERTICES(ctx
, 0);
1176 _mesa_glsl_link_shader(ctx
, shProg
);
1178 /* From section 7.3 (Program Objects) of the OpenGL 4.5 spec:
1180 * "If LinkProgram or ProgramBinary successfully re-links a program
1181 * object that is active for any shader stage, then the newly generated
1182 * executable code will be installed as part of the current rendering
1183 * state for all shader stages where the program is active.
1184 * Additionally, the newly generated executable code is made part of
1185 * the state of any program pipeline for all stages where the program
1188 if (shProg
->data
->LinkStatus
&& programs_in_use
) {
1189 while (programs_in_use
) {
1190 const int stage
= u_bit_scan(&programs_in_use
);
1192 struct gl_program
*prog
= NULL
;
1193 if (shProg
->_LinkedShaders
[stage
])
1194 prog
= shProg
->_LinkedShaders
[stage
]->Program
;
1196 _mesa_use_program(ctx
, stage
, shProg
, prog
, ctx
->_Shader
);
1200 /* Capture .shader_test files. */
1201 const char *capture_path
= _mesa_get_shader_capture_path();
1202 if (shProg
->Name
!= 0 && shProg
->Name
!= ~0 && capture_path
!= NULL
) {
1204 char *filename
= ralloc_asprintf(NULL
, "%s/%u.shader_test",
1205 capture_path
, shProg
->Name
);
1206 file
= fopen(filename
, "w");
1208 fprintf(file
, "[require]\nGLSL%s >= %u.%02u\n",
1209 shProg
->IsES
? " ES" : "",
1210 shProg
->data
->Version
/ 100, shProg
->data
->Version
% 100);
1211 if (shProg
->SeparateShader
)
1212 fprintf(file
, "GL_ARB_separate_shader_objects\nSSO ENABLED\n");
1213 fprintf(file
, "\n");
1215 for (unsigned i
= 0; i
< shProg
->NumShaders
; i
++) {
1216 fprintf(file
, "[%s shader]\n%s\n",
1217 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1218 shProg
->Shaders
[i
]->Source
);
1222 _mesa_warning(ctx
, "Failed to open %s", filename
);
1225 ralloc_free(filename
);
1228 if (shProg
->data
->LinkStatus
== linking_failure
&&
1229 (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
)) {
1230 _mesa_debug(ctx
, "Error linking program %u:\n%s\n",
1231 shProg
->Name
, shProg
->data
->InfoLog
);
1238 printf("Link %u shaders in program %u: %s\n",
1239 shProg
->NumShaders
, shProg
->Name
,
1240 shProg
->data
->LinkStatus
? "Success" : "Failed");
1242 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1243 printf(" shader %u, stage %u\n",
1244 shProg
->Shaders
[i
]->Name
,
1245 shProg
->Shaders
[i
]->Stage
);
1252 link_program_error(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1254 link_program(ctx
, shProg
, false);
1259 link_program_no_error(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1261 link_program(ctx
, shProg
, true);
1266 _mesa_link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1268 link_program_error(ctx
, shProg
);
1273 * Print basic shader info (for debug).
1276 print_shader_info(const struct gl_shader_program
*shProg
)
1280 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
1281 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1283 printf(" %s shader %u, checksum %u\n",
1284 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1285 shProg
->Shaders
[i
]->Name
,
1286 shProg
->Shaders
[i
]->SourceChecksum
);
1288 printf(" %s shader %u\n",
1289 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1290 shProg
->Shaders
[i
]->Name
);
1293 if (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
])
1294 printf(" vert prog %u\n",
1295 shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
]->Program
->Id
);
1296 if (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
])
1297 printf(" frag prog %u\n",
1298 shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
->Id
);
1299 if (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
])
1300 printf(" geom prog %u\n",
1301 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->Program
->Id
);
1302 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
])
1303 printf(" tesc prog %u\n",
1304 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->Program
->Id
);
1305 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
])
1306 printf(" tese prog %u\n",
1307 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->Program
->Id
);
1312 * Use the named shader program for subsequent glUniform calls
1315 _mesa_active_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1318 if ((shProg
!= NULL
) && !shProg
->data
->LinkStatus
) {
1319 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1320 "%s(program %u not linked)", caller
, shProg
->Name
);
1324 if (ctx
->Shader
.ActiveProgram
!= shProg
) {
1325 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, shProg
);
1331 * Use the named shader program for subsequent rendering.
1334 _mesa_use_shader_program(struct gl_context
*ctx
,
1335 struct gl_shader_program
*shProg
)
1337 for (int i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1338 struct gl_program
*new_prog
= NULL
;
1339 if (shProg
&& shProg
->_LinkedShaders
[i
])
1340 new_prog
= shProg
->_LinkedShaders
[i
]->Program
;
1341 _mesa_use_program(ctx
, i
, shProg
, new_prog
, &ctx
->Shader
);
1343 _mesa_active_program(ctx
, shProg
, "glUseProgram");
1348 * Do validation of the given shader program.
1349 * \param errMsg returns error message if validation fails.
1350 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1353 validate_shader_program(const struct gl_shader_program
*shProg
,
1356 if (!shProg
->data
->LinkStatus
) {
1360 /* From the GL spec, a program is invalid if any of these are true:
1362 any two active samplers in the current program object are of
1363 different types, but refer to the same texture image unit,
1365 any active sampler in the current program object refers to a texture
1366 image unit where fixed-function fragment processing accesses a
1367 texture target that does not match the sampler type, or
1369 the sum of the number of active samplers in the program and the
1370 number of texture image units enabled for fixed-function fragment
1371 processing exceeds the combined limit on the total number of texture
1372 image units allowed.
1376 * Check: any two active samplers in the current program object are of
1377 * different types, but refer to the same texture image unit,
1379 if (!_mesa_sampler_uniforms_are_valid(shProg
, errMsg
, 100))
1387 * Called via glValidateProgram()
1390 validate_program(struct gl_context
*ctx
, GLuint program
)
1392 struct gl_shader_program
*shProg
;
1393 char errMsg
[100] = "";
1395 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1400 shProg
->data
->Validated
= validate_shader_program(shProg
, errMsg
);
1401 if (!shProg
->data
->Validated
) {
1402 /* update info log */
1403 if (shProg
->data
->InfoLog
) {
1404 ralloc_free(shProg
->data
->InfoLog
);
1406 shProg
->data
->InfoLog
= ralloc_strdup(shProg
->data
, errMsg
);
1412 _mesa_AttachObjectARB_no_error(GLhandleARB program
, GLhandleARB shader
)
1414 GET_CURRENT_CONTEXT(ctx
);
1415 attach_shader_no_error(ctx
, program
, shader
);
1420 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1422 GET_CURRENT_CONTEXT(ctx
);
1423 attach_shader_err(ctx
, program
, shader
, "glAttachObjectARB");
1428 _mesa_AttachShader_no_error(GLuint program
, GLuint shader
)
1430 GET_CURRENT_CONTEXT(ctx
);
1431 attach_shader_no_error(ctx
, program
, shader
);
1436 _mesa_AttachShader(GLuint program
, GLuint shader
)
1438 GET_CURRENT_CONTEXT(ctx
);
1439 attach_shader_err(ctx
, program
, shader
, "glAttachShader");
1444 _mesa_CompileShader(GLuint shaderObj
)
1446 GET_CURRENT_CONTEXT(ctx
);
1447 if (MESA_VERBOSE
& VERBOSE_API
)
1448 _mesa_debug(ctx
, "glCompileShader %u\n", shaderObj
);
1449 _mesa_compile_shader(ctx
, _mesa_lookup_shader_err(ctx
, shaderObj
,
1450 "glCompileShader"));
1455 _mesa_CreateShader_no_error(GLenum type
)
1457 GET_CURRENT_CONTEXT(ctx
);
1458 return create_shader(ctx
, type
);
1463 _mesa_CreateShader(GLenum type
)
1465 GET_CURRENT_CONTEXT(ctx
);
1467 if (MESA_VERBOSE
& VERBOSE_API
)
1468 _mesa_debug(ctx
, "glCreateShader %s\n", _mesa_enum_to_string(type
));
1470 return create_shader_err(ctx
, type
, "glCreateShader");
1474 GLhandleARB GLAPIENTRY
1475 _mesa_CreateShaderObjectARB_no_error(GLenum type
)
1477 GET_CURRENT_CONTEXT(ctx
);
1478 return create_shader(ctx
, type
);
1482 GLhandleARB GLAPIENTRY
1483 _mesa_CreateShaderObjectARB(GLenum type
)
1485 GET_CURRENT_CONTEXT(ctx
);
1486 return create_shader_err(ctx
, type
, "glCreateShaderObjectARB");
1491 _mesa_CreateProgram(void)
1493 GET_CURRENT_CONTEXT(ctx
);
1494 if (MESA_VERBOSE
& VERBOSE_API
)
1495 _mesa_debug(ctx
, "glCreateProgram\n");
1496 return create_shader_program(ctx
);
1500 GLhandleARB GLAPIENTRY
1501 _mesa_CreateProgramObjectARB(void)
1503 GET_CURRENT_CONTEXT(ctx
);
1504 return create_shader_program(ctx
);
1509 _mesa_DeleteObjectARB(GLhandleARB obj
)
1511 if (MESA_VERBOSE
& VERBOSE_API
) {
1512 GET_CURRENT_CONTEXT(ctx
);
1513 _mesa_debug(ctx
, "glDeleteObjectARB(%lu)\n", (unsigned long)obj
);
1517 GET_CURRENT_CONTEXT(ctx
);
1518 FLUSH_VERTICES(ctx
, 0);
1519 if (is_program(ctx
, obj
)) {
1520 delete_shader_program(ctx
, obj
);
1522 else if (is_shader(ctx
, obj
)) {
1523 delete_shader(ctx
, obj
);
1533 _mesa_DeleteProgram(GLuint name
)
1536 GET_CURRENT_CONTEXT(ctx
);
1537 FLUSH_VERTICES(ctx
, 0);
1538 delete_shader_program(ctx
, name
);
1544 _mesa_DeleteShader(GLuint name
)
1547 GET_CURRENT_CONTEXT(ctx
);
1548 FLUSH_VERTICES(ctx
, 0);
1549 delete_shader(ctx
, name
);
1555 _mesa_DetachObjectARB_no_error(GLhandleARB program
, GLhandleARB shader
)
1557 GET_CURRENT_CONTEXT(ctx
);
1558 detach_shader_no_error(ctx
, program
, shader
);
1563 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1565 GET_CURRENT_CONTEXT(ctx
);
1566 detach_shader_error(ctx
, program
, shader
);
1571 _mesa_DetachShader_no_error(GLuint program
, GLuint shader
)
1573 GET_CURRENT_CONTEXT(ctx
);
1574 detach_shader_no_error(ctx
, program
, shader
);
1579 _mesa_DetachShader(GLuint program
, GLuint shader
)
1581 GET_CURRENT_CONTEXT(ctx
);
1582 detach_shader_error(ctx
, program
, shader
);
1587 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1588 GLsizei
* count
, GLhandleARB
* obj
)
1590 GET_CURRENT_CONTEXT(ctx
);
1591 get_attached_shaders(ctx
, (GLuint
)container
, maxCount
, count
, NULL
, obj
);
1596 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1597 GLsizei
*count
, GLuint
*obj
)
1599 GET_CURRENT_CONTEXT(ctx
);
1600 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
, NULL
);
1605 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1606 GLcharARB
* infoLog
)
1608 GET_CURRENT_CONTEXT(ctx
);
1609 if (is_program(ctx
, object
)) {
1610 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1612 else if (is_shader(ctx
, object
)) {
1613 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1616 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1622 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1624 GET_CURRENT_CONTEXT(ctx
);
1625 /* Implement in terms of GetProgramiv, GetShaderiv */
1626 if (is_program(ctx
, object
)) {
1627 if (pname
== GL_OBJECT_TYPE_ARB
) {
1628 *params
= GL_PROGRAM_OBJECT_ARB
;
1631 get_programiv(ctx
, object
, pname
, params
);
1634 else if (is_shader(ctx
, object
)) {
1635 if (pname
== GL_OBJECT_TYPE_ARB
) {
1636 *params
= GL_SHADER_OBJECT_ARB
;
1639 get_shaderiv(ctx
, object
, pname
, params
);
1643 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1649 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1652 GLint iparams
[1] = {0}; /* XXX is one element enough? */
1653 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1654 params
[0] = (GLfloat
) iparams
[0];
1659 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1661 GET_CURRENT_CONTEXT(ctx
);
1662 get_programiv(ctx
, program
, pname
, params
);
1667 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1669 GET_CURRENT_CONTEXT(ctx
);
1670 get_shaderiv(ctx
, shader
, pname
, params
);
1675 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1676 GLsizei
*length
, GLchar
*infoLog
)
1678 GET_CURRENT_CONTEXT(ctx
);
1679 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1684 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1685 GLsizei
*length
, GLchar
*infoLog
)
1687 GET_CURRENT_CONTEXT(ctx
);
1688 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1693 _mesa_GetShaderSource(GLuint shader
, GLsizei maxLength
,
1694 GLsizei
*length
, GLchar
*sourceOut
)
1696 GET_CURRENT_CONTEXT(ctx
);
1697 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1701 GLhandleARB GLAPIENTRY
1702 _mesa_GetHandleARB(GLenum pname
)
1704 GET_CURRENT_CONTEXT(ctx
);
1705 return get_handle(ctx
, pname
);
1709 GLboolean GLAPIENTRY
1710 _mesa_IsProgram(GLuint name
)
1712 GET_CURRENT_CONTEXT(ctx
);
1713 return is_program(ctx
, name
);
1717 GLboolean GLAPIENTRY
1718 _mesa_IsShader(GLuint name
)
1720 GET_CURRENT_CONTEXT(ctx
);
1721 return is_shader(ctx
, name
);
1726 _mesa_LinkProgram_no_error(GLuint programObj
)
1728 GET_CURRENT_CONTEXT(ctx
);
1730 struct gl_shader_program
*shProg
=
1731 _mesa_lookup_shader_program(ctx
, programObj
);
1732 link_program_no_error(ctx
, shProg
);
1737 _mesa_LinkProgram(GLuint programObj
)
1739 GET_CURRENT_CONTEXT(ctx
);
1741 if (MESA_VERBOSE
& VERBOSE_API
)
1742 _mesa_debug(ctx
, "glLinkProgram %u\n", programObj
);
1744 struct gl_shader_program
*shProg
=
1745 _mesa_lookup_shader_program_err(ctx
, programObj
, "glLinkProgram");
1746 link_program_error(ctx
, shProg
);
1749 #ifdef ENABLE_SHADER_CACHE
1751 * Generate a SHA-1 hash value string for given source string.
1754 generate_sha1(const char *source
, char sha_str
[64])
1756 unsigned char sha
[20];
1757 _mesa_sha1_compute(source
, strlen(source
), sha
);
1758 _mesa_sha1_format(sha_str
, sha
);
1762 * Construct a full path for shader replacement functionality using
1765 * <path>/<stage prefix>_<CHECKSUM>.glsl
1768 construct_name(const gl_shader_stage stage
, const char *source
,
1772 static const char *types
[] = {
1773 "VS", "TC", "TE", "GS", "FS", "CS",
1776 generate_sha1(source
, sha
);
1777 return ralloc_asprintf(NULL
, "%s/%s_%s.glsl", path
, types
[stage
], sha
);
1781 * Write given shader source to a file in MESA_SHADER_DUMP_PATH.
1784 dump_shader(const gl_shader_stage stage
, const char *source
)
1786 static bool path_exists
= true;
1793 dump_path
= getenv("MESA_SHADER_DUMP_PATH");
1795 path_exists
= false;
1799 char *name
= construct_name(stage
, source
, dump_path
);
1801 f
= fopen(name
, "w");
1806 GET_CURRENT_CONTEXT(ctx
);
1807 _mesa_warning(ctx
, "could not open %s for dumping shader (%s)", name
,
1814 * Read shader source code from a file.
1815 * Useful for debugging to override an app's shader.
1818 read_shader(const gl_shader_stage stage
, const char *source
)
1821 static bool path_exists
= true;
1822 int len
, shader_size
= 0;
1829 read_path
= getenv("MESA_SHADER_READ_PATH");
1831 path_exists
= false;
1835 char *name
= construct_name(stage
, source
, read_path
);
1836 f
= fopen(name
, "r");
1841 /* allocate enough room for the entire shader */
1842 fseek(f
, 0, SEEK_END
);
1843 shader_size
= ftell(f
);
1845 assert(shader_size
);
1847 /* add one for terminating zero */
1850 buffer
= malloc(shader_size
);
1853 len
= fread(buffer
, 1, shader_size
, f
);
1861 #endif /* ENABLE_SHADER_CACHE */
1864 * Called via glShaderSource() and glShaderSourceARB() API functions.
1865 * Basically, concatenate the source code strings into one long string
1866 * and pass it to _mesa_shader_source().
1868 static ALWAYS_INLINE
void
1869 shader_source(struct gl_context
*ctx
, GLuint shaderObj
, GLsizei count
,
1870 const GLchar
*const *string
, const GLint
*length
, bool no_error
)
1873 GLsizei i
, totalLength
;
1875 struct gl_shader
*sh
;
1878 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glShaderSourceARB");
1882 if (string
== NULL
) {
1883 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
1887 sh
= _mesa_lookup_shader(ctx
, shaderObj
);
1891 * This array holds offsets of where the appropriate string ends, thus the
1892 * last element will be set to the total length of the source code.
1894 offsets
= malloc(count
* sizeof(GLint
));
1895 if (offsets
== NULL
) {
1896 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1900 for (i
= 0; i
< count
; i
++) {
1901 if (!no_error
&& string
[i
] == NULL
) {
1902 free((GLvoid
*) offsets
);
1903 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1904 "glShaderSourceARB(null string)");
1907 if (length
== NULL
|| length
[i
] < 0)
1908 offsets
[i
] = strlen(string
[i
]);
1910 offsets
[i
] = length
[i
];
1911 /* accumulate string lengths */
1913 offsets
[i
] += offsets
[i
- 1];
1916 /* Total length of source string is sum off all strings plus two.
1917 * One extra byte for terminating zero, another extra byte to silence
1918 * valgrind warnings in the parser/grammer code.
1920 totalLength
= offsets
[count
- 1] + 2;
1921 source
= malloc(totalLength
* sizeof(GLcharARB
));
1922 if (source
== NULL
) {
1923 free((GLvoid
*) offsets
);
1924 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1928 for (i
= 0; i
< count
; i
++) {
1929 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
1930 memcpy(source
+ start
, string
[i
],
1931 (offsets
[i
] - start
) * sizeof(GLcharARB
));
1933 source
[totalLength
- 1] = '\0';
1934 source
[totalLength
- 2] = '\0';
1936 #ifdef ENABLE_SHADER_CACHE
1937 GLcharARB
*replacement
;
1939 /* Dump original shader source to MESA_SHADER_DUMP_PATH and replace
1940 * if corresponding entry found from MESA_SHADER_READ_PATH.
1942 dump_shader(sh
->Stage
, source
);
1944 replacement
= read_shader(sh
->Stage
, source
);
1947 source
= replacement
;
1949 #endif /* ENABLE_SHADER_CACHE */
1951 set_shader_source(sh
, source
);
1958 _mesa_ShaderSource_no_error(GLuint shaderObj
, GLsizei count
,
1959 const GLchar
*const *string
, const GLint
*length
)
1961 GET_CURRENT_CONTEXT(ctx
);
1962 shader_source(ctx
, shaderObj
, count
, string
, length
, true);
1967 _mesa_ShaderSource(GLuint shaderObj
, GLsizei count
,
1968 const GLchar
*const *string
, const GLint
*length
)
1970 GET_CURRENT_CONTEXT(ctx
);
1971 shader_source(ctx
, shaderObj
, count
, string
, length
, false);
1975 static ALWAYS_INLINE
void
1976 use_program(GLuint program
, bool no_error
)
1978 GET_CURRENT_CONTEXT(ctx
);
1979 struct gl_shader_program
*shProg
= NULL
;
1981 if (MESA_VERBOSE
& VERBOSE_API
)
1982 _mesa_debug(ctx
, "glUseProgram %u\n", program
);
1986 shProg
= _mesa_lookup_shader_program(ctx
, program
);
1989 if (_mesa_is_xfb_active_and_unpaused(ctx
)) {
1990 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1991 "glUseProgram(transform feedback active)");
1997 _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
2001 if (!shProg
->data
->LinkStatus
) {
2002 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2003 "glUseProgram(program %u not linked)", program
);
2008 if (ctx
->_Shader
->Flags
& GLSL_USE_PROG
) {
2009 print_shader_info(shProg
);
2014 /* The ARB_separate_shader_object spec says:
2016 * "The executable code for an individual shader stage is taken from
2017 * the current program for that stage. If there is a current program
2018 * object established by UseProgram, that program is considered current
2019 * for all stages. Otherwise, if there is a bound program pipeline
2020 * object (section 2.14.PPO), the program bound to the appropriate
2021 * stage of the pipeline object is considered current."
2024 /* Attach shader state to the binding point */
2025 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, &ctx
->Shader
);
2026 /* Update the program */
2027 _mesa_use_shader_program(ctx
, shProg
);
2029 /* Must be done first: detach the progam */
2030 _mesa_use_shader_program(ctx
, shProg
);
2031 /* Unattach shader_state binding point */
2032 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
,
2033 ctx
->Pipeline
.Default
);
2034 /* If a pipeline was bound, rebind it */
2035 if (ctx
->Pipeline
.Current
) {
2037 _mesa_BindProgramPipeline_no_error(ctx
->Pipeline
.Current
->Name
);
2039 _mesa_BindProgramPipeline(ctx
->Pipeline
.Current
->Name
);
2046 _mesa_UseProgram_no_error(GLuint program
)
2048 use_program(program
, true);
2053 _mesa_UseProgram(GLuint program
)
2055 use_program(program
, false);
2060 _mesa_ValidateProgram(GLuint program
)
2062 GET_CURRENT_CONTEXT(ctx
);
2063 validate_program(ctx
, program
);
2068 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2071 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
2072 GLint
* range
, GLint
* precision
)
2074 const struct gl_program_constants
*limits
;
2075 const struct gl_precision
*p
;
2076 GET_CURRENT_CONTEXT(ctx
);
2078 switch (shadertype
) {
2079 case GL_VERTEX_SHADER
:
2080 limits
= &ctx
->Const
.Program
[MESA_SHADER_VERTEX
];
2082 case GL_FRAGMENT_SHADER
:
2083 limits
= &ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
];
2086 _mesa_error(ctx
, GL_INVALID_ENUM
,
2087 "glGetShaderPrecisionFormat(shadertype)");
2091 switch (precisiontype
) {
2093 p
= &limits
->LowFloat
;
2095 case GL_MEDIUM_FLOAT
:
2096 p
= &limits
->MediumFloat
;
2099 p
= &limits
->HighFloat
;
2102 p
= &limits
->LowInt
;
2105 p
= &limits
->MediumInt
;
2108 p
= &limits
->HighInt
;
2111 _mesa_error(ctx
, GL_INVALID_ENUM
,
2112 "glGetShaderPrecisionFormat(precisiontype)");
2116 range
[0] = p
->RangeMin
;
2117 range
[1] = p
->RangeMax
;
2118 precision
[0] = p
->Precision
;
2123 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2126 _mesa_ReleaseShaderCompiler(void)
2128 _mesa_destroy_shader_compiler_caches();
2133 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
2136 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
2137 const void* binary
, GLint length
)
2139 GET_CURRENT_CONTEXT(ctx
);
2141 (void) binaryformat
;
2144 /* Page 68, section 7.2 'Shader Binaries" of the of the OpenGL ES 3.1, and
2145 * page 88 of the OpenGL 4.5 specs state:
2147 * "An INVALID_VALUE error is generated if count or length is negative.
2148 * An INVALID_ENUM error is generated if binaryformat is not a supported
2149 * format returned in SHADER_BINARY_FORMATS."
2151 if (n
< 0 || length
< 0) {
2152 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderBinary(count or length < 0)");
2156 _mesa_error(ctx
, GL_INVALID_ENUM
, "glShaderBinary(format)");
2161 _mesa_GetProgramBinary(GLuint program
, GLsizei bufSize
, GLsizei
*length
,
2162 GLenum
*binaryFormat
, GLvoid
*binary
)
2164 struct gl_shader_program
*shProg
;
2165 GLsizei length_dummy
;
2166 GET_CURRENT_CONTEXT(ctx
);
2169 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramBinary(bufSize < 0)");
2173 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramBinary");
2177 /* The ARB_get_program_binary spec says:
2179 * "If <length> is NULL, then no length is returned."
2181 * Ensure that length always points to valid storage to avoid multiple NULL
2182 * pointer checks below.
2185 length
= &length_dummy
;
2188 /* The ARB_get_program_binary spec says:
2190 * "When a program object's LINK_STATUS is FALSE, its program binary
2191 * length is zero, and a call to GetProgramBinary will generate an
2192 * INVALID_OPERATION error.
2194 if (!shProg
->data
->LinkStatus
) {
2195 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2196 "glGetProgramBinary(program %u not linked)",
2203 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2204 "glGetProgramBinary(driver supports zero binary formats)");
2206 (void) binaryFormat
;
2211 _mesa_ProgramBinary(GLuint program
, GLenum binaryFormat
,
2212 const GLvoid
*binary
, GLsizei length
)
2214 struct gl_shader_program
*shProg
;
2215 GET_CURRENT_CONTEXT(ctx
);
2217 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glProgramBinary");
2221 (void) binaryFormat
;
2224 /* Section 2.3.1 (Errors) of the OpenGL 4.5 spec says:
2226 * "If a negative number is provided where an argument of type sizei or
2227 * sizeiptr is specified, an INVALID_VALUE error is generated."
2230 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramBinary(length < 0)");
2234 /* The ARB_get_program_binary spec says:
2236 * "<binaryFormat> and <binary> must be those returned by a previous
2237 * call to GetProgramBinary, and <length> must be the length of the
2238 * program binary as returned by GetProgramBinary or GetProgramiv with
2239 * <pname> PROGRAM_BINARY_LENGTH. Loading the program binary will fail,
2240 * setting the LINK_STATUS of <program> to FALSE, if these conditions
2243 * Since any value of binaryFormat passed "is not one of those specified as
2244 * allowable for [this] command, an INVALID_ENUM error is generated."
2246 shProg
->data
->LinkStatus
= linking_failure
;
2247 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramBinary");
2251 static ALWAYS_INLINE
void
2252 program_parameteri(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
2253 GLuint pname
, GLint value
, bool no_error
)
2256 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
2257 /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
2258 * is part of OpenGL ES 3.0. For the ES2 case, this function shouldn't
2259 * even be in the dispatch table, so we shouldn't need to expclicitly
2262 * On desktop, we ignore the 3.0+ requirement because it is silly.
2265 /* The ARB_get_program_binary extension spec says:
2267 * "An INVALID_VALUE error is generated if the <value> argument to
2268 * ProgramParameteri is not TRUE or FALSE."
2270 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2274 /* No need to notify the driver. Any changes will actually take effect
2275 * the next time the shader is linked.
2277 * The ARB_get_program_binary extension spec says:
2279 * "To indicate that a program binary is likely to be retrieved,
2280 * ProgramParameteri should be called with <pname>
2281 * PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
2282 * will not be in effect until the next time LinkProgram or
2283 * ProgramBinary has been called successfully."
2285 * The resloution of issue 9 in the extension spec also says:
2287 * "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
2288 * to indicate to the GL implementation that this program will
2289 * likely be saved with GetProgramBinary at some point. This will
2290 * give the GL implementation the opportunity to track any state
2291 * changes made to the program before being saved such that when it
2292 * is loaded again a recompile can be avoided."
2294 shProg
->BinaryRetreivableHint
= value
;
2297 case GL_PROGRAM_SEPARABLE
:
2298 /* Spec imply that the behavior is the same as ARB_get_program_binary
2299 * Chapter 7.3 Program Objects
2301 if (!no_error
&& value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2304 shProg
->SeparateShader
= value
;
2309 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteri(pname=%s)",
2310 _mesa_enum_to_string(pname
));
2316 _mesa_error(ctx
, GL_INVALID_VALUE
,
2317 "glProgramParameteri(pname=%s, value=%d): "
2318 "value must be 0 or 1.",
2319 _mesa_enum_to_string(pname
),
2325 _mesa_ProgramParameteri_no_error(GLuint program
, GLenum pname
, GLint value
)
2327 GET_CURRENT_CONTEXT(ctx
);
2329 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, program
);
2330 program_parameteri(ctx
, shProg
, pname
, value
, true);
2335 _mesa_ProgramParameteri(GLuint program
, GLenum pname
, GLint value
)
2337 struct gl_shader_program
*shProg
;
2338 GET_CURRENT_CONTEXT(ctx
);
2340 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
2341 "glProgramParameteri");
2345 program_parameteri(ctx
, shProg
, pname
, value
, false);
2350 _mesa_use_program(struct gl_context
*ctx
, gl_shader_stage stage
,
2351 struct gl_shader_program
*shProg
, struct gl_program
*prog
,
2352 struct gl_pipeline_object
*shTarget
)
2354 struct gl_program
**target
;
2356 target
= &shTarget
->CurrentProgram
[stage
];
2358 _mesa_program_init_subroutine_defaults(ctx
, prog
);
2361 if (*target
!= prog
) {
2362 /* Program is current, flush it */
2363 if (shTarget
== ctx
->_Shader
) {
2364 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
2367 _mesa_reference_shader_program(ctx
,
2368 &shTarget
->ReferencedPrograms
[stage
],
2370 _mesa_reference_program(ctx
, target
, prog
);
2378 * Copy program-specific data generated by linking from the gl_shader_program
2379 * object to the gl_program object referred to by the gl_linked_shader.
2381 * This function expects _mesa_reference_program() to have been previously
2382 * called setting the gl_linked_shaders program reference.
2385 _mesa_copy_linked_program_data(const struct gl_shader_program
*src
,
2386 struct gl_linked_shader
*dst_sh
)
2388 assert(dst_sh
->Program
);
2390 struct gl_program
*dst
= dst_sh
->Program
;
2392 dst
->info
.separate_shader
= src
->SeparateShader
;
2394 switch (dst_sh
->Stage
) {
2395 case MESA_SHADER_GEOMETRY
: {
2396 dst
->info
.gs
.vertices_in
= src
->Geom
.VerticesIn
;
2397 dst
->info
.gs
.uses_end_primitive
= src
->Geom
.UsesEndPrimitive
;
2398 dst
->info
.gs
.uses_streams
= src
->Geom
.UsesStreams
;
2401 case MESA_SHADER_FRAGMENT
: {
2402 dst
->info
.fs
.depth_layout
= src
->FragDepthLayout
;
2405 case MESA_SHADER_COMPUTE
: {
2406 dst
->info
.cs
.shared_size
= src
->Comp
.SharedSize
;
2415 * ARB_separate_shader_objects: Compile & Link Program
2418 _mesa_CreateShaderProgramv(GLenum type
, GLsizei count
,
2419 const GLchar
* const *strings
)
2421 GET_CURRENT_CONTEXT(ctx
);
2423 const GLuint shader
= create_shader_err(ctx
, type
, "glCreateShaderProgramv");
2427 * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2428 * GL_INVALID_VALUE should be generated if count < 0
2431 _mesa_error(ctx
, GL_INVALID_VALUE
, "glCreateShaderProgram (count < 0)");
2436 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
2438 _mesa_ShaderSource(shader
, count
, strings
, NULL
);
2439 _mesa_compile_shader(ctx
, sh
);
2441 program
= create_shader_program(ctx
);
2443 struct gl_shader_program
*shProg
;
2444 GLint compiled
= GL_FALSE
;
2446 shProg
= _mesa_lookup_shader_program(ctx
, program
);
2448 shProg
->SeparateShader
= GL_TRUE
;
2450 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
2452 attach_shader_err(ctx
, program
, shader
, "glCreateShaderProgramv");
2453 _mesa_link_program(ctx
, shProg
);
2454 detach_shader_error(ctx
, program
, shader
);
2458 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
2459 append
-error
-to
-info
-log
;
2460 shProg
->data
->LinkStatus
= linking_failure
;
2465 ralloc_strcat(&shProg
->data
->InfoLog
, sh
->InfoLog
);
2468 delete_shader(ctx
, shader
);
2476 * For GL_ARB_tessellation_shader
2479 _mesa_PatchParameteri_no_error(GLenum pname
, GLint value
)
2481 GET_CURRENT_CONTEXT(ctx
);
2482 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2486 extern void GLAPIENTRY
2487 _mesa_PatchParameteri(GLenum pname
, GLint value
)
2489 GET_CURRENT_CONTEXT(ctx
);
2491 if (!_mesa_has_tessellation(ctx
)) {
2492 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameteri");
2496 if (pname
!= GL_PATCH_VERTICES
) {
2497 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameteri");
2501 if (value
<= 0 || value
> ctx
->Const
.MaxPatchVertices
) {
2502 _mesa_error(ctx
, GL_INVALID_VALUE
, "glPatchParameteri");
2506 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2510 extern void GLAPIENTRY
2511 _mesa_PatchParameterfv(GLenum pname
, const GLfloat
*values
)
2513 GET_CURRENT_CONTEXT(ctx
);
2515 if (!_mesa_has_tessellation(ctx
)) {
2516 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameterfv");
2521 case GL_PATCH_DEFAULT_OUTER_LEVEL
:
2522 FLUSH_VERTICES(ctx
, 0);
2523 memcpy(ctx
->TessCtrlProgram
.patch_default_outer_level
, values
,
2524 4 * sizeof(GLfloat
));
2525 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2527 case GL_PATCH_DEFAULT_INNER_LEVEL
:
2528 FLUSH_VERTICES(ctx
, 0);
2529 memcpy(ctx
->TessCtrlProgram
.patch_default_inner_level
, values
,
2530 2 * sizeof(GLfloat
));
2531 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2534 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameterfv");
2540 * ARB_shader_subroutine
2543 _mesa_GetSubroutineUniformLocation(GLuint program
, GLenum shadertype
,
2546 GET_CURRENT_CONTEXT(ctx
);
2547 const char *api_name
= "glGetSubroutineUniformLocation";
2548 struct gl_shader_program
*shProg
;
2549 GLenum resource_type
;
2550 gl_shader_stage stage
;
2552 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2553 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2557 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2561 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2562 if (!shProg
->_LinkedShaders
[stage
]) {
2563 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2567 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2568 return _mesa_program_resource_location(shProg
, resource_type
, name
);
2572 _mesa_GetSubroutineIndex(GLuint program
, GLenum shadertype
,
2575 GET_CURRENT_CONTEXT(ctx
);
2576 const char *api_name
= "glGetSubroutineIndex";
2577 struct gl_shader_program
*shProg
;
2578 struct gl_program_resource
*res
;
2579 GLenum resource_type
;
2580 gl_shader_stage stage
;
2582 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2583 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2587 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2591 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2592 if (!shProg
->_LinkedShaders
[stage
]) {
2593 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2597 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2598 res
= _mesa_program_resource_find_name(shProg
, resource_type
, name
, NULL
);
2603 return _mesa_program_resource_index(shProg
, res
);
2608 _mesa_GetActiveSubroutineUniformiv(GLuint program
, GLenum shadertype
,
2609 GLuint index
, GLenum pname
, GLint
*values
)
2611 GET_CURRENT_CONTEXT(ctx
);
2612 const char *api_name
= "glGetActiveSubroutineUniformiv";
2613 struct gl_shader_program
*shProg
;
2614 struct gl_linked_shader
*sh
;
2615 gl_shader_stage stage
;
2616 struct gl_program_resource
*res
;
2617 const struct gl_uniform_storage
*uni
;
2618 GLenum resource_type
;
2621 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2622 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2626 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2630 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2631 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2633 sh
= shProg
->_LinkedShaders
[stage
];
2635 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2639 struct gl_program
*p
= shProg
->_LinkedShaders
[stage
]->Program
;
2640 if (index
>= p
->sh
.NumSubroutineUniforms
) {
2641 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s: invalid index greater than GL_ACTIVE_SUBROUTINE_UNIFORMS", api_name
);
2646 case GL_NUM_COMPATIBLE_SUBROUTINES
: {
2647 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2650 values
[0] = uni
->num_compatible_subroutines
;
2654 case GL_COMPATIBLE_SUBROUTINES
: {
2655 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2659 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2660 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
2661 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2662 if (fn
->types
[j
] == uni
->type
) {
2663 values
[count
++] = i
;
2671 case GL_UNIFORM_SIZE
:
2672 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2675 values
[0] = uni
->array_elements
? uni
->array_elements
: 1;
2678 case GL_UNIFORM_NAME_LENGTH
:
2679 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2681 values
[0] = strlen(_mesa_program_resource_name(res
)) + 1
2682 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2686 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2693 _mesa_GetActiveSubroutineUniformName(GLuint program
, GLenum shadertype
,
2694 GLuint index
, GLsizei bufsize
,
2695 GLsizei
*length
, GLchar
*name
)
2697 GET_CURRENT_CONTEXT(ctx
);
2698 const char *api_name
= "glGetActiveSubroutineUniformName";
2699 struct gl_shader_program
*shProg
;
2700 GLenum resource_type
;
2701 gl_shader_stage stage
;
2703 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2704 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2708 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2712 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2713 if (!shProg
->_LinkedShaders
[stage
]) {
2714 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2718 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2719 /* get program resource name */
2720 _mesa_get_program_resource_name(shProg
, resource_type
,
2722 length
, name
, api_name
);
2727 _mesa_GetActiveSubroutineName(GLuint program
, GLenum shadertype
,
2728 GLuint index
, GLsizei bufsize
,
2729 GLsizei
*length
, GLchar
*name
)
2731 GET_CURRENT_CONTEXT(ctx
);
2732 const char *api_name
= "glGetActiveSubroutineName";
2733 struct gl_shader_program
*shProg
;
2734 GLenum resource_type
;
2735 gl_shader_stage stage
;
2737 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2738 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2742 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2746 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2747 if (!shProg
->_LinkedShaders
[stage
]) {
2748 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2751 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2752 _mesa_get_program_resource_name(shProg
, resource_type
,
2754 length
, name
, api_name
);
2758 _mesa_UniformSubroutinesuiv(GLenum shadertype
, GLsizei count
,
2759 const GLuint
*indices
)
2761 GET_CURRENT_CONTEXT(ctx
);
2762 const char *api_name
= "glUniformSubroutinesuiv";
2763 gl_shader_stage stage
;
2766 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2767 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2771 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2772 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
2774 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2778 if (count
!= p
->sh
.NumSubroutineUniformRemapTable
) {
2779 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2784 bool flushed
= false;
2786 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
2793 _mesa_flush_vertices_for_uniforms(ctx
, uni
);
2797 int uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
2800 for (j
= i
; j
< i
+ uni_count
; j
++) {
2801 struct gl_subroutine_function
*subfn
= NULL
;
2802 if (indices
[j
] > p
->sh
.MaxSubroutineFunctionIndex
) {
2803 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2807 for (f
= 0; f
< p
->sh
.NumSubroutineFunctions
; f
++) {
2808 if (p
->sh
.SubroutineFunctions
[f
].index
== indices
[j
])
2809 subfn
= &p
->sh
.SubroutineFunctions
[f
];
2816 for (k
= 0; k
< subfn
->num_compat_types
; k
++) {
2817 if (subfn
->types
[k
] == uni
->type
)
2820 if (k
== subfn
->num_compat_types
) {
2821 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2825 ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[j
] = indices
[j
];
2833 _mesa_GetUniformSubroutineuiv(GLenum shadertype
, GLint location
,
2836 GET_CURRENT_CONTEXT(ctx
);
2837 const char *api_name
= "glGetUniformSubroutineuiv";
2838 gl_shader_stage stage
;
2840 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2841 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2845 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2846 struct gl_program
*p
= ctx
->_Shader
->CurrentProgram
[stage
];
2848 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2852 if (location
>= p
->sh
.NumSubroutineUniformRemapTable
) {
2853 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2857 *params
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[location
];
2862 _mesa_GetProgramStageiv(GLuint program
, GLenum shadertype
,
2863 GLenum pname
, GLint
*values
)
2865 GET_CURRENT_CONTEXT(ctx
);
2866 const char *api_name
= "glGetProgramStageiv";
2867 struct gl_shader_program
*shProg
;
2868 struct gl_linked_shader
*sh
;
2869 gl_shader_stage stage
;
2871 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2872 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2876 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2880 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2881 sh
= shProg
->_LinkedShaders
[stage
];
2883 /* ARB_shader_subroutine doesn't ask the program to be linked, or list any
2884 * INVALID_OPERATION in the case of not be linked.
2886 * And for some pnames, like GL_ACTIVE_SUBROUTINE_UNIFORMS, you can ask the
2887 * same info using other specs (ARB_program_interface_query), without the
2888 * need of the program to be linked, being the value for that case 0.
2890 * But at the same time, some other methods require the program to be
2891 * linked for pname related to locations, so it would be inconsistent to
2892 * not do the same here. So we are:
2893 * * Return GL_INVALID_OPERATION if not linked only for locations.
2894 * * Setting a default value of 0, to be returned if not linked.
2898 if (pname
== GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
) {
2899 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2904 struct gl_program
*p
= sh
->Program
;
2906 case GL_ACTIVE_SUBROUTINES
:
2907 values
[0] = p
->sh
.NumSubroutineFunctions
;
2909 case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
:
2910 values
[0] = p
->sh
.NumSubroutineUniformRemapTable
;
2912 case GL_ACTIVE_SUBROUTINE_UNIFORMS
:
2913 values
[0] = p
->sh
.NumSubroutineUniforms
;
2915 case GL_ACTIVE_SUBROUTINE_MAX_LENGTH
:
2919 GLenum resource_type
;
2920 struct gl_program_resource
*res
;
2922 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2923 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2924 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
2926 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1;
2931 values
[0] = max_len
;
2934 case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH
:
2938 GLenum resource_type
;
2939 struct gl_program_resource
*res
;
2941 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2942 for (i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
2943 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
2945 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1
2946 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2952 values
[0] = max_len
;
2956 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s", api_name
);
2963 find_compat_subroutine(struct gl_program
*p
, const struct glsl_type
*type
)
2967 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2968 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
2969 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2970 if (fn
->types
[j
] == type
)
2978 _mesa_shader_write_subroutine_index(struct gl_context
*ctx
,
2979 struct gl_program
*p
)
2983 if (p
->sh
.NumSubroutineUniformRemapTable
== 0)
2988 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
2997 uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
2998 for (j
= 0; j
< uni_count
; j
++) {
2999 val
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[i
+ j
];
3000 memcpy(&uni
->storage
[j
], &val
, sizeof(int));
3003 _mesa_propagate_uniforms_to_driver_storage(uni
, 0, uni_count
);
3005 } while(i
< p
->sh
.NumSubroutineUniformRemapTable
);
3009 _mesa_shader_write_subroutine_indices(struct gl_context
*ctx
,
3010 gl_shader_stage stage
)
3012 if (ctx
->_Shader
->CurrentProgram
[stage
])
3013 _mesa_shader_write_subroutine_index(ctx
,
3014 ctx
->_Shader
->CurrentProgram
[stage
]);
3018 _mesa_program_init_subroutine_defaults(struct gl_context
*ctx
,
3019 struct gl_program
*p
)
3023 struct gl_subroutine_index_binding
*binding
= &ctx
->SubroutineIndex
[p
->info
.stage
];
3024 if (binding
->NumIndex
!= p
->sh
.NumSubroutineUniformRemapTable
) {
3025 binding
->IndexPtr
= realloc(binding
->IndexPtr
,
3026 p
->sh
.NumSubroutineUniformRemapTable
* (sizeof(GLuint
)));
3027 binding
->NumIndex
= p
->sh
.NumSubroutineUniformRemapTable
;
3030 for (int i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
3031 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
3036 binding
->IndexPtr
[i
] = find_compat_subroutine(p
, uni
->type
);