AeonEngine (Archive)

This repository is an archive. It contains a very old, no-longer-developed version of the AeonEngine — a hobbyist 3D game engine I worked on, on and off, while teaching myself how to build engines from the ground up. It is published here purely as a historical snapshot of that learning journey.

The code is not production quality, is not maintained, and will not receive bug fixes, feature work, or pull request reviews. Many design choices reflect what was idiomatic (or simply what I knew) at the time rather than what I would write today. There are dead ends, half-finished experiments, and entire subsystems that were superseded several times over the project's life.

If you found this repo and it is useful as reference, inspiration, or a cautionary tale — wonderful. Otherwise, please look at it as one would a sketch book: a record of the process, not a finished product.

Looking for the active project? Most of the genuinely useful code from this archive has been carried forward, rewritten, and is being actively developed in the current AeonEngine repository on GitHub, which is released under the Apache License 2.0. If you want a working, maintained engine, go there. This repository is kept around purely for historical interest.

---

History

• Origins: ~2003, started as a personal project to learn 3D graphics, math, and engine architecture.
• Version control: lived in a private Subversion repository for most of its life (initial git-svn import dates to April 2009); later migrated to git.
• Status: development on this codebase wound down years ago. Newer work evolved into separate, unrelated projects.

Why it was retired

The main reason for abandoning this codebase and starting a new engine from scratch was its deep coupling to OpenGL. The renderer, resource system, materials, programs, and even parts of the scene graph all assumed an OpenGL-style API. By the time Vulkan was released — and with Direct3D firmly established as the go-to API for shipping games on Windows and consoles — OpenGL was clearly losing relevance for serious cross-platform work. Cross-API support was always a long-term goal of the project, and retrofitting it into this design would have meant rewriting most of the engine anyway. Better to start fresh with a rendering abstraction that could host multiple backends (Vulkan, Direct3D, OpenGL) from day one — which is what the active AeonEngine does.

What's in here

This repository is a multi-component workspace — the engine itself plus the tooling and assets that grew up around it.

engine/      Core C++ engine (rendering, scene, resources, input, math, ...)
editor/      Qt-based scene/material/program/code editor
demo/        Small playable demo using the engine
game/        Example game assets (models, materials, scenes, shaders, ...)
common/      Shared headers, icons, utilities
tools/       Asset pipeline and helper utilities (see below)
android/     Android port (native + JNI + Java glue)
jogl/        JOGL/Java front-end experiment
jni/         JNI bindings
thesis/      Thesis-related experiment harness
documents/   Specification documents (ODT)
cmake/       CMake helper modules and third-party fetchers

Engine features (snapshot of what got built)

Not all of these are equally finished. This is "what's there", not "what shipped".

Rendering

• OpenGL 3.x / OpenGL ES 2.0 renderer
• Programs, shaders (vertex/fragment), uniforms, vertex buffers/arrays
• Textures with PNG loading; KTX coder module for ImageMagick
• Materials and a binary material format (.matl / .mtl)
• Meshes (.msh), models (.mdl), scenes (.scn), tiles (.tle)
• Skeletons (.skl) and skeletal animations (.anm)
• Skybox, frustum culling, camera + director camera
• Custom binary asset formats with Protocol Buffers definitions (MaterialBuffer.proto, ProgramBuffer.proto)

Scene & gameplay

• Scene graph (Node, BoxNode, CapsuleNode, GeometryNode, SphereNode, PointNode, NullNode)
• Entities and environments
• Movables, instances (model/scene/tile), velocity
• Finite state machine and a character state machine demo
• Resource manager with reference table
• Input abstraction (keyboard, mouse, "human interface device" interface) and an input-mapping layer
• Optional V8 JavaScript scripting integration
• Optional OpenAL audio integration
• Optional Telnet console server for in-engine command access
• CLI parser using flex/bison (engine/lexers, engine/parsers)

Math

• Custom Vector3, Vector4, Matrix4x4, Transform types
• Frustum, geometry helpers (BSP/portal-style operations in tooling)

Editor (Qt)

• Main window with OpenGL viewport widget
• Scene editor, material editor, program editor, code editor
• Console window, settings dialog, theming
• Property system with custom item delegates

Platforms / build

• CMake-based build (CMake ≥ 2.8.12)
• MinGW cross-compile toolchain files for Windows targets from Linux
• Android port with NDK JNI layer and Java activity glue
• Optional Java/JOGL front-end
• Cross-platform (Linux, Windows, Android) at various points in time

Optional integrations (gated by CMake options)

• USE_AEONGUI – Glitch GUI library
• USE_ZLIB, USE_PNG – compression and image loading
• USE_OPENAL – audio
• USE_V8 – JavaScript scripting
• USE_GTEST – unit tests
• USE_OPENGEX – OpenGEX scene format
• USE_ASSIMP – Open Asset Import Library

Tools

The tools/ directory holds the asset pipeline and miscellaneous utilities that grew alongside the engine:

• map2bsp — Quake-style .map → custom BSP level compiler with optional POV-Ray-based light-map baking.
• blender/ — Blender exporters and importers for the engine's mesh, skeleton, animation, tile, and "gty" formats (Blender 2.4x and 2.6x+).
• max/ — old 3ds Max mesh exporter.
• daz/ — DAZ Studio exporters.
• converter/ — asset converter.
• packager/ — asset packaging tool.
• xsltproc/ — custom XSLT processor with engine-specific extensions.
• ktxcoder/ — ImageMagick coder module for the KTX texture format.
• bin2hex/, axe/, scripts/ — assorted helpers.

Demo & sample assets

demo/ contains a small playable program built on the engine, including a character driven by a CharacterStateMachine. game/ contains the accompanying assets (meshes, materials, programs, scenes, tiles, shaders, textures, skeletons, animations, scripts).

Building

The project builds with CMake. Many features are optional, gated by option() flags listed in the top-level CMakeLists.txt. A typical configure looks like:

mkdir build && cd build
cmake -DUSE_PNG=ON -DUSE_OPENAL=ON -DBUILD_EDITOR=ON ..
cmake --build .

Caveat emptor: these build instructions are aspirational for an archived project. Several dependencies have moved on (Qt versions, V8 API, Protobuf versions, Bison/Flex behaviour, Android NDK layouts, OpenGL driver quirks) since this code was last actively built. Expect breakage. The repository is preserved as-is; getting it to build on a modern system is left as an exercise for the curious.

License & attribution

All source authored by Rodrigo Hernandez (@kwizatz) unless otherwise noted in individual file headers. Third-party headers (e.g. OpenGL glext.h) retain their original licenses.

This archive is released under an all-rights-reserved, personal-study-only license — see LICENSE for the full terms. In short: you may read, clone, and study the code, but redistribution, derivative works, and use in other projects (commercial or otherwise) require prior written permission. Open an issue if you'd like to use any part of it under different terms — I'm happy to discuss it case by case.

If you want a permissively-licensed, actively-maintained version of the AeonEngine, use the current AeonEngine repository instead — it is released under the Apache License 2.0.

Why publish it at all?

Because deleting old work erases the trail. Even messy, abandoned projects contain decisions, mistakes, and small clever tricks worth preserving — for me to look back on, and on the off chance someone else finds value in any fragment of it.