static void svga_blit(struct pipe_context *pipe,
const struct pipe_blit_info *blit_info)
{
struct svga_context *svga = svga_context(pipe);
struct pipe_blit_info info = *blit_info;
if (info.src.resource->nr_samples > 1 &&
info.dst.resource->nr_samples <= 1 &&
!util_format_is_depth_or_stencil(info.src.resource->format) &&
!util_format_is_pure_integer(info.src.resource->format)) {
debug_printf("svga: color resolve unimplemented\n");
return;
}
if (util_try_blit_via_copy_region(pipe, &info)) {
return; /* done */
}
if (info.mask & PIPE_MASK_S) {
debug_printf("svga: cannot blit stencil, skipping\n");
info.mask &= ~PIPE_MASK_S;
}
if (!util_blitter_is_blit_supported(svga->blitter, &info)) {
debug_printf("svga: blit unsupported %s -> %s\n",
util_format_short_name(info.src.resource->format),
util_format_short_name(info.dst.resource->format));
return;
}
/* XXX turn off occlusion and streamout queries */
util_blitter_save_vertex_buffers(svga->blitter,
svga->curr.num_vertex_buffers,
svga->curr.vb);
util_blitter_save_vertex_elements(svga->blitter, (void*)svga->curr.velems);
util_blitter_save_vertex_shader(svga->blitter, svga->curr.vs);
/*util_blitter_save_geometry_shader(svga->blitter, svga->curr.gs);*/
/*util_blitter_save_so_targets(svga->blitter, svga->num_so_targets,
(struct pipe_stream_output_target**)svga->so_targets);*/
util_blitter_save_rasterizer(svga->blitter, (void*)svga->curr.rast);
util_blitter_save_viewport(svga->blitter, &svga->curr.viewport);
util_blitter_save_scissor(svga->blitter, &svga->curr.scissor);
util_blitter_save_fragment_shader(svga->blitter, svga->curr.fs);
util_blitter_save_blend(svga->blitter, (void*)svga->curr.blend);
util_blitter_save_depth_stencil_alpha(svga->blitter,
(void*)svga->curr.depth);
util_blitter_save_stencil_ref(svga->blitter, &svga->curr.stencil_ref);
/*util_blitter_save_sample_mask(svga->blitter, svga->sample_mask);*/
util_blitter_save_framebuffer(svga->blitter, &svga->curr.framebuffer);
util_blitter_save_fragment_sampler_states(svga->blitter,
svga->curr.num_samplers,
(void**)svga->curr.sampler);
util_blitter_save_fragment_sampler_views(svga->blitter,
svga->curr.num_sampler_views,
svga->curr.sampler_views);
/*util_blitter_save_render_condition(svga->blitter, svga->render_cond_query,
svga->render_cond_mode);*/
util_blitter_blit(svga->blitter, &info);
}
static void lp_blit(struct pipe_context *pipe,
const struct pipe_blit_info *blit_info)
{
struct llvmpipe_context *lp = llvmpipe_context(pipe);
struct pipe_blit_info info = *blit_info;
if (info.src.resource->nr_samples > 1 &&
info.dst.resource->nr_samples <= 1 &&
!util_format_is_depth_or_stencil(info.src.resource->format) &&
!util_format_is_pure_integer(info.src.resource->format)) {
debug_printf("llvmpipe: color resolve unimplemented\n");
return;
}
if (util_try_blit_via_copy_region(pipe, &info)) {
return; /* done */
}
if (info.mask & PIPE_MASK_S) {
debug_printf("llvmpipe: cannot blit stencil, skipping\n");
info.mask &= ~PIPE_MASK_S;
}
if (!util_blitter_is_blit_supported(lp->blitter, &info)) {
debug_printf("llvmpipe: blit unsupported %s -> %s\n",
util_format_short_name(info.src.resource->format),
util_format_short_name(info.dst.resource->format));
return;
}
/* XXX turn off occlusion and streamout queries */
util_blitter_save_vertex_buffers(lp->blitter, lp->num_vertex_buffers,
lp->vertex_buffer);
util_blitter_save_vertex_elements(lp->blitter, (void*)lp->velems);
util_blitter_save_vertex_shader(lp->blitter, (void*)lp->vs);
util_blitter_save_geometry_shader(lp->blitter, (void*)lp->gs);
/*util_blitter_save_so_targets(lp->blitter, lp->num_so_targets,
(struct pipe_stream_output_target**)lp->so_targets);*/
util_blitter_save_rasterizer(lp->blitter, (void*)lp->rasterizer);
util_blitter_save_viewport(lp->blitter, &lp->viewport);
util_blitter_save_scissor(lp->blitter, &lp->scissor);
util_blitter_save_fragment_shader(lp->blitter, lp->fs);
util_blitter_save_blend(lp->blitter, (void*)lp->blend);
util_blitter_save_depth_stencil_alpha(lp->blitter, (void*)lp->depth_stencil);
util_blitter_save_stencil_ref(lp->blitter, &lp->stencil_ref);
/*util_blitter_save_sample_mask(sp->blitter, lp->sample_mask);*/
util_blitter_save_framebuffer(lp->blitter, &lp->framebuffer);
util_blitter_save_fragment_sampler_states(lp->blitter,
lp->num_samplers[PIPE_SHADER_FRAGMENT],
(void**)lp->samplers[PIPE_SHADER_FRAGMENT]);
util_blitter_save_fragment_sampler_views(lp->blitter,
lp->num_sampler_views[PIPE_SHADER_FRAGMENT],
lp->sampler_views[PIPE_SHADER_FRAGMENT]);
util_blitter_save_render_condition(lp->blitter, lp->render_cond_query,
lp->render_cond_mode);
util_blitter_blit(lp->blitter, &info);
}
static void r600_blitter_begin(struct pipe_context *ctx, enum r600_blitter_op op)
{
struct r600_context *rctx = (struct r600_context *)ctx;
r600_suspend_nontimer_queries(rctx);
util_blitter_save_vertex_buffers(rctx->blitter,
util_last_bit(rctx->vertex_buffer_state.enabled_mask),
rctx->vertex_buffer_state.vb);
util_blitter_save_vertex_elements(rctx->blitter, rctx->vertex_elements);
util_blitter_save_vertex_shader(rctx->blitter, rctx->vs_shader);
util_blitter_save_so_targets(rctx->blitter, rctx->num_so_targets,
(struct pipe_stream_output_target**)rctx->so_targets);
util_blitter_save_rasterizer(rctx->blitter, rctx->states[R600_PIPE_STATE_RASTERIZER]);
if (op & R600_SAVE_FRAGMENT_STATE) {
if (rctx->states[R600_PIPE_STATE_VIEWPORT]) {
util_blitter_save_viewport(rctx->blitter, &rctx->viewport);
}
util_blitter_save_fragment_shader(rctx->blitter, rctx->ps_shader);
util_blitter_save_blend(rctx->blitter, rctx->states[R600_PIPE_STATE_BLEND]);
util_blitter_save_depth_stencil_alpha(rctx->blitter, rctx->states[R600_PIPE_STATE_DSA]);
if (rctx->states[R600_PIPE_STATE_STENCIL_REF]) {
util_blitter_save_stencil_ref(rctx->blitter, &rctx->stencil_ref);
}
util_blitter_save_sample_mask(rctx->blitter, rctx->sample_mask.sample_mask);
}
if (op & R600_SAVE_FRAMEBUFFER)
util_blitter_save_framebuffer(rctx->blitter, &rctx->framebuffer);
if (op & R600_SAVE_TEXTURES) {
util_blitter_save_fragment_sampler_states(
rctx->blitter, rctx->ps_samplers.n_samplers,
(void**)rctx->ps_samplers.samplers);
util_blitter_save_fragment_sampler_views(
rctx->blitter, util_last_bit(rctx->ps_samplers.views.enabled_mask),
(struct pipe_sampler_view**)rctx->ps_samplers.views.views);
}
if ((op & R600_DISABLE_RENDER_COND) && rctx->current_render_cond) {
rctx->saved_render_cond = rctx->current_render_cond;
rctx->saved_render_cond_mode = rctx->current_render_cond_mode;
rctx->context.render_condition(&rctx->context, NULL, 0);
}
}
static void r300_blitter_begin(struct r300_context* r300, enum r300_blitter_op op)
{
if ((op & R300_STOP_QUERY) && r300->query_current) {
r300->blitter_saved_query = r300->query_current;
r300_stop_query(r300);
}
/* Yeah we have to save all those states to ensure the blitter operation
* is really transparent. The states will be restored by the blitter once
* copying is done. */
util_blitter_save_blend(r300->blitter, r300->blend_state.state);
util_blitter_save_depth_stencil_alpha(r300->blitter, r300->dsa_state.state);
util_blitter_save_stencil_ref(r300->blitter, &(r300->stencil_ref));
util_blitter_save_rasterizer(r300->blitter, r300->rs_state.state);
util_blitter_save_fragment_shader(r300->blitter, r300->fs.state);
util_blitter_save_vertex_shader(r300->blitter, r300->vs_state.state);
util_blitter_save_viewport(r300->blitter, &r300->viewport);
util_blitter_save_clip(r300->blitter, (struct pipe_clip_state*)r300->clip_state.state);
util_blitter_save_vertex_elements(r300->blitter, r300->velems);
util_blitter_save_vertex_buffers(r300->blitter, r300->vbuf_mgr->nr_vertex_buffers,
r300->vbuf_mgr->vertex_buffer);
if (op & R300_SAVE_FRAMEBUFFER) {
util_blitter_save_framebuffer(r300->blitter, r300->fb_state.state);
}
if (op & R300_SAVE_TEXTURES) {
struct r300_textures_state* state =
(struct r300_textures_state*)r300->textures_state.state;
util_blitter_save_fragment_sampler_states(
r300->blitter, state->sampler_state_count,
(void**)state->sampler_states);
util_blitter_save_fragment_sampler_views(
r300->blitter, state->sampler_view_count,
(struct pipe_sampler_view**)state->sampler_views);
}
if (op & R300_IGNORE_RENDER_COND) {
/* Save the flag. */
r300->blitter_saved_skip_rendering = r300->skip_rendering+1;
r300->skip_rendering = FALSE;
} else {
r300->blitter_saved_skip_rendering = 0;
}
}
static void r600_blitter_begin(struct pipe_context *ctx, enum r600_blitter_op op)
{
struct r600_context *rctx = (struct r600_context *)ctx;
r600_context_queries_suspend(rctx);
util_blitter_save_blend(rctx->blitter, rctx->queued.named.blend);
util_blitter_save_depth_stencil_alpha(rctx->blitter, rctx->queued.named.dsa);
util_blitter_save_stencil_ref(rctx->blitter, &rctx->stencil_ref);
util_blitter_save_rasterizer(rctx->blitter, rctx->queued.named.rasterizer);
util_blitter_save_fragment_shader(rctx->blitter, rctx->ps_shader);
util_blitter_save_vertex_shader(rctx->blitter, rctx->vs_shader);
util_blitter_save_vertex_elements(rctx->blitter, rctx->vertex_elements);
if (rctx->queued.named.viewport) {
util_blitter_save_viewport(rctx->blitter, &rctx->queued.named.viewport->viewport);
}
util_blitter_save_vertex_buffers(rctx->blitter,
rctx->nr_vertex_buffers,
rctx->vertex_buffer);
util_blitter_save_so_targets(rctx->blitter, rctx->num_so_targets,
(struct pipe_stream_output_target**)rctx->so_targets);
if (op & R600_SAVE_FRAMEBUFFER)
util_blitter_save_framebuffer(rctx->blitter, &rctx->framebuffer);
if (op & R600_SAVE_TEXTURES) {
util_blitter_save_fragment_sampler_states(
rctx->blitter, rctx->ps_samplers.n_samplers,
(void**)rctx->ps_samplers.samplers);
util_blitter_save_fragment_sampler_views(
rctx->blitter, rctx->ps_samplers.n_views,
(struct pipe_sampler_view**)rctx->ps_samplers.views);
}
if ((op & R600_DISABLE_RENDER_COND) && rctx->current_render_cond) {
rctx->saved_render_cond = rctx->current_render_cond;
rctx->saved_render_cond_mode = rctx->current_render_cond_mode;
rctx->context.render_condition(&rctx->context, NULL, 0);
}
}
static void
i915_surface_copy_render(struct pipe_context *pipe,
struct pipe_resource *dst, unsigned dst_level,
unsigned dstx, unsigned dsty, unsigned dstz,
struct pipe_resource *src, unsigned src_level,
const struct pipe_box *src_box)
{
struct i915_context *i915 = i915_context(pipe);
/* Fallback for buffers. */
if (dst->target == PIPE_BUFFER && src->target == PIPE_BUFFER) {
util_resource_copy_region(pipe, dst, dst_level, dstx, dsty, dstz,
src, src_level, src_box);
return;
}
util_blitter_save_blend(i915->blitter, (void *)i915->blend);
util_blitter_save_depth_stencil_alpha(i915->blitter, (void *)i915->depth_stencil);
util_blitter_save_stencil_ref(i915->blitter, &i915->stencil_ref);
util_blitter_save_rasterizer(i915->blitter, (void *)i915->rasterizer);
util_blitter_save_fragment_shader(i915->blitter, i915->saved_fs);
util_blitter_save_vertex_shader(i915->blitter, i915->saved_vs);
util_blitter_save_viewport(i915->blitter, &i915->viewport);
util_blitter_save_clip(i915->blitter, &i915->saved_clip);
util_blitter_save_vertex_elements(i915->blitter, i915->saved_velems);
util_blitter_save_vertex_buffers(i915->blitter, i915->saved_nr_vertex_buffers,
i915->saved_vertex_buffers);
util_blitter_save_framebuffer(i915->blitter, &i915->framebuffer);
util_blitter_save_fragment_sampler_states(i915->blitter,
i915->saved_nr_samplers,
i915->saved_samplers);
util_blitter_save_fragment_sampler_views(i915->blitter,
i915->saved_nr_sampler_views,
i915->saved_sampler_views);
util_blitter_copy_texture(i915->blitter, dst, dst_level, dstx, dsty, dstz,
src, src_level, src_box, TRUE);
}
static void r300_blitter_begin(struct r300_context* r300, enum r300_blitter_op op)
{
if (r300->query_current) {
r300->blitter_saved_query = r300->query_current;
r300_stop_query(r300);
}
/* Yeah we have to save all those states to ensure the blitter operation
* is really transparent. The states will be restored by the blitter once
* copying is done. */
util_blitter_save_blend(r300->blitter, r300->blend_state.state);
util_blitter_save_depth_stencil_alpha(r300->blitter, r300->dsa_state.state);
util_blitter_save_stencil_ref(r300->blitter, &(r300->stencil_ref));
util_blitter_save_rasterizer(r300->blitter, r300->rs_state.state);
util_blitter_save_fragment_shader(r300->blitter, r300->fs.state);
util_blitter_save_vertex_shader(r300->blitter, r300->vs_state.state);
util_blitter_save_viewport(r300->blitter, &r300->viewport);
util_blitter_save_clip(r300->blitter, (struct pipe_clip_state*)r300->clip_state.state);
util_blitter_save_vertex_elements(r300->blitter, r300->velems);
util_blitter_save_vertex_buffers(r300->blitter, r300->vertex_buffer_count,
r300->vertex_buffer);
if (op & (R300_CLEAR_SURFACE | R300_COPY))
util_blitter_save_framebuffer(r300->blitter, r300->fb_state.state);
if (op & R300_COPY) {
struct r300_textures_state* state =
(struct r300_textures_state*)r300->textures_state.state;
util_blitter_save_fragment_sampler_states(
r300->blitter, state->sampler_state_count,
(void**)state->sampler_states);
util_blitter_save_fragment_sampler_views(
r300->blitter, state->sampler_view_count,
(struct pipe_sampler_view**)state->sampler_views);
}
}