Sign in to follow this  
Husbj

DX11 Getting around non-connected vertex gaps in hardware tessellation displacement mapping

Recommended Posts

Sorry for the long title, couldn't figure out how to express it shorter without being overly ambigious as to what this post is about.

 

Anyway, I've been poking around with displacement maping using the hardware tessellation features of DX11 for getting some more vertices to actually displace the last few days, for no particular reason other than to try it out so I'm not really looking for other ways to solve some specific problem.

Displacing a sphere or some other surface with completely connected faces work out as intended but issues obviously occur where there are multiple vertices with the same position but different normals (these vertices then get displaced in different directions and thus become disconnected => gaps appear in the geometry). I tried to mock up some simple solution to this by finding out which vertices share positions in my meshes and then setting a flag for these to tell my domain shader to not displace those vertices at all; it wouldn't be overly pretty but at least the mesh should be gapless and it hopefully wouldn't be too noticeable I reasoned. Of course this didn't work out very well (the whole subdivision patches generated from such overlapping vertices had their displacement factors set to 0 creating quite obvious, large frames around right angles and such). What I'm wondering is basically if this is a reasonable approach to try to refine further or if there are other ways to go about it that may be better? The only article on the topic I've managed to find mostly went on about the exquisitness of Bezier curves but didn't really seem to come to any conclusions (although maybe those would've been obvious to anyone having the required math skills).

Thankful for any pointers on this, the more I try to force this, the more it feels like I'm probably missing something.

 

As for my implementation of the tessellation, I've mostly based it around what is described in chapter 18.7 and 18.8 of Introduction to 3D Game Programming With DirectX 11 (http://www.amazon.com/Introduction-3D-Game-Programming-DirectX/dp/1936420228).

Share this post


Link to post
Share on other sites

Thanks MJP.

I don't suppose there's any video / audio recording of the presentation using those slides available somewhere, possibly for a nominal fee?

 

On a more off-topic note, I recognize that avatar of yours but have been unable to remember the name of the show (or was it possibly a book?) it featured in, care to enlighten me? 

Share this post


Link to post
Share on other sites

I think i have implemented index buffer for PN-AEN as described in that pdf document, but once i finished i saw that patch funcion HS_Constant is missing from shader that they have provided in appendix. sad.png

Copy-paste error. laugh.png

 

 


D3D11 ERROR: ID3D11DeviceContext::DrawIndexed: Mismatched topology. Current Hull Shader expects input Control Point count of 3, but Input Assembler topology defines a patch list with 9 Control Points per patch. [ EXECUTION ERROR #2097222: DEVICE_DRAW_HULL_SHADER_INPUT_TOPOLOGY_MISMATCH]

 

Damn. Why did they provide code that does not work.

 

edit 6841:

I get shader to work this time but i am not sure if i have indices right as i see no displacement.

normal.jpg

 

if i add displacement along normal:

... // domain shader
float3 n = mul(f3Normal, (float3x3)g_f4x4WorldView);
    n = normalize(n);
    f3EyePosition += n * 0.02f;

disp.jpg

CRACKS!

void Test::calcPNAENIndices(const std::vector<USHORT>& ind, const std::vector<VERTEX>& verts, std::vector<USHORT>& out)
{
    out.resize(ind.size() * 3);
    for (std::size_t i = 0; i < ind.size(); i += 3)
    {
        out[3 * i + 0] = ind[i + 0];
        out[3 * i + 1] = ind[i + 1];
        out[3 * i + 2] = ind[i + 2];

        out[3 * i + 3] = ind[i + 0];
        out[3 * i + 4] = ind[i + 1];
        out[3 * i + 5] = ind[i + 1];

        out[3 * i + 6] = ind[i + 2];
        out[3 * i + 7] = ind[i + 2];
        out[3 * i + 8] = ind[i + 0];
    }

    struct Edge
    {
        float3 p[2];
        USHORT inx[2];

        bool operator == (const Edge& o) const
        {
            if (inx[0] == o.inx[0] && inx[1] == o.inx[1])
                return true;

            if (Equal(p[0].x, o.p[0].x) && Equal(p[0].y, o.p[0].y) && Equal(p[0].z, o.p[0].z))
            {
                if (Equal(p[1].x, o.p[1].x) && Equal(p[1].y, o.p[1].y) && Equal(p[1].z, o.p[1].z))
                {
                    return true;
                }
            }

            return false;
        }
    };
 
    // reverse edges
    std::vector<Edge> edges;
    edges.resize(ind.size());
    for (std::size_t i = 0; i < ind.size(); i += 3)
    {
        edges[i + 0].p[1]   = verts[ind[i + 0]].pos;
        edges[i + 0].p[0]   = verts[ind[i + 1]].pos;
        edges[i + 0].inx[1] = ind[i + 0];
        edges[i + 0].inx[0] = ind[i + 1];

        edges[i + 1].p[1]   = verts[ind[i + 1]].pos;
        edges[i + 1].p[0]   = verts[ind[i + 2]].pos;
        edges[i + 1].inx[1] = ind[i + 1];
        edges[i + 1].inx[0] = ind[i + 2];

        edges[i + 2].p[1]   = verts[ind[i + 2]].pos;
        edges[i + 2].p[0]   = verts[ind[i + 0]].pos;
        edges[i + 2].inx[1] = ind[i + 2];
        edges[i + 2].inx[0] = ind[i + 0];
    }
 
    // compare
    for (std::size_t i = 0, j = 0; i < out.size(); i += 9, j += 3)
    {
        Edge e;

        // edge 0
        e.p[0]   = verts[out[i + 0]].pos;
        e.p[1]   = verts[out[i + 1]].pos;
        e.inx[0] = out[i + 0];
        e.inx[1] = out[i + 1];

        if (e == edges[j + 0])
        {
            out[i + 0] = edges[j + 0].inx[0];
            out[i + 1] = edges[j + 0].inx[1];
        }

        // edge 1
        e.p[0]   = verts[out[i + 1]].pos;
        e.p[1]   = verts[out[i + 2]].pos;
        e.inx[0] = out[i + 1];
        e.inx[1] = out[i + 2];

        if (e == edges[j + 0])
        {
            out[i + 1] = edges[j + 0].inx[0];
            out[i + 2] = edges[j + 0].inx[1];
        }

        // edge 2
        e.p[0]   = verts[out[i + 2]].pos;
        e.p[1]   = verts[out[i + 3]].pos;
        e.inx[0] = out[i + 2];
        e.inx[1] = out[i + 3];

        if (e == edges[j + 0])
        {
            out[i + 2] = edges[j + 0].inx[0];
            out[i + 3] = edges[j + 0].inx[1];
        }

        // edge 3
        e.p[0] = verts[out[i + 3]].pos;
        e.p[1] = verts[out[i + 4]].pos;
        e.inx[0] = out[i + 3];
        e.inx[1] = out[i + 4];

        if (e == edges[j + 1])
        {
            out[i + 3] = edges[j + 1].inx[0];
            out[i + 4] = edges[j + 1].inx[1];
        }

        // edge 4
        e.p[0] = verts[out[i + 4]].pos;
        e.p[1] = verts[out[i + 5]].pos;
        e.inx[0] = out[i + 4];
        e.inx[1] = out[i + 5];

        if (e == edges[j + 1])
        {
            out[i + 4] = edges[j + 1].inx[0];
            out[i + 5] = edges[j + 1].inx[1];
        }

        // edge 5
        e.p[0] = verts[out[i + 5]].pos;
        e.p[1] = verts[out[i + 6]].pos;
        e.inx[0] = out[i + 5];
        e.inx[1] = out[i + 6];

        if (e == edges[j + 1])
        {
            out[i + 5] = edges[j + 1].inx[0];
            out[i + 6] = edges[j + 1].inx[1];
        }

        // edge 6
        e.p[0] = verts[out[i + 6]].pos;
        e.p[1] = verts[out[i + 7]].pos;
        e.inx[0] = out[i + 6];
        e.inx[1] = out[i + 7];

        if (e == edges[j + 2])
        {
            out[i + 6] = edges[j + 2].inx[0];
            out[i + 7] = edges[j + 2].inx[1];
        }

        // edge 7
        e.p[0]   = verts[out[i + 7]].pos;
        e.p[1]   = verts[out[i + 8]].pos;
        e.inx[0] = out[i + 7];
        e.inx[1] = out[i + 8];

        if (e == edges[j + 2])
        {
            out[i + 7] = edges[j + 2].inx[0];
            out[i + 8] = edges[j + 2].inx[1];
        }

        // edge 8
        e.p[0] = verts[out[i + 8]].pos;
        e.p[1] = verts[out[i + 0]].pos;
        e.inx[0] = out[i + 8];
        e.inx[1] = out[i + 0];

        if (e == edges[j + 2])
        {
            out[i + 8] = edges[j + 2].inx[0];
            out[i + 0] = edges[j + 2].inx[1];
        }
    }
}
Edited by belfegor

Share this post


Link to post
Share on other sites


I don't suppose there's any video / audio recording of the presentation using those slides available somewhere, possibly for a nominal fee?

 

Not that I know of, sorry.

 


On a more off-topic note, I recognize that avatar of yours but have been unable to remember the name of the show (or was it possibly a book?) it featured in, care to enlighten me?

 

It's Rocko!

Share this post


Link to post
Share on other sites

I think i had some mistakes in code, having hard time to understand what exactly i need to do.

Here is corrected version but still wrong results. sad.png

void Test::calcPNAENIndices(const std::vector<USHORT>& ind, const std::vector<VERTEX>& verts, std::vector<USHORT>& out)
{
    struct Edge
    {
        float3 p[2];
        USHORT inx[2];

        bool operator == (const Edge& o) const
        {
            if (inx[0] == o.inx[0] && inx[1] == o.inx[1])
                return true;

            if (Equal(p[0].x, o.p[0].x) && Equal(p[0].y, o.p[0].y) && Equal(p[0].z, o.p[0].z))
            {
                if (Equal(p[1].x, o.p[1].x) && Equal(p[1].y, o.p[1].y) && Equal(p[1].z, o.p[1].z))
                {
                    return true;
                }
            }

            return false;
        }
    };

    std::vector<Edge> edges(ind.size());
    out.resize(ind.size() * 3);

    for (std::size_t i = 0; i < ind.size(); i += 3)
    {
        // initial values
        out[3 * i + 0] = ind[i + 0];
        out[3 * i + 1] = ind[i + 1];
        out[3 * i + 2] = ind[i + 2];

        out[3 * i + 3] = ind[i + 0];
        out[3 * i + 4] = ind[i + 1];
        out[3 * i + 5] = ind[i + 1];

        out[3 * i + 6] = ind[i + 2];
        out[3 * i + 7] = ind[i + 2];
        out[3 * i + 8] = ind[i + 0];

        // store reversed
        edges[i + 0].p[1]   = verts[ind[i + 0]].pos;
        edges[i + 0].p[0]   = verts[ind[i + 1]].pos;
        edges[i + 0].inx[1] = ind[i + 0];
        edges[i + 0].inx[0] = ind[i + 1];

        edges[i + 1].p[1]   = verts[ind[i + 1]].pos;
        edges[i + 1].p[0]   = verts[ind[i + 2]].pos;
        edges[i + 1].inx[1] = ind[i + 1];
        edges[i + 1].inx[0] = ind[i + 2];

        edges[i + 2].p[1]   = verts[ind[i + 2]].pos;
        edges[i + 2].p[0]   = verts[ind[i + 0]].pos;
        edges[i + 2].inx[1] = ind[i + 2];
        edges[i + 2].inx[0] = ind[i + 0];
    }

    for (std::size_t i = 0; i < out.size(); i += 9)
    {
        // i think i should skip first 3 indices as they point to triangle and i need to check edges
        for (std::size_t j = 3; j < 9; ++j)
        {
            std::size_t first  = j;
            std::size_t second = j + 1;
            if (second == 9)
                second = 3;

            Edge e;
            e.p[0]   = verts[out[i + first]].pos;
            e.p[1]   = verts[out[i + second]].pos;
            e.inx[0] = out[i + first];
            e.inx[1] = out[i + second];

            for (std::size_t k = 0; k < edges.size(); ++k)
            {
                if (e == edges[k])
                {
                    out[i + first]  = edges[k].inx[0];
                    out[i + second] = edges[k].inx[1];
                }
            }
        }
    }
}

Can someone take a look please and decipher instructions given for this to work:

 

 

1.  Create an output IB that is 3 times the size of input IB.

2.  For each input Triangle in IB, with indices i0, i1 and i2:
    a.  Write out an initial output entry of:  i0, i1, i2, i0, i1, i1, i2, i2, i0, which sets edges to

        initially be neighbors of themselves. This would produce identical results to PN
        Triangles.
    b.  Lookup the positions p0, p1, and p2, using i0, i1 and i2 to perform a lookup for
        position of the associated vertex in VB.
    c.  Define 3 Edges, which consist of the two indices and two positions that make up
        the corresponding Edge. An Edge should consist of the origin index, the
        destination index, the origin position and the destination position.
    d.  For each edge, store the reverse of that edge in an easily searchable data structure
        for the next step. The reference implementation uses an stdext::hash_map<Edge,
        Edge> for this purpose. Reverse simply flips the sense of the edge (originating at
        the destination position and index and heading to the origin position and index).

 

3.  Walk the output index buffer (OB) constructed in step 2. For each patch of 9 indices:
    a.  For each Edge in the current Patch, perform a lookup into Edge->Edge mapping
        created in step 2d.
    b.  If found, replace the current indices with the indices found in the map. Note that
        two edges should be considered matching if their "from" and "to" indices match,
        OR if their "from" and "to" positions match.
    c.  If not, continue to use the existing indices.

Upon completion of this algorithm, a buffer suitable for usage with PN-AEN will be
available.

 

Edited by belfegor

Share this post


Link to post
Share on other sites

That is that. Thank you very much. smile.png

 

With "initial" IB (notice cracks):

crack.jpg

 

PNAEN

good.jpg

 

Now i would like to displace position along normal using heightmap but i dont know how to get average normal so i can pass it to domain shader. Any pointers?

Share this post


Link to post
Share on other sites
Now the real challenge starts. Here the sample goes the easy way and just passes the normals from the inner triangle and interpolates linearly. "Correct" PN triangles uses a quadratic bezier patch for the normals, examples of which you can find in the (June 2010 SDK) samples or in the Hieroglyph 3 engine (there's also full chapter in the Practical Rendering book).
There's also a displacement tesselation sample using decals in the SDK which might be worth a peek.

Either way it sounds complex as the presentation MJP linked to shows. Can't help you any further now, I haven't done displacement mapping (not counting terrain). For a simple start maybe you can get away averaging normals at corners (not using a bezier quad patch and taking averaged normals from all adjacent triangles). But that's really just an idea.

Anyway, looks like it also needs special care on the content creation side (citing above presentation).

Speaking of which (and out of curiosity): Why does that pig/boar generate cracks ? I wouldn't expect them on organic surfaces (the initial index buffer results in usual PN triangles). You got a link to that mesh ?

Share this post


Link to post
Share on other sites


It's Rocko!

Ah yes, haha, remember watching that in the mid-late 90's. Maybe worth a rewatch now that I'm old enough to actually understand it better than back then...

 

As for the displacement mapping I eventually settled on a rather simple approach for use with pre-existing triangle list meshes (it is by no means perfect but it seems that the "real" solution is really just having the 3D / texturing artist(s) being aware of your intents and have them author appropriately mapped bump maps and ensure corners actually are rounded, albeit with extremely short edges between corner vertices, as seemed to be the main point that the chapter in Zink, Pettineo & Hoxley (2011) as referred by unbird in the last post). Basically I average all disjoint vertex normals and create a 6-control patch index buffer that holds the initial triangle in the first 3 indices and then any "dominant" vertices sharing the position of these original vertices in the last 3 indices. The dominant vertices are arbitrarily chosen as the first found in the vertex data for a given position and are set to the same vertex as in the first three indices if there are no shared vertices at a given position. The dominant vertex is used to ensure that all overlapping vertices will sample the same value from the displacement map, while still allowing them to sample other textures by their UV coords.

Not perfect but good enough for some general-purpose examples.

As for actually employing this kind of displacement mapping in a more professional game / visual demo / what-have-you, the artist should ensure that there are *no* disjoint vertices (as said, such vertices can be moved slightly apart and be connected by a short edge, allowing the corners to appear mostly sharp) and a secondary set of texture coordinates should be provided for the displacement map / alternatively the displacement map should be handcrafted such that when displaced (with a reasonable strength / height factor), faces won't extrude through each others.

Of course there exists more elaborate ways as described in the previous posts, I just thought I would share this if anyone found it interesting, After tracking down a copy of that practical rendering book just for that tessellation chapter, it didn't say that much more about this particular problem, so might as well save others the trouble.

Share this post


Link to post
Share on other sites

Hi,

i'm struggling with PN AEN now for two weeks and I'm not sure where my mistake could be... I'm pretty sure, the indices are correct, since I tried out unbirds exmaple and get the same indices. However my result looks like this:screenshot.png

 

I get the same result as with PN Triangles, no difference.

 

My TCS is:

#version 420
layout (vertices = 9) out;
in vec3 vp[];
in vec2 UV[];
in vec3 vn[];
out vec3 vpos[];
out vec2 outuv[];
out vec3 vnor[];
uniform vec3  tessLevelOuter;
uniform float tessLevelInner;

patch out Patch
{
    vec3 b210;
    vec3 b120;
    vec3 b021;
    vec3 b012;
    vec3 b102;
    vec3 b201;
    vec3 b111;
    vec3 n110;
    vec3 n011;
    vec3 n101;
	vec2 t110;
    vec2 t011;
    vec2 t101;
} OutPatch;

#define b300 vp[0]
#define b030 vp[1]
#define b003 vp[2]

#define n200 vn[0]
#define n020 vn[1]
#define n002 vn[2]

#define t200 UV[0]
#define t020 UV[1]
#define t002 UV[2]

void main()
{

	if( gl_InvocationID == 0 )
		{
			gl_TessLevelOuter[0] = tessLevelOuter[0];
			gl_TessLevelOuter[1] = tessLevelOuter[1];
			gl_TessLevelOuter[2] = tessLevelOuter[2];
			gl_TessLevelInner[0] = tessLevelInner;
		}
		vpos[gl_InvocationID]=vp[gl_InvocationID];
		vnor[gl_InvocationID]=vn[gl_InvocationID];
		outuv[gl_InvocationID]=UV[gl_InvocationID];
		
		if( gl_InvocationID == 0 )
    {

						 
						 
		OutPatch.b210 = (2.0 * b300 + b030 - dot( b030 - b300, n200 ) * n200 + 2.0 * vp[3] + vp[4] - dot( vp[4] - vp[3], vn[3] ) * vn[3] ) / 6.0;
        OutPatch.b120 = (2.0 * b030 + b300 - dot( b300 - b030, n020 ) * n020 +2.0 * vp[4] + vp[3] -dot( vp[3] - vp[4], vn[4] ) * vn[4] ) / 6.0;
        OutPatch.b021 = (2.0 * b030 + b003 - dot( b003 - b030, n020 ) * n020 +2.0 * vp[5] + vp[6] - dot( vp[6] - vp[5], vn[5] ) * vn[5] ) / 6.0;
        OutPatch.b012 = (2.0 * b003 + b030 - dot( b030 - b003, n002 ) * n002 +2.0 * vp[6] + vp[5] - dot( vp[5] - vp[6], vn[6] ) * vn[6] ) / 6.0;
        OutPatch.b102 = (2.0 * b003 + b300 - dot( b300 - b003, n002 ) * n002 +2.0 * vp[7] + vp[8] -dot( vp[8] - vp[7], vn[7] ) * vn[7] ) / 6.0;
        OutPatch.b201 = (2.0 * b300 + b003 - dot( b003 - b300, n200 ) * n200 + 2.0 * vp[8] + vp[7] -dot( vp[7] - vp[8], vn[8] ) * vn[8] ) / 6.0;
				 
		OutPatch.b111 = (OutPatch.b210 + OutPatch.b120 + OutPatch.b021 +
                         OutPatch.b012 + OutPatch.b102 + OutPatch.b201) / 4.0 - (b300 + b030 + b003) / 6.0;				 
						 
						 
						 

        const vec3 d0 = b030 - b300;
        const vec3 d1 = b003 - b030;
        const vec3 d2 = b300 - b003;
        const vec3 n0 = n020 + n200;
        const vec3 n1 = n002 + n020;
        const vec3 n2 = n200 + n002;
        const vec3 v0 = (2.0 * dot( d0, n0 ) / dot( d0, d0 )) * d0;
        const vec3 v1 = (2.0 * dot( d1, n1 ) / dot( d1, d1 )) * d1;
        const vec3 v2 = (2.0 * dot( d2, n2 ) / dot( d2, d2 )) * d2;
        OutPatch.n110 = normalize( n0 - v0 );
        OutPatch.n011 = normalize( n1 - v1 );
        OutPatch.n101 = normalize( n2 - v2 );
     }
}

Any ideas what I'm doing wrong?

Share this post


Link to post
Share on other sites

Off the top of my head each individual face of your cube is tessellated and then displaced.

You need to ensure that the edge vertices are shared in each (subdivided) side-face or else these seams will occur since all vertices on the top face are displaced only along the up axis and all vertices of the front face are displaced only along the depth axis.

A simple solution is to displace along the vertex normals and ensure that whereever you have overlapping vertices (such as at the corners of a cube) you set the normal of all such vertices to the average of all "actual" vertex normals at that position. This will make the edges a bit more bulky but keep the faces connected.

 

My previous post in this thread (just above yours) describes how I solved this in a relatively simple way in more detail.

Share this post


Link to post
Share on other sites

I'm not doing any Displayment mapping so far.

My TES looks like this:

	vec3 vp=vpos[0] * w * w * w +
                          b030 * u * u * u +
                          b003 * v * v * v + 
						  InPatch.b210 * 3.0 * w * w * u + 
                          InPatch.b120 * 3.0 * w * u * u +
                          InPatch.b201 * 3.0 * w * w * v +
                          InPatch.b021 * 3.0 * u * u * v +
                          InPatch.b102 * 3.0 * w * v * v +
                          InPatch.b012 * 3.0 * u * v * v +
                          InPatch.b111 * 6.0 * w * u * v; 

	vec3 vn= normalize( n200 * w * w + n020 * u * u + n002 * v * v +
                             InPatch.n110 * w * u + InPatch.n011 * u * v + InPatch.n101 * w * v );

About the screenshot above: I'm not applying any displacement yet. The cube simply cracks by smoothing the surface. As far as I understood this is a known issue with PN, but PNAEN shouldn't have this problem.

I know that you meant dominant UV to solve displacement map cracking, but I still have PN cracking with PNAEN.

Share this post


Link to post
Share on other sites

I just fed a standard cube to my shader and it stays a cube with flat sides, no matter the tesselation factors (both PN and PNAEN). Makes sense if you use the axis-aligned normals and not averaged, like suggested several times (the bezier surfaces are indeed flat if all normals are equal). Maybe you stumbled across the same bug I did (vertex shader, not normalized normals therefore wrong control point calculation).

 

Edit: How does your PN behave for a nice model like a sphere ?

Edited by unbird

Share this post


Link to post
Share on other sites

I just fed a standard cube to my shader and it stays a cube with flat sides, no matter the tesselation factors (both PN and PNAEN). Makes sense if you use the axis-aligned normals and not averaged, like suggested several times (the bezier surfaces are indeed flat if all normals are equal).

At first I used a standard cube generated by Maya and the cube stayed flat exactly as you said. Then I changed the normals of the cube like this:

cubes.png

PN got the cracks as expected, but PN doesn't look smooth like in the graphic above and looks 100% like PN.

 Maybe you stumbled across the same bug I did (vertex shader, not normalized normals therefore wrong control point calculation).

I tried that, adding normalize in the Vertexshader, but no difference, still cracks.

 

Edit: How does your PN behave for a nice model like a sphere ?

Looks smooth, no cracks. No difference to flat tessealtion or PNAEN.

Share this post


Link to post
Share on other sites
OK, now I made you move in circles, sorry about that. I can only guess: Either your re-indexing goes wrong or the shader has a bug (well, not very helpful either, I know).
 
You might show your re-indexing code, maybe someone spots something. Also, my test case is probably too small. Can you put that cube up for download (preferably in a common exchange format like Wavefront) ? I'll run it through my reindexer and give you the results.
 
As for the shader: Cannot help you there, I'm really just a D3D guy wink.png. You might have more luck in the OpenGL forum. Though if you carefully translated it from the paper it should work (apart from the vertex shader bug).

Share this post


Link to post
Share on other sites

You might show your re-indexing code, maybe someone spots something. Also, my test case is probably too small.

 

Here is my indexing code:

void indexPNAEN(std::vector<unsigned short> indices, std::vector<glm::vec3> & in_vertices, std::vector<unsigned short> & out_indicesaen)
{
	out_indicesaen.resize(indices.size()*3); //step 1 Create an output IB that is 3 times the size of input IB.
	//step 2 c define edge
	struct Edge
	{
		glm::vec3 p[2];
		short ind[2];

		bool operator == (const Edge& o) const
		{
			if (ind[0] == o.ind[0] && ind[1] == o.ind[1])
				return true;

			if (p[0] == o.p[0] && p[1] == o.p[1])
			{

					return true;
			}

			return false;
		}

	/*	bool operator != (const Edge& o) const{
			return !(*this == o);
		}*/


		Edge reverse()
		{
			Edge returnedge;
			returnedge.p[0] = p[1];
			returnedge.p[1] = p[0];
			returnedge.ind[0] = ind[1];
			returnedge.ind[1] = ind[0];

			return returnedge;	
		}
	};

	struct KeyHasher
	{
		std::size_t operator()(const Edge& k) const
		{
			using boost::hash_value;
			using boost::hash_combine;

			// Start with a hash value of 0    .
			std::size_t seed = 0;

			// Modify 'seed' by XORing and bit-shifting in
			// one member of 'Key' after the other:
			for (int hashi = 0; hashi < 2; hashi++)
			{
				hash_combine(seed, hash_value(k.p[hashi].x));
				hash_combine(seed, hash_value(k.p[hashi].y));
				hash_combine(seed, hash_value(k.p[hashi].z));
				hash_combine(seed, hash_value(k.ind[hashi]));
			}

			// Return the result.
			return seed;
		}
	};



	std::unordered_map<Edge, Edge,KeyHasher> edges(indices.size()); 

	//step 2
	for (int i = 0; i < indices.size(); i += 3) //For each input Triangle in IB,
	{
		out_indicesaen[3 * i] = indices[i]; //i0
		out_indicesaen[3 * i + 1] = indices[i+1]; //i1
		out_indicesaen[3 * i + 2] = indices[i + 2]; //i2

		out_indicesaen[3 * i + 3] = indices[i]; //i0
		out_indicesaen[3 * i + 4] = indices[i + 1]; //i1
		out_indicesaen[3 * i + 5] = indices[i + 1]; //i1

		out_indicesaen[3 * i + 6] = indices[i+2]; //i2
		out_indicesaen[3 * i + 7] = indices[i + 2]; //i2
		out_indicesaen[3 * i + 8] = indices[i]; //i0

		//2b and 2d

		Edge edge0;
		edge0.p[0] = in_vertices[indices[i + 1]];
		edge0.p[1] = in_vertices[indices[i]];
		edge0.ind[1] = indices[indices[i]];
		edge0.ind[0] = indices[indices[i + 1]];
		edges.emplace(edge0.reverse(), edge0);

		Edge edge1;
		edge1.p[0] = in_vertices[indices[i + 2]];
		edge1.p[1] = in_vertices[indices[i + 1]];
		edge1.ind[1] = indices[indices[i + 1]];
		edge1.ind[0] = indices[indices[i + 2]];
		edges.emplace(edge1.reverse(), edge1);

		Edge edge2;
		edge2.p[0] = in_vertices[indices[i]];
		edge2.p[1] = in_vertices[indices[i + 2]];
		edge2.ind[1] = indices[indices[i + 2]];
		edge2.ind[0] = indices[indices[i]];
		edges.emplace(edge2.reverse(), edge2);
	}


	//step 3 Walk the output index buffer (OB) constructed in step 2. For each patch of 9 indices:
	for (int i = 3; i < out_indicesaen.size(); i += 9)
	{

		//3a For each Edge in the current Patch, perform a lookup into Edge->Edge mapping created in step 2d.
		for (int k = 0; k < 6; k += 2)
		{
			int i0 = out_indicesaen[i + k];
			int i1 = out_indicesaen[i + k + 1];
			Edge temp;
			temp.ind[0] = i1;
			temp.ind[1] = i0;
			temp.p[0] = in_vertices[i1];
			temp.p[1] = in_vertices[i0];

			auto foundIt = edges.find(temp);
			if (foundIt!=edges.end()) //look up in edge vector
			{
				const Edge& second = foundIt->second;
				out_indicesaen[i + k] = second.ind[1];
				out_indicesaen[i + k + 1] = second.ind[0];
				
			}

		}

	}

}

Can you put that cube up for download (preferably in a common exchange format like Wavefront) ? I'll run it through my reindexer and give you the results.

Oh, thank you! IThe cube can be downloaded here. (I'm not permitted to attach an .obj file blink.png ). I'm starting to get frustrated with PNAEN...I can't find the bug for two weeks now. It's part of my master thesis.

Share this post


Link to post
Share on other sites

Ok. Had to adjust the import (Assimp, join identical vertices), so only 24 instead of 36 distinct vertices. In any case, I included a dump of the vertices, so you could reconstruct the mesh programmatically. It's a bloated html-log (and the indices are dumped as tables and "raw" for easier copying).

 

From a quick glance, I think your reindexer is fine. 

 

Edit: Wait, try something first. Hash only the positions (x,y,z), the map will fail otherwise (at least it did for my C# dictionary).

Share this post


Link to post
Share on other sites

My reindexer is indeed wrong, I get totally different indices. I copied your indices manually into the vector and the cracks are gone! The shader works!

I'll try to hash only the positions.  I hope that's the bug! Thank you very much for your help, the html log is awesome!

 

Edit: I found out that my edge Map seems to be already wrong. i have only 32 entried while your map has 36 entries.

Edited by windschuetze

Share this post


Link to post
Share on other sites

I solved my problem! I had serveal bugs:

  • filling the edge map: indices[indices[i]] instead of indices[i]...

  • I removed the hashing of the index and it worked!

Thank you very much, I couldn't have done it without your help!

 

Now my cube looks smooth and crackfree:

screenshot16111.png

Edited by windschuetze

Share this post


Link to post
Share on other sites

 


It's Rocko!

Ah yes, haha, remember watching that in the mid-late 90's. Maybe worth a rewatch now that I'm old enough to actually understand it better than back then...

 

As for the displacement mapping I eventually settled on a rather simple approach for use with pre-existing triangle list meshes (it is by no means perfect but it seems that the "real" solution is really just having the 3D / texturing artist(s) being aware of your intents and have them author appropriately mapped bump maps and ensure corners actually are rounded, albeit with extremely short edges between corner vertices, as seemed to be the main point that the chapter in Zink, Pettineo & Hoxley (2011) as referred by unbird in the last post). Basically I average all disjoint vertex normals and create a 6-control patch index buffer that holds the initial triangle in the first 3 indices and then any "dominant" vertices sharing the position of these original vertices in the last 3 indices. The dominant vertices are arbitrarily chosen as the first found in the vertex data for a given position and are set to the same vertex as in the first three indices if there are no shared vertices at a given position. The dominant vertex is used to ensure that all overlapping vertices will sample the same value from the displacement map, while still allowing them to sample other textures by their UV coords.

Not perfect but good enough for some general-purpose examples.

As for actually employing this kind of displacement mapping in a more professional game / visual demo / what-have-you, the artist should ensure that there are *no* disjoint vertices (as said, such vertices can be moved slightly apart and be connected by a short edge, allowing the corners to appear mostly sharp) and a secondary set of texture coordinates should be provided for the displacement map / alternatively the displacement map should be handcrafted such that when displaced (with a reasonable strength / height factor), faces won't extrude through each others.

Of course there exists more elaborate ways as described in the previous posts, I just thought I would share this if anyone found it interesting, After tracking down a copy of that practical rendering book just for that tessellation chapter, it didn't say that much more about this particular problem, so might as well save others the trouble.

 

Hi,

im trying to implement the dominandt data, but I'm struggling again...I'm not sure how to understand the  GDC 2012 slides, when i'm generating the index buffer:

? Can use AEN edge data as well

vs:

? All shared vertices must have the same dominant data
? Both edge vertices must be from the same primitive

 

I tried with the PN AEN Indexbuffer adding 3 arbitrarly chosen vertices, but it didn't worked.

Then I found on the Maya Homepage a despription of a PNAEN 18 implementation using dominant data with a 18 size index buffer and I tried to adapt it. But the result isn't good either, the UVs doesn't look smoother:

 

screenshot0312.png

 

My index buffer now looks like this for unbirds example:

0,1,2,0,1,4,3,2,0,0,1,4,3,2,0,0,4,2,3,4,5,2,1,4,5,5,3,4,3,4,5,5,3,4,4,5

(See also xls Attachment for details).

I'm pretty sure that the shader interpolates right:

			float 
		uCorner =  (u == 1 ? 1:0),
		vCorner =  (v == 1 ? 1:0),
		wCorner =  (w == 1 ? 1:0),
		uEdge =    (u == 0 && (v * w)!=0 ? 1:0),
		vEdge =    (v == 0 && (u * w)!=0 ? 1:0),
		wEdge =    (w == 0 && (u * v)!=0 ? 1:0),
		interior = (u * v * w)!=0 ? 1:0;

		vec2 displaceCoord= 	uCorner*InPatch.domVert[0]
							+vCorner*InPatch.domVert[1]
							+wCorner*InPatch.domVert[2]
							+uEdge*mix(InPatch.domEdge0[1],InPatch.domEdge1[1],v)
							+vEdge*mix(InPatch.domEdge0[2],InPatch.domEdge1[2],w)
							+wEdge*mix(InPatch.domEdge0[0],InPatch.domEdge1[0],u)
							+interior*UV;

Any clue?

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now

Sign in to follow this  

  • Forum Statistics

    • Total Topics
      627714
    • Total Posts
      2978775
  • Similar Content

    • By Baemz
      Hello,
      I've been working on some culling-techniques for a project. We've built our own engine so pretty much everything is built from scratch. I've set up a frustum with the following code, assuming that the FOV is 90 degrees.
      float angle = CU::ToRadians(45.f); Plane<float> nearPlane(Vector3<float>(0, 0, aNear), Vector3<float>(0, 0, -1)); Plane<float> farPlane(Vector3<float>(0, 0, aFar), Vector3<float>(0, 0, 1)); Plane<float> right(Vector3<float>(0, 0, 0), Vector3<float>(angle, 0, -angle)); Plane<float> left(Vector3<float>(0, 0, 0), Vector3<float>(-angle, 0, -angle)); Plane<float> up(Vector3<float>(0, 0, 0), Vector3<float>(0, angle, -angle)); Plane<float> down(Vector3<float>(0, 0, 0), Vector3<float>(0, -angle, -angle)); myVolume.AddPlane(nearPlane); myVolume.AddPlane(farPlane); myVolume.AddPlane(right); myVolume.AddPlane(left); myVolume.AddPlane(up); myVolume.AddPlane(down); When checking the intersections I am using a BoundingSphere of my models, which is calculated by taking the average position of all vertices and then choosing the furthest distance to a vertex for radius. The actual intersection test looks like this, where the "myFrustum90" is the actual frustum described above.
      The orientationInverse is the viewMatrix in this case.
      bool CFrustum::Intersects(const SFrustumCollider& aCollider) { CU::Vector4<float> position = CU::Vector4<float>(aCollider.myCenter.x, aCollider.myCenter.y, aCollider.myCenter.z, 1.f) * myOrientationInverse; return myFrustum90.Inside({ position.x, position.y, position.z }, aCollider.myRadius); } The Inside() function looks like this.
      template <typename T> bool PlaneVolume<T>::Inside(Vector3<T> aPosition, T aRadius) const { for (unsigned short i = 0; i < myPlaneList.size(); ++i) { if (myPlaneList[i].ClassifySpherePlane(aPosition, aRadius) > 0) { return false; } } return true; } And this is the ClassifySpherePlane() function. (The plane is defined as a Vector4 called myABCD, where ABC is the normal)
      template <typename T> inline int Plane<T>::ClassifySpherePlane(Vector3<T> aSpherePosition, float aSphereRadius) const { float distance = (aSpherePosition.Dot(myNormal)) - myABCD.w; // completely on the front side if (distance >= aSphereRadius) { return 1; } // completely on the backside (aka "inside") if (distance <= -aSphereRadius) { return -1; } //sphere intersects the plane return 0; }  
      Please bare in mind that this code is not optimized nor well-written by any means. I am just looking to get it working.
      The result of this culling is that the models seem to be culled a bit "too early", so that the culling is visible and the models pops away.
      How do I get the culling to work properly?
      I have tried different techniques but haven't gotten any of them to work.
      If you need more code or explanations feel free to ask for it.

      Thanks.
       
    • By evelyn4you
      hi,
      i have read very much about the binding of a constantbuffer to a shader but something is still unclear to me.
      e.g. when performing :   vertexshader.setConstantbuffer ( buffer,  slot )
       is the buffer bound
      a.  to the VertexShaderStage
      or
      b. to the VertexShader that is currently set as the active VertexShader
      Is it possible to bind a constantBuffer to a VertexShader e.g. VS_A and keep this binding even after the active VertexShader has changed ?
      I mean i want to bind constantbuffer_A  to VS_A, an Constantbuffer_B to VS_B  and  only use updateSubresource without using setConstantBuffer command every time.

      Look at this example:
      SetVertexShader ( VS_A )
      updateSubresource(buffer_A)
      vertexshader.setConstantbuffer ( buffer_A,  slot_A )
      perform drawcall       ( buffer_A is used )

      SetVertexShader ( VS_B )
      updateSubresource(buffer_B)
      vertexshader.setConstantbuffer ( buffer_B,  slot_A )
      perform drawcall   ( buffer_B is used )
      SetVertexShader ( VS_A )
      perform drawcall   (now which buffer is used ??? )
       
      I ask this question because i have made a custom render engine an want to optimize to
      the minimum  updateSubresource, and setConstantbuffer  calls
       
       
       
       
       
    • By noodleBowl
      I got a quick question about buffers when it comes to DirectX 11. If I bind a buffer using a command like:
      IASetVertexBuffers IASetIndexBuffer VSSetConstantBuffers PSSetConstantBuffers  and then later on I update that bound buffer's data using commands like Map/Unmap or any of the other update commands.
      Do I need to rebind the buffer again in order for my update to take effect? If I dont rebind is that really bad as in I get a performance hit? My thought process behind this is that if the buffer is already bound why do I need to rebind it? I'm using that same buffer it is just different data
       
    • By Rockmover
      I am really stuck with something that should be very simple in DirectX 11. 
      1. I can draw lines using a PC (position, colored) vertices and a simple shader just fine.
      2. I can draw 3D triangles using PCN (position, colored, normal) vertices just fine (even transparency and SpecularBlinnPhong shaders).
       
      However, if I'm using my 3D shader, and I want to draw my PC lines in the same scene how can I do that?
       
      If I change my lines to PCN and pass them to the 3D shader with my triangles, then the lighting screws them all up.  I only want the lighting for the 3D triangles, but no SpecularBlinnPhong/Lighting for the lines (just PC). 
      I am sure this is because if I change the lines to PNC there is not really a correct "normal" for the lines.  
      I assume I somehow need to draw the 3D triangles using one shader, and then "switch" to another shader and draw the lines?  But I have no clue how to use two different shaders in the same scene.  And then are the lines just drawn on top of the triangles, or vice versa (maybe draw order dependent)?  
      I must be missing something really basic, so if anyone can just point me in the right direction (or link to an example showing the implementation of multiple shaders) that would be REALLY appreciated.
       
      I'm also more than happy to post my simple test code if that helps as well!
       
      THANKS SO MUCH IN ADVANCE!!!
    • By Reitano
      Hi,
      I am writing a linear allocator of per-frame constants using the DirectX 11.1 API. My plan is to replace the traditional constant allocation strategy, where most of the work is done by the driver behind my back, with a manual one inspired by the DirectX 12 and Vulkan APIs.
      In brief, the allocator maintains a list of 64K pages, each page owns a constant buffer managed as a ring buffer. Each page has a history of the N previous frames. At the beginning of a new frame, the allocator retires the frames that have been processed by the GPU and frees up the corresponding space in each page. I use DirectX 11 queries for detecting when a frame is complete and the ID3D11DeviceContext1::VS/PSSetConstantBuffers1 methods for binding constant buffers with an offset.
      The new allocator appears to be working but I am not 100% confident it is actually correct. In particular:
      1) it relies on queries which I am not too familiar with. Are they 100% reliable ?
      2) it maps/unmaps the constant buffer of each page at the beginning of a new frame and then writes the mapped memory as the frame is built. In pseudo code:
      BeginFrame:
          page.data = device.Map(page.buffer)
          device.Unmap(page.buffer)
      RenderFrame
          Alloc(size, initData)
              ...
              memcpy(page.data + page.start, initData, size)
          Alloc(size, initData)
              ...
              memcpy(page.data + page.start, initData, size)
      (Note: calling Unmap at the end of a frame prevents binding the mapped constant buffers and triggers an error in the debug layer)
      Is this valid ? 
      3) I don't fully understand how many frames I should keep in the history. My intuition says it should be equal to the maximum latency reported by IDXGIDevice1::GetMaximumFrameLatency, which is 3 on my machine. But, this value works fine in an unit test while on a more complex demo I need to manually set it to 5, otherwise the allocator starts overwriting previous frames that have not completed yet. Shouldn't the swap chain Present method block the CPU in this case ?
      4) Should I expect this approach to be more efficient than the one managed by the driver ? I don't have meaningful profile data yet.
      Is anybody familiar with the approach described above and can answer my questions and discuss the pros and cons of this technique based on his experience ? 
      For reference, I've uploaded the (WIP) allocator code at https://paste.ofcode.org/Bq98ujP6zaAuKyjv4X7HSv.  Feel free to adapt it in your engine and please let me know if you spot any mistakes
      Thanks
      Stefano Lanza
       
  • Popular Now