From 5f60f7c5335920ed016fc0fa151bf33ea0b1877f Mon Sep 17 00:00:00 2001 From: Edouard DUPIN Date: Fri, 6 Dec 2013 16:12:49 +0100 Subject: [PATCH] [DEV] add first exml documentation --- .gitignore | 64 +++ base.css | 131 +++++ ege__Camera.html | 232 +++++++++ ege__ElementGame.html | 488 +++++++++++++++++++ ege__ElementGame__localIA.html | 81 +++ ege__ElementInteraction.html | 98 ++++ ege__Environement.html | 253 ++++++++++ ege__Environement__ResultNearestElement.html | 40 ++ ege__Particule.html | 141 ++++++ ege__ParticuleEngine.html | 128 +++++ ege__ParticuleSimple.html | 154 ++++++ ege__Scene.html | 249 ++++++++++ ege__resource__ParticuleMesh.html | 109 +++++ index.html | 32 ++ 14 files changed, 2200 insertions(+) create mode 100644 .gitignore create mode 100644 base.css create mode 100644 ege__Camera.html create mode 100644 ege__ElementGame.html create mode 100644 ege__ElementGame__localIA.html create mode 100644 ege__ElementInteraction.html create mode 100644 ege__Environement.html create mode 100644 ege__Environement__ResultNearestElement.html create mode 100644 ege__Particule.html create mode 100644 ege__ParticuleEngine.html create mode 100644 ege__ParticuleSimple.html create mode 100644 ege__Scene.html create mode 100644 ege__resource__ParticuleMesh.html create mode 100644 index.html diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..b08d134 --- /dev/null +++ b/.gitignore @@ -0,0 +1,64 @@ + +################################### +# folders +################################### +CVS +.svn +Object_* +doxygen/API/ +doxygen/ALL/ + +################################### +# backup files +################################### +*~ +*.swp +*.old +*.bck + +################################### +# Compiled source # +################################### +*.com +*.class +*.dll +*.exe +*.o +*.so +*.pyc +tags +#ewol +out +ewol_debug +ewol_release + +################################### +# Packages # +################################### +# it's better to unpack these files and commit the raw source +# git has its own built in compression methods +*.7z +*.dmg +*.gz +*.iso +*.jar +*.rar +*.tar +*.zip + +################################### +# Logs and databases # +################################### +*.log +*.sql +*.sqlite + +################################### +# OS generated files # +################################### +.DS_Store? +ehthumbs.db +Icon? +Thumbs.db +Sources/libewol/ewol/os/AndroidAbstraction.cpp +org_ewol_EwolConstants.h diff --git a/base.css b/base.css new file mode 100644 index 0000000..aa94d74 --- /dev/null +++ b/base.css @@ -0,0 +1,131 @@ + +html { + display: block; +} + +body { + font-family: 'Ubuntu',Tahoma,sans-serif; + padding-top: 40px; + padding-bottom: 40px; + font-size: 15px; + line-height: 150%; + margin: 0; + color: #333333; + background-color: #ffffff; + display: block; + margin-left: 250px; + margin-right: 50px; +}; + +.container{ + width:940px; + margin-right: auto; + margin-left: auto; + display: block; +}; + +.navbar { + z-index: 1; + overflow: visible; + color: #ffffff; + display: block; +} + +.navbar div { + display: block; + margin-left: 5px; + margin-right: 5px; +} + +.navbar-fixed-top { + width:210px; + display: block; + position: fixed; + padding-top: 0px; + top: 0; + height: 100%; + right: 0; + left: 0; + margin-bottom: 0; + background-color: #d44413; + border: 1px solid #c64012; + font-size: 15px; + font-weight: 200; + color: #ffffff; + text-shadow: 0 1px 0 #ce4213; + padding: 10px 20px 10px; + margin-left: -20px; + overflow:scroll; + overflow-x:hidden; +} +/* +.navbar ul { + font-size: 15px; +}; +*/ +h1, h2, h3, h4, h5, h6 { + display: block; + margin: 10px 0; + font-family: inherit; + font-weight: bold; + line-height: 1; + color: inherit; + text-rendering: optimizelegibility; +} + +p { + margin: 0 0 10px; + display: block; +} + +pre { + #margin-left: 20px; + display: block; + padding: 9.5px; + margin: 0 0 10px; + font-size: 13px; + line-height: 20px; + word-break: break-all; + word-wrap: break-word; + white-space: pre; + white-space: pre-wrap; + background-color: #f5f5f5; + border: 1px solid #ccc; + border: 1px solid rgba(0, 0, 0, 0.15); + border-radius: 4px; +} + + + +.code-function { + text-decoration:none; + color:#09857e; + font-weight:bold; +} + +.code-type { + text-decoration:none; + color:#376d0a; + font-weight:bold; +} + +.code-argument { + text-decoration:none; + color:#B80000; + font-weight:bold; +} + +.code-number { + text-decoration:none; + color:#007b00; +} + +.code-keyword { + text-decoration:none; + color:#215eb8; + font-weight:bold; +} +.code-storage-keyword { + text-decoration:none; + color:#466cb4; +} \ No newline at end of file diff --git a/ege__Camera.html b/ege__Camera.html new file mode 100644 index 0000000..9c9abe1 --- /dev/null +++ b/ege__Camera.html @@ -0,0 +1,232 @@ + + + + + ege Library + + + +
+
+

ege Library

+
  • ege
    • + + +
    +
    +
    +

    Class: ege::Camera

    +
    +

    Synopsis:

    +
    ++                Camera             (const vec3 & _eye,
                                         float _angleZ,
                                         float _angleTeta,
                                         float _distance);
    +  void          setEye             (const vec3 & _eye);
    +  const vec3 &  getEye             (void);
    +  const vec3 &  getOrigin          (void);
    +  const vec3 &  getViewVector      (void);
    +  void          setAngleZ          (float _angleZ);
    +  float         getAngleZ          (void);
    +  void          setAngleTeta       (float _angleTeta);
    +  float         getAngleTeta       (void);
    +  void          setDistance        (float _distance);
    +  float         getDistance        (void);
    +  const mat4 &  getMatrix          (void);
    +  void          setForcingViewTop  (bool _newState);
    +  void          periodicCall       (float _step);
    +  vec3          projectOnZGround   (const vec2 & _cameraDeltaAngle,
                                         float _zValue);
    #  void          update             (void);
    + + +

    Detail:

    +

    ege::Camera ()

    + +
    +Camera(const vec3 & _eye,
+       float _angleZ,
+       float _angleTeta,
+       float _distance);
    +
    +Constructor. +
    +
    + +
    +

    setEye ()

    + +
    +void setEye(const vec3 & _eye);
    +
    +set the position of the camera. +
    +
    + +
    +

    getEye ()

    + +
    +const vec3 & getEye(void);
    +
    +get the curent Camera Eye position. +
    +
    + +
    +

    getOrigin ()

    + +
    +const vec3 & getOrigin(void);
    +
    +get the curent Camera origin position. +
    +
    + +
    +

    getViewVector ()

    + +
    +const vec3 & getViewVector(void);
    +
    +Get the camera viewing vector. +
    +
    + +
    +

    setAngleZ ()

    + +
    +void setAngleZ(float _angleZ);
    +
    +set the angle on the camera +
    +
    + +
    +

    getAngleZ ()

    + +
    +float getAngleZ(void);
    +
    +get the curent Camera angles. +
    +
    + +
    +

    setAngleTeta ()

    + +
    +void setAngleTeta(float _angleTeta);
    +
    +set the angle on the camera +
    +
    + +
    +

    getAngleTeta ()

    + +
    +float getAngleTeta(void);
    +
    +get the curent Camera angles. +
    +
    + +
    +

    setDistance ()

    + +
    +void setDistance(float _distance);
    +
    +set the angle on the camera +
    +
    + +
    +

    getDistance ()

    + +
    +float getDistance(void);
    +
    +get the curent Camera angles. +
    +
    + +
    +

    getMatrix ()

    + +
    +const mat4 & getMatrix(void);
    +
    +get the transformation matix for the camera. +
    +
    + +
    +

    setForcingViewTop ()

    + +
    +void setForcingViewTop(bool _newState);
    +
    +change camera mode of view == > force to the top view +
    +
    + +
    +

    periodicCall ()

    + +
    +void periodicCall(float _step);
    +
    +It is really needed to call the camera periodicly for performing automatic movement +
    +
    + +
    +

    projectOnZGround ()

    + +
    +vec3 projectOnZGround(const vec2 & _cameraDeltaAngle,
+                      float _zValue);
    +
    +
    + +
    +

    update ()

    + +
    +void update(void);
    +
    +update the matrix property +

    + +
    +
    + + diff --git a/ege__ElementGame.html b/ege__ElementGame.html new file mode 100644 index 0000000..c1194ac --- /dev/null +++ b/ege__ElementGame.html @@ -0,0 +1,488 @@ + + + + + ege Library + + + +
    +
    +

    ege Library

    +
  • ege
    • + + +
    +
    +
    +

    Class: ege::ElementGame

    +
    +

    Synopsis:

    +
    ++                             ElementGame         (ege::Environement & _env);
    +                            ~ElementGame         (void);
    +  const std::string &        getType             (void);
    +  bool                       init                (property_te _property,
                                                       void * _value);
    +  bool                       unInit              (void);
    +  uint32_t                   getUID              (void);
    +  bool                       loadMesh            (const std::string & _meshFileName);
    +  bool                       setMesh             (ewol::Mesh * _mesh);
    +  bool                       setShape            (btCollisionShape * _shape);
    +  ewol::Mesh *               getMesh             (void);
    +  btCollisionShape *         getShape            (void);
    +  float                      getLifeRatio        (void);
    +  bool                       isDead              (void);
    +  bool                       needToRemove        (void);
    +  void                       setFireOn           (int32_t _groupIdSource,
                                                       int32_t _type,
                                                       float _power,
                                                       const vec3 & _center);
    +  void                       onLifeChange        (void);
    +  int32_t                    getGroup            (void);
    +  void                       setGroup            (int32_t _newGroup);
    +  void                       preCalculationDraw  (const ege::Camera & _camera);
    +  void                       draw                (int32_t _pass);
    +  void                       drawLife            (ewol::Colored3DObject * _draw,
                                                       const ege::Camera & _camera);
    +  void                       drawDebug           (ewol::Colored3DObject * _draw,
                                                       const ege::Camera & _camera);
    +  vec3                       getPositionTheoric  (void);
    +  void                       setPositionTheoric  (const vec3 & _pos);
    +  const vec3 &               getPosition         (void);
    +  void                       setPosition         (const vec3 & _pos);
    +  const vec3 &               getSpeed            (void);
    +  const float                getInvMass          (void);
    +  void                       elementIsRemoved    (ege::ElementGame * _removedElement);
    +  bool                       isFixed             (void);
    +  float                      getRadius           (void);
    +  void                       dynamicEnable       (void);
    +  void                       dynamicDisable      (void);
    +  void                       iaEnable            (void);
    +  void                       iaDisable           (void);
    +  void                       iaAction            (float _step);
    +  void                       onDestroy           (void);
    -  static void                FunctionFreeShape   (void * _pointer);
    -  void                       removeShape         (void);
    + + +

    Detail:

    +

    ege::ElementGame ()

    + +
    +ElementGame(ege::Environement & _env);
    +
    +Constructor (when constructer is called just add element that did not change. +The objest will be stored in a pool of element and keep a second time if needed == > redure memory allocation, +when needed, the system will call the init and un-init function... +

    + +
    +

    ege::~ElementGame ()

    + +
    +~ElementGame(void);
    +
    +Destructor +

    + +
    +

    getType ()

    + +
    +const std::string & getType(void);
    +
    +get the element Type description string. +
    +
    + +
    +

    init ()

    + +
    +bool init(property_te _property,
+          void * _value);
    +
    +init the element with the defined properties +
    +
    + +
    +

    unInit ()

    + +
    +bool unInit(void);
    +
    +
    + +
    +

    getUID ()

    + +
    +uint32_t getUID(void);
    +
    +get the curent Element Unique ID in the all Game. +
    +
    + +
    +

    loadMesh ()

    + +
    +bool loadMesh(const std::string & _meshFileName);
    +
    +Select a mesh with a specific name. +
    Notes: Automaticly load the shape if it is specify in the mesh file +
    +
    + +
    +

    setMesh ()

    + +
    +bool setMesh(ewol::Mesh * _mesh);
    +
    +set the the Mesh properties. +
    Notes: : this remove the shape and the mesh properties. +
    +
    + +
    +

    setShape ()

    + +
    +bool setShape(btCollisionShape * _shape);
    +
    +set the shape properties. +
    Notes: : this remove the shape properties. +
    +
    + +
    +

    getMesh ()

    + +
    +ewol::Mesh * getMesh(void);
    +
    +get a pointer on the Mesh file. +
    +
    + +
    +

    getShape ()

    + +
    +btCollisionShape * getShape(void);
    +
    +get a pointer on the bullet collision shape. +
    +
    + +
    +

    getLifeRatio ()

    + +
    +float getLifeRatio(void);
    +
    +get the curent life ratio [0..1] +
    +
    + +
    +

    isDead ()

    + +
    +bool isDead(void);
    +
    +Check if the element is dead. +
    +
    + +
    +

    needToRemove ()

    + +
    +bool needToRemove(void);
    +
    +Request if the element might be removed from the system +
    +
    + +
    +

    setFireOn ()

    + +
    +void setFireOn(int32_t _groupIdSource,
+               int32_t _type,
+               float _power,
+               const vec3 & _center);
    +
    +apply a fire on the element at a current power and a specific power. +
    +
    + +
    +

    onLifeChange ()

    + +
    +void onLifeChange(void);
    +
    +Call chan the element life change +

    + +
    +

    getGroup ()

    + +
    +int32_t getGroup(void);
    +
    +get the Group of the element. +
    +
    + +
    +

    setGroup ()

    + +
    +void setGroup(int32_t _newGroup);
    +
    +set the group of the curent element +
    +
    + +
    +

    preCalculationDraw ()

    + +
    +void preCalculationDraw(const ege::Camera & _camera);
    +
    +Can be call tu opdate the list of the element displayed on the scren (example : no display of the hiden triangle) +
    +
    + +
    +

    draw ()

    + +
    +void draw(int32_t _pass);
    +
    +draw the curent element (can have multiple display) +
    +
    + +
    +

    drawLife ()

    + +
    +void drawLife(ewol::Colored3DObject * _draw,
+              const ege::Camera & _camera);
    +
    +draw the current life of the element +

    + +
    +

    drawDebug ()

    + +
    +void drawDebug(ewol::Colored3DObject * _draw,
+               const ege::Camera & _camera);
    +
    +Debug display of the current element +
    +
    + +
    +

    getPositionTheoric ()

    + +
    +vec3 getPositionTheoric(void);
    +
    +get the theoric position. Sometimes, the element has move due to an explosion or something else, then its real position in not the one that woult it be at the end ... +
    +
    + +
    +

    setPositionTheoric ()

    + +
    +void setPositionTheoric(const vec3 & _pos);
    +
    +set the current Theoric position of the element +
    +
    + +
    +

    getPosition ()

    + +
    +const vec3 & getPosition(void);
    +
    +get the current position of the element +
    +
    + +
    +

    setPosition ()

    + +
    +void setPosition(const vec3 & _pos);
    +
    +set the current position of the element +
    +
    + +
    +

    getSpeed ()

    + +
    +const vec3 & getSpeed(void);
    +
    +get the current speed of the element +
    +
    + +
    +

    getInvMass ()

    + +
    +const float getInvMass(void);
    +
    +get the current mass of the element +
    +
    + +
    +

    elementIsRemoved ()

    + +
    +void elementIsRemoved(ege::ElementGame * _removedElement);
    +
    +Event arrive when an element has been remove from the system == > this permit to keep pointer of ennemy, and not search them every cycle ... +
    +
    + +
    +

    isFixed ()

    + +
    +bool isFixed(void);
    +
    +get the element if it is fixed or not. if the element is fixed this is for tower, and all thing does not really move +
    +
    + +
    +

    getRadius ()

    + +
    +float getRadius(void);
    +
    +get the current space needed by the element in the workspace +
    +
    + +
    +

    dynamicEnable ()

    + +
    +void dynamicEnable(void);
    +
    +set the elment in the physique engine +

    + +
    +

    dynamicDisable ()

    + +
    +void dynamicDisable(void);
    +
    +remove this element from the physique engine +

    + +
    +

    iaEnable ()

    + +
    +void iaEnable(void);
    +
    +enable periodic call Of this object for processing Artificial Intelligence +

    + +
    +

    iaDisable ()

    + +
    +void iaDisable(void);
    +
    +disable periodic call Of this object for processing Artificial Intelligence +

    + +
    +

    iaAction ()

    + +
    +void iaAction(float _step);
    +
    +periodic call for intelligence artificial. +
    +
    + +
    +

    onDestroy ()

    + +
    +void onDestroy(void);
    +
    +
    + +
    +

    ege::FunctionFreeShape ()

    + +
    +static void FunctionFreeShape(void * _pointer);
    +
    +
    + +
    +

    removeShape ()

    + +
    +void removeShape(void);
    +
    +remove the curent selected shape. +

    + +
    +
    + + diff --git a/ege__ElementGame__localIA.html b/ege__ElementGame__localIA.html new file mode 100644 index 0000000..51cdc61 --- /dev/null +++ b/ege__ElementGame__localIA.html @@ -0,0 +1,81 @@ + + + + + ege Library + + + +
    +
    +

    ege Library

    +
  • ege
    • + + +
    +
    +
    +

    Class: ege::ElementGame::localIA

    +
    +

    Synopsis:

    +
    ++        localIA       (ElementGame & element);
    +       ~localIA       (void);
    +  void  debugDraw     (btIDebugDraw * _debugDrawer);
    +  void  updateAction  (btCollisionWorld * _collisionWorld,
                            btScalar _step);
    + + +

    Object Hierarchy:

    +
    +btActionInterface
+    +--> ege::ElementGame::localIA
+
    +
    +

    Detail:

    +

    ege::ElementGame::localIA ()

    + +
    +localIA(ElementGame & element);
    +
    +Constructor +

    + +
    +

    ege::ElementGame::~localIA ()

    + +
    +~localIA(void);
    +
    +Destructor +

    + +
    +

    debugDraw ()

    + +
    +void debugDraw(btIDebugDraw * _debugDrawer);
    +
    +
    + +
    +

    updateAction ()

    + +
    +void updateAction(btCollisionWorld * _collisionWorld,
+                  btScalar _step);
    +
    +
    + +
    +
    + + diff --git a/ege__ElementInteraction.html b/ege__ElementInteraction.html new file mode 100644 index 0000000..adccfa5 --- /dev/null +++ b/ege__ElementInteraction.html @@ -0,0 +1,98 @@ + + + + + ege Library + + + +
    +
    +

    ege Library

    +
  • ege
    • + + +
    +
    +
    +

    Class: ege::ElementInteraction

    +
    +

    Synopsis:

    +
    ++  int32_t                       getType              (void);
    +  int32_t                       getSourceGroup       (void);
    +  const std::vector<int32_t> &  getDestinationGroup  (void);
    +  void                          addGroupDestination  (int32_t _id);
    +  const vec3 &                  getSourcePosition    (void);
    +                                ElementInteraction   (int32_t _type,
                                                           int32_t _groupSource,
                                                           const vec3 & _pos);
    +  void                          applyEvent           (ege::ElementGame & _element);
    + + +

    Detail:

    +

    getType ()

    + +
    +int32_t getType(void);
    +
    +
    + +
    +

    getSourceGroup ()

    + +
    +int32_t getSourceGroup(void);
    +
    +
    + +
    +

    getDestinationGroup ()

    + +
    +const std::vector<int32_t> & getDestinationGroup(void);
    +
    +
    + +
    +

    addGroupDestination ()

    + +
    +void addGroupDestination(int32_t _id);
    +
    +
    + +
    +

    getSourcePosition ()

    + +
    +const vec3 & getSourcePosition(void);
    +
    +
    + +
    +

    ege::ElementInteraction ()

    + +
    +ElementInteraction(int32_t _type,
+                   int32_t _groupSource,
+                   const vec3 & _pos);
    +
    +
    + +
    +

    applyEvent ()

    + +
    +void applyEvent(ege::ElementGame & _element);
    +
    +
    + +
    +
    + + diff --git a/ege__Environement.html b/ege__Environement.html new file mode 100644 index 0000000..863d9d5 --- /dev/null +++ b/ege__Environement.html @@ -0,0 +1,253 @@ + + + + + ege Library + + + +
    +
    +

    ege Library

    +
  • ege
    • + + +
    +
    +
    +

    Class: ege::Environement

    +
    +

    Synopsis:

    +
    ++                                     Environement                 (void);
    +                                    ~Environement                 (void);
    +  static void                        addCreator                   (const std::string & _type,
                                                                        ege::createElement_tf _creator);
    +  ege::ElementGame *                 createElement                (const std::string & _type,
                                                                        bool _autoAddElement,
                                                                        ege::property_te _property,
                                                                        void * _value);
    +  ege::ElementGame *                 createElement                (const std::string & _type,
                                                                        std::string & _description,
                                                                        bool _autoAddElement);
    +  ege::ElementGame *                 createElement                (const std::string & _type,
                                                                        ejson::Value * _value,
                                                                        bool _autoAddElement);
    +  ege::ElementGame *                 createElement                (const std::string & _type,
                                                                        exml::Node * _node,
                                                                        bool _autoAddElement);
    +  void                               setDynamicWorld              (btDynamicsWorld * _newWorld);
    +  btDynamicsWorld *                  getDynamicWorld              (void);
    +  std::vector &  getElementGame               (void);
    +  ege::ElementGame *                 getElementNearest            (ege::ElementGame * _sourceRequest,
                                                                        float & _distance);
    +  void                               getElementNearest            (const vec3 & _sourcePosition,
                                                                        float _distanceMax,
                                                                        std::vector & _resultList);
    +  void                               getElementNearestFixed       (const vec3 & _sourcePosition,
                                                                        float _distanceMax,
                                                                        std::vector & _resultList);
    +  void                               addElementGame               (ege::ElementGame * _newElement);
    +  void                               rmElementGame                (ege::ElementGame * _removeElement);
    +  void                               getOrderedElementForDisplay  (std::vector & _resultList,
                                                                        const vec3 & _position,
                                                                        const vec3 & _direction);
    +  void                               generateInteraction          (ege::ElementInteraction & _event);
    +  ege::ParticuleEngine &             getParticuleEngine           (void);
    + + +

    Detail:

    +

    ege::Environement ()

    + +
    +Environement(void);
    +
    +
    + +
    +

    ege::~Environement ()

    + +
    +~Environement(void);
    +
    +
    + +
    +

    ege::addCreator ()

    + +
    +static void addCreator(const std::string & _type,
+                       ege::createElement_tf _creator);
    +
    +add a creator element system +
    +
    + +
    +

    createElement ()

    + +
    +ege::ElementGame * createElement(const std::string & _type,
+                                 bool _autoAddElement,
+                                 ege::property_te _property,
+                                 void * _value);
    +
    +Create an element on the curent scene. +
    Notes: Pointer is return in case of setting properties on it... +
    +
    + +
    +

    createElement ()

    + +
    +ege::ElementGame * createElement(const std::string & _type,
+                                 std::string & _description,
+                                 bool _autoAddElement);
    +
    +
    + +
    +

    createElement ()

    + +
    +ege::ElementGame * createElement(const std::string & _type,
+                                 ejson::Value * _value,
+                                 bool _autoAddElement);
    +
    +
    + +
    +

    createElement ()

    + +
    +ege::ElementGame * createElement(const std::string & _type,
+                                 exml::Node * _node,
+                                 bool _autoAddElement);
    +
    +
    + +
    +

    setDynamicWorld ()

    + +
    +void setDynamicWorld(btDynamicsWorld * _newWorld);
    +
    +set the curent world +
    +
    + +
    +

    getDynamicWorld ()

    + +
    +btDynamicsWorld * getDynamicWorld(void);
    +
    +get the curent world +
    +
    + +
    +

    getElementGame ()

    + +
    +std::vector & getElementGame(void);
    +
    + +
    + +
    +

    getElementNearest ()

    + +
    +ege::ElementGame * getElementNearest(ege::ElementGame * _sourceRequest,
+                                     float & _distance);
    +
    +get the nearest Element +
    +
    + +
    +

    getElementNearest ()

    + +
    +void getElementNearest(const vec3 & _sourcePosition,
+                       float _distanceMax,
+                       std::vector & _resultList);
    +
    +
    + +
    +

    getElementNearestFixed ()

    + +
    +void getElementNearestFixed(const vec3 & _sourcePosition,
+                            float _distanceMax,
+                            std::vector & _resultList);
    +
    +
    + +
    +

    addElementGame ()

    + +
    +void addElementGame(ege::ElementGame * _newElement);
    +
    +add an element on the list availlable. +
    +
    + +
    +

    rmElementGame ()

    + +
    +void rmElementGame(ege::ElementGame * _removeElement);
    +
    +remove an element on the list availlable. +
    +
    + +
    +

    getOrderedElementForDisplay ()

    + +
    +void getOrderedElementForDisplay(std::vector & _resultList,
+                                 const vec3 & _position,
+                                 const vec3 & _direction);
    +
    +get the element order from the nearest to the farest, and remove all element that are not in the camera angle and axes. +
    +
    + +
    +

    generateInteraction ()

    + +
    +void generateInteraction(ege::ElementInteraction & _event);
    +
    +generate an event on all the sub element of the game == > usefull for explosion, or lazer fire ... +
    +
    + +
    +

    getParticuleEngine ()

    + +
    +ege::ParticuleEngine & getParticuleEngine(void);
    +
    +get the particule engine reference. +
    +
    + +
    +
    + + diff --git a/ege__Environement__ResultNearestElement.html b/ege__Environement__ResultNearestElement.html new file mode 100644 index 0000000..d1b8a5a --- /dev/null +++ b/ege__Environement__ResultNearestElement.html @@ -0,0 +1,40 @@ + + + + + ege Library + + + +
    +
    +

    ege Library

    +
  • ege
    • + + +
    +
    +
    +

    Class: ege::Environement::ResultNearestElement

    +
    +

    Synopsis:

    +
    +
    + + +

    Detail:

    +

    + + diff --git a/ege__Particule.html b/ege__Particule.html new file mode 100644 index 0000000..f8a122c --- /dev/null +++ b/ege__Particule.html @@ -0,0 +1,141 @@ + + + + + ege Library + + + +
    +
    +

    ege Library

    +
  • ege
    • + + +
    +
    +
    +

    Class: ege::Particule

    +
    +

    Synopsis:

    +
    ++                Particule         (ege::ParticuleEngine & _particuleEngine,
                                        const char * _particuleType);
    +               ~Particule         (void);
    +  void          init              (void);
    +  void          UnInit            (void);
    +  void          update            (float _delta);
    +  void          draw              (const ege::Camera & _camera);
    +  bool          needRemove        (void);
    +  const char *  getParticuleType  (void);
    +  void          onEnd             (void);
    + + +

    Description:

    +/** +* @brief The particule class is an element with no control, when it will be created, +* it does not have any control, for example smoke or reactor generation ... +* or explosion particule ... +*/

    Detail:

    +

    ege::Particule ()

    + +
    +Particule(ege::ParticuleEngine & _particuleEngine,
+          const char * _particuleType);
    +
    +Constructor. +
    +
    + +
    +

    ege::~Particule ()

    + +
    +~Particule(void);
    +
    +Destructor. +

    + +
    +

    init ()

    + +
    +void init(void);
    +
    +init the particule +

    + +
    +

    UnInit ()

    + +
    +void UnInit(void);
    +
    +Un-init the particule +

    + +
    +

    update ()

    + +
    +void update(float _delta);
    +
    +update the paticule properties +
    +
    + +
    +

    draw ()

    + +
    +void draw(const ege::Camera & _camera);
    +
    +draw the current particule +

    + +
    +

    needRemove ()

    + +
    +bool needRemove(void);
    +
    +Check if the element might be removed +
    +
    + +
    +

    getParticuleType ()

    + +
    +const char * getParticuleType(void);
    +
    +get the type of the particule +
    +
    + +
    +

    onEnd ()

    + +
    +void onEnd(void);
    +
    +When the particule arrive to his end of life, this function is called. +

    + +
    +
    + + diff --git a/ege__ParticuleEngine.html b/ege__ParticuleEngine.html new file mode 100644 index 0000000..6b0fa3d --- /dev/null +++ b/ege__ParticuleEngine.html @@ -0,0 +1,128 @@ + + + + + ege Library + + + +
    +
    +

    ege Library

    +
  • ege
    • + + +
    +
    +
    +

    Class: ege::ParticuleEngine

    +
    +

    Synopsis:

    +
    ++               ParticuleEngine  (ege::Environement & _env);
    +              ~ParticuleEngine  (void);
    +  void         clear            (void);
    +  void         add              (Particule * _particule);
    +  void         update           (float _deltaTime);
    +  void         draw             (const ege::Camera & _camera);
    +  Particule *  respown          (const char * _particuleType);
    -  void         addRemoved       (Particule * _particule);
    + + +

    Detail:

    +

    ege::ParticuleEngine ()

    + +
    +ParticuleEngine(ege::Environement & _env);
    +
    +
    + +
    +

    ege::~ParticuleEngine ()

    + +
    +~ParticuleEngine(void);
    +
    +
    + +
    +

    clear ()

    + +
    +void clear(void);
    +
    +clear the particule engine +

    + +
    +

    add ()

    + +
    +void add(Particule * _particule);
    +
    +add a particule in the engine (internal acces only) +
    +
    + +
    +

    update ()

    + +
    +void update(float _deltaTime);
    +
    +update particule properties +
    +
    + +
    +

    draw ()

    + +
    +void draw(const ege::Camera & _camera);
    +
    +draw all the active Particule +
    +
    + +
    +

    respown ()

    + +
    +Particule * respown(const char * _particuleType);
    +
    +get a particue with his type, we get particule that has been already removed, otherwise, you will create new +
    Notes: If you did not want to use respawn set type at NULL. +
    +
    + +
    +

    addRemoved ()

    + +
    +void addRemoved(Particule * _particule);
    +
    +add a particule in the removed section == > this not delete the particule, but just set it in an other list +
    +
    + +
    +
    + + diff --git a/ege__ParticuleSimple.html b/ege__ParticuleSimple.html new file mode 100644 index 0000000..b9e4d96 --- /dev/null +++ b/ege__ParticuleSimple.html @@ -0,0 +1,154 @@ + + + + + ege Library + + + +
    +
    +

    ege Library

    +
  • ege
    • + + +
    +
    +
    +

    Class: ege::ParticuleSimple

    +
    +

    Synopsis:

    +
    ++        ParticuleSimple  (ege::ParticuleEngine & _particuleEngine,
                               const char * _particuleType);
    +       ~ParticuleSimple  (void);
    +  void  update           (float _delta);
    +  bool  needRemove       (void);
    +  void  init             (void);
    +  void  setLife          (float _life);
    +  void  setLevel         (float _level);
    +  void  setPosition      (const vec3 & _pos);
    +  void  setAngle         (float _angle);
    +  void  setMoveSpeed     (const vec3 & _speed);
    +  void  setScale         (const vec3 & _scale);
    +  void  setScaleExpend   (const vec3 & _scaleExpand);
    + + +

    Object Hierarchy:

    +
    +Particule
+    +--> ege::ParticuleSimple
+
    +
    +

    Description:

    +/** +* @brief The particule class is an element with no control, when it will be created, +* it does not have any control, for example smoke or reactor generation ... +* or explosion particule ... +*/

    Detail:

    +

    ege::ParticuleSimple ()

    + +
    +ParticuleSimple(ege::ParticuleEngine & _particuleEngine,
+                const char * _particuleType);
    +
    +Constructor. +
    +
    + +
    +

    ege::~ParticuleSimple ()

    + +
    +~ParticuleSimple(void);
    +
    +Destructor. +

    + +
    +

    update ()

    + +
    +void update(float _delta);
    +
    +
    + +
    +

    needRemove ()

    + +
    +bool needRemove(void);
    +
    +
    + +
    +

    init ()

    + +
    +void init(void);
    +
    +
    + +
    +

    setLife ()

    + +
    +void setLife(float _life);
    +
    +
    + +
    +

    setLevel ()

    + +
    +void setLevel(float _level);
    +
    +
    + +
    +

    setPosition ()

    + +
    +void setPosition(const vec3 & _pos);
    +
    +
    + +
    +

    setAngle ()

    + +
    +void setAngle(float _angle);
    +
    +
    + +
    +

    setMoveSpeed ()

    + +
    +void setMoveSpeed(const vec3 & _speed);
    +
    +
    + +
    +

    setScale ()

    + +
    +void setScale(const vec3 & _scale);
    +
    +
    + +
    +

    setScaleExpend ()

    + +
    +void setScaleExpend(const vec3 & _scaleExpand);
    +
    +
    + +
    +
    + + diff --git a/ege__Scene.html b/ege__Scene.html new file mode 100644 index 0000000..65dd3af --- /dev/null +++ b/ege__Scene.html @@ -0,0 +1,249 @@ + + + + + ege Library + + + +
    +
    +

    ege Library

    +
  • ege
    • + + +
    +
    +
    +

    Class: ege::Scene

    +
    +

    Synopsis:

    +
    ++                      Scene                               (bool _setAutoBullet,
                                                                bool _setAutoCamera);
    +                     ~Scene                               (void);
    +  void                setBulletConfig                     (btDefaultCollisionConfiguration * _collisionConfiguration,
                                                                btCollisionDispatcher * _dispatcher,
                                                                btBroadphaseInterface * _broadphase,
                                                                btConstraintSolver * _solver,
                                                                btDynamicsWorld * _dynamicsWorld);
    +  void                setCamera                           (ege::Camera * _camera);
    +  void                pause                               (void);
    +  void                resume                              (void);
    +  void                pauseToggle                         (void);
    +  void                debugToggle                         (void);
    +  vec2                calculateDeltaAngle                 (const vec2 & _posScreen);
    +  vec3                convertScreenPositionInMapPosition  (const vec2 & _posScreen);
    +  ege::Camera &       getCamera                           (void);
    +  void                setRatioTime                        (float _newRatio);
    +  void                renderscene                         (int pass);
    +  void                drawOpenGL                          (btScalar * m,
                                                                const btCollisionShape * _shape,
                                                                const btVector3 & _color,
                                                                int32_t _debugMode,
                                                                const btVector3 & _worldBoundsMin,
                                                                const btVector3 & _worldBoundsMax);
    +  void                drawSphere                          (btScalar _radius,
                                                                int _lats,
                                                                int _longs,
                                                                mat4 & _transformationMatrix,
                                                                etk::Color<float> & _tmpColor);
    +  void                getElementAroundNewElement          (vec3 _sourcePosition,
                                                                std::vector & _resultList);
    +  const char * const  getObjectType                       (void);
    +  void                systemDraw                          (const ewol::DrawProperty & _displayProp);
    +  void                onRegenerateDisplay                 (void);
    +  void                periodicCall                        (const ewol::EventTime & _event);
    #  void                ScenePeriodicCall                   (int64_t _localTime,
                                                                int32_t _deltaTime);
    #  void                onDraw                              (void);
    + + +

    Object Hierarchy:

    +
    +ewol::Widget
+    +--> ege::Scene
+
    +
    +

    Detail:

    +

    ege::Scene ()

    + +
    +Scene(bool _setAutoBullet,
+      bool _setAutoCamera);
    +
    +Constructor of the widget classes +
    +
    + +
    +

    ege::~Scene ()

    + +
    +~Scene(void);
    +
    +Destructor of the widget classes +

    + +
    +

    setBulletConfig ()

    + +
    +void setBulletConfig(btDefaultCollisionConfiguration * _collisionConfiguration,
+                     btCollisionDispatcher * _dispatcher,
+                     btBroadphaseInterface * _broadphase,
+                     btConstraintSolver * _solver,
+                     btDynamicsWorld * _dynamicsWorld);
    +
    +
    + +
    +

    setCamera ()

    + +
    +void setCamera(ege::Camera * _camera);
    +
    +
    + +
    +

    pause ()

    + +
    +void pause(void);
    +
    +set the scene in pause for a while +

    + +
    +

    resume ()

    + +
    +void resume(void);
    +
    +resume the scene activity +

    + +
    +

    pauseToggle ()

    + +
    +void pauseToggle(void);
    +
    +Toggle between pause and running +

    + +
    +

    debugToggle ()

    + +
    +void debugToggle(void);
    +
    +Toggle the debug mode == > usefull for DEBUG only ... +

    + +
    +

    calculateDeltaAngle ()

    + +
    +vec2 calculateDeltaAngle(const vec2 & _posScreen);
    +
    +
    + +
    +

    convertScreenPositionInMapPosition ()

    + +
    +vec3 convertScreenPositionInMapPosition(const vec2 & _posScreen);
    +
    +
    + +
    +

    getCamera ()

    + +
    +ege::Camera & getCamera(void);
    +
    +get the current camera reference for the scene rendering +

    + +
    +

    setRatioTime ()

    + +
    +void setRatioTime(float _newRatio);
    +
    +set the curent Time Ratio (default 1) +

    + +
    +

    renderscene ()

    + +
    +void renderscene(int pass);
    +
    +
    + +
    +

    drawOpenGL ()

    + +
    +void drawOpenGL(btScalar * m,
+                const btCollisionShape * _shape,
+                const btVector3 & _color,
+                int32_t _debugMode,
+                const btVector3 & _worldBoundsMin,
+                const btVector3 & _worldBoundsMax);
    +
    +
    + +
    +

    drawSphere ()

    + +
    +void drawSphere(btScalar _radius,
+                int _lats,
+                int _longs,
+                mat4 & _transformationMatrix,
+                etk::Color<float> & _tmpColor);
    +
    +
    + +
    +

    getElementAroundNewElement ()

    + +
    +void getElementAroundNewElement(vec3 _sourcePosition,
+                                std::vector & _resultList);
    +
    +
    + +
    +

    getObjectType ()

    + +
    +const char * const getObjectType(void);
    +
    +
    + +
    +

    systemDraw ()

    + +
    +void systemDraw(const ewol::DrawProperty & _displayProp);
    +
    +
    + +
    +

    onRegenerateDisplay ()

    + +
    +void onRegenerateDisplay(void);
    +
    +
    + +
    +

    periodicCall ()

    + +
    +void periodicCall(const ewol::EventTime & _event);
    +
    +
    + +
    +

    ScenePeriodicCall ()

    + +
    +void ScenePeriodicCall(int64_t _localTime,
+                       int32_t _deltaTime);
    +
    +
    + +
    +

    onDraw ()

    + +
    +void onDraw(void);
    +
    +
    + +
    +
    + + diff --git a/ege__resource__ParticuleMesh.html b/ege__resource__ParticuleMesh.html new file mode 100644 index 0000000..07533be --- /dev/null +++ b/ege__resource__ParticuleMesh.html @@ -0,0 +1,109 @@ + + + + + ege Library + + + +
    +
    +

    ege Library

    +
  • ege
    • + + +
    +
    +
    +

    Class: ege::resource::ParticuleMesh

    +
    +

    Synopsis:

    +
    ++  const char *                           getType        (void);
    +  void                                   draw           (mat4 & _positionMatrix,
                                                              const etk::Color<float> & _mainColor,
                                                              bool _enableDepthTest,
                                                              bool _enableDepthUpdate);
    +  static ege::resource::ParticuleMesh *  keep           (const std::string & _meshName,
                                                              const std::string & _shaderName);
    +  static void                            release        (ege::resource::ParticuleMesh * & _object);
    #                                         ParticuleMesh  (const std::string & _fileName,
                                                              const std::string & _shaderName);
    #                                        ~ParticuleMesh  (void);
    + + +

    Object Hierarchy:

    +
    +ewol::Mesh
+    +--> ege::resource::ParticuleMesh
+
    +
    +

    Detail:

    +

    getType ()

    + +
    +const char * getType(void);
    +
    +
    + +
    +

    draw ()

    + +
    +void draw(mat4 & _positionMatrix,
+          const etk::Color<float> & _mainColor,
+          bool _enableDepthTest,
+          bool _enableDepthUpdate);
    +
    +
    + +
    +

    ege::resource::keep ()

    + +
    +static ege::resource::ParticuleMesh * keep(const std::string & _meshName,
+                                           const std::string & _shaderName);
    +
    +keep the resource pointer. +
    Notes: Never free this pointer by your own... +
    +
    + +
    +

    ege::resource::release ()

    + +
    +static void release(ege::resource::ParticuleMesh * & _object);
    +
    +release the keeped resources +
    +
    + +
    +

    ege::resource::ParticuleMesh ()

    + +
    +ParticuleMesh(const std::string & _fileName,
+              const std::string & _shaderName);
    +
    +
    + +
    +

    ege::resource::~ParticuleMesh ()

    + +
    +~ParticuleMesh(void);
    +
    +
    + +
    +
    + + diff --git a/index.html b/index.html new file mode 100644 index 0000000..936a572 --- /dev/null +++ b/index.html @@ -0,0 +1,32 @@ + + + + + ege Library + + + +
    +
    +

    ege Library

    +
  • ege
    • + + +
    +
    +
    +

    ege


    TODO : Main page ...

    + +