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

[DEV] some renames to be more common with other engines

Browse Source
This commit is contained in:
Edouard DUPIN 2017-05-22 22:25:37 +02:00
parent 3f22081ced
commit d154b0c901
37 changed files with 768 additions and 811 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ege/Engine.hpp
View File

@ -31,12 +31,12 @@ namespace ege {
*/
virtual const std::string& getType() const;
/**
* @brief An ege::Element component has been removed ==> need remove it in local if needed
* @brief An ege::Entity component has been removed ==> need remove it in local if needed
* @param[in] _ref Referrence on the component
*/
virtual void componentRemove(const ememory::SharedPtr<ege::Component>& _ref);
/**
* @brief An ege::Element component has been added ==> need add it in local if needed
* @brief An ege::Entity component has been added ==> need add it in local if needed
* @param[in] _ref Referrence on the component
*/
virtual void componentAdd(const ememory::SharedPtr<ege::Component>& _ref);

40
ege/elements/Element.cpp → ege/Entity.cpp
View File

@ -6,17 +6,17 @@
#include <etk/types.hpp>
#include <ege/debug.hpp>
#include <ege/elements/Element.hpp>
#include <ege/Entity.hpp>
#include <ege/Environement.hpp>
const std::string& ege::Element::getType() const {
const std::string& ege::Entity::getType() const {
static const std::string nameType("----");
return nameType;
}
ege::Element::Element(const ememory::SharedPtr<ege::Environement>& _env) :
ege::Entity::Entity(const ememory::SharedPtr<ege::Environement>& _env) :
m_env(_env),
m_uID(0),
m_life(100),
@ -25,16 +25,16 @@ ege::Element::Element(const ememory::SharedPtr<ege::Environement>& _env) :
m_radius(0) {
static uint32_t unique=0;
m_uID = unique;
EGE_DEBUG("Create element: uId=" << m_uID);
EGE_DEBUG("Create Entity: uId=" << m_uID);
//m_debugText.setFontSize(12);
unique++;
}
ege::Element::~Element() {
EGE_DEBUG("Destroy element: uId=" << m_uID);
ege::Entity::~Entity() {
EGE_DEBUG("Destroy Entity: uId=" << m_uID);
}
void ege::Element::addComponent(const ememory::SharedPtr<ege::Component>& _ref) {
void ege::Entity::addComponent(const ememory::SharedPtr<ege::Component>& _ref) {
if (_ref == nullptr) {
EGE_ERROR("try to add an empty component");
return;
@ -93,7 +93,7 @@ void ege::Element::addComponent(const ememory::SharedPtr<ege::Component>& _ref)
}
}
void ege::Element::rmComponent(const ememory::SharedPtr<ege::Component>& _ref) {
void ege::Entity::rmComponent(const ememory::SharedPtr<ege::Component>& _ref) {
if (_ref == nullptr) {
EGE_ERROR("try to remove an empty component");
return;
@ -123,7 +123,7 @@ void ege::Element::rmComponent(const ememory::SharedPtr<ege::Component>& _ref) {
}
}
void ege::Element::rmComponent(const std::string& _type) {
void ege::Entity::rmComponent(const std::string& _type) {
int32_t findId = -1;
ememory::SharedPtr<ege::Component> componentRemoved;
// check if not exist
@ -155,45 +155,45 @@ void ege::Element::rmComponent(const std::string& _type) {
bool ege::Element::init() {
bool ege::Entity::init() {
EGE_WARNING("init() not implemented: uId=" << m_uID);
return false;
}
bool ege::Element::initString(const std::string& _description) {
bool ege::Entity::initString(const std::string& _description) {
EGE_WARNING("String Init not implemented: uId=" << m_uID);
return false;
}
bool ege::Element::initXML(const exml::Node& _node) {
bool ege::Entity::initXML(const exml::Node& _node) {
EGE_WARNING("xml Init not implemented: uId=" << m_uID);
return false;
}
bool ege::Element::initJSON(const ejson::Value& _value) {
bool ege::Entity::initJSON(const ejson::Value& _value) {
EGE_WARNING("JSON Init not implemented: uId=" << m_uID);
return false;
}
bool ege::Element::initVoid(void* _value) {
bool ege::Entity::initVoid(void* _value) {
EGE_WARNING("joid* Init not implemented: uId=" << m_uID);
return false;
}
bool ege::Element::unInit() {
bool ege::Entity::unInit() {
return true;
}
float ege::Element::getLifeRatio() {
float ege::Entity::getLifeRatio() {
if (0 >= m_life) {
return 0;
}
return m_life/m_lifeMax;
}
void ege::Element::setFireOn(int32_t _groupIdSource, int32_t _type, float _power, const vec3& _center) {
void ege::Entity::setFireOn(int32_t _groupIdSource, int32_t _type, float _power, const vec3& _center) {
float previousLife = m_life;
m_life += _power;
m_life = std::avg(0.0f, m_life, m_lifeMax);
if (m_life <= 0) {
EGE_DEBUG("[" << getUID() << "] element is killed ..." << getType());
EGE_DEBUG("[" << getUID() << "] Entity is killed ..." << getType());
}
if (m_life != previousLife) {
onLifeChange();
@ -206,7 +206,7 @@ const float lifeWidth = 2.0f;
const float lifeYPos = 1.7f;
#if 0
void ege::Element::drawLife(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera) {
void ege::Entity::drawLife(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera) {
if (_draw == nullptr) {
return;
}
@ -246,7 +246,7 @@ void ege::Element::drawLife(ememory::SharedPtr<ewol::resource::Colored3DObject>
}
#endif
void ege::Element::drawDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera) {
void ege::Entity::drawDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera) {
/*
m_debugText.clear();
m_debugText.setColor(etk::Color<>(0x00, 0xFF, 0x00, 0xFF));

60
ege/elements/Element.hpp → ege/Entity.hpp
View File

@ -23,23 +23,23 @@
#define INDEX_FORWARD_AXIS (1)
#define INDEX_UP_AXIS (2)
#define ELEMENT_SCALE (1.0f/8.0f)
#define Entity_SCALE (1.0f/8.0f)
namespace ege {
class Element : public ememory::EnableSharedFromThis<Element> {
class Entity : public ememory::EnableSharedFromThis<Entity> {
protected:
ememory::SharedPtr<ege::Environement> m_env;
public:
/**
* @brief 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,
* @brief Constructor (when constructer is called just add Entity that did not change.
* The objest will be stored in a pool of Entity and keep a second time if needed == > redure memory allocation,
* when needed, the system will call the init and un-init function...
*/
Element(const ememory::SharedPtr<ege::Environement>& _env);
Entity(const ememory::SharedPtr<ege::Environement>& _env);
/**
* @brief Destructor
*/
virtual ~Element();
virtual ~Entity();
protected:
std::vector<ememory::SharedPtr<ege::Component>> m_component;
public:
@ -48,15 +48,15 @@ namespace ege {
void rmComponent(const std::string& _type);
/**
* @brief get the element Type description string.
* @brief get the Entity Type description string.
* @return A reference on the descriptive string.
*/
virtual const std::string& getType() const;
/**
* @brief init the element with the defined properties
* @param[in] _property Type of the next element
* @brief init the Entity with the defined properties
* @param[in] _property Type of the next Entity
* @param[in] _value pointer on the value type
* @return true, the element is corectly initialized.
* @return true, the Entity is corectly initialized.
*/
virtual bool init();
virtual bool initString(const std::string& _description);
@ -65,10 +65,10 @@ namespace ege {
virtual bool initVoid(void* _value);
virtual bool unInit();
private:
uint32_t m_uID; //!< This is a reference on a basic element ID
uint32_t m_uID; //!< This is a reference on a basic Entity ID
public:
/**
* @brief get the curent Element Unique ID in the all Game.
* @brief get the curent Entity Unique ID in the all Game.
* @return The requested Unique ID.
*/
inline uint32_t getUID() const {
@ -76,7 +76,7 @@ namespace ege {
};
protected:
float m_life; //!< Current life of the object
float m_lifeMax; //!< Maximum possible life of the element
float m_lifeMax; //!< Maximum possible life of the Entity
public:
/**
* @brief get the curent life ratio [0..1]
@ -84,21 +84,21 @@ namespace ege {
*/
float getLifeRatio();
/**
* @brief Check if the element is dead.
* @return true if the element does not exist anymore, false otherwise.
* @brief Check if the Entity is dead.
* @return true if the Entity does not exist anymore, false otherwise.
*/
bool isDead() {
return (0 >= m_life)?true:false;
};
/**
* @brief Request if the element might be removed from the system
* @brief Request if the Entity might be removed from the system
* @return true == > the object is removed
*/
virtual bool needToRemove() {
return isDead();
}
/**
* @brief apply a fire on the element at a current power and a specific power.
* @brief apply a fire on the Entity at a current power and a specific power.
* @param[in] _groupIdSource Source Id of the group, by default all event arrive at all group, buf some event can not be obviously apply at the ennemy like reparing ....
* @param[in] _type Type of event on the life propertied
* @param[in] _power Power of the event (can be >0 for adding life).
@ -106,22 +106,22 @@ namespace ege {
*/
virtual void setFireOn(int32_t _groupIdSource, int32_t _type, float _power, const vec3& _center=vec3(0,0,0));
/**
* @brief Call when the element life change.
* @brief Call when the Entity life change.
*/
virtual void onLifeChange() { };
protected:
int32_t m_group; //!< Every element has a generic group
int32_t m_group; //!< Every Entity has a generic group
public:
/**
* @brief get the Group of the element.
* @brief get the Group of the Entity.
* @return The group ID
*/
inline int32_t getGroup() const {
return m_group;
};
/**
* @brief set the group of the curent element
* @param[in] newGroup The new Group ID of the element.
* @brief set the group of the curent Entity
* @param[in] newGroup The new Group ID of the Entity.
*/
inline void setGroup(int32_t _newGroup) {
m_group=_newGroup;
@ -131,28 +131,28 @@ namespace ege {
//ewol::compositing::Text m_debugText; // ==> this is reall y a bad idea==> it is inneficient ...
public:
/**
* @brief Debug display of the current element
* @brief Debug display of the current Entity
* @param[in,out] _draw Basic system to draw the debug shape and informations
* @param[in] _camera Current camera for display
*/
virtual void drawDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera);
/**
* @brief Event arrive when an element has been remove from the system == > this permit to keep pointer of ennemy, and not search them every cycle ...
* @param[in] _removedElement Pointer on the element removed.
* @brief Event arrive when an Entity has been remove from the system == > this permit to keep pointer of ennemy, and not search them every cycle ...
* @param[in] _removedEntity Pointer on the Entity removed.
*/
virtual void elementIsRemoved(ememory::SharedPtr<ege::Element> _removedElement) { };
virtual void entityIsRemoved(ememory::SharedPtr<ege::Entity> _removedEntity) { };
protected:
float m_radius; //!< Radius of the element (all element have a radius, if == 0 ==> then ghost ...
float m_radius; //!< Radius of the Entity (all Entity have a radius, if == 0 ==> then ghost ...
public:
/**
* @brief get the current space needed by the element in the workspace
* @brief get the current space needed by the Entity in the workspace
* @return The dimention needed.
*/
inline float getRadius() {
return m_radius;
};
/**
* @brief, call when the element is removed (call only one time)
* @brief, call when the Entity is removed (call only one time)
*/
virtual void onDestroy() {};
/**
@ -160,7 +160,7 @@ namespace ege {
*/
virtual void dynamicEnable() {};
/**
* @brief remove this element from the physique engine
* @brief remove this Entity from the physique engine
*/
virtual void dynamicDisable() {};

214
ege/Environement.cpp
View File

@ -6,7 +6,7 @@
#include <ege/debug.hpp>
#include <ege/Environement.hpp>
#include <ege/elements/Element.hpp>
#include <ege/Entity.hpp>
#include <ewol/object/Manager.hpp>
#include <ege/particule/Engine.hpp>
@ -116,52 +116,52 @@ void ege::Environement::engineComponentAdd(const ememory::SharedPtr<ege::Compone
}
/*
ememory::SharedPtr<ege::Element> ege::Environement::getElementNearest(ememory::SharedPtr<ege::Element> _sourceRequest, float& _distance) {
ememory::SharedPtr<ege::Entity> ege::Environement::getEntityNearest(ememory::SharedPtr<ege::Entity> _sourceRequest, float& _distance) {
if (_sourceRequest == nullptr) {
return nullptr;
}
vec3 sourcePosition = _sourceRequest->getPosition();
ememory::SharedPtr<ege::Element> result = nullptr;
for (size_t iii=0; iii<m_listElement.size() ; iii++) {
ememory::SharedPtr<ege::Entity> result = nullptr;
for (size_t iii=0; iii<m_listEntity.size() ; iii++) {
// chack nullptr pointer
if (m_listElement[iii] == nullptr) {
if (m_listEntity[iii] == nullptr) {
continue;
}
if (m_listElement[iii]->getGroup() <= 0) {
if (m_listEntity[iii]->getGroup() <= 0) {
continue;
}
// check if they are in the same group:
if (m_listElement[iii]->getGroup() == _sourceRequest->getGroup()) {
if (m_listEntity[iii]->getGroup() == _sourceRequest->getGroup()) {
continue;
}
// check distance ...
vec3 destPosition = m_listElement[iii]->getPosition();
vec3 destPosition = m_listEntity[iii]->getPosition();
float distance = (sourcePosition - destPosition).length();
//EGE_DEBUG("Distance : " << _distance << " >? " << distance << " id=" << iii);
if (_distance>distance) {
_distance = distance;
result = m_listElement[iii];
result = m_listEntity[iii];
}
}
return result;
}
void ege::Environement::getElementNearest(const vec3& _sourcePosition,
void ege::Environement::getEntityNearest(const vec3& _sourcePosition,
float _distanceMax,
std::vector<ege::Environement::ResultNearestElement>& _resultList) {
std::vector<ege::Environement::ResultNearestEntity>& _resultList) {
_resultList.clear();
ege::Environement::ResultNearestElement result;
ege::Environement::ResultNearestEntity result;
result.dist = 99999999999.0f;
result.element = nullptr;
for (size_t iii=0; iii<m_listElement.size() ; iii++) {
result.entity = nullptr;
for (size_t iii=0; iii<m_listEntity.size() ; iii++) {
// chack nullptr pointer
result.element = m_listElement[iii];
if (result.element == nullptr) {
result.entity = m_listEntity[iii];
if (result.entity == nullptr) {
continue;
}
// check distance ...
vec3 destPosition = result.element->getPosition();
vec3 destPosition = result.entity->getPosition();
if (_sourcePosition == destPosition) {
continue;
}
@ -173,30 +173,30 @@ void ege::Environement::getElementNearest(const vec3& _sourcePosition,
}
}
void ege::Environement::getElementNearestFixed(const vec3& _sourcePosition,
void ege::Environement::getEntityNearestFixed(const vec3& _sourcePosition,
float _distanceMax,
std::vector<ege::Environement::ResultNearestElement>& _resultList) {
std::vector<ege::Environement::ResultNearestEntity>& _resultList) {
_resultList.clear();
ege::Environement::ResultNearestElement result;
ege::Environement::ResultNearestEntity result;
result.dist = 99999999999.0f;
result.element = nullptr;
for (size_t iii=0; iii<m_listElement.size() ; iii++) {
result.entity = nullptr;
for (size_t iii=0; iii<m_listEntity.size() ; iii++) {
// chack nullptr pointer
result.element = m_listElement[iii];
if (result.element == nullptr) {
result.entity = m_listEntity[iii];
if (result.entity == nullptr) {
continue;
}
if (result.element->isFixed() == false) {
if (result.entity->isFixed() == false) {
continue;
}
// check distance ...
vec3 destPosition = result.element->getPositionTheoric();
vec3 destPosition = result.entity->getPositionTheoric();
result.dist = (_sourcePosition - destPosition).length();
//EGE_DEBUG("Distance : " << _distance << " >? " << distance << " id=" << iii);
if (_distanceMax <= result.dist) {
continue;
}
// try to add the element at the best positions:
// try to add the entity at the best positions:
size_t jjj;
for (jjj=0; jjj<_resultList.size(); jjj++) {
if (_resultList[jjj].dist>result.dist) {
@ -204,7 +204,7 @@ void ege::Environement::getElementNearestFixed(const vec3& _sourcePosition,
break;
}
}
// add element at the end :
// add entity at the end :
if (jjj >= _resultList.size()) {
_resultList.push_back(result);
}
@ -212,12 +212,12 @@ void ege::Environement::getElementNearestFixed(const vec3& _sourcePosition,
}
*/
static etk::Hash<ege::createElement_tf>& getHachTableCreating() {
static etk::Hash<ege::createElement_tf> s_table;
static etk::Hash<ege::createEntity_tf>& getHachTableCreating() {
static etk::Hash<ege::createEntity_tf> s_table;
return s_table;
}
void ege::Environement::addCreator(const std::string& _type, ege::createElement_tf _creator) {
void ege::Environement::addCreator(const std::string& _type, ege::createEntity_tf _creator) {
if (_creator == nullptr) {
EGE_ERROR("Try to add an empty CREATOR ...");
return;
@ -228,183 +228,183 @@ void ege::Environement::addCreator(const std::string& _type, ege::createElement_
}
ememory::SharedPtr<ege::Element> ege::Environement::createElement(const std::string& _type, const std::string& _description, bool _autoAddElement) {
ememory::SharedPtr<ege::Entity> ege::Environement::createEntity(const std::string& _type, const std::string& _description, bool _autoAddEntity) {
if (getHachTableCreating().exist(_type) == false) {
EGE_ERROR("Request creating of an type that is not known '" << _type << "'");
return nullptr;
}
ege::createElement_tf creatorPointer = getHachTableCreating()[_type];
ege::createEntity_tf creatorPointer = getHachTableCreating()[_type];
if (creatorPointer == nullptr) {
EGE_ERROR("nullptr pointer creator == > internal error... '" << _type << "'");
return nullptr;
}
ememory::SharedPtr<ege::Element> tmpElement = creatorPointer(ememory::dynamicPointerCast<ege::Environement>(sharedFromThis()));
if (tmpElement == nullptr) {
ememory::SharedPtr<ege::Entity> tmpEntity = creatorPointer(ememory::dynamicPointerCast<ege::Environement>(sharedFromThis()));
if (tmpEntity == nullptr) {
EGE_ERROR("allocation error '" << _type << "'");
return nullptr;
}
if (tmpElement->initString(_description) == false) {
if (tmpEntity->initString(_description) == false) {
EGE_ERROR("Init error ... '" << _type << "'");
return nullptr;
}
if (_autoAddElement == true) {
addElement(tmpElement);
if (_autoAddEntity == true) {
addEntity(tmpEntity);
}
return tmpElement;
return tmpEntity;
}
ememory::SharedPtr<ege::Element> ege::Environement::createElement(const std::string& _type, const ejson::Value& _value, bool _autoAddElement) {
ememory::SharedPtr<ege::Entity> ege::Environement::createEntity(const std::string& _type, const ejson::Value& _value, bool _autoAddEntity) {
if (getHachTableCreating().exist(_type) == false) {
EGE_ERROR("Request creating of an type that is not known '" << _type << "'");
return nullptr;
}
ege::createElement_tf creatorPointer = getHachTableCreating()[_type];
ege::createEntity_tf creatorPointer = getHachTableCreating()[_type];
if (creatorPointer == nullptr) {
EGE_ERROR("nullptr pointer creator == > internal error... '" << _type << "'");
return nullptr;
}
ememory::SharedPtr<ege::Element> tmpElement = creatorPointer(ememory::dynamicPointerCast<ege::Environement>(sharedFromThis()));
if (tmpElement == nullptr) {
ememory::SharedPtr<ege::Entity> tmpEntity = creatorPointer(ememory::dynamicPointerCast<ege::Environement>(sharedFromThis()));
if (tmpEntity == nullptr) {
EGE_ERROR("allocation error '" << _type << "'");
return nullptr;
}
if (tmpElement->initJSON(_value) == false) {
if (tmpEntity->initJSON(_value) == false) {
EGE_ERROR("Init error ... '" << _type << "'");
return nullptr;
}
if (_autoAddElement == true) {
addElement(tmpElement);
if (_autoAddEntity == true) {
addEntity(tmpEntity);
}
return tmpElement;
return tmpEntity;
}
ememory::SharedPtr<ege::Element> ege::Environement::createElement(const std::string& _type, const exml::Node& _node, bool _autoAddElement) {
ememory::SharedPtr<ege::Entity> ege::Environement::createEntity(const std::string& _type, const exml::Node& _node, bool _autoAddEntity) {
if (getHachTableCreating().exist(_type) == false) {
EGE_ERROR("Request creating of an type that is not known '" << _type << "'");
return nullptr;
}
ege::createElement_tf creatorPointer = getHachTableCreating()[_type];
ege::createEntity_tf creatorPointer = getHachTableCreating()[_type];
if (creatorPointer == nullptr) {
EGE_ERROR("nullptr pointer creator == > internal error... '" << _type << "'");
return nullptr;
}
ememory::SharedPtr<ege::Element> tmpElement = creatorPointer(ememory::dynamicPointerCast<ege::Environement>(sharedFromThis()));
if (tmpElement == nullptr) {
ememory::SharedPtr<ege::Entity> tmpEntity = creatorPointer(ememory::dynamicPointerCast<ege::Environement>(sharedFromThis()));
if (tmpEntity == nullptr) {
EGE_ERROR("allocation error '" << _type << "'");
return nullptr;
}
if (tmpElement->initXML(_node) == false) {
if (tmpEntity->initXML(_node) == false) {
EGE_ERROR("Init error ... '" << _type << "'");
return nullptr;
}
if (_autoAddElement == true) {
addElement(tmpElement);
if (_autoAddEntity == true) {
addEntity(tmpEntity);
}
return tmpElement;
return tmpEntity;
}
ememory::SharedPtr<ege::Element> ege::Environement::createElement(const std::string& _type, void* _data, bool _autoAddElement) {
ememory::SharedPtr<ege::Entity> ege::Environement::createEntity(const std::string& _type, void* _data, bool _autoAddEntity) {
if (getHachTableCreating().exist(_type) == false) {
EGE_ERROR("Request creating of an type that is not known '" << _type << "'");
return nullptr;
}
ege::createElement_tf creatorPointer = getHachTableCreating()[_type];
ege::createEntity_tf creatorPointer = getHachTableCreating()[_type];
if (creatorPointer == nullptr) {
EGE_ERROR("nullptr pointer creator == > internal error... '" << _type << "'");
return nullptr;
}
ememory::SharedPtr<ege::Element> tmpElement = creatorPointer(ememory::dynamicPointerCast<ege::Environement>(sharedFromThis()));
if (tmpElement == nullptr) {
ememory::SharedPtr<ege::Entity> tmpEntity = creatorPointer(ememory::dynamicPointerCast<ege::Environement>(sharedFromThis()));
if (tmpEntity == nullptr) {
EGE_ERROR("allocation error '" << _type << "'");
return nullptr;
}
if (tmpElement->initVoid(_data) == false) {
if (tmpEntity->initVoid(_data) == false) {
EGE_ERROR("Init error ... '" << _type << "'");
return nullptr;
}
if (_autoAddElement == true) {
addElement(tmpElement);
if (_autoAddEntity == true) {
addEntity(tmpEntity);
}
return tmpElement;
return tmpEntity;
}
ememory::SharedPtr<ege::Element> ege::Environement::createElement(const std::string& _type, bool _autoAddElement) {
ememory::SharedPtr<ege::Entity> ege::Environement::createEntity(const std::string& _type, bool _autoAddEntity) {
if (getHachTableCreating().exist(_type) == false) {
EGE_ERROR("Request creating of an type that is not known '" << _type << "'");
return nullptr;
}
ege::createElement_tf creatorPointer = getHachTableCreating()[_type];
ege::createEntity_tf creatorPointer = getHachTableCreating()[_type];
if (creatorPointer == nullptr) {
EGE_ERROR("nullptr pointer creator == > internal error... '" << _type << "'");
return nullptr;
}
ememory::SharedPtr<ege::Element> tmpElement = creatorPointer(ememory::dynamicPointerCast<ege::Environement>(sharedFromThis()));
if (tmpElement == nullptr) {
ememory::SharedPtr<ege::Entity> tmpEntity = creatorPointer(ememory::dynamicPointerCast<ege::Environement>(sharedFromThis()));
if (tmpEntity == nullptr) {
EGE_ERROR("allocation error '" << _type << "'");
return nullptr;
}
if (tmpElement->init() == false) {
if (tmpEntity->init() == false) {
EGE_ERROR("Init error ... '" << _type << "'");
return nullptr;
}
if (_autoAddElement == true) {
addElement(tmpElement);
if (_autoAddEntity == true) {
addEntity(tmpEntity);
}
return tmpElement;
return tmpEntity;
}
void ege::Environement::addElement(ememory::SharedPtr<ege::Element> _newElement) {
void ege::Environement::addEntity(ememory::SharedPtr<ege::Entity> _newEntity) {
// prevent memory allocation and un allocation ...
if (_newElement == nullptr) {
if (_newEntity == nullptr) {
return;
}
for (size_t iii=0; iii<m_listElement.size() ; iii++) {
if (m_listElement[iii] == nullptr) {
m_listElement[iii] = _newElement;
m_listElement[iii]->dynamicEnable();
for (size_t iii=0; iii<m_listEntity.size() ; iii++) {
if (m_listEntity[iii] == nullptr) {
m_listEntity[iii] = _newEntity;
m_listEntity[iii]->dynamicEnable();
return;
}
}
m_listElement.push_back(_newElement);
_newElement->dynamicEnable();
m_listEntity.push_back(_newEntity);
_newEntity->dynamicEnable();
}
void ege::Environement::rmElement(ememory::SharedPtr<ege::Element> _removeElement) {
if (_removeElement == nullptr) {
void ege::Environement::rmEntity(ememory::SharedPtr<ege::Entity> _removeEntity) {
if (_removeEntity == nullptr) {
return;
}
// inform the element that an element has been removed == > this permit to keep pointer on elements ...
for (size_t iii=0; iii<m_listElement.size() ; iii++) {
if (m_listElement[iii] != nullptr) {
m_listElement[iii]->elementIsRemoved(_removeElement);
// inform the entity that an entity has been removed == > this permit to keep pointer on entitys ...
for (size_t iii=0; iii<m_listEntity.size() ; iii++) {
if (m_listEntity[iii] != nullptr) {
m_listEntity[iii]->entityIsRemoved(_removeEntity);
}
}
// ream remove on the element :
for (size_t iii=0; iii<m_listElement.size() ; iii++) {
if (_removeElement == m_listElement[iii]) {
m_listElement[iii]->onDestroy();
m_listElement[iii]->dynamicDisable();
m_listElement[iii]->unInit();
m_listElement[iii].reset();
// ream remove on the entity :
for (size_t iii=0; iii<m_listEntity.size() ; iii++) {
if (_removeEntity == m_listEntity[iii]) {
m_listEntity[iii]->onDestroy();
m_listEntity[iii]->dynamicDisable();
m_listEntity[iii]->unInit();
m_listEntity[iii].reset();
}
}
}
void ege::Environement::generateInteraction(ege::ElementInteraction& _event) {
// inform the element that an element has been removed == > this permit to keep pointer on elements ...
for (size_t iii=0; iii<m_listElement.size() ; iii++) {
if (m_listElement[iii] == nullptr) {
void ege::Environement::generateInteraction(ege::EntityInteraction& _event) {
// inform the entity that an entity has been removed == > this permit to keep pointer on entitys ...
for (size_t iii=0; iii<m_listEntity.size() ; iii++) {
if (m_listEntity[iii] == nullptr) {
continue;
}
_event.applyEvent(*m_listElement[iii]);
_event.applyEvent(*m_listEntity[iii]);
/*
vec3 destPosition = m_listElement[iii]->getPosition();
vec3 destPosition = m_listEntity[iii]->getPosition();
float dist = (sourcePosition - destPosition).length;
if (dist == 0 || dist>decreasePower) {
continue;
}
float inpact = (decreasePower-dist)/decreasePower * power;
g_listElement[iii]->setFireOn(groupIdSource, type, -inpact, sourcePosition);
g_listEntity[iii]->setFireOn(groupIdSource, type, -inpact, sourcePosition);
*/
}
}
@ -418,7 +418,7 @@ ege::Environement::Environement() :
propertyRatio(this, "ratio",
1.0f,
"game speed ratio"),
m_listElement() {
m_listEntity() {
// nothing to do ...
propertyStatus.add(gameStart, "start", "Scene is started");
propertyStatus.add(gamePause, "pause", "Scene is paused");
@ -431,7 +431,7 @@ ege::Environement::Environement() :
}
void ege::Environement::clear() {
m_listElement.clear();
m_listEntity.clear();
}
@ -500,22 +500,22 @@ void ege::Environement::onCallbackPeriodicCall(const ewol::event::Time& _event)
// TODO : m_physicEngine.debugDrawWorld();
// TODO : EGE_INFO(" Update particule engine");
// TODO : m_particuleEngine.update(curentDelta);
// remove all element that requested it ...
// remove all entity that requested it ...
/**
{
int32_t numberEnnemyKilled=0;
int32_t victoryPoint=0;
auto it(m_listElement.begin());
while (it != m_listElement.end()) {
auto it(m_listEntity.begin());
while (it != m_listEntity.end()) {
if(*it != nullptr) {
if ((*it)->needToRemove() == true) {
if ((*it)->getGroup() > 1) {
numberEnnemyKilled++;
victoryPoint++;
}
EGE_INFO("[" << (*it)->getUID() << "] element Removing ... " << (*it)->getType());
rmElement((*it));
it = m_listElement.begin();
EGE_INFO("[" << (*it)->getUID() << "] entity Removing ... " << (*it)->getType());
rmEntity((*it));
it = m_listEntity.begin();
} else {
++it;
}

90
ege/Environement.hpp
View File

@ -7,7 +7,7 @@
namespace ege {
class Environement;
class ElementInteraction;
class EntityInteraction;
};
#include <ege/camera/Camera.hpp>
@ -26,9 +26,9 @@ namespace ege {
#include <ege/resource/Mesh.hpp>
namespace ege {
class Element;
class Entity;
class Environement;
typedef ememory::SharedPtr<ege::Element> (*createElement_tf)(const ememory::SharedPtr<ege::Environement>& _env);
typedef ememory::SharedPtr<ege::Entity> (*createEntity_tf)(const ememory::SharedPtr<ege::Environement>& _env);
enum gameStatus {
gameStart,
@ -36,7 +36,7 @@ namespace ege {
gameStop
};
class ElementInteraction {
class EntityInteraction {
protected:
int32_t m_type;
public:
@ -65,15 +65,15 @@ namespace ege {
return m_positionSource;
};
public:
ElementInteraction(int32_t _type, int32_t _groupSource, const vec3& _pos) :
EntityInteraction(int32_t _type, int32_t _groupSource, const vec3& _pos) :
m_type(_type),
m_groupSource(_groupSource),
m_positionSource(_pos)
{ };
public:
virtual void applyEvent(ege::Element& _element) { };
virtual void applyEvent(ege::Entity& _entity) { };
};
// TODO : An element must be created by a local factory...
// TODO : An entity must be created by a local factory...
class Environement : public ewol::Object {
public:
// Signals
@ -92,7 +92,7 @@ namespace ege {
void engineComponentAdd(const ememory::SharedPtr<ege::Component>& _ref);
private:
std::vector<ememory::SharedPtr<ege::Element>> m_listElement; //!< List of all element added in the Game
std::vector<ememory::SharedPtr<ege::Entity>> m_listEntity; //!< List of all entity added in the Game
protected:
Environement();
public:
@ -128,28 +128,28 @@ namespace ege {
*/
void clear();
/**
* @brief add a creator element system
* @param[in] _type Type of the element.
* @param[in] _creator Function pointer that reference the element creating.
* @brief add a creator entity system
* @param[in] _type Type of the entity.
* @param[in] _creator Function pointer that reference the entity creating.
*/
static void addCreator(const std::string& _type, ege::createElement_tf _creator);
static void addCreator(const std::string& _type, ege::createEntity_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 nullptr if an error occured OR the pointer on the element and it is already added on the system.
* @brief Create an entity on the curent scene.
* @param[in] _type Type of the entity that might be created.
* @param[in] _description String that describe the content of the entity properties.
* @param[in] _autoAddEntity this permit to add the entity if it is created == > no more action ...
* @return nullptr if an error occured OR the pointer on the entity and it is already added on the system.
* @note Pointer is return in case of setting properties on it...
*/
ememory::SharedPtr<ege::Element> createElement(const std::string& _type, const std::string& _description, bool _autoAddElement=true);
ememory::SharedPtr<ege::Element> createElement(const std::string& _type, const ejson::Value& _value, bool _autoAddElement=true);
ememory::SharedPtr<ege::Element> createElement(const std::string& _type, const exml::Node& _node, bool _autoAddElement=true);
ememory::SharedPtr<ege::Element> createElement(const std::string& _type, void* _data, bool _autoAddElement=true);
ememory::SharedPtr<ege::Element> createElement(const std::string& _type, bool _autoAddElement=true);
ememory::SharedPtr<ege::Entity> createEntity(const std::string& _type, const std::string& _description, bool _autoAddEntity=true);
ememory::SharedPtr<ege::Entity> createEntity(const std::string& _type, const ejson::Value& _value, bool _autoAddEntity=true);
ememory::SharedPtr<ege::Entity> createEntity(const std::string& _type, const exml::Node& _node, bool _autoAddEntity=true);
ememory::SharedPtr<ege::Entity> createEntity(const std::string& _type, void* _data, bool _autoAddEntity=true);
ememory::SharedPtr<ege::Entity> createEntity(const std::string& _type, bool _autoAddEntity=true);
public:
class ResultNearestElement {
class ResultNearestEntity {
public:
ememory::SharedPtr<ege::Element> element;
ememory::SharedPtr<ege::Entity> entity;
float dist;
};
#if 0
@ -169,43 +169,43 @@ namespace ege {
};
#endif
/**
* @breif get a reference on the curent list of element games
* @return all element list
* @breif get a reference on the curent list of entity games
* @return all entity list
*/
std::vector<ememory::SharedPtr<ege::Element>>& getElement() {
return m_listElement;
std::vector<ememory::SharedPtr<ege::Entity>>& getEntity() {
return m_listEntity;
};
/**
* @brief get the nearest Element
* @param[in] _sourceRequest Pointer on the element that request this.
* @param[in] _distance Maximum distance search == > return the element distance
* @return Pointer on the neares element OR nullptr
* @brief get the nearest Entity
* @param[in] _sourceRequest Pointer on the entity that request this.
* @param[in] _distance Maximum distance search == > return the entity distance
* @return Pointer on the neares entity OR nullptr
*/
/*
ememory::SharedPtr<ege::Element> getElementNearest(ememory::SharedPtr<ege::Element> _sourceRequest, float& _distance);
ememory::SharedPtr<ege::Entity> getEntityNearest(ememory::SharedPtr<ege::Entity> _sourceRequest, float& _distance);
void getElementNearest(const vec3& _sourcePosition,
void getEntityNearest(const vec3& _sourcePosition,
float _distanceMax,
std::vector<ege::Environement::ResultNearestElement>& _resultList);
void getElementNearestFixed(const vec3& _sourcePosition,
std::vector<ege::Environement::ResultNearestEntity>& _resultList);
void getEntityNearestFixed(const vec3& _sourcePosition,
float _distanceMax,
std::vector<ege::Environement::ResultNearestElement>& _resultList);
std::vector<ege::Environement::ResultNearestEntity>& _resultList);
*/
/**
* @brief add an element on the list availlable.
* @param[in] _newElement Element to add.
* @brief add an entity on the list availlable.
* @param[in] _newEntity Entity to add.
*/
void addElement(ememory::SharedPtr<ege::Element> _newElement);
void addEntity(ememory::SharedPtr<ege::Entity> _newEntity);
/**
* @brief remove an element on the list availlable.
* @param[in] _removeElement Element to remove.
* @brief remove an entity on the list availlable.
* @param[in] _removeEntity Entity to remove.
*/
void rmElement(ememory::SharedPtr<ege::Element> _removeElement);
void rmEntity(ememory::SharedPtr<ege::Entity> _removeEntity);
/**
* @brief generate an event on all the sub element of the game == > usefull for explosion, or lazer fire ...
* @brief generate an event on all the sub entity of the game == > usefull for explosion, or lazer fire ...
* @param[in] _event event that might be apply ...
*/
void generateInteraction(ege::ElementInteraction& _event);
void generateInteraction(ege::EntityInteraction& _event);
protected:
int64_t m_gameTime; //!< time of the game running
public:

14
ege/Ray.cpp
View File

@ -6,7 +6,7 @@
#include <etk/types.hpp>
#include <ege/Ray.hpp>
#include <ege/debug.hpp>
#include <ege/elements/Element.hpp>
#include <ege/Entity.hpp>
#include <etk/math/Vector3D.hpp>
@ -57,7 +57,7 @@ std::pair<vec3,vec3> ege::Ray::testRay(ege::physics::Engine& _engine) {
}
std::pair<ememory::SharedPtr<ege::Element>, std::pair<vec3,vec3>> ege::Ray::testRayObject(ege::physics::Engine& _engine) {
std::pair<ememory::SharedPtr<ege::Entity>, std::pair<vec3,vec3>> ege::Ray::testRayObject(ege::physics::Engine& _engine) {
vec3 start = m_origin;
vec3 stop = m_origin+m_direction*1000.0f;
// Start and End are vectors
@ -69,17 +69,17 @@ std::pair<ememory::SharedPtr<ege::Element>, std::pair<vec3,vec3>> ege::Ray::test
if(rayCallback.hasHit()) {
vec3 end = rayCallback.m_hitPointWorld;
vec3 normal = rayCallback.m_hitNormalWorld;
ege::Element* elem = static_cast<ege::Element*>(rayCallback.m_collisionObject->getUserPointer());
ege::Entity* elem = static_cast<ege::Entity*>(rayCallback.m_collisionObject->getUserPointer());
if (elem != nullptr) {
EGE_VERBOSE(" hit at point=" << end << " normal=" << normal);
return std::pair<ememory::SharedPtr<ege::Element>, std::pair<vec3,vec3>>(elem->sharedFromThis(), std::pair<vec3,vec3>(end,normal));
return std::pair<ememory::SharedPtr<ege::Entity>, std::pair<vec3,vec3>>(elem->sharedFromThis(), std::pair<vec3,vec3>(end,normal));
}
EGE_VERBOSE(" Can not get the element pointer");
return std::pair<ememory::SharedPtr<ege::Element>, std::pair<vec3,vec3>>(nullptr, std::pair<vec3,vec3>(end,normal));
EGE_VERBOSE(" Can not get the entity pointer");
return std::pair<ememory::SharedPtr<ege::Entity>, std::pair<vec3,vec3>>(nullptr, std::pair<vec3,vec3>(end,normal));
}
*/
EGE_VERBOSE(" No Hit");
return std::pair<ememory::SharedPtr<ege::Element>, std::pair<vec3,vec3>>(nullptr, std::pair<vec3,vec3>(vec3(0,0,0),vec3(0,0,0)));
return std::pair<ememory::SharedPtr<ege::Entity>, std::pair<vec3,vec3>>(nullptr, std::pair<vec3,vec3>(vec3(0,0,0),vec3(0,0,0)));
}
vec3 ege::Ray::testRayZeroPlane() {

4
ege/Ray.hpp
View File

@ -8,7 +8,7 @@
#include <etk/math/Vector3D.hpp>
namespace ege {
class Ray;
class Element;
class Entity;
};
#include <ege/physics/Engine.hpp>
#include <ememory/memory.hpp>
@ -65,7 +65,7 @@ namespace ege {
void set(const vec3& _origin, const vec3& _direction);
public:
std::pair<vec3,vec3> testRay(ege::physics::Engine& _engine);
std::pair<ememory::SharedPtr<ege::Element>, std::pair<vec3,vec3>> testRayObject(ege::physics::Engine& _engine);
std::pair<ememory::SharedPtr<ege::Entity>, std::pair<vec3,vec3>> testRayObject(ege::physics::Engine& _engine);
vec3 testRayZeroPlane();
};
std::ostream& operator <<(std::ostream& _os, const ege::Ray& _obj);

68
ege/physics/Component.cpp
View File

@ -6,13 +6,13 @@
#include <ege/physics/Component.hpp>
#include <ege/physics/Engine.hpp>
#include <ege/Environement.hpp>
#include <ege/physicsShape/PhysicsShape.hpp>
#include <ege/physicsShape/PhysicsBox.hpp>
#include <ege/physicsShape/PhysicsCapsule.hpp>
#include <ege/physicsShape/PhysicsCone.hpp>
#include <ege/physicsShape/PhysicsConvexHull.hpp>
#include <ege/physicsShape/PhysicsCylinder.hpp>
#include <ege/physicsShape/PhysicsSphere.hpp>
#include <ege/physics/shape/Shape.hpp>
#include <ege/physics/shape/Box.hpp>
#include <ege/physics/shape/Capsule.hpp>
#include <ege/physics/shape/Cone.hpp>
#include <ege/physics/shape/ConvexHull.hpp>
#include <ege/physics/shape/Cylinder.hpp>
#include <ege/physics/shape/Sphere.hpp>
const std::string& ege::physics::Component::getType() const {
static std::string tmp("physics");
@ -80,9 +80,9 @@ void ege::physics::Component::generate() {
continue;
}
switch (it->getType()) {
case ege::PhysicsShape::box : {
case ege::physics::Shape::type::box : {
EGE_DEBUG(" Box");
const ege::PhysicsBox* tmpElement = it->toBox();
const ege::physics::shape::Box* tmpElement = it->toBox();
if (tmpElement == nullptr) {
EGE_ERROR(" Box ==> can not cast in BOX");
continue;
@ -106,9 +106,9 @@ void ege::physics::Component::generate() {
m_listProxyShape.push_back(proxyShape);
break;
}
case ege::PhysicsShape::cylinder : {
case ege::physics::Shape::type::cylinder : {
EGE_DEBUG(" Cylinder");
const ege::PhysicsCylinder* tmpElement = it->toCylinder();
const ege::physics::shape::Cylinder* tmpElement = it->toCylinder();
if (tmpElement == nullptr) {
EGE_ERROR(" Cylinder ==> can not cast in Cylinder");
continue;
@ -127,9 +127,9 @@ void ege::physics::Component::generate() {
m_listProxyShape.push_back(proxyShape);
break;
}
case ege::PhysicsShape::capsule : {
case ege::physics::Shape::type::capsule : {
EGE_DEBUG(" Capsule");
const ege::PhysicsCapsule* tmpElement = it->toCapsule();
const ege::physics::shape::Capsule* tmpElement = it->toCapsule();
if (tmpElement == nullptr) {
EGE_ERROR(" Capsule ==> can not cast in Capsule");
continue;
@ -148,9 +148,9 @@ void ege::physics::Component::generate() {
*/
break;
}
case ege::PhysicsShape::cone : {
case ege::physics::Shape::type::cone : {
EGE_DEBUG(" Cone");
const ege::PhysicsCone* tmpElement = it->toCone();
const ege::physics::shape::Cone* tmpElement = it->toCone();
if (tmpElement == nullptr) {
EGE_ERROR(" Cone ==> can not cast in Cone");
continue;
@ -169,9 +169,9 @@ void ege::physics::Component::generate() {
*/
break;
}
case ege::PhysicsShape::sphere : {
case ege::physics::Shape::type::sphere : {
EGE_DEBUG(" Sphere");
const ege::PhysicsSphere* tmpElement = it->toSphere();
const ege::physics::shape::Sphere* tmpElement = it->toSphere();
if (tmpElement == nullptr) {
EGE_ERROR(" Sphere ==> can not cast in Sphere");
continue;
@ -202,9 +202,9 @@ void ege::physics::Component::generate() {
*/
break;
}
case ege::PhysicsShape::convexHull : {
case ege::physics::Shape::type::convexHull : {
EGE_DEBUG(" convexHull");
const ege::PhysicsConvexHull* tmpElement = it->toConvexHull();
const ege::physics::shape::ConvexHull* tmpElement = it->toConvexHull();
if (tmpElement == nullptr) {
EGE_ERROR(" convexHull ==> can not cast in convexHull");
continue;
@ -311,15 +311,15 @@ void ege::physics::Component::setAngularVelocity(const vec3& _angularVelocity) {
m_rigidBody->setAngularVelocity(value);
}
const std::vector<ememory::SharedPtr<ege::PhysicsShape>>& ege::physics::Component::getShape() const {
const std::vector<ememory::SharedPtr<ege::physics::Shape>>& ege::physics::Component::getShape() const {
return m_shape;
}
void ege::physics::Component::setShape(const std::vector<ememory::SharedPtr<ege::PhysicsShape>>& _prop) {
void ege::physics::Component::setShape(const std::vector<ememory::SharedPtr<ege::physics::Shape>>& _prop) {
m_shape = _prop;
}
void ege::physics::Component::addShape(const ememory::SharedPtr<ege::PhysicsShape>& _shape) {
void ege::physics::Component::addShape(const ememory::SharedPtr<ege::physics::Shape>& _shape) {
m_shape.push_back(_shape);
}
@ -337,9 +337,9 @@ void ege::physics::Component::drawShape(ememory::SharedPtr<ewol::resource::Color
continue;
}
switch (it->getType()) {
case ege::PhysicsShape::box: {
case ege::physics::Shape::type::box: {
EGE_DEBUG(" Box");
const ege::PhysicsBox* tmpElement = it->toBox();
const ege::physics::shape::Box* tmpElement = it->toBox();
if (tmpElement == nullptr) {
EGE_ERROR(" Box ==> can not cast in BOX");
continue;
@ -352,9 +352,9 @@ void ege::physics::Component::drawShape(ememory::SharedPtr<ewol::resource::Color
_draw->drawSquare(tmpElement->getSize(), transformationMatrixLocal, tmpColor);
break;
}
case ege::PhysicsShape::cylinder : {
case ege::physics::Shape::type::cylinder : {
EGE_DEBUG(" Cylinder");
const ege::PhysicsCylinder* tmpElement = it->toCylinder();
const ege::physics::shape::Cylinder* tmpElement = it->toCylinder();
if (tmpElement == nullptr) {
EGE_ERROR(" Cylinder ==> can not cast in Cylinder");
continue;
@ -367,9 +367,9 @@ void ege::physics::Component::drawShape(ememory::SharedPtr<ewol::resource::Color
//_draw->drawSphere(radius, 10, 10, _transformationMatrix, tmpColor);
break;
}
case ege::PhysicsShape::capsule : {
case ege::physics::Shape::type::capsule : {
EGE_DEBUG(" Capsule");
const ege::PhysicsCapsule* tmpElement = it->toCapsule();
const ege::physics::shape::Capsule* tmpElement = it->toCapsule();
if (tmpElement == nullptr) {
EGE_ERROR(" Capsule ==> can not cast in Capsule");
continue;
@ -388,9 +388,9 @@ void ege::physics::Component::drawShape(ememory::SharedPtr<ewol::resource::Color
*/
break;
}
case ege::PhysicsShape::cone : {
case ege::physics::Shape::type::cone : {
EGE_DEBUG(" Cone");
const ege::PhysicsCone* tmpElement = it->toCone();
const ege::physics::shape::Cone* tmpElement = it->toCone();
if (tmpElement == nullptr) {
EGE_ERROR(" Cone ==> can not cast in Cone");
continue;
@ -409,9 +409,9 @@ void ege::physics::Component::drawShape(ememory::SharedPtr<ewol::resource::Color
*/
break;
}
case ege::PhysicsShape::sphere : {
case ege::physics::Shape::type::sphere : {
EGE_DEBUG(" Sphere");
const ege::PhysicsSphere* tmpElement = it->toSphere();
const ege::physics::shape::Sphere* tmpElement = it->toSphere();
if (tmpElement == nullptr) {
EGE_ERROR(" Sphere ==> can not cast in Sphere");
continue;
@ -424,9 +424,9 @@ void ege::physics::Component::drawShape(ememory::SharedPtr<ewol::resource::Color
_draw->drawSphere(tmpElement->getRadius(), 10, 10, transformationMatrixLocal, tmpColor);
break;
}
case ege::PhysicsShape::convexHull : {
case ege::physics::Shape::type::convexHull : {
EGE_DEBUG(" convexHull");
const ege::PhysicsConvexHull* tmpElement = it->toConvexHull();
const ege::physics::shape::ConvexHull* tmpElement = it->toConvexHull();
if (tmpElement == nullptr) {
EGE_ERROR(" convexHull ==> can not cast in convexHull");
continue;

8
ege/physics/Component.hpp
View File

@ -79,11 +79,11 @@ namespace ege {
*/
void setAngularVelocity(const vec3& _angularVelocity);
protected:
std::vector<ememory::SharedPtr<ege::PhysicsShape>> m_shape; //!< collision shape module ... (independent of bullet lib)
std::vector<ememory::SharedPtr<ege::physics::Shape>> m_shape; //!< collision shape module ... (independent of bullet lib)
public:
const std::vector<ememory::SharedPtr<ege::PhysicsShape>>& getShape() const;
void setShape(const std::vector<ememory::SharedPtr<ege::PhysicsShape>>& _prop);
void addShape(const ememory::SharedPtr<ege::PhysicsShape>& _shape);
const std::vector<ememory::SharedPtr<ege::physics::Shape>>& getShape() const;
void setShape(const std::vector<ememory::SharedPtr<ege::physics::Shape>>& _prop);
void addShape(const ememory::SharedPtr<ege::physics::Shape>& _shape);
void generate();
void drawShape(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera);
private:

10
ege/physics/Engine.cpp
View File

@ -4,7 +4,7 @@
* @license MPL v2.0 (see license file)
*/
#include <ege/elements/Element.hpp>
#include <ege/Entity.hpp>
#include <ege/physics/Engine.hpp>
#include <ege/debug.hpp>
@ -48,8 +48,8 @@ extern ContactProcessedCallback gContactProcessedCallback;
// TODO : remove double collision call ...
static bool handleContactsProcess(btManifoldPoint& _point, btCollisionObject* _body0, btCollisionObject* _body1) {
ege::ElementPhysic* elem0 = static_cast<ege::ElementPhysic*>(_body0->getUserPointer());
ege::ElementPhysic* elem1 = static_cast<ege::ElementPhysic*>(_body1->getUserPointer());
ege::Entityhysic* elem0 = static_cast<ege::EntityPhysic*>(_body0->getUserPointer());
ege::EntityPhysic* elem1 = static_cast<ege::EntityPhysic*>(_body1->getUserPointer());
if ( elem0 == nullptr
|| elem1 == nullptr) {
EGE_WARNING("callback of collision error");
@ -151,8 +151,8 @@ std::vector<ege::physics::Engine::collisionPoints> ege::physics::Engine::getList
|| obB == nullptr) {
continue;
}
ege::ElementPhysic* elem0 = static_cast<ege::ElementPhysic*>(obA->getUserPointer());
ege::ElementPhysic* elem1 = static_cast<ege::ElementPhysic*>(obB->getUserPointer());
ege::EntityPhysic* elem0 = static_cast<ege::EntityPhysic*>(obA->getUserPointer());
ege::EntityPhysic* elem1 = static_cast<ege::EntityPhysic*>(obB->getUserPointer());
if ( elem0 == nullptr
|| elem1 == nullptr) {
continue;

6
ege/physicsShape/PhysicsBox.cpp → ege/physics/shape/Box.cpp
View File

@ -5,11 +5,11 @@
*/
#include <ege/debug.hpp>
#include <etk/math/Vector3D.hpp>
#include <ege/physicsShape/PhysicsBox.hpp>
#include <ege/physics/shape/Box.hpp>
bool ege::PhysicsBox::parse(const char* _line) {
if (ege::PhysicsShape::parse(_line) == true) {
bool ege::physics::shape::Box::parse(const char* _line) {
if (ege::physics::Shape::parse(_line) == true) {
return true;
}
if(strncmp(_line, "half-extents:", 13) == 0) {

46
ege/physics/shape/Box.hpp Normal file
View File

@ -0,0 +1,46 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <ege/physics/shape/Shape.hpp>
namespace ege {
namespace physics {
namespace shape {
class Box : public ege::physics::Shape {
public:
Box() {};
virtual ~Box() {};
public:
virtual bool parse(const char* _line);
virtual void display() {};
public:
virtual enum ege::physics::Shape::type getType() const {
return ege::physics::Shape::type::box;
};
private:
vec3 m_size; // Box size property in X, Y and Z
public:
const vec3& getSize() const {
return m_size;
};
void setSize(const vec3& _size) {
m_size = _size;
}
public:
virtual const ege::physics::shape::Box* toBox() const {
return this;
};
virtual ege::physics::shape::Box* toBox() {
return this;
};
};
}
}
}

6
ege/physicsShape/PhysicsCapsule.cpp → ege/physics/shape/Capsule.cpp
View File

@ -4,12 +4,12 @@
* @license MPL v2.0 (see license file)
*/
#include <ege/debug.hpp>
#include <ege/physicsShape/PhysicsCapsule.hpp>
#include <ege/physics/shape/Capsule.hpp>
bool ege::PhysicsCapsule::parse(const char* _line) {
if (ege::PhysicsShape::parse(_line) == true) {
bool ege::physics::shape::Capsule::parse(const char* _line) {
if (ege::physics::Shape::parse(_line) == true) {
return true;
}
if(strncmp(_line, "radius:", 7) == 0) {

50
ege/physics/shape/Capsule.hpp Normal file
View File

@ -0,0 +1,50 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <ege/physics/shape/Shape.hpp>
namespace ege {
namespace physics {
namespace shape {
class Capsule : public ege::physics::Shape {
public:
Capsule() {};
virtual ~Capsule() {};
public:
virtual bool parse(const char* _line);
virtual void display() {};
public:
virtual enum ege::physics::Shape::type getType() const {
return ege::physics::Shape::type::capsule;
};
private:
float m_radius;
public:
float getRadius() const {
return m_radius;
};
private:
float m_height;
public:
float getHeight() const {
return m_height;
};
public:
virtual const ege::physics::shape::Capsule* toCapsule() const {
return this;
};
virtual ege::physics::shape::Capsule* toCapsule() {
return this;
};
};
}
}
}

6
ege/physicsShape/PhysicsCone.cpp → ege/physics/shape/Cone.cpp
View File

@ -4,12 +4,12 @@
* @license MPL v2.0 (see license file)
*/
#include <ege/debug.hpp>
#include <ege/physicsShape/PhysicsCone.hpp>
#include <ege/physics/shape/Cone.hpp>
bool ege::PhysicsCone::parse(const char* _line) {
if (ege::PhysicsShape::parse(_line) == true) {
bool ege::physics::shape::Cone::parse(const char* _line) {
if (ege::physics::Shape::parse(_line) == true) {
return true;
}
if(strncmp(_line, "radius:", 7) == 0) {

48
ege/physics/shape/Cone.hpp Normal file
View File

@ -0,0 +1,48 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <ege/physics/shape/Shape.hpp>
namespace ege {
namespace physics {
namespace shape {
class Cone : public ege::physics::Shape {
public:
Cone() {};
virtual ~Cone() {};
public:
virtual bool parse(const char* _line);
virtual void display() {};
public:
virtual enum ege::physics::Shape::type getType() const {
return ege::physics::Shape::type::cone;
};
private:
float m_radius;
public:
float getRadius() const {
return m_radius;
};
private:
float m_height;
public:
float getHeight() const {
return m_height;
};
public:
virtual const ege::physics::shape::Cone* toCone() const {
return this;
};
virtual ege::physics::shape::Cone* toCone() {
return this;
};
};
}
}
}

6
ege/physicsShape/PhysicsConvexHull.cpp → ege/physics/shape/ConvexHull.cpp
View File

@ -4,12 +4,12 @@
* @license MPL v2.0 (see license file)
*/
#include <ege/debug.hpp>
#include <ege/physicsShape/PhysicsConvexHull.hpp>
#include <ege/physics/shape/ConvexHull.hpp>
bool ege::PhysicsConvexHull::parse(const char* _line) {
if (ege::PhysicsShape::parse(_line) == true) {
bool ege::physics::shape::ConvexHull::parse(const char* _line) {
if (ege::physics::Shape::parse(_line) == true) {
return true;
}
if(strncmp(_line, "points:", 6) == 0) {

48
ege/physics/shape/ConvexHull.hpp Normal file
View File

@ -0,0 +1,48 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <ege/physics/shape/Shape.hpp>
namespace ege {
namespace physics {
namespace shape {
class ConvexHull : public ege::physics::Shape {
public:
ConvexHull() {};
virtual ~ConvexHull() {};
public:
virtual bool parse(const char* _line);
virtual void display() {};
public:
virtual enum ege::physics::Shape::type getType() const {
return ege::physics::Shape::type::convexHull;
};
private:
vec3 m_scale;
public:
vec3 getScale() const {
return m_scale;
};
private:
std::vector<vec3> m_points;
public:
const std::vector<vec3>& getPointList() const {
return m_points;
};
public:
virtual const ege::physics::shape::ConvexHull* toConvexHull() const {
return this;
};
virtual ege::physics::shape::ConvexHull* toConvexHull() {
return this;
};
};
}
}
}

6
ege/physicsShape/PhysicsCylinder.cpp → ege/physics/shape/Cylinder.cpp
View File

@ -4,11 +4,11 @@
* @license MPL v2.0 (see license file)
*/
#include <ege/debug.hpp>
#include <ege/physicsShape/PhysicsCylinder.hpp>
#include <ege/physics/shape/Cylinder.hpp>
bool ege::PhysicsCylinder::parse(const char* _line) {
if (ege::PhysicsShape::parse(_line) == true) {
bool ege::physics::shape::Cylinder::parse(const char* _line) {
if (ege::physics::Shape::parse(_line) == true) {
return true;
}
if(strncmp(_line, "half-extents:", 13) == 0) {

44
ege/physics/shape/Cylinder.hpp Normal file
View File

@ -0,0 +1,44 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <ege/physics/shape/Shape.hpp>
namespace ege {
namespace physics {
namespace shape {
class Cylinder : public ege::physics::Shape {
public:
Cylinder() {};
virtual ~Cylinder() {};
public:
virtual bool parse(const char* _line);
virtual void display() {};
public:
virtual enum ege::physics::Shape::type getType() const {
return ege::physics::Shape::type::cylinder;
};
private:
vec3 m_size;
public:
vec3 getSize() const {
return m_size;
};
public:
virtual const ege::physics::shape::Cylinder* toCylinder() const {
return this;
};
virtual ege::physics::shape::Cylinder* toCylinder() {
return this;
};
};
}
}
}

32
ege/physicsShape/PhysicsShape.cpp → ege/physics/shape/Shape.cpp
View File

@ -4,30 +4,30 @@
* @license MPL v2.0 (see license file)
*/
#include <ege/debug.hpp>
#include <ege/physicsShape/PhysicsShape.hpp>
#include <ege/physicsShape/PhysicsBox.hpp>
#include <ege/physicsShape/PhysicsCapsule.hpp>
#include <ege/physicsShape/PhysicsCone.hpp>
#include <ege/physicsShape/PhysicsConvexHull.hpp>
#include <ege/physicsShape/PhysicsCylinder.hpp>
#include <ege/physicsShape/PhysicsSphere.hpp>
#include <ege/physics/shape/Shape.hpp>
#include <ege/physics/shape/Box.hpp>
#include <ege/physics/shape/Capsule.hpp>
#include <ege/physics/shape/Cone.hpp>
#include <ege/physics/shape/ConvexHull.hpp>
#include <ege/physics/shape/Cylinder.hpp>
#include <ege/physics/shape/Sphere.hpp>
ememory::SharedPtr<ege::PhysicsShape> ege::PhysicsShape::create(const std::string& _name) {
ememory::SharedPtr<ege::PhysicsShape> tmpp = nullptr;
ememory::SharedPtr<ege::physics::Shape> ege::physics::Shape::create(const std::string& _name) {
ememory::SharedPtr<ege::physics::Shape> tmpp = nullptr;
std::string name = etk::tolower(_name);
if (name == "box") {
tmpp = ememory::makeShared<ege::PhysicsBox>();
tmpp = ememory::makeShared<ege::physics::shape::Box>();
} else if (name == "sphere") {
tmpp = ememory::makeShared<ege::PhysicsSphere>();
tmpp = ememory::makeShared<ege::physics::shape::Sphere>();
} else if (name == "cone") {
tmpp = ememory::makeShared<ege::PhysicsCone>();
tmpp = ememory::makeShared<ege::physics::shape::Cone>();
} else if (name == "cylinder") {
tmpp = ememory::makeShared<ege::PhysicsCylinder>();
tmpp = ememory::makeShared<ege::physics::shape::Cylinder>();
} else if (name == "capsule") {
tmpp = ememory::makeShared<ege::PhysicsCapsule>();
tmpp = ememory::makeShared<ege::physics::shape::Capsule>();
} else if (name == "convexhull") {
tmpp = ememory::makeShared<ege::PhysicsConvexHull>();
tmpp = ememory::makeShared<ege::physics::shape::ConvexHull>();
} else {
EGE_ERROR("Create an unknow element : '" << _name << "' availlable : [BOX,SPHERE,CONE,CYLINDER,CAPSULE,CONVEXHULL]");
return nullptr;
@ -39,7 +39,7 @@ ememory::SharedPtr<ege::PhysicsShape> ege::PhysicsShape::create(const std::strin
}
bool ege::PhysicsShape::parse(const char* _line) {
bool ege::physics::Shape::parse(const char* _line) {
if(strncmp(_line, "origin:", 7) == 0) {
sscanf(&_line[7], "%f %f %f", &m_origin.m_floats[0], &m_origin.m_floats[1], &m_origin.m_floats[2] );
EGE_VERBOSE(" Origin=" << m_origin);

145
ege/physics/shape/Shape.hpp Normal file
View File

@ -0,0 +1,145 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <etk/math/Vector4D.hpp>
#include <etk/math/Vector3D.hpp>
#include <etk/math/Quaternion.hpp>
#include <ememory/memory.hpp>
namespace ege {
namespace physics {
namespace shape {
class Box;
class Cylinder;
class Capsule;
class Cone;
class ConvexHull;
class Sphere;
}
class Shape {
public:
static ememory::SharedPtr<ege::physics::Shape> create(const std::string& _name);
public:
enum class type {
unknow,
box,
capsule,
cone,
convexHull,
cylinder,
sphere
};
public:
Shape() :
m_quaternion(1,0,0,0),
m_origin(0,0,0),
m_mass(1) { // by default set mass at 1g
}
virtual ~Shape() = default;
public:
virtual enum ege::physics::Shape::type getType() const {
return ege::physics::Shape::type::unknow;
}
public:
virtual bool parse(const char* _line);
virtual void display() {
}
private:
vec4 m_quaternion;
public:
const vec4& getQuaternion() const {
return m_quaternion;
}
etk::Quaternion getOrientation() const {
return etk::Quaternion(m_quaternion.x(), m_quaternion.y(), m_quaternion.z(), m_quaternion.w());
}
private:
vec3 m_origin;
public:
const vec3& getOrigin() const {
return m_origin;
};
private:
float m_mass; //!< element mass in "g" then 1000 for 1kg
public:
float getMass() const {
return m_mass;
}
void setMass(float _mass) {
m_mass = _mass;
}
public:
bool isBox() {
return getType() == ege::physics::Shape::type::box;
};
bool isCylinder() {
return getType() == ege::physics::Shape::type::cylinder;
};
bool isCapsule() {
return getType() == ege::physics::Shape::type::capsule;
};
bool isCone() {
return getType() == ege::physics::Shape::type::cone;
};
bool isConvexHull() {
return getType() == ege::physics::Shape::type::convexHull;
};
bool isSphere() {
return getType() == ege::physics::Shape::type::sphere;
};
virtual const ege::physics::shape::Box* toBox() const {
return nullptr;
};
virtual ege::physics::shape::Box* toBox() {
return nullptr;
};
virtual const ege::physics::shape::Cylinder* toCylinder() const {
return nullptr;
};
virtual ege::physics::shape::Cylinder* toCylinder() {
return nullptr;
};
virtual const ege::physics::shape::Capsule* toCapsule() const {
return nullptr;
};
virtual ege::physics::shape::Capsule* toCapsule() {
return nullptr;
};
virtual const ege::physics::shape::Cone* toCone() const {
return nullptr;
};
virtual ege::physics::shape::Cone* toCone() {
return nullptr;
};
virtual const ege::physics::shape::ConvexHull* toConvexHull() const {
return nullptr;
};
virtual ege::physics::shape::ConvexHull* toConvexHull() {
return nullptr;
};
virtual const ege::physics::shape::Sphere* toSphere() const {
return nullptr;
};
virtual ege::physics::shape::Sphere* toSphere() {
return nullptr;
};
};
}
}

6
ege/physicsShape/PhysicsSphere.cpp → ege/physics/shape/Sphere.cpp
View File

@ -4,12 +4,12 @@
* @license MPL v2.0 (see license file)
*/
#include <ege/debug.hpp>
#include <ege/physicsShape/PhysicsSphere.hpp>
#include <ege/physics/shape/Sphere.hpp>
bool ege::PhysicsSphere::parse(const char* _line) {
if (ege::PhysicsShape::parse(_line) == true) {
bool ege::physics::shape::Sphere::parse(const char* _line) {
if (ege::physics::Shape::parse(_line) == true) {
return true;
}
if(strncmp(_line, "radius:", 7) == 0) {

47
ege/physics/shape/Sphere.hpp Normal file
View File

@ -0,0 +1,47 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <ege/physics/shape/Shape.hpp>
namespace ege {
namespace physics {
namespace shape {
class Sphere : public ege::physics::Shape {
public:
Sphere() {};
virtual ~Sphere() {};
public:
virtual bool parse(const char* _line);
virtual void display() {};
public:
virtual enum ege::physics::Shape::type getType() const {
return ege::physics::Shape::type::sphere;
};
private:
float m_radius; // props["radius"] = obj.scale.x
public:
float getRadius() const {
return m_radius;
};
void setRadius(float _radius) {
m_radius = _radius;
};
private:
virtual const ege::physics::shape::Sphere* toSphere() const {
return this;
};
virtual ege::physics::shape::Sphere* toSphere() {
return this;
};
};
}
}
}

42
ege/physicsShape/PhysicsBox.hpp
View File

@ -1,42 +0,0 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <ege/physicsShape/PhysicsShape.hpp>
namespace ege {
class PhysicsBox : public ege::PhysicsShape {
public:
PhysicsBox() {};
virtual ~PhysicsBox() {};
public:
virtual bool parse(const char* _line);
virtual void display() {};
public:
virtual enum ege::PhysicsShape::type getType() const {
return ege::PhysicsShape::box;
};
private:
vec3 m_size; // Box size property in X, Y and Z
public:
const vec3& getSize() const {
return m_size;
};
void setSize(const vec3& _size) {
m_size = _size;
}
public:
virtual const ege::PhysicsBox* toBox() const {
return this;
};
virtual ege::PhysicsBox* toBox() {
return this;
};
};
}

46
ege/physicsShape/PhysicsCapsule.hpp
View File

@ -1,46 +0,0 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <ege/physicsShape/PhysicsShape.hpp>
namespace ege {
class PhysicsCapsule : public ege::PhysicsShape {
public:
PhysicsCapsule() {};
virtual ~PhysicsCapsule() {};
public:
virtual bool parse(const char* _line);
virtual void display() {};
public:
virtual enum ege::PhysicsShape::type getType() const {
return ege::PhysicsShape::capsule;
};
private:
float m_radius;
public:
float getRadius() const {
return m_radius;
};
private:
float m_height;
public:
float getHeight() const {
return m_height;
};
public:
virtual const ege::PhysicsCapsule* toCapsule() const {
return this;
};
virtual ege::PhysicsCapsule* toCapsule() {
return this;
};
};
}

44
ege/physicsShape/PhysicsCone.hpp
View File

@ -1,44 +0,0 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <ege/physicsShape/PhysicsShape.hpp>
namespace ege {
class PhysicsCone : public ege::PhysicsShape {
public:
PhysicsCone() {};
virtual ~PhysicsCone() {};
public:
virtual bool parse(const char* _line);
virtual void display() {};
public:
virtual enum ege::PhysicsShape::type getType() const {
return ege::PhysicsShape::cone;
};
private:
float m_radius;
public:
float getRadius() const {
return m_radius;
};
private:
float m_height;
public:
float getHeight() const {
return m_height;
};
public:
virtual const ege::PhysicsCone* toCone() const {
return this;
};
virtual ege::PhysicsCone* toCone() {
return this;
};
};
}

44
ege/physicsShape/PhysicsConvexHull.hpp
View File

@ -1,44 +0,0 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <ege/physicsShape/PhysicsShape.hpp>
namespace ege {
class PhysicsConvexHull : public ege::PhysicsShape {
public:
PhysicsConvexHull() {};
virtual ~PhysicsConvexHull() {};
public:
virtual bool parse(const char* _line);
virtual void display() {};
public:
virtual enum ege::PhysicsShape::type getType() const {
return ege::PhysicsShape::convexHull;
};
private:
vec3 m_scale;
public:
vec3 getScale() const {
return m_scale;
};
private:
std::vector<vec3> m_points;
public:
const std::vector<vec3>& getPointList() const {
return m_points;
};
public:
virtual const ege::PhysicsConvexHull* toConvexHull() const {
return this;
};
virtual ege::PhysicsConvexHull* toConvexHull() {
return this;
};
};
}

40
ege/physicsShape/PhysicsCylinder.hpp
View File

@ -1,40 +0,0 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <ege/physicsShape/PhysicsShape.hpp>
namespace ege {
class PhysicsCylinder : public ege::PhysicsShape {
public:
PhysicsCylinder() {};
virtual ~PhysicsCylinder() {};
public:
virtual bool parse(const char* _line);
virtual void display() {};
public:
virtual enum ege::PhysicsShape::type getType() const {
return ege::PhysicsShape::cylinder;
};
private:
vec3 m_size;
public:
vec3 getSize() const {
return m_size;
};
public:
virtual const ege::PhysicsCylinder* toCylinder() const {
return this;
};
virtual ege::PhysicsCylinder* toCylinder() {
return this;
};
};
}

143
ege/physicsShape/PhysicsShape.hpp
View File

@ -1,143 +0,0 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <etk/math/Vector4D.hpp>
#include <etk/math/Vector3D.hpp>
#include <etk/math/Quaternion.hpp>
#include <ememory/memory.hpp>
namespace ege {
class PhysicsBox;
class PhysicsCylinder;
class PhysicsCapsule;
class PhysicsCone;
class PhysicsConvexHull;
class PhysicsSphere;
class PhysicsShape {
public:
static ememory::SharedPtr<ege::PhysicsShape> create(const std::string& _name);
public:
enum type {
unknow,
box,
capsule,
cone,
convexHull,
cylinder,
sphere
};
public:
PhysicsShape() :
m_quaternion(1,0,0,0),
m_origin(0,0,0),
m_mass(1) { // by default set mass at 1g
}
virtual ~PhysicsShape() {
}
public:
virtual enum ege::PhysicsShape::type getType() const {
return ege::PhysicsShape::unknow;
}
public:
virtual bool parse(const char* _line);
virtual void display() {
}
private:
vec4 m_quaternion;
public:
const vec4& getQuaternion() const {
return m_quaternion;
}
etk::Quaternion getOrientation() const {
return etk::Quaternion(m_quaternion.x(), m_quaternion.y(), m_quaternion.z(), m_quaternion.w());
}
private:
vec3 m_origin;
public:
const vec3& getOrigin() const {
return m_origin;
};
private:
float m_mass; //!< element mass in "g" then 1000 for 1kg
public:
float getMass() const {
return m_mass;
}
void setMass(float _mass) {
m_mass = _mass;
}
public:
bool isBox() {
return getType() == ege::PhysicsShape::box;
};
bool isCylinder() {
return getType() == ege::PhysicsShape::cylinder;
};
bool isCapsule() {
return getType() == ege::PhysicsShape::capsule;
};
bool isCone() {
return getType() == ege::PhysicsShape::cone;
};
bool isConvexHull() {
return getType() == ege::PhysicsShape::convexHull;
};
bool isSphere() {
return getType() == ege::PhysicsShape::sphere;
};
virtual const ege::PhysicsBox* toBox() const {
return nullptr;
};
virtual ege::PhysicsBox* toBox() {
return nullptr;
};
virtual const ege::PhysicsCylinder* toCylinder() const {
return nullptr;
};
virtual ege::PhysicsCylinder* toCylinder() {
return nullptr;
};
virtual const ege::PhysicsCapsule* toCapsule() const {
return nullptr;
};
virtual ege::PhysicsCapsule* toCapsule() {
return nullptr;
};
virtual const ege::PhysicsCone* toCone() const {
return nullptr;
};
virtual ege::PhysicsCone* toCone() {
return nullptr;
};
virtual const ege::PhysicsConvexHull* toConvexHull() const {
return nullptr;
};
virtual ege::PhysicsConvexHull* toConvexHull() {
return nullptr;
};
virtual const ege::PhysicsSphere* toSphere() const {
return nullptr;
};
virtual ege::PhysicsSphere* toSphere() {
return nullptr;
};
};
}

43
ege/physicsShape/PhysicsSphere.hpp
View File

@ -1,43 +0,0 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#pragma once
#include <etk/types.hpp>
#include <ege/physicsShape/PhysicsShape.hpp>
namespace ege {
class PhysicsSphere : public ege::PhysicsShape {
public:
PhysicsSphere() {};
virtual ~PhysicsSphere() {};
public:
virtual bool parse(const char* _line);
virtual void display() {};
public:
virtual enum ege::PhysicsShape::type getType() const {
return ege::PhysicsShape::sphere;
};
private:
float m_radius; // props["radius"] = obj.scale.x
public:
float getRadius() const {
return m_radius;
};
void setRadius(float _radius) {
m_radius = _radius;
};
private:
virtual const ege::PhysicsSphere* toSphere() const {
return this;
};
virtual ege::PhysicsSphere* toSphere() {
return this;
};
};
}

8
ege/resource/Mesh.hpp
View File

@ -18,7 +18,7 @@
#include <ege/resource/tools/Face.hpp>
#include <ege/resource/tools/FaceIndexing.hpp>
#include <ege/physicsShape/PhysicsShape.hpp>
#include <ege/physics/shape/Shape.hpp>
// VBO table property:
#define MESH_VBO_VERTICES (0)
#define MESH_VBO_TEXTURE (1)
@ -80,7 +80,7 @@ namespace ege {
std::vector<vec3> m_listVertexNormal; //!< List of all Face normal, when calculated
etk::Hash<FaceIndexing> m_listFaces; //!< List of all Face for the mesh
etk::Hash<ememory::SharedPtr<ege::Material>> m_materials;
std::vector<ememory::SharedPtr<ege::PhysicsShape>> m_physics; //!< collision shape module ... (independent of bullet lib)
std::vector<ememory::SharedPtr<ege::physics::Shape>> m_physics; //!< collision shape module ... (independent of bullet lib)
void clean();
protected:
ememory::SharedPtr<gale::resource::VirtualBufferObject> m_verticesVBO;
@ -131,10 +131,10 @@ namespace ege {
bool getCheckNormal() {
return m_checkNormal;
};
const std::vector<ememory::SharedPtr<ege::PhysicsShape>>& getPhysicalProperties() const {
const std::vector<ememory::SharedPtr<ege::physics::Shape>>& getPhysicalProperties() const {
return m_physics;
};
void addPhysicElement(const ememory::SharedPtr<ege::PhysicsShape>& _shape) {
void addPhysicElement(const ememory::SharedPtr<ege::physics::Shape>& _shape) {
m_physics.push_back(_shape);
}
private:

6
ege/resource/MeshEmf.cpp
View File

@ -174,7 +174,7 @@ bool ege::resource::Mesh::loadEMF(const std::string& _fileName) {
std::string materialName = "";
ememory::SharedPtr<ege::Material> material;
// physical shape:
ememory::SharedPtr<ege::PhysicsShape> physics;
ememory::SharedPtr<ege::physics::Shape> physics;
bool haveUVMapping = false;
size_t offsetVertexId = 0;
size_t offsetUV = 0;
@ -435,7 +435,7 @@ bool ege::resource::Mesh::loadEMF(const std::string& _fileName) {
}
removeEndLine(inputDataLine);
if (level == 2) {
physics = ege::PhysicsShape::create(inputDataLine);
physics = ege::physics::Shape::create(inputDataLine);
if (physics == nullptr) {
EGE_ERROR("Allocation error when creating physical shape ...");
continue;
@ -532,7 +532,7 @@ bool ege::resource::Mesh::loadEMF(const std::string& _fileName) {
removeEndLine(inputDataLine);
if (level == 1) {
EGE_ERROR("Load shape : " << inputDataLine);
physics = ege::PhysicsShape::create(inputDataLine);
physics = ege::physics::Shape::create(inputDataLine);
if (physics == nullptr) {
EGE_ERROR("Allocation error when creating physical shape ...");
continue;

71
ege/widget/Scene.cpp
View File

@ -23,7 +23,7 @@ namespace etk {
};
ege::widget::Scene::Scene() :
signalDisplayDebug(this, "drawDebug", "Call to draw debug after all elements"),
signalDisplayDebug(this, "drawDebug", "Call to draw debug after all entitys"),
propertyDebugPhysic(this, "debugPhysic",
false,
"Display debug of the physic interface"),
@ -73,75 +73,6 @@ void ege::widget::Scene::onDraw() {
#endif
gale::openGL::clearColor(etk::color::black);
m_env->render(echrono::Duration(1.0/60.0), m_cameraName);
#if 0
// draw constant object:
{
mat4 tmpMatrix;
for (auto &it : m_env->getStaticMeshToDraw()) {
if (it != nullptr) {
it->draw(tmpMatrix);
}
}
}
// get camera:
ememory::SharedPtr<ege::Camera> camera = m_env->getCamera(m_cameraName);
if (camera == nullptr) {
EGE_ERROR(" can not get camera named: '" << m_cameraName << "'");
return;
}
//EGE_DEBUG("Draw (start)");
mat4 tmpMatrix;
m_env->getOrderedElementForDisplay(m_displayElementOrdered, camera->getEye(), camera->getViewVector());
EGE_VERBOSE("DRAW : " << m_displayElementOrdered.size() << "/" << m_env->getElement().size() << " elements");
// TODO : remove this == > no more needed ==> checked in the generate the list of the element ordered
for (size_t iii=0; iii<m_displayElementOrdered.size(); iii++) {
m_displayElementOrdered[iii].element->preCalculationDraw(*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)
for (int32_t iii=m_displayElementOrdered.size()-1; iii >= 0; iii--) {
m_displayElementOrdered[iii].element->draw(0);
}
// for the other pass the user can draw transparent elements ...
for (int32_t pass=1; pass <= NUMBER_OF_SUB_PASS+1; pass++) {
for (size_t iii=0; iii<m_displayElementOrdered.size(); iii++) {
m_displayElementOrdered[iii].element->draw(pass);
}
}
if (propertyDebugPhysic.get() == true) {
// Draw debug ... (Object)
for (int32_t iii=m_displayElementOrdered.size()-1; iii >= 0; iii--) {
m_displayElementOrdered[iii].element->drawDebug(m_debugDrawProperty, camera);
}
// Draw debug ... (Camera)
/*
std::map<std::string, ememory::SharedPtr<ege::Camera>> listCamera = m_env->getCameraList();
for (auto &itCam : listCamera) {
if (itCam.second != nullptr) {
itCam.second->drawDebug(m_debugDrawProperty, camera);
}
}
*/
}
if (propertyDebugNormal.get() == true) {
// Draw debug ... (Object)
for (int32_t iii=m_displayElementOrdered.size()-1; iii >= 0; iii--) {
m_displayElementOrdered[iii].element->drawNormalDebug(m_debugDrawProperty, camera);
}
}
if (propertyDebugApplication.get() == true) {
// Draw debug ... (User)
signalDisplayDebug.emit(m_debugDrawProperty);
}
/* TODO: set it back ...
if (camera != nullptr) {
m_env->getParticuleEngine().draw(*camera);
}
*/
#endif
#ifdef SCENE_DISPLAY_SPEED
echrono::Duration localTime = echrono::Steady::now() - g_startTime;
if (localTime>1) {

6
ege/widget/Scene.hpp
View File

@ -14,7 +14,7 @@
#include <ewol/widget/Widget.hpp>
#include <gale/renderer/openGL/openGL.hpp>
#include <gale/resource/Manager.hpp>
#include <ege/elements/Element.hpp>
#include <ege/Entity.hpp>
#include <gale/Dimension.hpp>
#include <ewol/widget/Widget.hpp>
#include <esignal/Signal.hpp>
@ -66,8 +66,8 @@ namespace ege {
return m_cameraName;
}
protected:
// Note : This is only for temporary elements : on the display
std::vector<ege::Environement::ResultNearestElement> m_displayElementOrdered;
// Note : This is only for temporary entitys : on the display
std::vector<ege::Environement::ResultNearestEntity> m_displayEntityOrdered;
protected:
esignal::Connection m_PCH; //!< Periodic call handle to remove it when needed
/**

32
lutin_ege.py
View File

@ -36,7 +36,7 @@ def configure(target, my_module):
'ege/position/Component.cpp',
'ege/physics/Component.cpp',
'ege/physics/Engine.cpp',
'ege/elements/Element.cpp',
'ege/Entity.cpp',
#'ege/elements/ElementBase.cpp',
#'ege/elements/ElementPhysic.cpp',
'ege/particule/Component.cpp',
@ -61,13 +61,13 @@ def configure(target, my_module):
'ege/resource/tools/viewBox.cpp',
'ege/Light.cpp',
'ege/Material.cpp',
'ege/physicsShape/PhysicsShape.cpp',
'ege/physicsShape/PhysicsBox.cpp',
'ege/physicsShape/PhysicsCapsule.cpp',
'ege/physicsShape/PhysicsCone.cpp',
'ege/physicsShape/PhysicsConvexHull.cpp',
'ege/physicsShape/PhysicsCylinder.cpp',
'ege/physicsShape/PhysicsSphere.cpp',
'ege/physics/shape/Shape.cpp',
'ege/physics/shape/Box.cpp',
'ege/physics/shape/Capsule.cpp',
'ege/physics/shape/Cone.cpp',
'ege/physics/shape/ConvexHull.cpp',
'ege/physics/shape/Cylinder.cpp',
'ege/physics/shape/Sphere.cpp',
'ege/Ray.cpp',
])
my_module.copy_path('data/ParticuleMesh.*')
@ -88,7 +88,7 @@ def configure(target, my_module):
'ege/position/Component.hpp',
'ege/physics/Engine.hpp',
'ege/physics/Component.hpp',
'ege/elements/Element.hpp',
'ege/Entity.hpp',
#'ege/elements/ElementBase.hpp',
#'ege/elements/ElementPhysic.hpp',
'ege/particule/Component.hpp',
@ -109,13 +109,13 @@ def configure(target, my_module):
'ege/resource/tools/FaceIndexing.hpp',
'ege/Light.hpp',
'ege/Material.hpp',
'ege/physicsShape/PhysicsShape.hpp',
'ege/physicsShape/PhysicsBox.hpp',
'ege/physicsShape/PhysicsCapsule.hpp',
'ege/physicsShape/PhysicsCone.hpp',
'ege/physicsShape/PhysicsConvexHull.hpp',
'ege/physicsShape/PhysicsCylinder.hpp',
'ege/physicsShape/PhysicsSphere.hpp',
'ege/physics/shape/Shape.hpp',
'ege/physics/shape/Box.hpp',
'ege/physics/shape/Capsule.hpp',
'ege/physics/shape/Cone.hpp',
'ege/physics/shape/ConvexHull.hpp',
'ege/physics/shape/Cylinder.hpp',
'ege/physics/shape/Sphere.hpp',
'ege/Ray.hpp',
])
# TODO: Remove this ...

46
sample/Collision/appl/Windows.cpp
View File

@ -15,9 +15,9 @@
#include <ege/widget/Scene.hpp>
#include <ege/camera/View.hpp>
#include <etk/tool.hpp>
#include <ege/elements/Element.hpp>
#include <ege/physicsShape/PhysicsBox.hpp>
#include <ege/physicsShape/PhysicsSphere.hpp>
#include <ege/Entity.hpp>
#include <ege/physics/shape/Box.hpp>
#include <ege/physics/shape/Sphere.hpp>
#include <ege/position/Component.hpp>
#include <ege/render/Component.hpp>
#include <ege/physics/Component.hpp>
@ -99,7 +99,7 @@ void appl::Windows::init() {
// Create an external box: (no physics)
myMesh = createViewBoxStar();
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Element> element = ememory::makeShared<ege::Element>(m_env);
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
@ -108,12 +108,12 @@ void appl::Windows::init() {
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
// add it ..
m_env->addElement(element);
m_env->addEntity(element);
}
// create basic gird: (no physics)
myMesh = ege::resource::Mesh::createGrid(10, vec3(0,0,0), 5);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Element> element = ememory::makeShared<ege::Element>(m_env);
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
// 1st Position component:
etk::Transform3D transform(vec3(0,0,0), etk::Quaternion::identity());
ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
@ -122,12 +122,12 @@ void appl::Windows::init() {
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender);
// add it ..
m_env->addElement(element);
m_env->addEntity(element);
}
// create cubes ...
myMesh = ege::resource::Mesh::createCube(3, "basics", etk::color::green);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Element> element = ememory::makeShared<ege::Element>(m_env);
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(0,0,2), etk::Quaternion::identity());
@ -136,18 +136,18 @@ void appl::Windows::init() {
element->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::PhysicsBox> physic = ememory::makeShared<ege::PhysicsBox>();
ememory::SharedPtr<ege::physics::shape::Box> physic = ememory::makeShared<ege::physics::shape::Box>();
physic->setSize(vec3(3.01,3.01,3.01));
physic->setMass(300000);
componentPhysics->addShape(physic);
componentPhysics->generate();
element->addComponent(componentPhysics);
// add it ..
m_env->addElement(element);
m_env->addEntity(element);
}
myMesh = ege::resource::Mesh::createCube(3, "basics", etk::color::orange);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Element> element = ememory::makeShared<ege::Element>(m_env);
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(20,-10,10), etk::Quaternion::identity());
@ -158,18 +158,18 @@ void appl::Windows::init() {
element->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::PhysicsBox> physic = ememory::makeShared<ege::PhysicsBox>();
ememory::SharedPtr<ege::physics::shape::Box> physic = ememory::makeShared<ege::physics::shape::Box>();
physic->setSize(vec3(3.01,3.01,3.01));
physic->setMass(50000);
componentPhysics->addShape(physic);
componentPhysics->generate();
element->addComponent(componentPhysics);
// add it ..
m_env->addElement(element);
m_env->addEntity(element);
}
myMesh = ege::resource::Mesh::createSphere(4, "basics", etk::color::blue);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Element> element = ememory::makeShared<ege::Element>(m_env);
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(vec3(-20,10,10), etk::Quaternion::identity());
@ -180,26 +180,26 @@ void appl::Windows::init() {
element->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::PhysicsSphere> physic = ememory::makeShared<ege::PhysicsSphere>();
ememory::SharedPtr<ege::physics::shape::Sphere> physic = ememory::makeShared<ege::physics::shape::Sphere>();
physic->setRadius(4.01);
physic->setMass(500000);
componentPhysics->addShape(physic);
componentPhysics->generate();
element->addComponent(componentPhysics);
// add it ..
m_env->addElement(element);
m_env->addEntity(element);
}
m_env->propertyStatus.set(ege::gameStart);
}
/*
namespace appl {
class ElementHerit : public ege::ElementPhysic {
class EntityHerit : public ege::EntityPhysic {
public:
ElementHerit(const ememory::SharedPtr<ege::Environement>& _env, bool _autoRigidBody=true) :
ege::ElementPhysic(_env, _autoRigidBody) {
EntityHerit(const ememory::SharedPtr<ege::Environement>& _env, bool _autoRigidBody=true) :
ege::EntityPhysic(_env, _autoRigidBody) {
setCollisionDetectionStatus(true);
}
virtual void onCollisionDetected(const ememory::SharedPtr<ege::Element>& _obj, const vec3& _point, const vec3& _normal) {
virtual void onCollisionDetected(const ememory::SharedPtr<ege::Entity>& _obj, const vec3& _point, const vec3& _normal) {
APPL_WARNING("[" << getUID() << "] collision : pos=" << _point << " norm=" <<_normal);
}
};
@ -217,7 +217,7 @@ bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
ememory::SharedPtr<ege::resource::Mesh> myMesh;
myMesh = ege::resource::Mesh::createCube(1, "basics", etk::color::orange);
if (myMesh != nullptr) {
ememory::SharedPtr<ege::Element> element = ememory::makeShared<ege::Element>(m_env);
ememory::SharedPtr<ege::Entity> element = ememory::makeShared<ege::Entity>(m_env);
// add all component:
// 1st Position component:
etk::Transform3D transform(ray.getOrigin(), etk::Quaternion::identity());
@ -228,7 +228,7 @@ bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
element->addComponent(componentRender);
// 3rd some physic:
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform);
ememory::SharedPtr<ege::PhysicsBox> physic = ememory::makeShared<ege::PhysicsBox>();
ememory::SharedPtr<ege::physics::shape::Box> physic = ememory::makeShared<ege::physics::shape::Box>();
physic->setSize(vec3(1.01,1.01,1.01));
physic->setMass(1000);
componentPhysics->setType(ege::physics::Component::type::bodyDynamic);
@ -239,7 +239,7 @@ bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
componentPhysics->setLinearVelocity(ray.getDirection()*100);
element->addComponent(componentPhysics);
// add it ..
m_env->addElement(element);
m_env->addEntity(element);
}
return true;
}