| /* |
| * Copyright 2014 VMware, Inc. |
| * All Rights Reserved. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the |
| * "Software"), to deal in the Software without restriction, including |
| * without limitation the rights to use, copy, modify, merge, publish, |
| * distribute, sub license, and/or sell copies of the Software, and to |
| * permit persons to whom the Software is furnished to do so, subject to |
| * the following conditions: |
| * |
| * The above copyright notice and this permission notice (including the |
| * next paragraph) shall be included in all copies or substantial portions |
| * of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
| * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. |
| * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR |
| * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
| * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
| * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| */ |
| |
| |
| |
| #include "u_inlines.h" |
| #include "u_memory.h" |
| #include "u_prim_restart.h" |
| |
| |
| /** |
| * Translate an index buffer for primitive restart. |
| * Create a new index buffer which is a copy of the original index buffer |
| * except that instances of 'restart_index' are converted to 0xffff or |
| * 0xffffffff. |
| * Also, index buffers using 1-byte indexes are converted to 2-byte indexes. |
| */ |
| enum pipe_error |
| util_translate_prim_restart_ib(struct pipe_context *context, |
| const struct pipe_draw_info *info, |
| struct pipe_resource **dst_buffer) |
| { |
| struct pipe_screen *screen = context->screen; |
| struct pipe_transfer *src_transfer = NULL, *dst_transfer = NULL; |
| void *src_map = NULL, *dst_map = NULL; |
| const unsigned src_index_size = info->index_size; |
| unsigned dst_index_size; |
| |
| /* 1-byte indexes are converted to 2-byte indexes, 4-byte stays 4-byte */ |
| dst_index_size = MAX2(2, info->index_size); |
| assert(dst_index_size == 2 || dst_index_size == 4); |
| |
| /* no user buffers for now */ |
| assert(!info->has_user_indices); |
| |
| /* Create new index buffer */ |
| *dst_buffer = pipe_buffer_create(screen, PIPE_BIND_INDEX_BUFFER, |
| PIPE_USAGE_STREAM, |
| info->count * dst_index_size); |
| if (!*dst_buffer) |
| goto error; |
| |
| /* Map new / dest index buffer */ |
| dst_map = pipe_buffer_map(context, *dst_buffer, |
| PIPE_TRANSFER_WRITE, &dst_transfer); |
| if (!dst_map) |
| goto error; |
| |
| /* Map original / src index buffer */ |
| src_map = pipe_buffer_map_range(context, info->index.resource, |
| info->start * src_index_size, |
| info->count * src_index_size, |
| PIPE_TRANSFER_READ, |
| &src_transfer); |
| if (!src_map) |
| goto error; |
| |
| if (src_index_size == 1 && dst_index_size == 2) { |
| uint8_t *src = (uint8_t *) src_map; |
| uint16_t *dst = (uint16_t *) dst_map; |
| unsigned i; |
| for (i = 0; i < info->count; i++) { |
| dst[i] = (src[i] == info->restart_index) ? 0xffff : src[i]; |
| } |
| } |
| else if (src_index_size == 2 && dst_index_size == 2) { |
| uint16_t *src = (uint16_t *) src_map; |
| uint16_t *dst = (uint16_t *) dst_map; |
| unsigned i; |
| for (i = 0; i < info->count; i++) { |
| dst[i] = (src[i] == info->restart_index) ? 0xffff : src[i]; |
| } |
| } |
| else { |
| uint32_t *src = (uint32_t *) src_map; |
| uint32_t *dst = (uint32_t *) dst_map; |
| unsigned i; |
| assert(src_index_size == 4); |
| assert(dst_index_size == 4); |
| for (i = 0; i < info->count; i++) { |
| dst[i] = (src[i] == info->restart_index) ? 0xffffffff : src[i]; |
| } |
| } |
| |
| pipe_buffer_unmap(context, src_transfer); |
| pipe_buffer_unmap(context, dst_transfer); |
| |
| return PIPE_OK; |
| |
| error: |
| if (src_transfer) |
| pipe_buffer_unmap(context, src_transfer); |
| if (dst_transfer) |
| pipe_buffer_unmap(context, dst_transfer); |
| if (*dst_buffer) |
| pipe_resource_reference(dst_buffer, NULL); |
| return PIPE_ERROR_OUT_OF_MEMORY; |
| } |
| |
| |
| /** Helper structs for util_draw_vbo_without_prim_restart() */ |
| |
| struct range { |
| unsigned start, count; |
| }; |
| |
| struct range_info { |
| struct range *ranges; |
| unsigned count, max; |
| }; |
| |
| |
| /** |
| * Helper function for util_draw_vbo_without_prim_restart() |
| * \return true for success, false if out of memory |
| */ |
| static boolean |
| add_range(struct range_info *info, unsigned start, unsigned count) |
| { |
| if (info->max == 0) { |
| info->max = 10; |
| info->ranges = MALLOC(info->max * sizeof(struct range)); |
| if (!info->ranges) { |
| return FALSE; |
| } |
| } |
| else if (info->count == info->max) { |
| /* grow the ranges[] array */ |
| info->ranges = REALLOC(info->ranges, |
| info->max * sizeof(struct range), |
| 2 * info->max * sizeof(struct range)); |
| if (!info->ranges) { |
| return FALSE; |
| } |
| |
| info->max *= 2; |
| } |
| |
| /* save the range */ |
| info->ranges[info->count].start = start; |
| info->ranges[info->count].count = count; |
| info->count++; |
| |
| return TRUE; |
| } |
| |
| |
| /** |
| * Implement primitive restart by breaking an indexed primitive into |
| * pieces which do not contain restart indexes. Each piece is then |
| * drawn by calling pipe_context::draw_vbo(). |
| * \return PIPE_OK if no error, an error code otherwise. |
| */ |
| enum pipe_error |
| util_draw_vbo_without_prim_restart(struct pipe_context *context, |
| const struct pipe_draw_info *info) |
| { |
| const void *src_map; |
| struct range_info ranges = {0}; |
| struct pipe_draw_info new_info; |
| struct pipe_transfer *src_transfer = NULL; |
| unsigned i, start, count; |
| |
| assert(info->index_size); |
| assert(info->primitive_restart); |
| |
| /* Get pointer to the index data */ |
| if (!info->has_user_indices) { |
| /* map the index buffer (only the range we need to scan) */ |
| src_map = pipe_buffer_map_range(context, info->index.resource, |
| info->start * info->index_size, |
| info->count * info->index_size, |
| PIPE_TRANSFER_READ, |
| &src_transfer); |
| if (!src_map) { |
| return PIPE_ERROR_OUT_OF_MEMORY; |
| } |
| } |
| else { |
| if (!info->index.user) { |
| debug_printf("User-space index buffer is null!"); |
| return PIPE_ERROR_BAD_INPUT; |
| } |
| src_map = (const uint8_t *) info->index.user |
| + info->start * info->index_size; |
| } |
| |
| #define SCAN_INDEXES(TYPE) \ |
| for (i = 0; i <= info->count; i++) { \ |
| if (i == info->count || \ |
| ((const TYPE *) src_map)[i] == info->restart_index) { \ |
| /* cut / restart */ \ |
| if (count > 0) { \ |
| if (!add_range(&ranges, info->start + start, count)) { \ |
| if (src_transfer) \ |
| pipe_buffer_unmap(context, src_transfer); \ |
| return PIPE_ERROR_OUT_OF_MEMORY; \ |
| } \ |
| } \ |
| start = i + 1; \ |
| count = 0; \ |
| } \ |
| else { \ |
| count++; \ |
| } \ |
| } |
| |
| start = 0; |
| count = 0; |
| switch (info->index_size) { |
| case 1: |
| SCAN_INDEXES(uint8_t); |
| break; |
| case 2: |
| SCAN_INDEXES(uint16_t); |
| break; |
| case 4: |
| SCAN_INDEXES(uint32_t); |
| break; |
| default: |
| assert(!"Bad index size"); |
| return PIPE_ERROR_BAD_INPUT; |
| } |
| |
| /* unmap index buffer */ |
| if (src_transfer) |
| pipe_buffer_unmap(context, src_transfer); |
| |
| /* draw ranges between the restart indexes */ |
| new_info = *info; |
| new_info.primitive_restart = FALSE; |
| for (i = 0; i < ranges.count; i++) { |
| new_info.start = ranges.ranges[i].start; |
| new_info.count = ranges.ranges[i].count; |
| context->draw_vbo(context, &new_info); |
| } |
| |
| FREE(ranges.ranges); |
| |
| return PIPE_OK; |
| } |