spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

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

// 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;

        // Sicherheitstests

    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;

    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;
    }

    return (result);
}

C-/C++-Quelltext

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

// PUBLIC 

//

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

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

void texture::loadTexture (const std::basic_string<wchar_t>& fileName)
{
        // Ist die zu ladene Textur schon enthalten?

    if (textures_.find(fileName) != textures_.end()) 
        return;

        // Hilfsstrukturen

    ::IDirect3DTexture9*    texture         = NULL;
    ::IDirect3DSurface9*    surface         = loadSurfaceFromFile (fileName, 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 freigeben

    safeRelease (surface);
    
        // 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);

    delete [] data;

        // Alphakey setzen

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

        // Textur und Dateiname in den Manager einfügen

    textures_.insert (std::make_pair(fileName, texture));
}

C-/C++-Quelltext

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

// GLOBAL

// 

// Gibt einer Textur einen Alphakey

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

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<describe.Height; ++y) 
    {
        for (unsigned long x=0; x<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);
}

C-/C++-Quelltext

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

// PUBLIC

// 

// Erstellung einer perspektivischen Projektionsmatrix

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

void direct3d::createProjection (float fov, float aspect, float nearPlane, float farPlane)
{
        // Sicherheitsabfragen

    if (abs<float>(farPlane-nearPlane) < epsilon<float>::value)
        return;
    if (abs<float>(sin<float>(deg2rad<float>(fov)/2)) < epsilon<float>::value)
        return;

        // Zwischenwerte berechnen

    const float cosin  = cos<float>(deg2rad<float>(fov)/2) / sin<float>(deg2rad<float>(fov)/2);
    const float farinv = farPlane / (farPlane - nearPlane);

        // Temporäres Objekt

    ::D3DMATRIX temp;

        // Einheitsmatrix erstellen

    matrixIdentity (&temp);

        // Matrix verändern

    temp._11 = aspect*cosin;
    temp._22 = 1.0f*cosin;
    temp._33 = farinv;
    temp._34 = 1.0f;
    temp._43 = -farinv*nearPlane;
    temp._44 = 0.0f;

        // Projektionsmatrix setzen

    direct3d_device_->SetTransform (D3DTS_PROJECTION, &temp);
}