Vantor Engine™

Low-Level Experimental In-House Game Engine for Vantor Studios™

v0.20.X - Experimental Build

Explore the docs »

Get Started · Report Bug · Request Feature · Vantor Studios™

Table of Contents

1. About The Project
   • Vantor Studios™
   • Built With
   • Experimental Status
2. Getting Started
   • Prerequisites
   • Installation
3. Usage
4. Development Tools
5. Roadmap
6. Contributing
7. License
8. Contact
9. Acknowledgments

About The Project

Vantor Engine™ is a low-level, experimental game engine developed in-house by Vantor Studios™ for creating high-performance games. Designed from the ground up with a focus on minimal abstraction and maximum control, Vantor provides game developers with direct access to rendering pipelines, memory management, and system resources.

The engine prioritizes performance, modularity, and flexibility over ease of use, making it ideal for developers who need fine-grained control over every aspect of their game's execution. Built with modern C++20 and OpenGL, Vantor serves as the foundation for VantorStudios' game development projects.

Key Philosophy

• Low-Level Control: Direct manipulation of rendering, physics, and resource systems
• Performance First: Optimized for real-time applications and resource-constrained environments
• Modular Architecture: Use only what you need, extend what you want
• Experimental Nature: Cutting-edge features and techniques in active development

"A delayed game is eventually good, a rushed game is bad forever." – Shigeru Miyamoto

Vantor Studios™

VantorStudios is an independent, hobby-driven game development studio focused on creating unqiue gaming experiences. The Vantor Engine serves as our proprietary technology stack, powering our internal game development projects and providing the technical foundation for our creative vision.

Experimental Status

⚠️ Important Notice: Vantor Engine is currently in experimental development status. This means:

• Rapid Changes: APIs and architecture may change frequently
• Limited Documentation: Focus is on development rather than user documentation
• Internal Use Priority: Designed primarily for VantorStudios' development needs
• Community Contributions: Welcome but may be adapted to fit internal roadmap
• No Stability Guarantees: Breaking changes can occur between versions

The engine is made available for educational purposes and community collaboration, but production use is not recommended until a stable release is announced.

(back to top)

Built With

The Vantor Engine is built using modern technologies and industry-standard tools:

Core Technologies:

• C++20: Modern C++ with latest language features
• OpenGL 4.6: Primary rendering API with Vulkan support planned
• Custom GLSL Shaders: Hand-optimized graphics shaders
• Python: Development tools and build automation (VTRG)
• CMake: Cross-platform build system

Third-Party Libraries:

• Dear ImGui: Immediate mode GUI for debugging and tools
• GLFW: Window management and input handling
• STB Headers: image loading and writing
• tinygltf.h: glTF 2.0 object loading and animations
• tinyobjloader: .obj and mtl object loading

(back to top)

Getting Started

⚠️ Warning: This engine is experimental and intended primarily for VantorStudios development. APIs may change without notice.

To get started with Vantor Engine development, follow these steps. Note that the engine is designed for experienced C++ developers familiar with low-level graphics programming.

Prerequisites

Before building Vantor, ensure you have the following installed:

Required:

• CMake (3.10 or higher)
• Make or Ninja build system
• C++20 capable compiler:
  • MSVC 2019+ (Windows)
  • GCC 10+ (Linux)
  • Clang 12+ (Cross-platform)
• Git for version control
• Python 3.7+ for development tools (VTRG)

Optional but Recommended:

• clang-format for code formatting
• Visual Studio Code or similar IDE with C++ support

Building

Windows (Recommended Platform)

Step 0: Setup Environment

Install MSYS2 from their website and Python from python.org.

Step 1: Clone Repository

git clone https://github.com/LukasRennhofer/VantorEngine.git
cd Vantor

Step 2: Install Dependencies

pacman -S cmake mingw-w64-x86_64-toolchain mingw-w64-x86_64-freeglut mingw-w64-x86_64-assimp mingw-w64-x86_64-sdl2

Step 3: Build Engine

# Using the new VTRG development tool
python vtrg.py build --platform Windows --debug

# Or using legacy DevConsole (deprecated)glTF 2.0 object loading and animations
python DevConsole.py --platform Windows --build-lib

Linux (Experimental Support)

⚠️ Status: Linux support is experimental and may have build issues. Tested on Ubuntu 24.10.

Step 0: Install Python

sudo apt-get install python3

Step 1: Clone Repository

git clone https://github.com/LukasRennhofer/VantorEngine.git
cd Vantor

Step 2: Install Dependencies

sudo apt-get install build-essential libsdl2-dev libsdl2-2.0-0 libassimp-dev cmake libglm-dev libglew-dev

Step 3: Build Engine

# Using VTRG (recommended)
python3 vtrg.py build --platform Linux --debug

# Or using legacy DevConsole
python3 DevConsole.py --platform Linux --build-lib

(back to top)

Usage

Vantor Engine™ is designed for experienced developers who need low-level control over game systems. Here are some ways to use the engine:

Basic Integration

#include <Vantor/Vantor.hpp>

#include <iostream>

// Create RHI device
auto device = Vantor::RHI::VRDCoordinator::Instance().CreateDevice(Vantor::RHI::EGraphicsAPI::OPENGL);

// Vertex structure with position + color
struct Vertex {
    Vantor::Math::VVector3 position;
    Vantor::Math::VVector3 color;
};

void ResizeCallback(int w, int h) {
        device->SetViewport(0, 0, w, h);
}

int main() {

    // Create the window
    Vantor::Context::VWindow* window = new Vantor::Context::VWindow(1920, 1080, "Legendary Triangle");
    

    if (!device->Initialize()) {
        std::cerr << "Failed to initialize RHI device" << std::endl;
        return 1;
    }

    window->setResizeCallback(ResizeCallback);


    // Define a colorful triangle
    Vantor::Core::Container::TVector<Vertex> vertices = {
        {{-0.5f, -0.5f, 0.0f}, {1.0f, 0.0f, 0.0f}}, // Red
        {{ 0.5f, -0.5f, 0.0f}, {0.0f, 1.0f, 0.0f}}, // Green
        {{ 0.0f,  0.5f, 0.0f}, {0.0f, 0.0f, 1.0f}}  // Blue
    };
    Vantor::Core::Container::TVector<uint32_t> indices = {0, 1, 2};

    // Vertex layout: position + color
    Vantor::RHI::VVertexLayout layout;
    layout.stride = sizeof(Vertex);
    layout.attributes = {
        {0, Vantor::RHI::ERHIFormat::R32G32B32_FLOAT, offsetof(Vertex, position)},
        {1, Vantor::RHI::ERHIFormat::R32G32B32_FLOAT, offsetof(Vertex, color)}
    };

    auto mesh = device->CreateMesh(
        vertices.data(),
        vertices.size() * sizeof(Vertex),
        indices.data(),
        indices.size(),
        layout
    );
    // ... See Template Sample

Sample Projects

The engine includes several sample projects in the Samples/ directory:

• Sandbox: Basic engine showcase and testing environment
• LightDemo: Demonstration of lighting systems
• Template: Starting point for new projects

Running Samples

# Build and run a sample using VTRG
python vtrg.py build --sample Sandbox --platform Windows --run

# Format code before contributing
python vtrg.py format

# Clean build artifacts
python vtrg.py clean --all

For more detailed examples and API documentation, please refer to the Documentation

Development Tools

VTRG (Vantor Trigger)

VTRG is the enhanced command-line development tool for Vantor Engine:

# Build commands
python vtrg.py build --help
python vtrg.py build --sample MyProject --debug --run

# Code formatting
python vtrg.py format --check
python vtrg.py format --path ./Source

# Cleanup
python vtrg.py clean --build
python vtrg.py clean --all --dry-run

# Get help
python vtrg.py --help
python vtrg.py build --help

Features:

• Multi-platform building with platform-specific optimizations
• Dependency checking and validation
• Build artifact management and cleanup

(back to top)

Roadmap

Current Focus (v0.16.x)

• [🟩] Platform Abstraction Layer - Windows/Linux/Switch support
• [�] Core Rendering Pipeline - OpenGL 4.6 implementation
• [🟧] Memory Management - Custom allocators and resource pooling
• [🟩] Scene Graph - Efficient spatial organization

Near-term Goals (v0.17.x - v0.20.x)

• [🟧] Multi-threaded Resource Management - Async loading and streaming
• [🟧] GPU-based Scene Graph - GPU-driven rendering pipeline
• [🟩] Editor Interface - Basic level editor and debugging tools
• [🟥] Audio System - 3D spatial audio implementation

Long-term Vision (v1.0+)

• [🟥] Full Vulkan Support - Modern low-level graphics API
• [🟥] Advanced Physics - Custom physics simulation
• [🟥] Networking Layer - Multiplayer game support
• [🟩] Documentation Expansion - Comprehensive API documentation

Legend:

• 🟩 Complete
• 🟧 In Progress
• 🟥 Planned

Note: Roadmap priorities may change based on VantorStudios' internal development needs.

See the open issues for detailed feature requests and known issues.

(back to top)

License

Distributed under the GNU General Public License, v3. See LICENSE for more information.

(back to top)

Contact

Vantor Studios™

• Lukas Rennhofer
• Moritz Rottensteiner

Lead Developer: Lukas Rennhofer
📧 Email: [email protected]

Project Repository: https://github.com/LukasRennhofer/VantorEngine

For technical questions, bug reports, or feature requests, please use the GitHub Issues system.

(back to top)

Acknowledgments

Vantor Studios™ would like to thank:

• Open Source Community - For the foundational libraries and tools that make Vantor possible
• Technical Inspirations:
  • WickedEngine - Modern C++ game engine architecture
  • Godot Engine - Open source game engine design patterns
  • Unreal Engine - Industry-standard rendering techniques
• Library Contributors:
  • Dear ImGui - Immediate mode GUI framework
  • SDL2 - Cross-platform development library
  • Assimp - 3D model loading library
  • GLFW - Window and input management
• Development Tools:
  • CMake - Cross-platform build system
  • clang-format - Code formatting
  • GitHub - Version control and collaboration

Special Recognition:

• All contributors who help improve the engine
• The game development community for sharing knowledge and best practices
• Beta testers and early adopters who provide valuable feedback

---

Vantor Engine™ - Experimental Low-Level Game Engine
Developed by Vantor Studios™ (Lukas Rennhofer, Moritz Rottensteiner)

(back to top)