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;
}
public override Vector3 SampleSplines(MegaShapeLoft loft, float ca, float pa)
{
Vector3 p = Vector3.zero;
float lerp = 0.0f;
Matrix4x4 pathtm = Matrix4x4.identity;
//if ( SnapToPath )
//pathtm = layerPath.transform.localToWorldMatrix;
Matrix4x4 twisttm = Matrix4x4.identity;
//Vector3 sclc = Vector2.one;
Matrix4x4 tm;
float offx = 0.0f;
float offy = 0.0f;
float offz = 0.0f;
//bool clsd = layerPath.splines[curve].closed;
Vector3 lastup = locup;
float alpha = pa; //(float)pi / (float)PathSteps;
float pathalpha = pathStart + (pathLength * alpha);
//if ( clsd )
//pathalpha = Mathf.Repeat(pathalpha, 1.0f);
//if ( useScaleXCrv )
//sclc.x = scaleCrvX.Evaluate(pathalpha);
//if ( useScaleYCrv )
//sclc.y = scaleCrvY.Evaluate(pathalpha);
if (useTwistCrv)
{
float twist = twistCrv.Evaluate(pathalpha);
float tw1 = layerPath.splines[curve].GetTwist(pathalpha);
MegaShapeUtils.RotateZ(ref twisttm, Mathf.Deg2Rad * (twist - tw1));
if (frameMethod == MegaFrameMethod.Old)
{
tm = pathtm * GetDeformMat(layerPath.splines[curve], pathalpha, layerPath.normalizedInterp) * twisttm;
}
else
{
tm = pathtm * GetDeformMatNewMethod(layerPath.splines[curve], pathalpha, layerPath.normalizedInterp, ref lastup) * twisttm;
}
}
else
{
if (frameMethod == MegaFrameMethod.Old)
{
tm = pathtm * GetDeformMat(layerPath.splines[curve], pathalpha, layerPath.normalizedInterp);
}
else
{
tm = pathtm * GetDeformMatNewMethod(layerPath.splines[curve], pathalpha, layerPath.normalizedInterp, ref lastup);
}
}
// Need to get the crosssection for the given alpha and the lerp value
int csect = GetSection(pathalpha, out lerp);
lerp = ease.easing(0.0f, 1.0f, lerp);
Vector3 off = Vector3.zero;
if (loftsections[csect].snap)
{
off = loftsections[0].shape.splines[loftsections[0].curve].knots[0].p - loftsections[csect].shape.splines[loftsections[csect].curve].knots[0].p;
}
else
{
off = Vector3.zero;
}
Vector3 crossp1 = GetCross(csect, ca, off);
if (loftsections[csect + 1].snap)
{
off = loftsections[0].shape.splines[loftsections[0].curve].knots[0].p - loftsections[csect + 1].shape.splines[loftsections[csect + 1].curve].knots[0].p;
}
else
{
off = Vector3.zero;
}
Vector3 crossp2 = GetCross(csect + 1, ca, off);
if (useOffsetX)
{
offx = offsetCrvX.Evaluate(pathalpha);
}
if (useOffsetY)
{
offy = offsetCrvY.Evaluate(pathalpha);
}
if (useOffsetZ)
{
offz = offsetCrvZ.Evaluate(pathalpha);
}
//float size = 1.0f / layerPath.splines[0].length;
p = Vector3.Lerp(crossp1, crossp2, lerp);
//if ( useScaleXCrv )
//p.x *= sclc.x;
//if ( useScaleYCrv )
//p.y *= sclc.y;
p.x += offx;
p.y += offy;
p.z += offz;
p = tm.MultiplyPoint3x4(p);
p += offset;
return(p);
}
public override int BuildMesh(MegaShapeLoft loft, int triindex)
{
if (Lock)
{
return(triindex);
}
if (layerPath == null || layerPath.splines == null || layerPath.splines.Count == 0)
{
return(triindex);
}
if (loftsections.Count < 2) //== 0 )
{
return(triindex);
}
Vector2 uv = Vector2.zero;
Vector3 p = Vector3.zero;
//int wc = 1; //ActualCrossVerts;
float lerp = 0.0f;
Matrix4x4 pathtm = Matrix4x4.identity;
//if ( SnapToPath )
// pathtm = layerPath.transform.localToWorldMatrix;
Matrix4x4 twisttm = Matrix4x4.identity;
//Vector3 sclc = Vector2.one;
Matrix4x4 tm;
float offx = 0.0f;
float offy = 0.0f;
float offz = 0.0f;
MegaSpline pathspline = layerPath.splines[curve];
//bool clsd = layerPath.splines[curve].closed;
float uvstart = pathStart;
if (UVOrigin == MegaLoftUVOrigin.SplineStart)
{
uvstart = 0.0f;
}
Vector3 lastup = locup;
Color col1 = color;
float calpha = 0.0f;
//float uvalpha = 0.0f;
for (int pi = 0; pi < crosses; pi++)
{
float alpha = (float)pi / (float)(crosses - 1); //PathSteps;
float pathalpha = pathStart + (pathLength * alpha);
//uvalpha = pathalpha;
//if ( clsd )
// pathalpha = Mathf.Repeat(pathalpha, 1.0f);
//if ( useScaleXCrv )
// sclc.x = scaleCrvX.Evaluate(pathalpha);
//if ( useScaleYCrv )
// sclc.y = scaleCrvY.Evaluate(pathalpha);
if (useTwistCrv)
{
float twist = twistCrv.Evaluate(pathalpha);
float tw1 = layerPath.splines[curve].GetTwist(pathalpha);
MegaShapeUtils.RotateZ(ref twisttm, Mathf.Deg2Rad * (twist - tw1));
if (frameMethod == MegaFrameMethod.Old)
{
tm = pathtm * GetDeformMat(layerPath.splines[curve], pathalpha, layerPath.normalizedInterp) * twisttm;
}
else
{
tm = pathtm * GetDeformMatNewMethod(layerPath.splines[curve], pathalpha, layerPath.normalizedInterp, ref lastup) * twisttm;
}
}
else
{
if (frameMethod == MegaFrameMethod.Old)
{
tm = pathtm * GetDeformMat(layerPath.splines[curve], pathalpha, layerPath.normalizedInterp);
}
else
{
tm = pathtm * GetDeformMatNewMethod(layerPath.splines[curve], pathalpha, layerPath.normalizedInterp, ref lastup);
}
}
// Need to get the crosssection for the given alpha and the lerp value
int csect = GetSection(pathalpha, out lerp);
lerp = ease.easing(0.0f, 1.0f, lerp);
MegaLoftSection cs1 = loftsections[csect];
MegaLoftSection cs2 = loftsections[csect + 1];
//MegaSpline sectionspline = cs1.shape.splines[cs1.curve];
if (useOffsetX)
{
offx = offsetCrvX.Evaluate(pathalpha);
}
if (useOffsetY)
{
offy = offsetCrvY.Evaluate(pathalpha);
}
if (useOffsetZ)
{
offz = offsetCrvZ.Evaluate(pathalpha);
}
for (int i = 0; i < cs1.meshsections.Count; i++)
{
MegaMeshSection ms0 = loftsections[0].meshsections[i];
//float slen = sectionspline.knots[ms0.lastknot].length - sectionspline.knots[ms0.firstknot].length;
MegaMaterialSection mats = sections[ms0.mat];
if (mats.Enabled)
{
MegaMeshSection ms1 = cs1.meshsections[i];
MegaMeshSection ms2 = cs2.meshsections[i];
if (loft.useColors)
{
if (mats.colmode == MegaLoftColMode.Loft)
{
calpha = alpha;
}
else
{
calpha = pathalpha;
}
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 < ms1.cverts.Count; v++)
{
p = Vector3.Lerp(ms1.cverts[v], ms2.cverts[v], lerp); // Easing here?
//if ( useScaleXCrv )
// p.x *= sclc.x;
//if ( useScaleYCrv )
// p.y *= sclc.y;
p.x += offx;
p.y += offy;
p.z += offz;
p = tm.MultiplyPoint3x4(p);
p += offset;
//int ix = (pi * wc) + v;
if (conform)
{
ms0.verts1.Add(p);
}
else
{
ms0.verts.Add(p);
}
uv.y = Mathf.Lerp(ms1.cuvs[v].y, ms2.cuvs[v].y, lerp);
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 *= ms0.len; //sectionspline.length;
}
else
{
if (mats.uvcalcy)
{
//uv.x = ((alpha * LoftLength) / sectionspline.length) - uvstart;
uv.x = ((alpha * pathspline.length) / ms0.len) - uvstart;
}
}
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;
ms0.uvs.Add(uv); //[vi] = uv;
if (loft.useColors)
{
ms0.cols.Add(col1);
}
#if false
uv.y = uvstart + alpha;
uv.x *= UVScale.x;
uv.y *= UVScale.y;
uv.x += UVOffset.x;
uv.y += UVOffset.y;
#endif
//ms0.uvs.Add(uv);
}
}
}
}
int index = triindex;
int fi = 0; // Calc this
if (enabled)
{
if (flip)
{
for (int m = 0; m < loftsections[0].meshsections.Count; m++)
{
MegaMeshSection ms = loftsections[0].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 < loftsections[0].meshsections.Count; m++)
{
MegaMeshSection ms = loftsections[0].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;
}
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;
}
}
}
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;
}
}
public override int BuildMesh(MegaShapeLoft loft, int triindex)
{
if (Lock)
{
return(triindex);
}
if (layerPath == null || layerPath.splines == null || layerPath.splines.Count == 0)
{
return(triindex);
}
if (sections.Count < 2) //== 0 )
{
return(triindex);
}
Vector2 uv = Vector2.zero;
Vector3 p = Vector3.zero;
int wc = ActualCrossVerts;
float lerp = 0.0f;
Matrix4x4 pathtm = Matrix4x4.identity;
if (SnapToPath)
{
pathtm = layerPath.transform.localToWorldMatrix;
}
Matrix4x4 twisttm = Matrix4x4.identity;
Vector3 sclc = Vector2.one;
Matrix4x4 tm;
float offx = 0.0f;
float offy = 0.0f;
float offz = 0.0f;
bool clsd = layerPath.splines[curve].closed;
float uvstart = pathStart;
if (UVOrigin == MegaLoftUVOrigin.SplineStart)
{
uvstart = 0.0f;
}
Vector3 lastup = locup;
for (int pi = 0; pi < PathSteps + 1; pi++)
{
float alpha = (float)pi / (float)PathSteps;
float pathalpha = pathStart + (pathLength * alpha);
if (clsd)
{
pathalpha = Mathf.Repeat(pathalpha, 1.0f);
}
if (useScaleXCrv)
{
sclc.x = scaleCrvX.Evaluate(pathalpha);
}
if (useScaleYCrv)
{
sclc.y = scaleCrvY.Evaluate(pathalpha);
}
if (useTwistCrv)
{
float twist = twistCrv.Evaluate(pathalpha);
float tw1 = layerPath.splines[curve].GetTwist(pathalpha);
MegaShapeUtils.RotateZ(ref twisttm, Mathf.Deg2Rad * (twist - tw1));
if (frameMethod == MegaFrameMethod.Old)
{
tm = pathtm * GetDeformMat(layerPath.splines[curve], pathalpha, layerPath.normalizedInterp) * twisttm;
}
else
{
tm = pathtm * GetDeformMatNewMethod(layerPath.splines[curve], pathalpha, layerPath.normalizedInterp, ref lastup) * twisttm;
}
}
else
{
if (frameMethod == MegaFrameMethod.Old)
{
tm = pathtm * GetDeformMat(layerPath.splines[curve], pathalpha, layerPath.normalizedInterp);
}
else
{
tm = pathtm * GetDeformMatNewMethod(layerPath.splines[curve], pathalpha, layerPath.normalizedInterp, ref lastup);
}
}
// Need to get the crosssection for the given alpha and the lerp value
int csect = GetSection(pathalpha, out lerp);
lerp = ease.easing(0.0f, 1.0f, lerp);
MegaLoftSection cs1 = sections[csect];
MegaLoftSection cs2 = sections[csect + 1];
if (useOffsetX)
{
offx = offsetCrvX.Evaluate(pathalpha);
}
if (useOffsetY)
{
offy = offsetCrvY.Evaluate(pathalpha);
}
if (useOffsetZ)
{
offz = offsetCrvZ.Evaluate(pathalpha);
}
if (planaruv)
{
float size = 1.0f / layerPath.splines[curve].length;
Matrix4x4 uvtm = Matrix4x4.TRS(new Vector3(UVOffset.x, 0.0f, UVOffset.y), Quaternion.Euler(UVRotate.x, UVRotate.y, 0.0f), new Vector3(size * UVScale.x, 1.0f, size * UVScale.y));
for (int v = 0; v < cs1.crossverts.Length; v++)
{
p = Vector3.Lerp(cs1.crossverts[v], cs2.crossverts[v], lerp);
if (useScaleXCrv)
{
p.x *= sclc.x;
}
if (useScaleYCrv)
{
p.y *= sclc.y;
}
p.x += offx;
p.y += offy;
p.z += offz;
p = tm.MultiplyPoint3x4(p);
p += offset;
int ix = (pi * wc) + v;
loftverts[ix] = p;
p.y = 0.0f;
p = uvtm.MultiplyPoint(p);
loftuvs[ix].x = p.x;
loftuvs[ix].y = p.z;
}
}
else
{
for (int v = 0; v < cs1.crossverts.Length; v++)
{
p = Vector3.Lerp(cs1.crossverts[v], cs2.crossverts[v], lerp);
if (useScaleXCrv)
{
p.x *= sclc.x;
}
if (useScaleYCrv)
{
p.y *= sclc.y;
}
p.x += offx;
p.y += offy;
p.z += offz;
p = tm.MultiplyPoint3x4(p);
p += offset;
int ix = (pi * wc) + v;
loftverts[ix] = p;
uv = Vector3.Lerp(cs1.crossuvs[v], cs2.crossuvs[v], lerp);
uv.y = uvstart + alpha;
uv.x *= UVScale.x;
uv.y *= UVScale.y;
uv.x += UVOffset.x;
uv.y += UVOffset.y;
loftuvs[ix] = uv;
}
}
}
// Now need to build faces, normal grid face builder
int fi = 0;
int index = triindex;
if (flip) //Tris )
{
for (int iz = 0; iz < ActualPathSteps - 1; iz++)
{
int kv = iz * (ActualCrossVerts) + index;
for (int ix = 0; ix < ActualCrossVerts - 1; ix++)
{
lofttris[fi + 0] = kv;
lofttris[fi + 1] = kv + wc;
lofttris[fi + 2] = kv + wc + 1;
lofttris[fi + 3] = kv + wc + 1;
lofttris[fi + 4] = kv + 1;
lofttris[fi + 5] = kv;
fi += 6;
kv++;
}
}
}
else
{
for (int iz = 0; iz < ActualPathSteps - 1; iz++)
{
int kv = iz * (ActualCrossVerts) + index;
for (int ix = 0; ix < ActualCrossVerts - 1; ix++)
{
lofttris[fi + 2] = kv;
lofttris[fi + 1] = kv + wc;
lofttris[fi + 0] = kv + wc + 1;
lofttris[fi + 5] = kv + wc + 1;
lofttris[fi + 4] = kv + 1;
lofttris[fi + 3] = kv;
fi += 6;
kv++;
}
}
}
index = triindex + loftverts.Length;
if (capStart)
{
Matrix4x4 uvtm = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0.0f, 0.0f, capStartUVRot), Vector3.one);
// Do uvs here from end points, as we do some clipping in here
for (int i = 0; i < capStartVerts.Length; i++)
{
Vector3 lp = loftverts[i];
capStartVerts[i] = lp;
Vector3 uv1 = crossverts[i];
uv1.y = lp.y;
uv1 = uvtm.MultiplyPoint(uv1);
capStartUVS[i].x = (uv1.x * capStartUVScale.x) + capStartUVOffset.x;
capStartUVS[i].y = (uv1.y * capStartUVScale.y) + capStartUVOffset.y;
}
if (capflip)
{
for (int i = 0; i < capfaces.Count; i += 3)
{
capStartTris[i + 2] = capfaces[i + 0] + index;
capStartTris[i + 1] = capfaces[i + 1] + index;
capStartTris[i + 0] = capfaces[i + 2] + index;
}
}
else
{
for (int i = 0; i < capfaces.Count; i += 3)
{
capStartTris[i + 0] = capfaces[i + 0] + index;
capStartTris[i + 1] = capfaces[i + 1] + index;
capStartTris[i + 2] = capfaces[i + 2] + index;
}
}
fi += capfaces.Count;
index += capStartVerts.Length;
}
if (capEnd)
{
Matrix4x4 uvtm = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0.0f, 0.0f, capEndUVRot), Vector3.one);
int ix = loftverts.Length - capEndVerts.Length;
for (int i = 0; i < capEndVerts.Length; i++)
{
Vector3 lp = loftverts[ix + i];
capEndVerts[i] = lp;
Vector3 uv1 = crossvertsend[i];
uv1.y = lp.y;
uv1 = uvtm.MultiplyPoint(uv1);
capEndUVS[i].x = (uv1.x * capEndUVScale.x) + capEndUVOffset.x;
capEndUVS[i].y = (uv1.y * capEndUVScale.y) + capEndUVOffset.y;
}
if (capflip)
{
for (int i = 0; i < capfacesend.Count; i += 3)
{
capEndTris[i + 0] = capfacesend[i + 0] + index;
capEndTris[i + 1] = capfacesend[i + 1] + index;
capEndTris[i + 2] = capfacesend[i + 2] + index;
}
}
else
{
for (int i = 0; i < capfacesend.Count; i += 3)
{
capEndTris[i + 2] = capfacesend[i + 0] + index;
capEndTris[i + 1] = capfacesend[i + 1] + index;
capEndTris[i + 0] = capfacesend[i + 2] + index;
}
}
fi += capfacesend.Count;
}
return(triindex + fi); //triindex;
}
