public void Generate()
{
var wythoff = new WythoffPoly(PolyType, PrismP, PrismQ);
wythoff.BuildFaces();
poly = new ConwayPoly(wythoff);
if (ApplyOp)
{
var o1 = new OpParams {
valueA = op1Amount1, valueB = op1Amount2, facesel = op1Facesel
};
poly = poly.ApplyOp(op1, o1);
}
if (Canonicalize)
{
poly = poly.Canonicalize(0.01, 0.01);
}
poly = poly.Transform(Position, Rotation, Scale);
var pos = SlicePosition;
if (animateSlice > 0)
{
pos.y = .1f + transform.position.y + ((Time.time % 2f) * animateSlice);
}
var rot = Quaternion.Euler(SliceRotation) * Vector3.up;
var slicePlane = new Plane(rot, pos);
var result = poly.SliceByPlane(slicePlane, Cap, includeTop, includeBottom);
poly = result.bottom;
var slicePoint = slicePlane.normal * (-slicePlane.distance + SegmentHeight);
slicePlane.SetNormalAndPosition(slicePlane.normal, slicePoint);
var(top, segment, _) = result.top.SliceByPlane(slicePlane, Cap, includeTop, includeBottom);
segment = segment.Transform(SegmentTransform);
poly.Append(top);
poly.Append(segment);
if (Weld)
{
poly = poly.Weld(0.0001f);
}
if (ApplyOp)
{
var o2 = new OpParams {
valueA = op2Amount1, valueB = op2Amount2, facesel = op2Facesel
};
poly = poly.ApplyOp(op2, o2);
}
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(poly, false, null, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
public void Generate()
{
var wythoff = new WythoffPoly(PolyType, PrismP, PrismQ);
wythoff.BuildFaces();
var poly = new ConwayPoly(wythoff);
ConwayPoly d, x, xd, dx, dxd;
var o = new OpParams {
valueA = op1Amount1, valueB = op1Amount2, facesel = op1Facesel
};
d = poly.Dual();
x = poly.ApplyOp(op, o);
xd = d.ApplyOp(op, o);
dx = poly.ApplyOp(op, o);
dx = dx.Dual();
dxd = d.ApplyOp(op, o);
dxd = dxd.Dual();
if (Canonicalize)
{
x = x.Canonicalize(0.01, 0.01);
dx = dx.Canonicalize(0.01, 0.01);
dxd = dxd.Canonicalize(0.01, 0.01);
xd = xd.Canonicalize(0.01, 0.01);
}
Debug.Log($"x: {x.vef.v},{x.vef.e},{x.vef.f}");
Debug.Log($"xd: {xd.vef.v},{xd.vef.e},{xd.vef.f}");
Debug.Log($"dx: {dx.vef.v},{dx.vef.e},{dx.vef.f}");
Debug.Log($"dxd: {dxd.vef.v},{dxd.vef.e},{dxd.vef.f}");
var allPoly = new ConwayPoly();
x = x.Transform(-Vector3.left);
xd = xd.Transform(Vector3.left * 2);
dx = dx.Transform(Vector3.left * 4);
dxd = dxd.Transform(Vector3.left * 6);
allPoly.Append(x);
allPoly.Append(xd);
allPoly.Append(dx);
allPoly.Append(dxd);
allPoly.Recenter();
allPoly = allPoly.Transform(Position, Rotation, Scale);
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(allPoly, false, null, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
public void Generate()
{
Func <FilterParams, bool> pickRandomly = x =>
{
// Sets random seed based on face index
// So that the results are the same if we call more than once
Random.InitState(x.index);
return(Random.value < Density);
};
// Generate the ground grid and extrude random buildings
var grid = Grids.Grids.MakeGrid(GridType, GridShape, width, depth);
grid = grid.VertexRotate(new OpParams(Jitter, randomValues: true));
var floors = grid.FaceKeep(new OpParams(.1f, pickRandomly));
var houses = floors.Loft(new OpParams(0, x => Random.Range(.5f, 1.5f)));
var(walls, roofs) = houses.Split(new OpParams(FaceSelections.Existing));
// Make window holes
walls = walls.Loft(new OpParams(0.75f, FaceSelections.AllNew));
walls = walls.FaceSlide(new OpParams(0.15f, FaceSelections.Existing));
walls = walls.FaceRemove(new OpParams(FaceSelections.Existing));
// Thicken the walls
walls = walls.Shell(0.025f);
// Add domes to the roofs
var domes = roofs.LoftAlongProfile(FaceSelections.All, DomeHeight, DomeSegments, easingType);
// Make nice patterns on the ground
var ground = grid.Dual();
ground = ground.Bevel(new OpParams(0.25f));
ground = ground.Medial(new OpParams(3f));
// Add some edging around buildings
var edging = floors.Transform(new Vector3(0, .03f, 0));
edging = edging.FaceScale(new OpParams(0.25f));
edging.SetFaceRoles(ConwayPoly.Roles.Existing);
// Assemble everything
var town = new ConwayPoly();
town.Append(edging);
town.Append(ground);
town.Append(walls);
town.Append(domes);
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(town, false, Colors, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
private ConwayPoly MakeAntenna(ConwayPoly spaceship)
{
var allNew = spaceship.FaceselToFaceFilterFunc(FaceSelections.AllNew);
var facingUp = spaceship.FaceselToFaceFilterFunc(FaceSelections.FacingUp);
Func <FilterParams, bool> newAndFacingUp = x => allNew(x) && facingUp(x);
var topSurfaces = spaceship.FaceKeep(new OpParams {
filterFunc = newAndFacingUp
});
var antennaGroup = new ConwayPoly();
var antenna = JohnsonPoly.Pyramid(4);
foreach (var face in topSurfaces.Faces)
{
float radius = Random.Range(0.01f, 0.05f);
float height = Random.Range(0.25f, 2f);
float offset = Random.value < .5 ? 0 : Random.value < 0.5 ? .5f : -.5f;
antennaGroup.Append(antenna.Transform(
face.GetPolarPoint(90, offset),
Vector3.zero,
new Vector3(radius, height, radius)
));
}
return(antennaGroup);
}
public void Generate()
{
var wythoff = new WythoffPoly(PolyType, PrismP, PrismQ);
wythoff.BuildFaces();
poly = new ConwayPoly(wythoff);
if (ApplyOp)
{
var o1 = new OpParams {
valueA = op1Amount1, valueB = op1Amount2, facesel = op1Facesel
};
poly = poly.ApplyOp(op1, o1);
}
if (Canonicalize)
{
poly = poly.Canonicalize(0.01, 0.01);
}
poly = poly.Transform(Position, Rotation, Scale);
var pos = SlicePosition;
if (animateSlice > 0)
{
pos.y = .1f + transform.position.y + ((Time.time % 2f) * animateSlice);
}
var result = poly.SliceByPlane(new Plane(Quaternion.Euler(SliceRotation) * Vector3.up, pos), Cap, includeTop, includeBottom);
poly = result.bottom;
var top = result.top.Transform(topTransform);
poly.Append(top);
// var sliceWythoff = new WythoffPoly(PolyTypes.Cube, 3, 3);
// sliceWythoff.BuildFaces();
// var slicePoly = new ConwayPoly(wythoff);
// slicePoly = slicePoly.Transform(SlicePosition, SliceRotation, Vector3.one * SliceScale);
// var result = poly.SliceByPoly(slicePoly, Cap);
// poly = result.outside;
// var top = result.outside.Transform(topTransform);
if (Weld)
{
poly = poly.Weld(0.0001f);
}
if (ApplyOp)
{
var o2 = new OpParams {
valueA = op2Amount1, valueB = op2Amount2, facesel = op2Facesel
};
poly = poly.ApplyOp(op2, o2);
}
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(poly, false, null, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
public void Generate()
{
Func <FilterParams, bool> pickRandomly = x =>
{
// Sets random seed based on face index
// So that the results are the same if we call more than once
Random.InitState(x.index);
return(Random.value < Density);
};
// Generate the ground grid and extrude random buildings
var grid = Grids.Grids.MakeGrid(GridType, GridShape, width, depth);
grid = grid.VertexRotate(new OpParams(Jitter, randomValues: true));
var faceSelectionFunc = grid.FaceselToFaceFilterFunc(faceSelection);
Func <FilterParams, bool> filterFunc = x => pickRandomly(x) && faceSelectionFunc(x);
var floors = grid.FaceKeep(new OpParams(.1f, filterFunc));
var houses = floors.Loft(new OpParams(0, x => Random.Range(.5f, 1.5f)));
var(walls, roofs) = houses.Split(new OpParams(FaceSelections.Existing));
// Make window holes
walls = walls.Loft(new OpParams(0.75f, FaceSelections.AllNew));
walls = walls.FaceSlide(new OpParams(0.15f, FaceSelections.Existing));
walls = walls.FaceRemove(new OpParams(FaceSelections.Existing));
// Thicken the walls
walls = walls.Shell(0.025f);
// Add domes to the roofs
var domes = roofs.LoftAlongProfile(new OpParams(DomeDepth, DomeHeight, FaceSelections.All), Profile, flipProfile: FlipProfile);
// Assemble everything
var town = new ConwayPoly();
town.Append(grid);
town.Append(walls);
town.Append(domes);
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(town, false, Colors, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
public static ConwayPoly ElongatedBicupola(int sides, bool gyro)
{
ConwayPoly poly = ElongatedCupola(sides);
Face bottom = poly.Faces[sides * 2];
int i = 0;
var middleVerts = bottom.GetVertices();
poly.Faces.Remove(bottom);
poly.FaceRoles.RemoveAt(poly.FaceRoles.Count - 1);
poly.FaceTags.RemoveAt(poly.FaceRoles.Count - 1);
float baseOffset = -(_CalcSideLength(sides * 2) + _CalcCupolaHeight(sides));
float angleOffset = gyro ? 0.75f : 0.25f;
ConwayPoly cap2 = _MakePolygon(sides, false, angleOffset, baseOffset, _CalcCupolaCapRadius(sides));
poly.Append(cap2);
var edge2 = poly.Faces.Last().Halfedge.Prev;
int edgeOffset = gyro ? 0 : 1;
while (true)
{
var side1 = new List <Vertex>
{
middleVerts[PolyUtils.ActualMod(i * 2 - 1 - edgeOffset, sides * 2)],
middleVerts[PolyUtils.ActualMod(i * 2 - edgeOffset, sides * 2)],
edge2.Vertex
};
poly.Faces.Add(side1);
poly.FaceRoles.Add(ConwayPoly.Roles.New);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
var side2 = new List <Vertex>
{
middleVerts[PolyUtils.ActualMod(i * 2 - edgeOffset, sides * 2)],
middleVerts[PolyUtils.ActualMod(i * 2 + 1 - edgeOffset, sides * 2)],
edge2.Next.Vertex,
edge2.Vertex,
};
poly.Faces.Add(side2);
poly.FaceRoles.Add(ConwayPoly.Roles.NewAlt);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
i++;
edge2 = edge2.Next;
if (i == sides)
{
break;
}
}
poly.Halfedges.MatchPairs();
return(poly);
}
public static ConwayPoly GyroelongatedCupola(int sides)
{
ConwayPoly poly = Antiprism(sides * 2);
Face topFace = poly.Faces[1];
ConwayPoly cap1 = _MakePolygon(sides, true, 0f, _CalcCupolaHeight(sides) + _CalcAntiprismHeight(sides * 2), _CalcCupolaCapRadius(sides));
poly.Append(cap1);
int i = 0;
var middleVerts = topFace.GetVertices();
poly.Faces.Remove(topFace);
poly.FaceRoles.RemoveAt(1);
poly.FaceTags.RemoveAt(1);
var edge2 = poly.Faces.Last().Halfedge.Prev;
while (true)
{
var side1 = new List <Vertex>
{
middleVerts[PolyUtils.ActualMod(i * 2 - 1, sides * 2)],
middleVerts[PolyUtils.ActualMod(i * 2, sides * 2)],
edge2.Vertex
};
poly.Faces.Add(side1);
poly.FaceRoles.Add(ConwayPoly.Roles.New);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
var side2 = new List <Vertex>
{
middleVerts[PolyUtils.ActualMod(i * 2, sides * 2)],
middleVerts[PolyUtils.ActualMod(i * 2 + 1, sides * 2)],
edge2.Next.Vertex,
edge2.Vertex,
};
poly.Faces.Add(side2);
poly.FaceRoles.Add(ConwayPoly.Roles.NewAlt);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
i++;
edge2 = edge2.Next;
if (i == sides)
{
break;
}
}
poly.Halfedges.MatchPairs();
return(poly);
}
private ConwayPoly MakeSection(ConwayPoly spaceship)
{
if (Random.value < ChanceOfLaceSegment)
{
spaceship = spaceship.Lace(new OpParams {
valueA = Random.Range(loftLow, loftHigh), facesel = FaceSelections.FacingStraightForward, valueB = Random.Range(.2f, .5f)
});
}
else if (Random.value < ChanceOfStakeSegment && !alreadyStake) // Only do this once
{
spaceship = spaceship.Stake(new OpParams {
valueA = Random.Range(loftLow, loftHigh), facesel = FaceSelections.FacingForward
});
alreadyStake = true;
}
else if (Random.value < ChanceOfRibbedSegment)
{
spaceship = RibbedExtrude(spaceship, Random.Range(2, 7));
}
else // Just a normal section
{
spaceship = spaceship.Loft(new OpParams {
valueA = Random.Range(loftLow, loftHigh), valueB = Random.Range(.2f, .5f), facesel = FaceSelections.FacingStraightForward
});
// Each simple section can have wings or fins
if (Random.value < ChanceOfWings)
{
var newWings = MakeWings(spaceship, MakeSideFaceFilter(numSides));
wings.Append(newWings);
}
else if (Random.value < ChanceOfFins)
{
spaceship = spaceship.Loft(new OpParams {
valueA = Random.Range(.5f, 0), valueB = Random.Range(0.05f, 1.0f), facesel = FaceSelections.AllNew
});
}
else if (Random.value < ChanceOfAntenna)
{
antennae.Append(MakeAntenna(spaceship));
}
}
spaceship = spaceship.FaceSlide(new OpParams {
valueA = Random.Range(-.3f, .3f), valueB = 0, facesel = FaceSelections.FacingStraightForward
});
return(spaceship);
}
// Work in progress. Not working at the moment
private static ConwayPoly _MakeRotunda(int sides, float height, bool bi = false)
{
sides = Mathf.Clamp(sides, 3, 64);
ConwayPoly poly = _MakePolygon(sides);
Face bottom = poly.Faces[0];
ConwayPoly cap1 = _MakePolygon(sides, true, 0.25f, height, _CalcCupolaCapRadius(sides));
poly.Append(cap1);
int i = 0;
// var upperTriFaces = new List<Face>();
// var LowerTriFaces = new List<Face>();
// var SidePentFaces = new List<Face>();
var edge1 = poly.Halfedges[0];
var edge2 = poly.Halfedges[sides * 2];
while (true)
{
poly.Vertices.Add(new Vertex(Vector3.Lerp(edge1.Vector, edge2.Vector, _CalcCupolaCapRadius(sides))));
var newV1 = poly.Vertices.Last();
poly.Vertices.Add(new Vertex(Vector3.Lerp(edge1.Prev.Vector, edge2.Next.Vector, 0.5f)));
var newV2 = poly.Vertices.Last();
var pentFace = new List <Vertex>
{
edge1.Next.Vertex,
edge1.Vertex,
newV1,
};
poly.Faces.Add(pentFace);
poly.FaceRoles.Add(ConwayPoly.Roles.New);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
i++;
edge1 = edge1.Next.Next;
edge2 = edge2.Prev;
if (i == sides)
{
break;
}
}
poly.Halfedges.MatchPairs();
return(poly);
}
public static ConwayPoly GyroelongatedBirotunda()
{
int sides = 10;
float bodyHeight = _CalcAntiprismHeight(sides);
ConwayPoly poly = Rotunda();
ConwayPoly baseDome = poly.Duplicate();
var boundaryEdges1 = poly.Faces.Remove(poly.Faces.Last());
baseDome.Mirror(Vector3.up, -bodyHeight);
baseDome.Halfedges.Flip();
baseDome = baseDome.Rotate(Vector3.up, 36f / 2f);
poly.Append(baseDome);
var boundaryEdges2 = poly.Faces.Remove(poly.Faces.Last());
boundaryEdges2.Reverse();
for (var i = 0; i < boundaryEdges1.Count; i++)
{
var edge1 = boundaryEdges1[i];
var edge2 = boundaryEdges2[i];
var side1 = new List <Vertex>
{
edge1.Vertex,
edge1.Prev.Vertex,
edge2.Prev.Vertex
};
poly.Faces.Add(side1);
poly.FaceRoles.Add(ConwayPoly.Roles.New);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
var side2 = new List <Vertex>
{
edge2.Vertex,
edge2.Prev.Vertex,
edge1.Prev.Vertex,
};
poly.Faces.Add(side2);
poly.FaceRoles.Add(ConwayPoly.Roles.NewAlt);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
}
poly.Halfedges.MatchPairs();
return(poly);
}
public void Generate()
{
var poly = JohnsonPoly.Antiprism(4);
var cube = JohnsonPoly.Prism(4);
var decorations = new ConwayPoly();
cube = cube.Transform(Vector3.zero, Vector3.zero, Vector3.one * cubeScale);
foreach (var face in poly.Faces)
{
for (float angle = 0; angle < 360; angle += theta)
{
var pos = face.GetPolarPoint(angle, distance);
var look = Quaternion.LookRotation(face.Normal, Vector3.up).eulerAngles + new Vector3(90, 0, 0);
decorations.Append(cube.Transform(pos, look, Vector3.one));
}
}
//poly.Append(decorations);
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(decorations, false);
GetComponent <MeshFilter>().mesh = mesh;
}
void Start()
{
// 1. Create a starting shape
ConwayPoly poly1 = JohnsonPoly.Build(PolyHydraEnums.JohnsonPolyTypes.Prism, 4);
// 2. Apply an operator to the starting shape
poly1 = poly1.ApplyOp(Ops.Chamfer, new OpParams(.3f));
// 3. Create a second shape
ConwayPoly poly2 = JohnsonPoly.Build(PolyHydraEnums.JohnsonPolyTypes.Pyramid, 4);
// 4. Move our second shape down by 0.5
poly2 = poly1.Transform(new Vector3(0, .5f, 0));
// 5. Join the two shapes
poly1.Append(poly2);
// 6. Build and apply the mesh
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(poly1);
GetComponent <MeshFilter>().mesh = mesh;
}
public void Generate()
{
poly = JohnsonPoly.Build(JohnsonPolyType, Sides);
poly = poly.Transform(PositionBefore, RotationBefore, ScaleBefore);
if (ApplyOp)
{
var o0 = new OpParams {
valueA = op0Amount1, valueB = op0Amount2, facesel = op0Facesel
};
poly = poly.ApplyOp(op0, o0);
}
if (Canonicalize)
{
poly = poly.Canonicalize(0.01, 0.01);
}
poly.Recenter();
ConwayPoly DoSlices(ConwayPoly input, Vector3 axis)
{
var result = new ConwayPoly();
if (SliceDistance < 0.01f)
{
return(result);
}
float offset = SliceStart;
do
{
offset += SliceDistance;
var planePos = new Vector3(offset * axis.x, offset * axis.y, offset * axis.z);
var sliced = input.SliceByPlane(new Plane(Quaternion.Euler(SliceAngle) * axis, planePos), true, false, false, true);
result.Append(sliced.cap);
} while (offset < SliceEnd);
return(result);
}
var output = new ConwayPoly();
if (SliceX)
{
output.Append(DoSlices(poly, Vector3.right));
}
if (SliceY)
{
output.Append(DoSlices(poly, Vector3.up));
}
if (SliceZ)
{
output.Append(DoSlices(poly, Vector3.forward));
}
if (Shell)
{
var shellParams = new OpParams {
valueA = SliceDistance - ShellSpacing
};
output = output.ApplyOp(Ops.Shell, shellParams);
}
if (ApplyOp)
{
var o1 = new OpParams {
valueA = op1Amount1, valueB = op1Amount2, facesel = op1Facesel
};
output = output.ApplyOp(op1, o1);
if (Weld)
{
poly = poly.Weld(0.0001f);
}
var o2 = new OpParams {
valueA = op2Amount1, valueB = op2Amount2, facesel = op2Facesel
};
output = output.ApplyOp(op2, o2);
}
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(output, false, null, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
private static ConwayPoly _MakePrism(int sides, float height, bool anti = false)
{
ConwayPoly poly = _MakePolygon(sides);
ConwayPoly cap = _MakePolygon(sides, true, anti?0.5f:0, height);
poly.Append(cap);
int i = 0;
var edge1 = poly.Halfedges[0];
var edge2 = poly.Halfedges[sides];
while (true)
{
if (anti)
{
var side1 = new List <Vertex>
{
edge1.Vertex,
edge1.Prev.Vertex,
edge2.Vertex
};
poly.Faces.Add(side1);
poly.FaceRoles.Add(ConwayPoly.Roles.New);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
var side2 = new List <Vertex>
{
edge1.Vertex,
edge2.Vertex,
edge2.Prev.Vertex
};
poly.Faces.Add(side2);
poly.FaceRoles.Add(ConwayPoly.Roles.NewAlt);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
}
else
{
var side = new List <Vertex>
{
edge1.Vertex,
edge1.Prev.Vertex,
edge2.Vertex,
edge2.Prev.Vertex
};
poly.Faces.Add(side);
poly.FaceRoles.Add(ConwayPoly.Roles.New);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
}
i++;
edge1 = edge1.Next;
edge2 = edge2.Prev;
if (i == sides)
{
break;
}
}
poly.Halfedges.MatchPairs();
return(poly);
}
public void Generate()
{
poly = JohnsonPoly.Build(JohnsonPolyType, sides);
if (ApplyOp)
{
var o1 = new OpParams {
valueA = op1Amount1, valueB = op1Amount2, facesel = op1Facesel
};
poly = poly.ApplyOp(op1, o1);
}
// Find and remove the edge loop
var face = poly.Faces[ConwayPoly.ActualMod(StartingFace, poly.Faces.Count)];
var edges = face.GetHalfedges();
var startingEdge = edges[ConwayPoly.ActualMod(StartingEdge, edges.Count)];
loop = poly.GetFaceLoop(startingEdge);
var faceIndices = loop.Select(x => x.Item1).ToList();
if (LoopAction == LoopActions.Remove)
{
poly = poly.FaceRemove(false, faceIndices);
}
else if (LoopAction == LoopActions.Keep)
{
poly = poly.FaceRemove(true, faceIndices);
}
else if (LoopAction == LoopActions.SplitFaces)
{
poly = poly.SplitLoop(loop);
}
else if (LoopAction == LoopActions.Split)
{
ConwayPoly otherPoly;
(otherPoly, poly) = poly.Split(new OpParams(x => faceIndices.Contains(x.index)));
poly.FaceRoles = Enumerable.Repeat(ConwayPoly.Roles.Existing, poly.Faces.Count).ToList();
poly.VertexRoles = Enumerable.Repeat(ConwayPoly.Roles.Existing, poly.Vertices.Count).ToList();
otherPoly.FaceRoles = Enumerable.Repeat(ConwayPoly.Roles.New, otherPoly.Faces.Count).ToList();
otherPoly.VertexRoles = Enumerable.Repeat(ConwayPoly.Roles.New, otherPoly.Vertices.Count).ToList();
poly.Append(otherPoly);
}
else if (LoopAction == LoopActions.SetRole)
{
var faceRoles = new List <ConwayPoly.Roles>();
for (var faceIndex = 0; faceIndex < poly.Faces.Count; faceIndex++)
{
faceRoles.Add(faceIndices.Contains(faceIndex) ? ConwayPoly.Roles.Existing : ConwayPoly.Roles.New);
}
poly.FaceRoles = faceRoles;
}
if (ApplyOp)
{
var o2 = new OpParams {
valueA = op2Amount1, valueB = op2Amount2, facesel = op2Facesel
};
poly = poly.ApplyOp(op2, o2);
}
if (Canonicalize)
{
poly = poly.Canonicalize(0.1, 0.1);
}
poly = poly.Transform(Position, Rotation, Scale);
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(poly, false, null, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
public void Generate()
{
poly = JohnsonPoly.Build(JohnsonPolyType, Sides);
poly = poly.Transform(PositionBefore, RotationBefore, ScaleBefore);
if (ApplyOp)
{
var o0 = new OpParams {
valueA = op0Amount1, valueB = op0Amount2, facesel = op0Facesel
};
poly = poly.ApplyOp(op0, o0);
}
if (Canonicalize)
{
poly = poly.Canonicalize(0.01, 0.01);
}
poly.Recenter();
ConwayPoly DoSlices(ConwayPoly input, Vector3 axis)
{
var result = new ConwayPoly();
float offset = SliceStart;
int failsafe = 100;
do
{
offset += SliceDistance;
var planePos = new Vector3(offset * axis.x, offset * axis.y, offset * axis.z);
var sliced = input.SliceByPlane(new Plane(Quaternion.Euler(SliceAngle) * axis, planePos), Cap);
var gapVector = new Vector3(-SliceGap * axis.x, -SliceGap * axis.y, -SliceGap * axis.z);
result = result.Transform(gapVector);
var lerp = Mathf.InverseLerp(SliceStart, SliceEnd, offset);
var shift = new Vector3(Mathf.Sin(lerp * frequency) * amplitude, 0, 0);
result.Append(sliced.bottom.Transform(shift));
input = sliced.top;
failsafe--;
} while (offset < SliceEnd && failsafe > 0);
result.Append(input);
if (Weld)
{
result = result.Weld(0.0001f);
}
return(result);
}
var output = new ConwayPoly();
output.Append(DoSlices(poly, Vector3.up));
if (ApplyOp)
{
var o1 = new OpParams {
valueA = op1Amount1, valueB = op1Amount2, facesel = op1Facesel
};
output = output.ApplyOp(op1, o1);
if (Weld)
{
poly = poly.Weld(0.0001f);
}
var o2 = new OpParams {
valueA = op2Amount1, valueB = op2Amount2, facesel = op2Facesel
};
output = output.ApplyOp(op2, o2);
}
output.Recenter();
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(output, false, null, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
public void Generate()
{
var wythoff = new WythoffPoly(PolyType, PrismP, PrismQ);
wythoff.BuildFaces();
poly = new ConwayPoly(wythoff);
if (ApplyOp)
{
var o1 = new OpParams {
valueA = op1Amount1, valueB = op1Amount2, facesel = op1Facesel
};
poly = poly.ApplyOp(op1, o1);
}
if (Canonicalize)
{
poly = poly.Canonicalize(0.01, 0.01);
}
poly = poly.Transform(Position, Rotation, Scale);
var rot = SliceRotation;
if (animateSlice > 0)
{
rot.y = Time.time * animateSlice;
}
SliceRotation = rot;
var sliceWythoff = new WythoffPoly(SlicePolyType, 3, 3);
sliceWythoff.BuildFaces();
var slicePoly = new ConwayPoly(sliceWythoff);
slicePoly = slicePoly.Transform(SlicePosition, SliceRotation, Vector3.one * SliceScale);
var result = poly.SliceByPoly(slicePoly, Cap, FaceCount);
poly = result.outside;
var inside = result.inside.Transform(insideTransform);
poly.Append(inside);
if (ShowSlicePoly)
{
poly.Append(slicePoly);
}
if (Weld)
{
poly = poly.Weld(0.0001f);
}
if (ApplyOp)
{
var o2 = new OpParams {
valueA = op2Amount1, valueB = op2Amount2, facesel = op2Facesel
};
poly = poly.ApplyOp(op2, o2);
}
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(poly, false, null, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
public void Generate()
{
switch (ShapeType)
{
case ShapeTypes.Wythoff:
var wythoff = new WythoffPoly(PolyType, P, Q);
wythoff.BuildFaces();
polyBeforeOp = new ConwayPoly(wythoff);
break;
case ShapeTypes.Johnson:
polyBeforeOp = JohnsonPoly.Build(JohnsonPolyType, P);
break;
case ShapeTypes.Grid:
polyBeforeOp = Grids.Grids.MakeGrid(GridType, GridShape, P, Q);
break;
}
var o1 = new OpParams {
valueA = op1Amount1, valueB = op1Amount2, facesel = op1Facesel
};
polyBeforeOp = polyBeforeOp.ApplyOp(op1, o1);
// Collision Mesh
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(polyBeforeOp, false, null, ColorMethod);
GetComponent <MeshCollider>().sharedMesh = mesh;
miscUVs2 = new List <Vector4>();
mesh.GetUVs(4, miscUVs2);
if (PolyHydraEnums.OpConfigs[op2].usesFaces)
{
var o2 = new OpParams {
valueA = op2Amount1, valueB = op2Amount2, filterFunc = x => SelectedFaces.Contains(x.index)
};
polyAfterOp = polyBeforeOp.ApplyOp(op2, o2);
}
else
{
var(excluded, included) = polyBeforeOp.Split(new OpParams {
filterFunc = x => SelectedFaces.Contains(x.index)
});
var o2 = new OpParams {
valueA = op2Amount1, valueB = op2Amount2
};
polyAfterOp = included.ApplyOp(op2, o2);
polyAfterOp.Append(excluded);
if (AttemptToFillHoles)
{
polyAfterOp = polyAfterOp.Weld(0.1f);
polyAfterOp = polyAfterOp.FillHoles();
}
}
// Final Mesh
mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(polyAfterOp, false, null, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
public void Generate()
{
if (Random.seed != 0)
{
Random.seed = RandomSeed;
}
poly = JohnsonPoly.Build(JohnsonPolyType, Sides);
poly = poly.Transform(PositionBefore, RotationBefore, ScaleBefore);
if (ApplyOp)
{
var o1 = new OpParams {
valueA = op1Amount1, valueB = op1Amount2, facesel = op1Facesel
};
poly = poly.ApplyOp(op1, o1);
}
if (Canonicalize)
{
poly = poly.Canonicalize(0.01, 0.01);
}
// poly.Recenter();
ConwayPoly DoSlices(ConwayPoly input, Vector3 axis)
{
var result = new ConwayPoly();
float offset = SliceStart;
do
{
offset += Random.Range(SliceMin, SliceMax);
var planePos = new Vector3(offset * axis.x, offset * axis.y, offset * axis.z);
var sliced = input.SliceByPlane(new Plane(Quaternion.Euler(SliceAngle) * axis, planePos), Cap);
var gapVector = new Vector3(-Gap * axis.x, -Gap * axis.y, -Gap * axis.z);
result = result.Transform(gapVector);
float randomShift = Random.Range(ShiftMin, ShiftMax);
var randomShiftVector = new Vector3(randomShift * axis.y, randomShift * axis.z, randomShift * axis.x);
result.Append(sliced.bottom.Transform(randomShiftVector));
input = sliced.top;
} while (offset < SliceEnd);
result.Append(input);
if (Weld)
{
result = result.Weld(0.0001f);
}
return(result);
}
if (SliceX)
{
poly = DoSlices(poly, Vector3.right);
}
if (SliceY)
{
poly = DoSlices(poly, Vector3.up);
}
if (SliceZ)
{
poly = DoSlices(poly, Vector3.forward);
}
// if (Weld)
// {
// poly = poly.Weld(0.0001f);
// }
if (ApplyOp)
{
var o2 = new OpParams {
valueA = op2Amount1, valueB = op2Amount2, facesel = op2Facesel
};
poly = poly.ApplyOp(op2, o2);
}
// poly.Recenter();
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(poly, false, null, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
public void Generate()
{
Random.seed = seed;
spaceship = JohnsonPoly.Prism(numSides);
wings = new ConwayPoly();
antennae = new ConwayPoly();
float angleCorrection = 180f / numSides;
if (numSides % 2 != 0)
{
angleCorrection /= 2f;
}
spaceship = spaceship.Rotate(Vector3.up, angleCorrection);
spaceship = spaceship.Rotate(Vector3.left, -90);
alreadyStake = false;
for (int i = 0; i < 2; i++) // Loop twice - once for the back and once for the front.
{
for (int j = 0; j <= numSections; j++)
{
spaceship = MakeSection(spaceship);
}
// Second time through loop:
// Flip everything around ready to generate the back sections
spaceship = spaceship.Rotate(Vector3.up, 180);
wings = wings.Rotate(Vector3.up, 180);
antennae = antennae.Rotate(Vector3.up, 180);
// Change random range for front sections
loftLow = -0.35f;
loftHigh = 0.15f;
}
// Make the engines
var engines = spaceship.FaceKeep(new OpParams {
facesel = FaceSelections.FacingStraightBackward
});
spaceship = spaceship.FaceRemove(new OpParams {
facesel = FaceSelections.FacingStraightBackward
});
engines = engines.Loft(new OpParams {
valueA = Random.Range(.3f, .4f), valueB = Random.Range(-.2f, .2f)
});
// spaceship = engines;
if (EngineVariant)
{
var engineRim = engines.FaceRemove(new OpParams {
facesel = FaceSelections.Existing
});
engines = engines.FaceKeep(new OpParams {
facesel = FaceSelections.Existing
});
engines = engines.Ortho(new OpParams {
valueA = 0
});
engines = engines.Loft(new OpParams {
valueA = Random.Range(0, .25f), valueB = -.5f
});
engines.Append(engineRim);
}
else
{
engines = engines.Loft(new OpParams {
valueA = Random.Range(.25f, .75f), valueB = Random.Range(0, .2f), facesel = FaceSelections.Existing
});
engines = engines.Loft(new OpParams {
valueA = Random.Range(.1f, .3f), valueB = Random.Range(-.3f, -.7f), facesel = FaceSelections.AllNew
});
}
// Make the nose section
if (NoseLength > 0)
{
spaceship = spaceship.Loft(new OpParams {
valueA = .2f, valueB = 0, facesel = FaceSelections.FacingStraightForward
});
spaceship = spaceship.FaceSlide(new OpParams {
valueA = .12f, facesel = FaceSelections.Existing
});
if (NoseVariant)
{
spaceship = spaceship.Lace(new OpParams {
valueA = NoseSharpness, valueB = NoseLength, facesel = FaceSelections.Existing
});
}
else
{
spaceship = spaceship.Loft(new OpParams {
valueA = NoseSharpness, valueB = NoseLength, facesel = FaceSelections.Existing
});
}
}
// Add panel insets to the hull
spaceship = spaceship.Loft(new OpParams {
valueA = 0.1f, valueB = 0.025f
});
// Add panel insets to the wings
wings = wings.Loft(new OpParams {
valueA = 0.1f, valueB = 0.025f
});
spaceship.Append(engines);
spaceship.Append(wings);
spaceship.Append(antennae);
// Build the final mesh
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(spaceship, false);
GetComponent <MeshFilter>().mesh = mesh;
GetComponent <MeshRenderer>().material = material;
}
private static ConwayPoly _MakeCupola(int sides, float height, bool bi = false, bool gyro = true)
{
sides = Mathf.Clamp(sides, 3, 64);
ConwayPoly poly = _MakePolygon(sides * 2);
Face bottom = poly.Faces[0];
ConwayPoly cap1 = _MakePolygon(sides, true, 0.25f, height, _CalcCupolaCapRadius(sides));
poly.Append(cap1);
int i = 0;
var squareSideFaces = new List <Face>();
var edge1 = poly.Halfedges[0];
var edge2 = poly.Halfedges[sides * 2];
while (true)
{
var side1 = new List <Vertex>
{
edge1.Next.Vertex,
edge1.Vertex,
edge2.Prev.Vertex
};
poly.Faces.Add(side1);
poly.FaceRoles.Add(ConwayPoly.Roles.New);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
var side2 = new List <Vertex>
{
edge1.Vertex,
edge1.Prev.Vertex,
edge2.Vertex,
edge2.Prev.Vertex
};
poly.Faces.Add(side2);
squareSideFaces.Add(poly.Faces.Last());
poly.FaceRoles.Add(ConwayPoly.Roles.NewAlt);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
i++;
edge1 = edge1.Next.Next;
edge2 = edge2.Prev;
if (i == sides)
{
break;
}
}
if (bi)
{
float angleOffset = gyro ? 0.75f : 0.25f;
ConwayPoly cap2 = _MakePolygon(sides, false, angleOffset, -height, _CalcCupolaCapRadius(sides));
poly.Append(cap2);
i = 0;
var middleVerts = bottom.GetVertices();
poly.Faces.Remove(bottom);
poly.FaceRoles.RemoveAt(0);
edge2 = poly.Faces.Last().Halfedge.Prev;
int indexOffset = gyro ? 0 : -1;
while (true)
{
var side1 = new List <Vertex>
{
middleVerts[PolyUtils.ActualMod(i * 2 - 1 + indexOffset, sides * 2)],
middleVerts[PolyUtils.ActualMod(i * 2 + indexOffset, sides * 2)],
edge2.Vertex
};
poly.Faces.Add(side1);
poly.FaceRoles.Add(ConwayPoly.Roles.New);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
var side2 = new List <Vertex>
{
middleVerts[PolyUtils.ActualMod(i * 2 + indexOffset, sides * 2)],
middleVerts[PolyUtils.ActualMod(i * 2 + 1 + indexOffset, sides * 2)],
edge2.Next.Vertex,
edge2.Vertex,
};
poly.Faces.Add(side2);
poly.FaceRoles.Add(ConwayPoly.Roles.NewAlt);
poly.FaceTags.Add(new HashSet <Tuple <string, ConwayPoly.TagType> >());
i++;
edge2 = edge2.Next;
if (i == sides)
{
break;
}
}
}
poly.Halfedges.MatchPairs();
return(poly);
}
