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

[DEV] collision and basic physics debug

Browse Source
This commit is contained in:
Edouard DUPIN 2017-05-21 15:49:28 +00:00
parent 80793fb4da
commit c25f125dee
31 changed files with 454 additions and 545 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

180
ege/CollisionShapeCreator.cpp
View File

@ -1,180 +0,0 @@
/** @file
* @author Edouard DUPIN
* @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file)
*/
#include <ege/debug.hpp>
#include <ege/CollisionShapeCreator.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>
// Documentetion of bullet library:
// http://bulletphysics.org/mediawiki-1.5.8/index.php/Collision_Shapes
/*
btCollisionShape* ege::collision::createShape(const ememory::SharedPtr<ege::resource::Mesh>& _mesh) {
if (_mesh == nullptr) {
EGE_ERROR("Create empty shape (no mesh)");
return new btEmptyShape();
}
const std::vector<ememory::SharedPtr<ege::PhysicsShape>>& physiqueProperty = _mesh->getPhysicalProperties();
if (physiqueProperty.size() == 0) {
EGE_ERROR("Create empty shape (no default shape)");
return new btEmptyShape();
}
int32_t count = 0;
for (size_t iii=0; iii<physiqueProperty.size(); iii++) {
if (physiqueProperty[iii] == nullptr) {
continue;
}
count++;
}
btCompoundShape* outputShape = nullptr;
if (count>1) {
EGE_ERROR("Create complexe shape");
outputShape = new btCompoundShape();
} else {
EGE_ERROR("Create simple shape");
// TODO : Remove this line ==> it is bad but it correct a bug of a single shape that has no more display
outputShape = new btCompoundShape();
}
for (size_t iii=0; iii<physiqueProperty.size(); iii++) {
if (physiqueProperty[iii] == nullptr) {
continue;
}
switch (physiqueProperty[iii]->getType()) {
case ege::PhysicsShape::box : {
EGE_ERROR(" Box");
const ege::PhysicsBox* tmpElement = physiqueProperty[iii]->toBox();
if (tmpElement == nullptr) {
EGE_ERROR(" Box ==> can not cast in BOX");
continue;
}
btCollisionShape* tmpShape = new btBoxShape(tmpElement->getSize());
if (tmpShape != nullptr) {
if (outputShape == nullptr) {
return tmpShape;
} else {
vec4 qqq = tmpElement->getQuaternion();
const btTransform localTransform(btQuaternion(qqq.x(),qqq.y(),qqq.z(),qqq.w()), tmpElement->getOrigin());
outputShape->addChildShape(localTransform, tmpShape);
}
} else {
EGE_ERROR("Allocation shape error BOX");
}
break;
}
case ege::PhysicsShape::cylinder : {
EGE_DEBUG(" Cylinder");
const ege::PhysicsCylinder* tmpElement = physiqueProperty[iii]->toCylinder();
if (tmpElement == nullptr) {
EGE_ERROR(" Cylinder ==> can not cast in Cylinder");
continue;
}
btCollisionShape* tmpShape = new btCylinderShape(tmpElement->getSize());
if (tmpShape != nullptr) {
if (outputShape == nullptr) {
return tmpShape;
} else {
vec4 qqq = tmpElement->getQuaternion();
const btTransform localTransform(btQuaternion(qqq.x(),qqq.y(),qqq.z(),qqq.w()), tmpElement->getOrigin());
outputShape->addChildShape(localTransform, tmpShape);
}
}
break;
}
case ege::PhysicsShape::capsule : {
EGE_DEBUG(" Capsule");
const ege::PhysicsCapsule* tmpElement = physiqueProperty[iii]->toCapsule();
if (tmpElement == nullptr) {
EGE_ERROR(" Capsule ==> can not cast in Capsule");
continue;
}
btCollisionShape* tmpShape = new btCapsuleShape(tmpElement->getRadius(), tmpElement->getHeight());
if (tmpShape != nullptr) {
if (outputShape == nullptr) {
return tmpShape;
} else {
vec4 qqq = tmpElement->getQuaternion();
const btTransform localTransform(btQuaternion(qqq.x(),qqq.y(),qqq.z(),qqq.w()), tmpElement->getOrigin());
outputShape->addChildShape(localTransform, tmpShape);
}
}
break;
}
case ege::PhysicsShape::cone : {
EGE_DEBUG(" Cone");
const ege::PhysicsCone* tmpElement = physiqueProperty[iii]->toCone();
if (tmpElement == nullptr) {
EGE_ERROR(" Cone ==> can not cast in Cone");
continue;
}
btCollisionShape* tmpShape = new btConeShape(tmpElement->getRadius(), tmpElement->getHeight());
if (tmpShape != nullptr) {
if (outputShape == nullptr) {
return tmpShape;
} else {
vec4 qqq = tmpElement->getQuaternion();
const btTransform localTransform(btQuaternion(qqq.x(),qqq.y(),qqq.z(),qqq.w()), tmpElement->getOrigin());
outputShape->addChildShape(localTransform, tmpShape);
}
}
break;
}
case ege::PhysicsShape::sphere : {
EGE_DEBUG(" Sphere");
const ege::PhysicsSphere* tmpElement = physiqueProperty[iii]->toSphere();
if (tmpElement == nullptr) {
EGE_ERROR(" Sphere ==> can not cast in Sphere");
continue;
}
btCollisionShape* tmpShape = new btSphereShape(tmpElement->getRadius());
if (tmpShape != nullptr) {
if (outputShape == nullptr) {
return tmpShape;
} else {
vec4 qqq = tmpElement->getQuaternion();
const btTransform localTransform(btQuaternion(qqq.x(),qqq.y(),qqq.z(),qqq.w()), tmpElement->getOrigin());
outputShape->addChildShape(localTransform, tmpShape);
}
}
break;
}
case ege::PhysicsShape::convexHull : {
EGE_DEBUG(" convexHull");
const ege::PhysicsConvexHull* tmpElement = physiqueProperty[iii]->toConvexHull();
if (tmpElement == nullptr) {
EGE_ERROR(" convexHull ==> can not cast in convexHull");
continue;
}
btConvexHullShape* tmpShape = new btConvexHullShape(&(tmpElement->getPointList()[0].x()), tmpElement->getPointList().size());
if (tmpShape != nullptr) {
if (outputShape == nullptr) {
return tmpShape;
} else {
vec4 qqq = tmpElement->getQuaternion();
const btTransform localTransform(btQuaternion(qqq.x(),qqq.y(),qqq.z(),qqq.w()), tmpElement->getOrigin());
outputShape->addChildShape(localTransform, tmpShape);
}
}
break;
}
default :
EGE_DEBUG(" ???");
// TODO : UNKNOW type ...
break;
}
}
if (outputShape == nullptr) {
EGE_DEBUG("create empty shape ...");
return new btEmptyShape();
}
return outputShape;
}
*/

16
ege/CollisionShapeCreator.hpp
View File

@ -1,16 +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/resource/Mesh.hpp>
namespace ege {
namespace collision {
//btCollisionShape* createShape(const ememory::SharedPtr<ege::resource::Mesh>& _mesh);
}
}

4
ege/Engine.cpp
View File

@ -30,4 +30,8 @@ void ege::Engine::update(const echrono::Duration& _delta) {
void ege::Engine::render(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera) { void ege::Engine::render(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera) {
}
void ege::Engine::renderDebug(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera) {
} }

11
ege/Engine.hpp
View File

@ -11,11 +11,14 @@
#include <ege/Component.hpp> #include <ege/Component.hpp>
#include <echrono/Duration.hpp> #include <echrono/Duration.hpp>
#include <ege/camera/Camera.hpp> #include <ege/camera/Camera.hpp>
#include <eproperty/Interface.hpp>
namespace ege { namespace ege {
class Environement; class Environement;
class Camera; class Camera;
class Engine : public ememory::EnableSharedFromThis<Engine> { class Engine :
public ememory::EnableSharedFromThis<Engine>,
public eproperty::Interface {
protected: protected:
ege::Environement* m_env; ege::Environement* m_env;
public: public:
@ -48,6 +51,12 @@ namespace ege {
* @param[in] _camera Camera property to render the engine properties ... * @param[in] _camera Camera property to render the engine properties ...
*/ */
virtual void render(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera); virtual void render(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera);
/**
* @brief Globalgame engine main cycle of draw
* @param[in] _delta time from the last render
* @param[in] _camera Camera property to render the engine properties ...
*/
virtual void renderDebug(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera);
}; };
} }

64
ege/Environement.cpp
View File

@ -115,7 +115,7 @@ 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::Element> ege::Environement::getElementNearest(ememory::SharedPtr<ege::Element> _sourceRequest, float& _distance) {
if (_sourceRequest == nullptr) { if (_sourceRequest == nullptr) {
return nullptr; return nullptr;
@ -210,6 +210,7 @@ void ege::Environement::getElementNearestFixed(const vec3& _sourcePosition,
} }
} }
} }
*/
static etk::Hash<ege::createElement_tf>& getHachTableCreating() { static etk::Hash<ege::createElement_tf>& getHachTableCreating() {
static etk::Hash<ege::createElement_tf> s_table; static etk::Hash<ege::createElement_tf> s_table;
@ -389,60 +390,6 @@ void ege::Environement::rmElement(ememory::SharedPtr<ege::Element> _removeElemen
} }
} }
// TODO : DEPRECATED ==> special function of the renderer ...
void ege::Environement::getOrderedElementForDisplay(std::vector<ege::Environement::ResultNearestElement>& _resultList,
const vec3& _position,
const vec3& _direction) {
// TODO : Set it back ... corrected...
// remove all unneeded elements (old display...)
_resultList.clear();
// basic element result
ege::Environement::ResultNearestElement result;
result.dist = 99999999999.0f;
result.element = nullptr;
// for all element in the game we chek if it is needed to display it ...
for (size_t iii=0; iii<m_listElement.size() ; iii++) {
// check nullptr pointer
if (m_listElement[iii] == nullptr) {
// no pointer null are set in the output list ...
continue;
}
result.element = m_listElement[iii];
// check distance ...
vec3 destPosition = result.element->getPosition();
vec3 angleView = (destPosition - _position);
angleView.safeNormalize();
float dotResult=angleView.dot(_direction);
//EGE_DEBUG("Dot position : " << destPosition << " == > dot=" << dotResult);
/*
if (dotResult <= 0.85f) {
// they are not in the camera angle view ... == > no need to process display
continue;
}
*/
result.dist = (_position - destPosition).length();
/*
if (result.dist>500.0f) {
// The element is realy too far ... == > no need to display
continue;
}
*/
// try to add the element at the best positions:
size_t jjj;
for (jjj=0; jjj<_resultList.size(); jjj++) {
if (_resultList[jjj].dist>result.dist) {
_resultList.insert(_resultList.begin()+jjj, result);
break;
}
}
// add element at the end :
if (jjj >= _resultList.size()) {
_resultList.push_back(result);
}
}
}
void ege::Environement::generateInteraction(ege::ElementInteraction& _event) { void ege::Environement::generateInteraction(ege::ElementInteraction& _event) {
// inform the element that an element has been removed == > this permit to keep pointer on elements ... // 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++) { for (size_t iii=0; iii<m_listElement.size() ; iii++) {
@ -502,6 +449,13 @@ void ege::Environement::render(const echrono::Duration& _delta, const std::strin
EGE_VERBOSE(" render: " << it->getType()); EGE_VERBOSE(" render: " << it->getType());
it->render(_delta, camera); it->render(_delta, camera);
} }
for (auto &it: m_engine) {
if(it == nullptr) {
continue;
}
EGE_VERBOSE(" render: " << it->getType());
it->renderDebug(_delta, camera);
}
} }
void ege::Environement::onCallbackPeriodicCall(const ewol::event::Time& _event) { void ege::Environement::onCallbackPeriodicCall(const ewol::event::Time& _event) {

9
ege/Environement.hpp
View File

@ -181,6 +181,7 @@ namespace ege {
* @param[in] _distance Maximum distance search == > return the element distance * @param[in] _distance Maximum distance search == > return the element distance
* @return Pointer on the neares element OR nullptr * @return Pointer on the neares element OR nullptr
*/ */
/*
ememory::SharedPtr<ege::Element> getElementNearest(ememory::SharedPtr<ege::Element> _sourceRequest, float& _distance); ememory::SharedPtr<ege::Element> getElementNearest(ememory::SharedPtr<ege::Element> _sourceRequest, float& _distance);
void getElementNearest(const vec3& _sourcePosition, void getElementNearest(const vec3& _sourcePosition,
@ -189,6 +190,7 @@ namespace ege {
void getElementNearestFixed(const vec3& _sourcePosition, void getElementNearestFixed(const vec3& _sourcePosition,
float _distanceMax, float _distanceMax,
std::vector<ege::Environement::ResultNearestElement>& _resultList); std::vector<ege::Environement::ResultNearestElement>& _resultList);
*/
/** /**
* @brief add an element on the list availlable. * @brief add an element on the list availlable.
* @param[in] _newElement Element to add. * @param[in] _newElement Element to add.
@ -199,13 +201,6 @@ namespace ege {
* @param[in] _removeElement Element to remove. * @param[in] _removeElement Element to remove.
*/ */
void rmElement(ememory::SharedPtr<ege::Element> _removeElement); void rmElement(ememory::SharedPtr<ege::Element> _removeElement);
/**
* @brief get the element order from the nearest to the farest, and remove all element that are not in the camera angle and axes.
* @param[in,out] _resultList List of the element ordered.
* @param[in] _position Camera position in the space.
* @param[in] _direction Camera direction of the view.
*/
void getOrderedElementForDisplay(std::vector<ege::Environement::ResultNearestElement>& _resultList, const vec3& _position, const vec3& _direction);
/** /**
* @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 element of the game == > usefull for explosion, or lazer fire ...
* @param[in] _event event that might be apply ... * @param[in] _event event that might be apply ...

42
ege/elements/Element.cpp
View File

@ -8,7 +8,6 @@
#include <ege/debug.hpp> #include <ege/debug.hpp>
#include <ege/elements/Element.hpp> #include <ege/elements/Element.hpp>
#include <ege/Environement.hpp> #include <ege/Environement.hpp>
#include <ege/CollisionShapeCreator.hpp>
const std::string& ege::Element::getType() const { const std::string& ege::Element::getType() const {
@ -20,16 +19,14 @@ const std::string& ege::Element::getType() const {
ege::Element::Element(const ememory::SharedPtr<ege::Environement>& _env) : ege::Element::Element(const ememory::SharedPtr<ege::Environement>& _env) :
m_env(_env), m_env(_env),
m_uID(0), m_uID(0),
m_mesh(),
m_life(100), m_life(100),
m_lifeMax(100), m_lifeMax(100),
m_group(0), m_group(0),
m_fixe(true),
m_radius(0) { m_radius(0) {
static uint32_t unique=0; static uint32_t unique=0;
m_uID = unique; m_uID = unique;
EGE_DEBUG("Create element: uId=" << m_uID); EGE_DEBUG("Create element: uId=" << m_uID);
m_debugText.setFontSize(12); //m_debugText.setFontSize(12);
unique++; unique++;
} }
@ -183,27 +180,6 @@ bool ege::Element::unInit() {
} }
bool ege::Element::loadMesh(const std::string& _meshFileName) {
ememory::SharedPtr<ege::resource::Mesh> tmpMesh = ege::resource::Mesh::create(_meshFileName);
if(tmpMesh == nullptr) {
EGE_ERROR("can not load the resources : " << _meshFileName);
return false;
}
return setMesh(tmpMesh);
}
bool ege::Element::setMesh(ememory::SharedPtr<ege::resource::Mesh> _mesh) {
if (m_mesh != nullptr) {
m_mesh.reset();
}
m_mesh = _mesh;
// auto load the shape :
if (m_mesh == nullptr) {
return true;
}
return true;
}
float ege::Element::getLifeRatio() { float ege::Element::getLifeRatio() {
if (0 >= m_life) { if (0 >= m_life) {
@ -224,18 +200,12 @@ void ege::Element::setFireOn(int32_t _groupIdSource, int32_t _type, float _power
} }
} }
const vec3& ege::Element::getPosition() {
// this is to prevent error like segmentation fault ...
static vec3 emptyPosition(-1000000,-1000000,-1000000);
return emptyPosition;
};
const float lifeBorder = 0.1f; const float lifeBorder = 0.1f;
const float lifeHeight = 0.3f; const float lifeHeight = 0.3f;
const float lifeWidth = 2.0f; const float lifeWidth = 2.0f;
const float lifeYPos = 1.7f; const float lifeYPos = 1.7f;
#if 0
void ege::Element::drawLife(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera) { void ege::Element::drawLife(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera) {
if (_draw == nullptr) { if (_draw == nullptr) {
return; return;
@ -274,16 +244,20 @@ void ege::Element::drawLife(ememory::SharedPtr<ewol::resource::Colored3DObject>
_draw->draw(localVertices, myColor, transformationMatrix, false, false); _draw->draw(localVertices, myColor, transformationMatrix, false, false);
#endif #endif
} }
#endif
void ege::Element::drawDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera) { void ege::Element::drawDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera) {
/*
m_debugText.clear(); m_debugText.clear();
m_debugText.setColor(etk::Color<>(0x00, 0xFF, 0x00, 0xFF)); m_debugText.setColor(etk::Color<>(0x00, 0xFF, 0x00, 0xFF));
m_debugText.setPos(vec3(-20,32,0)); m_debugText.setPos(vec3(-20,32,0));
m_debugText.print(getType()); m_debugText.print(getType());
m_debugText.setPos(vec3(-20,20,0)); m_debugText.setPos(vec3(-20,20,0));
m_debugText.print("life=("+etk::to_string(getLifeRatio())); m_debugText.print("life=("+etk::to_string(getLifeRatio()));
*/
//m_debugText.print(std::string("Axe=(")+std::string(m_tmpAxe.x())+std::string(",")+etk::UString(m_tmpAxe.y())+etk::UString(",")+etk::UString(m_tmpAxe.z())+etk::UString(")")); //m_debugText.print(std::string("Axe=(")+std::string(m_tmpAxe.x())+std::string(",")+etk::UString(m_tmpAxe.y())+etk::UString(",")+etk::UString(m_tmpAxe.z())+etk::UString(")"));
/* /*
// TODO : Keep this it can be usefull to print something in direction of the camera ...
m_debugText.draw( etk::matTranslate(getPosition()) m_debugText.draw( etk::matTranslate(getPosition())
* etk::matRotate(vec3(0,0,1),_camera.getAngleZ()) * etk::matRotate(vec3(0,0,1),_camera.getAngleZ())
* etk::matRotate(vec3(1,0,0),(M_PI/2.0f-_camera.getAngleTeta())) * etk::matRotate(vec3(1,0,0),(M_PI/2.0f-_camera.getAngleTeta()))
@ -291,10 +265,6 @@ void ege::Element::drawDebug(ememory::SharedPtr<ewol::resource::Colored3DObject>
*/ */
} }
void ege::Element::drawNormalDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera) {
// nothing to do ...
}

89
ege/elements/Element.hpp
View File

@ -74,40 +74,6 @@ namespace ege {
inline uint32_t getUID() const { inline uint32_t getUID() const {
return m_uID; return m_uID;
}; };
/*
* *********************************
* Remove in progress .... [BEGIN]
* *********************************
*/
protected:
ememory::SharedPtr<ege::resource::Mesh> m_mesh; //!< Mesh of the Element (can be nullptr)
public:
/**
* @brief Select a mesh with a specific name.
* @param[in] _meshFileName filename of the Mesh.
* @note Automaticly load the shape if it is specify in the mesh file
* @return true if no error occured
*/
virtual bool loadMesh(const std::string& _meshFileName);
/**
* @brief set the the Mesh properties.
* @param[in] _mesh The mesh pointer. (nullptr to force the mesh remove ...)
* @note : this remove the shape and the mesh properties.
* @return true if no error occured
*/
virtual bool setMesh(ememory::SharedPtr<ege::resource::Mesh> _mesh);
/**
* @brief get a pointer on the Mesh file.
* @return the mesh pointer.
*/
inline ememory::SharedPtr<ege::resource::Mesh> getMesh() {
return m_mesh;
};
/*
* *********************************
* Remove in progress .... [END]
* *********************************
*/
protected: protected:
float m_life; //!< Current life of the object 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 element
@ -160,28 +126,9 @@ namespace ege {
inline void setGroup(int32_t _newGroup) { inline void setGroup(int32_t _newGroup) {
m_group=_newGroup; m_group=_newGroup;
}; };
public:
/**
* @brief Can be call tu opdate the list of the element displayed on the scren (example : no display of the hiden triangle)
* @param[in] the camera properties
* @ note by default nothing to do ...
*/
virtual void preCalculationDraw(const ege::Camera& _camera) { };
/**
* @brief draw the curent element (can have multiple display)
* @param[in] pass Id of the current pass : [0..?]
*/
virtual void draw(int32_t _pass=0) { };
/**
* @brief draw the current life of the element
*/
// TODO : Remove this ...
virtual void drawLife(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera);
protected: protected:
// For debug only ... // For debug only ...
ewol::compositing::Text m_debugText; //ewol::compositing::Text m_debugText; // ==> this is reall y a bad idea==> it is inneficient ...
public: public:
/** /**
* @brief Debug display of the current element * @brief Debug display of the current element
@ -189,45 +136,11 @@ namespace ege {
* @param[in] _camera Current camera for display * @param[in] _camera Current camera for display
*/ */
virtual void drawDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera); virtual void drawDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera);
/**
* @brief Debug display of the current element normal face
* @param[in,out] _draw Basic system to draw the debug shape and informations
* @param[in] _camera Current camera for display
*/
virtual void drawNormalDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera);
/**
* @brief get the theoric position. Sometimes, the element has move due to an explosion or something else, then its real position in not the one that woult it be at the end ...
* @return the theoric position
*/
virtual vec3 getPositionTheoric() {
return getPosition();
};
/**
* @brief get the current position of the element
* @return the 3D position.
*/
virtual const vec3& getPosition();
/**
* @brief set the current position of the element
* @param[in] _pos set the 3D position.
*/
virtual void setPosition(const vec3& _pos) {};
/** /**
* @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 ... * @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. * @param[in] _removedElement Pointer on the element removed.
*/ */
virtual void elementIsRemoved(ememory::SharedPtr<ege::Element> _removedElement) { }; virtual void elementIsRemoved(ememory::SharedPtr<ege::Element> _removedElement) { };
protected:
bool m_fixe; //!< is a fixed element == > used for placement of every elements
public:
/**
* @brief get the element if it is fixed or not. if the element is fixed this is for tower, and all thing does not really move
* @return true : The element is fixed.
*/
inline bool isFixed() {
return m_fixe;
};
protected: protected:
float m_radius; //!< Radius of the element (all element have a radius, if == 0 ==> then ghost ... float m_radius; //!< Radius of the element (all element have a radius, if == 0 ==> then ghost ...
public: public:

3
ege/elements/ElementBase.cpp
View File

@ -4,6 +4,9 @@
* @license MPL v2.0 (see license file) * @license MPL v2.0 (see license file)
*/ */
*******************************************
** IS REMOVED
*******************************************
#include <ege/elements/ElementBase.hpp> #include <ege/elements/ElementBase.hpp>
#include <ege/debug.hpp> #include <ege/debug.hpp>

7
ege/elements/ElementBase.hpp
View File

@ -3,6 +3,13 @@
* @copyright 2011, Edouard DUPIN, all right reserved * @copyright 2011, Edouard DUPIN, all right reserved
* @license MPL v2.0 (see license file) * @license MPL v2.0 (see license file)
*/ */
*******************************************
** IS REMOVED
*******************************************
#pragma once #pragma once
#include <ege/elements/Element.hpp> #include <ege/elements/Element.hpp>

42
ege/elements/ElementPhysic.cpp
View File

@ -4,6 +4,13 @@
* @license MPL v2.0 (see license file) * @license MPL v2.0 (see license file)
*/ */
*******************************************
** IS REMOVED
*******************************************
#include <etk/types.hpp> #include <etk/types.hpp>
#include <ege/debug.hpp> #include <ege/debug.hpp>
#include <ege/elements/ElementPhysic.hpp> #include <ege/elements/ElementPhysic.hpp>
@ -318,41 +325,6 @@ void ege::ElementPhysic::drawShape(/*const btCollisionShape* _shape,*/
#endif #endif
} }
void ege::ElementPhysic::drawDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera) {
ege::Element::drawDebug(_draw, _camera);
/*
btScalar mmm[16];
if (m_body == nullptr) {
return;
}
btDefaultMotionState* myMotionState = (btDefaultMotionState*)m_body->getMotionState();
myMotionState->m_graphicsWorldTrans.getOpenGLMatrix(mmm);
mat4 transformationMatrix(mmm);
transformationMatrix.transpose();
// note : set the vertice here to prevent multiple allocations...
std::vector<vec3> EwolVertices;
drawShape(m_shape, _draw, transformationMatrix, EwolVertices);
*/
}
void ege::ElementPhysic::drawNormalDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera) {
/*
if( m_body != nullptr
&& m_mesh != nullptr
&& m_body->getMotionState() ) {
//EGE_INFO("element pos = " << getPosition());
btScalar mmm[16];
btDefaultMotionState* myMotionState = (btDefaultMotionState*)m_body->getMotionState();
myMotionState->m_graphicsWorldTrans.getOpenGLMatrix(mmm);
mat4 transformationMatrix(mmm);
transformationMatrix.transpose();
m_mesh->drawNormal(transformationMatrix, _draw);
}
*/
}
void ege::ElementPhysic::draw(int32_t _pass) { void ege::ElementPhysic::draw(int32_t _pass) {
if (m_elementInPhysicsSystem == false) { if (m_elementInPhysicsSystem == false) {

7
ege/elements/ElementPhysic.hpp
View File

@ -5,6 +5,13 @@
*/ */
#pragma once #pragma once
*******************************************
** IS REMOVED
*******************************************
#include <etk/types.hpp> #include <etk/types.hpp>
#include <etk/math/Vector3D.hpp> #include <etk/math/Vector3D.hpp>
#include <etk/math/Matrix4x4.hpp> #include <etk/math/Matrix4x4.hpp>

4
ege/particule/Engine.cpp
View File

@ -7,7 +7,7 @@
#include <ege/debug.hpp> #include <ege/debug.hpp>
#include <ege/particule/Engine.hpp> #include <ege/particule/Engine.hpp>
#include <ege/Environement.hpp> #include <ege/Environement.hpp>
#include <ege/particule/Particule.hpp> #include <ege/particule/Component.hpp>
ege::particule::Engine::Engine(ege::Environement* _env) : ege::particule::Engine::Engine(ege::Environement* _env) :
ege::Engine(_env) { ege::Engine(_env) {
@ -88,7 +88,7 @@ void ege::particule::Engine::update(const echrono::Duration& _delta) {
if (deltaTime>(1.0f/60.0f)) { if (deltaTime>(1.0f/60.0f)) {
deltaTime = (1.0f/60.0f); deltaTime = (1.0f/60.0f);
} }
EGE_WARNING("Update the Particule engine ... " << deltaTime); EGE_DEBUG("Update the Particule engine ... " << deltaTime);
for (size_t iii=0; iii<m_particuleList.size(); ++iii) { for (size_t iii=0; iii<m_particuleList.size(); ++iii) {
if (m_particuleList[iii] == nullptr) { if (m_particuleList[iii] == nullptr) {
continue; continue;

237
ege/physics/Component.cpp
View File

@ -25,6 +25,7 @@ ege::physics::Component::Component(ememory::SharedPtr<ege::Environement> _env) {
rp3d::Vector3 initPosition(0.0f, 0.0f, 0.0f); rp3d::Vector3 initPosition(0.0f, 0.0f, 0.0f);
rp3d::Quaternion initOrientation = rp3d::Quaternion::identity(); rp3d::Quaternion initOrientation = rp3d::Quaternion::identity();
rp3d::Transform transform(initPosition, initOrientation); rp3d::Transform transform(initPosition, initOrientation);
m_lastTransformEmit = etk::Transform3D(vec3(0,0,0), etk::Quaternion::identity());
m_rigidBody = m_engine->getDynamicWorld()->createRigidBody(transform); m_rigidBody = m_engine->getDynamicWorld()->createRigidBody(transform);
} }
@ -40,6 +41,7 @@ ege::physics::Component::Component(ememory::SharedPtr<ege::Environement> _env, c
rp3d::Transform transform(initPosition, initOrientation); rp3d::Transform transform(initPosition, initOrientation);
// Create a rigid body in the world // Create a rigid body in the world
m_rigidBody = m_engine->getDynamicWorld()->createRigidBody(transform); m_rigidBody = m_engine->getDynamicWorld()->createRigidBody(transform);
m_lastTransformEmit = _transform;
} }
void ege::physics::Component::setType(enum ege::physics::Component::type _type) { void ege::physics::Component::setType(enum ege::physics::Component::type _type) {
@ -79,7 +81,7 @@ void ege::physics::Component::generate() {
} }
switch (it->getType()) { switch (it->getType()) {
case ege::PhysicsShape::box : { case ege::PhysicsShape::box : {
EGE_ERROR(" Box"); EGE_DEBUG(" Box");
const ege::PhysicsBox* tmpElement = it->toBox(); const ege::PhysicsBox* tmpElement = it->toBox();
if (tmpElement == nullptr) { if (tmpElement == nullptr) {
EGE_ERROR(" Box ==> can not cast in BOX"); EGE_ERROR(" Box ==> can not cast in BOX");
@ -92,15 +94,15 @@ void ege::physics::Component::generate() {
// Create the box shape // Create the box shape
rp3d::BoxShape* shape = new rp3d::BoxShape(halfExtents); rp3d::BoxShape* shape = new rp3d::BoxShape(halfExtents);
m_listShape.push_back(shape); m_listShape.push_back(shape);
rp3d::Vector3 position(tmpElement->getOrigin().x(), rp3d::Vector3 position(it->getOrigin().x(),
tmpElement->getOrigin().y(), it->getOrigin().y(),
tmpElement->getOrigin().z()); it->getOrigin().z());
rp3d::Quaternion orientation(tmpElement->getQuaternion().x(), rp3d::Quaternion orientation(it->getQuaternion().x(),
tmpElement->getQuaternion().y(), it->getQuaternion().y(),
tmpElement->getQuaternion().z(), it->getQuaternion().z(),
tmpElement->getQuaternion().w()); it->getQuaternion().w());
rp3d::Transform transform(position, orientation); rp3d::Transform transform(position, orientation);
rp3d::ProxyShape* proxyShape = m_rigidBody->addCollisionShape(shape, transform, 4.0f /* mass */); rp3d::ProxyShape* proxyShape = m_rigidBody->addCollisionShape(shape, transform, it->getMass());
m_listProxyShape.push_back(proxyShape); m_listProxyShape.push_back(proxyShape);
break; break;
} }
@ -113,15 +115,15 @@ void ege::physics::Component::generate() {
} }
// Create the box shape // Create the box shape
rp3d::CylinderShape* shape = new rp3d::CylinderShape(tmpElement->getSize().x(), tmpElement->getSize().y()); rp3d::CylinderShape* shape = new rp3d::CylinderShape(tmpElement->getSize().x(), tmpElement->getSize().y());
rp3d::Vector3 position(tmpElement->getOrigin().x(), rp3d::Vector3 position(it->getOrigin().x(),
tmpElement->getOrigin().y(), it->getOrigin().y(),
tmpElement->getOrigin().z()); it->getOrigin().z());
rp3d::Quaternion orientation(tmpElement->getQuaternion().x(), rp3d::Quaternion orientation(it->getQuaternion().x(),
tmpElement->getQuaternion().y(), it->getQuaternion().y(),
tmpElement->getQuaternion().z(), it->getQuaternion().z(),
tmpElement->getQuaternion().w()); it->getQuaternion().w());
rp3d::Transform transform(position, orientation); rp3d::Transform transform(position, orientation);
rp3d::ProxyShape* proxyShape = m_rigidBody->addCollisionShape(shape, transform, 4.0f /* mass */); rp3d::ProxyShape* proxyShape = m_rigidBody->addCollisionShape(shape, transform, it->getMass());
m_listProxyShape.push_back(proxyShape); m_listProxyShape.push_back(proxyShape);
break; break;
} }
@ -218,6 +220,46 @@ void ege::physics::Component::generate() {
} }
void ege::physics::Component::emitAll() {
// emit onbly of new ...
etk::Transform3D transform = getTransform();
if (m_lastTransformEmit != transform) {
m_lastTransformEmit = transform;
signalPosition.emit(transform);
}
}
void ege::physics::Component::setTransform(const etk::Transform3D& _transform) {
if (m_rigidBody == nullptr) {
return;
}
rp3d::Vector3 position(_transform.getPosition().x(),
_transform.getPosition().y(),
_transform.getPosition().z());
rp3d::Quaternion orientation(_transform.getOrientation().x(),
_transform.getOrientation().y(),
_transform.getOrientation().z(),
_transform.getOrientation().w());
rp3d::Transform transform(position, orientation);
m_rigidBody->setTransform(transform);
}
etk::Transform3D ege::physics::Component::getTransform() const {
if (m_rigidBody == nullptr) {
return etk::Transform3D::identity();
}
rp3d::Transform transform = m_rigidBody->getTransform();
vec3 position(transform.getPosition().x,
transform.getPosition().y,
transform.getPosition().z);
etk::Quaternion orientation(transform.getOrientation().x,
transform.getOrientation().y,
transform.getOrientation().z,
transform.getOrientation().w);
return etk::Transform3D(position, orientation);
}
vec3 ege::physics::Component::getLinearVelocity() const { vec3 ege::physics::Component::getLinearVelocity() const {
if (m_rigidBody == nullptr) { if (m_rigidBody == nullptr) {
return vec3(0,0,0); return vec3(0,0,0);
@ -269,33 +311,138 @@ void ege::physics::Component::addShape(const ememory::SharedPtr<ege::PhysicsShap
m_shape.push_back(_shape); m_shape.push_back(_shape);
} }
void ege::physics::Component::setTransform(const etk::Transform3D& _transform) {
if (m_rigidBody == nullptr) {
return;
}
rp3d::Vector3 position(_transform.getPosition().x(),
_transform.getPosition().y(),
_transform.getPosition().z());
rp3d::Quaternion orientation(_transform.getOrientation().x(),
_transform.getOrientation().y(),
_transform.getOrientation().z(),
_transform.getOrientation().w());
rp3d::Transform transform(position, orientation);
m_rigidBody->setTransform(transform);
}
etk::Transform3D ege::physics::Component::getTransform() const { void ege::physics::Component::drawShape(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera) {
if (m_rigidBody == nullptr) { etk::Transform3D transform = getTransform();
return etk::Transform3D::identity(); float mmm[16];
// Get the OpenGL matrix array of the transform
transform.getOpenGLMatrix(mmm);
mat4 transformationMatrix(mmm);
transformationMatrix.transpose();
etk::Color<float> tmpColor(1.0, 0.0, 0.0, 0.3);
for (auto &it: m_shape) {
if (it == nullptr) {
continue;
}
switch (it->getType()) {
case ege::PhysicsShape::box: {
EGE_DEBUG(" Box");
const ege::PhysicsBox* tmpElement = it->toBox();
if (tmpElement == nullptr) {
EGE_ERROR(" Box ==> can not cast in BOX");
continue;
}
etk::Transform3D transformLocal(it->getOrigin(), it->getOrientation());
transformLocal.getOpenGLMatrix(mmm);
mat4 transformationMatrixLocal(mmm);
transformationMatrixLocal.transpose();
transformationMatrixLocal = transformationMatrix * transformationMatrixLocal;
_draw->drawSquare(tmpElement->getSize(), transformationMatrixLocal, tmpColor);
break;
}
case ege::PhysicsShape::cylinder : {
EGE_DEBUG(" Cylinder");
const ege::PhysicsCylinder* tmpElement = it->toCylinder();
if (tmpElement == nullptr) {
EGE_ERROR(" Cylinder ==> can not cast in Cylinder");
continue;
}
etk::Transform3D transformLocal(it->getOrigin(), it->getOrientation());
transformLocal.getOpenGLMatrix(mmm);
mat4 transformationMatrixLocal(mmm);
transformationMatrixLocal.transpose();
transformationMatrixLocal = transformationMatrix * transformationMatrixLocal;
//_draw->drawSphere(radius, 10, 10, _transformationMatrix, tmpColor);
break;
}
case ege::PhysicsShape::capsule : {
EGE_DEBUG(" Capsule");
const ege::PhysicsCapsule* tmpElement = it->toCapsule();
if (tmpElement == nullptr) {
EGE_ERROR(" Capsule ==> can not cast in Capsule");
continue;
}
/*
btCollisionShape* tmpShape = new btCapsuleShape(tmpElement->getRadius(), tmpElement->getHeight());
if (tmpShape != nullptr) {
if (outputShape == nullptr) {
return tmpShape;
} else {
vec4 qqq = tmpElement->getQuaternion();
const btTransform localTransform(btQuaternion(qqq.x(),qqq.y(),qqq.z(),qqq.w()), tmpElement->getOrigin());
outputShape->addChildShape(localTransform, tmpShape);
}
}
*/
break;
}
case ege::PhysicsShape::cone : {
EGE_DEBUG(" Cone");
const ege::PhysicsCone* tmpElement = it->toCone();
if (tmpElement == nullptr) {
EGE_ERROR(" Cone ==> can not cast in Cone");
continue;
}
/*
btCollisionShape* tmpShape = new btConeShape(tmpElement->getRadius(), tmpElement->getHeight());
if (tmpShape != nullptr) {
if (outputShape == nullptr) {
return tmpShape;
} else {
vec4 qqq = tmpElement->getQuaternion();
const btTransform localTransform(btQuaternion(qqq.x(),qqq.y(),qqq.z(),qqq.w()), tmpElement->getOrigin());
outputShape->addChildShape(localTransform, tmpShape);
}
}
*/
break;
}
case ege::PhysicsShape::sphere : {
EGE_DEBUG(" Sphere");
const ege::PhysicsSphere* tmpElement = it->toSphere();
if (tmpElement == nullptr) {
EGE_ERROR(" Sphere ==> can not cast in Sphere");
continue;
}
/*
btCollisionShape* tmpShape = new btSphereShape(tmpElement->getRadius());
if (tmpShape != nullptr) {
if (outputShape == nullptr) {
return tmpShape;
} else {
vec4 qqq = tmpElement->getQuaternion();
const btTransform localTransform(btQuaternion(qqq.x(),qqq.y(),qqq.z(),qqq.w()), tmpElement->getOrigin());
outputShape->addChildShape(localTransform, tmpShape);
}
}
*/
break;
}
case ege::PhysicsShape::convexHull : {
EGE_DEBUG(" convexHull");
const ege::PhysicsConvexHull* tmpElement = it->toConvexHull();
if (tmpElement == nullptr) {
EGE_ERROR(" convexHull ==> can not cast in convexHull");
continue;
}
/*
btConvexHullShape* tmpShape = new btConvexHullShape(&(tmpElement->getPointList()[0].x()), tmpElement->getPointList().size());
if (tmpShape != nullptr) {
if (outputShape == nullptr) {
return tmpShape;
} else {
vec4 qqq = tmpElement->getQuaternion();
const btTransform localTransform(btQuaternion(qqq.x(),qqq.y(),qqq.z(),qqq.w()), tmpElement->getOrigin());
outputShape->addChildShape(localTransform, tmpShape);
}
}
*/
break;
}
default :
EGE_DEBUG(" ???");
// TODO : UNKNOW type ...
break;
}
} }
rp3d::Transform transform = m_rigidBody->getTransform(); }
vec3 position(transform.getPosition().x,
transform.getPosition().y,
transform.getPosition().z);
etk::Quaternion orientation(transform.getOrientation().x,
transform.getOrientation().y,
transform.getOrientation().z,
transform.getOrientation().w);
return etk::Transform3D(position, orientation);
}

7
ege/physics/Component.hpp
View File

@ -12,6 +12,7 @@
#include <esignal/Signal.hpp> #include <esignal/Signal.hpp>
#include <ephysics/reactphysics3d.h> #include <ephysics/reactphysics3d.h>
#include <ege/resource/Mesh.hpp> #include <ege/resource/Mesh.hpp>
#include <ege/camera/Camera.hpp>
namespace ege { namespace ege {
class Environement; class Environement;
@ -20,6 +21,8 @@ namespace ege {
class Component : public ege::Component { class Component : public ege::Component {
public: public:
esignal::Signal<etk::Transform3D> signalPosition; esignal::Signal<etk::Transform3D> signalPosition;
protected:
etk::Transform3D m_lastTransformEmit;
protected: protected:
ememory::SharedPtr<ege::physics::Engine> m_engine; ememory::SharedPtr<ege::physics::Engine> m_engine;
rp3d::RigidBody* m_rigidBody; rp3d::RigidBody* m_rigidBody;
@ -82,6 +85,10 @@ namespace ege {
void setShape(const std::vector<ememory::SharedPtr<ege::PhysicsShape>>& _prop); void setShape(const std::vector<ememory::SharedPtr<ege::PhysicsShape>>& _prop);
void addShape(const ememory::SharedPtr<ege::PhysicsShape>& _shape); void addShape(const ememory::SharedPtr<ege::PhysicsShape>& _shape);
void generate(); void generate();
void drawShape(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw, ememory::SharedPtr<ege::Camera> _camera);
private:
void emitAll();
friend class ege::physics::Engine;
}; };
} }
} }

53
ege/physics/Engine.cpp
View File

@ -12,22 +12,36 @@
#include <gale/renderer/openGL/openGL.hpp> #include <gale/renderer/openGL/openGL.hpp>
#include <etk/math/Matrix4x4.hpp> #include <etk/math/Matrix4x4.hpp>
#include <ege/elements/ElementPhysic.hpp>
const std::string& ege::physics::Engine::getType() const { const std::string& ege::physics::Engine::getType() const {
static std::string tmp("physics"); static std::string tmp("physics");
return tmp; return tmp;
} }
void ege::physics::Engine::componentRemove(const ememory::SharedPtr<ege::Component>& _ref) { void ege::physics::Engine::componentRemove(const ememory::SharedPtr<ege::Component>& _ref) {
ememory::SharedPtr<ege::physics::Component> ref = ememory::dynamicPointerCast<ege::physics::Component>(_ref);
for (auto it=m_component.begin();
it != m_component.end();
++it) {
if (*it == ref) {
it->reset();
return;
}
}
} }
void ege::physics::Engine::componentAdd(const ememory::SharedPtr<ege::Component>& _ref) { void ege::physics::Engine::componentAdd(const ememory::SharedPtr<ege::Component>& _ref) {
ememory::SharedPtr<ege::physics::Component> ref = ememory::dynamicPointerCast<ege::physics::Component>(_ref);
for (auto it=m_component.begin();
it != m_component.end();
++it) {
if (*it == nullptr) {
*it = ref;
return;
}
}
m_component.push_back(ref);
} }
// unique callback function : // unique callback function :
/* /*
extern ContactProcessedCallback gContactProcessedCallback; extern ContactProcessedCallback gContactProcessedCallback;
@ -54,8 +68,11 @@ static bool handleContactsProcess(btManifoldPoint& _point, btCollisionObject* _b
ege::physics::Engine::Engine(ege::Environement* _env) : ege::physics::Engine::Engine(ege::Environement* _env) :
ege::Engine(_env), ege::Engine(_env),
propertyDebugAABB(this, "debug-AABB", false, "display the global AABB box of every shape"),
propertyDebugShape(this, "debug-shape", false, "display the physic shape"),
m_dynamicsWorld(nullptr), m_dynamicsWorld(nullptr),
m_accumulator(0.0f) { m_accumulator(0.0f) {
m_debugDrawProperty = ewol::resource::Colored3DObject::create();
// Start engine with no gravity // Start engine with no gravity
//rp3d::Vector3 gravity(0.0, -9.81, 0.0); // generic earth gravity //rp3d::Vector3 gravity(0.0, -9.81, 0.0); // generic earth gravity
rp3d::Vector3 gravity(0.0f, 0.0f, 0.0f); rp3d::Vector3 gravity(0.0f, 0.0f, 0.0f);
@ -92,13 +109,34 @@ void ege::physics::Engine::update(const echrono::Duration& _delta) {
while (m_accumulator >= timeStep) { while (m_accumulator >= timeStep) {
if (m_dynamicsWorld != nullptr) { if (m_dynamicsWorld != nullptr) {
// Update the Dynamics world with a constant time step // Update the Dynamics world with a constant time step
EGE_WARNING("Update the Physic engine ... " << timeStep); EGE_DEBUG("Update the Physic engine ... " << timeStep);
m_dynamicsWorld->update(timeStep); m_dynamicsWorld->update(timeStep);
} }
// Decrease the accumulated time // Decrease the accumulated time
m_accumulator -= timeStep; m_accumulator -= timeStep;
} }
for (auto &it: m_component) {
// check nullptr pointer
if (it == nullptr) {
// no pointer null are set in the output list ...
continue;
}
it->emitAll();
}
} }
void ege::physics::Engine::renderDebug(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera) {
if (propertyDebugShape.get() == true) {
for (auto &it : m_component) {
if (it == nullptr) {
continue;
}
it->drawShape(m_debugDrawProperty, _camera);
}
}
}
#if 0 #if 0
std::vector<ege::physics::Engine::collisionPoints> ege::physics::Engine::getListOfCollision() { std::vector<ege::physics::Engine::collisionPoints> ege::physics::Engine::getListOfCollision() {
std::vector<collisionPoints> out; std::vector<collisionPoints> out;
@ -132,4 +170,5 @@ std::vector<ege::physics::Engine::collisionPoints> ege::physics::Engine::getList
return out; return out;
} }
#endif #endif

11
ege/physics/Engine.hpp
View File

@ -23,11 +23,16 @@ namespace ege {
#include <gale/resource/Manager.hpp> #include <gale/resource/Manager.hpp>
#include <gale/Dimension.hpp> #include <gale/Dimension.hpp>
#include <ephysics/reactphysics3d.h> #include <ephysics/reactphysics3d.h>
#include <ege/physics/Component.hpp>
#include <eproperty/Value.hpp>
namespace ege { namespace ege {
namespace physics { namespace physics {
class Engine : public ege::Engine { class Engine : public ege::Engine {
public:
eproperty::Value<bool> propertyDebugAABB;
eproperty::Value<bool> propertyDebugShape;
private: private:
rp3d::DynamicsWorld* m_dynamicsWorld; rp3d::DynamicsWorld* m_dynamicsWorld;
float m_accumulator; // limit call of the step rendering float m_accumulator; // limit call of the step rendering
@ -74,12 +79,16 @@ namespace ege {
rp3d::DynamicsWorld* getDynamicWorld() { rp3d::DynamicsWorld* getDynamicWorld() {
return m_dynamicsWorld; return m_dynamicsWorld;
} }
protected:
std::vector<ememory::SharedPtr<ege::physics::Component>> m_component;
//TODO : set it not in ewol ...
ememory::SharedPtr<ewol::resource::Colored3DObject> m_debugDrawProperty;
public: public:
const std::string& getType() const override; const std::string& getType() const override;
void componentRemove(const ememory::SharedPtr<ege::Component>& _ref) override; void componentRemove(const ememory::SharedPtr<ege::Component>& _ref) override;
void componentAdd(const ememory::SharedPtr<ege::Component>& _ref) override; void componentAdd(const ememory::SharedPtr<ege::Component>& _ref) override;
void update(const echrono::Duration& _delta) override; void update(const echrono::Duration& _delta) override;
//void render(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera) override; void renderDebug(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera) override;
}; };
} }
} }

9
ege/physicsShape/PhysicsShape.cpp
View File

@ -41,15 +41,20 @@ ememory::SharedPtr<ege::PhysicsShape> ege::PhysicsShape::create(const std::strin
bool ege::PhysicsShape::parse(const char* _line) { bool ege::PhysicsShape::parse(const char* _line) {
if(strncmp(_line, "origin:", 7) == 0) { if(strncmp(_line, "origin:", 7) == 0) {
sscanf(&_line[9], "%f %f %f", &m_origin.m_floats[0], &m_origin.m_floats[1], &m_origin.m_floats[2] ); 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); EGE_VERBOSE(" Origin=" << m_origin);
return true; return true;
} }
if(strncmp(_line, "rotate:", 7) == 0) { if(strncmp(_line, "rotate:", 7) == 0) {
sscanf(&_line[9], "%f %f %f %f", &m_quaternion.m_floats[0], &m_quaternion.m_floats[1], &m_quaternion.m_floats[2], &m_quaternion.m_floats[3] ); sscanf(&_line[7], "%f %f %f %f", &m_quaternion.m_floats[0], &m_quaternion.m_floats[1], &m_quaternion.m_floats[2], &m_quaternion.m_floats[3] );
EGE_VERBOSE(" rotate=" << m_quaternion); EGE_VERBOSE(" rotate=" << m_quaternion);
return true; return true;
} }
if(strncmp(_line, "mass:", 5) == 0) {
sscanf(&_line[5], "%f", &m_mass );
EGE_VERBOSE(" mass=" << m_mass);
return true;
}
return false; return false;
} }

26
ege/physicsShape/PhysicsShape.hpp
View File

@ -8,6 +8,7 @@
#include <etk/types.hpp> #include <etk/types.hpp>
#include <etk/math/Vector4D.hpp> #include <etk/math/Vector4D.hpp>
#include <etk/math/Vector3D.hpp> #include <etk/math/Vector3D.hpp>
#include <etk/math/Quaternion.hpp>
#include <ememory/memory.hpp> #include <ememory/memory.hpp>
@ -35,34 +36,47 @@ namespace ege {
public: public:
PhysicsShape() : PhysicsShape() :
m_quaternion(1,0,0,0), m_quaternion(1,0,0,0),
m_origin(0,0,0) { m_origin(0,0,0),
m_mass(1) { // by default set mass at 1g
}; }
virtual ~PhysicsShape() { virtual ~PhysicsShape() {
}; }
public: public:
virtual enum ege::PhysicsShape::type getType() const { virtual enum ege::PhysicsShape::type getType() const {
return ege::PhysicsShape::unknow; return ege::PhysicsShape::unknow;
}; }
public: public:
virtual bool parse(const char* _line); virtual bool parse(const char* _line);
virtual void display() { virtual void display() {
}; }
private: private:
vec4 m_quaternion; vec4 m_quaternion;
public: public:
const vec4& getQuaternion() const { const vec4& getQuaternion() const {
return m_quaternion; return m_quaternion;
}; }
etk::Quaternion getOrientation() const {
return etk::Quaternion(m_quaternion.x(), m_quaternion.y(), m_quaternion.z(), m_quaternion.w());
}
private: private:
vec3 m_origin; vec3 m_origin;
public: public:
const vec3& getOrigin() const { const vec3& getOrigin() const {
return m_origin; 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: public:
bool isBox() { bool isBox() {
return getType() == ege::PhysicsShape::box; return getType() == ege::PhysicsShape::box;

17
ege/render/Component.cpp
View File

@ -76,13 +76,22 @@ void ege::render::Component::draw(int32_t _pass) {
float mmm[16]; float mmm[16];
// Get the OpenGL matrix array of the transform // Get the OpenGL matrix array of the transform
m_transform.getOpenGLMatrix(mmm); m_transform.getOpenGLMatrix(mmm);
//EGE_INFO(" mat = " << mat4(mmm));
mat4 transformationMatrix(mmm); mat4 transformationMatrix(mmm);
//mat4 transformationMatrix = mat4(mmm) * etk::matScale(vec3(20,20,20));
transformationMatrix.transpose(); transformationMatrix.transpose();
// TODO: check this : transformationMatrix.transpose(); // TODO: check this : transformationMatrix.transpose();
m_mesh->draw(transformationMatrix); m_mesh->draw(transformationMatrix);
} }
} }
} }
void ege::render::Component::drawNormalDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw) {
if(m_mesh != nullptr) {
float mmm[16];
// Get the OpenGL matrix array of the transform
m_transform.getOpenGLMatrix(mmm);
mat4 transformationMatrix(mmm);
transformationMatrix.transpose();
m_mesh->drawNormal(transformationMatrix, _draw);
}
}

6
ege/render/Component.hpp
View File

@ -64,7 +64,11 @@ namespace ege {
* @param[in] pass Id of the current pass : [0..?] * @param[in] pass Id of the current pass : [0..?]
*/ */
virtual void draw(int32_t _pass=0); virtual void draw(int32_t _pass=0);
/**
* @brief Debug display of the current element normal face
* @param[in,out] _draw Basic system to draw the debug shape and informations
*/
void drawNormalDebug(ememory::SharedPtr<ewol::resource::Colored3DObject> _draw);
public: public:
const std::string& getType() const override; const std::string& getType() const override;
void addFriendComponent(const ememory::SharedPtr<ege::Component>& _component) override; void addFriendComponent(const ememory::SharedPtr<ege::Component>& _component) override;

22
ege/render/Engine.cpp
View File

@ -6,8 +6,9 @@
#include <ege/render/Engine.hpp> #include <ege/render/Engine.hpp>
ege::render::Engine::Engine(ege::Environement* _env) : ege::render::Engine::Engine(ege::Environement* _env) :
ege::Engine(_env) { ege::Engine(_env),
propertyDebugNormal(this, "debug-normal", false, "display the normal debug information") {
m_debugDrawProperty = ewol::resource::Colored3DObject::create();
} }
const std::string& ege::render::Engine::getType() const { const std::string& ege::render::Engine::getType() const {
@ -17,7 +18,7 @@ const std::string& ege::render::Engine::getType() const {
void ege::render::Engine::componentRemove(const ememory::SharedPtr<ege::Component>& _ref) { void ege::render::Engine::componentRemove(const ememory::SharedPtr<ege::Component>& _ref) {
ememory::SharedPtr<ege::render::Component> ref = ememory::dynamicPointerCast<ege::render::Component>(_ref); ememory::SharedPtr<ege::render::Component> ref = ememory::dynamicPointerCast<ege::render::Component>(_ref);
for (auto it=m_component.begin(); for (auto it = m_component.begin();
it != m_component.end(); it != m_component.end();
++it) { ++it) {
if (*it == ref) { if (*it == ref) {
@ -95,13 +96,14 @@ void ege::render::Engine::getOrderedElementForDisplay(std::vector<ege::render::E
#define NUMBER_OF_SUB_PASS (5) #define NUMBER_OF_SUB_PASS (5)
void ege::render::Engine::render(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera) { void ege::render::Engine::render(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera) {
/*
for (auto &it : m_component) { for (auto &it : m_component) {
if (it == nullptr) { if (it == nullptr) {
continue; continue;
} }
} }
*/
//EGE_DEBUG("Draw (start)"); //EGE_DEBUG("Draw (start)");
mat4 tmpMatrix; mat4 tmpMatrix;
getOrderedElementForDisplay(m_displayElementOrdered, _camera->getEye(), _camera->getViewVector()); getOrderedElementForDisplay(m_displayElementOrdered, _camera->getEye(), _camera->getViewVector());
@ -118,6 +120,13 @@ void ege::render::Engine::render(const echrono::Duration& _delta, const ememory:
it.element->draw(pass); it.element->draw(pass);
} }
} }
}
void ege::render::Engine::renderDebug(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera) {
//EGE_DEBUG("Draw (start)");
mat4 tmpMatrix;
getOrderedElementForDisplay(m_displayElementOrdered, _camera->getEye(), _camera->getViewVector());
EGE_VERBOSE("DRAW : " << m_displayElementOrdered.size() << "/" << m_component.size() << " elements");
#if 0 #if 0
if (propertyDebugPhysic.get() == true) { if (propertyDebugPhysic.get() == true) {
// Draw debug ... (Object) // Draw debug ... (Object)
@ -134,13 +143,14 @@ void ege::render::Engine::render(const echrono::Duration& _delta, const ememory:
} }
*/ */
} }
#endif
if (propertyDebugNormal.get() == true) { if (propertyDebugNormal.get() == true) {
// Draw debug ... (Object) // Draw debug ... (Object)
for (int32_t iii=m_displayElementOrdered.size()-1; iii >= 0; iii--) { for (int32_t iii=m_displayElementOrdered.size()-1; iii >= 0; iii--) {
m_displayElementOrdered[iii].element->drawNormalDebug(m_debugDrawProperty, camera); m_displayElementOrdered[iii].element->drawNormalDebug(m_debugDrawProperty);
} }
} }
#if 0
if (propertyDebugApplication.get() == true) { if (propertyDebugApplication.get() == true) {
// Draw debug ... (User) // Draw debug ... (User)
signalDisplayDebug.emit(m_debugDrawProperty); signalDisplayDebug.emit(m_debugDrawProperty);

10
ege/render/Engine.hpp
View File

@ -12,6 +12,8 @@
#include <ege/debug.hpp> #include <ege/debug.hpp>
#include <ege/render/Component.hpp> #include <ege/render/Component.hpp>
#include <ege/Engine.hpp> #include <ege/Engine.hpp>
#include <eproperty/Value.hpp>
#include <ewol/widget/Widget.hpp>
namespace ege { namespace ege {
@ -20,6 +22,7 @@ namespace ege {
public: public:
Engine(ege::Environement* _env); Engine(ege::Environement* _env);
~Engine() {} ~Engine() {}
eproperty::Value<bool> propertyDebugNormal;
protected: protected:
std::vector<ememory::SharedPtr<ege::render::Component>> m_component; std::vector<ememory::SharedPtr<ege::render::Component>> m_component;
class ResultNearestElement { class ResultNearestElement {
@ -28,14 +31,17 @@ namespace ege {
float dist; float dist;
}; };
std::vector<ege::render::Engine::ResultNearestElement> m_displayElementOrdered; std::vector<ege::render::Engine::ResultNearestElement> m_displayElementOrdered;
//TODO : set it not in ewol ...
ememory::SharedPtr<ewol::resource::Colored3DObject> m_debugDrawProperty;
public: public:
const std::string& getType() const override; const std::string& getType() const override;
void componentRemove(const ememory::SharedPtr<ege::Component>& _ref) override; void componentRemove(const ememory::SharedPtr<ege::Component>& _ref) override;
void componentAdd(const ememory::SharedPtr<ege::Component>& _ref) override; void componentAdd(const ememory::SharedPtr<ege::Component>& _ref) override;
void render(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera) override; void render(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera) override;
void renderDebug(const echrono::Duration& _delta, const ememory::SharedPtr<ege::Camera>& _camera) override;
void getOrderedElementForDisplay(std::vector<ege::render::Engine::ResultNearestElement>& _resultList, void getOrderedElementForDisplay(std::vector<ege::render::Engine::ResultNearestElement>& _resultList,
const vec3& _position, const vec3& _position,
const vec3& _direction); const vec3& _direction);
}; };
} }
} }

56
ege/resource/Mesh.cpp
View File

@ -14,7 +14,7 @@
#include <ege/resource/tools/icoSphere.hpp> #include <ege/resource/tools/icoSphere.hpp>
ege::resource::Mesh::Mesh() : ege::resource::Mesh::Mesh() :
m_normalMode(normalModeNone), m_normalMode(ege::resource::Mesh::normalMode::none),
m_checkNormal(false), m_checkNormal(false),
m_GLPosition(-1), m_GLPosition(-1),
m_GLMatrix(-1), m_GLMatrix(-1),
@ -138,7 +138,7 @@ void ege::resource::Mesh::draw(mat4& _positionMatrix,
m_GLprogram->sendAttributePointer(m_GLtexture, m_verticesVBO, MESH_VBO_TEXTURE); m_GLprogram->sendAttributePointer(m_GLtexture, m_verticesVBO, MESH_VBO_TEXTURE);
} }
// position : // position :
if (m_normalMode != normalModeNone) { if (m_normalMode != ege::resource::Mesh::normalMode::none) {
m_GLprogram->sendAttributePointer(m_GLNormal, m_verticesVBO, MESH_VBO_VERTICES_NORMAL); m_GLprogram->sendAttributePointer(m_GLNormal, m_verticesVBO, MESH_VBO_VERTICES_NORMAL);
#if DEBUG #if DEBUG
// TODO : ... // TODO : ...
@ -184,7 +184,7 @@ void ege::resource::Mesh::draw(mat4& _positionMatrix,
std::vector<ege::Face>& tmppFaces = m_listFaces.getValue(kkk).m_faces; std::vector<ege::Face>& tmppFaces = m_listFaces.getValue(kkk).m_faces;
//std::vector<uint32_t>& tmppIndex = m_listFaces.getValue(kkk).m_index; //std::vector<uint32_t>& tmppIndex = m_listFaces.getValue(kkk).m_index;
switch(m_normalMode) { switch(m_normalMode) {
case normalModeFace: case ege::resource::Mesh::normalMode::face:
for(size_t iii=0; iii<tmppFaces.size() ; ++iii) { for(size_t iii=0; iii<tmppFaces.size() ; ++iii) {
if((mattttt * m_listFacesNormal[tmppFaces[iii].m_normal[0]]).dot(cameraNormal) >= 0.0f) { if((mattttt * m_listFacesNormal[tmppFaces[iii].m_normal[0]]).dot(cameraNormal) >= 0.0f) {
tmpIndexResult.push_back(iii*3); tmpIndexResult.push_back(iii*3);
@ -193,7 +193,7 @@ void ege::resource::Mesh::draw(mat4& _positionMatrix,
} }
} }
break; break;
case normalModeVertex: case ege::resource::Mesh::normalMode::vertex:
for(size_t iii=0; iii<tmppFaces.size() ; ++iii) { for(size_t iii=0; iii<tmppFaces.size() ; ++iii) {
if( ((mattttt * m_listVertexNormal[tmppFaces[iii].m_normal[0]]).dot(cameraNormal) >= -0.2f) if( ((mattttt * m_listVertexNormal[tmppFaces[iii].m_normal[0]]).dot(cameraNormal) >= -0.2f)
|| ((mattttt * m_listVertexNormal[tmppFaces[iii].m_normal[1]]).dot(cameraNormal) >= -0.2f) || ((mattttt * m_listVertexNormal[tmppFaces[iii].m_normal[1]]).dot(cameraNormal) >= -0.2f)
@ -278,17 +278,17 @@ void ege::resource::Mesh::drawNormal(mat4& _positionMatrix,
FaceIndexing& tmpFaceList = m_listFaces.getValue(kkk); FaceIndexing& tmpFaceList = m_listFaces.getValue(kkk);
for (size_t iii=0; iii<tmpFaceList.m_faces.size() ; iii++) { for (size_t iii=0; iii<tmpFaceList.m_faces.size() ; iii++) {
switch(m_normalMode) { switch(m_normalMode) {
case normalModeVertex: case ege::resource::Mesh::normalMode::vertex:
{ {
// dsplay normal for each vertice ... (TODO: not tested ...) // dsplay normal for each vertice ... (TODO: not tested ...)
for(size_t indice=0 ; indice<nbIndicInFace; indice++) { for(size_t indice=0 ; indice<nbIndicInFace; indice++) {
vec3 position = m_listVertex[tmpFaceList.m_faces[iii].m_vertex[indice]]; vec3 position = m_listVertex[tmpFaceList.m_faces[iii].m_vertex[indice]];
vec3 normal = m_listVertexNormal[tmpFaceList.m_faces[iii].m_normal[indice]]; vec3 normal = m_listVertexNormal[tmpFaceList.m_faces[iii].m_normal[indice]];
vertices.push_back(position); vertices.push_back(position);
vertices.push_back(position+normal*0.25f); vertices.push_back(position+normal*0.5f);
} }
} break; } break;
case normalModeFace: case ege::resource::Mesh::normalMode::face:
{ {
vec3 center(0,0,0); vec3 center(0,0,0);
for(size_t indice=0 ; indice<nbIndicInFace; indice++) { for(size_t indice=0 ; indice<nbIndicInFace; indice++) {
@ -296,11 +296,16 @@ void ege::resource::Mesh::drawNormal(mat4& _positionMatrix,
center += position; center += position;
} }
center /= float(nbIndicInFace); center /= float(nbIndicInFace);
vec3 normal = m_listFacesNormal[tmpFaceList.m_faces[iii].m_normal[0]]; int32_t index = tmpFaceList.m_faces[iii].m_normal[0];
if (index >= m_listFacesNormal.size()) {
EGE_ERROR("not enougth normal in the buffer ... " << index << " >= " << m_listFacesNormal.size());
return;
}
vec3 normal = m_listFacesNormal[index];
vertices.push_back(center); vertices.push_back(center);
vertices.push_back(center+normal*0.25f); vertices.push_back(center+normal*0.5f);
} break; } break;
case normalModeNone: case ege::resource::Mesh::normalMode::none:
break; break;
} }
} }
@ -308,11 +313,15 @@ void ege::resource::Mesh::drawNormal(mat4& _positionMatrix,
_draw->drawLine(vertices, tmpColor, _positionMatrix); _draw->drawLine(vertices, tmpColor, _positionMatrix);
} }
void ege::resource::Mesh::setNormalMode(enum normalMode _mode) {
m_normalMode = _mode;
}
// normal calculation of the normal face is really easy : // normal calculation of the normal face is really easy :
// TODO : Use it for multiple Material interface // TODO : Use it for multiple Material interface
void ege::resource::Mesh::calculateNormaleFace(const std::string& _materialName) { void ege::resource::Mesh::calculateNormaleFace(const std::string& _materialName) {
m_listFacesNormal.clear(); m_listFacesNormal.clear();
if (m_normalMode == ege::resource::Mesh::normalModeFace) { if (m_normalMode == ege::resource::Mesh::normalMode::face) {
EGE_VERBOSE("calculateNormaleFace(" << _materialName << ")"); EGE_VERBOSE("calculateNormaleFace(" << _materialName << ")");
gale::openGL::renderMode tmpRenderMode = m_materials[_materialName]->getRenderMode(); gale::openGL::renderMode tmpRenderMode = m_materials[_materialName]->getRenderMode();
if ( tmpRenderMode == gale::openGL::renderMode::point if ( tmpRenderMode == gale::openGL::renderMode::point
@ -320,25 +329,30 @@ void ege::resource::Mesh::calculateNormaleFace(const std::string& _materialName)
|| tmpRenderMode == gale::openGL::renderMode::lineStrip || tmpRenderMode == gale::openGL::renderMode::lineStrip
|| tmpRenderMode == gale::openGL::renderMode::lineLoop) { || tmpRenderMode == gale::openGL::renderMode::lineLoop) {
EGE_ERROR("calculateNormaleFace(" << _materialName << ") : can not calculate normal on lines ..."); EGE_ERROR("calculateNormaleFace(" << _materialName << ") : can not calculate normal on lines ...");
m_normalMode = ege::resource::Mesh::normalModeNone; m_normalMode = ege::resource::Mesh::normalMode::none;
return; return;
} }
for(auto &it : m_listFaces[_materialName].m_faces) { for(auto &it : m_listFaces[_materialName].m_faces) {
// for all case, We use only the 3 vertex for quad element, in theory 3D modeler export element in triangle if it is not a real plane. // for all case, We use only the 3 vertex for quad element, in theory 3D modeler export element in triangle if it is not a real plane.
vec3 normal = (m_listVertex[it.m_vertex[0]]-m_listVertex[it.m_vertex[1]]).cross(m_listVertex[it.m_vertex[1]]-m_listVertex[it.m_vertex[2]]); vec3 normal = (m_listVertex[it.m_vertex[0]]-m_listVertex[it.m_vertex[1]]).cross(m_listVertex[it.m_vertex[1]]-m_listVertex[it.m_vertex[2]]);
//EGE_INFO("normal: " << normal.normalized());
if (normal == vec3(0,0,0)) { if (normal == vec3(0,0,0)) {
EGE_ERROR("Null vertor for a face ... " << m_listVertex[it.m_vertex[0]] << " " << m_listVertex[it.m_vertex[1]] << " " << m_listVertex[it.m_vertex[2]]); EGE_ERROR("Null vertor for a face ... " << m_listVertex[it.m_vertex[0]] << " " << m_listVertex[it.m_vertex[1]] << " " << m_listVertex[it.m_vertex[2]]);
m_listFacesNormal.push_back(vec3(1,0,0)); m_listFacesNormal.push_back(vec3(1,0,0));
} else { } else {
m_listFacesNormal.push_back(normal.normalized()); m_listFacesNormal.push_back(normal.normalized());
} }
int32_t normalID = m_listFacesNormal.size() - 1;
it.m_normal[0] = normalID;
it.m_normal[1] = normalID;
it.m_normal[2] = normalID;
} }
} }
} }
void ege::resource::Mesh::calculateNormaleEdge(const std::string& _materialName) { void ege::resource::Mesh::calculateNormaleEdge(const std::string& _materialName) {
m_listVertexNormal.clear(); m_listVertexNormal.clear();
if (m_normalMode == ege::resource::Mesh::normalModeVertex) { if (m_normalMode == ege::resource::Mesh::normalMode::vertex) {
EGE_INFO("calculateNormaleEdge(" << _materialName << ")"); EGE_INFO("calculateNormaleEdge(" << _materialName << ")");
gale::openGL::renderMode tmpRenderMode = m_materials[_materialName]->getRenderMode(); gale::openGL::renderMode tmpRenderMode = m_materials[_materialName]->getRenderMode();
if ( tmpRenderMode == gale::openGL::renderMode::point if ( tmpRenderMode == gale::openGL::renderMode::point
@ -346,7 +360,7 @@ void ege::resource::Mesh::calculateNormaleEdge(const std::string& _materialName)
|| tmpRenderMode == gale::openGL::renderMode::lineStrip || tmpRenderMode == gale::openGL::renderMode::lineStrip
|| tmpRenderMode == gale::openGL::renderMode::lineLoop) { || tmpRenderMode == gale::openGL::renderMode::lineLoop) {
EGE_ERROR("calculateNormaleEdge(" << _materialName << ") : can not calculate normal on lines ..."); EGE_ERROR("calculateNormaleEdge(" << _materialName << ") : can not calculate normal on lines ...");
m_normalMode = ege::resource::Mesh::normalModeNone; m_normalMode = ege::resource::Mesh::normalMode::none;
return; return;
} }
for(size_t iii=0 ; iii<m_listVertex.size() ; iii++) { for(size_t iii=0 ; iii<m_listVertex.size() ; iii++) {
@ -376,7 +390,7 @@ void ege::resource::Mesh::calculateNormaleEdge(const std::string& _materialName)
void ege::resource::Mesh::generateVBO() { void ege::resource::Mesh::generateVBO() {
// calculate the normal of all faces if needed // calculate the normal of all faces if needed
if ( m_normalMode != ege::resource::Mesh::normalModeNone if ( m_normalMode != ege::resource::Mesh::normalMode::none
&& m_listFacesNormal.size() == 0) { && m_listFacesNormal.size() == 0) {
// when no normal detected == > auto generate Face normal .... // when no normal detected == > auto generate Face normal ....
EGE_ERROR("Calculate normal face ... in case ????"); EGE_ERROR("Calculate normal face ... in case ????");
@ -436,14 +450,14 @@ void ege::resource::Mesh::generateVBO() {
// get Normal // get Normal
vec3 normal; vec3 normal;
switch(m_normalMode) { switch(m_normalMode) {
case normalModeVertex: case ege::resource::Mesh::normalMode::vertex:
normal = m_listVertexNormal[tmpFaceList.m_faces[iii].m_normal[indice]]; normal = m_listVertexNormal[tmpFaceList.m_faces[iii].m_normal[indice]];
break; break;
case normalModeFace: case ege::resource::Mesh::normalMode::face:
normal = m_listFacesNormal[tmpFaceList.m_faces[iii].m_normal[indice]]; normal = m_listFacesNormal[tmpFaceList.m_faces[iii].m_normal[indice]];
break; break;
default: default:
case normalModeNone: case ege::resource::Mesh::normalMode::none:
break; break;
} }
// get Texture Position // get Texture Position
@ -471,7 +485,7 @@ void ege::resource::Mesh::generateVBO() {
#endif #endif
if (elementFind == false) { if (elementFind == false) {
m_verticesVBO->pushOnBuffer(MESH_VBO_VERTICES, position); m_verticesVBO->pushOnBuffer(MESH_VBO_VERTICES, position);
if (m_normalMode != normalModeNone) { if (m_normalMode != ege::resource::Mesh::normalMode::none) {
m_verticesVBO->pushOnBuffer(MESH_VBO_VERTICES_NORMAL, normal); m_verticesVBO->pushOnBuffer(MESH_VBO_VERTICES_NORMAL, normal);
} }
m_verticesVBO->pushOnBuffer(MESH_VBO_TEXTURE, texturepos); m_verticesVBO->pushOnBuffer(MESH_VBO_TEXTURE, texturepos);
@ -493,14 +507,14 @@ void ege::resource::Mesh::generateVBO() {
void ege::resource::Mesh::createViewBox(const std::string& _materialName,float _size) { void ege::resource::Mesh::createViewBox(const std::string& _materialName,float _size) {
m_normalMode = normalModeNone; m_normalMode = ege::resource::Mesh::normalMode::none;
ege::viewBox::create(m_materials, m_listFaces, m_listVertex, m_listUV, ege::viewBox::create(m_materials, m_listFaces, m_listVertex, m_listUV,
_materialName, _size); _materialName, _size);
calculateNormaleFace(_materialName); calculateNormaleFace(_materialName);
} }
void ege::resource::Mesh::createIcoSphere(const std::string& _materialName,float _size, int32_t _subdivision) { void ege::resource::Mesh::createIcoSphere(const std::string& _materialName,float _size, int32_t _subdivision) {
m_normalMode = normalModeNone; m_normalMode = ege::resource::Mesh::normalMode::none;
ege::icoSphere::create(m_materials, m_listFaces, m_listVertex, m_listUV, ege::icoSphere::create(m_materials, m_listFaces, m_listVertex, m_listUV,
_materialName, _size, _subdivision); _materialName, _size, _subdivision);
calculateNormaleFace(_materialName); calculateNormaleFace(_materialName);

11
ege/resource/Mesh.hpp
View File

@ -41,13 +41,16 @@ namespace ege {
/** /**
* @not_in_doc * @not_in_doc
*/ */
enum normalMode { enum class normalMode {
normalModeNone, none,
normalModeFace, face,
normalModeVertex, vertex,
}; };
protected: protected:
enum normalMode m_normalMode; // select the normal mode of display enum normalMode m_normalMode; // select the normal mode of display
public:
void setNormalMode(enum normalMode _mode);
protected:
bool m_checkNormal; //!< when enable, this check the normal of the mesh before sending it at the 3d card bool m_checkNormal; //!< when enable, this check the normal of the mesh before sending it at the 3d card
protected: protected:
ememory::SharedPtr<gale::resource::Program> m_GLprogram; ememory::SharedPtr<gale::resource::Program> m_GLprogram;

8
ege/resource/MeshCube.cpp
View File

@ -23,11 +23,13 @@ ememory::SharedPtr<ege::resource::Mesh> ege::resource::Mesh::createCube(float _s
out->addFaceIndexing(_materialName); out->addFaceIndexing(_materialName);
out->addQuad(_materialName, vec3(-1,-1,-1)*_size, vec3(-1, 1,-1)*_size, vec3( 1, 1,-1)*_size, vec3( 1,-1,-1)*_size, _color); out->addQuad(_materialName, vec3(-1,-1,-1)*_size, vec3(-1, 1,-1)*_size, vec3( 1, 1,-1)*_size, vec3( 1,-1,-1)*_size, _color);
out->addQuad(_materialName, vec3(-1,-1, 1)*_size, vec3(-1, 1, 1)*_size, vec3( 1, 1, 1)*_size, vec3( 1,-1, 1)*_size, _color); out->addQuad(_materialName, vec3(-1, 1, 1)*_size, vec3(-1,-1, 1)*_size, vec3( 1,-1, 1)*_size, vec3( 1, 1, 1)*_size, _color);
out->addQuad(_materialName, vec3(-1,-1,-1)*_size, vec3(-1,-1, 1)*_size, vec3(-1, 1, 1)*_size, vec3(-1, 1,-1)*_size, _color); out->addQuad(_materialName, vec3(-1,-1,-1)*_size, vec3(-1,-1, 1)*_size, vec3(-1, 1, 1)*_size, vec3(-1, 1,-1)*_size, _color);
out->addQuad(_materialName, vec3( 1,-1,-1)*_size, vec3( 1,-1, 1)*_size, vec3( 1, 1, 1)*_size, vec3( 1, 1,-1)*_size, _color); out->addQuad(_materialName, vec3( 1,-1, 1)*_size, vec3( 1,-1,-1)*_size, vec3( 1, 1,-1)*_size, vec3( 1, 1, 1)*_size, _color);
out->addQuad(_materialName, vec3(-1,-1,-1)*_size, vec3(-1,-1, 1)*_size, vec3( 1,-1, 1)*_size, vec3( 1,-1,-1)*_size, _color); out->addQuad(_materialName, vec3(-1,-1, 1)*_size, vec3(-1,-1,-1)*_size, vec3( 1,-1,-1)*_size, vec3( 1,-1, 1)*_size, _color);
out->addQuad(_materialName, vec3(-1, 1,-1)*_size, vec3(-1, 1, 1)*_size, vec3( 1, 1, 1)*_size, vec3( 1, 1,-1)*_size, _color); out->addQuad(_materialName, vec3(-1, 1,-1)*_size, vec3(-1, 1, 1)*_size, vec3( 1, 1, 1)*_size, vec3( 1, 1,-1)*_size, _color);
out->setNormalMode(ege::resource::Mesh::normalMode::face);
out->calculateNormaleFace(_materialName);
// generate the VBO // generate the VBO
out->generateVBO(); out->generateVBO();
} else { } else {

10
ege/resource/MeshEmf.cpp
View File

@ -141,7 +141,7 @@ enum emfModuleMode {
// TODO : rework with string line extractor // TODO : rework with string line extractor
bool ege::resource::Mesh::loadEMF(const std::string& _fileName) { bool ege::resource::Mesh::loadEMF(const std::string& _fileName) {
m_checkNormal = true; m_checkNormal = true;
m_normalMode = normalModeNone; m_normalMode = ege::resource::Mesh::normalMode::none;
etk::FSNode fileName(_fileName); etk::FSNode fileName(_fileName);
// get the fileSize ... // get the fileSize ...
int32_t size = fileName.fileSize(); int32_t size = fileName.fileSize();
@ -294,7 +294,7 @@ bool ege::resource::Mesh::loadEMF(const std::string& _fileName) {
break; break;
} }
case EMFModuleMeshNormalVertex: { case EMFModuleMeshNormalVertex: {
m_normalMode = normalModeVertex; m_normalMode = ege::resource::Mesh::normalMode::vertex;
vec3 normal(0,0,0); vec3 normal(0,0,0);
// find the vertex Normal list. // find the vertex Normal list.
while (loadNextData(inputDataLine, 2048, fileName, true, true) != nullptr) { while (loadNextData(inputDataLine, 2048, fileName, true, true) != nullptr) {
@ -314,7 +314,7 @@ bool ege::resource::Mesh::loadEMF(const std::string& _fileName) {
} }
case EMFModuleMeshNormalFace: { case EMFModuleMeshNormalFace: {
EGE_ERROR("Change mode in face mode ..."); EGE_ERROR("Change mode in face mode ...");
m_normalMode = normalModeFace; // TODO : check if it is the same mode of display the normal from the start of the file m_normalMode = ege::resource::Mesh::normalMode::face; // TODO : check if it is the same mode of display the normal from the start of the file
vec3 normal(0,0,0); vec3 normal(0,0,0);
// find the face Normal list. // find the face Normal list.
while (loadNextData(inputDataLine, 2048, fileName, true, true) != nullptr) { while (loadNextData(inputDataLine, 2048, fileName, true, true) != nullptr) {
@ -379,7 +379,7 @@ bool ege::resource::Mesh::loadEMF(const std::string& _fileName) {
uvIndex[0] += offsetUV; uvIndex[0] += offsetUV;
uvIndex[1] += offsetUV; uvIndex[1] += offsetUV;
uvIndex[2] += offsetUV; uvIndex[2] += offsetUV;
if (m_normalMode == normalModeFace) { if (m_normalMode == ege::resource::Mesh::normalMode::face) {
normalIndex[0] += offsetFaceNormal; normalIndex[0] += offsetFaceNormal;
normalIndex[1] += offsetFaceNormal; normalIndex[1] += offsetFaceNormal;
normalIndex[2] += offsetFaceNormal; normalIndex[2] += offsetFaceNormal;
@ -396,7 +396,7 @@ bool ege::resource::Mesh::loadEMF(const std::string& _fileName) {
vertexIndex[0] += offsetVertexId; vertexIndex[0] += offsetVertexId;
vertexIndex[1] += offsetVertexId; vertexIndex[1] += offsetVertexId;
vertexIndex[2] += offsetVertexId; vertexIndex[2] += offsetVertexId;
if (m_normalMode == normalModeFace) { if (m_normalMode == ege::resource::Mesh::normalMode::face) {
normalIndex[0] += offsetFaceNormal; normalIndex[0] += offsetFaceNormal;
normalIndex[1] += offsetFaceNormal; normalIndex[1] += offsetFaceNormal;
normalIndex[2] += offsetFaceNormal; normalIndex[2] += offsetFaceNormal;

2
ege/resource/MeshObj.cpp
View File

@ -9,7 +9,7 @@
bool ege::resource::Mesh::loadOBJ(const std::string& _fileName) { bool ege::resource::Mesh::loadOBJ(const std::string& _fileName) {
m_normalMode = normalModeNone; m_normalMode = ege::resource::Mesh::normalMode::none;
#if 0 #if 0
etk::FSNode fileName(_fileName); etk::FSNode fileName(_fileName);
// get the fileSize ... // get the fileSize ...

2
ege/resource/ParticuleMesh.cpp
View File

@ -88,7 +88,7 @@ void ege::resource::ParticuleMesh::draw(mat4& _positionMatrix,
std::vector<uint32_t> tmpIndexResult; std::vector<uint32_t> tmpIndexResult;
std::vector<ege::Face>& tmppFaces = m_listFaces.getValue(kkk).m_faces; std::vector<ege::Face>& tmppFaces = m_listFaces.getValue(kkk).m_faces;
//std::vector<uint32_t>& tmppIndex = m_listFaces.getValue(kkk).m_index; //std::vector<uint32_t>& tmppIndex = m_listFaces.getValue(kkk).m_index;
if (normalModeFace == m_normalMode) { if (m_normalMode == ege::resource::Mesh::normalMode::face) {
for(size_t iii=0; iii<tmppFaces.size() ; ++iii) { for(size_t iii=0; iii<tmppFaces.size() ; ++iii) {
if((mattttt * m_listFacesNormal[tmppFaces[iii].m_normal[0]]).dot(cameraNormal) >= 0.0f) { if((mattttt * m_listFacesNormal[tmppFaces[iii].m_normal[0]]).dot(cameraNormal) >= 0.0f) {
tmpIndexResult.push_back(iii*3); tmpIndexResult.push_back(iii*3);

13
lutin_ege.py
View File

@ -33,13 +33,12 @@ def configure(target, my_module):
'ege/camera/Camera.cpp', 'ege/camera/Camera.cpp',
'ege/camera/View.cpp', 'ege/camera/View.cpp',
'ege/camera/FPS.cpp', 'ege/camera/FPS.cpp',
'ege/CollisionShapeCreator.cpp',
'ege/position/Component.cpp', 'ege/position/Component.cpp',
'ege/physics/Component.cpp', 'ege/physics/Component.cpp',
'ege/physics/Engine.cpp', 'ege/physics/Engine.cpp',
'ege/elements/Element.cpp', 'ege/elements/Element.cpp',
'ege/elements/ElementBase.cpp', #'ege/elements/ElementBase.cpp',
'ege/elements/ElementPhysic.cpp', #'ege/elements/ElementPhysic.cpp',
'ege/particule/Component.cpp', 'ege/particule/Component.cpp',
'ege/particule/Engine.cpp', 'ege/particule/Engine.cpp',
'ege/particule/Simple.cpp', 'ege/particule/Simple.cpp',
@ -71,7 +70,7 @@ def configure(target, my_module):
]) ])
my_module.copy_path('data/ParticuleMesh.*') my_module.copy_path('data/ParticuleMesh.*')
my_module.copy_path('data/material3D.*') my_module.copy_path('data/material3D.*')
my_module.add_depend(['ewol', 'ephysics', 'echrono']) my_module.add_depend(['ewol', 'ephysics', 'eproperty', 'echrono'])
my_module.add_flag('c++', [ my_module.add_flag('c++', [
'-Wno-write-strings', '-Wno-write-strings',
'-Wmissing-field-initializers', '-Wmissing-field-initializers',
@ -84,13 +83,12 @@ def configure(target, my_module):
'ege/camera/Camera.hpp', 'ege/camera/Camera.hpp',
'ege/camera/View.hpp', 'ege/camera/View.hpp',
'ege/camera/FPS.hpp', 'ege/camera/FPS.hpp',
'ege/CollisionShapeCreator.hpp',
'ege/position/Component.hpp', 'ege/position/Component.hpp',
'ege/physics/Engine.hpp', 'ege/physics/Engine.hpp',
'ege/physics/Component.hpp', 'ege/physics/Component.hpp',
'ege/elements/Element.hpp', 'ege/elements/Element.hpp',
'ege/elements/ElementBase.hpp', #'ege/elements/ElementBase.hpp',
'ege/elements/ElementPhysic.hpp', #'ege/elements/ElementPhysic.hpp',
'ege/particule/Component.hpp', 'ege/particule/Component.hpp',
'ege/particule/Engine.hpp', 'ege/particule/Engine.hpp',
'ege/particule/Simple.hpp', 'ege/particule/Simple.hpp',
@ -121,7 +119,6 @@ def configure(target, my_module):
# TODO: Remove this ... # TODO: Remove this ...
my_module.add_flag('c++', "-Wno-unused-variable") my_module.add_flag('c++', "-Wno-unused-variable")
my_module.add_flag('c++', "-Wno-overloaded-virtual") my_module.add_flag('c++', "-Wno-overloaded-virtual")
my_module.add_path(".")
return True return True

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

@ -15,8 +15,7 @@
#include <ege/widget/Scene.hpp> #include <ege/widget/Scene.hpp>
#include <ege/camera/View.hpp> #include <ege/camera/View.hpp>
#include <etk/tool.hpp> #include <etk/tool.hpp>
#include <ege/elements/ElementBase.hpp> #include <ege/elements/Element.hpp>
#include <ege/elements/ElementPhysic.hpp>
#include <ege/physicsShape/PhysicsBox.hpp> #include <ege/physicsShape/PhysicsBox.hpp>
#include <ege/physicsShape/PhysicsSphere.hpp> #include <ege/physicsShape/PhysicsSphere.hpp>
#include <ege/position/Component.hpp> #include <ege/position/Component.hpp>
@ -76,6 +75,10 @@ void appl::Windows::init() {
getObjectManager().periodicCall.connect(sharedFromThis(), &appl::Windows::onCallbackPeriodicCheckCollision); getObjectManager().periodicCall.connect(sharedFromThis(), &appl::Windows::onCallbackPeriodicCheckCollision);
m_env = ege::Environement::create(); m_env = ege::Environement::create();
// set the debug property on the engines
m_env->getEngine("render")->properties.set("debug-normal", "true");
m_env->getEngine("physics")->properties.set("debug-AABB", "true");
m_env->getEngine("physics")->properties.set("debug-shape", "true");
// Create basic Camera // Create basic Camera
m_camera = ememory::makeShared<ege::camera::View>(vec3(30,30,-100), vec3(0,0,0)); m_camera = ememory::makeShared<ege::camera::View>(vec3(30,30,-100), vec3(0,0,0));
m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),40*std::cos(m_anglePsy))); m_camera->setEye(vec3(100*std::sin(m_angleTetha),100*std::cos(m_angleTetha),40*std::cos(m_anglePsy)));
@ -93,7 +96,7 @@ void appl::Windows::init() {
} }
ememory::SharedPtr<ege::resource::Mesh> myMesh; ememory::SharedPtr<ege::resource::Mesh> myMesh;
// Create an external box: // Create an external box: (no physics)
myMesh = createViewBoxStar(); myMesh = createViewBoxStar();
if (myMesh != nullptr) { if (myMesh != nullptr) {
ememory::SharedPtr<ege::Element> element = ememory::makeShared<ege::Element>(m_env); ememory::SharedPtr<ege::Element> element = ememory::makeShared<ege::Element>(m_env);
@ -107,7 +110,7 @@ void appl::Windows::init() {
// add it .. // add it ..
m_env->addElement(element); m_env->addElement(element);
} }
// create basic gird: // create basic gird: (no physics)
myMesh = ege::resource::Mesh::createGrid(10, vec3(0,0,0), 5); myMesh = ege::resource::Mesh::createGrid(10, vec3(0,0,0), 5);
if (myMesh != nullptr) { if (myMesh != nullptr) {
ememory::SharedPtr<ege::Element> element = ememory::makeShared<ege::Element>(m_env); ememory::SharedPtr<ege::Element> element = ememory::makeShared<ege::Element>(m_env);
@ -128,8 +131,6 @@ void appl::Windows::init() {
// add all component: // add all component:
// 1st Position component: // 1st Position component:
etk::Transform3D transform(vec3(0,0,2), etk::Quaternion::identity()); etk::Transform3D transform(vec3(0,0,2), etk::Quaternion::identity());
//ememory::SharedPtr<ege::position::Component> componentPosition = ememory::makeShared<ege::position::Component>(transform);
//element->addComponent(componentPosition);
// 2nd something to diplay: // 2nd something to diplay:
ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh); ememory::SharedPtr<ege::render::Component> componentRender = ememory::makeShared<ege::render::Component>(myMesh);
element->addComponent(componentRender); element->addComponent(componentRender);
@ -137,6 +138,7 @@ void appl::Windows::init() {
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform); 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::PhysicsBox> physic = ememory::makeShared<ege::PhysicsBox>();
physic->setSize(vec3(3.2,3.2,3.2)); physic->setSize(vec3(3.2,3.2,3.2));
physic->setMass(300000);
componentPhysics->addShape(physic); componentPhysics->addShape(physic);
componentPhysics->generate(); componentPhysics->generate();
element->addComponent(componentPhysics); element->addComponent(componentPhysics);
@ -158,6 +160,7 @@ void appl::Windows::init() {
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform); 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::PhysicsBox> physic = ememory::makeShared<ege::PhysicsBox>();
physic->setSize(vec3(3.2,3.2,3.2)); physic->setSize(vec3(3.2,3.2,3.2));
physic->setMass(50000);
componentPhysics->addShape(physic); componentPhysics->addShape(physic);
componentPhysics->generate(); componentPhysics->generate();
element->addComponent(componentPhysics); element->addComponent(componentPhysics);
@ -166,7 +169,7 @@ void appl::Windows::init() {
} }
m_env->propertyStatus.set(ege::gameStart); m_env->propertyStatus.set(ege::gameStart);
} }
/*
namespace appl { namespace appl {
class ElementHerit : public ege::ElementPhysic { class ElementHerit : public ege::ElementPhysic {
public: public:
@ -179,6 +182,7 @@ namespace appl {
} }
}; };
} }
*/
bool appl::Windows::onEventInput(const ewol::event::Input& _event) { bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
@ -204,12 +208,13 @@ bool appl::Windows::onEventInput(const ewol::event::Input& _event) {
ememory::SharedPtr<ege::physics::Component> componentPhysics = ememory::makeShared<ege::physics::Component>(m_env, transform); 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::PhysicsBox> physic = ememory::makeShared<ege::PhysicsBox>();
physic->setSize(vec3(1.1,1.1,1.1)); physic->setSize(vec3(1.1,1.1,1.1));
physic->setMass(1000);
componentPhysics->setType(ege::physics::Component::type::bodyDynamic); componentPhysics->setType(ege::physics::Component::type::bodyDynamic);
componentPhysics->addShape(physic); componentPhysics->addShape(physic);
componentPhysics->generate(); componentPhysics->generate();
// set has dynamic object (can move) // set has dynamic object (can move)
//APPL_CRITICAL("velocity : " << ray.getDirection()*100); //APPL_CRITICAL("velocity : " << ray.getDirection()*100);
componentPhysics->setLinearVelocity(ray.getDirection()*1000); componentPhysics->setLinearVelocity(ray.getDirection()*100);
element->addComponent(componentPhysics); element->addComponent(componentPhysics);
// add it .. // add it ..
m_env->addElement(element); m_env->addElement(element);