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

gallium: WIP: Introduce sampler views.

Browse source
This commit is contained in:
Michal Krol 2010-02-19 19:00:26 +01:00
parent 3d0bfc6a4b
commit f610656608
33 changed files with 660 additions and 277 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
src/gallium/auxiliary/Makefile
View file

@ -125,12 +125,13 @@ C_SOURCES = \
util/u_tile.c \
util/u_timed_winsys.c \
util/u_upload_mgr.c \
util/u_simple_screen.c \
vl/vl_bitstream_parser.c \
vl/vl_mpeg12_mc_renderer.c \
vl/vl_compositor.c \
vl/vl_csc.c \
vl/vl_shader_build.c
util/u_simple_screen.c
# Disabling until pipe-video branch gets merged in
#vl/vl_bitstream_parser.c \
#vl/vl_mpeg12_mc_renderer.c \
#vl/vl_compositor.c \
#vl/vl_csc.c \
#vl/vl_shader_build.c
GALLIVM_SOURCES = \
gallivm/lp_bld_alpha.c \

12
src/gallium/auxiliary/SConscript
View file

@ -153,6 +153,7 @@ source = [
'util/u_mm.c',
'util/u_rect.c',
'util/u_ringbuffer.c',
'util/u_sampler.c',
'util/u_simple_shaders.c',
'util/u_snprintf.c',
'util/u_surface.c',
@ -161,11 +162,12 @@ source = [
'util/u_timed_winsys.c',
'util/u_upload_mgr.c',
'util/u_simple_screen.c',
'vl/vl_bitstream_parser.c',
'vl/vl_mpeg12_mc_renderer.c',
'vl/vl_compositor.c',
'vl/vl_csc.c',
'vl/vl_shader_build.c',
# Disabling until pipe-video branch gets merged in
#'vl/vl_bitstream_parser.c',
#'vl/vl_mpeg12_mc_renderer.c',
#'vl/vl_compositor.c',
#'vl/vl_csc.c',
#'vl/vl_shader_build.c',
]
if drawllvm:

86
src/gallium/auxiliary/cso_cache/cso_context.c
View file

@ -38,6 +38,7 @@
#include "pipe/p_state.h"
#include "util/u_inlines.h"
#include "util/u_memory.h"
#include "util/u_sampler.h"
#include "tgsi/tgsi_parse.h"
#include "cso_cache/cso_context.h"
@ -70,16 +71,20 @@ struct cso_context {
void *vertex_samplers_saved[PIPE_MAX_VERTEX_SAMPLERS];
struct pipe_texture *textures[PIPE_MAX_SAMPLERS];
struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
uint nr_textures;
struct pipe_texture *vertex_textures[PIPE_MAX_VERTEX_SAMPLERS];
struct pipe_sampler_view *vertex_sampler_views[PIPE_MAX_VERTEX_SAMPLERS];
uint nr_vertex_textures;
uint nr_textures_saved;
struct pipe_texture *textures_saved[PIPE_MAX_SAMPLERS];
struct pipe_sampler_view *sampler_views_saved[PIPE_MAX_SAMPLERS];
uint nr_vertex_textures_saved;
struct pipe_texture *vertex_textures_saved[PIPE_MAX_SAMPLERS];
struct pipe_texture *vertex_textures_saved[PIPE_MAX_VERTEX_SAMPLERS];
struct pipe_sampler_view *vertex_sampler_views_saved[PIPE_MAX_VERTEX_SAMPLERS];
/** Current and saved state.
* The saved state is used as a 1-deep stack.
@ -273,11 +278,15 @@ void cso_release_all( struct cso_context *ctx )
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
pipe_texture_reference(&ctx->textures[i], NULL);
pipe_texture_reference(&ctx->textures_saved[i], NULL);
pipe_sampler_view_reference(&ctx->sampler_views[i], NULL);
pipe_sampler_view_reference(&ctx->sampler_views_saved[i], NULL);
}
for (i = 0; i < PIPE_MAX_VERTEX_SAMPLERS; i++) {
pipe_texture_reference(&ctx->vertex_textures[i], NULL);
pipe_texture_reference(&ctx->vertex_textures_saved[i], NULL);
pipe_sampler_view_reference(&ctx->vertex_sampler_views[i], NULL);
pipe_sampler_view_reference(&ctx->vertex_sampler_views_saved[i], NULL);
}
free_framebuffer_state(&ctx->fb);
@ -602,12 +611,27 @@ enum pipe_error cso_set_sampler_textures( struct cso_context *ctx,
ctx->nr_textures = count;
for (i = 0; i < count; i++)
pipe_texture_reference(&ctx->textures[i], textures[i]);
for ( ; i < PIPE_MAX_SAMPLERS; i++)
pipe_texture_reference(&ctx->textures[i], NULL);
for (i = 0; i < count; i++) {
struct pipe_sampler_view templ, *view;
ctx->pipe->set_fragment_sampler_textures(ctx->pipe, count, textures);
u_sampler_view_default_template(&templ,
textures[i],
textures[i]->format);
view = ctx->pipe->create_sampler_view(ctx->pipe,
textures[i],
&templ);
pipe_texture_reference(&ctx->textures[i], textures[i]);
pipe_sampler_view_reference(&ctx->sampler_views[i], view);
}
for ( ; i < PIPE_MAX_SAMPLERS; i++) {
pipe_texture_reference(&ctx->textures[i], NULL);
pipe_sampler_view_reference(&ctx->sampler_views[i], NULL);
}
ctx->pipe->set_fragment_sampler_views(ctx->pipe,
count,
ctx->sampler_views);
return PIPE_OK;
}
@ -619,7 +643,11 @@ void cso_save_sampler_textures( struct cso_context *ctx )
ctx->nr_textures_saved = ctx->nr_textures;
for (i = 0; i < ctx->nr_textures; i++) {
assert(!ctx->textures_saved[i]);
assert(!ctx->sampler_views_saved[i]);
pipe_texture_reference(&ctx->textures_saved[i], ctx->textures[i]);
pipe_sampler_view_reference(&ctx->sampler_views_saved[i],
ctx->sampler_views[i]);
}
}
@ -633,11 +661,19 @@ void cso_restore_sampler_textures( struct cso_context *ctx )
pipe_texture_reference(&ctx->textures[i], NULL);
ctx->textures[i] = ctx->textures_saved[i];
ctx->textures_saved[i] = NULL;
}
for ( ; i < PIPE_MAX_SAMPLERS; i++)
pipe_texture_reference(&ctx->textures[i], NULL);
ctx->pipe->set_fragment_sampler_textures(ctx->pipe, ctx->nr_textures, ctx->textures);
pipe_sampler_view_reference(&ctx->sampler_views[i], NULL);
ctx->sampler_views[i] = ctx->sampler_views_saved[i];
ctx->sampler_views_saved[i] = NULL;
}
for ( ; i < PIPE_MAX_SAMPLERS; i++) {
pipe_texture_reference(&ctx->textures[i], NULL);
pipe_sampler_view_reference(&ctx->sampler_views[i], NULL);
}
ctx->pipe->set_fragment_sampler_views(ctx->pipe,
ctx->nr_textures,
ctx->sampler_views);
ctx->nr_textures_saved = 0;
}
@ -654,13 +690,26 @@ cso_set_vertex_sampler_textures(struct cso_context *ctx,
ctx->nr_vertex_textures = count;
for (i = 0; i < count; i++) {
struct pipe_sampler_view templ, *view;
u_sampler_view_default_template(&templ,
textures[i],
textures[i]->format);
view = ctx->pipe->create_sampler_view(ctx->pipe,
textures[i],
&templ);
pipe_texture_reference(&ctx->vertex_textures[i], textures[i]);
pipe_sampler_view_reference(&ctx->vertex_sampler_views[i], view);
}
for ( ; i < PIPE_MAX_VERTEX_SAMPLERS; i++) {
pipe_texture_reference(&ctx->vertex_textures[i], NULL);
pipe_sampler_view_reference(&ctx->vertex_sampler_views[i], NULL);
}
ctx->pipe->set_vertex_sampler_textures(ctx->pipe, count, textures);
ctx->pipe->set_vertex_sampler_views(ctx->pipe,
count,
ctx->vertex_sampler_views);
return PIPE_OK;
}
@ -673,7 +722,11 @@ cso_save_vertex_sampler_textures(struct cso_context *ctx)
ctx->nr_vertex_textures_saved = ctx->nr_vertex_textures;
for (i = 0; i < ctx->nr_vertex_textures; i++) {
assert(!ctx->vertex_textures_saved[i]);
assert(!ctx->vertex_sampler_views_saved[i]);
pipe_texture_reference(&ctx->vertex_textures_saved[i], ctx->vertex_textures[i]);
pipe_sampler_view_reference(&ctx->vertex_sampler_views_saved[i],
ctx->vertex_sampler_views[i]);
}
}
@ -688,14 +741,19 @@ cso_restore_vertex_sampler_textures(struct cso_context *ctx)
pipe_texture_reference(&ctx->vertex_textures[i], NULL);
ctx->vertex_textures[i] = ctx->vertex_textures_saved[i];
ctx->vertex_textures_saved[i] = NULL;
pipe_sampler_view_reference(&ctx->vertex_sampler_views[i], NULL);
ctx->vertex_sampler_views[i] = ctx->vertex_sampler_views_saved[i];
ctx->vertex_sampler_views_saved[i] = NULL;
}
for ( ; i < PIPE_MAX_VERTEX_SAMPLERS; i++) {
pipe_texture_reference(&ctx->vertex_textures[i], NULL);
pipe_sampler_view_reference(&ctx->vertex_sampler_views[i], NULL);
}
ctx->pipe->set_vertex_sampler_textures(ctx->pipe,
ctx->nr_vertex_textures,
ctx->vertex_textures);
ctx->pipe->set_vertex_sampler_views(ctx->pipe,
ctx->nr_vertex_textures,
ctx->vertex_sampler_views);
ctx->nr_vertex_textures_saved = 0;
}

58
src/gallium/auxiliary/draw/draw_pipe_aaline.c
View file

@ -40,6 +40,7 @@
#include "util/u_format.h"
#include "util/u_math.h"
#include "util/u_memory.h"
#include "util/u_sampler.h"
#include "tgsi/tgsi_transform.h"
#include "tgsi/tgsi_dump.h"
@ -88,8 +89,9 @@ struct aaline_stage
void *sampler_cso;
struct pipe_texture *texture;
struct pipe_sampler_view *sampler_view;
uint num_samplers;
uint num_textures;
uint num_sampler_views;
/*
@ -98,7 +100,7 @@ struct aaline_stage
struct aaline_fragment_shader *fs;
struct {
void *sampler[PIPE_MAX_SAMPLERS];
struct pipe_texture *texture[PIPE_MAX_SAMPLERS];
struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
} state;
/*
@ -111,8 +113,9 @@ struct aaline_stage
void (*driver_bind_sampler_states)(struct pipe_context *, unsigned,
void **);
void (*driver_set_sampler_textures)(struct pipe_context *, unsigned,
struct pipe_texture **);
void (*driver_set_sampler_views)(struct pipe_context *,
unsigned,
struct pipe_sampler_view **);
struct pipe_context *pipe;
};
@ -394,6 +397,7 @@ aaline_create_texture(struct aaline_stage *aaline)
struct pipe_context *pipe = aaline->pipe;
struct pipe_screen *screen = pipe->screen;
struct pipe_texture texTemp;
struct pipe_sampler_view viewTempl;
uint level;
memset(&texTemp, 0, sizeof(texTemp));
@ -408,6 +412,16 @@ aaline_create_texture(struct aaline_stage *aaline)
if (!aaline->texture)
return FALSE;
u_sampler_view_default_template(&viewTempl,
aaline->texture,
aaline->texture->format);
aaline->sampler_view = pipe->create_sampler_view(pipe,
aaline->texture,
&viewTempl);
if (!aaline->sampler_view) {
return FALSE;
}
/* Fill in mipmap images.
* Basically each level is solid opaque, except for the outermost
* texels which are zero. Special case the 1x1 and 2x2 levels.
@ -669,16 +683,16 @@ aaline_first_line(struct draw_stage *stage, struct prim_header *header)
/* how many samplers? */
/* we'll use sampler/texture[pstip->sampler_unit] for the stipple */
num_samplers = MAX2(aaline->num_textures, aaline->num_samplers);
num_samplers = MAX2(aaline->num_sampler_views, aaline->num_samplers);
num_samplers = MAX2(num_samplers, aaline->fs->sampler_unit + 1);
aaline->state.sampler[aaline->fs->sampler_unit] = aaline->sampler_cso;
pipe_texture_reference(&aaline->state.texture[aaline->fs->sampler_unit],
aaline->texture);
pipe_sampler_view_reference(&aaline->state.sampler_views[aaline->fs->sampler_unit],
aaline->sampler_view);
draw->suspend_flushing = TRUE;
aaline->driver_bind_sampler_states(pipe, num_samplers, aaline->state.sampler);
aaline->driver_set_sampler_textures(pipe, num_samplers, aaline->state.texture);
aaline->driver_set_sampler_views(pipe, num_samplers, aaline->state.sampler_views);
draw->suspend_flushing = FALSE;
/* now really draw first line */
@ -702,8 +716,9 @@ aaline_flush(struct draw_stage *stage, unsigned flags)
aaline->driver_bind_fs_state(pipe, aaline->fs->driver_fs);
aaline->driver_bind_sampler_states(pipe, aaline->num_samplers,
aaline->state.sampler);
aaline->driver_set_sampler_textures(pipe, aaline->num_textures,
aaline->state.texture);
aaline->driver_set_sampler_views(pipe,
aaline->num_sampler_views,
aaline->state.sampler_views);
draw->suspend_flushing = FALSE;
draw->extra_shader_outputs.slot = 0;
@ -724,7 +739,7 @@ aaline_destroy(struct draw_stage *stage)
uint i;
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
pipe_texture_reference(&aaline->state.texture[i], NULL);
pipe_sampler_view_reference(&aaline->state.sampler_views[i], NULL);
}
if (aaline->sampler_cso)
@ -733,6 +748,10 @@ aaline_destroy(struct draw_stage *stage)
if (aaline->texture)
pipe_texture_reference(&aaline->texture, NULL);
if (aaline->sampler_view) {
pipe_sampler_view_reference(&aaline->sampler_view, NULL);
}
draw_free_temp_verts( stage );
FREE( stage );
@ -844,23 +863,24 @@ aaline_bind_sampler_states(struct pipe_context *pipe,
static void
aaline_set_sampler_textures(struct pipe_context *pipe,
unsigned num, struct pipe_texture **texture)
aaline_set_sampler_views(struct pipe_context *pipe,
unsigned num,
struct pipe_sampler_view **views)
{
struct aaline_stage *aaline = aaline_stage_from_pipe(pipe);
uint i;
/* save current */
for (i = 0; i < num; i++) {
pipe_texture_reference(&aaline->state.texture[i], texture[i]);
pipe_sampler_view_reference(&aaline->state.sampler_views[i], views[i]);
}
for ( ; i < PIPE_MAX_SAMPLERS; i++) {
pipe_texture_reference(&aaline->state.texture[i], NULL);
pipe_sampler_view_reference(&aaline->state.sampler_views[i], NULL);
}
aaline->num_textures = num;
aaline->num_sampler_views = num;
/* pass-through */
aaline->driver_set_sampler_textures(aaline->pipe, num, texture);
aaline->driver_set_sampler_views(aaline->pipe, num, views);
}
@ -898,7 +918,7 @@ draw_install_aaline_stage(struct draw_context *draw, struct pipe_context *pipe)
aaline->driver_delete_fs_state = pipe->delete_fs_state;
aaline->driver_bind_sampler_states = pipe->bind_fragment_sampler_states;
aaline->driver_set_sampler_textures = pipe->set_fragment_sampler_textures;
aaline->driver_set_sampler_views = pipe->set_fragment_sampler_views;
/* override the driver's functions */
pipe->create_fs_state = aaline_create_fs_state;
@ -906,7 +926,7 @@ draw_install_aaline_stage(struct draw_context *draw, struct pipe_context *pipe)
pipe->delete_fs_state = aaline_delete_fs_state;
pipe->bind_fragment_sampler_states = aaline_bind_sampler_states;
pipe->set_fragment_sampler_textures = aaline_set_sampler_textures;
pipe->set_fragment_sampler_views = aaline_set_sampler_views;
/* Install once everything is known to be OK:
*/

58
src/gallium/auxiliary/draw/draw_pipe_pstipple.c
View file

@ -42,6 +42,7 @@
#include "util/u_format.h"
#include "util/u_math.h"
#include "util/u_memory.h"
#include "util/u_sampler.h"
#include "tgsi/tgsi_transform.h"
#include "tgsi/tgsi_dump.h"
@ -75,8 +76,9 @@ struct pstip_stage
void *sampler_cso;
struct pipe_texture *texture;
struct pipe_sampler_view *sampler_view;
uint num_samplers;
uint num_textures;
uint num_sampler_views;
/*
* Currently bound state
@ -84,7 +86,7 @@ struct pstip_stage
struct pstip_fragment_shader *fs;
struct {
void *samplers[PIPE_MAX_SAMPLERS];
struct pipe_texture *textures[PIPE_MAX_SAMPLERS];
struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
const struct pipe_poly_stipple *stipple;
} state;
@ -98,8 +100,9 @@ struct pstip_stage
void (*driver_bind_sampler_states)(struct pipe_context *, unsigned, void **);
void (*driver_set_sampler_textures)(struct pipe_context *, unsigned,
struct pipe_texture **);
void (*driver_set_sampler_views)(struct pipe_context *,
unsigned,
struct pipe_sampler_view **);
void (*driver_set_polygon_stipple)(struct pipe_context *,
const struct pipe_poly_stipple *);
@ -422,6 +425,7 @@ pstip_create_texture(struct pstip_stage *pstip)
struct pipe_context *pipe = pstip->pipe;
struct pipe_screen *screen = pipe->screen;
struct pipe_texture texTemp;
struct pipe_sampler_view viewTempl;
memset(&texTemp, 0, sizeof(texTemp));
texTemp.target = PIPE_TEXTURE_2D;
@ -435,6 +439,16 @@ pstip_create_texture(struct pstip_stage *pstip)
if (pstip->texture == NULL)
return FALSE;
u_sampler_view_default_template(&viewTempl,
pstip->texture,
pstip->texture->format);
pstip->sampler_view = pipe->create_sampler_view(pipe,
pstip->texture,
&viewTempl);
if (!pstip->sampler_view) {
return FALSE;
}
return TRUE;
}
@ -513,19 +527,19 @@ pstip_first_tri(struct draw_stage *stage, struct prim_header *header)
/* how many samplers? */
/* we'll use sampler/texture[pstip->sampler_unit] for the stipple */
num_samplers = MAX2(pstip->num_textures, pstip->num_samplers);
num_samplers = MAX2(pstip->num_sampler_views, pstip->num_samplers);
num_samplers = MAX2(num_samplers, pstip->fs->sampler_unit + 1);
/* plug in our sampler, texture */
pstip->state.samplers[pstip->fs->sampler_unit] = pstip->sampler_cso;
pipe_texture_reference(&pstip->state.textures[pstip->fs->sampler_unit],
pstip->texture);
pipe_sampler_view_reference(&pstip->state.sampler_views[pstip->fs->sampler_unit],
pstip->sampler_view);
assert(num_samplers <= PIPE_MAX_SAMPLERS);
draw->suspend_flushing = TRUE;
pstip->driver_bind_sampler_states(pipe, num_samplers, pstip->state.samplers);
pstip->driver_set_sampler_textures(pipe, num_samplers, pstip->state.textures);
pstip->driver_set_sampler_views(pipe, num_samplers, pstip->state.sampler_views);
draw->suspend_flushing = FALSE;
/* now really draw first triangle */
@ -549,8 +563,9 @@ pstip_flush(struct draw_stage *stage, unsigned flags)
pstip->driver_bind_fs_state(pipe, pstip->fs->driver_fs);
pstip->driver_bind_sampler_states(pipe, pstip->num_samplers,
pstip->state.samplers);
pstip->driver_set_sampler_textures(pipe, pstip->num_textures,
pstip->state.textures);
pstip->driver_set_sampler_views(pipe,
pstip->num_sampler_views,
pstip->state.sampler_views);
draw->suspend_flushing = FALSE;
}
@ -569,13 +584,17 @@ pstip_destroy(struct draw_stage *stage)
uint i;
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
pipe_texture_reference(&pstip->state.textures[i], NULL);
pipe_sampler_view_reference(&pstip->state.sampler_views[i], NULL);
}
pstip->pipe->delete_sampler_state(pstip->pipe, pstip->sampler_cso);
pipe_texture_reference(&pstip->texture, NULL);
if (pstip->sampler_view) {
pipe_sampler_view_reference(&pstip->sampler_view, NULL);
}
draw_free_temp_verts( stage );
FREE( stage );
}
@ -680,24 +699,25 @@ pstip_bind_sampler_states(struct pipe_context *pipe,
static void
pstip_set_sampler_textures(struct pipe_context *pipe,
unsigned num, struct pipe_texture **texture)
pstip_set_sampler_views(struct pipe_context *pipe,
unsigned num,
struct pipe_sampler_view **views)
{
struct pstip_stage *pstip = pstip_stage_from_pipe(pipe);
uint i;
/* save current */
for (i = 0; i < num; i++) {
pipe_texture_reference(&pstip->state.textures[i], texture[i]);
pipe_sampler_view_reference(&pstip->state.sampler_views[i], views[i]);
}
for (; i < PIPE_MAX_SAMPLERS; i++) {
pipe_texture_reference(&pstip->state.textures[i], NULL);
pipe_sampler_view_reference(&pstip->state.sampler_views[i], NULL);
}
pstip->num_textures = num;
pstip->num_sampler_views = num;
/* pass-through */
pstip->driver_set_sampler_textures(pstip->pipe, num, texture);
pstip->driver_set_sampler_views(pstip->pipe, num, views);
}
@ -754,7 +774,7 @@ draw_install_pstipple_stage(struct draw_context *draw,
pstip->driver_delete_fs_state = pipe->delete_fs_state;
pstip->driver_bind_sampler_states = pipe->bind_fragment_sampler_states;
pstip->driver_set_sampler_textures = pipe->set_fragment_sampler_textures;
pstip->driver_set_sampler_views = pipe->set_fragment_sampler_views;
pstip->driver_set_polygon_stipple = pipe->set_polygon_stipple;
/* override the driver's functions */
@ -763,7 +783,7 @@ draw_install_pstipple_stage(struct draw_context *draw,
pipe->delete_fs_state = pstip_delete_fs_state;
pipe->bind_fragment_sampler_states = pstip_bind_sampler_states;
pipe->set_fragment_sampler_textures = pstip_set_sampler_textures;
pipe->set_fragment_sampler_views = pstip_set_sampler_views;
pipe->set_polygon_stipple = pstip_set_polygon_stipple;
return TRUE;

36
src/gallium/auxiliary/util/u_blitter.c
View file

@ -45,6 +45,7 @@
#include "util/u_draw_quad.h"
#include "util/u_pack_color.h"
#include "util/u_rect.h"
#include "util/u_sampler.h"
#include "util/u_simple_shaders.h"
#include "util/u_texture.h"
@ -93,6 +94,8 @@ struct blitter_context_priv
/* Rasterizer state. */
void *rs_state;
struct pipe_sampler_view *sampler_view;
};
struct blitter_context *util_blitter_create(struct pipe_context *pipe)
@ -117,7 +120,7 @@ struct blitter_context *util_blitter_create(struct pipe_context *pipe)
ctx->blitter.saved_fs = INVALID_PTR;
ctx->blitter.saved_vs = INVALID_PTR;
ctx->blitter.saved_fb_state.nr_cbufs = ~0;
ctx->blitter.saved_num_textures = ~0;
ctx->blitter.saved_num_sampler_views = ~0;
ctx->blitter.saved_num_sampler_states = ~0;
/* blend state objects */
@ -230,6 +233,10 @@ void util_blitter_destroy(struct blitter_context *blitter)
if (ctx->sampler_state[i])
pipe->delete_sampler_state(pipe, ctx->sampler_state[i]);
if (ctx->sampler_view) {
pipe_sampler_view_reference(&ctx->sampler_view, NULL);
}
pipe_buffer_reference(&ctx->vbuf, NULL);
FREE(ctx);
}
@ -277,11 +284,11 @@ static void blitter_restore_CSOs(struct blitter_context_priv *ctx)
ctx->blitter.saved_num_sampler_states = ~0;
}
if (ctx->blitter.saved_num_textures != ~0) {
pipe->set_fragment_sampler_textures(pipe,
ctx->blitter.saved_num_textures,
ctx->blitter.saved_textures);
ctx->blitter.saved_num_textures = ~0;
if (ctx->blitter.saved_num_sampler_views != ~0) {
pipe->set_fragment_sampler_views(pipe,
ctx->blitter.saved_num_sampler_views,
ctx->blitter.saved_sampler_views);
ctx->blitter.saved_num_sampler_views = ~0;
}
}
@ -577,9 +584,10 @@ static void util_blitter_do_copy(struct blitter_context *blitter,
struct blitter_context_priv *ctx = (struct blitter_context_priv*)blitter;
struct pipe_context *pipe = ctx->pipe;
struct pipe_framebuffer_state fb_state;
struct pipe_sampler_view viewTempl, *view;
assert(blitter->saved_fb_state.nr_cbufs != ~0);
assert(blitter->saved_num_textures != ~0);
assert(blitter->saved_num_sampler_views != ~0);
assert(blitter->saved_num_sampler_states != ~0);
assert(src->texture->target < PIPE_MAX_TEXTURE_TYPES);
@ -607,11 +615,23 @@ static void util_blitter_do_copy(struct blitter_context *blitter,
fb_state.zsbuf = 0;
}
u_sampler_view_default_template(&viewTempl,
src->texture,
src->texture->format);
view = pipe->create_sampler_view(pipe,
src->texture,
&viewTempl);
if (ctx->sampler_view) {
pipe_sampler_view_reference(&ctx->sampler_view, NULL);
}
ctx->sampler_view = view;
pipe->bind_rasterizer_state(pipe, ctx->rs_state);
pipe->bind_vs_state(pipe, ctx->vs_tex);
pipe->bind_fragment_sampler_states(pipe, 1,
blitter_get_sampler_state(ctx, src->level));
pipe->set_fragment_sampler_textures(pipe, 1, &src->texture);
pipe->set_fragment_sampler_views(pipe, 1, &view);
pipe->set_framebuffer_state(pipe, &fb_state);
/* set texture coordinates */

24
src/gallium/auxiliary/util/u_blitter.h
View file

@ -50,10 +50,10 @@ struct blitter_context
struct pipe_stencil_ref saved_stencil_ref; /**< stencil ref */
int saved_num_sampler_states;
void *saved_sampler_states[32];
void *saved_sampler_states[PIPE_MAX_SAMPLERS];
int saved_num_textures;
struct pipe_texture *saved_textures[32]; /* is 32 enough? */
int saved_num_sampler_views;
struct pipe_sampler_view *saved_sampler_views[PIPE_MAX_SAMPLERS];
};
/**
@ -218,17 +218,17 @@ void util_blitter_save_fragment_sampler_states(
num_sampler_states * sizeof(void *));
}
static INLINE
void util_blitter_save_fragment_sampler_textures(
struct blitter_context *blitter,
int num_textures,
struct pipe_texture **textures)
static INLINE void
util_blitter_save_fragment_sampler_views(struct blitter_context *blitter,
int num_views,
struct pipe_sampler_view **views)
{
assert(num_textures <= Elements(blitter->saved_textures));
assert(num_views <= Elements(blitter->saved_sampler_views));
blitter->saved_num_textures = num_textures;
memcpy(blitter->saved_textures, textures,
num_textures * sizeof(struct pipe_texture *));
blitter->saved_num_sampler_views = num_views;
memcpy(blitter->saved_sampler_views,
views,
num_views * sizeof(struct pipe_sampler_view *));
}
#ifdef __cplusplus

10
src/gallium/auxiliary/util/u_inlines.h
View file

@ -117,6 +117,16 @@ pipe_texture_reference(struct pipe_texture **ptr, struct pipe_texture *tex)
*ptr = tex;
}
static INLINE void
pipe_sampler_view_reference(struct pipe_sampler_view **ptr, struct pipe_sampler_view *view)
{
struct pipe_sampler_view *old_view = *ptr;
if (pipe_reference(&(*ptr)->reference, &view->reference))
old_view->context->sampler_view_destroy(old_view->context, old_view);
*ptr = view;
}
/*
* Convenience wrappers for screen buffer functions.

97
src/gallium/auxiliary/util/u_sampler.c Normal file
View file

@ -0,0 +1,97 @@
/**************************************************************************
*
* Copyright 2010 VMware, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include "u_format.h"
#include "u_sampler.h"
static void
default_template(struct pipe_sampler_view *view,
const struct pipe_texture *texture,
enum pipe_format format,
unsigned expand_green_blue)
{
/* XXX: Check if format is compatible with texture->format.
*/
view->format = format;
view->first_level = 0;
view->num_levels = texture->last_level + 1;
view->swizzle_r = PIPE_SWIZZLE_RED;
view->swizzle_g = PIPE_SWIZZLE_GREEN;
view->swizzle_b = PIPE_SWIZZLE_BLUE;
view->swizzle_a = PIPE_SWIZZLE_ALPHA;
/* Override default green and blue component expansion to the requested one.
*
* Gallium expands nonexistent components to (0,0,0,1), DX9 expands to (1,1,1,1).
* Since alpha is always expanded to 1, and red is always present, we only really
* care about green and blue components.
*
* To make it look less hackish, one would have to add UTIL_FORMAT_SWIZZLE_EXPAND
* to indicate components for expansion and then override without exceptions or
* favoring one component over another.
*/
if (format != PIPE_FORMAT_A8_UNORM) {
const struct util_format_description *desc = util_format_description(format);
assert(desc);
if (desc) {
if (desc->swizzle[1] == UTIL_FORMAT_SWIZZLE_0) {
view->swizzle_g = expand_green_blue;
}
if (desc->swizzle[2] == UTIL_FORMAT_SWIZZLE_0) {
view->swizzle_b = expand_green_blue;
}
}
}
}
void
u_sampler_view_default_template(struct pipe_sampler_view *view,
const struct pipe_texture *texture,
enum pipe_format format)
{
/* Expand to (0, 0, 0, 1) */
default_template(view,
texture,
format,
PIPE_SWIZZLE_ZERO);
}
void
u_sampler_view_default_dx9_template(struct pipe_sampler_view *view,
const struct pipe_texture *texture,
enum pipe_format format)
{
/* Expand to (1, 1, 1, 1) */
default_template(view,
texture,
format,
PIPE_SWIZZLE_ONE);
}

57
src/gallium/auxiliary/util/u_sampler.h Normal file
View file

@ -0,0 +1,57 @@
/**************************************************************************
*
* Copyright 2010 VMware, Inc.
* All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sub license, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice (including the
* next paragraph) shall be included in all copies or substantial portions
* of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
* IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#ifndef U_SAMPLER_H
#define U_SAMPLER_H
#include "pipe/p_defines.h"
#include "pipe/p_format.h"
#include "pipe/p_state.h"
#ifdef __cplusplus
extern "C" {
#endif
void
u_sampler_view_default_template(struct pipe_sampler_view *view,
const struct pipe_texture *texture,
enum pipe_format format);
void
u_sampler_view_default_dx9_template(struct pipe_sampler_view *view,
const struct pipe_texture *texture,
enum pipe_format format);
#ifdef __cplusplus
} /* extern "C" { */
#endif
#endif /* U_SAMPLER_H */

8
src/gallium/drivers/failover/fo_context.h
View file

@ -85,8 +85,8 @@ struct failover_context {
struct pipe_framebuffer_state framebuffer;
struct pipe_poly_stipple poly_stipple;
struct pipe_scissor_state scissor;
struct pipe_texture *texture[PIPE_MAX_SAMPLERS];
struct pipe_texture *vertex_textures[PIPE_MAX_VERTEX_SAMPLERS];
struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
struct pipe_sampler_view *vertex_sampler_views[PIPE_MAX_VERTEX_SAMPLERS];
struct pipe_viewport_state viewport;
struct pipe_vertex_buffer vertex_buffers[PIPE_MAX_ATTRIBS];
struct pipe_vertex_element vertex_elements[PIPE_MAX_ATTRIBS];
@ -103,8 +103,8 @@ struct failover_context {
unsigned num_samplers;
unsigned num_vertex_samplers;
unsigned num_textures;
unsigned num_vertex_textures;
unsigned num_sampler_views;
unsigned num_vertex_sampler_views;
unsigned mode;
struct pipe_context *hw;

60
src/gallium/drivers/failover/fo_state.c
View file

@ -405,9 +405,9 @@ failover_delete_sampler_state(struct pipe_context *pipe, void *sampler)
static void
failover_set_fragment_sampler_textures(struct pipe_context *pipe,
unsigned num,
struct pipe_texture **texture)
failover_set_fragment_sampler_views(struct pipe_context *pipe,
unsigned num,
struct pipe_sampler_view **views)
{
struct failover_context *failover = failover_context(pipe);
uint i;
@ -415,49 +415,49 @@ failover_set_fragment_sampler_textures(struct pipe_context *pipe,
assert(num <= PIPE_MAX_SAMPLERS);
/* Check for no-op */
if (num == failover->num_textures &&
!memcmp(failover->texture, texture, num * sizeof(struct pipe_texture *)))
if (num == failover->num_sampler_views &&
!memcmp(failover->sampler_views, views, num * sizeof(struct pipe_sampler_view *)))
return;
for (i = 0; i < num; i++)
pipe_texture_reference((struct pipe_texture **) &failover->texture[i],
texture[i]);
for (i = num; i < failover->num_textures; i++)
pipe_texture_reference((struct pipe_texture **) &failover->texture[i],
NULL);
pipe_sampler_view_reference((struct pipe_sampler_view **) &failover->sampler_views[i],
views[i]);
for (i = num; i < failover->num_sampler_views; i++)
pipe_sampler_view_reference((struct pipe_sampler_view **) &failover->sampler_views[i],
NULL);
failover->dirty |= FO_NEW_TEXTURE;
failover->num_textures = num;
failover->sw->set_fragment_sampler_textures( failover->sw, num, texture );
failover->hw->set_fragment_sampler_textures( failover->hw, num, texture );
failover->num_sampler_views = num;
failover->sw->set_fragment_sampler_views( failover->sw, num, views );
failover->hw->set_fragment_sampler_views( failover->hw, num, views );
}
static void
failover_set_vertex_sampler_textures(struct pipe_context *pipe,
unsigned num_textures,
struct pipe_texture **textures)
failover_set_vertex_sampler_views(struct pipe_context *pipe,
unsigned num,
struct pipe_sampler_view **views)
{
struct failover_context *failover = failover_context(pipe);
uint i;
assert(num_textures <= PIPE_MAX_VERTEX_SAMPLERS);
assert(num <= PIPE_MAX_VERTEX_SAMPLERS);
/* Check for no-op */
if (num_textures == failover->num_vertex_textures &&
!memcmp(failover->vertex_textures, textures, num_textures * sizeof(struct pipe_texture *))) {
if (num == failover->num_vertex_sampler_views &&
!memcmp(failover->vertex_sampler_views, views, num * sizeof(struct pipe_sampler_view *))) {
return;
}
for (i = 0; i < num_textures; i++) {
pipe_texture_reference((struct pipe_texture **)&failover->vertex_textures[i],
textures[i]);
for (i = 0; i < num; i++) {
pipe_sampler_view_reference((struct pipe_sampler_view **)&failover->vertex_sampler_views[i],
views[i]);
}
for (i = num_textures; i < failover->num_vertex_textures; i++) {
pipe_texture_reference((struct pipe_texture **)&failover->vertex_textures[i],
NULL);
for (i = num; i < failover->num_vertex_sampler_views; i++) {
pipe_sampler_view_reference((struct pipe_sampler_view **)&failover->vertex_sampler_views[i],
NULL);
}
failover->dirty |= FO_NEW_TEXTURE;
failover->num_vertex_textures = num_textures;
failover->sw->set_vertex_sampler_textures(failover->sw, num_textures, textures);
failover->hw->set_vertex_sampler_textures(failover->hw, num_textures, textures);
failover->num_vertex_sampler_views = num;
failover->sw->set_vertex_sampler_views(failover->sw, num, views);
failover->hw->set_vertex_sampler_views(failover->hw, num, views);
}
@ -550,8 +550,8 @@ failover_init_state_functions( struct failover_context *failover )
failover->pipe.set_framebuffer_state = failover_set_framebuffer_state;
failover->pipe.set_polygon_stipple = failover_set_polygon_stipple;
failover->pipe.set_scissor_state = failover_set_scissor_state;
failover->pipe.set_fragment_sampler_textures = failover_set_fragment_sampler_textures;
failover->pipe.set_vertex_sampler_textures = failover_set_vertex_sampler_textures;
failover->pipe.set_fragment_sampler_views = failover_set_fragment_sampler_views;
failover->pipe.set_vertex_sampler_views = failover_set_vertex_sampler_views;
failover->pipe.set_viewport_state = failover_set_viewport_state;
failover->pipe.set_vertex_buffers = failover_set_vertex_buffers;
failover->pipe.set_vertex_elements = failover_set_vertex_elements;

10
src/gallium/drivers/failover/fo_state_emit.c
View file

@ -103,11 +103,11 @@ failover_state_emit( struct failover_context *failover )
}
if (failover->dirty & FO_NEW_TEXTURE) {
failover->sw->set_fragment_sampler_textures( failover->sw, failover->num_textures,
failover->texture );
failover->sw->set_vertex_sampler_textures(failover->sw,
failover->num_vertex_textures,
failover->vertex_textures);
failover->sw->set_fragment_sampler_views( failover->sw, failover->num_sampler_views,
failover->sampler_views );
failover->sw->set_vertex_sampler_views(failover->sw,
failover->num_vertex_sampler_views,
failover->vertex_sampler_views);
}
if (failover->dirty & FO_NEW_VERTEX_BUFFER) {

52
src/gallium/drivers/identity/id_context.c
View file

@ -492,53 +492,49 @@ identity_set_viewport_state(struct pipe_context *_pipe,
}
static void
identity_set_fragment_sampler_textures(struct pipe_context *_pipe,
unsigned num_textures,
struct pipe_texture **_textures)
identity_set_fragment_sampler_views(struct pipe_context *_pipe,
unsigned num,
struct pipe_sampler_view **_views)
{
struct identity_context *id_pipe = identity_context(_pipe);
struct pipe_context *pipe = id_pipe->pipe;
struct pipe_texture *unwrapped_textures[PIPE_MAX_SAMPLERS];
struct pipe_texture **textures = NULL;
struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
struct pipe_sampler_view **views = NULL;
unsigned i;
if (_textures) {
for (i = 0; i < num_textures; i++)
unwrapped_textures[i] = identity_texture_unwrap(_textures[i]);
if (_views) {
for (i = 0; i < num; i++)
unwrapped_views[i] = identity_sampler_view_unwrap(_views[i]);
for (; i < PIPE_MAX_SAMPLERS; i++)
unwrapped_textures[i] = NULL;
unwrapped_views[i] = NULL;
textures = unwrapped_textures;
views = unwrapped_views;
}
pipe->set_fragment_sampler_textures(pipe,
num_textures,
textures);
pipe->set_fragment_sampler_views(pipe, num, views);
}
static void
identity_set_vertex_sampler_textures(struct pipe_context *_pipe,
unsigned num_textures,
struct pipe_texture **_textures)
identity_set_vertex_sampler_views(struct pipe_context *_pipe,
unsigned num,
struct pipe_sampler_view **_views)
{
struct identity_context *id_pipe = identity_context(_pipe);
struct pipe_context *pipe = id_pipe->pipe;
struct pipe_texture *unwrapped_textures[PIPE_MAX_VERTEX_SAMPLERS];
struct pipe_texture **textures = NULL;
struct pipe_sampler_view *unwrapped_views[PIPE_MAX_VERTEX_SAMPLERS];
struct pipe_sampler_view **views = NULL;
unsigned i;
if (_textures) {
for (i = 0; i < num_textures; i++)
unwrapped_textures[i] = identity_texture_unwrap(_textures[i]);
if (_views) {
for (i = 0; i < num; i++)
unwrapped_views[i] = identity_sampler_view_unwrap(_views[i]);
for (; i < PIPE_MAX_VERTEX_SAMPLERS; i++)
unwrapped_textures[i] = NULL;
unwrapped_views[i] = NULL;
textures = unwrapped_textures;
views = unwrapped_views;
}
pipe->set_vertex_sampler_textures(pipe,
num_textures,
textures);
pipe->set_vertex_sampler_views(pipe, num, views);
}
static void
@ -741,8 +737,8 @@ identity_context_create(struct pipe_screen *_screen, struct pipe_context *pipe)
id_pipe->base.set_polygon_stipple = identity_set_polygon_stipple;
id_pipe->base.set_scissor_state = identity_set_scissor_state;
id_pipe->base.set_viewport_state = identity_set_viewport_state;
id_pipe->base.set_fragment_sampler_textures = identity_set_fragment_sampler_textures;
id_pipe->base.set_vertex_sampler_textures = identity_set_vertex_sampler_textures;
id_pipe->base.set_fragment_sampler_views = identity_set_fragment_sampler_views;
id_pipe->base.set_vertex_sampler_views = identity_set_vertex_sampler_views;
id_pipe->base.set_vertex_buffers = identity_set_vertex_buffers;
id_pipe->base.set_vertex_elements = identity_set_vertex_elements;
id_pipe->base.surface_copy = identity_surface_copy;

26
src/gallium/drivers/identity/id_objects.h
View file

@ -52,6 +52,14 @@ struct identity_texture
};
struct identity_sampler_view
{
struct pipe_sampler_view base;
struct pipe_sampler_view *sampler_view;
};
struct identity_surface
{
struct pipe_surface base;
@ -94,6 +102,15 @@ identity_texture(struct pipe_texture *_texture)
return (struct identity_texture *)_texture;
}
static INLINE struct identity_sampler_view *
identity_sampler_view(struct pipe_sampler_view *_sampler_view)
{
if (!_sampler_view) {
return NULL;
}
return (struct identity_sampler_view *)_sampler_view;
}
static INLINE struct identity_surface *
identity_surface(struct pipe_surface *_surface)
{
@ -138,6 +155,15 @@ identity_texture_unwrap(struct pipe_texture *_texture)
return identity_texture(_texture)->texture;
}
static INLINE struct pipe_sampler_view *
identity_sampler_view_unwrap(struct pipe_sampler_view *_sampler_view)
{
if (!_sampler_view) {
return NULL;
}
return identity_sampler_view(_sampler_view)->sampler_view;
}
static INLINE struct pipe_surface *
identity_surface_unwrap(struct pipe_surface *_surface)
{

8
src/gallium/drivers/softpipe/sp_context.c
View file

@ -103,12 +103,12 @@ softpipe_destroy( struct pipe_context *pipe )
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
sp_destroy_tex_tile_cache(softpipe->tex_cache[i]);
pipe_texture_reference(&softpipe->texture[i], NULL);
pipe_sampler_view_reference(&softpipe->sampler_views[i], NULL);
}
for (i = 0; i < PIPE_MAX_VERTEX_SAMPLERS; i++) {
sp_destroy_tex_tile_cache(softpipe->vertex_tex_cache[i]);
pipe_texture_reference(&softpipe->vertex_textures[i], NULL);
pipe_sampler_view_reference(&softpipe->vertex_sampler_views[i], NULL);
}
for (i = 0; i < PIPE_SHADER_TYPES; i++) {
@ -252,8 +252,8 @@ softpipe_create_context( struct pipe_screen *screen,
softpipe->pipe.set_framebuffer_state = softpipe_set_framebuffer_state;
softpipe->pipe.set_polygon_stipple = softpipe_set_polygon_stipple;
softpipe->pipe.set_scissor_state = softpipe_set_scissor_state;
softpipe->pipe.set_fragment_sampler_textures = softpipe_set_sampler_textures;
softpipe->pipe.set_vertex_sampler_textures = softpipe_set_vertex_sampler_textures;
softpipe->pipe.set_fragment_sampler_views = softpipe_set_sampler_views;
softpipe->pipe.set_vertex_sampler_views = softpipe_set_vertex_sampler_views;
softpipe->pipe.set_viewport_state = softpipe_set_viewport_state;
softpipe->pipe.set_vertex_buffers = softpipe_set_vertex_buffers;

8
src/gallium/drivers/softpipe/sp_context.h
View file

@ -68,16 +68,16 @@ struct softpipe_context {
struct pipe_framebuffer_state framebuffer;
struct pipe_poly_stipple poly_stipple;
struct pipe_scissor_state scissor;
struct pipe_texture *texture[PIPE_MAX_SAMPLERS];
struct pipe_texture *vertex_textures[PIPE_MAX_VERTEX_SAMPLERS];
struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
struct pipe_sampler_view *vertex_sampler_views[PIPE_MAX_VERTEX_SAMPLERS];
struct pipe_viewport_state viewport;
struct pipe_vertex_buffer vertex_buffer[PIPE_MAX_ATTRIBS];
struct pipe_vertex_element vertex_element[PIPE_MAX_ATTRIBS];
unsigned num_samplers;
unsigned num_textures;
unsigned num_sampler_views;
unsigned num_vertex_samplers;
unsigned num_vertex_textures;
unsigned num_vertex_sampler_views;
unsigned num_vertex_elements;
unsigned num_vertex_buffers;

4
src/gallium/drivers/softpipe/sp_flush.c
View file

@ -50,10 +50,10 @@ softpipe_flush( struct pipe_context *pipe,
draw_flush(softpipe->draw);
if (flags & PIPE_FLUSH_TEXTURE_CACHE) {
for (i = 0; i < softpipe->num_textures; i++) {
for (i = 0; i < softpipe->num_sampler_views; i++) {
sp_flush_tex_tile_cache(softpipe->tex_cache[i]);
}
for (i = 0; i < softpipe->num_vertex_textures; i++) {
for (i = 0; i < softpipe->num_vertex_sampler_views; i++) {
sp_flush_tex_tile_cache(softpipe->vertex_tex_cache[i]);
}
}

12
src/gallium/drivers/softpipe/sp_state.h
View file

@ -166,14 +166,14 @@ void softpipe_set_polygon_stipple( struct pipe_context *,
void softpipe_set_scissor_state( struct pipe_context *,
const struct pipe_scissor_state * );
void softpipe_set_sampler_textures( struct pipe_context *,
unsigned num,
struct pipe_texture ** );
void softpipe_set_sampler_views( struct pipe_context *,
unsigned num,
struct pipe_sampler_view ** );
void
softpipe_set_vertex_sampler_textures(struct pipe_context *,
unsigned num_textures,
struct pipe_texture **);
softpipe_set_vertex_sampler_views(struct pipe_context *,
unsigned num,
struct pipe_sampler_view **);
void softpipe_set_viewport_state( struct pipe_context *,
const struct pipe_viewport_state * );

63
src/gallium/drivers/softpipe/sp_state_sampler.c
View file

@ -122,8 +122,9 @@ softpipe_bind_vertex_sampler_states(struct pipe_context *pipe,
void
softpipe_set_sampler_textures(struct pipe_context *pipe,
unsigned num, struct pipe_texture **texture)
softpipe_set_sampler_views(struct pipe_context *pipe,
unsigned num,
struct pipe_sampler_view **views)
{
struct softpipe_context *softpipe = softpipe_context(pipe);
uint i;
@ -131,51 +132,53 @@ softpipe_set_sampler_textures(struct pipe_context *pipe,
assert(num <= PIPE_MAX_SAMPLERS);
/* Check for no-op */
if (num == softpipe->num_textures &&
!memcmp(softpipe->texture, texture, num * sizeof(struct pipe_texture *)))
if (num == softpipe->num_sampler_views &&
!memcmp(softpipe->sampler_views, views, num * sizeof(struct pipe_sampler_view *)))
return;
draw_flush(softpipe->draw);
for (i = 0; i < PIPE_MAX_SAMPLERS; i++) {
struct pipe_texture *tex = i < num ? texture[i] : NULL;
struct pipe_sampler_view *view = i < num ? views[i] : NULL;
struct pipe_texture *texture = view ? view->texture : NULL;
pipe_texture_reference(&softpipe->texture[i], tex);
sp_tex_tile_cache_set_texture(softpipe->tex_cache[i], tex);
pipe_sampler_view_reference(&softpipe->sampler_views[i], view);
sp_tex_tile_cache_set_texture(softpipe->tex_cache[i], texture);
}
softpipe->num_textures = num;
softpipe->num_sampler_views = num;
softpipe->dirty |= SP_NEW_TEXTURE;
}
void
softpipe_set_vertex_sampler_textures(struct pipe_context *pipe,
unsigned num_textures,
struct pipe_texture **textures)
softpipe_set_vertex_sampler_views(struct pipe_context *pipe,
unsigned num,
struct pipe_sampler_view **views)
{
struct softpipe_context *softpipe = softpipe_context(pipe);
uint i;
assert(num_textures <= PIPE_MAX_VERTEX_SAMPLERS);
assert(num <= PIPE_MAX_VERTEX_SAMPLERS);
/* Check for no-op */
if (num_textures == softpipe->num_vertex_textures &&
!memcmp(softpipe->vertex_textures, textures, num_textures * sizeof(struct pipe_texture *))) {
if (num == softpipe->num_vertex_sampler_views &&
!memcmp(softpipe->vertex_sampler_views, views, num * sizeof(struct pipe_sampler_view *))) {
return;
}
draw_flush(softpipe->draw);
for (i = 0; i < PIPE_MAX_VERTEX_SAMPLERS; i++) {
struct pipe_texture *tex = i < num_textures ? textures[i] : NULL;
struct pipe_sampler_view *view = i < num ? views[i] : NULL;
struct pipe_texture *texture = view ? view->texture : NULL;
pipe_texture_reference(&softpipe->vertex_textures[i], tex);
sp_tex_tile_cache_set_texture(softpipe->vertex_tex_cache[i], tex);
pipe_sampler_view_reference(&softpipe->vertex_sampler_views[i], view);
sp_tex_tile_cache_set_texture(softpipe->vertex_tex_cache[i], texture);
}
softpipe->num_vertex_textures = num_textures;
softpipe->num_vertex_sampler_views = num;
softpipe->dirty |= SP_NEW_TEXTURE;
}
@ -245,29 +248,41 @@ softpipe_reset_sampler_varients(struct softpipe_context *softpipe)
*/
for (i = 0; i <= softpipe->vs->max_sampler; i++) {
if (softpipe->vertex_samplers[i]) {
struct pipe_texture *texture = NULL;
if (softpipe->vertex_sampler_views[i]) {
texture = softpipe->vertex_sampler_views[i]->texture;
}
softpipe->tgsi.vert_samplers_list[i] =
get_sampler_varient( i,
sp_sampler(softpipe->vertex_samplers[i]),
softpipe->vertex_textures[i],
sp_sampler(softpipe->vertex_samplers[i]),
texture,
TGSI_PROCESSOR_VERTEX );
sp_sampler_varient_bind_texture( softpipe->tgsi.vert_samplers_list[i],
softpipe->vertex_tex_cache[i],
softpipe->vertex_textures[i] );
softpipe->vertex_tex_cache[i],
texture );
}
}
for (i = 0; i <= softpipe->fs->info.file_max[TGSI_FILE_SAMPLER]; i++) {
if (softpipe->sampler[i]) {
struct pipe_texture *texture = NULL;
if (softpipe->sampler_views[i]) {
texture = softpipe->sampler_views[i]->texture;
}
softpipe->tgsi.frag_samplers_list[i] =
get_sampler_varient( i,
sp_sampler(softpipe->sampler[i]),
softpipe->texture[i],
texture,
TGSI_PROCESSOR_FRAGMENT );
sp_sampler_varient_bind_texture( softpipe->tgsi.frag_samplers_list[i],
softpipe->tex_cache[i],
softpipe->texture[i] );
texture );
}
}
}

4
src/gallium/drivers/svga/svga_context.h
View file

@ -179,7 +179,7 @@ struct svga_state
const struct svga_rasterizer_state *rast;
const struct svga_sampler_state *sampler[PIPE_MAX_SAMPLERS];
struct pipe_texture *texture[PIPE_MAX_SAMPLERS]; /* or texture ID's? */
struct pipe_sampler_view *sampler_views[PIPE_MAX_SAMPLERS]; /* or texture ID's? */
struct svga_fragment_shader *fs;
struct svga_vertex_shader *vs;
@ -203,7 +203,7 @@ struct svga_state
struct pipe_viewport_state viewport;
unsigned num_samplers;
unsigned num_textures;
unsigned num_sampler_views;
unsigned num_vertex_elements;
unsigned num_vertex_buffers;
unsigned reduced_prim;

30
src/gallium/drivers/svga/svga_pipe_sampler.c
View file

@ -176,9 +176,9 @@ static void svga_delete_sampler_state(struct pipe_context *pipe,
}
static void svga_set_sampler_textures(struct pipe_context *pipe,
unsigned num,
struct pipe_texture **texture)
static void svga_set_sampler_views(struct pipe_context *pipe,
unsigned num,
struct pipe_sampler_view **views)
{
struct svga_context *svga = svga_context(pipe);
unsigned flag_1d = 0;
@ -188,31 +188,31 @@ static void svga_set_sampler_textures(struct pipe_context *pipe,
assert(num <= PIPE_MAX_SAMPLERS);
/* Check for no-op */
if (num == svga->curr.num_textures &&
!memcmp(svga->curr.texture, texture, num * sizeof(struct pipe_texture *))) {
if (num == svga->curr.num_sampler_views &&
!memcmp(svga->curr.sampler_views, views, num * sizeof(struct pipe_sampler_view *))) {
if (0) debug_printf("texture noop\n");
return;
}
for (i = 0; i < num; i++) {
pipe_texture_reference(&svga->curr.texture[i],
texture[i]);
pipe_sampler_view_reference(&svga->curr.sampler_views[i],
views[i]);
if (!texture[i])
if (!views[i])
continue;
if (texture[i]->format == PIPE_FORMAT_A8R8G8B8_SRGB)
if (views[i]->texture->format == PIPE_FORMAT_A8R8G8B8_SRGB)
flag_srgb |= 1 << i;
if (texture[i]->target == PIPE_TEXTURE_1D)
if (views[i]->texture->target == PIPE_TEXTURE_1D)
flag_1d |= 1 << i;
}
for (i = num; i < svga->curr.num_textures; i++)
pipe_texture_reference(&svga->curr.texture[i],
NULL);
for (i = num; i < svga->curr.num_sampler_views; i++)
pipe_sampler_view_reference(&svga->curr.sampler_views[i],
NULL);
svga->curr.num_textures = num;
svga->curr.num_sampler_views = num;
svga->dirty |= SVGA_NEW_TEXTURE_BINDING;
if (flag_srgb != svga->curr.tex_flags.flag_srgb ||
@ -231,7 +231,7 @@ void svga_init_sampler_functions( struct svga_context *svga )
svga->pipe.create_sampler_state = svga_create_sampler_state;
svga->pipe.bind_fragment_sampler_states = svga_bind_sampler_states;
svga->pipe.delete_sampler_state = svga_delete_sampler_state;
svga->pipe.set_fragment_sampler_textures = svga_set_sampler_textures;
svga->pipe.set_fragment_sampler_views = svga_set_sampler_views;
}

2
src/gallium/drivers/svga/svga_state_constants.c
View file

@ -137,7 +137,7 @@ static int emit_fs_consts( struct svga_context *svga,
for (i = 0; i < key->num_textures; i++) {
if (key->tex[i].unnormalized) {
struct pipe_texture *tex = svga->curr.texture[i];
struct pipe_texture *tex = svga->curr.sampler_views[i]->texture;
float data[4];
data[0] = 1.0 / (float)tex->width0;

9
src/gallium/drivers/svga/svga_state_fs.c
View file

@ -158,10 +158,11 @@ static int make_fs_key( const struct svga_context *svga,
*
* SVGA_NEW_TEXTURE_BINDING | SVGA_NEW_SAMPLER
*/
for (i = 0; i < svga->curr.num_textures; i++) {
if (svga->curr.texture[i]) {
for (i = 0; i < svga->curr.num_sampler_views; i++) {
if (svga->curr.sampler_views[i]) {
assert(svga->curr.sampler[i]);
key->tex[i].texture_target = svga->curr.texture[i]->target;
assert(svga->curr.sampler_views[i]->texture);
key->tex[i].texture_target = svga->curr.sampler_views[i]->texture->target;
if (!svga->curr.sampler[i]->normalized_coords) {
key->tex[i].width_height_idx = idx++;
key->tex[i].unnormalized = TRUE;
@ -169,7 +170,7 @@ static int make_fs_key( const struct svga_context *svga,
}
}
}
key->num_textures = svga->curr.num_textures;
key->num_textures = svga->curr.num_sampler_views;
idx = 0;
for (i = 0; i < svga->curr.num_samplers; ++i) {

22
src/gallium/drivers/svga/svga_state_tss.c
View file

@ -37,14 +37,14 @@
void svga_cleanup_tss_binding(struct svga_context *svga)
{
int i;
unsigned count = MAX2( svga->curr.num_textures,
unsigned count = MAX2( svga->curr.num_sampler_views,
svga->state.hw_draw.num_views );
for (i = 0; i < count; i++) {
struct svga_hw_view_state *view = &svga->state.hw_draw.views[i];
svga_sampler_view_reference(&view->v, NULL);
pipe_texture_reference( &svga->curr.texture[i], NULL );
pipe_sampler_view_reference( &svga->curr.sampler_views[i], NULL );
pipe_texture_reference( &view->texture, NULL );
view->dirty = 1;
@ -57,7 +57,7 @@ update_tss_binding(struct svga_context *svga,
unsigned dirty )
{
unsigned i;
unsigned count = MAX2( svga->curr.num_textures,
unsigned count = MAX2( svga->curr.num_sampler_views,
svga->state.hw_draw.num_views );
unsigned min_lod;
unsigned max_lod;
@ -77,30 +77,32 @@ update_tss_binding(struct svga_context *svga,
for (i = 0; i < count; i++) {
const struct svga_sampler_state *s = svga->curr.sampler[i];
struct svga_hw_view_state *view = &svga->state.hw_draw.views[i];
struct pipe_texture *texture = NULL;
/* get min max lod */
if (svga->curr.texture[i]) {
if (svga->curr.sampler_views[i]) {
min_lod = MAX2(s->view_min_lod, 0);
max_lod = MIN2(s->view_max_lod, svga->curr.texture[i]->last_level);
max_lod = MIN2(s->view_max_lod, svga->curr.sampler_views[i]->texture->last_level);
texture = svga->curr.sampler_views[i]->texture;
} else {
min_lod = 0;
max_lod = 0;
}
if (view->texture != svga->curr.texture[i] ||
if (view->texture != texture ||
view->min_lod != min_lod ||
view->max_lod != max_lod) {
svga_sampler_view_reference(&view->v, NULL);
pipe_texture_reference( &view->texture, svga->curr.texture[i] );
pipe_texture_reference( &view->texture, texture );
view->dirty = TRUE;
view->min_lod = min_lod;
view->max_lod = max_lod;
if (svga->curr.texture[i])
if (texture)
view->v = svga_get_tex_sampler_view(&svga->pipe,
svga->curr.texture[i],
texture,
min_lod,
max_lod);
}
@ -115,7 +117,7 @@ update_tss_binding(struct svga_context *svga,
}
}
svga->state.hw_draw.num_views = svga->curr.num_textures;
svga->state.hw_draw.num_views = svga->curr.num_sampler_views;
if (queue.bind_count) {
SVGA3dTextureState *ts;

76
src/gallium/drivers/trace/tr_context.c
View file

@ -112,7 +112,7 @@ trace_context_draw_block(struct trace_context *tr_ctx, int flag)
(void *) tr_ctx->draw_rule.fs, (void *) tr_ctx->curr.fs,
(void *) tr_ctx->draw_rule.vs, (void *) tr_ctx->curr.vs,
(void *) tr_ctx->draw_rule.surf, 0,
(void *) tr_ctx->draw_rule.tex, 0);
(void *) tr_ctx->draw_rule.sampler_view, 0);
if (tr_ctx->draw_rule.fs &&
tr_ctx->draw_rule.fs == tr_ctx->curr.fs)
block = TRUE;
@ -126,12 +126,12 @@ trace_context_draw_block(struct trace_context *tr_ctx, int flag)
for (k = 0; k < tr_ctx->curr.nr_cbufs; k++)
if (tr_ctx->draw_rule.surf == tr_ctx->curr.cbufs[k])
block = TRUE;
if (tr_ctx->draw_rule.tex) {
for (k = 0; k < tr_ctx->curr.num_texs; k++)
if (tr_ctx->draw_rule.tex == tr_ctx->curr.tex[k])
if (tr_ctx->draw_rule.sampler_view) {
for (k = 0; k < tr_ctx->curr.num_sampler_views; k++)
if (tr_ctx->draw_rule.sampler_view == tr_ctx->curr.sampler_views[k])
block = TRUE;
for (k = 0; k < tr_ctx->curr.num_vert_texs; k++) {
if (tr_ctx->draw_rule.tex == tr_ctx->curr.vert_tex[k]) {
for (k = 0; k < tr_ctx->curr.num_vert_sampler_views; k++) {
if (tr_ctx->draw_rule.sampler_view == tr_ctx->curr.vert_sampler_views[k]) {
block = TRUE;
}
}
@ -950,62 +950,62 @@ trace_context_set_viewport_state(struct pipe_context *_pipe,
static INLINE void
trace_context_set_fragment_sampler_textures(struct pipe_context *_pipe,
unsigned num_textures,
struct pipe_texture **textures)
trace_context_set_fragment_sampler_views(struct pipe_context *_pipe,
unsigned num,
struct pipe_sampler_view **views)
{
struct trace_context *tr_ctx = trace_context(_pipe);
struct trace_texture *tr_tex;
struct trace_sampler_view *tr_view;
struct pipe_context *pipe = tr_ctx->pipe;
struct pipe_texture *unwrapped_textures[PIPE_MAX_SAMPLERS];
struct pipe_sampler_view *unwrapped_views[PIPE_MAX_SAMPLERS];
unsigned i;
tr_ctx->curr.num_texs = num_textures;
for(i = 0; i < num_textures; ++i) {
tr_tex = trace_texture(textures[i]);
tr_ctx->curr.tex[i] = tr_tex;
unwrapped_textures[i] = tr_tex ? tr_tex->texture : NULL;
tr_ctx->curr.num_sampler_views = num;
for(i = 0; i < num; ++i) {
tr_view = trace_sampler_view(views[i]);
tr_ctx->curr.sampler_views[i] = tr_view;
unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
}
textures = unwrapped_textures;
views = unwrapped_views;
trace_dump_call_begin("pipe_context", "set_fragment_sampler_textures");
trace_dump_call_begin("pipe_context", "set_fragment_sampler_views");
trace_dump_arg(ptr, pipe);
trace_dump_arg(uint, num_textures);
trace_dump_arg_array(ptr, textures, num_textures);
trace_dump_arg(uint, num);
trace_dump_arg_array(ptr, views, num);
pipe->set_fragment_sampler_textures(pipe, num_textures, textures);
pipe->set_fragment_sampler_views(pipe, num, views);
trace_dump_call_end();
}
static INLINE void
trace_context_set_vertex_sampler_textures(struct pipe_context *_pipe,
unsigned num_textures,
struct pipe_texture **textures)
trace_context_set_vertex_sampler_views(struct pipe_context *_pipe,
unsigned num,
struct pipe_sampler_view **views)
{
struct trace_context *tr_ctx = trace_context(_pipe);
struct trace_texture *tr_tex;
struct trace_sampler_view *tr_view;
struct pipe_context *pipe = tr_ctx->pipe;
struct pipe_texture *unwrapped_textures[PIPE_MAX_VERTEX_SAMPLERS];
struct pipe_sampler_view *unwrapped_views[PIPE_MAX_VERTEX_SAMPLERS];
unsigned i;
tr_ctx->curr.num_vert_texs = num_textures;
for(i = 0; i < num_textures; ++i) {
tr_tex = trace_texture(textures[i]);
tr_ctx->curr.vert_tex[i] = tr_tex;
unwrapped_textures[i] = tr_tex ? tr_tex->texture : NULL;
tr_ctx->curr.num_vert_sampler_views = num;
for(i = 0; i < num; ++i) {
tr_view = trace_sampler_view(views[i]);
tr_ctx->curr.vert_sampler_views[i] = tr_view;
unwrapped_views[i] = tr_view ? tr_view->sampler_view : NULL;
}
textures = unwrapped_textures;
views = unwrapped_views;
trace_dump_call_begin("pipe_context", "set_vertex_sampler_textures");
trace_dump_call_begin("pipe_context", "set_vertex_sampler_views");
trace_dump_arg(ptr, pipe);
trace_dump_arg(uint, num_textures);
trace_dump_arg_array(ptr, textures, num_textures);
trace_dump_arg(uint, num);
trace_dump_arg_array(ptr, views, num);
pipe->set_vertex_sampler_textures(pipe, num_textures, textures);
pipe->set_vertex_sampler_views(pipe, num, views);
trace_dump_call_end();
}
@ -1311,8 +1311,8 @@ trace_context_create(struct trace_screen *tr_scr,
tr_ctx->base.set_polygon_stipple = trace_context_set_polygon_stipple;
tr_ctx->base.set_scissor_state = trace_context_set_scissor_state;
tr_ctx->base.set_viewport_state = trace_context_set_viewport_state;
tr_ctx->base.set_fragment_sampler_textures = trace_context_set_fragment_sampler_textures;
tr_ctx->base.set_vertex_sampler_textures = trace_context_set_vertex_sampler_textures;
tr_ctx->base.set_fragment_sampler_views = trace_context_set_fragment_sampler_views;
tr_ctx->base.set_vertex_sampler_views = trace_context_set_vertex_sampler_views;
tr_ctx->base.set_vertex_buffers = trace_context_set_vertex_buffers;
tr_ctx->base.set_vertex_elements = trace_context_set_vertex_elements;
if (pipe->surface_copy)

10
src/gallium/drivers/trace/tr_context.h
View file

@ -53,11 +53,11 @@ struct trace_context
struct trace_shader *fs;
struct trace_shader *vs;
struct trace_texture *tex[PIPE_MAX_SAMPLERS];
unsigned num_texs;
struct trace_sampler_view *sampler_views[PIPE_MAX_SAMPLERS];
unsigned num_sampler_views;
struct trace_texture *vert_tex[PIPE_MAX_VERTEX_SAMPLERS];
unsigned num_vert_texs;
struct trace_sampler_view *vert_sampler_views[PIPE_MAX_VERTEX_SAMPLERS];
unsigned num_vert_sampler_views;
unsigned nr_cbufs;
struct trace_texture *cbufs[PIPE_MAX_COLOR_BUFS];
@ -68,7 +68,7 @@ struct trace_context
struct trace_shader *fs;
struct trace_shader *vs;
struct trace_texture *tex;
struct trace_sampler_view *sampler_view;
struct trace_texture *surf;
int blocker;

8
src/gallium/drivers/trace/tr_rbug.c
View file

@ -313,12 +313,12 @@ trace_rbug_context_info(struct trace_rbug *tr_rbug, struct rbug_header *header,
for (i = 0; i < tr_ctx->curr.nr_cbufs; i++)
cbufs[i] = VOID2U64(tr_ctx->curr.cbufs[i]);
for (i = 0; i < tr_ctx->curr.num_texs; i++)
texs[i] = VOID2U64(tr_ctx->curr.tex[i]);
for (i = 0; i < tr_ctx->curr.num_sampler_views; i++)
texs[i] = VOID2U64(tr_ctx->curr.sampler_views[i]);
rbug_send_context_info_reply(tr_rbug->con, serial,
VOID2U64(tr_ctx->curr.vs), VOID2U64(tr_ctx->curr.fs),
texs, tr_ctx->curr.num_texs,
texs, tr_ctx->curr.num_sampler_views,
cbufs, tr_ctx->curr.nr_cbufs,
VOID2U64(tr_ctx->curr.zsbuf),
tr_ctx->draw_blocker, tr_ctx->draw_blocked, NULL);
@ -444,7 +444,7 @@ trace_rbug_context_draw_rule(struct trace_rbug *tr_rbug, struct rbug_header *hea
pipe_mutex_lock(tr_ctx->draw_mutex);
tr_ctx->draw_rule.vs = U642VOID(rule->vertex);
tr_ctx->draw_rule.fs = U642VOID(rule->fragment);
tr_ctx->draw_rule.tex = U642VOID(rule->texture);
tr_ctx->draw_rule.sampler_view = U642VOID(rule->texture);
tr_ctx->draw_rule.surf = U642VOID(rule->surface);
tr_ctx->draw_rule.blocker = rule->block;
tr_ctx->draw_blocker |= RBUG_BLOCK_RULE;

19
src/gallium/drivers/trace/tr_texture.h
View file

@ -55,6 +55,16 @@ struct trace_surface
};
struct trace_sampler_view
{
struct pipe_sampler_view base;
struct pipe_sampler_view *sampler_view;
struct tr_list list;
};
struct trace_transfer
{
struct pipe_transfer base;
@ -87,6 +97,15 @@ trace_surface(struct pipe_surface *surface)
}
static INLINE struct trace_sampler_view *
trace_sampler_view(struct pipe_sampler_view *sampler_view)
{
if (!sampler_view)
return NULL;
return (struct trace_sampler_view *)sampler_view;
}
static INLINE struct trace_transfer *
trace_transfer(struct pipe_transfer *transfer)
{

22
src/gallium/include/pipe/p_context.h
View file

@ -208,13 +208,13 @@ struct pipe_context {
void (*set_viewport_state)( struct pipe_context *,
const struct pipe_viewport_state * );
void (*set_fragment_sampler_textures)(struct pipe_context *,
unsigned num_textures,
struct pipe_texture **);
void (*set_fragment_sampler_views)(struct pipe_context *,
unsigned num_views,
struct pipe_sampler_view **);
void (*set_vertex_sampler_textures)(struct pipe_context *,
unsigned num_textures,
struct pipe_texture **);
void (*set_vertex_sampler_views)(struct pipe_context *,
unsigned num_views,
struct pipe_sampler_view **);
void (*set_vertex_buffers)( struct pipe_context *,
unsigned num_buffers,
@ -303,6 +303,16 @@ struct pipe_context {
*/
unsigned int (*is_buffer_referenced)(struct pipe_context *pipe,
struct pipe_buffer *buf);
/**
* Create a view on a texture to be used by a shader stage.
*/
struct pipe_sampler_view * (*create_sampler_view)(struct pipe_context *ctx,
struct pipe_texture *texture,
const struct pipe_sampler_view *templat);
void (*sampler_view_destroy)(struct pipe_context *ctx,
struct pipe_sampler_view *view);
};

11
src/gallium/include/pipe/p_defines.h
View file

@ -368,6 +368,17 @@ enum pipe_transfer_usage {
#define PIPE_SPRITE_COORD_LOWER_LEFT 1
/**
* Texture swizzles
*/
#define PIPE_SWIZZLE_RED 0
#define PIPE_SWIZZLE_GREEN 1
#define PIPE_SWIZZLE_BLUE 2
#define PIPE_SWIZZLE_ALPHA 3
#define PIPE_SWIZZLE_ZERO 4
#define PIPE_SWIZZLE_ONE 5
/**
* Implementation capabilities/limits which are queried through
* pipe_screen::get_param() and pipe_screen::get_paramf().

18
src/gallium/include/pipe/p_state.h
View file

@ -309,6 +309,24 @@ struct pipe_surface
};
/**
* A view into a texture that can be bound to a shader stage.
*/
struct pipe_sampler_view
{
struct pipe_reference reference;
enum pipe_format format; /**< typed PIPE_FORMAT_x */
struct pipe_texture *texture; /**< texture into which this is a view */
struct pipe_context *context; /**< context this view belongs to */
unsigned first_level:8; /**< first mipmap level */
unsigned num_levels:8; /**< number of mipamp levels */
unsigned swizzle_r:3; /**< PIPE_SWIZZLE_x for red component */
unsigned swizzle_g:3; /**< PIPE_SWIZZLE_x for green component */
unsigned swizzle_b:3; /**< PIPE_SWIZZLE_x for blue component */
unsigned swizzle_a:3; /**< PIPE_SWIZZLE_x for alpha component */
};
/**
* Transfer object. For data transfer to/from a texture.
*/

4
src/mesa/state_tracker/st_cb_drawpixels.c
View file

@ -586,10 +586,10 @@ draw_textured_quad(GLcontext *ctx, GLint x, GLint y, GLfloat z,
struct pipe_texture *textures[2];
textures[0] = pt;
textures[1] = st->pixel_xfer.pixelmap_texture;
pipe->set_fragment_sampler_textures(pipe, 2, textures);
cso_set_sampler_textures(cso, 2, textures);
}
else {
pipe->set_fragment_sampler_textures(pipe, 1, &pt);
cso_set_sampler_textures(cso, 1, &pt);
}
/* Compute window coords (y=0=bottom) with pixel zoom.