OpenGL, DevIL, obj загрузчик с текстурами

Я написал загрузчик obj, и, насколько я могу судить, все загрузки работают нормально, однако, когда я пытаюсь нарисовать текстуры, это не работает.

Я посмотрел в дьявола, и после загрузки нет ошибок, у всех есть данные, но когда я рисую, изображение не отображается просто черным.

есть что-нибудь, что вы, ребята, могли бы порекомендовать?
Я уже посмотрел несколько вещей, но не смог найти решение.

с тем, как я делаю вещи
у меня есть MTL, созданный в соответствии с текстурой

Loader.h

#pragma once
#include "typedef.h"#include <string>
#include <vector>
#include <fstream>

#include "MTL.h"#include "../freeglut.h"
#include <iostream> // this is just for testing, you can remove this with all the cout's

class Loader
{
public:
/**
*  \brief string location of the obj file
*
*  In Order for you to Load the 3D object you need to specify its location
*  in a string.
*
*
*/
Loader( std::string input);

~Loader(void);void draw(); // this function takes the obj file and draws it

//this can be ignored, it does not make any changes to the problem
void move(float x, float y, float z);
void getPos();
void setPos(float x, float y, float z); // set position
void find_box(float &maxX,float &minX,float &maxY, float &minY, float &maxZ,float &minZ);

private:std::ifstream m_inFile;

// the list of vectors that i will be using
std::vector<points> m_points;
std::vector<normal> m_normals;
std::vector<coordinate> m_coords;

std::vector<MTL> m_mtl;

std::vector<face> m_faces;

void process(std::string input);
void processMTL(std::string input);

void inputPoints(points temp);
void inputNormals(normal temp);
void inputCoordinates(coordinate temp);
void createFaces(face temp);};

Loader.cpp

void Loader::process(std::string input)
{
std::string identifier; //used to identify where the input should gopoints temppoint;
normal tempnormal;
coordinate tempcoord;
face tempface;std::string read;       // used to read the curent line

int readNum; // this is the number that has just been read in
char skip; // a char to skip thr /
int i;
int count= 1;

//other things to take into account
//****************************************
std::string l_name;
bool firstRun = true;
std::string parse;
//**************************************m_inFile.open(input);//creation of the reading loop

m_inFile >> identifier;

do {
// check to see what the opening is

if (identifier =="#")
{
getline(m_inFile,read); // use this to read the whole line

}
else if(identifier == "v")
{
m_inFile >> temppoint.x >> temppoint.y >> temppoint.z;
inputPoints(temppoint);
}
else if(identifier == "vn")
{
m_inFile >> tempnormal.vn[0] >> tempnormal.vn[1] >> tempnormal.vn[2];
inputNormals(tempnormal);
}
else if (identifier == "vt")
{
m_inFile >> tempcoord.vt[0] >> tempcoord.vt[1] >> tempcoord.vt[2];
inputCoordinates(tempcoord);
}
else if(identifier == "f")
{for( i =0; i < 3; i++)
{
count++;m_inFile >> readNum;
if(readNum == 0)
break;
readNum--;
tempface.p[i].x = m_points[readNum].x;
tempface.p[i].y = m_points[readNum].y;
tempface.p[i].z = m_points[readNum].z;m_inFile >> skip >> readNum;
readNum--;
tempface.coord[i].vt[0] = m_coords[readNum].vt[0];
tempface.coord[i].vt[1] = m_coords[readNum].vt[1];
tempface.coord[i].vt[2] = m_coords[readNum].vt[2];m_inFile >> skip >> readNum;
readNum--;
tempface.norm[i].vn[0] = m_normals[readNum].vn[0];
tempface.norm[i].vn[1] = m_normals[readNum].vn[1];
tempface.norm[i].vn[2] = m_normals[readNum].vn[2];}

tempface.name = l_name; // this gives the mtl name to the face so it can be compared and applied later

createFaces(tempface);

}
else if(identifier =="mtllib")
{
m_inFile >> identifier;
identifier = "test/" + identifier;
processMTL(identifier);
}

else if(identifier == "usemtl")
{
// chnages the mtl that is being applied
m_inFile >> read;

l_name = read; // so the face can have

}
else
{
getline(m_inFile,read);
std::cout << "Not Processed From Loader" << identifier << " " << read <<std::endl;
}

m_inFile >> identifier;

} while (!m_inFile.eof());
//m_inFile.close();
//m_inFile.~basic_ifstream();
}void Loader::draw()
{
int i;
int j;
int k;

std::string currentTex;

glEnable(GL_TEXTURE_2D);
//glDisable(GL_TEXTURE_2D);
//glBegin(GL_TRIANGLES);

for (i=0; i < m_faces.size();i++)
{
//bind a certain image
for (k=0; k<m_mtl.size();k++)
{
if (m_mtl[k].compare(m_faces[i].name) == true)
{
//these next two lines do the same thing
//m_mtl[k].draw();
glBindTexture(GL_TEXTURE_2D,m_mtl[k].getGLID());
//break; // break out of the loop
}

}

glBegin(GL_TRIANGLES);

for(j = 0 ; j < 3; j++)
{
glNormal3f(m_faces[i].norm[j].vn[0],m_faces[i].norm[j].vn[1],m_faces[i].norm[j].vn[2]);
glTexCoord2f(m_faces[i].coord[j].vt[0],m_faces[i].coord[j].vt[1]);
glVertex3f(m_faces[i].p[j].x,m_faces[i].p[j].y,m_faces[i].p[j].z);
}
glEnd();

}

}
void Loader::processMTL(std::string input)
{

std::string identifier;
std::string read; //for reading whole lines

MTL mtlTemp;
std::ifstream l_inMtl;

//for reading in numbers to give to the mtl
float ka0, ka1, ka2;
float kd0, kd1, kd2;
float ks0, ks1, ks2;

//so that an empty mtl is not pushed back into the vector
bool firstRun = true;

l_inMtl.open(input);
l_inMtl >> identifier;

do{
if(identifier == "#")
{
getline(l_inMtl,read);
}
else if(identifier == "newmtl")
{
//checks to see if it has run before if it has not run before don't push back the last read
if (firstRun == false)
m_mtl.push_back(mtlTemp);
else
firstRun = false;l_inMtl >> identifier;
mtlTemp.setName(identifier);
}
else if(identifier == "Ka")
{
l_inMtl >>ka0 >> ka1 >> ka2;
mtlTemp.setKa(ka0,ka1,ka2);
}
else if(identifier == "Kd")
{
l_inMtl >> kd0 >>kd1 >> kd2;
mtlTemp.setKd(kd0,kd1,kd2);
}
else if(identifier =="Ks")
{
l_inMtl >> ks0 >> ks1 >> ks2;
mtlTemp.setKs(ks0, ks1, ks2);
}
else if(identifier == "map_Ka")
{
getline(l_inMtl,identifier);
//l_inMtl >> identifier;
mtlTemp.setLoc(identifier);
}
else
{
getline(l_inMtl,read);
std::cout << "Not Processed MTL" << identifier << " " << read << std::endl;
}
l_inMtl >> identifier;
}while(!l_inMtl.eof());

l_inMtl.close();
m_mtl.push_back(mtlTemp); // so the last one is pushed back

}

MTL.h

 #pragma once#include "../freeglut.h"
#include <string>
#include <fstream>
#include "typedef.h"#include "../lib/IL/il.h"#include <iostream>
//#include <IL/il.h>

class MTL
{
public:
MTL(); //name of the file
~MTL(void);

void bind(std::string bindType);// somehow set the bind type eg tile stretch ect

void setVar(float ka0, float ka1, float ka2,float kd0, float kd1, float kd2, float ks0, float ks1, float ks2); // takes in all the inputs and sets them to the class
void setLoc(std::string inLocation); // set the location
void setName(std::string inName);

void setKa(float ka0, float ka1, float ka2);
void setKd(float kd0, float kd1, float kd2);
void setKs(float ks0, float ks1, float ks2);

void setNs(float inNs);

bool compare(std::string inName); // compare the string with another
void draw(); // change the binds
GLuint getGLID() { return texture;};

private:

std::string name;
std::string location; // the location of the image

float ka[3];
float kd[3];
float ks[3];// must have freeglut in order to use this
BYTE *pixmap; // contains the data (not yet set)
GLuint texture;

//two functions that you need to load and display
void LoadThing();
void createTex(int width, int height, int chan);

};

MTL.cpp

#include "MTL.h"
MTL::MTL() /
{
}
MTL::~MTL()
{

}

void MTL::setName(std::string inName)
{
name = inName;
}void MTL::setLoc(std::string inLocation)
{
location = inLocation;

LoadThing();
}
bool MTL::compare(std::string inName) // compare the string with another
{
//return true if they are the same
if (name == inName)
return true;
else
return false;

}
void MTL::draw() // change the binds
{
glBindTexture(GL_TEXTURE_2D, texture);

}

void MTL::setKa(float ka0, float ka1, float ka2)
{
ka[0] = ka0;
ka[1] = ka1;
ka[2] = ka2;
}

void MTL::setKd(float kd0, float kd1, float kd2)
{
kd[0] = kd0;
kd[1] = kd1;
kd[2] = kd2;
}

void MTL::setKs(float ks0, float ks1, float ks2)
{
ks[0] = ks0;
ks[1] = ks1;
ks[2] = ks2;
}

void MTL::LoadThing()
{
ILuint devImg;
ilGenImages(1,&devImg);
ilBindImage(devImg);

int error = ilLoadImage("marble_floor2.png");

int e = ilGetError();

pixmap = ilGetData();
int width = ilGetInteger(IL_IMAGE_WIDTH);
int height = ilGetInteger(IL_IMAGE_HEIGHT);
int chan = ilGetInteger(IL_IMAGE_BYTES_PER_PIXEL);

createTex(width,height,chan);
}

void MTL::createTex(int width, int height, int chan)
{
glEnable(GL_TEXTURE_2D);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

glGenTextures(1, &texture);glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, texture);

glTexImage2D(GL_TEXTURE_2D, 0, chan, width, height, 0, (chan == 4)?GL_RGBA: GL_RGB, GL_UNSIGNED_BYTE, pixmap);

//no clue
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);

}

Редактировать: Во-первых, спасибо парням, которые проголосовали за меня, мне потребовалось некоторое время, чтобы понять, но у меня было много функций, которые вы, ребята, не должны были видеть, поэтому они были сокращены.

места, которые я думаю, могут содержать проблему, будут
рисовать()
process () из загрузчика
а также
Рисовать()
LoadThings ()
createTex () из MTL

РЕДАКТИРОВАТЬ:
Хорошо, ребята, я нашел решение, оказывается, почему-то opengl использует glColor при отображении текстур, так что было сделано … opengl

решение:
добавьте эту строку чуть выше вашего glBegin (poly? triangle)
glColor3f (1.0f, 1.0f, 1.0f)