<p>The straightforward solution is to simple not render the high poly model at all. Have a lower detail model that you can switch to once the model is too far away for it to make a difference. There is no point in rendering 20 triangles that all end up in the same pixel.</p>

<p>Next option is to partition the model and then cull the individual parts. You can also make each (set of) patch have different Levels of detail. </p>

<p>This partition can take the form of patches that are mostly flat. That way you can use backface culling on the whole group by taking the dot product of the average normal and comparing it to the look vector, if it is too large only the backsides will be showing and there is no point in rendering that patch.</p>

CC BY-SA 4.0
2019-06-27T22:13:31.070Z
Great thanks, do you know where could I find information on some common partition methods?
tester
CC BY-SA 4.0
2019-06-27T16:14:56.843Z
2019-06-27T16:14:56.843Z
ratchet freak
<p>My first thought (aside from culling) is to perform some sort of distance based level of detail algorithm. I've heard of systems in the past that could selectively remove edges and merge faces to produce lower detail sections on a single mesh, but most systems go for the far simpler method of simply loading in an entirely separate lower detail model once the higher detail model moves far enough from the camera.</p>

CC BY-SA 4.0
2019-06-28T00:47:17.053Z
2019-06-28T00:47:17.053Z
RoboticForest
<p>I would like to know what common techniques are used for rendering large models, when using rasterisation within a graphics API, for example OpenGL or Vulkan. </p>

<p>For example if I had a model with >10 million triangles, and it would be too slow to render the whole model, what optimisation steps or techniques could I use?</p>

<p>I am currently aware of:</p>

<ul>
<li><strong>Frustum culling</strong></li>
<li><strong>Occlusion culling</strong></li>
</ul>

<p>I would not know how to apply frustum culling to a single model. I know it can be used for multiple models:</p>

<pre><code>for( int i=0; i &lt; numObjects; i++ )
{
    if( insideFrustrum( objects[i] )
    {
        addModelToBeRendered( objects[i] );
    }
}
</code></pre>

<ol>
<li>Can frustum culling be applied to a single model/mesh?</li>
<li>What other techniques besides the two stated can be used when rendering large data-sets?</li>
</ol>

CC BY-SA 4.0
2019-06-27T10:46:07.283Z
It entirely depends on what type of renderer you're talking about. Techniques appropriate to ray-tracing aren't necessarily appropriate to triangle rasterisation, and vice-versa. If you're using scanline rasterisation, are you asking from the POV of someone designing a GPU, implementing OpenGL (or similar) in software, or writing an application that sends triangles to an OpenGL implementation?
Dan Hulme
CC BY-SA 4.0
2019-06-27T13:09:27.627Z
@DanHulme I have edited the post with more specific details. (Rasterisation when using a graphics API like OpenGL or Vulkan)
tester
<algorithm><computational-geometry><occlusion>
Techniques for rendering high polycount models
tester
# Techniques for rendering high polycount models

(Asked by: username_0 on 2019-06-27)

I would like to know what common techniques are used for rendering large models, when using rasterisation within a graphics API, for example OpenGL or Vulkan.

For example if I had a model with >10 million triangles, and it would be too slow to render the whole model, what optimisation steps or techniques could I use?

I am currently aware of:

* **Frustum culling**
* **Occlusion culling**

I would not know how to apply frustum culling to a single model. I know it can be used for multiple models:

```
for( int i=0; i < numObjects; i++ )
{
    if( insideFrustrum( objects[i] )
    {
        addModelToBeRendered( objects[i] );
    }
}

```

1. Can frustum culling be applied to a single model/mesh?
2. What other techniques besides the two stated can be used when rendering large data-sets?

**Tags:** algorithm, computational-geometry, occlusion

> **Comments:**
> **username_1**: It entirely depends on what type of renderer you're talking about. Techniques appropriate to ray-tracing aren't necessarily appropriate to triangle rasterisation, and vice-versa. If you're using scanline rasterisation, are you asking from the POV of someone designing a GPU, implementing OpenGL (or similar) in software, or writing an application that sends triangles to an OpenGL implementation?  
> **username_0**: @username_1 I have edited the post with more specific details. (Rasterisation when using a graphics API like OpenGL or Vulkan)  

---

## 2 answers

### Answer by username_2 on 2019-06-27. Score: 1 | Accepted answer

The straightforward solution is to simple not render the high poly model at all. Have a lower detail model that you can switch to once the model is too far away for it to make a difference. There is no point in rendering 20 triangles that all end up in the same pixel.

Next option is to partition the model and then cull the individual parts. You can also make each (set of) patch have different Levels of detail.

This partition can take the form of patches that are mostly flat. That way you can use backface culling on the whole group by taking the dot product of the average normal and comparing it to the look vector, if it is too large only the backsides will be showing and there is no point in rendering that patch.

> **Comments:**
> **username_0**: Great thanks, do you know where could I find information on some common partition methods?  

---

### Answer by username_3 on 2019-06-28. Score: 0

My first thought (aside from culling) is to perform some sort of distance based level of detail algorithm. I've heard of systems in the past that could selectively remove edges and merge faces to produce lower detail sections on a single mesh, but most systems go for the far simpler method of simply loading in an entirely separate lower detail model once the higher detail model moves far enough from the camera.


---

