Feature/uniform location

src/backend/Backend.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include "backend/BindGroup.h"
 #include "backend/RenderPassDescriptor.h"
 #include "backend/RenderPipeline.h"
 #include "backend/RenderPipelineDescriptor.h"
@@ -9,7 +8,7 @@
 #include "backend/CommandBuffer.h"
 #include "backend/Buffer.h"
 #include "backend/VertexLayout.h"
-#include "backend/ShaderModule.h"
 #include "backend/Texture.h"
 #include "backend/DepthStencilState.h"
 #include "backend/BlendState.h"
+#include "backend/ProgramCache.h"

src/backend/CommandBuffer.h

@@ -13,7 +13,6 @@ CC_BACKEND_BEGIN
 class RenderPass;
 class RenderPipeline;
 class Buffer;
-class BindGroup;
 
 class CommandBuffer : public cocos2d::Ref
 {
@@ -24,7 +23,6 @@ class CommandBuffer : public cocos2d::Ref
     virtual void setViewport(uint32_t x, uint32_t y, uint32_t w, uint32_t h) = 0;
     virtual void setCullMode(CullMode mode) = 0;
     virtual void setVertexBuffer(uint32_t index, Buffer* buffer) = 0;
-    virtual void setBindGroup(BindGroup* bindGroup) = 0;
     virtual void setIndexBuffer(Buffer* buffer) = 0;
     virtual void drawArrays(PrimitiveType primitiveType, uint32_t start,  uint32_t count) = 0;
     virtual void drawElements(PrimitiveType primitiveType, IndexFormat indexType, uint32_t count) = 0;

src/backend/Device.h

@@ -7,6 +7,7 @@
 #include "Texture.h"
 #include "DepthStencilState.h"
 #include "BlendState.h"
+#include "ProgramCache.h"
 
 #include "base/CCRef.h"
 
@@ -19,6 +20,7 @@ class Buffer;
 class ShaderModule;
 class RenderPipeline;
 class RenderPass;
+class Program;
 
 class Device : public cocos2d::Ref
 {
@@ -33,14 +35,14 @@ class Device : public cocos2d::Ref
     virtual Buffer* newBuffer(uint32_t size, BufferType type, BufferUsage usage) = 0;
     // Create a texture, not auto released.
     virtual Texture* newTexture(const TextureDescriptor& descriptor) = 0;
-    // Create a auto released shader module.
-    virtual ShaderModule* createShaderModule(ShaderStage stage, const std::string& source) = 0;
     // Create a auto released depth stencil state.
     virtual DepthStencilState* createDepthStencilState(const DepthStencilDescriptor& descriptor) = 0;
     // Create a auto released blend state.
     virtual BlendState* createBlendState(const BlendDescriptor& descriptor) = 0;
     // Create a render pipeline, not auto released.
     virtual RenderPipeline* newRenderPipeline(const RenderPipelineDescriptor& descriptor) = 0;
+    virtual Program* createProgram(const std::string& vertexShader, const std::string& fragmentShader) = 0;
+
 
 private:
     static Device* _instance;

src/backend/Program.cpp

@@ -0,0 +1,80 @@
+#include "Program.h"
+#include "ShaderModule.h"
+#include "Texture.h"
+
+CC_BACKEND_BEGIN
+
+Program::Program(const std::string& vertexShader, const std::string& fragmentShader)
+{
+    std::string shaderSource = vertexShader + fragmentShader;
+    _key = std::hash<std::string>{}(shaderSource);
+}
+
+Program::~Program()
+{
+    _vertexTextureInfos.clear();
+    _fragmentTextureInfos.clear();
+}
+
+Program::TextureInfo::~TextureInfo()
+{
+    releaseTextures();
+}
+
+void Program::TextureInfo::retainTextures()
+{
+    for (auto& texture : textures)
+        CC_SAFE_RETAIN(texture);
+}
+
+void Program::TextureInfo::releaseTextures()
+{
+    for (auto& texture : textures)
+        CC_SAFE_RELEASE(texture);
+}
+
+void Program::setVertexTexture(int location, uint32_t slot, Texture* texture)
+{
+    setTexture(location, slot, texture, _vertexTextureInfos);
+}
+
+void Program::setFragmentTexture(int location, uint32_t slot, Texture* texture)
+{
+    setTexture(location, slot, texture, _fragmentTextureInfos);
+}
+
+void Program::setVertexTextureArray(int location, const std::vector<uint32_t>& slots, const std::vector<Texture*> textures)
+{
+    setTextureArray(location, slots, textures, _vertexTextureInfos);
+}
+
+void Program::setFragmentTextureArray(int location, const std::vector<uint32_t>& slots, const std::vector<Texture*> textures)
+{
+    setTextureArray(location, slots, textures, _fragmentTextureInfos);
+}
+
+void Program::setTexture(int location, uint32_t slot, Texture* texture, std::unordered_map<int, TextureInfo>& textureInfo)
+{
+    if(location < 0)
+        return;
+
+    TextureInfo info;
+    info.location = location;
+    info.slot = {slot};
+    info.textures = {texture};
+    info.retainTextures();
+    textureInfo[location] = info;
+}
+
+void Program::setTextureArray(int location, const std::vector<uint32_t>& slots, const std::vector<Texture*> textures, std::unordered_map<int, TextureInfo>& textureInfo)
+{
+    assert(slots.size() == textures.size());
+    TextureInfo info;
+    info.location = location;
+    info.slot = slots;
+    info.textures = textures;
+    info.retainTextures();
+    textureInfo[location] = info;
+}
+
+CC_BACKEND_END

src/backend/Program.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include "Macros.h"
+#include "base/CCRef.h"
+#include "platform/CCPlatformMacros.h"
+#include <string>
+#include <vector>
+#include <unordered_map>
+
+CC_BACKEND_BEGIN
+
+class ShaderModule;
+class Texture;
+
+class Program : public Ref
+{
+public:
+    struct TextureInfo
+    {
+        ~TextureInfo();
+
+        void retainTextures();
+        void releaseTextures();
+
+        int location = 0;
+        std::vector<uint32_t> slot;
+        std::vector<Texture*> textures;
+    };
+
+    Program(const std::string& vertexShader, const std::string& fragmentShader);
+
+    virtual int getVertexUniformLocation(const std::string& uniform) const = 0;
+    virtual int getFragmentUniformLocation(const std::string& uniform) const = 0;
+    virtual void setVertexUniform(int location, void* data, uint32_t size) = 0;
+    virtual void setFragmentUniform(int location, void* data, uint32_t size) = 0;
+    virtual void setVertexTexture(int location, uint32_t slot, Texture* texture);
+    virtual void setFragmentTexture(int location, uint32_t slot, Texture* texture);
+    virtual void setVertexTextureArray(int location, const std::vector<uint32_t>& slots, const std::vector<Texture*> textures);
+    virtual void setFragmentTextureArray(int location, const std::vector<uint32_t>& slots, const std::vector<Texture*> textures);
+
+    inline const std::unordered_map<int, TextureInfo>& getVertexTextureInfos() const { return _vertexTextureInfos; }
+    inline const std::unordered_map<int, TextureInfo>& getFragmentTextureInfos() const { return _fragmentTextureInfos; }
+    inline std::size_t getKey() const { return _key; }
+
+protected:
+    Program() = default;
+    virtual ~Program();
+
+    void setTexture(int location, uint32_t slot, Texture* texture, std::unordered_map<int, TextureInfo>& textureInfo);
+    void setTextureArray(int location, const std::vector<uint32_t>& slots, const std::vector<Texture*> textures, std::unordered_map<int, TextureInfo>& textureInfo);
+
+    std::unordered_map<int, TextureInfo> _vertexTextureInfos;
+    std::unordered_map<int, TextureInfo> _fragmentTextureInfos;
+
+    std::size_t _key = 0;
+};
+
+CC_BACKEND_END