src/gallium/drivers/swr/swr_draw.cpp

   1 /****************************************************************************
   2  * Copyright (C) 2015 Intel Corporation.   All Rights Reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  ***************************************************************************/
  23
  24 #include "swr_screen.h"
  25 #include "swr_context.h"
  26 #include "swr_resource.h"
  27 #include "swr_fence.h"
  28 #include "swr_query.h"
  29 #include "jit_api.h"
  30
  31 #include "util/u_draw.h"
  32 #include "util/u_prim.h"
  33
  34 /*
  35  * Convert mesa PIPE_PRIM_X to SWR enum PRIMITIVE_TOPOLOGY
  36  */
  37 static INLINE enum PRIMITIVE_TOPOLOGY
  38 swr_convert_prim_topology(const unsigned mode)
  39 {
  40    switch (mode) {
  41    case PIPE_PRIM_POINTS:
  42       return TOP_POINT_LIST;
  43    case PIPE_PRIM_LINES:
  44       return TOP_LINE_LIST;
  45    case PIPE_PRIM_LINE_LOOP:
  46       return TOP_LINE_LOOP;
  47    case PIPE_PRIM_LINE_STRIP:
  48       return TOP_LINE_STRIP;
  49    case PIPE_PRIM_TRIANGLES:
  50       return TOP_TRIANGLE_LIST;
  51    case PIPE_PRIM_TRIANGLE_STRIP:
  52       return TOP_TRIANGLE_STRIP;
  53    case PIPE_PRIM_TRIANGLE_FAN:
  54       return TOP_TRIANGLE_FAN;
  55    case PIPE_PRIM_QUADS:
  56       return TOP_QUAD_LIST;
  57    case PIPE_PRIM_QUAD_STRIP:
  58       return TOP_QUAD_STRIP;
  59    case PIPE_PRIM_POLYGON:
  60       return TOP_TRIANGLE_FAN; /* XXX TOP_POLYGON; */
  61    case PIPE_PRIM_LINES_ADJACENCY:
  62       return TOP_LINE_LIST_ADJ;
  63    case PIPE_PRIM_LINE_STRIP_ADJACENCY:
  64       return TOP_LISTSTRIP_ADJ;
  65    case PIPE_PRIM_TRIANGLES_ADJACENCY:
  66       return TOP_TRI_LIST_ADJ;
  67    case PIPE_PRIM_TRIANGLE_STRIP_ADJACENCY:
  68       return TOP_TRI_STRIP_ADJ;
  69    default:
  70       assert(0 && "Unknown topology");
  71       return TOP_UNKNOWN;
  72    }
  73 };
  74
  75
  76 /*
  77  * Draw vertex arrays, with optional indexing, optional instancing.
  78  */
  79 static void
  80 swr_draw_vbo(struct pipe_context *pipe, const struct pipe_draw_info *info)
  81 {
  82    struct swr_context *ctx = swr_context(pipe);
  83
  84    if (!swr_check_render_cond(pipe))
  85       return;
  86
  87    if (info->indirect) {
  88       util_draw_indirect(pipe, info);
  89       return;
  90    }
  91
  92    /* Update derived state, pass draw info to update function */
  93    if (ctx->dirty)
  94       swr_update_derived(pipe, info);
  95
  96    swr_update_draw_context(ctx);
  97
  98    if (ctx->vs->pipe.stream_output.num_outputs) {
  99       if (!ctx->vs->soFunc[info->mode]) {
 100          STREAMOUT_COMPILE_STATE state = {0};
 101          struct pipe_stream_output_info *so = &ctx->vs->pipe.stream_output;
 102
 103          state.numVertsPerPrim = u_vertices_per_prim(info->mode);
 104
 105          uint32_t offsets[MAX_SO_STREAMS] = {0};
 106          uint32_t num = 0;
 107
 108          for (uint32_t i = 0; i < so->num_outputs; i++) {
 109             assert(so->output[i].stream == 0); // @todo
 110             uint32_t output_buffer = so->output[i].output_buffer;
 111             if (so->output[i].dst_offset != offsets[output_buffer]) {
 112                // hole - need to fill
 113                state.stream.decl[num].bufferIndex = output_buffer;
 114                state.stream.decl[num].hole = true;
 115                state.stream.decl[num].componentMask =
 116                   (1 << (so->output[i].dst_offset - offsets[output_buffer]))
 117                   - 1;
 118                num++;
 119                offsets[output_buffer] = so->output[i].dst_offset;
 120             }
 121
 122             state.stream.decl[num].bufferIndex = output_buffer;
 123             state.stream.decl[num].attribSlot = so->output[i].register_index - 1;
 124             state.stream.decl[num].componentMask =
 125                ((1 << so->output[i].num_components) - 1)
 126                << so->output[i].start_component;
 127             state.stream.decl[num].hole = false;
 128             num++;
 129
 130             offsets[output_buffer] += so->output[i].num_components;
 131          }
 132
 133          state.stream.numDecls = num;
 134
 135          HANDLE hJitMgr = swr_screen(pipe->screen)->hJitMgr;
 136          ctx->vs->soFunc[info->mode] = JitCompileStreamout(hJitMgr, state);
 137          debug_printf("so shader    %p\n", ctx->vs->soFunc[info->mode]);
 138          assert(ctx->vs->soFunc[info->mode] && "Error: SoShader = NULL");
 139       }
 140
 141       SwrSetSoFunc(ctx->swrContext, ctx->vs->soFunc[info->mode], 0);
 142    }
 143
 144    struct swr_vertex_element_state *velems = ctx->velems;
 145    if (!velems->fsFunc
 146        || (velems->fsState.cutIndex != info->restart_index)
 147        || (velems->fsState.bEnableCutIndex != info->primitive_restart)) {
 148
 149       velems->fsState.cutIndex = info->restart_index;
 150       velems->fsState.bEnableCutIndex = info->primitive_restart;
 151
 152       /* Create Fetch Shader */
 153       HANDLE hJitMgr = swr_screen(ctx->pipe.screen)->hJitMgr;
 154       velems->fsFunc = JitCompileFetch(hJitMgr, velems->fsState);
 155
 156       debug_printf("fetch shader %p\n", velems->fsFunc);
 157       assert(velems->fsFunc && "Error: FetchShader = NULL");
 158    }
 159
 160    SwrSetFetchFunc(ctx->swrContext, velems->fsFunc);
 161
 162    /* Set up frontend state
 163     * XXX setup provokingVertex & topologyProvokingVertex */
 164    SWR_FRONTEND_STATE feState = {0};
 165    if (ctx->rasterizer->flatshade_first) {
 166       feState.provokingVertex = {1, 0, 0};
 167    } else {
 168       feState.provokingVertex = {2, 1, 2};
 169    }
 170
 171    switch (info->mode) {
 172    case PIPE_PRIM_TRIANGLE_FAN:
 173       feState.topologyProvokingVertex = feState.provokingVertex.triFan;
 174       break;
 175    case PIPE_PRIM_TRIANGLE_STRIP:
 176    case PIPE_PRIM_TRIANGLES:
 177       feState.topologyProvokingVertex = feState.provokingVertex.triStripList;
 178       break;
 179    case PIPE_PRIM_QUAD_STRIP:
 180    case PIPE_PRIM_QUADS:
 181       if (ctx->rasterizer->flatshade_first)
 182          feState.topologyProvokingVertex = 0;
 183       else
 184          feState.topologyProvokingVertex = 3;
 185       break;
 186    case PIPE_PRIM_LINES:
 187    case PIPE_PRIM_LINE_LOOP:
 188    case PIPE_PRIM_LINE_STRIP:
 189       feState.topologyProvokingVertex = feState.provokingVertex.lineStripList;
 190       break;
 191    default:
 192       feState.topologyProvokingVertex = 0;
 193    }
 194
 195    feState.bEnableCutIndex = info->primitive_restart;
 196    SwrSetFrontendState(ctx->swrContext, &feState);
 197
 198    if (info->indexed)
 199       SwrDrawIndexedInstanced(ctx->swrContext,
 200                               swr_convert_prim_topology(info->mode),
 201                               info->count,
 202                               info->instance_count,
 203                               info->start,
 204                               info->index_bias,
 205                               info->start_instance);
 206    else
 207       SwrDrawInstanced(ctx->swrContext,
 208                        swr_convert_prim_topology(info->mode),
 209                        info->count,
 210                        info->instance_count,
 211                        info->start,
 212                        info->start_instance);
 213 }
 214
 215
 216 static void
 217 swr_flush(struct pipe_context *pipe,
 218           struct pipe_fence_handle **fence,
 219           unsigned flags)
 220 {
 221    struct swr_context *ctx = swr_context(pipe);
 222    struct swr_screen *screen = swr_screen(pipe->screen);
 223    struct pipe_surface *cb = ctx->framebuffer.cbufs[0];
 224
 225    /* If the current renderTarget is the display surface, store tiles back to
 226     * the surface, in preparation for present (swr_flush_frontbuffer).
 227     * Other renderTargets get stored back when attachment changes or
 228     * swr_surface_destroy */
 229    if (cb && swr_resource(cb->texture)->display_target)
 230       swr_store_dirty_resource(pipe, cb->texture, SWR_TILE_RESOLVED);
 231
 232    if (fence)
 233       swr_fence_reference(pipe->screen, fence, screen->flush_fence);
 234 }
 235
 236 void
 237 swr_finish(struct pipe_context *pipe)
 238 {
 239    struct pipe_fence_handle *fence = nullptr;
 240
 241    swr_flush(pipe, &fence, 0);
 242    swr_fence_finish(pipe->screen, NULL, fence, 0);
 243    swr_fence_reference(pipe->screen, &fence, NULL);
 244 }
 245
 246
 247 /*
 248  * Store SWR HotTiles back to renderTarget surface.
 249  */
 250 void
 251 swr_store_render_target(struct pipe_context *pipe,
 252                         uint32_t attachment,
 253                         enum SWR_TILE_STATE post_tile_state)
 254 {
 255    struct swr_context *ctx = swr_context(pipe);
 256    struct swr_draw_context *pDC = &ctx->swrDC;
 257    struct SWR_SURFACE_STATE *renderTarget = &pDC->renderTargets[attachment];
 258
 259    /* Only proceed if there's a valid surface to store to */
 260    if (renderTarget->pBaseAddress) {
 261       swr_update_draw_context(ctx);
 262       SWR_RECT full_rect =
 263          {0, 0, (int32_t)renderTarget->width, (int32_t)renderTarget->height};
 264       SwrStoreTiles(ctx->swrContext,
 265                     1 << attachment,
 266                     post_tile_state,
 267                     full_rect);
 268    }
 269 }
 270
 271 void
 272 swr_store_dirty_resource(struct pipe_context *pipe,
 273                          struct pipe_resource *resource,
 274                          enum SWR_TILE_STATE post_tile_state)
 275 {
 276    /* Only store resource if it has been written to */
 277    if (swr_resource(resource)->status & SWR_RESOURCE_WRITE) {
 278       struct swr_context *ctx = swr_context(pipe);
 279       struct swr_screen *screen = swr_screen(pipe->screen);
 280       struct swr_resource *spr = swr_resource(resource);
 281
 282       swr_draw_context *pDC = &ctx->swrDC;
 283       SWR_SURFACE_STATE *renderTargets = pDC->renderTargets;
 284       for (uint32_t i = 0; i < SWR_NUM_ATTACHMENTS; i++)
 285          if (renderTargets[i].pBaseAddress == spr->swr.pBaseAddress) {
 286             swr_store_render_target(pipe, i, post_tile_state);
 287
 288             /* Mesa thinks depth/stencil are fused, so we'll never get an
 289              * explicit resource for stencil.  So, if checking depth, then
 290              * also check for stencil. */
 291             if (spr->has_stencil && (i == SWR_ATTACHMENT_DEPTH)) {
 292                swr_store_render_target(
 293                   pipe, SWR_ATTACHMENT_STENCIL, post_tile_state);
 294             }
 295
 296             /* This fence signals StoreTiles completion */
 297             swr_fence_submit(ctx, screen->flush_fence);
 298
 299             break;
 300          }
 301    }
 302 }
 303
 304 void
 305 swr_draw_init(struct pipe_context *pipe)
 306 {
 307    pipe->draw_vbo = swr_draw_vbo;
 308    pipe->flush = swr_flush;
 309 }