6 replies to this topic

[Adam West]

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, &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) * texCoords.size(), reinterpret_cast<void *>(&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,SOIL_CREATE_NEW_ID,SOIL_FLAG_MIPMAPS);
glGenTextures(1, &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!

[nitro glycerine]

Would be much more helpful if you indicated the line(s) these errors are occurring on, not really sure where I'm looking.

[Rld_]

Can't really tell what it is without knowing where the error comes from (the line(s)) like Nitro said.

After skimming a bit through your code, what types are your m_VertexVBO, m_NormalVBO and m_TexCoordVBO? Perhaps you wanted to create an array for those and forgot to switch back as the error seems to be that you're trying to cast an int to a float array.

In general, check what line gives the error and check if the types are similar.

[Adam West]

Would be much more helpful if you indicated the line(s) these errors are occurring on, not really sure where I'm looking.

the errors point to xutility and memory dumps :S

[Evil Steve]

What .cpp file is being compiled when those errors occur?

EDIT: Also, this shouldn't even compile:
throw strcat("Unable to load ", filename.c_str());
That appends to a const char array, which will probably cause memory corruption, or if you're lucky just crash there.
You should throw a std::string or other exception class instead, e.g.
throw "Unable to load " + filename;

[SiCrane]

When dealing with errors, usually you want to deal with the first error and then work down to the errors in the middle and end. This is because the first errors often create errors that propagate down and create additional errors just because the compiler is still confused. So starting with errors twelve and thirteen probably isn't the best course of action. Secondly, when you get errors in template code that isn't your own, it's often helpful to move from the Error List to the Build Output. The Build Output will generally show you the call tree such that it will point out what line of your code invoked the template code that's going haywire.

[Ectara]

After a little research, I found this:
typedef float Lib3dsTexel [2];

This seems to be related to the most likely cause, as I guessed from the error that it was something in a template that was attempting to construct this type from an integer, and assign it to another of its type. Try replacing the std::vector with a dynamically allocated array, since it won't be changing size, and you're using it as one; your problem might disappear, or you might get a better error message.

Also, it's nice to be consistent.