2 * Copyright 2008 Corbin Simpson <MostAwesomeDude@gmail.com>
3 * Joakim Sindholt <opensource@zhasha.com>
4 * Copyright 2009 Marek Olšák <maraeo@gmail.com>
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 * on the rights to use, copy, modify, merge, publish, distribute, sub
10 * license, and/or sell copies of the Software, and to permit persons to whom
11 * the Software is furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice (including the next
14 * paragraph) shall be included in all copies or substantial portions of the
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
21 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
22 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
23 * USE OR OTHER DEALINGS IN THE SOFTWARE. */
25 #include "util/u_format.h"
26 #include "util/u_math.h"
27 #include "util/u_memory.h"
29 #include "tgsi/tgsi_dump.h"
30 #include "tgsi/tgsi_ureg.h"
33 #include "r300_context.h"
34 #include "r300_emit.h"
35 #include "r300_screen.h"
38 #include "r300_texture.h"
39 #include "r300_tgsi_to_rc.h"
41 #include "compiler/radeon_compiler.h"
43 /* Convert info about FS input semantics to r300_shader_semantics. */
44 void r300_shader_read_fs_inputs(struct tgsi_shader_info
* info
,
45 struct r300_shader_semantics
* fs_inputs
)
50 r300_shader_semantics_reset(fs_inputs
);
52 for (i
= 0; i
< info
->num_inputs
; i
++) {
53 index
= info
->input_semantic_index
[i
];
55 switch (info
->input_semantic_name
[i
]) {
56 case TGSI_SEMANTIC_COLOR
:
57 assert(index
< ATTR_COLOR_COUNT
);
58 fs_inputs
->color
[index
] = i
;
61 case TGSI_SEMANTIC_GENERIC
:
62 assert(index
< ATTR_GENERIC_COUNT
);
63 fs_inputs
->generic
[index
] = i
;
66 case TGSI_SEMANTIC_FOG
:
71 case TGSI_SEMANTIC_POSITION
:
76 case TGSI_SEMANTIC_FACE
:
82 fprintf(stderr
, "r300: FP: Unknown input semantic: %i\n",
83 info
->input_semantic_name
[i
]);
88 static void find_output_registers(struct r300_fragment_program_compiler
* compiler
,
89 struct r300_fragment_shader_code
*shader
)
91 unsigned i
, colorbuf_count
= 0;
93 /* Mark the outputs as not present initially */
94 compiler
->OutputColor
[0] = shader
->info
.num_outputs
;
95 compiler
->OutputColor
[1] = shader
->info
.num_outputs
;
96 compiler
->OutputColor
[2] = shader
->info
.num_outputs
;
97 compiler
->OutputColor
[3] = shader
->info
.num_outputs
;
98 compiler
->OutputDepth
= shader
->info
.num_outputs
;
100 /* Now see where they really are. */
101 for(i
= 0; i
< shader
->info
.num_outputs
; ++i
) {
102 switch(shader
->info
.output_semantic_name
[i
]) {
103 case TGSI_SEMANTIC_COLOR
:
104 compiler
->OutputColor
[colorbuf_count
] = i
;
107 case TGSI_SEMANTIC_POSITION
:
108 compiler
->OutputDepth
= i
;
114 static void allocate_hardware_inputs(
115 struct r300_fragment_program_compiler
* c
,
116 void (*allocate
)(void * data
, unsigned input
, unsigned hwreg
),
119 struct r300_shader_semantics
* inputs
=
120 (struct r300_shader_semantics
*)c
->UserData
;
123 /* Allocate input registers. */
124 for (i
= 0; i
< ATTR_COLOR_COUNT
; i
++) {
125 if (inputs
->color
[i
] != ATTR_UNUSED
) {
126 allocate(mydata
, inputs
->color
[i
], reg
++);
129 if (inputs
->face
!= ATTR_UNUSED
) {
130 allocate(mydata
, inputs
->face
, reg
++);
132 for (i
= 0; i
< ATTR_GENERIC_COUNT
; i
++) {
133 if (inputs
->generic
[i
] != ATTR_UNUSED
) {
134 allocate(mydata
, inputs
->generic
[i
], reg
++);
137 if (inputs
->fog
!= ATTR_UNUSED
) {
138 allocate(mydata
, inputs
->fog
, reg
++);
140 if (inputs
->wpos
!= ATTR_UNUSED
) {
141 allocate(mydata
, inputs
->wpos
, reg
++);
145 static void get_external_state(
146 struct r300_context
* r300
,
147 struct r300_fragment_program_external_state
* state
)
149 struct r300_textures_state
*texstate
= r300
->textures_state
.state
;
150 struct r300_rs_state
*rs
= r300
->rs_state
.state
;
153 state
->frag_clamp
= rs
? rs
->rs
.clamp_fragment_color
: 0;
155 for (i
= 0; i
< texstate
->sampler_state_count
; i
++) {
156 struct r300_sampler_state
*s
= texstate
->sampler_states
[i
];
157 struct r300_sampler_view
*v
= texstate
->sampler_views
[i
];
158 struct r300_resource
*t
;
164 t
= r300_resource(v
->base
.texture
);
166 if (s
->state
.compare_mode
== PIPE_TEX_COMPARE_R_TO_TEXTURE
) {
167 state
->unit
[i
].compare_mode_enabled
= 1;
169 /* Fortunately, no need to translate this. */
170 state
->unit
[i
].texture_compare_func
= s
->state
.compare_func
;
173 state
->unit
[i
].non_normalized_coords
= !s
->state
.normalized_coords
;
174 state
->unit
[i
].convert_unorm_to_snorm
=
175 v
->base
.format
== PIPE_FORMAT_RGTC1_SNORM
||
176 v
->base
.format
== PIPE_FORMAT_LATC1_SNORM
;
178 /* Pass texture swizzling to the compiler, some lowering passes need it. */
179 if (v
->base
.format
== PIPE_FORMAT_RGTC1_SNORM
||
180 v
->base
.format
== PIPE_FORMAT_LATC1_SNORM
) {
181 unsigned char swizzle
[4];
183 util_format_compose_swizzles(
184 util_format_description(v
->base
.format
)->swizzle
,
188 state
->unit
[i
].texture_swizzle
=
189 RC_MAKE_SWIZZLE(swizzle
[0], swizzle
[1],
190 swizzle
[2], swizzle
[3]);
191 } else if (state
->unit
[i
].compare_mode_enabled
) {
192 state
->unit
[i
].texture_swizzle
=
193 RC_MAKE_SWIZZLE(v
->swizzle
[0], v
->swizzle
[1],
194 v
->swizzle
[2], v
->swizzle
[3]);
197 /* XXX this should probably take into account STR, not just S. */
198 if (t
->tex
.is_npot
) {
199 switch (s
->state
.wrap_s
) {
200 case PIPE_TEX_WRAP_REPEAT
:
201 state
->unit
[i
].wrap_mode
= RC_WRAP_REPEAT
;
204 case PIPE_TEX_WRAP_MIRROR_REPEAT
:
205 state
->unit
[i
].wrap_mode
= RC_WRAP_MIRRORED_REPEAT
;
208 case PIPE_TEX_WRAP_MIRROR_CLAMP
:
209 case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE
:
210 case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER
:
211 state
->unit
[i
].wrap_mode
= RC_WRAP_MIRRORED_CLAMP
;
215 state
->unit
[i
].wrap_mode
= RC_WRAP_NONE
;
218 if (t
->b
.b
.b
.target
== PIPE_TEXTURE_3D
)
219 state
->unit
[i
].clamp_and_scale_before_fetch
= TRUE
;
224 static void r300_translate_fragment_shader(
225 struct r300_context
* r300
,
226 struct r300_fragment_shader_code
* shader
,
227 const struct tgsi_token
*tokens
);
229 static void r300_dummy_fragment_shader(
230 struct r300_context
* r300
,
231 struct r300_fragment_shader_code
* shader
)
233 struct pipe_shader_state state
;
234 struct ureg_program
*ureg
;
238 /* Make a simple fragment shader which outputs (0, 0, 0, 1) */
239 ureg
= ureg_create(TGSI_PROCESSOR_FRAGMENT
);
240 out
= ureg_DECL_output(ureg
, TGSI_SEMANTIC_COLOR
, 0);
241 imm
= ureg_imm4f(ureg
, 0, 0, 0, 1);
243 ureg_MOV(ureg
, out
, imm
);
246 state
.tokens
= ureg_finalize(ureg
);
248 shader
->dummy
= TRUE
;
249 r300_translate_fragment_shader(r300
, shader
, state
.tokens
);
254 static void r300_emit_fs_code_to_buffer(
255 struct r300_context
*r300
,
256 struct r300_fragment_shader_code
*shader
)
258 struct rX00_fragment_program_code
*generic_code
= &shader
->code
;
259 unsigned imm_count
= shader
->immediates_count
;
260 unsigned imm_first
= shader
->externals_count
;
261 unsigned imm_end
= generic_code
->constants
.Count
;
262 struct rc_constant
*constants
= generic_code
->constants
.Constants
;
266 if (r300
->screen
->caps
.is_r500
) {
267 struct r500_fragment_program_code
*code
= &generic_code
->code
.r500
;
269 shader
->cb_code_size
= 19 +
270 ((code
->inst_end
+ 1) * 6) +
272 code
->int_constant_count
* 2;
274 NEW_CB(shader
->cb_code
, shader
->cb_code_size
);
275 OUT_CB_REG(R500_US_CONFIG
, R500_ZERO_TIMES_ANYTHING_EQUALS_ZERO
);
276 OUT_CB_REG(R500_US_PIXSIZE
, code
->max_temp_idx
);
277 OUT_CB_REG(R500_US_FC_CTRL
, code
->us_fc_ctrl
);
278 for(i
= 0; i
< code
->int_constant_count
; i
++){
279 OUT_CB_REG(R500_US_FC_INT_CONST_0
+ (i
* 4),
280 code
->int_constants
[i
]);
282 OUT_CB_REG(R500_US_CODE_RANGE
,
283 R500_US_CODE_RANGE_ADDR(0) | R500_US_CODE_RANGE_SIZE(code
->inst_end
));
284 OUT_CB_REG(R500_US_CODE_OFFSET
, 0);
285 OUT_CB_REG(R500_US_CODE_ADDR
,
286 R500_US_CODE_START_ADDR(0) | R500_US_CODE_END_ADDR(code
->inst_end
));
288 OUT_CB_REG(R500_GA_US_VECTOR_INDEX
, R500_GA_US_VECTOR_INDEX_TYPE_INSTR
);
289 OUT_CB_ONE_REG(R500_GA_US_VECTOR_DATA
, (code
->inst_end
+ 1) * 6);
290 for (i
= 0; i
<= code
->inst_end
; i
++) {
291 OUT_CB(code
->inst
[i
].inst0
);
292 OUT_CB(code
->inst
[i
].inst1
);
293 OUT_CB(code
->inst
[i
].inst2
);
294 OUT_CB(code
->inst
[i
].inst3
);
295 OUT_CB(code
->inst
[i
].inst4
);
296 OUT_CB(code
->inst
[i
].inst5
);
299 /* Emit immediates. */
301 for(i
= imm_first
; i
< imm_end
; ++i
) {
302 if (constants
[i
].Type
== RC_CONSTANT_IMMEDIATE
) {
303 const float *data
= constants
[i
].u
.Immediate
;
305 OUT_CB_REG(R500_GA_US_VECTOR_INDEX
,
306 R500_GA_US_VECTOR_INDEX_TYPE_CONST
|
307 (i
& R500_GA_US_VECTOR_INDEX_MASK
));
308 OUT_CB_ONE_REG(R500_GA_US_VECTOR_DATA
, 4);
309 OUT_CB_TABLE(data
, 4);
314 struct r300_fragment_program_code
*code
= &generic_code
->code
.r300
;
315 unsigned int alu_length
= code
->alu
.length
;
316 unsigned int alu_iterations
= ((alu_length
- 1) / 64) + 1;
317 unsigned int tex_length
= code
->tex
.length
;
318 unsigned int tex_iterations
=
319 tex_length
> 0 ? ((tex_length
- 1) / 32) + 1 : 0;
320 unsigned int iterations
=
321 alu_iterations
> tex_iterations
? alu_iterations
: tex_iterations
;
322 unsigned int bank
= 0;
324 shader
->cb_code_size
= 15 +
325 /* R400_US_CODE_BANK */
326 (r300
->screen
->caps
.is_r400
? 2 * (iterations
+ 1): 0) +
327 /* R400_US_CODE_EXT */
328 (r300
->screen
->caps
.is_r400
? 2 : 0) +
329 /* R300_US_ALU_{RGB,ALPHA}_{INST,ADDR}_0, R400_US_ALU_EXT_ADDR_0 */
330 (code
->r390_mode
? (5 * alu_iterations
) : 4) +
331 /* R400_US_ALU_EXT_ADDR_[0-63] */
332 (code
->r390_mode
? (code
->alu
.length
) : 0) +
333 /* R300_US_ALU_{RGB,ALPHA}_{INST,ADDR}_0 */
334 code
->alu
.length
* 4 +
335 /* R300_US_TEX_INST_0, R300_US_TEX_INST_[0-31] */
336 (code
->tex
.length
> 0 ? code
->tex
.length
+ tex_iterations
: 0) +
339 NEW_CB(shader
->cb_code
, shader
->cb_code_size
);
341 OUT_CB_REG(R300_US_CONFIG
, code
->config
);
342 OUT_CB_REG(R300_US_PIXSIZE
, code
->pixsize
);
343 OUT_CB_REG(R300_US_CODE_OFFSET
, code
->code_offset
);
345 if (code
->r390_mode
) {
346 OUT_CB_REG(R400_US_CODE_EXT
, code
->r400_code_offset_ext
);
347 } else if (r300
->screen
->caps
.is_r400
) {
348 /* This register appears to affect shaders even if r390_mode is
349 * disabled, so it needs to be set to 0 for shaders that
350 * don't use r390_mode. */
351 OUT_CB_REG(R400_US_CODE_EXT
, 0);
354 OUT_CB_REG_SEQ(R300_US_CODE_ADDR_0
, 4);
355 OUT_CB_TABLE(code
->code_addr
, 4);
358 unsigned int bank_alu_length
= (alu_length
< 64 ? alu_length
: 64);
359 unsigned int bank_alu_offset
= bank
* 64;
360 unsigned int bank_tex_length
= (tex_length
< 32 ? tex_length
: 32);
361 unsigned int bank_tex_offset
= bank
* 32;
363 if (r300
->screen
->caps
.is_r400
) {
364 OUT_CB_REG(R400_US_CODE_BANK
, code
->r390_mode
?
365 (bank
<< R400_BANK_SHIFT
) | R400_R390_MODE_ENABLE
: 0);//2
368 if (bank_alu_length
> 0) {
369 OUT_CB_REG_SEQ(R300_US_ALU_RGB_INST_0
, bank_alu_length
);
370 for (i
= 0; i
< bank_alu_length
; i
++)
371 OUT_CB(code
->alu
.inst
[i
+ bank_alu_offset
].rgb_inst
);
373 OUT_CB_REG_SEQ(R300_US_ALU_RGB_ADDR_0
, bank_alu_length
);
374 for (i
= 0; i
< bank_alu_length
; i
++)
375 OUT_CB(code
->alu
.inst
[i
+ bank_alu_offset
].rgb_addr
);
377 OUT_CB_REG_SEQ(R300_US_ALU_ALPHA_INST_0
, bank_alu_length
);
378 for (i
= 0; i
< bank_alu_length
; i
++)
379 OUT_CB(code
->alu
.inst
[i
+ bank_alu_offset
].alpha_inst
);
381 OUT_CB_REG_SEQ(R300_US_ALU_ALPHA_ADDR_0
, bank_alu_length
);
382 for (i
= 0; i
< bank_alu_length
; i
++)
383 OUT_CB(code
->alu
.inst
[i
+ bank_alu_offset
].alpha_addr
);
385 if (code
->r390_mode
) {
386 OUT_CB_REG_SEQ(R400_US_ALU_EXT_ADDR_0
, bank_alu_length
);
387 for (i
= 0; i
< bank_alu_length
; i
++)
388 OUT_CB(code
->alu
.inst
[i
+ bank_alu_offset
].r400_ext_addr
);
392 if (bank_tex_length
> 0) {
393 OUT_CB_REG_SEQ(R300_US_TEX_INST_0
, bank_tex_length
);
394 OUT_CB_TABLE(code
->tex
.inst
+ bank_tex_offset
, bank_tex_length
);
397 alu_length
-= bank_alu_length
;
398 tex_length
-= bank_tex_length
;
400 } while(code
->r390_mode
&& (alu_length
> 0 || tex_length
> 0));
402 /* R400_US_CODE_BANK needs to be reset to 0, otherwise some shaders
403 * will be rendered incorrectly. */
404 if (r300
->screen
->caps
.is_r400
) {
405 OUT_CB_REG(R400_US_CODE_BANK
,
406 code
->r390_mode
? R400_R390_MODE_ENABLE
: 0);
409 /* Emit immediates. */
411 for(i
= imm_first
; i
< imm_end
; ++i
) {
412 if (constants
[i
].Type
== RC_CONSTANT_IMMEDIATE
) {
413 const float *data
= constants
[i
].u
.Immediate
;
415 OUT_CB_REG_SEQ(R300_PFS_PARAM_0_X
+ i
* 16, 4);
416 OUT_CB(pack_float24(data
[0]));
417 OUT_CB(pack_float24(data
[1]));
418 OUT_CB(pack_float24(data
[2]));
419 OUT_CB(pack_float24(data
[3]));
425 OUT_CB_REG(R300_FG_DEPTH_SRC
, shader
->fg_depth_src
);
426 OUT_CB_REG(R300_US_W_FMT
, shader
->us_out_w
);
430 static void r300_translate_fragment_shader(
431 struct r300_context
* r300
,
432 struct r300_fragment_shader_code
* shader
,
433 const struct tgsi_token
*tokens
)
435 struct r300_fragment_program_compiler compiler
;
436 struct tgsi_to_rc ttr
;
440 tgsi_scan_shader(tokens
, &shader
->info
);
441 r300_shader_read_fs_inputs(&shader
->info
, &shader
->inputs
);
443 wpos
= shader
->inputs
.wpos
;
444 face
= shader
->inputs
.face
;
446 /* Setup the compiler. */
447 memset(&compiler
, 0, sizeof(compiler
));
448 rc_init(&compiler
.Base
);
449 DBG_ON(r300
, DBG_FP
) ? compiler
.Base
.Debug
|= RC_DBG_LOG
: 0;
450 DBG_ON(r300
, DBG_P_STAT
) ? compiler
.Base
.Debug
|= RC_DBG_STATS
: 0;
452 compiler
.code
= &shader
->code
;
453 compiler
.state
= shader
->compare_state
;
454 compiler
.Base
.is_r500
= r300
->screen
->caps
.is_r500
;
455 compiler
.Base
.is_r400
= r300
->screen
->caps
.is_r400
;
456 compiler
.Base
.disable_optimizations
= DBG_ON(r300
, DBG_NO_OPT
);
457 compiler
.Base
.has_half_swizzles
= TRUE
;
458 compiler
.Base
.has_presub
= TRUE
;
459 compiler
.Base
.has_omod
= TRUE
;
460 compiler
.Base
.max_temp_regs
=
461 compiler
.Base
.is_r500
? 128 : (compiler
.Base
.is_r400
? 64 : 32);
462 compiler
.Base
.max_constants
= compiler
.Base
.is_r500
? 256 : 32;
463 compiler
.Base
.max_alu_insts
=
464 (compiler
.Base
.is_r500
|| compiler
.Base
.is_r400
) ? 512 : 64;
465 compiler
.Base
.max_tex_insts
=
466 (compiler
.Base
.is_r500
|| compiler
.Base
.is_r400
) ? 512 : 32;
467 compiler
.AllocateHwInputs
= &allocate_hardware_inputs
;
468 compiler
.UserData
= &shader
->inputs
;
470 find_output_registers(&compiler
, shader
);
472 shader
->write_all
= FALSE
;
473 for (i
= 0; i
< shader
->info
.num_properties
; i
++) {
474 if (shader
->info
.properties
[i
].name
== TGSI_PROPERTY_FS_COLOR0_WRITES_ALL_CBUFS
) {
475 shader
->write_all
= TRUE
;
479 if (compiler
.Base
.Debug
& RC_DBG_LOG
) {
480 DBG(r300
, DBG_FP
, "r300: Initial fragment program\n");
481 tgsi_dump(tokens
, 0);
484 /* Translate TGSI to our internal representation */
485 ttr
.compiler
= &compiler
.Base
;
486 ttr
.info
= &shader
->info
;
487 ttr
.use_half_swizzles
= TRUE
;
489 r300_tgsi_to_rc(&ttr
, tokens
);
492 fprintf(stderr
, "r300 FP: Cannot translate a shader. "
493 "Using a dummy shader instead.\n");
494 r300_dummy_fragment_shader(r300
, shader
);
498 if (!r300
->screen
->caps
.is_r500
||
499 compiler
.Base
.Program
.Constants
.Count
> 200) {
500 compiler
.Base
.remove_unused_constants
= TRUE
;
504 * Transform the program to support WPOS.
506 * Introduce a small fragment at the start of the program that will be
507 * the only code that directly reads the WPOS input.
508 * All other code pieces that reference that input will be rewritten
509 * to read from a newly allocated temporary. */
510 if (wpos
!= ATTR_UNUSED
) {
511 /* Moving the input to some other reg is not really necessary. */
512 rc_transform_fragment_wpos(&compiler
.Base
, wpos
, wpos
, TRUE
);
515 if (face
!= ATTR_UNUSED
) {
516 rc_transform_fragment_face(&compiler
.Base
, face
);
519 /* Invoke the compiler */
520 r3xx_compile_fragment_program(&compiler
);
522 if (compiler
.Base
.Error
) {
523 fprintf(stderr
, "r300 FP: Compiler Error:\n%sUsing a dummy shader"
524 " instead.\n", compiler
.Base
.ErrorMsg
);
527 fprintf(stderr
, "r300 FP: Cannot compile the dummy shader! "
532 rc_destroy(&compiler
.Base
);
533 r300_dummy_fragment_shader(r300
, shader
);
537 /* Shaders with zero instructions are invalid,
538 * use the dummy shader instead. */
539 if (shader
->code
.code
.r500
.inst_end
== -1) {
540 rc_destroy(&compiler
.Base
);
541 r300_dummy_fragment_shader(r300
, shader
);
545 /* Initialize numbers of constants for each type. */
546 shader
->externals_count
= 0;
548 i
< shader
->code
.constants
.Count
&&
549 shader
->code
.constants
.Constants
[i
].Type
== RC_CONSTANT_EXTERNAL
; i
++) {
550 shader
->externals_count
= i
+1;
552 shader
->immediates_count
= 0;
553 shader
->rc_state_count
= 0;
555 for (i
= shader
->externals_count
; i
< shader
->code
.constants
.Count
; i
++) {
556 switch (shader
->code
.constants
.Constants
[i
].Type
) {
557 case RC_CONSTANT_IMMEDIATE
:
558 ++shader
->immediates_count
;
560 case RC_CONSTANT_STATE
:
561 ++shader
->rc_state_count
;
568 /* Setup shader depth output. */
569 if (shader
->code
.writes_depth
) {
570 shader
->fg_depth_src
= R300_FG_DEPTH_SRC_SHADER
;
571 shader
->us_out_w
= R300_W_FMT_W24
| R300_W_SRC_US
;
573 shader
->fg_depth_src
= R300_FG_DEPTH_SRC_SCAN
;
574 shader
->us_out_w
= R300_W_FMT_W0
| R300_W_SRC_US
;
577 /* And, finally... */
578 rc_destroy(&compiler
.Base
);
580 /* Build the command buffer. */
581 r300_emit_fs_code_to_buffer(r300
, shader
);
584 boolean
r300_pick_fragment_shader(struct r300_context
* r300
)
586 struct r300_fragment_shader
* fs
= r300_fs(r300
);
587 struct r300_fragment_program_external_state state
= {{{ 0 }}};
588 struct r300_fragment_shader_code
* ptr
;
590 get_external_state(r300
, &state
);
593 /* Build the fragment shader for the first time. */
594 fs
->first
= fs
->shader
= CALLOC_STRUCT(r300_fragment_shader_code
);
596 memcpy(&fs
->shader
->compare_state
, &state
,
597 sizeof(struct r300_fragment_program_external_state
));
598 r300_translate_fragment_shader(r300
, fs
->shader
, fs
->state
.tokens
);
602 /* Check if the currently-bound shader has been compiled
603 * with the texture-compare state we need. */
604 if (memcmp(&fs
->shader
->compare_state
, &state
, sizeof(state
)) != 0) {
605 /* Search for the right shader. */
608 if (memcmp(&ptr
->compare_state
, &state
, sizeof(state
)) == 0) {
609 if (fs
->shader
!= ptr
) {
613 /* The currently-bound one is OK. */
619 /* Not found, gotta compile a new one. */
620 ptr
= CALLOC_STRUCT(r300_fragment_shader_code
);
621 ptr
->next
= fs
->first
;
622 fs
->first
= fs
->shader
= ptr
;
624 ptr
->compare_state
= state
;
625 r300_translate_fragment_shader(r300
, ptr
, fs
->state
.tokens
);