Texture Mapping Issues

Hi, I have been working on a project for school and I am having some problems with texturing a model after I load it from a file. The models seem to all be load and drawn fine, but the textures appear to just be placed anywhere they want on the model itself. as see below.

[attachment=7676:model loader.png]

below is the code involved aswell

Load the Model

ObjectModelType * LoadObjectModel(char *data, int datasize)
{
Vector3f objboundingboxmin(9999,9999,9999);
Vector3f objboundingboxmax(0,0,0);
char *memoryPositionPtr, *endOfMemoryPtr;
int c=0, polyCtr=0, vertexCtr=0, uvCtr=0, normalCtr=0;
ObjectModelType *theModel;
theModel = (ObjectModelType *)calloc(1,sizeof(ObjectModelType));
memoryPositionPtr = data; // current position and end location pointers
endOfMemoryPtr = data + datasize;
while (memoryPositionPtr != endOfMemoryPtr)
{
if (*memoryPositionPtr == 'v')
// theModel->VertexCount++; // removed
if (*(memoryPositionPtr+1) == 't') // added
theModel->UVvertexCount++; // added
else if (*(memoryPositionPtr+1) == 'n')
theModel->NormalCount++;
else // added
theModel->VertexCount++; // added
else if (*memoryPositionPtr == 'f')
theModel->PolygonCount++;
while (*memoryPositionPtr++ != 0x0A)
;
}
//allocate memory for the model data
theModel->VertexArray = (ObjectVertexType *)malloc(sizeof(ObjectVertexType)*theModel->VertexCount);
theModel->NormalArray = (ObjectNormalType *)malloc(sizeof(ObjectNormalType)*theModel->NormalCount);// now allocate the arrays
theModel->UVArray = (ObjectUVType *)malloc(sizeof(ObjectUVType)*theModel->UVvertexCount); // added
theModel->PolygonArray = (ObjectPolygonType *)malloc(sizeof(ObjectPolygonType)*theModel->PolygonCount);

memoryPositionPtr = data; // finally, go back and scan the values
vertexCtr = 1;
polyCtr = uvCtr = 0; // reset values // added modified
while (memoryPositionPtr != endOfMemoryPtr)
{
if (*memoryPositionPtr=='v') // might be a vertex or a uv coord
{
if (*(memoryPositionPtr+1) == 't') // it's a uv coord
{
sscanf(memoryPositionPtr,"vt %f %f",&theModel->UVArray[uvCtr].u,
&theModel->UVArray[uvCtr].v);
uvCtr++;
}
else if (*(memoryPositionPtr+1) == 'n') // it's a normal coord
{
sscanf(memoryPositionPtr,"v %f %f %f",&theModel->NormalArray[normalCtr].x,
&theModel->NormalArray[normalCtr].y,
&theModel->NormalArray[normalCtr].z);
normalCtr++;
}
else // no, it's a vertex
{
sscanf(memoryPositionPtr,"v %f %f %f",&theModel->VertexArray[vertexCtr].x,
&theModel->VertexArray[vertexCtr].y,
&theModel->VertexArray[vertexCtr].z);
if (objboundingboxmin.x > theModel->VertexArray[vertexCtr].x)
{
objboundingboxmin.x = theModel->VertexArray[vertexCtr].x;
theModel->bbminx = objboundingboxmin.x;
}
if (objboundingboxmin.y > theModel->VertexArray[vertexCtr].y)
{
objboundingboxmin.y = theModel->VertexArray[vertexCtr].y;
}
if (objboundingboxmin.z > theModel->VertexArray[vertexCtr].z)
{
objboundingboxmin.z = theModel->VertexArray[vertexCtr].z;
}
if (objboundingboxmax.x < theModel->VertexArray[vertexCtr].x)
{
objboundingboxmax.x = theModel->VertexArray[vertexCtr].x;
}
if (objboundingboxmax.y < theModel->VertexArray[vertexCtr].y)
{
objboundingboxmax.y = theModel->VertexArray[vertexCtr].y;
}
if (objboundingboxmax.z < theModel->VertexArray[vertexCtr].z)
{
objboundingboxmax.z = theModel->VertexArray[vertexCtr].z;
}
theModel->bbminx = objboundingboxmin.x;
theModel->bbminy = objboundingboxmin.y;
theModel->bbminz = objboundingboxmin.z;
theModel->bbmaxx = objboundingboxmax.x;
theModel->bbmaxy = objboundingboxmax.y;
theModel->bbmaxz = objboundingboxmax.z;
vertexCtr++;
}
}
else if (*memoryPositionPtr=='f')
{
sscanf(memoryPositionPtr,"f %d/%d/%d %d/%d/%d %d/%d/%d ",
&theModel->PolygonArray[polyCtr].Vertex[0],&theModel->PolygonArray[polyCtr].UV[0],&theModel->PolygonArray[polyCtr].Normal[0], // added modified
&theModel->PolygonArray[polyCtr].Vertex[1],&theModel->PolygonArray[polyCtr].UV[1],&theModel->PolygonArray[polyCtr].Normal[1], // added modified
&theModel->PolygonArray[polyCtr].Vertex[2],&theModel->PolygonArray[polyCtr].UV[2],&theModel->PolygonArray[polyCtr].Normal[2]);// added modified
polyCtr++;
}

while (*memoryPositionPtr++ != (char) 0x0A)
;
}
return theModel;
}
//#include <direct.h> /* supports _getcwd to get the current working directory if their are problems finding the file */
long LoadObjectFile(const char* filename, char** data)
{
long bytes = 0;
FILE* theFile;
// char buffer[_MAX_PATH]; _getcwd( buffer, _MAX_PATH ); /* Get the current working directory: */
theFile = fopen(filename, "rt");
if (theFile != NULL)
{
fseek(theFile, 0, SEEK_END);
long end = ftell(theFile);
fseek(theFile, 0, SEEK_SET);

*data = (char*) malloc(end);
bytes = (long)fread(*data, sizeof(char), (size_t)end, theFile);
fclose(theFile);
}
return bytes;
}

Loading and Applying Textures

void Entity::loadImage(const char* filename)
{
ILuint ilimg;
ilGenImages(1, &ilimg);
ilBindImage(ilimg);
//load image
if(!ilLoadImage(filename))
{
printf("Error: Could load image %s\n", filename);
return;
}
glGenTextures(1, ℑ);
glBindTexture(GL_TEXTURE_2D, image);
ILuint bpp = ilGetInteger(IL_IMAGE_BPP);
ILuint width = ilGetInteger(IL_IMAGE_WIDTH);
ILuint height = ilGetInteger(IL_IMAGE_HEIGHT);
ILuint format = ilGetInteger(IL_IMAGE_FORMAT);
ILubyte *data = ilGetData();
glPixelStorei(GL_UNPACK_ALIGNMENT,1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, bpp, width, height, 0, format,
GL_UNSIGNED_BYTE, data);
ilDeleteImages(1, &ilimg);
}
void Entity :: ApplyTexture()
{
glEnable(GL_NORMALIZE);
glTexEnvf(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE, GL_MODULATE);
glBindTexture(GL_TEXTURE_2D,image);
glEnable(GL_REPEAT);
}

Drawing the model
void Entity::draw()
{
/*draw the object in opengl to current location*/
glPushMatrix();
glColor3f(1,1,1);
glTranslatef(
currentAnimState->position.x,
currentAnimState->position.y,
currentAnimState->position.z);

//ApplyTexture();
for(long i=0; i<currentPose->PolygonCount;i++)
{
long v1 = currentPose->PolygonArray.Vertex[0];
long v2 = currentPose->PolygonArray.Vertex[1];
long v3 = currentPose->PolygonArray.Vertex[2];
long uv1 = currentPose->PolygonArray.UV[0];
long uv2 = currentPose->PolygonArray.UV[1];
long uv3 = currentPose->PolygonArray.UV[2];
long vn1 = currentPose->PolygonArray.Normal[0];
long vn2 = currentPose->PolygonArray.Normal[1];
long vn3 = currentPose->PolygonArray.Normal[2];
ApplyTexture();
glBegin(GL_TRIANGLES);

//point 1
glNormal3f(currentPose->NormalArray[vn1].x,currentPose->NormalArray[vn1].y,currentPose->NormalArray[vn1].z);
glTexCoord2f(currentPose->UVArray[uv1].u,currentPose->UVArray[uv1].v);
glVertex3f(currentPose->VertexArray[v1].x,currentPose->VertexArray[v1].y,currentPose->VertexArray[v1].z );

//point 2
glNormal3f(currentPose->NormalArray[vn2].x,currentPose->NormalArray[vn2].y,currentPose->NormalArray[vn2].z);
glTexCoord2f(currentPose->UVArray[uv2].u,currentPose->UVArray[uv2].v);
glVertex3f(currentPose->VertexArray[v2].x,currentPose->VertexArray[v2].y,currentPose->VertexArray[v2].z );

//point 3
glNormal3f(currentPose->NormalArray[vn3].x,currentPose->NormalArray[vn3].y,currentPose->NormalArray[vn3].z);
glTexCoord2f(currentPose->UVArray[uv3].u,currentPose->UVArray[uv3].v);
glVertex3f(currentPose->VertexArray[v3].x,currentPose->VertexArray[v3].y,currentPose->VertexArray[v3].z );
glEnd();
}

glPopMatrix();
}


any help would really be appreciated, I have spent many long nights trying to figure this out, also let me know If you want to me to include any other code. Thanks in advance.