unsafe public void TestCreateTriangle()
{
float3[] vertices =
{
new float3(-1.4f, 1.4f, 5.6f),
new float3(1.4f, 1.4f, 3.6f),
new float3(0.2f, 1.2f, 5.6f)
};
float3 normal = math.normalize(math.cross(vertices[1] - vertices[0], vertices[2] - vertices[0]));
var collider = PolygonCollider.CreateTriangle(vertices[0], vertices[1], vertices[2]);
var triangleCollider = UnsafeUtility.AsRef <PolygonCollider>(collider.GetUnsafePtr());
Assert.IsTrue(triangleCollider.IsTriangle);
Assert.IsFalse(triangleCollider.IsQuad);
TestUtils.AreEqual(triangleCollider.Vertices[0], vertices[0], 1e-3f);
TestUtils.AreEqual(triangleCollider.Vertices[1], vertices[1], 1e-3f);
TestUtils.AreEqual(triangleCollider.Vertices[2], vertices[2], 1e-3f);
Assert.AreEqual(2, triangleCollider.Planes.Length);
TestUtils.AreEqual(normal, triangleCollider.Planes[0].Normal, 1e-3f);
TestUtils.AreEqual(-normal, triangleCollider.Planes[1].Normal, 1e-3f);
Assert.AreEqual(ColliderType.Triangle, triangleCollider.Type);
Assert.AreEqual(CollisionType.Convex, triangleCollider.CollisionType);
}
public void TestCalculateAabbTransformedQuad()
{
float3[] vertices =
{
new float3(-4.5f, 0.0f, 1.0f),
new float3(3.4f, 0.7f, 1.0f),
new float3(3.4f, 2.7f, 1.0f),
new float3(-3.4f, 1.2f, 1.0f)
};
float3 translation = new float3(-3.4f, -2.5f, -1.1f);
quaternion rotation = quaternion.AxisAngle(math.normalize(new float3(11.1f, 10.1f, -3.4f)), 178.0f);
var collider = PolygonCollider.CreateQuad(vertices[0], vertices[1], vertices[2], vertices[3]);
Aabb aabb = collider.Value.CalculateAabb(new RigidTransform(rotation, translation));
for (int i = 0; i < 4; ++i)
{
vertices[i] = translation + math.mul(rotation, vertices[i]);
}
Aabb expected = Aabb.CreateFromPoints(new float3x4(vertices[0], vertices[1], vertices[2], vertices[3]));
TestUtils.AreEqual(expected.Min, aabb.Min, 1e-3f);
TestUtils.AreEqual(expected.Max, aabb.Max, 1e-3f);
}
public void TestCapsuleColliderMassProperties()
{
float radius = 2.3f;
float length = 5.5f;
float3 p0 = new float3(1.1f, 2.2f, 3.4f);
float3 p1 = p0 + length * math.normalize(new float3(1, 1, 1));
float hemisphereMass = 0.5f * 4.0f / 3.0f * (float)math.PI * radius * radius * radius;
float cylinderMass = (float)math.PI * radius * radius * length;
float totalMass = 2.0f * hemisphereMass + cylinderMass;
hemisphereMass /= totalMass;
cylinderMass /= totalMass;
float itX = cylinderMass * (length * length / 12.0f + radius * radius / 4.0f) + 2.0f * hemisphereMass * (2.0f * radius * radius / 5.0f + length * length / 4.0f + 3.0f * length * radius / 8.0f);
float itY = cylinderMass * radius * radius / 2.0f + 4.0f * hemisphereMass * radius * radius / 5.0f;
float itZ = itX;
float3 expectedInertiaTensor = new float3(itX, itY, itZ);
var capsuleCollider = CapsuleCollider.Create(p0, p1, radius);
float3 inertiaTensor = capsuleCollider.Value.MassProperties.MassDistribution.InertiaTensor;
Debug.Log($"Expected inertia tensor: {expectedInertiaTensor}, was {inertiaTensor}");
TestUtils.AreEqual(expectedInertiaTensor, inertiaTensor, 1e-3f);
}
unsafe public void TestCreateQuad()
{
float3[] vertices =
{
new float3(-4.5f, 0.0f, 1.0f),
new float3(3.4f, 0.7f, 1.0f),
new float3(3.4f, 2.7f, 1.0f),
new float3(-3.4f, 1.2f, 1.0f)
};
float3 normal = math.normalize(math.cross(vertices[2] - vertices[1], vertices[0] - vertices[1]));
var collider = PolygonCollider.CreateQuad(vertices[0], vertices[1], vertices[2], vertices[3]);
var quadCollider = UnsafeUtility.AsRef <PolygonCollider>(collider.GetUnsafePtr());
Assert.IsFalse(quadCollider.IsTriangle);
Assert.IsTrue(quadCollider.IsQuad);
TestUtils.AreEqual(quadCollider.Vertices[0], vertices[0], 1e-3f);
TestUtils.AreEqual(quadCollider.Vertices[1], vertices[1], 1e-3f);
TestUtils.AreEqual(quadCollider.Vertices[2], vertices[2], 1e-3f);
TestUtils.AreEqual(quadCollider.Vertices[3], vertices[3], 1e-3f);
Assert.AreEqual(2, quadCollider.Planes.Length);
TestUtils.AreEqual(normal, quadCollider.Planes[0].Normal, 1e-3f);
TestUtils.AreEqual(-normal, quadCollider.Planes[1].Normal, 1e-3f);
Assert.AreEqual(ColliderType.Quad, quadCollider.Type);
Assert.AreEqual(CollisionType.Convex, quadCollider.CollisionType);
}
public void TestCapsuleColliderCalculateAabbTransformed()
{
float radius = 2.3f;
float length = 5.5f;
float3 p0 = new float3(1.1f, 2.2f, 3.4f);
float3 p1 = p0 + length * math.normalize(new float3(1, 1, 1));
var capsuleCollider = CapsuleCollider.Create(p0, p1, radius);
float3 translation = new float3(-3.4f, 0.5f, 0.0f);
quaternion rotation = quaternion.AxisAngle(math.normalize(new float3(0.4f, 0.0f, 150.0f)), 123.0f);
Aabb expectedAabb = new Aabb();
float3 p0Transformed = math.mul(rotation, p0) + translation;
float3 p1Transformed = math.mul(rotation, p1) + translation;
expectedAabb.Min = math.min(p0Transformed, p1Transformed) - new float3(radius);
expectedAabb.Max = math.max(p0Transformed, p1Transformed) + new float3(radius);
Aabb aabb = capsuleCollider.Value.CalculateAabb(new RigidTransform(rotation, translation));
Debug.Log($"Expected Aabb: Min {expectedAabb.Min}, Max {expectedAabb.Max}");
Debug.Log($"Actual Aabb: Min {aabb.Min}, Max {aabb.Max}");
TestUtils.AreEqual(expectedAabb.Min, aabb.Min, 1e-3f);
TestUtils.AreEqual(expectedAabb.Max, aabb.Max, 1e-3f);
}
public void TestCalculateAabbTransformedTriangle()
{
float3[] vertices =
{
new float3(-1.8f, 2.4f, 4.6f),
new float3(1.4f, 1.6f, 1.6f),
new float3(0.2f, 1.2f, 3.6f)
};
float3 translation = new float3(3.4f, 2.5f, -1.1f);
quaternion rotation = quaternion.AxisAngle(math.normalize(new float3(1.1f, 10.1f, -3.4f)), 78.0f);
var collider = PolygonCollider.CreateTriangle(vertices[0], vertices[1], vertices[2]);
Aabb aabb = collider.Value.CalculateAabb(new RigidTransform(rotation, translation));
for (int i = 0; i < 3; ++i)
{
vertices[i] = translation + math.mul(rotation, vertices[i]);
}
Aabb expected = new Aabb()
{
Min = math.min(math.min(vertices[0], vertices[1]), vertices[2]),
Max = math.max(math.max(vertices[0], vertices[1]), vertices[2])
};
TestUtils.AreEqual(expected.Min, aabb.Min, 1e-3f);
TestUtils.AreEqual(expected.Max, aabb.Max, 1e-3f);
}
public void TestAabb()
{
float3 v0 = float3(100, 200, 300);
float3 v1 = float3(200, 300, 400);
float3 v2 = float3(50, 100, 350);
Aabb a0; a0.Min = float3.zero; a0.Max = v0;
Aabb a1; a1.Min = float3.zero; a1.Max = v1;
Aabb a2; a2.Min = v2; a2.Max = v1;
Aabb a3; a3.Min = v2; a3.Max = v0;
Assert.IsTrue(a0.IsValid);
Assert.IsTrue(a1.IsValid);
Assert.IsTrue(a2.IsValid);
Assert.IsFalse(a3.IsValid);
Assert.IsTrue(a1.Contains(a0));
Assert.IsFalse(a0.Contains(a1));
Assert.IsTrue(a1.Contains(a2));
Assert.IsFalse(a2.Contains(a1));
Assert.IsFalse(a0.Contains(a2));
Assert.IsFalse(a2.Contains(a0));
// Test Expand / Contains
{
Aabb a5; a5.Min = v2; a5.Max = v1;
float3 testPoint = float3(v2.x - 1.0f, v1.y + 1.0f, .5f * (v2.z + v1.z));
Assert.IsFalse(a5.Contains(testPoint));
a5.Expand(1.5f);
Assert.IsTrue(a5.Contains(testPoint));
}
// Test transform
{
Aabb ut; ut.Min = v0; ut.Max = v1;
// Identity transform should not modify aabb
Aabb outAabb = Unity.Physics.Math.TransformAabb(RigidTransform.identity, ut);
TestUtils.AreEqual(ut.Min, outAabb.Min, 1e-3f);
// Test translation
outAabb = Unity.Physics.Math.TransformAabb(new RigidTransform(quaternion.identity, float3(100.0f, 0.0f, 0.0f)), ut);
Assert.AreEqual(outAabb.Min.x, 200);
Assert.AreEqual(outAabb.Min.y, 200);
Assert.AreEqual(outAabb.Max.x, 300);
Assert.AreEqual(outAabb.Max.z, 400);
// Test rotation
quaternion rot = quaternion.EulerXYZ(0.0f, 0.0f, k_pi2);
outAabb = Unity.Physics.Math.TransformAabb(new RigidTransform(rot, float3.zero), ut);
TestUtils.AreEqual(outAabb.Min, float3(-300.0f, 100.0f, 300.0f), 1e-3f);
TestUtils.AreEqual(outAabb.Max, float3(-200.0f, 200.0f, 400.0f), 1e-3f);
TestUtils.AreEqual(outAabb.SurfaceArea, ut.SurfaceArea, 1e-2f);
}
}
unsafe public void TestSphereColliderCreate()
{
float3 center = new float3(-8.45f, 9.65f, -0.10f);
float radius = 0.98f;
var collider = SphereCollider.Create(center, radius);
var sphereCollider = UnsafeUtilityEx.AsRef <SphereCollider>(collider.GetUnsafePtr());
TestUtils.AreEqual(center, sphereCollider.Center, 1e-3f);
TestUtils.AreEqual(radius, sphereCollider.Radius, 1e-3f);
Assert.AreEqual(ColliderType.Sphere, sphereCollider.Type);
Assert.AreEqual(CollisionType.Convex, sphereCollider.CollisionType);
}
public void TestSphereColliderMassProperties()
{
float3 center = new float3(-8.4f, 5.63f, 77.2f);
float radius = 2.3f;
var sphereCollider = SphereCollider.Create(center, radius);
float inertia = 2.0f / 5.0f * radius * radius;
float3 expectedInertiaTensor = new float3(inertia, inertia, inertia);
float3 inertiaTensor = sphereCollider.Value.MassProperties.MassDistribution.InertiaTensor;
Debug.Log($"Expected inertia tensor: {expectedInertiaTensor}, was: {inertiaTensor}");
TestUtils.AreEqual(expectedInertiaTensor, inertiaTensor, 1e-3f);
}
unsafe public void TestCapsuleColliderCreate()
{
float3 v0 = new float3(1.45f, 0.34f, -8.65f);
float3 v1 = new float3(100.45f, -80.34f, -8.65f);
float radius = 1.45f;
var collider = CapsuleCollider.Create(v0, v1, radius);
var capsuleCollider = UnsafeUtilityEx.AsRef <CapsuleCollider>(collider.GetUnsafePtr());
Assert.AreEqual(ColliderType.Capsule, capsuleCollider.Type);
Assert.AreEqual(CollisionType.Convex, capsuleCollider.CollisionType);
TestUtils.AreEqual(v0, capsuleCollider.Vertex0);
TestUtils.AreEqual(v1, capsuleCollider.Vertex1);
TestUtils.AreEqual(radius, capsuleCollider.Radius);
}
public void TestCalculateAabbLocalQuad()
{
float3[] quadVertices =
{
new float3(-4.5f, 0.0f, 1.0f),
new float3(3.4f, 0.7f, 1.0f),
new float3(3.4f, 2.7f, 1.0f),
new float3(-3.4f, 1.2f, 1.0f)
};
var collider = PolygonCollider.CreateQuad(quadVertices[0], quadVertices[1], quadVertices[2], quadVertices[3]);
Aabb aabb = collider.Value.CalculateAabb();
Aabb expected = Aabb.CreateFromPoints(new float3x4(quadVertices[0], quadVertices[1], quadVertices[2], quadVertices[3]));
TestUtils.AreEqual(expected.Min, aabb.Min, 1e-3f);
TestUtils.AreEqual(expected.Max, aabb.Max, 1e-3f);
}
public void TestSphereColliderCalculateAabbLocal()
{
float3 center = new float3(-8.4f, 5.63f, -7.2f);
float radius = 2.3f;
var sphereCollider = SphereCollider.Create(center, radius);
Aabb expected = new Aabb();
expected.Min = center - new float3(radius, radius, radius);
expected.Max = center + new float3(radius, radius, radius);
Aabb actual = sphereCollider.Value.CalculateAabb();
Debug.Log($"Expected aabb: Min: {expected.Min} Max: {expected.Max}, was Min: {actual.Min} Max: {actual.Max}");
TestUtils.AreEqual(expected.Min, actual.Min, 1e-3f);
TestUtils.AreEqual(expected.Max, actual.Max, 1e-3f);
}
//[Test] // #TODO: Add test back in once we have implemented this in Physics
public void TestMassPropertiesQuad()
{
float3[] vertices =
{
new float3(-1.1f, -0.4f, 0.0f),
new float3(0.8f, -0.1f, 0.0f),
new float3(1.2f, 1.3f, 0.0f),
new float3(-0.2f, 1.3f, 0.0f)
};
var collider = PolygonCollider.CreateQuad(vertices[0], vertices[1], vertices[2], vertices[3]);
float3 inertiaTensor = collider.Value.MassProperties.MassDistribution.InertiaTensor;
float3 expectedInertiaTensor = calcQuadInertiaTensor(vertices[0], vertices[1], vertices[2], vertices[3]);
TestUtils.AreEqual(expectedInertiaTensor, inertiaTensor, 1e-3f);
}
//[Test] // #TODO: Add test back in once we have implemented this in Physics
unsafe public void TestMassPropertiesTriangle()
{
// constructing the triangle to be parallel to the xy plane so we don't have to figure out the transformations first
float3[] vertices =
{
new float3(-1.1f, -0.4f, 0.0f),
new float3(0.8f, -0.1f, 0.0f),
new float3(-0.2f, 1.3f, 0.0f)
};
var collider = PolygonCollider.CreateTriangle(vertices[0], vertices[1], vertices[2]);
float3 inertiaTensor = collider.Value.MassProperties.MassDistribution.InertiaTensor;
float3 expectedInertiaTensor = calcTriangleInertiaTensor(vertices[0], vertices[1], vertices[2]);
TestUtils.AreEqual(expectedInertiaTensor, inertiaTensor, 1e-3f);
}
public void TestSphereColliderCalculateAabbLocal()
{
float3 center = new float3(-8.4f, 5.63f, -7.2f);
float radius = 2.3f;
var sphereCollider = SphereCollider.Create(new SphereGeometry {
Center = center, Radius = radius
});
Aabb expected = new Aabb();
expected.Min = center - new float3(radius, radius, radius);
expected.Max = center + new float3(radius, radius, radius);
Aabb actual = sphereCollider.Value.CalculateAabb();
TestUtils.AreEqual(expected.Min, actual.Min, 1e-3f);
TestUtils.AreEqual(expected.Max, actual.Max, 1e-3f);
}
unsafe public void TestCapsuleColliderCreate()
{
var geometry = new CapsuleGeometry
{
Vertex0 = new float3(1.45f, 0.34f, -8.65f),
Vertex1 = new float3(100.45f, -80.34f, -8.65f),
Radius = 1.45f
};
var collider = CapsuleCollider.Create(geometry);
var capsuleCollider = UnsafeUtility.AsRef<CapsuleCollider>(collider.GetUnsafePtr());
Assert.AreEqual(ColliderType.Capsule, capsuleCollider.Type);
Assert.AreEqual(CollisionType.Convex, capsuleCollider.CollisionType);
TestUtils.AreEqual(geometry.Vertex0, capsuleCollider.Vertex0);
TestUtils.AreEqual(geometry.Vertex0, capsuleCollider.Geometry.Vertex0);
TestUtils.AreEqual(geometry.Vertex1, capsuleCollider.Vertex1);
TestUtils.AreEqual(geometry.Vertex1, capsuleCollider.Geometry.Vertex1);
TestUtils.AreEqual(geometry.Radius, capsuleCollider.Radius);
TestUtils.AreEqual(geometry.Radius, capsuleCollider.Geometry.Radius);
}
public void TestBoxColliderCalculateAabbLocalTranslationAndOrientation()
{
float3 center = new float3(-2.56f, -4.33f, 54.30f);
quaternion orientation = quaternion.AxisAngle(math.normalize(new float3(0, 1, 1)), 42.0f);
float3 size = new float3(5.0f, 0.25f, 1.3f);
float convexRadius = 0.25f;
Aabb expectedAabb = new Aabb
{
Min = new float3(-4.062223f, -6.442692f, 52.3973f),
Max = new float3(-1.057776f, -2.217308f, 56.2027f)
};
var boxCollider = BoxCollider.Create(center, orientation, size, convexRadius);
Aabb aabb = boxCollider.Value.CalculateAabb();
Debug.Log($"Expeced: Min: {expectedAabb.Min}, Max: {expectedAabb.Max}, Was: Min: {aabb.Min}, Max: {aabb.Max}");
TestUtils.AreEqual(expectedAabb.Min, aabb.Min, 1e-3f);
TestUtils.AreEqual(expectedAabb.Max, aabb.Max, 1e-3f);
}
public void TestCapsuleColliderCalculateAabbLocal()
{
float radius = 2.3f;
float length = 5.5f;
float3 p0 = new float3(1.1f, 2.2f, 3.4f);
float3 p1 = p0 + length * math.normalize(new float3(1, 1, 1));
var capsuleCollider = CapsuleCollider.Create(p0, p1, radius);
Aabb expectedAabb = new Aabb();
expectedAabb.Min = math.min(p0, p1) - new float3(radius);
expectedAabb.Max = math.max(p0, p1) + new float3(radius);
Aabb aabb = capsuleCollider.Value.CalculateAabb();
Debug.Log($"Expected Aabb: Min {expectedAabb.Min}, Max {expectedAabb.Max}");
Debug.Log($"Actual Aabb: Min {aabb.Min}, Max {aabb.Max}");
TestUtils.AreEqual(expectedAabb.Min, aabb.Min, 1e-3f);
TestUtils.AreEqual(expectedAabb.Max, aabb.Max, 1e-3f);
}
public void TestSphereColliderCalculateAabbTransformed()
{
float3 center = new float3(-3.4f, 0.63f, -17.2f);
float radius = 5.3f;
var sphereCollider = SphereCollider.Create(center, radius);
float3 translation = new float3(8.3f, -0.5f, 170.0f);
quaternion rotation = quaternion.AxisAngle(math.normalize(new float3(1.1f, 4.5f, 0.0f)), 146.0f);
Aabb expected = new Aabb();
expected.Min = math.mul(rotation, center) + translation - new float3(radius, radius, radius);
expected.Max = math.mul(rotation, center) + translation + new float3(radius, radius, radius);
Aabb actual = sphereCollider.Value.CalculateAabb(new RigidTransform(rotation, translation));
Debug.Log($"Expected aabb: Min: {expected.Min} Max: {expected.Max}, was Min: {actual.Min} Max: {actual.Max}");
TestUtils.AreEqual(expected.Min, actual.Min, 1e-3f);
TestUtils.AreEqual(expected.Max, actual.Max, 1e-3f);
}
public void TestCalculateAabbLocalTriangle()
{
float3[] vertices =
{
new float3(-1.8f, 2.4f, 4.6f),
new float3(1.4f, 1.6f, 1.6f),
new float3(0.2f, 1.2f, 3.6f)
};
var collider = PolygonCollider.CreateTriangle(vertices[0], vertices[1], vertices[2]);
Aabb aabb = collider.Value.CalculateAabb();
Aabb expected = new Aabb()
{
Min = math.min(math.min(vertices[0], vertices[1]), vertices[2]),
Max = math.max(math.max(vertices[0], vertices[1]), vertices[2])
};
TestUtils.AreEqual(expected.Min, aabb.Min, 1e-3f);
TestUtils.AreEqual(expected.Max, aabb.Max, 1e-3f);
}
public void TestBoxColliderMassProperties()
{
var geometry = new BoxGeometry
{
Center = float3.zero,
Orientation = quaternion.identity,
Size = new float3(1.0f, 250.0f, 2.0f),
BevelRadius = 0.25f
};
var boxCollider = BoxCollider.Create(geometry);
float3 expectedInertiaTensor = 1.0f / 12.0f * new float3(
geometry.Size.y * geometry.Size.y + geometry.Size.z * geometry.Size.z,
geometry.Size.x * geometry.Size.x + geometry.Size.z * geometry.Size.z,
geometry.Size.y * geometry.Size.y + geometry.Size.x * geometry.Size.x);
MassProperties massProperties = boxCollider.Value.MassProperties;
float3 inertiaTensor = massProperties.MassDistribution.InertiaTensor;
TestUtils.AreEqual(expectedInertiaTensor, inertiaTensor, 1e-3f);
}
