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 void CalcMatrix(ref Matrix4x4 mat, float incr) { #if false Matrix4x4 RingTM = Matrix4x4.identity; Matrix4x4 invRingTM = Matrix4x4.identity; int k = 0; Vector3 ThisPosition = hosespline.InterpCurve3D(incr, true, ref k); Vector3 ThisZAxis = (hosespline.InterpCurve3D(incr + 0.001f, true, ref k) - ThisPosition).normalized; Vector3 ThisYAxis = starty; if (yangle > EPSILON) { RotateOnePoint(ref ThisYAxis, Vector3.zero, roty, incr * yangle); } Vector3 ThisXAxis = Vector3.Cross(ThisYAxis, ThisZAxis).normalized; ThisYAxis = Vector3.Cross(ThisZAxis, ThisXAxis); RingTM.SetColumn(0, ThisXAxis); RingTM.SetColumn(1, ThisYAxis); RingTM.SetColumn(2, ThisZAxis); MegaMatrix.SetTrans(ref RingTM, ThisPosition); #endif mat = Tlocal; // * RingTM; }
public override bool Prepare(MegaModContext mc) { if (path != null) { usepercent = percent / 100.0f; ovlen = (1.0f / path.splines[0].length); // * stretch; usetan = (tangent * 0.01f); mat = Matrix4x4.identity; switch (axis) { case MegaAxis.X: MegaMatrix.RotateZ(ref mat, Mathf.PI * 0.5f); break; case MegaAxis.Y: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); break; case MegaAxis.Z: break; } MegaMatrix.RotateZ(ref mat, Mathf.Deg2Rad * rotate); SetAxis(mat); mat = transform.localToWorldMatrix.inverse * path.transform.localToWorldMatrix; return(true); } return(false); }
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 override bool Prepare(MegaModContext mc) { Vector3 s = LatticeSize(); for (int i = 0; i < 3; i++) { if (s[i] == 0.0f) { s[i] = 1.0f; } else { s[i] = 1.0f / s[i]; } } Vector3 c = MegaMatrix.GetTrans(ref tm); MegaMatrix.SetTrans(ref tm, c - bbox.min - Offset); MegaMatrix.Scale(ref tm, s, false); invtm = tm.inverse; return(true); }
public override bool Prepare(MegaModContext mc) { mat = Matrix4x4.identity; //SetTM1(); switch (axis) { case MegaAxis.X: MegaMatrix.RotateZ(ref mat, Mathf.PI * 0.5f); break; case MegaAxis.Y: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); break; case MegaAxis.Z: break; } SetAxis(mat); float xsize = bbox.max.x - bbox.min.x; float zsize = bbox.max.z - bbox.min.z; size = (xsize > zsize) ? xsize : zsize; // Get the percentage to spherify at this time per = Percent / 100.0f; return(true); }
public override bool Prepare(float decay) { tm = transform.worldToLocalMatrix; invtm = tm.inverse; mat = Matrix4x4.identity; switch (axis) { case MegaAxis.X: MegaMatrix.RotateZ(ref mat, Mathf.PI * 0.5f); break; case MegaAxis.Y: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); break; case MegaAxis.Z: break; } SetAxis(mat); CalcBulge(axis, amount, amplify); totaldecay = Decay + decay; if (totaldecay < 0.0f) { totaldecay = 0.0f; } return(true); }
public override bool Prepare(MegaModContext mc) { switch (EAxis) { case MegaEffectAxis.X: doX = true; doY = false; break; case MegaEffectAxis.Y: doX = false; doY = true; break; case MegaEffectAxis.XY: doX = true; doY = true; break; } mat = Matrix4x4.identity; switch (axis) { case MegaAxis.X: MegaMatrix.RotateZ(ref mat, Mathf.PI * 0.5f); l = bbox.max[0] - bbox.min[0]; break; case MegaAxis.Y: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); l = bbox.max[2] - bbox.min[2]; break; case MegaAxis.Z: l = bbox.max[1] - bbox.min[1]; break; } if (l != 0.0f) { ovl = 1.0f / l; } MegaMatrix.RotateY(ref mat, Mathf.Deg2Rad * dir); SetAxis(mat); SetK(amount, crv); return(true); }
public override void DrawGizmo(MegaModContext context) { Gizmos.color = Color.yellow; Matrix4x4 gtm = Matrix4x4.identity; Vector3 pos = gizmoPos; pos.x = -pos.x; pos.y = -pos.y; pos.z = -pos.z; Vector3 scl = gizmoScale; scl.x = 1.0f - (scl.x - 1.0f); scl.y = 1.0f - (scl.y - 1.0f); gtm.SetTRS(pos, Quaternion.Euler(gizmoRot), scl); Matrix4x4 tm = Matrix4x4.identity; switch (axis) { case MegaAxis.X: MegaMatrix.RotateZ(ref tm, 90.0f * Mathf.Deg2Rad); break; case MegaAxis.Z: MegaMatrix.RotateX(ref tm, 90.0f * Mathf.Deg2Rad); break; } Gizmos.matrix = transform.localToWorldMatrix * gtm * tm; BuildMesh(); }
public override bool Prepare(MegaModContext mc) { if (path != null) { if (curve >= path.splines.Count) { curve = 0; } usepercent = percent / 100.0f; ovlen = (1.0f / path.splines[curve].length); // * stretch; usetan = (tangent * 0.01f); //Debug.Log("PathLength " + path.splines[0].length); //path.CalcLength(0, 5); //Debug.Log("CalcPathLength " + path.splines[0].length); //return false; //if ( path.beendrawn == false ) //return false; mat = Matrix4x4.identity; switch (axis) { case MegaAxis.Z: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); break; } MegaMatrix.RotateZ(ref mat, Mathf.Deg2Rad * rotate); SetAxis(mat); start = path.splines[curve].knots[0].p; Vector3 p1 = path.InterpCurve3D(0, 0.01f, path.normalizedInterp); Vector3 up = Vector3.zero; switch (axis) { case MegaAxis.X: up = Vector3.left; break; case MegaAxis.Y: up = Vector3.back; break; case MegaAxis.Z: up = Vector3.up; break; } Quaternion lrot = Quaternion.identity; if (flip) { up = -up; } lrot = Quaternion.FromToRotation(p1 - start, up); mat.SetTRS(Vector3.zero, lrot, Vector3.one); return(true); } return(false); }
public override bool Prepare(float decay) { tm = transform.worldToLocalMatrix; invtm = tm.inverse; mat = Matrix4x4.identity; switch (axis) { case MegaAxis.X: MegaMatrix.RotateZ(ref mat, Mathf.PI * 0.5f); break; case MegaAxis.Y: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); break; case MegaAxis.Z: break; } SetAxis(mat); if (Bias != 0.0f) { bias = 1.0f - (Bias + 100.0f) / 200.0f; if (bias < 0.00001f) { bias = 0.00001f; } if (bias > 0.99999f) { bias = 0.99999f; } bias = Mathf.Log(bias) / Mathf.Log(0.5f); doBias = true; } else { bias = 1.0f; doBias = false; } CalcHeight(axis, angle); totaldecay = Decay + decay; if (totaldecay < 0.0f) { totaldecay = 0.0f; } if (from > to) { from = to; } if (to < from) { to = from; } return(true); }
void Calc() { //if ( from > 0.0f) from = 0.0f; //if ( to < 0.0f ) to = 0.0f; tm = transform.worldToLocalMatrix; invtm = tm.inverse; mat = Matrix4x4.identity; switch (axis) { case MegaAxis.X: MegaMatrix.RotateZ(ref mat, Mathf.PI * 0.5f); break; case MegaAxis.Y: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); break; case MegaAxis.Z: break; } MegaMatrix.RotateY(ref mat, Mathf.Deg2Rad * dir); SetAxis(mat); CalcR(axis, Mathf.Deg2Rad * -angle); if (doRegion) { doRegion = false; float len = to - from; float rat1, rat2; if (len == 0.0f) { rat1 = rat2 = 1.0f; } else { rat1 = to / len; rat2 = from / len; } Vector3 pt; tmAbove = Matrix4x4.identity; MegaMatrix.Translate(ref tmAbove, 0.0f, -to, 0.0f); MegaMatrix.RotateZ(ref tmAbove, -Mathf.Deg2Rad * angle * rat1); MegaMatrix.Translate(ref tmAbove, 0.0f, to, 0.0f); pt = new Vector3(0.0f, to, 0.0f); MegaMatrix.Translate(ref tmAbove, tm.MultiplyPoint3x4(Map(0, invtm.MultiplyPoint3x4(pt))) - pt); tmBelow = Matrix4x4.identity; MegaMatrix.Translate(ref tmBelow, 0.0f, -from, 0.0f); MegaMatrix.RotateZ(ref tmBelow, -Mathf.Deg2Rad * angle * rat2); MegaMatrix.Translate(ref tmBelow, 0.0f, from, 0.0f); pt = new Vector3(0.0f, from, 0.0f); MegaMatrix.Translate(ref tmBelow, tm.MultiplyPoint3x4(Map(0, invtm.MultiplyPoint3x4(pt))) - pt); doRegion = true; } }
// TODO: If we draw like warps do we know if we are the current edited script? public virtual void DrawGizmo(MegaModContext context) { tm = Matrix4x4.identity; MegaMatrix.Translate(ref tm, context.Offset); invtm = tm.inverse; if ( !Prepare(context) ) return; Vector3 min = context.bbox.min; Vector3 max = context.bbox.max; Matrix4x4 gtm = Matrix4x4.identity; Vector3 pos = gizmoPos; pos.x = -pos.x; pos.y = -pos.y; pos.z = -pos.z; Vector3 scl = gizmoScale; scl.x = 1.0f - (scl.x - 1.0f); scl.y = 1.0f - (scl.y - 1.0f); gtm.SetTRS(pos, Quaternion.Euler(gizmoRot), scl); // put sourceObj into context if ( context.mod.sourceObj != null ) Gizmos.matrix = context.mod.sourceObj.transform.localToWorldMatrix * gtm; else Gizmos.matrix = context.go.transform.localToWorldMatrix * gtm; //Gizmos.color = ModCol(); //Color.yellow; corners[0] = new Vector3(min.x, min.y, min.z); corners[1] = new Vector3(min.x, max.y, min.z); corners[2] = new Vector3(max.x, max.y, min.z); corners[3] = new Vector3(max.x, min.y, min.z); corners[4] = new Vector3(min.x, min.y, max.z); corners[5] = new Vector3(min.x, max.y, max.z); corners[6] = new Vector3(max.x, max.y, max.z); corners[7] = new Vector3(max.x, min.y, max.z); DrawEdge(corners[0], corners[1]); DrawEdge(corners[1], corners[2]); DrawEdge(corners[2], corners[3]); DrawEdge(corners[3], corners[0]); DrawEdge(corners[4], corners[5]); DrawEdge(corners[5], corners[6]); DrawEdge(corners[6], corners[7]); DrawEdge(corners[7], corners[4]); DrawEdge(corners[0], corners[4]); DrawEdge(corners[1], corners[5]); DrawEdge(corners[2], corners[6]); DrawEdge(corners[3], corners[7]); ExtraGizmo(context); }
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); }
Vector3 Deform(Vector3 p, float off, MegaRope rope, float alpha) { Vector3 np = rope.Interp(alpha); //tm.MultiplyPoint3x4(rope.Interp(alpha)); T = rope.Velocity(alpha).normalized; wtm = rope.CalcFrame(T, ref N, ref B); //wtm.SetRow(3, np); MegaMatrix.SetTrans(ref wtm, np); return(p); }
public void SetTM1() { tm = Matrix4x4.identity; MegaMatrix.RotateZ(ref tm, -gizmoRot.z * Mathf.Deg2Rad); MegaMatrix.RotateY(ref tm, -gizmoRot.y * Mathf.Deg2Rad); MegaMatrix.RotateX(ref tm, -gizmoRot.x * Mathf.Deg2Rad); MegaMatrix.SetTrans(ref tm, gizmoPos + Offset); invtm = tm.inverse; }
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 override bool Prepare(MegaModContext mc) { if (from > 0.0f) { from = 0.0f; } if (to < 0.0f) { to = 0.0f; } mat = Matrix4x4.identity; switch (axis) { case MegaAxis.X: MegaMatrix.RotateZ(ref mat, Mathf.PI * 0.5f); break; case MegaAxis.Y: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); break; case MegaAxis.Z: break; } MegaMatrix.RotateY(ref mat, Mathf.Deg2Rad * dir); SetAxis(mat); float len = 0.0f; if (!doRegion) { switch (axis) { case MegaAxis.X: len = bbox.max.x - bbox.min.x; break; case MegaAxis.Z: len = bbox.max.y - bbox.min.y; break; case MegaAxis.Y: len = bbox.max.z - bbox.min.z; break; } } else { len = to - from; } if (len == 0.0f) { len = 0.000001f; } amountOverLength = amount / len; return(true); }
void Calc() { tm = transform.worldToLocalMatrix; invtm = tm.inverse; mat = Matrix4x4.identity; tm1 = tm; invtm1 = invtm; switch (axis) { case MegaAxis.X: MegaMatrix.RotateZ(ref mat, Mathf.PI * 0.5f); break; case MegaAxis.Y: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); break; case MegaAxis.Z: break; } MegaMatrix.RotateY(ref mat, Mathf.Deg2Rad * dir); SetAxis(mat); mat = Matrix4x4.identity; switch (axis1) { case MegaAxis.X: MegaMatrix.RotateZ(ref mat, Mathf.PI * 0.5f); break; case MegaAxis.Y: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); break; case MegaAxis.Z: break; } MegaMatrix.RotateY(ref mat, Mathf.Deg2Rad * dir1); //SetAxis(mat); Matrix4x4 itm = mat.inverse; tm1 = mat * tm1; invtm1 = invtm1 * itm; r = -radius; if (linkRadii) { r1 = -radius; } else { r1 = -radius1; } }
public void SetTM1() { tm = Matrix4x4.identity; //Quaternion rot = Quaternion.Euler(-gizmoRot); MegaMatrix.RotateZ(ref tm, -gizmoRot.z * Mathf.Deg2Rad); MegaMatrix.RotateY(ref tm, -gizmoRot.y * Mathf.Deg2Rad); MegaMatrix.RotateX(ref tm, -gizmoRot.x * Mathf.Deg2Rad); MegaMatrix.SetTrans(ref tm, gizmoPos + Offset); //tm.SetTRS(gizmoPos + Offset, rot, gizmoScale); invtm = tm.inverse; }
public override bool Prepare(MegaModContext mc) { mat = Matrix4x4.identity; switch (axis) { case MegaAxis.X: MegaMatrix.RotateZ(ref mat, Mathf.PI * 0.5f); break; case MegaAxis.Y: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); break; case MegaAxis.Z: break; } SetAxis(mat); if (Bias != 0.0f) { bias = 1.0f - (Bias + 100.0f) / 200.0f; if (bias < 0.00001f) { bias = 0.00001f; } if (bias > 0.99999f) { bias = 0.99999f; } bias = Mathf.Log(bias) / Mathf.Log(0.5f); doBias = true; } else { bias = 1.0f; doBias = false; } if (from > to) { from = to; } if (to < from) { to = from; } CalcHeight(axis, angle, mc.bbox); return(true); }
public override bool Prepare(MegaModContext mc) { if (path != null) { if (usedist) { percent = distance / path.splines[curve].length * 100.0f; } if (curve >= path.splines.Count) { curve = 0; } usepercent = percent / 100.0f; switch (loopmode) { case MegaLoopMode.Clamp: usepercent = Mathf.Clamp01(usepercent); break; case MegaLoopMode.Loop: usepercent = Mathf.Repeat(usepercent, 1.0f); break; case MegaLoopMode.PingPong: usepercent = Mathf.PingPong(usepercent, 1.0f); break; } ovlen = (1.0f / path.splines[curve].length); // * stretch; usetan = (tangent * 0.01f); mat = Matrix4x4.identity; switch (axis) { case MegaAxis.X: MegaMatrix.RotateZ(ref mat, Mathf.PI * 0.5f); break; case MegaAxis.Y: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); break; case MegaAxis.Z: break; } MegaMatrix.RotateZ(ref mat, Mathf.Deg2Rad * rotate); SetAxis(mat); mat = transform.localToWorldMatrix.inverse * path.transform.localToWorldMatrix; return(true); } return(false); }
public Matrix4x4 GetMatrix() { Matrix4x4 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; //Matrix.RotateY(ref tm, Mathf.PI * 0.5f); break; } return(tm); }
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); }
//Matrix4x4 tmm = Matrix4x4.identity; public override bool Prepare(float decay) { if (bsize.x != Width || bsize.y != Height || bsize.z != Length) { Init(); } Vector3 s = LatticeSize(); for (int i = 0; i < 3; i++) { if (s[i] == 0.0f) { s[i] = 1.0f; } else { s[i] = 1.0f / s[i]; } } tm = transform.worldToLocalMatrix; //Matrix4x4 tmm = Matrix4x4.TRS(bsize * 0.5f, Quaternion.identity, Vector3.one); Vector3 c = MegaMatrix.GetTrans(ref tm); MegaMatrix.SetTrans(ref tm, c - (-bsize * 0.5f)); //Vector3.zero); //c - bbox.min - Offset); MegaMatrix.Scale(ref tm, s, false); invtm = tm.inverse; //tm = tmm * transform.worldToLocalMatrix; //invtm = tm.inverse; totaldecay = Decay + decay; if (totaldecay < 0.0f) { totaldecay = 0.0f; } hw = Width * 0.5f; hh = Height * 0.5f; hl = Length * 0.5f; return(true); }
public override bool Prepare(MegaModContext mc) { mat = Matrix4x4.identity; switch (axis) { case MegaAxis.X: MegaMatrix.RotateZ(ref mat, Mathf.PI * 0.5f); break; case MegaAxis.Y: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); break; case MegaAxis.Z: break; } SetAxis(mat); CalcBulge(axis, amount, amplify); return(true); }
public override bool Prepare(MegaModContext mc) { mat = Matrix4x4.identity; MegaMatrix.RotateZ(ref mat, Mathf.Deg2Rad * dir); SetAxis(mat); dy = Decay / 1000.0f; dist = (wave / 10.0f) * 4.0f * 5.0f; //float(numSides); if (dist == 0.0f) { dist = 1.0f; } return(true); }
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)); }
Vector3 GetCross(int csect, float ca, Vector3 off) { MegaLoftSection lsection = loftsections[csect]; int curve = lsection.curve; int k = -1; Matrix4x4 tm1 = Matrix4x4.identity; float start = crossStart; float len = crossEnd; if (lsection.uselen) { start = lsection.start; len = lsection.length; } MegaShape shape = lsection.shape; MegaMatrix.Translate(ref tm1, pivot); Vector3 rot = crossRot + lsection.rot; MegaMatrix.Rotate(ref tm1, new Vector3(Mathf.Deg2Rad * rot.x, Mathf.Deg2Rad * rot.y, Mathf.Deg2Rad * rot.z)); float alpha = start + (ca * len); //float alpha = start + ca; if (shape.splines[curve].closed) { alpha = Mathf.Repeat(alpha, 1.0f); } Vector3 pos = tm1.MultiplyPoint3x4(shape.splines[curve].InterpCurve3D(alpha, shape.normalizedInterp, ref k) + off + lsection.offset); pos.x *= lsection.scale.x; pos.y *= lsection.scale.y; pos.z *= lsection.scale.z; return(pos); }
public override bool Prepare(float decay) { totaldecay = Decay + decay; if (totaldecay < 0.0f) { totaldecay = 0.0f; } tm = transform.worldToLocalMatrix; invtm = tm.inverse; //size = bbox.Size(); //size.x = Width; //size.y = Height; //size.z = Length; mat = Matrix4x4.identity; //SetTM1(); switch (axis) { case MegaAxis.X: MegaMatrix.RotateZ(ref mat, Mathf.PI * 0.5f); break; case MegaAxis.Y: MegaMatrix.RotateX(ref mat, -Mathf.PI * 0.5f); break; case MegaAxis.Z: break; } SetAxis(mat); float xsize = Width; //bbox.max.x - bbox.min.x; float zsize = Length; //bbox.max.z - bbox.min.z; size1 = (xsize > zsize) ? xsize : zsize; // Get the percentage to spherify at this time per = Percent / 100.0f; return(true); }