LAGGED

Personal project for creating a general-purpose engine

About this project

LAGGED (which stands for 'Learning About Graphics and Game Engine Development') is my custom game engine project aimed at exploring various aspects of graphics and engine development. In this project, I’ve been researching and implementing procedural terrain generation, reflection using EnTT Meta and GLTF model support. The renderer uses OpenGL. Although I'm trying to write a general-purpose engine, my goal is to implement a procedural city generator that players can explore.
This project is currently in development.

My contributions to the project

Since this is a personal project, everything has been done by me. A brief list of systems that have been implemented will be listed below:

ECS using EnTT: The project uses an entity-component-system, powered by the EnTT library. A nice wrapper has been created around the EnTT API in order to simplify the use of the ECS. This also means that the user doesn't have to interact with EnTT code.

Several components have already been implemented, like a camera component, light component, terrain component, transform component, etc.

Entity Editor using EnTT Meta reflection system: In order to easily adjust values of entities during runtime, an entity editor tool has been implemented. Using the EnTT Meta reflection system, variables can easily be registered to appear in the editor. These variables are then displayed in the editor window. The entity editor consists of two parts:

The first part is the entity list, which contains all of the entities in the level . Users can select a specific entity from the list to inspect its components further. Upon selecting an entity, all of the components belonging to the entity are shown to the user.

The second part contains information about all components: Using EnTT Meta, variables from the components are reflected, allowing the entity editor tool to load various editor widgets, like sliders and text fields. These widgets can be used by the user to change the variables to their liking.

In the future, additional functionality will be implemented to enable users to add new components to entities, thus providing them with greater customization options.

Terrain generation using Perlin noise: Terrain can be generated using Perlin noise. By changing parameters like the amplitude and frequency of the Perlin noise, the look of the terrain can be adjusted.

Generates around the player: The terrain generation centers around the player, ensuring that new parts of the terrain dynamically generate around the camera, thereby creating the illusion of an infinite world. These chunks are only loaded/unloaded when the camera is a certain distance away from a chunk. This loading/unloading distance can be adjusted in the editor.

Terrain can be customized in the editor: Terrain properties are stored in the Terrain Component, making it editable within the entity editor. The editor reflection system reflects the properties for the terrain component, which allow the user to change the terrain subdivision, noise amplitude and frequency, as well as the generation seed.

Renderer using OpenGL: The renderer uses OpenGL3 and supports the following features:

glTF model support: The renderer is capable of loading and processing static glTF files (.gltf and .glb). Upon loading a glTF file, all associated models and textures are automatically loaded as well. For the implementation of glTF model support, TinyGLTF library was used.

Lighting: Basic lighting has been implemented. Diffuse lighting is used to simulate the directional impact a light has on an object. Light attenuation has also been implemented, meaning that the further an object is from a light, the less lit it will be. Multiple lighting sources can be used to light an object. In the future, Phong shading will be implemented.

Terrain rendering using height maps: Height map / noise map textures are used for generating the vertices and indices required for rendering terrain.

Post processing: Objects in the scene are rendered to a frame buffer, which allows me to apply post-processing effects to the render. Post-processing effects that are currently implemented are grayscale and color inversion. These effects can be changed in the post-processing options window.

ImGui support: ImGui has been implemented to create a variety of tools.

Filewatch for real-time shader development: I've implemented a filewatch system that checks all shader files and reloads them automatically if any changes are made. This functionality allows for quick shader development without needing to restart the engine.

More details about these contributions can be found below.

A screenshot of some of the editor tools that are currently available

This project is still in-development so more features will be added in the future. Some planned features include implementing a multithreading system (which will be used for loading resources and generating terrain on a separate thread) and a serialization/deserialization system for levels.

Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.

Quick overview

Project Type: Custom Game Engine

Platform: Windows

Tools: C++

Role in Team: Engine & Graphics programmer

Project Duration: 16 weeks

Release Date: 2024

Team size: 1

Role in Team: Engine programmer and Lead

Now available!

The LAGGED repository is public on GitHub and can be accessed by anyone.
LAGGED on GitHub