Tutorial: DirectX - DirectInput 7

1. Einleitung

Vielleicht stellten Sie sich auch schon einmal die Frage, wozu man sich die Mühe machen sollte, DirectInput zu lernen, wo man doch über einfache Windows API Funktionen ganz leicht und schnell Zugriff auf Joystick, Tastatur, Maus, etc. bekommt. Nun, die Antwort ist eigentlich ganz einfach: DirectInput bietet (wie alle DirectX Module) direkten Zugriff auf die Hardware, was für uns letztendlich eine bessere Performance bedeutet. Außerdem wurde DirectInput so konzipiert, dass auch Geräte die irgendwann in der Zukunft einmal auf den Markt kommen werden und neue Möglichkeiten bieten unterstützt werden. Wir werden uns in diesem Tutorial den Schwerpunkt "Joystick/Maus/Tastatur" setzen und werden darauf verzichten, eigene Datenmodelle zur Kommunikation mit den Geräten zu erstellen, da das für den Anfang etwas kompliziert wäre.

2. Mausabfrage

2.1 Grundlagen

Beginnen wollen wir mit der Maussteuerung. Dazu benötiegen wir ein DirectX und ein DirectInput Objekt, sowie ein Objekt für das Gerät. Erst wenn wir dieses Device-Object initialisiert haben können wir die Verbindung zur Maus herstellen und mit dem Abfragen der Daten beginnen. Also als erstes unsere Objekte:

Dim DirectX AsDirectX7
Dim DInput As DirectInput
Dim DInputDevice As DirectInputDevice

Jetzt können wir das DirectInput Objekt über das DirectX Objekt erstellen.

Set DirectX = New DirectX7
Set DInput = DirectX.DirectInputCreate()

Wenn das erledigt ist können wir das Device-Objekt initialisieren und erstellen. Wir müssen DirectInput mitteilen, dass wir mit der Systemmaus arbeiten möchten und dass ein Standart-Datenformat zur Kommunikation verwendet werden soll. Wie schon erwähnt unterstützt DirectInput das Erstellen von eigenen Datenformaten, damit auch Geräte, die in Zukunft auf den Markt kommen verwendet werden können. Zusätzlich bietet es jedoch einige Standartdatenformate, wie z.B. für Maus, Tastatur und Joystick. Und dieses wollen wir auch verwenden.

SetDInputDevice = DInput.CreateDevice("GUID_SysMouse")
DInputDevice.SetCommonDataFormat DIFORMAT_MOUSE

Natürlich benötigen wir wieder die Zugriffsnummer eines Fensters. In unserem Beispiel geben wir die beiden Parameter DISCL_BACKGROUND und DISCL_NONEXCLUSIVE an. In Kapitel 5 "Der CooperativeLevel" finden Sie eine Auflistung aller Möglichkeiten, was sie bewirken und wann sie verwendet werden sollten. Das war auch schon alles, was wir für ein einfaches Beispiel benötigen. Wir müssen jetzt, wo wir alles eingestellt haben, nur noch die Verbindung mit dem Gerät herstellen. Dafür verwenden wir die Acquire - Methode des GeräteObjekts.

DInputDevice.Acquire

Sie sehen, diese Methode nimmt nicht einmal Daten entgegen und ist daher sehr leicht zu bedienen. Wir können jetzt Daten vom Gerät abfragen. Dazu nutzen wir zwei Dinge - zum einen die GetDeviceStateMouse Methode und zum anderen den DIMOUSESTATE Variablentyp. Wenn wir die Methode aufrufen und eine Variable dieses Typs übergeben, dann enthält dieser anschließend die aktuellen Werte der Maus (diese enthalten die Zahl, um die sich die Position der Maus seit dem letzten Abfragen verändert hat). Folgendermaßen sieht der Typ aus:

Type DIMOUSESTATE
buttons(0 To 3) As Byte
x As Integer
y As Integer
z As Integer
End Type

x, y und z wird wohl keiner Erklärung bedürfen. Das sind einfach die Werte der Achsen (Im Kapitel 2.2 erfahren Sie, wie Sie alle Achsen und Knöpfe der Maus auslesen können). buttons gibt die Knöpfe der Maus in einem Array wieder. Sobald ein Wert dieses Arrays ungleich 0 ist, ist der Knopf gedrückt. So! Das war eigentlich schon das Wichtigste zur Maussteuerung! Wenn Sie möchten, können Sie jetzt ein Beispielprojekt (Beispiel 1) downloaden, was das oben gelernte noch mal veranschaulicht.

2.2 Achsen und Knöpfe der Maus auslesen

Manchmal ist es notwendig zu wissen, wie viele Achsen und Tasten eine Maus hat damit man diese mit besonderen Funktionen belegen kann (vor allem bei Spielen). Mit dem obigen Beispielprojekt haben Sie ja bereits gelernt, wie man die Daten von Achsen und Knöpfen abfragen kann. Folgende Funktion (eingefügt in die alte Klasse, so dass sie mit den Namen übereinstimmt) gibt einem die Zahl der Achsen zurück:

Function HowManyAxes() As Integer

'Variablen und Objekte initialisieren
Dim objenum As DirectInputEnumDeviceObjects
Dim oneobj As DirectInputDeviceObjectInstance
Dim Acount As Integer

'Standartwert einstellen
Acount = 0

'Achsen der Device abfragen und zählen
Set objenum = DInputDevice.GetDeviceObjectsEnum(DIDFT_AXIS)

   For i = 1 To objenum.GetCount

   Set oneobj = objenum.GetItem(i)

      Select Case oneobj.GetOfs

         Case DIMOFS_X
            Acount = Acount + 1

         Case DIMOFS_Y
            Acount = Acount + 1

         Case DIMOFS_Z
            Acount = Acount + 1

      End Select

   Next

   HowManyAxes = Acount

End Function

Sie können sicherlich erkennen, dass diese Codes ein wenig umständlich geschrieben sind. Man hätte auch gleich objenum.GetCount zurückgeben können. Ich habe jedoch bewusst dieses Verfahren gewählt, weil Sie so den Code leichter modifizieren können um gezielt nach einzelnen Achsen suchen zu können. Ebenfalls der untere Code um die Tasten zu zählen:

Function HowManyButtons() As Integer

'Variablen und Objekte initialisieren
Dim objenum As DirectInputEnumDeviceObjects
Dim oneobj As DirectInputDeviceObjectInstance
Dim Acount As Integer

'Standartwert einstellen
Acount = 0

'Tasten der Device abfragen und zählen
Set objenum = DInputDevice.GetDeviceObjectsEnum(DIDFT_BUTTON)

   For i = 1 To objenum.GetCount

   Set oneobj = objenum.GetItem(i)

      Select Case oneobj.GetOfs

         Case DIMOFS_BUTTON0
            Acount = Acount + 1

         Case DIMOFS_BUTTON1
            Acount = Acount + 1

         Case DIMOFS_BUTTON2
            Acount = Acount + 1

         Case DIMOFS_BUTTON3
            Acount = Acount + 1

      End Select

   Next

   HowManyButtons = Acount

End Function

Sie sehen also, dass diese Codes nicht relativ kompliziert sind. Zunächst wird ein Auflistungsobjekt erstellt, dessen Inhalt bei der Funktion GetDeviceObjectsEnum mit dem Parameter festgelegt wird. Dnn werden die Objekte (in DirectInput gelten alle Tasten, Achsen, etc. als Objekte) einzeln erstellt und Ihre Eigenschaften abgefragt. Wie immer habe ich auch hierzu ein Beispielprojekt (Beispiel 2) erstellt, dass Sie sich gerne downloaden können.

3. Tastaturabfrage

3.1 Datenabfrage

Daten von der Tastatur abzufragen funktioniert eigentlich genauso wie die Datenabfrage von der Maus. Der einzige Unterschied besteht darin, dass Sie keine Achsen haben und ein wesentlich größeres Byte Array, dass natürlich alle Tasten der Tastatur enthält (auch hier gilt: ist der Wert eines Eintrags in diesem Array ungleich 0 dann ist die entsprechende Taste gedrückt. Nachdem wir die globalen Variablen wie bei der Maus deklariert und das DirectX und DirectInput Objekt initialisiert haben müssen wir wieder das Device-Objekt erstellen. Es sieht jetzt ein klein wenig anders aus, weil wir natürlich mit der Tastatur des Systems arbeiten möchten:

Set DInputDevice = DInput.CreateDevice("GUID_SysKeyboard")
DInputDevice.SetCommonDataFormat DIFORMAT_KEYBOARD
DInputDevice.SetCooperativeLevel Form_Val.hWnd, DISCL_NONEXCLUSIVE Or DISCL_BACKGROUND
DInputDevice.Acquire

Wie Sie sehen hat sich in der ersten Zeile der Parameter von GUID_SysMouse zu GUID_SysKeyboard geändert. Des weiteren wird in der zweiten Zeile das Standartdatenformat für Tastaturen verwendet. Die dritte Zeile setzt den Cooperative Level und sagt DirectInput wie immer, wie es mit diesem Gerät umspringen soll (siehe Kapitel 5). In der vierten Zeile stellen wir die Verbindung zur Tastatur her. Dazu nutzen wir wieder die Acquire Methode des Device Objekts. Und wieder sind wir soweit, dass wir die Daten abfragen können. Der Datentyp den wir von der Funktion GetDeviceStateKeyboard füllen lassen heißt diesesmal DIKEYBOARDSTATE. Er sieht wie folgt aus:

Type DIKEYBOARDSTATE
   Key(0 To 255) As Byte
End Type

Wie Sie bereits erwartet haben steht jeder Eintrag in diesem Array für eine Taste. Wenn der Eintrag ungleich 0 ist, dann heißt das, dass die Taste gedrückt ist. Und wieder haben wir ein Beispielprojekt (Beispiel 3).

3.2 Tastenreihenfolge im Byte Array

Ich musste feststellen, dass die Tastencodes nicht mit denen übereinstimmen, die ich von Visual Basic kannte. Auf jeden Fall habe ich Ihnen hier einmal eine Tabelle aufgestellt, die Ihnen zeigen soll, welche Stelle im Byte Array für welche Taste auf der Tastatur steht:

4. Joystickabfrage

4.1 Grundsätzliches

Was wir hier als Joystick bezeichnen muss in Wirklichkeit keiner sein. Es sind einfach alle anderen Geräte außer Maus und Tastatur, also Joysticks, Lenkräder, GamePads, und alles was noch auf den Markt kommen wird. Die Handhabung solcher Geräte ist natürlich wesentlich komplizierter als die einer Maus oder einer Tastatur. Außerdem kommt noch erschwerend dazu, dass an einem System nicht unbedingt ein solches Gerät angeschlossen sein muss, mit einem anderen können dagegen fünf verwendet werden und das ist ein großer Unterschied zu Maus und Tastatur. Denn bei den beiden sind wir bisher immer von den Standartgeräten ausgegangen (und die sind normalerweise an jedem PC angeschlossen :-) Jetzt müssen wir erstmals vor dem initialisieren eines Gerätes prüfen, ob es dieses überhaupt gibt und noch mehr.. wir müssen sogar seine Adresse (eine Nummer in der Registrierung mit der das Gerät in Windows angesprochen werden kann) herausfinden. Erst dann können wir eine Device-Objekt mit dieser Adresse erstellen. Wenn wir dann einmal soweit sind kommt noch ein weiterer Aspekt dazu. Die Achsen eines Joysticks. Die Ausschlagsbreite ist ja bekanntlich von Joystick zu Joystick verschieden also müssen wir diese Werte entsprechend umstellen, damit das Gerät einheitlich funktioniert (man kann kein Programm schreiben, dass auf jeden einzelnen Joystick eingeht - das zur Beruhigung!). Und wir müssen prüfen, wie viele Achsen und Tasten es überhaupt gibt. Aber gut. Fangen wir erst einmal damit an, alle Geräte aufzulisten, die im System angeschlossen sind.

4.2 Installierte Geräte ermitteln

Wie immer benötigen wir ein DirectX und DirectInput Objekt. Des weiteren benötigen wir dieses mal ein Objekt, das die Auflistung aller Geräte aufnimmt. Also deklarieren wir diese zuerst:

Dim DirectX As DirectX7
Dim DInput As DirectInput
Dim DDeviceEnum As DirectInputEnumDevices

Jetzt können wir die Objekte initialisieren. Bei DirectX und DirectInput geschieht dies wie gewohnt. Nur das DDeviceEnum Objekt ist hierbei neu:

Set DirectX = New DirectX7
Set DInput = DirectX.DirectInputCreate()
Set DDeviceEnum = DInput.GetDIEnumDevices(0, DIEDFL_ALLDEVICES) 

Wir erstellen das Auflistungsobjekt über DInput.GetDIEnumDevices. Diese Funktion nimmt zwei Parameter entgegen. Der erste sagt, welche Gerätetypen aufgelistet werden sollen (wir haben hier 0 übergeben, um DInput zu sagen, dass wir alle Eingabegerätetypen wünschen), mit dem zweiten legen wir den Status der Geräte fest. (wir können nur Geräte auflisten lassen, die im Moment angeschlossen sind, oder alle, die registriert sind, etc.). In unserem Beispiel verwenden wir den DIEDFL_ALLDEVICES Parameter. DirectInput listet dadurch wirlich alle Geräte auf, auch solche, die im Moment nicht am PC angeschlossen sind. Wenn Sie nur Geräte aufgelistet bekommen möchten, die im Moment angeschlossen sind, verwenden Sie anstatt unserem, den Parameter DIEDFL_ATTACHEDONLY. Das war auch schon fast alles. Wir können jetzt über unser Objekt alle Geräte abfragen und beispielsweise in eine ListBox eintragen:

For i = 1 To DDeviceEnum.GetCount
   List1.AddItem DDeviceEnum.GetItem(i).GetInstanceName
Next 

Wie immer können Sie sich auch dieses mal ein Beispielprojekt (Beispiel 4) downloaden.

4.3 Informationen über installierte Geräte ermitteln

Im letzten Kapitel (IV.II) hatten wir schon mehr oder weniger eine Datenabfrage. Wir haben den Namen des Gerätes aus der Auflistung abgefragt. Genauso verhält es sich mit allen anderen Daten über das Gerät. Stöbern Sie ruhig mal ein bisschen in der Liste herum, die VB Ihnen anzeigt, wenn Sie nach GetItem(i) den Punkt setzen. Ich möchte in diesem Kapitel zunächst auf eine Eigenschaft eingehen, die wir im Folgenden brauchen werden.. "GetGuidInstance". Wie vorhin schon angesprochen hat jedes Eingabegerät im System eine ID, mit der es eindeutig identifiziert werden kann. Bei Tastatur und Maus waren diese GUID_SysMouse und GUID_SysKeyboard. Bei anderen Geräten wissen wir diese ID nicht und müssen sie über "GetGuidInstance" abfragen. Wir bekommen dann einen String zurück, der zum Beispiel so aussehen könnte:

{6F1D2B70-D5A0-11CF-BFC7-444553540000}

Das ist aber noch nicht alles, was wir über unser Gerät wissen müssen. Wie Sie wissen hat jeder Joystick, jedes Gamepad, etc. eine unterschiedliche Anzahl an Knöpfen und teilweise sogar an Achsen. Deshalb ist es unbedingt notwendig vor der Verwendung eines solchen Gerätes herauszufinden, wie viele Achsen und Tasten es hat (auch bei einer Maus kann dies nützlich sein. Viele Mäuse haben mittlerweile ein Rad - das ist dann die Z-Achse). Um die ID eines Gerätes herauszubekommen mussten wir unsere Codes nicht wesentlich verändern. Dies ändert sich jetzt jedoch. Wir benötigen zwei neue Objekte. Eines, mit dem wir das Gerät wirklich erstellen können und eines, was es uns ermöglicht, eine Objektauflistung für dieses Gerät zu erstellen (Jede Taste, Achse, etc. wird in DirectInput als "Objekt" bezeichnet. Ich meine hier also keine anderen Variablen... etwas verwirrend ;-) Also fügen wir unsere beiden neuen Freunde erst einmal im Deklarationsabschnitt ein:

Dim DDevice As DirectInputDevice
Dim DDeviceObjects As DirectInputEnumDeviceObjects 

Wenn wir jetzt Informationen über ein Gerät erhalten wollen, dann benötigen wir dazu nur noch eines. die Geräte ID. Mit dieser ID erstellen wir dann das Gerät im DDevice Objekt und aus diesem können wir wiederrum in unser DDeviceObjects Objekt eine Aufzählung von verschiedenen Tasten oder Achsen erstellen (Es verhält sich also wie im Kapitel 2.2, als wir die Tasten und Achsen der Maus ausgelesen haben). Die folgenden Codes sind zusätzlich zu den Codes im letzten Beispiel eingefügt (es ist also wieder die ListBox, die eine Auflistung aller Geräte enthält):

Private Sub List1_Click()

'Fehlerkontrolle
If List1.Text = "" Then Exit Sub

'Ein Geräteobjekt mit diesem Objekt erstellen
Set DDevice = DInput.CreateDevice(DDeviceEnum.GetItem(List1.ListIndex + 1).GetGuidInstance)
Label7.Caption = DDeviceEnum.GetItem(List1.ListIndex + 1).GetGuidInstance

'Die Anzahl an Tasten abfragen
Set DDeviceObjects = DDevice.GetDeviceObjectsEnum(DIDFT_BUTTON)
Label3.Caption = DDeviceObjects.GetCount

'Die Anzahl an Achsen abrufen
Set DDeviceObjects = DDevice.GetDeviceObjectsEnum(DIDFT_AXIS)
Label5.Caption = DDeviceObjects.GetCount

End Sub

Das wars auch schon. Wir zeigen die Anzahl der Objekte jeweils in einem Label an und natürlich gibt es auch weider ein passendes Beispielprojekt (Beispiel 5) dazu.

4.4 Daten eines registrierten Joysticks abfragen

Jetzt ist es endlich soweit! Wir haben alle Vorarbeit geleistet und können die Daten abfragen. Wir brauchen zunächst einige Objekte:

Dim DirectX As DirectX7
Dim DInput As DirectInput
Dim DInputDevice As DirectInputDevice
Dim JoyState As DIJOYSTATE

Die ersten drei dürften eigentlich keiner Erklärung bedürfen. Das letzte wird die Daten vom Joystick empfangen. Folgendermaßen sieht der Typ aus:

Type DIJOYSTATE
   buttons(0 To 31)    
   POV(0 To 3) As Long
   rx As Integer
   ry As  Integer
   rz As Integer
   slider(0 To 1) As Long
   x As Integer
   y As Integer
   z As Integer
End Type

Allerdings müssen wir den Joystick erst einmal erneut initialisieren, bevor wir seine Daten abfragen können. Dabei gehe ich natürlich davon aus, dass in JoyAddress die ID des Joysticks (Geräts) vorhanden ist:

Set DInputDevice = DInput.CreateDevice(JoyAddress)
DInputDevice.SetCommonDataFormat DIFORMAT_JOYSTICK
DInputDevice.SetCooperativeLevel Form_Val.hWnd, DISCL_BACKGROUND Or DISCL_NONEXCLUSIVE
DInputDevice.Acquire

'Achsen neu konfigurieren
Dim DiProp_Range As DIPROPRANGE
With DiProp_Range
   .lHow = DIPH_DEVICE
   .lSize = Len(DiProp_Range)
   .lMin = 0
   .lMax = 5000
End With

DInputDevice.SetProperty "DIPROP_RANGE", DiProp_Range

'Deadzone neu konfigurieren
Dim DiProp_Dead As DIPROPLONG
With DiProp_Dead
   .lData = 1000
   .lSize = Len(DiProp_Dead)
   .lHow = DIPH_BYOFFSET
   .lObj = DIJOFS_X
   DInputDevice.SetProperty "DIPROP_DEADZONE", DiProp_Dead
   .lObj = DIJOFS_Y
   DInputDevice.SetProperty "DIPROP_DEADZONE", DiProp_Dead
End With

DInputDevice.Poll

Die ersten vier Zeilen dürften auch dieses mal wieder klar sein. Wir erstellen mit der Adresse ein Geräteobjekt, setzen das Datenformat und legen fest, wie DirectInput mit dem Gerät umgehen soll und rufen anschließend Acquire auf. Jetzt kommen jedoch drei weitere Dinge, die wir unbedingt erledigen müssen. Wie schon gesagt haben alle Joysticks unterschiedliche Achsenbereiche. Da wir als Programmierer nicht auf alle Möglichkeiten eingehen können, müssen wir den Bereich festlegen. Dies geschieht im ersten Teil "Achsen neu konfigurieren". Wir erstellen eine Variable, die alle Daten aufnehmen wird (lmin und lmax sind hier die wichtigen, weil sie letztendlich die Skala festlegen in der sich der Wert der Achsenabfrage bewegen kann) und setzen diese dann. Zum Schluss rufen wir noch die SetProperty Methode unseres Geräteobjekts auf und übergeben ihr die Daten mit dem Parameter, was wir ändern möchten ("DIPROP_RANGE" für Achsenbereich). Als nächstes müssen wir die so genannte Deadzone neu festlegen. Dies ist ein Bereich, in dem der Joystick nicht reagieren soll. Auch hier kommt zunächst eine Variable, die die Werte aufnimmt, und zum Schluss zwei Aufrufe (für beide Achsen einer) von SetProperty. Jetzt ist nur noch die letzte Zeile übrig. Wir müssen sie beim Joystick immer aufrufen, bevor wir Daten abrufen können. Jetzt ist es soweit. Wir fragen die Daten ab:

DInputDevice.Poll
DInputDevice.GetDeviceStateJoystick JoyState

Und nun müssen Sie nur noch die Daten in der Variablen JoyState (siehe auch weiter oben in diesem Kapitel) abrufen und auswerten! Ein Beispiel-Projekt (Beispiel 6) dazu habe ich natürlich wie immer hier zum downloaden gestellt.

5. Der CooperativeLevel

Dieses Kapitel soll Ihnen einen kleinen Überblick über alle Möglichkeiten geben, die Sie beim Festlegen des Cooperative Levels haben.

Aus diesen vier Parametern ergeben sich insgesamt vier Kombinationsmöglichkeiten, weil wir immer einen Parameter von Exclusive/Nonexclusive kombiniert mit einem Parameter Forderground/Background benötigen. In der folgenden Tabelle sehen Sie welche Kombination für welche Geräte geeignet ist:

6. Datenabfrage per DirectX CallBack Ereignis

In allen Beispielen oben haben wir die Datenabfrage über "GetDeviceState..." durchgeführt, wir haben also einen Timer angelegt und dort ständig die Daten abgefragt (bzw. das ganze in die Hauptschleife des Spiels gelegt). Zusätzlich gibt es noch die Möglichkeit ein Ereignis zu erstellen, was immer aufgerufen wird, wenn neue Daten ankommen. Wie Sie die Daten abfragen müssen Sie letztendlich entscheiden (ich tendiere meistens zu der Variante, die hier vorgesetellt wurde, weil ich sowieso in jedem Spiel eine Hauptschleife benutze, die ununterbrochen läuft und dort kann ich diese Abfrage direkt einfügen). Ich möchte jetzt noch kurz erklären, wie Sie ein DirectX_CallBack Ereignis für ein Gerät einrichten.

Zunächst müssen Sie eine zusätzliche Zeile in den Deklarationsabschnitt einfügen und eine weitere Variable deklarieren:

Implements DirectXEvent
Dim EventHandle As Long

Jetzt haben Sie im Codebearbeitungsfenster in der Objektcombo einen weiteren Eintrag: DirectXEvent. Sie müssen diese Sub erstellen, sonst ist ein ausführen nicht möglich, egal, ob sie letztendlich ewas reinschreiben oder nicht. Klicken Sie also den Eintrag in der Liste an, um eine solche Sub mit dem richtigen Namen und den richtigen Parametern automatisch erstellen zu lassen. Als nächstes müssen Sie DirectX sagen, bei was es Sie benachrichtigen soll. Dies geschieht in unserem Fall in zwei Schritten. Als erstes brauchen wir nach dem Initialisieren der Objekte eine Zeile wie folgt:

EventHandle = DirectX.CreateEvent(Me)

Und dann brauchen wir als zweites nach dem Initialisieren des Objekts (bei dessen Datenänderung wir benachrichtigt werden wollen) noch eine Zeile an das DeviceObject:

Call DDevice.SetEventNotification(EventHandle)

Wir können unsere Datenabfrage jetzt wie gewohnt in das Ereignis einfügen dann wird der Codes immer bei einer Datenänderung ausgeführt. Was wir noch beachten müssen, ist, dass wir das Ereignis auch wieder zerstören, sobald wir es nicht mehr brauchen (sprich: wenn die Anwendung beendet wird). Dazu benötigen wir folgende Zeile:

DirectX.DestroyEvent EventHandle

Downloads

» DirectX - DirectInput - Beispiel-Projekt Nr. 1
» DirectX - DirectInput - Beispiel-Projekt Nr. 2
» DirectX - DirectInput - Beispiel-Projekt Nr. 3
» DirectX - DirectInput - Beispiel-Projekt Nr. 4
» DirectX - DirectInput - Beispiel-Projekt Nr. 5
» DirectX - DirectInput - Beispiel-Projekt Nr. 6

» Autor: Thomas Geiger

Aktuelle Seite Back To Top
Druckansicht | Feedback | Favoriten
Copyright © Visual Basic World, 2000-2022 | Kontakt | Impressum