public Matrix4x4 GetDeformMat(MegaSpline spline, float alpha, bool interp) { int k = -1; //Vector3 ps = spline.Interpolate(alpha, interp, ref k); Vector3 ps = spline.InterpCurve3D(alpha, interp, ref k); alpha += 0.01f; // TODO: Tangent value if (spline.closed) { alpha = alpha % 1.0f; } //Vector3 ps1 = spline.Interpolate(alpha, interp, ref k); Vector3 ps1 = spline.InterpCurve3D(alpha, interp, ref k); ps1.x -= ps.x; ps1.y -= ps.y; ps1.z -= ps.z; ps1.y *= PathTeeter; //wtm1.SetTRS(ps, Quaternion.LookRotation(ps1, locup), Vector3.one); MegaMatrix.SetTR(ref wtm1, ps, Quaternion.LookRotation(ps1, locup)); return(wtm1); }
public Matrix4x4 GetSplineMat(MegaSpline spline, float alpha, bool interp, ref Vector3 lastup) { int k = -1; Vector3 ps = spline.InterpCurve3D(alpha, interp, ref k); alpha += 0.01f; // TODO: Tangent value if (spline.closed) { alpha = alpha % 1.0f; } Vector3 ps1 = spline.InterpCurve3D(alpha, interp, ref k); Vector3 ps2; ps1.x = ps2.x = ps1.x - ps.x; ps1.y = ps2.y = ps1.y - ps.y; ps1.z = ps2.z = ps1.z - ps.z; MegaMatrix.SetTR(ref wtm1, ps, Quaternion.LookRotation(ps1, lastup)); //locup)); // calc new up value ps2 = ps2.normalized; Vector3 cross = Vector3.Cross(ps2, lastup); lastup = Vector3.Cross(cross, ps2); return(wtm1); }
public override Vector3 Map(int i, Vector3 p) { p = tm.MultiplyPoint3x4(p); // Dont need either, so saving 3 vector mat mults but gaining a mat mult float alpha; float tws = 0.0f; if (UseStretchCurve) { float str = stretchCurve.Evaluate(Mathf.Repeat(p.z * ovlen + usepercent, 1.0f)) * stretch; alpha = (p.z * ovlen * str) + usepercent; //(percent / 100.0f); // can precalc this } else { alpha = (p.z * ovlen * stretch) + usepercent; //(percent / 100.0f); // can precalc this } Vector3 ps = path.InterpCurve3D(curve, alpha, path.normalizedInterp, ref tws); // - start; Vector3 ps1 = path.InterpCurve3D(curve, alpha + usetan, path.normalizedInterp); // - start; if (path.splines[curve].closed) { alpha = Mathf.Repeat(alpha, 1.0f); } else { alpha = Mathf.Clamp01(alpha); } Quaternion tw = Quaternion.identity; if (UseTwistCurve) { float twst = twistCurve.Evaluate(alpha) * twist; tw = Quaternion.AngleAxis(twst + tws, Vector3.forward); } else { tw = Quaternion.AngleAxis((twist * alpha) + tws, Vector3.forward); } ps1.x -= ps.x; ps1.y -= ps.y; ps1.z -= ps.z; Quaternion rotation = Quaternion.LookRotation(ps1, Up) * tw; Matrix4x4 wtm = Matrix4x4.identity; MegaMatrix.SetTR(ref wtm, ps, rotation); wtm = mat * wtm; ps.x = (p.x * wtm[0]) + (p.y * wtm[4]) + wtm[12]; ps.y = (p.x * wtm[1]) + (p.y * wtm[5]) + wtm[13]; ps.z = (p.x * wtm[2]) + (p.y * wtm[6]) + wtm[14]; return(ps); //wtm.MultiplyPoint3x4(p); }
public override Vector3 Map(int i, Vector3 p) { p = tm.MultiplyPoint3x4(p); // Dont need either, so saving 3 vector mat mults but gaining a mat mult float alpha; float tws = 0.0f; if (UseStretchCurve) { float str = stretchCurve.Evaluate(Mathf.Repeat(p.z * ovlen + usepercent, 1.0f)) * stretch; alpha = (p.z * ovlen * str) + usepercent; //(percent / 100.0f); // can precalc this } else { alpha = (p.z * ovlen * stretch) + usepercent; //(percent / 100.0f); // can precalc this } //float alpha = ((p.z * stretch) / path.splines[0].length) + usepercent; //(percent / 100.0f); // can precalc this //alpha = (p.z * ovlen * stretch) + usepercent; //(percent / 100.0f); // can precalc this Vector3 ps = path.InterpCurve3D(curve, alpha, path.normalizedInterp, ref tws) - start; Vector3 ps1 = path.InterpCurve3D(curve, alpha + usetan, path.normalizedInterp) - start; if (path.splines[curve].closed) { alpha = Mathf.Repeat(alpha, 1.0f); } else { alpha = Mathf.Clamp01(alpha); } if (UseTwistCurve) { float twst = twistCurve.Evaluate(alpha) * twist; tw = Quaternion.AngleAxis(twst + tws, Vector3.forward); } else { tw = Quaternion.AngleAxis(tws + (twist * alpha), Vector3.forward); } Vector3 relativePos = ps1 - ps; Quaternion rotation = Quaternion.LookRotation(relativePos, Up) * tw; //wtm.SetTRS(ps, rotation, Vector3.one); Matrix4x4 wtm = Matrix4x4.identity; MegaMatrix.SetTR(ref wtm, ps, rotation); wtm = mat * wtm; p.z = 0.0f; return(wtm.MultiplyPoint3x4(p)); //return invtm.MultiplyPoint3x4(p); }
public Matrix4x4 GetDeformMatNew(MegaSpline spline, float alpha, bool interp, float align) { int k = -1; Vector3 ps; Vector3 ps1; if (spline.closed) { alpha = Mathf.Repeat(alpha, 1.0f); ps = spline.Interpolate(alpha, interp, ref k); } else { ps = spline.InterpCurve3D(alpha, interp, ref k); } alpha += tangent; //0.01f; if (spline.closed) { alpha = alpha % 1.0f; ps1 = spline.Interpolate(alpha, interp, ref k); } else { ps1 = spline.InterpCurve3D(alpha, interp, ref k); } ps1.x -= ps.x; ps1.y -= ps.y; // * align; ps1.z -= ps.z; ps1.y *= align; //wtm.SetTRS(ps, Quaternion.LookRotation(ps1, up), Vector3.one); Quaternion rot = lastrot; if (ps1 != Vector3.zero) { rot = Quaternion.LookRotation(ps1, up); } MegaMatrix.SetTR(ref wtm, ps, rot); lastrot = rot; return(wtm); }
Vector3 Deform(Vector3 p, MegaShape path, float percent, float off, Vector3 scale, float removeDof, Vector3 locoff, Vector3 sploff) { 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 / path.splines[curve].length) + percent; float tw1 = 0.0f; Vector3 ps = pathtm.MultiplyPoint(path.InterpCurve3D(curve, alpha, path.normalizedInterp, ref tw1) + sploff); Vector3 ps1 = pathtm.MultiplyPoint(path.InterpCurve3D(curve, alpha + (tangent * 0.001f), path.normalizedInterp) + sploff); if (path.splines[curve].closed) { alpha = Mathf.Repeat(alpha, 1.0f); } else { alpha = Mathf.Clamp01(alpha); } if (useTwist) { //float tw1 = path.splines[curve].GetTwist(alpha); tw = meshrot * Quaternion.AngleAxis((twist * twistCrv.Evaluate(alpha)) + tw1, Vector3.forward); } Vector3 relativePos = ps1 - ps; relativePos.y *= removeDof; Quaternion rotation = Quaternion.LookRotation(relativePos) * tw; // * meshrot; //wtm.SetTRS(ps, rotation, Vector3.one); MegaMatrix.SetTR(ref wtm, ps, rotation); wtm = mat * wtm; p.z = 0.0f; return(wtm.MultiplyPoint3x4(p)); }
// Should be a spline method public Matrix4x4 GetDeformMat(MegaSpline spline, float alpha, bool interp) { int k = -1; Vector3 ps; Vector3 ps1; if (spline.closed) { alpha = Mathf.Repeat(alpha, 1.0f); ps = spline.Interpolate(alpha, interp, ref k); } else { ps = spline.InterpCurve3D(alpha, interp, ref k); } alpha += tangent; //0.01f; if (spline.closed) { alpha = alpha % 1.0f; ps1 = spline.Interpolate(alpha, interp, ref k); } else { ps1 = spline.InterpCurve3D(alpha, interp, ref k); } ps1.x -= ps.x; ps1.y = 0.0f; //ps.y; ps1.z -= ps.z; //wtm.SetTRS(ps, Quaternion.LookRotation(ps1, up), Vector3.one); MegaMatrix.SetTR(ref wtm, ps, Quaternion.LookRotation(ps1, up)); return(wtm); }
public Matrix4x4 GetDeformMatNewMethod(MegaSpline spline, float alpha, bool interp, ref Vector3 lastup) { int k = -1; //Vector3 ps = spline.Interpolate(alpha, interp, ref k); Vector3 ps = spline.InterpCurve3D(alpha, interp, ref k); alpha += 0.01f; // TODO: Tangent value if (spline.closed) { alpha = alpha % 1.0f; } //Vector3 ps1 = spline.Interpolate(alpha, interp, ref k); Vector3 ps1 = spline.InterpCurve3D(alpha, interp, ref k); Vector3 ps2; ps1.x = ps2.x = ps1.x - ps.x; ps1.y = ps2.y = ps1.y - ps.y; ps1.z = ps2.z = ps1.z - ps.z; //ps1.x -= ps.x; //ps1.y -= ps.y; //ps1.z -= ps.z; ps1.y *= PathTeeter; //wtm1.SetTRS(ps, Quaternion.LookRotation(ps1, locup), Vector3.one); MegaMatrix.SetTR(ref wtm1, ps, Quaternion.LookRotation(ps1, lastup)); //locup)); // calc new up value ps2 = ps2.normalized; Vector3 cross = Vector3.Cross(ps2, lastup); lastup = Vector3.Cross(cross, ps2); return(wtm1); }
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)); }
// Keep track of up method public Matrix4x4 GetDeformMatNewMethod(MegaSpline spline, float alpha, bool interp, float align, ref Vector3 lastup) { int k = -1; Vector3 ps; Vector3 ps1; Vector3 ps2; if (spline.closed) { alpha = Mathf.Repeat(alpha, 1.0f); ps = spline.Interpolate(alpha, interp, ref k); } else { ps = spline.InterpCurve3D(alpha, interp, ref k); } alpha += tangent; //0.01f; if (spline.closed) { alpha = alpha % 1.0f; ps1 = spline.Interpolate(alpha, interp, ref k); } else { ps1 = spline.InterpCurve3D(alpha, interp, ref k); } ps1.x = ps2.x = ps1.x - ps.x; ps1.y = ps2.y = ps1.y - ps.y; ps1.z = ps2.z = ps1.z - ps.z; //ps1.x -= ps.x; //ps1.y -= ps.y; // * align; //ps1.z -= ps.z; ps1.y *= align; Quaternion rot = lastrot; if (ps1 != Vector3.zero) { rot = Quaternion.LookRotation(ps1, lastup); } //wtm.SetTRS(ps, Quaternion.LookRotation(ps1, up), Vector3.one); //Debug.Log("lupin: " + lastup); MegaMatrix.SetTR(ref wtm, ps, rot); //Quaternion.LookRotation(ps1, lastup)); lastrot = rot; // calc new up value ps2 = ps2.normalized; Vector3 cross = Vector3.Cross(ps2, lastup); lastup = Vector3.Cross(cross, ps2); //Debug.Log("lupout: " + lastup); return(wtm); }
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)); }