spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#if !defined (_CGFXDEVICE_HPP_)
#define _CGFXDEVICE_HPP_

#include "Headerpool.hpp"

class GfxDevice
{
private:
        // m e m b e r _ v a r i a b l e s

    HWND            m_hwndMain;
    HDC             m_dcBackBuffer;
    HBITMAP         m_bmBackBuffer;

    const double    pi; 

        // m e m b e r _ f u n c t i o n s

    unsigned int    createBackBuffer    (void);
    void            clearBackBuffer     (void);
    void            renderImage         (void);
    void            flip                (void);
    double          degToRad            (const double degree) { return degree * pi / 180; }

public:

        // m e m b e r _ f u n c t i o n s

                    GfxDevice           (HWND hwndMain);
                    ~GfxDevice          (void);
    bool            loadBitmap          (const wchar_t *pFilename, HDC *pDC, HBITMAP *phBitmap, BITMAPINFO *pbmInfo);
    void            renderFrame         (void);
    void            rotateBitmap        (const BITMAPINFO bmInfo, signed int *degree);

}; // class GfxDevice


#endif

#include "CGfxDevice.hpp"

extern Player tplayer;

    
     // P R I V A T E

     

        // m e m b e r _ f u n c t i o n s



unsigned int GfxDevice::createBackBuffer (void)
{
    HDC     dcMainWindow;
    RECT    rClient;
    HGDIOBJ hGdiObj;

    GetClientRect(m_hwndMain, &rClient);

    if((dcMainWindow = GetDC(m_hwndMain)) == NULL )
        return 0;

    if((m_dcBackBuffer = CreateCompatibleDC(dcMainWindow)) == NULL )
        return 0;

    if((m_bmBackBuffer = CreateCompatibleBitmap(dcMainWindow, rClient.right, rClient.bottom)) == NULL)
        return 0;

    hGdiObj = SelectObject(m_dcBackBuffer, m_bmBackBuffer);

    if(hGdiObj == NULL || hGdiObj == HGDI_ERROR)
        return 0;

    ReleaseDC(m_hwndMain, dcMainWindow);

    return 1;
} // createBackBuffer()


void GfxDevice::clearBackBuffer(void)
{
    RECT rClient;

    GetClientRect(m_hwndMain, &rClient);
    FillRect(m_dcBackBuffer, &rClient, (HBRUSH)GetStockObject(WHITE_BRUSH));
} // clearBackBuffer()


void GfxDevice::renderImage(void)
{
    HDC dcMainWindow;
    dcMainWindow = GetDC(m_hwndMain);

    HGDIOBJ gdiobj;
    gdiobj = SelectObject(tplayer.hDC(0), tplayer.hBitmap(0));

    TransparentBlt(m_dcBackBuffer, tplayer.xPos(), tplayer.yPos(), tplayer.bmWidth(0), tplayer.bmHeight(0), tplayer.hDC(0), 0, 0, tplayer.bmWidth(0), tplayer.bmHeight(0), RGB(0, 255, 0));
    TransparentBlt(m_dcBackBuffer, tplayer.xPos(), tplayer.yPos(), tplayer.bmWidth(1), tplayer.bmHeight(1), tplayer.hDC(1), 0, 0, tplayer.bmWidth(1), tplayer.bmHeight(1), RGB(0, 255, 0));
} // renderImage()


void GfxDevice::flip(void)
{
    HDC dcRenderTarget;
    RECT rClient;

    GetClientRect(m_hwndMain, &rClient);
    dcRenderTarget = GetDC(m_hwndMain); 

    BitBlt(dcRenderTarget, 0, 0, rClient.right, rClient.bottom, m_dcBackBuffer, 0, 0, SRCCOPY);

    ReleaseDC(m_hwndMain, dcRenderTarget);
} // flip()



    
     // P U B L I C

     

GfxDevice::GfxDevice(HWND hwndMain)
: m_dcBackBuffer(NULL), m_hwndMain(NULL), m_bmBackBuffer(NULL), pi(3.14159265)
{
    m_hwndMain = hwndMain;

    createBackBuffer();
} // Constructor()


GfxDevice::~GfxDevice(void)
{
    delete m_dcBackBuffer;
    m_dcBackBuffer = NULL;

    DeleteObject(m_bmBackBuffer);
    DeleteDC(m_dcBackBuffer);
} // Destructor()



        // m e m b e r _ f u n c t i o n s



bool GfxDevice::loadBitmap(const wchar_t *pFilename, HDC *pDC, HBITMAP *phBitmap, BITMAPINFO *pbmInfo)
{
    HDC                 dcMainWindow;
    HANDLE              hFile;
    unsigned long       ulBitmapSize    = 0;
    BITMAPFILEHEADER    bmFile;
    unsigned long       ulBytesRead     = 0;
    char                *pBitmapData    = NULL;

        // open file

    if(((hFile = CreateFileW(pFilename, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL))) == INVALID_HANDLE_VALUE)
    {
        return false;
    }

    if((!ReadFile(hFile, &bmFile, sizeof(BITMAPFILEHEADER), &ulBytesRead, NULL)) || 
        (ulBytesRead != sizeof(BITMAPFILEHEADER)))
    {
        CloseHandle(hFile);
        return false;
    }

    if(!ReadFile(hFile, &pbmInfo->bmiHeader, sizeof(BITMAPINFOHEADER), &ulBytesRead, NULL) ||  
        ulBytesRead                         != sizeof(BITMAPINFOHEADER) || 
        pbmInfo->bmiHeader.biCompression    != BI_RGB ||  
        pbmInfo->bmiHeader.biBitCount       != 24)
    {
        CloseHandle(hFile);
        return false;
    }

    SetFilePointer(hFile, bmFile.bfOffBits, NULL, FILE_BEGIN);

        // size of bitmap

    ulBitmapSize = ((pbmInfo->bmiHeader.biWidth + 3) / 4) * 4;
    ulBitmapSize = (ulBitmapSize * (pbmInfo->bmiHeader.biHeight * pbmInfo->bmiHeader.biBitCount)) / 8;

    pBitmapData = new char[ulBitmapSize];

    if(!ReadFile(hFile, pBitmapData, ulBitmapSize, &ulBytesRead, NULL))
    {
        CloseHandle(hFile);
        delete pBitmapData;
        return false;
    }

    dcMainWindow    = GetDC(m_hwndMain);
    *pDC            = CreateCompatibleDC(dcMainWindow);
    *phBitmap       = CreateCompatibleBitmap(dcMainWindow, pbmInfo->bmiHeader.biWidth, pbmInfo->bmiHeader.biHeight);

    SetDIBits(*pDC, *phBitmap, 0, pbmInfo->bmiHeader.biHeight, pBitmapData, pbmInfo, DIB_RGB_COLORS);

    HGDIOBJ gdiobj;

    gdiobj = SelectObject(*pDC, *phBitmap);

    if(gdiobj == NULL || gdiobj == HGDI_ERROR)
        return false;

    delete pBitmapData;
    CloseHandle(hFile);
    ReleaseDC(m_hwndMain, dcMainWindow);

    return true;
} // loadBitmap()


void GfxDevice::rotateBitmap (const BITMAPINFO bmInfo, signed int *degree)
{
    POINT   destPt[3];

    //      angle   = degToRad(degree);

    double  cosa    = cos(degToRad(*degree));
    double  sina    = sin(degToRad(*degree));
    int     halfW   = bmInfo.bmiHeader.biWidth / 2;
    int     halfH   = bmInfo.bmiHeader.biHeight / 2;

    destPt[0].x = static_cast<long>( (tplayer.xPos() + halfW) + (-halfW * cosa + halfH * sina) );
    destPt[0].y = static_cast<long>( (tplayer.yPos() + halfH) + (-halfW * sina - halfH * cosa) );

    destPt[1].x = static_cast<long>( (tplayer.xPos() + halfW) + (halfW * cosa + halfH * sina) );
    destPt[1].y = static_cast<long>( (tplayer.yPos() + halfH) + (halfW * sina - halfH * cosa) );

    destPt[2].x = static_cast<long>( (tplayer.xPos() + halfW) + (-halfW * cosa - halfH * sina) );
    destPt[2].y = static_cast<long>( (tplayer.yPos() + halfH) + (-halfW * sina + halfH * cosa) );

    *degree = 0;

    int ret;
    ret = PlgBlt(tplayer.hDC(0), destPt, tplayer.hDC(0), tplayer.xPos(), tplayer.yPos(), bmInfo.bmiHeader.biWidth, bmInfo.bmiHeader.biHeight, NULL, 0, 0);
} // rotateBitmap()


void GfxDevice::renderFrame(void)
{
    clearBackBuffer();
    
    int dir;
    if((dir = tplayer.dDirection()) != 0)
        rotateBitmap(tplayer.BitmapInfo(0), tplayer.pdDirection());

    renderImage();

    flip();
} // renderFrame()

C-/C++-Quelltext

#if !defined (_CPLAYER_HPP_)
#define _CPLAYER_HPP_

#include "Headerpool.hpp"

class Player
{
private:
        // e n u m s

    enum pictures { MAX_PICS = 2, ROTATION = 5 };

        // c o n s t a n t s

    const int VK_A;
    const int VK_D;
    const int STEP_SIZE;

        // s t r u c t s

    struct  _bitmaps
    {
        wchar_t *path;
    };

        // m e m b e r _ v a r i a b l e s

    int             m_dDirection;
    _bitmaps        m_Bitmaps[MAX_PICS];
    HDC             m_dcPlayer[MAX_PICS];
    HBITMAP         m_bmPlayer[MAX_PICS];
    BITMAPINFO      m_bmInfoPlayer[MAX_PICS];
    POINT           m_Position;

    

        // m e m b e r _ f u n c t i o n s


public:
        // m e m b e r _ f u n c t i o n s

                Player  (void);
                ~Player (void);
    void processInput(void);

        // s e t _ f u n c t i o n s

    void dDirection(signed int angle){ m_dDirection += angle; }
    void xPos(signed int step){ m_Position.x += step; }
        void yPos(signed int step){ m_Position.y += step; }

        // g e t _ f u n c t i o n s

    int* pdDirection(void){ return &m_dDirection; }
    int dDirection(void){ return m_dDirection; }
    int xPos(void){ return m_Position.x; }
    int yPos(void){ return m_Position.y; }
    int bmHeight(const int index){ return m_bmInfoPlayer[index].bmiHeader.biHeight; }
    int bmWidth(const int index){ return m_bmInfoPlayer[index].bmiHeader.biWidth; }
    _bitmaps Bitmaps(const int index){ return m_Bitmaps[index]; }
    HDC hDC(const int index){ return m_dcPlayer[index]; }
    HDC* phDC(const int index){ return &m_dcPlayer[index]; }
    HBITMAP hBitmap(const int index){ return m_bmPlayer[index]; }
    HBITMAP* phBitmap(const int index){ return &m_bmPlayer[index]; }
    BITMAPINFO BitmapInfo(const int index){ return m_bmInfoPlayer[index]; } 
    BITMAPINFO* pBitmapInfo(const int index){ return &m_bmInfoPlayer[index]; }
}; // class Player


#endif

#include "CPlayer.hpp"
    
     // P U B L I C 


        // m e m b e r _ f u n c t i o n s 


Player::Player(void)
: VK_A(0x41), VK_D(0x44), STEP_SIZE(1), m_dDirection(0)
{
    m_Bitmaps[0].path = L"Bitmap.bmp";
    m_Bitmaps[1].path = L"Bitmap2.bmp";
} // Constructor()


Player::~Player(void)
{
    int x;
    for (x = 0; x < MAX_PICS; x++)
    {
        DeleteDC(m_dcPlayer[x]);
        DeleteObject(m_bmPlayer[x]);
    }
} // Destructor()


        // m e m b e r _ f u n c t i o n s


void Player::processInput(void)
{
        // moving

    if(GetAsyncKeyState(VK_A))
        xPos(-STEP_SIZE);

    if(GetAsyncKeyState(VK_D))
        xPos(STEP_SIZE);

    if(GetAsyncKeyState(VK_UP))
        yPos(-STEP_SIZE);

    if(GetAsyncKeyState(VK_DOWN))
        yPos(STEP_SIZE);

        // rotating

    if(GetAsyncKeyState(VK_RIGHT))
        dDirection(ROTATION);

    if(GetAsyncKeyState(VK_LEFT))
        dDirection(-ROTATION);

} // processInput()

C-/C++-Quelltext

// headerpool.hpp


#if !defined (_HEADERPOOL_HPP_)
#define _HEADERPOOL_HPP_

#include <windows.h>
#include <cmath>
#include "CPlayer.hpp"
#include "CGfxDevice.hpp"

#endif