Merge pull request #8317 from hyperlogic/bug-fix/web3doverlay-rendering

Fix alpha cut-outs and incorrect gamma on web overlays and entities

interface/src/ui/overlays/Web3DOverlay.cpp

@@ -101,7 +101,7 @@ void Web3DOverlay::render(RenderArgs* args) {
 
     batch.setModelTransform(transform);
     auto geometryCache = DependencyManager::get<GeometryCache>();
-    geometryCache->bindSimpleProgram(batch, true, false, true, false);
+    geometryCache->bindSimpleSRGBTexturedUnlitNoTexAlphaProgram(batch);
     geometryCache->renderQuad(batch, halfSize * -1.0f, halfSize, vec2(0), vec2(1), color);
     batch.setResourceTexture(0, args->_whiteTexture); // restore default white color after me
 }

libraries/entities-renderer/src/RenderableWebEntityItem.cpp

@@ -203,14 +203,12 @@ void RenderableWebEntityItem::render(RenderArgs* args) {
     if (!success) {
         return;
     }
-    bool textured = false, culled = false, emissive = false;
     if (_texture) {
         batch._glActiveBindTexture(GL_TEXTURE0, GL_TEXTURE_2D, _texture);
-        textured = emissive = true;
     }
-    
+
-    DependencyManager::get<GeometryCache>()->bindSimpleProgram(batch, textured, culled, emissive);
+    DependencyManager::get<GeometryCache>()->bindSimpleSRGBTexturedUnlitNoTexAlphaProgram(batch);
-    DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, texMin, texMax, glm::vec4(1.0f, 1.0f, 1.0f, 0.0f));
+    DependencyManager::get<GeometryCache>()->renderQuad(batch, topLeft, bottomRight, texMin, texMax, glm::vec4(1.0f, 1.0f, 1.0f, 1.0f));
 }
 
 void RenderableWebEntityItem::setSourceUrl(const QString& value) {

libraries/render-utils/src/GeometryCache.cpp

@@ -35,6 +35,7 @@
 #include "simple_vert.h"
 #include "simple_textured_frag.h"
 #include "simple_textured_unlit_frag.h"
+#include "simple_srgb_textured_unlit_no_tex_alpha_frag.h"
 #include "glowLine_vert.h"
 #include "glowLine_geom.h"
 #include "glowLine_frag.h"
@@ -1748,6 +1749,38 @@ inline bool operator==(const SimpleProgramKey& a, const SimpleProgramKey& b) {
     return a.getRaw() == b.getRaw();
 }
 
+void GeometryCache::bindSimpleSRGBTexturedUnlitNoTexAlphaProgram(gpu::Batch& batch) {
+    batch.setPipeline(getSimpleSRGBTexturedUnlitNoTexAlphaPipeline());
+    // Set a default normal map
+    batch.setResourceTexture(render::ShapePipeline::Slot::MAP::NORMAL_FITTING,
+        DependencyManager::get<TextureCache>()->getNormalFittingTexture());
+}
+
+gpu::PipelinePointer GeometryCache::getSimpleSRGBTexturedUnlitNoTexAlphaPipeline() {
+    // Compile the shaders, once
+    static std::once_flag once;
+    std::call_once(once, [&]() {
+        auto VS = gpu::Shader::createVertex(std::string(simple_vert));
+        auto PS = gpu::Shader::createPixel(std::string(simple_srgb_textured_unlit_no_tex_alpha_frag));
+
+        _simpleSRGBTexturedUnlitNoTexAlphaShader = gpu::Shader::createProgram(VS, PS);
+
+        gpu::Shader::BindingSet slotBindings;
+        slotBindings.insert(gpu::Shader::Binding(std::string("normalFittingMap"), render::ShapePipeline::Slot::MAP::NORMAL_FITTING));
+        gpu::Shader::makeProgram(*_simpleSRGBTexturedUnlitNoTexAlphaShader, slotBindings);
+        auto state = std::make_shared<gpu::State>();
+        state->setCullMode(gpu::State::CULL_NONE);
+        state->setDepthTest(true, true, gpu::LESS_EQUAL);
+        state->setBlendFunction(false,
+                                gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
+                                gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
+
+        _simpleSRGBTexturedUnlitNoTexAlphaPipeline = gpu::Pipeline::create(_simpleSRGBTexturedUnlitNoTexAlphaShader, state);
+    });
+
+    return _simpleSRGBTexturedUnlitNoTexAlphaPipeline;
+}
+
 void GeometryCache::bindSimpleProgram(gpu::Batch& batch, bool textured, bool culled, bool unlit, bool depthBiased) {
     batch.setPipeline(getSimplePipeline(textured, culled, unlit, depthBiased));
 

libraries/render-utils/src/GeometryCache.h

@@ -157,6 +157,10 @@ public:
     // Get the pipeline to render static geometry
     gpu::PipelinePointer getSimplePipeline(bool textured = false, bool culled = true,
                                           bool unlit = false, bool depthBias = false);
+
+    void bindSimpleSRGBTexturedUnlitNoTexAlphaProgram(gpu::Batch& batch);
+    gpu::PipelinePointer getSimpleSRGBTexturedUnlitNoTexAlphaPipeline();
+
     render::ShapePipelinePointer getShapePipeline() { return GeometryCache::_simplePipeline; }
     render::ShapePipelinePointer getWireShapePipeline() { return GeometryCache::_simpleWirePipeline; }
 
@@ -416,6 +420,10 @@ private:
     static render::ShapePipelinePointer _simpleWirePipeline;
     gpu::PipelinePointer _glowLinePipeline;
     QHash<SimpleProgramKey, gpu::PipelinePointer> _simplePrograms;
+
+    gpu::ShaderPointer _simpleSRGBTexturedUnlitNoTexAlphaShader;
+    gpu::PipelinePointer _simpleSRGBTexturedUnlitNoTexAlphaPipeline;
+
 };
 
 #endif // hifi_GeometryCache_h

libraries/render-utils/src/simple_srgb_textured_unlit_no_tex_alpha.slf

@@ -0,0 +1,34 @@
+<@include gpu/Config.slh@>
+<$VERSION_HEADER$>
+//  Generated on <$_SCRIBE_DATE$>
+//
+//  simple_srgb_texture_unlit_no_tex_alpha.frag
+//  fragment shader
+//
+//  Created by Anthony Thibault on 7/25/16.
+//  Copyright 2016 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/Color.slh@>
+<@include DeferredBufferWrite.slh@>
+
+// the albedo texture
+uniform sampler2D originalTexture;
+
+// the interpolated normal
+in vec3 _normal;
+in vec4 _color;
+in vec2 _texCoord0;
+
+void main(void) {
+    vec4 texel = texture(originalTexture, _texCoord0.st);
+    texel = colorToLinearRGBA(texel);
+
+    packDeferredFragmentUnlit(
+         normalize(_normal),
+         1.0,
+         _color.rgb * texel.rgb);
+}