spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// ###########################################################################

// Datei:        surface.cpp

// ###########################################################################

// Autor:        Patrick Ullmann

// Erstellt:     18.12.2005

// Änderungen:   18.12.2005/Patrick: Datei erstellt

// ###########################################################################

// Beschreibung: Diverse Surface Hilfsfunktionen /- Strukturen


// I N C L U D E S ###########################################################

#include "surface.h"

// F U N K T I O N E N #######################################################

namespace core
{
// ///////////////////////////////////////////////////////////////////////////

// PUBLIC

// 

// Funktion zum vertauschen von Daten

// ///////////////////////////////////////////////////////////////////////////

void flip (unsigned char* image, unsigned long bytesPerLine, unsigned long height)
{
        // Speicher bereit stellen

    unsigned char *line1 = new unsigned char [bytesPerLine];
    unsigned char *line2 = new unsigned char [bytesPerLine];    

        // Spiegeln

    for (unsigned long i=0; i<height/2; ++i)
    {
        memcpy (line1, &image [i * bytesPerLine], bytesPerLine);
        memcpy (line2, &image [(height - 1 - i) * bytesPerLine], bytesPerLine);

        memcpy (&image [i * bytesPerLine], line2, bytesPerLine);
        memcpy (&image [(height - 1 - i) * bytesPerLine], line1, bytesPerLine);
    }

        // Aufräumen nach der Party

    delete [] line1;
    delete [] line2;
}

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC

// 

// Läd eine Bitmap in eine Direct3D Surface

// ///////////////////////////////////////////////////////////////////////////

::IDirect3DSurface9* loadSurfaceFromFile (const std::basic_string<wchar_t>& fileName, ::IDirect3DDevice9* device)
{
    DEBUG_STACK;

        // Es kann nur ein gültiges Device benutzt werden.

    if (!device) EXCEPTION (L"Invalid parameters");

        // Hilfsstrukturen /-Variabeln

    ::BITMAPFILEHEADER  FileHeader;     // BMP Datei Header

    ::BITMAPINFOHEADER  InfoHeader;     // BMP Datei Info Header

    unsigned long       mem;            // Zwischenspeicher

    unsigned long       pitch;          // lPitch der Surface >> 1

    void*               dest;           // Für die Pixeldaten

    ::D3DLOCKED_RECT    rectLock;       // Enthält Speicheradresse

    ::IDirect3DSurface9 *result = NULL; // Rückgabesurface


        // BMP Datei öffnen

    ::HANDLE file = ::CreateFile (fileName.c_str(),         // Datei Name

                                  GENERIC_READ,             // Nur lesen

                                  FILE_SHARE_READ,          // andere auch

                                  NULL,                     // keine Attrib.

                                  OPEN_EXISTING,            // exist. Datei

                                  FILE_ATTRIBUTE_NORMAL,    // norm.Attrib.

                                  NULL);                    // unbenutzt


        // Hat es geklappt?

    if (file == INVALID_HANDLE_VALUE) 
        EXCEPTION (L"Invalid file! (FILE_SHARE_READ)");

        // BMP Header einlesen

    if (!::ReadFile(file, &FileHeader, sizeof(FileHeader), &mem, NULL)) 
    {
        ::CloseHandle(file);
        EXCEPTION (L"Invalid file! (BMPFILEHEADER)");
    }

        // BMP Info-Header einlesen

    if (!::ReadFile(file, &InfoHeader, sizeof(InfoHeader), &mem, NULL)) 
    {
        ::CloseHandle(file);
        EXCEPTION (L"Invalid file! (BMPINFOHEADER)");
    }

        // Hat das Bitmap das gewünschte Format

    if (InfoHeader.biBitCount != 24) 
    {
        ::CloseHandle(file);
        EXCEPTION (L"Invalid file! (File must be 24bpp)");
    }

        // Initialisiere Surface Objekt im Bildschirmformat

    if (device->CreateOffscreenPlainSurface (InfoHeader.biWidth, InfoHeader.biHeight, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, &result, NULL) != D3D_OK)
    {
        ::CloseHandle(file);
        EXCEPTION (L"Invalid file! (BMPFILEHEADER)");
    }

        // Speicher dynamisch bereitstellen

    unsigned char* data = new unsigned char [InfoHeader.biSizeImage];

        // Lies die eigentlichen Bilddaten des BMP

    if (!::ReadFile (file, data, InfoHeader.biSizeImage, &mem, NULL)) 
    {
        ::CloseHandle(file);
        EXCEPTION (L"Invalid file! (Reading imagedata)");
    }

        // Schliesse die Datei wieder

    ::CloseHandle(file);

        // Surface verriegeln

    if (result->LockRect (&rectLock, NULL, 0) != D3D_OK) 
        EXCEPTION (L"IDirect3DSurface9::LockRect");

    pitch   = rectLock.Pitch >> 2; // Byte/2 weil 32bpp = 4 Byte

    dest    = (unsigned long *)rectLock.pBits;

        // Spiegelung durchführen

    flip (data, InfoHeader.biSizeImage/InfoHeader.biHeight, InfoHeader.biHeight);

        // Wir müssen jeden Pixel umwandeln, also Pixel für Pixel

        // das Bild kopieren, und zwar von unten nach oben

    for (unsigned long cy=0; cy<static_cast<unsigned long>(InfoHeader.biHeight); ++cy) 
    {
        for (unsigned long cx=0; cx<static_cast<unsigned long>(InfoHeader.biWidth); ++cx) 
        {
                // Farbe mit Alpha = 100 % initialisieren

            unsigned long color = 0xff000000;

                // Kopiere 24 Bit Farbe in den 32 Bit Wert

            memcpy (&color, &data[(cy*InfoHeader.biWidth + cx)*3], sizeof(unsigned char)*3);

                // Pixel in 32 Bit Farbe schreiben

            ((unsigned long*)dest)[cx + (cy*pitch)] = color;
        }
    }

        // Entriegeln der Surface nach dem Schreiben der Daten

    result->UnlockRect();

        // Speicher freigeben

    if (data != NULL)
    {
        delete [] data;
        data = NULL;
    }

        // Surface zurückgeben

    return (result);
}
} // Namespace: core

C-/C++-Quelltext

// ///////////////////////////////////////////////////////////////////////////

// PUBLIC 

//

// Läd eine 24Bit (!!!) Bitmap in den Texturmanager

// ///////////////////////////////////////////////////////////////////////////

void texture::loadTexture (const std::basic_string<wchar_t>& file)
{
    DEBUG_STACK;

        // Ist die zu ladene Textur schon enthalten?

    if (texture_.find(file) != texture_.end()) return;

        // Hilfsstrukturen

    ::IDirect3DTexture9*    texture         = NULL;
    ::IDirect3DSurface9*    surface         = loadSurfaceFromFile (file, direct3d::getInstance().direct3d_device_);
    ::D3DSURFACE_DESC       desc_surface;
    ::D3DLOCKED_RECT        locked_surface;
    ::D3DLOCKED_RECT        locked_texture;

        // Daten der Surface abfragen

    surface->GetDesc (&desc_surface);

        // Größe berechnen

    unsigned long size = desc_surface.Width*desc_surface.Height*2*2;
        // Speicher für Bilddaten bereitstellen

    unsigned char* data = new unsigned char [size*sizeof(unsigned char)];

        // Bilddaten aus der Surface kopieren

    surface->LockRect (&locked_surface, NULL, D3DLOCK_READONLY);
    memcpy (data, locked_surface.pBits, size * sizeof(unsigned char));
    surface->UnlockRect ();
       
        // Surface ggf. freigeben und NULLen

    if (surface != NULL)
    {
        surface->Release ();
        surface = NULL;
    }
    
        // Initialisiere das IDirect3DTexture9 Objekt

    if (direct3d::getInstance().direct3d_device_->CreateTexture 
       (desc_surface.Width, desc_surface.Height, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, &texture, NULL) != D3D_OK)
        EXCEPTION (L"IDirect3DDevice9::CreateTexture(); failed!");

        // Farbdaten von der Surface in die Textur kopieren

    texture->LockRect (0, &locked_texture, NULL, 0);
    memcpy (locked_texture.pBits, data, size * sizeof(unsigned char));
    texture->UnlockRect (0);

        // Datenarray freigeben

    delete [] data;

        // Alphakey setzen

    setAlphakey (&texture, 0xFFFF00FF, 0x00FFFFFF);

        // Textur und Dateiname in den Manager einfügen

    texture_.insert (std::make_pair(file, texture));
}

C-/C++-Quelltext

    // Einer Textur einen Alphakey geben

void setAlphakey (::IDirect3DTexture9** texture, unsigned long colorkey, unsigned long alpha)
{
        // Hilfsobjekte

    static ::D3DSURFACE_DESC    describe;
    static ::D3DLOCKED_RECT     rect;

        // Surfacebeschreibung holen

    (*texture)->GetLevelDesc (0, &describe);

        // Textur verriegeln

    (*texture)->LockRect (0, &rect, NULL, 0);

        // 32 Bit Pointer auf Bilddaten in der Textur

    for (unsigned long y=0; y<static_cast<unsigned long>(describe.Height); ++y) 
    {
        for (unsigned long x=0; x<static_cast<unsigned long>(describe.Width); ++x) 
        {
            if ((static_cast<unsigned long*>(rect.pBits))[describe.Width*y+x] == colorkey)
                (static_cast<unsigned long*>(rect.pBits))[describe.Width*y+x] = alpha;
        }
    }

        // Textur entriegeln

    (*texture)->UnlockRect (0);
}