external/vulkancts/modules/vulkan/pipeline/vktPipelineReferenceRenderer.hpp

   1 #ifndef _VKTPIPELINEREFERENCERENDERER_HPP
   2 #define _VKTPIPELINEREFERENCERENDERER_HPP
   3 /*------------------------------------------------------------------------
   4  * Vulkan Conformance Tests
   5  * ------------------------
   6  *
   7  * Copyright (c) 2015 The Khronos Group Inc.
   8  * Copyright (c) 2015 Imagination Technologies Ltd.
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *      http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  *//*!
  23  * \file
  24  * \brief Reference renderer.
  25  *//*--------------------------------------------------------------------*/
  26
  27 #include "vkDefs.hpp"
  28 #include "vktPipelineVertexUtil.hpp"
  29 #include "tcuVector.hpp"
  30 #include "tcuVectorType.hpp"
  31 #include "tcuTexture.hpp"
  32 #include "tcuTextureUtil.hpp"
  33 #include "rrRenderState.hpp"
  34 #include "rrRenderer.hpp"
  35 #include <cstring>
  36
  37 namespace vkt
  38 {
  39
  40 namespace pipeline
  41 {
  42
  43 tcu::Vec4       swizzle         (const tcu::Vec4& color, const tcu::UVec4& swizzle);
  44
  45 class ColorVertexShader : public rr::VertexShader
  46 {
  47 public:
  48         ColorVertexShader (void) : rr::VertexShader(2, 2)
  49         {
  50                 m_inputs[0].type        = rr::GENERICVECTYPE_FLOAT;
  51                 m_inputs[1].type        = rr::GENERICVECTYPE_FLOAT;
  52
  53                 m_outputs[0].type       = rr::GENERICVECTYPE_FLOAT;
  54                 m_outputs[1].type       = rr::GENERICVECTYPE_FLOAT;
  55         }
  56
  57         virtual ~ColorVertexShader (void) {}
  58
  59         virtual void shadeVertices (const rr::VertexAttrib*             inputs,
  60                                                                 rr::VertexPacket* const*        packets,
  61                                                                 const int                                       numPackets) const
  62         {
  63                 tcu::Vec4 position;
  64                 tcu::Vec4 color;
  65
  66                 for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
  67                 {
  68                         rr::VertexPacket* const packet  = packets[packetNdx];
  69
  70                         readVertexAttrib(position, inputs[0], packet->instanceNdx, packet->vertexNdx);
  71                         readVertexAttrib(color, inputs[1], packet->instanceNdx, packet->vertexNdx);
  72
  73                         packet->outputs[0]      = position;
  74                         packet->outputs[1]      = color;
  75                         packet->position        = position;
  76                 }
  77         }
  78 };
  79
  80 class TexCoordVertexShader : public rr::VertexShader
  81 {
  82 public:
  83         TexCoordVertexShader (void) : rr::VertexShader(2, 2)
  84         {
  85                 m_inputs[0].type        = rr::GENERICVECTYPE_FLOAT;
  86                 m_inputs[1].type        = rr::GENERICVECTYPE_FLOAT;
  87
  88                 m_outputs[0].type       = rr::GENERICVECTYPE_FLOAT;
  89                 m_outputs[1].type       = rr::GENERICVECTYPE_FLOAT;
  90         }
  91
  92         virtual ~TexCoordVertexShader (void) {}
  93
  94         virtual void shadeVertices (const rr::VertexAttrib*             inputs,
  95                                                                 rr::VertexPacket* const*        packets,
  96                                                                 const int                                       numPackets) const
  97         {
  98                 tcu::Vec4 position;
  99                 tcu::Vec4 texCoord;
 100
 101                 for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
 102                 {
 103                         rr::VertexPacket* const packet  = packets[packetNdx];
 104
 105                         readVertexAttrib(position, inputs[0], packet->instanceNdx, packet->vertexNdx);
 106                         readVertexAttrib(texCoord, inputs[1], packet->instanceNdx, packet->vertexNdx);
 107
 108                         packet->outputs[0]      = position;
 109                         packet->outputs[1]      = texCoord;
 110                         packet->position        = position;
 111                 }
 112         }
 113 };
 114
 115 class ColorFragmentShader : public rr::FragmentShader
 116 {
 117 private:
 118         const tcu::TextureFormat                m_colorFormat;
 119         const tcu::TextureFormat                m_depthStencilFormat;
 120
 121 public:
 122         ColorFragmentShader (const tcu::TextureFormat& colorFormat,
 123                                                  const tcu::TextureFormat& depthStencilFormat)
 124                 : rr::FragmentShader    (2, 1)
 125                 , m_colorFormat                 (colorFormat)
 126                 , m_depthStencilFormat  (depthStencilFormat)
 127         {
 128                 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(m_colorFormat.type);
 129
 130                 m_inputs[0].type        = rr::GENERICVECTYPE_FLOAT;
 131                 m_inputs[1].type        = rr::GENERICVECTYPE_FLOAT;
 132                 m_outputs[0].type       = (channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER)? rr::GENERICVECTYPE_INT32 :
 133                                                           (channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER)? rr::GENERICVECTYPE_UINT32
 134                                                           : rr::GENERICVECTYPE_FLOAT;
 135         }
 136
 137         virtual ~ColorFragmentShader (void) {}
 138
 139         virtual void shadeFragments (rr::FragmentPacket*                                packets,
 140                                                                  const int                                                      numPackets,
 141                                                                  const rr::FragmentShadingContext&      context) const
 142         {
 143                 for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
 144                 {
 145                         const rr::FragmentPacket& packet = packets[packetNdx];
 146
 147                         if (m_depthStencilFormat.order == tcu::TextureFormat::D || m_depthStencilFormat.order == tcu::TextureFormat::DS)
 148                         {
 149                                 for (int fragNdx = 0; fragNdx < 4; fragNdx++)
 150                                 {
 151                                         const tcu::Vec4 vtxPosition = rr::readVarying<float>(packet, context, 0, fragNdx);
 152                                         rr::writeFragmentDepth(context, packetNdx, fragNdx, 0, vtxPosition.z());
 153                                 }
 154                         }
 155
 156                         for (int fragNdx = 0; fragNdx < 4; fragNdx++)
 157                         {
 158                                 const tcu::Vec4 vtxColor = rr::readVarying<float>(packet, context, 1, fragNdx);
 159                                 rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, vtxColor);
 160                         }
 161                 }
 162         }
 163 };
 164
 165 template<typename TextureType>
 166 class SamplerFragmentShader : public rr::FragmentShader
 167 {
 168 private:
 169         const tcu::TextureFormat                m_colorFormat;
 170         const tcu::TextureFormatInfo    m_colorFormatInfo;
 171         const TextureType                               m_texture;
 172         const tcu::Sampler                              m_sampler;
 173         const float                                             m_lod;
 174         const tcu::Vec4                                 m_lookupScale;
 175         const tcu::Vec4                                 m_lookupBias;
 176         const tcu::UVec4                                m_swizzle;
 177
 178 public:
 179         SamplerFragmentShader (const tcu::TextureFormat& colorFormat, const TextureType& texture, const tcu::Sampler& sampler, float lod, const tcu::Vec4& lookupScale, const tcu::Vec4& lookupBias, const tcu::UVec4& swizzle)
 180                 : rr::FragmentShader    (2, 1)
 181                 , m_colorFormat                 (colorFormat)
 182                 , m_colorFormatInfo             (tcu::getTextureFormatInfo(m_colorFormat))
 183                 , m_texture                             (texture)
 184                 , m_sampler                             (sampler)
 185                 , m_lod                                 (lod)
 186                 , m_lookupScale                 (lookupScale)
 187                 , m_lookupBias                  (lookupBias)
 188                 , m_swizzle                             (swizzle)
 189         {
 190                 const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(m_colorFormat.type);
 191                 m_inputs[0].type        = rr::GENERICVECTYPE_FLOAT;
 192                 m_inputs[1].type        = rr::GENERICVECTYPE_FLOAT;
 193                 m_outputs[0].type       = (channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER)? rr::GENERICVECTYPE_INT32 :
 194                                                           (channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER)? rr::GENERICVECTYPE_UINT32
 195                                                           : rr::GENERICVECTYPE_FLOAT;
 196         }
 197
 198         virtual ~SamplerFragmentShader (void)
 199         {
 200         }
 201
 202         static tcu::Vec4 sampleTexture (const tcu::Texture1D& texture, const tcu::Sampler& sampler, const tcu::Vec4& texCoord, float lod)
 203         {
 204                 return texture.sample(sampler, texCoord.x(), lod);
 205         }
 206
 207         static tcu::Vec4 sampleTexture (const tcu::Texture1DArray& texture, const tcu::Sampler& sampler, const tcu::Vec4& texCoord, float lod)
 208         {
 209                 return texture.sample(sampler, texCoord.x(), texCoord.y(), lod);
 210         }
 211
 212         static tcu::Vec4 sampleTexture (const tcu::Texture2D& texture, const tcu::Sampler& sampler, const tcu::Vec4& texCoord, float lod)
 213         {
 214                 return texture.sample(sampler, texCoord.x(), texCoord.y(), lod);
 215         }
 216
 217         static tcu::Vec4 sampleTexture (const tcu::Texture2DArray& texture, const tcu::Sampler& sampler, const tcu::Vec4& texCoord, float lod)
 218         {
 219                 return texture.sample(sampler, texCoord.x(), texCoord.y(), texCoord.z(), lod);
 220         }
 221
 222         static tcu::Vec4 sampleTexture (const tcu::Texture3D& texture, const tcu::Sampler& sampler, const tcu::Vec4& texCoord, float lod)
 223         {
 224                 return texture.sample(sampler, texCoord.x(), texCoord.y(), texCoord.z(), lod);
 225         }
 226
 227         static tcu::Vec4 sampleTexture (const tcu::TextureCube& texture, const tcu::Sampler& sampler, const tcu::Vec4& texCoord, float lod)
 228         {
 229                 return texture.sample(sampler, texCoord.x(), texCoord.y(), texCoord.z(), lod);
 230         }
 231
 232         static tcu::Vec4 sampleTexture (const tcu::TextureCubeArray& texture, const tcu::Sampler& sampler, const tcu::Vec4& texCoord, float lod)
 233         {
 234                 return texture.sample(sampler, texCoord.x(), texCoord.y(), texCoord.z(), texCoord.w(), lod);
 235         }
 236
 237         virtual void shadeFragments (rr::FragmentPacket*                                packets,
 238                                                                  const int                                                      numPackets,
 239                                                                  const rr::FragmentShadingContext&      context) const
 240         {
 241                 for (int packetNdx = 0; packetNdx < numPackets; packetNdx++)
 242                 {
 243                         const rr::FragmentPacket& packet = packets[packetNdx];
 244
 245                         for (int fragNdx = 0; fragNdx < 4; fragNdx++)
 246                         {
 247                                 const tcu::Vec4 vtxTexCoord     = rr::readVarying<float>(packet, context, 1, fragNdx);
 248                                 const tcu::Vec4 texColor        = sampleTexture(m_texture, m_sampler, vtxTexCoord, m_lod);
 249                                 const tcu::Vec4 normColor       = texColor * m_lookupScale + m_lookupBias;
 250                                 const tcu::Vec4 swizColor       = swizzle(normColor, m_swizzle);
 251                                 const tcu::Vec4 color           = (swizColor + m_colorFormatInfo.lookupBias) / m_colorFormatInfo.lookupScale;
 252                                 rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
 253                         }
 254                 }
 255         }
 256 };
 257
 258 class Program
 259 {
 260 public:
 261         virtual ~Program (void) { }
 262
 263         virtual rr::Program getReferenceProgram (void) const = 0;
 264 };
 265
 266 template<typename TextureType>
 267 class SamplerProgram: public Program
 268 {
 269 private:
 270         TexCoordVertexShader                            m_vertexShader;
 271         SamplerFragmentShader<TextureType>      m_fragmentShader;
 272 public:
 273         SamplerProgram (const tcu::TextureFormat& colorFormat, const TextureType& texture, const tcu::Sampler& sampler, float lod, const tcu::Vec4& lookupScale, const tcu::Vec4& lookupBias, const tcu::UVec4& swizzle)
 274                 : m_vertexShader        ()
 275                 , m_fragmentShader      (colorFormat, texture, sampler, lod, lookupScale, lookupBias, swizzle)
 276         {
 277         }
 278
 279         virtual ~SamplerProgram (void) { }
 280
 281         virtual rr::Program getReferenceProgram (void) const
 282         {
 283                 return rr::Program(&m_vertexShader, &m_fragmentShader);
 284         }
 285 };
 286
 287 class ReferenceRenderer
 288 {
 289 public:
 290                                                                 ReferenceRenderer               (int                                                    surfaceWidth,
 291                                                                                                                  int                                                    surfaceHeight,
 292                                                                                                                  int                                                    numSamples,
 293                                                                                                                  const tcu::TextureFormat&              colorFormat,
 294                                                                                                                  const tcu::TextureFormat&              depthStencilFormat,
 295                                                                                                                  const rr::Program* const               program);
 296
 297         virtual                                         ~ReferenceRenderer              (void);
 298
 299         void                                            colorClear                              (const tcu::Vec4& color);
 300
 301         void                                            draw                                    (const rr::RenderState&                         renderState,
 302                                                                                                                  const rr::PrimitiveType                        primitive,
 303                                                                                                                  const std::vector<Vertex4RGBA>&        vertexBuffer);
 304
 305         void                                            draw                                    (const rr::RenderState&                         renderState,
 306                                                                                                                  const rr::PrimitiveType                        primitive,
 307                                                                                                                  const std::vector<Vertex4Tex4>&        vertexBuffer);
 308
 309         tcu::PixelBufferAccess          getAccess                               (void);
 310         const rr::ViewportState         getViewportState                (void) const;
 311
 312 private:
 313         rr::Renderer                            m_renderer;
 314
 315         const int                                       m_surfaceWidth;
 316         const int                                       m_surfaceHeight;
 317         const int                                       m_numSamples;
 318
 319         const tcu::TextureFormat        m_colorFormat;
 320         const tcu::TextureFormat        m_depthStencilFormat;
 321
 322         tcu::TextureLevel                       m_colorBuffer;
 323         tcu::TextureLevel                       m_resolveColorBuffer;
 324         tcu::TextureLevel                       m_depthStencilBuffer;
 325
 326         rr::RenderTarget*                       m_renderTarget;
 327         const rr::Program*                      m_program;
 328 };
 329
 330 rr::TestFunc                                    mapVkCompareOp                          (vk::VkCompareOp compareFunc);
 331 rr::PrimitiveType                               mapVkPrimitiveTopology          (vk::VkPrimitiveTopology primitiveTopology);
 332 rr::BlendFunc                                   mapVkBlendFactor                        (vk::VkBlendFactor blendFactor);
 333 rr::BlendEquation                               mapVkBlendOp                            (vk::VkBlendOp blendOp);
 334 tcu::BVec4                                              mapVkColorComponentFlags        (vk::VkColorComponentFlags flags);
 335 rr::StencilOp                                   mapVkStencilOp                          (vk::VkStencilOp stencilOp);
 336
 337 } // pipeline
 338 } // vkt
 339
 340 #endif // _VKTPIPELINEREFERENCERENDERER_HPP