external/vulkancts/modules/vulkan/shaderrender/vktShaderRenderDiscardTests.cpp

   1 /*------------------------------------------------------------------------
   2  * Vulkan Conformance Tests
   3  * ------------------------
   4  *
   5  * Copyright (c) 2015 The Khronos Group Inc.
   6  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   7  * Copyright (c) 2016 The Android Open Source Project
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*!
  22  * \file
  23  * \brief Shader discard statement tests.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "vktShaderRenderDiscardTests.hpp"
  27 #include "vktShaderRender.hpp"
  28 #include "tcuStringTemplate.hpp"
  29 #include "gluTexture.hpp"
  30
  31 #include <string>
  32
  33 using tcu::StringTemplate;
  34
  35 namespace vkt
  36 {
  37 namespace sr
  38 {
  39 namespace
  40 {
  41
  42 class SamplerUniformSetup : public UniformSetup
  43 {
  44 public:
  45                                                 SamplerUniformSetup                     (bool useSampler)
  46                                                         : m_useSampler(useSampler)
  47                                                 {}
  48
  49         virtual void            setup                                            (ShaderRenderCaseInstance& instance, const tcu::Vec4&) const
  50                                                 {
  51                                                         instance.useUniform(0u, UI_ONE);
  52                                                         instance.useUniform(1u, UI_TWO);
  53                                                         if (m_useSampler)
  54                                                                 instance.useSampler(2u, 0u); // To the uniform binding location 2 bind the texture 0
  55                                                 }
  56
  57 private:
  58         const bool                      m_useSampler;
  59 };
  60
  61
  62 class ShaderDiscardCaseInstance : public ShaderRenderCaseInstance
  63 {
  64 public:
  65                                                 ShaderDiscardCaseInstance       (Context&                               context,
  66                                                                                                         bool                                    isVertexCase,
  67                                                                                                         const ShaderEvaluator&  evaluator,
  68                                                                                                         const UniformSetup&             uniformSetup,
  69                                                                                                         bool                                    usesTexture);
  70         virtual                         ~ShaderDiscardCaseInstance      (void);
  71 };
  72
  73 ShaderDiscardCaseInstance::ShaderDiscardCaseInstance (Context&                                  context,
  74                                                                                                          bool                                           isVertexCase,
  75                                                                                                          const ShaderEvaluator&         evaluator,
  76                                                                                                          const UniformSetup&            uniformSetup,
  77                                                                                                          bool                                           usesTexture)
  78         : ShaderRenderCaseInstance      (context, isVertexCase, evaluator, uniformSetup, DE_NULL)
  79 {
  80         if (usesTexture)
  81         {
  82                 de::SharedPtr<TextureBinding> brickTexture(new TextureBinding(m_context.getTestContext().getArchive(),
  83                                                                                                                                           "vulkan/data/brick.png",
  84                                                                                                                                           TextureBinding::TYPE_2D,
  85                                                                                                                                           tcu::Sampler(tcu::Sampler::CLAMP_TO_EDGE,
  86                                                                                                                                                                         tcu::Sampler::CLAMP_TO_EDGE,
  87                                                                                                                                                                         tcu::Sampler::CLAMP_TO_EDGE,
  88                                                                                                                                                                         tcu::Sampler::LINEAR,
  89                                                                                                                                                                         tcu::Sampler::LINEAR)));
  90                 m_textures.push_back(brickTexture);
  91         }
  92 }
  93
  94 ShaderDiscardCaseInstance::~ShaderDiscardCaseInstance (void)
  95 {
  96 }
  97
  98 class ShaderDiscardCase : public ShaderRenderCase
  99 {
 100 public:
 101                                                         ShaderDiscardCase                       (tcu::TestContext&              testCtx,
 102                                                                                                                  const char*                    name,
 103                                                                                                                  const char*                    description,
 104                                                                                                                  const char*                    shaderSource,
 105                                                                                                                  const ShaderEvalFunc   evalFunc,
 106                                                                                                                  bool                                   usesTexture);
 107         virtual TestInstance*   createInstance                          (Context& context) const
 108                                                         {
 109                                                                 DE_ASSERT(m_evaluator != DE_NULL);
 110                                                                 DE_ASSERT(m_uniformSetup != DE_NULL);
 111                                                                 return new ShaderDiscardCaseInstance(context, m_isVertexCase, *m_evaluator, *m_uniformSetup, m_usesTexture);
 112                                                         }
 113
 114 private:
 115         const bool                              m_usesTexture;
 116 };
 117
 118 ShaderDiscardCase::ShaderDiscardCase (tcu::TestContext&         testCtx,
 119                                                                           const char*                   name,
 120                                                                           const char*                   description,
 121                                                                           const char*                   shaderSource,
 122                                                                           const ShaderEvalFunc  evalFunc,
 123                                                                           bool                                  usesTexture)
 124         : ShaderRenderCase      (testCtx, name, description, false, evalFunc, new SamplerUniformSetup(usesTexture), DE_NULL)
 125         , m_usesTexture         (usesTexture)
 126 {
 127         m_fragShaderSource      = shaderSource;
 128         m_vertShaderSource      =
 129                 "#version 310 es\n"
 130                 "layout(location=0) in  highp   vec4 a_position;\n"
 131                 "layout(location=1) in  highp   vec4 a_coords;\n"
 132                 "layout(location=0) out mediump vec4 v_color;\n"
 133                 "layout(location=1) out mediump vec4 v_coords;\n\n"
 134                 "void main (void)\n"
 135                 "{\n"
 136                 "    gl_Position = a_position;\n"
 137                 "    v_color = vec4(a_coords.xyz, 1.0);\n"
 138                 "    v_coords = a_coords;\n"
 139                 "}\n";
 140 }
 141
 142
 143 enum DiscardMode
 144 {
 145         DISCARDMODE_ALWAYS = 0,
 146         DISCARDMODE_NEVER,
 147         DISCARDMODE_UNIFORM,
 148         DISCARDMODE_DYNAMIC,
 149         DISCARDMODE_TEXTURE,
 150
 151         DISCARDMODE_LAST
 152 };
 153
 154 enum DiscardTemplate
 155 {
 156         DISCARDTEMPLATE_MAIN_BASIC = 0,
 157         DISCARDTEMPLATE_FUNCTION_BASIC,
 158         DISCARDTEMPLATE_MAIN_STATIC_LOOP,
 159         DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP,
 160         DISCARDTEMPLATE_FUNCTION_STATIC_LOOP,
 161
 162         DISCARDTEMPLATE_LAST
 163 };
 164
 165 // Evaluation functions
 166 inline void evalDiscardAlways   (ShaderEvalContext& c) { c.discard(); }
 167 inline void evalDiscardNever    (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); }
 168 inline void evalDiscardDynamic  (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); if (c.coords.x()+c.coords.y() > 0.0f) c.discard(); }
 169
 170 inline void evalDiscardTexture (ShaderEvalContext& c)
 171 {
 172         c.color.xyz() = c.coords.swizzle(0,1,2);
 173         if (c.texture2D(0, c.coords.swizzle(0,1) * 0.25f + 0.5f).x() < 0.7f)
 174                 c.discard();
 175 }
 176
 177 static ShaderEvalFunc getEvalFunc (DiscardMode mode)
 178 {
 179         switch (mode)
 180         {
 181                 case DISCARDMODE_ALWAYS:        return evalDiscardAlways;
 182                 case DISCARDMODE_NEVER:         return evalDiscardNever;
 183                 case DISCARDMODE_UNIFORM:       return evalDiscardAlways;
 184                 case DISCARDMODE_DYNAMIC:       return evalDiscardDynamic;
 185                 case DISCARDMODE_TEXTURE:       return evalDiscardTexture;
 186                 default:
 187                         DE_ASSERT(DE_FALSE);
 188                         return evalDiscardAlways;
 189         }
 190 }
 191
 192 static const char* getTemplate (DiscardTemplate variant)
 193 {
 194         #define GLSL_SHADER_TEMPLATE_HEADER \
 195                                 "#version 310 es\n"     \
 196                                 "layout(location = 0) in mediump vec4 v_color;\n"       \
 197                                 "layout(location = 1) in mediump vec4 v_coords;\n"      \
 198                                 "layout(location = 0) out mediump vec4 o_color;\n"      \
 199                                 "layout(set = 0, binding = 2) uniform sampler2D    ut_brick;\n" \
 200                                 "layout(set = 0, binding = 0) uniform block0 { mediump int  ui_one; };\n\n"
 201
 202         switch (variant)
 203         {
 204                 case DISCARDTEMPLATE_MAIN_BASIC:
 205                         return GLSL_SHADER_TEMPLATE_HEADER
 206                                    "void main (void)\n"
 207                                    "{\n"
 208                                    "    o_color = v_color;\n"
 209                                    "    ${DISCARD};\n"
 210                                    "}\n";
 211
 212                 case DISCARDTEMPLATE_FUNCTION_BASIC:
 213                         return GLSL_SHADER_TEMPLATE_HEADER
 214                                    "void myfunc (void)\n"
 215                                    "{\n"
 216                                    "    ${DISCARD};\n"
 217                                    "}\n\n"
 218                                    "void main (void)\n"
 219                                    "{\n"
 220                                    "    o_color = v_color;\n"
 221                                    "    myfunc();\n"
 222                                    "}\n";
 223
 224                 case DISCARDTEMPLATE_MAIN_STATIC_LOOP:
 225                         return GLSL_SHADER_TEMPLATE_HEADER
 226                                    "void main (void)\n"
 227                                    "{\n"
 228                                    "    o_color = v_color;\n"
 229                                    "    for (int i = 0; i < 2; i++)\n"
 230                                    "    {\n"
 231                                    "        if (i > 0)\n"
 232                                    "            ${DISCARD};\n"
 233                                    "    }\n"
 234                                    "}\n";
 235
 236                 case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP:
 237                         return GLSL_SHADER_TEMPLATE_HEADER
 238                                    "layout(set = 0, binding = 1) uniform block1 { mediump int  ui_two; };\n\n"
 239                                    "void main (void)\n"
 240                                    "{\n"
 241                                    "    o_color = v_color;\n"
 242                                    "    for (int i = 0; i < ui_two; i++)\n"
 243                                    "    {\n"
 244                                    "        if (i > 0)\n"
 245                                    "            ${DISCARD};\n"
 246                                    "    }\n"
 247                                    "}\n";
 248
 249                 case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP:
 250                         return GLSL_SHADER_TEMPLATE_HEADER
 251                                    "void myfunc (void)\n"
 252                                    "{\n"
 253                                    "    for (int i = 0; i < 2; i++)\n"
 254                                    "    {\n"
 255                                    "        if (i > 0)\n"
 256                                    "            ${DISCARD};\n"
 257                                    "    }\n"
 258                                    "}\n\n"
 259                                    "void main (void)\n"
 260                                    "{\n"
 261                                    "    o_color = v_color;\n"
 262                                    "    myfunc();\n"
 263                                    "}\n";
 264
 265                 default:
 266                         DE_ASSERT(DE_FALSE);
 267                         return DE_NULL;
 268         }
 269
 270         #undef GLSL_SHADER_TEMPLATE_HEADER
 271 }
 272
 273 static const char* getTemplateName (DiscardTemplate variant)
 274 {
 275         switch (variant)
 276         {
 277                 case DISCARDTEMPLATE_MAIN_BASIC:                        return "basic";
 278                 case DISCARDTEMPLATE_FUNCTION_BASIC:            return "function";
 279                 case DISCARDTEMPLATE_MAIN_STATIC_LOOP:          return "static_loop";
 280                 case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP:         return "dynamic_loop";
 281                 case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP:      return "function_static_loop";
 282                 default:
 283                         DE_ASSERT(DE_FALSE);
 284                         return DE_NULL;
 285         }
 286 }
 287
 288 static const char* getModeName (DiscardMode mode)
 289 {
 290         switch (mode)
 291         {
 292                 case DISCARDMODE_ALWAYS:        return "always";
 293                 case DISCARDMODE_NEVER:         return "never";
 294                 case DISCARDMODE_UNIFORM:       return "uniform";
 295                 case DISCARDMODE_DYNAMIC:       return "dynamic";
 296                 case DISCARDMODE_TEXTURE:       return "texture";
 297                 default:
 298                         DE_ASSERT(DE_FALSE);
 299                         return DE_NULL;
 300         }
 301 }
 302
 303 static const char* getTemplateDesc (DiscardTemplate variant)
 304 {
 305         switch (variant)
 306         {
 307                 case DISCARDTEMPLATE_MAIN_BASIC:                        return "main";
 308                 case DISCARDTEMPLATE_FUNCTION_BASIC:            return "function";
 309                 case DISCARDTEMPLATE_MAIN_STATIC_LOOP:          return "static loop";
 310                 case DISCARDTEMPLATE_MAIN_DYNAMIC_LOOP:         return "dynamic loop";
 311                 case DISCARDTEMPLATE_FUNCTION_STATIC_LOOP:      return "static loop in function";
 312                 default:
 313                         DE_ASSERT(DE_FALSE);
 314                         return DE_NULL;
 315         }
 316 }
 317
 318 static const char* getModeDesc (DiscardMode mode)
 319 {
 320         switch (mode)
 321         {
 322                 case DISCARDMODE_ALWAYS:        return "Always discard";
 323                 case DISCARDMODE_NEVER:         return "Never discard";
 324                 case DISCARDMODE_UNIFORM:       return "Discard based on uniform value";
 325                 case DISCARDMODE_DYNAMIC:       return "Discard based on varying values";
 326                 case DISCARDMODE_TEXTURE:       return "Discard based on texture value";
 327                 default:
 328                         DE_ASSERT(DE_FALSE);
 329                         return DE_NULL;
 330         }
 331 }
 332
 333 de::MovePtr<ShaderDiscardCase> makeDiscardCase (tcu::TestContext& testCtx, DiscardTemplate tmpl, DiscardMode mode)
 334 {
 335         StringTemplate shaderTemplate(getTemplate(tmpl));
 336
 337         std::map<std::string, std::string> params;
 338
 339         switch (mode)
 340         {
 341                 case DISCARDMODE_ALWAYS:        params["DISCARD"] = "discard";                                                                          break;
 342                 case DISCARDMODE_NEVER:         params["DISCARD"] = "if (false) discard";                                                       break;
 343                 case DISCARDMODE_UNIFORM:       params["DISCARD"] = "if (ui_one > 0) discard";                                          break;
 344                 case DISCARDMODE_DYNAMIC:       params["DISCARD"] = "if (v_coords.x+v_coords.y > 0.0) discard";         break;
 345                 case DISCARDMODE_TEXTURE:       params["DISCARD"] = "if (texture(ut_brick, v_coords.xy*0.25+0.5).x < 0.7) discard";     break;
 346                 default:
 347                         DE_ASSERT(DE_FALSE);
 348                         break;
 349         }
 350
 351         std::string name                = std::string(getTemplateName(tmpl)) + "_" + getModeName(mode);
 352         std::string description = std::string(getModeDesc(mode)) + " in " + getTemplateDesc(tmpl);
 353
 354         return de::MovePtr<ShaderDiscardCase>(new ShaderDiscardCase(testCtx, name.c_str(), description.c_str(), shaderTemplate.specialize(params).c_str(), getEvalFunc(mode), mode == DISCARDMODE_TEXTURE));
 355 }
 356
 357 class ShaderDiscardTests : public tcu::TestCaseGroup
 358 {
 359 public:
 360                                                         ShaderDiscardTests              (tcu::TestContext& textCtx);
 361         virtual                                 ~ShaderDiscardTests             (void);
 362
 363         virtual void                    init                                    (void);
 364
 365 private:
 366                                                         ShaderDiscardTests              (const ShaderDiscardTests&);            // not allowed!
 367         ShaderDiscardTests&             operator=                               (const ShaderDiscardTests&);            // not allowed!
 368 };
 369
 370 ShaderDiscardTests::ShaderDiscardTests (tcu::TestContext& testCtx)
 371         : TestCaseGroup(testCtx, "discard", "Discard statement tests")
 372 {
 373 }
 374
 375 ShaderDiscardTests::~ShaderDiscardTests (void)
 376 {
 377 }
 378
 379 void ShaderDiscardTests::init (void)
 380 {
 381         for (int tmpl = 0; tmpl < DISCARDTEMPLATE_LAST; tmpl++)
 382                 for (int mode = 0; mode < DISCARDMODE_LAST; mode++)
 383                         addChild(makeDiscardCase(m_testCtx, (DiscardTemplate)tmpl, (DiscardMode)mode).release());
 384 }
 385
 386 } // anonymous
 387
 388 tcu::TestCaseGroup* createDiscardTests (tcu::TestContext& testCtx)
 389 {
 390         return new ShaderDiscardTests(testCtx);
 391 }
 392
 393 } // sr
 394 } // vkt