Merge branch 'master' of https://github.com/highfidelity/hifi into atmosphereBatchFix

interface/src/ui/overlays/BillboardOverlay.cpp

@@ -43,16 +43,6 @@ void BillboardOverlay::render(RenderArgs* args) {
         return;
     }
 
-    glEnable(GL_ALPHA_TEST);
-    glAlphaFunc(GL_GREATER, 0.5f);
-
-    glEnable(GL_TEXTURE_2D);
-    glDisable(GL_LIGHTING);
-
-    glBindTexture(GL_TEXTURE_2D, _texture->getID());
-
-    glPushMatrix(); {
-        glTranslatef(_position.x, _position.y, _position.z);
     glm::quat rotation;
     if (_isFacingAvatar) {
         // rotate about vertical to face the camera
@@ -62,13 +52,6 @@ void BillboardOverlay::render(RenderArgs* args) {
     } else {
         rotation = getRotation();
     }
-        glm::vec3 axis = glm::axis(rotation);
-        glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
-        glScalef(_scale, _scale, _scale);
-
-        const float MAX_COLOR = 255.0f;
-        xColor color = getColor();
-        float alpha = getAlpha();
 
     float imageWidth = _texture->getWidth();
     float imageHeight = _texture->getHeight();
@@ -99,6 +82,40 @@ void BillboardOverlay::render(RenderArgs* args) {
     glm::vec2 texCoordBottomRight((fromImage.x() + fromImage.width()) / imageWidth,
                                   (fromImage.y() + fromImage.height()) / imageHeight);
 
+    const float MAX_COLOR = 255.0f;
+    xColor color = getColor();
+    float alpha = getAlpha();
+
+    auto batch = args->_batch;
+
+    if (batch) {
+        Transform transform;
+        transform.setTranslation(_position);
+        transform.setRotation(rotation);
+        transform.setScale(_scale);
+
+        batch->setModelTransform(transform);
+        batch->setUniformTexture(0, _texture->getGPUTexture());
+        
+        DependencyManager::get<GeometryCache>()->renderQuad(*batch, topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight,
+                                                            glm::vec4(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha));
+    
+        batch->setUniformTexture(0, args->_whiteTexture); // restore default white color after me
+    } else {
+        glEnable(GL_ALPHA_TEST);
+        glAlphaFunc(GL_GREATER, 0.5f);
+
+        glEnable(GL_TEXTURE_2D);
+        glDisable(GL_LIGHTING);
+
+        glBindTexture(GL_TEXTURE_2D, _texture->getID());
+
+        glPushMatrix(); {
+            glTranslatef(_position.x, _position.y, _position.z);
+            glm::vec3 axis = glm::axis(rotation);
+            glRotatef(glm::degrees(glm::angle(rotation)), axis.x, axis.y, axis.z);
+            glScalef(_scale, _scale, _scale);
+
             DependencyManager::get<GeometryCache>()->renderQuad(topLeft, bottomRight, texCoordTopLeft, texCoordBottomRight,
                                                                 glm::vec4(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha));
 
@@ -109,6 +126,7 @@ void BillboardOverlay::render(RenderArgs* args) {
         glDisable(GL_ALPHA_TEST);
 
         glBindTexture(GL_TEXTURE_2D, 0);
+    }
 }
 
 void BillboardOverlay::setProperties(const QScriptValue &properties) {

interface/src/ui/overlays/Cube3DOverlay.cpp

@@ -35,13 +35,6 @@ void Cube3DOverlay::render(RenderArgs* args) {
         return; // do nothing if we're not visible
     }
 
-
-    float glowLevel = getGlowLevel();
-    Glower* glower = NULL;
-    if (glowLevel > 0.0f) {
-        glower = new Glower(glowLevel);
-    }
-
     float alpha = getAlpha();
     xColor color = getColor();
     const float MAX_COLOR = 255.0f;
@@ -55,6 +48,75 @@ void Cube3DOverlay::render(RenderArgs* args) {
     glm::vec3 dimensions = getDimensions();
     glm::quat rotation = getRotation();
 
+    auto batch = args->_batch;
+
+    if (batch) {
+        Transform transform;
+        transform.setTranslation(position);
+        transform.setRotation(rotation);
+        if (_isSolid) {
+            // if (_borderSize > 0) {
+            //     // Draw a cube at a larger size behind the main cube, creating
+            //     // a border effect.
+            //     // Disable writing to the depth mask so that the "border" cube will not
+            //     // occlude the main cube.  This means the border could be covered by
+            //     // overlays that are further back and drawn later, but this is good
+            //     // enough for the use-case.
+            //     transform.setScale(dimensions * _borderSize);
+            //     batch->setModelTransform(transform);
+            //     DependencyManager::get<GeometryCache>()->renderSolidCube(*batch, 1.0f, glm::vec4(1.0f, 1.0f, 1.0f, alpha));
+            // }
+
+            transform.setScale(dimensions);
+            batch->setModelTransform(transform);
+            DependencyManager::get<GeometryCache>()->renderSolidCube(*batch, 1.0f, cubeColor);
+        } else {
+
+            if (getIsDashedLine()) {
+                transform.setScale(1.0f);
+                batch->setModelTransform(transform);
+
+                glm::vec3 halfDimensions = dimensions / 2.0f;
+                glm::vec3 bottomLeftNear(-halfDimensions.x, -halfDimensions.y, -halfDimensions.z);
+                glm::vec3 bottomRightNear(halfDimensions.x, -halfDimensions.y, -halfDimensions.z);
+                glm::vec3 topLeftNear(-halfDimensions.x, halfDimensions.y, -halfDimensions.z);
+                glm::vec3 topRightNear(halfDimensions.x, halfDimensions.y, -halfDimensions.z);
+
+                glm::vec3 bottomLeftFar(-halfDimensions.x, -halfDimensions.y, halfDimensions.z);
+                glm::vec3 bottomRightFar(halfDimensions.x, -halfDimensions.y, halfDimensions.z);
+                glm::vec3 topLeftFar(-halfDimensions.x, halfDimensions.y, halfDimensions.z);
+                glm::vec3 topRightFar(halfDimensions.x, halfDimensions.y, halfDimensions.z);
+
+                auto geometryCache = DependencyManager::get<GeometryCache>();
+
+                geometryCache->renderDashedLine(*batch, bottomLeftNear, bottomRightNear, cubeColor);
+                geometryCache->renderDashedLine(*batch, bottomRightNear, bottomRightFar, cubeColor);
+                geometryCache->renderDashedLine(*batch, bottomRightFar, bottomLeftFar, cubeColor);
+                geometryCache->renderDashedLine(*batch, bottomLeftFar, bottomLeftNear, cubeColor);
+
+                geometryCache->renderDashedLine(*batch, topLeftNear, topRightNear, cubeColor);
+                geometryCache->renderDashedLine(*batch, topRightNear, topRightFar, cubeColor);
+                geometryCache->renderDashedLine(*batch, topRightFar, topLeftFar, cubeColor);
+                geometryCache->renderDashedLine(*batch, topLeftFar, topLeftNear, cubeColor);
+
+                geometryCache->renderDashedLine(*batch, bottomLeftNear, topLeftNear, cubeColor);
+                geometryCache->renderDashedLine(*batch, bottomRightNear, topRightNear, cubeColor);
+                geometryCache->renderDashedLine(*batch, bottomLeftFar, topLeftFar, cubeColor);
+                geometryCache->renderDashedLine(*batch, bottomRightFar, topRightFar, cubeColor);
+
+            } else {
+                transform.setScale(dimensions);
+                batch->setModelTransform(transform);
+                DependencyManager::get<DeferredLightingEffect>()->renderWireCube(*batch, 1.0f, cubeColor);
+            }
+        }
+    } else {
+        float glowLevel = getGlowLevel();
+        Glower* glower = NULL;
+        if (glowLevel > 0.0f) {
+            glower = new Glower(glowLevel);
+        }
+
         glPushMatrix();
             glTranslatef(position.x, position.y, position.z);
             glm::vec3 axis = glm::axis(rotation);
@@ -135,6 +197,7 @@ void Cube3DOverlay::render(RenderArgs* args) {
         if (glower) {
             delete glower;
         }
+    }
 }
 
 Cube3DOverlay* Cube3DOverlay::createClone() const {

interface/src/ui/overlays/Grid3DOverlay.cpp

@@ -36,6 +36,59 @@ void Grid3DOverlay::render(RenderArgs* args) {
         return; // do nothing if we're not visible
     }
 
+    const int MINOR_GRID_DIVISIONS = 200;
+    const int MAJOR_GRID_DIVISIONS = 100;
+    const float MAX_COLOR = 255.0f;
+
+    // center the grid around the camera position on the plane
+    glm::vec3 rotated = glm::inverse(_rotation) * Application::getInstance()->getCamera()->getPosition();
+
+    float spacing = _minorGridWidth;
+
+    float alpha = getAlpha();
+    xColor color = getColor();
+    glm::vec4 gridColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
+
+    auto batch = args->_batch;
+
+    if (batch) {
+        Transform transform;
+        transform.setRotation(_rotation);
+
+
+        // Minor grid
+        {
+            batch->_glLineWidth(1.0f);
+            auto position = glm::vec3(_minorGridWidth * (floorf(rotated.x / spacing) - MINOR_GRID_DIVISIONS / 2),
+                                      spacing * (floorf(rotated.y / spacing) - MINOR_GRID_DIVISIONS / 2),
+                                      _position.z);
+            float scale = MINOR_GRID_DIVISIONS * spacing;
+
+            transform.setTranslation(position);
+            transform.setScale(scale);
+
+            batch->setModelTransform(transform);
+
+            DependencyManager::get<GeometryCache>()->renderGrid(*batch, MINOR_GRID_DIVISIONS, MINOR_GRID_DIVISIONS, gridColor);
+        }
+
+        // Major grid
+        {
+            batch->_glLineWidth(4.0f);
+            spacing *= _majorGridEvery;
+            auto position = glm::vec3(spacing * (floorf(rotated.x / spacing) - MAJOR_GRID_DIVISIONS / 2),
+                                      spacing * (floorf(rotated.y / spacing) - MAJOR_GRID_DIVISIONS / 2),
+                                      _position.z);
+            float scale = MAJOR_GRID_DIVISIONS * spacing;
+
+            transform.setTranslation(position);
+            transform.setScale(scale);
+
+            batch->setModelTransform(transform);
+
+            DependencyManager::get<GeometryCache>()->renderGrid(*batch, MAJOR_GRID_DIVISIONS, MAJOR_GRID_DIVISIONS, gridColor);
+        }
+    } else {
         if (!_gridProgram.isLinked()) {
             if (!_gridProgram.addShaderFromSourceFile(QGLShader::Vertex, PathUtils::resourcesPath() + "shaders/grid.vert")) {
                 qDebug() << "Failed to compile: " + _gridProgram.log();
@@ -66,21 +119,8 @@ void Grid3DOverlay::render(RenderArgs* args) {
 
         glLineWidth(1.5f);
 
-    // center the grid around the camera position on the plane
-    glm::vec3 rotated = glm::inverse(rotation) * Application::getInstance()->getCamera()->getPosition();
-    float spacing = _minorGridWidth;
-
-    float alpha = getAlpha();
-    xColor color = getColor();
         glm::vec3 position = getPosition();
 
-    const int MINOR_GRID_DIVISIONS = 200;
-    const int MAJOR_GRID_DIVISIONS = 100;
-    const float MAX_COLOR = 255.0f;
-
-
-    glm::vec4 gridColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
-
         _gridProgram.bind();
 
         // Minor grid
@@ -117,6 +157,7 @@ void Grid3DOverlay::render(RenderArgs* args) {
 
         glEnable(GL_LIGHTING);
         glDepthMask(GL_TRUE);
+    }
 }
 
 void Grid3DOverlay::setProperties(const QScriptValue& properties) {

interface/src/ui/overlays/Line3DOverlay.cpp

@@ -37,6 +37,26 @@ void Line3DOverlay::render(RenderArgs* args) {
         return; // do nothing if we're not visible
     }
 
+    float alpha = getAlpha();
+    xColor color = getColor();
+    const float MAX_COLOR = 255.0f;
+    glm::vec4 colorv4(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
+
+    auto batch = args->_batch;
+
+    if (batch) {
+        Transform transform;
+        transform.setTranslation(_position);
+        transform.setRotation(_rotation);
+        batch->setModelTransform(transform);
+
+        if (getIsDashedLine()) {
+            // TODO: add support for color to renderDashedLine()
+            DependencyManager::get<GeometryCache>()->renderDashedLine(*batch, _position, _end, colorv4, _geometryCacheID);
+        } else {
+            DependencyManager::get<GeometryCache>()->renderLine(*batch, _start, _end, colorv4, _geometryCacheID);
+        }
+    } else {
         float glowLevel = getGlowLevel();
         Glower* glower = NULL;
         if (glowLevel > 0.0f) {
@@ -48,11 +68,6 @@ void Line3DOverlay::render(RenderArgs* args) {
         glDisable(GL_LIGHTING);
         glLineWidth(_lineWidth);
 
-    float alpha = getAlpha();
-    xColor color = getColor();
-    const float MAX_COLOR = 255.0f;
-    glm::vec4 colorv4(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
-
         glm::vec3 position = getPosition();
         glm::quat rotation = getRotation();
 
@@ -73,6 +88,7 @@ void Line3DOverlay::render(RenderArgs* args) {
         if (glower) {
             delete glower;
         }
+    }
 }
 
 void Line3DOverlay::setProperties(const QScriptValue& properties) {

interface/src/ui/overlays/OverlaysPayload.cpp

@@ -66,8 +66,8 @@ namespace render {
     }
     template <> void payloadRender(const Overlay::Pointer& overlay, RenderArgs* args) {
         if (args) {
-            glPushMatrix();
             if (overlay->getAnchor() == Overlay::MY_AVATAR) {
+                glPushMatrix();
                 MyAvatar* avatar = DependencyManager::get<AvatarManager>()->getMyAvatar();
                 glm::quat myAvatarRotation = avatar->getOrientation();
                 glm::vec3 myAvatarPosition = avatar->getPosition();
@@ -78,9 +78,11 @@ namespace render {
                 glTranslatef(myAvatarPosition.x, myAvatarPosition.y, myAvatarPosition.z);
                 glRotatef(angle, axis.x, axis.y, axis.z);
                 glScalef(myAvatarScale, myAvatarScale, myAvatarScale);
-            }
                 overlay->render(args);
                 glPopMatrix();
+            } else {
+                overlay->render(args);
+            }
         }
     }
 }

interface/src/ui/overlays/Rectangle3DOverlay.cpp

@@ -41,14 +41,55 @@ void Rectangle3DOverlay::render(RenderArgs* args) {
     const float MAX_COLOR = 255.0f;
     glm::vec4 rectangleColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
 
-    glDisable(GL_LIGHTING);
-    
     glm::vec3 position = getPosition();
     glm::vec3 center = getCenter();
     glm::vec2 dimensions = getDimensions();
     glm::vec2 halfDimensions = dimensions * 0.5f;
     glm::quat rotation = getRotation();
 
+    auto batch = args->_batch;
+
+    if (batch) {
+        Transform transform;
+        transform.setTranslation(position);
+        transform.setRotation(rotation);
+
+        batch->setModelTransform(transform);
+
+        if (getIsSolid()) {
+            glm::vec3 topLeft(-halfDimensions.x, -halfDimensions.y, 0.0f);
+            glm::vec3 bottomRight(halfDimensions.x, halfDimensions.y, 0.0f);
+            DependencyManager::get<GeometryCache>()->renderQuad(*batch, topLeft, bottomRight, rectangleColor);
+        } else {
+            auto geometryCache = DependencyManager::get<GeometryCache>();
+            if (getIsDashedLine()) {
+                glm::vec3 point1(-halfDimensions.x, -halfDimensions.y, 0.0f);
+                glm::vec3 point2(halfDimensions.x, -halfDimensions.y, 0.0f);
+                glm::vec3 point3(halfDimensions.x, halfDimensions.y, 0.0f);
+                glm::vec3 point4(-halfDimensions.x, halfDimensions.y, 0.0f);
+            
+                geometryCache->renderDashedLine(*batch, point1, point2, rectangleColor);
+                geometryCache->renderDashedLine(*batch, point2, point3, rectangleColor);
+                geometryCache->renderDashedLine(*batch, point3, point4, rectangleColor);
+                geometryCache->renderDashedLine(*batch, point4, point1, rectangleColor);
+            } else {
+                if (halfDimensions != _previousHalfDimensions) {
+                    QVector<glm::vec3> border;
+                    border << glm::vec3(-halfDimensions.x, -halfDimensions.y, 0.0f);
+                    border << glm::vec3(halfDimensions.x, -halfDimensions.y, 0.0f);
+                    border << glm::vec3(halfDimensions.x, halfDimensions.y, 0.0f);
+                    border << glm::vec3(-halfDimensions.x, halfDimensions.y, 0.0f);
+                    border << glm::vec3(-halfDimensions.x, -halfDimensions.y, 0.0f);
+                    geometryCache->updateVertices(_geometryCacheID, border, rectangleColor);
+
+                    _previousHalfDimensions = halfDimensions;
+                }
+                geometryCache->renderVertices(*batch, gpu::LINE_STRIP, _geometryCacheID);
+            }
+        }
+    } else {
+        glDisable(GL_LIGHTING);
+        
         float glowLevel = getGlowLevel();
         Glower* glower = NULL;
         if (glowLevel > 0.0f) {
@@ -110,6 +151,7 @@ void Rectangle3DOverlay::render(RenderArgs* args) {
         if (glower) {
             delete glower;
         }
+    }
 }
 
 void Rectangle3DOverlay::setProperties(const QScriptValue &properties) {

interface/src/ui/overlays/Sphere3DOverlay.cpp

@@ -39,6 +39,17 @@ void Sphere3DOverlay::render(RenderArgs* args) {
     const float MAX_COLOR = 255.0f;
     glm::vec4 sphereColor(color.red / MAX_COLOR, color.green / MAX_COLOR, color.blue / MAX_COLOR, alpha);
 
+    auto batch = args->_batch;
+
+    if (batch) {
+        Transform transform;
+        transform.setTranslation(_position);
+        transform.setRotation(_rotation);
+        transform.setScale(_dimensions);
+
+        batch->setModelTransform(transform);
+        DependencyManager::get<GeometryCache>()->renderSphere(*batch, 1.0f, SLICES, SLICES, sphereColor, _isSolid);
+    } else {
         glDisable(GL_LIGHTING);
         
         glm::vec3 position = getPosition();
@@ -67,6 +78,7 @@ void Sphere3DOverlay::render(RenderArgs* args) {
         if (glower) {
             delete glower;
         }
+    }
 
 }
 

libraries/gpu/src/gpu/GLBackendShader.cpp

@@ -61,6 +61,10 @@ void makeBindings(GLBackend::GLShader* shader) {
     if (loc >= 0) {
         glBindAttribLocation(glprogram, gpu::Stream::TEXCOORD, "texcoord");
     }
+    loc = glGetAttribLocation(glprogram, "attribTexcoord");
+    if (loc >= 0) {
+        glBindAttribLocation(glprogram, gpu::Stream::TEXCOORD, "attribTexcoord");
+    }
     
     loc = glGetAttribLocation(glprogram, "tangent");
     if (loc >= 0) {

libraries/render-utils/src/RenderDeferredTask.cpp

@@ -15,9 +15,12 @@
 #include "DeferredLightingEffect.h"
 #include "ViewFrustum.h"
 #include "RenderArgs.h"
+#include "TextureCache.h"
 
 #include <PerfStat.h>
 
+#include "overlay3D_vert.h"
+#include "overlay3D_frag.h"
 
 using namespace render;
 
@@ -50,7 +53,7 @@ RenderDeferredTask::RenderDeferredTask() : Task() {
    _jobs.push_back(Job(RenderDeferred()));
    _jobs.push_back(Job(ResolveDeferred()));
    _jobs.push_back(Job(DrawTransparentDeferred()));
-   _jobs.push_back(Job(DrawPostLayered()));
+   _jobs.push_back(Job(DrawOverlay3D()));
    _jobs.push_back(Job(ResetGLState()));
 }
 
@@ -225,10 +228,76 @@ template <> void render::jobRun(const DrawTransparentDeferred& job, const SceneC
 
         renderItems(sceneContext, renderContext, renderedItems, renderContext->_maxDrawnTransparentItems);
 
+        // Before rendering the batch make sure we re in sync with gl state
+        args->_context->syncCache();
         args->_context->render((*args->_batch));
         args->_batch = nullptr;
 
         // reset blend function to standard...
-        glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
+       // glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_CONSTANT_ALPHA, GL_ONE);
     }
 }
+
+const gpu::PipelinePointer& DrawOverlay3D::getOpaquePipeline() const {
+    if (!_opaquePipeline) {
+        auto vs = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(overlay3D_vert)));
+        auto ps = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(overlay3D_frag)));
+        
+        auto program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps));
+
+        auto state = gpu::StatePointer(new gpu::State());
+        state->setDepthTest(true, true, gpu::LESS_EQUAL);
+
+        _opaquePipeline.reset(gpu::Pipeline::create(program, state));
+    }
+    return _opaquePipeline;
+}
+
+template <> void render::jobRun(const DrawOverlay3D& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext) {
+      PerformanceTimer perfTimer("DrawOverlay3D");
+    assert(renderContext->args);
+    assert(renderContext->args->_viewFrustum);
+
+    // render backgrounds
+    auto& scene = sceneContext->_scene;
+    auto& items = scene->getMasterBucket().at(ItemFilter::Builder::opaqueShape().withLayered());
+
+
+    ItemIDsBounds inItems;
+    inItems.reserve(items.size());
+    for (auto id : items) {
+        auto& item = scene->getItem(id);
+        if (item.getKey().isVisible() && (item.getLayer() == 1)) {
+            inItems.emplace_back(id);
+        }
+    }
+ 
+    RenderArgs* args = renderContext->args;
+    gpu::Batch batch;
+    args->_batch = &batch;
+    args->_whiteTexture = DependencyManager::get<TextureCache>()->getWhiteTexture();
+
+
+    glm::mat4 projMat;
+    Transform viewMat;
+    args->_viewFrustum->evalProjectionMatrix(projMat);
+    args->_viewFrustum->evalViewTransform(viewMat);
+    if (args->_renderMode == RenderArgs::MIRROR_RENDER_MODE) {
+        viewMat.postScale(glm::vec3(-1.0f, 1.0f, 1.0f));
+    }
+    batch.setProjectionTransform(projMat);
+    batch.setViewTransform(viewMat);
+    batch.setPipeline(job.getOpaquePipeline());
+    batch.setUniformTexture(0, args->_whiteTexture);
+
+    if (!inItems.empty()) {
+        batch.clearFramebuffer(gpu::Framebuffer::BUFFER_DEPTH, glm::vec4(), 1.f, 0);
+        renderItems(sceneContext, renderContext, inItems);
+    }
+
+    // Before rendering the batch make sure we re in sync with gl state
+    args->_context->syncCache();
+    args->_context->render((*args->_batch));
+    args->_batch = nullptr;
+    args->_whiteTexture.reset();
+}

libraries/render-utils/src/RenderDeferredTask.h

@@ -14,6 +14,8 @@
 
 #include "render/DrawTask.h"
 
+#include "gpu/Pipeline.h"
+
 class PrepareDeferred {
 public:
 };
@@ -50,6 +52,15 @@ namespace render {
 template <> void jobRun(const DrawTransparentDeferred& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
 }
 
+class DrawOverlay3D {
+    mutable gpu::PipelinePointer _opaquePipeline; //lazy evaluation hence mutable
+public:
+    const gpu::PipelinePointer& getOpaquePipeline() const;
+};
+namespace render {
+template <> void jobRun(const DrawOverlay3D& job, const SceneContextPointer& sceneContext, const RenderContextPointer& renderContext);
+}
+
 class RenderDeferredTask : public render::Task {
 public:
 

libraries/render-utils/src/overlay3D.slf

@@ -0,0 +1,29 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//  model.frag
+//  fragment shader
+//
+//  Created by Sam Gateau on 6/16/15.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+uniform sampler2D diffuseMap;
+
+varying vec2 varTexcoord;
+
+varying vec3 varEyeNormal;
+
+varying vec4 varColor;
+
+
+void main(void) {
+    vec4 diffuse = texture2D(diffuseMap, varTexcoord.st);
+    if (diffuse.a < 0.5) {
+        discard;
+    }
+    gl_FragColor = vec4(varColor * diffuse);
+}

libraries/render-utils/src/overlay3D.slv

@@ -0,0 +1,40 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//  overlay3D.slv
+//
+//  Created by Sam Gateau on 6/16/15.
+//  Copyright 2015 High Fidelity, Inc.
+//
+//  Distributed under the Apache License, Version 2.0.
+//  See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
+//
+
+<@include gpu/Transform.slh@>
+
+<$declareStandardTransform()$>
+
+//attribute vec2 texcoord;
+
+varying vec2 varTexcoord;
+
+// interpolated eye position
+varying vec4 varEyePosition;
+
+// the interpolated normal
+varying vec3 varEyeNormal;
+
+varying vec4 varColor;
+
+void main(void) {
+    varTexcoord = gl_MultiTexCoord0.xy;
+
+    // pass along the color
+    varColor = gl_Color;
+
+    // standard transform
+    TransformCamera cam = getTransformCamera();
+    TransformObject obj = getTransformObject();
+    <$transformModelToEyeAndClipPos(cam, obj, gl_Vertex, varEyePosition, gl_Position)$>
+    <$transformModelToEyeDir(cam, obj, gl_Normal, varEyeNormal.xyz)$>
+}

libraries/shared/src/RenderArgs.h

@@ -13,6 +13,8 @@
 #define hifi_RenderArgs_h
 
 #include <functional>
+#include <memory>
+
 
 class AABox;
 class OctreeRenderer;
@@ -20,6 +22,7 @@ class ViewFrustum;
 namespace gpu {
 class Batch;
 class Context;
+class Texture;
 }
 
 class RenderDetails {
@@ -109,6 +112,8 @@ public:
     gpu::Batch* _batch = nullptr;
     ShoudRenderFunctor _shouldRender;
     
+    std::shared_ptr<gpu::Texture> _whiteTexture;
+
     RenderDetails _details;
 
     float _alphaThreshold = 0.5f;