Implement the uniform buffer and resource texture cache and their reset

libraries/gpu/src/gpu/GLBackend.h

@@ -197,6 +197,15 @@ public:
 
     uint32 getNumInputBuffers() const { return _input._invalidBuffers.size(); }
 
+    // this is the maximum per shader stage on the low end apple
+    // TODO make it platform dependant at init time
+    static const int MAX_NUM_UNIFORM_BUFFERS = 12;
+    uint32 getMaxNumUniformBuffers() const { return MAX_NUM_UNIFORM_BUFFERS; }
+
+    // this is the maximum per shader stage on the low end apple
+    // TODO make it platform dependant at init time
+    static const int MAX_NUM_RESOURCE_TEXTURES = 16;
+    uint32 getMaxNumResourceTextures() const { return MAX_NUM_RESOURCE_TEXTURES; }
 
     // The State setters called by the GLState::Commands when a new state is assigned
     void do_setStateFillMode(int32 mode);
@@ -332,19 +341,30 @@ protected:
 
     // Uniform Stage
     void do_setUniformBuffer(Batch& batch, uint32 paramOffset);
-    
+
+    void releaseUniformBuffer(int slot);
     void resetUniformStage();
     struct UniformStageState {
-        
+        Buffers _buffers;
-    };
+
+        UniformStageState():
+            _buffers(MAX_NUM_UNIFORM_BUFFERS, nullptr)
+        {}
+    } _uniform;
     
     // Resource Stage
     void do_setResourceTexture(Batch& batch, uint32 paramOffset);
     
+    void releaseResourceTexture(int slot);
     void resetResourceStage();
     struct ResourceStageState {
-        
+        Textures _textures;
-    };
+
+        ResourceStageState():
+            _textures(MAX_NUM_RESOURCE_TEXTURES, nullptr)
+        {}
+
+    } _resource;
 
     // Pipeline Stage
     void do_setPipeline(Batch& batch, uint32 paramOffset);

libraries/gpu/src/gpu/GLBackendPipeline.cpp

@@ -178,8 +178,27 @@ void GLBackend::resetPipelineStage() {
     glUseProgram(0);
 }
 
+
+void GLBackend::releaseUniformBuffer(int slot) {
+#if (GPU_FEATURE_PROFILE == GPU_CORE)
+    auto& buf = _uniform._buffers[slot];
+    if (buf) {
+        auto* object = Backend::getGPUObject<GLBackend::GLBuffer>(*buf);
+        if (object) {
+            GLuint bo = object->_buffer;
+            glBindBufferBase(GL_UNIFORM_BUFFER, slot, 0); // RELEASE
+
+            (void) CHECK_GL_ERROR();
+        }
+        buf.reset();
+    }
+#endif
+}
+
 void GLBackend::resetUniformStage() {
-    
+    for (int i = 0; i < _uniform._buffers.size(); i++) {
+        releaseUniformBuffer(i);
+    }
 }
 
 void GLBackend::do_setUniformBuffer(Batch& batch, uint32 paramOffset) {
@@ -188,9 +207,31 @@ void GLBackend::do_setUniformBuffer(Batch& batch, uint32 paramOffset) {
     GLintptr rangeStart = batch._params[paramOffset + 1]._uint;
     GLsizeiptr rangeSize = batch._params[paramOffset + 0]._uint;
 
+
+
+
 #if (GPU_FEATURE_PROFILE == GPU_CORE)
-    GLuint bo = getBufferID(*uniformBuffer);
+    if (!uniformBuffer) {
-    glBindBufferRange(GL_UNIFORM_BUFFER, slot, bo, rangeStart, rangeSize);
+        releaseUniformBuffer(slot);
+        return;
+    }
+    
+    // check cache before thinking
+    if (_uniform._buffers[slot] == uniformBuffer) {
+        return;
+    }
+
+    // Sync BufferObject
+    auto* object = GLBackend::syncGPUObject(*uniformBuffer);
+    if (object) {
+        glBindBufferRange(GL_UNIFORM_BUFFER, slot, object->_buffer, rangeStart, rangeSize);
+
+        _uniform._buffers[slot] = uniformBuffer;
+        (void) CHECK_GL_ERROR();
+    } else {
+        releaseResourceTexture(slot);
+        return;
+    }
 #else
     // because we rely on the program uniform mechanism we need to have
     // the program bound, thank you MacOSX Legacy profile.
@@ -202,23 +243,49 @@ void GLBackend::do_setUniformBuffer(Batch& batch, uint32 paramOffset) {
     // NOT working so we ll stick to the uniform float array until we move to core profile
     // GLuint bo = getBufferID(*uniformBuffer);
     //glUniformBufferEXT(_shader._program, slot, bo);
-#endif
+
     (void) CHECK_GL_ERROR();
+
+#endif
+}
+
+void GLBackend::releaseResourceTexture(int slot) {
+    auto& tex = _resource._textures[slot];
+    if (tex) {
+        auto* object = Backend::getGPUObject<GLBackend::GLTexture>(*tex);
+        if (object) {
+            GLuint to = object->_texture;
+            GLuint target = object->_target;
+            glActiveTexture(GL_TEXTURE0 + slot);
+            glBindTexture(target, 0); // RELEASE
+
+            (void) CHECK_GL_ERROR();
+        }
+        tex.reset();
+    }
 }
 
 void GLBackend::resetResourceStage() {
-    
+    for (int i = 0; i < _resource._textures.size(); i++) {
+        releaseResourceTexture(i);
+    }
 }
 
 void GLBackend::do_setResourceTexture(Batch& batch, uint32 paramOffset) {
     GLuint slot = batch._params[paramOffset + 1]._uint;
-    TexturePointer uniformTexture = batch._textures.get(batch._params[paramOffset + 0]._uint);
+    TexturePointer resourceTexture = batch._textures.get(batch._params[paramOffset + 0]._uint);
 
-    if (!uniformTexture) {
+    if (!resourceTexture) {
+        releaseResourceTexture(slot);
+        return;
+    }
+    // check cache before thinking
+    if (_resource._textures[slot] == resourceTexture) {
         return;
     }
 
-    GLTexture* object = GLBackend::syncGPUObject(*uniformTexture);
+    // Always make sure the GLObject is in sync
+    GLTexture* object = GLBackend::syncGPUObject(*resourceTexture);
     if (object) {
         GLuint to = object->_texture;
         GLuint target = object->_target;
@@ -227,7 +294,10 @@ void GLBackend::do_setResourceTexture(Batch& batch, uint32 paramOffset) {
 
         (void) CHECK_GL_ERROR();
 
+        _resource._textures[slot] = resourceTexture;
+
     } else {
+        releaseResourceTexture(slot);
         return;
     }
 }