spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

// INCLUDES ///////////////////////////////////////////////

#define WIN32_LEAN_AND_MEAN 
#define INITGUID

#include <windows.h>   

//Eigene Includes:

#include "Engine.h"


HWND main_window_handle = NULL;
HINSTANCE main_instance = NULL;
char buffer[80];


LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nFunsterStil)

{
    HWND hwnd;               
    MSG messages;           
    WNDCLASSEX wincl;       

   
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = WINDOW_CLASS_NAME;
    wincl.lpfnWndProc = WindowProcedure;     
    wincl.style = CS_DBLCLKS;                 
    wincl.cbSize = sizeof (WNDCLASSEX);

   
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 
    wincl.cbClsExtra = 0;                     
    wincl.cbWndExtra = 0;                     
   
    wincl.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);

   
    if (!RegisterClassEx (&wincl))
        return 0;

   
    hwnd = CreateWindowEx (
           0,                   
           WINDOW_CLASS_NAME,         
           WINDOW_CLASS_NAME,       
           WS_POPUP,               
           CW_USEDEFAULT,       
           CW_USEDEFAULT,       
           WINDOW_WIDTH,               
           WINDOW_HEIGHT,                 
           NULL,       
           NULL,               
           hThisInstance,       
           NULL                 
           );

   
    ShowWindow (hwnd, nFunsterStil);
    UpdateWindow(hwnd);
   
   
    main_window_handle = hwnd;
    main_instance      = hThisInstance;
    
    CEngine Engine;
   
    //Spiel starten:

    Engine.InitGame();
   

// Spielschleife:

while(1)
    {
    if (PeekMessage(&messages,NULL,0,0,PM_REMOVE))
        {
       
        if (messages.message == WM_QUIT)
           break;
   
       
        TranslateMessage(&messages);

       
        DispatchMessage(&messages);
        }
   
    //Hier läuft das Spiel ab:

    Engine.MainGame();

    }
   
    //Hier wird das Spiel herrunter gefahren:

    Engine.ShutdownGame();
   

   
    return messages.wParam;
}




LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{

        HDC hdc;
        PAINTSTRUCT ps;
       
       
    switch (message)                 
    {
        case WM_CREATE:
             break;
             
        case WM_PAINT:
             hdc=BeginPaint(hwnd,&ps);
             
             EndPaint(hwnd, &ps);
             break;
               
        case WM_DESTROY:
            PostQuitMessage (0);       
            break;
           
        default:                     
            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}

C-/C++-Quelltext

#ifndef Engine_H
#define Engine_H

//Compilierer Includes:

#include <windows.h>             

//Eigene Includes:

#include "DirectX/ddraw.h"

// DEFINES ////////////////////////////////////////////////


// defines for windows

const char WINDOW_CLASS_NAME[20]="Game";  // class name


const unsigned long WINDOW_WIDTH=800;              // size of window

const unsigned long WINDOW_HEIGHT=600;
const unsigned long SCREEN_WIDTH=800;              // size of screen

const unsigned long SCREEN_HEIGHT=600;
const unsigned long SCREEN_BPP=16;               // bits per pixel


// MACROS /////////////////////////////////////////////////


// these read the keyboard asynchronously

#define KEY_DOWN(vk_code) ((GetAsyncKeyState(vk_code) & 0x8000) ? 1 : 0)
#define KEY_UP(vk_code)   ((GetAsyncKeyState(vk_code) & 0x8000) ? 0 : 1)

// this builds a 16 bit color value in 5.5.5 format (1-bit alpha mode)

#define _RGB16BIT555(r,g,b) ((b & 31) + ((g & 31) << 5) + ((r & 31) << 10))

// this builds a 16 bit color value in 5.6.5 format (green dominate mode)

#define _RGB16BIT565(r,g,b) ((b & 31) + ((g & 63) << 5) + ((r & 31) << 11))

// TYPES //////////////////////////////////////////////////



class CEngine
{
 public:
       
 //Konstruktor/Destruktor:

 CEngine();
 ~CEngine();

 //Spiel starten:

 void InitGame();
 
 //Fenster Stuff:

 void InitWindow();

 //Grafik Stuff:

 void InitDirectDraw();
 void InitPrimarySurface();
 void InitSecondarySurface();

 //Tastatur(Eingaben)Stuff:

 void InitDirectInput();

 //SoundStuff:

 void InitDirectSound();

 //Hauptteil des Spiels:

 void MainGame();


 //Spiel beenden:

 void ShutdownGame();
 
 //Fenster Stuff:

 void ReleaseWindow();
       
 //Grafik Stuff:

 void ReleaseDirectDraw();
 void ReleasePrimarySurface();
 void ReleaseSecondarySurface();

 //Tastatur(Eingaben)Stuff:

 void ReleaseDirectInput();

 //SoundStuff:

 void ReleaseDirectSound();



 private:
       
 //DirectX Stuff:

 LPDIRECTDRAW7        lpdd;  // dd object

 LPDIRECTDRAWSURFACE7 lpddsprimary;  // dd primary surface

 LPDIRECTDRAWSURFACE7 lpddsback;  // dd back surface

 LPDIRECTDRAWPALETTE  lpddpal;  // a pointer to the created dd palette

 DDSURFACEDESC2       ddsd;                 // a direct draw surface description struct

 DDSCAPS2             ddscaps;              // a direct draw surface capabilities struct

 HRESULT              ddrval;               // result back from dd calls

};

#endif //Engine_H

C-/C++-Quelltext

#include "Engine.h"

//Fenster Hanlder:

extern HWND main_window_handle;
extern HINSTANCE main_instance;
extern char buffer[80];

//Konstruktor/Destruktor:

CEngine::CEngine()
{
 lpdd         = NULL;  // dd object

 lpddsprimary = NULL;  // dd primary surface

 lpddsback    = NULL;  // dd back surface

 lpddpal      = NULL;  // a pointer to the created dd palette

}

CEngine::~CEngine()
{
}


//Grafik Stuff:

void CEngine::InitGame()
{
 InitDirectDraw();
 InitPrimarySurface();
 InitSecondarySurface();
 InitDirectSound();
 InitDirectInput();
}

void CEngine::InitDirectDraw()
{
 // this function is where you do all the initialization

 // for your game


 // create object and test for error

 if (DirectDrawCreateEx(NULL, (void **)&lpdd, IID_IDirectDraw7, NULL)!=DD_OK)
 {
  MessageBox(main_window_handle, "Das DirectX Objekt konnte nicht erstellt werden!", "Fehler beim erstellen des DX Objekts", MB_OK);
  PostMessage(main_window_handle, WM_DESTROY,0,0);
 }

 // set cooperation level to windowed mode normal

 if ((lpdd->SetCooperativeLevel(main_window_handle,
     DDSCL_ALLOWMODEX | DDSCL_FULLSCREEN |
     DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT))!=DD_OK)
 {
    MessageBox(main_window_handle, "Die Kooperationsebene konnte nicht gesetzt werden!", "Kooperationsfehler", MB_OK);
    PostMessage(main_window_handle, WM_DESTROY,0,0);
 }

 // set the display mode

 if ((lpdd->SetDisplayMode(SCREEN_WIDTH,SCREEN_HEIGHT,16,0,0))!=DD_OK)
 {
   MessageBox(main_window_handle, "Die Bildschrimgröße konnte nicht angepasst werden!", "Display Fehler", MB_OK);
   PostMessage(main_window_handle, WM_DESTROY,0,0);
 }
}

void CEngine::InitPrimarySurface()
{
 // Create the primary surface

 memset(&ddsd,0,sizeof(ddsd));
 ddsd.dwSize = sizeof(ddsd);

 // set the flags to validate both the capabilities

 // field and the backbuffer count field

 ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;

 // we need to let dd know that we want a complex

 // flippable surface structure, set flags for that

 ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP |
                      DDSCAPS_COMPLEX;

 // set the backbuffer count to 1

 ddsd.dwBackBufferCount = 1;

 if (lpdd->CreateSurface(&ddsd,&lpddsprimary,NULL)!=DD_OK)
 {
  MessageBox(main_window_handle,"Die Primäroberfäche konnte nicht erstellt werden!", "Fehler beim erstellen der Primär Oberfläche",MB_OK);
  PostMessage(main_window_handle, WM_DESTROY,0,0);
 }


 // query for the backbuffer or secondary surface

 // notice the use of ddscaps to indicate what

 // we are requesting

 ddscaps.dwCaps = DDSCAPS_BACKBUFFER;

 // get the surface

 lpddsprimary->GetAttachedSurface(&ddscaps,&lpddsback);
}

void CEngine::InitSecondarySurface()
{
}

//Tastatur(Eingaben)Stuff:

void CEngine::InitDirectInput()
{
}

//SoundStuff:

void CEngine::InitDirectSound()
{
}


//Spielteil:

void CEngine::MainGame()
{
     
  // check of user is trying to exit

 if (KEY_DOWN(VK_ESCAPE) || KEY_DOWN(VK_SPACE))
    {
     MessageBox(main_window_handle, "Spiel wurde unterbrochen!", "Spiel wird beendet!", MB_OK);
     PostMessage(main_window_handle, WM_DESTROY,0,0);
    }
     
 // this is the workhorse of your game it will be called

 // continuously in real-time this is like main() in C

 // all the calls for you game go here!


 USHORT *back_buffer = NULL, // used to draw

        *dest_ptr    = NULL, // used in line by line copy

        *src_ptr     = NULL; // " "


 // erase secondary back buffer

 memset(&ddsd,0,sizeof(ddsd));
 ddsd.dwSize = sizeof(ddsd);

 // lock the secondary surface

 lpddsback->Lock(NULL,&ddsd,
                 DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,NULL);

 // get video pointer to secondary surface

 back_buffer = (USHORT *)ddsd.lpSurface;     

 // clear back buffer out, remember in 16bit mode there are

 // 2 bytes per pixel, so watch out for addressing and multiplying

 // issues in this code


 // linear memory

 if (ddsd.lPitch == SCREEN_WIDTH*2)
     memset(back_buffer,0,SCREEN_WIDTH*SCREEN_HEIGHT*(SCREEN_BPP/8));
 else
    {
    // non-linear memory

   
    // make copy of video pointer

    dest_ptr = back_buffer;

    // clear out memory one line at a time

    for (int y=0; y < SCREEN_HEIGHT; y++)
        {
        // clear next line

        memset(dest_ptr,0,SCREEN_WIDTH*(SCREEN_BPP/8));
       
        // advance pointer to next line

        dest_ptr+=(ddsd.lPitch/2);

        } // end for y


    } // end else


 // perform game logic...

       
 // draw the next frame into the secondary back buffer

 // plot 5000 random pixels

 for (unsigned int index = 0; index < 5000; index++)
     {
     int   x     = rand()%SCREEN_WIDTH;
     int   y     = rand()%SCREEN_HEIGHT;

     UCHAR red   = rand()%256;
     UCHAR green = rand()%256;
     UCHAR blue  = rand()%256;
   
     // back_buffer is a short pointer, BUT lpitch is in bytes

     // so divide by 2, to get number of "pixels" or words

     back_buffer[x+y*(ddsd.lPitch/2)] = _RGB16BIT565(red, green, blue);
     } // end for index


 // unlock secondary buffer

 lpddsback->Unlock(NULL);

 // flip pages

 if(lpddsprimary->Flip(NULL, DDFLIP_WAIT)!=DD_OK)
 {
  MessageBox(main_window_handle,"Es gab einen Fehler beim flippen!", "Flipping Fehler!",MB_OK);
  PostMessage(main_window_handle, WM_DESTROY,0,0);
 }
}




//Spielbeenden:

void CEngine::ShutdownGame()
{
 ReleaseSecondarySurface();
 ReleasePrimarySurface();
 ReleaseDirectDraw();
 ReleaseDirectInput();
 ReleaseDirectSound();
}

//Fenster Stuff:

void CEngine::ReleaseWindow()
{
 main_window_handle=NULL;
 main_instance=NULL;
}

//Grafik Stuff:

void CEngine::ReleaseDirectDraw()
{
 // this function is where you shutdown your game and

 // release all resources that you allocated


 // release the directdraw object

 if (lpdd!=NULL)
   lpdd->Release();
}

void CEngine::ReleasePrimarySurface()
{
 // first release the primary surface

 if (lpddsprimary!=NULL)
     lpddsprimary->Release();
}

void CEngine::ReleaseSecondarySurface()
{
 // first release the secondary surface

 if(lpddsback!=NULL)
    lpddsback->Release();
}

//Tastatur(Eingaben)Stuff:

void CEngine::ReleaseDirectInput()
{
}

//SoundStuff:

void CEngine::ReleaseDirectSound()
{
}