AlexIndustrial/mesa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge remote branch 'upstream/gallium-0.1' into nouveau-gallium-0.1

Browse Source
This commit is contained in:
Ben Skeggs
2008-03-21 00:11:25 +11:00
parent 62767cf2dd 122ed506f4
commit c7e9cb1093
35 changed files with 595 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files
progs/tests/mipmap_view.c
+16 -9
View File
@@ -55,17 +55,10 @@ Display(void)
for (bias = -1; bias < 11; bias++) {
glRasterPos2f(x, y + TexHeight + 5);
sprintf(str, "Texture LOD Bias = %d", bias);
PrintString(str);
glPushMatrix();
glTranslatef(x, y, 0);
glEnable(GL_TEXTURE_2D);
if (ScaleQuads) {
if (bias > 0) {
if (texWidth == 1 && texHeight == 1)
break;
texWidth = TexWidth >> bias;
texHeight = TexHeight >> bias;
if (texWidth < 1)
@@ -79,6 +72,20 @@ Display(void)
glTexEnvf(GL_TEXTURE_FILTER_CONTROL_EXT, GL_TEXTURE_LOD_BIAS_EXT, bias);
}
glRasterPos2f(x, y + TexHeight + 5);
if (ScaleQuads)
sprintf(str, "Texture Level %d: %d x %d",
(bias < 0 ? 0 : bias),
texWidth, texHeight);
else
sprintf(str, "Texture LOD Bias = %d", bias);
PrintString(str);
glPushMatrix();
glTranslatef(x, y, 0);
glEnable(GL_TEXTURE_2D);
glBegin(GL_POLYGON);
glTexCoord2f(0, 0); glVertex2f(0, 0);
glTexCoord2f(1, 0); glVertex2f(texWidth, 0);
src/gallium/auxiliary/cso_cache/cso_context.c
+187 -21
View File
@@ -52,11 +52,27 @@ struct cso_context {
void *samplers[PIPE_MAX_SAMPLERS];
unsigned nr_samplers;
void *blend;
void *depth_stencil;
void *rasterizer;
void *fragment_shader;
void *vertex_shader;
void *samplers_saved[PIPE_MAX_SAMPLERS];
unsigned nr_samplers_saved;
struct pipe_texture *textures[PIPE_MAX_SAMPLERS];
uint nr_textures;
struct pipe_texture *textures_saved[PIPE_MAX_SAMPLERS];
uint nr_textures_saved;
/** Current and saved state.
* The saved state is used as a 1-deep stack.
*/
void *blend, *blend_saved;
void *depth_stencil, *depth_stencil_saved;
void *rasterizer, *rasterizer_saved;
void *fragment_shader, *fragment_shader_saved;
void *vertex_shader, *vertex_shader_saved;
struct pipe_framebuffer_state fb, fb_saved;
struct pipe_viewport_state vp, vp_saved;
struct pipe_blend_color blend_color;
};
@@ -149,11 +165,22 @@ void cso_set_blend(struct cso_context *ctx,
}
}
void cso_unset_blend(struct cso_context *ctx)
void cso_save_blend(struct cso_context *ctx)
{
ctx->blend = NULL;
assert(!ctx->blend_saved);
ctx->blend_saved = ctx->blend;
}
void cso_restore_blend(struct cso_context *ctx)
{
if (ctx->blend != ctx->blend_saved) {
ctx->blend = ctx->blend_saved;
ctx->pipe->bind_blend_state(ctx->pipe, ctx->blend_saved);
}
ctx->blend_saved = NULL;
}
void cso_single_sampler(struct cso_context *ctx,
unsigned idx,
@@ -190,9 +217,11 @@ void cso_single_sampler_done( struct cso_context *ctx )
{
unsigned i;
for (i = 0; i < 8; i++)
if (ctx->samplers[i] == NULL)
/* find highest non-null sampler */
for (i = PIPE_MAX_SAMPLERS; i > 0; i--) {
if (ctx->samplers[i - 1] != NULL)
break;
}
ctx->nr_samplers = i;
@@ -226,13 +255,48 @@ void cso_set_samplers( struct cso_context *ctx,
cso_single_sampler_done( ctx );
}
void cso_unset_samplers( struct cso_context *ctx )
void cso_save_samplers(struct cso_context *ctx)
{
ctx->nr_samplers_saved = ctx->nr_samplers;
memcpy(ctx->samplers_saved, ctx->samplers, sizeof(ctx->samplers));
}
void cso_restore_samplers(struct cso_context *ctx)
{
cso_set_samplers(ctx, ctx->nr_samplers_saved,
(const struct pipe_sampler_state **) ctx->samplers_saved);
}
void cso_set_sampler_textures( struct cso_context *ctx,
uint count,
struct pipe_texture **textures )
{
uint i;
for (i = 0; i < ctx->nr_samplers; i++)
ctx->samplers[i] = NULL;
ctx->nr_textures = count;
for (i = 0; i < count; i++)
ctx->textures[i] = textures[i];
for ( ; i < PIPE_MAX_SAMPLERS; i++)
ctx->textures[i] = NULL;
ctx->pipe->set_sampler_textures(ctx->pipe, count, textures);
}
void cso_save_sampler_textures( struct cso_context *ctx )
{
ctx->nr_textures_saved = ctx->nr_textures;
memcpy(ctx->textures_saved, ctx->textures, sizeof(ctx->textures));
}
void cso_restore_sampler_textures( struct cso_context *ctx )
{
cso_set_sampler_textures(ctx, ctx->nr_textures_saved, ctx->textures_saved);
ctx->nr_textures_saved = 0;
}
void cso_set_depth_stencil_alpha(struct cso_context *ctx,
@@ -267,15 +331,25 @@ void cso_set_depth_stencil_alpha(struct cso_context *ctx,
}
}
void cso_unset_depth_stencil_alpha(struct cso_context *ctx)
void cso_save_depth_stencil_alpha(struct cso_context *ctx)
{
ctx->depth_stencil = NULL;
assert(!ctx->depth_stencil_saved);
ctx->depth_stencil_saved = ctx->depth_stencil;
}
void cso_restore_depth_stencil_alpha(struct cso_context *ctx)
{
if (ctx->depth_stencil != ctx->depth_stencil_saved) {
ctx->depth_stencil = ctx->depth_stencil_saved;
ctx->pipe->bind_depth_stencil_alpha_state(ctx->pipe, ctx->depth_stencil_saved);
}
ctx->depth_stencil_saved = NULL;
}
void cso_set_rasterizer(struct cso_context *ctx,
const struct pipe_rasterizer_state *templ)
const struct pipe_rasterizer_state *templ)
{
unsigned hash_key = cso_construct_key((void*)templ,
sizeof(struct pipe_rasterizer_state));
@@ -305,11 +379,20 @@ void cso_set_rasterizer(struct cso_context *ctx,
}
}
void cso_unset_rasterizer(struct cso_context *ctx)
void cso_save_rasterizer(struct cso_context *ctx)
{
ctx->rasterizer = NULL;
assert(!ctx->rasterizer_saved);
ctx->rasterizer_saved = ctx->rasterizer;
}
void cso_restore_rasterizer(struct cso_context *ctx)
{
if (ctx->rasterizer != ctx->rasterizer_saved) {
ctx->rasterizer = ctx->rasterizer_saved;
ctx->pipe->bind_rasterizer_state(ctx->pipe, ctx->rasterizer_saved);
}
ctx->rasterizer_saved = NULL;
}
void cso_set_fragment_shader(struct cso_context *ctx,
@@ -343,11 +426,23 @@ void cso_set_fragment_shader(struct cso_context *ctx,
}
}
void cso_unset_fragment_shader(struct cso_context *ctx)
void cso_save_fragment_shader(struct cso_context *ctx)
{
ctx->fragment_shader = NULL;
assert(!ctx->fragment_shader_saved);
ctx->fragment_shader_saved = ctx->fragment_shader;
}
void cso_restore_fragment_shader(struct cso_context *ctx)
{
assert(ctx->fragment_shader_saved);
if (ctx->fragment_shader_saved != ctx->fragment_shader) {
ctx->pipe->bind_fs_state(ctx->pipe, ctx->fragment_shader_saved);
ctx->fragment_shader = ctx->fragment_shader_saved;
}
ctx->fragment_shader_saved = NULL;
}
void cso_set_vertex_shader(struct cso_context *ctx,
const struct pipe_shader_state *templ)
@@ -380,7 +475,78 @@ void cso_set_vertex_shader(struct cso_context *ctx,
}
}
void cso_unset_vertex_shader(struct cso_context *ctx)
void cso_save_vertex_shader(struct cso_context *ctx)
{
ctx->vertex_shader = NULL;
assert(!ctx->vertex_shader_saved);
ctx->vertex_shader_saved = ctx->vertex_shader;
}
void cso_restore_vertex_shader(struct cso_context *ctx)
{
assert(ctx->vertex_shader_saved);
if (ctx->vertex_shader_saved != ctx->vertex_shader) {
ctx->pipe->bind_fs_state(ctx->pipe, ctx->vertex_shader_saved);
ctx->vertex_shader = ctx->vertex_shader_saved;
}
ctx->vertex_shader_saved = NULL;
}
void cso_set_framebuffer(struct cso_context *ctx,
const struct pipe_framebuffer_state *fb)
{
if (memcmp(&ctx->fb, fb, sizeof(*fb))) {
ctx->fb = *fb;
ctx->pipe->set_framebuffer_state(ctx->pipe, fb);
}
}
void cso_save_framebuffer(struct cso_context *ctx)
{
ctx->fb_saved = ctx->fb;
}
void cso_restore_framebuffer(struct cso_context *ctx)
{
if (memcmp(&ctx->fb, &ctx->fb_saved, sizeof(ctx->fb))) {
ctx->fb = ctx->fb_saved;
ctx->pipe->set_framebuffer_state(ctx->pipe, &ctx->fb);
}
}
void cso_set_viewport(struct cso_context *ctx,
const struct pipe_viewport_state *vp)
{
if (memcmp(&ctx->vp, vp, sizeof(*vp))) {
ctx->vp = *vp;
ctx->pipe->set_viewport_state(ctx->pipe, vp);
}
}
void cso_save_viewport(struct cso_context *ctx)
{
ctx->vp_saved = ctx->vp;
}
void cso_restore_viewport(struct cso_context *ctx)
{
if (memcmp(&ctx->vp, &ctx->vp_saved, sizeof(ctx->vp))) {
ctx->vp = ctx->vp_saved;
ctx->pipe->set_viewport_state(ctx->pipe, &ctx->vp);
}
}
void cso_set_blend_color(struct cso_context *ctx,
const struct pipe_blend_color *bc)
{
if (memcmp(&ctx->blend_color, bc, sizeof(ctx->blend_color))) {
ctx->blend_color = *bc;
ctx->pipe->set_blend_color(ctx->pipe, bc);
}
}
src/gallium/auxiliary/cso_cache/cso_context.h
+44 -9
View File
@@ -41,27 +41,36 @@ struct cso_context;
struct cso_context *cso_create_context( struct pipe_context *pipe );
void cso_destroy_context( struct cso_context *cso );
void cso_set_blend( struct cso_context *cso,
const struct pipe_blend_state *blend );
void cso_save_blend(struct cso_context *cso);
void cso_restore_blend(struct cso_context *cso);
void cso_unset_blend(struct cso_context *cso);
void cso_set_depth_stencil_alpha( struct cso_context *cso,
const struct pipe_depth_stencil_alpha_state *dsa );
void cso_save_depth_stencil_alpha(struct cso_context *cso);
void cso_restore_depth_stencil_alpha(struct cso_context *cso);
void cso_unset_depth_stencil_alpha( struct cso_context *cso );
void cso_set_rasterizer( struct cso_context *cso,
const struct pipe_rasterizer_state *rasterizer );
void cso_save_rasterizer(struct cso_context *cso);
void cso_restore_rasterizer(struct cso_context *cso);
void cso_unset_rasterizer( struct cso_context *cso );
void cso_set_samplers( struct cso_context *cso,
unsigned count,
const struct pipe_sampler_state **states );
void cso_unset_samplers( struct cso_context *cso );
void cso_save_samplers(struct cso_context *cso);
void cso_restore_samplers(struct cso_context *cso);
/* Alternate interface to support state trackers that like to modify
* samplers one at a time:
@@ -73,6 +82,15 @@ void cso_single_sampler( struct cso_context *cso,
void cso_single_sampler_done( struct cso_context *cso );
void cso_set_sampler_textures( struct cso_context *cso,
uint count,
struct pipe_texture **textures );
void cso_save_sampler_textures( struct cso_context *cso );
void cso_restore_sampler_textures( struct cso_context *cso );
/* These aren't really sensible -- most of the time the api provides
* object semantics for shaders anyway, and the cases where it doesn't
* (eg mesa's internall-generated texenv programs), it will be up to
@@ -80,15 +98,32 @@ void cso_single_sampler_done( struct cso_context *cso );
*/
void cso_set_fragment_shader( struct cso_context *cso,
const struct pipe_shader_state *shader );
void cso_save_fragment_shader(struct cso_context *cso);
void cso_restore_fragment_shader(struct cso_context *cso);
void cso_unset_fragment_shader( struct cso_context *cso );
void cso_set_vertex_shader( struct cso_context *cso,
const struct pipe_shader_state *shader );
void cso_save_vertex_shader(struct cso_context *cso);
void cso_restore_vertex_shader(struct cso_context *cso);
void cso_unset_vertex_shader( struct cso_context *cso );
void cso_destroy_context( struct cso_context *cso );
void cso_set_framebuffer(struct cso_context *cso,
const struct pipe_framebuffer_state *fb);
void cso_save_framebuffer(struct cso_context *cso);
void cso_restore_framebuffer(struct cso_context *cso);
void cso_set_viewport(struct cso_context *cso,
const struct pipe_viewport_state *vp);
void cso_save_viewport(struct cso_context *cso);
void cso_restore_viewport(struct cso_context *cso);
void cso_set_blend_color(struct cso_context *cso,
const struct pipe_blend_color *bc);
#ifdef __cplusplus
src/gallium/auxiliary/draw/draw_aaline.c
+1
View File
@@ -410,6 +410,7 @@ aaline_create_texture(struct aaline_stage *aaline)
/* unmap */
pipe_surface_unmap(surface);
pipe_surface_reference(&surface, NULL);
pipe->texture_update(pipe, aaline->texture, 0, (1 << level));
}
}
src/gallium/auxiliary/draw/draw_pstipple.c
+1 -1
View File
@@ -374,7 +374,7 @@ pstip_update_texture(struct pstip_stage *pstip)
/* unmap */
pipe_surface_unmap(surface);
pipe_surface_reference(&surface, NULL);
pipe->texture_update(pipe, pstip->texture);
pipe->texture_update(pipe, pstip->texture, 0, 0x1);
}
src/gallium/auxiliary/util/p_debug.c
+59
View File
@@ -52,6 +52,9 @@ rpl_EngDebugPrint(const char *format, ...)
}
int rpl_vsnprintf(char *, size_t, const char *, va_list);
int rpl_snprintf(char *str, size_t size, const char *format, ...);
#define vsnprintf rpl_vsnprintf
#define snprintf rpl_snprintf
#endif
@@ -181,3 +184,59 @@ void debug_mask_vprintf(uint32_t uuid, uint32_t what, const char *format, va_lis
if(mask & what)
debug_vprintf(format, ap);
}
const char *
debug_dump_enum(const struct debug_named_value *names,
unsigned long value)
{
static char rest[256];
while(names->name) {
if(names->value == value)
return names->name;
++names;
}
snprintf(rest, sizeof(rest), "0x%08x", value);
return rest;
}
const char *
debug_dump_flags(const struct debug_named_value *names,
unsigned long value)
{
static char output[4096];
static char rest[256];
int first = 1;
output[0] = '\0';
while(names->name) {
if((names->value & value) == names->value) {
if (!first)
strncat(output, "|", sizeof(output));
else
first = 0;
strncat(output, names->name, sizeof(output));
value &= ~names->value;
}
++names;
}
if (value) {
if (!first)
strncat(output, "|", sizeof(output));
else
first = 0;
snprintf(rest, sizeof(rest), "0x%08x", value);
strncat(output, rest, sizeof(output));
}
if(first)
return "0";
return output;
}
src/gallium/auxiliary/util/u_blit.c
+65 -66
View File
@@ -45,15 +45,18 @@
#include "util/u_blit.h"
#include "util/u_simple_shaders.h"
#include "cso_cache/cso_context.h"
struct blit_state
{
struct pipe_context *pipe;
struct cso_context *cso;
void *blend;
void *depthstencil;
void *rasterizer;
void *samplers[2]; /* one for linear, one for nearest sampling */
struct pipe_blend_state blend;
struct pipe_depth_stencil_alpha_state depthstencil;
struct pipe_rasterizer_state rasterizer;
struct pipe_sampler_state sampler;
/*struct pipe_viewport_state viewport;*/
struct pipe_sampler_state *vs;
@@ -66,56 +69,44 @@ struct blit_state
* Intended to be created once and re-used for many blit() calls.
*/
struct blit_state *
util_create_blit(struct pipe_context *pipe)
util_create_blit(struct pipe_context *pipe, struct cso_context *cso)
{
struct pipe_blend_state blend;
struct pipe_depth_stencil_alpha_state depthstencil;
struct pipe_rasterizer_state rasterizer;
struct blit_state *ctx;
struct pipe_sampler_state sampler;
ctx = CALLOC_STRUCT(blit_state);
if (!ctx)
return NULL;
ctx->pipe = pipe;
ctx->cso = cso;
/* we don't use blending, but need to set valid values */
memset(&blend, 0, sizeof(blend));
blend.rgb_src_factor = PIPE_BLENDFACTOR_ONE;
blend.alpha_src_factor = PIPE_BLENDFACTOR_ONE;
blend.rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
blend.alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
blend.colormask = PIPE_MASK_RGBA;
ctx->blend = pipe->create_blend_state(pipe, &blend);
/* disabled blending/masking */
memset(&ctx->blend, 0, sizeof(ctx->blend));
ctx->blend.rgb_src_factor = PIPE_BLENDFACTOR_ONE;
ctx->blend.alpha_src_factor = PIPE_BLENDFACTOR_ONE;
ctx->blend.rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
ctx->blend.alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
ctx->blend.colormask = PIPE_MASK_RGBA;
/* depth/stencil/alpha */
memset(&depthstencil, 0, sizeof(depthstencil));
ctx->depthstencil = pipe->create_depth_stencil_alpha_state(pipe, &depthstencil);
/* no-op depth/stencil/alpha */
memset(&ctx->depthstencil, 0, sizeof(ctx->depthstencil));
/* rasterizer */
memset(&rasterizer, 0, sizeof(rasterizer));
rasterizer.front_winding = PIPE_WINDING_CW;
rasterizer.cull_mode = PIPE_WINDING_NONE;
rasterizer.bypass_clipping = 1; /* bypasses viewport too */
/*rasterizer.bypass_vs = 1;*/
ctx->rasterizer = pipe->create_rasterizer_state(pipe, &rasterizer);
memset(&ctx->rasterizer, 0, sizeof(ctx->rasterizer));
ctx->rasterizer.front_winding = PIPE_WINDING_CW;
ctx->rasterizer.cull_mode = PIPE_WINDING_NONE;
ctx->rasterizer.bypass_clipping = 1; /* bypasses viewport too */
/*ctx->rasterizer.bypass_vs = 1;*/
/* samplers */
memset(&sampler, 0, sizeof(sampler));
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
sampler.min_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_NEAREST;
sampler.normalized_coords = 1;
ctx->samplers[0] = pipe->create_sampler_state(pipe, &sampler);
sampler.min_img_filter = PIPE_TEX_MIPFILTER_LINEAR;
sampler.mag_img_filter = PIPE_TEX_MIPFILTER_LINEAR;
ctx->samplers[1] = pipe->create_sampler_state(pipe, &sampler);
memset(&ctx->sampler, 0, sizeof(ctx->sampler));
ctx->sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NONE;
ctx->sampler.min_img_filter = 0; /* set later */
ctx->sampler.mag_img_filter = 0; /* set later */
ctx->sampler.normalized_coords = 1;
#if 0
/* viewport */
@@ -153,12 +144,6 @@ util_destroy_blit(struct blit_state *ctx)
{
struct pipe_context *pipe = ctx->pipe;
pipe->delete_blend_state(pipe, ctx->blend);
pipe->delete_depth_stencil_alpha_state(pipe, ctx->depthstencil);
pipe->delete_rasterizer_state(pipe, ctx->rasterizer);
pipe->delete_sampler_state(pipe, ctx->samplers[0]);
pipe->delete_sampler_state(pipe, ctx->samplers[1]);
pipe->delete_vs_state(pipe, ctx->vs);
pipe->delete_fs_state(pipe, ctx->fs);
@@ -236,17 +221,24 @@ util_blit_pixels(struct blit_state *ctx,
src, srcLeft, srcTop, /* src */
srcW, srcH); /* size */
/* drawing dest */
memset(&fb, 0, sizeof(fb));
fb.num_cbufs = 1;
fb.cbufs[0] = dst;
pipe->set_framebuffer_state(pipe, &fb);
/* save state (restored below) */
cso_save_blend(ctx->cso);
cso_save_depth_stencil_alpha(ctx->cso);
cso_save_rasterizer(ctx->cso);
cso_save_samplers(ctx->cso);
cso_save_sampler_textures(ctx->cso);
cso_save_framebuffer(ctx->cso);
/* set misc state we care about */
cso_set_blend(ctx->cso, &ctx->blend);
cso_set_depth_stencil_alpha(ctx->cso, &ctx->depthstencil);
cso_set_rasterizer(ctx->cso, &ctx->rasterizer);
/* sampler */
if (filter == PIPE_TEX_MIPFILTER_NEAREST)
pipe->bind_sampler_states(pipe, 1, &ctx->samplers[0]);
else
pipe->bind_sampler_states(pipe, 1, &ctx->samplers[1]);
ctx->sampler.min_img_filter = filter;
ctx->sampler.mag_img_filter = filter;
cso_single_sampler(ctx->cso, 0, &ctx->sampler);
cso_single_sampler_done(ctx->cso);
/* texture */
pipe->set_sampler_textures(pipe, 1, &tex);
@@ -255,22 +247,29 @@ util_blit_pixels(struct blit_state *ctx,
pipe->bind_fs_state(pipe, ctx->fs);
pipe->bind_vs_state(pipe, ctx->vs);
/* misc state */
pipe->bind_blend_state(pipe, ctx->blend);
pipe->bind_depth_stencil_alpha_state(pipe, ctx->depthstencil);
pipe->bind_rasterizer_state(pipe, ctx->rasterizer);
/* drawing dest */
memset(&fb, 0, sizeof(fb));
fb.num_cbufs = 1;
fb.cbufs[0] = dst;
cso_set_framebuffer(ctx->cso, &fb);
/* draw quad */
util_draw_texquad(pipe, dstX0, dstY0, dstX1, dstY1, z);
util_draw_texquad(pipe,
(float)dstX0,
(float)dstY0,
(float)dstX1,
(float)dstY1, z);
/* unbind */
pipe->set_sampler_textures(pipe, 0, NULL);
pipe->bind_sampler_states(pipe, 0, NULL);
/* restore state we changed */
cso_restore_blend(ctx->cso);
cso_restore_depth_stencil_alpha(ctx->cso);
cso_restore_rasterizer(ctx->cso);
cso_restore_samplers(ctx->cso);
cso_restore_sampler_textures(ctx->cso);
cso_restore_framebuffer(ctx->cso);
/* free stuff */
/* free the texture */
pipe_surface_reference(&texSurf, NULL);
screen->texture_release(screen, &tex);
/* Note: caller must restore pipe/gallium state at this time */
}
src/gallium/auxiliary/util/u_blit.h
+3 -2
View File
@@ -30,15 +30,16 @@
#define U_BLIT_H
struct pipe_context;
struct pipe_surface;
struct cso_context;
struct blit_state;
extern struct blit_state *
util_create_blit(struct pipe_context *pipe);
util_create_blit(struct pipe_context *pipe, struct cso_context *cso);
extern void
src/gallium/auxiliary/util/u_gen_mipmap.c
+64 -55
View File
@@ -49,14 +49,18 @@
#include "tgsi/util/tgsi_dump.h"
#include "tgsi/util/tgsi_parse.h"
#include "cso_cache/cso_context.h"
struct gen_mipmap_state
{
struct pipe_context *pipe;
struct cso_context *cso;
void *blend;
void *depthstencil;
void *rasterizer;
struct pipe_blend_state blend;
struct pipe_depth_stencil_alpha_state depthstencil;
struct pipe_rasterizer_state rasterizer;
struct pipe_sampler_state sampler;
/*struct pipe_viewport_state viewport;*/
struct pipe_sampler_state *vs;
struct pipe_sampler_state *fs;
@@ -675,11 +679,9 @@ fallback_gen_mipmap(struct gen_mipmap_state *ctx,
* generate a mipmap.
*/
struct gen_mipmap_state *
util_create_gen_mipmap(struct pipe_context *pipe)
util_create_gen_mipmap(struct pipe_context *pipe,
struct cso_context *cso)
{
struct pipe_blend_state blend;
struct pipe_depth_stencil_alpha_state depthstencil;
struct pipe_rasterizer_state rasterizer;
struct gen_mipmap_state *ctx;
ctx = CALLOC_STRUCT(gen_mipmap_state);
@@ -687,27 +689,36 @@ util_create_gen_mipmap(struct pipe_context *pipe)
return NULL;
ctx->pipe = pipe;
ctx->cso = cso;
/* we don't use blending, but need to set valid values */
memset(&blend, 0, sizeof(blend));
blend.rgb_src_factor = PIPE_BLENDFACTOR_ONE;
blend.alpha_src_factor = PIPE_BLENDFACTOR_ONE;
blend.rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
blend.alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
blend.colormask = PIPE_MASK_RGBA;
ctx->blend = pipe->create_blend_state(pipe, &blend);
/* disabled blending/masking */
memset(&ctx->blend, 0, sizeof(ctx->blend));
ctx->blend.rgb_src_factor = PIPE_BLENDFACTOR_ONE;
ctx->blend.alpha_src_factor = PIPE_BLENDFACTOR_ONE;
ctx->blend.rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
ctx->blend.alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
ctx->blend.colormask = PIPE_MASK_RGBA;
/* depth/stencil/alpha */
memset(&depthstencil, 0, sizeof(depthstencil));
ctx->depthstencil = pipe->create_depth_stencil_alpha_state(pipe, &depthstencil);
/* no-op depth/stencil/alpha */
memset(&ctx->depthstencil, 0, sizeof(ctx->depthstencil));
/* rasterizer */
memset(&rasterizer, 0, sizeof(rasterizer));
rasterizer.front_winding = PIPE_WINDING_CW;
rasterizer.cull_mode = PIPE_WINDING_NONE;
rasterizer.bypass_clipping = 1; /* bypasses viewport too */
//rasterizer.bypass_vs = 1;
ctx->rasterizer = pipe->create_rasterizer_state(pipe, &rasterizer);
memset(&ctx->rasterizer, 0, sizeof(ctx->rasterizer));
ctx->rasterizer.front_winding = PIPE_WINDING_CW;
ctx->rasterizer.cull_mode = PIPE_WINDING_NONE;
ctx->rasterizer.bypass_clipping = 1; /* bypasses viewport too */
/*ctx->rasterizer.bypass_vs = 1;*/
/* sampler state */
memset(&ctx->sampler, 0, sizeof(ctx->sampler));
ctx->sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
ctx->sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST;
ctx->sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR;
ctx->sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR;
ctx->sampler.normalized_coords = 1;
#if 0
/* viewport */
@@ -745,9 +756,6 @@ util_destroy_gen_mipmap(struct gen_mipmap_state *ctx)
{
struct pipe_context *pipe = ctx->pipe;
pipe->delete_blend_state(pipe, ctx->blend);
pipe->delete_depth_stencil_alpha_state(pipe, ctx->depthstencil);
pipe->delete_rasterizer_state(pipe, ctx->rasterizer);
pipe->delete_vs_state(pipe, ctx->vs);
pipe->delete_fs_state(pipe, ctx->fs);
@@ -792,8 +800,6 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
struct pipe_context *pipe = ctx->pipe;
struct pipe_screen *screen = pipe->screen;
struct pipe_framebuffer_state fb;
struct pipe_sampler_state sampler;
void *sampler_cso;
uint dstLevel;
uint zslice = 0;
@@ -803,30 +809,29 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
return;
}
/* init framebuffer state */
memset(&fb, 0, sizeof(fb));
fb.num_cbufs = 1;
/* sampler state */
memset(&sampler, 0, sizeof(sampler));
sampler.wrap_s = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
sampler.wrap_t = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
sampler.wrap_r = PIPE_TEX_WRAP_CLAMP_TO_EDGE;
sampler.min_mip_filter = PIPE_TEX_MIPFILTER_NEAREST;
sampler.min_img_filter = PIPE_TEX_FILTER_LINEAR;
sampler.mag_img_filter = PIPE_TEX_FILTER_LINEAR;
sampler.normalized_coords = 1;
/* save state (restored below) */
cso_save_blend(ctx->cso);
cso_save_depth_stencil_alpha(ctx->cso);
cso_save_rasterizer(ctx->cso);
cso_save_samplers(ctx->cso);
cso_save_sampler_textures(ctx->cso);
cso_save_framebuffer(ctx->cso);
/* bind our state */
pipe->bind_blend_state(pipe, ctx->blend);
pipe->bind_depth_stencil_alpha_state(pipe, ctx->depthstencil);
pipe->bind_rasterizer_state(pipe, ctx->rasterizer);
cso_set_blend(ctx->cso, &ctx->blend);
cso_set_depth_stencil_alpha(ctx->cso, &ctx->depthstencil);
cso_set_rasterizer(ctx->cso, &ctx->rasterizer);
pipe->bind_vs_state(pipe, ctx->vs);
pipe->bind_fs_state(pipe, ctx->fs);
#if 0
pipe->set_viewport_state(pipe, &ctx->viewport);
#endif
/* init framebuffer state */
memset(&fb, 0, sizeof(fb));
fb.num_cbufs = 1;
/*
* XXX for small mipmap levels, it may be faster to use the software
* fallback path...
@@ -838,7 +843,7 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
* Setup framebuffer / dest surface
*/
fb.cbufs[0] = screen->get_tex_surface(screen, pt, face, dstLevel, zslice);
pipe->set_framebuffer_state(pipe, &fb);
cso_set_framebuffer(ctx->cso, &fb);
/*
* Setup sampler state
@@ -847,11 +852,10 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
* has trouble with min clamping so we also set the lod_bias to
* try to work around that.
*/
sampler.min_lod = sampler.max_lod = (float) srcLevel;
sampler.lod_bias = (float) srcLevel;
sampler_cso = pipe->create_sampler_state(pipe, &sampler);
pipe->bind_sampler_states(pipe, 1, &sampler_cso);
ctx->sampler.min_lod = ctx->sampler.max_lod = (float) srcLevel;
ctx->sampler.lod_bias = (float) srcLevel;
cso_single_sampler(ctx->cso, 0, &ctx->sampler);
cso_single_sampler_done(ctx->cso);
#if 0
simple_viewport(pipe, pt->width[dstLevel], pt->height[dstLevel]);
#endif
@@ -868,10 +872,15 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
pipe->flush(pipe, PIPE_FLUSH_WAIT);
/*pipe->texture_update(pipe, pt); not really needed */
pipe->delete_sampler_state(pipe, sampler_cso);
/* need to signal that the texture has changed _after_ rendering to it */
pipe->texture_update(pipe, pt, face, (1 << dstLevel));
}
/* Note: caller must restore pipe/gallium state at this time */
/* restore state we changed */
cso_restore_blend(ctx->cso);
cso_restore_depth_stencil_alpha(ctx->cso);
cso_restore_rasterizer(ctx->cso);
cso_restore_samplers(ctx->cso);
cso_restore_sampler_textures(ctx->cso);
cso_restore_framebuffer(ctx->cso);
}
src/gallium/auxiliary/util/u_gen_mipmap.h
+5 -1
View File
@@ -31,11 +31,15 @@
#include "pipe/p_state.h"
struct pipe_context;
struct pipe_texture;
struct cso_context;
struct gen_mipmap_state;
extern struct gen_mipmap_state *
util_create_gen_mipmap(struct pipe_context *pipe);
util_create_gen_mipmap(struct pipe_context *pipe, struct cso_context *cso);
extern void
src/gallium/auxiliary/util/u_handle_table.c
+1 -1
View File
@@ -248,7 +248,7 @@ handle_table_get_next_handle(struct handle_table *ht,
unsigned index;
for(index = handle; index < ht->size; ++index) {
if(!ht->objects[index])
if(ht->objects[index])
return index + 1;
}
src/gallium/drivers/cell/ppu/cell_texture.c
+2 -1
View File
@@ -134,7 +134,8 @@ cell_texture_release_screen(struct pipe_screen *screen,
static void
cell_texture_update(struct pipe_context *pipe, struct pipe_texture *texture)
cell_texture_update(struct pipe_context *pipe, struct pipe_texture *texture,
uint face, uint levelsMask)
{
/* XXX TO DO: re-tile the texture data ... */
src/gallium/drivers/i915simple/i915_texture.c
+2 -1
View File
@@ -542,7 +542,8 @@ i915_texture_release_screen(struct pipe_screen *screen,
static void
i915_texture_update(struct pipe_context *pipe, struct pipe_texture *texture)
i915_texture_update(struct pipe_context *pipe, struct pipe_texture *texture,
uint face, uint levelsMask)
{
/* no-op? */
}
src/gallium/drivers/i965simple/brw_tex_layout.c
+2 -1
View File
@@ -358,7 +358,8 @@ brw_texture_release_screen(struct pipe_screen *screen,
static void
brw_texture_update(struct pipe_context *pipe, struct pipe_texture *texture)
brw_texture_update(struct pipe_context *pipe, struct pipe_texture *texture,
uint face, uint levelsMask)
{
/* no-op? */
}
src/gallium/drivers/softpipe/sp_context.h
+2
View File
@@ -84,6 +84,8 @@ struct softpipe_context {
unsigned num_samplers;
unsigned num_textures;
uint fb_width, fb_height;
/* Counter for occlusion queries. Note this supports overlapping
* queries.
*/
src/gallium/drivers/softpipe/sp_prim_setup.c
+1 -1
View File
@@ -485,7 +485,7 @@ setup_fragcoord_coeff(struct setup_stage *setup, uint slot)
/*Y*/
if (setup->softpipe->rasterizer->origin_lower_left) {
/* y=0=bottom */
const int winHeight = setup->softpipe->framebuffer.cbufs[0]->height;
const int winHeight = setup->softpipe->fb_height;
setup->coef[slot].a0[1] = (float) (winHeight - 1);
setup->coef[slot].dady[1] = -1.0;
}
src/gallium/drivers/softpipe/sp_quad_stipple.c
+1 -1
View File
@@ -25,7 +25,7 @@ stipple_quad(struct quad_stage *qs, struct quad_header *quad)
int y0, y1;
uint stipple0, stipple1;
if (softpipe->rasterizer->origin_lower_left) {
y0 = softpipe->framebuffer.cbufs[0]->height - 1 - quad->y0;
y0 = softpipe->fb_height - 1 - quad->y0;
y1 = y0 - 1;
}
else {
src/gallium/drivers/softpipe/sp_state_derived.c
+2 -11
View File
@@ -171,17 +171,8 @@ softpipe_get_vbuf_vertex_info(struct softpipe_context *softpipe)
static void
compute_cliprect(struct softpipe_context *sp)
{
unsigned surfWidth, surfHeight;
if (sp->framebuffer.num_cbufs > 0) {
surfWidth = sp->framebuffer.cbufs[0]->width;
surfHeight = sp->framebuffer.cbufs[0]->height;
}
else {
/* no surface? */
surfWidth = sp->scissor.maxx;
surfHeight = sp->scissor.maxy;
}
uint surfWidth = sp->fb_width;
uint surfHeight = sp->fb_height;
if (sp->rasterizer->scissor) {
/* clip to scissor rect */
src/gallium/drivers/softpipe/sp_state_surface.c
+12
View File
@@ -48,6 +48,9 @@ softpipe_set_framebuffer_state(struct pipe_context *pipe,
struct softpipe_context *sp = softpipe_context(pipe);
uint i;
/* updated below */
sp->fb_width = sp->fb_height = 0;
for (i = 0; i < PIPE_MAX_COLOR_BUFS; i++) {
/* check if changing cbuf */
if (sp->framebuffer.cbufs[i] != fb->cbufs[i]) {
@@ -60,6 +63,10 @@ softpipe_set_framebuffer_state(struct pipe_context *pipe,
/* update cache */
sp_tile_cache_set_surface(sp->cbuf_cache[i], fb->cbufs[i]);
}
if (fb->cbufs[i]) {
sp->fb_width = fb->cbufs[i]->width;
sp->fb_height = fb->cbufs[i]->height;
}
}
sp->framebuffer.num_cbufs = fb->num_cbufs;
@@ -74,6 +81,11 @@ softpipe_set_framebuffer_state(struct pipe_context *pipe,
/* update cache */
sp_tile_cache_set_surface(sp->zsbuf_cache, fb->zsbuf);
if (!sp->fb_width && fb->zsbuf) {
sp->fb_width = fb->zsbuf->width;
sp->fb_height = fb->zsbuf->height;
}
}
#if 0
src/gallium/drivers/softpipe/sp_texture.c
+2 -1
View File
@@ -174,7 +174,8 @@ softpipe_get_tex_surface_screen(struct pipe_screen *screen,
static void
softpipe_texture_update(struct pipe_context *pipe,
struct pipe_texture *texture)
struct pipe_texture *texture,
uint face, uint levelsMask)
{
struct softpipe_context *softpipe = softpipe_context(pipe);
uint unit;
src/gallium/drivers/softpipe/sp_tile_cache.c
+1
View File
@@ -156,6 +156,7 @@ sp_tile_cache_set_surface(struct softpipe_tile_cache *tc,
if (tc->surface_map) {
/*assert(tc->surface != ps);*/
pipe_surface_unmap(tc->surface);
tc->surface_map = NULL;
}
pipe_surface_reference(&tc->surface, ps);
src/gallium/include/pipe/p_context.h
+2 -4
View File
@@ -192,12 +192,10 @@ struct pipe_context {
/**
* Called when texture data is changed.
* Note: we could pass some hints about which mip levels or cube faces
* have changed...
* XXX this may go away - could pass a 'write' flag to get_tex_surface()
*/
void (*texture_update)(struct pipe_context *pipe,
struct pipe_texture *texture);
struct pipe_texture *texture,
uint face, uint dirtyLevelsMask);
src/gallium/include/pipe/p_debug.h
+49
View File
@@ -168,6 +168,55 @@ void debug_mask_vprintf(uint32_t uuid,
#endif
/**
* Used by debug_dump_enum and debug_dump_flags to describe symbols.
*/
struct debug_named_value
{
const char *name;
unsigned long value;
};
/**
* Some C pre-processor magic to simplify creating named values.
*
* Example:
* @code
* static const debug_named_value my_names[] = {
* DEBUG_NAMED_VALUE(MY_ENUM_VALUE_X),
* DEBUG_NAMED_VALUE(MY_ENUM_VALUE_Y),
* DEBUG_NAMED_VALUE(MY_ENUM_VALUE_Z),
* DEBUG_NAMED_VALUE_END
* };
*
* ...
* debug_printf("%s = %s\n",
* name,
* debug_dump_enum(my_names, my_value));
* ...
* @endcode
*/
#define DEBUG_NAMED_VALUE(__symbol) {#__symbol, (unsigned long)__symbol}
#define DEBUG_NAMED_VALUE_END {NULL, 0}
/**
* Convert a enum value to a string.
*/
const char *
debug_dump_enum(const struct debug_named_value *names,
unsigned long value);
/**
* Convert binary flags value to a string.
*/
const char *
debug_dump_flags(const struct debug_named_value *names,
unsigned long value);
#ifdef __cplusplus
}
#endif
src/mesa/state_tracker/st_atom_blend.c
+5 -7
View File
@@ -39,6 +39,7 @@
#include "pipe/p_defines.h"
#include "cso_cache/cso_context.h"
#include "main/macros.h"
/**
* Convert GLenum blend tokens to pipe tokens.
@@ -213,13 +214,10 @@ update_blend( struct st_context *st )
cso_set_blend(st->cso_context, blend);
if (memcmp(st->ctx->Color.BlendColor, &st->state.blend_color, 4 * sizeof(GLfloat)) != 0) {
/* state has changed */
st->state.blend_color.color[0] = st->ctx->Color.BlendColor[0];
st->state.blend_color.color[1] = st->ctx->Color.BlendColor[1];
st->state.blend_color.color[2] = st->ctx->Color.BlendColor[2];
st->state.blend_color.color[3] = st->ctx->Color.BlendColor[3];
st->pipe->set_blend_color(st->pipe, (struct pipe_blend_color *) st->ctx->Color.BlendColor);
{
struct pipe_blend_color bc;
COPY_4FV(bc.color, st->ctx->Color.BlendColor);
cso_set_blend_color(st->cso_context, &bc);
}
}
src/mesa/state_tracker/st_atom_framebuffer.c
+9 -14
View File
@@ -35,6 +35,7 @@
#include "st_atom.h"
#include "st_cb_fbo.h"
#include "pipe/p_context.h"
#include "cso_cache/cso_context.h"
/**
@@ -44,45 +45,39 @@
static void
update_framebuffer_state( struct st_context *st )
{
struct pipe_framebuffer_state framebuffer;
struct pipe_framebuffer_state *framebuffer = &st->state.framebuffer;
struct gl_framebuffer *fb = st->ctx->DrawBuffer;
struct st_renderbuffer *strb;
GLuint i;
memset(&framebuffer, 0, sizeof(framebuffer));
memset(framebuffer, 0, sizeof(*framebuffer));
/* Examine Mesa's ctx->DrawBuffer->_ColorDrawBuffers state
* to determine which surfaces to draw to
*/
framebuffer.num_cbufs = fb->_NumColorDrawBuffers[0];
for (i = 0; i < framebuffer.num_cbufs; i++) {
framebuffer->num_cbufs = fb->_NumColorDrawBuffers[0];
for (i = 0; i < framebuffer->num_cbufs; i++) {
strb = st_renderbuffer(fb->_ColorDrawBuffers[0][i]);
assert(strb->surface);
framebuffer.cbufs[i] = strb->surface;
framebuffer->cbufs[i] = strb->surface;
}
strb = st_renderbuffer(fb->Attachment[BUFFER_DEPTH].Renderbuffer);
if (strb) {
strb = st_renderbuffer(strb->Base.Wrapped);
assert(strb->surface);
framebuffer.zsbuf = strb->surface;
framebuffer->zsbuf = strb->surface;
}
else {
strb = st_renderbuffer(fb->Attachment[BUFFER_STENCIL].Renderbuffer);
if (strb) {
strb = st_renderbuffer(strb->Base.Wrapped);
assert(strb->surface);
framebuffer.zsbuf = strb->surface;
framebuffer->zsbuf = strb->surface;
}
}
/* XXX: The memcmp is insufficient for eliminating redundant state changes,
* but we should probably do more work here to that end.
*/
if (1 /*memcmp(&framebuffer, &st->state.framebuffer, sizeof(framebuffer)) != 0*/) {
st->state.framebuffer = framebuffer;
st->pipe->set_framebuffer_state( st->pipe, &framebuffer );
}
cso_set_framebuffer(st->cso_context, framebuffer);
}
src/mesa/state_tracker/st_atom_texture.c
-5
View File
@@ -76,11 +76,6 @@ update_textures(struct st_context *st)
pt = st_get_stobj_texture(stObj);
pipe_texture_reference(&st->state.sampler_texture[unit], pt);
if (stObj && stObj->dirtyData) {
st->pipe->texture_update(st->pipe, pt);
stObj->dirtyData = GL_FALSE;
}
}
st->pipe->set_sampler_textures(st->pipe, st->state.num_textures,
src/mesa/state_tracker/st_atom_viewport.c
+11 -15
View File
@@ -29,9 +29,9 @@
#include "context.h"
#include "colormac.h"
#include "st_context.h"
#include "pipe/p_context.h"
#include "st_atom.h"
#include "pipe/p_context.h"
#include "cso_cache/cso_context.h"
/**
* Update the viewport transformation matrix. Depends on:
@@ -65,22 +65,18 @@ update_viewport( struct st_context *st )
GLfloat half_width = ctx->Viewport.Width / 2.0;
GLfloat half_height = ctx->Viewport.Height / 2.0;
GLfloat half_depth = (ctx->Viewport.Far - ctx->Viewport.Near) / 2.0;
struct pipe_viewport_state vp;
vp.scale[0] = half_width;
vp.scale[1] = half_height * yScale;
vp.scale[2] = half_depth;
vp.scale[3] = 1.0;
st->state.viewport.scale[0] = half_width;
st->state.viewport.scale[1] = half_height * yScale;
st->state.viewport.scale[2] = half_depth;
st->state.viewport.scale[3] = 1.0;
vp.translate[0] = half_width + x;
vp.translate[1] = (half_height + y) * yScale + yBias;
vp.translate[2] = half_depth + z;
vp.translate[3] = 0.0;
st->state.viewport.translate[0] = half_width + x;
st->state.viewport.translate[1] = (half_height + y) * yScale + yBias;
st->state.viewport.translate[2] = half_depth + z;
st->state.viewport.translate[3] = 0.0;
if (memcmp(&vp, &st->state.viewport, sizeof(vp)) != 0) {
st->state.viewport = vp;
st->pipe->set_viewport_state(st->pipe, &vp);
}
cso_set_viewport(st->cso_context, &st->state.viewport);
}
}
src/mesa/state_tracker/st_cb_blit.c
+2 -15
View File
@@ -52,7 +52,7 @@
void
st_init_blit(struct st_context *st)
{
st->blit = util_create_blit(st->pipe);
st->blit = util_create_blit(st->pipe, st->cso_context);
}
@@ -98,22 +98,9 @@ st_BlitFramebuffer(GLcontext *ctx,
}
#if 0
/* XXX is this sufficient? */
st_invalidate_state(ctx, _NEW_COLOR | _NEW_TEXTURE);
#else
/* need to "unset" cso state because we went behind the back of the cso
* tracker. Without unset, the _set_ calls would be no-ops.
*/
cso_unset_blend(st->cso_context);
cso_unset_depth_stencil_alpha(st->cso_context);
cso_unset_rasterizer(st->cso_context);
cso_set_blend(st->cso_context, &st->state.blend);
cso_set_depth_stencil_alpha(st->cso_context, &st->state.depth_stencil);
cso_set_rasterizer(st->cso_context, &st->state.rasterizer);
/* shaders don't go through CSO yet */
pipe->bind_fs_state(pipe, st->fp->driver_shader);
pipe->bind_vs_state(pipe, st->vp->driver_shader);
#endif
}
src/mesa/state_tracker/st_cb_clear.c
+15 -20
View File
@@ -247,10 +247,19 @@ clear_with_quad(GLcontext *ctx,
x1, y1);
*/
cso_save_blend(st->cso_context);
cso_save_depth_stencil_alpha(st->cso_context);
cso_save_rasterizer(st->cso_context);
cso_save_viewport(st->cso_context);
/* blend state: RGBA masking */
{
struct pipe_blend_state blend;
memset(&blend, 0, sizeof(blend));
blend.rgb_src_factor = PIPE_BLENDFACTOR_ONE;
blend.alpha_src_factor = PIPE_BLENDFACTOR_ONE;
blend.rgb_dst_factor = PIPE_BLENDFACTOR_ZERO;
blend.alpha_dst_factor = PIPE_BLENDFACTOR_ZERO;
if (color) {
if (ctx->Color.ColorMask[0])
blend.colormask |= PIPE_MASK_R;
@@ -294,13 +303,6 @@ clear_with_quad(GLcontext *ctx,
{
struct pipe_rasterizer_state raster;
memset(&raster, 0, sizeof(raster));
#if 0
/* don't do per-pixel scissor; we'll just draw a PIPE_PRIM_QUAD
* that matches the scissor bounds.
*/
if (ctx->Scissor.Enabled)
raster.scissor = 1;
#endif
#if TEST_DRAW_PASSTHROUGH
raster.bypass_clipping = 1;
raster.bypass_vs = 1;
@@ -342,28 +344,21 @@ clear_with_quad(GLcontext *ctx,
vp.translate[1] = 0.5 * height;
vp.translate[2] = 0.0;
vp.translate[3] = 0.0;
pipe->set_viewport_state(pipe, &vp);
cso_set_viewport(st->cso_context, &vp);
}
#endif
/* draw quad matching scissor rect (XXX verify coord round-off) */
draw_quad(ctx, x0, y0, x1, y1, ctx->Depth.Clear, ctx->Color.ClearColor);
#if 0
/* Can't depend on old state objects still existing -- may have
* been deleted to make room in the hash, etc. (Should get
* fixed...)
*/
st_invalidate_state(ctx, _NEW_COLOR | _NEW_DEPTH | _NEW_STENCIL);
#else
/* Restore pipe state */
cso_set_blend(st->cso_context, &st->state.blend);
cso_set_depth_stencil_alpha(st->cso_context, &st->state.depth_stencil);
cso_set_rasterizer(st->cso_context, &st->state.rasterizer);
cso_restore_blend(st->cso_context);
cso_restore_depth_stencil_alpha(st->cso_context);
cso_restore_rasterizer(st->cso_context);
cso_restore_viewport(st->cso_context);
/* these don't go through cso yet */
pipe->bind_fs_state(pipe, st->fp->driver_shader);
pipe->bind_vs_state(pipe, st->vp->driver_shader);
#endif
pipe->set_viewport_state(pipe, &st->state.viewport);
}
src/mesa/state_tracker/st_cb_drawpixels.c
+13 -15
View File
@@ -513,6 +513,8 @@ make_texture(struct st_context *st,
/* unmap */
pipe_surface_unmap(surface);
pipe_surface_reference(&surface, NULL);
pipe->texture_update(pipe, pt, 0, 0x1);
assert(success);
/* restore */
@@ -650,6 +652,9 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
assert(width <= maxSize);
assert(height <= maxSize);
cso_save_rasterizer(cso);
cso_save_viewport(cso);
/* setup state: just scissor */
{
struct pipe_rasterizer_state setup;
@@ -696,7 +701,7 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
vp.translate[1] = 0.5 * height;
vp.translate[2] = 0.0;
vp.translate[3] = 0.0;
pipe->set_viewport_state(pipe, &vp);
cso_set_viewport(cso, &vp);
}
/* texture state: */
@@ -719,26 +724,18 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
else
draw_quad(ctx, x0, y0, z, x1, y1, invertTex);
/* restore GL state */
pipe->set_sampler_textures(pipe, ctx->st->state.num_textures,
ctx->st->state.sampler_texture);
pipe->set_viewport_state(pipe, &ctx->st->state.viewport);
#if 0
/* Can't depend on old state objects still existing -- may have
* been deleted to make room in the hash, etc. (Should get
* fixed...)
*/
st_invalidate_state(ctx, _NEW_COLOR | _NEW_TEXTURE);
#else
/* restore state */
cso_restore_rasterizer(cso);
cso_restore_viewport(cso);
/* shaders don't go through cso yet */
pipe->bind_fs_state(pipe, st->fp->driver_shader);
pipe->bind_vs_state(pipe, st->vp->driver_shader);
cso_set_rasterizer(cso, &st->state.rasterizer);
cso_set_samplers(cso, PIPE_MAX_SAMPLERS,
(const struct pipe_sampler_state **) st->state.sampler_list);
#endif
pipe->set_sampler_textures(pipe, ctx->st->state.num_textures,
ctx->st->state.sampler_texture);
}
@@ -1105,6 +1102,7 @@ make_bitmap_texture(GLcontext *ctx, GLsizei width, GLsizei height,
/* Release surface */
pipe_surface_unmap(surface);
pipe_surface_reference(&surface, NULL);
pipe->texture_update(pipe, pt, 0, 0x1);
pt->format = format;
src/mesa/state_tracker/st_cb_texture.c
+7 -6
View File
@@ -476,6 +476,7 @@ st_TexImage(GLcontext * ctx,
struct gl_texture_image *texImage,
GLsizei imageSize, int compressed)
{
struct pipe_context *pipe = ctx->st->pipe;
struct st_texture_object *stObj = st_texture_object(texObj);
struct st_texture_image *stImage = st_texture_image(texImage);
GLint postConvWidth, postConvHeight;
@@ -690,8 +691,8 @@ st_TexImage(GLcontext * ctx,
texImage->Data = NULL;
}
/* flag data as dirty */
stObj->dirtyData = GL_TRUE;
if (stObj->pt)
pipe->texture_update(pipe, stObj->pt, stImage->face, (1 << level));
if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
ctx->Driver.GenerateMipmap(ctx, target, texObj);
@@ -866,6 +867,7 @@ st_TexSubimage(GLcontext * ctx,
struct gl_texture_object *texObj,
struct gl_texture_image *texImage)
{
struct pipe_context *pipe = ctx->st->pipe;
struct st_texture_object *stObj = st_texture_object(texObj);
struct st_texture_image *stImage = st_texture_image(texImage);
GLuint dstRowStride;
@@ -924,8 +926,7 @@ st_TexSubimage(GLcontext * ctx,
texImage->Data = NULL;
}
/* flag data as dirty */
stObj->dirtyData = GL_TRUE;
pipe->texture_update(pipe, stObj->pt, stImage->face, (1 << level));
}
@@ -1179,8 +1180,7 @@ do_copy_texsubimage(GLcontext *ctx,
pipe_surface_reference(&dest_surface, NULL);
/* flag data as dirty */
stObj->dirtyData = GL_TRUE;
pipe->texture_update(pipe, stObj->pt, stImage->face, (1 << level));
if (level == texObj->BaseLevel && texObj->GenerateMipmap) {
ctx->Driver.GenerateMipmap(ctx, target, texObj);
@@ -1481,6 +1481,7 @@ st_finalize_texture(GLcontext *ctx,
if (stImage && stObj->pt != stImage->pt) {
copy_image_data_to_texture(ctx->st, stObj, level, stImage);
*needFlush = GL_TRUE;
pipe->texture_update(pipe, stObj->pt, face, (1 << level));
}
}
}
src/mesa/state_tracker/st_context.h
-1
View File
@@ -82,7 +82,6 @@ struct st_context
struct pipe_rasterizer_state rasterizer;
struct pipe_sampler_state samplers[PIPE_MAX_SAMPLERS];
struct pipe_sampler_state *sampler_list[PIPE_MAX_SAMPLERS];
struct pipe_blend_color blend_color;
struct pipe_clip_state clip;
struct pipe_constant_buffer constants[2];
struct pipe_framebuffer_state framebuffer;
src/mesa/state_tracker/st_draw.c
+3 -3
View File
@@ -223,7 +223,7 @@ st_draw_vbo(GLcontext *ctx,
/* loop over TGSI shader inputs to determine vertex buffer
* and attribute info
*/
for (attr = 0; attr < /*vs*/vp->num_inputs; attr++) {
for (attr = 0; attr < vp->num_inputs; attr++) {
const GLuint mesaAttr = vp->index_to_input[attr];
struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;
struct pipe_vertex_element velement;
@@ -333,7 +333,7 @@ st_draw_vbo(GLcontext *ctx,
}
/* unreference buffers (frees wrapped user-space buffer objects) */
for (attr = 0; attr < /*vs*/vp->num_inputs; attr++) {
for (attr = 0; attr < vp->num_inputs; attr++) {
pipe_buffer_reference(winsys, &vbuffer[attr].buffer, NULL);
assert(!vbuffer[attr].buffer);
pipe->set_vertex_buffer(pipe, attr, &vbuffer[attr]);
@@ -502,7 +502,7 @@ st_feedback_draw_vbo(GLcontext *ctx,
/* loop over TGSI shader inputs to determine vertex buffer
* and attribute info
*/
for (attr = 0; attr < /*vs*/vp->num_inputs; attr++) {
for (attr = 0; attr < vp->num_inputs; attr++) {
const GLuint mesaAttr = vp->index_to_input[attr];
struct gl_buffer_object *bufobj = arrays[mesaAttr]->BufferObj;
struct pipe_vertex_element velement;
src/mesa/state_tracker/st_gen_mipmap.c
+6 -14
View File
@@ -59,7 +59,7 @@
void
st_init_generate_mipmap(struct st_context *st)
{
st->gen_mipmap = util_create_gen_mipmap(st->pipe);
st->gen_mipmap = util_create_gen_mipmap(st->pipe, st->cso_context);
}
@@ -94,19 +94,11 @@ st_render_mipmap(struct st_context *st,
util_gen_mipmap(st->gen_mipmap, pt, face, baseLevel, lastLevel);
/* restore pipe state */
#if 0
cso_set_rasterizer(st->cso_context, &st->state.rasterizer);
cso_set_samplers(st->cso_context, st->state.samplers_list);
pipe->bind_fs_state(pipe, st->fp->shader_program);
pipe->bind_vs_state(pipe, st->vp->shader_program);
pipe->set_sampler_textures(pipe, st->state.num_textures,
st->state.sampler_texture);
pipe->set_viewport_state(pipe, &st->state.viewport);
#else
/* XXX is this sufficient? */
st_invalidate_state(st->ctx, _NEW_COLOR | _NEW_TEXTURE);
#endif
/* shaders don't go through CSO yet */
if (st->fp)
pipe->bind_fs_state(pipe, st->fp->driver_shader);
if (st->vp)
pipe->bind_vs_state(pipe, st->vp->driver_shader);
return TRUE;
}
src/mesa/state_tracker/st_texture.h
-2
View File
@@ -71,8 +71,6 @@ struct st_texture_object
GLboolean imageOverride;
GLint depthOverride;
GLuint pitchOverride;
GLboolean dirtyData;
};