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);
var o2 = new OpParams {
valueA = op2Amount1, valueB = op2Amount2, facesel = op2Facesel
};
poly = poly.ApplyOp(op2, o2);
}
if (Canonicalize)
{
poly = poly.Canonicalize(0.01, 0.01);
}
poly = poly.LoftAlongProfile(new OpParams(DomeDepth, DomeHeight, domeFaceSel), Profile, Shear, shearDirection, flipProfile: FlipProfile);
// poly = poly.Transform(Position, Rotation, Scale);
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(poly, false, Colors, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
public void Generate()
{
poly = WatermanPoly.Build(1f, root, c, MergeFaces);
if (ApplyOps)
{
var o1 = new OpParams {
valueA = op1Amount1, valueB = op1Amount2, facesel = op1Facesel
};
poly = poly.ApplyOp(op1, o1);
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, Colors, 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 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()
{
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 virtual void AfterAllOps()
{
if (Canonicalize)
{
poly = poly.Canonicalize(0.01, 0.01);
}
if (Position != Vector3.zero || Rotation != Vector3.zero || Scale != Vector3.one)
{
poly = poly.Transform(Position, Rotation, Scale);
}
}
public void Generate()
{
poly = JohnsonPoly.Build(JohnsonPolyType, sides);
Face face;
var sidesFilter = poly.FaceselToFaceFilterFunc(FaceSelections.FourSided);
var roleFilter = poly.FaceselToFaceFilterFunc(FaceSelections.New);
Func <FilterParams, bool> filterFunc = x => sidesFilter(x);
for (int i = 0; i < splits; i++)
{
face = poly.GetFace(new OpParams(filterFunc), 0);
if (face != null)
{
var edges = face.GetHalfedges();
poly = poly.SplitLoop(poly.GetFaceLoop(edges[edgeIndex % edges.Count]), splitRatio);
}
// Change the filter after the first loop iteration as we can
// ensure we get the right face based on it's role
filterFunc = x => sidesFilter(x) && roleFilter(x);
}
if (ApplyOp)
{
var o1 = new OpParams(op1Amount1, op1Amount2, op1Facesel);
poly = poly.ApplyOp(op1, o1);
var o2 = new OpParams(op2Amount1, op2Amount2, 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);
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()
{
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()
{
switch (ShapeType)
{
case ShapeTypes.Wythoff:
var wythoff = new WythoffPoly(PolyType, PrismP, PrismQ);
wythoff.BuildFaces();
preOpPoly = new ConwayPoly(wythoff);
break;
case ShapeTypes.Johnson:
preOpPoly = JohnsonPoly.Build(JohnsonPolyType, PrismP);
break;
case ShapeTypes.Grid:
preOpPoly = Grids.Grids.MakeGrid(GridType, GridShape, PrismP, PrismQ);
break;
}
// var animValue1 = Mathf.PerlinNoise(Time.time / AnimateAmountRate, 0) * Mathf.PerlinNoise(Time.time / AnimateAmountRate * 3.1f, Time.time);
var animValue1 = 1;
if (ApplyOp)
{
var o1 = new OpParams {
valueA = op1Amount1 * animValue1, valueB = op1Amount2, facesel = op1Facesel
};
preOpPoly = preOpPoly.ApplyOp(op1, o1);
}
if (PreCanonicalize)
{
preOpPoly = preOpPoly.Canonicalize(0.01, 0.01);
}
var postOpPoly = preOpPoly.Transform(Position, Rotation, Scale);
var animValue2 = Mathf.Sin(Time.time / AnimateAmountRate);
// var animValue2 = Mathf.PerlinNoise(Time.time / AnimateAmountRate, 0) * Mathf.PerlinNoise(Time.time / AnimateAmountRate * .3f, 10) -.5f;
var _amount = AnimateAmount > 0 ? animValue2 * AnimateAmount : Amount;
var o = new OpParams(_amount, NormalBlend, Facesel);
postOpPoly = postOpPoly.Segment(o);
if (Canonicalize)
{
postOpPoly = postOpPoly.Canonicalize(0.01, 0.01);
}
if (ApplyOp)
{
var o2 = new OpParams {
valueA = op2Amount1, valueB = op2Amount2, facesel = op2Facesel
};
postOpPoly = postOpPoly.ApplyOp(op2, o2);
}
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(postOpPoly, false, null, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
public void Generate()
{
switch (ShapeType)
{
case ShapeTypes.Wythoff:
var wythoff = new WythoffPoly(PolyType, PrismP, PrismQ);
wythoff.BuildFaces();
poly = new ConwayPoly(wythoff);
break;
case ShapeTypes.Johnson:
poly = JohnsonPoly.Build(JohnsonPolyType, PrismP);
break;
case ShapeTypes.Grid:
poly = Grids.Grids.MakeGrid(GridType, GridShape, PrismP, PrismQ);
break;
}
if (ApplyOp)
{
var o1 = new OpParams {
valueA = op1Amount1, valueB = op1Amount2, facesel = op1Facesel
};
poly = poly.ApplyOp(op1, o1);
}
if (PreCanonicalize)
{
poly = poly.Canonicalize(0.01, 0.01);
}
if (Canonicalize)
{
poly = poly.Canonicalize(0.01, 0.01);
}
if (ApplyOp)
{
var o2 = new OpParams {
valueA = op2Amount1, valueB = op2Amount2, facesel = op2Facesel
};
poly = poly.ApplyOp(op2, o2);
var o3 = new OpParams {
valueA = op3Amount1, valueB = op3Amount2, facesel = op3Facesel
};
poly = poly.ApplyOp(op3, o3);
}
var points = poly.ListVerticesByPoints().ToList();
if (JitterAmount > 0)
{
for (int i = 0; i < points.Count(); i++)
{
var point = points[i];
points[i] = new Vector3(
point.x + Random.value * JitterAmount,
point.y + Random.value * JitterAmount,
point.z + Random.value * JitterAmount
);
}
}
var faceIndices = poly.ListFacesByVertexIndices();
// This whole mess is because I can't find a way to regenerate
// a probuilder mesh and therefore have to continually create/destroy gameobjects
// (which is a mess in edit mode)
// If anyone can explain how to simply take an existing probuilder object clear it
// and pass in a list of Vector3's and lists of ordered indexes for faces
// then please do.
if (pbmesh != null && pbmesh.gameObject != null)
{
if (Application.isPlaying)
{
Destroy(pbmesh.gameObject);
}
else
{
var go = pbmesh.gameObject;
UnityEditor.EditorApplication.delayCall += () =>
{
DestroyImmediate(go);
};
}
}
var colors = Enumerable.Range(0, 8).Select(x => Colors.Evaluate(((x / 8f) * ColorRange + ColorOffset) % 1)).ToArray();
pbmesh = ProBuilderMesh.Create(points, new List <Face>());
var faces = new List <PBFace>();
for (var i = 0; i < faceIndices.Length; i++)
{
var face = faceIndices[i];
var result = AppendElements.CreatePolygon(pbmesh, face, false);
if (result != null)
{
pbmesh.SetFaceColor(result, colors[(int)poly.FaceRoles[i]]);
faces.Add(result);
}
}
if (faces.Count < 1 || pbmesh == null)
{
return;
}
pbmesh.SetMaterial(faces, material);
pbmesh.ToMesh();
pbmesh.Refresh();
}
public static ConwayPoly ApplyOp(ConwayPoly conway, ConwayOperator op)
{
switch (op.opType)
{
case Ops.Identity:
break;
case Ops.Kis:
conway = conway.Kis(op.amount, op.faceSelections, op.randomize);
break;
case Ops.Dual:
conway = conway.Dual();
break;
case Ops.Ambo:
conway = conway.Ambo();
break;
case Ops.Zip:
conway = conway.Kis(op.amount, op.faceSelections, op.randomize);
conway = conway.Dual();
break;
case Ops.Expand:
conway = conway.Ambo();
conway = conway.Ambo();
break;
case Ops.Bevel:
conway = conway.Ambo();
conway = conway.Dual();
conway = conway.Kis(op.amount, op.faceSelections, op.randomize);
conway = conway.Dual();
break;
case Ops.Join:
// conway = conway.Join(op.amount); // Not currently used as it results in non-coplanar faces
conway = conway.Ambo();
conway = conway.Dual();
break;
case Ops.Needle:
conway = conway.Dual();
conway = conway.Kis(op.amount, op.faceSelections, op.randomize);
break;
case Ops.Ortho:
conway = conway.Ambo();
conway = conway.Ambo();
conway = conway.Dual();
break;
case Ops.Meta:
conway = conway.Ambo();
conway = conway.Dual();
conway = conway.Kis(op.amount, op.faceSelections, op.randomize);
break;
case Ops.Truncate:
conway = conway.Dual();
conway = conway.Kis(op.amount, op.faceSelections, op.randomize);
conway = conway.Dual();
break;
case Ops.Gyro:
conway = conway.Gyro(op.amount);
break;
case Ops.Snub:
conway = conway.Gyro(op.amount);
conway = conway.Dual();
break;
case Ops.Exalt:
conway = conway.Dual();
conway = conway.Kis(op.amount, op.faceSelections, op.randomize);
conway = conway.Dual();
conway = conway.Kis(op.amount, op.faceSelections, op.randomize);
break;
case Ops.Yank:
conway = conway.Kis(op.amount, op.faceSelections, op.randomize);
conway = conway.Dual();
conway = conway.Kis(op.amount, op.faceSelections, op.randomize);
conway = conway.Dual();
break;
case Ops.Subdivide:
conway = conway.Subdivide();
break;
case Ops.Loft:
conway = conway.Loft(op.amount, op.faceSelections);
break;
case Ops.Quinto:
conway = conway.Quinto(op.amount);
break;
case Ops.JoinedLace:
conway = conway.JoinedLace(op.amount);
break;
case Ops.Lace:
conway = conway.Lace(op.amount, op.faceSelections);
break;
case Ops.Stake:
conway = conway.Stake(op.amount, op.faceSelections);
break;
// case Ops.Medial:
// conway = conway.Medial((int)op.amount);
// break;
// case Ops.EdgeMedial:
// conway = conway.EdgeMedial((int)op.amount);
// break;
// case Ops.JoinedMedial:
// conway = conway.JoinedMedial();
// break;
case Ops.Propeller:
conway = conway.Propeller(op.amount);
break;
case Ops.Whirl:
conway = conway.Whirl(op.amount);
break;
case Ops.Volute:
conway = conway.Volute(op.amount);
break;
case Ops.Extrude:
// Split faces
conway = conway.FaceScale(0, ConwayPoly.FaceSelections.All, false);
conway = conway.Extrude(op.amount, false, op.randomize);
break;
case Ops.VertexScale:
conway = conway.VertexScale(op.amount, op.faceSelections, op.randomize);
break;
case Ops.FaceOffset:
// Split faces
var origRoles = conway.FaceRoles;
conway = conway.FaceScale(0, ConwayPoly.FaceSelections.All, false);
conway.FaceRoles = origRoles;
conway = conway.Offset(op.amount, op.faceSelections, op.randomize);
break;
case Ops.FaceScale:
conway = conway.FaceScale(op.amount, op.faceSelections, op.randomize);
break;
case Ops.FaceRotate:
conway = conway.FaceRotate(op.amount, op.faceSelections, 0, op.randomize);
break;
// case Ops.Chamfer:
// conway = conway.Chamfer();
// break;
// case Ops.Ribbon:
// conway = conway.Ribbon(op.amount, false, 0.1f);
// break;
// case Ops.FaceTranslate:
// conway = conway.FaceTranslate(op.amount, op.faceSelections);
// break;
// case Ops.FaceRotateX:
// conway = conway.FaceRotate(op.amount, op.faceSelections, 1);
// break;
// case Ops.FaceRotateY:
// conway = conway.FaceRotate(op.amount, op.faceSelections, 2);
// break;
case Ops.FaceRemove:
conway = conway.FaceRemove(op.faceSelections, false);
break;
case Ops.FaceKeep:
conway = conway.FaceRemove(op.faceSelections, true);
break;
case Ops.AddDual:
conway = conway.AddDual(op.amount);
break;
case Ops.Canonicalize:
conway = conway.Canonicalize(op.amount, op.amount);
break;
case Ops.CanonicalizeI:
conway = conway.Canonicalize((int)op.amount, (int)op.amount);
break;
}
return(conway);
}
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;
}
