Adam West

Your problem most likely resides here (as I have tried to point out several times before in multiple threads).  Have you tried debugging the problem?  (I'm inferring a Visual Studio/Windows setup here.)

nope.avi

strcat is fine, its the way the object memory is handeled

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!