/****************************************************************************
 * Copyright (C) 2014-2015 Intel Corporation.   All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 *
 * @file rasterizer.h
 *
 * @brief Definitions for the rasterizer.
 *
 ******************************************************************************/
#pragma once

#include "context.h"
#include <type_traits>
#include "conservativeRast.h"
#include "multisample.h"

void RasterizeLine(DRAW_CONTEXT* pDC, uint32_t workerId, uint32_t macroTile, void* pData);
void RasterizeSimplePoint(DRAW_CONTEXT* pDC, uint32_t workerId, uint32_t macroTile, void* pData);
void RasterizeTriPoint(DRAW_CONTEXT* pDC, uint32_t workerId, uint32_t macroTile, void* pData);
void InitRasterizerFunctions();

INLINE
__m128i fpToFixedPoint(const __m128 vIn)
{
    __m128 vFixed = _mm_mul_ps(vIn, _mm_set1_ps(FIXED_POINT_SCALE));
    return _mm_cvtps_epi32(vFixed);
}

enum TriEdgesStates
{
    STATE_NO_VALID_EDGES = 0,
    STATE_E0_E1_VALID,
    STATE_E0_E2_VALID,
    STATE_E1_E2_VALID,
    STATE_ALL_EDGES_VALID,
    STATE_VALID_TRI_EDGE_COUNT,
};

enum TriEdgesValues
{
    NO_VALID_EDGES  = 0,
    E0_E1_VALID     = 0x3,
    E0_E2_VALID     = 0x5,
    E1_E2_VALID     = 0x6,
    ALL_EDGES_VALID = 0x7,
    VALID_TRI_EDGE_COUNT,
};

// Selector for correct templated RasterizeTriangle function
PFN_WORK_FUNC GetRasterizerFunc(SWR_MULTISAMPLE_COUNT numSamples,
                                bool                  IsCenter,
                                bool                  IsConservative,
                                SWR_INPUT_COVERAGE    InputCoverage,
                                uint32_t              EdgeEnable,
                                bool                  RasterizeScissorEdges);

//////////////////////////////////////////////////////////////////////////
/// @brief ValidTriEdges convenience typedefs used for templated function
/// specialization supported Fixed Point precisions
typedef std::integral_constant<uint32_t, ALL_EDGES_VALID> AllEdgesValidT;
typedef std::integral_constant<uint32_t, E0_E1_VALID>     E0E1ValidT;
typedef std::integral_constant<uint32_t, E0_E2_VALID>     E0E2ValidT;
typedef std::integral_constant<uint32_t, E1_E2_VALID>     E1E2ValidT;
typedef std::integral_constant<uint32_t, NO_VALID_EDGES>  NoEdgesValidT;

typedef std::integral_constant<uint32_t, STATE_ALL_EDGES_VALID> StateAllEdgesValidT;
typedef std::integral_constant<uint32_t, STATE_E0_E1_VALID>     StateE0E1ValidT;
typedef std::integral_constant<uint32_t, STATE_E0_E2_VALID>     StateE0E2ValidT;
typedef std::integral_constant<uint32_t, STATE_E1_E2_VALID>     StateE1E2ValidT;
typedef std::integral_constant<uint32_t, STATE_NO_VALID_EDGES>  StateNoEdgesValidT;

// some specializations to convert from edge state to edge bitmask values
template <typename EdgeMask>
struct EdgeMaskVal
{
    static_assert(EdgeMask::value > STATE_ALL_EDGES_VALID,
                  "Primary EdgeMaskVal shouldn't be instantiated");
};

template <>
struct EdgeMaskVal<StateAllEdgesValidT>
{
    typedef AllEdgesValidT T;
};

template <>
struct EdgeMaskVal<StateE0E1ValidT>
{
    typedef E0E1ValidT T;
};

template <>
struct EdgeMaskVal<StateE0E2ValidT>
{
    typedef E0E2ValidT T;
};

template <>
struct EdgeMaskVal<StateE1E2ValidT>
{
    typedef E1E2ValidT T;
};

template <>
struct EdgeMaskVal<StateNoEdgesValidT>
{
    typedef NoEdgesValidT T;
};

INLINE uint32_t EdgeValToEdgeState(uint32_t val)
{
    SWR_ASSERT(val < VALID_TRI_EDGE_COUNT, "Unexpected tri edge mask");
    static const uint32_t edgeValToEdgeState[VALID_TRI_EDGE_COUNT] = {0, 0, 0, 1, 0, 2, 3, 4};
    return edgeValToEdgeState[val];
}

//////////////////////////////////////////////////////////////////////////
/// @struct RasterScissorEdgesT
/// @brief Primary RasterScissorEdgesT templated struct that holds compile
/// time information about the number of edges needed to be rasterized,
/// If either the scissor rect or conservative rast is enabled,
/// the scissor test is enabled and the rasterizer will test
/// 3 triangle edges + 4 scissor edges for coverage.
/// @tparam RasterScissorEdgesT: number of multisamples
/// @tparam ConservativeT: is this a conservative rasterization
/// @tparam EdgeMaskT: Which edges are valid(not degenerate)
template <typename RasterScissorEdgesT, typename ConservativeT, typename EdgeMaskT>
struct RasterEdgeTraits
{
    typedef std::true_type                      RasterizeScissorEdgesT;
    typedef std::integral_constant<uint32_t, 7> NumEdgesT;
    // typedef std::integral_constant<uint32_t, EdgeMaskT::value> ValidEdgeMaskT;
    typedef typename EdgeMaskVal<EdgeMaskT>::T ValidEdgeMaskT;
};

//////////////////////////////////////////////////////////////////////////
/// @brief specialization of RasterEdgeTraits. If neither scissor rect
/// nor conservative rast is enabled, only test 3 triangle edges
/// for coverage
template <typename EdgeMaskT>
struct RasterEdgeTraits<std::false_type, std::false_type, EdgeMaskT>
{
    typedef std::false_type                     RasterizeScissorEdgesT;
    typedef std::integral_constant<uint32_t, 3> NumEdgesT;
    // no need for degenerate edge masking in non-conservative case; rasterize all triangle edges
    typedef std::integral_constant<uint32_t, ALL_EDGES_VALID> ValidEdgeMaskT;
};

//////////////////////////////////////////////////////////////////////////
/// @struct RasterizerTraits
/// @brief templated struct that holds compile time information used
/// during rasterization. Inherits EdgeTraits and ConservativeRastBETraits.
/// @tparam NumSamplesT: number of multisamples
/// @tparam ConservativeT: is this a conservative rasterization
/// @tparam InputCoverageT: what type of input coverage is the PS expecting?
/// (only used with conservative rasterization)
/// @tparam RasterScissorEdgesT: do we need to rasterize with a scissor?
template <typename NumSamplesT,
          typename CenterPatternT,
          typename ConservativeT,
          typename InputCoverageT,
          typename EdgeEnableT,
          typename RasterScissorEdgesT>
struct _RasterizerTraits : public ConservativeRastBETraits<ConservativeT, InputCoverageT>,
                           public RasterEdgeTraits<RasterScissorEdgesT, ConservativeT, EdgeEnableT>
{
    typedef MultisampleTraits<static_cast<SWR_MULTISAMPLE_COUNT>(NumSamplesT::value),
                              CenterPatternT::value>
        MT;

    /// Fixed point precision the rasterizer is using
    typedef FixedPointTraits<Fixed_16_8> PrecisionT;
    /// Fixed point precision of the edge tests used during rasterization
    typedef FixedPointTraits<Fixed_X_16> EdgePrecisionT;

    // If conservative rast or MSAA center pattern is enabled, only need a single sample coverage
    // test, with the result copied to all samples
    typedef std::integral_constant<int, ConservativeT::value ? 1 : MT::numCoverageSamples>
        NumCoverageSamplesT;

    static_assert(
        EdgePrecisionT::BitsT::value >=
            ConservativeRastBETraits<ConservativeT,
                                     InputCoverageT>::ConservativePrecisionT::BitsT::value,
        "Rasterizer edge fixed point precision < required conservative rast precision");

    /// constants used to offset between different types of raster tiles
    static const int colorRasterTileStep{
        (KNOB_TILE_X_DIM * KNOB_TILE_Y_DIM * (FormatTraits<KNOB_COLOR_HOT_TILE_FORMAT>::bpp / 8)) *
        MT::numSamples};
    static const int depthRasterTileStep{
        (KNOB_TILE_X_DIM * KNOB_TILE_Y_DIM * (FormatTraits<KNOB_DEPTH_HOT_TILE_FORMAT>::bpp / 8)) *
        MT::numSamples};
    static const int stencilRasterTileStep{(KNOB_TILE_X_DIM * KNOB_TILE_Y_DIM *
                                            (FormatTraits<KNOB_STENCIL_HOT_TILE_FORMAT>::bpp / 8)) *
                                           MT::numSamples};
    static const int colorRasterTileRowStep{(KNOB_MACROTILE_X_DIM / KNOB_TILE_X_DIM) *
                                            colorRasterTileStep};
    static const int depthRasterTileRowStep{(KNOB_MACROTILE_X_DIM / KNOB_TILE_X_DIM) *
                                            depthRasterTileStep};
    static const int stencilRasterTileRowStep{(KNOB_MACROTILE_X_DIM / KNOB_TILE_X_DIM) *
                                              stencilRasterTileStep};
};

template <uint32_t NumSamplesT,
          uint32_t CenterPatternT,
          uint32_t ConservativeT,
          uint32_t InputCoverageT,
          uint32_t EdgeEnableT,
          uint32_t RasterScissorEdgesT>
struct RasterizerTraits final
    : public _RasterizerTraits<std::integral_constant<uint32_t, NumSamplesT>,
                               std::integral_constant<bool, CenterPatternT != 0>,
                               std::integral_constant<bool, ConservativeT != 0>,
                               std::integral_constant<uint32_t, InputCoverageT>,
                               std::integral_constant<uint32_t, EdgeEnableT>,
                               std::integral_constant<bool, RasterScissorEdgesT != 0>>
{
};