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; }