framework/referencerenderer/rrFragmentOperations.hpp

   1 #ifndef _RRFRAGMENTOPERATIONS_HPP
   2 #define _RRFRAGMENTOPERATIONS_HPP
   3 /*-------------------------------------------------------------------------
   4  * drawElements Quality Program Reference Renderer
   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 Reference implementation for per-fragment operations.
  24  *
  25  * \note In this file, a multisample buffer means a tcu::PixelBufferAccess
  26  *               (or ConstPixelBufferAccess) where the x coordinate is the sample
  27  *               index and the y and z coordinates are the pixel's x and y
  28  *               coordinates, respectively. To prevent supplying a buffer in
  29  *               a wrong format the buffers are wrapped in rr::MultisamplePixelBufferAccess
  30  *               wrapper. FragmentProcessor::render() operates on
  31  *               this kind of buffers. The function fromSinglesampleAccess() can be
  32  *               used to get a one-sampled multisample access to a normal 2d
  33  *               buffer.
  34  *//*--------------------------------------------------------------------*/
  35
  36 #include "rrDefs.hpp"
  37 #include "tcuVector.hpp"
  38 #include "tcuTexture.hpp"
  39 #include "rrRenderState.hpp"
  40 #include "rrGenericVector.hpp"
  41 #include "rrMultisamplePixelBufferAccess.hpp"
  42
  43 namespace rr
  44 {
  45
  46 struct Fragment
  47 {
  48         tcu::IVec2                      pixelCoord;
  49         GenericVec4                     value;
  50         GenericVec4                     value1;
  51         deUint32                        coverage;
  52         const float*            sampleDepths;
  53
  54         Fragment (const tcu::IVec2& pixelCoord_, const GenericVec4& value_, deUint32 coverage_, const float* sampleDepths_)
  55                 : pixelCoord    (pixelCoord_)
  56                 , value                 (value_)
  57                 , value1                ()
  58                 , coverage              (coverage_)
  59                 , sampleDepths  (sampleDepths_)
  60         {
  61         }
  62
  63         Fragment (const tcu::IVec2& pixelCoord_, const GenericVec4& value_, const GenericVec4& value1_, deUint32 coverage_, const float* sampleDepths_)
  64                 : pixelCoord    (pixelCoord_)
  65                 , value                 (value_)
  66                 , value1                (value1_)
  67                 , coverage              (coverage_)
  68                 , sampleDepths  (sampleDepths_)
  69         {
  70         }
  71
  72         Fragment (void)
  73                 : pixelCoord    (0)
  74                 , value                 ()
  75                 , coverage              (0)
  76                 , sampleDepths  (DE_NULL)
  77         {
  78         }
  79 } DE_WARN_UNUSED_TYPE;
  80
  81 // These functions are for clearing only a specific pixel rectangle in a multisample buffer.
  82 // When clearing the entire buffer, tcu::clear, tcu::clearDepth and tcu::clearStencil can be used.
  83 void clearMultisampleColorBuffer                (const tcu::PixelBufferAccess& dst, const tcu::Vec4&    value, const WindowRectangle& rect);
  84 void clearMultisampleColorBuffer                (const tcu::PixelBufferAccess& dst, const tcu::IVec4&   value, const WindowRectangle& rect);
  85 void clearMultisampleColorBuffer                (const tcu::PixelBufferAccess& dst, const tcu::UVec4&   value, const WindowRectangle& rect);
  86 void clearMultisampleDepthBuffer                (const tcu::PixelBufferAccess& dst, float                               value, const WindowRectangle& rect);
  87 void clearMultisampleStencilBuffer              (const tcu::PixelBufferAccess& dst, int                                 value, const WindowRectangle& rect);
  88
  89 /*--------------------------------------------------------------------*//*!
  90  * \brief Reference fragment renderer.
  91  *
  92  * FragmentProcessor.render() draws a given set of fragments. No two
  93  * fragments given in one render() call should have the same pixel
  94  * coordinates coordinates, and they must all have the same facing.
  95  *//*--------------------------------------------------------------------*/
  96 class FragmentProcessor
  97 {
  98 public:
  99                                 FragmentProcessor       (void);
 100
 101         void            render                          (const rr::MultisamplePixelBufferAccess&        colorMultisampleBuffer,
 102                                                                          const rr::MultisamplePixelBufferAccess&        depthMultisampleBuffer,
 103                                                                          const rr::MultisamplePixelBufferAccess&        stencilMultisampleBuffer,
 104                                                                          const Fragment*                                                        fragments,
 105                                                                          int                                                                            numFragments,
 106                                                                          FaceType                                                                       fragmentFacing,
 107                                                                          const FragmentOperationState&                          state);
 108
 109 private:
 110         enum
 111         {
 112                 SAMPLE_REGISTER_SIZE = 64
 113         };
 114         struct SampleData
 115         {
 116                 bool                                            isAlive;
 117                 bool                                            stencilPassed;
 118                 bool                                            depthPassed;
 119                 tcu::Vec4                                       clampedBlendSrcColor;
 120                 tcu::Vec4                                       clampedBlendSrc1Color;
 121                 tcu::Vec4                                       clampedBlendDstColor;
 122                 tcu::Vec3                                       blendSrcFactorRGB;
 123                 float                                           blendSrcFactorA;
 124                 tcu::Vec3                                       blendDstFactorRGB;
 125                 float                                           blendDstFactorA;
 126                 tcu::Vec3                                       blendedRGB;
 127                 float                                           blendedA;
 128                 tcu::Vector<deInt32,  4>        signedValue;            //!< integer targets
 129                 tcu::Vector<deUint32, 4>        unsignedValue;          //!< unsigned integer targets
 130         };
 131
 132         // These functions operate on the values in m_sampleRegister and, in some cases, the buffers.
 133
 134         void            executeScissorTest                              (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const WindowRectangle& scissorRect);
 135         void            executeStencilCompare                   (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const StencilState& stencilState, int numStencilBits, const tcu::ConstPixelBufferAccess& stencilBuffer);
 136         void            executeStencilSFail                             (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const StencilState& stencilState, int numStencilBits, const tcu::PixelBufferAccess& stencilBuffer);
 137         void            executeDepthCompare                             (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, TestFunc depthFunc, const tcu::ConstPixelBufferAccess& depthBuffer);
 138         void            executeDepthWrite                               (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::PixelBufferAccess& depthBuffer);
 139         void            executeStencilDpFailAndPass             (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const StencilState& stencilState, int numStencilBits, const tcu::PixelBufferAccess& stencilBuffer);
 140         void            executeBlendFactorComputeRGB    (const tcu::Vec4& blendColor, const BlendState& blendRGBState);
 141         void            executeBlendFactorComputeA              (const tcu::Vec4& blendColor, const BlendState& blendAState);
 142         void            executeBlend                                    (const BlendState& blendRGBState, const BlendState& blendAState);
 143         void            executeAdvancedBlend                    (BlendEquationAdvanced equation);
 144
 145         void            executeColorWrite                               (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, bool isSRGB, const tcu::PixelBufferAccess& colorBuffer);
 146         void            executeRGBA8ColorWrite                  (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::PixelBufferAccess& colorBuffer);
 147         void            executeMaskedColorWrite                 (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::Vec4& colorMaskFactor, const tcu::Vec4& colorMaskNegationFactor, bool isSRGB, const tcu::PixelBufferAccess& colorBuffer);
 148         void            executeSignedValueWrite                 (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::BVec4& colorMask, const tcu::PixelBufferAccess& colorBuffer);
 149         void            executeUnsignedValueWrite               (int fragNdxOffset, int numSamplesPerFragment, const Fragment* inputFragments, const tcu::BVec4& colorMask, const tcu::PixelBufferAccess& colorBuffer);
 150
 151         SampleData      m_sampleRegister[SAMPLE_REGISTER_SIZE];
 152 } DE_WARN_UNUSED_TYPE;
 153
 154 } // rr
 155
 156 #endif // _RRFRAGMENTOPERATIONS_HPP