public static List<MeshFilter> fillCell(Vector3 start, Vector3 end, Vector3 size, Vector3 dimensions, Transform parent, Color color, Vector3 normal) {
List<MeshFilter> meshes = new List<MeshFilter> ();
// Calculate edge and it's magnitude
Vector3 edge = end-start;
Vector3 direction = edge.normalized;
float magnitude = edge.magnitude;
Quaternion rotation = Quaternion.FromToRotation (Vector3.forward, direction);
int numCells = (int) Mathf.Floor(magnitude / dimensions.z) + 1; // Floor the number of cells and add one (no Roof method is available)
float magnitudeOvershoot = -(magnitude - numCells * dimensions.z);
Vector3 startCenter = start + direction * dimensions.z / 2;
float overshootSize = dimensions.z - magnitudeOvershoot;
for (int i = 0; i < numCells; i++) {
Vector3 p = startCenter + i * direction * dimensions.z;
if (i == numCells - 1) {
if (overshootSize > 0.01f) {
size.z = overshootSize;
p -= magnitudeOvershoot / 2 * direction;
Cell c = new Cell (parent, p, size, rotation, "CellOvershoot", normal);
c.setColor(color);
meshes.Add(c.getCell ().GetComponent<MeshFilter> ());
}
} else {
Cell c = new Cell (parent, p, size, rotation, "Cell", normal);
c.setColor(color);
meshes.Add (c.getCell ().GetComponent<MeshFilter> ());
}
}
return meshes;
}
public override List<MeshFilter> apply (Corner corner)
{
List<MeshFilter> meshes = new List<MeshFilter> ();
Vector3 normal = corner.getNormal ();
Vector3 p = corner.getVertex ().getPoint ();
p = parent.TransformPoint (p);
Vector3 scale = this.getCornerScale ();
foreach (HighLevelEdge e in corner.getEdges()) {
Vector3 direction = e.getDirection (corner).normalized;
// Debug.DrawRay (p, direction * 0.2f, Color.cyan, 200);
Quaternion rotation = Quaternion.FromToRotation(Vector3.forward, direction);
Vector3 location = p + direction * scale.z / 2 + e.getNormal () * scale.x / 2;
Cell c = new Cell (parent, location, scale, rotation, "BrickCorner");
meshes.Add(c.getCell ().GetComponent<MeshFilter> ());
}
// p += Vector3.Scale(translateVector, dimensions / 2);
// Cell c = new Cell (parent, p, scale, Quaternion.identity, "BrickCorner");
// Color finalColor = Color.Lerp (color, Color.black, UnityEngine.Random.value * 0.3f);
// c.setColor (finalColor);
return meshes;
}
public override List<MeshFilter> apply (Corner corner)
{
List<MeshFilter> meshes = new List<MeshFilter>();
Vector3 translateVector = corner.getTranslateVector ();
Vector3 p = corner.getVertex ().getPoint ();
p = parent.TransformPoint (p);
Vector3 scale = this.getCornerScale ();
p += Vector3.Scale(translateVector, dimensions / 2);
Cell c = new Cell (parent, p, scale, Quaternion.identity, "BrickCorner");
Color finalColor = Color.Lerp (color, Color.black, UnityEngine.Random.value * 0.3f);
c.setColor (finalColor);
meshes.Add (c.getCell ().GetComponent<MeshFilter> ());
return meshes;
}
public override List<MeshFilter> apply (HighLevelEdge edge)
{
List<MeshFilter> meshes = new List<MeshFilter> ();
Vector3 cornerDimensions = new Vector3 (1.0f, 1.0f, 1.0f);
// Get points of edge and translate to world space
Corner cFrom = edge.getFrom();
Vector3 from = edge.getFrom ().getVertex().getPoint();
Vector3 to = edge.getTo ().getVertex().getPoint();
from = parent.TransformPoint (from);
to = parent.TransformPoint (to);
// Get other two edges for brick direction
HighLevelEdge e1 = null, e2 = null;
foreach (HighLevelEdge e in edge.getFrom().getEdges()) {
if (e.Equals (edge))
continue;
else if (e1 == null) {
e1 = e;
} else if (e2 == null) {
e2 = e;
} else {
Debug.Log ("Warning more then 3 edges, likely invalid render");
}
}
if (e2 == null) {
Debug.Log ("Warning, corner with only one edge found, something went wrong!");
return meshes;
}
// Calculate rotation for the two directions
Vector3 e1Dir = e1.getDirection(cFrom).normalized;
Vector3 e2Dir = e2.getDirection(cFrom).normalized;
Quaternion rotationE1 = Quaternion.FromToRotation(Vector3.forward, e1Dir);
Quaternion rotationE2 = Quaternion.FromToRotation (Vector3.forward, e2Dir);
// Get direction and translate to world space
Vector3 direction = edge.getDirection ();
direction = parent.TransformDirection (direction);
float edgeMagnitude = parent.TransformVector (direction).magnitude - cornerDimensions.y * 2;
direction.Normalize ();
// Set from and to actual center points of the corner
from = from + Vector3.Scale (edge.getFrom ().getTranslateVector (), cornerDimensions/2) + Vector3.Scale(direction, cornerDimensions/2);
to = to + Vector3.Scale (edge.getTo ().getTranslateVector (), cornerDimensions/2) - Vector3.Scale(direction, cornerDimensions/2);
edgeMagnitude = (to-from).magnitude;
// These are all world space
Vector3 dimensions = this.getCellDimensions ();
Vector3 scale = this.getCellSize();
// Calculate start position
Vector3 start = from + direction * dimensions.y / 2;
// Create each cell
int maxCount = (int) Mathf.Floor(edgeMagnitude / scale.y) - 1;
int i = 0;
bool takeDir1 = direction.y >= 0;
float stepSize = dimensions.y;
for (Vector3 p = start; i < maxCount; p += direction * stepSize) {
Cell c;
Color finalColor = Color.Lerp (color, Color.black, UnityEngine.Random.value * 0.3f);
if (takeDir1) {
c = new Cell (parent, p + (dimensions.z / 2 - cornerDimensions.z / 2) * e1Dir, scale, rotationE1, "CornerEdgeBrick");
} else {
c = new Cell (parent, p + (dimensions.z / 2 - cornerDimensions.z / 2) * e2Dir, scale, rotationE2, "CornerEdgeBrick");
}
takeDir1 = !takeDir1;
c.setColor (finalColor);
i++;
meshes.Add(c.getCell().GetComponent<MeshFilter>());
}
return meshes;
}
