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_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) {

122
draw/Image.h
View File

@ -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: