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"
62 #include "util/crc32.h"
65 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
68 _mesa_get_shader_flags(void)
70 GLbitfield flags
= 0x0;
71 const char *env
= getenv("MESA_GLSL");
74 if (strstr(env
, "dump_on_error"))
75 flags
|= GLSL_DUMP_ON_ERROR
;
76 else if (strstr(env
, "dump"))
78 if (strstr(env
, "log"))
80 if (strstr(env
, "nopvert"))
81 flags
|= GLSL_NOP_VERT
;
82 if (strstr(env
, "nopfrag"))
83 flags
|= GLSL_NOP_FRAG
;
84 if (strstr(env
, "nopt"))
86 else if (strstr(env
, "opt"))
88 if (strstr(env
, "uniform"))
89 flags
|= GLSL_UNIFORMS
;
90 if (strstr(env
, "useprog"))
91 flags
|= GLSL_USE_PROG
;
92 if (strstr(env
, "errors"))
93 flags
|= GLSL_REPORT_ERRORS
;
100 * Memoized version of getenv("MESA_SHADER_CAPTURE_PATH").
103 _mesa_get_shader_capture_path(void)
105 static bool read_env_var
= false;
106 static const char *path
= NULL
;
109 path
= getenv("MESA_SHADER_CAPTURE_PATH");
117 * Initialize context's shader state.
120 _mesa_init_shader_state(struct gl_context
*ctx
)
122 /* Device drivers may override these to control what kind of instructions
123 * are generated by the GLSL compiler.
125 struct gl_shader_compiler_options options
;
129 memset(&options
, 0, sizeof(options
));
130 options
.MaxUnrollIterations
= 32;
131 options
.MaxIfDepth
= UINT_MAX
;
133 for (sh
= 0; sh
< MESA_SHADER_STAGES
; ++sh
)
134 memcpy(&ctx
->Const
.ShaderCompilerOptions
[sh
], &options
, sizeof(options
));
136 ctx
->Shader
.Flags
= _mesa_get_shader_flags();
138 if (ctx
->Shader
.Flags
!= 0)
139 ctx
->Const
.GenerateTemporaryNames
= true;
141 /* Extended for ARB_separate_shader_objects */
142 ctx
->Shader
.RefCount
= 1;
143 mtx_init(&ctx
->Shader
.Mutex
, mtx_plain
);
145 ctx
->TessCtrlProgram
.patch_vertices
= 3;
146 for (i
= 0; i
< 4; ++i
)
147 ctx
->TessCtrlProgram
.patch_default_outer_level
[i
] = 1.0;
148 for (i
= 0; i
< 2; ++i
)
149 ctx
->TessCtrlProgram
.patch_default_inner_level
[i
] = 1.0;
154 * Free the per-context shader-related state.
157 _mesa_free_shader_state(struct gl_context
*ctx
)
160 for (i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
161 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
[i
],
164 _mesa_reference_program(ctx
, &ctx
->Shader
._CurrentFragmentProgram
, NULL
);
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
->data
->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
->data
->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
->data
->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
->data
->LinkStatus
;
641 case GL_VALIDATE_STATUS
:
642 *params
= shProg
->data
->Validated
;
644 case GL_INFO_LOG_LENGTH
:
645 *params
= (shProg
->data
->InfoLog
&& shProg
->data
->InfoLog
[0] != '\0') ?
646 strlen(shProg
->data
->InfoLog
) + 1 : 0;
648 case GL_ATTACHED_SHADERS
:
649 *params
= shProg
->NumShaders
;
651 case GL_ACTIVE_ATTRIBUTES
:
652 *params
= _mesa_count_active_attribs(shProg
);
654 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
655 *params
= _mesa_longest_attribute_name_length(shProg
);
657 case GL_ACTIVE_UNIFORMS
: {
659 const unsigned num_uniforms
=
660 shProg
->data
->NumUniformStorage
- shProg
->data
->NumHiddenUniforms
;
661 for (*params
= 0, i
= 0; i
< num_uniforms
; i
++) {
662 if (!shProg
->data
->UniformStorage
[i
].is_shader_storage
)
667 case GL_ACTIVE_UNIFORM_MAX_LENGTH
: {
670 const unsigned num_uniforms
=
671 shProg
->data
->NumUniformStorage
- shProg
->data
->NumHiddenUniforms
;
673 for (i
= 0; i
< num_uniforms
; i
++) {
674 if (shProg
->data
->UniformStorage
[i
].is_shader_storage
)
677 /* Add one for the terminating NUL character for a non-array, and
678 * 4 for the "[0]" and the NUL for an array.
680 const GLint len
= strlen(shProg
->data
->UniformStorage
[i
].name
) + 1 +
681 ((shProg
->data
->UniformStorage
[i
].array_elements
!= 0) ? 3 : 0);
690 case GL_TRANSFORM_FEEDBACK_VARYINGS
:
693 *params
= shProg
->TransformFeedback
.NumVarying
;
695 case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH
: {
701 for (i
= 0; i
< shProg
->TransformFeedback
.NumVarying
; i
++) {
702 /* Add one for the terminating NUL character.
705 strlen(shProg
->TransformFeedback
.VaryingNames
[i
]) + 1;
714 case GL_TRANSFORM_FEEDBACK_BUFFER_MODE
:
717 *params
= shProg
->TransformFeedback
.BufferMode
;
719 case GL_GEOMETRY_VERTICES_OUT
:
722 if (check_gs_query(ctx
, shProg
)) {
723 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
724 info
.Geom
.VerticesOut
;
727 case GL_GEOMETRY_SHADER_INVOCATIONS
:
728 if (!has_core_gs
|| !ctx
->Extensions
.ARB_gpu_shader5
)
730 if (check_gs_query(ctx
, shProg
)) {
731 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
732 info
.Geom
.Invocations
;
735 case GL_GEOMETRY_INPUT_TYPE
:
738 if (check_gs_query(ctx
, shProg
)) {
739 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
743 case GL_GEOMETRY_OUTPUT_TYPE
:
746 if (check_gs_query(ctx
, shProg
)) {
747 *params
= shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->
748 info
.Geom
.OutputType
;
751 case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH
: {
758 for (i
= 0; i
< shProg
->data
->NumUniformBlocks
; i
++) {
759 /* Add one for the terminating NUL character.
761 const GLint len
= strlen(shProg
->data
->UniformBlocks
[i
].Name
) + 1;
770 case GL_ACTIVE_UNIFORM_BLOCKS
:
774 *params
= shProg
->data
->NumUniformBlocks
;
776 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
777 /* This enum isn't part of the OES extension for OpenGL ES 2.0. It is
778 * only available with desktop OpenGL 3.0+ with the
779 * GL_ARB_get_program_binary extension or OpenGL ES 3.0.
781 * On desktop, we ignore the 3.0+ requirement because it is silly.
783 if (!_mesa_is_desktop_gl(ctx
) && !_mesa_is_gles3(ctx
))
786 *params
= shProg
->BinaryRetreivableHint
;
788 case GL_PROGRAM_BINARY_LENGTH
:
791 case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS
:
792 if (!ctx
->Extensions
.ARB_shader_atomic_counters
)
795 *params
= shProg
->data
->NumAtomicBuffers
;
797 case GL_COMPUTE_WORK_GROUP_SIZE
: {
799 if (!_mesa_has_compute_shaders(ctx
))
801 if (!shProg
->data
->LinkStatus
) {
802 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(program not "
806 if (shProg
->_LinkedShaders
[MESA_SHADER_COMPUTE
] == NULL
) {
807 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetProgramiv(no compute "
811 for (i
= 0; i
< 3; i
++)
812 params
[i
] = shProg
->Comp
.LocalSize
[i
];
815 case GL_PROGRAM_SEPARABLE
:
816 /* If the program has not been linked, return initial value 0. */
817 *params
= (shProg
->data
->LinkStatus
== GL_FALSE
) ? 0 : shProg
->SeparateShader
;
820 /* ARB_tessellation_shader */
821 case GL_TESS_CONTROL_OUTPUT_VERTICES
:
824 if (check_tcs_query(ctx
, shProg
)) {
825 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->
826 Program
->info
.tess
.tcs_vertices_out
;
829 case GL_TESS_GEN_MODE
:
832 if (check_tes_query(ctx
, shProg
)) {
833 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
834 info
.TessEval
.PrimitiveMode
;
837 case GL_TESS_GEN_SPACING
:
840 if (check_tes_query(ctx
, shProg
)) {
841 const struct gl_linked_shader
*tes
=
842 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
];
843 switch (tes
->info
.TessEval
.Spacing
) {
844 case TESS_SPACING_EQUAL
:
847 case TESS_SPACING_FRACTIONAL_ODD
:
848 *params
= GL_FRACTIONAL_ODD
;
850 case TESS_SPACING_FRACTIONAL_EVEN
:
851 *params
= GL_FRACTIONAL_EVEN
;
853 case TESS_SPACING_UNSPECIFIED
:
859 case GL_TESS_GEN_VERTEX_ORDER
:
862 if (check_tes_query(ctx
, shProg
)) {
863 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
864 info
.TessEval
.VertexOrder
;
867 case GL_TESS_GEN_POINT_MODE
:
870 if (check_tes_query(ctx
, shProg
)) {
871 *params
= shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->
872 info
.TessEval
.PointMode
;
879 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname=%s)",
880 _mesa_enum_to_string(pname
));
885 * glGetShaderiv() - get GLSL shader state
888 get_shaderiv(struct gl_context
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
890 struct gl_shader
*shader
=
891 _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
899 *params
= shader
->Type
;
901 case GL_DELETE_STATUS
:
902 *params
= shader
->DeletePending
;
904 case GL_COMPILE_STATUS
:
905 *params
= shader
->CompileStatus
;
907 case GL_INFO_LOG_LENGTH
:
908 *params
= (shader
->InfoLog
&& shader
->InfoLog
[0] != '\0') ?
909 strlen(shader
->InfoLog
) + 1 : 0;
911 case GL_SHADER_SOURCE_LENGTH
:
912 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
915 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
922 get_program_info_log(struct gl_context
*ctx
, GLuint program
, GLsizei bufSize
,
923 GLsizei
*length
, GLchar
*infoLog
)
925 struct gl_shader_program
*shProg
;
927 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
928 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
930 * "If a negative number is provided where an argument of type sizei or
931 * sizeiptr is specified, an INVALID_VALUE error is generated."
934 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(bufSize < 0)");
938 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
939 "glGetProgramInfoLog(program)");
944 _mesa_copy_string(infoLog
, bufSize
, length
, shProg
->data
->InfoLog
);
949 get_shader_info_log(struct gl_context
*ctx
, GLuint shader
, GLsizei bufSize
,
950 GLsizei
*length
, GLchar
*infoLog
)
952 struct gl_shader
*sh
;
954 /* Section 2.5 GL Errors (page 18) of the OpenGL ES 3.0.4 spec and
955 * section 2.3.1 (Errors) of the OpenGL 4.5 spec say:
957 * "If a negative number is provided where an argument of type sizei or
958 * sizeiptr is specified, an INVALID_VALUE error is generated."
961 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(bufSize < 0)");
965 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderInfoLog(shader)");
970 _mesa_copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
975 * Return shader source code.
978 get_shader_source(struct gl_context
*ctx
, GLuint shader
, GLsizei maxLength
,
979 GLsizei
*length
, GLchar
*sourceOut
)
981 struct gl_shader
*sh
;
984 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderSource(bufSize < 0)");
988 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
992 _mesa_copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
997 * Set/replace shader source code. A helper function used by
998 * glShaderSource[ARB].
1001 shader_source(struct gl_shader
*sh
, const GLchar
*source
)
1005 /* free old shader source string and install new one */
1006 free((void *)sh
->Source
);
1007 sh
->Source
= source
;
1009 sh
->SourceChecksum
= util_hash_crc32(sh
->Source
, strlen(sh
->Source
));
1018 _mesa_compile_shader(struct gl_context
*ctx
, struct gl_shader
*sh
)
1024 /* If the user called glCompileShader without first calling
1025 * glShaderSource, we should fail to compile, but not raise a GL_ERROR.
1027 sh
->CompileStatus
= GL_FALSE
;
1029 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1030 _mesa_log("GLSL source for %s shader %d:\n",
1031 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1032 _mesa_log("%s\n", sh
->Source
);
1035 /* this call will set the shader->CompileStatus field to indicate if
1036 * compilation was successful.
1038 _mesa_glsl_compile_shader(ctx
, sh
, false, false);
1040 if (ctx
->_Shader
->Flags
& GLSL_LOG
) {
1041 _mesa_write_shader_to_file(sh
);
1044 if (ctx
->_Shader
->Flags
& GLSL_DUMP
) {
1045 if (sh
->CompileStatus
) {
1047 _mesa_log("GLSL IR for shader %d:\n", sh
->Name
);
1048 _mesa_print_ir(_mesa_get_log_file(), sh
->ir
, NULL
);
1050 _mesa_log("No GLSL IR for shader %d (shader may be from "
1051 "cache)\n", sh
->Name
);
1055 _mesa_log("GLSL shader %d failed to compile.\n", sh
->Name
);
1057 if (sh
->InfoLog
&& sh
->InfoLog
[0] != 0) {
1058 _mesa_log("GLSL shader %d info log:\n", sh
->Name
);
1059 _mesa_log("%s\n", sh
->InfoLog
);
1064 if (!sh
->CompileStatus
) {
1065 if (ctx
->_Shader
->Flags
& GLSL_DUMP_ON_ERROR
) {
1066 _mesa_log("GLSL source for %s shader %d:\n",
1067 _mesa_shader_stage_to_string(sh
->Stage
), sh
->Name
);
1068 _mesa_log("%s\n", sh
->Source
);
1069 _mesa_log("Info Log:\n%s\n", sh
->InfoLog
);
1072 if (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
) {
1073 _mesa_debug(ctx
, "Error compiling shader %u:\n%s\n",
1074 sh
->Name
, sh
->InfoLog
);
1081 * Link a program's shaders.
1084 _mesa_link_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1089 /* From the ARB_transform_feedback2 specification:
1090 * "The error INVALID_OPERATION is generated by LinkProgram if <program> is
1091 * the name of a program being used by one or more transform feedback
1092 * objects, even if the objects are not currently bound or are paused."
1094 if (_mesa_transform_feedback_is_using_program(ctx
, shProg
)) {
1095 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1096 "glLinkProgram(transform feedback is using the program)");
1100 unsigned programs_in_use
= 0;
1102 for (unsigned stage
= 0; stage
< MESA_SHADER_STAGES
; stage
++) {
1103 if (ctx
->_Shader
->CurrentProgram
[stage
] == shProg
) {
1104 programs_in_use
|= 1 << stage
;
1108 FLUSH_VERTICES(ctx
, 0);
1109 _mesa_glsl_link_shader(ctx
, shProg
);
1111 /* From section 7.3 (Program Objects) of the OpenGL 4.5 spec:
1113 * "If LinkProgram or ProgramBinary successfully re-links a program
1114 * object that is active for any shader stage, then the newly generated
1115 * executable code will be installed as part of the current rendering
1116 * state for all shader stages where the program is active.
1117 * Additionally, the newly generated executable code is made part of
1118 * the state of any program pipeline for all stages where the program
1121 if (shProg
->data
->LinkStatus
&& programs_in_use
) {
1122 ctx
->NewState
|= _NEW_PROGRAM
;
1125 /* Capture .shader_test files. */
1126 const char *capture_path
= _mesa_get_shader_capture_path();
1127 if (shProg
->Name
!= 0 && shProg
->Name
!= ~0 && capture_path
!= NULL
) {
1129 char *filename
= ralloc_asprintf(NULL
, "%s/%u.shader_test",
1130 capture_path
, shProg
->Name
);
1131 file
= fopen(filename
, "w");
1133 fprintf(file
, "[require]\nGLSL%s >= %u.%02u\n",
1134 shProg
->IsES
? " ES" : "",
1135 shProg
->data
->Version
/ 100, shProg
->data
->Version
% 100);
1136 if (shProg
->SeparateShader
)
1137 fprintf(file
, "GL_ARB_separate_shader_objects\nSSO ENABLED\n");
1138 fprintf(file
, "\n");
1140 for (unsigned i
= 0; i
< shProg
->NumShaders
; i
++) {
1141 fprintf(file
, "[%s shader]\n%s\n",
1142 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1143 shProg
->Shaders
[i
]->Source
);
1147 _mesa_warning(ctx
, "Failed to open %s", filename
);
1150 ralloc_free(filename
);
1153 if (shProg
->data
->LinkStatus
== GL_FALSE
&&
1154 (ctx
->_Shader
->Flags
& GLSL_REPORT_ERRORS
)) {
1155 _mesa_debug(ctx
, "Error linking program %u:\n%s\n",
1156 shProg
->Name
, shProg
->data
->InfoLog
);
1163 printf("Link %u shaders in program %u: %s\n",
1164 shProg
->NumShaders
, shProg
->Name
,
1165 shProg
->data
->LinkStatus
? "Success" : "Failed");
1167 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1168 printf(" shader %u, stage %u\n",
1169 shProg
->Shaders
[i
]->Name
,
1170 shProg
->Shaders
[i
]->Stage
);
1177 * Print basic shader info (for debug).
1180 print_shader_info(const struct gl_shader_program
*shProg
)
1184 printf("Mesa: glUseProgram(%u)\n", shProg
->Name
);
1185 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1187 printf(" %s shader %u, checksum %u\n",
1188 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1189 shProg
->Shaders
[i
]->Name
,
1190 shProg
->Shaders
[i
]->SourceChecksum
);
1192 printf(" %s shader %u\n",
1193 _mesa_shader_stage_to_string(shProg
->Shaders
[i
]->Stage
),
1194 shProg
->Shaders
[i
]->Name
);
1197 if (shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
])
1198 printf(" vert prog %u\n",
1199 shProg
->_LinkedShaders
[MESA_SHADER_VERTEX
]->Program
->Id
);
1200 if (shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
])
1201 printf(" frag prog %u\n",
1202 shProg
->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
->Id
);
1203 if (shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
])
1204 printf(" geom prog %u\n",
1205 shProg
->_LinkedShaders
[MESA_SHADER_GEOMETRY
]->Program
->Id
);
1206 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
])
1207 printf(" tesc prog %u\n",
1208 shProg
->_LinkedShaders
[MESA_SHADER_TESS_CTRL
]->Program
->Id
);
1209 if (shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
])
1210 printf(" tese prog %u\n",
1211 shProg
->_LinkedShaders
[MESA_SHADER_TESS_EVAL
]->Program
->Id
);
1216 * Use the named shader program for subsequent glUniform calls
1219 _mesa_active_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
,
1222 if ((shProg
!= NULL
) && !shProg
->data
->LinkStatus
) {
1223 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1224 "%s(program %u not linked)", caller
, shProg
->Name
);
1228 if (ctx
->Shader
.ActiveProgram
!= shProg
) {
1229 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.ActiveProgram
, shProg
);
1235 use_shader_program(struct gl_context
*ctx
, gl_shader_stage stage
,
1236 struct gl_shader_program
*shProg
,
1237 struct gl_pipeline_object
*shTarget
)
1239 struct gl_shader_program
**target
;
1241 target
= &shTarget
->CurrentProgram
[stage
];
1242 if ((shProg
!= NULL
) && (shProg
->_LinkedShaders
[stage
] == NULL
))
1246 for (unsigned i
= 0; i
< MESA_SHADER_STAGES
; i
++) {
1247 struct gl_linked_shader
*sh
= shProg
->_LinkedShaders
[i
];
1251 _mesa_program_init_subroutine_defaults(ctx
, sh
->Program
);
1255 if (*target
!= shProg
) {
1256 /* Program is current, flush it */
1257 if (shTarget
== ctx
->_Shader
) {
1258 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
1261 /* If the shader is also bound as the current rendering shader, unbind
1262 * it from that binding point as well. This ensures that the correct
1263 * semantics of glDeleteProgram are maintained.
1266 case MESA_SHADER_VERTEX
:
1267 case MESA_SHADER_TESS_CTRL
:
1268 case MESA_SHADER_TESS_EVAL
:
1269 case MESA_SHADER_GEOMETRY
:
1270 case MESA_SHADER_COMPUTE
:
1271 /* Empty for now. */
1273 case MESA_SHADER_FRAGMENT
:
1274 if (*target
!= NULL
&&
1275 ((*target
)->_LinkedShaders
[MESA_SHADER_FRAGMENT
] &&
1276 (*target
)->_LinkedShaders
[MESA_SHADER_FRAGMENT
]->Program
==
1277 ctx
->_Shader
->_CurrentFragmentProgram
)) {
1278 _mesa_reference_program(ctx
,
1279 &ctx
->_Shader
->_CurrentFragmentProgram
,
1285 _mesa_reference_shader_program(ctx
, target
, shProg
);
1292 * Use the named shader program for subsequent rendering.
1295 _mesa_use_program(struct gl_context
*ctx
, struct gl_shader_program
*shProg
)
1298 for (i
= 0; i
< MESA_SHADER_STAGES
; i
++)
1299 use_shader_program(ctx
, i
, shProg
, &ctx
->Shader
);
1300 _mesa_active_program(ctx
, shProg
, "glUseProgram");
1305 * Do validation of the given shader program.
1306 * \param errMsg returns error message if validation fails.
1307 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
1310 validate_shader_program(const struct gl_shader_program
*shProg
,
1313 if (!shProg
->data
->LinkStatus
) {
1317 /* From the GL spec, a program is invalid if any of these are true:
1319 any two active samplers in the current program object are of
1320 different types, but refer to the same texture image unit,
1322 any active sampler in the current program object refers to a texture
1323 image unit where fixed-function fragment processing accesses a
1324 texture target that does not match the sampler type, or
1326 the sum of the number of active samplers in the program and the
1327 number of texture image units enabled for fixed-function fragment
1328 processing exceeds the combined limit on the total number of texture
1329 image units allowed.
1333 * Check: any two active samplers in the current program object are of
1334 * different types, but refer to the same texture image unit,
1336 if (!_mesa_sampler_uniforms_are_valid(shProg
, errMsg
, 100))
1344 * Called via glValidateProgram()
1347 validate_program(struct gl_context
*ctx
, GLuint program
)
1349 struct gl_shader_program
*shProg
;
1350 char errMsg
[100] = "";
1352 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1357 shProg
->data
->Validated
= validate_shader_program(shProg
, errMsg
);
1358 if (!shProg
->data
->Validated
) {
1359 /* update info log */
1360 if (shProg
->data
->InfoLog
) {
1361 ralloc_free(shProg
->data
->InfoLog
);
1363 shProg
->data
->InfoLog
= ralloc_strdup(shProg
->data
, errMsg
);
1370 _mesa_AttachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1372 GET_CURRENT_CONTEXT(ctx
);
1373 attach_shader(ctx
, program
, shader
);
1378 _mesa_AttachShader(GLuint program
, GLuint shader
)
1380 GET_CURRENT_CONTEXT(ctx
);
1381 attach_shader(ctx
, program
, shader
);
1386 _mesa_CompileShader(GLuint shaderObj
)
1388 GET_CURRENT_CONTEXT(ctx
);
1389 if (MESA_VERBOSE
& VERBOSE_API
)
1390 _mesa_debug(ctx
, "glCompileShader %u\n", shaderObj
);
1391 _mesa_compile_shader(ctx
, _mesa_lookup_shader_err(ctx
, shaderObj
,
1392 "glCompileShader"));
1397 _mesa_CreateShader(GLenum type
)
1399 GET_CURRENT_CONTEXT(ctx
);
1400 if (MESA_VERBOSE
& VERBOSE_API
)
1401 _mesa_debug(ctx
, "glCreateShader %s\n", _mesa_enum_to_string(type
));
1402 return create_shader(ctx
, type
);
1406 GLhandleARB GLAPIENTRY
1407 _mesa_CreateShaderObjectARB(GLenum type
)
1409 GET_CURRENT_CONTEXT(ctx
);
1410 return create_shader(ctx
, type
);
1415 _mesa_CreateProgram(void)
1417 GET_CURRENT_CONTEXT(ctx
);
1418 if (MESA_VERBOSE
& VERBOSE_API
)
1419 _mesa_debug(ctx
, "glCreateProgram\n");
1420 return create_shader_program(ctx
);
1424 GLhandleARB GLAPIENTRY
1425 _mesa_CreateProgramObjectARB(void)
1427 GET_CURRENT_CONTEXT(ctx
);
1428 return create_shader_program(ctx
);
1433 _mesa_DeleteObjectARB(GLhandleARB obj
)
1435 if (MESA_VERBOSE
& VERBOSE_API
) {
1436 GET_CURRENT_CONTEXT(ctx
);
1437 _mesa_debug(ctx
, "glDeleteObjectARB(%lu)\n", (unsigned long)obj
);
1441 GET_CURRENT_CONTEXT(ctx
);
1442 FLUSH_VERTICES(ctx
, 0);
1443 if (is_program(ctx
, obj
)) {
1444 delete_shader_program(ctx
, obj
);
1446 else if (is_shader(ctx
, obj
)) {
1447 delete_shader(ctx
, obj
);
1457 _mesa_DeleteProgram(GLuint name
)
1460 GET_CURRENT_CONTEXT(ctx
);
1461 FLUSH_VERTICES(ctx
, 0);
1462 delete_shader_program(ctx
, name
);
1468 _mesa_DeleteShader(GLuint name
)
1471 GET_CURRENT_CONTEXT(ctx
);
1472 FLUSH_VERTICES(ctx
, 0);
1473 delete_shader(ctx
, name
);
1479 _mesa_DetachObjectARB(GLhandleARB program
, GLhandleARB shader
)
1481 GET_CURRENT_CONTEXT(ctx
);
1482 detach_shader(ctx
, program
, shader
);
1487 _mesa_DetachShader(GLuint program
, GLuint shader
)
1489 GET_CURRENT_CONTEXT(ctx
);
1490 detach_shader(ctx
, program
, shader
);
1495 _mesa_GetAttachedObjectsARB(GLhandleARB container
, GLsizei maxCount
,
1496 GLsizei
* count
, GLhandleARB
* obj
)
1498 GET_CURRENT_CONTEXT(ctx
);
1499 get_attached_shaders(ctx
, container
, maxCount
, count
, obj
);
1504 _mesa_GetAttachedShaders(GLuint program
, GLsizei maxCount
,
1505 GLsizei
*count
, GLuint
*obj
)
1507 GET_CURRENT_CONTEXT(ctx
);
1508 get_attached_shaders(ctx
, program
, maxCount
, count
, obj
);
1513 _mesa_GetInfoLogARB(GLhandleARB object
, GLsizei maxLength
, GLsizei
* length
,
1514 GLcharARB
* infoLog
)
1516 GET_CURRENT_CONTEXT(ctx
);
1517 if (is_program(ctx
, object
)) {
1518 get_program_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1520 else if (is_shader(ctx
, object
)) {
1521 get_shader_info_log(ctx
, object
, maxLength
, length
, infoLog
);
1524 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInfoLogARB");
1530 _mesa_GetObjectParameterivARB(GLhandleARB object
, GLenum pname
, GLint
*params
)
1532 GET_CURRENT_CONTEXT(ctx
);
1533 /* Implement in terms of GetProgramiv, GetShaderiv */
1534 if (is_program(ctx
, object
)) {
1535 if (pname
== GL_OBJECT_TYPE_ARB
) {
1536 *params
= GL_PROGRAM_OBJECT_ARB
;
1539 get_programiv(ctx
, object
, pname
, params
);
1542 else if (is_shader(ctx
, object
)) {
1543 if (pname
== GL_OBJECT_TYPE_ARB
) {
1544 *params
= GL_SHADER_OBJECT_ARB
;
1547 get_shaderiv(ctx
, object
, pname
, params
);
1551 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetObjectParameterivARB");
1557 _mesa_GetObjectParameterfvARB(GLhandleARB object
, GLenum pname
,
1560 GLint iparams
[1] = {0}; /* XXX is one element enough? */
1561 _mesa_GetObjectParameterivARB(object
, pname
, iparams
);
1562 params
[0] = (GLfloat
) iparams
[0];
1567 _mesa_GetProgramiv(GLuint program
, GLenum pname
, GLint
*params
)
1569 GET_CURRENT_CONTEXT(ctx
);
1570 get_programiv(ctx
, program
, pname
, params
);
1575 _mesa_GetShaderiv(GLuint shader
, GLenum pname
, GLint
*params
)
1577 GET_CURRENT_CONTEXT(ctx
);
1578 get_shaderiv(ctx
, shader
, pname
, params
);
1583 _mesa_GetProgramInfoLog(GLuint program
, GLsizei bufSize
,
1584 GLsizei
*length
, GLchar
*infoLog
)
1586 GET_CURRENT_CONTEXT(ctx
);
1587 get_program_info_log(ctx
, program
, bufSize
, length
, infoLog
);
1592 _mesa_GetShaderInfoLog(GLuint shader
, GLsizei bufSize
,
1593 GLsizei
*length
, GLchar
*infoLog
)
1595 GET_CURRENT_CONTEXT(ctx
);
1596 get_shader_info_log(ctx
, shader
, bufSize
, length
, infoLog
);
1601 _mesa_GetShaderSource(GLuint shader
, GLsizei maxLength
,
1602 GLsizei
*length
, GLchar
*sourceOut
)
1604 GET_CURRENT_CONTEXT(ctx
);
1605 get_shader_source(ctx
, shader
, maxLength
, length
, sourceOut
);
1609 GLhandleARB GLAPIENTRY
1610 _mesa_GetHandleARB(GLenum pname
)
1612 GET_CURRENT_CONTEXT(ctx
);
1613 return get_handle(ctx
, pname
);
1617 GLboolean GLAPIENTRY
1618 _mesa_IsProgram(GLuint name
)
1620 GET_CURRENT_CONTEXT(ctx
);
1621 return is_program(ctx
, name
);
1625 GLboolean GLAPIENTRY
1626 _mesa_IsShader(GLuint name
)
1628 GET_CURRENT_CONTEXT(ctx
);
1629 return is_shader(ctx
, name
);
1634 _mesa_LinkProgram(GLuint programObj
)
1636 GET_CURRENT_CONTEXT(ctx
);
1637 if (MESA_VERBOSE
& VERBOSE_API
)
1638 _mesa_debug(ctx
, "glLinkProgram %u\n", programObj
);
1639 _mesa_link_program(ctx
, _mesa_lookup_shader_program_err(ctx
, programObj
,
1643 #ifdef ENABLE_SHADER_CACHE
1645 * Generate a SHA-1 hash value string for given source string.
1648 generate_sha1(const char *source
, char sha_str
[64])
1650 unsigned char sha
[20];
1651 _mesa_sha1_compute(source
, strlen(source
), sha
);
1652 _mesa_sha1_format(sha_str
, sha
);
1656 * Construct a full path for shader replacement functionality using
1659 * <path>/<stage prefix>_<CHECKSUM>.glsl
1662 construct_name(const gl_shader_stage stage
, const char *source
,
1666 static const char *types
[] = {
1667 "VS", "TC", "TE", "GS", "FS", "CS",
1670 generate_sha1(source
, sha
);
1671 return ralloc_asprintf(NULL
, "%s/%s_%s.glsl", path
, types
[stage
], sha
);
1675 * Write given shader source to a file in MESA_SHADER_DUMP_PATH.
1678 dump_shader(const gl_shader_stage stage
, const char *source
)
1680 static bool path_exists
= true;
1687 dump_path
= getenv("MESA_SHADER_DUMP_PATH");
1689 path_exists
= false;
1693 char *name
= construct_name(stage
, source
, dump_path
);
1695 f
= fopen(name
, "w");
1700 GET_CURRENT_CONTEXT(ctx
);
1701 _mesa_warning(ctx
, "could not open %s for dumping shader (%s)", name
,
1708 * Read shader source code from a file.
1709 * Useful for debugging to override an app's shader.
1712 read_shader(const gl_shader_stage stage
, const char *source
)
1715 static bool path_exists
= true;
1716 int len
, shader_size
= 0;
1723 read_path
= getenv("MESA_SHADER_READ_PATH");
1725 path_exists
= false;
1729 char *name
= construct_name(stage
, source
, read_path
);
1730 f
= fopen(name
, "r");
1735 /* allocate enough room for the entire shader */
1736 fseek(f
, 0, SEEK_END
);
1737 shader_size
= ftell(f
);
1739 assert(shader_size
);
1741 /* add one for terminating zero */
1744 buffer
= malloc(shader_size
);
1747 len
= fread(buffer
, 1, shader_size
, f
);
1755 #endif /* ENABLE_SHADER_CACHE */
1758 * Called via glShaderSource() and glShaderSourceARB() API functions.
1759 * Basically, concatenate the source code strings into one long string
1760 * and pass it to _mesa_shader_source().
1763 _mesa_ShaderSource(GLuint shaderObj
, GLsizei count
,
1764 const GLchar
* const * string
, const GLint
* length
)
1766 GET_CURRENT_CONTEXT(ctx
);
1768 GLsizei i
, totalLength
;
1770 struct gl_shader
*sh
;
1772 GLcharARB
*replacement
;
1774 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glShaderSourceARB");
1778 if (string
== NULL
) {
1779 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderSourceARB");
1784 * This array holds offsets of where the appropriate string ends, thus the
1785 * last element will be set to the total length of the source code.
1787 offsets
= malloc(count
* sizeof(GLint
));
1788 if (offsets
== NULL
) {
1789 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1793 for (i
= 0; i
< count
; i
++) {
1794 if (string
[i
] == NULL
) {
1795 free((GLvoid
*) offsets
);
1796 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1797 "glShaderSourceARB(null string)");
1800 if (length
== NULL
|| length
[i
] < 0)
1801 offsets
[i
] = strlen(string
[i
]);
1803 offsets
[i
] = length
[i
];
1804 /* accumulate string lengths */
1806 offsets
[i
] += offsets
[i
- 1];
1809 /* Total length of source string is sum off all strings plus two.
1810 * One extra byte for terminating zero, another extra byte to silence
1811 * valgrind warnings in the parser/grammer code.
1813 totalLength
= offsets
[count
- 1] + 2;
1814 source
= malloc(totalLength
* sizeof(GLcharARB
));
1815 if (source
== NULL
) {
1816 free((GLvoid
*) offsets
);
1817 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glShaderSourceARB");
1821 for (i
= 0; i
< count
; i
++) {
1822 GLint start
= (i
> 0) ? offsets
[i
- 1] : 0;
1823 memcpy(source
+ start
, string
[i
],
1824 (offsets
[i
] - start
) * sizeof(GLcharARB
));
1826 source
[totalLength
- 1] = '\0';
1827 source
[totalLength
- 2] = '\0';
1829 #ifdef ENABLE_SHADER_CACHE
1830 /* Dump original shader source to MESA_SHADER_DUMP_PATH and replace
1831 * if corresponding entry found from MESA_SHADER_READ_PATH.
1833 dump_shader(sh
->Stage
, source
);
1835 replacement
= read_shader(sh
->Stage
, source
);
1838 source
= replacement
;
1840 #endif /* ENABLE_SHADER_CACHE */
1842 shader_source(sh
, source
);
1849 _mesa_UseProgram(GLuint program
)
1851 GET_CURRENT_CONTEXT(ctx
);
1852 struct gl_shader_program
*shProg
;
1854 if (MESA_VERBOSE
& VERBOSE_API
)
1855 _mesa_debug(ctx
, "glUseProgram %u\n", program
);
1857 if (_mesa_is_xfb_active_and_unpaused(ctx
)) {
1858 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1859 "glUseProgram(transform feedback active)");
1864 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
1868 if (!shProg
->data
->LinkStatus
) {
1869 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1870 "glUseProgram(program %u not linked)", program
);
1875 if (ctx
->_Shader
->Flags
& GLSL_USE_PROG
) {
1876 print_shader_info(shProg
);
1883 /* The ARB_separate_shader_object spec says:
1885 * "The executable code for an individual shader stage is taken from
1886 * the current program for that stage. If there is a current program
1887 * object established by UseProgram, that program is considered current
1888 * for all stages. Otherwise, if there is a bound program pipeline
1889 * object (section 2.14.PPO), the program bound to the appropriate
1890 * stage of the pipeline object is considered current."
1893 /* Attach shader state to the binding point */
1894 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, &ctx
->Shader
);
1895 /* Update the program */
1896 _mesa_use_program(ctx
, shProg
);
1898 /* Must be done first: detach the progam */
1899 _mesa_use_program(ctx
, shProg
);
1900 /* Unattach shader_state binding point */
1901 _mesa_reference_pipeline_object(ctx
, &ctx
->_Shader
, ctx
->Pipeline
.Default
);
1902 /* If a pipeline was bound, rebind it */
1903 if (ctx
->Pipeline
.Current
) {
1904 _mesa_BindProgramPipeline(ctx
->Pipeline
.Current
->Name
);
1911 _mesa_ValidateProgram(GLuint program
)
1913 GET_CURRENT_CONTEXT(ctx
);
1914 validate_program(ctx
, program
);
1919 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1922 _mesa_GetShaderPrecisionFormat(GLenum shadertype
, GLenum precisiontype
,
1923 GLint
* range
, GLint
* precision
)
1925 const struct gl_program_constants
*limits
;
1926 const struct gl_precision
*p
;
1927 GET_CURRENT_CONTEXT(ctx
);
1929 switch (shadertype
) {
1930 case GL_VERTEX_SHADER
:
1931 limits
= &ctx
->Const
.Program
[MESA_SHADER_VERTEX
];
1933 case GL_FRAGMENT_SHADER
:
1934 limits
= &ctx
->Const
.Program
[MESA_SHADER_FRAGMENT
];
1937 _mesa_error(ctx
, GL_INVALID_ENUM
,
1938 "glGetShaderPrecisionFormat(shadertype)");
1942 switch (precisiontype
) {
1944 p
= &limits
->LowFloat
;
1946 case GL_MEDIUM_FLOAT
:
1947 p
= &limits
->MediumFloat
;
1950 p
= &limits
->HighFloat
;
1953 p
= &limits
->LowInt
;
1956 p
= &limits
->MediumInt
;
1959 p
= &limits
->HighInt
;
1962 _mesa_error(ctx
, GL_INVALID_ENUM
,
1963 "glGetShaderPrecisionFormat(precisiontype)");
1967 range
[0] = p
->RangeMin
;
1968 range
[1] = p
->RangeMax
;
1969 precision
[0] = p
->Precision
;
1974 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1977 _mesa_ReleaseShaderCompiler(void)
1979 _mesa_destroy_shader_compiler_caches();
1984 * For OpenGL ES 2.0, GL_ARB_ES2_compatibility
1987 _mesa_ShaderBinary(GLint n
, const GLuint
* shaders
, GLenum binaryformat
,
1988 const void* binary
, GLint length
)
1990 GET_CURRENT_CONTEXT(ctx
);
1992 (void) binaryformat
;
1995 /* Page 68, section 7.2 'Shader Binaries" of the of the OpenGL ES 3.1, and
1996 * page 88 of the OpenGL 4.5 specs state:
1998 * "An INVALID_VALUE error is generated if count or length is negative.
1999 * An INVALID_ENUM error is generated if binaryformat is not a supported
2000 * format returned in SHADER_BINARY_FORMATS."
2002 if (n
< 0 || length
< 0) {
2003 _mesa_error(ctx
, GL_INVALID_VALUE
, "glShaderBinary(count or length < 0)");
2007 _mesa_error(ctx
, GL_INVALID_ENUM
, "glShaderBinary(format)");
2012 _mesa_GetProgramBinary(GLuint program
, GLsizei bufSize
, GLsizei
*length
,
2013 GLenum
*binaryFormat
, GLvoid
*binary
)
2015 struct gl_shader_program
*shProg
;
2016 GLsizei length_dummy
;
2017 GET_CURRENT_CONTEXT(ctx
);
2020 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramBinary(bufSize < 0)");
2024 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetProgramBinary");
2028 /* The ARB_get_program_binary spec says:
2030 * "If <length> is NULL, then no length is returned."
2032 * Ensure that length always points to valid storage to avoid multiple NULL
2033 * pointer checks below.
2036 length
= &length_dummy
;
2039 /* The ARB_get_program_binary spec says:
2041 * "When a program object's LINK_STATUS is FALSE, its program binary
2042 * length is zero, and a call to GetProgramBinary will generate an
2043 * INVALID_OPERATION error.
2045 if (!shProg
->data
->LinkStatus
) {
2046 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2047 "glGetProgramBinary(program %u not linked)",
2054 _mesa_error(ctx
, GL_INVALID_OPERATION
,
2055 "glGetProgramBinary(driver supports zero binary formats)");
2057 (void) binaryFormat
;
2062 _mesa_ProgramBinary(GLuint program
, GLenum binaryFormat
,
2063 const GLvoid
*binary
, GLsizei length
)
2065 struct gl_shader_program
*shProg
;
2066 GET_CURRENT_CONTEXT(ctx
);
2068 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glProgramBinary");
2072 (void) binaryFormat
;
2075 /* Section 2.3.1 (Errors) of the OpenGL 4.5 spec says:
2077 * "If a negative number is provided where an argument of type sizei or
2078 * sizeiptr is specified, an INVALID_VALUE error is generated."
2081 _mesa_error(ctx
, GL_INVALID_VALUE
, "glProgramBinary(length < 0)");
2085 /* The ARB_get_program_binary spec says:
2087 * "<binaryFormat> and <binary> must be those returned by a previous
2088 * call to GetProgramBinary, and <length> must be the length of the
2089 * program binary as returned by GetProgramBinary or GetProgramiv with
2090 * <pname> PROGRAM_BINARY_LENGTH. Loading the program binary will fail,
2091 * setting the LINK_STATUS of <program> to FALSE, if these conditions
2094 * Since any value of binaryFormat passed "is not one of those specified as
2095 * allowable for [this] command, an INVALID_ENUM error is generated."
2097 shProg
->data
->LinkStatus
= GL_FALSE
;
2098 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramBinary");
2103 _mesa_ProgramParameteri(GLuint program
, GLenum pname
, GLint value
)
2105 struct gl_shader_program
*shProg
;
2106 GET_CURRENT_CONTEXT(ctx
);
2108 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
2109 "glProgramParameteri");
2114 case GL_PROGRAM_BINARY_RETRIEVABLE_HINT
:
2115 /* This enum isn't part of the OES extension for OpenGL ES 2.0, but it
2116 * is part of OpenGL ES 3.0. For the ES2 case, this function shouldn't
2117 * even be in the dispatch table, so we shouldn't need to expclicitly
2120 * On desktop, we ignore the 3.0+ requirement because it is silly.
2123 /* The ARB_get_program_binary extension spec says:
2125 * "An INVALID_VALUE error is generated if the <value> argument to
2126 * ProgramParameteri is not TRUE or FALSE."
2128 if (value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2132 /* No need to notify the driver. Any changes will actually take effect
2133 * the next time the shader is linked.
2135 * The ARB_get_program_binary extension spec says:
2137 * "To indicate that a program binary is likely to be retrieved,
2138 * ProgramParameteri should be called with <pname>
2139 * PROGRAM_BINARY_RETRIEVABLE_HINT and <value> TRUE. This setting
2140 * will not be in effect until the next time LinkProgram or
2141 * ProgramBinary has been called successfully."
2143 * The resloution of issue 9 in the extension spec also says:
2145 * "The application may use the PROGRAM_BINARY_RETRIEVABLE_HINT hint
2146 * to indicate to the GL implementation that this program will
2147 * likely be saved with GetProgramBinary at some point. This will
2148 * give the GL implementation the opportunity to track any state
2149 * changes made to the program before being saved such that when it
2150 * is loaded again a recompile can be avoided."
2152 shProg
->BinaryRetreivableHint
= value
;
2155 case GL_PROGRAM_SEPARABLE
:
2156 /* Spec imply that the behavior is the same as ARB_get_program_binary
2157 * Chapter 7.3 Program Objects
2159 if (value
!= GL_TRUE
&& value
!= GL_FALSE
) {
2162 shProg
->SeparateShader
= value
;
2166 _mesa_error(ctx
, GL_INVALID_ENUM
, "glProgramParameteri(pname=%s)",
2167 _mesa_enum_to_string(pname
));
2172 _mesa_error(ctx
, GL_INVALID_VALUE
,
2173 "glProgramParameteri(pname=%s, value=%d): "
2174 "value must be 0 or 1.",
2175 _mesa_enum_to_string(pname
),
2181 _mesa_use_shader_program(struct gl_context
*ctx
, GLenum type
,
2182 struct gl_shader_program
*shProg
,
2183 struct gl_pipeline_object
*shTarget
)
2185 gl_shader_stage stage
= _mesa_shader_enum_to_shader_stage(type
);
2186 use_shader_program(ctx
, stage
, shProg
, shTarget
);
2191 * Copy program-specific data generated by linking from the gl_shader_program
2192 * object to the gl_program object referred to by the gl_linked_shader.
2194 * This function expects _mesa_reference_program() to have been previously
2195 * called setting the gl_linked_shaders program reference.
2198 _mesa_copy_linked_program_data(const struct gl_shader_program
*src
,
2199 struct gl_linked_shader
*dst_sh
)
2201 assert(dst_sh
->Program
);
2203 struct gl_program
*dst
= dst_sh
->Program
;
2205 dst
->info
.separate_shader
= src
->SeparateShader
;
2207 switch (dst_sh
->Stage
) {
2208 case MESA_SHADER_VERTEX
:
2209 dst
->ClipDistanceArraySize
= src
->Vert
.ClipDistanceArraySize
;
2210 dst
->CullDistanceArraySize
= src
->Vert
.CullDistanceArraySize
;
2212 case MESA_SHADER_TESS_EVAL
: {
2213 dst
->info
.tess
.primitive_mode
= dst_sh
->info
.TessEval
.PrimitiveMode
;
2214 dst
->info
.tess
.spacing
= dst_sh
->info
.TessEval
.Spacing
;
2215 dst
->info
.tess
.ccw
= dst_sh
->info
.TessEval
.VertexOrder
== GL_CCW
;
2216 dst
->info
.tess
.point_mode
= dst_sh
->info
.TessEval
.PointMode
;
2217 dst
->ClipDistanceArraySize
= src
->TessEval
.ClipDistanceArraySize
;
2218 dst
->CullDistanceArraySize
= src
->TessEval
.CullDistanceArraySize
;
2221 case MESA_SHADER_GEOMETRY
: {
2222 dst
->info
.gs
.vertices_in
= src
->Geom
.VerticesIn
;
2223 dst
->info
.gs
.vertices_out
= dst_sh
->info
.Geom
.VerticesOut
;
2224 dst
->info
.gs
.invocations
= dst_sh
->info
.Geom
.Invocations
;
2225 dst
->info
.gs
.input_primitive
= dst_sh
->info
.Geom
.InputType
;
2226 dst
->info
.gs
.output_primitive
= dst_sh
->info
.Geom
.OutputType
;
2227 dst
->ClipDistanceArraySize
= src
->Geom
.ClipDistanceArraySize
;
2228 dst
->CullDistanceArraySize
= src
->Geom
.CullDistanceArraySize
;
2229 dst
->info
.gs
.uses_end_primitive
= src
->Geom
.UsesEndPrimitive
;
2230 dst
->info
.gs
.uses_streams
= src
->Geom
.UsesStreams
;
2233 case MESA_SHADER_FRAGMENT
: {
2234 dst
->info
.fs
.depth_layout
= src
->FragDepthLayout
;
2235 dst
->info
.fs
.inner_coverage
= dst_sh
->info
.InnerCoverage
;
2236 dst
->info
.fs
.post_depth_coverage
= dst_sh
->info
.PostDepthCoverage
;
2239 case MESA_SHADER_COMPUTE
: {
2240 for (int i
= 0; i
< 3; i
++)
2241 dst
->info
.cs
.local_size
[i
] = src
->Comp
.LocalSize
[i
];
2242 dst
->info
.cs
.shared_size
= src
->Comp
.SharedSize
;
2243 dst
->info
.cs
.local_size_variable
= src
->Comp
.LocalSizeVariable
;
2252 * ARB_separate_shader_objects: Compile & Link Program
2255 _mesa_CreateShaderProgramv(GLenum type
, GLsizei count
,
2256 const GLchar
* const *strings
)
2258 GET_CURRENT_CONTEXT(ctx
);
2260 const GLuint shader
= create_shader(ctx
, type
);
2264 * According to OpenGL 4.5 and OpenGL ES 3.1 standards, section 7.3:
2265 * GL_INVALID_VALUE should be generated if count < 0
2268 _mesa_error(ctx
, GL_INVALID_VALUE
, "glCreateShaderProgram (count < 0)");
2273 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
2275 _mesa_ShaderSource(shader
, count
, strings
, NULL
);
2276 _mesa_compile_shader(ctx
, sh
);
2278 program
= create_shader_program(ctx
);
2280 struct gl_shader_program
*shProg
;
2281 GLint compiled
= GL_FALSE
;
2283 shProg
= _mesa_lookup_shader_program(ctx
, program
);
2285 shProg
->SeparateShader
= GL_TRUE
;
2287 get_shaderiv(ctx
, shader
, GL_COMPILE_STATUS
, &compiled
);
2289 attach_shader(ctx
, program
, shader
);
2290 _mesa_link_program(ctx
, shProg
);
2291 detach_shader(ctx
, program
, shader
);
2295 if (active
-user
-defined
-varyings
-in
-linked
-program
) {
2296 append
-error
-to
-info
-log
;
2297 shProg
->data
->LinkStatus
= GL_FALSE
;
2302 ralloc_strcat(&shProg
->data
->InfoLog
, sh
->InfoLog
);
2305 delete_shader(ctx
, shader
);
2313 * For GL_ARB_tessellation_shader
2315 extern void GLAPIENTRY
2316 _mesa_PatchParameteri(GLenum pname
, GLint value
)
2318 GET_CURRENT_CONTEXT(ctx
);
2320 if (!_mesa_has_tessellation(ctx
)) {
2321 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameteri");
2325 if (pname
!= GL_PATCH_VERTICES
) {
2326 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameteri");
2330 if (value
<= 0 || value
> ctx
->Const
.MaxPatchVertices
) {
2331 _mesa_error(ctx
, GL_INVALID_VALUE
, "glPatchParameteri");
2335 ctx
->TessCtrlProgram
.patch_vertices
= value
;
2339 extern void GLAPIENTRY
2340 _mesa_PatchParameterfv(GLenum pname
, const GLfloat
*values
)
2342 GET_CURRENT_CONTEXT(ctx
);
2344 if (!_mesa_has_tessellation(ctx
)) {
2345 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glPatchParameterfv");
2350 case GL_PATCH_DEFAULT_OUTER_LEVEL
:
2351 FLUSH_VERTICES(ctx
, 0);
2352 memcpy(ctx
->TessCtrlProgram
.patch_default_outer_level
, values
,
2353 4 * sizeof(GLfloat
));
2354 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2356 case GL_PATCH_DEFAULT_INNER_LEVEL
:
2357 FLUSH_VERTICES(ctx
, 0);
2358 memcpy(ctx
->TessCtrlProgram
.patch_default_inner_level
, values
,
2359 2 * sizeof(GLfloat
));
2360 ctx
->NewDriverState
|= ctx
->DriverFlags
.NewDefaultTessLevels
;
2363 _mesa_error(ctx
, GL_INVALID_ENUM
, "glPatchParameterfv");
2369 * ARB_shader_subroutine
2372 _mesa_GetSubroutineUniformLocation(GLuint program
, GLenum shadertype
,
2375 GET_CURRENT_CONTEXT(ctx
);
2376 const char *api_name
= "glGetSubroutineUniformLocation";
2377 struct gl_shader_program
*shProg
;
2378 GLenum resource_type
;
2379 gl_shader_stage stage
;
2381 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2382 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2386 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2387 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2391 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2395 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2396 if (!shProg
->_LinkedShaders
[stage
]) {
2397 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2401 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2402 return _mesa_program_resource_location(shProg
, resource_type
, name
);
2406 _mesa_GetSubroutineIndex(GLuint program
, GLenum shadertype
,
2409 GET_CURRENT_CONTEXT(ctx
);
2410 const char *api_name
= "glGetSubroutineIndex";
2411 struct gl_shader_program
*shProg
;
2412 struct gl_program_resource
*res
;
2413 GLenum resource_type
;
2414 gl_shader_stage stage
;
2416 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2417 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2421 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2422 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2426 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2430 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2431 if (!shProg
->_LinkedShaders
[stage
]) {
2432 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2436 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2437 res
= _mesa_program_resource_find_name(shProg
, resource_type
, name
, NULL
);
2442 return _mesa_program_resource_index(shProg
, res
);
2447 _mesa_GetActiveSubroutineUniformiv(GLuint program
, GLenum shadertype
,
2448 GLuint index
, GLenum pname
, GLint
*values
)
2450 GET_CURRENT_CONTEXT(ctx
);
2451 const char *api_name
= "glGetActiveSubroutineUniformiv";
2452 struct gl_shader_program
*shProg
;
2453 struct gl_linked_shader
*sh
;
2454 gl_shader_stage stage
;
2455 struct gl_program_resource
*res
;
2456 const struct gl_uniform_storage
*uni
;
2457 GLenum resource_type
;
2460 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2461 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2465 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2466 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2470 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2474 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2475 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2477 sh
= shProg
->_LinkedShaders
[stage
];
2479 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2483 struct gl_program
*p
= shProg
->_LinkedShaders
[stage
]->Program
;
2484 if (index
>= p
->sh
.NumSubroutineUniforms
) {
2485 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s: invalid index greater than GL_ACTIVE_SUBROUTINE_UNIFORMS", api_name
);
2490 case GL_NUM_COMPATIBLE_SUBROUTINES
: {
2491 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2494 values
[0] = uni
->num_compatible_subroutines
;
2498 case GL_COMPATIBLE_SUBROUTINES
: {
2499 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2503 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2504 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
2505 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2506 if (fn
->types
[j
] == uni
->type
) {
2507 values
[count
++] = i
;
2515 case GL_UNIFORM_SIZE
:
2516 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2519 values
[0] = uni
->array_elements
? uni
->array_elements
: 1;
2522 case GL_UNIFORM_NAME_LENGTH
:
2523 res
= _mesa_program_resource_find_index(shProg
, resource_type
, index
);
2525 values
[0] = strlen(_mesa_program_resource_name(res
)) + 1
2526 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2530 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2537 _mesa_GetActiveSubroutineUniformName(GLuint program
, GLenum shadertype
,
2538 GLuint index
, GLsizei bufsize
,
2539 GLsizei
*length
, GLchar
*name
)
2541 GET_CURRENT_CONTEXT(ctx
);
2542 const char *api_name
= "glGetActiveSubroutineUniformName";
2543 struct gl_shader_program
*shProg
;
2544 GLenum resource_type
;
2545 gl_shader_stage stage
;
2547 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2548 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
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 /* get program resource name */
2569 _mesa_get_program_resource_name(shProg
, resource_type
,
2571 length
, name
, api_name
);
2576 _mesa_GetActiveSubroutineName(GLuint program
, GLenum shadertype
,
2577 GLuint index
, GLsizei bufsize
,
2578 GLsizei
*length
, GLchar
*name
)
2580 GET_CURRENT_CONTEXT(ctx
);
2581 const char *api_name
= "glGetActiveSubroutineName";
2582 struct gl_shader_program
*shProg
;
2583 GLenum resource_type
;
2584 gl_shader_stage stage
;
2586 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2587 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2591 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2592 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2596 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2600 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2601 if (!shProg
->_LinkedShaders
[stage
]) {
2602 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2605 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2606 _mesa_get_program_resource_name(shProg
, resource_type
,
2608 length
, name
, api_name
);
2612 _mesa_UniformSubroutinesuiv(GLenum shadertype
, GLsizei count
,
2613 const GLuint
*indices
)
2615 GET_CURRENT_CONTEXT(ctx
);
2616 const char *api_name
= "glUniformSubroutinesuiv";
2617 struct gl_shader_program
*shProg
;
2618 struct gl_linked_shader
*sh
;
2619 gl_shader_stage stage
;
2622 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2623 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2627 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2628 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2632 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2633 shProg
= ctx
->_Shader
->CurrentProgram
[stage
];
2635 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2639 sh
= shProg
->_LinkedShaders
[stage
];
2641 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2645 struct gl_program
*p
= shProg
->_LinkedShaders
[stage
]->Program
;
2646 if (count
!= p
->sh
.NumSubroutineUniformRemapTable
) {
2647 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2653 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
2659 int uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
2662 for (j
= i
; j
< i
+ uni_count
; j
++) {
2663 struct gl_subroutine_function
*subfn
= NULL
;
2664 if (indices
[j
] > p
->sh
.MaxSubroutineFunctionIndex
) {
2665 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2669 for (f
= 0; f
< p
->sh
.NumSubroutineFunctions
; f
++) {
2670 if (p
->sh
.SubroutineFunctions
[f
].index
== indices
[j
])
2671 subfn
= &p
->sh
.SubroutineFunctions
[f
];
2678 for (k
= 0; k
< subfn
->num_compat_types
; k
++) {
2679 if (subfn
->types
[k
] == uni
->type
)
2682 if (k
== subfn
->num_compat_types
) {
2683 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2687 ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[j
] = indices
[j
];
2692 FLUSH_VERTICES(ctx
, _NEW_PROGRAM_CONSTANTS
);
2697 _mesa_GetUniformSubroutineuiv(GLenum shadertype
, GLint location
,
2700 GET_CURRENT_CONTEXT(ctx
);
2701 const char *api_name
= "glGetUniformSubroutineuiv";
2702 struct gl_shader_program
*shProg
;
2703 struct gl_linked_shader
*sh
;
2704 gl_shader_stage stage
;
2706 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2707 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2711 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2712 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2716 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2717 shProg
= ctx
->_Shader
->CurrentProgram
[stage
];
2719 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2723 sh
= shProg
->_LinkedShaders
[stage
];
2725 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2729 struct gl_program
*p
= sh
->Program
;
2730 if (location
>= p
->sh
.NumSubroutineUniformRemapTable
) {
2731 _mesa_error(ctx
, GL_INVALID_VALUE
, "%s", api_name
);
2735 *params
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[location
];
2740 _mesa_GetProgramStageiv(GLuint program
, GLenum shadertype
,
2741 GLenum pname
, GLint
*values
)
2743 GET_CURRENT_CONTEXT(ctx
);
2744 const char *api_name
= "glGetProgramStageiv";
2745 struct gl_shader_program
*shProg
;
2746 struct gl_linked_shader
*sh
;
2747 gl_shader_stage stage
;
2749 if (!_mesa_has_ARB_shader_subroutine(ctx
)) {
2750 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2754 if (!_mesa_validate_shader_target(ctx
, shadertype
)) {
2755 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2759 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, api_name
);
2763 stage
= _mesa_shader_enum_to_shader_stage(shadertype
);
2764 sh
= shProg
->_LinkedShaders
[stage
];
2766 /* ARB_shader_subroutine doesn't ask the program to be linked, or list any
2767 * INVALID_OPERATION in the case of not be linked.
2769 * And for some pnames, like GL_ACTIVE_SUBROUTINE_UNIFORMS, you can ask the
2770 * same info using other specs (ARB_program_interface_query), without the
2771 * need of the program to be linked, being the value for that case 0.
2773 * But at the same time, some other methods require the program to be
2774 * linked for pname related to locations, so it would be inconsistent to
2775 * not do the same here. So we are:
2776 * * Return GL_INVALID_OPERATION if not linked only for locations.
2777 * * Setting a default value of 0, to be returned if not linked.
2781 if (pname
== GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
) {
2782 _mesa_error(ctx
, GL_INVALID_OPERATION
, "%s", api_name
);
2787 struct gl_program
*p
= sh
->Program
;
2789 case GL_ACTIVE_SUBROUTINES
:
2790 values
[0] = p
->sh
.NumSubroutineFunctions
;
2792 case GL_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS
:
2793 values
[0] = p
->sh
.NumSubroutineUniformRemapTable
;
2795 case GL_ACTIVE_SUBROUTINE_UNIFORMS
:
2796 values
[0] = p
->sh
.NumSubroutineUniforms
;
2798 case GL_ACTIVE_SUBROUTINE_MAX_LENGTH
:
2802 GLenum resource_type
;
2803 struct gl_program_resource
*res
;
2805 resource_type
= _mesa_shader_stage_to_subroutine(stage
);
2806 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2807 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
2809 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1;
2814 values
[0] = max_len
;
2817 case GL_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH
:
2821 GLenum resource_type
;
2822 struct gl_program_resource
*res
;
2824 resource_type
= _mesa_shader_stage_to_subroutine_uniform(stage
);
2825 for (i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
2826 res
= _mesa_program_resource_find_index(shProg
, resource_type
, i
);
2828 const GLint len
= strlen(_mesa_program_resource_name(res
)) + 1
2829 + ((_mesa_program_resource_array_size(res
) != 0) ? 3 : 0);
2835 values
[0] = max_len
;
2839 _mesa_error(ctx
, GL_INVALID_ENUM
, "%s", api_name
);
2846 find_compat_subroutine(struct gl_program
*p
, const struct glsl_type
*type
)
2850 for (i
= 0; i
< p
->sh
.NumSubroutineFunctions
; i
++) {
2851 struct gl_subroutine_function
*fn
= &p
->sh
.SubroutineFunctions
[i
];
2852 for (j
= 0; j
< fn
->num_compat_types
; j
++) {
2853 if (fn
->types
[j
] == type
)
2861 _mesa_shader_write_subroutine_index(struct gl_context
*ctx
,
2862 struct gl_program
*p
)
2866 if (p
->sh
.NumSubroutineUniformRemapTable
== 0)
2871 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
2880 uni_count
= uni
->array_elements
? uni
->array_elements
: 1;
2881 for (j
= 0; j
< uni_count
; j
++) {
2882 val
= ctx
->SubroutineIndex
[p
->info
.stage
].IndexPtr
[i
+ j
];
2883 memcpy(&uni
->storage
[j
], &val
, sizeof(int));
2886 _mesa_propagate_uniforms_to_driver_storage(uni
, 0, uni_count
);
2888 } while(i
< p
->sh
.NumSubroutineUniformRemapTable
);
2892 _mesa_shader_write_subroutine_indices(struct gl_context
*ctx
,
2893 gl_shader_stage stage
)
2895 if (ctx
->_Shader
->CurrentProgram
[stage
] &&
2896 ctx
->_Shader
->CurrentProgram
[stage
]->_LinkedShaders
[stage
])
2897 _mesa_shader_write_subroutine_index(ctx
,
2898 ctx
->_Shader
->CurrentProgram
[stage
]->_LinkedShaders
[stage
]->Program
);
2902 _mesa_program_init_subroutine_defaults(struct gl_context
*ctx
,
2903 struct gl_program
*p
)
2907 struct gl_subroutine_index_binding
*binding
= &ctx
->SubroutineIndex
[p
->info
.stage
];
2908 if (binding
->NumIndex
!= p
->sh
.NumSubroutineUniformRemapTable
) {
2909 binding
->IndexPtr
= realloc(binding
->IndexPtr
,
2910 p
->sh
.NumSubroutineUniformRemapTable
* (sizeof(GLuint
)));
2911 binding
->NumIndex
= p
->sh
.NumSubroutineUniformRemapTable
;
2914 for (int i
= 0; i
< p
->sh
.NumSubroutineUniformRemapTable
; i
++) {
2915 struct gl_uniform_storage
*uni
= p
->sh
.SubroutineUniformRemapTable
[i
];
2920 binding
->IndexPtr
[i
] = find_compat_subroutine(p
, uni
->type
);