fixing the stencil not clearing correctly and shaders not compiled correctly in main thread

interface/src/Application.cpp

@@ -1132,7 +1132,7 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer, bo
     updateHeartbeat();
 
     // Now that OpenGL is initialized, we are sure we have a valid context and can create the various pipeline shaders with success.
-    DependencyManager::get<GeometryCache>()->initializeShapePipelines();
+  //  DependencyManager::get<GeometryCache>()->initializeShapePipelines();
 
     // sessionRunTime will be reset soon by loadSettings. Grab it now to get previous session value.
     // The value will be 0 if the user blew away settings this session, which is both a feature and a bug.
@@ -2254,6 +2254,9 @@ void Application::initializeGL() {
     _renderEngine->load();
     _renderEngine->registerScene(_main3DScene);
 
+    // Now that OpenGL is initialized, we are sure we have a valid context and can create the various pipeline shaders with success.
+    DependencyManager::get<GeometryCache>()->initializeShapePipelines();
+
     _offscreenContext = new OffscreenGLCanvas();
     _offscreenContext->setObjectName("MainThreadContext");
     _offscreenContext->create(_glWidget->qglContext());

libraries/gpu-gles/src/gpu/gl/GLBackendOutput.cpp

@@ -63,11 +63,17 @@ void GLBackend::do_clearFramebuffer(const Batch& batch, size_t paramOffset) {
     int useScissor = batch._params[paramOffset + 0]._int;
 
     GLuint glmask = 0;
+    bool restoreStencilMask = false;
+    uint8_t cacheStencilMask = 0xFF;
     if (masks & Framebuffer::BUFFER_STENCIL) {
         glClearStencil(stencil);
         glmask |= GL_STENCIL_BUFFER_BIT;
-        // TODO: we will probably need to also check the write mask of stencil like we do
-        // for depth buffer, but as would say a famous Fez owner "We'll cross that bridge when we come to it"
+
+        cacheStencilMask = _pipeline._stateCache.stencilActivation.getWriteMaskFront();
+        if (cacheStencilMask != 0xFF) {
+            restoreStencilMask = true;
+            glStencilMask(0xFF);
+        }
     }
 
     bool restoreDepthMask = false;
@@ -122,6 +128,11 @@ void GLBackend::do_clearFramebuffer(const Batch& batch, size_t paramOffset) {
         glDisable(GL_SCISSOR_TEST);
     }
 
+    // Restore Stencil write mask
+    if (restoreStencilMask) {
+        glStencilMask(cacheStencilMask);
+    }
+
     // Restore write mask meaning turn back off
     if (restoreDepthMask) {
         glDepthMask(GL_FALSE);

libraries/gpu/src/gpu/Batch.h

@@ -269,6 +269,10 @@ public:
 
     void _glColor4f(float red, float green, float blue, float alpha);
 
+    // Maybe useful but shoudln't be public. Please convince me otherwise
+    // Well porting to gles i need it...
+    void runLambda(std::function<void()> f);
+
     enum Command {
         COMMAND_draw = 0,
         COMMAND_drawIndexed,
@@ -497,8 +501,7 @@ protected:
     void startNamedCall(const std::string& name);
     void stopNamedCall();
 
-    // Maybe useful but shoudln't be public. Please convince me otherwise
-    void runLambda(std::function<void()> f);
+
 
     void captureDrawCallInfoImpl();
 };

libraries/model/src/model/Skybox.cpp

@@ -89,12 +89,14 @@ void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Sky
             auto skyFS = gpu::Shader::createPixel(std::string(skybox_frag));
             auto skyShader = gpu::Shader::createProgram(skyVS, skyFS);
 
-            gpu::Shader::BindingSet bindings;
-            bindings.insert(gpu::Shader::Binding(std::string("cubeMap"), SKYBOX_SKYMAP_SLOT));
-            bindings.insert(gpu::Shader::Binding(std::string("skyboxBuffer"), SKYBOX_CONSTANTS_SLOT));
-            if (!gpu::Shader::makeProgram(*skyShader, bindings)) {
+            batch.runLambda([skyShader] {
+                gpu::Shader::BindingSet bindings;
+                bindings.insert(gpu::Shader::Binding(std::string("cubeMap"), SKYBOX_SKYMAP_SLOT));
+                bindings.insert(gpu::Shader::Binding(std::string("skyboxBuffer"), SKYBOX_CONSTANTS_SLOT));
+                if (!gpu::Shader::makeProgram(*skyShader, bindings)) {
 
-            }
+                }
+            });
 
             auto skyState = std::make_shared<gpu::State>();
             // Must match PrepareStencil::STENCIL_BACKGROUND

libraries/render-utils/src/GeometryCache.cpp

@@ -715,6 +715,10 @@ void GeometryCache::initializeShapePipelines() {
         _simpleOpaqueFadePipeline = getFadingShapePipeline(false, false, false, false, false);
         _simpleTransparentFadePipeline = getFadingShapePipeline(false, true, false, false, false);
         _simpleWirePipeline = getShapePipeline(false, false, true, true);
+
+        auto vs = gpu::Shader::createVertex(std::string(standardTransformPNTC_vert));
+        auto ps = gpu::Shader::createPixel(std::string(standardDrawTexture_frag));
+        auto program = gpu::Shader::createProgram(vs, ps);
     }
 }
 
@@ -2001,11 +2005,11 @@ void GeometryCache::renderGlowLine(gpu::Batch& batch, const glm::vec3& p1, const
 }
 
 void GeometryCache::useSimpleDrawPipeline(gpu::Batch& batch, bool noBlend) {
-    if (!_standardDrawPipeline) {
+    static std::once_flag once;
+    std::call_once(once, [&]() {
         auto vs = gpu::Shader::createVertex(std::string(standardTransformPNTC_vert));
         auto ps = gpu::Shader::createPixel(std::string(standardDrawTexture_frag));
         auto program = gpu::Shader::createProgram(vs, ps);
-        gpu::Shader::makeProgram((*program));
 
         auto state = std::make_shared<gpu::State>();
 
@@ -2021,9 +2025,15 @@ void GeometryCache::useSimpleDrawPipeline(gpu::Batch& batch, bool noBlend) {
 
         auto noBlendPS = gpu::StandardShaderLib::getDrawTextureOpaquePS();
         auto programNoBlend = gpu::Shader::createProgram(vs, noBlendPS);
-        gpu::Shader::makeProgram((*programNoBlend));
+
         _standardDrawPipelineNoBlend = gpu::Pipeline::create(programNoBlend, stateNoBlend);
-    }
+
+        batch.runLambda([program, programNoBlend] {
+            gpu::Shader::makeProgram((*program));
+            gpu::Shader::makeProgram((*programNoBlend));
+        });
+    });
+
     if (noBlend) {
         batch.setPipeline(_standardDrawPipelineNoBlend);
     } else {

libraries/render-utils/src/MaterialTextures.slh

@@ -17,7 +17,9 @@
 const int MAX_TEXCOORDS = 2;
 
 struct TexMapArray { 
-    mat4 _texcoordTransforms[MAX_TEXCOORDS];
+//    mat4 _texcoordTransforms[MAX_TEXCOORDS];
+    mat4 _texcoordTransforms0;
+    mat4 _texcoordTransforms1;
     vec4 _lightmapParams;
 };
 
@@ -31,13 +33,13 @@ TexMapArray getTexMapArray() {
 
 <@func evalTexMapArrayTexcoord0(texMapArray, inTexcoord0, outTexcoord0)@>
 {
-    <$outTexcoord0$> = (<$texMapArray$>._texcoordTransforms[0] * vec4(<$inTexcoord0$>.st, 0.0, 1.0)).st;
+    <$outTexcoord0$> = (<$texMapArray$>._texcoordTransforms0 * vec4(<$inTexcoord0$>.st, 0.0, 1.0)).st;
 }
 <@endfunc@>
 
 <@func evalTexMapArrayTexcoord1(texMapArray, inTexcoord1, outTexcoord1)@>
 {
-    <$outTexcoord1$> = (<$texMapArray$>._texcoordTransforms[1] * vec4(<$inTexcoord1$>.st, 0.0, 1.0)).st;
+    <$outTexcoord1$> = (<$texMapArray$>._texcoordTransforms1 * vec4(<$inTexcoord1$>.st, 0.0, 1.0)).st;
 }
 <@endfunc@>
 

libraries/render-utils/src/RenderForwardTask.cpp

@@ -130,7 +130,7 @@ void PrepareFramebuffer::run(const RenderContextPointer& renderContext, gpu::Fra
         batch.setFramebuffer(_framebuffer);
         batch.clearFramebuffer(gpu::Framebuffer::BUFFER_COLOR0 | gpu::Framebuffer::BUFFER_DEPTH |
             gpu::Framebuffer::BUFFER_STENCIL,
-            vec4(vec3(0), 1), 1.0, 0, true);
+            vec4(vec3(0, 1.0, 0.0), 0), 1.0, 0, true);
     });
 
     framebuffer = _framebuffer;