kann nicht glm::rotate arbeiten

Ich kann nicht den Anruf bekommen, glm::rotate(mat4, int, vec3(x,y,z)); zu arbeiten. VS 2010 ist mir zu sagen

Intellisense: no instance of function template "glm::gtc::matrix_transform::rotate" matches the argument

Ich bin mit der glm-0.9.1

Ich habe gesehen, dass dieses stack overflow Frage, aber die Lösung löst dennoch einen Fehler beim intellisense: glm drehen Verwendung in Opengl

Kann ich nicht wirklich erhalten, es zu akzeptieren, jeder der die überladung von Methoden. Ich könnte nur etwas fehlt offensichtlich obwohl.

Ich versuchte zu drehen, rufen offensichtlich in den code, es ist ein bisschen der Weg nach unten.

hier einige code:

#include <GL/glew.h>
#include <GL/glfw.h>
#include <GL/glut.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>

#include "loadShader.h"

#include <stdio.h>
#include <stdlib.h>

glm::mat4 Projection;
glm::mat4 View;
glm::mat4 Model;
glm::mat4 MVP;

glm::mat4 t;
glm::mat4 s;
glm::mat4 r;


GLuint programID;


int main()
{

    //Initialise GLFW
    if( !glfwInit() )
    {
        fprintf( stderr, "Failed to initialize GLFW\n" );
        return -1;
    }

    glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3);
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3);
    glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    //Open a window and create its OpenGL context
    if( !glfwOpenWindow( 1024, 768, 0,0,0,0, 32,0, GLFW_WINDOW ) )
    {
        fprintf( stderr, "Failed to open GLFW window. If you have an Intel GPU, they are not 3.3 compatible. Try the 2.1 version of the tutorials.\n" );
        glfwTerminate();
        return -1;
    }

    //Initialize GLEW
    if (glewInit() != GLEW_OK) {
        fprintf(stderr, "Failed to initialize GLEW\n");
        return -1;
    }

    glfwSetWindowTitle( "Tutorial 02" );

    //Ensure we can capture the escape key being pressed below
    glfwEnable( GLFW_STICKY_KEYS );

    glewExperimental = GL_TRUE;
    glewInit();




    //Dark blue background
    glClearColor(0.0f, 0.0f, 0.3f, 0.0f);

    GLuint VertexArrayID;

    glGenVertexArrays(1, &VertexArrayID);

    glBindVertexArray(VertexArrayID);



    //Create and compile our GLSL program from the shaders
    programID = LoadShaders( "vertexShader.glsl", "fragmentShader.glsl" );


        //Pojectio matrix : 45 degree Field of view, 4:3 ratio, display range : 0.1 unit <-> 100 units
    Projection = glm::perspective( 45.0f, 4.0f /3.0f, 0.1f, 100.0f );
    //Camera matrix
    View = glm::lookAt(
        glm::vec3(4,3,3), //Camera is at (4,3,3), in World Space
        glm::vec3(0,0,0), //and looks at the origin
        glm::vec3(0,1,0) //Head is up (set to 0, -1,0 to look upside down)
        );
    //Model matrix : an identity matrix (model will be at the origin)




    Model = glm::mat4(1.0f); //Changes for each Model !

    //INTELLISENSE ERROR ==================================================================>>>>
    r = glm::rotate(Model, 45, glm::vec3(1,0,0));

    //Our ModelViewProjection : multiplication of our 3 matrices
    MVP = Projection * View * Model; //Remember matrix multiplication is the other way around


        //Get a handle for our "MVP" uniform.
    //Only at initialisation time.
    GLuint MatrixID = glGetUniformLocation(programID, "MVP");

    //Send our transformation to the currently bound shader,
    //in the "MVP" uniform
    //For each model you fender, since the MVP will be different (at least the M part)


    static const GLfloat g_vertex_buffer_data[] = { 
        -1.0f, -1.0f, 0.0f,
         1.0f, -1.0f, 0.0f,
         0.0f,  1.0f, 0.0f,
    };

    GLuint vertexbuffer;
    glGenBuffers(1, &vertexbuffer);
    glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
    glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);





    do{

        //Clear the screen
        glClear( GL_COLOR_BUFFER_BIT );

        //Use our shader
        glUseProgram(programID);

        glUniformMatrix4fv(MatrixID, 1, GL_FALSE, &MVP[0][0]);

        //1rst attribute buffer : vertices
        glEnableVertexAttribArray(0);
        glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
        glVertexAttribPointer(
            0,                  //attribute 0. No particular reason for 0, but must match the layout in the shader.
            3,                  //size
            GL_FLOAT,           //type
            GL_FALSE,           //normalized?
            0,                  //stride
            (void*)0            //array buffer offset
        );

        //Draw the triangle !
        glDrawArrays(GL_TRIANGLES, 0, 3); //From index 0 to 3 -> 1 triangle

        glDisableVertexAttribArray(0);

        //Swap buffers
        glfwSwapBuffers();

    } //Check if the ESC key was pressed or the window was closed
    while( glfwGetKey( GLFW_KEY_ESC ) != GLFW_PRESS &&
           glfwGetWindowParam( GLFW_OPENED ) );

    //Close OpenGL window and terminate GLFW
    glfwTerminate();

    //Cleanup VBO
    glDeleteBuffers(1, &vertexbuffer);
    glDeleteVertexArrays(1, &VertexArrayID);

    return 0;
}

InformationsquelleAutor not_shitashi | 2012-08-23