dethraid / androidrenderer Goto Github PK

We need to create a GV for the LPV. There's a few ideas on how to do this

One idea is to build a 3D rasterizer in compute shaders. This has some advantages. A major one is that we have ful control over the rasterization pipeline and can easily implement conservative rasterization. I've already implemented this and found that it takes about 8 ms per frame on my RTX 2080 Super. I'd like to get that down to 1 ms

Another idea is to implement the original GV from the cascades LPVs paper. We can use the player's depth buffer from last frame and the RSM's depth buffer, and inject them into the appropriate volumes with SH. This will probably work alright. I'm worried about light leaking from occluded surfaces, but we'll see

A third idea is to build a 3D GV for each mesh offline, and add it to the per-cascade GV at runtime. This avoids the high runtime cost of voxelization, while still giving us full control over the rasterization pipeline.

Virtual Resources

TextureHandle and BufferHandle shouldn't require real vulkan resources

We should be able to re-use the same VkBuffer or VkTexture object (or even VkMemory) within the same frame. Letting resources alias the same memory regions will lead to reduced memory consumption and increased coolness

Currently, the backend only submits command buffers on end of frame. We want to be able to submit command buffers in the middle of the frame, to decrease latency. We also want to be able to explicitly submit command buffers before any frames are rendered, in order to support doing work on startup

We want pipeline handles

Currently pipelines go through a cringe system where you make a pipeline builder, set a bunch of state, then call build and get a Pipeline object. This object is large and cringe. Instead, we should get a PipelineHandle

PipelineHandles point to the real pipelines. The command buffer can retrieve the real object when you bind it, this is fine. There's a few benefits, though. One major one is uniformity with TextureHandle and BufferHandle. Another is shader hot reload. The backend Pipeline storage thing can save the create info, such that it can reload the shader files, recompile them, and build new VkPipelines from them - all at the press of a button

I want bindless textures

We need a class, TextureViewPool or something, that manages texture descriptors

Some things to improve the depth buffer injection:

• Generate a mip chain for the normal target as well
• Can we use FP16 when generating the depth buffer mip chain?
• One pass to inject into all cascades. The VS reads the point's position and normal and passes it to the GS. The GS tests that position against each cascade, and emits a primitive for each cascade that passes. the FS adds the SH normal as usual

We need some way to save what state a resource was in last frame, and issue barrier from that state to the current state

Maybe a StateTracker class that handles all state tracking?

Inject VPLs from mesh lights

We'll need to first generate VPLs from mesh lights. We can sample random triangles, weighted by their area, then sample random points on those triangles. Generating barycentrics randomly should work for now

After that, we can use the existing VPL injection shader to... you know, inject the VPLs