Engine3D
Documentation

Properties:

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 :

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 :

Relation m_engineIO (<unidirectional association>)

Declaration :

Relation m_lightManager (<unidirectional association>)

Declaration :

Relation m_frustum (<unidirectional association>)

Declaration :

Relation m_skyBox (<unidirectional association>)

Declaration :

Relation m_animationManager (<unidirectional association>)

Declaration :

Relation m_partikelManager (<unidirectional association>)

Declaration :

Relation m_surfaceCache (<unidirectional association>)

Declaration :

Relation m_renderer (<unidirectional association>)

Declaration :

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 :

Relation m_lifting (<directional composition>)

UP, DOWN, STOP

Declaration :

Relation m_strafing (<directional composition>)

LEFT, RIGHT, STOP

Declaration :

Relation m_rotating (<directional composition>)

LEFT, RIGHT, STOP

Declaration :

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 :

Operation isMoving

Declaration :

Operation lift

Declaration :

Operation isLifting

Declaration :

Operation strafe

Declaration :

  • Uml : + strafe(in step : STEP_DIR) : void
  • C++ : public: void strafe(STEP_DIR step)
Operation isStrafing

Declaration :

Operation rotate

Declaration :

  • Uml : + rotate(in step : STEP_DIR) : void
  • C++ : public: void rotate(STEP_DIR step)
Operation isRotating

Declaration :

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 :

Operation save

Declaration :

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 :

Relation m_camera (<unidirectional association>)

Declaration :

Relation m_lightManager (<unidirectional association>)

Declaration :

Relation m_skybox (<unidirectional association>)

Declaration :

Relation m_animationManager (<unidirectional association>)

Declaration :

Relation m_partikelManager (<unidirectional association>)

Declaration :

Relation m_textMapper (<unidirectional association>)

Declaration :

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 :

Operation save

Declaration :

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 :

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 :

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 :

Operation LightManager

Declaration :

  • Uml : # LightManager() :
  • C++ : protected: LightManager()
Relation _instance (<unidirectional association>)

Declaration :

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 :

Stereotype: std::vector

Relation lightMaps (<unidirectional association>)

Declaration :

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 :

Operation save

Declaration :

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 :

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 :

Operation save

Declaration :

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 :

Relation _instance (<unidirectional association>)

Declaration :

Operation AnimationManager

Declaration :

  • Uml : # AnimationManager() :
  • C++ : protected: AnimationManager()
Operation ~AnimationManager

Declaration :

  • Uml : + ~AnimationManager() :
  • C++ : public: virtual ~AnimationManager()
Relation m_animDummy (<directional composition>)

Declaration :

Relation m_animList (<unidirectional association>)

Declaration :

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 :

Operation animate

Declaration :

  • Uml : + animate(in : void) : void
  • C++ : public: void animate(void )
Operation load

Declaration :

Operation save

throws IOException;

Declaration :

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 :

Operation SurfaceCache

Declaration :

  • Uml : # SurfaceCache() :
  • C++ : protected: SurfaceCache()
Relation _instance (<unidirectional association>)

Declaration :

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 :

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 :

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 :

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 :

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 :

Operation load

Declaration :

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 :

Relation _instance (<unidirectional association>)

Declaration :

Operation MaterialManager

Declaration :

  • Uml : # MaterialManager() :
  • C++ : protected: MaterialManager()
Operation ~MaterialManager

Declaration :

  • Uml : + ~MaterialManager() :
  • C++ : public: virtual ~MaterialManager()
Relation texList (<unidirectional association>)

Declaration :

Stereotype: std::vector

Relation matList (<unidirectional association>)

Declaration :

Stereotype: std::vector

Relation texDummy (<directional composition>)

Declaration :

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 :

Operation save

Declaration :

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 :

Operation save

throws IOException;

Declaration :

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 :

Operation save

throws IOException;

Declaration :

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 :

Operation save

throws IOException;

Declaration :

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 :

Relation _instance (<unidirectional association>)

Declaration :

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 :

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 :

Operation save

Declaration :

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 :

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 :

Operation save

throws IOException;

Declaration :

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 :

Operation init

Declaration :

  • Uml : + init(inout spriteList : std::vector<Sprite*>) : void
  • C++ : public: void init(std::vector<Sprite*> & spriteList)
Operation save

Declaration :

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 :

Relation m_textureMapper (<unidirectional association>)

Declaration :

Relation m_textMapper (<unidirectional association>)

Declaration :

Relation m_surfaceCache (<unidirectional association>)

Declaration :

Relation m_spriteMapper (<unidirectional association>)

Declaration :

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 :

Operation TextMapper

Declaration :

  • Uml : # TextMapper() :
  • C++ : protected: TextMapper()
Relation _instance (<unidirectional association>)

Declaration :

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 :

Operation save

Declaration :

Relation m_texture (<directional composition>)

Declaration :

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 :

Relation m_surface (<unidirectional association>)

Declaration :

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 :

Relation _instance (<unidirectional association>)

Declaration :

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 :

Relation _instance (<unidirectional association>)

Declaration :

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