Negative Scaling Flips Face Winding (Affects backface culling)

Started by
11 comments, last by HardlineDigital 11 years ago

OK, so I was making an environment with modular set peices and thought I'd be clever by just negating the scale on certain objects to mirror them.

Only I now noticed that this causes my engine to flip the face culling on them. With back face culling, the opposite side of the object is visible when I negate one of the axes.

I guess I can try to determine what face culling mode to enable based on scale. I'm trying to figure out though, do most game engines try to allow for this and switch face culling state based on object scale or should I just make mirrored versions of my objects?

Also how would I reliably tell if I should front face cull or back face cull? I see that one axis being flipped causes this face culling flippage. Is face culling flipped with odd axis numbers, or any flipped axes? I tried searching for the pattern for this, and I can't find a reliable way to check the face culling mode based on scale. If no one has an answer I can try to spend some time experimenting.

Advertisement

Yeah, if you scale an odd number of axes by a negative amount, your winding order becomes reversed. This is to be expected and can't really be avoided.

If you want to support negative scale values for your models, you can either:
* not backface cull them tongue.png

* pick a culling order based on the number of negatively scaled axes.

* pick an index buffer based on the same (and have an alternative index buffer for each mesh, where the winding order is reversed).

Let's say we have the scaling matrix :

a 0 0 0

0 b 0 0

0 0 c 0

0 0 0 1

My guess is that if a*b*c<0 then the culling order must be inverted.

Let's say we have the scaling matrix :

a 0 0 0

0 b 0 0

0 0 c 0

0 0 0 1

My guess is that if a*b*c<0 then the culling order must be inverted.

Correct. More generally, it needs to be inverted whenever det(M) < 0.

I just tell our artists that they can't use negative scale, and that they have to deal with it. :P

You can handle that on the exporter :


int VertexIndex[ 3 ];
if( TMNegParity( tm ) )
{
  VertexIndex[ 0 ] = 1;
  VertexIndex[ 1 ] = 2;
  VertexIndex[ 2 ] = 0;
}
else
{
  VertexIndex[ 0 ] = 0;
  VertexIndex[ 1 ] = 2;
  VertexIndex[ 2 ] = 1;
}
...
for( int j = 0; j < 3; ++j )
{
  ...
  Pos = mesh->verts[ f->v[ VertexIndex[ j ] ] ];
  ...
}

The problem is that this usually happens *after* export. The OP mentioned using 'modular set pieces', so I'm picturing stamping down multiple copies of a simple object (tree, bench, whatever). In that situation, negative scale is a good way to add variety, but you have the culling problem. In any case, the methods suggested by Hodgman are probably the best.

Sometimes it happens before export especially in character models to mirror the right/left side or a character, in which case the export winding order flip is useful.

At run time yeah, just get the sign of x * y * z scale and reverse the culling mode if it is negative.

"Most people think, great God will come from the sky, take away everything, and make everybody feel high" - Bob Marley

Why do you need to have a negative scale factor? Seems to me that it just leads to an unhappy place that needs to be special-cased in your code.

throw table_exception("(? ???)? ? ???");

If you mirror an object in one axis it has a negative transform matrix determinant. Also if you do mirror tracks on racing games, etc.

"Most people think, great God will come from the sky, take away everything, and make everybody feel high" - Bob Marley

This topic is closed to new replies.

Advertisement