Get Multicore Differentiation and Great Integrated Graphics Performance
0 likes3,256 views
The document outlines the architecture and processing workflow of a turn-based battle RTS game, detailing how game state is built and rendered using worker threads for efficiency. It describes various processes including instance data management, mesh list handling, and rendering pipeline stages, focusing on optimizing tasks and ensuring lockless access. Additionally, it addresses challenges with particle emissions caused by overlapping emitters and the solutions explored, such as order-independent transparency techniques.
Get Multicore Differentiation and Great Integrated Graphics Performance
- 5. Game Tick thread is running ~10 fps
- 6. Main Thread and Render Thread are running in sync
- 7. Game Tick builds game state and passes it to main thread
- 14. We calculate intersection with all the frustums at once
- 15. Intersection results are stored in a bitfield
- 16. We calculate the area of the projected bounding box and cull small models
- 17. Then we select the LOD level based on the approximated average triangle size on screen
- 18. Then we select the LOD level based on the approximated average triangle size on screen
- 29. Next step is building instance data for the individual parts
- 31. Based on the mesh and instance data and the material we figure out which parts of the pipeline the mesh needs to be rendered to.
- 32. Each pipeline stage uses the same instance data.
- 33. Every single mesh has a number of instance lists. One instance list per pipeline stage. The instance is added to all the relevant instance lists.
- 34. The instance lists are duplicated to every worker thread to ensure lockless access.
- 35. And double buffered because while the render thread is rendering the current frame, the main thread (and workers) Is adding instances to the next frame’s instance lists.
- 36. We have one mesh list per mesh type. Every mesh with at least a single instance in the frame will get added to exactly one mesh list matching its mesh type.
- 37. Just like the instance lists we have one mesh list for every single worker thread.
- 44. We start by processing the mesh lists We run one task per mesh type
- 45. Per-thread mesh lists are combined to a single list of meshes
- 46. Per-thread mesh lists are combined to a single list of meshes
- 47. Then we process all the meshes in the list one by one
- 48. Each mesh has instance lists per pipeline stage
- 49. We start with the first pipeline stage and combine the instances there into a single list
- 50. Then we process the instances
- 51. Then process all subsequent stages sequentially
- 55. Instance data is now uploaded to the GPU and prepared for batching
- 60. The actual rendering follows the different pipeline stages
- 61. Each stage renders a selection of mesh types
- 62. The meshes are prepared by the render thread workers
- 63. We have to start by waiting for the preparation tasks to be finished
- 64. We have to start by waiting for the preparation tasks to be finished
- 65. The tasks process all meshes/instances for all pipeline stages We can use an atomic counter per pipeline stage
- 66. No need to further split the tasks We just increased the granularity of waiting for other sub-tasks
- 67. Usually everything is ready after the short initial wait
- 68. Usually everything is ready after the short initial wait
- 69. Usually everything is ready after the short initial wait
- 80. The basic building blocks of the system are emitters
- 81. Emitters are emitting a number of particles over time
- 82. Particles are often just sorted per emitter
- 83. Problems start happening when the emitters overlap
- 84. Problems start happening when the emitters overlap
- 85. We sort all the particles together
- 87. Emission takes place on the CPU
- 88. Sorting is responsible for moving dead particles to one end of the GPU buffer
- 89. This make uploading new particles trivial
- 90. Running out of particle space stomps over particles farthest from camera
- 91. (for Total War:THREE KINGDOMS) We were confident that order-independent transparency is the solution
- 92. First try was WBOIT
- 93. Second try was MBOIT
- 95. TW:3K was released with MBOIT