RendererGL

RendererGL is a basic 3D renderer written in C++ and OpenGL that allows working with 3D graphics without the need to know computer graphics or OpenGL. So that both beginners and more experienced programmers can create a 3D scene with lighting, shadows and materials.

Warning This project is still under development

Take a look at some screenshots. 3D assets are not included

Features

Trackball and first person shooter camera
Anti aliasing (MSAA)
Textures
Load 3D models and textures from files
Skybox (cubemap)
FrameCapturer: create a texture of the scene
Blinn-Phong lighting: Ambient, Diffuse, Specular, Emission
Physically Based Rendering (PBR): Albedo, Metallic, Normal, Roughness, Ambient Occlusion, Emission
Shadow Mapping: percentage closer filtering
Normal Mapping
Gamma correction
HDR
Mouse ray casting: object selection

Scene Graph

A scene graph is a general data structure which arranges the logical and often spatial representation of a graphical scene. It is a collection of nodes in a graph or tree structure:

Polytope: A set of vertices and indices (optional) that defines a shape
Group: A set of polytopes. It also defines the primitive (triangles, quads...) which the polytopes inside of it will be drawn.
Model: A group which contains a set of polytopes that are loaded from a file (.obj, .dae, ...)
Scene: Contains a set of groups, models and other scenes
Renderer: Contains a set of scenes. It's the one who deals with all the graphics stuff

Take a look at the example below

Example: rotating cube with lighting

#include <iostream>
#include <vector>

#include <engine/renderer/Renderer.h>
#include <engine/renderer/TrackballCamera.h>
#include <engine/shapes/Cube.h>

#include <GLFW/glfw3.h>

const int WIDTH = 1280;
const int HEIGHT = 900;
GLFWwindow* window;

Renderer::Ptr renderer;

int main() {

    // Create window
    if (!glfwInit()) {
        std::cout << "Couldn't initialize window" << std::endl;
        return -1;
    }

    window = glfwCreateWindow(WIDTH, HEIGHT, "Cube example", NULL, NULL);
    
    if (!window) glfwTerminate();

    glfwMakeContextCurrent(window);

    // Renderer
    renderer = Renderer::New(WIDTH, HEIGHT);
    renderer->enableLight();

    // Camera
    double aspectRatio = static_cast<double>(WIDTH) / HEIGHT;
    TrackballCamera::Ptr camera = TrackballCamera::perspectiveCamera(glm::radians(45.0f), aspectRatio, 0.1, 1000);
    camera->zoom(-2.5);
    renderer->setCamera(std::dynamic_pointer_cast<Camera>(camera));

    // Light
    DirectionalLight light(glm::vec3(1));
    light.setColor(glm::vec3(1));
    renderer->addLight(light);

    // Scene
    Cube::Ptr cube = Cube::New();

    Group::Ptr group = Group::New();
    group->add(cube);

    Scene::Ptr scene = Scene::New();
    scene->addGroup(group);

    renderer->addScene(scene);

    // Main loop
    while (!glfwWindowShouldClose(window)) {

        // Update scene
        cube->rotate(0.55, glm::vec3(1, 0, 1));

        // Draw scene
        renderer->clear();
        renderer->render();
        
        // Update window
        glfwSwapBuffers(window);
        glfwPollEvents();
    }

    // Destroy window
    glfwTerminate();

    return 0;
}

Custom mesh

std::vector<Vec3f> vertices { ... };
std::vector<unsigned int> indices { ... };

Polytope::Ptr mesh = Polytope::New(vertices, indices);

Group::Ptr group = Group::New();
group->add(mesh);