atria-soft/ege
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] start to have a generic game engine

Browse Source
This commit is contained in:
Edouard DUPIN 2013-08-14 22:48:01 +02:00
parent 926bbe6b3d
commit eefbe48546
9 changed files with 240 additions and 202 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
ege/ElementGame.cpp
View File

@ -43,7 +43,8 @@ ege::ElementGame::ElementGame(ege::Environement& _env) :
m_group(0),
m_fixe(true),
m_radius(0),
m_elementInPhysicsSystem(false)
m_elementInPhysicsSystem(false),
m_IA(NULL)
{
static uint32_t unique=0;
m_uID = unique;
@ -53,6 +54,10 @@ ege::ElementGame::ElementGame(ege::Environement& _env) :
ege::ElementGame::~ElementGame(void)
{
// in every case remove IA
IADisable();
// same ...
DynamicDisable();
EGE_DEBUG("Destroy element : uId=" << m_uID);
}
@ -71,6 +76,9 @@ void ege::ElementGame::SetFireOn(int32_t groupIdSource, int32_t type, float powe
float previousLife = m_life;
m_life += power;
m_life = etk_avg(0, m_life, m_lifeMax);
if (m_life<=0) {
EGE_DEBUG("[" << GetUID() << "] element is killed ..." << GetType());
}
if (m_life!=previousLife) {
OnLifeChange();
}
@ -351,4 +359,33 @@ void ege::ElementGame::DynamicDisable(void)
}
}
void ege::ElementGame::IAEnable(void)
{
if (NULL != m_IA) {
// IA already started ...
return;
}
DynamicEnable();
m_IA = new localIA(*this);
if (NULL == m_IA) {
EGE_ERROR("Can not start the IA ==> allocation error");
return;
}
m_env.GetDynamicWorld()->addAction(m_IA);
}
void ege::ElementGame::IADisable(void)
{
if (NULL == m_IA) {
// IA already stopped ...
return;
}
m_env.GetDynamicWorld()->removeAction(m_IA);
// Remove IA :
delete(m_IA);
m_IA = NULL;
}

76
ege/ElementGame.h
View File

@ -45,6 +45,19 @@ namespace ege
* @brief Destructor
*/
virtual ~ElementGame(void);
/**
* @brief Get the element Type description string
* @return A pointer on the descriptive string (Do not free it ==> it might be a const)
*/
virtual const etk::UString& GetType(void) const;
private:
uint32_t m_uID; //!< This is a reference on a basic element ID
public:
/**
* @brief Get the curent Element Unique ID in the all Game.
* @return The requested Unique ID.
*/
inline uint32_t GetUID(void) const { return m_uID; };
protected:
ewol::Mesh* m_mesh; //!< Mesh of the Element (can be NULL)
btCollisionShape* m_shape; //!< shape of the element (set a copy here to have the debug display of it)
@ -88,22 +101,6 @@ namespace ege
* @brief Call chan the element life change
*/
virtual void OnLifeChange(void) {}
private:
uint32_t m_uID; //!< This is a reference on a basic element ID
public:
/**
* @brief Get the curent Element Unique ID in the all Game.
* @return The requested Unique ID.
*/
inline uint32_t GetUID(void) const
{
return m_uID;
}
/**
* @brief Get the element Type description string
* @return A pointer on the descriptive string (Do not free it ==> it might be a const)
*/
virtual const etk::UString& GetType(void) const;
protected:
int32_t m_group; //!< Every element has a generic group
public:
@ -203,10 +200,51 @@ namespace ege
bool m_elementInPhysicsSystem;
public:
/**
* @brief For intelligent system : this activate the Dynamic object
* @brief Set the elment in the physique engine
*/
virtual void DynamicEnable(void);
virtual void DynamicDisable(void);
void DynamicEnable(void);
/**
* @brief Remove this element from the physique engine
*/
void DynamicDisable(void);
private:
class localIA : public btActionInterface
{
private:
ege::ElementGame& m_element;
public:
/**
* @brief Constructor
*/
localIA(ElementGame& element) : m_element(element) { };
/**
* @brief Destructor
*/
virtual ~localIA(void) { };
// herited function
void debugDraw(btIDebugDraw* debugDrawer) { };
// herited function
void updateAction(btCollisionWorld* collisionWorld, btScalar step)
{
m_element.IAAction(step);
}
};
localIA* m_IA;
public:
/**
* @brief Enable periodic call Of this object for processing Artificial Intelligence
*/
void IAEnable(void);
/**
* @brief Disable periodic call Of this object for processing Artificial Intelligence
*/
void IADisable(void);
/**
* @brief Periodic call for intelligence artificial.
* @param[in] step : step of time in s
*/
virtual void IAAction(float _step) { };
};
};

63
ege/ElementGameIA.cpp
View File

@ -1,63 +0,0 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license BSD v3 (see license file)
*/
#include <ege/debug.h>
#include <ege/ElementGameIA.h>
#include <ewol/renderer/ResourceManager.h>
#include <BulletDynamics/Dynamics/btRigidBody.h>
#include <LinearMath/btDefaultMotionState.h>
#include <BulletDynamics/Dynamics/btDynamicsWorld.h>
#include <BulletCollision/CollisionShapes/btCollisionShape.h>
#include <LinearMath/btIDebugDraw.h>
#include <btBulletCollisionCommon.h>
#include <BulletCollision/CollisionShapes/btConvexPolyhedron.h>
#include <BulletCollision/CollisionShapes/btShapeHull.h>
#include <LinearMath/btTransformUtil.h>
#include <LinearMath/btIDebugDraw.h>
#include <btBulletDynamicsCommon.h>
#include <BulletCollision/CollisionDispatch/btCollisionObject.h>
ege::ElementGameIA::ElementGameIA(ege::Environement& _env) :
ElementGame(_env),
m_IA(*this),
m_isDynamicStarted(false)
{
}
ege::ElementGameIA::~ElementGameIA(void)
{
DynamicDisable();
}
void ege::ElementGameIA::DynamicEnable(void)
{
ege::ElementGame::DynamicEnable();
if (false == m_isDynamicStarted) {
m_env.GetDynamicWorld()->addAction(&m_IA);
m_isDynamicStarted = true;
}
}
void ege::ElementGameIA::DynamicDisable(void)
{
ege::ElementGame::DynamicDisable();
if (true == m_isDynamicStarted) {
m_env.GetDynamicWorld()->removeAction(&m_IA);
m_isDynamicStarted = false;
}
}

67
ege/ElementGameIA.h
View File

@ -1,67 +0,0 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license BSD v3 (see license file)
*/
#ifndef __EGE_ELEMENT_GAME_IA_H__
#define __EGE_ELEMENT_GAME_IA_H__
#include <ege/ElementGame.h>
namespace ege
{
class ElementGameIA : public ege::ElementGame
{
private:
class localIA : public btActionInterface
{
private:
ElementGameIA& m_element;
public:
/**
* @brief Constructor
*/
localIA(ElementGameIA& element) : m_element(element) { };
/**
* @brief Destructor
*/
virtual ~localIA(void) { };
// herited function
void debugDraw(btIDebugDraw* debugDrawer) { };
// herited function
void updateAction(btCollisionWorld* collisionWorld, btScalar step)
{
m_element.IAAction(step);
}
};
localIA m_IA;
public:
/**
* @brief Constructor
*/
ElementGameIA(ege::Environement& _env);
/**
* @brief Destructor
*/
virtual ~ElementGameIA(void);
/**
* @brief Periodic call for intelligence artificial.
* @param[in] step : step of time in s
*/
virtual void IAAction(float _step)=0;
private:
bool m_isDynamicStarted;
public:
virtual void DynamicEnable(void);
virtual void DynamicDisable(void);
};
};
#endif

40
ege/Environement.cpp
View File

@ -111,6 +111,46 @@ void ege::Environement::GetElementNearestFixed(const vec3& _sourcePosition,
}
}
static etk::Hash<ege::createElement_tf>& GetHachTableCreating(void)
{
static etk::Hash<ege::createElement_tf> s_table;
return s_table;
}
void ege::Environement::AddCreator(const etk::UString& _type, ege::createElement_tf _creator)
{
if (NULL == _creator) {
EGE_ERROR("Try to add an empty CREATOR ...");
return;
}
GetHachTableCreating().Add(_type, _creator);
}
ege::ElementGame* ege::Environement::CreateElement(const etk::UString& _type, const etk::UString& _description, bool _autoAddElement)
{
if (false==GetHachTableCreating().Exist(_type)) {
EGE_ERROR("Request creating of an type that is not known '" << _type << "'");
return NULL;
}
ege::createElement_tf pointerFunction = GetHachTableCreating()[_type];
if (NULL == pointerFunction) {
EGE_ERROR("NULL pointer ==> internal error... '" << _type << "'");
// internal error
return NULL;
}
ege::ElementGame* tmpElement = pointerFunction(*this, _description);
if (NULL == tmpElement) {
EGE_ERROR("Sub creator han an error when creating element : '" << _type << "'");
return NULL;
}
if (_autoAddElement==true) {
AddElementGame(tmpElement);
}
return tmpElement;
}
void ege::Environement::AddElementGame(ege::ElementGame* _newElement)
{
// prevent memory allocation and un allocation ...

21
ege/Environement.h
View File

@ -9,6 +9,7 @@
#ifndef __EGE_ENVIRONEMENT_H__
#define __EGE_ENVIRONEMENT_H__
#include <etk/UString.h>
#include <BulletDynamics/Dynamics/btActionInterface.h>
class btDynamicsWorld;
@ -17,6 +18,9 @@ class btDynamicsWorld;
namespace ege {
class ElementGame;
class Environement;
typedef ege::ElementGame* (*createElement_tf)(ege::Environement& _env, const etk::UString& _description);
class Environement
{
private:
@ -25,7 +29,22 @@ namespace ege {
public:
Environement(void) : m_dynamicsWorld(NULL) { };
virtual ~Environement(void) { };
public:
/**
* @brief Add a creator element system
* @param[in] _type Type of the element.
* @param[in] _creator Function pointer that reference the element creating.
*/
static void AddCreator(const etk::UString& _type, ege::createElement_tf _creator);
/**
* @brief Create an element on the curent scene.
* @param[in] _type Type of the element that might be created.
* @param[in] _description String that describe the content of the element properties.
* @param[in] _autoAddElement this permit to add the element if it is created ==> no more action ...
* @return NULL if an error occured OR the pointer on the element and it is already added on the system.
* @note Pointer is return in case of setting properties on it...
*/
ege::ElementGame* CreateElement(const etk::UString& _type, const etk::UString& _description, bool _autoAddElement=true);
public:
class ResultNearestElement
{

100
ege/Scene.cpp
View File

@ -41,12 +41,17 @@ const char * const ege::Scene::eventKillEnemy = "event-scene-kill-ennemy";
#define WALK_FLAG_RIGHT (1<<3)
#define WALK_FLAG_CAUTION (1<<4)
ege::Scene::Scene(void) :
ege::Scene::Scene(btDefaultCollisionConfiguration* _collisionConfiguration,
btCollisionDispatcher* _dispatcher,
btBroadphaseInterface* _broadphase,
btConstraintSolver* _solver,
btDynamicsWorld* _dynamicsWorld,
ege::Camera* _camera) :
m_gameTime(0),
m_angleView(M_PI/3.0),
m_finger_DoubleTouch(false),
m_dynamicsWorld(NULL),
m_camera(vec3(0,0,0), 0, DEG_TO_RAD(45) ,50),
m_camera(NULL),
m_isRunning(true),
m_walk(0),
m_debugMode(false),
@ -60,26 +65,48 @@ ege::Scene::Scene(void) :
ewol::resource::Keep(m_debugDrawing);
m_zoom = 1.0/1000.0;
m_ratioTime = 1.0f;
if (NULL != _collisionConfiguration) {
m_collisionConfiguration = _collisionConfiguration;
} else {
m_collisionConfiguration = new btDefaultCollisionConfiguration();
}
///use the default collision dispatcher.
if (NULL != _dispatcher) {
m_dispatcher = _dispatcher;
} else {
m_dispatcher = new btCollisionDispatcher(m_collisionConfiguration);
}
if (NULL != _broadphase) {
m_broadphase = _broadphase;
} else {
m_broadphase = new btDbvtBroadphase();
}
///the default constraint solver.
btSequentialImpulseConstraintSolver* sol = new btSequentialImpulseConstraintSolver;
m_solver = sol;
if (NULL != _solver) {
m_solver = _solver;
} else {
m_solver = new btSequentialImpulseConstraintSolver();
}
if (NULL != _dynamicsWorld) {
m_dynamicsWorld = _dynamicsWorld;
} else {
m_dynamicsWorld = new btDiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration);
// in space, we set no gravity ...
// By default we set no gravity
m_dynamicsWorld->setGravity(btVector3(0,0,0));
}
m_env.SetDynamicWorld(m_dynamicsWorld);
if (NULL != _camera) {
m_camera = _camera;
} else {
m_camera = new ege::Camera(vec3(0,0,0), 0, DEG_TO_RAD(45) ,50);
// SET THE STATION ..
m_camera.SetEye(vec3(0,0,0));
m_camera->SetEye(vec3(0,0,0));
}
}
@ -162,12 +189,12 @@ void ege::Scene::OnDraw(void)
//EGE_DEBUG("Draw (start)");
mat4 tmpMatrix;
if (m_dynamicsWorld) {
m_env.GetOrderedElementForDisplay(m_displayElementOrdered, m_camera.GetOrigin(), m_camera.GetViewVector());
m_env.GetOrderedElementForDisplay(m_displayElementOrdered, m_camera->GetOrigin(), m_camera->GetViewVector());
//EGE_DEBUG("DRAW : " << m_displayElementOrdered.Size() << " elements");
// TODO : Remove this ==> no more needed ==> checked in the Generate the list of the element ordered
for (int32_t iii=0; iii<m_displayElementOrdered.Size(); iii++) {
m_displayElementOrdered[iii].element->PreCalculationDraw(m_camera);
m_displayElementOrdered[iii].element->PreCalculationDraw(*m_camera);
}
// note : the first pass is done at the reverse way to prevent multiple display od the same point in the screen
// (and we remember that the first pass is to display all the non transparent elements)
@ -186,12 +213,12 @@ void ege::Scene::OnDraw(void)
}
}
for (int32_t iii=0; iii<m_displayElementOrdered.Size(); iii++) {
m_displayElementOrdered[iii].element->DrawLife(m_debugDrawing, m_camera);
m_displayElementOrdered[iii].element->DrawLife(m_debugDrawing, *m_camera);
}
#ifdef DEBUG
if (true == m_debugMode) {
for (int32_t iii=0; iii<m_displayElementOrdered.Size(); iii++) {
m_displayElementOrdered[iii].element->DrawDebug(m_debugDrawing, m_camera);
m_displayElementOrdered[iii].element->DrawDebug(m_debugDrawing, *m_camera);
}
}
#endif
@ -247,7 +274,7 @@ void ege::Scene::PeriodicCall(const ewol::EventTime& _event)
//EWOL_DEBUG("Time: m_lastCallTime=" << m_lastCallTime << " deltaTime=" << deltaTime);
// update camera positions:
m_camera.PeriodicCall(curentDelta);
m_camera->PeriodicCall(curentDelta);
//EGE_DEBUG("stepSimulation (start)");
///step the simulation
@ -261,13 +288,14 @@ void ege::Scene::PeriodicCall(const ewol::EventTime& _event)
int32_t numberEnnemyKilled=0;
int32_t victoryPoint=0;
etk::Vector<ege::ElementGame*>& elementList = m_env.GetElementGame();
for (int32_t iii=0; iii<elementList.Size(); iii++) {
for (int32_t iii=elementList.Size()-1; iii>=0; --iii) {
if(NULL != elementList[iii]) {
if (true == elementList[iii]->NeedToRemove()) {
if (elementList[iii]->GetGroup() > 1) {
numberEnnemyKilled++;
victoryPoint++;
}
EGE_DEBUG("[" << elementList[iii]->GetUID() << "] element Removing ... " << elementList[iii]->GetType());
m_env.RmElementGame(elementList[iii]);
}
}
@ -290,14 +318,14 @@ void ege::Scene::PeriodicCall(const ewol::EventTime& _event)
walkValue = -1;
}
if (walkValue!=0) {
float angleZ = m_camera.GetAngleZ();
float angleZ = m_camera->GetAngleZ();
vec3 offsetPosition( cosf(angleZ-M_PI/2.0)*walkValue,
-sinf(angleZ-M_PI/2.0)*walkValue,
0);
//EWOL_DEBUG("Walk : " << ((int32_t)(angles.z/M_PI*180+180)%360-180) << " ==> " << angles);
// walk is 6 km/h
vec3 pos = m_camera.GetEye() + offsetPosition*l_walkRatio*curentDelta;
m_camera.SetEye(pos);
vec3 pos = m_camera->GetEye() + offsetPosition*l_walkRatio*curentDelta;
m_camera->SetEye(pos);
}
walkValue=0;
if( (m_walk&WALK_FLAG_LEFT)!=0
@ -310,14 +338,14 @@ void ege::Scene::PeriodicCall(const ewol::EventTime& _event)
walkValue = -1;
}
if (walkValue != 0) {
float angleZ = m_camera.GetAngleZ();
float angleZ = m_camera->GetAngleZ();
vec3 offsetPosition( cosf(angleZ)*walkValue,
-sinf(angleZ)*walkValue,
0);
//EWOL_DEBUG("Walk : " << ((int32_t)(angles.z/M_PI*180+180)%360-180) << " ==> " << angles);
// lateral walk is 4 km/h
vec3 pos = m_camera.GetEye() + offsetPosition*l_walkLateralRatio*curentDelta;
m_camera.SetEye(pos);
vec3 pos = m_camera->GetEye() + offsetPosition*l_walkLateralRatio*curentDelta;
m_camera->SetEye(pos);
}
}
}
@ -351,8 +379,8 @@ float tmp___localTime1 = (float)(ewol::GetTime() - tmp___startTime1) / 1000.0f;
EWOL_DEBUG(" SCENE111 : " << tmp___localTime1 << "ms ");
int64_t tmp___startTime2 = ewol::GetTime();
#endif
ewol::openGL::SetCameraMatrix(m_camera.GetMatrix());
//mat4 tmpMat = tmpProjection * m_camera.GetMatrix();
ewol::openGL::SetCameraMatrix(m_camera->GetMatrix());
//mat4 tmpMat = tmpProjection * m_camera->GetMatrix();
// set internal matrix system :
//ewol::openGL::SetMatrix(tmpMat);
ewol::openGL::SetMatrix(tmpProjection);
@ -397,7 +425,7 @@ vec2 ege::Scene::CalculateDeltaAngle(const vec2& posScreen)
vec3 ege::Scene::ConvertScreenPositionInMapPosition(const vec2& posScreen)
{
return m_camera.projectOnZGround(CalculateDeltaAngle(posScreen));
return m_camera->projectOnZGround(CalculateDeltaAngle(posScreen));
}
bool ege::Scene::OnEventInput(const ewol::EventInput& _event)
@ -430,8 +458,8 @@ bool ege::Scene::OnEventInput(const ewol::EventInput& _event)
if (ewol::keyEvent::statusMove == _event.GetStatus()) {
vec2 tmppPos = relPos-m_centerButtonStartPos;
tmppPos *= M_PI/(360.0f*6);
m_camera.SetAngleZ(m_camera.GetAngleZ()- tmppPos.x());
m_camera.SetAngleTeta(m_camera.GetAngleTeta()-tmppPos.y());
m_camera->SetAngleZ(m_camera->GetAngleZ()- tmppPos.x());
m_camera->SetAngleTeta(m_camera->GetAngleTeta()-tmppPos.y());
}
// update register position ...
m_centerButtonStartPos = relPos;
@ -440,12 +468,12 @@ bool ege::Scene::OnEventInput(const ewol::EventInput& _event)
if (ewol::keyEvent::statusMove == _event.GetStatus()) {
vec3 nextPosition = ConvertScreenPositionInMapPosition(relPos);
vec3 tmppPos = nextPosition-m_finger_StartPosMoving;
vec3 oldposition = m_camera.GetEye();
vec3 oldposition = m_camera->GetEye();
// update the camera positions:
oldposition.setX(oldposition.x() - tmppPos.x());
oldposition.setY(oldposition.y() - tmppPos.y());
// set the new position
m_camera.SetEye(oldposition);
m_camera->SetEye(oldposition);
}
// update register position ...
m_leftButtonStartPos = relPos;
@ -453,16 +481,16 @@ bool ege::Scene::OnEventInput(const ewol::EventInput& _event)
} else if (4 == _event.GetId()) {
if (ewol::keyEvent::statusSingle == _event.GetStatus()) {
// scrool input
float cameraDistance = m_camera.GetDistance()-3;
float cameraDistance = m_camera->GetDistance()-3;
EGE_DEBUG("New camera distance : " << etk_avg(10, cameraDistance, 100));
m_camera.SetDistance(etk_avg(10, cameraDistance, 100));
m_camera->SetDistance(etk_avg(10, cameraDistance, 100));
}
} else if (5 == _event.GetId()) {
if (ewol::keyEvent::statusSingle == _event.GetStatus()) {
// scrool output
float cameraDistance = m_camera.GetDistance()+3;
float cameraDistance = m_camera->GetDistance()+3;
EGE_DEBUG("New camera distance : " << etk_avg(10, cameraDistance, 100));
m_camera.SetDistance(etk_avg(10, cameraDistance, 100));
m_camera->SetDistance(etk_avg(10, cameraDistance, 100));
}
}
/*
@ -504,9 +532,9 @@ bool ege::Scene::OnEventInput(const ewol::EventInput& _event)
realDistance /= 2.0f;
if (m_finger_oldDistance>=0) {
float distanceDelta = m_finger_oldDistance-realDistance;
m_camera.SetDistance(etk_avg(10,m_camera.GetDistance()+distanceDelta/3.0f,100));
m_camera->SetDistance(etk_avg(10,m_camera->GetDistance()+distanceDelta/3.0f,100));
float angleDelta = m_finger_oldAngle - fingerAngle;
m_camera.SetAngleZ(m_camera.GetAngleZ()+angleDelta);
m_camera->SetAngleZ(m_camera->GetAngleZ()+angleDelta);
}
m_finger_oldDistance = realDistance;
m_finger_oldAngle = fingerAngle;
@ -536,9 +564,9 @@ bool ege::Scene::OnEventInput(const ewol::EventInput& _event)
realDistance /= 2.0f;
if (m_finger_oldDistance>=0) {
float distanceDelta = m_finger_oldDistance-realDistance;
m_camera.SetDistance(etk_avg(10,m_camera.GetDistance()+distanceDelta/3.0f,100));
m_camera->SetDistance(etk_avg(10,m_camera->GetDistance()+distanceDelta/3.0f,100));
float angleDelta = m_finger_oldAngle - fingerAngle;
m_camera.SetAngleZ(m_camera.GetAngleZ()+angleDelta);
m_camera->SetAngleZ(m_camera->GetAngleZ()+angleDelta);
}
m_finger_oldDistance = realDistance;
m_finger_oldAngle = fingerAngle;

23
ege/Scene.h
View File

@ -46,7 +46,12 @@ namespace ege {
* @brief Constructor of the widget classes
* @return (no execption generated (not managed in embended platform))
*/
Scene(void);
Scene(btDefaultCollisionConfiguration* _collisionConfiguration=NULL,
btCollisionDispatcher* _dispatcher=NULL,
btBroadphaseInterface* _broadphase=NULL,
btConstraintSolver* _solver=NULL,
btDynamicsWorld* _dynamicsWorld=NULL,
ege::Camera* _camera=NULL);
/**
* @brief Destructor of the widget classes
*/
@ -70,14 +75,12 @@ namespace ege {
btConstraintSolver* m_solver;
btDynamicsWorld* m_dynamicsWorld;
// camera section
ege::Camera m_camera; //!< Display point of view.
ege::Camera* m_camera; //!< Display point of view.
vec3 m_cameraMovePointStart; //!< Position where the mouse start to move
// Other elements
bool m_isRunning; //!< the display is running (not in pause)
float m_ratioTime; //!< Ratio time for the speed of the game ...
uint32_t m_walk; //!< Wolk properties
bool m_debugMode;
ewol::Colored3DObject* m_debugDrawing; //!< for the debug draw elements
// Note : This is only for temporary elements : on the display
etk::Vector<ege::Environement::ResultNearestElement> m_displayElementOrdered;
public:
@ -93,20 +96,24 @@ namespace ege {
* @brief Toggle between pause and running
*/
void PauseToggle(void);
protected:
bool m_debugMode;
ewol::Colored3DObject* m_debugDrawing; //!< for the debug draw elements
public:
/**
* @brief Toggle the debug mode ==> usefull for DEBUG only ...
*/
void DebugToggle(void) { m_debugMode = m_debugMode?false:true; };
protected:
// Derived function
virtual void ScenePeriodicCall(int64_t localTime, int32_t deltaTime) { };
// camera properties :
private:
float m_zoom;
public:
vec2 CalculateDeltaAngle(const vec2& posScreen);
vec3 ConvertScreenPositionInMapPosition(const vec2& posScreen);
/**
* @brief Get the current camera reference for the scene rendering
*/
ege::Camera& GetCamera(void) { return m_camera; };
ege::Camera& GetCamera(void) { return *m_camera; };
/**
* @brief Set the curent Time Ratio (default 1)
*/

1
lutin_ege.py
View File

@ -13,7 +13,6 @@ def Create(target):
'ege/AudioEngine.cpp',
'ege/Camera.cpp',
'ege/ElementGame.cpp',
'ege/ElementGameIA.cpp',
'ege/Particule.cpp',
'ege/ParticuleEngine.cpp',
'ege/Scene.cpp',