Home | History | Annotate | Download | only in svga 
      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 "draw/draw_vbuf.h"
     28 #include "util/u_bitmask.h"
     29 #include "util/u_inlines.h"
     30 #include "pipe/p_state.h"
     31 
     32 #include "svga_cmd.h"
     33 #include "svga_context.h"
     34 #include "svga_shader.h"
     35 #include "svga_swtnl.h"
     36 #include "svga_state.h"
     37 #include "svga_tgsi.h"
     38 #include "svga_swtnl_private.h"
     39 
     40 
     41 #define SVGA_POINT_ADJ_X -0.375f
     42 #define SVGA_POINT_ADJ_Y -0.5f
     43 
     44 #define SVGA_LINE_ADJ_X -0.5f
     45 #define SVGA_LINE_ADJ_Y -0.5f
     46 
     47 #define SVGA_TRIANGLE_ADJ_X -0.375f
     48 #define SVGA_TRIANGLE_ADJ_Y -0.5f
     49 
     50 
     51 static void
     52 set_draw_viewport(struct svga_context *svga)
     53 {
     54    struct pipe_viewport_state vp = svga->curr.viewport;
     55    float adjx = 0.0f;
     56    float adjy = 0.0f;
     57 
     58    if (svga_have_vgpu10(svga)) {
     59       if (svga->curr.reduced_prim == PIPE_PRIM_TRIANGLES) {
     60          adjy = 0.25;
     61       }
     62    }
     63    else {
     64       switch (svga->curr.reduced_prim) {
     65       case PIPE_PRIM_POINTS:
     66          adjx = SVGA_POINT_ADJ_X;
     67          adjy = SVGA_POINT_ADJ_Y;
     68          break;
     69       case PIPE_PRIM_LINES:
     70          /* XXX: This is to compensate for the fact that wide lines are
     71           * going to be drawn with triangles, but we're not catching all
     72           * cases where that will happen.
     73           */
     74          if (svga->curr.rast->need_pipeline & SVGA_PIPELINE_FLAG_LINES)
     75          {
     76             adjx = SVGA_LINE_ADJ_X + 0.175f;
     77             adjy = SVGA_LINE_ADJ_Y - 0.175f;
     78          }
     79          else {
     80             adjx = SVGA_LINE_ADJ_X;
     81             adjy = SVGA_LINE_ADJ_Y;
     82          }
     83          break;
     84       case PIPE_PRIM_TRIANGLES:
     85          adjx += SVGA_TRIANGLE_ADJ_X;
     86          adjy += SVGA_TRIANGLE_ADJ_Y;
     87          break;
     88       default:
     89          /* nothing */
     90          break;
     91       }
     92    }
     93 
     94    vp.translate[0] += adjx;
     95    vp.translate[1] += adjy;
     96 
     97    draw_set_viewport_states(svga->swtnl.draw, 0, 1, &vp);
     98 }
     99 
    100 static enum pipe_error
    101 update_swtnl_draw(struct svga_context *svga, unsigned dirty)
    102 {
    103    SVGA_STATS_TIME_PUSH(svga_sws(svga), SVGA_STATS_TIME_SWTNLUPDATEDRAW);
    104 
    105    draw_flush(svga->swtnl.draw);
    106 
    107    if (dirty & SVGA_NEW_VS)
    108       draw_bind_vertex_shader(svga->swtnl.draw,
    109                               svga->curr.vs->draw_shader);
    110 
    111    if (dirty & SVGA_NEW_FS)
    112       draw_bind_fragment_shader(svga->swtnl.draw,
    113                                 svga->curr.fs->draw_shader);
    114 
    115    if (dirty & SVGA_NEW_VBUFFER)
    116       draw_set_vertex_buffers(svga->swtnl.draw, 0,
    117                               svga->curr.num_vertex_buffers,
    118                               svga->curr.vb);
    119 
    120    if (dirty & SVGA_NEW_VELEMENT)
    121       draw_set_vertex_elements(svga->swtnl.draw,
    122                                svga->curr.velems->count,
    123                                svga->curr.velems->velem);
    124 
    125    if (dirty & SVGA_NEW_CLIP)
    126       draw_set_clip_state(svga->swtnl.draw,
    127                           &svga->curr.clip);
    128 
    129    if (dirty & (SVGA_NEW_VIEWPORT |
    130                 SVGA_NEW_REDUCED_PRIMITIVE |
    131                 SVGA_NEW_RAST))
    132       set_draw_viewport(svga);
    133 
    134    if (dirty & SVGA_NEW_RAST)
    135       draw_set_rasterizer_state(svga->swtnl.draw,
    136                                 &svga->curr.rast->templ,
    137                                 (void *) svga->curr.rast);
    138 
    139    /* Tell the draw module how deep the Z/depth buffer is.
    140     *
    141     * If no depth buffer is bound, send the utility function the
    142     * format for no bound depth (PIPE_FORMAT_NONE).
    143     */
    144    if (dirty & SVGA_NEW_FRAME_BUFFER)
    145       draw_set_zs_format(svga->swtnl.draw,
    146          (svga->curr.framebuffer.zsbuf) ?
    147              svga->curr.framebuffer.zsbuf->format : PIPE_FORMAT_NONE);
    148 
    149    SVGA_STATS_TIME_POP(svga_sws(svga));
    150    return PIPE_OK;
    151 }
    152 
    153 
    154 struct svga_tracked_state svga_update_swtnl_draw =
    155 {
    156    "update draw module state",
    157    (SVGA_NEW_VS |
    158     SVGA_NEW_VBUFFER |
    159     SVGA_NEW_VELEMENT |
    160     SVGA_NEW_CLIP |
    161     SVGA_NEW_VIEWPORT |
    162     SVGA_NEW_RAST |
    163     SVGA_NEW_FRAME_BUFFER |
    164     SVGA_NEW_REDUCED_PRIMITIVE),
    165    update_swtnl_draw
    166 };
    167 
    168 
    169 static SVGA3dSurfaceFormat
    170 translate_vertex_format(SVGA3dDeclType format)
    171 {
    172    switch (format) {
    173    case SVGA3D_DECLTYPE_FLOAT1:
    174       return SVGA3D_R32_FLOAT;
    175    case SVGA3D_DECLTYPE_FLOAT2:
    176       return SVGA3D_R32G32_FLOAT;
    177    case SVGA3D_DECLTYPE_FLOAT3:
    178       return SVGA3D_R32G32B32_FLOAT;
    179    case SVGA3D_DECLTYPE_FLOAT4:
    180       return SVGA3D_R32G32B32A32_FLOAT;
    181    default:
    182       assert(!"Unexpected format in translate_vertex_format()");
    183       return SVGA3D_R32G32B32A32_FLOAT;
    184    }
    185 }
    186 
    187 
    188 static SVGA3dElementLayoutId
    189 svga_vdecl_to_input_element(struct svga_context *svga,
    190                             const SVGA3dVertexDecl *vdecl, unsigned num_decls)
    191 {
    192    SVGA3dElementLayoutId id;
    193    SVGA3dInputElementDesc elements[PIPE_MAX_ATTRIBS];
    194    enum pipe_error ret;
    195    unsigned i;
    196 
    197    assert(num_decls <= PIPE_MAX_ATTRIBS);
    198    assert(svga_have_vgpu10(svga));
    199 
    200    for (i = 0; i < num_decls; i++) {
    201       elements[i].inputSlot = 0; /* vertex buffer index */
    202       elements[i].alignedByteOffset = vdecl[i].array.offset;
    203       elements[i].format = translate_vertex_format(vdecl[i].identity.type);
    204       elements[i].inputSlotClass = SVGA3D_INPUT_PER_VERTEX_DATA;
    205       elements[i].instanceDataStepRate = 0;
    206       elements[i].inputRegister = i;
    207    }
    208 
    209    id = util_bitmask_add(svga->input_element_object_id_bm);
    210 
    211    ret = SVGA3D_vgpu10_DefineElementLayout(svga->swc, num_decls, id, elements);
    212    if (ret != PIPE_OK) {
    213       svga_context_flush(svga, NULL);
    214       ret = SVGA3D_vgpu10_DefineElementLayout(svga->swc, num_decls,
    215                                               id, elements);
    216       assert(ret == PIPE_OK);
    217    }
    218 
    219    return id;
    220 }
    221 
    222 
    223 enum pipe_error
    224 svga_swtnl_update_vdecl(struct svga_context *svga)
    225 {
    226    struct svga_vbuf_render *svga_render = svga_vbuf_render(svga->swtnl.backend);
    227    struct draw_context *draw = svga->swtnl.draw;
    228    struct vertex_info *vinfo = &svga_render->vertex_info;
    229    SVGA3dVertexDecl vdecl[PIPE_MAX_ATTRIBS];
    230    struct svga_fragment_shader *fs = svga->curr.fs;
    231    int offset = 0;
    232    int nr_decls = 0;
    233    int src;
    234    unsigned i;
    235    int any_change;
    236 
    237    SVGA_STATS_TIME_PUSH(svga_sws(svga), SVGA_STATS_TIME_SWTNLUPDATEVDECL);
    238 
    239    memset(vinfo, 0, sizeof(*vinfo));
    240    memset(vdecl, 0, sizeof(vdecl));
    241 
    242    draw_prepare_shader_outputs(draw);
    243 
    244    /* always add position */
    245    src = draw_find_shader_output(draw, TGSI_SEMANTIC_POSITION, 0);
    246    draw_emit_vertex_attr(vinfo, EMIT_4F, src);
    247    vinfo->attrib[0].emit = EMIT_4F;
    248    vdecl[0].array.offset = offset;
    249    vdecl[0].identity.method = SVGA3D_DECLMETHOD_DEFAULT;
    250    vdecl[0].identity.type = SVGA3D_DECLTYPE_FLOAT4;
    251    vdecl[0].identity.usage = SVGA3D_DECLUSAGE_POSITIONT;
    252    vdecl[0].identity.usageIndex = 0;
    253    offset += 16;
    254    nr_decls++;
    255 
    256    for (i = 0; i < fs->base.info.num_inputs; i++) {
    257       const enum tgsi_semantic sem_name = fs->base.info.input_semantic_name[i];
    258       const unsigned sem_index = fs->base.info.input_semantic_index[i];
    259 
    260       src = draw_find_shader_output(draw, sem_name, sem_index);
    261 
    262       vdecl[nr_decls].array.offset = offset;
    263       vdecl[nr_decls].identity.usageIndex = sem_index;
    264 
    265       switch (sem_name) {
    266       case TGSI_SEMANTIC_COLOR:
    267          draw_emit_vertex_attr(vinfo, EMIT_4F, src);
    268          vdecl[nr_decls].identity.usage = SVGA3D_DECLUSAGE_COLOR;
    269          vdecl[nr_decls].identity.type = SVGA3D_DECLTYPE_FLOAT4;
    270          offset += 16;
    271          nr_decls++;
    272          break;
    273       case TGSI_SEMANTIC_GENERIC:
    274          draw_emit_vertex_attr(vinfo, EMIT_4F, src);
    275          vdecl[nr_decls].identity.usage = SVGA3D_DECLUSAGE_TEXCOORD;
    276          vdecl[nr_decls].identity.type = SVGA3D_DECLTYPE_FLOAT4;
    277          vdecl[nr_decls].identity.usageIndex =
    278             svga_remap_generic_index(fs->generic_remap_table, sem_index);
    279          offset += 16;
    280          nr_decls++;
    281          break;
    282       case TGSI_SEMANTIC_FOG:
    283          draw_emit_vertex_attr(vinfo, EMIT_1F, src);
    284          vdecl[nr_decls].identity.usage = SVGA3D_DECLUSAGE_TEXCOORD;
    285          vdecl[nr_decls].identity.type = SVGA3D_DECLTYPE_FLOAT1;
    286          assert(vdecl[nr_decls].identity.usageIndex == 0);
    287          offset += 4;
    288          nr_decls++;
    289          break;
    290       case TGSI_SEMANTIC_POSITION:
    291          /* generated internally, not a vertex shader output */
    292          break;
    293       default:
    294          assert(0);
    295       }
    296    }
    297 
    298    draw_compute_vertex_size(vinfo);
    299 
    300    svga_render->vdecl_count = nr_decls;
    301    for (i = 0; i < svga_render->vdecl_count; i++) {
    302       vdecl[i].array.stride = offset;
    303    }
    304 
    305    any_change = memcmp(svga_render->vdecl, vdecl, sizeof(vdecl));
    306 
    307    if (svga_have_vgpu10(svga)) {
    308       enum pipe_error ret;
    309 
    310       if (!any_change && svga_render->layout_id != SVGA3D_INVALID_ID) {
    311          goto done;
    312       }
    313 
    314       if (svga_render->layout_id != SVGA3D_INVALID_ID) {
    315          /* destroy old */
    316          ret = SVGA3D_vgpu10_DestroyElementLayout(svga->swc,
    317                                                   svga_render->layout_id);
    318          if (ret != PIPE_OK) {
    319             svga_context_flush(svga, NULL);
    320             ret = SVGA3D_vgpu10_DestroyElementLayout(svga->swc,
    321                                                      svga_render->layout_id);
    322             assert(ret == PIPE_OK);
    323          }
    324 
    325          /**
    326           * reset current layout id state after the element layout is
    327           * destroyed, so that if a new layout has the same layout id, we
    328           * will know to re-issue the SetInputLayout command.
    329           */
    330          if (svga->state.hw_draw.layout_id == svga_render->layout_id)
    331             svga->state.hw_draw.layout_id = SVGA3D_INVALID_ID;
    332 
    333          util_bitmask_clear(svga->input_element_object_id_bm,
    334                             svga_render->layout_id);
    335       }
    336 
    337       svga_render->layout_id =
    338          svga_vdecl_to_input_element(svga, vdecl, nr_decls);
    339 
    340       /* bind new */
    341       if (svga->state.hw_draw.layout_id != svga_render->layout_id) {
    342          ret = SVGA3D_vgpu10_SetInputLayout(svga->swc, svga_render->layout_id);
    343          if (ret != PIPE_OK) {
    344             svga_context_flush(svga, NULL);
    345             ret = SVGA3D_vgpu10_SetInputLayout(svga->swc,
    346                                                svga_render->layout_id);
    347             assert(ret == PIPE_OK);
    348          }
    349 
    350          svga->state.hw_draw.layout_id = svga_render->layout_id;
    351       }
    352    }
    353    else {
    354       if (!any_change)
    355          goto done;
    356    }
    357 
    358    memcpy(svga_render->vdecl, vdecl, sizeof(vdecl));
    359    svga->swtnl.new_vdecl = TRUE;
    360 
    361 done:
    362    SVGA_STATS_TIME_POP(svga_sws(svga));
    363    return PIPE_OK;
    364 }
    365 
    366 
    367 static enum pipe_error
    368 update_swtnl_vdecl(struct svga_context *svga, unsigned dirty)
    369 {
    370    return svga_swtnl_update_vdecl(svga);
    371 }
    372 
    373 
    374 struct svga_tracked_state svga_update_swtnl_vdecl =
    375 {
    376    "update draw module vdecl",
    377    (SVGA_NEW_VS |
    378     SVGA_NEW_FS),
    379    update_swtnl_vdecl
    380 };
    381