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!
Werbeanzeige
Quellcode |
|
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 |
/******************************************************************** _________ __ _____ /\___ ___\ /\_\ /\ __\ \/__/\ \__/ _ __\/_/_ \ \ \_\\ ____ _____ __ \ \ \ /\`´__\ /\ \ \ \ __\ /\ __\_ /\ __\ /´__`\ \ \ \ \ \ \/ \ \ \ \ \ \_\\\ \\_\ \\ \____\ /\ __/ \ \_\ \ \_\ \ \_\ \ \____\\ \___\ \ \____\\ \____\ \/_/ \/_/ \/_/ \/____/ \/__/ \/____/ \/____/ tbButtonHandler.h ================= Diese Datei ist Teil der TriBase-Engine. Zweck: Umgang Tasten und Knöpfen Autor: Snorky [20.8.2003] ********************************************************************/ #ifndef __TBBUTTONHANDLER__ #define __TBBUTTONHANDLER__ // Klasse für das Keyboard-Verhalten class TRIBASE_API tbButtonHandler { private: // Variablen BOOL* m_pbButtonsCurrent; // aktueller Knöpfe Status BOOL* m_pbButtonsPast; // alter Knöpfe Status DWORD m_dwNumButtons; // Anzahl der Knöpfe public: // Konstruktor und Destruktor tbButtonHandler(); ~tbButtonHandler(); // Methoden tbResult Exit(); // alles freigeben und zurücksetzen tbResult Init(DWORD dwButtons); // festlegen wieviele Knöpfe es geben soll tbResult GetState(BOOL* pbKeys); // aktualisieren der Buttons BOOL AnyKeyPressed(); // ist irgendeine Taste gedrückt? BOOL AnyKeyGetPressed(); // wird irgendeine Taste gedrückt? BOOL AnyKeyReleased(); // wird irgendeine Taste losgelassen? // Inline-Methoden // ist die Taste gedrückt? BOOL KeyPressed(DWORD dwKey) {return (m_pbButtonsCurrent[dwKey]);} // wird die Taste gerade gedrückt? BOOL KeyGetPressed(DWORD dwKey) {return (!(m_pbButtonsPast[dwKey]) && (m_pbButtonsCurrent[dwKey]));} // wird die Taste gerade losgelassen? BOOL KeyReleased(DWORD dwKey) {return ((m_pbButtonsPast[dwKey]) && !(m_pbButtonsCurrent[dwKey]));} BOOL* GetButtonsCurrent() {return m_pbButtonsCurrent;} BOOL* GetButtonsPast() {return m_pbButtonsPast;} DWORD GetNumButtons() {return m_dwNumButtons;} }; // ****************************************************************** #endif __TBBUTTONHANDLER__ |
Quellcode |
|
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 168 169 170 171 |
/******************************************************************** _________ __ _____ /\___ ___\ /\_\ /\ __\ \/__/\ \__/ _ __\/_/_ \ \ \_\\ ____ _____ __ \ \ \ /\`´__\ /\ \ \ \ __\ /\ __\_ /\ __\ /´__`\ \ \ \ \ \ \/ \ \ \ \ \ \_\\\ \\_\ \\ \____\ /\ __/ \ \_\ \ \_\ \ \_\ \ \____\\ \___\ \ \____\\ \____\ \/_/ \/_/ \/_/ \/____/ \/__/ \/____/ \/____/ tbButtonHandler.cpp =================== Diese Datei ist Teil der TriBase-Engine. Zweck: Umgang Tasten und Knöpfen Autor: Snorky [20.8.2003] ********************************************************************/ #include <TriBase.h> // ****************************************************************** // Konsturktor tbButtonHandler::tbButtonHandler() { // Alles zurücksetzen ZeroMemory(this, sizeof(tbButtonHandler)); } // ****************************************************************** // Destruktor tbButtonHandler::~tbButtonHandler() { Exit(); } // ****************************************************************** // alles freigeben und zurücksetzen tbResult tbButtonHandler::Exit() { // Arrays freigeben TB_SAFE_DELETE_ARRAY(m_pbButtonsCurrent); TB_SAFE_DELETE_ARRAY(m_pbButtonsPast); // Alles zurücksetzen ZeroMemory(this, sizeof(tbButtonHandler)); return TB_OK; } // ****************************************************************** // festlegen wieviele Knöpfe es geben soll tbResult tbButtonHandler::Init(DWORD dwButtons) { // sicherheitshalber alles vorher freigeben Exit(); // Knopfanzahl setzen m_dwNumButtons = dwButtons; // Speicher für Knöpfe belegen m_pbButtonsCurrent = new BOOL [m_dwNumButtons]; if(m_pbButtonsCurrent == NULL) { // Fehler! TB_ERROR_OUT_OF_MEMORY(TB_ERROR); } m_pbButtonsPast = new BOOL [m_dwNumButtons]; if(m_pbButtonsPast == NULL) { // Fehler! TB_ERROR_OUT_OF_MEMORY(TB_ERROR); } // Tasten mit FALSE vorbelegen ZeroMemory((void*)m_pbButtonsCurrent, m_dwNumButtons * sizeof(BOOL)); ZeroMemory((void*)m_pbButtonsPast, m_dwNumButtons * sizeof(BOOL)); return TB_OK; } // ****************************************************************** // aktualisieren der Buttons tbResult tbButtonHandler::GetState(BOOL* pbKeys) { // aktuellen Stand zum alten machen memcpy(m_pbButtonsPast, m_pbButtonsCurrent, m_dwNumButtons*sizeof(BOOL)); // aktuellen Stand durch neuen ersetzen memcpy(m_pbButtonsCurrent, pbKeys, m_dwNumButtons*sizeof(BOOL)); return TB_OK; } // ****************************************************************** // ist irgendeine Taste gedrückt? BOOL tbButtonHandler::AnyKeyPressed() { DWORD dw; // Alle Tastaturtasten durchgehen for(dw = 0; dw <= 107; dw++) { if(m_pbButtonsCurrent[dw]) return TRUE; } // Maustasten auch checken for(dw = 114; dw <= 121; dw++) { if(m_pbButtonsCurrent[dw]) return TRUE; } // nichts gefunden return FALSE; } // ****************************************************************** // wird irgendeine Taste gedrückt? BOOL tbButtonHandler::AnyKeyGetPressed() { DWORD dw; // Alle Tastaturtasten durchgehen for(dw = 0; dw <= 107; dw++) { if(!(m_pbButtonsPast[dw]) && m_pbButtonsCurrent[dw]) return TRUE; } // Maustasten auch checken for(dw = 114; dw <= 121; dw++) { if(!(m_pbButtonsPast[dw]) && m_pbButtonsCurrent[dw]) return TRUE; } // nichts gefunden return FALSE; } // ****************************************************************** // wird irgendeine Taste losgelassen? BOOL tbButtonHandler::AnyKeyReleased() { DWORD dw; // Alle Tastaturtasten durchgehen for(dw = 0; dw <= 107; dw++) { if(m_pbButtonsPast[dw] && !(m_pbButtonsCurrent[dw])) return TRUE; } // Maustasten auch checken for(dw = 114; dw <= 121; dw++) { if(m_pbButtonsPast[dw] && !(m_pbButtonsCurrent[dw])) return TRUE; } // nichts gefunden return FALSE; } // ****************************************************************** |
Quellcode |
|
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 |
// Variablendefinition float* g_pfButtons = NULL; // Analoges Verhalten der Knöpfe BOOL* g_pbButtons = NULL; // Digitales Verhalten der Knöpfe tbButtonHandler* g_pButtons = NULL; // Inputverhalten der Knöpfe // Nach tbDirectInput::Init() // Speicher für die Knöpfe reservieren g_pfButtons = new float[tbDirectInput::GetNumButtons()]; g_pbButtons = new BOOL[tbDirectInput::GetNumButtons()]; g_pButtons = new tbButtonHandler; g_pButtons->Init(tbDirectInput::GetNumButtons()); // In der Move-Methode // Eingabegeräte abfragen tbDirectInput::GetState(g_pfButtons, g_pbButtons); g_pButtons->GetState(g_pbButtons); // Und der eigentlich Sinn des Ganzen // An gegebener Stelle z.B. das Programm beenden, // wenn die ESC-Taste losgelassen wird. Nicht vorher! if(g_pButtons->KeyReleased(TB_KEY_ESCAPE)) PostQuitMessage(0); // Speicher natürlich an der richtigen Stelle wieder freigeben TB_SAFE_DELETE(g_pButtons); TB_SAFE_DELETE_ARRAY(g_pfButtons); TB_SAFE_DELETE_ARRAY(g_pbButtons); |
Administrator
Administrator
Quellcode |
|
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 |
/******************************************************************** _________ __ _____ /\___ ___\ /\_\ /\ __\ \/__/\ \__/ _ __\/_/_ \ \ \_\\ ____ _____ __ \ \ \ /\`´__\ /\ \ \ \ __\ /\ __\_ /\ __\ /´__`\ \ \ \ \ \ \/ \ \ \ \ \ \_\\\ \\_\ \\ \____\ /\ __/ \ \_\ \ \_\ \ \_\ \ \____\\ \___\ \ \____\\ \____\ \/_/ \/_/ \/_/ \/____/ \/__/ \/____/ \/____/ tbButtonHandler.h ================= Diese Datei ist Teil der TriBase-Engine. Zweck: Umgang Tasten und Knöpfen Autor: Snorky [21.8.2003] ********************************************************************/ #ifndef __TBBUTTONHANDLER__ #define __TBBUTTONHANDLER__ // ****************************************************************** // Statusflags für die Rückruffunktionen #define TB_BH_NOTPRESSED (0) #define TB_BH_PRESSED (1) #define TB_BH_GETPRESSED (2) #define TB_BH_RELEASED (4) // ****************************************************************** // Klasse für das Keyboard-Verhalten class TRIBASE_API tbButtonHandler { private: // Variablen BOOL* m_pbButtonsCurrent; // aktueller Knöpfe Status BOOL* m_pbButtonsPast; // alter Knöpfe Status DWORD m_dwNumButtons; // Anzahl der Knöpfe tbResult (**m_pCallback)(DWORD dwKey, DWORD dwFlags); // Array von Rückruffunktionen public: // Konstruktor und Destruktor tbButtonHandler(); ~tbButtonHandler(); // Methoden tbResult Exit(); // alles freigeben und zurücksetzen tbResult Init(DWORD dwButtons); // festlegen wieviele Knöpfe es geben soll tbResult GetState(BOOL* pbKeys); // aktualisieren der Buttons BOOL AnyKeyPressed(); // ist irgendeine Taste gedrückt? BOOL AnyKeyGetPressed(); // wird irgendeine Taste gedrückt? BOOL AnyKeyReleased(); // wird irgendeine Taste losgelassen? tbResult SetCallback(DWORD dwKey, tbResult (*pFunc)(DWORD, DWORD)); // Setzen einer Rückruffunktion tbResult Process(); // Alle Rückruffunktionen ausführen // Inline-Methoden // ist die Taste gedrückt? BOOL KeyPressed(DWORD dwKey) {return (m_pbButtonsCurrent[dwKey]);} // wird die Taste gerade gedrückt? BOOL KeyGetPressed(DWORD dwKey) {return (!(m_pbButtonsPast[dwKey]) && (m_pbButtonsCurrent[dwKey]));} // wird die Taste gerade losgelassen? BOOL KeyReleased(DWORD dwKey) {return ((m_pbButtonsPast[dwKey]) && !(m_pbButtonsCurrent[dwKey]));} BOOL* GetButtonsCurrent() {return m_pbButtonsCurrent;} BOOL* GetButtonsPast() {return m_pbButtonsPast;} DWORD GetNumButtons() {return m_dwNumButtons;} }; // ****************************************************************** #endif __TBBUTTONHANDLER__ |
Quellcode |
|
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 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 |
/******************************************************************** _________ __ _____ /\___ ___\ /\_\ /\ __\ \/__/\ \__/ _ __\/_/_ \ \ \_\\ ____ _____ __ \ \ \ /\`´__\ /\ \ \ \ __\ /\ __\_ /\ __\ /´__`\ \ \ \ \ \ \/ \ \ \ \ \ \_\\\ \\_\ \\ \____\ /\ __/ \ \_\ \ \_\ \ \_\ \ \____\\ \___\ \ \____\\ \____\ \/_/ \/_/ \/_/ \/____/ \/__/ \/____/ \/____/ tbButtonHandler.cpp =================== Diese Datei ist Teil der TriBase-Engine. Zweck: Umgang Tasten und Knöpfen Autor: Snorky [21.8.2003] ********************************************************************/ #include <TriBase.h> // ****************************************************************** // Konsturktor tbButtonHandler::tbButtonHandler() { // Alles zurücksetzen ZeroMemory(this, sizeof(tbButtonHandler)); } // ****************************************************************** // Destruktor tbButtonHandler::~tbButtonHandler() { Exit(); } // ****************************************************************** // alles freigeben und zurücksetzen tbResult tbButtonHandler::Exit() { // Arrays freigeben TB_SAFE_DELETE_ARRAY(m_pbButtonsCurrent); TB_SAFE_DELETE_ARRAY(m_pbButtonsPast); TB_SAFE_DELETE_ARRAY(m_pCallback); // Alles zurücksetzen ZeroMemory(this, sizeof(tbButtonHandler)); return TB_OK; } // ****************************************************************** // festlegen wieviele Knöpfe es geben soll tbResult tbButtonHandler::Init(DWORD dwButtons) { // sicherheitshalber alles vorher freigeben Exit(); // Knopfanzahl setzen m_dwNumButtons = dwButtons; // Speicher für aktuelle Knöpfe belegen m_pbButtonsCurrent = new BOOL [m_dwNumButtons]; if(m_pbButtonsCurrent == NULL) { // Fehler! TB_ERROR_OUT_OF_MEMORY(TB_ERROR); } // Speicher für vergangene Knöpfe belegen m_pbButtonsPast = new BOOL [m_dwNumButtons]; if(m_pbButtonsPast == NULL) { // Fehler! TB_ERROR_OUT_OF_MEMORY(TB_ERROR); } // Speicher für Rückruffunktionen der Knöpfe belegen m_pCallback = new (tbResult (*[m_dwNumButtons])(DWORD, DWORD)); if(m_pCallback == NULL) { // Fehler! TB_ERROR_OUT_OF_MEMORY(TB_ERROR); } // Tasten mit FALSE vorbelegen ZeroMemory((void*)m_pbButtonsCurrent, m_dwNumButtons * sizeof(BOOL)); ZeroMemory((void*)m_pbButtonsPast, m_dwNumButtons * sizeof(BOOL)); ZeroMemory((void*)m_pCallback, m_dwNumButtons * sizeof(tbResult (*)(DWORD, DWORD))); return TB_OK; } // ****************************************************************** // aktualisieren der Buttons tbResult tbButtonHandler::GetState(BOOL* pbKeys) { // aktuellen Stand zum alten machen memcpy(m_pbButtonsPast, m_pbButtonsCurrent, m_dwNumButtons*sizeof(BOOL)); // aktuellen Stand durch neuen ersetzen memcpy(m_pbButtonsCurrent, pbKeys, m_dwNumButtons*sizeof(BOOL)); return TB_OK; } // ****************************************************************** // ist irgendeine Taste gedrückt? BOOL tbButtonHandler::AnyKeyPressed() { DWORD dw; // Alle Tastaturtasten durchgehen for(dw = 0; dw <= 107; dw++) { if(m_pbButtonsCurrent[dw]) return TRUE; } // Maustasten auch checken for(dw = 114; dw <= 121; dw++) { if(m_pbButtonsCurrent[dw]) return TRUE; } // nichts gefunden return FALSE; } // ****************************************************************** // wird irgendeine Taste gedrückt? BOOL tbButtonHandler::AnyKeyGetPressed() { DWORD dw; // Alle Tastaturtasten durchgehen for(dw = 0; dw <= 107; dw++) { if(!(m_pbButtonsPast[dw]) && m_pbButtonsCurrent[dw]) return TRUE; } // Maustasten auch checken for(dw = 114; dw <= 121; dw++) { if(!(m_pbButtonsPast[dw]) && m_pbButtonsCurrent[dw]) return TRUE; } // nichts gefunden return FALSE; } // ****************************************************************** // wird irgendeine Taste losgelassen? BOOL tbButtonHandler::AnyKeyReleased() { DWORD dw; // Alle Tastaturtasten durchgehen for(dw = 0; dw <= 107; dw++) { if(m_pbButtonsPast[dw] && !(m_pbButtonsCurrent[dw])) return TRUE; } // Maustasten auch checken for(dw = 114; dw <= 121; dw++) { if(m_pbButtonsPast[dw] && !(m_pbButtonsCurrent[dw])) return TRUE; } // nichts gefunden return FALSE; } // ****************************************************************** // Setzen einer Rückruffunktion tbResult tbButtonHandler::SetCallback(DWORD dwKey, tbResult (*pFunc)(DWORD, DWORD)) { if(dwKey < 0 || dwKey >= m_dwNumButtons) return TB_ERROR; m_pCallback[dwKey] = pFunc; return TB_OK; } // ****************************************************************** // Alle Rückruffunktionen ausführen tbResult tbButtonHandler::Process() { tbResult r; DWORD dwFlags; // Alle Knöpfe durchgehen for(DWORD dw = 0; dw < m_dwNumButtons; dw++) { // Hat der Knopf eine Rückruffunktion? if(m_pCallback[dw] != NULL) { // Flags setzen dwFlags = TB_BH_NOTPRESSED; if(KeyPressed(dw)) dwFlags |= TB_BH_PRESSED; if(KeyGetPressed(dw)) dwFlags |= TB_BH_GETPRESSED; if(KeyReleased(dw)) dwFlags |= TB_BH_RELEASED; // Rückruffunktion ausführen r = m_pCallback[dw](dw, dwFlags); // Auf Fehler prüfen if(r != TB_OK) TB_ERROR("Fehler bei einer ButtonHandler-Rückruffunktion!",TB_ERROR); } } return TB_OK; } // ****************************************************************** |
Administrator
Werbeanzeige