enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
static const float green[] = {0.0, 1.0, 0.0, 0.0};
static const float blue[] = {0.0, 0.0, 1.0, 0.0};
glClearColor(1.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, green);
piglit_draw_rect(-1, -1, 1, 2);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, blue);
piglit_draw_rect(0, -1, 1, 2);
pass &= piglit_probe_rect_rgba(0, 0,
piglit_width / 2, piglit_height,
green);
pass &= piglit_probe_rect_rgba(piglit_width / 2, 0,
piglit_width / 2, piglit_height,
blue);
glutSwapBuffers();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void COGLColorCombinerTNT2::GenerateCombinerSettingConstants(int index)
{
TNT2CombinerSaveType &res = m_vCompiledTNTSettings[index];
for( int i=0; i<2; i++ )
{
float *fv;
glActiveTextureARB(GL_TEXTURE0_ARB+i);
switch( res.units[i].constant & MUX_MASK )
{
case MUX_PRIM:
fv = GetPrimitiveColorfv();
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,fv);
break;
case MUX_ENV:
fv = GetEnvColorfv();
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,fv);
break;
case MUX_LODFRAC:
{
float frac = gRDP.LODFrac / 255.0f;
float tempf[4] = {frac,frac,frac,frac};
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,tempf);
break;
}
case MUX_PRIMLODFRAC:
{
float frac = gRDP.primLODFrac / 255.0f;
float tempf[4] = {frac,frac,frac,frac};
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,tempf);
break;
}
}
}
}
inline void gl_texture_glow_set(GLuint txt_id,GLuint glow_id,float glow_color)
{
GLfloat col4[4];
if (glow_id!=gl_texture_current_glow_id) {
gl_texture_current_glow_id=glow_id;
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D,glow_id);
}
if (txt_id!=gl_texture_current_txt_id) {
gl_texture_current_txt_id=txt_id;
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D,txt_id);
}
if (glow_color!=gl_texture_current_glow_color) {
gl_texture_current_glow_color=glow_color;
col4[0]=col4[1]=col4[2]=glow_color;
col4[3]=1.0f;
glActiveTexture(GL_TEXTURE0);
glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR,col4);
}
}
void c_textura_2D::activa( void ) {
glEnable( GL_TEXTURE_2D );
glBindTexture( GL_TEXTURE_2D, this->textura );
if ( Modo == GL_BLEND ) glTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, Color_Blend );
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, Modo );
if ( this->alpha ) { glAlphaFunc( GL_GREATER, 0.5f ); glEnable( GL_ALPHA_TEST ); }
}
int PlainRenderModifier::BeginPass(int pass)
{
ENSURE(pass == 0);
// set up texture environment for base pass - modulate texture and primary color
pglActiveTextureARB(GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, GL_SRC_COLOR);
// Set the proper LOD bias
glTexEnvf(GL_TEXTURE_FILTER_CONTROL, GL_TEXTURE_LOD_BIAS, g_Renderer.m_Options.m_LodBias);
// pass one through as alpha; transparent textures handled specially by TransparencyRenderer
// (gl_constant means the colour comes from the gl_texture_env_color)
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA_ARB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, GL_SRC_ALPHA);
float color[] = { 1.0, 1.0, 1.0, 1.0 };
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
return STREAM_POS|STREAM_COLOR|STREAM_UV0;
}
void RSTexEnvV::set(){
if ( _dataType == X ){
glTexEnvxv(GL_TEXTURE_ENV, _pname, _xParam);
}else{
glTexEnvfv(GL_TEXTURE_ENV, _pname, _fParam);
}
}
void LLDrawPoolWLSky::renderStars(void) const
{
LLGLSPipelineSkyBox gls_sky;
LLGLEnable blend(GL_BLEND);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
// *NOTE: have to have bound the cloud noise texture already since register
// combiners blending below requires something to be bound
// and we might as well only bind once.
gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
gPipeline.disableLights();
/*if (!LLPipeline::sReflectionRender)
{
glPointSize(2.f);
}*/
// *NOTE: we divide by two here and GL_ALPHA_SCALE by two below to avoid
// clamping and allow the star_alpha param to brighten the stars.
bool error;
LLColor4 star_alpha(LLColor4::black);
star_alpha.mV[3] = LLWLParamManager::getInstance()->mCurParams.getFloat("star_brightness", error) / 2.f;
llassert_always(!error);
// gl_FragColor.rgb = gl_Color.rgb;
// gl_FragColor.a = gl_Color.a * star_alpha.a;
//New
gGL.getTexUnit(0)->bind(gSky.mVOSkyp->getBloomTex());
gGL.pushMatrix();
glRotatef(gFrameTimeSeconds*0.01f, 0.f, 0.f, 1.f);
// gl_FragColor.rgb = gl_Color.rgb;
// gl_FragColor.a = gl_Color.a * star_alpha.a;
if (LLGLSLShader::sNoFixedFunction)
{
gCustomAlphaProgram.bind();
gCustomAlphaProgram.uniform1f("custom_alpha", star_alpha.mV[3]);
}
else
{
gGL.getTexUnit(0)->setTextureColorBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_COLOR, LLTexUnit::TBS_VERT_COLOR);
gGL.getTexUnit(0)->setTextureAlphaBlend(LLTexUnit::TBO_MULT_X2, LLTexUnit::TBS_CONST_ALPHA, LLTexUnit::TBS_TEX_ALPHA);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, star_alpha.mV);
}
gSky.mVOWLSkyp->drawStars();
gGL.popMatrix();
if (LLGLSLShader::sNoFixedFunction)
{
gCustomAlphaProgram.unbind();
}
else
{
// and disable the combiner states
gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
}
}
void glTexEnvi( GLenum target, GLenum pname, GLint param )
{
GLfloat p[4];
p[0] = (GLfloat) param;
p[1] = p[2] = p[3] = 0.0;
glTexEnvfv( target, pname, p );
}
void Environment::enableEvironmentMapping(GLfloat* reflectivity,
unsigned int textureUnitOffset)
{
if(!GLEW_VERSION_1_3)
return;
glActiveTexture(GL_TEXTURE0 + ++textureUnitOffset);
setInvMVMatrixAsTextureMatrix();
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, reflectivity);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvf(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_TEXTURE);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_PREVIOUS);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvf(GL_TEXTURE_ENV, GL_SRC2_RGB, GL_CONSTANT);
glTexEnvf(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, cubeMapGenMode);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, cubeMapGenMode);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, cubeMapGenMode);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
glEnable(GL_TEXTURE_CUBE_MAP);
glActiveTexture(GL_TEXTURE0 + --textureUnitOffset);
}
// Interpolate between PREV and TEX, using constant color as interpolation coef.
// => Too whitish
void cgrMultiTexState::interpolateConst()
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
//Interpolate RGB / RGB
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_COLOR);
//Interpolate ALPHA / ALPHA
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA, GL_SRC_ALPHA);
// The GL_CONSTANT used above.
static const float aColor[4] =
//{ 1.0, 1.0, 1.0, 1.0 }; // No change.
//{ 0.5, 0.5, 0.5, 1.0 }; // Very whitish
{ 0.75, 0.75, 0.75, 1.0 }; // Whitish
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, aColor);
}
void gl_texture_simple_set(GLuint txt_id,bool clamp,float r,float g,float b,float alpha)
{
GLfloat col4[4];
// set the texture
glBindTexture(GL_TEXTURE_2D,txt_id);
// set the clamping
if (clamp) {
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_CLAMP_TO_EDGE);
}
else {
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
}
// put the constants in environment color
col4[0]=r;
col4[1]=g;
col4[2]=b;
col4[3]=alpha;
glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR,col4);
}
static void APIENTRY SetTextureMode(int type)
{
static float white[] = {1.f,1.f,1.f,1.f};
if (gl_vid_compatibility)
{
type = TM_MODULATE;
}
if (type == TM_MASK)
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
}
else if (type == TM_OPAQUE)
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
}
else if (type == TM_BRIGHTMAP || type == TM_BRIGHTMAP_TEXTURED)
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_PRIMARY_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_COLOR);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, white);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
if (type == TM_BRIGHTMAP_TEXTURED)
{
gl->ActiveTexture(GL_TEXTURE1);
gl->ActiveTexture(GL_TEXTURE0);
}
}
else // if (type == TM_MODULATE)
{
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
}
}
void UnitDrawerStateFFP::SetTeamColor(int team, const float2 alpha) const {
// non-shader case via texture combiners
const float4 m = {1.0f, 1.0f, 1.0f, alpha.x};
glActiveTexture(GL_TEXTURE0);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, std::move(GetTeamColor(team, alpha.x)));
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, &m.x);
}
void __glXDisp_TexEnvfv(GLbyte *pc)
{
glTexEnvfv(
*(GLenum *)(pc + 0),
*(GLenum *)(pc + 4),
(GLfloat *)(pc + 8)
);
}
void COGLColorCombiner4v2::GenerateCombinerSettingConstants(int index)
{
//COGLColorCombiner4::GenerateCombinerSettingConstants(index);
//return;
OGLExtCombinerSaveType &res = m_vCompiledSettings[index];
COGLExtRender *prender = (COGLExtRender *)m_pRender;
if( res.primIsUsed )
{
float *fv = GetPrimitiveColorfv(); // CONSTANT COLOR
for( int i=0; i<res.numOfUnits; i++ )
{
pglActiveTexture(GL_TEXTURE0_ARB+i);
OPENGL_CHECK_ERRORS;
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,fv);
OPENGL_CHECK_ERRORS;
}
}
if( res.envIsUsed )
{
// Set Texture unit 2 to ENV
pglActiveTexture(GL_TEXTURE2_ARB);
OPENGL_CHECK_ERRORS;
prender->EnableTexUnit(2, true);
TxtrCacheEntry *pEntry = gTextureManager.GetConstantColorTexture(MUX_ENV);
prender->SetCurrentTexture( (gRSP.curTile+2)%7, pEntry->pTexture, 4, 4, pEntry);
prender->SetTexelRepeatFlags((gRSP.curTile+2)%7);
}
if( res.lodFracIsUsed)
{
int unit = 3;
if( !res.envIsUsed )
unit = 2;
// Set Texture unit 3 to LODFRAC
pglActiveTexture(GL_TEXTURE0_ARB+unit);
OPENGL_CHECK_ERRORS;
prender->EnableTexUnit(unit, true);
TxtrCacheEntry *pEntry = gTextureManager.GetConstantColorTexture(MUX_LODFRAC);
prender->SetCurrentTexture( (gRSP.curTile+unit)%7, pEntry->pTexture, 4, 4, pEntry);
prender->SetTexelRepeatFlags((gRSP.curTile+unit)%7);
}
else
{
int unit = 3;
if( !res.envIsUsed )
unit = 2;
// Disable texture unit 3
pglActiveTexture(GL_TEXTURE0_ARB+unit);
OPENGL_CHECK_ERRORS;
prender->EnableTexUnit(unit, false);
prender->SetTextureToTextureUnitMap(-1,unit);
}
}
void pie_ActivateFallback(SHADER_MODE, iIMDShape* shape, PIELIGHT teamcolour, PIELIGHT colour)
{
if (shape->tcmaskpage == iV_TEX_INVALID)
{
return;
}
//Set the environment colour with tcmask
GLfloat tc_env_colour[4];
pal_PIELIGHTtoRGBA4f(&tc_env_colour[0], teamcolour);
// TU0
glActiveTexture(GL_TEXTURE0);
pie_SetTexturePage(shape->texpage);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, tc_env_colour);
// TU0 RGB
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD_SIGNED);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
// TU0 Alpha
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
// TU1
glActiveTexture(GL_TEXTURE1);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, _TEX_PAGE[shape->tcmaskpage].id);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
// TU1 RGB
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE0);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB, GL_SRC_ALPHA);
// TU1 Alpha
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, GL_REPLACE);
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA, GL_PREVIOUS);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
if (GLEW_ARB_imaging || GLEW_EXT_blend_color)
{
glEnable(GL_BLEND);
glBlendFunc(GL_CONSTANT_COLOR, GL_ZERO);
glBlendColor(colour.byte.r / 255.0, colour.byte.g / 255.0, colour.byte.b / 255.0, colour.byte.a / 255.0);
}
glActiveTexture(GL_TEXTURE0);
}
void FastPlayerColorRender::PrepareModel(int UNUSED(pass), CModel* model)
{
// Get the player color
SMaterialColor colour = model->GetMaterial().GetObjectColor();
float* color = &colour.r; // because it's stored RGBA
// Set the texture environment color the player color
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
}
void LLDrawPoolWLSky::renderStars(void) const
{
LLGLSPipelineSkyBox gls_sky;
LLGLEnable blend(GL_BLEND);
gGL.setSceneBlendType(LLRender::BT_ALPHA);
// *NOTE: have to have bound the cloud noise texture already since register
// combiners blending below requires something to be bound
// and we might as well only bind once.
gGL.getTexUnit(0)->enable(LLTexUnit::TT_TEXTURE);
gPipeline.disableLights();
// *NOTE: we divide by two here and GL_ALPHA_SCALE by two below to avoid
// clamping and allow the star_alpha param to brighten the stars.
bool error;
LLColor4 star_alpha(LLColor4::black);
star_alpha.mV[3] = LLWLParamManager::getInstance()->mCurParams.getFloat("star_brightness", error) / 2.f;
// If start_brightness is not set, exit
if( error )
{
LL_WARNS() << "star_brightness missing in mCurParams" << LL_ENDL;
return;
}
gGL.getTexUnit(0)->bind(gSky.mVOSkyp->getBloomTex());
gGL.pushMatrix();
gGL.rotatef(gFrameTimeSeconds*0.01f, 0.f, 0.f, 1.f);
if (LLGLSLShader::sNoFixedFunction)
{
gCustomAlphaProgram.bind();
static LLStaticHashedString sCustomAlpha("custom_alpha");
gCustomAlphaProgram.uniform1f(sCustomAlpha, star_alpha.mV[3]);
}
else
{
gGL.getTexUnit(0)->setTextureColorBlend(LLTexUnit::TBO_MULT, LLTexUnit::TBS_TEX_COLOR, LLTexUnit::TBS_VERT_COLOR);
gGL.getTexUnit(0)->setTextureAlphaBlend(LLTexUnit::TBO_MULT_X2, LLTexUnit::TBS_CONST_ALPHA, LLTexUnit::TBS_TEX_ALPHA);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, star_alpha.mV);
}
gSky.mVOWLSkyp->drawStars();
gGL.popMatrix();
if (LLGLSLShader::sNoFixedFunction)
{
gCustomAlphaProgram.unbind();
}
else
{
// and disable the combiner states
gGL.getTexUnit(0)->setTextureBlendType(LLTexUnit::TB_MULT);
}
}
static void
Init(void)
{
static float ambient[] =
{0.1, 0.1, 0.1, 1.0};
static float diffuse[] =
{1.0, 1.0, 1.0, 1.0};
static float position[] =
{0.0, 0.0, -150.0, 0.0};
static float front_mat_diffuse[] =
{1.0, 0.2, 1.0, 1.0};
static float back_mat_diffuse[] =
{1.0, 1.0, 0.2, 1.0};
static float lmodel_ambient[] =
{1.0, 1.0, 1.0, 1.0};
static float lmodel_twoside[] =
{GL_TRUE};
static float decal[] =
{GL_DECAL};
static float repeat[] =
{GL_REPEAT};
static float nr[] =
{GL_NEAREST};
glFrontFace(GL_CCW);
glEnable(GL_DEPTH_TEST);
glMap1d(GL_MAP1_VERTEX_4, 0.0, 1.0, VDIM, VORDER, point1);
glMap1d(GL_MAP1_COLOR_4, 0.0, 1.0, CDIM, CORDER, cpoint1);
glMap2d(GL_MAP2_VERTEX_4, 0.0, 1.0, VMINOR_ORDER * VDIM, VMAJOR_ORDER, 0.0,
1.0, VDIM, VMINOR_ORDER, point2);
glMap2d(GL_MAP2_COLOR_4, 0.0, 1.0, CMINOR_ORDER * CDIM, CMAJOR_ORDER, 0.0,
1.0, CDIM, CMINOR_ORDER, cpoint2);
glMap2d(GL_MAP2_TEXTURE_COORD_2, 0.0, 1.0, TMINOR_ORDER * TDIM,
TMAJOR_ORDER, 0.0, 1.0, TDIM, TMINOR_ORDER, tpoint2);
glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse);
glLightfv(GL_LIGHT0, GL_POSITION, position);
glMaterialfv(GL_FRONT, GL_DIFFUSE, front_mat_diffuse);
glMaterialfv(GL_BACK, GL_DIFFUSE, back_mat_diffuse);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
glLightModelfv(GL_LIGHT_MODEL_TWO_SIDE, lmodel_twoside);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, decal);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, repeat);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, repeat);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, nr);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, nr);
glTexImage2D(GL_TEXTURE_2D, 0, 4, 2, 4, 0, GL_RGBA, GL_FLOAT,
(GLvoid *) textureImage);
}
void c_textura_2D::activa_Alpha_Blend( void ) {
glEnable( GL_TEXTURE_2D );
glBindTexture( GL_TEXTURE_2D, this->textura );
if ( Modo == GL_BLEND ) glTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, Color_Blend );
glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, Modo );
glAlphaFunc( GL_ALWAYS, 1.0 );
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
glEnable( GL_ALPHA_TEST );
glEnable( GL_BLEND );
}
void
SoGLMultiTextureImageElement::updateGL(const int unit)
{
const GLUnitData & glud =
(unit < PRIVATE(this)->unitdata.getLength()) ?
PRIVATE(this)->unitdata[unit] :
PRIVATE(this)->defaultdata;
if (glud.glimage) {
const cc_glglue * glue = cc_glglue_instance(PRIVATE(this)->cachecontext);
cc_glglue_glActiveTexture(glue, (GLenum) (int(GL_TEXTURE0) + unit));
const UnitData & ud = this->getUnitData(unit);
SoState * state = PRIVATE(this)->state;
SoGLDisplayList * dl = glud.glimage->getGLDisplayList(state);
// tag image (for GLImage LRU cache).
SoGLImage::tagImage(state, glud.glimage);
if (SoTextureCombineElement::isDefault(state, unit)) {
switch (ud.model) {
case DECAL:
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
break;
case MODULATE:
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
break;
case BLEND:
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, ud.blendColor.getValue());
break;
case REPLACE:
// GL_REPLACE mode was introduced with OpenGL 1.1. It is
// considered the client code's responsibility to check
// that it can use this mode.
//
// FIXME: ..but we should do a sanity check anyway.
// 20030901 mortene.
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
break;
default:
assert(0 && "unknown model");
break;
}
}
else {
SoTextureCombineElement::apply(state, unit);
}
if (dl) {
dl->call(state);
}
cc_glglue_glActiveTexture(glue, (GLenum) GL_TEXTURE0);
}
}
void MultiTex::EnableTex() const
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, m_texID);
GLfloat constColor[4] = {0.0, 0.0, 0.0, m_alpha };
glBindTexture(GL_TEXTURE_2D, m_texID);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, constColor);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE);
}
void GLES11RenderEngine::setupLayerBlending(
bool premultipliedAlpha, bool opaque, int alpha) {
GLenum combineRGB;
GLenum combineAlpha;
GLenum src0Alpha;
GLfloat envColor[4];
if (CC_UNLIKELY(alpha < 0xFF)) {
// Cv = premultiplied ? Cs*alpha : Cs
// Av = !opaque ? As*alpha : As
combineRGB = premultipliedAlpha ? GL_MODULATE : GL_REPLACE;
combineAlpha = !opaque ? GL_MODULATE : GL_REPLACE;
src0Alpha = GL_CONSTANT;
envColor[0] = alpha * (1.0f / 255.0f);
} else {
// Cv = Cs
// Av = opaque ? 1.0 : As
combineRGB = GL_REPLACE;
combineAlpha = GL_REPLACE;
src0Alpha = opaque ? GL_CONSTANT : GL_TEXTURE;
envColor[0] = 1.0f;
}
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE);
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, combineRGB);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_RGB, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR);
if (combineRGB == GL_MODULATE) {
glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_RGB, GL_CONSTANT);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR);
}
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, combineAlpha);
glTexEnvi(GL_TEXTURE_ENV, GL_SRC0_ALPHA, src0Alpha);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA, GL_SRC_ALPHA);
if (combineAlpha == GL_MODULATE) {
glTexEnvi(GL_TEXTURE_ENV, GL_SRC1_ALPHA, GL_TEXTURE);
glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA, GL_SRC_ALPHA);
}
if (combineRGB == GL_MODULATE || src0Alpha == GL_CONSTANT) {
envColor[1] = envColor[0];
envColor[2] = envColor[0];
envColor[3] = envColor[0];
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, envColor);
}
if (alpha < 0xFF || !opaque) {
glEnable(GL_BLEND);
glBlendFunc(premultipliedAlpha ? GL_ONE : GL_SRC_ALPHA,
GL_ONE_MINUS_SRC_ALPHA);
} else {
glDisable(GL_BLEND);
}
}
void glTexEnviv( GLenum target, GLenum pname, const GLint *param )
{
GLfloat p[4];
if (pname == GL_TEXTURE_ENV_COLOR) {
p[0] = INT_TO_FLOAT( param[0] );
p[1] = INT_TO_FLOAT( param[1] );
p[2] = INT_TO_FLOAT( param[2] );
p[3] = INT_TO_FLOAT( param[3] );
}
else {
p[0] = (GLfloat) param[0];
p[1] = p[2] = p[3] = 0; /* init to zero, just to be safe */
}
glTexEnvfv( target, pname, p );
}
void renderShadowStage ( int n, float* vmat )
{
GLfloat pos[4];
GLfloat row[4];
computeLightMatrix ( n, TEX_SIZE, TEX_SIZE );
if ( n == 0 ) {
glActiveTextureARB( GL_TEXTURE1_ARB ); // TEXTURE1 = shadow map stage #1
} else {
glActiveTextureARB( GL_TEXTURE2_ARB ); // TEXTURE2 = shadow map stage #2
}
glEnable ( GL_TEXTURE_2D );
if ( n == 0 ) glBindTexture ( GL_TEXTURE_2D, shadow1_id );
else glBindTexture ( GL_TEXTURE_2D, shadow2_id );
glMatrixMode( GL_MODELVIEW );
glLoadMatrixf ( vmat );
row[0] = light_proj[0]; row[1] = light_proj[4]; row[2] = light_proj[8]; row[3] = light_proj[12];
glTexGenfv(GL_S, GL_EYE_PLANE, &row[0] );
row[0] = light_proj[1]; row[1] = light_proj[5]; row[2] = light_proj[9]; row[3] = light_proj[13];
glTexGenfv(GL_T, GL_EYE_PLANE, &row[0] );
row[0] = light_proj[2]; row[1] = light_proj[6]; row[2] = light_proj[10]; row[3] = light_proj[14];
glTexGenfv(GL_R, GL_EYE_PLANE, &row[0] );
row[0] = light_proj[3]; row[1] = light_proj[7]; row[2] = light_proj[11]; row[3] = light_proj[15];
glTexGenfv(GL_Q, GL_EYE_PLANE, &row[0] );
glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glEnable(GL_TEXTURE_GEN_S);
glEnable(GL_TEXTURE_GEN_T);
glEnable(GL_TEXTURE_GEN_R);
glEnable(GL_TEXTURE_GEN_Q);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE );
glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_INTERPOLATE ) ;
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB, GL_TEXTURE ) ;
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS ) ;
glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB, GL_CONSTANT ) ;
pos[0] = 0.50;
pos[1] = 0.50;
pos[2] = 0.50;
pos[3] = 0.50;
glTexEnvfv (GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, &pos[0] );
}
void ReInit(void)
{
if (genericObject == torus) {
glEnable(GL_DEPTH_TEST);
} else {
glDisable(GL_DEPTH_TEST);
}
if (isFogged) {
textureEnvironment = modulate;
}
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, textureEnvironment);
}
void
texenv(void)
{
GLfloat env_color[4], border_color[4];
cell_vector(env_color, ecolor, 4);
cell_vector(border_color, bcolor, 4);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minfilter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magfilter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wraps);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapt);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, env);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, env_color);
glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_BORDER_COLOR, border_color);
}
inline void gl_texture_transparent_set(GLuint txt_id,float alpha)
{
GLfloat col4[4];
if (txt_id!=gl_texture_current_txt_id) {
gl_texture_current_txt_id=txt_id;
glBindTexture(GL_TEXTURE_2D,txt_id);
}
if (alpha!=gl_texture_current_alpha) {
gl_texture_current_alpha=alpha;
col4[0]=col4[1]=col4[2]=1.0f;
col4[3]=alpha;
glTexEnvfv(GL_TEXTURE_ENV,GL_TEXTURE_ENV_COLOR,col4);
}
}
void loadTex(char * pstrName)
{
image_t temp_image;
tgaLoad ( pstrName, &temp_image, TGA_DEFAULT);
glGenTextures(1, &tex[demoId]);
glBindTexture(GL_TEXTURE_2D, tex[demoId]);
glTexImage2D(GL_TEXTURE_2D, 0, 4, temp_image.info.width, temp_image.info.height,
0, GL_RGB, GL_UNSIGNED_BYTE, temp_image.data);
GLfloat color[4];
color[0] = 1.0f, color[1] = 0.0f, color[2] = 1.0f, color[3] = 0.5f;
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, color);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
static void Init(void)
{
doSphere = GL_FALSE;
xRotation = 0.0;
yRotation = 0.0;
zTranslate = -3.125;
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
if (multTex && texObj) {
int i;
glGenTexturesEXT(NUM_TEXTURES, texNames);
for (i = 1; i < NUM_TEXTURES; i++) {
glBindTextureEXT(GL_TEXTURE_2D, texNames[i]);
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, images[i]->sizeX,
images[i]->sizeY, GL_RGB, GL_UNSIGNED_BYTE,
images[i]->data);
}
glBindTextureEXT(GL_TEXTURE_2D, texNames[0]);
glPrioritizeTexturesEXT(NUM_TEXTURES, texNames, texPriorities);
}
gluBuild2DMipmaps(GL_TEXTURE_2D, 3, images[0]->sizeX, images[0]->sizeY,
GL_RGB, GL_UNSIGNED_BYTE, images[0]->data);
glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, decal);
glEnable(GL_TEXTURE_2D);
glFrontFace(GL_CCW);
glCullFace(GL_FRONT);
glEnable(GL_CULL_FACE);
BuildLists();
glClearColor(0.0, 0.0, 0.0, 0.0);
magFilter = nr;
minFilter = nr;
sWrapMode = repeat;
tWrapMode = repeat;
}
