Vulkan Schnee is a C++20 Vulkan engine built around VR-first rendering, OpenXR input, GPU-driven scene rendering, and Blender-based content authoring.

Short Pitch

Vulkan Schnee is a VR-capable Vulkan engine focused on high-performance 3D worlds with GPU-driven rendering, mesh shaders, physics, audio, skeletal animation, and Blender-to-engine asset workflows. It supports OpenXR headsets, desktop mirror rendering, glTF scene import, baked lighting, spherical-harmonics probes, dynamic shadows, and gameplay systems for physics-based VR movement and wind-driven gliding.

Rendering

Vulkan renderer with OpenXR integration for stereo VR rendering.
Desktop mirror view for headset output, debugging, and non-headset inspection.
GPU-driven rendering pipeline using compute shaders for culling, meshlet binning, meshlet unpacking, and indirect draw command generation.
Mesh shader path for meshlet rendering.
Vertex shader fallback path for single-meshlet geometry.
Unified GPU buffer architecture for scene geometry, materials, textures, transforms, meshlets, and draw data.
Frustum culling for both VR eyes.
Hi-Z occlusion culling using previous and current depth pyramids.
GPU-side object bounds transformation to avoid CPU-side transform iteration for culling.
Per-material pipeline binning for fewer draw dispatches.
Cluster LOD data and GPU LOD selection support.
Dynamic texture materials with base color, normal, roughness, metallic, emissive, and alpha-mask support.
Static lightmap material path using a second UV channel and EXR lightmaps.
Spherical harmonics probe lighting with L0, L1, and L2 shader/debug paths.
Directional light component with sun shadow resources and cascade data.
Static and dynamic shadow caster paths, including alpha-tested shadow pipelines.
Image-based lighting resources with prefiltered environment map support and a generated BRDF LUT.
Post-process tonemapping with Reinhard and ACES material options.
Particle and trail rendering paths backed by compute update/emit/prepare-draw shaders.
Debug line rendering and collision/debug visualization hooks.

Gameplay And Engine Systems

Actor, scene, and component model backed by EnTT ECS data.
Scene graph with parented transforms and glTF scene spawning.
Runtime scene loading through a scene manager.
Static mesh actors and skeletal mesh actors.
Skeletal animation asset loading and keyframe evaluation.
Bone pose access and manual bone transform overrides for skeletal actors.
Bullet physics integration with rigid bodies, collision shapes, triangle mesh collision, convex hull collision, compound shapes, and raycasts.
Collision components for boxes, capsules, mesh collision, and physics bodies.
VR camera and VR movement components.
Physics-based VR glider component driven by headset and controller hand poses.
Wind field system with configurable wind pockets, vertical wind, wind direction, speed, debug arrows, and wind samples for gameplay.
Wind trail component for visible motion feedback.
OpenXR input handler for controller poses, triggers, grips, thumbsticks, and action-based gameplay.
Desktop key input available through GLFW for non-VR prototypes.
Miniaudio-based audio engine with asset registration, playback handles, looping, stopping, master volume, and playback state checks.
Example gameplay code includes player actors, VR hands, glider player, health component, enemies, projectiles, physics demo actors, audio tests, and world demo scenes.

Content Pipeline

Blender acts as the level editor and content setup tool.
Custom Blender exporter extends glTF with Vulkan Schnee engine metadata.
glTF import supports mesh properties, collision flags, static/dynamic object metadata, lighting flags, material shader settings, lightmap metadata, and SH probe grids.
Blender shader nodes map to engine material pipelines.
Export presets support runtime glTF, external texture workflows, and lightmapped scenes.
Lightmap baking pipeline uses Blender Cycles, EXR output, UV2 lightmap coordinates, optional xatlas UV packing, atlas batching, and engine-side static lightmap loading.
SH probe baking pipeline places adaptive octree probes inside Blender volumes, renders probe panoramas, projects them to L0-L2 coefficients, exports .shprobe files, and loads them into GPU buffers.
Asset system loads meshes, textures, materials, cubemaps, audio, animations, skins, KTX textures, and EXR data.
Asset references expose load-state checks for asynchronous asset use.
Optional asset LSP tooling exists for asset path validation/completion.

Platforms And Runtime Targets

Primary target: PC VR through OpenXR and Vulkan.
OpenXR runtime targets include SteamVR, Oculus/Meta runtime through Link, Windows Mixed Reality, Monado, or any compatible OpenXR runtime.
Desktop windowing uses GLFW.
Linux supports Wayland or X11/XCB selection based on the active display environment.
Windows support is present in build configuration, including native GLFW exposure and optional RenderDoc integration.
The engine builds with CMake/Ninja presets for debug, release, release-fast, Tracy profiling, testing, and documentation.
Vulkan, OpenXR, Bullet, meshoptimizer, VMA, EnTT, KTX, tinyexr, miniaudio, ImGui, Tracy, and plog are integrated dependencies.

Practical Pitch Bullets

VR-first engine with OpenXR support and desktop mirror output.
GPU-driven Vulkan renderer using compute culling, mesh shaders, indirect draws, Hi-Z occlusion, LOD, and material binning.
Modern lighting stack with baked lightmaps, SH probes, directional sun shadows, IBL resources, and tonemapping.
Gameplay-ready systems for actors, components, physics, raycasts, audio, skeletal animation, VR input, and scene loading.
Built-in VR movement experiments, including hand-pose gliding, wind fields, wind trails, and physics-based player collision.
Blender-based world creation pipeline with custom glTF metadata, material nodes, collision flags, lightmap baking, and SH probe baking.
Runs on Vulkan-capable PC platforms with OpenXR runtimes for headset support.