Esempio n. 1
0
    public void CalculateWind(HookesLaw.Particle p1, HookesLaw.Particle p2, HookesLaw.Particle p3, Vector3 windDir, float p, float cd)
    {
        Vector3 vsurface = p1.velocity + p2.velocity + p3.velocity / 3;
        Vector3 v        = vsurface - windDir;
        Vector3 n        = Vector3.Cross((p2.position - p1.position), (p3.position - p1.position)).normalized;
        float   a        = Vector3.Dot(v, n) / v.magnitude;

        Vector3 f = -.5f * p * (v.magnitude * v.magnitude) * cd * a * n;

        p1.AddForce(f / 3);
        p2.AddForce(f / 3);
        p3.AddForce(f / 3);
    }
Esempio n. 2
0
        public void Spring(Particle a, Particle b)
        {
            var dir = b.Position - a.Position;

            var dirNormal = dir.normalized;

            var dist = (a.Position - b.Position).magnitude;

            var L = sd._lo - dist;

            var force = -sd._ks * L * dirNormal;

            a.AddForce(force);
            b.AddForce(-force);
        }
Esempio n. 3
0
        public void CalculateForce()
        {
            Vector3 estar = p2.position - p1.position;
            float   l     = Vector3.Magnitude(estar);
            Vector3 e     = Vector3.Normalize(estar);

            float v1 = Vector3.Dot(e, p1.velocity);
            float v2 = Vector3.Dot(e, p2.velocity);

            float Fsminusd = (-Ks * (Lo - l)) - (Kd * (v1 - v2));

            Vector3 correction = Fsminusd * e;

            p1.AddForce(correction);
            p2.AddForce(-correction);
        }
        public void BacktoNormal()
        {
            Vector3 estar = _p2.position - _p1.position;
            float   _l    = estar.magnitude;
            Vector3 _E    = estar / _l;

            float _v1 = Vector3.Dot(_E, _p1.velocity);
            float _v2 = Vector3.Dot(_E, _p2.velocity);

            float Fsd = (-_Ks * (_Lo - _l)) - (_Kd * (_v1 - _v2));

            Vector3 _f1 = Fsd * _E;
            Vector3 _f2 = -_f1;

            _p1.AddForce(_f1);
            _p2.AddForce(_f2);
        }
Esempio n. 5
0
        public void AerodynamicForce(Vector3 Force)
        {
            var crossA = Particle2.Position - Particle1.Position;
            var crossB = Particle3.Position - Particle1.Position;

            var v = (Particle1.Velocity + Particle2.Velocity + Particle3.Velocity) / 3f - Force;

            var a0 = .5f * Vector3.Cross(crossA.normalized, crossB.normalized).magnitude;

            var n = Vector3.Cross(crossA, crossB).normalized;

            var a = a0 * (Vector3.Dot(v, n) / v.magnitude);

            var force = -.5f * p * (v.magnitude * v.magnitude) * Cd * a * n;

            Particle1.AddForce(force / 3f);
            Particle2.AddForce(force / 3f);
            Particle3.AddForce(force / 3f);
        }
Esempio n. 6
0
        public void SpringDot(Particle a, Particle b, float springK, float springD)
        {
            sd._ks = springK;
            sd._kd = springD;

            var dir = b.Position - a.Position;
            var l   = dir.magnitude;
            var e   = dir / l;

            var v1 = Vector3.Dot(e, a.Velocity);
            var v2 = Vector3.Dot(e, b.Velocity);

            var s = sd._ks * (sd._lo - l);
            var d = sd._kd * (v1 - v2);

            var f  = -s - d;
            var f1 = f * e;
            var f2 = -f1;

            a.AddForce(f1);
            b.AddForce(f2);
        }