public void Calculate_frame_instance_for_square_rotated_45_degrees_clockwise()
{
var startMesh = JMeshPhysicsMeshes.squareMeshIdentity;
var jMesh = JMesh.FromMeshAndTransform(startMesh, Matrix4x4.TRS(
new Vector3(1, 0, 1),
Quaternion.Euler(Vector3.up * 45),
Vector3.one * 2
));
var halfHeight = Mathf.Sqrt(2);
var upRightDirection = new Vector3(1, 0, 1).normalized;
var vcs = jMesh.EdgeVertices;
TestMethods.AreEqualIsh(new Vector3(1, 0, 1), vcs[0], "v0");
TestMethods.AreEqualIsh(new Vector3(1 + halfHeight, 0, 1 - halfHeight), vcs[1], "v1");
TestMethods.AreEqualIsh(new Vector3(1 + 2 * halfHeight, 0, 1), vcs[2], "v2");
TestMethods.AreEqualIsh(new Vector3(1 + halfHeight, 0, 1 + halfHeight), vcs[3], "v3");
var ns = jMesh.EdgeOutwardNormals;
TestMethods.AreEqualIsh(-upRightDirection, ns[0], "ns0");
TestMethods.AreEqualIsh(new Vector3(upRightDirection.x, 0, -upRightDirection.z), ns[1], "ns1");
TestMethods.AreEqualIsh(upRightDirection, ns[2], "ns2");
TestMethods.AreEqualIsh(new Vector3(-upRightDirection.x, 0, upRightDirection.z), ns[3], "ns3");
}
public void Calculate_AABB()
{
var bounds = JMesh.CalculateBounds(JMeshPhysicsMeshes.triangle);
TestMethods.AreEqualIsh(bounds.center, new Vector3(0.5f, 0, 0.5f));
TestMethods.AreEqualIsh(bounds.size, new Vector3(1f, 0, 1f));
}
public void Calculate_frame_instance_for_triangle_rotated_90_degrees_anti_clockwise_with_translation()
{
var startMesh = JMeshPhysicsMeshes.triangleMeshIdentity;
var jMesh = JMesh.FromMeshAndTransform(startMesh, Matrix4x4.TRS(
new Vector3(1, 0, 1),
Quaternion.Euler(Vector3.up * -90),
Vector3.one
));
TestMethods.AreEqualIsh(Vector3.right, startMesh.EdgeOutwardNormals[1], "bc normal");
var vcs = jMesh.EdgeVertices;
TestMethods.AreEqualIsh(new Vector3(1, 0, 1), vcs[0], "v0");
TestMethods.AreEqualIsh(new Vector3(1, 0, 2), vcs[1], "v1");
TestMethods.AreEqualIsh(new Vector3(0, 0, 2), vcs[2], "v2");
var ns = jMesh.EdgeOutwardNormals;
TestMethods.AreEqualIsh(Vector3.right, ns[0], "ns0");
TestMethods.AreEqualIsh(Vector3.forward, ns[1], "ns1");
TestMethods.AreEqualIsh(new Vector3(-1, 0, -1).normalized, ns[2], "ns2");
var bounds = jMesh.AABB;
var center = bounds.center;
var min = bounds.min;
var max = bounds.max;
TestMethods.AreEqualIsh(new Vector3(0.5f, 0, 1.5f), center, "center");
TestMethods.AreEqualIsh(0f, min.x, TestMethods.VECTOR_DIFF);
TestMethods.AreEqualIsh(1f, min.z, TestMethods.VECTOR_DIFF);
TestMethods.AreEqualIsh(1f, max.x, TestMethods.VECTOR_DIFF);
TestMethods.AreEqualIsh(2f, max.z, TestMethods.VECTOR_DIFF);
}
public void Extract_triangle_edge_vertices_test()
{
var vertices = JMesh.ExtractEdgeVertices(JMeshPhysicsMeshes.triangle, JMeshPhysicsMeshes.triangleTriangles);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.triangle[0], vertices[0]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.triangle[1], vertices[1]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.triangle[2], vertices[2]);
}
public PushResult(bool canPush, Push push, JMesh pusher, JMesh pushee)
{
CanPush = canPush;
this.push = push;
APushB = false;
Pusher = pusher;
Pushee = pushee;
}
public PushResult(bool canPush, Push push, bool aPushB, JMesh pusher, JMesh pushee)
{
CanPush = canPush;
this.push = push;
APushB = aPushB;
Pusher = pusher;
Pushee = pushee;
}
public PushResult(bool canPush, Push push, bool aPushB)
{
CanPush = canPush;
this.push = push;
APushB = aPushB;
Pusher = default(JMesh);
Pushee = default(JMesh);
}
public void Extract_square_five_edge_vertices_test()
{
var vertices = JMesh.ExtractEdgeVertices(JMeshPhysicsMeshes.squareFive, JMeshPhysicsMeshes.squareFiveTriangles);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.squareFive[0], vertices[0]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.squareFive[1], vertices[1]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.squareFive[3], vertices[2]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.squareFive[4], vertices[3]);
}
public void Extract_square_edge_vertices_for_reversed_triangle_faces_test()
{
var vertices = JMesh.ExtractEdgeVertices(JMeshPhysicsMeshes.square, JMeshPhysicsMeshes.squareTrianglesDifferentTriangles);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.square[0], vertices[0]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.square[1], vertices[1]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.square[2], vertices[2]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.square[3], vertices[3]);
}
public void Calculate_outward_normals_of_square_different_triangles_should_give_same_as_normal_since_vertex_order_is_the_same()
{
var vertices = JMesh.ExtractEdgeVertices(JMeshPhysicsMeshes.square, JMeshPhysicsMeshes.squareTrianglesDifferentTriangles);
var normals = JMesh.CalculateOutwardNormals(vertices);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.squareFiveNormals[0], normals[0]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.squareFiveNormals[1], normals[1]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.squareFiveNormals[2], normals[2]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.squareFiveNormals[3], normals[3]);
}
public void Calculate_outwards_normals_of_tall_triangle()
{
var vertices = JMesh.ExtractEdgeVertices(JMeshPhysicsMeshes.triangleTall, JMeshPhysicsMeshes.triangleTallTriangles);
var normals = JMesh.CalculateOutwardNormals(vertices);
Assert.AreEqual(3, normals.Length);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.triangleTallNormals[0], normals[0]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.triangleTallNormals[1], normals[1]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.triangleTallNormals[2], normals[2]);
}
public void Calculate_minmumPushDistance_should_push_b_down_even_when_argument_order_is_reversed()
{
var meshA = JMeshPhysicsMeshes.squareMeshIdentity;
var meshB = JMesh.FromMeshAndTransform(JMeshPhysicsMeshes.triangleMeshIdentity, Matrix4x4.Translate(new Vector3(0, 0, -0.5f)));
var pushResult = JMeshOverlapPushUtil.CalculateMinimumPush(meshB, meshA);
TestMethods.AreEqualIshOrOppositeIsh(new Vector3(-1, 0, 1).normalized, pushResult.Direction);
TestMethods.AreEqualIsh(Mathf.Sin(45 * Mathf.Deg2Rad) / 2f, pushResult.Magnitude, TestMethods.VECTOR_DIFF);
}
public void Calculate_minmumPushDistance_should_push_b_left()
{
var meshA = JMeshPhysicsMeshes.squareMeshIdentity;
var meshB = JMesh.FromMeshAndTransform(JMeshPhysicsMeshes.triangleMeshIdentity, Matrix4x4.Translate(new Vector3(-0.8f, 0, 0.25f)));
var pushResult = JMeshOverlapPushUtil.CalculateMinimumPush(meshA, meshB);
TestMethods.AreEqualIshOrOppositeIsh(new Vector3(-1, 0, 0), pushResult.Direction);
TestMethods.AreEqualIsh(0.2f, pushResult.Magnitude, TestMethods.VECTOR_DIFF);
}
public void Calculate_outward_normals_of_square()
{
var vertices = JMesh.ExtractEdgeVertices(JMeshPhysicsMeshes.square, JMeshPhysicsMeshes.squareTriangles);
var normals = JMesh.CalculateOutwardNormals(vertices);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.squareNormals[0], normals[0]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.squareNormals[1], normals[1]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.squareNormals[2], normals[2]);
TestMethods.AreEqualIsh(JMeshPhysicsMeshes.squareNormals[3], normals[3]);
}
public void Point_should_be_inside_the_transformed_square_mesh()
{
var mesh = JMeshPhysicsMeshes.squareMeshIdentity;
var meshFrameInstance = JMesh.FromMeshAndTransform(mesh, Matrix4x4.TRS(
new Vector3(1, 0, 1),
Quaternion.Euler(Vector3.up * 45),
Vector3.one * 2
));
Assert.IsTrue(JMeshOverlap.IsPointInsideMesh(new Vector3(1.001f, 0, 1f), meshFrameInstance));
Assert.IsTrue(JMeshOverlap.IsPointInsideMesh(new Vector3(1f, 0, 1f), meshFrameInstance));
}
public void Calculate_frame_instance_for_nonunformly_scaled_triangle()
{
var transformed = JMesh.FromMeshAndTransform(JMeshPhysicsMeshes.triangleMeshIdentity, Matrix4x4.Scale(new Vector3(1, 1, 2)));
var expected = JMeshPhysicsMeshes.triangleTallMeshIdentity;
var tMesh = transformed;
TestMethods.AreEqualIsh(expected.AABB.size, tMesh.AABB.size);
TestMethods.AreEqualIsh(expected.EdgeOutwardNormals[0], tMesh.EdgeOutwardNormals[0]);
TestMethods.AreEqualIsh(expected.EdgeOutwardNormals[1], tMesh.EdgeOutwardNormals[1]);
TestMethods.AreEqualIsh(expected.EdgeOutwardNormals[2], tMesh.EdgeOutwardNormals[2]);
TestMethods.AreEqualIsh(expected.EdgeVertices[0], tMesh.EdgeVertices[0]);
TestMethods.AreEqualIsh(expected.EdgeVertices[1], tMesh.EdgeVertices[1]);
TestMethods.AreEqualIsh(expected.EdgeVertices[2], tMesh.EdgeVertices[2]);
}
public void Point_shold_be_inside_mesh_when_point_is_exactly_on_a_mesh_edge_vertex()
{
var mesh = JMeshPhysicsMeshes.squareMeshIdentity;
var meshFrameInstance = JMesh.FromMeshAndTransform(mesh, Matrix4x4.TRS(
new Vector3(1, 0, 1),
Quaternion.Euler(Vector3.up * 45),
Vector3.one * 2
));
var instanceMesh = meshFrameInstance;
Assert.IsTrue(JMeshOverlap.IsPointInsideMesh(instanceMesh.EdgeVertices[0], meshFrameInstance));
Assert.IsTrue(JMeshOverlap.IsPointInsideMesh(instanceMesh.EdgeVertices[1], meshFrameInstance));
Assert.IsTrue(JMeshOverlap.IsPointInsideMesh(instanceMesh.EdgeVertices[2], meshFrameInstance));
Assert.IsTrue(JMeshOverlap.IsPointInsideMesh(instanceMesh.EdgeVertices[3], meshFrameInstance));
}
void Setup()
{
/// set position
GameObject gObj = gameObject;
JMesh jMsh = m_jRoom.boundary;
// Vector2 pos = Utils.Rvt2CamCoord(jMsh.BD.min, m_floor.FloorBDs, true, m_floor.PixelPerUnit);
gObj.transform.position = new Vector3(0, 0, 5);
/// calculate mesh
/// reshape
List <Vector3> v2ds = Utils.Rvt2CamCoord(jMsh.Vct2ds, m_floor.FloorBDs, true, m_floor.PixelPerUnit);
List <Vector2> uv = new List <Vector2>();
for (int i = 0; i < v2ds.Count; i++)
{
uv.Add(new Vector2((float)i / (float)v2ds.Count * jMsh.BD.size.x, (float)i / (float)v2ds.Count * jMsh.BD.size.y));
}
MeshFilter mFilter = gObj.GetComponent <MeshFilter>();
Mesh oldMesh = mFilter.mesh;
Mesh msh = new Mesh();
mFilter.mesh = msh;
msh.vertices = v2ds.ToArray();
jMsh.Triangles.Reverse();
msh.triangles = jMsh.Triangles.ToArray();
msh.uv = uv.ToArray();
MeshCollider msCll = gObj.GetComponent <MeshCollider>();
msCll.sharedMesh = msh;
MeshRenderer mshRender = GetComponent <MeshRenderer>();
mshRender.material.color = RoomUtils.GetColor(m_jRoom.program_type);
foreach (JFurniture fn in m_jRoom.furniture)
{
GameObject dskObj = GameObject.Instantiate(m_floor.m_desk);
Desk dsk = dskObj.GetComponent <Desk>();
dsk.m_furniture = fn;
dsk.m_rm = this;
}
}
public static float[] CalculatePushLengthsForPoint(JMesh meshA, Vector3 vertex)
{
var aVertices = meshA.EdgeVertices;
var aNormals = meshA.EdgeOutwardNormals;
var aNormalsLength = aNormals.Length;
var pushLengths = new float[aNormalsLength];
for (var a = 0; a < aNormalsLength; a++)
{
var PAVector = (aVertices[a] - vertex);
var normal = aNormals[a];
var distance = Vector3.Dot(normal, PAVector);
pushLengths[a] = distance;
//Debug.Log("vertex: " + vertex + ", PAVector: " + PAVector + ", normal: " + normal + ", distance: " + distance);
}
return(pushLengths);
}
public static Push CalculatePushForPoints(Vector3[] points, JMesh mesh)
{
var vertices = points;
var end = points.Length - 1;
var normals = mesh.EdgeOutwardNormals.Length;
var distancesA = new List <float[]>(normals);
for (var i = 0; i < end; i++)
{
distancesA.Add(CalculatePushLengthsForPoint(mesh, vertices[i]));
}
var maxValues = FindMaxesForEachValue(distancesA);
var indexOfFirstMinValue = IndexOfSmallestValue(maxValues);
var minPushDistance = maxValues[indexOfFirstMinValue];
var pushDirection = mesh.EdgeOutwardNormals[indexOfFirstMinValue];
return(new Push(pushDirection, minPushDistance));
}
public void AABB_should_not_overlap_for_squares()
{
var mesh = squareMesh;
var rightOf = JMesh.FromMeshAndTransform(mesh, Matrix4x4.Translate(new Vector3(2, 0, 0)));
var above = JMesh.FromMeshAndTransform(mesh, Matrix4x4.Translate(new Vector3(0, 0, 2)));
var upperRight = JMesh.FromMeshAndTransform(mesh, Matrix4x4.Translate(new Vector3(2, 0, 2)));
var lowerRight = JMesh.FromMeshAndTransform(mesh, Matrix4x4.Translate(new Vector3(2, 0, -2)));
Assert.IsFalse(JMeshOverlap.AABBOverlap(mesh.AABB, rightOf.AABB));
Assert.IsFalse(JMeshOverlap.AABBOverlap(rightOf.AABB, mesh.AABB));
Assert.IsFalse(JMeshOverlap.AABBOverlap(mesh.AABB, above.AABB));
Assert.IsFalse(JMeshOverlap.AABBOverlap(above.AABB, mesh.AABB));
Assert.IsFalse(JMeshOverlap.AABBOverlap(mesh.AABB, upperRight.AABB));
Assert.IsFalse(JMeshOverlap.AABBOverlap(upperRight.AABB, mesh.AABB));
Assert.IsFalse(JMeshOverlap.AABBOverlap(mesh.AABB, lowerRight.AABB));
Assert.IsFalse(JMeshOverlap.AABBOverlap(lowerRight.AABB, mesh.AABB));
}
public static Push CalculateMinimumPush(JMesh meshA, JMesh meshB)
{
// Mulig metoden bør utbedres med sjekk i alle normalretningene for alle vertices, men dette kan være dyrt?
var pushA = CalculatePushForPoints(meshA.EdgeVertices, meshB);
var pushB = CalculatePushForPoints(meshB.EdgeVertices, meshA);
if (pushA.Magnitude <= pushB.Magnitude)
{
return(pushA);
}
return(pushB);
//var verticesA = meshA.EdgeVertices;
//var endA = verticesA.Length - 1;
//var normalsEndB = meshB.EdgeOutwardNormals.Length;
//var distancesA = new List<float[]>(normalsEndB);
//for (var i = 0; i < endA; i++)
//{
// distancesA.Add(CalculatePushLengthsForPoint(meshB, verticesA[i]));
//}
//var maxValuesA = FindMaxesForEachValue(distancesA);
//foreach (var v in distancesA)
//{
// Debug.Log(Logging.AsString(v));
//}
//var indexOfMin = IndexOfSmallestValue(maxValuesA);
//var minDistanceA = maxValuesA[indexOfMin];
//var directionA = meshB.EdgeOutwardNormals[indexOfMin];
//var verticesB = meshB.EdgeVertices;
//var endB = verticesB.Length - 1;
//var normalsEndA = meshA.EdgeOutwardNormals.Length;
//var distancesB = new List<float[]>(normalsEndA);
//for (var i = 0; i < endB; i++)
//{
// distancesB.Add(CalculatePushLengthsForPoint(meshA, verticesB[i]));
//}
//Debug.Log("B");
//foreach (var v in distancesB)
//{
// Debug.Log(Logging.AsString(v));
//}
//var maxValuesB = FindMaxesForEachValue(distancesB);
//var indexOfMinB = IndexOfSmallestValue(maxValuesB);
//var minDistanceB = maxValuesB[indexOfMinB];
//var directionB = meshB.EdgeOutwardNormals[indexOfMinB];
//Debug.Log("maxValuesA: " + Logging.AsString(maxValuesA));
//Debug.Log("maxValuesB: " + Logging.AsString(maxValuesB));
//Debug.Log("minDistanceA: " + minDistanceA + ", directionA: " + directionA + ": minDistanceB: " + minDistanceB + ", directionB: " + directionB);
//Debug.Log("verticesA: " + verticesA.Length + ", verticesB: " + verticesB.Length);
//if (minDistanceA <= minDistanceB)
//{
// return new Push(directionA, minDistanceA);
//}
//return new Push(directionB, minDistanceB);
// FV (fevest vertices), MV (most vertices)
// Velg mesh med færrest vertices, FV
// For hver vertex i FV, beregn dytte-avstand i retningene til hver av normalene på MV. Dersom en vertex allerede er utenfor, gi negativ dyttestørrelse
// Lagre avstander og retninger i FV-pushes for alle vertex i FV
// Velg så maks-avstand i hver av retningene, og lagre i en FVMax array
// Velg så minste verdi for hver av retningene, lagre resultatet av retning og størrelse i FVBest
// Velg mesh med flest vertices, MV
// For hver vertex i MV, beregn dytte-avstand i retningene til hver av normalene på FV. Dersom en vertex allerede er utenfor, gi negativ dyttestørrelse
// Lagre avstander og retninger i MV-pushes for alle vertex i MV
// Velg så maks-avstand i hver av retningene, og lagre i en MVMax array
// Velg så minste verdi for hver av retningene, lagre resultatet av retning og størrelse i MVBest
// Velg så minste avstand av FVBest og MVBest
}
public void Meshes_should_not_overlap()
{
Assert.IsFalse(JMeshOverlap.MeshesOverlap(meshA, JMesh.FromMeshAndTransform(meshB, Matrix4x4.Translate(new Vector3(10, 0, 0)))));
Assert.IsFalse(JMeshOverlap.MeshesOverlap(meshA, JMesh.FromMeshAndTransform(meshB, Matrix4x4.Translate(new Vector3(4, 0, 0)))));
}
