1/* 2 * Copyright (C) 2016 Miklós Máté 3 * Copyright (C) 2020 Google LLC 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be included in 13 * all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 21 * OTHER DEALINGS IN THE SOFTWARE. 22 */ 23 24#include "main/mtypes.h" 25#include "main/atifragshader.h" 26#include "main/errors.h" 27#include "program/prog_parameter.h" 28#include "program/prog_instruction.h" 29#include "program/prog_to_nir.h" 30 31#include "st_program.h" 32#include "st_atifs_to_nir.h" 33#include "compiler/nir/nir_builder.h" 34 35#define FOG_PARAMS_UNIFORM (MAX_NUM_FRAGMENT_CONSTANTS_ATI + 0) 36#define FOG_COLOR_UNIFORM (MAX_NUM_FRAGMENT_CONSTANTS_ATI + 1) 37 38/** 39 * Intermediate state used during shader translation. 40 */ 41struct st_translate { 42 nir_builder *b; 43 struct ati_fragment_shader *atifs; 44 const struct st_fp_variant_key *key; 45 46 nir_ssa_def *temps[MAX_PROGRAM_TEMPS]; 47 48 nir_variable *fragcolor; 49 nir_variable *constants; 50 nir_variable *samplers[MAX_TEXTURE_UNITS]; 51 52 nir_ssa_def *inputs[VARYING_SLOT_MAX]; 53 54 unsigned current_pass; 55 56 bool regs_written[MAX_NUM_PASSES_ATI][MAX_NUM_FRAGMENT_REGISTERS_ATI]; 57 58 boolean error; 59}; 60 61static nir_ssa_def * 62nir_channel_vec4(nir_builder *b, nir_ssa_def *src, unsigned channel) 63{ 64 unsigned swizzle[4] = { channel, channel, channel, channel }; 65 return nir_swizzle(b, src, swizzle, 4); 66} 67 68static nir_ssa_def * 69nir_imm_vec4_float(nir_builder *b, float f) 70{ 71 return nir_channel_vec4(b, nir_imm_float(b, f), 0); 72} 73 74static nir_ssa_def * 75get_temp(struct st_translate *t, unsigned index) 76{ 77 if (!t->temps[index]) 78 t->temps[index] = nir_ssa_undef(t->b, 4, 32); 79 return t->temps[index]; 80} 81 82static nir_ssa_def * 83apply_swizzle(struct st_translate *t, 84 struct nir_ssa_def *src, GLuint swizzle) 85{ 86 /* From the ATI_fs spec: 87 * 88 * "Table 3.20 shows the <swizzle> modes: 89 * 90 * Coordinates Used for 1D or Coordinates Used for 91 * Swizzle 2D SampleMap and PassTexCoord 3D or cubemap SampleMap 92 * ------- ----------------------------- ----------------------- 93 * SWIZZLE_STR_ATI (s, t, r, undefined) (s, t, r, undefined) 94 * SWIZZLE_STQ_ATI (s, t, q, undefined) (s, t, q, undefined) 95 * SWIZZLE_STR_DR_ATI (s/r, t/r, 1/r, undefined) (undefined) 96 * SWIZZLE_STQ_DQ_ATI (s/q, t/q, 1/q, undefined) (undefined) 97 */ 98 if (swizzle == GL_SWIZZLE_STR_ATI) { 99 return src; 100 } else if (swizzle == GL_SWIZZLE_STQ_ATI) { 101 static unsigned xywz[4] = { 0, 1, 3, 2 }; 102 return nir_swizzle(t->b, src, xywz, 4); 103 } else { 104 nir_ssa_def *rcp = nir_frcp(t->b, nir_channel(t->b, src, 105 swizzle == GL_SWIZZLE_STR_DR_ATI ? 2 : 3)); 106 107 nir_ssa_def *st_mul = nir_fmul(t->b, nir_channels(t->b, src, 0x3), rcp); 108 109 return nir_vec4(t->b, 110 nir_channel(t->b, st_mul, 0), 111 nir_channel(t->b, st_mul, 1), 112 rcp, 113 rcp); 114 } 115} 116 117static nir_ssa_def * 118load_input(struct st_translate *t, gl_varying_slot slot) 119{ 120 if (!t->inputs[slot]) { 121 const char *slot_name = 122 gl_varying_slot_name_for_stage(slot, MESA_SHADER_FRAGMENT); 123 nir_variable *var = nir_variable_create(t->b->shader, nir_var_shader_in, 124 slot == VARYING_SLOT_FOGC ? 125 glsl_float_type() : glsl_vec4_type(), 126 slot_name); 127 var->data.location = slot; 128 var->data.interpolation = INTERP_MODE_NONE; 129 130 t->inputs[slot] = nir_load_var(t->b, var); 131 } 132 133 return t->inputs[slot]; 134} 135 136static nir_ssa_def * 137atifs_load_uniform(struct st_translate *t, int index) 138{ 139 nir_deref_instr *deref = nir_build_deref_array(t->b, 140 nir_build_deref_var(t->b, t->constants), 141 nir_imm_int(t->b, index)); 142 return nir_load_deref(t->b, deref); 143} 144 145static struct nir_ssa_def * 146get_source(struct st_translate *t, GLenum src_type) 147{ 148 if (src_type >= GL_REG_0_ATI && src_type <= GL_REG_5_ATI) { 149 if (t->regs_written[t->current_pass][src_type - GL_REG_0_ATI]) { 150 return get_temp(t, src_type - GL_REG_0_ATI); 151 } else { 152 return nir_imm_vec4_float(t->b, 0.0); 153 } 154 } else if (src_type >= GL_CON_0_ATI && src_type <= GL_CON_7_ATI) { 155 int index = src_type - GL_CON_0_ATI; 156 if (t->atifs->LocalConstDef & (1 << index)) { 157 return nir_imm_vec4(t->b, 158 t->atifs->Constants[index][0], 159 t->atifs->Constants[index][1], 160 t->atifs->Constants[index][2], 161 t->atifs->Constants[index][3]); 162 } else { 163 return atifs_load_uniform(t, index); 164 } 165 } else if (src_type == GL_ZERO) { 166 return nir_imm_vec4_float(t->b, 0.0); 167 } else if (src_type == GL_ONE) { 168 return nir_imm_vec4_float(t->b, 1.0); 169 } else if (src_type == GL_PRIMARY_COLOR_ARB) { 170 return load_input(t, VARYING_SLOT_COL0); 171 } else if (src_type == GL_SECONDARY_INTERPOLATOR_ATI) { 172 return load_input(t, VARYING_SLOT_COL1); 173 } else { 174 /* frontend prevents this */ 175 unreachable("unknown source"); 176 } 177} 178 179static nir_ssa_def * 180prepare_argument(struct st_translate *t, const struct atifs_instruction *inst, 181 const unsigned argId, bool alpha) 182{ 183 if (argId >= inst->ArgCount[alpha]) { 184 _mesa_warning(0, "Using 0 for missing argument %d\n", argId); 185 return nir_imm_vec4_float(t->b, 0.0f); 186 } 187 188 const struct atifragshader_src_register *srcReg = &inst->SrcReg[alpha][argId]; 189 190 nir_ssa_def *src = get_source(t, srcReg->Index); 191 192 switch (srcReg->argRep) { 193 case GL_NONE: 194 break; 195 case GL_RED: 196 src = nir_channel_vec4(t->b, src, 0); 197 break; 198 case GL_GREEN: 199 src = nir_channel_vec4(t->b, src, 1); 200 break; 201 case GL_BLUE: 202 src = nir_channel_vec4(t->b, src, 2); 203 break; 204 case GL_ALPHA: 205 src = nir_channel_vec4(t->b, src, 3); 206 break; 207 } 208 209 t->temps[MAX_NUM_FRAGMENT_REGISTERS_ATI + argId] = src; 210 211 if (srcReg->argMod & GL_COMP_BIT_ATI) 212 src = nir_fsub(t->b, nir_imm_vec4_float(t->b, 1.0), src); 213 if (srcReg->argMod & GL_BIAS_BIT_ATI) 214 src = nir_fadd(t->b, src, nir_imm_vec4_float(t->b, -0.5)); 215 if (srcReg->argMod & GL_2X_BIT_ATI) 216 src = nir_fadd(t->b, src, src); 217 if (srcReg->argMod & GL_NEGATE_BIT_ATI) 218 src = nir_fneg(t->b, src); 219 220 return src; 221} 222 223static nir_ssa_def * 224emit_arith_inst(struct st_translate *t, 225 const struct atifs_instruction *inst, 226 bool alpha) 227{ 228 nir_ssa_def *src[3] = {0}; 229 for (int i = 0; i < inst->ArgCount[alpha]; i++) 230 src[i] = prepare_argument(t, inst, i, alpha); 231 232 switch (inst->Opcode[alpha]) { 233 case GL_MOV_ATI: 234 return src[0]; 235 236 case GL_ADD_ATI: 237 return nir_fadd(t->b, src[0], src[1]); 238 239 case GL_SUB_ATI: 240 return nir_fsub(t->b, src[0], src[1]); 241 242 case GL_MUL_ATI: 243 return nir_fmul(t->b, src[0], src[1]); 244 245 case GL_MAD_ATI: 246 return nir_ffma(t->b, src[0], src[1], src[2]); 247 248 case GL_LERP_ATI: 249 return nir_flrp(t->b, src[2], src[1], src[0]); 250 251 case GL_CND_ATI: 252 return nir_bcsel(t->b, 253 nir_fge(t->b, nir_imm_vec4_float(t->b, 0.5), src[2]), 254 src[1], 255 src[0]); 256 257 case GL_CND0_ATI: 258 return nir_bcsel(t->b, 259 nir_fge(t->b, src[2], nir_imm_vec4_float(t->b, 0.0)), 260 src[0], 261 src[1]); 262 263 case GL_DOT2_ADD_ATI: 264 return nir_channel_vec4(t->b, 265 nir_fadd(t->b, 266 nir_fdot2(t->b, src[0], src[1]), 267 nir_channel(t->b, src[1], 2)), 268 0); 269 270 case GL_DOT3_ATI: 271 return nir_channel_vec4(t->b, nir_fdot3(t->b,src[0], src[1]), 0); 272 273 case GL_DOT4_ATI: 274 return nir_channel_vec4(t->b, nir_fdot4(t->b,src[0], src[1]), 0); 275 276 default: 277 unreachable("Unknown ATI_fs opcode"); 278 } 279} 280 281static nir_ssa_def * 282emit_dstmod(struct st_translate *t, 283 struct nir_ssa_def *dst, GLuint dstMod) 284{ 285 switch (dstMod & ~GL_SATURATE_BIT_ATI) { 286 case GL_2X_BIT_ATI: 287 dst = nir_fmul_imm(t->b, dst, 2.0f); 288 break; 289 case GL_4X_BIT_ATI: 290 dst = nir_fmul_imm(t->b, dst, 4.0f); 291 break; 292 case GL_8X_BIT_ATI: 293 dst = nir_fmul_imm(t->b, dst, 8.0f); 294 break; 295 case GL_HALF_BIT_ATI: 296 dst = nir_fmul_imm(t->b, dst, 0.5f); 297 break; 298 case GL_QUARTER_BIT_ATI: 299 dst = nir_fmul_imm(t->b, dst, 0.25f); 300 break; 301 case GL_EIGHTH_BIT_ATI: 302 dst = nir_fmul_imm(t->b, dst, 0.125f); 303 break; 304 default: 305 break; 306 } 307 308 if (dstMod & GL_SATURATE_BIT_ATI) 309 dst = nir_fsat(t->b, dst); 310 311 return dst; 312} 313 314/** 315 * Compile one setup instruction to NIR instructions. 316 */ 317static void 318compile_setupinst(struct st_translate *t, 319 const unsigned r, 320 const struct atifs_setupinst *texinst) 321{ 322 if (!texinst->Opcode) 323 return; 324 325 GLuint pass_tex = texinst->src; 326 327 nir_ssa_def *coord; 328 329 if (pass_tex >= GL_TEXTURE0_ARB && pass_tex <= GL_TEXTURE7_ARB) { 330 unsigned attr = pass_tex - GL_TEXTURE0_ARB; 331 332 coord = load_input(t, VARYING_SLOT_TEX0 + attr); 333 } else if (pass_tex >= GL_REG_0_ATI && pass_tex <= GL_REG_5_ATI) { 334 unsigned reg = pass_tex - GL_REG_0_ATI; 335 336 /* the frontend already validated that REG is only allowed in second pass */ 337 if (t->regs_written[0][reg]) { 338 coord = t->temps[reg]; 339 } else { 340 coord = nir_imm_vec4_float(t->b, 0.0f); 341 } 342 } else { 343 coord = nir_ssa_undef(t->b, 4, 32); 344 } 345 coord = apply_swizzle(t, coord, texinst->swizzle); 346 347 if (texinst->Opcode == ATI_FRAGMENT_SHADER_SAMPLE_OP) { 348 nir_variable *tex_var = t->samplers[r]; 349 if (!tex_var) { 350 bool is_array; 351 enum glsl_sampler_dim sampler_dim = 352 _mesa_texture_index_to_sampler_dim(t->key->texture_index[r], &is_array); 353 const struct glsl_type *sampler_type = 354 glsl_sampler_type(sampler_dim, false, false, GLSL_TYPE_FLOAT); 355 356 tex_var = nir_variable_create(t->b->shader, nir_var_uniform, sampler_type, "tex"); 357 tex_var->data.binding = r; 358 tex_var->data.explicit_binding = true; 359 t->samplers[r] = tex_var; 360 } 361 nir_deref_instr *tex_deref = nir_build_deref_var(t->b, t->samplers[r]); 362 363 nir_tex_instr *tex = nir_tex_instr_create(t->b->shader, 3); 364 tex->op = nir_texop_tex; 365 tex->sampler_dim = glsl_get_sampler_dim(tex_var->type); 366 tex->dest_type = nir_type_float32; 367 tex->coord_components = 368 glsl_get_sampler_dim_coordinate_components(tex->sampler_dim); 369 370 tex->src[0].src_type = nir_tex_src_texture_deref; 371 tex->src[0].src = nir_src_for_ssa(&tex_deref->dest.ssa); 372 tex->src[1].src_type = nir_tex_src_sampler_deref; 373 tex->src[1].src = nir_src_for_ssa(&tex_deref->dest.ssa); 374 tex->src[2].src_type = nir_tex_src_coord; 375 tex->src[2].src = 376 nir_src_for_ssa(nir_channels(t->b, coord, 377 (1 << tex->coord_components) - 1)); 378 379 nir_ssa_dest_init(&tex->instr, &tex->dest, 4, 32, NULL); 380 nir_builder_instr_insert(t->b, &tex->instr); 381 382 t->temps[r] = &tex->dest.ssa; 383 } else if (texinst->Opcode == ATI_FRAGMENT_SHADER_PASS_OP) { 384 t->temps[r] = coord; 385 } 386 387 t->regs_written[t->current_pass][r] = true; 388} 389 390/** 391 * Compile one arithmetic operation COLOR&ALPHA pair into NIR instructions. 392 */ 393static void 394compile_instruction(struct st_translate *t, 395 const struct atifs_instruction *inst) 396{ 397 unsigned optype; 398 399 for (optype = 0; optype < 2; optype++) { /* color, alpha */ 400 unsigned dstreg = inst->DstReg[optype].Index - GL_REG_0_ATI; 401 402 if (!inst->Opcode[optype]) 403 continue; 404 405 /* Execute the op */ 406 nir_ssa_def *result = emit_arith_inst(t, inst, optype); 407 result = emit_dstmod(t, result, inst->DstReg[optype].dstMod); 408 409 /* Do the writemask */ 410 nir_const_value wrmask[4] = { 0 }; 411 for (int i = 0; i < 4; i++) { 412 if (inst->DstReg[optype].dstMask & (1 << i)) 413 wrmask[i].b = 1; 414 } 415 416 t->temps[dstreg] = nir_bcsel(t->b, 417 nir_build_imm(t->b, 4, 1, wrmask), 418 result, 419 get_temp(t, dstreg)); 420 t->regs_written[t->current_pass][dstreg] = true; 421 } 422} 423 424 425/* Creates the uniform variable referencing the ATI_fragment_shader constants 426 * plus the optimized fog state. 427 */ 428static void 429st_atifs_setup_uniforms(struct st_translate *t, struct gl_program *program) 430{ 431 const struct glsl_type *type = 432 glsl_array_type(glsl_vec4_type(), program->Parameters->NumParameters, 0); 433 t->constants = 434 nir_variable_create(t->b->shader, nir_var_uniform, type, 435 "gl_ATI_fragment_shader_constants"); 436} 437 438/** 439 * Called when a new variant is needed, we need to translate 440 * the ATI fragment shader to NIR 441 */ 442nir_shader * 443st_translate_atifs_program(struct ati_fragment_shader *atifs, 444 const struct st_fp_variant_key *key, 445 struct gl_program *program, 446 const nir_shader_compiler_options *options) 447{ 448 nir_builder b = nir_builder_init_simple_shader(MESA_SHADER_FRAGMENT, options, "ATI_fs"); 449 450 struct st_translate translate = { 451 .atifs = atifs, 452 .b = &b, 453 .key = key, 454 }; 455 struct st_translate *t = &translate; 456 457 /* Copy the shader_info from the gl_program */ 458 t->b->shader->info = program->info; 459 460 nir_shader *s = t->b->shader; 461 s->info.name = ralloc_asprintf(s, "ATIFS%d", program->Id); 462 463 t->fragcolor = nir_variable_create(b.shader, nir_var_shader_out, 464 glsl_vec4_type(), "gl_FragColor"); 465 t->fragcolor->data.location = FRAG_RESULT_COLOR; 466 467 st_atifs_setup_uniforms(t, program); 468 469 /* emit instructions */ 470 for (unsigned pass = 0; pass < atifs->NumPasses; pass++) { 471 t->current_pass = pass; 472 for (unsigned r = 0; r < MAX_NUM_FRAGMENT_REGISTERS_ATI; r++) { 473 struct atifs_setupinst *texinst = &atifs->SetupInst[pass][r]; 474 compile_setupinst(t, r, texinst); 475 } 476 for (unsigned i = 0; i < atifs->numArithInstr[pass]; i++) { 477 struct atifs_instruction *inst = &atifs->Instructions[pass][i]; 478 compile_instruction(t, inst); 479 } 480 } 481 482 if (t->regs_written[atifs->NumPasses-1][0]) { 483 nir_ssa_def *color = t->temps[0]; 484 485 if (key->fog) { 486 nir_ssa_def *fogc = load_input(t, VARYING_SLOT_FOGC); 487 488 nir_ssa_def *params = atifs_load_uniform(t, FOG_PARAMS_UNIFORM); 489 490 /* compute the 1 component fog factor f */ 491 nir_ssa_def *f = NULL; 492 if (key->fog == FOG_LINEAR) { 493 f = nir_ffma(t->b, fogc, 494 nir_channel(t->b, params, 0), 495 nir_channel(t->b, params, 1)); 496 } else if (key->fog == FOG_EXP) { 497 /* EXP formula: f = exp(-dens * z) 498 * with optimized parameters: 499 * f = MUL(fogcoord, oparams.z); f= EX2(-f) 500 */ 501 f = nir_fmul(t->b, fogc, nir_channel(t->b, params, 2)); 502 f = nir_fexp2(t->b, nir_fneg(t->b, f)); 503 } else if (key->fog == FOG_EXP2) { 504 /* EXP2 formula: f = exp(-(dens * z)^2) 505 * with optimized parameters: 506 * f = MUL(fogcoord, oparams.w); f=MUL(f, f); f= EX2(-f) 507 */ 508 f = nir_fmul(t->b, fogc, nir_channel(t->b, params, 3)); 509 f = nir_fmul(t->b, f, f); 510 f = nir_fexp2(t->b, nir_fneg(t->b, f)); 511 } 512 f = nir_fsat(t->b, f); 513 514 nir_ssa_def *fog_color = nir_flrp(t->b, 515 atifs_load_uniform(t, FOG_COLOR_UNIFORM), 516 color, 517 f); 518 color = nir_vec4(t->b, 519 nir_channel(t->b, fog_color, 0), 520 nir_channel(t->b, fog_color, 1), 521 nir_channel(t->b, fog_color, 2), 522 nir_channel(t->b, color, 3)); 523 } 524 525 nir_store_var(t->b, t->fragcolor, color, 0xf); 526 } 527 528 return b.shader; 529} 530 531/** 532 * Called in ProgramStringNotify, we need to fill the metadata of the 533 * gl_program attached to the ati_fragment_shader 534 */ 535void 536st_init_atifs_prog(struct gl_context *ctx, struct gl_program *prog) 537{ 538 /* we know this is st_fragment_program, because of st_new_ati_fs() */ 539 struct st_program *stfp = (struct st_program *) prog; 540 struct ati_fragment_shader *atifs = stfp->ati_fs; 541 542 unsigned pass, i, r, optype, arg; 543 544 static const gl_state_index16 fog_params_state[STATE_LENGTH] = 545 {STATE_FOG_PARAMS_OPTIMIZED, 0, 0}; 546 static const gl_state_index16 fog_color[STATE_LENGTH] = 547 {STATE_FOG_COLOR, 0, 0, 0}; 548 549 prog->info.inputs_read = 0; 550 prog->info.outputs_written = BITFIELD64_BIT(FRAG_RESULT_COLOR); 551 prog->SamplersUsed = 0; 552 prog->Parameters = _mesa_new_parameter_list(); 553 554 /* fill in inputs_read, SamplersUsed, TexturesUsed */ 555 for (pass = 0; pass < atifs->NumPasses; pass++) { 556 for (r = 0; r < MAX_NUM_FRAGMENT_REGISTERS_ATI; r++) { 557 struct atifs_setupinst *texinst = &atifs->SetupInst[pass][r]; 558 GLuint pass_tex = texinst->src; 559 560 if (texinst->Opcode == ATI_FRAGMENT_SHADER_SAMPLE_OP) { 561 /* mark which texcoords are used */ 562 prog->info.inputs_read |= BITFIELD64_BIT(VARYING_SLOT_TEX0 + pass_tex - GL_TEXTURE0_ARB); 563 /* by default there is 1:1 mapping between samplers and textures */ 564 prog->SamplersUsed |= (1 << r); 565 /* the target is unknown here, it will be fixed in the draw call */ 566 prog->TexturesUsed[r] = TEXTURE_2D_BIT; 567 } else if (texinst->Opcode == ATI_FRAGMENT_SHADER_PASS_OP) { 568 if (pass_tex >= GL_TEXTURE0_ARB && pass_tex <= GL_TEXTURE7_ARB) { 569 prog->info.inputs_read |= BITFIELD64_BIT(VARYING_SLOT_TEX0 + pass_tex - GL_TEXTURE0_ARB); 570 } 571 } 572 } 573 } 574 for (pass = 0; pass < atifs->NumPasses; pass++) { 575 for (i = 0; i < atifs->numArithInstr[pass]; i++) { 576 struct atifs_instruction *inst = &atifs->Instructions[pass][i]; 577 578 for (optype = 0; optype < 2; optype++) { /* color, alpha */ 579 if (inst->Opcode[optype]) { 580 for (arg = 0; arg < inst->ArgCount[optype]; arg++) { 581 GLint index = inst->SrcReg[optype][arg].Index; 582 if (index == GL_PRIMARY_COLOR_EXT) { 583 prog->info.inputs_read |= BITFIELD64_BIT(VARYING_SLOT_COL0); 584 } else if (index == GL_SECONDARY_INTERPOLATOR_ATI) { 585 /* note: ATI_fragment_shader.txt never specifies what 586 * GL_SECONDARY_INTERPOLATOR_ATI is, swrast uses 587 * VARYING_SLOT_COL1 for this input */ 588 prog->info.inputs_read |= BITFIELD64_BIT(VARYING_SLOT_COL1); 589 } 590 } 591 } 592 } 593 } 594 } 595 /* we may need fog */ 596 prog->info.inputs_read |= BITFIELD64_BIT(VARYING_SLOT_FOGC); 597 598 /* we always have the ATI_fs constants, and the fog params */ 599 for (i = 0; i < MAX_NUM_FRAGMENT_CONSTANTS_ATI; i++) { 600 _mesa_add_parameter(prog->Parameters, PROGRAM_UNIFORM, 601 NULL, 4, GL_FLOAT, NULL, NULL, true); 602 } 603 ASSERTED uint32_t ref; 604 ref = _mesa_add_state_reference(prog->Parameters, fog_params_state); 605 assert(ref == FOG_PARAMS_UNIFORM); 606 ref = _mesa_add_state_reference(prog->Parameters, fog_color); 607 assert(ref == FOG_COLOR_UNIFORM); 608} 609