modules/glshared/glsFragmentOpUtil.hpp

   1 #ifndef _GLSFRAGMENTOPUTIL_HPP
   2 #define _GLSFRAGMENTOPUTIL_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 Fragment operation test utilities.
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "tcuDefs.hpp"
  27 #include "gluShaderUtil.hpp"
  28 #include "tcuVector.hpp"
  29 #include "tcuTexture.hpp"
  30 #include "rrFragmentOperations.hpp"
  31
  32 namespace glu
  33 {
  34 class ShaderProgram;
  35 class RenderContext;
  36 }
  37
  38 namespace deqp
  39 {
  40 namespace gls
  41 {
  42 namespace FragmentOpUtil
  43 {
  44
  45 struct Quad
  46 {
  47         tcu::Vec2               posA;
  48         tcu::Vec2               posB;
  49
  50         // Normalized device coordinates (range [-1, 1]).
  51         // In order (A.x, A.y), (A.x, B.y), (B.x, A.y), (B.x, B.y)
  52         tcu::Vec4               color[4];
  53         tcu::Vec4               color1[4];
  54         float                   depth[4];
  55
  56         Quad (void)
  57                 : posA(-1.0f, -1.0f)
  58                 , posB( 1.0f,  1.0f)
  59         {
  60                 for (int i = 0; i < DE_LENGTH_OF_ARRAY(depth); i++)
  61                         depth[i] = 0.0f;
  62         }
  63 };
  64
  65 class QuadRenderer
  66 {
  67 public:
  68                                                                 QuadRenderer                            (const glu::RenderContext& context, glu::GLSLVersion glslVersion);
  69                                                                 ~QuadRenderer                           (void);
  70
  71         void                                            render                                          (const Quad& quad) const;
  72
  73 private:
  74                                                                 QuadRenderer                            (const QuadRenderer& other); // Not allowed!
  75         QuadRenderer&                           operator=                                       (const QuadRenderer& other); // Not allowed!
  76
  77         const glu::RenderContext&       m_context;
  78         glu::ShaderProgram*                     m_program;
  79         int                                                     m_positionLoc;
  80         int                                                     m_colorLoc;
  81         int                                                     m_color1Loc;
  82         const bool                                      m_blendFuncExt;
  83 };
  84
  85 struct IntegerQuad
  86 {
  87         tcu::IVec2      posA;
  88         tcu::IVec2      posB;
  89
  90         // Viewport coordinates (depth in range [0, 1]).
  91         // In order (A.x, A.y), (A.x, B.y), (B.x, A.y), (B.x, B.y)
  92         tcu::Vec4       color[4];
  93         tcu::Vec4       color1[4];
  94         float           depth[4];
  95
  96         IntegerQuad (int windowWidth, int windowHeight)
  97                 : posA(0,                               0)
  98                 , posB(windowWidth-1,   windowHeight-1)
  99         {
 100                 for (int i = 0; i < DE_LENGTH_OF_ARRAY(depth); i++)
 101                         depth[i] = 0.0f;
 102         }
 103
 104         IntegerQuad (void)
 105                 : posA(0, 0)
 106                 , posB(1, 1)
 107         {
 108                 for (int i = 0; i < DE_LENGTH_OF_ARRAY(depth); i++)
 109                         depth[i] = 0.0f;
 110         }
 111 };
 112
 113 class ReferenceQuadRenderer
 114 {
 115 public:
 116                                                                 ReferenceQuadRenderer   (void);
 117
 118         void                                            render                                  (const tcu::PixelBufferAccess&                  colorBuffer,
 119                                                                                                                  const tcu::PixelBufferAccess&                  depthBuffer,
 120                                                                                                                  const tcu::PixelBufferAccess&                  stencilBuffer,
 121                                                                                                                  const IntegerQuad&                                             quad,
 122                                                                                                                  const rr::FragmentOperationState&              state);
 123
 124 private:
 125         enum
 126         {
 127                 MAX_FRAGMENT_BUFFER_SIZE = 1024
 128         };
 129
 130         void                                            flushFragmentBuffer (const rr::MultisamplePixelBufferAccess&    colorBuffer,
 131                                                                                                          const rr::MultisamplePixelBufferAccess&        depthBuffer,
 132                                                                                                          const rr::MultisamplePixelBufferAccess&        stencilBuffer,
 133                                                                                                          rr::FaceType                                                           faceType,
 134                                                                                                          const rr::FragmentOperationState&                      state);
 135
 136         rr::Fragment                            m_fragmentBuffer[MAX_FRAGMENT_BUFFER_SIZE];
 137         float                                           m_fragmentDepths[MAX_FRAGMENT_BUFFER_SIZE];
 138         int                                                     m_fragmentBufferSize;
 139
 140         rr::FragmentProcessor           m_fragmentProcessor;
 141 };
 142
 143
 144 // These functions take a normally-indexed 2d pixel buffer and return a pixel buffer access
 145 // that indexes the same memory area, but using the multisample indexing convention.
 146 tcu::PixelBufferAccess                                  getMultisampleAccess(const tcu::PixelBufferAccess&                      original);
 147 tcu::ConstPixelBufferAccess                             getMultisampleAccess(const tcu::ConstPixelBufferAccess& original);
 148
 149 } // FragmentOpUtil
 150 } // gls
 151 } // deqp
 152
 153 #endif // _GLSFRAGMENTOPUTIL_HPP