Optimize polygons renderization

Question

I'm developing a game (in Ogre3D) that, in short, consist in a vehicle that moves along a terrain and leaves a colored trail behind it. The trails are basically quads (a), these quads changes their color accordingly to the vehicle's speed. My challenge now is that I need to subdivide these quads into 5 (or more) sub-polygons (b) and each one of them should have a different color accordingly to others vehicle's properties. When moving around for a while these quads start to accumulate on screen and the render process starts to heavily lag and thus fps count is sub optimal.

Some considerations: - All quads are appended to a single mesh that belongs to a single entity sharing the same material, so batching should be optimal. - Tried adding LOD for this mesh but I had no luck to make it work in Ogre1.9.

So, my main question is how can I optimize the rendering of this polygons?? Can I delegate this task by somehow to the gpu via shader programming?

Edit: My goal would be to avoid having to draw each one of those sub-quads in (b) (only draw the big quad (a)) but by somehow being able to colorize each one of those sub-quads.

Answer 1

NOTE: I am unfamiliar with Ogre3d but I do greatly enjoy optimizing things.

I would imagine that part of the issue is that you're going to be continually Allocating memory. What's worse, it sounds like you're appending this allocated memory to a structure you already have. What can happen is that as these accumulate you may be rewriting the structure as you append to it. If you're using a C# List, a C++ Vector, or many other datastructures, you could instead be requesting it allocate a contiguous block of size equal to double your current size, which will slowly cause it to fragment your memory and allocated giant chunks. Definitely look into how you're allocating your memory for this, and really consider how badly you need these to be truly a single mesh rather than simply adjacent to one another.

Secondly, it sounds as though you're trying to solve your problem with more Polygons when you don't need them. For instance, if you wrote a shader that took those properties and simply colored the original polygon in sections according to the data you want, you could easy save yourself the quin-tupling of quads you're experiencing.

Lastly, it also sounds as though you're possibly "rendering" things that aren't on screen, when this is unnecessary. If these things exist as a way to see the history of how your vehicle traveled, you can simply care about the ones that are in view. Be sure you're only rendering those that are on screen.

Without code I'm not sure there's anything else I could suggest. Hope this helps!

Answer 2

Disclaimer: I am not familiar with Ogre3D.

You can manage to do the effect you want via shaders.

Since I am only familiar with GLSL I will be using that...

First off all, whatever changes from quad to quad (for example the speed of the vehicle) you need to pass it as an attribute. I will assume we pass four such properties (based on the example image) and they dictate the intensity of the colors of the bands.

Note: I say quad, but there is no difference if you are using triangle primitives. I fact I tested this with triangles.

Now, how does the shader knows the positions to place those colors? Well, you need to pass an additional attribute for that. Sure, it can be standard texture coordinates, but it does not need to be. It makes no difference.

With that said, our vextex shader will be doing passthrough, so we can use the properties in the fragment shader:

#version 330

layout (location = 0) in vec3 VertexPosition;
layout (location = 1) in float prop1;
layout (location = 2) in float prop2;
layout (location = 3) in float prop3;
layout (location = 4) in float prop4;
layout (location = 5) in float pos;

smooth out float vprop1;
smooth out float vprop2;
smooth out float vprop3;
smooth out float vprop4;
smooth out float vpos;

void main()
{
    vprop1 = prop1;
    vprop2 = prop2;
    vprop3 = prop3;
    vprop4 = prop4;
    vpos = pos;
    gl_Position = vec4(VertexPosition, 1.0f);
}

OpenGl will interpolate the values for us. Thus, if we pass pos=0 on one side of the quad and pos=1 on the other, we get a gradient. That is what we will be using that on the fragment shader to place the colors.

The other attributes (prop1, prop2, prop3, prop4) are going to tell the intensity of the colors. The code I wrote for that uses a vec4 to specify the color of each band and use scalar product.

Notice also that - with this shader code - OpenGL will also interpolate the values of the other attributes. This means that if you set the old values on the bottom of the quad and the new ones on the top you get a nice gradient.

This is the fragment shader I wrote for this:

#version 330

smooth in float vprop1;
smooth in float vprop2;
smooth in float vprop3;
smooth in float vprop4;
smooth in float vpos;

out vec4 FragColor;

void main()
{
    vec4 s =
          ((step(0.75, vpos) - step(1.00, vpos)) * vec4(0.0, 1.0, 1.0, 0.5) * vprop1)
        + ((step(0.50, vpos) - step(0.75, vpos)) * vec4(0.0, 0.0, 1.0, 0.5) * vprop2)
        + ((step(0.25, vpos) - step(0.50, vpos)) * vec4(0.0, 1.0, 0.0, 0.5) * vprop3)
        + ((step(0.00, vpos) - step(0.25, vpos)) * vec4(1.0, 1.0, 0.0, 0.5) * vprop4);
    FragColor = s;
}

Here the step function will give me hard edges for the colors. ((step(0.75, vpos) - step(1.00, vpos)) will be 1 when vpos is in the range from 0.75 to 1.00, and it will be 0 otherwise. Similarly happens with the other terms. Yes, I have extra zeroes after the comma, for readability.

The code above puts alpha on 0.5. Use whatever you need.

---

Aside from that, you are probably better off using an array to store your vertex, and use it as a circular buffer (once you get to the end, you start overwriting at the start). Using Triangles or Quads primitive type (but not strips or fans). Doing that you know it won't grow. I do not know how permisive Ogre3D is about that.

As, as I said, you can animate the quads fading away. You can add another attribute for the time when the quad was created, and pass the current time as a uniform to the shaders (Note: you do not need passthrough uniforms, you can use them directly in the fragment shader). That way the fragment shader knows how much time has passed since the Quad was created, and use that for setting alpha. Figure out what do you need to do on Ogre3D to get alpha blending working properly for the transparency effect.