opengl - State of the art Culling and Batching techniques in rendering -

I am currently working to upgrade and reorganize an OpenGL render engine. Engine is used for the view of large scenes of architectural data (building with interior), and the quantity of objects can be larger as in case of any building, there are many object objects within the walls, And you can naturally only see the object that is in the same room as you, or if you are outdoors, leave this large number of objects, And should be done through frustrated colon.

At the same time there are many repeater geometries that can be batch in renderbatch, and many objects can be provided with instanced rendering.

The way I see it, it can be difficult to add renderbatching and kalan in an optimum fashion. If you batch too many objects in the same VBO, it is difficult to remove the object on the CPU to render that batch. At the same time if you leave the dead on the CPU, many objects will be processed by the GPU, while they are not visible. If you leave batching softly to dodge more easily on the CPU, then there will be an unwanted high volume of render calls.

I have done some research in the current techniques and principles like how these problems are solved in modern graphics, but I can not find any concrete solution, a colleague and an idea came up with me in which The batches were limited to close objects close to each individual, within all rooms or within the radius of N meters. It can be adapted through the use of simplified and oct-trees.

Is there any indication of the techniques used for visual management, cooling, batching etc. in the state of a modern graphics engine?

There is a lot of information about frustration and impediment on the Internet, most of it comes from game developers. Here is a list of some articles that will get you started:

< Li>

My (very fast) renderer works like this:

1. Archive : Renderers want to present all of you who want to render.
2. Frustum : Draws invisible propulsions from the renderer list using multiple threads in parallel.
3. Horse Racing : Now you can try to stop crossing the CPU (I have not implemented it yet, because I do not need it). Detailed information on how to do it efficiently can be found in the Kilozone and Crisis slides. One solution will be to read back the buffer depth of the previous frame from the GPU, and then the object bounding bounding boxes must be rastered to see if the object is visible.
4. Splitting : Now that you know which objects are actually to be presented, because they appear, you have to divide them by the net, because in each trap There is a separate material or texture (otherwise they are gathered in one trap)
5. batching : You now have a list of meshes to render. You can sort them:
   • In depth (this trap can be done at the proportal level instead of the level), to protect Bharrat (I do not advise not to do this if your piece is very easy ). / Li>
   • by the net (because there can be many instances of the same mesh and it makes adding an instance easier).
   • By texture, because texture switches are very expensive.
   • Rendering : Repeat through your partitioned mess and present them.

     And already said as "full headache nudity": There is no correct solution.