1 #ifndef _VKTSHADERRENDER_HPP
2 #define _VKTSHADERRENDER_HPP
3 /*------------------------------------------------------------------------
4 * Vulkan Conformance Tests
5 * ------------------------
7 * Copyright (c) 2015 The Khronos Group Inc.
8 * Copyright (c) 2015 Samsung Electronics Co., Ltd.
10 * Permission is hereby granted, free of charge, to any person obtaining a
11 * copy of this software and/or associated documentation files (the
12 * "Materials"), to deal in the Materials without restriction, including
13 * without limitation the rights to use, copy, modify, merge, publish,
14 * distribute, sublicense, and/or sell copies of the Materials, and to
15 * permit persons to whom the Materials are furnished to do so, subject to
16 * the following conditions:
18 * The above copyright notice(s) and this permission notice shall be included
19 * in all copies or substantial portions of the Materials.
21 * The Materials are Confidential Information as defined by the
22 * Khronos Membership Agreement until designated non-confidential by Khronos,
23 * at which point this condition clause shall be removed.
25 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
28 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
29 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
30 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
31 * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
35 * \brief Vulkan ShaderRenderCase
36 *//*--------------------------------------------------------------------*/
38 #include "tcuTexture.hpp"
39 #include "tcuSurface.hpp"
42 #include "deSharedPtr.hpp"
43 #include "deUniquePtr.hpp"
46 #include "vkPrograms.hpp"
48 #include "vkMemUtil.hpp"
49 #include "vkBuilderUtil.hpp"
51 #include "vktTestCaseUtil.hpp"
61 LineStream (int indent = 0) { m_indent = indent; }
64 const char* str (void) const { m_string = m_stream.str(); return m_string.c_str(); }
65 LineStream& operator<< (const char* line) { for (int i = 0; i < m_indent; i++) { m_stream << "\t"; } m_stream << line << "\n"; return *this; }
69 std::ostringstream m_stream;
70 mutable std::string m_string;
74 class ShaderRenderCaseInstance;
90 TextureBinding (const tcu::Archive& archive,
93 const tcu::Sampler& sampler);
94 ~TextureBinding (void);
95 Type getType (void) const { return m_type; }
96 const tcu::Sampler& getSampler (void) const { return m_sampler; }
97 const tcu::Texture2D& get2D (void) const { DE_ASSERT(getType() == TYPE_2D && m_binding.tex2D !=NULL); return *m_binding.tex2D; }
100 TextureBinding (const TextureBinding&); // not allowed!
101 TextureBinding& operator= (const TextureBinding&); // not allowed!
103 static de::MovePtr<tcu::Texture2D> loadTexture2D (const tcu::Archive& archive, const char* filename);
106 tcu::Sampler m_sampler;
110 const tcu::Texture2D* tex2D;
114 typedef de::SharedPtr<TextureBinding> TextureBindingSp;
116 // ShaderEvalContext.
118 class ShaderEvalContext
124 MAX_USER_ATTRIBS = 4,
130 tcu::Sampler sampler;
131 const tcu::Texture2D* tex2D;
132 const tcu::TextureCube* texCube;
133 const tcu::Texture2DArray* tex2DArray;
134 const tcu::Texture3D* tex3D;
136 inline ShaderSampler (void)
139 , tex2DArray(DE_NULL)
145 ShaderEvalContext (const QuadGrid& quadGrid);
146 ~ShaderEvalContext (void);
148 void reset (float sx, float sy);
152 tcu::Vec4 unitCoords;
153 tcu::Vec4 constCoords;
155 tcu::Vec4 in[MAX_USER_ATTRIBS];
156 ShaderSampler textures[MAX_TEXTURES];
163 inline void discard (void) { isDiscarded = true; }
164 tcu::Vec4 texture2D (int unitNdx, const tcu::Vec2& coords);
167 const QuadGrid& m_quadGrid;
170 typedef void (*ShaderEvalFunc) (ShaderEvalContext& c);
172 inline void evalCoordsPassthroughX (ShaderEvalContext& c) { c.color.x() = c.coords.x(); }
173 inline void evalCoordsPassthroughXY (ShaderEvalContext& c) { c.color.xy() = c.coords.swizzle(0,1); }
174 inline void evalCoordsPassthroughXYZ (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); }
175 inline void evalCoordsPassthrough (ShaderEvalContext& c) { c.color = c.coords; }
176 inline void evalCoordsSwizzleWZYX (ShaderEvalContext& c) { c.color = c.coords.swizzle(3,2,1,0); }
179 // Either inherit a class with overridden evaluate() or just pass in an evalFunc.
181 class ShaderEvaluator
184 ShaderEvaluator (void);
185 ShaderEvaluator (const ShaderEvalFunc evalFunc);
186 virtual ~ShaderEvaluator (void);
188 virtual void evaluate (ShaderEvalContext& ctx) const;
191 ShaderEvaluator (const ShaderEvaluator&); // not allowed!
192 ShaderEvaluator& operator= (const ShaderEvaluator&); // not allowed!
194 const ShaderEvalFunc m_evalFunc;
199 typedef void (*UniformSetupFunc) (ShaderRenderCaseInstance& instance, const tcu::Vec4& constCoords);
205 UniformSetup (const UniformSetupFunc setup);
206 virtual ~UniformSetup (void);
207 virtual void setup (ShaderRenderCaseInstance& instance, const tcu::Vec4& constCoords) const;
210 UniformSetup (const UniformSetup&); // not allowed!
211 UniformSetup& operator= (const UniformSetup&); // not allowed!
213 const UniformSetupFunc m_setupFunc;
216 typedef void (*AttributeSetupFunc) (ShaderRenderCaseInstance& instance, deUint32 numVertices);
218 class ShaderRenderCase : public vkt::TestCase
221 ShaderRenderCase (tcu::TestContext& testCtx,
222 const std::string& name,
223 const std::string& description,
224 const bool isVertexCase,
225 const ShaderEvalFunc evalFunc,
226 const UniformSetup* uniformSetup,
227 const AttributeSetupFunc attribFunc);
229 ShaderRenderCase (tcu::TestContext& testCtx,
230 const std::string& name,
231 const std::string& description,
232 const bool isVertexCase,
233 const ShaderEvaluator* evaluator,
234 const UniformSetup* uniformSetup,
235 const AttributeSetupFunc attribFunc);
238 virtual ~ShaderRenderCase (void);
239 virtual void initPrograms (vk::SourceCollections& programCollection) const;
240 virtual TestInstance* createInstance (Context& context) const;
243 std::string m_vertShaderSource;
244 std::string m_fragShaderSource;
246 const bool m_isVertexCase;
247 const de::UniquePtr<const ShaderEvaluator> m_evaluator;
248 const de::UniquePtr<const UniformSetup> m_uniformSetup;
249 const AttributeSetupFunc m_attribFunc;
353 enum BaseAttributeType
373 // ShaderRenderCaseInstance.
375 class ShaderRenderCaseInstance : public vkt::TestInstance
378 ShaderRenderCaseInstance (Context& context,
379 const bool isVertexCase,
380 const ShaderEvaluator& evaluator,
381 const UniformSetup& uniformSetup,
382 const AttributeSetupFunc attribFunc);
384 virtual ~ShaderRenderCaseInstance (void);
385 virtual tcu::TestStatus iterate (void);
387 void addAttribute (deUint32 bindingLocation,
389 deUint32 sizePerElement,
392 void useAttribute (deUint32 bindingLocation,
393 BaseAttributeType type);
396 void addUniform (deUint32 bindingLocation,
397 vk::VkDescriptorType descriptorType,
399 void addUniform (deUint32 bindingLocation,
400 vk::VkDescriptorType descriptorType,
403 void useUniform (deUint32 bindingLocation,
404 BaseUniformType type);
405 void useSampler2D (deUint32 bindingLocation,
409 virtual void setup (void);
410 virtual void setupUniforms (const tcu::Vec4& constCoords);
412 const tcu::UVec2 getViewportSize (void) const;
414 std::vector<tcu::Mat4> m_userAttribTransforms;
415 const tcu::Vec4 m_clearColor;
416 std::vector<TextureBindingSp> m_textures;
418 vk::Allocator& m_memAlloc;
422 void setupTextures (void);
423 de::MovePtr<vk::Allocation> uploadImage2D (const tcu::Texture2D& refTexture,
424 const vk::VkImage& vkTexture);
425 vk::Move<vk::VkImage> createImage2D (const tcu::Texture2D& texture,
426 const vk::VkFormat format,
427 const vk::VkImageUsageFlags usage,
428 const vk::VkImageTiling tiling);
429 void copyTilingImageToOptimal (const vk::VkImage& srcImage,
430 const vk::VkImage& dstImage,
434 void setupUniformData (deUint32 bindingLocation, size_t size, const void* dataPtr);
435 void setupDefaultInputs (const QuadGrid& quadGrid);
437 void render (tcu::Surface& result, const QuadGrid& quadGrid);
438 void computeVertexReference (tcu::Surface& result, const QuadGrid& quadGrid);
439 void computeFragmentReference (tcu::Surface& result, const QuadGrid& quadGrid);
440 bool compareImages (const tcu::Surface& resImage,
441 const tcu::Surface& refImage,
442 float errorThreshold);
444 const bool m_isVertexCase;
445 const ShaderEvaluator& m_evaluator;
446 const UniformSetup& m_uniformSetup;
447 const AttributeSetupFunc m_attribFunc;
449 struct EnabledBaseAttribute
452 BaseAttributeType type;
454 std::vector<EnabledBaseAttribute> m_enabledBaseAttributes;
456 const tcu::UVec2 m_renderSize;
457 const vk::VkFormat m_colorFormat;
459 vk::Move<vk::VkImage> m_colorImage;
460 de::MovePtr<vk::Allocation> m_colorImageAlloc;
461 vk::Move<vk::VkImageView> m_colorImageView;
463 vk::Move<vk::VkRenderPass> m_renderPass;
464 vk::Move<vk::VkFramebuffer> m_framebuffer;
465 vk::Move<vk::VkPipelineLayout> m_pipelineLayout;
466 vk::Move<vk::VkPipeline> m_graphicsPipeline;
468 vk::Move<vk::VkShaderModule> m_vertexShaderModule;
469 vk::Move<vk::VkShaderModule> m_fragmentShaderModule;
471 vk::Move<vk::VkBuffer> m_indiceBuffer;
472 de::MovePtr<vk::Allocation> m_indiceBufferAlloc;
474 vk::Move<vk::VkDescriptorSetLayout> m_descriptorSetLayout;
476 vk::Move<vk::VkDescriptorPool> m_descriptorPool;
477 vk::Move<vk::VkDescriptorSet> m_descriptorSet;
479 vk::Move<vk::VkCommandPool> m_cmdPool;
480 vk::Move<vk::VkCommandBuffer> m_cmdBuffer;
482 vk::Move<vk::VkFence> m_fence;
484 vk::DescriptorSetLayoutBuilder m_descriptorSetLayoutBuilder;
485 vk::DescriptorPoolBuilder m_descriptorPoolBuilder;
486 vk::DescriptorSetUpdateBuilder m_descriptorSetUpdateBuilder;
488 typedef de::SharedPtr<vk::Unique<vk::VkBuffer> > VkBufferSp;
490 typedef de::SharedPtr<vk::Unique<vk::VkImage> > VkImageSp;
491 typedef de::SharedPtr<vk::Unique<vk::VkImageView> > VkImageViewSp;
492 typedef de::SharedPtr<vk::Unique<vk::VkSampler> > VkSamplerSp;
493 typedef de::SharedPtr<vk::Allocation> AllocationSp;
498 UniformInfo (void) {}
499 virtual ~UniformInfo (void) {}
501 vk::VkDescriptorType type;
505 class BufferUniform : public UniformInfo
508 BufferUniform (void) {}
509 virtual ~BufferUniform (void) {}
513 vk::VkDescriptorBufferInfo descriptor;
516 class SamplerUniform : public UniformInfo
519 SamplerUniform (void) {}
520 virtual ~SamplerUniform (void) {}
523 VkImageViewSp imageView;
526 vk::VkDescriptorImageInfo descriptor;
529 typedef de::SharedPtr<de::UniquePtr<UniformInfo> > UniformInfoSp;
530 std::vector<UniformInfoSp> m_uniformInfos;
532 std::vector<vk::VkVertexInputBindingDescription> m_vertexBindingDescription;
533 std::vector<vk::VkVertexInputAttributeDescription> m_vertexattributeDescription;
535 std::vector<VkBufferSp> m_vertexBuffers;
536 std::vector<AllocationSp> m_vertexBufferAllocs;
540 void ShaderRenderCaseInstance::addUniform (deUint32 bindingLocation, vk::VkDescriptorType descriptorType, const T& data)
542 addUniform(bindingLocation, descriptorType, sizeof(T), &data);
548 #endif // _VKTSHADERRENDER_HPP