LAGGED

Personal project for creating a general-purpose engine

Now available!

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

Quick overview

Project Type: Personal Project, Custom Game Engine

Platform: Windows

Tools: C++

Role in Team: Lead Programmer

Project Duration: Since August 2023

Release Date: Ongoing

Team size: 1

Role in Team: Engine programmer and Lead

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:

Custom ECS implementation using archetypes: This project uses an entity-component-system (ECS) powered by a custom implementation with an archetype architecture, storing component data in a cache-friendly manner. A user-friendly API allows users to create entities, add or remove components, and run systems over all entities containing a specific set of components.

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

Custom (work-in-progress) reflection system for reflecting ECS components: A reflection system has been implemented for ECS components, allowing components and their variables to be reflected and iterated over with just a few function calls. This system is already integrated into editor tools, such as the entity editor, enabling users to adjust component values on entities at runtime. 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: The entity editor iterates over all components and their variables for the selected entity and displays widgets (such as sliders and text fields) based on the datatype of each reflected variable. Users can interact with these widgets to modify the variable values in real time.

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.