Cartographie une texture carré à un triangle

Question

J'ai commencé à jouer avec un problème OpenGL ES 1.0 et je cours dans certains (débutants): J'ai essayé de tracer une texture carré au cube décrit par des triangles.

    // Turn necessary features on
    glEnable(GL_TEXTURE_2D);
    glEnable(GL_BLEND);
    glBlendFunc(GL_ONE, GL_SRC_COLOR);
    glEnable(GL_CULL_FACE);
    //glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  

    // Bind the number of textures we need, in this case one.
    glGenTextures(1, &texture[0]);
    glBindTexture(GL_TEXTURE_2D, texture[0]);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); 
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); 

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

//Drawing code
static GLfloat rot = 0.0;

static const Vertex3D vertices[] = {
    -1.0f,-1.0f,-1.0f, //0  00  
     1.0f,-1.0f,-1.0f, //1  10
     1.0f, 1.0f,-1.0f, //2  11
    -1.0f, 1.0f,-1.0f, //3  01      
};


static const int vertexCnt = 3 * 2;

static const GLubyte cube[] = {
    3,0,2,
    1,2,0,
};

static const GLfloat texCoords[] = {
    0,1,
    0,0,
    1,1,
    1,0,
    1,1,
    0,0,
};


glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glLoadIdentity();

glTranslatef(0.0f, 0.0f, -3.0f);

glBindTexture(GL_TEXTURE_2D, texture[0]);

glEnableClientState(GL_VERTEX_ARRAY);
//glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_COLOR_MATERIAL);


glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glVertexPointer(3, GL_FLOAT, 0, vertices);

//glColorPointer(4, GL_FLOAT, 0, colors);
glNormalPointer(GL_FLOAT, 0, normals);



glDrawElements(GL_TRIANGLES, vertexCnt, GL_UNSIGNED_BYTE, cube);


glDisableClientState(GL_VERTEX_ARRAY);
//glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);

Maintenant, après une tentative de zillion, je ne peux pas le faire fonctionner pour d'autres côtés ... Y at-il une règle de base pour le cas lors du mappage de texture carré triangles?

EDIT: Je pense que je figure sur la façon de mener la cartographie. Mais cela ne fonctionne pas pour cet exemple (une face). Quelqu'un peut-il simplement vérifier si je s'il vous plaît la cartographie fait correctement (en supposant que le reste du code fonctionne)?

Merci beaucoup

Answer 1

Comme d'autres, je ne pense pas qu'il y ait une astuce pour mapper vos textures quad sur des triangles.

Le principal problème que vous rencontrez est à cause de discontinuités dans la texture coords pour chaque coin. Si un coin que certains coords UV {u, v} pour une face, cela ne signifie pas qu'il aura la même valeur pour les deux autres faces qui partagent le sommet. Il est possible de trouver une cartographie de telle sorte que UV est unique à chaque coin du cube (partagé par 3 faces) et que toutes les 4 valeurs UV ({0,0}, {} 1,0, {1,1} et {0,1}) sont présents sur chaque face mais certaines textures seraient complètement déformées. Essayez de vérifier sur un morceau de papier. {1,1} est pas toujours à l'opposé de {0,0}

La meilleure façon de commencer, serait de déclarer explicitement 6, quadriceps chacun d'eux composé de 2 triangles. Cela vous donne un total de 24 sommets (24 positions et 24 tex coords, entrelacée ou non) et 36 indices (6 quadriceps composé de deux triangles, 6 * 2 * 3 = 36).

Voici votre code mis à jour pour afficher un cube (il pourrait y avoir un problème d'enroulement donc je visage désactivé culling pour être sûr):

glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glEnable(GL_DEPTH_TEST);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);

static const float vertices[] = {
        0.0f, 1.0f, 0.0f,
        1.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 0.0f,
        1.0f, 0.0f, 0.0f,

        0.0f, 1.0f, 1.0f,
        0.0f, 0.0f, 1.0f,
        1.0f, 1.0f, 1.0f,
        1.0f, 0.0f, 1.0f,

        0.0f, 1.0f, 1.0f,
        1.0f, 1.0f, 1.0f,
        0.0f, 1.0f, 0.0f,
        1.0f, 1.0f, 0.0f,

        0.0f, 0.0f, 1.0f,
        0.0f, 0.0f, 0.0f,
        1.0f, 0.0f, 1.0f,
        1.0f, 0.0f, 0.0f,

        1.0f, 1.0f, 0.0f,
        1.0f, 1.0f, 1.0f,
        1.0f, 0.0f, 0.0f,
        1.0f, 0.0f, 1.0f,

        0.0f, 1.0f, 0.0f,
        0.0f, 0.0f, 0.0f,
        0.0f, 1.0f, 1.0f,
        0.0f, 0.0f, 1.0f
        };


static const int vertexCnt = 6 * 4;

static const GLubyte cube[] = {
     0,  1,  2,  1,  2,  3,
     4,  5,  6,  5,  6,  7,
     8,  9, 10,  9, 10, 11,
    12, 13, 14, 13, 14, 15,
    16, 17, 18, 17, 18, 19,
    20, 21, 22, 21, 22, 23 
};

static const GLfloat texCoords[] = {
    0.0f, 0.0f,
    1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f,

    1.0f, 0.0f,
    1.0f, 1.0f,
    0.0f, 0.0f,
    0.0f, 1.0f,

    0.0f, 0.0f,
    1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f,

    0.0f, 1.0f,
    0.0f, 0.0f,
    1.0f, 1.0f,
    1.0f, 0.0f,

    0.0f, 0.0f,
    1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f,

    1.0f, 0.0f,
    1.0f, 1.0f,
    0.0f, 0.0f,
    0.0f, 1.0f
    };

glClearColor(0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

//glLoadIdentity();

//glTranslatef(0.0f, 0.0f, -3.0f);
glRotatef(3.1415927f, 1.0f, 1.0f, 0.0f);

glBindTexture(GL_TEXTURE_2D, spriteTexture);

glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);

glTexCoordPointer(2, GL_FLOAT, 0, texCoords);
glVertexPointer(3, GL_FLOAT, 0, vertices);

glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_BYTE, cube);

Answer 2

Je ne l'ai pas essayé de pièce à travers vos listes de sommets, mais mon deviner est que vous avez vos coordonnées entièrement foiré et le mal de cartographie, vous avez spécifié le format de mémoire tampon d'index de manière incorrecte, ou si vous avez retour face mise à la réforme activée, et certains de vos sommets sont dans le mauvais ordre.

En ce qui concerne les coordonnées de texture eux-mêmes, il ne devrait pas être tour avec la cartographie de triangles par rapport aux quadriceps. Vous aurez juste à avoir 6 coordonnées de texture où vous auriez déjà avons eu quatre, car il y a 6 sommets (deux doublons par face). Vous pourriez être en mesure d'éviter la duplication en utilisant un tampon d'index, que vous avez avec votre cube.

En ce qui concerne un problème potentiel culling retour face, vous devez définir vos sommets dans le même ordre chaque fois. Toutes les aiguilles d'une montre, par rapport à la direction de la texture sera face, ou tout le sens antihoraire.

Qu'est-ce que les commandes que vous utilisez pour configurer votre pipeline OpenGL, et quelles commandes utilisez-vous pour dessiner ces sommets? S'il vous plaît ajouter le code correspondant à la question.