/* Populate a swrast SWvertex from an attrib-style vertex.
*/
void
_swsetup_Translate( GLcontext *ctx, const void *vertex, SWvertex *dest )
{
const GLfloat *m = ctx->Viewport._WindowMap.m;
GLfloat tmp[4];
GLuint i;
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_POS, tmp );
dest->win[0] = m[0] * tmp[0] + m[12];
dest->win[1] = m[5] * tmp[1] + m[13];
dest->win[2] = m[10] * tmp[2] + m[14];
dest->win[3] = tmp[3];
for (i = 0 ; i < ctx->Const.MaxTextureUnits ; i++)
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_TEX0+i, dest->texcoord[i] );
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_COLOR0, tmp );
UNCLAMPED_FLOAT_TO_RGBA_CHAN( dest->color, tmp );
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_COLOR1, tmp );
UNCLAMPED_FLOAT_TO_RGBA_CHAN( dest->specular, tmp );
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_FOG, tmp );
dest->fog = tmp[0];
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_INDEX, tmp );
dest->index = (GLuint) tmp[0];
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_POINTSIZE, tmp );
dest->pointSize = tmp[0];
}
static void nv30ClearColor(GLcontext *ctx, const GLfloat color[4])
{
nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
GLubyte c[4];
UNCLAMPED_FLOAT_TO_RGBA_CHAN(c,color);
BEGIN_RING_CACHE(NvSub3D, NV30_TCL_PRIMITIVE_3D_CLEAR_VALUE_ARGB, 1);
OUT_RING_CACHE(PACK_COLOR_8888(c[3],c[0],c[1],c[2]));
}
static void radeonTexEnv( GLcontext *ctx, GLenum target,
GLenum pname, const GLfloat *param )
{
radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
GLuint unit = ctx->Texture.CurrentUnit;
struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
if ( RADEON_DEBUG & DEBUG_STATE ) {
fprintf( stderr, "%s( %s )\n",
__FUNCTION__, _mesa_lookup_enum_by_nr( pname ) );
}
switch ( pname ) {
case GL_TEXTURE_ENV_COLOR: {
GLubyte c[4];
GLuint envColor;
UNCLAMPED_FLOAT_TO_RGBA_CHAN( c, texUnit->EnvColor );
envColor = radeonPackColor( 4, c[0], c[1], c[2], c[3] );
if ( rmesa->hw.tex[unit].cmd[TEX_PP_TFACTOR] != envColor ) {
RADEON_STATECHANGE( rmesa, tex[unit] );
rmesa->hw.tex[unit].cmd[TEX_PP_TFACTOR] = envColor;
}
break;
}
case GL_TEXTURE_LOD_BIAS_EXT: {
GLfloat bias, min;
GLuint b;
/* The Radeon's LOD bias is a signed 2's complement value with a
* range of -1.0 <= bias < 4.0. We break this into two linear
* functions, one mapping [-1.0,0.0] to [-128,0] and one mapping
* [0.0,4.0] to [0,127].
*/
min = driQueryOptionb (&rmesa->optionCache, "no_neg_lod_bias") ?
0.0 : -1.0;
bias = CLAMP( *param, min, 4.0 );
if ( bias == 0 ) {
b = 0;
} else if ( bias > 0 ) {
b = ((GLuint)SCALED_FLOAT_TO_BYTE( bias, 4.0 )) << RADEON_LOD_BIAS_SHIFT;
} else {
b = ((GLuint)SCALED_FLOAT_TO_BYTE( bias, 1.0 )) << RADEON_LOD_BIAS_SHIFT;
}
if ( (rmesa->hw.tex[unit].cmd[TEX_PP_TXFILTER] & RADEON_LOD_BIAS_MASK) != b ) {
RADEON_STATECHANGE( rmesa, tex[unit] );
rmesa->hw.tex[unit].cmd[TEX_PP_TXFILTER] &= ~RADEON_LOD_BIAS_MASK;
rmesa->hw.tex[unit].cmd[TEX_PP_TXFILTER] |= (b & RADEON_LOD_BIAS_MASK);
}
break;
}
default:
return;
}
}
static void intelClearColor(GLcontext *ctx, const GLfloat color[4])
{
struct intel_context *intel = intel_context(ctx);
intelScreenPrivate *screen = intel->intelScreen;
UNCLAMPED_FLOAT_TO_RGBA_CHAN(intel->clear_chan, color);
intel->ClearColor = INTEL_PACKCOLOR(screen->fbFormat,
intel->clear_chan[0],
intel->clear_chan[1],
intel->clear_chan[2],
intel->clear_chan[3]);
}
static void mgaDDTexEnv( GLcontext *ctx, GLenum target,
GLenum pname, const GLfloat *param )
{
GLuint unit = ctx->Texture.CurrentUnit;
struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
mgaContextPtr mmesa = MGA_CONTEXT(ctx);
switch( pname ) {
case GL_TEXTURE_ENV_COLOR: {
GLubyte c[4];
UNCLAMPED_FLOAT_TO_RGBA_CHAN( c, texUnit->EnvColor );
mmesa->envcolor[unit] = PACK_COLOR_8888( c[3], c[0], c[1], c[2] );
break;
}
}
}
/**
* Populate a swrast SWvertex from an attrib-style vertex.
*/
void
_swsetup_Translate( struct gl_context *ctx, const void *vertex, SWvertex *dest )
{
const GLfloat *m = ctx->Viewport._WindowMap.m;
GLfloat tmp[4];
GLuint i;
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_POS, tmp );
dest->attrib[VARYING_SLOT_POS][0] = m[0] * tmp[0] + m[12];
dest->attrib[VARYING_SLOT_POS][1] = m[5] * tmp[1] + m[13];
dest->attrib[VARYING_SLOT_POS][2] = m[10] * tmp[2] + m[14];
dest->attrib[VARYING_SLOT_POS][3] = tmp[3];
/** XXX try to limit these loops someday */
for (i = 0 ; i < ctx->Const.MaxTextureCoordUnits ; i++)
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_TEX0 + i,
dest->attrib[VARYING_SLOT_TEX0 + i] );
for (i = 0 ; i < ctx->Const.MaxVarying ; i++)
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_GENERIC0 + i,
dest->attrib[VARYING_SLOT_VAR0 + i] );
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_COLOR0,
dest->attrib[VARYING_SLOT_COL0] );
UNCLAMPED_FLOAT_TO_RGBA_CHAN( dest->color, tmp );
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_COLOR1,
dest->attrib[VARYING_SLOT_COL1]);
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_FOG, tmp );
dest->attrib[VARYING_SLOT_FOGC][0] = tmp[0];
/* XXX See _tnl_get_attr about pointsize ... */
_tnl_get_attr( ctx, vertex, _TNL_ATTRIB_POINTSIZE, tmp );
dest->pointSize = tmp[0];
}
/**
* \brief Set texture environment parameters.
*
* \param ctx GL context.
* \param target texture environment.
* \param pname texture parameter. Accepted value is GL_TEXTURE_ENV_COLOR.
* \param param parameter value.
*
* Updates the current unit's RADEON_TEX_PP_TFACTOR register and informs of the
* state change.
*/
static void radeonTexEnv( GLcontext *ctx, GLenum target,
GLenum pname, const GLfloat *param )
{
radeonContextPtr rmesa = RADEON_CONTEXT(ctx);
GLuint unit = ctx->Texture.CurrentUnit;
struct gl_texture_unit *texUnit = &ctx->Texture.Unit[unit];
switch ( pname ) {
case GL_TEXTURE_ENV_COLOR: {
GLubyte c[4];
GLuint envColor;
UNCLAMPED_FLOAT_TO_RGBA_CHAN( c, texUnit->EnvColor );
envColor = radeonPackColor( 4, c[0], c[1], c[2], c[3] );
if ( rmesa->hw.tex[unit].cmd[TEX_PP_TFACTOR] != envColor ) {
RADEON_STATECHANGE( rmesa, tex[unit] );
rmesa->hw.tex[unit].cmd[TEX_PP_TFACTOR] = envColor;
}
break;
}
default:
return;
}
}
/* Handle texenv stuff, called from validate_texture (renderstart) */
static void
sis_set_texture_env0( struct gl_context *ctx, struct gl_texture_object *texObj,
int unit )
{
sisContextPtr smesa = SIS_CONTEXT(ctx);
GLubyte c[4];
__GLSiSHardware *prev = &smesa->prev;
__GLSiSHardware *current = &smesa->current;
struct gl_texture_unit *texture_unit = &ctx->Texture.Unit[unit];
sisTexObjPtr t = texObj->DriverData;
switch (texture_unit->EnvMode)
{
case GL_REPLACE:
switch (t->format)
{
case GL_ALPHA:
current->hwTexBlendColor0 = STAGE0_C_CF;
current->hwTexBlendAlpha0 = STAGE0_A_AS;
break;
case GL_LUMINANCE:
case GL_RGB:
case GL_YCBCR_MESA:
current->hwTexBlendColor0 = STAGE0_C_CS;
current->hwTexBlendAlpha0 = STAGE0_A_AF;
break;
case GL_INTENSITY:
case GL_LUMINANCE_ALPHA:
case GL_RGBA:
current->hwTexBlendColor0 = STAGE0_C_CS;
current->hwTexBlendAlpha0 = STAGE0_A_AS;
break;
default:
sis_fatal_error("unknown base format 0x%x\n", t->format);
}
break;
case GL_MODULATE:
switch (t->format)
{
case GL_ALPHA:
current->hwTexBlendColor0 = STAGE0_C_CF;
current->hwTexBlendAlpha0 = STAGE0_A_AFAS;
break;
case GL_LUMINANCE:
case GL_RGB:
case GL_YCBCR_MESA:
current->hwTexBlendColor0 = STAGE0_C_CFCS;
current->hwTexBlendAlpha0 = STAGE0_A_AF;
break;
case GL_INTENSITY:
case GL_LUMINANCE_ALPHA:
case GL_RGBA:
current->hwTexBlendColor0 = STAGE0_C_CFCS;
current->hwTexBlendAlpha0 = STAGE0_A_AFAS;
break;
default:
sis_fatal_error("unknown base format 0x%x\n", t->format);
}
break;
case GL_DECAL:
switch (t->format)
{
case GL_RGB:
case GL_YCBCR_MESA:
current->hwTexBlendColor0 = STAGE0_C_CS;
current->hwTexBlendAlpha0 = STAGE0_A_AF;
break;
case GL_RGBA:
current->hwTexBlendColor0 = STAGE0_C_CFOMAS_CSAS;
current->hwTexBlendAlpha0 = STAGE0_A_AF;
break;
case GL_ALPHA:
case GL_LUMINANCE:
case GL_INTENSITY:
case GL_LUMINANCE_ALPHA:
current->hwTexBlendColor0 = STAGE0_C_CF;
current->hwTexBlendAlpha0 = STAGE0_A_AF;
break;
default:
sis_fatal_error("unknown base format 0x%x\n", t->format);
}
break;
case GL_BLEND:
UNCLAMPED_FLOAT_TO_RGBA_CHAN(c, texture_unit->EnvColor);
current->hwTexEnvColor = ((GLint) (c[3])) << 24 |
((GLint) (c[0])) << 16 |
((GLint) (c[1])) << 8 |
((GLint) (c[2]));
switch (t->format)
{
case GL_ALPHA:
current->hwTexBlendColor0 = STAGE0_C_CF;
current->hwTexBlendAlpha0 = STAGE0_A_AFAS;
break;
case GL_LUMINANCE:
case GL_RGB:
case GL_YCBCR_MESA:
current->hwTexBlendColor0 = STAGE0_C_CFOMCS_CCCS;
current->hwTexBlendAlpha0 = STAGE0_A_AF;
break;
case GL_INTENSITY:
current->hwTexBlendColor0 = STAGE0_C_CFOMCS_CCCS;
current->hwTexBlendAlpha0 = STAGE0_A_AFOMAS_ACAS;
break;
case GL_LUMINANCE_ALPHA:
case GL_RGBA:
current->hwTexBlendColor0 = STAGE0_C_CFOMCS_CCCS;
current->hwTexBlendAlpha0 = STAGE0_A_AFAS;
break;
default:
sis_fatal_error("unknown base format 0x%x\n", t->format);
}
break;
default:
sis_fatal_error("unknown env mode 0x%x\n", texture_unit->EnvMode);
}
if ((current->hwTexBlendColor0 != prev->hwTexBlendColor0) ||
(current->hwTexBlendAlpha0 != prev->hwTexBlendAlpha0) ||
(current->hwTexEnvColor != prev->hwTexEnvColor))
{
prev->hwTexEnvColor = current->hwTexEnvColor;
prev->hwTexBlendColor0 = current->hwTexBlendColor0;
prev->hwTexBlendAlpha0 = current->hwTexBlendAlpha0;
smesa->GlobalFlag |= GFLAG_TEXTUREENV;
}
}
static void nv30Fogfv(GLcontext *ctx, GLenum pname, const GLfloat *params)
{
nouveauContextPtr nmesa = NOUVEAU_CONTEXT(ctx);
if (NOUVEAU_CARD_USING_SHADERS)
return;
switch(pname)
{
case GL_FOG_MODE:
{
int mode = 0;
/* The modes are different in GL and the card. */
switch(ctx->Fog.Mode)
{
case GL_LINEAR:
mode = 0x804;
break;
case GL_EXP:
mode = 0x802;
break;
case GL_EXP2:
mode = 0x803;
break;
}
BEGIN_RING_CACHE(NvSub3D, NV30_TCL_PRIMITIVE_3D_FOG_MODE, 1);
OUT_RING_CACHE (mode);
break;
}
case GL_FOG_COLOR:
{
GLubyte c[4];
UNCLAMPED_FLOAT_TO_RGBA_CHAN(c,params);
BEGIN_RING_CACHE(NvSub3D, NV30_TCL_PRIMITIVE_3D_FOG_COLOR, 1);
/* nvidia ignores the alpha channel */
OUT_RING_CACHE(PACK_COLOR_8888_REV(c[0],c[1],c[2],c[3]));
break;
}
case GL_FOG_DENSITY:
case GL_FOG_START:
case GL_FOG_END:
{
GLfloat f=0., c=0.;
switch(ctx->Fog.Mode)
{
case GL_LINEAR:
f = -1.0/(ctx->Fog.End - ctx->Fog.Start);
c = ctx->Fog.Start/(ctx->Fog.End - ctx->Fog.Start) + 2.001953;
break;
case GL_EXP:
f = -0.090168*ctx->Fog.Density;
c = 1.5;
case GL_EXP2:
f = -0.212330*ctx->Fog.Density;
c = 1.5;
}
BEGIN_RING_CACHE(NvSub3D, NV30_TCL_PRIMITIVE_3D_FOG_EQUATION_LINEAR, 1);
OUT_RING_CACHE(f);
BEGIN_RING_CACHE(NvSub3D, NV30_TCL_PRIMITIVE_3D_FOG_EQUATION_CONSTANT, 1);
OUT_RING_CACHE(c);
BEGIN_RING_CACHE(NvSub3D, NV30_TCL_PRIMITIVE_3D_FOG_EQUATION_QUADRATIC, 1);
OUT_RING_CACHE(0); /* Is this always the same? */
break;
}
// case GL_FOG_COORD_SRC:
default:
break;
}
}
