Hola,

Estudio Opengl y programación y cuando tengo dudas no tengo a nadie a quien preguntar, y en los foros no hay actividad..

Se que hay páginas en inglés pero yo no lo hablo..

Me podeis recomendar alguna página y foro de habla hispana?

Hola,

Ya se leer un fichero obj que contiene coordenadas de vértices.. y más adelante los índices de vértice para dibujar con gldrawelements().
Utilizo shaders cómo método de render.. y voy pasando los atributos de vértice a las variables "in" del shader..

Mi problema es al dibujar el objeto 3d con gldrawelements().. ya que utilizo los índices de vértice.. pero no los índices de textura ni de normales.. me refiero a que en el fichero tengo: f 1/1/1 2/2/2 3/3/3f     1/2/3 1/2/3 1/2/3f  ....

Yo pensaba que sólo con cargar los 'v' y 'vt' y'vn'.. y dibujar utilizando el gldrawelements() usando los índices de vértices ('v's) ya era suficiente..
Pero imagino que algo no he entendido porqué también hay índices de 'vt' y 'vn'..

Cómo puedo utilizar estos índices también?
Gracias!

Hola,

Hace unas semanas que no toco opengl.. estuve probando lo que me dijisteis.
Si escupo las coordenadas de textura como colores veo el objeto3d cargado con colorines.
También he bindeado la textura antes del render.
Y las coordenadas de textura van de 0 a 1.
Y también la textura es potencia de 2.

Sigo sin poder ver las texturas.. Y cómo dije antes el shader funciona..

Ayuda porfavor..

Hola,

Sigo atascado con las texturas.. he probado de todo..
Por favor echadme un cable porque no avanzo. Gracias.

El problema que tengo es que no se muestra nada por pantalla al dibujar un modelo con texturas. Se ve todo negro. Pero el programa continua. Los eventos de pantalla funcionan.
Si cambio el color de salida del fragment shader de esta manera:
outColor = texture(texture0, coordenadaTexturaSalida.st);
por..:
outColor = vec4(1.0f, 1.0f, 1.0f, 1.0f);
El módelo se ve todo en blanco.. Con lo cual el shader funciona..

Pongo aquí el código que carga las texturas..:

Código [Seleccionar] Expand


//!ESTO SON LAS TEXTURAS..*******************
    glEnable(GL_TEXTURE_2D);
    glActiveTexture(GL_TEXTURE0);
    TargaImage textura1;
    textura1.load(ficheroText);
                //!Aquí muestro lo que he leido del fichero ..:
                std::cout << "\nEsto es lo que se ha leido de la cabezera del fichero tga..:";
               // std::cout << "\nidLength..: " << tgaFile.idLength;
               // printf("\nimageTypeCode..: %d", tgaFile->imageTypeCode);
                std::cout << "\nLongitud del widht..: " << textura1.getWidth();
                std::cout << "\nLongitud del height..: " << textura1.getHeight();
                printf("\nbitCount..: %d\n", textura1.getBitsPerPixel());
                system("pause");
    GLuint firstTexture;
    glGenTextures(1, &firstTexture);
    glBindTexture(GL_TEXTURE_2D, firstTexture);
    //!PRUEBO A RELLENAR LA TEXTURA CON UN COLOR..:    ************************
        //textura1.texturaDeUnColor();
        //!El error no esta en la carga del archivo de textura..
    //!************************************************************************

    if (((textura1.getBitsPerPixel()) / 3) == 8){
        std::cout << "\nSe trata de una textura RGB";
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, textura1.getWidth(), textura1.getHeight(), 0, GL_RGB, GL_UNSIGNED_BYTE, textura1.getImageData());
    }
    if ((textura1.getBitsPerPixel() / 4) == 8){
        std::cout << "\nSe trata de una textura RGBA";
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, textura1.getWidth(), textura1.getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, textura1.getImageData());
    }
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    shader.envioUniformeSamplerText("texture0");       //Esto envía "0" a la variable de tipo sampler2d llamada "texture0"



Y el código del fragment..:

Código [Seleccionar] Expand


#version 150

uniform sampler2D texture0;

in vec2 coordenadaTexturaSalida;
out vec4 outColor;

void main(void) {
outColor = texture(texture0, coordenadaTexturaSalida.st);
}


Y luego también.. la función que utilizo para dibujar..:

Código [Seleccionar] Expand


        shader.envioAtributo(objeto3d1.submodelo[0].vertice, "a_Vertex");
        shader.envioAtributoTextura(objeto3d1.submodelo[0].textura, "coordenadaTextura");
     glDrawElements(GL_TRIANGLES, objeto3d1.submodelo[0].NumeroIndices, GL_UNSIGNED_INT, objeto3d1.submodelo[0].IndicesVertice);


No entiendo donde está el error.. Ayuda por favor porque no avanzo..

^_^' ^_^'

Hola de nuevo  :D
Sigo teniendo problemas con las texturas, la pantalla se queda en negro pero responde a los eventos. Si sustituyo las texturas por un color uniforme se ve el objeto 3d.
Mejor pongo el código..:

Éste es el código que carga el fichero de texturas en memoria y luego crea el objeto de textura y vuelca los datos en él..:

Código [Seleccionar] Expand


    void elemento::CrearTexturas(char FicheroToConvertText[], struct TexturaCabezera *tgaFile){
    //!******* ESTO CREA EL OBJETO DE LA CLASE QUE EXTRAE DATOS DE LA IMAGEN DE TEXTURA **********
       // TargaImage textura; 
        FILE *filePtr;
        unsigned char ucharBad;
        short int sintBad;

        filePtr = fopen(FicheroToConvertText, "rb");
        if (filePtr == NULL)
        {
        exit(1);
        }
        //fseek(filePtr, 0, SEEK_SET);
        std::cout << "\nel fichero de textura a leer es..: " << FicheroToConvertText;
        std::cout << "\nPulse una tecla.." ; getchar();

    // Read the two first bytes we don't need.     Estos dos bits no los necesito..
    fread(&ucharBad, sizeof(unsigned char), 1, filePtr);
    fread(&ucharBad, sizeof(unsigned char), 1, filePtr);
        // Which type of image gets stored in imageTypeCode.

    fread(&tgaFile->imageTypeCode, sizeof(unsigned char), 1, filePtr);   //!Esto lee el tipo de imagen que es la textura
/*
                if (tgaFile->imageTypeCode != 2 && tgaFile->imageTypeCode != 3)
                {
                    fclose(filePtr);
                    return;
                }      //!Sale de la función creartexturas si el tipo de textura está comprimido. ver pagina 178 del libro
*/
    // Read 13 bytes of data we don't need.       Lo mismo de antes .. no los necesito
    fread(&sintBad, sizeof(short int), 1, filePtr);
    fread(&sintBad, sizeof(short int), 1, filePtr);
    fread(&ucharBad, sizeof(unsigned char), 1, filePtr);
    fread(&sintBad, sizeof(short int), 1, filePtr);
    fread(&sintBad, sizeof(short int), 1, filePtr);

        // Read the image's width and height.
        fread(&tgaFile->imageWidth, sizeof(short int), 1, filePtr);
        fread(&tgaFile->imageHeight, sizeof(short int), 1, filePtr);
        // Read the bit depth.
        fread(&tgaFile->bitCount, sizeof(unsigned char), 1, filePtr);

    // Read one byte of data we don't need.
    fread(&ucharBad, sizeof(unsigned char), 1, filePtr);

        long imageSize;
        int colorMode; // Color mode -> 3 = BGR, 4 = BGRA.
        colorMode = tgaFile->bitCount / 8;
        imageSize = tgaFile->imageWidth * tgaFile->imageHeight * colorMode;

        //!esto da dimensión al arreglo imagedata
        tgaFile->imageData = (unsigned char*)malloc(sizeof(unsigned char)*imageSize);
        fread(tgaFile->imageData, sizeof(unsigned char), imageSize, filePtr);

       //!Aquí muestro lo que he leido del fichero ..:
        std::cout << "\nEsto es lo que se ha leido de la cabezera del fichero tga..:";
       // std::cout << "\nidLength..: " << tgaFile.idLength;
        printf("\nimageTypeCode..: %d", tgaFile->imageTypeCode);
        std::cout << "\nLongitud del widht..: " << tgaFile->imageWidth;
        std::cout << "\nLongitud del height..: " << tgaFile->imageHeight;
        printf("\nbitCount..: %d", tgaFile->bitCount);

                        std::cout << "\nAhora se van a mostrar los 20 primeros datos de los datos de imagen..:\n" ;
                        for (int counter = 0; counter < 25; counter++){
                            printf("%d ", tgaFile->imageData[counter]);
                        }
                        getchar();

        fclose(filePtr);


        GLuint firstTexture;
        glGenTextures(1, &firstTexture);



        glBindTexture(GL_TEXTURE_2D, firstTexture);


        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, tgaFile->imageWidth, tgaFile->imageHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, tgaFile->imageData);
                    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
                    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);



Y esto en el main, que carga los atributos de vértice y dibuja..:

Código [Seleccionar] Expand


    objeto3d1.CrearTexturas(ficheroText, &tgaFile);        glActiveTexture(GL_TEXTURE0);
//!*****************************************************************************************************
    switch (OpcionMenu) {
    case '2':
        {

        //! Crea la ventana y la inicializa para opengl ******
        OpenGLWindow VentanaOpenGL(hInstance);
        VentanaOpenGL.CrearVentana(1366, 768, 32, 1);
        VentanaOpenGL.IniciaOpenGL();
         objeto3d1.CrearIndices();
        glLoadIdentity();
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        //glEnableClientState(GL_VERTEX_ARRAY);

        // *************************************************
        shader.OpenFiles();
        shader.BorrarLeeFichero();
        shader.leeFichero();
        shader.compila();
        shader.activaShader();

        std::cout << "\nAhora se va a pintar el objeto en pantalla" ;
       // getchar();
        int rotacion = 0;
        shader.envioAtributo(objeto3d1.submodelo[0].vertice, "a_Vertex");
        shader.envioAtributoTextura(objeto3d1.submodelo[0].textura, "coordenadaTextura");
         shader.envioUniformeSamplerText("texture0");

        while (1){
        glLoadIdentity();
        rotacion++; if (rotacion > 360) rotacion = 0;
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        //Ahora dibujo..:
        glTranslatef(0,0,-8);
        glPushMatrix();
        glRotatef(rotacion, 0,1,0);
        shader.cargoMatrices();
        glPopMatrix();
       // for (int modelos = 1 ; modelos > 0 ; modelos-- ){

        glDrawElements(GL_TRIANGLES, objeto3d1.submodelo[0].NumeroIndices, GL_UNSIGNED_INT, objeto3d1.submodelo[0].IndicesVertice);
        //shader.desactivarAtributos();
       // }
        //glPopMatrix();
        for (int retard = 0; retard < 1000000; retard++);
        VentanaOpenGL.ActualizarBuffer();
        VentanaOpenGL.processEvents();
        }


Si me ayudais muchas gracias.. Estoy aprendiendo yo sólo OpengGL y no tengo a nadei a quien preguntar..

 :D

Hola, Gracias por responder,

Es decir..
Si al leer la cabezera del fichero tga. El valo bpp (profundiad de color) es de 24 , entonces se trata de un RGB8/RGB..
Ya que son 8 bits por canal = 8*3=24 ?

Si fuera bpp de 32.. Entonces se trataría de RGBA8/RGBA?
8*4 = 32?

Hola,

Me respondo a mi mismo en parte ..  :D
Si divido la profundiad en bits entre 3 tendré el internal format.

Faltaría el format ..         que el dato de la cabezera del fichero tga ya lo especifica    El más común gl_rgb?

Y el type cómo se sabe?

["internal_format"]

Hola,

Esto del c++ me está enganchando  :D                8)
Tengo dudas de cómo utilizar la función glTexImage2d( )  .
No entiendo los datos de:
glTexImage2d(gl_texture2d, 0, "internal_format", ancho , alto , 0, "format" , "type", , datos de imagen);

Cómo se yo el tipo de internal format que tiene la textura?
Lo mismo con el format.
Y el type de datos?

Muchas Gracias

Hola,

Ya lo he hecho y no muestra nada..

Código [Seleccionar] Expand


        //!esto da dimensión al arreglo imagedata
        tgaFile->imageData = (unsigned char*)malloc(sizeof(unsigned char)*imageSize);
        for (int counter = 0; counter < (imageSize / colorMode) ; counter++){
            tgaFile->imageData[counter] = 1.0;
        }
        //fread(tgaFile->imageData, sizeof(unsigned char), imageSize, filePtr);       Esto lee el fichero de imagen


Hola,

Perdón, lo escribí con prisa.
Quiero decir que el programa va bien (muestra el modelo en 3d)(hace el render bien).. si le digo que utilize un color al azar para todos los vértices. Manipulando el fragment shader. Es decir, que los shaders funcionan bien. Los cargo desde un fichero de texto.
El problema viene cuando utilizo en la salida del fragment la función texture(). La cual da error de programa y sale.

Ahora voy paso por paso..:
Estoy investigando las textura targa o "tga". Me podeis decir si está muy popularizada este tipo de texturas?
Estoy intentando leer la cabezera de un fichero tga.. Lo estoy haciendo bien?..:

Código [Seleccionar] Expand


//! ********************* DATOS DE LA CABEZERA DEL FICHERO DE LA TEXTURA **************
        struct TargaCabezera
        {
            unsigned char idLength;
            unsigned char colorMapType;
            unsigned char imageTypeCode;
            unsigned char colorMapSpec[5];
            unsigned short xOrigin;
            unsigned short yOrigin;
            unsigned short widht;
            unsigned short height;
            unsigned char bpp;
            unsigned char imageDesc;
        };
        TargaCabezera cabezera1;
        caracter = getc(ficheroTextura);
        cabezera1.idLength = caracter;
        getc(ficheroTextura);
        caracter = getc(fichero);
        cabezera1.imageTypeCode = caracter;
        getc(ficheroTextura);

        fscanf(ficheroTextura, "%d", cabezera1.xOrigin);
        fscanf(ficheroTextura, "%d", cabezera1.yOrigin);
        fscanf(ficheroTextura, "%d", cabezera1.widht);
        fscanf(ficheroTextura, "&d", cabezera1.height);

        cabezera1.bpp = getc(ficheroTextura);
        cabezera1.imageDesc = getc(ficheroTextura);


Muchas Gracias por todo

Hola,

Estoy utilizando shaders con opengl. El programa va bien. Pero al aplicar texturas el programa no me funciona.

el código que tengo de los shaders es el siguiente..:
vertex:

Código [Seleccionar] Expand


#version 130

uniform mat4 projection_matrix;
uniform mat4 modelview_matrix;

in vec2 coordenadaTextura;
in vec3 a_Vertex;


out vec2 coordenadaTexturaSalida;

void main(void)
{
coordenadaTexturaSalida = coordenadaTextura;
vec4 pos = modelview_matrix * vec4(a_Vertex, 1.0);
gl_Position = projection_matrix * pos;
}



Y fragment:

Código [Seleccionar] Expand


#version 130

uniform sampler2D texture0;

in vec2 coordenadaTexturaSalida;
out vec3 outColor;

void main(void) {
outColor = vec3(texture(texture0, coordenadaTexturaSalida.st));
}


No se si puede estar ahí el error.. O no estoy cargando la textura bien en el programa
El código de las texturas en el programa de opengl es éste:

Código [Seleccionar] Expand


        TargaImage textura;     //clase que contiene la siguiente función y carga la textura..
        if (!textura.load(FicheroToConvertText)){
            std::cerr << "No se ha podido cargar la imagen de la textura";
            exit(0);
        }
        GLuint firstTexture = 0;
        glGenTextures(1, &firstTexture);
        glBindTexture(GL_TEXTURE_2D, firstTexture);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, textura.getWidth(), textura.getHeight(), 0, GL_RGB, GL_UNSIGNED_BYTE, textura.getImageData());


Gracias!

Ya. Pero estoy utilizando shaders...
Quieres decir que active un buffer cada vez, y luego lo envíe con glvertexattribpointer()?

Entonces cada vez que reenvío atributos de vértice al shader, los sobreescribo?

O he de utilizar un shader para cada "objeto" del juego?

Hola,

Ando buscando información en internet sobre la estructura interna para ficheros targa, la cual necesito para un programa de opengl. Y no encuentro nada concreto.
Mi intención es entender como leer este fichero, para extraer los datos y su indormación de cabezera.

Gracias

Hola,

Eso! . Que no se cómo reescribir atributos de vértice una vez ya los he pasado con glVertexAttribPointer();

Tengo modelos 3d que están divididos en varios submodelos, y cada uno de ellos los tengo en arreglos diferentes.
Mi intención es pasar uno a uno los arreglos y dibujarlos, para luego mostrar en pantalla.
No se si existe otra forma de hacerlo.

Gracias,