Hallo,
ich hoffe das ist der richtige Bereich für die folgende Diskussion.
Nach diversen OpenGL Demos (Windows - C++ | Android - Java | Browser - JavaScript) möchte ich nun ein paar Sachen zum Aufbau klären.
In so gut wie jedem Tutorial hat man folgenden Aufbau:
|
Quellcode
|
1
2
3
4
5
6
7
8
9
10
|
RenderWindow window;
GameScene scene;
while(window.isOpen())
{
scene.update();
window.update();
}
window.destroy();
|
Man erstellt ein Fenster und einen OpenGL-Context, anschließend hat man seine "Main-Game-Loop" und aktualisiert alle Komponenten.
Dabei hat z.b. GameScene Child-Elemente in Form eines GameObjects, welches wiederum weitere Children haben kann.
Bei diesem Aufbau erkennt man sofort wie abhängig die Objekte voneinander sind und dass man Operationen wiederholt.
Sagen wir ich habe eine Klasse die z.b. die Kollisionserkennung der GameObjects vornimmt und eine Klasse die die GameObjects rendert.
Meine Kollision-Klasse holt sich GameObject #1 und anschließend GameObject #2,
danach macht die Render-Klasse das Gleiche.
In meinen Augen recht ineffektiv und problematisch bei sehr vielen Objekten(Partikel-System) oder beim Multithreading.
Ich habe mir überlegt dass ich für jede Kernaufgabe ein eigens unabhängiges "System" habe, welches nur seine einfache Arbeit erledigt.
Als Beispiel habe ich einen RenderManager der für sich alleine durch eine Liste läuft und die Objekte zeichnet.
Die Klasse hat keine Ahnung über irgendwas, sie zeichnet nur die Objekte in der Liste.
Ich habe mehrerer solcher Manager die unabhängig voneinander laufen und voneinander auch nichts wissen.
Meine Scene-Klasse enthält die Logik und befüttert die jeweiligen Manager.
Als Beispiel: Ich habe eine Spielfigur die gezeichnet werden soll, dessen Kollision abgefragt werden soll und die brennt.
Die GameScene würde dann ein RenderObject, ein PhysicsObject und ein ParticelObject an die jeweiligen Manager schicken.
Die Frage die sich jetzt stellt lautet: Wie kommunizieren die Manager, wenn sie nur ihre eigene kleine Welt kennen ?
Ich dachte da an ein Observer-System wie aus der Java-Welt.
Ich habe einen EventManager der Listener registrieren kann und Events an diese abfeuern kann.
Beispiel:
|
Quellcode
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
EventManager eventManager;
LogManager logManager(eventManager);
WindowManager windowManager(eventManager);
PhysicsManager physicsManager(eventManager);
RenderManager renderManager(eventManager);
ParticleManager particleManager(eventManager);
AudioManager audioManager(eventManager);
SceneManager sceneManager(eventManager);
eventManager.fire(SceneEvent(SceneEvent.NEW_SCENE, "GameScene"));
while(windowManager.isOpen())
{
eventManager.update();
physicsManager.update();
renderManager.update();
particleManager.update();
}
|
Der Übersicht halber habe ich auch hier eine "Main-Game-Loop", jedoch laufen die Manager unabhängig voneinander und wissen auch nicht welche "Scene" gerade aktiv ist.
Haltet ihr das für einen brauchbaren Aufbau, auch in Hinsicht auf den Observer ?