brkho
/
mesa
Suivre 1
Ajouter aux favoris 0
Bifurcation 0
Code Versions 562 Wiki Activité
Parcourir la source

swr/rast: Make SIMDLib templated types easier to use 

"typename SIMD_T::TypeName" --> "TypeName<SIMD_T>"

Reviewed-by: Bruce Cherniak <bruce.cherniak@intel.com>
tags/18.1-branchpoint
George Kyriazis il y a 7 ans
Parent
74e8bb4a22
révision
37ebf86add
5 fichiers modifiés avec 307 ajouts et 298 suppressions
Vue séparée Afficher les stats Diff
  1. 9
    0
      src/gallium/drivers/swr/rasterizer/common/simdlib.hpp
  2. 169
    169
      src/gallium/drivers/swr/rasterizer/core/binner.cpp
  3. 9
    9
      src/gallium/drivers/swr/rasterizer/core/binner.h
  4. 109
    109
      src/gallium/drivers/swr/rasterizer/core/clip.h
  5. 11
    11
      src/gallium/drivers/swr/rasterizer/core/frontend.cpp

+ 9
- 0
src/gallium/drivers/swr/rasterizer/common/simdlib.hpp Voir le fichier

@@ -571,3 +571,12 @@ struct SIMDBase : Traits::IsaImpl
using SIMD128 = SIMDBase<SIMDImpl::SIMD128Impl::Traits>;
using SIMD256 = SIMDBase<SIMDImpl::SIMD256Impl::Traits>;
using SIMD512 = SIMDBase<SIMDImpl::SIMD512Impl::Traits>;

template <typename SIMD_T> using CompareType = typename SIMD_T::CompareType;
template <typename SIMD_T> using ScaleFactor = typename SIMD_T::ScaleFactor;
template <typename SIMD_T> using RoundMode = typename SIMD_T::RoundMode;
template <typename SIMD_T> using Float = typename SIMD_T::Float;
template <typename SIMD_T> using Double = typename SIMD_T::Double;
template <typename SIMD_T> using Integer = typename SIMD_T::Integer;
template <typename SIMD_T> using Vec4 = typename SIMD_T::Vec4;
template <typename SIMD_T> using Mask = typename SIMD_T::Mask;

+ 169
- 169
src/gallium/drivers/swr/rasterizer/core/binner.cpp Voir le fichier

@@ -41,23 +41,23 @@ void BinPostSetupLinesImpl(
DRAW_CONTEXT *pDC,
PA_STATE &pa,
uint32_t workerId,
typename SIMD_T::Vec4 prim[],
typename SIMD_T::Float recipW[],
Vec4<SIMD_T> prim[],
Float<SIMD_T> recipW[],
uint32_t primMask,
typename SIMD_T::Integer const &primID,
typename SIMD_T::Integer const &viewportIdx,
typename SIMD_T::Integer const &rtIdx);
Integer<SIMD_T> const &primID,
Integer<SIMD_T> const &viewportIdx,
Integer<SIMD_T> const &rtIdx);

template <typename SIMD_T, uint32_t SIMD_WIDTH>
void BinPostSetupPointsImpl(
DRAW_CONTEXT *pDC,
PA_STATE &pa,
uint32_t workerId,
typename SIMD_T::Vec4 prim[],
Vec4<SIMD_T> prim[],
uint32_t primMask,
typename SIMD_T::Integer const &primID,
typename SIMD_T::Integer const &viewportIdx,
typename SIMD_T::Integer const &rtIdx);
Integer<SIMD_T> const &primID,
Integer<SIMD_T> const &viewportIdx,
Integer<SIMD_T> const &rtIdx);

//////////////////////////////////////////////////////////////////////////
/// @brief Processes attributes for the backend based on linkage mask and
@@ -327,34 +327,34 @@ struct EarlyRastHelper<SIMD512>
template <typename SIMD_T, uint32_t SIMD_WIDTH, typename CT>
uint32_t SIMDCALL EarlyRasterizer(
SIMDBBOX_T<SIMD_T> &er_bbox,
typename SIMD_T::Integer (&vAi)[3],
typename SIMD_T::Integer (&vBi)[3],
typename SIMD_T::Integer (&vXi)[3],
typename SIMD_T::Integer (&vYi)[3],
Integer<SIMD_T> (&vAi)[3],
Integer<SIMD_T> (&vBi)[3],
Integer<SIMD_T> (&vXi)[3],
Integer<SIMD_T> (&vYi)[3],
uint32_t cwTrisMask,
uint32_t triMask,
uint32_t oneTileMask)
{
// step to pixel center of top-left pixel of the triangle bbox
typename SIMD_T::Integer vTopLeftX = SIMD_T::template slli_epi32<ER_SIMD_TILE_X_SHIFT + FIXED_POINT_SHIFT>(er_bbox.xmin);
Integer<SIMD_T> vTopLeftX = SIMD_T::template slli_epi32<ER_SIMD_TILE_X_SHIFT + FIXED_POINT_SHIFT>(er_bbox.xmin);
vTopLeftX = SIMD_T::add_epi32(vTopLeftX, SIMD_T::set1_epi32(FIXED_POINT_SCALE / 2));

typename SIMD_T::Integer vTopLeftY = SIMD_T::template slli_epi32<ER_SIMD_TILE_Y_SHIFT + FIXED_POINT_SHIFT>(er_bbox.ymin);
Integer<SIMD_T> vTopLeftY = SIMD_T::template slli_epi32<ER_SIMD_TILE_Y_SHIFT + FIXED_POINT_SHIFT>(er_bbox.ymin);
vTopLeftY = SIMD_T::add_epi32(vTopLeftY, SIMD_T::set1_epi32(FIXED_POINT_SCALE / 2));

// negate A and B for CW tris
typename SIMD_T::Integer vNegA0 = SIMD_T::mullo_epi32(vAi[0], SIMD_T::set1_epi32(-1));
typename SIMD_T::Integer vNegA1 = SIMD_T::mullo_epi32(vAi[1], SIMD_T::set1_epi32(-1));
typename SIMD_T::Integer vNegA2 = SIMD_T::mullo_epi32(vAi[2], SIMD_T::set1_epi32(-1));
typename SIMD_T::Integer vNegB0 = SIMD_T::mullo_epi32(vBi[0], SIMD_T::set1_epi32(-1));
typename SIMD_T::Integer vNegB1 = SIMD_T::mullo_epi32(vBi[1], SIMD_T::set1_epi32(-1));
typename SIMD_T::Integer vNegB2 = SIMD_T::mullo_epi32(vBi[2], SIMD_T::set1_epi32(-1));
Integer<SIMD_T> vNegA0 = SIMD_T::mullo_epi32(vAi[0], SIMD_T::set1_epi32(-1));
Integer<SIMD_T> vNegA1 = SIMD_T::mullo_epi32(vAi[1], SIMD_T::set1_epi32(-1));
Integer<SIMD_T> vNegA2 = SIMD_T::mullo_epi32(vAi[2], SIMD_T::set1_epi32(-1));
Integer<SIMD_T> vNegB0 = SIMD_T::mullo_epi32(vBi[0], SIMD_T::set1_epi32(-1));
Integer<SIMD_T> vNegB1 = SIMD_T::mullo_epi32(vBi[1], SIMD_T::set1_epi32(-1));
Integer<SIMD_T> vNegB2 = SIMD_T::mullo_epi32(vBi[2], SIMD_T::set1_epi32(-1));

RDTSC_EVENT(FEEarlyRastEnter, _mm_popcnt_u32(oneTileMask & triMask), 0);

typename SIMD_T::Integer vShiftCntrl = EarlyRastHelper <SIMD_T>::InitShiftCntrl();
typename SIMD_T::Integer vCwTris = SIMD_T::set1_epi32(cwTrisMask);
typename SIMD_T::Integer vMask = SIMD_T::sllv_epi32(vCwTris, vShiftCntrl);
Integer<SIMD_T> vShiftCntrl = EarlyRastHelper <SIMD_T>::InitShiftCntrl();
Integer<SIMD_T> vCwTris = SIMD_T::set1_epi32(cwTrisMask);
Integer<SIMD_T> vMask = SIMD_T::sllv_epi32(vCwTris, vShiftCntrl);

vAi[0] = SIMD_T::castps_si(SIMD_T::blendv_ps(SIMD_T::castsi_ps(vAi[0]), SIMD_T::castsi_ps(vNegA0), SIMD_T::castsi_ps(vMask)));
vAi[1] = SIMD_T::castps_si(SIMD_T::blendv_ps(SIMD_T::castsi_ps(vAi[1]), SIMD_T::castsi_ps(vNegA1), SIMD_T::castsi_ps(vMask)));
@@ -364,34 +364,34 @@ uint32_t SIMDCALL EarlyRasterizer(
vBi[2] = SIMD_T::castps_si(SIMD_T::blendv_ps(SIMD_T::castsi_ps(vBi[2]), SIMD_T::castsi_ps(vNegB2), SIMD_T::castsi_ps(vMask)));

// evaluate edge equations at top-left pixel
typename SIMD_T::Integer vDeltaX0 = SIMD_T::sub_epi32(vTopLeftX, vXi[0]);
typename SIMD_T::Integer vDeltaX1 = SIMD_T::sub_epi32(vTopLeftX, vXi[1]);
typename SIMD_T::Integer vDeltaX2 = SIMD_T::sub_epi32(vTopLeftX, vXi[2]);
Integer<SIMD_T> vDeltaX0 = SIMD_T::sub_epi32(vTopLeftX, vXi[0]);
Integer<SIMD_T> vDeltaX1 = SIMD_T::sub_epi32(vTopLeftX, vXi[1]);
Integer<SIMD_T> vDeltaX2 = SIMD_T::sub_epi32(vTopLeftX, vXi[2]);

typename SIMD_T::Integer vDeltaY0 = SIMD_T::sub_epi32(vTopLeftY, vYi[0]);
typename SIMD_T::Integer vDeltaY1 = SIMD_T::sub_epi32(vTopLeftY, vYi[1]);
typename SIMD_T::Integer vDeltaY2 = SIMD_T::sub_epi32(vTopLeftY, vYi[2]);
Integer<SIMD_T> vDeltaY0 = SIMD_T::sub_epi32(vTopLeftY, vYi[0]);
Integer<SIMD_T> vDeltaY1 = SIMD_T::sub_epi32(vTopLeftY, vYi[1]);
Integer<SIMD_T> vDeltaY2 = SIMD_T::sub_epi32(vTopLeftY, vYi[2]);

typename SIMD_T::Integer vAX0 = SIMD_T::mullo_epi32(vAi[0], vDeltaX0);
typename SIMD_T::Integer vAX1 = SIMD_T::mullo_epi32(vAi[1], vDeltaX1);
typename SIMD_T::Integer vAX2 = SIMD_T::mullo_epi32(vAi[2], vDeltaX2);
Integer<SIMD_T> vAX0 = SIMD_T::mullo_epi32(vAi[0], vDeltaX0);
Integer<SIMD_T> vAX1 = SIMD_T::mullo_epi32(vAi[1], vDeltaX1);
Integer<SIMD_T> vAX2 = SIMD_T::mullo_epi32(vAi[2], vDeltaX2);

typename SIMD_T::Integer vBY0 = SIMD_T::mullo_epi32(vBi[0], vDeltaY0);
typename SIMD_T::Integer vBY1 = SIMD_T::mullo_epi32(vBi[1], vDeltaY1);
typename SIMD_T::Integer vBY2 = SIMD_T::mullo_epi32(vBi[2], vDeltaY2);
Integer<SIMD_T> vBY0 = SIMD_T::mullo_epi32(vBi[0], vDeltaY0);
Integer<SIMD_T> vBY1 = SIMD_T::mullo_epi32(vBi[1], vDeltaY1);
Integer<SIMD_T> vBY2 = SIMD_T::mullo_epi32(vBi[2], vDeltaY2);

typename SIMD_T::Integer vEdge0 = SIMD_T::add_epi32(vAX0, vBY0);
typename SIMD_T::Integer vEdge1 = SIMD_T::add_epi32(vAX1, vBY1);
typename SIMD_T::Integer vEdge2 = SIMD_T::add_epi32(vAX2, vBY2);
Integer<SIMD_T> vEdge0 = SIMD_T::add_epi32(vAX0, vBY0);
Integer<SIMD_T> vEdge1 = SIMD_T::add_epi32(vAX1, vBY1);
Integer<SIMD_T> vEdge2 = SIMD_T::add_epi32(vAX2, vBY2);

vEdge0 = SIMD_T::template srai_epi32<FIXED_POINT_SHIFT>(vEdge0);
vEdge1 = SIMD_T::template srai_epi32<FIXED_POINT_SHIFT>(vEdge1);
vEdge2 = SIMD_T::template srai_epi32<FIXED_POINT_SHIFT>(vEdge2);

// top left rule
typename SIMD_T::Integer vEdgeAdjust0 = SIMD_T::sub_epi32(vEdge0, SIMD_T::set1_epi32(1));
typename SIMD_T::Integer vEdgeAdjust1 = SIMD_T::sub_epi32(vEdge1, SIMD_T::set1_epi32(1));
typename SIMD_T::Integer vEdgeAdjust2 = SIMD_T::sub_epi32(vEdge2, SIMD_T::set1_epi32(1));
Integer<SIMD_T> vEdgeAdjust0 = SIMD_T::sub_epi32(vEdge0, SIMD_T::set1_epi32(1));
Integer<SIMD_T> vEdgeAdjust1 = SIMD_T::sub_epi32(vEdge1, SIMD_T::set1_epi32(1));
Integer<SIMD_T> vEdgeAdjust2 = SIMD_T::sub_epi32(vEdge2, SIMD_T::set1_epi32(1));

// vA < 0
vEdge0 = SIMD_T::castps_si(SIMD_T::blendv_ps(SIMD_T::castsi_ps(vEdge0), SIMD_T::castsi_ps(vEdgeAdjust0), SIMD_T::castsi_ps(vAi[0])));
@@ -399,9 +399,9 @@ uint32_t SIMDCALL EarlyRasterizer(
vEdge2 = SIMD_T::castps_si(SIMD_T::blendv_ps(SIMD_T::castsi_ps(vEdge2), SIMD_T::castsi_ps(vEdgeAdjust2), SIMD_T::castsi_ps(vAi[2])));

// vA == 0 && vB < 0
typename SIMD_T::Integer vCmp0 = SIMD_T::cmpeq_epi32(vAi[0], SIMD_T::setzero_si());
typename SIMD_T::Integer vCmp1 = SIMD_T::cmpeq_epi32(vAi[1], SIMD_T::setzero_si());
typename SIMD_T::Integer vCmp2 = SIMD_T::cmpeq_epi32(vAi[2], SIMD_T::setzero_si());
Integer<SIMD_T> vCmp0 = SIMD_T::cmpeq_epi32(vAi[0], SIMD_T::setzero_si());
Integer<SIMD_T> vCmp1 = SIMD_T::cmpeq_epi32(vAi[1], SIMD_T::setzero_si());
Integer<SIMD_T> vCmp2 = SIMD_T::cmpeq_epi32(vAi[2], SIMD_T::setzero_si());

vCmp0 = SIMD_T::and_si(vCmp0, vBi[0]);
vCmp1 = SIMD_T::and_si(vCmp1, vBi[1]);
@@ -415,28 +415,28 @@ uint32_t SIMDCALL EarlyRasterizer(
#if ER_SIMD_TILE_X_DIM == 4 && ER_SIMD_TILE_Y_DIM == 4
// Go down
// coverage pixel 0
typename SIMD_T::Integer vMask0 = SIMD_T::and_si(vEdge0, vEdge1);
Integer<SIMD_T> vMask0 = SIMD_T::and_si(vEdge0, vEdge1);
vMask0 = SIMD_T::and_si(vMask0, vEdge2);

// coverage pixel 1
typename SIMD_T::Integer vEdge0N = SIMD_T::add_epi32(vEdge0, vBi[0]);
typename SIMD_T::Integer vEdge1N = SIMD_T::add_epi32(vEdge1, vBi[1]);
typename SIMD_T::Integer vEdge2N = SIMD_T::add_epi32(vEdge2, vBi[2]);
typename SIMD_T::Integer vMask1 = SIMD_T::and_si(vEdge0N, vEdge1N);
Integer<SIMD_T> vEdge0N = SIMD_T::add_epi32(vEdge0, vBi[0]);
Integer<SIMD_T> vEdge1N = SIMD_T::add_epi32(vEdge1, vBi[1]);
Integer<SIMD_T> vEdge2N = SIMD_T::add_epi32(vEdge2, vBi[2]);
Integer<SIMD_T> vMask1 = SIMD_T::and_si(vEdge0N, vEdge1N);
vMask1 = SIMD_T::and_si(vMask1, vEdge2N);

// coverage pixel 2
vEdge0N = SIMD_T::add_epi32(vEdge0N, vBi[0]);
vEdge1N = SIMD_T::add_epi32(vEdge1N, vBi[1]);
vEdge2N = SIMD_T::add_epi32(vEdge2N, vBi[2]);
typename SIMD_T::Integer vMask2 = SIMD_T::and_si(vEdge0N, vEdge1N);
Integer<SIMD_T> vMask2 = SIMD_T::and_si(vEdge0N, vEdge1N);
vMask2 = SIMD_T::and_si(vMask2, vEdge2N);

// coverage pixel 3
vEdge0N = SIMD_T::add_epi32(vEdge0N, vBi[0]);
vEdge1N = SIMD_T::add_epi32(vEdge1N, vBi[1]);
vEdge2N = SIMD_T::add_epi32(vEdge2N, vBi[2]);
typename SIMD_T::Integer vMask3 = SIMD_T::and_si(vEdge0N, vEdge1N);
Integer<SIMD_T> vMask3 = SIMD_T::and_si(vEdge0N, vEdge1N);
vMask3 = SIMD_T::and_si(vMask3, vEdge2N);

// One step to the right and then up
@@ -445,31 +445,31 @@ uint32_t SIMDCALL EarlyRasterizer(
vEdge0N = SIMD_T::add_epi32(vEdge0N, vAi[0]);
vEdge1N = SIMD_T::add_epi32(vEdge1N, vAi[1]);
vEdge2N = SIMD_T::add_epi32(vEdge2N, vAi[2]);
typename SIMD_T::Integer vMask4 = SIMD_T::and_si(vEdge0N, vEdge1N);
Integer<SIMD_T> vMask4 = SIMD_T::and_si(vEdge0N, vEdge1N);
vMask4 = SIMD_T::and_si(vMask4, vEdge2N);

// coverage pixel 5
vEdge0N = SIMD_T::sub_epi32(vEdge0N, vBi[0]);
vEdge1N = SIMD_T::sub_epi32(vEdge1N, vBi[1]);
vEdge2N = SIMD_T::sub_epi32(vEdge2N, vBi[2]);
typename SIMD_T::Integer vMask5 = SIMD_T::and_si(vEdge0N, vEdge1N);
Integer<SIMD_T> vMask5 = SIMD_T::and_si(vEdge0N, vEdge1N);
vMask5 = SIMD_T::and_si(vMask5, vEdge2N);

// coverage pixel 6
vEdge0N = SIMD_T::sub_epi32(vEdge0N, vBi[0]);
vEdge1N = SIMD_T::sub_epi32(vEdge1N, vBi[1]);
vEdge2N = SIMD_T::sub_epi32(vEdge2N, vBi[2]);
typename SIMD_T::Integer vMask6 = SIMD_T::and_si(vEdge0N, vEdge1N);
Integer<SIMD_T> vMask6 = SIMD_T::and_si(vEdge0N, vEdge1N);
vMask6 = SIMD_T::and_si(vMask6, vEdge2N);

// coverage pixel 7
vEdge0N = SIMD_T::sub_epi32(vEdge0N, vBi[0]);
vEdge1N = SIMD_T::sub_epi32(vEdge1N, vBi[1]);
vEdge2N = SIMD_T::sub_epi32(vEdge2N, vBi[2]);
typename SIMD_T::Integer vMask7 = SIMD_T::and_si(vEdge0N, vEdge1N);
Integer<SIMD_T> vMask7 = SIMD_T::and_si(vEdge0N, vEdge1N);
vMask7 = SIMD_T::and_si(vMask7, vEdge2N);

typename SIMD_T::Integer vLit1 = SIMD_T::or_si(vMask0, vMask1);
Integer<SIMD_T> vLit1 = SIMD_T::or_si(vMask0, vMask1);
vLit1 = SIMD_T::or_si(vLit1, vMask2);
vLit1 = SIMD_T::or_si(vLit1, vMask3);
vLit1 = SIMD_T::or_si(vLit1, vMask4);
@@ -537,7 +537,7 @@ uint32_t SIMDCALL EarlyRasterizer(
vMask7 = SIMD_T::and_si(vEdge0N, vEdge1N);
vMask7 = SIMD_T::and_si(vMask7, vEdge2N);

typename SIMD_T::Integer vLit2 = SIMD_T::or_si(vMask0, vMask1);
Integer<SIMD_T> vLit2 = SIMD_T::or_si(vMask0, vMask1);
vLit2 = SIMD_T::or_si(vLit2, vMask2);
vLit2 = SIMD_T::or_si(vLit2, vMask3);
vLit2 = SIMD_T::or_si(vLit2, vMask4);
@@ -545,24 +545,24 @@ uint32_t SIMDCALL EarlyRasterizer(
vLit2 = SIMD_T::or_si(vLit2, vMask6);
vLit2 = SIMD_T::or_si(vLit2, vMask7);

typename SIMD_T::Integer vLit = SIMD_T::or_si(vLit1, vLit2);
Integer<SIMD_T> vLit = SIMD_T::or_si(vLit1, vLit2);

#else
// Generic algorithm sweeping in row by row order
typename SIMD_T::Integer vRowMask[ER_SIMD_TILE_Y_DIM];
Integer<SIMD_T> vRowMask[ER_SIMD_TILE_Y_DIM];

typename SIMD_T::Integer vEdge0N = vEdge0;
typename SIMD_T::Integer vEdge1N = vEdge1;
typename SIMD_T::Integer vEdge2N = vEdge2;
Integer<SIMD_T> vEdge0N = vEdge0;
Integer<SIMD_T> vEdge1N = vEdge1;
Integer<SIMD_T> vEdge2N = vEdge2;

for (uint32_t row = 0; row < ER_SIMD_TILE_Y_DIM; row++)
{
// Store edge values at the beginning of the row
typename SIMD_T::Integer vRowEdge0 = vEdge0N;
typename SIMD_T::Integer vRowEdge1 = vEdge1N;
typename SIMD_T::Integer vRowEdge2 = vEdge2N;
Integer<SIMD_T> vRowEdge0 = vEdge0N;
Integer<SIMD_T> vRowEdge1 = vEdge1N;
Integer<SIMD_T> vRowEdge2 = vEdge2N;

typename SIMD_T::Integer vColMask[ER_SIMD_TILE_X_DIM];
Integer<SIMD_T> vColMask[ER_SIMD_TILE_X_DIM];

for (uint32_t col = 0; col < ER_SIMD_TILE_X_DIM; col++)
{
@@ -589,7 +589,7 @@ uint32_t SIMDCALL EarlyRasterizer(
}

// compress all masks
typename SIMD_T::Integer vLit = vRowMask[0];
Integer<SIMD_T> vLit = vRowMask[0];
for (uint32_t row = 1; row < ER_SIMD_TILE_Y_DIM; row++)
{
vLit = SIMD_T::or_si(vLit, vRowMask[row]);
@@ -627,11 +627,11 @@ void SIMDCALL BinTrianglesImpl(
DRAW_CONTEXT *pDC,
PA_STATE &pa,
uint32_t workerId,
typename SIMD_T::Vec4 tri[3],
Vec4<SIMD_T> tri[3],
uint32_t triMask,
typename SIMD_T::Integer const &primID,
typename SIMD_T::Integer const &viewportIdx,
typename SIMD_T::Integer const &rtIdx)
Integer<SIMD_T> const &primID,
Integer<SIMD_T> const &viewportIdx,
Integer<SIMD_T> const &rtIdx)
{
const uint32_t *aRTAI = reinterpret_cast<const uint32_t *>(&rtIdx);

@@ -643,9 +643,9 @@ void SIMDCALL BinTrianglesImpl(

MacroTileMgr *pTileMgr = pDC->pTileMgr;

typename SIMD_T::Float vRecipW0 = SIMD_T::set1_ps(1.0f);
typename SIMD_T::Float vRecipW1 = SIMD_T::set1_ps(1.0f);
typename SIMD_T::Float vRecipW2 = SIMD_T::set1_ps(1.0f);
Float<SIMD_T> vRecipW0 = SIMD_T::set1_ps(1.0f);
Float<SIMD_T> vRecipW1 = SIMD_T::set1_ps(1.0f);
Float<SIMD_T> vRecipW2 = SIMD_T::set1_ps(1.0f);

if (feState.vpTransformDisable)
{
@@ -685,7 +685,7 @@ void SIMDCALL BinTrianglesImpl(
}

// Adjust for pixel center location
typename SIMD_T::Float offset = SwrPixelOffsets<SIMD_T>::GetOffset(rastState.pixelLocation);
Float<SIMD_T> offset = SwrPixelOffsets<SIMD_T>::GetOffset(rastState.pixelLocation);

tri[0].x = SIMD_T::add_ps(tri[0].x, offset);
tri[0].y = SIMD_T::add_ps(tri[0].y, offset);
@@ -697,15 +697,15 @@ void SIMDCALL BinTrianglesImpl(
tri[2].y = SIMD_T::add_ps(tri[2].y, offset);

// Set vXi, vYi to required fixed point precision
typename SIMD_T::Integer vXi[3], vYi[3];
Integer<SIMD_T> vXi[3], vYi[3];
FPToFixedPoint<SIMD_T>(tri, vXi, vYi);

// triangle setup
typename SIMD_T::Integer vAi[3], vBi[3];
Integer<SIMD_T> vAi[3], vBi[3];
triangleSetupABIntVertical(vXi, vYi, vAi, vBi);

// determinant
typename SIMD_T::Integer vDet[2];
Integer<SIMD_T> vDet[2];
calcDeterminantIntVertical(vAi, vBi, vDet);

// cull zero area
@@ -774,14 +774,14 @@ void SIMDCALL BinTrianglesImpl(
if (cullZeroAreaMask > 0)
{
// e0 = v1-v0
const typename SIMD_T::Integer x0x1Mask = SIMD_T::cmpeq_epi32(vXi[0], vXi[1]);
const typename SIMD_T::Integer y0y1Mask = SIMD_T::cmpeq_epi32(vYi[0], vYi[1]);
const Integer<SIMD_T> x0x1Mask = SIMD_T::cmpeq_epi32(vXi[0], vXi[1]);
const Integer<SIMD_T> y0y1Mask = SIMD_T::cmpeq_epi32(vYi[0], vYi[1]);

uint32_t e0Mask = SIMD_T::movemask_ps(SIMD_T::castsi_ps(SIMD_T::and_si(x0x1Mask, y0y1Mask)));

// e1 = v2-v1
const typename SIMD_T::Integer x1x2Mask = SIMD_T::cmpeq_epi32(vXi[1], vXi[2]);
const typename SIMD_T::Integer y1y2Mask = SIMD_T::cmpeq_epi32(vYi[1], vYi[2]);
const Integer<SIMD_T> x1x2Mask = SIMD_T::cmpeq_epi32(vXi[1], vXi[2]);
const Integer<SIMD_T> y1y2Mask = SIMD_T::cmpeq_epi32(vYi[1], vYi[2]);

uint32_t e1Mask = SIMD_T::movemask_ps(SIMD_T::castsi_ps(SIMD_T::and_si(x1x2Mask, y1y2Mask)));

@@ -836,19 +836,19 @@ void SIMDCALL BinTrianglesImpl(
int cullCenterMask;

{
typename SIMD_T::Integer xmin = SIMD_T::add_epi32(bbox.xmin, SIMD_T::set1_epi32(127));
Integer<SIMD_T> xmin = SIMD_T::add_epi32(bbox.xmin, SIMD_T::set1_epi32(127));
xmin = SIMD_T::and_si(xmin, SIMD_T::set1_epi32(~255));
typename SIMD_T::Integer xmax = SIMD_T::add_epi32(bbox.xmax, SIMD_T::set1_epi32(128));
Integer<SIMD_T> xmax = SIMD_T::add_epi32(bbox.xmax, SIMD_T::set1_epi32(128));
xmax = SIMD_T::and_si(xmax, SIMD_T::set1_epi32(~255));

typename SIMD_T::Integer vMaskH = SIMD_T::cmpeq_epi32(xmin, xmax);
Integer<SIMD_T> vMaskH = SIMD_T::cmpeq_epi32(xmin, xmax);

typename SIMD_T::Integer ymin = SIMD_T::add_epi32(bbox.ymin, SIMD_T::set1_epi32(127));
Integer<SIMD_T> ymin = SIMD_T::add_epi32(bbox.ymin, SIMD_T::set1_epi32(127));
ymin = SIMD_T::and_si(ymin, SIMD_T::set1_epi32(~255));
typename SIMD_T::Integer ymax = SIMD_T::add_epi32(bbox.ymax, SIMD_T::set1_epi32(128));
Integer<SIMD_T> ymax = SIMD_T::add_epi32(bbox.ymax, SIMD_T::set1_epi32(128));
ymax = SIMD_T::and_si(ymax, SIMD_T::set1_epi32(~255));

typename SIMD_T::Integer vMaskV = SIMD_T::cmpeq_epi32(ymin, ymax);
Integer<SIMD_T> vMaskV = SIMD_T::cmpeq_epi32(ymin, ymax);

vMaskV = SIMD_T::or_si(vMaskH, vMaskV);
cullCenterMask = SIMD_T::movemask_ps(SIMD_T::castsi_ps(vMaskV));
@@ -866,7 +866,7 @@ void SIMDCALL BinTrianglesImpl(
// Gather the AOS effective scissor rects based on the per-prim VP index.
/// @todo: Look at speeding this up -- weigh against corresponding costs in rasterizer.
{
typename SIMD_T::Integer scisXmin, scisYmin, scisXmax, scisYmax;
Integer<SIMD_T> scisXmin, scisYmin, scisXmax, scisYmax;
if (pa.viewportArrayActive)

{
@@ -895,18 +895,18 @@ void SIMDCALL BinTrianglesImpl(
// in the case where a degenerate triangle is on a scissor edge, we need to make sure the primitive bbox has
// some area. Bump the xmax/ymax edges out

typename SIMD_T::Integer topEqualsBottom = SIMD_T::cmpeq_epi32(bbox.ymin, bbox.ymax);
Integer<SIMD_T> topEqualsBottom = SIMD_T::cmpeq_epi32(bbox.ymin, bbox.ymax);
bbox.ymax = SIMD_T::blendv_epi32(bbox.ymax, SIMD_T::add_epi32(bbox.ymax, SIMD_T::set1_epi32(1)), topEqualsBottom);

typename SIMD_T::Integer leftEqualsRight = SIMD_T::cmpeq_epi32(bbox.xmin, bbox.xmax);
Integer<SIMD_T> leftEqualsRight = SIMD_T::cmpeq_epi32(bbox.xmin, bbox.xmax);
bbox.xmax = SIMD_T::blendv_epi32(bbox.xmax, SIMD_T::add_epi32(bbox.xmax, SIMD_T::set1_epi32(1)), leftEqualsRight);
}

// Cull tris completely outside scissor
{
typename SIMD_T::Integer maskOutsideScissorX = SIMD_T::cmpgt_epi32(bbox.xmin, bbox.xmax);
typename SIMD_T::Integer maskOutsideScissorY = SIMD_T::cmpgt_epi32(bbox.ymin, bbox.ymax);
typename SIMD_T::Integer maskOutsideScissorXY = SIMD_T::or_si(maskOutsideScissorX, maskOutsideScissorY);
Integer<SIMD_T> maskOutsideScissorX = SIMD_T::cmpgt_epi32(bbox.xmin, bbox.xmax);
Integer<SIMD_T> maskOutsideScissorY = SIMD_T::cmpgt_epi32(bbox.ymin, bbox.ymax);
Integer<SIMD_T> maskOutsideScissorXY = SIMD_T::or_si(maskOutsideScissorX, maskOutsideScissorY);
uint32_t maskOutsideScissor = SIMD_T::movemask_ps(SIMD_T::castsi_ps(maskOutsideScissorXY));
triMask = triMask & ~maskOutsideScissor;
}
@@ -924,8 +924,8 @@ void SIMDCALL BinTrianglesImpl(
er_bbox.ymin = SIMD_T::template srai_epi32<ER_SIMD_TILE_Y_SHIFT + FIXED_POINT_SHIFT>(bbox.ymin);
er_bbox.ymax = SIMD_T::template srai_epi32<ER_SIMD_TILE_Y_SHIFT + FIXED_POINT_SHIFT>(bbox.ymax);

typename SIMD_T::Integer vTileX = SIMD_T::cmpeq_epi32(er_bbox.xmin, er_bbox.xmax);
typename SIMD_T::Integer vTileY = SIMD_T::cmpeq_epi32(er_bbox.ymin, er_bbox.ymax);
Integer<SIMD_T> vTileX = SIMD_T::cmpeq_epi32(er_bbox.xmin, er_bbox.xmax);
Integer<SIMD_T> vTileY = SIMD_T::cmpeq_epi32(er_bbox.ymin, er_bbox.ymax);

// Take only triangles that fit into ER tile
uint32_t oneTileMask = triMask & SIMD_T::movemask_ps(SIMD_T::castsi_ps(SIMD_T::and_si(vTileX, vTileY)));
@@ -958,8 +958,8 @@ endBinTriangles:
{
// Simple non-conformant wireframe mode, useful for debugging
// construct 3 SIMD lines out of the triangle and call the line binner for each SIMD
typename SIMD_T::Vec4 line[2];
typename SIMD_T::Float recipW[2];
Vec4<SIMD_T> line[2];
Float<SIMD_T> recipW[2];

line[0] = tri[0];
line[1] = tri[1];
@@ -1004,10 +1004,10 @@ endBinTriangles:

OSALIGNSIMD16(uint32_t) aMTLeft[SIMD_WIDTH], aMTRight[SIMD_WIDTH], aMTTop[SIMD_WIDTH], aMTBottom[SIMD_WIDTH];

SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMTLeft), bbox.xmin);
SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMTRight), bbox.xmax);
SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMTTop), bbox.ymin);
SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMTBottom), bbox.ymax);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMTLeft), bbox.xmin);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMTRight), bbox.xmax);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMTTop), bbox.ymin);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMTBottom), bbox.ymax);

// transpose verts needed for backend
/// @todo modify BE to take non-transformed verts
@@ -1173,15 +1173,15 @@ void BinPostSetupPointsImpl(
DRAW_CONTEXT *pDC,
PA_STATE &pa,
uint32_t workerId,
typename SIMD_T::Vec4 prim[],
Vec4<SIMD_T> prim[],
uint32_t primMask,
typename SIMD_T::Integer const &primID,
typename SIMD_T::Integer const &viewportIdx,
typename SIMD_T::Integer const &rtIdx)
Integer<SIMD_T> const &primID,
Integer<SIMD_T> const &viewportIdx,
Integer<SIMD_T> const &rtIdx)
{
RDTSC_BEGIN(FEBinPoints, pDC->drawId);

typename SIMD_T::Vec4 &primVerts = prim[0];
Vec4<SIMD_T> &primVerts = prim[0];

const API_STATE& state = GetApiState(pDC);
const SWR_RASTSTATE& rastState = state.rastState;
@@ -1192,7 +1192,7 @@ void BinPostSetupPointsImpl(
state.backendState.swizzleEnable, state.backendState.constantInterpolationMask);

// convert to fixed point
typename SIMD_T::Integer vXi, vYi;
Integer<SIMD_T> vXi, vYi;

vXi = fpToFixedPointVertical<SIMD_T>(primVerts.x);
vYi = fpToFixedPointVertical<SIMD_T>(primVerts.y);
@@ -1208,36 +1208,36 @@ void BinPostSetupPointsImpl(
primMask &= ~SIMD_T::movemask_ps(SIMD_T::castsi_ps(vYi));

// compute macro tile coordinates
typename SIMD_T::Integer macroX = SIMD_T::template srai_epi32<KNOB_MACROTILE_X_DIM_FIXED_SHIFT>(vXi);
typename SIMD_T::Integer macroY = SIMD_T::template srai_epi32<KNOB_MACROTILE_Y_DIM_FIXED_SHIFT>(vYi);
Integer<SIMD_T> macroX = SIMD_T::template srai_epi32<KNOB_MACROTILE_X_DIM_FIXED_SHIFT>(vXi);
Integer<SIMD_T> macroY = SIMD_T::template srai_epi32<KNOB_MACROTILE_Y_DIM_FIXED_SHIFT>(vYi);

OSALIGNSIMD16(uint32_t) aMacroX[SIMD_WIDTH], aMacroY[SIMD_WIDTH];

SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMacroX), macroX);
SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMacroY), macroY);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMacroX), macroX);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMacroY), macroY);

// compute raster tile coordinates
typename SIMD_T::Integer rasterX = SIMD_T::template srai_epi32<KNOB_TILE_X_DIM_SHIFT + FIXED_POINT_SHIFT>(vXi);
typename SIMD_T::Integer rasterY = SIMD_T::template srai_epi32<KNOB_TILE_Y_DIM_SHIFT + FIXED_POINT_SHIFT>(vYi);
Integer<SIMD_T> rasterX = SIMD_T::template srai_epi32<KNOB_TILE_X_DIM_SHIFT + FIXED_POINT_SHIFT>(vXi);
Integer<SIMD_T> rasterY = SIMD_T::template srai_epi32<KNOB_TILE_Y_DIM_SHIFT + FIXED_POINT_SHIFT>(vYi);

// compute raster tile relative x,y for coverage mask
typename SIMD_T::Integer tileAlignedX = SIMD_T::template slli_epi32<KNOB_TILE_X_DIM_SHIFT>(rasterX);
typename SIMD_T::Integer tileAlignedY = SIMD_T::template slli_epi32<KNOB_TILE_Y_DIM_SHIFT>(rasterY);
Integer<SIMD_T> tileAlignedX = SIMD_T::template slli_epi32<KNOB_TILE_X_DIM_SHIFT>(rasterX);
Integer<SIMD_T> tileAlignedY = SIMD_T::template slli_epi32<KNOB_TILE_Y_DIM_SHIFT>(rasterY);

typename SIMD_T::Integer tileRelativeX = SIMD_T::sub_epi32(SIMD_T::template srai_epi32<FIXED_POINT_SHIFT>(vXi), tileAlignedX);
typename SIMD_T::Integer tileRelativeY = SIMD_T::sub_epi32(SIMD_T::template srai_epi32<FIXED_POINT_SHIFT>(vYi), tileAlignedY);
Integer<SIMD_T> tileRelativeX = SIMD_T::sub_epi32(SIMD_T::template srai_epi32<FIXED_POINT_SHIFT>(vXi), tileAlignedX);
Integer<SIMD_T> tileRelativeY = SIMD_T::sub_epi32(SIMD_T::template srai_epi32<FIXED_POINT_SHIFT>(vYi), tileAlignedY);

OSALIGNSIMD16(uint32_t) aTileRelativeX[SIMD_WIDTH];
OSALIGNSIMD16(uint32_t) aTileRelativeY[SIMD_WIDTH];

SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aTileRelativeX), tileRelativeX);
SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aTileRelativeY), tileRelativeY);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aTileRelativeX), tileRelativeX);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aTileRelativeY), tileRelativeY);

OSALIGNSIMD16(uint32_t) aTileAlignedX[SIMD_WIDTH];
OSALIGNSIMD16(uint32_t) aTileAlignedY[SIMD_WIDTH];

SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aTileAlignedX), tileAlignedX);
SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aTileAlignedY), tileAlignedY);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aTileAlignedX), tileAlignedX);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aTileAlignedY), tileAlignedY);

OSALIGNSIMD16(float) aZ[SIMD_WIDTH];
SIMD_T::store_ps(reinterpret_cast<float *>(aZ), primVerts.z);
@@ -1307,11 +1307,11 @@ void BinPostSetupPointsImpl(
else
{
// non simple points need to be potentially binned to multiple macro tiles
typename SIMD_T::Float vPointSize;
Float<SIMD_T> vPointSize;

if (rastState.pointParam)
{
typename SIMD_T::Vec4 size[3];
Vec4<SIMD_T> size[3];
pa.Assemble(VERTEX_SGV_SLOT, size);
vPointSize = size[0][VERTEX_SGV_POINT_SIZE_COMP];
}
@@ -1326,8 +1326,8 @@ void BinPostSetupPointsImpl(
bbox.xmin = bbox.xmax = vXi;
bbox.ymin = bbox.ymax = vYi;

typename SIMD_T::Float vHalfWidth = SIMD_T::mul_ps(vPointSize, SIMD_T::set1_ps(0.5f));
typename SIMD_T::Integer vHalfWidthi = fpToFixedPointVertical<SIMD_T>(vHalfWidth);
Float<SIMD_T> vHalfWidth = SIMD_T::mul_ps(vPointSize, SIMD_T::set1_ps(0.5f));
Integer<SIMD_T> vHalfWidthi = fpToFixedPointVertical<SIMD_T>(vHalfWidth);

bbox.xmin = SIMD_T::sub_epi32(bbox.xmin, vHalfWidthi);
bbox.xmax = SIMD_T::add_epi32(bbox.xmax, vHalfWidthi);
@@ -1338,7 +1338,7 @@ void BinPostSetupPointsImpl(
// Gather the AOS effective scissor rects based on the per-prim VP index.
/// @todo: Look at speeding this up -- weigh against corresponding costs in rasterizer.
{
typename SIMD_T::Integer scisXmin, scisYmin, scisXmax, scisYmax;
Integer<SIMD_T> scisXmin, scisYmin, scisXmax, scisYmax;

if (pa.viewportArrayActive)
{
@@ -1359,9 +1359,9 @@ void BinPostSetupPointsImpl(
}

// Cull bloated points completely outside scissor
typename SIMD_T::Integer maskOutsideScissorX = SIMD_T::cmpgt_epi32(bbox.xmin, bbox.xmax);
typename SIMD_T::Integer maskOutsideScissorY = SIMD_T::cmpgt_epi32(bbox.ymin, bbox.ymax);
typename SIMD_T::Integer maskOutsideScissorXY = SIMD_T::or_si(maskOutsideScissorX, maskOutsideScissorY);
Integer<SIMD_T> maskOutsideScissorX = SIMD_T::cmpgt_epi32(bbox.xmin, bbox.xmax);
Integer<SIMD_T> maskOutsideScissorY = SIMD_T::cmpgt_epi32(bbox.ymin, bbox.ymax);
Integer<SIMD_T> maskOutsideScissorXY = SIMD_T::or_si(maskOutsideScissorX, maskOutsideScissorY);
uint32_t maskOutsideScissor = SIMD_T::movemask_ps(SIMD_T::castsi_ps(maskOutsideScissorXY));
primMask = primMask & ~maskOutsideScissor;

@@ -1373,10 +1373,10 @@ void BinPostSetupPointsImpl(

OSALIGNSIMD16(uint32_t) aMTLeft[SIMD_WIDTH], aMTRight[SIMD_WIDTH], aMTTop[SIMD_WIDTH], aMTBottom[SIMD_WIDTH];

SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMTLeft), bbox.xmin);
SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMTRight), bbox.xmax);
SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMTTop), bbox.ymin);
SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMTBottom), bbox.ymax);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMTLeft), bbox.xmin);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMTRight), bbox.xmax);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMTTop), bbox.ymin);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMTBottom), bbox.ymax);

// store render target array index
const uint32_t *aRTAI = reinterpret_cast<const uint32_t *>(&rtIdx);
@@ -1477,11 +1477,11 @@ void BinPointsImpl(
DRAW_CONTEXT *pDC,
PA_STATE &pa,
uint32_t workerId,
typename SIMD_T::Vec4 prim[3],
Vec4<SIMD_T> prim[3],
uint32_t primMask,
typename SIMD_T::Integer const &primID,
typename SIMD_T::Integer const &viewportIdx,
typename SIMD_T::Integer const &rtIdx)
Integer<SIMD_T> const &primID,
Integer<SIMD_T> const &viewportIdx,
Integer<SIMD_T> const &rtIdx)
{
const API_STATE& state = GetApiState(pDC);
const SWR_FRONTEND_STATE& feState = state.frontendState;
@@ -1490,7 +1490,7 @@ void BinPointsImpl(
if (!feState.vpTransformDisable)
{
// perspective divide
typename SIMD_T::Float vRecipW0 = SIMD_T::div_ps(SIMD_T::set1_ps(1.0f), prim[0].w);
Float<SIMD_T> vRecipW0 = SIMD_T::div_ps(SIMD_T::set1_ps(1.0f), prim[0].w);

prim[0].x = SIMD_T::mul_ps(prim[0].x, vRecipW0);
prim[0].y = SIMD_T::mul_ps(prim[0].y, vRecipW0);
@@ -1507,7 +1507,7 @@ void BinPointsImpl(
}
}

typename SIMD_T::Float offset = SwrPixelOffsets<SIMD_T>::GetOffset(rastState.pixelLocation);
Float<SIMD_T> offset = SwrPixelOffsets<SIMD_T>::GetOffset(rastState.pixelLocation);

prim[0].x = SIMD_T::add_ps(prim[0].x, offset);
prim[0].y = SIMD_T::add_ps(prim[0].y, offset);
@@ -1580,12 +1580,12 @@ void BinPostSetupLinesImpl(
DRAW_CONTEXT *pDC,
PA_STATE &pa,
uint32_t workerId,
typename SIMD_T::Vec4 prim[],
typename SIMD_T::Float recipW[],
Vec4<SIMD_T> prim[],
Float<SIMD_T> recipW[],
uint32_t primMask,
typename SIMD_T::Integer const &primID,
typename SIMD_T::Integer const &viewportIdx,
typename SIMD_T::Integer const &rtIdx)
Integer<SIMD_T> const &primID,
Integer<SIMD_T> const &viewportIdx,
Integer<SIMD_T> const &rtIdx)
{
const uint32_t *aRTAI = reinterpret_cast<const uint32_t *>(&rtIdx);

@@ -1598,11 +1598,11 @@ void BinPostSetupLinesImpl(
PFN_PROCESS_ATTRIBUTES pfnProcessAttribs = GetProcessAttributesFunc(2,
state.backendState.swizzleEnable, state.backendState.constantInterpolationMask);

typename SIMD_T::Float &vRecipW0 = recipW[0];
typename SIMD_T::Float &vRecipW1 = recipW[1];
Float<SIMD_T> &vRecipW0 = recipW[0];
Float<SIMD_T> &vRecipW1 = recipW[1];

// convert to fixed point
typename SIMD_T::Integer vXi[2], vYi[2];
Integer<SIMD_T> vXi[2], vYi[2];

vXi[0] = fpToFixedPointVertical<SIMD_T>(prim[0].x);
vYi[0] = fpToFixedPointVertical<SIMD_T>(prim[0].y);
@@ -1610,13 +1610,13 @@ void BinPostSetupLinesImpl(
vYi[1] = fpToFixedPointVertical<SIMD_T>(prim[1].y);

// compute x-major vs y-major mask
typename SIMD_T::Integer xLength = SIMD_T::abs_epi32(SIMD_T::sub_epi32(vXi[0], vXi[1]));
typename SIMD_T::Integer yLength = SIMD_T::abs_epi32(SIMD_T::sub_epi32(vYi[0], vYi[1]));
typename SIMD_T::Float vYmajorMask = SIMD_T::castsi_ps(SIMD_T::cmpgt_epi32(yLength, xLength));
Integer<SIMD_T> xLength = SIMD_T::abs_epi32(SIMD_T::sub_epi32(vXi[0], vXi[1]));
Integer<SIMD_T> yLength = SIMD_T::abs_epi32(SIMD_T::sub_epi32(vYi[0], vYi[1]));
Float<SIMD_T> vYmajorMask = SIMD_T::castsi_ps(SIMD_T::cmpgt_epi32(yLength, xLength));
uint32_t yMajorMask = SIMD_T::movemask_ps(vYmajorMask);

// cull zero-length lines
typename SIMD_T::Integer vZeroLengthMask = SIMD_T::cmpeq_epi32(xLength, SIMD_T::setzero_si());
Integer<SIMD_T> vZeroLengthMask = SIMD_T::cmpeq_epi32(xLength, SIMD_T::setzero_si());
vZeroLengthMask = SIMD_T::and_si(vZeroLengthMask, SIMD_T::cmpeq_epi32(yLength, SIMD_T::setzero_si()));

primMask &= ~SIMD_T::movemask_ps(SIMD_T::castsi_ps(vZeroLengthMask));
@@ -1632,8 +1632,8 @@ void BinPostSetupLinesImpl(
bbox.ymax = SIMD_T::max_epi32(vYi[0], vYi[1]);

// bloat bbox by line width along minor axis
typename SIMD_T::Float vHalfWidth = SIMD_T::set1_ps(rastState.lineWidth / 2.0f);
typename SIMD_T::Integer vHalfWidthi = fpToFixedPointVertical<SIMD_T>(vHalfWidth);
Float<SIMD_T> vHalfWidth = SIMD_T::set1_ps(rastState.lineWidth / 2.0f);
Integer<SIMD_T> vHalfWidthi = fpToFixedPointVertical<SIMD_T>(vHalfWidth);

SIMDBBOX_T<SIMD_T> bloatBox;

@@ -1649,7 +1649,7 @@ void BinPostSetupLinesImpl(

// Intersect with scissor/viewport. Subtract 1 ULP in x.8 fixed point since xmax/ymax edge is exclusive.
{
typename SIMD_T::Integer scisXmin, scisYmin, scisXmax, scisYmax;
Integer<SIMD_T> scisXmin, scisYmin, scisXmax, scisYmax;

if (pa.viewportArrayActive)
{
@@ -1671,9 +1671,9 @@ void BinPostSetupLinesImpl(

// Cull prims completely outside scissor
{
typename SIMD_T::Integer maskOutsideScissorX = SIMD_T::cmpgt_epi32(bbox.xmin, bbox.xmax);
typename SIMD_T::Integer maskOutsideScissorY = SIMD_T::cmpgt_epi32(bbox.ymin, bbox.ymax);
typename SIMD_T::Integer maskOutsideScissorXY = SIMD_T::or_si(maskOutsideScissorX, maskOutsideScissorY);
Integer<SIMD_T> maskOutsideScissorX = SIMD_T::cmpgt_epi32(bbox.xmin, bbox.xmax);
Integer<SIMD_T> maskOutsideScissorY = SIMD_T::cmpgt_epi32(bbox.ymin, bbox.ymax);
Integer<SIMD_T> maskOutsideScissorXY = SIMD_T::or_si(maskOutsideScissorX, maskOutsideScissorY);
uint32_t maskOutsideScissor = SIMD_T::movemask_ps(SIMD_T::castsi_ps(maskOutsideScissorXY));
primMask = primMask & ~maskOutsideScissor;
}
@@ -1698,10 +1698,10 @@ void BinPostSetupLinesImpl(

OSALIGNSIMD16(uint32_t) aMTLeft[SIMD_WIDTH], aMTRight[SIMD_WIDTH], aMTTop[SIMD_WIDTH], aMTBottom[SIMD_WIDTH];

SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMTLeft), bbox.xmin);
SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMTRight), bbox.xmax);
SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMTTop), bbox.ymin);
SIMD_T::store_si(reinterpret_cast<typename SIMD_T::Integer *>(aMTBottom), bbox.ymax);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMTLeft), bbox.xmin);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMTRight), bbox.xmax);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMTTop), bbox.ymin);
SIMD_T::store_si(reinterpret_cast<Integer<SIMD_T> *>(aMTBottom), bbox.ymax);

TransposeVertices(vHorizX, prim[0].x, prim[1].x, SIMD_T::setzero_ps());
TransposeVertices(vHorizY, prim[0].y, prim[1].y, SIMD_T::setzero_ps());
@@ -1786,17 +1786,17 @@ void SIMDCALL BinLinesImpl(
DRAW_CONTEXT *pDC,
PA_STATE &pa,
uint32_t workerId,
typename SIMD_T::Vec4 prim[3],
Vec4<SIMD_T> prim[3],
uint32_t primMask,
typename SIMD_T::Integer const &primID,
typename SIMD_T::Integer const &viewportIdx,
typename SIMD_T::Integer const & rtIdx)
Integer<SIMD_T> const &primID,
Integer<SIMD_T> const &viewportIdx,
Integer<SIMD_T> const & rtIdx)
{
const API_STATE& state = GetApiState(pDC);
const SWR_RASTSTATE& rastState = state.rastState;
const SWR_FRONTEND_STATE& feState = state.frontendState;

typename SIMD_T::Float vRecipW[2] = { SIMD_T::set1_ps(1.0f), SIMD_T::set1_ps(1.0f) };
Float<SIMD_T> vRecipW[2] = { SIMD_T::set1_ps(1.0f), SIMD_T::set1_ps(1.0f) };

if (!feState.vpTransformDisable)
{
@@ -1825,7 +1825,7 @@ void SIMDCALL BinLinesImpl(
}

// adjust for pixel center location
typename SIMD_T::Float offset = SwrPixelOffsets<SIMD_T>::GetOffset(rastState.pixelLocation);
Float<SIMD_T> offset = SwrPixelOffsets<SIMD_T>::GetOffset(rastState.pixelLocation);

prim[0].x = SIMD_T::add_ps(prim[0].x, offset);
prim[0].y = SIMD_T::add_ps(prim[0].y, offset);

+ 9
- 9
src/gallium/drivers/swr/rasterizer/core/binner.h Voir le fichier

@@ -38,7 +38,7 @@ template <typename SIMD_T>
struct SwrPixelOffsets
{
public:
INLINE static typename SIMD_T::Float GetOffset(uint32_t loc)
INLINE static Float<SIMD_T> GetOffset(uint32_t loc)
{
SWR_ASSERT(loc <= 1);

@@ -50,7 +50,7 @@ public:
/// @brief Convert the X,Y coords of a triangle to the requested Fixed
/// Point precision from FP32.
template <typename SIMD_T, typename PT = FixedPointTraits<Fixed_16_8>>
INLINE typename SIMD_T::Integer fpToFixedPointVertical(const typename SIMD_T::Float &vIn)
INLINE Integer<SIMD_T> fpToFixedPointVertical(const Float<SIMD_T> &vIn)
{
return SIMD_T::cvtps_epi32(SIMD_T::mul_ps(vIn, SIMD_T::set1_ps(PT::ScaleT::value)));
}
@@ -62,7 +62,7 @@ INLINE typename SIMD_T::Integer fpToFixedPointVertical(const typename SIMD_T::Fl
/// @param vXi: fixed point X coords of tri verts
/// @param vYi: fixed point Y coords of tri verts
template <typename SIMD_T>
INLINE static void FPToFixedPoint(const typename SIMD_T::Vec4 *const tri, typename SIMD_T::Integer(&vXi)[3], typename SIMD_T::Integer(&vYi)[3])
INLINE static void FPToFixedPoint(const Vec4<SIMD_T> *const tri, Integer<SIMD_T>(&vXi)[3], Integer<SIMD_T>(&vYi)[3])
{
vXi[0] = fpToFixedPointVertical<SIMD_T>(tri[0].x);
vYi[0] = fpToFixedPointVertical<SIMD_T>(tri[0].y);
@@ -81,24 +81,24 @@ INLINE static void FPToFixedPoint(const typename SIMD_T::Vec4 *const tri, typena
/// *Note*: expects vX, vY to be in the correct precision for the type
/// of rasterization. This avoids unnecessary FP->fixed conversions.
template <typename SIMD_T, typename CT>
INLINE void calcBoundingBoxIntVertical(const typename SIMD_T::Integer(&vX)[3], const typename SIMD_T::Integer(&vY)[3], SIMDBBOX_T<SIMD_T> &bbox)
INLINE void calcBoundingBoxIntVertical(const Integer<SIMD_T>(&vX)[3], const Integer<SIMD_T>(&vY)[3], SIMDBBOX_T<SIMD_T> &bbox)
{
typename SIMD_T::Integer vMinX = vX[0];
Integer<SIMD_T> vMinX = vX[0];

vMinX = SIMD_T::min_epi32(vMinX, vX[1]);
vMinX = SIMD_T::min_epi32(vMinX, vX[2]);

typename SIMD_T::Integer vMaxX = vX[0];
Integer<SIMD_T> vMaxX = vX[0];

vMaxX = SIMD_T::max_epi32(vMaxX, vX[1]);
vMaxX = SIMD_T::max_epi32(vMaxX, vX[2]);

typename SIMD_T::Integer vMinY = vY[0];
Integer<SIMD_T> vMinY = vY[0];

vMinY = SIMD_T::min_epi32(vMinY, vY[1]);
vMinY = SIMD_T::min_epi32(vMinY, vY[2]);

typename SIMD_T::Integer vMaxY = vY[0];
Integer<SIMD_T> vMaxY = vY[0];

vMaxY = SIMD_T::max_epi32(vMaxY, vY[1]);
vMaxY = SIMD_T::max_epi32(vMaxY, vY[2]);
@@ -108,7 +108,7 @@ INLINE void calcBoundingBoxIntVertical(const typename SIMD_T::Integer(&vX)[3], c
/// Bounding box needs to be expanded by 1/512 before snapping to 16.8 for conservative rasterization
/// expand bbox by 1/256; coverage will be correctly handled in the rasterizer.

const typename SIMD_T::Integer value = SIMD_T::set1_epi32(CT::BoundingBoxOffsetT::value);
const Integer<SIMD_T> value = SIMD_T::set1_epi32(CT::BoundingBoxOffsetT::value);

vMinX = SIMD_T::sub_epi32(vMinX, value);
vMaxX = SIMD_T::add_epi32(vMaxX, value);

+ 109
- 109
src/gallium/drivers/swr/rasterizer/core/clip.h Voir le fichier

@@ -62,15 +62,15 @@ enum SWR_CLIPCODES
#define GUARDBAND_CLIP_MASK (FRUSTUM_NEAR|FRUSTUM_FAR|GUARDBAND_LEFT|GUARDBAND_TOP|GUARDBAND_RIGHT|GUARDBAND_BOTTOM|NEGW)

template<typename SIMD_T>
void ComputeClipCodes(const API_STATE &state, const typename SIMD_T::Vec4 &vertex, typename SIMD_T::Float &clipCodes, typename SIMD_T::Integer const &viewportIndexes)
void ComputeClipCodes(const API_STATE &state, const Vec4<SIMD_T> &vertex, Float<SIMD_T> &clipCodes, Integer<SIMD_T> const &viewportIndexes)
{
clipCodes = SIMD_T::setzero_ps();

// -w
typename SIMD_T::Float vNegW = SIMD_T::mul_ps(vertex.w,SIMD_T::set1_ps(-1.0f));
Float<SIMD_T> vNegW = SIMD_T::mul_ps(vertex.w,SIMD_T::set1_ps(-1.0f));

// FRUSTUM_LEFT
typename SIMD_T::Float vRes = SIMD_T::cmplt_ps(vertex.x, vNegW);
Float<SIMD_T> vRes = SIMD_T::cmplt_ps(vertex.x, vNegW);
clipCodes = SIMD_T::and_ps(vRes, SIMD_T::castsi_ps(SIMD_T::set1_epi32(FRUSTUM_LEFT)));

// FRUSTUM_TOP
@@ -109,22 +109,22 @@ void ComputeClipCodes(const API_STATE &state, const typename SIMD_T::Vec4 &verte
clipCodes = SIMD_T::or_ps(clipCodes, SIMD_T::and_ps(vRes, SIMD_T::castsi_ps(SIMD_T::set1_epi32(NEGW))));

// GUARDBAND_LEFT
typename SIMD_T::Float gbMult = SIMD_T::mul_ps(vNegW, SIMD_T::template i32gather_ps<typename SIMD_T::ScaleFactor(4)>(&state.gbState.left[0], viewportIndexes));
Float<SIMD_T> gbMult = SIMD_T::mul_ps(vNegW, SIMD_T::template i32gather_ps<ScaleFactor<SIMD_T>(4)>(&state.gbState.left[0], viewportIndexes));
vRes = SIMD_T::cmplt_ps(vertex.x, gbMult);
clipCodes = SIMD_T::or_ps(clipCodes, SIMD_T::and_ps(vRes, SIMD_T::castsi_ps(SIMD_T::set1_epi32(GUARDBAND_LEFT))));

// GUARDBAND_TOP
gbMult = SIMD_T::mul_ps(vNegW, SIMD_T::template i32gather_ps<typename SIMD_T::ScaleFactor(4)>(&state.gbState.top[0], viewportIndexes));
gbMult = SIMD_T::mul_ps(vNegW, SIMD_T::template i32gather_ps<ScaleFactor<SIMD_T>(4)>(&state.gbState.top[0], viewportIndexes));
vRes = SIMD_T::cmplt_ps(vertex.y, gbMult);
clipCodes = SIMD_T::or_ps(clipCodes, SIMD_T::and_ps(vRes, SIMD_T::castsi_ps(SIMD_T::set1_epi32(GUARDBAND_TOP))));

// GUARDBAND_RIGHT
gbMult = SIMD_T::mul_ps(vertex.w, SIMD_T::template i32gather_ps<typename SIMD_T::ScaleFactor(4)>(&state.gbState.right[0], viewportIndexes));
gbMult = SIMD_T::mul_ps(vertex.w, SIMD_T::template i32gather_ps<ScaleFactor<SIMD_T>(4)>(&state.gbState.right[0], viewportIndexes));
vRes = SIMD_T::cmpgt_ps(vertex.x, gbMult);
clipCodes = SIMD_T::or_ps(clipCodes, SIMD_T::and_ps(vRes, SIMD_T::castsi_ps(SIMD_T::set1_epi32(GUARDBAND_RIGHT))));

// GUARDBAND_BOTTOM
gbMult = SIMD_T::mul_ps(vertex.w, SIMD_T::template i32gather_ps<typename SIMD_T::ScaleFactor(4)>(&state.gbState.bottom[0], viewportIndexes));
gbMult = SIMD_T::mul_ps(vertex.w, SIMD_T::template i32gather_ps<ScaleFactor<SIMD_T>(4)>(&state.gbState.bottom[0], viewportIndexes));
vRes = SIMD_T::cmpgt_ps(vertex.y, gbMult);
clipCodes = SIMD_T::or_ps(clipCodes, SIMD_T::and_ps(vRes, SIMD_T::castsi_ps(SIMD_T::set1_epi32(GUARDBAND_BOTTOM))));
}
@@ -311,7 +311,7 @@ public:
static_assert(NumVertsPerPrim >= 1 && NumVertsPerPrim <= 3, "Invalid NumVertsPerPrim");
}

void ComputeClipCodes(typename SIMD_T::Vec4 vertex[], const typename SIMD_T::Integer &viewportIndexes)
void ComputeClipCodes(Vec4<SIMD_T> vertex[], const Integer<SIMD_T> &viewportIndexes)
{
for (uint32_t i = 0; i < NumVertsPerPrim; ++i)
{
@@ -319,9 +319,9 @@ public:
}
}

typename SIMD_T::Float ComputeClipCodeIntersection()
Float<SIMD_T> ComputeClipCodeIntersection()
{
typename SIMD_T::Float result = clipCodes[0];
Float<SIMD_T> result = clipCodes[0];

for (uint32_t i = 1; i < NumVertsPerPrim; ++i)
{
@@ -331,9 +331,9 @@ public:
return result;
}

typename SIMD_T::Float ComputeClipCodeUnion()
Float<SIMD_T> ComputeClipCodeUnion()
{
typename SIMD_T::Float result = clipCodes[0];
Float<SIMD_T> result = clipCodes[0];

for (uint32_t i = 1; i < NumVertsPerPrim; ++i)
{
@@ -345,7 +345,7 @@ public:

int ComputeClipMask()
{
typename SIMD_T::Float clipUnion = ComputeClipCodeUnion();
Float<SIMD_T> clipUnion = ComputeClipCodeUnion();

clipUnion = SIMD_T::and_ps(clipUnion, SIMD_T::castsi_ps(SIMD_T::set1_epi32(GUARDBAND_CLIP_MASK)));

@@ -353,31 +353,31 @@ public:
}

// clipper is responsible for culling any prims with NAN coordinates
int ComputeNaNMask(typename SIMD_T::Vec4 prim[])
int ComputeNaNMask(Vec4<SIMD_T> prim[])
{
typename SIMD_T::Float vNanMask = SIMD_T::setzero_ps();
Float<SIMD_T> vNanMask = SIMD_T::setzero_ps();

for (uint32_t e = 0; e < NumVertsPerPrim; ++e)
{
typename SIMD_T::Float vNan01 = SIMD_T::template cmp_ps<SIMD_T::CompareType::UNORD_Q>(prim[e].v[0], prim[e].v[1]);
Float<SIMD_T> vNan01 = SIMD_T::template cmp_ps<SIMD_T::CompareType::UNORD_Q>(prim[e].v[0], prim[e].v[1]);
vNanMask = SIMD_T::or_ps(vNanMask, vNan01);

typename SIMD_T::Float vNan23 = SIMD_T::template cmp_ps<SIMD_T::CompareType::UNORD_Q>(prim[e].v[2], prim[e].v[3]);
Float<SIMD_T> vNan23 = SIMD_T::template cmp_ps<SIMD_T::CompareType::UNORD_Q>(prim[e].v[2], prim[e].v[3]);
vNanMask = SIMD_T::or_ps(vNanMask, vNan23);
}

return SIMD_T::movemask_ps(vNanMask);
}

int ComputeUserClipCullMask(PA_STATE &pa, typename SIMD_T::Vec4 prim[])
int ComputeUserClipCullMask(PA_STATE &pa, Vec4<SIMD_T> prim[])
{
uint8_t cullMask = state.backendState.cullDistanceMask;
uint32_t vertexClipCullOffset = state.backendState.vertexClipCullOffset;

typename SIMD_T::Float vClipCullMask = SIMD_T::setzero_ps();
Float<SIMD_T> vClipCullMask = SIMD_T::setzero_ps();

typename SIMD_T::Vec4 vClipCullDistLo[3];
typename SIMD_T::Vec4 vClipCullDistHi[3];
Vec4<SIMD_T> vClipCullDistLo[3];
Vec4<SIMD_T> vClipCullDistHi[3];

pa.Assemble(vertexClipCullOffset, vClipCullDistLo);
pa.Assemble(vertexClipCullOffset + 1, vClipCullDistHi);
@@ -389,10 +389,10 @@ public:
uint32_t slot = index >> 2;
uint32_t component = index & 0x3;

typename SIMD_T::Float vCullMaskElem = SIMD_T::set1_ps(-1.0f);
Float<SIMD_T> vCullMaskElem = SIMD_T::set1_ps(-1.0f);
for (uint32_t e = 0; e < NumVertsPerPrim; ++e)
{
typename SIMD_T::Float vCullComp;
Float<SIMD_T> vCullComp;
if (slot == 0)
{
vCullComp = vClipCullDistLo[e][component];
@@ -403,7 +403,7 @@ public:
}

// cull if cull distance < 0 || NAN
typename SIMD_T::Float vCull = SIMD_T::template cmp_ps<SIMD_T::CompareType::NLE_UQ>(SIMD_T::setzero_ps(), vCullComp);
Float<SIMD_T> vCull = SIMD_T::template cmp_ps<SIMD_T::CompareType::NLE_UQ>(SIMD_T::setzero_ps(), vCullComp);
vCullMaskElem = SIMD_T::and_ps(vCullMaskElem, vCull);
}
vClipCullMask = SIMD_T::or_ps(vClipCullMask, vCullMaskElem);
@@ -417,10 +417,10 @@ public:
uint32_t slot = index >> 2;
uint32_t component = index & 0x3;

typename SIMD_T::Float vCullMaskElem = SIMD_T::set1_ps(-1.0f);
Float<SIMD_T> vCullMaskElem = SIMD_T::set1_ps(-1.0f);
for (uint32_t e = 0; e < NumVertsPerPrim; ++e)
{
typename SIMD_T::Float vClipComp;
Float<SIMD_T> vClipComp;
if (slot == 0)
{
vClipComp = vClipCullDistLo[e][component];
@@ -430,8 +430,8 @@ public:
vClipComp = vClipCullDistHi[e][component];
}

typename SIMD_T::Float vClip = SIMD_T::template cmp_ps<SIMD_T::CompareType::UNORD_Q>(vClipComp, vClipComp);
typename SIMD_T::Float vCull = SIMD_T::template cmp_ps<SIMD_T::CompareType::NLE_UQ>(SIMD_T::setzero_ps(), vClipComp);
Float<SIMD_T> vClip = SIMD_T::template cmp_ps<SIMD_T::CompareType::UNORD_Q>(vClipComp, vClipComp);
Float<SIMD_T> vCull = SIMD_T::template cmp_ps<SIMD_T::CompareType::NLE_UQ>(SIMD_T::setzero_ps(), vClipComp);
vCullMaskElem = SIMD_T::and_ps(vCullMaskElem, vCull);
vClipCullMask = SIMD_T::or_ps(vClipCullMask, vClip);
}
@@ -441,8 +441,8 @@ public:
return SIMD_T::movemask_ps(vClipCullMask);
}

void ClipSimd(const typename SIMD_T::Vec4 prim[], const typename SIMD_T::Float &vPrimMask, const typename SIMD_T::Float &vClipMask, PA_STATE &pa,
const typename SIMD_T::Integer &vPrimId, const typename SIMD_T::Integer &vViewportIdx, const typename SIMD_T::Integer &vRtIdx)
void ClipSimd(const Vec4<SIMD_T> prim[], const Float<SIMD_T> &vPrimMask, const Float<SIMD_T> &vClipMask, PA_STATE &pa,
const Integer<SIMD_T> &vPrimId, const Integer<SIMD_T> &vViewportIdx, const Integer<SIMD_T> &vRtIdx)
{
// input/output vertex store for clipper
SIMDVERTEX_T<SIMD_T> vertices[7]; // maximum 7 verts generated per triangle
@@ -456,7 +456,7 @@ public:
///@todo: line topology for wireframe?

// assemble pos
typename SIMD_T::Vec4 tmpVector[NumVertsPerPrim];
Vec4<SIMD_T> tmpVector[NumVertsPerPrim];
for (uint32_t i = 0; i < NumVertsPerPrim; ++i)
{
vertices[i].attrib[VERTEX_POSITION_SLOT] = prim[i];
@@ -515,7 +515,7 @@ public:

uint32_t numAttribs = maxSlot + 1;

typename SIMD_T::Integer vNumClippedVerts = ClipPrims((float*)&vertices[0], vPrimMask, vClipMask, numAttribs);
Integer<SIMD_T> vNumClippedVerts = ClipPrims((float*)&vertices[0], vPrimMask, vClipMask, numAttribs);

BinnerChooser<SIMD_T> binner(NumVertsPerPrim, pa.pDC->pState->state.rastState.conservativeRast);

@@ -602,9 +602,9 @@ public:
#endif
for (uint32_t c = 0; c < 4; ++c)
{
SIMD256::Float temp = SIMD256::template mask_i32gather_ps<typename SIMD_T::ScaleFactor(1)>(SIMD256::setzero_ps(), reinterpret_cast<const float *>(pBase), vOffsets, vMask);
SIMD256::Float temp = SIMD256::template mask_i32gather_ps<ScaleFactor<SIMD_T>(1)>(SIMD256::setzero_ps(), reinterpret_cast<const float *>(pBase), vOffsets, vMask);
transposedPrims[0].attrib[VERTEX_POSITION_SLOT][c] = SimdHelper<SIMD_T>::insert_lo_ps(temp);
pBase += sizeof(typename SIMD_T::Float);
pBase += sizeof(Float<SIMD_T>);
}

// transpose attribs
@@ -616,9 +616,9 @@ public:

for (uint32_t c = 0; c < 4; ++c)
{
SIMD256::Float temp = SIMD256::template mask_i32gather_ps<typename SIMD_T::ScaleFactor(1)>(SIMD256::setzero_ps(), reinterpret_cast<const float *>(pBase), vOffsets, vMask);
SIMD256::Float temp = SIMD256::template mask_i32gather_ps<ScaleFactor<SIMD_T>(1)>(SIMD256::setzero_ps(), reinterpret_cast<const float *>(pBase), vOffsets, vMask);
transposedPrims[0].attrib[attribSlot][c] = SimdHelper<SIMD_T>::insert_lo_ps(temp);
pBase += sizeof(typename SIMD_T::Float);
pBase += sizeof(Float<SIMD_T>);
}
}

@@ -630,9 +630,9 @@ public:

for (uint32_t c = 0; c < 4; ++c)
{
SIMD256::Float temp = SIMD256::template mask_i32gather_ps<typename SIMD_T::ScaleFactor(1)>(SIMD256::setzero_ps(), reinterpret_cast<const float *>(pBase), vOffsets, vMask);
SIMD256::Float temp = SIMD256::template mask_i32gather_ps<ScaleFactor<SIMD_T>(1)>(SIMD256::setzero_ps(), reinterpret_cast<const float *>(pBase), vOffsets, vMask);
transposedPrims[0].attrib[vertexClipCullSlot][c] = SimdHelper<SIMD_T>::insert_lo_ps(temp);
pBase += sizeof(typename SIMD_T::Float);
pBase += sizeof(Float<SIMD_T>);
}
}

@@ -642,9 +642,9 @@ public:

for (uint32_t c = 0; c < 4; ++c)
{
SIMD256::Float temp = SIMD256::template mask_i32gather_ps<typename SIMD_T::ScaleFactor(1)>(SIMD256::setzero_ps(), reinterpret_cast<const float *>(pBase), vOffsets, vMask);
SIMD256::Float temp = SIMD256::template mask_i32gather_ps<ScaleFactor<SIMD_T>(1)>(SIMD256::setzero_ps(), reinterpret_cast<const float *>(pBase), vOffsets, vMask);
transposedPrims[0].attrib[vertexClipCullSlot + 1][c] = SimdHelper<SIMD_T>::insert_lo_ps(temp);
pBase += sizeof(typename SIMD_T::Float);
pBase += sizeof(Float<SIMD_T>);
}
}

@@ -656,16 +656,16 @@ public:

const uint32_t primMask = primMaskMap[numEmittedPrims];

const typename SIMD_T::Integer primID = SIMD_T::set1_epi32(pPrimitiveId[inputPrim]);
const typename SIMD_T::Integer viewportIdx = SIMD_T::set1_epi32(pViewportIdx[inputPrim]);
const typename SIMD_T::Integer rtIdx = SIMD_T::set1_epi32(pRtIdx[inputPrim]);
const Integer<SIMD_T> primID = SIMD_T::set1_epi32(pPrimitiveId[inputPrim]);
const Integer<SIMD_T> viewportIdx = SIMD_T::set1_epi32(pViewportIdx[inputPrim]);
const Integer<SIMD_T> rtIdx = SIMD_T::set1_epi32(pRtIdx[inputPrim]);


while (clipPA.GetNextStreamOutput())
{
do
{
typename SIMD_T::Vec4 attrib[NumVertsPerPrim];
Vec4<SIMD_T> attrib[NumVertsPerPrim];

bool assemble = clipPA.Assemble(VERTEX_POSITION_SLOT, attrib);

@@ -686,8 +686,8 @@ public:
UPDATE_STAT_FE(CPrimitives, numClippedPrims);
}

void ExecuteStage(PA_STATE &pa, typename SIMD_T::Vec4 prim[], uint32_t primMask,
typename SIMD_T::Integer const &primId, typename SIMD_T::Integer const &viewportIdx, typename SIMD_T::Integer const &rtIdx)
void ExecuteStage(PA_STATE &pa, Vec4<SIMD_T> prim[], uint32_t primMask,
Integer<SIMD_T> const &primId, Integer<SIMD_T> const &viewportIdx, Integer<SIMD_T> const &rtIdx)
{
SWR_ASSERT(pa.pDC != nullptr);

@@ -709,7 +709,7 @@ public:
}

// cull prims outside view frustum
typename SIMD_T::Float clipIntersection = ComputeClipCodeIntersection();
Float<SIMD_T> clipIntersection = ComputeClipCodeIntersection();
int validMask = primMask & SimdHelper<SIMD_T>::cmpeq_ps_mask(clipIntersection, SIMD_T::setzero_ps());

// skip clipping for points
@@ -740,16 +740,16 @@ public:
}

private:
typename SIMD_T::Float ComputeInterpFactor(typename SIMD_T::Float const &boundaryCoord0, typename SIMD_T::Float const &boundaryCoord1)
Float<SIMD_T> ComputeInterpFactor(Float<SIMD_T> const &boundaryCoord0, Float<SIMD_T> const &boundaryCoord1)
{
return SIMD_T::div_ps(boundaryCoord0, SIMD_T::sub_ps(boundaryCoord0, boundaryCoord1));
}

typename SIMD_T::Integer ComputeOffsets(uint32_t attrib, typename SIMD_T::Integer const &vIndices, uint32_t component)
Integer<SIMD_T> ComputeOffsets(uint32_t attrib, Integer<SIMD_T> const &vIndices, uint32_t component)
{
const uint32_t simdVertexStride = sizeof(SIMDVERTEX_T<SIMD_T>);
const uint32_t componentStride = sizeof(typename SIMD_T::Float);
const uint32_t attribStride = sizeof(typename SIMD_T::Vec4);
const uint32_t componentStride = sizeof(Float<SIMD_T>);
const uint32_t attribStride = sizeof(Vec4<SIMD_T>);

static const OSALIGNSIMD16(uint32_t) elemOffset[16] =
{
@@ -771,12 +771,12 @@ private:
15 * sizeof(float),
};

static_assert(sizeof(typename SIMD_T::Integer) <= sizeof(elemOffset), "Clipper::ComputeOffsets, Increase number of element offsets.");
static_assert(sizeof(Integer<SIMD_T>) <= sizeof(elemOffset), "Clipper::ComputeOffsets, Increase number of element offsets.");

typename SIMD_T::Integer vElemOffset = SIMD_T::loadu_si(reinterpret_cast<const typename SIMD_T::Integer *>(elemOffset));
Integer<SIMD_T> vElemOffset = SIMD_T::loadu_si(reinterpret_cast<const Integer<SIMD_T> *>(elemOffset));

// step to the simdvertex
typename SIMD_T::Integer vOffsets = SIMD_T::mullo_epi32(vIndices, SIMD_T::set1_epi32(simdVertexStride));
Integer<SIMD_T> vOffsets = SIMD_T::mullo_epi32(vIndices, SIMD_T::set1_epi32(simdVertexStride));

// step to the attribute and component
vOffsets = SIMD_T::add_epi32(vOffsets, SIMD_T::set1_epi32(attribStride * attrib + componentStride * component));
@@ -787,17 +787,17 @@ private:
return vOffsets;
}

typename SIMD_T::Float GatherComponent(const float* pBuffer, uint32_t attrib, typename SIMD_T::Float const &vMask, typename SIMD_T::Integer const &vIndices, uint32_t component)
Float<SIMD_T> GatherComponent(const float* pBuffer, uint32_t attrib, Float<SIMD_T> const &vMask, Integer<SIMD_T> const &vIndices, uint32_t component)
{
typename SIMD_T::Integer vOffsets = ComputeOffsets(attrib, vIndices, component);
typename SIMD_T::Float vSrc = SIMD_T::setzero_ps();
Integer<SIMD_T> vOffsets = ComputeOffsets(attrib, vIndices, component);
Float<SIMD_T> vSrc = SIMD_T::setzero_ps();

return SIMD_T::template mask_i32gather_ps<typename SIMD_T::ScaleFactor(1)>(vSrc, pBuffer, vOffsets, vMask);
return SIMD_T::template mask_i32gather_ps<ScaleFactor<SIMD_T>(1)>(vSrc, pBuffer, vOffsets, vMask);
}

void ScatterComponent(const float* pBuffer, uint32_t attrib, typename SIMD_T::Float const &vMask, typename SIMD_T::Integer const &vIndices, uint32_t component, typename SIMD_T::Float const &vSrc)
void ScatterComponent(const float* pBuffer, uint32_t attrib, Float<SIMD_T> const &vMask, Integer<SIMD_T> const &vIndices, uint32_t component, Float<SIMD_T> const &vSrc)
{
typename SIMD_T::Integer vOffsets = ComputeOffsets(attrib, vIndices, component);
Integer<SIMD_T> vOffsets = ComputeOffsets(attrib, vIndices, component);

const uint32_t *pOffsets = reinterpret_cast<const uint32_t *>(&vOffsets);
const float *pSrc = reinterpret_cast<const float *>(&vSrc);
@@ -813,12 +813,12 @@ private:

template<SWR_CLIPCODES ClippingPlane>
void intersect(
const typename SIMD_T::Float &vActiveMask, // active lanes to operate on
const typename SIMD_T::Integer &s, // index to first edge vertex v0 in pInPts.
const typename SIMD_T::Integer &p, // index to second edge vertex v1 in pInPts.
const typename SIMD_T::Vec4 &v1, // vertex 0 position
const typename SIMD_T::Vec4 &v2, // vertex 1 position
typename SIMD_T::Integer &outIndex, // output index.
const Float<SIMD_T> &vActiveMask, // active lanes to operate on
const Integer<SIMD_T> &s, // index to first edge vertex v0 in pInPts.
const Integer<SIMD_T> &p, // index to second edge vertex v1 in pInPts.
const Vec4<SIMD_T> &v1, // vertex 0 position
const Vec4<SIMD_T> &v2, // vertex 1 position
Integer<SIMD_T> &outIndex, // output index.
const float *pInVerts, // array of all the input positions.
uint32_t numInAttribs, // number of attributes per vertex.
float *pOutVerts) // array of output positions. We'll write our new intersection point at i*4.
@@ -827,7 +827,7 @@ private:
uint32_t vertexClipCullOffset = this->state.backendState.vertexClipCullOffset;

// compute interpolation factor
typename SIMD_T::Float t;
Float<SIMD_T> t;
switch (ClippingPlane)
{
case FRUSTUM_LEFT: t = ComputeInterpFactor(SIMD_T::add_ps(v1[3], v1[0]), SIMD_T::add_ps(v2[3], v2[0])); break;
@@ -852,7 +852,7 @@ private:
// interpolate position and store
for (uint32_t c = 0; c < 4; ++c)
{
typename SIMD_T::Float vOutPos = SIMD_T::fmadd_ps(SIMD_T::sub_ps(v2[c], v1[c]), t, v1[c]);
Float<SIMD_T> vOutPos = SIMD_T::fmadd_ps(SIMD_T::sub_ps(v2[c], v1[c]), t, v1[c]);
ScatterComponent(pOutVerts, VERTEX_POSITION_SLOT, vActiveMask, outIndex, c, vOutPos);
}

@@ -862,9 +862,9 @@ private:
uint32_t attribSlot = vertexAttribOffset + a;
for (uint32_t c = 0; c < 4; ++c)
{
typename SIMD_T::Float vAttrib0 = GatherComponent(pInVerts, attribSlot, vActiveMask, s, c);
typename SIMD_T::Float vAttrib1 = GatherComponent(pInVerts, attribSlot, vActiveMask, p, c);
typename SIMD_T::Float vOutAttrib = SIMD_T::fmadd_ps(SIMD_T::sub_ps(vAttrib1, vAttrib0), t, vAttrib0);
Float<SIMD_T> vAttrib0 = GatherComponent(pInVerts, attribSlot, vActiveMask, s, c);
Float<SIMD_T> vAttrib1 = GatherComponent(pInVerts, attribSlot, vActiveMask, p, c);
Float<SIMD_T> vOutAttrib = SIMD_T::fmadd_ps(SIMD_T::sub_ps(vAttrib1, vAttrib0), t, vAttrib0);
ScatterComponent(pOutVerts, attribSlot, vActiveMask, outIndex, c, vOutAttrib);
}
}
@@ -875,9 +875,9 @@ private:
uint32_t attribSlot = vertexClipCullOffset;
for (uint32_t c = 0; c < 4; ++c)
{
typename SIMD_T::Float vAttrib0 = GatherComponent(pInVerts, attribSlot, vActiveMask, s, c);
typename SIMD_T::Float vAttrib1 = GatherComponent(pInVerts, attribSlot, vActiveMask, p, c);
typename SIMD_T::Float vOutAttrib = SIMD_T::fmadd_ps(SIMD_T::sub_ps(vAttrib1, vAttrib0), t, vAttrib0);
Float<SIMD_T> vAttrib0 = GatherComponent(pInVerts, attribSlot, vActiveMask, s, c);
Float<SIMD_T> vAttrib1 = GatherComponent(pInVerts, attribSlot, vActiveMask, p, c);
Float<SIMD_T> vOutAttrib = SIMD_T::fmadd_ps(SIMD_T::sub_ps(vAttrib1, vAttrib0), t, vAttrib0);
ScatterComponent(pOutVerts, attribSlot, vActiveMask, outIndex, c, vOutAttrib);
}
}
@@ -887,16 +887,16 @@ private:
uint32_t attribSlot = vertexClipCullOffset + 1;
for (uint32_t c = 0; c < 4; ++c)
{
typename SIMD_T::Float vAttrib0 = GatherComponent(pInVerts, attribSlot, vActiveMask, s, c);
typename SIMD_T::Float vAttrib1 = GatherComponent(pInVerts, attribSlot, vActiveMask, p, c);
typename SIMD_T::Float vOutAttrib = SIMD_T::fmadd_ps(SIMD_T::sub_ps(vAttrib1, vAttrib0), t, vAttrib0);
Float<SIMD_T> vAttrib0 = GatherComponent(pInVerts, attribSlot, vActiveMask, s, c);
Float<SIMD_T> vAttrib1 = GatherComponent(pInVerts, attribSlot, vActiveMask, p, c);
Float<SIMD_T> vOutAttrib = SIMD_T::fmadd_ps(SIMD_T::sub_ps(vAttrib1, vAttrib0), t, vAttrib0);
ScatterComponent(pOutVerts, attribSlot, vActiveMask, outIndex, c, vOutAttrib);
}
}
}

template<SWR_CLIPCODES ClippingPlane>
typename SIMD_T::Float inside(const typename SIMD_T::Vec4 &v)
Float<SIMD_T> inside(const Vec4<SIMD_T> &v)
{
switch (ClippingPlane)
{
@@ -913,23 +913,23 @@ private:
}

template<SWR_CLIPCODES ClippingPlane>
typename SIMD_T::Integer ClipTriToPlane(const float *pInVerts, const typename SIMD_T::Integer &vNumInPts, uint32_t numInAttribs, float *pOutVerts)
Integer<SIMD_T> ClipTriToPlane(const float *pInVerts, const Integer<SIMD_T> &vNumInPts, uint32_t numInAttribs, float *pOutVerts)
{
uint32_t vertexAttribOffset = this->state.backendState.vertexAttribOffset;

typename SIMD_T::Integer vCurIndex = SIMD_T::setzero_si();
typename SIMD_T::Integer vOutIndex = SIMD_T::setzero_si();
typename SIMD_T::Float vActiveMask = SIMD_T::castsi_ps(SIMD_T::cmplt_epi32(vCurIndex, vNumInPts));
Integer<SIMD_T> vCurIndex = SIMD_T::setzero_si();
Integer<SIMD_T> vOutIndex = SIMD_T::setzero_si();
Float<SIMD_T> vActiveMask = SIMD_T::castsi_ps(SIMD_T::cmplt_epi32(vCurIndex, vNumInPts));

while (!SIMD_T::testz_ps(vActiveMask, vActiveMask)) // loop until activeMask is empty
{
typename SIMD_T::Integer s = vCurIndex;
typename SIMD_T::Integer p = SIMD_T::add_epi32(s, SIMD_T::set1_epi32(1));
typename SIMD_T::Integer underFlowMask = SIMD_T::cmpgt_epi32(vNumInPts, p);
Integer<SIMD_T> s = vCurIndex;
Integer<SIMD_T> p = SIMD_T::add_epi32(s, SIMD_T::set1_epi32(1));
Integer<SIMD_T> underFlowMask = SIMD_T::cmpgt_epi32(vNumInPts, p);
p = SIMD_T::castps_si(SIMD_T::blendv_ps(SIMD_T::setzero_ps(), SIMD_T::castsi_ps(p), SIMD_T::castsi_ps(underFlowMask)));

// gather position
typename SIMD_T::Vec4 vInPos0, vInPos1;
Vec4<SIMD_T> vInPos0, vInPos1;
for (uint32_t c = 0; c < 4; ++c)
{
vInPos0[c] = GatherComponent(pInVerts, VERTEX_POSITION_SLOT, vActiveMask, s, c);
@@ -937,11 +937,11 @@ private:
}

// compute inside mask
typename SIMD_T::Float s_in = inside<ClippingPlane>(vInPos0);
typename SIMD_T::Float p_in = inside<ClippingPlane>(vInPos1);
Float<SIMD_T> s_in = inside<ClippingPlane>(vInPos0);
Float<SIMD_T> p_in = inside<ClippingPlane>(vInPos1);

// compute intersection mask (s_in != p_in)
typename SIMD_T::Float intersectMask = SIMD_T::xor_ps(s_in, p_in);
Float<SIMD_T> intersectMask = SIMD_T::xor_ps(s_in, p_in);
intersectMask = SIMD_T::and_ps(intersectMask, vActiveMask);

// store s if inside
@@ -960,7 +960,7 @@ private:
uint32_t attribSlot = vertexAttribOffset + a;
for (uint32_t c = 0; c < 4; ++c)
{
typename SIMD_T::Float vAttrib = GatherComponent(pInVerts, attribSlot, s_in, s, c);
Float<SIMD_T> vAttrib = GatherComponent(pInVerts, attribSlot, s_in, s, c);
ScatterComponent(pOutVerts, attribSlot, s_in, vOutIndex, c, vAttrib);
}
}
@@ -972,7 +972,7 @@ private:
uint32_t attribSlot = vertexClipCullSlot;
for (uint32_t c = 0; c < 4; ++c)
{
typename SIMD_T::Float vAttrib = GatherComponent(pInVerts, attribSlot, s_in, s, c);
Float<SIMD_T> vAttrib = GatherComponent(pInVerts, attribSlot, s_in, s, c);
ScatterComponent(pOutVerts, attribSlot, s_in, vOutIndex, c, vAttrib);
}
}
@@ -982,7 +982,7 @@ private:
uint32_t attribSlot = vertexClipCullSlot + 1;
for (uint32_t c = 0; c < 4; ++c)
{
typename SIMD_T::Float vAttrib = GatherComponent(pInVerts, attribSlot, s_in, s, c);
Float<SIMD_T> vAttrib = GatherComponent(pInVerts, attribSlot, s_in, s, c);
ScatterComponent(pOutVerts, attribSlot, s_in, vOutIndex, c, vAttrib);
}
}
@@ -1009,21 +1009,21 @@ private:
}

template<SWR_CLIPCODES ClippingPlane>
typename SIMD_T::Integer ClipLineToPlane(const float *pInVerts, const typename SIMD_T::Integer &vNumInPts, uint32_t numInAttribs, float *pOutVerts)
Integer<SIMD_T> ClipLineToPlane(const float *pInVerts, const Integer<SIMD_T> &vNumInPts, uint32_t numInAttribs, float *pOutVerts)
{
uint32_t vertexAttribOffset = this->state.backendState.vertexAttribOffset;

typename SIMD_T::Integer vCurIndex = SIMD_T::setzero_si();
typename SIMD_T::Integer vOutIndex = SIMD_T::setzero_si();
typename SIMD_T::Float vActiveMask = SIMD_T::castsi_ps(SIMD_T::cmplt_epi32(vCurIndex, vNumInPts));
Integer<SIMD_T> vCurIndex = SIMD_T::setzero_si();
Integer<SIMD_T> vOutIndex = SIMD_T::setzero_si();
Float<SIMD_T> vActiveMask = SIMD_T::castsi_ps(SIMD_T::cmplt_epi32(vCurIndex, vNumInPts));

if (!SIMD_T::testz_ps(vActiveMask, vActiveMask))
{
typename SIMD_T::Integer s = vCurIndex;
typename SIMD_T::Integer p = SIMD_T::add_epi32(s, SIMD_T::set1_epi32(1));
Integer<SIMD_T> s = vCurIndex;
Integer<SIMD_T> p = SIMD_T::add_epi32(s, SIMD_T::set1_epi32(1));

// gather position
typename SIMD_T::Vec4 vInPos0, vInPos1;
Vec4<SIMD_T> vInPos0, vInPos1;
for (uint32_t c = 0; c < 4; ++c)
{
vInPos0[c] = GatherComponent(pInVerts, VERTEX_POSITION_SLOT, vActiveMask, s, c);
@@ -1031,11 +1031,11 @@ private:
}

// compute inside mask
typename SIMD_T::Float s_in = inside<ClippingPlane>(vInPos0);
typename SIMD_T::Float p_in = inside<ClippingPlane>(vInPos1);
Float<SIMD_T> s_in = inside<ClippingPlane>(vInPos0);
Float<SIMD_T> p_in = inside<ClippingPlane>(vInPos1);

// compute intersection mask (s_in != p_in)
typename SIMD_T::Float intersectMask = SIMD_T::xor_ps(s_in, p_in);
Float<SIMD_T> intersectMask = SIMD_T::xor_ps(s_in, p_in);
intersectMask = SIMD_T::and_ps(intersectMask, vActiveMask);

// store s if inside
@@ -1053,7 +1053,7 @@ private:
uint32_t attribSlot = vertexAttribOffset + a;
for (uint32_t c = 0; c < 4; ++c)
{
typename SIMD_T::Float vAttrib = GatherComponent(pInVerts, attribSlot, s_in, s, c);
Float<SIMD_T> vAttrib = GatherComponent(pInVerts, attribSlot, s_in, s, c);
ScatterComponent(pOutVerts, attribSlot, s_in, vOutIndex, c, vAttrib);
}
}
@@ -1086,7 +1086,7 @@ private:
uint32_t attribSlot = vertexAttribOffset + a;
for (uint32_t c = 0; c < 4; ++c)
{
typename SIMD_T::Float vAttrib = GatherComponent(pInVerts, attribSlot, p_in, p, c);
Float<SIMD_T> vAttrib = GatherComponent(pInVerts, attribSlot, p_in, p, c);
ScatterComponent(pOutVerts, attribSlot, p_in, vOutIndex, c, vAttrib);
}
}
@@ -1099,17 +1099,17 @@ private:
return vOutIndex;
}

typename SIMD_T::Integer ClipPrims(float *pVertices, const typename SIMD_T::Float &vPrimMask, const typename SIMD_T::Float &vClipMask, int numAttribs)
Integer<SIMD_T> ClipPrims(float *pVertices, const Float<SIMD_T> &vPrimMask, const Float<SIMD_T> &vClipMask, int numAttribs)
{
// temp storage
float *pTempVerts = reinterpret_cast<float *>(ClipHelper<SIMD_T>::GetTempVertices());

// zero out num input verts for non-active lanes
typename SIMD_T::Integer vNumInPts = SIMD_T::set1_epi32(NumVertsPerPrim);
Integer<SIMD_T> vNumInPts = SIMD_T::set1_epi32(NumVertsPerPrim);
vNumInPts = SIMD_T::blendv_epi32(SIMD_T::setzero_si(), vNumInPts, vClipMask);

// clip prims to frustum
typename SIMD_T::Integer vNumOutPts;
Integer<SIMD_T> vNumOutPts;
if (NumVertsPerPrim == 3)
{
vNumOutPts = ClipTriToPlane<FRUSTUM_NEAR>(pVertices, vNumInPts, numAttribs, pTempVerts);
@@ -1131,7 +1131,7 @@ private:
}

// restore num verts for non-clipped, active lanes
typename SIMD_T::Float vNonClippedMask = SIMD_T::andnot_ps(vClipMask, vPrimMask);
Float<SIMD_T> vNonClippedMask = SIMD_T::andnot_ps(vClipMask, vPrimMask);
vNumOutPts = SIMD_T::blendv_epi32(vNumOutPts, SIMD_T::set1_epi32(NumVertsPerPrim), vNonClippedMask);

return vNumOutPts;
@@ -1140,7 +1140,7 @@ private:
const uint32_t workerId{ 0 };
DRAW_CONTEXT *pDC{ nullptr };
const API_STATE &state;
typename SIMD_T::Float clipCodes[NumVertsPerPrim];
Float<SIMD_T> clipCodes[NumVertsPerPrim];
};



+ 11
- 11
src/gallium/drivers/swr/rasterizer/core/frontend.cpp Voir le fichier

@@ -733,7 +733,7 @@ template<typename SIMD_T, uint32_t SimdWidth>
void TransposeSOAtoAOS(uint8_t* pDst, uint8_t* pSrc, uint32_t numVerts, uint32_t numAttribs)
{
uint32_t srcVertexStride = numAttribs * sizeof(float) * 4;
uint32_t dstVertexStride = numAttribs * sizeof(typename SIMD_T::Float) * 4;
uint32_t dstVertexStride = numAttribs * sizeof(Float<SIMD_T>) * 4;

OSALIGNSIMD16(uint32_t) gatherOffsets[SimdWidth];

@@ -741,7 +741,7 @@ void TransposeSOAtoAOS(uint8_t* pDst, uint8_t* pSrc, uint32_t numVerts, uint32_t
{
gatherOffsets[i] = srcVertexStride * i;
}
auto vGatherOffsets = SIMD_T::load_si((typename SIMD_T::Integer*)&gatherOffsets[0]);
auto vGatherOffsets = SIMD_T::load_si((Integer<SIMD_T>*)&gatherOffsets[0]);

uint32_t numSimd = AlignUp(numVerts, SimdWidth) / SimdWidth;
uint32_t remainingVerts = numVerts;
@@ -759,18 +759,18 @@ void TransposeSOAtoAOS(uint8_t* pDst, uint8_t* pSrc, uint32_t numVerts, uint32_t

for (uint32_t a = 0; a < numAttribs; ++a)
{
auto attribGatherX = SIMD_T::template mask_i32gather_ps<typename SIMD_T::ScaleFactor(1)>(SIMD_T::setzero_ps(), (const float*)pSrcBase, vGatherOffsets, vMask);
auto attribGatherY = SIMD_T::template mask_i32gather_ps<typename SIMD_T::ScaleFactor(1)>(SIMD_T::setzero_ps(), (const float*)(pSrcBase + sizeof(float)), vGatherOffsets, vMask);
auto attribGatherZ = SIMD_T::template mask_i32gather_ps<typename SIMD_T::ScaleFactor(1)>(SIMD_T::setzero_ps(), (const float*)(pSrcBase + sizeof(float) * 2), vGatherOffsets, vMask);
auto attribGatherW = SIMD_T::template mask_i32gather_ps<typename SIMD_T::ScaleFactor(1)>(SIMD_T::setzero_ps(), (const float*)(pSrcBase + sizeof(float) * 3), vGatherOffsets, vMask);
auto attribGatherX = SIMD_T::template mask_i32gather_ps<ScaleFactor<SIMD_T>(1)>(SIMD_T::setzero_ps(), (const float*)pSrcBase, vGatherOffsets, vMask);
auto attribGatherY = SIMD_T::template mask_i32gather_ps<ScaleFactor<SIMD_T>(1)>(SIMD_T::setzero_ps(), (const float*)(pSrcBase + sizeof(float)), vGatherOffsets, vMask);
auto attribGatherZ = SIMD_T::template mask_i32gather_ps<ScaleFactor<SIMD_T>(1)>(SIMD_T::setzero_ps(), (const float*)(pSrcBase + sizeof(float) * 2), vGatherOffsets, vMask);
auto attribGatherW = SIMD_T::template mask_i32gather_ps<ScaleFactor<SIMD_T>(1)>(SIMD_T::setzero_ps(), (const float*)(pSrcBase + sizeof(float) * 3), vGatherOffsets, vMask);

SIMD_T::maskstore_ps((float*)pDstBase, viMask, attribGatherX);
SIMD_T::maskstore_ps((float*)(pDstBase + sizeof(typename SIMD_T::Float)), viMask, attribGatherY);
SIMD_T::maskstore_ps((float*)(pDstBase + sizeof(typename SIMD_T::Float) * 2), viMask, attribGatherZ);
SIMD_T::maskstore_ps((float*)(pDstBase + sizeof(typename SIMD_T::Float) * 3), viMask, attribGatherW);
SIMD_T::maskstore_ps((float*)(pDstBase + sizeof(Float<SIMD_T>)), viMask, attribGatherY);
SIMD_T::maskstore_ps((float*)(pDstBase + sizeof(Float<SIMD_T>) * 2), viMask, attribGatherZ);
SIMD_T::maskstore_ps((float*)(pDstBase + sizeof(Float<SIMD_T>) * 3), viMask, attribGatherW);

pSrcBase += sizeof(float) * 4;
pDstBase += sizeof(typename SIMD_T::Float) * 4;
pDstBase += sizeof(Float<SIMD_T>) * 4;
}
remainingVerts -= SimdWidth;
}
@@ -1101,7 +1101,7 @@ static INLINE void AllocateGsBuffers(DRAW_CONTEXT* pDC, const API_STATE& state,

// Allocate storage for transposed GS output
uint32_t numSimdBatches = AlignUp(gsState.maxNumVerts, SIMD_WIDTH) / SIMD_WIDTH;
uint32_t transposedBufferSize = numSimdBatches * gsState.outputVertexSize * sizeof(typename SIMD_T::Vec4);
uint32_t transposedBufferSize = numSimdBatches * gsState.outputVertexSize * sizeof(Vec4<SIMD_T>);
pGsBuffers->pGsTransposed = (uint8_t*)pArena->AllocAligned(transposedBufferSize, 32);

// Allocate storage to hold temporary stream->cut buffer, if necessary

Écrire Aperçu
Chargement…
Annuler
Enregistrer