if (target == PIPE_TEXTURE_CUBE)
assert(layers == 6);
- DBG("%s target %d format %s last_level %d\n", __FUNCTION__,
+ DBG("%s target %d format %s last_level %d\n", __func__,
(int) target, util_format_name(format), last_level);
assert(format);
pt.width0 = width0;
pt.height0 = height0;
pt.depth0 = depth0;
- pt.array_size = (target == PIPE_TEXTURE_CUBE ? 6 : layers);
+ pt.array_size = layers;
pt.usage = PIPE_USAGE_DEFAULT;
pt.bind = bind;
pt.flags = 0;
*widthOut = widthIn;
*heightOut = heightIn;
*depthOut = 1;
- *layersOut = depthIn;
+ *layersOut = util_align_npot(depthIn, 6);
break;
default:
assert(0 && "Unexpected texture in st_gl_texture_dims_to_pipe_dims()");
* Check if a texture image can be pulled into a unified mipmap texture.
*/
GLboolean
-st_texture_match_image(const struct pipe_resource *pt,
+st_texture_match_image(struct st_context *st,
+ const struct pipe_resource *pt,
const struct gl_texture_image *image)
{
GLuint ptWidth, ptHeight, ptDepth, ptLayers;
/* Check if this image's format matches the established texture's format.
*/
- if (st_mesa_format_to_pipe_format(image->TexFormat) != pt->format)
+ if (st_mesa_format_to_pipe_format(st, image->TexFormat) != pt->format)
return GL_FALSE;
st_gl_texture_dims_to_pipe_dims(image->TexObject->Target,
st_texture_image_map(struct st_context *st, struct st_texture_image *stImage,
enum pipe_transfer_usage usage,
GLuint x, GLuint y, GLuint z,
- GLuint w, GLuint h, GLuint d)
+ GLuint w, GLuint h, GLuint d,
+ struct pipe_transfer **transfer)
{
struct st_texture_object *stObj =
st_texture_object(stImage->base.TexObject);
GLuint level;
+ void *map;
- DBG("%s \n", __FUNCTION__);
+ DBG("%s \n", __func__);
if (!stImage->pt)
return NULL;
else
level = stImage->base.Level;
- return pipe_transfer_map_3d(st->pipe, stImage->pt, level, usage,
- x, y, z + stImage->base.Face,
- w, h, d, &stImage->transfer);
-}
-
-
-void
-st_texture_image_unmap(struct st_context *st,
- struct st_texture_image *stImage)
-{
- struct pipe_context *pipe = st->pipe;
+ if (stObj->base.Immutable) {
+ level += stObj->base.MinLevel;
+ z += stObj->base.MinLayer;
+ if (stObj->pt->array_size > 1)
+ d = MIN2(d, stObj->base.NumLayers);
+ }
- DBG("%s\n", __FUNCTION__);
+ z += stImage->base.Face;
+
+ map = pipe_transfer_map_3d(st->pipe, stImage->pt, level, usage,
+ x, y, z, w, h, d, transfer);
+ if (map) {
+ /* Enlarge the transfer array if it's not large enough. */
+ if (z >= stImage->num_transfers) {
+ unsigned new_size = z + 1;
+
+ stImage->transfer = realloc(stImage->transfer,
+ new_size * sizeof(struct st_texture_image_transfer));
+ memset(&stImage->transfer[stImage->num_transfers], 0,
+ (new_size - stImage->num_transfers) *
+ sizeof(struct st_texture_image_transfer));
+ stImage->num_transfers = new_size;
+ }
- pipe_transfer_unmap(pipe, stImage->transfer);
- stImage->transfer = NULL;
+ assert(!stImage->transfer[z].transfer);
+ stImage->transfer[z].transfer = *transfer;
+ }
+ return map;
}
-/* Upload data for a particular image.
- */
void
-st_texture_image_data(struct st_context *st,
- struct pipe_resource *dst,
- GLuint face,
- GLuint level,
- void *src,
- GLuint src_row_stride, GLuint src_image_stride)
+st_texture_image_unmap(struct st_context *st,
+ struct st_texture_image *stImage, unsigned slice)
{
struct pipe_context *pipe = st->pipe;
- GLuint i;
- const GLubyte *srcUB = src;
- GLuint layers;
-
- if (dst->target == PIPE_TEXTURE_1D_ARRAY ||
- dst->target == PIPE_TEXTURE_2D_ARRAY ||
- dst->target == PIPE_TEXTURE_CUBE_ARRAY)
- layers = dst->array_size;
- else
- layers = u_minify(dst->depth0, level);
-
- DBG("%s\n", __FUNCTION__);
+ struct st_texture_object *stObj =
+ st_texture_object(stImage->base.TexObject);
+ struct pipe_transfer **transfer;
- for (i = 0; i < layers; i++) {
- struct pipe_box box;
- u_box_2d_zslice(0, 0, face + i,
- u_minify(dst->width0, level),
- u_minify(dst->height0, level),
- &box);
+ if (stObj->base.Immutable)
+ slice += stObj->base.MinLayer;
+ transfer = &stImage->transfer[slice + stImage->base.Face].transfer;
- pipe->transfer_inline_write(pipe, dst, level, PIPE_TRANSFER_WRITE,
- &box, srcUB, src_row_stride, 0);
+ DBG("%s\n", __func__);
- srcUB += src_image_stride;
- }
+ pipe_transfer_unmap(pipe, *transfer);
+ *transfer = NULL;
}
-
/**
* For debug only: get/print center pixel in the src resource.
*/
src_box.width = width;
src_box.height = height;
src_box.depth = 1;
+
+ if (src->target == PIPE_TEXTURE_1D_ARRAY ||
+ src->target == PIPE_TEXTURE_2D_ARRAY ||
+ src->target == PIPE_TEXTURE_CUBE_ARRAY) {
+ face = 0;
+ depth = src->array_size;
+ }
+
/* Loop over 3D image slices */
/* could (and probably should) use "true" 3d box here -
but drivers can't quite handle it yet */
st_texture_get_sampler_view(struct st_context *st,
struct st_texture_object *stObj)
{
- struct pipe_sampler_view **used = NULL, **free = NULL;
+ struct pipe_sampler_view *used = NULL, **free = NULL;
GLuint i;
for (i = 0; i < stObj->num_sampler_views; ++i) {
return sv;
/* Wasn't the right one, but remember it as template */
- used = sv;
+ used = *sv;
} else {
/* Found a free slot, remember that */
free = sv;
/* Add just any sampler view to be used as a template */
if (used)
- pipe_sampler_view_reference(free, *used);
+ pipe_sampler_view_reference(free, used);
return free;
}
+
+/**
+ * For the given texture object, release any sampler views which belong
+ * to the calling context.
+ */
void
st_texture_release_sampler_view(struct st_context *st,
struct st_texture_object *stObj)
}
}
+
+/**
+ * Release all sampler views attached to the given texture object, regardless
+ * of the context.
+ */
void
-st_texture_release_all_sampler_views(struct st_texture_object *stObj)
+st_texture_release_all_sampler_views(struct st_context *st,
+ struct st_texture_object *stObj)
{
GLuint i;
+ /* XXX This should use sampler_views[i]->pipe, not st->pipe */
for (i = 0; i < stObj->num_sampler_views; ++i)
- pipe_sampler_view_reference(&stObj->sampler_views[i], NULL);
+ pipe_sampler_view_release(st->pipe, &stObj->sampler_views[i]);
+}
+
+
+void
+st_texture_free_sampler_views(struct st_texture_object *stObj)
+{
+ /* NOTE:
+ * We use FREE() here to match REALLOC() above. Both come from
+ * u_memory.h, not imports.h. If we mis-match MALLOC/FREE from
+ * those two headers we can trash the heap.
+ */
+ FREE(stObj->sampler_views);
}
projects / mesa.git / blobdiff