src/gallium/drivers/svga/svga_shader.h

   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 flatshade:1;
  81       unsigned pstipple:1;
  82       unsigned alpha_func:4;  /**< SVGA3D_CMP_x */
  83       unsigned write_color0_to_n_cbufs:4;
  84       unsigned aa_point:1;
  85       int aa_point_coord_index;
  86       float alpha_ref;
  87    } fs;
  88
  89    /* any shader type */
  90    int8_t generic_remap_table[MAX_GENERIC_VARYING];
  91    unsigned num_textures:8;
  92    unsigned num_unnormalized_coords:8;
  93    unsigned clip_plane_enable:PIPE_MAX_CLIP_PLANES;
  94    unsigned sprite_origin_lower_left:1;
  95    unsigned sprite_coord_enable;
  96    struct {
  97       unsigned compare_mode:1;
  98       unsigned compare_func:3;
  99       unsigned unnormalized:1;
 100       unsigned width_height_idx:5; /**< texture unit */
 101       unsigned texture_target:4;   /**< PIPE_TEXTURE_x */
 102       unsigned texture_msaa:1;    /**< A multisample texture? */
 103       unsigned sprite_texgen:1;
 104       unsigned swizzle_r:3;
 105       unsigned swizzle_g:3;
 106       unsigned swizzle_b:3;
 107       unsigned swizzle_a:3;
 108       unsigned return_type:3;  /**< TGSI_RETURN_TYPE_x */
 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    /** For FS-based polygon stipple */
 162    unsigned pstipple_sampler_unit;
 163
 164    /** Next variant */
 165    struct svga_shader_variant *next;
 166 };
 167
 168
 169 struct svga_shader
 170 {
 171    const struct tgsi_token *tokens;
 172    struct svga_token_key token_key;     /* token key for the token string */
 173    struct tgsi_shader_info info;
 174
 175    /* List of shaders with tokens derived from the same token string */
 176    struct svga_shader *next;
 177    struct svga_shader *parent;   /* shader with the original token string */
 178
 179    struct svga_stream_output *stream_output;
 180
 181    /** Head of linked list of compiled variants */
 182    struct svga_shader_variant *variants;
 183
 184    unsigned id;  /**< for debugging only */
 185 };
 186
 187
 188 struct svga_fragment_shader
 189 {
 190    struct svga_shader base;
 191
 192    struct draw_fragment_shader *draw_shader;
 193
 194    /** Mask of which generic varying variables are read by this shader */
 195    uint64_t generic_inputs;
 196
 197    /** Table mapping original TGSI generic indexes to low integers */
 198    int8_t generic_remap_table[MAX_GENERIC_VARYING];
 199 };
 200
 201
 202 struct svga_vertex_shader
 203 {
 204    struct svga_shader base;
 205
 206    struct draw_vertex_shader *draw_shader;
 207
 208    /** Mask of which generic varying variables are written by this shader */
 209    uint64_t generic_outputs;
 210
 211    /** Generated geometry shader that goes with this vertex shader */
 212    struct svga_geometry_shader *gs;
 213 };
 214
 215
 216 struct svga_geometry_shader
 217 {
 218    struct svga_shader base;
 219
 220    struct draw_geometry_shader *draw_shader;
 221
 222    /** Table mapping original TGSI generic indexes to low integers */
 223    int8_t generic_remap_table[MAX_GENERIC_VARYING];
 224    uint64_t generic_outputs;
 225
 226    unsigned aa_point_coord_index; /* generic index for aa point coord */
 227
 228    unsigned wide_point:1;      /* set if the shader emulates wide point */
 229 };
 230
 231
 232 static inline boolean
 233 svga_compile_keys_equal(const struct svga_compile_key *a,
 234                         const struct svga_compile_key *b)
 235 {
 236    unsigned key_size =
 237       (const char *) &a->tex[a->num_textures] - (const char *) a;
 238
 239    return memcmp(a, b, key_size) == 0;
 240 }
 241
 242
 243 uint64_t
 244 svga_get_generic_inputs_mask(const struct tgsi_shader_info *info);
 245
 246 uint64_t
 247 svga_get_generic_outputs_mask(const struct tgsi_shader_info *info);
 248
 249 void
 250 svga_remap_generics(uint64_t generics_mask,
 251                     int8_t remap_table[MAX_GENERIC_VARYING]);
 252
 253 int
 254 svga_remap_generic_index(int8_t remap_table[MAX_GENERIC_VARYING],
 255                          int generic_index);
 256
 257 void
 258 svga_init_shader_key_common(const struct svga_context *svga, unsigned shader,
 259                             struct svga_compile_key *key);
 260
 261 struct svga_shader_variant *
 262 svga_search_shader_key(const struct svga_shader *shader,
 263                        const struct svga_compile_key *key);
 264
 265 struct svga_shader *
 266 svga_search_shader_token_key(struct svga_shader *shader,
 267                              const struct svga_token_key *key);
 268
 269 enum pipe_error
 270 svga_define_shader(struct svga_context *svga,
 271                    SVGA3dShaderType type,
 272                    struct svga_shader_variant *variant);
 273
 274 enum pipe_error
 275 svga_set_shader(struct svga_context *svga,
 276                 SVGA3dShaderType type,
 277                 struct svga_shader_variant *variant);
 278
 279 struct svga_shader_variant *
 280 svga_new_shader_variant(struct svga_context *svga);
 281
 282 enum pipe_error
 283 svga_destroy_shader_variant(struct svga_context *svga,
 284                             SVGA3dShaderType type,
 285                             struct svga_shader_variant *variant);
 286
 287 enum pipe_error
 288 svga_rebind_shaders(struct svga_context *svga);
 289
 290 /**
 291  * Check if a shader's bytecode exceeds the device limits.
 292  */
 293 static inline boolean
 294 svga_shader_too_large(const struct svga_context *svga,
 295                       const struct svga_shader_variant *variant)
 296 {
 297    if (svga_have_gb_objects(svga)) {
 298       return FALSE;
 299    }
 300
 301    if (variant->nr_tokens * sizeof(variant->tokens[0])
 302        + sizeof(SVGA3dCmdDefineShader) + sizeof(SVGA3dCmdHeader)
 303        < SVGA_CB_MAX_COMMAND_SIZE) {
 304       return FALSE;
 305    }
 306
 307    return TRUE;
 308 }
 309
 310
 311 /**
 312  * Convert from PIPE_SHADER_* to SVGA3D_SHADERTYPE_*
 313  */
 314 static inline SVGA3dShaderType
 315 svga_shader_type(unsigned shader)
 316 {
 317    switch (shader) {
 318    case PIPE_SHADER_VERTEX:
 319       return SVGA3D_SHADERTYPE_VS;
 320    case PIPE_SHADER_GEOMETRY:
 321       return SVGA3D_SHADERTYPE_GS;
 322    case PIPE_SHADER_FRAGMENT:
 323       return SVGA3D_SHADERTYPE_PS;
 324    default:
 325       assert(!"Invalid shader type");
 326       return SVGA3D_SHADERTYPE_VS;
 327    }
 328 }
 329
 330
 331 /** Does the current VS have stream output? */
 332 static inline boolean
 333 svga_have_vs_streamout(const struct svga_context *svga)
 334 {
 335    return svga->curr.vs != NULL && svga->curr.vs->base.stream_output != NULL;
 336 }
 337
 338
 339 /** Does the current GS have stream output? */
 340 static inline boolean
 341 svga_have_gs_streamout(const struct svga_context *svga)
 342 {
 343    return svga->curr.gs != NULL && svga->curr.gs->base.stream_output != NULL;
 344 }
 345
 346
 347 #endif /* SVGA_SHADER_H */