Phase 2: GPU-driven voxel rendering pipeline
Mega-buffer architecture replacing per-chunk GPU buffers: - Single StructuredBuffer<PackedQuad> for all chunks (2M quads, 16 MB) - StructuredBuffer<GPUChunkInfo> with per-chunk metadata (position, quad offsets, face groups) - VS reads chunk info via push constants (b999) for driver-safe chunk indexing - CPU frustum culling with wi::primitive::Frustum + AABB per chunk - Quads sorted by face direction in greedy mesher (faceOffsets/faceCounts) - GPU frustum + backface cull compute shader (voxelCullCS.hlsl) - GPU binary mesher compute shader baseline (voxelMeshCS.hlsl) - Indirect draw buffers and timestamp query infrastructure - README with build instructions and project architecture
This commit is contained in:
commit
5f346bb14a
18 changed files with 2697 additions and 0 deletions
31
.gitignore
vendored
Normal file
31
.gitignore
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
||||||
|
# Build output
|
||||||
|
build/
|
||||||
|
out/
|
||||||
|
cmake-build-*/
|
||||||
|
|
||||||
|
# Compiled shaders (regenerated at runtime by DXC)
|
||||||
|
shaders/hlsl6/
|
||||||
|
shaders/spirv/
|
||||||
|
|
||||||
|
# Wicked Engine submodule (cloned separately)
|
||||||
|
engine/
|
||||||
|
|
||||||
|
# IDE
|
||||||
|
.vs/
|
||||||
|
.vscode/
|
||||||
|
*.suo
|
||||||
|
*.user
|
||||||
|
*.sln.docstates
|
||||||
|
|
||||||
|
# Crash dumps & logs
|
||||||
|
*.dmp
|
||||||
|
bvle_crash.log
|
||||||
|
log.txt
|
||||||
|
|
||||||
|
# OS
|
||||||
|
Thumbs.db
|
||||||
|
Desktop.ini
|
||||||
|
.DS_Store
|
||||||
|
|
||||||
|
# Claude Code
|
||||||
|
.claude/
|
||||||
278
CLAUDE.md
Normal file
278
CLAUDE.md
Normal file
|
|
@ -0,0 +1,278 @@
|
||||||
|
# BVLE Voxels - Prototype de Moteur Voxel Hybride
|
||||||
|
|
||||||
|
## Vue d'ensemble
|
||||||
|
|
||||||
|
Prototype de moteur voxel basé sur **Wicked Engine** (MIT, C++17, DX12/Vulkan) pour valider les performances de rendu sur GPU moderne (AMD RDNA 2+ / Nvidia RTX 3060+). Le document de spécification complet est dans `voxel_engine_spec.docx` à la racine du projet.
|
||||||
|
|
||||||
|
Cible : 60+ fps en 1440p, monde de 512x512x256 voxels visibles.
|
||||||
|
|
||||||
|
## Architecture
|
||||||
|
|
||||||
|
```
|
||||||
|
bvle-voxels/
|
||||||
|
├── CMakeLists.txt # Build CMake racine
|
||||||
|
├── engine/ # Wicked Engine (clone --depth 1, branche main)
|
||||||
|
│ └── WickedEngine/shaders/voxel/ # Nos shaders copiés ici pour compilation DXC
|
||||||
|
├── src/
|
||||||
|
│ ├── voxel/ # Bibliothèque VoxelEngine (static lib)
|
||||||
|
│ │ ├── VoxelTypes.h # Types fondamentaux (VoxelData, PackedQuad, MaterialDesc, ChunkPos)
|
||||||
|
│ │ ├── VoxelWorld.h/.cpp # Monde voxel (hashmap de chunks, génération procédurale)
|
||||||
|
│ │ ├── VoxelMesher.h/.cpp # Binary Greedy Mesher CPU
|
||||||
|
│ │ └── VoxelRenderer.h/.cpp# Renderer + VoxelRenderPath (sous-classe RenderPath3D)
|
||||||
|
│ └── app/
|
||||||
|
│ └── main.cpp # Point d'entrée Win32 + crash handler SEH
|
||||||
|
├── shaders/ # Sources HLSL des shaders voxel (copiés dans engine/ au build)
|
||||||
|
│ ├── voxelCommon.hlsli # Root signature et CB partagés (inclus par VS et PS)
|
||||||
|
│ ├── voxelVS.hlsl # Vertex shader (vertex pulling)
|
||||||
|
│ └── voxelPS.hlsl # Pixel shader (triplanar + lighting)
|
||||||
|
└── CLAUDE.md
|
||||||
|
```
|
||||||
|
|
||||||
|
## Build
|
||||||
|
|
||||||
|
### Prérequis
|
||||||
|
|
||||||
|
- CMake 3.19+ (`winget install Kitware.CMake`)
|
||||||
|
- Visual Studio 2022 Build Tools (`winget install Microsoft.VisualStudio.2022.BuildTools`)
|
||||||
|
- Windows SDK 10.0.26100+ (`winget install Microsoft.WindowsSDK.10.0.26100`)
|
||||||
|
|
||||||
|
### Commandes
|
||||||
|
|
||||||
|
```bash
|
||||||
|
# Configurer (depuis la racine du projet)
|
||||||
|
cmake -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_SYSTEM_VERSION=10.0.26100.0
|
||||||
|
|
||||||
|
# Compiler
|
||||||
|
cmake --build build --config Release --target BVLEVoxels --parallel
|
||||||
|
|
||||||
|
# Exécutable produit dans build/Release/BVLEVoxels.exe
|
||||||
|
```
|
||||||
|
|
||||||
|
Le SDK 10.0.26100 est requis car les headers DX12 (`d3dx12_check_feature_support.h`) fournis par Wicked Engine ne sont pas compatibles avec le SDK 22621.
|
||||||
|
|
||||||
|
### Post-build automatique (CMakeLists.txt)
|
||||||
|
|
||||||
|
Le build copie automatiquement :
|
||||||
|
1. `dxcompiler.dll` → à côté de l'exe (requis pour la compilation runtime des shaders)
|
||||||
|
2. `shaders/*.hlsl` → `engine/WickedEngine/shaders/voxel/` (pour que `LoadShader` les trouve via `SHADERSOURCEPATH`)
|
||||||
|
3. `engine/Content/` → à côté de l'exe (assets Wicked Engine)
|
||||||
|
|
||||||
|
## Intégration Wicked Engine
|
||||||
|
|
||||||
|
### Backend graphique
|
||||||
|
|
||||||
|
Wicked Engine utilise **DX12 par défaut sur Windows**, Vulkan sur Linux. Les shaders sont écrits en **HLSL** et compilés via DXC vers :
|
||||||
|
- `shaders/hlsl6/*.cso` pour DX12
|
||||||
|
- `shaders/spirv/*.spv` pour Vulkan
|
||||||
|
|
||||||
|
Pour forcer Vulkan sur Windows, passer `"vulkan"` en argument de ligne de commande.
|
||||||
|
|
||||||
|
### Point d'entrée et architecture de rendu
|
||||||
|
|
||||||
|
`VoxelRenderPath` hérite de `wi::RenderPath3D`. **IMPORTANT** : le rendu voxel utilise ses propres render targets (`voxelRT_`, `voxelDepth_`) et est exécuté dans `Render()` sur un **command list dédié** (`device->BeginCommandList()`). Le résultat est ensuite composité dans `Compose()` via `wi::image::Draw()`.
|
||||||
|
|
||||||
|
**NE JAMAIS créer un render pass dans `Compose()`** : cette méthode est appelée à l'intérieur du render pass du swapchain. Imbriquer des render passes est interdit en D3D12 (cause `DXGI_ERROR_INVALID_CALL → device removed`).
|
||||||
|
|
||||||
|
Architecture correcte :
|
||||||
|
```
|
||||||
|
Render() → RenderPath3D::Render() // Wicked rend sa scène
|
||||||
|
→ device->BeginCommandList() // Nouveau cmd list
|
||||||
|
→ renderer.render(cmd, ...) // Notre render pass (clear + draw voxels → voxelRT_)
|
||||||
|
Compose() → RenderPath3D::Compose() // Wicked affiche son résultat
|
||||||
|
→ wi::image::Draw(voxelRT_) // On overlay nos voxels par-dessus
|
||||||
|
```
|
||||||
|
|
||||||
|
La caméra est gérée manuellement dans `Update()` en écrivant directement `camera->Eye`, `camera->At` (direction LookTo), `camera->Up`.
|
||||||
|
|
||||||
|
### APIs Wicked utilisées
|
||||||
|
|
||||||
|
| Besoin | API Wicked |
|
||||||
|
|--------|-----------|
|
||||||
|
| Clavier WASD | `wi::input::Down(CHARACTER_RANGE_START + offset)` (pas de `KEYBOARD_BUTTON_W`) |
|
||||||
|
| Souris delta | `wi::input::GetMouseState().delta_position` |
|
||||||
|
| Cacher curseur | `wi::input::HidePointer(bool)` |
|
||||||
|
| Shader loading | `wi::renderer::LoadShader()` - compile auto les .hlsl en .cso si absent |
|
||||||
|
| PSO states | `wi::renderer::GetRasterizerState()` etc. retournent des pointeurs (pas besoin de `&`) |
|
||||||
|
| Render pass | `RenderPassImage::RenderTarget(texture, loadOp, storeOp, layoutBefore, layoutAfter, subresource=-1)` |
|
||||||
|
| Font overlay | `wi::font::Params` est un struct - setter les membres un par un |
|
||||||
|
| Camera | `CameraComponent::At` est une **direction** (utilisé avec `XMMatrixLookToLH`), pas un point cible |
|
||||||
|
| Buffer create | `device->CreateBuffer(desc, raw_data_ptr, buffer)` — PAS de `SubresourceData` pour les buffers ! |
|
||||||
|
| Texture create | `device->CreateTexture(desc, subresourceData_ptr, texture)` — utilise `SubresourceData*` (différent de CreateBuffer) |
|
||||||
|
| Buffer update | `device->UpdateBuffer(buffer, data, cmd, size, offset)` |
|
||||||
|
| Push constants | `device->PushConstants(data, size, cmd)` — mappés à `register(b999)`, taille fixe 48 bytes (12 × uint32) |
|
||||||
|
| Command list | `device->BeginCommandList()` — nouveau cmd list pour render passes séparés |
|
||||||
|
| Render pass | NE JAMAIS imbriquer ! Un seul render pass actif par command list |
|
||||||
|
| Debug DX12 | Passer `"debugdevice"` en argument pour activer la couche de debug D3D12 |
|
||||||
|
| Logging | `wi::backlog::post(message, logLevel)` — préférer au logging fichier |
|
||||||
|
|
||||||
|
### Shaders custom — PIÈGES IMPORTANTS
|
||||||
|
|
||||||
|
Les shaders custom doivent respecter le **binding model de Wicked Engine** :
|
||||||
|
|
||||||
|
1. **Root signature obligatoire** : chaque shader DOIT avoir une root signature DX12 intégrée, soit via `#include "globals.hlsli"` (auto), soit via `[RootSignature(MACRO)]` sur le entry point.
|
||||||
|
|
||||||
|
2. **Root signature Wicked** (HLSL 6.6+) :
|
||||||
|
- `b999` → push constants (12 × uint32 = 48 bytes max)
|
||||||
|
- `b0, b1, b2` → CBV root descriptors
|
||||||
|
- `t0-t15, u0-u15` → dans une descriptor table partagée
|
||||||
|
- `s0-s7` → samplers dynamiques
|
||||||
|
- `s100-s109` → static samplers (linear, point, aniso, etc.)
|
||||||
|
|
||||||
|
3. **Chemins des shaders** :
|
||||||
|
- `SHADERPATH` = `<exe_dir>/shaders/hlsl6/` — où les `.cso` compilés sont stockés
|
||||||
|
- `SHADERSOURCEPATH` = `../../engine/WickedEngine/shaders/` — où les `.hlsl` sources sont cherchés
|
||||||
|
- Les shaders custom doivent être copiés dans `SHADERSOURCEPATH` (sous-dossier `voxel/`)
|
||||||
|
- `LoadShader(stage, shader, "voxel/voxelVS.cso")` → compile `SHADERSOURCEPATH/voxel/voxelVS.hlsl` si `.cso` absent
|
||||||
|
|
||||||
|
4. **`dxcompiler.dll` doit être à côté de l'exe** sinon la compilation runtime échoue silencieusement.
|
||||||
|
|
||||||
|
5. **CreateBuffer prend `void*`**, pas `SubresourceData*`. L'API texture (`CreateTexture`) prend bien `SubresourceData*`.
|
||||||
|
|
||||||
|
6. **Winding des triangles — PIÈGE MAJEUR** :
|
||||||
|
|
||||||
|
Wicked Engine utilise `front_counter_clockwise = true` + `CullMode::BACK` (state `RSTYPE_FRONT`). Malgré cela, les quads voxel doivent utiliser un winding **CW** (clockwise) comme défaut, pas CCW. Confirmé empiriquement via `SV_IsFrontFace` : avec des corners CCW standard, DX12 voit tous les triangles comme **back-facing**.
|
||||||
|
|
||||||
|
La règle pour nos tangent axes U/V :
|
||||||
|
- `cross(U,V) = N` (faces +X, -Y, +Z) → corners **CW** pour être front-facing
|
||||||
|
- `cross(U,V) ≠ N` (faces -X, +Y, -Z) → corners **CCW** pour être front-facing
|
||||||
|
|
||||||
|
```
|
||||||
|
CW corners: (0,0)(0,1)(1,0), (1,0)(0,1)(1,1) ← défaut
|
||||||
|
CCW corners: (0,0)(1,0)(0,1), (0,1)(1,0)(1,1) ← faces 1,2,5
|
||||||
|
```
|
||||||
|
|
||||||
|
### Diagnostics et debugging
|
||||||
|
|
||||||
|
**Crash handler SEH** (`main.cpp`) : `SetUnhandledExceptionFilter` écrit :
|
||||||
|
- `bvle_crash.log` : stack trace avec symboles + adresses
|
||||||
|
- `bvle_crash.dmp` : minidump analysable avec Visual Studio
|
||||||
|
- Nécessite `dbghelp.lib` et build avec symbols (`RelWithDebInfo` ou `Debug`)
|
||||||
|
|
||||||
|
**D3D12 Debug Layer** : lancer avec `BVLEVoxels.exe debugdevice` pour activer. Active aussi DRED (Device Removed Extended Data) pour diagnostiquer les GPU hangs.
|
||||||
|
|
||||||
|
**Erreurs GPU courantes** :
|
||||||
|
- `DXGI_ERROR_INVALID_CALL` → render pass imbriqué ou resource state invalide
|
||||||
|
- `DXGI_ERROR_DEVICE_HUNG` → shader en boucle infinie ou accès mémoire hors limites
|
||||||
|
- Dialog bloquant avec `messageBox` → vient de `wi::helper::messageBox()`, ne pas confondre avec un crash
|
||||||
|
|
||||||
|
**Backlog Wicked** : `wi::backlog::SetLogFile("bvle_backlog.txt")` redirige les logs vers un fichier. Touche `~` (tilde) pour toggler la console à l'écran.
|
||||||
|
|
||||||
|
**Mode debug face-color** : lancer avec `BVLEVoxels.exe debug` pour activer. Génère un monde de test (blocs isolés) et colore chaque face selon sa direction :
|
||||||
|
- Bright Red / Dark Red = +X / -X
|
||||||
|
- Bright Green / Dark Green = +Y / -Y
|
||||||
|
- Bright Blue / Dark Blue = +Z / -Z
|
||||||
|
|
||||||
|
## Détails d'implémentation
|
||||||
|
|
||||||
|
### VoxelData (16 bits)
|
||||||
|
|
||||||
|
```
|
||||||
|
[15:8] material ID (256 matériaux)
|
||||||
|
[7:4] flags (smooth, transparent, emissive, custom)
|
||||||
|
[3:0] metadata (orientation, variant)
|
||||||
|
```
|
||||||
|
|
||||||
|
### PackedQuad (64 bits = 8 octets par quad)
|
||||||
|
|
||||||
|
```
|
||||||
|
[5:0] position X (0-63)
|
||||||
|
[11:6] position Y (0-63)
|
||||||
|
[17:12] position Z (0-63)
|
||||||
|
[23:18] width (1-32)
|
||||||
|
[29:24] height (1-32)
|
||||||
|
[32:30] face (0-5 : +X,-X,+Y,-Y,+Z,-Z)
|
||||||
|
[40:33] material ID
|
||||||
|
[48:41] AO (4x2 bits par coin)
|
||||||
|
[63:49] flags (réservés)
|
||||||
|
```
|
||||||
|
|
||||||
|
### Binary Greedy Mesher (CPU, `VoxelMesher.cpp`)
|
||||||
|
|
||||||
|
1. **Masques binaires** : pour chaque axe (X,Y,Z), `solid[u][v]` = bitmask 32 bits de voxels solides
|
||||||
|
2. **Face culling** : `visible = solid & ~(solid >> 1)` pour faces positives (shift adapté par direction), avec lookup cross-chunk aux frontières
|
||||||
|
3. **Greedy merge** : par tranche de profondeur, grille 2D de material IDs, expansion rectangulaire maximale (largeur puis hauteur)
|
||||||
|
|
||||||
|
### Génération procédurale (`VoxelWorld.cpp`)
|
||||||
|
|
||||||
|
- Perlin noise 3D (permutation-based, seed configurable)
|
||||||
|
- fBm 5 octaves pour le heightmap
|
||||||
|
- Caves : `|fbm(x,y,z)| < threshold` en 3D
|
||||||
|
- Matériaux par altitude : sable < 25, herbe 25-70, pierre 70-90, neige > 90
|
||||||
|
- Chunks générés en Y = 0..7 (hauteur max 256 blocs)
|
||||||
|
|
||||||
|
### Renderer (`VoxelRenderer.cpp`)
|
||||||
|
|
||||||
|
- **Vertex pulling** : pas de vertex buffer classique, le VS lit un `StructuredBuffer<PackedQuad>` via `SV_VertexID`
|
||||||
|
- **Pipeline** : PSO avec `RSTYPE_FRONT` (backface cull), `DSSTYPE_DEFAULT` (depth test), `BSTYPE_OPAQUE`
|
||||||
|
- **Per-chunk** : push constants (b999, 48 bytes) pour la position monde du chunk, bind du quad buffer en `t0`
|
||||||
|
- **Textures** : texture array 2D (256x256, 5 layers) générée procéduralement, triplanar mapping dans le PS
|
||||||
|
- **Culling** : distance-based simple (512 blocs), pas de frustum culling GPU
|
||||||
|
- **Render targets propres** : `voxelRT_` (R8G8B8A8) + `voxelDepth_` (D32_FLOAT), rendu dans `Render()` sur cmd list dédié
|
||||||
|
- **Composition** : overlay sur le swapchain via `wi::image::Draw()` dans `Compose()`
|
||||||
|
- **Stats overlay** : affichage HUD des chunks/quads/draw calls via `wi::font::Draw`
|
||||||
|
|
||||||
|
## Phases de développement (spec)
|
||||||
|
|
||||||
|
### Phase 1 - Setup et meshing de base [FAIT]
|
||||||
|
|
||||||
|
- Fork Wicked Engine, structure de modules
|
||||||
|
- VoxelWorld avec génération procédurale Perlin (rayon 4 chunks = ~150 chunks)
|
||||||
|
- Binary Greedy Mesher CPU (~300K quads pour le monde initial)
|
||||||
|
- Rendu basique avec vertex pulling et texture array
|
||||||
|
- Caméra libre de navigation (WASD + souris)
|
||||||
|
- Crash handler SEH avec stack trace symbolique
|
||||||
|
|
||||||
|
### Phase 2 - Performance GPU [A FAIRE]
|
||||||
|
|
||||||
|
- Porter le mesher en compute shader
|
||||||
|
- MultiDrawIndirect (un seul draw call pour tous les chunks)
|
||||||
|
- Frustum culling GPU + indirect args
|
||||||
|
- Backface culling par orientation (6 groupes de faces)
|
||||||
|
- Benchmark CPU vs GPU mesher
|
||||||
|
|
||||||
|
### Phase 3 - Texture blending [A FAIRE]
|
||||||
|
|
||||||
|
- Triplanar mapping (déjà en place, à affiner)
|
||||||
|
- Height-based blending aux frontières de matériaux
|
||||||
|
- Heightmaps dans le canal alpha ou texture séparée
|
||||||
|
- Neighbor material ID dans le vertex format (8 bits dans les flags réservés)
|
||||||
|
|
||||||
|
### Phase 4 - Toping [A FAIRE]
|
||||||
|
|
||||||
|
- TopingSystem avec bitmask d'adjacence 4 bits (16 variantes)
|
||||||
|
- Instance buffer GPU par chunk
|
||||||
|
- Instanced draw dans le G-buffer
|
||||||
|
- 2-3 types de test (rebord de pierre, bordure d'herbe)
|
||||||
|
|
||||||
|
### Phase 5 - Rendu smooth [A FAIRE]
|
||||||
|
|
||||||
|
- Surface Nets (ou Marching Cubes) en compute shader
|
||||||
|
- Flag `smooth` dans VoxelData
|
||||||
|
- Coexistence blocky/smooth dans le même chunk
|
||||||
|
- Buffer séparé pour les triangles smooth
|
||||||
|
|
||||||
|
### Phase 6 - Ray tracing hybride [A FAIRE]
|
||||||
|
|
||||||
|
- BLAS par chunk (depuis le mesh greedy), TLAS par frame
|
||||||
|
- RT Shadows via ray queries (compute shader)
|
||||||
|
- RT AO (4-8 rayons, courte portée)
|
||||||
|
- Fallback shadow maps / SSAO si RT non disponible
|
||||||
|
|
||||||
|
## Métriques cibles
|
||||||
|
|
||||||
|
| Métrique | Cible |
|
||||||
|
|----------|-------|
|
||||||
|
| FPS 1440p | > 60 fps, monde 512x512x128 |
|
||||||
|
| Meshing GPU | < 200 us par chunk 32^3 |
|
||||||
|
| Re-mesh | < 1 frame (16ms) pour 1 chunk |
|
||||||
|
| Mémoire GPU | < 500 Mo pour 512x512x128 |
|
||||||
|
| RT shadows + AO | < 4ms en 1440p |
|
||||||
|
| Draw calls | < 100 (hors post-process) |
|
||||||
|
|
||||||
|
## Conventions
|
||||||
|
|
||||||
|
- Namespaces : tout le code voxel est dans `namespace voxel`
|
||||||
|
- Chunks : 32x32x32, configurable via `CHUNK_SIZE`
|
||||||
|
- Coordonnées : Y = haut, monde infini en X/Z, hashmap sparse
|
||||||
|
- Matériaux : palette de 256, index 0 = air (vide)
|
||||||
|
- Faces : 0=+X, 1=-X, 2=+Y, 3=-Y, 4=+Z, 5=-Z
|
||||||
51
CMakeLists.txt
Normal file
51
CMakeLists.txt
Normal file
|
|
@ -0,0 +1,51 @@
|
||||||
|
cmake_minimum_required(VERSION 3.19)
|
||||||
|
project(BVLEVoxels LANGUAGES CXX)
|
||||||
|
|
||||||
|
set(CMAKE_CXX_STANDARD 17)
|
||||||
|
set(CMAKE_CXX_STANDARD_REQUIRED ON)
|
||||||
|
set(CMAKE_CXX_EXTENSIONS OFF)
|
||||||
|
|
||||||
|
# Wicked Engine options - disable what we don't need
|
||||||
|
set(WICKED_EDITOR OFF CACHE BOOL "" FORCE)
|
||||||
|
set(WICKED_TESTS OFF CACHE BOOL "" FORCE)
|
||||||
|
set(WICKED_IMGUI_EXAMPLE OFF CACHE BOOL "" FORCE)
|
||||||
|
set(WICKED_WINDOWS_TEMPLATE OFF CACHE BOOL "" FORCE)
|
||||||
|
set(WICKED_LINUX_TEMPLATE OFF CACHE BOOL "" FORCE)
|
||||||
|
set(WICKED_ENABLE_SYMLINKS OFF CACHE BOOL "" FORCE)
|
||||||
|
|
||||||
|
add_subdirectory(engine)
|
||||||
|
|
||||||
|
# ── Voxel Engine Library ──────────────────────────────────────────
|
||||||
|
file(GLOB_RECURSE VOXEL_SOURCES src/voxel/*.cpp src/voxel/*.h)
|
||||||
|
add_library(VoxelEngine STATIC ${VOXEL_SOURCES})
|
||||||
|
target_include_directories(VoxelEngine PUBLIC src)
|
||||||
|
target_link_libraries(VoxelEngine PUBLIC WickedEngine)
|
||||||
|
|
||||||
|
# ── Main Application ─────────────────────────────────────────────
|
||||||
|
file(GLOB APP_SOURCES src/app/*.cpp src/app/*.h)
|
||||||
|
add_executable(BVLEVoxels WIN32 ${APP_SOURCES})
|
||||||
|
target_link_libraries(BVLEVoxels PRIVATE VoxelEngine WickedEngine)
|
||||||
|
|
||||||
|
# Copy Content directory (shaders, etc.) to build output
|
||||||
|
add_custom_command(TARGET BVLEVoxels POST_BUILD
|
||||||
|
COMMAND ${CMAKE_COMMAND} -E copy_directory
|
||||||
|
${CMAKE_SOURCE_DIR}/engine/Content
|
||||||
|
$<TARGET_FILE_DIR:BVLEVoxels>/Content
|
||||||
|
)
|
||||||
|
|
||||||
|
# Copy DXC shader compiler DLL next to the exe (required for runtime shader compilation)
|
||||||
|
add_custom_command(TARGET BVLEVoxels POST_BUILD
|
||||||
|
COMMAND ${CMAKE_COMMAND} -E copy_if_different
|
||||||
|
${CMAKE_SOURCE_DIR}/engine/WickedEngine/dxcompiler.dll
|
||||||
|
$<TARGET_FILE_DIR:BVLEVoxels>/dxcompiler.dll
|
||||||
|
COMMENT "Copying DXC shader compiler DLL"
|
||||||
|
)
|
||||||
|
|
||||||
|
# Copy our custom shader sources into Wicked's shader source tree
|
||||||
|
# so LoadShader can find and compile them as "voxel/voxelVS.cso"
|
||||||
|
add_custom_command(TARGET BVLEVoxels POST_BUILD
|
||||||
|
COMMAND ${CMAKE_COMMAND} -E copy_directory
|
||||||
|
${CMAKE_SOURCE_DIR}/shaders
|
||||||
|
${CMAKE_SOURCE_DIR}/engine/WickedEngine/shaders/voxel
|
||||||
|
COMMENT "Copying voxel shaders to Wicked Engine shader source directory"
|
||||||
|
)
|
||||||
120
README.md
Normal file
120
README.md
Normal file
|
|
@ -0,0 +1,120 @@
|
||||||
|
# BVLE Voxels
|
||||||
|
|
||||||
|
Prototype de moteur voxel hybride basé sur [Wicked Engine](https://github.com/turanszkij/WickedEngine) (MIT, C++17, DX12/Vulkan).
|
||||||
|
|
||||||
|
Cible : **60+ fps en 1440p**, monde de 512×512×256 voxels visibles.
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
|
## Prérequis
|
||||||
|
|
||||||
|
| Outil | Version | Installation |
|
||||||
|
|-------|---------|-------------|
|
||||||
|
| **Windows** | 10/11 (x64) | — |
|
||||||
|
| **CMake** | 3.19+ | `winget install Kitware.CMake` |
|
||||||
|
| **Visual Studio 2022 Build Tools** | 17.x | `winget install Microsoft.VisualStudio.2022.BuildTools` |
|
||||||
|
| **Windows SDK** | 10.0.26100+ | `winget install Microsoft.WindowsSDK.10.0.26100` |
|
||||||
|
| **GPU** | DX12 feature level 12.0+ | AMD RDNA 2+ / Nvidia RTX 3060+ recommandé |
|
||||||
|
|
||||||
|
> Le SDK **10.0.26100** est requis car les headers DX12 fournis par Wicked Engine ne sont pas compatibles avec le SDK 22621.
|
||||||
|
|
||||||
|
## Installation
|
||||||
|
|
||||||
|
```bash
|
||||||
|
# 1. Cloner le dépôt
|
||||||
|
git clone <url> bvle-voxels
|
||||||
|
cd bvle-voxels
|
||||||
|
|
||||||
|
# 2. Cloner Wicked Engine dans engine/
|
||||||
|
git clone --depth 1 https://github.com/turanszkij/WickedEngine.git engine
|
||||||
|
|
||||||
|
# 3. Configurer CMake
|
||||||
|
cmake -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_SYSTEM_VERSION=10.0.26100.0
|
||||||
|
|
||||||
|
# 4. Compiler
|
||||||
|
cmake --build build --config Release --target BVLEVoxels --parallel
|
||||||
|
|
||||||
|
# 5. Lancer
|
||||||
|
./build/Release/BVLEVoxels.exe
|
||||||
|
```
|
||||||
|
|
||||||
|
## Commandes de lancement
|
||||||
|
|
||||||
|
| Commande | Description |
|
||||||
|
|----------|-------------|
|
||||||
|
| `BVLEVoxels.exe` | Mode normal (monde procédural, rayon 4 chunks) |
|
||||||
|
| `BVLEVoxels.exe debug` | Mode debug face-color (+X=Rouge, -X=Rouge sombre, etc.) |
|
||||||
|
| `BVLEVoxels.exe debugdevice` | Active la couche de debug D3D12 |
|
||||||
|
| `BVLEVoxels.exe vulkan` | Force le backend Vulkan |
|
||||||
|
|
||||||
|
## Contrôles
|
||||||
|
|
||||||
|
| Touche | Action |
|
||||||
|
|--------|--------|
|
||||||
|
| **WASD** | Déplacement caméra |
|
||||||
|
| **Espace / Ctrl** | Monter / Descendre |
|
||||||
|
| **Shift** | Vitesse ×3 |
|
||||||
|
| **Clic droit** | Capturer/libérer la souris |
|
||||||
|
| **~** (tilde) | Console Wicked Engine |
|
||||||
|
|
||||||
|
## Architecture
|
||||||
|
|
||||||
|
```
|
||||||
|
bvle-voxels/
|
||||||
|
├── CMakeLists.txt # Build CMake
|
||||||
|
├── engine/ # Wicked Engine (git clone --depth 1)
|
||||||
|
├── src/
|
||||||
|
│ ├── voxel/ # Bibliothèque VoxelEngine (static lib)
|
||||||
|
│ │ ├── VoxelTypes.h # Types (VoxelData, PackedQuad, ChunkPos)
|
||||||
|
│ │ ├── VoxelWorld.h/.cpp # Monde voxel (hashmap, génération Perlin)
|
||||||
|
│ │ ├── VoxelMesher.h/.cpp # Binary Greedy Mesher CPU
|
||||||
|
│ │ └── VoxelRenderer.h/.cpp# Renderer GPU-driven + VoxelRenderPath
|
||||||
|
│ └── app/
|
||||||
|
│ └── main.cpp # Point d'entrée Win32
|
||||||
|
├── shaders/ # Sources HLSL
|
||||||
|
│ ├── voxelCommon.hlsli # Root signature, CB, structs partagés
|
||||||
|
│ ├── voxelVS.hlsl # Vertex shader (vertex pulling)
|
||||||
|
│ ├── voxelPS.hlsl # Pixel shader (triplanar + lighting)
|
||||||
|
│ ├── voxelCullCS.hlsl # Compute: frustum + backface culling
|
||||||
|
│ └── voxelMeshCS.hlsl # Compute: GPU mesher (binary, baseline)
|
||||||
|
└── voxel_engine_spec.docx # Document de spécification complet
|
||||||
|
```
|
||||||
|
|
||||||
|
## Pipeline de rendu (Phase 2 — GPU-driven)
|
||||||
|
|
||||||
|
```
|
||||||
|
CPU: mesh dirty chunks (greedy merge) → pack quads + chunkInfo dans mega-buffers → upload GPU
|
||||||
|
GPU: frustum cull compute → indirect args → DrawInstancedIndirectCount (1 appel = N draws)
|
||||||
|
```
|
||||||
|
|
||||||
|
**Buffers GPU :**
|
||||||
|
|
||||||
|
| Buffer | Type | Slot | Rôle |
|
||||||
|
|--------|------|------|------|
|
||||||
|
| `megaQuadBuffer_` | StructuredBuffer\<PackedQuad\> | SRV t0 | 2M quads max (16 MB) |
|
||||||
|
| `chunkInfoBuffer_` | StructuredBuffer\<GPUChunkInfo\> | SRV t2 | 2048 chunks max |
|
||||||
|
| `indirectArgsBuffer_` | RWStructuredBuffer | UAV u0 | Indirect draw args |
|
||||||
|
| `drawCountBuffer_` | RWByteAddressBuffer | UAV u1 | Compteur atomique de draws |
|
||||||
|
|
||||||
|
**Caractéristiques Phase 2 :**
|
||||||
|
- Mega-buffer unique pour tous les quads de tous les chunks
|
||||||
|
- Vertex pulling via `SV_VertexID` + push constants (`b999`)
|
||||||
|
- Frustum culling CPU (wi::primitive::Frustum)
|
||||||
|
- Backface culling par face group (6 directions × chunk)
|
||||||
|
- GPU frustum cull compute shader (prêt, activation via flag)
|
||||||
|
- GPU mesher compute shader baseline (binary, sans greedy merge)
|
||||||
|
- Tri des quads par direction de face dans le mesher CPU
|
||||||
|
- GPU timestamp queries pour benchmark
|
||||||
|
|
||||||
|
## Phases de développement
|
||||||
|
|
||||||
|
- [x] **Phase 1** — Setup, meshing CPU, rendu basique
|
||||||
|
- [x] **Phase 2** — GPU-driven pipeline, mega-buffer, culling, compute shaders
|
||||||
|
- [ ] **Phase 3** — Texture blending (triplanar, height-based)
|
||||||
|
- [ ] **Phase 4** — Toping (rebords, bordures procédurales)
|
||||||
|
- [ ] **Phase 5** — Rendu smooth (Surface Nets / Marching Cubes)
|
||||||
|
- [ ] **Phase 6** — Ray tracing hybride (RT shadows + AO)
|
||||||
|
|
||||||
|
## Licence
|
||||||
|
|
||||||
|
Wicked Engine est sous licence MIT. Le code spécifique BVLE est propriétaire.
|
||||||
99
shaders/voxelCommon.hlsli
Normal file
99
shaders/voxelCommon.hlsli
Normal file
|
|
@ -0,0 +1,99 @@
|
||||||
|
// BVLE Voxels - Shared shader definitions
|
||||||
|
// Root signature, common structures, and constant buffers for voxel shaders.
|
||||||
|
|
||||||
|
#ifndef VOXEL_COMMON_HLSLI
|
||||||
|
#define VOXEL_COMMON_HLSLI
|
||||||
|
|
||||||
|
// Wicked Engine DX12 root signature (HLSL 6.6+ bindless model)
|
||||||
|
// b999: push constants (12 x uint32 = 48 bytes)
|
||||||
|
// b0-b2: root CBV descriptors
|
||||||
|
// t0-t15, u0-u15: SRV/UAV descriptor table
|
||||||
|
// s0-s7: dynamic samplers
|
||||||
|
// s100+: static samplers
|
||||||
|
#define VOXEL_ROOTSIG \
|
||||||
|
"RootFlags(CBV_SRV_UAV_HEAP_DIRECTLY_INDEXED | SAMPLER_HEAP_DIRECTLY_INDEXED), " \
|
||||||
|
"RootConstants(num32BitConstants=12, b999), " \
|
||||||
|
"CBV(b0), " \
|
||||||
|
"CBV(b1), " \
|
||||||
|
"CBV(b2), " \
|
||||||
|
"DescriptorTable( " \
|
||||||
|
"CBV(b3, numDescriptors = 11, flags = DATA_STATIC_WHILE_SET_AT_EXECUTE)," \
|
||||||
|
"SRV(t0, numDescriptors = 16, flags = DESCRIPTORS_VOLATILE | DATA_STATIC_WHILE_SET_AT_EXECUTE)," \
|
||||||
|
"UAV(u0, numDescriptors = 16, flags = DESCRIPTORS_VOLATILE | DATA_STATIC_WHILE_SET_AT_EXECUTE)" \
|
||||||
|
")," \
|
||||||
|
"DescriptorTable( " \
|
||||||
|
"Sampler(s0, offset = 0, numDescriptors = 8, flags = DESCRIPTORS_VOLATILE)" \
|
||||||
|
")," \
|
||||||
|
"StaticSampler(s100, addressU = TEXTURE_ADDRESS_CLAMP, addressV = TEXTURE_ADDRESS_CLAMP, addressW = TEXTURE_ADDRESS_CLAMP, filter = FILTER_MIN_MAG_MIP_LINEAR)," \
|
||||||
|
"StaticSampler(s101, addressU = TEXTURE_ADDRESS_WRAP, addressV = TEXTURE_ADDRESS_WRAP, addressW = TEXTURE_ADDRESS_WRAP, filter = FILTER_MIN_MAG_MIP_LINEAR)," \
|
||||||
|
"StaticSampler(s102, addressU = TEXTURE_ADDRESS_MIRROR, addressV = TEXTURE_ADDRESS_MIRROR, addressW = TEXTURE_ADDRESS_MIRROR, filter = FILTER_MIN_MAG_MIP_LINEAR)," \
|
||||||
|
"StaticSampler(s103, addressU = TEXTURE_ADDRESS_CLAMP, addressV = TEXTURE_ADDRESS_CLAMP, addressW = TEXTURE_ADDRESS_CLAMP, filter = FILTER_MIN_MAG_MIP_POINT)," \
|
||||||
|
"StaticSampler(s104, addressU = TEXTURE_ADDRESS_WRAP, addressV = TEXTURE_ADDRESS_WRAP, addressW = TEXTURE_ADDRESS_WRAP, filter = FILTER_MIN_MAG_MIP_POINT)," \
|
||||||
|
"StaticSampler(s105, addressU = TEXTURE_ADDRESS_MIRROR, addressV = TEXTURE_ADDRESS_MIRROR, addressW = TEXTURE_ADDRESS_MIRROR, filter = FILTER_MIN_MAG_MIP_POINT)," \
|
||||||
|
"StaticSampler(s106, addressU = TEXTURE_ADDRESS_CLAMP, addressV = TEXTURE_ADDRESS_CLAMP, addressW = TEXTURE_ADDRESS_CLAMP, filter = FILTER_ANISOTROPIC, maxAnisotropy = 16)," \
|
||||||
|
"StaticSampler(s107, addressU = TEXTURE_ADDRESS_WRAP, addressV = TEXTURE_ADDRESS_WRAP, addressW = TEXTURE_ADDRESS_WRAP, filter = FILTER_ANISOTROPIC, maxAnisotropy = 16)," \
|
||||||
|
"StaticSampler(s108, addressU = TEXTURE_ADDRESS_MIRROR, addressV = TEXTURE_ADDRESS_MIRROR, addressW = TEXTURE_ADDRESS_MIRROR, filter = FILTER_ANISOTROPIC, maxAnisotropy = 16)," \
|
||||||
|
"StaticSampler(s109, addressU = TEXTURE_ADDRESS_CLAMP, addressV = TEXTURE_ADDRESS_CLAMP, addressW = TEXTURE_ADDRESS_CLAMP, filter = FILTER_COMPARISON_MIN_MAG_LINEAR_MIP_POINT, comparisonFunc = COMPARISON_GREATER_EQUAL),"
|
||||||
|
|
||||||
|
// ── Per-frame constant buffer (b0) ──────────────────────────────
|
||||||
|
cbuffer VoxelCB : register(b0) {
|
||||||
|
float4x4 viewProjection;
|
||||||
|
float4 cameraPosition;
|
||||||
|
float4 sunDirection;
|
||||||
|
float4 sunColor;
|
||||||
|
float chunkSize;
|
||||||
|
float textureTiling;
|
||||||
|
float2 _pad;
|
||||||
|
// Frustum culling data (used by cull compute shader)
|
||||||
|
float4 frustumPlanes[6]; // ax+by+cz+d=0, xyz=normal, w=distance
|
||||||
|
uint chunkCount;
|
||||||
|
uint _cullPad0;
|
||||||
|
uint _cullPad1;
|
||||||
|
uint _cullPad2;
|
||||||
|
};
|
||||||
|
|
||||||
|
// ── Indirect draw args (must match C++ IndirectDrawArgs / DX12 DrawInstanced) ──
|
||||||
|
struct IndirectDrawArgsInstanced {
|
||||||
|
uint vertexCountPerInstance;
|
||||||
|
uint instanceCount;
|
||||||
|
uint startVertexLocation;
|
||||||
|
uint startInstanceLocation;
|
||||||
|
};
|
||||||
|
|
||||||
|
// ── GPU chunk info (must match C++ GPUChunkInfo, 80 bytes) ──────
|
||||||
|
// NOTE: No arrays — scalar-only to guarantee C-style packing in StructuredBuffer.
|
||||||
|
struct GPUChunkInfo {
|
||||||
|
float4 worldPos; // xyz = chunk origin in world space, w = debug flag
|
||||||
|
uint quadOffset; // offset into mega quad buffer (in quads)
|
||||||
|
uint quadCount; // number of quads for this chunk
|
||||||
|
uint _pad0;
|
||||||
|
uint _pad1;
|
||||||
|
// Per-face data (6 faces: +X -X +Y -Y +Z -Z)
|
||||||
|
uint faceOff0, faceOff1, faceOff2, faceOff3, faceOff4, faceOff5;
|
||||||
|
uint faceCnt0, faceCnt1, faceCnt2, faceCnt3, faceCnt4, faceCnt5;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper functions to access scalar face fields by index
|
||||||
|
uint getFaceOffset(GPUChunkInfo info, uint f) {
|
||||||
|
switch (f) {
|
||||||
|
case 0: return info.faceOff0;
|
||||||
|
case 1: return info.faceOff1;
|
||||||
|
case 2: return info.faceOff2;
|
||||||
|
case 3: return info.faceOff3;
|
||||||
|
case 4: return info.faceOff4;
|
||||||
|
default: return info.faceOff5;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
uint getFaceCount(GPUChunkInfo info, uint f) {
|
||||||
|
switch (f) {
|
||||||
|
case 0: return info.faceCnt0;
|
||||||
|
case 1: return info.faceCnt1;
|
||||||
|
case 2: return info.faceCnt2;
|
||||||
|
case 3: return info.faceCnt3;
|
||||||
|
case 4: return info.faceCnt4;
|
||||||
|
default: return info.faceCnt5;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // VOXEL_COMMON_HLSLI
|
||||||
93
shaders/voxelCullCS.hlsl
Normal file
93
shaders/voxelCullCS.hlsl
Normal file
|
|
@ -0,0 +1,93 @@
|
||||||
|
// BVLE Voxels - Frustum + Backface Culling Compute Shader
|
||||||
|
// 1 thread per chunk: tests AABB vs 6 frustum planes, then emits up to 6 draws
|
||||||
|
// (one per visible face group, back-facing groups are culled).
|
||||||
|
|
||||||
|
#include "voxelCommon.hlsli"
|
||||||
|
|
||||||
|
StructuredBuffer<GPUChunkInfo> chunkInfoBuffer : register(t2);
|
||||||
|
RWStructuredBuffer<IndirectDrawArgsInstanced> indirectArgs : register(u0);
|
||||||
|
RWByteAddressBuffer drawCount : register(u1);
|
||||||
|
|
||||||
|
// Test AABB against 6 frustum planes (returns true if visible)
|
||||||
|
bool frustumTestAABB(float3 aabbMin, float3 aabbMax)
|
||||||
|
{
|
||||||
|
[unroll]
|
||||||
|
for (uint i = 0; i < 6; i++)
|
||||||
|
{
|
||||||
|
float4 plane = frustumPlanes[i];
|
||||||
|
float3 pVertex;
|
||||||
|
pVertex.x = (plane.x >= 0.0) ? aabbMax.x : aabbMin.x;
|
||||||
|
pVertex.y = (plane.y >= 0.0) ? aabbMax.y : aabbMin.y;
|
||||||
|
pVertex.z = (plane.z >= 0.0) ? aabbMax.z : aabbMin.z;
|
||||||
|
|
||||||
|
if (dot(plane.xyz, pVertex) + plane.w < 0.0)
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Face normals: +X, -X, +Y, -Y, +Z, -Z
|
||||||
|
static const float3 faceNormals[6] = {
|
||||||
|
float3( 1, 0, 0), float3(-1, 0, 0),
|
||||||
|
float3( 0, 1, 0), float3( 0,-1, 0),
|
||||||
|
float3( 0, 0, 1), float3( 0, 0,-1)
|
||||||
|
};
|
||||||
|
|
||||||
|
[RootSignature(VOXEL_ROOTSIG)]
|
||||||
|
[numthreads(64, 1, 1)]
|
||||||
|
void main(uint3 DTid : SV_DispatchThreadID)
|
||||||
|
{
|
||||||
|
uint chunkIdx = DTid.x;
|
||||||
|
if (chunkIdx >= chunkCount) return;
|
||||||
|
|
||||||
|
GPUChunkInfo info = chunkInfoBuffer[chunkIdx];
|
||||||
|
if (info.quadCount == 0) return;
|
||||||
|
|
||||||
|
float3 aabbMin = info.worldPos.xyz;
|
||||||
|
float3 aabbMax = aabbMin + (float3)chunkSize;
|
||||||
|
|
||||||
|
if (!frustumTestAABB(aabbMin, aabbMax)) return;
|
||||||
|
|
||||||
|
// Camera-to-chunk vector for backface test
|
||||||
|
float3 chunkCenter = (aabbMin + aabbMax) * 0.5;
|
||||||
|
float3 viewDir = chunkCenter - cameraPosition.xyz;
|
||||||
|
|
||||||
|
// Emit one draw per visible face group
|
||||||
|
[unroll]
|
||||||
|
for (uint f = 0; f < 6; f++)
|
||||||
|
{
|
||||||
|
uint fCnt = getFaceCount(info, f);
|
||||||
|
if (fCnt == 0) continue;
|
||||||
|
|
||||||
|
// Backface cull: if camera sees the back of this face group, skip it.
|
||||||
|
// A face group with normal N is back-facing if dot(viewDir, N) > 0.
|
||||||
|
// But we need a per-face test relative to the chunk AABB, not just center:
|
||||||
|
// face +X: back-facing if camera.x < aabbMin.x (camera is on -X side)
|
||||||
|
// face -X: back-facing if camera.x > aabbMax.x (camera is on +X side)
|
||||||
|
// This is more conservative and correct than dot product with center.
|
||||||
|
bool backFacing = false;
|
||||||
|
switch (f)
|
||||||
|
{
|
||||||
|
case 0: backFacing = (cameraPosition.x < aabbMin.x); break; // +X
|
||||||
|
case 1: backFacing = (cameraPosition.x > aabbMax.x); break; // -X
|
||||||
|
case 2: backFacing = (cameraPosition.y < aabbMin.y); break; // +Y
|
||||||
|
case 3: backFacing = (cameraPosition.y > aabbMax.y); break; // -Y
|
||||||
|
case 4: backFacing = (cameraPosition.z < aabbMin.z); break; // +Z
|
||||||
|
case 5: backFacing = (cameraPosition.z > aabbMax.z); break; // -Z
|
||||||
|
}
|
||||||
|
if (backFacing) continue;
|
||||||
|
|
||||||
|
uint drawIdx;
|
||||||
|
drawCount.InterlockedAdd(0, 1, drawIdx);
|
||||||
|
|
||||||
|
// The face group's quads start at (chunk's mega-buffer offset + face offset within chunk)
|
||||||
|
uint faceQuadOffset = info.quadOffset + getFaceOffset(info, f);
|
||||||
|
|
||||||
|
IndirectDrawArgsInstanced args;
|
||||||
|
args.vertexCountPerInstance = fCnt * 6;
|
||||||
|
args.instanceCount = 1;
|
||||||
|
args.startVertexLocation = faceQuadOffset * 6;
|
||||||
|
args.startInstanceLocation = chunkIdx;
|
||||||
|
indirectArgs[drawIdx] = args;
|
||||||
|
}
|
||||||
|
}
|
||||||
86
shaders/voxelMeshCS.hlsl
Normal file
86
shaders/voxelMeshCS.hlsl
Normal file
|
|
@ -0,0 +1,86 @@
|
||||||
|
// BVLE Voxels - GPU Compute Mesher (Binary Face Culling only)
|
||||||
|
// 1 thread per voxel: checks 6 neighbors, emits 1x1 PackedQuad per visible face.
|
||||||
|
// No greedy merge — this is the simple GPU baseline for benchmark comparison.
|
||||||
|
|
||||||
|
#include "voxelCommon.hlsli"
|
||||||
|
|
||||||
|
// Push constants: chunk index + output offset
|
||||||
|
struct MeshPush {
|
||||||
|
uint chunkIndex; // which chunk to mesh
|
||||||
|
uint voxelBufferOffset; // offset into the voxel data buffer (in uint16 pairs)
|
||||||
|
uint quadBufferOffset; // offset into the output quad buffer (in quads)
|
||||||
|
uint maxOutputQuads; // safety cap on output
|
||||||
|
uint pad[8]; // pad to 48 bytes (12 x uint32)
|
||||||
|
};
|
||||||
|
[[vk::push_constant]] ConstantBuffer<MeshPush> push : register(b999);
|
||||||
|
|
||||||
|
// Input: voxel data for one chunk (32^3 = 32768 voxels, packed as uint16 pairs in uint)
|
||||||
|
// Each uint holds 2 voxels: low 16 bits = voxel A, high 16 bits = voxel B
|
||||||
|
StructuredBuffer<uint> voxelData : register(t0);
|
||||||
|
|
||||||
|
// Output: packed quads (append buffer with atomic counter)
|
||||||
|
RWStructuredBuffer<uint2> outputQuads : register(u0); // uint2 = 8 bytes = PackedQuad
|
||||||
|
RWByteAddressBuffer quadCounter : register(u1); // atomic counter
|
||||||
|
|
||||||
|
// Constants
|
||||||
|
static const uint CSIZE = 32;
|
||||||
|
static const uint CVOL = CSIZE * CSIZE * CSIZE; // 32768
|
||||||
|
|
||||||
|
// Read a single voxel (16-bit) from the packed buffer
|
||||||
|
uint readVoxel(uint flatIndex) {
|
||||||
|
uint pairIndex = flatIndex >> 1; // which uint (2 voxels per uint)
|
||||||
|
uint shift = (flatIndex & 1) * 16; // 0 or 16
|
||||||
|
return (voxelData[push.voxelBufferOffset + pairIndex] >> shift) & 0xFFFF;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check if neighbor is air (handles out-of-bounds as air for chunk boundaries)
|
||||||
|
bool isNeighborAir(int3 pos, int3 dir) {
|
||||||
|
int3 n = pos + dir;
|
||||||
|
// Out-of-chunk = treat as air (boundary faces always visible)
|
||||||
|
if (any(n < 0) || any(n >= (int3)CSIZE))
|
||||||
|
return true;
|
||||||
|
uint flatN = (uint)n.x + (uint)n.y * CSIZE + (uint)n.z * CSIZE * CSIZE;
|
||||||
|
return readVoxel(flatN) == 0; // materialID 0 = air
|
||||||
|
}
|
||||||
|
|
||||||
|
// Pack a quad into uint2 (matches CPU PackedQuad format)
|
||||||
|
uint2 packQuad(uint x, uint y, uint z, uint w, uint h, uint face, uint matID) {
|
||||||
|
uint lo = x | (y << 6) | (z << 12) | (w << 18) | (h << 24) | (face << 30);
|
||||||
|
uint hi = (face >> 2) | (matID << 1) | (0 << 9) | (0 << 17); // AO=0, flags=0
|
||||||
|
return uint2(lo, hi);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Face directions
|
||||||
|
static const int3 faceDirs[6] = {
|
||||||
|
int3( 1, 0, 0), int3(-1, 0, 0),
|
||||||
|
int3( 0, 1, 0), int3( 0,-1, 0),
|
||||||
|
int3( 0, 0, 1), int3( 0, 0,-1)
|
||||||
|
};
|
||||||
|
|
||||||
|
[RootSignature(VOXEL_ROOTSIG)]
|
||||||
|
[numthreads(8, 8, 8)] // 512 threads = covers 32^3 with 64 groups of 512
|
||||||
|
void main(uint3 DTid : SV_DispatchThreadID)
|
||||||
|
{
|
||||||
|
if (any(DTid >= CSIZE)) return;
|
||||||
|
|
||||||
|
uint flatIdx = DTid.x + DTid.y * CSIZE + DTid.z * CSIZE * CSIZE;
|
||||||
|
uint voxel = readVoxel(flatIdx);
|
||||||
|
if (voxel == 0) return; // air voxel, nothing to emit
|
||||||
|
|
||||||
|
uint matID = voxel >> 8; // high 8 bits = material ID
|
||||||
|
|
||||||
|
// Check each face direction
|
||||||
|
[unroll]
|
||||||
|
for (uint f = 0; f < 6; f++) {
|
||||||
|
if (!isNeighborAir((int3)DTid, faceDirs[f])) continue;
|
||||||
|
|
||||||
|
// Emit a 1x1 quad
|
||||||
|
uint slot;
|
||||||
|
quadCounter.InterlockedAdd(0, 1, slot);
|
||||||
|
if (slot >= push.maxOutputQuads) return; // overflow guard
|
||||||
|
|
||||||
|
outputQuads[push.quadBufferOffset + slot] = packQuad(
|
||||||
|
DTid.x, DTid.y, DTid.z, 1, 1, f, matID
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
83
shaders/voxelPS.hlsl
Normal file
83
shaders/voxelPS.hlsl
Normal file
|
|
@ -0,0 +1,83 @@
|
||||||
|
// BVLE Voxels - Pixel Shader (Triplanar textured with simple lighting)
|
||||||
|
|
||||||
|
#include "voxelCommon.hlsli"
|
||||||
|
|
||||||
|
Texture2DArray materialTextures : register(t1);
|
||||||
|
SamplerState materialSampler : register(s0);
|
||||||
|
|
||||||
|
struct PSInput {
|
||||||
|
float4 position : SV_POSITION;
|
||||||
|
float3 worldPos : WORLDPOS;
|
||||||
|
float3 normal : NORMAL;
|
||||||
|
float2 uv : TEXCOORD0;
|
||||||
|
nointerpolation uint materialID : MATERIALID;
|
||||||
|
nointerpolation uint faceID : FACEID;
|
||||||
|
nointerpolation float debugFlag : DEBUGFLAG;
|
||||||
|
float ao : AO;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Triplanar blend weights
|
||||||
|
float3 triplanarWeights(float3 normal, float sharpness) {
|
||||||
|
float3 w = abs(normal);
|
||||||
|
w = pow(w, (float3)sharpness);
|
||||||
|
return w / (w.x + w.y + w.z + 0.0001);
|
||||||
|
}
|
||||||
|
|
||||||
|
float3 sampleTriplanar(float3 worldPos, float3 normal, uint texIndex, float tiling) {
|
||||||
|
float3 w = triplanarWeights(normal, 4.0);
|
||||||
|
|
||||||
|
float3 colX = materialTextures.Sample(materialSampler, float3(worldPos.yz * tiling, (float)texIndex)).rgb;
|
||||||
|
float3 colY = materialTextures.Sample(materialSampler, float3(worldPos.xz * tiling, (float)texIndex)).rgb;
|
||||||
|
float3 colZ = materialTextures.Sample(materialSampler, float3(worldPos.xy * tiling, (float)texIndex)).rgb;
|
||||||
|
|
||||||
|
return colX * w.x + colY * w.y + colZ * w.z;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Debug face colors
|
||||||
|
static const float3 faceDebugColors[6] = {
|
||||||
|
float3(1.0, 0.2, 0.2), // 0: +X = RED
|
||||||
|
float3(0.5, 0.0, 0.0), // 1: -X = DARK RED
|
||||||
|
float3(0.2, 1.0, 0.2), // 2: +Y = GREEN
|
||||||
|
float3(0.0, 0.5, 0.0), // 3: -Y = DARK GREEN
|
||||||
|
float3(0.2, 0.2, 1.0), // 4: +Z = BLUE
|
||||||
|
float3(0.0, 0.0, 0.5), // 5: -Z = DARK BLUE
|
||||||
|
};
|
||||||
|
|
||||||
|
[RootSignature(VOXEL_ROOTSIG)]
|
||||||
|
float4 main(PSInput input) : SV_TARGET0
|
||||||
|
{
|
||||||
|
// ── DEBUG MODE: face direction colors ──
|
||||||
|
if (input.debugFlag > 0.5)
|
||||||
|
{
|
||||||
|
uint fid = min(input.faceID, 5u);
|
||||||
|
float3 faceColor = faceDebugColors[fid];
|
||||||
|
float2 checker = floor(input.worldPos.xz * 0.5);
|
||||||
|
float check = frac((checker.x + checker.y) * 0.5) * 2.0;
|
||||||
|
faceColor *= (0.85 + 0.15 * check);
|
||||||
|
return float4(faceColor, 1.0);
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── NORMAL MODE: triplanar textured ──
|
||||||
|
float3 N = normalize(input.normal);
|
||||||
|
float3 L = normalize(-sunDirection.xyz);
|
||||||
|
float NdotL = max(dot(N, L), 0.0);
|
||||||
|
|
||||||
|
float3 baseColor = N * 0.5 + 0.5;
|
||||||
|
|
||||||
|
uint texIndex = clamp(input.materialID - 1u, 0u, 4u);
|
||||||
|
float tiling = textureTiling;
|
||||||
|
float3 texColor = sampleTriplanar(input.worldPos, N, texIndex, tiling);
|
||||||
|
|
||||||
|
float3 albedo = (input.materialID > 0u) ? texColor : baseColor;
|
||||||
|
|
||||||
|
float3 ambient = float3(0.15, 0.18, 0.25);
|
||||||
|
float3 diffuse = sunColor.rgb * NdotL;
|
||||||
|
float3 color = albedo * (ambient + diffuse) * input.ao;
|
||||||
|
|
||||||
|
float dist = length(input.worldPos - cameraPosition.xyz);
|
||||||
|
float fog = 1.0 - exp(-dist * 0.003);
|
||||||
|
float3 fogColor = float3(0.55, 0.70, 0.90);
|
||||||
|
color = lerp(color, fogColor, saturate(fog));
|
||||||
|
|
||||||
|
return float4(color, 1.0);
|
||||||
|
}
|
||||||
127
shaders/voxelVS.hlsl
Normal file
127
shaders/voxelVS.hlsl
Normal file
|
|
@ -0,0 +1,127 @@
|
||||||
|
// BVLE Voxels - Vertex Shader (Vertex Pulling from mega-buffer)
|
||||||
|
// Phase 2: uses SV_InstanceID to look up chunk info instead of push constants.
|
||||||
|
|
||||||
|
#include "voxelCommon.hlsli"
|
||||||
|
|
||||||
|
struct PackedQuad {
|
||||||
|
uint2 data; // 8 bytes = 2 x uint32
|
||||||
|
};
|
||||||
|
|
||||||
|
StructuredBuffer<PackedQuad> quadBuffer : register(t0);
|
||||||
|
StructuredBuffer<GPUChunkInfo> chunkInfoBuffer : register(t2);
|
||||||
|
|
||||||
|
// Push constants: chunk index + quad offset for current draw call
|
||||||
|
struct VoxelPush {
|
||||||
|
uint chunkIndex;
|
||||||
|
uint quadOffset; // offset into mega quad buffer (in quads)
|
||||||
|
uint pad0, pad1, pad2, pad3, pad4, pad5, pad6, pad7, pad8, pad9;
|
||||||
|
};
|
||||||
|
[[vk::push_constant]] ConstantBuffer<VoxelPush> push : register(b999);
|
||||||
|
|
||||||
|
struct VSOutput {
|
||||||
|
float4 position : SV_POSITION;
|
||||||
|
float3 worldPos : WORLDPOS;
|
||||||
|
float3 normal : NORMAL;
|
||||||
|
float2 uv : TEXCOORD0;
|
||||||
|
nointerpolation uint materialID : MATERIALID;
|
||||||
|
nointerpolation uint faceID : FACEID;
|
||||||
|
nointerpolation float debugFlag : DEBUGFLAG;
|
||||||
|
float ao : AO;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Unpack 64 bits from 2 x uint32
|
||||||
|
void unpackQuad(uint2 raw, out uint px, out uint py, out uint pz,
|
||||||
|
out uint w, out uint h, out uint face,
|
||||||
|
out uint matID, out uint ao)
|
||||||
|
{
|
||||||
|
uint lo = raw.x;
|
||||||
|
uint hi = raw.y;
|
||||||
|
px = lo & 0x3F;
|
||||||
|
py = (lo >> 6) & 0x3F;
|
||||||
|
pz = (lo >> 12) & 0x3F;
|
||||||
|
w = (lo >> 18) & 0x3F;
|
||||||
|
h = (lo >> 24) & 0x3F;
|
||||||
|
face = ((lo >> 30) & 0x3) | ((hi & 0x1) << 2);
|
||||||
|
matID = (hi >> 1) & 0xFF;
|
||||||
|
ao = (hi >> 9) & 0xFF;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Face normals: +X, -X, +Y, -Y, +Z, -Z
|
||||||
|
static const float3 faceNormals[6] = {
|
||||||
|
float3( 1, 0, 0), float3(-1, 0, 0),
|
||||||
|
float3( 0, 1, 0), float3( 0,-1, 0),
|
||||||
|
float3( 0, 0, 1), float3( 0, 0,-1)
|
||||||
|
};
|
||||||
|
|
||||||
|
// Face U/V tangent axes for quad expansion
|
||||||
|
static const float3 faceU[6] = {
|
||||||
|
float3(0, 1, 0), float3(0, 1, 0),
|
||||||
|
float3(1, 0, 0), float3(1, 0, 0),
|
||||||
|
float3(1, 0, 0), float3(1, 0, 0)
|
||||||
|
};
|
||||||
|
|
||||||
|
static const float3 faceV[6] = {
|
||||||
|
float3(0, 0, 1), float3(0, 0, 1),
|
||||||
|
float3(0, 0, 1), float3(0, 0, 1),
|
||||||
|
float3(0, 1, 0), float3(0, 1, 0)
|
||||||
|
};
|
||||||
|
|
||||||
|
[RootSignature(VOXEL_ROOTSIG)]
|
||||||
|
VSOutput main(uint vertexID : SV_VertexID)
|
||||||
|
{
|
||||||
|
VSOutput output;
|
||||||
|
|
||||||
|
// Look up chunk info via push constant (SV_InstanceID doesn't include StartInstanceLocation in D3D12)
|
||||||
|
GPUChunkInfo info = chunkInfoBuffer[push.chunkIndex];
|
||||||
|
|
||||||
|
// 6 vertices per quad (2 triangles)
|
||||||
|
// Use push.quadOffset instead of relying on StartVertexLocation in SV_VertexID
|
||||||
|
uint localVertex = vertexID;
|
||||||
|
uint quadIndex = push.quadOffset + (localVertex / 6);
|
||||||
|
uint cornerIndex = localVertex % 6;
|
||||||
|
|
||||||
|
PackedQuad packed = quadBuffer[quadIndex];
|
||||||
|
uint px, py, pz, w, h, face, matID, ao;
|
||||||
|
unpackQuad(packed.data, px, py, pz, w, h, face, matID, ao);
|
||||||
|
|
||||||
|
// Corner offsets for 2 triangles (6 vertices per quad)
|
||||||
|
// cross(U,V) matches N for faces: +X(0), -Y(3), +Z(4) -> CW corners
|
||||||
|
// cross(U,V) opposes N for faces: -X(1), +Y(2), -Z(5) -> CCW corners
|
||||||
|
static const float2 cornersCW[6] = {
|
||||||
|
float2(0, 0), float2(0, 1), float2(1, 0),
|
||||||
|
float2(1, 0), float2(0, 1), float2(1, 1)
|
||||||
|
};
|
||||||
|
static const float2 cornersCCW[6] = {
|
||||||
|
float2(0, 0), float2(1, 0), float2(0, 1),
|
||||||
|
float2(0, 1), float2(1, 0), float2(1, 1)
|
||||||
|
};
|
||||||
|
bool useCCW = (face == 1 || face == 2 || face == 5);
|
||||||
|
float2 corner = useCCW ? cornersCCW[cornerIndex] : cornersCW[cornerIndex];
|
||||||
|
|
||||||
|
float3 basePos = float3((float)px, (float)py, (float)pz);
|
||||||
|
float3 normal = faceNormals[face];
|
||||||
|
float3 uAxis = faceU[face];
|
||||||
|
float3 vAxis = faceV[face];
|
||||||
|
|
||||||
|
// Positive faces: offset by 1 in normal direction
|
||||||
|
float3 faceOffset = (face % 2 == 0) ? normal : float3(0, 0, 0);
|
||||||
|
|
||||||
|
// Expand quad
|
||||||
|
float3 localPos = basePos + faceOffset + uAxis * corner.x * (float)w + vAxis * corner.y * (float)h;
|
||||||
|
float3 worldPos = localPos + info.worldPos.xyz;
|
||||||
|
|
||||||
|
output.position = mul(viewProjection, float4(worldPos, 1.0));
|
||||||
|
output.worldPos = worldPos;
|
||||||
|
output.normal = normal;
|
||||||
|
output.uv = corner * float2((float)w, (float)h) * textureTiling;
|
||||||
|
output.materialID = matID;
|
||||||
|
output.faceID = face;
|
||||||
|
output.debugFlag = info.worldPos.w;
|
||||||
|
|
||||||
|
// AO: 4 corners x 2 bits
|
||||||
|
uint aoCorner = min(cornerIndex, 3u);
|
||||||
|
float aoValue = (float)((ao >> (aoCorner * 2u)) & 3u) / 3.0;
|
||||||
|
output.ao = 1.0 - aoValue * 0.4;
|
||||||
|
|
||||||
|
return output;
|
||||||
|
}
|
||||||
187
src/app/main.cpp
Normal file
187
src/app/main.cpp
Normal file
|
|
@ -0,0 +1,187 @@
|
||||||
|
#include "WickedEngine.h"
|
||||||
|
#include "voxel/VoxelRenderer.h"
|
||||||
|
#include <fstream>
|
||||||
|
#include <DbgHelp.h>
|
||||||
|
#pragma comment(lib, "dbghelp.lib")
|
||||||
|
|
||||||
|
// ── BVLE Voxels - Prototype Application ─────────────────────────
|
||||||
|
// Wicked Engine based voxel engine prototype for performance validation.
|
||||||
|
|
||||||
|
// ── Crash handler: writes stack trace + minidump on unhandled exception ──
|
||||||
|
static LONG WINAPI CrashHandler(EXCEPTION_POINTERS* ep) {
|
||||||
|
std::ofstream crash("bvle_crash.log", std::ios::trunc);
|
||||||
|
crash << "=== BVLE CRASH REPORT ===" << std::endl;
|
||||||
|
|
||||||
|
DWORD code = ep->ExceptionRecord->ExceptionCode;
|
||||||
|
PVOID addr = ep->ExceptionRecord->ExceptionAddress;
|
||||||
|
crash << "Exception code: 0x" << std::hex << code << std::endl;
|
||||||
|
crash << "Crash address: 0x" << addr << std::endl;
|
||||||
|
|
||||||
|
if (code == EXCEPTION_ACCESS_VIOLATION && ep->ExceptionRecord->NumberParameters >= 2) {
|
||||||
|
ULONG_PTR type = ep->ExceptionRecord->ExceptionInformation[0];
|
||||||
|
ULONG_PTR target = ep->ExceptionRecord->ExceptionInformation[1];
|
||||||
|
crash << (type == 0 ? "Reading" : "Writing") << " address: 0x" << std::hex << target << std::endl;
|
||||||
|
}
|
||||||
|
|
||||||
|
HANDLE process = GetCurrentProcess();
|
||||||
|
HANDLE thread = GetCurrentThread();
|
||||||
|
SymInitialize(process, NULL, TRUE);
|
||||||
|
|
||||||
|
CONTEXT* ctx = ep->ContextRecord;
|
||||||
|
STACKFRAME64 frame = {};
|
||||||
|
frame.AddrPC.Offset = ctx->Rip; frame.AddrPC.Mode = AddrModeFlat;
|
||||||
|
frame.AddrFrame.Offset = ctx->Rbp; frame.AddrFrame.Mode = AddrModeFlat;
|
||||||
|
frame.AddrStack.Offset = ctx->Rsp; frame.AddrStack.Mode = AddrModeFlat;
|
||||||
|
|
||||||
|
crash << "\nStack trace:" << std::endl;
|
||||||
|
for (int i = 0; i < 32; i++) {
|
||||||
|
if (!StackWalk64(IMAGE_FILE_MACHINE_AMD64, process, thread, &frame,
|
||||||
|
ctx, NULL, SymFunctionTableAccess64, SymGetModuleBase64, NULL))
|
||||||
|
break;
|
||||||
|
char symbolBuf[sizeof(SYMBOL_INFO) + 256];
|
||||||
|
SYMBOL_INFO* symbol = (SYMBOL_INFO*)symbolBuf;
|
||||||
|
symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
|
||||||
|
symbol->MaxNameLen = 255;
|
||||||
|
DWORD64 disp64 = 0;
|
||||||
|
crash << " [" << i << "] 0x" << std::hex << frame.AddrPC.Offset;
|
||||||
|
if (SymFromAddr(process, frame.AddrPC.Offset, &disp64, symbol))
|
||||||
|
crash << " " << symbol->Name << " +0x" << disp64;
|
||||||
|
IMAGEHLP_LINE64 line = {}; line.SizeOfStruct = sizeof(IMAGEHLP_LINE64);
|
||||||
|
DWORD disp32 = 0;
|
||||||
|
if (SymGetLineFromAddr64(process, frame.AddrPC.Offset, &disp32, &line))
|
||||||
|
crash << " (" << line.FileName << ":" << std::dec << line.LineNumber << ")";
|
||||||
|
crash << std::endl;
|
||||||
|
}
|
||||||
|
|
||||||
|
HANDLE dumpFile = CreateFileA("bvle_crash.dmp", GENERIC_WRITE, 0, NULL,
|
||||||
|
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
||||||
|
if (dumpFile != INVALID_HANDLE_VALUE) {
|
||||||
|
MINIDUMP_EXCEPTION_INFORMATION mei;
|
||||||
|
mei.ThreadId = GetCurrentThreadId();
|
||||||
|
mei.ExceptionPointers = ep;
|
||||||
|
mei.ClientPointers = FALSE;
|
||||||
|
MiniDumpWriteDump(process, GetCurrentProcessId(), dumpFile,
|
||||||
|
MiniDumpWithDataSegs, &mei, NULL, NULL);
|
||||||
|
CloseHandle(dumpFile);
|
||||||
|
}
|
||||||
|
|
||||||
|
crash.close();
|
||||||
|
SymCleanup(process);
|
||||||
|
return EXCEPTION_EXECUTE_HANDLER;
|
||||||
|
}
|
||||||
|
|
||||||
|
static wi::Application application;
|
||||||
|
static voxel::VoxelRenderPath renderPath;
|
||||||
|
|
||||||
|
int APIENTRY wWinMain(
|
||||||
|
_In_ HINSTANCE hInstance,
|
||||||
|
_In_opt_ HINSTANCE hPrevInstance,
|
||||||
|
_In_ LPWSTR lpCmdLine,
|
||||||
|
_In_ int nCmdShow)
|
||||||
|
{
|
||||||
|
SetUnhandledExceptionFilter(CrashHandler);
|
||||||
|
|
||||||
|
// Win32 window setup
|
||||||
|
static auto WndProc = [](HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) -> LRESULT
|
||||||
|
{
|
||||||
|
switch (message)
|
||||||
|
{
|
||||||
|
case WM_SIZE:
|
||||||
|
case WM_DPICHANGED:
|
||||||
|
if (application.is_window_active)
|
||||||
|
application.SetWindow(hWnd);
|
||||||
|
break;
|
||||||
|
case WM_CHAR:
|
||||||
|
switch (wParam)
|
||||||
|
{
|
||||||
|
case VK_BACK:
|
||||||
|
wi::gui::TextInputField::DeleteFromInput();
|
||||||
|
break;
|
||||||
|
case VK_RETURN:
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
wi::gui::TextInputField::AddInput((const wchar_t)wParam);
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
break;
|
||||||
|
case WM_INPUT:
|
||||||
|
wi::input::rawinput::ParseMessage((void*)lParam);
|
||||||
|
break;
|
||||||
|
case WM_KILLFOCUS:
|
||||||
|
application.is_window_active = false;
|
||||||
|
break;
|
||||||
|
case WM_SETFOCUS:
|
||||||
|
application.is_window_active = true;
|
||||||
|
break;
|
||||||
|
case WM_DESTROY:
|
||||||
|
PostQuitMessage(0);
|
||||||
|
break;
|
||||||
|
default:
|
||||||
|
return DefWindowProc(hWnd, message, wParam, lParam);
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
};
|
||||||
|
|
||||||
|
SetProcessDpiAwarenessContext(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
|
||||||
|
|
||||||
|
WNDCLASSEXW wcex = {};
|
||||||
|
wcex.cbSize = sizeof(WNDCLASSEX);
|
||||||
|
wcex.style = CS_HREDRAW | CS_VREDRAW;
|
||||||
|
wcex.lpfnWndProc = WndProc;
|
||||||
|
wcex.hInstance = hInstance;
|
||||||
|
wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
|
||||||
|
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
|
||||||
|
wcex.lpszClassName = L"BVLEVoxels";
|
||||||
|
RegisterClassExW(&wcex);
|
||||||
|
|
||||||
|
HWND hWnd = CreateWindowW(
|
||||||
|
wcex.lpszClassName,
|
||||||
|
L"BVLE Voxels - Prototype",
|
||||||
|
WS_OVERLAPPEDWINDOW,
|
||||||
|
CW_USEDEFAULT, 0,
|
||||||
|
1920, 1080,
|
||||||
|
nullptr, nullptr, hInstance, nullptr
|
||||||
|
);
|
||||||
|
ShowWindow(hWnd, SW_SHOWMAXIMIZED);
|
||||||
|
|
||||||
|
// Initialize Wicked Engine (selects DX12 by default on Windows, Vulkan on Linux)
|
||||||
|
// Pass "vulkan" as command line argument to force Vulkan backend
|
||||||
|
// Pass "debugdevice" for D3D debug layer, "gpuvalidation" for GPU-based validation
|
||||||
|
application.SetWindow(hWnd);
|
||||||
|
wi::arguments::Parse(lpCmdLine);
|
||||||
|
|
||||||
|
|
||||||
|
// Redirect Wicked Engine log to file
|
||||||
|
wi::backlog::SetLogFile("bvle_backlog.txt");
|
||||||
|
|
||||||
|
// Info display
|
||||||
|
application.infoDisplay.active = true;
|
||||||
|
application.infoDisplay.watermark = false;
|
||||||
|
application.infoDisplay.resolution = true;
|
||||||
|
application.infoDisplay.fpsinfo = true;
|
||||||
|
application.infoDisplay.heap_allocation_counter = true;
|
||||||
|
|
||||||
|
// Check for "debug" argument to enable face-color debug mode
|
||||||
|
if (wi::arguments::HasArgument("debug")) {
|
||||||
|
renderPath.debugMode = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Activate our custom voxel render path
|
||||||
|
application.ActivatePath(&renderPath);
|
||||||
|
|
||||||
|
// Main loop
|
||||||
|
MSG msg = { 0 };
|
||||||
|
while (msg.message != WM_QUIT)
|
||||||
|
{
|
||||||
|
if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
|
||||||
|
TranslateMessage(&msg);
|
||||||
|
DispatchMessage(&msg);
|
||||||
|
}
|
||||||
|
else {
|
||||||
|
application.Run();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
wi::jobsystem::ShutDown();
|
||||||
|
return (int)msg.wParam;
|
||||||
|
}
|
||||||
238
src/voxel/VoxelMesher.cpp
Normal file
238
src/voxel/VoxelMesher.cpp
Normal file
|
|
@ -0,0 +1,238 @@
|
||||||
|
#include "VoxelMesher.h"
|
||||||
|
#include <cstring>
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
|
namespace voxel {
|
||||||
|
|
||||||
|
// ── Build binary masks per axis ─────────────────────────────────
|
||||||
|
// For each axis, solid[u][v] is a 32-bit mask where bit i=1 means
|
||||||
|
// voxel at position i along that axis is solid.
|
||||||
|
void VoxelMesher::buildAxisMasks(const Chunk& chunk, AxisMasks masks[3]) {
|
||||||
|
std::memset(masks, 0, sizeof(AxisMasks) * 3);
|
||||||
|
|
||||||
|
for (int z = 0; z < CHUNK_SIZE; z++) {
|
||||||
|
for (int y = 0; y < CHUNK_SIZE; y++) {
|
||||||
|
for (int x = 0; x < CHUNK_SIZE; x++) {
|
||||||
|
if (!chunk.at(x, y, z).isEmpty()) {
|
||||||
|
// X-axis: march along X, indexed by [Y][Z]
|
||||||
|
masks[0].solid[y][z] |= (1u << x);
|
||||||
|
// Y-axis: march along Y, indexed by [X][Z]
|
||||||
|
masks[1].solid[x][z] |= (1u << y);
|
||||||
|
// Z-axis: march along Z, indexed by [X][Y]
|
||||||
|
masks[2].solid[x][y] |= (1u << z);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Helper: get voxel, considering neighbor chunks for boundary faces
|
||||||
|
static VoxelData getVoxelSafe(const Chunk& chunk, const VoxelWorld& world, int x, int y, int z) {
|
||||||
|
if (chunk.isInBounds(x, y, z)) {
|
||||||
|
return chunk.at(x, y, z);
|
||||||
|
}
|
||||||
|
// Cross-chunk lookup
|
||||||
|
int wx = chunk.pos.x * CHUNK_SIZE + x;
|
||||||
|
int wy = chunk.pos.y * CHUNK_SIZE + y;
|
||||||
|
int wz = chunk.pos.z * CHUNK_SIZE + z;
|
||||||
|
return world.getVoxel(wx, wy, wz);
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── Greedy Merge ────────────────────────────────────────────────
|
||||||
|
// For a given face direction, merge visible faces of the same material
|
||||||
|
// into maximal rectangular quads.
|
||||||
|
void VoxelMesher::greedyMerge(
|
||||||
|
const Chunk& chunk,
|
||||||
|
const VoxelWorld& world,
|
||||||
|
uint8_t face,
|
||||||
|
const uint32_t faceMasks[CHUNK_SIZE][CHUNK_SIZE],
|
||||||
|
std::vector<PackedQuad>& outQuads
|
||||||
|
) {
|
||||||
|
// Determine axis mapping based on face
|
||||||
|
// face 0,1 = X axis -> iterate over Y,Z slices
|
||||||
|
// face 2,3 = Y axis -> iterate over X,Z slices
|
||||||
|
// face 4,5 = Z axis -> iterate over X,Y slices
|
||||||
|
|
||||||
|
// For each slice along the face normal axis
|
||||||
|
for (int depth = 0; depth < CHUNK_SIZE; depth++) {
|
||||||
|
// Build a 2D grid of material IDs for this slice
|
||||||
|
uint8_t matGrid[CHUNK_SIZE][CHUNK_SIZE];
|
||||||
|
bool visited[CHUNK_SIZE][CHUNK_SIZE];
|
||||||
|
std::memset(matGrid, 0, sizeof(matGrid));
|
||||||
|
std::memset(visited, 0, sizeof(visited));
|
||||||
|
|
||||||
|
int faceCount = 0;
|
||||||
|
for (int v = 0; v < CHUNK_SIZE; v++) {
|
||||||
|
for (int u = 0; u < CHUNK_SIZE; u++) {
|
||||||
|
// Check if this face is visible at this depth
|
||||||
|
bool faceVisible = false;
|
||||||
|
|
||||||
|
int x, y, z;
|
||||||
|
switch (face) {
|
||||||
|
case FACE_POS_X: x = depth; y = u; z = v; faceVisible = (faceMasks[u][v] >> depth) & 1; break;
|
||||||
|
case FACE_NEG_X: x = depth; y = u; z = v; faceVisible = (faceMasks[u][v] >> depth) & 1; break;
|
||||||
|
case FACE_POS_Y: y = depth; x = u; z = v; faceVisible = (faceMasks[u][v] >> depth) & 1; break;
|
||||||
|
case FACE_NEG_Y: y = depth; x = u; z = v; faceVisible = (faceMasks[u][v] >> depth) & 1; break;
|
||||||
|
case FACE_POS_Z: z = depth; x = u; y = v; faceVisible = (faceMasks[u][v] >> depth) & 1; break;
|
||||||
|
case FACE_NEG_Z: z = depth; x = u; y = v; faceVisible = (faceMasks[u][v] >> depth) & 1; break;
|
||||||
|
}
|
||||||
|
|
||||||
|
if (faceVisible) {
|
||||||
|
matGrid[v][u] = chunk.at(x, y, z).getMaterialID();
|
||||||
|
faceCount++;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
if (faceCount == 0) continue;
|
||||||
|
|
||||||
|
// Greedy merge: scan row by row, merge same-material quads
|
||||||
|
for (int v = 0; v < CHUNK_SIZE; v++) {
|
||||||
|
for (int u = 0; u < CHUNK_SIZE; u++) {
|
||||||
|
if (visited[v][u] || matGrid[v][u] == 0) continue;
|
||||||
|
|
||||||
|
uint8_t mat = matGrid[v][u];
|
||||||
|
|
||||||
|
// Expand width (along u)
|
||||||
|
int w = 1;
|
||||||
|
while (u + w < CHUNK_SIZE && !visited[v][u + w] && matGrid[v][u + w] == mat) {
|
||||||
|
w++;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Expand height (along v)
|
||||||
|
int h = 1;
|
||||||
|
bool canExpand = true;
|
||||||
|
while (v + h < CHUNK_SIZE && canExpand) {
|
||||||
|
for (int du = 0; du < w; du++) {
|
||||||
|
if (visited[v + h][u + du] || matGrid[v + h][u + du] != mat) {
|
||||||
|
canExpand = false;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if (canExpand) h++;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Mark as visited
|
||||||
|
for (int dv = 0; dv < h; dv++) {
|
||||||
|
for (int du = 0; du < w; du++) {
|
||||||
|
visited[v + dv][u + du] = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Compute the actual position in chunk-local coords
|
||||||
|
uint8_t px, py, pz;
|
||||||
|
switch (face) {
|
||||||
|
case FACE_POS_X: px = (uint8_t)depth; py = (uint8_t)u; pz = (uint8_t)v; break;
|
||||||
|
case FACE_NEG_X: px = (uint8_t)depth; py = (uint8_t)u; pz = (uint8_t)v; break;
|
||||||
|
case FACE_POS_Y: px = (uint8_t)u; py = (uint8_t)depth; pz = (uint8_t)v; break;
|
||||||
|
case FACE_NEG_Y: px = (uint8_t)u; py = (uint8_t)depth; pz = (uint8_t)v; break;
|
||||||
|
case FACE_POS_Z: px = (uint8_t)u; py = (uint8_t)v; pz = (uint8_t)depth; break;
|
||||||
|
case FACE_NEG_Z: px = (uint8_t)u; py = (uint8_t)v; pz = (uint8_t)depth; break;
|
||||||
|
default: px = py = pz = 0; break;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Width/height in the quad's local UV space
|
||||||
|
uint8_t qw, qh;
|
||||||
|
switch (face) {
|
||||||
|
case FACE_POS_X: case FACE_NEG_X: qw = (uint8_t)w; qh = (uint8_t)h; break;
|
||||||
|
case FACE_POS_Y: case FACE_NEG_Y: qw = (uint8_t)w; qh = (uint8_t)h; break;
|
||||||
|
case FACE_POS_Z: case FACE_NEG_Z: qw = (uint8_t)w; qh = (uint8_t)h; break;
|
||||||
|
default: qw = qh = 1; break;
|
||||||
|
}
|
||||||
|
|
||||||
|
outQuads.push_back(PackedQuad::create(
|
||||||
|
px, py, pz, qw, qh, face, mat, 0, 0
|
||||||
|
));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t VoxelMesher::meshChunk(Chunk& chunk, const VoxelWorld& world) {
|
||||||
|
chunk.quads.clear();
|
||||||
|
|
||||||
|
// Step 1: Build binary solid masks per axis
|
||||||
|
AxisMasks axisMasks[3];
|
||||||
|
buildAxisMasks(chunk, axisMasks);
|
||||||
|
|
||||||
|
// Step 2: For each face direction, compute visible face masks
|
||||||
|
// then do greedy merge
|
||||||
|
for (uint8_t face = 0; face < FACE_COUNT; face++) {
|
||||||
|
int axis = face / 2; // 0=X, 1=Y, 2=Z
|
||||||
|
bool positive = (face % 2 == 0);
|
||||||
|
|
||||||
|
// Compute visible face masks
|
||||||
|
// A face is visible if the voxel is solid and the neighbor in the face direction is air
|
||||||
|
uint32_t faceMasks[CHUNK_SIZE][CHUNK_SIZE];
|
||||||
|
std::memset(faceMasks, 0, sizeof(faceMasks));
|
||||||
|
|
||||||
|
for (int v = 0; v < CHUNK_SIZE; v++) {
|
||||||
|
for (int u = 0; u < CHUNK_SIZE; u++) {
|
||||||
|
uint32_t solid = axisMasks[axis].solid[u][v];
|
||||||
|
if (solid == 0) continue;
|
||||||
|
|
||||||
|
uint32_t visible;
|
||||||
|
if (positive) {
|
||||||
|
// +dir: face visible if solid here and NOT solid at pos+1
|
||||||
|
// Shift right: neighbor is at bit+1
|
||||||
|
uint32_t neighbor = (solid >> 1);
|
||||||
|
// The highest bit has no neighbor in this chunk - check boundary
|
||||||
|
visible = solid & ~neighbor;
|
||||||
|
// Bit 31 (chunk boundary): need to check neighbor chunk
|
||||||
|
// For now, always show boundary faces
|
||||||
|
if (solid & (1u << (CHUNK_SIZE - 1))) {
|
||||||
|
// Check if neighbor chunk's voxel is empty
|
||||||
|
int nx, ny, nz;
|
||||||
|
switch (axis) {
|
||||||
|
case 0: nx = CHUNK_SIZE; ny = u; nz = v; break; // X+
|
||||||
|
case 1: nx = u; ny = CHUNK_SIZE; nz = v; break; // Y+
|
||||||
|
case 2: nx = u; ny = v; nz = CHUNK_SIZE; break; // Z+
|
||||||
|
default: nx = ny = nz = 0;
|
||||||
|
}
|
||||||
|
if (!getVoxelSafe(chunk, world, nx, ny, nz).isEmpty()) {
|
||||||
|
visible &= ~(1u << (CHUNK_SIZE - 1)); // hide boundary face
|
||||||
|
}
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// -dir: face visible if solid here and NOT solid at pos-1
|
||||||
|
uint32_t neighbor = (solid << 1);
|
||||||
|
visible = solid & ~neighbor;
|
||||||
|
// Bit 0 (chunk boundary)
|
||||||
|
if (solid & 1u) {
|
||||||
|
int nx, ny, nz;
|
||||||
|
switch (axis) {
|
||||||
|
case 0: nx = -1; ny = u; nz = v; break;
|
||||||
|
case 1: nx = u; ny = -1; nz = v; break;
|
||||||
|
case 2: nx = u; ny = v; nz = -1; break;
|
||||||
|
default: nx = ny = nz = 0;
|
||||||
|
}
|
||||||
|
if (!getVoxelSafe(chunk, world, nx, ny, nz).isEmpty()) {
|
||||||
|
visible &= ~1u; // hide boundary face
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
faceMasks[u][v] = visible;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
uint32_t beforeCount = (uint32_t)chunk.quads.size();
|
||||||
|
greedyMerge(chunk, world, face, faceMasks, chunk.quads);
|
||||||
|
chunk.faceOffsets[face] = beforeCount;
|
||||||
|
chunk.faceCounts[face] = (uint32_t)chunk.quads.size() - beforeCount;
|
||||||
|
}
|
||||||
|
|
||||||
|
chunk.quadCount = (uint32_t)chunk.quads.size();
|
||||||
|
chunk.dirty = false;
|
||||||
|
return chunk.quadCount;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t VoxelMesher::calcAO(const VoxelWorld& world, const ChunkPos& cpos,
|
||||||
|
int x, int y, int z, uint8_t face) {
|
||||||
|
// Simplified AO: count occluding neighbors around the vertex
|
||||||
|
// Returns packed 4x2-bit AO for the 4 corners
|
||||||
|
// TODO: implement proper per-corner AO
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace voxel
|
||||||
40
src/voxel/VoxelMesher.h
Normal file
40
src/voxel/VoxelMesher.h
Normal file
|
|
@ -0,0 +1,40 @@
|
||||||
|
#pragma once
|
||||||
|
#include "VoxelTypes.h"
|
||||||
|
#include "VoxelWorld.h"
|
||||||
|
|
||||||
|
namespace voxel {
|
||||||
|
|
||||||
|
// ── Binary Greedy Mesher (CPU implementation, port of cgerikj) ──
|
||||||
|
// Generates PackedQuad list for a chunk using binary greedy meshing.
|
||||||
|
// For each axis, uses bitmask operations to find visible faces,
|
||||||
|
// then greedily merges same-material quads.
|
||||||
|
class VoxelMesher {
|
||||||
|
public:
|
||||||
|
// Mesh a single chunk, populating chunk.quads
|
||||||
|
// Returns number of quads generated
|
||||||
|
static uint32_t meshChunk(Chunk& chunk, const VoxelWorld& world);
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Per-axis binary face culling
|
||||||
|
// col_masks[axis][u][v] = 32-bit mask of solid voxels along axis
|
||||||
|
struct AxisMasks {
|
||||||
|
uint32_t solid[CHUNK_SIZE][CHUNK_SIZE]; // solid[u][v] = bitmask along axis
|
||||||
|
};
|
||||||
|
|
||||||
|
static void buildAxisMasks(const Chunk& chunk, AxisMasks masks[3]);
|
||||||
|
|
||||||
|
// Greedy merge faces of same material into larger quads
|
||||||
|
static void greedyMerge(
|
||||||
|
const Chunk& chunk,
|
||||||
|
const VoxelWorld& world,
|
||||||
|
uint8_t face,
|
||||||
|
const uint32_t faceMasks[CHUNK_SIZE][CHUNK_SIZE],
|
||||||
|
std::vector<PackedQuad>& outQuads
|
||||||
|
);
|
||||||
|
|
||||||
|
// Calculate ambient occlusion for quad corners
|
||||||
|
static uint8_t calcAO(const VoxelWorld& world, const ChunkPos& cpos,
|
||||||
|
int x, int y, int z, uint8_t face);
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace voxel
|
||||||
597
src/voxel/VoxelRenderer.cpp
Normal file
597
src/voxel/VoxelRenderer.cpp
Normal file
|
|
@ -0,0 +1,597 @@
|
||||||
|
#include "VoxelRenderer.h"
|
||||||
|
#include "wiPrimitive.h"
|
||||||
|
#include <algorithm>
|
||||||
|
#include <cmath>
|
||||||
|
|
||||||
|
using namespace wi::graphics;
|
||||||
|
|
||||||
|
namespace voxel {
|
||||||
|
|
||||||
|
// ── VoxelRenderer Implementation ────────────────────────────────
|
||||||
|
|
||||||
|
VoxelRenderer::VoxelRenderer() = default;
|
||||||
|
VoxelRenderer::~VoxelRenderer() { shutdown(); }
|
||||||
|
|
||||||
|
void VoxelRenderer::initialize(GraphicsDevice* dev) {
|
||||||
|
device_ = dev;
|
||||||
|
if (!device_) return;
|
||||||
|
|
||||||
|
createPipeline();
|
||||||
|
if (!pso_.IsValid()) {
|
||||||
|
wi::backlog::post("VoxelRenderer: pipeline creation failed", wi::backlog::LogLevel::Error);
|
||||||
|
initialized_ = false;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
generateTextures();
|
||||||
|
|
||||||
|
// Create mega quad buffer (SRV for vertex pulling)
|
||||||
|
GPUBufferDesc megaDesc;
|
||||||
|
megaDesc.size = MEGA_BUFFER_CAPACITY * sizeof(PackedQuad);
|
||||||
|
megaDesc.bind_flags = BindFlag::SHADER_RESOURCE;
|
||||||
|
megaDesc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
|
||||||
|
megaDesc.stride = sizeof(PackedQuad);
|
||||||
|
megaDesc.usage = Usage::DEFAULT;
|
||||||
|
device_->CreateBuffer(&megaDesc, nullptr, &megaQuadBuffer_);
|
||||||
|
|
||||||
|
// Create chunk info buffer (SRV for VS chunk lookup)
|
||||||
|
GPUBufferDesc infoDesc;
|
||||||
|
infoDesc.size = MAX_CHUNKS * sizeof(GPUChunkInfo);
|
||||||
|
infoDesc.bind_flags = BindFlag::SHADER_RESOURCE;
|
||||||
|
infoDesc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
|
||||||
|
infoDesc.stride = sizeof(GPUChunkInfo);
|
||||||
|
infoDesc.usage = Usage::DEFAULT;
|
||||||
|
device_->CreateBuffer(&infoDesc, nullptr, &chunkInfoBuffer_);
|
||||||
|
|
||||||
|
// Create indirect args buffer (for DrawInstancedIndirectCount, up to 6 draws per chunk)
|
||||||
|
// UAV bind flag needed for GPU cull compute shader to write args
|
||||||
|
GPUBufferDesc argsDesc;
|
||||||
|
argsDesc.size = MAX_DRAWS * sizeof(IndirectDrawArgs);
|
||||||
|
argsDesc.bind_flags = BindFlag::UNORDERED_ACCESS;
|
||||||
|
argsDesc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED | ResourceMiscFlag::INDIRECT_ARGS;
|
||||||
|
argsDesc.stride = sizeof(IndirectDrawArgs);
|
||||||
|
argsDesc.usage = Usage::DEFAULT;
|
||||||
|
device_->CreateBuffer(&argsDesc, nullptr, &indirectArgsBuffer_);
|
||||||
|
|
||||||
|
// Create draw count buffer (single uint32, raw for RWByteAddressBuffer)
|
||||||
|
// UAV bind flag needed for GPU cull compute shader atomic counter
|
||||||
|
GPUBufferDesc countDesc;
|
||||||
|
countDesc.size = sizeof(uint32_t);
|
||||||
|
countDesc.bind_flags = BindFlag::UNORDERED_ACCESS;
|
||||||
|
countDesc.misc_flags = ResourceMiscFlag::BUFFER_RAW | ResourceMiscFlag::INDIRECT_ARGS;
|
||||||
|
countDesc.usage = Usage::DEFAULT;
|
||||||
|
device_->CreateBuffer(&countDesc, nullptr, &drawCountBuffer_);
|
||||||
|
|
||||||
|
// ── GPU Timestamp Queries ──────────────────────────────────────
|
||||||
|
GPUQueryHeapDesc queryDesc;
|
||||||
|
queryDesc.type = GpuQueryType::TIMESTAMP;
|
||||||
|
queryDesc.query_count = TS_COUNT;
|
||||||
|
device_->CreateQueryHeap(&queryDesc, ×tampHeap_);
|
||||||
|
|
||||||
|
GPUBufferDesc readbackDesc;
|
||||||
|
readbackDesc.size = TS_COUNT * sizeof(uint64_t);
|
||||||
|
readbackDesc.usage = Usage::READBACK;
|
||||||
|
device_->CreateBuffer(&readbackDesc, nullptr, ×tampReadback_);
|
||||||
|
|
||||||
|
// ── GPU Compute Mesher resources ─────────────────────────────
|
||||||
|
wi::renderer::LoadShader(ShaderStage::CS, meshShader_, "voxel/voxelMeshCS.cso");
|
||||||
|
gpuMesherAvailable_ = meshShader_.IsValid();
|
||||||
|
if (gpuMesherAvailable_) {
|
||||||
|
// Voxel data buffer: 1 chunk's worth (32^3 voxels / 2 per uint = 16384 uint)
|
||||||
|
GPUBufferDesc voxDesc;
|
||||||
|
voxDesc.size = (CHUNK_VOLUME / 2) * sizeof(uint32_t);
|
||||||
|
voxDesc.bind_flags = BindFlag::SHADER_RESOURCE;
|
||||||
|
voxDesc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
|
||||||
|
voxDesc.stride = sizeof(uint32_t);
|
||||||
|
voxDesc.usage = Usage::DEFAULT;
|
||||||
|
device_->CreateBuffer(&voxDesc, nullptr, &voxelDataBuffer_);
|
||||||
|
|
||||||
|
// GPU quad output: same capacity as mega-buffer
|
||||||
|
GPUBufferDesc gpuQDesc;
|
||||||
|
gpuQDesc.size = MEGA_BUFFER_CAPACITY * sizeof(uint64_t); // PackedQuad = 8 bytes
|
||||||
|
gpuQDesc.bind_flags = BindFlag::UNORDERED_ACCESS;
|
||||||
|
gpuQDesc.misc_flags = ResourceMiscFlag::BUFFER_STRUCTURED;
|
||||||
|
gpuQDesc.stride = sizeof(uint64_t); // uint2 = 8 bytes
|
||||||
|
gpuQDesc.usage = Usage::DEFAULT;
|
||||||
|
device_->CreateBuffer(&gpuQDesc, nullptr, &gpuQuadBuffer_);
|
||||||
|
|
||||||
|
// Quad counter
|
||||||
|
GPUBufferDesc cntDesc;
|
||||||
|
cntDesc.size = sizeof(uint32_t);
|
||||||
|
cntDesc.bind_flags = BindFlag::UNORDERED_ACCESS;
|
||||||
|
cntDesc.misc_flags = ResourceMiscFlag::BUFFER_RAW;
|
||||||
|
cntDesc.usage = Usage::DEFAULT;
|
||||||
|
device_->CreateBuffer(&cntDesc, nullptr, &gpuQuadCounter_);
|
||||||
|
|
||||||
|
wi::backlog::post("VoxelRenderer: GPU compute mesher available");
|
||||||
|
} else {
|
||||||
|
wi::backlog::post("VoxelRenderer: GPU compute mesher not available", wi::backlog::LogLevel::Warning);
|
||||||
|
}
|
||||||
|
|
||||||
|
cpuMegaQuads_.reserve(MEGA_BUFFER_CAPACITY);
|
||||||
|
cpuChunkInfo_.reserve(MAX_CHUNKS);
|
||||||
|
chunkSlots_.reserve(MAX_CHUNKS);
|
||||||
|
cpuIndirectArgs_.reserve(MAX_CHUNKS);
|
||||||
|
|
||||||
|
initialized_ = true;
|
||||||
|
wi::backlog::post("VoxelRenderer: initialized (mega-buffer: "
|
||||||
|
+ std::to_string(MEGA_BUFFER_CAPACITY) + " quads capacity)");
|
||||||
|
}
|
||||||
|
|
||||||
|
void VoxelRenderer::shutdown() {
|
||||||
|
chunkSlots_.clear();
|
||||||
|
cpuChunkInfo_.clear();
|
||||||
|
cpuMegaQuads_.clear();
|
||||||
|
initialized_ = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
void VoxelRenderer::createPipeline() {
|
||||||
|
// Constant buffer for per-frame data
|
||||||
|
GPUBufferDesc cbDesc;
|
||||||
|
cbDesc.size = sizeof(VoxelConstants);
|
||||||
|
cbDesc.bind_flags = BindFlag::CONSTANT_BUFFER;
|
||||||
|
cbDesc.usage = Usage::DEFAULT;
|
||||||
|
device_->CreateBuffer(&cbDesc, nullptr, &constantBuffer_);
|
||||||
|
|
||||||
|
// Anisotropic wrap sampler
|
||||||
|
SamplerDesc samplerDesc;
|
||||||
|
samplerDesc.filter = Filter::ANISOTROPIC;
|
||||||
|
samplerDesc.address_u = TextureAddressMode::WRAP;
|
||||||
|
samplerDesc.address_v = TextureAddressMode::WRAP;
|
||||||
|
samplerDesc.address_w = TextureAddressMode::WRAP;
|
||||||
|
samplerDesc.max_anisotropy = 16;
|
||||||
|
device_->CreateSampler(&samplerDesc, &sampler_);
|
||||||
|
|
||||||
|
// Load shaders
|
||||||
|
wi::renderer::LoadShader(ShaderStage::VS, vertexShader_, "voxel/voxelVS.cso");
|
||||||
|
wi::renderer::LoadShader(ShaderStage::PS, pixelShader_, "voxel/voxelPS.cso");
|
||||||
|
wi::renderer::LoadShader(ShaderStage::CS, cullShader_, "voxel/voxelCullCS.cso");
|
||||||
|
|
||||||
|
if (!vertexShader_.IsValid() || !pixelShader_.IsValid()) {
|
||||||
|
wi::backlog::post("VoxelRenderer: shader loading failed", wi::backlog::LogLevel::Error);
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
gpuCullingEnabled_ = cullShader_.IsValid();
|
||||||
|
if (!gpuCullingEnabled_) {
|
||||||
|
wi::backlog::post("VoxelRenderer: cull compute shader not available, using CPU culling", wi::backlog::LogLevel::Warning);
|
||||||
|
} else {
|
||||||
|
wi::backlog::post("VoxelRenderer: GPU frustum+backface culling enabled");
|
||||||
|
}
|
||||||
|
|
||||||
|
// Pipeline: backface cull, depth test, opaque blend, triangle list
|
||||||
|
PipelineStateDesc psoDesc;
|
||||||
|
psoDesc.vs = &vertexShader_;
|
||||||
|
psoDesc.ps = &pixelShader_;
|
||||||
|
psoDesc.rs = wi::renderer::GetRasterizerState(wi::enums::RSTYPE_FRONT);
|
||||||
|
psoDesc.dss = wi::renderer::GetDepthStencilState(wi::enums::DSSTYPE_DEFAULT);
|
||||||
|
psoDesc.bs = wi::renderer::GetBlendState(wi::enums::BSTYPE_OPAQUE);
|
||||||
|
psoDesc.pt = PrimitiveTopology::TRIANGLELIST;
|
||||||
|
|
||||||
|
device_->CreatePipelineState(&psoDesc, &pso_);
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── Procedural texture generation ───────────────────────────────
|
||||||
|
|
||||||
|
static void generateNoiseTexture(uint8_t* pixels, int w, int h,
|
||||||
|
uint8_t r0, uint8_t g0, uint8_t b0,
|
||||||
|
uint8_t r1, uint8_t g1, uint8_t b1,
|
||||||
|
uint32_t seed)
|
||||||
|
{
|
||||||
|
uint32_t s = seed;
|
||||||
|
for (int y = 0; y < h; y++) {
|
||||||
|
for (int x = 0; x < w; x++) {
|
||||||
|
s = s * 1664525u + 1013904223u;
|
||||||
|
float noise = (float)(s & 0xFFFF) / 65535.0f;
|
||||||
|
float fx = (float)x / w;
|
||||||
|
float fy = (float)y / h;
|
||||||
|
float pattern = 0.5f + 0.5f * std::sin(fx * 20.0f + noise * 3.0f) *
|
||||||
|
std::cos(fy * 20.0f + noise * 3.0f);
|
||||||
|
float t = noise * 0.6f + pattern * 0.4f;
|
||||||
|
|
||||||
|
int idx = (y * w + x) * 4;
|
||||||
|
pixels[idx + 0] = (uint8_t)(r0 + (r1 - r0) * t);
|
||||||
|
pixels[idx + 1] = (uint8_t)(g0 + (g1 - g0) * t);
|
||||||
|
pixels[idx + 2] = (uint8_t)(b0 + (b1 - b0) * t);
|
||||||
|
pixels[idx + 3] = 255;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void VoxelRenderer::generateTextures() {
|
||||||
|
const int TEX_SIZE = 256;
|
||||||
|
const int NUM_MATERIALS = 5;
|
||||||
|
|
||||||
|
std::vector<uint8_t> allPixels(TEX_SIZE * TEX_SIZE * 4 * NUM_MATERIALS);
|
||||||
|
|
||||||
|
struct MatColor { uint8_t r0,g0,b0, r1,g1,b1; uint32_t seed; };
|
||||||
|
MatColor colors[NUM_MATERIALS] = {
|
||||||
|
{ 60, 140, 40, 80, 180, 60, 101 }, // Grass
|
||||||
|
{ 100, 70, 40, 140, 100, 60, 202 }, // Dirt
|
||||||
|
{ 110, 110, 105, 140, 140, 130, 303 }, // Stone
|
||||||
|
{ 200, 190, 140, 230, 220, 170, 404 }, // Sand
|
||||||
|
{ 220, 225, 230, 245, 248, 252, 505 }, // Snow
|
||||||
|
};
|
||||||
|
|
||||||
|
for (int i = 0; i < NUM_MATERIALS; i++) {
|
||||||
|
auto& c = colors[i];
|
||||||
|
generateNoiseTexture(
|
||||||
|
allPixels.data() + i * TEX_SIZE * TEX_SIZE * 4,
|
||||||
|
TEX_SIZE, TEX_SIZE,
|
||||||
|
c.r0, c.g0, c.b0, c.r1, c.g1, c.b1, c.seed
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
TextureDesc texDesc;
|
||||||
|
texDesc.type = TextureDesc::Type::TEXTURE_2D;
|
||||||
|
texDesc.width = TEX_SIZE;
|
||||||
|
texDesc.height = TEX_SIZE;
|
||||||
|
texDesc.array_size = NUM_MATERIALS;
|
||||||
|
texDesc.mip_levels = 1;
|
||||||
|
texDesc.format = Format::R8G8B8A8_UNORM;
|
||||||
|
texDesc.bind_flags = BindFlag::SHADER_RESOURCE;
|
||||||
|
texDesc.usage = Usage::DEFAULT;
|
||||||
|
|
||||||
|
std::vector<SubresourceData> subData(NUM_MATERIALS);
|
||||||
|
for (int i = 0; i < NUM_MATERIALS; i++) {
|
||||||
|
subData[i].data_ptr = allPixels.data() + i * TEX_SIZE * TEX_SIZE * 4;
|
||||||
|
subData[i].row_pitch = TEX_SIZE * 4;
|
||||||
|
subData[i].slice_pitch = TEX_SIZE * TEX_SIZE * 4;
|
||||||
|
}
|
||||||
|
|
||||||
|
device_->CreateTexture(&texDesc, subData.data(), &textureArray_);
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── Mega-buffer rebuild ─────────────────────────────────────────
|
||||||
|
// Packs all chunk quads contiguously into a single buffer.
|
||||||
|
// Simple strategy: full rebuild whenever any chunk is dirty.
|
||||||
|
|
||||||
|
void VoxelRenderer::rebuildMegaBuffer(VoxelWorld& world) {
|
||||||
|
cpuMegaQuads_.clear();
|
||||||
|
chunkSlots_.clear();
|
||||||
|
cpuChunkInfo_.clear();
|
||||||
|
|
||||||
|
uint32_t offset = 0;
|
||||||
|
float debugFlag = debugFaceColors_ ? 1.0f : 0.0f;
|
||||||
|
|
||||||
|
world.forEachChunk([&](const ChunkPos& pos, Chunk& chunk) {
|
||||||
|
if (chunk.quadCount == 0) return;
|
||||||
|
if (offset + chunk.quadCount > MEGA_BUFFER_CAPACITY) return; // overflow guard
|
||||||
|
|
||||||
|
ChunkSlot slot;
|
||||||
|
slot.pos = pos;
|
||||||
|
slot.quadOffset = offset;
|
||||||
|
slot.quadCount = chunk.quadCount;
|
||||||
|
chunkSlots_.push_back(slot);
|
||||||
|
|
||||||
|
GPUChunkInfo info = {};
|
||||||
|
info.worldPos = XMFLOAT4(
|
||||||
|
(float)(pos.x * CHUNK_SIZE),
|
||||||
|
(float)(pos.y * CHUNK_SIZE),
|
||||||
|
(float)(pos.z * CHUNK_SIZE),
|
||||||
|
debugFlag
|
||||||
|
);
|
||||||
|
info.quadOffset = offset;
|
||||||
|
info.quadCount = chunk.quadCount;
|
||||||
|
for (int f = 0; f < 6; f++) {
|
||||||
|
info.faceOffsets[f] = chunk.faceOffsets[f];
|
||||||
|
info.faceCounts[f] = chunk.faceCounts[f];
|
||||||
|
}
|
||||||
|
cpuChunkInfo_.push_back(info);
|
||||||
|
|
||||||
|
cpuMegaQuads_.insert(cpuMegaQuads_.end(), chunk.quads.begin(), chunk.quads.end());
|
||||||
|
offset += chunk.quadCount;
|
||||||
|
});
|
||||||
|
|
||||||
|
chunkCount_ = (uint32_t)chunkSlots_.size();
|
||||||
|
totalQuads_ = offset;
|
||||||
|
}
|
||||||
|
|
||||||
|
void VoxelRenderer::updateMeshes(VoxelWorld& world) {
|
||||||
|
if (!device_) return;
|
||||||
|
|
||||||
|
// Re-mesh dirty chunks
|
||||||
|
bool anyDirty = false;
|
||||||
|
world.forEachChunk([&](const ChunkPos& pos, Chunk& chunk) {
|
||||||
|
if (chunk.dirty) {
|
||||||
|
VoxelMesher::meshChunk(chunk, world);
|
||||||
|
anyDirty = true;
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
if (anyDirty || megaBufferDirty_) {
|
||||||
|
rebuildMegaBuffer(world);
|
||||||
|
megaBufferDirty_ = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── Render pass ─────────────────────────────────────────────────
|
||||||
|
|
||||||
|
void VoxelRenderer::render(
|
||||||
|
CommandList cmd,
|
||||||
|
const wi::scene::CameraComponent& camera,
|
||||||
|
const Texture& depthBuffer,
|
||||||
|
const Texture& renderTarget
|
||||||
|
) const {
|
||||||
|
if (!initialized_ || chunkCount_ == 0 || !pso_.IsValid()) return;
|
||||||
|
|
||||||
|
auto* dev = device_;
|
||||||
|
|
||||||
|
// Upload mega-buffer and chunk info to GPU
|
||||||
|
if (!cpuMegaQuads_.empty()) {
|
||||||
|
dev->UpdateBuffer(&megaQuadBuffer_, cpuMegaQuads_.data(), cmd,
|
||||||
|
cpuMegaQuads_.size() * sizeof(PackedQuad));
|
||||||
|
}
|
||||||
|
if (!cpuChunkInfo_.empty()) {
|
||||||
|
dev->UpdateBuffer(&chunkInfoBuffer_, cpuChunkInfo_.data(), cmd,
|
||||||
|
cpuChunkInfo_.size() * sizeof(GPUChunkInfo));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Per-frame constants
|
||||||
|
VoxelConstants cb = {};
|
||||||
|
XMStoreFloat4x4(&cb.viewProjection, camera.GetViewProjection());
|
||||||
|
cb.cameraPosition = XMFLOAT4(camera.Eye.x, camera.Eye.y, camera.Eye.z, 1.0f);
|
||||||
|
cb.sunDirection = XMFLOAT4(-0.5f, -0.8f, -0.3f, 0.0f);
|
||||||
|
cb.sunColor = XMFLOAT4(1.2f, 1.1f, 0.9f, 1.0f);
|
||||||
|
cb.chunkSize = (float)CHUNK_SIZE;
|
||||||
|
cb.textureTiling = 0.25f;
|
||||||
|
cb.chunkCount = chunkCount_;
|
||||||
|
dev->UpdateBuffer(&constantBuffer_, &cb, cmd, sizeof(cb));
|
||||||
|
|
||||||
|
// CPU frustum culling
|
||||||
|
wi::primitive::Frustum frustum;
|
||||||
|
frustum.Create(camera.GetViewProjection());
|
||||||
|
|
||||||
|
// ── Render pass: color + depth ────────────────────────────────
|
||||||
|
RenderPassImage rp[] = {
|
||||||
|
RenderPassImage::RenderTarget(
|
||||||
|
&renderTarget,
|
||||||
|
RenderPassImage::LoadOp::CLEAR,
|
||||||
|
RenderPassImage::StoreOp::STORE,
|
||||||
|
ResourceState::SHADER_RESOURCE,
|
||||||
|
ResourceState::SHADER_RESOURCE
|
||||||
|
),
|
||||||
|
RenderPassImage::DepthStencil(
|
||||||
|
&depthBuffer,
|
||||||
|
RenderPassImage::LoadOp::CLEAR,
|
||||||
|
RenderPassImage::StoreOp::STORE,
|
||||||
|
ResourceState::DEPTHSTENCIL,
|
||||||
|
ResourceState::DEPTHSTENCIL,
|
||||||
|
ResourceState::DEPTHSTENCIL
|
||||||
|
),
|
||||||
|
};
|
||||||
|
dev->RenderPassBegin(rp, 2, cmd);
|
||||||
|
|
||||||
|
Viewport vp;
|
||||||
|
vp.width = (float)renderTarget.GetDesc().width;
|
||||||
|
vp.height = (float)renderTarget.GetDesc().height;
|
||||||
|
vp.min_depth = 0.0f;
|
||||||
|
vp.max_depth = 1.0f;
|
||||||
|
dev->BindViewports(1, &vp, cmd);
|
||||||
|
|
||||||
|
Rect scissor = { 0, 0, (int)vp.width, (int)vp.height };
|
||||||
|
dev->BindScissorRects(1, &scissor, cmd);
|
||||||
|
|
||||||
|
dev->BindPipelineState(&pso_, cmd);
|
||||||
|
dev->BindConstantBuffer(&constantBuffer_, 0, cmd);
|
||||||
|
dev->BindResource(&megaQuadBuffer_, 0, cmd); // t0: mega quad buffer
|
||||||
|
dev->BindResource(&textureArray_, 1, cmd); // t1: material textures
|
||||||
|
dev->BindResource(&chunkInfoBuffer_, 2, cmd); // t2: chunk info
|
||||||
|
dev->BindSampler(&sampler_, 0, cmd);
|
||||||
|
|
||||||
|
visibleChunks_ = 0;
|
||||||
|
drawCalls_ = 0;
|
||||||
|
|
||||||
|
// Push constant structure (must be 48 bytes = 12 x uint32, matches b999)
|
||||||
|
struct VoxelPush {
|
||||||
|
uint32_t chunkIndex;
|
||||||
|
uint32_t quadOffset; // offset into mega quad buffer (in quads)
|
||||||
|
uint32_t pad[10];
|
||||||
|
};
|
||||||
|
|
||||||
|
// Simple DrawInstanced loop with frustum culling + push constants
|
||||||
|
for (uint32_t i = 0; i < chunkCount_; i++) {
|
||||||
|
const auto& slot = chunkSlots_[i];
|
||||||
|
if (slot.quadCount == 0) continue;
|
||||||
|
|
||||||
|
XMFLOAT3 aabbMin(
|
||||||
|
(float)(slot.pos.x * CHUNK_SIZE),
|
||||||
|
(float)(slot.pos.y * CHUNK_SIZE),
|
||||||
|
(float)(slot.pos.z * CHUNK_SIZE)
|
||||||
|
);
|
||||||
|
XMFLOAT3 aabbMax(
|
||||||
|
aabbMin.x + CHUNK_SIZE,
|
||||||
|
aabbMin.y + CHUNK_SIZE,
|
||||||
|
aabbMin.z + CHUNK_SIZE
|
||||||
|
);
|
||||||
|
wi::primitive::AABB aabb(aabbMin, aabbMax);
|
||||||
|
if (!frustum.CheckBoxFast(aabb)) continue;
|
||||||
|
|
||||||
|
visibleChunks_++;
|
||||||
|
|
||||||
|
// Pass chunk index AND quad offset via push constants
|
||||||
|
// (SV_VertexID/SV_InstanceID offsets unreliable across drivers)
|
||||||
|
VoxelPush pushData = {};
|
||||||
|
pushData.chunkIndex = i;
|
||||||
|
pushData.quadOffset = slot.quadOffset;
|
||||||
|
dev->PushConstants(&pushData, sizeof(pushData), cmd);
|
||||||
|
|
||||||
|
// startVertexLocation = 0: the VS computes quad address from push.quadOffset
|
||||||
|
dev->DrawInstanced(slot.quadCount * 6, 1, 0, 0, cmd);
|
||||||
|
drawCalls_++;
|
||||||
|
}
|
||||||
|
|
||||||
|
dev->RenderPassEnd(cmd);
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── VoxelRenderPath (custom RenderPath3D) ───────────────────────
|
||||||
|
|
||||||
|
void VoxelRenderPath::Start() {
|
||||||
|
RenderPath3D::Start();
|
||||||
|
|
||||||
|
auto* device = wi::graphics::GetDevice();
|
||||||
|
renderer.initialize(device);
|
||||||
|
renderer.debugFaceColors_ = debugMode;
|
||||||
|
|
||||||
|
// Generate world
|
||||||
|
if (debugMode) {
|
||||||
|
world.generateDebug();
|
||||||
|
cameraPos = { 10.0f, 10.0f, 0.0f };
|
||||||
|
cameraPitch = -0.4f;
|
||||||
|
cameraYaw = 0.5f;
|
||||||
|
} else {
|
||||||
|
world.generateAround(cameraPos.x, cameraPos.y, cameraPos.z, 4);
|
||||||
|
}
|
||||||
|
if (renderer.isInitialized()) {
|
||||||
|
renderer.updateMeshes(world);
|
||||||
|
}
|
||||||
|
worldGenerated_ = true;
|
||||||
|
|
||||||
|
setAO(AO_DISABLED);
|
||||||
|
setFXAAEnabled(true);
|
||||||
|
setBloomEnabled(false);
|
||||||
|
|
||||||
|
createRenderTargets();
|
||||||
|
}
|
||||||
|
|
||||||
|
void VoxelRenderPath::createRenderTargets() {
|
||||||
|
auto* device = wi::graphics::GetDevice();
|
||||||
|
if (!device) return;
|
||||||
|
|
||||||
|
uint32_t w = GetPhysicalWidth();
|
||||||
|
uint32_t h = GetPhysicalHeight();
|
||||||
|
if (w == 0 || h == 0) { w = 1920; h = 1080; }
|
||||||
|
|
||||||
|
wi::graphics::TextureDesc rtDesc;
|
||||||
|
rtDesc.type = wi::graphics::TextureDesc::Type::TEXTURE_2D;
|
||||||
|
rtDesc.width = w;
|
||||||
|
rtDesc.height = h;
|
||||||
|
rtDesc.format = wi::graphics::Format::R8G8B8A8_UNORM;
|
||||||
|
rtDesc.bind_flags = wi::graphics::BindFlag::RENDER_TARGET | wi::graphics::BindFlag::SHADER_RESOURCE;
|
||||||
|
rtDesc.mip_levels = 1;
|
||||||
|
rtDesc.sample_count = 1;
|
||||||
|
rtDesc.layout = wi::graphics::ResourceState::SHADER_RESOURCE;
|
||||||
|
device->CreateTexture(&rtDesc, nullptr, &voxelRT_);
|
||||||
|
|
||||||
|
wi::graphics::TextureDesc depthDesc;
|
||||||
|
depthDesc.type = wi::graphics::TextureDesc::Type::TEXTURE_2D;
|
||||||
|
depthDesc.width = w;
|
||||||
|
depthDesc.height = h;
|
||||||
|
depthDesc.format = wi::graphics::Format::D32_FLOAT;
|
||||||
|
depthDesc.bind_flags = wi::graphics::BindFlag::DEPTH_STENCIL | wi::graphics::BindFlag::SHADER_RESOURCE;
|
||||||
|
depthDesc.mip_levels = 1;
|
||||||
|
depthDesc.sample_count = 1;
|
||||||
|
depthDesc.layout = wi::graphics::ResourceState::DEPTHSTENCIL;
|
||||||
|
device->CreateTexture(&depthDesc, nullptr, &voxelDepth_);
|
||||||
|
|
||||||
|
rtCreated_ = voxelRT_.IsValid() && voxelDepth_.IsValid();
|
||||||
|
wi::backlog::post("VoxelRenderPath: render targets " + std::string(rtCreated_ ? "OK" : "FAILED")
|
||||||
|
+ " (" + std::to_string(w) + "x" + std::to_string(h) + ")");
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── WASD camera input ───────────────────────────────────────────
|
||||||
|
|
||||||
|
static constexpr wi::input::BUTTON KEY_W = (wi::input::BUTTON)(wi::input::CHARACTER_RANGE_START + ('W' - 'A'));
|
||||||
|
static constexpr wi::input::BUTTON KEY_A = (wi::input::BUTTON)(wi::input::CHARACTER_RANGE_START + ('A' - 'A'));
|
||||||
|
static constexpr wi::input::BUTTON KEY_S = (wi::input::BUTTON)(wi::input::CHARACTER_RANGE_START + ('S' - 'A'));
|
||||||
|
static constexpr wi::input::BUTTON KEY_D = (wi::input::BUTTON)(wi::input::CHARACTER_RANGE_START + ('D' - 'A'));
|
||||||
|
|
||||||
|
void VoxelRenderPath::handleInput(float dt) {
|
||||||
|
if (wi::input::Press(wi::input::MOUSE_BUTTON_RIGHT)) {
|
||||||
|
mouseCaptured = !mouseCaptured;
|
||||||
|
wi::input::HidePointer(mouseCaptured);
|
||||||
|
}
|
||||||
|
|
||||||
|
if (mouseCaptured) {
|
||||||
|
auto mouseState = wi::input::GetMouseState();
|
||||||
|
cameraYaw += mouseState.delta_position.x * cameraSensitivity;
|
||||||
|
cameraPitch += mouseState.delta_position.y * cameraSensitivity;
|
||||||
|
cameraPitch = std::clamp(cameraPitch, -1.5f, 1.5f);
|
||||||
|
}
|
||||||
|
|
||||||
|
float cosPitch = std::cos(cameraPitch);
|
||||||
|
XMFLOAT3 forward(
|
||||||
|
std::sin(cameraYaw) * cosPitch,
|
||||||
|
-std::sin(cameraPitch),
|
||||||
|
std::cos(cameraYaw) * cosPitch
|
||||||
|
);
|
||||||
|
XMFLOAT3 right(std::cos(cameraYaw), 0.0f, -std::sin(cameraYaw));
|
||||||
|
|
||||||
|
float speed = cameraSpeed * dt;
|
||||||
|
if (wi::input::Down(wi::input::KEYBOARD_BUTTON_LSHIFT)) speed *= 3.0f;
|
||||||
|
|
||||||
|
if (wi::input::Down(KEY_W)) { cameraPos.x += forward.x * speed; cameraPos.y += forward.y * speed; cameraPos.z += forward.z * speed; }
|
||||||
|
if (wi::input::Down(KEY_S)) { cameraPos.x -= forward.x * speed; cameraPos.y -= forward.y * speed; cameraPos.z -= forward.z * speed; }
|
||||||
|
if (wi::input::Down(KEY_A)) { cameraPos.x -= right.x * speed; cameraPos.z -= right.z * speed; }
|
||||||
|
if (wi::input::Down(KEY_D)) { cameraPos.x += right.x * speed; cameraPos.z += right.z * speed; }
|
||||||
|
if (wi::input::Down(wi::input::KEYBOARD_BUTTON_SPACE)) cameraPos.y += speed;
|
||||||
|
if (wi::input::Down(wi::input::KEYBOARD_BUTTON_LCONTROL)) cameraPos.y -= speed;
|
||||||
|
|
||||||
|
camera->Eye = cameraPos;
|
||||||
|
camera->At = forward;
|
||||||
|
camera->Up = XMFLOAT3(0, 1, 0);
|
||||||
|
camera->UpdateCamera();
|
||||||
|
}
|
||||||
|
|
||||||
|
void VoxelRenderPath::Update(float dt) {
|
||||||
|
lastDt_ = dt;
|
||||||
|
float instantFps = (dt > 0.0f) ? (1.0f / dt) : 0.0f;
|
||||||
|
smoothFps_ = smoothFps_ * 0.95f + instantFps * 0.05f;
|
||||||
|
if (camera) handleInput(dt);
|
||||||
|
if (renderer.isInitialized()) renderer.updateMeshes(world);
|
||||||
|
RenderPath3D::Update(dt);
|
||||||
|
}
|
||||||
|
|
||||||
|
void VoxelRenderPath::Render() const {
|
||||||
|
RenderPath3D::Render();
|
||||||
|
|
||||||
|
if (renderer.isInitialized() && camera && rtCreated_) {
|
||||||
|
auto* device = wi::graphics::GetDevice();
|
||||||
|
CommandList cmd = device->BeginCommandList();
|
||||||
|
renderer.render(cmd, *camera, voxelDepth_, voxelRT_);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void VoxelRenderPath::Compose(CommandList cmd) const {
|
||||||
|
frameCount_++;
|
||||||
|
|
||||||
|
RenderPath3D::Compose(cmd);
|
||||||
|
|
||||||
|
if (rtCreated_ && voxelRT_.IsValid()) {
|
||||||
|
wi::image::Params fx;
|
||||||
|
fx.enableFullScreen();
|
||||||
|
fx.blendFlag = wi::enums::BLENDMODE_OPAQUE;
|
||||||
|
wi::image::Draw(&voxelRT_, fx, cmd);
|
||||||
|
}
|
||||||
|
|
||||||
|
// HUD overlay
|
||||||
|
wi::font::Params fp;
|
||||||
|
fp.posX = 10; fp.posY = 10; fp.size = 20;
|
||||||
|
fp.color = wi::Color(255, 255, 255, 230);
|
||||||
|
fp.shadowColor = wi::Color(0, 0, 0, 180);
|
||||||
|
|
||||||
|
char fpsStr[16];
|
||||||
|
snprintf(fpsStr, sizeof(fpsStr), "%.1f", smoothFps_);
|
||||||
|
char dtStr[16];
|
||||||
|
snprintf(dtStr, sizeof(dtStr), "%.2f", lastDt_ * 1000.0f);
|
||||||
|
|
||||||
|
std::string stats = "BVLE Voxel Engine (Phase 2 — GPU-driven)\n";
|
||||||
|
stats += "FPS: " + std::string(fpsStr) + " (" + std::string(dtStr) + " ms)\n";
|
||||||
|
if (debugMode) {
|
||||||
|
stats += "=== DEBUG FACE MODE ===\n";
|
||||||
|
stats += "+X=Red -X=DkRed +Y=Green -Y=DkGreen +Z=Blue -Z=DkBlue\n";
|
||||||
|
}
|
||||||
|
stats += "Chunks: " + std::to_string(renderer.getVisibleChunks())
|
||||||
|
+ "/" + std::to_string(renderer.getChunkCount()) + "\n";
|
||||||
|
stats += "Quads: " + std::to_string(renderer.getTotalQuads()) + "\n";
|
||||||
|
stats += "Draw Calls: " + std::to_string(renderer.getDrawCalls())
|
||||||
|
+ " (DrawInstanced + CPU cull + backface)\n";
|
||||||
|
|
||||||
|
char cullStr[16], drawStr[16];
|
||||||
|
snprintf(cullStr, sizeof(cullStr), "%.3f", renderer.getGpuCullTimeMs());
|
||||||
|
snprintf(drawStr, sizeof(drawStr), "%.3f", renderer.getGpuDrawTimeMs());
|
||||||
|
stats += "GPU Cull: " + std::string(cullStr) + " ms | Draw: " + std::string(drawStr) + " ms\n";
|
||||||
|
stats += "WASD+Space/Ctrl: move | Shift: fast | Right-click: capture mouse";
|
||||||
|
|
||||||
|
wi::font::Draw(stats, fp, cmd);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace voxel
|
||||||
180
src/voxel/VoxelRenderer.h
Normal file
180
src/voxel/VoxelRenderer.h
Normal file
|
|
@ -0,0 +1,180 @@
|
||||||
|
#pragma once
|
||||||
|
#include "VoxelWorld.h"
|
||||||
|
#include "VoxelMesher.h"
|
||||||
|
#include "WickedEngine.h"
|
||||||
|
|
||||||
|
namespace voxel {
|
||||||
|
|
||||||
|
// ── GPU-visible chunk info (must match HLSL GPUChunkInfo) ────────
|
||||||
|
struct GPUChunkInfo {
|
||||||
|
XMFLOAT4 worldPos; // xyz = chunk origin, w = debug flag
|
||||||
|
uint32_t quadOffset; // offset into mega quad buffer
|
||||||
|
uint32_t quadCount; // number of quads for this chunk
|
||||||
|
uint32_t pad[2]; // align to 32 bytes
|
||||||
|
uint32_t faceOffsets[6]; // per-face quad offset within this chunk's quads
|
||||||
|
uint32_t faceCounts[6]; // per-face quad count
|
||||||
|
};
|
||||||
|
|
||||||
|
// ── Voxel Renderer (Phase 2: mega-buffer + MDI pipeline) ────────
|
||||||
|
class VoxelRenderer {
|
||||||
|
public:
|
||||||
|
VoxelRenderer();
|
||||||
|
~VoxelRenderer();
|
||||||
|
|
||||||
|
void initialize(wi::graphics::GraphicsDevice* device);
|
||||||
|
void shutdown();
|
||||||
|
|
||||||
|
// Mesh dirty chunks and repack the mega-buffer
|
||||||
|
void updateMeshes(VoxelWorld& world);
|
||||||
|
|
||||||
|
// Render all visible chunks
|
||||||
|
void render(
|
||||||
|
wi::graphics::CommandList cmd,
|
||||||
|
const wi::scene::CameraComponent& camera,
|
||||||
|
const wi::graphics::Texture& depthBuffer,
|
||||||
|
const wi::graphics::Texture& renderTarget
|
||||||
|
) const;
|
||||||
|
|
||||||
|
// Generate procedural textures for materials
|
||||||
|
void generateTextures();
|
||||||
|
|
||||||
|
// Stats
|
||||||
|
uint32_t getTotalQuads() const { return totalQuads_; }
|
||||||
|
uint32_t getVisibleChunks() const { return visibleChunks_; }
|
||||||
|
uint32_t getDrawCalls() const { return drawCalls_; }
|
||||||
|
uint32_t getChunkCount() const { return chunkCount_; }
|
||||||
|
bool isInitialized() const { return initialized_; }
|
||||||
|
bool isGpuCulling() const { return gpuCullingEnabled_; }
|
||||||
|
|
||||||
|
bool debugFaceColors_ = false;
|
||||||
|
|
||||||
|
private:
|
||||||
|
void createPipeline();
|
||||||
|
void rebuildMegaBuffer(VoxelWorld& world);
|
||||||
|
|
||||||
|
wi::graphics::GraphicsDevice* device_ = nullptr;
|
||||||
|
|
||||||
|
// Shaders & Pipeline
|
||||||
|
wi::graphics::Shader vertexShader_;
|
||||||
|
wi::graphics::Shader pixelShader_;
|
||||||
|
wi::graphics::PipelineState pso_;
|
||||||
|
wi::graphics::Shader cullShader_; // Frustum cull compute shader
|
||||||
|
|
||||||
|
// Texture array for materials (256x256, 5 layers for prototype)
|
||||||
|
wi::graphics::Texture textureArray_;
|
||||||
|
wi::graphics::Sampler sampler_;
|
||||||
|
|
||||||
|
// ── Mega-buffer architecture (Phase 2) ──────────────────────
|
||||||
|
static constexpr uint32_t MEGA_BUFFER_CAPACITY = 2 * 1024 * 1024; // 2M quads max (16 MB)
|
||||||
|
static constexpr uint32_t MAX_CHUNKS = 2048;
|
||||||
|
static constexpr uint32_t MAX_DRAWS = MAX_CHUNKS * 6; // up to 6 face groups per chunk
|
||||||
|
|
||||||
|
wi::graphics::GPUBuffer megaQuadBuffer_; // StructuredBuffer<PackedQuad>, SRV t0
|
||||||
|
wi::graphics::GPUBuffer chunkInfoBuffer_; // StructuredBuffer<GPUChunkInfo>, SRV t2
|
||||||
|
|
||||||
|
// CPU-side tracking
|
||||||
|
struct ChunkSlot {
|
||||||
|
ChunkPos pos;
|
||||||
|
uint32_t quadOffset; // offset into mega-buffer (in quads)
|
||||||
|
uint32_t quadCount;
|
||||||
|
};
|
||||||
|
std::vector<ChunkSlot> chunkSlots_;
|
||||||
|
std::vector<GPUChunkInfo> cpuChunkInfo_;
|
||||||
|
std::vector<PackedQuad> cpuMegaQuads_; // CPU staging for mega-buffer
|
||||||
|
uint32_t chunkCount_ = 0;
|
||||||
|
bool megaBufferDirty_ = true;
|
||||||
|
|
||||||
|
// ── Indirect draw (Phase 2 MDI) ─────────────────────────────
|
||||||
|
// IndirectDrawArgsInstanced: { vertexCount, instanceCount, startVertex, startInstance }
|
||||||
|
struct IndirectDrawArgs {
|
||||||
|
uint32_t vertexCountPerInstance;
|
||||||
|
uint32_t instanceCount;
|
||||||
|
uint32_t startVertexLocation;
|
||||||
|
uint32_t startInstanceLocation;
|
||||||
|
};
|
||||||
|
wi::graphics::GPUBuffer indirectArgsBuffer_; // IndirectDrawArgs[MAX_DRAWS]
|
||||||
|
wi::graphics::GPUBuffer drawCountBuffer_; // uint32_t[1]
|
||||||
|
mutable std::vector<IndirectDrawArgs> cpuIndirectArgs_;
|
||||||
|
bool gpuCullingEnabled_ = false; // GPU compute cull vs CPU fallback
|
||||||
|
|
||||||
|
// Constants buffer (must match HLSL VoxelCB)
|
||||||
|
struct VoxelConstants {
|
||||||
|
XMFLOAT4X4 viewProjection;
|
||||||
|
XMFLOAT4 cameraPosition;
|
||||||
|
XMFLOAT4 sunDirection;
|
||||||
|
XMFLOAT4 sunColor;
|
||||||
|
float chunkSize;
|
||||||
|
float textureTiling;
|
||||||
|
float _pad[2];
|
||||||
|
XMFLOAT4 frustumPlanes[6]; // ax+by+cz+d=0
|
||||||
|
uint32_t chunkCount;
|
||||||
|
uint32_t _cullPad0;
|
||||||
|
uint32_t _cullPad1;
|
||||||
|
uint32_t _cullPad2;
|
||||||
|
};
|
||||||
|
wi::graphics::GPUBuffer constantBuffer_;
|
||||||
|
|
||||||
|
// ── GPU Compute Mesher (Phase 2 benchmark) ─────────────────────
|
||||||
|
wi::graphics::Shader meshShader_; // voxelMeshCS compute shader
|
||||||
|
wi::graphics::GPUBuffer voxelDataBuffer_; // chunk voxel data (StructuredBuffer<uint>)
|
||||||
|
wi::graphics::GPUBuffer gpuQuadBuffer_; // GPU mesh output (RWStructuredBuffer<uint2>)
|
||||||
|
wi::graphics::GPUBuffer gpuQuadCounter_; // atomic counter for GPU mesh output
|
||||||
|
bool gpuMesherAvailable_ = false;
|
||||||
|
|
||||||
|
// ── GPU Timestamp Queries (Phase 2 benchmark) ────────────────
|
||||||
|
wi::graphics::GPUQueryHeap timestampHeap_;
|
||||||
|
wi::graphics::GPUBuffer timestampReadback_;
|
||||||
|
static constexpr uint32_t TS_CULL_BEGIN = 0;
|
||||||
|
static constexpr uint32_t TS_CULL_END = 1;
|
||||||
|
static constexpr uint32_t TS_DRAW_BEGIN = 2;
|
||||||
|
static constexpr uint32_t TS_DRAW_END = 3;
|
||||||
|
static constexpr uint32_t TS_COUNT = 4;
|
||||||
|
mutable float gpuCullTimeMs_ = 0.0f;
|
||||||
|
mutable float gpuDrawTimeMs_ = 0.0f;
|
||||||
|
|
||||||
|
// Stats (mutable: updated during const Render() call)
|
||||||
|
mutable uint32_t totalQuads_ = 0;
|
||||||
|
mutable uint32_t visibleChunks_ = 0;
|
||||||
|
mutable uint32_t drawCalls_ = 0;
|
||||||
|
|
||||||
|
bool initialized_ = false;
|
||||||
|
|
||||||
|
public:
|
||||||
|
float getGpuCullTimeMs() const { return gpuCullTimeMs_; }
|
||||||
|
float getGpuDrawTimeMs() const { return gpuDrawTimeMs_; }
|
||||||
|
};
|
||||||
|
|
||||||
|
// ── Custom RenderPath that integrates voxel rendering ───────────
|
||||||
|
class VoxelRenderPath : public wi::RenderPath3D {
|
||||||
|
public:
|
||||||
|
VoxelWorld world;
|
||||||
|
VoxelRenderer renderer;
|
||||||
|
|
||||||
|
bool debugMode = false;
|
||||||
|
|
||||||
|
float cameraSpeed = 50.0f;
|
||||||
|
float cameraSensitivity = 0.003f;
|
||||||
|
XMFLOAT3 cameraPos = { 256.0f, 100.0f, 256.0f };
|
||||||
|
float cameraPitch = -0.3f;
|
||||||
|
float cameraYaw = 0.0f;
|
||||||
|
bool mouseCaptured = false;
|
||||||
|
|
||||||
|
void Start() override;
|
||||||
|
void Update(float dt) override;
|
||||||
|
void Render() const override;
|
||||||
|
void Compose(wi::graphics::CommandList cmd) const override;
|
||||||
|
|
||||||
|
private:
|
||||||
|
void handleInput(float dt);
|
||||||
|
void createRenderTargets();
|
||||||
|
mutable bool worldGenerated_ = false;
|
||||||
|
mutable int frameCount_ = 0;
|
||||||
|
mutable float lastDt_ = 0.016f;
|
||||||
|
mutable float smoothFps_ = 60.0f;
|
||||||
|
|
||||||
|
wi::graphics::Texture voxelRT_;
|
||||||
|
wi::graphics::Texture voxelDepth_;
|
||||||
|
mutable bool rtCreated_ = false;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace voxel
|
||||||
118
src/voxel/VoxelTypes.h
Normal file
118
src/voxel/VoxelTypes.h
Normal file
|
|
@ -0,0 +1,118 @@
|
||||||
|
#pragma once
|
||||||
|
#include <cstdint>
|
||||||
|
#include <functional>
|
||||||
|
|
||||||
|
namespace voxel {
|
||||||
|
|
||||||
|
// ── Voxel Data (16 bits per voxel, as per spec) ─────────────────
|
||||||
|
// Layout: 8 bits material ID | 4 bits flags | 4 bits metadata
|
||||||
|
struct VoxelData {
|
||||||
|
uint16_t packed = 0;
|
||||||
|
|
||||||
|
VoxelData() = default;
|
||||||
|
explicit VoxelData(uint8_t materialID, uint8_t flags = 0, uint8_t meta = 0) {
|
||||||
|
packed = (uint16_t(materialID) << 8) | (uint16_t(flags & 0xF) << 4) | (meta & 0xF);
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t getMaterialID() const { return uint8_t(packed >> 8); }
|
||||||
|
uint8_t getFlags() const { return uint8_t((packed >> 4) & 0xF); }
|
||||||
|
uint8_t getMetadata() const { return uint8_t(packed & 0xF); }
|
||||||
|
|
||||||
|
bool isEmpty() const { return packed == 0; }
|
||||||
|
bool isSmooth() const { return (getFlags() & FLAG_SMOOTH) != 0; }
|
||||||
|
bool isTransparent() const { return (getFlags() & FLAG_TRANSPARENT) != 0; }
|
||||||
|
bool isEmissive() const { return (getFlags() & FLAG_EMISSIVE) != 0; }
|
||||||
|
|
||||||
|
static constexpr uint8_t FLAG_SMOOTH = 0x1;
|
||||||
|
static constexpr uint8_t FLAG_TRANSPARENT = 0x2;
|
||||||
|
static constexpr uint8_t FLAG_EMISSIVE = 0x4;
|
||||||
|
static constexpr uint8_t FLAG_CUSTOM = 0x8;
|
||||||
|
};
|
||||||
|
|
||||||
|
// ── Chunk Constants ─────────────────────────────────────────────
|
||||||
|
static constexpr int CHUNK_SIZE = 32;
|
||||||
|
static constexpr int CHUNK_VOLUME = CHUNK_SIZE * CHUNK_SIZE * CHUNK_SIZE;
|
||||||
|
|
||||||
|
// ── Packed Vertex for Greedy Mesh Quads (8 bytes per quad) ──────
|
||||||
|
// Layout per spec:
|
||||||
|
// 6 bits posX | 6 bits posY | 6 bits posZ |
|
||||||
|
// 6 bits width | 6 bits height | 3 bits face |
|
||||||
|
// 8 bits materialID | 8 bits AO | 15 bits flags
|
||||||
|
struct PackedQuad {
|
||||||
|
uint64_t data;
|
||||||
|
|
||||||
|
static PackedQuad create(
|
||||||
|
uint8_t x, uint8_t y, uint8_t z,
|
||||||
|
uint8_t w, uint8_t h, uint8_t face,
|
||||||
|
uint8_t materialID, uint8_t ao = 0, uint16_t flags = 0
|
||||||
|
) {
|
||||||
|
PackedQuad q;
|
||||||
|
q.data =
|
||||||
|
(uint64_t(x & 0x3F)) |
|
||||||
|
(uint64_t(y & 0x3F) << 6) |
|
||||||
|
(uint64_t(z & 0x3F) << 12) |
|
||||||
|
(uint64_t(w & 0x3F) << 18) |
|
||||||
|
(uint64_t(h & 0x3F) << 24) |
|
||||||
|
(uint64_t(face & 0x7) << 30) |
|
||||||
|
(uint64_t(materialID) << 33) |
|
||||||
|
(uint64_t(ao) << 41) |
|
||||||
|
(uint64_t(flags & 0x7FFF) << 49);
|
||||||
|
return q;
|
||||||
|
}
|
||||||
|
|
||||||
|
uint8_t getX() const { return uint8_t(data & 0x3F); }
|
||||||
|
uint8_t getY() const { return uint8_t((data >> 6) & 0x3F); }
|
||||||
|
uint8_t getZ() const { return uint8_t((data >> 12) & 0x3F); }
|
||||||
|
uint8_t getWidth() const { return uint8_t((data >> 18) & 0x3F); }
|
||||||
|
uint8_t getHeight() const { return uint8_t((data >> 24) & 0x3F); }
|
||||||
|
uint8_t getFace() const { return uint8_t((data >> 30) & 0x7); }
|
||||||
|
uint8_t getMaterialID() const { return uint8_t((data >> 33) & 0xFF); }
|
||||||
|
uint8_t getAO() const { return uint8_t((data >> 41) & 0xFF); }
|
||||||
|
uint16_t getFlags() const { return uint16_t((data >> 49) & 0x7FFF); }
|
||||||
|
};
|
||||||
|
|
||||||
|
// Face directions: +X, -X, +Y, -Y, +Z, -Z
|
||||||
|
enum Face : uint8_t {
|
||||||
|
FACE_POS_X = 0,
|
||||||
|
FACE_NEG_X = 1,
|
||||||
|
FACE_POS_Y = 2,
|
||||||
|
FACE_NEG_Y = 3,
|
||||||
|
FACE_POS_Z = 4,
|
||||||
|
FACE_NEG_Z = 5,
|
||||||
|
FACE_COUNT = 6
|
||||||
|
};
|
||||||
|
|
||||||
|
// ── Material Descriptor ─────────────────────────────────────────
|
||||||
|
struct MaterialDesc {
|
||||||
|
uint16_t albedoTextureIndex = 0;
|
||||||
|
uint16_t normalTextureIndex = 0;
|
||||||
|
uint16_t heightmapTextureIndex = 0;
|
||||||
|
uint8_t roughness = 128; // 0-255 mapped to 0.0-1.0
|
||||||
|
uint8_t metallic = 0;
|
||||||
|
uint8_t flags = 0; // triplanar, blend mode, etc.
|
||||||
|
uint8_t _pad = 0;
|
||||||
|
|
||||||
|
static constexpr uint8_t FLAG_TRIPLANAR = 0x1;
|
||||||
|
};
|
||||||
|
|
||||||
|
// ── Chunk Position Hash ─────────────────────────────────────────
|
||||||
|
struct ChunkPos {
|
||||||
|
int32_t x, y, z;
|
||||||
|
|
||||||
|
bool operator==(const ChunkPos& other) const {
|
||||||
|
return x == other.x && y == other.y && z == other.z;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
struct ChunkPosHash {
|
||||||
|
size_t operator()(const ChunkPos& p) const {
|
||||||
|
// FNV-1a inspired hash
|
||||||
|
size_t h = 0x811c9dc5;
|
||||||
|
h ^= size_t(p.x); h *= 0x01000193;
|
||||||
|
h ^= size_t(p.y); h *= 0x01000193;
|
||||||
|
h ^= size_t(p.z); h *= 0x01000193;
|
||||||
|
return h;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace voxel
|
||||||
282
src/voxel/VoxelWorld.cpp
Normal file
282
src/voxel/VoxelWorld.cpp
Normal file
|
|
@ -0,0 +1,282 @@
|
||||||
|
#include "VoxelWorld.h"
|
||||||
|
#include <cmath>
|
||||||
|
#include <algorithm>
|
||||||
|
|
||||||
|
namespace voxel {
|
||||||
|
|
||||||
|
VoxelWorld::VoxelWorld() {
|
||||||
|
setupDefaultMaterials();
|
||||||
|
}
|
||||||
|
|
||||||
|
VoxelWorld::~VoxelWorld() = default;
|
||||||
|
|
||||||
|
void VoxelWorld::setupDefaultMaterials() {
|
||||||
|
// Material 0: Air (empty, never rendered)
|
||||||
|
// Material 1: Grass
|
||||||
|
materials[1].albedoTextureIndex = 0;
|
||||||
|
materials[1].roughness = 200;
|
||||||
|
materials[1].flags = MaterialDesc::FLAG_TRIPLANAR;
|
||||||
|
// Material 2: Dirt
|
||||||
|
materials[2].albedoTextureIndex = 1;
|
||||||
|
materials[2].roughness = 220;
|
||||||
|
materials[2].flags = MaterialDesc::FLAG_TRIPLANAR;
|
||||||
|
// Material 3: Stone
|
||||||
|
materials[3].albedoTextureIndex = 2;
|
||||||
|
materials[3].roughness = 180;
|
||||||
|
materials[3].flags = MaterialDesc::FLAG_TRIPLANAR;
|
||||||
|
// Material 4: Sand
|
||||||
|
materials[4].albedoTextureIndex = 3;
|
||||||
|
materials[4].roughness = 230;
|
||||||
|
materials[4].flags = MaterialDesc::FLAG_TRIPLANAR;
|
||||||
|
// Material 5: Snow
|
||||||
|
materials[5].albedoTextureIndex = 4;
|
||||||
|
materials[5].roughness = 150;
|
||||||
|
materials[5].flags = MaterialDesc::FLAG_TRIPLANAR;
|
||||||
|
}
|
||||||
|
|
||||||
|
// ── Permutation-based noise (no external dependency) ────────────
|
||||||
|
|
||||||
|
static constexpr int PERM_SIZE = 256;
|
||||||
|
static uint8_t perm[512];
|
||||||
|
static uint32_t permSeed = 0;
|
||||||
|
static bool permInitialized = false;
|
||||||
|
|
||||||
|
static void initPerm(uint32_t seed) {
|
||||||
|
if (permInitialized && permSeed == seed) return;
|
||||||
|
for (int i = 0; i < PERM_SIZE; i++) perm[i] = (uint8_t)i;
|
||||||
|
// Fisher-Yates shuffle with seed
|
||||||
|
uint32_t s = seed;
|
||||||
|
for (int i = PERM_SIZE - 1; i > 0; i--) {
|
||||||
|
s = s * 1664525u + 1013904223u; // LCG
|
||||||
|
int j = s % (i + 1);
|
||||||
|
uint8_t tmp = perm[i];
|
||||||
|
perm[i] = perm[j];
|
||||||
|
perm[j] = tmp;
|
||||||
|
}
|
||||||
|
for (int i = 0; i < 256; i++) perm[i + 256] = perm[i];
|
||||||
|
permSeed = seed;
|
||||||
|
permInitialized = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
static float fade(float t) { return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f); }
|
||||||
|
static float lerp(float a, float b, float t) { return a + t * (b - a); }
|
||||||
|
|
||||||
|
static float grad(int hash, float x, float y, float z) {
|
||||||
|
int h = hash & 15;
|
||||||
|
float u = h < 8 ? x : y;
|
||||||
|
float v = h < 4 ? y : (h == 12 || h == 14 ? x : z);
|
||||||
|
return ((h & 1) ? -u : u) + ((h & 2) ? -v : v);
|
||||||
|
}
|
||||||
|
|
||||||
|
float VoxelWorld::noise3D(float x, float y, float z) const {
|
||||||
|
initPerm(seed_);
|
||||||
|
int X = (int)std::floor(x) & 255;
|
||||||
|
int Y = (int)std::floor(y) & 255;
|
||||||
|
int Z = (int)std::floor(z) & 255;
|
||||||
|
x -= std::floor(x);
|
||||||
|
y -= std::floor(y);
|
||||||
|
z -= std::floor(z);
|
||||||
|
float u = fade(x), v = fade(y), w = fade(z);
|
||||||
|
|
||||||
|
int A = perm[X] + Y;
|
||||||
|
int AA = perm[A] + Z;
|
||||||
|
int AB = perm[A + 1] + Z;
|
||||||
|
int B = perm[X + 1] + Y;
|
||||||
|
int BA = perm[B] + Z;
|
||||||
|
int BB = perm[B + 1] + Z;
|
||||||
|
|
||||||
|
return lerp(
|
||||||
|
lerp(lerp(grad(perm[AA], x, y, z), grad(perm[BA], x-1, y, z), u),
|
||||||
|
lerp(grad(perm[AB], x, y-1, z), grad(perm[BB], x-1, y-1, z), u), v),
|
||||||
|
lerp(lerp(grad(perm[AA+1], x, y, z-1), grad(perm[BA+1], x-1, y, z-1), u),
|
||||||
|
lerp(grad(perm[AB+1], x, y-1, z-1), grad(perm[BB+1], x-1, y-1, z-1), u), v),
|
||||||
|
w);
|
||||||
|
}
|
||||||
|
|
||||||
|
float VoxelWorld::fbm(float x, float y, float z, int octaves) const {
|
||||||
|
float value = 0.0f;
|
||||||
|
float amplitude = 1.0f;
|
||||||
|
float frequency = 1.0f;
|
||||||
|
float maxVal = 0.0f;
|
||||||
|
for (int i = 0; i < octaves; i++) {
|
||||||
|
value += amplitude * noise3D(x * frequency, y * frequency, z * frequency);
|
||||||
|
maxVal += amplitude;
|
||||||
|
amplitude *= 0.5f;
|
||||||
|
frequency *= 2.0f;
|
||||||
|
}
|
||||||
|
return value / maxVal;
|
||||||
|
}
|
||||||
|
|
||||||
|
void VoxelWorld::generateChunk(Chunk& chunk) {
|
||||||
|
const float scale = 0.02f; // terrain horizontal scale
|
||||||
|
const float heightScale = 64.0f;
|
||||||
|
const float baseHeight = 40.0f;
|
||||||
|
const float caveScale = 0.05f;
|
||||||
|
const float caveThreshold = 0.3f;
|
||||||
|
|
||||||
|
for (int z = 0; z < CHUNK_SIZE; z++) {
|
||||||
|
for (int x = 0; x < CHUNK_SIZE; x++) {
|
||||||
|
// World-space coordinates
|
||||||
|
float wx = (float)(chunk.pos.x * CHUNK_SIZE + x);
|
||||||
|
float wz = (float)(chunk.pos.z * CHUNK_SIZE + z);
|
||||||
|
|
||||||
|
// Heightmap using fBm
|
||||||
|
float height = baseHeight + heightScale * fbm(wx * scale, 0.0f, wz * scale, 5);
|
||||||
|
|
||||||
|
for (int y = 0; y < CHUNK_SIZE; y++) {
|
||||||
|
float wy = (float)(chunk.pos.y * CHUNK_SIZE + y);
|
||||||
|
VoxelData v;
|
||||||
|
|
||||||
|
if (wy > height) {
|
||||||
|
// Air above terrain
|
||||||
|
v = VoxelData();
|
||||||
|
} else {
|
||||||
|
// Cave generation
|
||||||
|
float cave = fbm(wx * caveScale, wy * caveScale, wz * caveScale, 3);
|
||||||
|
if (std::abs(cave) < caveThreshold && wy > 10.0f && wy < height - 3.0f) {
|
||||||
|
v = VoxelData(); // Cave
|
||||||
|
} else if (wy > height - 1.0f) {
|
||||||
|
// Surface layer: material depends on height
|
||||||
|
if (wy > 90.0f) {
|
||||||
|
v = VoxelData(5); // Snow
|
||||||
|
} else if (wy > 70.0f) {
|
||||||
|
v = VoxelData(3); // Stone
|
||||||
|
} else if (wy < 25.0f) {
|
||||||
|
v = VoxelData(4); // Sand
|
||||||
|
} else {
|
||||||
|
v = VoxelData(1); // Grass
|
||||||
|
}
|
||||||
|
} else if (wy > height - 4.0f) {
|
||||||
|
v = VoxelData(2); // Dirt
|
||||||
|
} else {
|
||||||
|
v = VoxelData(3); // Stone
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
chunk.at(x, y, z) = v;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
chunk.dirty = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void VoxelWorld::generateAround(float cx, float cy, float cz, int radiusChunks) {
|
||||||
|
int ccx = (int)std::floor(cx / CHUNK_SIZE);
|
||||||
|
int ccy = (int)std::floor(cy / CHUNK_SIZE);
|
||||||
|
int ccz = (int)std::floor(cz / CHUNK_SIZE);
|
||||||
|
|
||||||
|
for (int dz = -radiusChunks; dz <= radiusChunks; dz++) {
|
||||||
|
for (int dx = -radiusChunks; dx <= radiusChunks; dx++) {
|
||||||
|
// Y range: only generate chunks that could contain terrain (0 to ~4 chunks high)
|
||||||
|
for (int dy = 0; dy < 8; dy++) {
|
||||||
|
ChunkPos pos = { ccx + dx, dy, ccz + dz };
|
||||||
|
if (chunks_.find(pos) == chunks_.end()) {
|
||||||
|
auto chunk = std::make_unique<Chunk>();
|
||||||
|
chunk->pos = pos;
|
||||||
|
generateChunk(*chunk);
|
||||||
|
chunks_[pos] = std::move(chunk);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Chunk* VoxelWorld::getChunk(const ChunkPos& pos) {
|
||||||
|
auto it = chunks_.find(pos);
|
||||||
|
return it != chunks_.end() ? it->second.get() : nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
const Chunk* VoxelWorld::getChunk(const ChunkPos& pos) const {
|
||||||
|
auto it = chunks_.find(pos);
|
||||||
|
return it != chunks_.end() ? it->second.get() : nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
VoxelData VoxelWorld::getVoxel(int wx, int wy, int wz) const {
|
||||||
|
// Integer floor division that works for negatives
|
||||||
|
auto floorDiv = [](int a, int b) -> int {
|
||||||
|
return (a >= 0) ? (a / b) : ((a - b + 1) / b);
|
||||||
|
};
|
||||||
|
auto floorMod = [](int a, int b) -> int {
|
||||||
|
int r = a % b;
|
||||||
|
return (r < 0) ? r + b : r;
|
||||||
|
};
|
||||||
|
|
||||||
|
ChunkPos cp = {
|
||||||
|
floorDiv(wx, CHUNK_SIZE),
|
||||||
|
floorDiv(wy, CHUNK_SIZE),
|
||||||
|
floorDiv(wz, CHUNK_SIZE)
|
||||||
|
};
|
||||||
|
const Chunk* chunk = getChunk(cp);
|
||||||
|
if (!chunk) return VoxelData();
|
||||||
|
|
||||||
|
return chunk->at(
|
||||||
|
floorMod(wx, CHUNK_SIZE),
|
||||||
|
floorMod(wy, CHUNK_SIZE),
|
||||||
|
floorMod(wz, CHUNK_SIZE)
|
||||||
|
);
|
||||||
|
}
|
||||||
|
|
||||||
|
void VoxelWorld::setVoxel(int wx, int wy, int wz, VoxelData v) {
|
||||||
|
auto floorDiv = [](int a, int b) -> int {
|
||||||
|
return (a >= 0) ? (a / b) : ((a - b + 1) / b);
|
||||||
|
};
|
||||||
|
auto floorMod = [](int a, int b) -> int {
|
||||||
|
int r = a % b;
|
||||||
|
return (r < 0) ? r + b : r;
|
||||||
|
};
|
||||||
|
|
||||||
|
ChunkPos cp = {
|
||||||
|
floorDiv(wx, CHUNK_SIZE),
|
||||||
|
floorDiv(wy, CHUNK_SIZE),
|
||||||
|
floorDiv(wz, CHUNK_SIZE)
|
||||||
|
};
|
||||||
|
Chunk* chunk = getChunk(cp);
|
||||||
|
if (!chunk) return;
|
||||||
|
|
||||||
|
chunk->at(
|
||||||
|
floorMod(wx, CHUNK_SIZE),
|
||||||
|
floorMod(wy, CHUNK_SIZE),
|
||||||
|
floorMod(wz, CHUNK_SIZE)
|
||||||
|
) = v;
|
||||||
|
chunk->dirty = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void VoxelWorld::generateDebug() {
|
||||||
|
chunks_.clear();
|
||||||
|
|
||||||
|
// Create a single chunk at origin
|
||||||
|
ChunkPos cp = {0, 0, 0};
|
||||||
|
auto chunk = std::make_unique<Chunk>();
|
||||||
|
chunk->pos = cp;
|
||||||
|
std::memset(chunk->voxels, 0, sizeof(chunk->voxels));
|
||||||
|
|
||||||
|
VoxelData stone(3); // material 3 = stone
|
||||||
|
|
||||||
|
// Block 1: single isolated block at (5, 5, 5)
|
||||||
|
// → should show all 6 faces
|
||||||
|
chunk->at(5, 5, 5) = stone;
|
||||||
|
|
||||||
|
// Block 2: 2x1x1 bar at (12, 5, 5) along X
|
||||||
|
// → internal faces should be culled
|
||||||
|
chunk->at(12, 5, 5) = stone;
|
||||||
|
chunk->at(13, 5, 5) = stone;
|
||||||
|
|
||||||
|
// Block 3: L-shape at (5, 5, 12)
|
||||||
|
chunk->at(5, 5, 12) = stone;
|
||||||
|
chunk->at(6, 5, 12) = stone;
|
||||||
|
chunk->at(5, 5, 13) = stone;
|
||||||
|
|
||||||
|
// Block 4: 3-high column at (12, 5, 12)
|
||||||
|
chunk->at(12, 5, 12) = stone;
|
||||||
|
chunk->at(12, 6, 12) = stone;
|
||||||
|
chunk->at(12, 7, 12) = stone;
|
||||||
|
|
||||||
|
// Block 5: single block at (20, 5, 5) with material 1 (grass)
|
||||||
|
chunk->at(20, 5, 5) = VoxelData(1);
|
||||||
|
|
||||||
|
chunk->dirty = true;
|
||||||
|
chunks_[cp] = std::move(chunk);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace voxel
|
||||||
87
src/voxel/VoxelWorld.h
Normal file
87
src/voxel/VoxelWorld.h
Normal file
|
|
@ -0,0 +1,87 @@
|
||||||
|
#pragma once
|
||||||
|
#include "VoxelTypes.h"
|
||||||
|
#include <unordered_map>
|
||||||
|
#include <vector>
|
||||||
|
#include <memory>
|
||||||
|
#include <mutex>
|
||||||
|
|
||||||
|
namespace voxel {
|
||||||
|
|
||||||
|
// ── Chunk ───────────────────────────────────────────────────────
|
||||||
|
struct Chunk {
|
||||||
|
VoxelData voxels[CHUNK_VOLUME];
|
||||||
|
ChunkPos pos;
|
||||||
|
bool dirty = true;
|
||||||
|
|
||||||
|
// Mesh data (output of greedy mesher, sorted by face ID 0-5)
|
||||||
|
std::vector<PackedQuad> quads;
|
||||||
|
uint32_t quadCount = 0;
|
||||||
|
uint32_t faceOffsets[6] = {}; // offset (in quads) for each face group within quads[]
|
||||||
|
uint32_t faceCounts[6] = {}; // number of quads per face group
|
||||||
|
|
||||||
|
VoxelData& at(int x, int y, int z) {
|
||||||
|
return voxels[x + y * CHUNK_SIZE + z * CHUNK_SIZE * CHUNK_SIZE];
|
||||||
|
}
|
||||||
|
|
||||||
|
const VoxelData& at(int x, int y, int z) const {
|
||||||
|
return voxels[x + y * CHUNK_SIZE + z * CHUNK_SIZE * CHUNK_SIZE];
|
||||||
|
}
|
||||||
|
|
||||||
|
bool isInBounds(int x, int y, int z) const {
|
||||||
|
return x >= 0 && x < CHUNK_SIZE &&
|
||||||
|
y >= 0 && y < CHUNK_SIZE &&
|
||||||
|
z >= 0 && z < CHUNK_SIZE;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// ── World ───────────────────────────────────────────────────────
|
||||||
|
class VoxelWorld {
|
||||||
|
public:
|
||||||
|
VoxelWorld();
|
||||||
|
~VoxelWorld();
|
||||||
|
|
||||||
|
// Generate a procedural world around a center position
|
||||||
|
void generateAround(float cx, float cy, float cz, int radiusChunks);
|
||||||
|
|
||||||
|
// Generate debug world: isolated blocks for face visibility testing
|
||||||
|
void generateDebug();
|
||||||
|
|
||||||
|
// Get a chunk (nullptr if not loaded)
|
||||||
|
Chunk* getChunk(const ChunkPos& pos);
|
||||||
|
const Chunk* getChunk(const ChunkPos& pos) const;
|
||||||
|
|
||||||
|
// Get voxel at world position (handles cross-chunk lookup)
|
||||||
|
VoxelData getVoxel(int wx, int wy, int wz) const;
|
||||||
|
void setVoxel(int wx, int wy, int wz, VoxelData v);
|
||||||
|
|
||||||
|
// Iterate all chunks
|
||||||
|
template<typename Fn>
|
||||||
|
void forEachChunk(Fn&& fn) {
|
||||||
|
for (auto& [pos, chunk] : chunks_) {
|
||||||
|
fn(pos, *chunk);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template<typename Fn>
|
||||||
|
void forEachChunk(Fn&& fn) const {
|
||||||
|
for (auto& [pos, chunk] : chunks_) {
|
||||||
|
fn(pos, *chunk);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
size_t chunkCount() const { return chunks_.size(); }
|
||||||
|
|
||||||
|
// Material palette
|
||||||
|
MaterialDesc materials[256];
|
||||||
|
void setupDefaultMaterials();
|
||||||
|
|
||||||
|
private:
|
||||||
|
void generateChunk(Chunk& chunk);
|
||||||
|
float noise3D(float x, float y, float z) const;
|
||||||
|
float fbm(float x, float y, float z, int octaves) const;
|
||||||
|
|
||||||
|
std::unordered_map<ChunkPos, std::unique_ptr<Chunk>, ChunkPosHash> chunks_;
|
||||||
|
uint32_t seed_ = 42;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace voxel
|
||||||
BIN
voxel_engine_spec.docx
Normal file
BIN
voxel_engine_spec.docx
Normal file
Binary file not shown.
Loading…
Add table
Reference in a new issue