/****************************************************************************
|
* 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 clip.h
|
*
|
* @brief Definitions for clipping
|
*
|
******************************************************************************/
|
#pragma once
|
|
#include "common/simdintrin.h"
|
#include "core/context.h"
|
#include "core/pa.h"
|
#include "rdtsc_core.h"
|
|
// Temp storage used by the clipper
|
extern THREAD SIMDVERTEX_T<SIMD256> tlsTempVertices[7];
|
#if USE_SIMD16_FRONTEND
|
extern THREAD SIMDVERTEX_T<SIMD512> tlsTempVertices_simd16[7];
|
#endif
|
|
enum SWR_CLIPCODES
|
{
|
// Shift clip codes out of the mantissa to prevent denormalized values when used in float compare.
|
// Guardband is able to use a single high-bit with 4 separate LSBs, because it computes a union, rather than intersection, of clipcodes.
|
#define CLIPCODE_SHIFT 23
|
FRUSTUM_LEFT = (0x01 << CLIPCODE_SHIFT),
|
FRUSTUM_TOP = (0x02 << CLIPCODE_SHIFT),
|
FRUSTUM_RIGHT = (0x04 << CLIPCODE_SHIFT),
|
FRUSTUM_BOTTOM = (0x08 << CLIPCODE_SHIFT),
|
|
FRUSTUM_NEAR = (0x10 << CLIPCODE_SHIFT),
|
FRUSTUM_FAR = (0x20 << CLIPCODE_SHIFT),
|
|
NEGW = (0x40 << CLIPCODE_SHIFT),
|
|
GUARDBAND_LEFT = (0x80 << CLIPCODE_SHIFT | 0x1),
|
GUARDBAND_TOP = (0x80 << CLIPCODE_SHIFT | 0x2),
|
GUARDBAND_RIGHT = (0x80 << CLIPCODE_SHIFT | 0x4),
|
GUARDBAND_BOTTOM = (0x80 << CLIPCODE_SHIFT | 0x8)
|
};
|
|
#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)
|
{
|
clipCodes = SIMD_T::setzero_ps();
|
|
// -w
|
typename SIMD_T::Float 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);
|
clipCodes = SIMD_T::and_ps(vRes, SIMD_T::castsi_ps(SIMD_T::set1_epi32(FRUSTUM_LEFT)));
|
|
// FRUSTUM_TOP
|
vRes = SIMD_T::cmplt_ps(vertex.y, vNegW);
|
clipCodes = SIMD_T::or_ps(clipCodes, SIMD_T::and_ps(vRes, SIMD_T::castsi_ps(SIMD_T::set1_epi32(FRUSTUM_TOP))));
|
|
// FRUSTUM_RIGHT
|
vRes = SIMD_T::cmpgt_ps(vertex.x, vertex.w);
|
clipCodes = SIMD_T::or_ps(clipCodes, SIMD_T::and_ps(vRes, SIMD_T::castsi_ps(SIMD_T::set1_epi32(FRUSTUM_RIGHT))));
|
|
// FRUSTUM_BOTTOM
|
vRes = SIMD_T::cmpgt_ps(vertex.y, vertex.w);
|
clipCodes = SIMD_T::or_ps(clipCodes, SIMD_T::and_ps(vRes, SIMD_T::castsi_ps(SIMD_T::set1_epi32(FRUSTUM_BOTTOM))));
|
|
if (state.rastState.depthClipEnable)
|
{
|
// FRUSTUM_NEAR
|
// DX clips depth [0..w], GL clips [-w..w]
|
if (state.rastState.clipHalfZ)
|
{
|
vRes = SIMD_T::cmplt_ps(vertex.z, SIMD_T::setzero_ps());
|
}
|
else
|
{
|
vRes = SIMD_T::cmplt_ps(vertex.z, vNegW);
|
}
|
clipCodes = SIMD_T::or_ps(clipCodes, SIMD_T::and_ps(vRes, SIMD_T::castsi_ps(SIMD_T::set1_epi32(FRUSTUM_NEAR))));
|
|
// FRUSTUM_FAR
|
vRes = SIMD_T::cmpgt_ps(vertex.z, vertex.w);
|
clipCodes = SIMD_T::or_ps(clipCodes, SIMD_T::and_ps(vRes, SIMD_T::castsi_ps(SIMD_T::set1_epi32(FRUSTUM_FAR))));
|
}
|
|
// NEGW
|
vRes = SIMD_T::cmple_ps(vertex.w, SIMD_T::setzero_ps());
|
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));
|
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));
|
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));
|
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));
|
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))));
|
}
|
|
template<typename SIMD_T>
|
struct BinnerChooser
|
{
|
};
|
|
template<>
|
struct BinnerChooser<SIMD256>
|
{
|
PFN_PROCESS_PRIMS pfnBinFunc;
|
|
BinnerChooser(uint32_t numVertsPerPrim, uint32_t conservativeRast)
|
:pfnBinFunc(nullptr)
|
{
|
if (numVertsPerPrim == 3)
|
{
|
pfnBinFunc = GetBinTrianglesFunc(conservativeRast > 0);
|
|
}
|
else if (numVertsPerPrim == 2)
|
{
|
pfnBinFunc = BinLines;
|
}
|
else
|
{
|
SWR_ASSERT(0 && "Unexpected points in clipper.");
|
}
|
}
|
|
BinnerChooser(PRIMITIVE_TOPOLOGY topology, uint32_t conservativeRast)
|
:pfnBinFunc(nullptr)
|
{
|
switch (topology)
|
{
|
case TOP_POINT_LIST:
|
pfnBinFunc = BinPoints;
|
break;
|
case TOP_LINE_LIST:
|
case TOP_LINE_STRIP:
|
case TOP_LINE_LOOP:
|
case TOP_LINE_LIST_ADJ:
|
case TOP_LISTSTRIP_ADJ:
|
pfnBinFunc = BinLines;
|
break;
|
default:
|
pfnBinFunc = GetBinTrianglesFunc(conservativeRast > 0);
|
break;
|
};
|
}
|
|
void BinFunc(DRAW_CONTEXT *pDC, PA_STATE &pa, uint32_t workerId, SIMD256::Vec4 prims[], uint32_t primMask, SIMD256::Integer const &primID, SIMD256::Integer &viewportIdx, SIMD256::Integer &rtIdx)
|
{
|
SWR_ASSERT(pfnBinFunc != nullptr);
|
|
pfnBinFunc(pDC, pa, workerId, prims, primMask, primID, viewportIdx, rtIdx);
|
}
|
};
|
|
#if USE_SIMD16_FRONTEND
|
template<>
|
struct BinnerChooser<SIMD512>
|
{
|
PFN_PROCESS_PRIMS_SIMD16 pfnBinFunc;
|
|
BinnerChooser(uint32_t numVertsPerPrim, uint32_t conservativeRast)
|
:pfnBinFunc(nullptr)
|
{
|
if (numVertsPerPrim == 3)
|
{
|
pfnBinFunc = GetBinTrianglesFunc_simd16(conservativeRast > 0);
|
|
}
|
else if (numVertsPerPrim == 2)
|
{
|
pfnBinFunc = BinLines_simd16;
|
}
|
else
|
{
|
SWR_ASSERT(0 && "Unexpected points in clipper.");
|
}
|
}
|
|
BinnerChooser(PRIMITIVE_TOPOLOGY topology, uint32_t conservativeRast)
|
:pfnBinFunc(nullptr)
|
{
|
switch (topology)
|
{
|
case TOP_POINT_LIST:
|
pfnBinFunc = BinPoints_simd16;
|
break;
|
case TOP_LINE_LIST:
|
case TOP_LINE_STRIP:
|
case TOP_LINE_LOOP:
|
case TOP_LINE_LIST_ADJ:
|
case TOP_LISTSTRIP_ADJ:
|
pfnBinFunc = BinLines_simd16;
|
break;
|
default:
|
pfnBinFunc = GetBinTrianglesFunc_simd16(conservativeRast > 0);
|
break;
|
};
|
}
|
|
void BinFunc(DRAW_CONTEXT *pDC, PA_STATE &pa, uint32_t workerId, SIMD512::Vec4 prims[], uint32_t primMask, SIMD512::Integer const &primID, SIMD512::Integer &viewportIdx, SIMD512::Integer &rtIdx)
|
{
|
SWR_ASSERT(pfnBinFunc != nullptr);
|
|
pfnBinFunc(pDC, pa, workerId, prims, primMask, primID, viewportIdx, rtIdx);
|
}
|
};
|
|
#endif
|
template<typename SIMD_T>
|
struct SimdHelper
|
{
|
};
|
|
template<>
|
struct SimdHelper<SIMD256>
|
{
|
static SIMD256::Float insert_lo_ps(SIMD256::Float a)
|
{
|
return a;
|
}
|
|
static SIMD256::Mask cmpeq_ps_mask(SIMD256::Float a, SIMD256::Float b)
|
{
|
return SIMD256::movemask_ps(SIMD256::cmpeq_ps(a, b));
|
}
|
};
|
|
#if USE_SIMD16_FRONTEND
|
template<>
|
struct SimdHelper<SIMD512>
|
{
|
static SIMD512::Float insert_lo_ps(SIMD256::Float a)
|
{
|
return SIMD512::insert_ps<0>(SIMD512::setzero_ps(), a);
|
}
|
|
static SIMD512::Mask cmpeq_ps_mask(SIMD512::Float a, SIMD512::Float b)
|
{
|
return SIMD512::cmp_ps_mask<SIMD16::CompareType::EQ_OQ>(a, b);
|
}
|
};
|
|
#endif
|
// Temp storage used by the clipper
|
template<typename SIMD_T>
|
struct ClipHelper
|
{
|
};
|
|
template<>
|
struct ClipHelper<SIMD256>
|
{
|
static SIMDVERTEX_T<SIMD256> *GetTempVertices()
|
{
|
return tlsTempVertices;
|
}
|
};
|
|
#if USE_SIMD16_FRONTEND
|
template<>
|
struct ClipHelper<SIMD512>
|
{
|
static SIMDVERTEX_T<SIMD512> *GetTempVertices()
|
{
|
return tlsTempVertices_simd16;
|
}
|
};
|
|
#endif
|
template<typename SIMD_T, uint32_t NumVertsPerPrim>
|
class Clipper
|
{
|
public:
|
INLINE Clipper(uint32_t in_workerId, DRAW_CONTEXT* in_pDC) :
|
workerId(in_workerId), pDC(in_pDC), state(GetApiState(in_pDC))
|
{
|
static_assert(NumVertsPerPrim >= 1 && NumVertsPerPrim <= 3, "Invalid NumVertsPerPrim");
|
}
|
|
void ComputeClipCodes(typename SIMD_T::Vec4 vertex[], const typename SIMD_T::Integer &viewportIndexes)
|
{
|
for (uint32_t i = 0; i < NumVertsPerPrim; ++i)
|
{
|
::ComputeClipCodes<SIMD_T>(state, vertex[i], clipCodes[i], viewportIndexes);
|
}
|
}
|
|
typename SIMD_T::Float ComputeClipCodeIntersection()
|
{
|
typename SIMD_T::Float result = clipCodes[0];
|
|
for (uint32_t i = 1; i < NumVertsPerPrim; ++i)
|
{
|
result = SIMD_T::and_ps(result, clipCodes[i]);
|
}
|
|
return result;
|
}
|
|
typename SIMD_T::Float ComputeClipCodeUnion()
|
{
|
typename SIMD_T::Float result = clipCodes[0];
|
|
for (uint32_t i = 1; i < NumVertsPerPrim; ++i)
|
{
|
result = SIMD_T::or_ps(result, clipCodes[i]);
|
}
|
|
return result;
|
}
|
|
int ComputeClipMask()
|
{
|
typename SIMD_T::Float clipUnion = ComputeClipCodeUnion();
|
|
clipUnion = SIMD_T::and_ps(clipUnion, SIMD_T::castsi_ps(SIMD_T::set1_epi32(GUARDBAND_CLIP_MASK)));
|
|
return SIMD_T::movemask_ps(SIMD_T::cmpneq_ps(clipUnion, SIMD_T::setzero_ps()));
|
}
|
|
// clipper is responsible for culling any prims with NAN coordinates
|
int ComputeNaNMask(typename SIMD_T::Vec4 prim[])
|
{
|
typename SIMD_T::Float 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]);
|
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]);
|
vNanMask = SIMD_T::or_ps(vNanMask, vNan23);
|
}
|
|
return SIMD_T::movemask_ps(vNanMask);
|
}
|
|
int ComputeUserClipCullMask(PA_STATE &pa, typename SIMD_T::Vec4 prim[])
|
{
|
uint8_t cullMask = state.backendState.cullDistanceMask;
|
uint32_t vertexClipCullOffset = state.backendState.vertexClipCullOffset;
|
|
typename SIMD_T::Float vClipCullMask = SIMD_T::setzero_ps();
|
|
typename SIMD_T::Vec4 vClipCullDistLo[3];
|
typename SIMD_T::Vec4 vClipCullDistHi[3];
|
|
pa.Assemble(vertexClipCullOffset, vClipCullDistLo);
|
pa.Assemble(vertexClipCullOffset + 1, vClipCullDistHi);
|
|
DWORD index;
|
while (_BitScanForward(&index, cullMask))
|
{
|
cullMask &= ~(1 << index);
|
uint32_t slot = index >> 2;
|
uint32_t component = index & 0x3;
|
|
typename SIMD_T::Float vCullMaskElem = SIMD_T::set1_ps(-1.0f);
|
for (uint32_t e = 0; e < NumVertsPerPrim; ++e)
|
{
|
typename SIMD_T::Float vCullComp;
|
if (slot == 0)
|
{
|
vCullComp = vClipCullDistLo[e][component];
|
}
|
else
|
{
|
vCullComp = vClipCullDistHi[e][component];
|
}
|
|
// 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);
|
vCullMaskElem = SIMD_T::and_ps(vCullMaskElem, vCull);
|
}
|
vClipCullMask = SIMD_T::or_ps(vClipCullMask, vCullMaskElem);
|
}
|
|
// clipper should also discard any primitive with NAN clip distance
|
uint8_t clipMask = state.backendState.clipDistanceMask;
|
while (_BitScanForward(&index, clipMask))
|
{
|
clipMask &= ~(1 << index);
|
uint32_t slot = index >> 2;
|
uint32_t component = index & 0x3;
|
|
for (uint32_t e = 0; e < NumVertsPerPrim; ++e)
|
{
|
typename SIMD_T::Float vClipComp;
|
if (slot == 0)
|
{
|
vClipComp = vClipCullDistLo[e][component];
|
}
|
else
|
{
|
vClipComp = vClipCullDistHi[e][component];
|
}
|
|
typename SIMD_T::Float vClip = SIMD_T::template cmp_ps<SIMD_T::CompareType::UNORD_Q>(vClipComp, vClipComp);
|
vClipCullMask = SIMD_T::or_ps(vClipCullMask, vClip);
|
}
|
}
|
|
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)
|
{
|
// input/output vertex store for clipper
|
SIMDVERTEX_T<SIMD_T> vertices[7]; // maximum 7 verts generated per triangle
|
|
uint32_t constantInterpMask = state.backendState.constantInterpolationMask;
|
uint32_t provokingVertex = 0;
|
if (pa.binTopology == TOP_TRIANGLE_FAN)
|
{
|
provokingVertex = state.frontendState.provokingVertex.triFan;
|
}
|
///@todo: line topology for wireframe?
|
|
// assemble pos
|
typename SIMD_T::Vec4 tmpVector[NumVertsPerPrim];
|
for (uint32_t i = 0; i < NumVertsPerPrim; ++i)
|
{
|
vertices[i].attrib[VERTEX_POSITION_SLOT] = prim[i];
|
}
|
|
// assemble attribs
|
const SWR_BACKEND_STATE& backendState = state.backendState;
|
|
int32_t maxSlot = -1;
|
for (uint32_t slot = 0; slot < backendState.numAttributes; ++slot)
|
{
|
// Compute absolute attrib slot in vertex array
|
uint32_t mapSlot = backendState.swizzleEnable ? backendState.swizzleMap[slot].sourceAttrib : slot;
|
maxSlot = std::max<int32_t>(maxSlot, mapSlot);
|
uint32_t inputSlot = backendState.vertexAttribOffset + mapSlot;
|
|
pa.Assemble(inputSlot, tmpVector);
|
|
// if constant interpolation enabled for this attribute, assign the provoking
|
// vertex values to all edges
|
if (CheckBit(constantInterpMask, slot))
|
{
|
for (uint32_t i = 0; i < NumVertsPerPrim; ++i)
|
{
|
vertices[i].attrib[inputSlot] = tmpVector[provokingVertex];
|
}
|
}
|
else
|
{
|
for (uint32_t i = 0; i < NumVertsPerPrim; ++i)
|
{
|
vertices[i].attrib[inputSlot] = tmpVector[i];
|
}
|
}
|
}
|
|
// assemble user clip distances if enabled
|
uint32_t vertexClipCullSlot = state.backendState.vertexClipCullOffset;
|
if (state.backendState.clipDistanceMask & 0xf)
|
{
|
pa.Assemble(vertexClipCullSlot, tmpVector);
|
for (uint32_t i = 0; i < NumVertsPerPrim; ++i)
|
{
|
vertices[i].attrib[vertexClipCullSlot] = tmpVector[i];
|
}
|
}
|
|
if (state.backendState.clipDistanceMask & 0xf0)
|
{
|
pa.Assemble(vertexClipCullSlot + 1, tmpVector);
|
for (uint32_t i = 0; i < NumVertsPerPrim; ++i)
|
{
|
vertices[i].attrib[vertexClipCullSlot + 1] = tmpVector[i];
|
}
|
}
|
|
uint32_t numAttribs = maxSlot + 1;
|
|
typename SIMD_T::Integer vNumClippedVerts = ClipPrims((float*)&vertices[0], vPrimMask, vClipMask, numAttribs);
|
|
BinnerChooser<SIMD_T> binner(NumVertsPerPrim, pa.pDC->pState->state.rastState.conservativeRast);
|
|
// set up new PA for binning clipped primitives
|
PRIMITIVE_TOPOLOGY clipTopology = TOP_UNKNOWN;
|
if (NumVertsPerPrim == 3)
|
{
|
clipTopology = TOP_TRIANGLE_FAN;
|
|
// so that the binner knows to bloat wide points later
|
if (pa.binTopology == TOP_POINT_LIST)
|
{
|
clipTopology = TOP_POINT_LIST;
|
}
|
}
|
else if (NumVertsPerPrim == 2)
|
{
|
clipTopology = TOP_LINE_LIST;
|
}
|
else
|
{
|
SWR_ASSERT(0 && "Unexpected points in clipper.");
|
}
|
|
const uint32_t *pVertexCount = reinterpret_cast<const uint32_t *>(&vNumClippedVerts);
|
const uint32_t *pPrimitiveId = reinterpret_cast<const uint32_t *>(&vPrimId);
|
const uint32_t *pViewportIdx = reinterpret_cast<const uint32_t *>(&vViewportIdx);
|
const uint32_t *pRtIdx = reinterpret_cast<const uint32_t *>(&vRtIdx);
|
|
const SIMD256::Integer vOffsets = SIMD256::set_epi32(
|
0 * sizeof(SIMDVERTEX_T<SIMD_T>), // unused lane
|
6 * sizeof(SIMDVERTEX_T<SIMD_T>),
|
5 * sizeof(SIMDVERTEX_T<SIMD_T>),
|
4 * sizeof(SIMDVERTEX_T<SIMD_T>),
|
3 * sizeof(SIMDVERTEX_T<SIMD_T>),
|
2 * sizeof(SIMDVERTEX_T<SIMD_T>),
|
1 * sizeof(SIMDVERTEX_T<SIMD_T>),
|
0 * sizeof(SIMDVERTEX_T<SIMD_T>));
|
|
// only need to gather 7 verts
|
// @todo dynamic mask based on actual # of verts generated per lane
|
const SIMD256::Float vMask = SIMD256::set_ps(0, -1, -1, -1, -1, -1, -1, -1);
|
|
uint32_t numClippedPrims = 0;
|
|
// tranpose clipper output so that each lane's vertices are in SIMD order
|
// set aside space for 2 vertices, as the PA will try to read up to 16 verts
|
// for triangle fan
|
|
#if defined(_DEBUG)
|
// TODO: need to increase stack size, allocating SIMD16-widened transposedPrims causes stack overflow in debug builds
|
SIMDVERTEX_T<SIMD_T> *transposedPrims = reinterpret_cast<SIMDVERTEX_T<SIMD_T> *>(AlignedMalloc(sizeof(SIMDVERTEX_T<SIMD_T>) * 2, 64));
|
|
#else
|
SIMDVERTEX_T<SIMD_T> transposedPrims[2];
|
|
#endif
|
uint32_t numInputPrims = pa.NumPrims();
|
for (uint32_t inputPrim = 0; inputPrim < numInputPrims; ++inputPrim)
|
{
|
uint32_t numEmittedVerts = pVertexCount[inputPrim];
|
if (numEmittedVerts < NumVertsPerPrim)
|
{
|
continue;
|
}
|
SWR_ASSERT(numEmittedVerts <= 7, "Unexpected vertex count from clipper.");
|
|
uint32_t numEmittedPrims = GetNumPrims(clipTopology, numEmittedVerts);
|
SWR_ASSERT(numEmittedPrims <= 7, "Unexpected primitive count from clipper.");
|
|
numClippedPrims += numEmittedPrims;
|
|
// tranpose clipper output so that each lane's vertices are in SIMD order
|
// set aside space for 2 vertices, as the PA will try to read up to 16 verts
|
// for triangle fan
|
|
// transpose pos
|
uint8_t *pBase = reinterpret_cast<uint8_t *>(&vertices[0].attrib[VERTEX_POSITION_SLOT]) + sizeof(float) * inputPrim;
|
|
#if 0
|
// TEMPORARY WORKAROUND for bizarre VS2015 code-gen bug
|
static const float *dummy = reinterpret_cast<const float *>(pBase);
|
|
#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);
|
transposedPrims[0].attrib[VERTEX_POSITION_SLOT][c] = SimdHelper<SIMD_T>::insert_lo_ps(temp);
|
pBase += sizeof(typename SIMD_T::Float);
|
}
|
|
// transpose attribs
|
pBase = reinterpret_cast<uint8_t *>(&vertices[0].attrib[backendState.vertexAttribOffset]) + sizeof(float) * inputPrim;
|
|
for (uint32_t attrib = 0; attrib < numAttribs; ++attrib)
|
{
|
uint32_t attribSlot = backendState.vertexAttribOffset + attrib;
|
|
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);
|
transposedPrims[0].attrib[attribSlot][c] = SimdHelper<SIMD_T>::insert_lo_ps(temp);
|
pBase += sizeof(typename SIMD_T::Float);
|
}
|
}
|
|
// transpose user clip distances if enabled
|
uint32_t vertexClipCullSlot = backendState.vertexClipCullOffset;
|
if (state.backendState.clipDistanceMask & 0x0f)
|
{
|
pBase = reinterpret_cast<uint8_t *>(&vertices[0].attrib[vertexClipCullSlot]) + sizeof(float) * inputPrim;
|
|
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);
|
transposedPrims[0].attrib[vertexClipCullSlot][c] = SimdHelper<SIMD_T>::insert_lo_ps(temp);
|
pBase += sizeof(typename SIMD_T::Float);
|
}
|
}
|
|
if (state.backendState.clipDistanceMask & 0xf0)
|
{
|
pBase = reinterpret_cast<uint8_t *>(&vertices[0].attrib[vertexClipCullSlot + 1]) + sizeof(float) * inputPrim;
|
|
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);
|
transposedPrims[0].attrib[vertexClipCullSlot + 1][c] = SimdHelper<SIMD_T>::insert_lo_ps(temp);
|
pBase += sizeof(typename SIMD_T::Float);
|
}
|
}
|
|
PA_STATE_OPT clipPA(pDC, numEmittedPrims, reinterpret_cast<uint8_t *>(&transposedPrims[0]), numEmittedVerts, SWR_VTX_NUM_SLOTS, true, NumVertsPerPrim, clipTopology);
|
clipPA.viewportArrayActive = pa.viewportArrayActive;
|
clipPA.rtArrayActive = pa.rtArrayActive;
|
|
static const uint32_t primMaskMap[] = { 0x0, 0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f };
|
|
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]);
|
|
|
while (clipPA.GetNextStreamOutput())
|
{
|
do
|
{
|
typename SIMD_T::Vec4 attrib[NumVertsPerPrim];
|
|
bool assemble = clipPA.Assemble(VERTEX_POSITION_SLOT, attrib);
|
|
if (assemble)
|
{
|
binner.pfnBinFunc(pDC, clipPA, workerId, attrib, primMask, primID, viewportIdx, rtIdx);
|
}
|
|
} while (clipPA.NextPrim());
|
}
|
}
|
|
#if defined(_DEBUG)
|
AlignedFree(transposedPrims);
|
|
#endif
|
// update global pipeline stat
|
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)
|
{
|
SWR_ASSERT(pa.pDC != nullptr);
|
|
SWR_CONTEXT *pContext = pa.pDC->pContext;
|
|
BinnerChooser<SIMD_T> binner(pa.binTopology, pa.pDC->pState->state.rastState.conservativeRast);
|
|
// update clipper invocations pipeline stat
|
uint32_t numInvoc = _mm_popcnt_u32(primMask);
|
UPDATE_STAT_FE(CInvocations, numInvoc);
|
|
ComputeClipCodes(prim, viewportIdx);
|
|
// cull prims with NAN coords
|
primMask &= ~ComputeNaNMask(prim);
|
|
// user cull distance cull
|
if (state.backendState.cullDistanceMask)
|
{
|
primMask &= ~ComputeUserClipCullMask(pa, prim);
|
}
|
|
// cull prims outside view frustum
|
typename SIMD_T::Float clipIntersection = ComputeClipCodeIntersection();
|
int validMask = primMask & SimdHelper<SIMD_T>::cmpeq_ps_mask(clipIntersection, SIMD_T::setzero_ps());
|
|
// skip clipping for points
|
uint32_t clipMask = 0;
|
if (NumVertsPerPrim != 1)
|
{
|
clipMask = primMask & ComputeClipMask();
|
}
|
|
if (clipMask)
|
{
|
AR_BEGIN(FEGuardbandClip, pa.pDC->drawId);
|
// we have to clip tris, execute the clipper, which will also
|
// call the binner
|
ClipSimd(prim, SIMD_T::vmask_ps(primMask), SIMD_T::vmask_ps(clipMask), pa, primId, viewportIdx, rtIdx);
|
AR_END(FEGuardbandClip, 1);
|
}
|
else if (validMask)
|
{
|
// update CPrimitives pipeline state
|
UPDATE_STAT_FE(CPrimitives, _mm_popcnt_u32(validMask));
|
|
// forward valid prims directly to binner
|
binner.pfnBinFunc(this->pDC, pa, this->workerId, prim, validMask, primId, viewportIdx, rtIdx);
|
}
|
}
|
|
private:
|
typename SIMD_T::Float ComputeInterpFactor(typename SIMD_T::Float const &boundaryCoord0, typename SIMD_T::Float 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)
|
{
|
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);
|
|
static const OSALIGNSIMD16(uint32_t) elemOffset[16] =
|
{
|
0 * sizeof(float),
|
1 * sizeof(float),
|
2 * sizeof(float),
|
3 * sizeof(float),
|
4 * sizeof(float),
|
5 * sizeof(float),
|
6 * sizeof(float),
|
7 * sizeof(float),
|
8 * sizeof(float),
|
9 * sizeof(float),
|
10 * sizeof(float),
|
11 * sizeof(float),
|
12 * sizeof(float),
|
13 * sizeof(float),
|
14 * sizeof(float),
|
15 * sizeof(float),
|
};
|
|
static_assert(sizeof(typename SIMD_T::Integer) <= 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));
|
|
// step to the simdvertex
|
typename SIMD_T::Integer 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));
|
|
// step to the lane
|
vOffsets = SIMD_T::add_epi32(vOffsets, vElemOffset);
|
|
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)
|
{
|
typename SIMD_T::Integer vOffsets = ComputeOffsets(attrib, vIndices, component);
|
typename SIMD_T::Float vSrc = SIMD_T::setzero_ps();
|
|
return SIMD_T::template mask_i32gather_ps<typename SIMD_T::ScaleFactor(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)
|
{
|
typename SIMD_T::Integer vOffsets = ComputeOffsets(attrib, vIndices, component);
|
|
const uint32_t *pOffsets = reinterpret_cast<const uint32_t *>(&vOffsets);
|
const float *pSrc = reinterpret_cast<const float *>(&vSrc);
|
uint32_t mask = SIMD_T::movemask_ps(vMask);
|
DWORD lane;
|
while (_BitScanForward(&lane, mask))
|
{
|
mask &= ~(1 << lane);
|
const uint8_t *pBuf = reinterpret_cast<const uint8_t *>(pBuffer) + pOffsets[lane];
|
*(float *)pBuf = pSrc[lane];
|
}
|
}
|
|
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 *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.
|
{
|
uint32_t vertexAttribOffset = this->state.backendState.vertexAttribOffset;
|
uint32_t vertexClipCullOffset = this->state.backendState.vertexClipCullOffset;
|
|
// compute interpolation factor
|
typename SIMD_T::Float 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;
|
case FRUSTUM_RIGHT: t = ComputeInterpFactor(SIMD_T::sub_ps(v1[3], v1[0]), SIMD_T::sub_ps(v2[3], v2[0])); break;
|
case FRUSTUM_TOP: t = ComputeInterpFactor(SIMD_T::add_ps(v1[3], v1[1]), SIMD_T::add_ps(v2[3], v2[1])); break;
|
case FRUSTUM_BOTTOM: t = ComputeInterpFactor(SIMD_T::sub_ps(v1[3], v1[1]), SIMD_T::sub_ps(v2[3], v2[1])); break;
|
case FRUSTUM_NEAR:
|
// DX Znear plane is 0, GL is -w
|
if (this->state.rastState.clipHalfZ)
|
{
|
t = ComputeInterpFactor(v1[2], v2[2]);
|
}
|
else
|
{
|
t = ComputeInterpFactor(SIMD_T::add_ps(v1[3], v1[2]), SIMD_T::add_ps(v2[3], v2[2]));
|
}
|
break;
|
case FRUSTUM_FAR: t = ComputeInterpFactor(SIMD_T::sub_ps(v1[3], v1[2]), SIMD_T::sub_ps(v2[3], v2[2])); break;
|
default: SWR_INVALID("invalid clipping plane: %d", ClippingPlane);
|
};
|
|
// 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]);
|
ScatterComponent(pOutVerts, VERTEX_POSITION_SLOT, vActiveMask, outIndex, c, vOutPos);
|
}
|
|
// interpolate attributes and store
|
for (uint32_t a = 0; a < numInAttribs; ++a)
|
{
|
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);
|
ScatterComponent(pOutVerts, attribSlot, vActiveMask, outIndex, c, vOutAttrib);
|
}
|
}
|
|
// interpolate clip distance if enabled
|
if (this->state.backendState.clipDistanceMask & 0xf)
|
{
|
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);
|
ScatterComponent(pOutVerts, attribSlot, vActiveMask, outIndex, c, vOutAttrib);
|
}
|
}
|
|
if (this->state.backendState.clipDistanceMask & 0xf0)
|
{
|
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);
|
ScatterComponent(pOutVerts, attribSlot, vActiveMask, outIndex, c, vOutAttrib);
|
}
|
}
|
}
|
|
template<SWR_CLIPCODES ClippingPlane>
|
typename SIMD_T::Float inside(const typename SIMD_T::Vec4 &v)
|
{
|
switch (ClippingPlane)
|
{
|
case FRUSTUM_LEFT: return SIMD_T::cmpge_ps(v[0], SIMD_T::mul_ps(v[3], SIMD_T::set1_ps(-1.0f)));
|
case FRUSTUM_RIGHT: return SIMD_T::cmple_ps(v[0], v[3]);
|
case FRUSTUM_TOP: return SIMD_T::cmpge_ps(v[1], SIMD_T::mul_ps(v[3], SIMD_T::set1_ps(-1.0f)));
|
case FRUSTUM_BOTTOM: return SIMD_T::cmple_ps(v[1], v[3]);
|
case FRUSTUM_NEAR: return SIMD_T::cmpge_ps(v[2], this->state.rastState.clipHalfZ ? SIMD_T::setzero_ps() : SIMD_T::mul_ps(v[3], SIMD_T::set1_ps(-1.0f)));
|
case FRUSTUM_FAR: return SIMD_T::cmple_ps(v[2], v[3]);
|
default:
|
SWR_INVALID("invalid clipping plane: %d", ClippingPlane);
|
return SIMD_T::setzero_ps();
|
}
|
}
|
|
template<SWR_CLIPCODES ClippingPlane>
|
typename SIMD_T::Integer ClipTriToPlane(const float *pInVerts, const typename SIMD_T::Integer &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));
|
|
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);
|
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;
|
for (uint32_t c = 0; c < 4; ++c)
|
{
|
vInPos0[c] = GatherComponent(pInVerts, VERTEX_POSITION_SLOT, vActiveMask, s, c);
|
vInPos1[c] = GatherComponent(pInVerts, VERTEX_POSITION_SLOT, vActiveMask, p, c);
|
}
|
|
// compute inside mask
|
typename SIMD_T::Float s_in = inside<ClippingPlane>(vInPos0);
|
typename SIMD_T::Float 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);
|
intersectMask = SIMD_T::and_ps(intersectMask, vActiveMask);
|
|
// store s if inside
|
s_in = SIMD_T::and_ps(s_in, vActiveMask);
|
if (!SIMD_T::testz_ps(s_in, s_in))
|
{
|
// store position
|
for (uint32_t c = 0; c < 4; ++c)
|
{
|
ScatterComponent(pOutVerts, VERTEX_POSITION_SLOT, s_in, vOutIndex, c, vInPos0[c]);
|
}
|
|
// store attribs
|
for (uint32_t a = 0; a < numInAttribs; ++a)
|
{
|
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);
|
ScatterComponent(pOutVerts, attribSlot, s_in, vOutIndex, c, vAttrib);
|
}
|
}
|
|
// store clip distance if enabled
|
uint32_t vertexClipCullSlot = this->state.backendState.vertexClipCullOffset;
|
if (this->state.backendState.clipDistanceMask & 0xf)
|
{
|
uint32_t attribSlot = vertexClipCullSlot;
|
for (uint32_t c = 0; c < 4; ++c)
|
{
|
typename SIMD_T::Float vAttrib = GatherComponent(pInVerts, attribSlot, s_in, s, c);
|
ScatterComponent(pOutVerts, attribSlot, s_in, vOutIndex, c, vAttrib);
|
}
|
}
|
|
if (this->state.backendState.clipDistanceMask & 0xf0)
|
{
|
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);
|
ScatterComponent(pOutVerts, attribSlot, s_in, vOutIndex, c, vAttrib);
|
}
|
}
|
|
// increment outIndex
|
vOutIndex = SIMD_T::blendv_epi32(vOutIndex, SIMD_T::add_epi32(vOutIndex, SIMD_T::set1_epi32(1)), s_in);
|
}
|
|
// compute and store intersection
|
if (!SIMD_T::testz_ps(intersectMask, intersectMask))
|
{
|
intersect<ClippingPlane>(intersectMask, s, p, vInPos0, vInPos1, vOutIndex, pInVerts, numInAttribs, pOutVerts);
|
|
// increment outIndex for active lanes
|
vOutIndex = SIMD_T::blendv_epi32(vOutIndex, SIMD_T::add_epi32(vOutIndex, SIMD_T::set1_epi32(1)), intersectMask);
|
}
|
|
// increment loop index and update active mask
|
vCurIndex = SIMD_T::add_epi32(vCurIndex, SIMD_T::set1_epi32(1));
|
vActiveMask = SIMD_T::castsi_ps(SIMD_T::cmplt_epi32(vCurIndex, vNumInPts));
|
}
|
|
return vOutIndex;
|
}
|
|
template<SWR_CLIPCODES ClippingPlane>
|
typename SIMD_T::Integer ClipLineToPlane(const float *pInVerts, const typename SIMD_T::Integer &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));
|
|
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));
|
|
// gather position
|
typename SIMD_T::Vec4 vInPos0, vInPos1;
|
for (uint32_t c = 0; c < 4; ++c)
|
{
|
vInPos0[c] = GatherComponent(pInVerts, VERTEX_POSITION_SLOT, vActiveMask, s, c);
|
vInPos1[c] = GatherComponent(pInVerts, VERTEX_POSITION_SLOT, vActiveMask, p, c);
|
}
|
|
// compute inside mask
|
typename SIMD_T::Float s_in = inside<ClippingPlane>(vInPos0);
|
typename SIMD_T::Float 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);
|
intersectMask = SIMD_T::and_ps(intersectMask, vActiveMask);
|
|
// store s if inside
|
s_in = SIMD_T::and_ps(s_in, vActiveMask);
|
if (!SIMD_T::testz_ps(s_in, s_in))
|
{
|
for (uint32_t c = 0; c < 4; ++c)
|
{
|
ScatterComponent(pOutVerts, VERTEX_POSITION_SLOT, s_in, vOutIndex, c, vInPos0[c]);
|
}
|
|
// interpolate attributes and store
|
for (uint32_t a = 0; a < numInAttribs; ++a)
|
{
|
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);
|
ScatterComponent(pOutVerts, attribSlot, s_in, vOutIndex, c, vAttrib);
|
}
|
}
|
|
// increment outIndex
|
vOutIndex = SIMD_T::blendv_epi32(vOutIndex, SIMD_T::add_epi32(vOutIndex, SIMD_T::set1_epi32(1)), s_in);
|
}
|
|
// compute and store intersection
|
if (!SIMD_T::testz_ps(intersectMask, intersectMask))
|
{
|
intersect<ClippingPlane>(intersectMask, s, p, vInPos0, vInPos1, vOutIndex, pInVerts, numInAttribs, pOutVerts);
|
|
// increment outIndex for active lanes
|
vOutIndex = SIMD_T::blendv_epi32(vOutIndex, SIMD_T::add_epi32(vOutIndex, SIMD_T::set1_epi32(1)), intersectMask);
|
}
|
|
// store p if inside
|
p_in = SIMD_T::and_ps(p_in, vActiveMask);
|
if (!SIMD_T::testz_ps(p_in, p_in))
|
{
|
for (uint32_t c = 0; c < 4; ++c)
|
{
|
ScatterComponent(pOutVerts, VERTEX_POSITION_SLOT, p_in, vOutIndex, c, vInPos1[c]);
|
}
|
|
// interpolate attributes and store
|
for (uint32_t a = 0; a < numInAttribs; ++a)
|
{
|
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);
|
ScatterComponent(pOutVerts, attribSlot, p_in, vOutIndex, c, vAttrib);
|
}
|
}
|
|
// increment outIndex
|
vOutIndex = SIMD_T::blendv_epi32(vOutIndex, SIMD_T::add_epi32(vOutIndex, SIMD_T::set1_epi32(1)), p_in);
|
}
|
}
|
|
return vOutIndex;
|
}
|
|
typename SIMD_T::Integer ClipPrims(float *pVertices, const typename SIMD_T::Float &vPrimMask, const typename SIMD_T::Float &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);
|
vNumInPts = SIMD_T::blendv_epi32(SIMD_T::setzero_si(), vNumInPts, vClipMask);
|
|
// clip prims to frustum
|
typename SIMD_T::Integer vNumOutPts;
|
if (NumVertsPerPrim == 3)
|
{
|
vNumOutPts = ClipTriToPlane<FRUSTUM_NEAR>(pVertices, vNumInPts, numAttribs, pTempVerts);
|
vNumOutPts = ClipTriToPlane<FRUSTUM_FAR>(pTempVerts, vNumOutPts, numAttribs, pVertices);
|
vNumOutPts = ClipTriToPlane<FRUSTUM_LEFT>(pVertices, vNumOutPts, numAttribs, pTempVerts);
|
vNumOutPts = ClipTriToPlane<FRUSTUM_RIGHT>(pTempVerts, vNumOutPts, numAttribs, pVertices);
|
vNumOutPts = ClipTriToPlane<FRUSTUM_BOTTOM>(pVertices, vNumOutPts, numAttribs, pTempVerts);
|
vNumOutPts = ClipTriToPlane<FRUSTUM_TOP>(pTempVerts, vNumOutPts, numAttribs, pVertices);
|
}
|
else
|
{
|
SWR_ASSERT(NumVertsPerPrim == 2);
|
vNumOutPts = ClipLineToPlane<FRUSTUM_NEAR>(pVertices, vNumInPts, numAttribs, pTempVerts);
|
vNumOutPts = ClipLineToPlane<FRUSTUM_FAR>(pTempVerts, vNumOutPts, numAttribs, pVertices);
|
vNumOutPts = ClipLineToPlane<FRUSTUM_LEFT>(pVertices, vNumOutPts, numAttribs, pTempVerts);
|
vNumOutPts = ClipLineToPlane<FRUSTUM_RIGHT>(pTempVerts, vNumOutPts, numAttribs, pVertices);
|
vNumOutPts = ClipLineToPlane<FRUSTUM_BOTTOM>(pVertices, vNumOutPts, numAttribs, pTempVerts);
|
vNumOutPts = ClipLineToPlane<FRUSTUM_TOP>(pTempVerts, vNumOutPts, numAttribs, pVertices);
|
}
|
|
// restore num verts for non-clipped, active lanes
|
typename SIMD_T::Float vNonClippedMask = SIMD_T::andnot_ps(vClipMask, vPrimMask);
|
vNumOutPts = SIMD_T::blendv_epi32(vNumOutPts, SIMD_T::set1_epi32(NumVertsPerPrim), vNonClippedMask);
|
|
return vNumOutPts;
|
}
|
|
const uint32_t workerId{ 0 };
|
DRAW_CONTEXT *pDC{ nullptr };
|
const API_STATE &state;
|
typename SIMD_T::Float clipCodes[NumVertsPerPrim];
|
};
|
|
|
// pipeline stage functions
|
void ClipTriangles(DRAW_CONTEXT *pDC, PA_STATE& pa, uint32_t workerId, simdvector prims[], uint32_t primMask, simdscalari const &primId, simdscalari const &viewportIdx, simdscalari const &rtIdx);
|
void ClipLines(DRAW_CONTEXT *pDC, PA_STATE& pa, uint32_t workerId, simdvector prims[], uint32_t primMask, simdscalari const &primId, simdscalari const &viewportIdx, simdscalari const &rtIdx);
|
void ClipPoints(DRAW_CONTEXT *pDC, PA_STATE& pa, uint32_t workerId, simdvector prims[], uint32_t primMask, simdscalari const &primId, simdscalari const &viewportIdx, simdscalari const &rtIdx);
|
#if USE_SIMD16_FRONTEND
|
void SIMDCALL ClipTriangles_simd16(DRAW_CONTEXT *pDC, PA_STATE& pa, uint32_t workerId, simd16vector prims[], uint32_t primMask, simd16scalari const &primId, simd16scalari const &viewportIdx, simd16scalari const &rtIdx);
|
void SIMDCALL ClipLines_simd16(DRAW_CONTEXT *pDC, PA_STATE& pa, uint32_t workerId, simd16vector prims[], uint32_t primMask, simd16scalari const &primId, simd16scalari const &viewportIdx, simd16scalari const &rtIdx);
|
void SIMDCALL ClipPoints_simd16(DRAW_CONTEXT *pDC, PA_STATE& pa, uint32_t workerId, simd16vector prims[], uint32_t primMask, simd16scalari const &primId, simd16scalari const &viewportIdx, simd16scalari const &rtIdx);
|
#endif
|
