GLuint TextureLoader::loadTexture(const std::string & filename) {
unsigned char* data = NULL;
if(filename.length() < 5) {
return 0;
}
std::string extension = filename.substr(filename.length() - 3, 3);
bool isPNG = false;
bool isBMP = false;
if(extension.compare("png") == 0) {
isPNG = true;
} else if(extension.compare("bmp") == 0) {
isBMP = true;
} else {
std::cout << "Texture loading error: Bad file extension!\n";
return 0;
}
std::ifstream textureFile(filename.c_str(), std::ios::in | std::ios::binary);
if(!textureFile.good()) {
std::cout << "Texture loading error: File not good!\n";
return 0;
}
unsigned int width = 0;
unsigned int height = 0;
if(isPNG && !isBMP) {
loadPNGTexture(textureFile, width, height, data);
} else if(isBMP && !isPNG) {
loadBMPTexture(textureFile, width, height, data);
} else {
return 0;
}
textureFile.close();
if(data == NULL) {
return 0;
}
GLuint texture;
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
GLfloat maxAnisotropy = 1.0;
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, maxAnisotropy);
// Not needed after adding alpha byte - natural alignment to 4 bytes
// glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
glGenerateMipmap(GL_TEXTURE_2D);
delete data;
return texture;
}
int* loadTextures(B3DFile* b3d) {
int* output;
Blitz3DTEXSChunk* texsChunk;
unsigned int textureCount;
unsigned int iter;
texsChunk = getTEXSChunkFromBB3DChunk(getBB3DChunkFromFile(b3d));
textureCount = getTextureArrayCountFromTEXSChunk(texsChunk);
output = (int*)calloc(textureCount, sizeof(int));
glEnable(GL_TEXTURE_2D);
for (iter = 0; iter < textureCount; iter++) {
char* directoryPath;
char* fileName;
char* filePath;
directoryPath = getDirectoryFromFile(b3d);
fileName = getFileFromTexture(getTextureArrayEntryFromTEXSChunk(texsChunk, iter));
filePath = (char*)calloc(strlen(directoryPath) + strlen(fileName) + 1, sizeof(char));
sprintf(filePath, "%s%s", directoryPath, fileName);
/*printf("full path: %s\n", filePath);*/
if (filePath[strlen(filePath) - 1] == 'g') {
/*printf(" is a PNG image\n");*/
output[iter] = loadPNGTexture(filePath);
/*printf(" texture id: %d\n", output[iter]);*/
}
if (filePath[strlen(filePath) - 1] == 'p') {
/*printf(" is a BMP image\n");*/
output[iter] = loadBMPTexture(filePath);
/*printf(" texture id: %d\n", output[iter]);*/
}
free(filePath);
}
return output;
}
void init() {
glClearColor (0.0,0.0,0.0,0.0);
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(50,1.5,1,40);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0,2,10,0,2,0,0,1,0);
//Enable Point sprites
glEnable(GL_POINT_SPRITE);
glEnable(GL_TEXTURE_2D);
//set texture
water_tex = loadPNGTexture("particle_water.png");
water_list.clear();
}
void AnimatedTexture::addTexture(const char *textureName, double interval)
{
textureList.push_back(loadPNGTexture(textureName));
changeDelay.push_back(interval);
}
void AnimatedTexture::addTexture(const char *textureName)
{
textureList.push_back(loadPNGTexture(textureName));
changeDelay.push_back(1.0);
}
void InitLivin(int width, int height){
int i;
char letterpath[] = "data/x.obj"; /* character mesh mask */
char letterlist[LETTERNUM] = "bceginrsty"; /* Cybernetic genetics characters */
char greetingspath[21];
/* OpenGL related initialization */
glClearColor(0.0, 0.0, 0.0, 0.0);
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
perspectiveMatrix(pmatrix, 35.0, (float)width/(float)height, 0.1, 1500.0);
/* Demo related initialization */
head = openDepthVideo("data/head.dv");
matat = openDepthVideo("data/matat.dv");
face = initFace("shaders/face.vs", "shaders/face.fs");
armface = initFace("shaders/face.vs", "shaders/face.fs");
knock = openOutline("data/knock.pyd", "shaders/knock.vs", "shaders/knock.fs");
jump = openOutline("data/jump.pyd", "shaders/jump.vs", "shaders/outline.fs");
hang = openOutline("data/hanging.pyd", "shaders/hang.vs", "shaders/outline.fs");
run = openOutline("data/run.pyd", "shaders/run.vs", "shaders/outline.fs");
falling = openOutline("data/falling_letters.pyd", "shaders/run.vs", "shaders/outline.fs");
door = openOutline("data/door.pyd", "shaders/door.vs", "shaders/door.fs");
trap = openOutline("data/trap.pyd", "shaders/trap.vs", "shaders/outline.fs");
fractalme = openOutline("data/fractalme.pyd", "shaders/frme.vs", "shaders/frme.fs");
/* Acrobatic outlines */
tiger = openOutline("data/tiger.pyd", "shaders/acrobat.vs", "shaders/outline.fs");
hop = openOutline("data/hop.pyd", "shaders/acrobat.vs", "shaders/outline.fs");
katf = openOutline("data/kezenatfordulas.pyd", "shaders/acrobat.vs", "shaders/outline.fs");
flip = openOutline("data/flip.pyd", "shaders/acrobat.vs", "shaders/outline.fs");
run2 = openOutline("data/run2.pyd", "shaders/acrobat.vs", "shaders/outline.fs");
catwheel = openOutline("data/catwheel.pyd", "shaders/acrobat.vs", "shaders/outline.fs");
tbill = openOutline("data/tarkobillenes.pyd", "shaders/acrobat.vs", "shaders/outline.fs");
createBox();
createBackground();
initGreetings();
createDistBack();
bigcube = createBigCube(600);
titletex = loadPNGTexture("data/title.png");
greentex = loadPNGTexture("data/green.png");
creditstex = loadPNGTexture("data/credits.png");
bgalphatex = loadPNGTexture("data/bg_alpha.png");
whitetex = loadPNGTexture("data/white.png");
icubetex = loadPNGTexture("data/innercube.png");
headouttex = loadPNGTexture("data/headout.png");
chesstex = loadPNGTexture("data/chessboard.png");
atpartytex = loadPNGTexture("data/at_party.png");
for(i = 0; i < 12; i++){
sprintf(greetingspath, "data/greetings%d.png", i+1);
greetingstex[i] = loadPNGTexture(greetingspath);
}
for(i = 0; i < MAXKNOCKINGMAN; i++){
knockingmans[i * 3 + 0] = drand48() * 4.0 + 8.0;
knockingmans[i * 3 + 1] = drand48() * 6.0 + 1.0;
knockingmans[i * 3 + 2] = drand48();
}
/* Shaders */
background_src[0] = loadShader(GL_VERTEX_SHADER, "shaders/background.vs");
background_src[1] = loadShader(GL_FRAGMENT_SHADER, "shaders/background.fs");
background_src[2] = loadShader(GL_TESS_EVALUATION_SHADER, "shaders/background.te");
background_src[3] = loadShader(GL_TESS_CONTROL_SHADER, "shaders/background.tc");
background_src[4] = loadShader(GL_GEOMETRY_SHADER, "shaders/background.gs");
background_shader = createProgram(5, background_src);
title_src[0] = background_src[0];
title_src[1] = loadShader(GL_FRAGMENT_SHADER, "shaders/title.fs");
title_src[2] = background_src[2];
title_src[3] = background_src[3];
title_src[4] = background_src[4];
title_shader = createProgram(5, title_src);
scroll_src[0] = background_src[0];
scroll_src[1] = loadShader(GL_FRAGMENT_SHADER, "shaders/scroll.fs");
scroll_src[2] = background_src[2];
scroll_src[3] = background_src[3];
scroll_src[4] = background_src[4];
scroll_shader = createProgram(5, scroll_src);
credits_src[0] = background_src[0];
credits_src[1] = loadShader(GL_FRAGMENT_SHADER, "shaders/credits.fs");
credits_src[2] = background_src[2];
credits_src[3] = background_src[3];
credits_src[4] = loadShader(GL_GEOMETRY_SHADER, "shaders/credits.gs");
credits_shader = createProgram(5, credits_src);
letter_src[0] = loadShader(GL_VERTEX_SHADER, "shaders/letter.vs");
letter_src[1] = loadShader(GL_FRAGMENT_SHADER, "shaders/letter.fs");
letter_shader = createProgram(2, letter_src);
cube_src[0] = loadShader(GL_VERTEX_SHADER, "shaders/cube.vs");
cube_src[1] = loadShader(GL_FRAGMENT_SHADER, "shaders/cube.fs");
cube_src[2] = loadShader(GL_GEOMETRY_SHADER, "shaders/cube.gs");
cube_shader = createProgram(3, cube_src);
gr_src[0] = loadShader(GL_VERTEX_SHADER, "shaders/greetings.vs");
gr_src[1] = loadShader(GL_FRAGMENT_SHADER, "shaders/greetings.fs");
gr_shader = createProgram(2, gr_src);
dbgr_src[0] = loadShader(GL_VERTEX_SHADER, "shaders/dbgr.vs");
dbgr_src[1] = loadShader(GL_FRAGMENT_SHADER, "shaders/dbgr.fs");
dbgr_shader = createProgram(2, dbgr_src);
bigcube_src[0] = loadShader(GL_VERTEX_SHADER, "shaders/bigcube.vs");
bigcube_src[1] = loadShader(GL_FRAGMENT_SHADER, "shaders/bigcube.fs");
bigcube_shader = createProgram(2, bigcube_src);
/* Letters */
for(i = 0; i < LETTERNUM; i++){
letterpath[5] = letterlist[i];
letters[i] = loadOBJ(letterpath);
glBindVertexArray(letters[i]->vao);
bindVarToBuff(letter_shader, "vertex", letters[i]->vbo[MESHVERTEXINDEX], 3);
bindVarToBuff(letter_shader, "normal", letters[i]->vbo[MESHNORMALINDEX], 3);
bindVarToBuff(letter_shader, "tcoord", letters[i]->vbo[MESHTEXINDEX], 2);
}
cube = loadOBJ("data/cube.obj");
glBindVertexArray(cube->vao);
bindVarToBuff(cube_shader, "vertex", cube->vbo[MESHVERTEXINDEX], 3);
bindVarToBuff(cube_shader, "normal", cube->vbo[MESHNORMALINDEX], 3);
bindVarToBuff(cube_shader, "tcoord", cube->vbo[MESHTEXINDEX], 2);
initExplosion();
startTime();
}
