public bool ViewportToWorldPoint(ref Vector3 v, out Vector3 p) { Vector3G vectorg2; Vector3G win = new Vector3G((Vector3)v); bool flag = this.projectViewport.UnProject(ref win, out vectorg2); p = vectorg2.f; return(flag); }
public bool ScreenToWorldPoint(ref Vector3 v) { Vector3G vectorg2; Vector3G win = new Vector3G((Vector3)v); bool flag = this.projectScreen.UnProject(ref win, out vectorg2); v = vectorg2.f; return(flag); }
private void RunSim(ref int i, ref Vector3G force, ref Vector3G torque) { while (i < this.dataCount) { this.ctx.data = this.data[i]; switch (this.ctx.data.effect.Simulate(ref this.ctx)) { case BOBRES.CONTINUE: { force.x = force.x + this.ctx.data.force.x; force.y = force.y + this.ctx.data.force.y; force.z = force.z + this.ctx.data.force.z; torque.x = torque.x + this.ctx.data.torque.x; torque.y = torque.y + this.ctx.data.torque.y; torque.z = torque.z + this.ctx.data.torque.z; break; } case BOBRES.EXIT: { if (!this.isFork) { int num = i; int num1 = num; i = num + 1; int num2 = num1; this.RunSim(ref i, ref force, ref torque); if (this.ctx.data == null) { this.data.RemoveAt(num2); } else { if (this.ctx.data.effect != null) { this.ctx.data.effect.Destroy(ref this.ctx.data); } this.data.RemoveAt(num2); foreach (BobEffectStack fork in this.forks) { fork.data.RemoveAt(num2); } } } return; } case BOBRES.ERROR: { Debug.LogError("Error with effect", this.ctx.data.effect); break; } } i = i + 1; } }
public void Simulate(ref double dt, ref Vector3G force, ref Vector3G torque) { this.dataCount = this.data.Count; if (this.dataCount > 0) { int i = 0; this.ctx.dt = dt; this.RunSim(ref i, ref force, ref torque); } }
private void CalculateVelocity() { Vector3G vectorg2; double num = Time.time - this.lastVelocityCalc; Character idMain = base.idMain; Vector3 v = (idMain == null) ? base.transform.position : idMain.origin; Vector3G vectorg = new Vector3G(ref v); double num2 = 1.0 / num; vectorg2.x = num2 * (vectorg.x - this.lastPosPrecise.x); vectorg2.y = num2 * (vectorg.y - this.lastPosPrecise.y); vectorg2.z = num2 * (vectorg.z - this.lastPosPrecise.z); Matrix4x4G b = new Matrix4x4G(base.transform.worldToLocalMatrix); Matrix4x4G.Mult3x3(ref vectorg2, ref b, out this.localVelocityPrecise); this.lastVelocityCalc = Time.time; this.speedPrecise = Math.Sqrt((this.localVelocityPrecise.x * this.localVelocityPrecise.x) + (this.localVelocityPrecise.z * this.localVelocityPrecise.z)); if (this.speedPrecise < this.movement.configuration.minMoveSpeed) { float num3; this.speedPrecise = 0.0; this.movementNormalPrecise.x = 0.0; this.movementNormalPrecise.y = 0.0; if ((this.lastAngleSpeedPrecise > 0.0) && ((num3 = this.movement.configuration.maxTimeBetweenTurns) > 0f)) { this.lastAngleSpeedPrecise -= Time.deltaTime / num3; } } else { double num4 = 1.0 / this.speedPrecise; this.movementNormalPrecise.x = this.localVelocity.x * num4; this.movementNormalPrecise.y = this.localVelocity.z * num4; double anglePrecise = this.anglePrecise; this.anglePrecise = (Math.Atan2(this.movementNormalPrecise.x, this.movementNormalPrecise.y) / 3.1415926535897931) * 180.0; float maxTurnSpeed = this.movement.configuration.maxTurnSpeed; if (((maxTurnSpeed > 0f) && (this.anglePrecise != anglePrecise)) && (this.lastAngleSpeedPrecise >= 0.05)) { double maxDelta = Time.deltaTime * maxTurnSpeed; if (Precise.MoveTowardsAngle(ref anglePrecise, ref this.anglePrecise, ref maxDelta, out this.anglePrecise)) { double a = (this.anglePrecise / 180.0) * 3.1415926535897931; this.movementNormalPrecise.x = Math.Sin(a); this.movementNormalPrecise.y = Math.Cos(a); } } this.lastAngleSpeedPrecise = this.speedPrecise; } this.lastPosPrecise = vectorg; this.lastPos = v; this.movementNormal = this.movementNormalPrecise.f; this.speed = (float)this.speedPrecise; this.angle = (float)this.anglePrecise; this.localVelocity = this.localVelocityPrecise.f; }
public Ray ViewportPointToRay(Vector3 v) { Vector3G vector3G; Vector3G vector3G1; Vector3G vector3G2 = new Vector3G(v); this.projectViewport.UnProject(ref vector3G2, out vector3G); vector3G2.z = vector3G2.z + 1; this.projectViewport.UnProject(ref vector3G2, out vector3G1); return(new Ray(vector3G.f, new Vector3((float)(vector3G1.x - vector3G.x), (float)(vector3G1.y - vector3G.y), (float)(vector3G1.z - vector3G.z)))); }
public Ray ViewportPointToRay(Vector3 v) { Vector3G vectorg2; Vector3G vectorg3; Vector3G win = new Vector3G(v); this.projectViewport.UnProject(ref win, out vectorg2); win.z++; this.projectViewport.UnProject(ref win, out vectorg3); return(new Ray(vectorg2.f, new Vector3((float)(vectorg3.x - vectorg2.x), (float)(vectorg3.y - vectorg2.y), (float)(vectorg3.z - vectorg2.z)))); }
public double AddDifference(ref HeadBob.VectorStamp previous, ref Vector3G difference) { if (previous.valid && (previous.timeStamp != this.timeStamp)) { double num = 1.0 / ((double)(this.timeStamp - previous.timeStamp)); difference.x += num * (this.vector.x - previous.vector.x); difference.y += num * (this.vector.y - previous.vector.y); difference.z += num * (this.vector.z - previous.vector.z); return(1.0); } return(0.0); }
private void RunSim(ref int i, ref Vector3G force, ref Vector3G torque) { while (i < this.dataCount) { int num; this.ctx.data = this.data[i]; switch (this.ctx.data.effect.Simulate(ref this.ctx)) { case BOBRES.CONTINUE: force.x += this.ctx.data.force.x; force.y += this.ctx.data.force.y; force.z += this.ctx.data.force.z; torque.x += this.ctx.data.torque.x; torque.y += this.ctx.data.torque.y; torque.z += this.ctx.data.torque.z; goto Label_0210; case BOBRES.EXIT: if (!this.isFork) { num = i++; this.RunSim(ref i, ref force, ref torque); if (this.ctx.data == null) { break; } if (this.ctx.data.effect != null) { this.ctx.data.effect.Destroy(ref this.ctx.data); } this.data.RemoveAt(num); foreach (BobEffectStack stack in this.forks) { stack.data.RemoveAt(num); } } return; case BOBRES.ERROR: Debug.LogError("Error with effect", this.ctx.data.effect); goto Label_0210; default: goto Label_0210; } this.data.RemoveAt(num); return; Label_0210: i++; } }
public double AddDifference(ref HeadBob.VectorStamp previous, ref Vector3G difference) { if (!previous.valid || previous.timeStamp == this.timeStamp) { return(0); } double num = 1 / (double)(this.timeStamp - previous.timeStamp); difference.x = difference.x + num * (this.vector.x - previous.vector.x); difference.y = difference.y + num * (this.vector.y - previous.vector.y); difference.z = difference.z + num * (this.vector.z - previous.vector.z); return(1); }
public static Vector3G Slerp(double t, Vector3G a, Vector3G b) { double num2; double v = AngleRadians(a, b); if ((v == 0.0) || ((num2 = Sin(v)) == 0.0)) { return(Linear(t, a, b)); } double num3 = Sin((double)((1.0 - t) * v)) / num2; double num4 = Sin((double)(t * v)) / num2; return(Sum(Mul(a, num3), Mul(b, num4))); }
// Token: 0x0600176C RID: 5996 RVA: 0x00057580 File Offset: 0x00055780 private void RunSim(ref int i, ref Vector3G force, ref Vector3G torque) { while (i < this.dataCount) { this.ctx.data = this.data[i]; switch (this.ctx.data.effect.Simulate(ref this.ctx)) { case global::BOBRES.CONTINUE: force.x += this.ctx.data.force.x; force.y += this.ctx.data.force.y; force.z += this.ctx.data.force.z; torque.x += this.ctx.data.torque.x; torque.y += this.ctx.data.torque.y; torque.z += this.ctx.data.torque.z; break; case global::BOBRES.EXIT: if (!this.isFork) { int index = i++; this.RunSim(ref i, ref force, ref torque); if (this.ctx.data != null) { if (this.ctx.data.effect != null) { this.ctx.data.effect.Destroy(ref this.ctx.data); } this.data.RemoveAt(index); foreach (global::BobEffectStack bobEffectStack in this.forks) { bobEffectStack.data.RemoveAt(index); } } else { this.data.RemoveAt(index); } } return; case global::BOBRES.ERROR: Debug.LogError("Error with effect", this.ctx.data.effect); break; } i++; } }
public static double AngleDegrees(Vector3G a, Vector3G b) { double num = TransitionFunctions.DotNormal(a, b); if (num >= 1) { return 0; } if (num <= -1) { return 180; } if (num == 0) { return 90; } return TransitionFunctions.RadiansToDegrees(TransitionFunctions.Acos(num)); }
public static double AngleRadians(Vector3G a, Vector3G b) { double num = TransitionFunctions.DotNormal(a, b); if (num >= 1) { return 0; } if (num <= -1) { return 3.14159265358979; } if (num == 0) { return 1.5707963267949; } return TransitionFunctions.Acos(num); }
public static Vector3G Normalize(Vector3G v) { Vector3G vectorg; double num = ((v.x * v.x) + (v.y * v.y)) + (v.z * v.z); switch (num) { case 0.0: case 1.0: return(v); } num = Sqrt(num); vectorg.x = v.x / num; vectorg.y = v.y / num; vectorg.z = v.z / num; return(vectorg); }
private void OnDrawGizmos() { Matrix4x4G matrix4x4G; Vector3G vector3G; Vector3G vector3G1; Vector3G vector3G2; Vector3G vector3G3; Vector3G vector3G4 = new Vector3G(); base.transform.ExtractLocalToWorld(out matrix4x4G); Matrix4x4 matrix4x4 = base.transform.localToWorldMatrix; Vector3 vector3 = matrix4x4.MultiplyPoint(Vector3.zero); Vector3 vector31 = matrix4x4.MultiplyPoint(Vector3.forward); Vector3 vector32 = matrix4x4.MultiplyPoint(Vector3.up); Vector3 vector33 = matrix4x4.MultiplyPoint(Vector3.right); vector3G4.x = 1; vector3G4.y = 0; vector3G4.z = 0; Matrix4x4G.Mult(ref vector3G4, ref matrix4x4G, out vector3G); vector3G4.x = 0; vector3G4.y = 1; vector3G4.z = 0; Matrix4x4G.Mult(ref vector3G4, ref matrix4x4G, out vector3G1); vector3G4.x = 0; vector3G4.y = 0; vector3G4.z = 1; Matrix4x4G.Mult(ref vector3G4, ref matrix4x4G, out vector3G2); vector3G4.x = 0; vector3G4.y = 0; vector3G4.z = 0; Matrix4x4G.Mult(ref vector3G4, ref matrix4x4G, out vector3G3); Gizmos.color = Color.red * new Color(1f, 1f, 1f, 0.5f); Gizmos.DrawLine(vector3, vector33); Gizmos.color = Color.green * new Color(1f, 1f, 1f, 0.5f); Gizmos.DrawLine(vector3, vector32); Gizmos.color = Color.blue * new Color(1f, 1f, 1f, 0.5f); Gizmos.DrawLine(vector3, vector31); Gizmos.color = Color.red * new Color(1f, 1f, 1f, 1f); Gizmos.DrawLine(vector3G3.f, vector3G.f); Gizmos.color = Color.green * new Color(1f, 1f, 1f, 1f); Gizmos.DrawLine(vector3G3.f, vector3G1.f); Gizmos.color = Color.blue * new Color(1f, 1f, 1f, 1f); Gizmos.DrawLine(vector3G3.f, vector3G2.f); }
public static double AngleDegrees(Vector3G a, Vector3G b) { double v = DotNormal(a, b); if (v >= 1.0) { return(0.0); } if (v <= -1.0) { return(180.0); } if (v == 0.0) { return(90.0); } return(RadiansToDegrees(Acos(v))); }
public static double AngleRadians(Vector3G a, Vector3G b) { double v = DotNormal(a, b); if (v >= 1.0) { return(0.0); } if (v <= -1.0) { return(3.1415926535897931); } if (v == 0.0) { return(1.5707963267948966); } return(Acos(v)); }
private void Update() { if ((this.R == null) || (this.R.Length == 0)) { this.unity = Quaternion.identity; this.facep = QuaternionG.identity; } else if (this.revMul) { int index = this.R.Length - 1; this.unity = Quaternion.Euler(this.R[index]); Vector3G deg = new Vector3G(this.R[index]); QuaternionG.Euler(ref deg, out this.facep); index--; while (index >= 0) { QuaternionG ng; this.unity = Quaternion.Euler(this.R[index]) * this.unity; deg.f = this.R[index]; QuaternionG.Euler(ref deg, out ng); QuaternionG.Mult(ref ng, ref this.facep, out this.facep); index--; } } else { int num2 = 0; this.unity = Quaternion.Euler(this.R[num2]); Vector3G vectorg2 = new Vector3G(this.R[num2]); QuaternionG.Euler(ref vectorg2, out this.facep); num2++; while (num2 < this.R.Length) { QuaternionG ng2; this.unity *= Quaternion.Euler(this.R[num2]); vectorg2.f = this.R[num2]; QuaternionG.Euler(ref vectorg2, out ng2); QuaternionG.Mult(ref this.facep, ref ng2, out this.facep); num2++; } } }
private void Update() { QuaternionG quaternionG; QuaternionG quaternionG1; if (this.R == null || (int)this.R.Length == 0) { this.unity = Quaternion.identity; this.facep = QuaternionG.identity; } else if (!this.revMul) { int i = 0; this.unity = Quaternion.Euler(this.R[i]); Vector3G vector3G = new Vector3G(this.R[i]); QuaternionG.Euler(ref vector3G, out this.facep); for (i++; i < (int)this.R.Length; i++) { QuaternionTest quaternionTest = this; quaternionTest.unity = quaternionTest.unity * Quaternion.Euler(this.R[i]); vector3G.f = this.R[i]; QuaternionG.Euler(ref vector3G, out quaternionG1); QuaternionG quaternionG2 = this.facep; QuaternionG.Mult(ref quaternionG2, ref quaternionG1, out this.facep); } } else { int length = (int)this.R.Length - 1; this.unity = Quaternion.Euler(this.R[length]); Vector3G r = new Vector3G(this.R[length]); QuaternionG.Euler(ref r, out this.facep); for (length--; length >= 0; length--) { this.unity = Quaternion.Euler(this.R[length]) * this.unity; r.f = this.R[length]; QuaternionG.Euler(ref r, out quaternionG); QuaternionG.Mult(ref quaternionG, ref this.facep, out this.facep); } } }
public static Vector3G Evaluate(this TransitionFunction f, double t, Vector3G a, Vector3G b) { switch (f) { case TransitionFunction.Linear: return(Linear(t, a, b)); case TransitionFunction.Round: return(Round(t, a, b)); case TransitionFunction.Floor: return(Floor(t, a, b)); case TransitionFunction.Ceil: return(Ceil(t, a, b)); case TransitionFunction.Spline: return(Spline(t, a, b)); } throw new ArgumentOutOfRangeException("v", "Attempted use of unrecognized TransitionFunction enum value"); }
public void Sample(ref Vector3G v, float timeStamp) { if (this.sample1.timeStamp < timeStamp) { this.sample2 = this.sample1; } if (this.sample0.timeStamp < timeStamp) { this.sample1 = this.sample0; } this.sample0.vector = v; this.sample0.timeStamp = timeStamp; this.sample0.valid = true; Vector3G vector3G = new Vector3G(); double num = this.sample0.AddDifference(ref this.sample1, ref vector3G) + this.sample0.AddDifference(ref this.sample2, ref vector3G); if (num != 0) { num = 1 / num; this.accel.x = vector3G.x * num; this.accel.y = vector3G.y * num; this.accel.z = vector3G.z * num; } }
public static QuaternionG LookRotation(Vector3G forward, Vector3G up) { QuaternionG quaternionG; QuaternionG.LookRotation(ref forward, ref up, out quaternionG); return quaternionG; }
private void Solve(ref Weight weight, ref double dt) { Vector3G vectorg; vectorg.x = (dt * this.groundLocalVelocity.x) * this.cfg.forceSpeedMultiplier.x; vectorg.y = (dt * this.groundLocalVelocity.y) * this.cfg.forceSpeedMultiplier.y; vectorg.z = (dt * this.groundLocalVelocity.z) * this.cfg.forceSpeedMultiplier.z; Vector3G fE = weight.position.fE; Vector3G vectorg3 = weight.rotation.fE; weight.position.fE = new Vector3G(); weight.rotation.fE = new Vector3G(); if (this.anyAdditionalCurves) { for (int i = 0; i < this.additionalCurveCount; i++) { double groundLocalVelocityMag; BobForceCurve curve = this.cfg.additionalCurves[i]; switch (curve.source) { case BobForceCurveSource.LocalMovementMagnitude: groundLocalVelocityMag = this.groundLocalVelocityMag; break; case BobForceCurveSource.LocalMovementX: groundLocalVelocityMag = this.groundLocalVelocity.x; break; case BobForceCurveSource.LocalMovementY: groundLocalVelocityMag = this.groundLocalVelocity.y; break; case BobForceCurveSource.LocalMovementZ: groundLocalVelocityMag = this.groundLocalVelocity.z; break; case BobForceCurveSource.WorldMovementMagnitude: groundLocalVelocityMag = this.groundWorldVelocityMag; break; case BobForceCurveSource.WorldMovementX: groundLocalVelocityMag = this.groundWorldVelocity.x; break; case BobForceCurveSource.WorldMovementY: groundLocalVelocityMag = this.groundWorldVelocity.y; break; case BobForceCurveSource.WorldMovementZ: groundLocalVelocityMag = this.groundWorldVelocity.z; break; case BobForceCurveSource.LocalVelocityMagnitude: groundLocalVelocityMag = this.localVelocityMag; break; case BobForceCurveSource.LocalVelocityX: groundLocalVelocityMag = this.localVelocity.x; break; case BobForceCurveSource.LocalVelocityY: groundLocalVelocityMag = this.localVelocity.y; break; case BobForceCurveSource.WorldVelocityMagnitude: groundLocalVelocityMag = this.worldVelocityMag; break; case BobForceCurveSource.WorldVelocityX: groundLocalVelocityMag = this.worldVelocity.x; break; case BobForceCurveSource.WorldVelocityY: groundLocalVelocityMag = this.worldVelocity.y; break; case BobForceCurveSource.WorldVelocityZ: groundLocalVelocityMag = this.worldVelocity.z; break; case BobForceCurveSource.RotationMagnitude: groundLocalVelocityMag = this.localAngularVelocityMag; break; case BobForceCurveSource.RotationPitch: groundLocalVelocityMag = this.localAngularVelocity.x; break; case BobForceCurveSource.RotationYaw: groundLocalVelocityMag = this.localAngularVelocity.y; break; case BobForceCurveSource.RotationRoll: groundLocalVelocityMag = this.localAngularVelocity.z; break; case BobForceCurveSource.TurnMagnitude: groundLocalVelocityMag = this.groundLocalAngularVelocityMag; break; case BobForceCurveSource.TurnPitch: groundLocalVelocityMag = this.groundLocalAngularVelocity.x; break; case BobForceCurveSource.TurnYaw: groundLocalVelocityMag = this.groundLocalAngularVelocity.y; break; case BobForceCurveSource.TurnRoll: groundLocalVelocityMag = this.groundLocalAngularVelocity.z; break; default: groundLocalVelocityMag = this.localVelocity.z; break; } BobForceCurveTarget target = curve.target; if ((target == BobForceCurveTarget.Position) || (target != BobForceCurveTarget.Rotation)) { curve.Calculate(ref weight.additionalPositions[i], ref groundLocalVelocityMag, ref dt, ref weight.position.fE); } else { curve.Calculate(ref weight.additionalPositions[i], ref groundLocalVelocityMag, ref dt, ref weight.rotation.fE); } } } if (this.cfg.impulseForceSmooth > 0f) { Vector3G.SmoothDamp(ref weight.position.fI, ref this.impulseForce.accel, ref weight.position.fIV, this.cfg.impulseForceSmooth, this.cfg.impulseForceMaxChangeAcceleration, ref dt); } else { weight.position.fI = this.impulseForce.accel; } if (this.cfg.angleImpulseForceSmooth > 0f) { Vector3G.SmoothDamp(ref weight.rotation.fI, ref this.impulseTorque.accel, ref weight.rotation.fIV, this.cfg.angleImpulseForceSmooth, this.cfg.angleImpulseForceMaxChangeAcceleration, ref dt); } else { weight.rotation.fI = this.impulseTorque.accel; } weight.position.fE.x += this.inputForce.x + (weight.position.fI.x * this.cfg.impulseForceScale.x); weight.position.fE.y += this.inputForce.y + (weight.position.fI.y * this.cfg.impulseForceScale.y); weight.position.fE.z += this.inputForce.z + (weight.position.fI.z * this.cfg.impulseForceScale.z); weight.rotation.fE.x += weight.rotation.fI.x * this.cfg.angularImpulseForceScale.x; weight.rotation.fE.y += weight.rotation.fI.y * this.cfg.angularImpulseForceScale.y; weight.rotation.fE.z += weight.rotation.fI.z * this.cfg.angularImpulseForceScale.z; Vector3G vectorg4 = weight.position.value; vectorg4.x /= (double)this.cfg.elipsoidRadii.x; vectorg4.y /= (double)this.cfg.elipsoidRadii.y; vectorg4.z /= (double)this.cfg.elipsoidRadii.z; double d = ((vectorg4.x * vectorg4.x) + (vectorg4.y * vectorg4.y)) + (vectorg4.z * vectorg4.z); if (d > 1.0) { d = 1.0 / Math.Sqrt(d); vectorg4.x *= d; vectorg4.y *= d; vectorg4.z *= d; } vectorg4.x *= this.cfg.elipsoidRadii.x; vectorg4.y *= this.cfg.elipsoidRadii.y; vectorg4.z *= this.cfg.elipsoidRadii.z; weight.stack.Simulate(ref dt, ref weight.position.fE, ref weight.rotation.fE); weight.position.acceleration.x = (weight.position.fE.x - fE.x) + (((vectorg4.x * -this.cfg.springConstant.x) - (weight.position.velocity.x * this.cfg.springDampen.x)) * this.cfg.weightMass); weight.position.acceleration.y = (weight.position.fE.y - fE.y) + (((vectorg4.y * -this.cfg.springConstant.y) - (weight.position.velocity.y * this.cfg.springDampen.y)) * this.cfg.weightMass); weight.position.acceleration.z = (weight.position.fE.z - fE.z) + (((vectorg4.z * -this.cfg.springConstant.z) - (weight.position.velocity.z * this.cfg.springDampen.z)) * this.cfg.weightMass); weight.position.velocity.x += weight.position.acceleration.x * dt; weight.position.velocity.y += weight.position.acceleration.y * dt; weight.position.velocity.z += weight.position.acceleration.z * dt; if (!float.IsInfinity(this.cfg.maxVelocity.x)) { if (weight.position.velocity.x < -this.cfg.maxVelocity.x) { weight.position.value.x -= this.cfg.maxVelocity.x * dt; } else if (weight.position.velocity.x > this.cfg.maxVelocity.x) { weight.position.value.x += this.cfg.maxVelocity.x * dt; } else { weight.position.value.x += weight.position.velocity.x * dt; } } else { weight.position.value.x += weight.position.velocity.x * dt; } if (!float.IsInfinity(this.cfg.maxVelocity.y)) { if (weight.position.velocity.y < -this.cfg.maxVelocity.y) { weight.position.value.y -= this.cfg.maxVelocity.y * dt; } else if (weight.position.velocity.y > this.cfg.maxVelocity.y) { weight.position.value.y += this.cfg.maxVelocity.y * dt; } else { weight.position.value.y += weight.position.velocity.y * dt; } } else { weight.position.value.y += weight.position.velocity.y * dt; } if (!float.IsInfinity(this.cfg.maxVelocity.z)) { if (weight.position.velocity.z < -this.cfg.maxVelocity.z) { weight.position.value.z -= this.cfg.maxVelocity.z * dt; } else if (weight.position.velocity.z > this.cfg.maxVelocity.z) { weight.position.value.z += this.cfg.maxVelocity.z * dt; } else { weight.position.value.z += weight.position.velocity.z * dt; } } else { weight.position.value.z += weight.position.velocity.z * dt; } weight.rotation.acceleration.x = (weight.rotation.fE.x - vectorg3.x) + (((weight.rotation.value.x * -this.cfg.angularSpringConstant.x) - (weight.rotation.velocity.x * this.cfg.angularSpringDampen.x)) * this.cfg.angularWeightMass); weight.rotation.acceleration.y = (weight.rotation.fE.y - vectorg3.y) + (((weight.rotation.value.y * -this.cfg.angularSpringConstant.y) - (weight.rotation.velocity.y * this.cfg.angularSpringDampen.y)) * this.cfg.angularWeightMass); weight.rotation.acceleration.z = (weight.rotation.fE.z - vectorg3.z) + (((weight.rotation.value.z * -this.cfg.angularSpringConstant.z) - (weight.rotation.velocity.z * this.cfg.angularSpringDampen.z)) * this.cfg.angularWeightMass); weight.rotation.velocity.x += weight.rotation.acceleration.x * dt; weight.rotation.velocity.y += weight.rotation.acceleration.y * dt; weight.rotation.velocity.z += weight.rotation.acceleration.z * dt; weight.rotation.value.x += weight.rotation.velocity.x * dt; weight.rotation.value.y += weight.rotation.velocity.y * dt; weight.rotation.value.z += weight.rotation.velocity.z * dt; }
public static Vector3G Floor(double t, Vector3G a, Vector3G b) { return (t >= 1 ? b : a); }
private int Step(float dt) { double num; int num1 = 0; int num2 = 0; HeadBob headBob = this; headBob.timeSolve = headBob.timeSolve + (double)dt; double num3 = ((double)this.cfg.solveRate >= 0 ? 1 / (double)this.cfg.solveRate : 1 / -(double)this.cfg.solveRate); if ((double)this.cfg.intermitRate != 0) { num = ((double)this.cfg.intermitRate >= 0 ? 1 / (double)this.cfg.intermitRate : 1 / -(double)this.cfg.intermitRate); } else { num = 0; } double num4 = num; if (double.IsInfinity(num3) || num3 == 0) { num3 = this.timeSolve; } bool flag = num4 > num3; double num5 = num3 * (double)this.cfg.timeScale; if (this.timeSolve >= num3) { do { HeadBob headBob1 = this; headBob1.timeSolve = headBob1.timeSolve - num3; if (flag) { HeadBob headBob2 = this; headBob2.timeIntermit = headBob2.timeIntermit - num3; if (this.timeIntermit < 0) { this.intermitStart = this.working; } } this.Solve(ref this.working, ref num5); if (flag && this.timeIntermit < 0) { this.intermitNext = this.working; this.intermitFraction = (this.timeIntermit + num3) / num3; HeadBob headBob3 = this; headBob3.timeIntermit = headBob3.timeIntermit + num4; num2++; } num1++; }while (this.timeSolve >= num3); } if (flag) { if (num2 > 0) { if (!this.simStep) { this.raw_pos = this.intermitNext.position.@value; this.raw_rot = this.intermitNext.rotation.@value; this.CheckDeadZone(); } else { Vector3G.Lerp(ref this.intermitStart.position.@value, ref this.intermitNext.position.@value, ref this.intermitFraction, out this.raw_pos); Vector3G.Lerp(ref this.intermitStart.rotation.@value, ref this.intermitNext.rotation.@value, ref this.intermitFraction, out this.raw_rot); this.CheckDeadZone(); } } return(num2); } if (!this.simStep) { this.raw_pos = this.working.position.@value; this.raw_rot = this.working.rotation.@value; this.CheckDeadZone(); } else { this.working.CopyTo(ref this.predicted); this.Solve(ref this.predicted, ref num5); num1 = -(num1 + 1); double num6 = this.timeSolve / num3; Vector3G.Lerp(ref this.working.position.@value, ref this.predicted.position.@value, ref num6, out this.raw_pos); Vector3G.Lerp(ref this.working.rotation.@value, ref this.predicted.rotation.@value, ref num6, out this.raw_rot); this.CheckDeadZone(); } return(num1); }
public static double Dot(Vector3G a, Vector3G b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
// Token: 0x06002E47 RID: 11847 RVA: 0x000B1304 File Offset: 0x000AF504 public void Calculate(ref Vector3G v, ref double pow, ref double dt, ref Vector3G sum) { if (!this.once) { this.Gasp(); } if (!this.calc) { return; } float num = (!this.mask) ? 1f : this.sourceMask.Evaluate((float)pow); bool flag = num == 0f || num == -0f; float num2 = (!this.scaleFixed) ? ((!this.scale) ? 1f : this.sourceScale.Evaluate((float)pow)) : 0f; bool flag2 = !this.scaleFixed && num2 != 0f && num2 != -0f; Vector3G vector3G; if (this.infoX.calc) { if (flag2 && !this.infoX.constant) { v.x += pow * dt * (double)num2 * (double)this.positionScale.x; if (v.x > (double)this.infoX.duration) { v.x -= (double)this.infoX.duration; } else if (v.x < (double)(-(double)this.infoX.duration)) { v.x += (double)this.infoX.duration; } } vector3G.x = (double)((!flag) ? (this.forceX.Evaluate((float)v.x) * this.outputScale.x) : 0f); } else { vector3G.x = 0.0; } if (this.infoY.calc) { if (flag2 && !this.infoY.constant) { v.y += pow * dt * (double)num2 * (double)this.positionScale.y; if (v.y > (double)this.infoY.duration) { v.y -= (double)this.infoY.duration; } else if (v.y < (double)(-(double)this.infoY.duration)) { v.y += (double)this.infoY.duration; } } vector3G.y = (double)((!flag) ? (this.forceY.Evaluate((float)v.y) * this.outputScale.y) : 0f); } else { vector3G.y = 0.0; } if (this.infoZ.calc) { if (flag2 && !this.infoZ.constant) { v.z += pow * dt * (double)num2 * (double)this.positionScale.z; if (v.z > (double)this.infoZ.duration) { v.z -= (double)this.infoZ.duration; } else if (v.z < (double)(-(double)this.infoZ.duration)) { v.z += (double)this.infoZ.duration; } } vector3G.z = (double)((!flag) ? (this.forceZ.Evaluate((float)v.z) * this.outputScale.z) : 0f); } else { vector3G.z = 0.0; } if (!flag) { sum.x += vector3G.x * (double)num; sum.y += vector3G.y * (double)num; sum.z += vector3G.z * (double)num; } }
private static void SET_X3(ref Matrix4x4G m, Vector3G v) { m.m03 = v.x; m.m13 = v.y; m.m23 = v.z; }
private static void TRANS(ref Matrix4x4G a, Vector3G v) { TransitionFunctions.SET_X3(ref a, v); }
private static void SET_X0(ref Matrix4x4G m, Vector3G v) { m.m00 = v.x; m.m10 = v.y; m.m20 = v.z; }
private static void SET_X1(ref Matrix4x4G m, Vector3G v) { m.m01 = v.x; m.m11 = v.y; m.m21 = v.z; }
private static void SET_2X(ref Matrix4x4G m, Vector3G v) { m.m20 = v.x; m.m21 = v.y; m.m22 = v.z; }
public static Vector3G Linear(double t, Vector3G a, Vector3G b) { return(Sum(Mul(a, 1.0 - t), Mul(b, t))); }
public void PostPreCull() { Vector3G vector3G; Matrix4x4G matrix4x4G; Matrix4x4G matrix4x4G1; Vector3G vector3G1 = new Vector3G(); Vector3G vector3G2; Vector3G vector3G3; Vector3G vector3G4; Vector3G vector3G5; Vector3G vector3G6 = new Vector3G(); RaycastHit raycastHit; Matrix4x4G matrix4x4G2; PerspectiveMatrixBuilder perspectiveMatrixBuilder = new PerspectiveMatrixBuilder(); Vector4 vector4 = new Vector4(); PerspectiveMatrixBuilder perspectiveMatrixBuilder1 = new PerspectiveMatrixBuilder(); Matrix4x4G matrix4x4G3; Vector3G vector3G7; QuaternionG quaternionG; Vector3G vector3G8; Matrix4x4G matrix4x4G4; Matrix4x4G matrix4x4G5; Matrix4x4G matrix4x4G6; Matrix4x4G matrix4x4G7; Matrix4x4G matrix4x4G8; Matrix4x4G matrix4x4G9; Matrix4x4G matrix4x4G10; Matrix4x4G matrix4x4G11; if (CameraFX.viewModelRootTransform) { Quaternion quaternion = base.transform.localRotation; Vector3 vector3 = base.transform.localPosition; if (this.viewModel) { this.viewModel.ModifyAiming(new Ray(base.transform.parent.position, base.transform.parent.forward), ref vector3, ref quaternion); } CameraFX.viewModelRootTransform.localRotation = Quaternion.Inverse(quaternion); CameraFX.viewModelRootTransform.localPosition = -vector3; } this.camera.transform.ExtractLocalToWorldToLocal(out this.localToWorldMatrix, out this.worldToLocalMatrix); if (this.adaptiveNearPlane) { int num = this.camera.cullingMask & ~this.adaptiveNearPlane.ignoreLayers.@value | this.adaptiveNearPlane.forceLayers.@value; Vector3G vector3G9 = new Vector3G(); this.localToWorldMatrix.MultiplyPoint(ref vector3G9, out vector3G); Collider[] colliderArray = Physics.OverlapSphere(vector3G.f, this.adaptiveNearPlane.minNear + this.adaptiveNearPlane.maxNear, num); int num1 = -1; float single = Single.PositiveInfinity; double num2 = (double)this.camera.fieldOfView; double num3 = (double)this.camera.aspect; double num4 = (double)this.adaptiveNearPlane.minNear; double num5 = (double)(this.adaptiveNearPlane.maxNear + this.adaptiveNearPlane.threshold); float single1 = this.adaptiveNearPlane.minNear; float single2 = this.adaptiveNearPlane.maxNear + this.adaptiveNearPlane.threshold - single1; Matrix4x4G.Perspective(ref num2, ref num3, ref num4, ref num5, out matrix4x4G); Matrix4x4G.Inverse(ref matrix4x4G, out matrix4x4G1); for (int i = 0; i < 8; i++) { for (int j = 0; j < 8; j++) { vector3G1.x = ((double)i - 3.5) / 3.5; vector3G1.y = ((double)j - 3.5) / 3.5; vector3G1.z = 0; matrix4x4G1.MultiplyPoint(ref vector3G1, out vector3G2); vector3G1.z = 1; matrix4x4G1.MultiplyPoint(ref vector3G1, out vector3G3); vector3G2.x = -vector3G2.x; vector3G2.y = -vector3G2.y; vector3G2.z = -vector3G2.z; vector3G3.x = -vector3G3.x; vector3G3.y = -vector3G3.y; vector3G3.z = -vector3G3.z; this.localToWorldMatrix.MultiplyPoint(ref vector3G2, out vector3G4); this.localToWorldMatrix.MultiplyPoint(ref vector3G3, out vector3G5); vector3G6.x = vector3G5.x - vector3G4.x; vector3G6.y = vector3G5.y - vector3G4.y; vector3G6.z = vector3G5.z - vector3G4.z; float single3 = (float)Math.Sqrt(vector3G6.x * vector3G6.x + vector3G6.y * vector3G6.y + vector3G6.z * vector3G6.z); float single4 = single3; Ray ray = new Ray(vector3G4.f, vector3G6.f); for (int k = 0; k < (int)colliderArray.Length; k++) { if (colliderArray[k].Raycast(ray, out raycastHit, single4)) { float single5 = raycastHit.distance; if (single5 < single4) { single4 = single5; float single6 = single1 + single5 / single3 * single2; if (single > single6) { single = single6; num1 = k; } } } } } } if (!float.IsInfinity(single)) { single = single - this.adaptiveNearPlane.threshold; if (single >= this.adaptiveNearPlane.maxNear) { this.camera.nearClipPlane = this.adaptiveNearPlane.maxNear; } else if (single > this.adaptiveNearPlane.minNear) { this.camera.nearClipPlane = single; } else { this.camera.nearClipPlane = this.adaptiveNearPlane.minNear; } } else { this.camera.nearClipPlane = this.adaptiveNearPlane.maxNear; } } perspectiveMatrixBuilder.fieldOfView = (double)this.camera.fieldOfView; perspectiveMatrixBuilder.aspectRatio = (double)this.camera.aspect; perspectiveMatrixBuilder.nearPlane = (double)this.camera.nearClipPlane; perspectiveMatrixBuilder.farPlane = (double)this.camera.farClipPlane; PerspectiveMatrixBuilder perspectiveMatrixBuilder2 = perspectiveMatrixBuilder; if (!this.camera.isOrthoGraphic) { if (this.viewModel) { this.viewModel.ModifyPerspective(ref perspectiveMatrixBuilder2); } if (!CameraFX.vm_projuse) { perspectiveMatrixBuilder.ToProjectionMatrix(out this.projectionMatrix); } else { perspectiveMatrixBuilder2.ToProjectionMatrix(out this.projectionMatrix); } this.camera.projectionMatrix = this.projectionMatrix.f; perspectiveMatrixBuilder2.ToProjectionMatrix(out matrix4x4G2); } else { this.projectionMatrix.f = this.camera.projectionMatrix; matrix4x4G2 = this.projectionMatrix; } vector4.y = (float)perspectiveMatrixBuilder2.nearPlane; vector4.z = (float)perspectiveMatrixBuilder2.farPlane; vector4.w = (float)(1 / perspectiveMatrixBuilder2.farPlane); if (CameraFX.vm_flip != CameraFX.PLATFORM_POLL.flipRequired) { vector4.x = -1f; perspectiveMatrixBuilder1.nearPlane = perspectiveMatrixBuilder2.nearPlane; perspectiveMatrixBuilder1.farPlane = perspectiveMatrixBuilder2.farPlane; perspectiveMatrixBuilder1.fieldOfView = -perspectiveMatrixBuilder2.fieldOfView; perspectiveMatrixBuilder1.aspectRatio = -perspectiveMatrixBuilder2.aspectRatio; perspectiveMatrixBuilder1.ToProjectionMatrix(out matrix4x4G3); Shader.SetGlobalMatrix("V_MUNITY_MATRIX_P", matrix4x4G3.f); } else { vector4.x = 1f; Shader.SetGlobalMatrix("V_MUNITY_MATRIX_P", matrix4x4G2.f); } Shader.SetGlobalVector("V_M_ProjectionParams", vector4); if (!this.recalcViewMatrix) { this.cameraToWorldMatrix.f = this.camera.cameraToWorldMatrix; this.worldToCameraMatrix.f = this.camera.worldToCameraMatrix; } else { this.camera.transform.ExtractWorldCoordinates(out vector3G7, out quaternionG, out vector3G8); vector3G8.x = 1; vector3G8.y = 1; vector3G8.z = -1; Matrix4x4G.TRS(ref vector3G7, ref quaternionG, ref vector3G8, out this.cameraToWorldMatrix); if (Matrix4x4G.Inverse(ref this.cameraToWorldMatrix, out this.worldToCameraMatrix)) { this.camera.worldToCameraMatrix = this.worldToCameraMatrix.f; } } this.worldToCameraMatrixUnAltered = this.worldToCameraMatrix; this.cameraToWorldMatrixUnAltered = this.cameraToWorldMatrix; this.projectionMatrixUnAltered = this.projectionMatrix; CameraFX.ApplyTransitionAlterations(this.camera, this, true); Matrix4x4G matrix4x4G12 = this.worldToCameraMatrix; Matrix4x4G matrix4x4G13 = matrix4x4G12; this.projectViewport.modelview = matrix4x4G12; this.projectScreen.modelview = matrix4x4G13; Matrix4x4G matrix4x4G14 = this.projectionMatrix; matrix4x4G13 = matrix4x4G14; this.projectViewport.projection = matrix4x4G14; this.projectScreen.projection = matrix4x4G13; Rect rect = this.camera.pixelRect; this.projectScreen.offset.x = (double)rect.x; this.projectScreen.offset.y = (double)rect.y; this.projectScreen.size.x = (double)rect.width; this.projectScreen.size.y = (double)rect.height; rect = this.camera.rect; this.projectViewport.offset.x = (double)rect.x; this.projectViewport.offset.y = (double)rect.y; this.projectViewport.size.x = (double)rect.width; this.projectViewport.size.y = (double)rect.height; Matrix4x4G.Mult(ref this.localToWorldMatrix, ref this.worldToCameraMatrix, out matrix4x4G7); Matrix4x4G.Mult(ref matrix4x4G7, ref this.projectionMatrix, out matrix4x4G4); Matrix4x4G.Inverse(ref matrix4x4G7, out matrix4x4G8); Matrix4x4G.Inverse(ref matrix4x4G4, out matrix4x4G5); Matrix4x4G.Inverse(ref this.localToWorldMatrix, out matrix4x4G10); Matrix4x4G.Transpose(ref matrix4x4G5, out matrix4x4G6); Matrix4x4G.Transpose(ref matrix4x4G8, out matrix4x4G9); Matrix4x4G.Transpose(ref matrix4x4G10, out matrix4x4G11); if (this.viewModel) { this.viewModel.UpdateProxies(); } BoundHack.Achieve(base.transform.position); ContextSprite.UpdateSpriteFading(this.camera); PlayerClient playerClient = PlayerClient.localPlayerClient; if (playerClient) { playerClient.ProcessLocalPlayerPreRender(); } RPOS.BeforeSceneRender_Internal(this.camera); }
private static Vector3G LLERP(double t, Vector3G a, Vector3G b) { return(Linear(t, a, b)); }
public void Calculate(ref Vector3G v, ref double pow, ref double dt, ref Vector3G sum) { Vector3G vector3G = new Vector3G(); float single; bool flag; if (!this.once) { this.Gasp(); } if (!this.calc) { return; } float single1 = (!this.mask ? 1f : this.sourceMask.Evaluate((float)pow)); bool flag1 = (single1 == 0f ? true : single1 == 0f); if (!this.scaleFixed) { single = (!this.scale ? 1f : this.sourceScale.Evaluate((float)pow)); } else { single = 0f; } float single2 = single; if (this.scaleFixed) { flag = false; } else { flag = (single2 == 0f ? false : single2 != 0f); } bool flag2 = flag; if (!this.infoX.calc) { vector3G.x = 0; } else { if (flag2 && !this.infoX.constant) { v.x = v.x + pow * dt * (double)single2 * (double)this.positionScale.x; if (v.x > (double)this.infoX.duration) { v.x = v.x - (double)this.infoX.duration; } else if (v.x < (double)(-this.infoX.duration)) { v.x = v.x + (double)this.infoX.duration; } } vector3G.x = (double)((!flag1 ? this.forceX.Evaluate((float)v.x) * this.outputScale.x : 0f)); } if (!this.infoY.calc) { vector3G.y = 0; } else { if (flag2 && !this.infoY.constant) { v.y = v.y + pow * dt * (double)single2 * (double)this.positionScale.y; if (v.y > (double)this.infoY.duration) { v.y = v.y - (double)this.infoY.duration; } else if (v.y < (double)(-this.infoY.duration)) { v.y = v.y + (double)this.infoY.duration; } } vector3G.y = (double)((!flag1 ? this.forceY.Evaluate((float)v.y) * this.outputScale.y : 0f)); } if (!this.infoZ.calc) { vector3G.z = 0; } else { if (flag2 && !this.infoZ.constant) { v.z = v.z + pow * dt * (double)single2 * (double)this.positionScale.z; if (v.z > (double)this.infoZ.duration) { v.z = v.z - (double)this.infoZ.duration; } else if (v.z < (double)(-this.infoZ.duration)) { v.z = v.z + (double)this.infoZ.duration; } } vector3G.z = (double)((!flag1 ? this.forceZ.Evaluate((float)v.z) * this.outputScale.z : 0f)); } if (!flag1) { sum.x = sum.x + vector3G.x * (double)single1; sum.y = sum.y + vector3G.y * (double)single1; sum.z = sum.z + vector3G.z * (double)single1; } }
private static void SET_3X(ref Matrix4x4G m, Vector3G v) { m.m30 = v.x; m.m31 = v.y; m.m32 = v.z; }
private int Step(float dt) { int num = 0; int num2 = 0; this.timeSolve += dt; double d = (this.cfg.solveRate >= 0.0) ? (1.0 / ((double)this.cfg.solveRate)) : (1.0 / -((double)this.cfg.solveRate)); double num4 = (this.cfg.intermitRate != 0.0) ? ((this.cfg.intermitRate >= 0.0) ? (1.0 / ((double)this.cfg.intermitRate)) : (1.0 / -((double)this.cfg.intermitRate))) : 0.0; if (double.IsInfinity(d) || (d == 0.0)) { d = this.timeSolve; } bool flag = num4 > d; double num5 = d * this.cfg.timeScale; if (this.timeSolve >= d) { do { this.timeSolve -= d; if (flag) { this.timeIntermit -= d; if (this.timeIntermit < 0.0) { this.intermitStart = this.working; } } this.Solve(ref this.working, ref num5); if (flag && (this.timeIntermit < 0.0)) { this.intermitNext = this.working; this.intermitFraction = (this.timeIntermit + d) / d; this.timeIntermit += num4; num2++; } num++; }while (this.timeSolve >= d); } if (flag) { if (num2 > 0) { if (this.simStep) { Vector3G.Lerp(ref this.intermitStart.position.value, ref this.intermitNext.position.value, ref this.intermitFraction, out this.raw_pos); Vector3G.Lerp(ref this.intermitStart.rotation.value, ref this.intermitNext.rotation.value, ref this.intermitFraction, out this.raw_rot); this.CheckDeadZone(); return(num2); } this.raw_pos = this.intermitNext.position.value; this.raw_rot = this.intermitNext.rotation.value; this.CheckDeadZone(); } return(num2); } if (this.simStep) { this.working.CopyTo(ref this.predicted); this.Solve(ref this.predicted, ref num5); num = -(num + 1); double t = this.timeSolve / d; Vector3G.Lerp(ref this.working.position.value, ref this.predicted.position.value, ref t, out this.raw_pos); Vector3G.Lerp(ref this.working.rotation.value, ref this.predicted.rotation.value, ref t, out this.raw_rot); this.CheckDeadZone(); return(num); } this.raw_pos = this.working.position.value; this.raw_rot = this.working.rotation.value; this.CheckDeadZone(); return(num); }
public static double CrossDot(Vector3G a, Vector3G b, Vector3G dotB) { return (a.y * b.z - a.z * b.y) * dotB.x + (a.z * b.x - a.x * b.z) * dotB.y + (a.x * b.y - a.y * b.x) * dotB.z; }
public static Vector3G Normalize(Vector3G v) { Vector3G vector3G = new Vector3G(); double num = v.x * v.x + v.y * v.y + v.z * v.z; if (num == 0 || num == 1) { return v; } num = TransitionFunctions.Sqrt(num); vector3G.x = v.x / num; vector3G.y = v.y / num; vector3G.z = v.z / num; return vector3G; }
private static void SET_X2(ref Matrix4x4G m, Vector3G v) { m.m02 = v.x; m.m12 = v.y; m.m22 = v.z; }
public static Vector3G Z3(double z) { Vector3G vector3G = new Vector3G(); double num = 0; double num1 = num; vector3G.y = num; vector3G.x = num1; vector3G.z = z; return vector3G; }
private static Vector3G SLERP(double t, Vector3G a, Vector3G b) { return TransitionFunctions.Slerp(t, a, b); }
private static void DIR_Z(ref Matrix4x4G a, Vector3G v) { TransitionFunctions.SET_X2(ref a, v); }
private static Vector3G VECT3F(double x, double y, double z) { Vector3G vector3G = new Vector3G(); vector3G.x = x; vector3G.y = y; vector3G.z = z; return vector3G; }
public static Vector3G Cross(Vector3G a, Vector3G b) { Vector3G vector3G = new Vector3G(); vector3G.x = a.y * b.z - a.z * b.y; vector3G.y = a.z * b.x - a.x * b.z; vector3G.z = a.x * b.y - a.y * b.x; return vector3G; }
public static double DotNormal(Vector3G a, Vector3G b) { return TransitionFunctions.Dot(TransitionFunctions.Normalize(a), TransitionFunctions.Normalize(b)); }
private static Vector3G LLERP(double t, Vector3G a, Vector3G b) { return TransitionFunctions.Linear(t, a, b); }
public static Vector3G Evaluate(this TransitionFunction f, double t, Vector3G a, Vector3G b) { switch (f) { case TransitionFunction.Linear: { return TransitionFunctions.Linear(t, a, b); } case TransitionFunction.Round: { return TransitionFunctions.Round(t, a, b); } case TransitionFunction.Floor: { return TransitionFunctions.Floor(t, a, b); } case TransitionFunction.Ceil: { return TransitionFunctions.Ceil(t, a, b); } case TransitionFunction.Spline: { return TransitionFunctions.Spline(t, a, b); } } throw new ArgumentOutOfRangeException("v", "Attempted use of unrecognized TransitionFunction enum value"); }
private static void SCALE(ref Matrix4x4G a, Vector3G v) { TransitionFunctions.SET_3X(ref a, v); }
public static double Length(Vector3G a) { return TransitionFunctions.Sqrt(a.x * a.x + a.y * a.y + a.z * a.z); }
private static void SET_0X(ref Matrix4x4G m, Vector3G v) { m.m00 = v.x; m.m01 = v.y; m.m02 = v.z; }
public static Vector3G Linear(double t, Vector3G a, Vector3G b) { return TransitionFunctions.Sum(TransitionFunctions.Mul(a, 1 - t), TransitionFunctions.Mul(b, t)); }
private static void SET_1X(ref Matrix4x4G m, Vector3G v) { m.m10 = v.x; m.m11 = v.y; m.m12 = v.z; }
public static Vector3G Mul(Vector3G a, double b) { Vector3G vector3G = new Vector3G(); vector3G.x = a.x * b; vector3G.y = a.y * b; vector3G.z = a.z * b; return vector3G; }
private void Solve(ref HeadBob.Weight weight, ref double dt) { Vector3G vector3G = new Vector3G(); double num; vector3G.x = dt * this.groundLocalVelocity.x * (double)this.cfg.forceSpeedMultiplier.x; vector3G.y = dt * this.groundLocalVelocity.y * (double)this.cfg.forceSpeedMultiplier.y; vector3G.z = dt * this.groundLocalVelocity.z * (double)this.cfg.forceSpeedMultiplier.z; Vector3G vector3G1 = weight.position.fE; Vector3G vector3G2 = weight.rotation.fE; Vector3G vector3G3 = new Vector3G(); weight.position.fE = vector3G3; Vector3G vector3G4 = new Vector3G(); weight.rotation.fE = vector3G4; if (this.anyAdditionalCurves) { for (int i = 0; i < this.additionalCurveCount; i++) { BobForceCurve bobForceCurve = this.cfg.additionalCurves[i]; switch (bobForceCurve.source) { case BobForceCurveSource.LocalMovementMagnitude: { num = this.groundLocalVelocityMag; break; } case BobForceCurveSource.LocalMovementX: { num = this.groundLocalVelocity.x; break; } case BobForceCurveSource.LocalMovementY: { num = this.groundLocalVelocity.y; break; } case BobForceCurveSource.LocalMovementZ: { num = this.groundLocalVelocity.z; break; } case BobForceCurveSource.WorldMovementMagnitude: { num = this.groundWorldVelocityMag; break; } case BobForceCurveSource.WorldMovementX: { num = this.groundWorldVelocity.x; break; } case BobForceCurveSource.WorldMovementY: { num = this.groundWorldVelocity.y; break; } case BobForceCurveSource.WorldMovementZ: { num = this.groundWorldVelocity.z; break; } case BobForceCurveSource.LocalVelocityMagnitude: { num = this.localVelocityMag; break; } case BobForceCurveSource.LocalVelocityX: { num = this.localVelocity.x; break; } case BobForceCurveSource.LocalVelocityY: { num = this.localVelocity.y; break; } case BobForceCurveSource.LocalVelocityZ: { num = this.localVelocity.z; break; } case BobForceCurveSource.WorldVelocityMagnitude: { num = this.worldVelocityMag; break; } case BobForceCurveSource.WorldVelocityX: { num = this.worldVelocity.x; break; } case BobForceCurveSource.WorldVelocityY: { num = this.worldVelocity.y; break; } case BobForceCurveSource.WorldVelocityZ: { num = this.worldVelocity.z; break; } case BobForceCurveSource.RotationMagnitude: { num = this.localAngularVelocityMag; break; } case BobForceCurveSource.RotationPitch: { num = this.localAngularVelocity.x; break; } case BobForceCurveSource.RotationYaw: { num = this.localAngularVelocity.y; break; } case BobForceCurveSource.RotationRoll: { num = this.localAngularVelocity.z; break; } case BobForceCurveSource.TurnMagnitude: { num = this.groundLocalAngularVelocityMag; break; } case BobForceCurveSource.TurnPitch: { num = this.groundLocalAngularVelocity.x; break; } case BobForceCurveSource.TurnYaw: { num = this.groundLocalAngularVelocity.y; break; } case BobForceCurveSource.TurnRoll: { num = this.groundLocalAngularVelocity.z; break; } default: { goto case BobForceCurveSource.LocalVelocityZ; } } BobForceCurveTarget bobForceCurveTarget = bobForceCurve.target; if (bobForceCurveTarget != BobForceCurveTarget.Position) { if (bobForceCurveTarget != BobForceCurveTarget.Rotation) { goto Label3; } bobForceCurve.Calculate(ref weight.additionalPositions[i], ref num, ref dt, ref weight.rotation.fE); goto Label1; } Label3: bobForceCurve.Calculate(ref weight.additionalPositions[i], ref num, ref dt, ref weight.position.fE); Label1: } } if (this.cfg.impulseForceSmooth <= 0f) { weight.position.fI = this.impulseForce.accel; } else { Vector3G.SmoothDamp(ref weight.position.fI, ref this.impulseForce.accel, ref weight.position.fIV, this.cfg.impulseForceSmooth, this.cfg.impulseForceMaxChangeAcceleration, ref dt); } if (this.cfg.angleImpulseForceSmooth <= 0f) { weight.rotation.fI = this.impulseTorque.accel; } else { Vector3G.SmoothDamp(ref weight.rotation.fI, ref this.impulseTorque.accel, ref weight.rotation.fIV, this.cfg.angleImpulseForceSmooth, this.cfg.angleImpulseForceMaxChangeAcceleration, ref dt); } weight.position.fE.x = weight.position.fE.x + (this.inputForce.x + weight.position.fI.x * (double)this.cfg.impulseForceScale.x); weight.position.fE.y = weight.position.fE.y + (this.inputForce.y + weight.position.fI.y * (double)this.cfg.impulseForceScale.y); weight.position.fE.z = weight.position.fE.z + (this.inputForce.z + weight.position.fI.z * (double)this.cfg.impulseForceScale.z); weight.rotation.fE.x = weight.rotation.fE.x + weight.rotation.fI.x * (double)this.cfg.angularImpulseForceScale.x; weight.rotation.fE.y = weight.rotation.fE.y + weight.rotation.fI.y * (double)this.cfg.angularImpulseForceScale.y; weight.rotation.fE.z = weight.rotation.fE.z + weight.rotation.fI.z * (double)this.cfg.angularImpulseForceScale.z; Vector3G vector3G5 = weight.position.@value; vector3G5.x = vector3G5.x / (double)this.cfg.elipsoidRadii.x; vector3G5.y = vector3G5.y / (double)this.cfg.elipsoidRadii.y; vector3G5.z = vector3G5.z / (double)this.cfg.elipsoidRadii.z; double num1 = vector3G5.x * vector3G5.x + vector3G5.y * vector3G5.y + vector3G5.z * vector3G5.z; if (num1 > 1) { num1 = 1 / Math.Sqrt(num1); vector3G5.x = vector3G5.x * num1; vector3G5.y = vector3G5.y * num1; vector3G5.z = vector3G5.z * num1; } vector3G5.x = vector3G5.x * (double)this.cfg.elipsoidRadii.x; vector3G5.y = vector3G5.y * (double)this.cfg.elipsoidRadii.y; vector3G5.z = vector3G5.z * (double)this.cfg.elipsoidRadii.z; weight.stack.Simulate(ref dt, ref weight.position.fE, ref weight.rotation.fE); weight.position.acceleration.x = weight.position.fE.x - vector3G1.x + (vector3G5.x * (double)(-this.cfg.springConstant.x) - weight.position.velocity.x * (double)this.cfg.springDampen.x) * (double)this.cfg.weightMass; weight.position.acceleration.y = weight.position.fE.y - vector3G1.y + (vector3G5.y * (double)(-this.cfg.springConstant.y) - weight.position.velocity.y * (double)this.cfg.springDampen.y) * (double)this.cfg.weightMass; weight.position.acceleration.z = weight.position.fE.z - vector3G1.z + (vector3G5.z * (double)(-this.cfg.springConstant.z) - weight.position.velocity.z * (double)this.cfg.springDampen.z) * (double)this.cfg.weightMass; weight.position.velocity.x = weight.position.velocity.x + weight.position.acceleration.x * dt; weight.position.velocity.y = weight.position.velocity.y + weight.position.acceleration.y * dt; weight.position.velocity.z = weight.position.velocity.z + weight.position.acceleration.z * dt; if (float.IsInfinity(this.cfg.maxVelocity.x)) { [email protected] = [email protected] + weight.position.velocity.x * dt; } else if (weight.position.velocity.x < (double)(-this.cfg.maxVelocity.x)) { [email protected] = [email protected] - (double)this.cfg.maxVelocity.x * dt; } else if (weight.position.velocity.x <= (double)this.cfg.maxVelocity.x) { [email protected] = [email protected] + weight.position.velocity.x * dt; } else { [email protected] = [email protected] + (double)this.cfg.maxVelocity.x * dt; } if (float.IsInfinity(this.cfg.maxVelocity.y)) { [email protected] = [email protected] + weight.position.velocity.y * dt; } else if (weight.position.velocity.y < (double)(-this.cfg.maxVelocity.y)) { [email protected] = [email protected] - (double)this.cfg.maxVelocity.y * dt; } else if (weight.position.velocity.y <= (double)this.cfg.maxVelocity.y) { [email protected] = [email protected] + weight.position.velocity.y * dt; } else { [email protected] = [email protected] + (double)this.cfg.maxVelocity.y * dt; } if (float.IsInfinity(this.cfg.maxVelocity.z)) { [email protected] = [email protected] + weight.position.velocity.z * dt; } else if (weight.position.velocity.z < (double)(-this.cfg.maxVelocity.z)) { [email protected] = [email protected] - (double)this.cfg.maxVelocity.z * dt; } else if (weight.position.velocity.z <= (double)this.cfg.maxVelocity.z) { [email protected] = [email protected] + weight.position.velocity.z * dt; } else { [email protected] = [email protected] + (double)this.cfg.maxVelocity.z * dt; } weight.rotation.acceleration.x = weight.rotation.fE.x - vector3G2.x + ([email protected] * (double)(-this.cfg.angularSpringConstant.x) - weight.rotation.velocity.x * (double)this.cfg.angularSpringDampen.x) * (double)this.cfg.angularWeightMass; weight.rotation.acceleration.y = weight.rotation.fE.y - vector3G2.y + ([email protected] * (double)(-this.cfg.angularSpringConstant.y) - weight.rotation.velocity.y * (double)this.cfg.angularSpringDampen.y) * (double)this.cfg.angularWeightMass; weight.rotation.acceleration.z = weight.rotation.fE.z - vector3G2.z + ([email protected] * (double)(-this.cfg.angularSpringConstant.z) - weight.rotation.velocity.z * (double)this.cfg.angularSpringDampen.z) * (double)this.cfg.angularWeightMass; weight.rotation.velocity.x = weight.rotation.velocity.x + weight.rotation.acceleration.x * dt; weight.rotation.velocity.y = weight.rotation.velocity.y + weight.rotation.acceleration.y * dt; weight.rotation.velocity.z = weight.rotation.velocity.z + weight.rotation.acceleration.z * dt; [email protected] = [email protected] + weight.rotation.velocity.x * dt; [email protected] = [email protected] + weight.rotation.velocity.y * dt; [email protected] = [email protected] + weight.rotation.velocity.z * dt; }
public static Vector3G Rotate(QuaternionG rotation, Vector3G vector) { Vector3G vector3G; QuaternionG.Mult(ref rotation, ref vector, out vector3G); return vector3G; }
public void Calculate(ref Vector3G v, ref double pow, ref double dt, ref Vector3G sum) { if (!this.once) { this.Gasp(); } if (this.calc) { Vector3G vectorg; float num = !this.mask ? 1f : this.sourceMask.Evaluate((float)pow); bool flag = (num == 0f) || (num == 0f); float num2 = !this.scaleFixed ? (!this.scale ? 1f : this.sourceScale.Evaluate((float)pow)) : 0f; bool flag2 = !this.scaleFixed && ((num2 != 0f) && (num2 != 0f)); if (this.infoX.calc) { if (flag2 && !this.infoX.constant) { v.x += ((pow * dt) * num2) * this.positionScale.x; if (v.x > this.infoX.duration) { v.x -= this.infoX.duration; } else if (v.x < -this.infoX.duration) { v.x += this.infoX.duration; } } vectorg.x = !flag ? ((double)(this.forceX.Evaluate((float)v.x) * this.outputScale.x)) : ((double)0f); } else { vectorg.x = 0.0; } if (this.infoY.calc) { if (flag2 && !this.infoY.constant) { v.y += ((pow * dt) * num2) * this.positionScale.y; if (v.y > this.infoY.duration) { v.y -= this.infoY.duration; } else if (v.y < -this.infoY.duration) { v.y += this.infoY.duration; } } vectorg.y = !flag ? ((double)(this.forceY.Evaluate((float)v.y) * this.outputScale.y)) : ((double)0f); } else { vectorg.y = 0.0; } if (this.infoZ.calc) { if (flag2 && !this.infoZ.constant) { v.z += ((pow * dt) * num2) * this.positionScale.z; if (v.z > this.infoZ.duration) { v.z -= this.infoZ.duration; } else if (v.z < -this.infoZ.duration) { v.z += this.infoZ.duration; } } vectorg.z = !flag ? ((double)(this.forceZ.Evaluate((float)v.z) * this.outputScale.z)) : ((double)0f); } else { vectorg.z = 0.0; } if (!flag) { sum.x += vectorg.x * num; sum.y += vectorg.y * num; sum.z += vectorg.z * num; } } }