X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fr300%2Fr300_fs.c;h=4d61f6385301d53b8793e548509a72f31c912a97;hb=9f2f6096a80c0c20b27d3fd59cf07839f4ddff55;hp=79b01bb4dc26ce97534c915f9dc015647b4ea792;hpb=eaa3a025da18a0b7f25460f86bb4afcd08017dfe;p=mesa.git diff --git a/src/gallium/drivers/r300/r300_fs.c b/src/gallium/drivers/r300/r300_fs.c index 79b01bb4dc2..4d61f638530 100644 --- a/src/gallium/drivers/r300/r300_fs.c +++ b/src/gallium/drivers/r300/r300_fs.c @@ -22,19 +22,24 @@ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE * USE OR OTHER DEALINGS IN THE SOFTWARE. */ +#include "util/u_math.h" +#include "util/u_memory.h" + #include "tgsi/tgsi_dump.h" +#include "tgsi/tgsi_ureg.h" #include "r300_context.h" #include "r300_screen.h" #include "r300_fs.h" +#include "r300_reg.h" #include "r300_tgsi_to_rc.h" #include "radeon_code.h" #include "radeon_compiler.h" /* Convert info about FS input semantics to r300_shader_semantics. */ -static void r300_shader_read_fs_inputs(struct tgsi_shader_info* info, - struct r300_shader_semantics* fs_inputs) +void r300_shader_read_fs_inputs(struct tgsi_shader_info* info, + struct r300_shader_semantics* fs_inputs) { int i; unsigned index; @@ -46,12 +51,12 @@ static void r300_shader_read_fs_inputs(struct tgsi_shader_info* info, switch (info->input_semantic_name[i]) { case TGSI_SEMANTIC_COLOR: - assert(index <= ATTR_COLOR_COUNT); + assert(index < ATTR_COLOR_COUNT); fs_inputs->color[index] = i; break; case TGSI_SEMANTIC_GENERIC: - assert(index <= ATTR_GENERIC_COUNT); + assert(index < ATTR_GENERIC_COUNT); fs_inputs->generic[index] = i; break; @@ -60,27 +65,36 @@ static void r300_shader_read_fs_inputs(struct tgsi_shader_info* info, fs_inputs->fog = i; break; + case TGSI_SEMANTIC_POSITION: + assert(index == 0); + fs_inputs->wpos = i; + break; + default: - assert(0); + fprintf(stderr, "r300: FP: Unknown input semantic: %i\n", + info->input_semantic_name[i]); } } } - static void find_output_registers(struct r300_fragment_program_compiler * compiler, - struct r300_fragment_shader * fs) + struct r300_fragment_shader_code *shader) { - unsigned i; + unsigned i, colorbuf_count = 0; /* Mark the outputs as not present initially */ - compiler->OutputColor = fs->info.num_outputs; - compiler->OutputDepth = fs->info.num_outputs; + compiler->OutputColor[0] = shader->info.num_outputs; + compiler->OutputColor[1] = shader->info.num_outputs; + compiler->OutputColor[2] = shader->info.num_outputs; + compiler->OutputColor[3] = shader->info.num_outputs; + compiler->OutputDepth = shader->info.num_outputs; /* Now see where they really are. */ - for(i = 0; i < fs->info.num_outputs; ++i) { - switch(fs->info.output_semantic_name[i]) { + for(i = 0; i < shader->info.num_outputs; ++i) { + switch(shader->info.output_semantic_name[i]) { case TGSI_SEMANTIC_COLOR: - compiler->OutputColor = i; + compiler->OutputColor[colorbuf_count] = i; + colorbuf_count++; break; case TGSI_SEMANTIC_POSITION: compiler->OutputDepth = i; @@ -95,7 +109,7 @@ static void allocate_hardware_inputs( void * mydata) { struct r300_shader_semantics* inputs = - &((struct r300_fragment_shader*)c->UserData)->inputs; + (struct r300_shader_semantics*)c->UserData; int i, reg = 0; /* Allocate input registers. */ @@ -112,57 +126,246 @@ static void allocate_hardware_inputs( if (inputs->fog != ATTR_UNUSED) { allocate(mydata, inputs->fog, reg++); } + if (inputs->wpos != ATTR_UNUSED) { + allocate(mydata, inputs->wpos, reg++); + } } -void r300_translate_fragment_shader(struct r300_context* r300, - struct r300_fragment_shader* fs) +static void get_external_state( + struct r300_context* r300, + struct r300_fragment_program_external_state* state) +{ + struct r300_textures_state *texstate = r300->textures_state.state; + unsigned i; + + for (i = 0; i < texstate->sampler_state_count; i++) { + struct r300_sampler_state* s = texstate->sampler_states[i]; + + if (!s) { + continue; + } + + if (s->state.compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) { + /* XXX Gallium doesn't provide us with any information regarding + * this mode, so we are screwed. I'm setting 0 = LUMINANCE. */ + state->unit[i].depth_texture_mode = 0; + + /* Fortunately, no need to translate this. */ + state->unit[i].texture_compare_func = s->state.compare_func; + } + + state->unit[i].non_normalized_coords = !s->state.normalized_coords; + + if (texstate->sampler_views[i]) { + struct r300_texture *t; + t = (struct r300_texture*)texstate->sampler_views[i]->base.texture; + + /* XXX this should probably take into account STR, not just S. */ + if (t->uses_pitch) { + switch (s->state.wrap_s) { + case PIPE_TEX_WRAP_REPEAT: + state->unit[i].wrap_mode = RC_WRAP_REPEAT; + state->unit[i].fake_npot = TRUE; + break; + + case PIPE_TEX_WRAP_MIRROR_REPEAT: + state->unit[i].wrap_mode = RC_WRAP_MIRRORED_REPEAT; + state->unit[i].fake_npot = TRUE; + break; + + case PIPE_TEX_WRAP_MIRROR_CLAMP: + case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_EDGE: + case PIPE_TEX_WRAP_MIRROR_CLAMP_TO_BORDER: + state->unit[i].wrap_mode = RC_WRAP_MIRRORED_CLAMP; + state->unit[i].fake_npot = TRUE; + break; + + default: + state->unit[i].wrap_mode = RC_WRAP_NONE; + break; + } + } + } + } +} + +static void r300_translate_fragment_shader( + struct r300_context* r300, + struct r300_fragment_shader_code* shader, + const struct tgsi_token *tokens); + +static void r300_dummy_fragment_shader( + struct r300_context* r300, + struct r300_fragment_shader_code* shader) +{ + struct pipe_shader_state state; + struct ureg_program *ureg; + struct ureg_dst out; + struct ureg_src imm; + + /* Make a simple fragment shader which outputs (0, 0, 0, 1) */ + ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT); + out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0); + imm = ureg_imm4f(ureg, 0, 0, 0, 1); + + ureg_MOV(ureg, out, imm); + ureg_END(ureg); + + state.tokens = ureg_finalize(ureg); + + shader->dummy = TRUE; + r300_translate_fragment_shader(r300, shader, state.tokens); + + ureg_destroy(ureg); +} + +static void r300_translate_fragment_shader( + struct r300_context* r300, + struct r300_fragment_shader_code* shader, + const struct tgsi_token *tokens) { struct r300_fragment_program_compiler compiler; struct tgsi_to_rc ttr; + int wpos; + unsigned i; + + tgsi_scan_shader(tokens, &shader->info); + r300_shader_read_fs_inputs(&shader->info, &shader->inputs); - /* Initialize. */ - r300_shader_read_fs_inputs(&fs->info, &fs->inputs); + wpos = shader->inputs.wpos; /* Setup the compiler. */ memset(&compiler, 0, sizeof(compiler)); rc_init(&compiler.Base); compiler.Base.Debug = DBG_ON(r300, DBG_FP); - compiler.code = &fs->code; - compiler.is_r500 = r300_screen(r300->context.screen)->caps->is_r500; + compiler.code = &shader->code; + compiler.state = shader->compare_state; + compiler.is_r500 = r300->screen->caps.is_r500; + compiler.max_temp_regs = compiler.is_r500 ? 128 : 32; compiler.AllocateHwInputs = &allocate_hardware_inputs; - compiler.UserData = fs; - - /* XXX: Program compilation depends on texture compare modes, - * which are sampler state. Therefore, programs need to be recompiled - * depending on this state as in the classic Mesa driver. - * - * This is not yet handled correctly. - */ + compiler.UserData = &shader->inputs; - find_output_registers(&compiler, fs); + find_output_registers(&compiler, shader); if (compiler.Base.Debug) { debug_printf("r300: Initial fragment program\n"); - tgsi_dump(fs->state.tokens, 0); + tgsi_dump(tokens, 0); } /* Translate TGSI to our internal representation */ ttr.compiler = &compiler.Base; - ttr.info = &fs->info; + ttr.info = &shader->info; + ttr.use_half_swizzles = TRUE; - r300_tgsi_to_rc(&ttr, fs->state.tokens); + r300_tgsi_to_rc(&ttr, tokens); + + /** + * Transform the program to support WPOS. + * + * Introduce a small fragment at the start of the program that will be + * the only code that directly reads the WPOS input. + * All other code pieces that reference that input will be rewritten + * to read from a newly allocated temporary. */ + if (wpos != ATTR_UNUSED) { + /* Moving the input to some other reg is not really necessary. */ + rc_transform_fragment_wpos(&compiler.Base, wpos, wpos, TRUE); + } /* Invoke the compiler */ r3xx_compile_fragment_program(&compiler); + if (compiler.Base.Error) { - /* XXX failover maybe? */ - DBG(r300, DBG_FP, "r300: Error compiling fragment program: %s\n", - compiler.Base.ErrorMsg); - assert(0); + fprintf(stderr, "r300 FP: Compiler Error:\n%sUsing a dummy shader" + " instead.\n", compiler.Base.ErrorMsg); + + if (shader->dummy) { + fprintf(stderr, "r300 FP: Cannot compile the dummy shader! " + "Giving up...\n"); + abort(); + } + + rc_destroy(&compiler.Base); + r300_dummy_fragment_shader(r300, shader); + return; + } + + /* Initialize numbers of constants for each type. */ + shader->externals_count = ttr.immediate_offset; + shader->immediates_count = 0; + shader->rc_state_count = 0; + + for (i = shader->externals_count; i < shader->code.constants.Count; i++) { + switch (shader->code.constants.Constants[i].Type) { + case RC_CONSTANT_IMMEDIATE: + ++shader->immediates_count; + break; + case RC_CONSTANT_STATE: + ++shader->rc_state_count; + break; + default: + assert(0); + } + } + + /* Setup shader depth output. */ + if (shader->code.writes_depth) { + shader->fg_depth_src = R300_FG_DEPTH_SRC_SHADER; + shader->us_out_w = R300_W_FMT_W24 | R300_W_SRC_US; + } else { + shader->fg_depth_src = R300_FG_DEPTH_SRC_SCAN; + shader->us_out_w = R300_W_FMT_W0 | R300_W_SRC_US; } /* And, finally... */ rc_destroy(&compiler.Base); - fs->translated = TRUE; +} + +boolean r300_pick_fragment_shader(struct r300_context* r300) +{ + struct r300_fragment_shader* fs = r300_fs(r300); + struct r300_fragment_program_external_state state = {{{ 0 }}}; + struct r300_fragment_shader_code* ptr; + + get_external_state(r300, &state); + + if (!fs->first) { + /* Build the fragment shader for the first time. */ + fs->first = fs->shader = CALLOC_STRUCT(r300_fragment_shader_code); + + memcpy(&fs->shader->compare_state, &state, + sizeof(struct r300_fragment_program_external_state)); + r300_translate_fragment_shader(r300, fs->shader, fs->state.tokens); + return TRUE; + + } else { + /* Check if the currently-bound shader has been compiled + * with the texture-compare state we need. */ + if (memcmp(&fs->shader->compare_state, &state, sizeof(state)) != 0) { + /* Search for the right shader. */ + ptr = fs->first; + while (ptr) { + if (memcmp(&ptr->compare_state, &state, sizeof(state)) == 0) { + if (fs->shader != ptr) { + fs->shader = ptr; + return TRUE; + } + /* The currently-bound one is OK. */ + return FALSE; + } + ptr = ptr->next; + } + + /* Not found, gotta compile a new one. */ + ptr = CALLOC_STRUCT(r300_fragment_shader_code); + ptr->next = fs->first; + fs->first = fs->shader = ptr; + + ptr->compare_state = state; + r300_translate_fragment_shader(r300, ptr, fs->state.tokens); + return TRUE; + } + } + + return FALSE; }