modules/glshared/glsShaderRenderCase.hpp

   1 #ifndef _GLSSHADERRENDERCASE_HPP
   2 #define _GLSSHADERRENDERCASE_HPP
   3 /*-------------------------------------------------------------------------
   4  * drawElements Quality Program OpenGL (ES) Module
   5  * -----------------------------------------------
   6  *
   7  * Copyright 2014 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 execute test.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "tcuDefs.hpp"
  27 #include "tcuTestCase.hpp"
  28 #include "tcuVector.hpp"
  29 #include "tcuMatrix.hpp"
  30 #include "tcuTexture.hpp"
  31 #include "tcuSurface.hpp"
  32 #include "gluRenderContext.hpp"
  33 #include "gluContextInfo.hpp"
  34 #include "gluShaderProgram.hpp"
  35
  36 #include <sstream>
  37 #include <string>
  38
  39 namespace glu
  40 {
  41 class RenderContext;
  42 class Texture2D;
  43 class TextureCube;
  44 class Texture2DArray;
  45 class Texture3D;
  46 } // glu
  47
  48 namespace deqp
  49 {
  50 namespace gls
  51 {
  52
  53 // LineStream \todo [2011-10-17 pyry] Move to proper place!
  54
  55 class LineStream
  56 {
  57 public:
  58                                                 LineStream              (int indent = 0)        { m_indent = indent; }
  59                                                 ~LineStream             (void)                          {}
  60
  61         const char*                     str                             (void) const            { m_string = m_stream.str(); return m_string.c_str(); }
  62         LineStream&                     operator<<              (const char* line)      { for (int i = 0; i < m_indent; i++) { m_stream << "\t"; } m_stream << line << "\n"; return *this; }
  63
  64 private:
  65         int                                     m_indent;
  66         std::ostringstream      m_stream;
  67         mutable std::string     m_string;
  68 };
  69
  70 class QuadGrid;
  71
  72 // TextureBinding
  73
  74 class TextureBinding
  75 {
  76 public:
  77         enum Type
  78         {
  79                 TYPE_NONE = 0,
  80                 TYPE_2D,
  81                 TYPE_CUBE_MAP,
  82                 TYPE_2D_ARRAY,
  83                 TYPE_3D,
  84
  85                 TYPE_LAST
  86         };
  87
  88                                                                 TextureBinding          (const glu::Texture2D* tex2D, const tcu::Sampler& sampler);
  89                                                                 TextureBinding          (const glu::TextureCube* texCube, const tcu::Sampler& sampler);
  90                                                                 TextureBinding          (const glu::Texture2DArray* tex2DArray, const tcu::Sampler& sampler);
  91                                                                 TextureBinding          (const glu::Texture3D* tex3D, const tcu::Sampler& sampler);
  92                                                                 TextureBinding          (void);
  93
  94         void                                            setSampler                      (const tcu::Sampler& sampler);
  95         void                                            setTexture                      (const glu::Texture2D* tex2D);
  96         void                                            setTexture                      (const glu::TextureCube* texCube);
  97         void                                            setTexture                      (const glu::Texture2DArray* tex2DArray);
  98         void                                            setTexture                      (const glu::Texture3D* tex3D);
  99
 100         Type                                            getType                         (void) const { return m_type;           }
 101         const tcu::Sampler&                     getSampler                      (void) const { return m_sampler;        }
 102         const glu::Texture2D*           get2D                           (void) const { DE_ASSERT(getType() == TYPE_2D);                 return m_binding.tex2D;         }
 103         const glu::TextureCube*         getCube                         (void) const { DE_ASSERT(getType() == TYPE_CUBE_MAP);   return m_binding.texCube;       }
 104         const glu::Texture2DArray*      get2DArray                      (void) const { DE_ASSERT(getType() == TYPE_2D_ARRAY);   return m_binding.tex2DArray;}
 105         const glu::Texture3D*           get3D                           (void) const { DE_ASSERT(getType() == TYPE_3D);                 return m_binding.tex3D;         }
 106
 107 private:
 108         Type                                    m_type;
 109         tcu::Sampler                    m_sampler;
 110         union
 111         {
 112                 const glu::Texture2D*           tex2D;
 113                 const glu::TextureCube*         texCube;
 114                 const glu::Texture2DArray*      tex2DArray;
 115                 const glu::Texture3D*           tex3D;
 116         } m_binding;
 117 };
 118
 119 // ShaderEvalContext.
 120
 121 class ShaderEvalContext
 122 {
 123 public:
 124         // Limits.
 125         enum
 126         {
 127                 MAX_USER_ATTRIBS        = 4,
 128                 MAX_TEXTURES            = 4,
 129         };
 130
 131         struct ShaderSampler
 132         {
 133                 tcu::Sampler                            sampler;
 134                 const tcu::Texture2D*           tex2D;
 135                 const tcu::TextureCube*         texCube;
 136                 const tcu::Texture2DArray*      tex2DArray;
 137                 const tcu::Texture3D*           tex3D;
 138
 139                 inline ShaderSampler (void)
 140                         : tex2D         (DE_NULL)
 141                         , texCube       (DE_NULL)
 142                         , tex2DArray(DE_NULL)
 143                         , tex3D         (DE_NULL)
 144                 {
 145                 }
 146         };
 147
 148                                                         ShaderEvalContext               (const QuadGrid& quadGrid);
 149                                                         ~ShaderEvalContext              (void);
 150
 151         void                                    reset                                   (float sx, float sy);
 152
 153         // Inputs.
 154         tcu::Vec4                               coords;
 155         tcu::Vec4                               unitCoords;
 156         tcu::Vec4                               constCoords;
 157
 158         tcu::Vec4                               in[MAX_USER_ATTRIBS];
 159         ShaderSampler                   textures[MAX_TEXTURES];
 160
 161         // Output.
 162         tcu::Vec4                               color;
 163         bool                                    isDiscarded;
 164
 165         // Functions.
 166         inline void                             discard                                 (void)  { isDiscarded = true; }
 167         tcu::Vec4                               texture2D                               (int unitNdx, const tcu::Vec2& coords);
 168
 169 private:
 170         const QuadGrid&                 quadGrid;
 171 };
 172
 173 // ShaderEvalFunc.
 174
 175 typedef void (*ShaderEvalFunc) (ShaderEvalContext& c);
 176
 177 inline void evalCoordsPassthroughX              (ShaderEvalContext& c) { c.color.x() = c.coords.x(); }
 178 inline void evalCoordsPassthroughXY             (ShaderEvalContext& c) { c.color.xy() = c.coords.swizzle(0,1); }
 179 inline void evalCoordsPassthroughXYZ    (ShaderEvalContext& c) { c.color.xyz() = c.coords.swizzle(0,1,2); }
 180 inline void evalCoordsPassthrough               (ShaderEvalContext& c) { c.color = c.coords; }
 181 inline void evalCoordsSwizzleWZYX               (ShaderEvalContext& c) { c.color = c.coords.swizzle(3,2,1,0); }
 182
 183 // ShaderEvaluator
 184 // Either inherit a class with overridden evaluate() or just pass in an evalFunc.
 185
 186 class ShaderEvaluator
 187 {
 188 public:
 189                                                 ShaderEvaluator                 (void);
 190                                                 ShaderEvaluator                 (ShaderEvalFunc evalFunc);
 191         virtual                         ~ShaderEvaluator                (void);
 192
 193         virtual void            evaluate                                (ShaderEvalContext& ctx);
 194
 195 private:
 196                                                 ShaderEvaluator                 (const ShaderEvaluator&);       // not allowed!
 197         ShaderEvaluator&        operator=                               (const ShaderEvaluator&);       // not allowed!
 198
 199         ShaderEvalFunc          m_evalFunc;
 200 };
 201
 202 // ShaderRenderCase.
 203
 204 class ShaderRenderCase : public tcu::TestCase
 205 {
 206 public:
 207                                                                 ShaderRenderCase                (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* description, bool isVertexCase, ShaderEvalFunc evalFunc);
 208                                                                 ShaderRenderCase                (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const glu::ContextInfo& ctxInfo, const char* name, const char* description, bool isVertexCase, ShaderEvaluator& evaluator);
 209         virtual                                         ~ShaderRenderCase               (void);
 210
 211         void                                            init                                    (void);
 212         void                                            deinit                                  (void);
 213
 214         IterateResult                           iterate                                 (void);
 215
 216 protected:
 217         virtual void                            setupShaderData                 (void);
 218         virtual void                            setup                                   (int programID);
 219         virtual void                            setupUniforms                   (int programID, const tcu::Vec4& constCoords);
 220
 221         tcu::IVec2                                      getViewportSize                 (void) const;
 222
 223         class CompileFailed : public tcu::TestError
 224         {
 225         public:
 226                 inline CompileFailed (const char* file, int line) : tcu::TestError("Failed to compile shader program", DE_NULL, file, line) {}
 227         };
 228
 229 private:
 230                                                                 ShaderRenderCase                (const ShaderRenderCase&);              // not allowed!
 231         ShaderRenderCase&                       operator=                               (const ShaderRenderCase&);              // not allowed!
 232
 233         void                                            setupDefaultInputs              (int programID);
 234
 235         void                                            render                                  (tcu::Surface& result, int programID, const QuadGrid& quadGrid);
 236         void                                            computeVertexReference  (tcu::Surface& result, const QuadGrid& quadGrid);
 237         void                                            computeFragmentReference(tcu::Surface& result, const QuadGrid& quadGrid);
 238         bool                                            compareImages                   (const tcu::Surface& resImage, const tcu::Surface& refImage, float errorThreshold);
 239
 240 protected:
 241         glu::RenderContext&                     m_renderCtx;
 242         const glu::ContextInfo&         m_ctxInfo;
 243
 244         bool                                            m_isVertexCase;
 245         ShaderEvaluator                         m_defaultEvaluator;
 246         ShaderEvaluator&                        m_evaluator;
 247         std::string                                     m_vertShaderSource;
 248         std::string                                     m_fragShaderSource;
 249         tcu::Vec4                                       m_clearColor;
 250
 251         std::vector<tcu::Mat4>          m_userAttribTransforms;
 252         std::vector<TextureBinding>     m_textures;
 253
 254         glu::ShaderProgram*                     m_program;
 255 };
 256
 257 // Helpers.
 258 // \todo [2012-04-10 pyry] Move these to separate utility?
 259
 260 const char*             getIntUniformName                       (int number);
 261 const char*             getFloatUniformName                     (int number);
 262 const char*             getFloatFractionUniformName     (int number);
 263
 264 void                    setupDefaultUniforms            (const glu::RenderContext& context, deUint32 programID);
 265
 266 } // gls
 267 } // deqp
 268
 269 #endif // _GLSSHADERRENDERCASE_HPP