static CRect _FeedMinMaxUV(const TMemoryView<const CFloat2> &texcoords)
{
HH_ASSERT(!texcoords.Empty());
// SIMD loop below 22 times faster than naive C++ loop with HHMin/HHMax on
// the CFloat2 values that was generating branches + cmovs.
const CFloat2 *srcUV = texcoords.Data();
const CFloat2 *srcUVStop = texcoords.DataEnd();
SIMD::Scalar minU = srcUV->x();
SIMD::Scalar minV = srcUV->y();
SIMD::Scalar maxU = minU;
SIMD::Scalar maxV = minV;
if (Mem::IsAligned<0x10>(texcoords.Data()))
{
SIMD::Float4 minUVx4_01 = SIMD::Float4(minU, minV, minU, minV);
SIMD::Float4 maxUVx4_01 = minUVx4_01;
SIMD::Float4 minUVx4_23 = minUVx4_01;
SIMD::Float4 maxUVx4_23 = maxUVx4_01;
srcUVStop -= 4;
while (srcUV <= srcUVStop)
{
const SIMD::Float4 uv0uv1 = SIMD::Float4::LoadAligned16(srcUV, 0x00);
const SIMD::Float4 uv2uv3 = SIMD::Float4::LoadAligned16(srcUV, 0x10);
minUVx4_01 = SIMD::Min(minUVx4_01, uv0uv1);
maxUVx4_01 = SIMD::Max(maxUVx4_01, uv0uv1);
minUVx4_23 = SIMD::Min(minUVx4_23, uv2uv3);
maxUVx4_23 = SIMD::Max(maxUVx4_23, uv2uv3);
srcUV += 4;
}
srcUVStop += 4;
const SIMD::Float4 minUVx4 = SIMD::Min(minUVx4_01, minUVx4_23);
const SIMD::Float4 maxUVx4 = SIMD::Max(maxUVx4_01, maxUVx4_23);
const SIMD::Float4 hMin = SIMD::Min(minUVx4, minUVx4.Swizzle<2,3,2,3>()); // movehl
const SIMD::Float4 hMax = SIMD::Max(maxUVx4, maxUVx4.Swizzle<2,3,2,3>()); // movehl
minV = hMin.y();
minU = hMin.x();
maxV = hMax.y();
maxU = hMax.x();
}
while (srcUV < srcUVStop)
{
const SIMD::Scalar u = SIMD::Scalar::Load(srcUV, 0);
const SIMD::Scalar v = SIMD::Scalar::Load(srcUV, 4);
minU = SIMD::Min(minU, u);
minV = SIMD::Min(minV, v);
maxU = SIMD::Max(maxU, u);
maxV = SIMD::Max(maxV, v);
srcUV += 1;
}
return CRect::FromMinMaxUnchecked( CFloat2(minU.AsFloat(), minV.AsFloat()),
CFloat2(maxU.AsFloat(), maxV.AsFloat()));
}
//----------------------------------------------------------------------------
static bool _TriangleOverlapsBox(const CFloat2 &pa, const CFloat2 &pb, const CFloat2 &pc, const CFloat4 (&cellBoxCenterAndHalfWidth)[2])
{
// The cell box center and half widths we're given should be broadcasted to a float4 in 'xyxy' form
const SIMD::Float4 vbc = SIMD::Float4::LoadAligned16(cellBoxCenterAndHalfWidth, 0x00);
const SIMD::Float4 vbw = SIMD::Float4::LoadAligned16(cellBoxCenterAndHalfWidth, 0x10);
const SIMD::Float4 kSwapZWSign = SIMD::Float4::FromConstInt<0,0,0x80000000,0x80000000>();
const SIMD::Float4 vla = SIMD::Float4::LoadUnaligned(&pa).Swizzle<0,1,0,1>() - vbc; // NOTE: could also do a 'SIMD::Float4::LoadUnaligned_LoHi(&pa, &pa) - vbc'
const SIMD::Float4 vlb = SIMD::Float4::LoadUnaligned(&pb).Swizzle<0,1,0,1>() - vbc;
const SIMD::Float4 vlc = SIMD::Float4::LoadUnaligned(&pc).Swizzle<0,1,0,1>() - vbc;
// Early-out test: triangle bbox vs cell bbox overlap test: if boxes don't overlap, reject
const SIMD::Float4 vlaSwap = vla ^ kSwapZWSign;
const SIMD::Float4 vlbSwap = vlb ^ kSwapZWSign;
const SIMD::Float4 vlcSwap = vlc ^ kSwapZWSign;
const SIMD::Float4 vMinMax = SIMD::Min(vlaSwap, vlbSwap, vlcSwap);
const hh_u32 isOut = vMinMax.MaskGreater_Imm4(vbw);
if (isOut != 0)
return false;
// SAT test for the 3 triangle edges
// (note: code below would work for quads with almost no changes, we're doing the SAT
// test in SOA, using the xyz lanes of each vector for the 3 edges. a 4th edge would use w)
const SIMD::Float4 axcxaycy = SIMD::InterleaveLo(vla, vlc);
const SIMD::Float4 bxbxbyby = vlb.Swizzle<0,0,1,1>();
const SIMD::Float4 vlabc_x = SIMD::InterleaveLo(axcxaycy, bxbxbyby); // axbxcxbx
const SIMD::Float4 vlabc_y = SIMD::InterleaveHi(axcxaycy, bxbxbyby); // aybycyby
const SIMD::Float4 vlbca_x = vlabc_x.Swizzle<1,2,0,2>();
const SIMD::Float4 vlbca_y = vlabc_y.Swizzle<1,2,0,2>();
const SIMD::Float4 vlcab_x = vlabc_x.Swizzle<2,0,1,0>();
const SIMD::Float4 vlcab_y = vlabc_y.Swizzle<2,0,1,0>();
const SIMD::Float4 e012x = vlbca_x - vlabc_x;
const SIMD::Float4 e012y = vlbca_y - vlabc_y;
const SIMD::Float4 pr012_0 = vlabc_x.Nmsub(e012y, vlabc_y * e012x);
const SIMD::Float4 pr012_1 = vlcab_x.Nmsub(e012y, vlcab_y * e012x);
const SIMD::Float4 pr012Min = SIMD::Min(pr012_0, pr012_1);
const SIMD::Float4 pr012Max = SIMD::Max(pr012_0, pr012_1);
const SIMD::Float4 e012xAbs = SIMD::Abs(e012x);
const SIMD::Float4 e012yAbs = SIMD::Abs(e012y);
const SIMD::Float4 b012Radius = vbw.xxxx().Madd(e012yAbs, vbw.yyyy() * e012xAbs);
const SIMD::Float4 pr012Test = SIMD::Max(pr012Min, -pr012Max);
return pr012Test.MaskGreater_Imm4(b012Radius) == 0;
}
//----------------------------------------------------------------------------
template <typename _Type>
static hh_u32 _ClassifyTriangles(const CRect &bounds, const _Type *indexStream, const TMemoryView<hh_u32> &triangleIDs, const TMemoryView<const CFloat2> &texcoords, hh_u32 tIndexMask)
{
const CFloat2 boxCenter = bounds.Center();
const CFloat2 boxHalfWidth = 0.5f * (bounds.Max() - bounds.Min());
HH_ALIGN(0x10) const CFloat4 boxCenterAndHalfWidth[2] =
{
CFloat4(boxCenter, boxCenter),
CFloat4(boxHalfWidth, boxHalfWidth),
};
hh_u32 curChildCount = 0;
for (hh_u32 tidx = 0; tidx < triangleIDs.Count(); tidx++)
{
const hh_u32 tIndex = triangleIDs[tidx];
const hh_u32 vIndex = tIndex + ((tIndex + tIndex) & tIndexMask);
const CFloat2 &a = texcoords[indexStream[vIndex + 0]];
const CFloat2 &b = texcoords[indexStream[vIndex + 1]];
const CFloat2 &c = texcoords[indexStream[vIndex + 2]];
if (_TriangleOverlapsBox(a, b, c, boxCenterAndHalfWidth))
{
HHSwap(triangleIDs[curChildCount], triangleIDs[tidx]);
curChildCount++;
}
}
return curChildCount;
}
