PDA

View Full Version : weird errors in game project [HELP ME]



adam west
03-25-2012, 10:25 PM
hey there.

i just tried to implement textures and im getting this weird error which i unfortunately do not know where to start with it.
could anyone help me shed some light??



//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 glm;
extern int loadTexture(const char* texfilename);
extern void InitializeWindow();
extern void shutdown();
#endif




//MAIN.CPP
#include "main.h"
#include "3dsloader.h"
#include "camera.h"

bool mousein= false;
void lighting();
void initRendering();
void drawScene();
void mainLoop();

FPSCamera * camera;
Object* testcube;
//textureLoader * testTex;
int main(int argc, char **argv)
{
bool running = true;

InitializeWindow();

testcube = new Object("test.3ds");

testcube->CreateVBO();
initRendering();
mainLoop();


return 0;
}
void initRendering()
{
glClearColor(0.0, 0.0, 0.0, 0.0);
glShadeModel(GL_SMOOTH);
glEnable(GL_TEXTURE_2D);
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);

}

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);

// ADD SCENE OBJECTS TO RENDER HERE
//model loading and stuff
glEnable(GL_TEXTURE_2D);
loadTexture("texture.jpg");
testcube->Draw();
glDisable(GL_TEXTURE_2D);
glLoadIdentity();
};
void shutdown()
{
glfwTerminate();
delete testcube;
delete camera;
exit(1);
}





//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());
}

}
Object::~Object()
{
if(m_model) // if the file isn't freed yet
lib3ds_file_free(m_model); //free up memory
//disable texture generation
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
}
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];
std::vector<Lib3dsTexel> texCoords(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, &amp;normals[FinishedFaces*3]);
// Loop through every face
for(unsigned int cur_face = 0; cur_face < mesh->faces;cur_face++)
{
Lib3dsFace * face = &amp;mesh->faceL[cur_face];
for(unsigned int i = 0;i < 3;i++)
{

//NEW
if(mesh->texels)
{
memcpy(&amp;texCoords[FinishedFaces*3 + i], mesh->texelL[face->points[ i ]], sizeof(Lib3dsTexel));
//NEW
}
memcpy(&amp;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, &amp;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, &amp;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, &amp;m_TexCoordVBO);
glBindBuffer(GL_ARRAY_BUFFER, m_TexCoordVBO);
glBufferData(GL_ARRAY_BUFFER, sizeof(Lib3dsTexel) * texCoords.size(), reinterpret_cast<void *>(&amp;texCoords[0]), 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:: 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);


}




//texture.cpp
#include "3dsloader.h"
int loadTexture(const char* texfilename) //load bitmap and convert to texture
{

GLuint textureObject = 0;
textureObject = SOIL_load_OGL_texture(texfilename,SOIL_LOAD_AUTO,S OIL_CREATE_NEW_ID,SOIL_FLAG_MIPMAPS);
glGenTextures(1, &amp;textureObject); // allocate memory for one texture
glBindTexture(GL_TEXTURE_2D, textureObject); // use our newest texture
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 texture

glBindTexture( GL_TEXTURE_2D,textureObject);
return textureObject;
}



and the following errors i am getting are:


Error 12 error C2440: '<function-style-cast>' : cannot convert from 'int' to 'float [2]' c:\program files (x86)\microsoft visual studio 10.0\vc\include\memory 631
Error 13 error C2106: '=' : left operand must be l-value c:\program files (x86)\microsoft visual studio 10.0\vc\include\xutility 2514



thanks, for your help!