diff --git a/draw/Image.cpp b/draw/Image.cpp
index 8267bb0..565c881 100644
--- a/draw/Image.cpp
+++ b/draw/Image.cpp
@@ -34,12 +34,12 @@ draw::Image::Image(void) :
 	m_strokeColor(0,0,0,0),
 	m_strokeSize(0)
 {
-	m_size.x = 32;
-	m_size.y = 32;
+	m_size.setX(32);
+	m_size.setY(32);
 	Init();
 }
 
-draw::Image::Image(etk::Vector2D<int32_t> size) :
+draw::Image::Image(ivec2 size) :
 	m_renderingBuffer(NULL),
 	m_pixFrame(NULL),
 	m_renderBase(NULL),
@@ -57,13 +57,13 @@ void draw::Image::Init(void)
 	// basic element :
 	draw::Color tmpBg(0,0,0,0);
 	// preallocate data with a basic bg elements :
-	m_data.ReSize(m_size.x*m_size.y, tmpBg);
-	if (m_size.x*m_size.y > m_data.Size()) {
+	m_data.ReSize(m_size.x()*m_size.y(), tmpBg);
+	if (m_size.x()*m_size.y() > m_data.Size()) {
 		DRAW_ERROR("Allocation of data buffer in error");
 		return;
 	}
 	// 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) {
 		DRAW_ERROR("Allocation of the m_renderingBuffer for SVG drawing error");
 		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) {
 		delete(m_renderArea);
@@ -142,13 +142,13 @@ void draw::Image::Resize(etk::Vector2D<int32_t> size)
 	// basic element :
 	draw::Color tmpBg(0,0,0,0);
 	// preallocate data with a basic bg elements :
-	m_data.ReSize(m_size.x*m_size.y, tmpBg);
-	if (m_size.x*m_size.y > m_data.Size()) {
+	m_data.ReSize(m_size.x()*m_size.y(), tmpBg);
+	if (m_size.x()*m_size.y() > m_data.Size()) {
 		DRAW_ERROR("Allocation of data buffer in error");
 		return;
 	}
 	// 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) {
 		DRAW_ERROR("Allocation of the m_renderingBuffer for SVG drawing error");
 		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();
@@ -237,7 +237,7 @@ void draw::Image::Dot(etk::Vector2D<float> pos)
 	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();
 	MoveTo(posStart);
@@ -245,27 +245,27 @@ void draw::Image::Line(etk::Vector2D<float> posStart, etk::Vector2D<float> posEn
 	End();
 }
 
-void draw::Image::Rectangle(etk::Vector2D<float> pos, etk::Vector2D<float> size)
+void draw::Image::Rectangle(vec2 pos, vec2 size)
 {
 	Begin();
-	etk::Vector2D<float> tmp = pos;
+	vec2 tmp = pos;
 	MoveTo(pos);
-	tmp.x += size.x;
+	tmp += vec2(size.x(),0);
 	LineTo(tmp);
-	tmp.y += size.y;
+	tmp += vec2(0,size.y());
 	LineTo(tmp);
-	tmp.x -= size.x;
+	tmp -= vec2(size.x(),0);
 	LineTo(tmp);
 	Join();
 	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()
 {
 	// Pass 0
-	etk::Vector2D<int32_t> tmpPos;
-	for (tmpPos.y=1 ; tmpPos.y<m_size.y-1 ; tmpPos.y++) {
-		for (tmpPos.x=1 ; tmpPos.x<m_size.x-1 ; tmpPos.x++) {
-			etk::Vector2D<int32_t> p = Get(tmpPos);
+	ivec2 tmpPos(1,1);
+	for (tmpPos.setY(1) ; tmpPos.y()<m_size.y()-1 ; tmpPos+=vec2(0,1)) {
+		for (tmpPos.setX(1) ; tmpPos.x()<m_size.x()-1 ; tmpPos+=vec2(1,0) ) {
+			ivec2 p = Get(tmpPos);
 			Compare(p, tmpPos, -1,  0 );
 			Compare(p, tmpPos,  0, -1 );
 			Compare(p, tmpPos, -1, -1 );
 			Compare(p, tmpPos,  1, -1 );
 			Set(tmpPos, p);
 		}
-		for (tmpPos.x=m_size.x-2 ; tmpPos.x>0 ; tmpPos.x--) {
-			etk::Vector2D<int32_t> p = Get(tmpPos);
+		for (tmpPos.setX(m_size.x()-2) ; tmpPos.x()>0 ; tmpPos-=vec2(1,0) ) {
+			ivec2 p = Get(tmpPos);
 			Compare(p, tmpPos, 1, 0 );
 			Set(tmpPos, p );
 		}
 	}
 	// Pass 1
-	for (tmpPos.y=m_size.y-2 ; tmpPos.y>0 ; tmpPos.y--) {
-		for (tmpPos.x=m_size.x-2 ; tmpPos.x>1 ; tmpPos.x--) {
-			etk::Vector2D<int32_t> p = Get(tmpPos);
+	for (tmpPos.setY(m_size.y()-2) ; tmpPos.y()>0 ; tmpPos-=vec2(0,1)) {
+		for (tmpPos.setX(m_size.x()-2) ; tmpPos.x()>1 ; tmpPos-=vec2(1,0)) {
+			ivec2 p = Get(tmpPos);
 			Compare(p, tmpPos,  1,  0 );
 			Compare(p, tmpPos,  0,  1 );
 			Compare(p, tmpPos, -1,  1 );
 			Compare(p, tmpPos,  1,  1 );
 			Set(tmpPos, p);
 		}
-		for (tmpPos.x=1 ; tmpPos.x<m_size.x-1 ; tmpPos.x++) {
-			etk::Vector2D<int32_t> p = Get(tmpPos);
+		for (tmpPos.setX(1) ; tmpPos.x()<m_size.x()-1 ; tmpPos+=vec2(1,0)) {
+			ivec2 p = Get(tmpPos);
 			Compare(p, tmpPos, -1,  0 );
 			Set(tmpPos, p);
 		}
@@ -312,29 +312,29 @@ void Grid::GenerateSDF()
 
 void draw::Image::DistanceField(void)
 {
-	DistanceField(etk::Vector2D<int32_t>(0,0), m_size);
+	DistanceField(ivec2(0,0), m_size);
 }
 #endif
 
 #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
-	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;
 	// generate distance system ... matrix ...
-	Grid grid2(etk::Vector2D<int32_t>(META_DIST*2,META_DIST*2));
-	for(tmpPos.y=0 ; tmpPos.y<META_DIST*2 ; tmpPos.y++ ) {
-		for(tmpPos.x=0 ; tmpPos.x<META_DIST*2 ; tmpPos.x++ ) {
-			int32_t val = 1000.0*sqrt((tmpPos.x-META_DIST)*(tmpPos.x-META_DIST) + (tmpPos.y-META_DIST)*(tmpPos.y-META_DIST));
+	Grid grid2(ivec2(META_DIST*2,META_DIST*2));
+	for(tmpPos.setY(0) ; tmpPos.y()<META_DIST*2 ; tmpPos+=vec2(0,1) ) {
+		for(tmpPos.setX(0) ; tmpPos.x<META_DIST*2 ; tmpPos+=vec2(1,0) ) {
+			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);
 		}
 	}
 	Grid grid1(size);
 	grid1.SetErrorVal(0);
 	
-	for(tmpPos.y=0 ; tmpPos.y<size.y ; tmpPos.y++ ) {
-		for(tmpPos.x=0 ; tmpPos.x<size.x ; tmpPos.x++ ) {
+	for(tmpPos.setY(0) ; tmpPos.y()<size.y() ; tmpPos+=vec2(0,1) ) {
+		for(tmpPos.setX(0) ; tmpPos.x<size.x() ; tmpPos+=vec2(1,0) ) {
 			draw::Color tmpColor = Get(pos+tmpPos);
 			// Points inside get marked with a x/y of zero.
 			// 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.x=startPos ; tmpPos.x<size.x ; tmpPos.x+=upscaler ) {
+	for(tmpPos.setY(startPos) ; tmpPos.y()<size.y() ; tmpPos+=vec2(0,upscaler) ) {
+		for(tmpPos.setX(startPos) ; tmpPos.x<size.x() ; tmpPos+=vec2(upscaler,0) ) {
 			int32_t insideOrOutsideCurrentPixel = grid1.Get(tmpPos);
 			// when out no distance find ...
 			grid1.SetErrorVal(insideOrOutsideCurrentPixel);
 			
-			etk::Vector2D<int32_t> tmpPos2;
+			ivec2 tmpPos2;
 			int32_t newDist = 50000000;
-			for(tmpPos2.y=-META_DIST ; tmpPos2.y<META_DIST ; tmpPos2.y++ ) {
-				for(tmpPos2.x=-META_DIST ; tmpPos2.x<META_DIST ; tmpPos2.x++ ) {
+			for(tmpPos2.setY(-META_DIST) ; tmpPos2.y()<META_DIST ; tmpPos+=vec2(0,1) ) {
+				for(tmpPos2.setX(-META_DIST) ; tmpPos2.x()<META_DIST ; tmpPos+=vec2(1,0) ) {
 					// we have an opposite factor ...
 					if (insideOrOutsideCurrentPixel != grid1.Get(tmpPos+tmpPos2)) {
 						// 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) {
 							newDist = tmpDist;
 						}
@@ -384,9 +384,9 @@ void draw::Image::DistanceField(etk::Vector2D<int32_t> pos, etk::Vector2D<int32_
 	grid1.SetErrorVal(0);
 	grid2.SetErrorVal(500000);
 	
-	etk::Vector2D<int32_t> tmpPos;
-	for(tmpPos.y=0 ; tmpPos.y<size.y ; tmpPos.y++ ) {
-		for(tmpPos.x=0 ; tmpPos.x<size.x ; tmpPos.x++ ) {
+	ivec2 tmpPos;
+	for(tmpPos.setY(0) ; tmpPos.y()<size.y() ; tmpPos+=vec2(0,1) ) {
+		for(tmpPos.setX(0) ; tmpPos.x()<size.x() ; tmpPos+=vec2(1,0) ) {
 			draw::Color tmpColor = Get(pos+tmpPos);
 			// Points inside get marked with a x/y of zero.
 			// 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();
 	grid2.GenerateSDF();
 	
-	for(tmpPos.y=startPos ; tmpPos.y<size.y ; tmpPos.y+=upscaler ) {
-		for(tmpPos.x=startPos ; tmpPos.x<size.x ; tmpPos.x+=upscaler ) {
-			etk::Vector2D<int32_t> elem1 = grid1.Get(tmpPos);
-			etk::Vector2D<int32_t> elem2 = grid2.Get(tmpPos);
+	for(tmpPos.setY(startPos) ; tmpPos.y()<size.y() ; tmpPos+=vec2(0,upscaler) ) {
+		for(tmpPos.setX(startPos) ; tmpPos.x()<size.x() ; tmpPos+=vec2(upscaler,0) ) {
+			ivec2 elem1 = grid1.Get(tmpPos);
+			ivec2 elem2 = grid2.Get(tmpPos);
 			// Calculate the actual distance from the x/y
-			float dist1 = elem1.GetLength();
-			float dist2 = elem2.GetLength();
+			float dist1 = elem1.length();
+			float dist2 = elem2.length();
 			float dist = dist1 - dist2;
 			/*
 			if (tmpPos.y < 32) {
diff --git a/draw/Image.h b/draw/Image.h
index 8425e66..85387b2 100644
--- a/draw/Image.h
+++ b/draw/Image.h
@@ -53,7 +53,7 @@ class Grid
 		etk::Vector<int32_t > m_data;
 		int32_t               m_outsideVal;
 		int32_t               m_errorVal;
-		Grid(etk::Vector2D<int32_t> size)
+		Grid(ivec2 size)
 		{
 			m_size = size;
 			m_outsideVal = 20;
@@ -61,7 +61,7 @@ class Grid
 			// basic element :
 			int32_t tmpPoint = 0;
 			// 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) { };
 		void SetOutsideVal(int32_t newVal)
@@ -74,34 +74,34 @@ class Grid
 		}
 		void SetInide(etk::Vector2D<int32_t> pos)
 		{
-			if(    pos.x>=0 && pos.x<m_size.x
-			    && pos.y>=0 && pos.y<m_size.y) {
-				m_data[pos.x+pos.y*m_size.x]=0;
+			if(    pos.x()>=0 && pos.x()<m_size.x()
+			    && pos.y()>=0 && pos.y()<m_size.y()) {
+				m_data[pos.x()+pos.y()*m_size.x()]=0;
 			}
 		};
 		void SetOutside(etk::Vector2D<int32_t> pos)
 		{
-			if(    pos.x>=0 && pos.x<m_size.x
-			    && pos.y>=0 && pos.y<m_size.y) {
-				m_data[pos.x+pos.y*m_size.x]=m_outsideVal;
+			if(    pos.x()>=0 && pos.x()<m_size.x()
+			    && pos.y()>=0 && pos.y()<m_size.y()) {
+				m_data[pos.x()+pos.y()*m_size.x()]=m_outsideVal;
 			}
 		};
 		
 		int32_t Get(etk::Vector2D<int32_t> pos)
 		{
 			;
-			if(    pos.x>0 && pos.x<m_size.x
-			    && pos.y>0 && pos.y<m_size.y) {
-				return m_data[pos.x+pos.y*m_size.x];
+			if(    pos.x()>0 && pos.x()<m_size.x()
+			    && pos.y()>0 && pos.y()<m_size.y()) {
+				return m_data[pos.x()+pos.y()*m_size.x()];
 			}
 			return m_errorVal;
 		};
 		
 		void Set(etk::Vector2D<int32_t> pos, int32_t val)
 		{
-			if(    pos.x>0 && pos.x<m_size.x
-			    && pos.y>0 && pos.y<m_size.y) {
-				m_data[pos.x+pos.y*m_size.x] = val;
+			if(    pos.x()>0 && pos.x()<m_size.x()
+			    && pos.y()>0 && pos.y()<m_size.y()) {
+				m_data[pos.x()+pos.y()*m_size.x()] = val;
 			}
 		};
 		
@@ -110,11 +110,11 @@ class Grid
 class Grid
 {
 	public:
-		etk::Vector2D<int32_t>               m_size;
-		etk::Vector<etk::Vector2D<int32_t> > m_data;
-		int32_t                              m_outsideVal;
-		int32_t                              m_errorVal;
-		Grid(etk::Vector2D<int32_t> size)
+		ivec2               m_size;
+		etk::Vector<ivec2>  m_data;
+		int32_t             m_outsideVal;
+		int32_t             m_errorVal;
+		Grid(ivec2 size)
 		{
 			m_size = size;
 			m_outsideVal = 20;
@@ -122,7 +122,7 @@ class Grid
 			// basic element :
 			etk::Vector2D<int32_t> tmpPoint(0,0);
 			// 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) { };
 		void SetOutsideVal(int32_t newVal)
@@ -133,48 +133,46 @@ class Grid
 		{
 			m_errorVal = newVal;
 		}
-		void SetInide(etk::Vector2D<int32_t> pos)
+		void SetInide(ivec2 pos)
 		{
 			//if(    pos.x>=0 && pos.x<m_size.x
 			//    && 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].y=0;
+				m_data[pos.x()+pos.y()*m_size.x()].setX(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
 			//    && 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].y=m_outsideVal;
+				m_data[pos.x()+pos.y()*m_size.x()].setX(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
 			//    && 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);
 		};
 		
-		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
 			//    && 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.y += offsety;
-			etk::Vector2D<int32_t> other = Get(pos);
-			other.x += offsetx;
-			other.y += offsety;
-			if (other.GetSquaredLength() < p.GetSquaredLength()) {
+			pos += ivec2(offsetx,offsety);
+			ivec2 other = Get(pos);
+			other += ivec2(offsetx,offsety);
+			if (other.dot(p) < p.dot(p)) {
 				p = other;
 			}
 		};
@@ -192,7 +190,7 @@ namespace draw
 	
 	class Image {
 		private:
-			etk::Vector2D<int32_t>        m_size;
+			ivec2                         m_size;
 			etk::Vector<draw::Color>      m_data;
 			agg::rendering_buffer *       m_renderingBuffer;
 			agg::pixfmt_rgba32 *          m_pixFrame;
@@ -206,7 +204,7 @@ namespace draw
 			float                         m_strokeSize;
 		public:
 			// constructor :
-			Image(etk::Vector2D<int32_t> size);
+			Image(ivec2 size);
 			Image(void);
 			// destructor
 			~Image(void);
@@ -221,20 +219,20 @@ namespace draw
 		// -- basic tools :
 		// -----------------------------------------------
 		public :
-			void Resize(etk::Vector2D<int32_t> size);
+			void Resize(ivec2 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;
 			};
 			int32_t GetWidth(void) const
 			{
-				return m_size.x;
+				return m_size.x();
 			};
 			int32_t GetHeight(void) const
 			{
-				return m_size.y;
+				return m_size.y();
 			};
 			
 			//void Move(etk::Vector2D<int32_t> pos);
@@ -246,7 +244,7 @@ namespace draw
 			
 			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;
 				}
 			}
@@ -255,21 +253,21 @@ namespace draw
 			
 			//Image & operator= (const Image &image)
 			
-			draw::Color Get(etk::Vector2D<int32_t> pos)
+			draw::Color Get(ivec2 pos)
 			{
 				draw::Color outColor(0x00000000);
-				if(    pos.x>0 && pos.x<m_size.x
-				    && pos.y>0 && pos.y<m_size.y) {
-					outColor = m_data[pos.x+pos.y*m_size.x];
+				if(    pos.x()>0 && pos.x()<m_size.x()
+				    && pos.y()>0 && pos.y()<m_size.y()) {
+					outColor = m_data[pos.x()+pos.y()*m_size.x()];
 				}
 				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
-				    && pos.y>=0 && pos.y<m_size.y) {
-					m_data[pos.x+pos.y*m_size.x] = newColor;
+				if(    pos.x()>=0 && pos.x()<m_size.x()
+				    && pos.y()>=0 && pos.y()<m_size.y()) {
+					m_data[pos.x()+pos.y()*m_size.x()] = newColor;
 				}
 			}
 			
@@ -292,21 +290,21 @@ namespace draw
 			void SetStrokeSize(float thickness) {
 				m_strokeSize = thickness;
 			}
-			void MoveTo(etk::Vector2D<float> pos);
-			void MoveToAbs(etk::Vector2D<float> pos);
-			void LineTo(etk::Vector2D<float> pos);
-			void LineToAbs(etk::Vector2D<float> pos);
+			void MoveTo(vec2 pos);
+			void MoveToAbs(vec2 pos);
+			void LineTo(vec2 pos);
+			void LineToAbs(vec2 pos);
 			void Join(void);
 			void Draw(void);
 			
-			void Line(etk::Vector2D<float> posStart, etk::Vector2D<float> posEnd);
-			void Dot(etk::Vector2D<float> pos);
-			void Rectangle(etk::Vector2D<float> pos, etk::Vector2D<float> size);
-			void Circle(etk::Vector2D<float> 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 Line(vec2 posStart, vec2 posEnd);
+			void Dot(vec2 pos);
+			void Rectangle(vec2 pos, vec2 size);
+			void Circle(vec2 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
 			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) {};
 		private: