opengl 카메라 이동

<basic.vert>

#version 400
in vec3 VertexPosition;
in vec3 VertexColor;
out vec3 Color;
 
uniform mat4 MVP;
 
void main()
{
    Color = VertexColor;
    gl_Position = MVP * vec4(VertexPosition, 1.0);
}

 

<basic.frag>

#version 400
in vec3 Color;
out vec4 FragColor;
void main() {
    FragColor = vec4(Color, 1.0);
}
 

 

 

<main.cpp>

using namespace std;
 
#include "stdlib.h"
#include "time.h"
#include <GL/glew.h>
#include <GL/freeglut.h>
 
#include "glm\glm.hpp"
#include "glm\gtc\matrix_transform.hpp"
#include <string>
#include <fstream>
 
int setShader(char* shaderType, char* shaderFile);
char* readShader(std::string fileName);
 
#define BUFFER_OFFSET(x)  ((const void*) (x))
#define FPS 60
 
#define X_AXIS glm::vec3(1,0,0)
#define Y_AXIS glm::vec3(0,1,0)
#define Z_AXIS glm::vec3(0,0,1)
#define XY_AXIS glm::vec3(1,0.9,0)
#define YZ_AXIS glm::vec3(0,1,1)
#define XZ_AXIS glm::vec3(1,0,1)
 
 
static unsigned int
program,
vertexShaderId,
fragmentShaderId;
 
glm::mat4 MVP, View, Projection;
GLuint vao, points_vbo, colors_vbo, modelID;
float xVal = 0.0f, yVal = 0.0f, zVal = 5.0f;;
int randomColorSeed[10];
 
glm::vec3 cameraPos = glm::vec3(0.0f, 0.0f, 5.0f);
glm::vec3 cameraFront = glm::vec3(0.0f, 0.0f, -1.0f);
glm::vec3 cameraUp = glm::vec3(0.0f, 1.0f, 0.0f);
glm::vec3 cameraRight = glm::vec3(1.0f, 0.0f, 0.0f);
float cameraSpeed = 0.2;
 
GLshort cube_indices[] = {
    // Front.
    3, 2, 1, 0,
    // Left.
    0, 3, 7, 4,
    // Bottom.
    4, 0, 1, 5,
    // Right.
    5, 1, 2, 6,
    // Back.
    6, 5, 4, 7,
    // Top.
    7, 6, 2, 3
};
 
GLfloat cube_vertices[] = {
    -0.9f, -0.9f, 0.9f,        // 0.
    0.9f, -0.9f, 0.9f,        // 1.
    0.9f, 0.9f, 0.9f,        // 2.
    -0.9f, 0.9f, 0.9f,        // 3.
    -0.9f, -0.9f, -0.9f,    // 4.
    0.9f, -0.9f, -0.9f,        // 5.
    0.9f, 0.9f, -0.9f,        // 6.
    -0.9f, 0.9f, -0.9f,        // 7.
};
 
GLfloat colors[] = {
    1.0f, 0.0f, 0.0f,
    0.0f, 1.0f, 0.0f,
    0.0f, 0.0f, 1.0f,
    1.0f, 1.0f, 0.0f,
    1.0f, 0.0f, 1.0f,
    0.0f, 1.0f, 1.0f,
    0.5f, 0.0f, 0.0f,
    0.0f, 0.5f, 0.0f
};
 
float scale = 1.0f, inc = -0.05f, angle1 = 0.0f, angle2 = 0.0f;
 
void timer(int); // Prototype.
 
void init(void)
{
    // Create shader program executable.
    vertexShaderId = setShader((char*)"vertex", (char*)"basic.vert");
    fragmentShaderId = setShader((char*)"fragment", (char*)"basic.frag");
    program = glCreateProgram();
    glAttachShader(program, vertexShaderId);
    glAttachShader(program, fragmentShaderId);
    glLinkProgram(program);
    glUseProgram(program);
 
    modelID = glGetUniformLocation(program, "MVP");
 
    // Projection matrix : 45∞ Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
    Projection = glm::perspective(glm::radians(45.0f), 4.0f / 3.0f, 0.1f, 100.0f);
    // Or, for an ortho camera :
    //Projection = glm::ortho(-3.0f, 3.0f, -3.0f, 3.0f, 0.0f, 100.0f); // In world coordinates
 
    // Camera matrix
    View = glm::lookAt(
        glm::vec3(0, 0, 3), // Origin. Camera is at (0,0,3), in World Space
        glm::vec3(0, 0, 0),      // Look target. Looks at the origin
        glm::vec3(0, 1, 0)   // Up vector. Head is up (set to 0,-1,0 to look upside-down)
    );
 
 
    // Create and set-up the vertex array object
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
 
    GLuint vboHandles[2];
    glGenBuffers(2, vboHandles);
    GLuint positionBufferHandle = vboHandles[0];
    GLuint colorBufferHandle = vboHandles[1];
 
 
    // Populate the position buffer
    glBindBuffer(GL_ARRAY_BUFFER, positionBufferHandle);
    glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(float), cube_vertices, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte*)NULL);
    // Enable the vertex attribute arrays
    glEnableVertexAttribArray(0); // for Vertex position
 
    // Populate the color buffer
    glBindBuffer(GL_ARRAY_BUFFER, colorBufferHandle);
    glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(float), colors, GL_STATIC_DRAW);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (GLubyte*)NULL);
    glEnableVertexAttribArray(1); // for Vertex color
 
 
    GLuint indexBufferObjec;
    glGenBuffers(1, &indexBufferObjec);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferObjec);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cube_indices), cube_indices, GL_STATIC_DRAW);
 
 
    glEnable(GL_DEPTH_TEST);
    timer(0);
}
 
//---------------------------------------------------------------------
//
// transformModel
//
void transformObject(float scale, glm::vec3 rotationAxis, float rotationAngle, glm::vec3 translation) {
    glm::mat4 Model;
    Model = glm::mat4(1.0f);
    Model = glm::translate(Model, translation);
    Model = glm::rotate(Model, glm::radians(rotationAngle), rotationAxis);
    Model = glm::scale(Model, glm::vec3(scale));
 
    View = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
    //View = glm::lookAt(
    //    glm::vec3(xVal, yVal, 5), // Origin. Camera is at (0,0,3), in World Space
    //    glm::vec3(0, 0, -4),      // Look target. Looks at the origin
    //    glm::vec3(0, 1, 0)   // Up vector. Head is up (set to 0,-1,0 to look upside-down)
    //);
    MVP = Projection * View * Model;
    glUniformMatrix4fv(modelID, 1, GL_FALSE, &MVP[0][0]);
}
 
//---------------------------------------------------------------------
//
// display
//
 
void display(void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
    glBindVertexArray(vao);
 
    transformObject(1.0f, XY_AXIS, angle1 += 0.2f, glm::vec3(0.0f, 1.5f, 0.0f));
 
 
    glDrawElements(GL_QUADS, 24, GL_UNSIGNED_SHORT, 0);
 
    transformObject(1.0f, XY_AXIS, angle2 -= 0.2f, glm::vec3(0.0f, -1.5f, 0.0f));
 
 
    glDrawElements(GL_QUADS, 24, GL_UNSIGNED_SHORT, 0);
 
    glutSwapBuffers(); // Now for a potentially smoother render.
}
 
void idle() // Not even called.
{
    glutPostRedisplay();
}
 
void timer(int) {
    glutPostRedisplay();
    glutTimerFunc(1000 / FPS, timer, 0);
}
 
 
// Keyboard input processing routine.
void keyDown(unsigned char key, int x, int y)
{
    switch (key)
    {
        case 27:
            exit(0);
            break;
        case 'w':
            cameraPos += cameraSpeed * cameraFront;
            break;
        case 's':
            cameraPos -= cameraSpeed * cameraFront;
            break;
        case 'r':
            cameraPos -= glm::normalize(glm::cross(cameraFront, cameraRight)) * cameraSpeed;
            break;
        case 'f':
            cameraPos += glm::normalize(glm::cross(cameraFront, cameraRight)) * cameraSpeed;
            break;
        case 'a':
            cameraPos -= glm::normalize(glm::cross(cameraFront, cameraUp)) * cameraSpeed;
            break;
        case 'd':
            cameraPos += glm::normalize(glm::cross(cameraFront, cameraUp)) * cameraSpeed;
            break;
        default:
            break;
    }
}
 
//---------------------------------------------------------------------
//
// main
//
 
int main(int argc, char** argv)
{
    //Before we can open a window, theremust be interaction between the windowing systemand OpenGL.In GLUT, this interaction is initiated by the following function call :
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE);
 
    //if you comment out this line, a window is created with a default size
    glutInitWindowSize(800, 600);
 
    //the top-left corner of the display
    glutInitWindowPosition(0, 0);
 
    glutCreateWindow("GAME2012_A2_KongWoonhak, 101300258");
 
    // background color is white
    glClearColor(0.0f, 0.5f, 0.5f, 1.0f);
    glewInit();    //Initializes the glew and prepares the drawing pipeline.
 
    init(); // Our own custom function.
 
    //If there are events in the queue, our program responds to them through functions
    //called callbacks.A callback function is associated with a specific type of event.
    //A display callback is generated when the application programm or the
    //operating system determines that the graphics in a window need to be redrawn.
    glutDisplayFunc(display); // Output.
    //glutIdleFunc(idle);
 
    glutKeyboardFunc(keyDown); // Input.
 
    //begin an event-processing loop
    glutMainLoop();
}
 
// Function to initialize shaders.
int setShader(char* shaderType, char* shaderFile)
{
    int shaderId;
    char* shader = readShader(shaderFile);
 
    if (shaderType == "vertex") shaderId = glCreateShader(GL_VERTEX_SHADER);
    if (shaderType == "tessControl") shaderId = glCreateShader(GL_TESS_CONTROL_SHADER);
    if (shaderType == "tessEvaluation") shaderId = glCreateShader(GL_TESS_EVALUATION_SHADER);
    if (shaderType == "geometry") shaderId = glCreateShader(GL_GEOMETRY_SHADER);
    if (shaderType == "fragment") shaderId = glCreateShader(GL_FRAGMENT_SHADER);
 
    glShaderSource(shaderId, 1, (const char**)&shader, NULL);
    glCompileShader(shaderId);
 
    return shaderId;
}
// Function to read external shader file.
char* readShader(std::string fileName)
{
    // Initialize input stream.
    std::ifstream inFile(fileName.c_str(), std::ios::binary);
 
    // Determine shader file length and reserve space to read it in.
    inFile.seekg(0, std::ios::end);
    int fileLength = inFile.tellg();
    char* fileContent = (char*)malloc((fileLength + 1) * sizeof(char));
 
    // Read in shader file, set last character to NUL, close input stream.
    inFile.seekg(0, std::ios::beg);
    inFile.read(fileContent, fileLength);
    fileContent[fileLength] = '\0';
    inFile.close();
 
    return fileContent;
}

 

<결과>

 

<소스코드>

https://github.com/woonhak-kong/OpenGL_Practice11_camera_movement