1 /**************************************************************************
3 * Copyright 2009 Marek Olšák <maraeo@gmail.com>
5 * Permission is hereby granted, free of charge, to any person obtaining a
6 * copy of this software and associated documentation files (the
7 * "Software"), to deal in the Software without restriction, including
8 * without limitation the rights to use, copy, modify, merge, publish,
9 * distribute, sub license, and/or sell copies of the Software, and to
10 * permit persons to whom the Software is furnished to do so, subject to
11 * the following conditions:
13 * The above copyright notice and this permission notice (including the
14 * next paragraph) shall be included in all copies or substantial portions
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
18 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
19 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
20 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
21 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
22 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
23 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
25 **************************************************************************/
29 * Blitter utility to facilitate acceleration of the clear, surface_copy,
30 * and surface_fill functions.
35 #include "pipe/p_context.h"
36 #include "pipe/p_defines.h"
37 #include "util/u_inlines.h"
38 #include "pipe/p_shader_tokens.h"
39 #include "pipe/p_state.h"
41 #include "util/u_format.h"
42 #include "util/u_memory.h"
43 #include "util/u_math.h"
44 #include "util/u_blitter.h"
45 #include "util/u_draw_quad.h"
46 #include "util/u_pack_color.h"
47 #include "util/u_rect.h"
48 #include "util/u_sampler.h"
49 #include "util/u_simple_shaders.h"
50 #include "util/u_texture.h"
52 #define INVALID_PTR ((void*)~0)
54 struct blitter_context_priv
56 struct blitter_context blitter;
58 struct pipe_context *pipe; /**< pipe context */
59 struct pipe_resource *vbuf; /**< quad */
61 float vertices[4][2][4]; /**< {pos, color} or {pos, texcoord} */
63 /* Templates for various state objects. */
64 struct pipe_sampler_state template_sampler_state;
66 /* Constant state objects. */
68 void *vs_col; /**< Vertex shader which passes {pos, color} to the output */
69 void *vs_tex; /**< Vertex shader which passes {pos, texcoord} to the output.*/
71 /* Fragment shaders. */
72 /* FS which outputs a color to multiple color buffers. */
73 void *fs_col[PIPE_MAX_COLOR_BUFS];
75 /* FS which outputs a color from a texture,
76 where the index is PIPE_TEXTURE_* to be sampled. */
77 void *fs_texfetch_col[PIPE_MAX_TEXTURE_TYPES];
79 /* FS which outputs a depth from a texture,
80 where the index is PIPE_TEXTURE_* to be sampled. */
81 void *fs_texfetch_depth[PIPE_MAX_TEXTURE_TYPES];
84 void *blend_write_color; /**< blend state with writemask of RGBA */
85 void *blend_keep_color; /**< blend state with writemask of 0 */
87 /* Depth stencil alpha state. */
88 void *dsa_write_depth_stencil;
89 void *dsa_write_depth_keep_stencil;
90 void *dsa_keep_depth_stencil;
94 /* Sampler state for clamping to a miplevel. */
95 void *sampler_state[PIPE_MAX_TEXTURE_LEVELS];
97 /* Rasterizer state. */
100 struct pipe_sampler_view *sampler_view;
102 /* Viewport state. */
103 struct pipe_viewport_state viewport;
106 struct pipe_clip_state clip;
109 struct blitter_context *util_blitter_create(struct pipe_context *pipe)
111 struct blitter_context_priv *ctx;
112 struct pipe_blend_state blend;
113 struct pipe_depth_stencil_alpha_state dsa;
114 struct pipe_rasterizer_state rs_state;
115 struct pipe_sampler_state *sampler_state;
116 struct pipe_vertex_element velem[2];
119 ctx = CALLOC_STRUCT(blitter_context_priv);
125 /* init state objects for them to be considered invalid */
126 ctx->blitter.saved_blend_state = INVALID_PTR;
127 ctx->blitter.saved_dsa_state = INVALID_PTR;
128 ctx->blitter.saved_rs_state = INVALID_PTR;
129 ctx->blitter.saved_fs = INVALID_PTR;
130 ctx->blitter.saved_vs = INVALID_PTR;
131 ctx->blitter.saved_velem_state = INVALID_PTR;
132 ctx->blitter.saved_fb_state.nr_cbufs = ~0;
133 ctx->blitter.saved_num_sampler_views = ~0;
134 ctx->blitter.saved_num_sampler_states = ~0;
136 /* blend state objects */
137 memset(&blend, 0, sizeof(blend));
138 ctx->blend_keep_color = pipe->create_blend_state(pipe, &blend);
140 blend.rt[0].colormask = PIPE_MASK_RGBA;
141 ctx->blend_write_color = pipe->create_blend_state(pipe, &blend);
143 /* depth stencil alpha state objects */
144 memset(&dsa, 0, sizeof(dsa));
145 ctx->dsa_keep_depth_stencil =
146 pipe->create_depth_stencil_alpha_state(pipe, &dsa);
148 dsa.depth.enabled = 1;
149 dsa.depth.writemask = 1;
150 dsa.depth.func = PIPE_FUNC_ALWAYS;
151 ctx->dsa_write_depth_keep_stencil =
152 pipe->create_depth_stencil_alpha_state(pipe, &dsa);
154 dsa.stencil[0].enabled = 1;
155 dsa.stencil[0].func = PIPE_FUNC_ALWAYS;
156 dsa.stencil[0].fail_op = PIPE_STENCIL_OP_REPLACE;
157 dsa.stencil[0].zpass_op = PIPE_STENCIL_OP_REPLACE;
158 dsa.stencil[0].zfail_op = PIPE_STENCIL_OP_REPLACE;
159 dsa.stencil[0].valuemask = 0xff;
160 dsa.stencil[0].writemask = 0xff;
161 ctx->dsa_write_depth_stencil =
162 pipe->create_depth_stencil_alpha_state(pipe, &dsa);
163 /* The DSA state objects which write depth and stencil are created
167 sampler_state = &ctx->template_sampler_state;
168 sampler_state->wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
169 sampler_state->wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
170 sampler_state->wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
171 /* The sampler state objects which sample from a specified mipmap level
172 * are created on-demand. */
174 /* rasterizer state */
175 memset(&rs_state, 0, sizeof(rs_state));
176 rs_state.front_winding = PIPE_WINDING_CW;
177 rs_state.cull_mode = PIPE_WINDING_NONE;
178 rs_state.gl_rasterization_rules = 1;
179 rs_state.flatshade = 1;
180 ctx->rs_state = pipe->create_rasterizer_state(pipe, &rs_state);
182 /* vertex elements state */
183 memset(&velem[0], 0, sizeof(velem[0]) * 2);
184 for (i = 0; i < 2; i++) {
185 velem[i].src_offset = i * 4 * sizeof(float);
186 velem[i].instance_divisor = 0;
187 velem[i].vertex_buffer_index = 0;
188 velem[i].src_format = PIPE_FORMAT_R32G32B32A32_FLOAT;
190 ctx->velem_state = pipe->create_vertex_elements_state(pipe, 2, &velem[0]);
192 /* fragment shaders are created on-demand */
196 const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,
197 TGSI_SEMANTIC_COLOR };
198 const uint semantic_indices[] = { 0, 0 };
200 util_make_vertex_passthrough_shader(pipe, 2, semantic_names,
204 const uint semantic_names[] = { TGSI_SEMANTIC_POSITION,
205 TGSI_SEMANTIC_GENERIC };
206 const uint semantic_indices[] = { 0, 0 };
208 util_make_vertex_passthrough_shader(pipe, 2, semantic_names,
212 /* set invariant vertex coordinates */
213 for (i = 0; i < 4; i++)
214 ctx->vertices[i][0][3] = 1; /*v.w*/
216 /* create the vertex buffer */
217 ctx->vbuf = pipe_buffer_create(ctx->pipe->screen,
218 PIPE_BIND_VERTEX_BUFFER,
219 sizeof(ctx->vertices));
221 return &ctx->blitter;
224 void util_blitter_destroy(struct blitter_context *blitter)
226 struct blitter_context_priv *ctx = (struct blitter_context_priv*)blitter;
227 struct pipe_context *pipe = ctx->pipe;
230 pipe->delete_blend_state(pipe, ctx->blend_write_color);
231 pipe->delete_blend_state(pipe, ctx->blend_keep_color);
232 pipe->delete_depth_stencil_alpha_state(pipe, ctx->dsa_keep_depth_stencil);
233 pipe->delete_depth_stencil_alpha_state(pipe,
234 ctx->dsa_write_depth_keep_stencil);
235 pipe->delete_depth_stencil_alpha_state(pipe, ctx->dsa_write_depth_stencil);
237 pipe->delete_rasterizer_state(pipe, ctx->rs_state);
238 pipe->delete_vs_state(pipe, ctx->vs_col);
239 pipe->delete_vs_state(pipe, ctx->vs_tex);
240 pipe->delete_vertex_elements_state(pipe, ctx->velem_state);
242 for (i = 0; i < PIPE_MAX_TEXTURE_TYPES; i++) {
243 if (ctx->fs_texfetch_col[i])
244 pipe->delete_fs_state(pipe, ctx->fs_texfetch_col[i]);
245 if (ctx->fs_texfetch_depth[i])
246 pipe->delete_fs_state(pipe, ctx->fs_texfetch_depth[i]);
249 for (i = 0; i < PIPE_MAX_COLOR_BUFS && ctx->fs_col[i]; i++)
251 pipe->delete_fs_state(pipe, ctx->fs_col[i]);
253 for (i = 0; i < PIPE_MAX_TEXTURE_LEVELS; i++)
254 if (ctx->sampler_state[i])
255 pipe->delete_sampler_state(pipe, ctx->sampler_state[i]);
257 if (ctx->sampler_view) {
258 pipe_sampler_view_reference(&ctx->sampler_view, NULL);
261 pipe_resource_reference(&ctx->vbuf, NULL);
265 static void blitter_check_saved_CSOs(struct blitter_context_priv *ctx)
267 /* make sure these CSOs have been saved */
268 assert(ctx->blitter.saved_blend_state != INVALID_PTR &&
269 ctx->blitter.saved_dsa_state != INVALID_PTR &&
270 ctx->blitter.saved_rs_state != INVALID_PTR &&
271 ctx->blitter.saved_fs != INVALID_PTR &&
272 ctx->blitter.saved_vs != INVALID_PTR &&
273 ctx->blitter.saved_velem_state != INVALID_PTR);
276 static void blitter_restore_CSOs(struct blitter_context_priv *ctx)
278 struct pipe_context *pipe = ctx->pipe;
280 /* restore the state objects which are always required to be saved */
281 pipe->bind_blend_state(pipe, ctx->blitter.saved_blend_state);
282 pipe->bind_depth_stencil_alpha_state(pipe, ctx->blitter.saved_dsa_state);
283 pipe->bind_rasterizer_state(pipe, ctx->blitter.saved_rs_state);
284 pipe->bind_fs_state(pipe, ctx->blitter.saved_fs);
285 pipe->bind_vs_state(pipe, ctx->blitter.saved_vs);
286 pipe->bind_vertex_elements_state(pipe, ctx->blitter.saved_velem_state);
288 ctx->blitter.saved_blend_state = INVALID_PTR;
289 ctx->blitter.saved_dsa_state = INVALID_PTR;
290 ctx->blitter.saved_rs_state = INVALID_PTR;
291 ctx->blitter.saved_fs = INVALID_PTR;
292 ctx->blitter.saved_vs = INVALID_PTR;
293 ctx->blitter.saved_velem_state = INVALID_PTR;
295 pipe->set_stencil_ref(pipe, &ctx->blitter.saved_stencil_ref);
297 pipe->set_viewport_state(pipe, &ctx->blitter.saved_viewport);
298 pipe->set_clip_state(pipe, &ctx->blitter.saved_clip);
300 /* restore the state objects which are required to be saved before copy/fill
302 if (ctx->blitter.saved_fb_state.nr_cbufs != ~0) {
303 pipe->set_framebuffer_state(pipe, &ctx->blitter.saved_fb_state);
304 ctx->blitter.saved_fb_state.nr_cbufs = ~0;
307 if (ctx->blitter.saved_num_sampler_states != ~0) {
308 pipe->bind_fragment_sampler_states(pipe,
309 ctx->blitter.saved_num_sampler_states,
310 ctx->blitter.saved_sampler_states);
311 ctx->blitter.saved_num_sampler_states = ~0;
314 if (ctx->blitter.saved_num_sampler_views != ~0) {
315 pipe->set_fragment_sampler_views(pipe,
316 ctx->blitter.saved_num_sampler_views,
317 ctx->blitter.saved_sampler_views);
318 ctx->blitter.saved_num_sampler_views = ~0;
322 static void blitter_set_rectangle(struct blitter_context_priv *ctx,
323 unsigned x1, unsigned y1,
324 unsigned x2, unsigned y2,
325 unsigned width, unsigned height,
330 /* set vertex positions */
331 ctx->vertices[0][0][0] = (float)x1 / width * 2.0f - 1.0f; /*v0.x*/
332 ctx->vertices[0][0][1] = (float)y1 / height * 2.0f - 1.0f; /*v0.y*/
334 ctx->vertices[1][0][0] = (float)x2 / width * 2.0f - 1.0f; /*v1.x*/
335 ctx->vertices[1][0][1] = (float)y1 / height * 2.0f - 1.0f; /*v1.y*/
337 ctx->vertices[2][0][0] = (float)x2 / width * 2.0f - 1.0f; /*v2.x*/
338 ctx->vertices[2][0][1] = (float)y2 / height * 2.0f - 1.0f; /*v2.y*/
340 ctx->vertices[3][0][0] = (float)x1 / width * 2.0f - 1.0f; /*v3.x*/
341 ctx->vertices[3][0][1] = (float)y2 / height * 2.0f - 1.0f; /*v3.y*/
343 for (i = 0; i < 4; i++)
344 ctx->vertices[i][0][2] = depth; /*z*/
347 ctx->viewport.scale[0] = 0.5f * width;
348 ctx->viewport.scale[1] = 0.5f * height;
349 ctx->viewport.scale[2] = 1.0f;
350 ctx->viewport.scale[3] = 1.0f;
351 ctx->viewport.translate[0] = 0.5f * width;
352 ctx->viewport.translate[1] = 0.5f * height;
353 ctx->viewport.translate[2] = 0.0f;
354 ctx->viewport.translate[3] = 0.0f;
355 ctx->pipe->set_viewport_state(ctx->pipe, &ctx->viewport);
358 ctx->pipe->set_clip_state(ctx->pipe, &ctx->clip);
361 static void blitter_set_clear_color(struct blitter_context_priv *ctx,
366 for (i = 0; i < 4; i++) {
367 ctx->vertices[i][1][0] = rgba[0];
368 ctx->vertices[i][1][1] = rgba[1];
369 ctx->vertices[i][1][2] = rgba[2];
370 ctx->vertices[i][1][3] = rgba[3];
374 static void blitter_set_texcoords_2d(struct blitter_context_priv *ctx,
375 struct pipe_surface *surf,
376 unsigned x1, unsigned y1,
377 unsigned x2, unsigned y2)
380 float s1 = x1 / (float)surf->width;
381 float t1 = y1 / (float)surf->height;
382 float s2 = x2 / (float)surf->width;
383 float t2 = y2 / (float)surf->height;
385 ctx->vertices[0][1][0] = s1; /*t0.s*/
386 ctx->vertices[0][1][1] = t1; /*t0.t*/
388 ctx->vertices[1][1][0] = s2; /*t1.s*/
389 ctx->vertices[1][1][1] = t1; /*t1.t*/
391 ctx->vertices[2][1][0] = s2; /*t2.s*/
392 ctx->vertices[2][1][1] = t2; /*t2.t*/
394 ctx->vertices[3][1][0] = s1; /*t3.s*/
395 ctx->vertices[3][1][1] = t2; /*t3.t*/
397 for (i = 0; i < 4; i++) {
398 ctx->vertices[i][1][2] = 0; /*r*/
399 ctx->vertices[i][1][3] = 1; /*q*/
403 static void blitter_set_texcoords_3d(struct blitter_context_priv *ctx,
404 struct pipe_surface *surf,
405 unsigned x1, unsigned y1,
406 unsigned x2, unsigned y2)
409 float depth = u_minify(surf->texture->depth0, surf->level);
410 float r = surf->zslice / depth;
412 blitter_set_texcoords_2d(ctx, surf, x1, y1, x2, y2);
414 for (i = 0; i < 4; i++)
415 ctx->vertices[i][1][2] = r; /*r*/
418 static void blitter_set_texcoords_cube(struct blitter_context_priv *ctx,
419 struct pipe_surface *surf,
420 unsigned x1, unsigned y1,
421 unsigned x2, unsigned y2)
424 float s1 = x1 / (float)surf->width;
425 float t1 = y1 / (float)surf->height;
426 float s2 = x2 / (float)surf->width;
427 float t2 = y2 / (float)surf->height;
439 util_map_texcoords2d_onto_cubemap(surf->face,
440 /* pointer, stride in floats */
442 &ctx->vertices[0][1][0], 8);
444 for (i = 0; i < 4; i++)
445 ctx->vertices[i][1][3] = 1; /*q*/
448 static void blitter_draw_quad(struct blitter_context_priv *ctx)
450 struct pipe_context *pipe = ctx->pipe;
452 /* write vertices and draw them */
453 pipe_buffer_write(pipe, ctx->vbuf,
454 0, sizeof(ctx->vertices), ctx->vertices);
456 util_draw_vertex_buffer(pipe, ctx->vbuf, 0, PIPE_PRIM_TRIANGLE_FAN,
458 2); /* attribs/vert */
462 void **blitter_get_sampler_state(struct blitter_context_priv *ctx,
465 struct pipe_context *pipe = ctx->pipe;
466 struct pipe_sampler_state *sampler_state = &ctx->template_sampler_state;
468 assert(miplevel < PIPE_MAX_TEXTURE_LEVELS);
470 /* Create the sampler state on-demand. */
471 if (!ctx->sampler_state[miplevel]) {
472 sampler_state->lod_bias = miplevel;
473 sampler_state->min_lod = miplevel;
474 sampler_state->max_lod = miplevel;
476 ctx->sampler_state[miplevel] = pipe->create_sampler_state(pipe,
480 /* Return void** so that it can be passed to bind_fragment_sampler_states
482 return &ctx->sampler_state[miplevel];
486 void *blitter_get_fs_col(struct blitter_context_priv *ctx, unsigned num_cbufs)
488 struct pipe_context *pipe = ctx->pipe;
489 unsigned index = num_cbufs ? num_cbufs - 1 : 0;
491 assert(num_cbufs <= PIPE_MAX_COLOR_BUFS);
493 if (!ctx->fs_col[index])
495 util_make_fragment_clonecolor_shader(pipe, num_cbufs);
497 return ctx->fs_col[index];
501 void *blitter_get_fs_texfetch_col(struct blitter_context_priv *ctx,
504 struct pipe_context *pipe = ctx->pipe;
506 assert(tex_target < PIPE_MAX_TEXTURE_TYPES);
508 /* Create the fragment shader on-demand. */
509 if (!ctx->fs_texfetch_col[tex_target]) {
510 switch (tex_target) {
511 case PIPE_TEXTURE_1D:
512 ctx->fs_texfetch_col[PIPE_TEXTURE_1D] =
513 util_make_fragment_tex_shader(pipe, TGSI_TEXTURE_1D);
515 case PIPE_TEXTURE_2D:
516 ctx->fs_texfetch_col[PIPE_TEXTURE_2D] =
517 util_make_fragment_tex_shader(pipe, TGSI_TEXTURE_2D);
519 case PIPE_TEXTURE_3D:
520 ctx->fs_texfetch_col[PIPE_TEXTURE_3D] =
521 util_make_fragment_tex_shader(pipe, TGSI_TEXTURE_3D);
523 case PIPE_TEXTURE_CUBE:
524 ctx->fs_texfetch_col[PIPE_TEXTURE_CUBE] =
525 util_make_fragment_tex_shader(pipe, TGSI_TEXTURE_CUBE);
531 return ctx->fs_texfetch_col[tex_target];
535 void *blitter_get_fs_texfetch_depth(struct blitter_context_priv *ctx,
538 struct pipe_context *pipe = ctx->pipe;
540 assert(tex_target < PIPE_MAX_TEXTURE_TYPES);
542 /* Create the fragment shader on-demand. */
543 if (!ctx->fs_texfetch_depth[tex_target]) {
544 switch (tex_target) {
545 case PIPE_TEXTURE_1D:
546 ctx->fs_texfetch_depth[PIPE_TEXTURE_1D] =
547 util_make_fragment_tex_shader_writedepth(pipe, TGSI_TEXTURE_1D);
549 case PIPE_TEXTURE_2D:
550 ctx->fs_texfetch_depth[PIPE_TEXTURE_2D] =
551 util_make_fragment_tex_shader_writedepth(pipe, TGSI_TEXTURE_2D);
553 case PIPE_TEXTURE_3D:
554 ctx->fs_texfetch_depth[PIPE_TEXTURE_3D] =
555 util_make_fragment_tex_shader_writedepth(pipe, TGSI_TEXTURE_3D);
557 case PIPE_TEXTURE_CUBE:
558 ctx->fs_texfetch_depth[PIPE_TEXTURE_CUBE] =
559 util_make_fragment_tex_shader_writedepth(pipe,TGSI_TEXTURE_CUBE);
565 return ctx->fs_texfetch_depth[tex_target];
568 void util_blitter_clear(struct blitter_context *blitter,
569 unsigned width, unsigned height,
571 unsigned clear_buffers,
573 double depth, unsigned stencil)
575 struct blitter_context_priv *ctx = (struct blitter_context_priv*)blitter;
576 struct pipe_context *pipe = ctx->pipe;
577 struct pipe_stencil_ref sr = { { 0 } };
579 assert(num_cbufs <= PIPE_MAX_COLOR_BUFS);
581 blitter_check_saved_CSOs(ctx);
584 if (clear_buffers & PIPE_CLEAR_COLOR)
585 pipe->bind_blend_state(pipe, ctx->blend_write_color);
587 pipe->bind_blend_state(pipe, ctx->blend_keep_color);
589 if (clear_buffers & PIPE_CLEAR_DEPTHSTENCIL) {
590 sr.ref_value[0] = stencil & 0xff;
591 pipe->bind_depth_stencil_alpha_state(pipe, ctx->dsa_write_depth_stencil);
592 pipe->set_stencil_ref(pipe, &sr);
595 pipe->bind_depth_stencil_alpha_state(pipe, ctx->dsa_keep_depth_stencil);
597 pipe->bind_rasterizer_state(pipe, ctx->rs_state);
598 pipe->bind_vertex_elements_state(pipe, ctx->velem_state);
599 pipe->bind_fs_state(pipe, blitter_get_fs_col(ctx, num_cbufs));
600 pipe->bind_vs_state(pipe, ctx->vs_col);
602 blitter_set_clear_color(ctx, rgba);
603 blitter_set_rectangle(ctx, 0, 0, width, height, width, height, depth);
604 blitter_draw_quad(ctx);
605 blitter_restore_CSOs(ctx);
609 is_overlap(unsigned sx1, unsigned sx2, unsigned sy1, unsigned sy2,
610 unsigned dx1, unsigned dx2, unsigned dy1, unsigned dy2)
612 if (sx1 >= dx2 || sx2 <= dx1 || sy1 >= dy2 || sy2 <= dy1) {
619 static void util_blitter_do_copy(struct blitter_context *blitter,
620 struct pipe_surface *dst,
621 unsigned dstx, unsigned dsty,
622 struct pipe_surface *src,
623 unsigned srcx, unsigned srcy,
624 unsigned width, unsigned height,
627 struct blitter_context_priv *ctx = (struct blitter_context_priv*)blitter;
628 struct pipe_context *pipe = ctx->pipe;
629 struct pipe_framebuffer_state fb_state;
630 struct pipe_sampler_view viewTempl, *view;
632 assert(blitter->saved_fb_state.nr_cbufs != ~0);
633 assert(blitter->saved_num_sampler_views != ~0);
634 assert(blitter->saved_num_sampler_states != ~0);
635 assert(src->texture->target < PIPE_MAX_TEXTURE_TYPES);
638 fb_state.width = dst->width;
639 fb_state.height = dst->height;
642 pipe->bind_blend_state(pipe, ctx->blend_keep_color);
643 pipe->bind_depth_stencil_alpha_state(pipe,
644 ctx->dsa_write_depth_keep_stencil);
645 pipe->bind_fs_state(pipe,
646 blitter_get_fs_texfetch_depth(ctx, src->texture->target));
648 fb_state.nr_cbufs = 0;
649 fb_state.zsbuf = dst;
651 pipe->bind_blend_state(pipe, ctx->blend_write_color);
652 pipe->bind_depth_stencil_alpha_state(pipe, ctx->dsa_keep_depth_stencil);
653 pipe->bind_fs_state(pipe,
654 blitter_get_fs_texfetch_col(ctx, src->texture->target));
656 fb_state.nr_cbufs = 1;
657 fb_state.cbufs[0] = dst;
661 u_sampler_view_default_template(&viewTempl,
663 src->texture->format);
664 view = pipe->create_sampler_view(pipe,
668 if (ctx->sampler_view) {
669 pipe_sampler_view_reference(&ctx->sampler_view, NULL);
671 ctx->sampler_view = view;
673 pipe->bind_rasterizer_state(pipe, ctx->rs_state);
674 pipe->bind_vs_state(pipe, ctx->vs_tex);
675 pipe->bind_fragment_sampler_states(pipe, 1,
676 blitter_get_sampler_state(ctx, src->level));
677 pipe->bind_vertex_elements_state(pipe, ctx->velem_state);
678 pipe->set_fragment_sampler_views(pipe, 1, &view);
679 pipe->set_framebuffer_state(pipe, &fb_state);
681 /* set texture coordinates */
682 switch (src->texture->target) {
683 case PIPE_TEXTURE_1D:
684 case PIPE_TEXTURE_2D:
685 blitter_set_texcoords_2d(ctx, src, srcx, srcy,
686 srcx+width, srcy+height);
688 case PIPE_TEXTURE_3D:
689 blitter_set_texcoords_3d(ctx, src, srcx, srcy,
690 srcx+width, srcy+height);
692 case PIPE_TEXTURE_CUBE:
693 blitter_set_texcoords_cube(ctx, src, srcx, srcy,
694 srcx+width, srcy+height);
700 blitter_set_rectangle(ctx, dstx, dsty, dstx+width, dsty+height, dst->width, dst->height, 0);
701 blitter_draw_quad(ctx);
705 static void util_blitter_overlap_copy(struct blitter_context *blitter,
706 struct pipe_surface *dst,
707 unsigned dstx, unsigned dsty,
708 struct pipe_surface *src,
709 unsigned srcx, unsigned srcy,
710 unsigned width, unsigned height)
712 struct blitter_context_priv *ctx = (struct blitter_context_priv*)blitter;
713 struct pipe_context *pipe = ctx->pipe;
714 struct pipe_screen *screen = pipe->screen;
716 struct pipe_resource texTemp;
717 struct pipe_resource *texture;
718 struct pipe_surface *tex_surf;
720 /* check whether the states are properly saved */
721 blitter_check_saved_CSOs(ctx);
723 memset(&texTemp, 0, sizeof(texTemp));
724 texTemp.target = PIPE_TEXTURE_2D;
725 texTemp.format = dst->texture->format; /* XXX verify supported by driver! */
726 texTemp.last_level = 0;
727 texTemp.width0 = width;
728 texTemp.height0 = height;
731 texture = screen->resource_create(screen, &texTemp);
735 tex_surf = screen->get_tex_surface(screen, texture, 0, 0, 0,
736 PIPE_BIND_BLIT_SOURCE |
737 PIPE_BIND_BLIT_DESTINATION);
739 /* blit from the src to the temp */
740 util_blitter_do_copy(blitter, tex_surf, 0, 0,
744 util_blitter_do_copy(blitter, dst, dstx, dsty,
748 pipe_surface_reference(&tex_surf, NULL);
749 pipe_resource_reference(&texture, NULL);
750 blitter_restore_CSOs(ctx);
753 void util_blitter_copy(struct blitter_context *blitter,
754 struct pipe_surface *dst,
755 unsigned dstx, unsigned dsty,
756 struct pipe_surface *src,
757 unsigned srcx, unsigned srcy,
758 unsigned width, unsigned height,
759 boolean ignore_stencil)
761 struct blitter_context_priv *ctx = (struct blitter_context_priv*)blitter;
762 struct pipe_context *pipe = ctx->pipe;
763 struct pipe_screen *screen = pipe->screen;
764 boolean is_stencil, is_depth;
765 unsigned dst_tex_usage;
767 /* give up if textures are not set */
768 assert(dst->texture && src->texture);
769 if (!dst->texture || !src->texture)
772 if (dst->texture == src->texture) {
773 if (is_overlap(srcx, srcx + width, srcy, srcy + height,
774 dstx, dstx + width, dsty, dsty + height)) {
775 util_blitter_overlap_copy(blitter, dst, dstx, dsty, src, srcx, srcy,
781 is_depth = util_format_get_component_bits(src->format, UTIL_FORMAT_COLORSPACE_ZS, 0) != 0;
782 is_stencil = util_format_get_component_bits(src->format, UTIL_FORMAT_COLORSPACE_ZS, 1) != 0;
783 dst_tex_usage = is_depth || is_stencil ? PIPE_BIND_DEPTH_STENCIL :
784 PIPE_BIND_RENDER_TARGET;
786 /* check if we can sample from and render to the surfaces */
787 /* (assuming copying a stencil buffer is not possible) */
788 if ((!ignore_stencil && is_stencil) ||
789 !screen->is_format_supported(screen, dst->format, dst->texture->target,
791 !screen->is_format_supported(screen, src->format, src->texture->target,
792 PIPE_BIND_SAMPLER_VIEW, 0)) {
793 util_surface_copy(pipe, FALSE, dst, dstx, dsty, src, srcx, srcy,
798 /* check whether the states are properly saved */
799 blitter_check_saved_CSOs(ctx);
800 util_blitter_do_copy(blitter,
803 width, height, is_depth);
804 blitter_restore_CSOs(ctx);
807 void util_blitter_fill(struct blitter_context *blitter,
808 struct pipe_surface *dst,
809 unsigned dstx, unsigned dsty,
810 unsigned width, unsigned height,
813 struct blitter_context_priv *ctx = (struct blitter_context_priv*)blitter;
814 struct pipe_context *pipe = ctx->pipe;
815 struct pipe_screen *screen = pipe->screen;
816 struct pipe_framebuffer_state fb_state;
818 ubyte ub_rgba[4] = {0};
819 union util_color color;
822 assert(dst->texture);
826 /* check if we can render to the surface */
827 if (util_format_is_depth_or_stencil(dst->format) || /* unlikely, but you never know */
828 !screen->is_format_supported(screen, dst->format, dst->texture->target,
829 PIPE_BIND_RENDER_TARGET, 0)) {
830 util_surface_fill(pipe, dst, dstx, dsty, width, height, value);
834 /* unpack the color */
836 util_unpack_color_ub(dst->format, &color,
837 ub_rgba, ub_rgba+1, ub_rgba+2, ub_rgba+3);
838 for (i = 0; i < 4; i++)
839 rgba[i] = ubyte_to_float(ub_rgba[i]);
841 /* check the saved state */
842 blitter_check_saved_CSOs(ctx);
843 assert(blitter->saved_fb_state.nr_cbufs != ~0);
846 pipe->bind_blend_state(pipe, ctx->blend_write_color);
847 pipe->bind_depth_stencil_alpha_state(pipe, ctx->dsa_keep_depth_stencil);
848 pipe->bind_rasterizer_state(pipe, ctx->rs_state);
849 pipe->bind_fs_state(pipe, blitter_get_fs_col(ctx, 1));
850 pipe->bind_vs_state(pipe, ctx->vs_col);
851 pipe->bind_vertex_elements_state(pipe, ctx->velem_state);
853 /* set a framebuffer state */
854 fb_state.width = dst->width;
855 fb_state.height = dst->height;
856 fb_state.nr_cbufs = 1;
857 fb_state.cbufs[0] = dst;
859 pipe->set_framebuffer_state(pipe, &fb_state);
861 blitter_set_clear_color(ctx, rgba);
862 blitter_set_rectangle(ctx, 0, 0, width, height, dst->width, dst->height, 0);
863 blitter_draw_quad(ctx);
864 blitter_restore_CSOs(ctx);