TODO List:

• Fill UBO transfer command

• SDL backend?

  • SDL Window
  • SDL Input listeners
  • SDL Audio

• CPU Parallel task executions

  • Task executor
  • Shader compilation
  • Pipeline creation

• Common Shaders Definitions

• Common shaders bindings

• Automatic shader definitions (to progressively complete)

• Shader pragma once

• Dynamic Shaders Definitions (keep a table)

• UpdateContext

• VkShaderObjectEXT?

• Complete Graphics command

  • Bresenham line rasterization
  • Mesh Shaders command
  • MSAA
  • FragmentCommand

• RenderPass-less rendering?

• Mesh

  • Mesh interface
    • Rigid Mesh
    • Animated Mesh with skeleton
    • Terrain
    • ???
  • .obj loader
  • Simple mesh generation
    • Platonic solids
    • Box
    • Sphere
    • Icosphere
  • Mesh renderer, Mesh representation
    • Mesh attribs from reflection
  • Mesh compression?
  • Meshlets?
  • Separate positions from other vertex data?

• Scene

• VkRayTracingKHR

  • TLAS
  • SBT

• Modules

• Multi layer swapchain (for VR)

• Debug buffers

  • GLSL strings

• Input manager

• Improve CMake

  • AddProject function
  • Separate list for .exe
  • Option to build .exe
  • FastDebug build (Same as Debug, with IDL=0)
  • Correctly import Vulkan

• Better ResourceStateTracker

  • Remake the interface
  • Actually store the resource state in the resource rather than in a separate map?
  • Correctly track potentially overlapping subresources
    • for Buffers
    • for Images

• Fix synchronization validation errors

• Re use descriptor sets

  • set = 0: common set (debug, ...), managed by the executor
  • set = 1: scene set
  • set = 2: module set
  • set = 3: shader set
  • set = 4: push_descriptor set (shader invocation specific data)

• CmdBuffer bindings (pipeline + desc sets)

  • Bind pipeline -> reset desc bindings?

• DescSetLayout cache managed by the application

• Accumulate all descriptor updates in the UpdateContext

• Multi window mode (independent of ImGui)

• Buffer / Image on recreate instance command policy (copy content)

• MultiExecutor

• Cmake: Make and Optimized mode (debug info for my code, other libs ands stl linked in release with IDL = 0)

• Window:

  • Correct HDR support (also ImGui)
  • Fullscreen
  • Resized by the application

• UpdateResources takes a priority as parameter, so for instance shaders that will not be used can still be updated, but with a lower priority

  • For now, AsynchTasks are executed asynch, but are joined synch, which allows them to have side effect (store their result in the object emmiting the task). It should be forbiden, as it might create bugs, especially with an asynch joining of tasks.

• InstanceHolders (aka Descriptors) have an option to not hold and instance (mostly to free memory for Images and Buffers)

• Add a mode to use the GENERAL image layout instead of the specialized layout and measure the performance of doing so

• Refactor ResourceBinding and remove Resource

• Remove ext features from the device requested feature chain when the extension is not used (it now generates a validation error)

• Separate DescriptorSet and DescriptorPool

  • Use one pool for many descriptor sets (for model resources)

• Add helper types StringVector, AnyVector, ...

• Refactor UploadQueue, AsynchUpload, ... to avoid using individual small allocations

• Find a better project name

• Rework on thatlib

Projects Ideas:

• Basic Renderer
• Seam Carving
• Mutiple rigid body simulation
• Fluid simulation?
• Reversed perspective redering
• Wave Function Collapse
• PT, LT, BDPT, VCM?
• SIBR
• HashCache based field storage + neural recontstruction?
• ReStiR
• Radiance guiding

Loose Ideas:

October 2023: There should be two types of resources, synch ones and asynch ones.

• Synch resources (curent implementation) are intended to be "script resources", in a limited number, updated by the main thread, always loaded and ready to use
• Asynch resources are intended to be meshes, textures, etc, in a large number, managed (loaded, updated) by asynch threads and can be not avaible yet, partially available, or complitely available April 2024: The distinction has kind of been implemented now. Problem: automatic synchronization of all the scene resources is expesive. But all these resources are synched the "same" way, the synchronization work can be done once and shared to all these resources. Maybe create a distinction between two synch regimes: Auto and Manual.

Resources management / Execution refactor

Objectives:

• Synchronize multiple times the same resources for the same or different usages (refactor of SynchHelper)
  • Simple Resource usage list with one usage per resources (works for now)
• Have more dynamic descriptor sets (adding or removing descriptors "on the fly")
• Resource management: have resources be managed by their owner ifp, else by the script manager, instead of only by the executor
• Execute host tasks in parallel (such as shader compilation, resources loading)
• Load scene (mesh, textures) asynch
  • Asynch Textures
  • Asynch Mesh
  • Asynch Mesh group
• Refactor the Executor (and linearExecutor): issue an ExecThread to record commands in
• Add a transfer queue to the LinearExecutor to load assets
• Refactor command execition:
  • Command execution issue an execution object declaring the resources on which it will interact and how, synchronization of said resources will be done externaly by the executor. This allows for ASAP synch, rather than the current mandatory ALAP
  • Auto Build an execution graph from these execution objects (nodes) and their resources (edges)
• Explicitely instancify Resources
• ExecutionNodes are Command's instances, as such, they should only reference resources instances.
• Have a separate render thread