Write a small game with opengl (1)

expense or outlayopengl Write a small game (1)

Write a small game in opengl 1
- Environment Setup
  - freetype
  - soil
  - glm
  - caveat
- basic component
  - shader
  - texture
  - Resource loading
- renderer (computing)
- Main game category
- game window

Code for this sectiongithub

Environment Setup

The basic environment setup can be found in my previous articleIntegration of opengl environment in Eclipse or CLion (windows+mingw)
Here we need two other packages, freetype and soil.

freetype

The FreeType library is a completely free (open source), high-quality and portable font engine that provides a unified interface to multiple font format files. It provides a unified interface to access a wide range of font formats. It is available inthis websiteDownload the source code or download the binary directly.

soil

SOIL is the Simple OpenGL Image Library (Simple OpenGL).Image Library), which supports most popular image formats and is easy to use. It helps us to load images for textures in openGL projects. This is the SOIL libraryhomepage。

glm

Because the C/C++ standard library does not have a geometric math library, which causes in the development of a 3D system at the beginning often need to implement a practical geometric math library, which is too time-consuming and laborious.GLM's appearance can be a good solution to this problem.GLM is designed to comply with the style of the OpenGL Shading Language, the use of the open MIT license agreement. People who know GLSL can get started quickly. Because of the separation of data structure and function method, it is easy to expand the function method without changing the original file (adding new header file is enough, but it is hard to find function method in different header files).
download address
Note that this library doesn't need a link, it just needs to include the header files.

caveat

Pay attention to the order of linking, some packages can't be reversed. My order is

target_link_libraries(game glew32s  glfw3 gdi32 freetype soil opengl32)

game is the game program. Followed by the packages you need to use.

basic component

We need to use both parts frequently in the process of writing the game:shader and texture, i.e. shader and texture. We can encapsulate this into two classes.

shader

.h file

#ifndef GAME_SHADER_H
#define GAME_SHADER_H

#include <string>

#define GLEW_STATIC
#include <GL/>
#include <glm/>
#include <glm/gtc/type_ptr.hpp>

class Shader{
public:
    GLuint id;

    // Constructor
    Shader(){};

    //Use this program
    Shader &use();

    //Compile shader code, optional geometry shader
    void    Compile(const GLchar *vertexSource, const GLchar *fragmentSource, const GLchar *geometrySource = nullptr);

    // Setting parameters
    void    SetFloat    (const GLchar *name, GLfloat value, GLboolean useShader = false);
    void    SetInteger  (const GLchar *name, GLint value, GLboolean useShader = false);
    void    SetVector2f (const GLchar *name, GLfloat x, GLfloat y, GLboolean useShader = false);
    void    SetVector2f (const GLchar *name, const glm::vec2 &value, GLboolean useShader = false);
    void    SetVector3f (const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLboolean useShader = false);
    void    SetVector3f (const GLchar *name, const glm::vec3 &value, GLboolean useShader = false);
    void    SetVector4f (const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLboolean useShader = false);
    void    SetVector4f (const GLchar *name, const glm::vec4 &value, GLboolean useShader = false);
    void    SetMatrix4  (const GLchar *name, const glm::mat4 &matrix, GLboolean useShader = false);
private:
    // Check for compilation errors
void    checkCompileErrors(GLuint object, std::string type);
};
#endif //GAME_SHADER_H

.cpp file

#include ""

#include <iostream>

Shader &Shader::use()
{
    glewExperimental = GL_TRUE;
    glewInit();
    glUseProgram(this->id);
    return *this;
}

void Shader::Compile(const GLchar* vertexSource, const GLchar* fragmentSource, const GLchar* geometrySource)
{
    GLuint sVertex, sFragment, gShader;
    // Vertex Shader
    sVertex = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(sVertex, 1, &vertexSource, NULL);
    glCompileShader(sVertex);
    checkCompileErrors(sVertex, "VERTEX");
    // Fragment Shader
    sFragment = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(sFragment, 1, &fragmentSource, NULL);
    glCompileShader(sFragment);
    checkCompileErrors(sFragment, "FRAGMENT");
    // Geometry Shader (optional)
    if (geometrySource != nullptr)
    {
        gShader = glCreateShader(GL_GEOMETRY_SHADER);
        glShaderSource(gShader, 1, &geometrySource, NULL);
        glCompileShader(gShader);
        checkCompileErrors(gShader, "GEOMETRY");
    }
    // Shader Program
    this->id = glCreateProgram();
    glAttachShader(this->id, sVertex);
    glAttachShader(this->id, sFragment);
    if (geometrySource != nullptr)
        glAttachShader(this->id, gShader);
    glLinkProgram(this->id);
    checkCompileErrors(this->id, "PROGRAM");
    // Delete the shader when the link succeeds
    glDeleteShader(sVertex);
    glDeleteShader(sFragment);
    if (geometrySource != nullptr)
        glDeleteShader(gShader);
}

void Shader::SetFloat(const GLchar *name, GLfloat value, GLboolean useShader)
{
    if (useShader)
        this->use();
    glUniform1f(glGetUniformLocation(this->id, name), value);
}
void Shader::SetInteger(const GLchar *name, GLint value, GLboolean useShader)
{
    if (useShader)
        this->use();
    glUniform1i(glGetUniformLocation(this->id, name), value);
}
void Shader::SetVector2f(const GLchar *name, GLfloat x, GLfloat y, GLboolean useShader)
{
    if (useShader)
        this->use();
    glUniform2f(glGetUniformLocation(this->id, name), x, y);
}
void Shader::SetVector2f(const GLchar *name, const glm::vec2 &value, GLboolean useShader)
{
    if (useShader)
        this->use();
    glUniform2f(glGetUniformLocation(this->id, name), value.x, value.y);
}
void Shader::SetVector3f(const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLboolean useShader)
{
    if (useShader)
        this->use();
    glUniform3f(glGetUniformLocation(this->id, name), x, y, z);
}
void Shader::SetVector3f(const GLchar *name, const glm::vec3 &value, GLboolean useShader)
{
    if (useShader)
        this->use();
    glUniform3f(glGetUniformLocation(this->id, name), value.x, value.y, value.z);
}
void Shader::SetVector4f(const GLchar *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLboolean useShader)
{
    if (useShader)
        this->use();
    glUniform4f(glGetUniformLocation(this->id, name), x, y, z, w);
}
void Shader::SetVector4f(const GLchar *name, const glm::vec4 &value, GLboolean useShader)
{
    if (useShader)
        this->use();
    glUniform4f(glGetUniformLocation(this->id, name), value.x, value.y, value.z, value.w);
}
void Shader::SetMatrix4(const GLchar *name, const glm::mat4 &matrix, GLboolean useShader)
{
    if (useShader)
        this->use();
    glUniformMatrix4fv(glGetUniformLocation(this->id, name), 1, GL_FALSE, glm::value_ptr(matrix));
}


void Shader::checkCompileErrors(GLuint object, std::string type)
{
    GLint success;
    GLchar infoLog[1024];
    if (type != "PROGRAM")
    {
        glGetShaderiv(object, GL_COMPILE_STATUS, &success);
        if (!success)
        {
            glGetShaderInfoLog(object, 1024, NULL, infoLog);
            std::cout << "| ERROR::SHADER: Compile-time error: Type: " << type << "\n"
                      << infoLog << "\n -- --------------------------------------------------- -- "
                      << std::endl;
        }
    }
    else
    {
        glGetProgramiv(object, GL_LINK_STATUS, &success);
        if (!success)
        {
            glGetProgramInfoLog(object, 1024, NULL, infoLog);
            std::cout << "| ERROR::Shader: Link-time error: Type: " << type << "\n"
                      << infoLog << "\n -- --------------------------------------------------- -- "
                      << std::endl;
        }
    }
}

texture

.h file

#ifndef GAME_TEXTURE_H
#define GAME_TEXTURE_H
#include <GL/>


class Texture2D
{
public:
    GLuint id;
    // Texture image size
    GLuint width, height;
    // Texture format
    GLuint internalFormat; // Format of the texture object
    GLuint imageFormat; // Format for loading images
    // Texture settings
    GLuint wrapS;
    GLuint wrapT;
    GLuint filterMin;
    GLuint filterMax;

    Texture2D();
    // Generate texture
    void generate(GLuint width, GLuint height, unsigned char* data);
    // Bind textures
    void bind() const;
};
#endif //GAME_TEXTURE_H

.cpp file

#include <iostream>

#include ""


Texture2D::Texture2D()
        : width(0), height(0), internalFormat(GL_RGB), imageFormat(GL_RGB), wrapS(GL_REPEAT), wrapT(GL_REPEAT), filterMin(GL_LINEAR), filterMax(GL_LINEAR)
{
    glGenTextures(1, &this->id);
}

void Texture2D::generate(GLuint width, GLuint height, unsigned char* data)
{
    this->width = width;
    this->height = height;
    // Create textures
    glBindTexture(GL_TEXTURE_2D, this->id);
    glTexImage2D(GL_TEXTURE_2D, 0, this->internalFormat, width, height, 0, this->imageFormat, GL_UNSIGNED_BYTE, data);
    // Set the texture
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, this->wrapS);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, this->wrapT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, this->filterMin);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, this->filterMax);
    // Unbinding textures
    glBindTexture(GL_TEXTURE_2D, 0);
}

void Texture2D::bind() const
{
    glBindTexture(GL_TEXTURE_2D, this->id);
}

Resource loading

In the above two classes just texture and shader generation, we also need to load the appropriate resources from the file. For convenience, we can write a static resource loading class.
.h file

#include <map>
#include <string>

#define GLEW_STATIC
#include <GL/>

#include "utility/"
#include "utility/"


class ResourceManager
{
public:
    static std::map<std::string, Shader>    shaders;
    static std::map<std::string, Texture2D> textures;
    // Load the shader program
    static Shader   loadShader(const GLchar *vShaderFile, const GLchar *fShaderFile, const GLchar *gShaderFile, std::string name);
    // Get the specified shader
    static Shader   getShader(std::string name);
    // Load texture from file
    static Texture2D loadTexture(const GLchar *file, GLboolean alpha, std::string name);
    // Get the specified texture
    static Texture2D getTexture(std::string name);

    static void      clear();
private:

    ResourceManager() { }

    static Shader    loadShaderFromFile(const GLchar *vShaderFile, const GLchar *fShaderFile, const GLchar *gShaderFile = nullptr);

    static Texture2D loadTextureFromFile(const GLchar *file, GLboolean alpha);
};

#endif //GAME_RESOURCEMANAGER_H

.cpp file

#include ""

#include <iostream>
#include <sstream>
#include <fstream>

#include <SOIL/>

// Instantiate static variables
std::map<std::string, Texture2D>    ResourceManager::textures;
std::map<std::string, Shader>       ResourceManager::shaders;

//Load the shader
Shader ResourceManager::loadShader(const GLchar *vShaderFile, const GLchar *fShaderFile, const GLchar *gShaderFile, std::string name)
{
    shaders[name] = loadShaderFromFile(vShaderFile, fShaderFile, gShaderFile);
    return shaders[name];
}

// Get the specified shader
Shader ResourceManager::getShader(std::string name)
{
    return shaders[name];
}

//load texture
Texture2D ResourceManager::loadTexture(const GLchar *file, GLboolean alpha, std::string name)
{
    textures[name] = loadTextureFromFile(file, alpha);
    return textures[name];
}

//get the specified texture
Texture2D ResourceManager::getTexture(std::string name)
{
    return textures[name];
}

//Clean-up
void ResourceManager::clear()
{

    for (auto iter : shaders)
        glDeleteProgram();

    for (auto iter : textures)
        glDeleteTextures(1, &);
}

Shader ResourceManager::loadShaderFromFile(const GLchar *vShaderFile, const GLchar *fShaderFile, const GLchar *gShaderFile)
{
    std::string vertexCode;
    std::string fragmentCode;
    std::string geometryCode;
    try
    {
        // Open the file
        std::ifstream vertexShaderFile(vShaderFile);
        std::ifstream fragmentShaderFile(fShaderFile);
        std::stringstream vShaderStream, fShaderStream;
        //Read the file
        vShaderStream << ();
        fShaderStream << ();
        // Close the file
        ();
        ();

        vertexCode = ();
        fragmentCode = ();

        if (gShaderFile != nullptr)
        {
            std::ifstream geometryShaderFile(gShaderFile);
            std::stringstream gShaderStream;
            gShaderStream << ();
            ();
            geometryCode = ();
        }
    }
    catch (std::exception e)
    {
        std::cout << "ERROR::SHADER: Failed to read shader files" << std::endl;
    }
    const GLchar *vShaderCode = vertexCode.c_str();
    const GLchar *fShaderCode = fragmentCode.c_str();
    const GLchar *gShaderCode = geometryCode.c_str();
    // Generate shader objects
    Shader shader;
    (vShaderCode, fShaderCode, gShaderFile != nullptr ? gShaderCode : nullptr);
    return shader;
}

Texture2D ResourceManager::loadTextureFromFile(const GLchar *file, GLboolean alpha)
{
    // Generate texture objects
    Texture2D texture;
    if (alpha)
    {
         = GL_RGBA;
         = GL_RGBA;
    }
    // Load image
    int width, height;
    unsigned char* image = SOIL_load_image(file, &width, &height, 0,  == GL_RGBA ? SOIL_LOAD_RGBA : SOIL_LOAD_RGB);
    // Generate texture
    (width, height, image);
    // Release of data
    SOIL_free_image_data(image);
    return texture;
}

renderer (computing)

This is a simple renderer for rendering textures.


#ifndef SPRITE_RENDERER_H
#define SPRITE_RENDERER_H
#define GLEW_STATIC
#include <GL/>
#include <glm/>
#include <glm/gtc/matrix_transform.hpp>

#include "../utility/"
#include "../utility/"


class SpriteRenderer
{
public:

    SpriteRenderer(Shader &shader);

    ~SpriteRenderer();
    // Render the texture, note that the pos coordinates are the coordinates of the upper-left corner of the texture.
    void drawSprite(Texture2D texture, glm::vec2 position, glm::vec2 size = glm::vec2(10, 10), GLfloat rotate = 0.0f, glm::vec3 color = glm::vec3(1.0f));
private:

    Shader shader;
    GLuint quadVAO;
    // Initialization
    void initRenderData();
};
#endif //SPRITE_RENDERER_H

#include ""
#include "../"

SpriteRenderer::SpriteRenderer(Shader &shader)
{
    this->shader = shader;
    this->initRenderData();
}

SpriteRenderer::~SpriteRenderer()
{
    glDeleteVertexArrays(1, &this->quadVAO);
}

void SpriteRenderer::drawSprite(Texture2D texture, glm::vec2 position, glm::vec2 size, GLfloat rotate, glm::vec3 color)
{

    //();
    glm::mat4 model;
    //Translational transformations
    model = glm::translate(model, glm::vec3(position, 0.0f));
    //Rotational transformations
    model = glm::translate(model, glm::vec3(0.5f * , 0.5f * , 0.0f));
    model = glm::rotate(model, rotate, glm::vec3(0.0f, 0.0f, 1.0f));
    model = glm::translate(model, glm::vec3(-0.5f * , -0.5f * , 0.0f));
    // Zoom Transforms
    model = glm::scale(model, glm::vec3(size, 1.0f));

    this->shader.SetMatrix4("model", model);

    this->shader.SetVector3f("spriteColor", color);

    glActiveTexture(GL_TEXTURE0);
    ();

    glBindVertexArray(this->quadVAO);
    glDrawArrays(GL_TRIANGLES, 0, 6);
    glBindVertexArray(0);
}

void SpriteRenderer::initRenderData()
{
    // Setting the VAO/VBO
    GLuint VBO;
    GLfloat vertices[] = {
            // Pos      // Tex
            0.0f, 1.0f, 0.0f, 1.0f,
            1.0f, 0.0f, 1.0f, 0.0f,
            0.0f, 0.0f, 0.0f, 0.0f,

            0.0f, 1.0f, 0.0f, 1.0f,
            1.0f, 1.0f, 1.0f, 1.0f,
            1.0f, 0.0f, 1.0f, 0.0f
    };

    glGenVertexArrays(1, &this->quadVAO);
    glGenBuffers(1, &VBO);

    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    glBindVertexArray(this->quadVAO);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), (GLvoid*)0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);
}

And the shader it needs
vertex shader

#version 330 core
layout (location = 0) in vec4 vertex; // <vec2 position, vec2 texCoords>

out vec2 TexCoords;

uniform mat4 model;
uniform mat4 projection;

void main()
{
    TexCoords = ;
    gl_Position = projection * model * vec4(, 0.0, 1.0);
}

fragment shader

#version 330 core
in vec2 TexCoords;
out vec4 color;

uniform sampler2D image;
uniform vec3 spriteColor;

void main()
{
    color = vec4(spriteColor, 1.0) * texture(image, TexCoords);
}

Main game category

in this class to load resources and perform rendering.

Textures can be found at the beginning of the articlegithub Found in the link.

#ifndef GAME_GAME_H
#define GAME_GAME_H

#define GLEW_STATIC
#include <GL/>
#include <GLFW/>

#include ""
#include "component/"



enum gameState {
    GAME_ACTIVE,
    GAME_MENU,
    GAME_WIN
};

class Game
{
public:

    // Game state
    gameState              state;
    GLuint                 level;
    GLboolean              keys[1024];
    GLuint                 width, height;
    // Constructor/Destructor
    Game(GLuint width, GLuint height);
    ~Game();
    // Initialization - loading textures, shaders, etc.
    void init();
    //Control class operation
    void processInput(GLfloat dt);
    //Update data
    void update(GLfloat dt);
    // Rendering
    void render();
private:
    //void DoCollisions();

};

#endif //GAME_GAME_H

#include ""
#include <tuple>

SpriteRenderer *renderer;


Game::Game(GLuint width, GLuint height)
        : state(GAME_ACTIVE), keys(), width(width), height(height) {}

Game::~Game() {
    delete renderer;
}

void Game::init() {
    //load shaders
    ResourceManager::loadShader("../shaders/", "../shaders/", nullptr, "sprite");
    // Projection matrix
    glm::mat4 projection = glm::ortho(0.0f, static_cast<GLfloat>(this->width), static_cast<GLfloat>(this->height), 0.0f,
                                      -1.0f, 1.0f);
    ResourceManager::getShader("sprite").use().SetInteger("image", 0);
    ResourceManager::getShader("sprite").SetMatrix4("projection", projection);

    // Load a texture
    ResourceManager::loadTexture("textures/", GL_TRUE, "car");

    Shader spriteShader = ResourceManager::getShader("sprite");
    renderer = new SpriteRenderer(spriteShader);
}

void Game::processInput(GLfloat dt) {
}

void Game::update(GLfloat dt) {

}

void Game::render() {
    // Render textures
    if (this->state == GAME_ACTIVE) {
        renderer->drawSprite(ResourceManager::getTexture("car"), glm::vec2(0, 0),
                             glm::vec2(this->width, this->height/3*2));
    }
}

game window

Here you can refer to the previouswritings

#define GLEW_STATIC

#include <GL/>
#include <GLFW/>
#include ""
#include ""

// Keystroke callback function
void key_callback(GLFWwindow* wwindow, int key,int scancode, int action, int mode);

// Screen width
const GLuint SCREEN_WIDTH = 800;
//Screen Height
const GLuint SCREEN_HEIGHT = 600;

Game game(SCREEN_WIDTH, SCREEN_HEIGHT);

int main() {
    //Initialize glfw
    glfwInit();
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
    GLFWwindow* window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "game", nullptr, nullptr);
    glfwMakeContextCurrent(window);
    glfwSetKeyCallback(window, key_callback);

    //Initialize glew
    glewExperimental = GL_TRUE;
    glewInit();
    glGetError();

    //opengl setup
    glViewport(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT);
    glEnable(GL_CULL_FACE);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

    ();

    GLfloat deltaTime = 0.0f;
    GLfloat lastFrame = 0.0f;

     = GAME_ACTIVE;

    // Game Loop
    while(!glfwWindowShouldClose(window))
    {
        GLfloat currentFrame = glfwGetTime();
        deltaTime = currentFrame - lastFrame;
        lastFrame = currentFrame;

        glfwPollEvents();

        (deltaTime);
        (deltaTime);

        //Set the screen color
        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);
        ();
        glfwSwapBuffers(window);
    }
    ResourceManager::clear();
    glfwTerminate();
    return 0;
}

void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
        glfwSetWindowShouldClose(window, GL_TRUE);
    if (key >= 0 && key < 1024)
    {
        if (action == GLFW_PRESS)
            [key] = GL_TRUE;
        else if (action == GLFW_RELEASE)
            [key] = GL_FALSE;
    }
}

running result
渲染结果

Preparation is more or less complete, and the next section will actually start writing the game.