2 * Mesa 3-D graphics library
5 * Copyright (C) 1999-2007 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.
26 * \file prog_parameter.c
27 * Program parameter lists and functions.
35 #include "prog_instruction.h"
36 #include "prog_parameter.h"
37 #include "prog_statevars.h"
40 struct gl_program_parameter_list
*
41 _mesa_new_parameter_list(void)
43 return (struct gl_program_parameter_list
*)
44 _mesa_calloc(sizeof(struct gl_program_parameter_list
));
49 * Free a parameter list and all its parameters
52 _mesa_free_parameter_list(struct gl_program_parameter_list
*paramList
)
55 for (i
= 0; i
< paramList
->NumParameters
; i
++) {
56 if (paramList
->Parameters
[i
].Name
)
57 _mesa_free((void *) paramList
->Parameters
[i
].Name
);
59 _mesa_free(paramList
->Parameters
);
60 if (paramList
->ParameterValues
)
61 _mesa_align_free(paramList
->ParameterValues
);
62 _mesa_free(paramList
);
68 * Add a new parameter to a parameter list.
69 * Note that parameter values are usually 4-element GLfloat vectors.
70 * When size > 4 we'll allocate a sequential block of parameters to
71 * store all the values (in blocks of 4).
73 * \param paramList the list to add the parameter to
74 * \param type type of parameter, such as
75 * \param name the parameter name, will be duplicated/copied!
76 * \param size number of elements in 'values' vector (1..4, or more)
77 * \param values initial parameter value, up to 4 GLfloats, or NULL
78 * \param state state indexes, or NULL
79 * \return index of new parameter in the list, or -1 if error (out of mem)
82 _mesa_add_parameter(struct gl_program_parameter_list
*paramList
,
83 enum register_file type
, const char *name
,
84 GLuint size
, const GLfloat
*values
,
85 const gl_state_index state
[STATE_LENGTH
])
87 const GLuint oldNum
= paramList
->NumParameters
;
88 const GLuint sz4
= (size
+ 3) / 4; /* no. of new param slots needed */
91 assert(size
<= 16); /* XXX anything larger than a matrix??? */
93 if (oldNum
+ sz4
> paramList
->Size
) {
94 /* Need to grow the parameter list array (alloc some extra) */
95 paramList
->Size
= paramList
->Size
+ 4 * sz4
;
98 paramList
->Parameters
= (struct gl_program_parameter
*)
99 _mesa_realloc(paramList
->Parameters
,
100 oldNum
* sizeof(struct gl_program_parameter
),
101 paramList
->Size
* sizeof(struct gl_program_parameter
));
103 paramList
->ParameterValues
= (GLfloat (*)[4])
104 _mesa_align_realloc(paramList
->ParameterValues
, /* old buf */
105 oldNum
* 4 * sizeof(GLfloat
), /* old size */
106 paramList
->Size
* 4 *sizeof(GLfloat
), /* new sz */
110 if (!paramList
->Parameters
||
111 !paramList
->ParameterValues
) {
113 paramList
->NumParameters
= 0;
120 paramList
->NumParameters
= oldNum
+ sz4
;
122 _mesa_memset(¶mList
->Parameters
[oldNum
], 0,
123 sz4
* sizeof(struct gl_program_parameter
));
125 for (i
= 0; i
< sz4
; i
++) {
126 struct gl_program_parameter
*p
= paramList
->Parameters
+ oldNum
+ i
;
127 p
->Name
= name
? _mesa_strdup(name
) : NULL
;
131 COPY_4V(paramList
->ParameterValues
[oldNum
+ i
], values
);
138 for (i
= 0; i
< STATE_LENGTH
; i
++)
139 paramList
->Parameters
[oldNum
].StateIndexes
[i
] = state
[i
];
142 return (GLint
) oldNum
;
148 * Add a new named program parameter (Ex: NV_fragment_program DEFINE statement)
149 * \return index of the new entry in the parameter list
152 _mesa_add_named_parameter(struct gl_program_parameter_list
*paramList
,
153 const char *name
, const GLfloat values
[4])
155 return _mesa_add_parameter(paramList
, PROGRAM_NAMED_PARAM
, name
,
162 * Add a new named constant to the parameter list.
163 * This will be used when the program contains something like this:
164 * PARAM myVals = { 0, 1, 2, 3 };
166 * \param paramList the parameter list
167 * \param name the name for the constant
168 * \param values four float values
169 * \return index/position of the new parameter in the parameter list
172 _mesa_add_named_constant(struct gl_program_parameter_list
*paramList
,
173 const char *name
, const GLfloat values
[4],
176 #if 0 /* disable this for now -- we need to save the name! */
179 ASSERT(size
== 4); /* XXX future feature */
180 /* check if we already have this constant */
181 if (_mesa_lookup_parameter_constant(paramList
, values
, 4, &pos
, &swizzle
)) {
185 size
= 4; /** XXX fix */
186 return _mesa_add_parameter(paramList
, PROGRAM_CONSTANT
, name
,
192 * Add a new unnamed constant to the parameter list.
193 * This will be used when the program contains something like this:
194 * MOV r, { 0, 1, 2, 3 };
196 * \param paramList the parameter list
197 * \param values four float values
198 * \param swizzleOut returns swizzle mask for accessing the constant
199 * \return index/position of the new parameter in the parameter list.
202 _mesa_add_unnamed_constant(struct gl_program_parameter_list
*paramList
,
203 const GLfloat values
[4], GLuint size
,
210 if (_mesa_lookup_parameter_constant(paramList
, values
,
211 size
, &pos
, swizzleOut
)) {
215 /* Look for empty space in an already unnamed constant parameter
216 * to add this constant. This will only work for single-element
217 * constants because we rely on smearing (i.e. .yyyy or .zzzz).
220 for (pos
= 0; pos
< (GLint
) paramList
->NumParameters
; pos
++) {
221 struct gl_program_parameter
*p
= paramList
->Parameters
+ pos
;
222 if (p
->Type
== PROGRAM_CONSTANT
&& p
->Size
+ size
<= 4) {
224 GLfloat
*pVal
= paramList
->ParameterValues
[pos
];
225 GLuint swz
= p
->Size
; /* 1, 2 or 3 for Y, Z, W */
226 pVal
[p
->Size
] = values
[0];
228 *swizzleOut
= MAKE_SWIZZLE4(swz
, swz
, swz
, swz
);
234 /* add a new parameter to store this constant */
235 pos
= _mesa_add_parameter(paramList
, PROGRAM_CONSTANT
, NULL
,
239 *swizzleOut
= MAKE_SWIZZLE4(SWIZZLE_X
, SWIZZLE_X
,
240 SWIZZLE_X
, SWIZZLE_X
);
242 *swizzleOut
= SWIZZLE_NOOP
;
249 _mesa_add_uniform(struct gl_program_parameter_list
*paramList
,
250 const char *name
, GLuint size
)
252 GLint i
= _mesa_lookup_parameter_index(paramList
, -1, name
);
253 if (i
>= 0 && paramList
->Parameters
[i
].Type
== PROGRAM_UNIFORM
) {
254 /* already in list */
258 i
= _mesa_add_parameter(paramList
, PROGRAM_UNIFORM
, name
,
267 _mesa_add_sampler(struct gl_program_parameter_list
*paramList
,
270 GLint i
= _mesa_lookup_parameter_index(paramList
, -1, name
);
271 if (i
>= 0 && paramList
->Parameters
[i
].Type
== PROGRAM_SAMPLER
) {
272 /* already in list */
276 const GLint size
= 1;
277 i
= _mesa_add_parameter(paramList
, PROGRAM_SAMPLER
, name
,
285 * Add parameter representing a varying variable.
288 _mesa_add_varying(struct gl_program_parameter_list
*paramList
,
289 const char *name
, GLuint size
)
291 GLint i
= _mesa_lookup_parameter_index(paramList
, -1, name
);
292 if (i
>= 0 && paramList
->Parameters
[i
].Type
== PROGRAM_VARYING
) {
293 /* already in list */
298 i
= _mesa_add_parameter(paramList
, PROGRAM_VARYING
, name
,
306 * Add parameter representing a vertex program attribute.
307 * \param size size of attribute (in floats), may be -1 if unknown
308 * \param attrib the attribute index, or -1 if unknown
311 _mesa_add_attribute(struct gl_program_parameter_list
*paramList
,
312 const char *name
, GLint size
, GLint attrib
)
314 GLint i
= _mesa_lookup_parameter_index(paramList
, -1, name
);
319 paramList
->Parameters
[i
].StateIndexes
[0] = attrib
;
323 gl_state_index state
[STATE_LENGTH
];
324 state
[0] = (gl_state_index
) attrib
;
327 i
= _mesa_add_parameter(paramList
, PROGRAM_INPUT
, name
,
335 #if 0 /* not used yet */
337 * Returns the number of 4-component registers needed to store a piece
338 * of GL state. For matrices this may be as many as 4 registers,
339 * everything else needs
343 sizeof_state_reference(const GLint
*stateTokens
)
345 if (stateTokens
[0] == STATE_MATRIX
) {
346 GLuint rows
= stateTokens
[4] - stateTokens
[3] + 1;
359 * Add a new state reference to the parameter list.
360 * This will be used when the program contains something like this:
361 * PARAM ambient = state.material.front.ambient;
363 * \param paramList the parameter list
364 * \param state an array of 6 (STATE_LENGTH) state tokens
365 * \return index of the new parameter.
368 _mesa_add_state_reference(struct gl_program_parameter_list
*paramList
,
369 const GLint stateTokens
[STATE_LENGTH
])
371 const GLuint size
= 4; /* XXX fix */
375 /* Check if the state reference is already in the list */
376 for (index
= 0; index
< (GLint
) paramList
->NumParameters
; index
++) {
378 for (i
= 0; i
< 6; i
++) {
379 if (paramList
->Parameters
[index
].StateIndexes
[i
] == stateTokens
[i
]) {
386 if (match
== STATE_LENGTH
) {
387 /* this state reference is already in the parameter list */
392 name
= _mesa_program_state_string(stateTokens
);
393 index
= _mesa_add_parameter(paramList
, PROGRAM_STATE_VAR
, name
,
394 size
, NULL
, (gl_state_index
*) stateTokens
);
395 paramList
->StateFlags
|= _mesa_program_state_flags(stateTokens
);
397 /* free name string here since we duplicated it in add_parameter() */
398 _mesa_free((void *) name
);
405 * Lookup a parameter value by name in the given parameter list.
406 * \return pointer to the float[4] values.
409 _mesa_lookup_parameter_value(const struct gl_program_parameter_list
*paramList
,
410 GLsizei nameLen
, const char *name
)
412 GLuint i
= _mesa_lookup_parameter_index(paramList
, nameLen
, name
);
416 return paramList
->ParameterValues
[i
];
421 * Given a program parameter name, find its position in the list of parameters.
422 * \param paramList the parameter list to search
423 * \param nameLen length of name (in chars).
424 * If length is negative, assume that name is null-terminated.
425 * \param name the name to search for
426 * \return index of parameter in the list.
429 _mesa_lookup_parameter_index(const struct gl_program_parameter_list
*paramList
,
430 GLsizei nameLen
, const char *name
)
438 /* name is null-terminated */
439 for (i
= 0; i
< (GLint
) paramList
->NumParameters
; i
++) {
440 if (paramList
->Parameters
[i
].Name
&&
441 _mesa_strcmp(paramList
->Parameters
[i
].Name
, name
) == 0)
446 /* name is not null-terminated, use nameLen */
447 for (i
= 0; i
< (GLint
) paramList
->NumParameters
; i
++) {
448 if (paramList
->Parameters
[i
].Name
&&
449 _mesa_strncmp(paramList
->Parameters
[i
].Name
, name
, nameLen
) == 0
450 && _mesa_strlen(paramList
->Parameters
[i
].Name
) == (size_t)nameLen
)
459 * Look for a float vector in the given parameter list. The float vector
460 * may be of length 1, 2, 3 or 4.
461 * \param list the parameter list to search
462 * \param v the float vector to search for
463 * \param size number of element in v
464 * \param posOut returns the position of the constant, if found
465 * \param swizzleOut returns a swizzle mask describing location of the
466 * vector elements if found
467 * \return GL_TRUE if found, GL_FALSE if not found
470 _mesa_lookup_parameter_constant(const struct gl_program_parameter_list
*list
,
471 const GLfloat v
[], GLuint vSize
,
472 GLint
*posOut
, GLuint
*swizzleOut
)
482 for (i
= 0; i
< list
->NumParameters
; i
++) {
483 if (list
->Parameters
[i
].Type
== PROGRAM_CONSTANT
) {
485 /* look for v[0] anywhere within float[4] value */
487 for (j
= 0; j
< 4; j
++) {
488 if (list
->ParameterValues
[i
][j
] == v
[0]) {
491 *swizzleOut
= MAKE_SWIZZLE4(j
, j
, j
, j
);
496 else if (vSize
<= list
->Parameters
[i
].Size
) {
497 /* see if we can match this constant (with a swizzle) */
499 GLuint match
= 0, j
, k
;
500 for (j
= 0; j
< vSize
; j
++) {
501 if (v
[j
] == list
->ParameterValues
[i
][j
]) {
506 for (k
= 0; k
< list
->Parameters
[i
].Size
; k
++) {
507 if (v
[j
] == list
->ParameterValues
[i
][k
]) {
515 if (match
== vSize
) {
517 *swizzleOut
= MAKE_SWIZZLE4(swz
[0], swz
[1], swz
[2], swz
[3]);
529 struct gl_program_parameter_list
*
530 _mesa_clone_parameter_list(const struct gl_program_parameter_list
*list
)
532 struct gl_program_parameter_list
*clone
;
535 clone
= _mesa_new_parameter_list();
539 /** Not too efficient, but correct */
540 for (i
= 0; i
< list
->NumParameters
; i
++) {
541 struct gl_program_parameter
*p
= list
->Parameters
+ i
;
542 GLuint size
= MIN2(p
->Size
, 4);
543 GLint j
= _mesa_add_parameter(clone
, p
->Type
, p
->Name
,
544 size
, list
->ParameterValues
[i
], NULL
);
546 /* copy state indexes */
547 if (p
->Type
== PROGRAM_STATE_VAR
) {
549 struct gl_program_parameter
*q
= clone
->Parameters
+ j
;
550 for (k
= 0; k
< STATE_LENGTH
; k
++) {
551 q
->StateIndexes
[k
] = p
->StateIndexes
[k
];
555 clone
->Parameters
[j
].Size
= p
->Size
;
564 * Find longest name of any parameter in list.
567 _mesa_parameter_longest_name(const struct gl_program_parameter_list
*list
)
569 GLuint i
, maxLen
= 0;
572 for (i
= 0; i
< list
->NumParameters
; i
++) {
573 GLuint len
= _mesa_strlen(list
->Parameters
[i
].Name
);