1 /* 2 * Mesa 3-D graphics library 3 * 4 * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included 14 * in all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 17 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 20 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 21 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 22 * OTHER DEALINGS IN THE SOFTWARE. 23 */ 24 25 /** 26 * \file prog_parameter.c 27 * Program parameter lists and functions. 28 * \author Brian Paul 29 */ 30 31 32 #include "main/glheader.h" 33 #include "main/imports.h" 34 #include "main/macros.h" 35 #include "prog_instruction.h" 36 #include "prog_parameter.h" 37 #include "prog_statevars.h" 38 39 40 /** 41 * Look for a float vector in the given parameter list. The float vector 42 * may be of length 1, 2, 3 or 4. If swizzleOut is non-null, we'll try 43 * swizzling to find a match. 44 * \param list the parameter list to search 45 * \param v the float vector to search for 46 * \param vSize number of element in v 47 * \param posOut returns the position of the constant, if found 48 * \param swizzleOut returns a swizzle mask describing location of the 49 * vector elements if found. 50 * \return GL_TRUE if found, GL_FALSE if not found 51 */ 52 static GLboolean 53 lookup_parameter_constant(const struct gl_program_parameter_list *list, 54 const gl_constant_value v[], GLuint vSize, 55 GLint *posOut, GLuint *swizzleOut) 56 { 57 GLuint i; 58 59 assert(vSize >= 1); 60 assert(vSize <= 4); 61 62 if (!list) { 63 *posOut = -1; 64 return GL_FALSE; 65 } 66 67 for (i = 0; i < list->NumParameters; i++) { 68 if (list->Parameters[i].Type == PROGRAM_CONSTANT) { 69 if (!swizzleOut) { 70 /* swizzle not allowed */ 71 GLuint j, match = 0; 72 for (j = 0; j < vSize; j++) { 73 if (v[j].u == list->ParameterValues[i][j].u) 74 match++; 75 } 76 if (match == vSize) { 77 *posOut = i; 78 return GL_TRUE; 79 } 80 } 81 else { 82 /* try matching w/ swizzle */ 83 if (vSize == 1) { 84 /* look for v[0] anywhere within float[4] value */ 85 GLuint j; 86 for (j = 0; j < list->Parameters[i].Size; j++) { 87 if (list->ParameterValues[i][j].u == v[0].u) { 88 /* found it */ 89 *posOut = i; 90 *swizzleOut = MAKE_SWIZZLE4(j, j, j, j); 91 return GL_TRUE; 92 } 93 } 94 } 95 else if (vSize <= list->Parameters[i].Size) { 96 /* see if we can match this constant (with a swizzle) */ 97 GLuint swz[4]; 98 GLuint match = 0, j, k; 99 for (j = 0; j < vSize; j++) { 100 if (v[j].u == list->ParameterValues[i][j].u) { 101 swz[j] = j; 102 match++; 103 } 104 else { 105 for (k = 0; k < list->Parameters[i].Size; k++) { 106 if (v[j].u == list->ParameterValues[i][k].u) { 107 swz[j] = k; 108 match++; 109 break; 110 } 111 } 112 } 113 } 114 /* smear last value to remaining positions */ 115 for (; j < 4; j++) 116 swz[j] = swz[j-1]; 117 118 if (match == vSize) { 119 *posOut = i; 120 *swizzleOut = MAKE_SWIZZLE4(swz[0], swz[1], swz[2], swz[3]); 121 return GL_TRUE; 122 } 123 } 124 } 125 } 126 } 127 128 *posOut = -1; 129 return GL_FALSE; 130 } 131 132 133 struct gl_program_parameter_list * 134 _mesa_new_parameter_list(void) 135 { 136 return CALLOC_STRUCT(gl_program_parameter_list); 137 } 138 139 140 struct gl_program_parameter_list * 141 _mesa_new_parameter_list_sized(unsigned size) 142 { 143 struct gl_program_parameter_list *p = _mesa_new_parameter_list(); 144 145 if ((p != NULL) && (size != 0)) { 146 p->Size = size; 147 148 /* alloc arrays */ 149 p->Parameters = (struct gl_program_parameter *) 150 calloc(size, sizeof(struct gl_program_parameter)); 151 152 p->ParameterValues = (gl_constant_value (*)[4]) 153 _mesa_align_malloc(size * 4 *sizeof(gl_constant_value), 16); 154 155 156 if ((p->Parameters == NULL) || (p->ParameterValues == NULL)) { 157 free(p->Parameters); 158 _mesa_align_free(p->ParameterValues); 159 free(p); 160 p = NULL; 161 } 162 } 163 164 return p; 165 } 166 167 168 /** 169 * Free a parameter list and all its parameters 170 */ 171 void 172 _mesa_free_parameter_list(struct gl_program_parameter_list *paramList) 173 { 174 GLuint i; 175 for (i = 0; i < paramList->NumParameters; i++) { 176 free((void *)paramList->Parameters[i].Name); 177 } 178 free(paramList->Parameters); 179 _mesa_align_free(paramList->ParameterValues); 180 free(paramList); 181 } 182 183 184 /** 185 * Make sure there are enough unused parameter slots. Reallocate the list 186 * if needed. 187 * 188 * \param paramList where to reserve parameter slots 189 * \param reserve_slots number of slots to reserve 190 */ 191 void 192 _mesa_reserve_parameter_storage(struct gl_program_parameter_list *paramList, 193 unsigned reserve_slots) 194 { 195 const GLuint oldNum = paramList->NumParameters; 196 197 if (oldNum + reserve_slots > paramList->Size) { 198 /* Need to grow the parameter list array (alloc some extra) */ 199 paramList->Size = paramList->Size + 4 * reserve_slots; 200 201 /* realloc arrays */ 202 paramList->Parameters = 203 realloc(paramList->Parameters, 204 paramList->Size * sizeof(struct gl_program_parameter)); 205 206 paramList->ParameterValues = (gl_constant_value (*)[4]) 207 _mesa_align_realloc(paramList->ParameterValues, /* old buf */ 208 oldNum * 4 * sizeof(gl_constant_value),/* old sz */ 209 paramList->Size*4*sizeof(gl_constant_value),/*new*/ 210 16); 211 } 212 } 213 214 215 /** 216 * Add a new parameter to a parameter list. 217 * Note that parameter values are usually 4-element GLfloat vectors. 218 * When size > 4 we'll allocate a sequential block of parameters to 219 * store all the values (in blocks of 4). 220 * 221 * \param paramList the list to add the parameter to 222 * \param type type of parameter, such as 223 * \param name the parameter name, will be duplicated/copied! 224 * \param size number of elements in 'values' vector (1..4, or more) 225 * \param datatype GL_FLOAT, GL_FLOAT_VECx, GL_INT, GL_INT_VECx or GL_NONE. 226 * \param values initial parameter value, up to 4 gl_constant_values, or NULL 227 * \param state state indexes, or NULL 228 * \return index of new parameter in the list, or -1 if error (out of mem) 229 */ 230 GLint 231 _mesa_add_parameter(struct gl_program_parameter_list *paramList, 232 gl_register_file type, const char *name, 233 GLuint size, GLenum datatype, 234 const gl_constant_value *values, 235 const gl_state_index state[STATE_LENGTH]) 236 { 237 assert(0 < size && size <=4); 238 const GLuint oldNum = paramList->NumParameters; 239 240 _mesa_reserve_parameter_storage(paramList, 1); 241 242 if (!paramList->Parameters || 243 !paramList->ParameterValues) { 244 /* out of memory */ 245 paramList->NumParameters = 0; 246 paramList->Size = 0; 247 return -1; 248 } 249 250 paramList->NumParameters = oldNum + 1; 251 252 memset(¶mList->Parameters[oldNum], 0, 253 sizeof(struct gl_program_parameter)); 254 255 struct gl_program_parameter *p = paramList->Parameters + oldNum; 256 p->Name = strdup(name ? name : ""); 257 p->Type = type; 258 p->Size = size; 259 p->DataType = datatype; 260 261 if (values) { 262 if (size >= 4) { 263 COPY_4V(paramList->ParameterValues[oldNum], values); 264 } else { 265 /* copy 1, 2 or 3 values */ 266 assert(size < 4); 267 for (unsigned j = 0; j < size; j++) { 268 paramList->ParameterValues[oldNum][j].f = values[j].f; 269 } 270 } 271 } else { 272 for (unsigned j = 0; j < 4; j++) { 273 paramList->ParameterValues[oldNum][j].f = 0; 274 } 275 } 276 277 if (state) { 278 for (unsigned i = 0; i < STATE_LENGTH; i++) 279 paramList->Parameters[oldNum].StateIndexes[i] = state[i]; 280 } 281 282 return (GLint) oldNum; 283 } 284 285 286 /** 287 * Add a new unnamed constant to the parameter list. This will be used 288 * when a fragment/vertex program contains something like this: 289 * MOV r, { 0, 1, 2, 3 }; 290 * If swizzleOut is non-null we'll search the parameter list for an 291 * existing instance of the constant which matches with a swizzle. 292 * 293 * \param paramList the parameter list 294 * \param values four float values 295 * \param swizzleOut returns swizzle mask for accessing the constant 296 * \return index/position of the new parameter in the parameter list. 297 */ 298 GLint 299 _mesa_add_typed_unnamed_constant(struct gl_program_parameter_list *paramList, 300 const gl_constant_value values[4], GLuint size, 301 GLenum datatype, GLuint *swizzleOut) 302 { 303 GLint pos; 304 assert(size >= 1); 305 assert(size <= 4); 306 307 if (swizzleOut && 308 lookup_parameter_constant(paramList, values, size, &pos, swizzleOut)) { 309 return pos; 310 } 311 312 /* Look for empty space in an already unnamed constant parameter 313 * to add this constant. This will only work for single-element 314 * constants because we rely on smearing (i.e. .yyyy or .zzzz). 315 */ 316 if (size == 1 && swizzleOut) { 317 for (pos = 0; pos < (GLint) paramList->NumParameters; pos++) { 318 struct gl_program_parameter *p = paramList->Parameters + pos; 319 if (p->Type == PROGRAM_CONSTANT && p->Size + size <= 4) { 320 /* ok, found room */ 321 gl_constant_value *pVal = paramList->ParameterValues[pos]; 322 GLuint swz = p->Size; /* 1, 2 or 3 for Y, Z, W */ 323 pVal[p->Size] = values[0]; 324 p->Size++; 325 *swizzleOut = MAKE_SWIZZLE4(swz, swz, swz, swz); 326 return pos; 327 } 328 } 329 } 330 331 /* add a new parameter to store this constant */ 332 pos = _mesa_add_parameter(paramList, PROGRAM_CONSTANT, NULL, 333 size, datatype, values, NULL); 334 if (pos >= 0 && swizzleOut) { 335 if (size == 1) 336 *swizzleOut = SWIZZLE_XXXX; 337 else 338 *swizzleOut = SWIZZLE_NOOP; 339 } 340 return pos; 341 } 342 343 344 /** 345 * Add a new state reference to the parameter list. 346 * This will be used when the program contains something like this: 347 * PARAM ambient = state.material.front.ambient; 348 * 349 * \param paramList the parameter list 350 * \param stateTokens an array of 5 (STATE_LENGTH) state tokens 351 * \return index of the new parameter. 352 */ 353 GLint 354 _mesa_add_state_reference(struct gl_program_parameter_list *paramList, 355 const gl_state_index stateTokens[STATE_LENGTH]) 356 { 357 const GLuint size = 4; /* XXX fix */ 358 char *name; 359 GLint index; 360 361 /* Check if the state reference is already in the list */ 362 for (index = 0; index < (GLint) paramList->NumParameters; index++) { 363 if (!memcmp(paramList->Parameters[index].StateIndexes, 364 stateTokens, STATE_LENGTH * sizeof(gl_state_index))) { 365 return index; 366 } 367 } 368 369 name = _mesa_program_state_string(stateTokens); 370 index = _mesa_add_parameter(paramList, PROGRAM_STATE_VAR, name, 371 size, GL_NONE, 372 NULL, (gl_state_index *) stateTokens); 373 paramList->StateFlags |= _mesa_program_state_flags(stateTokens); 374 375 /* free name string here since we duplicated it in add_parameter() */ 376 free(name); 377 378 return index; 379 } 380