elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado:


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Insertar imágenes en C con Open GL
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Insertar imágenes en C con Open GL  (Leído 3,106 veces)
Markitukas

Desconectado Desconectado

Mensajes: 5


Ver Perfil
Insertar imágenes en C con Open GL
« en: 28 Febrero 2012, 15:51 pm »

Hola gente, estoy haciendo un juego tipo pc futbol y la parte programación esta bastante aceptable ya, pero me quise adentrar a la programación Básica y resulta que no puedo poner por ejemplo en un rectángulo una imagen de una cancha de futbol que quiero poner, alguien me puede dar una mano?

Muchas gracias.


En línea

BlackZeroX
Wiki

Desconectado Desconectado

Mensajes: 3.148


I'Love...!¡.


Ver Perfil WWW
Re: Insertar imágenes en C con Open GL
« Respuesta #1 en: 28 Febrero 2012, 19:22 pm »

La pagina de Nehe tiene buenas guías mírate estos:

http://nehe.gamedev.net/tutorial/lessons_06__10/17010/



1ro debes cargar la imagen:

    glGenTextures(1 , &this->uiID);   // Generamos la ID de la textura
    glBindTexture(GL_TEXTURE_2D , this->uiID-1);
    glTexParameteri(GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_LINEAR);

// Una vez creado el ID para la tectura debes cargarla y asignarla a este ID...

::glBindTexture( GL_TEXTURE_2D, this->uiID);
        ::glTexImage2D(GL_TEXTURE_2D,
                       0,
                       3,
                       oBMPReader.getInfo().bmiHeader.biWidth,
                       oBMPReader.getInfo().bmiHeader.biHeight,
                       0,
                       GL_RGB,
                       GL_UNSIGNED_BYTE,
                       (GLvoid*)oBMPReader.getBytes().lpData);

Para implementarla debes usar

    if(this->uiID > 0 && this->enabled)
        ::glBindTexture(GL_TEXTURE_2D , this->uiID - 1);
    else
        ::glBindTexture(GL_TEXTURE_2D , 0);

Para poderla dibujar debes definir antes los vértices que definen la textura a implementar y (estos vertices pueden inclusive estirar la textura) de la textura:

glTexCoord3f();

Antes de llamar a

glVertex3f();

Te dejo mis clases con las que realizo estas acciones:

CTexture.h
Código:
#ifndef CTexture_H
#define CTexture_H

#include "native.h"
#include "_Formatos/mBitmap/CBMPReader.h"
#include <windows.h>
#include <GL/glut.h>

class CGL_Texture;
typedef CGL_Texture CGL_TEXTURE, *LPCGL_TEXTURE;

class CGL_Texture: public Object
{
private:
    unsigned int uiID;
    void create();
    bool bLoadBMP;

public:
    CGL_Texture();
    ~CGL_Texture();

    bool itsLoad();
    bool enabled;
    void remove();
    void use();
    bool loadBMP(const char* szFile);
};

#endif // CTexture_H


CTexture.cpp
Código:

#include "OpenGL/ctexture.h"

//---------------------------------------------------------------
// Nombre: Constructor
// Descripcion: Constructor de la clase. Inicializa las variables
// Parametros: Ninguno
//---------------------------------------------------------------
CGL_Texture::CGL_Texture():
Object()
{
    this->uiID = 0;
    this->enabled = false;
    this->bLoadBMP = false;
}

//---------------------------------------------------------------
// Nombre: Destructor
// Descripcion: Destructor de la clase. Elimina la textura
// Parametros: Ninguno
//---------------------------------------------------------------
CGL_Texture::~CGL_Texture()
{
    this->remove();
}

//---------------------------------------------------------------
// Nombre: Crear
// Descripcion: Establece los parámetros GL para cargar
// Parametros:
//                char* szNombreFichero: Nombre del fichero a cargar
//---------------------------------------------------------------
void CGL_Texture::create()
{
    this->remove();
    ::glGenTextures(1 , &this->uiID);   // Generamos la ID de la textura
    this->uiID++;    // Usamos un offset de +1 para diferenciar del estado no-inicializado
    ::glBindTexture(GL_TEXTURE_2D , this->uiID-1);
    ::glTexParameteri(GL_TEXTURE_2D , GL_TEXTURE_MAG_FILTER , GL_LINEAR);
    ::glTexParameteri(GL_TEXTURE_2D , GL_TEXTURE_MIN_FILTER , GL_LINEAR);
}
//---------------------------------------------------------------
// Nombre: Elimina
// Descripcion: Elimina la textura
// Parametros: Ninguno
//---------------------------------------------------------------
void CGL_Texture::remove()
{
    if( this->uiID > 0)
        ::glDeleteTextures(1 , &(--this->uiID));
    this->uiID = 0;
    this->bLoadBMP = false;
}

//---------------------------------------------------------------
// Nombre: Usa
// Descripcion: Usa la textura actual
// Parametros: Ninguno
//---------------------------------------------------------------
void CGL_Texture::use()
{
    if(this->uiID > 0 && this->enabled)
        ::glBindTexture(GL_TEXTURE_2D , this->uiID - 1);
    else
        ::glBindTexture(GL_TEXTURE_2D , 0);
}

//---------------------------------------------------------------
// Nombre: CargarBMP
// Descripcion: Carga un fichero BMP y almacena los datos
// Parametros: Ninguno
//---------------------------------------------------------------
bool CGL_Texture::loadBMP(const char *szFile)
{
    CBMPReader oBMPReader;
    this->remove();
    if(oBMPReader.loadBMP(szFile) != NULL)
    {
        this->create();
        ::glBindTexture( GL_TEXTURE_2D, this->uiID);
        ::glTexImage2D(GL_TEXTURE_2D,
                       0,
                       3,
                       oBMPReader.getInfo().bmiHeader.biWidth,
                       oBMPReader.getInfo().bmiHeader.biHeight,
                       0,
                       GL_RGB,
                       GL_UNSIGNED_BYTE,
                       (GLvoid*)oBMPReader.getBytes().lpData);
        return this->bLoadBMP = true;
    }
    return this->bLoadBMP = false;
}

//---------------------------------------------------------------
// Nombre: itsLoad
// Descripcion: Esta cargada la textura en memoria?.
// Parametros: Ninguno
//---------------------------------------------------------------
bool
CGL_Texture::itsLoad()
{
    return this->bLoadBMP;
}


CDrawn.h
Código:

#ifndef CGL_DRAWN_H
#define CGL_DRAWN_H

#include <windows.h>
#include <stack>
#include "native.h"
#include "OpenGL/cglobject.h"

using namespace std;

class CGL_Drawn;
typedef CGL_Drawn CGL_DRAWN, *LPCGL_DRAWN;

class CGL_Drawn: public Object, public stack<LPCGL_OBJECT>
{
public:
    CGL_Drawn();
    CGL_Drawn(int idWin);
    virtual ~CGL_Drawn();
    int draw();
    int draw(int idWin);
protected:
    int idWin;
private:
};

#endif // CGL_DRAWN_H


CDrawn.cpp
Código:

#include "OpenGL/cdrawn.h"

#include <iostream>
#include <algorithm>

using namespace std;

CGL_Drawn::CGL_Drawn(int idWin):
    Object()
{
    this->idWin = idWin;
    //ctor
}

CGL_Drawn::CGL_Drawn():
    Object(), idWin(0)
{
    //ctor
}

CGL_Drawn::~CGL_Drawn()
{
    //dtor
}

int CGL_Drawn::draw()
{
    return this->draw(idWin);
}

int CGL_Drawn::draw(int idWin)
{
    LPCGL_OBJECT lpCGL_Object = NULL;
    LPCASE_MATERIAL lpMaterial = NULL;
    LPCASE_MESH lpCASE_Mesh = NULL;
    TAnimObject* lpAniObj = NULL;
    int iRet = 0,
        n = 0,
        tv = 0,
        v = 0;
    int i = 0,
    j = 0;

    float fMax = 0.0f;

    ::glutPushWindow();
    ::glutSetWindow(idWin);

    while(!this->empty())
    {
        ::glPushMatrix();

        lpCGL_Object = this->top();
        lpCASE_Mesh = lpCGL_Object->lpCASE_Object->lpMesh;

        ::glTranslatef(lpCGL_Object->x, lpCGL_Object->y, lpCGL_Object->z);

        /// Animación...
        lpAniObj = &lpCGL_Object->lpCASE_Object->udtAnimate.udtAnimObject;

        if (lpAniObj->iPosCount)
        {
            if (lpAniObj->iStepPos >= lpAniObj->iPosCount)
                lpAniObj->iStepPos = 0;
            ::glTranslatef(lpAniObj->lpPosTrack[i]->fPosition[0],
                           lpAniObj->lpPosTrack[i]->fPosition[1],
                           lpAniObj->lpPosTrack[i]->fPosition[2]);
            lpAniObj->iStepPos++;
        }
        else
        {
            ::glTranslatef(lpCGL_Object->lpCASE_Object->lpNodeTM->fTMPos[0],
                           lpCGL_Object->lpCASE_Object->lpNodeTM->fTMPos[1],
                           lpCGL_Object->lpCASE_Object->lpNodeTM->fTMPos[2]);
        }

        if (lpAniObj->iRotCount)
        {
            if (lpAniObj->iStepRot >= lpAniObj->iRotCount)
                lpAniObj->iStepRot = 0;
            ::glRotatef(lpAniObj->lpRotTrack[lpAniObj->iStepRot]->fAngle,
                        lpAniObj->lpRotTrack[lpAniObj->iStepRot]->fAxis[0],
                        lpAniObj->lpRotTrack[lpAniObj->iStepRot]->fAxis[1],
                        lpAniObj->lpRotTrack[lpAniObj->iStepRot]->fAxis[2]);
            lpAniObj->iStepPos++;
        }
        else
        {
            ::glRotatef(lpCGL_Object->lpCASE_Object->lpNodeTM->fTMRotAngle,
                        lpCGL_Object->lpCASE_Object->lpNodeTM->fTMRotAxis[0],
                        lpCGL_Object->lpCASE_Object->lpNodeTM->fTMRotAxis[1],
                        lpCGL_Object->lpCASE_Object->lpNodeTM->fTMRotAxis[2]);
        }

        /// End

        //cout << lpCGL_Object->lpCASE_Object->sNodeName << "\t" << lpCGL_Object->lpCASE_Object->iMaterialRef <<endl;

        if (lpCGL_Object->lpCASE_Object->iMaterialRef != -1)
            lpMaterial = lpCGL_Object->lpCASE_Object->lpModels->listMaterials[lpCGL_Object->lpCASE_Object->iMaterialRef];


        if (lpMaterial)
        {
            ::glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, lpMaterial->fMaterialAmbient);
            ::glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, lpMaterial->fMaterialDiffuse);
            ::glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, lpMaterial->fMaterialSpecular);
            ::glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, lpMaterial->fMaterialShine);
        }

        if (lpMaterial)
            ::glColor3fv(lpMaterial->fMaterialDiffuse);

        //  Aplicar color o Textura al objeto.
        ::glColor3fv(lpCGL_Object->lpCASE_Object->fWireFameColor);

        //  Malla de Poligonos.
        for(v = 0 ; v < lpCASE_Mesh->listFace.size(); ++v)
        {
            ::glBegin(GL_TRIANGLES);
            for(n = 0 ; n < 3 ; ++n)                 //  Vertices(Triangulos).
            {
                if(lpCGL_Object->oTexture.itsLoad())// && lpCGL_Object->oTexture.enabled)         //  Textura.
                {
                    switch(n)
                    {
                    case 0: tv = lpCASE_Mesh->listTFace[v]->ia; break;
                    case 1: tv = lpCASE_Mesh->listTFace[v]->ib; break;
                    case 2: tv = lpCASE_Mesh->listTFace[v]->ic; break;
                    }
                    lpCGL_Object->oTexture.use();
                    ::glTexCoord3f(lpCASE_Mesh->listTVertex[tv]->fx,
                                   lpCASE_Mesh->listTVertex[tv]->fy,
                                   lpCASE_Mesh->listTVertex[tv]->fz);
                }   //  Textura
                //cout << lpCASE_Mesh->listFace.size() << "\t" << n << "\t" << v << "\t" << endl;
                switch(n)
                {
                case 0: tv = lpCASE_Mesh->listFace[v]->ia; break;
                case 1: tv = lpCASE_Mesh->listFace[v]->ib; break;
                case 2: tv = lpCASE_Mesh->listFace[v]->ic; break;
                }
                ::glVertex3f(lpCASE_Mesh->listVertex[tv]->fx,
                             lpCASE_Mesh->listVertex[tv]->fy,
                             lpCASE_Mesh->listVertex[tv]->fz);
            }
        }   //  v < lpCASE_Mesh->ListFace.size();

        ::glEnd();
        iRet++;
        this->pop();

        ::glPopMatrix();
    }

//    cout << fMax << endl;

    ::glutPopWindow();

    return iRet;
}


P.D.: No son todos los archivos de mi proyecto... solo te los dejo para/como Guía.

Dulces Lunas!¡.


« Última modificación: 28 Febrero 2012, 19:26 pm por BlackZeroX (Astaroth) » En línea

The Dark Shadow is my passion.
Markitukas

Desconectado Desconectado

Mensajes: 5


Ver Perfil
Re: Insertar imágenes en C con Open GL
« Respuesta #2 en: 28 Febrero 2012, 21:26 pm »

Muchísimas gracias Man! ya las voy a leer tranquilo y voy a intentar, si tengo alguna duda te consulto. Muchísimas gracias por respodener tan rápido un abrazo.
En línea

Markitukas

Desconectado Desconectado

Mensajes: 5


Ver Perfil
Re: Insertar imágenes en C con Open GL
« Respuesta #3 en: 1 Marzo 2012, 15:24 pm »

Buenas acabo de ver el post que me pasaste y sigo con una duda muy grande. Cuando le paso el archivo? por que es como si esa parte todo el mundo se la salteara y la verdad que se me complica mucho. Muchos tutoriales me dicen que cargue la imagen en memoria y ninguna de las que hago me funciona. Un abrazo.

Saludos
En línea

Markitukas

Desconectado Desconectado

Mensajes: 5


Ver Perfil
Re: Insertar imágenes en C con Open GL
« Respuesta #4 en: 6 Marzo 2012, 16:36 pm »

Aver mirando un tutorial trate de hacer esto pero sigue sin aparecer mi textura, me esta volviendo loco...

#include <stdio.h>
#include <windows.h>
#include "GL/glut.h"

typedef struct // Utilizamos esta estructura
{
GLubyte *imageData;
GLuint bpp;
GLuint width;
GLuint height;
GLuint texID;
} Imagen;
int textura;

void *CargaTGA(char *cancha,int *tam)
{
GLubyte TGAheader[12]={0,0,2,0,0,0,0,0,0,0,0,0};
GLubyte TGAcompare[12];
GLubyte header[6];
GLuint bytesPerPixel;
GLuint imageSize;
GLuint temp,i;
GLuint type=GL_RGBA;
Imagen texture;
GLubyte *aux;
FILE *file = fopen(cancha, "rb");
if (file == NULL)
return NULL;
/* Esto abre y comprueba que es un TGA */
fread(TGAcompare,1,sizeof(TGAcompare),file);
if (memcmp(TGAheader,TGAcompare,sizeof(TGAheader))!=0)
return NULL;

/* Leemos la cabecera*/
fread(header,1,sizeof(header),file);
/* Determinamos el tamaño */
texture.width = header[1] * 256 + header[0];
texture.height = header[3] * 256 + header[2];

/* Vemos las características y comprobamos si son correctas*/
if( texture.width <=0 ||texture.height <=0 ||texture.width >256 ||texture.height !=texture.width ||( header[4]!=32))
{
fclose(file);
return NULL;
}
/* Calculamos la memoria que será necesaria */
texture.bpp = header[4];
bytesPerPixel = texture.bpp/8;
imageSize = texture.width*texture.height*bytesPerPixel;

/* Reservamos memoria */
texture.imageData=(GLubyte *)malloc(imageSize);

/* Cargamos y hacemos alguna comprobaciones */
if( texture.imageData==NULL ||
fread(texture.imageData, 1, imageSize, file)!=imageSize)
{
if(texture.imageData!=NULL)
free(texture.imageData);
fclose(file);
return NULL;
}


/* El TGA viene en formato BGR, lo pasamos a RGB */
for(i=0; i<(GLuint)(imageSize); i+=bytesPerPixel)
{
temp=texture.imageData;
texture.imageData = texture.imageData[i + 2];
texture.imageData[i + 2] = temp;
}
fclose (file);

/* Ahora, cambiamos el orden de las líneas, como si hiciesemosun flip vertical. */
aux=(GLubyte *)malloc(imageSize);
for(i=0; i<texture.height; i++)
memcpy(&aux[imageSize-((i+1)*texture.width*4)],&texture.imageData[i*texture.width*4],texture.width*4);

/* tam devolverá el tamaño */
*tam=texture.width;

/* Liberamos memoria */
free(texture.imageData);

/* Todo fue bien!*/
return aux;

}

int carga_texturas(void) {

Imagen texture;
int tam;
texture.imageData=(char *)CargaTGA("cancha.tga",&tam);if (texture.imageData == NULL) {
return -1;
}

/* Genera una textura, referenciada por el entero textura */
glGenTextures (1, &textura);

/* Esta función indica que será una textura en 2D. Las siguientes funciones hará referncia a esta textura */
glBindTexture (GL_TEXTURE_2D, textura);

/* Aquí ajustamos algunos parámetros de la textura, concretamente los filtros */
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_NEAREST);

/* Con esta función de GLU, creamos un mipmap. Nótese que especificamos el tamaño con tam, que devolvia la función CargaTGA*/
gluBuild2DMipmaps (GL_TEXTURE_2D, 4, tam, tam, GL_RGBA,GL_UNSIGNED_BYTE, texture.imageData);

/* Liberamos la memoria que ya no utilizaremos */
free(texture.imageData);

return 0;
}

      
  void display()
  {
   
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glClear(GL_COLOR_BUFFER_BIT);
    glColor4f(0.0, 0.5, 0.2,0.0);
   glBindTexture(GL_TEXTURE_2D, textura);
    glBegin(GL_POLYGON);
      glTexCoord2f(0.0, 0.0);
        glVertex2f(-0.5, 0.9);
      glTexCoord2f(1.0, 0.0);
      glVertex2f(0.5, 0.9);
      glTexCoord2f(1.0, 1.0);
        glVertex2f(0.5, -0.9);
      glTexCoord2f(0.0, 1.0);
        glVertex2f(-0.5,-0.9);
    glEnd();
    glColor3f(1.0, 1.0, 1.0);
    glTranslatef(0.1,0.1,0);
    glPushMatrix();
    glTranslatef(0.1,0.1,0.1);
    glutSolidSphere(0.02,300,300);
    glPopMatrix();
    glutSolidSphere(0.02,300,300);

   glFlush();
  }

  void init()
  {
    glClearColor(0.000, 0.110, 0.392, 0.0); // JMU Gold

    glColor3f(0.314, 0.314, 0.000); // JMU Purple

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluOrtho2D(-1.0, 1.0, -1.0, 1.0);
  }

  int main(int argc, char** argv)
  {
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(640, 480);
    glutInitWindowPosition(0, 0);
    glutCreateWindow("Test");
    glutDisplayFunc(display);
    init();
    glutMainLoop();
  }

Aver si me pueden ayudar. Saludos.
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Insertar imagenes en Inyección SQL « 1 2 »
Nivel Web
rikrdo_mat 12 7,304 Último mensaje 2 Diciembre 2010, 04:38 am
por 3st3
SDL insertar imagenes [lenjuage C]
Programación C/C++
JORGE BAAK 3 8,301 Último mensaje 9 Marzo 2011, 11:57 am
por anonimo12121
Getty Images libera 35 millones de imágenes, que cualquiera podrá insertar en...
Noticias
wolfbcn 0 816 Último mensaje 6 Marzo 2014, 12:47 pm
por wolfbcn
Insertar imágenes en el foro
Sugerencias y dudas sobre el Foro
anlimo69 2 1,808 Último mensaje 1 Septiembre 2015, 19:45 pm
por anlimo69
Aprovechan un bug de Facebook para insertar imágenes con las que infectarte ...
Noticias
wolfbcn 0 1,027 Último mensaje 25 Noviembre 2016, 21:42 pm
por wolfbcn
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines