1 /********************************************************** 2 * Copyright 2008-2012 VMware, Inc. All rights reserved. 3 * 4 * Permission is hereby granted, free of charge, to any person 5 * obtaining a copy of this software and associated documentation 6 * files (the "Software"), to deal in the Software without 7 * restriction, including without limitation the rights to use, copy, 8 * modify, merge, publish, distribute, sublicense, and/or sell copies 9 * of the Software, and to permit persons to whom the Software is 10 * furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be 13 * included in all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 * SOFTWARE. 23 * 24 **********************************************************/ 25 26 #ifndef SVGA_SHADER_H 27 #define SVGA_SHADER_H 28 29 #include "svga3d_reg.h" 30 #include "svga_context.h" 31 #include "svga_streamout.h" 32 33 34 /** 35 * We use a 64-bit mask to keep track of the generic indexes. 36 * This is the maximum semantic index for a TGSI GENERIC[i] register. 37 */ 38 #define MAX_GENERIC_VARYING 64 39 40 41 struct svga_context; 42 43 44 struct svga_compile_key 45 { 46 /* vertex shader only */ 47 struct { 48 uint64_t fs_generic_inputs; 49 unsigned passthrough:1; 50 unsigned need_prescale:1; 51 unsigned undo_viewport:1; 52 unsigned allow_psiz:1; 53 /** The following are all 32-bit bitmasks (per VS input) */ 54 unsigned adjust_attrib_range; 55 unsigned attrib_is_pure_int; 56 unsigned adjust_attrib_w_1; 57 unsigned adjust_attrib_itof; 58 unsigned adjust_attrib_utof; 59 unsigned attrib_is_bgra; 60 unsigned attrib_puint_to_snorm; 61 unsigned attrib_puint_to_uscaled; 62 unsigned attrib_puint_to_sscaled; 63 } vs; 64 65 /* geometry shader only */ 66 struct { 67 uint64_t vs_generic_outputs; 68 unsigned need_prescale:1; 69 unsigned writes_psize:1; 70 unsigned wide_point:1; 71 } gs; 72 73 /* fragment shader only */ 74 struct { 75 uint64_t vs_generic_outputs; 76 uint64_t gs_generic_outputs; 77 unsigned light_twoside:1; 78 unsigned front_ccw:1; 79 unsigned white_fragments:1; 80 unsigned alpha_to_one:1; 81 unsigned flatshade:1; 82 unsigned pstipple:1; 83 unsigned alpha_func:4; /**< SVGA3D_CMP_x */ 84 unsigned write_color0_to_n_cbufs:4; 85 unsigned aa_point:1; 86 int aa_point_coord_index; 87 float alpha_ref; 88 } fs; 89 90 /* any shader type */ 91 int8_t generic_remap_table[MAX_GENERIC_VARYING]; 92 unsigned num_textures:8; 93 unsigned num_unnormalized_coords:8; 94 unsigned clip_plane_enable:PIPE_MAX_CLIP_PLANES; 95 unsigned sprite_origin_lower_left:1; 96 unsigned sprite_coord_enable; 97 struct { 98 unsigned compare_mode:1; 99 unsigned compare_func:3; 100 unsigned unnormalized:1; 101 unsigned texel_bias:1; 102 unsigned width_height_idx:5; /**< texture unit */ 103 unsigned is_array:1; 104 unsigned sprite_texgen:1; 105 unsigned swizzle_r:3; 106 unsigned swizzle_g:3; 107 unsigned swizzle_b:3; 108 unsigned swizzle_a:3; 109 } tex[PIPE_MAX_SAMPLERS]; 110 /* Note: svga_compile_keys_equal() depends on the variable-size 111 * tex[] array being at the end of this structure. 112 */ 113 }; 114 115 /* A key for a variant of token string of a shader */ 116 struct svga_token_key { 117 struct { 118 unsigned sprite_coord_enable:24; 119 unsigned sprite_origin_upper_left:1; 120 unsigned point_pos_stream_out:1; 121 unsigned writes_psize:1; 122 unsigned aa_point:1; 123 } gs; 124 }; 125 126 /** 127 * A single TGSI shader may be compiled into different variants of 128 * SVGA3D shaders depending on the compile key. Each user shader 129 * will have a linked list of these variants. 130 */ 131 struct svga_shader_variant 132 { 133 const struct svga_shader *shader; 134 135 /** Parameters used to generate this variant */ 136 struct svga_compile_key key; 137 138 /* Compiled shader tokens: 139 */ 140 const unsigned *tokens; 141 unsigned nr_tokens; 142 143 /** Per-context shader identifier used with SVGA_3D_CMD_SHADER_DEFINE, 144 * SVGA_3D_CMD_SET_SHADER and SVGA_3D_CMD_SHADER_DESTROY. 145 */ 146 unsigned id; 147 148 /** Start of extra constants (number of float[4] constants) */ 149 unsigned extra_const_start; 150 151 /* GB object buffer containing the bytecode */ 152 struct svga_winsys_gb_shader *gb_shader; 153 154 boolean uses_flat_interp; /** TRUE if flat interpolation qualifier is 155 * applied to any of the varyings. 156 */ 157 158 /** Is the color output just a constant value? (fragment shader only) */ 159 boolean constant_color_output; 160 161 /** Bitmask indicating which texture units are doing the shadow 162 * comparison test in the shader rather than the sampler state. 163 */ 164 unsigned fs_shadow_compare_units; 165 166 /** For FS-based polygon stipple */ 167 unsigned pstipple_sampler_unit; 168 169 /** Next variant */ 170 struct svga_shader_variant *next; 171 }; 172 173 174 struct svga_shader 175 { 176 const struct tgsi_token *tokens; 177 struct svga_token_key token_key; /* token key for the token string */ 178 struct tgsi_shader_info info; 179 180 /* List of shaders with tokens derived from the same token string */ 181 struct svga_shader *next; 182 struct svga_shader *parent; /* shader with the original token string */ 183 184 struct svga_stream_output *stream_output; 185 186 /** Head of linked list of compiled variants */ 187 struct svga_shader_variant *variants; 188 189 unsigned id; /**< for debugging only */ 190 }; 191 192 193 struct svga_fragment_shader 194 { 195 struct svga_shader base; 196 197 struct draw_fragment_shader *draw_shader; 198 199 /** Mask of which generic varying variables are read by this shader */ 200 uint64_t generic_inputs; 201 202 /** Table mapping original TGSI generic indexes to low integers */ 203 int8_t generic_remap_table[MAX_GENERIC_VARYING]; 204 }; 205 206 207 struct svga_vertex_shader 208 { 209 struct svga_shader base; 210 211 struct draw_vertex_shader *draw_shader; 212 213 /** Mask of which generic varying variables are written by this shader */ 214 uint64_t generic_outputs; 215 216 /** Generated geometry shader that goes with this vertex shader */ 217 struct svga_geometry_shader *gs; 218 }; 219 220 221 struct svga_geometry_shader 222 { 223 struct svga_shader base; 224 225 struct draw_geometry_shader *draw_shader; 226 227 /** Table mapping original TGSI generic indexes to low integers */ 228 int8_t generic_remap_table[MAX_GENERIC_VARYING]; 229 uint64_t generic_outputs; 230 231 unsigned aa_point_coord_index; /* generic index for aa point coord */ 232 233 unsigned wide_point:1; /* set if the shader emulates wide point */ 234 }; 235 236 237 static inline boolean 238 svga_compile_keys_equal(const struct svga_compile_key *a, 239 const struct svga_compile_key *b) 240 { 241 unsigned key_size = 242 (const char *) &a->tex[a->num_textures] - (const char *) a; 243 244 return memcmp(a, b, key_size) == 0; 245 } 246 247 248 uint64_t 249 svga_get_generic_inputs_mask(const struct tgsi_shader_info *info); 250 251 uint64_t 252 svga_get_generic_outputs_mask(const struct tgsi_shader_info *info); 253 254 void 255 svga_remap_generics(uint64_t generics_mask, 256 int8_t remap_table[MAX_GENERIC_VARYING]); 257 258 int 259 svga_remap_generic_index(int8_t remap_table[MAX_GENERIC_VARYING], 260 int generic_index); 261 262 void 263 svga_init_shader_key_common(const struct svga_context *svga, 264 enum pipe_shader_type shader, 265 struct svga_compile_key *key); 266 267 struct svga_shader_variant * 268 svga_search_shader_key(const struct svga_shader *shader, 269 const struct svga_compile_key *key); 270 271 struct svga_shader * 272 svga_search_shader_token_key(struct svga_shader *shader, 273 const struct svga_token_key *key); 274 275 enum pipe_error 276 svga_define_shader(struct svga_context *svga, 277 SVGA3dShaderType type, 278 struct svga_shader_variant *variant); 279 280 enum pipe_error 281 svga_set_shader(struct svga_context *svga, 282 SVGA3dShaderType type, 283 struct svga_shader_variant *variant); 284 285 struct svga_shader_variant * 286 svga_new_shader_variant(struct svga_context *svga); 287 288 enum pipe_error 289 svga_destroy_shader_variant(struct svga_context *svga, 290 SVGA3dShaderType type, 291 struct svga_shader_variant *variant); 292 293 enum pipe_error 294 svga_rebind_shaders(struct svga_context *svga); 295 296 /** 297 * Check if a shader's bytecode exceeds the device limits. 298 */ 299 static inline boolean 300 svga_shader_too_large(const struct svga_context *svga, 301 const struct svga_shader_variant *variant) 302 { 303 if (svga_have_gb_objects(svga)) { 304 return FALSE; 305 } 306 307 if (variant->nr_tokens * sizeof(variant->tokens[0]) 308 + sizeof(SVGA3dCmdDefineShader) + sizeof(SVGA3dCmdHeader) 309 < SVGA_CB_MAX_COMMAND_SIZE) { 310 return FALSE; 311 } 312 313 return TRUE; 314 } 315 316 317 /** 318 * Convert from PIPE_SHADER_* to SVGA3D_SHADERTYPE_* 319 */ 320 static inline SVGA3dShaderType 321 svga_shader_type(enum pipe_shader_type shader) 322 { 323 switch (shader) { 324 case PIPE_SHADER_VERTEX: 325 return SVGA3D_SHADERTYPE_VS; 326 case PIPE_SHADER_GEOMETRY: 327 return SVGA3D_SHADERTYPE_GS; 328 case PIPE_SHADER_FRAGMENT: 329 return SVGA3D_SHADERTYPE_PS; 330 default: 331 assert(!"Invalid shader type"); 332 return SVGA3D_SHADERTYPE_VS; 333 } 334 } 335 336 337 /** Does the current VS have stream output? */ 338 static inline boolean 339 svga_have_vs_streamout(const struct svga_context *svga) 340 { 341 return svga->curr.vs != NULL && svga->curr.vs->base.stream_output != NULL; 342 } 343 344 345 /** Does the current GS have stream output? */ 346 static inline boolean 347 svga_have_gs_streamout(const struct svga_context *svga) 348 { 349 return svga->curr.gs != NULL && svga->curr.gs->base.stream_output != NULL; 350 } 351 352 353 #endif /* SVGA_SHADER_H */ 354
