Second Life viewer sources 1.21.0-RC

1 files changed, 574 insertions, 0 deletions

diff --git a/linden/indra/llrender/llpostprocess.cpp b/linden/indra/llrender/llpostprocess.cpp
new file mode 100644
index 0000000..c884951
--- /dev/null
+++ b/linden/indra/llrender/llpostprocess.cpp
@@ -0,0 +1,574 @@
+/** 
+ * @file llpostprocess.cpp
+ * @brief LLPostProcess class implementation
+ *
+ * $LicenseInfo:firstyear=2007&license=viewergpl$
+ * 
+ * Copyright (c) 2007-2008, Linden Research, Inc.
+ * 
+ * Second Life Viewer Source Code
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlifegrid.net/programs/open_source/licensing/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ * $/LicenseInfo$
+ */
+
+#include "linden_common.h"
+
+#include "llpostprocess.h"
+#include "llglslshader.h"
+#include "llsdserialize.h"
+#include "llrender.h"
+
+
+LLPostProcess * gPostProcess = NULL;
+
+
+static const unsigned int NOISE_SIZE = 512;
+
+/// CALCULATING LUMINANCE (Using NTSC lum weights)
+/// http://en.wikipedia.org/wiki/Luma_%28video%29
+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)
+{
+        /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
+        std::string 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);
+
+        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);
+
+                /// NVG Defaults
+                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;
+                
+                /// Bloom Defaults
+                defaultEffect["extract_low"] = 0.95;
+                defaultEffect["extract_high"] = 1.0;
+                defaultEffect["bloom_width"] = 2.25;
+                defaultEffect["bloom_strength"] = 1.5;
+
+                /// Color Filter Defaults
+                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)
+{
+        /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
+        mAllEffects[effectName] = tweaks;
+
+        std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight", XML_FILENAME));
+        //llinfos << "Saving PostProcess Effects settings to " << pathName << llendl;
+
+        llofstream effectsXML(pathName);
+
+        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 any of the above shaders have been called update the frame buffer;
+                if (tweaks.useColorFilter()){
+                        copyFrameBuffer(sceneRenderTexture, screenW, screenH);
+                }
+                applyNightVisionShader();
+                checkError();
+        }
+        if (tweaks.useBloomShader()){
+                /// If any of the above shaders have been called update the frame buffer;
+                if (tweaks.useColorFilter().asBoolean() || tweaks.useNightVisionShader().asBoolean()){
+                        copyFrameBuffer(sceneRenderTexture, screenW, screenH);
+                }
+                applyBloomShader();
+                checkError();
+        }
+}
+
+void LLPostProcess::applyColorFilterShader(void)
+{       
+        /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
+        gPostColorFilterProgram.bind();
+
+        gGL.getTexUnit(0)->activate();
+        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.setSceneBlendType(LLRender::BT_REPLACE);
+        LLGLDepthTest depth(GL_FALSE);
+                
+        /// Draw a screen space quad
+        drawOrthoQuad(screenW, screenH, QUAD_NORMAL);
+        gPostColorFilterProgram.unbind();
+        */
+}
+
+void LLPostProcess::createColorFilterShader(void)
+{
+        /// Define uniform names
+        colorFilterUniforms["RenderTexture"] = 0;
+        colorFilterUniforms["brightness"] = 0;
+        colorFilterUniforms["contrast"] = 0;
+        colorFilterUniforms["contrastBase"] = 0;
+        colorFilterUniforms["saturation"] = 0;
+        colorFilterUniforms["lumWeights"] = 0;
+}
+
+void LLPostProcess::applyNightVisionShader(void)
+{       
+        /*  Do nothing.  Needs to be updated to use our current shader system, and to work with the move into llrender.
+        gPostNightVisionProgram.bind();
+
+        gGL.getTexUnit(0)->activate();
+        glEnable(GL_TEXTURE_RECTANGLE_ARB);     
+
+        getShaderUniforms(nightVisionUniforms, gPostNightVisionProgram.mProgramObject);
+        glBindTexture(GL_TEXTURE_RECTANGLE_ARB, sceneRenderTexture);
+        glUniform1iARB(nightVisionUniforms["RenderTexture"], 0);
+
+        gGL.getTexUnit(1)->activate();
+        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.setSceneBlendType(LLRender::BT_REPLACE);
+        LLGLDepthTest depth(GL_FALSE);
+                
+        /// Draw a screen space quad
+        drawOrthoQuad(screenW, screenH, QUAD_NOISE);
+        gPostNightVisionProgram.unbind();
+        gGL.getTexUnit(0)->activate();
+        */
+}
+
+void LLPostProcess::createNightVisionShader(void)
+{
+        /// Define uniform names
+        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));
+
+        /// Create Bloom Extract Shader
+        bloomExtractUniforms["RenderTexture"] = 0;
+        bloomExtractUniforms["extractLow"] = 0;
+        bloomExtractUniforms["extractHigh"] = 0;        
+        bloomExtractUniforms["lumWeights"] = 0; 
+        
+        /// Create Bloom Blur Shader
+        bloomBlurUniforms["RenderTexture"] = 0;
+        bloomBlurUniforms["bloomStrength"] = 0; 
+        bloomBlurUniforms["texelSize"] = 0;
+        bloomBlurUniforms["blurDirection"] = 0;
+        bloomBlurUniforms["blurWidth"] = 0;
+}
+
+void LLPostProcess::getShaderUniforms(glslUniforms & uniforms, GLhandleARB & prog)
+{
+        /// Find uniform locations and insert into map  
+        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)
+{
+        /// Save GL State
+        glPushAttrib(GL_ALL_ATTRIB_BITS);
+        glPushClientAttrib(GL_ALL_ATTRIB_BITS);
+
+        /// Copy the screen buffer to the render texture
+        copyFrameBuffer(sceneRenderTexture, screenW, screenH);
+
+        /// Clear the frame buffer.
+        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+        glClear(GL_COLOR_BUFFER_BIT);
+        
+        /// Change to an orthogonal view
+        viewOrthogonal(screenW, screenH);
+        
+        checkError();
+        applyShaders();
+        
+        LLGLSLShader::bindNoShader();
+        checkError();
+
+        /// Change to a perspective view
+        viewPerspective();      
+
+        /// Reset GL State
+        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)
+        {
+            /// Could not allocate infolog buffer
+            return;
+        }
+        glGetInfoLogARB(shader, infologLength, &charsWritten, infoLog);
+                // shaderErrorLog << (char *) infoLog << std::endl;
+                mShaderErrorString = (char *) infoLog;
+        free(infoLog);
+    }
+    checkError();  // Check for OpenGL errors
+}