HW vertex processing vs. simulation

no_way

Regular
From DemoCoder in another thread:
2) ability to handle geometry amplification issues on the chip, making TruForm(n-patch), HOS, displacement mapping, etc more useful. Most new games are going to want to do shadow volumes, and all current geometry amplificiation schemes hurt collision detection and shadow generation. This "per primitive processor" on the NV30 sounds like it could do the trick by enabling you to create and destroy vertices and send them to the vertex shader. Being able to query about collisions would be good too

Im quite puzzled over how HW geometry generation will relate to simulation in the future.
For collision detection, one can work with general bounding volumes and hierarchical bounding volumes first, when there's possibility for collision, mesh fragment can be run through HW "primitive processor" and VS, which will be doing HOS tessellation, displacement, and vertices can be read back for collision detection / physics calculations on host CPU.
That could work because in most situations exact collision calculations can be reduced to minimum with various caching schemes etc. And for HOS exact collision detection can be performed on CPU even without tessellation, although the algos are quite complicated.
But for shadows... precise calculation would mean that basically all the geometry that will be casting shadows needs to be processed twice on HW.
In real world, most likely nobody will take displacement maps into account for shadow generation, but HOS-s will need to be adressed.

In any case, im often wondering whether the whole T&L thing on graphics cchips makes much sense .. post-transform vertices are often useful for more than just displaying on the screen. And reading them back to host CPU and then retransforming again doesnt sound like very efficient solution. Wouldnt just T&L coprocessor make much more sense ?

I know it's been argued over when HW T&L first appeared already.. but now the whole issue is getting even more complicated because of the "programmable primitive processing" on the horizon .. ( BTW i still havent found any info on how this PPP will fit into OGL2 specification )
 
no_way,
I was thinking of the case where you send a HOS to the PPP. The PPP performs the tesselation (generating vertices), but it also calculates the silhouette edges, generates the shadow volumes, and optimizes them as a separate vertex stream. This stream could even be cached (cacheable stream, hmmm) and the PPP could be given control to run the multipass loop.
 
Well first of all, I think the main problem which you can't currently address with a vertex shader when using HOS/dmaps is shadowing (if the shadow volume approach is being used).

IMO Collision detection is an issue whether or not it is done on the VPU or CPU:

The post transform vertices are not all that useful for exact collision detection, because they themselves are not exact representations of the underlying geomtry. HOS/dmaps will not be tesselated to max detail everywhere (so the VPU does not in fact generate all the vertices necessary for exact collision detection). Furthermore I'd say in a lot of cases (i.e. two 5000 to 10000 tri character meshes against eachother),
calculating "exact" collision is not very practical or even all that desireable.

Methods that I have seen can figure out exact solutions given two static meshes (i.e. do they intersect, if so where). I have never seen an exact method for intersecting a mesh undergoing complicated skeletal animation with something else (i.e. do they intersect given "trajectories" for each bone, if so, where and when).

Furthermore, in all likelyhood, a game will have to do collision detection for geometry not even being processed by the VPU (offscreen AIs, a multiplayer game server, etc...).

Levels of tesselation and offscreen geometry is also a problem for the shadow volume approach. For instance if an off-screen shadow-caster's shadow is visible, and it's tesselation level changes when it becomes visible, you will get a discontinuity in the shadow being cast...

Regards,
Serge
 
I'm currently hoping that future hardware will become programmable enough (and powerful enough) to allow the video card to do nearly any conceivable operation that a program using software transform might want to do after transforming the vertices.

After all, since nearly any operation would be a vector operation, it seems like programmable vertex shaders should be quite good at doing those operations.

It does seem like we still have a ways to go with programmable GPU's :) But, I think the future is very bright. While it is certain that turning these vertex shaders into basically vector processors would decrease their performance in certain situations, I see no reason why it would decrease their performance when they're not accessing the added flexibility.
 
There is no need to merge everything. There are operations at each granularity (per scene, per object, per vertex, per pixel). It is best to keep these separate due to optimizations you can perform. That's why introducing a "per object" unit that sits in front of the vertex shader unit is better. Let the vertex shader be a stage in the pipeline optimized for what it does best. For more complicated stuff regarding morphing objects and creating/destroying objects, move it to a higher level processor.

Don't try to jam everything into one uber-unit that can do everything. It's a bad idea.
 
Back
Top