# Calculate the angle of intersection and depth

This topic is 3891 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

## Recommended Posts

hello everyone, i successfully implemented the separating axis theorem for my collision-detection. now i just need to know how to calculate the angle in which the one object hit the other and of course the depth to know how much both objects intersect. here is what i have so far: a working obb-collision-detection. it is a bit messed up between DX and our own vector-format, because i am still using DirectX for the matrix-calculations till i write my own matrix-class:
	bool OBBCollision::checkForCollision(const Tron::BoundingBox &boxA, const Tron::BoundingBox &boxB){
// rotation-matrizes for A and B
D3DXMATRIX matRotA;
D3DXMatrixRotationYawPitchRoll(&matRotA, boxA.getDirection().y, boxA.getDirection().x, boxA.getDirection().z);
D3DXMATRIX matRotB;
D3DXMatrixRotationYawPitchRoll(&matRotB, boxB.getDirection().y, boxB.getDirection().x, boxB.getDirection().z);

D3DXMATRIX matRotA_inverse;
D3DXMatrixInverse(&matRotA_inverse, NULL, &matRotA);

// the rotation of B in relation to A
D3DXMATRIX rotAtoB = matRotB*matRotA_inverse;

CVector3D diff(boxB.getPosition() - boxA.getPosition());
D3DXVECTOR3 dxDiff;
CVector3D::toDxVector3(dxDiff,diff);

// the translation of B in relation to A
D3DXVECTOR3 transAtoB;
D3DXVec3TransformCoord(&transAtoB, &dxDiff, &matRotA_inverse);

// we need the individual axis
CVector3D axisX(rotAtoB._11,rotAtoB._21,rotAtoB._31);
CVector3D axisY(rotAtoB._12,rotAtoB._22,rotAtoB._32);
CVector3D axisZ(rotAtoB._13,rotAtoB._23,rotAtoB._33);

CVector3D axisXabs(std::abs(rotAtoB._11),std::abs(rotAtoB._21),std::abs(rotAtoB._31));
CVector3D axisYabs(std::abs(rotAtoB._12),std::abs(rotAtoB._22),std::abs(rotAtoB._32));
CVector3D axisZabs(std::abs(rotAtoB._13),std::abs(rotAtoB._23),std::abs(rotAtoB._33));

// the tests need the half-sizes
CVector3D halfSizeA(boxA.getSize());
halfSizeA.x /=2.0f; halfSizeA.y /=2.0f; halfSizeA.z /=2.0f;
CVector3D halfSizeB(boxB.getSize());
halfSizeB.x /=2.0f; halfSizeB.y /=2.0f; halfSizeB.z /=2.0f;

//15 tests
//1 (Ra)x
if(fabs(transAtoB.x) > halfSizeA.x + halfSizeB.x * axisXabs.x + halfSizeB.y * axisXabs.y + halfSizeB.z * axisXabs.z)
return false;
//2 (Ra)y
if(fabs(transAtoB.y) > halfSizeA.y + halfSizeB.x * axisYabs.x + halfSizeB.y * axisYabs.y + halfSizeB.z * axisYabs.z)
return false;
//3 (Ra)z
if(fabs(transAtoB.z) > halfSizeA.z + halfSizeB.x * axisZabs.x + halfSizeB.y * axisZabs.y + halfSizeB.z * axisZabs.z)
return false;

//4 (Rb)x
if(fabs(transAtoB.x*axisX.x + transAtoB.y*axisY.x+transAtoB.z*axisZ.x) >
(halfSizeB.x+halfSizeA.x*axisXabs.x + halfSizeA.y * axisYabs.x + halfSizeA.z*axisZabs.x))
return false;
//5 (Rb)y
if(fabs(transAtoB.x*axisX.y+transAtoB.y*axisY.y+transAtoB.z*axisZ.y) >
(halfSizeB.y+halfSizeA.x*axisXabs.y + halfSizeA.y * axisYabs.y + halfSizeA.z*axisZabs.y))
return false;
//6 (Rb)z
if(fabs(transAtoB.x*axisX.z+transAtoB.y*axisY.z+transAtoB.z*axisZ.z) >
(halfSizeB.z+halfSizeA.x*axisXabs.z + halfSizeA.y * axisYabs.z + halfSizeA.z*axisZabs.z))
return false;

//7 (Ra)x X (Rb)x
if(fabs(transAtoB.z*axisY.x-transAtoB.y*axisZ.x) > halfSizeA.y*axisZabs.x +
halfSizeA.z*axisYabs.x + halfSizeB.y*axisXabs.z + halfSizeB.z*axisXabs.y)
return false;
//8 (Ra)x X (Rb)y
if(fabs(transAtoB.z*axisY.y-transAtoB.y*axisZ.y) > halfSizeA.y*axisZabs.y +
halfSizeA.z*axisYabs.y + halfSizeB.x*axisXabs.z + halfSizeB.z*axisXabs.x)
return false;
//9 (Ra)x X (Rb)z
if(fabs(transAtoB.z*axisY.z-transAtoB.y*axisZ.z) > halfSizeA.y*axisZabs.z +
halfSizeA.z*axisYabs.z + halfSizeB.x*axisXabs.y + halfSizeB.y*axisXabs.x)
return false;

//10 (Ra)y X (Rb)x
if(fabs(transAtoB.x*axisZ.x-transAtoB.z*axisX.x) > halfSizeA.x*axisZabs.x +
halfSizeA.z*axisXabs.x + halfSizeB.y*axisYabs.z + halfSizeB.z*axisYabs.y)
return false;
//11 (Ra)y X (Rb)y
if(fabs(transAtoB.x*axisZ.y-transAtoB.z*axisX.y) > halfSizeA.x*axisZabs.y +
halfSizeA.z*axisXabs.y + halfSizeB.x*axisYabs.z + halfSizeB.z*axisYabs.x)
return false;
//12 (Ra)y X (Rb)z
if(fabs(transAtoB.x*axisZ.z-transAtoB.z*axisX.z) > halfSizeA.x*axisZabs.z +
halfSizeA.z*axisXabs.z + halfSizeB.x*axisYabs.y + halfSizeB.y*axisYabs.x)
return false;

//13 (Ra)z X (Rb)x
if(fabs(transAtoB.y*axisX.x-transAtoB.x*axisY.x) > halfSizeA.x*axisYabs.x +
halfSizeA.y*axisXabs.x + halfSizeB.y*axisZabs.z + halfSizeB.z*axisZabs.y)
return false;
//14 (Ra)z X (Rb)y
if(fabs(transAtoB.y*axisX.y-transAtoB.x*axisY.y) > halfSizeA.x*axisYabs.y +
halfSizeA.y*axisXabs.y + halfSizeB.x*axisZabs.z + halfSizeB.z*axisZabs.x)
return false;
//15 (Ra)z X (Rb)z
if(fabs(transAtoB.y*axisX.z-transAtoB.x*axisY.z) > halfSizeA.x*axisYabs.z +
halfSizeA.y*axisXabs.z + halfSizeB.x*axisZabs.y + halfSizeB.y*axisZabs.x)
return false;
return true;
}


but how (and from which information) do i calculate the angle now??? thanks for any little tip!!! best regards! anchelito  am i right to think, that i need the length of each overlapping? (the overlap of rA and rB in this pic)

1. 1
2. 2
Rutin
24
3. 3
4. 4
JoeJ
18
5. 5

• 14
• 23
• 11
• 11
• 9
• ### Forum Statistics

• Total Topics
631768
• Total Posts
3002241
×