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

[STYLE] remove (void) in () to be c++ coherent

Browse Source
This commit is contained in:
Edouard DUPIN 2014-05-15 21:37:39 +02:00
parent 000bde321d
commit ba20ab59f7
32 changed files with 189 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ege/Camera.cpp
View File

@ -13,7 +13,7 @@
#undef __class__
#define __class__ "Camera"
void ege::Camera::update(void) {
void ege::Camera::update() {
// Note the view axes of the basic camera is (0,0,-1)
// clean matrix :
m_matrix.identity();

16
ege/Camera.h
View File

@ -25,7 +25,7 @@ namespace ege
/**
* @brief update the matrix property
*/
void update(void);
void update();
public:
/**
* @brief Constructor.
@ -47,7 +47,7 @@ namespace ege
* @brief get the curent Camera Eye position.
* @return the current position.
*/
const vec3& getEye(void) const {
const vec3& getEye() const {
return m_eye;
};
protected:
@ -57,7 +57,7 @@ namespace ege
* @brief get the curent Camera origin position.
* @return the current position.
*/
const vec3& getOrigin(void) const {
const vec3& getOrigin() const {
return m_calculatedOrigin;
};
protected:
@ -67,7 +67,7 @@ namespace ege
* @brief Get the camera viewing vector.
* @return the current position.
*/
const vec3& getViewVector(void) const {
const vec3& getViewVector() const {
return m_calculatedViewVector;
};
protected:
@ -82,7 +82,7 @@ namespace ege
* @brief get the curent Camera angles.
* @return the current angles Z.
*/
float getAngleZ(void) const {
float getAngleZ() const {
return m_angleZ;
};
protected:
@ -97,7 +97,7 @@ namespace ege
* @brief get the curent Camera angles.
* @return the current angles Teta.
*/
float getAngleTeta(void) const {
float getAngleTeta() const {
return m_angleTeta;
};
protected:
@ -112,14 +112,14 @@ namespace ege
* @brief get the curent Camera angles.
* @return the current distance to the eye.
*/
float getDistance(void) const {
float getDistance() const {
return m_distance;
};
/**
* @brief get the transformation matix for the camera.
* @return the current transformation matrix
*/
const mat4& getMatrix(void) const {
const mat4& getMatrix() const {
return m_matrix;
};
protected:

22
ege/ElementGame.cpp
View File

@ -28,7 +28,7 @@
#undef __class__
#define __class__ "ElementGame"
const std::string& ege::ElementGame::getType(void) const {
const std::string& ege::ElementGame::getType() const {
static const std::string nameType("----");
return nameType;
}
@ -54,7 +54,7 @@ ege::ElementGame::ElementGame(ege::Environement& _env) :
unique++;
}
ege::ElementGame::~ElementGame(void) {
ege::ElementGame::~ElementGame() {
// in every case remove IA
iaDisable();
// same ...
@ -68,7 +68,7 @@ ege::ElementGame::~ElementGame(void) {
EGE_DEBUG("Destroy element : uId=" << m_uID);
}
void ege::ElementGame::removeShape(void) {
void ege::ElementGame::removeShape() {
// no shape
if (NULL == m_shape) {
return;
@ -130,7 +130,7 @@ bool ege::ElementGame::setShape(btCollisionShape* _shape) {
return true;
}
float ege::ElementGame::getLifeRatio(void) {
float ege::ElementGame::getLifeRatio() {
if (0 >= m_life) {
return 0;
}
@ -157,7 +157,7 @@ void ege::ElementGame::setPosition(const vec3& _pos) {
}
}
const vec3& ege::ElementGame::getPosition(void) {
const vec3& ege::ElementGame::getPosition() {
// this is to prevent error like segmentation fault ...
static vec3 emptyPosition(-1000000,-1000000,-1000000);
if (NULL!=m_body) {
@ -166,7 +166,7 @@ const vec3& ege::ElementGame::getPosition(void) {
return emptyPosition;
};
const vec3& ege::ElementGame::getSpeed(void) {
const vec3& ege::ElementGame::getSpeed() {
// this is to prevent error like segmentation fault ...
static vec3 emptySpeed(0,0,0);
if (NULL!=m_body) {
@ -175,7 +175,7 @@ const vec3& ege::ElementGame::getSpeed(void) {
return emptySpeed;
};
const float ege::ElementGame::getInvMass(void) {
const float ege::ElementGame::getInvMass() {
if (NULL!=m_body) {
return m_body->getInvMass();
}
@ -479,7 +479,7 @@ void ege::ElementGame::draw(int32_t _pass) {
}
}
void ege::ElementGame::dynamicEnable(void) {
void ege::ElementGame::dynamicEnable() {
if (true == m_elementInPhysicsSystem) {
return;
}
@ -492,7 +492,7 @@ void ege::ElementGame::dynamicEnable(void) {
m_elementInPhysicsSystem = true;
}
void ege::ElementGame::dynamicDisable(void) {
void ege::ElementGame::dynamicDisable() {
if (false == m_elementInPhysicsSystem) {
return;
}
@ -507,7 +507,7 @@ void ege::ElementGame::dynamicDisable(void) {
m_elementInPhysicsSystem = false;
}
void ege::ElementGame::iaEnable(void) {
void ege::ElementGame::iaEnable() {
if (NULL != m_IA) {
// IA already started ...
return;
@ -522,7 +522,7 @@ void ege::ElementGame::iaEnable(void) {
}
}
void ege::ElementGame::iaDisable(void) {
void ege::ElementGame::iaDisable() {
if (NULL == m_IA) {
// IA already stopped ...
return;

48
ege/ElementGame.h
View File

@ -46,12 +46,12 @@ namespace ege {
/**
* @brief Destructor
*/
virtual ~ElementGame(void);
virtual ~ElementGame();
/**
* @brief get the element Type description string.
* @return A reference on the descriptive string.
*/
virtual const std::string& getType(void) const;
virtual const std::string& getType() const;
/**
* @brief init the element with the defined properties
* @param[in] _property Type of the next element
@ -61,7 +61,7 @@ namespace ege {
virtual bool init(enum property _property, void* _value) {
return false;
};
virtual bool unInit(void) {
virtual bool unInit() {
return true;
};
private:
@ -71,7 +71,7 @@ namespace ege {
* @brief get the curent Element Unique ID in the all Game.
* @return The requested Unique ID.
*/
inline uint32_t getUID(void) const {
inline uint32_t getUID() const {
return m_uID;
};
private:
@ -103,21 +103,21 @@ namespace ege {
* @brief get a pointer on the Mesh file.
* @return the mesh pointer.
*/
inline ege::resource::Mesh* getMesh(void) {
inline ege::resource::Mesh* getMesh() {
return m_mesh;
};
/**
* @brief get a pointer on the bullet collision shape.
* @return the collision pointer.
*/
inline btCollisionShape* getShape(void) {
inline btCollisionShape* getShape() {
return m_shape;
};
private:
/**
* @brief remove the curent selected shape.
*/
void removeShape(void);
void removeShape();
protected:
float m_life; //!< Current life of the object
float m_lifeMax; //!< Maximum possible life of the element
@ -126,19 +126,19 @@ namespace ege {
* @brief get the curent life ratio [0..1]
* @return The proportionnal life
*/
float getLifeRatio(void);
float getLifeRatio();
/**
* @brief Check if the element is dead.
* @return true if the element does not exist anymore, false otherwise.
*/
bool isDead(void) {
bool isDead() {
return (0 >= m_life)?true:false;
};
/**
* @brief Request if the element might be removed from the system
* @return true == > the object is removed
*/
virtual bool needToRemove(void) {
virtual bool needToRemove() {
return isDead();
}
/**
@ -152,7 +152,7 @@ namespace ege {
/**
* @brief Call chan the element life change
*/
virtual void onLifeChange(void) { };
virtual void onLifeChange() { };
protected:
int32_t m_group; //!< Every element has a generic group
public:
@ -160,7 +160,7 @@ namespace ege {
* @brief get the Group of the element.
* @return The group ID
*/
inline int32_t getGroup(void) const {
inline int32_t getGroup() const {
return m_group;
};
/**
@ -202,7 +202,7 @@ namespace ege {
* @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(void) {
virtual vec3 getPositionTheoric() {
return getPosition();
};
/**
@ -214,7 +214,7 @@ namespace ege {
* @brief get the current position of the element
* @return the 3D position.
*/
const vec3& getPosition(void);
const vec3& getPosition();
/**
* @brief set the current position of the element
* @param[in] _pos set the 3D position.
@ -224,12 +224,12 @@ namespace ege {
* @brief get the current speed of the element
* @return the 3D speed.
*/
const vec3& getSpeed(void);
const vec3& getSpeed();
/**
* @brief get the current mass of the element
* @return the mass in kG.
*/
const float getInvMass(void);
const float getInvMass();
/**
* @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.
@ -242,7 +242,7 @@ namespace ege {
* @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(void) {
inline bool isFixed() {
return m_fixe;
};
protected:
@ -252,7 +252,7 @@ namespace ege {
* @brief get the current space needed by the element in the workspace
* @return The dimention needed.
*/
inline float getRadius(void)
inline float getRadius()
{
return m_radius;
};
@ -262,11 +262,11 @@ namespace ege {
/**
* @brief set the elment in the physique engine
*/
void dynamicEnable(void);
void dynamicEnable();
/**
* @brief remove this element from the physique engine
*/
void dynamicDisable(void);
void dynamicDisable();
private:
class localIA : public btActionInterface {
private:
@ -279,7 +279,7 @@ namespace ege {
/**
* @brief Destructor
*/
virtual ~localIA(void) {
virtual ~localIA() {
};
public: // herited function
@ -295,11 +295,11 @@ namespace ege {
/**
* @brief enable periodic call Of this object for processing Artificial Intelligence
*/
void iaEnable(void);
void iaEnable();
/**
* @brief disable periodic call Of this object for processing Artificial Intelligence
*/
void iaDisable(void);
void iaDisable();
/**
* @brief periodic call for intelligence artificial.
* @param[in] step : step of time in s
@ -308,7 +308,7 @@ namespace ege {
/**
* @brief, call when the element is removed (call only one time
*/
virtual void onDestroy(void) {};
virtual void onDestroy() {};
};
};

4
ege/Environement.cpp
View File

@ -110,7 +110,7 @@ void ege::Environement::getElementNearestFixed(const vec3& _sourcePosition,
}
}
static etk::Hash<ege::createElement_tf>& getHachTableCreating(void) {
static etk::Hash<ege::createElement_tf>& getHachTableCreating() {
static etk::Hash<ege::createElement_tf> s_table;
return s_table;
}
@ -270,7 +270,7 @@ void ege::Environement::generateInteraction(ege::ElementInteraction& _event) {
}
}
ege::Environement::Environement(void) :
ege::Environement::Environement() :
m_dynamicsWorld(NULL),
m_particuleEngine(*this) {
// nothing to do ...

18
ege/Environement.h
View File

@ -42,15 +42,15 @@ namespace ege {
protected:
int32_t m_type;
public:
int32_t getType(void) { return m_type; };
int32_t getType() { return m_type; };
protected:
int32_t m_groupSource;
public:
int32_t getSourceGroup(void) { return m_groupSource; };
int32_t getSourceGroup() { return m_groupSource; };
protected:
std::vector<int32_t> m_groupDestination;
public:
const std::vector<int32_t>& getDestinationGroup(void) {
const std::vector<int32_t>& getDestinationGroup() {
return m_groupDestination;
};
void addGroupDestination(int32_t _id) {
@ -59,7 +59,7 @@ namespace ege {
protected:
vec3 m_positionSource;
public:
const vec3& getSourcePosition(void) {
const vec3& getSourcePosition() {
return m_positionSource;
};
public:
@ -77,8 +77,8 @@ namespace ege {
btDynamicsWorld* m_dynamicsWorld; //!< curent system world description
std::vector<ege::ElementGame*> m_listElementGame; //!< List of all element added in the Game
public:
Environement(void);
virtual ~Environement(void) { };
Environement();
virtual ~Environement() { };
public:
/**
* @brief add a creator element system
@ -115,14 +115,14 @@ namespace ege {
* @brief get the curent world
* @return pointer on the current world
*/
btDynamicsWorld* getDynamicWorld(void) {
btDynamicsWorld* getDynamicWorld() {
return m_dynamicsWorld;
};
/**
* @breif get a reference on the curent list of element games
* @return all element list
*/
std::vector<ege::ElementGame*>& getElementGame(void) {
std::vector<ege::ElementGame*>& getElementGame() {
return m_listElementGame;
};
/**
@ -168,7 +168,7 @@ namespace ege {
* @brief get the particule engine reference.
* @return The requested reference on the engine
*/
ege::ParticuleEngine& getParticuleEngine(void) {
ege::ParticuleEngine& getParticuleEngine() {
return m_particuleEngine;
};
};

4
ege/Light.cpp
View File

@ -9,7 +9,7 @@
#include <ege/Light.h>
#include <ege/debug.h>
ege::Light::Light(void) :
ege::Light::Light() :
m_direction(0,0,0),
m_halfplane(0,0,0),
m_ambientColor(0,0,0,0),
@ -23,7 +23,7 @@ ege::Light::Light(void) :
// nothing to do else ...
}
ege::Light::~Light(void) {
ege::Light::~Light() {
}

4
ege/Light.h
View File

@ -31,8 +31,8 @@ namespace ege {
int32_t m_GL_diffuseColor;
int32_t m_GL_specularColor;
public:
Light(void);
~Light(void);
Light();
~Light();
void link(ewol::resource::Program* _prog, const std::string& _baseName);
void draw(ewol::resource::Program* _prog);
void setDirection(const vec3& val) {

6
ege/Material.cpp
View File

@ -10,7 +10,7 @@
#include <ege/Material.h>
#include <ege/debug.h>
ege::MaterialGlId::MaterialGlId(void) :
ege::MaterialGlId::MaterialGlId() :
m_GL_ambientFactor(0),
m_GL_diffuseFactor(0),
m_GL_specularFactor(0),
@ -31,7 +31,7 @@ void ege::MaterialGlId::link(ewol::resource::Program* _prog, const std::string&
m_GL_texture0 = _prog->getUniform("EW_texID");
}
ege::Material::Material(void) :
ege::Material::Material() :
m_ambientFactor(1,1,1,1),
m_diffuseFactor(0,0,0,1),
m_specularFactor(0,0,0,1),
@ -39,7 +39,7 @@ ege::Material::Material(void) :
m_texture0(NULL) {
// nothing to do else ...
}
ege::Material::~Material(void) {
ege::Material::~Material() {
if(NULL!=m_texture0) {
ewol::resource::TextureFile::release(m_texture0);
}

10
ege/Material.h
View File

@ -27,7 +27,7 @@ namespace ege {
int32_t m_GL_specularFactor;
int32_t m_GL_shininess;
int32_t m_GL_texture0;
MaterialGlId(void);
MaterialGlId();
void link(ewol::resource::Program* _prog, const std::string& _baseName);
};
class Material {
@ -41,8 +41,8 @@ namespace ege {
public:
std::vector<uint32_t> m_listIndexFaces;
public:
Material(void);
~Material(void);
Material();
~Material();
void draw(ewol::resource::Program* _prog, const ege::MaterialGlId& _glID);
void setAmbientFactor(const vec4& _val) {
m_ambientFactor = _val;
@ -65,14 +65,14 @@ namespace ege {
m_texture0->setImageSize(_newSize);
};
// get the reference on this image to draw nomething on it ...
egami::Image* get(void) {
egami::Image* get() {
if (m_texture0 == NULL){
return NULL;
}
return &m_texture0->get();
};
// flush the data to send it at the openGl system
void flush(void) {
void flush() {
if (m_texture0 == NULL){
return;
}

12
ege/Particule.h
View File

@ -38,15 +38,15 @@ namespace ege {
/**
* @brief Destructor.
*/
virtual ~Particule(void) { };
virtual ~Particule() { };
/**
* @brief init the particule
*/
virtual void init(void) { };
virtual void init() { };
/**
* @brief Un-init the particule
*/
virtual void UnInit(void) { };
virtual void UnInit() { };
/**
* @brief update the paticule properties
* @param[in] _delta Delta time from the previous call
@ -61,20 +61,20 @@ namespace ege {
* @return true : The element might be removed
* @return false : The element might be keeped
*/
virtual bool needRemove(void) {
virtual bool needRemove() {
return false;
};
/**
* @brief get the type of the particule
* @return Type of the current particule
*/
const char* getParticuleType(void) {
const char* getParticuleType() {
return m_particuleType;
};
/**
* @brief When the particule arrive to his end of life, this function is called.
*/
virtual void onEnd(void) {};
virtual void onEnd() {};
};
};

4
ege/ParticuleEngine.cpp
View File

@ -17,7 +17,7 @@ ege::ParticuleEngine::ParticuleEngine(ege::Environement& _env) :
}
ege::ParticuleEngine::~ParticuleEngine(void) {
ege::ParticuleEngine::~ParticuleEngine() {
clear();
}
@ -118,7 +118,7 @@ void ege::ParticuleEngine::draw(const ege::Camera& _camera) {
}
}
void ege::ParticuleEngine::clear(void) {
void ege::ParticuleEngine::clear() {
// clear element not removed
for (size_t iii=0; iii<m_particuleList.size(); ++iii) {
if (m_particuleList[iii] == NULL) {

4
ege/ParticuleEngine.h
View File

@ -25,7 +25,7 @@ namespace ege {
ege::Environement& m_env;
public:
ParticuleEngine(ege::Environement& _env); // note : need the engine to register has an dynamic element ... (the first ...)
~ParticuleEngine(void);
~ParticuleEngine();
private:
std::vector<Particule*> m_particuleList; //!< all particule created and active
std::vector<Particule*> m_particuleRemoved; //!< removed particule
@ -33,7 +33,7 @@ namespace ege {
/**
* @brief clear the particule engine
*/
void clear(void);
void clear();
/**
* @brief add a particule in the engine (internal acces only)
* @param[in] _particule Pointer on the particule to add

4
ege/ParticuleSimple.cpp
View File

@ -18,7 +18,7 @@ ege::ParticuleSimple::ParticuleSimple(ege::ParticuleEngine& _particuleEngine, co
}
void ege::ParticuleSimple::init(void) {
void ege::ParticuleSimple::init() {
m_lifeFull = 3;
m_life = m_lifeFull;
m_level = 0;
@ -29,7 +29,7 @@ void ege::ParticuleSimple::init(void) {
m_scaleExpand = vec3(0,0,0);
}
bool ege::ParticuleSimple::needRemove(void) {
bool ege::ParticuleSimple::needRemove() {
return m_life<0.0f;
}

8
ege/ParticuleSimple.h
View File

@ -38,12 +38,12 @@ namespace ege {
/**
* @brief Destructor.
*/
virtual ~ParticuleSimple(void) { };
virtual ~ParticuleSimple() { };
public: // herited elements:
virtual void update(float _delta);
//virtual void draw(void) { };
virtual bool needRemove(void);
virtual void init(void);
//virtual void draw() { };
virtual bool needRemove();
virtual void init();
protected:
float m_lifeFull;
float m_life;

2
ege/debug.cpp
View File

@ -8,7 +8,7 @@
#include <ege/debug.h>
int32_t ege::getLogId(void) {
int32_t ege::getLogId() {
static int32_t g_val = etk::log::registerInstance("ege");
return g_val;
}

2
ege/debug.h
View File

@ -12,7 +12,7 @@
#include <etk/log.h>
namespace ege {
int32_t getLogId(void);
int32_t getLogId();
};
// TODO : Review this problem of multiple intanciation of "std::stringbuf sb"
#define EGE_BASE(info,data) \

14
ege/physicsShape/PhysicsBox.h
View File

@ -16,26 +16,26 @@
namespace ege {
class PhysicsBox : public ege::PhysicsShape {
public:
PhysicsBox(void) {};
virtual ~PhysicsBox(void) {};
PhysicsBox() {};
virtual ~PhysicsBox() {};
public:
virtual bool parse(const char* _line);
virtual void display(void) {};
virtual void display() {};
public:
virtual enum ege::PhysicsShape::type getType(void) {
virtual enum ege::PhysicsShape::type getType() {
return ege::PhysicsShape::box;
};
private:
vec3 m_size; // Box size property in X, Y and Z
public:
const vec3& getSize(void) const {
const vec3& getSize() const {
return m_size;
};
public:
virtual const ege::PhysicsBox* toBox(void) const {
virtual const ege::PhysicsBox* toBox() const {
return this;
};
virtual ege::PhysicsBox* toBox(void) {
virtual ege::PhysicsBox* toBox() {
return this;
};
};

16
ege/physicsShape/PhysicsCapsule.h
View File

@ -17,32 +17,32 @@
namespace ege {
class PhysicsCapsule : public ege::PhysicsShape {
public:
PhysicsCapsule(void) {};
virtual ~PhysicsCapsule(void) {};
PhysicsCapsule() {};
virtual ~PhysicsCapsule() {};
public:
virtual bool parse(const char* _line);
virtual void display(void) {};
virtual void display() {};
public:
virtual enum ege::PhysicsShape::type getType(void) {
virtual enum ege::PhysicsShape::type getType() {
return ege::PhysicsShape::capsule;
};
private:
float m_radius;
public:
float getRadius(void) const {
float getRadius() const {
return m_radius;
};
private:
float m_height;
public:
float getHeight(void) const {
float getHeight() const {
return m_height;
};
public:
virtual const ege::PhysicsCapsule* toCapsule(void) const {
virtual const ege::PhysicsCapsule* toCapsule() const {
return this;
};
virtual ege::PhysicsCapsule* toCapsule(void) {
virtual ege::PhysicsCapsule* toCapsule() {
return this;
};
};

16
ege/physicsShape/PhysicsCone.h
View File

@ -17,32 +17,32 @@
namespace ege {
class PhysicsCone : public ege::PhysicsShape {
public:
PhysicsCone(void) {};
virtual ~PhysicsCone(void) {};
PhysicsCone() {};
virtual ~PhysicsCone() {};
public:
virtual bool parse(const char* _line);
virtual void display(void) {};
virtual void display() {};
public:
virtual enum ege::PhysicsShape::type getType(void) {
virtual enum ege::PhysicsShape::type getType() {
return ege::PhysicsShape::cone;
};
private:
float m_radius;
public:
float getRadius(void) const {
float getRadius() const {
return m_radius;
};
private:
float m_height;
public:
float getHeight(void) const {
float getHeight() const {
return m_height;
};
public:
virtual const ege::PhysicsCone* toCone(void) const {
virtual const ege::PhysicsCone* toCone() const {
return this;
};
virtual ege::PhysicsCone* toCone(void) {
virtual ege::PhysicsCone* toCone() {
return this;
};
};

16
ege/physicsShape/PhysicsConvexHull.h
View File

@ -17,32 +17,32 @@
namespace ege {
class PhysicsConvexHull : public ege::PhysicsShape {
public:
PhysicsConvexHull(void) {};
virtual ~PhysicsConvexHull(void) {};
PhysicsConvexHull() {};
virtual ~PhysicsConvexHull() {};
public:
virtual bool parse(const char* _line);
virtual void display(void) {};
virtual void display() {};
public:
virtual enum ege::PhysicsShape::type getType(void) {
virtual enum ege::PhysicsShape::type getType() {
return ege::PhysicsShape::convexHull;
};
private:
vec3 m_scale;
public:
vec3 getScale(void) const {
vec3 getScale() const {
return m_scale;
};
private:
std::vector<vec3> m_points;
public:
const std::vector<vec3>& getPointList(void) const {
const std::vector<vec3>& getPointList() const {
return m_points;
};
public:
virtual const ege::PhysicsConvexHull* toConvexHull(void) const {
virtual const ege::PhysicsConvexHull* toConvexHull() const {
return this;
};
virtual ege::PhysicsConvexHull* toConvexHull(void) {
virtual ege::PhysicsConvexHull* toConvexHull() {
return this;
};
};

14
ege/physicsShape/PhysicsCylinder.h
View File

@ -17,26 +17,26 @@
namespace ege {
class PhysicsCylinder : public ege::PhysicsShape {
public:
PhysicsCylinder(void) {};
virtual ~PhysicsCylinder(void) {};
PhysicsCylinder() {};
virtual ~PhysicsCylinder() {};
public:
virtual bool parse(const char* _line);
virtual void display(void) {};
virtual void display() {};
public:
virtual enum ege::PhysicsShape::type getType(void) {
virtual enum ege::PhysicsShape::type getType() {
return ege::PhysicsShape::cylinder;
};
private:
vec3 m_size;
public:
vec3 getSize(void) const {
vec3 getSize() const {
return m_size;
};
public:
virtual const ege::PhysicsCylinder* toCylinder(void) const {
virtual const ege::PhysicsCylinder* toCylinder() const {
return this;
};
virtual ege::PhysicsCylinder* toCylinder(void) {
virtual ege::PhysicsCylinder* toCylinder() {
return this;
};
};

48
ege/physicsShape/PhysicsShape.h
View File

@ -38,95 +38,95 @@ namespace ege {
sphere
};
public:
PhysicsShape(void) :
PhysicsShape() :
m_quaternion(1,0,0,0),
m_origin(0,0,0) {
};
virtual ~PhysicsShape(void) {
virtual ~PhysicsShape() {
};
public:
virtual enum ege::PhysicsShape::type getType(void) {
virtual enum ege::PhysicsShape::type getType() {
return ege::PhysicsShape::unknow;
};
public:
virtual bool parse(const char* _line);
virtual void display(void) {
virtual void display() {
};
private:
vec4 m_quaternion;
public:
const vec4& getQuaternion(void) const {
const vec4& getQuaternion() const {
return m_quaternion;
};
private:
vec3 m_origin;
public:
const vec3& getOrigin(void) const {
const vec3& getOrigin() const {
return m_origin;
};
public:
bool isBox(void) {
bool isBox() {
return getType() == ege::PhysicsShape::box;
};
bool isCylinder(void) {
bool isCylinder() {
return getType() == ege::PhysicsShape::cylinder;
};
bool isCapsule(void) {
bool isCapsule() {
return getType() == ege::PhysicsShape::capsule;
};
bool isCone(void) {
bool isCone() {
return getType() == ege::PhysicsShape::cone;
};
bool isConvexHull(void) {
bool isConvexHull() {
return getType() == ege::PhysicsShape::convexHull;
};
bool isSphere(void) {
bool isSphere() {
return getType() == ege::PhysicsShape::sphere;
};
virtual const ege::PhysicsBox* toBox(void) const {
virtual const ege::PhysicsBox* toBox() const {
return NULL;
};
virtual ege::PhysicsBox* toBox(void) {
virtual ege::PhysicsBox* toBox() {
return NULL;
};
virtual const ege::PhysicsCylinder* toCylinder(void) const {
virtual const ege::PhysicsCylinder* toCylinder() const {
return NULL;
};
virtual ege::PhysicsCylinder* toCylinder(void) {
virtual ege::PhysicsCylinder* toCylinder() {
return NULL;
};
virtual const ege::PhysicsCapsule* toCapsule(void) const {
virtual const ege::PhysicsCapsule* toCapsule() const {
return NULL;
};
virtual ege::PhysicsCapsule* toCapsule(void) {
virtual ege::PhysicsCapsule* toCapsule() {
return NULL;
};
virtual const ege::PhysicsCone* toCone(void) const {
virtual const ege::PhysicsCone* toCone() const {
return NULL;
};
virtual ege::PhysicsCone* toCone(void) {
virtual ege::PhysicsCone* toCone() {
return NULL;
};
virtual const ege::PhysicsConvexHull* toConvexHull(void) const {
virtual const ege::PhysicsConvexHull* toConvexHull() const {
return NULL;
};
virtual ege::PhysicsConvexHull* toConvexHull(void) {
virtual ege::PhysicsConvexHull* toConvexHull() {
return NULL;
};
virtual const ege::PhysicsSphere* toSphere(void) const {
virtual const ege::PhysicsSphere* toSphere() const {
return NULL;
};
virtual ege::PhysicsSphere* toSphere(void) {
virtual ege::PhysicsSphere* toSphere() {
return NULL;
};
};

14
ege/physicsShape/PhysicsSphere.h
View File

@ -17,26 +17,26 @@
namespace ege {
class PhysicsSphere : public ege::PhysicsShape {
public:
PhysicsSphere(void) {};
virtual ~PhysicsSphere(void) {};
PhysicsSphere() {};
virtual ~PhysicsSphere() {};
public:
virtual bool parse(const char* _line);
virtual void display(void) {};
virtual void display() {};
public:
virtual enum ege::PhysicsShape::type getType(void) {
virtual enum ege::PhysicsShape::type getType() {
return ege::PhysicsShape::sphere;
};
private:
float m_radius; // props["radius"] = obj.scale.x
public:
float getRadius(void) const {
float getRadius() const {
return m_radius;
};
private:
virtual const ege::PhysicsSphere* toSphere(void) const {
virtual const ege::PhysicsSphere* toSphere() const {
return this;
};
virtual ege::PhysicsSphere* toSphere(void) {
virtual ege::PhysicsSphere* toSphere() {
return this;
};
};

8
ege/resource/Mesh.cpp
View File

@ -65,7 +65,7 @@ ege::resource::Mesh::Mesh(const std::string& _fileName, const std::string& _shad
}
}
ege::resource::Mesh::~Mesh(void) {
ege::resource::Mesh::~Mesh() {
// remove dynamics dependencies :
ewol::resource::Program::release(m_GLprogram);
ewol::resource::VirtualBufferObject::release(m_verticesVBO);
@ -178,7 +178,7 @@ void ege::resource::Mesh::draw(mat4& _positionMatrix,
}
// normal calculation of the normal face is really easy :
void ege::resource::Mesh::calculateNormaleFace(void) {
void ege::resource::Mesh::calculateNormaleFace() {
m_listFacesNormal.clear();
if (m_normalMode != ege::resource::Mesh::normalModeFace) {
std::vector<Face>& tmpFaceList = m_listFaces.getValue(0).m_faces;
@ -192,7 +192,7 @@ void ege::resource::Mesh::calculateNormaleFace(void) {
}
}
void ege::resource::Mesh::calculateNormaleEdge(void) {
void ege::resource::Mesh::calculateNormaleEdge() {
m_listVertexNormal.clear();
if (m_normalMode != ege::resource::Mesh::normalModeVertex) {
for(size_t iii=0 ; iii<m_listVertex.size() ; iii++) {
@ -221,7 +221,7 @@ void ege::resource::Mesh::calculateNormaleEdge(void) {
//#define PRINT_HALF (1)
//#define TRY_MINIMAL_VBO
void ege::resource::Mesh::generateVBO(void) {
void ege::resource::Mesh::generateVBO() {
// calculate the normal of all faces if needed
if (m_normalMode == ege::resource::Mesh::normalModeNone) {
// when no normal detected == > auto generate Face normal ....

16
ege/resource/Mesh.h
View File

@ -40,7 +40,7 @@ namespace ege {
int32_t m_uv[3];
int32_t m_normal[3];
public:
Face(void) {};
Face() {};
Face(int32_t v1, int32_t t1,
int32_t v2, int32_t t2,
int32_t v3, int32_t t3) {
@ -113,7 +113,7 @@ namespace ege {
ewol::resource::VirtualBufferObject* m_verticesVBO;
protected:
Mesh(const std::string& _fileName, const std::string& _shaderName="DATA:textured3D2.prog");
virtual ~Mesh(void);
virtual ~Mesh();
public:
virtual void draw(mat4& _positionMatrix, bool _enableDepthTest=true, bool _enableDepthUpdate=true);
virtual void draw(mat4& _positionMatrix,
@ -122,10 +122,10 @@ namespace ege {
bool _enableDepthUpdate = true) {
draw(_positionMatrix, _enableDepthTest, _enableDepthUpdate);
}
void generateVBO(void);
void generateVBO();
private:
void calculateNormaleFace(void);
void calculateNormaleEdge(void);
void calculateNormaleFace();
void calculateNormaleEdge();
public :
void createViewBox(const std::string& _materialName,float _size=1.0);
private:
@ -145,10 +145,10 @@ namespace ege {
* @brief get the check value of normal position befor sending it to the openGl card
* @return get the chcking stus of normal or not
*/
bool getCheckNormal(void) {
bool getCheckNormal() {
return m_checkNormal;
};
const std::vector<ege::PhysicsShape*>& getPhysicalProperties(void) const {
const std::vector<ege::PhysicsShape*>& getPhysicalProperties() const {
return m_physics;
};
private:
@ -163,7 +163,7 @@ namespace ege {
* @brief get the pointer on the shame (no type)
* @return Pointer on shape.
*/
void* getShape(void) {
void* getShape() {
return m_pointerShape;
};
private:

2
ege/resource/ParticuleMesh.cpp
View File

@ -18,7 +18,7 @@ ege::resource::ParticuleMesh::ParticuleMesh(const std::string& _fileName, const
}
}
ege::resource::ParticuleMesh::~ParticuleMesh(void)
ege::resource::ParticuleMesh::~ParticuleMesh()
{
}

2
ege/resource/ParticuleMesh.h
View File

@ -18,7 +18,7 @@ namespace ege {
int32_t m_GLMainColor;
protected:
ParticuleMesh(const std::string& _fileName, const std::string& _shaderName);
virtual ~ParticuleMesh(void);
virtual ~ParticuleMesh();
public:
virtual void draw(mat4& _positionMatrix,
const etk::Color<float>& _mainColor,

6
ege/widget/Mesh.cpp
View File

@ -38,11 +38,11 @@ ege::widget::Mesh::Mesh(const std::string& _filename) :
}
}
ege::widget::Mesh::~Mesh(void) {
ege::widget::Mesh::~Mesh() {
ege::resource::Mesh::release(m_object);
}
void ege::widget::Mesh::onDraw(void) {
void ege::widget::Mesh::onDraw() {
mat4 transformationMatrix = etk::matTranslate(vec3(0,0,-m_cameraDistance))
* etk::matTranslate(m_position)
* etk::matRotate(vec3(1,0,0),m_angle.x())
@ -72,7 +72,7 @@ void ege::widget::Mesh::systemDraw(const ewol::DrawProperty& _displayProp) {
ewol::openGL::pop();
}
void ege::widget::Mesh::onRegenerateDisplay(void) {
void ege::widget::Mesh::onRegenerateDisplay() {
if (true == needRedraw()) {
}

6
ege/widget/Mesh.h
View File

@ -33,11 +33,11 @@ namespace ege {
float m_cameraDistance;
public:
Mesh(const std::string& _filename); // automatic considering in the appl Data older
virtual ~Mesh(void);
virtual ~Mesh();
public: // Derived function
virtual void onRegenerateDisplay(void);
virtual void onRegenerateDisplay();
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual void onDraw(void);
virtual void onDraw();
virtual bool onEventInput(const ewol::event::Input& _event);
virtual void periodicCall(const ewol::event::Time& _event);
public:

14
ege/widget/Scene.cpp
View File

@ -112,7 +112,7 @@ void ege::widget::Scene::setCamera(ege::Camera* _camera) {
}
}
ege::widget::Scene::~Scene(void) {
ege::widget::Scene::~Scene() {
ewol::resource::Colored3DObject::release(m_debugDrawing);
/*
ewol::resource::release(m_directDrawObject);
@ -136,23 +136,23 @@ ege::widget::Scene::~Scene(void) {
*/
}
void ege::widget::Scene::onRegenerateDisplay(void) {
void ege::widget::Scene::onRegenerateDisplay() {
if (true == needRedraw()) {
}
}
void ege::widget::Scene::pause(void) {
void ege::widget::Scene::pause() {
EGE_DEBUG("Set pause");
m_isRunning = false;
}
void ege::widget::Scene::resume(void) {
void ege::widget::Scene::resume() {
EGE_DEBUG("Set resume");
m_isRunning = true;
}
void ege::widget::Scene::pauseToggle(void) {
void ege::widget::Scene::pauseToggle() {
if(true == m_isRunning) {
EGE_DEBUG("Set Toggle: pause");
m_isRunning=false;
@ -173,7 +173,7 @@ void ege::widget::Scene::pauseToggle(void) {
#define NUMBER_OF_SUB_PASS (0)
void ege::widget::Scene::onDraw(void) {
void ege::widget::Scene::onDraw() {
#ifdef SCENE_DISPLAY_SPEED
g_counterNbTimeDisplay++;
g_startTime = ewol::getTime();
@ -230,7 +230,7 @@ void ege::widget::Scene::onDraw(void) {
}
// I really does not know what is this ...
btRigidBody& btActionInterface::getFixedBody(void) {
btRigidBody& btActionInterface::getFixedBody() {
static btRigidBody s_fixed(0, 0,0);
s_fixed.setMassProps(btScalar(0.),btVector3(btScalar(0.),btScalar(0.),btScalar(0.)));
return s_fixed;

16
ege/widget/Scene.h
View File

@ -50,7 +50,7 @@ namespace ege {
/**
* @brief Destructor of the widget classes
*/
virtual ~Scene(void);
virtual ~Scene();
void setBulletConfig(btDefaultCollisionConfiguration* _collisionConfiguration=NULL,
btCollisionDispatcher* _dispatcher=NULL,
btBroadphaseInterface* _broadphase=NULL,
@ -78,15 +78,15 @@ namespace ege {
/**
* @brief set the scene in pause for a while
*/
void pause(void);
void pause();
/**
* @brief resume the scene activity
*/
void resume(void);
void resume();
/**
* @brief Toggle between pause and running
*/
void pauseToggle(void);
void pauseToggle();
protected:
bool m_debugMode;
ewol::resource::Colored3DObject* m_debugDrawing; //!< for the debug draw elements
@ -94,7 +94,7 @@ namespace ege {
/**
* @brief Toggle the debug mode == > usefull for DEBUG only ...
*/
void debugToggle(void) {
void debugToggle() {
m_debugMode = m_debugMode?false:true;
};
protected:
@ -106,7 +106,7 @@ namespace ege {
/**
* @brief get the current camera reference for the scene rendering
*/
ege::Camera& getCamera(void) {
ege::Camera& getCamera() {
return *m_camera;
};
/**
@ -132,10 +132,10 @@ namespace ege {
std::vector<ege::Environement::ResultNearestElement>& _resultList);
protected: // Derived function
virtual void onDraw(void);
virtual void onDraw();
public: // Derived function
virtual void systemDraw(const ewol::DrawProperty& _displayProp);
virtual void onRegenerateDisplay(void);
virtual void onRegenerateDisplay();
virtual void periodicCall(const ewol::event::Time& _event);
};
};