Engine3D
Documentation

Properties:

- html dir:
  d:/Project/engine3d/cplusplus/docs/bouml/

# 1 Package src

## 1.1 Package canvas

### 1.1.1 Class View canvas

#### 1.1.1.1 Class Canvas3D

**************************************************************************
* \class Canvas3D
\brief Schnittstelle zur Render-Engine.
Beinhaltet OS-spezifische Unterscheidungen
****************************************************************************

Declaration :

- C++ : class Canvas3D

Artifact : Canvas3D

Relation m_engine (<unidirectional association>)

Declaration :

- Uml : - m_engine : Engine
- C++ : private: Engine * m_engine

Attribute m_widthCanvas

Declaration :

- Uml : - m_widthCanvas : int
- C++ : private: int m_widthCanvas

Attribute m_heightCanvas

Declaration :

- Uml : - m_heightCanvas : int
- C++ : private: int m_heightCanvas

Attribute m_height

Declaration :

- Uml : - m_height : int
- C++ : private: int m_height

Attribute m_width

Declaration :

- Uml : - m_width : int
- C++ : private: int m_width

Attribute m_startX

Declaration :

- Uml : - m_startX : int
- C++ : private: int m_startX

Attribute m_startY

Declaration :

- Uml : - m_startY : int
- C++ : private: int m_startY

Attribute m_pDib

Declaration :

- Uml : - m_pDib : BYTE
- C++ : private: BYTE * m_pDib

Attribute m_hdc

Declaration :

- Uml : - m_hdc : HDC
- C++ : private: HDC m_hdc

Attribute m_pDiData

Declaration :

- Uml : + m_pDiData : BYTE
- C++ : public: BYTE * m_pDiData

Operation getInstance

Declaration :

- Uml : static, + getInstance() : Canvas3D
- C++ : public: static Canvas3D * getInstance()

Operation Canvas3D

Declaration :

- Uml : # Canvas3D() :
- C++ : protected: Canvas3D()

Operation paintBltBit

Declaration :

- Uml : - paintBltBit(in hdc : HDC) : void
- C++ : private: void paintBltBit(HDC hdc)

Operation paintCanvas

Declaration :

- Uml : - paintCanvas(in hdc : HDC) : void
- C++ : private: void paintCanvas(HDC hdc)

Operation createImage

Declaration :

- Uml : - createImage() : bool
- C++ : private: bool createImage()

Operation InitBitmap

Declaration :

- Uml : - InitBitmap(inout pDiData : BYTE, in cxWinSize : int, in cyWinSize : int) : void
- C++ : private: void InitBitmap(BYTE * pDiData, int cxWinSize, int cyWinSize)

Operation flipImage

Declaration :

- Uml : - flipImage(in : void) : void
- C++ : private: void flipImage(void )

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : Canvas3D= 0
- C++ : private: static Canvas3D * _instance

Operation paint

Declaration :

- Uml : + paint(in hdc : HDC) : void
- C++ : public: void paint(HDC hdc)

Operation paint

Declaration :

- Uml : + paint(in : void) : void
- C++ : public: void paint(void )

Operation init

Declaration :

- Uml : + init(inout datFile : char) : bool
- C++ : public: bool init(char * datFile)

Operation initialize

Declaration :

- Uml : + initialize(in widthCanvas : int, in heightCanvas : int, in width : int, in height : int) : void
- C++ : public: void initialize(int widthCanvas, int heightCanvas, int width, int height)

Operation renderFrame

Declaration :

- Uml : + renderFrame(in : void) : void
- C++ : public: void renderFrame(void )

Operation inputKey

Declaration :

- Uml : + inputKey(in pressed : bool, in key : int) : bool
- C++ : public: bool inputKey(bool pressed, int key)

Operation getFrameRate

Declaration :

- Uml : + getFrameRate(in : void) : double
- C++ : public: double getFrameRate(void )

Operation getTilesPerFrame

Declaration :

- Uml : + getTilesPerFrame(in : void) : int
- C++ : public: int getTilesPerFrame(void )

Operation getPartikelsPerFrame

Declaration :

- Uml : + getPartikelsPerFrame(in : void) : int
- C++ : public: int getPartikelsPerFrame(void )

Operation ~Canvas3D

Declaration :

- Uml : + ~Canvas3D() :
- C++ : public: virtual ~Canvas3D()

All public operations : getFrameRate , getInstance , getPartikelsPerFrame , getTilesPerFrame , init , initialize , inputKey , paint , paint , renderFrame

### 1.1.2 Deployment View canvas

Artifact Canvas3D

Stereotype: source

Artifact source associated with : Canvas3D

## 1.2 Package engine

### 1.2.1 Class View engine

#### 1.2.1.1 Class Engine

**************************************************************************
* \class Engine
\brief Die Hauptklasse der 3D Engine
Dieser Klasse beinhaltet ALLE Methoden, die fuer die Nutzung
der Engine benoetigt werden.
****************************************************************************

Declaration :

- C++ : class Engine

Artifact : Engine

Operation getInstance

Declaration :

- Uml : static, + getInstance() : Engine
- C++ : public: static Engine * getInstance()

Operation Engine

Declaration :

- Uml : # Engine() :
- C++ : protected: Engine()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : Engine= 0
- C++ : private: static Engine * _instance

Operation ~Engine

Declaration :

- Uml : + ~Engine() :
- C++ : public: virtual ~Engine()

Attribute m_drawInfo

Declaration :

- Uml : - m_drawInfo : bool
- C++ : private: bool m_drawInfo

Attribute m_usePortalFrustum

Declaration :

- Uml : - m_usePortalFrustum : bool
- C++ : private: bool m_usePortalFrustum

Attribute m_rendering

Declaration :

- Uml : - m_rendering : bool
- C++ : private: bool m_rendering

Relation m_timer (<directional composition>)

Declaration :

- Uml : - m_timer : Timer
- C++ : private: Timer m_timer

Attribute m_frameRate

Declaration :

- Uml : - m_frameRate : double
- C++ : private: double m_frameRate

Attribute m_partikelCount

Declaration :

- Uml : - m_partikelCount : int
- C++ : private: int m_partikelCount

Relation m_map (<unidirectional association>)

Declaration :

- Uml : - m_map : Map
- C++ : private: Map * m_map

Relation m_camera (<unidirectional association>)

Declaration :

- Uml : - m_camera : Camera
- C++ : private: Camera * m_camera

Relation m_engineIO (<unidirectional association>)

Declaration :

- Uml : - m_engineIO : EngineIO
- C++ : private: EngineIO * m_engineIO

Relation m_lightManager (<unidirectional association>)

Declaration :

- Uml : - m_lightManager : LightManager
- C++ : private: LightManager * m_lightManager

Relation m_frustum (<unidirectional association>)

Declaration :

- Uml : - m_frustum : Frustum
- C++ : private: Frustum * m_frustum

Relation m_skyBox (<unidirectional association>)

Declaration :

- Uml : - m_skyBox : SkyBox
- C++ : private: SkyBox * m_skyBox

Relation m_animationManager (<unidirectional association>)

Declaration :

- Uml : - m_animationManager : AnimationManager
- C++ : private: AnimationManager * m_animationManager

Relation m_partikelManager (<unidirectional association>)

Declaration :

- Uml : - m_partikelManager : PartikelManager
- C++ : private: PartikelManager * m_partikelManager

Relation m_surfaceCache (<unidirectional association>)

Declaration :

- Uml : - m_surfaceCache : SurfaceCache
- C++ : private: SurfaceCache * m_surfaceCache

Relation m_renderer (<unidirectional association>)

Declaration :

- Uml : - m_renderer : Renderer
- C++ : private: Renderer * m_renderer

Attribute m_height

Declaration :

- Uml : - m_height : int
- C++ : private: int m_height

Attribute m_width

Declaration :

- Uml : - m_width : int
- C++ : private: int m_width

Relation m_camdir (<directional composition>)

Declaration :

- Uml : - m_camdir : Vec
- C++ : private: Vec m_camdir

Relation m_campos (<directional composition>)

Declaration :

- Uml : - m_campos : Vec
- C++ : private: Vec m_campos

Relation m_matTranslate (<directional composition>)

Declaration :

- Uml : - m_matTranslate : Matrix
- C++ : private: Matrix m_matTranslate

Relation m_matRotate (<directional composition>)

Declaration :

- Uml : - m_matRotate : Matrix
- C++ : private: Matrix m_matRotate

Relation m_matAnimate (<directional composition>)

Declaration :

- Uml : - m_matAnimate : Matrix
- C++ : private: Matrix m_matAnimate

Attribute m_isRendererInitialized

Declaration :

- Uml : - m_isRendererInitialized : bool
- C++ : private: bool m_isRendererInitialized

Relation m_tileList (<unidirectional association>)

Declaration :

- Uml : - m_tileList : Tile
- C++ : private: std::vector<Tile*> m_tileList

Stereotype: std::vector

Relation m_partikelList (<unidirectional association>)

Declaration :

- Uml : - m_partikelList : Partikel
- C++ : private: std::vector<Partikel*> m_partikelList

Stereotype: std::vector

Relation m_text (<unidirectional association>)

Declaration :

- Uml : - m_text : Text
- C++ : private: Text * m_text

Relation m_textList (<unidirectional association>)

Declaration :

- Uml : - m_textList : Text
- C++ : private: std::vector<Text*> m_textList

Stereotype: std::vector

Operation initRenderer

Declaration :

- Uml : + initRenderer(in width : int, in height : int, inout data : BYTE) : void
- C++ : public: void initRenderer(int width, int height, BYTE * data)

Operation renderFrame

Declaration :

- Uml : + renderFrame() : void
- C++ : public: void renderFrame()

Operation saveAsMapfile

Declaration :

- Uml : + saveAsMapfile(inout fname : char) : void
- C++ : public: void saveAsMapfile(char * fname)

Operation loadMapfile

Declaration :

- Uml : + loadMapfile(inout fname : char) : bool
- C++ : public: bool loadMapfile(char * fname)

Operation calcAnimation

Declaration :

- Uml : + calcAnimation() : void
- C++ : public: void calcAnimation()

Operation calcLightMapGrid

Declaration :

- Uml : + calcLightMapGrid() : void
- C++ : public: void calcLightMapGrid()

Operation calcLightMap

Declaration :

- Uml : + calcLightMap() : void
- C++ : public: void calcLightMap()

Operation inputKey

Declaration :

- Uml : + inputKey(in pressed : bool, in key : int) : bool
- C++ : public: bool inputKey(bool pressed, int key)

Operation getFrameRate

Declaration :

- Uml : + getFrameRate(in : void) : double
- C++ : public: double getFrameRate(void )

Operation getTilesPerFrame

Declaration :

- Uml : + getTilesPerFrame(in : void) : int
- C++ : public: int getTilesPerFrame(void )

Operation getPartikelsPerFrame

Declaration :

- Uml : + getPartikelsPerFrame(in : void) : int
- C++ : public: int getPartikelsPerFrame(void )

Operation animate

Declaration :

- Uml : - animate(in : void) : void
- C++ : private: void animate(void )

Operation culling

Declaration :

- Uml : - culling(in zoneNr : int, inout frust : Frustum) : void
- C++ : private: void culling(int zoneNr, Frustum & frust)

Operation paintZone

Declaration :

- Uml : - paintZone() : void
- C++ : private: void paintZone()

Operation paint2D

Declaration :

- Uml : - paint2D(in zoneNr : int, inout frustum : Frustum) : void
- C++ : private: void paint2D(int zoneNr, Frustum & frustum)

Operation paintSkyBox

Declaration :

- Uml : - paintSkyBox() : void
- C++ : private: void paintSkyBox()

Operation sortBack2Front

Declaration :

- Uml : - sortBack2Front() : void
- C++ : private: void sortBack2Front()

Operation solveZConflicts

Declaration :

- Uml : - solveZConflicts(in : void) : void
- C++ : private: void solveZConflicts(void )

All public operations : calcAnimation , calcLightMap , calcLightMapGrid , getFrameRate , getInstance , getPartikelsPerFrame , getTilesPerFrame , initRenderer , inputKey , loadMapfile , renderFrame , saveAsMapfile

#### 1.2.1.2 Class 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
****************************************************************************

Declaration :

- C++ : class Camera

Artifact : Camera

Operation getInstance

Declaration :

- Uml : static, + getInstance() : Camera
- C++ : public: static Camera * getInstance()

Operation Camera

Declaration :

- Uml : # Camera() :
- C++ : protected: Camera()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : Camera= 0
- C++ : private: static Camera * _instance

Operation ~Camera

Declaration :

- Uml : + ~Camera() :
- C++ : public: virtual ~Camera()

#### 1.2.1.2.1 Class STEP_DIR

Declaration :

- C++ : enum STEP_DIR

nested in Camera

Stereotype: enum

Items :

- STOP
- STEP_FORWARD
- STEP_BACKWARD
- STRAFE_LEFT
- STRAFE_RIGHT
- STEP_LEFT
- STEP_RIGHT
- STEP_UP
- STEP_DOWN
- ROTATE_LEFT
- ROTATE_RIGHT

Relation m_moving (<directional composition>)

FORWARD, BACKWARD, STOP

Declaration :

- Uml : - m_moving : STEP_DIR
- C++ : private: STEP_DIR m_moving

Relation m_lifting (<directional composition>)

UP, DOWN, STOP

Declaration :

- Uml : - m_lifting : STEP_DIR
- C++ : private: STEP_DIR m_lifting

Relation m_strafing (<directional composition>)

LEFT, RIGHT, STOP

Declaration :

- Uml : - m_strafing : STEP_DIR
- C++ : private: STEP_DIR m_strafing

Relation m_rotating (<directional composition>)

LEFT, RIGHT, STOP

Declaration :

- Uml : - m_rotating : STEP_DIR
- C++ : private: STEP_DIR m_rotating

Relation m_vecPos (<directional composition>)

Standpunkt der Kamera

Declaration :

- Uml : - m_vecPos : Vec
- C++ : private: Vec m_vecPos

Relation m_vecDir (<directional composition>)

Blickrichtung der Kamera (Richtungsvektor mit einem Betrag = 1)

Declaration :

- Uml : - m_vecDir : Vec
- C++ : private: Vec m_vecDir

Relation m_vecPosNext (<directional composition>)

neuer Standpunkt der Kamera

Declaration :

- Uml : - m_vecPosNext : Vec
- C++ : private: Vec m_vecPosNext

Relation m_vecDirNext (<directional composition>)

neue Blickrichtung der Kamera (Richtungsvektor mit einem Betrag = 1)

Declaration :

- Uml : - m_vecDirNext : Vec
- C++ : private: Vec m_vecDirNext

Relation m_vecPosColl (<directional composition>)

Declaration :

- Uml : - m_vecPosColl : Vec
- C++ : private: Vec m_vecPosColl

Relation m_vecDirColl (<directional composition>)

Declaration :

- Uml : - m_vecDirColl : Vec
- C++ : private: Vec m_vecDirColl

Attribute m_stepColl

Kollisionsdistanz

Declaration :

- Uml : - m_stepColl : float
- C++ : private: float m_stepColl

Attribute m_stepAnim

Declaration :

- Uml : - m_stepAnim : float
- C++ : private: float m_stepAnim

Attribute m_step

Schrittweite

Declaration :

- Uml : - m_step : float
- C++ : private: float m_step

Attribute m_turn

Drehwinkel

Declaration :

- Uml : - m_turn : int
- C++ : private: int m_turn

Attribute m_zone

Declaration :

- Uml : - m_zone : int
- C++ : private: int m_zone

Attribute m_HOG

Hoehe ueber Grund (typ TexturHeight / 2)

Declaration :

- Uml : - m_HOG : int
- C++ : private: int m_HOG

Attribute m_moverCount

Declaration :

- Uml : - m_moverCount : int
- C++ : private: int m_moverCount

Attribute m_moverDeltaY

Declaration :

- Uml : - m_moverDeltaY : float
- C++ : private: float m_moverDeltaY

Operation action

Declaration :

- Uml : + action() : void
- C++ : public: void action()

Operation move

Declaration :

- Uml : + move(in step : STEP_DIR) : void
- C++ : public: void move(STEP_DIR step)

Operation isMoving

Declaration :

- Uml : + isMoving() : STEP_DIR
- C++ : public: STEP_DIR isMoving()

Operation lift

Declaration :

- Uml : + lift(in step : STEP_DIR) : void
- C++ : public: void lift(STEP_DIR step)

Operation isLifting

Declaration :

- Uml : + isLifting() : STEP_DIR
- C++ : public: STEP_DIR isLifting()

Operation strafe

Declaration :

- Uml : + strafe(in step : STEP_DIR) : void
- C++ : public: void strafe(STEP_DIR step)

Operation isStrafing

Declaration :

- Uml : + isStrafing() : STEP_DIR
- C++ : public: STEP_DIR isStrafing()

Operation rotate

Declaration :

- Uml : + rotate(in step : STEP_DIR) : void
- C++ : public: void rotate(STEP_DIR step)

Operation isRotating

Declaration :

- Uml : + isRotating() : STEP_DIR
- C++ : public: STEP_DIR isRotating()

Operation getZone

Declaration :

- Uml : + getZone() : int
- C++ : public: int getZone()

Operation setZone

Declaration :

- Uml : + setZone(in zone : int) : void
- C++ : public: void setZone(int zone)

Operation setPos

Declaration :

- Uml : + setPos(in x : float, in y : float, in z : float) : void
- C++ : public: void setPos(float x, float y, float z)

Operation setDir

Declaration :

- Uml : + setDir(in x : float, in y : float, in z : float) : void
- C++ : public: void setDir(float x, float y, float z)

Operation getPos

Declaration :

- Uml : + getPos() : Vec
- C++ : public: Vec & getPos()

Operation getDir

Declaration :

- Uml : + getDir() : Vec
- C++ : public: Vec & getDir()

Operation stepForward

Declaration :

- Uml : + stepForward() : void
- C++ : public: void stepForward()

Operation stepBackward

Declaration :

- Uml : + stepBackward() : void
- C++ : public: void stepBackward()

Operation stepStrafeRight

Declaration :

- Uml : + stepStrafeRight() : void
- C++ : public: void stepStrafeRight()

Operation stepStrafeLeft

Declaration :

- Uml : + stepStrafeLeft() : void
- C++ : public: void stepStrafeLeft()

Operation stepUp

Declaration :

- Uml : + stepUp() : void
- C++ : public: void stepUp()

Operation stepDown

Declaration :

- Uml : + stepDown() : void
- C++ : public: void stepDown()

Operation stepTurnRight

Declaration :

- Uml : + stepTurnRight() : void
- C++ : public: void stepTurnRight()

Operation stepTurnLeft

Declaration :

- Uml : + stepTurnLeft() : void
- C++ : public: void stepTurnLeft()

Operation aimUp

Declaration :

- Uml : + aimUp() : void
- C++ : public: void aimUp()

Operation aimDown

Declaration :

- Uml : + aimDown() : void
- C++ : public: void aimDown()

Operation incMove

Declaration :

- Uml : + incMove() : void
- C++ : public: void incMove()

Operation collision

Declaration :

- Uml : + collision(in typ : int, in dir : int) : bool
- C++ : public: bool collision(int typ, int dir)

Operation getLevel

Declaration :

- Uml : + getLevel() : float
- C++ : public: float getLevel()

Operation dump

Declaration :

- Uml : + dump() : void
- C++ : public: void dump()

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

Operation save

Declaration :

- Uml : + save(inout dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream & dataOut)

All public operations : action , aimDown , aimUp , collision , dump , getDir , getInstance , getLevel , getPos , getZone , incMove , isLifting , isMoving , isRotating , isStrafing , lift , load , move , rotate , save , setDir , setPos , setZone , stepBackward , stepDown , stepForward , stepStrafeLeft , stepStrafeRight , stepTurnLeft , stepTurnRight , stepUp , strafe

#### 1.2.1.3 Class Map

**************************************************************************
* \class Map
\brief Container fuer die Map
****************************************************************************

Declaration :

- C++ : class Map

Artifact : Map

Operation Map

Declaration :

- Uml : # Map() :
- C++ : protected: Map()

Relation zoneList (<unidirectional association>)

Declaration :

- Uml : + zoneList : Zone
- C++ : public: std::vector<Zone*> zoneList

Stereotype: std::vector

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : Map= 0
- C++ : private: static Map * _instance

Attribute m_mapfile

Declaration :

- Uml : - m_mapfile : char, multiplicity : [255]
- C++ : private: char m_mapfile[255]

Operation getInstance

Declaration :

- Uml : static, + getInstance() : Map
- C++ : public: static Map * getInstance()

Operation ~Map

Declaration :

- Uml : + ~Map() :
- C++ : public: virtual ~Map()

Operation calcAnimation

Declaration :

- Uml : + calcAnimation() : void
- C++ : public: void calcAnimation()

Operation calcLightMapGrid

Declaration :

- Uml : + calcLightMapGrid() : void
- C++ : public: void calcLightMapGrid()

Operation calcLightMap

Declaration :

- Uml : + calcLightMap() : void
- C++ : public: void calcLightMap()

Operation dump

Declaration :

- Uml : + dump() : void
- C++ : public: void dump()

Operation addTile

Declaration :

- Uml : - addTile(inout tile : Tile) : void
- C++ : private: void addTile(Tile * tile)

All public operations : calcAnimation , calcLightMap , calcLightMapGrid , dump , getInstance

#### 1.2.1.4 Class EngineIO

**************************************************************************
* \class EngineIO
\brief EngineIO
****************************************************************************

Declaration :

- C++ : class EngineIO

Artifact : EngineIO

Operation getInstance

Declaration :

- Uml : static, + getInstance() : EngineIO
- C++ : public: static EngineIO * getInstance()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : EngineIO= 0
- C++ : private: static EngineIO * _instance

Operation EngineIO

Declaration :

- Uml : # EngineIO() :
- C++ : protected: EngineIO()

Operation ~EngineIO

Declaration :

- Uml : + ~EngineIO() :
- C++ : public: virtual ~EngineIO()

Relation m_map (<unidirectional association>)

Declaration :

- Uml : - m_map : Map
- C++ : private: Map * m_map

Relation m_materialManager (<unidirectional association>)

Declaration :

- Uml : - m_materialManager : MaterialManager
- C++ : private: MaterialManager * m_materialManager

Relation m_camera (<unidirectional association>)

Declaration :

- Uml : - m_camera : Camera
- C++ : private: Camera * m_camera

Relation m_lightManager (<unidirectional association>)

Declaration :

- Uml : - m_lightManager : LightManager
- C++ : private: LightManager * m_lightManager

Relation m_skybox (<unidirectional association>)

Declaration :

- Uml : - m_skybox : SkyBox
- C++ : private: SkyBox * m_skybox

Relation m_animationManager (<unidirectional association>)

Declaration :

- Uml : - m_animationManager : AnimationManager
- C++ : private: AnimationManager * m_animationManager

Relation m_partikelManager (<unidirectional association>)

Declaration :

- Uml : - m_partikelManager : PartikelManager
- C++ : private: PartikelManager * m_partikelManager

Relation m_textMapper (<unidirectional association>)

Declaration :

- Uml : - m_textMapper : TextMapper
- C++ : private: TextMapper * m_textMapper

Operation save

Declaration :

- Uml : + save(inout fname : char) : void
- C++ : public: void save(char * fname)

Operation load

Declaration :

- Uml : + load(inout mapfile : char) : bool
- C++ : public: bool load(char * mapfile)

All public operations : getInstance , load , save

#### 1.2.1.5 Class 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.
****************************************************************************

Declaration :

- C++ : class Frustum

Artifact : Frustum

Attribute viewAngle

Declaration :

- Uml : - viewAngle : int
- C++ : private: int viewAngle

Attribute NearPlaneHeight

Declaration :

- Uml : + NearPlaneHeight : int
- C++ : public: int NearPlaneHeight

Attribute NearPlaneWidth

Declaration :

- Uml : + NearPlaneWidth : int
- C++ : public: int NearPlaneWidth

Attribute NearFarDist

Declaration :

- Uml : + NearFarDist : int
- C++ : public: int NearFarDist

Attribute NearPlaneDist

Declaration :

- Uml : + NearPlaneDist : int
- C++ : public: int NearPlaneDist

Attribute FarPlaneDist

Declaration :

- Uml : + FarPlaneDist : int
- C++ : public: int FarPlaneDist

Relation vOrigin (<directional composition>)

Declaration :

- Uml : - vOrigin : Vec
- C++ : private: Vec vOrigin

Relation vEnd (<directional composition>)

Declaration :

- Uml : + vEnd : Vec
- C++ : public: Vec vEnd

Relation Origin (<directional composition>)

Declaration :

- Uml : + Origin : Vec
- C++ : public: Vec Origin

Attribute OriginDist

Declaration :

- Uml : - OriginDist : float
- C++ : private: float OriginDist

Relation OriginPlaneLR (<directional composition>)

Eckpunkt Lower Right der NearPlane (rel. zur Camerapositon im Ursprung)

Declaration :

- Uml : + OriginPlaneLR : Vec
- C++ : public: Vec OriginPlaneLR

Relation OriginPlaneUR (<directional composition>)

Eckpunkt Upper Right der NearPlane (rel. zur Camerapositon im Ursprung)

Declaration :

- Uml : + OriginPlaneUR : Vec
- C++ : public: Vec OriginPlaneUR

Relation OriginPlaneLL (<directional composition>)

Eckpunkt Lower Left der NearPlane (rel. zur Camerapositon im Ursprung)

Declaration :

- Uml : + OriginPlaneLL : Vec
- C++ : public: Vec OriginPlaneLL

Relation OriginPlaneUL (<directional composition>)

Eckpunkt Upper Left der NearPlane (rel. zur Camerapositon im Ursprung)

Declaration :

- Uml : + OriginPlaneUL : Vec
- C++ : public: Vec OriginPlaneUL

Relation PlaneDir (<directional composition>)

Declaration :

- Uml : + PlaneDir : Vec
- C++ : public: Vec PlaneDir

Relation NearPlaneLR (<directional composition>)

Eckpunkt Lower Right der NearPlane (rel. zur Camerapositon im Ursprung)

Declaration :

- Uml : + NearPlaneLR : Vec
- C++ : public: Vec NearPlaneLR

Relation NearPlaneUR (<directional composition>)

Eckpunkt Upper Right der NearPlane (rel. zur Camerapositon im Ursprung)

Declaration :

- Uml : + NearPlaneUR : Vec
- C++ : public: Vec NearPlaneUR

Relation NearPlaneLL (<directional composition>)

Eckpunkt Lower Left der NearPlane (rel. zur Camerapositon im Ursprung)

Declaration :

- Uml : + NearPlaneLL : Vec
- C++ : public: Vec NearPlaneLL

Relation NearPlaneUL (<directional composition>)

Eckpunkt Upper Left der NearPlane (rel. zur Camerapositon im Ursprung)

Declaration :

- Uml : + NearPlaneUL : Vec
- C++ : public: Vec NearPlaneUL

Relation FarPlaneLR (<directional composition>)

Eckpunkt Lower Right der FarPlane (rel. zur Camerapositon im Ursprung)

Declaration :

- Uml : + FarPlaneLR : Vec
- C++ : public: Vec FarPlaneLR

Relation FarPlaneUR (<directional composition>)

Eckpunkt Upper Right der FarPlane (rel. zur Camerapositon im Ursprung)

Declaration :

- Uml : + FarPlaneUR : Vec
- C++ : public: Vec FarPlaneUR

Relation FarPlaneLL (<directional composition>)

Eckpunkt Lower Left der FarPlane (rel. zur Camerapositon im Ursprung)

Declaration :

- Uml : + FarPlaneLL : Vec
- C++ : public: Vec FarPlaneLL

Relation FarPlaneUL (<directional composition>)

Eckpunkt Upper Left der FarPlane (rel. zur Camerapositon im Ursprung)

Declaration :

- Uml : + FarPlaneUL : Vec
- C++ : public: Vec FarPlaneUL

#### 1.2.1.5.1 Class PLANE_SIDE

Declaration :

- C++ : enum PLANE_SIDE

nested in Frustum

Stereotype: enum

Items :

- PLANE_TOP
- PLANE_RIGHT
- PLANE_BOTTOM
- PLANE_LEFT

Attribute m_usedSidePlanes

Declaration :

- Uml : - m_usedSidePlanes : int
- C++ : private: int m_usedSidePlanes

Attribute SIDE_PLANES

Declaration :

- Uml : static, - SIDE_PLANES : int= 10
- C++ : private: static int SIDE_PLANES

Relation m_sidePlanes (<unidirectional association>)

TODO: 10 == SIDE_PLANES

Declaration :

- Uml : - m_sidePlanes : Plane
- C++ : private: Plane * m_sidePlanes

Relation OriginPlane (<directional composition>)

Declaration :

- Uml : - OriginPlane : Plane
- C++ : private: Plane OriginPlane

Relation NearPlane (<directional composition>)

Declaration :

- Uml : - NearPlane : Plane
- C++ : private: Plane NearPlane

Relation FarPlane (<directional composition>)

Declaration :

- Uml : - FarPlane : Plane
- C++ : private: Plane FarPlane

Operation Frustum

Declaration :

- Uml : + Frustum() :
- C++ : public: Frustum()

Operation Frustum

Declaration :

- Uml : + Frustum(in width : int, in height : int) :
- C++ : public: Frustum(int width, int height)

Operation init

Declaration :

- Uml : + init() : void
- C++ : public: void init()

Operation set

Declaration :

- Uml : + set(inout tile : Tile) : void
- C++ : public: void set(Tile & tile)

Operation getOriginDist

Declaration :

- Uml : + getOriginDist() : float
- C++ : public: float getOriginDist()

Operation clip

Declaration :

- Uml : + clip(inout tile : Tile) : void
- C++ : public: void clip(Tile & tile)

Operation inside

Declaration :

- Uml : + inside(inout tile : Tile) : bool
- C++ : public: bool inside(Tile & tile)

Operation inside

Declaration :

- Uml : + inside(inout partikel : Partikel) : bool
- C++ : public: bool inside(Partikel & partikel)

Operation dump

Declaration :

- Uml : + dump() : void
- C++ : public: void dump()

Operation ~Frustum

Declaration :

- Uml : + ~Frustum() :
- C++ : public: virtual ~Frustum()

Operation inside

Declaration :

- Uml : - inside(inout v : Vec) : bool
- C++ : private: bool inside(Vec & v)

Operation intersects

Declaration :

- Uml : - intersects(inout line : Line) : bool
- C++ : private: bool intersects(Line & line)

All public operations : clip , dump , getOriginDist , init , inside , inside , set

#### 1.2.1.6 Class Zone

**************************************************************************
* \class Zone
\brief Container-Klasse fuer alle Tiles die zu einer Zone gehoeren
****************************************************************************

Declaration :

- C++ : class Zone

Artifact : Zone

Operation Zone

Declaration :

- Uml : + Zone() :
- C++ : public: Zone()

Operation Zone

Declaration :

- Uml : + Zone(in zone : int) :
- C++ : public: Zone(int zone)

Operation ~Zone

Declaration :

- Uml : + ~Zone() :
- C++ : public: virtual ~Zone()

Operation addTile

Declaration :

- Uml : + addTile(inout tile : Tile) : void
- C++ : public: void addTile(Tile * tile)

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

Operation save

Declaration :

- Uml : + save(inout dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream & dataOut)

Relation tileList (<unidirectional association>)

Declaration :

- Uml : + tileList : Tile
- C++ : public: std::vector<Tile*> tileList

Stereotype: std::vector

Attribute m_zone

Declaration :

- Uml : + m_zone : int
- C++ : public: int m_zone

All public operations : addTile , load , save

### 1.2.2 Deployment View engine

Artifact Camera

Stereotype: source

Artifact source associated with : Camera

Artifact Engine

Stereotype: source

Artifact source associated with : Engine

Artifact EngineIO

Stereotype: source

Artifact source associated with : EngineIO

Artifact Frustum

Stereotype: source

Artifact source associated with : Frustum

Artifact Map

Stereotype: source

Artifact source associated with : Map

Artifact Zone

Stereotype: source

Artifact source associated with : Zone

## 1.3 Package math3d

### 1.3.1 Class View math3d

#### 1.3.1.1 Class 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)
****************************************************************************

Declaration :

- C++ : class Vec

Directly inherited by : Vertex

Artifact : Vec

Attribute m_x

Declaration :

- Uml : + m_x : float
- C++ : public: float m_x

Attribute m_y

Declaration :

- Uml : + m_y : float
- C++ : public: float m_y

Attribute m_z

Declaration :

- Uml : + m_z : float
- C++ : public: float m_z

Operation Vec

Declaration :

- Uml : + Vec() :
- C++ : public: Vec()

Operation ~Vec

Declaration :

- Uml : + ~Vec() :
- C++ : public: virtual ~Vec()

Operation Vec

Declaration :

- Uml : + Vec(inout v : Vec) :
- C++ : public: Vec(Vec & v)

Operation Vec

Declaration :

- Uml : + Vec(in x : int, in y : int, in z : int) :
- C++ : public: Vec(int x, int y, int z)

Operation Vec

Declaration :

- Uml : + Vec(in x : float, in y : float, in z : float) :
- C++ : public: Vec(float x, float y, float z)

Operation clear

Declaration :

- Uml : + clear(in : void) : void
- C++ : public: void clear(void )

Operation set

Declaration :

- Uml : + set(in x : float, in y : float, in z : float) : void
- C++ : public: void set(float x, float y, float z)

Operation set

Declaration :

- Uml : + set(inout v : Vec) : void
- C++ : public: void set(Vec & v)

Operation add

Declaration :

- Uml : + add(inout v : Vec) : void
- C++ : public: void add(Vec & v)

Operation sub

Declaration :

- Uml : + sub(inout v : Vec) : void
- C++ : public: void sub(Vec & v)

Operation sub

Declaration :

- Uml : + sub(inout v1 : Vec, inout v2 : Vec) : void
- C++ : public: void sub(Vec & v1, Vec & v2)

Operation mul

Declaration :

- Uml : + mul(inout v : Vec) : void
- C++ : public: void mul(Vec & v)

Operation div

Declaration :

- Uml : + div(in v : float) : void
- C++ : public: void div(float v)

Operation mul

Declaration :

- Uml : + mul(in d : float) : void
- C++ : public: void mul(float d)

Operation length

Declaration :

- Uml : + length(in : void) : float
- C++ : public: float length(void )

Operation dot

Declaration :

- Uml : + dot(inout v : Vec) : float
- C++ : public: float dot(Vec & v)

Operation cross

Declaration :

- Uml : + cross(inout v1 : Vec, inout v2 : Vec) : void
- C++ : public: void cross(Vec & v1, Vec & v2)

Operation getZ

Declaration :

- Uml : + getZ(inout a : Vec, inout b : Vec, in z : float) : bool
- C++ : public: bool getZ(Vec & a, Vec & b, float z)

Operation angle

Declaration :

- Uml : + angle(inout v : Vec) : float
- C++ : public: float angle(Vec & v)

Operation winkel

Declaration :

- Uml : + winkel(in : void) : int
- C++ : public: int winkel(void )

Operation transform

Declaration :

- Uml : + transform(inout mat : Matrix) : void
- C++ : public: void transform(Matrix & mat)

Operation normalize

Declaration :

- Uml : + normalize(in : void) : void
- C++ : public: void normalize(void )

Operation negative

Declaration :

- Uml : + negative(in : void) : void
- C++ : public: void negative(void )

Operation rotateX

Declaration :

- Uml : + rotateX(in w : int) : void
- C++ : public: void rotateX(int w)

Operation rotateY

Declaration :

- Uml : + rotateY(in w : int) : void
- C++ : public: void rotateY(int w)

Operation rotateZ

Declaration :

- Uml : + rotateZ(in w : int) : void
- C++ : public: void rotateZ(int w)

Operation getWinkelY

Declaration :

- Uml : + getWinkelY(in : void) : int
- C++ : public: int getWinkelY(void )

Operation dump

Declaration :

- Uml : + dump(in : void) : char
- C++ : public: char * dump(void )

All public operations : add , angle , clear , cross , div , dot , dump , getWinkelY , getZ , length , mul , mul , negative , normalize , rotateX , rotateY , rotateZ , set , set , sub , sub , transform , winkel

#### 1.3.1.2 Class Matrix

**************************************************************************
* \class Matrix
\brief Matrixklasse
****************************************************************************

Declaration :

- C++ : class Matrix

Artifact : Matrix

Relation m_arc (<unidirectional association>)

Declaration :

- Uml : - m_arc : TArc
- C++ : private: TArc * m_arc

Operation Matrix

Declaration :

- Uml : + Matrix() :
- C++ : public: Matrix()

Operation ~Matrix

Declaration :

- Uml : + ~Matrix() :
- C++ : public: virtual ~Matrix()

Operation clear

Declaration :

- Uml : + clear(in : void) : void
- C++ : public: void clear(void )

Operation set

Declaration :

- Uml : + set(inout v1 : Vec, inout v2 : Vec, inout v3 : Vec) : void
- C++ : public: void set(Vec & v1, Vec & v2, Vec & v3)

Operation setInv

Declaration :

- Uml : + setInv(inout v1 : Vec, inout v2 : Vec, inout v3 : Vec) : void
- C++ : public: void setInv(Vec & v1, Vec & v2, Vec & v3)

Operation rotateX

Declaration :

- Uml : + rotateX(in w : int) : void
- C++ : public: void rotateX(int w)

Operation rotateY

Declaration :

- Uml : + rotateY(in w : int) : void
- C++ : public: void rotateY(int w)

Operation rotateZ

Declaration :

- Uml : + rotateZ(in w : int) : void
- C++ : public: void rotateZ(int w)

Operation rotateXRad

Declaration :

- Uml : + rotateXRad(in w : float) : void
- C++ : public: void rotateXRad(float w)

Operation rotateYRad

Declaration :

- Uml : + rotateYRad(in w : float) : void
- C++ : public: void rotateYRad(float w)

Operation rotateZRad

Declaration :

- Uml : + rotateZRad(in w : float) : void
- C++ : public: void rotateZRad(float w)

Operation translate

Declaration :

- Uml : + translate(inout v : Vec) : void
- C++ : public: void translate(Vec & v)

Operation scale

Declaration :

- Uml : + scale(in s : float) : void
- C++ : public: void scale(float s)

Operation dump

Declaration :

- Uml : + dump(in : void) : void
- C++ : public: void dump(void )

All public operations : clear , dump , rotateX , rotateXRad , rotateY , rotateYRad , rotateZ , rotateZRad , scale , set , setInv , translate

#### 1.3.1.3 Class Plane

**************************************************************************
* \class Plane
\brief Plane
****************************************************************************

Declaration :

- C++ : class Plane

Directly inherited by : Tile

Artifact : Plane

Operation Plane

Declaration :

- Uml : + Plane() :
- C++ : public: Plane()

Operation ~Plane

Declaration :

- Uml : + ~Plane() :
- C++ : public: virtual ~Plane()

#### 1.3.1.3.1 Class PLANE_TYPE

Declaration :

- C++ : enum PLANE_TYPE

nested in Plane

Stereotype: enum

Items :

- INSIDE
- OUTSIDE
- INPLANE

Relation m_N (<directional composition>)

Normalenvektor zur Ebene

Declaration :

- Uml : + m_N : Vec
- C++ : public: Vec m_N

Relation m_P (<directional composition>)

Punkt auf der Ebene

Declaration :

- Uml : + m_P : Vec
- C++ : public: Vec m_P

Attribute m_D

Entfernung zum Ursprung

Declaration :

- Uml : + m_D : float
- C++ : public: float m_D

Attribute m_intersectLength

Declaration :

- Uml : - m_intersectLength : float
- C++ : private: float m_intersectLength

Operation clear

Declaration :

- Uml : + clear(in : void) : void
- C++ : public: void clear(void )

Operation set

Declaration :

- Uml : + set(inout v0 : Vec, inout va : Vec, inout vb : Vec) : void
- C++ : public: void set(Vec & v0, Vec & va, Vec & vb)

Operation check

Declaration :

- Uml : + check(inout v0 : Vec) : int
- C++ : public: int check(Vec & v0)

Operation intersect

Declaration :

- Uml : + intersect(inout P : Line, inout dist : float) : bool
- C++ : public: bool intersect(Line & P, float * dist)

Operation getInterLegth

Declaration :

- Uml : + getInterLegth() : float
- C++ : public: float getInterLegth()

Operation dump

Declaration :

- Uml : + dump(inout msg : char) : void
- C++ : public: void dump(char * msg)

All public operations : check , clear , dump , getInterLegth , intersect , set

#### 1.3.1.4 Class Line

**************************************************************************
* \class Line
\brief Klasse einer Line
****************************************************************************

Declaration :

- C++ : class Line

Artifact : Line

Operation Line

Declaration :

- Uml : + Line() :
- C++ : public: Line()

Operation ~Line

Declaration :

- Uml : + ~Line() :
- C++ : public: virtual ~Line()

Relation m_S (<directional composition>)

Startpunkt der Linie

Declaration :

- Uml : + m_S : Vec
- C++ : public: Vec m_S

Relation m_E (<directional composition>)

Endpunkt der Linie

Declaration :

- Uml : + m_E : Vec
- C++ : public: Vec m_E

Relation m_V (<directional composition>)

Richtungsvektor der Linie

Declaration :

- Uml : + m_V : Vec
- C++ : public: Vec m_V

Operation set

Declaration :

- Uml : + set(inout p1 : Vec, inout p2 : Vec) : void
- C++ : public: void set(Vec & p1, Vec & p2)

Operation getLength

Declaration :

- Uml : + getLength(in : void) : float
- C++ : public: float getLength(void )

Operation getEndPoint

Declaration :

- Uml : + getEndPoint(in t : float) : Vec
- C++ : public: Vec * getEndPoint(float t)

Operation getEndPoint2

Declaration :

- Uml : + getEndPoint2(in t : float) : Vec
- C++ : public: Vec & getEndPoint2(float t)

Operation getEndPoint

Declaration :

- Uml : + getEndPoint(in t : float, inout E : Vec) : void
- C++ : public: void getEndPoint(float t, Vec * E)

Operation dump

Declaration :

- Uml : + dump(inout msg : char) : void
- C++ : public: void dump(char * msg)

All public operations : dump , getEndPoint , getEndPoint , getEndPoint2 , getLength , set

#### 1.3.1.5 Class TArc

**************************************************************************
* \class TArc
\brief TArc
****************************************************************************

Declaration :

- C++ : class TArc

Artifact : TArc

Operation getInstance

Declaration :

- Uml : static, + getInstance() : TArc
- C++ : public: static TArc * getInstance()

Operation TArc

Declaration :

- Uml : # TArc() :
- C++ : protected: TArc()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : TArc= 0
- C++ : private: static TArc * _instance

Operation ~TArc

Declaration :

- Uml : + ~TArc() :
- C++ : public: virtual ~TArc()

Attribute arc360

Declaration :

- Uml : - arc360 : int
- C++ : private: int arc360

Attribute arc180

Declaration :

- Uml : - arc180 : int
- C++ : private: int arc180

Attribute m_sin

Declaration :

- Uml : - m_sin : float, multiplicity : [361]
- C++ : private: float m_sin[361]

Attribute m_cos

Declaration :

- Uml : - m_cos : float, multiplicity : [361]
- C++ : private: float m_cos[361]

Attribute m_tan

Declaration :

- Uml : - m_tan : float, multiplicity : [361]
- C++ : private: float m_tan[361]

Operation getSin

Declaration :

- Uml : + getSin(in w : int) : float
- C++ : public: float getSin(int w)

Operation getCos

Declaration :

- Uml : + getCos(in w : int) : float
- C++ : public: float getCos(int w)

Operation getTan

Declaration :

- Uml : + getTan(in w : int) : float
- C++ : public: float getTan(int w)

Operation norm

Declaration :

- Uml : + norm(in w : int) : int
- C++ : public: int norm(int w)

Operation grad2rad

Declaration :

- Uml : - grad2rad(in grad : float) : float
- C++ : private: float grad2rad(float grad)

All public operations : getCos , getInstance , getSin , getTan , norm

#### 1.3.1.6 Class Triangle

**************************************************************************
* \class Triangle
\brief Triangle
****************************************************************************

Declaration :

- C++ : class Triangle

Artifact : Triangle

Relation m_p0 (<directional composition>)

Eckpunkte des Dreiecks im 3D-Raum

Declaration :

- Uml : + m_p0 : Vec
- C++ : public: Vec m_p0

Relation m_p1 (<directional composition>)

Declaration :

- Uml : + m_p1 : Vec
- C++ : public: Vec m_p1

Relation m_p2 (<directional composition>)

Declaration :

- Uml : + m_p2 : Vec
- C++ : public: Vec m_p2

Attribute x

x0' (projiziert auf Plane)

Declaration :

- Uml : + x : float, multiplicity : [3]
- C++ : public: float x[3]

Attribute y

y0' (projiziert auf Plane)

Declaration :

- Uml : + y : float, multiplicity : [3]
- C++ : public: float y[3]

Attribute z

z0-Koordinate (im Raum)

Declaration :

- Uml : + z : float, multiplicity : [3]
- C++ : public: float z[3]

Attribute c

c0 ==> 1/z0-Koordinate (im Raum)

Declaration :

- Uml : + c : float, multiplicity : [3]
- C++ : public: float c[3]

Attribute uc

u * c0 (u Texelkoordinate in x-Richtung)

Declaration :

- Uml : + uc : float, multiplicity : [3]
- C++ : public: float uc[3]

Attribute vc

v * c0 (v Texelkoordinate in y-Richtung)

Declaration :

- Uml : + vc : float, multiplicity : [3]
- C++ : public: float vc[3]

Attribute m_u0

Eckpunkte der Texture

Declaration :

- Uml : + m_u0 : float
- C++ : public: float m_u0

Attribute m_v0

Declaration :

- Uml : + m_v0 : float
- C++ : public: float m_v0

Attribute m_u1

Declaration :

- Uml : + m_u1 : float
- C++ : public: float m_u1

Attribute m_v1

Declaration :

- Uml : + m_v1 : float
- C++ : public: float m_v1

Attribute m_u2

Declaration :

- Uml : + m_u2 : float
- C++ : public: float m_u2

Attribute m_v2

Declaration :

- Uml : + m_v2 : float
- C++ : public: float m_v2

Attribute m_xmax

Declaration :

- Uml : + m_xmax : int
- C++ : public: int m_xmax

Attribute m_ymax

Declaration :

- Uml : + m_ymax : int
- C++ : public: int m_ymax

Attribute m_alpha

Declaration :

- Uml : + m_alpha : int
- C++ : public: int m_alpha

Attribute m_sid

Declaration :

- Uml : + m_sid : long
- C++ : public: long m_sid

Attribute m_textureID

Declaration :

- Uml : + m_textureID : int
- C++ : public: int m_textureID

Relation m_tex (<unidirectional association>)

Declaration :

- Uml : + m_tex : Texture
- C++ : public: Texture * m_tex

Attribute m_ambientLight

Declaration :

- Uml : + m_ambientLight : float
- C++ : public: float m_ambientLight

Attribute m_directionalLight

Declaration :

- Uml : + m_directionalLight : float
- C++ : public: float m_directionalLight

Relation m_lightMap (<unidirectional association>)

Declaration :

- Uml : + m_lightMap : LightMap
- C++ : public: LightMap * m_lightMap

Operation Triangle

Declaration :

- Uml : + Triangle() :
- C++ : public: Triangle()

Operation ~Triangle

Declaration :

- Uml : + ~Triangle() :
- C++ : public: virtual ~Triangle()

Operation set

Declaration :

- Uml : + set(in textureID : int, inout v0 : Vec, inout v1 : Vec, inout v2 : Vec) : void
- C++ : public: void set(int textureID, Vec & v0, Vec & v1, Vec & v2)

Operation dump

Declaration :

- Uml : + dump() : void
- C++ : public: void dump()

All public operations : dump , set

#### 1.3.1.7 Class Vertex

**************************************************************************
* \class Vertex
\brief Vertex (Abgeleitet von einem Vec(tor) und um u,v Koordinaten erweitert)
****************************************************************************

Declaration :

- C++ : class Vertex : public Vec

Artifact : Vertex

Operation set

Declaration :

- Uml : + set(inout vertex : Vertex) : void
- C++ : public: void set(Vertex & vertex)

Operation set

Declaration :

- Uml : + set(inout vec : Vec) : void
- C++ : public: inline void set(Vec & vec)

Operation setUV

JAVA ist hier besser !!!

Declaration :

- Uml : + setUV(in u : float, in v : float) : void
- C++ : public: void setUV(float u, float v)

Operation Vertex

Declaration :

- Uml : + Vertex() :
- C++ : public: Vertex()

Operation ~Vertex

Declaration :

- Uml : + ~Vertex() :
- C++ : public: virtual ~Vertex()

Attribute m_u

Declaration :

- Uml : + m_u : float
- C++ : public: float m_u

Attribute m_v

Declaration :

- Uml : + m_v : float
- C++ : public: float m_v

All public operations : add , angle , clear , cross , div , dot , dump , getWinkelY , getZ , length , mul , mul , negative , normalize , rotateX , rotateY , rotateZ , set , set , set , set , setUV , sub , sub , transform , winkel

### 1.3.2 Deployment View math3d

Artifact Line

Stereotype: source

Artifact source associated with : Line

Artifact Matrix

Stereotype: source

Artifact source associated with : Matrix

Artifact Plane

Stereotype: source

Artifact source associated with : Plane

Artifact TArc

Stereotype: source

Artifact source associated with : TArc

Artifact Triangle

Stereotype: source

Artifact source associated with : Triangle

Artifact Vec

Stereotype: source

Artifact source associated with : Vec

Artifact Vertex

Stereotype: source

Artifact source associated with : Vertex

## 1.4 Package utils

### 1.4.1 Class View utils

#### 1.4.1.1 Class 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)
****************************************************************************

Declaration :

- C++ : class DataInputStream

Artifact : DataInputStream

Attribute p

Declaration :

- Uml : - p : FILE
- C++ : private: FILE * p

Operation DataInputStream

Declaration :

- Uml : + DataInputStream(inout fname : char) :
- C++ : public: DataInputStream(char * fname)

Operation read

Declaration :

- Uml : + read(inout buf : BYTE, in start : int, in len : int) : void
- C++ : public: void read(BYTE * buf, int start, int len)

Operation readInt

Declaration :

- Uml : + readInt(in : void) : int
- C++ : public: int readInt(void )

Operation readDouble

Declaration :

- Uml : + readDouble(in : void) : double
- C++ : public: double readDouble(void )

Operation close

Declaration :

- Uml : + close(in : void) : void
- C++ : public: void close(void )

Operation ~DataInputStream

Declaration :

- Uml : + ~DataInputStream() :
- C++ : public: virtual ~DataInputStream()

All public operations : close , read , readDouble , readInt

#### 1.4.1.2 Class DataOutputStream

**************************************************************************
* \class DataOutputStream
\brief DataOutputStream
****************************************************************************

Declaration :

- C++ : class DataOutputStream

Artifact : DataOutputStream

Attribute p

Declaration :

- Uml : - p : FILE
- C++ : private: FILE * p

Operation DataOutputStream

Declaration :

- Uml : + DataOutputStream(inout fname : char) :
- C++ : public: DataOutputStream(char * fname)

Operation write

Declaration :

- Uml : + write(inout buf : BYTE, in start : int, in len : int) : void
- C++ : public: void write(BYTE * buf, int start, int len)

Operation writeInt

Declaration :

- Uml : + writeInt(in val : int) : void
- C++ : public: void writeInt(int val)

Operation writeDouble

Declaration :

- Uml : + writeDouble(in val : double) : void
- C++ : public: void writeDouble(double val)

Operation close

Declaration :

- Uml : + close(in : void) : void
- C++ : public: void close(void )

Operation ~DataOutputStream

Declaration :

- Uml : + ~DataOutputStream() :
- C++ : public: virtual ~DataOutputStream()

All public operations : close , write , writeDouble , writeInt

#### 1.4.1.3 Class Timer

**************************************************************************
* \class Timer
\brief Allgemeine Klasse fuer einen hochaufloesenden Timer
(Plattformabhaengig, siehe WIN32 Sections)
****************************************************************************

Declaration :

- C++ : class Timer

Artifact : Timer

Operation Timer

Declaration :

- Uml : + Timer() :
- C++ : public: Timer()

Operation ~Timer

Declaration :

- Uml : + ~Timer() :
- C++ : public: virtual ~Timer()

Operation start

Declaration :

- Uml : + start(in : void) : void
- C++ : public: void start(void )

Operation end

Declaration :

- Uml : + end(in : void) : double
- C++ : public: double end(void )

Attribute m_freq

Declaration :

- Uml : - m_freq : LARGE_INTEGER
- C++ : private: LARGE_INTEGER m_freq

Attribute m_start

Declaration :

- Uml : - m_start : LARGE_INTEGER
- C++ : private: LARGE_INTEGER m_start

Attribute m_stop

Declaration :

- Uml : - m_stop : LARGE_INTEGER
- C++ : private: LARGE_INTEGER m_stop

All public operations : end , start

#### 1.4.1.4 Class Text

**************************************************************************
* \class Text
\brief Einfache Textklasse
****************************************************************************

Declaration :

- C++ : class Text

Artifact : Text

Operation Text

Declaration :

- Uml : + Text() :
- C++ : public: Text()

Operation Text

Declaration :

- Uml : + Text(in startX : int, in startY : int, inout text : char) :
- C++ : public: Text(int startX, int startY, char * text)

Operation ~Text

Declaration :

- Uml : + ~Text() :
- C++ : public: virtual ~Text()

Operation set

Declaration :

- Uml : + set(in startX : int, in startY : int, inout text : char) : void
- C++ : public: void set(int startX, int startY, char * text)

Attribute m_startX

Declaration :

- Uml : + m_startX : int
- C++ : public: int m_startX

Attribute m_startY

Declaration :

- Uml : + m_startY : int
- C++ : public: int m_startY

Attribute m_text

Declaration :

- Uml : + m_text : char
- C++ : public: char * m_text

Attribute m_len

Declaration :

- Uml : - m_len : int
- C++ : private: int m_len

Operation init

Declaration :

- Uml : - init(in : void) : void
- C++ : private: void init(void )

All public operations : set

#### 1.4.1.5 Class Logging

**************************************************************************
* \class Logging
\brief Einfache Logging-Klasse (noch nicht wirklich implementiert)
****************************************************************************

Declaration :

- C++ : class Logging

Artifact : Logging

Operation Logging

Declaration :

- Uml : + Logging() :
- C++ : public: Logging()

Operation Logging

Declaration :

- Uml : + Logging(inout fname : char) :
- C++ : public: Logging(char * fname)

Operation ~Logging

Declaration :

- Uml : + ~Logging() :
- C++ : public: virtual ~Logging()

Attribute m_msg

Declaration :

- Uml : + m_msg : char, multiplicity : [1024]
- C++ : public: char m_msg[1024]

Operation info

Declaration :

- Uml : + info(inout msg : char) : void
- C++ : public: void info(char * msg)

Operation debug

Declaration :

- Uml : + debug(inout msg : char) : void
- C++ : public: void debug(char * msg)

Operation error

Declaration :

- Uml : + error(inout msg : char) : void
- C++ : public: void error(char * msg)

Attribute m_logfile

Declaration :

- Uml : - m_logfile : char, multiplicity : [1024]
- C++ : private: char m_logfile[1024]

Operation write

Declaration :

- Uml : - write(inout msg : char) : void
- C++ : private: void write(char * msg)

All public operations : debug , error , info

#### 1.4.1.6 Class Trigger

**************************************************************************
* \class Trigger
\brief Zeitgesteuerte Zustandsklasse
****************************************************************************

Declaration :

- C++ : class Trigger

Artifact : Trigger

Operation Trigger

Declaration :

- Uml : + Trigger() :
- C++ : public: Trigger()

Operation Trigger

Declaration :

- Uml : + Trigger(in t : int) :
- C++ : public: Trigger(int t)

Operation ~Trigger

Declaration :

- Uml : + ~Trigger() :
- C++ : public: virtual ~Trigger()

Operation set

Declaration :

- Uml : + set(in t : int) : void
- C++ : public: void set(int t)

Operation isTriggered

Declaration :

- Uml : + isTriggered(in : void) : bool
- C++ : public: bool isTriggered(void )

Attribute m_triggerTime

Declaration :

- Uml : - m_triggerTime : ulong
- C++ : private: unsigned long m_triggerTime

Attribute m_startTime

Declaration :

- Uml : - m_startTime : ulong
- C++ : private: unsigned long m_startTime

All public operations : isTriggered , set

### 1.4.2 Deployment View utils

Artifact DataInputStream

Stereotype: source

Artifact source associated with : DataInputStream

Artifact DataOutputStream

Stereotype: source

Artifact source associated with : DataOutputStream

Artifact Logging

Stereotype: source

Artifact source associated with : Logging

Artifact Text

Stereotype: source

Artifact source associated with : Text

Artifact Timer

Stereotype: source

Artifact source associated with : Timer

Artifact Trigger

Stereotype: source

Artifact source associated with : Trigger

## 1.5 Package light

### 1.5.1 Class View light

#### 1.5.1.1 Class 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.
****************************************************************************

Declaration :

- C++ : class LightManager

Artifact : LightManager

Operation getInstance

Declaration :

- Uml : static, + getInstance() : LightManager
- C++ : public: static LightManager * getInstance()

Operation LightManager

Declaration :

- Uml : # LightManager() :
- C++ : protected: LightManager()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : LightManager= 0
- C++ : private: static LightManager * _instance

Operation ~LightManager

Declaration :

- Uml : + ~LightManager() :
- C++ : public: virtual ~LightManager()

Attribute m_AmbientON

Flag fuer ambientes Licht An/Aus

Declaration :

- Uml : - m_AmbientON : bool
- C++ : private: bool m_AmbientON

Attribute m_DirectionalON

Flag fuer directional Licht An/Aus

Declaration :

- Uml : - m_DirectionalON : bool
- C++ : private: bool m_DirectionalON

Attribute m_LightMapON

Flag fuer LightMap An/Aus

Declaration :

- Uml : - m_LightMapON : bool
- C++ : private: bool m_LightMapON

Relation lightZoneList (<unidirectional association>)

Declaration :

- Uml : + lightZoneList : LightZone
- C++ : public: std::vector<LightZone*> lightZoneList

Stereotype: std::vector

Relation lightMaps (<unidirectional association>)

Declaration :

- Uml : + lightMaps : LightMap
- C++ : public: std::vector<LightMap*> lightMaps

Stereotype: std::vector

Attribute m_gamma

private oder public??

Declaration :

- Uml : + m_gamma : float
- C++ : public: float m_gamma

Attribute m_gammaR

Declaration :

- Uml : + m_gammaR : int, multiplicity : [256]
- C++ : public: int m_gammaR[256]

Attribute m_gammaG

Declaration :

- Uml : + m_gammaG : int, multiplicity : [256]
- C++ : public: int m_gammaG[256]

Attribute m_gammaB

Declaration :

- Uml : + m_gammaB : int, multiplicity : [256]
- C++ : public: int m_gammaB[256]

Operation addEnvironment

Declaration :

- Uml : + addEnvironment(in zone : int, in ambient : float, in directionalMax : float, in pointMax : float) : void
- C++ : public: void addEnvironment(int zone, float ambient, float directionalMax, float pointMax)

Operation setDirectionalLight

Declaration :

- Uml : + setDirectionalLight(in zone : int, in dirX : float, in dirY : float, in dirZ : float) : void
- C++ : public: void setDirectionalLight(int zone, float dirX, float dirY, float dirZ)

Operation addPointLight

Declaration :

- Uml : + addPointLight(in zone : int, in x : float, in y : float, in z : float) : void
- C++ : public: void addPointLight(int zone, float x, float y, float z)

Operation calcPointLight

Declaration :

- Uml : + calcPointLight(inout tile : Tile, inout le : LightZone) : void
- C++ : public: void calcPointLight(Tile & tile, LightZone & le)

Operation calcLightMapGrid

Declaration :

- Uml : + calcLightMapGrid(inout tile : Tile) : void
- C++ : public: void calcLightMapGrid(Tile & tile)

Operation calcLightMap

Declaration :

- Uml : + calcLightMap(inout tile : Tile) : void
- C++ : public: void calcLightMap(Tile & tile)

Operation toggleAmbientLight

Declaration :

- Uml : + toggleAmbientLight() : void
- C++ : public: void toggleAmbientLight()

Operation toggleDirectionalLight

Declaration :

- Uml : + toggleDirectionalLight() : void
- C++ : public: void toggleDirectionalLight()

Operation toggleLightMap

Declaration :

- Uml : + toggleLightMap() : void
- C++ : public: void toggleLightMap()

Operation stepGamma

Declaration :

- Uml : + stepGamma(in up : bool) : void
- C++ : public: void stepGamma(bool up)

Operation isAmbientON

Declaration :

- Uml : + isAmbientON() : bool
- C++ : public: bool isAmbientON()

Operation isDirectionalON

Declaration :

- Uml : + isDirectionalON() : bool
- C++ : public: bool isDirectionalON()

Operation isLightMapON

Declaration :

- Uml : + isLightMapON() : bool
- C++ : public: bool isLightMapON()

Operation calcGamma

Declaration :

- Uml : + calcGamma(in gamma : float) : void
- C++ : public: void calcGamma(float gamma)

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

Operation save

Declaration :

- Uml : + save(in dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream dataOut)

Operation dump

Declaration :

- Uml : + dump() : void
- C++ : public: void dump()

Operation calcLightMapGrid

Declaration :

- Uml : - calcLightMapGrid(inout tile : Tile, inout le : LightZone) : void
- C++ : private: void calcLightMapGrid(Tile & tile, LightZone & le)

Operation getLightZone

Declaration :

- Uml : - getLightZone(in zone : int) : LightZone
- C++ : private: LightZone * getLightZone(int zone)

Operation calcDirectional

Declaration :

- Uml : - calcDirectional(inout tile : Tile, inout le : LightZone) : float
- C++ : private: float calcDirectional(Tile & tile, LightZone & le)

Operation calcLPs

Declaration :

- Uml : - calcLPs(inout lightPoints : std::vector<LightPoint*>, in x : float, in y : float, in z : float, in pointMax : float) : float
- C++ : private: float calcLPs(std::vector<LightPoint*> & lightPoints, float x, float y, float z, float pointMax)

Operation biInterpolate

Declaration :

- Uml : - biInterpolate(in q12 : int, in q22 : int, in q11 : int, in q21 : int, in x : int, in y : int) : BYTE
- C++ : private: BYTE biInterpolate(int q12, int q22, int q11, int q21, int x, int y)

All public operations : addEnvironment , addPointLight , calcGamma , calcLightMap , calcLightMapGrid , calcPointLight , dump , getInstance , isAmbientON , isDirectionalON , isLightMapON , load , save , setDirectionalLight , stepGamma , toggleAmbientLight , toggleDirectionalLight , toggleLightMap

#### 1.5.1.2 Class 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
****************************************************************************

Declaration :

- C++ : class LightZone

Artifact : LightZone

Attribute m_zone

Declaration :

- Uml : - m_zone : int
- C++ : private: int m_zone

Attribute m_ambient

Declaration :

- Uml : - m_ambient : float
- C++ : private: float m_ambient

Attribute m_directionalMax

Declaration :

- Uml : - m_directionalMax : float
- C++ : private: float m_directionalMax

Attribute m_pointMax

Declaration :

- Uml : - m_pointMax : float
- C++ : private: float m_pointMax

Relation m_dir (<directional composition>)

Declaration :

- Uml : + m_dir : Vec
- C++ : public: Vec m_dir

Relation lightPointList (<unidirectional association>)

Declaration :

- Uml : + lightPointList : LightPoint
- C++ : public: std::vector<LightPoint*> lightPointList

Stereotype: std::vector

Operation LightZone

Declaration :

- Uml : + LightZone(in zone : int) :
- C++ : public: LightZone(int zone)

Operation LightZone

Declaration :

- Uml : + LightZone(in zone : int, in ambient : float, in directionalMax : float, in pointMax : float) :
- C++ : public: LightZone(int zone, float ambient, float directionalMax, float pointMax)

Operation ~LightZone

Declaration :

- Uml : + ~LightZone() :
- C++ : public: virtual ~LightZone()

Operation set

Declaration :

- Uml : + set(in ambient : float, in directionalMax : float, in pointMax : float) : void
- C++ : public: void set(float ambient, float directionalMax, float pointMax)

Operation setDirectionalLight

Declaration :

- Uml : + setDirectionalLight(in dirX : float, in dirY : float, in dirZ : float) : void
- C++ : public: void setDirectionalLight(float dirX, float dirY, float dirZ)

Operation addPointLight

Declaration :

- Uml : + addPointLight(in posX : float, in posY : float, in posZ : float) : void
- C++ : public: void addPointLight(float posX, float posY, float posZ)

Operation getZone

Declaration :

- Uml : + getZone() : int
- C++ : public: int getZone()

Operation getAmbient

Declaration :

- Uml : + getAmbient() : float
- C++ : public: float getAmbient()

Operation getDirectionalMax

Declaration :

- Uml : + getDirectionalMax() : float
- C++ : public: float getDirectionalMax()

Operation getPointMax

Declaration :

- Uml : + getPointMax() : float
- C++ : public: float getPointMax()

Operation hasPointLights

Declaration :

- Uml : + hasPointLights() : bool
- C++ : public: bool hasPointLights()

Operation dump

Declaration :

- Uml : + dump() : void
- C++ : public: void dump()

Operation init

Declaration :

- Uml : - init(in zone : int) : void
- C++ : private: void init(int zone)

All public operations : addPointLight , dump , getAmbient , getDirectionalMax , getPointMax , getZone , hasPointLights , set , setDirectionalLight

#### 1.5.1.3 Class LightMap

**************************************************************************
* \class LightMap
\brief LightMap
****************************************************************************

Declaration :

- C++ : class LightMap

Artifact : LightMap

Attribute m_len

Declaration :

- Uml : + m_len : int
- C++ : public: int m_len

Attribute m_width

aka umax

Declaration :

- Uml : + m_width : int
- C++ : public: int m_width

Attribute m_height

aka vmax

Declaration :

- Uml : + m_height : int
- C++ : public: int m_height

Attribute m_map

Declaration :

- Uml : + m_map : BYTE
- C++ : public: BYTE * m_map

Operation LightMap

Declaration :

- Uml : + LightMap(in width : int, in height : int) :
- C++ : public: LightMap(int width, int height)

Operation ~LightMap

Declaration :

- Uml : + ~LightMap() :
- C++ : public: virtual ~LightMap()

Operation clear

Declaration :

- Uml : + clear() : void
- C++ : public: void clear()

Operation getMax

Declaration :

- Uml : + getMax() : BYTE
- C++ : public: BYTE getMax()

Operation set

Declaration :

- Uml : + set(in u : int, in v : int, in value : BYTE) : void
- C++ : public: void set(int u, int v, BYTE value)

Operation dump

Declaration :

- Uml : + dump() : void
- C++ : public: void dump()

All public operations : clear , dump , getMax , set

#### 1.5.1.4 Class LightPoint

**************************************************************************
* \class LightPoint
\brief Klasse fuer ein Punktlicht
****************************************************************************

Declaration :

- C++ : class LightPoint

Artifact : LightPoint

Relation m_pos (<directional composition>)

Declaration :

- Uml : + m_pos : Vec
- C++ : public: Vec m_pos

Attribute xs

Declaration :

- Uml : - xs : float
- C++ : private: float xs

Attribute ys

Declaration :

- Uml : - ys : float
- C++ : private: float ys

Attribute xe

Declaration :

- Uml : - xe : float
- C++ : private: float xe

Attribute ye

Declaration :

- Uml : - ye : float
- C++ : private: float ye

Attribute c

Declaration :

- Uml : - c : float
- C++ : private: float c

Attribute a

Declaration :

- Uml : - a : float
- C++ : private: float a

Operation LightPoint

Declaration :

- Uml : + LightPoint() :
- C++ : public: LightPoint()

Operation LightPoint

Declaration :

- Uml : + LightPoint(in posX : float, in posY : float, in posZ : float) :
- C++ : public: LightPoint(float posX, float posY, float posZ)

Operation ~LightPoint

Declaration :

- Uml : + ~LightPoint() :
- C++ : public: virtual ~LightPoint()

Operation set

Declaration :

- Uml : + set(in posX : float, in posY : float, in posZ : float) : void
- C++ : public: void set(float posX, float posY, float posZ)

Operation calcParameters

Declaration :

- Uml : + calcParameters(in xs : float, in ys : float, in xe : float, in ye : float) : void
- C++ : public: void calcParameters(float xs, float ys, float xe, float ye)

Operation calc

Declaration :

- Uml : + calc(in x : float) : float
- C++ : public: float calc(float x)

Operation getXS

Declaration :

- Uml : + getXS() : float
- C++ : public: float getXS()

Operation getYS

Declaration :

- Uml : + getYS() : float
- C++ : public: float getYS()

Operation getXE

Declaration :

- Uml : + getXE() : float
- C++ : public: float getXE()

Operation getYE

Declaration :

- Uml : + getYE() : float
- C++ : public: float getYE()

Operation dump

Declaration :

- Uml : + dump() : void
- C++ : public: void dump()

Operation dumpDiagram

Declaration :

- Uml : + dumpDiagram() : void
- C++ : public: void dumpDiagram()

Operation init

Declaration :

- Uml : - init() : void
- C++ : private: void init()

All public operations : calc , calcParameters , dump , dumpDiagram , getXE , getXS , getYE , getYS , set

### 1.5.2 Deployment View light

Artifact LightManager

Stereotype: source

Artifact source associated with : LightManager

Artifact LightMap

Stereotype: source

Artifact source associated with : LightMap

Artifact LightPoint

Stereotype: source

Artifact source associated with : LightPoint

Artifact LightZone

Stereotype: source

Artifact source associated with : LightZone

## 1.6 Package scene3d

### 1.6.1 Class View scene3d

#### 1.6.1.1 Class SkyBox

**************************************************************************
* \class SkyBox
\brief SkyBox Klasse
****************************************************************************

Declaration :

- C++ : class SkyBox

Artifact : SkyBox

Operation getInstance

Declaration :

- Uml : static, + getInstance() : SkyBox
- C++ : public: static SkyBox * getInstance()

Operation SkyBox

Declaration :

- Uml : # SkyBox() :
- C++ : protected: SkyBox()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : SkyBox= 0
- C++ : private: static SkyBox * _instance

Operation ~SkyBox

Declaration :

- Uml : + ~SkyBox() :
- C++ : public: virtual ~SkyBox()

Attribute TILE_COUNT

= 6

Declaration :

- Uml : static, + TILE_COUNT : int = (6), read only
- C++ : public: static const int TILE_COUNT

#### 1.6.1.1.1 Class SKYBOX_SIDES

Declaration :

- C++ : enum SKYBOX_SIDES

nested in SkyBox

Stereotype: enum

Items :

- TILE_LEFT
- TILE_FRONT
- TILE_DOWN
- TILE_TOP
- TILE_RIGHT
- TILE_BACK

Relation m_tiles (<unidirectional association>)

Declaration :

- Uml : + m_tiles : Tile, multiplicity : [6]
- C++ : public: Tile * m_tiles[6]

Operation setZone

Declaration :

- Uml : + setZone(in zone : int) : void
- C++ : public: void setZone(int zone)

Operation reset

Declaration :

- Uml : + reset() : void
- C++ : public: void reset()

Operation test

Declaration :

- Uml : + test(in zone : int) : void
- C++ : public: void test(int zone)

Operation test

Declaration :

- Uml : + test() : bool
- C++ : public: bool test()

Operation setLeft

Declaration :

- Uml : + setLeft(in textureID : int) : void
- C++ : public: void setLeft(int textureID)

Operation setFront

Declaration :

- Uml : + setFront(in textureID : int) : void
- C++ : public: void setFront(int textureID)

Operation setDown

Declaration :

- Uml : + setDown(in textureID : int) : void
- C++ : public: void setDown(int textureID)

Operation setTop

Declaration :

- Uml : + setTop(in textureID : int) : void
- C++ : public: void setTop(int textureID)

Operation setRight

Declaration :

- Uml : + setRight(in textureID : int) : void
- C++ : public: void setRight(int textureID)

Operation setBack

Declaration :

- Uml : + setBack(in textureID : int) : void
- C++ : public: void setBack(int textureID)

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

Operation save

Declaration :

- Uml : + save(inout dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream & dataOut)

Attribute m_zone

Declaration :

- Uml : - m_zone : int
- C++ : private: int m_zone

Attribute m_use

Declaration :

- Uml : - m_use : bool
- C++ : private: bool m_use

All public operations : getInstance , load , reset , save , setBack , setDown , setFront , setLeft , setRight , setTop , setZone , test , test

#### 1.6.1.2 Class AnimationManager

**************************************************************************
* \class AnimationManager
\brief Container fuer alle Animationen
****************************************************************************

Declaration :

- C++ : class AnimationManager

Artifact : AnimationManager

Operation getInstance

Declaration :

- Uml : static, + getInstance() : AnimationManager
- C++ : public: static AnimationManager * getInstance()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : AnimationManager= 0
- C++ : private: static AnimationManager * _instance

Operation AnimationManager

Declaration :

- Uml : # AnimationManager() :
- C++ : protected: AnimationManager()

Operation ~AnimationManager

Declaration :

- Uml : + ~AnimationManager() :
- C++ : public: virtual ~AnimationManager()

Relation m_animDummy (<directional composition>)

Declaration :

- Uml : - m_animDummy : Animation
- C++ : private: Animation m_animDummy

Relation m_animList (<unidirectional association>)

Declaration :

- Uml : - m_animList : Animation
- C++ : private: std::vector<Animation*> m_animList

Stereotype: std::vector

Operation clear

Declaration :

- Uml : + clear(in : void) : void
- C++ : public: void clear(void )

Operation add

Declaration :

- Uml : + add(in aID : int) : int
- C++ : public: int add(int aID)

Operation get

Declaration :

- Uml : + get(in aID : int) : Animation
- C++ : public: Animation * get(int aID)

Operation animate

Declaration :

- Uml : + animate(in : void) : void
- C++ : public: void animate(void )

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

Operation save

throws IOException;

Declaration :

- Uml : + save(inout dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream & dataOut)

All public operations : add , animate , clear , get , getInstance , load , save

#### 1.6.1.3 Class 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.
****************************************************************************

Declaration :

- C++ : class SurfaceCache

Artifact : SurfaceCache

Operation getInstance

Declaration :

- Uml : static, + getInstance() : SurfaceCache
- C++ : public: static SurfaceCache * getInstance()

Operation SurfaceCache

Declaration :

- Uml : # SurfaceCache() :
- C++ : protected: SurfaceCache()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : SurfaceCache= 0
- C++ : private: static SurfaceCache * _instance

Attribute m_usedCounter

Declaration :

- Uml : - m_usedCounter : int
- C++ : private: int m_usedCounter

Attribute m_sid

Declaration :

- Uml : - m_sid : long
- C++ : private: long m_sid

Relation m_surfaces (<unidirectional association>)

Declaration :

- Uml : - m_surfaces : Surface, multiplicity : [MAX_SURFACES]
- C++ : private: Surface * m_surfaces[MAX_SURFACES]

Attribute m_rgbIntensity

Declaration :

- Uml : - m_rgbIntensity : BYTE, multiplicity : [256][256]
- C++ : private: BYTE m_rgbIntensity[256][256]

Operation ~SurfaceCache

Declaration :

- Uml : + ~SurfaceCache(in : void) :
- C++ : public: ~SurfaceCache(void )

Operation refresh

Declaration :

- Uml : + refresh() : void
- C++ : public: void refresh()

Operation addSurface

Declaration :

- Uml : + addSurface(inout texture : Texture) : long
- C++ : public: long addSurface(Texture & texture)

Operation addSurface

Declaration :

- Uml : + addSurface(inout texture : Texture, inout lightMap : LightMap, in intensity : BYTE) : long
- C++ : public: long addSurface(Texture & texture, LightMap * lightMap, BYTE intensity)

Operation updateSurface

Declaration :

- Uml : + updateSurface(in sid : long, inout texture : Texture) : long
- C++ : public: long updateSurface(long sid, Texture & texture)

Operation updateSurface

Declaration :

- Uml : + updateSurface(in sid : long, inout texture : Texture, inout lightMap : LightMap, in intensity : BYTE) : long
- C++ : public: long updateSurface(long sid, Texture & texture, LightMap * lightMap, BYTE intensity)

Operation getSurface

Declaration :

- Uml : + getSurface(in sid : long) : Surface
- C++ : public: Surface * getSurface(long sid)

Operation getCount

Declaration :

- Uml : + getCount(in : void) : int
- C++ : public: int getCount(void )

All public operations : addSurface , addSurface , getCount , getInstance , getSurface , refresh , updateSurface , updateSurface

#### 1.6.1.4 Class 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.
****************************************************************************

Declaration :

- C++ : class Tile : public Plane

Artifact : Tile

#### 1.6.1.4.1 Class TILE_TYP

Declaration :

- C++ : enum TILE_TYP

nested in Tile

Stereotype: enum

Items :

- FLOOR
- WALL
- PORTAL

Attribute m_sid

SurfaceID

Declaration :

- Uml : + m_sid : long
- C++ : public: long m_sid

Attribute m_typ

Declaration :

- Uml : + m_typ : int
- C++ : public: int m_typ

Attribute m_textureID

Declaration :

- Uml : + m_textureID : int
- C++ : public: int m_textureID

Attribute m_name

TODO: war vorher String

Declaration :

- Uml : + m_name : char, multiplicity : [100]
- C++ : public: char m_name[100]

Attribute m_zoneTHIS

Declaration :

- Uml : + m_zoneTHIS : int
- C++ : public: int m_zoneTHIS

Attribute m_zoneOTHER

Declaration :

- Uml : + m_zoneOTHER : int
- C++ : public: int m_zoneOTHER

Attribute m_scrollFlag

Declaration :

- Uml : + m_scrollFlag : int
- C++ : public: int m_scrollFlag

Attribute m_animationID

Declaration :

- Uml : + m_animationID : int
- C++ : public: int m_animationID

Attribute m_d

Distanz vom Ursprung zur Plane

Declaration :

- Uml : + m_d : float
- C++ : public: float m_d

Attribute m_numVertices

Wird in der cpp-Datei auf 4 gesetzt

Declaration :

- Uml : + m_numVertices : int
- C++ : public: int m_numVertices

Relation m_vertexOrg (<unidirectional association>)

Declaration :

- Uml : + m_vertexOrg : Vertex
- C++ : public: Vertex * m_vertexOrg

Relation m_vertex (<unidirectional association>)

Declaration :

- Uml : + m_vertex : Vertex
- C++ : public: Vertex * m_vertex

Operation initialize

Die Tile besteht aus 4 Punkten. Sie kann potentiell
4 Planes des Frustums schneiden, d.h es koennen max.
8 Liniensegmente entstehen (plus dem letzten pseudo punkt

Declaration :

- Uml : - initialize() : void
- C++ : private: void initialize()

Attribute m_numClipVertices

Declaration :

- Uml : - m_numClipVertices : int
- C++ : private: int m_numClipVertices

Attribute m_maxFC

Anzahl der tatsaechlich ermittelten Vertices:

Declaration :

- Uml : + m_maxFC : int
- C++ : public: int m_maxFC

Relation m_vFC (<unidirectional association>)

Declaration :

- Uml : + m_vFC : Vertex
- C++ : public: Vertex * m_vFC

Attribute m_x

x' projiziert auf Plane

Declaration :

- Uml : + m_x : float
- C++ : public: float * m_x

Attribute m_y

y' projiziert auf Plane

Declaration :

- Uml : + m_y : float
- C++ : public: float * m_y

Attribute m_u

u Texelkoordinate in x-Richtung

Declaration :

- Uml : + m_u : float
- C++ : public: float * m_u

Attribute m_v

v Texelkoordinate in y-Richtung

Declaration :

- Uml : + m_v : float
- C++ : public: float * m_v

Attribute m_numTriangles

Declaration :

- Uml : - m_numTriangles : int
- C++ : private: int m_numTriangles

Attribute m_maxTri

Anzahl der tatsaechlich ermittelten Triangles:

Declaration :

- Uml : + m_maxTri : int
- C++ : public: int m_maxTri

Relation m_tri (<unidirectional association>)

Declaration :

- Uml : + m_tri : Triangle
- C++ : public: Triangle * m_tri

Attribute m_ambientLight

Declaration :

- Uml : + m_ambientLight : float
- C++ : public: float m_ambientLight

Attribute m_directionalLight

Declaration :

- Uml : + m_directionalLight : float
- C++ : public: float m_directionalLight

Relation m_lightMap (<unidirectional association>)

Declaration :

- Uml : + m_lightMap : LightMap
- C++ : public: LightMap * m_lightMap

Attribute m_minXDist2D

Declaration :

- Uml : + m_minXDist2D : float
- C++ : public: float m_minXDist2D

Attribute m_maxXDist2D

Declaration :

- Uml : + m_maxXDist2D : float
- C++ : public: float m_maxXDist2D

Attribute m_minYDist2D

Declaration :

- Uml : + m_minYDist2D : float
- C++ : public: float m_minYDist2D

Attribute m_maxYDist2D

Declaration :

- Uml : + m_maxYDist2D : float
- C++ : public: float m_maxYDist2D

Attribute m_minXDist3D

Declaration :

- Uml : + m_minXDist3D : float
- C++ : public: float m_minXDist3D

Attribute m_maxXDist3D

Declaration :

- Uml : + m_maxXDist3D : float
- C++ : public: float m_maxXDist3D

Attribute m_minYDist3D

Declaration :

- Uml : + m_minYDist3D : float
- C++ : public: float m_minYDist3D

Attribute m_maxYDist3D

Declaration :

- Uml : + m_maxYDist3D : float
- C++ : public: float m_maxYDist3D

Attribute m_minZDist3D

Declaration :

- Uml : + m_minZDist3D : float
- C++ : public: float m_minZDist3D

Attribute m_maxZDist3D

Declaration :

- Uml : + m_maxZDist3D : float
- C++ : public: float m_maxZDist3D

Attribute m_hasLightMapGrid

Declaration :

- Uml : + m_hasLightMapGrid : bool
- C++ : public: bool m_hasLightMapGrid

Attribute m_lightMapGrid

Declaration :

- Uml : + m_lightMapGrid : BYTE, multiplicity : [33][33]
- C++ : public: BYTE m_lightMapGrid[33][33]

Operation setLightMap

Declaration :

- Uml : + setLightMap(inout lightMap : LightMap) : void
- C++ : public: void setLightMap(LightMap * lightMap)

Operation Tile

Declaration :

- Uml : + Tile() :
- C++ : public: Tile()

Operation Tile

Declaration :

- Uml : + Tile(inout v0 : Vec, inout v1 : Vec, inout v2 : Vec, inout v3 : Vec, in typ : int, in zoneTHIS : int, in zoneOTHER : int, inout name : char) :
- C++ : public: Tile(Vec & v0, Vec & v1, Vec & v2, Vec & v3, int typ, int zoneTHIS, int zoneOTHER, char * name)

Operation ~Tile

Declaration :

- Uml : + ~Tile() :
- C++ : public: virtual ~Tile()

Operation set

Declaration :

- Uml : + set(inout t : Tile) : void
- C++ : public: void set(Tile & t)

Operation getZoneTHIS

Declaration :

- Uml : + getZoneTHIS() : int
- C++ : public: int getZoneTHIS()

Operation getZoneOTHER

Declaration :

- Uml : + getZoneOTHER() : int
- C++ : public: int getZoneOTHER()

Operation resetClipList

Declaration :

- Uml : + resetClipList() : void
- C++ : public: void resetClipList()

Operation resetVertices

Declaration :

- Uml : + resetVertices() : void
- C++ : public: void resetVertices()

Operation reverseVertices

Declaration :

- Uml : + reverseVertices() : void
- C++ : public: void reverseVertices()

Operation clip

Declaration :

- Uml : + clip(inout p : Plane) : void
- C++ : public: void clip(Plane & p)

Operation getTyp

Declaration :

- Uml : + getTyp() : int
- C++ : public: int getTyp()

Operation intersect

Declaration :

- Uml : + intersect(inout v0 : Vec, inout v1 : Vec) : bool
- C++ : public: bool intersect(Vec & v0, Vec & v1)

Operation transform

Declaration :

- Uml : + transform(inout mat : Matrix) : void
- C++ : public: void transform(Matrix & mat)

Operation project

Declaration :

- Uml : + project(in d : float) : void
- C++ : public: void project(float d)

Operation calcUV

Declaration :

- Uml : + calcUV() : void
- C++ : public: void calcUV()

Operation calcTexelVertices

Declaration :

- Uml : + calcTexelVertices() : void
- C++ : public: void calcTexelVertices()

Operation triangulate

Declaration :

- Uml : + triangulate() : void
- C++ : public: void triangulate()

Operation calcDistances

Declaration :

- Uml : + calcDistances(in d : float) : void
- C++ : public: void calcDistances(float d)

Operation getScrollFlag

Declaration :

- Uml : + getScrollFlag(in : void) : int
- C++ : public: int getScrollFlag(void )

Operation setScrollFlag

Declaration :

- Uml : + setScrollFlag(in scrollFlag : int) : void
- C++ : public: void setScrollFlag(int scrollFlag)

Operation dump

Declaration :

- Uml : + dump() : void
- C++ : public: void dump()

Operation save

Declaration :

- Uml : + save(inout dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream & dataOut)

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

All public operations : calcDistances , calcTexelVertices , calcUV , check , clear , clip , dump , dump , getInterLegth , getScrollFlag , getTyp , getZoneOTHER , getZoneTHIS , intersect , intersect , load , project , resetClipList , resetVertices , reverseVertices , save , set , set , setLightMap , setScrollFlag , transform , triangulate

#### 1.6.1.5 Class MaterialManager

**************************************************************************
* \class MaterialManager
\brief Container fuer alle Materialien
****************************************************************************

Declaration :

- C++ : class MaterialManager

Artifact : MaterialManager

Operation getInstance

Declaration :

- Uml : static, + getInstance() : MaterialManager
- C++ : public: static MaterialManager * getInstance()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : MaterialManager= 0
- C++ : private: static MaterialManager * _instance

Operation MaterialManager

Declaration :

- Uml : # MaterialManager() :
- C++ : protected: MaterialManager()

Operation ~MaterialManager

Declaration :

- Uml : + ~MaterialManager() :
- C++ : public: virtual ~MaterialManager()

Relation texList (<unidirectional association>)

Declaration :

- Uml : - texList : Texture
- C++ : private: std::vector<Texture*> texList

Stereotype: std::vector

Relation matList (<unidirectional association>)

Declaration :

- Uml : - matList : Material
- C++ : private: std::vector<Material*> matList

Stereotype: std::vector

Relation texDummy (<directional composition>)

Declaration :

- Uml : - texDummy : Texture
- C++ : private: Texture texDummy

Operation clear

Declaration :

- Uml : + clear(in : void) : void
- C++ : public: void clear(void )

Operation add

Declaration :

- Uml : + add(inout t : Texture) : void
- C++ : public: void add(Texture * t)

Operation add

Declaration :

- Uml : + add(in mid : int, in tid : int) : bool
- C++ : public: bool add(int mid, int tid)

Operation countTextures

Declaration :

- Uml : + countTextures(in : void) : int
- C++ : public: int countTextures(void )

Operation get

Declaration :

- Uml : + get(in index : int) : Texture
- C++ : public: Texture * get(int index)

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

Operation save

Declaration :

- Uml : + save(inout dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream & dataOut)

All public operations : add , add , clear , countTextures , get , getInstance , load , save

#### 1.6.1.6 Class Texture

**************************************************************************
* \class Texture
\brief Eine Texture
****************************************************************************

Declaration :

- C++ : class Texture : public Image

Artifact : Texture

Attribute m_time

Declaration :

- Uml : - m_time : ulong
- C++ : private: unsigned long m_time

Operation Texture

Declaration :

- Uml : + Texture() :
- C++ : public: Texture()

Operation ~Texture

Declaration :

- Uml : + ~Texture() :
- C++ : public: virtual ~Texture()

Operation scroll

Declaration :

- Uml : + scroll(in dir : int) : void
- C++ : public: void scroll(int dir)

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

Operation save

throws IOException;

Declaration :

- Uml : + save(inout dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream & dataOut)

All public operations : getAlpha , getHeight , getWidth , load , save , scroll , setAlpha , setImage

#### 1.6.1.7 Class Image

**************************************************************************
* \class Image
\brief Generische Klasse fuer Images, Bitmaps
***************************************************************************

Declaration :

- C++ : class Image

Directly inherited by : Sprite Surface Texture

Artifact : Image

#### 1.6.1.7.1 Class IMAGE_TYP

Declaration :

- C++ : enum IMAGE_TYP

nested in Image

Stereotype: enum

Items :

- UNKNOWN
- PALETTE
- RGB
- RGBA01
- RGBA256

Attribute m_typ

Declaration :

- Uml : + m_typ : int
- C++ : public: int m_typ

Attribute m_height

Declaration :

- Uml : + m_height : int
- C++ : public: int m_height

Attribute m_width

Declaration :

- Uml : + m_width : int
- C++ : public: int m_width

Attribute m_shift

Declaration :

- Uml : + m_shift : int
- C++ : public: int m_shift

Attribute m_alpha

Declaration :

- Uml : + m_alpha : int
- C++ : public: int m_alpha

Attribute m_rgbLUT

Declaration :

- Uml : + m_rgbLUT : BYTE
- C++ : public: BYTE * m_rgbLUT

Attribute m_indexArray

Declaration :

- Uml : + m_indexArray : BYTE
- C++ : public: BYTE * m_indexArray

Operation Image

Declaration :

- Uml : + Image() :
- C++ : public: Image()

Operation ~Image

Declaration :

- Uml : + ~Image(in : void) :
- C++ : public: ~Image(void )

Operation setImage

Declaration :

- Uml : + setImage(in typ : IMAGE_TYP, in width : int, in height : int) : void
- C++ : public: void setImage(IMAGE_TYP typ, int width, int height)

Operation getHeight

Declaration :

- Uml : + getHeight(in : void) : int
- C++ : public: int getHeight(void )

Operation getWidth

Declaration :

- Uml : + getWidth(in : void) : int
- C++ : public: int getWidth(void )

Operation getAlpha

Declaration :

- Uml : + getAlpha(in : void) : int
- C++ : public: int getAlpha(void )

Operation setAlpha

Declaration :

- Uml : + setAlpha(in alpha : int) : void
- C++ : public: void setAlpha(int alpha)

Operation setShift

Declaration :

- Uml : - setShift(in : void) : void
- C++ : private: void setShift(void )

All public operations : getAlpha , getHeight , getWidth , setAlpha , setImage

#### 1.6.1.8 Class 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
***************************************************************************

Declaration :

- C++ : class Surface : public Image

Artifact : Surface

Attribute m_sid

Declaration :

- Uml : + m_sid : ulong
- C++ : public: unsigned long m_sid

Attribute m_counter

Declaration :

- Uml : + m_counter : int
- C++ : public: int m_counter

Operation Surface

Declaration :

- Uml : + Surface(in sid : ulong, inout texture : Texture) :
- C++ : public: Surface(unsigned long sid, Texture & texture)

Operation Surface

Declaration :

- Uml : + Surface(in sid : ulong, inout texture : Texture, inout lightmap : LightMap, in rgbIntensity : BYTE, in intensity : BYTE) :
- C++ : public: Surface(unsigned long sid, Texture & texture, LightMap * lightmap, BYTE rgbIntensity[256], BYTE intensity)

Operation ~Surface

Declaration :

- Uml : + ~Surface(in : void) :
- C++ : public: ~Surface(void )

Operation init

Declaration :

- Uml : - init(in sid : ulong, inout texture : Texture) : void
- C++ : private: void init(unsigned long sid, Texture & texture)

All public operations : getAlpha , getHeight , getWidth , setAlpha , setImage

#### 1.6.1.9 Class Animation

**************************************************************************
* \class Animation
\brief Zustandklasse fuer eine Animation
****************************************************************************

Declaration :

- C++ : class Animation

Artifact : Animation

#### 1.6.1.9.1 Class anonymous1

Declaration :

- C++ : enum

nested in Animation

Stereotype: enum

Items :

- ANIM_STOP
- ANIM_RUN
- ANIM_FORWARD
- ANIM_BACKWARD
- ANIM_ROTATE
- ANIM_FWD_BACK
- ANIM_WAIT
- ANIM_FWD_WAIT_BACK_STOP

Relation m_stepVec (<directional composition>)

Declaration :

- Uml : - m_stepVec : Vec
- C++ : private: Vec m_stepVec

Attribute m_aID

Declaration :

- Uml : - m_aID : int
- C++ : private: int m_aID

Attribute m_aID2

Declaration :

- Uml : - m_aID2 : int
- C++ : private: int m_aID2

Attribute m_dir

Declaration :

- Uml : - m_dir : int
- C++ : private: int m_dir

Attribute m_len

Declaration :

- Uml : - m_len : int
- C++ : private: int m_len

Attribute m_status

Declaration :

- Uml : - m_status : int
- C++ : private: int m_status

Attribute m_mode

Declaration :

- Uml : - m_mode : int
- C++ : private: int m_mode

Attribute m_waitMax

Declaration :

- Uml : - m_waitMax : int
- C++ : private: int m_waitMax

Attribute m_waitCount

Declaration :

- Uml : - m_waitCount : int
- C++ : private: int m_waitCount

Operation reset

Declaration :

- Uml : - reset(in : void) : void
- C++ : private: void reset(void )

Relation m_dirVec (<directional composition>)

Declaration :

- Uml : + m_dirVec : Vec
- C++ : public: Vec m_dirVec

Operation Animation

Declaration :

- Uml : + Animation() :
- C++ : public: Animation()

Operation Animation

Declaration :

- Uml : + Animation(in aID : int) :
- C++ : public: Animation(int aID)

Operation runForward

Declaration :

- Uml : + runForward(in : void) : void
- C++ : public: void runForward(void )

Operation runForwardBackward

Declaration :

- Uml : + runForwardBackward() : void
- C++ : public: void runForwardBackward()

Operation runForwardWaitBackwardStop

Declaration :

- Uml : + runForwardWaitBackwardStop() : void
- C++ : public: void runForwardWaitBackwardStop()

Operation stop

Declaration :

- Uml : + stop() : void
- C++ : public: void stop()

Operation doStep

Declaration :

- Uml : + doStep() : void
- C++ : public: void doStep()

Operation translate

Declaration :

- Uml : + translate(inout tile : Tile) : void
- C++ : public: void translate(Tile & tile)

Operation getID

Declaration :

- Uml : + getID(in : void) : int
- C++ : public: int getID(void )

Operation getID2

Declaration :

- Uml : + getID2(in : void) : int
- C++ : public: int getID2(void )

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

Operation save

throws IOException;

Declaration :

- Uml : + save(inout dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream & dataOut)

Operation ~Animation

throws IOException;

Declaration :

- Uml : + ~Animation() :
- C++ : public: virtual ~Animation()

All public operations : doStep , getID , getID2 , load , runForward , runForwardBackward , runForwardWaitBackwardStop , save , stop , translate

#### 1.6.1.10 Class Material

**************************************************************************
* \class Material
\brief Container fuer ein Material
****************************************************************************

Declaration :

- C++ : class Material

Artifact : Material

Attribute m_mid

Declaration :

- Uml : - m_mid : int
- C++ : private: int m_mid

Attribute m_textureList

Declaration :

- Uml : - m_textureList : int
- C++ : private: std::vector<int> m_textureList

Stereotype: std::vector

Attribute m_time

Declaration :

- Uml : - m_time : ulong
- C++ : private: unsigned long m_time

Attribute m_index

Declaration :

- Uml : - m_index : int
- C++ : private: int m_index

Operation Material

Declaration :

- Uml : + Material() :
- C++ : public: Material()

Operation ~Material

Declaration :

- Uml : + ~Material() :
- C++ : public: virtual ~Material()

Operation getID

Declaration :

- Uml : + getID(in : void) : int
- C++ : public: int getID(void )

Operation getTID

Declaration :

- Uml : + getTID(in : void) : int
- C++ : public: int getTID(void )

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

Operation save

throws IOException;

Declaration :

- Uml : + save(inout dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream & dataOut)

All public operations : getID , getTID , load , save

### 1.6.2 Deployment View scene3d

Artifact Animation

Stereotype: source

Artifact source associated with : Animation

Artifact AnimationManager

Stereotype: source

Artifact source associated with : AnimationManager

Artifact Image

Stereotype: source

Artifact source associated with : Image

Artifact Material

Stereotype: source

Artifact source associated with : Material

Artifact MaterialManager

Stereotype: source

Artifact source associated with : MaterialManager

Artifact SkyBox

Stereotype: source

Artifact source associated with : SkyBox

Artifact Surface

Stereotype: source

Artifact source associated with : Surface

Artifact SurfaceCache

Stereotype: source

Artifact source associated with : SurfaceCache

Artifact Texture

Stereotype: source

Artifact source associated with : Texture

Artifact Tile

Stereotype: source

Artifact source associated with : Tile

## 1.7 Package partikel

### 1.7.1 Class View partikel

#### 1.7.1.1 Class PartikelManager

**************************************************************************
* \class PartikelManager
\brief Muesste eigentlich PartikelSystemManger heissen. Es verwaltet alle
Partikelsysteme und alle Sprites, die fuer die Darstellung der
einzelnen Partikel gebraucht werden.
****************************************************************************

Declaration :

- C++ : class PartikelManager

Artifact : PartikelManager

Operation getInstance

Declaration :

- Uml : static, + getInstance() : PartikelManager
- C++ : public: static PartikelManager * getInstance()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : PartikelManager= 0
- C++ : private: static PartikelManager * _instance

Operation PartikelManager

Declaration :

- Uml : # PartikelManager() :
- C++ : protected: PartikelManager()

Operation ~PartikelManager

Declaration :

- Uml : + ~PartikelManager() :
- C++ : public: virtual ~PartikelManager()

Relation m_spriteList (<unidirectional association>)

Declaration :

- Uml : + m_spriteList : Sprite
- C++ : public: std::vector<Sprite*> m_spriteList

Stereotype: std::vector

Relation m_partikelSystemList (<unidirectional association>)

Declaration :

- Uml : + m_partikelSystemList : PartikelSystem
- C++ : public: std::vector<PartikelSystem*> m_partikelSystemList

Stereotype: std::vector

Operation clear

Declaration :

- Uml : - clear(in : void) : void
- C++ : private: void clear(void )

Operation transform

Declaration :

- Uml : + transform(inout matTranslate : Matrix, inout matRotate : Matrix) : void
- C++ : public: void transform(Matrix & matTranslate, Matrix & matRotate)

Operation project

Declaration :

- Uml : + project(in nearDist : float, in farDist : float) : void
- C++ : public: void project(float nearDist, float farDist)

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

Operation save

Declaration :

- Uml : + save(inout dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream & dataOut)

All public operations : getInstance , load , project , save , transform

#### 1.7.1.2 Class 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)
****************************************************************************

Declaration :

- C++ : class Partikel : public Object2D

Artifact : Partikel

#### 1.7.1.2.1 Class ACTION

Declaration :

- C++ : enum ACTION

nested in Partikel

Stereotype: enum

Items :

- RESPAWN_AT_EMITTER
- NO_RESPAWN
- RESPAWN_REFLECTON

#### 1.7.1.2.2 Class LIFECYCLE

Declaration :

- C++ : enum LIFECYCLE

nested in Partikel

Stereotype: enum

Items :

- IS_OFF
- IS_ON
- SWITCH_OFF
- SWITCH_ON
- IS_DEAD

Operation Partikel

Declaration :

- Uml : + Partikel(in zone : int, in action : int) :
- C++ : public: Partikel(int zone, int action)

Operation ~Partikel

Declaration :

- Uml : + ~Partikel() :
- C++ : public: virtual ~Partikel()

Operation setMotion

Declaration :

- Uml : + setMotion(inout startpos : Vec, inout velocity : Vec, inout force : Vec) : void
- C++ : public: void setMotion(Vec & startpos, Vec & velocity, Vec & force)

Operation setMotion

Declaration :

- Uml : + setMotion(inout startpos : Vec, inout randomMin : Vec, inout randomMax : Vec, in speed : float, inout force : Vec) : void
- C++ : public: void setMotion(Vec & startpos, Vec & randomMin, Vec & randomMax, float speed, Vec & force)

Operation setONtime

Declaration :

- Uml : + setONtime(in ontime : int) : void
- C++ : public: void setONtime(int ontime)

Operation setOFFtime

Declaration :

- Uml : + setOFFtime(in offtime : int) : void
- C++ : public: void setOFFtime(int offtime)

Operation getONtime

Declaration :

- Uml : + getONtime() : float
- C++ : public: float getONtime()

Operation setFading

Declaration :

- Uml : + setFading(in fading : bool) : void
- C++ : public: void setFading(bool fading)

Operation setROLLtime

Declaration :

- Uml : + setROLLtime(in rolltime : int) : void
- C++ : public: void setROLLtime(int rolltime)

Operation animate

Declaration :

- Uml : + animate(in : void) : void
- C++ : public: void animate(void )

Operation isON

Declaration :

- Uml : + isON(in : void) : bool
- C++ : public: bool isON(void )

Operation addSprite

Declaration :

- Uml : + addSprite(inout sprite : Sprite) : void
- C++ : public: void addSprite(Sprite * sprite)

Operation querySprite

Declaration :

- Uml : + querySprite(in : void) : void
- C++ : public: void querySprite(void )

Attribute m_isScale

Declaration :

- Uml : + m_isScale : bool
- C++ : public: bool m_isScale

Attribute m_isFading

Declaration :

- Uml : + m_isFading : bool
- C++ : public: bool m_isFading

Relation m_sprite (<unidirectional association>)

Declaration :

- Uml : + m_sprite : Sprite
- C++ : public: Sprite * m_sprite

Operation calcVelocity

Declaration :

- Uml : - calcVelocity(in : void) : void
- C++ : private: void calcVelocity(void )

Operation refreshStatus

Declaration :

- Uml : - refreshStatus(in : void) : int
- C++ : private: int refreshStatus(void )

Attribute m_zone

Declaration :

- Uml : - m_zone : int
- C++ : private: int m_zone

Relation m_emitterPos (<directional composition>)

Position des Emitters

Declaration :

- Uml : - m_emitterPos : Vec
- C++ : private: Vec m_emitterPos

Relation m_velocity (<directional composition>)

aktuelle Richtung- bzw. Geschwindigkeitsvektor

Declaration :

- Uml : - m_velocity : Vec
- C++ : private: Vec m_velocity

Relation m_randomMin (<directional composition>)

Declaration :

- Uml : - m_randomMin : Vec
- C++ : private: Vec m_randomMin

Relation m_randomMax (<directional composition>)

Declaration :

- Uml : - m_randomMax : Vec
- C++ : private: Vec m_randomMax

Relation m_force (<directional composition>)

Kraftvektor, der auf das Partikel einwirkt (Wind, Gravitation)

Declaration :

- Uml : - m_force : Vec
- C++ : private: Vec m_force

Attribute m_frames

Declaration :

- Uml : - m_frames : float
- C++ : private: float m_frames

Attribute m_useSpeed

Declaration :

- Uml : - m_useSpeed : bool
- C++ : private: bool m_useSpeed

Attribute m_speed

Declaration :

- Uml : - m_speed : float
- C++ : private: float m_speed

Attribute m_ONtime

Dauer der ON-Zeit (0 == Unendlich!!)

Declaration :

- Uml : - m_ONtime : ulong
- C++ : private: unsigned long m_ONtime

Attribute m_ONstart

Declaration :

- Uml : - m_ONstart : ulong
- C++ : private: unsigned long m_ONstart

Attribute m_OFFtime

Dauer der OFF-Zeit

Declaration :

- Uml : - m_OFFtime : ulong
- C++ : private: unsigned long m_OFFtime

Attribute m_OFFstart

Declaration :

- Uml : - m_OFFstart : ulong
- C++ : private: unsigned long m_OFFstart

Attribute m_ROLLtime

Declaration :

- Uml : - m_ROLLtime : ulong
- C++ : private: unsigned long m_ROLLtime

Attribute m_ROLLstart

Declaration :

- Uml : - m_ROLLstart : ulong
- C++ : private: unsigned long m_ROLLstart

Attribute m_status

Declaration :

- Uml : - m_status : int
- C++ : private: int m_status

Attribute m_action

Declaration :

- Uml : - m_action : int
- C++ : private: int m_action

Attribute m_spriteCount

Declaration :

- Uml : - m_spriteCount : int
- C++ : private: int m_spriteCount

Relation m_spriteOrg (<unidirectional association>)

Declaration :

- Uml : - m_spriteOrg : Sprite, multiplicity : [50]
- C++ : private: Sprite * m_spriteOrg[50]

Attribute m_currSpriteID

Declaration :

- Uml : - m_currSpriteID : int
- C++ : private: int m_currSpriteID

All public operations : addSprite , animate , getONtime , isON , project , querySprite , scaleEnable , setFading , setMotion , setMotion , setOFFtime , setONtime , setPos , setROLLtime , setScale , setSize , transform

#### 1.7.1.3 Class Object2D

**************************************************************************
* \class Object2D
\brief Beschreibt ein rechteckiges 2D-Objekt im 3D-Raum (typ. Sprites,
Partikel...)
****************************************************************************

Declaration :

- C++ : class Object2D

Directly inherited by : Partikel

Artifact : Object2D

Operation Object2D

Declaration :

- Uml : + Object2D() :
- C++ : public: Object2D()

Operation ~Object2D

Declaration :

- Uml : + ~Object2D() :
- C++ : public: virtual ~Object2D()

Relation m_startPosOrg (<directional composition>)

Position im 3D-Raum

Declaration :

- Uml : + m_startPosOrg : Vec
- C++ : public: Vec m_startPosOrg

Attribute m_height

Hoehe des 2D-Objektes

Declaration :

- Uml : + m_height : float
- C++ : public: float m_height

Attribute m_width

Breite des 2D-Objektes

Declaration :

- Uml : + m_width : float
- C++ : public: float m_width

Attribute m_scaleEnable

Declaration :

- Uml : + m_scaleEnable : bool
- C++ : public: bool m_scaleEnable

Relation m_pos (<directional composition>)

Position in 3D-Raum transformiert zur Camera

Declaration :

- Uml : + m_pos : Vec
- C++ : public: Vec m_pos

Attribute m_u

Punkt Mitte

Declaration :

- Uml : + m_u : float
- C++ : public: float m_u

Attribute m_v

Declaration :

- Uml : + m_v : float
- C++ : public: float m_v

Attribute m_u0

Punkt oben links

Declaration :

- Uml : + m_u0 : float
- C++ : public: float m_u0

Attribute m_v0

Declaration :

- Uml : + m_v0 : float
- C++ : public: float m_v0

Attribute m_u1

Punkt oben rechts

Declaration :

- Uml : + m_u1 : float
- C++ : public: float m_u1

Attribute m_v1

Declaration :

- Uml : + m_v1 : float
- C++ : public: float m_v1

Attribute m_u2

Punkt unten rechts

Declaration :

- Uml : + m_u2 : float
- C++ : public: float m_u2

Attribute m_v2

Declaration :

- Uml : + m_v2 : float
- C++ : public: float m_v2

Attribute m_u3

Punkt unten links

Declaration :

- Uml : + m_u3 : float
- C++ : public: float m_u3

Attribute m_v3

Declaration :

- Uml : + m_v3 : float
- C++ : public: float m_v3

Attribute m_scale

Declaration :

- Uml : + m_scale : float
- C++ : public: float m_scale

Operation setPos

Declaration :

- Uml : + setPos(inout vec : Vec) : void
- C++ : public: void setPos(Vec & vec)

Operation setSize

Declaration :

- Uml : + setSize(in width : float, in height : float) : void
- C++ : public: void setSize(float width, float height)

Operation scaleEnable

Declaration :

- Uml : + scaleEnable(in scaleEnable : bool) : void
- C++ : public: void scaleEnable(bool scaleEnable)

Operation setScale

Declaration :

- Uml : + setScale(in scale : float) : void
- C++ : public: void setScale(float scale)

Operation transform

Declaration :

- Uml : + transform(inout matTranslate : Matrix, inout matRotate : Matrix) : void
- C++ : public: void transform(Matrix & matTranslate, Matrix & matRotate)

Operation project

Declaration :

- Uml : + project(in nearDist : float, in farDist : float) : bool
- C++ : public: bool project(float nearDist, float farDist)

All public operations : project , scaleEnable , setPos , setScale , setSize , transform

#### 1.7.1.4 Class 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.
****************************************************************************

Declaration :

- C++ : class Sprite : public Image

Artifact : Sprite

Attribute m_indexSize

Declaration :

- Uml : - m_indexSize : int
- C++ : private: int m_indexSize

Attribute m_delta

Declaration :

- Uml : - m_delta : float
- C++ : private: float m_delta

Operation Sprite

Declaration :

- Uml : + Sprite() :
- C++ : public: Sprite()

Operation set

Declaration :

- Uml : + set(inout sprite : Sprite, in delta : float) : void
- C++ : public: void set(Sprite * sprite, float delta)

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

Operation save

throws IOException;

Declaration :

- Uml : + save(inout dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream & dataOut)

Operation ~Sprite

throws IOException;

Declaration :

- Uml : + ~Sprite() :
- C++ : public: virtual ~Sprite()

All public operations : getAlpha , getHeight , getWidth , load , save , set , setAlpha , setImage

#### 1.7.1.5 Class PartikelSystem

**************************************************************************
* \class PartikelSystem
\brief Ein Partikelsystem beschreibt das Verhalten von Partikeln, die zu
diesem System gehoeren.
****************************************************************************

Declaration :

- C++ : class PartikelSystem

Artifact : PartikelSystem

Operation PartikelSystem

Declaration :

- Uml : + PartikelSystem() :
- C++ : public: PartikelSystem()

Operation ~PartikelSystem

Declaration :

- Uml : + ~PartikelSystem() :
- C++ : public: virtual ~PartikelSystem()

Attribute m_zone

Declaration :

- Uml : + m_zone : int
- C++ : public: int m_zone

Relation m_partikelList (<unidirectional association>)

Declaration :

- Uml : + m_partikelList : Partikel
- C++ : public: std::vector<Partikel*> m_partikelList

Stereotype: std::vector

Attribute m_typ

Declaration :

- Uml : - m_typ : int
- C++ : private: int m_typ

Attribute m_respawn

Declaration :

- Uml : - m_respawn : bool
- C++ : private: bool m_respawn

Attribute m_maxPartikel

Declaration :

- Uml : - m_maxPartikel : int
- C++ : private: int m_maxPartikel

Attribute m_lifeTime

Declaration :

- Uml : - m_lifeTime : ulong
- C++ : private: unsigned long m_lifeTime

Relation m_startPosOrg (<directional composition>)

Declaration :

- Uml : - m_startPosOrg : Vec
- C++ : private: Vec m_startPosOrg

Relation m_startPos (<directional composition>)

Declaration :

- Uml : - m_startPos : Vec
- C++ : private: Vec m_startPos

Attribute m_nearDist

Declaration :

- Uml : - m_nearDist : float
- C++ : private: float m_nearDist

Attribute m_farDist

Declaration :

- Uml : - m_farDist : float
- C++ : private: float m_farDist

Attribute m_spriteCount

Declaration :

- Uml : - m_spriteCount : int
- C++ : private: int m_spriteCount

Attribute m_spriteID

Declaration :

- Uml : - m_spriteID : int, multiplicity : [50]
- C++ : private: int m_spriteID[50]

Operation clear

Declaration :

- Uml : - clear(in : void) : void
- C++ : private: void clear(void )

Operation getRandom

Declaration :

- Uml : - getRandom(in max : int) : float
- C++ : private: float getRandom(int max)

Operation init_0

Declaration :

- Uml : - init_0(in : void) : void
- C++ : private: void init_0(void )

Operation init_1

Declaration :

- Uml : - init_1(in : void) : void
- C++ : private: void init_1(void )

Operation init_2

Declaration :

- Uml : - init_2(in : void) : void
- C++ : private: void init_2(void )

Operation init_3

Declaration :

- Uml : - init_3(in : void) : void
- C++ : private: void init_3(void )

Operation init_4

Declaration :

- Uml : - init_4(in : void) : void
- C++ : private: void init_4(void )

Operation init_5

Declaration :

- Uml : - init_5(in : void) : void
- C++ : private: void init_5(void )

Operation init_6

Declaration :

- Uml : - init_6(in : void) : void
- C++ : private: void init_6(void )

Operation init_7

Declaration :

- Uml : - init_7(in : void) : void
- C++ : private: void init_7(void )

Operation animate

Declaration :

- Uml : + animate(in : void) : void
- C++ : public: void animate(void )

Operation transform

Declaration :

- Uml : + transform(inout matTranslate : Matrix, inout matRotate : Matrix) : void
- C++ : public: void transform(Matrix & matTranslate, Matrix & matRotate)

Operation project

Declaration :

- Uml : + project(in nearDist : float, in farDist : float) : void
- C++ : public: void project(float nearDist, float farDist)

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

Operation init

Declaration :

- Uml : + init(inout spriteList : std::vector<Sprite*>) : void
- C++ : public: void init(std::vector<Sprite*> & spriteList)

Operation save

Declaration :

- Uml : + save(inout dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream & dataOut)

All public operations : animate , init , load , project , save , transform

### 1.7.2 Deployment View partikel

Artifact Object2D

Stereotype: source

Artifact source associated with : Object2D

Artifact Partikel

Stereotype: source

Artifact source associated with : Partikel

Artifact PartikelManager

Stereotype: source

Artifact source associated with : PartikelManager

Artifact PartikelSystem

Stereotype: source

Artifact source associated with : PartikelSystem

Artifact Sprite

Stereotype: source

Artifact source associated with : Sprite

## 1.8 Package renderer

### 1.8.1 Class View renderer

#### 1.8.1.1 Class Renderer

**************************************************************************
* \class Renderer
\brief Die Hauptklasse der Renderer 3D Engine
Dieser Klasse beinhaltet ALLE Methoden, die fuer die Nutzung
der Engine benoetigt werden.
****************************************************************************

Declaration :

- C++ : class Renderer

Artifact : Renderer

Operation getInstance

Declaration :

- Uml : static, + getInstance() : Renderer
- C++ : public: static Renderer * getInstance()

Operation Renderer

Declaration :

- Uml : # Renderer() :
- C++ : protected: Renderer()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : Renderer= 0
- C++ : private: static Renderer * _instance

Operation ~Renderer

Declaration :

- Uml : + ~Renderer() :
- C++ : public: virtual ~Renderer()

Attribute m_drawInfo

Declaration :

- Uml : - m_drawInfo : bool
- C++ : private: bool m_drawInfo

Relation m_frustum (<unidirectional association>)

Declaration :

- Uml : - m_frustum : Frustum
- C++ : private: Frustum * m_frustum

Relation m_textureMapper (<unidirectional association>)

Declaration :

- Uml : - m_textureMapper : TextureMapper
- C++ : private: TextureMapper * m_textureMapper

Relation m_textMapper (<unidirectional association>)

Declaration :

- Uml : - m_textMapper : TextMapper
- C++ : private: TextMapper * m_textMapper

Relation m_surfaceCache (<unidirectional association>)

Declaration :

- Uml : - m_surfaceCache : SurfaceCache
- C++ : private: SurfaceCache * m_surfaceCache

Relation m_spriteMapper (<unidirectional association>)

Declaration :

- Uml : - m_spriteMapper : SpriteMapper
- C++ : private: SpriteMapper * m_spriteMapper

Attribute m_height

Declaration :

- Uml : - m_height : int
- C++ : private: int m_height

Attribute m_width

Declaration :

- Uml : - m_width : int
- C++ : private: int m_width

Attribute m_PlanePixels

Declaration :

- Uml : - m_PlanePixels : BYTE
- C++ : private: BYTE * m_PlanePixels

Attribute m_ZBuffer

Declaration :

- Uml : - m_ZBuffer : float
- C++ : private: float * m_ZBuffer

Attribute m_isRendererInitialized

Declaration :

- Uml : - m_isRendererInitialized : bool
- C++ : private: bool m_isRendererInitialized

Operation initRenderer

Declaration :

- Uml : + initRenderer(in width : int, in height : int, inout data : BYTE) : void
- C++ : public: void initRenderer(int width, int height, BYTE * data)

Operation renderFrame

Declaration :

- Uml : + renderFrame() : void
- C++ : public: void renderFrame()

Operation clearZBuffer

Declaration :

- Uml : + clearZBuffer(in : void) : void
- C++ : public: void clearZBuffer(void )

Operation renderTiles

Declaration :

- Uml : + renderTiles(inout tileList : std::vector<Tile*>) : void
- C++ : public: void renderTiles(std::vector<Tile*> & tileList)

Operation renderParticles

Declaration :

- Uml : + renderParticles(inout partikelList : std::vector<Partikel*>) : void
- C++ : public: void renderParticles(std::vector<Partikel*> & partikelList)

Operation renderText

Declaration :

- Uml : + renderText(inout textList : std::vector<Text*>) : void
- C++ : public: void renderText(std::vector<Text*> & textList)

Operation clearPlane

Declaration :

- Uml : - clearPlane(in : void) : void
- C++ : private: void clearPlane(void )

All public operations : clearZBuffer , getInstance , initRenderer , renderFrame , renderParticles , renderText , renderTiles

#### 1.8.1.2 Class TextMapper

**************************************************************************
* \class TextMapper
\brief TextMapper Klasse
****************************************************************************

Declaration :

- C++ : class TextMapper

Artifact : TextMapper

Operation getInstance

Declaration :

- Uml : static, + getInstance() : TextMapper
- C++ : public: static TextMapper * getInstance()

Operation TextMapper

Declaration :

- Uml : # TextMapper() :
- C++ : protected: TextMapper()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : TextMapper= 0
- C++ : private: static TextMapper * _instance

Operation ~TextMapper

Declaration :

- Uml : + ~TextMapper() :
- C++ : public: virtual ~TextMapper()

Operation drawText

Declaration :

- Uml : + drawText(inout pane : BYTE, inout text : Text) : void
- C++ : public: void drawText(BYTE * pane, Text & text)

Operation drawText

Declaration :

- Uml : + drawText(inout pane : BYTE, inout text : char, in startX : int, in startY : int) : void
- C++ : public: void drawText(BYTE * pane, char * text, int startX, int startY)

Operation load

Declaration :

- Uml : + load(inout dataIn : DataInputStream) : void
- C++ : public: void load(DataInputStream & dataIn)

Operation save

Declaration :

- Uml : + save(inout dataOut : DataOutputStream) : void
- C++ : public: void save(DataOutputStream & dataOut)

Relation m_texture (<directional composition>)

Declaration :

- Uml : - m_texture : Texture
- C++ : private: Texture m_texture

Attribute m_charWidth

Declaration :

- Uml : - m_charWidth : int
- C++ : private: int m_charWidth

Attribute m_charHeight

Declaration :

- Uml : - m_charHeight : int
- C++ : private: int m_charHeight

Attribute m_linespace

Declaration :

- Uml : - m_linespace : int
- C++ : private: int m_linespace

Attribute m_charAscent

Declaration :

- Uml : - m_charAscent : int
- C++ : private: int m_charAscent

Attribute m_charDescent

Declaration :

- Uml : - m_charDescent : int
- C++ : private: int m_charDescent

All public operations : drawText , drawText , getInstance , load , save

#### 1.8.1.3 Class TextureMapper

**************************************************************************
* \class TextureMapper
\brief Projiziert eine Texture aus dem 3D Raum in den 2D Raum
****************************************************************************

Declaration :

- C++ : class TextureMapper

Artifact : TextureMapper

Attribute m_xmax

Declaration :

- Uml : - m_xmax : int
- C++ : private: int m_xmax

Attribute m_ymax

Declaration :

- Uml : - m_ymax : int
- C++ : private: int m_ymax

Attribute m_tex_width

Declaration :

- Uml : - m_tex_width : int
- C++ : private: int m_tex_width

Attribute m_tex_height

Declaration :

- Uml : - m_tex_height : int
- C++ : private: int m_tex_height

Attribute m_rgbIntensity

Declaration :

- Uml : - m_rgbIntensity : BYTE, multiplicity : [256][256]
- C++ : private: BYTE m_rgbIntensity[256][256]

Attribute debugFlag

Declaration :

- Uml : - debugFlag : bool
- C++ : private: bool debugFlag

Attribute msg_count

Declaration :

- Uml : - msg_count : int
- C++ : private: int msg_count

Relation m_tex (<unidirectional association>)

Declaration :

- Uml : - m_tex : Texture
- C++ : private: Texture * m_tex

Relation m_surface (<unidirectional association>)

Declaration :

- Uml : - m_surface : Surface
- C++ : private: Surface * m_surface

Attribute m_height

Declaration :

- Uml : - m_height : int
- C++ : private: int m_height

Attribute m_height_1

Declaration :

- Uml : - m_height_1 : int
- C++ : private: int m_height_1

Attribute m_width

Declaration :

- Uml : - m_width : int
- C++ : private: int m_width

Attribute m_alpha

Declaration :

- Uml : - m_alpha : int
- C++ : private: int m_alpha

Attribute m_ZBuffer

Declaration :

- Uml : - m_ZBuffer : float
- C++ : private: float * m_ZBuffer

Relation m_p0 (<directional composition>)

Declaration :

- Uml : + m_p0 : Vec
- C++ : public: Vec m_p0

Relation m_p1 (<directional composition>)

Declaration :

- Uml : + m_p1 : Vec
- C++ : public: Vec m_p1

Relation m_p2 (<directional composition>)

Declaration :

- Uml : + m_p2 : Vec
- C++ : public: Vec m_p2

Attribute m_d

Distanz vom Ursprung zur Plane

Declaration :

- Uml : + m_d : float
- C++ : public: float m_d

Attribute x0

x0' (projiziert auf Plane)

Declaration :

- Uml : + x0 : float
- C++ : public: float x0

Attribute y0

y0' (projiziert auf Plane)

Declaration :

- Uml : + y0 : float
- C++ : public: float y0

Attribute z0

z0-Koordinate (im Raum)

Declaration :

- Uml : + z0 : float
- C++ : public: float z0

Attribute c0

c0 ==> 1/z0-Koordinate (im Raum)

Declaration :

- Uml : + c0 : float
- C++ : public: float c0

Attribute uc0

u * c0 (u Texelkoordinate in x-Richtung)

Declaration :

- Uml : + uc0 : float
- C++ : public: float uc0

Attribute vc0

v * c0 (v Texelkoordinate in y-Richtung)

Declaration :

- Uml : + vc0 : float
- C++ : public: float vc0

Attribute x1

x1' (projiziert auf Plane)

Declaration :

- Uml : + x1 : float
- C++ : public: float x1

Attribute y1

y1' (projiziert auf Plane)

Declaration :

- Uml : + y1 : float
- C++ : public: float y1

Attribute z1

z1-Koordinate (im Raum)

Declaration :

- Uml : + z1 : float
- C++ : public: float z1

Attribute c1

c1 ==> 1/z1-Koordinate (im Raum)

Declaration :

- Uml : + c1 : float
- C++ : public: float c1

Attribute uc1

u * c1 (u Texelkoordinate in x-Richtung)

Declaration :

- Uml : + uc1 : float
- C++ : public: float uc1

Attribute vc1

v * c1 (v Texelkoordinate in y-Richtung)

Declaration :

- Uml : + vc1 : float
- C++ : public: float vc1

Attribute x2

x2' (projiziert auf Plane)

Declaration :

- Uml : + x2 : float
- C++ : public: float x2

Attribute y2

y2' (projiziert auf Plane)

Declaration :

- Uml : + y2 : float
- C++ : public: float y2

Attribute z2

z2-Koordinate (im Raum)

Declaration :

- Uml : + z2 : float
- C++ : public: float z2

Attribute c2

c2 ==> 1/z2-Koordinate (im Raum)

Declaration :

- Uml : + c2 : float
- C++ : public: float c2

Attribute uc2

u * c2 (u Texelkoordinate in x-Richtung)

Declaration :

- Uml : + uc2 : float
- C++ : public: float uc2

Attribute vc2

v * c2 (v Texelkoordinate in y-Richtung)

Declaration :

- Uml : + vc2 : float
- C++ : public: float vc2

Attribute dc_dx

dc/dx' (mit dy = const!!)

Declaration :

- Uml : - dc_dx : float
- C++ : private: float dc_dx

Attribute dc_dy

dc/dy' (mit dx = const!!)

Declaration :

- Uml : - dc_dy : float
- C++ : private: float dc_dy

Attribute duc_dx

duc/dx

Declaration :

- Uml : - duc_dx : float
- C++ : private: float duc_dx

Attribute duc_dy

duc/dy

Declaration :

- Uml : - duc_dy : float
- C++ : private: float duc_dy

Attribute dvc_dx

dvc/dx

Declaration :

- Uml : - dvc_dx : float
- C++ : private: float dvc_dx

Attribute dvc_dy

dvc/dy

Declaration :

- Uml : - dvc_dy : float
- C++ : private: float dvc_dy

Attribute dx_dy_a

Steigung dx/dy der linken Seite

Declaration :

- Uml : - dx_dy_a : float
- C++ : private: float dx_dy_a

Attribute dc_dy_a

Steigung dc/dy der linken Seite

Declaration :

- Uml : - dc_dy_a : float
- C++ : private: float dc_dy_a

Attribute duc_dy_a

Steigung duc/dy der linken Seite

Declaration :

- Uml : - duc_dy_a : float
- C++ : private: float duc_dy_a

Attribute dvc_dy_a

Steigung dvc/dy der linken Seite

Declaration :

- Uml : - dvc_dy_a : float
- C++ : private: float dvc_dy_a

Attribute dx_dy_b

Steigung dx/dy der rechten Seite

Declaration :

- Uml : - dx_dy_b : float
- C++ : private: float dx_dy_b

Attribute dc_dy_b

Steigung dc/dy der rechten Seite

Declaration :

- Uml : - dc_dy_b : float
- C++ : private: float dc_dy_b

Attribute duc_dy_b

Steigung duc/dy der rechten Seite

Declaration :

- Uml : - duc_dy_b : float
- C++ : private: float duc_dy_b

Attribute dvc_dy_b

Steigung dvc/dy der rechten Seite

Declaration :

- Uml : - dvc_dy_b : float
- C++ : private: float dvc_dy_b

Attribute xa

Declaration :

- Uml : - xa : float
- C++ : private: float xa

Attribute xb

Declaration :

- Uml : - xb : float
- C++ : private: float xb

Attribute ca

Declaration :

- Uml : - ca : float
- C++ : private: float ca

Attribute uca

Declaration :

- Uml : - uca : float
- C++ : private: float uca

Attribute vca

Declaration :

- Uml : - vca : float
- C++ : private: float vca

Attribute m_planePixels

Declaration :

- Uml : - m_planePixels : BYTE
- C++ : private: BYTE * m_planePixels

Operation project

Declaration :

- Uml : - project(in d : float, in p0 : Vec, in p1 : Vec, in p2 : Vec) : void
- C++ : private: void project(float d, Vec p0, Vec p1, Vec p2)

Operation addOffset

Declaration :

- Uml : - addOffset() : void
- C++ : private: void addOffset()

Operation sortVertices

Declaration :

- Uml : - sortVertices() : void
- C++ : private: void sortVertices()

Operation gradients

Declaration :

- Uml : - gradients() : void
- C++ : private: void gradients()

Operation gradients2

Declaration :

- Uml : - gradients2() : void
- C++ : private: void gradients2()

Operation gradients3

Declaration :

- Uml : - gradients3() : void
- C++ : private: void gradients3()

Operation doit

Declaration :

- Uml : - doit() : void
- C++ : private: void doit()

Operation renderSegment

Declaration :

- Uml : - renderSegment(in y1 : int, in y2 : int) : void
- C++ : private: void renderSegment(int y1, int y2)

Operation renderLine

Declaration :

- Uml : - renderLine(in y : int, in x1 : int, in x2 : int, in cs : float, in ucs : float, in vcs : float) : void
- C++ : private: inline void renderLine(int y, int x1, int x2, float cs, float ucs, float vcs)

Operation dumpVertices

Declaration :

- Uml : + dumpVertices() : void
- C++ : public: void dumpVertices()

Operation dumpProjection

Declaration :

- Uml : + dumpProjection() : void
- C++ : public: void dumpProjection()

Operation dumpGradients

Declaration :

- Uml : + dumpGradients() : void
- C++ : public: void dumpGradients()

Operation getInstance

Declaration :

- Uml : static, + getInstance() : TextureMapper
- C++ : public: static TextureMapper * getInstance()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : TextureMapper= 0
- C++ : private: static TextureMapper * _instance

Operation TextureMapper

Declaration :

- Uml : # TextureMapper() :
- C++ : protected: TextureMapper()

Operation ~TextureMapper

Declaration :

- Uml : + ~TextureMapper() :
- C++ : public: virtual ~TextureMapper()

Operation render

Declaration :

- Uml : + render(in d : float, inout t : Triangle, inout pane : BYTE, inout ZBuffer : float, in width : int, in height : int) : void
- C++ : public: void render(float d, Triangle & t, BYTE * pane, float * ZBuffer, int width, int height)

All public operations : dumpGradients , dumpProjection , dumpVertices , getInstance , render

#### 1.8.1.4 Class SpriteMapper

**************************************************************************
* \class SpriteMapper
\brief Rendert die Sprites (2D-Objekte) auf die Canvas unter
Beruecksichtigung der Smitransparenz
****************************************************************************

Declaration :

- C++ : class SpriteMapper

Artifact : SpriteMapper

Attribute m_planePixels

Declaration :

- Uml : - m_planePixels : BYTE
- C++ : private: BYTE * m_planePixels

Attribute m_ZBuffer

Declaration :

- Uml : - m_ZBuffer : float
- C++ : private: float * m_ZBuffer

Operation getInstance

Declaration :

- Uml : static, + getInstance() : SpriteMapper
- C++ : public: static SpriteMapper * getInstance()

Relation _instance (<unidirectional association>)

Declaration :

- Uml : static, - _instance : SpriteMapper= 0
- C++ : private: static SpriteMapper * _instance

Operation SpriteMapper

Declaration :

- Uml : # SpriteMapper() :
- C++ : protected: SpriteMapper()

Operation ~SpriteMapper

Declaration :

- Uml : + ~SpriteMapper() :
- C++ : public: virtual ~SpriteMapper()

Operation render

Declaration :

- Uml : + render(inout partikel : Partikel, inout pane : BYTE, inout ZBuffer : float, in width : int, in height : int) : void
- C++ : public: void render(Partikel * partikel, BYTE * pane, float * ZBuffer, int width, int height)

Operation renderNeu

Declaration :

- Uml : + renderNeu(inout partikel : Partikel, inout pane : BYTE, inout ZBuffer : float, in width : int, in height : int) : void
- C++ : public: void renderNeu(Partikel * partikel, BYTE * pane, float * ZBuffer, int width, int height)

All public operations : getInstance , render , renderNeu

### 1.8.2 Deployment View renderer

Artifact Renderer

Stereotype: source

Artifact source associated with : Renderer

Artifact SpriteMapper

Stereotype: source

Artifact source associated with : SpriteMapper

Artifact TextMapper

Stereotype: source

Artifact source associated with : TextMapper

Artifact TextureMapper

Stereotype: source

Artifact source associated with : TextureMapper

# 2 Class View Übersicht

Übersicht