src/gallium/drivers/swr/rasterizer/core/rasterizer.h - platform/external/mesa3d - Git at Google

 /****************************************************************************
  * 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>>
 {
 };
	/****************************************************************************
	* 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>>
	{
	};