Hey I'm using Unity. I'm making a really sick car game, with dynamic car damage, crazy stunts, and wacky cartoonish graphics. I'm running into problems with math, though. Basically, I'm trying to make a function that inputs the damage done to the car and the Vector3 location of the impact. Then, the code should use this information to distort the mesh around the point of impact by a reasonable amount.

It looks like the following in pseudocode:

public void DestortMesh(collision point, amount of damage)
{
    Radius = damage / 10;
    for (each verex of the mesh)
    {
        if (the vertex is within the radius from the collision point)
        {
              distort the vertex
        }
    }
}

Here is the actual code:

    void deform(float radius, ContactPoint contactPoint)
    {
        Debug.Log("Deform called with radius of " + radius);
        Vector3 relativePosition = gameObject.transform.InverseTransformPoint(contactPoint.point);
        for (int x = 0; x < vertices.Count; x ++)
        {
            Debug.Log(Vector3.Distance(vertices[x], relativePosition));
            if (Vector3.Distance(vertices[x], relativePosition) <= radius)
            {
                //time to deform
                vertices[x] += vertices[x] * Random.Range(-.1f,.1f);
            }
            
        }

        mesh.SetVertices(vertices);
        mesh.RecalculateBounds();
        mesh.RecalculateNormals();
    }

This looks all fine and dandy, right? but when I look at the distances between each vertex and the collision point (the debug log right before the if statement), they look like this:

basically, the output is weird. The speed of impact seems to affect it slightly, and for every impact, each vertex's distance is within a few 1000ths of each other. This makes it really hard to tell which points are close and which ones are far from the impact point. When trying out this in the game, the damage to the car is sporadic. For the most part, no damage is visible on the car. Then randomly, usually after a high speed impact is made, the car will become completely distorted, with every vertex changed.

You can see a video of this happening here:

So in the end, this is not the result I was aiming for. Something seems to be off with the Vector3 distance, but in the Unity forums all I'm getting are people saying there couldn't possibly be anything wrong with them. So I'm going to assume that there is something wrong with my code perhaps?

If you think you could help me, add me on Discord. Ramaraunt#6934

Several things:

a) What is the ratio of the size of the bounding box of the mesh (enough "of" for now ;)) and the damage infliction?

b) From the video it seems me that the mesh has a too low resolution for deformation. Either use a higher resolution in advance or refine resolution locally just before applying the damage.

c) Damage infliction is done by applying a translation in direction of and proportional to the position of the vertex. That means that the intentional same damage factor applied to a vertex farther away from the origin has a higher impact, and that the bumps are not oriented correctly. What you probably want is to support a direction of damage (i.e. the damage is input as a vector with its length denoting the damage amplitude), scale that with one minus the normalized distance from the impact point, and add that to the vertex position.

d) Using a translation in range [-1,+1] gives inside and outside bumps; perhaps not what you want.

Several things:

a) What is the ratio of the size of the bounding box of the mesh (enough "of" for now ;)) and the damage infliction?

b) From the video it seems me that the mesh has a too low resolution for deformation. Either use a higher resolution in advance or refine resolution locally just before applying the damage.

c) Damage infliction is done by applying a translation in direction of and proportional to the position of the vertex. That means that the intentional same damage factor applied to a vertex farther away from the origin has a higher impact, and that the bumps are not oriented correctly. What you probably want is to support a direction of damage (i.e. the damage is input as a vector with its length denoting the damage amplitude), scale that with one minus the normalized distance from the impact point, and add that to the vertex position.

d) Using a translation in range [-1,+1] gives inside and outside bumps; perhaps not what you want.

A: There will be 100 damage maximum before the car is wasted. The bounding box is about 2 by .4 by .7.

B: I want the resolution to be low. Is there a way to make that work?

C: Normalized distance? How do you normalize a float?

D: Yeah that could be changed.

I'll pm you a copy of the game.

EDIT: I tried this

vertices[x] += Vector3.Normalize(vertices[x] - relativePosition) * Random.Range(-.1f,.1f); 

and it does this

BTW: I'm *not* running Unity3D at the moment, so we need to solve the problem on a more theoretical basis.

to A: What I asked for is the ratio of the bounding box size to the area of damage. If the radius of the sphere that locates the damage is, say, 1.0, while the bounding is 2 by .4 by .7, then every applied damage has an influence on at least half of the vertices. Hence my question: Is the ratio low enough?

to B: Think of the radius being 0.3 when damage is inflicted to the front right corner of the car. The bounding box's size in x direction is 2, and it is covered by 2 faces along from front to back. Only the vertices at the front are located within the sphere of damage. What we would expect is that the region 0.7 to 1.0 along x direction is damaged. However, the mesh's face ranges from 0.0 to 1.0 in that direction, and hence the deformation appears over half of the length of the car although the relatively small damage sphere.

to C: "Normalized distance" means that it ranges from 0.0 to 1.0. Since the unnormalized value ranges from 0.0 to radius, dividing by radius is the calculation to be done for normalization.

to D: Well, when being done "correctly", then this kind of calculation will be removed totally.

It seems me worth to clarify first how exactly an inflicted damage should look like...

I appreciate the responses!

Here is my fixed up code using what you said

    void deform(float radius, ContactPoint contactPoint)
    {
        Debug.Log("Deform called with radius of " + radius);
        Vector3 center = gameObject.GetComponent<Rigidbody>().centerOfMass;
        Vector3 relativePosition = gameObject.transform.InverseTransformPoint(contactPoint.point);
        for (int x = 0; x < vertices.Count; x ++)
        {
            float normalized = (1 - (Vector3.Distance(vertices[x], relativePosition) / radius));
            //Debug.Log(Vector3.Distance(vertices[x], relativePosition));
            if (normalized > 0)
            {
                //time to deform
                vertices[x] -= vertices[x] * normalized *Random.Range(1, 5);
            }

            Debug.Log(normalized);
            
        }

        mesh.SetVertices(vertices);
        mesh.RecalculateBounds();
        mesh.RecalculateNormals();
    }

Here is the debug log output. Its still weird though.

http://pastebin.com/dH5fGy3Y

Why are all the distances for each point equal to about -3?

EDIT: btw, I've got a friend from blenderartists.org who is pumping out some nice models. In light of this, I changed the shaders to be more smooth looking. I like it much better.

So, I tried doing just this:

float normalized = ((Vector3.Distance(vertices[x], relativePosition)));

And the distance between each vertex and the collision point is .98XXXXXX every single time.

Solved it! The problem was, the model was originally imported really tiny, and it was scaled up 100 times. So the mesh.vertices values were really tiny.

Here is a video of the fixed game!