src/gallium/drivers/svga/svga_pipe_rasterizer.c

   1 /**********************************************************
   2  * Copyright 2008-2009 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 #include "draw/draw_context.h"
  27 #include "util/u_inlines.h"
  28 #include "pipe/p_defines.h"
  29 #include "util/u_math.h"
  30 #include "util/u_memory.h"
  31
  32 #include "svga_context.h"
  33
  34 #include "svga_hw_reg.h"
  35
  36 /* Hardware frontwinding is always set up as SVGA3D_FRONTWINDING_CW.
  37  */
  38 static SVGA3dFace svga_translate_cullmode( unsigned mode,
  39                                            unsigned front_ccw )
  40 {
  41    const int hw_front_ccw = 0;  /* hardware is always CW */
  42    switch (mode) {
  43    case PIPE_FACE_NONE:
  44       return SVGA3D_FACE_NONE;
  45    case PIPE_FACE_FRONT:
  46       return front_ccw == hw_front_ccw ? SVGA3D_FACE_FRONT : SVGA3D_FACE_BACK;
  47    case PIPE_FACE_BACK:
  48       return front_ccw == hw_front_ccw ? SVGA3D_FACE_BACK : SVGA3D_FACE_FRONT;
  49    case PIPE_FACE_FRONT_AND_BACK:
  50       return SVGA3D_FACE_FRONT_BACK;
  51    default:
  52       assert(0);
  53       return SVGA3D_FACE_NONE;
  54    }
  55 }
  56
  57 static SVGA3dShadeMode svga_translate_flatshade( unsigned mode )
  58 {
  59    return mode ? SVGA3D_SHADEMODE_FLAT : SVGA3D_SHADEMODE_SMOOTH;
  60 }
  61
  62
  63 static void *
  64 svga_create_rasterizer_state(struct pipe_context *pipe,
  65                              const struct pipe_rasterizer_state *templ)
  66 {
  67    struct svga_context *svga = svga_context(pipe);
  68    struct svga_rasterizer_state *rast = CALLOC_STRUCT( svga_rasterizer_state );
  69
  70    /* need this for draw module. */
  71    rast->templ = *templ;
  72
  73    /* light_twoside          - XXX: need fragment shader variant */
  74    /* poly_smooth            - XXX: no fallback available */
  75    /* poly_stipple_enable    - draw module */
  76    /* sprite_coord_enable    - ? */
  77    /* point_quad_rasterization - ? */
  78    /* point_size_per_vertex  - ? */
  79    /* sprite_coord_mode      - ??? */
  80    /* flatshade_first        - handled by index translation */
  81    /* gl_rasterization_rules - XXX - viewport code */
  82    /* line_width             - draw module */
  83    /* fill_cw, fill_ccw      - draw module or index translation */
  84
  85    rast->shademode = svga_translate_flatshade( templ->flatshade );
  86    rast->cullmode = svga_translate_cullmode( templ->cull_face,
  87                                              templ->front_ccw );
  88    rast->scissortestenable = templ->scissor;
  89    rast->multisampleantialias = templ->multisample;
  90    rast->antialiasedlineenable = templ->line_smooth;
  91    rast->lastpixel = templ->line_last_pixel;
  92    rast->pointsize = templ->point_size;
  93    rast->hw_unfilled = PIPE_POLYGON_MODE_FILL;
  94
  95    /* Use swtnl + decomposition implement these:
  96     */
  97    if (templ->poly_stipple_enable) {
  98       rast->need_pipeline |= SVGA_PIPELINE_FLAG_TRIS;
  99       rast->need_pipeline_tris_str = "poly stipple";
 100    }
 101
 102    if (templ->line_width >= 1.5f &&
 103        !svga->debug.no_line_width) {
 104       rast->need_pipeline |= SVGA_PIPELINE_FLAG_LINES;
 105       rast->need_pipeline_lines_str = "line width";
 106    }
 107
 108    if (templ->line_stipple_enable) {
 109       /* XXX: LinePattern not implemented on all backends, and there is no
 110        * mechanism to query it.
 111        */
 112       if (!svga->debug.force_hw_line_stipple) {
 113          SVGA3dLinePattern lp;
 114          lp.repeat = templ->line_stipple_factor + 1;
 115          lp.pattern = templ->line_stipple_pattern;
 116          rast->linepattern = lp.uintValue;
 117       }
 118       else {
 119          rast->need_pipeline |= SVGA_PIPELINE_FLAG_LINES;
 120          rast->need_pipeline_lines_str = "line stipple";
 121       }
 122    }
 123
 124    if (templ->point_smooth) {
 125       rast->need_pipeline |= SVGA_PIPELINE_FLAG_POINTS;
 126       rast->need_pipeline_points_str = "smooth points";
 127    }
 128
 129    if (templ->line_smooth) {
 130       rast->need_pipeline |= SVGA_PIPELINE_FLAG_LINES;
 131       rast->need_pipeline_lines_str = "smooth lines";
 132    }
 133
 134    {
 135       int fill_front = templ->fill_front;
 136       int fill_back = templ->fill_back;
 137       int fill = PIPE_POLYGON_MODE_FILL;
 138       boolean offset_front = util_get_offset(templ, fill_front);
 139       boolean offset_back = util_get_offset(templ, fill_back);
 140       boolean offset  = 0;
 141
 142       switch (templ->cull_face) {
 143       case PIPE_FACE_FRONT_AND_BACK:
 144          offset = 0;
 145          fill = PIPE_POLYGON_MODE_FILL;
 146          break;
 147
 148       case PIPE_FACE_FRONT:
 149          offset = offset_front;
 150          fill = fill_front;
 151          break;
 152
 153       case PIPE_FACE_BACK:
 154          offset = offset_back;
 155          fill = fill_back;
 156          break;
 157
 158       case PIPE_FACE_NONE:
 159          if (fill_front != fill_back || offset_front != offset_back)
 160          {
 161             /* Always need the draw module to work out different
 162              * front/back fill modes:
 163              */
 164             rast->need_pipeline |= SVGA_PIPELINE_FLAG_TRIS;
 165             rast->need_pipeline_tris_str = "different front/back fillmodes";
 166          }
 167          else {
 168             offset = offset_front;
 169             fill = fill_front;
 170          }
 171          break;
 172
 173       default:
 174          assert(0);
 175          break;
 176       }
 177
 178       /* Unfilled primitive modes aren't implemented on all virtual
 179        * hardware.  We can do some unfilled processing with index
 180        * translation, but otherwise need the draw module:
 181        */
 182       if (fill != PIPE_POLYGON_MODE_FILL &&
 183           (templ->flatshade ||
 184            templ->light_twoside ||
 185            offset ||
 186            templ->cull_face != PIPE_FACE_NONE))
 187       {
 188          fill = PIPE_POLYGON_MODE_FILL;
 189          rast->need_pipeline |= SVGA_PIPELINE_FLAG_TRIS;
 190          rast->need_pipeline_tris_str = "unfilled primitives with no index manipulation";
 191       }
 192
 193       /* If we are decomposing to lines, and lines need the pipeline,
 194        * then we also need the pipeline for tris.
 195        */
 196       if (fill == PIPE_POLYGON_MODE_LINE &&
 197           (rast->need_pipeline & SVGA_PIPELINE_FLAG_LINES))
 198       {
 199          fill = PIPE_POLYGON_MODE_FILL;
 200          rast->need_pipeline |= SVGA_PIPELINE_FLAG_TRIS;
 201          rast->need_pipeline_tris_str = "decomposing lines";
 202       }
 203
 204       /* Similarly for points:
 205        */
 206       if (fill == PIPE_POLYGON_MODE_POINT &&
 207           (rast->need_pipeline & SVGA_PIPELINE_FLAG_POINTS))
 208       {
 209          fill = PIPE_POLYGON_MODE_FILL;
 210          rast->need_pipeline |= SVGA_PIPELINE_FLAG_TRIS;
 211          rast->need_pipeline_tris_str = "decomposing points";
 212       }
 213
 214       if (offset) {
 215          rast->slopescaledepthbias = templ->offset_scale;
 216          rast->depthbias = templ->offset_units;
 217       }
 218
 219       rast->hw_unfilled = fill;
 220    }
 221
 222    if (rast->need_pipeline & SVGA_PIPELINE_FLAG_TRIS) {
 223       /* Turn off stuff which will get done in the draw module:
 224        */
 225       rast->hw_unfilled = PIPE_POLYGON_MODE_FILL;
 226       rast->slopescaledepthbias = 0;
 227       rast->depthbias = 0;
 228    }
 229
 230    return rast;
 231 }
 232
 233 static void svga_bind_rasterizer_state( struct pipe_context *pipe,
 234                                         void *state )
 235 {
 236    struct svga_context *svga = svga_context(pipe);
 237    struct svga_rasterizer_state *raster = (struct svga_rasterizer_state *)state;
 238
 239    svga->curr.rast = raster;
 240
 241    draw_set_rasterizer_state(svga->swtnl.draw, raster ? &raster->templ : NULL,
 242                              state);
 243
 244    svga->dirty |= SVGA_NEW_RAST;
 245 }
 246
 247 static void svga_delete_rasterizer_state(struct pipe_context *pipe,
 248                                          void *raster)
 249 {
 250    FREE(raster);
 251 }
 252
 253
 254 void svga_init_rasterizer_functions( struct svga_context *svga )
 255 {
 256    svga->pipe.create_rasterizer_state = svga_create_rasterizer_state;
 257    svga->pipe.bind_rasterizer_state = svga_bind_rasterizer_state;
 258    svga->pipe.delete_rasterizer_state = svga_delete_rasterizer_state;
 259 }
 260
 261
 262 /***********************************************************************
 263  * Hardware state update
 264  */
 265