Bonjour,

Après plusieurs jours de casse tête, je reviens vers vous pour un nouveau problème

J'ai une classe qui fait des IAnimatedMesh à partir d'un tableau à 3 dimensions.
En gros, si pour mapcube[1] [2] [1] y'a true, ca me fait un cube a la position 1,2,1.
Chaque cube est généré avec 4 vertices, 1 normal et 2 triangles.
Si l'on génère une map ou il y à 2 cubes l'un à coté de l'autre, les faces consécutives ne sont pas crées.

Mais je viens de remarquer qu'en essayant d'afficher des ombre portées ça coince.

Un p'tit screen et j'explique:


=> Sur l'image "1" on voit qu'avec un seul cube l'ombre se comporte normalement

=> Sur l'image "2", j'ai généré un mesh avec deux cubes consécutifs et la le résultat est pour le moins déconcertant ...
     plusieurs ombres au sol (avec certaines qui s'annulent on dirais) et une ombre sur une face du mesh lui même

=> Sur l'image "3", j'ai généré 2 mesh séparés de 1 cube (donc avec toutes leurs faces contrairement à l'image 2)
     et la, tout à l'air normal

... Avez vous une explication à ce "bug"? ... pitié, je désespère


Ce que j'ai cru comprendre nécessaire en farfouillant à droite à gauche et que j'ai respecté dans l'exemple ci-dessus:
- Stencilbuffer à true
- IAnimatedMesh uniquement
- node->addShadowVolumeSceneNode( mesh->getMesh(0,255,-1,-1) );

Dernière modification par yata (14-12-2013 02:25:10)

Pour commencer il y a déjà un soucis avec le cube lorsque tu merges les deux (outre le shadown).
Il te manque une face sur le dessus et probablement en dessous.
Ensuite, tu as forcement un problème avec tes normales qui va impacter tes ombres.
Tu dois avoir dans ton cas 4 normales distinctes pour un cube.

Ensuite je sais pas si tu considères "triangle = polygone" mais dans ce cas tu n'en as plus que 2

"addShadowVolumeSceneNode" disponible sur "IAnimatedMeshSceneNode" et "ImeshSceneNode",
prennent tout deux des "IMesh", donc pas nécessairement "IAnimatedMesh".

Salut Magun et merci a toi pour ce p'tit coup d'pouce

Magun :

pour commencer il y a déjà un soucis avec le cube l'orsque tu merge les deux (outre le shadown)

On est d'accord :p

Magun :

il te manque une face sur le dessus et probablement en dessous

He bien non, toutes les faces sont présentes.
J'ai fait un essais en changement uniquement la couleur de la face du dessus par du bleu (alors que le reste des cubes est rouge.
Et on voit bien la face supérieure. (d’ailleurs, si il n'y avais pas de faces supérieure on verrais "à travers les autres faces quand on regarde par l'intérieur". vu que je ne définit que 6 indices par faces, j'ai remarqué que les faces ne sont visibles que de l'extérieur) ... Je ne sait pas si j'ai été très clair :s
Screen à l'appui:

Magun :

en suite tu a forcement un problème avec t'est normal qui va impacter t'est ombres
tu doit avoir dans ton cas 4 normal distinct pour un cube

En fait j'en ai 6, toujours les mêmes et différents pour chaque faces. Ceux la:
front: vector3df(0.0f, 0.0f, 1.0f);
back: vector3df(0.0f, 0.0f, -1.0f);
right: vector3df(1.0f, 0.0f, 0.0f);
left: vector3df(-1.0f, 0.0f, 0.0f);
top: vector3df(0.0f, 1.0f, 0.0f);
bottom: vector3df(0.0f, -1.0f, 0.0f);

Magun :

en suite je sais pas si tu considère triangle = polygone mais dans ce cas tu en n'a plus que 2

J'comprend pas. Quand je dit triangle, j' entend "3 indices"

Magun :

addShadowVolumeSceneNode disponible sur IAnimatedMeshSceneNode et ImeshSceneNode,
prenne tout deux des IMesh donc non pas nécessairement IAnimatedMesh

Cool, j'avais pas vu ca. Ca va me permettre de simplifier un peu ma classe

Si t'as besoin d'une partie du code pour comprendre, hésite pas. Je l’enverrais direct ^^

En fait j'en ai 6, toujours les mêmes et différents pour chaque faces. Ceux la...

ok, au niveaux rendue, mais au niveaux données tu devraient en avoir 8 (et non pas 4 je penssais a une seul face)

au pire post un bout de code si tu peut, ce seras plus explicite

Ouais, en fait pour chaque face j'ai 4 fois le même, perpendiculaire à la face ( ce qui à l'air différent sur ton schéma :s )

du coups, si je comprend bien j'ai :
    Face HAUT:
        vertice1 -> normal : 0, 1, 0
        vertice2 -> normal : 0, 1, 0
        vertice3 -> normal : 0, 1, 0
        vertice4 -> normal : 0, 1, 0

mais je devrais avoir un truc comme :
    Face HAUT:
        vertice1 -> normal : 0, 1, 0
        vertice2 -> normal : 1, 1, 0
        vertice3 -> normal : 1, 1, 1
        vertice4 -> normal : 0, 1, 1


Et un p'tit bout de code en prime (méthode qui ajoute 1 cube au buffer)

void chunk::createCube ( u16 size, vector3df pos, SColor cubeColor, bool ftFace, bool bkFace, bool rtFace, bool ltFace, bool tpFace, bool bmFace )
{
    u32 i=0;

    u32 v1=0;
    u32 v2=0;
    u32 v3=0;
    u32 v4=0;

    vector3df norm;
    vector2d<f32> tcoords(0.0f, 0.0f);

    f32 halfSise = (f32)size/2;

    vector3df p1(pos.X-halfSise, pos.Y-halfSise, pos.Z+halfSise);
    vector3df p2(pos.X+halfSise, pos.Y-halfSise, pos.Z+halfSise);
    vector3df p3(pos.X+halfSise, pos.Y+halfSise, pos.Z+halfSise);
    vector3df p4(pos.X-halfSise, pos.Y+halfSise, pos.Z+halfSise);
    vector3df p5(pos.X+halfSise, pos.Y-halfSise, pos.Z-halfSise);
    vector3df p6(pos.X-halfSise, pos.Y-halfSise, pos.Z-halfSise);
    vector3df p7(pos.X-halfSise, pos.Y+halfSise, pos.Z-halfSise);
    vector3df p8(pos.X+halfSise, pos.Y+halfSise, pos.Z-halfSise);

    for (u16 face=0; face<6; face++)
    {
        // FRONT ( => Vertices )
        if (face==0 && ftFace)
        {
            norm = vector3df(0.0f, 0.0f, 1.0f);
            v1=vCount++;  buffer->Vertices.push_back( S3DVertex(p1, norm, cubeColor, tcoords) );
            v2=vCount++;  buffer->Vertices.push_back( S3DVertex(p2, norm, cubeColor, tcoords) );
            v3=vCount++;  buffer->Vertices.push_back( S3DVertex(p3, norm, cubeColor, tcoords) );
            v4=vCount++;  buffer->Vertices.push_back( S3DVertex(p4, norm, cubeColor, tcoords) );
        }

        // BACK ( => Vertices )
        if (face==1 && bkFace)
        {
            norm = vector3df(0.0f, 0.0f, -1.0f);
            v1=vCount++;  buffer->Vertices.push_back( S3DVertex(p5, norm, cubeColor, tcoords) );
            v2=vCount++;  buffer->Vertices.push_back( S3DVertex(p6, norm, cubeColor, tcoords) );
            v3=vCount++;  buffer->Vertices.push_back( S3DVertex(p7, norm, cubeColor, tcoords) );
            v4=vCount++;  buffer->Vertices.push_back( S3DVertex(p8, norm, cubeColor, tcoords) );
        }

        // RIGHT ( => Vertices )
        if (face==2 && rtFace)
        {
            norm = vector3df(1.0f, 0.0f, 0.0f);
            v1=vCount++;  buffer->Vertices.push_back( S3DVertex(p2, norm, cubeColor, tcoords) );
            v2=vCount++;  buffer->Vertices.push_back( S3DVertex(p5, norm, cubeColor, tcoords) );
            v3=vCount++;  buffer->Vertices.push_back( S3DVertex(p8, norm, cubeColor, tcoords) );
            v4=vCount++;  buffer->Vertices.push_back( S3DVertex(p3, norm, cubeColor, tcoords) );
        }

        // LEFT ( => Vertices )
        if (face==3 && ltFace)
        {
            norm = vector3df(-1.0f, 0.0f, 0.0f);
            v1=vCount++;  buffer->Vertices.push_back( S3DVertex(p6, norm, cubeColor, tcoords) );
            v2=vCount++;  buffer->Vertices.push_back( S3DVertex(p1, norm, cubeColor, tcoords) );
            v3=vCount++;  buffer->Vertices.push_back( S3DVertex(p4, norm, cubeColor, tcoords) );
            v4=vCount++;  buffer->Vertices.push_back( S3DVertex(p7, norm, cubeColor, tcoords) );
        }

        // TOP ( => Vertices )
        if (face==4 && tpFace)
        {
            norm = vector3df(0.0f, 1.0f, 0.0f);
            v1=vCount++;  buffer->Vertices.push_back( S3DVertex(p4, norm, cubeColor, tcoords) );
            v2=vCount++;  buffer->Vertices.push_back( S3DVertex(p3, norm, cubeColor, tcoords) );
            v3=vCount++;  buffer->Vertices.push_back( S3DVertex(p8, norm, cubeColor, tcoords) );
            v4=vCount++;  buffer->Vertices.push_back( S3DVertex(p7, norm, cubeColor, tcoords) );
        }

        // BOTTOM ( => Vertices )
        if (face==5 && bmFace)
        {
            norm = vector3df(0.0f, -1.0f, 0.0f);
            v1=vCount++;  buffer->Vertices.push_back( S3DVertex(p6, norm, cubeColor, tcoords) );
            v2=vCount++;  buffer->Vertices.push_back( S3DVertex(p5, norm, cubeColor, tcoords) );
            v3=vCount++;  buffer->Vertices.push_back( S3DVertex(p2, norm, cubeColor, tcoords) );
            v4=vCount++;  buffer->Vertices.push_back( S3DVertex(p1, norm, cubeColor, tcoords) );
        }

        // ALL ( => Indices )
        if (ftFace||bkFace||rtFace||ltFace||tpFace||bmFace)
        {
            i = buffer->getIndexCount();
            buffer->Indices.set_used( i+6 );

            buffer->Indices[i++] = v1;   buffer->Indices[i++] = v2;   buffer->Indices[i++] = v3;
            buffer->Indices[i++] = v1;   buffer->Indices[i++] = v3;   buffer->Indices[i++] = v4;
        }
    }
}

Bon, beh j'viens d'essayer d'affecter mes normaux comme sur ton schéma (les p'tits traits bleus)

Le résultat est pas très concluant :p (même chose qu'avant pour les ombres et merdique pour la lumière huhu):


En gros j'ai changé les "norm" du code précédent par
vector3df n1(-1.0f, -1.0f, 1.0f);
vector3df n2(1.0f, -1.0f, 1.0f);
vector3df n3(1.0f, 1.0f, 1.0f);
vector3df n4(-1.0f, 1.0f, 1.0f);
vector3df n5(1.0f, -1.0f, -1.0f);
vector3df n6(-1.0f, -1.0f, -1.0f);
vector3df n7(-1.0f, 1.0f, -1.0f);
vector3df n8(1.0f, 1.0f, -1.0f);

avec n1 allant toujours avec p1, n2 avec p2 ... etc


HAAAAAAAAAAAAAAAAAAAAAAAAA :'(

En repartant sur le premier code et en désactivant le zfail, ca me donne ca:

... Si ca peux aider à comprendre :s

Dernière modification par yata (16-12-2013 21:41:14)

donc au final t'a pas 8 vertex mais 24, cela dit je ne voie pas trop l'utiliter d'une boucle dans le cas présent
tu pourrais n'en avoir que 8 et agir sur les indices pour définir s'il y a une face ou non, faut voir ce qui est le plus lourd au rendu
ton code semble bien, probablement un peut lourd pour un simple cube

pour ce qui est du premier message tu a surment un soucis dans l'ordenenement des t'est indices
clockwise/counter-clockwise qui définir le "sens" du polygone d'ou le fait que j'usse vue l'absence de face

j'ai trouvé ... et j'suis un peu honteux du coup ^^

j'ai fait une erreur dans le test la:

if (ftFace||bkFace||rtFace||ltFace||tpFace||bmFace)

qui devais être équivalent à ceux du dessus soit:

if ((face==0 && ftFace)||(face==1 && bkFace)||(face==2 && rtFace)||(face==3 && ltFace)||(face==4 && tpFace)||(face==5 && bmFace))

Merci de m'avoir aider, même indirectement; et de m'avoir évité un suicide quasiment inévitable :p

PS: ouaip, j'connaissait la méthode createCubeMesh c'est de la que je suis parti plus ou moins. Mais j'avais justement modifié les vecteurs normaux parce qu'avec ceux la, comme dans le test que j'ai essayé de faire quand j'ai vu ton schéma de cube l'éclairage n'est pas correct. Ça reflète par les coins à la place de refléter par les faces

Je n'avais pas vraiment regardé de ce coté-ci ^^"