void Start()
{
PointList pointsA = PrimitiveBuilder.CreateUnitTile();
PointList pointsB = pointsA.Translate(0.2f * Vector3.up);
List <PointList> list = pointsB.Divide(3, 3);
MeshBuilder builder = new MeshBuilder();
builder.Cap(pointsA.Bridge(pointsB, PointList.BridgeMode.CloseReuse));
foreach (PointList points in list)
{
DigHole(points, builder);
}
builder.Cap(pointsA.Reverse());
Mesh mesh = builder.Build();
NodeBuilder.SetMesh(gameObject, mesh);
}
private GameObject CreateUnitTileHop(float x, float z)
{
GameObject obj = CreateChild(x, z);
MeshBuilder builder = new MeshBuilder();
PointList pointsA = PrimitiveBuilder.CreateUnitTile();
PointList pointsB = pointsA.Translate(Vector3.up);
List <PointList> list = pointsA.Bridge(pointsB, PointList.BridgeMode.CloseReuse);
list.Add(pointsA.Reverse());
list.Add(pointsB);
foreach (PointList points in list)
{
Extend(points, builder);
}
Mesh mesh = builder.Build();
NodeBuilder.SetMesh(obj, mesh);
return(obj);
}
public List <PointList> Bridge(PointList pointsB, BridgeMode mode = BridgeMode.Open)
{
List <PointList> list = new List <PointList> ();
if (Count != pointsB.Count)
{
Debug.LogError("PointList : Cannot Bridge PointLists of different size (" + Count + " / " + pointsB.Count + ")");
}
else
{
// Add top points
int iMax = this.Count - 1;
if (mode == BridgeMode.CloseReuse)
{
iMax++;
}
for (int i = 0; i < iMax; i++)
{
// Add side points
PointList points = new PointList();
points.Copy(this, i);
points.Copy(this, (i + 1) % this.Count);
points.Copy(pointsB, (i + 1) % this.Count);
points.Copy(pointsB, i);
list.Add(points);
}
if (mode == BridgeMode.CloseDuplicate)
{
PointList points = new PointList();
points.Copy(this, iMax);
points.Add(this [0]);
points.Add(pointsB [0]);
points.Copy(pointsB, iMax);
list.Add(points);
}
}
return(list);
}
void Start()
{
MeshBuilder builder = new MeshBuilder();
// Create a cube
PointList pointsA = PrimitiveBuilder.CreateUnitTile();
PointList pointsB = pointsA.Translate(Vector3.up);
List <PointList> list = pointsA.Bridge(pointsB, PointList.BridgeMode.CloseReuse);
list.Add(pointsA.Reverse());
list.Add(pointsB);
// Call Branch() on each face
foreach (PointList points in list)
{
Branch(points, builder, 5);
}
Mesh mesh = builder.Build();
NodeBuilder.SetMesh(gameObject, mesh);
}
private static PointList CreateXZRectangle(float xSize, float zSize, AxisSide axisSide, float axisCoord)
{
PointList result = new PointList();
float x = xSize * 0.5f;
float z = zSize * 0.5f;
if (axisSide == AxisSide.Negative)
{
result.Add(-x, axisCoord, z);
result.Add(-x, axisCoord, -z);
result.Add(x, axisCoord, -z);
result.Add(x, axisCoord, z);
}
else
{
result.Add(-x, axisCoord, z);
result.Add(x, axisCoord, z);
result.Add(x, axisCoord, -z);
result.Add(-x, axisCoord, -z);
}
return(result);
}
public void TestCreate()
{
PointList list = new PointList();
Assert.IsNotNull(list);
}
//
// Copy a point from another PointList and preserve point uid, see Bridge(), Reverse(), Shift() methods
//
public void Copy(PointList list, int index)
{
m_points.Add(list.m_points[index]);
m_uids.Add(list.m_uids[index]);
}
// Init with 1:1 scale between geometry space and uv space, and no rotation
// Enough to set uVec and vVec, uCst and vCst are left as is
public void InitLastSideU(PointList points)
{
uVec = (points [points.Count - 1] - points [0]).normalized;
vVec = Vector3.Cross(uVec, points.ComputeNormal()).normalized;
}
// Init with 1:1 scale between geometry space and uv space, and no rotation
// Enough to set uVec and vVec, uCst and vCst are left as is
public void InitFirstSideV(PointList points)
{
vVec = (points [1] - points [0]).normalized;
uVec = Vector3.Cross(points.ComputeNormal(), vVec).normalized;
}
private static List <PointList> BridgeRectangleToRoundRectangle(PointList rect, PointList roundRect)
{
int pointsPerCorner = roundRect.Count / 4;
List <PointList> list = new List <PointList> ();
// Corner 1
for (int i = 1; i < pointsPerCorner; i++)
{
PointList points = new PointList();
points.Copy(rect, 0);
points.Copy(roundRect, i);
points.Copy(roundRect, i - 1);
list.Add(points);
}
// Corner 2
for (int i = 1; i < pointsPerCorner; i++)
{
PointList points = new PointList();
points.Copy(rect, 1);
points.Copy(roundRect, pointsPerCorner + i);
points.Copy(roundRect, pointsPerCorner + i - 1);
list.Add(points);
}
// Corner 3
for (int i = 1; i < pointsPerCorner; i++)
{
PointList points = new PointList();
points.Copy(rect, 2);
points.Copy(roundRect, 2 * pointsPerCorner + i);
points.Copy(roundRect, 2 * pointsPerCorner + i - 1);
list.Add(points);
}
// Corner 4
for (int i = 1; i < pointsPerCorner; i++)
{
PointList points = new PointList();
points.Copy(rect, 3);
points.Copy(roundRect, 3 * pointsPerCorner + i);
points.Copy(roundRect, 3 * pointsPerCorner + i - 1);
list.Add(points);
}
// Sides
for (int i = 1; i <= 4; i++)
{
PointList points = new PointList();
points.Copy(rect, i % 4);
points.Copy(roundRect, (i * pointsPerCorner) % roundRect.Count);
points.Copy(roundRect, (i * pointsPerCorner - 1) % roundRect.Count);
points.Copy(rect, (i - 1) % 4);
list.Add(points);
}
return(list);
}
private static List <PointList> BridgeRoundRectangleToRectangle(PointList roundRect, PointList rect)
{
return(BridgeRectangleToRoundRectangle(rect.Reverse(), roundRect.Reverse()));
}
private static PointList CreateXZRoundRectangle(float xSize, float zSize, float radius, int cornerSides, AxisSide axisSide, float axisCoord)
{
PointList result = new PointList();
float x = xSize * 0.5f - radius;
float z = zSize * 0.5f - radius;
float PI_2 = Mathf.PI * 0.5f;
float indexToAngle = PI_2 / cornerSides;
if (axisSide == AxisSide.Negative)
{
// Corner 1
for (int i = 0; i < cornerSides + 1; i++)
{
float angle = PI_2 + i * indexToAngle;
result.Add(-x + radius * Mathf.Cos(angle), axisCoord, z + radius * Mathf.Sin(angle));
}
// Corner 2
for (int i = 0; i < cornerSides + 1; i++)
{
float angle = Mathf.PI + i * indexToAngle;
result.Add(-x + radius * Mathf.Cos(angle), axisCoord, -z + radius * Mathf.Sin(angle));
}
// Corner 3
for (int i = 0; i < cornerSides + 1; i++)
{
float angle = -PI_2 + i * indexToAngle;
result.Add(x + radius * Mathf.Cos(angle), axisCoord, -z + radius * Mathf.Sin(angle));
}
// Corner 4
for (int i = 0; i < cornerSides + 1; i++)
{
float angle = i * indexToAngle;
result.Add(x + radius * Mathf.Cos(angle), axisCoord, z + radius * Mathf.Sin(angle));
}
}
else
{
// Corner 1
for (int i = 0; i < cornerSides + 1; i++)
{
float angle = Mathf.PI - i * indexToAngle;
result.Add(-x + radius * Mathf.Cos(angle), axisCoord, z + radius * Mathf.Sin(angle));
}
// Corner 4
for (int i = 0; i < cornerSides + 1; i++)
{
float angle = PI_2 - i * indexToAngle;
result.Add(x + radius * Mathf.Cos(angle), axisCoord, z + radius * Mathf.Sin(angle));
}
// Corner 3
for (int i = 0; i < cornerSides + 1; i++)
{
float angle = -i * indexToAngle;
result.Add(x + radius * Mathf.Cos(angle), axisCoord, -z + radius * Mathf.Sin(angle));
}
// Corner 2
for (int i = 0; i < cornerSides + 1; i++)
{
float angle = -PI_2 - i * indexToAngle;
result.Add(-x + radius * Mathf.Cos(angle), axisCoord, -z + radius * Mathf.Sin(angle));
}
}
return(result);
}
//
// Find the best Axis Aligned UV Mapper
//
public static void ComputeUVMapper(ref PointList points)
{
points.UVMapper = ComputeUVMapper(points);
}
