Original Post
Hello I have a small 3d game demo that loads in Obj files and Md2 files and you can move around. I would like to know how to test for collision detection between the obj files and the md2 files. I think that it should be so that the md2 file(the player) would be treated as a sphere and the Obj files(objects) would have triangles(because they are triangulated), so I need to know how to check for sphere-triangle collision. This is how my Obj loading code looks like ( I don't think the Md2 loading code is important beacause I just need the players positions) ObjLoader.cpp Thanks in advance Edit: I hope this was in the right forum.
#ifdef WIN32
#include <windows.h>
#endif
#include "Main.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include "ObjLoader.h"
extern int NumObjects;
/* Ignored until Version6 */
void ConvertMeshTo(ObjFile id,unsigned char What)
{
}
void SetLightPosition(float lx,float ly,float lz)
{
}
void SetTextures(ObjFile id,const char BumpTex[],const char BaseTex[])
{
}
/*===================================================================================================
**
** Internal Data Structures
**
**=================================================================================================*/
typedef struct
{
float x, /* The x component of the vertex position */
y, /* The y component of the vertex position */
z; /* The z component of the vertex position */
} ObjVertex;
typedef struct
{
float x, /* The x component of the normal vector */
y, /* The y component of the normal vector */
z; /* The z component of the normal vector */
} ObjNormal;
typedef struct
{
float u, /* The u parametric texturing co-ordinate */
v; /* The v parametric texturing co-ordinate */
} ObjTexCoord;
typedef struct
{
unsigned int m_aVertexIndices[3], /* array of indicies that reference the vertex array in the mesh */
m_aNormalIndices[3], /* array of indicies that reference the normal array in the mesh */
m_aTexCoordIndicies[3]; /* array of indicies that reference the uv coordinate array in the mesh */
} ObjFace;
typedef struct _ObjMesh
{
ObjVertex *m_aVertexArray; /* Array of vertices that make up this mesh */
ObjNormal *m_aNormalArray; /* Array of normals that make up this mesh */
ObjTexCoord *m_aTexCoordArray; /* Array of texturing co-ordinates that make up this mesh */
ObjFace *m_aFaces; /* Array of faces that make up this mesh */
unsigned int m_iNumberOfVertices, /* The number of vertices in the m_aVertexArray array */
m_iNumberOfNormals, /* The number of normals in the m_aNormalArray array */
m_iNumberOfTexCoords, /* The number of uv's in the m_aTexCoordArray array */
m_iNumberOfFaces; /* The number of faces in the m_aFaces array */
struct _ObjMesh *m_pNext; /* Each mesh will be stored internally as a node on a linked list */
ObjFile m_iMeshID; /* the ID of the mesh */
} ObjMesh;
unsigned int ResizeTriangleArray(ObjMesh *pMesh,unsigned int iExtraTriangleCount)
{
/*
** Create a temporary pointer to the old face array in the mesh
*/
ObjFace *pTempFaces = pMesh->m_aFaces;
/*
** Keep track of the old face count
*/
unsigned int iTemp = pMesh->m_iNumberOfFaces;
/*
** Increase the number of faces that will be stored in the mesh
*/
pMesh->m_iNumberOfFaces += iExtraTriangleCount;
/*
** Allocate the number of faces now required by this mesh. Note, you could use
** realloc for this, but it's just my personal preference to do it this way.
*/
pMesh->m_aFaces = (ObjFace*)malloc(pMesh->m_iNumberOfFaces*sizeof(ObjFace));
/*
** If we assert here then the memory allocation for the meshes failed
*/
assert(pMesh->m_aFaces);
/*
** Copy across the data that was stored in the old array
*/
memcpy(pMesh->m_aFaces,pTempFaces,iTemp*sizeof(ObjFace));
/*
** Delete the data held in the previous array
*/
free(pTempFaces);
memset(&pMesh->m_aFaces[ iTemp ],0,iExtraTriangleCount*sizeof(ObjFace) );
/*
** return the old size of the array (thats the same as the index of the first new triangle).
*/
return iTemp;
}
// Global Variables
ObjMesh *g_LinkedListHead = NULL;
/*
** This is used to generate a unique ID for each Obj File
*/
unsigned int g_ObjIdGenerator=0;
/*
** This function is only called from within the *.c file and is used to create an ObjMesh structure and
** initialise its values (adds the mesh to the linked list also).
*/
ObjMesh *MakeOBJ( void )
{
/*
** The pointer we will create the mesh at the end of
*/
ObjMesh *pMesh = NULL;
pMesh = (ObjMesh*) malloc (sizeof(ObjMesh));
/* If the program asserts here, then there was a memory allocation failure */
assert(pMesh);
/*
** Initialise all pointers to NULL
*/
pMesh->m_aFaces = NULL;
pMesh->m_aNormalArray = NULL;
pMesh->m_aTexCoordArray = NULL;
pMesh->m_aVertexArray = NULL;
pMesh->m_iNumberOfFaces = 0;
pMesh->m_iNumberOfNormals = 0;
pMesh->m_iNumberOfTexCoords = 0;
pMesh->m_iNumberOfVertices = 0;
pMesh->m_iMeshID = ++g_ObjIdGenerator;
/*
** Insert the mesh at the beginning of the linked list
*/
pMesh->m_pNext = g_LinkedListHead;
g_LinkedListHead = pMesh;
return pMesh;
}
void GetIndices(char *pString, unsigned int *pVert, unsigned int *pNorm, unsigned int *pUV)
{
char *pV = pString,
*pN = NULL,
*pT = NULL;
while( *pString != '\0' )
{
if(*pString == '/')
{
*pString = '\0';
if(!pT)
{
pT = pString+1;
}
else
{
pN = pString+1;
}
}
pString++;
}
/*
** Read the vertex index
*/
sscanf(pV,"%d",pVert);
if( pN == NULL || *pN == '\0' )
{
*pNorm = 1;
}
else
{
sscanf(pN,"%d",pNorm);
}
if( pT == NULL || *pT == '\0' )
{
*pUV = 1;
}
else
{
sscanf(pT,"%d",pUV);
}
}
ObjFile LoadOBJ(const char *filename)
{
ObjMesh *pMesh=NULL;
unsigned int vc=0,nc=0,tc=0,fc=0;
char buffer[256];
FILE *fp = NULL;
/*
** Open the file for reading
*/
fp = fopen(filename,"r");
/*
** If the program asserted here, then the file could not be found or opened
*/
assert(fp);
/*
** Create the mesh structure and add it to the linked list
*/
pMesh = MakeOBJ();
while(!feof(fp))
{
memset(buffer,0,200);
/* Grab a line at a time */
fgets(buffer,256,fp);
/* look for the 'vn' - vertex normal - flag */
if( strncmp("vn ",buffer,3) == 0 )
{
++pMesh->m_iNumberOfNormals;
}
else
/* look for the 'vt' - texturing co-ordinate - flag */
if( strncmp("vt ",buffer,3) == 0 )
{
++pMesh->m_iNumberOfTexCoords;
}
else
/* look for the 'v ' - vertex co-ordinate - flag */
if( strncmp("v ",buffer,2) == 0 )
{
++pMesh->m_iNumberOfVertices;
}
else
/* look for the 'f ' - face - flag */
if( strncmp("f ",buffer,2) == 0 )
{
++pMesh->m_iNumberOfFaces;
}
}
/*
** close the file for now....
*/
fclose(fp);
/*
** Allocate the memory for the data arrays and check that it allocated ok
*/
pMesh->m_aVertexArray = (ObjVertex* )malloc( pMesh->m_iNumberOfVertices * sizeof(ObjVertex) );
assert(pMesh->m_aVertexArray);
/* there are occasionally times when the obj does not have any normals in it */
if( pMesh->m_iNumberOfNormals > 0 )
{
pMesh->m_aNormalArray = (ObjNormal* )malloc( pMesh->m_iNumberOfNormals * sizeof(ObjNormal) );
assert(pMesh->m_aNormalArray);
}
/* there are occasionally times when the obj does not have any tex coords in it */
if( pMesh->m_iNumberOfTexCoords > 0 )
{
pMesh->m_aTexCoordArray = (ObjTexCoord*)malloc( pMesh->m_iNumberOfTexCoords * sizeof(ObjTexCoord) );
assert(pMesh->m_aTexCoordArray);
}
pMesh->m_aFaces = (ObjFace* )malloc( pMesh->m_iNumberOfFaces * sizeof(ObjFace) );
assert(pMesh->m_aFaces);
fp = fopen(filename,"r");
while(!feof(fp))
{
memset(buffer,0,255);
/* Grab a line at a time */
fgets(buffer,256,fp);
/* look for the 'vn' - vertex normal - flag */
if( strncmp("vn ",buffer,3) == 0 )
{
sscanf((buffer+2),"%f%f%f",
&pMesh->m_aNormalArray[ nc ].x,
&pMesh->m_aNormalArray[ nc ].y,
&pMesh->m_aNormalArray[ nc ].z);
++nc;
}
else
/* look for the 'vt' - texturing co-ordinate - flag */
if( strncmp("vt ",buffer,3) == 0 )
{
sscanf((buffer+2),"%f%f",
&pMesh->m_aTexCoordArray[ tc ].u,
&pMesh->m_aTexCoordArray[ tc ].v);
++tc;
}
else
/* look for the 'v ' - vertex co-ordinate - flag */
if( strncmp("v ",buffer,2) == 0 )
{
sscanf((buffer+1),"%f%f%f",
&pMesh->m_aVertexArray[ vc ].x,
&pMesh->m_aVertexArray[ vc ].y,
&pMesh->m_aVertexArray[ vc ].z);
++vc;
}
else
/* look for the 'f ' - face - flag */
if( strncmp("f ",buffer,2) == 0 )
{
/*
** some data for later....
*/
char *pSplitString = NULL;
unsigned int i,ii = 0;
unsigned int iNewTrianglesIndex = 0,
iNumberOfExtraTriangles = 0;
unsigned int aFirstIndices[3],
aSecondIndices[3];
ObjFace *pf = NULL;
for(i=0;i<strlen(buffer);i++)
{
if(buffer == '/')
ii++;
}
ii/=2;
if( (ii-2) > 1 )
{
iNumberOfExtraTriangles = ii-3;
iNewTrianglesIndex = ResizeTriangleArray(pMesh,iNumberOfExtraTriangles);
}
pf = &pMesh->m_aFaces[ fc ];
pSplitString = strtok((buffer+2)," \t\n");
i=0;
/*
** Get the vertex structures that we know WILL exists (there has to be a minimum of three)
*/
for(i=0;i<3;i++)
{
GetIndices( pSplitString,
&pf->m_aVertexIndices,
&pf->m_aNormalIndices,
&pf->m_aTexCoordIndicies);
/* need to reduce the indices by 1 because array indices start at 0, obj starts at 1 */
--pf->m_aTexCoordIndicies;
--pf->m_aNormalIndices;
--pf->m_aVertexIndices;
switch(i)
{
case 0:
aFirstIndices[0] = pf->m_aVertexIndices;
aFirstIndices[1] = pf->m_aNormalIndices;
aFirstIndices[2] = pf->m_aTexCoordIndicies;
break;
case 2:
aSecondIndices[0] = pf->m_aVertexIndices;
aSecondIndices[1] = pf->m_aNormalIndices;
aSecondIndices[2] = pf->m_aTexCoordIndicies;
break;
default:
break;
}
pSplitString = strtok(NULL," \t\n");
}
++fc;
/*
** Get the additional triangles that may be there
*/
for(i=0;i<iNumberOfExtraTriangles;i++)
{
pf = &pMesh->m_aFaces[ iNewTrianglesIndex + i ];
GetIndices( pSplitString,
&pf->m_aVertexIndices[2],
&pf->m_aNormalIndices[2],
&pf->m_aTexCoordIndicies[2]);
/* need to reduce the indices by 1 because array indices start at 0, obj starts at 1 */
--pf->m_aTexCoordIndicies[2];
--pf->m_aNormalIndices[2];
--pf->m_aVertexIndices[2];
/*
** Now assign the other indices for the triangle
*/
pf->m_aVertexIndices[0] = aFirstIndices[0];
pf->m_aNormalIndices[0] = aFirstIndices[1];
pf->m_aTexCoordIndicies[0] = aFirstIndices[2];
pf->m_aVertexIndices[1] = aSecondIndices[0];
pf->m_aNormalIndices[1] = aSecondIndices[1];
pf->m_aTexCoordIndicies[1] = aSecondIndices[2];
/*
** Copy over the indices for the next triangle.
*/
aSecondIndices[0] = pf->m_aVertexIndices[2];
aSecondIndices[1] = pf->m_aNormalIndices[2];
aSecondIndices[2] = pf->m_aTexCoordIndicies[2];
pSplitString = strtok(NULL," \t\n");
}
}
}
fclose(fp);
return pMesh->m_iMeshID;
}
void DrawOBJ(ObjFile id)
{
ObjMesh *pMesh = g_LinkedListHead;
while(pMesh && pMesh->m_iMeshID != id)
{
pMesh = pMesh->m_pNext;
}
/*
** Check to see if the mesh ID is valid.
*/
if(pMesh != NULL)
{
if( pMesh->m_aNormalArray != NULL &&
pMesh->m_aTexCoordArray != NULL )
{
unsigned int i;
glBegin(GL_TRIANGLES);
for(i=0;i<pMesh->m_iNumberOfFaces;i++)
{
unsigned int j;
ObjFace *pf = &pMesh->m_aFaces;
/*
** Draw the polygons with normals & uv co-ordinates
*/
for(j=0;j<3;j++)
{
glTexCoord2f( pMesh->m_aTexCoordArray[ pf->m_aTexCoordIndicies[j] ].u,
pMesh->m_aTexCoordArray[ pf->m_aTexCoordIndicies[j] ].v);
glNormal3f( pMesh->m_aNormalArray[ pf->m_aNormalIndices[j] ].x,
pMesh->m_aNormalArray[ pf->m_aNormalIndices[j] ].y,
pMesh->m_aNormalArray[ pf->m_aNormalIndices[j] ].z);
glVertex3f( pMesh->m_aVertexArray[ pf->m_aVertexIndices[j] ].x,
pMesh->m_aVertexArray[ pf->m_aVertexIndices[j] ].y,
pMesh->m_aVertexArray[ pf->m_aVertexIndices[j] ].z);
}
}
glEnd();
}
else
if( pMesh->m_aNormalArray != NULL )
{
unsigned int i;
glBegin(GL_TRIANGLES);
for(i=0;i<pMesh->m_iNumberOfFaces;i++)
{
unsigned int j;
ObjFace *pf = &pMesh->m_aFaces;
/*
** Draw the polygons with Normals only
*/
for(j=0;j<3;j++)
{
glNormal3f( pMesh->m_aNormalArray[ pf->m_aNormalIndices[j] ].x,
pMesh->m_aNormalArray[ pf->m_aNormalIndices[j] ].y,
pMesh->m_aNormalArray[ pf->m_aNormalIndices[j] ].z);
glVertex3f( pMesh->m_aVertexArray[ pf->m_aVertexIndices[j] ].x,
pMesh->m_aVertexArray[ pf->m_aVertexIndices[j] ].y,
pMesh->m_aVertexArray[ pf->m_aVertexIndices[j] ].z);
}
}
glEnd();
}
else
if( pMesh->m_aTexCoordArray != NULL )
{
unsigned int i;
glBegin(GL_TRIANGLES);
for(i=0;i<pMesh->m_iNumberOfFaces;i++)
{
unsigned int j;
ObjFace *pf = &pMesh->m_aFaces;
/*
** Draw the polygons with Texturing co-ordinates only
*/
for(j=0;j<3;j++)
{
glTexCoord2f( pMesh->m_aTexCoordArray[ pf->m_aTexCoordIndicies[j] ].u,
pMesh->m_aTexCoordArray[ pf->m_aTexCoordIndicies[j] ].v);
glVertex3f( pMesh->m_aVertexArray[ pf->m_aVertexIndices[j] ].x,
pMesh->m_aVertexArray[ pf->m_aVertexIndices[j] ].y,
pMesh->m_aVertexArray[ pf->m_aVertexIndices[j] ].z);
}
}
glEnd();
}
else
{
unsigned int i;
glBegin(GL_TRIANGLES);
for(i=0;i<pMesh->m_iNumberOfFaces;i++)
{
unsigned int j;
ObjFace *pf = &pMesh->m_aFaces;
/*
** Draw the polygons
*/
for(j=0;j<3;j++)
{
glVertex3f( pMesh->m_aVertexArray[ pf->m_aVertexIndices[j] ].x,
pMesh->m_aVertexArray[ pf->m_aVertexIndices[j] ].y,
pMesh->m_aVertexArray[ pf->m_aVertexIndices[j] ].z);
}
}
glEnd();
}
}
}
void DeleteMesh(ObjMesh* pMesh)
{
/*
** If the pointer is valid
*/
if(pMesh)
{
/* delete the face array */
if(pMesh->m_aFaces)
{
free(pMesh->m_aFaces);
pMesh->m_aFaces = NULL;
}
/* delete the vertex array */
if(pMesh->m_aVertexArray)
{
free(pMesh->m_aVertexArray);
pMesh->m_aVertexArray = NULL;
}
/* delete the normal array */
if(pMesh->m_aNormalArray)
{
free(pMesh->m_aNormalArray);
pMesh->m_aNormalArray = NULL;
}
/* delete the texturing co-ordinate array */
if(pMesh->m_aTexCoordArray)
{
free(pMesh->m_aTexCoordArray);
pMesh->m_aTexCoordArray = NULL;
}
/* free the mesh */
free( pMesh );
}
}
void DeleteOBJ(ObjFile id)
{
/*
** Create two pointers to walk through the linked list
*/
ObjMesh *pCurr,
*pPrev = NULL;
/*
** Start traversing the list from the start
*/
pCurr = g_LinkedListHead;
while(pCurr != NULL && pCurr->m_iMeshID != id)
{
pPrev = pCurr;
pCurr = pCurr->m_pNext;
}
/*
** If we found the node that needs to be deleted
*/
if(pCurr != NULL)
{
/*
** If the pointer before it is NULL, then we need to
** remove the first node in the list
*/
if(pPrev == NULL)
{
g_LinkedListHead = pCurr->m_pNext;
}
/*
** Otherwise we are removing a node from somewhere else
*/
else
{
pPrev->m_pNext = pCurr->m_pNext;
}
/*
** Free the memory allocated for this mesh
*/
DeleteMesh(pCurr);
}
}
/*
** Delete all of the meshes starting from the front.
*/
void CleanUpOBJ(void)
{
ObjMesh *pCurr;
while(g_LinkedListHead != NULL)
{
pCurr = g_LinkedListHead;
g_LinkedListHead = g_LinkedListHead->m_pNext;
DeleteMesh(pCurr);
}
}
