Esempio n. 1
0
    void ApplyForce(ref SpringHandler.particle[] ps, SpringHandler.spring[] ss)
    {
        for (int i = 0; i < count; i++)
        {
            SpringHandler.particle p = ps[i];
            if (!(p.isFixed == 1))
            {
                Vector3 gravity          = new Vector3(0, -5f, 0);
                float   mass             = p.mass;
                Vector3 dampingForce     = new Vector3(0, 0, 0);
                Vector3 springForce      = new Vector3(0, 0, 0);
                Vector3 tempSpringForce  = new Vector3(0, 0, 0);
                Vector3 tempdampingForce = new Vector3(0, 0, 0);

                if (ps[i].structuralSprings.x != -1)
                {
                    SpringHandler.GetSpringForce(ref ss, ref ps, out tempdampingForce, out tempSpringForce, ps[i], ps[i].structuralSprings.x);
                    dampingForce += tempdampingForce;
                    springForce  += tempSpringForce;
                }

                if (ps[i].structuralSprings.y != -1)
                {
                    SpringHandler.GetSpringForce(ref ss, ref ps, out tempdampingForce, out tempSpringForce, ps[i], ps[i].structuralSprings.y);
                    dampingForce += tempdampingForce;
                    springForce  += tempSpringForce;
                }

                if (ps[i].structuralSprings.z != -1)
                {
                    SpringHandler.GetSpringForce(ref ss, ref ps, out tempdampingForce, out tempSpringForce, ps[i], ps[i].structuralSprings.z);
                    dampingForce += tempdampingForce;
                    springForce  += tempSpringForce;
                }

                if (ps[i].structuralSprings.w != -1)
                {
                    SpringHandler.GetSpringForce(ref ss, ref ps, out tempdampingForce, out tempSpringForce, ps[i], ps[i].structuralSprings.w);
                    dampingForce += tempdampingForce;
                    springForce  += tempSpringForce;
                }

                Vector3 force        = dampingForce + springForce + mass * gravity;
                Vector3 acceleration = force / mass;


                p.velocity = p.velocity + acceleration * Time.deltaTime;
                p.position = p.position + p.velocity * Time.deltaTime;

                ps[i].position = p.position;
                ps[i].velocity = p.velocity;
            }
        }
    }
Esempio n. 2
0
 void DrawConnections(SpringHandler.particle[] ps, SpringHandler.spring[] ss, int i)
 {
     if (drawStructuralSprings)
     {
         SpringHandler.DrawStructuralSprings(ps, ss, i);
     }
     if (drawShearSprings)
     {
         SpringHandler.DrawShearSprings(ps, ss, i);
     }
     if (drawStructuralBendingSprings)
     {
         SpringHandler.DrawStructuralBendingSprings(ps, ss, i);
     }
     if (drawShearBendingSprings)
     {
         SpringHandler.DrawShearBendingSprings(ps, ss, i);
     }
 }
Esempio n. 3
0
    void Update()
    {
        if (clothHandler != null)
        {
            clothComputeShader.SetVector("fixedPos", clothHandler.transform.position);
        }
        clothComputeShader.SetFloat("globalStiffness", globalStiffness);
        clothComputeShader.SetFloat("globalDamping", damping);
        clothComputeShader.SetFloat("mass", mass);
        clothComputeShader.SetFloat("gravityMul", gravityMul);
        clothComputeShader.SetVector("spherePos", sphereCollider.transform.position);
        clothComputeShader.SetFloat("sphereRadius", sphereCollider.transform.lossyScale.y / 2);

        for (int i = 0; i < solverSteps; i++)
        {
            clothComputeShader.SetFloat("deltaTime", Time.deltaTime / solverSteps);
            clothComputeShader.Dispatch(mainClothKernelHandler, count / 8, 1, 1);
        }

        SpringHandler.particle[] ps = new SpringHandler.particle[count];
        SpringHandler.spring[]   ss = new SpringHandler.spring[springCount];

        particleBuffer.GetData(ps);
        springBuffer.GetData(ss);

        if (drawCloth)
        {
            DrawAllConnections(ps, ss);
        }
        if (drawVelocities)
        {
            SpringHandler.DrawVelocity(ps);
        }

        if (printDebug)
        {
            Print("Velocities", ps);
            printDebug = false;
        }

        for (int i = 0; i < ss.Length; i++)
        {
            SpringHandler.spring s = ss[i];
            switch ((SpringHandler.SpringType)s.springType)
            {
            case (SpringHandler.SpringType.StructuralSpring):
                s = SpringHandler.ApplyChanges(s, structuralSpringVars);
                break;

            case (SpringHandler.SpringType.ShearSpring):
                s = SpringHandler.ApplyChanges(s, shearSpringVars);
                break;

            case (SpringHandler.SpringType.StructuralBendingSpring):
                s = SpringHandler.ApplyChanges(s, structuralBendingSpringVars);
                break;

            case (SpringHandler.SpringType.ShearBendingSpring):
                s = SpringHandler.ApplyChanges(s, shearBendingSpringVars);
                break;
            }
            ss[i] = s;
        }

        particleBuffer.SetData(ps);
        springBuffer.SetData(ss);
    }
Esempio n. 4
0
    void AddSprings(int x, int y, int rows, SpringHandler.particle[] particles, ref List <SpringHandler.spring> springs)
    {
        //Get Structural springs
        if (y < rows - 1)
        {
            particles[y + x * rows].structuralSprings.x = springs.Count;
            int connectedParticleIndex;
            springs.Add(SpringHandler.GetSpring(x, y, rows, out connectedParticleIndex, 0, 1, structuralSpringVars, SpringHandler.SpringType.StructuralSpring));
            particles[connectedParticleIndex].structuralSprings.w = springs.Count - 1;
        }

        if (x < rows - 1)
        {
            particles[y + x * rows].structuralSprings.y = springs.Count;
            int connectedParticleIndex;
            springs.Add(SpringHandler.GetSpring(x, y, rows, out connectedParticleIndex, 1, 0, structuralSpringVars, SpringHandler.SpringType.StructuralSpring));
            particles[connectedParticleIndex].structuralSprings.z = springs.Count - 1;
        }
        //Get Shear Springs
        if (y < rows - 1 && x < rows - 1)
        {
            particles[y + x * rows].shearSprings.x = springs.Count;
            int connectedParticleIndex;
            springs.Add(SpringHandler.GetSpring(x, y, rows, out connectedParticleIndex, 1, 1, shearSpringVars, SpringHandler.SpringType.ShearSpring));
            particles[connectedParticleIndex].shearSprings.z = springs.Count - 1;
        }

        if (y < rows - 1 && x > 0)
        {
            particles[y + x * rows].shearSprings.y = springs.Count;
            int connectedParticleIndex;
            springs.Add(SpringHandler.GetSpring(x, y, rows, out connectedParticleIndex, -1, 1, shearSpringVars, SpringHandler.SpringType.ShearSpring));
            particles[connectedParticleIndex].shearSprings.w = springs.Count - 1;
        }

        //Get shearBendingSprings
        int BendRange = 2;

        if (y < rows - BendRange && x < rows - BendRange)
        {
            particles[y + x * rows].shearBendingSprings.x = springs.Count;
            int connectedParticleIndex;
            springs.Add(SpringHandler.GetSpring(x, y, rows, out connectedParticleIndex, BendRange, BendRange, shearBendingSpringVars, SpringHandler.SpringType.ShearBendingSpring));
            particles[connectedParticleIndex].shearBendingSprings.z = springs.Count - 1;
        }

        if (y < rows - BendRange && x > BendRange - 1)
        {
            particles[y + x * rows].shearBendingSprings.y = springs.Count;
            int connectedParticleIndex;
            springs.Add(SpringHandler.GetSpring(x, y, rows, out connectedParticleIndex, -BendRange, BendRange, shearBendingSpringVars, SpringHandler.SpringType.ShearBendingSpring));
            particles[connectedParticleIndex].shearBendingSprings.w = springs.Count - 1;
        }

        //Get structutralBendingSprings
        if (y < rows - BendRange)
        {
            particles[y + x * rows].structutralBendingSprings.x = springs.Count;
            int connectedParticleIndex;
            springs.Add(SpringHandler.GetSpring(x, y, rows, out connectedParticleIndex, 0, BendRange, structuralBendingSpringVars, SpringHandler.SpringType.StructuralBendingSpring));
            particles[connectedParticleIndex].structutralBendingSprings.z = springs.Count - 1;
        }

        if (x < rows - BendRange)
        {
            particles[y + x * rows].structutralBendingSprings.y = springs.Count;
            int connectedParticleIndex;
            springs.Add(SpringHandler.GetSpring(x, y, rows, out connectedParticleIndex, BendRange, 0, structuralBendingSpringVars, SpringHandler.SpringType.StructuralBendingSpring));
            particles[connectedParticleIndex].structutralBendingSprings.w = springs.Count - 1;
        }
    }