Die DX7 Lib (c)2003 Kai Schmiegelt.
Aktuelle Version 1.0 ( Download
)
Übersicht
-------------
1. Vorwort
2. Benutzung der Lib
3. Initialisierungs-Beispiel
4. Befehlsübersicht
5. Wichtige Hinweise
1. Vorwort
--------------
Die DX7 Lib ist, wie der Name schon sagt, eine Sammlung von
Funktionen um leichter und schneller mit
DirectX 7 arbeiten zu können.
Sie beinhaltet jedoch kein 3D, sondern ist nur für 2D Spiele ausgelegt. Aber es muss ja
nicht immer nur 3D sein.
Nachdem mittlerweile fast jedes MauMau schon in 3D veröffentlicht wird hab ich den
Entschluss gefasst
diese Lib zu veröffentlichen.
Besonders geeignet ist sie für Leute die hin und wieder gerne mal ein Spiel coden, aber
nicht die Zeit finden
DirectX zu lernen, da diese Lib keine DirectX Kenntnisse voraussetzt.
Jedoch sollte der Umgang mit C++ und der WinApi kein Fremdword sein, und auch das Wissen
wie man ein Spiel realisiert
sollten vorhanden sein. Darauf wird dieses kleine Tutorial nicht eingehen.
Dafür bietet die Lib alle wichtigen Funktionen um Grafiken zu laden, zu kopieren, zu
manipulieren und
anzuzeigen. Selbst eine Pixelgenaue Kollisions-Erkennung beinhaltet die Lib, damit dem
Weltraum-Shooter nichts mehr
im Wege steht.
2. Benutzung der Lib
----------------------------
Diese Lib wurde mit dem Visual C++ 6.0 erstellt. Ich nehme mal
starkt an, dass sie auch nur auf diesen
funktionieren wird. Aber ein Test wirds beweisen.
Das Wichtigste was sie brauchen, um die Lib zu verwenden, ist das DirectX-SDK von
Mircosoft (release Version!).
Dieses Packet enthält die Lib-und Header-Dateien für DirectX. Es muss mind. das SDK für
DirectX 7,
oder höher, ebenso DirectX ansich, installiert werden!
Soweit ich in Erinnerung habe passt das Installationsprogramm des SDK die
Pfad-Verzeichnisse im
Visual C++ selbstständig an. Falls nicht können sie diese im Visual C++ wie folgt
einstellen:
( wenn das SDK schon installiert ist können sie den Absatz überspringen )
Nach einen Klick auf Optionen erscheint folgendes Fenster (Klicken sie
auf den Reiter 'Verzeichnisse'):
Die Pfadangaben können natürlich variieren. Achten sie darauf,
dass das Verzeichnis von DirectX
an oberster Stelle steht. Dies können sie einstellen in dem sie den Eintrag markieren und
mittels
den schwarzen Pfeilen, bzw. gedrückter Maustaste, verschieben.
Sollte von DirectX hier nichts zu sehen sein fügen sie den Include-Pfad hier hinzu.
Danach überprüfen die noch den Lib-Pfad von DirectX:
Achten sie auch hier wieder darauf, dass der Lib-Pfad ganz oben in
der Liste steht.
Wenn sie möchten können sie auch die DXLib in ein eigenes Verzeichnis kopieren und dann
in der selben
Methode hier in die Verzeichnissliste eintragen. Das erspart ihnen später das manuelle
Hinzufügen
der Lib in ihr Projekt.
Wenn bis hierher alles Reibungslos geklappt hat kann es los gehen, denn DirectX ist nun in
ihrer
Entwicklungsumgebung verfügbar.
3. Programm-Beispiel
-------------------------------
An dieser Stelle setze ich einfach mal vorraus, dass sie den Visual C++ gestartet und ein
neues Win32 Projekt
erstellt haben. Wenn nicht können sie auch den Beispiel-Code im Source-Verzeichnis
öffnen und das Projekt weiter verfolgen.
Als erstes muss die Lib ins Projekt aufgenommen werden.
Dazu kopieren sie die DXLib Dateien (.h .lib) in ihr Projekt-Verzeichnis.
Danach fügen sie die Dateien dem Projekt hinzu:
Nach der Bestätigung von Dateien erscheint ein Dialogfeld um die
Dateien zu wählen.
Markieren sie die DXClass.lib und DXClass.h und klicken sie auf OK.
Jetzt muss noch Microsoft's ddraw.lib in unser Projekt.
Drücken sie im Visual C++ die Tasten ALT + F7 und es erscheint folgendes Fenster:
Klicken sie auf den Reiter 'Linker' und fügen sie unter
Objekt-/Bibliothek-Module
ddraw.lib hinzu. OK klicken, fertig.
Da wir die Release-Version des DirectX SDK verwenden, Visual C++
aber Standardmässig das Projekt
als Debug erstellt, ändern wir jetzt auch dieses, und zwar unter:
Danach erscheint folgendes Fenster:
Wählen sie die Release-Version und bestätigen sie durch einen
Klick auf OK.
Jetzt können wir uns wieder voll und ganz auf das Programm
konzentrieren.
Fügen sie nun in ihrem Projekt-Code, gaaaaaanz oben folgende Zeile hinzu:
#define INITGUID
danach includen wir den Header der Lib:
#include "DXClass.h"
Wenn wir jetzt mal unsere Sourcen testweise compilieren dürfte kein
Fehler erscheinen,
höchstens die Warnung: Alle Verweise auf "DDRAW.dll" wurden durch
/OPT:REF verworfen
Diese können wir aber ignorieren, da sie später verschwindet.
Nun verschaffen wir und mal Zugriff auf die DXLib. Ich verwende
grundsätzlich einen globalen
Zeiger, werde dies also hier im Beispiel auch tun.
DXClass *g_pGfx = NULL;
In der WinMain verschaffen wir uns dann Zugriff
if( (g_pGfx = new DXClass()) == NULL )
{
MessageBox( hWnd, "DX-Class Instanz Fail!", NULL,
MB_OK );
return 0;
}
Damit ist nun unser Projekt DirectX fähig.
Jetzt ist es an der Zeit sich Gedanken darüber zu machen wie gross der
Screen sein soll.
640x480 , 800x600, 1024x768 ?
Wir nehmen 640x480. Die Farbtiefe ist bei der DXLib grundsätzlich 16 Bit.
Also initialisieren wir kurzer Hand DirectX über die DXLib Funktion 'DD_Init( ... )' :
// DX initialisieren
if( g_pGfx->DD_Init( hWnd, 640, 480, 0 ) == false )
{
MessageBox( hWnd, "DirectX konnte nicht initialisiert
werden", NULL, MB_OK );
return 0;
}
Als Parameter wurde der Fensterhandle und die ScreenX/Y Grösse
übergeben. Der letzte Parameter ist immer 0.
Wenn man das Programm jetzt compiliert und starten würde, wird ihr Monitor evtl. klicken
und den Screen
kurz auf schwarz schalten. Das war dann einmal DirectX und zurück.
Also ist nach dem Initialisieren der Aufruf einer Spiel-Schleife zu empfehlen.
Nun zu dem Konzept wie Grafiken geladen und verwaltet werden.
Ab dieser Stelle werd ich jetzt mal das Wort "lib" vermeiden und auf Class
wechseln, da es sich ja eigentlich
um eine Class handelt, wo der .cpp Teil eben als .lib bei liegt.
Bei jeder Funktion, wo ein Bitmap geladen oder erzeugt wird, liefert die Class einen
Zeiger auf
DX7SURFACE zurück.
Der Aufbau dieser Struktur ist...
typedef struct
{
LPDIRECTDRAWSURFACE7 lpDDSurface;
DDSURFACEDESC2 ddsDesc2;
int iPosX;
int iPosY;
}DX7SURFACE, *PDX7SURFACE;
... und ist in der DXClass.h zu finden.
An den letzten drei Parametern sollte tunlichst nichts gemacht werden, damit habe ich nur
verhindert, dass man
bei jeden Zeichenaufruf auch die Grösse des Bitmaps übergeben muss (da Faulheit
bekanntlich siegt).
Diese sind nämlich später darin abgelegt, ebenso die aktuelle Position.
Wer diese Werte mutwillig verändert soll sich also nicht wundern wenn komische Sachen
passieren.
Um also jetzt ein Bitmap zu laden bedient man sich dieser Struktur.
Beispiel:
PDX7SURFACE pBitmap = NULL;
nun ist pBitmap ein Zeiger auf DX7SURFACE und wurde mit NULL
initialisiert.
Jetzt laden wir mal ein Bitmap: ( die Farbe 255,0,255 (lila) wird als tranzparent
behandelt )
pBitmap = g_pGfx->DD_LoadBitmapFromFile( "bild.bmp",
true );
Ist pBitmap jetzt NULL gab es einen Fehler, ansonsten ist das Bild geladen.
Als Parameter ist der Erste ein Filename des Bildes was geladen werden soll, mit dem
Zweiten entscheiden wir
ob das Bild in den Grafikkartenspeicher geladen werden soll (true) oder in den
Systemspeicher (false).
Wenn true angegeben ist wird die Ladefunktion versuchen auf alle Fälle das Bitmap in den
Grafikkartenspeicher
zu laden. Sollte das nicht klappen wird versucht das Bitmap in dem Systemspeicher
unterzubringen.
Klappt weder das Eine, noch das Andere, oder ist das File nicht auffindbar, liefert die
Funktion einen NULL-Zeiger zurück.
Wenn also NULL geliefert wird sollte man am besten erstmal checken ob das File überhaupt
existiert, bevor man seine
Grafikkarte als Schuldigen dahin stellt. :)
Aber da wir ja optimistisch sind, und jetzt davon ausgehen, dass das Bitmap geladen wurde,
können wir es fix in den
Backbuffer kopieren.
Ist das Bitmap nicht so gross wie der BackBuffer empfieht es sich diesen erstmal zu
leeren:
g_pGfx->DD_ClearBackBuffer( 0, 0, 0 );
Die drei Parameter geben dabei die Farbwerte RGB an. Damit ist der BackBuffer nun schwarz.
Nun wollen wir das Bitmap in den BackBuffer kopieren:
g_pGfx->DD_PutImage( pBitmap, 0, 0 );
Der erste Parameter ist ein Zeiger auf DX7SURFACE, die letzten
Beiden sind die X und Y Koordinaten, wo denn das
Bitmap im BackBuffer überhaupt erscheinen soll. In diesen Falle bei 0, 0 , also oben
links.
Und da wir an dieser Stelle noch immer nix sehen würden schalten wir den BackBuffer in
den Vordergrund:
g_pGfx->DD_PutScreen();
Ergebnis: Bild auf dem Monitor.
Wenn man das Programm beendet ist daran zu denken, dass man die Bitmaps wieder aus dem
Speicher wirft
da das die Class NICHT selbstständig macht. Aber sie besitzt eine Funktion dazu.
Ein Aufruf von
g_pGfx->DD_Delete( pBitmap );
würde das geladene Bitmap incl. der Struktur zunichte machen.
Bei diesen Tutorial gibt es ein Verzeichnis "Source", wo genau das passiert wie
eben alles beschrieben.
Wer es bis hierher verstanden hat, dem steht nichts mehr im Weg ein Spiel zu coden.
Da ich natürlich nicht zu jeder Funktion ein Programmbeispiel machen kann, kommt als
letztes Kapitel eine
Beschreibung aller Funktionen der Class.
4. Befehlsübersicht
--------------------------
Init Funktionen
Lade Funktionen
Ausgabe Funktionen
Create Funktionen
Restore Funktionen
Copy Funktionen
Get Funktionen
Lösch Funktionen
Diverse Funktionen
GDI Funktionen
// Init Funktionen
//
bool DD_Init( HWND hwnd, DWORD dwScreenSizeX, DWORD dwScreenSizeY, DWORD dwReserved );
Initialisiert die DXClass. Ist als erstes aufzurufen.
Erwartet: Handle des Hauptfensters
Screengrösse X Richtung
Screengrösse Y Ruchting
dwReserved immer 0
Liefert: true bei Erfolg, false bei Fehler
--------
// Lade Funktionen
//
PDX7SURFACE DD_LoadBitmapFromFile( char *strFilename, bool bToVideoMemory );
Lädt ein Bitmap von einen Datenträger in den System/Video Speicher
Erwartet: Filename des Bitmaps, das geladen werden soll
true für laden ins Videomem, false für laden in den Systemspeicher
Liefert: Zeiger auf DX7SURFACE-Struktur ( NULL = Fehler )
--------
PDX7SURFACE DD_LoadBitmapFromResource( UINT iResID, bool bToVideoMemory );
Lädt ein Bitmap aus einer Resource in den System/Video Speicher
Erwartet: ResourceID der Resource
true für laden ins Videomem, false für laden in den Systemspeicher
Liefert: Zeiger auf DX7SURFACE-Struktur ( NULL = Fehler )
--------
PDX7SURFACE DD_LoadBitmapFromMemory( BYTE *pData, bool bToVideoMemory );
Lädt ein Bitmap aus dem Hauptspeicher in den System/Video Speicher
Erwartet: Zeiger auf die Bitmapdaten
true für laden ins Videomem, false für laden in den Systemspeicher
Liefert: Zeiger auf DX7SURFACE-Struktur ( NULL = Fehler )
--------
// Ausgabe Funktionen
//
void DD_PutScreen( void );
Bringt den BackBuffer auf den Screen
Erwartet: *-*
Liefert: *-*
--------
void DD_PutImage( PDX7SURFACE pSurfaceStruct, int iScreenPosX, int iScreenPosY );
Kopiert ein Bitmap in den BackBuffer
Erwartet: gültigen Zeiger auf DX7SURFACE
XPosition an der das Bitmap in den BackBuffer kopiert werden soll
YPosition an der das Bitmap in den BackBuffer kopiert werden soll
Liefert: *-*
--------
void DD_PutImageXY( PDX7SURFACE pSurfaceStruct, int iScreenPosX, int iScreenPosY,
int iFromSrcX, int iFromSrcY, int iToSrcX, int iToSrcY );
Kopiert einen Teilausschnitt eines Bitmaps in den BackBuffer
Erwartet: gültigen Zeiger auf DX7SURFACE
X
Position an der das Bitmap in den BackBuffer kopiert werden soll
Y Position an der das Bitmap in den BackBuffer kopiert werden soll
X Position von der im Source-Surface kopiert wird
Y Position von der im Source-Surface kopiert wird
X Position bis zu der im Source-Surface kopiert wird
Y Position bis zu der im im Source-Surface kopiert wird
Liefert: *-*
--------
void DD_SetPixel( PDX7SURFACE pSurfaceStruct, int iPosX, int iPosY,
BYTE byRed, BYTE byGreen, BYTE byBlue );
Setzt einen Pixel in einer Surface in einer betimmten Farbe
Erwartet: gültigen Zeiger auf DX7SURFACE
X Position in der Surface
Y Position in der Surface
Farbwert Rot
Farbwert Grün
Farbwert Blau
Liefert: *-*
--------
void DD_SetPixelBackBuffer( int iPosX, int iPosY, BYTE byRed, BYTE byGreen, BYTE byBlue );
Setzt einen Pixel im BackBuffer in einer betimmten Farbe
Erwartet: X Position vom BackBuffer
Y Position vom BackBuffer
Farbwert Rot
Farbwert Grün
Farbwert Blau
Liefert: *-*
--------
// Create Funktionen
//
PDX7SURFACE DD_CreateSurface( int iSizeX, int iSizeY, bool bToVideoMemory );
Erzeugt eine Surface für ein Bitmap
Erwartet: X-Grösse der zu erzeugenden Surface
Y-Grösse der zu erzeugenden Surface
true für erzeugen im Videomem, false für erzeugen im Systemspeicher
Liefert: Zeiger auf DX7SURFACE-Struktur ( NULL = Fehler )
--------
PDX7SURFACE DD_CreateSurfaceFromSurface( PDX7SURFACE bSrcSurfaceStruct, bool
bToVideoMemory );
Erzeugt eine Surface von einer Anderen in den selben Ausmassen
Erwartet: gültigen Zeiger auf DX7SURFACE (Quelle)
true für erzeugen im Videomem, false für erzeugen im Systemspeicher
Liefert: Zeiger auf DX7SURFACE-Struktur ( NULL = Fehler )
--------
PDX7SURFACE DD_CreateSurfaceFromSurfaceXY( PDX7SURFACE pSrcSurfaceStruct, int
iFromSrcXPos,
int iFromSrcYPos, int iSizeX, int iSizeY, bool
bToVideoMemory );
Erzeugt eine Surface von einen Teilausschnitt einer anderen Surface
Erwartet: gültigen Zeiger auf DX7SURFACE (Quelle)
X Position von der im Source-Surface kopiert wird
Y Position von der im Source-Surface kopiert wird
X Grösse der neuen Surface
Y Grösse der neuen Surface
true für erzeugen im Videomem, false für erzeugen im Systemspeicher
Liefert: Zeiger auf DX7SURFACE-Struktur ( NULL = Fehler )
--------
// Restore Funktionen
//
void DD_Restore( void )
Stellt sämtliche Surfaces wieder her, incl. Backbuffer, da diese zerstört werden wenn
die Anwendung den Focus verliert.
Diese Funktion muss als erstes, nach der Anwendungswiederherstellung, aufgerufen werden.
Erwartet: *-*
Liefert:: *-*
--------
bool DD_RestoreSurfaceFromFile( PDX7SURFACE pSurfaceStruct, char
*strFilename );
Lädt die Grafikdaten neu in ein Surface, wenn dieses durch den Focusverlust der Anwendung
zerstört wurde.
Erwartet: gültugen Zeiger auf eine Surface-Struct
Filename
vom Bitmap File, welches neu geladen werden soll
Liefert: true bei Erfolg, sonst false
--------
bool DD_RestoreSurfaceFromResource( PDX7SURFACE pSurfaceStruct, UINT
iResID );
Lädt die Grafikdaten neu in ein Surface, wenn dieses durch den
Focusverlust der Anwendung zerstört wurde.
Erwartet: gültugen Zeiger auf eine Surface-Struct
Bitmap
ResourceID, welches neu geladen werden soll
Liefert: true bei Erfolg, sonst false
--------
bool DD_RestoreSurfaceFromMemory( PDX7SURFACE pSurfaceStruct, BYTE
*pData );
Lädt die Grafikdaten neu in ein Surface, wenn dieses durch den
Focusverlust der Anwendung zerstört wurde.
Erwartet: gültugen Zeiger auf eine Surface-Struct
Zeiger
auf Bitmap-Daten, welche neu geladen werden sollen
Liefert: true bei Erfolg, sonst false
--------
// Copy Funktionen
//
void DD_CopySurfaceToSurface( PDX7SURFACE pDestSurfaceStruct, PDX7SURFACE
pSrcSurfaceStruct,
bool bColorKey, bool bResizeSource);
Kopiert eine Surface in eine Andere
Erwartet: gültigen Zeiger auf DX7SURFACE (Ziel)
gültigen Zeiger auf DX7SURFACE (Quelle)
true wenn der ColorKey beachtet werden soll (dann lila = tranzparent), ansonsten false
true wenn die Source-Surface an die Grösse der Ziel-Surface angepasst werden soll, sonst
false
Liefert: *-*
--------
void DD_CopySurfaceToSurfaceXY( PDX7SURFACE pDestSurfaceStruct,
PDX7SURFACE pSrcSurfaceStruct,
int iToDestXPos, int iToDestYPos );
Kopiert eine Surface in eine Andere mit Positionsangaben
Erwartet: gültigen Zeiger auf DX7SURFACE (Ziel)
gültigen Zeiger auf DX7SURFACE (Quelle)
X Position in der Ziel-Surface
Y Position in der Ziel-Surface
Liefert: *-*
--------
// Get Funktionen
//
int DD_GetScreenX( void );
Liefert die aktuelle Screengrösse in X-Richtung
Erwartet: *-*
Liefert: Screen X Grösse
--------
int DD_GetScreenY( void );
Liefert die aktuelle Screengrösse in Y-Richtung
Erwartet: *-*
Liefert: Screen Y Grösse
--------
DWORD DD_GetColorKey( void );
Liefert die aktuelle ColorKey Farbe
Erwartet: *-*
Liefert: ColorKey Farbe
--------
DWORD DD_GetColor( BYTE byRed, BYTE byGreen, BYTE byBlue );
Wandelt BYTE Farbwerte in ein DX Format um.
Erwartet: Farbwert Rot
Farbwert Grün
Farbwert Blau
Liefert: Farbwert im DX Format
--------
DWORD DD_GetPixel( PDX7SURFACE pSurfaceStruct, int iPosX, int iPosY );
Liesst einen Pixel aus einer Surface
Erwartet: gültigen Zeiger auf DX7SURFACE
X Position in der Surface
Y Position in der Surface
Liefert: Farbwert im DX Format
--------
DWORD DD_GetPixelBackBuffer( int iPosX, int iPosY );
Liesst einen Pixel aus dem BackBuffer
Erwartet: X Position im BackBuffer
Y Position im BackBuffer
Liefert: Farbwert im DX Format
--------
DWORD DD_GetFreeVideoMem( void );
Liefert den freien Grafikkarten-Speicher
Erwartet: *-*
Liefert: freien Videospeicher
--------
DDCAPS DD_GetDeviceCaps( void )
Liefert die Eigenschaften der verwendeten Grafikkarte.
Erwartet: *-*
Liefert: Grafikkarten-Eigenschaften
--------
LPDIRECTDRAWSURFACE7 DD_GetBackbuffer( void )
Liefert einen Zeiger auf den BackBuffer
Erwartet: *-*
Liefert: BackBuffer Zeiger
--------
// Lösch Funktionen
//
void DD_Delete( PDX7SURFACE pSurfaceStruct );
Löscht eine Bitmap-Surface incl. deren Struktur
Erwartet: gültigen Zeiger auf DX7SURFACE
Liefert: *-*
--------
void DD_ClearSurface( PDX7SURFACE pSurfaceStruct, BYTE byRed, BYTE byGreen, BYTE byBlue );
Reinigt eine Surface mit einer bestimmten Farbe
Erwartet: gültigen Zeiger auf DX7SURFACE
Farbwert Rot
Farbwert Grün
Farbwert Blau
Liefert: *-*
--------
void DD_ClearBackBuffer( BYTE byRed, BYTE byGreen, BYTE byBlue );
Reinigt den BackBuffer mit einer bestimmten Farbe
Erwartet: Farbwert Rot
Farbwert Grün
Farbwert Blau
Liefert: *-*
--------
// Diverse Funktionen
//
void DD_SetGamma( BYTE byRed, BYTE byGreen, BYTE byBlue );
Setzt den Gamma-Wert ( Fade In/Out Effekt )
Erwartet: Farbwert Rot (0-100)
Farbwert Grün (0-100)
Farbwert Blau (0-100)
Liefert: *-*
--------
bool DD_CollisionCheck( PDX7SURFACE pSurfaceStruct1, PDX7SURFACE pSurfaceStruct2 );
Überpüft ob sich zwei Objekte berühren (Pixelgenau)
Erwartet: gültigen Zeiger auf DX7SURFACE von Objekt 1
gültigen Zeiger auf DX7SURFACE von Objekt 2
Liefert: true bei Kollision, sonst false
--------
void DD_MirrorSurface( PDX7SURFACE pSurfaceStruct, bool bHorizontal );
Spiegelt eine Surface
Erwartet: gültigen Zeiger auf DX7SURFACE die zu Spiegeln ist.
true wenn horizontal gespiegelt werden soll, false = vertikal
Liefert: *-*
--------
// GDI Funktionen (langsam aber nützlich)
//
void DD_GDILine( int iFromX, int iFromY, int iToX, int iToY, int iPenStrong, COLORREF
color );
Zeichnet eine Linie mit Hilfe des GDI in den BackBuffer
Erwartet: X Startposition der Linie
Y Startposition der Linie
X Endposition der Linie
Y Endposition der Linie
Zeichenstiftstärke
Farbwert als COLORREF Format
Liefert: *-*
--------
void DD_GDITextOut( char *strText, int iPosX, int iPosY );
Schreibt einen Text an einer bestimmten Stelle in den BackBuffer
Erwartet: den Text der auszugeben ist
X Position im BackBuffer
Y Position im BackBuffer
Liefert: *-*
--------
void DD_GDITextOut( char *strText, int iPosX, int iPosY,
BYTE byForeRed, BYTE byForeGreen, BYTE byForeBlue,
int iTabSpace, bool bTransparent );
Schreibt einen Text an einer bestimmten Stelle in den BackBuffer mit Eigenschaftenangabe
(Von Escape)
Erwartet: den Text der auszugeben ist
X Position im BackBuffer
Y Position im BackBuffer
Farbwert Rot
Farbwert Grün
Farbwert Blau
Zeichenabstand
true wenn Hintergrund tranzparent sein soll, sonst false
Liefert: *-*
5. Wichtige Hinweise
-----------------------------
Um erfolgreich mit der Class arbeiten zu können sollten ein paar
Kleinigkeiten beachtet werden.
Bitmaps sollten nie grösser als der Screenbereich sein.
Ist der Screen auf 640x480 eingestellt, und Du willst ein 800x600 Pixel Bitmap laden, so
wird allerdings
nur 640x480 dargestellt. Die restlichen Pixel wandern ins Nirvana. Warum weiss ich
allerdings nicht.
Zudem bringt sowas die Kollisionserkennung ins schwitzen.
Programmiere bitte Ressourcenschonend. D.h. wenn Du Sprites erstellst, dann nicht so:
sondern besser so:
Auch wenn das Lila später nicht zu sehen ist, ist es trotzdem da.
Jetzt kann ich Dir nur noch viel Spass beim Programmieren wünschen.
Wenn Du mehr wissen möchtest, Fragen hast, oder sonstige Anliegen, dann kannst Du mich
unter
http://www.midiarea.com/email.php
kontaktieren.
Merke: Die DX7 Lib ist umsonst. Deshalb würde ich mich über einen Vermerk in dein
Programm freuen.
PS:
Meine EMail werde ich an dieser Stelle natürlich nicht mehr angeben, da es so
vorpubertäre Pickeldies gibt die nichts besseres zu
tun haben als den ganzen Tag EMails mit ca. 120KB grossen, nervigen, Anhängseln zu
verschicken und auch noch meinen, dass ich
so blöd ware diese zu öffnen. Sucht euch lieber nen Job.
(Das musste einfach mal gesagt werden)