TextureManager.cpp

gehe zur Dokumentation dieser Datei

/*
Autor: $Author: kunkel $ State: $State: Exp $
Datum: $Date: 2005/05/30 12:35:25 $
Version: $Revision: 1.1 $
*/

#include "TextureManager.h"
TextureManager ourTextureManager;

bool TextureManager::check_if_png(FILE *fp) {
    unsigned char buf[PNG_BYTES_TO_CHECK];
    //falls nicht genug Bytes von der Datei gelesen werden koennen
    if (fread(buf, 1, PNG_BYTES_TO_CHECK, fp) != PNG_BYTES_TO_CHECK)
        return false;
    //Magic Vergleich mittels Libpng
    return(!png_sig_cmp(&buf[0], (png_size_t)0, PNG_BYTES_TO_CHECK));
}

bool TextureManager::read_png(const char *fname, oneTexture & target) {
    int width;
    int height;
    int bit_depth;
    png_structp png_ptr;
    png_infop info_ptr;

    //Oeffne die Datei
    FILE *fp = fopen(fname, "rb");
    if(fp == NULL)
        return false;

    if(check_if_png(fp) == 0)
        return false;

    //Allgemeine png lese struktur erzeugen
    png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    if (png_ptr == NULL) {
        fclose(fp);
        return false;
    }

    //informationsstruktur erzeugen
    info_ptr = png_create_info_struct(png_ptr);
    if (info_ptr == NULL) {
        fclose(fp);
        png_destroy_read_struct(&png_ptr, png_infopp_NULL, png_infopp_NULL);
        return false;
    }

    if (setjmp(png_jmpbuf(png_ptr))) {
        png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
        fclose(fp);
        return false;
    }

    //Datei mit lese struktur verknuepfen
    png_init_io(png_ptr, fp);
    png_set_sig_bytes(png_ptr, PNG_BYTES_TO_CHECK);

    // high-level lesen des bildes
    png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, png_voidp_NULL);
    fclose(fp);

    //Information ueber das Bild extrahieren
    width = (int)png_get_image_width(png_ptr, info_ptr);
    height = (int)png_get_image_height(png_ptr, info_ptr);
    bit_depth = png_get_bit_depth(png_ptr, info_ptr);

    if(bit_depth != 8) {
        cerr << "WARNUNG ben�ige RGB Bild "<<endl;
        png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
        return false;
    }

    //bildzeilen in data speichen:
    png_bytep * data = png_get_rows(png_ptr, info_ptr);

    //zielinformation setzen:
    target.width = width;
    target.height = height;

    //Speicher fuer das Bild reservieren:
    target.data = new GLbyte[width*height*3];
    //umkonvertieren der Information in fuer Opengl verstaendliche
    // Information
    //Dies ist abhaengig davon wie fuer Opengl die Anordnung im Speicher
    // gewaehlt wird.
    for(int y=0; y < height; y++) {
        for(int x=0; x < width; x++) {
            for(int k=0; k < 3; k++)
                target.data[(x+width*y)*3+k] =(GLbyte) data[y][x*3+k];
        }
    }

    //Freigabe des Speichers von libpng
    png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
    return true;
}

void TextureManager::createPNGTexture(const string & filename, oneTexture & targetTexture, bool createMipmaps) {
    // oeffne das Bild und lese das Bild ein:
    if(! read_png(filename.c_str(), targetTexture)) {
        cerr <<  "PNG Textur konnte nicht geladen werden: " << filename << endl;
        targetTexture.data = 0;
        return;
    }

    //Anordnung des Bildes im Speicher fuer Opengl festlegen:
    glPixelStorei (GL_UNPACK_ALIGNMENT, 1);
    //Die Textur soll so um das Objekt gelegt werden das sie wiederholt wird.
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

    // Erzeuge eine Opengl texture und speichere die Opengl textur nummer.
    glGenTextures(1, &targetTexture.number);

    // Binde die Texture an die Opengl Textur nummer und initialisiere die Textur
    glBindTexture(GL_TEXTURE_2D, targetTexture.number);

    if(createMipmaps) {
        //Falls Mipmaps erzeugt werden sollen muss die Qualitaet dieser
        // festgelegt werden.
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,
                        GL_LINEAR_MIPMAP_NEAREST);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,
                        GL_LINEAR_MIPMAP_LINEAR);

        // Erzeuge Mipmaps, es werden verschiedene Texturversionen erzeugt die
        //abhaengig von Entfernung angezeigt werden.
        gluBuild2DMipmaps(GL_TEXTURE_2D, 3, targetTexture.width,
                          targetTexture.height, GL_RGB, GL_UNSIGNED_BYTE,
                          targetTexture.data);
    } else {
        //Das Bild muss 2^k gro�sein !!!
        glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
                         GL_NEAREST);
        glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                         GL_NEAREST);
    }

    //Textur opengl bekannt machen
    glTexImage2D (GL_TEXTURE_2D, 0, GL_RGBA, targetTexture.width,
                  targetTexture.height,0, GL_RGB,
                  GL_UNSIGNED_BYTE, targetTexture.data);
}

unsigned short TextureManager::getTextureNumber(const string & tex) {
    int free=MAX_TEXTURES;

    for(int i=0; i < MAX_TEXTURES ; i++) {
        //naechste freie position ermitteln:
        if(textureArray[i].references == 0 && free == MAX_TEXTURES)
            free = i;

        //ist textur bereits im speicher ?
        if(textureArray[i].references != 0 && tex == textureArray[i].name) {
            //textur im Speicher gefunden:
            textureArray[i].references++;
            return i;
        }
    }
    //Die Textur konnte also nicht im Speicher gefunden werden und muss
    // geladen werden:

    if(free == MAX_TEXTURES) {
        cerr <<
        "WARNING MAX_TEXTURES limit reached !! TEXTURE COULD NOT BE LOADED"
        << endl;
        return 0;
    }

    //Lade die Texture an die freie Stelle im Array:
    createPNGTexture(tex,textureArray[free],true);
    textureArray[free].references=1;
    textureArray[free].name = tex;
    return free;
}

void TextureManager::freeReference(unsigned short texture) {
    textureArray[texture].references--;
    if(textureArray[texture].references == 0 &&
            textureArray[texture].data != 0 ) {
        //Freigabe der Textur:
        glDeleteTextures(1,& textureArray[texture].number);
        delete(textureArray[texture].data);
    }
}

void TextureManager::freeTextures() {
    //texturen loeschen
    for (int i=0; i<MAX_TEXTURES; i++) {
        if(textureArray[i].references > 0) {
            textureArray[i].references=1;
            freeReference(i);
        }
    }
}

GLuint TextureManager::getOpenglTexture(unsigned short num) {
    return textureArray[num].number;
}

TextureManager::~TextureManager() {
    //Freigabe der Texturen:
    freeTextures();
}

---