st->pbo_upload.rgba_only =
screen->get_param(screen, PIPE_CAP_BUFFER_SAMPLER_VIEW_RGBA_ONLY);
- /* Create the vertex shader */
- {
- unsigned semantic_names[] = { TGSI_SEMANTIC_POSITION };
- unsigned semantic_indexes[] = { 0 };
-
- st->pbo_upload.vs = util_make_vertex_passthrough_shader(pipe, 1,
- semantic_names,
- semantic_indexes,
- FALSE);
+ if (screen->get_param(screen, PIPE_CAP_TGSI_INSTANCEID)) {
+ if (screen->get_param(screen, PIPE_CAP_TGSI_VS_LAYER_VIEWPORT)) {
+ st->pbo_upload.upload_layers = true;
+ } else if (screen->get_param(screen, PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES) >= 3) {
+ st->pbo_upload.upload_layers = true;
+ st->pbo_upload.use_gs = true;
+ }
}
/* Blend state */
st->pbo_upload.fs = NULL;
}
+ if (st->pbo_upload.gs) {
+ cso_delete_geometry_shader(st->cso_context, st->pbo_upload.gs);
+ st->pbo_upload.gs = NULL;
+ }
+
if (st->pbo_upload.vs) {
cso_delete_vertex_shader(st->cso_context, st->pbo_upload.vs);
st->pbo_upload.vs = NULL;
}
static void *
-create_pbo_upload_shader(struct st_context *st)
+create_pbo_upload_vs(struct st_context *st)
+{
+ struct ureg_program *ureg;
+ struct ureg_src in_pos;
+ struct ureg_src in_instanceid;
+ struct ureg_dst out_pos;
+ struct ureg_dst out_layer;
+
+ ureg = ureg_create(TGSI_PROCESSOR_VERTEX);
+ if (!ureg)
+ return NULL;
+
+ in_pos = ureg_DECL_vs_input(ureg, TGSI_SEMANTIC_POSITION);
+
+ out_pos = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
+
+ if (st->pbo_upload.upload_layers) {
+ in_instanceid = ureg_DECL_system_value(ureg, TGSI_SEMANTIC_INSTANCEID, 0);
+
+ if (!st->pbo_upload.use_gs)
+ out_layer = ureg_DECL_output(ureg, TGSI_SEMANTIC_LAYER, 0);
+ }
+
+ /* out_pos = in_pos */
+ ureg_MOV(ureg, out_pos, in_pos);
+
+ if (st->pbo_upload.upload_layers) {
+ if (st->pbo_upload.use_gs) {
+ /* out_pos.z = i2f(gl_InstanceID) */
+ ureg_I2F(ureg, ureg_writemask(out_pos, TGSI_WRITEMASK_Z),
+ ureg_scalar(in_instanceid, TGSI_SWIZZLE_X));
+ } else {
+ /* out_layer = gl_InstanceID */
+ ureg_MOV(ureg, out_layer, in_instanceid);
+ }
+ }
+
+ ureg_END(ureg);
+
+ return ureg_create_shader_and_destroy(ureg, st->pipe);
+}
+
+static void *
+create_pbo_upload_gs(struct st_context *st)
+{
+ static const int zero = 0;
+ struct ureg_program *ureg;
+ struct ureg_dst out_pos;
+ struct ureg_dst out_layer;
+ struct ureg_src in_pos;
+ struct ureg_src imm;
+ unsigned i;
+
+ ureg = ureg_create(TGSI_PROCESSOR_GEOMETRY);
+ if (!ureg)
+ return NULL;
+
+ ureg_property(ureg, TGSI_PROPERTY_GS_INPUT_PRIM, PIPE_PRIM_TRIANGLES);
+ ureg_property(ureg, TGSI_PROPERTY_GS_OUTPUT_PRIM, PIPE_PRIM_TRIANGLE_STRIP);
+ ureg_property(ureg, TGSI_PROPERTY_GS_MAX_OUTPUT_VERTICES, 3);
+
+ out_pos = ureg_DECL_output(ureg, TGSI_SEMANTIC_POSITION, 0);
+ out_layer = ureg_DECL_output(ureg, TGSI_SEMANTIC_LAYER, 0);
+
+ in_pos = ureg_DECL_input(ureg, TGSI_SEMANTIC_POSITION, 0, 0, 1);
+
+ imm = ureg_DECL_immediate_int(ureg, &zero, 1);
+
+ for (i = 0; i < 3; ++i) {
+ struct ureg_src in_pos_vertex = ureg_src_dimension(in_pos, i);
+
+ /* out_pos = in_pos[i] */
+ ureg_MOV(ureg, out_pos, in_pos_vertex);
+
+ /* out_layer.x = f2i(in_pos[i].z) */
+ ureg_F2I(ureg, ureg_writemask(out_layer, TGSI_WRITEMASK_X),
+ ureg_scalar(in_pos_vertex, TGSI_SWIZZLE_Z));
+
+ ureg_EMIT(ureg, ureg_scalar(imm, TGSI_SWIZZLE_X));
+ }
+
+ ureg_END(ureg);
+
+ return ureg_create_shader_and_destroy(ureg, st->pipe);
+}
+
+static void *
+create_pbo_upload_fs(struct st_context *st)
{
struct pipe_context *pipe = st->pipe;
struct pipe_screen *screen = pipe->screen;
struct ureg_dst out;
struct ureg_src sampler;
struct ureg_src pos;
+ struct ureg_src layer;
struct ureg_src const0;
struct ureg_dst temp0;
- ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);
+ ureg = ureg_create(TGSI_PROCESSOR_FRAGMENT);
+ if (!ureg)
+ return NULL;
+
out = ureg_DECL_output(ureg, TGSI_SEMANTIC_COLOR, 0);
sampler = ureg_DECL_sampler(ureg, 0);
if (screen->get_param(screen, PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL)) {
pos = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_POSITION, 0,
TGSI_INTERPOLATE_LINEAR);
}
+ if (st->pbo_upload.upload_layers) {
+ layer = ureg_DECL_fs_input(ureg, TGSI_SEMANTIC_LAYER, 0,
+ TGSI_INTERPOLATE_CONSTANT);
+ }
const0 = ureg_DECL_constant(ureg, 0);
temp0 = ureg_DECL_temporary(ureg);
- /* Note: const0 = [ -xoffset + skip_pixels, -yoffset, stride, 0 ] */
+ /* Note: const0 = [ -xoffset + skip_pixels, -yoffset, stride, image_height ] */
/* temp0.xy = f2i(temp0.xy) */
ureg_F2I(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_XY),
ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_Y),
ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_X));
+ if (st->pbo_upload.upload_layers) {
+ /* temp0.x = const0.w * layer + temp0.x */
+ ureg_UMAD(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_X),
+ ureg_scalar(const0, TGSI_SWIZZLE_W),
+ ureg_scalar(layer, TGSI_SWIZZLE_X),
+ ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_X));
+ }
+
+ /* temp0.w = 0 */
+ ureg_MOV(ureg, ureg_writemask(temp0, TGSI_WRITEMASK_W), ureg_imm1u(ureg, 0));
+
/* out = txf(sampler, temp0.x) */
- ureg_TXF(ureg, out, TGSI_TEXTURE_BUFFER,
- ureg_scalar(ureg_src(temp0), TGSI_SWIZZLE_X),
- sampler);
+ ureg_TXF(ureg, out, TGSI_TEXTURE_BUFFER, ureg_src(temp0), sampler);
ureg_release_temporary(ureg, temp0);
unsigned image_height)
{
struct st_context *st = st_context(ctx);
+ struct cso_context *cso = st->cso_context;
struct pipe_context *pipe = st->pipe;
- struct pipe_sampler_view *sampler_view = NULL;
unsigned depth = surface->u.tex.last_layer - surface->u.tex.first_layer + 1;
unsigned skip_pixels = 0;
+ bool success = false;
/* Check alignment. */
{
}
/* Create the shaders */
+ if (!st->pbo_upload.vs) {
+ st->pbo_upload.vs = create_pbo_upload_vs(st);
+ if (!st->pbo_upload.vs)
+ return false;
+ }
+
+ if (depth != 1 && st->pbo_upload.use_gs && !st->pbo_upload.gs) {
+ st->pbo_upload.gs = create_pbo_upload_gs(st);
+ if (!st->pbo_upload.gs)
+ return false;
+ }
+
if (!st->pbo_upload.fs) {
- st->pbo_upload.fs = create_pbo_upload_shader(st);
+ st->pbo_upload.fs = create_pbo_upload_fs(st);
if (!st->pbo_upload.fs)
return false;
}
+ cso_save_state(cso, (CSO_BIT_FRAGMENT_SAMPLER_VIEWS |
+ CSO_BIT_FRAGMENT_SAMPLERS |
+ CSO_BIT_VERTEX_ELEMENTS |
+ CSO_BIT_AUX_VERTEX_BUFFER_SLOT |
+ CSO_BIT_FRAMEBUFFER |
+ CSO_BIT_VIEWPORT |
+ CSO_BIT_BLEND |
+ CSO_BIT_DEPTH_STENCIL_ALPHA |
+ CSO_BIT_RASTERIZER |
+ CSO_BIT_STREAM_OUTPUTS |
+ CSO_BITS_ALL_SHADERS));
+ cso_save_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT);
+
+
/* Set up the sampler_view */
{
unsigned first_element = buf_offset;
unsigned last_element = buf_offset + skip_pixels + upload_width - 1
+ (upload_height - 1 + (depth - 1) * image_height) * stride;
struct pipe_sampler_view templ;
+ struct pipe_sampler_view *sampler_view;
+ struct pipe_sampler_state sampler = {0};
+ const struct pipe_sampler_state *samplers[1] = {&sampler};
/* This should be ensured by Mesa before calling our callbacks */
assert((last_element + 1) * bytes_per_pixel <= buffer->width0);
if (last_element - first_element > ctx->Const.MaxTextureBufferSize - 1)
- return false;
+ goto fail;
memset(&templ, 0, sizeof(templ));
+ templ.target = PIPE_BUFFER;
templ.format = src_format;
templ.u.buf.first_element = first_element;
templ.u.buf.last_element = last_element;
sampler_view = pipe->create_sampler_view(pipe, buffer, &templ);
if (sampler_view == NULL)
- return false;
- }
-
- /* Begin setting state. This is the point of no return. */
- cso_save_fragment_sampler_views(st->cso_context);
- cso_set_sampler_views(st->cso_context, PIPE_SHADER_FRAGMENT, 1,
- &sampler_view);
-
- /* Framebuffer_state */
- {
- struct pipe_framebuffer_state fb;
- memset(&fb, 0, sizeof(fb));
- fb.width = surface->width;
- fb.height = surface->height;
- fb.nr_cbufs = 1;
- pipe_surface_reference(&fb.cbufs[0], surface);
-
- cso_save_framebuffer(st->cso_context);
- cso_set_framebuffer(st->cso_context, &fb);
+ goto fail;
- pipe_surface_reference(&fb.cbufs[0], NULL);
- }
+ cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, 1, &sampler_view);
- /* Viewport state */
- {
- struct pipe_viewport_state vp;
- vp.scale[0] = 0.5f * surface->width;
- vp.scale[1] = 0.5f * surface->height;
- vp.scale[2] = 1.0f;
- vp.translate[0] = 0.5f * surface->width;
- vp.translate[1] = 0.5f * surface->height;
- vp.translate[2] = 0.0f;
+ pipe_sampler_view_reference(&sampler_view, NULL);
- cso_save_viewport(st->cso_context);
- cso_set_viewport(st->cso_context, &vp);
+ cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, samplers);
}
- /* Blend state */
- cso_save_blend(st->cso_context);
- cso_set_blend(st->cso_context, &st->pbo_upload.blend);
-
- /* Rasterizer state */
- cso_save_rasterizer(st->cso_context);
- cso_set_rasterizer(st->cso_context, &st->pbo_upload.raster);
-
/* Upload vertices */
{
struct pipe_vertex_buffer vbo;
u_upload_alloc(st->uploader, 0, 8 * sizeof(float), 4,
&vbo.buffer_offset, &vbo.buffer, (void **) &verts);
+ if (!verts)
+ goto fail;
verts[0] = x0;
verts[1] = y0;
velem.src_offset = 0;
velem.instance_divisor = 0;
- velem.vertex_buffer_index = cso_get_aux_vertex_buffer_slot(st->cso_context);
+ velem.vertex_buffer_index = cso_get_aux_vertex_buffer_slot(cso);
velem.src_format = PIPE_FORMAT_R32G32_FLOAT;
- cso_save_vertex_elements(st->cso_context);
- cso_set_vertex_elements(st->cso_context, 1, &velem);
+ cso_set_vertex_elements(cso, 1, &velem);
+
+ cso_set_vertex_buffers(cso, velem.vertex_buffer_index, 1, &vbo);
- cso_save_aux_vertex_buffer_slot(st->cso_context);
- cso_set_vertex_buffers(st->cso_context, velem.vertex_buffer_index,
- 1, &vbo);
+ pipe_resource_reference(&vbo.buffer, NULL);
}
/* Upload constants */
+ /* Note: the user buffer must be valid until draw time */
+ struct {
+ int32_t xoffset;
+ int32_t yoffset;
+ int32_t stride;
+ int32_t image_size;
+ } constants;
+
{
struct pipe_constant_buffer cb;
- struct {
- int32_t xoffset;
- int32_t yoffset;
- int32_t stride;
- int32_t pad;
- } constants;
-
constants.xoffset = -xoffset + skip_pixels;
constants.yoffset = -yoffset;
constants.stride = stride;
- constants.pad = 0;
+ constants.image_size = stride * image_height;
if (st->constbuf_uploader) {
cb.buffer = NULL;
cb.user_buffer = NULL;
u_upload_data(st->constbuf_uploader, 0, sizeof(constants),
- st->ctx->Const.UniformBufferOffsetAlignment,
+ ctx->Const.UniformBufferOffsetAlignment,
&constants, &cb.buffer_offset, &cb.buffer);
+ if (!cb.buffer)
+ goto fail;
+
u_upload_unmap(st->constbuf_uploader);
} else {
cb.buffer = NULL;
}
cb.buffer_size = sizeof(constants);
- cso_save_constant_buffer_slot0(st->cso_context, PIPE_SHADER_FRAGMENT);
- cso_set_constant_buffer(st->cso_context, PIPE_SHADER_FRAGMENT, 0, &cb);
+ cso_set_constant_buffer(cso, PIPE_SHADER_FRAGMENT, 0, &cb);
+
+ pipe_resource_reference(&cb.buffer, NULL);
+ }
+
+ /* Framebuffer_state */
+ {
+ struct pipe_framebuffer_state fb;
+ memset(&fb, 0, sizeof(fb));
+ fb.width = surface->width;
+ fb.height = surface->height;
+ fb.nr_cbufs = 1;
+ pipe_surface_reference(&fb.cbufs[0], surface);
+
+ cso_set_framebuffer(cso, &fb);
+
+ pipe_surface_reference(&fb.cbufs[0], NULL);
}
+ cso_set_viewport_dims(cso, surface->width, surface->height, FALSE);
+
+ /* Blend state */
+ cso_set_blend(cso, &st->pbo_upload.blend);
+
+ /* Depth/stencil/alpha state */
+ {
+ struct pipe_depth_stencil_alpha_state dsa;
+ memset(&dsa, 0, sizeof(dsa));
+ cso_set_depth_stencil_alpha(cso, &dsa);
+ }
+
+ /* Rasterizer state */
+ cso_set_rasterizer(cso, &st->pbo_upload.raster);
+
/* Set up the shaders */
- cso_save_vertex_shader(st->cso_context);
- cso_set_vertex_shader_handle(st->cso_context, st->pbo_upload.vs);
+ cso_set_vertex_shader_handle(cso, st->pbo_upload.vs);
- cso_save_geometry_shader(st->cso_context);
- cso_set_geometry_shader_handle(st->cso_context, NULL);
+ cso_set_geometry_shader_handle(cso, depth != 1 ? st->pbo_upload.gs : NULL);
- cso_save_tessctrl_shader(st->cso_context);
- cso_set_tessctrl_shader_handle(st->cso_context, NULL);
+ cso_set_tessctrl_shader_handle(cso, NULL);
- cso_save_tesseval_shader(st->cso_context);
- cso_set_tesseval_shader_handle(st->cso_context, NULL);
+ cso_set_tesseval_shader_handle(cso, NULL);
- cso_save_fragment_shader(st->cso_context);
- cso_set_fragment_shader_handle(st->cso_context, st->pbo_upload.fs);
+ cso_set_fragment_shader_handle(cso, st->pbo_upload.fs);
/* Disable stream output */
- cso_save_stream_outputs(st->cso_context);
- cso_set_stream_outputs(st->cso_context, 0, NULL, 0);
-
- cso_draw_arrays(st->cso_context, PIPE_PRIM_TRIANGLE_STRIP, 0, 4);
-
- cso_restore_fragment_sampler_views(st->cso_context);
- cso_restore_framebuffer(st->cso_context);
- cso_restore_viewport(st->cso_context);
- cso_restore_blend(st->cso_context);
- cso_restore_rasterizer(st->cso_context);
- cso_restore_vertex_elements(st->cso_context);
- cso_restore_aux_vertex_buffer_slot(st->cso_context);
- cso_restore_constant_buffer_slot0(st->cso_context, PIPE_SHADER_FRAGMENT);
- cso_restore_vertex_shader(st->cso_context);
- cso_restore_geometry_shader(st->cso_context);
- cso_restore_tessctrl_shader(st->cso_context);
- cso_restore_tesseval_shader(st->cso_context);
- cso_restore_fragment_shader(st->cso_context);
- cso_restore_stream_outputs(st->cso_context);
-
- pipe_sampler_view_reference(&sampler_view, NULL);
+ cso_set_stream_outputs(cso, 0, NULL, 0);
- return true;
+ if (depth == 1) {
+ cso_draw_arrays(cso, PIPE_PRIM_TRIANGLE_STRIP, 0, 4);
+ } else {
+ cso_draw_arrays_instanced(cso, PIPE_PRIM_TRIANGLE_STRIP,
+ 0, 4, 0, depth);
+ }
+
+ success = true;
+
+fail:
+ cso_restore_state(cso);
+ cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT);
+
+ return success;
}
static bool
image_height = unpack->ImageHeight > 0 ? unpack->ImageHeight : height;
}
- /* XXX We only support updating a single layer */
- if (depth != 1)
+ if (depth != 1 && !st->pbo_upload.upload_layers)
return false;
/* Choose the source format. Initially, we do so without checking driver
}
+static void
+st_CompressedTexSubImage(struct gl_context *ctx, GLuint dims,
+ struct gl_texture_image *texImage,
+ GLint x, GLint y, GLint z,
+ GLsizei w, GLsizei h, GLsizei d,
+ GLenum format, GLsizei imageSize, const GLvoid *data)
+{
+ struct st_context *st = st_context(ctx);
+ struct st_texture_image *stImage = st_texture_image(texImage);
+ struct st_texture_object *stObj = st_texture_object(texImage->TexObject);
+ struct pipe_resource *texture = stImage->pt;
+ struct pipe_context *pipe = st->pipe;
+ struct pipe_screen *screen = pipe->screen;
+ struct pipe_resource *dst = stImage->pt;
+ struct pipe_surface *surface = NULL;
+ struct compressed_pixelstore store;
+ enum pipe_format copy_format;
+ unsigned bytes_per_block;
+ unsigned bw, bh;
+ intptr_t buf_offset;
+ bool success = false;
+
+ /* Check basic pre-conditions for PBO upload */
+ if (!st->prefer_blit_based_texture_transfer) {
+ goto fallback;
+ }
+
+ if (!_mesa_is_bufferobj(ctx->Unpack.BufferObj))
+ goto fallback;
+
+ if ((_mesa_is_format_etc2(texImage->TexFormat) && !st->has_etc2) ||
+ (texImage->TexFormat == MESA_FORMAT_ETC1_RGB8 && !st->has_etc1)) {
+ /* ETC isn't supported and is represented by uncompressed formats. */
+ goto fallback;
+ }
+
+ if (!dst) {
+ goto fallback;
+ }
+
+ if (!st->pbo_upload.enabled ||
+ !screen->get_param(screen, PIPE_CAP_SURFACE_REINTERPRET_BLOCKS)) {
+ goto fallback;
+ }
+
+ /* Choose the pipe format for the upload. */
+ bytes_per_block = util_format_get_blocksize(dst->format);
+ bw = util_format_get_blockwidth(dst->format);
+ bh = util_format_get_blockheight(dst->format);
+
+ switch (bytes_per_block) {
+ case 8:
+ copy_format = PIPE_FORMAT_R16G16B16A16_UINT;
+ break;
+ case 16:
+ copy_format = PIPE_FORMAT_R32G32B32A32_UINT;
+ break;
+ default:
+ goto fallback;
+ }
+
+ if (!screen->is_format_supported(screen, copy_format, PIPE_BUFFER, 0,
+ PIPE_BIND_SAMPLER_VIEW)) {
+ goto fallback;
+ }
+
+ if (!screen->is_format_supported(screen, copy_format, dst->target,
+ dst->nr_samples, PIPE_BIND_RENDER_TARGET)) {
+ goto fallback;
+ }
+
+ /* Interpret the pixelstore settings. */
+ _mesa_compute_compressed_pixelstore(dims, texImage->TexFormat, w, h, d,
+ &ctx->Unpack, &store);
+ assert(store.CopyBytesPerRow % bytes_per_block == 0);
+ assert(store.SkipBytes % bytes_per_block == 0);
+
+ /* Compute the offset into the buffer */
+ buf_offset = (intptr_t)data + store.SkipBytes;
+
+ if (buf_offset % bytes_per_block) {
+ goto fallback;
+ }
+
+ buf_offset = buf_offset / bytes_per_block;
+
+ /* Set up the surface. */
+ {
+ unsigned level = stObj->pt != stImage->pt ? 0 : texImage->TexObject->MinLevel + texImage->Level;
+ unsigned max_layer = util_max_layer(texture, level);
+
+ z += texImage->Face + texImage->TexObject->MinLayer;
+
+ struct pipe_surface templ;
+ memset(&templ, 0, sizeof(templ));
+ templ.format = copy_format;
+ templ.u.tex.level = level;
+ templ.u.tex.first_layer = MIN2(z, max_layer);
+ templ.u.tex.last_layer = MIN2(z + d - 1, max_layer);
+
+ surface = pipe->create_surface(pipe, texture, &templ);
+ if (!surface)
+ goto fallback;
+ }
+
+ success = try_pbo_upload_common(ctx, surface,
+ x / bw, y / bh,
+ store.CopyBytesPerRow / bytes_per_block,
+ store.CopyRowsPerSlice,
+ st_buffer_object(ctx->Unpack.BufferObj)->buffer,
+ copy_format,
+ buf_offset,
+ bytes_per_block,
+ store.TotalBytesPerRow / bytes_per_block,
+ store.TotalRowsPerSlice);
+
+ pipe_surface_reference(&surface, NULL);
+
+ if (success)
+ return;
+
+fallback:
+ _mesa_store_compressed_texsubimage(ctx, dims, texImage,
+ x, y, z, w, h, d,
+ format, imageSize, data);
+}
+
static void
st_CompressedTexImage(struct gl_context *ctx, GLuint dims,
struct gl_texture_image *texImage,
GLsizei imageSize, const GLvoid *data)
{
prep_teximage(ctx, texImage, GL_NONE, GL_NONE);
- _mesa_store_compressed_teximage(ctx, dims, texImage, imageSize, data);
+
+ /* only 2D and 3D compressed images are supported at this time */
+ if (dims == 1) {
+ _mesa_problem(ctx, "Unexpected glCompressedTexImage1D call");
+ return;
+ }
+
+ /* This is pretty simple, because unlike the general texstore path we don't
+ * have to worry about the usual image unpacking or image transfer
+ * operations.
+ */
+ assert(texImage);
+ assert(texImage->Width > 0);
+ assert(texImage->Height > 0);
+ assert(texImage->Depth > 0);
+
+ /* allocate storage for texture data */
+ if (!st_AllocTextureImageBuffer(ctx, texImage)) {
+ _mesa_error(ctx, GL_OUT_OF_MEMORY, "glCompressedTexImage%uD", dims);
+ return;
+ }
+
+ st_CompressedTexSubImage(ctx, dims, texImage,
+ 0, 0, 0,
+ texImage->Width, texImage->Height, texImage->Depth,
+ texImage->TexFormat,
+ imageSize, data);
}
{
struct st_context *st = st_context(ctx);
struct st_texture_object *stObj = st_texture_object(tObj);
- const GLuint nr_faces = (stObj->base.Target == GL_TEXTURE_CUBE_MAP) ? 6 : 1;
+ const GLuint nr_faces = _mesa_num_tex_faces(stObj->base.Target);
GLuint face;
const struct st_texture_image *firstImage;
enum pipe_format firstImageFormat;
/* Need to import images in main memory or held in other textures.
*/
if (stImage && stObj->pt != stImage->pt) {
+ GLuint depth = stObj->depth0;
+ if (stObj->base.Target == GL_TEXTURE_3D)
+ depth = u_minify(depth, level);
if (level == 0 ||
(stImage->base.Width == u_minify(stObj->width0, level) &&
stImage->base.Height == u_minify(stObj->height0, level) &&
- stImage->base.Depth == u_minify(stObj->depth0, level))) {
+ stImage->base.Depth == depth)) {
/* src image fits expected dest mipmap level size */
copy_image_data_to_texture(st, stObj, level, stImage);
}
st_init_texture_functions(struct dd_function_table *functions)
{
functions->ChooseTextureFormat = st_ChooseTextureFormat;
- functions->QuerySamplesForFormat = st_QuerySamplesForFormat;
+ functions->QueryInternalFormat = st_QueryInternalFormat;
functions->TexImage = st_TexImage;
functions->TexSubImage = st_TexSubImage;
- functions->CompressedTexSubImage = _mesa_store_compressed_texsubimage;
+ functions->CompressedTexSubImage = st_CompressedTexSubImage;
functions->CopyTexSubImage = st_CopyTexSubImage;
functions->GenerateMipmap = st_generate_mipmap;
projects / mesa.git / blobdiff