private static BzPolyLoop GetLoop(int[] outerIndexes, BzMeshData meshData)
{
return(new BzPolyLoop(meshData, new LinkedLoop <int>(
outerIndexes.ToList()),
Vector3.back,
new SliceAdapterMock()));
}
public void GetEdgeLoops()
{
//Arrange
var vertices = new Vector3[]
{
new Vector3(0f, 0f, 0),
new Vector3(0f, 1f, 0),
new Vector3(0f, 1f, 0),
new Vector3(0.5f, 1f, 0),
new Vector3(1f, 1f, 0),
};
var mesh = new Mesh();
mesh.vertices = vertices;
var meshData = new BzMeshData(mesh, null);
var adapter = new BzManualMeshAdapter(vertices);
BzMeshDataEditor editor = new BzMeshDataEditor(meshData, new Plane(), adapter, false);
editor.CapEdges.Add(new IndexVector(0, 1));
editor.CapEdges.Add(new IndexVector(1, 2));
editor.CapEdges.Add(new IndexVector(2, 3));
editor.CapEdges.Add(new IndexVector(3, 4));
//Act
var loops = editor.GetEdgeLoops();
//Assert
Assert.AreEqual(1, loops.Count);
var loop = loops.Single();
CollectionAssert.AreEqual(new[] { 0, 1, 4 }, LoopToArray(loop));
}
private static BzPolyLoop GetLoop(Vector2[] vertices, int[] outerIndexes)
{
BzMeshData meshData = GetMeshData(vertices);
BzPolyLoop outer = GetLoop(outerIndexes, meshData);
return(outer);
}
public Vector3 GetWorldPos(BzMeshData meshData, int index)
{
Vector3 position = meshData.Vertices[index];
var boneWeight = meshData.BoneWeights[index];
Vector3 newPosition = Vector3.zero;
if (boneWeight.weight0 > 0f)
{
newPosition += _charToW[boneWeight.boneIndex0].MultiplyPoint3x4(position) * boneWeight.weight0;
}
if (boneWeight.weight1 > 0f)
{
newPosition += _charToW[boneWeight.boneIndex1].MultiplyPoint3x4(position) * boneWeight.weight1;
}
if (boneWeight.weight2 > 0f)
{
newPosition += _charToW[boneWeight.boneIndex2].MultiplyPoint3x4(position) * boneWeight.weight2;
}
if (boneWeight.weight3 > 0f)
{
newPosition += _charToW[boneWeight.boneIndex3].MultiplyPoint3x4(position) * boneWeight.weight3;
}
return(newPosition);
}
private static BzMeshData GetMeshData(Vector2[] vertices)
{
var mesh = new Mesh();
mesh.vertices = vertices.Select(v => new Vector3(v.x, v.y, 0f)).ToArray();
var meshData = new BzMeshData(mesh, null);
return(meshData);
}
public void JoinBySameValue()
{
//Arrange
var vertices = new Vector3[]
{
new Vector3(0, 0, 0),
new Vector3(1, 0, 0),
new Vector3(1, 0, 0),
new Vector3(3, 0, 0),
new Vector3(4, 0, 0),
new Vector3(5, 0, 0),
new Vector3(5, 0, 0),
new Vector3(7, 0, 0),
};
var mesh = new Mesh();
mesh.vertices = vertices;
var meshData = new BzMeshData(mesh, null);
var adapter = new BzMockAddapter(vertices);
BzMeshDataEditor editor = new BzMeshDataEditor(meshData, new Plane(), adapter);
editor.CapEdges.Add(new IndexVector(2, 3));
editor.CapEdges.Add(new IndexVector(0, 1));
editor.CapEdges.Add(new IndexVector(4, 5));
editor.CapEdges.Add(new IndexVector(6, 5));
editor.CapEdges.Add(new IndexVector(6, 7));
//Act
var loops = editor.GetEdgeLoopsByIndex();
Assert.AreEqual(3, loops.Count);
editor.EdgeLoops_JoinBySameValue(loops);
//Assert
Assert.AreEqual(2, loops.Count);
var loop1 = loops.Single(loop => loop.first.value == 0 | loop.last.value == 0);
if (loop1.first.value != 0)
{
loop1.Reverse();
}
var loop2 = loops.Single(loop => loop.first.value == 4 | loop.last.value == 4);
if (loop2.first.value != 4)
{
loop2.Reverse();
}
Assert.IsTrue(Enumerable.SequenceEqual(new[] { 0, 1, 3 }, LoopToArray(loop1)));
Assert.IsTrue(Enumerable.SequenceEqual(new[] { 4, 5, 6, 7 }, LoopToArray(loop2)));
}
public bool Check(BzMeshData meshData)
{
int trCount = 0;
for (int i = 0; i < meshData.SubMeshes.Length; i++)
{
trCount += meshData.SubMeshes[i].Length;
}
if (trCount < 3)
{
throw new Exception("FFFFF3");
}
if (trCount % 3 != 0)
{
throw new Exception("FFFFF4");
}
return(true);
}
/// <param name="vertices">Chain of vertices for polygon</param>
/// <param name="normal">Normal the polygon is facing to</param>
public BzPolyLoop(BzMeshData meshData, LinkedLoop <int> edgeLoop, Vector3 normal, IBzSliceAdapter adapter)
{
this.meshData = meshData;
this.edgeLoop = edgeLoop;
if (edgeLoop.size < 3)
{
return;
}
Profiler.BeginSample("ConvertV3ToV2");
polyVertices2D = ConvertV3ToV2(adapter, normal);
Profiler.EndSample();
Profiler.BeginSample("MakeMesh");
var newTriangles1 = MakeMesh(true);
var newTriangles2 = MakeMesh(false);
Profiler.EndSample();
// get triangle list with more vertices
OuterLoop = newTriangles1.Count >= newTriangles2.Count;
if (OuterLoop)
{
triangles = newTriangles1;
}
else
{
triangles = newTriangles2;
}
if (triangles.Count != 0)
{
CalculateMetodata();
Created = true;
}
}
public void DiffDirections(bool diffDir)
{
// 1 4 2
// |--------|--------|
// | |\ |
// | t0 | | t3 |
// | || \ |
// | / | | |
// | / | \ |
// | | | | |
// | / | \ |
// | / | | |
// | | | \ |
// | / t1| t2 | |
// | / | \ |
// | | | | |
// |/_______|_ | |
// 0 5 `"--..\|
// 3
//Arrange
var vertices = new Vector3[]
{
new Vector3(-10, -10, 0),
new Vector3(-10, 10, 0),
new Vector3(10, 10, 0),
new Vector3(10, diffDir ? -15 : -10, 0),
new Vector3(0, 10, 0), // 4
new Vector3(0, -10, 0), // 5
};
List <BzTriangle> trianglesSliced = new List <BzTriangle>();
trianglesSliced.Add(new BzTriangle(1, 4, 0));
trianglesSliced.Add(new BzTriangle(4, 5, 0));
trianglesSliced.Add(new BzTriangle(4, 3, 5));
trianglesSliced.Add(new BzTriangle(4, 2, 3));
var mesh = new Mesh();
mesh.vertices = vertices;
var meshData = new BzMeshData(mesh, null);
var linkedLoops = new LinkedList <LinkedLoop <int> >();
var linkedLoop = new LinkedLoop <int>();
linkedLoops.AddLast(linkedLoop);
linkedLoop.AddLast(2);
linkedLoop.AddLast(4);
linkedLoop.AddLast(1);
//Act
MeshTriangleOptimizer.OptimizeEdgeTriangles(linkedLoops, meshData, trianglesSliced);
//Assert
if (diffDir)
{
Assert.That(trianglesSliced.Count >= 3);
}
else
{
Assert.AreEqual(2, trianglesSliced.Count);
}
}
public void BigAngle(bool mirror)
{
// 0 1 2
// --|-----|.-------------------------|--
// \ \ *._ /
// \ \ *._ /
// \ \ *._ /
// \ \ *._ /
// \ \ *._ /
// \ \ *_ /
// \ \ | 3
// \ \ |
// \ \ |
// \ \ |
// \ \ |
// \ \ |
// \\|
// -----*-----
// 4
//Arrange
float m = mirror ? -1f : 1f;
var vertices = new Vector3[]
{
new Vector3(m * -10, 0, 0),
new Vector3(m * -5, 0, 0),
new Vector3(m * 10, 0, 0),
new Vector3(0, -1, 0),
new Vector3(0, -5, 0),
};
List <BzTriangle> trianglesSliced = new List <BzTriangle>();
trianglesSliced.Add(GetOrder(new BzTriangle(0, 1, 4), mirror));
trianglesSliced.Add(GetOrder(new BzTriangle(1, 3, 4), mirror));
trianglesSliced.Add(GetOrder(new BzTriangle(1, 2, 3), mirror));
var mesh = new Mesh();
mesh.vertices = vertices;
var meshData = new BzMeshData(mesh, null);
var linkedLoops = new LinkedList <LinkedLoop <int> >();
var linkedLoop = new LinkedLoop <int>();
linkedLoops.AddLast(linkedLoop);
if (mirror)
{
linkedLoop.AddLast(0);
linkedLoop.AddLast(1);
linkedLoop.AddLast(2);
}
else
{
linkedLoop.AddLast(2);
linkedLoop.AddLast(1);
linkedLoop.AddLast(0);
}
//Act
MeshTriangleOptimizer.OptimizeEdgeTriangles(linkedLoops, meshData, trianglesSliced);
//Assert
Assert.AreEqual(2, trianglesSliced.Count);
var tr1 = trianglesSliced[0];
var tr2 = trianglesSliced[1];
bool case1 =
TrAreEqual(tr1, GetOrder(new BzTriangle(0, 2, 3), mirror)) &&
TrAreEqual(tr2, GetOrder(new BzTriangle(0, 3, 4), mirror));
bool case2 =
TrAreEqual(tr1, GetOrder(new BzTriangle(0, 3, 4), mirror)) &&
TrAreEqual(tr2, GetOrder(new BzTriangle(0, 2, 3), mirror));
Assert.That(case1 ^ case2);
}
public void Optimize()
{
// 1 4 5 2
// |--------*-----------|--------|
// | | \ \ |
// | t0 / \ t3 | t4 |
// | | | \ \ |
// | / | \ \ |
// | / \ \ | |
// | | | \ \ |
// | / | \ \ |
// | / \ \ | |
// | | | \ \ |
// | / t1 | t2 \ \ |
// | / \ \ | |
// | | | \\ |
// |/___________|_______________\|
// 0 6 3
//Arrange
var vertices = new Vector3[]
{
new Vector3(-10, -10, 0),
new Vector3(-10, 10, 0),
new Vector3(10, 10, 0),
new Vector3(10, -10, 0),
new Vector3(-5, 10, 0), // 4
new Vector3(5, 10, 0), // 5
new Vector3(0, -10, 0), // 6
};
List <BzTriangle> trianglesSliced = new List <BzTriangle>();
trianglesSliced.Add(new BzTriangle(1, 4, 0));
trianglesSliced.Add(new BzTriangle(4, 6, 0));
trianglesSliced.Add(new BzTriangle(4, 3, 6));
trianglesSliced.Add(new BzTriangle(4, 5, 3));
trianglesSliced.Add(new BzTriangle(5, 2, 3));
var mesh = new Mesh();
mesh.vertices = vertices;
var meshData = new BzMeshData(mesh, null);
var linkedLoops = new LinkedList <LinkedLoop <int> >();
var linkedLoop = new LinkedLoop <int>();
linkedLoops.AddLast(linkedLoop);
linkedLoop.AddLast(2);
linkedLoop.AddLast(5);
linkedLoop.AddLast(4);
linkedLoop.AddLast(1);
//Act
MeshTriangleOptimizer.OptimizeEdgeTriangles(linkedLoops, meshData, trianglesSliced);
//Assert
Assert.AreEqual(2, trianglesSliced.Count);
var tr1 = trianglesSliced[0];
var tr2 = trianglesSliced[1];
bool case1 =
TrAreEqual(tr1, new BzTriangle(1, 2, 0)) &&
TrAreEqual(tr2, new BzTriangle(1, 3, 0));
bool case2 =
TrAreEqual(tr1, new BzTriangle(1, 2, 0)) &&
TrAreEqual(tr2, new BzTriangle(2, 3, 0));
Assert.That(case1 ^ case2);
}
public Vector3 GetWorldPos(BzMeshData meshData, int index)
{
var v = meshData.Vertices[index];
return(v);
}
public Vector3 GetLocalPos(BzMeshData meshData, int index)
{
return(meshData.Vertices[index]);
}
public bool Check(BzMeshData meshData)
{
throw new System.NotImplementedException();
}
public bool Check(BzMeshData meshData)
{
return(true);
}
public Vector3 GetWorldPos(BzMeshData meshData, int index)
{
var v = meshData.Vertices[index];
return(new Vector3(v.x, v.y, v.z));
}
