if (readAtt && readAtt->Texture) {
const struct gl_texture_object *texObj = readAtt->Texture;
const GLuint srcLevel = readAtt->TextureLevel;
- const GLenum minFilterSave = texObj->MinFilter;
- const GLenum magFilterSave = texObj->MagFilter;
+ const GLenum minFilterSave = texObj->Sampler.MinFilter;
+ const GLenum magFilterSave = texObj->Sampler.MagFilter;
const GLint baseLevelSave = texObj->BaseLevel;
const GLint maxLevelSave = texObj->MaxLevel;
- const GLenum wrapSSave = texObj->WrapS;
- const GLenum wrapTSave = texObj->WrapT;
+ const GLenum wrapSSave = texObj->Sampler.WrapS;
+ const GLenum wrapTSave = texObj->Sampler.WrapT;
const GLenum target = texObj->Target;
if (drawAtt->Texture == readAtt->Texture) {
struct vertex verts[4];
const GLuint baseLevel = texObj->BaseLevel;
const GLuint maxLevel = texObj->MaxLevel;
- const GLenum minFilterSave = texObj->MinFilter;
- const GLenum magFilterSave = texObj->MagFilter;
+ const GLenum minFilterSave = texObj->Sampler.MinFilter;
+ const GLenum magFilterSave = texObj->Sampler.MagFilter;
const GLint maxLevelSave = texObj->MaxLevel;
const GLboolean genMipmapSave = texObj->GenerateMipmap;
- const GLenum wrapSSave = texObj->WrapS;
- const GLenum wrapTSave = texObj->WrapT;
- const GLenum wrapRSave = texObj->WrapR;
+ const GLenum wrapSSave = texObj->Sampler.WrapS;
+ const GLenum wrapTSave = texObj->Sampler.WrapT;
+ const GLenum wrapRSave = texObj->Sampler.WrapR;
const GLuint fboSave = ctx->DrawBuffer->Name;
const GLuint original_active_unit = ctx->Texture.CurrentUnit;
GLenum faceTarget;
case GL_TEXTURE_2D:
case GL_TEXTURE_3D:
case GL_TEXTURE_CUBE_MAP:
- if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) {
+ if (tObj->Sampler.MinFilter == GL_NEAREST ||
+ tObj->Sampler.MinFilter == GL_LINEAR) {
/* GL_NEAREST and GL_LINEAR only care about GL_TEXTURE_BASE_LEVEL.
*/
firstLevel = lastLevel = tObj->BaseLevel;
}
else {
- firstLevel = tObj->BaseLevel + (GLint)(tObj->MinLod + 0.5);
+ firstLevel = tObj->BaseLevel + (GLint)(tObj->Sampler.MinLod + 0.5);
firstLevel = MAX2(firstLevel, tObj->BaseLevel);
firstLevel = MIN2(firstLevel, tObj->BaseLevel + baseImage->MaxLog2);
- lastLevel = tObj->BaseLevel + (GLint)(tObj->MaxLod + 0.5);
+ lastLevel = tObj->BaseLevel + (GLint)(tObj->Sampler.MaxLod + 0.5);
lastLevel = MAX2(lastLevel, t->tObj->BaseLevel);
lastLevel = MIN2(lastLevel, t->tObj->BaseLevel + baseImage->MaxLog2);
lastLevel = MIN2(lastLevel, t->tObj->MaxLevel);
make_empty_list( & t->base );
- i810SetTexWrapping( t, texObj->WrapS, texObj->WrapT );
+ i810SetTexWrapping( t, texObj->Sampler.WrapS, texObj->Sampler.WrapT );
/*i830SetTexMaxAnisotropy( t, texObj->MaxAnisotropy );*/
- i810SetTexFilter( imesa, t, texObj->MinFilter, texObj->MagFilter, bias );
- i810SetTexBorderColor( t, texObj->BorderColor.f );
+ i810SetTexFilter( imesa, t, texObj->Sampler.MinFilter, texObj->Sampler.MagFilter, bias );
+ i810SetTexBorderColor( t, texObj->Sampler.BorderColor.f );
}
return t;
case GL_TEXTURE_MAG_FILTER:
{
GLfloat bias = ctx->Texture.Unit[ctx->Texture.CurrentUnit].LodBias;
- i810SetTexFilter( imesa, t, tObj->MinFilter, tObj->MagFilter, bias );
+ i810SetTexFilter( imesa, t, tObj->Sampler.MinFilter, tObj->Sampler.MagFilter, bias );
}
break;
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
- i810SetTexWrapping( t, tObj->WrapS, tObj->WrapT );
+ i810SetTexWrapping( t, tObj->Sampler.WrapS, tObj->Sampler.WrapT );
break;
case GL_TEXTURE_BORDER_COLOR:
- i810SetTexBorderColor( t, tObj->BorderColor.f );
+ i810SetTexBorderColor( t, tObj->Sampler.BorderColor.f );
break;
case GL_TEXTURE_BASE_LEVEL:
float maxlod;
uint32_t minlod_fixed, maxlod_fixed;
- switch (tObj->MinFilter) {
+ switch (tObj->Sampler.MinFilter) {
case GL_NEAREST:
minFilt = FILTER_NEAREST;
mipFilt = MIPFILTER_NONE;
return GL_FALSE;
}
- if (tObj->MaxAnisotropy > 1.0) {
+ if (tObj->Sampler.MaxAnisotropy > 1.0) {
minFilt = FILTER_ANISOTROPIC;
magFilt = FILTER_ANISOTROPIC;
}
else {
- switch (tObj->MagFilter) {
+ switch (tObj->Sampler.MagFilter) {
case GL_NEAREST:
magFilt = FILTER_NEAREST;
break;
}
}
- lodbias = (int) ((tUnit->LodBias + tObj->LodBias) * 16.0);
+ lodbias = (int) ((tUnit->LodBias + tObj->Sampler.LodBias) * 16.0);
if (lodbias < -64)
lodbias = -64;
if (lodbias > 63)
* addressable (smallest resolution) LOD. Use it to cover both
* MAX_LEVEL and MAX_LOD.
*/
- minlod_fixed = U_FIXED(CLAMP(tObj->MinLod, 0.0, 11), 4);
- maxlod = MIN2(tObj->MaxLod, tObj->_MaxLevel - tObj->BaseLevel);
+ minlod_fixed = U_FIXED(CLAMP(tObj->Sampler.MinLod, 0.0, 11), 4);
+ maxlod = MIN2(tObj->Sampler.MaxLod, tObj->_MaxLevel - tObj->BaseLevel);
if (intel->intelScreen->deviceID == PCI_CHIP_I855_GM ||
intel->intelScreen->deviceID == PCI_CHIP_I865_G) {
maxlod_fixed = U_FIXED(CLAMP(maxlod, 0.0, 11.75), 2);
}
{
- GLenum ws = tObj->WrapS;
- GLenum wt = tObj->WrapT;
+ GLenum ws = tObj->Sampler.WrapS;
+ GLenum wt = tObj->Sampler.WrapT;
/* 3D textures not available on i830
}
/* convert border color from float to ubyte */
- CLAMPED_FLOAT_TO_UBYTE(border[0], tObj->BorderColor.f[0]);
- CLAMPED_FLOAT_TO_UBYTE(border[1], tObj->BorderColor.f[1]);
- CLAMPED_FLOAT_TO_UBYTE(border[2], tObj->BorderColor.f[2]);
- CLAMPED_FLOAT_TO_UBYTE(border[3], tObj->BorderColor.f[3]);
+ CLAMPED_FLOAT_TO_UBYTE(border[0], tObj->Sampler.BorderColor.f[0]);
+ CLAMPED_FLOAT_TO_UBYTE(border[1], tObj->Sampler.BorderColor.f[1]);
+ CLAMPED_FLOAT_TO_UBYTE(border[2], tObj->Sampler.BorderColor.f[2]);
+ CLAMPED_FLOAT_TO_UBYTE(border[3], tObj->Sampler.BorderColor.f[3]);
state[I830_TEXREG_TM0S4] = PACK_COLOR_8888(border[3],
border[0],
format = translate_texture_format(firstImage->TexFormat,
firstImage->InternalFormat,
- tObj->DepthMode);
+ tObj->Sampler.DepthMode);
pitch = intelObj->mt->region->pitch * intelObj->mt->cpp;
state[I915_TEXREG_MS3] =
* (lowest resolution) LOD. Use it to cover both MAX_LEVEL and
* MAX_LOD.
*/
- maxlod = MIN2(tObj->MaxLod, tObj->_MaxLevel - tObj->BaseLevel);
+ maxlod = MIN2(tObj->Sampler.MaxLod, tObj->_MaxLevel - tObj->BaseLevel);
state[I915_TEXREG_MS4] =
((((pitch / 4) - 1) << MS4_PITCH_SHIFT) |
MS4_CUBE_FACE_ENA_MASK |
{
GLuint minFilt, mipFilt, magFilt;
- switch (tObj->MinFilter) {
+ switch (tObj->Sampler.MinFilter) {
case GL_NEAREST:
minFilt = FILTER_NEAREST;
mipFilt = MIPFILTER_NONE;
return GL_FALSE;
}
- if (tObj->MaxAnisotropy > 1.0) {
+ if (tObj->Sampler.MaxAnisotropy > 1.0) {
minFilt = FILTER_ANISOTROPIC;
magFilt = FILTER_ANISOTROPIC;
- if (tObj->MaxAnisotropy > 2.0)
+ if (tObj->Sampler.MaxAnisotropy > 2.0)
aniso = SS2_MAX_ANISO_4;
else
aniso = SS2_MAX_ANISO_2;
}
else {
- switch (tObj->MagFilter) {
+ switch (tObj->Sampler.MagFilter) {
case GL_NEAREST:
magFilt = FILTER_NEAREST;
break;
}
}
- lodbias = (int) ((tUnit->LodBias + tObj->LodBias) * 16.0);
+ lodbias = (int) ((tUnit->LodBias + tObj->Sampler.LodBias) * 16.0);
if (lodbias < -256)
lodbias = -256;
if (lodbias > 255)
/* Shadow:
*/
- if (tObj->CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB &&
+ if (tObj->Sampler.CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB &&
tObj->Target != GL_TEXTURE_3D) {
if (tObj->Target == GL_TEXTURE_1D)
return GL_FALSE;
state[I915_TEXREG_SS2] |=
(SS2_SHADOW_ENABLE |
- intel_translate_shadow_compare_func(tObj->CompareFunc));
+ intel_translate_shadow_compare_func(tObj->Sampler.CompareFunc));
minFilt = FILTER_4X4_FLAT;
magFilt = FILTER_4X4_FLAT;
}
{
- GLenum ws = tObj->WrapS;
- GLenum wt = tObj->WrapT;
- GLenum wr = tObj->WrapR;
+ GLenum ws = tObj->Sampler.WrapS;
+ GLenum wt = tObj->Sampler.WrapT;
+ GLenum wr = tObj->Sampler.WrapR;
float minlod;
/* We program 1D textures as 2D textures, so the 2D texcoord could
* clamp_to_border.
*/
if (tObj->Target == GL_TEXTURE_3D &&
- (tObj->MinFilter != GL_NEAREST ||
- tObj->MagFilter != GL_NEAREST) &&
+ (tObj->Sampler.MinFilter != GL_NEAREST ||
+ tObj->Sampler.MagFilter != GL_NEAREST) &&
(ws == GL_CLAMP ||
wt == GL_CLAMP ||
wr == GL_CLAMP ||
(translate_wrap_mode(wt) << SS3_TCY_ADDR_MODE_SHIFT) |
(translate_wrap_mode(wr) << SS3_TCZ_ADDR_MODE_SHIFT));
- minlod = MIN2(tObj->MinLod, tObj->_MaxLevel - tObj->BaseLevel);
+ minlod = MIN2(tObj->Sampler.MinLod, tObj->_MaxLevel - tObj->BaseLevel);
state[I915_TEXREG_SS3] |= (unit << SS3_TEXTUREMAP_INDEX_SHIFT);
state[I915_TEXREG_SS3] |= (U_FIXED(CLAMP(minlod, 0.0, 11.0), 4) <<
SS3_MIN_LOD_SHIFT);
}
/* convert border color from float to ubyte */
- CLAMPED_FLOAT_TO_UBYTE(border[0], tObj->BorderColor.f[0]);
- CLAMPED_FLOAT_TO_UBYTE(border[1], tObj->BorderColor.f[1]);
- CLAMPED_FLOAT_TO_UBYTE(border[2], tObj->BorderColor.f[2]);
- CLAMPED_FLOAT_TO_UBYTE(border[3], tObj->BorderColor.f[3]);
+ CLAMPED_FLOAT_TO_UBYTE(border[0], tObj->Sampler.BorderColor.f[0]);
+ CLAMPED_FLOAT_TO_UBYTE(border[1], tObj->Sampler.BorderColor.f[1]);
+ CLAMPED_FLOAT_TO_UBYTE(border[2], tObj->Sampler.BorderColor.f[2]);
+ CLAMPED_FLOAT_TO_UBYTE(border[3], tObj->Sampler.BorderColor.f[3]);
if (firstImage->_BaseFormat == GL_DEPTH_COMPONENT) {
/* GL specs that border color for depth textures is taken from the
struct gl_texture_unit *texUnit = &ctx->Texture.Unit[u];
if (texUnit->Enabled) {
if (texUnit->Enabled & TEXTURE_1D_BIT) {
- if (texUnit->CurrentTex[TEXTURE_1D_INDEX]->WrapS == GL_CLAMP) {
+ if (texUnit->CurrentTex[TEXTURE_1D_INDEX]->Sampler.WrapS == GL_CLAMP) {
return GL_TRUE;
}
}
if (texUnit->Enabled & TEXTURE_2D_BIT) {
- if (texUnit->CurrentTex[TEXTURE_2D_INDEX]->WrapS == GL_CLAMP ||
- texUnit->CurrentTex[TEXTURE_2D_INDEX]->WrapT == GL_CLAMP) {
+ if (texUnit->CurrentTex[TEXTURE_2D_INDEX]->Sampler.WrapS == GL_CLAMP ||
+ texUnit->CurrentTex[TEXTURE_2D_INDEX]->Sampler.WrapT == GL_CLAMP) {
return GL_TRUE;
}
}
if (texUnit->Enabled & TEXTURE_3D_BIT) {
- if (texUnit->CurrentTex[TEXTURE_3D_INDEX]->WrapS == GL_CLAMP ||
- texUnit->CurrentTex[TEXTURE_3D_INDEX]->WrapT == GL_CLAMP ||
- texUnit->CurrentTex[TEXTURE_3D_INDEX]->WrapR == GL_CLAMP) {
+ if (texUnit->CurrentTex[TEXTURE_3D_INDEX]->Sampler.WrapS == GL_CLAMP ||
+ texUnit->CurrentTex[TEXTURE_3D_INDEX]->Sampler.WrapT == GL_CLAMP ||
+ texUnit->CurrentTex[TEXTURE_3D_INDEX]->Sampler.WrapR == GL_CLAMP) {
return GL_TRUE;
}
}
* well and our shadow compares always return the result in
* all 4 channels.
*/
- if (t->CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) {
- if (t->DepthMode == GL_ALPHA) {
+ if (t->Sampler.CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) {
+ if (t->Sampler.DepthMode == GL_ALPHA) {
swizzles[0] = SWIZZLE_ZERO;
swizzles[1] = SWIZZLE_ZERO;
swizzles[2] = SWIZZLE_ZERO;
- } else if (t->DepthMode == GL_LUMINANCE) {
+ } else if (t->Sampler.DepthMode == GL_LUMINANCE) {
swizzles[3] = SWIZZLE_ONE;
- } else if (t->DepthMode == GL_RED) {
+ } else if (t->Sampler.DepthMode == GL_RED) {
/* See table 3.23 of the GL 3.0 spec. */
swizzles[1] = SWIZZLE_ZERO;
swizzles[2] = SWIZZLE_ZERO;
entry->seamless_cube_map = (texObj->Target == GL_TEXTURE_CUBE_MAP)
? ctx->Texture.CubeMapSeamless : GL_FALSE;
- entry->wrap_r = texObj->WrapR;
- entry->wrap_s = texObj->WrapS;
- entry->wrap_t = texObj->WrapT;
-
- entry->maxlod = texObj->MaxLod;
- entry->minlod = texObj->MinLod;
- entry->lod_bias = texUnit->LodBias + texObj->LodBias;
- entry->max_aniso = texObj->MaxAnisotropy;
- entry->minfilter = texObj->MinFilter;
- entry->magfilter = texObj->MagFilter;
- entry->comparemode = texObj->CompareMode;
- entry->comparefunc = texObj->CompareFunc;
+ entry->wrap_r = texObj->Sampler.WrapR;
+ entry->wrap_s = texObj->Sampler.WrapS;
+ entry->wrap_t = texObj->Sampler.WrapT;
+
+ entry->maxlod = texObj->Sampler.MaxLod;
+ entry->minlod = texObj->Sampler.MinLod;
+ entry->lod_bias = texUnit->LodBias + texObj->Sampler.LodBias;
+ entry->max_aniso = texObj->Sampler.MaxAnisotropy;
+ entry->minfilter = texObj->Sampler.MinFilter;
+ entry->magfilter = texObj->Sampler.MagFilter;
+ entry->comparemode = texObj->Sampler.CompareMode;
+ entry->comparefunc = texObj->Sampler.CompareFunc;
drm_intel_bo_unreference(brw->wm.sdc_bo[unit]);
if (firstImage->_BaseFormat == GL_DEPTH_COMPONENT) {
float bordercolor[4] = {
- texObj->BorderColor.f[0],
- texObj->BorderColor.f[0],
- texObj->BorderColor.f[0],
- texObj->BorderColor.f[0]
+ texObj->Sampler.BorderColor.f[0],
+ texObj->Sampler.BorderColor.f[0],
+ texObj->Sampler.BorderColor.f[0],
+ texObj->Sampler.BorderColor.f[0]
};
/* GL specs that border color for depth textures is taken from the
* R channel, while the hardware uses A. Spam R into all the
brw->wm.sdc_bo[unit] = upload_default_color(brw, bordercolor);
} else {
brw->wm.sdc_bo[unit] = upload_default_color(brw,
- texObj->BorderColor.f);
+ texObj->Sampler.BorderColor.f);
}
key->sampler_count = unit + 1;
}
surf->ss0.mipmap_layout_mode = BRW_SURFACE_MIPMAPLAYOUT_BELOW;
surf->ss0.surface_type = translate_tex_target(tObj->Target);
surf->ss0.surface_format = translate_tex_format(firstImage->TexFormat,
- firstImage->InternalFormat,
- tObj->DepthMode, tObj->sRGBDecode);
+ firstImage->InternalFormat,
+ tObj->Sampler.DepthMode,
+ tObj->Sampler.sRGBDecode);
/* This is ok for all textures with channel width 8bit or less:
*/
* resizable buffers, or require that buffers implement lazy
* pagetable arrangements.
*/
- if ((intelObj->base.MinFilter == GL_NEAREST ||
- intelObj->base.MinFilter == GL_LINEAR) &&
+ if ((intelObj->base.Sampler.MinFilter == GL_NEAREST ||
+ intelObj->base.Sampler.MinFilter == GL_LINEAR) &&
intelImage->level == firstLevel &&
(intel->gen < 4 || firstLevel == 0)) {
lastLevel = firstLevel;
{
struct gl_texture_object *tObj = &intelObj->base;
- if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) {
+ if (tObj->Sampler.MinFilter == GL_NEAREST || tObj->Sampler.MinFilter == GL_LINEAR) {
intelObj->_MaxLevel = tObj->BaseLevel;
} else {
intelObj->_MaxLevel = tObj->_MaxLevel;
make_empty_list( (driTextureObject *) t );
- mach64SetTexWrap( t, texObj->WrapS, texObj->WrapT );
- mach64SetTexFilter( t, texObj->MinFilter, texObj->MagFilter );
- mach64SetTexBorderColor( t, texObj->BorderColor.f );
+ mach64SetTexWrap( t, texObj->Sampler.WrapS, texObj->Sampler.WrapT );
+ mach64SetTexFilter( t, texObj->Sampler.MinFilter, texObj->Sampler.MagFilter );
+ mach64SetTexBorderColor( t, texObj->Sampler.BorderColor.f );
return t;
}
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_MAG_FILTER:
if ( t->base.bound ) FLUSH_BATCH( mmesa );
- mach64SetTexFilter( t, tObj->MinFilter, tObj->MagFilter );
+ mach64SetTexFilter( t, tObj->Sampler.MinFilter, tObj->Sampler.MagFilter );
break;
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
if ( t->base.bound ) FLUSH_BATCH( mmesa );
- mach64SetTexWrap( t, tObj->WrapS, tObj->WrapT );
+ mach64SetTexWrap( t, tObj->Sampler.WrapS, tObj->Sampler.WrapT );
break;
case GL_TEXTURE_BORDER_COLOR:
if ( t->base.bound ) FLUSH_BATCH( mmesa );
- mach64SetTexBorderColor( t, tObj->BorderColor.f );
+ mach64SetTexBorderColor( t, tObj->Sampler.BorderColor.f );
break;
case GL_TEXTURE_BASE_LEVEL:
make_empty_list( & t->base );
- mgaSetTexWrapping( t, tObj->WrapS, tObj->WrapT );
- mgaSetTexFilter( t, tObj->MinFilter, tObj->MagFilter );
- mgaSetTexBorderColor( t, tObj->BorderColor.f );
+ mgaSetTexWrapping( t, tObj->Sampler.WrapS, tObj->Sampler.WrapT );
+ mgaSetTexFilter( t, tObj->Sampler.MinFilter, tObj->Sampler.MagFilter );
+ mgaSetTexBorderColor( t, tObj->Sampler.BorderColor.f );
}
return( t );
/* FALLTHROUGH */
case GL_TEXTURE_MAG_FILTER:
FLUSH_BATCH(mmesa);
- mgaSetTexFilter( t, tObj->MinFilter, tObj->MagFilter );
+ mgaSetTexFilter( t, tObj->Sampler.MinFilter, tObj->Sampler.MagFilter );
break;
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
FLUSH_BATCH(mmesa);
- mgaSetTexWrapping(t,tObj->WrapS,tObj->WrapT);
+ mgaSetTexWrapping(t,tObj->Sampler.WrapS,tObj->Sampler.WrapT);
break;
case GL_TEXTURE_BORDER_COLOR:
FLUSH_BATCH(mmesa);
- mgaSetTexBorderColor(t, tObj->BorderColor.f);
+ mgaSetTexBorderColor(t, tObj->Sampler.BorderColor.f);
break;
case GL_TEXTURE_BASE_LEVEL:
{
struct gl_texture_image *base = t->Image[0][t->BaseLevel];
- if (t->MinFilter == GL_NEAREST ||
- t->MinFilter == GL_LINEAR || !base)
+ if (t->Sampler.MinFilter == GL_NEAREST ||
+ t->Sampler.MinFilter == GL_LINEAR || !base)
return t->BaseLevel;
else
return MIN2(t->BaseLevel + base->MaxLog2, t->MaxLevel);
s = &to_nouveau_texture(t)->surfaces[t->BaseLevel];
- if (t->MinFilter != GL_NEAREST &&
- t->MinFilter != GL_LINEAR) {
+ if (t->Sampler.MinFilter != GL_NEAREST &&
+ t->Sampler.MinFilter != GL_LINEAR) {
lod_max = CLAMP(MIN2(t->MaxLod, t->_MaxLambda),
0, 15) + 1;
t->LodBias, -16, 15) * 8;
}
- format |= nvgl_wrap_mode(t->WrapT) << 28 |
- nvgl_wrap_mode(t->WrapS) << 24 |
+ format |= nvgl_wrap_mode(t->Sampler.WrapT) << 28 |
+ nvgl_wrap_mode(t->Sampler.WrapS) << 24 |
ti->HeightLog2 << 20 |
ti->WidthLog2 << 16 |
lod_max << 12 |
get_tex_format(ti);
filter |= log2i(t->MaxAnisotropy) << 31 |
- nvgl_filter_mode(t->MagFilter) << 28 |
+ nvgl_filter_mode(t->Sampler.MagFilter) << 28 |
log2i(t->MaxAnisotropy) << 27 |
- nvgl_filter_mode(t->MinFilter) << 24 |
+ nvgl_filter_mode(t->Sampler.MinFilter) << 24 |
(lod_bias & 0xff) << 16;
} else {
return;
/* Recompute the texturing registers. */
- tx_format = nvgl_wrap_mode(t->WrapT) << 28
- | nvgl_wrap_mode(t->WrapS) << 24
+ tx_format = nvgl_wrap_mode(t->Sampler.WrapT) << 28
+ | nvgl_wrap_mode(t->Sampler.WrapS) << 24
| ti->HeightLog2 << 20
| ti->WidthLog2 << 16
| 5 << 4 | 1 << 12;
- tx_filter = nvgl_filter_mode(t->MagFilter) << 28
- | nvgl_filter_mode(t->MinFilter) << 24;
+ tx_filter = nvgl_filter_mode(t->Sampler.MagFilter) << 28
+ | nvgl_filter_mode(t->Sampler.MinFilter) << 24;
tx_enable = NV10_3D_TEX_ENABLE_ENABLE
| log2i(t->MaxAnisotropy) << 4;
tx_format |= get_tex_format_pot(ti);
}
- if (t->MinFilter != GL_NEAREST &&
- t->MinFilter != GL_LINEAR) {
+ if (t->Sampler.MinFilter != GL_NEAREST &&
+ t->Sampler.MinFilter != GL_LINEAR) {
int lod_min = t->MinLod;
int lod_max = MIN2(t->MaxLod, t->_MaxLambda);
int lod_bias = t->LodBias
| NV20_3D_TEX_FORMAT_NO_BORDER
| 1 << 16;
- tx_wrap = nvgl_wrap_mode(t->WrapR) << 16
- | nvgl_wrap_mode(t->WrapT) << 8
- | nvgl_wrap_mode(t->WrapS) << 0;
+ tx_wrap = nvgl_wrap_mode(t->Sampler.WrapR) << 16
+ | nvgl_wrap_mode(t->Sampler.WrapT) << 8
+ | nvgl_wrap_mode(t->Sampler.WrapS) << 0;
- tx_filter = nvgl_filter_mode(t->MagFilter) << 24
- | nvgl_filter_mode(t->MinFilter) << 16
+ tx_filter = nvgl_filter_mode(t->Sampler.MagFilter) << 24
+ | nvgl_filter_mode(t->Sampler.MinFilter) << 16
| 2 << 12;
tx_enable = NV20_3D_TEX_ENABLE_ENABLE
tx_format |= get_tex_format_pot(ti);
}
- if (t->MinFilter != GL_NEAREST &&
- t->MinFilter != GL_LINEAR) {
+ if (t->Sampler.MinFilter != GL_NEAREST &&
+ t->Sampler.MinFilter != GL_LINEAR) {
int lod_min = t->MinLod;
int lod_max = MIN2(t->MaxLod, t->_MaxLambda);
int lod_bias = t->LodBias
make_empty_list( (driTextureObject *) t );
- r128SetTexWrap( t, texObj->WrapS, texObj->WrapT );
- r128SetTexFilter( t, texObj->MinFilter, texObj->MagFilter );
- r128SetTexBorderColor( t, texObj->BorderColor.f );
+ r128SetTexWrap( t, texObj->Sampler.WrapS, texObj->Sampler.WrapT );
+ r128SetTexFilter( t, texObj->Sampler.MinFilter, texObj->Sampler.MagFilter );
+ r128SetTexBorderColor( t, texObj->Sampler.BorderColor.f );
}
return t;
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_MAG_FILTER:
if ( t->base.bound ) FLUSH_BATCH( rmesa );
- r128SetTexFilter( t, tObj->MinFilter, tObj->MagFilter );
+ r128SetTexFilter( t, tObj->Sampler.MinFilter, tObj->Sampler.MagFilter );
break;
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
if ( t->base.bound ) FLUSH_BATCH( rmesa );
- r128SetTexWrap( t, tObj->WrapS, tObj->WrapT );
+ r128SetTexWrap( t, tObj->Sampler.WrapS, tObj->Sampler.WrapT );
break;
case GL_TEXTURE_BORDER_COLOR:
if ( t->base.bound ) FLUSH_BATCH( rmesa );
- r128SetTexBorderColor( t, tObj->BorderColor.f );
+ r128SetTexBorderColor( t, tObj->Sampler.BorderColor.f );
break;
case GL_TEXTURE_BASE_LEVEL:
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_MAG_FILTER:
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
- r200SetTexMaxAnisotropy( t, texObj->MaxAnisotropy );
- r200SetTexFilter( t, texObj->MinFilter, texObj->MagFilter );
+ r200SetTexMaxAnisotropy( t, texObj->Sampler.MaxAnisotropy );
+ r200SetTexFilter( t, texObj->Sampler.MinFilter, texObj->Sampler.MagFilter );
break;
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
case GL_TEXTURE_WRAP_R:
- r200SetTexWrap( t, texObj->WrapS, texObj->WrapT, texObj->WrapR );
+ r200SetTexWrap( t, texObj->Sampler.WrapS, texObj->Sampler.WrapT, texObj->Sampler.WrapR );
break;
case GL_TEXTURE_BORDER_COLOR:
- r200SetTexBorderColor( t, texObj->BorderColor.f );
+ r200SetTexBorderColor( t, texObj->Sampler.BorderColor.f );
break;
case GL_TEXTURE_BASE_LEVEL:
_mesa_lookup_enum_by_nr(target), t);
_mesa_initialize_texture_object(&t->base, name, target);
- t->base.MaxAnisotropy = rmesa->radeon.initialMaxAnisotropy;
+ t->base.Sampler.MaxAnisotropy = rmesa->radeon.initialMaxAnisotropy;
/* Initialize hardware state */
- r200SetTexWrap( t, t->base.WrapS, t->base.WrapT, t->base.WrapR );
- r200SetTexMaxAnisotropy( t, t->base.MaxAnisotropy );
- r200SetTexFilter(t, t->base.MinFilter, t->base.MagFilter);
- r200SetTexBorderColor(t, t->base.BorderColor.f);
+ r200SetTexWrap( t, t->base.Sampler.WrapS, t->base.Sampler.WrapT, t->base.Sampler.WrapR );
+ r200SetTexMaxAnisotropy( t, t->base.Sampler.MaxAnisotropy );
+ r200SetTexFilter(t, t->base.Sampler.MinFilter, t->base.Sampler.MagFilter);
+ r200SetTexBorderColor(t, t->base.Sampler.BorderColor.f);
return &t->base;
}
if (fp->Base.ShadowSamplers & (1 << unit)) {
struct gl_texture_object* tex = r300->radeon.glCtx->Texture.Unit[unit]._Current;
- state->unit[unit].texture_swizzle = build_dts(tex->DepthMode);
- state->unit[unit].texture_compare_func = build_func(tex->CompareFunc);
+ state->unit[unit].texture_swizzle = build_dts(tex->Sampler.DepthMode);
+ state->unit[unit].texture_compare_func = build_func(tex->Sampler.CompareFunc);
}
}
}
*/
r300->hw.tex.filter_1.cmd[R300_TEX_VALUE_0 + hw_tmu] =
t->pp_txfilter_1 |
- translate_lod_bias(ctx->Texture.Unit[i].LodBias + t->base.LodBias);
+ translate_lod_bias(ctx->Texture.Unit[i].LodBias + t->base.Sampler.LodBias);
r300->hw.tex.size.cmd[R300_TEX_VALUE_0 + hw_tmu] =
t->pp_txsize;
r300->hw.tex.format.cmd[R300_TEX_VALUE_0 +
buffer[0] =
buffer[1] =
buffer[2] =
- buffer[3] = texObj->CompareFailValue;
+ buffer[3] = texObj->Sampler.CompareFailValue;
}
return buffer;
}
t->pp_txfilter &=
~(R300_TX_WRAP_S_MASK | R300_TX_WRAP_T_MASK | R300_TX_WRAP_R_MASK);
- t->pp_txfilter |= translate_wrap_mode(tObj->WrapS) << R300_TX_WRAP_S_SHIFT;
+ t->pp_txfilter |= translate_wrap_mode(tObj->Sampler.WrapS) << R300_TX_WRAP_S_SHIFT;
if (tObj->Target != GL_TEXTURE_1D) {
- t->pp_txfilter |= translate_wrap_mode(tObj->WrapT) << R300_TX_WRAP_T_SHIFT;
+ t->pp_txfilter |= translate_wrap_mode(tObj->Sampler.WrapT) << R300_TX_WRAP_T_SHIFT;
if (tObj->Target == GL_TEXTURE_3D)
- t->pp_txfilter |= translate_wrap_mode(tObj->WrapR) << R300_TX_WRAP_R_SHIFT;
+ t->pp_txfilter |= translate_wrap_mode(tObj->Sampler.WrapR) << R300_TX_WRAP_R_SHIFT;
}
}
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_MAG_FILTER:
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
- r300SetTexFilter(t, texObj->MinFilter, texObj->MagFilter, texObj->MaxAnisotropy);
+ r300SetTexFilter(t, texObj->Sampler.MinFilter, texObj->Sampler.MagFilter, texObj->Sampler.MaxAnisotropy);
break;
case GL_TEXTURE_WRAP_S:
break;
case GL_TEXTURE_BORDER_COLOR:
- r300SetTexBorderColor(t, texObj->BorderColor.f);
+ r300SetTexBorderColor(t, texObj->Sampler.BorderColor.f);
break;
case GL_TEXTURE_BASE_LEVEL:
}
_mesa_initialize_texture_object(&t->base, name, target);
- t->base.MaxAnisotropy = rmesa->radeon.initialMaxAnisotropy;
+ t->base.Sampler.MaxAnisotropy = rmesa->radeon.initialMaxAnisotropy;
/* Initialize hardware state */
r300UpdateTexWrap(t);
- r300SetTexFilter(t, t->base.MinFilter, t->base.MagFilter, t->base.MaxAnisotropy);
- r300SetTexBorderColor(t, t->base.BorderColor.f);
+ r300SetTexFilter(t, t->base.Sampler.MinFilter,
+ t->base.Sampler.MagFilter,
+ t->base.Sampler.MaxAnisotropy);
+ r300SetTexBorderColor(t, t->base.Sampler.BorderColor.f);
return &t->base;
}
return;
}
- switch (tObj->DepthMode) {
+ switch (tObj->Sampler.DepthMode) {
case GL_LUMINANCE:
t->pp_txformat = format[0];
break;
{
struct gl_texture_object *tObj = &t->base;
- SETfield(t->SQ_TEX_SAMPLER0, evergreen_translate_wrap_mode(tObj->WrapS),
+ SETfield(t->SQ_TEX_SAMPLER0, evergreen_translate_wrap_mode(tObj->Sampler.WrapS),
EG_SQ_TEX_SAMPLER_WORD0_0__CLAMP_X_shift,
EG_SQ_TEX_SAMPLER_WORD0_0__CLAMP_X_mask);
if (tObj->Target != GL_TEXTURE_1D)
{
- SETfield(t->SQ_TEX_SAMPLER0, evergreen_translate_wrap_mode(tObj->WrapT),
+ SETfield(t->SQ_TEX_SAMPLER0, evergreen_translate_wrap_mode(tObj->Sampler.WrapT),
EG_SQ_TEX_SAMPLER_WORD0_0__CLAMP_Y_shift,
EG_SQ_TEX_SAMPLER_WORD0_0__CLAMP_Y_mask);
if (tObj->Target == GL_TEXTURE_3D)
- SETfield(t->SQ_TEX_SAMPLER0, evergreen_translate_wrap_mode(tObj->WrapR),
+ SETfield(t->SQ_TEX_SAMPLER0, evergreen_translate_wrap_mode(tObj->Sampler.WrapR),
EG_SQ_TEX_SAMPLER_WORD0_0__CLAMP_Z_shift,
EG_SQ_TEX_SAMPLER_WORD0_0__CLAMP_Z_mask);
}
}
}
-static void evergreenSetTexBorderColor(radeonTexObjPtr t, const GLfloat color[4])
+static void evergreenSetTexSampler.BorderColor(radeonTexObjPtr t, const GLfloat color[4])
{
t->TD_PS_SAMPLER0_BORDER_ALPHA = *((uint32_t*)&(color[3]));
t->TD_PS_SAMPLER0_BORDER_RED = *((uint32_t*)&(color[2]));
evergreenSetTexDefaultState(t);
evergreenUpdateTexWrap(t);
- evergreenSetTexFilter(t, t->base.MinFilter, t->base.MagFilter, t->base.MaxAnisotropy);
- evergreenSetTexBorderColor(t, t->base.BorderColor.f);
+ evergreenSetTexFilter(t, t->base.Sampler.MinFilter, t->base.Sampler.MagFilter, t->base.MaxAnisotropy);
+ evergreenSetTexSampler.BorderColor(t, t->base.Sampler.BorderColor.f);
return &t->base;
}
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_MAG_FILTER:
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
- evergreenSetTexFilter(t, texObj->MinFilter, texObj->MagFilter, texObj->MaxAnisotropy);
+ evergreenSetTexFilter(t, texObj->Sampler.MinFilter, texObj->Sampler.MagFilter, texObj->MaxAnisotropy);
break;
case GL_TEXTURE_WRAP_S:
break;
case GL_TEXTURE_BORDER_COLOR:
- evergreenSetTexBorderColor(t, texObj->BorderColor.f);
+ evergreenSetTexSampler.BorderColor(t, texObj->Sampler.BorderColor.f);
break;
case GL_TEXTURE_BASE_LEVEL:
{
struct gl_texture_object *tObj = &t->base;
- SETfield(t->SQ_TEX_SAMPLER0, translate_wrap_mode(tObj->WrapS),
+ SETfield(t->SQ_TEX_SAMPLER0, translate_wrap_mode(tObj->Sampler.WrapS),
SQ_TEX_SAMPLER_WORD0_0__CLAMP_X_shift, SQ_TEX_SAMPLER_WORD0_0__CLAMP_X_mask);
if (tObj->Target != GL_TEXTURE_1D) {
- SETfield(t->SQ_TEX_SAMPLER0, translate_wrap_mode(tObj->WrapT),
+ SETfield(t->SQ_TEX_SAMPLER0, translate_wrap_mode(tObj->Sampler.WrapT),
CLAMP_Y_shift, CLAMP_Y_mask);
if (tObj->Target == GL_TEXTURE_3D)
- SETfield(t->SQ_TEX_SAMPLER0, translate_wrap_mode(tObj->WrapR),
+ SETfield(t->SQ_TEX_SAMPLER0, translate_wrap_mode(tObj->Sampler.WrapR),
CLAMP_Z_shift, CLAMP_Z_mask);
}
}
}
}
-static void r600SetTexBorderColor(radeonTexObjPtr t, const GLfloat color[4])
+static void r600SetTexSampler.BorderColor(radeonTexObjPtr t, const GLfloat color[4])
{
t->TD_PS_SAMPLER0_BORDER_ALPHA = *((uint32_t*)&(color[3]));
t->TD_PS_SAMPLER0_BORDER_BLUE = *((uint32_t*)&(color[2]));
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_MAG_FILTER:
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
- r600SetTexFilter(t, texObj->MinFilter, texObj->MagFilter, texObj->MaxAnisotropy);
+ r600SetTexFilter(t, texObj->Sampler.MinFilter, texObj->Sampler.MagFilter, texObj->MaxAnisotropy);
break;
case GL_TEXTURE_WRAP_S:
break;
case GL_TEXTURE_BORDER_COLOR:
- r600SetTexBorderColor(t, texObj->BorderColor.f);
+ r600SetTexSampler.BorderColor(t, texObj->Sampler.BorderColor.f);
break;
case GL_TEXTURE_BASE_LEVEL:
/* Initialize hardware state */
r600SetTexDefaultState(t);
r600UpdateTexWrap(t);
- r600SetTexFilter(t, t->base.MinFilter, t->base.MagFilter, t->base.MaxAnisotropy);
- r600SetTexBorderColor(t, t->base.BorderColor.f);
+ r600SetTexFilter(t, t->base.Sampler.MinFilter, t->base.Sampler.MagFilter, t->base.MaxAnisotropy);
+ r600SetTexSampler.BorderColor(t, t->base.Sampler.BorderColor.f);
return &t->base;
}
}
}
-static void r700SendTexBorderColorState(struct gl_context *ctx, struct radeon_state_atom *atom)
+static void r700SendTexSampler.BorderColorState(struct gl_context *ctx, struct radeon_state_atom *atom)
{
context_t *context = R700_CONTEXT(ctx);
R700_CHIP_CONTEXT *r700 = (R700_CHIP_CONTEXT*)(&context->hw);
ALLOC_STATE(vtx, vtx, (VERT_ATTRIB_MAX * 18), r700SendVTXState);
ALLOC_STATE(tx, tx, (R700_TEXTURE_NUMBERUNITS * 20), r700SendTexState);
ALLOC_STATE(tx_smplr, tx, (R700_TEXTURE_NUMBERUNITS * 5), r700SendTexSamplerState);
- ALLOC_STATE(tx_brdr_clr, tx, (R700_TEXTURE_NUMBERUNITS * 6), r700SendTexBorderColorState);
+ ALLOC_STATE(tx_brdr_clr, tx, (R700_TEXTURE_NUMBERUNITS * 6), r700SendTexSampler.BorderColorState);
r600_init_query_stateobj(&context->radeon, 6 * 2);
context->radeon.hw.is_dirty = GL_TRUE;
case GL_TEXTURE_2D:
case GL_TEXTURE_3D:
case GL_TEXTURE_CUBE_MAP:
- if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) {
+ if (tObj->Sampler.MinFilter == GL_NEAREST || tObj->Sampler.MinFilter == GL_LINEAR) {
/* GL_NEAREST and GL_LINEAR only care about GL_TEXTURE_BASE_LEVEL.
*/
minLod = maxLod = tObj->BaseLevel;
} else {
- minLod = tObj->BaseLevel + (GLint)(tObj->MinLod);
+ minLod = tObj->BaseLevel + (GLint)(tObj->Sampler.MinLod);
minLod = MAX2(minLod, tObj->BaseLevel);
minLod = MIN2(minLod, tObj->MaxLevel);
- maxLod = tObj->BaseLevel + (GLint)(tObj->MaxLod + 0.5);
+ maxLod = tObj->BaseLevel + (GLint)(tObj->Sampler.MaxLod + 0.5);
maxLod = MIN2(maxLod, tObj->MaxLevel);
maxLod = MIN2(maxLod, tObj->Image[0][minLod]->MaxLog2 + minLod);
maxLod = MAX2(maxLod, minLod); /* need at least one level */
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_MAG_FILTER:
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
- radeonSetTexMaxAnisotropy( t, texObj->MaxAnisotropy );
- radeonSetTexFilter( t, texObj->MinFilter, texObj->MagFilter );
+ radeonSetTexMaxAnisotropy( t, texObj->Sampler.MaxAnisotropy );
+ radeonSetTexFilter( t, texObj->Sampler.MinFilter, texObj->Sampler.MagFilter );
break;
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
- radeonSetTexWrap( t, texObj->WrapS, texObj->WrapT );
+ radeonSetTexWrap( t, texObj->Sampler.WrapS, texObj->Sampler.WrapT );
break;
case GL_TEXTURE_BORDER_COLOR:
- radeonSetTexBorderColor( t, texObj->BorderColor.f );
+ radeonSetTexBorderColor( t, texObj->Sampler.BorderColor.f );
break;
case GL_TEXTURE_BASE_LEVEL:
radeonTexObj* t = CALLOC_STRUCT(radeon_tex_obj);
_mesa_initialize_texture_object(&t->base, name, target);
- t->base.MaxAnisotropy = rmesa->radeon.initialMaxAnisotropy;
+ t->base.Sampler.MaxAnisotropy = rmesa->radeon.initialMaxAnisotropy;
t->border_fallback = GL_FALSE;
t->pp_txformat = (RADEON_TXFORMAT_ENDIAN_NO_SWAP |
RADEON_TXFORMAT_PERSPECTIVE_ENABLE);
- radeonSetTexWrap( t, t->base.WrapS, t->base.WrapT );
- radeonSetTexMaxAnisotropy( t, t->base.MaxAnisotropy );
- radeonSetTexFilter( t, t->base.MinFilter, t->base.MagFilter );
- radeonSetTexBorderColor( t, t->base.BorderColor.f );
+ radeonSetTexWrap( t, t->base.Sampler.WrapS, t->base.Sampler.WrapT );
+ radeonSetTexMaxAnisotropy( t, t->base.Sampler.MaxAnisotropy );
+ radeonSetTexFilter( t, t->base.Sampler.MinFilter, t->base.Sampler.MagFilter );
+ radeonSetTexBorderColor( t, t->base.Sampler.BorderColor.f );
return &t->base;
}
const GLbitfield reallyEnabled = ctx->Texture.Unit[i]._ReallyEnabled;
if (reallyEnabled) {
const struct gl_texture_object *texObj = ctx->Texture.Unit[i]._Current;
- const GLboolean normalizeS = (texObj->WrapS == GL_REPEAT);
+ const GLboolean normalizeS = (texObj->Sampler.WrapS == GL_REPEAT);
const GLboolean normalizeT = (reallyEnabled & TEXTURE_2D_BIT) &&
- (texObj->WrapT == GL_REPEAT);
+ (texObj->Sampler.WrapT == GL_REPEAT);
const GLfloat *in = (GLfloat *)VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]->data;
const GLint instride = VB->AttribPtr[_TNL_ATTRIB_TEX0 + i]->stride;
GLfloat (*out)[4] = store->texcoord[i].data;
GLuint flags = 0;
if (((ctx->Texture.Unit[0]._ReallyEnabled & (TEXTURE_1D_BIT|TEXTURE_2D_BIT)) &&
- (ctx->Texture.Unit[0]._Current->WrapS == GL_REPEAT)) ||
+ (ctx->Texture.Unit[0]._Current->Sampler.WrapS == GL_REPEAT)) ||
((ctx->Texture.Unit[0]._ReallyEnabled & TEXTURE_2D_BIT) &&
- (ctx->Texture.Unit[0]._Current->WrapT == GL_REPEAT)))
+ (ctx->Texture.Unit[0]._Current->Sampler.WrapT == GL_REPEAT)))
flags |= VERT_BIT_TEX0;
if (((ctx->Texture.Unit[1]._ReallyEnabled & (TEXTURE_1D_BIT|TEXTURE_2D_BIT)) &&
- (ctx->Texture.Unit[1]._Current->WrapS == GL_REPEAT)) ||
+ (ctx->Texture.Unit[1]._Current->Sampler.WrapS == GL_REPEAT)) ||
((ctx->Texture.Unit[1]._ReallyEnabled & TEXTURE_2D_BIT) &&
- (ctx->Texture.Unit[1]._Current->WrapT == GL_REPEAT)))
+ (ctx->Texture.Unit[1]._Current->Sampler.WrapT == GL_REPEAT)))
flags |= VERT_BIT_TEX1;
store->active = (flags != 0);
make_empty_list( &t->base );
- savageSetTexWrapping(t,texObj->WrapS,texObj->WrapT);
- savageSetTexFilter(t,texObj->MinFilter,texObj->MagFilter);
- savageSetTexBorderColor(t,texObj->BorderColor.f);
+ savageSetTexWrapping(t,texObj->Sampler.WrapS,texObj->Sampler.WrapT);
+ savageSetTexFilter(t,texObj->Sampler.MinFilter,texObj->Sampler.MagFilter);
+ savageSetTexBorderColor(t,texObj->Sampler.BorderColor.f);
}
return t;
switch (pname) {
case GL_TEXTURE_MIN_FILTER:
case GL_TEXTURE_MAG_FILTER:
- savageSetTexFilter(t,tObj->MinFilter,tObj->MagFilter);
+ savageSetTexFilter(t,tObj->Sampler.MinFilter,tObj->Sampler.MagFilter);
break;
case GL_TEXTURE_WRAP_S:
case GL_TEXTURE_WRAP_T:
- savageSetTexWrapping(t,tObj->WrapS,tObj->WrapT);
+ savageSetTexWrapping(t,tObj->Sampler.WrapS,tObj->Sampler.WrapT);
break;
case GL_TEXTURE_BORDER_COLOR:
- savageSetTexBorderColor(t,tObj->BorderColor.f);
+ savageSetTexBorderColor(t,tObj->Sampler.BorderColor.f);
break;
default:
current->texture[hw_unit].hwTextureMip = 0UL;
current->texture[hw_unit].hwTextureSet = t->hwformat;
- if ((texObj->MinFilter == GL_NEAREST) || (texObj->MinFilter == GL_LINEAR)) {
+ if ((texObj->Sampler.MinFilter == GL_NEAREST) || (texObj->Sampler.MinFilter == GL_LINEAR)) {
firstLevel = lastLevel = texObj->BaseLevel;
} else {
/* Compute which mipmap levels we really want to send to the hardware.
* Yes, this looks overly complicated, but it's all needed.
*/
- firstLevel = texObj->BaseLevel + (GLint)(texObj->MinLod + 0.5);
+ firstLevel = texObj->BaseLevel + (GLint)(texObj->Sampler.MinLod + 0.5);
firstLevel = MAX2(firstLevel, texObj->BaseLevel);
- lastLevel = texObj->BaseLevel + (GLint)(texObj->MaxLod + 0.5);
+ lastLevel = texObj->BaseLevel + (GLint)(texObj->Sampler.MaxLod + 0.5);
lastLevel = MAX2(lastLevel, texObj->BaseLevel);
lastLevel = MIN2(lastLevel, texObj->BaseLevel +
texObj->Image[0][texObj->BaseLevel]->MaxLog2);
current->texture[hw_unit].hwTextureSet |= (lastLevel << 8);
- switch (texObj->MagFilter)
+ switch (texObj->Sampler.MagFilter)
{
case GL_NEAREST:
current->texture[hw_unit].hwTextureMip |= TEXTURE_FILTER_NEAREST;
MASK_TextureMipmapLodBias);
}
- switch (texObj->MinFilter)
+ switch (texObj->Sampler.MinFilter)
{
case GL_NEAREST:
current->texture[hw_unit].hwTextureMip |= TEXTURE_FILTER_NEAREST;
break;
}
- switch (texObj->WrapS)
+ switch (texObj->Sampler.WrapS)
{
case GL_REPEAT:
current->texture[hw_unit].hwTextureSet |= MASK_TextureWrapU;
break;
}
- switch (texObj->WrapT)
+ switch (texObj->Sampler.WrapT)
{
case GL_REPEAT:
current->texture[hw_unit].hwTextureSet |= MASK_TextureWrapV;
{
GLubyte c[4];
- CLAMPED_FLOAT_TO_UBYTE(c[0], texObj->BorderColor.f[0]);
- CLAMPED_FLOAT_TO_UBYTE(c[1], texObj->BorderColor.f[1]);
- CLAMPED_FLOAT_TO_UBYTE(c[2], texObj->BorderColor.f[2]);
- CLAMPED_FLOAT_TO_UBYTE(c[3], texObj->BorderColor.f[3]);
+ CLAMPED_FLOAT_TO_UBYTE(c[0], texObj->Sampler.BorderColor.f[0]);
+ CLAMPED_FLOAT_TO_UBYTE(c[1], texObj->Sampler.BorderColor.f[1]);
+ CLAMPED_FLOAT_TO_UBYTE(c[2], texObj->Sampler.BorderColor.f[2]);
+ CLAMPED_FLOAT_TO_UBYTE(c[3], texObj->Sampler.BorderColor.f[3]);
current->texture[hw_unit].hwTextureBorderColor =
PACK_COLOR_8888(c[3], c[0], c[1], c[2]);
&(ti->sScale), &(ti->tScale), NULL, NULL);
}
- if (tObj->Image[0][maxl] && (tObj->MinFilter != GL_NEAREST) && (tObj->MinFilter != GL_LINEAR)) {
+ if (tObj->Image[0][maxl] && (tObj->Sampler.MinFilter != GL_NEAREST) && (tObj->Sampler.MinFilter != GL_LINEAR)) {
/* mipmapping: need to compute smallLodLog2 */
tdfxTexGetInfo(ctx, tObj->Image[0][maxl]->Width,
tObj->Image[0][maxl]->Height,
#endif
if (level == 0) {
/* don't use mipmap levels > 0 */
- tObj->MinFilter = tObj->MagFilter = GL_NEAREST;
+ tObj->Sampler.MinFilter = tObj->Sampler.MagFilter = GL_NEAREST;
}
else {
/* test with all mipmap levels */
- tObj->MinFilter = GL_LINEAR_MIPMAP_LINEAR;
- tObj->MagFilter = GL_NEAREST;
+ tObj->Sampler.MinFilter = GL_LINEAR_MIPMAP_LINEAR;
+ tObj->Sampler.MagFilter = GL_NEAREST;
}
RevalidateTexture(ctx, tObj);
if (texUnit0->_ReallyEnabled) {
struct gl_texture_object *texObj = texUnit0->_Current;
- vmesa->regHTXnTB[0] = get_minmag_filter( texObj->MinFilter,
- texObj->MagFilter );
+ vmesa->regHTXnTB[0] = get_minmag_filter( texObj->Sampler.MinFilter,
+ texObj->Sampler.MagFilter );
vmesa->regHTXnMPMD[0] &= ~(HC_HTXnMPMD_SMASK | HC_HTXnMPMD_TMASK);
- vmesa->regHTXnMPMD[0] |= get_wrap_mode( texObj->WrapS,
- texObj->WrapT );
+ vmesa->regHTXnMPMD[0] |= get_wrap_mode( texObj->Sampler.WrapS,
+ texObj->Sampler.WrapT );
vmesa->regHTXnTB[0] &= ~(HC_HTXnTB_TBC_S | HC_HTXnTB_TBC_T);
if (texObj->Image[0][texObj->BaseLevel]->Border > 0) {
vmesa->regHTXnTB[0] |= (HC_HTXnTB_TBC_S | HC_HTXnTB_TBC_T);
vmesa->regHTXnTBC[0] =
- PACK_COLOR_888(FLOAT_TO_UBYTE(texObj->BorderColor.f[0]),
- FLOAT_TO_UBYTE(texObj->BorderColor.f[1]),
- FLOAT_TO_UBYTE(texObj->BorderColor.f[2]));
- vmesa->regHTXnTRAH[0] = FLOAT_TO_UBYTE(texObj->BorderColor.f[3]);
+ PACK_COLOR_888(FLOAT_TO_UBYTE(texObj->Sampler.BorderColor.f[0]),
+ FLOAT_TO_UBYTE(texObj->Sampler.BorderColor.f[1]),
+ FLOAT_TO_UBYTE(texObj->Sampler.BorderColor.f[2]));
+ vmesa->regHTXnTRAH[0] = FLOAT_TO_UBYTE(texObj->Sampler.BorderColor.f[3]);
}
if (texUnit0->LodBias != 0.0f) {
if (texUnit1->_ReallyEnabled) {
struct gl_texture_object *texObj = texUnit1->_Current;
- vmesa->regHTXnTB[1] = get_minmag_filter( texObj->MinFilter,
- texObj->MagFilter );
+ vmesa->regHTXnTB[1] = get_minmag_filter( texObj->Sampler.MinFilter,
+ texObj->Sampler.MagFilter );
vmesa->regHTXnMPMD[1] &= ~(HC_HTXnMPMD_SMASK | HC_HTXnMPMD_TMASK);
- vmesa->regHTXnMPMD[1] |= get_wrap_mode( texObj->WrapS,
- texObj->WrapT );
+ vmesa->regHTXnMPMD[1] |= get_wrap_mode( texObj->Sampler.WrapS,
+ texObj->Sampler.WrapT );
vmesa->regHTXnTB[1] &= ~(HC_HTXnTB_TBC_S | HC_HTXnTB_TBC_T);
if (texObj->Image[0][texObj->BaseLevel]->Border > 0) {
vmesa->regHTXnTB[1] |= (HC_HTXnTB_TBC_S | HC_HTXnTB_TBC_T);
vmesa->regHTXnTBC[1] =
- PACK_COLOR_888(FLOAT_TO_UBYTE(texObj->BorderColor.f[0]),
- FLOAT_TO_UBYTE(texObj->BorderColor.f[1]),
- FLOAT_TO_UBYTE(texObj->BorderColor.f[2]));
- vmesa->regHTXnTRAH[1] = FLOAT_TO_UBYTE(texObj->BorderColor.f[3]);
+ PACK_COLOR_888(FLOAT_TO_UBYTE(texObj->Sampler.BorderColor.f[0]),
+ FLOAT_TO_UBYTE(texObj->Sampler.BorderColor.f[1]),
+ FLOAT_TO_UBYTE(texObj->Sampler.BorderColor.f[2]));
+ vmesa->regHTXnTRAH[1] = FLOAT_TO_UBYTE(texObj->Sampler.BorderColor.f[3]);
}
* GL_TEXTURE_MAX_LOD, GL_TEXTURE_BASE_LEVEL, and GL_TEXTURE_MAX_LEVEL.
* Yes, this looks overly complicated, but it's all needed.
*/
- if (texObj->MinFilter == GL_LINEAR || texObj->MinFilter == GL_NEAREST) {
+ if (texObj->Sampler.MinFilter == GL_LINEAR || texObj->Sampler.MinFilter == GL_NEAREST) {
firstLevel = lastLevel = texObj->BaseLevel;
}
else {
- firstLevel = texObj->BaseLevel + (GLint)(texObj->MinLod + 0.5);
+ firstLevel = texObj->BaseLevel + (GLint)(texObj->Sampler.MinLod + 0.5);
firstLevel = MAX2(firstLevel, texObj->BaseLevel);
- lastLevel = texObj->BaseLevel + (GLint)(texObj->MaxLod + 0.5);
+ lastLevel = texObj->BaseLevel + (GLint)(texObj->Sampler.MaxLod + 0.5);
lastLevel = MAX2(lastLevel, texObj->BaseLevel);
lastLevel = MIN2(lastLevel, texObj->BaseLevel + baseImage->image.MaxLog2);
lastLevel = MIN2(lastLevel, texObj->MaxLevel);
/* Restore texture object state for each target */
for (tgt = 0; tgt < NUM_TEXTURE_TARGETS; tgt++) {
const struct gl_texture_object *obj = NULL;
+ const struct gl_sampler_object *samp;
GLenum target;
obj = &texstate->SavedObj[u][tgt];
_mesa_BindTexture(target, obj->Name);
- _mesa_TexParameterfv(target, GL_TEXTURE_BORDER_COLOR, obj->BorderColor.f);
+ samp = &obj->Sampler;
+
+ _mesa_TexParameterfv(target, GL_TEXTURE_BORDER_COLOR, samp->BorderColor.f);
+ _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, samp->WrapS);
+ _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, samp->WrapT);
+ _mesa_TexParameteri(target, GL_TEXTURE_WRAP_R, samp->WrapR);
+ _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, samp->MinFilter);
+ _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, samp->MagFilter);
+ _mesa_TexParameterf(target, GL_TEXTURE_MIN_LOD, samp->MinLod);
+ _mesa_TexParameterf(target, GL_TEXTURE_MAX_LOD, samp->MaxLod);
+ _mesa_TexParameterf(target, GL_TEXTURE_LOD_BIAS, samp->LodBias);
_mesa_TexParameterf(target, GL_TEXTURE_PRIORITY, obj->Priority);
- _mesa_TexParameteri(target, GL_TEXTURE_WRAP_S, obj->WrapS);
- _mesa_TexParameteri(target, GL_TEXTURE_WRAP_T, obj->WrapT);
- _mesa_TexParameteri(target, GL_TEXTURE_WRAP_R, obj->WrapR);
- _mesa_TexParameteri(target, GL_TEXTURE_MIN_FILTER, obj->MinFilter);
- _mesa_TexParameteri(target, GL_TEXTURE_MAG_FILTER, obj->MagFilter);
- _mesa_TexParameterf(target, GL_TEXTURE_MIN_LOD, obj->MinLod);
- _mesa_TexParameterf(target, GL_TEXTURE_MAX_LOD, obj->MaxLod);
- _mesa_TexParameterf(target, GL_TEXTURE_LOD_BIAS, obj->LodBias);
_mesa_TexParameteri(target, GL_TEXTURE_BASE_LEVEL, obj->BaseLevel);
if (target != GL_TEXTURE_RECTANGLE_ARB)
_mesa_TexParameteri(target, GL_TEXTURE_MAX_LEVEL, obj->MaxLevel);
if (ctx->Extensions.EXT_texture_filter_anisotropic) {
_mesa_TexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT,
- obj->MaxAnisotropy);
+ samp->MaxAnisotropy);
}
if (ctx->Extensions.ARB_shadow_ambient) {
_mesa_TexParameterf(target, GL_TEXTURE_COMPARE_FAIL_VALUE_ARB,
- obj->CompareFailValue);
+ samp->CompareFailValue);
}
}
key->unit[i].source_index =
translate_tex_src_bit(texUnit->_ReallyEnabled);
- key->unit[i].shadow = ((texObj->CompareMode == GL_COMPARE_R_TO_TEXTURE) &&
- ((format == GL_DEPTH_COMPONENT) ||
- (format == GL_DEPTH_STENCIL_EXT)));
+ key->unit[i].shadow =
+ ((texObj->Sampler.CompareMode == GL_COMPARE_R_TO_TEXTURE) &&
+ ((format == GL_DEPTH_COMPONENT) ||
+ (format == GL_DEPTH_STENCIL_EXT)));
key->unit[i].NumArgsRGB = comb->_NumArgsRGB;
key->unit[i].NumArgsA = comb->_NumArgsA;
/**
- * Texture object state. Contains the array of mipmap images, border color,
- * wrap modes, filter modes, shadow/texcompare state, and the per-texture
- * color palette.
+ * Sampler object state. These objects are new with GL_ARB_sampler_objects
+ * and OpenGL 3.3. Legacy texture objects also contain a sampler object.
*/
-struct gl_texture_object
+struct gl_sampler_object
{
- _glthread_Mutex Mutex; /**< for thread safety */
- GLint RefCount; /**< reference count */
- GLuint Name; /**< the user-visible texture object ID */
- GLenum Target; /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */
- GLfloat Priority; /**< in [0,1] */
- union {
- GLfloat f[4];
- GLuint ui[4];
- GLint i[4];
- } BorderColor; /**< Interpreted according to texture format */
+ GLuint Name;
+ GLint RefCount;
+
GLenum WrapS; /**< S-axis texture image wrap mode */
GLenum WrapT; /**< T-axis texture image wrap mode */
GLenum WrapR; /**< R-axis texture image wrap mode */
GLenum MinFilter; /**< minification filter */
GLenum MagFilter; /**< magnification filter */
+ union {
+ GLfloat f[4];
+ GLuint ui[4];
+ GLint i[4];
+ } BorderColor; /**< Interpreted according to texture format */
GLfloat MinLod; /**< min lambda, OpenGL 1.2 */
GLfloat MaxLod; /**< max lambda, OpenGL 1.2 */
GLfloat LodBias; /**< OpenGL 1.4 */
- GLint BaseLevel; /**< min mipmap level, OpenGL 1.2 */
- GLint MaxLevel; /**< max mipmap level, OpenGL 1.2 */
GLfloat MaxAnisotropy; /**< GL_EXT_texture_filter_anisotropic */
GLenum CompareMode; /**< GL_ARB_shadow */
GLenum CompareFunc; /**< GL_ARB_shadow */
GLfloat CompareFailValue; /**< GL_ARB_shadow_ambient */
+ GLenum sRGBDecode; /**< GL_DECODE_EXT or GL_SKIP_DECODE_EXT */
+
+ /* deprecated sampler state */
GLenum DepthMode; /**< GL_ARB_depth_texture */
+
+ /** Is the texture object complete with respect to this sampler? */
+ GLboolean _CompleteTexture;
+};
+
+
+/**
+ * Texture object state. Contains the array of mipmap images, border color,
+ * wrap modes, filter modes, shadow/texcompare state, and the per-texture
+ * color palette.
+ */
+struct gl_texture_object
+{
+ _glthread_Mutex Mutex; /**< for thread safety */
+ GLint RefCount; /**< reference count */
+ GLuint Name; /**< the user-visible texture object ID */
+ GLenum Target; /**< GL_TEXTURE_1D, GL_TEXTURE_2D, etc. */
+
+ struct gl_sampler_object Sampler;
+
+ GLfloat Priority; /**< in [0,1] */
+ GLint BaseLevel; /**< min mipmap level, OpenGL 1.2 */
+ GLint MaxLevel; /**< max mipmap level, OpenGL 1.2 */
GLint _MaxLevel; /**< actual max mipmap level (q in the spec) */
GLfloat _MaxLambda; /**< = _MaxLevel - BaseLevel (q - b in spec) */
GLint CropRect[4]; /**< GL_OES_draw_texture */
GLboolean _Complete; /**< Is texture object complete? */
GLboolean _RenderToTexture; /**< Any rendering to this texture? */
GLboolean Purgeable; /**< Is the buffer purgeable under memory pressure? */
- GLenum sRGBDecode; /**< GL_DECODE_EXT or GL_SKIP_DECODE_EXT */
/** Actual texture images, indexed by [cube face] and [mipmap level] */
struct gl_texture_image *Image[MAX_FACES][MAX_TEXTURE_LEVELS];
GLenum BumpTarget;
GLfloat RotMatrix[4]; /* 2x2 matrix */
+ /** Current sampler object (GL_ARB_sampler_objects) */
+ struct gl_sampler_object *Sampler;
+
/**
* \name GL_EXT_texture_env_combine
*/
/* GL_ARB_sync */
struct simple_node SyncObjects;
+ /** GL_ARB_sampler_objects */
+ struct _mesa_HashTable *SamplerObjects;
+
void *DriverData; /**< Device driver shared state */
};
ASSERT(dims == 1 || dims == 2 || dims == 3);
- if (texImage->TexObject->sRGBDecode == GL_SKIP_DECODE_EXT &&
+ if (texImage->TexObject->Sampler.sRGBDecode == GL_SKIP_DECODE_EXT &&
_mesa_get_format_color_encoding(format) == GL_SRGB) {
format = _mesa_get_srgb_format_linear(format);
}
obj->Name = name;
obj->Target = target;
obj->Priority = 1.0F;
+ obj->BaseLevel = 0;
+ obj->MaxLevel = 1000;
+
+ /* sampler state */
if (target == GL_TEXTURE_RECTANGLE_NV) {
- obj->WrapS = GL_CLAMP_TO_EDGE;
- obj->WrapT = GL_CLAMP_TO_EDGE;
- obj->WrapR = GL_CLAMP_TO_EDGE;
- obj->MinFilter = GL_LINEAR;
+ obj->Sampler.WrapS = GL_CLAMP_TO_EDGE;
+ obj->Sampler.WrapT = GL_CLAMP_TO_EDGE;
+ obj->Sampler.WrapR = GL_CLAMP_TO_EDGE;
+ obj->Sampler.MinFilter = GL_LINEAR;
}
else {
- obj->WrapS = GL_REPEAT;
- obj->WrapT = GL_REPEAT;
- obj->WrapR = GL_REPEAT;
- obj->MinFilter = GL_NEAREST_MIPMAP_LINEAR;
+ obj->Sampler.WrapS = GL_REPEAT;
+ obj->Sampler.WrapT = GL_REPEAT;
+ obj->Sampler.WrapR = GL_REPEAT;
+ obj->Sampler.MinFilter = GL_NEAREST_MIPMAP_LINEAR;
}
- obj->MagFilter = GL_LINEAR;
- obj->MinLod = -1000.0;
- obj->MaxLod = 1000.0;
- obj->LodBias = 0.0;
- obj->BaseLevel = 0;
- obj->MaxLevel = 1000;
- obj->MaxAnisotropy = 1.0;
- obj->CompareMode = GL_NONE; /* ARB_shadow */
- obj->CompareFunc = GL_LEQUAL; /* ARB_shadow */
- obj->CompareFailValue = 0.0F; /* ARB_shadow_ambient */
- obj->DepthMode = GL_LUMINANCE; /* ARB_depth_texture */
+ obj->Sampler.MagFilter = GL_LINEAR;
+ obj->Sampler.MinLod = -1000.0;
+ obj->Sampler.MaxLod = 1000.0;
+ obj->Sampler.LodBias = 0.0;
+ obj->Sampler.MaxAnisotropy = 1.0;
+ obj->Sampler.CompareMode = GL_NONE; /* ARB_shadow */
+ obj->Sampler.CompareFunc = GL_LEQUAL; /* ARB_shadow */
+ obj->Sampler.CompareFailValue = 0.0F; /* ARB_shadow_ambient */
+ obj->Sampler.DepthMode = GL_LUMINANCE; /* ARB_depth_texture */
obj->Swizzle[0] = GL_RED;
obj->Swizzle[1] = GL_GREEN;
obj->Swizzle[2] = GL_BLUE;
obj->Swizzle[3] = GL_ALPHA;
obj->_Swizzle = SWIZZLE_NOOP;
- obj->sRGBDecode = GL_DECODE_EXT;
+ obj->Sampler.sRGBDecode = GL_DECODE_EXT;
}
if (target == GL_TEXTURE_RECTANGLE_NV) {
/* have to init wrap and filter state here - kind of klunky */
- obj->WrapS = GL_CLAMP_TO_EDGE;
- obj->WrapT = GL_CLAMP_TO_EDGE;
- obj->WrapR = GL_CLAMP_TO_EDGE;
- obj->MinFilter = GL_LINEAR;
+ obj->Sampler.WrapS = GL_CLAMP_TO_EDGE;
+ obj->Sampler.WrapT = GL_CLAMP_TO_EDGE;
+ obj->Sampler.WrapR = GL_CLAMP_TO_EDGE;
+ obj->Sampler.MinFilter = GL_LINEAR;
if (ctx->Driver.TexParameter) {
static const GLfloat fparam_wrap[1] = {(GLfloat) GL_CLAMP_TO_EDGE};
static const GLfloat fparam_filter[1] = {(GLfloat) GL_LINEAR};
dest->Target = src->Target;
dest->Name = src->Name;
dest->Priority = src->Priority;
- dest->BorderColor.f[0] = src->BorderColor.f[0];
- dest->BorderColor.f[1] = src->BorderColor.f[1];
- dest->BorderColor.f[2] = src->BorderColor.f[2];
- dest->BorderColor.f[3] = src->BorderColor.f[3];
- dest->WrapS = src->WrapS;
- dest->WrapT = src->WrapT;
- dest->WrapR = src->WrapR;
- dest->MinFilter = src->MinFilter;
- dest->MagFilter = src->MagFilter;
- dest->MinLod = src->MinLod;
- dest->MaxLod = src->MaxLod;
- dest->LodBias = src->LodBias;
+ dest->Sampler.BorderColor.f[0] = src->Sampler.BorderColor.f[0];
+ dest->Sampler.BorderColor.f[1] = src->Sampler.BorderColor.f[1];
+ dest->Sampler.BorderColor.f[2] = src->Sampler.BorderColor.f[2];
+ dest->Sampler.BorderColor.f[3] = src->Sampler.BorderColor.f[3];
+ dest->Sampler.WrapS = src->Sampler.WrapS;
+ dest->Sampler.WrapT = src->Sampler.WrapT;
+ dest->Sampler.WrapR = src->Sampler.WrapR;
+ dest->Sampler.MinFilter = src->Sampler.MinFilter;
+ dest->Sampler.MagFilter = src->Sampler.MagFilter;
+ dest->Sampler.MinLod = src->Sampler.MinLod;
+ dest->Sampler.MaxLod = src->Sampler.MaxLod;
+ dest->Sampler.LodBias = src->Sampler.LodBias;
dest->BaseLevel = src->BaseLevel;
dest->MaxLevel = src->MaxLevel;
- dest->MaxAnisotropy = src->MaxAnisotropy;
- dest->CompareMode = src->CompareMode;
- dest->CompareFunc = src->CompareFunc;
- dest->CompareFailValue = src->CompareFailValue;
- dest->DepthMode = src->DepthMode;
+ dest->Sampler.MaxAnisotropy = src->Sampler.MaxAnisotropy;
+ dest->Sampler.CompareMode = src->Sampler.CompareMode;
+ dest->Sampler.CompareFunc = src->Sampler.CompareFunc;
+ dest->Sampler.CompareFailValue = src->Sampler.CompareFailValue;
+ dest->Sampler.DepthMode = src->Sampler.DepthMode;
dest->_MaxLevel = src->_MaxLevel;
dest->_MaxLambda = src->_MaxLambda;
dest->GenerateMipmap = src->GenerateMipmap;
}
/* extra checking for mipmaps */
- if (t->MinFilter != GL_NEAREST && t->MinFilter != GL_LINEAR) {
+ if (t->Sampler.MinFilter != GL_NEAREST && t->Sampler.MinFilter != GL_LINEAR) {
/*
* Mipmapping: determine if we have a complete set of mipmaps
*/
/* create texture object */
texObj = ctx->Driver.NewTextureObject(ctx, 0, GL_TEXTURE_2D);
assert(texObj->RefCount == 1);
- texObj->MinFilter = GL_NEAREST;
- texObj->MagFilter = GL_NEAREST;
+ texObj->Sampler.MinFilter = GL_NEAREST;
+ texObj->Sampler.MagFilter = GL_NEAREST;
/* create level[0] texture image */
texImage = _mesa_get_tex_image(ctx, texObj, GL_TEXTURE_2D, 0);
{
switch (pname) {
case GL_TEXTURE_MIN_FILTER:
- if (texObj->MinFilter == params[0])
+ if (texObj->Sampler.MinFilter == params[0])
return GL_FALSE;
switch (params[0]) {
case GL_NEAREST:
case GL_LINEAR:
incomplete(ctx, texObj);
- texObj->MinFilter = params[0];
+ texObj->Sampler.MinFilter = params[0];
return GL_TRUE;
case GL_NEAREST_MIPMAP_NEAREST:
case GL_LINEAR_MIPMAP_NEAREST:
case GL_LINEAR_MIPMAP_LINEAR:
if (texObj->Target != GL_TEXTURE_RECTANGLE_NV) {
incomplete(ctx, texObj);
- texObj->MinFilter = params[0];
+ texObj->Sampler.MinFilter = params[0];
return GL_TRUE;
}
/* fall-through */
return GL_FALSE;
case GL_TEXTURE_MAG_FILTER:
- if (texObj->MagFilter == params[0])
+ if (texObj->Sampler.MagFilter == params[0])
return GL_FALSE;
switch (params[0]) {
case GL_NEAREST:
case GL_LINEAR:
flush(ctx); /* does not effect completeness */
- texObj->MagFilter = params[0];
+ texObj->Sampler.MagFilter = params[0];
return GL_TRUE;
default:
goto invalid_param;
return GL_FALSE;
case GL_TEXTURE_WRAP_S:
- if (texObj->WrapS == params[0])
+ if (texObj->Sampler.WrapS == params[0])
return GL_FALSE;
if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
flush(ctx);
- texObj->WrapS = params[0];
+ texObj->Sampler.WrapS = params[0];
return GL_TRUE;
}
return GL_FALSE;
case GL_TEXTURE_WRAP_T:
- if (texObj->WrapT == params[0])
+ if (texObj->Sampler.WrapT == params[0])
return GL_FALSE;
if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
flush(ctx);
- texObj->WrapT = params[0];
+ texObj->Sampler.WrapT = params[0];
return GL_TRUE;
}
return GL_FALSE;
case GL_TEXTURE_WRAP_R:
- if (texObj->WrapR == params[0])
+ if (texObj->Sampler.WrapR == params[0])
return GL_FALSE;
if (validate_texture_wrap_mode(ctx, texObj->Target, params[0])) {
flush(ctx);
- texObj->WrapR = params[0];
+ texObj->Sampler.WrapR = params[0];
return GL_TRUE;
}
return GL_FALSE;
case GL_TEXTURE_COMPARE_MODE_ARB:
if (ctx->Extensions.ARB_shadow) {
- if (texObj->CompareMode == params[0])
+ if (texObj->Sampler.CompareMode == params[0])
return GL_FALSE;
if (params[0] == GL_NONE ||
params[0] == GL_COMPARE_R_TO_TEXTURE_ARB) {
flush(ctx);
- texObj->CompareMode = params[0];
+ texObj->Sampler.CompareMode = params[0];
return GL_TRUE;
}
goto invalid_param;
case GL_TEXTURE_COMPARE_FUNC_ARB:
if (ctx->Extensions.ARB_shadow) {
- if (texObj->CompareFunc == params[0])
+ if (texObj->Sampler.CompareFunc == params[0])
return GL_FALSE;
switch (params[0]) {
case GL_LEQUAL:
case GL_GEQUAL:
flush(ctx);
- texObj->CompareFunc = params[0];
+ texObj->Sampler.CompareFunc = params[0];
return GL_TRUE;
case GL_EQUAL:
case GL_NOTEQUAL:
case GL_NEVER:
if (ctx->Extensions.EXT_shadow_funcs) {
flush(ctx);
- texObj->CompareFunc = params[0];
+ texObj->Sampler.CompareFunc = params[0];
return GL_TRUE;
}
/* fall-through */
case GL_DEPTH_TEXTURE_MODE_ARB:
if (ctx->Extensions.ARB_depth_texture) {
- if (texObj->DepthMode == params[0])
+ if (texObj->Sampler.DepthMode == params[0])
return GL_FALSE;
if (params[0] == GL_LUMINANCE ||
params[0] == GL_INTENSITY ||
params[0] == GL_ALPHA ||
(ctx->Extensions.ARB_texture_rg && params[0] == GL_RED)) {
flush(ctx);
- texObj->DepthMode = params[0];
+ texObj->Sampler.DepthMode = params[0];
return GL_TRUE;
}
goto invalid_param;
if (ctx->Extensions.EXT_texture_sRGB_decode) {
GLenum decode = params[0];
if (decode == GL_DECODE_EXT || decode == GL_SKIP_DECODE_EXT) {
- if (texObj->sRGBDecode != decode) {
+ if (texObj->Sampler.sRGBDecode != decode) {
flush(ctx);
- texObj->sRGBDecode = decode;
+ texObj->Sampler.sRGBDecode = decode;
_mesa_update_fetch_functions(texObj);
}
return GL_TRUE;
{
switch (pname) {
case GL_TEXTURE_MIN_LOD:
- if (texObj->MinLod == params[0])
+ if (texObj->Sampler.MinLod == params[0])
return GL_FALSE;
flush(ctx);
- texObj->MinLod = params[0];
+ texObj->Sampler.MinLod = params[0];
return GL_TRUE;
case GL_TEXTURE_MAX_LOD:
- if (texObj->MaxLod == params[0])
+ if (texObj->Sampler.MaxLod == params[0])
return GL_FALSE;
flush(ctx);
- texObj->MaxLod = params[0];
+ texObj->Sampler.MaxLod = params[0];
return GL_TRUE;
case GL_TEXTURE_PRIORITY:
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
if (ctx->Extensions.EXT_texture_filter_anisotropic) {
- if (texObj->MaxAnisotropy == params[0])
+ if (texObj->Sampler.MaxAnisotropy == params[0])
return GL_FALSE;
if (params[0] < 1.0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glTexParameter(param)" );
}
flush(ctx);
/* clamp to max, that's what NVIDIA does */
- texObj->MaxAnisotropy = MIN2(params[0],
+ texObj->Sampler.MaxAnisotropy = MIN2(params[0],
ctx->Const.MaxTextureMaxAnisotropy);
return GL_TRUE;
}
case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
if (ctx->Extensions.ARB_shadow_ambient) {
- if (texObj->CompareFailValue != params[0]) {
+ if (texObj->Sampler.CompareFailValue != params[0]) {
flush(ctx);
- texObj->CompareFailValue = CLAMP(params[0], 0.0F, 1.0F);
+ texObj->Sampler.CompareFailValue = CLAMP(params[0], 0.0F, 1.0F);
return GL_TRUE;
}
}
case GL_TEXTURE_LOD_BIAS:
/* NOTE: this is really part of OpenGL 1.4, not EXT_texture_lod_bias */
if (ctx->Extensions.EXT_texture_lod_bias) {
- if (texObj->LodBias != params[0]) {
+ if (texObj->Sampler.LodBias != params[0]) {
flush(ctx);
- texObj->LodBias = params[0];
+ texObj->Sampler.LodBias = params[0];
return GL_TRUE;
}
return GL_FALSE;
flush(ctx);
/* ARB_texture_float disables clamping */
if (ctx->Extensions.ARB_texture_float) {
- texObj->BorderColor.f[RCOMP] = params[0];
- texObj->BorderColor.f[GCOMP] = params[1];
- texObj->BorderColor.f[BCOMP] = params[2];
- texObj->BorderColor.f[ACOMP] = params[3];
+ texObj->Sampler.BorderColor.f[RCOMP] = params[0];
+ texObj->Sampler.BorderColor.f[GCOMP] = params[1];
+ texObj->Sampler.BorderColor.f[BCOMP] = params[2];
+ texObj->Sampler.BorderColor.f[ACOMP] = params[3];
} else {
- texObj->BorderColor.f[RCOMP] = CLAMP(params[0], 0.0F, 1.0F);
- texObj->BorderColor.f[GCOMP] = CLAMP(params[1], 0.0F, 1.0F);
- texObj->BorderColor.f[BCOMP] = CLAMP(params[2], 0.0F, 1.0F);
- texObj->BorderColor.f[ACOMP] = CLAMP(params[3], 0.0F, 1.0F);
+ texObj->Sampler.BorderColor.f[RCOMP] = CLAMP(params[0], 0.0F, 1.0F);
+ texObj->Sampler.BorderColor.f[GCOMP] = CLAMP(params[1], 0.0F, 1.0F);
+ texObj->Sampler.BorderColor.f[BCOMP] = CLAMP(params[2], 0.0F, 1.0F);
+ texObj->Sampler.BorderColor.f[ACOMP] = CLAMP(params[3], 0.0F, 1.0F);
}
return GL_TRUE;
case GL_TEXTURE_BORDER_COLOR:
FLUSH_VERTICES(ctx, _NEW_TEXTURE);
/* set the integer-valued border color */
- COPY_4V(texObj->BorderColor.i, params);
+ COPY_4V(texObj->Sampler.BorderColor.i, params);
break;
default:
_mesa_TexParameteriv(target, pname, params);
case GL_TEXTURE_BORDER_COLOR:
FLUSH_VERTICES(ctx, _NEW_TEXTURE);
/* set the unsigned integer-valued border color */
- COPY_4V(texObj->BorderColor.ui, params);
+ COPY_4V(texObj->Sampler.BorderColor.ui, params);
break;
default:
_mesa_TexParameteriv(target, pname, (const GLint *) params);
_mesa_lock_texture(ctx, obj);
switch (pname) {
case GL_TEXTURE_MAG_FILTER:
- *params = ENUM_TO_FLOAT(obj->MagFilter);
+ *params = ENUM_TO_FLOAT(obj->Sampler.MagFilter);
break;
case GL_TEXTURE_MIN_FILTER:
- *params = ENUM_TO_FLOAT(obj->MinFilter);
+ *params = ENUM_TO_FLOAT(obj->Sampler.MinFilter);
break;
case GL_TEXTURE_WRAP_S:
- *params = ENUM_TO_FLOAT(obj->WrapS);
+ *params = ENUM_TO_FLOAT(obj->Sampler.WrapS);
break;
case GL_TEXTURE_WRAP_T:
- *params = ENUM_TO_FLOAT(obj->WrapT);
+ *params = ENUM_TO_FLOAT(obj->Sampler.WrapT);
break;
case GL_TEXTURE_WRAP_R:
- *params = ENUM_TO_FLOAT(obj->WrapR);
+ *params = ENUM_TO_FLOAT(obj->Sampler.WrapR);
break;
case GL_TEXTURE_BORDER_COLOR:
if(ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP))
_mesa_update_state_locked(ctx);
if(ctx->Color._ClampFragmentColor)
{
- params[0] = CLAMP(obj->BorderColor.f[0], 0.0F, 1.0F);
- params[1] = CLAMP(obj->BorderColor.f[1], 0.0F, 1.0F);
- params[2] = CLAMP(obj->BorderColor.f[2], 0.0F, 1.0F);
- params[3] = CLAMP(obj->BorderColor.f[3], 0.0F, 1.0F);
+ params[0] = CLAMP(obj->Sampler.BorderColor.f[0], 0.0F, 1.0F);
+ params[1] = CLAMP(obj->Sampler.BorderColor.f[1], 0.0F, 1.0F);
+ params[2] = CLAMP(obj->Sampler.BorderColor.f[2], 0.0F, 1.0F);
+ params[3] = CLAMP(obj->Sampler.BorderColor.f[3], 0.0F, 1.0F);
}
else
{
- params[0] = obj->BorderColor.f[0];
- params[1] = obj->BorderColor.f[1];
- params[2] = obj->BorderColor.f[2];
- params[3] = obj->BorderColor.f[3];
+ params[0] = obj->Sampler.BorderColor.f[0];
+ params[1] = obj->Sampler.BorderColor.f[1];
+ params[2] = obj->Sampler.BorderColor.f[2];
+ params[3] = obj->Sampler.BorderColor.f[3];
}
break;
case GL_TEXTURE_RESIDENT:
*params = obj->Priority;
break;
case GL_TEXTURE_MIN_LOD:
- *params = obj->MinLod;
+ *params = obj->Sampler.MinLod;
break;
case GL_TEXTURE_MAX_LOD:
- *params = obj->MaxLod;
+ *params = obj->Sampler.MaxLod;
break;
case GL_TEXTURE_BASE_LEVEL:
*params = (GLfloat) obj->BaseLevel;
break;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
if (ctx->Extensions.EXT_texture_filter_anisotropic) {
- *params = obj->MaxAnisotropy;
+ *params = obj->Sampler.MaxAnisotropy;
}
else
error = GL_TRUE;
break;
case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
if (ctx->Extensions.ARB_shadow_ambient) {
- *params = obj->CompareFailValue;
+ *params = obj->Sampler.CompareFailValue;
}
else
error = GL_TRUE;
break;
case GL_TEXTURE_COMPARE_MODE_ARB:
if (ctx->Extensions.ARB_shadow) {
- *params = (GLfloat) obj->CompareMode;
+ *params = (GLfloat) obj->Sampler.CompareMode;
}
else
error = GL_TRUE;
break;
case GL_TEXTURE_COMPARE_FUNC_ARB:
if (ctx->Extensions.ARB_shadow) {
- *params = (GLfloat) obj->CompareFunc;
+ *params = (GLfloat) obj->Sampler.CompareFunc;
}
else
error = GL_TRUE;
break;
case GL_DEPTH_TEXTURE_MODE_ARB:
if (ctx->Extensions.ARB_depth_texture) {
- *params = (GLfloat) obj->DepthMode;
+ *params = (GLfloat) obj->Sampler.DepthMode;
}
else
error = GL_TRUE;
break;
case GL_TEXTURE_LOD_BIAS:
if (ctx->Extensions.EXT_texture_lod_bias) {
- *params = obj->LodBias;
+ *params = obj->Sampler.LodBias;
}
else
error = GL_TRUE;
_mesa_lock_texture(ctx, obj);
switch (pname) {
case GL_TEXTURE_MAG_FILTER:
- *params = (GLint) obj->MagFilter;
+ *params = (GLint) obj->Sampler.MagFilter;
break;;
case GL_TEXTURE_MIN_FILTER:
- *params = (GLint) obj->MinFilter;
+ *params = (GLint) obj->Sampler.MinFilter;
break;;
case GL_TEXTURE_WRAP_S:
- *params = (GLint) obj->WrapS;
+ *params = (GLint) obj->Sampler.WrapS;
break;;
case GL_TEXTURE_WRAP_T:
- *params = (GLint) obj->WrapT;
+ *params = (GLint) obj->Sampler.WrapT;
break;;
case GL_TEXTURE_WRAP_R:
- *params = (GLint) obj->WrapR;
+ *params = (GLint) obj->Sampler.WrapR;
break;;
case GL_TEXTURE_BORDER_COLOR:
{
GLfloat b[4];
- b[0] = CLAMP(obj->BorderColor.f[0], 0.0F, 1.0F);
- b[1] = CLAMP(obj->BorderColor.f[1], 0.0F, 1.0F);
- b[2] = CLAMP(obj->BorderColor.f[2], 0.0F, 1.0F);
- b[3] = CLAMP(obj->BorderColor.f[3], 0.0F, 1.0F);
+ b[0] = CLAMP(obj->Sampler.BorderColor.f[0], 0.0F, 1.0F);
+ b[1] = CLAMP(obj->Sampler.BorderColor.f[1], 0.0F, 1.0F);
+ b[2] = CLAMP(obj->Sampler.BorderColor.f[2], 0.0F, 1.0F);
+ b[3] = CLAMP(obj->Sampler.BorderColor.f[3], 0.0F, 1.0F);
params[0] = FLOAT_TO_INT(b[0]);
params[1] = FLOAT_TO_INT(b[1]);
params[2] = FLOAT_TO_INT(b[2]);
*params = FLOAT_TO_INT(obj->Priority);
break;;
case GL_TEXTURE_MIN_LOD:
- *params = (GLint) obj->MinLod;
+ *params = (GLint) obj->Sampler.MinLod;
break;;
case GL_TEXTURE_MAX_LOD:
- *params = (GLint) obj->MaxLod;
+ *params = (GLint) obj->Sampler.MaxLod;
break;;
case GL_TEXTURE_BASE_LEVEL:
*params = obj->BaseLevel;
break;;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
if (ctx->Extensions.EXT_texture_filter_anisotropic) {
- *params = (GLint) obj->MaxAnisotropy;
+ *params = (GLint) obj->Sampler.MaxAnisotropy;
}
else {
error = GL_TRUE;
break;
case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
if (ctx->Extensions.ARB_shadow_ambient) {
- *params = (GLint) FLOAT_TO_INT(obj->CompareFailValue);
+ *params = (GLint) FLOAT_TO_INT(obj->Sampler.CompareFailValue);
}
else {
error = GL_TRUE;
break;
case GL_TEXTURE_COMPARE_MODE_ARB:
if (ctx->Extensions.ARB_shadow) {
- *params = (GLint) obj->CompareMode;
+ *params = (GLint) obj->Sampler.CompareMode;
}
else {
error = GL_TRUE;
break;
case GL_TEXTURE_COMPARE_FUNC_ARB:
if (ctx->Extensions.ARB_shadow) {
- *params = (GLint) obj->CompareFunc;
+ *params = (GLint) obj->Sampler.CompareFunc;
}
else {
error = GL_TRUE;
break;
case GL_DEPTH_TEXTURE_MODE_ARB:
if (ctx->Extensions.ARB_depth_texture) {
- *params = (GLint) obj->DepthMode;
+ *params = (GLint) obj->Sampler.DepthMode;
}
else {
error = GL_TRUE;
break;
case GL_TEXTURE_LOD_BIAS:
if (ctx->Extensions.EXT_texture_lod_bias) {
- *params = (GLint) obj->LodBias;
+ *params = (GLint) obj->Sampler.LodBias;
}
else {
error = GL_TRUE;
switch (pname) {
case GL_TEXTURE_BORDER_COLOR:
- COPY_4V(params, texObj->BorderColor.i);
+ COPY_4V(params, texObj->Sampler.BorderColor.i);
break;
default:
_mesa_GetTexParameteriv(target, pname, params);
switch (pname) {
case GL_TEXTURE_BORDER_COLOR:
- COPY_4V(params, texObj->BorderColor.i);
+ COPY_4V(params, texObj->Sampler.BorderColor.i);
break;
default:
{
}
else if (format == GL_DEPTH_COMPONENT ||
format == GL_DEPTH_STENCIL_EXT) {
- format = texObj->DepthMode;
+ format = texObj->Sampler.DepthMode;
}
calculate_derived_texenv(&texUnit->_EnvMode, texUnit->EnvMode, format);
texUnit->_CurrentCombine = & texUnit->_EnvMode;
/* GL_ARB_texture_buffer_object */
_mesa_reference_buffer_object(ctx, &ctx->Texture.BufferObject, NULL);
+
+#if FEATURE_sampler_objects
+ for (u = 0; u < Elements(ctx->Texture.Unit); u++) {
+ _mesa_reference_sampler_object(ctx, &ctx->Texture.Unit[u].Sampler, NULL);
+ }
+#endif
}
value[0] =
value[1] =
value[2] =
- value[3] = texObj->CompareFailValue;
+ value[3] = texObj->Sampler.CompareFailValue;
}
}
return;
#include "st_cb_texture.h"
#include "st_format.h"
#include "st_atom.h"
+#include "st_texture.h"
#include "pipe/p_context.h"
#include "pipe/p_defines.h"
if (samplersUsed & (1 << su)) {
struct gl_texture_object *texobj;
struct gl_texture_image *teximg;
+ struct gl_sampler_object *msamp;
GLuint texUnit;
if (fprog->Base.SamplersUsed & (1 << su))
teximg = texobj->Image[0][texobj->BaseLevel];
- sampler->wrap_s = gl_wrap_xlate(texobj->WrapS);
- sampler->wrap_t = gl_wrap_xlate(texobj->WrapT);
- sampler->wrap_r = gl_wrap_xlate(texobj->WrapR);
+ msamp = st_get_mesa_sampler(st->ctx, texUnit);
- sampler->min_img_filter = gl_filter_to_img_filter(texobj->MinFilter);
- sampler->min_mip_filter = gl_filter_to_mip_filter(texobj->MinFilter);
- sampler->mag_img_filter = gl_filter_to_img_filter(texobj->MagFilter);
+ sampler->wrap_s = gl_wrap_xlate(msamp->WrapS);
+ sampler->wrap_t = gl_wrap_xlate(msamp->WrapT);
+ sampler->wrap_r = gl_wrap_xlate(msamp->WrapR);
+
+ sampler->min_img_filter = gl_filter_to_img_filter(msamp->MinFilter);
+ sampler->min_mip_filter = gl_filter_to_mip_filter(msamp->MinFilter);
+ sampler->mag_img_filter = gl_filter_to_img_filter(msamp->MagFilter);
if (texobj->Target != GL_TEXTURE_RECTANGLE_ARB)
sampler->normalized_coords = 1;
sampler->lod_bias = st->ctx->Texture.Unit[texUnit].LodBias +
- texobj->LodBias;
+ msamp->LodBias;
- sampler->min_lod = CLAMP(texobj->MinLod,
+ sampler->min_lod = CLAMP(msamp->MinLod,
0.0f,
(GLfloat) texobj->MaxLevel - texobj->BaseLevel);
sampler->max_lod = MIN2((GLfloat) texobj->MaxLevel - texobj->BaseLevel,
- texobj->MaxLod);
+ msamp->MaxLod);
if (sampler->max_lod < sampler->min_lod) {
/* The GL spec doesn't seem to specify what to do in this case.
* Swap the values.
assert(sampler->min_lod <= sampler->max_lod);
}
- st_translate_color(texobj->BorderColor.f,
+ st_translate_color(msamp->BorderColor.f,
teximg ? teximg->_BaseFormat : GL_RGBA,
sampler->border_color);
- sampler->max_anisotropy = (texobj->MaxAnisotropy == 1.0 ? 0 : (GLuint)texobj->MaxAnisotropy);
+ sampler->max_anisotropy = (msamp->MaxAnisotropy == 1.0 ?
+ 0 : (GLuint) msamp->MaxAnisotropy);
/* only care about ARB_shadow, not SGI shadow */
- if (texobj->CompareMode == GL_COMPARE_R_TO_TEXTURE) {
+ if (msamp->CompareMode == GL_COMPARE_R_TO_TEXTURE) {
sampler->compare_mode = PIPE_TEX_COMPARE_R_TO_TEXTURE;
sampler->compare_func
- = st_compare_func_to_pipe(texobj->CompareFunc);
+ = st_compare_func_to_pipe(msamp->CompareFunc);
}
st->state.num_samplers = su + 1;
static INLINE struct pipe_sampler_view *
st_create_texture_sampler_view_from_stobj(struct pipe_context *pipe,
struct st_texture_object *stObj,
+ const struct gl_sampler_object *samp,
enum pipe_format format)
{
struct pipe_sampler_view templ;
GLuint swizzle = apply_depthmode(stObj->pt->format,
stObj->base._Swizzle,
- stObj->base.DepthMode);
+ samp->DepthMode);
u_sampler_view_default_template(&templ,
stObj->pt,
static INLINE struct pipe_sampler_view *
st_get_texture_sampler_view_from_stobj(struct st_texture_object *stObj,
struct pipe_context *pipe,
+ const struct gl_sampler_object *samp,
enum pipe_format format)
{
if (!stObj || !stObj->pt) {
if (!stObj->sampler_view) {
stObj->sampler_view =
- st_create_texture_sampler_view_from_stobj(pipe, stObj, format);
+ st_create_texture_sampler_view_from_stobj(pipe, stObj, samp, format);
}
return stObj->sampler_view;
struct st_texture_object *stObj;
GLboolean retval;
GLuint texUnit;
+ const struct gl_sampler_object *samp;
if (fprog->Base.SamplersUsed & (1 << su))
texUnit = fprog->Base.SamplerUnits[su];
else
texUnit = vprog->Base.SamplerUnits[su];
+ samp = st_get_mesa_sampler(st->ctx, texUnit);
+
texObj = st->ctx->Texture.Unit[texUnit]._Current;
if (!texObj) {
texObj = st_get_default_texture(st);
+ samp = &texObj->Sampler;
}
stObj = st_texture_object(texObj);
enum pipe_format firstImageFormat =
st_mesa_format_to_pipe_format(texFormat);
- if ((stObj->base.sRGBDecode == GL_SKIP_DECODE_EXT) &&
+ if ((samp->sRGBDecode == GL_SKIP_DECODE_EXT) &&
(_mesa_get_format_color_encoding(texFormat) == GL_SRGB)) {
/* don't do sRGB->RGB conversion. Interpret the texture
* texture data as linear values.
if (stObj->sampler_view)
if (check_sampler_swizzle(stObj->sampler_view,
stObj->base._Swizzle,
- stObj->base.DepthMode) ||
+ samp->DepthMode) ||
(st_view_format != stObj->sampler_view->format) ||
stObj->base.BaseLevel != stObj->sampler_view->u.tex.first_level)
pipe_sampler_view_reference(&stObj->sampler_view, NULL);
- sampler_view = st_get_texture_sampler_view_from_stobj(stObj, pipe, st_view_format);
+ sampler_view = st_get_texture_sampler_view_from_stobj(stObj, pipe,
+ samp,
+ st_view_format);
}
pipe_sampler_view_reference(&st->state.sampler_views[su], sampler_view);
}
* to re-allocating a texture buffer with space for more (or fewer)
* mipmap levels later.
*/
- if ((stObj->base.MinFilter == GL_NEAREST ||
- stObj->base.MinFilter == GL_LINEAR ||
+ if ((stObj->base.Sampler.MinFilter == GL_NEAREST ||
+ stObj->base.Sampler.MinFilter == GL_LINEAR ||
stImage->base._BaseFormat == GL_DEPTH_COMPONENT ||
stImage->base._BaseFormat == GL_DEPTH_STENCIL_EXT) &&
!stObj->base.GenerateMipmap &&
* incomplete. In that case, we'll have set stObj->lastLevel before
* we get here.
*/
- if (stObj->base.MinFilter == GL_LINEAR ||
- stObj->base.MinFilter == GL_NEAREST)
+ if (stObj->base.Sampler.MinFilter == GL_LINEAR ||
+ stObj->base.Sampler.MinFilter == GL_NEAREST)
stObj->lastLevel = stObj->base.BaseLevel;
else
stObj->lastLevel = stObj->base._MaxLevel;
texObj, texImg,
0, 0);
- texObj->MinFilter = GL_NEAREST;
- texObj->MagFilter = GL_NEAREST;
+ texObj->Sampler.MinFilter = GL_NEAREST;
+ texObj->Sampler.MagFilter = GL_NEAREST;
texObj->_Complete = GL_TRUE;
st->default_texture = texObj;
}
+/**
+ * Get pointer to the active sampler object for the given texture unit.
+ * This will either be a user-defined sampler object or the texture
+ * object's own sampler state.
+ */
+static INLINE struct gl_sampler_object *
+st_get_mesa_sampler(const struct gl_context *ctx, GLuint unit)
+{
+ if (ctx->Texture.Unit[unit].Sampler)
+ return ctx->Texture.Unit[unit].Sampler;
+ else
+ return &ctx->Texture.Unit[unit]._Current->Sampler;
+}
+
+
extern struct pipe_resource *
st_texture_create(struct st_context *st,
enum pipe_texture_target target,
SWcontext *swrast = SWRAST_CONTEXT(ctx);
GLfloat rgba[4];
- lambda = CLAMP(lambda, texObj->MinLod, texObj->MaxLod);
+ lambda = CLAMP(lambda, texObj->Sampler.MinLod, texObj->Sampler.MaxLod);
swrast->TextureSample[unit](ctx, texObj, 1,
(const GLfloat (*)[4]) texcoord,
texcoord[0], texcoord[1], texcoord[3],
1.0F / texcoord[3]);
- lambda += lodBias + texUnit->LodBias + texObj->LodBias;
+ lambda += lodBias + texUnit->LodBias + texObj->Sampler.LodBias;
- lambda = CLAMP(lambda, texObj->MinLod, texObj->MaxLod);
+ lambda = CLAMP(lambda, texObj->Sampler.MinLod, texObj->Sampler.MaxLod);
swrast->TextureSample[unit](ctx, texObj, 1,
(const GLfloat (*)[4]) texcoord,
if (obj) {
const struct gl_texture_image *img = obj->Image[0][obj->BaseLevel];
- needLambda = (obj->MinFilter != obj->MagFilter)
+ needLambda = (obj->Sampler.MinFilter != obj->Sampler.MagFilter)
|| ctx->FragmentProgram._Current;
texW = img->WidthScale;
texH = img->HeightScale;
/* adjust texture lod (lambda) */
if (span->arrayMask & SPAN_LAMBDA) {
- if (texUnit->LodBias + curObj->LodBias != 0.0F) {
+ if (texUnit->LodBias + curObj->Sampler.LodBias != 0.0F) {
/* apply LOD bias, but don't clamp yet */
- const GLfloat bias = CLAMP(texUnit->LodBias + curObj->LodBias,
+ const GLfloat bias = CLAMP(texUnit->LodBias + curObj->Sampler.LodBias,
-ctx->Const.MaxTextureLodBias,
ctx->Const.MaxTextureLodBias);
GLuint i;
}
}
- if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) {
+ if (curObj->Sampler.MinLod != -1000.0 ||
+ curObj->Sampler.MaxLod != 1000.0) {
/* apply LOD clamping to lambda */
- const GLfloat min = curObj->MinLod;
- const GLfloat max = curObj->MaxLod;
+ const GLfloat min = curObj->Sampler.MinLod;
+ const GLfloat max = curObj->Sampler.MaxLod;
GLuint i;
for (i = 0; i < span->end; i++) {
GLfloat l = lambda[i];
/* adjust texture lod (lambda) */
if (span->arrayMask & SPAN_LAMBDA) {
- if (texUnit->LodBias + curObj->LodBias != 0.0F) {
+ if (texUnit->LodBias + curObj->Sampler.LodBias != 0.0F) {
/* apply LOD bias, but don't clamp yet */
- const GLfloat bias = CLAMP(texUnit->LodBias + curObj->LodBias,
+ const GLfloat bias = CLAMP(texUnit->LodBias + curObj->Sampler.LodBias,
-ctx->Const.MaxTextureLodBias,
ctx->Const.MaxTextureLodBias);
GLuint i;
}
}
- if (curObj->MinLod != -1000.0 || curObj->MaxLod != 1000.0) {
+ if (curObj->Sampler.MinLod != -1000.0 ||
+ curObj->Sampler.MaxLod != 1000.0) {
/* apply LOD clamping to lambda */
- const GLfloat min = curObj->MinLod;
- const GLfloat max = curObj->MaxLod;
+ const GLfloat min = curObj->Sampler.MinLod;
+ const GLfloat max = curObj->Sampler.MaxLod;
GLuint i;
for (i = 0; i < span->end; i++) {
GLfloat l = lambda[i];
switch (texObj->Target) {
case GL_TEXTURE_RECTANGLE_ARB:
- *i = clamp_rect_coord_nearest(texObj->WrapS, texcoord[0], width);
- *j = clamp_rect_coord_nearest(texObj->WrapT, texcoord[1], height);
+ *i = clamp_rect_coord_nearest(texObj->Sampler.WrapS, texcoord[0], width);
+ *j = clamp_rect_coord_nearest(texObj->Sampler.WrapT, texcoord[1], height);
*k = 0;
break;
case GL_TEXTURE_1D:
- *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);
+ *i = nearest_texel_location(texObj->Sampler.WrapS, img, width, texcoord[0]);
*j = 0;
*k = 0;
break;
case GL_TEXTURE_2D:
- *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);
- *j = nearest_texel_location(texObj->WrapT, img, height, texcoord[1]);
+ *i = nearest_texel_location(texObj->Sampler.WrapS, img, width, texcoord[0]);
+ *j = nearest_texel_location(texObj->Sampler.WrapT, img, height, texcoord[1]);
*k = 0;
break;
case GL_TEXTURE_1D_ARRAY_EXT:
- *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);
+ *i = nearest_texel_location(texObj->Sampler.WrapS, img, width, texcoord[0]);
*j = tex_array_slice(texcoord[1], height);
*k = 0;
break;
case GL_TEXTURE_2D_ARRAY_EXT:
- *i = nearest_texel_location(texObj->WrapS, img, width, texcoord[0]);
- *j = nearest_texel_location(texObj->WrapT, img, height, texcoord[1]);
+ *i = nearest_texel_location(texObj->Sampler.WrapS, img, width, texcoord[0]);
+ *j = nearest_texel_location(texObj->Sampler.WrapT, img, height, texcoord[1]);
*k = tex_array_slice(texcoord[2], depth);
break;
default:
switch (texObj->Target) {
case GL_TEXTURE_RECTANGLE_ARB:
- clamp_rect_coord_linear(texObj->WrapS, texcoord[0],
+ clamp_rect_coord_linear(texObj->Sampler.WrapS, texcoord[0],
width, i0, i1, wi);
- clamp_rect_coord_linear(texObj->WrapT, texcoord[1],
+ clamp_rect_coord_linear(texObj->Sampler.WrapT, texcoord[1],
height, j0, j1, wj);
*slice = 0;
break;
case GL_TEXTURE_1D:
case GL_TEXTURE_2D:
- linear_texel_locations(texObj->WrapS, img, width,
+ linear_texel_locations(texObj->Sampler.WrapS, img, width,
texcoord[0], i0, i1, wi);
- linear_texel_locations(texObj->WrapT, img, height,
+ linear_texel_locations(texObj->Sampler.WrapT, img, height,
texcoord[1], j0, j1, wj);
*slice = 0;
break;
case GL_TEXTURE_1D_ARRAY_EXT:
- linear_texel_locations(texObj->WrapS, img, width,
+ linear_texel_locations(texObj->Sampler.WrapS, img, width,
texcoord[0], i0, i1, wi);
*j0 = tex_array_slice(texcoord[1], height);
*j1 = *j0;
break;
case GL_TEXTURE_2D_ARRAY_EXT:
- linear_texel_locations(texObj->WrapS, img, width,
+ linear_texel_locations(texObj->Sampler.WrapS, img, width,
texcoord[0], i0, i1, wi);
- linear_texel_locations(texObj->WrapT, img, height,
+ linear_texel_locations(texObj->Sampler.WrapT, img, height,
texcoord[1], j0, j1, wj);
*slice = tex_array_slice(texcoord[2], depth);
break;
GLfloat minMagThresh;
/* we shouldn't be here if minfilter == magfilter */
- ASSERT(tObj->MinFilter != tObj->MagFilter);
+ ASSERT(tObj->Sampler.MinFilter != tObj->Sampler.MagFilter);
/* This bit comes from the OpenGL spec: */
- if (tObj->MagFilter == GL_LINEAR
- && (tObj->MinFilter == GL_NEAREST_MIPMAP_NEAREST ||
- tObj->MinFilter == GL_NEAREST_MIPMAP_LINEAR)) {
+ if (tObj->Sampler.MagFilter == GL_LINEAR
+ && (tObj->Sampler.MinFilter == GL_NEAREST_MIPMAP_NEAREST ||
+ tObj->Sampler.MinFilter == GL_NEAREST_MIPMAP_LINEAR)) {
minMagThresh = 0.5F;
}
else {
{
switch (img->_BaseFormat) {
case GL_RGB:
- rgba[0] = tObj->BorderColor.f[0];
- rgba[1] = tObj->BorderColor.f[1];
- rgba[2] = tObj->BorderColor.f[2];
+ rgba[0] = tObj->Sampler.BorderColor.f[0];
+ rgba[1] = tObj->Sampler.BorderColor.f[1];
+ rgba[2] = tObj->Sampler.BorderColor.f[2];
rgba[3] = 1.0F;
break;
case GL_ALPHA:
rgba[0] = rgba[1] = rgba[2] = 0.0;
- rgba[3] = tObj->BorderColor.f[3];
+ rgba[3] = tObj->Sampler.BorderColor.f[3];
break;
case GL_LUMINANCE:
- rgba[0] = rgba[1] = rgba[2] = tObj->BorderColor.f[0];
+ rgba[0] = rgba[1] = rgba[2] = tObj->Sampler.BorderColor.f[0];
rgba[3] = 1.0;
break;
case GL_LUMINANCE_ALPHA:
- rgba[0] = rgba[1] = rgba[2] = tObj->BorderColor.f[0];
- rgba[3] = tObj->BorderColor.f[3];
+ rgba[0] = rgba[1] = rgba[2] = tObj->Sampler.BorderColor.f[0];
+ rgba[3] = tObj->Sampler.BorderColor.f[3];
break;
case GL_INTENSITY:
- rgba[0] = rgba[1] = rgba[2] = rgba[3] = tObj->BorderColor.f[0];
+ rgba[0] = rgba[1] = rgba[2] = rgba[3] = tObj->Sampler.BorderColor.f[0];
break;
default:
- COPY_4V(rgba, tObj->BorderColor.f);
+ COPY_4V(rgba, tObj->Sampler.BorderColor.f);
}
}
{
const GLint width = img->Width2; /* without border, power of two */
GLint i;
- i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
+ i = nearest_texel_location(tObj->Sampler.WrapS, img, width, texcoord[0]);
/* skip over the border, if any */
i += img->Border;
if (i < 0 || i >= (GLint) img->Width) {
GLfloat a;
GLfloat t0[4], t1[4]; /* texels */
- linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a);
+ linear_texel_locations(tObj->Sampler.WrapS, img, width, texcoord[0], &i0, &i1, &a);
if (img->Border) {
i0 += img->Border;
if (minStart < minEnd) {
/* do the minified texels */
const GLuint m = minEnd - minStart;
- switch (tObj->MinFilter) {
+ switch (tObj->Sampler.MinFilter) {
case GL_NEAREST:
for (i = minStart; i < minEnd; i++)
sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
if (magStart < magEnd) {
/* do the magnified texels */
- switch (tObj->MagFilter) {
+ switch (tObj->Sampler.MagFilter) {
case GL_NEAREST:
for (i = magStart; i < magEnd; i++)
sample_1d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
GLint i, j;
(void) ctx;
- i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
- j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);
+ i = nearest_texel_location(tObj->Sampler.WrapS, img, width, texcoord[0]);
+ j = nearest_texel_location(tObj->Sampler.WrapT, img, height, texcoord[1]);
/* skip over the border, if any */
i += img->Border;
GLfloat a, b;
GLfloat t00[4], t10[4], t01[4], t11[4]; /* sampled texel colors */
- linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a);
- linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);
+ linear_texel_locations(tObj->Sampler.WrapS, img, width, texcoord[0], &i0, &i1, &a);
+ linear_texel_locations(tObj->Sampler.WrapT, img, height, texcoord[1], &j0, &j1, &b);
if (img->Border) {
i0 += img->Border;
(void) ctx;
- ASSERT(tObj->WrapS == GL_REPEAT);
- ASSERT(tObj->WrapT == GL_REPEAT);
+ ASSERT(tObj->Sampler.WrapS == GL_REPEAT);
+ ASSERT(tObj->Sampler.WrapT == GL_REPEAT);
ASSERT(img->Border == 0);
ASSERT(img->_BaseFormat != GL_COLOR_INDEX);
ASSERT(img->_IsPowerOfTwo);
{
GLuint i;
ASSERT(lambda != NULL);
- ASSERT(tObj->WrapS == GL_REPEAT);
- ASSERT(tObj->WrapT == GL_REPEAT);
+ ASSERT(tObj->Sampler.WrapS == GL_REPEAT);
+ ASSERT(tObj->Sampler.WrapT == GL_REPEAT);
for (i = 0; i < n; i++) {
GLint level = linear_mipmap_level(tObj, lambda[i]);
if (level >= tObj->_MaxLevel) {
GLuint i;
struct gl_texture_image *image = tObj->Image[0][tObj->BaseLevel];
(void) lambda;
- if (tObj->WrapS == GL_REPEAT &&
- tObj->WrapT == GL_REPEAT &&
+ if (tObj->Sampler.WrapS == GL_REPEAT &&
+ tObj->Sampler.WrapT == GL_REPEAT &&
image->_IsPowerOfTwo &&
image->Border == 0) {
for (i = 0; i < n; i++) {
GLuint k;
(void) ctx;
(void) lambda;
- ASSERT(tObj->WrapS==GL_REPEAT);
- ASSERT(tObj->WrapT==GL_REPEAT);
+ ASSERT(tObj->Sampler.WrapS==GL_REPEAT);
+ ASSERT(tObj->Sampler.WrapT==GL_REPEAT);
ASSERT(img->Border==0);
ASSERT(img->TexFormat == MESA_FORMAT_RGB888);
ASSERT(img->_IsPowerOfTwo);
GLuint i;
(void) ctx;
(void) lambda;
- ASSERT(tObj->WrapS==GL_REPEAT);
- ASSERT(tObj->WrapT==GL_REPEAT);
+ ASSERT(tObj->Sampler.WrapS==GL_REPEAT);
+ ASSERT(tObj->Sampler.WrapT==GL_REPEAT);
ASSERT(img->Border==0);
ASSERT(img->TexFormat == MESA_FORMAT_RGBA8888);
ASSERT(img->_IsPowerOfTwo);
GLuint minStart, minEnd; /* texels with minification */
GLuint magStart, magEnd; /* texels with magnification */
- const GLboolean repeatNoBorderPOT = (tObj->WrapS == GL_REPEAT)
- && (tObj->WrapT == GL_REPEAT)
+ const GLboolean repeatNoBorderPOT = (tObj->Sampler.WrapS == GL_REPEAT)
+ && (tObj->Sampler.WrapT == GL_REPEAT)
&& (tImg->Border == 0 && (tImg->Width == tImg->RowStride))
&& (tImg->_BaseFormat != GL_COLOR_INDEX)
&& tImg->_IsPowerOfTwo;
if (minStart < minEnd) {
/* do the minified texels */
const GLuint m = minEnd - minStart;
- switch (tObj->MinFilter) {
+ switch (tObj->Sampler.MinFilter) {
case GL_NEAREST:
if (repeatNoBorderPOT) {
switch (tImg->TexFormat) {
/* do the magnified texels */
const GLuint m = magEnd - magStart;
- switch (tObj->MagFilter) {
+ switch (tObj->Sampler.MagFilter) {
case GL_NEAREST:
if (repeatNoBorderPOT) {
switch (tImg->TexFormat) {
GLint i, j, k;
(void) ctx;
- i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
- j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);
- k = nearest_texel_location(tObj->WrapR, img, depth, texcoord[2]);
+ i = nearest_texel_location(tObj->Sampler.WrapS, img, width, texcoord[0]);
+ j = nearest_texel_location(tObj->Sampler.WrapT, img, height, texcoord[1]);
+ k = nearest_texel_location(tObj->Sampler.WrapR, img, depth, texcoord[2]);
if (i < 0 || i >= (GLint) img->Width ||
j < 0 || j >= (GLint) img->Height ||
GLfloat t000[4], t010[4], t001[4], t011[4];
GLfloat t100[4], t110[4], t101[4], t111[4];
- linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a);
- linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);
- linear_texel_locations(tObj->WrapR, img, depth, texcoord[2], &k0, &k1, &c);
+ linear_texel_locations(tObj->Sampler.WrapS, img, width, texcoord[0], &i0, &i1, &a);
+ linear_texel_locations(tObj->Sampler.WrapT, img, height, texcoord[1], &j0, &j1, &b);
+ linear_texel_locations(tObj->Sampler.WrapR, img, depth, texcoord[2], &k0, &k1, &c);
if (img->Border) {
i0 += img->Border;
if (minStart < minEnd) {
/* do the minified texels */
GLuint m = minEnd - minStart;
- switch (tObj->MinFilter) {
+ switch (tObj->Sampler.MinFilter) {
case GL_NEAREST:
for (i = minStart; i < minEnd; i++)
sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
if (magStart < magEnd) {
/* do the magnified texels */
- switch (tObj->MagFilter) {
+ switch (tObj->Sampler.MagFilter) {
case GL_NEAREST:
for (i = magStart; i < magEnd; i++)
sample_3d_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
if (minStart < minEnd) {
/* do the minified texels */
const GLuint m = minEnd - minStart;
- switch (tObj->MinFilter) {
+ switch (tObj->Sampler.MinFilter) {
case GL_NEAREST:
sample_nearest_cube(ctx, tObj, m, texcoords + minStart,
lambda + minStart, rgba + minStart);
if (magStart < magEnd) {
/* do the magnified texels */
const GLuint m = magEnd - magStart;
- switch (tObj->MagFilter) {
+ switch (tObj->Sampler.MagFilter) {
case GL_NEAREST:
sample_nearest_cube(ctx, tObj, m, texcoords + magStart,
lambda + magStart, rgba + magStart);
(void) ctx;
(void) lambda;
- ASSERT(tObj->WrapS == GL_CLAMP ||
- tObj->WrapS == GL_CLAMP_TO_EDGE ||
- tObj->WrapS == GL_CLAMP_TO_BORDER);
- ASSERT(tObj->WrapT == GL_CLAMP ||
- tObj->WrapT == GL_CLAMP_TO_EDGE ||
- tObj->WrapT == GL_CLAMP_TO_BORDER);
+ ASSERT(tObj->Sampler.WrapS == GL_CLAMP ||
+ tObj->Sampler.WrapS == GL_CLAMP_TO_EDGE ||
+ tObj->Sampler.WrapS == GL_CLAMP_TO_BORDER);
+ ASSERT(tObj->Sampler.WrapT == GL_CLAMP ||
+ tObj->Sampler.WrapT == GL_CLAMP_TO_EDGE ||
+ tObj->Sampler.WrapT == GL_CLAMP_TO_BORDER);
ASSERT(img->_BaseFormat != GL_COLOR_INDEX);
for (i = 0; i < n; i++) {
GLint row, col;
- col = clamp_rect_coord_nearest(tObj->WrapS, texcoords[i][0], width);
- row = clamp_rect_coord_nearest(tObj->WrapT, texcoords[i][1], height);
+ col = clamp_rect_coord_nearest(tObj->Sampler.WrapS, texcoords[i][0], width);
+ row = clamp_rect_coord_nearest(tObj->Sampler.WrapT, texcoords[i][1], height);
if (col < 0 || col >= width || row < 0 || row >= height)
get_border_color(tObj, img, rgba[i]);
else
(void) ctx;
(void) lambda;
- ASSERT(tObj->WrapS == GL_CLAMP ||
- tObj->WrapS == GL_CLAMP_TO_EDGE ||
- tObj->WrapS == GL_CLAMP_TO_BORDER);
- ASSERT(tObj->WrapT == GL_CLAMP ||
- tObj->WrapT == GL_CLAMP_TO_EDGE ||
- tObj->WrapT == GL_CLAMP_TO_BORDER);
+ ASSERT(tObj->Sampler.WrapS == GL_CLAMP ||
+ tObj->Sampler.WrapS == GL_CLAMP_TO_EDGE ||
+ tObj->Sampler.WrapS == GL_CLAMP_TO_BORDER);
+ ASSERT(tObj->Sampler.WrapT == GL_CLAMP ||
+ tObj->Sampler.WrapT == GL_CLAMP_TO_EDGE ||
+ tObj->Sampler.WrapT == GL_CLAMP_TO_BORDER);
ASSERT(img->_BaseFormat != GL_COLOR_INDEX);
for (i = 0; i < n; i++) {
GLfloat a, b;
GLbitfield useBorderColor = 0x0;
- clamp_rect_coord_linear(tObj->WrapS, texcoords[i][0], width,
+ clamp_rect_coord_linear(tObj->Sampler.WrapS, texcoords[i][0], width,
&i0, &i1, &a);
- clamp_rect_coord_linear(tObj->WrapT, texcoords[i][1], height,
+ clamp_rect_coord_linear(tObj->Sampler.WrapT, texcoords[i][1], height,
&j0, &j1, &b);
/* compute integer rows/columns */
&minStart, &minEnd, &magStart, &magEnd);
if (minStart < minEnd) {
- if (tObj->MinFilter == GL_NEAREST) {
+ if (tObj->Sampler.MinFilter == GL_NEAREST) {
sample_nearest_rect(ctx, tObj, minEnd - minStart,
texcoords + minStart, NULL, rgba + minStart);
}
}
}
if (magStart < magEnd) {
- if (tObj->MagFilter == GL_NEAREST) {
+ if (tObj->Sampler.MagFilter == GL_NEAREST) {
sample_nearest_rect(ctx, tObj, magEnd - magStart,
texcoords + magStart, NULL, rgba + magStart);
}
GLint array;
(void) ctx;
- i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
- j = nearest_texel_location(tObj->WrapT, img, height, texcoord[1]);
+ i = nearest_texel_location(tObj->Sampler.WrapS, img, width, texcoord[0]);
+ j = nearest_texel_location(tObj->Sampler.WrapT, img, height, texcoord[1]);
array = tex_array_slice(texcoord[2], depth);
if (i < 0 || i >= (GLint) img->Width ||
GLfloat a, b;
GLfloat t00[4], t01[4], t10[4], t11[4];
- linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a);
- linear_texel_locations(tObj->WrapT, img, height, texcoord[1], &j0, &j1, &b);
+ linear_texel_locations(tObj->Sampler.WrapS, img, width, texcoord[0], &i0, &i1, &a);
+ linear_texel_locations(tObj->Sampler.WrapT, img, height, texcoord[1], &j0, &j1, &b);
array = tex_array_slice(texcoord[2], depth);
if (array < 0 || array >= depth) {
- COPY_4V(rgba, tObj->BorderColor.f);
+ COPY_4V(rgba, tObj->Sampler.BorderColor.f);
}
else {
if (img->Border) {
if (minStart < minEnd) {
/* do the minified texels */
GLuint m = minEnd - minStart;
- switch (tObj->MinFilter) {
+ switch (tObj->Sampler.MinFilter) {
case GL_NEAREST:
for (i = minStart; i < minEnd; i++)
sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
if (magStart < magEnd) {
/* do the magnified texels */
- switch (tObj->MagFilter) {
+ switch (tObj->Sampler.MagFilter) {
case GL_NEAREST:
for (i = magStart; i < magEnd; i++)
sample_2d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
GLint array;
(void) ctx;
- i = nearest_texel_location(tObj->WrapS, img, width, texcoord[0]);
+ i = nearest_texel_location(tObj->Sampler.WrapS, img, width, texcoord[0]);
array = tex_array_slice(texcoord[1], height);
if (i < 0 || i >= (GLint) img->Width ||
GLfloat a;
GLfloat t0[4], t1[4];
- linear_texel_locations(tObj->WrapS, img, width, texcoord[0], &i0, &i1, &a);
+ linear_texel_locations(tObj->Sampler.WrapS, img, width, texcoord[0], &i0, &i1, &a);
array = tex_array_slice(texcoord[1], height);
if (img->Border) {
if (minStart < minEnd) {
/* do the minified texels */
GLuint m = minEnd - minStart;
- switch (tObj->MinFilter) {
+ switch (tObj->Sampler.MinFilter) {
case GL_NEAREST:
for (i = minStart; i < minEnd; i++)
sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
if (magStart < magEnd) {
/* do the magnified texels */
- switch (tObj->MagFilter) {
+ switch (tObj->Sampler.MagFilter) {
case GL_NEAREST:
for (i = magStart; i < magEnd; i++)
sample_1d_array_nearest(ctx, tObj, tObj->Image[0][tObj->BaseLevel],
{
GLint level;
- if (tObj->MinFilter == GL_NEAREST || tObj->MinFilter == GL_LINEAR) {
+ if (tObj->Sampler.MinFilter == GL_NEAREST || tObj->Sampler.MinFilter == GL_LINEAR) {
/* no mipmapping - use base level */
level = tObj->BaseLevel;
}
else {
/* choose mipmap level */
- lambda = CLAMP(lambda, tObj->MinLod, tObj->MaxLod);
+ lambda = CLAMP(lambda, tObj->Sampler.MinLod, tObj->Sampler.MaxLod);
level = (GLint) lambda;
level = CLAMP(level, tObj->BaseLevel, tObj->_MaxLevel);
}
tObj->Target == GL_TEXTURE_1D_ARRAY_EXT ||
tObj->Target == GL_TEXTURE_2D_ARRAY_EXT);
- ambient = tObj->CompareFailValue;
+ ambient = tObj->Sampler.CompareFailValue;
- /* XXXX if tObj->MinFilter != tObj->MagFilter, we're ignoring lambda */
+ /* XXXX if tObj->Sampler.MinFilter != tObj->Sampler.MagFilter, we're ignoring lambda */
- function = (tObj->CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) ?
- tObj->CompareFunc : GL_NONE;
+ function = (tObj->Sampler.CompareMode == GL_COMPARE_R_TO_TEXTURE_ARB) ?
+ tObj->Sampler.CompareFunc : GL_NONE;
- if (tObj->MagFilter == GL_NEAREST) {
+ if (tObj->Sampler.MagFilter == GL_NEAREST) {
GLuint i;
for (i = 0; i < n; i++) {
GLfloat depthSample, depthRef;
img->FetchTexelf(img, col, row, slice, &depthSample);
}
else {
- depthSample = tObj->BorderColor.f[0];
+ depthSample = tObj->Sampler.BorderColor.f[0];
}
depthRef = CLAMP(texcoords[i][compare_coord], 0.0F, 1.0F);
result = shadow_compare(function, depthRef, depthSample, ambient);
- switch (tObj->DepthMode) {
+ switch (tObj->Sampler.DepthMode) {
case GL_LUMINANCE:
ASSIGN_4V(texel[i], result, result, result, 1.0F);
break;
}
else {
GLuint i;
- ASSERT(tObj->MagFilter == GL_LINEAR);
+ ASSERT(tObj->Sampler.MagFilter == GL_LINEAR);
for (i = 0; i < n; i++) {
GLfloat depth00, depth01, depth10, depth11, depthRef;
GLint i0, i1, j0, j1;
}
if (slice < 0 || slice >= (GLint) depth) {
- depth00 = tObj->BorderColor.f[0];
- depth01 = tObj->BorderColor.f[0];
- depth10 = tObj->BorderColor.f[0];
- depth11 = tObj->BorderColor.f[0];
+ depth00 = tObj->Sampler.BorderColor.f[0];
+ depth01 = tObj->Sampler.BorderColor.f[0];
+ depth10 = tObj->Sampler.BorderColor.f[0];
+ depth11 = tObj->Sampler.BorderColor.f[0];
}
else {
/* get four depth samples from the texture */
if (useBorderTexel & (I0BIT | J0BIT)) {
- depth00 = tObj->BorderColor.f[0];
+ depth00 = tObj->Sampler.BorderColor.f[0];
}
else {
img->FetchTexelf(img, i0, j0, slice, &depth00);
}
if (useBorderTexel & (I1BIT | J0BIT)) {
- depth10 = tObj->BorderColor.f[0];
+ depth10 = tObj->Sampler.BorderColor.f[0];
}
else {
img->FetchTexelf(img, i1, j0, slice, &depth10);
if (tObj->Target != GL_TEXTURE_1D_ARRAY_EXT) {
if (useBorderTexel & (I0BIT | J1BIT)) {
- depth01 = tObj->BorderColor.f[0];
+ depth01 = tObj->Sampler.BorderColor.f[0];
}
else {
img->FetchTexelf(img, i0, j1, slice, &depth01);
}
if (useBorderTexel & (I1BIT | J1BIT)) {
- depth11 = tObj->BorderColor.f[0];
+ depth11 = tObj->Sampler.BorderColor.f[0];
}
else {
img->FetchTexelf(img, i1, j1, slice, &depth11);
depth00, depth01, depth10, depth11,
ambient, wi, wj);
- switch (tObj->DepthMode) {
+ switch (tObj->Sampler.DepthMode) {
case GL_LUMINANCE:
ASSIGN_4V(texel[i], result, result, result, 1.0F);
break;
return &null_sample_func;
}
else {
- const GLboolean needLambda = (GLboolean) (t->MinFilter != t->MagFilter);
+ const GLboolean needLambda =
+ (GLboolean) (t->Sampler.MinFilter != t->Sampler.MagFilter);
const GLenum format = t->Image[0][t->BaseLevel]->_BaseFormat;
switch (t->Target) {
else if (needLambda) {
return &sample_lambda_1d;
}
- else if (t->MinFilter == GL_LINEAR) {
+ else if (t->Sampler.MinFilter == GL_LINEAR) {
return &sample_linear_1d;
}
else {
- ASSERT(t->MinFilter == GL_NEAREST);
+ ASSERT(t->Sampler.MinFilter == GL_NEAREST);
return &sample_nearest_1d;
}
case GL_TEXTURE_2D:
else if (needLambda) {
return &sample_lambda_2d;
}
- else if (t->MinFilter == GL_LINEAR) {
+ else if (t->Sampler.MinFilter == GL_LINEAR) {
return &sample_linear_2d;
}
else {
/* check for a few optimized cases */
const struct gl_texture_image *img = t->Image[0][t->BaseLevel];
- ASSERT(t->MinFilter == GL_NEAREST);
- if (t->WrapS == GL_REPEAT &&
- t->WrapT == GL_REPEAT &&
+ ASSERT(t->Sampler.MinFilter == GL_NEAREST);
+ if (t->Sampler.WrapS == GL_REPEAT &&
+ t->Sampler.WrapT == GL_REPEAT &&
img->_IsPowerOfTwo &&
img->Border == 0 &&
img->TexFormat == MESA_FORMAT_RGB888) {
return &opt_sample_rgb_2d;
}
- else if (t->WrapS == GL_REPEAT &&
- t->WrapT == GL_REPEAT &&
+ else if (t->Sampler.WrapS == GL_REPEAT &&
+ t->Sampler.WrapT == GL_REPEAT &&
img->_IsPowerOfTwo &&
img->Border == 0 &&
img->TexFormat == MESA_FORMAT_RGBA8888) {
if (needLambda) {
return &sample_lambda_3d;
}
- else if (t->MinFilter == GL_LINEAR) {
+ else if (t->Sampler.MinFilter == GL_LINEAR) {
return &sample_linear_3d;
}
else {
- ASSERT(t->MinFilter == GL_NEAREST);
+ ASSERT(t->Sampler.MinFilter == GL_NEAREST);
return &sample_nearest_3d;
}
case GL_TEXTURE_CUBE_MAP:
if (needLambda) {
return &sample_lambda_cube;
}
- else if (t->MinFilter == GL_LINEAR) {
+ else if (t->Sampler.MinFilter == GL_LINEAR) {
return &sample_linear_cube;
}
else {
- ASSERT(t->MinFilter == GL_NEAREST);
+ ASSERT(t->Sampler.MinFilter == GL_NEAREST);
return &sample_nearest_cube;
}
case GL_TEXTURE_RECTANGLE_NV:
else if (needLambda) {
return &sample_lambda_rect;
}
- else if (t->MinFilter == GL_LINEAR) {
+ else if (t->Sampler.MinFilter == GL_LINEAR) {
return &sample_linear_rect;
}
else {
- ASSERT(t->MinFilter == GL_NEAREST);
+ ASSERT(t->Sampler.MinFilter == GL_NEAREST);
return &sample_nearest_rect;
}
case GL_TEXTURE_1D_ARRAY_EXT:
if (needLambda) {
return &sample_lambda_1d_array;
}
- else if (t->MinFilter == GL_LINEAR) {
+ else if (t->Sampler.MinFilter == GL_LINEAR) {
return &sample_linear_1d_array;
}
else {
- ASSERT(t->MinFilter == GL_NEAREST);
+ ASSERT(t->Sampler.MinFilter == GL_NEAREST);
return &sample_nearest_1d_array;
}
case GL_TEXTURE_2D_ARRAY_EXT:
if (needLambda) {
return &sample_lambda_2d_array;
}
- else if (t->MinFilter == GL_LINEAR) {
+ else if (t->Sampler.MinFilter == GL_LINEAR) {
return &sample_linear_2d_array;
}
else {
- ASSERT(t->MinFilter == GL_NEAREST);
+ ASSERT(t->Sampler.MinFilter == GL_NEAREST);
return &sample_nearest_2d_array;
}
default:
info.smask = texImg->Width - 1; \
info.tmask = texImg->Height - 1; \
info.format = texImg->TexFormat; \
- info.filter = obj->MinFilter; \
+ info.filter = obj->Sampler.MinFilter; \
info.envmode = unit->EnvMode; \
info.er = 0; \
info.eg = 0; \
info.smask = texImg->Width - 1; \
info.tmask = texImg->Height - 1; \
info.format = texImg->TexFormat; \
- info.filter = obj->MinFilter; \
+ info.filter = obj->Sampler.MinFilter; \
info.envmode = unit->EnvMode; \
info.er = 0; \
info.eg = 0; \
texImg = texObj2D ? texObj2D->Image[0][texObj2D->BaseLevel] : NULL;
format = texImg ? texImg->TexFormat : MESA_FORMAT_NONE;
- minFilter = texObj2D ? texObj2D->MinFilter : GL_NONE;
- magFilter = texObj2D ? texObj2D->MagFilter : GL_NONE;
+ minFilter = texObj2D ? texObj2D->Sampler.MinFilter : GL_NONE;
+ magFilter = texObj2D ? texObj2D->Sampler.MagFilter : GL_NONE;
envMode = ctx->Texture.Unit[0].EnvMode;
/* First see if we can use an optimized 2-D texture function */
&& !ctx->ATIFragmentShader._Enabled
&& ctx->Texture._EnabledUnits == 0x1
&& ctx->Texture.Unit[0]._ReallyEnabled == TEXTURE_2D_BIT
- && texObj2D->WrapS == GL_REPEAT
- && texObj2D->WrapT == GL_REPEAT
+ && texObj2D->Sampler.WrapS == GL_REPEAT
+ && texObj2D->Sampler.WrapT == GL_REPEAT
&& texObj2D->_Swizzle == SWIZZLE_NOOP
&& texImg->_IsPowerOfTwo
&& texImg->Border == 0
projects / platform / upstream / mesa.git / commitdiff