// iterate over vertices of face, compute u&v coords, compute min & max
void get_face_extent(int face, int *u0, int *v0, int *u1, int *v1)
{
float uv[32][2], u[4],v[4], umin,umax,vmin,vmax;
int tex = dfaces[face].texinfo;
int i,n = dfaces[face].numedges;
int se = dfaces[face].firstedge;
vector *loc;
memcpy(u, texinfo[tex].vecs[0], sizeof(u));
memcpy(v, texinfo[tex].vecs[1], sizeof(v));
for (i=0; i < n; ++i) {
int j = dsurfedges[se+i];
if (j < 0)
loc = (vector *) VERTEX(dedges[-j].v[1]);
else
loc = (vector *) VERTEX(dedges[ j].v[0]);
uv[i][0] = loc->x*u[0] + loc->y*u[1] + loc->z*u[2] + u[3];
uv[i][1] = loc->x*v[0] + loc->y*v[1] + loc->z*v[2] + v[3];
}
umin = umax = uv[0][0];
vmin = vmax = uv[0][1];
for (i=1; i < n; ++i) {
if (uv[i][0] < umin) umin = uv[i][0];
else if (uv[i][0] > umax) umax = uv[i][0];
if (uv[i][1] < vmin) vmin = uv[i][1];
else if (uv[i][1] > vmax) vmax = uv[i][1];
}
*u0 = FLOAT_TO_INT(umin) & ~15;
*v0 = FLOAT_TO_INT(vmin) & ~15;
*u1 = FLOAT_TO_INT(ceil(umax/16)) << 4;
*v1 = FLOAT_TO_INT(ceil(vmax/16)) << 4;
}
void scan_convert(point_3d *a, point_3d *b)
{
void *temp;
int right;
fix x,dx;
int y,ey;
if (a->sy == b->sy)
return;
if (a->sy < b->sy) {
right = 0;
} else {
temp = a;
a = b;
b = temp;
right = 1;
}
// compute dxdy
dx = FLOAT_TO_INT(65536.0 * (b->sx - a->sx) / (b->sy - a->sy));
x = a->sx;
y = fix_cint(a->sy);
ey = fix_cint(b->sy);
// fixup x location to 'y' (subpixel correction in y)
x += FLOAT_TO_INT(((double) dx * ((y << 16) - a->sy)) / 65536.0);
while (y < ey) {
scan[y][right] = x;
x += dx;
++y;
}
}
void GLAPIENTRY
_mesa_GetTexEnviv( GLenum target, GLenum pname, GLint *params )
{
GLuint maxUnit;
const struct gl_texture_unit *texUnit;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
maxUnit = (target == GL_POINT_SPRITE_NV && pname == GL_COORD_REPLACE_NV)
? ctx->Const.MaxTextureCoordUnits : ctx->Const.MaxCombinedTextureImageUnits;
if (ctx->Texture.CurrentUnit >= maxUnit) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexEnviv(current unit)");
return;
}
texUnit = _mesa_get_current_tex_unit(ctx);
if (target == GL_TEXTURE_ENV) {
if (pname == GL_TEXTURE_ENV_COLOR) {
params[0] = FLOAT_TO_INT( texUnit->EnvColor[0] );
params[1] = FLOAT_TO_INT( texUnit->EnvColor[1] );
params[2] = FLOAT_TO_INT( texUnit->EnvColor[2] );
params[3] = FLOAT_TO_INT( texUnit->EnvColor[3] );
}
else {
GLint val = get_texenvi(ctx, texUnit, pname);
if (val >= 0) {
*params = val;
}
}
}
else if (target == GL_TEXTURE_FILTER_CONTROL_EXT) {
if (pname == GL_TEXTURE_LOD_BIAS_EXT) {
*params = (GLint) texUnit->LodBias;
}
else {
_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
return;
}
}
else if (target == GL_POINT_SPRITE_NV) {
/* GL_ARB_point_sprite / GL_NV_point_sprite */
if (!ctx->Extensions.NV_point_sprite
&& !ctx->Extensions.ARB_point_sprite) {
_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
return;
}
if (pname == GL_COORD_REPLACE_NV) {
*params = (GLint) ctx->Point.CoordReplace[ctx->Texture.CurrentUnit];
}
else {
_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(pname)" );
return;
}
}
else {
_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexEnviv(target)" );
return;
}
}
static void
f2alaw_array (float *ptr, unsigned int index, unsigned char *buffer, unsigned int count, float normfact)
{ unsigned int k ;
for (k = 0 ; k < count ; k++)
{ if (ptr [index] >= 0)
buffer [k] = alaw_encode [(FLOAT_TO_INT (normfact * ptr [index])) / 16] ;
else
buffer [k] = 0x7F & alaw_encode [(FLOAT_TO_INT (normfact * ptr [index])) / -16] ;
index ++ ;
} ;
} /* f2alaw_array */
void GLAPIENTRY
_mesa_GetTexBumpParameterivATI( GLenum pname, GLint *param )
{
const struct gl_texture_unit *texUnit;
GLuint i;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (!ctx->Extensions.ATI_envmap_bumpmap) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glGetTexBumpParameterivATI");
return;
}
texUnit = _mesa_get_current_tex_unit(ctx);
if (pname == GL_BUMP_ROT_MATRIX_SIZE_ATI) {
/* spec leaves open to support larger matrices.
Don't think anyone would ever want to use it
(and apps almost certainly would not understand it and
thus fail to submit matrices correctly) so hardcode this. */
*param = 4;
}
else if (pname == GL_BUMP_ROT_MATRIX_ATI) {
/* hope that conversion is correct here */
param[0] = FLOAT_TO_INT(texUnit->RotMatrix[0]);
param[1] = FLOAT_TO_INT(texUnit->RotMatrix[1]);
param[2] = FLOAT_TO_INT(texUnit->RotMatrix[2]);
param[3] = FLOAT_TO_INT(texUnit->RotMatrix[3]);
}
else if (pname == GL_BUMP_NUM_TEX_UNITS_ATI) {
GLint count = 0;
for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
if (ctx->Const.SupportedBumpUnits & (1 << i)) {
count++;
}
}
*param = count;
}
else if (pname == GL_BUMP_TEX_UNITS_ATI) {
for (i = 0; i < ctx->Const.MaxTextureImageUnits; i++) {
if (ctx->Const.SupportedBumpUnits & (1 << i)) {
*param++ = i + GL_TEXTURE0;
}
}
}
else {
_mesa_error( ctx, GL_INVALID_ENUM, "glGetTexBumpParameter(pname)" );
return;
}
}
void gl_GetTexEnviv( GLcontext *ctx,
GLenum target, GLenum pname, GLint *params )
{
if (target!=GL_TEXTURE_ENV) {
gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(target)" );
return;
}
switch (pname) {
case GL_TEXTURE_ENV_MODE:
*params = (GLint) ctx->Texture.EnvMode;
break;
case GL_TEXTURE_ENV_COLOR:
params[0] = FLOAT_TO_INT( ctx->Texture.EnvColor[0] );
params[1] = FLOAT_TO_INT( ctx->Texture.EnvColor[1] );
params[2] = FLOAT_TO_INT( ctx->Texture.EnvColor[2] );
params[3] = FLOAT_TO_INT( ctx->Texture.EnvColor[3] );
break;
default:
gl_error( ctx, GL_INVALID_ENUM, "glGetTexEnvfv(pname)" );
}
}
void GLAPIENTRY
_mesa_GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
{
struct gl_sampler_object *sampObj;
GET_CURRENT_CONTEXT(ctx);
sampObj = sampler_parameter_error_check(ctx, sampler, true,
"glGetSamplerParameteriv");
if (!sampObj)
return;
switch (pname) {
case GL_TEXTURE_WRAP_S:
*params = sampObj->WrapS;
break;
case GL_TEXTURE_WRAP_T:
*params = sampObj->WrapT;
break;
case GL_TEXTURE_WRAP_R:
*params = sampObj->WrapR;
break;
case GL_TEXTURE_MIN_FILTER:
*params = sampObj->MinFilter;
break;
case GL_TEXTURE_MAG_FILTER:
*params = sampObj->MagFilter;
break;
case GL_TEXTURE_MIN_LOD:
/* GL spec 'Data Conversions' section specifies that floating-point
* value in integer Get function is rounded to nearest integer
*/
*params = IROUND(sampObj->MinLod);
break;
case GL_TEXTURE_MAX_LOD:
/* GL spec 'Data Conversions' section specifies that floating-point
* value in integer Get function is rounded to nearest integer
*/
*params = IROUND(sampObj->MaxLod);
break;
case GL_TEXTURE_LOD_BIAS:
/* GL spec 'Data Conversions' section specifies that floating-point
* value in integer Get function is rounded to nearest integer
*/
*params = IROUND(sampObj->LodBias);
break;
case GL_TEXTURE_COMPARE_MODE:
*params = sampObj->CompareMode;
break;
case GL_TEXTURE_COMPARE_FUNC:
*params = sampObj->CompareFunc;
break;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
/* GL spec 'Data Conversions' section specifies that floating-point
* value in integer Get function is rounded to nearest integer
*/
*params = IROUND(sampObj->MaxAnisotropy);
break;
case GL_TEXTURE_BORDER_COLOR:
params[0] = FLOAT_TO_INT(sampObj->BorderColor.f[0]);
params[1] = FLOAT_TO_INT(sampObj->BorderColor.f[1]);
params[2] = FLOAT_TO_INT(sampObj->BorderColor.f[2]);
params[3] = FLOAT_TO_INT(sampObj->BorderColor.f[3]);
break;
case GL_TEXTURE_CUBE_MAP_SEAMLESS:
if (!ctx->Extensions.AMD_seamless_cubemap_per_texture)
goto invalid_pname;
*params = sampObj->CubeMapSeamless;
break;
case GL_TEXTURE_SRGB_DECODE_EXT:
if (!ctx->Extensions.EXT_texture_sRGB_decode)
goto invalid_pname;
*params = (GLenum) sampObj->sRGBDecode;
break;
default:
goto invalid_pname;
}
return;
invalid_pname:
_mesa_error(ctx, GL_INVALID_ENUM, "glGetSamplerParameteriv(pname=%s)",
_mesa_enum_to_string(pname));
}
void GLAPIENTRY
_mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
{
struct gl_texture_unit *texUnit;
struct gl_texture_object *obj;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureImageUnits) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glGetTexParameteriv(current unit)");
return;
}
texUnit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
obj = _mesa_select_tex_object(ctx, texUnit, target);
if (!obj) {
_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(target)");
return;
}
switch (pname) {
case GL_TEXTURE_MAG_FILTER:
*params = (GLint) obj->MagFilter;
return;
case GL_TEXTURE_MIN_FILTER:
*params = (GLint) obj->MinFilter;
return;
case GL_TEXTURE_WRAP_S:
*params = (GLint) obj->WrapS;
return;
case GL_TEXTURE_WRAP_T:
*params = (GLint) obj->WrapT;
return;
case GL_TEXTURE_WRAP_R:
*params = (GLint) obj->WrapR;
return;
case GL_TEXTURE_BORDER_COLOR:
{
GLfloat b[4];
b[0] = CLAMP(obj->BorderColor[0], 0.0F, 1.0F);
b[1] = CLAMP(obj->BorderColor[1], 0.0F, 1.0F);
b[2] = CLAMP(obj->BorderColor[2], 0.0F, 1.0F);
b[3] = CLAMP(obj->BorderColor[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[3] = FLOAT_TO_INT(b[3]);
}
return;
case GL_TEXTURE_RESIDENT:
{
GLboolean resident;
if (ctx->Driver.IsTextureResident)
resident = ctx->Driver.IsTextureResident(ctx, obj);
else
resident = GL_TRUE;
*params = (GLint) resident;
}
return;
case GL_TEXTURE_PRIORITY:
*params = FLOAT_TO_INT(obj->Priority);
return;
case GL_TEXTURE_MIN_LOD:
*params = (GLint) obj->MinLod;
return;
case GL_TEXTURE_MAX_LOD:
*params = (GLint) obj->MaxLod;
return;
case GL_TEXTURE_BASE_LEVEL:
*params = obj->BaseLevel;
return;
case GL_TEXTURE_MAX_LEVEL:
*params = obj->MaxLevel;
return;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
if (ctx->Extensions.EXT_texture_filter_anisotropic) {
*params = (GLint) obj->MaxAnisotropy;
return;
}
break;
case GL_TEXTURE_COMPARE_SGIX:
if (ctx->Extensions.SGIX_shadow) {
*params = (GLint) obj->CompareFlag;
return;
}
break;
case GL_TEXTURE_COMPARE_OPERATOR_SGIX:
if (ctx->Extensions.SGIX_shadow) {
*params = (GLint) obj->CompareOperator;
return;
}
break;
case GL_SHADOW_AMBIENT_SGIX: /* aka GL_TEXTURE_COMPARE_FAIL_VALUE_ARB */
if (ctx->Extensions.SGIX_shadow_ambient) {
*params = (GLint) FLOAT_TO_INT(obj->ShadowAmbient);
return;
}
break;
case GL_GENERATE_MIPMAP_SGIS:
if (ctx->Extensions.SGIS_generate_mipmap) {
*params = (GLint) obj->GenerateMipmap;
return;
}
break;
case GL_TEXTURE_COMPARE_MODE_ARB:
if (ctx->Extensions.ARB_shadow) {
*params = (GLint) obj->CompareMode;
return;
}
break;
case GL_TEXTURE_COMPARE_FUNC_ARB:
if (ctx->Extensions.ARB_shadow) {
*params = (GLint) obj->CompareFunc;
return;
}
break;
case GL_DEPTH_TEXTURE_MODE_ARB:
if (ctx->Extensions.ARB_depth_texture) {
*params = (GLint) obj->DepthMode;
return;
}
break;
case GL_TEXTURE_LOD_BIAS:
if (ctx->Extensions.EXT_texture_lod_bias) {
*params = (GLint) obj->LodBias;
return;
}
break;
#ifdef FEATURE_OES_draw_texture
case GL_TEXTURE_CROP_RECT_OES:
params[0] = obj->CropRect[0];
params[1] = obj->CropRect[1];
params[2] = obj->CropRect[2];
params[3] = obj->CropRect[3];
break;
#endif
default:
; /* silence warnings */
}
/* If we get here, pname was an unrecognized enum */
_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname=0x%x)", pname);
}
void GLAPIENTRY
_mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
{
struct gl_texture_object *obj;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
obj = get_texobj(ctx, target, GL_TRUE);
if (!obj)
return;
_mesa_lock_texture(ctx, obj);
switch (pname) {
case GL_TEXTURE_MAG_FILTER:
*params = (GLint) obj->Sampler.MagFilter;
break;;
case GL_TEXTURE_MIN_FILTER:
*params = (GLint) obj->Sampler.MinFilter;
break;;
case GL_TEXTURE_WRAP_S:
*params = (GLint) obj->Sampler.WrapS;
break;;
case GL_TEXTURE_WRAP_T:
*params = (GLint) obj->Sampler.WrapT;
break;;
case GL_TEXTURE_WRAP_R:
*params = (GLint) obj->Sampler.WrapR;
break;;
case GL_TEXTURE_BORDER_COLOR:
{
GLfloat b[4];
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[3] = FLOAT_TO_INT(b[3]);
}
break;;
case GL_TEXTURE_RESIDENT:
*params = 1;
break;;
case GL_TEXTURE_PRIORITY:
*params = FLOAT_TO_INT(obj->Priority);
break;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
if (!ctx->Extensions.EXT_texture_filter_anisotropic)
goto invalid_pname;
*params = (GLint) obj->Sampler.MaxAnisotropy;
break;
case GL_TEXTURE_IMMUTABLE_FORMAT:
if (!ctx->Extensions.ARB_texture_storage)
goto invalid_pname;
*params = (GLint) obj->Immutable;
break;
default:
goto invalid_pname;
}
/* no error if we get here */
_mesa_unlock_texture(ctx, obj);
return;
invalid_pname:
_mesa_unlock_texture(ctx, obj);
_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname=0x%x)", pname);
}
void GLAPIENTRY
_mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
{
struct gl_texture_object *obj;
GLboolean error = GL_FALSE;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
obj = get_texobj(ctx, target, GL_TRUE);
if (!obj)
return;
_mesa_lock_texture(ctx, obj);
switch (pname) {
case GL_TEXTURE_MAG_FILTER:
*params = (GLint) obj->Sampler.MagFilter;
break;;
case GL_TEXTURE_MIN_FILTER:
*params = (GLint) obj->Sampler.MinFilter;
break;;
case GL_TEXTURE_WRAP_S:
*params = (GLint) obj->Sampler.WrapS;
break;;
case GL_TEXTURE_WRAP_T:
*params = (GLint) obj->Sampler.WrapT;
break;;
case GL_TEXTURE_WRAP_R:
*params = (GLint) obj->Sampler.WrapR;
break;;
case GL_TEXTURE_BORDER_COLOR:
{
GLfloat b[4];
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[3] = FLOAT_TO_INT(b[3]);
}
break;;
case GL_TEXTURE_RESIDENT:
{
GLboolean resident;
if (ctx->Driver.IsTextureResident)
resident = ctx->Driver.IsTextureResident(ctx, obj);
else
resident = GL_TRUE;
*params = (GLint) resident;
}
break;;
case GL_TEXTURE_PRIORITY:
*params = FLOAT_TO_INT(obj->Priority);
break;;
case GL_TEXTURE_MIN_LOD:
*params = (GLint) obj->Sampler.MinLod;
break;;
case GL_TEXTURE_MAX_LOD:
*params = (GLint) obj->Sampler.MaxLod;
break;;
case GL_TEXTURE_BASE_LEVEL:
*params = obj->BaseLevel;
break;;
case GL_TEXTURE_MAX_LEVEL:
*params = obj->MaxLevel;
break;;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
if (ctx->Extensions.EXT_texture_filter_anisotropic) {
*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->Sampler.CompareFailValue);
}
else {
error = GL_TRUE;
}
break;
case GL_GENERATE_MIPMAP_SGIS:
*params = (GLint) obj->GenerateMipmap;
break;
case GL_TEXTURE_COMPARE_MODE_ARB:
if (ctx->Extensions.ARB_shadow) {
*params = (GLint) obj->Sampler.CompareMode;
}
else {
error = GL_TRUE;
}
break;
case GL_TEXTURE_COMPARE_FUNC_ARB:
if (ctx->Extensions.ARB_shadow) {
*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->Sampler.DepthMode;
}
else {
error = GL_TRUE;
}
break;
case GL_TEXTURE_LOD_BIAS:
if (ctx->Extensions.EXT_texture_lod_bias) {
*params = (GLint) obj->Sampler.LodBias;
}
else {
error = GL_TRUE;
}
break;
#if FEATURE_OES_draw_texture
case GL_TEXTURE_CROP_RECT_OES:
params[0] = obj->CropRect[0];
params[1] = obj->CropRect[1];
params[2] = obj->CropRect[2];
params[3] = obj->CropRect[3];
break;
#endif
case GL_TEXTURE_SWIZZLE_R_EXT:
case GL_TEXTURE_SWIZZLE_G_EXT:
case GL_TEXTURE_SWIZZLE_B_EXT:
case GL_TEXTURE_SWIZZLE_A_EXT:
if (ctx->Extensions.EXT_texture_swizzle) {
GLuint comp = pname - GL_TEXTURE_SWIZZLE_R_EXT;
*params = obj->Swizzle[comp];
}
else {
error = GL_TRUE;
}
break;
case GL_TEXTURE_SWIZZLE_RGBA_EXT:
if (ctx->Extensions.EXT_texture_swizzle) {
COPY_4V(params, obj->Swizzle);
}
else {
error = GL_TRUE;
}
break;
case GL_TEXTURE_CUBE_MAP_SEAMLESS:
if (ctx->Extensions.AMD_seamless_cubemap_per_texture) {
*params = (GLint) obj->Sampler.CubeMapSeamless;
}
else {
error = GL_TRUE;
}
break;
default:
; /* silence warnings */
}
if (error)
_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname=0x%x)",
pname);
_mesa_unlock_texture(ctx, obj);
}
void GLAPIENTRY
_mesa_GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
{
struct gl_sampler_object *sampObj;
GET_CURRENT_CONTEXT(ctx);
sampObj = _mesa_lookup_samplerobj(ctx, sampler);
if (!sampObj) {
/* '3.8.2 Sampler Objects' section of the GL-ES 3.0 specification states:
*
* "An INVALID_OPERATION error is generated if sampler is not the name
* of a sampler object previously returned from a call to GenSamplers."
*
* In desktop GL, an GL_INVALID_VALUE is returned instead.
*/
_mesa_error(ctx, (_mesa_is_gles(ctx) ?
GL_INVALID_OPERATION : GL_INVALID_VALUE),
"glGetSamplerParameteriv(sampler %u)", sampler);
return;
}
switch (pname) {
case GL_TEXTURE_WRAP_S:
*params = sampObj->WrapS;
break;
case GL_TEXTURE_WRAP_T:
*params = sampObj->WrapT;
break;
case GL_TEXTURE_WRAP_R:
*params = sampObj->WrapR;
break;
case GL_TEXTURE_MIN_FILTER:
*params = sampObj->MinFilter;
break;
case GL_TEXTURE_MAG_FILTER:
*params = sampObj->MagFilter;
break;
case GL_TEXTURE_MIN_LOD:
/* GL spec 'Data Conversions' section specifies that floating-point
* value in integer Get function is rounded to nearest integer
*/
*params = IROUND(sampObj->MinLod);
break;
case GL_TEXTURE_MAX_LOD:
/* GL spec 'Data Conversions' section specifies that floating-point
* value in integer Get function is rounded to nearest integer
*/
*params = IROUND(sampObj->MaxLod);
break;
case GL_TEXTURE_LOD_BIAS:
/* GL spec 'Data Conversions' section specifies that floating-point
* value in integer Get function is rounded to nearest integer
*/
*params = IROUND(sampObj->LodBias);
break;
case GL_TEXTURE_COMPARE_MODE:
if (!ctx->Extensions.ARB_shadow)
goto invalid_pname;
*params = sampObj->CompareMode;
break;
case GL_TEXTURE_COMPARE_FUNC:
if (!ctx->Extensions.ARB_shadow)
goto invalid_pname;
*params = sampObj->CompareFunc;
break;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
/* GL spec 'Data Conversions' section specifies that floating-point
* value in integer Get function is rounded to nearest integer
*/
*params = IROUND(sampObj->MaxAnisotropy);
break;
case GL_TEXTURE_BORDER_COLOR:
params[0] = FLOAT_TO_INT(sampObj->BorderColor.f[0]);
params[1] = FLOAT_TO_INT(sampObj->BorderColor.f[1]);
params[2] = FLOAT_TO_INT(sampObj->BorderColor.f[2]);
params[3] = FLOAT_TO_INT(sampObj->BorderColor.f[3]);
break;
case GL_TEXTURE_CUBE_MAP_SEAMLESS:
if (!ctx->Extensions.AMD_seamless_cubemap_per_texture)
goto invalid_pname;
*params = sampObj->CubeMapSeamless;
break;
case GL_TEXTURE_SRGB_DECODE_EXT:
if (!ctx->Extensions.EXT_texture_sRGB_decode)
goto invalid_pname;
*params = (GLenum) sampObj->sRGBDecode;
break;
default:
goto invalid_pname;
}
return;
invalid_pname:
_mesa_error(ctx, GL_INVALID_ENUM, "glGetSamplerParameteriv(pname=%s)",
_mesa_enum_to_string(pname));
}
void gl_GetTexParameteriv( GLcontext *ctx,
GLenum target, GLenum pname, GLint *params )
{
switch (target) {
case GL_TEXTURE_1D:
switch (pname) {
case GL_TEXTURE_MAG_FILTER:
*params = (GLint) ctx->Texture.Current1D->MagFilter;
break;
case GL_TEXTURE_MIN_FILTER:
*params = (GLint) ctx->Texture.Current1D->MinFilter;
break;
case GL_TEXTURE_WRAP_S:
*params = (GLint) ctx->Texture.Current1D->WrapS;
break;
case GL_TEXTURE_WRAP_T:
*params = (GLint) ctx->Texture.Current1D->WrapT;
break;
case GL_TEXTURE_BORDER_COLOR:
{
GLfloat color[4];
color[0] = ctx->Texture.Current1D->BorderColor[0]/255.0;
color[1] = ctx->Texture.Current1D->BorderColor[1]/255.0;
color[2] = ctx->Texture.Current1D->BorderColor[2]/255.0;
color[3] = ctx->Texture.Current1D->BorderColor[3]/255.0;
params[0] = FLOAT_TO_INT( color[0] );
params[1] = FLOAT_TO_INT( color[1] );
params[2] = FLOAT_TO_INT( color[2] );
params[3] = FLOAT_TO_INT( color[3] );
}
break;
case GL_TEXTURE_RESIDENT:
*params = (GLint) GL_TRUE;
break;
case GL_TEXTURE_PRIORITY:
*params = (GLint) ctx->Texture.Current1D->Priority;
break;
default:
gl_error( ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname)" );
}
break;
case GL_TEXTURE_2D:
switch (pname) {
case GL_TEXTURE_MAG_FILTER:
*params = (GLint) ctx->Texture.Current2D->MagFilter;
break;
case GL_TEXTURE_MIN_FILTER:
*params = (GLint) ctx->Texture.Current2D->MinFilter;
break;
case GL_TEXTURE_WRAP_S:
*params = (GLint) ctx->Texture.Current2D->WrapS;
break;
case GL_TEXTURE_WRAP_T:
*params = (GLint) ctx->Texture.Current2D->WrapT;
break;
case GL_TEXTURE_BORDER_COLOR:
{
GLfloat color[4];
color[0] = ctx->Texture.Current2D->BorderColor[0]/255.0;
color[1] = ctx->Texture.Current2D->BorderColor[1]/255.0;
color[2] = ctx->Texture.Current2D->BorderColor[2]/255.0;
color[3] = ctx->Texture.Current2D->BorderColor[3]/255.0;
params[0] = FLOAT_TO_INT( color[0] );
params[1] = FLOAT_TO_INT( color[1] );
params[2] = FLOAT_TO_INT( color[2] );
params[3] = FLOAT_TO_INT( color[3] );
}
break;
case GL_TEXTURE_RESIDENT:
*params = (GLint) GL_TRUE;
break;
case GL_TEXTURE_PRIORITY:
*params = (GLint) ctx->Texture.Current2D->Priority;
break;
default:
gl_error( ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname)" );
}
break;
default:
gl_error( ctx, GL_INVALID_ENUM, "glGetTexParameteriv(target)" );
}
}
void GLAPIENTRY
_mesa_GetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
{
struct gl_sampler_object *sampObj;
GET_CURRENT_CONTEXT(ctx);
sampObj = _mesa_lookup_samplerobj(ctx, sampler);
if (!sampObj) {
_mesa_error(ctx, GL_INVALID_VALUE, "glGetSamplerParameteriv(sampler %u)",
sampler);
return;
}
switch (pname) {
case GL_TEXTURE_WRAP_S:
*params = sampObj->WrapS;
break;
case GL_TEXTURE_WRAP_T:
*params = sampObj->WrapT;
break;
case GL_TEXTURE_WRAP_R:
*params = sampObj->WrapR;
break;
case GL_TEXTURE_MIN_FILTER:
*params = sampObj->MinFilter;
break;
case GL_TEXTURE_MAG_FILTER:
*params = sampObj->MagFilter;
break;
case GL_TEXTURE_MIN_LOD:
*params = (GLint) sampObj->MinLod;
break;
case GL_TEXTURE_MAX_LOD:
*params = (GLint) sampObj->MaxLod;
break;
case GL_TEXTURE_LOD_BIAS:
*params = (GLint) sampObj->LodBias;
break;
case GL_TEXTURE_COMPARE_MODE:
if (!ctx->Extensions.ARB_shadow)
goto invalid_pname;
*params = sampObj->CompareMode;
break;
case GL_TEXTURE_COMPARE_FUNC:
if (!ctx->Extensions.ARB_shadow)
goto invalid_pname;
*params = sampObj->CompareFunc;
break;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
*params = (GLint) sampObj->MaxAnisotropy;
break;
case GL_TEXTURE_BORDER_COLOR:
params[0] = FLOAT_TO_INT(sampObj->BorderColor.f[0]);
params[1] = FLOAT_TO_INT(sampObj->BorderColor.f[1]);
params[2] = FLOAT_TO_INT(sampObj->BorderColor.f[2]);
params[3] = FLOAT_TO_INT(sampObj->BorderColor.f[3]);
break;
case GL_TEXTURE_CUBE_MAP_SEAMLESS:
if (!ctx->Extensions.AMD_seamless_cubemap_per_texture)
goto invalid_pname;
*params = sampObj->CubeMapSeamless;
break;
case GL_TEXTURE_SRGB_DECODE_EXT:
if (!ctx->Extensions.EXT_texture_sRGB_decode)
goto invalid_pname;
*params = (GLenum) sampObj->sRGBDecode;
break;
default:
goto invalid_pname;
}
return;
invalid_pname:
_mesa_error(ctx, GL_INVALID_ENUM, "glGetSamplerParameteriv(pname=%s)",
_mesa_lookup_enum_by_nr(pname));
}
void GLAPIENTRY
_mesa_GetTexParameteriv( GLenum target, GLenum pname, GLint *params )
{
struct gl_texture_object *obj;
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
obj = get_texobj(ctx, target, GL_TRUE);
if (!obj)
return;
_mesa_lock_texture(ctx, obj);
switch (pname) {
case GL_TEXTURE_MAG_FILTER:
*params = (GLint) obj->Sampler.MagFilter;
break;
case GL_TEXTURE_MIN_FILTER:
*params = (GLint) obj->Sampler.MinFilter;
break;
case GL_TEXTURE_WRAP_S:
*params = (GLint) obj->Sampler.WrapS;
break;
case GL_TEXTURE_WRAP_T:
*params = (GLint) obj->Sampler.WrapT;
break;
case GL_TEXTURE_WRAP_R:
*params = (GLint) obj->Sampler.WrapR;
break;
case GL_TEXTURE_BORDER_COLOR:
{
GLfloat b[4];
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[3] = FLOAT_TO_INT(b[3]);
}
break;
case GL_TEXTURE_RESIDENT:
*params = 1;
break;
case GL_TEXTURE_PRIORITY:
*params = FLOAT_TO_INT(obj->Priority);
break;
case GL_TEXTURE_MIN_LOD:
*params = (GLint) obj->Sampler.MinLod;
break;
case GL_TEXTURE_MAX_LOD:
*params = (GLint) obj->Sampler.MaxLod;
break;
case GL_TEXTURE_BASE_LEVEL:
*params = obj->BaseLevel;
break;
case GL_TEXTURE_MAX_LEVEL:
*params = obj->MaxLevel;
break;
case GL_TEXTURE_MAX_ANISOTROPY_EXT:
if (!ctx->Extensions.EXT_texture_filter_anisotropic)
goto invalid_pname;
*params = (GLint) obj->Sampler.MaxAnisotropy;
break;
case GL_TEXTURE_COMPARE_FAIL_VALUE_ARB:
if (!ctx->Extensions.ARB_shadow_ambient)
goto invalid_pname;
*params = (GLint) FLOAT_TO_INT(obj->Sampler.CompareFailValue);
break;
case GL_GENERATE_MIPMAP_SGIS:
*params = (GLint) obj->GenerateMipmap;
break;
case GL_TEXTURE_COMPARE_MODE_ARB:
if (!ctx->Extensions.ARB_shadow)
goto invalid_pname;
*params = (GLint) obj->Sampler.CompareMode;
break;
case GL_TEXTURE_COMPARE_FUNC_ARB:
if (!ctx->Extensions.ARB_shadow)
goto invalid_pname;
*params = (GLint) obj->Sampler.CompareFunc;
break;
case GL_DEPTH_TEXTURE_MODE_ARB:
if (!ctx->Extensions.ARB_depth_texture)
goto invalid_pname;
*params = (GLint) obj->DepthMode;
break;
case GL_TEXTURE_LOD_BIAS:
*params = (GLint) obj->Sampler.LodBias;
break;
#if FEATURE_OES_draw_texture
case GL_TEXTURE_CROP_RECT_OES:
params[0] = obj->CropRect[0];
params[1] = obj->CropRect[1];
params[2] = obj->CropRect[2];
params[3] = obj->CropRect[3];
break;
#endif
case GL_TEXTURE_SWIZZLE_R_EXT:
case GL_TEXTURE_SWIZZLE_G_EXT:
case GL_TEXTURE_SWIZZLE_B_EXT:
case GL_TEXTURE_SWIZZLE_A_EXT:
if (!ctx->Extensions.EXT_texture_swizzle)
goto invalid_pname;
*params = obj->Swizzle[pname - GL_TEXTURE_SWIZZLE_R_EXT];
break;
case GL_TEXTURE_SWIZZLE_RGBA_EXT:
if (!ctx->Extensions.EXT_texture_swizzle)
goto invalid_pname;
COPY_4V(params, obj->Swizzle);
break;
case GL_TEXTURE_CUBE_MAP_SEAMLESS:
if (!ctx->Extensions.AMD_seamless_cubemap_per_texture)
goto invalid_pname;
*params = (GLint) obj->Sampler.CubeMapSeamless;
break;
case GL_TEXTURE_IMMUTABLE_FORMAT:
if (!ctx->Extensions.ARB_texture_storage)
goto invalid_pname;
*params = (GLint) obj->Immutable;
break;
case GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES:
if (!ctx->Extensions.OES_EGL_image_external)
goto invalid_pname;
*params = obj->RequiredTextureImageUnits;
break;
default:
goto invalid_pname;
}
/* no error if we get here */
_mesa_unlock_texture(ctx, obj);
return;
invalid_pname:
_mesa_unlock_texture(ctx, obj);
_mesa_error(ctx, GL_INVALID_ENUM, "glGetTexParameteriv(pname=0x%x)", pname);
}
void
_mesa_GetLightiv( GLenum light, GLenum pname, GLint *params )
{
GET_CURRENT_CONTEXT(ctx);
GLint l = (GLint) (light - GL_LIGHT0);
ASSERT_OUTSIDE_BEGIN_END(ctx);
if (l < 0 || l >= (GLint) ctx->Const.MaxLights) {
_mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" );
return;
}
switch (pname) {
case GL_AMBIENT:
params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[0]);
params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[1]);
params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[2]);
params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Ambient[3]);
break;
case GL_DIFFUSE:
params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[0]);
params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[1]);
params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[2]);
params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Diffuse[3]);
break;
case GL_SPECULAR:
params[0] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[0]);
params[1] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[1]);
params[2] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[2]);
params[3] = FLOAT_TO_INT(ctx->Light.Light[l].Specular[3]);
break;
case GL_POSITION:
params[0] = (GLint) ctx->Light.Light[l].EyePosition[0];
params[1] = (GLint) ctx->Light.Light[l].EyePosition[1];
params[2] = (GLint) ctx->Light.Light[l].EyePosition[2];
params[3] = (GLint) ctx->Light.Light[l].EyePosition[3];
break;
case GL_SPOT_DIRECTION:
params[0] = (GLint) ctx->Light.Light[l].EyeDirection[0];
params[1] = (GLint) ctx->Light.Light[l].EyeDirection[1];
params[2] = (GLint) ctx->Light.Light[l].EyeDirection[2];
break;
case GL_SPOT_EXPONENT:
params[0] = (GLint) ctx->Light.Light[l].SpotExponent;
break;
case GL_SPOT_CUTOFF:
params[0] = (GLint) ctx->Light.Light[l].SpotCutoff;
break;
case GL_CONSTANT_ATTENUATION:
params[0] = (GLint) ctx->Light.Light[l].ConstantAttenuation;
break;
case GL_LINEAR_ATTENUATION:
params[0] = (GLint) ctx->Light.Light[l].LinearAttenuation;
break;
case GL_QUADRATIC_ATTENUATION:
params[0] = (GLint) ctx->Light.Light[l].QuadraticAttenuation;
break;
default:
_mesa_error( ctx, GL_INVALID_ENUM, "glGetLightiv" );
break;
}
}
void
_mesa_GetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
{
GET_CURRENT_CONTEXT(ctx);
const struct gl_convolution_attrib *conv;
GLuint c;
ASSERT_OUTSIDE_BEGIN_END(ctx);
switch (target) {
case GL_CONVOLUTION_1D:
c = 0;
conv = &ctx->Convolution1D;
break;
case GL_CONVOLUTION_2D:
c = 1;
conv = &ctx->Convolution2D;
break;
case GL_SEPARABLE_2D:
c = 2;
conv = &ctx->Separable2D;
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameteriv(target)");
return;
}
switch (pname) {
case GL_CONVOLUTION_BORDER_COLOR:
params[0] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][0]);
params[1] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][1]);
params[2] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][2]);
params[3] = FLOAT_TO_INT(ctx->Pixel.ConvolutionBorderColor[c][3]);
break;
case GL_CONVOLUTION_BORDER_MODE:
*params = (GLint) ctx->Pixel.ConvolutionBorderMode[c];
break;
case GL_CONVOLUTION_FILTER_SCALE:
params[0] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][0];
params[1] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][1];
params[2] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][2];
params[3] = (GLint) ctx->Pixel.ConvolutionFilterScale[c][3];
break;
case GL_CONVOLUTION_FILTER_BIAS:
params[0] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][0];
params[1] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][1];
params[2] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][2];
params[3] = (GLint) ctx->Pixel.ConvolutionFilterBias[c][3];
break;
case GL_CONVOLUTION_FORMAT:
*params = (GLint) conv->Format;
break;
case GL_CONVOLUTION_WIDTH:
*params = (GLint) conv->Width;
break;
case GL_CONVOLUTION_HEIGHT:
*params = (GLint) conv->Height;
break;
case GL_MAX_CONVOLUTION_WIDTH:
*params = (GLint) ctx->Const.MaxConvolutionWidth;
break;
case GL_MAX_CONVOLUTION_HEIGHT:
*params = (GLint) ctx->Const.MaxConvolutionHeight;
break;
default:
_mesa_error(ctx, GL_INVALID_ENUM, "glGetConvolutionParameteriv(pname)");
return;
}
}
