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

[DOC] nearly finish the basic documentation

Browse Source
This commit is contained in:
Edouard DUPIN 2016-04-03 23:20:37 +02:00
parent dc853d574f
commit 5f287ebdfe
28 changed files with 1455 additions and 938 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
etk/Color.cpp
View File

@ -15,9 +15,6 @@
#include <sstream>
#include <stdexcept>
#undef __class__
#define __class__ "Color"
typedef struct {
const char * colorName;
etk::Color<> color;

434
etk/Color.h
View File

@ -20,20 +20,21 @@ namespace etk {
* For example :
* - Graphic application use:
* - Image in 3/4 bytes for rgb(a)
* - Color description in char : '#F6780FFF' or the equivalent number:0xF6780FFF
* - Color description in char : '\#F6780FFF' or the equivalent number:0xF6780FFF
* - middleware will mainely use a the 4 separate value with 1 byte for each.
* - graphic interface (openGL) store image in 1/2/3/4 bytes color and interpolate it in 'n' float. And note that the user color is sored in float.
*
* Then with this class we abstract the transformation format and set an easy same way to use the color independing of the developpement level.
*
* Some of the basic color is defined in the namespace: [namespace[etk::color]].
* Some of the basic color is defined in the namespace: @ref etk::color.
*
* @template-param MY_TYPE Type of the internal template value. The generic value is uint8_t and float
* @param[in] MY_TYPE Type of the internal template value. The generic value is uint8_t and float
* @param[in] MY_TYPE_SIZE Number of value in the color
*/
template<typename MY_TYPE=uint8_t, int MY_TYPE_SIZE=4> class Color {
public:
static const Color<MY_TYPE, MY_TYPE_SIZE> emptyColor; // to auto fill with no data in all case
static const MY_TYPE defaultAlpha;
static const Color<MY_TYPE, MY_TYPE_SIZE> emptyColor; //!< To auto fill with no data in all case
static const MY_TYPE defaultAlpha; //!< Default alpha value
private:
MY_TYPE m_element[MY_TYPE_SIZE]; //!< all the color.
public:
@ -51,15 +52,27 @@ namespace etk {
Color(MY_TYPE _r, MY_TYPE _g, MY_TYPE _b, MY_TYPE _a) {
set(_r, _g, _b, _a);
};
//! @previous
/**
* @brief Contructor with request initialisation.
* @param[in] _r Red color.
* @param[in] _g Green color.
* @param[in] _b Blue color.
*/
Color(MY_TYPE _r, MY_TYPE _g, MY_TYPE _b) {
set(_r, _g, _b);
};
//! @previous
/**
* @brief Contructor with request initialisation.
* @param[in] _r Red color.
* @param[in] _g Green color.
*/
Color(MY_TYPE _r, MY_TYPE _g) {
set(_r, _g);
};
//! @previous
/**
* @brief Contructor with request initialisation.
* @param[in] _r Red color.
*/
Color(MY_TYPE _r) {
set(_r);
};
@ -80,7 +93,7 @@ namespace etk {
* @return reference on this element.
*/
Color<MY_TYPE,MY_TYPE_SIZE>& operator=(const etk::Color<MY_TYPE,MY_TYPE_SIZE>& _input) {
for (size_t iii=0; iii<MY_TYPE_SIZE; ++iii) {
for (size_t iii=0; iii<MY_TYPE_SIZE;iii) {
m_element[iii] = _input.m_element[iii];
}
return *this;
@ -92,7 +105,7 @@ namespace etk {
* @return false This is the same color.
*/
bool operator!= (const etk::Color<MY_TYPE,MY_TYPE_SIZE>& _obj) const {
for (size_t iii=0; iii<MY_TYPE_SIZE; ++iii) {
for (size_t iii=0; iii<MY_TYPE_SIZE;iii) {
if(m_element[iii] != _obj.m_element[iii]) {
return true;
}
@ -106,7 +119,7 @@ namespace etk {
* @return false The color are different.
*/
bool operator== (const etk::Color<MY_TYPE,MY_TYPE_SIZE>& _obj) const {
for (size_t iii=0; iii<MY_TYPE_SIZE; ++iii) {
for (size_t iii=0; iii<MY_TYPE_SIZE;iii) {
if(m_element[iii] != _obj.m_element[iii]) {
return false;
}
@ -114,7 +127,7 @@ namespace etk {
return true;
}
/**
* @breif Get the Generic uint32_t value of the color
* @brief Get the Generic uint32_t value of the color
* @return Color in unsigned integer
*/
uint32_t get() const;
@ -139,7 +152,12 @@ namespace etk {
m_element[3] = _a;
}
};
//! @previous
/**
* @brief Set the specified color elements.
* @param[in] _r Red color.
* @param[in] _g Green color.
* @param[in] _b Blue color.
*/
void set(MY_TYPE _r, MY_TYPE _g, MY_TYPE _b) {
if (MY_TYPE_SIZE >= 1) {
m_element[0] = _r;
@ -154,7 +172,11 @@ namespace etk {
m_element[3] = defaultAlpha;
}
};
//! @previous
/**
* @brief Set the specified color elements.
* @param[in] _r Red color.
* @param[in] _g Green color.
*/
void set(MY_TYPE _r, MY_TYPE _g) {
if (MY_TYPE_SIZE >= 1) {
m_element[0] = _r;
@ -169,7 +191,10 @@ namespace etk {
m_element[3] = defaultAlpha;
}
};
//! @previous
/**
* @brief Set the specified color elements.
* @param[in] _r Red color.
*/
void set(MY_TYPE _r) {
if (MY_TYPE_SIZE >= 1) {
m_element[0] = _r;
@ -282,9 +307,11 @@ namespace etk {
m_element[3] = MY_TYPE(_a);
}
};
/* ****************************************************
* += operator
*****************************************************/
/**
* @brief Operator+= Addition an other etk::color with this one
* @param[in] _obj Reference on the external object
* @return Local reference of the vector additionned
*/
const etk::Color<MY_TYPE,MY_TYPE_SIZE>& operator+= (const etk::Color<MY_TYPE,MY_TYPE_SIZE>& _obj) {
if (MY_TYPE_SIZE >= 1) {
m_element[0] += _obj.m_element[0];
@ -300,18 +327,22 @@ namespace etk {
}
return *this;
}
/* ****************************************************
* + operator
*****************************************************/
/**
* @brief Operator+ Addition an other etk::color with this one
* @param[in] _obj Reference on the external object
* @return New vector containing the value
*/
etk::Color<MY_TYPE,MY_TYPE_SIZE> operator+ (const etk::Color<MY_TYPE,MY_TYPE_SIZE>& _obj) const {
etk::Color<MY_TYPE,MY_TYPE_SIZE> tmpp(*this);
tmpp += _obj;
return tmpp;
}
/* ****************************************************
* *= operator
*****************************************************/
const etk::Color<MY_TYPE,MY_TYPE_SIZE>& operator*= (const etk::Color<MY_TYPE,MY_TYPE_SIZE>& _obj) {
/**
* @brief Operator*= Multiply 2 color together
* @param[in] _obj Reference on the external object
* @return Local reference of the vector
*/
etk::Color<MY_TYPE,MY_TYPE_SIZE>& operator*= (const etk::Color<MY_TYPE,MY_TYPE_SIZE>& _obj) {
if (MY_TYPE_SIZE >= 1) {
m_element[0] *= _obj.m_element[0];
}
@ -326,7 +357,12 @@ namespace etk {
}
return *this;
}
const etk::Color<MY_TYPE,MY_TYPE_SIZE>& operator*= (const MY_TYPE _val) {
/**
* @brief Operator*= Multiply the color With a specific value
* @param[in] _val Value to multiply the color
* @return Local reference of the vector
*/
etk::Color<MY_TYPE,MY_TYPE_SIZE>& operator*= (const MY_TYPE _val) {
if (MY_TYPE_SIZE >= 1) {
m_element[0] *= _val;
}
@ -341,28 +377,72 @@ namespace etk {
}
return *this;
}
/* ****************************************************
* * operator
*****************************************************/
/**
* @brief Operator*= Multiply 2 color together
* @param[in] _obj Reference on the external object
* @return New vector containing the value
*/
etk::Color<MY_TYPE,MY_TYPE_SIZE> operator* (const etk::Color<MY_TYPE,MY_TYPE_SIZE>& _obj) const {
etk::Color<MY_TYPE,MY_TYPE_SIZE> tmpp(*this);
tmpp *= _obj;
return tmpp;
}
/**
* @brief Operator*= Multiply the color With a specific value
* @param[in] _val Value to multiply the color
* @return New vector containing the value
*/
etk::Color<MY_TYPE,MY_TYPE_SIZE> operator* (const MY_TYPE _val) const {
etk::Color<MY_TYPE,MY_TYPE_SIZE> tmpp(*this);
tmpp *= _val;
return tmpp;
}
};
/**
* @brief Get a color value started with a "#"
* @param[in] _input String to parse
* @return Value parsed
*/
etk::Color<uint8_t, 4> parseStringStartWithSharp(const std::string& _input);
/**
* @brief Get a color value started with a "rgb()" converted in uint8
* @param[in] _input String to parse
* @return Value parsed
*/
etk::Color<uint8_t, 4> parseStringStartWithRGBGen(const std::string& _input);
/**
* @brief Get a color value started with a "rgb()" keep in double
* @param[in] _input String to parse
* @return Value parsed
*/
etk::Color<double, 4> parseStringStartWithRGB(const std::string& _input);
/**
* @brief Get a color value started with a "rgb()" converted in uint32
* @param[in] _input String to parse
* @return Value parsed
*/
etk::Color<uint32_t, 4> parseStringStartWithRGBUnsigned32(const std::string& _input);
/**
* @brief Get a color value started with a "rgb()" converted in uint16
* @param[in] _input String to parse
* @return Value parsed
*/
etk::Color<uint16_t, 4> parseStringStartWithRGBUnsigned16(const std::string& _input);
/**
* @brief Get a color value started with a "rgb()" converted in uint6
* @param[in] _input String to parse
* @return Value parsed
*/
etk::Color<uint8_t, 4> parseStringStartWithRGBUnsigned8(const std::string& _input);
/**
* @brief Get a color value started with a "named" converted in uint8 like red, geen ...
* @param[in] _input String to parse
* @return Value parsed
*/
etk::Color<uint8_t, 4> parseStringColorNamed(const std::string& _input);
//! @not_in_doc
template<> uint32_t Color<uint8_t, 4>::get() const;
template<typename MY_TYPE, int MY_TYPE_SIZE> uint32_t Color<MY_TYPE, MY_TYPE_SIZE>::get() const {
@ -565,7 +645,7 @@ namespace etk {
}
//! @not_in_doc
template<typename MY_TYPE, int MY_TYPE_SIZE> std::ostream& operator <<(std::ostream& _os, const std::vector<Color<MY_TYPE, MY_TYPE_SIZE> >& _obj) {
for (size_t iii = 0; iii < _obj.size(); ++iii) {
for (size_t iii = 0; iii < _obj.size();iii) {
if (iii != 0) {
_os << " ";
}
@ -579,153 +659,153 @@ namespace etk {
*/
namespace color {
extern const Color<> none; //!< No color (alpha = 0)
extern const Color<> aliceBlue; //!< ++ [color=aliceBlue] aliceBlue color [/color] ++
extern const Color<> antiqueWhite; //!< ++ [color=antiqueWhite] antiqueWhite color [/color] ++
extern const Color<> aqua; //!< ++ [color=aqua] aqua color [/color] ++
extern const Color<> aquamarine; //!< ++ [color=aquamarine] aquamarine color [/color] ++
extern const Color<> azure; //!< ++ [color=azure] azure color [/color] ++
extern const Color<> beige; //!< ++ [color=beige] beige color [/color] ++
extern const Color<> bisque; //!< ++ [color=bisque] bisque color [/color] ++
extern const Color<> black; //!< ++ [color=black] black color [/color] ++
extern const Color<> blanchedAlmond; //!< ++ [color=blanchedAlmond] blanchedAlmond color [/color] ++
extern const Color<> blue; //!< ++ [color=blue] blue color [/color] ++
extern const Color<> blueViolet; //!< ++ [color=blueViolet] blueViolet color [/color] ++
extern const Color<> brown; //!< ++ [color=brown] brown color [/color] ++
extern const Color<> burlyWood; //!< ++ [color=burlyWood] burlyWood color [/color] ++
extern const Color<> cadetBlue; //!< ++ [color=cadetBlue] cadetBlue color [/color] ++
extern const Color<> chartreuse; //!< ++ [color=chartreuse] chartreuse color [/color] ++
extern const Color<> chocolate; //!< ++ [color=chocolate] chocolate color [/color] ++
extern const Color<> coral; //!< ++ [color=coral] coral color [/color] ++
extern const Color<> cornflowerBlue; //!< ++ [color=cornflowerBlue] cornflowerBlue color [/color] ++
extern const Color<> cornsilk; //!< ++ [color=cornsilk] cornsilk color [/color] ++
extern const Color<> crimson; //!< ++ [color=crimson] crimson color [/color] ++
extern const Color<> cyan; //!< ++ [color=cyan] cyan color [/color] ++
extern const Color<> darkBlue; //!< ++ [color=darkBlue] darkBlue color [/color] ++
extern const Color<> darkCyan; //!< ++ [color=darkCyan] darkCyan color [/color] ++
extern const Color<> darkGoldenRod; //!< ++ [color=darkGoldenRod] darkGoldenRod color [/color] ++
extern const Color<> darkGray; //!< ++ [color=darkGray] darkGray color [/color] ++
extern const Color<> darkGrey; //!< ++ [color=darkGrey] darkGrey color [/color] ++
extern const Color<> darkGreen; //!< ++ [color=darkGreen] darkGreen color [/color] ++
extern const Color<> darkKhaki; //!< ++ [color=darkKhaki] darkKhaki color [/color] ++
extern const Color<> darkMagenta; //!< ++ [color=darkMagenta] darkMagenta color [/color] ++
extern const Color<> darkOliveGreen; //!< ++ [color=darkOliveGreen] darkOliveGreen color [/color] ++
extern const Color<> darkorange; //!< ++ [color=darkorange] darkorange color [/color] ++
extern const Color<> darkOrchid; //!< ++ [color=darkOrchid] darkOrchid color [/color] ++
extern const Color<> darkRed; //!< ++ [color=darkRed] darkRed color [/color] ++
extern const Color<> darkSalmon; //!< ++ [color=darkSalmon] darkSalmon color [/color] ++
extern const Color<> darkSeaGreen; //!< ++ [color=darkSeaGreen] darkSeaGreen color [/color] ++
extern const Color<> darkSlateBlue; //!< ++ [color=darkSlateBlue] darkSlateBlue color [/color] ++
extern const Color<> darkSlateGray; //!< ++ [color=darkSlateGray] darkSlateGray color [/color] ++
extern const Color<> darkSlateGrey; //!< ++ [color=darkSlateGrey] darkSlateGrey color [/color] ++
extern const Color<> darkTurquoise; //!< ++ [color=darkTurquoise] darkTurquoise color [/color] ++
extern const Color<> darkViolet; //!< ++ [color=darkViolet] darkViolet color [/color] ++
extern const Color<> deepPink; //!< ++ [color=deepPink] deepPink color [/color] ++
extern const Color<> deepSkyBlue; //!< ++ [color=deepSkyBlue] deepSkyBlue color [/color] ++
extern const Color<> dimGray; //!< ++ [color=dimGray] dimGray color [/color] ++
extern const Color<> dimGrey; //!< ++ [color=dimGrey] dimGrey color [/color] ++
extern const Color<> dodgerBlue; //!< ++ [color=dodgerBlue] dodgerBlue color [/color] ++
extern const Color<> fireBrick; //!< ++ [color=fireBrick] fireBrick color [/color] ++
extern const Color<> floralWhite; //!< ++ [color=floralWhite] floralWhite color [/color] ++
extern const Color<> forestGreen; //!< ++ [color=forestGreen] forestGreen color [/color] ++
extern const Color<> fuchsia; //!< ++ [color=fuchsia] fuchsia color [/color] ++
extern const Color<> gainsboro; //!< ++ [color=gainsboro] gainsboro color [/color] ++
extern const Color<> ghostWhite; //!< ++ [color=ghostWhite] ghostWhite color [/color] ++
extern const Color<> gold; //!< ++ [color=gold] gold color [/color] ++
extern const Color<> goldenRod; //!< ++ [color=goldenRod] goldenRod color [/color] ++
extern const Color<> gray; //!< ++ [color=gray] gray color [/color] ++
extern const Color<> grey; //!< ++ [color=grey] grey color [/color] ++
extern const Color<> green; //!< ++ [color=green] green color [/color] ++
extern const Color<> greenYellow; //!< ++ [color=greenYellow] greenYellow color [/color] ++
extern const Color<> honeyDew; //!< ++ [color=honeyDew] honeyDew color [/color] ++
extern const Color<> hotPink; //!< ++ [color=hotPink] hotPink color [/color] ++
extern const Color<> indianRed; //!< ++ [color=indianRed] indianRed color [/color] ++
extern const Color<> indigo; //!< ++ [color=indigo] indigo color [/color] ++
extern const Color<> ivory; //!< ++ [color=ivory] ivory color [/color] ++
extern const Color<> khaki; //!< ++ [color=khaki] khaki color [/color] ++
extern const Color<> lavender; //!< ++ [color=lavender] lavender color [/color] ++
extern const Color<> lavenderBlush; //!< ++ [color=lavenderBlush] lavenderBlush color [/color] ++
extern const Color<> lawnGreen; //!< ++ [color=lawnGreen] lawnGreen color [/color] ++
extern const Color<> lemonChiffon; //!< ++ [color=lemonChiffon] lemonChiffon color [/color] ++
extern const Color<> lightBlue; //!< ++ [color=lightBlue] lightBlue color [/color] ++
extern const Color<> lightCoral; //!< ++ [color=lightCoral] lightCoral color [/color] ++
extern const Color<> lightCyan; //!< ++ [color=lightCyan] lightCyan color [/color] ++
extern const Color<> lightGoldenRodYellow; //!< ++ [color=lightGoldenRodYellow] lightGoldenRodYellow color [/color] ++
extern const Color<> lightGray; //!< ++ [color=lightGray] lightGray color [/color] ++
extern const Color<> lightGrey; //!< ++ [color=lightGrey] lightGrey color [/color] ++
extern const Color<> lightGreen; //!< ++ [color=lightGreen] lightGreen color [/color] ++
extern const Color<> lightPink; //!< ++ [color=lightPink] lightPink color [/color] ++
extern const Color<> lightSalmon; //!< ++ [color=lightSalmon] lightSalmon color [/color] ++
extern const Color<> lightSeaGreen; //!< ++ [color=lightSeaGreen] lightSeaGreen color [/color] ++
extern const Color<> lightSkyBlue; //!< ++ [color=lightSkyBlue] lightSkyBlue color [/color] ++
extern const Color<> lightSlateGray; //!< ++ [color=lightSlateGray] lightSlateGray color [/color] ++
extern const Color<> lightSlateGrey; //!< ++ [color=lightSlateGrey] lightSlateGrey color [/color] ++
extern const Color<> lightSteelBlue; //!< ++ [color=lightSteelBlue] lightSteelBlue color [/color] ++
extern const Color<> lightYellow; //!< ++ [color=lightYellow] lightYellow color [/color] ++
extern const Color<> lime; //!< ++ [color=lime] lime color [/color] ++
extern const Color<> limeGreen; //!< ++ [color=limeGreen] limeGreen color [/color] ++
extern const Color<> linen; //!< ++ [color=linen] linen color [/color] ++
extern const Color<> magenta; //!< ++ [color=magenta] magenta color [/color] ++
extern const Color<> maroon; //!< ++ [color=maroon] maroon color [/color] ++
extern const Color<> mediumAquaMarine; //!< ++ [color=mediumAquaMarine] mediumAquaMarine color [/color] ++
extern const Color<> mediumBlue; //!< ++ [color=mediumBlue] mediumBlue color [/color] ++
extern const Color<> mediumOrchid; //!< ++ [color=mediumOrchid] mediumOrchid color [/color] ++
extern const Color<> mediumPurple; //!< ++ [color=mediumPurple] mediumPurple color [/color] ++
extern const Color<> mediumSeaGreen; //!< ++ [color=mediumSeaGreen] mediumSeaGreen color [/color] ++
extern const Color<> mediumSlateBlue; //!< ++ [color=mediumSlateBlue] mediumSlateBlue color [/color] ++
extern const Color<> mediumSpringGreen; //!< ++ [color=mediumSpringGreen] mediumSpringGreen color [/color] ++
extern const Color<> mediumTurquoise; //!< ++ [color=mediumTurquoise] mediumTurquoise color [/color] ++
extern const Color<> mediumVioletRed; //!< ++ [color=mediumVioletRed] mediumVioletRed color [/color] ++
extern const Color<> midnightBlue; //!< ++ [color=midnightBlue] midnightBlue color [/color] ++
extern const Color<> mintCream; //!< ++ [color=mintCream] mintCream color [/color] ++
extern const Color<> mistyRose; //!< ++ [color=mistyRose] mistyRose color [/color] ++
extern const Color<> moccasin; //!< ++ [color=moccasin] moccasin color [/color] ++
extern const Color<> navajoWhite; //!< ++ [color=navajoWhite] navajoWhite color [/color] ++
extern const Color<> navy; //!< ++ [color=navy] navy color [/color] ++
extern const Color<> oldLace; //!< ++ [color=oldLace] oldLace color [/color] ++
extern const Color<> olive; //!< ++ [color=olive] olive color [/color] ++
extern const Color<> oliveDrab; //!< ++ [color=oliveDrab] oliveDrab color [/color] ++
extern const Color<> orange; //!< ++ [color=orange] orange color [/color] ++
extern const Color<> orangeRed; //!< ++ [color=orangeRed] orangeRed color [/color] ++
extern const Color<> orchid; //!< ++ [color=orchid] orchid color [/color] ++
extern const Color<> paleGoldenRod; //!< ++ [color=paleGoldenRod] paleGoldenRod color [/color] ++
extern const Color<> paleGreen; //!< ++ [color=paleGreen] paleGreen color [/color] ++
extern const Color<> paleTurquoise; //!< ++ [color=paleTurquoise] paleTurquoise color [/color] ++
extern const Color<> paleVioletRed; //!< ++ [color=paleVioletRed] paleVioletRed color [/color] ++
extern const Color<> papayaWhip; //!< ++ [color=papayaWhip] papayaWhip color [/color] ++
extern const Color<> peachPuff; //!< ++ [color=peachPuff] peachPuff color [/color] ++
extern const Color<> peru; //!< ++ [color=peru] peru color [/color] ++
extern const Color<> pink; //!< ++ [color=pink] pink color [/color] ++
extern const Color<> plum; //!< ++ [color=plum] plum color [/color] ++
extern const Color<> powderBlue; //!< ++ [color=powderBlue] powderBlue color [/color] ++
extern const Color<> purple; //!< ++ [color=purple] purple color [/color] ++
extern const Color<> red; //!< ++ [color=red] red color [/color] ++
extern const Color<> rosyBrown; //!< ++ [color=rosyBrown] rosyBrown color [/color] ++
extern const Color<> royalBlue; //!< ++ [color=royalBlue] royalBlue color [/color] ++
extern const Color<> saddleBrown; //!< ++ [color=saddleBrown] saddleBrown color [/color] ++
extern const Color<> salmon; //!< ++ [color=salmon] salmon color [/color] ++
extern const Color<> sandyBrown; //!< ++ [color=sandyBrown] sandyBrown color [/color] ++
extern const Color<> seaGreen; //!< ++ [color=seaGreen] seaGreen color [/color] ++
extern const Color<> seaShell; //!< ++ [color=seaShell] seaShell color [/color] ++
extern const Color<> sienna; //!< ++ [color=sienna] sienna color [/color] ++
extern const Color<> silver; //!< ++ [color=silver] silver color [/color] ++
extern const Color<> skyBlue; //!< ++ [color=skyBlue] skyBlue color [/color] ++
extern const Color<> slateBlue; //!< ++ [color=slateBlue] slateBlue color [/color] ++
extern const Color<> slateGray; //!< ++ [color=slateGray] slateGray color [/color] ++
extern const Color<> slateGrey; //!< ++ [color=slateGrey] slateGrey color [/color] ++
extern const Color<> snow; //!< ++ [color=snow] snow color [/color] ++
extern const Color<> springGreen; //!< ++ [color=springGreen] springGreen color [/color] ++
extern const Color<> steelBlue; //!< ++ [color=steelBlue] steelBlue color [/color] ++
extern const Color<> tan; //!< ++ [color=tan] tan color [/color] ++
extern const Color<> teal; //!< ++ [color=teal] teal color [/color] ++
extern const Color<> thistle; //!< ++ [color=thistle] thistle color [/color] ++
extern const Color<> tomato; //!< ++ [color=tomato] tomato color [/color] ++
extern const Color<> turquoise; //!< ++ [color=turquoise] turquoise color [/color] ++
extern const Color<> violet; //!< ++ [color=violet] violet color [/color] ++
extern const Color<> wheat; //!< ++ [color=wheat] wheat color [/color] ++
extern const Color<> white; //!< ++ [color=white] white color [/color] ++
extern const Color<> whiteSmoke; //!< ++ [color=whiteSmoke] whiteSmoke color [/color] ++
extern const Color<> yellow; //!< ++ [color=yellow] yellow color [/color] ++
extern const Color<> yellowGreen; //!< ++ [color=yellowGreen] yellowGreen color [/color] ++
extern const Color<> aliceBlue; //!< - <span class="color:aliceBlue"> aliceBlue color </span>
extern const Color<> antiqueWhite; //!< - <span class="color:antiqueWhite"> antiqueWhite color </span>
extern const Color<> aqua; //!< - <span class="color:aqua"> aqua color </span>
extern const Color<> aquamarine; //!< - <span class="color:aquamarine"> aquamarine color </span>
extern const Color<> azure; //!< - <span class="color:azure"> azure color </span>
extern const Color<> beige; //!< - <span class="color:beige"> beige color </span>
extern const Color<> bisque; //!< - <span class="color:bisque"> bisque color </span>
extern const Color<> black; //!< - <span class="color:black"> black color </span>
extern const Color<> blanchedAlmond; //!< - <span class="color:blanchedAlmond"> blanchedAlmond color </span>
extern const Color<> blue; //!< - <span class="color:blue"> blue color </span>
extern const Color<> blueViolet; //!< - <span class="color:blueViolet"> blueViolet color </span>
extern const Color<> brown; //!< - <span class="color:brown"> brown color </span>
extern const Color<> burlyWood; //!< - <span class="color:burlyWood"> burlyWood color </span>
extern const Color<> cadetBlue; //!< - <span class="color:cadetBlue"> cadetBlue color </span>
extern const Color<> chartreuse; //!< - <span class="color:chartreuse"> chartreuse color </span>
extern const Color<> chocolate; //!< - <span class="color:chocolate"> chocolate color </span>
extern const Color<> coral; //!< - <span class="color:coral"> coral color </span>
extern const Color<> cornflowerBlue; //!< - <span class="color:cornflowerBlue"> cornflowerBlue color </span>
extern const Color<> cornsilk; //!< - <span class="color:cornsilk"> cornsilk color </span>
extern const Color<> crimson; //!< - <span class="color:crimson"> crimson color </span>
extern const Color<> cyan; //!< - <span class="color:cyan"> cyan color </span>
extern const Color<> darkBlue; //!< - <span class="color:darkBlue"> darkBlue color </span>
extern const Color<> darkCyan; //!< - <span class="color:darkCyan"> darkCyan color </span>
extern const Color<> darkGoldenRod; //!< - <span class="color:darkGoldenRod"> darkGoldenRod color </span>
extern const Color<> darkGray; //!< - <span class="color:darkGray"> darkGray color </span>
extern const Color<> darkGrey; //!< - <span class="color:darkGrey"> darkGrey color </span>
extern const Color<> darkGreen; //!< - <span class="color:darkGreen"> darkGreen color </span>
extern const Color<> darkKhaki; //!< - <span class="color:darkKhaki"> darkKhaki color </span>
extern const Color<> darkMagenta; //!< - <span class="color:darkMagenta"> darkMagenta color </span>
extern const Color<> darkOliveGreen; //!< - <span class="color:darkOliveGreen"> darkOliveGreen color </span>
extern const Color<> darkorange; //!< - <span class="color:darkorange"> darkorange color </span>
extern const Color<> darkOrchid; //!< - <span class="color:darkOrchid"> darkOrchid color </span>
extern const Color<> darkRed; //!< - <span class="color:darkRed"> darkRed color </span>
extern const Color<> darkSalmon; //!< - <span class="color:darkSalmon"> darkSalmon color </span>
extern const Color<> darkSeaGreen; //!< - <span class="color:darkSeaGreen"> darkSeaGreen color </span>
extern const Color<> darkSlateBlue; //!< - <span class="color:darkSlateBlue"> darkSlateBlue color </span>
extern const Color<> darkSlateGray; //!< - <span class="color:darkSlateGray"> darkSlateGray color </span>
extern const Color<> darkSlateGrey; //!< - <span class="color:darkSlateGrey"> darkSlateGrey color </span>
extern const Color<> darkTurquoise; //!< - <span class="color:darkTurquoise"> darkTurquoise color </span>
extern const Color<> darkViolet; //!< - <span class="color:darkViolet"> darkViolet color </span>
extern const Color<> deepPink; //!< - <span class="color:deepPink"> deepPink color </span>
extern const Color<> deepSkyBlue; //!< - <span class="color:deepSkyBlue"> deepSkyBlue color </span>
extern const Color<> dimGray; //!< - <span class="color:dimGray"> dimGray color </span>
extern const Color<> dimGrey; //!< - <span class="color:dimGrey"> dimGrey color </span>
extern const Color<> dodgerBlue; //!< - <span class="color:dodgerBlue"> dodgerBlue color </span>
extern const Color<> fireBrick; //!< - <span class="color:fireBrick"> fireBrick color </span>
extern const Color<> floralWhite; //!< - <span class="color:floralWhite"> floralWhite color </span>
extern const Color<> forestGreen; //!< - <span class="color:forestGreen"> forestGreen color </span>
extern const Color<> fuchsia; //!< - <span class="color:fuchsia"> fuchsia color </span>
extern const Color<> gainsboro; //!< - <span class="color:gainsboro"> gainsboro color </span>
extern const Color<> ghostWhite; //!< - <span class="color:ghostWhite"> ghostWhite color </span>
extern const Color<> gold; //!< - <span class="color:gold"> gold color </span>
extern const Color<> goldenRod; //!< - <span class="color:goldenRod"> goldenRod color </span>
extern const Color<> gray; //!< - <span class="color:gray"> gray color </span>
extern const Color<> grey; //!< - <span class="color:grey"> grey color </span>
extern const Color<> green; //!< - <span class="color:green"> green color </span>
extern const Color<> greenYellow; //!< - <span class="color:greenYellow"> greenYellow color </span>
extern const Color<> honeyDew; //!< - <span class="color:honeyDew"> honeyDew color </span>
extern const Color<> hotPink; //!< - <span class="color:hotPink"> hotPink color </span>
extern const Color<> indianRed; //!< - <span class="color:indianRed"> indianRed color </span>
extern const Color<> indigo; //!< - <span class="color:indigo"> indigo color </span>
extern const Color<> ivory; //!< - <span class="color:ivory"> ivory color </span>
extern const Color<> khaki; //!< - <span class="color:khaki"> khaki color </span>
extern const Color<> lavender; //!< - <span class="color:lavender"> lavender color </span>
extern const Color<> lavenderBlush; //!< - <span class="color:lavenderBlush"> lavenderBlush color </span>
extern const Color<> lawnGreen; //!< - <span class="color:lawnGreen"> lawnGreen color </span>
extern const Color<> lemonChiffon; //!< - <span class="color:lemonChiffon"> lemonChiffon color </span>
extern const Color<> lightBlue; //!< - <span class="color:lightBlue"> lightBlue color </span>
extern const Color<> lightCoral; //!< - <span class="color:lightCoral"> lightCoral color </span>
extern const Color<> lightCyan; //!< - <span class="color:lightCyan"> lightCyan color </span>
extern const Color<> lightGoldenRodYellow; //!< - <span class="color:lightGoldenRodYellow"> lightGoldenRodYellow color </span>
extern const Color<> lightGray; //!< - <span class="color:lightGray"> lightGray color </span>
extern const Color<> lightGrey; //!< - <span class="color:lightGrey"> lightGrey color </span>
extern const Color<> lightGreen; //!< - <span class="color:lightGreen"> lightGreen color </span>
extern const Color<> lightPink; //!< - <span class="color:lightPink"> lightPink color </span>
extern const Color<> lightSalmon; //!< - <span class="color:lightSalmon"> lightSalmon color </span>
extern const Color<> lightSeaGreen; //!< - <span class="color:lightSeaGreen"> lightSeaGreen color </span>
extern const Color<> lightSkyBlue; //!< - <span class="color:lightSkyBlue"> lightSkyBlue color </span>
extern const Color<> lightSlateGray; //!< - <span class="color:lightSlateGray"> lightSlateGray color </span>
extern const Color<> lightSlateGrey; //!< - <span class="color:lightSlateGrey"> lightSlateGrey color </span>
extern const Color<> lightSteelBlue; //!< - <span class="color:lightSteelBlue"> lightSteelBlue color </span>
extern const Color<> lightYellow; //!< - <span class="color:lightYellow"> lightYellow color </span>
extern const Color<> lime; //!< - <span class="color:lime"> lime color </span>
extern const Color<> limeGreen; //!< - <span class="color:limeGreen"> limeGreen color </span>
extern const Color<> linen; //!< - <span class="color:linen"> linen color </span>
extern const Color<> magenta; //!< - <span class="color:magenta"> magenta color </span>
extern const Color<> maroon; //!< - <span class="color:maroon"> maroon color </span>
extern const Color<> mediumAquaMarine; //!< - <span class="color:mediumAquaMarine"> mediumAquaMarine color </span>
extern const Color<> mediumBlue; //!< - <span class="color:mediumBlue"> mediumBlue color </span>
extern const Color<> mediumOrchid; //!< - <span class="color:mediumOrchid"> mediumOrchid color </span>
extern const Color<> mediumPurple; //!< - <span class="color:mediumPurple"> mediumPurple color </span>
extern const Color<> mediumSeaGreen; //!< - <span class="color:mediumSeaGreen"> mediumSeaGreen color </span>
extern const Color<> mediumSlateBlue; //!< - <span class="color:mediumSlateBlue"> mediumSlateBlue color </span>
extern const Color<> mediumSpringGreen; //!< - <span class="color:mediumSpringGreen"> mediumSpringGreen color </span>
extern const Color<> mediumTurquoise; //!< - <span class="color:mediumTurquoise"> mediumTurquoise color </span>
extern const Color<> mediumVioletRed; //!< - <span class="color:mediumVioletRed"> mediumVioletRed color </span>
extern const Color<> midnightBlue; //!< - <span class="color:midnightBlue"> midnightBlue color </span>
extern const Color<> mintCream; //!< - <span class="color:mintCream"> mintCream color </span>
extern const Color<> mistyRose; //!< - <span class="color:mistyRose"> mistyRose color </span>
extern const Color<> moccasin; //!< - <span class="color:moccasin"> moccasin color </span>
extern const Color<> navajoWhite; //!< - <span class="color:navajoWhite"> navajoWhite color </span>
extern const Color<> navy; //!< - <span class="color:navy"> navy color </span>
extern const Color<> oldLace; //!< - <span class="color:oldLace"> oldLace color </span>
extern const Color<> olive; //!< - <span class="color:olive"> olive color </span>
extern const Color<> oliveDrab; //!< - <span class="color:oliveDrab"> oliveDrab color </span>
extern const Color<> orange; //!< - <span class="color:orange"> orange color </span>
extern const Color<> orangeRed; //!< - <span class="color:orangeRed"> orangeRed color </span>
extern const Color<> orchid; //!< - <span class="color:orchid"> orchid color </span>
extern const Color<> paleGoldenRod; //!< - <span class="color:paleGoldenRod"> paleGoldenRod color </span>
extern const Color<> paleGreen; //!< - <span class="color:paleGreen"> paleGreen color </span>
extern const Color<> paleTurquoise; //!< - <span class="color:paleTurquoise"> paleTurquoise color </span>
extern const Color<> paleVioletRed; //!< - <span class="color:paleVioletRed"> paleVioletRed color </span>
extern const Color<> papayaWhip; //!< - <span class="color:papayaWhip"> papayaWhip color </span>
extern const Color<> peachPuff; //!< - <span class="color:peachPuff"> peachPuff color </span>
extern const Color<> peru; //!< - <span class="color:peru"> peru color </span>
extern const Color<> pink; //!< - <span class="color:pink"> pink color </span>
extern const Color<> plum; //!< - <span class="color:plum"> plum color </span>
extern const Color<> powderBlue; //!< - <span class="color:powderBlue"> powderBlue color </span>
extern const Color<> purple; //!< - <span class="color:purple"> purple color </span>
extern const Color<> red; //!< - <span class="color:red"> red color </span>
extern const Color<> rosyBrown; //!< - <span class="color:rosyBrown"> rosyBrown color </span>
extern const Color<> royalBlue; //!< - <span class="color:royalBlue"> royalBlue color </span>
extern const Color<> saddleBrown; //!< - <span class="color:saddleBrown"> saddleBrown color </span>
extern const Color<> salmon; //!< - <span class="color:salmon"> salmon color </span>
extern const Color<> sandyBrown; //!< - <span class="color:sandyBrown"> sandyBrown color </span>
extern const Color<> seaGreen; //!< - <span class="color:seaGreen"> seaGreen color </span>
extern const Color<> seaShell; //!< - <span class="color:seaShell"> seaShell color </span>
extern const Color<> sienna; //!< - <span class="color:sienna"> sienna color </span>
extern const Color<> silver; //!< - <span class="color:silver"> silver color </span>
extern const Color<> skyBlue; //!< - <span class="color:skyBlue"> skyBlue color </span>
extern const Color<> slateBlue; //!< - <span class="color:slateBlue"> slateBlue color </span>
extern const Color<> slateGray; //!< - <span class="color:slateGray"> slateGray color </span>
extern const Color<> slateGrey; //!< - <span class="color:slateGrey"> slateGrey color </span>
extern const Color<> snow; //!< - <span class="color:snow"> snow color </span>
extern const Color<> springGreen; //!< - <span class="color:springGreen"> springGreen color </span>
extern const Color<> steelBlue; //!< - <span class="color:steelBlue"> steelBlue color </span>
extern const Color<> tan; //!< - <span class="color:tan"> tan color </span>
extern const Color<> teal; //!< - <span class="color:teal"> teal color </span>
extern const Color<> thistle; //!< - <span class="color:thistle"> thistle color </span>
extern const Color<> tomato; //!< - <span class="color:tomato"> tomato color </span>
extern const Color<> turquoise; //!< - <span class="color:turquoise"> turquoise color </span>
extern const Color<> violet; //!< - <span class="color:violet"> violet color </span>
extern const Color<> wheat; //!< - <span class="color:wheat"> wheat color </span>
extern const Color<> white; //!< - <span class="color:white"> white color </span>
extern const Color<> whiteSmoke; //!< - <span class="color:whiteSmoke"> whiteSmoke color </span>
extern const Color<> yellow; //!< - <span class="color:yellow"> yellow color </span>
extern const Color<> yellowGreen; //!< - <span class="color:yellowGreen"> yellowGreen color </span>
};
};

59
etk/Hash.h
View File

@ -10,10 +10,6 @@
#pragma once
#undef __class__
#define __class__ "etk::Hash"
namespace etk {
/**
* @brief internel data of the [class[etk::hash]] class, it contain
@ -39,13 +35,17 @@ namespace etk {
* @brief Hash table tamplate is a simple classical hash interface.
* A hash table is a equivalent of the dictionary in python, this is a
* simple interfaace between a name and a value:
* :** "name" : 19
* :** "name 2" : 99
* - "name" : 19
* - "name 2" : 99
*
* [note]The name is unique and the value is what you want.[/note]
* @note The name is unique and the value is what you want
*
* @todo check if something ele exist in the STD. (not the std::map and the std::unordered_map
*
* @note The index are all time availlable since they are created. The order is the the one created
*
* A simple example of use:
* [code style=c++]
* @code{.cpp}
* // Create a integer hash table
* Hash<int> myValue;
* // add some element (note add and set is the same function)
@ -59,7 +59,7 @@ namespace etk {
* myValue.remove("plop");
* //Clean all the table:
* myValue.clear();
* [/code]
* @endcode
*/
template<class MY_TYPE> class Hash {
private:
@ -84,10 +84,10 @@ namespace etk {
* @note It does not delete pointer if your value is a pointer type...
*/
void clear() {
for (size_t iii = 0; iii < m_data.size(); ++iii) {
if (m_data[iii] != NULL) {
delete(m_data[iii]);
m_data[iii]=NULL;
for (auto &it : m_data) {
if (it != nullptr) {
delete(it);
it=nullptr;
}
}
m_data.clear();
@ -99,7 +99,7 @@ namespace etk {
*/
int64_t getId(const std::string& _key) const {
for (size_t iii=0; iii<m_data.size(); iii++) {
if (m_data[iii] != NULL) {
if (m_data[iii] != nullptr) {
//TK_INFO("Compare key : '" << m_data[iii]->m_key << "' with '" << _key << "'" );
if (m_data[iii]->m_key == _key) {
return iii;
@ -111,7 +111,7 @@ namespace etk {
}
/**
* @brief Check if an element exist or not
* @param[in] _key Name of the hash requested
* @param[in] _name Name of the hash requested
* @return true if the element exist
*/
bool exist(const std::string& _name) const {
@ -160,7 +160,7 @@ namespace etk {
int64_t elementId = getId(_key);
if (elementId <0) {
HashData<MY_TYPE>* tmp = new HashData<MY_TYPE>(_key, _value);
if (NULL == tmp) {
if (tmp == nullptr) {
//TK_ERROR("allocation error in Hash table : '" << _key << "'");
return;
}
@ -170,7 +170,10 @@ namespace etk {
m_data[elementId]->m_value = _value;
}
/**
* @previous
* @brief Set an element value
* @note add and set is the same function.
* @param[in] _key Name of the value to set in the hash table.
* @param[in] _value Value to set in the hash table.
*/
void set(const std::string& _key, const MY_TYPE& _value) {
add(_key, _value);
@ -186,7 +189,7 @@ namespace etk {
return;
}
delete(m_data[elementId]);
m_data[elementId] = NULL;
m_data[elementId] = nullptr;
m_data.erase(m_data.begin()+elementId);
}
/**
@ -206,7 +209,10 @@ namespace etk {
return getValue(_pos);
}
/**
* @previous
* @brief get an element with his id.
* @param[in] _pos Position on the element in the hash table.
* @return requested element at this position.
* @note this is a dangerous use of the hash table. Maybe you will use a simple vector.
*/
const MY_TYPE& operator[] (size_t _pos) const {
return getValue(_pos);
@ -231,16 +237,16 @@ namespace etk {
*/
std::vector<std::string> getKeys() const {
std::vector<std::string> keys;
for (size_t iii = 0; iii < m_data.size(); ++iii) {
if (m_data[iii] != NULL) {
keys.push_back(m_data[iii]->m_key);
for (auto &it : m_data) {
if (it != nullptr) {
keys.push_back(it->m_key);
}
}
return keys;
}
/**
* @brief Get a value of the hash table at a specific position.
* @param[in] _posPosition of the element in the hash table.
* @param[in] _pos of the element in the hash table.
* @return Value availlable at this position.
*/
const MY_TYPE& getValue(size_t _pos) const {
@ -253,7 +259,7 @@ namespace etk {
return m_data[_pos]->m_value;
}
/**
* @previous
* @copydoc getValue (size_t)
*/
MY_TYPE& getValue(size_t _pos) {
// NOTE :Do not change log level, this generate error only in debug mode
@ -265,8 +271,5 @@ namespace etk {
return m_data[_pos]->m_value;
}
};
};
#undef __class__
#define __class__ NULL
}

2
etk/Noise.cpp
View File

@ -17,7 +17,7 @@
#include <unistd.h>
#include <stdlib.h>
etk::BaseNoise::BaseNoise(ivec2 _size, float _min, float _max) :
etk::BaseNoise::BaseNoise(const ivec2& _size, float _min, float _max) :
m_data(_size.x()*_size.y()),
m_size(_size) {
m_data.resize(_size.x()*_size.y(), 0);

22
etk/Noise.h
View File

@ -16,18 +16,31 @@ namespace etk {
/**
* @brief BaseNoise Noise basic data.
* @todo Validate it, this is a !!! PROTOTYPE !!!
* @todo Remove this from ETK
*/
class BaseNoise {
private:
std::vector<float> m_data;
ivec2 m_size;
std::vector<float> m_data; //!< basic interface date
ivec2 m_size; //!< Size of the noise data
public:
BaseNoise(ivec2 _size, float _min, float _max);
~BaseNoise();
/**
* @brief basic constructor with randon settings
* @param[in] _size Size of the basic noise
* @param[in] _min Minimum value of the random
* @param[in] _max Maximum value of the random
*/
BaseNoise(const ivec2& _size, float _min, float _max);
/**
* @brief Get value at a specific position.
* @param[in] _x X position
* @param[in] _y Y position
* @return random noise value
*/
float get(int32_t _x, int32_t _y) const;
};
/**
* @brief List of noise type supported
* @todo Remove this from ETK
*/
enum noiseType {
noiseType_base, //!< basic random noise
@ -41,6 +54,7 @@ namespace etk {
/**
* @brief Noise basic interface.
* @todo Validate it, this is a !!! PROTOTYPE !!!
* @todo Remove this from ETK
*/
class Noise {
private:

382
etk/math/Matrix.h
View File

@ -12,75 +12,82 @@
#include <vector>
namespace etk {
/**
* @brief 2 dimention matrix template to manage simpliest algo
* @note Prototype
*/
template <typename T> class Matrix {
private:
ivec2 m_size;
std::vector<T> m_data;
uivec2 m_size; //!< Size of the Matrix
std::vector<T> m_data; //!< Data of the matrix
public:
/*****************************************************
* Constructor
*****************************************************/
Matrix(ivec2 _size, T* _defaultVal=nullptr) :
/**
* @brief Contructor that create a Vector with a specific size and specific raw data
* @param[in] _size Dimention of the matrix
* @param[in] _defaultVal Default list of element that might be set in the matrix
*/
Matrix(const ivec2& _size, T* _defaultVal=nullptr) :
m_size(_size),
etk::Vector2D<T>(_size.x.x()* _size.y()) {
if (defaultVal != nullptr) {
// copy all the elements
for(int32_t iii=0; iii<=m_size.x()*m_size.y(); iii++) {
// cast and set value :
m_data[iii] = T(_defaultVal++);
}
} else {
Clear();
etk::Vector2D<T>(_size.x()* _size.y()) {
if (defaultVal == nullptr) {
clear();
return;
}
};
// copy all the elements
for(size_t iii = 0;
iii <= m_size.x()*m_size.y();
++iii) {
// cast and set value :
m_data[iii] = T(_defaultVal++);
}
}
/**
* @brief default contructor that create a Vector with a specific size and specific raw data
* @param[in] _width Dimention width of the matrix
* @param[in] _heigh Dimention heigh of the matrix
* @param[in] _defaultVal Default list of element that might be set in the matrix
*/
Matrix(int32_t _width=0, int32_t _heigh=0, T* _defaultVal=nullptr) :
m_size(_width, _heigh),
etk::Vector2D<T>(_width*_heigh) {
if (_defaultVal != nullptr) {
// copy all the elements
for(int32_t iii=0; iii<=m_size.x()*m_size.y(); iii++) {
// cast and set value :
m_data[iii] = (T)_defaultVal++;
}
} else {
Clear();
if (_defaultVal == nullptr) {
clear();
return;
}
};
Matrix(const Matrix<double>& obj) :
// copy all the elements
for(size_t iii = 0;
iii <= m_size.x()*m_size.y();
++iii) {
// cast and set value :
m_data[iii] = T(_defaultVal++);
}
}
/**
* @brief Copy contructor with ETK_TYPE_MATRIX_2 type matrix input
* @param[in] _obj Object matrix to copy
*/
template<class ETK_TYPE_MATRIX_2>
Matrix(const Matrix<ETK_TYPE_MATRIX_2>& _obj) :
m_size(_obj.m_size),
etk::Vector2D<T>(_obj.m_size.x()* _obj.m_size.y()) {
// copy all the elements
for(int32_t iii=0; iii<=m_size.x()*m_size.y(); iii++) {
for(size_t iii = 0;
iii <= m_size.x()*m_size.y();
++iii) {
// cast and set value :
m_data[iii] = (T)_obj.m_data[iii];
m_data[iii] = T(_obj.m_data[iii]);
}
}
Matrix(const Matrix<float>& _obj) :
m_size(_obj.m_size),
etk::Vector2D<T>(_obj.m_size.x()* _obj.m_size.y()) {
// copy all the elements
for(int32_t iii=0; iii<=m_size.x()*m_size.y(); iii++) {
// cast and set value :
m_data[iii] = (T)_obj.m_data[iii];
}
}
Matrix(const Matrix<int32_t>& _obj) :
m_size(_obj.m_size.x(), _obj.m_size.y()),
etk::Vector2D<T>(_obj.m_size.x()* _obj.m_size.y()) {
// copy all the elements
for (int32_t iii=0; iii<=m_size.x()*m_size.y(); iii++) {
// cast and set value :
m_data[iii] = (T)_obj.m_data[iii];
}
}
/*****************************************************
* Destructor
*****************************************************/
virtual ~Matrix() {};
/**
* @brief Virtualisation of destructor
*/
virtual ~Matrix() = default;
/*****************************************************
* = assigment
*****************************************************/
/**
* @brief Operator= Asign the current object with an other object
* @param[in] _obj Reference on the external object
* @return Local reference of the vector asigned
*/
const Matrix<T>& operator= (const Matrix<T>& _obj ) {
// check if it was the same pointer
if (this == &_obj ) {
@ -90,29 +97,49 @@ namespace etk {
m_size = _obj.m_size;
m_data = _obj.m_data;
return *this;
};
}
/**
* @brief Operator= Asign the current object with a unique value
* @param[in] _value Value to set in the matrix data
* @return Local reference of the vector asigned
*/
const Matrix<T>& operator= (T& _value) {
// set data :
for (int32_t iii=0; iii<m_data.size(); iii++) {
for(size_t iii = 0;
iii <= m_size.x()*m_size.y();
++iii) {
m_data = _value;
}
return *this;
};
/*****************************************************
* == operator
*****************************************************/
}
/**
* @brief Equality compare operator with an other object.
* @param[in] _obj Reference on the comparing object
* @return true The Objects are identical
* @return false The Objects are NOT identical
*/
bool operator== (const Matrix<T>& _obj) const {
return (m_data == _obj.m_data);
};
/*****************************************************
* != operator
*****************************************************/
}
/**
* @brief In-Equality compare operator with an other object.
* @param[in] _obj Reference on the comparing object
* @return true The Objects are NOT identical
* @return false The Objects are identical
*/
bool operator!= (const Matrix<T>& _obj) const {
return (m_data != _obj.m_data);
};
/*****************************************************
* += operator
*****************************************************/
}
/**
* @brief Operator+= Addition an other matrix with this one
* <pre>
* (a b) (e f) (a+e b+f)
* (c d) + (g h) = (c+g d+h)
* </pre>
* @note If the size are different, we create a matrix witth the max size of the 2 others ...
* @param[in] _obj Reference on the external object
* @return Local reference of the vector additionned
*/
const Matrix<T>& operator+= (const Matrix<T>& _obj) {
if (m_size != _obj.m_size) {
//TK_CRITICAL("add 2 Matrix with différent size ... ==> generate the max size of all the 2 matrix");
@ -135,27 +162,41 @@ namespace etk {
m_size = tmpMatrix.m_size;
m_data = tmpMatrix.m_data;
} else {
// copy data for the same size :
// copy data for the same size:
for (int32_t iii=0; iii< m_data.size(); iii++) {
m_data[iii] += _obj.m_data[iii];
}
}
return *this;
};
/*****************************************************
* + operator
*****************************************************/
}
/**
* @brief Operator+= Addition an other matrix with this one
* <pre>
* (a b) (e f) (a+e b+f)
* (c d) + (g h) = (c+g d+h)
* </pre>
* @note If the size are different, we create a matrix witth the max size of the 2 others ...
* @param[in] _obj Reference on the external object
* @return New matrix containing the value
*/
Matrix<T> operator+ (const Matrix<T>& _obj) {
Matrix<T> tmpp(*this);
tmpp += _obj;
return tmpp;
}
/*****************************************************
* -= operator
*****************************************************/
/**
* @brief Operator+= Addition an other matrix with this one
* <pre>
* (a b) (e f) (a-e b-f)
* (c d) - (g h) = (c-g d-h)
* </pre>
* @note If the size are different, we create a matrix witth the max size of the 2 others ...
* @param[in] _obj Reference on the external object
* @return Local reference of the vector additionned
*/
const Matrix<T>& operator-= (const Matrix<T>& _obj) {
if (m_size != _obj.m_size) {
//TK_CRITICAL("less 2 Matrix with différent size ... ==> generate the max size of all the 2 matrix");
//TK_CRITICAL("less 2 Matrix with different size ... ==> generate the max size of all the 2 matrix");
etk::Matrix<T> tmpMatrix(std::max(m_size.x(),_obj.m_size.x()), std::max(m_size.y(),_obj.m_size.y()));
for (int32_t jjj=0; jjj< m_size.y; jjj++) {
T* tmpPointer = tmpMatrix[jjj];
@ -182,17 +223,26 @@ namespace etk {
}
return *this;
};
/*****************************************************
* - operator
*****************************************************/
/**
* @brief Operator+= Addition an other matrix with this one
* <pre>
* (a b) (e f) (a-e b-f)
* (c d) - (g h) = (c-g d-h)
* </pre>
* @note If the size are different, we create a matrix witth the max size of the 2 others ...
* @param[in] _obj Reference on the external object
* @return New matrix containing the value
*/
Matrix<T> operator- (const Matrix<T>& _obj) {
Matrix<T> tmpp(*this);
tmpp += _obj;
return tmpp;
}
/*****************************************************
* *= operator
*****************************************************/
/**
* @brief Operator*= Multiplication an other matrix with this one
* @param[in] _obj Reference on the external object
* @return Local reference of the vector multiplicated
*/
const Matrix<T>& operator*= (const Matrix<T>& _obj) {
if( m_size.x() != _obj.m_size.y()
|| m_size.y() != _obj.m_size.x()) {
@ -213,46 +263,89 @@ namespace etk {
m_data = tmpMatrix.m_data;
return *this;
};
/*****************************************************
* * operator
*****************************************************/
/**
* @brief Operator* Multiplication an other matrix with this one
* @param[in] _obj Reference on the external object
* @return New matrix containing the value
*/
Matrix<T> operator* (const Matrix<T>& _obj) {
Matrix tmpp(*this);
tmpp *= _obj;
return tmpp;
}
/*****************************************************
* [] operator
*****************************************************/
const T* operator[] (int32_t _line) const {
return &m_data[_line*m_size.x()];
// TODO : Check if is possible to do elemntValue = mayMatrix[xxx, yyy]
/**
* @brief Operator[] Access at the first element (const pointer) of a line
* <pre>
* elemntValue = mayMatrix[YYY][xxx];
* </pre>
* @param[in] _yyy Line Id requested [0..m_size.y()]
* @return Const pointer on the first line element
*/
const T* operator[] (int32_t _yyy) const {
return &m_data[_yyy*m_size.x()];
}
T* operator[] (int32_t _line) {
return &m_data[_line*m_size.x()];
/**
* @brief Operator[] Access at the first element (pointer) of a line
* <pre>
* elemntValue = mayMatrix[YYY][xxx];
* </pre>
* @param[in] _yyy Line Id requested [0..m_size.y()]
* @return Pointer on the first line element
*/
T* operator[] (int32_t _yyy) {
return &m_data[_yyy*m_size.x()];
}
/*****************************************************
* () operator
*****************************************************/
T& operator () (int32_t _line, int32_t _colomn) {
return m_data[_line*m_size.x() + _colomn];
/**
* @brief Operator[] Access at the element at a specific position
* <pre>
* elemntValue = mayMatrix[ivec2(xxx,yyy)];
* </pre>
* @param[in] _pos Position in the matrix
* @return Const Reference on the element
*/
const T& operator[] (const ivec2& _pos) const {
return m_data[_pos.y()*m_size.x() + _pos.x()];
}
/*****************************************************
* - operator
*****************************************************/
Matrix<T> operator - () {
/**
* @brief Operator[] Access at the element at a specific position
* <pre>
* elemntValue = mayMatrix[ivec2(xxx,yyy)];
* </pre>
* @param[in] _pos Position in the matrix
* @return Reference on the element
*/
T& operator[] (const ivec2& _pos) {
return m_data[_pos.y()*m_size.x() + _pos.x()];
}
/**
* @brief Operator() Access at the element at a specific position
* <pre>
* elemntValue = mayMatrix(xxx,yyy);
* </pre>
* @param[in] _xxx Colomn position in the matrix
* @param[in] _yyy Line position in the matrix
* @return Reference on the element
*/
T& operator () (size_t _xxx, size_t _yyy) {
return m_data[_yyy*m_size.x() + _xxx];
}
/**
* @brief Operator- Multiply with -1
* @return New matrix containing the value
*/
Matrix<T> operator- () const {
Matrix<T> tmp(m_size);
for (int32_t iii=0; iii<m_data.Size(); iii++) {
tmp.m_data[iii] = -m_data[iii];
}
return tmp;
}
/*****************************************************
* Other mathematical function
*****************************************************/
/**
* @ brief Transpose Matrix
* @ return the transpose matrix
* @brief Transpose Matrix
* @return New matrix containing the value
*/
Matrix<T> transpose() {
Matrix<T> transpose() const {
// create a matrix with the inverted size
Matrix<T> tmpMatrix(m_size);
for (int32_t jjj=0; jjj< m_size.y(); jjj++) {
@ -261,23 +354,23 @@ namespace etk {
}
}
return tmpMatrix;
};
}
/**
* @ brief Create a convolution on the matrix : set convolution on the lines
* @ param[in] _obj The convolution operator
* @ return the value of the convolution
* @brief Create a convolution on the matrix : set convolution on the lines
* @param[in] _obj The convolution operator
* @return New matrix containing the current matrix concoluate
*/
Matrix<T>& convolution(Matrix<T>& _obj) {
Matrix<T> convolution(Matrix<T>& _obj) const {
Matrix<T> tmppp(1,1);
// TODO : ...
return tmppp;
};
}
/**
* @ brief generate a devide of the curent Matrix with the specify power of 2
* @ param[in] _decalage The power of 2 of the division
* @ return the result
* @brief generate a devide of the curent Matrix with the specify power of 2
* @param[in] _decalage The power of 2 of the division
* @return New matrix containing the matrix fix()
*/
Matrix<T>& fix(int32_t _decalage) {
Matrix<T> fix(int32_t _decalage) const {
Matrix<T> tmppp(m_size);
T tmpVal = 0;
for(int32_t iii=0; iii<m_data.size(); iii++) {
@ -293,11 +386,11 @@ namespace etk {
return tmppp;
};
/**
* @ brief generate a devide of the curent Matrix with the specify power of 2
* @ param[in] _decalage The power of 2 of the division
* @ return the result
* @brief generate a devide of the curent Matrix with the specify power of 2
* @param[in] _decalage The power of 2 of the division
* @return New matrix containing the rounded matrix
*/
Matrix<T>& round(int32_t _decalage) {
Matrix<T> round(int32_t _decalage) const {
Matrix<T> tmppp(m_size);
for(int32_t iii=0; iii<m_data.size(); iii++) {
tmppp.m_data[iii] = ( m_data[iii]+(1<<(_decalage-1)) ) >> _decalage;
@ -305,11 +398,11 @@ namespace etk {
return tmppp;
};
/**
* @ brief Generate a resised matrix
* @ param[in] _size new output size
* @ return Te resied matrix
* @brief Generate a resised matrix
* @param[in] _size new output size
* @return New matrix resized
*/
Matrix<T>& resize(etk::Vector2D<int32_t> _size) {
Matrix<T> resize(etk::Vector2D<int32_t> _size) const {
Matrix<T> tmppp(_size);
for(int32_t iii=0; iii<m_data.m_size.x() && iii<tmppp.m_size.x(); iii++) {
for(int32_t jjj=0; jjj<m_data.m_size.y() && jjj<tmppp.m_size.y(); jjj++) {
@ -322,11 +415,11 @@ namespace etk {
* @brief Select element in the matrix from a list of element Ids
* @param[in] _np Width of the output matrix
* @param[in] _p List pointer of x
* @param[in] _np Heigh of the output matrix
* @param[in] _nq Heigh of the output matrix
* @param[in] _q List pointer of y
* @return the new matrix
* @return New matrix resized
*/
Matrix<T>& select(int32_t _np, int32_t* _p, int32_t _nq, int32_t* _q) {
Matrix<T> select(int32_t _np, int32_t* _p, int32_t _nq, int32_t* _q) const {
if (_np < 1 || _nq < 1) {
TK_WARNING("bad index array sizes");
}
@ -344,9 +437,6 @@ namespace etk {
}
return tmppp;
}
/*****************************************************
* utilities :
*****************************************************/
/**
* @brief Clear the Upper triangle of the current Matrix
* <pre>
@ -401,7 +491,7 @@ namespace etk {
* @param[in] _input The compared Matix.
* @return The absolute max value.
*/
T maxDifference(const Matrix<T>& _input) {
T maxDifference(const Matrix<T>& _input) const {
if (m_size != _input.m_size) {
TK_WARNING("better to do with same size Matrix");
}
@ -413,14 +503,21 @@ namespace etk {
if (diff<0) {
diff = -diff;
}
if (diff > max)
if (diff > max) {
max = diff;
}
}
return max;
};
}
/**
* @brief Clear all the matrix.
* <pre>
* 0 0 0 0 0
* 0 0 0 0 0
* 0 0 0 0 0
* 0 0 0 0 0
* 0 0 0 0 0
* </pre>
*/
void clear() {
// copy data for the same size :
@ -429,7 +526,13 @@ namespace etk {
}
};
/**
* @brief Set the diagonal at 1
* @brief Set the matrix identity
* <pre>
* 1 0 0 0 0
* 0 1 0 0 0
* 0 0 1 0 0
* 0 0 0 1 0
* </pre>
*/
void identity() {
// copy data for the same size :
@ -448,13 +551,14 @@ namespace etk {
* @brief Get the size of the current Matrix.
* @return Dimention of the matrix
*/
Vector2D<int32_t> size() {
const uivec2& size() const {
return m_size;
};
};
}
// To siplify the writing of the code ==> this is not compatible with GLSL ...
typedef etk::Matrix<float> mat;
typedef etk::Matrix<int32_t> imat;
typedef etk::Matrix<uint32_t> uimat;
using dmat = etk::Matrix<double>; //!< Helper to simplify using of matrix
using mat = etk::Matrix<float>; //!< Helper to simplify using of matrix
using imat = etk::Matrix<int32_t>; //!< Helper to simplify using of matrix
using uimat = etk::Matrix<uint32_t>; //!< Helper to simplify using of matrix

16
etk/math/Matrix2.cpp
View File

@ -78,10 +78,6 @@ etk::Matrix2::Matrix2(const double* _values) {
m_mat[5] = _values[5];
}
etk::Matrix2::~Matrix2() {
}
const etk::Matrix2& etk::Matrix2::operator= (const etk::Matrix2& _obj ) {
for(int32_t iii=0; iii<2*3 ; ++iii) {
m_mat[iii] = _obj.m_mat[iii];
@ -152,14 +148,14 @@ etk::Matrix2 etk::Matrix2::operator * (const etk::Matrix2& _obj) {
return tmp;
}
vec2 etk::Matrix2::operator * (const vec2& _obj) const {
return vec2(_obj.x()*m_mat[0] + _obj.y()*m_mat[1] + m_mat[2],
_obj.x()*m_mat[4] + _obj.y()*m_mat[3] + m_mat[5]);
vec2 etk::Matrix2::operator * (const vec2& _point) const {
return vec2(_point.x()*m_mat[0] + _point.y()*m_mat[1] + m_mat[2],
_point.x()*m_mat[4] + _point.y()*m_mat[3] + m_mat[5]);
}
vec2 etk::Matrix2::applyScaleRotation(const vec2& _obj) const {
return vec2(_obj.x()*m_mat[0] + _obj.y()*m_mat[1],
_obj.x()*m_mat[4] + _obj.y()*m_mat[3]);
vec2 etk::Matrix2::applyScaleRotation(const vec2& _point) const {
return vec2(_point.x()*m_mat[0] + _point.y()*m_mat[1],
_point.x()*m_mat[4] + _point.y()*m_mat[3]);
}
etk::Matrix2 etk::Matrix2::operator ~ () const {

175
etk/math/Matrix2.h
View File

@ -11,76 +11,128 @@
#include <etk/math/Vector2D.h>
#include <etk/types.h>
namespace etk {
/**
* @brief Transformation matrix for vector 2D.
*/
class Matrix2 {
public:
/*
private:
/**
* @brief Internal data
* sx shx tx
* sy shy ty
*/
float m_mat[2*3];
/**
* @brief Load Identity matrix
*/
void identity();
public:
/*****************************************************
* Constructor
*****************************************************/
/**
* @brief Constructor that load identity
*/
Matrix2();
/**
* @brief Copy constructor.
* @param[in] _obj Matrix object to copy
*/
Matrix2(const Matrix2& _obj);
/**
* @brief Configuration constructor.
* @param[in] _sx Scale threw X axis
* @param[in] _shy Rotate in radian threw Y axis
* @param[in] _shx Rotate in radian threw X axis
* @param[in] _sy Scale threw Y axis
* @param[in] _tx Translate threw X axis
* @param[in] _ty translate threw Y axis
*/
Matrix2(float _sx,
float _shy,
float _shx,
float _sy,
float _tx,
float _ty);
/**
* @brief Configuration constructor.
* @param[in] _values vector of values in float
*/
Matrix2(const float* _values);
/**
* @brief Configuration constructor.
* @param[in] _values vector of values in double
*/
Matrix2(const double* _values);
/*****************************************************
* Destructor
*****************************************************/
~Matrix2();
/*****************************************************
* = assigment
*****************************************************/
/**
* @brief Load Identity matrix
*/
void identity();
/**
* @brief Operator= Asign the current object with an other object
* @param[in] _obj Reference on the external object
* @return Local reference of the vector asigned
*/
const Matrix2& operator= (const Matrix2& _obj );
/*****************************************************
* == operator
*****************************************************/
/**
* @brief Equality compare operator with an other object.
* @param[in] _obj Reference on the comparing object
* @return true The Objects are identical
* @return false The Objects are NOT identical
*/
bool operator== (const Matrix2& _obj) const;
/*****************************************************
* != operator
*****************************************************/
/**
* @brief In-Equality compare operator with an other object.
* @param[in] _obj Reference on the comparing object
* @return true The Objects are NOT identical
* @return false The Objects are identical
*/
bool operator!= (const Matrix2& _obj) const;
/*****************************************************
* += operator
*****************************************************/
/**
* @brief Operator+= Addition an other matrix with this one
* @param[in] _obj Reference on the external object
* @return Local reference of the vector additionned
*/
const Matrix2& operator+= (const Matrix2& _obj);
/*****************************************************
* + operator
*****************************************************/
/**
* @brief Operator+ Addition an other matrix with this one
* @param[in] _obj Reference on the external object
* @return New vector containing the value
*/
Matrix2 operator+ (const Matrix2& _obj) const;
/*****************************************************
* -= operator
*****************************************************/
/**
* @brief Operator-= Decrement an other matrix with this one
* @param[in] _obj Reference on the external object
* @return Local reference of the vector decremented
*/
const Matrix2& operator-= (const Matrix2& _obj);
/*****************************************************
* - operator
*****************************************************/
/**
* @brief Operator- Decrement an other matrix with this one
* @param[in] _obj Reference on the external object
* @return New vector containing the value
*/
Matrix2 operator- (const Matrix2& _obj) const;
/*****************************************************
* *= operator
*****************************************************/
/**
* @brief Operator*= Multiplication an other matrix with this one
* @param[in] _obj Reference on the external object
* @return Local reference of the vector multiplicated
*/
const Matrix2& operator *= (const Matrix2& _obj);
/*****************************************************
* * operator
*****************************************************/
/**
* @brief Operator* Multiplication an other matrix with this one
* @param[in] _obj Reference on the external object
* @return New vector containing the value
*/
Matrix2 operator * (const Matrix2& _obj);
vec2 operator * (const vec2& _obj) const;
vec2 applyScaleRotation(const vec2& _obj) const;
/*****************************************************
* ~ operator
*****************************************************/
/**
* @brief Operator* apply matrix on a vector
* @param[in] _point Point value to apply the matrix
* @return New vector containing the value
*/
vec2 operator * (const vec2& _point) const;
/**
* @brief Apply matrix on a vector Scale Rotate, but NOT the translation
* @param[in] _point Point value to apply the matrix
* @return New vector containing the value
*/
vec2 applyScaleRotation(const vec2& _point) const;
/**
* @brief Inverse the current Matrix
* @return New vector containing the value
*/
Matrix2 operator ~ () const;
/**
* @brief Flip the mathix threw the X axis
@ -93,10 +145,12 @@ namespace etk {
/**
* @brief Scale the current Matrix.
* @param[in] _vect Vector to scale matrix.
* @param[in] _value Single value to scale in X andf Y.
*/
void scale(const vec2& _vect);
//! @previous
/**
* @brief Scale the current Matrix.
* @param[in] _value Single value to scale in X andf Y.
*/
void scale(float _value);
/**
* @brief Makes a rotation matrix.
@ -120,15 +174,40 @@ namespace etk {
*/
void invert();
};
/**
* @brief Create a matrix 2D with a simple rotation
* @param[in] _angleRad Radian angle to set at the matrix
* @return New matrix of the transformation requested
*/
Matrix2 mat2Rotate(float _angleRad);
/**
* @brief Create a matrix 2D with a simple scale
* @param[in] _scale 2 dimention scale
* @return New matrix of the transformation requested
*/
Matrix2 mat2Scale(const vec2& _scale);
/**
* @brief Create a matrix 2D with a simple scale
* @param[in] _scale same scale in 2 and Y
* @return New matrix of the transformation requested
*/
Matrix2 mat2Scale(float _scale);
/**
* @brief Create a matrix 2D with a simple translation
* @param[in] _translate 2 dimention translation
* @return New matrix of the transformation requested
*/
Matrix2 mat2Translate(const vec2& _translate);
/**
* @brief Create a matrix 2D with a simple skew
* @param[in] _skew 2 dimention skew
* @return New matrix of the transformation requested
*/
Matrix2 mat2Skew(const vec2& _skew);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const etk::Matrix2& _obj);
}
// simplify using of matrix ...
typedef etk::Matrix2 mat2;
using mat2 = etk::Matrix2; //!< Use simplification in upper application to use matrix like openGL shader

8
etk/math/Matrix4.cpp
View File

@ -11,8 +11,6 @@
#include <etk/debug.h>
#include <math.h>
#if 1
void etk::Matrix4::identity() {
for(int32_t iii=0; iii<4*4 ; iii++) {
m_mat[iii] = 0;
@ -65,10 +63,6 @@ etk::Matrix4::Matrix4(float* _obj) {
}
}
etk::Matrix4::~Matrix4() {
}
const etk::Matrix4& etk::Matrix4::operator= (const etk::Matrix4& _obj ) {
for(int32_t iii=0; iii<4*4 ; ++iii) {
m_mat[iii] = _obj.m_mat[iii];
@ -442,5 +436,3 @@ mat4 etk::matRotate(const vec3& _vect, float _angleRad) {
return tmp;
}
#endif

194
etk/math/Matrix4.h
View File

@ -12,78 +12,147 @@
#include <etk/math/Vector3D.h>
#if 1
#include <math.h>
/**
* @brief Convert degree in radian
* @param[in] a Value to converted in degree
* @return Angle in radian
*/
#define DEG_TO_RAD(a) ((a)*M_PI/180.0f)
/**
* @brief Convert radian in degree
* @param[in] a Value to converted in radian
* @return Angle in degree
*/
#define RAD_TO_DEG(a) ((a)*180.0f/M_PI)
namespace etk {
/**
* @brief Transformation matrix for vector 3D.
*/
class Matrix4 {
private:
float m_mat[4*4]; //!< matrix data
public:
float m_mat[4*4];
/**
* @brief configure identity of the matrix
*/
void identity();
/*****************************************************
* Constructor
*****************************************************/
/**
* @brief Constructor that load identity
*/
Matrix4();
/**
* @brief Copy constructor.
* @param[in] _obj Matrix object to copy
*/
Matrix4(const Matrix4& _obj);
/**
* @brief Configuration constructor.
* @param[in] _a1 1st colomn, 1 line value
* @param[in] _b1 2nd colomn, 1 line value
* @param[in] _c1 3rd colomn, 1 line value
* @param[in] _d1 4th colomn, 1 line value
* @param[in] _a2 1st colomn, 2 line value
* @param[in] _b2 2nd colomn, 2 line value
* @param[in] _c2 3rd colomn, 2 line value
* @param[in] _d2 4th colomn, 2 line value
* @param[in] _a3 1st colomn, 3 line value
* @param[in] _b3 2nd colomn, 3 line value
* @param[in] _c3 3rd colomn, 3 line value
* @param[in] _d3 4th colomn, 3 line value
* @param[in] _a4 1st colomn, 4 line value
* @param[in] _b4 2nd colomn, 4 line value
* @param[in] _c4 3rd colomn, 4 line value
* @param[in] _d4 4th colomn, 4 line value
*/
Matrix4(float _a1, float _b1, float _c1, float _d1,
float _a2, float _b2, float _c2, float _d2,
float _a3, float _b3, float _c3, float _d3,
float _a4, float _b4, float _c4, float _d4);
Matrix4(float* _obj);
/*****************************************************
* Destructor
*****************************************************/
~Matrix4();
/*****************************************************
* = assigment
*****************************************************/
const Matrix4& operator= (const Matrix4& _obj );
/*****************************************************
* == operator
*****************************************************/
/**
* @brief Configuration constructor.
* @param[in] _values vector of values
*/
Matrix4(float* _values);
/**
* @brief Operator= Asign the current object with an other object
* @param[in] _obj Reference on the external object
* @return Local reference of the vector asigned
*/
const Matrix4& operator= (const Matrix4& _obj);
/**
* @brief Equality compare operator with an other object.
* @param[in] _obj Reference on the comparing object
* @return true The Objects are identical
* @return false The Objects are NOT identical
*/
bool operator== (const Matrix4& _obj) const;
/*****************************************************
* != operator
*****************************************************/
/**
* @brief In-Equality compare operator with an other object.
* @param[in] _obj Reference on the comparing object
* @return true The Objects are NOT identical
* @return false The Objects are identical
*/
bool operator!= (const Matrix4& _obj) const;
/*****************************************************
* += operator
*****************************************************/
/**
* @brief Operator+= Addition an other matrix with this one
* @param[in] _obj Reference on the external object
* @return Local reference of the vector additionned
*/
const Matrix4& operator+= (const Matrix4& _obj);
/*****************************************************
* + operator
*****************************************************/
/**
* @brief Operator+ Addition an other matrix with this one
* @param[in] _obj Reference on the external object
* @return New vector containing the value
*/
Matrix4 operator+ (const Matrix4& _obj) const;
/*****************************************************
* -= operator
*****************************************************/
/**
* @brief Operator-= Decrement an other matrix with this one
* @param[in] _obj Reference on the external object
* @return Local reference of the vector decremented
*/
const Matrix4& operator-= (const Matrix4& _obj);
/*****************************************************
* - operator
*****************************************************/
/**
* @brief Operator- Decrement an other matrix with this one
* @param[in] _obj Reference on the external object
* @return New vector containing the value
*/
Matrix4 operator- (const Matrix4& _obj) const;
/*****************************************************
* *= operator
*****************************************************/
/**
* @brief Operator*= Multiplication an other matrix with this one
* @param[in] _obj Reference on the external object
* @return Local reference of the vector multiplicated
*/
const Matrix4& operator*= (const Matrix4& _obj);
/*****************************************************
* * operator
*****************************************************/
/**
* @brief Operator* Multiplication an other matrix with this one
* @param[in] _obj Reference on the external object
* @return New vector containing the value
*/
Matrix4 operator* (const Matrix4& _obj) const;
/**
* @brief Operator* apply matrix on a vector
* @param[in] _point Point value to apply the matrix
* @return New vector containing the value
*/
vec3 operator*(const vec3& _point) const;
/*****************************************************
* other basic function :
*****************************************************/
/**
* @brief Transpose the current matix (usefull for OpenGL display)
*/
void transpose();
/**
* @brief Scale the current Matrix.
* @param[in] _vect Scale vector to apply.
*/
void scale(const vec3& _vect);
//! @previous
/**
* @brief Scale the current Matrix.
* @param[in] _sx Scale X value to apply.
* @param[in] _sy Scale Y value to apply.
* @param[in] _sz Scale Z value to apply.
*/
void scale(float _sx, float _sy, float _sz);
/**
* @brief Makes a rotation matrix about an arbitrary axis.
@ -118,9 +187,26 @@ namespace etk {
Matrix4 matFrustum(float _xmin, float _xmax, float _ymin, float _ymax, float _zNear, float _zFar);
Matrix4 matPerspective(float _foxy, float _aspect, float _zNear, float _zFar);
Matrix4 matOrtho(float _left, float _right, float _bottom, float _top, float _nearVal, float _farVal);
Matrix4 matTranslate(vec3 _vect);
Matrix4 matScale(vec3 _vect);
Matrix4 matRotate(vec3 _vect, float _angleRad=0.0);
/**
* @brief Create a matrix 3D with a simple translation
* @param[in] _translate 3 dimention translation
* @return New matrix of the transformation requested
*/
Matrix4 matTranslate(vec3 _translate);
/**
* @brief Create a matrix 3D with a simple scale
* @param[in] _scale 3 dimention scale
* @return New matrix of the transformation requested
*/
Matrix4 matScale(vec3 _scale);
/**
* @brief Create a matrix 3D with a simple rotation
* @param[in] _normal vector aroud witch apply the rotation
* @param[in] _angleRad Radian angle to set at the matrix
* @return New matrix of the transformation requested
*/
Matrix4 matRotate(vec3 _normal, float _angleRad=0.0);
//! @not_in_doc
Matrix4 matRotate2(vec3 _vect);
Matrix4 matLookAt(const vec3& _eye,
const vec3& _target,
@ -131,21 +217,5 @@ namespace etk {
// To siplify the writing of the code ==> this permit to have the same name with the glsl language...
typedef etk::Matrix4 mat4;
#else
// include matrix from bulletlib mat4 interface:
#include <vectormath/scalar/vectormath_aos.h>
// To siplify the writing of the code ==> this permit to have the same name with the glsl language...
typedef Vectormath::Aos::Matrix4 mat4;
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const mat4& _obj);
// TODO : Remove this ???
namespace etk {
mat4 matTranslate(const vec3& _vect);
mat4 matScale(const vec3& _vect);
mat4 matRotate(const vec3& _vect, float _angleRad=0.0);
}
#endif
using mat4 = etk::Matrix4; //!< Matrix naming like openGl shader

4
etk/math/Vector2D.h
View File

@ -98,7 +98,7 @@ namespace etk {
* @return true The Objects are identical
* @return false The Objects are NOT identical
*/
bool operator== (const Vector2D<T>& _obj) const {
bool operator== (const Vector2D<T>& _obj) const {
return ( (T)_obj.m_floats[0] == m_floats[0]
&& (T)_obj.m_floats[1] == m_floats[1]);
}
@ -108,7 +108,7 @@ namespace etk {
* @return true The Objects are NOT identical
* @return false The Objects are identical
*/
bool operator!= (const Vector2D<T>& _obj) const {
bool operator!= (const Vector2D<T>& _obj) const {
return ( (T)_obj.m_floats[0] != m_floats[0]
|| (T)_obj.m_floats[1] != m_floats[1]);
}

12
etk/math/Vector3D.h
View File

@ -532,15 +532,15 @@ namespace etk {
// To siplify the writing of the code ==> this permit to have the same name with the glsl language...
#ifdef ETK_BUILD_LINEARMATH
typedef btVector3 vec3; //!< wrapper on etk::Vector3D<float> to have the same naming has OpenGL shader
using vec3 = btVector3; //!< wrapper on etk::Vector3D<float> to have the same naming has OpenGL shader
#else
typedef etk::Vector3D<float> vec3; //!< wrapper on etk::Vector3D<float> to have the same naming has OpenGL shader
using vec3 = etk::Vector3D<float>; //!< wrapper on etk::Vector3D<float> to have the same naming has OpenGL shader
#endif
typedef etk::Vector3D<float> ovec3; //!< wrapper on etk::Vector3D<float> to be complient all time with openGL internal mode (instead of vec3)
typedef etk::Vector3D<int32_t> ivec3; //!< wrapper on etk::Vector3D<int32_t> to have the same naming has OpenGL shader
using ovec3 = etk::Vector3D<float>; //!< wrapper on etk::Vector3D<float> to be complient all time with openGL internal mode (instead of vec3)
using ivec3 = etk::Vector3D<int32_t>; //!< wrapper on etk::Vector3D<int32_t> to have the same naming has OpenGL shader
// not compatible with glsl ... but it is better to have a same writing
typedef etk::Vector3D<uint32_t> uivec3; //!< wrapper on etk::Vector3D<uint32_t> to have the same naming has OpenGL shader
typedef etk::Vector3D<bool> bvec3; //!< wrapper on etk::Vector3D<bool> to have the same naming has OpenGL shader
using uivec3 = etk::Vector3D<uint32_t>; //!< wrapper on etk::Vector3D<uint32_t> to have the same naming has OpenGL shader
using bvec3 = etk::Vector3D<bool>; //!< wrapper on etk::Vector3D<bool> to have the same naming has OpenGL shader
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const vec3& _obj);

8
etk/math/Vector4D.h
View File

@ -432,10 +432,10 @@ namespace etk {
}
// To siplify the writing of the code ==> this permit to have the same name with the glsl language...
typedef etk::Vector4D<float> vec4; //!< wrapper on etk::Vector4D<float> to have the same naming has OpenGL shader
typedef etk::Vector4D<int32_t> ivec4; //!< wrapper on etk::Vector4D<int32_t> to have the same naming has OpenGL shader
using vec4 = etk::Vector4D<float>; //!< wrapper on etk::Vector4D<float> to have the same naming has OpenGL shader
using ivec4 = etk::Vector4D<int32_t>; //!< wrapper on etk::Vector4D<int32_t> to have the same naming has OpenGL shader
// not compatible with glsl ... but it is better to have a same writing
typedef etk::Vector4D<uint32_t> uivec4; //!< wrapper on etk::Vector4D<uint32_t> to have the same naming has OpenGL shader
typedef etk::Vector4D<bool> bvec4; //!< wrapper on etk::Vector4D<bool> to have the same naming has OpenGL shader
using uivec4 = etk::Vector4D<uint32_t>; //!< wrapper on etk::Vector4D<uint32_t> to have the same naming has OpenGL shader
using bvec4 = etk::Vector4D<bool>; //!< wrapper on etk::Vector4D<bool> to have the same naming has OpenGL shader

418
etk/os/FSNode.cpp
View File

File diff suppressed because it is too large Load Diff

124
etk/os/FSNode.h
View File

@ -11,7 +11,9 @@
#pragma once
#include <etk/os/FSNodeRight.h>
/**
* @brief Local maximum file name size
*/
#define MAX_FILE_NAME (10240)
//http://developer.android.com/guide/topics/data/data-storage.html
@ -32,76 +34,88 @@ namespace etk {
}
#endif
namespace etk {
/**
* @brief Set the firt argument of the application start (this permit to get the real position of the execution path and executable position
* @param[in] _val First parameter.
*/
void setArgZero(const std::string& _val);
/**
* @brief Simplify a path with all the complication that mean ".." or "///\//"
* @param[in] _input Parth to simplify
* @return the simplified path.
*/
std::string simplifyPath(std::string _input);
/**
* @brief Get application name.
* @return The application name
*/
std::string FSNodeGetApplicationName();
/**
* List of Type that a node can have (this wrap some type that not exist on Windows)
* @brief List of Type that a node can have (this wrap some type that not exist on Windows)
*/
enum typeNode {
FSN_UNKNOW, //!< Type of the node is not known
FSN_BLOCK, //!< The node is a block aceess device (Not availlable on Windows)
FSN_CHARACTER, //!< The node is a Char device type (Not availlable on Windows)
FSN_FOLDER, //!< The node is a folder
FSN_FIFO, //!< The node is a Fifo (Not availlable on Windows)
FSN_LINK, //!< The node is a Link
FSN_FILE, //!< The node is a File
FSN_SOCKET, //!< The node is a socket
typeNode_unknow, //!< Type of the node is not known
typeNode_block, //!< The node is a block aceess device (Not availlable on Windows)
typeNode_character, //!< The node is a Char device type (Not availlable on Windows)
typeNode_folder, //!< The node is a folder
typeNode_fifo, //!< The node is a Fifo (Not availlable on Windows)
typeNode_link, //!< The node is a Link
typeNode_file, //!< The node is a File
typeNode_socket, //!< The node is a socket
};
//! @not_in_doc
std::ostream& operator <<(std::ostream &_os, const enum etk::typeNode &_obj);
/**
* @brief Seek mode availlable (just to wrap it ...)
*/
enum seekNode{
FSN_SEEK_START,
FSN_SEEK_END,
FSN_SEEK_CURRENT,
seekNode_start, //!< request seek position start at the START of the file
seekNode_end, //!< request seek position start at the END of the file
seekNode_current, //!< request seek position start at the CURRENT position in the file
};
/**
* @brief Type of the file/folder/... accessible in the Node
*/
enum FSNType {
FSN_TYPE_UNKNOW,
FSNType_unknow, //!< Unknow type of the node (many time no file name seted)
// user might done abstraction ==> acces of the sdcard when possible ...
FSN_TYPE_DIRECT,
FSN_TYPE_RELATIF,
FSNType_direct, //!< Access at the file System with a direct naming like "/home/plop/xxx.txt"
FSNType_relatif, //!< Access at the file System with a relative naming like "../plop/xxx.txt"
// depend on case
// - PC : ~/
// - Android : /sdcard/
// - Apple : ????
FSN_TYPE_HOME,
FSNType_home, //!< acces at the home path of the system (with name of the current user)
// depend of the case
// - PC : /usr/shared/programName/
// - Android : Internal at the executable file (pointer on static area)
// - Apple : Internal at the executable file
FSN_TYPE_DATA,
FSNType_data, //!< Access on the application data (internal application data are the one provided with the binary)
// depend on case
// - PC : ~/.local/programName/
// - Android : /data/data/programName/files/
// - Apple : ????
FSN_TYPE_USER_DATA,
FSNType_userData, //!< Access on the user application data (where the data are stored when the application stop)
// depend on case
// - PC : ~/.programName/cache/
// - Android : /data/data/programName/cache/
// - Apple : ????
FSN_TYPE_CACHE,
FSNType_cache, //!< Access on the application temporary path (remove when user want and whe the compter restart or have not enought memory)
// depend on case
// - try on FSN_TYPE_USER_DATA:/theme/themeName/xxx
// - try on FSN_TYPE_DATA:/theme/themeName/xxx
// - try on USER_DATA:/theme/themeName/xxx
// - try on DATA:/theme/themeName/xxx
// and jump to the default theme file
// - try on FSN_TYPE_USER_DATA:/theme/default/xxx
// - try on FSN_TYPE_DATA:/theme/default/xxx
FSN_TYPE_THEME,
FSN_TYPE_THEME_DATA
// - try on USER_DATA:/theme/default/xxx
// - try on DATA:/theme/default/xxx
FSNType_theme, //!< Theme area
FSNType_themeData //!< Theme data area
};
//! @not_in_doc
std::ostream& operator <<(std::ostream &_os, const enum etk::FSNType &_obj);
/*
@ -144,7 +158,9 @@ namespace etk {
./
*/
/**
* @brief FS node is for File system IO access This class is independent of the OS, If you acces to a file in windows, it might generate the right loke Linux (it is important to know that windows right is lighter than linux)
* @brief FS node is for File System IO access (named classicly "node in linux EXT)
* This class is independent of the OS, If you acces to a file in windows, it might
* generate the right like Linux (it is important to know that windows right is lighter than linux)
*/
class FSNode {
private:
@ -210,11 +226,11 @@ namespace etk {
* @return false : The node does not exist.
*/
bool exist() const {
return (m_typeNode!=etk::FSN_UNKNOW);
return (m_typeNode!=etk::typeNode_unknow);
};
/**
* @brief Get the node type
* @return the requested type, FSN_UNKNOW if it does not existed
* @return the requested type, typeNode_unknow if it does not existed
*/
enum typeNode getNodeType() const {
return m_typeNode;
@ -234,10 +250,10 @@ namespace etk {
*/
bool setRight(etk::FSNodeRight _newRight);
/**
* @brief Change the Node seeing (not rename the node, for this @ref Move)
* @brief Change the Node seeing (not rename the node, for this @ref etk::FSNodeMove)
* @param[in] _newName New node name to show
* @return true : action done
* @return false : action not done
* @return true action done
* @return false action not done
*/
void setName(const std::string& _newName);
#if __CPP_VERSION__ >= 2011
@ -398,6 +414,14 @@ namespace etk {
bool _getFolderAndOther = true,
bool _getFile = true,
bool _temporaryFile = true);
/**
* @brief Get the List of all node inside a node (folder only)
* @param[in] _showHidenFile Add hidden file/folder/...
* @param[in] _getFolderAndOther get folder
* @param[in] _getFile Get files
* @param[in] _filter Generic regex string to filter file names
* @return The requested list
*/
std::vector<etk::FSNode*> folderGetSubList(bool _showHidenFile = true,
bool _getFolderAndOther = true,
bool _getFile = true,
@ -516,17 +540,23 @@ namespace etk {
* @return Number of element written (in block number)
*/
int64_t fileWrite(const void* _data, int64_t _blockSize, int64_t _nbBlock);
// TODO: etk::FSNode& operator<< (const std::ostream& _data);
/**
* @brief Stream write mode
* @param[in] _data Stream to write
* @return The current FSNode reference to add other stream.
* @note not stable API ...
*/
//etk::FSNode& operator<< (const std::ostream& _data);
etk::FSNode& operator<< (const std::stringstream& _data);
//! @copydoc etk::FSNode::operator<<(const std::stringstream&)
etk::FSNode& operator<< (const std::string& _data);
//! @copydoc etk::FSNode::operator<<(const std::stringstream&)
etk::FSNode& operator<< (const char* _data);
//! @copydoc etk::FSNode::operator<<(const std::stringstream&)
etk::FSNode& operator<< (const int32_t _data);
//! @copydoc etk::FSNode::operator<<(const std::stringstream&)
etk::FSNode& operator<< (const uint32_t _data);
//! @copydoc etk::FSNode::operator<<(const std::stringstream&)
etk::FSNode& operator<< (const float _data);
/**
* @brief Get the position in the file.
@ -555,6 +585,10 @@ namespace etk {
fileRead(&value[0], sizeof(T), fileSize()/sizeof(T));
return value;
}
/**
* @brief Read all element in a file and set it in a generic std::string
* @return the read string
*/
std::string fileReadAllString() {
std::string value;
value.resize(fileSize());
@ -568,10 +602,16 @@ namespace etk {
#endif
/**
* @brief Write all the vector in a file
* @param[in] _value Data to write in the File
*/
template<typename T> void fileWriteAll(const std::vector<T>& _value) {
template<typename T>
void fileWriteAll(const std::vector<T>& _value) {
fileWrite(static_cast<const void*>(&(_value[0])), sizeof(T), _value.size()/sizeof(T));
}
/**
* @brief Write all the vector in a file
* @param[in] _value String data to write in the File
*/
void fileWriteAll(const std::string& _value) {
fileWrite(static_cast<const void*>(&(_value[0])), sizeof(char), _value.size()/sizeof(char));
}
@ -587,7 +627,7 @@ namespace etk {
*/
void sortElementList(std::vector<etk::FSNode *>& _list);
};
//! @not_in_doc
std::ostream& operator <<(std::ostream &_os, const etk::FSNode &_obj);
/**
@ -709,9 +749,9 @@ namespace etk {
* @return true : Action done corectly
* @return false : An error occured
*/
bool FSNodeCreate(const std::string& _path, etk::FSNodeRight _right, enum etk::typeNode _type=etk::FSN_FOLDER);
bool FSNodeCreate(const std::string& _path, etk::FSNodeRight _right, enum etk::typeNode _type=etk::typeNode_folder);
#if __CPP_VERSION__ >= 2011
bool FSNodeCreate(const std::u32string& _path, etk::FSNodeRight _right, enum etk::typeNode _type=etk::FSN_FOLDER);
bool FSNodeCreate(const std::u32string& _path, etk::FSNodeRight _right, enum etk::typeNode _type=etk::typeNode_folder);
#endif
/**
* @brief Simple access for : chexk the exestance of an element

163
etk/os/FSNodeRight.cpp
View File

@ -11,167 +11,146 @@
// Right Flags :
enum {
RIGHT_OTHER_EXECUTE = 1 << 0,
RIGHT_OTHER_WRITE = 1 << 1,
RIGHT_OTHER_READ = 1 << 2,
RIGHT_GROUP_EXECUTE = 1 << 3,
RIGHT_GROUP_WRITE = 1 << 4,
RIGHT_GROUP_READ = 1 << 5,
RIGHT_USER_EXECUTE = 1 << 6,
RIGHT_USER_WRITE = 1 << 7,
RIGHT_USER_READ = 1 << 8,
right_other_execute = 1 << 0,
right_other_write = 1 << 1,
right_other_read = 1 << 2,
right_group_execute = 1 << 3,
right_group_write = 1 << 4,
right_group_read = 1 << 5,
right_user_execute = 1 << 6,
right_user_write = 1 << 7,
right_user_read = 1 << 8,
};
etk::FSNodeRight::FSNodeRight() :
m_rights(0)
{
m_rights(0) {
}
etk::FSNodeRight::FSNodeRight(int16_t _newRight) :
m_rights(_newRight&0x01FF)
{
m_rights(_newRight&0x01FF) {
}
// copy operator :
const etk::FSNodeRight& etk::FSNodeRight::operator= (const etk::FSNodeRight &_obj )
{
etk::FSNodeRight& etk::FSNodeRight::operator= (const etk::FSNodeRight &_obj ) {
m_rights = _obj.m_rights;
return *this;
}
// set right :
const etk::FSNodeRight& etk::FSNodeRight::operator= (const int32_t _newVal )
{
etk::FSNodeRight& etk::FSNodeRight::operator= (const int32_t _newVal) {
m_rights = _newVal&0x01FF;
return *this;
}
// User
bool etk::FSNodeRight::isUserReadable() const
{
return ((m_rights&RIGHT_USER_READ)!=0)?true:false;
void etk::FSNodeRight::clear() {
m_rights = 0;
}
bool etk::FSNodeRight::isUserWritable() const
{
return ((m_rights&RIGHT_USER_WRITE)!=0)?true:false;
bool etk::FSNodeRight::isUserReadable() const {
return ((m_rights&right_user_read)!=0)?true:false;
}
bool etk::FSNodeRight::isUserRunable() const
{
return ((m_rights&RIGHT_USER_EXECUTE)!=0)?true:false;
bool etk::FSNodeRight::isUserWritable() const {
return ((m_rights&right_user_write)!=0)?true:false;
}
void etk::FSNodeRight::setUserReadable(bool _newStatus)
{
bool etk::FSNodeRight::isUserRunable() const {
return ((m_rights&right_user_execute)!=0)?true:false;
}
void etk::FSNodeRight::setUserReadable(bool _newStatus) {
// reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_USER_READ);
if (true == _newStatus) {
m_rights |= RIGHT_USER_READ;
m_rights &= (0xFFFFFFFF - right_user_read);
if (_newStatus == true) {
m_rights |= right_user_read;
}
}
void etk::FSNodeRight::setUserWritable(bool _newStatus)
{
void etk::FSNodeRight::setUserWritable(bool _newStatus) {
// reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_USER_WRITE);
if (true == _newStatus) {
m_rights |= RIGHT_USER_WRITE;
m_rights &= (0xFFFFFFFF - right_user_write);
if (_newStatus == true) {
m_rights |= right_user_write;
}
}
void etk::FSNodeRight::setUserRunable(bool _newStatus)
{
void etk::FSNodeRight::setUserRunable(bool _newStatus) {
// reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_USER_EXECUTE);
if (true == _newStatus) {
m_rights |= RIGHT_USER_EXECUTE;
m_rights &= (0xFFFFFFFF - right_user_execute);
if (_newStatus == true) {
m_rights |= right_user_execute;
}
}
// group
bool etk::FSNodeRight::isGroupReadable() const
{
return ((m_rights&RIGHT_GROUP_READ)!=0)?true:false;
bool etk::FSNodeRight::isGroupReadable() const {
return ((m_rights&right_group_read)!=0)?true:false;
}
bool etk::FSNodeRight::isGroupWritable() const
{
return ((m_rights&RIGHT_GROUP_WRITE)!=0)?true:false;
bool etk::FSNodeRight::isGroupWritable() const {
return ((m_rights&right_group_write)!=0)?true:false;
}
bool etk::FSNodeRight::isGroupRunable() const
{
return ((m_rights&RIGHT_GROUP_EXECUTE)!=0)?true:false;
bool etk::FSNodeRight::isGroupRunable() const {
return ((m_rights&right_group_execute)!=0)?true:false;
}
void etk::FSNodeRight::setGroupReadable(bool _newStatus)
{
void etk::FSNodeRight::setGroupReadable(bool _newStatus) {
// reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_GROUP_READ);
m_rights &= (0xFFFFFFFF - right_group_read);
if (true == _newStatus) {
m_rights |= RIGHT_GROUP_READ;
m_rights |= right_group_read;
}
}
void etk::FSNodeRight::setGroupWritable(bool _newStatus)
{
void etk::FSNodeRight::setGroupWritable(bool _newStatus) {
// reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_GROUP_WRITE);
m_rights &= (0xFFFFFFFF - right_group_write);
if (true == _newStatus) {
m_rights |= RIGHT_GROUP_WRITE;
m_rights |= right_group_write;
}
}
void etk::FSNodeRight::setGroupRunable(bool _newStatus)
{
void etk::FSNodeRight::setGroupRunable(bool _newStatus) {
// reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_GROUP_EXECUTE);
m_rights &= (0xFFFFFFFF - right_group_execute);
if (true == _newStatus) {
m_rights |= RIGHT_GROUP_EXECUTE;
m_rights |= right_group_execute;
}
}
// other
bool etk::FSNodeRight::isOtherReadable() const
{
return ((m_rights&RIGHT_OTHER_READ) != 0)?true:false;
bool etk::FSNodeRight::isOtherReadable() const {
return ((m_rights&right_other_read) != 0)?true:false;
}
bool etk::FSNodeRight::isOtherWritable() const
{
return ((m_rights&RIGHT_OTHER_WRITE) != 0)?true:false;
bool etk::FSNodeRight::isOtherWritable() const {
return ((m_rights&right_other_write) != 0)?true:false;
}
bool etk::FSNodeRight::isOtherRunable() const
{
return ((m_rights&RIGHT_OTHER_EXECUTE) != 0)?true:false;
bool etk::FSNodeRight::isOtherRunable() const {
return ((m_rights&right_other_execute) != 0)?true:false;
}
void etk::FSNodeRight::setOtherReadable(bool _newStatus)
{
// reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_OTHER_READ);
if (true == _newStatus) {
m_rights |= RIGHT_OTHER_READ;
void etk::FSNodeRight::setOtherReadable(bool _newStatus) {
// reset the flag:
m_rights &= (0xFFFFFFFF - right_other_read);
if (_newStatus == true) {
m_rights |= right_other_read;
}
}
void etk::FSNodeRight::setOtherWritable(bool _newStatus)
{
void etk::FSNodeRight::setOtherWritable(bool _newStatus) {
// reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_OTHER_WRITE);
if (true == _newStatus) {
m_rights |= RIGHT_OTHER_WRITE;
m_rights &= (0xFFFFFFFF - right_other_write);
if (_newStatus == true) {
m_rights |= right_other_write;
}
}
void etk::FSNodeRight::setOtherRunable(bool _newStatus)
{
void etk::FSNodeRight::setOtherRunable(bool _newStatus) {
// reset the flag :
m_rights &= (0xFFFFFFFF - RIGHT_OTHER_EXECUTE);
if (true == _newStatus) {
m_rights |= RIGHT_OTHER_EXECUTE;
m_rights &= (0xFFFFFFFF - right_other_execute);
if (_newStatus == true) {
m_rights |= right_other_execute;
}
}
#if __CPP_VERSION__ >= 2011

129
etk/os/FSNodeRight.h
View File

@ -11,45 +11,144 @@
#pragma once
namespace etk {
/**
* @brief File System Right management
*/
class FSNodeRight {
private:
uint16_t m_rights;
uint16_t m_rights; //!< right manage in a bit field
public:
FSNodeRight();
FSNodeRight(int16_t _newRight);
~FSNodeRight() { };
// copy operator :
const etk::FSNodeRight& operator= (const etk::FSNodeRight &_obj );
// set right :
const etk::FSNodeRight& operator= (const int32_t _newVal );
void clear() {
m_rights = 0;
};
// User
/**
* @brief Right contructor.
* @param[in] _newRight Right to set by default
*/
FSNodeRight(int16_t _newRight = 0);
/**
* @brief Copy asignement operator (operator=)
* @param[in] _obj Object to copy
* @return Local reference on the object
*/
etk::FSNodeRight& operator= (const etk::FSNodeRight &_obj);
/**
* @brief Asignement operator (operator=)
* @param[in] _newVal Value to set on the right
* @return Local reference on the object
*/
etk::FSNodeRight& operator= (const int32_t _newVal );
/**
* @brief Clear right (set the value at 0 ==> cant not be read/write/execute
*/
void clear();
/**
* @brief Get the "Read status" for the "User"
* @return true The file/folder/... is readable
* @return false The file/folder/... is NOT readable
*/
bool isUserReadable() const;
/**
* @brief Get the "Write status" for the "User"
* @return true The file/folder/... is writable
* @return false The file/folder/... is NOT writable
*/
bool isUserWritable() const;
/**
* @brief Get the "execute status" for the "User"
* @return true The file/folder/... is executable
* @return false The file/folder/... is NOT executable
*/
bool isUserRunable() const;
/**
* @brief Set the "Read status" for the "User"
* @param[in] _newStatus New value to set on the file/folder/...
*/
void setUserReadable(bool _newStatus);
/**
* @brief Set the "Write status" for the "User"
* @param[in] _newStatus New value to set on the file/folder/...
*/
void setUserWritable(bool _newStatus);
/**
* @brief Set the "execute status" for the "User"
* @param[in] _newStatus New value to set on the file/folder/...
*/
void setUserRunable(bool _newStatus);
// group
/**
* @brief Get the "Read status" for the "Group"
* @return true The file/folder/... is readable
* @return false The file/folder/... is NOT readable
*/
bool isGroupReadable() const;
/**
* @brief Get the "Write status" for the "Group"
* @return true The file/folder/... is writable
* @return false The file/folder/... is NOT writable
*/
bool isGroupWritable() const;
/**
* @brief Get the "execute status" for the "Group"
* @return true The file/folder/... is executable
* @return false The file/folder/... is NOT executable
*/
bool isGroupRunable() const;
/**
* @brief Set the "Read status" for the "Group"
* @param[in] _newStatus New value to set on the file/folder/...
*/
void setGroupReadable(bool _newStatus);
/**
* @brief Set the "Write status" for the "Group"
* @param[in] _newStatus New value to set on the file/folder/...
*/
void setGroupWritable(bool _newStatus);
/**
* @brief Set the "Execute status" for the "Group"
* @param[in] _newStatus New value to set on the file/folder/...
*/
void setGroupRunable(bool _newStatus);
// other
/**
* @brief Get the "Read status" for the "Other"
* @return true The file/folder/... is readable
* @return false The file/folder/... is NOT readable
*/
bool isOtherReadable() const;
/**
* @brief Get the "Write status" for the "Other"
* @return true The file/folder/... is writable
* @return false The file/folder/... is NOT writable
*/
bool isOtherWritable() const;
/**
* @brief Get the "execute status" for the "Other"
* @return true The file/folder/... is executable
* @return false The file/folder/... is NOT executable
*/
bool isOtherRunable() const;
/**
* @brief Set the "Read status" for the "Other"
* @param[in] _newStatus New value to set on the file/folder/...
*/
void setOtherReadable(bool _newStatus);
/**
* @brief Set the "Write status" for the "Other"
* @param[in] _newStatus New value to set on the file/folder/...
*/
void setOtherWritable(bool _newStatus);
/**
* @brief Set the "Execute status" for the "Other"
* @param[in] _newStatus New value to set on the file/folder/...
*/
void setOtherRunable(bool _newStatus);
#if __CPP_VERSION__ >= 2011
/**
* @brief Get the write written in a string mode (like in linux rw-r-----)
* @return String with the right in string
*/
std::u32string getURight() const;
#endif
/**
* @brief Get the write written in a string mode (like in linux rw-r-----)
* @return String with the right in string
*/
std::string getRight() const;
};
//! @not_in_doc

5
etk/os/Fifo.h
View File

@ -103,7 +103,10 @@ namespace etk {
m_data.push_back(_data);
m_condition.notify_all();
};
//! @previous
/**
* @brief Send a message at the other thread by setting a new message in the fifo.
* @param[in] _data New data to add at the fifo.
*/
void post(const MY_TYPE &_data) {
std::unique_lock<std::mutex> lock(m_mutex);
m_data.push_back(_data);

8
etk/stdTools.cpp
View File

@ -9,8 +9,6 @@
#include <etk/stdTools.h>
#include <etk/debug.h>
#undef __class__
#define __class__ "u32char"
const char32_t u32char::Null('\0');
const char32_t u32char::Return('\n');
@ -137,10 +135,6 @@ int8_t u32char::convertUtf8(char32_t _val, char _output[5]) {
}
#endif
#undef __class__
#define __class__ "utf8"
static uint8_t sizeElement(const char* _data, int32_t _lenMax) {
uint8_t size = 0;
TK_ASSERT(0 <= _lenMax, "size can not be < 0 ...");
@ -309,8 +303,6 @@ char32_t utf8::iterator::operator* () {
}
#undef __class__
#define __class__ "etk"
namespace etk {
#if __CPP_VERSION__ >= 2011
template<> std::string to_string<std::u32string>(const std::u32string& _input) {

189
etk/stdTools.h
View File

@ -16,35 +16,66 @@
#include <algorithm>
#include <chrono>
/**
* @brief Unicode simple wrapper interface
*/
namespace u32char {
extern const char32_t Null; //!< '\0'
extern const char32_t Return; //!< '\n'
extern const char32_t CarrierReturn; //!< '\r' CR
extern const char32_t Tabulation; //!< '\t' TAB
extern const char32_t Suppress; //!< BS (SUPPRESS)
extern const char32_t Delete; //!< DEL
extern const char32_t Space; //!< ' ' SPACE
extern const char32_t Escape; //!< ESC Escape
extern const char32_t Null; //!< Value '\\0'
extern const char32_t Return; //!< Value '\\n'
extern const char32_t CarrierReturn; //!< Value '\\r' CR
extern const char32_t Tabulation; //!< Value '\\t' TAB
extern const char32_t Suppress; //!< Value BS (SUPPRESS)
extern const char32_t Delete; //!< Value DEL
extern const char32_t Space; //!< Value ' ' SPACE
extern const char32_t Escape; //!< Value ESC Escape
/**
* @brief check if the current element is white or not : '\t' '\n' '\r' ' '
* @return tue if it is white char
* @brief check if the current element is white or not : '\\t' '\\n' '\\r' ' '
* @param[in] _val Value to interprete
* @return true if it is white char
* @return false otherwise
*/
bool isWhiteChar(char32_t _val);
/**
* @brief check if the current element is NOT [a-zA-Z0-9]
* @param[in] _val Value to interprete
* @return true Not in the previous list
* @return false otherwise
*/
bool isSpecialChar(char32_t _val);
/**
* @brief check if the curent element is number or not
* @return tue if it is a number char
* @brief check if the curent element is number or not [0-9]
* @param[in] _val Value to interprete
* @return true if it is a number char
* @return false otherwise
*/
bool isInteger(char32_t _val);
/**
* @brief Convert char32_t in an interfer
* @param[in] _val Value to interprete
* @return The parsed Value or ...
*/
int32_t toInt(char32_t _val);
/**
* @brief Change order of the value to have an order of display with A->Z and after a->z and after 0->9 and after all the rest ....
* @param[in] _val Value in unicode
* @return A value usable in interfer only ... to check order...
*/
char32_t changeOrder(char32_t _val);
/**
* @brief Conver unicode in UTF8 value
* @param[in] _val Value to convert
* @param[out] _output Char data converted
* @return Number of char in utf8
*/
int8_t convertUtf8(char32_t _val, char _output[5]);
#if __CPP_VERSION__ >= 2011
std::string convertToUtf8(const std::u32string& _input);
#endif
};
/**
* @brief UTF-8 simple wrapper interface
*/
namespace utf8 {
/**
* @brief Get the size of an utf8 char with his first char.
@ -58,7 +89,11 @@ namespace utf8 {
* @return true if it was the first char.
*/
bool theoricFirst(const char _input);
/**
* @brief Convert a char* in a unicode value
* @param[in] _input pointer on a string C (utf-8) to convert
* @return Converted Value
*/
char32_t convertChar32(const char* _input);
#if __CPP_VERSION__ >= 2011
std::u32string convertUnicode(const std::string& _input);
@ -402,41 +437,61 @@ namespace utf8 {
namespace std {
#if (defined(__TARGET_OS__MacOs) || defined(__TARGET_OS__Windows))
typedef std::basic_string<char32_t> u32string;
using u32string = std::basic_string<char32_t>;
#endif
#if (defined(__TARGET_OS__Android))
//! @previous
//! @not_in_doc
std::string to_string(int _val);
//! @previous
//! @not_in_doc
std::string to_string(long _val);
//! @previous
//! @not_in_doc
std::string to_string(long long _val);
//! @previous
//! @not_in_doc
std::string to_string(unsigned _val);
//! @previous
//! @not_in_doc
std::string to_string(unsigned long _val);
//! @previous
//! @not_in_doc
std::string to_string(unsigned long long _val);
//! @previous
//! @not_in_doc
std::string to_string(float _val);
//! @previous
//! @not_in_doc
std::string to_string(double _val);
//! @previous
//! @not_in_doc
std::string to_string(long double _val);
//! @not_in_doc
double stod(const std::string& _str, size_t* _idx = 0);
//! @not_in_doc
float stof(const std::string& _str, size_t* _idx = 0);
//! @not_in_doc
int stoi(const std::string& _str, size_t* _idx = 0, int _base = 10);
//! @not_in_doc
long stol(const std::string& _str, size_t* _idx = 0, int _base = 10);
//! @not_in_doc
long double stold(const std::string& _str, size_t* _idx = 0);
//! @not_in_doc
long long stoll(const std::string& _str, size_t* _idx = 0, int _base = 10);
//! @not_in_doc
unsigned long stoul(const std::string& _str, size_t* _idx = 0, int _base = 10);
//! @not_in_doc
unsigned long long stoull(const std::string& _str, size_t* _idx = 0, int _base = 10);
#endif
};
namespace etk {
// these declaration is to prevent some under template declaration of unknown type
template <class TYPE> std::string to_string(const TYPE& _variable);
template <class TYPE> std::string to_string(const std::vector<TYPE>& _list) {
/**
* @brief Template to declare convertion from anything in std::string
* @param[in] _variable Variable to convert
* @return String of the value
*/
template <class TYPE>
std::string to_string(const TYPE& _variable);
/**
* @brief Template to declare convertion from std::vector<anything> in std::string
* @param[in] _list Variable to convert
* @return String of the value: {...,...,...}
*/
template <class TYPE>
std::string to_string(const std::vector<TYPE>& _list) {
std::string out = "{";
for (size_t iii=0; iii<_list.size(); ++iii) {
if (iii!=0) {
@ -448,131 +503,142 @@ namespace etk {
return out;
}
#if __CPP_VERSION__ >= 2011
template <class TYPE> std::u32string to_u32string(const TYPE& _variable);
template <class TYPE>
std::u32string to_u32string(const TYPE& _variable);
#endif
// these declaration is to prevent some under template declaration of unknown type
template <class TYPE> bool from_string(TYPE& _variableRet, const std::string& _value);
/**
* @brief Template to declare convertion from string to anything
* @param[out] _variableRet Output value
* @param[in] _value input property
* @return true if the can be converted.
*/
template <class TYPE>
bool from_string(TYPE& _variableRet, const std::string& _value);
#if __CPP_VERSION__ >= 2011
template <class TYPE> bool from_string(TYPE& _variableRet, const std::u32string& _value);
template <class TYPE>
bool from_string(TYPE& _variableRet, const std::u32string& _value);
#endif
// TODO : Change this in :
// TODO : template <typename TYPE> TYPE string_to<TYPE>(const std::u32string& _value); ==> check exceptions ...
//! @not_in_doc
long double string_to_long_double(const std::string& _str);
#if __CPP_VERSION__ >= 2011
long double string_to_long_double(const std::u32string& _str);
#endif
//! @not_in_doc
double string_to_double(const std::string& _str);
#if __CPP_VERSION__ >= 2011
double string_to_double(const std::u32string& _str);
#endif
//! @not_in_doc
float string_to_float(const std::string& _str);
#if __CPP_VERSION__ >= 2011
float string_to_float(const std::u32string& _str);
#endif
//! @not_in_doc
int8_t string_to_int8_t(const std::string& _str, int _base = 10);
#if __CPP_VERSION__ >= 2011
int8_t string_to_int8_t(const std::u32string& _str, int _base = 10);
#endif
//! @not_in_doc
int16_t string_to_int16_t(const std::string& _str, int _base = 10);
#if __CPP_VERSION__ >= 2011
int16_t string_to_int16_t(const std::u32string& _str, int _base = 10);
#endif
//! @not_in_doc
int32_t string_to_int32_t(const std::string& _str, int _base = 10);
#if __CPP_VERSION__ >= 2011
int32_t string_to_int32_t(const std::u32string& _str, int _base = 10);
#endif
//! @not_in_doc
int64_t string_to_int64_t(const std::string& _str, int _base = 10);
#if __CPP_VERSION__ >= 2011
int64_t string_to_int64_t(const std::u32string& _str, int _base = 10);
#endif
//! @not_in_doc
uint8_t string_to_uint8_t(const std::string& _str, int _base = 10);
#if __CPP_VERSION__ >= 2011
uint8_t string_to_uint8_t(const std::u32string& _str, int _base = 10);
#endif
//! @not_in_doc
uint16_t string_to_uint16_t(const std::string& _str, int _base = 10);
#if __CPP_VERSION__ >= 2011
uint16_t string_to_uint16_t(const std::u32string& _str, int _base = 10);
#endif
//! @not_in_doc
uint32_t string_to_uint32_t(const std::string& _str, int _base = 10);
#if __CPP_VERSION__ >= 2011
uint32_t string_to_uint32_t(const std::u32string& _str, int _base = 10);
#endif
//! @not_in_doc
uint64_t string_to_uint64_t(const std::string& _str, int _base = 10);
#if __CPP_VERSION__ >= 2011
uint64_t string_to_uint64_t(const std::u32string& _str, int _base = 10);
#endif
//! @not_in_doc
bool string_to_bool(const std::string& _str);
#if __CPP_VERSION__ >= 2011
bool string_to_bool(const std::u32string& _str);
#endif
//! @not_in_doc
std::string tolower(std::string _obj);
#if __CPP_VERSION__ >= 2011
//! @previous
std::u32string tolower(std::u32string _obj);
#endif
//! @not_in_doc
std::string toupper(std::string _obj);
#if __CPP_VERSION__ >= 2011
//! @previous
std::u32string toupper(std::u32string _obj);
#endif
//! @not_in_doc
bool compare_no_case(const std::string& _obj, const std::string& _val);
#if __CPP_VERSION__ >= 2011
//! @previous
bool compare_no_case(const std::u32string& _obj, const std::u32string& _val);
#endif
//! @not_in_doc
bool end_with(const std::string& _obj, const std::string& _val, bool _caseSensitive = true);
#if __CPP_VERSION__ >= 2011
//! @previous
bool end_with(const std::u32string& _obj, const std::u32string& _val, bool _caseSensitive = true);
#endif
//! @not_in_doc
bool start_with(const std::string& _obj, const std::string& _val, bool _caseSensitive = true);
#if __CPP_VERSION__ >= 2011
//! @previous
bool start_with(const std::u32string& _obj, const std::u32string& _val, bool _caseSensitive = true);
#endif
//! @not_in_doc
std::string replace(const std::string& _obj, char _val, char _replace);
#if __CPP_VERSION__ >= 2011
//! @previous
std::u32string replace(const std::u32string& _obj, char32_t _val, char32_t _replace);
#endif
//! @not_in_doc
std::string extract_line(const std::string& _obj, int32_t _pos);
#if __CPP_VERSION__ >= 2011
//! @previous
std::u32string extract_line(const std::u32string& _obj, int32_t _pos);
#endif
//! @not_in_doc
std::vector<std::string> split(const std::string& _input, char _val);
#if __CPP_VERSION__ >= 2011
//! @previous
std::vector<std::u32string> split(const std::u32string& _input, char32_t _val);
#endif
//! @not_in_doc
void sort(std::vector<std::string *>& _list);
#if __CPP_VERSION__ >= 2011
//! @previous
void sort(std::vector<std::u32string *>& _list);
#endif
template<typename T, typename T2> bool isIn(const T& _val, const std::vector<T2>& _list) {
//! @not_in_doc
template<typename T, typename T2>
bool isIn(const T& _val, const std::vector<T2>& _list) {
for (size_t iii=0; iii<_list.size(); ++iii) {
if (_list[iii] == _val) {
return true;
@ -583,8 +649,15 @@ namespace etk {
};
namespace std {
template <class TYPE> const TYPE& avg(const TYPE& a, const TYPE& b, const TYPE& c) {
return std::min(std::max(a,b),c);
/**
* @brief in std, we have min, max but not avg ==> it is missing... the Defineing avg template.
* @param[in] _min Minimum value of the range
* @param[in] _val The value that we want a min/max
* @param[in] _max Maximum value of the range
* @return Value that min/max applied
*/
template <class TYPE> const TYPE& avg(const TYPE& _min, const TYPE& _val, const TYPE& _max) {
return std::min(std::max(_min,_val),_max);
}
};
@ -623,10 +696,14 @@ namespace std {
std::ostream& operator <<(std::ostream& _os, const std::chrono::system_clock::time_point& _obj);
//! @not_in_doc
std::ostream& operator <<(std::ostream& _os, const std::chrono::steady_clock::time_point& _obj);
};
}
int32_t strlen(const char32_t * _data);
/**
* @brief Claculate the size of a string (unicode)
* @param[in] _data Data to parse to find the end of string
* @return the Number of char32_t befor the '\\0' value
*/
int32_t strlen(const char32_t* _data);
#if (defined(__TARGET_OS__Windows))
#define M_PI 3.14159265358979323846

13
etk/tool.h
View File

@ -11,15 +11,24 @@
#pragma once
namespace etk {
/**
* @brief Some un-usefull tools
* @todo Remove all of this use std11 random
*/
namespace tool {
/**
* @brief Get a random value in a specific range.
* @brief Get a random value in a specific range in float.
* @param[in] _a Lower value of the random.
* @param[in] _b Bigger value of the random.
* @return Random Value between [_a and _b]
*/
double frand(double _a, double _b);
//! @previous
/**
* @brief Get a random value in a specific range in integer.
* @param[in] _a Lower value of the random.
* @param[in] _b Bigger value of the random.
* @return Random Value between [_a and _b]
*/
int32_t irand(int32_t _a, int32_t _b);
/**
* @brief Reset the random system with a random value (time).

6
etk/types.h
View File

@ -44,13 +44,15 @@
#include <etk/stdTools.h>
#ifndef ETK_BUILD_LINEARMATH
typedef float btScalar;
//! @brief If not using linear math from bullet lib, we need to define the basic element of a btScalar (float)
using btScalar = float;
#endif
#ifndef _WIN32
#include <math.h>
#ifndef _MATH_H_MATHDEF
typedef float float_t;
//! @not_in_doc
using float_t = float;
#endif
#endif

4
test/main.cpp
View File

@ -26,10 +26,6 @@
#include "testHash.hpp"
#include "testStdShared.hpp"
#undef __class__
#define __class__ "etktest"
int main(int argc, const char *argv[]) {
// init Google test :
::testing::InitGoogleTest(&argc, const_cast<char **>(argv));

3
test/testArchive.hpp
View File

@ -10,9 +10,6 @@
#undef NAME
#define NAME "Archive"
#undef __class__
#define __class__ "etktest"
#ifdef ETK_BUILD_MINIZIP
TEST(TestEtkArchive, CreationWrong) {

3
test/testColor.hpp
View File

@ -10,9 +10,6 @@
#undef NAME
#define NAME "Color"
#undef __class__
#define __class__ "etktest"
TEST(TestEtkColor, RGBA8) {
etk::Color<uint8_t, 4> colorRGBA8(0x52,0x0F, 0x65, 0x44);
EXPECT_EQ(colorRGBA8.r(), 0x52);

3
test/testFSNode.hpp
View File

@ -10,9 +10,6 @@
#undef NAME
#define NAME "FSNode"
#undef __class__
#define __class__ "etktest"
TEST(TestEtkFSNode, checkType) {
std::string fileName("USERDATA:myFileTest.txt");
etk::FSNode myNodeTest1(fileName);

3
test/testHash.hpp
View File

@ -11,9 +11,6 @@
#undef NAME
#define NAME "Hash"
#undef __class__
#define __class__ "etktest"
TEST(TestEtkHash, Creation) {
etk::Hash<std::string> testData;
EXPECT_EQ(testData.size(), 0);

3
test/testStdShared.hpp
View File

@ -11,9 +11,6 @@
#undef NAME
#define NAME "Shared_ptr"
#undef __class__
#define __class__ "etktest"
class Example : public std::enable_shared_from_this<Example> {
protected:
int32_t m_id;