public override void OnInspectorGUI()
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)target;
MegaShapeLoft loft = layer.GetComponent <MegaShapeLoft>();
if (loft && loft.undo)
{
undoManager.CheckUndo();
}
DisplayGUI();
CommonGUI();
if (GUI.changed)
{
if (loft)
{
loft.rebuild = true;
EditorUtility.SetDirty(loft);
}
if (layer)
{
EditorUtility.SetDirty(layer);
}
}
if (loft && loft.undo)
{
undoManager.CheckDirty();
}
}
public void Position(GameObject gobj, float alpha, float crossalpha, float yrot, float scl)
{
if (surfaceLoft && surfaceLayer >= 0)
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
Vector3 at = Vector3.zero;
Vector3 up = Vector3.zero;
Vector3 right = Vector3.zero;
Vector3 fwd = Vector3.zero;
Vector3 p = layer.GetPosAndFrame(surfaceLoft, crossalpha, alpha, tangent, out at, out up, out right, out fwd);
p += up * offset;
Quaternion rot = Quaternion.LookRotation(fwd, up);
Quaternion rot1 = Quaternion.Euler(uprot);
rot = Quaternion.Lerp(rot, rot1, upright);
Vector3 lrot = rotate;
lrot.y += yrot;
gobj.transform.rotation = rot * Quaternion.Euler(lrot);
gobj.transform.position = layer.transform.TransformPoint(p);
gobj.transform.localScale = new Vector3(scl, scl, scl);
}
}
public Vector3 GetPoint(float dist, float crossa)
{
Vector3 retval = Vector3.zero;
if (surfaceLoft && surfaceLayer >= 0)
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
Vector3 at = Vector3.zero;
Vector3 up = Vector3.zero;
Vector3 right = Vector3.zero;
Vector3 fwd = Vector3.zero;
float a = dist / layer.layerPath.splines[layer.curve].length;
Vector3 p = layer.GetPosAndFrame(surfaceLoft, crossa, a, tangent, out at, out up, out right, out fwd);
p += up * offset;
p = layer.transform.TransformPoint(p);
retval = transform.worldToLocalMatrix.MultiplyPoint3x4(p);
}
return(retval);
}
public Vector3 GetPoint(float dist, float crossa)
{
Vector3 retval = Vector3.zero;
if (surfaceLoft && surfaceLayer >= 0)
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
float a = dist / layer.layerPath.splines[layer.curve].length;
Vector3 p = layer.transform.TransformPoint(layer.SampleSplines(surfaceLoft, crossalpha, a));
Vector3 pr = layer.transform.TransformPoint(layer.SampleSplines(surfaceLoft, crossalpha + tangent, a));
Vector3 pf = layer.transform.TransformPoint(layer.SampleSplines(surfaceLoft, crossalpha, a + tangent));
Vector3 fwd = (pf - p).normalized;
Vector3 right = (pr - p).normalized;
Vector3 up = Vector3.Cross(fwd, right); //.normalized;
p += up * offset;
p = layer.transform.TransformPoint(p);
retval = transform.worldToLocalMatrix.MultiplyPoint3x4(p);
}
return(retval);
}
void DoUpdate()
{
if (surfaceLoft && surfaceLayer >= 0 && surfaceLayer < surfaceLoft.Layers.Length)
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
if (animate)
{
distance += speed * Time.deltaTime;
distance = Mathf.Repeat(distance, layer.layerPath.splines[layer.curve].length);
alpha = distance / layer.layerPath.splines[layer.curve].length;
}
if (mode == MegaWalkMode.Distance)
{
alpha = distance / layer.layerPath.splines[layer.curve].length;
}
else
{
distance = alpha * layer.layerPath.splines[layer.curve].length;
}
//float tw = surfaceLoft.Layers[surfaceLayer].layerPath.splines[0].GetTwist(alpha);
Vector3 p = layer.transform.TransformPoint(layer.SampleSplines(surfaceLoft, crossalpha, alpha));
Vector3 pr = layer.transform.TransformPoint(layer.SampleSplines(surfaceLoft, crossalpha + tangent, alpha));
Vector3 pf = layer.transform.TransformPoint(layer.SampleSplines(surfaceLoft, crossalpha, alpha + tangent));
Vector3 fwd = (pf - p).normalized;
Vector3 right = (pr - p).normalized;
Vector3 up = Vector3.Cross(fwd, right); //.normalized;
if (useRaycast)
{
RaycastPosition(p, pf, fwd, up);
}
else
{
p += up * offset;
Quaternion rot = Quaternion.LookRotation(fwd, up);
Quaternion rot1 = Quaternion.Euler(uprot);
rot = Quaternion.Lerp(rot, rot1, upright);
Vector3 rt = rotate;
//rt.x -= tw;
Quaternion locrot = Quaternion.Euler(rt); //otate);
rot = rot * locrot;
transform.rotation = rot; // * locrot;
transform.position = p; //layer.transform.TransformPoint(p);
}
}
}
public Vector3 GetPos(float a, float ca)
{
if (surfaceLoft && surfaceLayer >= 0 && surfaceLayer < surfaceLoft.Layers.Length)
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
return(layer.SampleSplines(surfaceLoft, ca, a));
}
return(Vector3.zero);
}
public Vector3 GetPosDist(float dist, float ca)
{
if (surfaceLoft && surfaceLayer >= 0 && surfaceLayer < surfaceLoft.Layers.Length)
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
float a = dist / layer.layerPath.splines[layer.curve].length;
return(layer.SampleSplines(surfaceLoft, ca, a));
}
return(Vector3.zero);
}
void BuildCollider()
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
colobj = new GameObject();
mcol = colobj.AddComponent <MeshCollider>();
mesh = new Mesh();
int steps = (int)(layer.layerPath.splines[layer.curve].length / dist);
int[] tris = new int[steps * 6];
int index = 0;
index = 0;
for (int i = 0; i < steps; i++)
{
tris[index + 0] = (i * 2) + 0;
tris[index + 1] = (i * 2) + 3;
tris[index + 2] = (i * 2) + 1;
tris[index + 3] = (i * 2) + 0;
tris[index + 4] = (i * 2) + 2;
tris[index + 5] = (i * 2) + 3;
index += 6;
}
mesh.Clear();
mesh.subMeshCount = 1;
mesh.vertices = verts;
mesh.uv = uvs;
mesh.triangles = tris;
mesh.RecalculateNormals();
if (mcol != null)
{
mcol.sharedMesh = null;
mcol.sharedMesh = mesh;
}
}
public void DisplayGUI()
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)target;
SetLimits(layer.gameObject);
MegaShapeLoftEditor.PushCols();
GUI.color = Color.white;
GUI.backgroundColor = layer.paramcol;
GUI.contentColor = Color.white;
EditorGUILayout.BeginVertical("TextArea");
if (GUILayout.Button("Reset All Curves"))
{
layer.InitCurves();
GUI.changed = true;
EditorUtility.SetDirty(target);
}
layer.LayerName = EditorGUILayout.TextField(MegaToolTip.LayerName, layer.LayerName);
layer.LayerEnabled = EditorGUILayout.Toggle(MegaToolTip.Enabled, layer.LayerEnabled);
layer.paramcol = EditorGUILayout.ColorField(MegaToolTip.ParamCol, layer.paramcol);
if (layer.LayerEnabled)
{
layer.Lock = EditorGUILayout.Toggle(MegaToolTip.Lock, layer.Lock);
if (!layer.Lock)
{
layer.material = (Material)EditorGUILayout.ObjectField(MegaToolTip.Material, layer.material, typeof(Material), true);
layer.layerPath = (MegaShape)EditorGUILayout.ObjectField(MegaToolTip.Path, layer.layerPath, typeof(MegaShape), true);
if (layer.layerPath && layer.layerPath.splines != null)
{
if (layer.layerPath.splines.Count > 1)
{
layer.curve = EditorGUILayout.IntSlider(MegaToolTip.Curve, layer.curve, 0, layer.layerPath.splines.Count - 1);
}
if (layer.curve < 0)
{
layer.curve = 0;
}
if (layer.curve > layer.layerPath.splines.Count - 1)
{
layer.curve = layer.layerPath.splines.Count - 1;
}
}
layer.pathStart = EditorGUILayout.Slider(MegaToolTip.Start, layer.pathStart, sl, sh);
layer.pathLength = EditorGUILayout.Slider(MegaToolTip.Length, layer.pathLength, ll, lh);
layer.pathDist = EditorGUILayout.Slider(MegaToolTip.Dist, layer.pathDist, dl, dh);
EditorGUILayout.BeginVertical("Box");
layer.offset = EditorGUILayout.Vector3Field("Offset", layer.offset);
layer.useOffsetX = EditorGUILayout.BeginToggleGroup(MegaToolTip.UseOffsetX, layer.useOffsetX);
layer.offsetCrvX = EditorGUILayout.CurveField(MegaToolTip.OffsetCrvX, layer.offsetCrvX);
EditorGUILayout.EndToggleGroup();
layer.useOffsetY = EditorGUILayout.BeginToggleGroup(MegaToolTip.UseOffsetY, layer.useOffsetY);
layer.offsetCrvY = EditorGUILayout.CurveField(MegaToolTip.OffsetCrvY, layer.offsetCrvY);
EditorGUILayout.EndToggleGroup();
layer.useOffsetZ = EditorGUILayout.BeginToggleGroup(MegaToolTip.UseOffsetZ, layer.useOffsetZ);
layer.offsetCrvZ = EditorGUILayout.CurveField(MegaToolTip.OffsetCrvZ, layer.offsetCrvZ);
EditorGUILayout.EndToggleGroup();
layer.frameMethod = (MegaFrameMethod)EditorGUILayout.EnumPopup("Frame Method", layer.frameMethod);
layer.useTwistCrv = EditorGUILayout.BeginToggleGroup(MegaToolTip.UseTwist, layer.useTwistCrv);
layer.twistAmt = EditorGUILayout.FloatField(MegaToolTip.Twist, layer.twistAmt);
layer.twistCrv = EditorGUILayout.CurveField(MegaToolTip.TwistCrv, layer.twistCrv);
EditorGUILayout.EndToggleGroup();
layer.color = EditorGUILayout.ColorField("Color", layer.color);
layer.colR = EditorGUILayout.CurveField("Red", layer.colR);
layer.colG = EditorGUILayout.CurveField("Green", layer.colG);
layer.colB = EditorGUILayout.CurveField("Blue", layer.colB);
layer.colA = EditorGUILayout.CurveField("Alpha", layer.colA);
EditorGUILayout.EndVertical();
//layer.showcrossparams = EditorGUILayout.Foldout(layer.showcrossparams, MegaToolTip.CrossParams); //"Cross Params");
layer.showcrossparams = MegaFoldOut.Start("Cross Params", layer.showcrossparams, new Color(0.5f, 1.0f, 0.5f));
if (layer.showcrossparams)
{
//EditorGUILayout.BeginVertical("Box");
layer.layerSection = (MegaShape)EditorGUILayout.ObjectField(MegaToolTip.Section, layer.layerSection, typeof(MegaShape), true);
if (layer.layerSection && layer.layerSection.splines != null)
{
if (layer.layerSection.splines.Count > 1)
{
layer.crosscurve = EditorGUILayout.IntSlider(MegaToolTip.Curve, layer.crosscurve, 0, layer.layerSection.splines.Count - 1);
layer.snap = EditorGUILayout.Toggle(MegaToolTip.Snap, layer.snap);
}
if (layer.crosscurve < 0)
{
layer.crosscurve = 0;
}
if (layer.crosscurve > layer.layerSection.splines.Count - 1)
{
layer.crosscurve = layer.layerSection.splines.Count - 1;
}
}
//layer.alignCross = EditorGUILayout.Toggle("Align Cross", layer.alignCross);
layer.alignCross = EditorGUILayout.Slider("Align Cross", layer.alignCross, 0.0f, 1.0f);
layer.crossStart = EditorGUILayout.Slider(MegaToolTip.CrossStart, layer.crossStart, csl, csh);
layer.crossEnd = EditorGUILayout.Slider(MegaToolTip.CrossLength, layer.crossEnd, cll, clh);
layer.crossDist = EditorGUILayout.Slider(MegaToolTip.CrossDist, layer.crossDist, cdl, cdh); //0.025f, 1.0f);
layer.crossRot = EditorGUILayout.Vector3Field("Cross Rotate", layer.crossRot);
layer.crossScale = EditorGUILayout.Vector3Field("Cross Scale", layer.crossScale);
layer.pivot = EditorGUILayout.Vector3Field("Pivot", layer.pivot);
layer.includeknots = EditorGUILayout.Toggle(MegaToolTip.IncludeKnots, layer.includeknots);
layer.useCrossScaleCrv = EditorGUILayout.BeginToggleGroup(MegaToolTip.UseCrossScale, layer.useCrossScaleCrv);
layer.crossScaleCrv = EditorGUILayout.CurveField(MegaToolTip.CrossScaleCrv, layer.crossScaleCrv);
layer.scaleoff = EditorGUILayout.Slider(MegaToolTip.CrossOff, layer.scaleoff, -1.0f, 1.0f);
layer.sepscale = EditorGUILayout.Toggle(MegaToolTip.SeperateScale, layer.sepscale);
EditorGUILayout.EndToggleGroup();
if (layer.sepscale)
{
layer.useCrossScaleCrvY = EditorGUILayout.BeginToggleGroup(MegaToolTip.UseCrossScaleY, layer.useCrossScaleCrvY);
layer.crossScaleCrvY = EditorGUILayout.CurveField(MegaToolTip.CrossScaleCrvY, layer.crossScaleCrvY);
layer.scaleoffY = EditorGUILayout.Slider(MegaToolTip.CrossOffY, layer.scaleoffY, -1.0f, 1.0f);
EditorGUILayout.EndToggleGroup();
}
//EditorGUILayout.EndVertical();
}
MegaFoldOut.End(layer.showcrossparams);
//layer.showadvancedparams = EditorGUILayout.Foldout(layer.showadvancedparams, MegaToolTip.AdvancedParams);
layer.showadvancedparams = MegaFoldOut.Start("Advanced Params", layer.showadvancedparams, new Color(0.5f, 0.5f, 1.0f));
if (layer.showadvancedparams)
{
//layer.optimize = EditorGUILayout.Toggle("Optimize", layer.optimize);
//layer.maxdeviation = EditorGUILayout.Slider("Max Deviation", layer.maxdeviation, 0.0f, 90.0f);
layer.flip = EditorGUILayout.Toggle(MegaToolTip.Flip, layer.flip);
layer.snapTop = EditorGUILayout.BeginToggleGroup(MegaToolTip.SnapTop, layer.snapTop);
layer.Top = EditorGUILayout.FloatField(MegaToolTip.Top, layer.Top);
EditorGUILayout.EndToggleGroup();
layer.snapBottom = EditorGUILayout.BeginToggleGroup(MegaToolTip.SnapBottom, layer.snapBottom);
layer.Bottom = EditorGUILayout.FloatField(MegaToolTip.Bottom, layer.Bottom);
EditorGUILayout.EndToggleGroup();
layer.clipTop = EditorGUILayout.BeginToggleGroup(MegaToolTip.ClipTop, layer.clipTop);
layer.clipTopVal = EditorGUILayout.FloatField(MegaToolTip.ClipTopVal, layer.clipTopVal);
EditorGUILayout.EndToggleGroup();
layer.clipBottom = EditorGUILayout.BeginToggleGroup(MegaToolTip.ClipBottom, layer.clipBottom);
layer.clipBottomVal = EditorGUILayout.FloatField(MegaToolTip.ClipBottomVal, layer.clipBottomVal);
EditorGUILayout.EndToggleGroup();
}
MegaFoldOut.End(layer.showadvancedparams);
//layer.showuvparams = EditorGUILayout.Foldout(layer.showuvparams, MegaToolTip.UVParams);
layer.showuvparams = MegaFoldOut.Start("UV Params", layer.showuvparams, new Color(1.0f, 0.5f, 0.5f));
if (layer.showuvparams)
{
//EditorGUILayout.BeginVertical("Box");
MegaShapeLoftEditor.PushCols();
GUI.color = Color.white;
layer.UVOffset = EditorGUILayout.Vector2Field("UV Offset", layer.UVOffset);
layer.UVScale = EditorGUILayout.Vector2Field("UV Scale", layer.UVScale);
layer.swapuv = EditorGUILayout.Toggle(MegaToolTip.SwapUV, layer.swapuv);
layer.physuv = EditorGUILayout.Toggle(MegaToolTip.PhysicalUV, layer.physuv);
layer.uvcalcy = EditorGUILayout.Toggle("Calc Y", layer.uvcalcy);
layer.UVOrigin = (MegaLoftUVOrigin)EditorGUILayout.EnumPopup("UV origin", layer.UVOrigin);
//layer.pingpongx = EditorGUILayout.Toggle("PingPong uv X", layer.pingpongx);
//layer.pingpongy = EditorGUILayout.Toggle("PingPong uv Y", layer.pingpongy);
layer.planarMapping = EditorGUILayout.BeginToggleGroup("Planar", layer.planarMapping);
layer.planarAxis = (MegaAxis)EditorGUILayout.EnumPopup("Axis", layer.planarAxis);
//layer.planarWorld = EditorGUILayout.Toggle("World", layer.planarWorld);
layer.planarMode = (MegaPlanarMode)EditorGUILayout.EnumPopup("Mode", layer.planarMode);
bool lockWorld = EditorGUILayout.Toggle("Lock World", layer.lockWorld);
if (lockWorld != layer.lockWorld)
{
layer.lockWorld = lockWorld;
if (lockWorld)
{
layer.lockedTM = layer.transform.localToWorldMatrix;
}
}
EditorGUILayout.EndToggleGroup();
layer.sideViewUV = EditorGUILayout.BeginToggleGroup("Side View", layer.sideViewUV);
layer.sideViewAxis = (MegaAxis)EditorGUILayout.EnumPopup("Side Axis", layer.sideViewAxis);
EditorGUILayout.EndToggleGroup();
MegaShapeLoftEditor.PopCols();
//EditorGUILayout.EndVertical();
}
MegaFoldOut.End(layer.showuvparams);
//layer.showCapParams = EditorGUILayout.Foldout(layer.showCapParams, MegaToolTip.CapParams);
layer.showCapParams = MegaFoldOut.Start("Cap Params", layer.showCapParams, new Color(1.0f, 1.0f, 0.5f));
if (layer.showCapParams)
{
layer.capflip = EditorGUILayout.Toggle("Flip Caps", layer.capflip);
layer.capStart = EditorGUILayout.BeginToggleGroup(MegaToolTip.CapStart, layer.capStart);
layer.capStartMat = (Material)EditorGUILayout.ObjectField(MegaToolTip.CapStartMat, layer.capStartMat, typeof(Material), true);
layer.capStartUVOffset = EditorGUILayout.Vector2Field("UV Offset", layer.capStartUVOffset);
layer.capStartUVScale = EditorGUILayout.Vector2Field("UV Scale", layer.capStartUVScale);
layer.capStartUVRot = EditorGUILayout.FloatField(MegaToolTip.CapStartRot, layer.capStartUVRot);
EditorGUILayout.EndToggleGroup();
layer.capEnd = EditorGUILayout.BeginToggleGroup(MegaToolTip.CapEnd, layer.capEnd);
layer.capEndMat = (Material)EditorGUILayout.ObjectField(MegaToolTip.CapEndMat, layer.capEndMat, typeof(Material), true);
layer.capEndUVOffset = EditorGUILayout.Vector2Field("UV Offset", layer.capEndUVOffset);
layer.capEndUVScale = EditorGUILayout.Vector2Field("UV Scale", layer.capEndUVScale);
layer.capEndUVRot = EditorGUILayout.FloatField(MegaToolTip.CapEndRot, layer.capEndUVRot);
EditorGUILayout.EndToggleGroup();
}
MegaFoldOut.End(layer.showCapParams);
layer.showConformParams = MegaFoldOut.Start("Conform Params", layer.showConformParams, new Color(1.0f, 1.0f, 0.5f));
if (layer.showConformParams)
{
layer.conform = EditorGUILayout.BeginToggleGroup("Conform", layer.conform);
GameObject contarget = (GameObject)EditorGUILayout.ObjectField("Target", layer.target, typeof(GameObject), true);
if (contarget != layer.target)
{
layer.SetTarget(contarget);
}
layer.conformAmount = EditorGUILayout.Slider("Amount", layer.conformAmount, 0.0f, 1.0f);
layer.raystartoff = EditorGUILayout.FloatField("Ray Start Off", layer.raystartoff);
layer.conformOffset = EditorGUILayout.FloatField("Conform Offset", layer.conformOffset);
layer.raydist = EditorGUILayout.FloatField("Ray Dist", layer.raydist);
EditorGUILayout.EndToggleGroup();
}
MegaFoldOut.End(layer.showConformParams);
}
}
EditorGUILayout.EndVertical();
MegaShapeLoftEditor.PopCols();
layer.customizeOffset = EditorGUILayout.BeginToggleGroup("Customize Offset", layer.customizeOffset);
layer.param1 = EditorGUILayout.FloatField("Param 1", layer.param1);
layer.param2 = EditorGUILayout.FloatField("Param 2", layer.param2);
layer.param3 = EditorGUILayout.FloatField("Param 3", layer.param3);
layer.param4 = EditorGUILayout.FloatField("Param 4", layer.param4);
EditorGUILayout.EndToggleGroup();
}
void DoUpdate()
{
if (surfaceLoft && surfaceLayer >= 0)
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
if (animate)
{
distance += speed * Time.deltaTime;
distance = Mathf.Repeat(distance, layer.layerPath.splines[layer.curve].length);
alpha = distance / layer.layerPath.splines[layer.curve].length;
}
Vector3 at = Vector3.zero;
Vector3 up = Vector3.zero;
Vector3 right = Vector3.zero;
Vector3 fwd = Vector3.zero;
if (mode == MegaWalkMode.Distance)
{
alpha = distance / layer.layerPath.splines[layer.curve].length;
}
else
{
distance = alpha * layer.layerPath.splines[layer.curve].length;
}
Vector3 p = layer.GetPosAndFrame(surfaceLoft, crossalpha, alpha, tangent, out at, out up, out right, out fwd);
p += up * offset;
//up = -Vector3.up;
Quaternion rot = Quaternion.LookRotation(fwd, up);
Quaternion rot1 = Quaternion.Euler(uprot);
rot = Quaternion.Lerp(rot, rot1, upright);
Quaternion locrot = Quaternion.Euler(rotate);
if (!initrot && delay != 0.0f)
{
rot = Quaternion.Slerp(transform.rotation, rot * locrot, Time.deltaTime * delay);
}
else
{
initrot = false;
rot = rot * locrot;
}
transform.rotation = rot; // * locrot;
transform.position = layer.transform.TransformPoint(p);
#if false
//float a = 0.0f;
if (mode == MegaWalkMode.Distance)
{
alpha = distance / surfaceLoft.Layers[surfaceLayer].layerPath.splines[0].length;
}
else
{
distance = alpha * surfaceLoft.Layers[surfaceLayer].layerPath.splines[0].length;
}
Vector3 p = layer.GetPosAndFrame(surfaceLoft, crossalpha, alpha, tangent, out at, out up, out right, out fwd);
p += up * offset;
Quaternion rot = Quaternion.LookRotation(fwd, up);
Quaternion locrot = Quaternion.Euler(rotate);
if (delay != 0.0f)
{
rot = Quaternion.Slerp(transform.rotation, rot * locrot, delay);
}
else
{
rot = rot * locrot;
}
transform.rotation = rot; // * locrot;
transform.position = layer.transform.TransformPoint(p);
#endif
}
}
private void OnEnable()
{
src = target as MegaLoftLayerSimple;
undoManager = new MegaUndo(src, "Loft Param");
}
public override int BuildMesh(MegaShapeLoft loft, int triindex)
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
LayerLength = 1.0f / layer.GetLength(surfaceLoft);
if (tangent < 0.1f)
{
tangent = 0.1f;
}
//mat = surfaceLoft.transform.localToWorldMatrix;
//mat = transform.localToWorldMatrix * surfaceLoft.transform.worldToLocalMatrix; // * transform.worldToLocalMatrix; //mat = surfaceLoft.transform.localToWorldMatrix;
mat = surfaceLoft.transform.localToWorldMatrix * transform.worldToLocalMatrix;
tm = Matrix4x4.identity;
MegaMatrix.Rotate(ref tm, Mathf.Deg2Rad * tmrot);
meshtm = Matrix4x4.identity;
MegaMatrix.Rotate(ref meshtm, Mathf.Deg2Rad * rot);
meshrot = Quaternion.Euler(rot);
float off = 0.0f;
int trioff = 0;
int vi = 0;
int fi = 0;
float ca = CrossAlpha; //Mathf.Repeat(CrossAlpha, 1.0001f);
if (startObj != null && StartEnabled)
{
// deform start along the curve
// so for each vertex find offset to calc alpha to find rotation and position of vert
// need to add vert to list, also uv and tri (uv is a copy)
Vector3 sscl = StartScale * GlobalScale;
Vector3 soff = Vector3.Scale(StartOff + Offset, sscl);
off -= startObj.bounds.min[(int)axis] * sscl[(int)axis]; // - startObj.bounds.size[(int)axis]; //0.0f; //sz;
for (int i = 0; i < sverts.Length; i++)
{
Vector3 p = sverts[i];
p = Deform(p, surfaceLoft, layer, start, ca, off, sscl, RemoveDof, soff);
loftverts[vi] = p; // + StartOff;
loftuvs[vi++] = suvs[i];
}
// Tris are a copy, could use InsertRange
for (int i = 0; i < stris.Length; i++)
{
lofttris[fi++] = stris[i] + triindex;
}
off += startObj.bounds.max[(int)axis] * sscl[(int)axis]; //sw;
off += StartGap * GlobalScale;
trioff = vi; //verts.Count;
}
if (mainObj != null && MainEnabled)
{
float mw = mainObj.bounds.size[(int)axis]; // * (GlobalScale * 0.01f);
Vector3 mscl = MainScale * GlobalScale;
Vector3 moff = Vector3.Scale(MainOff + Offset, mscl);
off -= mainObj.bounds.min[(int)axis] * mscl[(int)axis];
mw *= mscl[(int)axis];
float gaps = Gap * GlobalScale;
for (int r = 0; r < repeat; r++)
{
for (int i = 0; i < mverts.Length; i++)
{
Vector3 p = mverts[i];
p = Deform(p, surfaceLoft, layer, start, ca, off, mscl, RemoveDof, moff);
loftverts[vi] = p; // + MainOff;
loftuvs[vi++] = muvs[i];
}
for (int i = 0; i < mtris.Length; i++)
{
lofttris[fi++] = mtris[i] + trioff + triindex;
}
off += mw;
off += gaps;
trioff = vi; //verts.Count;
}
off -= gaps; //Gap;
off += (mainObj.bounds.max[(int)axis] * mscl[(int)axis]) - mw;
}
if (endObj != null && EndEnabled)
{
Vector3 escl = EndScale * GlobalScale;
Vector3 eoff = Vector3.Scale(EndOff + Offset, escl);
off -= endObj.bounds.min[(int)axis] * escl[(int)axis];
off += EndGap * GlobalScale;
for (int i = 0; i < everts.Length; i++)
{
Vector3 p = everts[i];
p = Deform(p, surfaceLoft, layer, start, ca, off, escl, RemoveDof, eoff);
loftverts[vi] = p; // + EndOff;
loftuvs[vi++] = euvs[i];
}
for (int i = 0; i < etris.Length; i++)
{
lofttris[fi++] = etris[i] + trioff + triindex;
}
trioff += everts.Length;
}
return(triindex);
}
public override bool PrepareLoft(MegaShapeLoft loft, int sc)
{
Init();
int vcount = 0;
int tcount = 0;
if (startObj && StartEnabled)
{
vcount += sverts.Length;
tcount += stris.Length;
}
if (endObj && EndEnabled)
{
vcount += everts.Length;
tcount += etris.Length;
}
if (mainObj && MainEnabled)
{
if (Length != 0.0f)
{
MegaShape path = null;
float dist = 0.0f;
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
path = layer.layerPath;
dist = layer.LoftLength * Length;
if (path)
{
Vector3 scl = MainScale * GlobalScale;
Vector3 size = Vector3.zero; //Vector3.Scale(mainObj.bounds.size, scl); // * + Gap)
size.x = (mainObj.bounds.size.x * scl.x) + (Gap * GlobalScale);
size.y = (mainObj.bounds.size.y * scl.y) + (Gap * GlobalScale);
size.z = (mainObj.bounds.size.z * scl.z) + (Gap * GlobalScale);
// TODO: 2 should be axis?
repeat = (int)(dist / size[(int)axis]); //(int)axis]); // + Gap));
}
}
vcount += (mverts.Length * repeat);
tcount += (mtris.Length * repeat);
}
if (loftverts == null || loftverts.Length != vcount)
{
loftverts = new Vector3[vcount];
}
if (loftuvs == null || loftuvs.Length != vcount)
{
loftuvs = new Vector2[vcount];
}
if (lofttris == null || lofttris.Length != tcount)
{
lofttris = new int[tcount];
}
return(true);
}
public override bool PrepareLoft(MegaShapeLoft loft, int sc)
{
if (surfaceLayer < 0 || surfaceLoft == null)
{
return(false);
}
if (rules.Count == 0)
{
return(false);
}
#if UNITY_5_4 || UNITY_5_5 || UNITY_5_6 || UNITY_6
Random.InitState(Seed);
#else
Random.seed = Seed;
#endif
Init();
BuildRules();
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
float tlen = layer.LoftLength * Length;
BuildLoftObjects(tlen);
for (int r = 0; r < rules.Count; r++)
{
for (int i = 0; i < rules[r].lofttris.Count; i++)
{
rules[r].lofttris[i].offset = 0;
rules[r].lofttris[i].tris = new int[rules[r].lofttris[i].sourcetris.Length * rules[r].usage];
}
}
int vcount = 0;
int tcount = 0;
for (int r = 0; r < loftobjs.Count; r++)
{
vcount += loftobjs[r].verts.Length;
tcount += loftobjs[r].tris.Length;
}
if (loftverts == null || loftverts.Length != vcount)
{
loftverts = new Vector3[vcount];
}
if (loftuvs == null || loftuvs.Length != vcount)
{
loftuvs = new Vector2[vcount];
}
if (lofttris == null || lofttris.Length != tcount)
{
lofttris = new int[tcount];
}
return(true);
}
public void BuildVerts()
{
if (surfaceLoft == null)
{
return;
}
//if ( surfaceLayer >= 0 && surfaceLayer < surfaceLoft.Layers.Length )
//return;
surfaceLayer = Mathf.Clamp(surfaceLayer, 0, surfaceLoft.Layers.Length - 1);
//if ( surfaceLayer >= 0 && surfaceLayer < surfaceLoft.Layers.Length )
//return;
if (mesh == null)
{
mesh = new Mesh();
}
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
steps = (int)(layer.layerPath.splines[layer.curve].length / dist);
verts = new Vector3[(steps + 1) * 2];
uvs = new Vector2[(steps + 1) * 2];
int index = 0;
Vector2 uv = Vector2.zero;
Matrix4x4 tm = surfaceLoft.transform.localToWorldMatrix;
for (int i = 0; i <= steps; i++)
{
float alpha = (float)i / (float)steps;
alpha = Mathf.Clamp(alpha, 0.0f, 0.9997f);
Vector3 p = layer.GetPos(surfaceLoft, cstart, alpha);
Vector3 p1 = layer.GetPos(surfaceLoft, cend, alpha);
//float d = (p1 - p).magnitude;
Vector3 dir = (p1 - p).normalized;
p = p - (dir * leftscale); // * d);
p1 = p1 + (dir * rightscale); // * d);
uv.y = alpha;
uv.x = 0.0f;
uvs[index] = uv;
verts[index] = tm.MultiplyPoint3x4(p);
uv.x = 1.0f;
uvs[index + 1] = uv;
verts[index + 1] = tm.MultiplyPoint3x4(p1);
index += 2;
}
if (leftenabled && leftfalloff > 0.0f)
{
index = 0;
vertsl = new Vector3[(steps + 1) * 2];
uvsl = new Vector2[(steps + 1) * 2];
OutlineSpline(layer.layerPath.splines[layer.curve], leftfall, -leftfalloff, true);
leftfall.constantSpeed = layer.layerPath.splines[layer.curve].constantSpeed;
leftfall.subdivs = layer.layerPath.splines[layer.curve].subdivs;
leftfall.CalcLength(10);
int k = 0;
for (int i = 0; i <= steps; i++)
{
float alpha = (float)i / (float)steps;
alpha = Mathf.Clamp(alpha, 0.0f, 0.9997f);
Vector3 p = layer.GetPos(surfaceLoft, cstart, alpha);
Vector3 p1 = layer.GetPos(surfaceLoft, cend, alpha);
//float d = (p1 - p).magnitude;
Vector3 dir = (p1 - p).normalized;
p = p - (dir * leftscale); // * d);
p = tm.MultiplyPoint3x4(p);
uv.y = alpha;
uv.x = 0.0f;
vertsl[index] = p;
uvsl[index++] = uv;
uv.x = 1.0f;
float a1 = layer.pathStart + (alpha * layer.pathLength);
//vertsl[index] = tm.MultiplyPoint3x4(leftfall.InterpCurve3D(alpha + (leftalphaoff * 0.01f), true, ref k));
vertsl[index] = tm.MultiplyPoint3x4(leftfall.InterpCurve3D(a1 + (leftalphaoff * 0.01f), true, ref k));
uvsl[index++] = uv;
}
}
if (rightenabled && rightfalloff > 0.0f)
{
index = 0;
vertsr = new Vector3[(steps + 1) * 2];
uvsr = new Vector2[(steps + 1) * 2];
OutlineSpline(layer.layerPath.splines[layer.curve], rightfall, rightfalloff, true);
rightfall.constantSpeed = layer.layerPath.splines[layer.curve].constantSpeed;
rightfall.subdivs = layer.layerPath.splines[layer.curve].subdivs;
rightfall.CalcLength(10);
int k = 0;
for (int i = 0; i <= steps; i++)
{
float alpha = (float)i / (float)steps;
alpha = Mathf.Clamp(alpha, 0.0f, 0.9997f);
Vector3 p = layer.GetPos(surfaceLoft, cend, alpha);
Vector3 p1 = layer.GetPos(surfaceLoft, cstart, alpha);
//float d = (p1 - p).magnitude;
Vector3 dir = (p1 - p).normalized;
p = p - (dir * rightscale); // * d);
p = tm.MultiplyPoint3x4(p);
uv.y = alpha;
uv.x = 1.0f;
vertsr[index] = p;
uvsr[index++] = uv;
uv.x = 0.0f;
float a1 = layer.pathStart + (alpha * layer.pathLength);
//vertsr[index] = tm.MultiplyPoint3x4(rightfall.InterpCurve3D(alpha + (rightalphaoff * 0.01f), true, ref k));
vertsr[index] = tm.MultiplyPoint3x4(rightfall.InterpCurve3D(a1 + (rightalphaoff * 0.01f), true, ref k));
uvsr[index++] = uv;
}
}
}
Vector3 DeformOld(Vector3 p, MegaShapeLoft loft, MegaLoftLayerSimple layer, float percent, float ca, float off, Vector3 scale, float removeDof, Vector3 locoff)
{
p = tm.MultiplyPoint3x4(p);
p.z += off;
p.x *= scale.x;
p.y *= scale.y;
p.z *= scale.z;
p += locoff;
float alpha = (p.z * LayerLength) + percent;
if (useCrossCrv)
{
ca += CrossCrv.Evaluate(alpha);
if (ca < 0.0f)
{
ca = 0.0f;
}
if (ca > 0.999f)
{
ca = 0.999f;
}
}
Vector3 ps1;
Vector3 ps;
if (CalcUp)
{
Vector3 newup;
ps = layer.GetPosAndUp(loft, ca, alpha, 0.1f, out ps1, out newup);
//newup = surfacetolofttm.MultiplyVector(newup);
// May need this back in
//if ( path.splines[0].closed )
alpha = Mathf.Repeat(alpha, 1.0f);
if (calcUpAmount < 0.999f)
{
newup = Vector3.Lerp(Vector3.up, newup, calcUpAmount);
}
Quaternion uprot = Quaternion.FromToRotation(Vector3.up, newup);
if (useTwistCrv)
{
tw = uprot * Quaternion.AngleAxis(twist * twistCrv.Evaluate(alpha), Vector3.forward);
}
else
{
tw = uprot;
}
}
else
{
ps = layer.GetPosAndLook(loft, ca, alpha, 0.1f, out ps1);
alpha = Mathf.Repeat(alpha, 1.0f);
if (useTwistCrv)
{
tw = Quaternion.AngleAxis(twist * twistCrv.Evaluate(alpha), Vector3.forward);
}
}
Vector3 relativePos = ps1 - ps;
relativePos.y *= removeDof;
Quaternion rotation = tw * Quaternion.LookRotation(relativePos);
//wtm.SetTRS(ps, rotation, Vector3.one);
MegaMatrix.SetTR(ref wtm, ps, rotation);
wtm = mat * wtm;
p.z = 0.0f;
return(wtm.MultiplyPoint3x4(p));
}
Vector3 DeformOld(Vector3 p, MegaShapeLoft loft, MegaLoftLayerSimple layer, float percent, float ca, float off, Vector3 scale, float removeDof, Vector3 locoff)
{
p = tm.MultiplyPoint3x4(p);
p.z += off;
p.x *= scale.x;
p.y *= scale.y;
p.z *= scale.z;
p += locoff;
float alpha = (p.z * LayerLength) + percent;
if ( useCrossCrv )
{
ca += CrossCrv.Evaluate(alpha);
if ( ca < 0.0f )
ca = 0.0f;
if ( ca > 0.999f )
ca = 0.999f;
}
Vector3 ps1;
Vector3 ps;
if ( CalcUp )
{
Vector3 newup;
ps = layer.GetPosAndUp(loft, ca, alpha, 0.1f, out ps1, out newup);
//newup = surfacetolofttm.MultiplyVector(newup);
// May need this back in
//if ( path.splines[0].closed )
alpha = Mathf.Repeat(alpha, 1.0f);
if ( calcUpAmount < 0.999f )
newup = Vector3.Lerp(Vector3.up, newup, calcUpAmount);
Quaternion uprot = Quaternion.FromToRotation(Vector3.up, newup);
if ( useTwistCrv )
tw = uprot * Quaternion.AngleAxis(twist * twistCrv.Evaluate(alpha), Vector3.forward);
else
tw = uprot;
}
else
{
ps = layer.GetPosAndLook(loft, ca, alpha, 0.1f, out ps1);
alpha = Mathf.Repeat(alpha, 1.0f);
if ( useTwistCrv )
tw = Quaternion.AngleAxis(twist * twistCrv.Evaluate(alpha), Vector3.forward);
}
Vector3 relativePos = ps1 - ps;
relativePos.y *= removeDof;
Quaternion rotation = tw * Quaternion.LookRotation(relativePos);
//wtm.SetTRS(ps, rotation, Vector3.one);
MegaMatrix.SetTR(ref wtm, ps, rotation);
wtm = mat * wtm;
p.z = 0.0f;
return wtm.MultiplyPoint3x4(p);
}
Vector3 Deform(Vector3 p, MegaShapeLoft loft, MegaLoftLayerSimple layer, float percent, float ca, float off, Vector3 scale, float removeDof, Vector3 locoff)
{
p = tm.MultiplyPoint3x4(p);
p.x *= scale.x;
p.y *= scale.y;
p.z *= scale.z;
p.z += off;
p += locoff;
float alpha = (p.z * LayerLength) + percent;
if (useCrossCrv)
{
ca += CrossCrv.Evaluate(alpha);
}
Vector3 ps1;
Vector3 ps;
if (CalcUp)
{
Vector3 upv = Vector3.zero;
Vector3 right = Vector3.zero;
Vector3 fwd = Vector3.zero;
ps = layer.GetPosAndFrame(loft, ca, alpha, (tangent * 0.001f), out ps1, out upv, out right, out fwd);
tw = Quaternion.LookRotation(fwd, upv);
Quaternion rot = tw * meshrot;
if (useTwist)
{
rot *= Quaternion.AngleAxis(180.0f + (twist * twistCrv.Evaluate(alpha)), Vector3.forward);
}
else
{
rot *= Quaternion.AngleAxis(180.0f, Vector3.forward);
}
//wtm.SetTRS(ps, rot, Vector3.one);
MegaMatrix.SetTR(ref wtm, ps, rot);
wtm = mat * wtm;
p.z = 0.0f;
return(wtm.MultiplyPoint3x4(p));
}
else
{
ps = layer.GetPosAndLook(loft, ca, alpha, (tangent * 0.001f), out ps1);
if (useTwist)
{
tw = meshrot * Quaternion.AngleAxis((twist * twistCrv.Evaluate(alpha)), Vector3.forward); // * meshrot;
}
else
{
tw = meshrot * Quaternion.AngleAxis(0.0f, Vector3.forward); // * meshrot;
}
}
Vector3 relativePos = ps1 - ps;
relativePos.y *= removeDof;
if (relativePos == Vector3.zero)
{
relativePos = lastrel; //Vector3.forward;
}
lastrel = relativePos;
Quaternion rotation = Quaternion.LookRotation(relativePos) * tw; // * meshrot;
MegaMatrix.SetTR(ref wtm, ps, rotation);
//wtm.SetTRS(ps, rotation, Vector3.one);
wtm = mat * wtm;
p.z = 0.0f;
return(wtm.MultiplyPoint3x4(p));
}
void OnGUI()
{
if (Selection.activeGameObject == null)
{
return;
}
MegaShapeLoft loft = Selection.activeGameObject.GetComponent <MegaShapeLoft>();
if (loft == null)
{
return;
}
lofttype = (MegaLoftType)EditorGUILayout.EnumPopup("Type", lofttype);
LayerName = EditorGUILayout.TextField("Name", LayerName);
start = EditorGUILayout.FloatField("Start", start);
length = EditorGUILayout.FloatField("Length", length);
paramCol = EditorGUILayout.ColorField("Param Col", paramCol);
EditorStyles.textField.wordWrap = true;
switch (lofttype)
{
case MegaLoftType.Simple:
EditorGUILayout.TextArea("Basic Loft layer that uses a single spline for the path and another spline for the cross section", GUILayout.Height(50.0f));
path = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
section = (MegaShape)EditorGUILayout.ObjectField("Section", section, typeof(MegaShape), true);
material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
break;
//case MegaLoftType.Collider:
// colliderwidth = EditorGUILayout.FloatField("Collider Width", colliderwidth);
// break;
case MegaLoftType.CloneSimple:
EditorGUILayout.TextArea("Clone a mesh onto a surface with options for start, end and main meshes", GUILayout.Height(50.0f));
startObjMesh = (Mesh)EditorGUILayout.ObjectField("Start Obj", startObjMesh, typeof(Mesh), true);
mainObjMesh = (Mesh)EditorGUILayout.ObjectField("Main Obj", mainObjMesh, typeof(Mesh), true);
endObjMesh = (Mesh)EditorGUILayout.ObjectField("End Obj", endObjMesh, typeof(Mesh), true);
surfaceLoft = (MegaShapeLoft)EditorGUILayout.ObjectField("Surface", surfaceLoft, typeof(MegaShapeLoft), true);
surfaceLayer = EditorGUILayout.Popup("Layer", surfaceLayer + 1, MegaShapeUtils.GetLayers(surfaceLoft)) - 1;
material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
break;
case MegaLoftType.ScatterSimple:
EditorGUILayout.TextArea("Scatters a choosen mesh and material over a surface", GUILayout.Height(50.0f));
mainObjMesh = (Mesh)EditorGUILayout.ObjectField("Obj", mainObjMesh, typeof(Mesh), true);
surfaceLoft = (MegaShapeLoft)EditorGUILayout.ObjectField("Surface", surfaceLoft, typeof(MegaShapeLoft), true);
surfaceLayer = EditorGUILayout.Popup("Layer", surfaceLayer + 1, MegaShapeUtils.GetLayers(surfaceLoft)) - 1;
material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
break;
case MegaLoftType.Scatter:
EditorGUILayout.TextArea("Builds a mesh layer by scattering a choosen object over a surface", GUILayout.Height(50.0f));
mainObj = (GameObject)EditorGUILayout.ObjectField("Obj", mainObj, typeof(Mesh), true);
mainObj = MegaMeshCheck.ValidateObj(mainObj);
surfaceLoft = (MegaShapeLoft)EditorGUILayout.ObjectField("Surface", surfaceLoft, typeof(MegaShapeLoft), true);
surfaceLayer = EditorGUILayout.Popup("Layer", surfaceLayer + 1, MegaShapeUtils.GetLayers(surfaceLoft)) - 1;
break;
case MegaLoftType.ScatterSpline:
EditorGUILayout.TextArea("Build a mesh by scattering a choosen mesh and material along a spline", GUILayout.Height(50.0f));
path = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
mainObjMesh = (Mesh)EditorGUILayout.ObjectField("Obj", mainObjMesh, typeof(Mesh), true);
material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
break;
case MegaLoftType.Complex:
EditorGUILayout.TextArea("Advanced lofter that uses a spline for the path and any number of cross section splines to define the loft", GUILayout.Height(50.0f));
path = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
section = (MegaShape)EditorGUILayout.ObjectField("Section", section, typeof(MegaShape), true);
material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
break;
case MegaLoftType.CloneSplineSimple:
EditorGUILayout.TextArea("Clone a mesh along a spline with options for start, end and main meshes", GUILayout.Height(50.0f));
path = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
startObjMesh = (Mesh)EditorGUILayout.ObjectField("Start Obj", startObjMesh, typeof(Mesh), true);
//startObj = MegaMeshCheck.ValidateObj(startObj);
mainObjMesh = (Mesh)EditorGUILayout.ObjectField("Main Obj", mainObjMesh, typeof(Mesh), true);
//mainObj = MegaMeshCheck.ValidateObj(mainObj);
endObjMesh = (Mesh)EditorGUILayout.ObjectField("End Obj", endObjMesh, typeof(Mesh), true);
//endObj = MegaMeshCheck.ValidateObj(endObj);
material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
break;
case MegaLoftType.Clone:
EditorGUILayout.TextArea("Clone a mesh onto a surface with options for start, end and main meshes", GUILayout.Height(50.0f));
startObj = (GameObject)EditorGUILayout.ObjectField("Start Obj", startObj, typeof(GameObject), true);
startObj = MegaMeshCheck.ValidateObj(startObj);
mainObj = (GameObject)EditorGUILayout.ObjectField("Main Obj", mainObj, typeof(GameObject), true);
mainObj = MegaMeshCheck.ValidateObj(mainObj);
endObj = (GameObject)EditorGUILayout.ObjectField("End Obj", endObj, typeof(GameObject), true);
endObj = MegaMeshCheck.ValidateObj(endObj);
surfaceLoft = (MegaShapeLoft)EditorGUILayout.ObjectField("Surface", surfaceLoft, typeof(MegaShapeLoft), true);
surfaceLayer = EditorGUILayout.Popup("Layer", surfaceLayer + 1, MegaShapeUtils.GetLayers(surfaceLoft)) - 1;
material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
break;
case MegaLoftType.CloneSpline:
EditorGUILayout.TextArea("Build a mesh layer by cloning objects along a spline with options for start, end and main objects", GUILayout.Height(50.0f));
path = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
startObj = (GameObject)EditorGUILayout.ObjectField("Start Obj", startObj, typeof(GameObject), true);
startObj = MegaMeshCheck.ValidateObj(startObj);
mainObj = (GameObject)EditorGUILayout.ObjectField("Main Obj", mainObj, typeof(GameObject), true);
mainObj = MegaMeshCheck.ValidateObj(mainObj);
endObj = (GameObject)EditorGUILayout.ObjectField("End Obj", endObj, typeof(GameObject), true);
endObj = MegaMeshCheck.ValidateObj(endObj);
break;
case MegaLoftType.CloneRules:
EditorGUILayout.TextArea("Rule based clone onto a surface", GUILayout.Height(50.0f));
//path = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
surfaceLoft = (MegaShapeLoft)EditorGUILayout.ObjectField("Surface", surfaceLoft, typeof(MegaShapeLoft), true);
surfaceLayer = EditorGUILayout.Popup("Layer", surfaceLayer + 1, MegaShapeUtils.GetLayers(surfaceLoft)) - 1;
break;
case MegaLoftType.CloneSplineRules:
EditorGUILayout.TextArea("Rule based clone along a spline", GUILayout.Height(50.0f));
path = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
surfaceLoft = (MegaShapeLoft)EditorGUILayout.ObjectField("Surface", surfaceLoft, typeof(MegaShapeLoft), true);
surfaceLayer = EditorGUILayout.Popup("Layer", surfaceLayer + 1, MegaShapeUtils.GetLayers(surfaceLoft)) - 1;
break;
#if true
case MegaLoftType.MultiMaterial:
EditorGUILayout.TextArea("Will create a loft using multiple materials based on material ids in the spline knots. It uses a single spline for the path and another spline for the cross section", GUILayout.Height(50.0f));
path = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
section = (MegaShape)EditorGUILayout.ObjectField("Section", section, typeof(MegaShape), true);
material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
break;
case MegaLoftType.MultiMaterialComplex:
EditorGUILayout.TextArea("Will create a complex loft using multiple materials based on material ids in the spline knots. It uses a single spline for the path and another spline for the cross section", GUILayout.Height(50.0f));
path = (MegaShape)EditorGUILayout.ObjectField("Path", path, typeof(MegaShape), true);
section = (MegaShape)EditorGUILayout.ObjectField("Section", section, typeof(MegaShape), true);
material = (Material)EditorGUILayout.ObjectField("Material", material, typeof(Material), true);
break;
#endif
}
EditorStyles.textField.wordWrap = false;
EditorGUILayout.BeginHorizontal();
if (GUILayout.Button("Create"))
{
MegaLoftLayerBase laybase = null;
switch (lofttype)
{
case MegaLoftType.Simple:
{
MegaLoftLayerSimple layer = Selection.activeGameObject.AddComponent <MegaLoftLayerSimple>();
layer.pathStart = start;
layer.pathLength = length;
layer.layerPath = path;
layer.layerSection = section;
laybase = layer;
}
break;
case MegaLoftType.CloneSimple:
{
MegaLoftLayerCloneSimple layer = Selection.activeGameObject.AddComponent <MegaLoftLayerCloneSimple>();
layer.startObj = startObjMesh;
layer.mainObj = mainObjMesh;
layer.endObj = endObjMesh;
layer.surfaceLoft = surfaceLoft;
layer.surfaceLayer = surfaceLayer;
laybase = layer;
}
break;
case MegaLoftType.ScatterSimple:
{
MegaLoftLayerScatterSimple layer = Selection.activeGameObject.AddComponent <MegaLoftLayerScatterSimple>();
layer.scatterMesh = mainObjMesh;
layer.surfaceLoft = surfaceLoft;
layer.surfaceLayer = surfaceLayer;
laybase = layer;
}
break;
case MegaLoftType.Scatter:
{
MegaLoftLayerScatter layer = Selection.activeGameObject.AddComponent <MegaLoftLayerScatter>();
layer.mainObj = mainObj;
layer.surfaceLoft = surfaceLoft;
layer.surfaceLayer = surfaceLayer;
laybase = layer;
}
break;
case MegaLoftType.ScatterSpline:
{
MegaLoftLayerScatterSpline layer = Selection.activeGameObject.AddComponent <MegaLoftLayerScatterSpline>();
layer.scatterMesh = mainObjMesh;
layer.layerPath = path;
laybase = layer;
}
break;
case MegaLoftType.Complex:
{
MegaLoftLayerComplex layer = Selection.activeGameObject.AddComponent <MegaLoftLayerComplex>();
layer.layerPath = path;
layer.layerSection = section;
laybase = layer;
}
break;
case MegaLoftType.CloneSplineSimple:
{
MegaLoftLayerCloneSplineSimple layer = Selection.activeGameObject.AddComponent <MegaLoftLayerCloneSplineSimple>();
layer.layerPath = path;
layer.startObj = startObjMesh;
layer.mainObj = mainObjMesh;
layer.endObj = endObjMesh;
laybase = layer;
}
break;
case MegaLoftType.CloneSpline:
{
MegaLoftLayerCloneSpline layer = Selection.activeGameObject.AddComponent <MegaLoftLayerCloneSpline>();
layer.layerPath = path;
layer.startObj = startObj;
layer.mainObj = mainObj;
layer.endObj = endObj;
laybase = layer;
}
break;
case MegaLoftType.Clone:
{
MegaLoftLayerClone layer = Selection.activeGameObject.AddComponent <MegaLoftLayerClone>();
layer.surfaceLoft = surfaceLoft;
layer.surfaceLayer = surfaceLayer;
layer.startObj = startObj;
layer.mainObj = mainObj;
layer.endObj = endObj;
laybase = layer;
}
break;
case MegaLoftType.CloneRules:
{
MegaLoftLayerCloneRules layer = Selection.activeGameObject.AddComponent <MegaLoftLayerCloneRules>();
layer.surfaceLoft = surfaceLoft;
layer.surfaceLayer = surfaceLayer;
//layer.layerPath = path;
//layer.layerSection = section;
laybase = layer;
}
break;
case MegaLoftType.CloneSplineRules:
{
MegaLoftLayerCloneSplineRules layer = Selection.activeGameObject.AddComponent <MegaLoftLayerCloneSplineRules>();
layer.layerPath = path;
laybase = layer;
}
break;
#if true
case MegaLoftType.MultiMaterial:
{
MegaLoftLayerMultiMat layer = Selection.activeGameObject.AddComponent <MegaLoftLayerMultiMat>();
layer.pathStart = start;
layer.pathLength = length;
layer.layerPath = path;
layer.layerSection = section;
MegaMaterialSection ms = new MegaMaterialSection();
ms.mat = material;
layer.sections.Add(ms);
laybase = layer;
}
break;
// We should add two loft sections
// if cross has multiple splines add them all equally spaced?
case MegaLoftType.MultiMaterialComplex:
{
MegaLoftLayerMultiMatComplex layer = Selection.activeGameObject.AddComponent <MegaLoftLayerMultiMatComplex>();
layer.pathStart = start;
layer.pathLength = length;
layer.layerPath = path;
layer.layerSection = section;
MegaMaterialSection ms = new MegaMaterialSection();
ms.mat = material;
layer.sections.Add(ms);
laybase = layer;
}
break;
#endif
default:
EditorUtility.DisplayDialog("Layer Not Supported", "Currently this layer type is not not supported", "OK");
break;
}
// Common params
if (laybase)
{
laybase.paramcol = paramCol;
laybase.LayerName = LayerName;
laybase.LayerName = LayerName;
laybase.material = material;
}
this.Close();
}
if (GUILayout.Button("Cancel"))
{
this.Close();
}
EditorGUILayout.EndHorizontal();
}
Vector3 Deform(Vector3 p, MegaShapeLoft loft, MegaLoftLayerSimple layer, float percent, float ca, float off, Vector3 scale, float removeDof, Vector3 locoff)
{
p = tm.MultiplyPoint3x4(p);
p.x *= scale.x;
p.y *= scale.y;
p.z *= scale.z;
p.z += off;
p += locoff;
float alpha = (p.z * LayerLength) + percent;
if ( useCrossCrv )
ca += CrossCrv.Evaluate(alpha);
Vector3 ps1;
Vector3 ps;
if ( CalcUp )
{
Vector3 upv = Vector3.zero;
Vector3 right = Vector3.zero;
Vector3 fwd = Vector3.zero;
ps = layer.GetPosAndFrame(loft, ca, alpha, (tangent * 0.001f), out ps1, out upv, out right, out fwd);
tw = Quaternion.LookRotation(fwd, upv);
Quaternion rot = tw * meshrot;
if ( useTwist )
rot *= Quaternion.AngleAxis(180.0f + (twist * twistCrv.Evaluate(alpha)), Vector3.forward);
else
rot *= Quaternion.AngleAxis(180.0f, Vector3.forward);
//wtm.SetTRS(ps, rot, Vector3.one);
MegaMatrix.SetTR(ref wtm, ps, rot);
wtm = mat * wtm;
p.z = 0.0f;
return wtm.MultiplyPoint3x4(p);
}
else
{
ps = layer.GetPosAndLook(loft, ca, alpha, (tangent * 0.001f), out ps1);
if ( useTwist )
tw = meshrot * Quaternion.AngleAxis((twist * twistCrv.Evaluate(alpha)), Vector3.forward); // * meshrot;
else
tw = meshrot * Quaternion.AngleAxis(0.0f, Vector3.forward); // * meshrot;
}
Vector3 relativePos = ps1 - ps;
relativePos.y *= removeDof;
if ( relativePos == Vector3.zero )
{
relativePos = lastrel; //Vector3.forward;
}
lastrel = relativePos;
Quaternion rotation = Quaternion.LookRotation(relativePos) * tw; // * meshrot;
MegaMatrix.SetTR(ref wtm, ps, rotation);
//wtm.SetTRS(ps, rotation, Vector3.one);
wtm = mat * wtm;
p.z = 0.0f;
return wtm.MultiplyPoint3x4(p);
}
public override int BuildMesh(MegaShapeLoft loft, int triindex)
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
LayerLength = 1.0f / layer.GetLength(surfaceLoft);
if (tangent < 0.1f)
{
tangent = 0.1f;
}
//mat = surfaceLoft.transform.localToWorldMatrix;
mat = surfaceLoft.transform.localToWorldMatrix * transform.worldToLocalMatrix;
//mat = transform.localToWorldMatrix * surfaceLoft.transform.worldToLocalMatrix; // * transform.worldToLocalMatrix; //mat = surfaceLoft.transform.localToWorldMatrix;
//mat = surfaceLoft.transform.worldToLocalMatrix * transform.localToWorldMatrix; // * transform.worldToLocalMatrix; //mat = surfaceLoft.transform.localToWorldMatrix;
tm = Matrix4x4.identity;
tw = Quaternion.identity;
//surfacetolofttm = mat * transform.worldToLocalMatrix;
//surfacetolofttm = surfaceLoft.transform.localToWorldMatrix * transform.worldToLocalMatrix;
MegaMatrix.Rotate(ref tm, Mathf.Deg2Rad * tmrot);
float off = 0.0f;
int trioff = 0;
int vi = 0;
float ca = CrossAlpha;
if (ca > 0.99999f)
{
ca = 0.99999f;
}
// This is also done in prepareloft
for (int r = 0; r < rules.Count; r++)
{
for (int i = 0; i < rules[r].lofttris.Count; i++)
{
rules[r].lofttris[i].offset = 0;
}
}
for (int r = 0; r < loftobjs.Count; r++)
{
MegaLoftRule obj = loftobjs[r];
Vector3 sscl = (scale + obj.scale) * GlobalScale;
Vector3 soff = Vector3.Scale(offset + obj.offset, sscl);
off -= obj.bounds.min[(int)axis];
off += (obj.gapin * obj.bounds.size[(int)axis]);
for (int i = 0; i < obj.verts.Length; i++)
{
Vector3 p = obj.verts[i];
p = Deform(p, surfaceLoft, layer, start, ca, off, sscl, RemoveDof, soff);
loftverts[vi] = p;
loftuvs[vi++] = obj.uvs[i];
}
for (int i = 0; i < obj.lofttris.Count; i++)
{
int toff = obj.lofttris[i].offset;
for (int t = 0; t < obj.lofttris[i].sourcetris.Length; t++)
{
obj.lofttris[i].tris[toff++] = obj.lofttris[i].sourcetris[t] + trioff + triindex;
}
obj.lofttris[i].offset = toff;
}
off += obj.bounds.max[(int)axis];
off += (obj.gapout * obj.bounds.size[(int)axis]);
trioff = vi;
}
return(triindex);
}
public override bool PrepareLoft(MegaShapeLoft loft, int sc)
{
if (surfaceLayer < 0 || surfaceLoft == null)
{
return(false);
}
// If we dont have any meshes then return null for not building
if (startObj == null && mainObj == null && endObj == null)
{
return(false);
}
Init();
int vcount = 0;
int tcount = 0;
if (startObj && StartEnabled)
{
vcount += sverts.Length;
tcount += starttris; //stris.Length;
for (int i = 0; i < startlofttris.Count; i++)
{
startlofttris[i].tris = new int[startlofttris[i].sourcetris.Length];
}
}
if (mainObj && MainEnabled)
{
if (Length != 0.0f)
{
//Debug.Log("layer " + surfaceLayer);
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
MegaShape path = layer.layerPath;
if (path)
{
float dist = layer.LoftLength * Length;
Vector3 scl = MainScale * GlobalScale;
Vector3 size = Vector3.zero;
size.x = (mainBounds.size.x * scl.x) + (Gap * GlobalScale);
size.y = (mainBounds.size.y * scl.y) + (Gap * GlobalScale);
size.z = (mainBounds.size.z * scl.z) + (Gap * GlobalScale);
repeat = (int)(dist / size[(int)axis]); // + Gap));
}
}
vcount += (mverts.Length * repeat);
tcount += (maintris * repeat);
for (int i = 0; i < mainlofttris.Count; i++)
{
mainlofttris[i].tris = new int[mainlofttris[i].sourcetris.Length * repeat];
}
}
if (endObj && EndEnabled)
{
vcount += everts.Length;
tcount += endtris; //etris.Length;
for (int i = 0; i < endlofttris.Count; i++)
{
endlofttris[i].tris = new int[endlofttris[i].sourcetris.Length];
}
}
if (loftverts == null || loftverts.Length != vcount)
{
loftverts = new Vector3[vcount];
}
if (loftuvs == null || loftuvs.Length != vcount)
{
loftuvs = new Vector2[vcount];
}
if (lofttris == null || lofttris.Length != tcount)
{
lofttris = new int[tcount];
}
firstVerts = loftverts.Length;
return(true);
}
public override int BuildMesh(MegaShapeLoft loft, int triindex)
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
LayerLength = 1.0f / layer.GetLength(surfaceLoft);
if (tangent < 0.1f)
{
tangent = 0.1f;
}
//mat = surfaceLoft.transform.localToWorldMatrix;
//mat = transform.localToWorldMatrix * surfaceLoft.transform.worldToLocalMatrix; // * transform.worldToLocalMatrix; //mat = surfaceLoft.transform.localToWorldMatrix;
mat = surfaceLoft.transform.localToWorldMatrix * transform.worldToLocalMatrix;
tm = Matrix4x4.identity;
switch (axis)
{
case MegaAxis.X: MegaMatrix.RotateY(ref tm, -Mathf.PI * 0.5f); break;
case MegaAxis.Y: MegaMatrix.RotateX(ref tm, -Mathf.PI * 0.5f); break;
case MegaAxis.Z: break;
}
meshrot = Quaternion.Euler(rot);
int trioff = 0;
int vi = 0;
Matrix4x4 omat = Matrix4x4.identity;
#if UNITY_5_4 || UNITY_5_5 || UNITY_5_6 || UNITY_2017 || UNITY_2018 || UNITY_2019
Random.InitState(Seed);
#else
Random.seed = Seed;
#endif
Vector3 newup = Vector3.up;
Vector3 pivot;
Vector3 ps1;
Vector3 scl = Vector3.zero;
Vector3 sclmin = Vector3.Scale(scaleRangeMin, scale);
Vector3 sclmax = Vector3.Scale(scaleRangeMax, scale);
float a = 0.0f;
for (int r = 0; r < Count; r++)
{
scl.x = (scale.x + Mathf.Lerp(sclmin.x, sclmax.x, Random.value)) * GlobalScale;
scl.y = (scale.y + Mathf.Lerp(sclmin.y, sclmax.y, Random.value)) * GlobalScale;
scl.z = (scale.z + Mathf.Lerp(sclmin.z, sclmax.z, Random.value)) * GlobalScale;
if (useDensity)
{
a = FindScatterAlpha();
}
else
{
a = Random.value;
}
float alpha = start + (a * length) + Alpha;
float calpha = cstart + (Random.value * clength) + CAlpha;
Vector3 rt = rot + (((Random.value - 0.5f) * 2.0f) * rotRange);
meshrot = Quaternion.Euler(rt);
if (CalcUp)
{
pivot = layer.GetPos1(surfaceLoft, calpha, alpha, 0.001f, out ps1, out newup);
Quaternion uprot = Quaternion.FromToRotation(Vector3.up, newup);
tw = Quaternion.AngleAxis(180.0f, Vector3.forward) * uprot;
Vector3 relativePos = ps1 - pivot;
relativePos.y *= RemoveDof;
Quaternion rotation = Quaternion.LookRotation(relativePos) * tw * meshrot;
//wtm.SetTRS(Vector3.zero, rotation, scl);
wtm.SetTRS(pivot, rotation, scl);
omat = mat * wtm;
}
else
{
pivot = layer.GetPos1(surfaceLoft, calpha, alpha, 0.001f, out ps1, out newup);
tw = Quaternion.AngleAxis(180.0f, Vector3.forward);
Vector3 relativePos = ps1 - pivot;
relativePos.y *= RemoveDof;
Quaternion rotation = Quaternion.LookRotation(relativePos) * tw * meshrot;
//wtm.SetTRS(Vector3.zero, rotation, scl);
wtm.SetTRS(pivot, rotation, scl);
omat = mat * wtm;
}
Vector3 pp = Vector3.zero;
for (int i = 0; i < mverts.Length; i++)
{
pp.x = mverts[i].x + Offset.x;
pp.y = mverts[i].y + Offset.y;
pp.z = mverts[i].z + Offset.z;
pp = omat.MultiplyPoint3x4(pp);
loftverts[vi].x = pp.x; // + pivot.x;
loftverts[vi].y = pp.y; // + pivot.y;
loftverts[vi].z = pp.z; // + pivot.z;
loftuvs[vi++] = muvs[i];
}
for (int i = 0; i < mainlofttris.Count; i++)
{
int toff = mainlofttris[i].offset;
for (int t = 0; t < mainlofttris[i].sourcetris.Length; t++)
{
mainlofttris[i].tris[toff++] = mainlofttris[i].sourcetris[t] + trioff + triindex;
}
mainlofttris[i].offset = toff;
}
trioff = vi;
}
return(triindex);
}
public override int BuildMesh(MegaShapeLoft loft, int triindex)
{
MegaLoftLayerSimple layer = (MegaLoftLayerSimple)surfaceLoft.Layers[surfaceLayer];
LayerLength = 1.0f / layer.GetLength(surfaceLoft);
if (tangent < 0.1f)
{
tangent = 0.1f;
}
//mat = surfaceLoft.transform.localToWorldMatrix;
//mat = transform.localToWorldMatrix * surfaceLoft.transform.worldToLocalMatrix; // * transform.worldToLocalMatrix; //mat = surfaceLoft.transform.localToWorldMatrix;
mat = surfaceLoft.transform.localToWorldMatrix * transform.worldToLocalMatrix;
tm = Matrix4x4.identity;
MegaMatrix.Rotate(ref tm, Mathf.Deg2Rad * tmrot);
MegaMatrix.Rotate(ref meshtm, Mathf.Deg2Rad * rot);
meshtm = Matrix4x4.identity;
MegaMatrix.Rotate(ref meshtm, Mathf.Deg2Rad * rot);
meshrot = Quaternion.Euler(rot);
float off = 0.0f;
int trioff = 0;
int vi = 0;
float ca = CrossAlpha;
if (ca > 0.99999f)
{
ca = 0.99999f;
}
int ax = (int)axis;
if (startObj != null && StartEnabled)
{
Vector3 sscl = StartScale * GlobalScale;
Vector3 soff = Vector3.Scale(StartOff + Offset, sscl);
off -= startBounds.min[(int)axis] * sscl[ax];
for (int i = 0; i < sverts.Length; i++)
{
Vector3 p = sverts[i];
p = Deform(p, surfaceLoft, layer, start, ca, off, sscl, RemoveDof, soff);
loftverts[vi] = p;
loftuvs[vi++] = suvs[i];
}
for (int i = 0; i < startlofttris.Count; i++)
{
int toff = startlofttris[i].offset;
for (int t = 0; t < startlofttris[i].sourcetris.Length; t++)
{
startlofttris[i].tris[toff++] = startlofttris[i].sourcetris[t] + trioff + triindex;
}
startlofttris[i].offset = toff;
}
off += startBounds.max[(int)axis] * sscl[ax];
off += StartGap * GlobalScale;
trioff = vi;
}
if (mainObj != null && MainEnabled)
{
for (int i = 0; i < mainlofttris.Count; i++)
{
mainlofttris[i].offset = 0;
}
float mw = mainBounds.size[(int)axis];
Vector3 mscl = MainScale * GlobalScale;
Vector3 moff = Vector3.Scale(MainOff + Offset, mscl);
off -= mainBounds.min[(int)axis] * mscl[ax];
mw *= mscl[(int)axis];
float gaps = Gap * GlobalScale;
for (int r = 0; r < repeat; r++)
{
for (int i = 0; i < mverts.Length; i++)
{
Vector3 p = mverts[i];
p = Deform(p, surfaceLoft, layer, start, ca, off, mscl, RemoveDof, moff);
loftverts[vi] = p;
loftuvs[vi++] = muvs[i];
}
for (int i = 0; i < mainlofttris.Count; i++)
{
int toff = mainlofttris[i].offset;
for (int t = 0; t < mainlofttris[i].sourcetris.Length; t++)
{
mainlofttris[i].tris[toff++] = mainlofttris[i].sourcetris[t] + trioff + triindex;
}
mainlofttris[i].offset = toff;
}
off += mw;
off += gaps;
trioff = vi;
}
off -= gaps;
off += (mainBounds.max[(int)axis] * mscl[ax]) - mw;
}
if (endObj != null && EndEnabled)
{
Vector3 escl = EndScale * GlobalScale;
Vector3 eoff = Vector3.Scale(EndOff + Offset, escl);
off -= endBounds.min[(int)axis] * escl[ax];
off += EndGap * GlobalScale;
for (int i = 0; i < everts.Length; i++)
{
Vector3 p = everts[i];
p = Deform(p, surfaceLoft, layer, start, ca, off, escl, RemoveDof, eoff);
loftverts[vi] = p;
loftuvs[vi++] = euvs[i];
}
for (int i = 0; i < endlofttris.Count; i++)
{
int toff = endlofttris[i].offset;
for (int t = 0; t < endlofttris[i].sourcetris.Length; t++)
{
endlofttris[i].tris[toff++] = endlofttris[i].sourcetris[t] + trioff + triindex;
}
endlofttris[i].offset = toff;
}
trioff += everts.Length;
}
return(triindex);
}
private void OnEnable()
{
src = target as MegaLoftLayerSimple;
undoManager = new MegaUndo(src, "Loft Param");
}
