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

[DEV] update to the bullet vector common type

Browse Source
This commit is contained in:
Edouard DUPIN 2013-01-25 21:58:05 +01:00
parent 404b68ec9f
commit 0f43afbed2
2 changed files with 118 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

116
draw/Image.cpp
View File

@ -34,12 +34,12 @@ draw::Image::Image(void) :
m_strokeColor(0,0,0,0), m_strokeColor(0,0,0,0),
m_strokeSize(0) m_strokeSize(0)
{ {
m_size.x = 32; m_size.setX(32);
m_size.y = 32; m_size.setY(32);
Init(); Init();
} }
draw::Image::Image(etk::Vector2D<int32_t> size) : draw::Image::Image(ivec2 size) :
m_renderingBuffer(NULL), m_renderingBuffer(NULL),
m_pixFrame(NULL), m_pixFrame(NULL),
m_renderBase(NULL), m_renderBase(NULL),
@ -57,13 +57,13 @@ void draw::Image::Init(void)
// basic element : // basic element :
draw::Color tmpBg(0,0,0,0); draw::Color tmpBg(0,0,0,0);
// preallocate data with a basic bg elements : // preallocate data with a basic bg elements :
m_data.ReSize(m_size.x*m_size.y, tmpBg); m_data.ReSize(m_size.x()*m_size.y(), tmpBg);
if (m_size.x*m_size.y > m_data.Size()) { if (m_size.x()*m_size.y() > m_data.Size()) {
DRAW_ERROR("Allocation of data buffer in error"); DRAW_ERROR("Allocation of data buffer in error");
return; return;
} }
// Allocate the AGG renderer system : // Allocate the AGG renderer system :
m_renderingBuffer = new agg::rendering_buffer((uint8_t*)&m_data[0], m_size.x, m_size.y, m_size.x*sizeof(draw::Color)); m_renderingBuffer = new agg::rendering_buffer((uint8_t*)&m_data[0], m_size.x(), m_size.y(), m_size.x()*sizeof(draw::Color));
if (NULL == m_renderingBuffer) { if (NULL == m_renderingBuffer) {
DRAW_ERROR("Allocation of the m_renderingBuffer for SVG drawing error"); DRAW_ERROR("Allocation of the m_renderingBuffer for SVG drawing error");
return; return;
@ -120,7 +120,7 @@ draw::Image::~Image(void)
} }
} }
void draw::Image::Resize(etk::Vector2D<int32_t> size) void draw::Image::Resize(ivec2 size)
{ {
if (NULL != m_renderArea) { if (NULL != m_renderArea) {
delete(m_renderArea); delete(m_renderArea);
@ -142,13 +142,13 @@ void draw::Image::Resize(etk::Vector2D<int32_t> size)
// basic element : // basic element :
draw::Color tmpBg(0,0,0,0); draw::Color tmpBg(0,0,0,0);
// preallocate data with a basic bg elements : // preallocate data with a basic bg elements :
m_data.ReSize(m_size.x*m_size.y, tmpBg); m_data.ReSize(m_size.x()*m_size.y(), tmpBg);
if (m_size.x*m_size.y > m_data.Size()) { if (m_size.x()*m_size.y() > m_data.Size()) {
DRAW_ERROR("Allocation of data buffer in error"); DRAW_ERROR("Allocation of data buffer in error");
return; return;
} }
// Allocate the AGG renderer system : // Allocate the AGG renderer system :
m_renderingBuffer = new agg::rendering_buffer((uint8_t*)&m_data[0], m_size.x, m_size.y, m_size.x*sizeof(draw::Color)); m_renderingBuffer = new agg::rendering_buffer((uint8_t*)&m_data[0], m_size.x(), m_size.y(), m_size.x()*sizeof(draw::Color));
if (NULL == m_renderingBuffer) { if (NULL == m_renderingBuffer) {
DRAW_ERROR("Allocation of the m_renderingBuffer for SVG drawing error"); DRAW_ERROR("Allocation of the m_renderingBuffer for SVG drawing error");
return; return;
@ -196,22 +196,22 @@ void draw::Image::End(void)
} }
void draw::Image::MoveTo(etk::Vector2D<float> pos) void draw::Image::MoveTo(vec2 pos)
{ {
} }
void draw::Image::MoveToAbs(etk::Vector2D<float> pos) void draw::Image::MoveToAbs(vec2 pos)
{ {
} }
void draw::Image::LineTo(etk::Vector2D<float> pos) void draw::Image::LineTo(vec2 pos)
{ {
} }
void draw::Image::LineToAbs(etk::Vector2D<float> pos) void draw::Image::LineToAbs(vec2 pos)
{ {
} }
@ -226,7 +226,7 @@ void draw::Image::Draw(void)
} }
void draw::Image::Dot(etk::Vector2D<float> pos) void draw::Image::Dot(vec2 pos)
{ {
/* /*
Begin(); Begin();
@ -237,7 +237,7 @@ void draw::Image::Dot(etk::Vector2D<float> pos)
Set(pos, m_fillColor); Set(pos, m_fillColor);
} }
void draw::Image::Line(etk::Vector2D<float> posStart, etk::Vector2D<float> posEnd) void draw::Image::Line(vec2 posStart, vec2 posEnd)
{ {
Begin(); Begin();
MoveTo(posStart); MoveTo(posStart);
@ -245,27 +245,27 @@ void draw::Image::Line(etk::Vector2D<float> posStart, etk::Vector2D<float> posEn
End(); End();
} }
void draw::Image::Rectangle(etk::Vector2D<float> pos, etk::Vector2D<float> size) void draw::Image::Rectangle(vec2 pos, vec2 size)
{ {
Begin(); Begin();
etk::Vector2D<float> tmp = pos; vec2 tmp = pos;
MoveTo(pos); MoveTo(pos);
tmp.x += size.x; tmp += vec2(size.x(),0);
LineTo(tmp); LineTo(tmp);
tmp.y += size.y; tmp += vec2(0,size.y());
LineTo(tmp); LineTo(tmp);
tmp.x -= size.x; tmp -= vec2(size.x(),0);
LineTo(tmp); LineTo(tmp);
Join(); Join();
End(); End();
} }
void draw::Image::Circle(etk::Vector2D<float> pos, float radius, float angleStart, float angleStop) void draw::Image::Circle(vec2 pos, float radius, float angleStart, float angleStop)
{ {
} }
void draw::Image::Disc(etk::Vector2D<float> pos, float radius, float angleStart, float angleStop) void draw::Image::Disc(vec2 pos, float radius, float angleStart, float angleStop)
{ {
} }
@ -274,34 +274,34 @@ void draw::Image::Disc(etk::Vector2D<float> pos, float radius, float angleStart,
void Grid::GenerateSDF() void Grid::GenerateSDF()
{ {
// Pass 0 // Pass 0
etk::Vector2D<int32_t> tmpPos; ivec2 tmpPos(1,1);
for (tmpPos.y=1 ; tmpPos.y<m_size.y-1 ; tmpPos.y++) { for (tmpPos.setY(1) ; tmpPos.y()<m_size.y()-1 ; tmpPos+=vec2(0,1)) {
for (tmpPos.x=1 ; tmpPos.x<m_size.x-1 ; tmpPos.x++) { for (tmpPos.setX(1) ; tmpPos.x()<m_size.x()-1 ; tmpPos+=vec2(1,0) ) {
etk::Vector2D<int32_t> p = Get(tmpPos); ivec2 p = Get(tmpPos);
Compare(p, tmpPos, -1, 0 ); Compare(p, tmpPos, -1, 0 );
Compare(p, tmpPos, 0, -1 ); Compare(p, tmpPos, 0, -1 );
Compare(p, tmpPos, -1, -1 ); Compare(p, tmpPos, -1, -1 );
Compare(p, tmpPos, 1, -1 ); Compare(p, tmpPos, 1, -1 );
Set(tmpPos, p); Set(tmpPos, p);
} }
for (tmpPos.x=m_size.x-2 ; tmpPos.x>0 ; tmpPos.x--) { for (tmpPos.setX(m_size.x()-2) ; tmpPos.x()>0 ; tmpPos-=vec2(1,0) ) {
etk::Vector2D<int32_t> p = Get(tmpPos); ivec2 p = Get(tmpPos);
Compare(p, tmpPos, 1, 0 ); Compare(p, tmpPos, 1, 0 );
Set(tmpPos, p ); Set(tmpPos, p );
} }
} }
// Pass 1 // Pass 1
for (tmpPos.y=m_size.y-2 ; tmpPos.y>0 ; tmpPos.y--) { for (tmpPos.setY(m_size.y()-2) ; tmpPos.y()>0 ; tmpPos-=vec2(0,1)) {
for (tmpPos.x=m_size.x-2 ; tmpPos.x>1 ; tmpPos.x--) { for (tmpPos.setX(m_size.x()-2) ; tmpPos.x()>1 ; tmpPos-=vec2(1,0)) {
etk::Vector2D<int32_t> p = Get(tmpPos); ivec2 p = Get(tmpPos);
Compare(p, tmpPos, 1, 0 ); Compare(p, tmpPos, 1, 0 );
Compare(p, tmpPos, 0, 1 ); Compare(p, tmpPos, 0, 1 );
Compare(p, tmpPos, -1, 1 ); Compare(p, tmpPos, -1, 1 );
Compare(p, tmpPos, 1, 1 ); Compare(p, tmpPos, 1, 1 );
Set(tmpPos, p); Set(tmpPos, p);
} }
for (tmpPos.x=1 ; tmpPos.x<m_size.x-1 ; tmpPos.x++) { for (tmpPos.setX(1) ; tmpPos.x()<m_size.x()-1 ; tmpPos+=vec2(1,0)) {
etk::Vector2D<int32_t> p = Get(tmpPos); ivec2 p = Get(tmpPos);
Compare(p, tmpPos, -1, 0 ); Compare(p, tmpPos, -1, 0 );
Set(tmpPos, p); Set(tmpPos, p);
} }
@ -312,29 +312,29 @@ void Grid::GenerateSDF()
void draw::Image::DistanceField(void) void draw::Image::DistanceField(void)
{ {
DistanceField(etk::Vector2D<int32_t>(0,0), m_size); DistanceField(ivec2(0,0), m_size);
} }
#endif #endif
#define META_DIST (8) #define META_DIST (8)
void draw::Image::DistanceField(etk::Vector2D<int32_t> pos, etk::Vector2D<int32_t> size, int32_t upscaler, int32_t startPos) void draw::Image::DistanceField(ivec2 pos, ivec2 size, int32_t upscaler, int32_t startPos)
{ {
#ifndef BASIC_GRADIENT #ifndef BASIC_GRADIENT
float maxVal = 1/(1000.0*sqrt(META_DIST*META_DIST+META_DIST*META_DIST)); float maxVal = 1/(1000.0*sqrtf(META_DIST*META_DIST+META_DIST*META_DIST));
etk::Vector2D<int32_t> tmpPos; etk::Vector2D<int32_t> tmpPos;
// generate distance system ... matrix ... // generate distance system ... matrix ...
Grid grid2(etk::Vector2D<int32_t>(META_DIST*2,META_DIST*2)); Grid grid2(ivec2(META_DIST*2,META_DIST*2));
for(tmpPos.y=0 ; tmpPos.y<META_DIST*2 ; tmpPos.y++ ) { for(tmpPos.setY(0) ; tmpPos.y()<META_DIST*2 ; tmpPos+=vec2(0,1) ) {
for(tmpPos.x=0 ; tmpPos.x<META_DIST*2 ; tmpPos.x++ ) { for(tmpPos.setX(0) ; tmpPos.x<META_DIST*2 ; tmpPos+=vec2(1,0) ) {
int32_t val = 1000.0*sqrt((tmpPos.x-META_DIST)*(tmpPos.x-META_DIST) + (tmpPos.y-META_DIST)*(tmpPos.y-META_DIST)); int32_t val = 1000.0*sqrtf((tmpPos.x()-META_DIST)*(tmpPos.x()-META_DIST) + (tmpPos.y()-META_DIST)*(tmpPos.y()-META_DIST));
grid2.Set(tmpPos, val); grid2.Set(tmpPos, val);
} }
} }
Grid grid1(size); Grid grid1(size);
grid1.SetErrorVal(0); grid1.SetErrorVal(0);
for(tmpPos.y=0 ; tmpPos.y<size.y ; tmpPos.y++ ) { for(tmpPos.setY(0) ; tmpPos.y()<size.y() ; tmpPos+=vec2(0,1) ) {
for(tmpPos.x=0 ; tmpPos.x<size.x ; tmpPos.x++ ) { for(tmpPos.setX(0) ; tmpPos.x<size.x() ; tmpPos+=vec2(1,0) ) {
draw::Color tmpColor = Get(pos+tmpPos); draw::Color tmpColor = Get(pos+tmpPos);
// Points inside get marked with a x/y of zero. // Points inside get marked with a x/y of zero.
// Points outside get marked with an infinitely large distance. // Points outside get marked with an infinitely large distance.
@ -345,20 +345,20 @@ void draw::Image::DistanceField(etk::Vector2D<int32_t> pos, etk::Vector2D<int32_
} }
} }
} }
for(tmpPos.y=startPos ; tmpPos.y<size.y ; tmpPos.y+=upscaler ) { for(tmpPos.setY(startPos) ; tmpPos.y()<size.y() ; tmpPos+=vec2(0,upscaler) ) {
for(tmpPos.x=startPos ; tmpPos.x<size.x ; tmpPos.x+=upscaler ) { for(tmpPos.setX(startPos) ; tmpPos.x<size.x() ; tmpPos+=vec2(upscaler,0) ) {
int32_t insideOrOutsideCurrentPixel = grid1.Get(tmpPos); int32_t insideOrOutsideCurrentPixel = grid1.Get(tmpPos);
// when out no distance find ... // when out no distance find ...
grid1.SetErrorVal(insideOrOutsideCurrentPixel); grid1.SetErrorVal(insideOrOutsideCurrentPixel);
etk::Vector2D<int32_t> tmpPos2; ivec2 tmpPos2;
int32_t newDist = 50000000; int32_t newDist = 50000000;
for(tmpPos2.y=-META_DIST ; tmpPos2.y<META_DIST ; tmpPos2.y++ ) { for(tmpPos2.setY(-META_DIST) ; tmpPos2.y()<META_DIST ; tmpPos+=vec2(0,1) ) {
for(tmpPos2.x=-META_DIST ; tmpPos2.x<META_DIST ; tmpPos2.x++ ) { for(tmpPos2.setX(-META_DIST) ; tmpPos2.x()<META_DIST ; tmpPos+=vec2(1,0) ) {
// we have an opposite factor ... // we have an opposite factor ...
if (insideOrOutsideCurrentPixel != grid1.Get(tmpPos+tmpPos2)) { if (insideOrOutsideCurrentPixel != grid1.Get(tmpPos+tmpPos2)) {
// get new distance // get new distance
int32_t tmpDist = grid2.Get(tmpPos2 + etk::Vector2D<int32_t>(META_DIST,META_DIST)); int32_t tmpDist = grid2.Get(tmpPos2 + ivec2(META_DIST,META_DIST));
if (newDist > tmpDist) { if (newDist > tmpDist) {
newDist = tmpDist; newDist = tmpDist;
} }
@ -384,9 +384,9 @@ void draw::Image::DistanceField(etk::Vector2D<int32_t> pos, etk::Vector2D<int32_
grid1.SetErrorVal(0); grid1.SetErrorVal(0);
grid2.SetErrorVal(500000); grid2.SetErrorVal(500000);
etk::Vector2D<int32_t> tmpPos; ivec2 tmpPos;
for(tmpPos.y=0 ; tmpPos.y<size.y ; tmpPos.y++ ) { for(tmpPos.setY(0) ; tmpPos.y()<size.y() ; tmpPos+=vec2(0,1) ) {
for(tmpPos.x=0 ; tmpPos.x<size.x ; tmpPos.x++ ) { for(tmpPos.setX(0) ; tmpPos.x()<size.x() ; tmpPos+=vec2(1,0) ) {
draw::Color tmpColor = Get(pos+tmpPos); draw::Color tmpColor = Get(pos+tmpPos);
// Points inside get marked with a x/y of zero. // Points inside get marked with a x/y of zero.
// Points outside get marked with an infinitely large distance. // Points outside get marked with an infinitely large distance.
@ -403,13 +403,13 @@ void draw::Image::DistanceField(etk::Vector2D<int32_t> pos, etk::Vector2D<int32_
grid1.GenerateSDF(); grid1.GenerateSDF();
grid2.GenerateSDF(); grid2.GenerateSDF();
for(tmpPos.y=startPos ; tmpPos.y<size.y ; tmpPos.y+=upscaler ) { for(tmpPos.setY(startPos) ; tmpPos.y()<size.y() ; tmpPos+=vec2(0,upscaler) ) {
for(tmpPos.x=startPos ; tmpPos.x<size.x ; tmpPos.x+=upscaler ) { for(tmpPos.setX(startPos) ; tmpPos.x()<size.x() ; tmpPos+=vec2(upscaler,0) ) {
etk::Vector2D<int32_t> elem1 = grid1.Get(tmpPos); ivec2 elem1 = grid1.Get(tmpPos);
etk::Vector2D<int32_t> elem2 = grid2.Get(tmpPos); ivec2 elem2 = grid2.Get(tmpPos);
// Calculate the actual distance from the x/y // Calculate the actual distance from the x/y
float dist1 = elem1.GetLength(); float dist1 = elem1.length();
float dist2 = elem2.GetLength(); float dist2 = elem2.length();
float dist = dist1 - dist2; float dist = dist1 - dist2;
/* /*
if (tmpPos.y < 32) { if (tmpPos.y < 32) {

122
draw/Image.h
View File

@ -53,7 +53,7 @@ class Grid
etk::Vector<int32_t > m_data; etk::Vector<int32_t > m_data;
int32_t m_outsideVal; int32_t m_outsideVal;
int32_t m_errorVal; int32_t m_errorVal;
Grid(etk::Vector2D<int32_t> size) Grid(ivec2 size)
{ {
m_size = size; m_size = size;
m_outsideVal = 20; m_outsideVal = 20;
@ -61,7 +61,7 @@ class Grid
// basic element : // basic element :
int32_t tmpPoint = 0; int32_t tmpPoint = 0;
// preallocate data with a basic bg elements : // preallocate data with a basic bg elements :
m_data.ReSize(m_size.x*m_size.y, tmpPoint); m_data.ReSize(m_size.x()*m_size.y(), tmpPoint);
}; };
~Grid(void) { }; ~Grid(void) { };
void SetOutsideVal(int32_t newVal) void SetOutsideVal(int32_t newVal)
@ -74,34 +74,34 @@ class Grid
} }
void SetInide(etk::Vector2D<int32_t> pos) void SetInide(etk::Vector2D<int32_t> pos)
{ {
if( pos.x>=0 && pos.x<m_size.x if( pos.x()>=0 && pos.x()<m_size.x()
&& pos.y>=0 && pos.y<m_size.y) { && pos.y()>=0 && pos.y()<m_size.y()) {
m_data[pos.x+pos.y*m_size.x]=0; m_data[pos.x()+pos.y()*m_size.x()]=0;
} }
}; };
void SetOutside(etk::Vector2D<int32_t> pos) void SetOutside(etk::Vector2D<int32_t> pos)
{ {
if( pos.x>=0 && pos.x<m_size.x if( pos.x()>=0 && pos.x()<m_size.x()
&& pos.y>=0 && pos.y<m_size.y) { && pos.y()>=0 && pos.y()<m_size.y()) {
m_data[pos.x+pos.y*m_size.x]=m_outsideVal; m_data[pos.x()+pos.y()*m_size.x()]=m_outsideVal;
} }
}; };
int32_t Get(etk::Vector2D<int32_t> pos) int32_t Get(etk::Vector2D<int32_t> pos)
{ {
; ;
if( pos.x>0 && pos.x<m_size.x if( pos.x()>0 && pos.x()<m_size.x()
&& pos.y>0 && pos.y<m_size.y) { && pos.y()>0 && pos.y()<m_size.y()) {
return m_data[pos.x+pos.y*m_size.x]; return m_data[pos.x()+pos.y()*m_size.x()];
} }
return m_errorVal; return m_errorVal;
}; };
void Set(etk::Vector2D<int32_t> pos, int32_t val) void Set(etk::Vector2D<int32_t> pos, int32_t val)
{ {
if( pos.x>0 && pos.x<m_size.x if( pos.x()>0 && pos.x()<m_size.x()
&& pos.y>0 && pos.y<m_size.y) { && pos.y()>0 && pos.y()<m_size.y()) {
m_data[pos.x+pos.y*m_size.x] = val; m_data[pos.x()+pos.y()*m_size.x()] = val;
} }
}; };
@ -110,11 +110,11 @@ class Grid
class Grid class Grid
{ {
public: public:
etk::Vector2D<int32_t> m_size; ivec2 m_size;
etk::Vector<etk::Vector2D<int32_t> > m_data; etk::Vector<ivec2> m_data;
int32_t m_outsideVal; int32_t m_outsideVal;
int32_t m_errorVal; int32_t m_errorVal;
Grid(etk::Vector2D<int32_t> size) Grid(ivec2 size)
{ {
m_size = size; m_size = size;
m_outsideVal = 20; m_outsideVal = 20;
@ -122,7 +122,7 @@ class Grid
// basic element : // basic element :
etk::Vector2D<int32_t> tmpPoint(0,0); etk::Vector2D<int32_t> tmpPoint(0,0);
// preallocate data with a basic bg elements : // preallocate data with a basic bg elements :
m_data.ReSize(m_size.x*m_size.y, tmpPoint); m_data.ReSize(m_size.x()*m_size.y(), tmpPoint);
}; };
~Grid(void) { }; ~Grid(void) { };
void SetOutsideVal(int32_t newVal) void SetOutsideVal(int32_t newVal)
@ -133,48 +133,46 @@ class Grid
{ {
m_errorVal = newVal; m_errorVal = newVal;
} }
void SetInide(etk::Vector2D<int32_t> pos) void SetInide(ivec2 pos)
{ {
//if( pos.x>=0 && pos.x<m_size.x //if( pos.x>=0 && pos.x<m_size.x
// && pos.y>=0 && pos.y<m_size.y) { // && pos.y>=0 && pos.y<m_size.y) {
m_data[pos.x+pos.y*m_size.x].x=0; m_data[pos.x()+pos.y()*m_size.x()].setX(0);
m_data[pos.x+pos.y*m_size.x].y=0; m_data[pos.x()+pos.y()*m_size.x()].setY(0);
//} //}
}; };
void SetOutside(etk::Vector2D<int32_t> pos) void SetOutside(ivec2 pos)
{ {
//if( pos.x>=0 && pos.x<m_size.x //if( pos.x>=0 && pos.x<m_size.x
// && pos.y>=0 && pos.y<m_size.y) { // && pos.y>=0 && pos.y<m_size.y) {
m_data[pos.x+pos.y*m_size.x].x=m_outsideVal; m_data[pos.x()+pos.y()*m_size.x()].setX(m_outsideVal);
m_data[pos.x+pos.y*m_size.x].y=m_outsideVal; m_data[pos.x()+pos.y()*m_size.x()].setY(m_outsideVal);
//} //}
}; };
etk::Vector2D<int32_t> Get(etk::Vector2D<int32_t> pos) ivec2 Get(ivec2 pos)
{ {
//if( pos.x>0 && pos.x<m_size.x //if( pos.x>0 && pos.x<m_size.x
// && pos.y>0 && pos.y<m_size.y) { // && pos.y>0 && pos.y<m_size.y) {
return m_data[pos.x+pos.y*m_size.x]; return m_data[pos.x()+pos.y()*m_size.x()];
//} //}
//return etk::Vector2D<int32_t>(m_errorVal,m_errorVal); //return etk::Vector2D<int32_t>(m_errorVal,m_errorVal);
}; };
void Set(etk::Vector2D<int32_t> pos, etk::Vector2D<int32_t> val) void Set(ivec2 pos, ivec2 val)
{ {
//if( pos.x>0 && pos.x<m_size.x //if( pos.x>0 && pos.x<m_size.x
// && pos.y>0 && pos.y<m_size.y) { // && pos.y>0 && pos.y<m_size.y) {
m_data[pos.x+pos.y*m_size.x] = val; m_data[pos.x()+pos.y()*m_size.x()] = val;
//} //}
}; };
void Compare(etk::Vector2D<int32_t> &p, etk::Vector2D<int32_t> pos, int32_t offsetx, int32_t offsety ) void Compare(ivec2 &p, ivec2 pos, int32_t offsetx, int32_t offsety )
{ {
pos.x += offsetx; pos += ivec2(offsetx,offsety);
pos.y += offsety; ivec2 other = Get(pos);
etk::Vector2D<int32_t> other = Get(pos); other += ivec2(offsetx,offsety);
other.x += offsetx; if (other.dot(p) < p.dot(p)) {
other.y += offsety;
if (other.GetSquaredLength() < p.GetSquaredLength()) {
p = other; p = other;
} }
}; };
@ -192,7 +190,7 @@ namespace draw
class Image { class Image {
private: private:
etk::Vector2D<int32_t> m_size; ivec2 m_size;
etk::Vector<draw::Color> m_data; etk::Vector<draw::Color> m_data;
agg::rendering_buffer * m_renderingBuffer; agg::rendering_buffer * m_renderingBuffer;
agg::pixfmt_rgba32 * m_pixFrame; agg::pixfmt_rgba32 * m_pixFrame;
@ -206,7 +204,7 @@ namespace draw
float m_strokeSize; float m_strokeSize;
public: public:
// constructor : // constructor :
Image(etk::Vector2D<int32_t> size); Image(ivec2 size);
Image(void); Image(void);
// destructor // destructor
~Image(void); ~Image(void);
@ -221,20 +219,20 @@ namespace draw
// -- basic tools : // -- basic tools :
// ----------------------------------------------- // -----------------------------------------------
public : public :
void Resize(etk::Vector2D<int32_t> size); void Resize(ivec2 size);
//void Resize(etk::Vector2D<int32_t> startPos, Vector2D<int32_t> size); //void Resize(etk::Vector2D<int32_t> startPos, Vector2D<int32_t> size);
etk::Vector2D<int32_t> GetSize(void) const ivec2 GetSize(void) const
{ {
return m_size; return m_size;
}; };
int32_t GetWidth(void) const int32_t GetWidth(void) const
{ {
return m_size.x; return m_size.x();
}; };
int32_t GetHeight(void) const int32_t GetHeight(void) const
{ {
return m_size.y; return m_size.y();
}; };
//void Move(etk::Vector2D<int32_t> pos); //void Move(etk::Vector2D<int32_t> pos);
@ -246,7 +244,7 @@ namespace draw
void Clear(void) void Clear(void)
{ {
for (int32_t iii=0; iii<m_size.x*m_size.y; iii++) { for (int32_t iii=0; iii<m_size.x()*m_size.y(); iii++) {
m_data[iii] = m_fillColor; m_data[iii] = m_fillColor;
} }
} }
@ -255,21 +253,21 @@ namespace draw
//Image & operator= (const Image &image) //Image & operator= (const Image &image)
draw::Color Get(etk::Vector2D<int32_t> pos) draw::Color Get(ivec2 pos)
{ {
draw::Color outColor(0x00000000); draw::Color outColor(0x00000000);
if( pos.x>0 && pos.x<m_size.x if( pos.x()>0 && pos.x()<m_size.x()
&& pos.y>0 && pos.y<m_size.y) { && pos.y()>0 && pos.y()<m_size.y()) {
outColor = m_data[pos.x+pos.y*m_size.x]; outColor = m_data[pos.x()+pos.y()*m_size.x()];
} }
return outColor; return outColor;
} }
void Set(etk::Vector2D<int32_t> pos, draw::Color newColor) void Set(ivec2 pos, draw::Color newColor)
{ {
if( pos.x>=0 && pos.x<m_size.x if( pos.x()>=0 && pos.x()<m_size.x()
&& pos.y>=0 && pos.y<m_size.y) { && pos.y()>=0 && pos.y()<m_size.y()) {
m_data[pos.x+pos.y*m_size.x] = newColor; m_data[pos.x()+pos.y()*m_size.x()] = newColor;
} }
} }
@ -292,21 +290,21 @@ namespace draw
void SetStrokeSize(float thickness) { void SetStrokeSize(float thickness) {
m_strokeSize = thickness; m_strokeSize = thickness;
} }
void MoveTo(etk::Vector2D<float> pos); void MoveTo(vec2 pos);
void MoveToAbs(etk::Vector2D<float> pos); void MoveToAbs(vec2 pos);
void LineTo(etk::Vector2D<float> pos); void LineTo(vec2 pos);
void LineToAbs(etk::Vector2D<float> pos); void LineToAbs(vec2 pos);
void Join(void); void Join(void);
void Draw(void); void Draw(void);
void Line(etk::Vector2D<float> posStart, etk::Vector2D<float> posEnd); void Line(vec2 posStart, vec2 posEnd);
void Dot(etk::Vector2D<float> pos); void Dot(vec2 pos);
void Rectangle(etk::Vector2D<float> pos, etk::Vector2D<float> size); void Rectangle(vec2 pos, vec2 size);
void Circle(etk::Vector2D<float> pos, float radius, float angleStart=0, float angleStop=2*M_PI); void Circle(vec2 pos, float radius, float angleStart=0, float angleStop=2*M_PI);
void Disc(etk::Vector2D<float> pos, float radius, float angleStart=0, float angleStop=2*M_PI); void Disc(vec2 pos, float radius, float angleStart=0, float angleStop=2*M_PI);
// generate the distant field from the alpha value of the Image // generate the distant field from the alpha value of the Image
void DistanceField(void); void DistanceField(void);
void DistanceField(etk::Vector2D<int32_t> pos, etk::Vector2D<int32_t> size, int32_t upscaler=1, int32_t startPos=0); void DistanceField(ivec2 pos, ivec2 size, int32_t upscaler=1, int32_t startPos=0);
void SaveFile(const char * file) {}; void SaveFile(const char * file) {};
private: private: