Sedulous Engine

A modular game engine written in Beeflang with a cross-platform RHI (Vulkan + DX12), forward PBR renderer, entity-component scene system, asset pipeline, and an Android-inspired retained-mode UI framework.

Note: Sedulous is under active development. APIs are subject to change. Previous iterations of the engine have been used to create a few games. This version is a significant evolution and a full game built on it is in progress.

Architecture

Sedulous is built in layers. Each layer depends only on the layers below it.

Applications    -- Game, Editor, Sandboxes
Engine Layer    -- Engine.Core (Scene, Entities, Components, Transforms, Serialization)
                   Subsystems: Scene, Input, Physics, Animation, Audio, Navigation, Render, UI
Renderer Layer  -- RenderContext, Pipeline, PostProcessing, Shadows, Particles
Foundation      -- RHI, Shell, VG, Fonts, UI, Resources, Jobs, Shaders, Math

Foundation libraries are self-contained and can be used independently in tools, sandboxes, and tests without the engine.

Renderer is scene-independent -- it receives flat render data and draws it. Scene integration lives in the engine layer.

Engine provides Engine.Core (scene model, transforms, serialization) and subsystems (physics, audio, rendering, etc.) managed by a Context that handles lifecycle and update ordering. Subsystems that need resources receive them as explicit constructor parameters.

Applications own presentation (swapchain, frame pacing, blit) and decide what to render and where.

Key Features

Rendering

• Forward PBR with Cook-Torrance BRDF (directional, point, spot lights)
• Depth prepass with masked geometry support
• Mini G-buffer (normals + motion vectors) for future post-FX
• Compute skinning (72->48 byte vertex transform)
• Hierarchical shadow atlas (cascaded directional, point cubemap, spot)
• GPU-instanced sprites (3 orientation modes)
• Depth-reconstructed projected decals
• CPU particle system with billboard/trail rendering, sub-emitters, LOD
• Post-processing: SSAO, bloom, TAA, FXAA, ACES tone mapping
• Debug draw (wire shapes, screen text, light gizmos)
• Per-scene Pipeline -- multiple scenes render independently

RHI (Rendering Hardware Interface)

• WebGPU-inspired, lower-level API
• Vulkan and DX12 backends
• Validation wrapper for debugging
• Command encoder pattern (ICommandEncoder -> IRenderPassEncoder -> ICommandBuffer)
• Dependency-driven render graph with transient texture pool

Scene System

• Entity-component with lightweight handles (index + generation)
• ComponentManager pooling with deferred initialization
• Hierarchical transforms with dirty-flag propagation
• 8 update phases including parallel AsyncUpdate
• Scene serialization via ISerializableComponent

Physics

• Jolt Physics integration (multi-threaded)
• RigidBodyComponent with full config (shapes, mass, friction)
• Contact events (added, persisted, removed)
• Raycasting with entity handle decoding

Animation

• Skeletal animation (clip playback, animation graphs)
• Property animation with binder registry
• SkinnedMeshComponent decoupled from animation

Audio

• SDL3 audio backend with graph-based mixing
• Bus hierarchy (Master/SFX/Music/custom) with per-bus volume and mute
• DSP effects chain: reverb, delay, EQ, compressor, low/high-pass filters
• 3D spatialization with configurable attenuation curves, cone emission, doppler
• Sound cues with clip variation, pitch/volume randomization
• Music streaming, one-shot API, AudioSourceComponent

Navigation

• Recast/Detour integration
• NavMesh building, crowd management, obstacle avoidance
• NavAgent and NavObstacle components

UI Framework (Sedulous.UI)

• Android-inspired retained-mode: View/ViewGroup/RootView hierarchy
• FlexLayout, DockLayout, GridLayout, FlowLayout, AbsoluteLayout
• BoxConstraints / SizeSpec layout system
• StyleSheet with type/class/state selectors, theme registry (Dark, Light, Rounded)
• Input routing, focus management, drag-drop, shortcuts
• Popups, dialogs, context menus, tooltips
• Screen-space and world-space UI rendering
• Runs headless for tests -- no engine dependency

UI Toolkit (Sedulous.UI.Toolkit)

• DockManager with tabs at top, per-tab close buttons, dockable OS windows
• SplitView, MenuBar, StatusBar, Toolbar, BreadcrumbBar
• PropertyGrid with type-specific editors (float, bool, string, vector3, enum, color)
• TreeView, ColorPicker, TabView (closable)
• DraggableTreeView, IDockableWindowHost
• Layout persistence (ExportLayout/ApplyLayout with PersistenceId)

Editor (Sedulous.Editor)

• Plugin-based architecture ([EditorPlugin] auto-discovery)
• Project management (.sedproj) with recent projects
• Scene editor with hierarchy (drag reorder/reparent, inline rename), 3D viewport, inspector
• Independent editor camera (orbit/fly/pan/zoom) with CameraOverride
• Transform gizmos (translate/rotate/scale) with local/world orientation
• GPU entity picking (PickPass with async readback, proxy sphere fallback for non-mesh entities)
• Asset browser with registry tree, list/grid content view, breadcrumb navigation
• Registry management (mount/create/unmount, .sedproj persistence)
• Asset import pipeline (model + texture importers, import preview dialog)
• Context menus (create assets, delete, copy path/GUID, show in explorer)
• Comptime-generated component inspectors via [Property] attributes
• Per-page undo/redo command stack with drag merge
• LogView with thread-safe log capture
• Multi-window docking with cross-window drag
• ViewportView with render-to-texture via external texture cache

Samples

EngineSandbox is the primary testbed for engine features -- PBR rendering, shadows, skinned meshes, particles, sprites, decals, debug draw, world-space UI, physics, audio, and navigation.

Showcase demonstrates the asset import pipeline with a stylized nature scene built from glTF models, with material deduplication across imports.

Platform Support

Sedulous is developed and tested on Windows. The engine is intended to be cross-platform, but targeting other platforms would require building the dependencies for those platforms and filling any gaps in RHI bootstrapping.

Requirements

• Beeflang Nightly (BeefBuild or Beef IDE)
• Vulkan SDK (for shader compilation)
• GPU supporting Vulkan 1.3 or DX12

Building

cd Code
BeefBuild -workspace=. -project=EngineSandbox     # Game sandbox
BeefBuild -workspace=. -project=Sedulous.Editor.App # Editor
BeefBuild -workspace=. -project=UISandbox                 # UI demo

Shader compilation note: The first run of EngineSandbox may take a while as all shaders are compiled on startup. To speed up subsequent runs, enable shader caching in Code/Engine/Sedulous.Engine.App/src/EngineAppSettings.bf:

public bool EnableShaderCache = true;   // default is false

Shader caching is disabled by default because there is no automatic change detection yet -- if you modify shaders, you must manually delete the cache directory for them to recompile.

Project Structure

Code/
  Foundation/          -- Core libraries (RHI, Shell, VG, UI, Physics, Audio, etc.)
  Engine/              -- Engine.Core (scene model) + subsystems (Input, Physics, Render, UI, etc.)
  Editor/              -- Editor core + application
  Samples/             -- EngineSandbox, UISandbox, RHI samples, etc.
  Deprecated/          -- Legacy UI stack (replaced by Sedulous.UI)
  Dependencies/        -- Third-party bindings (Bulkan, SDL3, Jolt, Recast, etc.)

Documentation/
  Architecture.md      -- Full architecture reference
  Roadmap/             -- RendererRoadmap, EditorRoadmap, EngineRoadmap, UI.md

Documentation

• Manual -- Getting started, tutorials, and API guides
• Architecture -- Full architecture reference
• Editor Roadmap -- Editor implementation plan
• Renderer Roadmap -- Rendering feature plan
• Engine Roadmap -- Engine gap analysis
• UI Plan -- UI framework design and phase plan

Contributing

See CONTRIBUTING.md for guidelines on setting up the project, coding conventions, and submitting changes.

Areas where help is welcome:

• Testing and reporting issues
• Editor tooling
• Cross-platform support (Linux, macOS)
• Items on the roadmaps that are not yet complete

Dependencies

Built on these Beeflang bindings:

• Bulkan -- Vulkan API
• Win32-Beef -- DirectX 12 / Win32 API
• SDL3-Beef -- Window, input, audio
• joltc-Beef -- Jolt Physics
• recastnavigation-Beef -- NavMesh / pathfinding
• Dxc-Beef -- HLSL shader compilation
• stb_image-Beef, stb_truetype-Beef -- Image loading, font rasterization
• cgltf-Beef -- glTF model loading
• ufbx-Beef -- FBX/OBJ model loading

Inspiration

Sedulous draws inspiration from ezEngine, LumixEngine (mostly earlier iterations), and Traktor.

Community

Join the Discord for discussion and support.