//Where the damage is actually applied
        void DamageApplication(Vector3 damagePoint, Vector3 damageForce, float damageForceLimit, Vector3 surfaceNormal, ContactPoint colPoint, bool useContactPoint)
        {
            float          colMag        = Mathf.Min(damageForce.magnitude, maxCollisionMagnitude) * (1 - strength) * damageFactor; //Magnitude of collision
            float          clampedColMag = Mathf.Pow(Mathf.Sqrt(colMag) * 0.5f, 1.5f);                                              //Clamped magnitude of collision
            Vector3        clampedVel    = Vector3.ClampMagnitude(damageForce, damageForceLimit);                                   //Clamped velocity of collision
            Vector3        normalizedVel = damageForce.normalized;
            float          surfaceDot;                                                                                              //Dot production of collision velocity and surface normal
            float          massFactor = 1;                                                                                          //Multiplier for damage based on mass of other rigidbody
            Transform      curDamagePart;
            float          damagePartFactor;
            MeshFilter     curDamageMesh;
            Transform      curDisplacePart;
            Transform      seamKeeper = null;//Transform for maintaining seams on shattered parts
            Vector3        seamLocalPoint;
            Vector3        vertProjection;
            Vector3        translation;
            Vector3        clampedTranslation;
            Vector3        localPos;
            float          vertDist;
            float          distClamp;
            DetachablePart detachedPart;
            Suspension     damagedSus;

            //Get mass factor for multiplying damage
            if (useContactPoint)
            {
                damagePoint   = colPoint.point;
                surfaceNormal = colPoint.normal;

                if (colPoint.otherCollider.attachedRigidbody)
                {
                    massFactor = Mathf.Clamp01(colPoint.otherCollider.attachedRigidbody.mass / rb.mass);
                }
            }

            surfaceDot = Mathf.Clamp01(Vector3.Dot(surfaceNormal, normalizedVel)) * (Vector3.Dot((tr.position - damagePoint).normalized, normalizedVel) + 1) * 0.5f;

            //Damage damageable parts
            for (int i = 0; i < damageParts.Length; i++)
            {
                curDamagePart    = damageParts[i];
                damagePartFactor = colMag * surfaceDot * massFactor * Mathf.Min(clampedColMag * 0.01f, (clampedColMag * 0.001f) / Mathf.Pow(Vector3.Distance(curDamagePart.position, damagePoint), clampedColMag));

                //Damage motors
                Motor damagedMotor = curDamagePart.GetComponent <Motor>();
                if (damagedMotor)
                {
                    damagedMotor.health -= damagePartFactor * (1 - damagedMotor.strength);
                }

                //Damage transmissions
                Transmission damagedTransmission = curDamagePart.GetComponent <Transmission>();
                if (damagedTransmission)
                {
                    damagedTransmission.health -= damagePartFactor * (1 - damagedTransmission.strength);
                }
            }

            //Deform meshes
            for (int i = 0; i < deformMeshes.Length; i++)
            {
                curDamageMesh      = deformMeshes[i];
                localPos           = curDamageMesh.transform.InverseTransformPoint(damagePoint);
                translation        = curDamageMesh.transform.InverseTransformDirection(clampedVel);
                clampedTranslation = Vector3.ClampMagnitude(translation, clampedColMag);

                //Shatter parts that can shatter
                ShatterPart shattered = curDamageMesh.GetComponent <ShatterPart>();
                if (shattered)
                {
                    seamKeeper = shattered.seamKeeper;
                    if (Vector3.Distance(curDamageMesh.transform.position, damagePoint) < colMag * surfaceDot * 0.1f * massFactor && colMag * surfaceDot * massFactor > shattered.breakForce)
                    {
                        shattered.Shatter();
                    }
                }

                //Actual deformation
                if (translation.sqrMagnitude > 0 && strength < 1)
                {
                    for (int j = 0; j < meshVertices[i].verts.Length; j++)
                    {
                        vertDist  = Vector3.Distance(meshVertices[i].verts[j], localPos);
                        distClamp = (clampedColMag * 0.001f) / Mathf.Pow(vertDist, clampedColMag);

                        if (distClamp > 0.001f)
                        {
                            damagedMeshes[i] = true;
                            if (seamKeeper == null || seamlessDeform)
                            {
                                vertProjection            = seamlessDeform ? Vector3.zero : Vector3.Project(normalizedVel, meshVertices[i].verts[j]);
                                meshVertices[i].verts[j] += (clampedTranslation - vertProjection * (usePerlinNoise ? 1 + Mathf.PerlinNoise(meshVertices[i].verts[j].x * 100, meshVertices[i].verts[j].y * 100) : 1)) * surfaceDot * Mathf.Min(clampedColMag * 0.01f, distClamp) * massFactor;
                            }
                            else
                            {
                                seamLocalPoint            = seamKeeper.InverseTransformPoint(curDamageMesh.transform.TransformPoint(meshVertices[i].verts[j]));
                                meshVertices[i].verts[j] += (clampedTranslation - Vector3.Project(normalizedVel, seamLocalPoint) * (usePerlinNoise ? 1 + Mathf.PerlinNoise(seamLocalPoint.x * 100, seamLocalPoint.y * 100) : 1)) * surfaceDot * Mathf.Min(clampedColMag * 0.01f, distClamp) * massFactor;
                            }
                        }
                    }
                }
            }

            seamKeeper = null;

            //Deform mesh colliders
            for (int i = 0; i < deformColliders.Length; i++)
            {
                localPos           = deformColliders[i].transform.InverseTransformPoint(damagePoint);
                translation        = deformColliders[i].transform.InverseTransformDirection(clampedVel);
                clampedTranslation = Vector3.ClampMagnitude(translation, clampedColMag);

                if (translation.sqrMagnitude > 0 && strength < 1)
                {
                    for (int j = 0; j < colVertices[i].verts.Length; j++)
                    {
                        vertDist  = Vector3.Distance(colVertices[i].verts[j], localPos);
                        distClamp = (clampedColMag * 0.001f) / Mathf.Pow(vertDist, clampedColMag);

                        if (distClamp > 0.001f)
                        {
                            damagedCols[i]           = true;
                            colVertices[i].verts[j] += clampedTranslation * surfaceDot * Mathf.Min(clampedColMag * 0.01f, distClamp) * massFactor;
                        }
                    }
                }
            }


            //Displace parts
            for (int i = 0; i < displaceParts.Length; i++)
            {
                curDisplacePart    = displaceParts[i];
                translation        = clampedVel;
                clampedTranslation = Vector3.ClampMagnitude(translation, clampedColMag);

                if (translation.sqrMagnitude > 0 && strength < 1)
                {
                    vertDist  = Vector3.Distance(curDisplacePart.position, damagePoint);
                    distClamp = (clampedColMag * 0.001f) / Mathf.Pow(vertDist, clampedColMag);

                    if (distClamp > 0.001f)
                    {
                        curDisplacePart.position += clampedTranslation * surfaceDot * Mathf.Min(clampedColMag * 0.01f, distClamp) * massFactor;

                        //Detach detachable parts
                        if (curDisplacePart.GetComponent <DetachablePart>())
                        {
                            detachedPart = curDisplacePart.GetComponent <DetachablePart>();

                            if (colMag * surfaceDot * massFactor > detachedPart.looseForce && detachedPart.looseForce >= 0)
                            {
                                detachedPart.initialPos = curDisplacePart.localPosition;
                                detachedPart.Detach(true);
                            }
                            else if (colMag * surfaceDot * massFactor > detachedPart.breakForce)
                            {
                                detachedPart.Detach(false);
                            }
                        }
                        //Maybe the parent of this part is what actually detaches, useful for displacing compound colliders that represent single detachable objects
                        else if (curDisplacePart.parent.GetComponent <DetachablePart>())
                        {
                            detachedPart = curDisplacePart.parent.GetComponent <DetachablePart>();

                            if (!detachedPart.detached)
                            {
                                if (colMag * surfaceDot * massFactor > detachedPart.looseForce && detachedPart.looseForce >= 0)
                                {
                                    detachedPart.initialPos = curDisplacePart.parent.localPosition;
                                    detachedPart.Detach(true);
                                }
                                else if (colMag * surfaceDot * massFactor > detachedPart.breakForce)
                                {
                                    detachedPart.Detach(false);
                                }
                            }
                            else if (detachedPart.hinge)
                            {
                                detachedPart.displacedAnchor += curDisplacePart.parent.InverseTransformDirection(clampedTranslation * surfaceDot * Mathf.Min(clampedColMag * 0.01f, distClamp) * massFactor);
                            }
                        }

                        //Damage suspensions and wheels
                        damagedSus = curDisplacePart.GetComponent <Suspension>();
                        if (damagedSus)
                        {
                            if ((!damagedSus.wheel.grounded && ignoreGroundedWheels) || !ignoreGroundedWheels)
                            {
                                curDisplacePart.RotateAround(damagedSus.tr.TransformPoint(damagedSus.damagePivot), Vector3.ProjectOnPlane(damagePoint - curDisplacePart.position, -translation.normalized), clampedColMag * surfaceDot * distClamp * 20 * massFactor);

                                damagedSus.wheel.damage += clampedColMag * surfaceDot * distClamp * 10 * massFactor;

                                if (clampedColMag * surfaceDot * distClamp * 10 * massFactor > damagedSus.jamForce)
                                {
                                    damagedSus.jammed = true;
                                }

                                if (clampedColMag * surfaceDot * distClamp * 10 * massFactor > damagedSus.wheel.detachForce)
                                {
                                    damagedSus.wheel.Detach();
                                }

                                foreach (SuspensionPart curPart in damagedSus.movingParts)
                                {
                                    if (curPart.connectObj && !curPart.isHub && !curPart.solidAxle)
                                    {
                                        if (!curPart.connectObj.GetComponent <SuspensionPart>())
                                        {
                                            curPart.connectPoint += curPart.connectObj.InverseTransformDirection(clampedTranslation * surfaceDot * Mathf.Min(clampedColMag * 0.01f, distClamp) * massFactor);
                                        }
                                    }
                                }
                            }
                        }

                        //Damage hover wheels
                        HoverWheel damagedHoverWheel = curDisplacePart.GetComponent <HoverWheel>();
                        if (damagedHoverWheel)
                        {
                            if ((!damagedHoverWheel.grounded && ignoreGroundedWheels) || !ignoreGroundedWheels)
                            {
                                if (clampedColMag * surfaceDot * distClamp * 10 * massFactor > damagedHoverWheel.detachForce)
                                {
                                    damagedHoverWheel.Detach();
                                }
                            }
                        }
                    }
                }
            }
        }