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()
{
poly = Grids.Grids.MakeGrid(GridType, GridShape, width, depth);
poly.ClearTags();
poly.TagFaces("#FFFFFF", filter: whiteFilter);
poly.TagFaces("#000000", filter: blackFilter);
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);
var o3 = new OpParams {
valueA = op3Amount1, valueB = op3Amount2, facesel = op3Facesel
};
poly = poly.ApplyOp(op3, o3);
}
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(poly, false, meshColors, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
public void Generate()
{
var poly = JohnsonPoly.BuildOther(otherPolyType, sides, segments);
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.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 = 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 colorMethod = ColorBySides ? PolyHydraEnums.ColorMethods.BySides : PolyHydraEnums.ColorMethods.ByRole;
var poly = Grids.Grids.MakeGrid(GridType, GridShape, width, depth);
poly = poly.FaceRemove(new OpParams {
facesel = removeSelection
});
for (int i = 0; i < repeats; i++)
{
float angle = Mathf.Sin(((float)i / repeats) * frequency * Mathf.PI) * amplitude;
poly = poly.ExtendBoundaries(new OpParams {
valueA = amount, valueB = angle
});
}
if (ApplyOp)
{
var o = new OpParams {
valueA = opAmount, valueB = op2Amount, facesel = facesel
};
poly = poly.ApplyOp(op, o);
}
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(poly, false, null, colorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
/// <summary>
/// 更新後端作業選項
/// </summary>
public bool UpdateOperaionData(OpParams param)
{
bool result = false;
using (EmployeeAuthorityDataAccess empAuthDao = new EmployeeAuthorityDataAccess())
{
Operations entity = empAuthDao.GetEmptyEntity <Operations>(new OperationsRequiredPropValues()
{
OpId = param.OpId,
IsNewWindow = !param.IsNewWindow,
IsHideSelf = !param.IsHideSelf
});
entity.OpId = param.OpId;
entity.OpSubject = param.OpSubject;
entity.LinkUrl = param.LinkUrl;
entity.IsNewWindow = param.IsNewWindow;
entity.IconImageFile = param.IconImageFile;
entity.SortNo = param.SortNo;
entity.IsHideSelf = param.IsHideSelf;
entity.CommonClass = param.CommonClass;
entity.EnglishSubject = param.EnglishSubject;
entity.MdfAccount = param.PostAccount;
entity.MdfDate = DateTime.Now;
result = empAuthDao.Update();
dbErrMsg = empAuthDao.GetErrMsg();
}
return(result);
}
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()
{
var poly = Grids.Grids.MakeGrid(GridType, GridShape, width, depth);
if (ApplyOp)
{
var o1 = new OpParams {
valueA = op1Amount1 * Mathf.Abs(op1Animate ? Mathf.Sin(Time.time) : 1), valueB = op1Amount2, facesel = op1Facesel
};
poly = poly.ApplyOp(op1, o1);
}
poly = poly.LoftAlongProfile(domeFaceSel, DomeHeight, DomeSegments, easingType);
if (ApplyOp)
{
var o2 = new OpParams {
valueA = op2Amount1 * Mathf.Abs(op2Animate ? Mathf.Cos(Time.time * .6f) : 1), valueB = op2Amount2, facesel = op2Facesel
};
poly = poly.ApplyOp(op2, o2);
}
poly = poly.Transform(Position, Rotation, Scale);
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(poly, false, null, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
protected void rptSubitems_ItemCommand(object source, RepeaterCommandEventArgs e)
{
bool result = false;
int opId = 0;
switch (e.CommandName)
{
case "Del":
string[] args = e.CommandArgument.ToString().Split(',');
opId = Convert.ToInt32(args[0]);
string subject = args[1];
OpParams param = new OpParams()
{
OpId = opId
};
result = empAuth.DeleteOperationData(param);
//新增後端操作記錄
empAuth.InsertBackEndLogData(new BackEndLogData()
{
EmpAccount = c.GetEmpAccount(),
Description = string.Format("．刪除作業選項/Delete operation ．代碼/id[{0}] 標題/subject[{1}] 結果/result[{2}]", opId, subject, result),
IP = c.GetClientIP()
});
// log to file
c.LoggerOfUI.InfoFormat("{0} deletes {1}, result: {2}", c.GetEmpAccount(), "op-" + opId.ToString() + "-" + subject, result);
if (!result)
{
if (param.IsThereSubitemOfOp)
{
Master.ShowErrorMsg(Resources.Lang.ErrMsg_ThereIsSubitemofOp);
}
else
{
Master.ShowErrorMsg(Resources.Lang.ErrMsg_DeleteOperationFailed);
}
}
break;
case "MoveUp":
opId = Convert.ToInt32(e.CommandArgument);
result = empAuth.DecreaseOperationSortNo(opId, c.GetEmpAccount());
break;
case "MoveDown":
opId = Convert.ToInt32(e.CommandArgument);
result = empAuth.IncreaseOperationSortNo(opId, c.GetEmpAccount());
break;
}
if (result)
{
DisplaySubitems();
Master.RefreshOpMenu();
}
}
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 FindOpMatches(ConwayPoly sourcePoly, string sourcePolyName, ConwayPoly targetPoly, string targetPolyName)
{
// int v = poly.Vertices.Count;
// int e = poly.EdgeCount;
// int f = poly.Faces.Count;
//
// // Compare predicted and actual v,e,f
// Debug.Log($"{v} {e} {f} = {PolyHydraEnums.CalcVef(poly, op2)}");
// Loops through all Conway ops and records which ones
// Result in matching Vertex, Edge and Face counts
var matches = new Dictionary <int[], List <Ops> >();
// For all ops use:
// var opCount = ((Ops[]) Enum.GetValues(typeof(Ops))).Length;
// Just the conway ops
var opCount = 34;
var targetFaceTypes = targetPoly.GetFaceCountsByType();
for (var i = 1; i < 34; i++)
{
var o = new OpParams {
valueA = 0.2f, valueB = 0.2f, facesel = FaceSelections.All
};
var newPoly = sourcePoly.ApplyOp((Ops)i, o);
var sourceFaceTypes = newPoly.GetFaceCountsByType();
if (!sourceFaceTypes.SequenceEqual(targetFaceTypes))
{
continue;
}
if (!matches.ContainsKey(sourceFaceTypes))
{
matches[sourceFaceTypes] = new List <Ops>();
}
matches[sourceFaceTypes].Add((Ops)i);
}
if (matches.Count < 1)
{
return;
}
Debug.Log($"Matching {sourcePolyName} and {targetPolyName}: {matches.Count} matches");
foreach (var match in matches)
{
// if (match.Value.Count < 2) continue;
var lst = string.Join(",", match.Value);
Debug.Log($"{lst}");
}
}
public static ConwayPoly ApplyOp(ConwayPoly conway, ref ConwayPoly stash, ConwayOperator op)
{
float amount = op.amount;
var opParams = new OpParams
{
valueA = amount,
valueB = op.amount2,
randomize = op.randomize,
facesel = op.faceSelections
};
conway = conway.ApplyOp(op.opType, opParams);
return(conway);
}
/// <summary>
/// 刪除後端作業選項
/// </summary>
public bool DeleteOperationData(OpParams param)
{
bool result = false;
using (EmployeeAuthorityDataAccess empAuthDao = new EmployeeAuthorityDataAccess())
{
result = empAuthDao.DeleteOperationData(param.OpId);
dbErrMsg = empAuthDao.GetErrMsg();
if (!result && empAuthDao.GetSqlErrNumber() == 50000 && empAuthDao.GetSqlErrState() == 2)
{
param.IsThereSubitemOfOp = true;
}
}
return(result);
}
public void Generate()
{
switch (ShapeType)
{
case ShapeTypes.Wythoff:
var wythoff1 = new WythoffPoly(PolyType1, P1, Q1);
wythoff1.BuildFaces();
poly1 = new ConwayPoly(wythoff1);
var wythoff2 = new WythoffPoly(PolyType2, P2, Q2);
wythoff2.BuildFaces();
poly2 = new ConwayPoly(wythoff2);
break;
case ShapeTypes.Johnson:
poly1 = JohnsonPoly.Build(JohnsonPolyType1, P1);
poly2 = JohnsonPoly.Build(JohnsonPolyType2, P2);
break;
case ShapeTypes.Grid:
poly1 = Grids.Grids.MakeGrid(GridType, GridShape1, P1, Q1, false);
poly2 = Grids.Grids.MakeGrid(GridType, GridShape2, P2, Q2, false);
break;
}
var o1 = new OpParams {
valueA = op1Amount1, valueB = op1Amount2, facesel = op1Facesel
};
poly1 = poly1.ApplyOp(op1, o1);
var o2 = new OpParams {
valueA = op2Amount1, valueB = op2Amount2, facesel = op2Facesel
};
poly2 = poly2.ApplyOp(op2, o2);
poly1.Morph(poly2, morphAmount, reverseVertexOrder);
// Final Mesh
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(poly1, false, null, ColorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
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;
}
/// <summary>
/// 新增後端作業選項
/// </summary>
public bool InsertOperationData(OpParams param)
{
InsertResult insResult = new InsertResult()
{
IsSuccess = false
};
using (EmployeeAuthorityDataAccess empAuthDao = new EmployeeAuthorityDataAccess())
{
int?objParentId = null;
if (param.ParentId != 0)
{
objParentId = param.ParentId;
}
Operations entity = new Operations()
{
ParentId = objParentId,
OpSubject = param.OpSubject,
LinkUrl = param.LinkUrl,
IsNewWindow = param.IsNewWindow,
IconImageFile = param.IconImageFile,
SortNo = param.SortNo,
IsHideSelf = param.IsHideSelf,
CommonClass = param.CommonClass,
EnglishSubject = param.EnglishSubject,
PostAccount = param.PostAccount,
PostDate = DateTime.Now
};
insResult = empAuthDao.Insert <Operations>(entity);
dbErrMsg = empAuthDao.GetErrMsg();
if (insResult.IsSuccess)
{
param.OpId = (int)insResult.NewId;
}
}
return(insResult.IsSuccess);
}
public void Generate()
{
var poly = Grids.Grids.MakeGrid(GridType, GridShape, width, depth);
var colorMethod = ColorBySides ? PolyHydraEnums.ColorMethods.BySides : PolyHydraEnums.ColorMethods.ByRole;
if (ApplyOp)
{
var o = new OpParams {
valueA = opAmount, valueB = op2Amount, facesel = facesel
};
poly = poly.ApplyOp(op, o);
}
var bitsJoined = Enumerable.Repeat("".PadRight(width, '1'), depth).ToArray();
for (var i = 0; i < bits.Split(new[] { Environment.NewLine }, StringSplitOptions.None).Length; i++)
{
var line = bits.Split(new[] { Environment.NewLine }, StringSplitOptions.None)[i];
bitsJoined[i] = line.PadRight(width, '0').Substring(0, width);
}
Func <FilterParams, bool> filterFunc = f =>
{
int x = Mathf.FloorToInt(f.index / width);
int y = f.index % width;
Debug.Log($"{f.index} {x}x{y}");
return(!(x < bitsJoined[y].Length && bitsJoined[y].Substring(x, 1) == "1"));
};
poly = poly.FaceRemove(new OpParams {
filterFunc = filterFunc
});
poly = poly.Shell(new OpParams {
valueA = extrusionAmount
});
var mesh = PolyMeshBuilder.BuildMeshFromConwayPoly(poly, false, null, colorMethod);
GetComponent <MeshFilter>().mesh = mesh;
}
public Mesh MakeMorphTarget(int morphIndex, float amount)
{
var morphedPoly = poly.Duplicate();
for (var i = 0; i < Morphs.Count; i++)
{
float a = i == morphIndex ? amount : 0; // Zero amount for ops other than the requested one
var morphOp = Morphs[i];
var morphParams = new OpParams(
Mathf.Lerp(morphOp.opAmount1Start, morphOp.opAmount1End, a),
Mathf.Lerp(morphOp.opAmount2Start, morphOp.opAmount2End, a),
morphOp.opFacesel
);
morphedPoly = morphedPoly.ApplyOp(morphOp.op, morphParams);
morphedPoly = morphedPoly.ApplyOp(PostMorph.op, new OpParams(PostMorph.opAmount1, PostMorph.opAmount2, PostMorph.opFacesel));
}
var result = PolyMeshBuilder.BuildMeshFromConwayPoly(morphedPoly, false, null, ColorMethod);
// result.RecalculateNormals();
// result.RecalculateTangents();
return(result);
}
public void Generate()
{
var colorMethod = ColorBySides ? PolyHydraEnums.ColorMethods.BySides : PolyHydraEnums.ColorMethods.ByRole;
var poly = Grids.Grids.MakeGrid(GridType, GridShape, width, depth);
poly = poly.FaceRemove(new OpParams {
facesel = removeSelection
});
poly = poly.ExtendBoundaries(new OpParams {
valueA = amount, valueB = angle
});
if (ApplyOp)
{
var o = new OpParams {
valueA = opAmount, valueB = op2Amount, facesel = facesel
};
poly = poly.ApplyOp(op, o);
}
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;
}
protected void btnSave_Click(object sender, EventArgs e)
{
if (!IsValid)
{
return;
}
try
{
txtOpSubject.Text = txtOpSubject.Text.Trim();
txtEnglishSubject.Text = txtEnglishSubject.Text.Trim();
txtIconImageFile.Text = txtIconImageFile.Text.Trim();
txtLinkUrl.Text = txtLinkUrl.Text.Trim();
txtCommonClass.Text = txtCommonClass.Text.Trim();
OpParams param = new OpParams()
{
SortNo = Convert.ToInt32(txtSortNo.Text),
OpSubject = txtOpSubject.Text,
EnglishSubject = txtEnglishSubject.Text,
IconImageFile = txtIconImageFile.Text,
LinkUrl = txtLinkUrl.Text,
IsNewWindow = chkIsNewWindow.Checked,
IsHideSelf = chkIsHideSelf.Checked,
CommonClass = txtCommonClass.Text,
PostAccount = c.GetEmpAccount()
};
bool result = false;
if (c.qsAct == ConfigFormAction.add)
{
param.ParentId = c.qsId;
result = empAuth.InsertOperationData(param);
if (!result)
{
Master.ShowErrorMsg(Resources.Lang.ErrMsg_AddFailed);
}
}
else if (c.qsAct == ConfigFormAction.edit)
{
param.OpId = c.qsId;
result = empAuth.UpdateOperaionData(param);
if (!result)
{
Master.ShowErrorMsg(Resources.Lang.ErrMsg_UpdateFailed);
}
}
if (result)
{
ClientScript.RegisterStartupScript(this.GetType(), "", StringUtility.GetNoticeOpenerJs("Config"), true);
}
//新增後端操作記錄
empAuth.InsertBackEndLogData(new BackEndLogData()
{
EmpAccount = c.GetEmpAccount(),
Description = string.Format("．{0} ．儲存後端作業選項/Save operation[{1}][{2}] OpId[{3}] 結果/result[{4}]", Title, txtOpSubject.Text, txtEnglishSubject.Text, param.OpId, result),
IP = c.GetClientIP()
});
}
catch (Exception ex)
{
c.LoggerOfUI.Error("", ex);
Master.ShowErrorMsg(ex.Message);
}
}
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 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 multigrid = new MultiGrid(Divisions, Dimensions, Offset, MinDistance, MaxDistance, colorRatio, colorIndex, colorIntersect);
(poly, shapes, colors) = multigrid.Build(SharedVertices, randomize);
if (shapes.Count == 0)
{
return;
}
if (ColorMethod == PolyHydraEnums.ColorMethods.ByTags)
{
float colorMin = colors.Min();
float colorMax = colors.Max();
for (var faceIndex = 0; faceIndex < poly.Faces.Count; faceIndex++)
{
var face = poly.Faces[faceIndex];
var colorIndex = colors[faceIndex];
float colorValue;
switch (ColorFunction)
{
case ColorFunctions.Mod:
colorValue = colorIndex % 1;
break;
case ColorFunctions.ActualMod:
colorValue = PolyUtils.ActualMod(colorIndex, 1);
break;
case ColorFunctions.Normalized:
colorValue = Mathf.InverseLerp(colorMin, colorMax, colorIndex);
break;
case ColorFunctions.Abs:
colorValue = Mathf.Abs(colorIndex);
break;
default:
colorValue = colorIndex;
break;
}
string colorString = ColorUtility.ToHtmlStringRGB(ColorGradient.Evaluate(colorValue));
var tag = new Tuple <string, ConwayPoly.TagType>(
$"#{colorString}",
TagType);
poly.FaceTags[faceIndex].Add(tag);
}
}
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);
var o3 = new OpParams {
valueA = op3Amount1, valueB = op3Amount2, facesel = op3Facesel
};
poly = poly.ApplyOp(op3, o3);
}
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 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, 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;
case ShapeTypes.Other:
poly = JohnsonPoly.BuildOther(OtherPolyType, PrismP, PrismQ);
break;
}
if (applyPreOp)
{
var preOpParams = new OpParams {
valueA = preOpAmount1, valueB = preOpAmount2, facesel = preOpFacesel
};
for (int i = 0; i < preOpIterations; i++)
{
poly = poly.ApplyOp(preOp, preOpParams);
}
}
OpParams amount1Func = null;
switch (Equation)
{
case Equations.LinearX:
amount1Func = new OpParams
{
funcA = x => offset1 + Mathf.Sin((x.poly.Faces[x.index].Centroid.x * frequency1 + phase1 - (Time.time * animationSpeed1))) * amplitude1,
funcB = x => offset2 + Mathf.Sin((x.poly.Faces[x.index].Centroid.x * frequency2 + phase2 - (Time.time * animationSpeed2))) * amplitude2
};
break;
case Equations.LinearY:
amount1Func = new OpParams
{
funcA = x => offset1 + Mathf.Sin((x.poly.Faces[x.index].Centroid.y * frequency1 + phase1 - (Time.time * animationSpeed1))) * amplitude1,
funcB = x => offset2 + Mathf.Sin((x.poly.Faces[x.index].Centroid.y * frequency2 + phase2 - (Time.time * animationSpeed2))) * amplitude2
};
break;
case Equations.LinearZ:
amount1Func = new OpParams
{
funcA = x => offset1 + Mathf.Sin((x.poly.Faces[x.index].Centroid.z * frequency1 + phase1 - (Time.time * animationSpeed1))) * amplitude1,
funcB = x => offset2 + Mathf.Sin((x.poly.Faces[x.index].Centroid.z * frequency2 + phase2 - (Time.time * animationSpeed2))) * amplitude2
};
break;
case Equations.Radial:
amount1Func = new OpParams
{
funcA = x => offset1 + Mathf.Sin((x.poly.Faces[x.index].Centroid.magnitude * frequency1 + phase1 - (Time.time * animationSpeed1))) * amplitude1,
funcB = x => offset2 + Mathf.Sin((x.poly.Faces[x.index].Centroid.magnitude * frequency2 + phase2 - (Time.time * animationSpeed2))) * amplitude2
};
break;
case Equations.Perlin:
amount1Func = new OpParams
{
funcA = x => offset1 + Mathf.PerlinNoise(x.poly.Faces[x.index].Centroid.x * frequency1 + phase1 - (Time.time * animationSpeed1), x.poly.Faces[x.index].Centroid.z * frequency1 + phase1 - (Time.time * animationSpeed1)) * amplitude1,
funcB = x => offset2 + Mathf.PerlinNoise(x.poly.Faces[x.index].Centroid.x * frequency2 + phase2 - (Time.time * animationSpeed2), x.poly.Faces[x.index].Centroid.z * frequency2 + phase2 - Time.time) * amplitude2,
};
break;
}
poly = poly.ApplyOp(op, amount1Func);
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()
{
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;
}
