public static IEnumerable <Value> Intersect(BVH <Value> t, FastBounds bb)
{
if (t == null || !t.bb.Intersects(bb))
{
yield break;
}
if (!t.IsLeaf())
{
foreach (var s in t.ch)
{
if (s != null)
{
foreach (var r in Intersect(s, bb))
{
yield return(r);
}
}
}
}
foreach (var v in t.Values)
{
if (v != null)
{
yield return(v);
}
}
}
public static FastBounds EncapsulateInTargetSpace(this FastBounds local, Matrix4x4 localToTargetMat)
{
var absMat = localToTargetMat.Absolute();
var center = localToTargetMat.MultiplyPoint3x4(local.Center);
var extent = absMat.MultiplyVector(local.Extents);
return(new Bounds(center, 2f * extent));
}
public OBB3(FastBounds localBounds, Matrix4x4 modelMatrix)
{
this.localBounds = localBounds;
this.modelMatrix = modelMatrix;
this.modelITMatrix = modelMatrix.inverse.transpose;
this.worldBounds = localBounds.EncapsulateInTargetSpace(modelMatrix);
}
public void EditorTest()
{
var delta = 1e-4f;
var n = 4;
var bounds = new FastBounds[n];
var vals = new Value[n];
for (var i = 0; i < n; i++)
{
bounds [i] = new Bounds(Vector3.one * i, Vector3.one);
vals [i] = new Value()
{
id = i
};
}
var bvh = new MortonBVHController <Value> ();
bvh.Build(bounds, vals);
var nodeCount = bvh.Count();
var valueCount = bvh.CountValues();
bvh.Build(bounds, vals);
Assert.AreEqual(nodeCount, bvh.Count());
Assert.AreEqual(valueCount, bvh.CountValues());
Assert.AreEqual(0, bvh.Root.offset);
Assert.AreEqual(n, bvh.Root.length);
for (var i = 0; i < 3; i++)
{
Assert.AreEqual(1.5f, bvh.Root.bb.Center [i], delta);
Assert.AreEqual(2f, bvh.Root.bb.Extents [i], delta);
}
Assert.AreEqual(0, bvh.Root.ch [0].offset);
Assert.AreEqual(2, bvh.Root.ch [0].length);
Assert.AreEqual(2, bvh.Root.ch [1].offset);
Assert.AreEqual(2, bvh.Root.ch [1].length);
for (var j = 0; j < n; j++)
{
var s = (j & 2) != 0 ? 1 : 0;
var t = (j & 1) != 0 ? 1 : 0;
Assert.AreEqual(1, bvh.Root.ch [s].ch [t].Values.Count);
Assert.AreEqual(j, bvh.Root.ch [s].ch [t].Values.First.Value.id);
for (var i = 0; i < 3; i++)
{
Assert.AreEqual(j, bvh.Root.ch [s].ch [t].bb.Center [i], delta);
Assert.AreEqual(1f, bvh.Root.ch [s].ch [t].bb.Size [i], delta);
}
}
}
public static Vector3 SampleIn(this FastBounds fb, float uv_x, float uv_y, float uv_z)
{
var min = fb.Min;
var max = fb.Max;
var size = fb.Size;
return(new Vector3(
Mathf.Lerp(min.x, max.x, uv_x),
Mathf.Lerp(min.y, max.y, uv_y),
Mathf.Lerp(min.z, max.z, uv_z)));
}
public Frustum(Vector3 head, Vector3 farBottomLeft, float nearPlane, float farPlane, Quaternion axis)
{
farBottomLeft *= 1f / farBottomLeft.z;
this.farBottomLeft = farPlane * farBottomLeft;
this.nearBottomLeft = nearPlane * farBottomLeft;
this.modelMatrix = Matrix4x4.TRS(head, axis, Vector3.one);
this.modelITMatrix = modelMatrix.inverse.transpose;
this.worldBounds = Vertices().Encapsulate();
}
static Matrix4x4 CalculateViewUvToViewLocal(FastBounds viewBounds)
{
var size = viewBounds.Size;
var min = viewBounds.Min;
var m = Matrix4x4.zero;
m [0] = size.x;
m [12] = min.x;
m [5] = size.y;
m [13] = min.y;
m [10] = size.z;
m [14] = min.z;
m [15] = 1f;
return(m);
}
public FastBounds Build(IReadOnlyList <FastBounds> bounds, IReadOnlyList <Value> values)
{
if (IsLeaf())
{
bb = bounds.Range(offset, length).Encapsulate();
foreach (var v in values.Range(offset, length))
{
Values.AddLast(v);
}
}
else
{
bb.Encapsulate(ch.Where(t => t != null).Select(t => t.Build(bounds, values)).Encapsulate());
}
return(bb);
}
public static IList <Value> Intersect(BVH <Value> t, FastBounds bb, IList <Value> result)
{
if (t != null && t.bb.Intersects(bb))
{
Intersect(t.ch[0], bb, result);
Intersect(t.ch[1], bb, result);
foreach (var v in t.Values)
{
if (v != null)
{
result.Add(v);
}
}
}
return(result);
}
public static IEnumerable <Volume> Broadphase(BaseBVHController <Volume> bvh, FastBounds bb)
{
foreach (var v in bvh.Intersect(bb))
{
yield return(v);
}
}
public virtual IList <Value> Intersect(FastBounds bb, IList <Value> result)
{
return(Intersect(_root, bb, result));
}
public static FastBounds EncapsulateInWorldSpace(this Transform tr, FastBounds local)
{
var local2world = tr.localToWorldMatrix;
return(local.EncapsulateInTargetSpace(local2world));
}
public static Vector3 SampleIn(this FastBounds fb)
{
return(fb.SampleIn(Random.value, Random.value, Random.value));
}
public static IList <Volume> Broadphase(BaseBVHController <Volume> bvh, FastBounds bb, IList <Volume> result)
{
return(bvh.Intersect(bb, result));
}
public virtual IEnumerable <Value> Intersect(FastBounds bb)
{
return(Intersect(_root, bb));
}
public AABB3 Set(FastBounds fb)
{
return(Set(fb.Min, fb.Max));
}
public static OBB3 Create(Transform tr, FastBounds localBounds)
{
return(new OBB3(localBounds, tr.localToWorldMatrix));
}
