FREE( tc->tile );
if (tc->transfer) {
- tc->pipe->transfer_destroy(tc->pipe, tc->transfer);
+ tc->pipe->transfer_unmap(tc->pipe, tc->transfer);
}
FREE( tc );
{
struct pipe_context *pipe = tc->pipe;
- if (tc->transfer) {
+ if (tc->transfer_map) {
if (ps == tc->surface)
return;
- if (tc->transfer_map) {
- pipe->transfer_unmap(pipe, tc->transfer);
- tc->transfer_map = NULL;
- }
-
- pipe->transfer_destroy(pipe, tc->transfer);
+ pipe->transfer_unmap(pipe, tc->transfer);
tc->transfer = NULL;
+ tc->transfer_map = NULL;
}
tc->surface = ps;
if (ps) {
- tc->transfer = pipe_get_transfer(pipe, ps->texture,
- ps->u.tex.level, ps->u.tex.first_layer,
- PIPE_TRANSFER_READ_WRITE |
- PIPE_TRANSFER_UNSYNCHRONIZED,
- 0, 0, ps->width, ps->height);
-
- tc->depth_stencil = (ps->format == PIPE_FORMAT_Z24_UNORM_S8_USCALED ||
- ps->format == PIPE_FORMAT_Z24X8_UNORM ||
- ps->format == PIPE_FORMAT_S8_USCALED_Z24_UNORM ||
- ps->format == PIPE_FORMAT_X8Z24_UNORM ||
- ps->format == PIPE_FORMAT_Z16_UNORM ||
- ps->format == PIPE_FORMAT_Z32_UNORM ||
- ps->format == PIPE_FORMAT_S8_USCALED);
+ tc->transfer_map = pipe_transfer_map(pipe, ps->texture,
+ ps->u.tex.level, ps->u.tex.first_layer,
+ PIPE_TRANSFER_READ_WRITE |
+ PIPE_TRANSFER_UNSYNCHRONIZED,
+ 0, 0, ps->width, ps->height,
+ &tc->transfer);
+
+ tc->depth_stencil = util_format_is_depth_or_stencil(ps->format);
}
}
}
-void
-sp_tile_cache_map_transfers(struct softpipe_tile_cache *tc)
-{
- if (tc->transfer && !tc->transfer_map)
- tc->transfer_map = tc->pipe->transfer_map(tc->pipe, tc->transfer);
-}
-
-
-void
-sp_tile_cache_unmap_transfers(struct softpipe_tile_cache *tc)
-{
- if (tc->transfer_map) {
- tc->pipe->transfer_unmap(tc->pipe, tc->transfer);
- tc->transfer_map = NULL;
- }
-}
-
-
/**
* Set pixels in a tile to the given clear color/value, float.
*/
static void
clear_tile_rgba(struct softpipe_cached_tile *tile,
enum pipe_format format,
- const float clear_value[4])
+ const union pipe_color_union *clear_value)
{
- if (clear_value[0] == 0.0 &&
- clear_value[1] == 0.0 &&
- clear_value[2] == 0.0 &&
- clear_value[3] == 0.0) {
+ if (clear_value->f[0] == 0.0 &&
+ clear_value->f[1] == 0.0 &&
+ clear_value->f[2] == 0.0 &&
+ clear_value->f[3] == 0.0) {
memset(tile->data.color, 0, sizeof(tile->data.color));
}
else {
uint i, j;
- for (i = 0; i < TILE_SIZE; i++) {
- for (j = 0; j < TILE_SIZE; j++) {
- tile->data.color[i][j][0] = clear_value[0];
- tile->data.color[i][j][1] = clear_value[1];
- tile->data.color[i][j][2] = clear_value[2];
- tile->data.color[i][j][3] = clear_value[3];
+
+ if (util_format_is_pure_uint(format)) {
+ for (i = 0; i < TILE_SIZE; i++) {
+ for (j = 0; j < TILE_SIZE; j++) {
+ tile->data.colorui128[i][j][0] = clear_value->ui[0];
+ tile->data.colorui128[i][j][1] = clear_value->ui[1];
+ tile->data.colorui128[i][j][2] = clear_value->ui[2];
+ tile->data.colorui128[i][j][3] = clear_value->ui[3];
+ }
+ }
+ } else if (util_format_is_pure_sint(format)) {
+ for (i = 0; i < TILE_SIZE; i++) {
+ for (j = 0; j < TILE_SIZE; j++) {
+ tile->data.colori128[i][j][0] = clear_value->i[0];
+ tile->data.colori128[i][j][1] = clear_value->i[1];
+ tile->data.colori128[i][j][2] = clear_value->i[2];
+ tile->data.colori128[i][j][3] = clear_value->i[3];
+ }
+ }
+ } else {
+ for (i = 0; i < TILE_SIZE; i++) {
+ for (j = 0; j < TILE_SIZE; j++) {
+ tile->data.color[i][j][0] = clear_value->f[0];
+ tile->data.color[i][j][1] = clear_value->f[1];
+ tile->data.color[i][j][2] = clear_value->f[2];
+ tile->data.color[i][j][3] = clear_value->f[3];
+ }
}
}
}
static void
clear_tile(struct softpipe_cached_tile *tile,
enum pipe_format format,
- uint clear_value)
+ uint64_t clear_value)
{
uint i, j;
else {
for (i = 0; i < TILE_SIZE; i++) {
for (j = 0; j < TILE_SIZE; j++) {
- tile->data.color32[i][j] = clear_value;
+ tile->data.depth32[i][j] = clear_value;
+ }
+ }
+ }
+ break;
+ case 8:
+ if (clear_value == 0) {
+ memset(tile->data.any, 0, 8 * TILE_SIZE * TILE_SIZE);
+ }
+ else {
+ for (i = 0; i < TILE_SIZE; i++) {
+ for (j = 0; j < TILE_SIZE; j++) {
+ tile->data.depth64[i][j] = clear_value;
}
}
}
if (tc->depth_stencil) {
clear_tile(tc->tile, pt->resource->format, tc->clear_val);
} else {
- clear_tile_rgba(tc->tile, pt->resource->format, tc->clear_color);
+ clear_tile_rgba(tc->tile, pt->resource->format, &tc->clear_color);
}
/* push the tile to all positions marked as clear */
if (is_clear_flag_set(tc->clear_flags, addr)) {
/* write the scratch tile to the surface */
if (tc->depth_stencil) {
- pipe_put_tile_raw(tc->pipe,
- pt,
+ pipe_put_tile_raw(pt, tc->transfer_map,
x, y, TILE_SIZE, TILE_SIZE,
tc->tile->data.any, 0/*STRIDE*/);
}
else {
- pipe_put_tile_rgba(tc->pipe, pt,
- x, y, TILE_SIZE, TILE_SIZE,
- (float *) tc->tile->data.color);
+ if (util_format_is_pure_uint(tc->surface->format)) {
+ pipe_put_tile_ui_format(pt, tc->transfer_map,
+ x, y, TILE_SIZE, TILE_SIZE,
+ pt->resource->format,
+ (unsigned *) tc->tile->data.colorui128);
+ } else if (util_format_is_pure_sint(tc->surface->format)) {
+ pipe_put_tile_i_format(pt, tc->transfer_map,
+ x, y, TILE_SIZE, TILE_SIZE,
+ pt->resource->format,
+ (int *) tc->tile->data.colori128);
+ } else {
+ pipe_put_tile_rgba(pt, tc->transfer_map,
+ x, y, TILE_SIZE, TILE_SIZE,
+ (float *) tc->tile->data.color);
+ }
}
numCleared++;
}
{
if (!tc->tile_addrs[pos].bits.invalid) {
if (tc->depth_stencil) {
- pipe_put_tile_raw(tc->pipe, tc->transfer,
+ pipe_put_tile_raw(tc->transfer, tc->transfer_map,
tc->tile_addrs[pos].bits.x * TILE_SIZE,
tc->tile_addrs[pos].bits.y * TILE_SIZE,
TILE_SIZE, TILE_SIZE,
tc->entries[pos]->data.depth32, 0/*STRIDE*/);
}
else {
- pipe_put_tile_rgba_format(tc->pipe, tc->transfer,
+ if (util_format_is_pure_uint(tc->surface->format)) {
+ pipe_put_tile_ui_format(tc->transfer, tc->transfer_map,
+ tc->tile_addrs[pos].bits.x * TILE_SIZE,
+ tc->tile_addrs[pos].bits.y * TILE_SIZE,
+ TILE_SIZE, TILE_SIZE,
+ tc->surface->format,
+ (unsigned *) tc->entries[pos]->data.colorui128);
+ } else if (util_format_is_pure_sint(tc->surface->format)) {
+ pipe_put_tile_i_format(tc->transfer, tc->transfer_map,
tc->tile_addrs[pos].bits.x * TILE_SIZE,
tc->tile_addrs[pos].bits.y * TILE_SIZE,
TILE_SIZE, TILE_SIZE,
tc->surface->format,
- (float *) tc->entries[pos]->data.color);
+ (int *) tc->entries[pos]->data.colori128);
+ } else {
+ pipe_put_tile_rgba_format(tc->transfer, tc->transfer_map,
+ tc->tile_addrs[pos].bits.x * TILE_SIZE,
+ tc->tile_addrs[pos].bits.y * TILE_SIZE,
+ TILE_SIZE, TILE_SIZE,
+ tc->surface->format,
+ (float *) tc->entries[pos]->data.color);
+ }
}
tc->tile_addrs[pos].bits.invalid = 1; /* mark as empty */
}
union tile_address addr )
{
struct pipe_transfer *pt = tc->transfer;
-
/* cache pos/entry: */
const int pos = CACHE_POS(addr.bits.x,
addr.bits.y);
if (tc->tile_addrs[pos].bits.invalid == 0) {
/* put dirty tile back in framebuffer */
if (tc->depth_stencil) {
- pipe_put_tile_raw(tc->pipe, pt,
+ pipe_put_tile_raw(pt, tc->transfer_map,
tc->tile_addrs[pos].bits.x * TILE_SIZE,
tc->tile_addrs[pos].bits.y * TILE_SIZE,
TILE_SIZE, TILE_SIZE,
tile->data.depth32, 0/*STRIDE*/);
}
else {
- pipe_put_tile_rgba_format(tc->pipe, pt,
+ if (util_format_is_pure_uint(tc->surface->format)) {
+ pipe_put_tile_ui_format(pt, tc->transfer_map,
tc->tile_addrs[pos].bits.x * TILE_SIZE,
tc->tile_addrs[pos].bits.y * TILE_SIZE,
TILE_SIZE, TILE_SIZE,
tc->surface->format,
- (float *) tile->data.color);
+ (unsigned *) tile->data.colorui128);
+ } else if (util_format_is_pure_sint(tc->surface->format)) {
+ pipe_put_tile_i_format(pt, tc->transfer_map,
+ tc->tile_addrs[pos].bits.x * TILE_SIZE,
+ tc->tile_addrs[pos].bits.y * TILE_SIZE,
+ TILE_SIZE, TILE_SIZE,
+ tc->surface->format,
+ (int *) tile->data.colori128);
+ } else {
+ pipe_put_tile_rgba_format(pt, tc->transfer_map,
+ tc->tile_addrs[pos].bits.x * TILE_SIZE,
+ tc->tile_addrs[pos].bits.y * TILE_SIZE,
+ TILE_SIZE, TILE_SIZE,
+ tc->surface->format,
+ (float *) tile->data.color);
+ }
}
}
clear_tile(tile, pt->resource->format, tc->clear_val);
}
else {
- clear_tile_rgba(tile, pt->resource->format, tc->clear_color);
+ clear_tile_rgba(tile, pt->resource->format, &tc->clear_color);
}
clear_clear_flag(tc->clear_flags, addr);
}
else {
/* get new tile data from transfer */
if (tc->depth_stencil) {
- pipe_get_tile_raw(tc->pipe, pt,
+ pipe_get_tile_raw(pt, tc->transfer_map,
tc->tile_addrs[pos].bits.x * TILE_SIZE,
tc->tile_addrs[pos].bits.y * TILE_SIZE,
TILE_SIZE, TILE_SIZE,
tile->data.depth32, 0/*STRIDE*/);
}
else {
- pipe_get_tile_rgba(tc->pipe, pt,
- tc->tile_addrs[pos].bits.x * TILE_SIZE,
- tc->tile_addrs[pos].bits.y * TILE_SIZE,
- TILE_SIZE, TILE_SIZE,
- (float *) tile->data.color);
+ if (util_format_is_pure_uint(tc->surface->format)) {
+ pipe_get_tile_ui_format(pt, tc->transfer_map,
+ tc->tile_addrs[pos].bits.x * TILE_SIZE,
+ tc->tile_addrs[pos].bits.y * TILE_SIZE,
+ TILE_SIZE, TILE_SIZE,
+ tc->surface->format,
+ (unsigned *) tile->data.colorui128);
+ } else if (util_format_is_pure_sint(tc->surface->format)) {
+ pipe_get_tile_i_format(pt, tc->transfer_map,
+ tc->tile_addrs[pos].bits.x * TILE_SIZE,
+ tc->tile_addrs[pos].bits.y * TILE_SIZE,
+ TILE_SIZE, TILE_SIZE,
+ tc->surface->format,
+ (int *) tile->data.colori128);
+ } else {
+ pipe_get_tile_rgba_format(pt, tc->transfer_map,
+ tc->tile_addrs[pos].bits.x * TILE_SIZE,
+ tc->tile_addrs[pos].bits.y * TILE_SIZE,
+ TILE_SIZE, TILE_SIZE,
+ tc->surface->format,
+ (float *) tile->data.color);
+ }
}
}
}
* Save the color and set a 'clearflag' for each tile of the screen.
*/
void
-sp_tile_cache_clear(struct softpipe_tile_cache *tc, const float *rgba,
- uint clearValue)
+sp_tile_cache_clear(struct softpipe_tile_cache *tc,
+ const union pipe_color_union *color,
+ uint64_t clearValue)
{
uint pos;
- tc->clear_color[0] = rgba[0];
- tc->clear_color[1] = rgba[1];
- tc->clear_color[2] = rgba[2];
- tc->clear_color[3] = rgba[3];
+ tc->clear_color = *color;
tc->clear_val = clearValue;
projects / mesa.git / blobdiff