X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fgallium%2Fdrivers%2Fr300%2Fr300_fs.c;h=dab57fdcc77e73d2a489b81b2785f0d00646f8b3;hb=7d93f2bf8462948836491c004823feb7a1ce1445;hp=9e71e61c303593efe8f106c1264dafa592f327ef;hpb=f0f04cd12db156ec53b7ea46fae27199af121f90;p=mesa.git diff --git a/src/gallium/drivers/r300/r300_fs.c b/src/gallium/drivers/r300/r300_fs.c index 9e71e61c303..dab57fdcc77 100644 --- a/src/gallium/drivers/r300/r300_fs.c +++ b/src/gallium/drivers/r300/r300_fs.c @@ -26,10 +26,12 @@ #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" @@ -69,26 +71,27 @@ void r300_shader_read_fs_inputs(struct tgsi_shader_info* info, 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, colorbuf_count = 0; /* Mark the outputs as not present initially */ - compiler->OutputColor[0] = fs->info.num_outputs; - compiler->OutputColor[1] = fs->info.num_outputs; - compiler->OutputColor[2] = fs->info.num_outputs; - compiler->OutputColor[3] = 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[colorbuf_count] = i; colorbuf_count++; @@ -128,20 +131,21 @@ static void allocate_hardware_inputs( } } -static void get_compare_state( +static void get_external_state( struct r300_context* r300, - struct r300_fragment_program_external_state* state, - unsigned shadow_samplers) + struct r300_fragment_program_external_state* state) { - struct r300_textures_state *texstate = - (struct r300_textures_state*)r300->textures_state.state; - - memset(state, 0, sizeof(*state)); + struct r300_textures_state *texstate = r300->textures_state.state; + unsigned i; - for (int i = 0; i < texstate->sampler_count; i++) { + for (i = 0; i < texstate->sampler_state_count; i++) { struct r300_sampler_state* s = texstate->sampler_states[i]; - if (s && s->state.compare_mode == PIPE_TEX_COMPARE_R_TO_TEXTURE) { + 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; @@ -149,17 +153,82 @@ static void get_compare_state( /* Fortunately, no need to translate this. */ state->unit[i].texture_compare_func = s->state.compare_func; } + + if (texstate->sampler_views[i]) { + struct r300_texture *t; + t = (struct r300_texture*)texstate->sampler_views[i]->base.texture; + + state->unit[i].fake_npot = t->uses_pitch; + } + state->unit[i].non_normalized_coords = !s->state.normalized_coords; + + /* XXX this should probably take into account STR, not just S. */ + switch (s->state.wrap_s) { + case PIPE_TEX_WRAP_REPEAT: + state->unit[i].wrap_mode = RC_WRAP_REPEAT; + break; + case PIPE_TEX_WRAP_CLAMP: + case PIPE_TEX_WRAP_CLAMP_TO_EDGE: + case PIPE_TEX_WRAP_CLAMP_TO_BORDER: + state->unit[i].wrap_mode = RC_WRAP_CLAMP; + break; + case PIPE_TEX_WRAP_MIRROR_REPEAT: + 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_MIRROR; + 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 r300_fragment_shader* fs = r300->fs; + 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 = fs->inputs.wpos; + int wpos; + unsigned i; + + tgsi_scan_shader(tokens, &shader->info); + r300_shader_read_fs_inputs(&shader->info, &shader->inputs); + + wpos = shader->inputs.wpos; /* Setup the compiler. */ memset(&compiler, 0, sizeof(compiler)); @@ -168,25 +237,24 @@ static void r300_translate_fragment_shader( compiler.code = &shader->code; compiler.state = shader->compare_state; - compiler.is_r500 = r300_screen(r300->context.screen)->caps->is_r500; + 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->inputs; + 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); - - fs->shadow_samplers = compiler.Base.Program.ShadowSamplers; + r300_tgsi_to_rc(&ttr, tokens); /** * Transform the program to support WPOS. @@ -202,12 +270,47 @@ static void r300_translate_fragment_shader( /* 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); - abort(); + 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... */ @@ -216,24 +319,22 @@ static void r300_translate_fragment_shader( boolean r300_pick_fragment_shader(struct r300_context* r300) { - struct r300_fragment_shader* fs = r300->fs; - struct r300_fragment_program_external_state state; + 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); - /* BTW shadow samplers will be known after the first translation, - * therefore we set ~0, which means it should look at all sampler - * states. This choice doesn't have any impact on the correctness. */ - get_compare_state(r300, &fs->shader->compare_state, ~0); - r300_translate_fragment_shader(r300, fs->shader); + 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 if (fs->shadow_samplers) { - get_compare_state(r300, &state, fs->shadow_samplers); - + } 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) { @@ -253,7 +354,7 @@ boolean r300_pick_fragment_shader(struct r300_context* r300) fs->first = fs->shader = ptr; ptr->compare_state = state; - r300_translate_fragment_shader(r300, ptr); + r300_translate_fragment_shader(r300, ptr, fs->state.tokens); return TRUE; } }