class: ege::widget::Scene

Description:

Constructor and Destructor:

+                                                              Scene                              (bool _setAutoBullet,
                                                                                                   bool _setAutoCamera);
+ virtual                                                      ~Scene                             (void );

Synopsis:

+         const char* const                                    eventPlayTimeChange;
+         const char* const                                    eventKillEnemy;
#         ege::Environement                                    m_env;
+         void                                                 setBulletConfig                    (btDefaultCollisionConfiguration* _collisionConfiguration,
                                                                                                   btCollisionDispatcher* _dispatcher,
                                                                                                   btBroadphaseInterface* _broadphase,
                                                                                                   btConstraintSolver* _solver,
                                                                                                   btDynamicsWorld* _dynamicsWorld);
+         void                                                 setCamera                          (ege::Camera* _camera);
#         float                                                m_angleView;
#         btDefaultCollisionConfiguration*                     m_collisionConfiguration;
#         btCollisionDispatcher*                               m_dispatcher;
#         btBroadphaseInterface*                               m_broadphase;
#         btConstraintSolver*                                  m_solver;
#         btDynamicsWorld*                                     m_dynamicsWorld;
#         ege::Camera*                                         m_camera;
#         bool                                                 m_isRunning;
#         float                                                m_ratioTime;
#         std::vector<ege::Environement::ResultNearestElement> m_displayElementOrdered;
+         void                                                 pause                              (void );
+         void                                                 resume                             (void );
+         void                                                 pauseToggle                        (void );
#         bool                                                 m_debugMode;
#         ewol::resource::Colored3DObject*                     m_debugDrawing;
+         void                                                 debugToggle                        (void );
# virtual void                                                 ScenePeriodicCall                  (int64_t _localTime,
                                                                                                   int32_t _deltaTime);
+         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<ege::Environement::ResultNearestElement> & _resultList);
# virtual void                                                 onDraw                             (void );
+ virtual void                                                 systemDraw                         (const ewol::DrawProperty & _displayProp);
+ virtual void                                                 onRegenerateDisplay                (void );
+ virtual void                                                 periodicCall                       (const ewol::event::Time & _event);

Object Hierarchy:

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

Detail:

eventPlayTimeChange

+ const char* const eventPlayTimeChange;

eventKillEnemy

+ const char* const eventKillEnemy;

m_env

# ege::Environement m_env;

Scene

+  Scene (bool _setAutoBullet,
          bool _setAutoCamera);

Constructor of the widget classes

Return:

(no execption generated (not managed in embended platform))

~Scene

+ virtual  ~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);

m_angleView

# float m_angleView;

m_collisionConfiguration

# btDefaultCollisionConfiguration* m_collisionConfiguration;

this is the most important class

m_dispatcher

# btCollisionDispatcher* m_dispatcher;

m_broadphase

# btBroadphaseInterface* m_broadphase;

m_solver

# btConstraintSolver* m_solver;

m_dynamicsWorld

# btDynamicsWorld* m_dynamicsWorld;

m_camera

# ege::Camera* m_camera;

display point of view.

m_isRunning

# bool m_isRunning;

the display is running (not in pause)

m_ratioTime

# float m_ratioTime;

Ratio time for the speed of the game ...

m_displayElementOrdered

# std::vector<ege::Environement::ResultNearestElement> m_displayElementOrdered;

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

m_debugMode

# bool m_debugMode;

m_debugDrawing

# ewol::resource::Colored3DObject* m_debugDrawing;

for the debug draw elements

debugToggle

+ void debugToggle (void );

Toggle the debug mode == > usefull for DEBUG only ...

ScenePeriodicCall

# virtual void ScenePeriodicCall (int64_t _localTime,
                                  int32_t _deltaTime);

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<ege::Environement::ResultNearestElement> & _resultList);

onDraw

# virtual void onDraw (void );

Common widget drawing function (called by the drawing thread [Android, X11, ...])

systemDraw

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

{SYSTEM} extern interface to request a draw ... (called by the drawing thread [Android, X11, ...]) This function generate a clipping with the viewport openGL system. Like this a widget draw can not draw over an other widget
Note: This function is virtual for the scrolled widget, and the more complicated openGl widget
Note: : INTERNAL EWOL SYSTEM

Parameter [input]:

_displayProp

properties of the current display

onRegenerateDisplay

+ virtual void onRegenerateDisplay (void );

Event generated when a redraw is needed

periodicCall

+ virtual void periodicCall (const ewol::event::Time & _event);

periodic call of this widget

Parameter:

_event

Current time property

ege library

[ sources ]

API:

Associate libraries: