kolibrios/drivers/video/Gallium/auxiliary/draw/draw_pt_vsplit.c

305 lines
8.7 KiB
C
Raw Normal View History

/*
* Mesa 3-D graphics library
*
* Copyright 2007-2008 Tungsten Graphics, Inc., Cedar Park, Texas.
* Copyright (C) 2010 LunarG Inc.
*
* 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, sublicense,
* 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 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 NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS 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 "util/u_math.h"
#include "util/u_memory.h"
#include "draw/draw_context.h"
#include "draw/draw_private.h"
#include "draw/draw_pt.h"
#define SEGMENT_SIZE 1024
#define MAP_SIZE 256
/* The largest possible index withing an index buffer */
#define MAX_ELT_IDX 0xffffffff
struct vsplit_frontend {
struct draw_pt_front_end base;
struct draw_context *draw;
unsigned prim;
struct draw_pt_middle_end *middle;
unsigned max_vertices;
ushort segment_size;
/* buffers for splitting */
unsigned fetch_elts[SEGMENT_SIZE];
ushort draw_elts[SEGMENT_SIZE];
ushort identity_draw_elts[SEGMENT_SIZE];
struct {
/* map a fetch element to a draw element */
unsigned fetches[MAP_SIZE];
ushort draws[MAP_SIZE];
boolean has_max_fetch;
ushort num_fetch_elts;
ushort num_draw_elts;
} cache;
};
static void
vsplit_clear_cache(struct vsplit_frontend *vsplit)
{
memset(vsplit->cache.fetches, 0xff, sizeof(vsplit->cache.fetches));
vsplit->cache.has_max_fetch = FALSE;
vsplit->cache.num_fetch_elts = 0;
vsplit->cache.num_draw_elts = 0;
}
static void
vsplit_flush_cache(struct vsplit_frontend *vsplit, unsigned flags)
{
vsplit->middle->run(vsplit->middle,
vsplit->fetch_elts, vsplit->cache.num_fetch_elts,
vsplit->draw_elts, vsplit->cache.num_draw_elts, flags);
}
/**
* Add a fetch element and add it to the draw elements.
*/
static INLINE void
vsplit_add_cache(struct vsplit_frontend *vsplit, unsigned fetch, unsigned ofbias)
{
unsigned hash;
hash = fetch % MAP_SIZE;
/* If the value isn't in the cache of it's an overflow due to the
* element bias */
if (vsplit->cache.fetches[hash] != fetch || ofbias) {
/* update cache */
vsplit->cache.fetches[hash] = fetch;
vsplit->cache.draws[hash] = vsplit->cache.num_fetch_elts;
/* add fetch */
assert(vsplit->cache.num_fetch_elts < vsplit->segment_size);
vsplit->fetch_elts[vsplit->cache.num_fetch_elts++] = fetch;
}
vsplit->draw_elts[vsplit->cache.num_draw_elts++] = vsplit->cache.draws[hash];
}
/**
* Returns the base index to the elements array.
* The value is checked for overflows (both integer overflows
* and the elements array overflow).
*/
static INLINE unsigned
vsplit_get_base_idx(struct vsplit_frontend *vsplit,
unsigned start, unsigned fetch, unsigned *ofbit)
{
struct draw_context *draw = vsplit->draw;
unsigned elt_idx = draw_overflow_uadd(start, fetch, MAX_ELT_IDX);
if (ofbit)
*ofbit = 0;
/* Overflown indices need to wrap to the first element
* in the index buffer */
if (elt_idx >= draw->pt.user.eltMax) {
if (ofbit)
*ofbit = 1;
elt_idx = 0;
}
return elt_idx;
}
/**
* Returns the element index adjust for the element bias.
* The final element index is created from the actual element
* index, plus the element bias, clamped to maximum elememt
* index if that addition overflows.
*/
static INLINE unsigned
vsplit_get_bias_idx(struct vsplit_frontend *vsplit,
int idx, int bias, unsigned *ofbias)
{
int res = idx + bias;
if (ofbias)
*ofbias = 0;
if (idx > 0 && bias > 0) {
if (res < idx || res < bias) {
res = DRAW_MAX_FETCH_IDX;
if (ofbias)
*ofbias = 1;
}
} else if (idx < 0 && bias < 0) {
if (res > idx || res > bias) {
res = DRAW_MAX_FETCH_IDX;
if (ofbias)
*ofbias = 1;
}
}
return res;
}
#define VSPLIT_CREATE_IDX(elts, start, fetch, elt_bias) \
unsigned elt_idx; \
unsigned ofbit; \
unsigned ofbias; \
elt_idx = vsplit_get_base_idx(vsplit, start, fetch, &ofbit); \
elt_idx = vsplit_get_bias_idx(vsplit, ofbit ? 0 : DRAW_GET_IDX(elts, elt_idx), elt_bias, &ofbias)
static INLINE void
vsplit_add_cache_ubyte(struct vsplit_frontend *vsplit, const ubyte *elts,
unsigned start, unsigned fetch, int elt_bias)
{
struct draw_context *draw = vsplit->draw;
VSPLIT_CREATE_IDX(elts, start, fetch, elt_bias);
vsplit_add_cache(vsplit, elt_idx, ofbias);
}
static INLINE void
vsplit_add_cache_ushort(struct vsplit_frontend *vsplit, const ushort *elts,
unsigned start, unsigned fetch, int elt_bias)
{
struct draw_context *draw = vsplit->draw;
VSPLIT_CREATE_IDX(elts, start, fetch, elt_bias);
vsplit_add_cache(vsplit, elt_idx, ofbias);
}
/**
* Add a fetch element and add it to the draw elements. The fetch element is
* in full range (uint).
*/
static INLINE void
vsplit_add_cache_uint(struct vsplit_frontend *vsplit, const uint *elts,
unsigned start, unsigned fetch, int elt_bias)
{
struct draw_context *draw = vsplit->draw;
unsigned raw_elem_idx = start + fetch + elt_bias;
VSPLIT_CREATE_IDX(elts, start, fetch, elt_bias);
/* special care for DRAW_MAX_FETCH_IDX */
if (raw_elem_idx == DRAW_MAX_FETCH_IDX && !vsplit->cache.has_max_fetch) {
unsigned hash = fetch % MAP_SIZE;
vsplit->cache.fetches[hash] = raw_elem_idx - 1; /* force update */
vsplit->cache.has_max_fetch = TRUE;
}
vsplit_add_cache(vsplit, elt_idx, ofbias);
}
#define FUNC vsplit_run_linear
#include "draw_pt_vsplit_tmp.h"
#define FUNC vsplit_run_ubyte
#define ELT_TYPE ubyte
#define ADD_CACHE(vsplit, ib, start, fetch, bias) vsplit_add_cache_ubyte(vsplit,ib,start,fetch,bias)
#include "draw_pt_vsplit_tmp.h"
#define FUNC vsplit_run_ushort
#define ELT_TYPE ushort
#define ADD_CACHE(vsplit, ib, start, fetch, bias) vsplit_add_cache_ushort(vsplit,ib,start,fetch, bias)
#include "draw_pt_vsplit_tmp.h"
#define FUNC vsplit_run_uint
#define ELT_TYPE uint
#define ADD_CACHE(vsplit, ib, start, fetch, bias) vsplit_add_cache_uint(vsplit, ib, start, fetch, bias)
#include "draw_pt_vsplit_tmp.h"
static void vsplit_prepare(struct draw_pt_front_end *frontend,
unsigned in_prim,
struct draw_pt_middle_end *middle,
unsigned opt)
{
struct vsplit_frontend *vsplit = (struct vsplit_frontend *) frontend;
switch (vsplit->draw->pt.user.eltSize) {
case 0:
vsplit->base.run = vsplit_run_linear;
break;
case 1:
vsplit->base.run = vsplit_run_ubyte;
break;
case 2:
vsplit->base.run = vsplit_run_ushort;
break;
case 4:
vsplit->base.run = vsplit_run_uint;
break;
default:
assert(0);
break;
}
/* split only */
vsplit->prim = in_prim;
vsplit->middle = middle;
middle->prepare(middle, vsplit->prim, opt, &vsplit->max_vertices);
vsplit->segment_size = MIN2(SEGMENT_SIZE, vsplit->max_vertices);
}
static void vsplit_flush(struct draw_pt_front_end *frontend, unsigned flags)
{
struct vsplit_frontend *vsplit = (struct vsplit_frontend *) frontend;
if (flags & DRAW_FLUSH_STATE_CHANGE) {
vsplit->middle->finish(vsplit->middle);
vsplit->middle = NULL;
}
}
static void vsplit_destroy(struct draw_pt_front_end *frontend)
{
FREE(frontend);
}
struct draw_pt_front_end *draw_pt_vsplit(struct draw_context *draw)
{
struct vsplit_frontend *vsplit = CALLOC_STRUCT(vsplit_frontend);
ushort i;
if (!vsplit)
return NULL;
vsplit->base.prepare = vsplit_prepare;
vsplit->base.run = NULL;
vsplit->base.flush = vsplit_flush;
vsplit->base.destroy = vsplit_destroy;
vsplit->draw = draw;
for (i = 0; i < SEGMENT_SIZE; i++)
vsplit->identity_draw_elts[i] = i;
return &vsplit->base;
}