How to load .m file without getting getting error? - c++

Question

Following is my code.
I am getting multiple error
like:
Severity Code Description Project File Line Suppression State
Error C2995 'glm::detail::component_count_t
glm::detail::component_count(const genType &)': function template has
already been
defined Project103 c:\users\onedrive\desktop\r\glm\gtx\setup.hpp 918
Severity Code Description Project File Line Suppression State
Error C2995 'size_t glm::countof(const T (&)[N])': function template
has already been
defined Project103 c:\users\onedrive\desktop\r\glm\gtx\setup.hpp 947
Severity Code Description Project File Line Suppression State
Error C2011 'glm::ctor': 'enum' type
redefinition Project103 c:\users\onedrive\desktop\r\glm\gtx\setup.hpp 961
Severity Code Description Project File Line Suppression State
Error C2011 'glm::precision': 'enum' type
redefinition Project103 c:\users\onedrive\desktop\r\glm\gtx\precision.hpp 38
Severity Code Description Project File Line Suppression State Error
(active) E0458 argument of type "glm::precision" is incompatible with
template parameter of type
"glm::precision" Project103 C:\Users\OneDrive\Desktop\r\glm\gtc\matrix_transform.inl 261
#include <GL/glut.h>
#include <glm.hpp>
#include <gtx/component_wise.hpp>
#include <gtc/matrix_transform.hpp>
#include <vector>
#include <map>
#include <iostream>
#include <fstream>
#include <sstream>
using namespace std;
using namespace glm;
struct Vertex
{
vec3 position;
vec3 normal;
};
vector< Vertex > LoadM(istream& in)
{
vector< Vertex > verts;
map< int, vec3 > positions;
string lineStr;
while (getline(in, lineStr))
{
istringstream lineSS(lineStr);
string lineType;
lineSS >> lineType;
// parse vertex line
if (lineType == "Vertex")
{
int idx = 0;
float x = 0, y = 0, z = 0;
lineSS >> idx >> x >> y >> z;
positions.insert(make_pair(idx, vec3(x, y, z)));
}
// parse face line
if (lineType == "Face")
{
int indexes[3] = { 0 };
int idx = 0;
lineSS >> idx >> indexes[0] >> indexes[1] >> indexes[2];
// http://www.opengl.org/wiki/Calculating_a_Surface_Normal
vec3 U(positions[indexes[1]] - positions[indexes[0]]);
vec3 V(positions[indexes[2]] - positions[indexes[0]]);
vec3 faceNormal = normalize(cross(U, V));
for (size_t j = 0; j < 3; ++j)
{
Vertex vert;
vert.position = vec3(positions[indexes[j]]);
vert.normal = faceNormal;
verts.push_back(vert);
}
}
}
return verts;
}
// mouse state
int btn;
ivec2 startMouse;
ivec2 startRot, curRot;
ivec2 startTrans, curTrans;
void mouse(int button, int state, int x, int y)
{
y = glutGet(GLUT_WINDOW_HEIGHT) - y;
if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN)
{
btn = button;
startMouse = ivec2(x, y);
startRot = curRot;
}
if (button == GLUT_RIGHT_BUTTON && state == GLUT_DOWN)
{
btn = button;
startMouse = ivec2(x, y);
startTrans = curTrans;
}
}
void motion(int x, int y)
{
y = glutGet(GLUT_WINDOW_HEIGHT) - y;
ivec2 curMouse(x, y);
if (btn == GLUT_LEFT_BUTTON)
{
curRot = startRot + (curMouse - startMouse);
}
else if (btn == GLUT_RIGHT_BUTTON)
{
curTrans = startTrans + (curMouse - startMouse);
}
glutPostRedisplay();
}
vector< Vertex > model;
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
double w = glutGet(GLUT_WINDOW_WIDTH);
double h = glutGet(GLUT_WINDOW_HEIGHT);
double ar = w / h;
// "pan"
glTranslatef(curTrans.x / w * 2, curTrans.y / h * 2, 0);
gluPerspective(60, ar, 0.1, 20);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -10);
glPushMatrix();
// apply mouse rotation
glRotatef(curRot.x % 360, 0, 1, 0);
glRotatef(-curRot.y % 360, 1, 0, 0);
glColor3ub(255, 0, 0);
// draw model
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(Vertex), &model[0].position);
glNormalPointer(GL_FLOAT, sizeof(Vertex), &model[0].normal);
glDrawArrays(GL_TRIANGLES, 0, model.size());
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
// draw bounding cube
glDisable(GL_LIGHTING);
glColor3ub(255, 255, 255);
glutWireCube(7);
glEnable(GL_LIGHTING);
glPopMatrix();
glutSwapBuffers();
}
// return the x/y/z min/max of some geometry
template< typename Vec >
pair< Vec, Vec > GetExtents
(
const Vec* pts,
size_t stride,
size_t count
)
{
typedef typename Vec::value_type Scalar;
Vec pmin(std::numeric_limits< Scalar >::max());
Vec pmax(std::min(std::numeric_limits< Scalar >::min(),
(Scalar)-std::numeric_limits< Scalar >::max()));
// find extents
unsigned char* base = (unsigned char*)pts;
for (size_t i = 0; i < count; ++i)
{
const Vec& pt = *(Vec*)base;
pmin = glm::min(pmin, pt);
pmax = glm::max(pmax, pt);
base += stride;
}
return make_pair(pmin, pmax);
}
// centers geometry around the origin
// and scales it to fit in a size^3 box
template< typename Vec >
void CenterAndScale
(
Vec* pts,
size_t stride,
size_t count,
const typename Vec::value_type& size
)
{
typedef typename Vec::value_type Scalar;
// get min/max extents
pair< Vec, Vec > exts = GetExtents(pts, stride, count);
// center and scale
const Vec center = (exts.first * Scalar(0.5)) + (exts.second * Scalar(0.5f));
const Scalar factor = size / glm::compMax(exts.second - exts.first);
unsigned char* base = (unsigned char*)pts;
for (size_t i = 0; i < count; ++i)
{
Vec& pt = *(Vec*)base;
pt = ((pt - center) * factor);
base += stride;
}
}
int main(int argc, char **argv)
{
ifstream ifile("bunny.m");
model = LoadM(ifile);
if (model.empty())
{
cerr << "Empty model!" << endl;
return -1;
}
CenterAndScale(&model[0].position, sizeof(Vertex), model.size(), 7);
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
glutInitWindowSize(640, 480);
glutCreateWindow("GLUT");
glutDisplayFunc(display);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glEnable(GL_DEPTH_TEST);
// set up "headlamp"-like light
glShadeModel(GL_SMOOTH);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
GLfloat position[] = { 0, 0, 1, 0 };
glLightfv(GL_LIGHT0, GL_POSITION, position);
glPolygonMode(GL_FRONT, GL_FILL);
glPolygonMode(GL_BACK, GL_LINE);
glutMainLoop();
return 0;
}