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/shaderapi.h"
49 #include "main/shaderobj.h"
50 #include "main/transformfeedback.h"
51 #include "main/uniforms.h"
52 #include "compiler/glsl/glsl_parser_extras.h"
53 #include "compiler/glsl/ir.h"
54 #include "compiler/glsl/ir_uniform.h"
55 #include "compiler/glsl/program.h"
56 #include "program/program.h"
57 #include "program/prog_print.h"
58 #include "program/prog_parameter.h"
59 #include "util/ralloc.h"
60 #include "util/hash_table.h"
61 #include "util/mesa-sha1.h"
64 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
67 _mesa_get_shader_flags(void)
69 GLbitfield flags
= 0x0;
70 const char *env
= getenv("MESA_GLSL");
73 if (strstr(env
, "dump_on_error"))
74 flags
|= GLSL_DUMP_ON_ERROR
;
75 else if (strstr(env
, "dump"))
77 if (strstr(env
, "log"))
79 if (strstr(env
, "nopvert"))
80 flags
|= GLSL_NOP_VERT
;
81 if (strstr(env
, "nopfrag"))
82 flags
|= GLSL_NOP_FRAG
;
83 if (strstr(env
, "nopt"))
85 else if (strstr(env
, "opt"))
87 if (strstr(env
, "uniform"))
88 flags
|= GLSL_UNIFORMS
;
89 if (strstr(env
, "useprog"))
90 flags
|= GLSL_USE_PROG
;
91 if (strstr(env
, "errors"))
92 flags
|= GLSL_REPORT_ERRORS
;
99 * Memoized version of getenv("MESA_SHADER_CAPTURE_PATH").
102 _mesa_get_shader_capture_path(void)
104 static bool read_env_var
= false;
105 static const char *path
= NULL
;
108 path
= getenv("MESA_SHADER_CAPTURE_PATH");
116 * Initialize context's shader state.
119 _mesa_init_shader_state(struct gl_context
*ctx
)
121 /* Device drivers may override these to control what kind of instructions
122 * are generated by the GLSL compiler.
124 struct gl_shader_compiler_options options
;
128 memset(&options
, 0, sizeof(options
));
129 options
.MaxUnrollIterations
= 32;
130 options
.MaxIfDepth
= UINT_MAX
;
132 for (sh
= 0; sh
< MESA_SHADER_STAGES
; ++sh
)
133 memcpy(&ctx
->Const
.ShaderCompilerOptions
[sh
], &options
, sizeof(options
));
135 ctx
->Shader
.Flags
= _mesa_get_shader_flags();
137 if (ctx
->Shader
.Flags
!= 0)
138 ctx
->Const
.GenerateTemporaryNames
= true;
140 /* Extended for ARB_separate_shader_objects */
141 ctx
->Shader
.RefCount
= 1;
142 mtx_init(&ctx
->Shader
.Mutex
, mtx_plain
);
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
)
159 for (i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
160 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
[i
],
163 _mesa_reference_shader_program(ctx
, &ctx
->Shader
._CurrentFragmentProgram
,
165 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, NULL
);
167 /* Extended for ARB_separate_shader_objects */
168 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, NULL
);
170 assert(ctx
->Shader
.RefCount
== 1);
171 mtx_destroy(&ctx
->Shader
.Mutex
);
176 * Copy string from <src> to <dst>, up to maxLength characters, returning
177 * length of <dst> in <length>.
178 * \param src the strings source
179 * \param maxLength max chars to copy
180 * \param length returns number of chars copied
181 * \param dst the string destination
184 _mesa_copy_string(GLchar
*dst
, GLsizei maxLength
,
185 GLsizei
*length
, const GLchar
*src
)
188 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
199 * Confirm that the a shader type is valid and supported by the implementation
201 * \param ctx Current GL context
202 * \param type Shader target
206 _mesa_validate_shader_target(const struct gl_context
*ctx
, GLenum type
)
208 /* Note: when building built-in GLSL functions, this function may be
209 * invoked with ctx == NULL. In that case, we can only validate that it's
210 * a shader target we recognize, not that it's supported in the current
211 * context. But that's fine--we don't need any further validation than
212 * that when building built-in GLSL functions.
216 case GL_FRAGMENT_SHADER
:
217 return ctx
== NULL
|| ctx
->Extensions
.ARB_fragment_shader
;
218 case GL_VERTEX_SHADER
:
219 return ctx
== NULL
|| ctx
->Extensions
.ARB_vertex_shader
;
220 case GL_GEOMETRY_SHADER_ARB
:
221 return ctx
== NULL
|| _mesa_has_geometry_shaders(ctx
);
222 case GL_TESS_CONTROL_SHADER
:
223 case GL_TESS_EVALUATION_SHADER
:
224 return ctx
== NULL
|| _mesa_has_tessellation(ctx
);
225 case GL_COMPUTE_SHADER
:
226 return ctx
== NULL
|| _mesa_has_compute_shaders(ctx
);
234 is_program(struct gl_context
*ctx
, GLuint name
)
236 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
237 return shProg
? GL_TRUE
: GL_FALSE
;
242 is_shader(struct gl_context
*ctx
, GLuint name
)
244 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
245 return shader
? GL_TRUE
: GL_FALSE
;
250 * Attach shader to a shader program.
253 attach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
255 struct gl_shader_program
*shProg
;
256 struct gl_shader
*sh
;
259 const bool same_type_disallowed
= _mesa_is_gles(ctx
);
261 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glAttachShader");
265 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glAttachShader");
270 n
= shProg
->NumShaders
;
271 for (i
= 0; i
< n
; i
++) {
272 if (shProg
->Shaders
[i
] == sh
) {
273 /* The shader is already attched to this program. The
274 * GL_ARB_shader_objects spec says:
276 * "The error INVALID_OPERATION is generated by AttachObjectARB
277 * if <obj> is already attached to <containerObj>."
279 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glAttachShader");
281 } else if (same_type_disallowed
&&
282 shProg
->Shaders
[i
]->Stage
== sh
->Stage
) {
283 /* Shader with the same type is already attached to this program,
284 * OpenGL ES 2.0 and 3.0 specs say:
286 * "Multiple shader objects of the same type may not be attached
287 * to a single program object. [...] The error INVALID_OPERATION
288 * is generated if [...] another shader object of the same type
289 * as shader is already attached to program."
291 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glAttachShader");
297 shProg
->Shaders
= realloc(shProg
->Shaders
,
298 (n
+ 1) * sizeof(struct gl_shader
*));
299 if (!shProg
->Shaders
) {
300 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
305 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
306 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
307 shProg
->NumShaders
++;
312 create_shader(struct gl_context
*ctx
, GLenum type
)
314 struct gl_shader
*sh
;
317 if (!_mesa_validate_shader_target(ctx
, type
)) {
318 _mesa_error(ctx
, GL_INVALID_ENUM
, "CreateShader(%s)",
319 _mesa_enum_to_string(type
));
323 _mesa_HashLockMutex(ctx
->Shared
->ShaderObjects
);
324 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
325 sh
= _mesa_new_shader(name
, _mesa_shader_enum_to_shader_stage(type
));
327 _mesa_HashInsertLocked(ctx
->Shared
->ShaderObjects
, name
, sh
);
328 _mesa_HashUnlockMutex(ctx
->Shared
->ShaderObjects
);
335 create_shader_program(struct gl_context
*ctx
)
338 struct gl_shader_program
*shProg
;
340 _mesa_HashLockMutex(ctx
->Shared
->ShaderObjects
);
342 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
344 shProg
= _mesa_new_shader_program(name
);
346 _mesa_HashInsertLocked(ctx
->Shared
->ShaderObjects
, name
, shProg
);
348 assert(shProg
->RefCount
== 1);
350 _mesa_HashUnlockMutex(ctx
->Shared
->ShaderObjects
);
357 * Delete a shader program. Actually, just decrement the program's
358 * reference count and mark it as DeletePending.
359 * Used to implement glDeleteProgram() and glDeleteObjectARB().
362 delete_shader_program(struct gl_context
*ctx
, GLuint name
)
365 * NOTE: deleting shaders/programs works a bit differently than
366 * texture objects (and buffer objects, etc). Shader/program
367 * handles/IDs exist in the hash table until the object is really
368 * deleted (refcount==0). With texture objects, the handle/ID is
369 * removed from the hash table in glDeleteTextures() while the tex
370 * object itself might linger until its refcount goes to zero.
372 struct gl_shader_program
*shProg
;
374 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
378 if (!shProg
->DeletePending
) {
379 shProg
->DeletePending
= GL_TRUE
;
381 /* effectively, decr shProg's refcount */
382 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
388 delete_shader(struct gl_context
*ctx
, GLuint shader
)
390 struct gl_shader
*sh
;
392 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
396 if (!sh
->DeletePending
) {
397 sh
->DeletePending
= GL_TRUE
;
399 /* effectively, decr sh's refcount */
400 _mesa_reference_shader(ctx
, &sh
, NULL
);
406 detach_shader(struct gl_context
*ctx
, GLuint program
, GLuint shader
)
408 struct gl_shader_program
*shProg
;
412 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
416 n
= shProg
->NumShaders
;
418 for (i
= 0; i
< n
; i
++) {
419 if (shProg
->Shaders
[i
]->Name
== shader
) {
421 struct gl_shader
**newList
;
424 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
426 /* alloc new, smaller array */
427 newList
= malloc((n
- 1) * sizeof(struct gl_shader
*));
429 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
432 /* Copy old list entries to new list, skipping removed entry at [i] */
433 for (j
= 0; j
< i
; j
++) {
434 newList
[j
] = shProg
->Shaders
[j
];
437 newList
[j
++] = shProg
->Shaders
[i
];
440 /* Free old list and install new one */
441 free(shProg
->Shaders
);
442 shProg
->Shaders
= newList
;
443 shProg
->NumShaders
= n
- 1;
446 /* sanity check - make sure the new list's entries are sensible */
447 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
448 assert(shProg
->Shaders
[j
]->Stage
== MESA_SHADER_VERTEX
||
449 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_TESS_CTRL
||
450 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_TESS_EVAL
||
451 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_GEOMETRY
||
452 shProg
->Shaders
[j
]->Stage
== MESA_SHADER_FRAGMENT
);
453 assert(shProg
->Shaders
[j
]->RefCount
> 0);
464 if (is_shader(ctx
, shader
) || is_program(ctx
, shader
))
465 err
= GL_INVALID_OPERATION
;
467 err
= GL_INVALID_VALUE
;
468 _mesa_error(ctx
, err
, "glDetachShader(shader)");
475 * Return list of shaders attached to shader program.
478 get_attached_shaders(struct gl_context
*ctx
, GLuint program
, GLsizei maxCount
,
479 GLsizei
*count
, GLuint
*obj
)
481 struct gl_shader_program
*shProg
;
484 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetAttachedShaders(maxCount < 0)");
489 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
493 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
494 obj
[i
] = shProg
->Shaders
[i
]->Name
;
503 * glGetHandleARB() - return ID/name of currently bound shader program.
506 get_handle(struct gl_context
*ctx
, GLenum pname
)
508 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
509 if (ctx
->_Shader
->ActiveProgram
)
510 return ctx
->_Shader
->ActiveProgram
->Name
;
515 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
522 * Check if a geometry shader query is valid at this time. If not, report an
523 * error and return false.
525 * From GL 3.2 section 6.1.16 (Shader and Program Queries):
527 * "If GEOMETRY_VERTICES_OUT, GEOMETRY_INPUT_TYPE, or GEOMETRY_OUTPUT_TYPE
528 * are queried for a program which has not been linked successfully, or
529 * which does not contain objects to form a geometry shader, then an
530 * INVALID_OPERATION error is generated."
533 check_gs_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
535 if (shProg
->LinkStatus
&&
536 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
] != NULL
) {
540 _mesa_error(ctx
, GL_INVALID_OPERATION
,
541 "glGetProgramv(linked geometry shader required)");
547 * Check if a tessellation control shader query is valid at this time.
548 * If not, report an error and return false.
550 * From GL 4.0 section 6.1.12 (Shader and Program Queries):
552 * "If TESS_CONTROL_OUTPUT_VERTICES is queried for a program which has
553 * not been linked successfully, or which does not contain objects to
554 * form a tessellation control shader, then an INVALID_OPERATION error is
558 check_tcs_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
560 if (shProg
->LinkStatus
&&
561 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
] != NULL
) {
565 _mesa_error(ctx
, GL_INVALID_OPERATION
,
566 "glGetProgramv(linked tessellation control shader required)");
572 * Check if a tessellation evaluation shader query is valid at this time.
573 * If not, report an error and return false.
575 * From GL 4.0 section 6.1.12 (Shader and Program Queries):
577 * "If any of the pname values in this paragraph are queried for a program
578 * which has not been linked successfully, or which does not contain
579 * objects to form a tessellation evaluation shader, then an
580 * INVALID_OPERATION error is generated."
584 check_tes_query(struct gl_context
*ctx
, const struct gl_shader_program
*shProg
)
586 if (shProg
->LinkStatus
&&
587 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
] != NULL
) {
591 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramv(linked tessellation "
592 "evaluation shader required)");
598 * glGetProgramiv() - get shader program state.
599 * Note that this is for GLSL shader programs, not ARB vertex/fragment
600 * programs (see glGetProgramivARB).
603 get_programiv(struct gl_context
*ctx
, GLuint program
, GLenum pname
,
606 struct gl_shader_program
*shProg
607 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramiv(program)");
609 /* Is transform feedback available in this context?
612 (ctx
->API
== API_OPENGL_COMPAT
&& ctx
->Extensions
.EXT_transform_feedback
)
613 || ctx
->API
== API_OPENGL_CORE
614 || _mesa_is_gles3(ctx
);
616 /* True if geometry shaders (of the form that was adopted into GLSL 1.50
617 * and GL 3.2) are available in this context
619 const bool has_core_gs
= _mesa_has_geometry_shaders(ctx
);
620 const bool has_tess
= _mesa_has_tessellation(ctx
);
622 /* Are uniform buffer objects available in this context?
625 (ctx
->API
== API_OPENGL_COMPAT
&&
626 ctx
->Extensions
.ARB_uniform_buffer_object
)
627 || ctx
->API
== API_OPENGL_CORE
628 || _mesa_is_gles3(ctx
);
635 case GL_DELETE_STATUS
:
636 *params
= shProg
->DeletePending
;
639 *params
= shProg
->LinkStatus
;
641 case GL_VALIDATE_STATUS
:
642 *params
= shProg
->Validated
;
644 case GL_INFO_LOG_LENGTH
:
645 *params
= shProg
->InfoLog
? strlen(shProg
->InfoLog
) + 1 : 0;
647 case GL_ATTACHED_SHADERS
:
648 *params
= shProg
->NumShaders
;
650 case GL_ACTIVE_ATTRIBUTES
:
651 *params
= _mesa_count_active_attribs(shProg
);
653 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
654 *params
= _mesa_longest_attribute_name_length(shProg
);
656 case GL_ACTIVE_UNIFORMS
: {
658 const unsigned num_uniforms
=
659 shProg
->NumUniformStorage
- shProg
->NumHiddenUniforms
;
660 for (*params
= 0, i
= 0; i
< num_uniforms
; i
++) {
661 if (!shProg
->UniformStorage
[i
].is_shader_storage
)
666 case GL_ACTIVE_UNIFORM_MAX_LENGTH
: {
669 const unsigned num_uniforms
=
670 shProg
->NumUniformStorage
- shProg
->NumHiddenUniforms
;
672 for (i
= 0; i
< num_uniforms
; i
++) {
673 if (shProg
->UniformStorage
[i
].is_shader_storage
)
676 /* Add one for the terminating NUL character for a non-array, and
677 * 4 for the "[0]" and the NUL for an array.
679 const GLint len
= strlen(shProg
->UniformStorage
[i
].name
) + 1 +
680 ((shProg
->UniformStorage
[i
].array_elements
!= 0) ? 3 : 0);
689 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
692 *params
= shProg
->TransformFeedback
.NumVarying
;
694 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
: {
700 for (i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++) {
701 /* Add one for the terminating NUL character.
704 strlen(shProg
->TransformFeedback
.VaryingNames
[i
]) + 1;
713 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
716 *params
= shProg
->TransformFeedback
.BufferMode
;
718 case GL_GEOMETRY_VERTICES_OUT
:
721 if (check_gs_query(ctx
, shProg
)) {
722 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
723 info
.Geom
.VerticesOut
;
726 case GL_GEOMETRY_SHADER_INVOCATIONS
:
727 if (!has_core_gs
|| !ctx
->Extensions
.ARB_gpu_shader5
)
729 if (check_gs_query(ctx
, shProg
)) {
730 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
731 info
.Geom
.Invocations
;
734 case GL_GEOMETRY_INPUT_TYPE
:
737 if (check_gs_query(ctx
, shProg
)) {
738 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
742 case GL_GEOMETRY_OUTPUT_TYPE
:
745 if (check_gs_query(ctx
, shProg
)) {
746 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
747 info
.Geom
.OutputType
;
750 case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH
: {
757 for (i
= 0; i
< shProg
->NumUniformBlocks
; i
++) {
758 /* Add one for the terminating NUL character.
760 const GLint len
= strlen(shProg
->UniformBlocks
[i
].Name
) + 1;
769 case GL_ACTIVE_UNIFORM_BLOCKS
:
773 *params
= shProg
->NumUniformBlocks
;
775 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
776 /* This enum isn't part of the OES extension for OpenGL ES 2.0. It is
777 * only available with desktop OpenGL 3.0+ with the
778 * GL_ARB_get_program_binary extension or OpenGL ES 3.0.
780 * On desktop, we ignore the 3.0+ requirement because it is silly.
782 if (!_mesa_is_desktop_gl(ctx
) && !_mesa_is_gles3(ctx
))
785 *params
= shProg
->BinaryRetreivableHint
;
787 case GL_PROGRAM_BINARY_LENGTH
:
790 case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS
:
791 if (!ctx
->Extensions
.ARB_shader_atomic_counters
)
794 *params
= shProg
->NumAtomicBuffers
;
796 case GL_COMPUTE_WORK_GROUP_SIZE
: {
798 if (!_mesa_has_compute_shaders(ctx
))
800 if (!shProg
->LinkStatus
) {
801 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(program not "
805 if (shProg
->_LinkedShaders
[MESA_SHADER_COMPUTE
] == NULL
) {
806 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(no compute "
810 for (i
= 0; i
< 3; i
++)
811 params
[i
] = shProg
->Comp
.LocalSize
[i
];
814 case GL_PROGRAM_SEPARABLE
:
815 /* If the program has not been linked, return initial value 0. */
816 *params
= (shProg
->LinkStatus
== GL_FALSE
) ? 0 : shProg
->SeparateShader
;
819 /* ARB_tessellation_shader */
820 case GL_TESS_CONTROL_OUTPUT_VERTICES
:
823 if (check_tcs_query(ctx
, shProg
)) {
824 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->
825 info
.TessCtrl
.VerticesOut
;
828 case GL_TESS_GEN_MODE
:
831 if (check_tes_query(ctx
, shProg
)) {
832 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
833 info
.TessEval
.PrimitiveMode
;
836 case GL_TESS_GEN_SPACING
:
839 if (check_tes_query(ctx
, shProg
)) {
840 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
841 info
.TessEval
.Spacing
;
844 case GL_TESS_GEN_VERTEX_ORDER
:
847 if (check_tes_query(ctx
, shProg
)) {
848 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
849 info
.TessEval
.VertexOrder
;
852 case GL_TESS_GEN_POINT_MODE
:
855 if (check_tes_query(ctx
, shProg
)) {
856 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
857 info
.TessEval
.PointMode
;
864 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname=%s)",
865 _mesa_enum_to_string(pname
));
870 * glGetShaderiv() - get GLSL shader state
873 get_shaderiv(struct gl_context
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
875 struct gl_shader
*shader
=
876 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
884 *params
= shader
->Type
;
886 case GL_DELETE_STATUS
:
887 *params
= shader
->DeletePending
;
889 case GL_COMPILE_STATUS
:
890 *params
= shader
->CompileStatus
;
892 case GL_INFO_LOG_LENGTH
:
893 *params
= shader
->InfoLog
? strlen(shader
->InfoLog
) + 1 : 0;
895 case GL_SHADER_SOURCE_LENGTH
:
896 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
899 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
906 get_program_info_log(struct gl_context
*ctx
, GLuint program
, GLsizei bufSize
,
907 GLsizei
*length
, GLchar
*infoLog
)
909 struct gl_shader_program
*shProg
;
911 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
912 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
914 * "If a negative number is provided where an argument of type sizei or
915 * sizeiptr is specified, an INVALID_VALUE error is generated."
918 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(bufSize < 0)");
922 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
923 "glGetProgramInfoLog(program)");
928 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->InfoLog
);
933 get_shader_info_log(struct gl_context
*ctx
, GLuint shader
, GLsizei bufSize
,
934 GLsizei
*length
, GLchar
*infoLog
)
936 struct gl_shader
*sh
;
938 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
939 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
941 * "If a negative number is provided where an argument of type sizei or
942 * sizeiptr is specified, an INVALID_VALUE error is generated."
945 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(bufSize < 0)");
949 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderInfoLog(shader)");
954 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
959 * Return shader source code.
962 get_shader_source(struct gl_context
*ctx
, GLuint shader
, GLsizei maxLength
,
963 GLsizei
*length
, GLchar
*sourceOut
)
965 struct gl_shader
*sh
;
968 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderSource(bufSize < 0)");
972 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
976 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
981 * Set/replace shader source code. A helper function used by
982 * glShaderSource[ARB].
985 shader_source(struct gl_shader
*sh
, const GLchar
*source
)
989 /* free old shader source string and install new one */
990 free((void *)sh
->Source
);
993 sh
->SourceChecksum
= _mesa_str_checksum(sh
->Source
);
1002 _mesa_compile_shader(struct gl_context
*ctx
, struct gl_shader
*sh
)
1008 /* If the user called glCompileShader without first calling
1009 * glShaderSource, we should fail to compile, but not raise a GL_ERROR.
1011 sh
->CompileStatus
= GL_FALSE
;
1013 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1014 _mesa_log("GLSL source for %s shader %d:\n",
1015 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1016 _mesa_log("%s\n", sh
->Source
);
1019 /* this call will set the shader->CompileStatus field to indicate if
1020 * compilation was successful.
1022 _mesa_glsl_compile_shader(ctx
, sh
, false, false);
1024 if (ctx
->_Shader
->Flags
& GLSL_LOG
) {
1025 _mesa_write_shader_to_file(sh
);
1028 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1029 if (sh
->CompileStatus
) {
1031 _mesa_log("GLSL IR for shader %d:\n", sh
->Name
);
1032 _mesa_print_ir(_mesa_get_log_file(), sh
->ir
, NULL
);
1034 _mesa_log("No GLSL IR for shader %d (shader may be from "
1035 "cache)\n", sh
->Name
);
1039 _mesa_log("GLSL shader %d failed to compile.\n", sh
->Name
);
1041 if (sh
->InfoLog
&& sh
->InfoLog
[0] != 0) {
1042 _mesa_log("GLSL shader %d info log:\n", sh
->Name
);
1043 _mesa_log("%s\n", sh
->InfoLog
);
1048 if (!sh
->CompileStatus
) {
1049 if (ctx
->_Shader
->Flags
& GLSL_DUMP_ON_ERROR
) {
1050 _mesa_log("GLSL source for %s shader %d:\n",
1051 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1052 _mesa_log("%s\n", sh
->Source
);
1053 _mesa_log("Info Log:\n%s\n", sh
->InfoLog
);
1056 if (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
) {
1057 _mesa_debug(ctx
, "Error compiling shader %u:\n%s\n",
1058 sh
->Name
, sh
->InfoLog
);
1065 * Link a program's shaders.
1068 _mesa_link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1073 /* From the ARB_transform_feedback2 specification:
1074 * "The error INVALID_OPERATION is generated by LinkProgram if <program> is
1075 * the name of a program being used by one or more transform feedback
1076 * objects, even if the objects are not currently bound or are paused."
1078 if (_mesa_transform_feedback_is_using_program(ctx
, shProg
)) {
1079 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1080 "glLinkProgram(transform feedback is using the program)");
1084 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1086 _mesa_glsl_link_shader(ctx
, shProg
);
1088 /* Capture .shader_test files. */
1089 const char *capture_path
= _mesa_get_shader_capture_path();
1090 if (shProg
->Name
!= 0 && shProg
->Name
!= ~0 && capture_path
!= NULL
) {
1092 char *filename
= ralloc_asprintf(NULL
, "%s/%u.shader_test",
1093 capture_path
, shProg
->Name
);
1094 file
= fopen(filename
, "w");
1096 fprintf(file
, "[require]\nGLSL%s >= %u.%02u\n",
1097 shProg
->IsES
? " ES" : "",
1098 shProg
->Version
/ 100, shProg
->Version
% 100);
1099 if (shProg
->SeparateShader
)
1100 fprintf(file
, "GL_ARB_separate_shader_objects\nSSO ENABLED\n");
1101 fprintf(file
, "\n");
1103 for (unsigned i
= 0; i
< shProg
->NumShaders
; i
++) {
1104 fprintf(file
, "[%s shader]\n%s\n",
1105 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1106 shProg
->Shaders
[i
]->Source
);
1110 _mesa_warning(ctx
, "Failed to open %s", filename
);
1113 ralloc_free(filename
);
1116 if (shProg
->LinkStatus
== GL_FALSE
&&
1117 (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
)) {
1118 _mesa_debug(ctx
, "Error linking program %u:\n%s\n",
1119 shProg
->Name
, shProg
->InfoLog
);
1126 printf("Link %u shaders in program %u: %s\n",
1127 shProg
->NumShaders
, shProg
->Name
,
1128 shProg
->LinkStatus
? "Success" : "Failed");
1130 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1131 printf(" shader %u, stage %u\n",
1132 shProg
->Shaders
[i
]->Name
,
1133 shProg
->Shaders
[i
]->Stage
);
1140 * Print basic shader info (for debug).
1143 print_shader_info(const struct gl_shader_program
*shProg
)
1147 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
1148 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1149 printf(" %s shader %u, checksum %u\n",
1150 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1151 shProg
->Shaders
[i
]->Name
,
1152 shProg
->Shaders
[i
]->SourceChecksum
);
1154 if (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
])
1155 printf(" vert prog %u\n",
1156 shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
]->Program
->Id
);
1157 if (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
])
1158 printf(" frag prog %u\n",
1159 shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
->Id
);
1160 if (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
])
1161 printf(" geom prog %u\n",
1162 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->Program
->Id
);
1163 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
])
1164 printf(" tesc prog %u\n",
1165 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->Program
->Id
);
1166 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
])
1167 printf(" tese prog %u\n",
1168 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->Program
->Id
);
1173 * Use the named shader program for subsequent glUniform calls
1176 _mesa_active_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1179 if ((shProg
!= NULL
) && !shProg
->LinkStatus
) {
1180 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1181 "%s(program %u not linked)", caller
, shProg
->Name
);
1185 if (ctx
->Shader
.ActiveProgram
!= shProg
) {
1186 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, shProg
);
1192 use_shader_program(struct gl_context
*ctx
, gl_shader_stage stage
,
1193 struct gl_shader_program
*shProg
,
1194 struct gl_pipeline_object
*shTarget
)
1196 struct gl_shader_program
**target
;
1198 target
= &shTarget
->CurrentProgram
[stage
];
1199 if ((shProg
!= NULL
) && (shProg
->_LinkedShaders
[stage
] == NULL
))
1203 _mesa_shader_program_init_subroutine_defaults(ctx
, shProg
);
1205 if (*target
!= shProg
) {
1206 /* Program is current, flush it */
1207 if (shTarget
== ctx
->_Shader
) {
1208 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
1211 /* If the shader is also bound as the current rendering shader, unbind
1212 * it from that binding point as well. This ensures that the correct
1213 * semantics of glDeleteProgram are maintained.
1216 case MESA_SHADER_VERTEX
:
1217 case MESA_SHADER_TESS_CTRL
:
1218 case MESA_SHADER_TESS_EVAL
:
1219 case MESA_SHADER_GEOMETRY
:
1220 case MESA_SHADER_COMPUTE
:
1221 /* Empty for now. */
1223 case MESA_SHADER_FRAGMENT
:
1224 if (*target
== ctx
->_Shader
->_CurrentFragmentProgram
) {
1225 _mesa_reference_shader_program(ctx
,
1226 &ctx
->_Shader
->_CurrentFragmentProgram
,
1232 _mesa_reference_shader_program(ctx
, target
, shProg
);
1239 * Use the named shader program for subsequent rendering.
1242 _mesa_use_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1245 for (i
= 0; i
< MESA_SHADER_STAGES
; i
++)
1246 use_shader_program(ctx
, i
, shProg
, &ctx
->Shader
);
1247 _mesa_active_program(ctx
, shProg
, "glUseProgram");
1252 * Do validation of the given shader program.
1253 * \param errMsg returns error message if validation fails.
1254 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1257 validate_shader_program(const struct gl_shader_program
*shProg
,
1260 if (!shProg
->LinkStatus
) {
1264 /* From the GL spec, a program is invalid if any of these are true:
1266 any two active samplers in the current program object are of
1267 different types, but refer to the same texture image unit,
1269 any active sampler in the current program object refers to a texture
1270 image unit where fixed-function fragment processing accesses a
1271 texture target that does not match the sampler type, or
1273 the sum of the number of active samplers in the program and the
1274 number of texture image units enabled for fixed-function fragment
1275 processing exceeds the combined limit on the total number of texture
1276 image units allowed.
1280 * Check: any two active samplers in the current program object are of
1281 * different types, but refer to the same texture image unit,
1283 if (!_mesa_sampler_uniforms_are_valid(shProg
, errMsg
, 100))
1291 * Called via glValidateProgram()
1294 validate_program(struct gl_context
*ctx
, GLuint program
)
1296 struct gl_shader_program
*shProg
;
1297 char errMsg
[100] = "";
1299 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1304 shProg
->Validated
= validate_shader_program(shProg
, errMsg
);
1305 if (!shProg
->Validated
) {
1306 /* update info log */
1307 if (shProg
->InfoLog
) {
1308 ralloc_free(shProg
->InfoLog
);
1310 shProg
->InfoLog
= ralloc_strdup(shProg
, errMsg
);
1317 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1319 GET_CURRENT_CONTEXT(ctx
);
1320 attach_shader(ctx
, program
, shader
);
1325 _mesa_AttachShader(GLuint program
, GLuint shader
)
1327 GET_CURRENT_CONTEXT(ctx
);
1328 attach_shader(ctx
, program
, shader
);
1333 _mesa_CompileShader(GLuint shaderObj
)
1335 GET_CURRENT_CONTEXT(ctx
);
1336 if (MESA_VERBOSE
& VERBOSE_API
)
1337 _mesa_debug(ctx
, "glCompileShader %u\n", shaderObj
);
1338 _mesa_compile_shader(ctx
, _mesa_lookup_shader_err(ctx
, shaderObj
,
1339 "glCompileShader"));
1344 _mesa_CreateShader(GLenum type
)
1346 GET_CURRENT_CONTEXT(ctx
);
1347 if (MESA_VERBOSE
& VERBOSE_API
)
1348 _mesa_debug(ctx
, "glCreateShader %s\n", _mesa_enum_to_string(type
));
1349 return create_shader(ctx
, type
);
1353 GLhandleARB GLAPIENTRY
1354 _mesa_CreateShaderObjectARB(GLenum type
)
1356 GET_CURRENT_CONTEXT(ctx
);
1357 return create_shader(ctx
, type
);
1362 _mesa_CreateProgram(void)
1364 GET_CURRENT_CONTEXT(ctx
);
1365 if (MESA_VERBOSE
& VERBOSE_API
)
1366 _mesa_debug(ctx
, "glCreateProgram\n");
1367 return create_shader_program(ctx
);
1371 GLhandleARB GLAPIENTRY
1372 _mesa_CreateProgramObjectARB(void)
1374 GET_CURRENT_CONTEXT(ctx
);
1375 return create_shader_program(ctx
);
1380 _mesa_DeleteObjectARB(GLhandleARB obj
)
1382 if (MESA_VERBOSE
& VERBOSE_API
) {
1383 GET_CURRENT_CONTEXT(ctx
);
1384 _mesa_debug(ctx
, "glDeleteObjectARB(%lu)\n", (unsigned long)obj
);
1388 GET_CURRENT_CONTEXT(ctx
);
1389 FLUSH_VERTICES(ctx
, 0);
1390 if (is_program(ctx
, obj
)) {
1391 delete_shader_program(ctx
, obj
);
1393 else if (is_shader(ctx
, obj
)) {
1394 delete_shader(ctx
, obj
);
1404 _mesa_DeleteProgram(GLuint name
)
1407 GET_CURRENT_CONTEXT(ctx
);
1408 FLUSH_VERTICES(ctx
, 0);
1409 delete_shader_program(ctx
, name
);
1415 _mesa_DeleteShader(GLuint name
)
1418 GET_CURRENT_CONTEXT(ctx
);
1419 FLUSH_VERTICES(ctx
, 0);
1420 delete_shader(ctx
, name
);
1426 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1428 GET_CURRENT_CONTEXT(ctx
);
1429 detach_shader(ctx
, program
, shader
);
1434 _mesa_DetachShader(GLuint program
, GLuint shader
)
1436 GET_CURRENT_CONTEXT(ctx
);
1437 detach_shader(ctx
, program
, shader
);
1442 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1443 GLsizei
* count
, GLhandleARB
* obj
)
1445 GET_CURRENT_CONTEXT(ctx
);
1446 get_attached_shaders(ctx
, container
, maxCount
, count
, obj
);
1451 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1452 GLsizei
*count
, GLuint
*obj
)
1454 GET_CURRENT_CONTEXT(ctx
);
1455 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
);
1460 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1461 GLcharARB
* infoLog
)
1463 GET_CURRENT_CONTEXT(ctx
);
1464 if (is_program(ctx
, object
)) {
1465 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1467 else if (is_shader(ctx
, object
)) {
1468 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1471 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1477 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1479 GET_CURRENT_CONTEXT(ctx
);
1480 /* Implement in terms of GetProgramiv, GetShaderiv */
1481 if (is_program(ctx
, object
)) {
1482 if (pname
== GL_OBJECT_TYPE_ARB
) {
1483 *params
= GL_PROGRAM_OBJECT_ARB
;
1486 get_programiv(ctx
, object
, pname
, params
);
1489 else if (is_shader(ctx
, object
)) {
1490 if (pname
== GL_OBJECT_TYPE_ARB
) {
1491 *params
= GL_SHADER_OBJECT_ARB
;
1494 get_shaderiv(ctx
, object
, pname
, params
);
1498 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1504 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1507 GLint iparams
[1] = {0}; /* XXX is one element enough? */
1508 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1509 params
[0] = (GLfloat
) iparams
[0];
1514 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1516 GET_CURRENT_CONTEXT(ctx
);
1517 get_programiv(ctx
, program
, pname
, params
);
1522 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1524 GET_CURRENT_CONTEXT(ctx
);
1525 get_shaderiv(ctx
, shader
, pname
, params
);
1530 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1531 GLsizei
*length
, GLchar
*infoLog
)
1533 GET_CURRENT_CONTEXT(ctx
);
1534 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1539 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1540 GLsizei
*length
, GLchar
*infoLog
)
1542 GET_CURRENT_CONTEXT(ctx
);
1543 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1548 _mesa_GetShaderSource(GLuint shader
, GLsizei maxLength
,
1549 GLsizei
*length
, GLchar
*sourceOut
)
1551 GET_CURRENT_CONTEXT(ctx
);
1552 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1556 GLhandleARB GLAPIENTRY
1557 _mesa_GetHandleARB(GLenum pname
)
1559 GET_CURRENT_CONTEXT(ctx
);
1560 return get_handle(ctx
, pname
);
1564 GLboolean GLAPIENTRY
1565 _mesa_IsProgram(GLuint name
)
1567 GET_CURRENT_CONTEXT(ctx
);
1568 return is_program(ctx
, name
);
1572 GLboolean GLAPIENTRY
1573 _mesa_IsShader(GLuint name
)
1575 GET_CURRENT_CONTEXT(ctx
);
1576 return is_shader(ctx
, name
);
1581 _mesa_LinkProgram(GLuint programObj
)
1583 GET_CURRENT_CONTEXT(ctx
);
1584 if (MESA_VERBOSE
& VERBOSE_API
)
1585 _mesa_debug(ctx
, "glLinkProgram %u\n", programObj
);
1586 _mesa_link_program(ctx
, _mesa_lookup_shader_program_err(ctx
, programObj
,
1590 #if defined(HAVE_SHA1)
1592 * Generate a SHA-1 hash value string for given source string.
1595 generate_sha1(const char *source
, char sha_str
[64])
1597 unsigned char sha
[20];
1598 _mesa_sha1_compute(source
, strlen(source
), sha
);
1599 _mesa_sha1_format(sha_str
, sha
);
1603 * Construct a full path for shader replacement functionality using
1606 * <path>/<stage prefix>_<CHECKSUM>.glsl
1609 construct_name(const gl_shader_stage stage
, const char *source
,
1613 static const char *types
[] = {
1614 "VS", "TC", "TE", "GS", "FS", "CS",
1617 generate_sha1(source
, sha
);
1618 return ralloc_asprintf(NULL
, "%s/%s_%s.glsl", path
, types
[stage
], sha
);
1622 * Write given shader source to a file in MESA_SHADER_DUMP_PATH.
1625 dump_shader(const gl_shader_stage stage
, const char *source
)
1627 static bool path_exists
= true;
1634 dump_path
= getenv("MESA_SHADER_DUMP_PATH");
1636 path_exists
= false;
1640 char *name
= construct_name(stage
, source
, dump_path
);
1642 f
= fopen(name
, "w");
1647 GET_CURRENT_CONTEXT(ctx
);
1648 _mesa_warning(ctx
, "could not open %s for dumping shader (%s)", name
,
1655 * Read shader source code from a file.
1656 * Useful for debugging to override an app's shader.
1659 read_shader(const gl_shader_stage stage
, const char *source
)
1662 static bool path_exists
= true;
1663 int len
, shader_size
= 0;
1670 read_path
= getenv("MESA_SHADER_READ_PATH");
1672 path_exists
= false;
1676 char *name
= construct_name(stage
, source
, read_path
);
1677 f
= fopen(name
, "r");
1682 /* allocate enough room for the entire shader */
1683 fseek(f
, 0, SEEK_END
);
1684 shader_size
= ftell(f
);
1686 assert(shader_size
);
1688 /* add one for terminating zero */
1691 buffer
= malloc(shader_size
);
1694 len
= fread(buffer
, 1, shader_size
, f
);
1701 #endif /* HAVE_SHA1 */
1704 * Called via glShaderSource() and glShaderSourceARB() API functions.
1705 * Basically, concatenate the source code strings into one long string
1706 * and pass it to _mesa_shader_source().
1709 _mesa_ShaderSource(GLuint shaderObj
, GLsizei count
,
1710 const GLchar
* const * string
, const GLint
* length
)
1712 GET_CURRENT_CONTEXT(ctx
);
1714 GLsizei i
, totalLength
;
1716 struct gl_shader
*sh
;
1718 #if defined(HAVE_SHA1)
1719 GLcharARB
*replacement
;
1720 #endif /* HAVE_SHA1 */
1722 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glShaderSourceARB");
1726 if (string
== NULL
) {
1727 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
1732 * This array holds offsets of where the appropriate string ends, thus the
1733 * last element will be set to the total length of the source code.
1735 offsets
= malloc(count
* sizeof(GLint
));
1736 if (offsets
== NULL
) {
1737 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1741 for (i
= 0; i
< count
; i
++) {
1742 if (string
[i
] == NULL
) {
1743 free((GLvoid
*) offsets
);
1744 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1745 "glShaderSourceARB(null string)");
1748 if (length
== NULL
|| length
[i
] < 0)
1749 offsets
[i
] = strlen(string
[i
]);
1751 offsets
[i
] = length
[i
];
1752 /* accumulate string lengths */
1754 offsets
[i
] += offsets
[i
- 1];
1757 /* Total length of source string is sum off all strings plus two.
1758 * One extra byte for terminating zero, another extra byte to silence
1759 * valgrind warnings in the parser/grammer code.
1761 totalLength
= offsets
[count
- 1] + 2;
1762 source
= malloc(totalLength
* sizeof(GLcharARB
));
1763 if (source
== NULL
) {
1764 free((GLvoid
*) offsets
);
1765 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1769 for (i
= 0; i
< count
; i
++) {
1770 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
1771 memcpy(source
+ start
, string
[i
],
1772 (offsets
[i
] - start
) * sizeof(GLcharARB
));
1774 source
[totalLength
- 1] = '\0';
1775 source
[totalLength
- 2] = '\0';
1777 #if defined(HAVE_SHA1)
1778 /* Dump original shader source to MESA_SHADER_DUMP_PATH and replace
1779 * if corresponding entry found from MESA_SHADER_READ_PATH.
1781 dump_shader(sh
->Stage
, source
);
1783 replacement
= read_shader(sh
->Stage
, source
);
1786 source
= replacement
;
1788 #endif /* HAVE_SHA1 */
1790 shader_source(sh
, source
);
1797 _mesa_UseProgram(GLuint program
)
1799 GET_CURRENT_CONTEXT(ctx
);
1800 struct gl_shader_program
*shProg
;
1802 if (MESA_VERBOSE
& VERBOSE_API
)
1803 _mesa_debug(ctx
, "glUseProgram %u\n", program
);
1805 if (_mesa_is_xfb_active_and_unpaused(ctx
)) {
1806 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1807 "glUseProgram(transform feedback active)");
1812 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
1816 if (!shProg
->LinkStatus
) {
1817 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1818 "glUseProgram(program %u not linked)", program
);
1823 if (ctx
->_Shader
->Flags
& GLSL_USE_PROG
) {
1824 print_shader_info(shProg
);
1831 /* The ARB_separate_shader_object spec says:
1833 * "The executable code for an individual shader stage is taken from
1834 * the current program for that stage. If there is a current program
1835 * object established by UseProgram, that program is considered current
1836 * for all stages. Otherwise, if there is a bound program pipeline
1837 * object (section 2.14.PPO), the program bound to the appropriate
1838 * stage of the pipeline object is considered current."
1841 /* Attach shader state to the binding point */
1842 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, &ctx
->Shader
);
1843 /* Update the program */
1844 _mesa_use_program(ctx
, shProg
);
1846 /* Must be done first: detach the progam */
1847 _mesa_use_program(ctx
, shProg
);
1848 /* Unattach shader_state binding point */
1849 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, ctx
->Pipeline
.Default
);
1850 /* If a pipeline was bound, rebind it */
1851 if (ctx
->Pipeline
.Current
) {
1852 _mesa_BindProgramPipeline(ctx
->Pipeline
.Current
->Name
);
1859 _mesa_ValidateProgram(GLuint program
)
1861 GET_CURRENT_CONTEXT(ctx
);
1862 validate_program(ctx
, program
);
1867 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1870 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
1871 GLint
* range
, GLint
* precision
)
1873 const struct gl_program_constants
*limits
;
1874 const struct gl_precision
*p
;
1875 GET_CURRENT_CONTEXT(ctx
);
1877 switch (shadertype
) {
1878 case GL_VERTEX_SHADER
:
1879 limits
= &ctx
->Const
.Program
[MESA_SHADER_VERTEX
];
1881 case GL_FRAGMENT_SHADER
:
1882 limits
= &ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
];
1885 _mesa_error(ctx
, GL_INVALID_ENUM
,
1886 "glGetShaderPrecisionFormat(shadertype)");
1890 switch (precisiontype
) {
1892 p
= &limits
->LowFloat
;
1894 case GL_MEDIUM_FLOAT
:
1895 p
= &limits
->MediumFloat
;
1898 p
= &limits
->HighFloat
;
1901 p
= &limits
->LowInt
;
1904 p
= &limits
->MediumInt
;
1907 p
= &limits
->HighInt
;
1910 _mesa_error(ctx
, GL_INVALID_ENUM
,
1911 "glGetShaderPrecisionFormat(precisiontype)");
1915 range
[0] = p
->RangeMin
;
1916 range
[1] = p
->RangeMax
;
1917 precision
[0] = p
->Precision
;
1922 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1925 _mesa_ReleaseShaderCompiler(void)
1927 _mesa_destroy_shader_compiler_caches();
1932 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1935 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
1936 const void* binary
, GLint length
)
1938 GET_CURRENT_CONTEXT(ctx
);
1940 (void) binaryformat
;
1943 /* Page 68, section 7.2 'Shader Binaries" of the of the OpenGL ES 3.1, and
1944 * page 88 of the OpenGL 4.5 specs state:
1946 * "An INVALID_VALUE error is generated if count or length is negative.
1947 * An INVALID_ENUM error is generated if binaryformat is not a supported
1948 * format returned in SHADER_BINARY_FORMATS."
1950 if (n
< 0 || length
< 0) {
1951 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderBinary(count or length < 0)");
1955 _mesa_error(ctx
, GL_INVALID_ENUM
, "glShaderBinary(format)");
1960 _mesa_GetProgramBinary(GLuint program
, GLsizei bufSize
, GLsizei
*length
,
1961 GLenum
*binaryFormat
, GLvoid
*binary
)
1963 struct gl_shader_program
*shProg
;
1964 GLsizei length_dummy
;
1965 GET_CURRENT_CONTEXT(ctx
);
1968 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramBinary(bufSize < 0)");
1972 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramBinary");
1976 /* The ARB_get_program_binary spec says:
1978 * "If <length> is NULL, then no length is returned."
1980 * Ensure that length always points to valid storage to avoid multiple NULL
1981 * pointer checks below.
1984 length
= &length_dummy
;
1987 /* The ARB_get_program_binary spec says:
1989 * "When a program object's LINK_STATUS is FALSE, its program binary
1990 * length is zero, and a call to GetProgramBinary will generate an
1991 * INVALID_OPERATION error.
1993 if (!shProg
->LinkStatus
) {
1994 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1995 "glGetProgramBinary(program %u not linked)",
2002 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2003 "glGetProgramBinary(driver supports zero binary formats)");
2005 (void) binaryFormat
;
2010 _mesa_ProgramBinary(GLuint program
, GLenum binaryFormat
,
2011 const GLvoid
*binary
, GLsizei length
)
2013 struct gl_shader_program
*shProg
;
2014 GET_CURRENT_CONTEXT(ctx
);
2016 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glProgramBinary");
2020 (void) binaryFormat
;
2023 /* Section 2.3.1 (Errors) of the OpenGL 4.5 spec says:
2025 * "If a negative number is provided where an argument of type sizei or
2026 * sizeiptr is specified, an INVALID_VALUE error is generated."
2029 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramBinary(length < 0)");
2033 /* The ARB_get_program_binary spec says:
2035 * "<binaryFormat> and <binary> must be those returned by a previous
2036 * call to GetProgramBinary, and <length> must be the length of the
2037 * program binary as returned by GetProgramBinary or GetProgramiv with
2038 * <pname> PROGRAM_BINARY_LENGTH. Loading the program binary will fail,
2039 * setting the LINK_STATUS of <program> to FALSE, if these conditions
2042 * Since any value of binaryFormat passed "is not one of those specified as
2043 * allowable for [this] command, an INVALID_ENUM error is generated."
2045 shProg
->LinkStatus
= GL_FALSE
;
2046 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramBinary");
2051 _mesa_ProgramParameteri(GLuint program
, GLenum pname
, GLint value
)
2053 struct gl_shader_program
*shProg
;
2054 GET_CURRENT_CONTEXT(ctx
);
2056 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
2057 "glProgramParameteri");
2062 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
2063 /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
2064 * is part of OpenGL ES 3.0. For the ES2 case, this function shouldn't
2065 * even be in the dispatch table, so we shouldn't need to expclicitly
2068 * On desktop, we ignore the 3.0+ requirement because it is silly.
2071 /* The ARB_get_program_binary extension spec says:
2073 * "An INVALID_VALUE error is generated if the <value> argument to
2074 * ProgramParameteri is not TRUE or FALSE."
2076 if (value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2080 /* No need to notify the driver. Any changes will actually take effect
2081 * the next time the shader is linked.
2083 * The ARB_get_program_binary extension spec says:
2085 * "To indicate that a program binary is likely to be retrieved,
2086 * ProgramParameteri should be called with <pname>
2087 * PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
2088 * will not be in effect until the next time LinkProgram or
2089 * ProgramBinary has been called successfully."
2091 * The resloution of issue 9 in the extension spec also says:
2093 * "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
2094 * to indicate to the GL implementation that this program will
2095 * likely be saved with GetProgramBinary at some point. This will
2096 * give the GL implementation the opportunity to track any state
2097 * changes made to the program before being saved such that when it
2098 * is loaded again a recompile can be avoided."
2100 shProg
->BinaryRetreivableHint
= value
;
2103 case GL_PROGRAM_SEPARABLE
:
2104 /* Spec imply that the behavior is the same as ARB_get_program_binary
2105 * Chapter 7.3 Program Objects
2107 if (value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2110 shProg
->SeparateShader
= value
;
2114 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteri(pname=%s)",
2115 _mesa_enum_to_string(pname
));
2120 _mesa_error(ctx
, GL_INVALID_VALUE
,
2121 "glProgramParameteri(pname=%s, value=%d): "
2122 "value must be 0 or 1.",
2123 _mesa_enum_to_string(pname
),
2129 _mesa_use_shader_program(struct gl_context
*ctx
, GLenum type
,
2130 struct gl_shader_program
*shProg
,
2131 struct gl_pipeline_object
*shTarget
)
2133 gl_shader_stage stage
= _mesa_shader_enum_to_shader_stage(type
);
2134 use_shader_program(ctx
, stage
, shProg
, shTarget
);
2139 * Copy program-specific data generated by linking from the gl_shader_program
2140 * object to the gl_program object referred to by the gl_linked_shader.
2142 * This function expects _mesa_reference_program() to have been previously
2143 * called setting the gl_linked_shaders program reference.
2146 _mesa_copy_linked_program_data(const struct gl_shader_program
*src
,
2147 struct gl_linked_shader
*dst_sh
)
2149 assert(dst_sh
->Program
);
2151 struct gl_program
*dst
= dst_sh
->Program
;
2153 dst
->info
.num_abos
= dst_sh
->NumAtomicBuffers
;
2154 dst
->info
.num_images
= dst_sh
->NumImages
;
2156 switch (dst_sh
->Stage
) {
2157 case MESA_SHADER_VERTEX
:
2158 dst
->ClipDistanceArraySize
= src
->Vert
.ClipDistanceArraySize
;
2159 dst
->CullDistanceArraySize
= src
->Vert
.CullDistanceArraySize
;
2161 case MESA_SHADER_TESS_CTRL
: {
2162 dst
->info
.tcs
.vertices_out
= dst_sh
->info
.TessCtrl
.VerticesOut
;
2165 case MESA_SHADER_TESS_EVAL
: {
2166 dst
->info
.tes
.primitive_mode
= dst_sh
->info
.TessEval
.PrimitiveMode
;
2167 dst
->info
.tes
.spacing
= dst_sh
->info
.TessEval
.Spacing
;
2168 dst
->info
.tes
.vertex_order
= dst_sh
->info
.TessEval
.VertexOrder
;
2169 dst
->info
.tes
.point_mode
= dst_sh
->info
.TessEval
.PointMode
;
2170 dst
->ClipDistanceArraySize
= src
->TessEval
.ClipDistanceArraySize
;
2171 dst
->CullDistanceArraySize
= src
->TessEval
.CullDistanceArraySize
;
2174 case MESA_SHADER_GEOMETRY
: {
2175 dst
->info
.gs
.vertices_in
= src
->Geom
.VerticesIn
;
2176 dst
->info
.gs
.vertices_out
= dst_sh
->info
.Geom
.VerticesOut
;
2177 dst
->info
.gs
.invocations
= dst_sh
->info
.Geom
.Invocations
;
2178 dst
->info
.gs
.input_primitive
= dst_sh
->info
.Geom
.InputType
;
2179 dst
->info
.gs
.output_primitive
= dst_sh
->info
.Geom
.OutputType
;
2180 dst
->ClipDistanceArraySize
= src
->Geom
.ClipDistanceArraySize
;
2181 dst
->CullDistanceArraySize
= src
->Geom
.CullDistanceArraySize
;
2182 dst
->info
.gs
.uses_end_primitive
= src
->Geom
.UsesEndPrimitive
;
2183 dst
->info
.gs
.uses_streams
= src
->Geom
.UsesStreams
;
2186 case MESA_SHADER_FRAGMENT
: {
2187 dst
->info
.fs
.depth_layout
= src
->FragDepthLayout
;
2188 dst
->info
.fs
.early_fragment_tests
= dst_sh
->info
.EarlyFragmentTests
;
2191 case MESA_SHADER_COMPUTE
: {
2192 for (int i
= 0; i
< 3; i
++)
2193 dst
->info
.cs
.local_size
[i
] = src
->Comp
.LocalSize
[i
];
2194 dst
->info
.cs
.shared_size
= src
->Comp
.SharedSize
;
2203 * ARB_separate_shader_objects: Compile & Link Program
2206 _mesa_CreateShaderProgramv(GLenum type
, GLsizei count
,
2207 const GLchar
* const *strings
)
2209 GET_CURRENT_CONTEXT(ctx
);
2211 const GLuint shader
= create_shader(ctx
, type
);
2215 * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2216 * GL_INVALID_VALUE should be generated if count < 0
2219 _mesa_error(ctx
, GL_INVALID_VALUE
, "glCreateShaderProgram (count < 0)");
2224 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
2226 _mesa_ShaderSource(shader
, count
, strings
, NULL
);
2227 _mesa_compile_shader(ctx
, sh
);
2229 program
= create_shader_program(ctx
);
2231 struct gl_shader_program
*shProg
;
2232 GLint compiled
= GL_FALSE
;
2234 shProg
= _mesa_lookup_shader_program(ctx
, program
);
2236 shProg
->SeparateShader
= GL_TRUE
;
2238 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
2240 attach_shader(ctx
, program
, shader
);
2241 _mesa_link_program(ctx
, shProg
);
2242 detach_shader(ctx
, program
, shader
);
2246 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
2247 append
-error
-to
-info
-log
;
2248 shProg
->LinkStatus
= GL_FALSE
;
2253 ralloc_strcat(&shProg
->InfoLog
, sh
->InfoLog
);
2256 delete_shader(ctx
, shader
);
2264 * For GL_ARB_tessellation_shader
2266 extern void GLAPIENTRY
2267 _mesa_PatchParameteri(GLenum pname
, GLint value
)
2269 GET_CURRENT_CONTEXT(ctx
);
2271 if (!_mesa_has_tessellation(ctx
)) {
2272 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameteri");
2276 if (pname
!= GL_PATCH_VERTICES
) {
2277 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameteri");
2281 if (value
<= 0 || value
> ctx
->Const
.MaxPatchVertices
) {
2282 _mesa_error(ctx
, GL_INVALID_VALUE
, "glPatchParameteri");
2286 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2290 extern void GLAPIENTRY
2291 _mesa_PatchParameterfv(GLenum pname
, const GLfloat
*values
)
2293 GET_CURRENT_CONTEXT(ctx
);
2295 if (!_mesa_has_tessellation(ctx
)) {
2296 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameterfv");
2301 case GL_PATCH_DEFAULT_OUTER_LEVEL
:
2302 FLUSH_VERTICES(ctx
, 0);
2303 memcpy(ctx
->TessCtrlProgram
.patch_default_outer_level
, values
,
2304 4 * sizeof(GLfloat
));
2305 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2307 case GL_PATCH_DEFAULT_INNER_LEVEL
:
2308 FLUSH_VERTICES(ctx
, 0);
2309 memcpy(ctx
->TessCtrlProgram
.patch_default_inner_level
, values
,
2310 2 * sizeof(GLfloat
));
2311 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2314 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameterfv");
2320 * ARB_shader_subroutine
2323 _mesa_GetSubroutineUniformLocation(GLuint program
, GLenum shadertype
,
2326 GET_CURRENT_CONTEXT(ctx
);
2327 const char *api_name
= "glGetSubroutineUniformLocation";
2328 struct gl_shader_program
*shProg
;
2329 GLenum resource_type
;
2330 gl_shader_stage stage
;
2332 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2333 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2337 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2338 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2342 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2346 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2347 if (!shProg
->_LinkedShaders
[stage
]) {
2348 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2352 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2353 return _mesa_program_resource_location(shProg
, resource_type
, name
);
2357 _mesa_GetSubroutineIndex(GLuint program
, GLenum shadertype
,
2360 GET_CURRENT_CONTEXT(ctx
);
2361 const char *api_name
= "glGetSubroutineIndex";
2362 struct gl_shader_program
*shProg
;
2363 struct gl_program_resource
*res
;
2364 GLenum resource_type
;
2365 gl_shader_stage stage
;
2367 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2368 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2372 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2373 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2377 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2381 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2382 if (!shProg
->_LinkedShaders
[stage
]) {
2383 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2387 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2388 res
= _mesa_program_resource_find_name(shProg
, resource_type
, name
, NULL
);
2393 return _mesa_program_resource_index(shProg
, res
);
2398 _mesa_GetActiveSubroutineUniformiv(GLuint program
, GLenum shadertype
,
2399 GLuint index
, GLenum pname
, GLint
*values
)
2401 GET_CURRENT_CONTEXT(ctx
);
2402 const char *api_name
= "glGetActiveSubroutineUniformiv";
2403 struct gl_shader_program
*shProg
;
2404 struct gl_linked_shader
*sh
;
2405 gl_shader_stage stage
;
2406 struct gl_program_resource
*res
;
2407 const struct gl_uniform_storage
*uni
;
2408 GLenum resource_type
;
2411 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2412 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2416 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2417 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2421 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2425 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2426 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2428 sh
= shProg
->_LinkedShaders
[stage
];
2430 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2434 if (index
>= sh
->NumSubroutineUniforms
) {
2435 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s: invalid index greater than GL_ACTIVE_SUBROUTINE_UNIFORMS", api_name
);
2440 case GL_NUM_COMPATIBLE_SUBROUTINES
: {
2441 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2444 values
[0] = uni
->num_compatible_subroutines
;
2448 case GL_COMPATIBLE_SUBROUTINES
: {
2449 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2453 for (i
= 0; i
< sh
->NumSubroutineFunctions
; i
++) {
2454 struct gl_subroutine_function
*fn
= &sh
->SubroutineFunctions
[i
];
2455 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2456 if (fn
->types
[j
] == uni
->type
) {
2457 values
[count
++] = i
;
2465 case GL_UNIFORM_SIZE
:
2466 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2469 values
[0] = uni
->array_elements
? uni
->array_elements
: 1;
2472 case GL_UNIFORM_NAME_LENGTH
:
2473 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2475 values
[0] = strlen(_mesa_program_resource_name(res
)) + 1
2476 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2480 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2487 _mesa_GetActiveSubroutineUniformName(GLuint program
, GLenum shadertype
,
2488 GLuint index
, GLsizei bufsize
,
2489 GLsizei
*length
, GLchar
*name
)
2491 GET_CURRENT_CONTEXT(ctx
);
2492 const char *api_name
= "glGetActiveSubroutineUniformName";
2493 struct gl_shader_program
*shProg
;
2494 GLenum resource_type
;
2495 gl_shader_stage stage
;
2497 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2498 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2502 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2503 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2507 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2511 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2512 if (!shProg
->_LinkedShaders
[stage
]) {
2513 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2517 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2518 /* get program resource name */
2519 _mesa_get_program_resource_name(shProg
, resource_type
,
2521 length
, name
, api_name
);
2526 _mesa_GetActiveSubroutineName(GLuint program
, GLenum shadertype
,
2527 GLuint index
, GLsizei bufsize
,
2528 GLsizei
*length
, GLchar
*name
)
2530 GET_CURRENT_CONTEXT(ctx
);
2531 const char *api_name
= "glGetActiveSubroutineName";
2532 struct gl_shader_program
*shProg
;
2533 GLenum resource_type
;
2534 gl_shader_stage stage
;
2536 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2537 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2541 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2542 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2546 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2550 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2551 if (!shProg
->_LinkedShaders
[stage
]) {
2552 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2555 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2556 _mesa_get_program_resource_name(shProg
, resource_type
,
2558 length
, name
, api_name
);
2562 _mesa_UniformSubroutinesuiv(GLenum shadertype
, GLsizei count
,
2563 const GLuint
*indices
)
2565 GET_CURRENT_CONTEXT(ctx
);
2566 const char *api_name
= "glUniformSubroutinesuiv";
2567 struct gl_shader_program
*shProg
;
2568 struct gl_linked_shader
*sh
;
2569 gl_shader_stage stage
;
2572 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2573 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2577 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2578 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2582 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2583 shProg
= ctx
->_Shader
->CurrentProgram
[stage
];
2585 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2589 sh
= shProg
->_LinkedShaders
[stage
];
2591 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2595 if (count
!= sh
->NumSubroutineUniformRemapTable
) {
2596 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2602 struct gl_uniform_storage
*uni
= sh
->SubroutineUniformRemapTable
[i
];
2608 int uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
2611 for (j
= i
; j
< i
+ uni_count
; j
++) {
2612 struct gl_subroutine_function
*subfn
= NULL
;
2613 if (indices
[j
] > sh
->MaxSubroutineFunctionIndex
) {
2614 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2618 for (f
= 0; f
< sh
->NumSubroutineFunctions
; f
++) {
2619 if (sh
->SubroutineFunctions
[f
].index
== indices
[j
])
2620 subfn
= &sh
->SubroutineFunctions
[f
];
2627 for (k
= 0; k
< subfn
->num_compat_types
; k
++) {
2628 if (subfn
->types
[k
] == uni
->type
)
2631 if (k
== subfn
->num_compat_types
) {
2632 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2636 ctx
->SubroutineIndex
[sh
->Stage
].IndexPtr
[j
] = indices
[j
];
2641 FLUSH_VERTICES(ctx
, _NEW_PROGRAM_CONSTANTS
);
2646 _mesa_GetUniformSubroutineuiv(GLenum shadertype
, GLint location
,
2649 GET_CURRENT_CONTEXT(ctx
);
2650 const char *api_name
= "glGetUniformSubroutineuiv";
2651 struct gl_shader_program
*shProg
;
2652 struct gl_linked_shader
*sh
;
2653 gl_shader_stage stage
;
2655 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2656 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2660 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2661 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2665 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2666 shProg
= ctx
->_Shader
->CurrentProgram
[stage
];
2668 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2672 sh
= shProg
->_LinkedShaders
[stage
];
2674 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2678 if (location
>= sh
->NumSubroutineUniformRemapTable
) {
2679 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2683 *params
= ctx
->SubroutineIndex
[sh
->Stage
].IndexPtr
[location
];
2688 _mesa_GetProgramStageiv(GLuint program
, GLenum shadertype
,
2689 GLenum pname
, GLint
*values
)
2691 GET_CURRENT_CONTEXT(ctx
);
2692 const char *api_name
= "glGetProgramStageiv";
2693 struct gl_shader_program
*shProg
;
2694 struct gl_linked_shader
*sh
;
2695 gl_shader_stage stage
;
2697 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2698 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2702 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2703 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2707 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2711 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2712 sh
= shProg
->_LinkedShaders
[stage
];
2714 /* ARB_shader_subroutine doesn't ask the program to be linked, or list any
2715 * INVALID_OPERATION in the case of not be linked.
2717 * And for some pnames, like GL_ACTIVE_SUBROUTINE_UNIFORMS, you can ask the
2718 * same info using other specs (ARB_program_interface_query), without the
2719 * need of the program to be linked, being the value for that case 0.
2721 * But at the same time, some other methods require the program to be
2722 * linked for pname related to locations, so it would be inconsistent to
2723 * not do the same here. So we are:
2724 * * Return GL_INVALID_OPERATION if not linked only for locations.
2725 * * Setting a default value of 0, to be returned if not linked.
2729 if (pname
== GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
) {
2730 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2736 case GL_ACTIVE_SUBROUTINES
:
2737 values
[0] = sh
->NumSubroutineFunctions
;
2739 case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
:
2740 values
[0] = sh
->NumSubroutineUniformRemapTable
;
2742 case GL_ACTIVE_SUBROUTINE_UNIFORMS
:
2743 values
[0] = sh
->NumSubroutineUniforms
;
2745 case GL_ACTIVE_SUBROUTINE_MAX_LENGTH
:
2749 GLenum resource_type
;
2750 struct gl_program_resource
*res
;
2752 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2753 for (i
= 0; i
< sh
->NumSubroutineFunctions
; i
++) {
2754 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
2756 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1;
2761 values
[0] = max_len
;
2764 case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH
:
2768 GLenum resource_type
;
2769 struct gl_program_resource
*res
;
2771 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2772 for (i
= 0; i
< sh
->NumSubroutineUniformRemapTable
; i
++) {
2773 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
2775 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1
2776 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2782 values
[0] = max_len
;
2786 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s", api_name
);
2793 find_compat_subroutine(struct gl_linked_shader
*sh
,
2794 const struct glsl_type
*type
)
2798 for (i
= 0; i
< sh
->NumSubroutineFunctions
; i
++) {
2799 struct gl_subroutine_function
*fn
= &sh
->SubroutineFunctions
[i
];
2800 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2801 if (fn
->types
[j
] == type
)
2809 _mesa_shader_write_subroutine_index(struct gl_context
*ctx
,
2810 struct gl_linked_shader
*sh
)
2814 if (sh
->NumSubroutineUniformRemapTable
== 0)
2819 struct gl_uniform_storage
*uni
= sh
->SubroutineUniformRemapTable
[i
];
2828 uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
2829 for (j
= 0; j
< uni_count
; j
++) {
2830 val
= ctx
->SubroutineIndex
[sh
->Stage
].IndexPtr
[i
+ j
];
2831 memcpy(&uni
->storage
[j
], &val
, sizeof(int));
2834 _mesa_propagate_uniforms_to_driver_storage(uni
, 0, uni_count
);
2836 } while(i
< sh
->NumSubroutineUniformRemapTable
);
2840 _mesa_shader_write_subroutine_indices(struct gl_context
*ctx
,
2841 gl_shader_stage stage
)
2843 if (ctx
->_Shader
->CurrentProgram
[stage
] &&
2844 ctx
->_Shader
->CurrentProgram
[stage
]->_LinkedShaders
[stage
])
2845 _mesa_shader_write_subroutine_index(ctx
,
2846 ctx
->_Shader
->CurrentProgram
[stage
]->_LinkedShaders
[stage
]);
2850 _mesa_shader_init_subroutine_defaults(struct gl_context
*ctx
,
2851 struct gl_linked_shader
*sh
)
2854 struct gl_subroutine_index_binding
*binding
= &ctx
->SubroutineIndex
[sh
->Stage
];
2855 if (binding
->NumIndex
!= sh
->NumSubroutineUniformRemapTable
) {
2856 binding
->IndexPtr
= realloc(binding
->IndexPtr
,
2857 sh
->NumSubroutineUniformRemapTable
* (sizeof(GLuint
)));
2858 binding
->NumIndex
= sh
->NumSubroutineUniformRemapTable
;
2861 for (i
= 0; i
< sh
->NumSubroutineUniformRemapTable
; i
++) {
2862 struct gl_uniform_storage
*uni
= sh
->SubroutineUniformRemapTable
[i
];
2867 binding
->IndexPtr
[i
] = find_compat_subroutine(sh
, uni
->type
);
2872 _mesa_shader_program_init_subroutine_defaults(struct gl_context
*ctx
,
2873 struct gl_shader_program
*shProg
)
2880 for (i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
2881 if (!shProg
->_LinkedShaders
[i
])
2884 _mesa_shader_init_subroutine_defaults(ctx
, shProg
->_LinkedShaders
[i
]);