opengl dynamic polygon

<basic.frag>

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

 

 

 

<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);
}

 

 

<main>

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>
#include <array>
 
 
// Prototypes
int setShader(char* shaderType, char* shaderFile);
char* readShader(std::string fileName);
void timer(int);
void createModel(int n);
 
#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, indices_vbo;
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;
 
float scale = 1.0f, inc = -0.05f, angle1 = 0.0f, angle2 = 0.0f;
 
 
static float R = 2.0; // Radius of circle.
static float X = 0.0; // X-coordinate of center of circle.
static float Y = 0.0; // Y-coordinate of center of circle.
const int MaxNumVertices = 500; // Number of vertices on circle.
static int numVertices = 10;
#define PI 3.14159265358979324
 
float theta = 0.0f;
 
std::array<glm::vec3, MaxNumVertices> vertices = {};
std::array<glm::vec3, MaxNumVertices> colors = {};
 
GLfloat shape_vertices[MaxNumVertices][3] = { 0.0f, };
GLfloat shape_colors[MaxNumVertices][3] = { 0.0f, };
GLuint shape_indices[MaxNumVertices] = { 0, };
 
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);
 
 
 
    // vertex
    glGenBuffers(1, &points_vbo);
    // Populate the position buffer
    glBindBuffer(GL_ARRAY_BUFFER, points_vbo);
    // don't need to do now
    //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
 
    // color
    glGenBuffers(1, &colors_vbo);
    // Populate the color buffer
    glBindBuffer(GL_ARRAY_BUFFER, colors_vbo);
    // don't need to do now
    //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
 
 
 
    glGenBuffers(1, &indices_vbo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_vbo);
    //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.f, glm::vec3(0.0f, 0.0f, 0.0f));
 
    createModel(numVertices);
    glBindBuffer(GL_ARRAY_BUFFER, points_vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(shape_vertices), shape_vertices, GL_STATIC_DRAW);
 
    glBindBuffer(GL_ARRAY_BUFFER, colors_vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(shape_colors), shape_colors, GL_STATIC_DRAW);
 
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_vbo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(shape_indices), shape_indices, GL_STATIC_DRAW);
 
    // by array
    //glDrawArrays(GL_TRIANGLE_FAN, 0, numVertices);
 
    // by element array
    glDrawElements(GL_TRIANGLE_FAN, numVertices, GL_UNSIGNED_INT, NULL);
 
 
    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;
        case '+':
            numVertices++;
            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, 800);
 
    //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;
}
 
void createModel(int n)
{
    theta = 0.0f;
    for (int i = 0; i < n; ++i)
    {
 
        vertices[i] = glm::vec3(X + R * cos(theta), Y + R * sin(theta), 0.0);
        colors[i] = glm::vec3((float)rand() / (float)RAND_MAX, (float)rand() / (float)RAND_MAX, (float)rand() / (float)RAND_MAX);
 
        theta += 2 * PI / n;
    }
 
    for (int i = 0; i < n; ++i) {
 
        shape_vertices[i][0] = vertices[i].x;
        shape_vertices[i][1] = vertices[i].y;
        shape_vertices[i][2] = vertices[i].z;
 
        shape_colors[i][0] = colors[i][0];
        shape_colors[i][1] = colors[i][1];
        shape_colors[i][2] = colors[i][2];
 
        // for indices
        shape_indices[i] = i;
    }
 
 
}

 

 

 

<결과>

 

<소스코드>

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