src/gallium/auxiliary/indices/u_primconvert.c

   1 /*
   2  * Copyright (C) 2013 Rob Clark <robclark@freedesktop.org>
   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 FROM,
  20  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  21  * SOFTWARE.
  22  *
  23  * Authors:
  24  *    Rob Clark <robclark@freedesktop.org>
  25  */
  26
  27 /**
  28  * This module converts provides a more convenient front-end to u_indices,
  29  * etc, utils to convert primitive types supported not supported by the
  30  * hardware.  It handles binding new index buffer state, and restoring
  31  * previous state after.  To use, put something like this at the front of
  32  * drivers pipe->draw_vbo():
  33  *
  34  *    // emulate unsupported primitives:
  35  *    if (info->mode needs emulating) {
  36  *       util_primconvert_save_rasterizer_state(ctx->primconvert, ctx->rasterizer);
  37  *       util_primconvert_draw_vbo(ctx->primconvert, info);
  38  *       return;
  39  *    }
  40  *
  41  */
  42
  43 #include "pipe/p_state.h"
  44 #include "util/u_draw.h"
  45 #include "util/u_inlines.h"
  46 #include "util/u_memory.h"
  47 #include "util/u_upload_mgr.h"
  48
  49 #include "indices/u_indices.h"
  50 #include "indices/u_primconvert.h"
  51
  52 struct primconvert_context
  53 {
  54    struct pipe_context *pipe;
  55    struct primconvert_config cfg;
  56    unsigned api_pv;
  57 };
  58
  59
  60 struct primconvert_context *
  61 util_primconvert_create_config(struct pipe_context *pipe,
  62                                struct primconvert_config *cfg)
  63 {
  64    struct primconvert_context *pc = CALLOC_STRUCT(primconvert_context);
  65    if (!pc)
  66       return NULL;
  67    pc->pipe = pipe;
  68    pc->cfg = *cfg;
  69    return pc;
  70 }
  71
  72 struct primconvert_context *
  73 util_primconvert_create(struct pipe_context *pipe, uint32_t primtypes_mask)
  74 {
  75    struct primconvert_config cfg = { .primtypes_mask = primtypes_mask };
  76    return util_primconvert_create_config(pipe, &cfg);
  77 }
  78
  79 void
  80 util_primconvert_destroy(struct primconvert_context *pc)
  81 {
  82    FREE(pc);
  83 }
  84
  85 void
  86 util_primconvert_save_rasterizer_state(struct primconvert_context *pc,
  87                                        const struct pipe_rasterizer_state
  88                                        *rast)
  89 {
  90    /* if we actually translated the provoking vertex for the buffer,
  91     * we would actually need to save/restore rasterizer state.  As
  92     * it is, we just need to make note of the pv.
  93     */
  94    pc->api_pv = rast->flatshade_first ? PV_FIRST : PV_LAST;
  95 }
  96
  97 void
  98 util_primconvert_draw_vbo(struct primconvert_context *pc,
  99                           const struct pipe_draw_info *info)
 100 {
 101    struct pipe_draw_info new_info;
 102    struct pipe_transfer *src_transfer = NULL;
 103    u_translate_func trans_func;
 104    u_generate_func gen_func;
 105    const void *src = NULL;
 106    void *dst;
 107    unsigned ib_offset;
 108
 109    util_draw_init_info(&new_info);
 110    new_info.min_index = info->min_index;
 111    new_info.max_index = info->max_index;
 112    new_info.index_bias = info->index_bias;
 113    new_info.start_instance = info->start_instance;
 114    new_info.instance_count = info->instance_count;
 115    new_info.primitive_restart = info->primitive_restart;
 116    new_info.restart_index = info->restart_index;
 117    if (info->index_size) {
 118       enum pipe_prim_type mode = 0;
 119       unsigned index_size;
 120
 121       u_index_translator(pc->cfg.primtypes_mask,
 122                          info->mode, info->index_size, info->count,
 123                          pc->api_pv, pc->api_pv,
 124                          info->primitive_restart ? PR_ENABLE : PR_DISABLE,
 125                          &mode, &index_size, &new_info.count,
 126                          &trans_func);
 127       new_info.mode = mode;
 128       new_info.index_size = index_size;
 129       src = info->has_user_indices ? info->index.user : NULL;
 130       if (!src) {
 131          src = pipe_buffer_map(pc->pipe, info->index.resource,
 132                                PIPE_TRANSFER_READ, &src_transfer);
 133       }
 134       src = (const uint8_t *)src;
 135    }
 136    else {
 137       enum pipe_prim_type mode = 0;
 138       unsigned index_size;
 139
 140       u_index_generator(pc->cfg.primtypes_mask,
 141                         info->mode, info->start, info->count,
 142                         pc->api_pv, pc->api_pv,
 143                         &mode, &index_size, &new_info.count,
 144                         &gen_func);
 145       new_info.mode = mode;
 146       new_info.index_size = index_size;
 147    }
 148
 149    u_upload_alloc(pc->pipe->stream_uploader, 0, new_info.index_size * new_info.count, 4,
 150                   &ib_offset, &new_info.index.resource, &dst);
 151    new_info.start = ib_offset / new_info.index_size;
 152
 153    if (info->index_size) {
 154       trans_func(src, info->start, info->count, new_info.count, info->restart_index, dst);
 155    }
 156    else {
 157       gen_func(info->start, new_info.count, dst);
 158    }
 159
 160    if (src_transfer)
 161       pipe_buffer_unmap(pc->pipe, src_transfer);
 162
 163    u_upload_unmap(pc->pipe->stream_uploader);
 164
 165    /* to the translated draw: */
 166    pc->pipe->draw_vbo(pc->pipe, &new_info);
 167
 168    pipe_resource_reference(&new_info.index.resource, NULL);
 169 }