Projet personnel / Architecture moteur

Tessera Engine

Un moteur C++20/Direct3D 12 où chaque frontière possède un mécanisme de vérification et chaque décision s’accompagne de preuves.

Tessera est le moteur de jeu et l’éditeur Windows que je développe comme projet personnel. J’écris l’ECS, le système de jobs, le pipeline d’assets et le moteur de rendu. Pour les tech leads et responsables de projet, cette page explique les responsabilités de chaque système, les compromis retenus et mes critères d’acceptation d’une implémentation.

L’inventaire documenté du 12 octobre 2026 recense 819 fichiers C++, environ 270 000 lignes hors ThirdParty et 47 shaders. Deux solutions dans quatre configurations produisent huit builds locaux avec les avertissements traités comme erreurs. Ces chiffres décrivent l’échelle du projet ; les mesures ci-dessous appartiennent aux scénarios enregistrés, sur cette machine et dans les builds documentés. Le dépôt est privé.

  • C++20
  • Windows
  • Direct3D 12
  • ECS
  • DXR
  • Dear ImGui
  • Sharpmake
Vue de l’éditeur avec docking, viewport, hiérarchie, inspector et Content Browser ; cette capture montre une scène sans meshes préparés chargés.

Présentation

De petites pièces, des frontières vérifiables

Une tessera est une pièce de mosaïque. Chaque couche possède une responsabilité et une direction de dépendance définies. La simulation ne dépend pas du rendu ; le moteur de rendu construit un plan ; le backend graphique traduit ce plan en travail GPU. L’éditeur utilise le moteur qu’il inspecte.

Le moteur est une bibliothèque statique ; l’exécutable exporte D3D12SDKVersion et D3D12SDKPath de l’Agility SDK. Trois vérifications complémentaires séparent simulation, planification et exécution : un seul transfert de l’ECS vers RenderScene, un render graph testable sans GPU et une solution entière sans D3D12. Les frontières disposent ainsi de vérifications au-delà des conventions de dossiers.

Contrats d’architecture

Patterns, alternatives et preuves

Ces patterns relient une décision à son implémentation et à une vérification susceptible de la contredire. Chaque nom mène à la section détaillée ; les résultats décrivent des tests documentés, pas des garanties pour toute scène ou tout matériel.

La même politique guide simulation, GPU et authoring : déclarer les accès, centraliser les valeurs dérivées et expliciter les durées de vie. Je préfère une dépendance vérifiable par le compilateur à une règle imposant de se souvenir de tous ses consommateurs.

PatternEmplacementAlternative évitéePreuve dans le scénario mesuré
Le moteur de rendu planifie ; le backend exécuteRender/RenderGraph / RHI/D3D12/DxRenderGraphExecutorGraphe qui enregistre des commandes242 vérifications du plan sans device.
Un seul transfert ECS/renduRenderExtractionSystem vers RenderSceneMoteur de rendu lisant le World vivantAjouter 100 000 entités sans mesh conserve les instances et les octets transférés.
Backend nul comme solution de buildTessera.NoD3D12.slnIsolation reposant uniquement sur #ifdef ou des recherches textuellesZéro Dx*.obj dans les quatre configurations de la solution sans D3D12.
Handles avec générationRHI/Handles.hPointeur ou ComPtr dans un composantNeuf tags de handle ; un PSO retiré par hot reload entraîne un draw ignoré, sans référence pendante.
Accès déclarés et DAG de hazardsSystemDescriptor, AccessAuditorLocks dans l’ECSZéro mutex dans ECS/ ; 32 systèmes : 0,68 µs pour 10 000 entités et 0,86 µs pour un million.
Changements structurels différésCommandBuffer, PlaybackCommandsModifier les composants pendant l’itérationDans le test, 1 000 entités produisent une transition d’archetype.
Versions pour les changements ; hash pour la restaurationTransformState, WorldSnapshotFlags booléens comme seule source de validitéDans la frame immobile mesurée, GPU Scene reçoit 0 octet d’upload.
Un producteur par valeur dérivéeCanonicalCookedKey, ComputeSceneRectRecalculer identité ou rectangles chez chaque consommateurClé canonique partagée ; une clé recalculée a causé une scène magenta dans le diagnostic enregistré.
Composition avec contextes explicitesDxFramePassContextGod class ou extension par héritage85/85 fonctions virtual préservées dans 12 extractions de modules vérifiées.
Les defaults préservent le comportementQualitySettings, EffectToggleAppliquer un profil de qualité sans demandeSans flag, la comparaison d’acceptation compte 0 pixel différent sur 1 440 000.
Provenance et identité dans la donnéePROV, IDNTManifeste externe ou identité par cheminScan de 102 ms contre 316 s de recook dans le projet mesuré ; UUID préservé dans IDNT.
Instrumenter avant d’accepter--*-probeSe fier au seul build vertUn vérificateur post-build contrôle DLLs de runtime et shaders ; les probes exercent les fonctionnalités.
Flux actuel de la simulation au backend : extraction unique, plan sans GPU et exécution Direct3D 12. Diagramme conceptuel en anglais, sans nombres de passes propres à une scène.

Dépendances

Architecture en couches

Responsabilités, interfaces et dépendances vérifiables définissent les frontières. SDL3 apparaît uniquement sous Platform/ et UI/ ; les headers Direct3D restent dans RHI/D3D12/. Render/ décide quoi dessiner et produit le plan sans enregistrer de commandes GPU. ECS et Jobs n’incluent ni Render/ ni RHI/ : les recherches dans le code recensent zéro include de ces couches. Scene enregistre des composants de rendu et inclut leurs headers ; cette couche ne porte pas la même affirmation d’isolation.

Les bibliothèques d’import et de compression appartiennent exclusivement à Tools/TesseraCooker. Le runtime consomme des données préparées sans dépendances d’authoring. Tessera.NoD3D12.sln compile moteur et éditeur avec un backend nul et une interface SDL_Renderer. Un type D3D12 traversant la frontière casse ce build ; Debug, Development, Profile et Shipping produisent zéro objet Dx*.obj dans l’inventaire documenté.

Couches de dépendance du moteur et frontière isolée de Direct3D 12.

Simulation

Un ECS maison conçu pour l’ordonnancement

J’ai étudié EnTT et Flecs, puis construit un ECS autour de trois exigences : accès en lecture/écriture déclarés, changements structurels différés et déterministes, et snapshots du monde. Une Entity contient un index et une génération sur huit octets ; la génération détecte les références périmées. La persistance utilise un UUID, StableEntityId, et non un handle du runtime.

Les entités partageant les mêmes composants vivent dans des archetypes, avec des colonnes SoA contiguës dans des chunks de 64 KiB. Pour deux millions d’entités, 64 KiB nécessitait 1 482 pages contre 5 955 à 16 KiB, avec la même bande passante. Les sparse sets stockent les composants rares sans multiplier les archetypes. Les tables de composants partagés gardent une valeur par configuration distincte, référencée par le chunk.

Chaque SystemDescriptor déclare ses lectures et écritures. L’ordonnanceur en déduit un DAG de dépendances et exécute ensemble les systèmes sans conflit. Avec 32 systèmes, son coût mesuré était de 0,68 µs par frame sur 10 000 entités et de 0,86 µs sur 1 000 000 : il suit les systèmes, pas le nombre d’entités.

Des phases fixes définissent input, simulation, physique, événements, application structurelle, transforms et extraction pour le rendu. Créations, destructions et changements de composants passent par CommandBuffer, appliqué en un point déterministe. Un auditeur d’accès détecte les écritures non déclarées en développement et disparaît à la compilation Shipping. Événements typés, observers et stockage dédié de hiérarchie complètent le modèle ; la propagation par versions évite de recalculer les nœuds immobiles.

Le transfert vers le rendu est RenderExtractionSystem vers RenderScene : le moteur de rendu consomme les données extraites sans consulter le World vivant pour chaque draw. Dans la sonde enregistrée, ajouter 100 000 entités sans mesh conserve instances et octets transférés. Les changements structurels sont regroupés : 1 000 entités produisent une transition d’archetype dans le test de playback. Une frame immobile transfère 0 octet à GPU Scene ; les versions de TransformState suivent les changements et le hash de WorldSnapshot vérifie la restauration.

Le replay depuis un snapshot a reproduit 120 enregistrements d’audit identiques sur 120 frames, sur la même machine et le même build. C’est la portée vérifiée du déterminisme et la base du Play/Stop de l’éditeur ; le déterminisme entre plateformes n’est pas promis.

struct Entity
{
    uint32_t Index = InvalidEntityIndex;
    uint32_t Generation = 0;
};
static_assert(sizeof(Entity) == 8,
    "Entity is a chunk column; its size is layout.");
Stockage des archetypes en chunks avec colonnes contiguës de composants.
Structure ECS : handles d’entités, archetypes et stockage SoA.
Panneau ECS Diagnostics montrant le monde et l’ordonnancement.

Concurrence

Vol de travail sans bloquer la frame

Chaque worker possède un deque Chase-Lev : il empile et dépile sans verrou tandis que les workers inactifs volent à l’autre extrémité. Un worker qui attend un job exécute d’autres tâches sur sa pile courante. Le test avec un seul worker vérifie que les dépendances progressent. Les threads externes au pool attendent passivement ; leur participation créerait deux producteurs pour un deque qui n’en accepte qu’un.

Les jobs ont une affinité AnyWorker, LongRunning ou MainThread. Deux compteurs séparent le travail de la frame du travail long, pour empêcher la compilation de shaders de prolonger l’attente de la frame. Dans la comparaison enregistrée, la frame la plus lente pendant une recompilation est passée de 803 ms à 18,75 ms. Une FrameArena par worker fournit la mémoire temporaire ; ParallelFor sur 1 048 576 éléments a produit le résultat sériel sans allocation sur le heap.

Un watchdog nomme l’étape bloquée, y compris dans les exécutions avec la fenêtre de l’éditeur visible. Le vol par élément place le coût de recherche de travail sur le thread inactif. Dans le graphe large de travail réel enregistré, l’occupation des workers était de 94,7% ; la timeline relie cette mesure aux dépendances et au travail effectivement exécuté.

Le cooker utilise le même système : compresser une texture 2048² a pris 311,8 s avec un thread et 9,7 s avec 24. Tracy et une timeline intégrée exposent l’activité CPU/GPU et le travail par worker. Ce sont des mesures précises du projet, pas des garanties générales de débit.

Timeline de profiling avec les jobs par worker.
Profiling de l’éditeur avec informations de frame et de temps.

Persistance

Un conteneur, plusieurs chunks

Importer un modèle signifie le préparer pour le runtime. Un projet Tessera stocke les formats du moteur et référence l’original par une racine source nommée ; il ne copie jamais l’original dans le projet et refuse les chemins source absolus. Les données portables du projet restent ainsi séparées des fichiers d’authoring nécessaires à une réimportation.

Les formats binaires partagent un header de 64 octets avec magic, version, hash XXH3-128 et emplacement de la table de chunks. Des entrées FourCC localisent les chunks alignés sur 256 octets. Le runtime ne lit que le mip ou LOD nécessaire. PROV enregistre chemin et hash source, version du cooker et options ; scanner un projet inchangé a pris 102 ms contre 316 s pour le repréparer. IDNT conserve l’UUID lors des réimportations.

Un .tmesh contient un asset entier et ses submeshes : l’exemple du buggy transforme 109 maillages en un fichier de 236 submeshes. SXFM conserve les transforms par pièce, permettant de stocker une roue une fois et de la placer quatre fois. Dans la collection mesurée, le stockage est passé de 39,9 MB à 31,0 MB et les draws de 342 à 229.

L’absence des chunks optionnels a un comportement défini : sans SXFM, la transformation est l’identité. La politique de compatibilité permet d’ajouter PROV sans modifier la version du conteneur ; SXFM exige une version de maillage qui ouvre et rend toujours les anciens fichiers. Faire évoluer le format implique de décider explicitement quels lecteurs et quelles données doivent rester compatibles.

Le cycle de vie des assets comprend leur libération sur le GPU. CookedAssetLibrary::Clear appelle DestroyMesh tant que les handles identifient les maillages, puis ReleaseCookedTextures, avant de vider les tables locales. CanonicalCookedKey centralise l’identité dérivée ; les consommateurs réutilisent cette clé au lieu de produire des variantes qui ne retrouvent plus le même matériau.

FormatResponsabilité
.tmeshAsset de maillage, submeshes et LODs
.ttexTextures et mips compressés BC ; BC6H pour HDRI
.tmatMatériau OpenPBR
.tscn / .tpfb / .tcellNiveau, prefab et cellule de streaming
.tprojDescripteur de projet JSON, hors conteneur binaire
Disposition du mesh préparé et extension meshlets prévue.
Conteneur d’asset préparé : header, table de chunks et données.
Asset Properties montrant un asset préparé et ses chunks.
Interface d’import d’assets et suivi de progression.
Content Browser pour les formats d’assets du moteur.

Extension prévue

Préparer le chemin vers les mesh shaders

Les mesh shaders ne sont pas implémentés dans le renderer. Le pipeline existant laisse ce chemin ouvert : les slots de la root signature canonique sont visibles à tous les stages, les pipelines utilisent le pipeline state stream, DXC reconnaît ms et as à partir du Shader Model 6.5 et la détection de capacités interroge leur prise en charge par le GPU.

Un test a créé un pipeline de mesh shader avec cette root signature. Cela vérifie la compatibilité, pas un chemin de rendu livré. meshoptimizer est choisi mais pas intégré. Le plan prévoit que le cooker génère les meshlets dans un nouveau chunk .tmesh ; les anciens fichiers conserveront le chemin vertex traditionnel en son absence. Les contrats du conteneur et du pipeline rendent cette extension possible.

Frontière GPU

Le renderer planifie ; le backend exécute

IRenderBackend n’expose aucun type Direct3D. Les ressources utilisent des handles avec génération tels que Handle<TextureTag> et Handle<MeshTag> pour détecter les références à des objets libérés. Render/ construit un plan indépendant du GPU ; RHI/D3D12/ l’exécute. La planification est testable sans device.

Neuf tags de handle séparent les catégories de ressources et la génération valide leur durée de vie. Quand le hot reload retire un PSO, un draw qui le référence encore est ignoré. Le composant n’a pas besoin d’un pointeur ou ComPtr vers un objet du backend ; l’identité de la ressource reste distincte de sa représentation Direct3D.

Le backend emploie Enhanced Barriers par défaut avec repli legacy, et le bindless Shader Model 6.6 avec repli vers les tables de descripteurs. Sa root signature occupe 13 des 64 DWORDs. Une file de copie séparée gère les uploads ; le streaming avec budget VRAM réduit les mips sous pression au lieu de supprimer la scène. Le hot reload des shaders reconstruit les pipelines affectés.

L’enregistrement multithread est choisi lorsque la charge le justifie. Avec 23 099 draws, le temps CPU de la frame est passé de 207–229 ms à 82–91 ms, soit 2,3–2,8× d’amélioration. La petite frame habituelle conserve volontairement une seule liste de commandes. Les coûts supplémentaires d’ordonnancement et d’enregistrement doivent être justifiés.

Le plan de rendu traverse une interface abstraite avant son exécution par le backend D3D12.

Compilation de frame

Un render graph qui produit un plan

Chaque passe déclare lectures et écritures, types d’accès et stages GPU. Le graphe voit la frame entière et déduit ordre et barrières de ces déclarations. Il n’enregistre jamais de commandes. L’exécuteur D3D12 lit l’ordre d’exécution et les barrières par passe, puis enregistre le travail correspondant.

La compilation construit les dépendances sur le dernier écrivain précédent, rejette les cycles avec un plan vide, retire les producteurs inutilisés, choisit les files, calcule les durées de vie transitoires et génère les barrières lors des changements de rôle des ressources. Ressources exportées et effets de bord déclarés préservent le travail requis ; importer une ressource ne protège pas son producteur de la suppression.

L’ordre d’utilisation diffère de la durée de vie avec compute optionnel : les positions du plan ne décrivent pas les exécutions qui se chevauchent. Le graphe fournit les intervalles ; le propriétaire des heaps décide l’aliasing et demande ses barrières. Mon allocateur regroupe par durée de vie, exigence qui a motivé le rejet de l’approche par taille du D3D12 Memory Allocator évalué. Huit ressources volontairement échelonnées utilisaient 2 688 KB au lieu de 10 752 KB, soit 4,00× de réduction et le minimum pour ce test.

Le graphe forward fourni a été exporté depuis Sample.tscn le 6 octobre 2026. Dans cette configuration enregistrée, 20 passes produisent 15 barrières. Six passes d’occlusion/ray tracing désactivées ouvrent seulement des scopes vides : une passe sans écritures n’est pas un producteur inutilisé et n’est pas automatiquement supprimée. La transition SceneColor avant ToneMapPass est déduite du passage de render target à lecture shader. Les comptes varient avec le chemin de shading et les effets activés.

Reset() efface les données de frame en conservant la capacité des vecteurs ; les handles de ressources du graphe expirent alors. L’export Graphviz et le panneau de l’éditeur exposent le plan ; --rendergraph-self-test exécute 242 vérifications sans GPU.

  1. Déclarer

    Importer les ressources existantes avec leur état initial ; créer des transitoires indéfinis ; utiliser AddPass pour déclarer Read, Write ou ReadWrite.

  2. Compiler

    Exporter les états finaux requis, dont present pour le backbuffer. Compile() déduit l’ordre, les durées de vie et la synchronisation.

  3. Exécuter

    Le backend consomme GetExecutionOrder() et GetBarriers() et émet le travail GPU. La planification reste indépendante de Direct3D 12.

Graphe forward exporté depuis Sample.tscn le 6 octobre 2026 ; la transition SceneColor mise en évidence est déduite par le graphe.
Panneau Render Graph avec passes et connexions de ressources.

Rendu

Éclairage comparé à une référence

Le renderer implémente coat, anisotropie et fuzz OpenPBR, vérifiés par furnace test ; éclairage basé sur l’image, ciel procédural et HDRI ; ombres en cascades et clustered light culling. Dans le test enregistré, 125× plus de lumières coûtaient 1,39×. Les chemins forward et deferred sont interchangeables, avec SSAO, bloom, exposition automatique par histogramme et transparence.

DXR inline avec RayQuery fournit ombres douces, occlusion ambiante et réflexions tracées, ces dernières limitées au deferred. Un denoiser spatio-temporel et des budgets adaptatifs Low/High/Ultra contrôlent les effets temps réel. Un path tracer de référence mesure leur erreur. Les captures montrent la scène d’exemple et les diagnostics ; les compteurs visibles concernent ces captures et ne constituent pas un benchmark pour toutes les scènes.

Motion vectors, jitter et reprojection dans Render/TemporalReprojection.* fournissent déjà le socle temporel ; TAA, motion blur et upscaling temporel restent des extensions prévues. QualitySettings et EffectToggle préservent le comportement par défaut sans appliquer implicitement un profil. Dans la comparaison d’acceptation sans flag, 0 pixel sur 1 440 000 diffère. L’async compute est implémenté et désactivé par défaut : son gain d’environ 2% dans le scénario enregistré reste sous le seuil choisi de 5%.

Scène d’exemple Sponza rendue dans l’éditeur Tessera.
Scène d’exemple avec profil Ultra de ray tracing visible dans le panneau d’éclairage.
Visualisation de debug du ray tracing dans l’éditeur.
Contrôles d’éclairage et diagnostics dans la configuration capturée.

Authoring

L’éditeur utilise les systèmes qu’il expose

Dear ImGui docking garde l’éditeur en C++, dans le processus du moteur. La Lobby ouvre un projet sans lancer une autre application. Le Content Browser dispose de miniatures rendues, d’un cache disque à invalidation automatique et d’imports en arrière-plan. Les fenêtres mesh/prefab proposent des previews GPU ; l’éditeur de textures isole les canaux et regroupe ORM. Les propriétés d’assets exposent directement les chunks binaires.

Hierarchy, Inspector, transforms ImGuizmo, undo/redo, prefabs, tags et couleurs d’assets accompagnent l’édition des scènes. Le Material Graph est une vue en lecture seule dérivée du .tmat ; son câblage n’est pas éditable. Les widgets de graphes viennent du GraphEditor d’ImGuizmo.

Play, Pause, Stop et Simulate partagent les snapshots : Stop restaure le monde capturé et vérifie un hash identique. Les scènes d’authoring utilisent JSON pour des diffs Git lisibles, puis sont préparées en binaire pour le runtime. Profiling, Render Graph, ECS Diagnostics et Console permettent d’inspecter les systèmes en exécution depuis l’éditeur.

Éditeur d’asset avec preview 3D rendue par le GPU.
Lobby de projets à l’entrée de l’éditeur.
Autre vue du Content Browser dans le flux d’assets.
Material Graph en lecture seule dérivé des données du matériau.
Texture Editor avec inspection des canaux.

Choix techniques

Des dépendances au rôle défini

J’écris les politiques propres au moteur et emploie des bibliothèques pour des problèmes délimités. L’accès à SDL3 est limité à Platform/ et UI/ ; IPlatformBackend délimite les services de plateforme. DirectXMath fournit les mathématiques SIMD dans tout le moteur ; DXC compile le HLSL Shader Model 6.x. Dear ImGui et ImGuizmo fournissent les primitives d’interface plutôt qu’une seconde stack d’éditeur managé.

cgltf, ufbx et mon importeur OBJ restent dans le cooker. J’ai choisi ufbx, open source, plutôt que le FBX SDK pour sa triangulation ; mikktspace suit les conventions de tangentes des outils d’art. Parmi les compresseurs évalués, AMD Compressonator offrait la qualité BC7 préférée. stb_image et tinyexr décodent images/HDRI ; xxHash identifie le contenu préparé ; nlohmann/json conserve l’ordre des clés pour des diffs stables.

Tracy fournit les timelines CPU/GPU et WinPixEventRuntime nomme les passes GPU dans PIX. vcpkg fixe les versions avec la baseline du manifeste. Avant d’ajouter une dépendance, je lis la licence de chaque composant à la source officielle, avec une préférence pour l’open source.

Organisation du backend

Modules aux durées de vie explicites

Les fonctionnalités du backend comportent trois parties : des ressources vivant aussi longtemps que le device, un agrégat FrameState réinitialisé par une seule déclaration et des fonctions libres recevant (Feature, FrameState, Context). État persistant et transitoire ont des propriétaires distincts ; réinitialiser la frame ne dépend pas d’une liste de flags dispersée dans le backend.

Les contextes d’initialisation sont propres à chaque fonctionnalité. Pour enregistrer les passes, DxFramePassContext fournit les ressources empruntées à la frame. Les fonctions libres ne nomment pas DxRenderBackend : elles accèdent uniquement à ce qu’exposent leurs arguments. ComputeSceneRect centralise le calcul du rectangle et distingue sortie et rasterisation ; chaque passe utilise la valeur résolue pour garder viewport, picking et composition cohérents.

L’acceptation combine interface préservée, autotests et comparaison visuelle. Le relevé de 12 extractions de modules préserve les 85 fonctions virtual de l’interface, les résultats des autotests et 0 pixel différent dans la scène de comparaison. L’inventaire documenté recense 11 116 lignes dans DxRenderBackend.cpp. Ces résultats étayent la méthode d’isolation ; ils n’affirment pas l’absence de défaut dans toutes les exécutions.

  1. Device

    La fonctionnalité possède ses ressources persistantes et reçoit son contexte d’initialisation.

  2. Frame

    FrameState regroupe l’état transitoire et le réinitialise en une opération.

  3. Exécution

    Les fonctions libres reçoivent fonctionnalité, état et contexte ; la signature délimite leurs accès.

Composition d’une fonctionnalité du backend : ressources à durée de vie du device, état de frame et fonctions libres aux accès délimités par le contexte. Diagramme conceptuel en anglais.

Validation

Builds et comparaisons comme contraintes de conception

Sharpmake définit les builds de l’IDE et de la ligne de commande avec le même générateur. Avec le baseline de manifeste vcpkg, il produit deux solutions en Debug, Development, Profile et Shipping : huit builds locaux, tous traitant les avertissements comme erreurs. Les vérificateurs post-build contrôlent DLLs de runtime et arbres de shaders en miroir, car compiler et lier ne prouve pas que les ressources nécessaires seront présentes à l’exécution.

Les tests sans fenêtre comprennent 4 883 vérifications ECS, 242 du render graph et 837 du cooker. Des sondes en ligne de commande exercent les fonctions individuellement ; un harness compare temps et compteurs à une baseline. Les diffs d’images contre la version précédente exigent zéro pixel de scène différent pour les critères d’acceptation des refactorings décrits ici.

Ces nombres viennent des relevés du projet utilisés pour cette étude. Ils documentent la méthode et les scénarios mesurés, sans représenter une nouvelle exécution du dépôt privé par ce site. Build alternatif, audits de replay et comparaisons d’images vérifient des modes de défaillance qu’un build normal réussi ne suffirait pas à révéler.

Prochaines étapes

Direction d’implémentation et limites actuelles

Meshlets et mesh shaders constituent les prochaines étapes du rendu. Le plan est de générer les meshlets dans le cooker et de les stocker dans un chunk optionnel du .tmesh, en préservant le chemin traditionnel pour les assets sans ce chunk. Le test de compatibilité du pipeline existe ; le chemin de rendu par mesh shaders n’est pas encore implémenté.

Je souhaite utiliser les motion vectors, le jitter et la reprojection existants comme base pour TAA, motion blur et upscaling temporel. L’illumination globale reste prévue. L’async compute est déjà optionnel et son activation dépend d’un gain mesuré ; il reste désactivé par défaut.

Jolt Physics, miniaudio, GameNetworkingSockets et Recast & Detour sont choisis, mais pas encore intégrés. Un serveur autoritaire pour 16 joueurs est un objectif ; les snapshots à portée de réplication et la mesure de précision pour des mondes jusqu’à 200 km² constituent des bases de conception, sans démontrer un réseau fonctionnel. Windows est la seule plateforme prise en charge. Le déterminisme a été vérifié sur la même machine et le même build ; CI et déterminisme entre plateformes restent hors du périmètre validé.

Contact

Québec, QC, Canada / Ouvert aux opportunités

Je suis ouvert aux possibilités en développement logiciel, en programmation d'outils et de gameplay, ainsi qu'aux postes d'artiste 3D junior. Si mon expérience peut répondre aux besoins de votre équipe, je serai heureux d'échanger avec vous sur mes réseaux sociaux.