Как загрузить файл .m без получения ошибки?

Question

Ниже приведен мой код.Я получаю несколько ошибок, например:

Код серьезности Описание Ошибка состояния подавления строки файла проекта C2995 'glm :: detail :: component_count_t glm :: detail :: component_count (const genType &)': шаблон функцииуже определен Project103 c: \ users \ onedrive \ desktop \ r \ glm \ gtx \ setup.hpp 918

Код серьезности Описание Ошибка состояния подавления строки файла проекта C2995 'size_t glm :: countof (const T (&) [N]) ': шаблон функции уже определен Project103 c: \ users \ onedrive \ desktop \ r \ glm \ gtx \ setup.hpp 947

Код серьезности Описание Проект Состояние файла Подавление строки Ошибка C2011Переопределение типа 'glm :: ctor': 'enum' Project103 c: \ users \ onedrive \ desktop \ r \ glm \ gtx \ setup.hpp 961

Код серьезности Описание Описание Состояние файла Ошибка подавления строки файла проекта C2011 'glmПереопределение типа: precision ':' enum 'Project103 c: \ users \ onedrive \ desktop \ r \ glm \ gtx \ precision.hpp 38

Код серьезности Описание Файл состояния подавления строки файла проекта(активный) Аргумент E0458 типа «glm :: precision» несовместим с параметром шаблона типа «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;
}