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);
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;
+ (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;
+ goto fail;
- cso_save_fragment_sampler_views(cso);
cso_set_sampler_views(cso, PIPE_SHADER_FRAGMENT, 1, &sampler_view);
pipe_sampler_view_reference(&sampler_view, NULL);
+
+ cso_set_samplers(cso, PIPE_SHADER_FRAGMENT, 1, samplers);
}
/* Upload vertices */
u_upload_alloc(st->uploader, 0, 8 * sizeof(float), 4,
&vbo.buffer_offset, &vbo.buffer, (void **) &verts);
if (!verts)
- goto fail_vertex_upload;
+ goto fail;
verts[0] = x0;
verts[1] = y0;
velem.vertex_buffer_index = cso_get_aux_vertex_buffer_slot(cso);
velem.src_format = PIPE_FORMAT_R32G32_FLOAT;
- cso_save_vertex_elements(cso);
cso_set_vertex_elements(cso, 1, &velem);
- cso_save_aux_vertex_buffer_slot(cso);
cso_set_vertex_buffers(cso, 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 image_size;
- } constants;
-
constants.xoffset = -xoffset + skip_pixels;
constants.yoffset = -yoffset;
constants.stride = stride;
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_constant_upload;
+ goto fail;
u_upload_unmap(st->constbuf_uploader);
} else {
}
cb.buffer_size = sizeof(constants);
- cso_save_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT);
cso_set_constant_buffer(cso, PIPE_SHADER_FRAGMENT, 0, &cb);
pipe_resource_reference(&cb.buffer, NULL);
fb.nr_cbufs = 1;
pipe_surface_reference(&fb.cbufs[0], surface);
- cso_save_framebuffer(cso);
cso_set_framebuffer(cso, &fb);
pipe_surface_reference(&fb.cbufs[0], NULL);
}
- /* 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;
-
- cso_save_viewport(cso);
- cso_set_viewport(cso, &vp);
- }
+ cso_set_viewport_dims(cso, surface->width, surface->height, FALSE);
/* Blend state */
- cso_save_blend(cso);
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_save_rasterizer(cso);
cso_set_rasterizer(cso, &st->pbo_upload.raster);
/* Set up the shaders */
- cso_save_vertex_shader(cso);
cso_set_vertex_shader_handle(cso, st->pbo_upload.vs);
- cso_save_geometry_shader(cso);
cso_set_geometry_shader_handle(cso, depth != 1 ? st->pbo_upload.gs : NULL);
- cso_save_tessctrl_shader(cso);
cso_set_tessctrl_shader_handle(cso, NULL);
- cso_save_tesseval_shader(cso);
cso_set_tesseval_shader_handle(cso, NULL);
- cso_save_fragment_shader(cso);
cso_set_fragment_shader_handle(cso, st->pbo_upload.fs);
/* Disable stream output */
- cso_save_stream_outputs(cso);
cso_set_stream_outputs(cso, 0, NULL, 0);
if (depth == 1) {
success = true;
- cso_restore_framebuffer(cso);
- cso_restore_viewport(cso);
- cso_restore_blend(cso);
- cso_restore_rasterizer(cso);
- cso_restore_vertex_shader(cso);
- cso_restore_geometry_shader(cso);
- cso_restore_tessctrl_shader(cso);
- cso_restore_tesseval_shader(cso);
- cso_restore_fragment_shader(cso);
- cso_restore_stream_outputs(cso);
+fail:
+ cso_restore_state(cso);
cso_restore_constant_buffer_slot0(cso, PIPE_SHADER_FRAGMENT);
-fail_constant_upload:
- cso_restore_vertex_elements(cso);
- cso_restore_aux_vertex_buffer_slot(cso);
-fail_vertex_upload:
- cso_restore_fragment_sampler_views(cso);
return success;
}
{
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 height = stObj->height0;
+ GLuint depth = stObj->depth0;
+
+ if (stObj->base.Target != GL_TEXTURE_1D_ARRAY)
+ height = u_minify(height, level);
+ 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.Height == height &&
+ 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 = st_CompressedTexSubImage;
projects / mesa.git / blobdiff