src/gallium/auxiliary/util/u_prim_restart.c

   1 /*
   2  * Copyright 2014 VMware, Inc.
   3  * All Rights Reserved.
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sub license, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial portions
  15  * of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  20  * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
  21  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  22  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  23  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  */
  25
  26
  27
  28 #include "u_inlines.h"
  29 #include "u_memory.h"
  30 #include "u_prim_restart.h"
  31
  32
  33 /**
  34  * Translate an index buffer for primitive restart.
  35  * Create a new index buffer which is a copy of the original index buffer
  36  * except that instances of 'restart_index' are converted to 0xffff or
  37  * 0xffffffff.
  38  * Also, index buffers using 1-byte indexes are converted to 2-byte indexes.
  39  */
  40 enum pipe_error
  41 util_translate_prim_restart_ib(struct pipe_context *context,
  42                                struct pipe_index_buffer *src_buffer,
  43                                struct pipe_resource **dst_buffer,
  44                                unsigned num_indexes,
  45                                unsigned restart_index)
  46 {
  47    struct pipe_screen *screen = context->screen;
  48    struct pipe_transfer *src_transfer = NULL, *dst_transfer = NULL;
  49    void *src_map = NULL, *dst_map = NULL;
  50    const unsigned src_index_size = src_buffer->index_size;
  51    unsigned dst_index_size;
  52
  53    /* 1-byte indexes are converted to 2-byte indexes, 4-byte stays 4-byte */
  54    dst_index_size = MAX2(2, src_buffer->index_size);
  55    assert(dst_index_size == 2 || dst_index_size == 4);
  56
  57    /* no user buffers for now */
  58    assert(src_buffer->user_buffer == NULL);
  59
  60    /* Create new index buffer */
  61    *dst_buffer = pipe_buffer_create(screen, PIPE_BIND_INDEX_BUFFER,
  62                                     PIPE_USAGE_STREAM,
  63                                     num_indexes * dst_index_size);
  64    if (!*dst_buffer)
  65       goto error;
  66
  67    /* Map new / dest index buffer */
  68    dst_map = pipe_buffer_map(context, *dst_buffer,
  69                              PIPE_TRANSFER_WRITE, &dst_transfer);
  70    if (!dst_map)
  71       goto error;
  72
  73    /* Map original / src index buffer */
  74    src_map = pipe_buffer_map_range(context, src_buffer->buffer,
  75                                    src_buffer->offset,
  76                                    num_indexes * src_index_size,
  77                                    PIPE_TRANSFER_READ,
  78                                    &src_transfer);
  79    if (!src_map)
  80       goto error;
  81
  82    if (src_index_size == 1 && dst_index_size == 2) {
  83       uint8_t *src = (uint8_t *) src_map;
  84       uint16_t *dst = (uint16_t *) dst_map;
  85       unsigned i;
  86       for (i = 0; i < num_indexes; i++) {
  87          dst[i] = (src[i] == restart_index) ? 0xffff : src[i];
  88       }
  89    }
  90    else if (src_index_size == 2 && dst_index_size == 2) {
  91       uint16_t *src = (uint16_t *) src_map;
  92       uint16_t *dst = (uint16_t *) dst_map;
  93       unsigned i;
  94       for (i = 0; i < num_indexes; i++) {
  95          dst[i] = (src[i] == restart_index) ? 0xffff : src[i];
  96       }
  97    }
  98    else {
  99       uint32_t *src = (uint32_t *) src_map;
 100       uint32_t *dst = (uint32_t *) dst_map;
 101       unsigned i;
 102       assert(src_index_size == 4);
 103       assert(dst_index_size == 4);
 104       for (i = 0; i < num_indexes; i++) {
 105          dst[i] = (src[i] == restart_index) ? 0xffffffff : src[i];
 106       }
 107    }
 108
 109    pipe_buffer_unmap(context, src_transfer);
 110    pipe_buffer_unmap(context, dst_transfer);
 111
 112    return PIPE_OK;
 113
 114 error:
 115    if (src_transfer)
 116       pipe_buffer_unmap(context, src_transfer);
 117    if (dst_transfer)
 118       pipe_buffer_unmap(context, dst_transfer);
 119    if (*dst_buffer)
 120       screen->resource_destroy(screen, *dst_buffer);
 121    return PIPE_ERROR_OUT_OF_MEMORY;
 122 }
 123
 124
 125 /** Helper structs for util_draw_vbo_without_prim_restart() */
 126
 127 struct range {
 128    unsigned start, count;
 129 };
 130
 131 struct range_info {
 132    struct range *ranges;
 133    unsigned count, max;
 134 };
 135
 136
 137 /**
 138  * Helper function for util_draw_vbo_without_prim_restart()
 139  * \return true for success, false if out of memory
 140  */
 141 static boolean
 142 add_range(struct range_info *info, unsigned start, unsigned count)
 143 {
 144    if (info->max == 0) {
 145       info->max = 10;
 146       info->ranges = MALLOC(info->max * sizeof(struct range));
 147       if (!info->ranges) {
 148          return FALSE;
 149       }
 150    }
 151    else if (info->count == info->max) {
 152       /* grow the ranges[] array */
 153       info->ranges = REALLOC(info->ranges,
 154                              info->max * sizeof(struct range),
 155                              2 * info->max * sizeof(struct range));
 156       if (!info->ranges) {
 157          return FALSE;
 158       }
 159
 160       info->max *= 2;
 161    }
 162
 163    /* save the range */
 164    info->ranges[info->count].start = start;
 165    info->ranges[info->count].count = count;
 166    info->count++;
 167
 168    return TRUE;
 169 }
 170
 171
 172 /**
 173  * Implement primitive restart by breaking an indexed primitive into
 174  * pieces which do not contain restart indexes.  Each piece is then
 175  * drawn by calling pipe_context::draw_vbo().
 176  * \return PIPE_OK if no error, an error code otherwise.
 177  */
 178 enum pipe_error
 179 util_draw_vbo_without_prim_restart(struct pipe_context *context,
 180                                    const struct pipe_index_buffer *ib,
 181                                    const struct pipe_draw_info *info)
 182 {
 183    const void *src_map;
 184    struct range_info ranges = {0};
 185    struct pipe_draw_info new_info;
 186    struct pipe_transfer *src_transfer = NULL;
 187    unsigned i, start, count;
 188
 189    assert(info->indexed);
 190    assert(info->primitive_restart);
 191
 192    /* Get pointer to the index data */
 193    if (ib->buffer) {
 194       /* map the index buffer (only the range we need to scan) */
 195       src_map = pipe_buffer_map_range(context, ib->buffer,
 196                                       ib->offset + info->start * ib->index_size,
 197                                       info->count * ib->index_size,
 198                                       PIPE_TRANSFER_READ,
 199                                       &src_transfer);
 200       if (!src_map) {
 201          return PIPE_ERROR_OUT_OF_MEMORY;
 202       }
 203    }
 204    else {
 205       if (!ib->user_buffer) {
 206          debug_printf("User-space index buffer is null!");
 207          return PIPE_ERROR_BAD_INPUT;
 208       }
 209       src_map = (const uint8_t *) ib->user_buffer
 210          + ib->offset
 211          + info->start * ib->index_size;
 212    }
 213
 214 #define SCAN_INDEXES(TYPE) \
 215    for (i = 0; i <= info->count; i++) { \
 216       if (i == info->count || \
 217           ((const TYPE *) src_map)[i] == info->restart_index) { \
 218          /* cut / restart */ \
 219          if (count > 0) { \
 220             if (!add_range(&ranges, info->start + start, count)) { \
 221                if (src_transfer) \
 222                   pipe_buffer_unmap(context, src_transfer); \
 223                return PIPE_ERROR_OUT_OF_MEMORY; \
 224             } \
 225          } \
 226          start = i + 1; \
 227          count = 0; \
 228       } \
 229       else { \
 230          count++; \
 231       } \
 232    }
 233
 234    start = info->start;
 235    count = 0;
 236    switch (ib->index_size) {
 237    case 1:
 238       SCAN_INDEXES(uint8_t);
 239       break;
 240    case 2:
 241       SCAN_INDEXES(uint16_t);
 242       break;
 243    case 4:
 244       SCAN_INDEXES(uint32_t);
 245       break;
 246    default:
 247       assert(!"Bad index size");
 248       return PIPE_ERROR_BAD_INPUT;
 249    }
 250
 251    /* unmap index buffer */
 252    if (src_transfer)
 253       pipe_buffer_unmap(context, src_transfer);
 254
 255    /* draw ranges between the restart indexes */
 256    new_info = *info;
 257    new_info.primitive_restart = FALSE;
 258    for (i = 0; i < ranges.count; i++) {
 259       new_info.start = ranges.ranges[i].start;
 260       new_info.count = ranges.ranges[i].count;
 261       context->draw_vbo(context, &new_info);
 262    }
 263
 264    FREE(ranges.ranges);
 265
 266    return PIPE_OK;
 267 }