| #ifndef _VKTSHADEREXECUTOR_HPP |
| #define _VKTSHADEREXECUTOR_HPP |
| /*------------------------------------------------------------------------ |
| * Vulkan Conformance Tests |
| * ------------------------ |
| * |
| * Copyright (c) 2015 The Khronos Group Inc. |
| * Copyright (c) 2015 Samsung Electronics Co., Ltd. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| *//*! |
| * \file |
| * \brief Vulkan ShaderExecutor |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "deSharedPtr.hpp" |
| |
| #include "vktTestCase.hpp" |
| #include "vkMemUtil.hpp" |
| #include "vkBuilderUtil.hpp" |
| |
| #include "gluVarType.hpp" |
| |
| #include "tcuTexture.hpp" |
| |
| #include <vector> |
| |
| namespace vkt |
| { |
| namespace shaderexecutor |
| { |
| |
| using namespace vk; |
| |
| //! Shader input / output variable declaration. |
| struct Symbol |
| { |
| std::string name; //!< Symbol name. |
| glu::VarType varType; //!< Symbol type. |
| |
| Symbol (void) {} |
| Symbol (const std::string& name_, const glu::VarType& varType_) : name(name_), varType(varType_) {} |
| }; |
| |
| //! Complete shader specification. |
| struct ShaderSpec |
| { |
| std::vector<Symbol> inputs; |
| std::vector<Symbol> outputs; |
| std::string globalDeclarations; //!< These are placed into global scope. Can contain uniform declarations for example. |
| std::string source; //!< Source snippet to be executed. |
| |
| ShaderSpec (void) {} |
| }; |
| |
| // UniformSetup |
| |
| class UniformDataBase; |
| class ShaderExecutor; |
| |
| typedef de::SharedPtr<de::UniquePtr<UniformDataBase> > UniformDataSp; |
| |
| class UniformSetup |
| { |
| public: |
| UniformSetup (void) {} |
| virtual ~UniformSetup (void) {} |
| |
| void addData (UniformDataBase* uniformData) |
| { |
| m_uniforms.push_back(UniformDataSp(new de::UniquePtr<UniformDataBase>(uniformData))); |
| } |
| |
| const std::vector<UniformDataSp>& uniforms (void) const |
| { |
| return m_uniforms; |
| } |
| |
| private: |
| UniformSetup (const UniformSetup&); // not allowed! |
| UniformSetup& operator= (const UniformSetup&); // not allowed! |
| |
| std::vector<UniformDataSp> m_uniforms; |
| }; |
| |
| //! Base class for shader executor. |
| class ShaderExecutor |
| { |
| public: |
| virtual ~ShaderExecutor (void); |
| |
| //! Log executor details (program etc.). |
| virtual void log (tcu::TestLog& log) const = 0; |
| |
| //! Execute |
| virtual void execute (const Context& ctx, int numValues, const void* const* inputs, void* const* outputs) = 0; |
| |
| virtual void setShaderSources (SourceCollections& programCollection) const = 0; |
| |
| void setUniforms (const UniformSetup* uniformSetup) |
| { |
| m_uniformSetup = de::MovePtr<const UniformSetup>(uniformSetup); |
| }; |
| |
| void setupUniformData (const VkDevice& vkDevice, |
| const DeviceInterface& vk, |
| const VkQueue queue, |
| const deUint32 queueFamilyIndex, |
| Allocator& memAlloc, |
| deUint32 bindingLocation, |
| VkDescriptorType descriptorType, |
| deUint32 size, |
| const void* dataPtr); |
| |
| void setupUniformArray (const VkDevice& vkDevice, |
| const DeviceInterface& vk, |
| const VkQueue queue, |
| const deUint32 queueFamilyIndex, |
| Allocator& memAlloc, |
| deUint32 bindingLocation, |
| VkDescriptorType descriptorType, |
| deUint32 arraySize, |
| deUint32 size, |
| const void* dataPtr); |
| |
| void setupSamplerData (const VkDevice& vkDevice, |
| const DeviceInterface& vk, |
| const VkQueue queue, |
| const deUint32 queueFamilyIndex, |
| Allocator& memAlloc, |
| deUint32 bindingLocation, |
| deUint32 numSamplers, |
| const tcu::Sampler& refSampler, |
| const tcu::TextureFormat& texFormat, |
| const tcu::IVec3& texSize, |
| VkImageType imageType, |
| VkImageViewType imageViewType, |
| const void* data); |
| |
| const void* getBufferPtr (const deUint32 bindingLocation) const; |
| |
| protected: |
| ShaderExecutor (const ShaderSpec& shaderSpec, glu::ShaderType shaderType); |
| |
| void addUniforms (const VkDevice& vkDevice, const DeviceInterface& vk, const VkQueue queue, const deUint32 queueFamilyIndex, Allocator& memAlloc); |
| |
| void uploadUniforms (DescriptorSetUpdateBuilder& descriptorSetUpdateBuilder, VkDescriptorSet descriptorSet); |
| |
| class UniformInfo; |
| typedef de::SharedPtr<de::UniquePtr<UniformInfo> > UniformInfoSp; |
| class BufferUniform; |
| typedef de::SharedPtr<de::UniquePtr<BufferUniform> > BufferUniformSp; |
| class SamplerUniform; |
| typedef de::SharedPtr<de::UniquePtr<SamplerUniform> > SamplerUniformSp; |
| |
| typedef de::SharedPtr<Unique<VkBuffer> > VkBufferSp; |
| typedef de::SharedPtr<Unique<VkImage> > VkImageSp; |
| typedef de::SharedPtr<Unique<VkImageView> > VkImageViewSp; |
| typedef de::SharedPtr<Unique<VkSampler> > VkSamplerSp; |
| typedef de::SharedPtr<Allocation> AllocationSp; |
| |
| class UniformInfo |
| { |
| public: |
| enum UniformType |
| { |
| UNIFORM_TYPE_BUFFER = 0, |
| UNIFORM_TYPE_SAMPLER, |
| UNIFORM_TYPE_BUFFER_ARRAY, |
| UNIFORM_TYPE_SAMPLER_ARRAY, |
| |
| UNIFORM_TYPE_LAST |
| }; |
| |
| UniformInfo (void) {} |
| virtual ~UniformInfo (void) {} |
| virtual UniformType getType (void) const = 0; |
| |
| VkDescriptorType type; |
| deUint32 location; |
| }; |
| |
| class BufferUniform : public UniformInfo |
| { |
| public: |
| BufferUniform (void) {} |
| virtual ~BufferUniform (void) {} |
| virtual UniformType getType (void) const { return UNIFORM_TYPE_BUFFER; } |
| |
| VkBufferSp buffer; |
| AllocationSp alloc; |
| VkDescriptorBufferInfo descriptor; |
| }; |
| |
| class SamplerUniform : public UniformInfo |
| { |
| public: |
| SamplerUniform (void) {} |
| virtual ~SamplerUniform (void) {} |
| virtual UniformType getType (void) const { return UNIFORM_TYPE_SAMPLER; } |
| |
| VkImageSp image; |
| VkImageViewSp imageView; |
| VkSamplerSp sampler; |
| AllocationSp alloc; |
| VkDescriptorImageInfo descriptor; |
| }; |
| |
| class BufferArrayUniform : public UniformInfo |
| { |
| public: |
| BufferArrayUniform (void) {} |
| virtual ~BufferArrayUniform (void) {} |
| virtual UniformType getType (void) const { return UNIFORM_TYPE_BUFFER_ARRAY; } |
| |
| std::vector<BufferUniformSp> uniforms; |
| }; |
| |
| class SamplerArrayUniform : public UniformInfo |
| { |
| public: |
| SamplerArrayUniform (void) {} |
| virtual ~SamplerArrayUniform (void) {} |
| virtual UniformType getType (void) const { return UNIFORM_TYPE_SAMPLER_ARRAY; } |
| |
| std::vector<SamplerUniformSp> uniforms; |
| }; |
| |
| void uploadImage (const VkDevice& vkDevice, |
| const DeviceInterface& vk, |
| const VkQueue queue, |
| const deUint32 queueFamilyIndex, |
| Allocator& memAlloc, |
| const tcu::TextureFormat& texFormat, |
| const tcu::IVec3& texSize, |
| const void* data, |
| const deUint32 arraySize, |
| const VkImageAspectFlags aspectMask, |
| VkImage destImage); |
| |
| de::MovePtr<SamplerUniform> createSamplerUniform (const VkDevice& vkDevice, |
| const DeviceInterface& vk, |
| const VkQueue queue, |
| const deUint32 queueFamilyIndex, |
| Allocator& memAlloc, |
| deUint32 bindingLocation, |
| const tcu::Sampler& refSampler, |
| const tcu::TextureFormat& texFormat, |
| const tcu::IVec3& texSize, |
| VkImageType imageType, |
| VkImageViewType imageViewType, |
| const void* data); |
| |
| de::MovePtr<BufferUniform> createBufferUniform (const VkDevice& vkDevice, |
| const DeviceInterface& vk, |
| const VkQueue queue, |
| const deUint32 queueFamilyIndex, |
| Allocator& memAlloc, |
| deUint32 bindingLocation, |
| VkDescriptorType descriptorType, |
| deUint32 size, |
| const void* dataPtr); |
| |
| const ShaderSpec m_shaderSpec; |
| const glu::ShaderType m_shaderType; |
| |
| std::vector<UniformInfoSp> m_uniformInfos; |
| de::MovePtr<const UniformSetup> m_uniformSetup; |
| DescriptorSetLayoutBuilder m_descriptorSetLayoutBuilder; |
| DescriptorPoolBuilder m_descriptorPoolBuilder; |
| |
| }; |
| |
| inline tcu::TestLog& operator<< (tcu::TestLog& log, const ShaderExecutor* executor) { executor->log(log); return log; } |
| inline tcu::TestLog& operator<< (tcu::TestLog& log, const ShaderExecutor& executor) { executor.log(log); return log; } |
| |
| ShaderExecutor* createExecutor(glu::ShaderType shaderType, const ShaderSpec& shaderSpec); |
| |
| class UniformDataBase |
| { |
| public: |
| UniformDataBase (deUint32 bindingLocation) |
| : m_bindingLocation (bindingLocation) |
| { |
| } |
| virtual ~UniformDataBase (void) {} |
| virtual void setup (ShaderExecutor&, const VkDevice&, const DeviceInterface&, const VkQueue, const deUint32, Allocator&) const = 0; |
| |
| protected: |
| const deUint32 m_bindingLocation; |
| }; |
| |
| template<typename T> |
| class UniformData : public UniformDataBase |
| { |
| public: |
| UniformData (deUint32 bindingLocation, VkDescriptorType descriptorType, const T data); |
| virtual ~UniformData (void); |
| virtual void setup (ShaderExecutor& executor, const VkDevice& vkDevice, const DeviceInterface& vk, const VkQueue queue, const deUint32 queueFamilyIndex, Allocator& memAlloc) const; |
| |
| private: |
| VkDescriptorType m_descriptorType; |
| T m_data; |
| }; |
| |
| template<typename T> |
| UniformData<T>::UniformData (deUint32 bindingLocation, VkDescriptorType descriptorType, const T data) |
| : UniformDataBase (bindingLocation) |
| , m_descriptorType (descriptorType) |
| , m_data (data) |
| { |
| } |
| |
| template<typename T> |
| UniformData<T>::~UniformData (void) |
| { |
| } |
| |
| template<typename T> |
| void UniformData<T>::setup (ShaderExecutor& executor, const VkDevice& vkDevice, const DeviceInterface& vk, const VkQueue queue, const deUint32 queueFamilyIndex, Allocator& memAlloc) const |
| { |
| executor.setupUniformData(vkDevice, vk, queue, queueFamilyIndex, memAlloc, m_bindingLocation, m_descriptorType, sizeof(T), &m_data); |
| } |
| |
| template<typename T> |
| class UniformArrayData : public UniformDataBase |
| { |
| public: |
| UniformArrayData (deUint32 bindingLocation, VkDescriptorType descriptorType, const std::vector<T>& data); |
| virtual ~UniformArrayData (void); |
| virtual void setup (ShaderExecutor& executor, const VkDevice& vkDevice, const DeviceInterface& vk, const VkQueue queue, const deUint32 queueFamilyIndex, Allocator& memAlloc) const; |
| |
| private: |
| VkDescriptorType m_descriptorType; |
| std::vector<T> m_data; |
| }; |
| |
| template<typename T> |
| UniformArrayData<T>::UniformArrayData (deUint32 bindingLocation, VkDescriptorType descriptorType, const std::vector<T>& data) |
| : UniformDataBase (bindingLocation) |
| , m_descriptorType (descriptorType) |
| , m_data (data) |
| { |
| } |
| |
| template<typename T> |
| UniformArrayData<T>::~UniformArrayData (void) |
| { |
| } |
| |
| template<typename T> |
| void UniformArrayData<T>::setup (ShaderExecutor& executor, const VkDevice& vkDevice, const DeviceInterface& vk, const VkQueue queue, const deUint32 queueFamilyIndex, Allocator& memAlloc) const |
| { |
| DE_ASSERT(!m_data.empty()); |
| executor.setupUniformArray(vkDevice, vk, queue, queueFamilyIndex, memAlloc, m_bindingLocation, m_descriptorType, (deUint32)m_data.size(), sizeof(T), &m_data[0]); |
| } |
| |
| class SamplerUniformData : public UniformDataBase |
| { |
| public: |
| SamplerUniformData (deUint32 bindingLocation, |
| deUint32 numSamplers, |
| const tcu::Sampler& refSampler, |
| const tcu::TextureFormat& texFormat, |
| const tcu::IVec3& texSize, |
| VkImageType imageType, |
| VkImageViewType imageViewType, |
| const void* data); |
| virtual ~SamplerUniformData (void); |
| virtual void setup (ShaderExecutor& executor, const VkDevice& vkDevice, const DeviceInterface& vk, const VkQueue queue, const deUint32 queueFamilyIndex, Allocator& memAlloc) const; |
| |
| private: |
| deUint32 m_numSamplers; |
| const tcu::Sampler m_refSampler; |
| const tcu::TextureFormat m_texFormat; |
| const tcu::IVec3 m_texSize; |
| VkImageType m_imageType; |
| VkImageViewType m_imageViewType; |
| const void* m_data; |
| }; |
| |
| } // shaderexecutor |
| } // vkt |
| |
| #endif // _VKTSHADEREXECUTOR_HPP |
