xref: /aosp_15_r20/external/deqp/framework/referencerenderer/rrFragmentOperations.hpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

#ifndef _RRFRAGMENTOPERATIONS_HPP
#define _RRFRAGMENTOPERATIONS_HPP
/*-------------------------------------------------------------------------
 * drawElements Quality Program Reference Renderer
 * -----------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Reference implementation for per-fragment operations.
 *
 * \note In this file, a multisample buffer means a tcu::PixelBufferAccess
 *         (or ConstPixelBufferAccess) where the x coordinate is the sample
 *         index and the y and z coordinates are the pixel's x and y
 *         coordinates, respectively. To prevent supplying a buffer in
 *         a wrong format the buffers are wrapped in rr::MultisamplePixelBufferAccess
 *         wrapper. FragmentProcessor::render() operates on
 *         this kind of buffers. The function fromSinglesampleAccess() can be
 *         used to get a one-sampled multisample access to a normal 2d
 *         buffer.
 *//*--------------------------------------------------------------------*/

#include "rrDefs.hpp"
#include "tcuVector.hpp"
#include "tcuTexture.hpp"
#include "rrRenderState.hpp"
#include "rrGenericVector.hpp"
#include "rrMultisamplePixelBufferAccess.hpp"

namespace rr
{

struct Fragment
{
    tcu::IVec2 pixelCoord;
    GenericVec4 value;
    GenericVec4 value1;
    uint32_t coverage;
    const float *sampleDepths;

    Fragment(const tcu::IVec2 &pixelCoord_, const GenericVec4 &value_, uint32_t coverage_, const float *sampleDepths_)
        : pixelCoord(pixelCoord_)
        , value(value_)
        , value1()
        , coverage(coverage_)
        , sampleDepths(sampleDepths_)
    {
    }

    Fragment(const tcu::IVec2 &pixelCoord_, const GenericVec4 &value_, const GenericVec4 &value1_, uint32_t coverage_,
             const float *sampleDepths_)
        : pixelCoord(pixelCoord_)
        , value(value_)
        , value1(value1_)
        , coverage(coverage_)
        , sampleDepths(sampleDepths_)
    {
    }

    Fragment(void) : pixelCoord(0), value(), coverage(0), sampleDepths(DE_NULL)
    {
    }
} DE_WARN_UNUSED_TYPE;

// These functions are for clearing only a specific pixel rectangle in a multisample buffer.
// When clearing the entire buffer, tcu::clear, tcu::clearDepth and tcu::clearStencil can be used.
void clearMultisampleColorBuffer(const tcu::PixelBufferAccess &dst, const tcu::Vec4 &value,
                                 const WindowRectangle &rect);
void clearMultisampleColorBuffer(const tcu::PixelBufferAccess &dst, const tcu::IVec4 &value,
                                 const WindowRectangle &rect);
void clearMultisampleColorBuffer(const tcu::PixelBufferAccess &dst, const tcu::UVec4 &value,
                                 const WindowRectangle &rect);
void clearMultisampleDepthBuffer(const tcu::PixelBufferAccess &dst, float value, const WindowRectangle &rect);
void clearMultisampleStencilBuffer(const tcu::PixelBufferAccess &dst, int value, const WindowRectangle &rect);

/*--------------------------------------------------------------------*//*!
 * \brief Reference fragment renderer.
 *
 * FragmentProcessor.render() draws a given set of fragments. No two
 * fragments given in one render() call should have the same pixel
 * coordinates coordinates, and they must all have the same facing.
 *//*--------------------------------------------------------------------*/
class FragmentProcessor
{
public:
    FragmentProcessor(void);

    void render(const rr::MultisamplePixelBufferAccess &colorMultisampleBuffer,
                const rr::MultisamplePixelBufferAccess &depthMultisampleBuffer,
                const rr::MultisamplePixelBufferAccess &stencilMultisampleBuffer, const Fragment *fragments,
                int numFragments, FaceType fragmentFacing, const FragmentOperationState &state);

private:
    enum
    {
        SAMPLE_REGISTER_SIZE = 64
    };
    struct SampleData
    {
        bool isAlive;
        bool stencilPassed;
        bool depthPassed;
        tcu::Vec4 clampedBlendSrcColor;
        tcu::Vec4 clampedBlendSrc1Color;
        tcu::Vec4 clampedBlendDstColor;
        tcu::Vec3 blendSrcFactorRGB;
        float blendSrcFactorA;
        tcu::Vec3 blendDstFactorRGB;
        float blendDstFactorA;
        tcu::Vec3 blendedRGB;
        float blendedA;
        tcu::Vector<int32_t, 4> signedValue;    //!< integer targets
        tcu::Vector<uint32_t, 4> unsignedValue; //!< unsigned integer targets
    };

    // These functions operate on the values in m_sampleRegister and, in some cases, the buffers.

    void executeScissorTest(int fragNdxOffset, int numSamplesPerFragment, const Fragment *inputFragments,
                            const WindowRectangle &scissorRect);
    void executeStencilCompare(int fragNdxOffset, int numSamplesPerFragment, const Fragment *inputFragments,
                               const StencilState &stencilState, int numStencilBits,
                               const tcu::ConstPixelBufferAccess &stencilBuffer);
    void executeStencilSFail(int fragNdxOffset, int numSamplesPerFragment, const Fragment *inputFragments,
                             const StencilState &stencilState, int numStencilBits,
                             const tcu::PixelBufferAccess &stencilBuffer);
    void executeDepthBoundsTest(int fragNdxOffset, int numSamplesPerFragment, const Fragment *inputFragments,
                                const float minDepthBound, const float maxDepthBound,
                                const tcu::ConstPixelBufferAccess &depthBuffer);
    void executeDepthCompare(int fragNdxOffset, int numSamplesPerFragment, const Fragment *inputFragments,
                             TestFunc depthFunc, const tcu::ConstPixelBufferAccess &depthBuffer);
    void executeDepthWrite(int fragNdxOffset, int numSamplesPerFragment, const Fragment *inputFragments,
                           const tcu::PixelBufferAccess &depthBuffer);
    void executeStencilDpFailAndPass(int fragNdxOffset, int numSamplesPerFragment, const Fragment *inputFragments,
                                     const StencilState &stencilState, int numStencilBits,
                                     const tcu::PixelBufferAccess &stencilBuffer);
    void executeBlendFactorComputeRGB(const tcu::Vec4 &blendColor, const BlendState &blendRGBState);
    void executeBlendFactorComputeA(const tcu::Vec4 &blendColor, const BlendState &blendAState);
    void executeBlend(const BlendState &blendRGBState, const BlendState &blendAState);
    void executeAdvancedBlend(BlendEquationAdvanced equation);

    void executeColorWrite(int fragNdxOffset, int numSamplesPerFragment, const Fragment *inputFragments, bool isSRGB,
                           const tcu::PixelBufferAccess &colorBuffer);
    void executeRGBA8ColorWrite(int fragNdxOffset, int numSamplesPerFragment, const Fragment *inputFragments,
                                const tcu::PixelBufferAccess &colorBuffer);
    void executeMaskedColorWrite(int fragNdxOffset, int numSamplesPerFragment, const Fragment *inputFragments,
                                 const tcu::Vec4 &colorMaskFactor, const tcu::Vec4 &colorMaskNegationFactor,
                                 bool isSRGB, const tcu::PixelBufferAccess &colorBuffer);
    void executeSignedValueWrite(int fragNdxOffset, int numSamplesPerFragment, const Fragment *inputFragments,
                                 const tcu::BVec4 &colorMask, const tcu::PixelBufferAccess &colorBuffer);
    void executeUnsignedValueWrite(int fragNdxOffset, int numSamplesPerFragment, const Fragment *inputFragments,
                                   const tcu::BVec4 &colorMask, const tcu::PixelBufferAccess &colorBuffer);

    SampleData m_sampleRegister[SAMPLE_REGISTER_SIZE];
} DE_WARN_UNUSED_TYPE;

} // namespace rr

#endif // _RRFRAGMENTOPERATIONS_HPP