ShaderRenderCase: Add addUniform call which have a size parameter

diff --git a/external/vulkancts/modules/vulkan/shaderrendercase/vktShaderRenderCase.cpp b/external/vulkancts/modules/vulkan/shaderrendercase/vktShaderRenderCase.cpp
index 6c08b9d..b40cf10 100644 (file)
--- a/external/vulkancts/modules/vulkan/shaderrendercase/vktShaderRenderCase.cpp
+++ b/external/vulkancts/modules/vulkan/shaderrendercase/vktShaderRenderCase.cpp
@@ -296,15 +296,38 @@ void ShaderEvaluator::evaluate (ShaderEvalContext& ctx)
     m_evalFunc(ctx);
 }
 
+
+// UniformSetup.
+
+UniformSetup::UniformSetup (void)
+       : m_setupFunc(DE_NULL)
+{
+}
+
+UniformSetup::UniformSetup (UniformSetupFunc setupFunc)
+       : m_setupFunc(setupFunc)
+{
+}
+
+UniformSetup::~UniformSetup (void)
+{
+}
+
+void UniformSetup::setup (ShaderRenderCaseInstance& instance, const tcu::Vec4& constCoords)
+{
+       if (m_setupFunc)
+               m_setupFunc(instance, constCoords);
+}
+
 // ShaderRenderCaseInstance.
 
-ShaderRenderCaseInstance::ShaderRenderCaseInstance (Context& context, bool isVertexCase, ShaderEvaluator& evaluator, UniformSetupFunc uniformFunc, AttributeSetupFunc attribFunc)
+ShaderRenderCaseInstance::ShaderRenderCaseInstance (Context& context, bool isVertexCase, ShaderEvaluator& evaluator, UniformSetup& uniformSetup, AttributeSetupFunc attribFunc)
        : vkt::TestInstance(context)
        , m_clearColor(DEFAULT_CLEAR_COLOR)
        , memAlloc(m_context.getDeviceInterface(), m_context.getDevice(), getPhysicalDeviceMemoryProperties(m_context.getInstanceInterface(), m_context.getPhysicalDevice()))
        , m_isVertexCase(isVertexCase)
        , m_evaluator(evaluator)
-       , m_uniformFunc(uniformFunc)
+       , m_uniformSetup(uniformSetup)
        , m_attribFunc(attribFunc)
        , m_renderSize(100, 100)
        , m_colorFormat(VK_FORMAT_R8G8B8A8_UNORM)
@@ -431,6 +454,13 @@ void ShaderRenderCaseInstance::setupUniformData (deUint32 bindingLocation, deUin
        m_uniformInfos.push_back(uniformInfo);
 }
 
+void ShaderRenderCaseInstance::addUniform (deUint32 bindingLocation, vk::VkDescriptorType descriptorType, deUint32 dataSize, const void* data)
+{
+       m_descriptorSetLayoutBuilder.addSingleBinding(descriptorType, vk::VK_SHADER_STAGE_VERTEX_BIT);
+       m_descriptorPoolBuilder.addType(descriptorType);
+
+       setupUniformData(bindingLocation, dataSize, data);
+}
 
 void ShaderRenderCaseInstance::addAttribute (deUint32 bindingLocation, vk::VkFormat format, deUint32 sizePerElement, deUint32 count, const void* dataPtr)
 {
@@ -502,7 +532,7 @@ void ShaderRenderCaseInstance::setupUniforms (const Vec4& constCoords)
 {
        // TODO!!
        DE_UNREF(constCoords);
-       m_uniformFunc(*this);
+       m_uniformSetup.setup(*this, constCoords);
 }
 
 void ShaderRenderCaseInstance::useUniform (deUint32 bindingLocation, BaseUniformType type)

diff --git a/external/vulkancts/modules/vulkan/shaderrendercase/vktShaderRenderCase.hpp b/external/vulkancts/modules/vulkan/shaderrendercase/vktShaderRenderCase.hpp
index e4a508b..da5622a 100644 (file)
--- a/external/vulkancts/modules/vulkan/shaderrendercase/vktShaderRenderCase.hpp
+++ b/external/vulkancts/modules/vulkan/shaderrendercase/vktShaderRenderCase.hpp
@@ -165,9 +165,28 @@ private:
     ShaderEvalFunc      m_evalFunc;
 };
 
+
 class ShaderRenderCaseInstance;
 
-typedef void (*UniformSetupFunc) (ShaderRenderCaseInstance& instance);
+// UniformSetup
+
+typedef void (*UniformSetupFunc) (ShaderRenderCaseInstance& instance, const tcu::Vec4& constCoords);
+
+class UniformSetup
+{
+public:
+                                               UniformSetup                    (void);
+                                               UniformSetup                    (UniformSetupFunc setup);
+       virtual                         ~UniformSetup                   (void);
+       virtual void            setup                                   (ShaderRenderCaseInstance& instance, const tcu::Vec4& constCoords);
+
+private:
+                                               UniformSetup                    (const UniformSetup&);  // not allowed!
+       UniformSetup&           operator=                               (const UniformSetup&);  // not allowed!
+
+       UniformSetupFunc        m_setupFunc;
+};
+
 typedef void (*AttributeSetupFunc) (ShaderRenderCaseInstance& instance, deUint32 numVertices);
 
 template<typename Instance>
@@ -179,12 +198,12 @@ public:
                                                                                                const std::string& description,
                                                                                                bool isVertexCase,
                                                                                                ShaderEvalFunc evalFunc,
-                                                                                               UniformSetupFunc uniformFunc,
+                                                                                               UniformSetup* uniformSetup,
                                                                                                AttributeSetupFunc attribFunc)
                                                                : vkt::TestCase(testCtx, name, description)
                                                                , m_isVertexCase(isVertexCase)
                                                                , m_evaluator(new ShaderEvaluator(evalFunc))
-                                                               , m_uniformFunc(uniformFunc)
+                                                               , m_uniformSetup(uniformSetup)
                                                                , m_attribFunc(attribFunc)
                                                        {}
 
@@ -193,12 +212,12 @@ public:
                                                                                                const std::string& description,
                                                                                                bool isVertexCase,
                                                                                                ShaderEvaluator* evaluator,
-                                                                                               UniformSetupFunc uniformFunc,
+                                                                                               UniformSetup* uniformSetup,
                                                                                                AttributeSetupFunc attribFunc)
                                                                : vkt::TestCase(testCtx, name, description)
                                                                , m_isVertexCase(isVertexCase)
                                                                , m_evaluator(evaluator)
-                                                               , m_uniformFunc(uniformFunc)
+                                                               , m_uniformSetup(uniformSetup)
                                                                , m_attribFunc(attribFunc)
                                                        {}
 
@@ -210,7 +229,12 @@ public:
                                                                programCollection.add("frag") << glu::FragmentSource(m_fragShaderSource);
                                                        }
 
-       virtual TestInstance*   createInstance          (Context& context) const { return new Instance(context, m_isVertexCase, *m_evaluator, m_uniformFunc, m_attribFunc); }
+       virtual TestInstance*   createInstance          (Context& context) const
+                                                       {
+                                                               DE_ASSERT(m_evaluator != DE_NULL);
+                                                               DE_ASSERT(m_uniformSetup != DE_NULL);
+                                                               return new Instance(context, m_isVertexCase, *m_evaluator, *m_uniformSetup, m_attribFunc);
+                                                       }
 
 protected:
     std::string                                m_vertShaderSource;
@@ -219,7 +243,7 @@ protected:
 private:
        bool                                    m_isVertexCase;
        ShaderEvaluator*                m_evaluator;
-       UniformSetupFunc                m_uniformFunc;
+       UniformSetup*                   m_uniformSetup;
        AttributeSetupFunc              m_attribFunc;
 };
 
@@ -332,7 +356,7 @@ public:
                                                                                                                ShaderRenderCaseInstance        (Context& context,
                                                                                                                                                                        bool isVertexCase,
                                                                                                                                                                        ShaderEvaluator& evaluator,
-                                                                                                                                                                       UniformSetupFunc uniformFunc,
+                                                                                                                                                                       UniformSetup& uniformSetup,
                                                                                                                                                                        AttributeSetupFunc attribFunc);
 
        virtual                                                                                         ~ShaderRenderCaseInstance       (void);
@@ -348,6 +372,10 @@ public:
        void                                                                                            addUniform                                      (deUint32 bindingLocation,
                                                                                                                                                                        vk::VkDescriptorType descriptorType,
                                                                                                                                                                        const T data);
+       void                                                                                            addUniform                                      (deUint32 bindingLocation,
+                                                                                                                                                                       vk::VkDescriptorType descriptorType,
+                                                                                                                                                                       deUint32 dataSize,
+                                                                                                                                                                       const void* data);
        void                                                                                            useUniform                                      (deUint32 bindingLocation,
                                                                                                                                                                        BaseUniformType type);
        void                                                                                            useSampler2D                            (deUint32 bindingLocation,
@@ -381,7 +409,7 @@ private:
 
        bool                                                                                            m_isVertexCase;
        ShaderEvaluator&                                                                        m_evaluator;
-       UniformSetupFunc                                                                        m_uniformFunc;
+       UniformSetup&                                                                           m_uniformSetup;
        AttributeSetupFunc                                                                      m_attribFunc;
 
        const tcu::IVec2                                                                        m_renderSize;
@@ -441,10 +469,7 @@ private:
 template<typename T>
 void ShaderRenderCaseInstance::addUniform (deUint32 bindingLocation, vk::VkDescriptorType descriptorType, const T data)
 {
-       m_descriptorSetLayoutBuilder.addSingleBinding(descriptorType, vk::VK_SHADER_STAGE_VERTEX_BIT);
-       m_descriptorPoolBuilder.addType(descriptorType);
-
-       setupUniformData(bindingLocation, sizeof(T), &data);
+       addUniform(bindingLocation, descriptorType, sizeof(T), &data);
 }
 
 } // shaderrendercase

diff --git a/external/vulkancts/modules/vulkan/shaderrendercase/vktShaderRenderCaseTests.cpp b/external/vulkancts/modules/vulkan/shaderrendercase/vktShaderRenderCaseTests.cpp
index cf78f3c..d751cce 100644 (file)
--- a/external/vulkancts/modules/vulkan/shaderrendercase/vktShaderRenderCaseTests.cpp
+++ b/external/vulkancts/modules/vulkan/shaderrendercase/vktShaderRenderCaseTests.cpp
@@ -56,8 +56,9 @@ struct  test_struct {
 
 
 
-void dummy_uniforms (ShaderRenderCaseInstance& instance)
+void dummy_uniforms (ShaderRenderCaseInstance& instance, const tcu::Vec4& constCoords)
 {
+       DE_UNREF(constCoords);
        instance.useUniform(0u, UI_ZERO);
        instance.useUniform(1u, UI_ONE);
        //instance.addUniform(1u, vk::VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1.0f);
@@ -93,9 +94,9 @@ public:
                                        DummyShaderRenderCaseInstance   (Context& context,
                                                                                                        bool isVertexCase,
                                                                                                        ShaderEvaluator& evaluator,
-                                                                                                       UniformSetupFunc uniformFunc,
+                                                                                                       UniformSetup& uniformSetup,
                                                                                                        AttributeSetupFunc attribFunc)
-                                               : ShaderRenderCaseInstance(context, isVertexCase, evaluator, uniformFunc, attribFunc)
+                                               : ShaderRenderCaseInstance(context, isVertexCase, evaluator, uniformSetup, attribFunc)
                                        {}
 
        virtual                 ~DummyShaderRenderCaseInstance  (void)
@@ -130,7 +131,7 @@ public:
                                                ShaderEvalFunc evalFunc,
                                                std::string vertexShader,
                                                std::string fragmentShader)
-               : ShaderRenderCase(testCtx, name, description, isVertexCase, evalFunc, dummy_uniforms, dummy_attributes)
+               : ShaderRenderCase(testCtx, name, description, isVertexCase, evalFunc, new UniformSetup(dummy_uniforms), dummy_attributes)
        {
                m_vertShaderSource = vertexShader;
                m_fragShaderSource = fragmentShader;