Merging Static Geometries vs Individual Entities: Which Approach Yields Higher Mobile Frame Rates?

Merging static geometries typically yields higher frame rates on mobile devices by reducing draw call overhead, which is often the primary bottleneck on mobile CPUs and GPU drivers.

In mobile environments, the cost of issuing a draw call to the GPU is significantly higher than the cost of processing the actual vertices themselves. By merging hundreds of static objects into a single BufferGeometry, you collapse hundreds of API calls into one, allowing the GPU to process the geometry in a single pass without state changes.

The Bottleneck Analysis

Mobile GPUs, such as the Adreno or Apple A-series chips, are highly sensitive to memory bandwidth compared to desktop counterparts. When rendering individual entities:

• CPU Overhead: Each entity requires the CPU to set state (matrices, shaders, textures) and issue a command. With 200 entities, this can exhaust the main thread's budget before the GPU even starts working.
• GPU State Changes: Frequent switching between materials or textures for individual entities stalls the rendering pipeline.

Merging solves these issues by batching data into a single buffer. However, this is not a "silver bullet" and involves trade-offs:

When to Avoid Merging

While merging is faster for static objects, it introduces constraints that can actually degrade performance if overused:

• Culling Efficiency: If you merge 200 cubes into one mesh and only one is visible, the GPU must still process the vertices for all 200 cubes. Individual entities benefit from frustum culling.
• Dynamic Updates: If an entity needs to move, you must either rebuild the entire merged geometry (high CPU cost) or use vertex shaders for offsets, which can cause frame stutters (stuttering) on mobile devices.
• Memory Limits: Extremely large merged geometries can hit vertex buffer size limits on older mobile hardware, leading to rendering failures or crashes.

Practical Implementation Strategy

To optimize your mobile project, follow these steps:

1. Group by Material: Identify objects that share the exact same material and texture set.
2. Batch Static Groups: Use BufferGeometryUtils.mergeBufferGeometries for static objects that are spatially close.
3. Spatial Partitioning: Instead of one giant mesh for the whole level, merge objects into "chunks." This allows the engine to cull chunks that are behind the camera while still keeping draw calls low.
4. Use Individual for Dynamic: Keep entities that require physics, animation, or frequent movement as individual entities.

To provide a more specific recommendation, are these 200 entities moving during gameplay, or are they entirely environmental?