Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

Mit WinApi Bild geladen und nu is es weg

Werbeanzeige

spacegaier

Alter Hase

  • »spacegaier« ist der Autor dieses Themas

Beiträge: 572

Beruf: Student

  • Private Nachricht senden

1

08.06.2006, 21:26

Mit WinApi Bild geladen und nu is es weg

Hi,

ich bin dabei mit WinApi ein kleines Spiel zu proggen (versuch's zumindest ;) ). Habe nun folgenden Code. Es sollte lediglich ein Bild gezeichnet werden. Tut es aber net. Ging aber schon mal und ich weiß net was ich verfalschändert habe :( . (Bilder sind im Ordner und Msimg32.lib ist gelinkt.)

main.cpp

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

#include <windows.h>
#include "keyboard_dance.hpp"
#include "keyboard_dance_defs.hpp"

//#############################################################################


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

const char szAppName[] = "keyboard_dance 0.2";

//#############################################################################


int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, LPSTR lpCmdLine, int nCmdShow)
{
    HWND       hWnd;
    MSG        msg;
    WNDCLASS   wc;

    wc.style            = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
    wc.lpfnWndProc      = WndProc;
    wc.cbClsExtra       = 0;
    wc.cbWndExtra       = 0;
    wc.hInstance        = hInst;
    wc.hCursor          = LoadCursor(NULL,IDC_ARROW);
    wc.hIcon            = LoadIcon(NULL,IDI_APPLICATION);
    wc.hbrBackground    = (HBRUSH)GetStockObject(WHITE_BRUSH);
    wc.lpszClassName    =  szAppName;
    wc.lpszMenuName     =  NULL;

    RegisterClass(&wc);

    hWnd = CreateWindow(szAppName,szAppName,WS_OVERLAPPEDWINDOW,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,CW_USEDEFAULT,0,0,hInst,0);
    ShowWindow(hWnd, SW_SHOW);
    UpdateWindow(hWnd);

    keyboard_dance_SetMainWnd(hWnd);
    
    if(keyboard_dance_Init(11,11,1) != KEYD_OK)
    {
        keyboard_dance_Shutdown();
        return(0);
    }

    while(true)
    {
        keyboard_dance_ProcessFrame();

        if(PeekMessage(&msg,NULL,0,0,PM_REMOVE) == TRUE)
        {
            if(msg.message == WM_QUIT)
                break;

            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    keyboard_dance_Shutdown();

    return msg.wParam;
}

//##############################################################################


LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
    {
        case WM_DESTROY:
            PostQuitMessage(0);
            return(0);
        
        case WM_KEYDOWN:
        {
            switch (wParam)
            {
                case VK_ESCAPE:
                    PostQuitMessage(0);
                    return(0);
            }
        }


        default:
            return(DefWindowProc(hWnd,message,wParam,lParam));
    }
}


//##############################################################################


keyboard_dance.cpp

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

#include "keyboard_Dance.hpp"
#include "keyboard_dance_defs.hpp"
#include "graphic.hpp"

//##############################################################################


KEYD    KeyD;

//##############################################################################


void keyboard_dance_SetMainWnd(HWND hWndMain)
{
    KeyD.hMainWnd = hWndMain;
}

//##############################################################################


int keyboard_dance_Init(int iXSize, int iYSize, int iPlayers)
{
    RECT    rClient;
    RECT    rWindow;
    int     iRet;
    
    GetClientRect(KeyD.hMainWnd,&rClient);
    GetWindowRect(KeyD.hMainWnd,&rWindow);

    MoveWindow(KeyD.hMainWnd,
                rWindow.left,
                rWindow.top,
                rWindow.right - rWindow.left - rClient.right,
                rWindow.bottom - rWindow.top - rClient.bottom,
                TRUE);

    if((iRet = Graphics_CreateBackBuffer()) != KEYD_OK)
        return(iRet);

    if(Graphics_LoadBitmaps() == FALSE)
        return(iRet);

    return(KEYD_OK);
}

 
//##############################################################################


void keyboard_dance_ProcessFrame()
{
    DWORD   dwRenderTime;

    dwRenderTime = GetTickCount();

    Graphics_RenderFrame();
    
    dwRenderTime = GetTickCount() - dwRenderTime;

    if(dwRenderTime < 33)
        Sleep(33 - dwRenderTime);
}

//##############################################################################


void keyboard_dance_Shutdown()
{

}

//##############################################################################


Graphic.cpp

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

#include <windows.h>
#include "graphic.hpp"
#include "keyboard_dance.hpp"

//#############################################################################


HDC     dcBackBuffer    = NULL;
HBITMAP hBackBufferBmp  = NULL;
HDC     dcPlayerDCs;
HBITMAP hPlayerBitmaps;

//#############################################################################


extern  KEYD        KeyD;

//#############################################################################


int Graphics_CreateBackBuffer()
{
    HDC     dcMainWindow;
    RECT    rClient;
    HGDIOBJ hGdiObj;
    
    GetClientRect(KeyD.hMainWnd,&rClient);

    if((dcMainWindow = GetDC(KeyD.hMainWnd)) == NULL)   //Gerätekontext für das Hauptfenster

        return(ERROR_UNABLE_TO_RETRIEVE_DC);

    if((dcBackBuffer = CreateCompatibleDC(dcMainWindow)) == NULL)   //Gerätekontext für den Backbuffer

        return(ERROR_UNABLE_TO_CREATE_COMPATIBLE_DC);
    
    if((hBackBufferBmp = CreateCompatibleBitmap(dcMainWindow,rClient.right,rClient.bottom)) == NULL)    //Bitmap (Speicher für die Bildaten) erstellen

        return(ERROR_UNABLE_TO_CREATE_COMPATIBLE_BITMAP);

    hGdiObj = SelectObject(dcBackBuffer,hBackBufferBmp);    //Bitmap mit Gerätekontext des Backbuffers verknüpfen

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

    ReleaseDC(KeyD.hMainWnd,dcMainWindow);          //Gerätekontext des Hauptfenster wieder freigeben

    
    return(KEYD_OK);
}

//########################################################################


void Graphics_RenderFrame()
{
    Graphics_ClearBackBuffer();                     //Löschen des Backbuffers (mit neutraler Farbe übermalen)


    Render_Image();
    
    Graphics_Flip();                                //Backbufferframe in Vordegrundframe laden

}

//########################################################################


void Graphics_Flip()
{
    HDC     dcRenderTarget;
    RECT    rClient;
    
    GetClientRect(KeyD.hMainWnd,&rClient);          //Clientgröße holen

    dcRenderTarget = GetDC(KeyD.hMainWnd);          //Zielgerätekontext auf Hauptfenster setzen

    
    BitBlt(dcRenderTarget,0,0,rClient.right,rClient.bottom,dcBackBuffer,0,0,SRCCOPY);   //Backbufferframe in Vordegrundframe kopieren


    ReleaseDC(KeyD.hMainWnd,dcRenderTarget);        //Gerätekontext des Hauptfensters wieder freigeben

}

//########################################################################


void Graphics_ClearBackBuffer()
{
    RECT rClient;

    GetClientRect(KeyD.hMainWnd,&rClient);          //Clientgröße holen

    FillRect(dcBackBuffer,&rClient,(HBRUSH)GetStockObject(WHITE_BRUSH));    //Clientbereich mit weißer Farbe übermalen

}

//########################################################################


BOOL Graphics_LoadBitmap(char *pFilename, HDC *pDC, HBITMAP *phBitmap)
{
    HDC                 dcMainWindow;
    HANDLE              hFile;
    DWORD               dwBitmapSize;
    BITMAPINFO          bmInfo;
    BITMAPFILEHEADER    bmFile;
    DWORD               dwBytesRead;
    char                *pBitmapData;

    if((hFile = CreateFile(pFilename,GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL)) == INVALID_HANDLE_VALUE)    //Datei öffnen

        return(FALSE);

    if(!ReadFile(hFile,&bmFile,sizeof(BITMAPFILEHEADER),&dwBytesRead,NULL) ||   //Daten aus Datei auslesen

        dwBytesRead != sizeof(BITMAPFILEHEADER))
    {
        CloseHandle(hFile);
        return(FALSE);
    }

    if(!ReadFile(hFile,&bmInfo.bmiHeader,sizeof(BITMAPINFOHEADER),&dwBytesRead,NULL) ||
        dwBytesRead != sizeof(BITMAPINFOHEADER) ||
        bmInfo.bmiHeader.biCompression != BI_RGB ||
        bmInfo.bmiHeader.biBitCount != 24)
    {
        CloseHandle(hFile);
        return(FALSE);
    }
    
    SetFilePointer(hFile,bmFile.bfOffBits,NULL,FILE_BEGIN);

    dwBitmapSize = ((bmInfo.bmiHeader.biWidth + 3) / 4) * 4;    //Größe des zu reservierenden Speichers berechnen

    dwBitmapSize = (dwBitmapSize * (bmInfo.bmiHeader.biHeight * bmInfo.bmiHeader.biBitCount)) / 8;

    pBitmapData = new char[dwBitmapSize];   //Speicher reservieren


    if(!ReadFile(hFile,pBitmapData,dwBitmapSize,&dwBytesRead,NULL) ||
        dwBytesRead != dwBitmapSize)
    {
        CloseHandle(hFile);
        delete(pBitmapData);
        return(FALSE);
    }

    dcMainWindow = GetDC(KeyD.hMainWnd);    //Gerätekontext des Hauptfensters

    *pDC = CreateCompatibleDC(dcMainWindow);//kopatibler leerer Gerätekontext

    *phBitmap = CreateCompatibleBitmap(dcMainWindow,bmInfo.bmiHeader.biWidth,bmInfo.bmiHeader.biHeight);    //kopatibles Bitmap

    SetDIBits(*pDC,*phBitmap,0,bmInfo.bmiHeader.biHeight,pBitmapData,&bmInfo,DIB_RGB_COLORS);   //Bilddaten in das eben reservierte Bitmap laden 

    SelectObject(*pDC,*phBitmap);

    delete(pBitmapData);                    //Bildaten wieder freigeben

    CloseHandle(hFile);
    ReleaseDC(KeyD.hMainWnd,dcMainWindow);

    return(TRUE);
}

//#########################################################################


BOOL Graphics_LoadBitmaps()
{
    Graphics_LoadBitmap("bild.bmp", &dcPlayerDCs, &hPlayerBitmaps);

    return(TRUE);
}

//##########################################################################


void Graphics_Shutdown()
{
    if(hPlayerBitmaps != 0)
    DeleteObject(hPlayerBitmaps);

    if(dcPlayerDCs != 0)
    DeleteDC(dcPlayerDCs);
}

//#########################################################################################


void Render_Image()
{
    TransparentBlt(dcBackBuffer,0,0,189,189,dcPlayerDCs,0,0,189,189,RGB(255,0,255));
}

//#########################################################################################


keyboard_dance_hpp

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#ifndef KEYBOARD_DANCE_HPP
#define KEYBOARD_DANCE_HPP

//##############################################################################


#include <windows.h>
#include "keyboard_dance_defs.hpp"

//##############################################################################


void keyboard_dance_SetMainWnd(HWND hWndMain);
int  keyboard_dance_Init(int iXSize, int iYSize, int iPlayers);
void keyboard_dance_Shutdown();
void keyboard_dance_ProcessFrame();

//##############################################################################


#endif


Graphic.hpp

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#ifndef GRAPHIC_HPP
#define GRAPHIC_HPP

//##########################################################################


#include "keyboard_dance_defs.hpp"

//##########################################################################


int  Graphics_CreateBackBuffer();
void Graphics_RenderFrame();
void Graphics_Flip();
void Graphics_ClearBackBuffer();
void Render_Image();
BOOL Graphics_LoadBitmap(char *pFilename, HDC *pDC, HBITMAP *phBitmap);
BOOL Graphics_LoadBitmaps();
void Graphics_Shutdown();


//##########################################################################


#endif


keyboard_dance_defs.hpp

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#ifndef KEYBOARD_DANCE_DEFS_HPP
#define KEYBOARD_DANCE_DEFS_HPP

//##############################################################################


#include <windows.h>

//##############################################################################


typedef struct _keyd
{
    HWND    hMainWnd;
}KEYD;

//##############################################################################


#define KEYD_OK                                     0
#define ERROR_UNABLE_TO_RETRIEVE_DC                 4
#define ERROR_UNABLE_TO_CREATE_COMPATIBLE_DC        5
#define ERROR_UNABLE_TO_CREATE_COMPATIBLE_BITMAP    6
#define ERROR_UNABLE_TO_SELECT_BACKBUFFER_BITMAP    7
#define ERROR_UNABLE_TO_DELETE_BACKBUFFER_BITMAP    8
#define ERROR_UNABLE_TO_DELETE_BACKBUFFER_DC        9

//##############################################################################


#endif


Ich weiß es ist verdammt viel Code, aber ich weiß net wo der Fehler sein könnte -> poste lieber mal alles.

Bin für alle Hinweise dankbar :(

Deviloper

Community-Fossil

Beiträge: 2 872

  • Private Nachricht senden

2

08.06.2006, 22:02

Kommt da ne Fehlermeldung oder was? Glaubst doch net wirklich das jemand den gesammten code durchguckt ;)
Devil Entertainment :: Your education is our inspiration
Der Spieleprogrammierer :: Community Magazin
Merlin - A Legend awakes :: You are a dedicated C++ (DirectX) programmer and you have ability to work in a team? Contact us!
Siedler II.5 RttR :: The old settlers-style is comming back!

Also known as (D)Evil

spacegaier

Alter Hase

  • »spacegaier« ist der Autor dieses Themas

Beiträge: 572

Beruf: Student

  • Private Nachricht senden

3

08.06.2006, 22:14

Nee. Er debuggt anstandslos. Es kommt auch ein kleines Fenster (mit minimalem Clientbereich). Mehr net. Wenn man das Fenster maximiert ist es leer.

Der Code war auch net umbedingt zum durchlesen gedacht, sondern um eventuelle Einfälle überprüfen zu können.

Firefly

Alter Hase

Beiträge: 484

Wohnort: Irgendwoundnirgendwo

  • Private Nachricht senden

4

09.06.2006, 13:13

Wie wärs mit LoadImage? Das funzt immer... ;)

David Scherfgen

Administrator

Beiträge: 10 382

Wohnort: Hildesheim

Beruf: Wissenschaftlicher Mitarbeiter

  • Private Nachricht senden

5

09.06.2006, 13:26

Re: Mit WinApi Bild geladen und nu is es weg

Zitat von »"spacegaier"«

C-/C++-Quelltext

 
1
2

    dwBitmapSize = ((bmInfo.bmiHeader.biWidth + 3) / 4) * 4;    //Größe des zu reservierenden Speichers berechnen

    dwBitmapSize = (dwBitmapSize * (bmInfo.bmiHeader.biHeight * bmInfo.bmiHeader.biBitCount)) / 8;

Das sieht ja wohl ziemlich übel aus ...
David Scherfgens Website | Konzentrationstest Polizei

spacegaier

Alter Hase

  • »spacegaier« ist der Autor dieses Themas

Beiträge: 572

Beruf: Student

  • Private Nachricht senden

6

09.06.2006, 14:18

@Firefly: Funtzt auch net. :(

Will nur mal die Funktion testen. Klappt net. Es kommt nur ein Fenster in den angegeben Größen, ist aber nur weiß.
Muss LoadImage vielleicht wo anders hin?

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

#include <windows.h>

//###############################################################


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


const char szAppName[] = "LoadImage - Test";

//###############################################################


int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
                   PSTR szCmdLine, int iCmdShow)
{
    HWND       hWnd;
    MSG        msg;
    WNDCLASS   wc;
    wc.style         =  CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc   =  WndProc;
    wc.cbClsExtra    =  0;
    wc.cbWndExtra    =  0;
    wc.hInstance     =  hInstance;
    wc.hCursor       =  LoadCursor(NULL,IDC_ARROW);
    wc.hIcon         =  LoadIcon(NULL,IDI_APPLICATION);
    wc.hbrBackground =  (HBRUSH)GetStockObject(WHITE_BRUSH);
    wc.lpszClassName =  szAppName;
    wc.lpszMenuName  =  NULL;

    RegisterClass(&wc);

    hWnd = CreateWindow(szAppName,
                        szAppName,
                        WS_OVERLAPPEDWINDOW,
                        250,          /* X-Position auf dem Monitor */
                        150,          /* Y-Position auf dem Monitor */
                        600,          /* Fensterbreite              */
                        500,          /* Fensterhoehe               */
                        NULL,
                        NULL,
                        hInstance,
                        NULL);
    
    LoadImage(hInstance,"bild.bmp",IMAGE_BITMAP,189,189,LR_DEFAULTCOLOR);


    ShowWindow(hWnd, iCmdShow);
    UpdateWindow(hWnd);

    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
    
    return msg.wParam;
}

//###############################################################


LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
        case WM_DESTROY:
        {
            PostQuitMessage(0);
            return 0;
        }
    }
    return DefWindowProc(hWnd, message, wParam, lParam);
}


@David: Weiß nicht was daran so schlecht sein soll, weiß ber auch net was daran gut ist. Ich habe den Code zu großen Teilen aus einem Tutorial von German Game Dev übernommen und ihn versucht nachzuvollziehen.
Wäre dankbar für Aufklärung, warum das so net optimal ist.

spacegaier

spacegaier

Alter Hase

  • »spacegaier« ist der Autor dieses Themas

Beiträge: 572

Beruf: Student

  • Private Nachricht senden

7

10.06.2006, 14:33

Ok, habe meine Fehler nun gefunden. Nutze nun LoadImage (@Firefly: Danke!!!) => Er zeigt mir das Hintergrundbild an. :D

Nun möchte ich eine weiteres zufällig bestimmtes Bild drüber zeichnen. Muss ich dem Programm irgendwie mitteilen welches Bild über welchem liegen soll oder einfach in der passenden Reihenfolge zeichnen?

Momentan sehe ich dieses zweite Bild nämlich nicht (nur das Hintergrundbild).

Hier noch der fragliche Code (graphic.cpp)

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

#include <windows.h>
#include "graphic.hpp"
#include "defs.hpp"
#include "keyboardancer.hpp"

//#############################################################


extern  KEYD    KeyD;
extern  ARROW   Arrow;

//#############################################################


DrawBackground()
{
    HBITMAP hBackground = (HBITMAP)LoadImage(NULL, "background3.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE); 

    HDC hDCBackground = CreateCompatibleDC(0); 
    SelectObject(hDCBackground, hBackground); // hBackground ist der Handle auf deine Bitmap


    RECT rc;
    
    GetClientRect(KeyD.hWnd, &rc); 

    HDC hDChWnd = GetDC(KeyD.hWnd);
    
    BitBlt(hDChWnd,0,0,rc.right,rc.bottom,hDCBackground,0,0,SRCCOPY);
}

//############################################################


DrawArrow()
{
    int i = 0;
    HBITMAP hArrow[4];
    HDC     hDCArrow[4];
    RECT rc;

    hArrow[0] = (HBITMAP)LoadImage(NULL,"pfeil_oben",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);

    hArrow[1] = (HBITMAP)LoadImage(NULL,"pfeil_rechts",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);

    hArrow[2] = (HBITMAP)LoadImage(NULL,"pfeil_unten",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);

    hArrow[3] = (HBITMAP)LoadImage(NULL,"pfeil_links",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);

    hDCArrow[0] = CreateCompatibleDC(0);

    hDCArrow[1] = CreateCompatibleDC(0);

    hDCArrow[2] = CreateCompatibleDC(0);

    hDCArrow[3] = CreateCompatibleDC(0);

    SelectObject(hDCArrow[0], hArrow[0]);

    SelectObject(hDCArrow[1], hArrow[1]);

    SelectObject(hDCArrow[2], hArrow[2]);

    SelectObject(hDCArrow[3], hArrow[3]);

    GetClientRect(KeyD.hWnd, &rc); 

    HDC hDChWnd = GetDC(KeyD.hWnd); 

    BitBlt(hDChWnd,100,100,189,189,hDCArrow[0],0,0,SRCCOPY);
    
    
}
//############################################################


Die erste Funktion zeichnet den Hintergrund (funtzt). Die zweite soll nacher ein zufälliges Bild drüber zeichnen (dort wo momentan nur die eine BitBlt - Funktion ist kommt später eine switch-Anweisung hin, die eine Zufallsvariable auswertet (später mit TransprentBlt).

Diese beiden Funktionen werden dann wiederum in einer RunGame - Funktion aufgerufen (in obiger reihenfolge). Leider sehe ich wie gesagt ur das Hintergrundbild.

Hoffe aus Hinweise

Firefly

Alter Hase

Beiträge: 484

Wohnort: Irgendwoundnirgendwo

  • Private Nachricht senden

8

10.06.2006, 17:27

Na ja, du blittest einfach alles übereinander... ;) ..oder wie hast du das gemeint?
Mehrere Blittings übereinander:

C-/C++-Quelltext

 
1
2
3
4

HDC hDC=GetDC(hWnd);
BitBlt(...)
BitBlt(...)
ReleaseDC(hDC);

DAs wär's!

spacegaier

Alter Hase

  • »spacegaier« ist der Autor dieses Themas

Beiträge: 572

Beruf: Student

  • Private Nachricht senden

9

10.06.2006, 22:25

Ich wollte eigentlich wissen, warum ich diese Blt-Anweisungen nicht in verschiedene Funktionrn aufteilen und diese dann nacheinander anzeigen lassen kann.

Ich habe nun drei Blt-Anweisungen in eine Funktion hintereinander geschrieben. Es werden aber nur zwei von den drei ausgeführt (zumindest sehe ich nur zwei Bilder). Ist an dem Code etwas falsch?

C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

#include <windows.h>
#include "graphic.hpp"
#include "defs.hpp"
#include "keyboardancer.hpp"

//#############################################################


extern  KEYD    KeyD;
extern  ARROW   Arrow;

//#############################################################


DrawBackground()
{
    RECT rc;
    
    HBITMAP hBackground = (HBITMAP)LoadImage(NULL, "background4.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE); 
    HBITMAP hLogo = (HBITMAP)LoadImage(NULL, "logo.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE); 
    HBITMAP hArrow = (HBITMAP)LoadImage(NULL,"pfeil_rechts",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);

    HDC hDCBackground   = CreateCompatibleDC(0);
    HDC hDCLogo         = CreateCompatibleDC(0);
    HDC hDCArrow        = CreateCompatibleDC(0);

    SelectObject(hDCBackground, hBackground);
    SelectObject(hDCLogo, hLogo);
    SelectObject(hDCArrow, hArrow);

    GetClientRect(KeyD.hWnd, &rc); 

    HDC hDChWnd = GetDC(KeyD.hWnd);

    BitBlt(hDChWnd,0,0,rc.right,rc.bottom,hDCBackground,0,0,SRCCOPY);
    TransparentBlt(hDChWnd,0,0,189,189,hDCArrow,0,0,189,189,RGB(254,0,254));
    TransparentBlt(hDChWnd,430,400,152,62,hDCLogo,0,0,610,250,RGB(254,254,254));
    

    ReleaseDC(KeyD.hWnd, hDChWnd);
}

//#############################################################


Gibt es vielleicht eine maximale Anzahl von erlaubten Blt-Anweisungen pro Funktion (kann ich mir eigentlich nicht vorstellen).

Hoffe, dass jemand einen Hinweis hat. Verzweifle bald. :(

spacegaier

Alter Hase

  • »spacegaier« ist der Autor dieses Themas

Beiträge: 572

Beruf: Student

  • Private Nachricht senden

10

12.06.2006, 14:49

Ich bin ein Volltrottel!!!!

Hab meinen Fehler gefunden. Gibt natürlich keine maximale Blt-Anweisungsanzahl.

Diese Zeile

C-/C++-Quelltext

 
1

HBITMAP hArrow = (HBITMAP)LoadImage(NULL,"pfeil_rechts",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
muss

C-/C++-Quelltext

 
1

HBITMAP hArrow = (HBITMAP)LoadImage(NULL,"pfeil_rechts.bmp",IMAGE_BITMAP,0,0,LR_LOADFROMFILE);
heißen. Hab vergessen das Datentypkürzel anzugeben!!! :oops: :oops: :oops:

Asche über kein Haupt oder hackts besser gleich ab !!!

Werbeanzeige