Jump to content
  • Advertisement
Sign in to follow this  
Adam West

OpenGL opengl game engine [help]

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

If you intended to correct an error in the post then please contact us.

Recommended Posts

hey there,
im having a bit of trouble with my code as the texture co-ordinates are not binding to the texture :/
would you be so kind as to look at my code and show me where im going wrong, im only just learning opengl but i am a pro at c++.

main.h

//Include STD headers
#ifndef MAIN_H
#define MAIN_H

#include<GL/glew.h>
#include<GL/glfw.h>
#include<GL/freeglut.h>
#include <vector>
#include<algorithm>
#include <fstream>
#include<cstdio>
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <cmath>
#include <SFML/Graphics.hpp>
#include <SOIL.h>

//Include GLM
#include <glm/glm.hpp>
using namespace std;
extern GLuint loadShader(const char* vertex_file_path, const char* fragment_file_path);
extern int loadTexture(const char* texfilename,GLuint textureObject);
extern void deleteTexture(GLuint textureObject);
extern void InitializeWindow();
extern void shutdown();
#endif


main.cpp

#include "main.h"
#include "3dsloader.h"
#include "camera.h"
#include "skybox.h"
bool mousein= false;
GLuint programID;
void lighting();
void initRendering();
void drawScene();
void mainLoop();
FPSCamera * camera;
Object* testcube;
//skybox* sky;

int main(int argc, char **argv)
{
bool running = true;

InitializeWindow();

//sky->initSkybox("assets/skybox/citystorm/xpos.jpg","assets/skybox/citystorm/xneg.jpg","assets/skybox/citystorm/ypos.jpg","assets/skybox/citystorm/yneg.jpg","assets/skybox/citystorm/zpos.jpg","assets/skybox/citystorm/zneg.jpg");
//sky->skyboxVBO();
testcube = new Object("teapot.3ds");

testcube->CreateVBO();
// apply texture to all meshes that have texels
testcube->applyTexture("teapot.jpg");
initRendering();

//shader setup
programID = loadShader("emptyshader.vert","bokehDOF.frag");
mainLoop();


return 0;
}
void initRendering()
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_SMOOTH);
glEnable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
// Enable lighting and set the position of the light
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
GLfloat pos[] = { 0.0, 4.0, 4.0 };
glLightfv(GL_LIGHT0, GL_POSITION, pos);


//use shader
glUseProgram(programID);

}

void mainLoop(void)
{
// the time of the previous frame
double old_time = glfwGetTime();
// this just loops as long as the program runs
while(1)
{
// KEY EVENTS 1
// escape to quit,


camera->updateCamera();

if (glfwGetKey(GLFW_KEY_ESC) == GLFW_PRESS)
break;

if (glfwGetMouseButton(GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS)
{
mousein = true;
glfwDisable(GLFW_MOUSE_CURSOR);

}
if(glfwGetKey('P') == GLFW_PRESS)
{
mousein=false;
glfwEnable(GLFW_MOUSE_CURSOR);

}
camera->Control(0.2,0.2,mousein);
// draw the figure

drawScene();


// swap back and front buffers
glfwSwapBuffers();

}
}

void drawScene()
{
//clear info from last draw
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

//skybox for scene
//sky->drawSkybox();
// ADD SCENE OBJECTS TO RENDER HERE


//model loading and stuff
testcube->Draw();

glLoadIdentity();
};

void shutdown()
{
glfwTerminate();
//sky->destroySkybox();
//delete sky;
//sky= NULL;

delete testcube;
testcube = NULL;
delete camera;
camera = NULL;
exit(1);
}

3dsloader.h


#include "main.h"
#include "lib3ds/file.h"
#include "lib3ds/mesh.h"
#include "lib3ds/material.h"

class Object
{
public:
Object(std:: string filename);
virtual ~Object();
virtual void Draw() const;
virtual void CreateVBO();
void applyTexture(const char*texfilename);
protected:
void GetFaces();
unsigned int m_TotalFaces;
Lib3dsFile * m_model;
Lib3dsMesh* Mesh;
vector<GLuint> textureIndices;
GLuint textureObject;
GLuint m_VertexVBO, m_NormalVBO, m_TexCoordVBO;
};


3dsloader.cpp

#include "3dsloader.h"

Object::Object(std:: string filename)
{
m_TotalFaces = 0;
m_model = lib3ds_file_load(filename.c_str());
// If loading the model failed, we throw an exception
if(!m_model)
{
throw strcat("Unable to load ", filename.c_str());
}
// set properties of texture coordinate generation for both x and y coordinates
glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
// if not already enabled, enable texture generation
if(! glIsEnabled(GL_TEXTURE_GEN_S))
glEnable(GL_TEXTURE_GEN_S);
if(! glIsEnabled(GL_TEXTURE_GEN_T))
glEnable(GL_TEXTURE_GEN_T);
lib3ds_file_eval(m_model, 0); // set current frame to 0

}
Object::~Object()
{
if(m_model) // if the file isn't freed yet
lib3ds_file_free(m_model); //free up memory
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
//disable texture generation
for(unsigned int i = 0;i < textureIndices.size();i++)
glDeleteTextures(1, &textureIndices.at(i));
}

void Object::GetFaces()
{
m_TotalFaces = 0;
Lib3dsMesh * mesh;
// Loop through every mesh.
for(mesh = m_model->meshes;mesh != NULL;mesh = mesh->next)
{
// Add the number of faces this mesh has to the total number of faces.
m_TotalFaces += mesh->faces;
}
}
void Object::CreateVBO()
{
assert(m_model != NULL);
// Calculate the number of faces we have in total
GetFaces();
// Allocate memory for our vertices and normals
Lib3dsVector * vertices = new Lib3dsVector[m_TotalFaces * 3];
Lib3dsVector * normals = new Lib3dsVector[m_TotalFaces * 3];
Lib3dsTexel* texCoords = new Lib3dsTexel[m_TotalFaces * 3];
Lib3dsMesh * mesh;
unsigned int FinishedFaces = 0;
// Loop through all the meshes
for(mesh = m_model->meshes;mesh != NULL;mesh = mesh->next)
{
lib3ds_mesh_calculate_normals(mesh, &normals[FinishedFaces*3]);
// Loop through every face
for(unsigned int cur_face = 0; cur_face < mesh->faces;cur_face++)
{
Lib3dsFace * face = &mesh->faceL[cur_face];
for(unsigned int i = 0;i < 3;i++)
{

//NEW
if(mesh->texels)
{
memcpy(&texCoords[FinishedFaces*3 + i], mesh->texelL[face->points[ i ]], sizeof(Lib3dsTexel));
//NEW
}
memcpy(&vertices[FinishedFaces*3 + i], mesh->pointL[face->points[ i ]].pos, sizeof(Lib3dsVector));
}

FinishedFaces++;
}
}
// Generate a Vertex Buffer Object and store it with our vertices
glGenBuffers(1, &m_VertexVBO);
glBindBuffer(GL_ARRAY_BUFFER, m_VertexVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(Lib3dsVector) * 3 * m_TotalFaces, vertices, GL_STATIC_DRAW);
// Generate another Vertex Buffer Object and store the normals in it
glGenBuffers(1, &m_NormalVBO);
glBindBuffer(GL_ARRAY_BUFFER, m_NormalVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(Lib3dsVector) * 3 * m_TotalFaces, normals, GL_STATIC_DRAW);
// Generate a third VBO and store the texture coordinates in it.
glGenBuffers(1, &m_TexCoordVBO);
glBindBuffer(GL_ARRAY_BUFFER, m_TexCoordVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(Lib3dsTexel) * 3 * m_TotalFaces, texCoords, GL_STATIC_DRAW);

// Clean up our allocated memory
delete vertices;
delete normals;

// We no longer need lib3ds
lib3ds_file_free(m_model);
m_model = NULL;
}
void Object::applyTexture(const char*texfilename)
{

float imageWidth;
float imageHeight;
GLuint tmpIndex; // temporary index to old the place of our texture POINTER FOR MULTIPLE??
glGenTextures(1, &tmpIndex); // allocate memory for one texture

tmpIndex = SOIL_load_OGL_texture(texfilename,SOIL_LOAD_AUTO,SOIL_CREATE_NEW_ID,SOIL_FLAG_MIPMAPS);
glBindTexture(GL_TEXTURE_2D, tmpIndex); // use our newest textur
glPixelStorei(GL_UNPACK_ALIGNMENT,1);

glGetTexLevelParameterfv(GL_TEXTURE_2D,0,GL_TEXTURE_WIDTH,&imageWidth);
glGetTexLevelParameterfv(GL_TEXTURE_2D,0,GL_TEXTURE_HEIGHT,&imageHeight);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); // give the best result for texture magnification
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); //give the best result for texture minification
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP); // don't repeat texture
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); // don't repeat textureglTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP); // don't repeat texture
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,GL_MODULATE);
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,imageWidth,imageHeight,0,GL_RGB,GL_UNSIGNED_BYTE,&tmpIndex);
}

void Object::Draw() const
{
// Enable vertex, normal and texture-coordinate arrays.
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
// Bind the VBO with the normals.
glBindBuffer(GL_ARRAY_BUFFER, m_NormalVBO);
// The pointer for the normals is NULL which means that OpenGL will use the currently bound VBO.
glNormalPointer(GL_FLOAT, 0, NULL);
glBindBuffer(GL_ARRAY_BUFFER, m_TexCoordVBO);
glTexCoordPointer(2, GL_FLOAT, 0, NULL);
glBindBuffer(GL_ARRAY_BUFFER, m_VertexVBO);
glVertexPointer(3, GL_FLOAT, 0, NULL);
// Render the triangles.
glDrawArrays(GL_TRIANGLES, 0, m_TotalFaces * 3);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}


initialize.cpp

#include "main.h"

void shutdown();
void InitializeWindow()
{
const int window_width = 800,
window_height = 600;

if (glfwInit() != GL_TRUE)
shutdown();
// 800 x 600, 16 bit color, no depth, alpha or stencil buffers, windowed
if (glfwOpenWindow(window_width, window_height, 5, 6, 5,
0, 0, 0, GLFW_WINDOW) != GL_TRUE)
shutdown();
glfwSetWindowTitle("Pheonix engine R1");
glewInit();
glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4); // 4x antialiasing
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); // We want OpenGL 3.1
glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 1);
glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //We don't want the old OpenGL
// set the projection matrix to a normal frustum with a max depth of 50
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
float aspect_ratio = ((float)window_height) / window_width;

//culling etc
GLfloat zNear = 0.1f;
GLfloat zFar = 255.0f;

GLfloat fH = tan( float(45 / 360.0f * 3.14159f) ) * zNear;
GLfloat fW = fH * aspect_ratio;
glFrustum( -fW, fW, -fH, fH, zNear, zFar );

glMatrixMode(GL_MODELVIEW);

}



any insight into my problem is welcome,

also, with gl frustum, how can i make sure there is no warping of models from field of view. i also heard it was depreciated so an alternative would be awesome, thanks!

Share this post


Link to post
Share on other sites
Advertisement
I'm going to follow the same trend I did in your previous threads:

What does your shader look like?
Is your texture actually loaded? What is the ID returned by soil?
Are your UV coordinates properly loaded?
What does the model look like now?

Share this post


Link to post
Share on other sites

What does your shader look like?
Is your texture actually loaded? What is the ID returned by soil?
Are your UV coordinates properly loaded?
What does the model look like now?
[/quote]

1. no shader is actualy being loaded for the rendering of the model (should there be?)
2. yes the texture is loaded, the real question is how can i find the ID generated by soil?
3. UV co-ordinates are parsed and are in the 3ds file.
4. model looks just like a lit teapot with no texture.

Share this post


Link to post
Share on other sites

1. no shader is actualy being loaded for the rendering of the model (should there be?)

No, doesn't have to, but I see one being loaded in your program and as I don't know your full code, I don't want to assume you're not doing anything with it.


2. yes the texture is loaded, the real question is how can i find the ID generated by soil?

Well.. Obviously this:
tmpIndex = SOIL_load_OGL_texture(texfilename,SOIL_LOAD_AUTO,SOIL_CREATE_NEW_ID,SOIL_FLAG_MIPMAPS);
tmpIndex should return something other than 0. If this is 0 it means you are not loading your texture properly.

Also, SOIL takes all the loading for you, do you really need all the texture functions? I'm sure you don't need glGenTextures and glTexImage2D when using SOIL. As far as I know, all you need to do with SOIL is load your texture which returns the ID, which in turn you can use with glBindTexture.


3. UV co-ordinates are parsed and are in the 3ds file.

Just make sure they are correct and you use them correctly. I see you allocating texel data as if it has 3 elements, yet in your drawing routine you say there are 2. Also I am not sure if you need to keep binding your buffers that way. (might be wrong on that one, not a complete openGL guru here).


4. model looks just like a lit teapot with no texture.


Take baby steps when debugging, make sure all the data is as you expect it should be.

Share this post


Link to post
Share on other sites
thanks reloaded_,
that actually makes a lot more sense than other feeback i've been getting.

okay so the texture get assigned to the model now but the co-ordinates do not match up to the model.
i have done a bit of modding of my source and i have come up with this:

void Object::applyTexture(const char*texfilename)
{

textureObject = SOIL_load_OGL_texture(texfilename,SOIL_LOAD_AUTO,SOIL_CREATE_NEW_ID,SOIL_FLAG_MIPMAPS);

glBindTexture(GL_TEXTURE_2D,textureObject);// use our newest texture
}

void Object::Draw() const
{



// Enable vertex, normal and texture-coordinate arrays.
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);



// Bind the VBO with the normals.
glBindBuffer(GL_ARRAY_BUFFER, m_NormalVBO);
// The pointer for the normals is NULL which means that OpenGL will use the currently bound VBO.
glNormalPointer(GL_FLOAT, 0, NULL);

glBindBuffer(GL_ARRAY_BUFFER, m_TexCoordVBO);
glTexCoordPointer(3,GL_FLOAT,sizeof(Lib3dsVector), NULL);
glBindBuffer(GL_ARRAY_BUFFER, m_VertexVBO);
glVertexPointer(3, GL_FLOAT, 0, NULL);
// Render the triangles.
glDrawArrays(GL_TRIANGLES, 0, m_TotalFaces * 3);

glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
}


im really stuck now as i want the texture map to match the object. currently it looks like this:


currentno.png

Uploaded with ImageShack.us

Share this post


Link to post
Share on other sites
It's getting somewhere. You changed your texel data to a vector, which I am assuming has 3 components. UV coordinates mostly (if not always) come with 2 Components which was probably what your texel data has. Try changing your code to only us texel data where your texcoord data is concerned.

Share this post


Link to post
Share on other sites

It's getting somewhere. You changed your texel data to a vector, which I am assuming has 3 components. UV coordinates mostly (if not always) come with 2 Components which was probably what your texel data has. Try changing your code to only us texel data where your texcoord data is concerned.


hmm, bringing it down to two components causes a crash at runtime.

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!