| ACTION | enum | |
| Animation | ************************************************************************** * \class Animation \brief Zustandklasse fuer eine Animation **************************************************************************** | |
| AnimationManager | ************************************************************************** * \class AnimationManager \brief Container fuer alle Animationen **************************************************************************** | |
| anonymous1 | enum | |
| Camera | ************************************************************************** * \class Camera \brief Repraesentiert die Camera, bzw. das Auge des Spielers das in der Spitze des Frustums sitzt. Konkret wird die Camera in der Map bewegt. Nach einem 'Move' wird die Transformationsmatrix der Camera bezogen zum zum Ursprung berechnet um anschliessend die Weltobjekte in das Frustum zu transformieren. Ausserdem testet die Camera vor jedem Move, ob der Spieler gegen eine Wand gerannt ist: Bei den Kollsisionsabfragen wird aus dem aktuellen Standpunkt und dem naechsten Standpunkt ein Strahl ermittelt. Schneidet dieser Strahl eine Tile, so hat eine Kollision stattgefunden. Die Kamera darf sich dann NICHT zu diesem neuen Standpunkt bewegen (man koennte dann ja durch Waende gehen) Um eine rel. langsame und weiche Bewegung im Raum zu erreichen, ist die Distanz pro Step recht kurz. Daraus folgt, das die Camera sich auch sehr nah an eine WALL annaehern kann, was aber zu Render- bzw. Clippingproblemen fuehrt. Deshalb wird fuer die Collisionsabfrage eine groessere Distanz gefordert. Dazu gibt es hier die m_vecPosColl, m_vecDirColl und m_stepColl. Fuer die Kollision gegen ein PORTAL muss allerdings wieder die normale Schrittweite genommen werden, da sonst ein Portaluebergang zu frueh angezeigt wird, obwohl die Camera sich mit dem naechsten Step noch in der alten Zone befindet. MOVE_FORWARD MOVE_BACKWARD MOVE_STOP MOVE_DOWN MOVE_UP MOVE_STOP STRAFE_LEFT STRAFE_RIGHT STRAFE_STOP ROTATE_LEFT ROTATE_RIGHT ROTATE_STOP **************************************************************************** | |
| Canvas3D | ************************************************************************** * \class Canvas3D \brief Schnittstelle zur Render-Engine. Beinhaltet OS-spezifische Unterscheidungen **************************************************************************** | |
| DataInputStream | ************************************************************************** * \class DataInputStream \brief Wrapperklasse zum lesen von Daten aus einer Binaerdatei. Die Binaerdatei wird aus einer Java-Applikation heraus geschrieben. Daher sind einige Besonderheiten bzgl. der unterschiedlichen Ablage von Variablen zu beachten (Stichwort 'Byteorder' von Integers, Floats und Doubles) **************************************************************************** | |
| DataOutputStream | ************************************************************************** * \class DataOutputStream \brief DataOutputStream **************************************************************************** | |
| Engine | ************************************************************************** * \class Engine \brief Die Hauptklasse der 3D Engine Dieser Klasse beinhaltet ALLE Methoden, die fuer die Nutzung der Engine benoetigt werden. **************************************************************************** | |
| EngineIO | ************************************************************************** * \class EngineIO \brief EngineIO **************************************************************************** | |
| Frustum | ************************************************************************** * \class Frustum \brief Das Frustum ist der Sichtpyramide mit (normalerweise) vier Seiten, an deren Spitze sich das Auge des Betrachters, bzw. die Camera befindet. Die Frustumspitze ist fest verankert in 0,0,0. Wenn also die Camera, bzw. der Spieler den Standort aendert, wird die Welt in das Frustum hineinbewegt. Das ist nicht optimal. Performanter waere es, das Frustum mit der Camera zu bewegen. Auf der anderen Seite vereinfacht es einige Algorithmen, wenn der Ursprung in 0,0,0 sitzt. Bem.: Das Frustum der Camera hat vier Seiten, weil es den Sichtbereich des Betrachters gegen den Bildschirm abgrenzt. Wenn aber der Betrachter durch ein Portal schaut, koennen mehr als vier Frustumseiten existieren, weil das Portalfrustum voher gegen das Frustums des Betrachters geclipped wird. **************************************************************************** | |
| Image | ************************************************************************** * \class Image \brief Generische Klasse fuer Images, Bitmaps *************************************************************************** | |
| IMAGE_TYP | enum | |
| LIFECYCLE | enum | |
| LightManager | ************************************************************************** * \class Light \brief Containerklasse fuer alle Lichtquellen Es gibt folgende Arten von Lichtquellen: - Ambient Light, Umgebungslicht: Die Licht wird von der Umgebung reflektiert und erhellt den Raum ohne das die Quelle ersichtlich ist (z.B. Tageslicht bei bedecktem Himmel). Die Intensitaet bleibt ueber die Entfernung gleich. - Directional Light (direktes Licht): Die Quelle ist unendlich weit entfernt, so dass die Lichtstrahlen quasi parallel zueinander in eine Richtung verlaufen. Dadurch wird zur Beschreibung nur ein einfacher Richtungsvektor benoetigt. Die Intensitaet bleibt ueber die Entfernung gleich. Beispiel: Direkte Sonnenstrahlen. - Point Light (Punktlicht): Die Quelle hat eine Position. Die Lichtstahlen werden kugelfoermig von der Lichtquelle abgestrahlt. Die Intensitaet nimmt quadratisch mit der Entfernung ab Beispiel: Eine offene Kerzenflamme - Spot Light (Spot Light): Die Lichtstrahlen werden von einem Ausgangspunkt in eine Richtung ausgesendet Die Intensitaet nimmt quadratisch mit der Entfernung ab Beispiel: Taschenlampe Hier werden derzeit nur Ambient, Directional und Pointlight unterstuetzt Diese Komponenten koennen fuer jede (Portal-)Zone einzeln eingestellt werden. D.h. Die Klasse Light ist ein Container fuer eine Liste von 'LightZone' Fuer jede (Portal-)Zone gibt es genau ein LightZone, welches die zugehoerigen Lights (Ambient, Directional, Points) beinhaltet. **************************************************************************** | |
| LightMap | ************************************************************************** * \class LightMap \brief LightMap **************************************************************************** | |
| LightPoint | ************************************************************************** * \class LightPoint \brief Klasse fuer ein Punktlicht **************************************************************************** | |
| LightZone | ************************************************************************** * \class LightZone \brief Klasse fuer eine Zone: Es gibt nur eine Lichtumgebung pro Zone In einer Zone kann es nur ein Directional Light geben Eine Zone kann beliebig viele PointLights enthalten **************************************************************************** | |
| Line | ************************************************************************** * \class Line \brief Klasse einer Line **************************************************************************** | |
| Logging | ************************************************************************** * \class Logging \brief Einfache Logging-Klasse (noch nicht wirklich implementiert) **************************************************************************** | |
| Map | ************************************************************************** * \class Map \brief Container fuer die Map **************************************************************************** | |
| Material | ************************************************************************** * \class Material \brief Container fuer ein Material **************************************************************************** | |
| MaterialManager | ************************************************************************** * \class MaterialManager \brief Container fuer alle Materialien **************************************************************************** | |
| Matrix | ************************************************************************** * \class Matrix \brief Matrixklasse **************************************************************************** | |
| Object2D | ************************************************************************** * \class Object2D \brief Beschreibt ein rechteckiges 2D-Objekt im 3D-Raum (typ. Sprites, Partikel...) **************************************************************************** | |
| Partikel | ************************************************************************** * \class Partikel \brief Partikel werden fuer die Darstellung von Feuer, Rauch, Funken, Regen usw. verwendet. Typ. wird ein Partikel durch ein 2D-Objekt repraesentiert, dem eine semitransparente Bitmap (hier Sprite genannt) fuer die Darstellung zugeordnet ist. Partikel koennen sich bewegen oder auch stationaer zein (Blinklichter). Sie haben eine Emitter, einen Lebenszyklus und noch ein paar weitere Attribute. Um 'realistische' Bewegungsablaeufe zu simulieren, wird stark mit Zufallswerten gearbeitet. Bewegung: - Keine Bewegung: Permanent AN, Blinkend=f(zeitintervall) - Lineare Bewegung: Ueber die Zeit, oder ueber die Distanz zum Emitter Bei Erreichen des Ende: Dead(Ausblenden), Respawn am Emitter, Respawn am letzter Position mit Richtungsumkehr - Parabel (z.B. Granatenwurf): Ueber die Zeit, ueber die Strecke) Bei linearer Bewegung: - Bewegung innerhalb einer BBox (ggf, mit Reflexion) - Bewegung innerhalb eines Zylinders (ggf, mit Reflexion) - Bewegung innerhalb einer Kugel (ggf, mit Reflexion) - Bewegung auf einer BBox (Anwendungsfall??) - Bewegung auf einem Zylinders (Beamer von Startrek) - Bewegung auf einer Kugel (Kreis) **************************************************************************** | |
| PartikelManager | ************************************************************************** * \class PartikelManager \brief Muesste eigentlich PartikelSystemManger heissen. Es verwaltet alle Partikelsysteme und alle Sprites, die fuer die Darstellung der einzelnen Partikel gebraucht werden. **************************************************************************** | |
| PartikelSystem | ************************************************************************** * \class PartikelSystem \brief Ein Partikelsystem beschreibt das Verhalten von Partikeln, die zu diesem System gehoeren. **************************************************************************** | |
| Plane | ************************************************************************** * \class Plane \brief Plane **************************************************************************** | |
| PLANE_SIDE | enum | |
| PLANE_TYPE | enum | |
| Renderer | ************************************************************************** * \class Renderer \brief Die Hauptklasse der Renderer 3D Engine Dieser Klasse beinhaltet ALLE Methoden, die fuer die Nutzung der Engine benoetigt werden. **************************************************************************** | |
| SkyBox | ************************************************************************** * \class SkyBox \brief SkyBox Klasse **************************************************************************** | |
| SKYBOX_SIDES | enum | |
| Sprite | ************************************************************************** * \class Sprite \brief Sprites werden fuer Partikel verwendet. Eine Sprite ist wie eine Texture, nur einfacher gestrickt. Ausserdem sind die Pixel einer Sprite semitransparent. **************************************************************************** | |
| SpriteMapper | ************************************************************************** * \class SpriteMapper \brief Rendert die Sprites (2D-Objekte) auf die Canvas unter Beruecksichtigung der Smitransparenz **************************************************************************** | |
| STEP_DIR | enum | |
| Surface | ************************************************************************** * \class Surface \brief Eine Surface (Oberflaeche) besteht aus Textur + Lightmap Die Datenablage erfolgt maximal performant fuer den TexturMapper --> RGB pro Pixel Bytes/Pixel: 1 3 4 ! 1000 --------------------------------!---------- 64*64 = 4K 12K 16K ! 16M 128*128 = 16K 48K 64K ! 64M 256*256 = 64K 192K 256K ! 256M *************************************************************************** | |
| SurfaceCache | ************************************************************************** * \class SurfaceCache \brief Der SurfaceCache ist ein Container fuer alle Surfaces, die in einem Frame gerendert werden müssen. Die Anzahl der Surfaces im Cache ist auf MAX_SURFACES begrenzt. Damit der Cache nicht ueberlaeuft, muessen ungenutzte Eintraege entfernt werden. Die Strategie sieht wie folgt aus: Jedes Surfaceobjekt besitzt einen Zaehler der in der Methode refresh() inkrementiert wird. Erreicht der Zaehler eine bestimmte Grenze (MAX_DROP), wird das Objekt aus dem Cache entfernt. Typ. wird refresh() bei jedem Frame einmal aufgerufen. Jeder Aufruf der Methode getSurface() setzt den Zaehler auf 0 zurueck. Wird ein Surfaceobjekt immer wieder fuer ein Frame verwendet, kann der Zaehler nicht die Grenze erreichen und wird damit auch nicht aus dem Cache entfernt. Diese Strategie minmiert dynamisch den Speicherbedarf. Nachteil: Bewegt sich die Kamera uber eine laengere Zeit nicht, werden alle nichtgenutzten Surfaces aus dem Cache entfernt. Wird nun die Kamera position veraendert (z.B. durch Drehen) muessen alle neuen Surfaces in den Cache geladen werden. Das macht sich durch einen Einbruch in der Framerate bemerkbar. Besser: Den Fuellstand des Caches immer voll ausnutzen. Erst wenn mehr 100% erreicht wurde, nicht genutzte Surfaces entfernen. **************************************************************************** | |
| TArc | ************************************************************************** * \class TArc \brief TArc **************************************************************************** | |
| Text | ************************************************************************** * \class Text \brief Einfache Textklasse **************************************************************************** | |
| TextMapper | ************************************************************************** * \class TextMapper \brief TextMapper Klasse **************************************************************************** | |
| Texture | ************************************************************************** * \class Texture \brief Eine Texture **************************************************************************** | |
| TextureMapper | ************************************************************************** * \class TextureMapper \brief Projiziert eine Texture aus dem 3D Raum in den 2D Raum **************************************************************************** | |
| Tile | ************************************************************************** * \class Tile \brief Die Tile ist eine Spezialisierung eines Polygons. Es beschreibt ein Rechteck im 3D-Raum. Der Tile ist eine Textur zugewiesen, die genau in diese vier Eckpunkte eingespannt ist. Sie wird im Texuremapper auf die Canvas projiziert. **************************************************************************** | |
| TILE_TYP | enum | |
| Timer | ************************************************************************** * \class Timer \brief Allgemeine Klasse fuer einen hochaufloesenden Timer (Plattformabhaengig, siehe WIN32 Sections) **************************************************************************** | |
| Triangle | ************************************************************************** * \class Triangle \brief Triangle **************************************************************************** | |
| Trigger | ************************************************************************** * \class Trigger \brief Zeitgesteuerte Zustandsklasse **************************************************************************** | |
| Vec | ************************************************************************** * \class Vec \brief 3D-Vektor (Linkshaendiges Koordinatensystem) Kamerasicht: x zeigt nach RECHTS y zeigt nach OBEN z zeigt vom Betrachter weg (in die TIEFE) Draufsicht auf die Map: x zeigt nach RECHTS (OSTEN) y zeigt in die HOEHE (NORDEN) z zeigt zum Betrachter (nach OBEN) **************************************************************************** | |
| Vertex | ************************************************************************** * \class Vertex \brief Vertex (Abgeleitet von einem Vec(tor) und um u,v Koordinaten erweitert) **************************************************************************** | |
| Zone | ************************************************************************** * \class Zone \brief Container-Klasse fuer alle Tiles die zu einer Zone gehoeren **************************************************************************** |