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.

2. Campaign is turn-based

3. Battle is RTS

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

9. Worker Threads

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.

38. Double buffered too.

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