2 * Mesa 3-D graphics library
5 * Copyright (C) 2004-2008 Brian Paul All Rights Reserved.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
21 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
27 * Implementation of GLSL-related API functions
33 * 1. Check that the right error code is generated for all _mesa_error() calls.
34 * 2. Insert FLUSH_VERTICES calls in various places
38 #include "main/glheader.h"
39 #include "main/context.h"
40 #include "main/hash.h"
41 #include "main/macros.h"
42 #include "shader/program.h"
43 #include "shader/prog_parameter.h"
44 #include "shader/prog_print.h"
45 #include "shader/prog_statevars.h"
46 #include "shader/prog_uniform.h"
47 #include "shader/shader_api.h"
48 #include "shader/slang/slang_compile.h"
49 #include "shader/slang/slang_link.h"
50 #include "glapi/dispatch.h"
53 #ifndef GL_PROGRAM_BINARY_LENGTH_OES
54 #define GL_PROGRAM_BINARY_LENGTH_OES 0x8741
59 * Allocate a new gl_shader_program object, initialize it.
61 static struct gl_shader_program
*
62 _mesa_new_shader_program(GLcontext
*ctx
, GLuint name
)
64 struct gl_shader_program
*shProg
;
65 shProg
= CALLOC_STRUCT(gl_shader_program
);
67 shProg
->Type
= GL_SHADER_PROGRAM_MESA
;
70 shProg
->Attributes
= _mesa_new_parameter_list();
77 * Clear (free) the shader program state that gets produced by linking.
80 _mesa_clear_shader_program_data(GLcontext
*ctx
,
81 struct gl_shader_program
*shProg
)
83 _mesa_reference_vertprog(ctx
, &shProg
->VertexProgram
, NULL
);
84 _mesa_reference_fragprog(ctx
, &shProg
->FragmentProgram
, NULL
);
86 if (shProg
->Uniforms
) {
87 _mesa_free_uniform_list(shProg
->Uniforms
);
88 shProg
->Uniforms
= NULL
;
91 if (shProg
->Varying
) {
92 _mesa_free_parameter_list(shProg
->Varying
);
93 shProg
->Varying
= NULL
;
99 * Free all the data that hangs off a shader program object, but not the
103 _mesa_free_shader_program_data(GLcontext
*ctx
,
104 struct gl_shader_program
*shProg
)
108 assert(shProg
->Type
== GL_SHADER_PROGRAM_MESA
);
110 _mesa_clear_shader_program_data(ctx
, shProg
);
112 if (shProg
->Attributes
) {
113 _mesa_free_parameter_list(shProg
->Attributes
);
114 shProg
->Attributes
= NULL
;
118 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
119 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
121 shProg
->NumShaders
= 0;
123 if (shProg
->Shaders
) {
124 _mesa_free(shProg
->Shaders
);
125 shProg
->Shaders
= NULL
;
128 if (shProg
->InfoLog
) {
129 _mesa_free(shProg
->InfoLog
);
130 shProg
->InfoLog
= NULL
;
136 * Free/delete a shader program object.
139 _mesa_free_shader_program(GLcontext
*ctx
, struct gl_shader_program
*shProg
)
141 _mesa_free_shader_program_data(ctx
, shProg
);
148 * Set ptr to point to shProg.
149 * If ptr is pointing to another object, decrement its refcount (and delete
150 * if refcount hits zero).
151 * Then set ptr to point to shProg, incrementing its refcount.
153 /* XXX this could be static */
155 _mesa_reference_shader_program(GLcontext
*ctx
,
156 struct gl_shader_program
**ptr
,
157 struct gl_shader_program
*shProg
)
160 if (*ptr
== shProg
) {
165 /* Unreference the old shader program */
166 GLboolean deleteFlag
= GL_FALSE
;
167 struct gl_shader_program
*old
= *ptr
;
169 ASSERT(old
->RefCount
> 0);
172 printf("ShaderProgram %p ID=%u RefCount-- to %d\n",
173 (void *) old
, old
->Name
, old
->RefCount
);
175 deleteFlag
= (old
->RefCount
== 0);
178 _mesa_HashRemove(ctx
->Shared
->ShaderObjects
, old
->Name
);
179 _mesa_free_shader_program(ctx
, old
);
189 printf("ShaderProgram %p ID=%u RefCount++ to %d\n",
190 (void *) shProg
, shProg
->Name
, shProg
->RefCount
);
198 * Lookup a GLSL program object.
200 struct gl_shader_program
*
201 _mesa_lookup_shader_program(GLcontext
*ctx
, GLuint name
)
203 struct gl_shader_program
*shProg
;
205 shProg
= (struct gl_shader_program
*)
206 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
207 /* Note that both gl_shader and gl_shader_program objects are kept
208 * in the same hash table. Check the object's type to be sure it's
209 * what we're expecting.
211 if (shProg
&& shProg
->Type
!= GL_SHADER_PROGRAM_MESA
) {
221 * As above, but record an error if program is not found.
223 static struct gl_shader_program
*
224 _mesa_lookup_shader_program_err(GLcontext
*ctx
, GLuint name
,
228 _mesa_error(ctx
, GL_INVALID_VALUE
, caller
);
232 struct gl_shader_program
*shProg
= (struct gl_shader_program
*)
233 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
235 _mesa_error(ctx
, GL_INVALID_VALUE
, caller
);
238 if (shProg
->Type
!= GL_SHADER_PROGRAM_MESA
) {
239 _mesa_error(ctx
, GL_INVALID_OPERATION
, caller
);
250 * Allocate a new gl_shader object, initialize it.
253 _mesa_new_shader(GLcontext
*ctx
, GLuint name
, GLenum type
)
255 struct gl_shader
*shader
;
256 assert(type
== GL_FRAGMENT_SHADER
|| type
== GL_VERTEX_SHADER
);
257 shader
= CALLOC_STRUCT(gl_shader
);
261 shader
->RefCount
= 1;
268 _mesa_free_shader(GLcontext
*ctx
, struct gl_shader
*sh
)
271 _mesa_free((void *) sh
->Source
);
273 _mesa_free(sh
->InfoLog
);
274 _mesa_reference_program(ctx
, &sh
->Program
, NULL
);
280 * Set ptr to point to sh.
281 * If ptr is pointing to another shader, decrement its refcount (and delete
282 * if refcount hits zero).
283 * Then set ptr to point to sh, incrementing its refcount.
285 /* XXX this could be static */
287 _mesa_reference_shader(GLcontext
*ctx
, struct gl_shader
**ptr
,
288 struct gl_shader
*sh
)
296 /* Unreference the old shader */
297 GLboolean deleteFlag
= GL_FALSE
;
298 struct gl_shader
*old
= *ptr
;
300 ASSERT(old
->RefCount
> 0);
302 /*printf("SHADER DECR %p (%d) to %d\n",
303 (void*) old, old->Name, old->RefCount);*/
304 deleteFlag
= (old
->RefCount
== 0);
307 _mesa_HashRemove(ctx
->Shared
->ShaderObjects
, old
->Name
);
308 _mesa_free_shader(ctx
, old
);
318 /*printf("SHADER INCR %p (%d) to %d\n",
319 (void*) sh, sh->Name, sh->RefCount);*/
326 * Lookup a GLSL shader object.
329 _mesa_lookup_shader(GLcontext
*ctx
, GLuint name
)
332 struct gl_shader
*sh
= (struct gl_shader
*)
333 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
334 /* Note that both gl_shader and gl_shader_program objects are kept
335 * in the same hash table. Check the object's type to be sure it's
336 * what we're expecting.
338 if (sh
&& sh
->Type
== GL_SHADER_PROGRAM_MESA
) {
348 * As above, but record an error if shader is not found.
350 static struct gl_shader
*
351 _mesa_lookup_shader_err(GLcontext
*ctx
, GLuint name
, const char *caller
)
354 _mesa_error(ctx
, GL_INVALID_VALUE
, caller
);
358 struct gl_shader
*sh
= (struct gl_shader
*)
359 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
361 _mesa_error(ctx
, GL_INVALID_VALUE
, caller
);
364 if (sh
->Type
== GL_SHADER_PROGRAM_MESA
) {
365 _mesa_error(ctx
, GL_INVALID_OPERATION
, caller
);
374 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
377 get_shader_flags(void)
379 GLbitfield flags
= 0x0;
380 const char *env
= _mesa_getenv("MESA_GLSL");
383 if (_mesa_strstr(env
, "dump"))
385 if (_mesa_strstr(env
, "log"))
387 if (_mesa_strstr(env
, "nopt"))
388 flags
|= GLSL_NO_OPT
;
389 else if (_mesa_strstr(env
, "opt"))
391 if (_mesa_strstr(env
, "uniform"))
392 flags
|= GLSL_UNIFORMS
;
400 * Initialize context's shader state.
403 _mesa_init_shader_state(GLcontext
* ctx
)
405 /* Device drivers may override these to control what kind of instructions
406 * are generated by the GLSL compiler.
408 ctx
->Shader
.EmitHighLevelInstructions
= GL_TRUE
;
409 ctx
->Shader
.EmitCondCodes
= GL_FALSE
;
410 ctx
->Shader
.EmitComments
= GL_FALSE
;
411 ctx
->Shader
.Flags
= get_shader_flags();
416 * Free the per-context shader-related state.
419 _mesa_free_shader_state(GLcontext
*ctx
)
421 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
, NULL
);
426 * Copy string from <src> to <dst>, up to maxLength characters, returning
427 * length of <dst> in <length>.
428 * \param src the strings source
429 * \param maxLength max chars to copy
430 * \param length returns number of chars copied
431 * \param dst the string destination
434 copy_string(GLchar
*dst
, GLsizei maxLength
, GLsizei
*length
, const GLchar
*src
)
437 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
447 _mesa_is_program(GLcontext
*ctx
, GLuint name
)
449 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
450 return shProg
? GL_TRUE
: GL_FALSE
;
455 _mesa_is_shader(GLcontext
*ctx
, GLuint name
)
457 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
458 return shader
? GL_TRUE
: GL_FALSE
;
463 * Called via ctx->Driver.AttachShader()
466 _mesa_attach_shader(GLcontext
*ctx
, GLuint program
, GLuint shader
)
468 struct gl_shader_program
*shProg
;
469 struct gl_shader
*sh
;
472 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glAttachShader");
476 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glAttachShader");
481 n
= shProg
->NumShaders
;
482 for (i
= 0; i
< n
; i
++) {
483 if (shProg
->Shaders
[i
] == sh
) {
484 /* The shader is already attched to this program. The
485 * GL_ARB_shader_objects spec says:
487 * "The error INVALID_OPERATION is generated by AttachObjectARB
488 * if <obj> is already attached to <containerObj>."
490 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glAttachShader");
496 shProg
->Shaders
= (struct gl_shader
**)
497 _mesa_realloc(shProg
->Shaders
,
498 n
* sizeof(struct gl_shader
*),
499 (n
+ 1) * sizeof(struct gl_shader
*));
500 if (!shProg
->Shaders
) {
501 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
506 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
507 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
508 shProg
->NumShaders
++;
513 _mesa_get_attrib_location(GLcontext
*ctx
, GLuint program
,
516 struct gl_shader_program
*shProg
517 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttribLocation");
523 if (!shProg
->LinkStatus
) {
524 _mesa_error(ctx
, GL_INVALID_OPERATION
,
525 "glGetAttribLocation(program not linked)");
532 if (shProg
->VertexProgram
) {
533 const struct gl_program_parameter_list
*attribs
=
534 shProg
->VertexProgram
->Base
.Attributes
;
536 GLint i
= _mesa_lookup_parameter_index(attribs
, -1, name
);
538 return attribs
->Parameters
[i
].StateIndexes
[0];
547 _mesa_bind_attrib_location(GLcontext
*ctx
, GLuint program
, GLuint index
,
550 struct gl_shader_program
*shProg
;
551 const GLint size
= -1; /* unknown size */
553 GLenum datatype
= GL_FLOAT_VEC4
;
555 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
556 "glBindAttribLocation");
564 if (strncmp(name
, "gl_", 3) == 0) {
565 _mesa_error(ctx
, GL_INVALID_OPERATION
,
566 "glBindAttribLocation(illegal name)");
570 if (index
>= ctx
->Const
.VertexProgram
.MaxAttribs
) {
571 _mesa_error(ctx
, GL_INVALID_VALUE
, "glBindAttribLocation(index)");
575 if (shProg
->LinkStatus
) {
576 /* get current index/location for the attribute */
577 oldIndex
= _mesa_get_attrib_location(ctx
, program
, name
);
583 /* this will replace the current value if it's already in the list */
584 i
= _mesa_add_attribute(shProg
->Attributes
, name
, size
, datatype
, index
);
586 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glBindAttribLocation");
591 * Note that this attribute binding won't go into effect until
592 * glLinkProgram is called again.
598 _mesa_create_shader(GLcontext
*ctx
, GLenum type
)
600 struct gl_shader
*sh
;
603 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
606 case GL_FRAGMENT_SHADER
:
607 case GL_VERTEX_SHADER
:
608 sh
= _mesa_new_shader(ctx
, name
, type
);
611 _mesa_error(ctx
, GL_INVALID_ENUM
, "CreateShader(type)");
615 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, sh
);
622 _mesa_create_program(GLcontext
*ctx
)
625 struct gl_shader_program
*shProg
;
627 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
628 shProg
= _mesa_new_shader_program(ctx
, name
);
630 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, shProg
);
632 assert(shProg
->RefCount
== 1);
639 * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
643 _mesa_delete_program2(GLcontext
*ctx
, GLuint name
)
646 * NOTE: deleting shaders/programs works a bit differently than
647 * texture objects (and buffer objects, etc). Shader/program
648 * handles/IDs exist in the hash table until the object is really
649 * deleted (refcount==0). With texture objects, the handle/ID is
650 * removed from the hash table in glDeleteTextures() while the tex
651 * object itself might linger until its refcount goes to zero.
653 struct gl_shader_program
*shProg
;
655 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
659 shProg
->DeletePending
= GL_TRUE
;
661 /* effectively, decr shProg's refcount */
662 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
667 _mesa_delete_shader(GLcontext
*ctx
, GLuint shader
)
669 struct gl_shader
*sh
;
671 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
675 sh
->DeletePending
= GL_TRUE
;
677 /* effectively, decr sh's refcount */
678 _mesa_reference_shader(ctx
, &sh
, NULL
);
683 _mesa_detach_shader(GLcontext
*ctx
, GLuint program
, GLuint shader
)
685 struct gl_shader_program
*shProg
;
689 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
693 n
= shProg
->NumShaders
;
695 for (i
= 0; i
< n
; i
++) {
696 if (shProg
->Shaders
[i
]->Name
== shader
) {
698 struct gl_shader
**newList
;
701 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
703 /* alloc new, smaller array */
704 newList
= (struct gl_shader
**)
705 _mesa_malloc((n
- 1) * sizeof(struct gl_shader
*));
707 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
710 for (j
= 0; j
< i
; j
++) {
711 newList
[j
] = shProg
->Shaders
[j
];
714 newList
[j
++] = shProg
->Shaders
[i
];
715 _mesa_free(shProg
->Shaders
);
717 shProg
->Shaders
= newList
;
718 shProg
->NumShaders
= n
- 1;
723 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
724 assert(shProg
->Shaders
[j
]->Type
== GL_VERTEX_SHADER
||
725 shProg
->Shaders
[j
]->Type
== GL_FRAGMENT_SHADER
);
726 assert(shProg
->Shaders
[j
]->RefCount
> 0);
738 if (_mesa_is_shader(ctx
, shader
))
739 err
= GL_INVALID_OPERATION
;
740 else if (_mesa_is_program(ctx
, shader
))
741 err
= GL_INVALID_OPERATION
;
743 err
= GL_INVALID_VALUE
;
744 _mesa_error(ctx
, err
, "glDetachProgram(shader)");
751 sizeof_glsl_type(GLenum type
)
760 case GL_SAMPLER_CUBE
:
761 case GL_SAMPLER_1D_SHADOW
:
762 case GL_SAMPLER_2D_SHADOW
:
763 case GL_SAMPLER_2D_RECT_ARB
:
764 case GL_SAMPLER_2D_RECT_SHADOW_ARB
:
765 case GL_SAMPLER_1D_ARRAY_SHADOW_EXT
:
766 case GL_SAMPLER_2D_ARRAY_SHADOW_EXT
:
767 case GL_SAMPLER_CUBE_SHADOW_EXT
:
782 case GL_FLOAT_MAT2x3
:
783 case GL_FLOAT_MAT2x4
:
784 return 8; /* two float[4] vectors */
786 case GL_FLOAT_MAT3x2
:
787 case GL_FLOAT_MAT3x4
:
788 return 12; /* three float[4] vectors */
790 case GL_FLOAT_MAT4x2
:
791 case GL_FLOAT_MAT4x3
:
792 return 16; /* four float[4] vectors */
794 _mesa_problem(NULL
, "Invalid type in sizeof_glsl_type()");
801 is_boolean_type(GLenum type
)
816 is_integer_type(GLenum type
)
831 _mesa_get_active_attrib(GLcontext
*ctx
, GLuint program
, GLuint index
,
832 GLsizei maxLength
, GLsizei
*length
, GLint
*size
,
833 GLenum
*type
, GLchar
*nameOut
)
835 const struct gl_program_parameter_list
*attribs
= NULL
;
836 struct gl_shader_program
*shProg
;
838 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetActiveAttrib");
842 if (shProg
->VertexProgram
)
843 attribs
= shProg
->VertexProgram
->Base
.Attributes
;
845 if (!attribs
|| index
>= attribs
->NumParameters
) {
846 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetActiveAttrib(index)");
850 copy_string(nameOut
, maxLength
, length
, attribs
->Parameters
[index
].Name
);
853 *size
= attribs
->Parameters
[index
].Size
854 / sizeof_glsl_type(attribs
->Parameters
[index
].DataType
);
857 *type
= attribs
->Parameters
[index
].DataType
;
861 static struct gl_program_parameter
*
862 get_uniform_parameter(const struct gl_shader_program
*shProg
, GLuint index
)
864 const struct gl_program
*prog
;
867 progPos
= shProg
->Uniforms
->Uniforms
[index
].VertPos
;
869 prog
= &shProg
->VertexProgram
->Base
;
872 progPos
= shProg
->Uniforms
->Uniforms
[index
].FragPos
;
874 prog
= &shProg
->FragmentProgram
->Base
;
878 if (!prog
|| progPos
< 0)
879 return NULL
; /* should never happen */
881 return &prog
->Parameters
->Parameters
[progPos
];
886 * Called via ctx->Driver.GetActiveUniform().
889 _mesa_get_active_uniform(GLcontext
*ctx
, GLuint program
, GLuint index
,
890 GLsizei maxLength
, GLsizei
*length
, GLint
*size
,
891 GLenum
*type
, GLchar
*nameOut
)
893 const struct gl_shader_program
*shProg
;
894 const struct gl_program
*prog
;
895 const struct gl_program_parameter
*param
;
898 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetActiveUniform");
902 if (!shProg
->Uniforms
|| index
>= shProg
->Uniforms
->NumUniforms
) {
903 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetActiveUniform(index)");
907 progPos
= shProg
->Uniforms
->Uniforms
[index
].VertPos
;
909 prog
= &shProg
->VertexProgram
->Base
;
912 progPos
= shProg
->Uniforms
->Uniforms
[index
].FragPos
;
914 prog
= &shProg
->FragmentProgram
->Base
;
918 if (!prog
|| progPos
< 0)
919 return; /* should never happen */
921 ASSERT(progPos
< prog
->Parameters
->NumParameters
);
922 param
= &prog
->Parameters
->Parameters
[progPos
];
925 copy_string(nameOut
, maxLength
, length
, param
->Name
);
929 GLint typeSize
= sizeof_glsl_type(param
->DataType
);
930 if (param
->Size
> typeSize
) {
932 * Array elements are placed on vector[4] boundaries so they're
933 * a multiple of four floats. We round typeSize up to next multiple
934 * of four to get the right size below.
936 typeSize
= (typeSize
+ 3) & ~3;
938 /* Note that the returned size is in units of the <type>, not bytes */
939 *size
= param
->Size
/ typeSize
;
943 *type
= param
->DataType
;
949 * Called via ctx->Driver.GetAttachedShaders().
952 _mesa_get_attached_shaders(GLcontext
*ctx
, GLuint program
, GLsizei maxCount
,
953 GLsizei
*count
, GLuint
*obj
)
955 struct gl_shader_program
*shProg
=
956 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
959 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
960 obj
[i
] = shProg
->Shaders
[i
]->Name
;
969 _mesa_get_handle(GLcontext
*ctx
, GLenum pname
)
973 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
974 CALL_GetIntegerv(ctx
->Exec
, (GL_CURRENT_PROGRAM
, &handle
));
976 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
984 _mesa_get_programiv(GLcontext
*ctx
, GLuint program
,
985 GLenum pname
, GLint
*params
)
987 const struct gl_program_parameter_list
*attribs
;
988 struct gl_shader_program
*shProg
989 = _mesa_lookup_shader_program(ctx
, program
);
992 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramiv(program)");
996 if (shProg
->VertexProgram
)
997 attribs
= shProg
->VertexProgram
->Base
.Attributes
;
1002 case GL_DELETE_STATUS
:
1003 *params
= shProg
->DeletePending
;
1005 case GL_LINK_STATUS
:
1006 *params
= shProg
->LinkStatus
;
1008 case GL_VALIDATE_STATUS
:
1009 *params
= shProg
->Validated
;
1011 case GL_INFO_LOG_LENGTH
:
1012 *params
= shProg
->InfoLog
? strlen(shProg
->InfoLog
) + 1 : 0;
1014 case GL_ATTACHED_SHADERS
:
1015 *params
= shProg
->NumShaders
;
1017 case GL_ACTIVE_ATTRIBUTES
:
1018 *params
= attribs
? attribs
->NumParameters
: 0;
1020 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
1021 *params
= _mesa_longest_parameter_name(attribs
, PROGRAM_INPUT
) + 1;
1023 case GL_ACTIVE_UNIFORMS
:
1024 *params
= shProg
->Uniforms
? shProg
->Uniforms
->NumUniforms
: 0;
1026 case GL_ACTIVE_UNIFORM_MAX_LENGTH
:
1027 *params
= _mesa_longest_uniform_name(shProg
->Uniforms
);
1029 (*params
)++; /* add one for terminating zero */
1031 case GL_PROGRAM_BINARY_LENGTH_OES
:
1035 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname)");
1042 _mesa_get_shaderiv(GLcontext
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
1044 struct gl_shader
*shader
= _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
1051 case GL_SHADER_TYPE
:
1052 *params
= shader
->Type
;
1054 case GL_DELETE_STATUS
:
1055 *params
= shader
->DeletePending
;
1057 case GL_COMPILE_STATUS
:
1058 *params
= shader
->CompileStatus
;
1060 case GL_INFO_LOG_LENGTH
:
1061 *params
= shader
->InfoLog
? strlen(shader
->InfoLog
) + 1 : 0;
1063 case GL_SHADER_SOURCE_LENGTH
:
1064 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
1067 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
1074 _mesa_get_program_info_log(GLcontext
*ctx
, GLuint program
, GLsizei bufSize
,
1075 GLsizei
*length
, GLchar
*infoLog
)
1077 struct gl_shader_program
*shProg
1078 = _mesa_lookup_shader_program(ctx
, program
);
1080 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(program)");
1083 copy_string(infoLog
, bufSize
, length
, shProg
->InfoLog
);
1088 _mesa_get_shader_info_log(GLcontext
*ctx
, GLuint shader
, GLsizei bufSize
,
1089 GLsizei
*length
, GLchar
*infoLog
)
1091 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
1093 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(shader)");
1096 copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
1101 * Called via ctx->Driver.GetShaderSource().
1104 _mesa_get_shader_source(GLcontext
*ctx
, GLuint shader
, GLsizei maxLength
,
1105 GLsizei
*length
, GLchar
*sourceOut
)
1107 struct gl_shader
*sh
;
1108 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
1112 copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
1117 get_matrix_dims(GLenum type
, GLint
*rows
, GLint
*cols
)
1123 case GL_FLOAT_MAT2x3
:
1127 case GL_FLOAT_MAT2x4
:
1135 case GL_FLOAT_MAT3x2
:
1139 case GL_FLOAT_MAT3x4
:
1147 case GL_FLOAT_MAT4x2
:
1151 case GL_FLOAT_MAT4x3
:
1162 * Determine the number of rows and columns occupied by a uniform
1163 * according to its datatype. For non-matrix types (such as GL_FLOAT_VEC4),
1164 * the number of rows = 1 and cols = number of elements in the vector.
1167 get_uniform_rows_cols(const struct gl_program_parameter
*p
,
1168 GLint
*rows
, GLint
*cols
)
1170 get_matrix_dims(p
->DataType
, rows
, cols
);
1171 if (*rows
== 0 && *cols
== 0) {
1172 /* not a matrix type, probably a float or vector */
1178 *rows
= p
->Size
/ 4 + 1;
1179 if (p
->Size
% 4 == 0)
1182 *cols
= p
->Size
% 4;
1189 * Helper for get_uniform[fi]v() functions.
1190 * Given a shader program name and uniform location, return a pointer
1191 * to the shader program and return the program parameter position.
1194 lookup_uniform_parameter(GLcontext
*ctx
, GLuint program
, GLint location
,
1195 struct gl_program
**progOut
, GLint
*paramPosOut
)
1197 struct gl_shader_program
*shProg
1198 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetUniform[if]v");
1199 struct gl_program
*prog
= NULL
;
1202 /* if shProg is NULL, we'll have already recorded an error */
1205 if (!shProg
->Uniforms
||
1207 location
>= (GLint
) shProg
->Uniforms
->NumUniforms
) {
1208 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetUniformfv(location)");
1211 /* OK, find the gl_program and program parameter location */
1212 progPos
= shProg
->Uniforms
->Uniforms
[location
].VertPos
;
1214 prog
= &shProg
->VertexProgram
->Base
;
1217 progPos
= shProg
->Uniforms
->Uniforms
[location
].FragPos
;
1219 prog
= &shProg
->FragmentProgram
->Base
;
1226 *paramPosOut
= progPos
;
1231 * Called via ctx->Driver.GetUniformfv().
1234 _mesa_get_uniformfv(GLcontext
*ctx
, GLuint program
, GLint location
,
1237 struct gl_program
*prog
;
1240 lookup_uniform_parameter(ctx
, program
, location
, &prog
, ¶mPos
);
1243 const struct gl_program_parameter
*p
=
1244 &prog
->Parameters
->Parameters
[paramPos
];
1245 GLint rows
, cols
, i
, j
, k
;
1247 get_uniform_rows_cols(p
, &rows
, &cols
);
1250 for (i
= 0; i
< rows
; i
++) {
1251 for (j
= 0; j
< cols
; j
++ ) {
1252 params
[k
++] = prog
->Parameters
->ParameterValues
[paramPos
+i
][j
];
1260 * Called via ctx->Driver.GetUniformiv().
1261 * \sa _mesa_get_uniformfv, only difference is a cast.
1264 _mesa_get_uniformiv(GLcontext
*ctx
, GLuint program
, GLint location
,
1267 struct gl_program
*prog
;
1270 lookup_uniform_parameter(ctx
, program
, location
, &prog
, ¶mPos
);
1273 const struct gl_program_parameter
*p
=
1274 &prog
->Parameters
->Parameters
[paramPos
];
1275 GLint rows
, cols
, i
, j
, k
;
1277 get_uniform_rows_cols(p
, &rows
, &cols
);
1280 for (i
= 0; i
< rows
; i
++) {
1281 for (j
= 0; j
< cols
; j
++ ) {
1282 params
[k
++] = (GLint
) prog
->Parameters
->ParameterValues
[paramPos
+i
][j
];
1290 * The value returned by GetUniformLocation actually encodes two things:
1291 * 1. the index into the prog->Uniforms[] array for the uniform
1292 * 2. an offset in the prog->ParameterValues[] array for specifying array
1293 * elements or structure fields.
1294 * This function merges those two values.
1297 merge_location_offset(GLint
*location
, GLint offset
)
1299 *location
= *location
| (offset
<< 16);
1304 * Seperate the uniform location and parameter offset. See above.
1307 split_location_offset(GLint
*location
, GLint
*offset
)
1309 *offset
= (*location
>> 16);
1310 *location
= *location
& 0xffff;
1315 * Called via ctx->Driver.GetUniformLocation().
1317 * The return value will encode two values, the uniform location and an
1318 * offset (used for arrays, structs).
1321 _mesa_get_uniform_location(GLcontext
*ctx
, GLuint program
, const GLchar
*name
)
1323 GLint offset
= 0, location
= -1;
1325 struct gl_shader_program
*shProg
=
1326 _mesa_lookup_shader_program_err(ctx
, program
, "glGetUniformLocation");
1331 if (shProg
->LinkStatus
== GL_FALSE
) {
1332 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetUniformfv(program)");
1336 /* XXX we should return -1 if the uniform was declared, but not
1340 /* XXX we need to be able to parse uniform names for structs and arrays
1347 /* handle 1-dimension arrays here... */
1348 char *c
= strchr(name
, '[');
1350 /* truncate name at [ */
1351 const GLint len
= c
- name
;
1352 GLchar
*newName
= _mesa_malloc(len
+ 1);
1354 return -1; /* out of mem */
1355 _mesa_memcpy(newName
, name
, len
);
1358 location
= _mesa_lookup_uniform(shProg
->Uniforms
, newName
);
1359 if (location
>= 0) {
1360 const GLint element
= _mesa_atoi(c
+ 1);
1362 /* get type of the uniform array element */
1363 struct gl_program_parameter
*p
;
1364 p
= get_uniform_parameter(shProg
, location
);
1367 get_matrix_dims(p
->DataType
, &rows
, &cols
);
1370 offset
= element
* rows
;
1375 _mesa_free(newName
);
1380 location
= _mesa_lookup_uniform(shProg
->Uniforms
, name
);
1383 if (location
>= 0) {
1384 merge_location_offset(&location
, offset
);
1393 * Called via ctx->Driver.ShaderSource()
1396 _mesa_shader_source(GLcontext
*ctx
, GLuint shader
, const GLchar
*source
)
1398 struct gl_shader
*sh
;
1400 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glShaderSource");
1404 /* free old shader source string and install new one */
1406 _mesa_free((void *) sh
->Source
);
1408 sh
->Source
= source
;
1409 sh
->CompileStatus
= GL_FALSE
;
1414 * Called via ctx->Driver.CompileShader()
1417 _mesa_compile_shader(GLcontext
*ctx
, GLuint shaderObj
)
1419 struct gl_shader
*sh
;
1421 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glCompileShader");
1425 /* this call will set the sh->CompileStatus field to indicate if
1426 * compilation was successful.
1428 (void) _slang_compile(ctx
, sh
);
1433 * Called via ctx->Driver.LinkProgram()
1436 _mesa_link_program(GLcontext
*ctx
, GLuint program
)
1438 struct gl_shader_program
*shProg
;
1440 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glLinkProgram");
1444 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1446 _slang_link(ctx
, program
, shProg
);
1451 * Called via ctx->Driver.UseProgram()
1454 _mesa_use_program(GLcontext
*ctx
, GLuint program
)
1456 struct gl_shader_program
*shProg
;
1458 if (ctx
->Shader
.CurrentProgram
&&
1459 ctx
->Shader
.CurrentProgram
->Name
== program
) {
1464 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1467 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
1471 if (!shProg
->LinkStatus
) {
1472 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUseProgram");
1480 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
, shProg
);
1486 * Update the vertex/fragment program's TexturesUsed array.
1488 * This needs to be called after glUniform(set sampler var) is called.
1489 * A call to glUniform(samplerVar, value) causes a sampler to point to a
1490 * particular texture unit. We know the sampler's texture target
1491 * (1D/2D/3D/etc) from compile time but the sampler's texture unit is
1492 * set by glUniform() calls.
1494 * So, scan the program->SamplerUnits[] and program->SamplerTargets[]
1495 * information to update the prog->TexturesUsed[] values.
1496 * Each value of TexturesUsed[unit] is one of zero, TEXTURE_1D_INDEX,
1497 * TEXTURE_2D_INDEX, TEXTURE_3D_INDEX, etc.
1498 * We'll use that info for state validation before rendering.
1501 _mesa_update_shader_textures_used(struct gl_program
*prog
)
1505 memset(prog
->TexturesUsed
, 0, sizeof(prog
->TexturesUsed
));
1507 for (s
= 0; s
< MAX_SAMPLERS
; s
++) {
1508 if (prog
->SamplersUsed
& (1 << s
)) {
1509 GLuint u
= prog
->SamplerUnits
[s
];
1510 GLuint t
= prog
->SamplerTargets
[s
];
1511 assert(u
< MAX_TEXTURE_IMAGE_UNITS
);
1512 prog
->TexturesUsed
[u
] |= (1 << t
);
1519 is_sampler_type(GLenum type
)
1525 case GL_SAMPLER_CUBE
:
1526 case GL_SAMPLER_1D_SHADOW
:
1527 case GL_SAMPLER_2D_SHADOW
:
1528 case GL_SAMPLER_2D_RECT_ARB
:
1529 case GL_SAMPLER_2D_RECT_SHADOW_ARB
:
1530 case GL_SAMPLER_1D_ARRAY_EXT
:
1531 case GL_SAMPLER_2D_ARRAY_EXT
:
1540 * Check if the type given by userType is allowed to set a uniform of the
1541 * target type. Generally, equivalence is required, but setting Boolean
1542 * uniforms can be done with glUniformiv or glUniformfv.
1545 compatible_types(GLenum userType
, GLenum targetType
)
1547 if (userType
== targetType
)
1550 if (targetType
== GL_BOOL
&& (userType
== GL_FLOAT
|| userType
== GL_INT
))
1553 if (targetType
== GL_BOOL_VEC2
&& (userType
== GL_FLOAT_VEC2
||
1554 userType
== GL_INT_VEC2
))
1557 if (targetType
== GL_BOOL_VEC3
&& (userType
== GL_FLOAT_VEC3
||
1558 userType
== GL_INT_VEC3
))
1561 if (targetType
== GL_BOOL_VEC4
&& (userType
== GL_FLOAT_VEC4
||
1562 userType
== GL_INT_VEC4
))
1565 if (is_sampler_type(targetType
) && userType
== GL_INT
)
1573 * Set the value of a program's uniform variable.
1574 * \param program the program whose uniform to update
1575 * \param index the index of the program parameter for the uniform
1576 * \param offset additional parameter slot offset (for arrays)
1577 * \param type the datatype of the uniform
1578 * \param count the number of uniforms to set
1579 * \param elems number of elements per uniform
1580 * \param values the new values
1583 set_program_uniform(GLcontext
*ctx
, struct gl_program
*program
,
1584 GLint index
, GLint offset
,
1585 GLenum type
, GLsizei count
, GLint elems
,
1588 struct gl_program_parameter
*param
=
1589 &program
->Parameters
->Parameters
[index
];
1591 assert(offset
>= 0);
1593 if (!compatible_types(type
, param
->DataType
)) {
1594 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUniform(type mismatch)");
1598 if (index
+ offset
> (GLint
) program
->Parameters
->Size
) {
1599 /* out of bounds! */
1603 if (param
->Type
== PROGRAM_SAMPLER
) {
1604 /* This controls which texture unit which is used by a sampler */
1605 GLuint texUnit
, sampler
;
1608 /* data type for setting samplers must be int */
1609 if (type
!= GL_INT
) {
1610 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1611 "glUniform(only glUniform1i can be used "
1612 "to set sampler uniforms)");
1616 /* XXX arrays of samplers haven't been tested much, but it's not a
1619 for (i
= 0; i
< count
; i
++) {
1620 sampler
= (GLuint
) program
->Parameters
->ParameterValues
[index
+ i
][0];
1621 texUnit
= ((GLuint
*) values
)[i
];
1623 /* check that the sampler (tex unit index) is legal */
1624 if (texUnit
>= ctx
->Const
.MaxTextureImageUnits
) {
1625 _mesa_error(ctx
, GL_INVALID_VALUE
,
1626 "glUniform1(invalid sampler/tex unit index)");
1630 /* This maps a sampler to a texture unit: */
1631 if (sampler
< MAX_SAMPLERS
) {
1632 program
->SamplerUnits
[sampler
] = texUnit
;
1636 _mesa_update_shader_textures_used(program
);
1638 FLUSH_VERTICES(ctx
, _NEW_TEXTURE
);
1641 /* ordinary uniform variable */
1643 const GLint slots
= (param
->Size
+ 3) / 4;
1644 const GLint typeSize
= sizeof_glsl_type(param
->DataType
);
1646 if (param
->Size
> typeSize
) {
1648 /* we'll ignore extra data below */
1651 /* non-array: count must be one */
1653 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1654 "glUniform(uniform is not an array)");
1659 for (k
= 0; k
< count
; k
++) {
1660 GLfloat
*uniformVal
;
1662 if (offset
+ k
> slots
) {
1663 /* Extra array data is ignored */
1667 uniformVal
= program
->Parameters
->ParameterValues
[index
+ offset
+ k
];
1668 if (is_integer_type(type
)) {
1669 const GLint
*iValues
= ((const GLint
*) values
) + k
* elems
;
1670 for (i
= 0; i
< elems
; i
++) {
1671 uniformVal
[i
] = (GLfloat
) iValues
[i
];
1675 const GLfloat
*fValues
= ((const GLfloat
*) values
) + k
* elems
;
1676 for (i
= 0; i
< elems
; i
++) {
1677 uniformVal
[i
] = fValues
[i
];
1681 /* if the uniform is bool-valued, convert to 1.0 or 0.0 */
1682 if (is_boolean_type(param
->DataType
)) {
1683 for (i
= 0; i
< elems
; i
++) {
1684 uniformVal
[i
] = uniformVal
[i
] ? 1.0f
: 0.0f
;
1693 * Called via ctx->Driver.Uniform().
1696 _mesa_uniform(GLcontext
*ctx
, GLint location
, GLsizei count
,
1697 const GLvoid
*values
, GLenum type
)
1699 struct gl_shader_program
*shProg
= ctx
->Shader
.CurrentProgram
;
1700 struct gl_uniform
*uniform
;
1701 GLint elems
, offset
;
1704 if (!shProg
|| !shProg
->LinkStatus
) {
1705 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUniform(program not linked)");
1710 return; /* The standard specifies this as a no-op */
1712 if (location
< -1) {
1713 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUniform(location)");
1717 split_location_offset(&location
, &offset
);
1719 if (location
< 0 || location
>= (GLint
) shProg
->Uniforms
->NumUniforms
) {
1720 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniform(location)");
1725 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniform(count < 0)");
1731 basicType
= GL_FLOAT
;
1739 basicType
= GL_FLOAT
;
1747 basicType
= GL_FLOAT
;
1755 basicType
= GL_FLOAT
;
1763 _mesa_problem(ctx
, "Invalid type in _mesa_uniform");
1767 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1769 uniform
= &shProg
->Uniforms
->Uniforms
[location
];
1771 if (ctx
->Shader
.Flags
& GLSL_UNIFORMS
) {
1773 _mesa_printf("Mesa: set program %u uniform %s (loc %d) to: ",
1774 shProg
->Name
, uniform
->Name
, location
);
1775 if (basicType
== GL_INT
) {
1776 const GLint
*v
= (const GLint
*) values
;
1777 for (i
= 0; i
< count
* elems
; i
++) {
1778 _mesa_printf("%d ", v
[i
]);
1782 const GLfloat
*v
= (const GLfloat
*) values
;
1783 for (i
= 0; i
< count
* elems
; i
++) {
1784 _mesa_printf("%g ", v
[i
]);
1790 /* A uniform var may be used by both a vertex shader and a fragment
1791 * shader. We may need to update one or both shader's uniform here:
1793 if (shProg
->VertexProgram
) {
1794 /* convert uniform location to program parameter index */
1795 GLint index
= uniform
->VertPos
;
1797 set_program_uniform(ctx
, &shProg
->VertexProgram
->Base
,
1798 index
, offset
, type
, count
, elems
, values
);
1802 if (shProg
->FragmentProgram
) {
1803 /* convert uniform location to program parameter index */
1804 GLint index
= uniform
->FragPos
;
1806 set_program_uniform(ctx
, &shProg
->FragmentProgram
->Base
,
1807 index
, offset
, type
, count
, elems
, values
);
1811 uniform
->Initialized
= GL_TRUE
;
1816 * Set a matrix-valued program parameter.
1819 set_program_uniform_matrix(GLcontext
*ctx
, struct gl_program
*program
,
1820 GLuint index
, GLuint offset
,
1821 GLuint count
, GLuint rows
, GLuint cols
,
1822 GLboolean transpose
, const GLfloat
*values
)
1824 GLuint mat
, row
, col
;
1825 GLuint dst
= index
+ offset
, src
= 0;
1828 /* check that the number of rows, columns is correct */
1829 get_matrix_dims(program
->Parameters
->Parameters
[index
].DataType
, &nr
, &nc
);
1830 if (rows
!= nr
|| cols
!= nc
) {
1831 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1832 "glUniformMatrix(matrix size mismatch)");
1836 if (index
+ offset
> program
->Parameters
->Size
) {
1837 /* out of bounds! */
1842 * Note: the _columns_ of a matrix are stored in program registers, not
1843 * the rows. So, the loops below look a little funny.
1844 * XXX could optimize this a bit...
1847 /* loop over matrices */
1848 for (mat
= 0; mat
< count
; mat
++) {
1851 for (col
= 0; col
< cols
; col
++) {
1852 GLfloat
*v
= program
->Parameters
->ParameterValues
[dst
];
1853 for (row
= 0; row
< rows
; row
++) {
1855 v
[row
] = values
[src
+ row
* cols
+ col
];
1858 v
[row
] = values
[src
+ col
* rows
+ row
];
1864 src
+= rows
* cols
; /* next matrix */
1870 * Called by ctx->Driver.UniformMatrix().
1871 * Note: cols=2, rows=4 ==> array[2] of vec4
1874 _mesa_uniform_matrix(GLcontext
*ctx
, GLint cols
, GLint rows
,
1875 GLenum matrixType
, GLint location
, GLsizei count
,
1876 GLboolean transpose
, const GLfloat
*values
)
1878 struct gl_shader_program
*shProg
= ctx
->Shader
.CurrentProgram
;
1879 struct gl_uniform
*uniform
;
1882 if (!shProg
|| !shProg
->LinkStatus
) {
1883 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1884 "glUniformMatrix(program not linked)");
1889 return; /* The standard specifies this as a no-op */
1891 if (location
< -1) {
1892 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUniformMatrix(location)");
1896 split_location_offset(&location
, &offset
);
1898 if (location
< 0 || location
>= (GLint
) shProg
->Uniforms
->NumUniforms
) {
1899 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniformMatrix(location)");
1902 if (values
== NULL
) {
1903 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniformMatrix");
1907 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1909 uniform
= &shProg
->Uniforms
->Uniforms
[location
];
1911 if (shProg
->VertexProgram
) {
1912 /* convert uniform location to program parameter index */
1913 GLint index
= uniform
->VertPos
;
1915 set_program_uniform_matrix(ctx
, &shProg
->VertexProgram
->Base
,
1917 count
, rows
, cols
, transpose
, values
);
1921 if (shProg
->FragmentProgram
) {
1922 /* convert uniform location to program parameter index */
1923 GLint index
= uniform
->FragPos
;
1925 set_program_uniform_matrix(ctx
, &shProg
->FragmentProgram
->Base
,
1927 count
, rows
, cols
, transpose
, values
);
1931 uniform
->Initialized
= GL_TRUE
;
1936 _mesa_validate_program(GLcontext
*ctx
, GLuint program
)
1938 struct gl_shader_program
*shProg
;
1940 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
1945 if (!shProg
->LinkStatus
) {
1946 shProg
->Validated
= GL_FALSE
;
1950 /* From the GL spec, a program is invalid if any of these are true:
1952 any two active samplers in the current program object are of
1953 different types, but refer to the same texture image unit,
1955 any active sampler in the current program object refers to a texture
1956 image unit where fixed-function fragment processing accesses a
1957 texture target that does not match the sampler type, or
1959 the sum of the number of active samplers in the program and the
1960 number of texture image units enabled for fixed-function fragment
1961 processing exceeds the combined limit on the total number of texture
1962 image units allowed.
1965 shProg
->Validated
= GL_TRUE
;
1970 * Plug in Mesa's GLSL functions into the device driver function table.
1973 _mesa_init_glsl_driver_functions(struct dd_function_table
*driver
)
1975 driver
->AttachShader
= _mesa_attach_shader
;
1976 driver
->BindAttribLocation
= _mesa_bind_attrib_location
;
1977 driver
->CompileShader
= _mesa_compile_shader
;
1978 driver
->CreateProgram
= _mesa_create_program
;
1979 driver
->CreateShader
= _mesa_create_shader
;
1980 driver
->DeleteProgram2
= _mesa_delete_program2
;
1981 driver
->DeleteShader
= _mesa_delete_shader
;
1982 driver
->DetachShader
= _mesa_detach_shader
;
1983 driver
->GetActiveAttrib
= _mesa_get_active_attrib
;
1984 driver
->GetActiveUniform
= _mesa_get_active_uniform
;
1985 driver
->GetAttachedShaders
= _mesa_get_attached_shaders
;
1986 driver
->GetAttribLocation
= _mesa_get_attrib_location
;
1987 driver
->GetHandle
= _mesa_get_handle
;
1988 driver
->GetProgramiv
= _mesa_get_programiv
;
1989 driver
->GetProgramInfoLog
= _mesa_get_program_info_log
;
1990 driver
->GetShaderiv
= _mesa_get_shaderiv
;
1991 driver
->GetShaderInfoLog
= _mesa_get_shader_info_log
;
1992 driver
->GetShaderSource
= _mesa_get_shader_source
;
1993 driver
->GetUniformfv
= _mesa_get_uniformfv
;
1994 driver
->GetUniformiv
= _mesa_get_uniformiv
;
1995 driver
->GetUniformLocation
= _mesa_get_uniform_location
;
1996 driver
->IsProgram
= _mesa_is_program
;
1997 driver
->IsShader
= _mesa_is_shader
;
1998 driver
->LinkProgram
= _mesa_link_program
;
1999 driver
->ShaderSource
= _mesa_shader_source
;
2000 driver
->Uniform
= _mesa_uniform
;
2001 driver
->UniformMatrix
= _mesa_uniform_matrix
;
2002 driver
->UseProgram
= _mesa_use_program
;
2003 driver
->ValidateProgram
= _mesa_validate_program
;