Since the play testing a few weeks ago I have been busy but I have not got a great deal to show for it yet.
My main task is trying to improve the draw performance so I can add a bit more detail to the levels and counter some of the additions I made based on the suggestions from the play testing.
I already do the typical view frustum culling and restrict the far plane range so I am only left with the more complex things to try. Pretty much that is some form of pre-calculation of what is in view.
From the reading I have done Binary Space Partitioning (BSP) is not appropriate to the type of exterior vistas I would like to have in the game. Therefore I have been concentrating on Occlusion Volumes (View or Visibility Cells). My understanding being that these are areas of the map that if you are inside that area the models and meshes in view have been pre-calculated and therefore exclude meshes that are hidden by other meshes. Both Unity and the Unreal Engine have variations of this that can be enabled depending on if it is appropriate for the map.
My map already uses a grid for storing, triangles and other information so adding additional heights to set the boundaries of the Occlusion Volume is trivial. The tricky task has been calculating the mesh occlusion information.
I tried to calculate the view using the GPU. I wrote a shader that stored an index for each model and returned that in the render target. By drawing the view in sufficient directions from various points in each Occlusion Volume I would get a fairly accurate chance of knowing what was not in view and could therefore be ignored and not drawn in game.
I wrote all the code to do the calculations using the GPU but now for the problem. Based on my initial trials it would take 72 hours to calculate the information for the entire usable area of the map! I decided that was too long to run every time I made a tiny change to any game level!
I was also not confident that the result from the render target was completely accurate because my tests showed that if I put a float value in, the float I got out was close but not identical when rendered!
For my next trick I am attempting to use the grid and simply ray cast between cells. I have not finished coding this but in the process I have used the Bresenham Line Algorithm.
The algorithm was originally intended to plot a line on early printers in the '60's. I have come across it before but as it does not include every possible cell that a line could pass through it was no good for my impact calculations. However for view occlusion I need something that is fast and where a few false positives for grid squares in view will not be harmful to the overall result.
It's only a tiny bit of code but I decided to put my C# XNA versions on CodePlex. The important bit is that one of the variations I've included gives the result in order from the start to the finish point. If it is of interest you can view and download it from there.