fdo-mirrors/mesa
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/mesa/mesa.git synced 2025-12-21 00:40:10 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

gallium: remove the geom_flags param from is_format_supported

Browse source
This commit is contained in:
Marek Olšák 2011-03-08 00:01:58 +01:00
parent bfe88e6998
commit e968975cb5
50 changed files with 208 additions and 283 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
src/gallium/auxiliary/util/u_blit.c
View file

@ -464,11 +464,11 @@ util_blit_pixels_writemask(struct blit_state *ctx,
assert(screen->is_format_supported(screen, sampler_view->format, ctx->internal_target,
sampler_view->texture->nr_samples,
PIPE_BIND_SAMPLER_VIEW, 0));
PIPE_BIND_SAMPLER_VIEW));
assert(screen->is_format_supported(screen, dst->format, ctx->internal_target,
dst->texture->nr_samples,
dst_is_depth ? PIPE_BIND_DEPTH_STENCIL :
PIPE_BIND_RENDER_TARGET, 0));
PIPE_BIND_RENDER_TARGET));
/* save state (restored below) */
cso_save_blend(ctx->cso);
cso_save_depth_stencil_alpha(ctx->cso);
@ -660,8 +660,7 @@ util_blit_pixels_tex(struct blit_state *ctx,
assert(ctx->pipe->screen->is_format_supported(ctx->pipe->screen, dst->format,
PIPE_TEXTURE_2D,
dst->texture->nr_samples,
PIPE_BIND_RENDER_TARGET,
0));
PIPE_BIND_RENDER_TARGET));
/* save state (restored below) */
cso_save_blend(ctx->cso);

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

@ -772,9 +772,9 @@ void util_blitter_copy_region(struct blitter_context *blitter,
/* (assuming copying a stencil buffer is not possible) */
if ((!ignore_stencil && is_stencil) ||
!screen->is_format_supported(screen, dst->format, dst->target,
dst->nr_samples, bind, 0) ||
dst->nr_samples, bind) ||
!screen->is_format_supported(screen, src->format, src->target,
src->nr_samples, PIPE_BIND_SAMPLER_VIEW, 0)) {
src->nr_samples, PIPE_BIND_SAMPLER_VIEW)) {
ctx->base.running = TRUE;
util_resource_copy_region(pipe, dst, dstlevel, dstx, dsty, dstz,
src, srclevel, srcbox);

3
src/gallium/auxiliary/util/u_caps.c
View file

@ -69,8 +69,7 @@ util_check_caps_out(struct pipe_screen *screen, const unsigned *list, int *out)
list[i++],
PIPE_TEXTURE_2D,
0,
PIPE_BIND_SAMPLER_VIEW,
0)) {
PIPE_BIND_SAMPLER_VIEW)) {
*out = i - 2;
return FALSE;
}

2
src/gallium/auxiliary/util/u_gen_mipmap.c
View file

@ -1539,7 +1539,7 @@ util_gen_mipmap(struct gen_mipmap_state *ctx,
/* check if we can render in the texture's format */
if (!screen->is_format_supported(screen, psv->format, pt->target,
pt->nr_samples, PIPE_BIND_RENDER_TARGET, 0)) {
pt->nr_samples, PIPE_BIND_RENDER_TARGET)) {
fallback_gen_mipmap(ctx, pt, face, baseLevel, lastLevel);
return;
}

2
src/gallium/auxiliary/util/u_surface.c
View file

@ -84,7 +84,7 @@ util_create_rgba_surface(struct pipe_context *pipe,
/* Choose surface format */
for (i = 0; rgbaFormats[i]; i++) {
if (screen->is_format_supported(screen, rgbaFormats[i],
target, 0, bind, 0)) {
target, 0, bind)) {
format = rgbaFormats[i];
break;
}

14
src/gallium/auxiliary/util/u_vbuf_mgr.c
View file

@ -87,27 +87,27 @@ static void u_vbuf_mgr_init_format_caps(struct u_vbuf_mgr_priv *mgr)
mgr->caps.format_fixed32 =
screen->is_format_supported(screen, PIPE_FORMAT_R32_FIXED, PIPE_BUFFER,
0, PIPE_BIND_VERTEX_BUFFER, 0);
0, PIPE_BIND_VERTEX_BUFFER);
mgr->caps.format_float16 =
screen->is_format_supported(screen, PIPE_FORMAT_R16_FLOAT, PIPE_BUFFER,
0, PIPE_BIND_VERTEX_BUFFER, 0);
0, PIPE_BIND_VERTEX_BUFFER);
mgr->caps.format_float64 =
screen->is_format_supported(screen, PIPE_FORMAT_R64_FLOAT, PIPE_BUFFER,
0, PIPE_BIND_VERTEX_BUFFER, 0);
0, PIPE_BIND_VERTEX_BUFFER);
mgr->caps.format_norm32 =
screen->is_format_supported(screen, PIPE_FORMAT_R32_UNORM, PIPE_BUFFER,
0, PIPE_BIND_VERTEX_BUFFER, 0) &&
0, PIPE_BIND_VERTEX_BUFFER) &&
screen->is_format_supported(screen, PIPE_FORMAT_R32_SNORM, PIPE_BUFFER,
0, PIPE_BIND_VERTEX_BUFFER, 0);
0, PIPE_BIND_VERTEX_BUFFER);
mgr->caps.format_scaled32 =
screen->is_format_supported(screen, PIPE_FORMAT_R32_USCALED, PIPE_BUFFER,
0, PIPE_BIND_VERTEX_BUFFER, 0) &&
0, PIPE_BIND_VERTEX_BUFFER) &&
screen->is_format_supported(screen, PIPE_FORMAT_R32_SSCALED, PIPE_BUFFER,
0, PIPE_BIND_VERTEX_BUFFER, 0);
0, PIPE_BIND_VERTEX_BUFFER);
}
struct u_vbuf_mgr *

3
src/gallium/drivers/cell/ppu/cell_screen.c
View file

@ -149,8 +149,7 @@ cell_is_format_supported( struct pipe_screen *screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned tex_usage,
unsigned geom_flags )
unsigned tex_usage)
{
struct sw_winsys *winsys = cell_screen(screen)->winsys;

6
src/gallium/drivers/galahad/glhd_screen.c
View file

@ -106,8 +106,7 @@ galahad_screen_is_format_supported(struct pipe_screen *_screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned tex_usage,
unsigned geom_flags)
unsigned tex_usage)
{
struct galahad_screen *glhd_screen = galahad_screen(_screen);
struct pipe_screen *screen = glhd_screen->screen;
@ -120,8 +119,7 @@ galahad_screen_is_format_supported(struct pipe_screen *_screen,
format,
target,
sample_count,
tex_usage,
geom_flags);
tex_usage);
}
static struct pipe_context *

3
src/gallium/drivers/i915/i915_screen.c
View file

@ -250,8 +250,7 @@ i915_is_format_supported(struct pipe_screen *screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned tex_usage,
unsigned geom_flags)
unsigned tex_usage)
{
static const enum pipe_format tex_supported[] = {
PIPE_FORMAT_B8G8R8A8_UNORM,

3
src/gallium/drivers/i965/brw_screen.c
View file

@ -278,8 +278,7 @@ brw_is_format_supported(struct pipe_screen *screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned tex_usage,
unsigned geom_flags)
unsigned tex_usage)
{
static const enum pipe_format tex_supported[] = {
PIPE_FORMAT_L8_UNORM,

6
src/gallium/drivers/identity/id_screen.c
View file

@ -103,8 +103,7 @@ identity_screen_is_format_supported(struct pipe_screen *_screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned tex_usage,
unsigned geom_flags)
unsigned tex_usage)
{
struct identity_screen *id_screen = identity_screen(_screen);
struct pipe_screen *screen = id_screen->screen;
@ -113,8 +112,7 @@ identity_screen_is_format_supported(struct pipe_screen *_screen,
format,
target,
sample_count,
tex_usage,
geom_flags);
tex_usage);
}
static struct pipe_context *

3
src/gallium/drivers/llvmpipe/lp_screen.c
View file

@ -225,8 +225,7 @@ llvmpipe_is_format_supported( struct pipe_screen *_screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned bind,
unsigned geom_flags )
unsigned bind)
{
struct llvmpipe_screen *screen = llvmpipe_screen(_screen);
struct sw_winsys *winsys = screen->winsys;

3
src/gallium/drivers/noop/noop_pipe.c
View file

@ -445,8 +445,7 @@ static boolean noop_is_format_supported(struct pipe_screen* screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned usage,
unsigned geom_flags)
unsigned usage)
{
return true;
}

2
src/gallium/drivers/nv50/nv50_screen.c
View file

@ -40,7 +40,7 @@ nv50_screen_is_format_supported(struct pipe_screen *pscreen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned bindings, unsigned geom_flags)
unsigned bindings)
{
if (sample_count > 1)
return FALSE;

2
src/gallium/drivers/nvc0/nvc0_screen.c
View file

@ -34,7 +34,7 @@ nvc0_screen_is_format_supported(struct pipe_screen *pscreen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned bindings, unsigned geom_flags)
unsigned bindings)
{
if (sample_count > 1)
return FALSE;

6
src/gallium/drivers/nvfx/nvfx_miptree.c
View file

@ -138,11 +138,11 @@ nvfx_miptree_create_skeleton(struct pipe_screen *pscreen, const struct pipe_reso
// on our current driver (and the driver too), format support does not depend on geometry, so don't bother computing it
// TODO: may want to revisit this
if(!pscreen->is_format_supported(pscreen, pt->format, pt->target, 0, PIPE_BIND_RENDER_TARGET, 0))
if(!pscreen->is_format_supported(pscreen, pt->format, pt->target, 0, PIPE_BIND_RENDER_TARGET))
mt->base.base.bind &=~ PIPE_BIND_RENDER_TARGET;
if(!pscreen->is_format_supported(pscreen, pt->format, pt->target, 0, PIPE_BIND_SAMPLER_VIEW, 0))
if(!pscreen->is_format_supported(pscreen, pt->format, pt->target, 0, PIPE_BIND_SAMPLER_VIEW))
mt->base.base.bind &=~ PIPE_BIND_SAMPLER_VIEW;
if(!pscreen->is_format_supported(pscreen, pt->format, pt->target, 0, PIPE_BIND_DEPTH_STENCIL, 0))
if(!pscreen->is_format_supported(pscreen, pt->format, pt->target, 0, PIPE_BIND_DEPTH_STENCIL))
mt->base.base.bind &=~ PIPE_BIND_DEPTH_STENCIL;
return mt;

2
src/gallium/drivers/nvfx/nvfx_screen.c
View file

@ -202,7 +202,7 @@ nvfx_screen_is_format_supported(struct pipe_screen *pscreen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned bind, unsigned geom_flags)
unsigned bind)
{
struct nvfx_screen *screen = nvfx_screen(pscreen);

4
src/gallium/drivers/r300/r300_blit.c
View file

@ -447,11 +447,11 @@ static void r300_resource_copy_region(struct pipe_context *pipe,
!pipe->screen->is_format_supported(pipe->screen,
src->format, src->target,
src->nr_samples,
PIPE_BIND_SAMPLER_VIEW, 0) ||
PIPE_BIND_SAMPLER_VIEW) ||
!pipe->screen->is_format_supported(pipe->screen,
dst->format, dst->target,
dst->nr_samples,
PIPE_BIND_RENDER_TARGET, 0))) {
PIPE_BIND_RENDER_TARGET))) {
switch (util_format_get_blocksize(old_dst.format)) {
case 1:
new_dst.format = PIPE_FORMAT_I8_UNORM;

3
src/gallium/drivers/r300/r300_screen.c
View file

@ -306,8 +306,7 @@ static boolean r300_is_format_supported(struct pipe_screen* screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned usage,
unsigned geom_flags)
unsigned usage)
{
struct r300_winsys_screen *rws = r300_screen(screen)->rws;
uint32_t retval = 0;

3
src/gallium/drivers/r600/r600_pipe.c
View file

@ -417,8 +417,7 @@ static boolean r600_is_format_supported(struct pipe_screen* screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned usage,
unsigned geom_flags)
unsigned usage)
{
unsigned retval = 0;
if (target >= PIPE_MAX_TEXTURE_TYPES) {

4
src/gallium/drivers/r600/r600_texture.c
View file

@ -299,14 +299,14 @@ static boolean permit_hardware_blit(struct pipe_screen *screen,
res->format,
res->target,
res->nr_samples,
bind, 0))
bind))
return FALSE;
if (!screen->is_format_supported(screen,
res->format,
res->target,
res->nr_samples,
PIPE_BIND_SAMPLER_VIEW, 0))
PIPE_BIND_SAMPLER_VIEW))
return FALSE;
return TRUE;

6
src/gallium/drivers/rbug/rbug_screen.c
View file

@ -106,8 +106,7 @@ rbug_screen_is_format_supported(struct pipe_screen *_screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned tex_usage,
unsigned geom_flags)
unsigned tex_usage)
{
struct rbug_screen *rb_screen = rbug_screen(_screen);
struct pipe_screen *screen = rb_screen->screen;
@ -116,8 +115,7 @@ rbug_screen_is_format_supported(struct pipe_screen *_screen,
format,
target,
sample_count,
tex_usage,
geom_flags);
tex_usage);
}
static struct pipe_context *

3
src/gallium/drivers/softpipe/sp_screen.c
View file

@ -180,8 +180,7 @@ softpipe_is_format_supported( struct pipe_screen *screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned bind,
unsigned geom_flags )
unsigned bind)
{
struct sw_winsys *winsys = softpipe_screen(screen)->winsys;
const struct util_format_description *format_desc;

3
src/gallium/drivers/svga/svga_screen.c
View file

@ -342,8 +342,7 @@ svga_is_format_supported( struct pipe_screen *screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned tex_usage,
unsigned geom_flags )
unsigned tex_usage)
{
struct svga_winsys_screen *sws = svga_screen(screen)->sws;
SVGA3dDevCapIndex index;

6
src/gallium/drivers/trace/tr_screen.c
View file

@ -158,8 +158,7 @@ trace_screen_is_format_supported(struct pipe_screen *_screen,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned tex_usage,
unsigned geom_flags)
unsigned tex_usage)
{
struct trace_screen *tr_scr = trace_screen(_screen);
struct pipe_screen *screen = tr_scr->screen;
@ -172,10 +171,9 @@ trace_screen_is_format_supported(struct pipe_screen *_screen,
trace_dump_arg(int, target);
trace_dump_arg(uint, sample_count);
trace_dump_arg(uint, tex_usage);
trace_dump_arg(uint, geom_flags);
result = screen->is_format_supported(screen, format, target, sample_count,
tex_usage, geom_flags);
tex_usage);
trace_dump_ret(bool, result);

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

@ -337,16 +337,6 @@ enum pipe_transfer_usage {
#define PIPE_USAGE_STAGING 5 /* supports data transfers from the GPU to the CPU */
/* These are intended to be used in calls to is_format_supported, but
* no driver actually uses these flags, and only the glx/xlib state
* tracker issues them.
*
* Deprecate?
*/
#define PIPE_TEXTURE_GEOM_NON_SQUARE 0x1
#define PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO 0x2
/**
* Flush types:
*/

4
src/gallium/include/pipe/p_screen.h
View file

@ -99,14 +99,12 @@ struct pipe_screen {
* Check if the given pipe_format is supported as a texture or
* drawing surface.
* \param bindings bitmask of PIPE_BIND_*
* \param geom_flags bitmask of PIPE_TEXTURE_GEOM_*
*/
boolean (*is_format_supported)( struct pipe_screen *,
enum pipe_format format,
enum pipe_texture_target target,
unsigned sample_count,
unsigned bindings,
unsigned geom_flags );
unsigned bindings );
/**
* Create a new texture object, using the given template info.

20
src/gallium/state_trackers/d3d1x/gd3d11/d3d11_screen.h
View file

@ -299,25 +299,25 @@ struct GalliumD3D11ScreenImpl : public GalliumD3D11Screen
sampler_view |= D3D11_FORMAT_SUPPORT_SHADER_SAMPLE_COMPARISON;
/* TODO: do this properly when Gallium drivers actually support index/vertex format queries */
if(screen->is_format_supported(screen, format, PIPE_BUFFER, 0, PIPE_BIND_VERTEX_BUFFER, 0)
|| (screen->is_format_supported(screen, format, PIPE_BUFFER, 0, PIPE_BIND_INDEX_BUFFER, 0)
if(screen->is_format_supported(screen, format, PIPE_BUFFER, 0, PIPE_BIND_VERTEX_BUFFER)
|| (screen->is_format_supported(screen, format, PIPE_BUFFER, 0, PIPE_BIND_INDEX_BUFFER)
|| format == PIPE_FORMAT_R8_UNORM))
support |= buffer;
if(screen->is_format_supported(screen, format, PIPE_BUFFER, 0, PIPE_BIND_STREAM_OUTPUT, 0))
if(screen->is_format_supported(screen, format, PIPE_BUFFER, 0, PIPE_BIND_STREAM_OUTPUT))
support |= buffer | D3D11_FORMAT_SUPPORT_SO_BUFFER;
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_1D, 0, PIPE_BIND_SAMPLER_VIEW, 0))
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_1D, 0, PIPE_BIND_SAMPLER_VIEW))
support |= D3D11_FORMAT_SUPPORT_TEXTURE1D | sampler_view;
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW, 0))
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_SAMPLER_VIEW))
support |= D3D11_FORMAT_SUPPORT_TEXTURE2D | sampler_view;
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_CUBE, 0, PIPE_BIND_SAMPLER_VIEW, 0))
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_CUBE, 0, PIPE_BIND_SAMPLER_VIEW))
support |= D3D11_FORMAT_SUPPORT_TEXTURE2D | sampler_view;
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_3D, 0, PIPE_BIND_SAMPLER_VIEW, 0))
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_3D, 0, PIPE_BIND_SAMPLER_VIEW))
support |= D3D11_FORMAT_SUPPORT_TEXTURE3D | sampler_view;
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET, 0))
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET))
support |= D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_RENDER_TARGET | D3D11_FORMAT_SUPPORT_BLENDABLE;
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL, 0))
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL))
support |= D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_DEPTH_STENCIL;
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_DISPLAY_TARGET, 0))
if(screen->is_format_supported(screen, format, PIPE_TEXTURE_2D, 0, PIPE_BIND_DISPLAY_TARGET))
support |= D3D11_FORMAT_SUPPORT_DISPLAY;
format_support[format] = support;
}

24
src/gallium/state_trackers/dri/common/dri_screen.c
View file

@ -81,34 +81,34 @@ dri_fill_in_modes(struct dri_screen *screen,
pf_x8z24 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z24X8_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_DEPTH_STENCIL, 0);
PIPE_BIND_DEPTH_STENCIL);
pf_z24x8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_X8Z24_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_DEPTH_STENCIL, 0);
PIPE_BIND_DEPTH_STENCIL);
pf_s8z24 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_DEPTH_STENCIL, 0);
PIPE_BIND_DEPTH_STENCIL);
pf_z24s8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_DEPTH_STENCIL, 0);
PIPE_BIND_DEPTH_STENCIL);
pf_a8r8g8b8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8A8_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_RENDER_TARGET, 0);
PIPE_BIND_RENDER_TARGET);
pf_x8r8g8b8 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8X8_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_RENDER_TARGET, 0);
PIPE_BIND_RENDER_TARGET);
pf_r5g6b5 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_B5G6R5_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_RENDER_TARGET, 0);
PIPE_BIND_RENDER_TARGET);
/* We can only get a 16 or 32 bit depth buffer with getBuffersWithFormat */
if (dri_with_format(screen->sPriv)) {
pf_z16 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z16_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_DEPTH_STENCIL, 0);
PIPE_BIND_DEPTH_STENCIL);
pf_z32 = p_screen->is_format_supported(p_screen, PIPE_FORMAT_Z32_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_DEPTH_STENCIL, 0);
PIPE_BIND_DEPTH_STENCIL);
} else {
pf_z16 = FALSE;
pf_z32 = FALSE;
@ -142,7 +142,7 @@ dri_fill_in_modes(struct dri_screen *screen,
for (i = 1; i < 5; i++) {
if (p_screen->is_format_supported(p_screen, PIPE_FORMAT_B5G6R5_UNORM,
PIPE_TEXTURE_2D, i*2,
PIPE_BIND_RENDER_TARGET, 0)) {
PIPE_BIND_RENDER_TARGET)) {
msaa_samples_array[msaa_samples_factor] = i * 2;
msaa_samples_factor++;
}
@ -161,7 +161,7 @@ dri_fill_in_modes(struct dri_screen *screen,
for (i = 1; i < 5; i++) {
if (p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8A8_UNORM,
PIPE_TEXTURE_2D, i*2,
PIPE_BIND_RENDER_TARGET, 0)) {
PIPE_BIND_RENDER_TARGET)) {
msaa_samples_array[msaa_samples_factor] = i * 2;
msaa_samples_factor++;
}
@ -183,7 +183,7 @@ dri_fill_in_modes(struct dri_screen *screen,
for (i = 1; i < 5; i++) {
if (p_screen->is_format_supported(p_screen, PIPE_FORMAT_B8G8R8X8_UNORM,
PIPE_TEXTURE_2D, i*2,
PIPE_BIND_RENDER_TARGET, 0)) {
PIPE_BIND_RENDER_TARGET)) {
msaa_samples_array[msaa_samples_factor] = i * 2;
msaa_samples_factor++;
}

2
src/gallium/state_trackers/egl/common/egl_g3d.c
View file

@ -368,7 +368,7 @@ egl_g3d_fill_depth_stencil_formats(_EGLDisplay *dpy,
/* pick the first supported format */
for (i = 0; i < n; i++) {
if (screen->is_format_supported(screen, fmt[i],
PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL, 0)) {
PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL)) {
formats[count++] = fmt[i];
break;
}

2
src/gallium/state_trackers/egl/drm/native_drm.c
View file

@ -43,7 +43,7 @@ drm_display_is_format_supported(struct native_display *ndpy,
return ndpy->screen->is_format_supported(ndpy->screen,
fmt, PIPE_TEXTURE_2D, 0,
(is_color) ? PIPE_BIND_RENDER_TARGET :
PIPE_BIND_DEPTH_STENCIL, 0);
PIPE_BIND_DEPTH_STENCIL);
}
static const struct native_config **

2
src/gallium/state_trackers/egl/fbdev/native_fbdev.c
View file

@ -422,7 +422,7 @@ fbdev_display_init(struct native_display *ndpy)
if (fbdpy->base.screen) {
if (!fbdpy->base.screen->is_format_supported(fbdpy->base.screen,
fbdpy->config.color_format, PIPE_TEXTURE_2D, 0,
PIPE_BIND_RENDER_TARGET, 0)) {
PIPE_BIND_RENDER_TARGET)) {
fbdpy->base.screen->destroy(fbdpy->base.screen);
fbdpy->base.screen = NULL;
}

2
src/gallium/state_trackers/egl/gdi/native_gdi.c
View file

@ -285,7 +285,7 @@ fill_color_formats(struct native_display *ndpy, enum pipe_format formats[8])
for (i = 0; i < Elements(candidates); i++) {
if (screen->is_format_supported(screen, candidates[i],
PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET, 0))
PIPE_TEXTURE_2D, 0, PIPE_BIND_RENDER_TARGET))
formats[count++] = candidates[i];
}

2
src/gallium/state_trackers/egl/x11/native_dri2.c
View file

@ -541,7 +541,7 @@ is_format_supported(struct pipe_screen *screen,
{
return screen->is_format_supported(screen, fmt, PIPE_TEXTURE_2D, sample_count,
(is_color) ? PIPE_BIND_RENDER_TARGET :
PIPE_BIND_DEPTH_STENCIL, 0);
PIPE_BIND_DEPTH_STENCIL);
}
static boolean

4
src/gallium/state_trackers/glx/xlib/xm_api.c
View file

@ -376,8 +376,6 @@ choose_depth_stencil_format(XMesaDisplay xmdpy, int depth, int stencil)
{
const enum pipe_texture_target target = PIPE_TEXTURE_2D;
const unsigned tex_usage = PIPE_BIND_DEPTH_STENCIL;
const unsigned geom_flags = (PIPE_TEXTURE_GEOM_NON_SQUARE |
PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO);
const unsigned sample_count = 0;
enum pipe_format formats[8], fmt;
int count, i;
@ -403,7 +401,7 @@ choose_depth_stencil_format(XMesaDisplay xmdpy, int depth, int stencil)
for (i = 0; i < count; i++) {
if (xmdpy->screen->is_format_supported(xmdpy->screen, formats[i],
target, sample_count,
tex_usage, geom_flags)) {
tex_usage)) {
fmt = formats[i];
break;
}

2
src/gallium/state_trackers/vega/image.c
View file

@ -257,7 +257,7 @@ struct vg_image * image_create(VGImageFormat format,
image->sampler.normalized_coords = 1;
assert(screen->is_format_supported(screen, pformat, PIPE_TEXTURE_2D,
0, PIPE_BIND_SAMPLER_VIEW, 0));
0, PIPE_BIND_SAMPLER_VIEW));
memset(&pt, 0, sizeof(pt));
pt.target = PIPE_TEXTURE_2D;

8
src/gallium/state_trackers/vega/renderer.c
View file

@ -140,7 +140,7 @@ static VGboolean renderer_can_support(struct renderer *renderer,
struct pipe_screen *screen = renderer->pipe->screen;
return screen->is_format_supported(screen,
res->format, res->target, 0, bindings, 0);
res->format, res->target, 0, bindings);
}
/**
@ -1463,11 +1463,11 @@ void renderer_copy_surface(struct renderer *ctx,
}
assert(screen->is_format_supported(screen, src->format, PIPE_TEXTURE_2D,
0, PIPE_BIND_SAMPLER_VIEW, 0));
0, PIPE_BIND_SAMPLER_VIEW));
assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D,
0, PIPE_BIND_SAMPLER_VIEW, 0));
0, PIPE_BIND_SAMPLER_VIEW));
assert(screen->is_format_supported(screen, dst->format, PIPE_TEXTURE_2D,
0, PIPE_BIND_RENDER_TARGET, 0));
0, PIPE_BIND_RENDER_TARGET));
/*
* XXX for now we're always creating a temporary texture.

2
src/gallium/state_trackers/vega/vg_context.c
View file

@ -69,7 +69,7 @@ choose_depth_stencil_format(struct vg_context *ctx)
for (fmt = formats; *fmt != PIPE_FORMAT_NONE; fmt++) {
if (screen->is_format_supported(screen, *fmt,
PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL, 0))
PIPE_TEXTURE_2D, 0, PIPE_BIND_DEPTH_STENCIL))
break;
}

4
src/gallium/state_trackers/wgl/stw_pixelformat.c
View file

@ -225,7 +225,7 @@ stw_pixelformat_init( void )
if(!screen->is_format_supported(screen, color->format, PIPE_TEXTURE_2D,
0, PIPE_BIND_RENDER_TARGET |
PIPE_BIND_DISPLAY_TARGET, 0))
PIPE_BIND_DISPLAY_TARGET))
continue;
for(k = 0; k < Elements(stw_pf_doublebuffer); ++k) {
@ -235,7 +235,7 @@ stw_pixelformat_init( void )
const struct stw_pf_depth_info *depth = &stw_pf_depth_stencil[l];
if(!screen->is_format_supported(screen, depth->format, PIPE_TEXTURE_2D,
0, PIPE_BIND_DEPTH_STENCIL, 0))
0, PIPE_BIND_DEPTH_STENCIL))
continue;
stw_pixelformat_add( stw_dev, color, depth, 0, doublebuffer, samples );

4
src/gallium/state_trackers/xorg/xorg_dri2.c
View file

@ -452,12 +452,12 @@ xorg_dri2_init(ScreenPtr pScreen)
ms->screen->is_format_supported(ms->screen, PIPE_FORMAT_Z24X8_UNORM,
PIPE_TEXTURE_2D,
0,
PIPE_BIND_DEPTH_STENCIL, 0);
PIPE_BIND_DEPTH_STENCIL);
ms->ds_depth_bits_last =
ms->screen->is_format_supported(ms->screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
PIPE_TEXTURE_2D,
0,
PIPE_BIND_DEPTH_STENCIL, 0);
PIPE_BIND_DEPTH_STENCIL);
return DRI2ScreenInit(pScreen, &dri2info);
}

12
src/gallium/state_trackers/xorg/xorg_exa.c
View file

@ -349,7 +349,7 @@ ExaPrepareSolid(PixmapPtr pPixmap, int alu, Pixel planeMask, Pixel fg)
if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
priv->tex->target, 0,
PIPE_BIND_RENDER_TARGET, 0)) {
PIPE_BIND_RENDER_TARGET)) {
XORG_FALLBACK("format %s", util_format_name(priv->tex->format));
}
@ -430,12 +430,12 @@ ExaPrepareCopy(PixmapPtr pSrcPixmap, PixmapPtr pDstPixmap, int xdir,
if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
priv->tex->target, 0,
PIPE_BIND_RENDER_TARGET, 0))
PIPE_BIND_RENDER_TARGET))
XORG_FALLBACK("pDst format %s", util_format_name(priv->tex->format));
if (!exa->scrn->is_format_supported(exa->scrn, src_priv->tex->format,
src_priv->tex->target, 0,
PIPE_BIND_SAMPLER_VIEW, 0))
PIPE_BIND_SAMPLER_VIEW))
XORG_FALLBACK("pSrc format %s", util_format_name(src_priv->tex->format));
exa->copy.src = src_priv;
@ -630,7 +630,7 @@ ExaPrepareComposite(int op, PicturePtr pSrcPicture,
if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
priv->tex->target, 0,
PIPE_BIND_RENDER_TARGET, 0))
PIPE_BIND_RENDER_TARGET))
XORG_FALLBACK("pDst format: %s", util_format_name(priv->tex->format));
if (priv->picture_format != pDstPicture->format)
@ -645,7 +645,7 @@ ExaPrepareComposite(int op, PicturePtr pSrcPicture,
if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
priv->tex->target, 0,
PIPE_BIND_SAMPLER_VIEW, 0))
PIPE_BIND_SAMPLER_VIEW))
XORG_FALLBACK("pSrc format: %s", util_format_name(priv->tex->format));
if (!picture_check_formats(priv, pSrcPicture))
@ -662,7 +662,7 @@ ExaPrepareComposite(int op, PicturePtr pSrcPicture,
if (!exa->scrn->is_format_supported(exa->scrn, priv->tex->format,
priv->tex->target, 0,
PIPE_BIND_SAMPLER_VIEW, 0))
PIPE_BIND_SAMPLER_VIEW))
XORG_FALLBACK("pMask format: %s", util_format_name(priv->tex->format));
if (!picture_check_formats(priv, pMaskPicture))

5
src/gallium/state_trackers/xorg/xorg_renderer.c
View file

@ -450,8 +450,7 @@ void renderer_copy_prepare(struct xorg_renderer *r,
assert(screen->is_format_supported(screen, dst_surface->format,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_RENDER_TARGET,
0));
PIPE_BIND_RENDER_TARGET));
(void) screen;
@ -522,7 +521,7 @@ renderer_clone_texture(struct xorg_renderer *r,
/* the coming in texture should already have that invariance */
debug_assert(screen->is_format_supported(screen, src->format,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0));
PIPE_BIND_SAMPLER_VIEW));
format = src->format;

6
src/mesa/state_tracker/st_cb_bitmap.c
View file

@ -838,17 +838,17 @@ st_init_bitmap(struct st_context *st)
/* find a usable texture format */
if (screen->is_format_supported(screen, PIPE_FORMAT_I8_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0)) {
PIPE_BIND_SAMPLER_VIEW)) {
st->bitmap.tex_format = PIPE_FORMAT_I8_UNORM;
}
else if (screen->is_format_supported(screen, PIPE_FORMAT_A8_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0)) {
PIPE_BIND_SAMPLER_VIEW)) {
st->bitmap.tex_format = PIPE_FORMAT_A8_UNORM;
}
else if (screen->is_format_supported(screen, PIPE_FORMAT_L8_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0)) {
PIPE_BIND_SAMPLER_VIEW)) {
st->bitmap.tex_format = PIPE_FORMAT_L8_UNORM;
}
else {

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

@ -1332,7 +1332,7 @@ st_CopyPixels(struct gl_context *ctx, GLint srcx, GLint srcy,
if (screen->is_format_supported(screen, srcFormat, st->internal_target,
sample_count,
PIPE_BIND_SAMPLER_VIEW, 0)) {
PIPE_BIND_SAMPLER_VIEW)) {
texFormat = srcFormat;
}
else {

2
src/mesa/state_tracker/st_cb_fbo.c
View file

@ -485,7 +485,7 @@ st_validate_attachment(struct gl_context *ctx,
return screen->is_format_supported(screen, format,
PIPE_TEXTURE_2D,
stObj->pt->nr_samples, bindings, 0);
stObj->pt->nr_samples, bindings);
}

11
src/mesa/state_tracker/st_cb_texture.c
View file

@ -217,7 +217,6 @@ default_bindings(struct st_context *st, enum pipe_format format)
{
struct pipe_screen *screen = st->pipe->screen;
const unsigned target = PIPE_TEXTURE_2D;
const unsigned geom = 0x0;
unsigned bindings;
if (util_format_is_depth_or_stencil(format))
@ -225,13 +224,13 @@ default_bindings(struct st_context *st, enum pipe_format format)
else
bindings = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
if (screen->is_format_supported(screen, format, target, 0, bindings, geom))
if (screen->is_format_supported(screen, format, target, 0, bindings))
return bindings;
else {
/* Try non-sRGB. */
format = util_format_linear(format);
if (screen->is_format_supported(screen, format, target, 0, bindings, geom))
if (screen->is_format_supported(screen, format, target, 0, bindings))
return bindings;
else
return PIPE_BIND_SAMPLER_VIEW;
@ -1523,12 +1522,10 @@ st_copy_texsubimage(struct gl_context *ctx,
texBaseFormat != GL_DEPTH_STENCIL &&
screen->is_format_supported(screen, src_format,
PIPE_TEXTURE_2D, sample_count,
PIPE_BIND_SAMPLER_VIEW,
0) &&
PIPE_BIND_SAMPLER_VIEW) &&
screen->is_format_supported(screen, dest_format,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_RENDER_TARGET,
0)) {
PIPE_BIND_RENDER_TARGET)) {
/* draw textured quad to do the copy */
GLint srcY0, srcY1;
struct pipe_surface surf_tmpl;

44
src/mesa/state_tracker/st_extensions.c
View file

@ -366,36 +366,36 @@ void st_init_extensions(struct st_context *st)
*/
if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_DEPTH_STENCIL, 0) &&
PIPE_BIND_DEPTH_STENCIL) &&
screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0)) {
PIPE_BIND_SAMPLER_VIEW)) {
ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
}
else if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_DEPTH_STENCIL, 0) &&
PIPE_BIND_DEPTH_STENCIL) &&
screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0)) {
PIPE_BIND_SAMPLER_VIEW)) {
ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
}
/* sRGB support */
if (screen->is_format_supported(screen, PIPE_FORMAT_A8B8G8R8_SRGB,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0) ||
PIPE_BIND_SAMPLER_VIEW) ||
screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0)) {
PIPE_BIND_SAMPLER_VIEW)) {
ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
ctx->Extensions.EXT_texture_sRGB_decode = GL_TRUE;
if (screen->is_format_supported(screen, PIPE_FORMAT_A8B8G8R8_SRGB,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_RENDER_TARGET, 0) ||
PIPE_BIND_RENDER_TARGET) ||
screen->is_format_supported(screen, PIPE_FORMAT_B8G8R8A8_SRGB,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_RENDER_TARGET, 0)) {
PIPE_BIND_RENDER_TARGET)) {
ctx->Extensions.EXT_framebuffer_sRGB = GL_TRUE;
ctx->Const.sRGBCapable = GL_TRUE;
}
@ -403,14 +403,14 @@ void st_init_extensions(struct st_context *st)
if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0)) {
PIPE_BIND_SAMPLER_VIEW)) {
ctx->Extensions.ARB_texture_rg = GL_TRUE;
}
/* s3tc support */
if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0) &&
PIPE_BIND_SAMPLER_VIEW) &&
ctx->Mesa_DXTn) {
ctx->Extensions.EXT_texture_compression_s3tc = GL_TRUE;
ctx->Extensions.S3_s3tc = GL_TRUE;
@ -418,48 +418,48 @@ void st_init_extensions(struct st_context *st)
if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0) &&
PIPE_BIND_SAMPLER_VIEW) &&
screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0) &&
PIPE_BIND_SAMPLER_VIEW) &&
screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0) &&
PIPE_BIND_SAMPLER_VIEW) &&
screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0)
PIPE_BIND_SAMPLER_VIEW)
) {
ctx->Extensions.ARB_texture_compression_rgtc = GL_TRUE;
}
if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0) &&
PIPE_BIND_SAMPLER_VIEW) &&
screen->is_format_supported(screen, PIPE_FORMAT_LATC1_SNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0) &&
PIPE_BIND_SAMPLER_VIEW) &&
screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0) &&
PIPE_BIND_SAMPLER_VIEW) &&
screen->is_format_supported(screen, PIPE_FORMAT_LATC2_SNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0)) {
PIPE_BIND_SAMPLER_VIEW)) {
ctx->Extensions.EXT_texture_compression_latc = GL_TRUE;
}
if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0)) {
PIPE_BIND_SAMPLER_VIEW)) {
ctx->Extensions.ATI_texture_compression_3dc = GL_TRUE;
}
/* ycbcr support */
if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0) ||
PIPE_BIND_SAMPLER_VIEW) ||
screen->is_format_supported(screen, PIPE_FORMAT_YUYV,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_SAMPLER_VIEW, 0)) {
PIPE_BIND_SAMPLER_VIEW)) {
ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;
}
@ -490,7 +490,7 @@ void st_init_extensions(struct st_context *st)
/* GL_ARB_half_float_vertex */
if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_FLOAT,
PIPE_BUFFER, 0,
PIPE_BIND_VERTEX_BUFFER, 0)) {
PIPE_BIND_VERTEX_BUFFER)) {
ctx->Extensions.ARB_half_float_vertex = GL_TRUE;
}

210
src/mesa/state_tracker/st_format.c
View file

@ -432,13 +432,12 @@ find_supported_format(struct pipe_screen *screen,
uint num_formats,
enum pipe_texture_target target,
unsigned sample_count,
unsigned tex_usage,
unsigned geom_flags)
unsigned tex_usage)
{
uint i;
for (i = 0; i < num_formats; i++) {
if (screen->is_format_supported(screen, formats[i], target,
sample_count, tex_usage, geom_flags)) {
sample_count, tex_usage)) {
return formats[i];
}
}
@ -453,8 +452,7 @@ static enum pipe_format
default_rgba_format(struct pipe_screen *screen,
enum pipe_texture_target target,
unsigned sample_count,
unsigned tex_usage,
unsigned geom_flags)
unsigned tex_usage)
{
static const enum pipe_format colorFormats[] = {
PIPE_FORMAT_B8G8R8A8_UNORM,
@ -463,7 +461,7 @@ default_rgba_format(struct pipe_screen *screen,
PIPE_FORMAT_B5G6R5_UNORM
};
return find_supported_format(screen, colorFormats, Elements(colorFormats),
target, sample_count, tex_usage, geom_flags);
target, sample_count, tex_usage);
}
@ -474,8 +472,7 @@ static enum pipe_format
default_rgb_format(struct pipe_screen *screen,
enum pipe_texture_target target,
unsigned sample_count,
unsigned tex_usage,
unsigned geom_flags)
unsigned tex_usage)
{
static const enum pipe_format colorFormats[] = {
PIPE_FORMAT_B8G8R8X8_UNORM,
@ -487,7 +484,7 @@ default_rgb_format(struct pipe_screen *screen,
PIPE_FORMAT_B5G6R5_UNORM
};
return find_supported_format(screen, colorFormats, Elements(colorFormats),
target, sample_count, tex_usage, geom_flags);
target, sample_count, tex_usage);
}
/**
@ -497,8 +494,7 @@ static enum pipe_format
default_srgba_format(struct pipe_screen *screen,
enum pipe_texture_target target,
unsigned sample_count,
unsigned tex_usage,
unsigned geom_flags)
unsigned tex_usage)
{
static const enum pipe_format colorFormats[] = {
PIPE_FORMAT_B8G8R8A8_SRGB,
@ -506,7 +502,7 @@ default_srgba_format(struct pipe_screen *screen,
PIPE_FORMAT_A8B8G8R8_SRGB,
};
return find_supported_format(screen, colorFormats, Elements(colorFormats),
target, sample_count, tex_usage, geom_flags);
target, sample_count, tex_usage);
}
@ -528,87 +524,71 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
enum pipe_texture_target target, unsigned sample_count,
unsigned bindings)
{
unsigned geom_flags = 0; /* we don't care about POT vs. NPOT here, yet */
switch (internalFormat) {
case GL_RGB10:
case GL_RGB10_A2:
if (screen->is_format_supported( screen, PIPE_FORMAT_B10G10R10A2_UNORM,
target, sample_count, bindings,
geom_flags ))
target, sample_count, bindings))
return PIPE_FORMAT_B10G10R10A2_UNORM;
/* Pass through. */
case 4:
case GL_RGBA:
case GL_RGBA8:
return default_rgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_rgba_format( screen, target, sample_count, bindings);
case GL_BGRA:
if (screen->is_format_supported( screen, PIPE_FORMAT_B8G8R8A8_UNORM,
target, sample_count, bindings,
geom_flags ))
target, sample_count, bindings))
return PIPE_FORMAT_B8G8R8A8_UNORM;
return default_rgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_rgba_format( screen, target, sample_count, bindings);
case 3:
case GL_RGB:
case GL_RGB8:
return default_rgb_format( screen, target, sample_count, bindings,
geom_flags );
return default_rgb_format( screen, target, sample_count, bindings);
case GL_RGB12:
case GL_RGB16:
case GL_RGBA12:
case GL_RGBA16:
if (screen->is_format_supported( screen, PIPE_FORMAT_R16G16B16A16_UNORM,
target, sample_count, bindings,
geom_flags ))
target, sample_count, bindings))
return PIPE_FORMAT_R16G16B16A16_UNORM;
return default_rgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_rgba_format( screen, target, sample_count, bindings);
case GL_RGBA4:
case GL_RGBA2:
if (screen->is_format_supported( screen, PIPE_FORMAT_B4G4R4A4_UNORM,
target, sample_count, bindings,
geom_flags ))
target, sample_count, bindings))
return PIPE_FORMAT_B4G4R4A4_UNORM;
return default_rgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_rgba_format( screen, target, sample_count, bindings);
case GL_RGB5_A1:
if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
target, sample_count, bindings,
geom_flags ))
target, sample_count, bindings))
return PIPE_FORMAT_B5G5R5A1_UNORM;
return default_rgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_rgba_format( screen, target, sample_count, bindings);
case GL_R3_G3_B2:
if (screen->is_format_supported( screen, PIPE_FORMAT_B2G3R3_UNORM,
target, sample_count, bindings,
geom_flags ))
target, sample_count, bindings))
return PIPE_FORMAT_B2G3R3_UNORM;
/* Pass through. */
case GL_RGB5:
case GL_RGB4:
if (screen->is_format_supported( screen, PIPE_FORMAT_B5G6R5_UNORM,
target, sample_count, bindings,
geom_flags ))
target, sample_count, bindings))
return PIPE_FORMAT_B5G6R5_UNORM;
if (screen->is_format_supported( screen, PIPE_FORMAT_B5G5R5A1_UNORM,
target, sample_count, bindings,
geom_flags ))
target, sample_count, bindings))
return PIPE_FORMAT_B5G5R5A1_UNORM;
return default_rgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_rgba_format( screen, target, sample_count, bindings);
case GL_ALPHA12:
case GL_ALPHA16:
if (screen->is_format_supported( screen, PIPE_FORMAT_A16_UNORM, target,
sample_count, bindings, geom_flags ))
sample_count, bindings))
return PIPE_FORMAT_A16_UNORM;
/* Pass through. */
case GL_ALPHA:
@ -616,15 +596,14 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_ALPHA8:
case GL_COMPRESSED_ALPHA:
if (screen->is_format_supported( screen, PIPE_FORMAT_A8_UNORM, target,
sample_count, bindings, geom_flags ))
sample_count, bindings))
return PIPE_FORMAT_A8_UNORM;
return default_rgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_rgba_format( screen, target, sample_count, bindings);
case GL_LUMINANCE12:
case GL_LUMINANCE16:
if (screen->is_format_supported( screen, PIPE_FORMAT_L16_UNORM, target,
sample_count, bindings, geom_flags ))
sample_count, bindings))
return PIPE_FORMAT_L16_UNORM;
/* Pass through. */
case 1:
@ -632,16 +611,15 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_LUMINANCE4:
case GL_LUMINANCE8:
if (screen->is_format_supported( screen, PIPE_FORMAT_L8_UNORM, target,
sample_count, bindings, geom_flags ))
sample_count, bindings))
return PIPE_FORMAT_L8_UNORM;
return default_rgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_rgba_format( screen, target, sample_count, bindings);
case GL_LUMINANCE12_ALPHA4:
case GL_LUMINANCE12_ALPHA12:
case GL_LUMINANCE16_ALPHA16:
if (screen->is_format_supported( screen, PIPE_FORMAT_L16A16_UNORM, target,
sample_count, bindings, geom_flags ))
sample_count, bindings))
return PIPE_FORMAT_L16A16_UNORM;
/* Pass through. */
case 2:
@ -649,25 +627,23 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_LUMINANCE6_ALPHA2:
case GL_LUMINANCE8_ALPHA8:
if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,
sample_count, bindings, geom_flags ))
sample_count, bindings))
return PIPE_FORMAT_L8A8_UNORM;
return default_rgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_rgba_format( screen, target, sample_count, bindings);
case GL_LUMINANCE4_ALPHA4:
if (screen->is_format_supported( screen, PIPE_FORMAT_L4A4_UNORM, target,
sample_count, bindings, geom_flags ))
sample_count, bindings))
return PIPE_FORMAT_L4A4_UNORM;
if (screen->is_format_supported( screen, PIPE_FORMAT_L8A8_UNORM, target,
sample_count, bindings, geom_flags ))
sample_count, bindings))
return PIPE_FORMAT_L8A8_UNORM;
return default_rgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_rgba_format( screen, target, sample_count, bindings);
case GL_INTENSITY12:
case GL_INTENSITY16:
if (screen->is_format_supported( screen, PIPE_FORMAT_I16_UNORM, target,
sample_count, bindings, geom_flags ))
sample_count, bindings))
return PIPE_FORMAT_I16_UNORM;
/* Pass through. */
case GL_INTENSITY:
@ -675,18 +651,17 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_INTENSITY8:
case GL_COMPRESSED_INTENSITY:
if (screen->is_format_supported( screen, PIPE_FORMAT_I8_UNORM, target,
sample_count, bindings, geom_flags ))
sample_count, bindings))
return PIPE_FORMAT_I8_UNORM;
return default_rgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_rgba_format( screen, target, sample_count, bindings);
case GL_YCBCR_MESA:
if (screen->is_format_supported(screen, PIPE_FORMAT_UYVY, target,
sample_count, bindings, geom_flags)) {
sample_count, bindings)) {
return PIPE_FORMAT_UYVY;
}
if (screen->is_format_supported(screen, PIPE_FORMAT_YUYV, target,
sample_count, bindings, geom_flags)) {
sample_count, bindings)) {
return PIPE_FORMAT_YUYV;
}
return PIPE_FORMAT_NONE;
@ -696,39 +671,33 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
return PIPE_FORMAT_NONE;
else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
target, sample_count, bindings,
geom_flags))
target, sample_count, bindings))
return PIPE_FORMAT_DXT1_RGB;
else
return default_rgb_format(screen, target, sample_count, bindings,
geom_flags);
return default_rgb_format(screen, target, sample_count, bindings);
case GL_COMPRESSED_RGBA:
/* can only sample from compressed formats */
if (bindings & ~PIPE_BIND_SAMPLER_VIEW)
return PIPE_FORMAT_NONE;
else if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
target, sample_count, bindings,
geom_flags))
target, sample_count, bindings))
return PIPE_FORMAT_DXT3_RGBA;
else
return default_rgba_format(screen, target, sample_count, bindings,
geom_flags);
return default_rgba_format(screen, target, sample_count, bindings);
case GL_RGB_S3TC:
case GL_RGB4_S3TC:
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGB,
target, sample_count, bindings,
geom_flags))
target, sample_count, bindings))
return PIPE_FORMAT_DXT1_RGB;
else
return PIPE_FORMAT_NONE;
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_RGBA,
target, sample_count, bindings,
geom_flags))
target, sample_count, bindings))
return PIPE_FORMAT_DXT1_RGBA;
else
return PIPE_FORMAT_NONE;
@ -737,16 +706,14 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_RGBA4_S3TC:
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_RGBA,
target, sample_count, bindings,
geom_flags))
target, sample_count, bindings))
return PIPE_FORMAT_DXT3_RGBA;
else
return PIPE_FORMAT_NONE;
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_DXT5_RGBA,
target, sample_count, bindings,
geom_flags))
target, sample_count, bindings))
return PIPE_FORMAT_DXT5_RGBA;
else
return PIPE_FORMAT_NONE;
@ -760,20 +727,20 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_DEPTH_COMPONENT16:
if (screen->is_format_supported(screen, PIPE_FORMAT_Z16_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_Z16_UNORM;
/* fall-through */
case GL_DEPTH_COMPONENT24:
if (screen->is_format_supported(screen, PIPE_FORMAT_Z24_UNORM_S8_USCALED,
target, sample_count, bindings, geom_flags))
target, sample_count, bindings))
return PIPE_FORMAT_Z24_UNORM_S8_USCALED;
if (screen->is_format_supported(screen, PIPE_FORMAT_S8_USCALED_Z24_UNORM,
target, sample_count, bindings, geom_flags))
target, sample_count, bindings))
return PIPE_FORMAT_S8_USCALED_Z24_UNORM;
/* fall-through */
case GL_DEPTH_COMPONENT32:
if (screen->is_format_supported(screen, PIPE_FORMAT_Z32_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_Z32_UNORM;
/* fall-through */
case GL_DEPTH_COMPONENT:
@ -785,7 +752,7 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
PIPE_FORMAT_Z16_UNORM
};
return find_supported_format(screen, formats, Elements(formats),
target, sample_count, bindings, geom_flags);
target, sample_count, bindings);
}
case GL_STENCIL_INDEX:
@ -800,7 +767,7 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
PIPE_FORMAT_S8_USCALED_Z24_UNORM
};
return find_supported_format(screen, formats, Elements(formats),
target, sample_count, bindings, geom_flags);
target, sample_count, bindings);
}
case GL_DEPTH_STENCIL_EXT:
@ -811,23 +778,21 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
PIPE_FORMAT_S8_USCALED_Z24_UNORM
};
return find_supported_format(screen, formats, Elements(formats),
target, sample_count, bindings, geom_flags);
target, sample_count, bindings);
}
case GL_SRGB_EXT:
case GL_SRGB8_EXT:
case GL_SRGB_ALPHA_EXT:
case GL_SRGB8_ALPHA8_EXT:
return default_srgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_srgba_format( screen, target, sample_count, bindings);
case GL_COMPRESSED_SRGB_EXT:
case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_DXT1_SRGB, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_DXT1_SRGB;
return default_srgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_srgba_format( screen, target, sample_count, bindings);
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
return PIPE_FORMAT_DXT1_SRGBA;
@ -835,10 +800,9 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_COMPRESSED_SRGB_ALPHA_EXT:
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_DXT3_SRGBA, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_DXT3_SRGBA;
return default_srgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_srgba_format( screen, target, sample_count, bindings);
case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
return PIPE_FORMAT_DXT5_SRGBA;
@ -848,89 +812,87 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_COMPRESSED_SLUMINANCE_EXT:
case GL_COMPRESSED_SLUMINANCE_ALPHA_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_SRGB, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_L8A8_SRGB;
return default_srgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_srgba_format( screen, target, sample_count, bindings);
case GL_SLUMINANCE_EXT:
case GL_SLUMINANCE8_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_L8_SRGB, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_L8_SRGB;
return default_srgba_format( screen, target, sample_count, bindings,
geom_flags );
return default_srgba_format( screen, target, sample_count, bindings);
case GL_RED:
case GL_R8:
if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_R8_UNORM;
return PIPE_FORMAT_NONE;
case GL_RG:
case GL_RG8:
if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_R8G8_UNORM;
return PIPE_FORMAT_NONE;
case GL_R16:
if (screen->is_format_supported(screen, PIPE_FORMAT_R16_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_R16_UNORM;
return PIPE_FORMAT_NONE;
case GL_RG16:
if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_R16G16_UNORM;
return PIPE_FORMAT_NONE;
case GL_COMPRESSED_RED:
case GL_COMPRESSED_RED_RGTC1:
if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_RGTC1_UNORM;
if (screen->is_format_supported(screen, PIPE_FORMAT_R8_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_R8_UNORM;
return PIPE_FORMAT_NONE;
case GL_COMPRESSED_SIGNED_RED_RGTC1:
if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC1_SNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_RGTC1_SNORM;
return PIPE_FORMAT_NONE;
case GL_COMPRESSED_RG:
case GL_COMPRESSED_RG_RGTC2:
if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_RGTC2_UNORM;
if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_R8G8_UNORM;
return PIPE_FORMAT_NONE;
case GL_COMPRESSED_SIGNED_RG_RGTC2:
if (screen->is_format_supported(screen, PIPE_FORMAT_RGTC2_SNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_RGTC2_SNORM;
return PIPE_FORMAT_NONE;
case GL_COMPRESSED_LUMINANCE:
case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_LATC1_UNORM;
if (screen->is_format_supported(screen, PIPE_FORMAT_L8_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_L8_UNORM;
return PIPE_FORMAT_NONE;
case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_LATC1_SNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_LATC1_SNORM;
return PIPE_FORMAT_NONE;
@ -938,16 +900,16 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
case GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI:
if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_LATC2_UNORM;
if (screen->is_format_supported(screen, PIPE_FORMAT_L8A8_UNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_L8A8_UNORM;
return PIPE_FORMAT_NONE;
case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_LATC2_SNORM, target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_LATC2_SNORM;
return PIPE_FORMAT_NONE;
@ -974,7 +936,7 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_LUMINANCE_ALPHA8I_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_SSCALED,
target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_R8G8B8A8_SSCALED;
return PIPE_FORMAT_NONE;
case GL_RGBA16I_EXT:
@ -985,7 +947,7 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_LUMINANCE_ALPHA16I_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_SSCALED,
target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_R16G16B16A16_SSCALED;
return PIPE_FORMAT_NONE;
case GL_RGBA32I_EXT:
@ -997,7 +959,7 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
/* xxx */
if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_SSCALED,
target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_R32G32B32A32_SSCALED;
return PIPE_FORMAT_NONE;
@ -1009,7 +971,7 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_LUMINANCE_ALPHA8UI_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_R8G8B8A8_USCALED,
target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_R8G8B8A8_USCALED;
return PIPE_FORMAT_NONE;
@ -1021,7 +983,7 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_LUMINANCE_ALPHA16UI_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_R16G16B16A16_USCALED,
target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_R16G16B16A16_USCALED;
return PIPE_FORMAT_NONE;
@ -1033,7 +995,7 @@ st_choose_format(struct pipe_screen *screen, GLenum internalFormat,
case GL_LUMINANCE_ALPHA32UI_EXT:
if (screen->is_format_supported(screen, PIPE_FORMAT_R32G32B32A32_USCALED,
target,
sample_count, bindings, geom_flags))
sample_count, bindings))
return PIPE_FORMAT_R32G32B32A32_USCALED;
return PIPE_FORMAT_NONE;

2
src/mesa/state_tracker/st_gen_mipmap.c
View file

@ -87,7 +87,7 @@ st_render_mipmap(struct st_context *st,
/* XXX should probably kill this and always use util_gen_mipmap
since this implements a sw fallback as well */
if (!screen->is_format_supported(screen, psv->format, psv->texture->target,
0, PIPE_BIND_RENDER_TARGET, 0)) {
0, PIPE_BIND_RENDER_TARGET)) {
return FALSE;
}

2
src/mesa/state_tracker/st_texture.c
View file

@ -78,7 +78,7 @@ st_texture_create(struct st_context *st,
assert(format);
assert(screen->is_format_supported(screen, format, target, 0,
PIPE_BIND_SAMPLER_VIEW, 0));
PIPE_BIND_SAMPLER_VIEW));
memset(&pt, 0, sizeof(pt));
pt.target = target;