* The number of elements is width_in_tiles * height_in_tiles.
*/
static enum lp_texture_layout *
-alloc_layout_array(unsigned width, unsigned height)
+alloc_layout_array(unsigned num_slices, unsigned width, unsigned height)
{
const unsigned tx = align(width, TILE_SIZE) / TILE_SIZE;
const unsigned ty = align(height, TILE_SIZE) / TILE_SIZE;
- assert(tx * ty > 0);
+ assert(num_slices * tx * ty > 0);
assert(LP_TEX_LAYOUT_NONE == 0); /* calloc'ing LP_TEX_LAYOUT_NONE here */
return (enum lp_texture_layout *)
- calloc(tx * ty, sizeof(enum lp_texture_layout));
+ calloc(num_slices * tx * ty, sizeof(enum lp_texture_layout));
}
unsigned level;
unsigned width = pt->width0;
unsigned height = pt->height0;
+ unsigned depth = pt->depth0;
assert(LP_MAX_TEXTURE_2D_LEVELS <= LP_MAX_TEXTURE_LEVELS);
assert(LP_MAX_TEXTURE_3D_LEVELS <= LP_MAX_TEXTURE_LEVELS);
for (level = 0; level <= pt->last_level; level++) {
- const unsigned num_faces = lpr->base.target == PIPE_TEXTURE_CUBE ? 6 : 1;
- unsigned nblocksx, face;
+ const unsigned width_t = align(width, TILE_SIZE) / TILE_SIZE;
+ const unsigned height_t = align(height, TILE_SIZE) / TILE_SIZE;
+ unsigned nblocksx, num_slices;
+
+ if (lpr->base.target == PIPE_TEXTURE_CUBE)
+ num_slices = 6;
+ else if (lpr->base.target == PIPE_TEXTURE_3D)
+ num_slices = depth;
+ else
+ num_slices = 1;
/* Allocate storage for whole quads. This is particularly important
* for depth surfaces, which are currently stored in a swizzled format.
lpr->stride[level] =
align(nblocksx * util_format_get_blocksize(pt->format), 16);
- lpr->tiles_per_row[level] = align(width, TILE_SIZE) / TILE_SIZE;
-
- for (face = 0; face < num_faces; face++) {
- lpr->layout[level][face] = alloc_layout_array(width, height);
- }
+ lpr->tiles_per_row[level] = width_t;
+ lpr->tiles_per_image[level] = width_t * height_t;
+ lpr->num_slices_faces[level] = num_slices;
+ lpr->layout[level] = alloc_layout_array(num_slices, width, height);
width = u_minify(width, 1);
height = u_minify(height, 1);
+ depth = u_minify(depth, 1);
}
return TRUE;
/* Round up the surface size to a multiple of the tile size to
* avoid tile clipping.
*/
- unsigned width = align(lpr->base.width0, TILE_SIZE);
- unsigned height = align(lpr->base.height0, TILE_SIZE);
+ const unsigned width = align(lpr->base.width0, TILE_SIZE);
+ const unsigned height = align(lpr->base.height0, TILE_SIZE);
+ const unsigned width_t = align(width, TILE_SIZE) / TILE_SIZE;
+ const unsigned height_t = align(height, TILE_SIZE) / TILE_SIZE;
- lpr->tiles_per_row[0] = align(width, TILE_SIZE) / TILE_SIZE;
+ lpr->tiles_per_row[0] = width_t;
+ lpr->tiles_per_image[0] = width_t * height_t;
+ lpr->num_slices_faces[0] = 1;
- lpr->layout[0][0] = alloc_layout_array(width, height);
+ lpr->layout[0] = alloc_layout_array(1, width, height);
lpr->dt = winsys->displaytarget_create(winsys,
lpr->base.bind,
/* displayable surface */
if (!llvmpipe_displaytarget_layout(screen, lpr))
goto fail;
- assert(lpr->layout[0][0][0] == LP_TEX_LAYOUT_NONE);
+ assert(lpr->layout[0][0] == LP_TEX_LAYOUT_NONE);
}
else if (lpr->base.bind & (PIPE_BIND_SAMPLER_VIEW |
PIPE_BIND_DEPTH_STENCIL)) {
/* texture map */
if (!llvmpipe_texture_layout(screen, lpr))
goto fail;
- assert(lpr->layout[0][0][0] == LP_TEX_LAYOUT_NONE);
+ assert(lpr->layout[0][0] == LP_TEX_LAYOUT_NONE);
}
else {
/* other data (vertex buffer, const buffer, etc) */
}
if (resource_is_texture(&lpr->base)) {
- assert(lpr->layout[0][0]);
+ assert(lpr->layout[0]);
}
lpr->id = id_counter++;
}
else if (resource_is_texture(pt)) {
/* regular texture */
- const uint num_faces = pt->target == PIPE_TEXTURE_CUBE ? 6 : 1;
- uint level, face;
+ uint level;
/* free linear image data */
for (level = 0; level < Elements(lpr->linear); level++) {
/* free layout flag arrays */
for (level = 0; level < Elements(lpr->tiled); level++) {
- for (face = 0; face < num_faces; face++) {
- free(lpr->layout[level][face]);
- lpr->layout[level][face] = NULL;
- }
+ free(lpr->layout[level]);
+ lpr->layout[level] = NULL;
}
}
else if (!lpr->userBuffer) {
/* install this linear image in texture data structure */
lpr->linear[level].data = map;
- map = llvmpipe_get_texture_image(lpr, face, level, tex_usage, layout);
+ map = llvmpipe_get_texture_image(lpr, face + zslice, level,
+ tex_usage, layout);
assert(map);
return map;
}
else if (resource_is_texture(resource)) {
/* regular texture */
- const unsigned tex_height = u_minify(resource->height0, level);
- const unsigned nblocksy =
- util_format_get_nblocksy(resource->format, tex_height);
- const unsigned stride = lpr->stride[level];
- unsigned offset = 0;
-
- if (resource->target == PIPE_TEXTURE_CUBE) {
- /* XXX incorrect
- offset = face * nblocksy * stride;
- */
- }
- else if (resource->target == PIPE_TEXTURE_3D) {
- offset = zslice * nblocksy * stride;
- }
- else {
+ if (resource->target != PIPE_TEXTURE_CUBE) {
assert(face == 0);
+ }
+ if (resource->target != PIPE_TEXTURE_3D) {
assert(zslice == 0);
- offset = 0;
}
- map = llvmpipe_get_texture_image(lpr, face, level, tex_usage, layout);
+ map = llvmpipe_get_texture_image(lpr, face + zslice, level,
+ tex_usage, layout);
assert(map);
- map += offset;
return map;
}
else {
assert(zslice == 0);
/* make sure linear image is up to date */
- (void) llvmpipe_get_texture_image(lpr, 0, 0,
+ (void) llvmpipe_get_texture_image(lpr, face + zslice, level,
LP_TEX_USAGE_READ,
LP_TEX_LAYOUT_LINEAR);
/**
* Compute size (in bytes) need to store a texture image / mipmap level,
- * for just one cube face.
+ * for just one cube face or one 3D texture slice
*/
static unsigned
tex_image_face_size(const struct llvmpipe_resource *lpr, unsigned level,
{
const unsigned width = u_minify(lpr->base.width0, level);
const unsigned height = u_minify(lpr->base.height0, level);
- const unsigned depth = u_minify(lpr->base.depth0, level);
assert(layout == LP_TEX_LAYOUT_TILED ||
layout == LP_TEX_LAYOUT_LINEAR);
util_format_get_nblocksy(format, align(height, TILE_SIZE));
const unsigned nblocksx =
util_format_get_nblocksx(format, align(width, TILE_SIZE));
- const unsigned buffer_size =
- block_size * nblocksy * nblocksx *
- (lpr->base.target == PIPE_TEXTURE_3D ? depth : 1);
+ const unsigned buffer_size = block_size * nblocksy * nblocksx;
return buffer_size;
}
else {
const enum pipe_format format = lpr->base.format;
const unsigned nblocksy =
util_format_get_nblocksy(format, align(height, TILE_SIZE));
- const unsigned buffer_size =
- nblocksy * lpr->stride[level] *
- (lpr->base.target == PIPE_TEXTURE_3D ? depth : 1);
+ const unsigned buffer_size = nblocksy * lpr->stride[level];
return buffer_size;
}
}
/**
* Compute size (in bytes) need to store a texture image / mipmap level,
- * including all cube faces.
+ * including all cube faces or 3D image slices
*/
static unsigned
tex_image_size(const struct llvmpipe_resource *lpr, unsigned level,
enum lp_texture_layout layout)
{
const unsigned buf_size = tex_image_face_size(lpr, level, layout);
- const unsigned num_faces = lpr->base.target == PIPE_TEXTURE_CUBE ? 6 : 1;
- return buf_size * num_faces;
+ return buf_size * lpr->num_slices_faces[level];
}
uint i;
assert(resource_is_texture(&lpr->base));
assert(x < lpr->tiles_per_row[level]);
- i = y * lpr->tiles_per_row[level] + x;
- return lpr->layout[level][face_slice][i];
+ i = face_slice * lpr->tiles_per_image[level]
+ + y * lpr->tiles_per_row[level] + x;
+ return lpr->layout[level][i];
}
uint i;
assert(resource_is_texture(&lpr->base));
assert(x < lpr->tiles_per_row[level]);
- i = y * lpr->tiles_per_row[level] + x;
- lpr->layout[level][face_slice][i] = layout;
+ i = face_slice * lpr->tiles_per_image[level]
+ + y * lpr->tiles_per_row[level] + x;
+ lpr->layout[level][i] = layout;
}
/**
- * Return pointer to texture image data (either linear or tiled layout).
+ * Return pointer to texture image data (either linear or tiled layout)
+ * for a particular cube face or 3D texture slice.
+ *
+ * \param face_slice the cube face or 3D slice of interest
* \param usage one of LP_TEX_USAGE_READ/WRITE_ALL/READ_WRITE
* \param layout either LP_TEX_LAYOUT_LINEAR or _TILED or _NONE
*/
}
if (face_slice > 0) {
- unsigned offset;
- if (layout == LP_TEX_LAYOUT_LINEAR)
- offset = tex_image_face_size(lpr, level, LP_TEX_LAYOUT_LINEAR);
- else
- offset = tex_image_face_size(lpr, level, LP_TEX_LAYOUT_TILED);
-
- offset *= face_slice;
+ unsigned target_offset, other_offset;
+ target_offset = face_slice * tex_image_face_size(lpr, level, layout);
+ other_offset = face_slice * tex_image_face_size(lpr, level, other_layout);
if (target_data) {
- target_data = (uint8_t *) target_data + offset;
+ target_data = (uint8_t *) target_data + target_offset;
}
if (other_data) {
- other_data = (uint8_t *) other_data + offset;
+ other_data = (uint8_t *) other_data + other_offset;
}
}
if (only_allocate) {
- /* Just allocating tiled memory. Don't initialize it from the the
+ /* Just allocating tiled memory. Don't initialize it from the
* linear data if it exists.
*/
+ {
+ unsigned x, y;
+ for (y = 0; y < height_t; y++) {
+ for (x = 0; x < width_t; x++) {
+ llvmpipe_set_texture_tile_layout(lpr, face_slice, level,
+ x, y, layout);
+ }
+ }
+ }
+
return target_data;
}
}
+/**
+ * Return pointer to start of a texture image (1D, 2D, 3D, CUBE).
+ * All cube faces and 3D slices will be converted to the requested
+ * layout if needed.
+ * This is typically used when we're about to sample from a texture.
+ */
+void *
+llvmpipe_get_texture_image_all(struct llvmpipe_resource *lpr,
+ unsigned level,
+ enum lp_texture_usage usage,
+ enum lp_texture_layout layout)
+{
+ const int slices = lpr->num_slices_faces[level];
+ int slice;
+ void *map;
+
+ assert(slices > 0);
+
+ for (slice = slices - 1; slice >= 0; slice--) {
+ map = llvmpipe_get_texture_image(lpr, slice, level, usage, layout);
+ }
+
+ return map;
+}
+
+
+
/**
* Get pointer to a linear image where the tile at (x,y) is known to be
* in linear layout.
projects / mesa.git / commitdiff