public void OnSceneGUI()
{
MegaLoftLayerComplex layer = (MegaLoftLayerComplex)target;
MegaShapeLoft loft = layer.gameObject.GetComponent <MegaShapeLoft>();
if (loft == null)
{
return;
}
if (layer.layerPath == null)
{
return;
}
if (!layer.showsections)
{
return;
}
MegaSpline pathspline = layer.layerPath.splines[layer.curve];
Matrix4x4 pathtm = Matrix4x4.identity;
if (layer.SnapToPath)
{
pathtm = layer.layerPath.transform.localToWorldMatrix;
}
Matrix4x4 twisttm = Matrix4x4.identity;
Matrix4x4 tm;
float offx = 0.0f;
float offy = 0.0f;
float offz = 0.0f;
Vector3 lastup = locup;
for (int i = 1; i < layer.sections.Count - 1; i++)
{
MegaLoftSection section = layer.sections[i];
float alpha = section.alpha;
if (layer.useOffsetX)
{
offx = layer.offsetCrvX.Evaluate(alpha);
}
if (layer.useOffsetY)
{
offy = layer.offsetCrvY.Evaluate(alpha);
}
if (layer.useOffsetZ)
{
offz += layer.offsetCrvZ.Evaluate(alpha);
}
//if ( layer.useTwistCrv )
//{
// float twist = layer.twistCrv.Evaluate(alpha);
// MegaShapeUtils.RotateZ(ref twisttm, Mathf.Deg2Rad * twist);
// tm = pathtm * layer.GetDeformMat(pathspline, alpha, layer.layerPath.normalizedInterp) * twisttm;
//}
//else
// tm = pathtm * layer.GetDeformMat(pathspline, alpha, layer.layerPath.normalizedInterp);
if (layer.useTwistCrv)
{
float twist = layer.twistCrv.Evaluate(section.alpha);
float tw1 = pathspline.GetTwist(section.alpha);
MegaShapeUtils.RotateZ(ref twisttm, Mathf.Deg2Rad * (twist - tw1));
if (layer.frameMethod == MegaFrameMethod.Old)
{
tm = pathtm * layer.GetDeformMat(pathspline, section.alpha, layer.layerPath.normalizedInterp) * twisttm;
}
else
{
tm = pathtm * layer.GetDeformMatNewMethod(pathspline, section.alpha, layer.layerPath.normalizedInterp, ref lastup) * twisttm;
}
}
else
{
if (layer.frameMethod == MegaFrameMethod.Old)
{
tm = pathtm * layer.GetDeformMat(pathspline, section.alpha, layer.layerPath.normalizedInterp);
}
else
{
tm = pathtm * layer.GetDeformMatNewMethod(pathspline, section.alpha, layer.layerPath.normalizedInterp, ref lastup);
}
}
Vector3 p = section.crossverts[0];
if (layer.useScaleXCrv)
{
p.x *= layer.scaleCrvX.Evaluate(alpha);
}
if (layer.useScaleYCrv)
{
p.y *= layer.scaleCrvY.Evaluate(alpha);
}
p.x += offx;
p.y += offy;
p.z += offz;
Vector3 tp = p;
p = tm.MultiplyPoint3x4(p);
p += layer.offset;
Matrix4x4 tantm = pathtm * layer.GetDeformMat(pathspline, alpha + 0.01f, layer.layerPath.normalizedInterp);
Vector3 tan = tantm.MultiplyPoint3x4(tp);
tan += layer.offset;
tan = (tan - p).normalized;
Vector3 p1 = section.crossverts[section.crossverts.Length - 1];
if (layer.useScaleXCrv)
{
p1.x *= layer.scaleCrvX.Evaluate(alpha);
}
if (layer.useScaleYCrv)
{
p1.y *= layer.scaleCrvY.Evaluate(alpha);
}
p1.x += offx;
p1.y += offy;
p1.z += offz;
tp = p1;
p1 = tm.MultiplyPoint3x4(p1);
p1 += layer.offset;
Handles.color = Color.yellow;
p = loft.transform.TransformPoint(p);
//Vector3 pn = Handles.Slider(p, tan, layer.handlesize, Handles.SphereCap, 0.0f);
Vector3 pn = Slider(p, tan, layer.handlesize);
pn = pn - p;
float delta = pn.magnitude;
if (Vector3.Dot(tan, pn) < 0.0f)
{
delta = -delta;
}
section.alpha += delta * 0.0005f;
float al = section.alpha; // + delta * 0.0005f;
if (al != layer.sections[i].alpha)
{
if (i > 0)
{
if (al < layer.sections[i - 1].alpha)
{
al = layer.sections[i - 1].alpha;
}
}
if (i < layer.sections.Count - 1)
{
if (al > layer.sections[i + 1].alpha)
{
al = layer.sections[i + 1].alpha;
}
}
layer.sections[i].alpha = al;
}
if (delta != 0.0f)
{
GUI.changed = true;
loft.rebuild = true;
EditorUtility.SetDirty(target);
}
tan = tantm.MultiplyPoint3x4(tp);
tan += layer.offset;
tan = (tan - p1).normalized;
p1 = loft.transform.TransformPoint(p1);
//pn = Handles.Slider(p1, tan, layer.handlesize, Handles.SphereCap, 0.0f);
pn = Slider(p1, tan, layer.handlesize);
pn = pn - p1;
delta = pn.magnitude; //Vector3.Distance(p, pn);
if (Vector3.Dot(tan, pn) < 0.0f)
{
delta = -delta;
}
al = section.alpha + delta * 0.0005f;
if (al != layer.sections[i].alpha)
{
if (i > 0)
{
if (al < layer.sections[i - 1].alpha)
{
al = layer.sections[i - 1].alpha;
}
}
if (i < layer.sections.Count - 1)
{
if (al > layer.sections[i + 1].alpha)
{
al = layer.sections[i + 1].alpha;
}
}
layer.sections[i].alpha = al;
}
if (delta != 0.0f)
{
GUI.changed = true;
loft.rebuild = true;
EditorUtility.SetDirty(target);
}
}
if (layer.sections.Count > 0)
{
if (layer.sections[0].alpha != 0.0f)
{
layer.sections[0].alpha = 0.0f;
}
for (int i = 1; i < layer.sections.Count - 1; i++)
{
if (layer.sections[i].alpha <= layer.sections[i - 1].alpha)
{
layer.sections[i - 1].alpha = layer.sections[i].alpha;
}
if (layer.sections[i].alpha >= layer.sections[i + 1].alpha)
{
layer.sections[i].alpha = layer.sections[i + 1].alpha;
}
}
if (layer.sections[layer.sections.Count - 1].alpha != 1.0f)
{
layer.sections[layer.sections.Count - 1].alpha = 1.0f;
}
}
}
public override int BuildMesh(MegaShapeLoft loft, int triindex)
{
trisstart = triindex;
if (Lock)
{
return(triindex + ((crosses - 2) * (evert - svert)));
}
if (layerPath == null || layerSection == null)
{
return(triindex);
}
MegaSpline pathspline = layerPath.splines[curve];
MegaSpline sectionspline = layerSection.splines[crosscurve];
// so for each loft section run through
int vi = 0;
Vector2 uv = Vector2.zero;
Vector3 p = Vector3.zero;
Vector3 scl = Vector3.one;
float scalemultx = 1.0f;
float scalemulty = 1.0f;
Vector3 cmax = crossmax;
cmax.x = 0.0f;
cmax.z = 0.0f;
Vector3 cmin = crossmin;
cmin.x = 0.0f;
cmin.z = 0.0f;
Vector3 totaloff = Vector3.zero;
float uvstart = pathStart;
if (UVOrigin == MegaLoftUVOrigin.SplineStart)
{
uvstart = 0.0f;
}
Matrix4x4 twisttm = Matrix4x4.identity;
Color col1 = color;
Matrix4x4 tm;
Vector3 lastup = loft.up;
float calpha = 0.0f;
for (int cr = 0; cr < crosses; cr++)
{
float a = ((float)cr / (float)(crosses - 1));
float alpha = pathStart + (pathLength * a);
totaloff = offset;
if (useOffsetX)
{
totaloff.x += offsetCrvX.Evaluate(alpha);
}
if (useOffsetY)
{
totaloff.y += offsetCrvY.Evaluate(alpha);
}
if (useOffsetZ)
{
totaloff.z += offsetCrvZ.Evaluate(alpha);
}
// get the point on the spline
if (frameMethod == MegaFrameMethod.New)
{
tm = loft.GetDeformMatNewMethod(pathspline, alpha, true, alignCross, ref lastup);
}
else
{
tm = loft.GetDeformMatNew(pathspline, alpha, true, alignCross);
}
if (useTwistCrv)
{
float twist = twistCrv.Evaluate(alpha) * twistAmt;
float tw1 = pathspline.GetTwist(alpha);
MegaShapeUtils.RotateZ(ref twisttm, Mathf.Deg2Rad * (twist - tw1));
tm = tm * twisttm;
}
if (useCrossScaleCrv)
{
float sa = Mathf.Repeat(a + scaleoff, 1.0f);
scalemultx = crossScaleCrv.Evaluate(sa);
}
if (!sepscale)
{
scalemulty = scalemultx;
}
else
{
if (useCrossScaleCrvY)
{
float sa = Mathf.Repeat(a + scaleoffY, 1.0f);
scalemulty = crossScaleCrvY.Evaluate(sa);
}
}
scl.x = crossScale.x * scalemultx; // Use plus here and have curve as 0010
scl.y = crossScale.y * scalemulty;
Vector3 crrot = cmax;
crrot.y *= scl.y;
Vector3 cminrot = cmin;
cminrot.y *= scl.y;
// Now need to loop through all the meshsections
for (int m = 0; m < meshsections.Count; m++)
{
MegaMeshSection ms = meshsections[m];
MegaMaterialSection mats = sections[ms.mat];
if (mats.Enabled)
{
if (loft.useColors)
{
if (mats.colmode == MegaLoftColMode.Loft)
{
calpha = a;
}
else
{
calpha = alpha;
}
calpha = Mathf.Repeat(calpha + mats.coloffset, 1.0f);
col1.r = mats.colR.Evaluate(calpha);
col1.g = mats.colG.Evaluate(calpha);
col1.b = mats.colB.Evaluate(calpha);
col1.a = mats.colA.Evaluate(calpha);
}
for (int v = 0; v < ms.cverts.Count; v++)
{
p.x = ms.cverts[v].x * scl.x;
p.y = ms.cverts[v].y * scl.y; // Curve for this value
p.z = ms.cverts[v].z * scl.z;
p = tm.MultiplyPoint3x4(p);
uv.x = alpha - uvstart; //pathStart;
uv.y = ms.cuvs[v].y; // - crossStart; // again not sure here start;
if (mats.physuv)
{
uv.x *= pathspline.length;
uv.y *= sectionspline.length;
}
else
{
if (mats.uvcalcy)
{
//uv.x = ((a * LoftLength) / sectionspline.length) - uvstart;
uv.x = ((alpha * pathspline.length) / sectionspline.length) - uvstart;
}
}
if (conform)
{
ms.verts1.Add(p + totaloff);
}
else
{
ms.verts.Add(p + totaloff);
}
if (mats.swapuv)
{
float ux = uv.x;
uv.x = uv.y;
uv.y = ux;
}
uv.x *= mats.UVScale.x;
uv.y *= mats.UVScale.y;
uv.x += mats.UVOffset.x;
uv.y += mats.UVOffset.y;
ms.uvs.Add(uv); //[vi] = uv;
if (loft.useColors)
{
ms.cols.Add(col1);
}
vi++;
}
}
}
}
//OptmizeMesh();
// Faces
int index = triindex;
int fi = 0; // Calc this
if (enabled)
{
if (flip)
{
for (int m = 0; m < meshsections.Count; m++)
{
MegaMeshSection ms = meshsections[m];
MegaMaterialSection mats = sections[ms.mat];
if (mats.Enabled)
{
for (int cr = 0; cr < crosses - 1; cr++)
{
for (int f = 0; f < ms.cverts.Count - 1; f++)
{
ms.tris.Add(index + f);
ms.tris.Add(index + f + 1);
ms.tris.Add(index + f + 1 + ms.cverts.Count);
ms.tris.Add(index + f);
ms.tris.Add(index + f + 1 + ms.cverts.Count);
ms.tris.Add(index + f + ms.cverts.Count);
fi += 6;
}
index += ms.cverts.Count;
}
index += ms.cverts.Count;
}
}
}
else
{
for (int m = 0; m < meshsections.Count; m++)
{
MegaMeshSection ms = meshsections[m];
MegaMaterialSection mats = sections[ms.mat];
if (mats.Enabled)
{
for (int cr = 0; cr < crosses - 1; cr++)
{
for (int f = 0; f < ms.cverts.Count - 1; f++)
{
ms.tris.Add(index + f + 1 + ms.cverts.Count);
ms.tris.Add(index + f + 1);
ms.tris.Add(index + f);
ms.tris.Add(index + f + ms.cverts.Count);
ms.tris.Add(index + f + 1 + ms.cverts.Count);
ms.tris.Add(index + f);
fi += 6;
}
index += ms.cverts.Count;
}
index += ms.cverts.Count;
}
}
}
}
if (conform)
{
CalcBounds();
DoConform(loft);
}
return(triindex + fi); //triindex;
}
static void DrawPath(MegaLoftLayerComplex layer)
{
MegaShapeLoft loft = layer.gameObject.GetComponent <MegaShapeLoft>();
if (loft == null)
{
return;
}
if (layer.layerPath == null)
{
return;
}
if (layer.sections == null || layer.sections.Count < 2)
{
return;
}
for (int i = 0; i < layer.sections.Count; i++)
{
if (layer.sections[i].crossverts == null || layer.sections[i].crossverts.Length == 0)
{
return;
}
}
MegaSpline pathspline = layer.layerPath.splines[layer.curve];
Matrix4x4 pathtm = Matrix4x4.identity;
if (layer.SnapToPath)
{
pathtm = layer.layerPath.transform.localToWorldMatrix;
}
Color col = Gizmos.color;
Matrix4x4 twisttm = Matrix4x4.identity;
Matrix4x4 tm;
Vector3 lastup = locup;
for (int i = 0; i < layer.sections.Count; i++)
{
MegaLoftSection section = layer.sections[i];
//if ( layer.useTwistCrv )
//{
// float twist = layer.twistCrv.Evaluate(section.alpha);
// MegaShapeUtils.RotateZ(ref twisttm, Mathf.Deg2Rad * twist);
// tm = pathtm * layer.GetDeformMat(pathspline, section.alpha, layer.layerPath.normalizedInterp) * twisttm; //loft.);
//}
//else
// tm = pathtm * layer.GetDeformMat(pathspline, section.alpha, layer.layerPath.normalizedInterp); //loft.);
if (layer.useTwistCrv)
{
float twist = layer.twistCrv.Evaluate(section.alpha);
float tw1 = pathspline.GetTwist(section.alpha);
MegaShapeUtils.RotateZ(ref twisttm, Mathf.Deg2Rad * (twist - tw1));
if (layer.frameMethod == MegaFrameMethod.Old)
{
tm = pathtm * layer.GetDeformMat(pathspline, section.alpha, layer.layerPath.normalizedInterp) * twisttm;
}
else
{
tm = pathtm * layer.GetDeformMatNewMethod(pathspline, section.alpha, layer.layerPath.normalizedInterp, ref lastup) * twisttm;
}
}
else
{
if (layer.frameMethod == MegaFrameMethod.Old)
{
tm = pathtm * layer.GetDeformMat(pathspline, section.alpha, layer.layerPath.normalizedInterp);
}
else
{
tm = pathtm * layer.GetDeformMatNewMethod(pathspline, section.alpha, layer.layerPath.normalizedInterp, ref lastup);
}
}
Vector3 p1 = section.crossverts[0];
float offx = 0.0f;
float offy = 0.0f;
float offz = 0.0f;
float sclx = 1.0f;
float scly = 1.0f;
if (layer.useScaleXCrv)
{
p1.x *= layer.scaleCrvX.Evaluate(section.alpha);
}
if (layer.useScaleYCrv)
{
p1.y *= layer.scaleCrvY.Evaluate(section.alpha);
}
if (layer.useOffsetX)
{
offx = layer.offsetCrvX.Evaluate(section.alpha);
}
if (layer.useOffsetY)
{
offy = layer.offsetCrvY.Evaluate(section.alpha);
}
if (layer.useOffsetZ)
{
offz = layer.offsetCrvZ.Evaluate(section.alpha);
}
if (layer.useScaleXCrv)
{
sclx = layer.scaleCrvX.Evaluate(section.alpha);
}
if (layer.useScaleYCrv)
{
scly = layer.scaleCrvY.Evaluate(section.alpha);
}
p1 = tm.MultiplyPoint3x4(p1);
p1 += layer.offset;
Gizmos.color = seccol; //Color.red;
Vector3 mid = Vector3.zero;
for (int v = 1; v < section.crossverts.Length; v++)
{
Vector3 p = section.crossverts[v];
p.x *= sclx;
p.y *= scly;
p.x += offx;
p.y += offy;
p.z += offz;
p = tm.MultiplyPoint3x4(p);
p += layer.offset;
Gizmos.DrawLine(loft.transform.TransformPoint(p1), loft.transform.TransformPoint(p));
p1 = p;
if (v == section.crossverts.Length / 2)
{
mid = p;
}
}
Handles.color = Color.white;
Handles.Label(loft.transform.TransformPoint(mid), "Cross: " + i);
Gizmos.color = col;
}
// Draw outside edge
Vector3 sclc = Vector3.one;
float lerp = 0.0f;
// The position stuff here is waht we could use instead of mesh verts
Vector3 last = Vector3.zero;
Vector3 last1 = Vector3.zero;
lastup = locup;
for (float alpha = 0.0f; alpha <= 1.0f; alpha += 0.005f)
{
if (layer.useScaleXCrv)
{
sclc.x = layer.scaleCrvX.Evaluate(alpha);
}
if (layer.useScaleYCrv)
{
sclc.y = layer.scaleCrvY.Evaluate(alpha);
}
//if ( layer.useTwistCrv )
//{
// float twist = layer.twistCrv.Evaluate(alpha);
// MegaShapeUtils.RotateZ(ref twisttm, Mathf.Deg2Rad * twist);
// tm = pathtm * layer.GetDeformMat(layer.layerPath.splines[layer.curve], alpha, layer.layerPath.normalizedInterp) * twisttm; //loft.);
//}
//else
// tm = pathtm * layer.GetDeformMat(layer.layerPath.splines[layer.curve], alpha, layer.layerPath.normalizedInterp); //loft.);
if (layer.useTwistCrv)
{
float twist = layer.twistCrv.Evaluate(alpha);
float tw1 = pathspline.GetTwist(alpha);
MegaShapeUtils.RotateZ(ref twisttm, Mathf.Deg2Rad * (twist - tw1));
if (layer.frameMethod == MegaFrameMethod.Old)
{
tm = pathtm * layer.GetDeformMat(pathspline, alpha, layer.layerPath.normalizedInterp) * twisttm;
}
else
{
tm = pathtm * layer.GetDeformMatNewMethod(pathspline, alpha, layer.layerPath.normalizedInterp, ref lastup) * twisttm;
}
}
else
{
if (layer.frameMethod == MegaFrameMethod.Old)
{
tm = pathtm * layer.GetDeformMat(pathspline, alpha, layer.layerPath.normalizedInterp);
}
else
{
tm = pathtm * layer.GetDeformMatNewMethod(pathspline, alpha, layer.layerPath.normalizedInterp, ref lastup);
}
}
// Need to get the crosssection for the given alpha and the lerp value
int csect = layer.GetSection(alpha, out lerp);
lerp = layer.ease.easing(0.0f, 1.0f, lerp);
MegaLoftSection cs1 = layer.sections[csect];
MegaLoftSection cs2 = layer.sections[csect + 1];
Vector3 p = Vector3.Lerp(cs1.crossverts[0], cs2.crossverts[0], lerp); // * sclc;
Vector3 p1 = Vector3.Lerp(cs1.crossverts[cs1.crossverts.Length - 1], cs2.crossverts[cs2.crossverts.Length - 1], lerp); // * sclc;
if (layer.useScaleXCrv)
{
p.x *= sclc.x;
p1.x *= sclc.x;
}
if (layer.useScaleYCrv)
{
p.y *= sclc.y;
p1.y *= sclc.y;
}
if (layer.useOffsetX)
{
p.x += layer.offsetCrvX.Evaluate(alpha);
p1.x += layer.offsetCrvX.Evaluate(alpha);
}
if (layer.useOffsetY)
{
p.y += layer.offsetCrvY.Evaluate(alpha);
p1.y += layer.offsetCrvY.Evaluate(alpha);
}
if (layer.useOffsetZ)
{
p.z += layer.offsetCrvZ.Evaluate(alpha);
p1.z += layer.offsetCrvZ.Evaluate(alpha);
}
p = tm.MultiplyPoint3x4(p);
p += layer.offset;
p1 = tm.MultiplyPoint3x4(p1);
p1 += layer.offset;
if (alpha > 0.0f)
{
Gizmos.DrawLine(loft.transform.TransformPoint(last), loft.transform.TransformPoint(p));
Gizmos.DrawLine(loft.transform.TransformPoint(last1), loft.transform.TransformPoint(p1));
}
last = p;
last1 = p1;
}
}