Collision Angle Detection

Question

I have some questions regarding collision angles. I am trying to code physics for a game and I do not want to use any third party library, actually I want to code each and every thing by myself. I know how to detect collisions between two spheres but I can't figure out, how to find the angle of collision/repulsion between the two spherical objects. I've tried reversing the direction of the objects, but no luck. It would be very nice if you link me to an interesting .pdf file teaching physics programming.

Answer 1

There's a lot of ways to deal with collision

Impulsion

To model a impulsion, you can directly act on the speed of each objects, using the law of reflection, you can "reflect" each speed using the "normal of the impact"

so : v1 = v1 - 2 x ( v1 . n2 ) x n2

and v2 = v2 - 2 x ( v2 . n1 ) x n1

v1 and v2 speeds of sphere s1 and s2

n1 and n2 normal at collision point

Penalty

Here, we have 2 object interpenetrating, and we model the fact that they tend to not interpenetrate anymore, so you create a force that is proportional to the penetration using a spring force

I didn't speak about all the ways, but this are the two simplest I know

Answer 2

the angle between two objects in the 2D or 3D coordinate space can be found by A * B = |A||B|cosɵ Both A and B are vectors and ɵ is the angle between both vectors. the below class can be used to solve basic Vector calculations in games

    class 3Dvector

{

private:

    float x, y, z;

public:

    // purpose:     Our constructor

    // input:       ex- our vector's i component

    //               why- our vector's j component

    //               zee- our vector's k component

    // output:      no explicit output

    3Dvector(float ex = 0, float why = 0, float zee = 0)

{

    x = ex;  y = why; z = zee;

}



// purpose:    Our destructor

    // input:    none

    // output:   none

~3Dvector() { }



// purpose:    calculate the magnitude of our invoking vector

// input:      no explicit input

// output:     the magnitude of our invoking object

float getMagnitude()

{

    return sqrtf(x * x + y * y + z * z);

}



// purpose:  multiply our vector by a scalar value

// input:    num - the scalar value being multiplied

// output:   our newly created vector

3Dvector operator*(float num) const

{

    return 3Dvector(x * num, y * num, z * num);

}



// purpose:    multiply our vector by a scalar value

// input:      num - the scalar value being multiplied

//              vec - the vector we are multiplying to

// output:     our newly created vector

friend 3Dvector operator*(float num, const 3Dvector &vec)

{

    return 3Dvector(vec.x * num, vec.y * num, vec.z * num);

}



// purpose:     Adding two vectors

// input:       vec - the vector being added to our invoking object

// output:      our newly created sum of the two vectors

3Dvector operator+(const 3Dvector &vec) const

{

    return 3Dvector(x + vec.x, y + vec.y, z + vec.z);

}



// purpose:     Subtracting two vectors

// input:       vec - the vector being subtracted from our invoking object

// output:      our newly created difference of the two vectors

3Dvector operator-(const 3Dvector &vec) const

{

    return 3Dvector(x - vec.x, y - vec.y, z - vec.z);

}



// purpose:    Normalize our invoking vector *this changes our vector*

// input:      no explicit input

// output:     none

void normalize3Dvector(void)

{

    float mag = sqrtf(x * x + y * y + z * z);

    x /= mag;  y /= mag; z /= mag

}



// purpose:     Dot Product two vectors

// input:       vec - the vector being dotted with our invoking object

// output:       the dot product of the two vectors

float dot3Dvector(const 3Dvector &vec) const

{

    return x * vec.x + y * vec.y + z * vec.z;

}



// purpose:  Cross product two vectors

// input:    vec- the vector being crossed with our invoking object

// output:   our newly created resultant vector

3Dvector cross3Dvector(const 3Dvector &vec) const

{

    return 3Dvector( y * vec.z – z * vec.y,

                 z * vec.x – x * vec.z,

                 x * vec.y – y * vec.x);

}



};

Answer 3

I shouldn't be answering my own question but I found what I needed, I guess. It may help other people too. I was just fingering the wikipedia's physics section and I got this.

This link solves my question

Answer 4

The angle in a cartesian system can be found this way:

arctan((Ya-Yb)/(Xa-Xb))

Because this is a retangle triangle where you know the catets (diferences of heights and widths). This will calc the tangent. So the arctan will calc the angle thats have this tangent.

I hope I was helpful.