/**
* \brief Clear the whole render target using vgpu10 functionality
*
* \param svga[in] The svga context
* \param dst[in] The surface to clear
* \param color[in] Clear color
* \return PIPE_OK if all well, PIPE_ERROR_OUT_OF_MEMORY if ran out of
* command submission resources.
*/
static enum pipe_error
svga_try_clear_render_target(struct svga_context *svga,
struct pipe_surface *dst,
const union pipe_color_union *color)
{
struct pipe_surface *rtv =
svga_validate_surface_view(svga, svga_surface(dst));
if (!rtv)
return PIPE_ERROR_OUT_OF_MEMORY;
return SVGA3D_vgpu10_ClearRenderTargetView(svga->swc, rtv, color->f);
}
static enum pipe_error
emit_fb_vgpu10(struct svga_context *svga)
{
const struct svga_screen *ss = svga_screen(svga->pipe.screen);
struct pipe_surface *rtv[SVGA3D_MAX_RENDER_TARGETS];
struct pipe_surface *dsv;
struct pipe_framebuffer_state *curr = &svga->curr.framebuffer;
struct pipe_framebuffer_state *hw = &svga->state.hw_clear.framebuffer;
const unsigned num_color = MAX2(curr->nr_cbufs, hw->nr_cbufs);
unsigned i;
enum pipe_error ret;
assert(svga_have_vgpu10(svga));
/* Setup render targets array. Note that we loop over the max of the
* number of previously bound buffers and the new buffers to unbind
* any previously bound buffers when the new number of buffers is less
* than the old number of buffers.
*/
for (i = 0; i < num_color; i++) {
if (curr->cbufs[i]) {
rtv[i] = svga_validate_surface_view(svga,
svga_surface(curr->cbufs[i]));
if (rtv[i] == NULL) {
return PIPE_ERROR_OUT_OF_MEMORY;
}
assert(svga_surface(rtv[i])->view_id != SVGA3D_INVALID_ID);
}
else {
rtv[i] = NULL;
}
}
/* Setup depth stencil view */
if (curr->zsbuf) {
dsv = svga_validate_surface_view(svga, svga_surface(curr->zsbuf));
if (!dsv) {
return PIPE_ERROR_OUT_OF_MEMORY;
}
}
else {
dsv = NULL;
}
ret = SVGA3D_vgpu10_SetRenderTargets(svga->swc, num_color, rtv, dsv);
if (ret != PIPE_OK)
return ret;
for (i = 0; i < ss->max_color_buffers; i++) {
if (hw->cbufs[i] != curr->cbufs[i]) {
/* propagate the backed view surface before unbinding it */
if (hw->cbufs[i] && svga_surface(hw->cbufs[i])->backed) {
svga_propagate_surface(svga,
&svga_surface(hw->cbufs[i])->backed->base);
}
pipe_surface_reference(&hw->cbufs[i], curr->cbufs[i]);
}
}
hw->nr_cbufs = curr->nr_cbufs;
if (hw->zsbuf != curr->zsbuf) {
/* propagate the backed view surface before unbinding it */
if (hw->zsbuf && svga_surface(hw->zsbuf)->backed) {
svga_propagate_surface(svga, &svga_surface(hw->zsbuf)->backed->base);
}
pipe_surface_reference(&hw->zsbuf, curr->zsbuf);
}
return ret;
}
static void
svga_clear_texture(struct pipe_context *pipe,
struct pipe_resource *res,
unsigned level,
const struct pipe_box *box,
const void *data)
{
struct svga_context *svga = svga_context(pipe);
struct svga_surface *svga_surface_dst;
enum pipe_error ret;
struct pipe_surface tmpl;
struct pipe_surface *surface;
memset(&tmpl, 0, sizeof(tmpl));
tmpl.format = res->format;
tmpl.u.tex.first_layer = box->z;
tmpl.u.tex.last_layer = box->z + box->depth - 1;
tmpl.u.tex.level = level;
surface = pipe->create_surface(pipe, res, &tmpl);
if (surface == NULL) {
debug_printf("failed to create surface\n");
return;
}
svga_surface_dst = svga_surface(surface);
union pipe_color_union color;
const struct util_format_description *desc =
util_format_description(surface->format);
if (util_format_is_depth_or_stencil(surface->format)) {
float depth;
uint8_t stencil;
unsigned clear_flags = 0;
/* If data is NULL, then set depthValue and stencilValue to zeros */
if (data == NULL) {
depth = 0.0;
stencil = 0;
}
else {
desc->unpack_z_float(&depth, 0, data, 0, 1, 1);
desc->unpack_s_8uint(&stencil, 0, data, 0, 1, 1);
}
if (util_format_has_depth(desc)) {
clear_flags |= PIPE_CLEAR_DEPTH;
}
if (util_format_has_stencil(desc)) {
clear_flags |= PIPE_CLEAR_STENCIL;
}
/* Setup depth stencil view */
struct pipe_surface *dsv =
svga_validate_surface_view(svga, svga_surface_dst);
if (!dsv) {
pipe_surface_reference(&surface, NULL);
return;
}
if (box->x == 0 && box->y == 0 && box->width == surface->width &&
box->height == surface->height) {
/* clearing whole surface, use direct VGPU10 command */
ret = SVGA3D_vgpu10_ClearDepthStencilView(svga->swc, dsv,
clear_flags,
stencil, depth);
if (ret != PIPE_OK) {
/* flush and try again */
svga_context_flush(svga, NULL);
ret = SVGA3D_vgpu10_ClearDepthStencilView(svga->swc, dsv,
clear_flags,
stencil, depth);
assert(ret == PIPE_OK);
}
}
else {
/* To clear subtexture use software fallback */
util_blitter_save_framebuffer(svga->blitter,
&svga->curr.framebuffer);
begin_blit(svga);
util_blitter_clear_depth_stencil(svga->blitter,
dsv, clear_flags,
depth,stencil,
box->x, box->y,
box->width, box->height);
}
}
else {
/* non depth-stencil formats */
if (data == NULL) {
/* If data is NULL, the texture image is filled with zeros */
color.f[0] = color.f[1] = color.f[2] = color.f[3] = 0;
}
else {
if (util_format_is_pure_sint(surface->format)) {
/* signed integer */
desc->unpack_rgba_sint(color.i, 0, data, 0, 1, 1);
}
else if (util_format_is_pure_uint(surface->format)) {
/* unsigned integer */
desc->unpack_rgba_uint(color.ui, 0, data, 0, 1, 1);
}
else {
/* floating point */
desc->unpack_rgba_float(color.f, 0, data, 0, 1, 1);
}
}
/* Setup render target view */
struct pipe_surface *rtv =
svga_validate_surface_view(svga, svga_surface_dst);
if (!rtv) {
pipe_surface_reference(&surface, NULL);
return;
}
if (box->x == 0 && box->y == 0 && box->width == surface->width &&
box->height == surface->height) {
struct pipe_framebuffer_state *curr = &svga->curr.framebuffer;
if (is_integer_target(curr, PIPE_CLEAR_COLOR) &&
!ints_fit_in_floats(&color)) {
/* To clear full texture with integer format */
clear_buffers_with_quad(svga, PIPE_CLEAR_COLOR, &color, 0.0, 0);
}
else {
/* clearing whole surface using VGPU10 command */
ret = SVGA3D_vgpu10_ClearRenderTargetView(svga->swc, rtv,
color.f);
if (ret != PIPE_OK) {
svga_context_flush(svga,NULL);
ret = SVGA3D_vgpu10_ClearRenderTargetView(svga->swc, rtv,
color.f);
assert(ret == PIPE_OK);
}
}
}
else {
/* To clear subtexture use software fallback */
/**
* util_blitter_clear_render_target doesn't support PIPE_TEXTURE_3D
* It tries to draw quad with depth 0 for PIPE_TEXTURE_3D so use
* util_clear_render_target() for PIPE_TEXTURE_3D.
*/
if (rtv->texture->target != PIPE_TEXTURE_3D &&
pipe->screen->is_format_supported(pipe->screen, rtv->format,
rtv->texture->target,
rtv->texture->nr_samples,
PIPE_BIND_RENDER_TARGET)) {
/* clear with quad drawing */
util_blitter_save_framebuffer(svga->blitter,
&svga->curr.framebuffer);
begin_blit(svga);
util_blitter_clear_render_target(svga->blitter,
rtv,
&color,
box->x, box->y,
box->width, box->height);
}
else {
/* clear with map/write/unmap */
/* store layer values */
unsigned first_layer = rtv->u.tex.first_layer;
unsigned last_layer = rtv->u.tex.last_layer;
unsigned box_depth = last_layer - first_layer + 1;
for (unsigned i = 0; i < box_depth; i++) {
rtv->u.tex.first_layer = rtv->u.tex.last_layer =
first_layer + i;
util_clear_render_target(pipe, rtv, &color, box->x, box->y,
box->width, box->height);
}
/* restore layer values */
rtv->u.tex.first_layer = first_layer;
rtv->u.tex.last_layer = last_layer;
}
}
}
pipe_surface_reference(&surface, NULL);
}
static enum pipe_error
try_clear(struct svga_context *svga,
unsigned buffers,
const union pipe_color_union *color,
double depth,
unsigned stencil)
{
enum pipe_error ret = PIPE_OK;
SVGA3dRect rect = { 0, 0, 0, 0 };
boolean restore_viewport = FALSE;
SVGA3dClearFlag flags = 0;
struct pipe_framebuffer_state *fb = &svga->curr.framebuffer;
union util_color uc = {0};
ret = svga_update_state(svga, SVGA_STATE_HW_CLEAR);
if (ret != PIPE_OK)
return ret;
if (svga->rebind.flags.rendertargets) {
ret = svga_reemit_framebuffer_bindings(svga);
if (ret != PIPE_OK) {
return ret;
}
}
if (buffers & PIPE_CLEAR_COLOR) {
flags |= SVGA3D_CLEAR_COLOR;
util_pack_color(color->f, PIPE_FORMAT_B8G8R8A8_UNORM, &uc);
rect.w = fb->width;
rect.h = fb->height;
}
if ((buffers & PIPE_CLEAR_DEPTHSTENCIL) && fb->zsbuf) {
if (buffers & PIPE_CLEAR_DEPTH)
flags |= SVGA3D_CLEAR_DEPTH;
if (buffers & PIPE_CLEAR_STENCIL)
flags |= SVGA3D_CLEAR_STENCIL;
rect.w = MAX2(rect.w, fb->zsbuf->width);
rect.h = MAX2(rect.h, fb->zsbuf->height);
}
if (!svga_have_vgpu10(svga) &&
!svga_rects_equal(&rect, &svga->state.hw_clear.viewport)) {
restore_viewport = TRUE;
ret = SVGA3D_SetViewport(svga->swc, &rect);
if (ret != PIPE_OK)
return ret;
}
if (svga_have_vgpu10(svga)) {
if (flags & SVGA3D_CLEAR_COLOR) {
unsigned i;
if (is_integer_target(fb, buffers) && !ints_fit_in_floats(color)) {
clear_buffers_with_quad(svga, buffers, color, depth, stencil);
/* We also cleared depth/stencil, so that's done */
flags &= ~(SVGA3D_CLEAR_DEPTH | SVGA3D_CLEAR_STENCIL);
}
else {
struct pipe_surface *rtv;
/* Issue VGPU10 Clear commands */
for (i = 0; i < fb->nr_cbufs; i++) {
if ((fb->cbufs[i] == NULL) ||
!(buffers & (PIPE_CLEAR_COLOR0 << i)))
continue;
rtv = svga_validate_surface_view(svga,
svga_surface(fb->cbufs[i]));
if (!rtv)
return PIPE_ERROR_OUT_OF_MEMORY;
ret = SVGA3D_vgpu10_ClearRenderTargetView(svga->swc,
rtv, color->f);
if (ret != PIPE_OK)
return ret;
}
}
}
if (flags & (SVGA3D_CLEAR_DEPTH | SVGA3D_CLEAR_STENCIL)) {
struct pipe_surface *dsv =
svga_validate_surface_view(svga, svga_surface(fb->zsbuf));
if (!dsv)
return PIPE_ERROR_OUT_OF_MEMORY;
ret = SVGA3D_vgpu10_ClearDepthStencilView(svga->swc, dsv, flags,
stencil, (float) depth);
if (ret != PIPE_OK)
return ret;
}
}
else {
ret = SVGA3D_ClearRect(svga->swc, flags, uc.ui[0], (float) depth, stencil,
rect.x, rect.y, rect.w, rect.h);
if (ret != PIPE_OK)
return ret;
}
if (restore_viewport) {
ret = SVGA3D_SetViewport(svga->swc, &svga->state.hw_clear.viewport);
}
return ret;
}
