llpostprocess.cpp

Go to the documentation of this file.

#include "llviewerprecompiledheaders.h"

#include "pipeline.h"
#include "llpostprocess.h"
#include "llglslshader.h"
#include "llsdserialize.h"
#include "llglimmediate.h"


LLPostProcess * gPostProcess = NULL;


static const unsigned int NOISE_SIZE = 512;

static const float LUMINANCE_R = 0.299f;
static const float LUMINANCE_G = 0.587f;
static const float LUMINANCE_B = 0.114f;

static const char * const XML_FILENAME = "postprocesseffects.xml";

LLPostProcess::LLPostProcess(void) : 
                                        sceneRenderTexture(0), noiseTexture(0),
                                        tempBloomTexture(0),
                                        initialized(false),  
                                        mAllEffects(LLSD::emptyMap()),
                                        screenW(1), screenH(1)
{
        LLString pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight", XML_FILENAME));
        LL_DEBUGS2("AppInit", "Shaders") << "Loading PostProcess Effects settings from " << pathName << LL_ENDL;

        llifstream effectsXML(pathName.c_str());

        if (effectsXML)
        {
                LLPointer<LLSDParser> parser = new LLSDXMLParser();

                parser->parse(effectsXML, mAllEffects, LLSDSerialize::SIZE_UNLIMITED);
        }

        if (!mAllEffects.has("default"))
        {
                LLSD & defaultEffect = (mAllEffects["default"] = LLSD::emptyMap());

                defaultEffect["enable_night_vision"] = LLSD::Boolean(false);
                defaultEffect["enable_bloom"] = LLSD::Boolean(false);
                defaultEffect["enable_color_filter"] = LLSD::Boolean(false);

                defaultEffect["brightness_multiplier"] = 3.0;
                defaultEffect["noise_size"] = 25.0;
                defaultEffect["noise_strength"] = 0.4;

                // TODO BTest potentially add this to tweaks?
                noiseTextureScale = 1.0f;
                
                defaultEffect["extract_low"] = 0.95;
                defaultEffect["extract_high"] = 1.0;
                defaultEffect["bloom_width"] = 2.25;
                defaultEffect["bloom_strength"] = 1.5;

                defaultEffect["brightness"] = 1.0;
                defaultEffect["contrast"] = 1.0;
                defaultEffect["saturation"] = 1.0;

                LLSD& contrastBase = (defaultEffect["contrast_base"] = LLSD::emptyArray());
                contrastBase.append(1.0);
                contrastBase.append(1.0);
                contrastBase.append(1.0);
                contrastBase.append(0.5);
        }

        setSelectedEffect("default");
}

LLPostProcess::~LLPostProcess(void)
{
        glDeleteTextures(1, &sceneRenderTexture);
        glDeleteTextures(1, &noiseTexture);
        glDeleteTextures(1, &tempBloomTexture);
}

// static
void LLPostProcess::initClass(void)
{
        //this will cause system to crash at second time login
        //if first time login fails due to network connection --- bao
        //***llassert_always(gPostProcess == NULL);
        //replaced by the following line:
        if(gPostProcess)
                return ;
        
        
        gPostProcess = new LLPostProcess();
}

// static
void LLPostProcess::cleanupClass()
{
        delete gPostProcess;
        gPostProcess = NULL;
}

void LLPostProcess::setSelectedEffect(std::string const & effectName)
{
        mSelectedEffectName = effectName;
        static_cast<LLSD &>(tweaks) = mAllEffects[effectName];
}

void LLPostProcess::saveEffect(std::string const & effectName)
{
        mAllEffects[effectName] = tweaks;

        LLString pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight", XML_FILENAME));
        //llinfos << "Saving PostProcess Effects settings to " << pathName << llendl;

        llofstream effectsXML(pathName.c_str());

        LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter();

        formatter->format(mAllEffects, effectsXML);
}

void LLPostProcess::apply(unsigned int width, unsigned int height)
{
        if (!initialized || width != screenW || height != screenH){
                initialize(width, height);
        }
        if (shadersEnabled()){
                doEffects();
        }
}

void LLPostProcess::initialize(unsigned int width, unsigned int height)
{
        screenW = width;
        screenH = height;
        createTexture(sceneRenderTexture, screenW, screenH);
        initialized = true;

        checkError();
        createNightVisionShader();
        createBloomShader();
        createColorFilterShader();
        checkError();
}

inline bool LLPostProcess::shadersEnabled(void)
{
        return (tweaks.useColorFilter().asBoolean() ||
                        tweaks.useNightVisionShader().asBoolean() ||
                        tweaks.useBloomShader().asBoolean() );

}

void LLPostProcess::applyShaders(void)
{
        if (tweaks.useColorFilter()){
                applyColorFilterShader();
                checkError();
        }       
        if (tweaks.useNightVisionShader()){
                if (tweaks.useColorFilter()){
                        copyFrameBuffer(sceneRenderTexture, screenW, screenH);
                }
                applyNightVisionShader();
                checkError();
        }
        if (tweaks.useBloomShader()){
                if (tweaks.useColorFilter().asBoolean() || tweaks.useNightVisionShader().asBoolean()){
                        copyFrameBuffer(sceneRenderTexture, screenW, screenH);
                }
                applyBloomShader();
                checkError();
        }
}

void LLPostProcess::applyColorFilterShader(void)
{       
        gPostColorFilterProgram.bind();

        glActiveTextureARB(GL_TEXTURE0_ARB);
        glEnable(GL_TEXTURE_RECTANGLE_ARB);     

        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, sceneRenderTexture);

        getShaderUniforms(colorFilterUniforms, gPostColorFilterProgram.mProgramObject);
        glUniform1iARB(colorFilterUniforms["RenderTexture"], 0);
        glUniform1fARB(colorFilterUniforms["brightness"], tweaks.getBrightness());
        glUniform1fARB(colorFilterUniforms["contrast"], tweaks.getContrast());
        float baseI = (tweaks.getContrastBaseR() + tweaks.getContrastBaseG() + tweaks.getContrastBaseB()) / 3.0f;
        baseI = tweaks.getContrastBaseIntensity() / ((baseI < 0.001f) ? 0.001f : baseI);
        float baseR = tweaks.getContrastBaseR() * baseI;
        float baseG = tweaks.getContrastBaseG() * baseI;
        float baseB = tweaks.getContrastBaseB() * baseI;
        glUniform3fARB(colorFilterUniforms["contrastBase"], baseR, baseG, baseB);
        glUniform1fARB(colorFilterUniforms["saturation"], tweaks.getSaturation());
        glUniform3fARB(colorFilterUniforms["lumWeights"], LUMINANCE_R, LUMINANCE_G, LUMINANCE_B);
        
        LLGLEnable blend(GL_BLEND);
        gGL.blendFunc(GL_ONE,GL_ZERO);
        LLGLDepthTest depth(GL_FALSE);
                
        drawOrthoQuad(screenW, screenH, QUAD_NORMAL);
        gPostColorFilterProgram.unbind();
}

void LLPostProcess::createColorFilterShader(void)
{
        colorFilterUniforms["RenderTexture"] = 0;
        colorFilterUniforms["brightness"] = 0;
        colorFilterUniforms["contrast"] = 0;
        colorFilterUniforms["contrastBase"] = 0;
        colorFilterUniforms["saturation"] = 0;
        colorFilterUniforms["lumWeights"] = 0;
}

void LLPostProcess::applyNightVisionShader(void)
{       
        gPostNightVisionProgram.bind();

        glActiveTextureARB(GL_TEXTURE0_ARB);
        glEnable(GL_TEXTURE_RECTANGLE_ARB);     

        getShaderUniforms(nightVisionUniforms, gPostNightVisionProgram.mProgramObject);
        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, sceneRenderTexture);
        glUniform1iARB(nightVisionUniforms["RenderTexture"], 0);

        glActiveTextureARB(GL_TEXTURE1_ARB);
        glEnable(GL_TEXTURE_2D);        

        glBindTexture(GL_TEXTURE_2D, noiseTexture);
        glUniform1iARB(nightVisionUniforms["NoiseTexture"], 1);

        
        glUniform1fARB(nightVisionUniforms["brightMult"], tweaks.getBrightMult());
        glUniform1fARB(nightVisionUniforms["noiseStrength"], tweaks.getNoiseStrength());
        noiseTextureScale = 0.01f + ((101.f - tweaks.getNoiseSize()) / 100.f);
        noiseTextureScale *= (screenH / NOISE_SIZE);


        glUniform3fARB(nightVisionUniforms["lumWeights"], LUMINANCE_R, LUMINANCE_G, LUMINANCE_B);
        
        LLGLEnable blend(GL_BLEND);
        gGL.blendFunc(GL_ONE,GL_ZERO);
        LLGLDepthTest depth(GL_FALSE);
                
        drawOrthoQuad(screenW, screenH, QUAD_NOISE);
        gPostNightVisionProgram.unbind();
        glActiveTextureARB(GL_TEXTURE0_ARB);
}

void LLPostProcess::createNightVisionShader(void)
{
        nightVisionUniforms["RenderTexture"] = 0;
        nightVisionUniforms["NoiseTexture"] = 0;
        nightVisionUniforms["brightMult"] = 0;  
        nightVisionUniforms["noiseStrength"] = 0;
        nightVisionUniforms["lumWeights"] = 0;  

        createNoiseTexture(noiseTexture);
}

void LLPostProcess::applyBloomShader(void)
{

}

void LLPostProcess::createBloomShader(void)
{
        createTexture(tempBloomTexture, unsigned(screenW * 0.5), unsigned(screenH * 0.5));

        bloomExtractUniforms["RenderTexture"] = 0;
        bloomExtractUniforms["extractLow"] = 0;
        bloomExtractUniforms["extractHigh"] = 0;        
        bloomExtractUniforms["lumWeights"] = 0; 
        
        bloomBlurUniforms["RenderTexture"] = 0;
        bloomBlurUniforms["bloomStrength"] = 0; 
        bloomBlurUniforms["texelSize"] = 0;
        bloomBlurUniforms["blurDirection"] = 0;
        bloomBlurUniforms["blurWidth"] = 0;
}

void LLPostProcess::getShaderUniforms(glslUniforms & uniforms, GLhandleARB & prog)
{
        std::map<const char *, GLuint>::iterator i;
        for (i  = uniforms.begin(); i != uniforms.end(); ++i){
                i->second = glGetUniformLocationARB(prog, i->first);
        }
}

void LLPostProcess::doEffects(void)
{
        glPushAttrib(GL_ALL_ATTRIB_BITS);
        glPushClientAttrib(GL_ALL_ATTRIB_BITS);

        copyFrameBuffer(sceneRenderTexture, screenW, screenH);

        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
        
        viewOrthogonal(screenW, screenH);
        
        checkError();
        applyShaders();
        
        glUseProgramObjectARB(0);
        checkError();

        viewPerspective();      

        glPopClientAttrib();
        glPopAttrib();
        checkError();
}

void LLPostProcess::copyFrameBuffer(GLuint & texture, unsigned int width, unsigned int height)
{
        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texture);
        glCopyTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, GL_RGBA, 0, 0, width, height, 0);
}

void LLPostProcess::drawOrthoQuad(unsigned int width, unsigned int height, QuadType type)
{
#if 0
        float noiseX = 0.f;
        float noiseY = 0.f;
        float screenRatio = 1.0f;

        if (type == QUAD_NOISE){
                noiseX = ((float) rand() / (float) RAND_MAX);
                noiseY = ((float) rand() / (float) RAND_MAX);
                screenRatio = (float) width / (float) height;
        }
        

        glBegin(GL_QUADS);
                if (type != QUAD_BLOOM_EXTRACT){
                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.f, (GLfloat) height);
                } else {
                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.f, (GLfloat) height * 2.0f);
                }
                if (type == QUAD_NOISE){
                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB,
                                                                        noiseX,
                                                                        noiseTextureScale + noiseY);
                } else if (type == QUAD_BLOOM_COMBINE){
                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.f, (GLfloat) height * 0.5f);
                }
                glVertex2f(0.f, (GLfloat) screenH - height);

                if (type != QUAD_BLOOM_EXTRACT){
                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.f, 0.f);
                } else {
                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0.f, 0.f);
                }
                if (type == QUAD_NOISE){
                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB,
                                                                        noiseX,
                                                                        noiseY);
                } else if (type == QUAD_BLOOM_COMBINE){
                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB, 0.f, 0.f);
                }
                glVertex2f(0.f, (GLfloat) height + (screenH - height));

                
                if (type != QUAD_BLOOM_EXTRACT){
                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, (GLfloat) width, 0.f);
                } else {
                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, (GLfloat) width * 2.0f, 0.f);
                }
                if (type == QUAD_NOISE){
                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB,
                                                                        screenRatio * noiseTextureScale + noiseX,
                                                                        noiseY);
                } else if (type == QUAD_BLOOM_COMBINE){
                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB, (GLfloat) width * 0.5f, 0.f);
                }
                glVertex2f((GLfloat) width, (GLfloat) height + (screenH - height));

                
                if (type != QUAD_BLOOM_EXTRACT){
                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, (GLfloat) width, (GLfloat) height);
                } else {
                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, (GLfloat) width * 2.0f, (GLfloat) height * 2.0f);
                }
                if (type == QUAD_NOISE){
                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB,
                                                                        screenRatio * noiseTextureScale + noiseX,
                                                                        noiseTextureScale + noiseY);
                } else if (type == QUAD_BLOOM_COMBINE){
                        glMultiTexCoord2fARB(GL_TEXTURE1_ARB, (GLfloat) width * 0.5f, (GLfloat) height * 0.5f);
                }
                glVertex2f((GLfloat) width, (GLfloat) screenH - height);
        glEnd();
#endif
}

void LLPostProcess::viewOrthogonal(unsigned int width, unsigned int height)
{
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadIdentity();
        glOrtho( 0.f, (GLdouble) width , (GLdouble) height , 0.f, -1.f, 1.f );
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();
}

void LLPostProcess::viewPerspective(void)
{
        glMatrixMode( GL_PROJECTION );
        glPopMatrix();
        glMatrixMode( GL_MODELVIEW );
        glPopMatrix();
}

void LLPostProcess::changeOrthogonal(unsigned int width, unsigned int height)
{
        viewPerspective();
        viewOrthogonal(width, height);
}

void LLPostProcess::createTexture(GLuint & texture, unsigned int width, unsigned int height)
{
        if (texture != 0){
                glDeleteTextures(1, &texture);
        }

        std::vector<GLubyte> data(width * height * 4, 0);

        glGenTextures(1, &texture);
        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texture);
        glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, 4, width, height, 0,
                GL_RGBA, GL_UNSIGNED_BYTE, &data[0]);
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_RECTANGLE_ARB,GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}

void LLPostProcess::createNoiseTexture(GLuint & texture)
{
        if (texture != 0){
                glDeleteTextures(1, &texture);
        }
        glGenTextures(1, &texture);

        std::vector<GLubyte> buffer(NOISE_SIZE * NOISE_SIZE);
        for (unsigned int i = 0; i < NOISE_SIZE; i++){
                for (unsigned int k = 0; k < NOISE_SIZE; k++){
                        buffer[(i * NOISE_SIZE) + k] = (GLubyte)((double) rand() / ((double) RAND_MAX + 1.f) * 255.f);
                }
        }
        glBindTexture(GL_TEXTURE_2D, texture);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, NOISE_SIZE, NOISE_SIZE, 0, GL_LUMINANCE, GL_UNSIGNED_BYTE, &buffer[0]);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
}

bool LLPostProcess::checkError(void)
{
        GLenum glErr;
    bool    retCode = false;

    glErr = glGetError();
    while (glErr != GL_NO_ERROR)
    {
                // shaderErrorLog << (const char *) gluErrorString(glErr) << std::endl;
                char const * err_str_raw = (const char *) gluErrorString(glErr);

                if(err_str_raw == NULL)
                {
                        std::ostringstream err_builder;
                        err_builder << "unknown error number " << glErr;
                        mShaderErrorString = err_builder.str();
                }
                else
                {
                        mShaderErrorString = err_str_raw;
                }

        retCode = true;
        glErr = glGetError();
    }
    return retCode;
}

void LLPostProcess::checkShaderError(GLhandleARB shader)
{
    GLint infologLength = 0;
    GLint charsWritten  = 0;
    GLchar *infoLog;

    checkError();  // Check for OpenGL errors

    glGetObjectParameterivARB(shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &infologLength);

    checkError();  // Check for OpenGL errors

    if (infologLength > 0)
    {
        infoLog = (GLchar *)malloc(infologLength);
        if (infoLog == NULL)
        {
            return;
        }
        glGetInfoLogARB(shader, infologLength, &charsWritten, infoLog);
                // shaderErrorLog << (char *) infoLog << std::endl;
                mShaderErrorString = (char *) infoLog;
        free(infoLog);
    }
    checkError();  // Check for OpenGL errors
}

void LLPostProcess::textureBlendReplace(void)
{       
        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_TEXTURE );
        glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR );
}

void LLPostProcess::textureBlendAdd(void)
{       
        glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE );
        glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD );
        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_TEXTURE );
        glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR );
}

void LLPostProcess::textureBlendAddSigned(void)
{       
        glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE );
        glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_ADD_SIGNED );
        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_TEXTURE );
        glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR );
}

void LLPostProcess::textureBlendSubtract(void)
{       
        glTexEnvi( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE );
        glTexEnvi( GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_SUBTRACT );
        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_TEXTURE );
        glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR );
}

void LLPostProcess::textureBlendAlpha(void)
{       
        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_OPERAND0_RGB, GL_SRC_COLOR );
        glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_PREVIOUS );
        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 );
}

void LLPostProcess::textureBlendMultiply(void)
{       
        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_PREVIOUS );
        glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR );
        glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE );
        glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR );
}

void LLPostProcess::textureBlendMultiplyX2(void)
{       
        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_PREVIOUS );
        glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND0_RGB, GL_SRC_COLOR );
        glTexEnvi( GL_TEXTURE_ENV, GL_SOURCE1_RGB, GL_TEXTURE );
        glTexEnvi( GL_TEXTURE_ENV, GL_OPERAND1_RGB, GL_SRC_COLOR );
        glTexEnvi( GL_TEXTURE_ENV, GL_RGB_SCALE, 2 );
}

---