Fixed fading on skinned objects. Added initialiazeShapePipelines on GeometryCache to postpone simple pipeline creation after initializeGL

Olivier Prat committed 9 years ago

Commit 20d4fcb1 parent de143d08 files · +151 −73Browse files

Showing the changes to libraries/render-utils/src/GeometryCache.cpp (1 of 8 files). Show all

Unified · Split

libraries/render-utils/src/GeometryCache.cpp+80−39

 #include "TextureCache.h"
 #include "RenderUtilsLogging.h"
+#include "FadeEffect.h"
 #include "gpu/StandardShaderLib.h"
 #include "simple_vert.h"
 #include "simple_textured_frag.h"
 #include "simple_textured_unlit_frag.h"
+#include "simple_fade_vert.h"
+#include "simple_textured_fade_frag.h"
+#include "simple_textured_unlit_fade_frag.h"
 #include "simple_opaque_web_browser_frag.h"
 #include "simple_opaque_web_browser_overlay_frag.h"
 #include "simple_transparent_web_browser_frag.h"
 render::ShapePipelinePointer GeometryCache::_simpleOpaquePipeline;
 render::ShapePipelinePointer GeometryCache::_simpleTransparentPipeline;
+render::ShapePipelinePointer GeometryCache::_simpleOpaqueFadePipeline;
+render::ShapePipelinePointer GeometryCache::_simpleTransparentFadePipeline;
 render::ShapePipelinePointer GeometryCache::_simpleWirePipeline;
 GeometryCache::GeometryCache() :
 _nextID(0) {
     buildShapes();
-    GeometryCache::_simpleOpaquePipeline =
-        std::make_shared<render::ShapePipeline>(getSimplePipeline(false, false, true, false), nullptr,
-            [](const render::ShapePipeline&, gpu::Batch& batch) {
-                // Set the defaults needed for a simple program
-                batch.setResourceTexture(render::ShapePipeline::Slot::MAP::ALBEDO,
-                    DependencyManager::get<TextureCache>()->getWhiteTexture());
-            }
-        );
-    GeometryCache::_simpleTransparentPipeline =
-        std::make_shared<render::ShapePipeline>(getSimplePipeline(false, true, true, false), nullptr,
-            [](const render::ShapePipeline&, gpu::Batch& batch) {
-                // Set the defaults needed for a simple program
-                batch.setResourceTexture(render::ShapePipeline::Slot::MAP::ALBEDO,
-                    DependencyManager::get<TextureCache>()->getWhiteTexture());
-            }
-        );
-    GeometryCache::_simpleWirePipeline =
-        std::make_shared<render::ShapePipeline>(getSimplePipeline(false, false, true, true), nullptr,
-            [](const render::ShapePipeline&, gpu::Batch& batch) {});
 }
 GeometryCache::~GeometryCache() {
     batch.setInputBuffer(gpu::Stream::COLOR, colorView);
 }
+void GeometryCache::initializeShapePipelines() {
+    GeometryCache::_simpleOpaquePipeline = getShapePipeline(false, false, true, false);
+    GeometryCache::_simpleTransparentPipeline = getShapePipeline(false, true, true, false);
+    GeometryCache::_simpleOpaqueFadePipeline = getShapePipeline(false, false, true, false, false, true);
+    GeometryCache::_simpleTransparentFadePipeline = getShapePipeline(false, true, true, false, false, true);
+    GeometryCache::_simpleWirePipeline = getShapePipeline(false, false, true, true);
+}
+render::ShapePipelinePointer GeometryCache::getShapePipeline(bool textured, bool transparent, bool culled,
+    bool unlit, bool depthBias, bool fading) {
+    return std::make_shared<render::ShapePipeline>(getSimplePipeline(textured, transparent, culled, unlit, depthBias, fading), nullptr,
+        [](const render::ShapePipeline&, gpu::Batch& batch) {
+        // Set the defaults needed for a simple program
+        batch.setResourceTexture(render::ShapePipeline::Slot::MAP::ALBEDO,
+            DependencyManager::get<TextureCache>()->getWhiteTexture());
+    }
+    );
+}
+render::ShapePipelinePointer GeometryCache::getOpaqueShapePipeline(bool isFading) {
+    isFading = isFading || DependencyManager::get<FadeEffect>()->isDebugEnabled();
+    return isFading ? _simpleOpaqueFadePipeline : _simpleOpaquePipeline;
+}
+render::ShapePipelinePointer GeometryCache::getTransparentShapePipeline(bool isFading) {
+    isFading = isFading || DependencyManager::get<FadeEffect>()->isDebugEnabled();
+    return isFading ? _simpleTransparentFadePipeline : _simpleTransparentPipeline;
+}
 void GeometryCache::renderShape(gpu::Batch& batch, Shape shape) {
     batch.setInputFormat(getSolidStreamFormat());
     _shapes[shape].draw(batch);
         IS_CULLED_FLAG,
         IS_UNLIT_FLAG,
         HAS_DEPTH_BIAS_FLAG,
+        IS_FADING_FLAG,
         NUM_FLAGS,
     };
         IS_CULLED = (1 << IS_CULLED_FLAG),
         IS_UNLIT = (1 << IS_UNLIT_FLAG),
         HAS_DEPTH_BIAS = (1 << HAS_DEPTH_BIAS_FLAG),
+        IS_FADING = (1 << IS_FADING_FLAG),
     };
     typedef unsigned short Flags;
     bool isCulled() const { return isFlag(IS_CULLED); }
     bool isUnlit() const { return isFlag(IS_UNLIT); }
     bool hasDepthBias() const { return isFlag(HAS_DEPTH_BIAS); }
+    bool isFading() const { return isFlag(IS_FADING); }
     Flags _flags = 0;
     short _spare = 0;
     SimpleProgramKey(bool textured = false, bool transparent = false, bool culled = true,
-        bool unlit = false, bool depthBias = false) {
+        bool unlit = false, bool depthBias = false, bool fading = false) {
         _flags = (textured ? IS_TEXTURED : 0) | (transparent ? IS_TRANSPARENT : 0) | (culled ? IS_CULLED : 0) |
-            (unlit ? IS_UNLIT : 0) | (depthBias ? HAS_DEPTH_BIAS : 0);
+            (unlit ? IS_UNLIT : 0) | (depthBias ? HAS_DEPTH_BIAS : 0) | (fading ? IS_FADING : 0);
     }
     SimpleProgramKey(int bitmask) : _flags(bitmask) {}
     }
 }
-gpu::PipelinePointer GeometryCache::getSimplePipeline(bool textured, bool transparent, bool culled, bool unlit, bool depthBiased) {
+gpu::PipelinePointer GeometryCache::getSimplePipeline(bool textured, bool transparent, bool culled, bool unlit, bool depthBiased, bool fading) {
-    SimpleProgramKey config { textured, transparent, culled, unlit, depthBiased };
+    SimpleProgramKey config { textured, transparent, culled, unlit, depthBiased, fading };
-    // Compile the shaders
-    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_textured_frag));
-        auto PSUnlit = gpu::Shader::createPixel(std::string(simple_textured_unlit_frag));
-        _simpleShader = gpu::Shader::createProgram(VS, PS);
-        _unlitShader = gpu::Shader::createProgram(VS, PSUnlit);
-        gpu::Shader::BindingSet slotBindings;
-        gpu::Shader::makeProgram(*_simpleShader, slotBindings);
-        gpu::Shader::makeProgram(*_unlitShader, slotBindings);
-    });
     // If the pipeline already exists, return it
     auto it = _simplePrograms.find(config);
         return it.value();
     }
+    // Compile the shaders
+    if (!fading) {
+        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_textured_frag));
+            auto PSUnlit = gpu::Shader::createPixel(std::string(simple_textured_unlit_frag));
+            _simpleShader = gpu::Shader::createProgram(VS, PS);
+            _unlitShader = gpu::Shader::createProgram(VS, PSUnlit);
+            gpu::Shader::BindingSet slotBindings;
+            gpu::Shader::makeProgram(*_simpleShader, slotBindings);
+            gpu::Shader::makeProgram(*_unlitShader, slotBindings);
+        });
+    } else {
+        static std::once_flag once;
+        std::call_once(once, [&]() {
+            auto VS = gpu::Shader::createVertex(std::string(simple_fade_vert));
+            auto PS = gpu::Shader::createPixel(std::string(simple_textured_fade_frag));
+            auto PSUnlit = gpu::Shader::createPixel(std::string(simple_textured_unlit_fade_frag));
+            _simpleFadeShader = gpu::Shader::createProgram(VS, PS);
+            _unlitFadeShader = gpu::Shader::createProgram(VS, PSUnlit);
+            gpu::Shader::BindingSet slotBindings;
+            gpu::Shader::makeProgram(*_simpleFadeShader, slotBindings);
+            gpu::Shader::makeProgram(*_unlitFadeShader, slotBindings);
+        });
+    }
     // If the pipeline did not exist, make it
     auto state = std::make_shared<gpu::State>();
     if (config.isCulled()) {
         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);
-    gpu::ShaderPointer program = (config.isUnlit()) ? _unlitShader : _simpleShader;
+    gpu::ShaderPointer program = (config.isUnlit()) ? (config.isFading() ? _unlitFadeShader : _unlitShader) : (config.isFading() ? _simpleFadeShader : _simpleShader);
     gpu::PipelinePointer pipeline = gpu::Pipeline::create(program, state);
     _simplePrograms.insert(config, pipeline);
     return pipeline;
 }
 void GeometryCache::renderSolidShapeInstance(gpu::Batch& batch, GeometryCache::Shape shape, const glm::vec4& color, const render::ShapePipelinePointer& pipeline) {
+    assert(pipeline != nullptr);
     renderInstances(batch, color, false, pipeline, shape);
 }
 void GeometryCache::renderWireShapeInstance(gpu::Batch& batch, GeometryCache::Shape shape, const glm::vec4& color, const render::ShapePipelinePointer& pipeline) {
+    assert(pipeline != nullptr);
     renderInstances(batch, color, true, pipeline, shape);
 }
 void GeometryCache::renderSolidSphereInstance(gpu::Batch& batch, const glm::vec4& color, const render::ShapePipelinePointer& pipeline) {
+    assert(pipeline != nullptr);
     renderInstances(batch, color, false, pipeline, GeometryCache::Sphere);
 }
 void GeometryCache::renderWireSphereInstance(gpu::Batch& batch, const glm::vec4& color, const render::ShapePipelinePointer& pipeline) {
+    assert(pipeline != nullptr);
     renderInstances(batch, color, true, pipeline, GeometryCache::Sphere);
 }
 //#define DEBUG_SHAPES
 void GeometryCache::renderSolidCubeInstance(gpu::Batch& batch, const glm::vec4& color, const render::ShapePipelinePointer& pipeline) {
+    assert(pipeline != nullptr);
 #ifdef DEBUG_SHAPES
     static auto startTime = usecTimestampNow();
     renderInstances(INSTANCE_NAME, batch, color, pipeline, [](gpu::Batch& batch, gpu::Batch::NamedBatchData& data) {
 void GeometryCache::renderWireCubeInstance(gpu::Batch& batch, const glm::vec4& color, const render::ShapePipelinePointer& pipeline) {
     static const std::string INSTANCE_NAME = __FUNCTION__;
+    assert(pipeline != nullptr);
     renderInstances(batch, color, true, pipeline, GeometryCache::Cube);
 }