spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

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

#define WIN32_LEAN_AND_MEAN  
#define INITGUID

#include <windows.h>   // include important windows stuff

#include <windowsx.h> 
#include <mmsystem.h>
//#include <iostream.h> // include important C/C++ stuff

#include <conio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <math.h>
#include <io.h>
#include <fcntl.h>  

//Eigene Includes:

#include "Engine.h"

extern CEngine Engine;


HWND main_window_handle = NULL; // save the window handle

HINSTANCE main_instance = NULL; // save the instance

char buffer[80]; 

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

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

{
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = WINDOW_CLASS_NAME;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);

    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default color as the background of the window */
    wincl.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           WINDOW_CLASS_NAME,         /* Classname */
           WINDOW_CLASS_NAME,       /* Title Text */
           WS_POPUP,                /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           WINDOW_WIDTH,                 /* The programs width */
           WINDOW_HEIGHT,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );

    /* Make the window visible on the screen */
    ShowWindow (hwnd, nFunsterStil);
    UpdateWindow(hwnd);
    
    // save the window handle and instance in a global

    main_window_handle = hwnd;
    main_instance      = hThisInstance;
    
    //Spiel starten:

    Engine.InitGame();
    

// enter main event loop

while(1)
    {
    if (PeekMessage(&messages,NULL,0,0,PM_REMOVE))
        { 
        // test if this is a quit

        if (messages.message == WM_QUIT)
           break;
    
        // translate any accelerator keys

        TranslateMessage(&messages);

        // send the message to the window proc

        DispatchMessage(&messages);
        } // end if

    
    // main game processing goes here

    Engine.MainGame();

    } // end while

    
    //Hier wird das Spiel herrunter gefahren:

    Engine.ShutdownGame();
    

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}


/*  This function is called by the Windows function DispatchMessage()  */

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

        HDC hdc;
        PAINTSTRUCT ps;
        
        
    switch (message)                  /* handle the messages */
    {
        case WM_CREATE:
             break;
              
        case WM_PAINT:
             hdc=BeginPaint(hwnd,&ps);
             
             EndPaint(hwnd, &ps);
             break;
                
        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
            
        default:                      /* for messages that we don't deal with */
            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 

#define WINDOW_CLASS_NAME "Game.exe"  // class name


#define WINDOW_WIDTH  800              // size of window

#define WINDOW_HEIGHT 600
#define SCREEN_WIDTH  800              // size of screen

#define SCREEN_HEIGHT 600
#define 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 //////////////////////////////////////////////////


typedef unsigned short USHORT;
typedef unsigned short WORD;
typedef unsigned char  UCHAR;
typedef unsigned char  BYTE;



class CEngine
{
public:
       
//Konstruktor/Destruktor:

CEngine();
~CEngine();

//Spiel starten:

void InitGame();

//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();
        
//Grafik Stuff:

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

//Tastatur(Eingaben)Stuff:

void ReleaseDirectInput();

//SoundStuff:

void ReleaseDirectSound();



private:
protected:
};

#endif //Engine_H

C-/C++-Quelltext

#include "Engine.h"


LPDIRECTDRAW7        lpdd         = NULL;  // dd object

LPDIRECTDRAWSURFACE7 lpddsprimary = NULL;  // dd primary surface

LPDIRECTDRAWSURFACE7 lpddsback    = NULL;  // dd back surface

LPDIRECTDRAWPALETTE  lpddpal      = NULL;  // 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


//Globales Engine Objekt:

CEngine Engine;

//Fenster Hanlder:

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

//Konstruktor/Destruktor:

CEngine::CEngine()
{
}

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

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

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

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


// 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()
{
// 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; // " "


// check of user is trying to exit

if (KEY_DOWN(VK_ESCAPE) || KEY_DOWN(VK_SPACE))
    PostMessage(main_window_handle, WM_DESTROY,0,0);

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

while(lpddsprimary->Flip(NULL, DDFLIP_WAIT)!=DD_OK);

// wait a sec

Sleep(10);

// return success

}




//Grafik Stuff:

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

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()
{
}

C-/C++-Quelltext

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

#define WIN32_LEAN_AND_MEAN  
#define INITGUID

#include <windows.h>   

/*
#include <windowsx.h> 
#include <mmsystem.h>
#include <iostream.h> 
#include <conio.h>
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <string.h>
#include <stdarg.h>
#include <stdio.h>
#include <math.h>
#include <io.h>
#include <fcntl.h>  
*/

//Eigene Includes:

#include "Engine.h"

extern CEngine Engine;


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

/*
typedef unsigned short USHORT;
typedef unsigned short WORD;
typedef unsigned char  UCHAR;
typedef unsigned char  BYTE;
*/


class CEngine
{
 public:
       
 //Konstruktor/Destruktor:

 CEngine();
 ~CEngine();

 //Spiel starten:

 void InitGame();

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

//Globales Engine Objekt:

CEngine Engine;

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

 // 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()
{
 // 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; // " "


 // check of user is trying to exit

 if (KEY_DOWN(VK_ESCAPE) || KEY_DOWN(VK_SPACE))
     PostMessage(main_window_handle, WM_DESTROY,0,0);

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




//Grafik Stuff:

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

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()
{
}

C-/C++-Quelltext

    ::HWND__*
    ::HINSTANCE__* 

    //Und nicht einfach:

   HWND
   HINSTANCE