I briefly read the paper and I think I got the basic idea of it. The paper doesn't really go into implementation details though so my question is mostly on that.
In the paper, needed tiles are identified by going through the vertex stage and the vertices that make it to the fragment stage have paging data written into another texture at the vert's texcoord. Tiles are then assigned a tile from some form of pager. Cpu reads paging and assignment data and streams image data from disk to said tiles. At least that's from what I understand.
I'm unclear on the TLM implementation. I assume it's using image load stores (glsl. Don't know what the hlsl equivalent is). Is this a correct assumption to make or is there a better way to do this?
Also, is this better than just streaming in data based on the object distance from the camera? Their implementation may be more efficient that it streams in only when needed, but it sounds like it might introduce more pop in since it doesn't guarantee that objects nearby will have the appropriate mip level in memory.
Edit: link to the paper https://hal.inria.fr/inria-00070783
Did a proper read through again. It outputs the texcoord as a color frame buffer attachment at the vertex stage. Now the only confusion is how they output the texcoord coordinates but still use the mvp transform for the actual clipping. My solution is probably to abs the x and y mvp coords, take the max of those and output that to the z coord. The vertex will be clipped if the z value is more than one. That's my solution for this. They vaguely mentioned using the clipping registers in Nvidia hw. I'm guessing that means is a better way to do this?