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

Question

Merging Static Geometries vs Individual Entities
When targeting mobile browsers with limited GPU bandwidth, the decision between pre‑merging static meshes into a single BufferGeometry or rendering each entity separately can directly influence frame‑rate performance.
Key constraints:

Merge cost: one‑time CPU overhead using BufferGeometryUtils.mergeBufferGeometries, no runtime draw‑call penalty.
Individual entities: higher draw‑call count but allow per‑entity animation, physics, and unique material overrides.
Dynamic content: merged geometries must be rebuilt on any change, potentially stalling the main thread.
GPU limits: a very large merged geometry may exceed vertex or memory limits on older mobile GPUs.

To evaluate which strategy best meets mobile frame‑rate goals, consider the following:

For 200 static cubes sharing a material, does merging into a single BufferGeometry reduce draw calls enough to noticeably improve FPS on an average Android device?
How does the one‑time CPU cost of merging compare to the runtime draw‑call overhead on typical mobile GPUs (e.g., Adreno 630 vs Apple A14)?
What GPU limits might be exceeded by a large merged geometry on older mobile GPUs, and how can these be mitigated?

Tasadduq Burney · Answer

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:

Group by Material: Identify objects that share the exact same material and texture set.
  Batch Static Groups: Use BufferGeometryUtils.mergeBufferGeometries for static objects that are spatially close.
  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.
  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?

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

Merging Static Geometries vs Individual Entities

1 answer

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.

The Bottleneck Analysis

When to Avoid Merging

Practical Implementation Strategy

Your perspective belongs here.

1 question comment