2 * Mesa 3-D graphics library
5 * Copyright (C) 2004-2008 Brian Paul All Rights Reserved.
6 * Copyright (C) 2009 VMware, Inc. All Rights Reserved.
8 * Permission is hereby granted, free of charge, to any person obtaining a
9 * copy of this software and associated documentation files (the "Software"),
10 * to deal in the Software without restriction, including without limitation
11 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
12 * and/or sell copies of the Software, and to permit persons to whom the
13 * Software is furnished to do so, subject to the following conditions:
15 * The above copyright notice and this permission notice shall be included
16 * in all copies or substantial portions of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
21 * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
22 * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
23 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
28 * Implementation of GLSL-related API functions
34 * 1. Check that the right error code is generated for all _mesa_error() calls.
35 * 2. Insert FLUSH_VERTICES calls in various places
39 #include "main/glheader.h"
40 #include "main/context.h"
41 #include "main/hash.h"
42 #include "main/macros.h"
43 #include "shader/program.h"
44 #include "shader/prog_parameter.h"
45 #include "shader/prog_print.h"
46 #include "shader/prog_statevars.h"
47 #include "shader/prog_uniform.h"
48 #include "shader/shader_api.h"
49 #include "shader/slang/slang_compile.h"
50 #include "shader/slang/slang_link.h"
51 #include "glapi/dispatch.h"
55 * Allocate a new gl_shader_program object, initialize it.
57 static struct gl_shader_program
*
58 _mesa_new_shader_program(GLcontext
*ctx
, GLuint name
)
60 struct gl_shader_program
*shProg
;
61 shProg
= CALLOC_STRUCT(gl_shader_program
);
63 shProg
->Type
= GL_SHADER_PROGRAM_MESA
;
66 shProg
->Attributes
= _mesa_new_parameter_list();
73 * Clear (free) the shader program state that gets produced by linking.
76 _mesa_clear_shader_program_data(GLcontext
*ctx
,
77 struct gl_shader_program
*shProg
)
79 _mesa_reference_vertprog(ctx
, &shProg
->VertexProgram
, NULL
);
80 _mesa_reference_fragprog(ctx
, &shProg
->FragmentProgram
, NULL
);
82 if (shProg
->Uniforms
) {
83 _mesa_free_uniform_list(shProg
->Uniforms
);
84 shProg
->Uniforms
= NULL
;
87 if (shProg
->Varying
) {
88 _mesa_free_parameter_list(shProg
->Varying
);
89 shProg
->Varying
= NULL
;
95 * Free all the data that hangs off a shader program object, but not the
99 _mesa_free_shader_program_data(GLcontext
*ctx
,
100 struct gl_shader_program
*shProg
)
104 assert(shProg
->Type
== GL_SHADER_PROGRAM_MESA
);
106 _mesa_clear_shader_program_data(ctx
, shProg
);
108 if (shProg
->Attributes
) {
109 _mesa_free_parameter_list(shProg
->Attributes
);
110 shProg
->Attributes
= NULL
;
114 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
115 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
117 shProg
->NumShaders
= 0;
119 if (shProg
->Shaders
) {
120 _mesa_free(shProg
->Shaders
);
121 shProg
->Shaders
= NULL
;
124 if (shProg
->InfoLog
) {
125 _mesa_free(shProg
->InfoLog
);
126 shProg
->InfoLog
= NULL
;
132 * Free/delete a shader program object.
135 _mesa_free_shader_program(GLcontext
*ctx
, struct gl_shader_program
*shProg
)
137 _mesa_free_shader_program_data(ctx
, shProg
);
144 * Set ptr to point to shProg.
145 * If ptr is pointing to another object, decrement its refcount (and delete
146 * if refcount hits zero).
147 * Then set ptr to point to shProg, incrementing its refcount.
149 /* XXX this could be static */
151 _mesa_reference_shader_program(GLcontext
*ctx
,
152 struct gl_shader_program
**ptr
,
153 struct gl_shader_program
*shProg
)
156 if (*ptr
== shProg
) {
161 /* Unreference the old shader program */
162 GLboolean deleteFlag
= GL_FALSE
;
163 struct gl_shader_program
*old
= *ptr
;
165 ASSERT(old
->RefCount
> 0);
168 printf("ShaderProgram %p ID=%u RefCount-- to %d\n",
169 (void *) old
, old
->Name
, old
->RefCount
);
171 deleteFlag
= (old
->RefCount
== 0);
174 _mesa_HashRemove(ctx
->Shared
->ShaderObjects
, old
->Name
);
175 _mesa_free_shader_program(ctx
, old
);
185 printf("ShaderProgram %p ID=%u RefCount++ to %d\n",
186 (void *) shProg
, shProg
->Name
, shProg
->RefCount
);
194 * Lookup a GLSL program object.
196 struct gl_shader_program
*
197 _mesa_lookup_shader_program(GLcontext
*ctx
, GLuint name
)
199 struct gl_shader_program
*shProg
;
201 shProg
= (struct gl_shader_program
*)
202 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
203 /* Note that both gl_shader and gl_shader_program objects are kept
204 * in the same hash table. Check the object's type to be sure it's
205 * what we're expecting.
207 if (shProg
&& shProg
->Type
!= GL_SHADER_PROGRAM_MESA
) {
217 * As above, but record an error if program is not found.
219 static struct gl_shader_program
*
220 _mesa_lookup_shader_program_err(GLcontext
*ctx
, GLuint name
,
224 _mesa_error(ctx
, GL_INVALID_VALUE
, caller
);
228 struct gl_shader_program
*shProg
= (struct gl_shader_program
*)
229 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
231 _mesa_error(ctx
, GL_INVALID_VALUE
, caller
);
234 if (shProg
->Type
!= GL_SHADER_PROGRAM_MESA
) {
235 _mesa_error(ctx
, GL_INVALID_OPERATION
, caller
);
246 * Allocate a new gl_shader object, initialize it.
249 _mesa_new_shader(GLcontext
*ctx
, GLuint name
, GLenum type
)
251 struct gl_shader
*shader
;
252 assert(type
== GL_FRAGMENT_SHADER
|| type
== GL_VERTEX_SHADER
);
253 shader
= CALLOC_STRUCT(gl_shader
);
257 shader
->RefCount
= 1;
264 _mesa_free_shader(GLcontext
*ctx
, struct gl_shader
*sh
)
267 _mesa_free((void *) sh
->Source
);
269 _mesa_free(sh
->InfoLog
);
270 _mesa_reference_program(ctx
, &sh
->Program
, NULL
);
276 * Set ptr to point to sh.
277 * If ptr is pointing to another shader, decrement its refcount (and delete
278 * if refcount hits zero).
279 * Then set ptr to point to sh, incrementing its refcount.
281 /* XXX this could be static */
283 _mesa_reference_shader(GLcontext
*ctx
, struct gl_shader
**ptr
,
284 struct gl_shader
*sh
)
292 /* Unreference the old shader */
293 GLboolean deleteFlag
= GL_FALSE
;
294 struct gl_shader
*old
= *ptr
;
296 ASSERT(old
->RefCount
> 0);
298 /*printf("SHADER DECR %p (%d) to %d\n",
299 (void*) old, old->Name, old->RefCount);*/
300 deleteFlag
= (old
->RefCount
== 0);
303 _mesa_HashRemove(ctx
->Shared
->ShaderObjects
, old
->Name
);
304 _mesa_free_shader(ctx
, old
);
314 /*printf("SHADER INCR %p (%d) to %d\n",
315 (void*) sh, sh->Name, sh->RefCount);*/
322 * Lookup a GLSL shader object.
325 _mesa_lookup_shader(GLcontext
*ctx
, GLuint name
)
328 struct gl_shader
*sh
= (struct gl_shader
*)
329 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
330 /* Note that both gl_shader and gl_shader_program objects are kept
331 * in the same hash table. Check the object's type to be sure it's
332 * what we're expecting.
334 if (sh
&& sh
->Type
== GL_SHADER_PROGRAM_MESA
) {
344 * As above, but record an error if shader is not found.
346 static struct gl_shader
*
347 _mesa_lookup_shader_err(GLcontext
*ctx
, GLuint name
, const char *caller
)
350 _mesa_error(ctx
, GL_INVALID_VALUE
, caller
);
354 struct gl_shader
*sh
= (struct gl_shader
*)
355 _mesa_HashLookup(ctx
->Shared
->ShaderObjects
, name
);
357 _mesa_error(ctx
, GL_INVALID_VALUE
, caller
);
360 if (sh
->Type
== GL_SHADER_PROGRAM_MESA
) {
361 _mesa_error(ctx
, GL_INVALID_OPERATION
, caller
);
370 * Return mask of GLSL_x flags by examining the MESA_GLSL env var.
373 get_shader_flags(void)
375 GLbitfield flags
= 0x0;
376 const char *env
= _mesa_getenv("MESA_GLSL");
379 if (_mesa_strstr(env
, "dump"))
381 if (_mesa_strstr(env
, "log"))
383 if (_mesa_strstr(env
, "nopt"))
384 flags
|= GLSL_NO_OPT
;
385 else if (_mesa_strstr(env
, "opt"))
387 if (_mesa_strstr(env
, "uniform"))
388 flags
|= GLSL_UNIFORMS
;
396 * Initialize context's shader state.
399 _mesa_init_shader_state(GLcontext
* ctx
)
401 /* Device drivers may override these to control what kind of instructions
402 * are generated by the GLSL compiler.
404 ctx
->Shader
.EmitHighLevelInstructions
= GL_TRUE
;
405 ctx
->Shader
.EmitContReturn
= GL_TRUE
;
406 ctx
->Shader
.EmitCondCodes
= GL_FALSE
;
407 ctx
->Shader
.EmitComments
= GL_FALSE
;
408 ctx
->Shader
.Flags
= get_shader_flags();
410 /* Default pragma settings */
411 ctx
->Shader
.DefaultPragmas
.IgnoreOptimize
= GL_FALSE
;
412 ctx
->Shader
.DefaultPragmas
.IgnoreDebug
= GL_FALSE
;
413 ctx
->Shader
.DefaultPragmas
.Optimize
= GL_TRUE
;
414 ctx
->Shader
.DefaultPragmas
.Debug
= GL_FALSE
;
419 * Free the per-context shader-related state.
422 _mesa_free_shader_state(GLcontext
*ctx
)
424 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
, NULL
);
429 * Copy string from <src> to <dst>, up to maxLength characters, returning
430 * length of <dst> in <length>.
431 * \param src the strings source
432 * \param maxLength max chars to copy
433 * \param length returns number of chars copied
434 * \param dst the string destination
437 copy_string(GLchar
*dst
, GLsizei maxLength
, GLsizei
*length
, const GLchar
*src
)
440 for (len
= 0; len
< maxLength
- 1 && src
&& src
[len
]; len
++)
450 _mesa_is_program(GLcontext
*ctx
, GLuint name
)
452 struct gl_shader_program
*shProg
= _mesa_lookup_shader_program(ctx
, name
);
453 return shProg
? GL_TRUE
: GL_FALSE
;
458 _mesa_is_shader(GLcontext
*ctx
, GLuint name
)
460 struct gl_shader
*shader
= _mesa_lookup_shader(ctx
, name
);
461 return shader
? GL_TRUE
: GL_FALSE
;
466 * Called via ctx->Driver.AttachShader()
469 _mesa_attach_shader(GLcontext
*ctx
, GLuint program
, GLuint shader
)
471 struct gl_shader_program
*shProg
;
472 struct gl_shader
*sh
;
475 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glAttachShader");
479 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glAttachShader");
484 n
= shProg
->NumShaders
;
485 for (i
= 0; i
< n
; i
++) {
486 if (shProg
->Shaders
[i
] == sh
) {
487 /* The shader is already attched to this program. The
488 * GL_ARB_shader_objects spec says:
490 * "The error INVALID_OPERATION is generated by AttachObjectARB
491 * if <obj> is already attached to <containerObj>."
493 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glAttachShader");
499 shProg
->Shaders
= (struct gl_shader
**)
500 _mesa_realloc(shProg
->Shaders
,
501 n
* sizeof(struct gl_shader
*),
502 (n
+ 1) * sizeof(struct gl_shader
*));
503 if (!shProg
->Shaders
) {
504 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glAttachShader");
509 shProg
->Shaders
[n
] = NULL
; /* since realloc() didn't zero the new space */
510 _mesa_reference_shader(ctx
, &shProg
->Shaders
[n
], sh
);
511 shProg
->NumShaders
++;
516 _mesa_get_attrib_location(GLcontext
*ctx
, GLuint program
,
519 struct gl_shader_program
*shProg
520 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttribLocation");
526 if (!shProg
->LinkStatus
) {
527 _mesa_error(ctx
, GL_INVALID_OPERATION
,
528 "glGetAttribLocation(program not linked)");
535 if (shProg
->VertexProgram
) {
536 const struct gl_program_parameter_list
*attribs
=
537 shProg
->VertexProgram
->Base
.Attributes
;
539 GLint i
= _mesa_lookup_parameter_index(attribs
, -1, name
);
541 return attribs
->Parameters
[i
].StateIndexes
[0];
550 _mesa_bind_attrib_location(GLcontext
*ctx
, GLuint program
, GLuint index
,
553 struct gl_shader_program
*shProg
;
554 const GLint size
= -1; /* unknown size */
556 GLenum datatype
= GL_FLOAT_VEC4
;
558 shProg
= _mesa_lookup_shader_program_err(ctx
, program
,
559 "glBindAttribLocation");
567 if (strncmp(name
, "gl_", 3) == 0) {
568 _mesa_error(ctx
, GL_INVALID_OPERATION
,
569 "glBindAttribLocation(illegal name)");
573 if (index
>= ctx
->Const
.VertexProgram
.MaxAttribs
) {
574 _mesa_error(ctx
, GL_INVALID_VALUE
, "glBindAttribLocation(index)");
578 if (shProg
->LinkStatus
) {
579 /* get current index/location for the attribute */
580 oldIndex
= _mesa_get_attrib_location(ctx
, program
, name
);
586 /* this will replace the current value if it's already in the list */
587 i
= _mesa_add_attribute(shProg
->Attributes
, name
, size
, datatype
, index
);
589 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glBindAttribLocation");
594 * Note that this attribute binding won't go into effect until
595 * glLinkProgram is called again.
601 _mesa_create_shader(GLcontext
*ctx
, GLenum type
)
603 struct gl_shader
*sh
;
606 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
609 case GL_FRAGMENT_SHADER
:
610 case GL_VERTEX_SHADER
:
611 sh
= _mesa_new_shader(ctx
, name
, type
);
614 _mesa_error(ctx
, GL_INVALID_ENUM
, "CreateShader(type)");
618 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, sh
);
625 _mesa_create_program(GLcontext
*ctx
)
628 struct gl_shader_program
*shProg
;
630 name
= _mesa_HashFindFreeKeyBlock(ctx
->Shared
->ShaderObjects
, 1);
631 shProg
= _mesa_new_shader_program(ctx
, name
);
633 _mesa_HashInsert(ctx
->Shared
->ShaderObjects
, name
, shProg
);
635 assert(shProg
->RefCount
== 1);
642 * Named w/ "2" to indicate OpenGL 2.x vs GL_ARB_fragment_programs's
646 _mesa_delete_program2(GLcontext
*ctx
, GLuint name
)
649 * NOTE: deleting shaders/programs works a bit differently than
650 * texture objects (and buffer objects, etc). Shader/program
651 * handles/IDs exist in the hash table until the object is really
652 * deleted (refcount==0). With texture objects, the handle/ID is
653 * removed from the hash table in glDeleteTextures() while the tex
654 * object itself might linger until its refcount goes to zero.
656 struct gl_shader_program
*shProg
;
658 shProg
= _mesa_lookup_shader_program_err(ctx
, name
, "glDeleteProgram");
662 shProg
->DeletePending
= GL_TRUE
;
664 /* effectively, decr shProg's refcount */
665 _mesa_reference_shader_program(ctx
, &shProg
, NULL
);
670 _mesa_delete_shader(GLcontext
*ctx
, GLuint shader
)
672 struct gl_shader
*sh
;
674 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glDeleteShader");
678 sh
->DeletePending
= GL_TRUE
;
680 /* effectively, decr sh's refcount */
681 _mesa_reference_shader(ctx
, &sh
, NULL
);
686 _mesa_detach_shader(GLcontext
*ctx
, GLuint program
, GLuint shader
)
688 struct gl_shader_program
*shProg
;
692 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glDetachShader");
696 n
= shProg
->NumShaders
;
698 for (i
= 0; i
< n
; i
++) {
699 if (shProg
->Shaders
[i
]->Name
== shader
) {
701 struct gl_shader
**newList
;
704 _mesa_reference_shader(ctx
, &shProg
->Shaders
[i
], NULL
);
706 /* alloc new, smaller array */
707 newList
= (struct gl_shader
**)
708 _mesa_malloc((n
- 1) * sizeof(struct gl_shader
*));
710 _mesa_error(ctx
, GL_OUT_OF_MEMORY
, "glDetachShader");
713 for (j
= 0; j
< i
; j
++) {
714 newList
[j
] = shProg
->Shaders
[j
];
717 newList
[j
++] = shProg
->Shaders
[i
];
718 _mesa_free(shProg
->Shaders
);
720 shProg
->Shaders
= newList
;
721 shProg
->NumShaders
= n
- 1;
726 for (j
= 0; j
< shProg
->NumShaders
; j
++) {
727 assert(shProg
->Shaders
[j
]->Type
== GL_VERTEX_SHADER
||
728 shProg
->Shaders
[j
]->Type
== GL_FRAGMENT_SHADER
);
729 assert(shProg
->Shaders
[j
]->RefCount
> 0);
741 if (_mesa_is_shader(ctx
, shader
))
742 err
= GL_INVALID_OPERATION
;
743 else if (_mesa_is_program(ctx
, shader
))
744 err
= GL_INVALID_OPERATION
;
746 err
= GL_INVALID_VALUE
;
747 _mesa_error(ctx
, err
, "glDetachProgram(shader)");
754 sizeof_glsl_type(GLenum type
)
763 case GL_SAMPLER_CUBE
:
764 case GL_SAMPLER_1D_SHADOW
:
765 case GL_SAMPLER_2D_SHADOW
:
766 case GL_SAMPLER_2D_RECT_ARB
:
767 case GL_SAMPLER_2D_RECT_SHADOW_ARB
:
768 case GL_SAMPLER_1D_ARRAY_SHADOW_EXT
:
769 case GL_SAMPLER_2D_ARRAY_SHADOW_EXT
:
770 case GL_SAMPLER_CUBE_SHADOW_EXT
:
785 case GL_FLOAT_MAT2x3
:
786 case GL_FLOAT_MAT2x4
:
787 return 8; /* two float[4] vectors */
789 case GL_FLOAT_MAT3x2
:
790 case GL_FLOAT_MAT3x4
:
791 return 12; /* three float[4] vectors */
793 case GL_FLOAT_MAT4x2
:
794 case GL_FLOAT_MAT4x3
:
795 return 16; /* four float[4] vectors */
797 _mesa_problem(NULL
, "Invalid type in sizeof_glsl_type()");
804 is_boolean_type(GLenum type
)
819 is_integer_type(GLenum type
)
834 is_sampler_type(GLenum type
)
840 case GL_SAMPLER_CUBE
:
841 case GL_SAMPLER_1D_SHADOW
:
842 case GL_SAMPLER_2D_SHADOW
:
843 case GL_SAMPLER_2D_RECT_ARB
:
844 case GL_SAMPLER_2D_RECT_SHADOW_ARB
:
845 case GL_SAMPLER_1D_ARRAY_EXT
:
846 case GL_SAMPLER_2D_ARRAY_EXT
:
855 _mesa_get_active_attrib(GLcontext
*ctx
, GLuint program
, GLuint index
,
856 GLsizei maxLength
, GLsizei
*length
, GLint
*size
,
857 GLenum
*type
, GLchar
*nameOut
)
859 const struct gl_program_parameter_list
*attribs
= NULL
;
860 struct gl_shader_program
*shProg
;
862 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetActiveAttrib");
866 if (shProg
->VertexProgram
)
867 attribs
= shProg
->VertexProgram
->Base
.Attributes
;
869 if (!attribs
|| index
>= attribs
->NumParameters
) {
870 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetActiveAttrib(index)");
874 copy_string(nameOut
, maxLength
, length
, attribs
->Parameters
[index
].Name
);
877 *size
= attribs
->Parameters
[index
].Size
878 / sizeof_glsl_type(attribs
->Parameters
[index
].DataType
);
881 *type
= attribs
->Parameters
[index
].DataType
;
885 static struct gl_program_parameter
*
886 get_uniform_parameter(const struct gl_shader_program
*shProg
, GLuint index
)
888 const struct gl_program
*prog
= NULL
;
891 progPos
= shProg
->Uniforms
->Uniforms
[index
].VertPos
;
893 prog
= &shProg
->VertexProgram
->Base
;
896 progPos
= shProg
->Uniforms
->Uniforms
[index
].FragPos
;
898 prog
= &shProg
->FragmentProgram
->Base
;
902 if (!prog
|| progPos
< 0)
903 return NULL
; /* should never happen */
905 return &prog
->Parameters
->Parameters
[progPos
];
910 * Called via ctx->Driver.GetActiveUniform().
913 _mesa_get_active_uniform(GLcontext
*ctx
, GLuint program
, GLuint index
,
914 GLsizei maxLength
, GLsizei
*length
, GLint
*size
,
915 GLenum
*type
, GLchar
*nameOut
)
917 const struct gl_shader_program
*shProg
;
918 const struct gl_program
*prog
= NULL
;
919 const struct gl_program_parameter
*param
;
922 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glGetActiveUniform");
926 if (!shProg
->Uniforms
|| index
>= shProg
->Uniforms
->NumUniforms
) {
927 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetActiveUniform(index)");
931 progPos
= shProg
->Uniforms
->Uniforms
[index
].VertPos
;
933 prog
= &shProg
->VertexProgram
->Base
;
936 progPos
= shProg
->Uniforms
->Uniforms
[index
].FragPos
;
938 prog
= &shProg
->FragmentProgram
->Base
;
942 if (!prog
|| progPos
< 0)
943 return; /* should never happen */
945 ASSERT(progPos
< prog
->Parameters
->NumParameters
);
946 param
= &prog
->Parameters
->Parameters
[progPos
];
949 copy_string(nameOut
, maxLength
, length
, param
->Name
);
953 GLint typeSize
= sizeof_glsl_type(param
->DataType
);
954 if (param
->Size
> typeSize
) {
956 * Array elements are placed on vector[4] boundaries so they're
957 * a multiple of four floats. We round typeSize up to next multiple
958 * of four to get the right size below.
960 typeSize
= (typeSize
+ 3) & ~3;
962 /* Note that the returned size is in units of the <type>, not bytes */
963 *size
= param
->Size
/ typeSize
;
967 *type
= param
->DataType
;
973 * Called via ctx->Driver.GetAttachedShaders().
976 _mesa_get_attached_shaders(GLcontext
*ctx
, GLuint program
, GLsizei maxCount
,
977 GLsizei
*count
, GLuint
*obj
)
979 struct gl_shader_program
*shProg
=
980 _mesa_lookup_shader_program_err(ctx
, program
, "glGetAttachedShaders");
983 for (i
= 0; i
< (GLuint
) maxCount
&& i
< shProg
->NumShaders
; i
++) {
984 obj
[i
] = shProg
->Shaders
[i
]->Name
;
993 _mesa_get_handle(GLcontext
*ctx
, GLenum pname
)
997 if (pname
== GL_PROGRAM_OBJECT_ARB
) {
998 CALL_GetIntegerv(ctx
->Exec
, (GL_CURRENT_PROGRAM
, &handle
));
1000 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetHandleARB");
1008 _mesa_get_programiv(GLcontext
*ctx
, GLuint program
,
1009 GLenum pname
, GLint
*params
)
1011 const struct gl_program_parameter_list
*attribs
;
1012 struct gl_shader_program
*shProg
1013 = _mesa_lookup_shader_program(ctx
, program
);
1016 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramiv(program)");
1020 if (shProg
->VertexProgram
)
1021 attribs
= shProg
->VertexProgram
->Base
.Attributes
;
1026 case GL_DELETE_STATUS
:
1027 *params
= shProg
->DeletePending
;
1029 case GL_LINK_STATUS
:
1030 *params
= shProg
->LinkStatus
;
1032 case GL_VALIDATE_STATUS
:
1033 *params
= shProg
->Validated
;
1035 case GL_INFO_LOG_LENGTH
:
1036 *params
= shProg
->InfoLog
? strlen(shProg
->InfoLog
) + 1 : 0;
1038 case GL_ATTACHED_SHADERS
:
1039 *params
= shProg
->NumShaders
;
1041 case GL_ACTIVE_ATTRIBUTES
:
1042 *params
= attribs
? attribs
->NumParameters
: 0;
1044 case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH
:
1045 *params
= _mesa_longest_parameter_name(attribs
, PROGRAM_INPUT
) + 1;
1047 case GL_ACTIVE_UNIFORMS
:
1048 *params
= shProg
->Uniforms
? shProg
->Uniforms
->NumUniforms
: 0;
1050 case GL_ACTIVE_UNIFORM_MAX_LENGTH
:
1051 *params
= _mesa_longest_uniform_name(shProg
->Uniforms
);
1053 (*params
)++; /* add one for terminating zero */
1055 case GL_PROGRAM_BINARY_LENGTH_OES
:
1059 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetProgramiv(pname)");
1066 _mesa_get_shaderiv(GLcontext
*ctx
, GLuint name
, GLenum pname
, GLint
*params
)
1068 struct gl_shader
*shader
= _mesa_lookup_shader_err(ctx
, name
, "glGetShaderiv");
1075 case GL_SHADER_TYPE
:
1076 *params
= shader
->Type
;
1078 case GL_DELETE_STATUS
:
1079 *params
= shader
->DeletePending
;
1081 case GL_COMPILE_STATUS
:
1082 *params
= shader
->CompileStatus
;
1084 case GL_INFO_LOG_LENGTH
:
1085 *params
= shader
->InfoLog
? strlen(shader
->InfoLog
) + 1 : 0;
1087 case GL_SHADER_SOURCE_LENGTH
:
1088 *params
= shader
->Source
? strlen((char *) shader
->Source
) + 1 : 0;
1091 _mesa_error(ctx
, GL_INVALID_ENUM
, "glGetShaderiv(pname)");
1098 _mesa_get_program_info_log(GLcontext
*ctx
, GLuint program
, GLsizei bufSize
,
1099 GLsizei
*length
, GLchar
*infoLog
)
1101 struct gl_shader_program
*shProg
1102 = _mesa_lookup_shader_program(ctx
, program
);
1104 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetProgramInfoLog(program)");
1107 copy_string(infoLog
, bufSize
, length
, shProg
->InfoLog
);
1112 _mesa_get_shader_info_log(GLcontext
*ctx
, GLuint shader
, GLsizei bufSize
,
1113 GLsizei
*length
, GLchar
*infoLog
)
1115 struct gl_shader
*sh
= _mesa_lookup_shader(ctx
, shader
);
1117 _mesa_error(ctx
, GL_INVALID_VALUE
, "glGetShaderInfoLog(shader)");
1120 copy_string(infoLog
, bufSize
, length
, sh
->InfoLog
);
1125 * Called via ctx->Driver.GetShaderSource().
1128 _mesa_get_shader_source(GLcontext
*ctx
, GLuint shader
, GLsizei maxLength
,
1129 GLsizei
*length
, GLchar
*sourceOut
)
1131 struct gl_shader
*sh
;
1132 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glGetShaderSource");
1136 copy_string(sourceOut
, maxLength
, length
, sh
->Source
);
1141 get_matrix_dims(GLenum type
, GLint
*rows
, GLint
*cols
)
1147 case GL_FLOAT_MAT2x3
:
1151 case GL_FLOAT_MAT2x4
:
1159 case GL_FLOAT_MAT3x2
:
1163 case GL_FLOAT_MAT3x4
:
1171 case GL_FLOAT_MAT4x2
:
1175 case GL_FLOAT_MAT4x3
:
1186 * Determine the number of rows and columns occupied by a uniform
1187 * according to its datatype. For non-matrix types (such as GL_FLOAT_VEC4),
1188 * the number of rows = 1 and cols = number of elements in the vector.
1191 get_uniform_rows_cols(const struct gl_program_parameter
*p
,
1192 GLint
*rows
, GLint
*cols
)
1194 get_matrix_dims(p
->DataType
, rows
, cols
);
1195 if (*rows
== 0 && *cols
== 0) {
1196 /* not a matrix type, probably a float or vector */
1202 *rows
= p
->Size
/ 4 + 1;
1203 if (p
->Size
% 4 == 0)
1206 *cols
= p
->Size
% 4;
1213 * Helper for get_uniform[fi]v() functions.
1214 * Given a shader program name and uniform location, return a pointer
1215 * to the shader program and return the program parameter position.
1218 lookup_uniform_parameter(GLcontext
*ctx
, GLuint program
, GLint location
,
1219 struct gl_program
**progOut
, GLint
*paramPosOut
)
1221 struct gl_shader_program
*shProg
1222 = _mesa_lookup_shader_program_err(ctx
, program
, "glGetUniform[if]v");
1223 struct gl_program
*prog
= NULL
;
1226 /* if shProg is NULL, we'll have already recorded an error */
1229 if (!shProg
->Uniforms
||
1231 location
>= (GLint
) shProg
->Uniforms
->NumUniforms
) {
1232 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetUniformfv(location)");
1235 /* OK, find the gl_program and program parameter location */
1236 progPos
= shProg
->Uniforms
->Uniforms
[location
].VertPos
;
1238 prog
= &shProg
->VertexProgram
->Base
;
1241 progPos
= shProg
->Uniforms
->Uniforms
[location
].FragPos
;
1243 prog
= &shProg
->FragmentProgram
->Base
;
1250 *paramPosOut
= progPos
;
1255 * Called via ctx->Driver.GetUniformfv().
1258 _mesa_get_uniformfv(GLcontext
*ctx
, GLuint program
, GLint location
,
1261 struct gl_program
*prog
;
1264 lookup_uniform_parameter(ctx
, program
, location
, &prog
, ¶mPos
);
1267 const struct gl_program_parameter
*p
=
1268 &prog
->Parameters
->Parameters
[paramPos
];
1269 GLint rows
, cols
, i
, j
, k
;
1271 get_uniform_rows_cols(p
, &rows
, &cols
);
1274 for (i
= 0; i
< rows
; i
++) {
1275 for (j
= 0; j
< cols
; j
++ ) {
1276 params
[k
++] = prog
->Parameters
->ParameterValues
[paramPos
+i
][j
];
1284 * Called via ctx->Driver.GetUniformiv().
1285 * \sa _mesa_get_uniformfv, only difference is a cast.
1288 _mesa_get_uniformiv(GLcontext
*ctx
, GLuint program
, GLint location
,
1291 struct gl_program
*prog
;
1294 lookup_uniform_parameter(ctx
, program
, location
, &prog
, ¶mPos
);
1297 const struct gl_program_parameter
*p
=
1298 &prog
->Parameters
->Parameters
[paramPos
];
1299 GLint rows
, cols
, i
, j
, k
;
1301 get_uniform_rows_cols(p
, &rows
, &cols
);
1304 for (i
= 0; i
< rows
; i
++) {
1305 for (j
= 0; j
< cols
; j
++ ) {
1306 params
[k
++] = (GLint
) prog
->Parameters
->ParameterValues
[paramPos
+i
][j
];
1314 * The value returned by GetUniformLocation actually encodes two things:
1315 * 1. the index into the prog->Uniforms[] array for the uniform
1316 * 2. an offset in the prog->ParameterValues[] array for specifying array
1317 * elements or structure fields.
1318 * This function merges those two values.
1321 merge_location_offset(GLint
*location
, GLint offset
)
1323 *location
= *location
| (offset
<< 16);
1328 * Seperate the uniform location and parameter offset. See above.
1331 split_location_offset(GLint
*location
, GLint
*offset
)
1333 *offset
= (*location
>> 16);
1334 *location
= *location
& 0xffff;
1339 * Called via ctx->Driver.GetUniformLocation().
1341 * The return value will encode two values, the uniform location and an
1342 * offset (used for arrays, structs).
1345 _mesa_get_uniform_location(GLcontext
*ctx
, GLuint program
, const GLchar
*name
)
1347 GLint offset
= 0, location
= -1;
1349 struct gl_shader_program
*shProg
=
1350 _mesa_lookup_shader_program_err(ctx
, program
, "glGetUniformLocation");
1355 if (shProg
->LinkStatus
== GL_FALSE
) {
1356 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetUniformfv(program)");
1360 /* XXX we should return -1 if the uniform was declared, but not
1364 /* XXX we need to be able to parse uniform names for structs and arrays
1371 /* handle 1-dimension arrays here... */
1372 char *c
= strchr(name
, '[');
1374 /* truncate name at [ */
1375 const GLint len
= c
- name
;
1376 GLchar
*newName
= _mesa_malloc(len
+ 1);
1378 return -1; /* out of mem */
1379 _mesa_memcpy(newName
, name
, len
);
1382 location
= _mesa_lookup_uniform(shProg
->Uniforms
, newName
);
1383 if (location
>= 0) {
1384 const GLint element
= _mesa_atoi(c
+ 1);
1386 /* get type of the uniform array element */
1387 struct gl_program_parameter
*p
;
1388 p
= get_uniform_parameter(shProg
, location
);
1391 get_matrix_dims(p
->DataType
, &rows
, &cols
);
1394 offset
= element
* rows
;
1399 _mesa_free(newName
);
1404 location
= _mesa_lookup_uniform(shProg
->Uniforms
, name
);
1407 if (location
>= 0) {
1408 merge_location_offset(&location
, offset
);
1417 * Called via ctx->Driver.ShaderSource()
1420 _mesa_shader_source(GLcontext
*ctx
, GLuint shader
, const GLchar
*source
)
1422 struct gl_shader
*sh
;
1424 sh
= _mesa_lookup_shader_err(ctx
, shader
, "glShaderSource");
1428 /* free old shader source string and install new one */
1430 _mesa_free((void *) sh
->Source
);
1432 sh
->Source
= source
;
1433 sh
->CompileStatus
= GL_FALSE
;
1435 sh
->SourceChecksum
= _mesa_str_checksum(sh
->Source
);
1441 * Called via ctx->Driver.CompileShader()
1444 _mesa_compile_shader(GLcontext
*ctx
, GLuint shaderObj
)
1446 struct gl_shader
*sh
;
1448 sh
= _mesa_lookup_shader_err(ctx
, shaderObj
, "glCompileShader");
1452 /* set default pragma state for shader */
1453 sh
->Pragmas
= ctx
->Shader
.DefaultPragmas
;
1455 /* this call will set the sh->CompileStatus field to indicate if
1456 * compilation was successful.
1458 (void) _slang_compile(ctx
, sh
);
1463 * Called via ctx->Driver.LinkProgram()
1466 _mesa_link_program(GLcontext
*ctx
, GLuint program
)
1468 struct gl_shader_program
*shProg
;
1470 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glLinkProgram");
1474 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
);
1476 _slang_link(ctx
, program
, shProg
);
1481 * Called via ctx->Driver.UseProgram()
1484 _mesa_use_program(GLcontext
*ctx
, GLuint program
)
1486 struct gl_shader_program
*shProg
;
1488 if (ctx
->Shader
.CurrentProgram
&&
1489 ctx
->Shader
.CurrentProgram
->Name
== program
) {
1494 FLUSH_VERTICES(ctx
, _NEW_PROGRAM
| _NEW_PROGRAM_CONSTANTS
);
1497 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glUseProgram");
1501 if (!shProg
->LinkStatus
) {
1502 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1503 "glUseProgram(program %u not linked)", program
);
1510 _mesa_printf("Use Shader %u\n", shProg
->Name
);
1511 for (i
= 0; i
< shProg
->NumShaders
; i
++) {
1512 _mesa_printf(" shader %u, type 0x%x, checksum %u\n",
1513 shProg
->Shaders
[i
]->Name
,
1514 shProg
->Shaders
[i
]->Type
,
1515 shProg
->Shaders
[i
]->SourceChecksum
);
1517 if (shProg
->VertexProgram
)
1518 printf(" vert prog %u\n", shProg
->VertexProgram
->Base
.Id
);
1519 if (shProg
->FragmentProgram
)
1520 printf(" frag prog %u\n", shProg
->FragmentProgram
->Base
.Id
);
1527 _mesa_reference_shader_program(ctx
, &ctx
->Shader
.CurrentProgram
, shProg
);
1533 * Update the vertex/fragment program's TexturesUsed array.
1535 * This needs to be called after glUniform(set sampler var) is called.
1536 * A call to glUniform(samplerVar, value) causes a sampler to point to a
1537 * particular texture unit. We know the sampler's texture target
1538 * (1D/2D/3D/etc) from compile time but the sampler's texture unit is
1539 * set by glUniform() calls.
1541 * So, scan the program->SamplerUnits[] and program->SamplerTargets[]
1542 * information to update the prog->TexturesUsed[] values.
1543 * Each value of TexturesUsed[unit] is one of zero, TEXTURE_1D_INDEX,
1544 * TEXTURE_2D_INDEX, TEXTURE_3D_INDEX, etc.
1545 * We'll use that info for state validation before rendering.
1548 _mesa_update_shader_textures_used(struct gl_program
*prog
)
1552 memset(prog
->TexturesUsed
, 0, sizeof(prog
->TexturesUsed
));
1554 for (s
= 0; s
< MAX_SAMPLERS
; s
++) {
1555 if (prog
->SamplersUsed
& (1 << s
)) {
1556 GLuint unit
= prog
->SamplerUnits
[s
];
1557 GLuint tgt
= prog
->SamplerTargets
[s
];
1558 assert(unit
< MAX_TEXTURE_IMAGE_UNITS
);
1559 assert(tgt
< NUM_TEXTURE_TARGETS
);
1560 prog
->TexturesUsed
[unit
] |= (1 << tgt
);
1567 * Check if the type given by userType is allowed to set a uniform of the
1568 * target type. Generally, equivalence is required, but setting Boolean
1569 * uniforms can be done with glUniformiv or glUniformfv.
1572 compatible_types(GLenum userType
, GLenum targetType
)
1574 if (userType
== targetType
)
1577 if (targetType
== GL_BOOL
&& (userType
== GL_FLOAT
|| userType
== GL_INT
))
1580 if (targetType
== GL_BOOL_VEC2
&& (userType
== GL_FLOAT_VEC2
||
1581 userType
== GL_INT_VEC2
))
1584 if (targetType
== GL_BOOL_VEC3
&& (userType
== GL_FLOAT_VEC3
||
1585 userType
== GL_INT_VEC3
))
1588 if (targetType
== GL_BOOL_VEC4
&& (userType
== GL_FLOAT_VEC4
||
1589 userType
== GL_INT_VEC4
))
1592 if (is_sampler_type(targetType
) && userType
== GL_INT
)
1600 * Set the value of a program's uniform variable.
1601 * \param program the program whose uniform to update
1602 * \param index the index of the program parameter for the uniform
1603 * \param offset additional parameter slot offset (for arrays)
1604 * \param type the incoming datatype of 'values'
1605 * \param count the number of uniforms to set
1606 * \param elems number of elements per uniform (1, 2, 3 or 4)
1607 * \param values the new values, of datatype 'type'
1610 set_program_uniform(GLcontext
*ctx
, struct gl_program
*program
,
1611 GLint index
, GLint offset
,
1612 GLenum type
, GLsizei count
, GLint elems
,
1615 const struct gl_program_parameter
*param
=
1616 &program
->Parameters
->Parameters
[index
];
1618 assert(offset
>= 0);
1622 if (!compatible_types(type
, param
->DataType
)) {
1623 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUniform(type mismatch)");
1627 if (index
+ offset
> (GLint
) program
->Parameters
->Size
) {
1628 /* out of bounds! */
1632 if (param
->Type
== PROGRAM_SAMPLER
) {
1633 /* This controls which texture unit which is used by a sampler */
1634 GLboolean changed
= GL_FALSE
;
1637 /* this should have been caught by the compatible_types() check */
1638 ASSERT(type
== GL_INT
);
1640 /* loop over number of samplers to change */
1641 for (i
= 0; i
< count
; i
++) {
1643 (GLuint
) program
->Parameters
->ParameterValues
[index
+ offset
+ i
][0];
1644 GLuint texUnit
= ((GLuint
*) values
)[i
];
1646 /* check that the sampler (tex unit index) is legal */
1647 if (texUnit
>= ctx
->Const
.MaxTextureImageUnits
) {
1648 _mesa_error(ctx
, GL_INVALID_VALUE
,
1649 "glUniform1(invalid sampler/tex unit index)");
1653 /* This maps a sampler to a texture unit: */
1654 if (sampler
< MAX_SAMPLERS
) {
1656 _mesa_printf("Set program %p sampler %d '%s' to unit %u\n",
1657 program
, sampler
, param
->Name
, texUnit
);
1659 if (program
->SamplerUnits
[sampler
] != texUnit
) {
1660 program
->SamplerUnits
[sampler
] = texUnit
;
1667 /* When a sampler's value changes it usually requires rewriting
1668 * a GPU program's TEX instructions since there may not be a
1669 * sampler->texture lookup table. We signal this with the
1670 * ProgramStringNotify() callback.
1672 FLUSH_VERTICES(ctx
, _NEW_TEXTURE
| _NEW_PROGRAM
);
1673 _mesa_update_shader_textures_used(program
);
1674 ctx
->Driver
.ProgramStringNotify(ctx
, program
->Target
, program
);
1678 /* ordinary uniform variable */
1679 const GLboolean isUniformBool
= is_boolean_type(param
->DataType
);
1680 const GLboolean areIntValues
= is_integer_type(type
);
1681 const GLint slots
= (param
->Size
+ 3) / 4;
1682 const GLint typeSize
= sizeof_glsl_type(param
->DataType
);
1685 if (param
->Size
> typeSize
) {
1687 /* we'll ignore extra data below */
1690 /* non-array: count must be one */
1692 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1693 "glUniform(uniform is not an array)");
1698 /* loop over number of array elements */
1699 for (k
= 0; k
< count
; k
++) {
1700 GLfloat
*uniformVal
;
1702 if (offset
+ k
>= slots
) {
1703 /* Extra array data is ignored */
1707 /* uniformVal (the destination) is always float[4] */
1708 uniformVal
= program
->Parameters
->ParameterValues
[index
+ offset
+ k
];
1711 /* convert user's ints to floats */
1712 const GLint
*iValues
= ((const GLint
*) values
) + k
* elems
;
1713 for (i
= 0; i
< elems
; i
++) {
1714 uniformVal
[i
] = (GLfloat
) iValues
[i
];
1718 const GLfloat
*fValues
= ((const GLfloat
*) values
) + k
* elems
;
1719 for (i
= 0; i
< elems
; i
++) {
1720 uniformVal
[i
] = fValues
[i
];
1724 /* if the uniform is bool-valued, convert to 1.0 or 0.0 */
1725 if (isUniformBool
) {
1726 for (i
= 0; i
< elems
; i
++) {
1727 uniformVal
[i
] = uniformVal
[i
] ? 1.0f
: 0.0f
;
1736 * Called via ctx->Driver.Uniform().
1739 _mesa_uniform(GLcontext
*ctx
, GLint location
, GLsizei count
,
1740 const GLvoid
*values
, GLenum type
)
1742 struct gl_shader_program
*shProg
= ctx
->Shader
.CurrentProgram
;
1743 struct gl_uniform
*uniform
;
1744 GLint elems
, offset
;
1747 if (!shProg
|| !shProg
->LinkStatus
) {
1748 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUniform(program not linked)");
1753 return; /* The standard specifies this as a no-op */
1755 if (location
< -1) {
1756 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUniform(location)");
1760 split_location_offset(&location
, &offset
);
1762 if (location
< 0 || location
>= (GLint
) shProg
->Uniforms
->NumUniforms
) {
1763 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniform(location)");
1768 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniform(count < 0)");
1774 basicType
= GL_FLOAT
;
1782 basicType
= GL_FLOAT
;
1790 basicType
= GL_FLOAT
;
1798 basicType
= GL_FLOAT
;
1806 _mesa_problem(ctx
, "Invalid type in _mesa_uniform");
1810 FLUSH_VERTICES(ctx
, _NEW_PROGRAM_CONSTANTS
);
1812 uniform
= &shProg
->Uniforms
->Uniforms
[location
];
1814 if (ctx
->Shader
.Flags
& GLSL_UNIFORMS
) {
1816 _mesa_printf("Mesa: set program %u uniform %s (loc %d) to: ",
1817 shProg
->Name
, uniform
->Name
, location
);
1818 if (basicType
== GL_INT
) {
1819 const GLint
*v
= (const GLint
*) values
;
1820 for (i
= 0; i
< count
* elems
; i
++) {
1821 _mesa_printf("%d ", v
[i
]);
1825 const GLfloat
*v
= (const GLfloat
*) values
;
1826 for (i
= 0; i
< count
* elems
; i
++) {
1827 _mesa_printf("%g ", v
[i
]);
1833 /* A uniform var may be used by both a vertex shader and a fragment
1834 * shader. We may need to update one or both shader's uniform here:
1836 if (shProg
->VertexProgram
) {
1837 /* convert uniform location to program parameter index */
1838 GLint index
= uniform
->VertPos
;
1840 set_program_uniform(ctx
, &shProg
->VertexProgram
->Base
,
1841 index
, offset
, type
, count
, elems
, values
);
1845 if (shProg
->FragmentProgram
) {
1846 /* convert uniform location to program parameter index */
1847 GLint index
= uniform
->FragPos
;
1849 set_program_uniform(ctx
, &shProg
->FragmentProgram
->Base
,
1850 index
, offset
, type
, count
, elems
, values
);
1854 uniform
->Initialized
= GL_TRUE
;
1859 * Set a matrix-valued program parameter.
1862 set_program_uniform_matrix(GLcontext
*ctx
, struct gl_program
*program
,
1863 GLuint index
, GLuint offset
,
1864 GLuint count
, GLuint rows
, GLuint cols
,
1865 GLboolean transpose
, const GLfloat
*values
)
1867 GLuint mat
, row
, col
;
1868 GLuint dst
= index
+ offset
, src
= 0;
1871 /* check that the number of rows, columns is correct */
1872 get_matrix_dims(program
->Parameters
->Parameters
[index
].DataType
, &nr
, &nc
);
1873 if (rows
!= nr
|| cols
!= nc
) {
1874 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1875 "glUniformMatrix(matrix size mismatch)");
1879 if (index
+ offset
> program
->Parameters
->Size
) {
1880 /* out of bounds! */
1885 * Note: the _columns_ of a matrix are stored in program registers, not
1886 * the rows. So, the loops below look a little funny.
1887 * XXX could optimize this a bit...
1890 /* loop over matrices */
1891 for (mat
= 0; mat
< count
; mat
++) {
1894 for (col
= 0; col
< cols
; col
++) {
1895 GLfloat
*v
= program
->Parameters
->ParameterValues
[dst
];
1896 for (row
= 0; row
< rows
; row
++) {
1898 v
[row
] = values
[src
+ row
* cols
+ col
];
1901 v
[row
] = values
[src
+ col
* rows
+ row
];
1907 src
+= rows
* cols
; /* next matrix */
1913 * Called by ctx->Driver.UniformMatrix().
1914 * Note: cols=2, rows=4 ==> array[2] of vec4
1917 _mesa_uniform_matrix(GLcontext
*ctx
, GLint cols
, GLint rows
,
1918 GLint location
, GLsizei count
,
1919 GLboolean transpose
, const GLfloat
*values
)
1921 struct gl_shader_program
*shProg
= ctx
->Shader
.CurrentProgram
;
1922 struct gl_uniform
*uniform
;
1925 if (!shProg
|| !shProg
->LinkStatus
) {
1926 _mesa_error(ctx
, GL_INVALID_OPERATION
,
1927 "glUniformMatrix(program not linked)");
1932 return; /* The standard specifies this as a no-op */
1934 if (location
< -1) {
1935 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glUniformMatrix(location)");
1939 split_location_offset(&location
, &offset
);
1941 if (location
< 0 || location
>= (GLint
) shProg
->Uniforms
->NumUniforms
) {
1942 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniformMatrix(location)");
1945 if (values
== NULL
) {
1946 _mesa_error(ctx
, GL_INVALID_VALUE
, "glUniformMatrix");
1950 FLUSH_VERTICES(ctx
, _NEW_PROGRAM_CONSTANTS
);
1952 uniform
= &shProg
->Uniforms
->Uniforms
[location
];
1954 if (shProg
->VertexProgram
) {
1955 /* convert uniform location to program parameter index */
1956 GLint index
= uniform
->VertPos
;
1958 set_program_uniform_matrix(ctx
, &shProg
->VertexProgram
->Base
,
1960 count
, rows
, cols
, transpose
, values
);
1964 if (shProg
->FragmentProgram
) {
1965 /* convert uniform location to program parameter index */
1966 GLint index
= uniform
->FragPos
;
1968 set_program_uniform_matrix(ctx
, &shProg
->FragmentProgram
->Base
,
1970 count
, rows
, cols
, transpose
, values
);
1974 uniform
->Initialized
= GL_TRUE
;
1979 * Validate a program's samplers.
1980 * Specifically, check that there aren't two samplers of different types
1981 * pointing to the same texture unit.
1982 * \return GL_TRUE if valid, GL_FALSE if invalid
1985 validate_samplers(GLcontext
*ctx
, const struct gl_program
*prog
, char *errMsg
)
1987 static const char *targetName
[] = {
1996 GLint targetUsed
[MAX_TEXTURE_IMAGE_UNITS
];
1997 GLbitfield samplersUsed
= prog
->SamplersUsed
;
2000 assert(Elements(targetName
) == NUM_TEXTURE_TARGETS
);
2002 if (samplersUsed
== 0x0)
2005 for (i
= 0; i
< Elements(targetUsed
); i
++)
2008 /* walk over bits which are set in 'samplers' */
2009 while (samplersUsed
) {
2011 gl_texture_index target
;
2012 GLint sampler
= _mesa_ffs(samplersUsed
) - 1;
2013 assert(sampler
>= 0);
2014 assert(sampler
< MAX_TEXTURE_IMAGE_UNITS
);
2015 unit
= prog
->SamplerUnits
[sampler
];
2016 target
= prog
->SamplerTargets
[sampler
];
2017 if (targetUsed
[unit
] != -1 && targetUsed
[unit
] != target
) {
2018 _mesa_snprintf(errMsg
, 100,
2019 "Texture unit %d is accessed both as %s and %s",
2020 unit
, targetName
[targetUsed
[unit
]], targetName
[target
]);
2023 targetUsed
[unit
] = target
;
2024 samplersUsed
^= (1 << sampler
);
2032 * Do validation of the given shader program.
2033 * \param errMsg returns error message if validation fails.
2034 * \return GL_TRUE if valid, GL_FALSE if invalid (and set errMsg)
2037 _mesa_validate_shader_program(GLcontext
*ctx
,
2038 const struct gl_shader_program
*shProg
,
2041 const struct gl_vertex_program
*vp
= shProg
->VertexProgram
;
2042 const struct gl_fragment_program
*fp
= shProg
->FragmentProgram
;
2044 if (!shProg
->LinkStatus
) {
2048 /* From the GL spec, a program is invalid if any of these are true:
2050 any two active samplers in the current program object are of
2051 different types, but refer to the same texture image unit,
2053 any active sampler in the current program object refers to a texture
2054 image unit where fixed-function fragment processing accesses a
2055 texture target that does not match the sampler type, or
2057 the sum of the number of active samplers in the program and the
2058 number of texture image units enabled for fixed-function fragment
2059 processing exceeds the combined limit on the total number of texture
2060 image units allowed.
2065 * Check: any two active samplers in the current program object are of
2066 * different types, but refer to the same texture image unit,
2068 if (vp
&& !validate_samplers(ctx
, &vp
->Base
, errMsg
)) {
2071 if (fp
&& !validate_samplers(ctx
, &fp
->Base
, errMsg
)) {
2080 * Called via glValidateProgram()
2083 _mesa_validate_program(GLcontext
*ctx
, GLuint program
)
2085 struct gl_shader_program
*shProg
;
2088 shProg
= _mesa_lookup_shader_program_err(ctx
, program
, "glValidateProgram");
2093 shProg
->Validated
= _mesa_validate_shader_program(ctx
, shProg
, errMsg
);
2094 if (!shProg
->Validated
) {
2095 /* update info log */
2096 if (shProg
->InfoLog
) {
2097 _mesa_free(shProg
->InfoLog
);
2099 shProg
->InfoLog
= _mesa_strdup(errMsg
);
2105 * Plug in Mesa's GLSL functions into the device driver function table.
2108 _mesa_init_glsl_driver_functions(struct dd_function_table
*driver
)
2110 driver
->AttachShader
= _mesa_attach_shader
;
2111 driver
->BindAttribLocation
= _mesa_bind_attrib_location
;
2112 driver
->CompileShader
= _mesa_compile_shader
;
2113 driver
->CreateProgram
= _mesa_create_program
;
2114 driver
->CreateShader
= _mesa_create_shader
;
2115 driver
->DeleteProgram2
= _mesa_delete_program2
;
2116 driver
->DeleteShader
= _mesa_delete_shader
;
2117 driver
->DetachShader
= _mesa_detach_shader
;
2118 driver
->GetActiveAttrib
= _mesa_get_active_attrib
;
2119 driver
->GetActiveUniform
= _mesa_get_active_uniform
;
2120 driver
->GetAttachedShaders
= _mesa_get_attached_shaders
;
2121 driver
->GetAttribLocation
= _mesa_get_attrib_location
;
2122 driver
->GetHandle
= _mesa_get_handle
;
2123 driver
->GetProgramiv
= _mesa_get_programiv
;
2124 driver
->GetProgramInfoLog
= _mesa_get_program_info_log
;
2125 driver
->GetShaderiv
= _mesa_get_shaderiv
;
2126 driver
->GetShaderInfoLog
= _mesa_get_shader_info_log
;
2127 driver
->GetShaderSource
= _mesa_get_shader_source
;
2128 driver
->GetUniformfv
= _mesa_get_uniformfv
;
2129 driver
->GetUniformiv
= _mesa_get_uniformiv
;
2130 driver
->GetUniformLocation
= _mesa_get_uniform_location
;
2131 driver
->IsProgram
= _mesa_is_program
;
2132 driver
->IsShader
= _mesa_is_shader
;
2133 driver
->LinkProgram
= _mesa_link_program
;
2134 driver
->ShaderSource
= _mesa_shader_source
;
2135 driver
->Uniform
= _mesa_uniform
;
2136 driver
->UniformMatrix
= _mesa_uniform_matrix
;
2137 driver
->UseProgram
= _mesa_use_program
;
2138 driver
->ValidateProgram
= _mesa_validate_program
;