JLI Spieleprogrammierung Foren-Übersicht JLI Spieleprogrammierung

 
 FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen 
 medals.php?sid=86feaa25a1cf11f14b5f5c5ae0da2dd8Medaillen   RegistrierenRegistrieren   ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin 

Nocheinaml der Hintergrund

 
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Fragen, Antworten und Kritik
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
Mäscht
JLI'ler



Anmeldedatum: 22.05.2003
Beiträge: 150
Wohnort: Bad Hofgastein\Österreich
Medaillen: Keine

BeitragVerfasst am: 28.05.2003, 07:21    Titel: Nocheinaml der Hintergrund Antworten mit Zitat

Ich habe eh schon mal diese Frage gestellt, aber es ist nichts dabei herausgekommen! Jetzt habe ich entlich den gesamten Code hier:

SpriteAnim.cpp

Code:
#include "deklinationen.h"

HWND CreateMainWindow(HINSTANCE hInstance);

LRESULT CALLBACK WindowFunc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);

BOOL InitDirectDraw(void);

void CleanUpDirectDraw(void);

void Render(void);
void CreateBackground(LPDIRECTDRAWSURFACE7 lpDDBackground);
void DrawBackground(LPDIRECTDRAWSURFACE7 lpDDBackground);

LPDIRECTDRAWSURFACE7 CreateSurfaceFromBitmap(LPCTSTR File, int dWidth, int dHeight);


Sprite Sprite;
Hintergrund Hintergrund;


HWND hWnd = 0;

LPDIRECTDRAW7        lpDD7            = NULL;
LPDIRECTDRAWSURFACE7 lpDDSPrimary      = NULL;
LPDIRECTDRAWSURFACE7 lpDDSBackBuffer   = NULL;
LPDIRECTDRAWSURFACE7 lpDDSurface      = NULL;
LPDIRECTDRAWSURFACE7 lpDDBackground      = NULL;   




int WINAPI WinMain(HINSTANCE hInstance,     
                   HINSTANCE hPrevInstance, 
                   LPSTR lpCmdLine,         
                   int nCmdShow)             
{   
           
    hWnd = CreateMainWindow(hInstance);
   InitDirectDraw();
   
   
   
   
    MSG msg;
 
    while(TRUE)
   {   
        if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
        {
            if(msg.message == WM_QUIT)
            {
                break;
            }
   
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
        else
        {   
        
        }
    }
         
    return 0;
}


HWND CreateMainWindow(HINSTANCE hInstance)
{
    WNDCLASSEX wndClass;                                   // WNDCLASSEX Struktur
 
    wndClass.cbSize        = sizeof(WNDCLASSEX);           // Größe angeben (nie vergessen!)
    wndClass.style         = CS_DBLCLKS | CS_OWNDC |
                             CS_HREDRAW | CS_VREDRAW;      // Standard Stile
    wndClass.lpfnWndProc   = WindowFunc;                   // Die Callback Funktion angeben

    wndClass.cbClsExtra    = 0;                            // Zusätzliche Angaben, wird nicht benötigt
    wndClass.cbWndExtra    = 0;                            // Zusätzliche Angaben, wird nicht benötigt
    wndClass.hInstance     = hInstance;                    // Anwendungsinstanz

    wndClass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); // Schwarzer Pinsel
    wndClass.hCursor       = LoadCursor(NULL, IDC_ARROW);  // Normaler Cursor
    wndClass.lpszMenuName  = NULL;                         // Das Fenster hat kein Menü
    wndClass.lpszClassName = "WindowClass";                // Der Name der Klasse
    wndClass.hIcon         = LoadIcon(NULL, IDI_WINLOGO);  // Windows Logo
    wndClass.hIconSm       = LoadIcon(NULL, IDI_WINLOGO);  // Windows Logo

    RegisterClassEx(&wndClass);

    return CreateWindowEx(NULL,                   // Keine erweiterten Stile nutzen
                          "WindowClass",          // Klassenname
                          "DirectDraw",           // Fenstertitel
                          WS_POPUP |              // Fenster
                          WS_VISIBLE,             // Eigenschaften
                          0, 0,                   // Anfangsposition und
                          SCR_WIDTH, SCR_HEIGHT,  // Größe des Fensters
                          NULL,                   // Handle des Elternfensters
                          NULL,                   // Handle des Menüs
                          hInstance,              // Anwendungsinstanz
                          NULL);                  // wird nicht benötigt
}


   




LRESULT CALLBACK WindowFunc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {   
   
        case WM_KEYDOWN:
         switch(wParam)
         {

            case VK_ESCAPE:                     
                    DestroyWindow(hWnd);
                break;
               
                case VK_LEFT:
                    Sprite.Move(-S_STEP,0);
               Render();
                break;

                case VK_RIGHT:
                    Sprite.Move(S_STEP,0);
               Render();
                break;
   
                case VK_UP:
                    Sprite.Move(0,-S_STEP);
               Render();
                break;

                case VK_DOWN:
                    Sprite.Move(0,S_STEP);
               Render();
                break;

            case VK_F1:
               Render();
            break;

              case VK_SPACE:
               
               for(int a=0;a<20;a++)
               {
                  Sprite.Move(0,-S_JUMP);
                  Render();
               }

               for(int aa=0;aa<20;aa++)
               {
                  Sprite.Move(0,S_JUMP);
                  Render();
               }
               
            break;
            }
        break;

        case WM_DESTROY:
            CleanUpDirectDraw();
         PostQuitMessage(0);
      break;

      case WM_PAINT:
         PAINTSTRUCT ps;
         BeginPaint(hWnd,&ps);
         Render();
         EndPaint(hWnd,&ps);
      break;

    }

    return (DefWindowProc(hwnd, msg, wParam, lParam));
}


int InitDirectDraw(void)
{
    DirectDrawCreateEx(NULL,(void**)&lpDD7,IID_IDirectDraw7,NULL);
    lpDD7->SetCooperativeLevel(hWnd,DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN);
   lpDD7->SetDisplayMode(SCR_WIDTH,SCR_HEIGHT,COLOR_DEPTH,0,0);
   
    DDSURFACEDESC2 ddsd;

    ZeroMemory(&ddsd,sizeof(ddsd));
    ddsd.dwSize = sizeof(ddsd);
    ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
    ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
    ddsd.dwBackBufferCount = 1;

    lpDD7->CreateSurface(&ddsd,&lpDDSPrimary,NULL);
   
   ddsd.ddsCaps.dwCaps = DDSCAPS_BACKBUFFER;

   

    lpDDSPrimary->GetAttachedSurface(&ddsd.ddsCaps,&lpDDSBackBuffer);
   
     
   

    lpDDSurface = CreateSurfaceFromBitmap(S_FILE,S_WIDTH,S_HEIGHT);
   lpDDBackground = CreateSurfaceFromBitmap(BG_FILE,BG_WIDTH,BG_HEIGHT);
   
   
   

   Sprite.Create(lpDDSurface,S_FRAME_X,S_FRAME_Y,0);
   Hintergrund.Create(lpDDBackground);
   
    
    Sprite.Set(100,100);
   Hintergrund.Set(0,0);

    return TRUE;
}


void Render(void)
{
    DDBLTFX BlitFX;
    ZeroMemory(&BlitFX,0);
    BlitFX.dwSize = sizeof(BlitFX);
   BlitFX.dwFillColor = RGB(255,255,255);


    lpDDSBackBuffer->Blt(NULL,NULL,NULL,DDBLT_COLORFILL | DDBLT_WAIT,&BlitFX);
   
   Hintergrund.Draw(lpDDSBackBuffer);
   Sprite.Draw(lpDDSBackBuffer);
   
    lpDDSPrimary->Flip(NULL,DDFLIP_NOVSYNC);
}

LPDIRECTDRAWSURFACE7 CreateSurfaceFromBitmap(LPCTSTR File, int dWidth, int dHeight)
{
    HDC hBmDC,hSurfDC;

    HBITMAP hBM;                   
   
    DDSURFACEDESC2 SurfDesc; 
   
   LPDIRECTDRAWSURFACE7 lpDDSurface;   
   
    hBM = (HBITMAP)LoadImage(NULL,File,IMAGE_BITMAP,dWidth,dHeight,LR_LOADFROMFILE);

    ZeroMemory(&SurfDesc, sizeof(SurfDesc));
   SurfDesc.dwSize = sizeof(SurfDesc);
   
    SurfDesc.dwFlags =   DDSD_CAPS   | DDSD_HEIGHT | DDSD_WIDTH;

    SurfDesc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_VIDEOMEMORY | DDSCAPS_NONLOCALVIDMEM;
   SurfDesc.dwWidth  = dWidth;
   SurfDesc.dwHeight = dHeight;
   
    lpDD7->CreateSurface(&SurfDesc,&lpDDSurface,NULL);

    lpDDSurface->GetDC(&hSurfDC);

    hBmDC = CreateCompatibleDC(hSurfDC);

    SelectObject(hBmDC,hBM);

    BitBlt(hSurfDC,0,0,dWidth,dHeight,hBmDC,0,0,SRCCOPY);

    lpDDSurface->ReleaseDC(hSurfDC);
   
    DeleteDC(hBmDC);
   DeleteObject(hBM);

    return lpDDSurface;
}

void CleanUpDirectDraw(void)
{
   
   Sprite.Release();

    if(NULL != lpDDSPrimary)
    {
        lpDDSPrimary->Release();
        lpDDSPrimary = NULL;
    }

    if(NULL != lpDD7)
    {
        lpDD7->Release();
        lpDD7 = NULL;
    }
}


Hintergrund.cpp

Code:

#include "deklinationen.h"

Hintergrund::Hintergrund(void)
{
   lpDDBackgroundSurface = NULL;
   bg_x = 0;
   bg_y = 0;
}

void Hintergrund::Set(int bgx,int bgy)
{
   bg_x = bgx;
   bg_y = bgy;
}

void Hintergrund::Create(LPDIRECTDRAWSURFACE7 lpDDBackground)

   lpDDBackgroundSurface = lpDDBackground;
   
   DDSURFACEDESC2 BgDesc;
   
   ZeroMemory(&BgDesc,sizeof(BgDesc));
    BgDesc.dwSize = sizeof(BgDesc);
   
   

    lpDDBackgroundSurface->GetSurfaceDesc(&BgDesc);
   
    DDCOLORKEY ColorKey;
    ColorKey.dwColorSpaceLowValue  = BG_COLORKEY;
    ColorKey.dwColorSpaceHighValue = BG_COLORKEY;
   
    lpDDBackgroundSurface->SetColorKey(DDCKEY_SRCBLT,&ColorKey);
}


void Hintergrund::Draw(LPDIRECTDRAWSURFACE7 lpDDBackground)
{

   lpDDBackground->BltFast(bg_x,bg_y,lpDDBackgroundSurface,NULL,DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT);
      
   
}

Hintergrund::~Hintergrund()
{

   if(NULL != lpDDBackgroundSurface)
   {
      lpDDBackgroundSurface->Release();
      lpDDBackgroundSurface = NULL;
   }
}


Hintergrund.h

Code:

#include <ddraw.h>

class Hintergrund
{
   public:
      Hintergrund(void);
      ~Hintergrund();
      void Create(LPDIRECTDRAWSURFACE7 lpDDBackgroundSurface);
      void Draw(LPDIRECTDRAWSURFACE7 lpDDBackground);
      void Set(int bgx,int bgy);
            
   private:
      LPDIRECTDRAWSURFACE7 lpDDBackgroundSurface;
      int bg_x;
      int bg_y;
       
};


Sprite.cpp

Code:

#include "deklinationen.h"

Sprite::Sprite()
{
    lpDDSpriteSurface = NULL;   
    FrameWidth   = 0;
    FrameHeight  = 0;
    FramesX = 0;
    FramesY = 0;
    FrameDelay = 0;
    delay      = 0;
    x = 0;
    y = 0;
    CurrentFrameX = 0;
    CurrentFrameY = 0;
    delay = 0;
}

void Sprite::Create(LPDIRECTDRAWSURFACE7 lpDDSurface,int frmWidth,int frmHeight,int frmDelay)
{

   lpDDSpriteSurface = lpDDSurface;
   FrameWidth  = frmWidth;
    FrameHeight = frmHeight;

    FrameDelay = frmDelay;
   
    DDSURFACEDESC2 SurfaceDesc;
    ZeroMemory(&SurfaceDesc,sizeof(SurfaceDesc));
    SurfaceDesc.dwSize = sizeof(SurfaceDesc);

    lpDDSpriteSurface->GetSurfaceDesc(&SurfaceDesc);
   
    FramesX = SurfaceDesc.dwWidth  / FrameWidth;
    FramesY = SurfaceDesc.dwHeight / FrameHeight;

    DDCOLORKEY ColorKey;
    ColorKey.dwColorSpaceLowValue  = S_COLORKEY;
    ColorKey.dwColorSpaceHighValue = S_COLORKEY;
   
    lpDDSpriteSurface->SetColorKey(DDCKEY_SRCBLT,&ColorKey);

}


void Sprite::Draw(LPDIRECTDRAWSURFACE7 lpDDSurface)
{
   
    RECT SpriteRect;

    SpriteRect.left   = CurrentFrameX * FrameWidth;
    SpriteRect.right  = SpriteRect.left + FrameWidth;
    SpriteRect.top    = CurrentFrameY * FrameHeight;
    SpriteRect.bottom = SpriteRect.top + FrameHeight;
     
    lpDDSurface->BltFast(x,y,lpDDSpriteSurface,&SpriteRect,DDBLTFAST_SRCCOLORKEY | DDBLTFAST_WAIT);
   
    delay++;
    if(delay >= FrameDelay)
    {
        CurrentFrameX++;

        if(CurrentFrameX == FramesX)
        {
            CurrentFrameX = 0;
            CurrentFrameY++;

            if(CurrentFrameY == FramesY)
            {
                CurrentFrameY = 0;
            }
        }
        delay = 0;
    }
}

void Sprite::Set(int SpriteX,int SpriteY)
{
    x = SpriteX;
    y = SpriteY;
}

void Sprite::Move(int SpriteDX,int SpriteDY)
{
    x += SpriteDX;
    y += SpriteDY;
}

void Sprite::Release (void)
{

   if(NULL != lpDDSpriteSurface)
   {
      lpDDSpriteSurface->Release();
      lpDDSpriteSurface=NULL;
   }
}   


Sprite.h

Code:

#include <ddraw.h>

class Sprite
{
    public:
        Sprite();
        void Set(int SpriteX,int SpriteY);
        void Move(int SpriteDX,int SpriteDY);
      void Create(LPDIRECTDRAWSURFACE7 lpDDSpriteSurface,int frmWidth,int frmHeight,int frmDelay);
      void Draw(LPDIRECTDRAWSURFACE7 lpDDSurface);
      void Release(void);

    private:
        LPDIRECTDRAWSURFACE7 lpDDSpriteSurface;
           
        int FrameWidth;
        int FrameHeight;
        int FramesX;
        int FramesY;
        int CurrentFrameX;
        int CurrentFrameY;
        int FrameDelay;
        int delay;
        int x;
        int y;             
};


deklinatione.h

Code:

#include <ddraw.h>
#include "sprite.h"
#include "hintergrund.h"


//--------SPRITE-----/
#define S_FILE "walkexample.bmp"
#define S_COLORKEY RGB(0,0,0)
#define S_WIDTH 612
#define S_HEIGHT 456
#define S_FRAME_X 68
#define S_FRAME_Y 114
#define S_STEP 10
#define S_JUMP 6

//-----BILDSCHIRM---//
#define COLOR_DEPTH 32
#define SCR_WIDTH  800
#define SCR_HEIGHT 600


//-----HINTERGRUND------//
#define BG_FILE "hintergrund.bmp"
#define BG_COLORKEY RGB(0,0,0);
#define BG_WIDTH 800
#define BG_HEIGHT 600


A bissl fü, I was!! Embarassed
_________________
Motz´z mi net o, i bin ofänga!! AEIOU für immer
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Mäscht
JLI'ler



Anmeldedatum: 22.05.2003
Beiträge: 150
Wohnort: Bad Hofgastein\Österreich
Medaillen: Keine

BeitragVerfasst am: 28.05.2003, 07:24    Titel: Antworten mit Zitat

Hoppala! Ich habe vorher die Frage vergessen: Wenn ich 2 Oberflächen erstelle, die 1. mit einem Sprite und die 2. mit einem 800x600 großen hintergrund, bewegt sich der Sprite recht langsam!! Ohne dem Hintergrund bewegt er sich normal!! Bidde helfen!
_________________
Motz´z mi net o, i bin ofänga!! AEIOU für immer
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Hazel
JLI MVP
JLI MVP


Alter: 39
Anmeldedatum: 19.07.2002
Beiträge: 1761

Medaillen: Keine

BeitragVerfasst am: 28.05.2003, 11:31    Titel: Antworten mit Zitat

Du solltest deine Renderfunktion nicht in den Message Handler packen und die WM_PAINT Nachricht kannst du ignorieren, wenn es eine Vollbildanwendung ist.
_________________
*click* Dabuu!?
Twitter: http://twitter.com/Ollie_R
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Mäscht
JLI'ler



Anmeldedatum: 22.05.2003
Beiträge: 150
Wohnort: Bad Hofgastein\Österreich
Medaillen: Keine

BeitragVerfasst am: 02.06.2003, 10:04    Titel: Antworten mit Zitat

Danke für´s zurpückschreiben! Ich habe jetzt schon selber eine lösunggefunden: Ich erstelle eine Primäre Oberfläche und noch eine Andere(zB: lpDDBgSurface), dann erstelle ich den Hintergrund und den Sprite und blitte dann den Hintergrund in die Oberfläche lpDDBgSurface.
Dann blitte ich den Sprite und lpDDBgSurface in den Hintergrundbuffer.
Resultat: Es geht alles ganz normal.
_________________
Motz´z mi net o, i bin ofänga!! AEIOU für immer
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Hazel
JLI MVP
JLI MVP


Alter: 39
Anmeldedatum: 19.07.2002
Beiträge: 1761

Medaillen: Keine

BeitragVerfasst am: 02.06.2003, 10:35    Titel: Antworten mit Zitat

Warum erstellst du nicht einfach ein normalen Backbuffer und benutzt Page Flipping??
_________________
*click* Dabuu!?
Twitter: http://twitter.com/Ollie_R
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
The Lord of Programming
Living Legend


Alter: 37
Anmeldedatum: 14.03.2003
Beiträge: 3122

Medaillen: Keine

BeitragVerfasst am: 02.06.2003, 11:07    Titel: Antworten mit Zitat

Ja genau, das kommt ja ungefähr aufs Gleiche raus; nur dass es warscheinlich einfacher mit Backbuffer ist.
PS: Hab ich doch schon länger vorgeschlagen Rolling Eyes
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console


Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet...
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
Hazel
JLI MVP
JLI MVP


Alter: 39
Anmeldedatum: 19.07.2002
Beiträge: 1761

Medaillen: Keine

BeitragVerfasst am: 02.06.2003, 11:23    Titel: Antworten mit Zitat

Es kommt nicht aufs gleiche drauf raus, sondern es ist schneller.
_________________
*click* Dabuu!?
Twitter: http://twitter.com/Ollie_R
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Mäscht
JLI'ler



Anmeldedatum: 22.05.2003
Beiträge: 150
Wohnort: Bad Hofgastein\Österreich
Medaillen: Keine

BeitragVerfasst am: 04.06.2003, 07:18    Titel: Antworten mit Zitat

Das habe ich eh am Anfang gemacht! Aber dann war der Sprite aus irgendwelchen Gründen zu langsam! Mit meiner Lösung is es aber gegangen!
_________________
Motz´z mi net o, i bin ofänga!! AEIOU für immer
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Hazel
JLI MVP
JLI MVP


Alter: 39
Anmeldedatum: 19.07.2002
Beiträge: 1761

Medaillen: Keine

BeitragVerfasst am: 04.06.2003, 10:08    Titel: Antworten mit Zitat

Dann hast du warscheinlich irgendwelche Surfaces nicht im Grafikspeicher gehabt... normalerweise muss das gehen.
_________________
*click* Dabuu!?
Twitter: http://twitter.com/Ollie_R
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Mäscht
JLI'ler



Anmeldedatum: 22.05.2003
Beiträge: 150
Wohnort: Bad Hofgastein\Österreich
Medaillen: Keine

BeitragVerfasst am: 05.06.2003, 12:08    Titel: Antworten mit Zitat

An das habe ich auch schon gedacht und auch gemacht, aber es ist keine Lösung herausgekommen!
_________________
Motz´z mi net o, i bin ofänga!! AEIOU für immer
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Fragen, Antworten und Kritik Alle Zeiten sind GMT
Seite 1 von 1

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.


Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB.de

Impressum