1 /**************************************************************************
3 * Copyright 2007 Tungsten Graphics, Inc., Cedar Park, Texas.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
21 * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
31 * Builds per-tile display lists and executes them on calls to
37 #include "pipe/p_defines.h"
38 #include "util/u_framebuffer.h"
39 #include "util/u_inlines.h"
40 #include "util/u_memory.h"
41 #include "util/u_pack_color.h"
42 #include "lp_context.h"
43 #include "lp_memory.h"
45 #include "lp_scene_queue.h"
46 #include "lp_texture.h"
51 #include "lp_setup_context.h"
52 #include "lp_screen.h"
54 #include "state_tracker/sw_winsys.h"
56 #include "draw/draw_context.h"
57 #include "draw/draw_vbuf.h"
60 static void set_scene_state( struct lp_setup_context *, enum setup_state );
64 lp_setup_get_current_scene(struct lp_setup_context *setup)
67 set_scene_state( setup, SETUP_EMPTY );
74 * Check if the size of the current scene has exceeded the limit.
75 * If so, flush/render it.
78 setup_check_scene_size_and_flush(struct lp_setup_context *setup)
81 struct lp_scene *scene = lp_setup_get_current_scene(setup);
82 unsigned size = lp_scene_get_size(scene);
84 if (size > LP_MAX_SCENE_SIZE) {
85 /*printf("LLVMPIPE: scene size = %u, flushing.\n", size);*/
86 set_scene_state( setup, SETUP_FLUSHED );
87 /*assert(lp_scene_get_size(scene) == 0);*/
94 first_triangle( struct lp_setup_context *setup,
99 set_scene_state( setup, SETUP_ACTIVE );
100 lp_setup_choose_triangle( setup );
101 setup->triangle( setup, v0, v1, v2 );
105 first_line( struct lp_setup_context *setup,
106 const float (*v0)[4],
107 const float (*v1)[4])
109 set_scene_state( setup, SETUP_ACTIVE );
110 lp_setup_choose_line( setup );
111 setup->line( setup, v0, v1 );
115 first_point( struct lp_setup_context *setup,
116 const float (*v0)[4])
118 set_scene_state( setup, SETUP_ACTIVE );
119 lp_setup_choose_point( setup );
120 setup->point( setup, v0 );
123 static void reset_context( struct lp_setup_context *setup )
125 LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
127 /* Reset derived state */
128 setup->constants.stored_size = 0;
129 setup->constants.stored_data = NULL;
130 setup->fs.stored = NULL;
138 setup->clear.flags = 0;
139 setup->clear.clearzs.clearzs_mask = 0;
141 /* Have an explicit "start-binning" call and get rid of this
144 setup->line = first_line;
145 setup->point = first_point;
146 setup->triangle = first_triangle;
150 /** Rasterize all scene's bins */
152 lp_setup_rasterize_scene( struct lp_setup_context *setup )
154 struct lp_scene *scene = lp_setup_get_current_scene(setup);
155 struct llvmpipe_screen *screen = llvmpipe_screen(scene->pipe->screen);
157 pipe_mutex_lock(screen->rast_mutex);
158 lp_scene_rasterize(scene, screen->rast);
159 pipe_mutex_unlock(screen->rast_mutex);
161 reset_context( setup );
163 LP_DBG(DEBUG_SETUP, "%s done \n", __FUNCTION__);
169 begin_binning( struct lp_setup_context *setup )
171 struct lp_scene *scene = lp_setup_get_current_scene(setup);
172 boolean need_zsload = FALSE;
173 if (setup->fb.zsbuf &&
174 ((setup->clear.flags & PIPE_CLEAR_DEPTHSTENCIL) != PIPE_CLEAR_DEPTHSTENCIL) &&
175 util_format_is_depth_and_stencil(setup->fb.zsbuf->format))
178 LP_DBG(DEBUG_SETUP, "%s color: %s depth: %s\n", __FUNCTION__,
179 (setup->clear.flags & PIPE_CLEAR_COLOR) ? "clear": "load",
180 need_zsload ? "clear": "load");
182 if (setup->fb.nr_cbufs) {
183 if (setup->clear.flags & PIPE_CLEAR_COLOR) {
184 lp_scene_bin_everywhere( scene,
186 setup->clear.color );
187 scene->has_color_clear = TRUE;
191 if (setup->fb.zsbuf) {
192 if (setup->clear.flags & PIPE_CLEAR_DEPTHSTENCIL) {
194 scene->has_depthstencil_clear = TRUE;
195 lp_scene_bin_everywhere( scene,
196 lp_rast_clear_zstencil,
197 lp_rast_arg_clearzs(&setup->clear.clearzs) );
201 LP_DBG(DEBUG_SETUP, "%s done\n", __FUNCTION__);
205 /* This basically bins and then flushes any outstanding full-screen
208 * TODO: fast path for fullscreen clears and no triangles.
211 execute_clears( struct lp_setup_context *setup )
213 LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
215 begin_binning( setup );
216 lp_setup_rasterize_scene( setup );
221 set_scene_state( struct lp_setup_context *setup,
222 enum setup_state new_state )
224 unsigned old_state = setup->state;
226 if (old_state == new_state)
229 LP_DBG(DEBUG_SETUP, "%s old %d new %d\n", __FUNCTION__, old_state, new_state);
233 assert(old_state == SETUP_FLUSHED);
234 assert(setup->scene == NULL);
236 /* wait for a free/empty scene
238 setup->scene = lp_scene_dequeue(setup->empty_scenes, TRUE);
239 assert(lp_scene_is_empty(setup->scene));
240 lp_scene_begin_binning(setup->scene,
245 assert(old_state == SETUP_EMPTY);
246 assert(setup->scene != NULL);
250 assert(old_state == SETUP_EMPTY ||
251 old_state == SETUP_CLEARED);
252 assert(setup->scene != NULL);
253 begin_binning( setup );
257 if (old_state == SETUP_CLEARED)
258 execute_clears( setup );
260 lp_setup_rasterize_scene( setup );
261 assert(setup->scene == NULL);
265 assert(0 && "invalid setup state mode");
268 setup->state = new_state;
273 * \param flags bitmask of PIPE_FLUSH_x flags
276 lp_setup_flush( struct lp_setup_context *setup,
278 struct pipe_fence_handle **fence)
280 LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
283 struct lp_scene *scene = lp_setup_get_current_scene(setup);
284 union lp_rast_cmd_arg dummy = {0};
286 if (flags & (PIPE_FLUSH_SWAPBUFFERS |
288 /* Store colors in the linear color buffer(s).
289 * If we don't do this here, we'll end up converting the tiled
290 * data to linear in the texture_unmap() function, which will
291 * not be a parallel/threaded operation as here.
293 lp_scene_bin_everywhere(scene, lp_rast_store_linear_color, dummy);
298 /* if we're going to flush the setup/rasterization modules, emit
301 *fence = lp_setup_fence( setup );
306 set_scene_state( setup, SETUP_FLUSHED );
311 lp_setup_bind_framebuffer( struct lp_setup_context *setup,
312 const struct pipe_framebuffer_state *fb )
314 LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
316 /* Flush any old scene.
318 set_scene_state( setup, SETUP_FLUSHED );
321 * Ensure the old scene is not reused.
323 assert(!setup->scene);
325 /* Set new state. This will be picked up later when we next need a
328 util_copy_framebuffer_state(&setup->fb, fb);
333 lp_setup_clear( struct lp_setup_context *setup,
339 struct lp_scene *scene = lp_setup_get_current_scene(setup);
341 boolean full_zs_clear = TRUE;
344 LP_DBG(DEBUG_SETUP, "%s state %d\n", __FUNCTION__, setup->state);
347 if (flags & PIPE_CLEAR_COLOR) {
348 for (i = 0; i < 4; ++i)
349 setup->clear.color.clear_color[i] = float_to_ubyte(color[i]);
352 if (flags & PIPE_CLEAR_DEPTHSTENCIL) {
353 if (setup->fb.zsbuf &&
354 ((flags & PIPE_CLEAR_DEPTHSTENCIL) != PIPE_CLEAR_DEPTHSTENCIL) &&
355 util_format_is_depth_and_stencil(setup->fb.zsbuf->format))
356 full_zs_clear = FALSE;
359 setup->clear.clearzs.clearzs_value =
360 util_pack_z_stencil(setup->fb.zsbuf->format,
363 setup->clear.clearzs.clearzs_mask = 0xffffffff;
368 if (flags & PIPE_CLEAR_DEPTH) {
369 tmpval = util_pack_z(setup->fb.zsbuf->format,
371 switch (setup->fb.zsbuf->format) {
372 case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
375 case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
383 switch (setup->fb.zsbuf->format) {
384 case PIPE_FORMAT_Z24_UNORM_S8_USCALED:
386 tmpval = stencil << 24;
388 case PIPE_FORMAT_S8_USCALED_Z24_UNORM:
397 setup->clear.clearzs.clearzs_mask |= mask;
398 setup->clear.clearzs.clearzs_value =
399 (setup->clear.clearzs.clearzs_value & ~mask) | (tmpval & mask);
403 if (setup->state == SETUP_ACTIVE) {
404 /* Add the clear to existing scene. In the unusual case where
405 * both color and depth-stencil are being cleared when there's
406 * already been some rendering, we could discard the currently
407 * binned scene and start again, but I don't see that as being
410 if (flags & PIPE_CLEAR_COLOR) {
411 lp_scene_bin_everywhere( scene,
413 setup->clear.color );
414 scene->has_color_clear = TRUE;
417 if (flags & PIPE_CLEAR_DEPTHSTENCIL) {
419 scene->has_depthstencil_clear = TRUE;
421 setup->clear.clearzs.clearzs_mask = mask;
422 lp_scene_bin_everywhere( scene,
423 lp_rast_clear_zstencil,
424 lp_rast_arg_clearzs(&setup->clear.clearzs) );
431 /* Put ourselves into the 'pre-clear' state, specifically to try
432 * and accumulate multiple clears to color and depth_stencil
433 * buffers which the app or state-tracker might issue
436 set_scene_state( setup, SETUP_CLEARED );
438 setup->clear.flags |= flags;
446 struct pipe_fence_handle *
447 lp_setup_fence( struct lp_setup_context *setup )
449 if (setup->scene == NULL)
451 else if (setup->num_threads == 0)
455 struct lp_scene *scene = lp_setup_get_current_scene(setup);
456 const unsigned rank = setup->num_threads;
458 set_scene_state( setup, SETUP_ACTIVE );
460 assert(scene->fence == NULL);
462 /* The caller gets a reference, we keep a copy too, so need to
465 lp_fence_reference(&scene->fence, lp_fence_create(rank));
467 LP_DBG(DEBUG_SETUP, "%s rank %u\n", __FUNCTION__, rank);
469 return (struct pipe_fence_handle *) scene->fence;
475 lp_setup_set_triangle_state( struct lp_setup_context *setup,
477 boolean ccw_is_frontface,
479 boolean gl_rasterization_rules)
481 LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
483 setup->ccw_is_frontface = ccw_is_frontface;
484 setup->cullmode = cull_mode;
485 setup->triangle = first_triangle;
486 setup->scissor_test = scissor;
487 setup->pixel_offset = gl_rasterization_rules ? 0.5f : 0.0f;
493 lp_setup_set_fs_inputs( struct lp_setup_context *setup,
494 const struct lp_shader_input *input,
497 LP_DBG(DEBUG_SETUP, "%s %p %u\n", __FUNCTION__, (void *) input, nr);
499 memcpy( setup->fs.input, input, nr * sizeof input[0] );
500 setup->fs.nr_inputs = nr;
504 lp_setup_set_fs_variant( struct lp_setup_context *setup,
505 struct lp_fragment_shader_variant *variant)
507 LP_DBG(DEBUG_SETUP, "%s %p\n", __FUNCTION__,
509 /* FIXME: reference count */
511 setup->fs.current.variant = variant;
512 setup->dirty |= LP_SETUP_NEW_FS;
516 lp_setup_set_fs_constants(struct lp_setup_context *setup,
517 struct pipe_resource *buffer)
519 LP_DBG(DEBUG_SETUP, "%s %p\n", __FUNCTION__, (void *) buffer);
521 pipe_resource_reference(&setup->constants.current, buffer);
523 setup->dirty |= LP_SETUP_NEW_CONSTANTS;
528 lp_setup_set_alpha_ref_value( struct lp_setup_context *setup,
529 float alpha_ref_value )
531 LP_DBG(DEBUG_SETUP, "%s %f\n", __FUNCTION__, alpha_ref_value);
533 if(setup->fs.current.jit_context.alpha_ref_value != alpha_ref_value) {
534 setup->fs.current.jit_context.alpha_ref_value = alpha_ref_value;
535 setup->dirty |= LP_SETUP_NEW_FS;
540 lp_setup_set_stencil_ref_values( struct lp_setup_context *setup,
541 const ubyte refs[2] )
543 LP_DBG(DEBUG_SETUP, "%s %d %d\n", __FUNCTION__, refs[0], refs[1]);
545 if (setup->fs.current.jit_context.stencil_ref_front != refs[0] ||
546 setup->fs.current.jit_context.stencil_ref_back != refs[1]) {
547 setup->fs.current.jit_context.stencil_ref_front = refs[0];
548 setup->fs.current.jit_context.stencil_ref_back = refs[1];
549 setup->dirty |= LP_SETUP_NEW_FS;
554 lp_setup_set_blend_color( struct lp_setup_context *setup,
555 const struct pipe_blend_color *blend_color )
557 LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
561 if(memcmp(&setup->blend_color.current, blend_color, sizeof *blend_color) != 0) {
562 memcpy(&setup->blend_color.current, blend_color, sizeof *blend_color);
563 setup->dirty |= LP_SETUP_NEW_BLEND_COLOR;
569 lp_setup_set_scissor( struct lp_setup_context *setup,
570 const struct pipe_scissor_state *scissor )
572 LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
576 if (memcmp(&setup->scissor.current, scissor, sizeof(*scissor)) != 0) {
577 setup->scissor.current = *scissor; /* struct copy */
578 setup->dirty |= LP_SETUP_NEW_SCISSOR;
584 lp_setup_set_flatshade_first( struct lp_setup_context *setup,
585 boolean flatshade_first )
587 setup->flatshade_first = flatshade_first;
592 lp_setup_set_vertex_info( struct lp_setup_context *setup,
593 struct vertex_info *vertex_info )
595 /* XXX: just silently holding onto the pointer:
597 setup->vertex_info = vertex_info;
602 * Called during state validation when LP_NEW_SAMPLER_VIEW is set.
605 lp_setup_set_fragment_sampler_views(struct lp_setup_context *setup,
607 struct pipe_sampler_view **views)
611 LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
613 assert(num <= PIPE_MAX_SAMPLERS);
615 for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
616 struct pipe_sampler_view *view = i < num ? views[i] : NULL;
619 struct pipe_resource *tex = view->texture;
620 struct llvmpipe_resource *lp_tex = llvmpipe_resource(tex);
621 struct lp_jit_texture *jit_tex;
622 jit_tex = &setup->fs.current.jit_context.textures[i];
623 jit_tex->width = tex->width0;
624 jit_tex->height = tex->height0;
625 jit_tex->depth = tex->depth0;
626 jit_tex->last_level = tex->last_level;
628 /* We're referencing the texture's internal data, so save a
631 pipe_resource_reference(&setup->fs.current_tex[i], tex);
634 /* regular texture - setup array of mipmap level pointers */
636 for (j = 0; j <= tex->last_level; j++) {
638 llvmpipe_get_texture_image_all(lp_tex, j, LP_TEX_USAGE_READ,
639 LP_TEX_LAYOUT_LINEAR);
640 jit_tex->row_stride[j] = lp_tex->row_stride[j];
641 jit_tex->img_stride[j] = lp_tex->img_stride[j];
643 if (!jit_tex->data[j]) {
644 /* out of memory - use dummy tile memory */
645 jit_tex->data[j] = lp_get_dummy_tile();
646 jit_tex->width = TILE_SIZE;
647 jit_tex->height = TILE_SIZE;
649 jit_tex->last_level = 0;
650 jit_tex->row_stride[j] = 0;
651 jit_tex->img_stride[j] = 0;
656 /* display target texture/surface */
658 * XXX: Where should this be unmapped?
660 struct llvmpipe_screen *screen = llvmpipe_screen(tex->screen);
661 struct sw_winsys *winsys = screen->winsys;
662 jit_tex->data[0] = winsys->displaytarget_map(winsys, lp_tex->dt,
664 jit_tex->row_stride[0] = lp_tex->row_stride[0];
665 jit_tex->img_stride[0] = lp_tex->img_stride[0];
666 assert(jit_tex->data[0]);
671 setup->dirty |= LP_SETUP_NEW_FS;
676 * Is the given texture referenced by any scene?
677 * Note: we have to check all scenes including any scenes currently
678 * being rendered and the current scene being built.
681 lp_setup_is_resource_referenced( const struct lp_setup_context *setup,
682 const struct pipe_resource *texture )
686 /* check the render targets */
687 for (i = 0; i < setup->fb.nr_cbufs; i++) {
688 if (setup->fb.cbufs[i]->texture == texture)
689 return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
691 if (setup->fb.zsbuf && setup->fb.zsbuf->texture == texture) {
692 return PIPE_REFERENCED_FOR_READ | PIPE_REFERENCED_FOR_WRITE;
695 /* check textures referenced by the scene */
696 for (i = 0; i < Elements(setup->scenes); i++) {
697 if (lp_scene_is_resource_referenced(setup->scenes[i], texture)) {
698 return PIPE_REFERENCED_FOR_READ;
702 return PIPE_UNREFERENCED;
707 * Called by vbuf code when we're about to draw something.
710 lp_setup_update_state( struct lp_setup_context *setup )
712 struct lp_scene *scene;
714 LP_DBG(DEBUG_SETUP, "%s\n", __FUNCTION__);
716 setup_check_scene_size_and_flush(setup);
718 scene = lp_setup_get_current_scene(setup);
720 assert(setup->fs.current.variant);
722 /* Some of the 'draw' pipeline stages may have changed some driver state.
723 * Make sure we've processed those state changes before anything else.
725 * XXX this is the only place where llvmpipe_context is used in the
726 * setup code. This may get refactored/changed...
729 struct llvmpipe_context *lp = llvmpipe_context(scene->pipe);
731 llvmpipe_update_derived(lp);
733 assert(lp->dirty == 0);
736 if(setup->dirty & LP_SETUP_NEW_BLEND_COLOR) {
740 stored = lp_scene_alloc_aligned(scene, 4 * 16, 16);
743 /* smear each blend color component across 16 ubyte elements */
744 for (i = 0; i < 4; ++i) {
745 uint8_t c = float_to_ubyte(setup->blend_color.current.color[i]);
746 for (j = 0; j < 16; ++j)
747 stored[i*16 + j] = c;
750 setup->blend_color.stored = stored;
752 setup->fs.current.jit_context.blend_color = setup->blend_color.stored;
755 setup->dirty |= LP_SETUP_NEW_FS;
758 if(setup->dirty & LP_SETUP_NEW_CONSTANTS) {
759 struct pipe_resource *buffer = setup->constants.current;
762 unsigned current_size = buffer->width0;
763 const void *current_data = llvmpipe_resource_data(buffer);
765 /* TODO: copy only the actually used constants? */
767 if(setup->constants.stored_size != current_size ||
768 !setup->constants.stored_data ||
769 memcmp(setup->constants.stored_data,
771 current_size) != 0) {
774 stored = lp_scene_alloc(scene, current_size);
779 setup->constants.stored_size = current_size;
780 setup->constants.stored_data = stored;
785 setup->constants.stored_size = 0;
786 setup->constants.stored_data = NULL;
789 setup->fs.current.jit_context.constants = setup->constants.stored_data;
790 setup->dirty |= LP_SETUP_NEW_FS;
794 if(setup->dirty & LP_SETUP_NEW_FS) {
795 if(!setup->fs.stored ||
796 memcmp(setup->fs.stored,
798 sizeof setup->fs.current) != 0) {
799 /* The fs state that's been stored in the scene is different from
800 * the new, current state. So allocate a new lp_rast_state object
801 * and append it to the bin's setup data buffer.
804 struct lp_rast_state *stored =
805 (struct lp_rast_state *) lp_scene_alloc(scene, sizeof *stored);
809 sizeof setup->fs.current);
810 setup->fs.stored = stored;
813 /* The scene now references the textures in the rasterization
814 * state record. Note that now.
816 for (i = 0; i < Elements(setup->fs.current_tex); i++) {
817 if (setup->fs.current_tex[i])
818 lp_scene_add_resource_reference(scene, setup->fs.current_tex[i]);
825 assert(setup->fs.stored);
830 /* Only caller is lp_setup_vbuf_destroy()
833 lp_setup_destroy( struct lp_setup_context *setup )
837 reset_context( setup );
839 util_unreference_framebuffer_state(&setup->fb);
841 for (i = 0; i < Elements(setup->fs.current_tex); i++) {
842 pipe_resource_reference(&setup->fs.current_tex[i], NULL);
845 pipe_resource_reference(&setup->constants.current, NULL);
847 /* free the scenes in the 'empty' queue */
849 struct lp_scene *scene = lp_scene_dequeue(setup->empty_scenes, FALSE);
852 lp_scene_destroy(scene);
855 lp_scene_queue_destroy(setup->empty_scenes);
862 * Create a new primitive tiling engine. Plug it into the backend of
863 * the draw module. Currently also creates a rasterizer to use with
866 struct lp_setup_context *
867 lp_setup_create( struct pipe_context *pipe,
868 struct draw_context *draw )
870 struct llvmpipe_screen *screen = llvmpipe_screen(pipe->screen);
871 struct lp_setup_context *setup = CALLOC_STRUCT(lp_setup_context);
877 lp_setup_init_vbuf(setup);
879 setup->empty_scenes = lp_scene_queue_create();
880 if (!setup->empty_scenes)
883 setup->num_threads = screen->num_threads;
884 setup->vbuf = draw_vbuf_stage(draw, &setup->base);
888 draw_set_rasterize_stage(draw, setup->vbuf);
889 draw_set_render(draw, &setup->base);
891 /* create some empty scenes */
892 for (i = 0; i < MAX_SCENES; i++) {
893 setup->scenes[i] = lp_scene_create( pipe, setup->empty_scenes );
895 lp_scene_enqueue(setup->empty_scenes, setup->scenes[i]);
898 setup->triangle = first_triangle;
899 setup->line = first_line;
900 setup->point = first_point;
910 if (setup->empty_scenes)
911 lp_scene_queue_destroy(setup->empty_scenes);
919 * Put a BeginQuery command into all bins.
922 lp_setup_begin_query(struct lp_setup_context *setup,
923 struct llvmpipe_query *pq)
925 struct lp_scene * scene = lp_setup_get_current_scene(setup);
926 union lp_rast_cmd_arg cmd_arg;
928 /* init the query to its beginning state */
931 pq->num_tiles = scene->tiles_x * scene->tiles_y;
932 assert(pq->num_tiles > 0);
934 memset(pq->count, 0, sizeof(pq->count)); /* reset all counters */
936 set_scene_state( setup, SETUP_ACTIVE );
938 cmd_arg.query_obj = pq;
939 lp_scene_bin_everywhere(scene, lp_rast_begin_query, cmd_arg);
945 * Put an EndQuery command into all bins.
948 lp_setup_end_query(struct lp_setup_context *setup, struct llvmpipe_query *pq)
950 struct lp_scene * scene = lp_setup_get_current_scene(setup);
951 union lp_rast_cmd_arg cmd_arg;
953 set_scene_state( setup, SETUP_ACTIVE );
955 cmd_arg.query_obj = pq;
956 lp_scene_bin_everywhere(scene, lp_rast_end_query, cmd_arg);