C/OpenGL : geladenes Bild erscheint nur blau.

dot

Dann lass das wxImage mal, nimm die ersten 18 Byte aus deinem spriteredcross Array und mach einfach folgendes:

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, spriteredcross);

dot schrieb:

Dann lass das wxImage mal, nimm die ersten 18 Byte aus deinem spriteredcross Array und mach einfach folgendes:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, spriteredcross);

Danke dir für deine Mühe aber es klappt so nicht. Mittlerweile habe ich etwas gefunden. Falls jemand wxImage für OpenGL verwenden will sollte er sich das anschauen:

http://wiki.wxwidgets.org/Using_wxImage_to_load_textures_for_OpenGL

inter2k3

anfaenger01 schrieb:

dot schrieb:
Dann lass das wxImage mal, nimm die ersten 18 Byte aus deinem spriteredcross Array und mach einfach folgendes:
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, spriteredcross);
Danke dir für deine Mühe aber es klappt so nicht.

Dann liegt der Fehler irgendwo anders.
Selbst wenn du die ersten 18 Byte nicht ignorierst - sollte es funktionieren - nur eben mit einigen anderen Farbwerten (deine ersten 18 byte sind Tatsächlich der TGA-Header). Deine Farbinformationen liegen folgendermassen vor: blue - green - red - alpha (insofern wäre format: GL_BGRA).

Da es scheinbar immernoch nicht klappt - wirst du wohl an anderer Stelle ein Problem haben.

wxImage ist nicht so wirklich geeignet für OpenGL. Leider.
Ich würde da eher FreeImage (http://freeimage.sourceforge.net/) als Aufsatz für nehmen. Lädt die Bilder zwar in BGR aber das kann man sehr leicht switchen:

NLResource* NLTextureLoader::getTexture(const std::string& name, const std::string& filename, const bool repeat )
{
    FIBITMAP* dib(0);
    BYTE* pixels = NULL;
    u32 width    = 0;
    u32 height   = 0;
    u32 numcol   = 3;

    // Check image
    if ( FreeImage_GetFileType(filename.c_str()) == FIF_UNKNOWN )
    {
        NLError(std::string("[NLTextureLoader] Cannot determine filetype from '") + name + std::string("'"));
        return NULL;
    }
        if(FreeImage_FIFSupportsReading(FreeImage_GetFileType(filename.c_str())))
    {
        // Load Image
                dib = FreeImage_Load(FreeImage_GetFileType(filename.c_str()), filename.c_str());
            if(!dib)
        {
                    NLError(std::string("[NLTextureLoader] Cannot load Image '") + name + std::string("' due to missing plugin from FreeImage."));
            return NULL;
        }

        // Convert Image
        FreeImage_FlipVertical(dib);

        // Get Metrics       
        width  = FreeImage_GetWidth(dib);
        height = FreeImage_GetHeight(dib);
        numcol = this->getColorsFromFormat(FreeImage_GetColorType(dib));

        // Convert to24 bits. In some rare cases this is needed.
        if (FreeImage_GetPitch(dib)==width*4 && FreeImage_GetColorType(dib)==FIC_RGB){
            dib=FreeImage_ConvertTo24Bits(dib);
        }

                // Swap red and blue
                FIBITMAP* red  = FreeImage_GetChannel(dib, FICC_RED);
                FIBITMAP* blue = FreeImage_GetChannel(dib, FICC_BLUE);

                FreeImage_SetChannel(dib, red, FICC_BLUE);
                FreeImage_SetChannel(dib, blue, FICC_RED);

                // Get Pixels
                pixels = FreeImage_GetBits(dib);

        // Gen Texture
        u32 id = this->makeGLTexture(pixels, width, height, numcol, repeat);

        // Unload all images and free memory
        FreeImage_Unload(dib);

        // Create handle
                NLTexture* handle = new NLTexture(name.c_str(), glm::vec2(width, height), id);
        return handle;
    }
    return NULL;
}

Jetzt habe ich das ganze über wxWidgets implementiert. Nun habe ich das gleiche Ergebnis.

Scorcher24 schrieb:

wxImage ist nicht so wirklich geeignet für OpenGL. Leider.
Ich würde da eher FreeImage (http://freeimage.sourceforge.net/) als Aufsatz für nehmen. Lädt die Bilder zwar in BGR aber das kann man sehr leicht switchen:

Danke für den Hinweis ich werde es mir anschauen. Allerdings kann es doch wohl nicht all zu schwer sein einfach einen 16x16 Sprite mit einem Alpha Kanal in die Grafikkarte zu laden.

Was spricht dagegen, GL_BGRA zu verwenden wenn die Daten schon so vorliegen?