sp_fs_exec.c revision cc93fa3527e64963acd0e643d7d1061306d9e1df
1/************************************************************************** 2 * 3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas. 4 * 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 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR 22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27 28/** 29 * Execute fragment shader using the TGSI interpreter. 30 */ 31 32#include "sp_context.h" 33#include "sp_state.h" 34#include "sp_fs.h" 35#include "sp_quad.h" 36 37#include "pipe/p_state.h" 38#include "pipe/p_defines.h" 39#include "util/u_memory.h" 40#include "tgsi/tgsi_exec.h" 41#include "tgsi/tgsi_parse.h" 42 43 44/** 45 * Subclass of sp_fragment_shader 46 */ 47struct sp_exec_fragment_shader 48{ 49 struct sp_fragment_shader base; 50 /* No other members for now */ 51}; 52 53 54/** cast wrapper */ 55static INLINE struct sp_exec_fragment_shader * 56sp_exec_fragment_shader(const struct sp_fragment_shader *base) 57{ 58 return (struct sp_exec_fragment_shader *) base; 59} 60 61 62static void 63exec_prepare( const struct sp_fragment_shader *base, 64 struct tgsi_exec_machine *machine, 65 struct tgsi_sampler **samplers ) 66{ 67 /* 68 * Bind tokens/shader to the interpreter's machine state. 69 * Avoid redundant binding. 70 */ 71 if (machine->Tokens != base->shader.tokens) { 72 tgsi_exec_machine_bind_shader( machine, 73 base->shader.tokens, 74 PIPE_MAX_SAMPLERS, 75 samplers ); 76 } 77} 78 79 80 81/** 82 * Compute quad X,Y,Z,W for the four fragments in a quad. 83 * 84 * This should really be part of the compiled shader. 85 */ 86static void 87setup_pos_vector(const struct tgsi_interp_coef *coef, 88 float x, float y, 89 struct tgsi_exec_vector *quadpos) 90{ 91 uint chan; 92 /* do X */ 93 quadpos->xyzw[0].f[0] = x; 94 quadpos->xyzw[0].f[1] = x + 1; 95 quadpos->xyzw[0].f[2] = x; 96 quadpos->xyzw[0].f[3] = x + 1; 97 98 /* do Y */ 99 quadpos->xyzw[1].f[0] = y; 100 quadpos->xyzw[1].f[1] = y; 101 quadpos->xyzw[1].f[2] = y + 1; 102 quadpos->xyzw[1].f[3] = y + 1; 103 104 /* do Z and W for all fragments in the quad */ 105 for (chan = 2; chan < 4; chan++) { 106 const float dadx = coef->dadx[chan]; 107 const float dady = coef->dady[chan]; 108 const float a0 = coef->a0[chan] + dadx * x + dady * y; 109 quadpos->xyzw[chan].f[0] = a0; 110 quadpos->xyzw[chan].f[1] = a0 + dadx; 111 quadpos->xyzw[chan].f[2] = a0 + dady; 112 quadpos->xyzw[chan].f[3] = a0 + dadx + dady; 113 } 114} 115 116 117/* TODO: hide the machine struct in here somewhere, remove from this 118 * interface: 119 */ 120static unsigned 121exec_run( const struct sp_fragment_shader *base, 122 struct tgsi_exec_machine *machine, 123 struct quad_header *quad ) 124{ 125 /* Compute X, Y, Z, W vals for this quad */ 126 setup_pos_vector(quad->posCoef, 127 (float)quad->input.x0, (float)quad->input.y0, 128 &machine->QuadPos); 129 130 if (quad->input.facing) { 131 machine->Face = -1.0f; 132 } else { 133 machine->Face = 1.0f; 134 } 135 136 quad->inout.mask &= tgsi_exec_machine_run( machine ); 137 if (quad->inout.mask == 0) 138 return FALSE; 139 140 /* store outputs */ 141 { 142 const ubyte *sem_name = base->info.output_semantic_name; 143 const ubyte *sem_index = base->info.output_semantic_index; 144 const uint n = base->info.num_outputs; 145 uint i; 146 for (i = 0; i < n; i++) { 147 switch (sem_name[i]) { 148 case TGSI_SEMANTIC_COLOR: 149 { 150 uint cbuf = sem_index[i]; 151 memcpy(quad->output.color[cbuf], 152 &machine->Outputs[i].xyzw[0].f[0], 153 sizeof(quad->output.color[0]) ); 154 } 155 break; 156 case TGSI_SEMANTIC_POSITION: 157 { 158 uint j; 159 for (j = 0; j < 4; j++) { 160 quad->output.depth[j] = machine->Outputs[i].xyzw[2].f[j]; 161 } 162 } 163 break; 164 } 165 } 166 } 167 168 return TRUE; 169} 170 171 172static void 173exec_delete( struct sp_fragment_shader *base ) 174{ 175 FREE((void *) base->shader.tokens); 176 FREE(base); 177} 178 179 180struct sp_fragment_shader * 181softpipe_create_fs_exec(struct softpipe_context *softpipe, 182 const struct pipe_shader_state *templ) 183{ 184 struct sp_exec_fragment_shader *shader; 185 186 /* Decide whether we'll be codegenerating this shader and if so do 187 * that now. 188 */ 189 190 shader = CALLOC_STRUCT(sp_exec_fragment_shader); 191 if (!shader) 192 return NULL; 193 194 /* we need to keep a local copy of the tokens */ 195 shader->base.shader.tokens = tgsi_dup_tokens(templ->tokens); 196 shader->base.prepare = exec_prepare; 197 shader->base.run = exec_run; 198 shader->base.delete = exec_delete; 199 200 return &shader->base; 201} 202