framework/referencerenderer/rrRasterizer.hpp

   1 #ifndef _RRRASTERIZER_HPP
   2 #define _RRRASTERIZER_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 rasterizer
  24  *//*--------------------------------------------------------------------*/
  25
  26 #include "rrDefs.hpp"
  27 #include "tcuVector.hpp"
  28 #include "rrRenderState.hpp"
  29 #include "rrFragmentPacket.hpp"
  30
  31
  32 namespace rr
  33 {
  34
  35 //! Rasterizer configuration
  36 enum
  37 {
  38         RASTERIZER_SUBPIXEL_BITS                        = 8,
  39         RASTERIZER_MAX_SAMPLES_PER_FRAGMENT     = 16
  40 };
  41
  42 //! Get coverage bit value.
  43 inline deUint64 getCoverageBit (int numSamples, int x, int y, int sampleNdx)
  44 {
  45         const int       numBits         = (int)sizeof(deUint64)*8;
  46         const int       maxSamples      = numBits/4;
  47         DE_STATIC_ASSERT(maxSamples >= RASTERIZER_MAX_SAMPLES_PER_FRAGMENT);
  48         DE_ASSERT(de::inRange(numSamples, 1, maxSamples) && de::inBounds(x, 0, 2) && de::inBounds(y, 0, 2));
  49         return 1ull << ((x*2 + y)*numSamples + sampleNdx);
  50 }
  51
  52 //! Get all sample bits for fragment
  53 inline deUint64 getCoverageFragmentSampleBits (int numSamples, int x, int y)
  54 {
  55         DE_ASSERT(de::inBounds(x, 0, 2) && de::inBounds(y, 0, 2));
  56         const deUint64 fragMask = (1ull << numSamples) - 1;
  57         return fragMask << (x*2 + y)*numSamples;
  58 }
  59
  60 //! Set bit in coverage mask.
  61 inline deUint64 setCoverageValue (deUint64 mask, int numSamples, int x, int y, int sampleNdx, bool val)
  62 {
  63         const deUint64 bit = getCoverageBit(numSamples, x, y, sampleNdx);
  64         return val ? (mask | bit) : (mask & ~bit);
  65 }
  66
  67 //! Get coverage bit value in mask.
  68 inline bool getCoverageValue (deUint64 mask, int numSamples, int x, int y, int sampleNdx)
  69 {
  70         return (mask & getCoverageBit(numSamples, x, y, sampleNdx)) != 0;
  71 }
  72
  73 //! Test if any sample for fragment is live
  74 inline bool getCoverageAnyFragmentSampleLive (deUint64 mask, int numSamples, int x, int y)
  75 {
  76         return (mask & getCoverageFragmentSampleBits(numSamples, x, y)) != 0;
  77 }
  78
  79 //! Get position of first coverage bit of fragment - equivalent to deClz64(getCoverageFragmentSampleBits(numSamples, x, y)).
  80 inline int getCoverageOffset (int numSamples, int x, int y)
  81 {
  82         return (x*2 + y)*numSamples;
  83 }
  84
  85 /*--------------------------------------------------------------------*//*!
  86  * \brief Edge function
  87  *
  88  * Edge function can be evaluated for point P (in fixed-point coordinates
  89  * with SUBPIXEL_BITS fractional part) by computing
  90  *  D = a*Px + b*Py + c
  91  *
  92  * D will be fixed-point value where lower (SUBPIXEL_BITS*2) bits will
  93  * be fractional part.
  94  *
  95  * a and b are stored with SUBPIXEL_BITS fractional part, while c is stored
  96  * with SUBPIXEL_BITS*2 fractional bits.
  97  *//*--------------------------------------------------------------------*/
  98 struct EdgeFunction
  99 {
 100         inline EdgeFunction (void) : a(0), b(0), c(0), inclusive(false) {}
 101
 102         deInt64                 a;
 103         deInt64                 b;
 104         deInt64                 c;
 105         bool                    inclusive;      //!< True if edge is inclusive according to fill rules.
 106 };
 107
 108 /*--------------------------------------------------------------------*//*!
 109  * \brief Triangle rasterizer
 110  *
 111  * Triangle rasterizer implements following features:
 112  *  - Rasterization using fixed-point coordinates
 113  *  - 1, 4, and 16 -sample rasterization
 114  *  - Depth interpolation
 115  *  - Perspective-correct barycentric computation for interpolation
 116  *  - Visible face determination
 117  *
 118  * It does not (and will not) implement following:
 119  *  - Triangle setup
 120  *  - Clipping
 121  *  - Degenerate elimination
 122  *  - Coordinate transformation (inputs are in screen-space)
 123  *  - Culling - logic can be implemented outside by querying visible face
 124  *  - Scissoring (this can be done by controlling viewport rectangle)
 125  *  - Any per-fragment operations
 126  *//*--------------------------------------------------------------------*/
 127 class TriangleRasterizer
 128 {
 129 public:
 130                                                         TriangleRasterizer              (const tcu::IVec4& viewport, const int numSamples, const RasterizationState& state);
 131
 132         void                                    init                                    (const tcu::Vec4& v0, const tcu::Vec4& v1, const tcu::Vec4& v2);
 133
 134         // Following functions are only available after init()
 135         FaceType                                getVisibleFace                  (void) const { return m_face; }
 136         void                                    rasterize                               (FragmentPacket* const fragmentPackets, float* const depthValues, const int maxFragmentPackets, int& numPacketsRasterized);
 137
 138 private:
 139         void                                    rasterizeSingleSample   (FragmentPacket* const fragmentPackets, float* const depthValues, const int maxFragmentPackets, int& numPacketsRasterized);
 140
 141         template<int NumSamples>
 142         void                                    rasterizeMultiSample    (FragmentPacket* const fragmentPackets, float* const depthValues, const int maxFragmentPackets, int& numPacketsRasterized);
 143
 144         // Constant rasterization state.
 145         const tcu::IVec4                m_viewport;
 146         const int                               m_numSamples;
 147         const Winding                   m_winding;
 148         const HorizontalFill    m_horizontalFill;
 149         const VerticalFill              m_verticalFill;
 150
 151         // Per-triangle rasterization state.
 152         tcu::Vec4                               m_v0;
 153         tcu::Vec4                               m_v1;
 154         tcu::Vec4                               m_v2;
 155         EdgeFunction                    m_edge01;
 156         EdgeFunction                    m_edge12;
 157         EdgeFunction                    m_edge20;
 158         FaceType                                m_face;                                 //!< Triangle orientation, eg. visible face.
 159         tcu::IVec2                              m_bboxMin;                              //!< Bounding box min (inclusive).
 160         tcu::IVec2                              m_bboxMax;                              //!< Bounding box max (inclusive).
 161         tcu::IVec2                              m_curPos;                               //!< Current rasterization position.
 162         ViewportOrientation             m_viewportOrientation;  //!< Direction of +x+y axis
 163 } DE_WARN_UNUSED_TYPE;
 164
 165
 166 /*--------------------------------------------------------------------*//*!
 167  * \brief Single sample line rasterizer
 168  *
 169  * Line rasterizer implements following features:
 170  *  - Rasterization using fixed-point coordinates
 171  *  - Depth interpolation
 172  *  - Perspective-correct interpolation
 173  *
 174  * It does not (and will not) implement following:
 175  *  - Clipping
 176  *  - Multisampled line rasterization
 177  *//*--------------------------------------------------------------------*/
 178 class SingleSampleLineRasterizer
 179 {
 180 public:
 181                                                                         SingleSampleLineRasterizer      (const tcu::IVec4& viewport);
 182                                                                         ~SingleSampleLineRasterizer     (void);
 183
 184         void                                                    init                                            (const tcu::Vec4& v0, const tcu::Vec4& v1, float lineWidth);
 185
 186         // only available after init()
 187         void                                                    rasterize                                       (FragmentPacket* const fragmentPackets, float* const depthValues, const int maxFragmentPackets, int& numPacketsRasterized);
 188
 189 private:
 190                                                                         SingleSampleLineRasterizer      (const SingleSampleLineRasterizer&); // not allowed
 191         SingleSampleLineRasterizer&             operator=                                       (const SingleSampleLineRasterizer&); // not allowed
 192
 193         // Constant rasterization state.
 194         const tcu::IVec4                                m_viewport;
 195
 196         // Per-line rasterization state.
 197         tcu::Vec4                                               m_v0;
 198         tcu::Vec4                                               m_v1;
 199         tcu::IVec2                                              m_bboxMin;                      //!< Bounding box min (inclusive).
 200         tcu::IVec2                                              m_bboxMax;                      //!< Bounding box max (inclusive).
 201         tcu::IVec2                                              m_curPos;                       //!< Current rasterization position.
 202         deInt32                                                 m_curRowFragment;       //!< Current rasterization position of one fragment in column of lineWidth fragments
 203         float                                                   m_lineWidth;
 204 } DE_WARN_UNUSED_TYPE;
 205
 206
 207 /*--------------------------------------------------------------------*//*!
 208  * \brief Multisampled line rasterizer
 209  *
 210  * Line rasterizer implements following features:
 211  *  - Rasterization using fixed-point coordinates
 212  *  - Depth interpolation
 213  *  - Perspective-correct interpolation
 214  *
 215  * It does not (and will not) implement following:
 216  *  - Clipping
 217  *  - Aliased line rasterization
 218  *//*--------------------------------------------------------------------*/
 219 class MultiSampleLineRasterizer
 220 {
 221 public:
 222                                                                 MultiSampleLineRasterizer       (const int numSamples, const tcu::IVec4& viewport);
 223                                                                 ~MultiSampleLineRasterizer      ();
 224
 225         void                                            init                                            (const tcu::Vec4& v0, const tcu::Vec4& v1, float lineWidth);
 226
 227         // only available after init()
 228         void                                            rasterize                                       (FragmentPacket* const fragmentPackets, float* const depthValues, const int maxFragmentPackets, int& numPacketsRasterized);
 229
 230 private:
 231                                                                 MultiSampleLineRasterizer       (const MultiSampleLineRasterizer&); // not allowed
 232         MultiSampleLineRasterizer&      operator=                                       (const MultiSampleLineRasterizer&); // not allowed
 233
 234         // Constant rasterization state.
 235         const int                                       m_numSamples;
 236
 237         // Per-line rasterization state.
 238         TriangleRasterizer                      m_triangleRasterizer0; //!< not in array because we want to initialize these in the initialization list
 239         TriangleRasterizer                      m_triangleRasterizer1;
 240 } DE_WARN_UNUSED_TYPE;
 241
 242
 243 /*--------------------------------------------------------------------*//*!
 244  * \brief Pixel diamond
 245  *
 246  * Structure representing a diamond a line exits.
 247  *//*--------------------------------------------------------------------*/
 248 struct LineExitDiamond
 249 {
 250         tcu::IVec2      position;
 251 };
 252
 253 /*--------------------------------------------------------------------*//*!
 254  * \brief Line exit diamond generator
 255  *
 256  * For a given line, generates list of diamonds the line exits using the
 257  * line-exit rules of the line rasterization. Does not do scissoring.
 258  *
 259  * \note Not used by rr, but provided to prevent test cases requiring
 260  *       accurate diamonds from abusing SingleSampleLineRasterizer.
 261  *//*--------------------------------------------------------------------*/
 262 class LineExitDiamondGenerator
 263 {
 264 public:
 265                                                                         LineExitDiamondGenerator        (void);
 266                                                                         ~LineExitDiamondGenerator       (void);
 267
 268         void                                                    init                                            (const tcu::Vec4& v0, const tcu::Vec4& v1);
 269
 270         // only available after init()
 271         void                                                    rasterize                                       (LineExitDiamond* const lineDiamonds, const int maxDiamonds, int& numWritten);
 272
 273 private:
 274                                                                         LineExitDiamondGenerator        (const LineExitDiamondGenerator&); // not allowed
 275         LineExitDiamondGenerator&               operator=                                       (const LineExitDiamondGenerator&); // not allowed
 276
 277         // Per-line rasterization state.
 278         tcu::Vec4                                               m_v0;
 279         tcu::Vec4                                               m_v1;
 280         tcu::IVec2                                              m_bboxMin;                      //!< Bounding box min (inclusive).
 281         tcu::IVec2                                              m_bboxMax;                      //!< Bounding box max (inclusive).
 282         tcu::IVec2                                              m_curPos;                       //!< Current rasterization position.
 283 };
 284
 285 } // rr
 286
 287 #endif // _RRRASTERIZER_HPP