external/vulkancts/modules/vulkan/shaderrendercase/vktShaderRenderCase.hpp

   1 #ifndef _VKTSHADERRENDERCASE_HPP
   2 #define _VKTSHADERRENDERCASE_HPP
   3 /*------------------------------------------------------------------------
   4  * Copyright (c) 2015 The Khronos Group Inc.
   5  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and/or associated documentation files (the
   9  * "Materials"), to deal in the Materials without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sublicense, and/or sell copies of the Materials, and to
  12  * permit persons to whom the Materials are furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice(s) and this permission notice shall be included
  16  * in all copies or substantial portions of the Materials.
  17  *
  18  * The Materials are Confidential Information as defined by the
  19  * Khronos Membership Agreement until designated non-confidential by Khronos,
  20  * at which point this condition clause shall be removed.
  21  *
  22  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  25  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  26  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  27  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  28  * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
  29  *
  30  *//*!
  31  * \file
  32  * \brief Vulkan ShaderRenderCase
  33  *//*--------------------------------------------------------------------*/
  34
  35 #include "tcuTexture.hpp"
  36 #include "tcuSurface.hpp"
  37
  38 #include "deMemory.h"
  39 #include "deUniquePtr.hpp"
  40
  41 #include "vktTestCaseUtil.hpp"
  42
  43 #include "vkDefs.hpp"
  44 #include "vkPrograms.hpp"
  45 #include "vkRef.hpp"
  46 #include "vkMemUtil.hpp"
  47 #include "vkBuilderUtil.hpp"
  48
  49 namespace vkt
  50 {
  51 namespace shaderrendercase
  52 {
  53
  54 class QuadGrid;
  55
  56 class TextureBinding
  57 {
  58 };
  59
  60 // ShaderEvalContext.
  61
  62 class ShaderEvalContext
  63 {
  64 public:
  65     // Limits.
  66     enum
  67     {
  68         MAX_USER_ATTRIBS    = 4,
  69         MAX_TEXTURES        = 4,
  70     };
  71
  72     struct ShaderSampler
  73     {
  74         tcu::Sampler                sampler;
  75         const tcu::Texture2D*       tex2D;
  76         const tcu::TextureCube*     texCube;
  77         const tcu::Texture2DArray*  tex2DArray;
  78         const tcu::Texture3D*       tex3D;
  79
  80         inline ShaderSampler (void)
  81             : tex2D     (DE_NULL)
  82             , texCube   (DE_NULL)
  83             , tex2DArray(DE_NULL)
  84             , tex3D     (DE_NULL)
  85         {
  86         }
  87     };
  88
  89                             ShaderEvalContext       (const QuadGrid& quadGrid);
  90                             ~ShaderEvalContext      (void);
  91
  92     void                    reset                   (float sx, float sy);
  93
  94     // Inputs.
  95     tcu::Vec4               coords;
  96     tcu::Vec4               unitCoords;
  97     tcu::Vec4               constCoords;
  98
  99     tcu::Vec4               in[MAX_USER_ATTRIBS];
 100     ShaderSampler           textures[MAX_TEXTURES];
 101
 102     // Output.
 103     tcu::Vec4               color;
 104     bool                    isDiscarded;
 105
 106     // Functions.
 107     inline void             discard                 (void)  { isDiscarded = true; }
 108     tcu::Vec4               texture2D               (int unitNdx, const tcu::Vec2& coords);
 109
 110 private:
 111     const QuadGrid&         quadGrid;
 112 };
 113
 114
 115 typedef void (*ShaderEvalFunc) (ShaderEvalContext& c);
 116
 117 inline void evalCoordsPassthroughX      (ShaderEvalContext& c) { c.color.x() = c.coords.x(); }
 118 inline void evalCoordsPassthroughXY     (ShaderEvalContext& c) { c.color.xy() = c.coords.swizzle(0,1); }
 119 inline void evalCoordsPassthroughXYZ    (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); }
 120 inline void evalCoordsPassthrough       (ShaderEvalContext& c) { c.color = c.coords; }
 121 inline void evalCoordsSwizzleWZYX       (ShaderEvalContext& c) { c.color = c.coords.swizzle(3,2,1,0); }
 122
 123 // ShaderEvaluator
 124 // Either inherit a class with overridden evaluate() or just pass in an evalFunc.
 125
 126 class ShaderEvaluator
 127 {
 128 public:
 129                         ShaderEvaluator         (void);
 130                         ShaderEvaluator         (ShaderEvalFunc evalFunc);
 131     virtual             ~ShaderEvaluator        (void);
 132
 133     virtual void        evaluate                (ShaderEvalContext& ctx);
 134
 135 private:
 136                         ShaderEvaluator         (const ShaderEvaluator&);   // not allowed!
 137     ShaderEvaluator&    operator=               (const ShaderEvaluator&);   // not allowed!
 138
 139     ShaderEvalFunc      m_evalFunc;
 140 };
 141
 142 class ShaderRenderCaseInstance;
 143
 144 typedef void (*UniformSetupFunc) (ShaderRenderCaseInstance& instance);
 145 typedef void (*AttributeSetupFunc) (ShaderRenderCaseInstance& instance, deUint32 numVertices);
 146
 147 template<typename Instance>
 148 class ShaderRenderCase : public vkt::TestCase
 149 {
 150 public:
 151                                                         ShaderRenderCase        (tcu::TestContext& testCtx,
 152                                                                                                 const std::string& name,
 153                                                                                                 const std::string& description,
 154                                                                                                 bool isVertexCase,
 155                                                                                                 ShaderEvalFunc evalFunc,
 156                                                                                                 UniformSetupFunc uniformFunc,
 157                                                                                                 AttributeSetupFunc attribFunc)
 158                                                                 : vkt::TestCase(testCtx, name, description)
 159                                                                 , m_isVertexCase(isVertexCase)
 160                                                                 , m_evaluator(new ShaderEvaluator(evalFunc))
 161                                                                 , m_uniformFunc(uniformFunc)
 162                                                                 , m_attribFunc(attribFunc)
 163                                                         {}
 164
 165                                                         ShaderRenderCase        (tcu::TestContext& testCtx,
 166                                                                                                 const std::string& name,
 167                                                                                                 const std::string& description,
 168                                                                                                 bool isVertexCase,
 169                                                                                                 ShaderEvaluator* evaluator,
 170                                                                                                 UniformSetupFunc uniformFunc,
 171                                                                                                 AttributeSetupFunc attribFunc)
 172                                                                 : vkt::TestCase(testCtx, name, description)
 173                                                                 , m_isVertexCase(isVertexCase)
 174                                                                 , m_evaluator(evaluator)
 175                                                                 , m_uniformFunc(uniformFunc)
 176                                                                 , m_attribFunc(attribFunc)
 177                                                         {}
 178
 179
 180         virtual                                 ~ShaderRenderCase       (void) {}
 181         virtual void                    initPrograms            (vk::ProgramCollection<glu::ProgramSources>& programCollection) const
 182                                                         {
 183                                                                 programCollection.add(m_name + "_vert") << glu::VertexSource(m_vertShaderSource);
 184                                                                 programCollection.add(m_name + "_frag") << glu::FragmentSource(m_fragShaderSource);
 185                                                         }
 186
 187         virtual TestInstance*   createInstance          (Context& context) const { return new Instance(context, m_name, m_isVertexCase, *m_evaluator, m_uniformFunc, m_attribFunc); }
 188
 189 protected:
 190     std::string                         m_vertShaderSource;
 191     std::string                         m_fragShaderSource;
 192
 193 private:
 194         bool                                    m_isVertexCase;
 195         ShaderEvaluator*                m_evaluator;
 196         UniformSetupFunc                m_uniformFunc;
 197         AttributeSetupFunc              m_attribFunc;
 198 };
 199
 200
 201
 202 // ShaderRenderCaseInstance.
 203
 204 class ShaderRenderCaseInstance : public vkt::TestInstance
 205 {
 206 public:
 207                                                         ShaderRenderCaseInstance        (Context& context, const std::string& name, bool isVertexCase, ShaderEvaluator& evaluator, UniformSetupFunc uniformFunc, AttributeSetupFunc attribFunc);
 208         virtual                                 ~ShaderRenderCaseInstance       (void);
 209         virtual tcu::TestStatus iterate                                         (void);
 210
 211         void                                    addAttribute                            (deUint32 bindingLocation, vk::VkFormat, deUint32 sizePerElement, deUint32 count, const void* data);
 212
 213         template<typename T>
 214         void                                    addUniform                                      (deUint32 bindingLocation, vk::VkDescriptorType descriptorType, const T data);
 215
 216 protected:
 217         virtual void                    setupShaderData                         (void);
 218         virtual void                    setup                                           (void);
 219         virtual void                    setupUniforms                           (const tcu::Vec4& constCoords);
 220
 221         tcu::IVec2                              getViewportSize                         (void) const;
 222
 223         std::vector<tcu::Mat4>  m_userAttribTransforms;
 224         tcu::Vec4                               m_clearColor;
 225
 226         vk::SimpleAllocator                             memAlloc;
 227
 228 private:
 229
 230         void                                    setupUniformData                        (deUint32 bindingLocation, deUint32 size, const void* dataPtr);
 231         void                                    setupDefaultInputs                      (const QuadGrid& quadGrid);
 232
 233         void                                    render                                          (tcu::Surface& result, const QuadGrid& quadGrid);
 234         void                                    computeVertexReference          (tcu::Surface& result, const QuadGrid& quadGrid);
 235         void                                    computeFragmentReference        (tcu::Surface& result, const QuadGrid& quadGrid);
 236         bool                                    compareImages                           (const tcu::Surface& resImage, const tcu::Surface& refImage, float errorThreshold);
 237
 238         std::string                             m_name;
 239         bool                                    m_isVertexCase;
 240         ShaderEvaluator&                m_evaluator;
 241         UniformSetupFunc                m_uniformFunc;
 242         AttributeSetupFunc              m_attribFunc;
 243
 244         const tcu::IVec2                m_renderSize;
 245         const vk::VkFormat              m_colorFormat;
 246
 247         vk::Move<vk::VkImage>                           m_colorImage;
 248         de::MovePtr<vk::Allocation>                     m_colorImageAlloc;
 249         vk::Move<vk::VkAttachmentView>          m_colorAttachmentView;
 250
 251         vk::Move<vk::VkRenderPass>                      m_renderPass;
 252         vk::Move<vk::VkFramebuffer>                     m_framebuffer;
 253         vk::Move<vk::VkPipelineLayout>          m_pipelineLayout;
 254         vk::Move<vk::VkPipeline>                        m_graphicsPipeline;
 255
 256         vk::Move<vk::VkShaderModule>            m_vertexShaderModule;
 257         vk::Move<vk::VkShaderModule>            m_fragmentShaderModule;
 258         vk::Move<vk::VkShader>                          m_vertexShader;
 259         vk::Move<vk::VkShader>                          m_fragmentShader;
 260
 261         vk::Move<vk::VkDynamicViewportState>            m_viewportState;
 262         vk::Move<vk::VkDynamicRasterState>                      m_rasterState;
 263         vk::Move<vk::VkDynamicColorBlendState>          m_colorBlendState;
 264
 265         vk::Move<vk::VkBuffer>                                          m_vertexBuffer;
 266         de::MovePtr<vk::Allocation>                             m_vertexBufferAlloc;
 267
 268         vk::Move<vk::VkBuffer>                                          m_indiceBuffer;
 269         de::MovePtr<vk::Allocation>                             m_indiceBufferAlloc;
 270
 271         vk::Move<vk::VkDescriptorSetLayout>             m_descriptorSetLayout;
 272
 273         vk::Move<vk::VkDescriptorPool>          m_descriptorPool;
 274         vk::Move<vk::VkDescriptorSet>           m_descriptorSet;
 275
 276         vk::Move<vk::VkCmdPool>                                         m_cmdPool;
 277         vk::Move<vk::VkCmdBuffer>                                       m_cmdBuffer;
 278
 279         vk::Move<vk::VkFence>                           m_fence;
 280
 281         vk::DescriptorSetLayoutBuilder                  m_descriptorSetLayoutBuilder;
 282         vk::DescriptorPoolBuilder                               m_descriptorPoolBuilder;
 283         vk::DescriptorSetUpdateBuilder                  m_descriptorSetUpdateBuilder;
 284
 285         struct UniformInfo
 286         {
 287                 vk::VkBuffer                            buffer;
 288                 vk::Allocation*                         alloc;
 289                 vk::VkBufferView                        view;
 290                 vk::VkDescriptorInfo            descriptor;
 291                 deUint32                                        location;
 292         };
 293         std::vector<UniformInfo>                m_uniformInfos;
 294
 295         std::vector<vk::VkVertexInputBindingDescription>        m_vertexBindingDescription;
 296         std::vector<vk::VkVertexInputAttributeDescription>      m_vertexattributeDescription;
 297         std::vector<vk::VkBuffer>                                                       m_vertexBuffers;
 298         std::vector<vk::Allocation*>                                            m_vertexBufferAllocs;
 299 };
 300
 301 template<typename T>
 302 void ShaderRenderCaseInstance::addUniform (deUint32 bindingLocation, vk::VkDescriptorType descriptorType, const T data)
 303 {
 304         m_descriptorSetLayoutBuilder.addSingleBinding(descriptorType, vk::VK_SHADER_STAGE_VERTEX_BIT);
 305         m_descriptorPoolBuilder.addType(descriptorType);
 306
 307         setupUniformData(bindingLocation, sizeof(T), &data);
 308 }
 309
 310
 311
 312 } // shaderrendercase
 313 } // vkt
 314
 315 #endif // _VKTSHADERRENDERCASE_HPP