Merge pull request #854 from ey6es/glow

Three other glow techniques, with menu option to cycle between them.

interface/resources/shaders/diffuse.frag

@@ -0,0 +1,28 @@
+#version 120
+
+//
+//  diffuse.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 8/14/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+//
+
+// the texture containing the original color
+uniform sampler2D originalTexture;
+
+// the texture containing the diffused color
+uniform sampler2D diffusedTexture;
+
+void main(void) {
+    float ds = dFdx(gl_TexCoord[0].s);
+    float dt = dFdy(gl_TexCoord[0].t);
+    gl_FragColor = (texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(-ds, -dt)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(0.0, -dt)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(ds, -dt)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(ds, 0.0)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(ds, dt)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(0.0, dt)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(-ds, dt)) +
+        texture2D(diffusedTexture, gl_TexCoord[0].st + vec2(-ds, 0.0))) / 8.5 + texture2D(originalTexture, gl_TexCoord[0].st) * 0.1;
+}

interface/resources/shaders/glow_add.frag

@@ -0,0 +1,17 @@
+#version 120
+
+//
+//  glow_add.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 8/14/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+//
+
+// the texture containing the original color
+uniform sampler2D originalTexture;
+
+void main(void) {
+    vec4 color = texture2D(originalTexture, gl_TexCoord[0].st);
+    gl_FragColor = color * (1.0 + color.a);
+}

interface/resources/shaders/glow_add_separate.frag

@@ -0,0 +1,20 @@
+#version 120
+
+//
+//  glow_add_separate.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 8/14/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+//
+
+// the texture containing the original color
+uniform sampler2D originalTexture;
+
+// the texture containing the blurred color
+uniform sampler2D blurredTexture;
+
+void main(void) {
+    vec4 blurred = texture2D(blurredTexture, gl_TexCoord[0].st);
+    gl_FragColor = blurred * blurred.a + texture2D(originalTexture, gl_TexCoord[0].st) * (1.0 + blurred.a * 0.5);
+}

interface/resources/shaders/vertical_blur.frag

@@ -4,25 +4,21 @@
 //  vertical_blur.frag
 //  fragment shader
 //
-//  Created by Andrzej Kapolka on 8/8/13.
+//  Created by Andrzej Kapolka on 8/14/13.
 //  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
 //
 
-// the texture containing the original color
-uniform sampler2D originalTexture;
-
 // the texture containing the horizontally blurred color
-uniform sampler2D horizontallyBlurredTexture;
+uniform sampler2D originalTexture;
 
 void main(void) {
     float dt = dFdy(gl_TexCoord[0].t);
-    vec4 blurred = (texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -7.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -5.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -3.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -1.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 1.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 3.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 5.5)) +
-        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 7.5))) / 8.0;
-    gl_FragColor = blurred * blurred.a + texture2D(originalTexture, gl_TexCoord[0].st) * (1.0 + blurred.a * 0.5);
+    gl_FragColor = (texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * -7.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * -5.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * -3.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * -1.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * 1.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * 3.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * 5.5)) +
+        texture2D(originalTexture, gl_TexCoord[0].st + vec2(0.0, dt * 7.5))) / 8.0;
 }

interface/resources/shaders/vertical_blur_add.frag

@@ -0,0 +1,28 @@
+#version 120
+
+//
+//  vertical_blur_add.frag
+//  fragment shader
+//
+//  Created by Andrzej Kapolka on 8/8/13.
+//  Copyright (c) 2013 High Fidelity, Inc. All rights reserved.
+//
+
+// the texture containing the original color
+uniform sampler2D originalTexture;
+
+// the texture containing the horizontally blurred color
+uniform sampler2D horizontallyBlurredTexture;
+
+void main(void) {
+    float dt = dFdy(gl_TexCoord[0].t);
+    vec4 blurred = (texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -7.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -5.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -3.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * -1.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 1.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 3.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 5.5)) +
+        texture2D(horizontallyBlurredTexture, gl_TexCoord[0].st + vec2(0.0, dt * 7.5))) / 8.0;
+    gl_FragColor = blurred * blurred.a + texture2D(originalTexture, gl_TexCoord[0].st) * (1.0 + blurred.a * 0.5);
+}

interface/src/Application.cpp

@@ -1897,6 +1897,7 @@ void Application::initMenu() {
     _renderAvatarBalls->setChecked(false);
     renderMenu->addAction("Cycle Voxel Mode", _myAvatar.getVoxels(), SLOT(cycleMode()));
     renderMenu->addAction("Cycle Face Mode", &_myAvatar.getHead().getFace(), SLOT(cycleRenderMode()));
+    renderMenu->addAction("Cycle Glow Mode", &_glowEffect, SLOT(cycleRenderMode()));
     (_renderFrameTimerOn = renderMenu->addAction("Show Timer"))->setCheckable(true);
     _renderFrameTimerOn->setChecked(false);
     (_renderLookatOn = renderMenu->addAction("Lookat Vectors"))->setCheckable(true);

interface/src/renderer/GlowEffect.cpp

@@ -14,9 +14,12 @@
 #include "GlowEffect.h"
 #include "ProgramObject.h"
 
-static ProgramObject* createBlurProgram(const QString& direction) {
+GlowEffect::GlowEffect() : _renderMode(BLUR_ADD_MODE) {
+}
+
+static ProgramObject* createProgram(const QString& name) {
     ProgramObject* program = new ProgramObject();
-    program->addShaderFromSourceFile(QGLShader::Fragment, "resources/shaders/" + direction + "_blur.frag");
+    program->addShaderFromSourceFile(QGLShader::Fragment, "resources/shaders/" + name + ".frag");
     program->link();
     
     program->bind();
@@ -28,12 +31,25 @@ static ProgramObject* createBlurProgram(const QString& direction) {
 
 void GlowEffect::init() {
     switchToResourcesParentIfRequired();
-    _horizontalBlurProgram = createBlurProgram("horizontal");
-    _verticalBlurProgram = createBlurProgram("vertical");
     
-    _verticalBlurProgram->bind();
-    _verticalBlurProgram->setUniformValue("horizontallyBlurredTexture", 1);
-    _verticalBlurProgram->release();
+    _addProgram = createProgram("glow_add");
+    _horizontalBlurProgram = createProgram("horizontal_blur");
+    _verticalBlurAddProgram = createProgram("vertical_blur_add");
+    _verticalBlurProgram = createProgram("vertical_blur");
+    _addSeparateProgram = createProgram("glow_add_separate");
+    _diffuseProgram = createProgram("diffuse");
+    
+    _verticalBlurAddProgram->bind();
+    _verticalBlurAddProgram->setUniformValue("horizontallyBlurredTexture", 1);
+    _verticalBlurAddProgram->release();
+    
+    _addSeparateProgram->bind();
+    _addSeparateProgram->setUniformValue("blurredTexture", 1);
+    _addSeparateProgram->release();
+    
+    _diffuseProgram->bind();
+    _diffuseProgram->setUniformValue("diffusedTexture", 1);
+    _diffuseProgram->release();
 }
 
 void GlowEffect::prepare() {
@@ -43,8 +59,8 @@ void GlowEffect::prepare() {
     _isEmpty = true;
 }
 
-void GlowEffect::begin(float amount) {
-    glBlendColor(0.0f, 0.0f, 0.0f, amount);
+void GlowEffect::begin(float intensity) {
+    glBlendColor(0.0f, 0.0f, 0.0f, intensity);
     _isEmpty = false;
 }
 
@@ -93,7 +109,42 @@ void GlowEffect::render() {
             glDisable(GL_TEXTURE_2D);
             glEnable(GL_LIGHTING);
         }
-    } else {
+    } else if (_renderMode == ADD_MODE) {
+        _addProgram->bind();
+        renderFullscreenQuad();
+        _addProgram->release();
+    
+    } else if (_renderMode == DIFFUSE_ADD_MODE) {
+        // diffuse into the secondary/tertiary (alternating between frames)
+        QOpenGLFramebufferObject* oldDiffusedFBO =
+            Application::getInstance()->getTextureCache()->getSecondaryFramebufferObject();
+        QOpenGLFramebufferObject* newDiffusedFBO =
+            Application::getInstance()->getTextureCache()->getTertiaryFramebufferObject();
+        if ((_isOddFrame = !_isOddFrame)) {
+            qSwap(oldDiffusedFBO, newDiffusedFBO);
+        }
+        newDiffusedFBO->bind();
+        
+        glActiveTexture(GL_TEXTURE1);
+        glBindTexture(GL_TEXTURE_2D, oldDiffusedFBO->texture());
+            
+        _diffuseProgram->bind();
+        renderFullscreenQuad();
+        _diffuseProgram->release();
+        
+        newDiffusedFBO->release();
+        
+        // add diffused texture to the primary
+        glBindTexture(GL_TEXTURE_2D, newDiffusedFBO->texture());
+        
+        _addSeparateProgram->bind();      
+        renderFullscreenQuad();
+        _addSeparateProgram->release();
+        
+        glBindTexture(GL_TEXTURE_2D, 0);
+        glActiveTexture(GL_TEXTURE0);
+        
+    } else { // _renderMode == BLUR_ADD_MODE || _renderMode == BLUR_PERSIST_ADD_MODE
         // render the primary to the secondary with the horizontal blur
         QOpenGLFramebufferObject* secondaryFBO =
             Application::getInstance()->getTextureCache()->getSecondaryFramebufferObject();
@@ -105,13 +156,48 @@ void GlowEffect::render() {
      
         secondaryFBO->release();
         
-        // render the secondary to the screen with the vertical blur
-        glActiveTexture(GL_TEXTURE1);
-        glBindTexture(GL_TEXTURE_2D, secondaryFBO->texture());
+        if (_renderMode == BLUR_ADD_MODE) {
+            // render the secondary to the screen with the vertical blur
+            glActiveTexture(GL_TEXTURE1);
+            glBindTexture(GL_TEXTURE_2D, secondaryFBO->texture());
+            
+            _verticalBlurAddProgram->bind();      
+            renderFullscreenQuad();
+            _verticalBlurAddProgram->release();
+            
+        } else { // _renderMode == BLUR_PERSIST_ADD_MODE
+            // render the secondary to the tertiary with horizontal blur and persistence
+            QOpenGLFramebufferObject* tertiaryFBO =
+                Application::getInstance()->getTextureCache()->getTertiaryFramebufferObject();
+            tertiaryFBO->bind();
+            
+            glEnable(GL_BLEND);
+            glBlendFunc(GL_ONE_MINUS_CONSTANT_ALPHA, GL_CONSTANT_ALPHA);
+            const float PERSISTENCE_SMOOTHING = 0.9f;
+            glBlendColor(0.0f, 0.0f, 0.0f, PERSISTENCE_SMOOTHING);
+            
+            glBindTexture(GL_TEXTURE_2D, secondaryFBO->texture());
+            
+            _verticalBlurProgram->bind();      
+            renderFullscreenQuad();
+            _verticalBlurProgram->release();
         
-        _verticalBlurProgram->bind();      
-        renderFullscreenQuad();
-        _verticalBlurProgram->release();
+            glBlendColor(0.0f, 0.0f, 0.0f, 0.0f);
+            glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
+            glDisable(GL_BLEND);
+        
+            // now add the tertiary to the primary buffer
+            tertiaryFBO->release();
+            
+            glBindTexture(GL_TEXTURE_2D, primaryFBO->texture());
+            
+            glActiveTexture(GL_TEXTURE1);
+            glBindTexture(GL_TEXTURE_2D, tertiaryFBO->texture());
+            
+            _addSeparateProgram->bind();      
+            renderFullscreenQuad();
+            _addSeparateProgram->release();
+        }
         
         glBindTexture(GL_TEXTURE_2D, 0);
         glActiveTexture(GL_TEXTURE0);
@@ -126,3 +212,7 @@ void GlowEffect::render() {
     glEnable(GL_DEPTH_TEST);
     glBindTexture(GL_TEXTURE_2D, 0);
 }
+
+void GlowEffect::cycleRenderMode() {
+    _renderMode = (RenderMode)((_renderMode + 1) % RENDER_MODE_COUNT);
+}

interface/src/renderer/GlowEffect.h

@@ -9,26 +9,51 @@
 #ifndef __interface__GlowEffect__
 #define __interface__GlowEffect__
 
+#include <QObject>
+
 class ProgramObject;
 
-class GlowEffect {
+/// A generic full screen glow effect.
+class GlowEffect : public QObject {
+    Q_OBJECT
+    
 public:
     
+    GlowEffect();
+    
     void init();
     
+    /// Prepares the glow effect for rendering the current frame.  To be called before rendering the scene.
     void prepare();
     
-    void begin(float amount = 1.0f);
+    /// Starts using the glow effect.
+    /// \param intensity the desired glow intensity, from zero to one
+    void begin(float intensity = 1.0f);
+    
+    /// Stops using the glow effect.
     void end();
     
+    /// Renders the glow effect.  To be called after rendering the scene.
     void render();
 
+public slots:
+    
+    void cycleRenderMode();
+    
 private:
     
-    ProgramObject* _horizontalBlurProgram;
-    ProgramObject* _verticalBlurProgram;
+    enum RenderMode { ADD_MODE, BLUR_ADD_MODE, BLUR_PERSIST_ADD_MODE, DIFFUSE_ADD_MODE, RENDER_MODE_COUNT };
     
-    bool _isEmpty;
+    RenderMode _renderMode;
+    ProgramObject* _addProgram;
+    ProgramObject* _horizontalBlurProgram;
+    ProgramObject* _verticalBlurAddProgram;
+    ProgramObject* _verticalBlurProgram;
+    ProgramObject* _addSeparateProgram;
+    ProgramObject* _diffuseProgram;
+    
+    bool _isEmpty; ///< set when nothing in the scene is currently glowing
+    bool _isOddFrame; ///< controls the alternation between texture targets in diffuse add mode
 };
 
 #endif /* defined(__interface__GlowEffect__) */

interface/src/renderer/TextureCache.cpp

@@ -14,7 +14,7 @@
 #include "TextureCache.h"
 
 TextureCache::TextureCache() : _permutationNormalTextureID(0),
-    _primaryFramebufferObject(NULL), _secondaryFramebufferObject(NULL) {
+    _primaryFramebufferObject(NULL), _secondaryFramebufferObject(NULL), _tertiaryFramebufferObject(NULL) {
 }
 
 TextureCache::~TextureCache() {
@@ -27,6 +27,9 @@ TextureCache::~TextureCache() {
     if (_secondaryFramebufferObject != NULL) {
         delete _secondaryFramebufferObject;
     }
+    if (_tertiaryFramebufferObject != NULL) {
+        delete _tertiaryFramebufferObject;
+    }
 }
 
 GLuint TextureCache::getPermutationNormalTextureID() {
@@ -72,6 +75,14 @@ QOpenGLFramebufferObject* TextureCache::getSecondaryFramebufferObject() {
     return _secondaryFramebufferObject;
 }
 
+QOpenGLFramebufferObject* TextureCache::getTertiaryFramebufferObject() {
+    if (_tertiaryFramebufferObject == NULL) {
+        _tertiaryFramebufferObject = new QOpenGLFramebufferObject(Application::getInstance()->getGLWidget()->size());
+        Application::getInstance()->getGLWidget()->installEventFilter(this);
+    }
+    return _tertiaryFramebufferObject;
+}
+
 bool TextureCache::eventFilter(QObject* watched, QEvent* event) {
     if (event->type() == QEvent::Resize) {
         QSize size = static_cast<QResizeEvent*>(event)->size();
@@ -83,6 +94,10 @@ bool TextureCache::eventFilter(QObject* watched, QEvent* event) {
             delete _secondaryFramebufferObject;
             _secondaryFramebufferObject = NULL;
         }
+        if (_tertiaryFramebufferObject != NULL && _tertiaryFramebufferObject->size() != size) {
+            delete _tertiaryFramebufferObject;
+            _tertiaryFramebufferObject = NULL;
+        }
     }
     return false;
 }

interface/src/renderer/TextureCache.h

@@ -25,7 +25,8 @@ public:
 
     QOpenGLFramebufferObject* getPrimaryFramebufferObject();
     QOpenGLFramebufferObject* getSecondaryFramebufferObject();
-
+    QOpenGLFramebufferObject* getTertiaryFramebufferObject();
+    
     virtual bool eventFilter(QObject* watched, QEvent* event);
 
 private:
@@ -34,6 +35,7 @@ private:
     
     QOpenGLFramebufferObject* _primaryFramebufferObject;
     QOpenGLFramebufferObject* _secondaryFramebufferObject;
+    QOpenGLFramebufferObject* _tertiaryFramebufferObject;
 };
 
 #endif /* defined(__interface__TextureCache__) */