Switched shadow maps to sampler2DArrayShadow to try to fix on Mac

libraries/gpu-gl-common/src/gpu/gl/GLBackendPipeline.cpp

@@ -203,10 +203,11 @@ void GLBackend::releaseResourceTexture(uint32_t slot) {
 }
 
 void GLBackend::resetResourceStage() {
-    for (uint32_t i = 0; i < _resource._buffers.size(); i++) {
+    uint32_t i;
+    for (i = 0; i < _resource._buffers.size(); i++) {
         releaseResourceBuffer(i);
     }
-    for (uint32_t i = 0; i < _resource._textures.size(); i++) {
+    for (i = 0; i < _resource._textures.size(); i++) {
         releaseResourceTexture(i);
     }
 }

libraries/gpu-gl-common/src/gpu/gl/GLTexture.cpp

@@ -59,7 +59,11 @@ const size_t GLVariableAllocationSupport::MAX_BUFFER_SIZE = MAX_TRANSFER_SIZE;
 GLenum GLTexture::getGLTextureType(const Texture& texture) {
     switch (texture.getType()) {
     case Texture::TEX_2D:
-        return GL_TEXTURE_2D;
+        if (!texture.isArray()) {
+            return GL_TEXTURE_2D;
+        } else {
+            return GL_TEXTURE_2D_ARRAY;
+        }
         break;
 
     case Texture::TEX_CUBE:
@@ -77,6 +81,7 @@ GLenum GLTexture::getGLTextureType(const Texture& texture) {
 uint8_t GLTexture::getFaceCount(GLenum target) {
     switch (target) {
         case GL_TEXTURE_2D:
+        case GL_TEXTURE_2D_ARRAY:
             return TEXTURE_2D_NUM_FACES;
         case GL_TEXTURE_CUBE_MAP:
             return TEXTURE_CUBE_NUM_FACES;
@@ -86,17 +91,22 @@ uint8_t GLTexture::getFaceCount(GLenum target) {
     }
 }
 const std::vector<GLenum>& GLTexture::getFaceTargets(GLenum target) {
-    static std::vector<GLenum> cubeFaceTargets {
+    static const std::vector<GLenum> cubeFaceTargets {
         GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
         GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
         GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
     };
-    static std::vector<GLenum> faceTargets {
+    static const std::vector<GLenum> faceTargets {
         GL_TEXTURE_2D
     };
+    static const std::vector<GLenum> arrayFaceTargets{ 
+        GL_TEXTURE_2D_ARRAY 
+    };
     switch (target) {
     case GL_TEXTURE_2D:
         return faceTargets;
+    case GL_TEXTURE_2D_ARRAY:
+        return arrayFaceTargets;
     case GL_TEXTURE_CUBE_MAP:
         return cubeFaceTargets;
     default:

libraries/gpu-gl/src/gpu/gl41/GL41BackendOutput.cpp

@@ -64,7 +64,12 @@ public:
                     }
 
                     if (gltexture) {
-                        glFramebufferTexture2D(GL_FRAMEBUFFER, colorAttachments[unit], GL_TEXTURE_2D, gltexture->_texture, 0);
+                        if (gltexture->_target == GL_TEXTURE_2D) {
+                            glFramebufferTexture2D(GL_FRAMEBUFFER, colorAttachments[unit], GL_TEXTURE_2D, gltexture->_texture, 0);
+                        } else {
+                            glFramebufferTextureLayer(GL_FRAMEBUFFER, colorAttachments[unit], gltexture->_texture, 0,
+                                                      b._subresource);
+                        }
                         _colorBuffers.push_back(colorAttachments[unit]);
                     } else {
                         glFramebufferTexture2D(GL_FRAMEBUFFER, colorAttachments[unit], GL_TEXTURE_2D, 0, 0);
@@ -91,7 +96,12 @@ public:
             }
 
             if (gltexture) {
-                glFramebufferTexture2D(GL_FRAMEBUFFER, attachement, GL_TEXTURE_2D, gltexture->_texture, 0);
+                if (gltexture->_target == GL_TEXTURE_2D) {
+                    glFramebufferTexture2D(GL_FRAMEBUFFER, attachement, GL_TEXTURE_2D, gltexture->_texture, 0);
+                } else {
+                    glFramebufferTextureLayer(GL_FRAMEBUFFER, attachement, gltexture->_texture, 0,
+                                              _gpuObject.getDepthStencilBufferSubresource());
+                }
             } else {
                 glFramebufferTexture2D(GL_FRAMEBUFFER, attachement, GL_TEXTURE_2D, 0, 0);
             }

libraries/gpu-gl/src/gpu/gl41/GL41BackendTexture.cpp

@@ -215,12 +215,19 @@ GL41FixedAllocationTexture::~GL41FixedAllocationTexture() {
 void GL41FixedAllocationTexture::allocateStorage() const {
     const GLTexelFormat texelFormat = GLTexelFormat::evalGLTexelFormat(_gpuObject.getTexelFormat());
     const auto numMips = _gpuObject.getNumMips();
+    const auto numSlices = _gpuObject.getNumSlices();
 
     // glTextureStorage2D(_id, mips, texelFormat.internalFormat, dimensions.x, dimensions.y);
     for (GLint level = 0; level < numMips; level++) {
         Vec3u dimensions = _gpuObject.evalMipDimensions(level);
         for (GLenum target : getFaceTargets(_target)) {
-            glTexImage2D(target, level, texelFormat.internalFormat, dimensions.x, dimensions.y, 0, texelFormat.format, texelFormat.type, nullptr);
+            if (!_gpuObject.isArray()) {
+                glTexImage2D(target, level, texelFormat.internalFormat, dimensions.x, dimensions.y, 0, texelFormat.format,
+                             texelFormat.type, nullptr);
+            } else {
+                glTexImage3D(target, level, texelFormat.internalFormat, dimensions.x, dimensions.y, numSlices, 0,
+                             texelFormat.format, texelFormat.type, nullptr);
+            }
         }
     }
 

libraries/gpu-gl/src/gpu/gl45/GL45BackendOutput.cpp

@@ -60,7 +60,11 @@ public:
                     }
 
                     if (gltexture) {
-                        glNamedFramebufferTexture(_id, colorAttachments[unit], gltexture->_texture, 0);
+                        if (gltexture->_target == GL_TEXTURE_2D) {
+                            glNamedFramebufferTexture(_id, colorAttachments[unit], gltexture->_texture, 0);
+                        } else {
+                            glNamedFramebufferTextureLayer(_id, colorAttachments[unit], gltexture->_texture, 0, b._subresource);
+                        }
                         _colorBuffers.push_back(colorAttachments[unit]);
                     } else {
                         glNamedFramebufferTexture(_id, colorAttachments[unit], 0, 0);
@@ -87,14 +91,18 @@ public:
             }
 
             if (gltexture) {
-                glNamedFramebufferTexture(_id, attachement, gltexture->_texture, 0);
+                if (gltexture->_target == GL_TEXTURE_2D) {
+                    glNamedFramebufferTexture(_id, attachement, gltexture->_texture, 0);
+                } else {
+                    glNamedFramebufferTextureLayer(_id, attachement, gltexture->_texture, 0,
+                                                   _gpuObject.getDepthStencilBufferSubresource());
+                }
             } else {
                 glNamedFramebufferTexture(_id, attachement, 0, 0);
             }
             _depthStamp = _gpuObject.getDepthStamp();
         }
 
-
         // Last but not least, define where we draw
         if (!_colorBuffers.empty()) {
             glNamedFramebufferDrawBuffers(_id, (GLsizei)_colorBuffers.size(), _colorBuffers.data());

libraries/gpu-gl/src/gpu/gl45/GL45BackendTexture.cpp

@@ -374,8 +374,13 @@ void GL45FixedAllocationTexture::allocateStorage() const {
     const GLTexelFormat texelFormat = GLTexelFormat::evalGLTexelFormat(_gpuObject.getTexelFormat());
     const auto dimensions = _gpuObject.getDimensions();
     const auto mips = _gpuObject.getNumMips();
+    const auto numSlices = _gpuObject.getNumSlices();
 
-    glTextureStorage2D(_id, mips, texelFormat.internalFormat, dimensions.x, dimensions.y);
+    if (!_gpuObject.isArray()) {
+        glTextureStorage2D(_id, mips, texelFormat.internalFormat, dimensions.x, dimensions.y);
+    } else {
+        glTextureStorage3D(_id, mips, texelFormat.internalFormat, dimensions.x, dimensions.y, numSlices);
+    }
 
     glTextureParameteri(_id, GL_TEXTURE_BASE_LEVEL, 0);
     glTextureParameteri(_id, GL_TEXTURE_MAX_LEVEL, mips - 1);

libraries/gpu/src/gpu/Texture.cpp

@@ -184,6 +184,10 @@ TexturePointer Texture::createRenderBuffer(const Element& texelFormat, uint16 wi
     return create(TextureUsageType::RENDERBUFFER, TEX_2D, texelFormat, width, height, 1, 1, 0, numMips, sampler);
 }
 
+TexturePointer Texture::createRenderBufferArray(const Element& texelFormat, uint16 width, uint16 height, uint16 numSlices, uint16 numMips, const Sampler& sampler) {
+    return create(TextureUsageType::RENDERBUFFER, TEX_2D, texelFormat, width, height, 1, 1, numSlices, numMips, sampler);
+}
+
 TexturePointer Texture::create1D(const Element& texelFormat, uint16 width, uint16 numMips, const Sampler& sampler) {
     return create(TextureUsageType::RESOURCE, TEX_1D, texelFormat, width, 1, 1, 1, 0, numMips, sampler);
 }
@@ -192,6 +196,10 @@ TexturePointer Texture::create2D(const Element& texelFormat, uint16 width, uint1
     return create(TextureUsageType::RESOURCE, TEX_2D, texelFormat, width, height, 1, 1, 0, numMips, sampler);
 }
 
+TexturePointer Texture::create2DArray(const Element& texelFormat, uint16 width, uint16 height, uint16 numSlices, uint16 numMips, const Sampler& sampler) {
+    return create(TextureUsageType::STRICT_RESOURCE, TEX_2D, texelFormat, width, height, 1, 1, numSlices, numMips, sampler);
+}
+
 TexturePointer Texture::createStrict(const Element& texelFormat, uint16 width, uint16 height, uint16 numMips, const Sampler& sampler) {
     return create(TextureUsageType::STRICT_RESOURCE, TEX_2D, texelFormat, width, height, 1, 1, 0, numMips, sampler);
 }

libraries/gpu/src/gpu/Texture.h

@@ -374,9 +374,11 @@ public:
     static const uint16 SINGLE_MIP = 1;
     static TexturePointer create1D(const Element& texelFormat, uint16 width, uint16 numMips = SINGLE_MIP, const Sampler& sampler = Sampler());
     static TexturePointer create2D(const Element& texelFormat, uint16 width, uint16 height, uint16 numMips = SINGLE_MIP, const Sampler& sampler = Sampler());
+    static TexturePointer create2DArray(const Element& texelFormat, uint16 width, uint16 height, uint16 numSlices, uint16 numMips = SINGLE_MIP, const Sampler& sampler = Sampler());
     static TexturePointer create3D(const Element& texelFormat, uint16 width, uint16 height, uint16 depth, uint16 numMips = SINGLE_MIP, const Sampler& sampler = Sampler());
     static TexturePointer createCube(const Element& texelFormat, uint16 width, uint16 numMips = 1, const Sampler& sampler = Sampler());
     static TexturePointer createRenderBuffer(const Element& texelFormat, uint16 width, uint16 height, uint16 numMips = SINGLE_MIP, const Sampler& sampler = Sampler());
+    static TexturePointer createRenderBufferArray(const Element& texelFormat, uint16 width, uint16 height, uint16 numSlices, uint16 numMips = SINGLE_MIP, const Sampler& sampler = Sampler());
     static TexturePointer createStrict(const Element& texelFormat, uint16 width, uint16 height, uint16 numMips = SINGLE_MIP, const Sampler& sampler = Sampler());
     static TexturePointer createExternal(const ExternalRecycler& recycler, const Sampler& sampler = Sampler());
 

libraries/gpu/src/gpu/Texture_ktx.cpp

@@ -515,7 +515,7 @@ TexturePointer Texture::build(const ktx::KTXDescriptor& descriptor) {
         header.getPixelHeight(),
         header.getPixelDepth(),
         1, // num Samples
-        header.getNumberOfSlices(),
+        header.isArray() ? header.getNumberOfSlices() : 0,
         header.getNumberOfLevels(),
         samplerDesc);
     texture->setUsage(gpuktxKeyValue._usage);

libraries/ktx/src/ktx/KTX.h

@@ -163,6 +163,7 @@ namespace ktx {
         uint32_t getPixelDepth() const { return (pixelDepth ? pixelDepth : 1); }
         uint32_t getNumberOfSlices() const { return (numberOfArrayElements ? numberOfArrayElements : 1); }
         uint32_t getNumberOfLevels() const { return (numberOfMipmapLevels ? numberOfMipmapLevels : 1); }
+        bool isArray() const { return numberOfArrayElements > 0; }
         bool isCompressed() const { return glFormat == COMPRESSED_FORMAT; }
 
         uint32_t evalMaxDimension() const;

libraries/render-utils/src/DebugDeferredBuffer.cpp

@@ -140,11 +140,12 @@ static const std::string DEFAULT_LIGHTING_SHADER {
 };
 
 static const std::string DEFAULT_SHADOW_SHADER{
-    "uniform sampler2DShadow shadowMap;"
+    "uniform sampler2DArrayShadow shadowMaps;"
+    "uniform int shadowCascadeIndex;"
     "vec4 getFragmentColor() {"
     "    for (int i = 255; i >= 0; --i) {"
     "        float depth = i / 255.0;"
-    "        if (texture(shadowMap, vec3(uv, depth)) > 0.5) {"
+    "        if (texture(shadowMaps, vec4(uv, shadowCascadeIndex, depth)) > 0.5) {"
     "            return vec4(vec3(depth), 1.0);"
     "        }"
     "    }"
@@ -403,7 +404,7 @@ const gpu::PipelinePointer& DebugDeferredBuffer::getPipeline(Mode mode, std::str
         slotBindings.insert(gpu::Shader::Binding("depthMap", Depth));
         slotBindings.insert(gpu::Shader::Binding("obscuranceMap", AmbientOcclusion));
         slotBindings.insert(gpu::Shader::Binding("lightingMap", Lighting));
-        slotBindings.insert(gpu::Shader::Binding("shadowMap", Shadow));
+        slotBindings.insert(gpu::Shader::Binding("shadowMaps", Shadow));
         slotBindings.insert(gpu::Shader::Binding("linearDepthMap", LinearDepth));
         slotBindings.insert(gpu::Shader::Binding("halfLinearDepthMap", HalfLinearDepth));
         slotBindings.insert(gpu::Shader::Binding("halfNormalMap", HalfNormal));
@@ -490,7 +491,11 @@ void DebugDeferredBuffer::run(const RenderContextPointer& renderContext, const I
         const auto& globalShadow = lightAndShadow.second;
         if (globalShadow) {
             const auto cascadeIndex = glm::clamp(_mode - Mode::ShadowCascade0Mode, 0, (int)globalShadow->getCascadeCount() - 1);
-            batch.setResourceTexture(Shadow, globalShadow->getCascade(cascadeIndex).map);
+            const auto cascadeIndexLocation = pipeline->getProgram()->getUniforms().findLocation("shadowCascadeIndex");
+            batch.setResourceTexture(Shadow, globalShadow->map);
+            if (cascadeIndexLocation >= 0) {
+                batch._glUniform1i(cascadeIndexLocation, cascadeIndex);
+            }
             batch.setUniformBuffer(ShadowTransform, globalShadow->getBuffer());
             batch.setUniformBuffer(DeferredFrameTransform, frameTransform->getFrameTransformBuffer());
         }

libraries/render-utils/src/DeferredLightingEffect.cpp

@@ -68,7 +68,7 @@ enum DeferredShader_MapSlot {
     SCATTERING_SPECULAR_UNIT = 9,
     SKYBOX_MAP_UNIT = render::ShapePipeline::Slot::LIGHT_AMBIENT_MAP, // unit = 10
     SHADOW_MAP_UNIT = 11,
-    nextAvailableUnit = SHADOW_MAP_UNIT + SHADOW_CASCADE_MAX_COUNT
+    nextAvailableUnit = SHADOW_MAP_UNIT
 };
 enum DeferredShader_BufferSlot {
     DEFERRED_FRAME_TRANSFORM_BUFFER_SLOT = 0,
@@ -534,9 +534,7 @@ void RenderDeferredSetup::run(const render::RenderContextPointer& renderContext,
 
         // Bind the shadow buffers
         if (globalShadow) {
-            for (unsigned int i = 0; i < globalShadow->getCascadeCount(); i++) {
+            batch.setResourceTexture(SHADOW_MAP_UNIT, globalShadow->map);
-                batch.setResourceTexture(SHADOW_MAP_UNIT+i, globalShadow->getCascade(i).map);
-            }
         }
 
         auto program = deferredLightingEffect->_directionalSkyboxLight;

libraries/render-utils/src/LightStage.cpp

@@ -74,8 +74,6 @@ LightStage::Shadow::Cascade::Cascade() :
     _frustum{ std::make_shared<ViewFrustum>() },
     _minDistance{ 0.0f },
     _maxDistance{ 20.0f } {
-    framebuffer = gpu::FramebufferPointer(gpu::Framebuffer::createShadowmap(MAP_SIZE));
-    map = framebuffer->getDepthStencilBuffer();
 }
 
 const glm::mat4& LightStage::Shadow::Cascade::getView() const {
@@ -127,8 +125,29 @@ LightStage::Shadow::Shadow(graphics::LightPointer light, float maxDistance, unsi
     Schema schema;
     schema.cascadeCount = cascadeCount;
     _schemaBuffer = std::make_shared<gpu::Buffer>(sizeof(Schema), (const gpu::Byte*) &schema);
+
+    // Create shadow cascade texture array
+    auto depthFormat = gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::DEPTH);  // Depth32 texel format
+    map = gpu::TexturePointer(gpu::Texture::createRenderBufferArray(depthFormat, MAP_SIZE, MAP_SIZE, cascadeCount));
+    gpu::Sampler::Desc samplerDesc;
+    samplerDesc._borderColor = glm::vec4(1.0f);
+    samplerDesc._wrapModeU = gpu::Sampler::WRAP_BORDER;
+    samplerDesc._wrapModeV = gpu::Sampler::WRAP_BORDER;
+    samplerDesc._filter = gpu::Sampler::FILTER_MIN_MAG_LINEAR;
+    samplerDesc._comparisonFunc = gpu::LESS;
+
+    map->setSampler(gpu::Sampler(samplerDesc));
+
     _cascades.resize(cascadeCount);
 
+    for (uint cascadeIndex=0; cascadeIndex < cascadeCount; cascadeIndex++) {
+        auto& cascade = _cascades[cascadeIndex];
+        std::string name = "Shadowmap Cascade ";
+        name += '0' + cascadeIndex;
+        cascade.framebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create(name));
+        cascade.framebuffer->setDepthBuffer(map, depthFormat, cascadeIndex);
+    }
+
     setMaxDistance(maxDistance);
 }
 

libraries/render-utils/src/LightStage.h

@@ -53,7 +53,6 @@ public:
             Cascade();
 
             gpu::FramebufferPointer framebuffer;
-            gpu::TexturePointer map;
 
             const std::shared_ptr<ViewFrustum>& getFrustum() const { return _frustum; }
 
@@ -93,6 +92,8 @@ public:
 
         const graphics::LightPointer& getLight() const { return _light; }
 
+        gpu::TexturePointer map;
+
     protected:
 
 #include "Shadows_shared.slh"

libraries/render-utils/src/Shadow.slh

@@ -17,11 +17,11 @@
 #define SHADOW_SCREEN_SPACE_DITHER      1
 
 // the shadow texture
-uniform sampler2DShadow shadowMaps[SHADOW_CASCADE_MAX_COUNT];
+uniform sampler2DArrayShadow shadowMaps;
 
 // Sample the shadowMap with PCF (built-in)
 float fetchShadow(int cascadeIndex, vec3 shadowTexcoord) {
-    return texture(shadowMaps[cascadeIndex], shadowTexcoord);
+    return texture(shadowMaps, vec4(shadowTexcoord.xy, cascadeIndex, shadowTexcoord.z));
 }
 
 vec2 PCFkernel[4] = vec2[4](