fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2026-05-05 13:58:04 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

llvmpipe: fixes for conditional rendering

Browse source 
honor render_condition for clear_render_target and clear_depth_stencil.
Also add minimal support for occlusion predicate, though it can't be active
at the same time as an occlusion query yet.
While here also switchify some large if-else (actually just mutually
exclusive if-if-if...) constructs.

Reviewed-by: Jose Fonseca <jfonseca@vmware.com>
This commit is contained in:
Roland Scheidegger 2013-06-18 00:42:31 +02:00
parent 793e8e3d7e
commit 8975dc798d
4 changed files with 86 additions and 36 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/gallium/drivers/llvmpipe/lp_bld_depth.c
View file

@ -429,6 +429,7 @@ get_s_shift_and_mask(const struct util_format_description *format_desc,
* Test the depth mask. Add the number of channel which has none zero mask
* into the occlusion counter. e.g. maskvalue is {-1, -1, -1, -1}.
* The counter will add 4.
* TODO: could get that out of the loop, and need to use 64bit counter.
*
* \param type holds element type of the mask vector.
* \param maskvalue is the depth test mask.

77
src/gallium/drivers/llvmpipe/lp_query.c
View file

@ -125,6 +125,12 @@ llvmpipe_get_query_result(struct pipe_context *pipe,
*result += pq->count[i];
}
break;
case PIPE_QUERY_OCCLUSION_PREDICATE:
for (i = 0; i < num_threads; i++) {
/* safer (still not guaranteed) when there's an overflow */
*result = *result || pq->count[i];
}
break;
case PIPE_QUERY_TIMESTAMP:
for (i = 0; i < num_threads; i++) {
if (pq->count[i] > *result) {
@ -183,28 +189,25 @@ llvmpipe_begin_query(struct pipe_context *pipe, struct pipe_query *q)
memset(pq->count, 0, sizeof(pq->count));
lp_setup_begin_query(llvmpipe->setup, pq);
if (pq->type == PIPE_QUERY_PRIMITIVES_EMITTED) {
switch (pq->type) {
case PIPE_QUERY_PRIMITIVES_EMITTED:
pq->num_primitives_written = 0;
llvmpipe->so_stats.num_primitives_written = 0;
}
if (pq->type == PIPE_QUERY_PRIMITIVES_GENERATED) {
break;
case PIPE_QUERY_PRIMITIVES_GENERATED:
pq->num_primitives_generated = 0;
llvmpipe->num_primitives_generated = 0;
}
if (pq->type == PIPE_QUERY_SO_STATISTICS) {
break;
case PIPE_QUERY_SO_STATISTICS:
pq->num_primitives_written = 0;
llvmpipe->so_stats.num_primitives_written = 0;
pq->num_primitives_generated = 0;
llvmpipe->num_primitives_generated = 0;
}
if (pq->type == PIPE_QUERY_SO_OVERFLOW_PREDICATE) {
break;
case PIPE_QUERY_SO_OVERFLOW_PREDICATE:
pq->so_has_overflown = FALSE;
}
if (pq->type == PIPE_QUERY_PIPELINE_STATISTICS) {
break;
case PIPE_QUERY_PIPELINE_STATISTICS:
/* reset our cache */
if (llvmpipe->active_statistics_queries == 0) {
memset(&llvmpipe->pipeline_statistics, 0,
@ -212,11 +215,16 @@ llvmpipe_begin_query(struct pipe_context *pipe, struct pipe_query *q)
}
memcpy(&pq->stats, &llvmpipe->pipeline_statistics, sizeof(pq->stats));
llvmpipe->active_statistics_queries++;
}
if (pq->type == PIPE_QUERY_OCCLUSION_COUNTER) {
llvmpipe->active_occlusion_query = TRUE;
break;
case PIPE_QUERY_OCCLUSION_COUNTER:
case PIPE_QUERY_OCCLUSION_PREDICATE:
/* Both active at same time will still fail all over the place.
* Then again several of each type can be active too... */
llvmpipe->active_occlusion_query++;
llvmpipe->dirty |= LP_NEW_OCCLUSION_QUERY;
break;
default:
break;
}
}
@ -229,25 +237,23 @@ llvmpipe_end_query(struct pipe_context *pipe, struct pipe_query *q)
lp_setup_end_query(llvmpipe->setup, pq);
if (pq->type == PIPE_QUERY_PRIMITIVES_EMITTED) {
switch (pq->type) {
case PIPE_QUERY_PRIMITIVES_EMITTED:
pq->num_primitives_written = llvmpipe->so_stats.num_primitives_written;
}
if (pq->type == PIPE_QUERY_PRIMITIVES_GENERATED) {
break;
case PIPE_QUERY_PRIMITIVES_GENERATED:
pq->num_primitives_generated = llvmpipe->num_primitives_generated;
}
if (pq->type == PIPE_QUERY_SO_STATISTICS) {
break;
case PIPE_QUERY_SO_STATISTICS:
pq->num_primitives_written = llvmpipe->so_stats.num_primitives_written;
pq->num_primitives_generated = llvmpipe->num_primitives_generated;
}
if (pq->type == PIPE_QUERY_SO_OVERFLOW_PREDICATE) {
break;
case PIPE_QUERY_SO_OVERFLOW_PREDICATE:
pq->so_has_overflown = (llvmpipe->num_primitives_generated >
llvmpipe->so_stats.num_primitives_written);
}
if (pq->type == PIPE_QUERY_PIPELINE_STATISTICS) {
break;
case PIPE_QUERY_PIPELINE_STATISTICS:
pq->stats.ia_vertices =
llvmpipe->pipeline_statistics.ia_vertices - pq->stats.ia_vertices;
pq->stats.ia_primitives =
@ -266,12 +272,15 @@ llvmpipe_end_query(struct pipe_context *pipe, struct pipe_query *q)
llvmpipe->pipeline_statistics.ps_invocations - pq->stats.ps_invocations;
llvmpipe->active_statistics_queries--;
}
if (pq->type == PIPE_QUERY_OCCLUSION_COUNTER) {
break;
case PIPE_QUERY_OCCLUSION_COUNTER:
case PIPE_QUERY_OCCLUSION_PREDICATE:
assert(llvmpipe->active_occlusion_query);
llvmpipe->active_occlusion_query = FALSE;
llvmpipe->active_occlusion_query--;
llvmpipe->dirty |= LP_NEW_OCCLUSION_QUERY;
break;
default:
break;
}
}

2
src/gallium/drivers/llvmpipe/lp_rast.c
View file

@ -490,6 +490,7 @@ lp_rast_begin_query(struct lp_rasterizer_task *task,
switch (pq->type) {
case PIPE_QUERY_OCCLUSION_COUNTER:
case PIPE_QUERY_OCCLUSION_PREDICATE:
task->thread_data.vis_counter = 0;
break;
case PIPE_QUERY_PRIMITIVES_GENERATED:
@ -521,6 +522,7 @@ lp_rast_end_query(struct lp_rasterizer_task *task,
switch (pq->type) {
case PIPE_QUERY_OCCLUSION_COUNTER:
case PIPE_QUERY_OCCLUSION_PREDICATE:
pq->count[task->thread_index] += task->thread_data.vis_counter;
break;
case PIPE_QUERY_TIMESTAMP:

42
src/gallium/drivers/llvmpipe/lp_surface.c
View file

@ -32,6 +32,7 @@
#include "lp_limits.h"
#include "lp_surface.h"
#include "lp_texture.h"
#include "lp_query.h"
/**
@ -286,11 +287,48 @@ llvmpipe_surface_destroy(struct pipe_context *pipe,
}
static void
llvmpipe_clear_render_target(struct pipe_context *pipe,
struct pipe_surface *dst,
const union pipe_color_union *color,
unsigned dstx, unsigned dsty,
unsigned width, unsigned height)
{
struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
if (!llvmpipe_check_render_cond(llvmpipe))
return;
util_clear_render_target(pipe, dst, color,
dstx, dsty, width, height);
}
static void
llvmpipe_clear_depth_stencil(struct pipe_context *pipe,
struct pipe_surface *dst,
unsigned clear_flags,
double depth,
unsigned stencil,
unsigned dstx, unsigned dsty,
unsigned width, unsigned height)
{
struct llvmpipe_context *llvmpipe = llvmpipe_context(pipe);
if (!llvmpipe_check_render_cond(llvmpipe))
return;
util_clear_depth_stencil(pipe, dst, clear_flags,
depth, stencil,
dstx, dsty, width, height);
}
void
llvmpipe_init_surface_functions(struct llvmpipe_context *lp)
{
lp->pipe.clear_render_target = util_clear_render_target;
lp->pipe.clear_depth_stencil = util_clear_depth_stencil;
lp->pipe.clear_render_target = llvmpipe_clear_render_target;
lp->pipe.clear_depth_stencil = llvmpipe_clear_depth_stencil;
lp->pipe.create_surface = llvmpipe_create_surface;
lp->pipe.surface_destroy = llvmpipe_surface_destroy;
/* These two are not actually functions dealing with surfaces */