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

[DEV] create a real class to store path ...

Browse Source
This commit is contained in:
Edouard DUPIN 2015-11-18 21:07:51 +01:00
parent 2f095120dd
commit ea1aa31d49
47 changed files with 831 additions and 395 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
esvg/Base.cpp
View File

@ -404,6 +404,6 @@ const char * esvg::Base::spacingDist(int32_t _spacing) {
return tmpValue + 20*4 - _spacing*4;
}
void esvg::Base::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
void esvg::Base::draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
SVG_WARNING(spacingDist(_level) << "DRAW esvg::Base ... ==> No drawing availlable");
}

2
esvg/Base.h
View File

@ -71,7 +71,7 @@ namespace esvg {
virtual ~Base() { };
virtual bool parse(const std::shared_ptr<exml::Element>& _element, mat2& _parentTrans, vec2& _sizeMax);
//specific drawing for AAG librairy ...
virtual void aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level=1);
virtual void draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level=1);
virtual void display(int32_t _spacing) { };
void parseTransform(const std::shared_ptr<exml::Element>& _element);

2
esvg/Circle.cpp
View File

@ -61,7 +61,7 @@ void esvg::Circle::display(int32_t _spacing) {
}
void esvg::Circle::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
void esvg::Circle::draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
SVG_VERBOSE(spacingDist(_level) << "DRAW esvg::Circle");
/*
_myRenderer.m_renderArea->color(agg::rgba8(m_paint.fill.r, m_paint.fill.g, m_paint.fill.b, m_paint.fill.a));

2
esvg/Circle.h
View File

@ -21,7 +21,7 @@ namespace esvg {
~Circle();
virtual bool parse(const std::shared_ptr<exml::Element>& _element, mat2& _parentTrans, vec2& _sizeMax);
virtual void display(int32_t _spacing);
virtual void aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
virtual void draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
};
};

2
esvg/Ellipse.cpp
View File

@ -65,7 +65,7 @@ void esvg::Ellipse::display(int32_t _spacing) {
}
void esvg::Ellipse::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
void esvg::Ellipse::draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
SVG_VERBOSE(spacingDist(_level) << "DRAW esvg::Ellipse");
/*
_myRenderer.m_renderArea->color(agg::rgba8(m_paint.fill.r, m_paint.fill.g, m_paint.fill.b, m_paint.fill.a));

2
esvg/Ellipse.h
View File

@ -21,7 +21,7 @@ namespace esvg {
~Ellipse();
virtual bool parse(const std::shared_ptr<exml::Element>& _element, mat2& _parentTrans, vec2& _sizeMax);
virtual void display(int32_t _spacing);
virtual void aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
virtual void draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
};
};

4
esvg/Group.cpp
View File

@ -109,11 +109,11 @@ void esvg::Group::display(int32_t _spacing) {
SVG_DEBUG(spacingDist(_spacing) << "Group (STOP)");
}
void esvg::Group::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
void esvg::Group::draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
SVG_VERBOSE(spacingDist(_level) << "DRAW esvg::group");
for (int32_t iii=0; iii<m_subElementList.size(); iii++) {
if (NULL != m_subElementList[iii]) {
m_subElementList[iii]->aggDraw(_myRenderer, _basicTrans, _level+1);
m_subElementList[iii]->draw(_myRenderer, _basicTrans, _level+1);
}
}
}

2
esvg/Group.h
View File

@ -21,7 +21,7 @@ namespace esvg {
~Group();
virtual bool parse(const std::shared_ptr<exml::Element>& _element, mat2& _parentTrans, vec2& _sizeMax);
virtual void display(int32_t spacing);
virtual void aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
virtual void draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
};
};

2
esvg/Line.cpp
View File

@ -58,7 +58,7 @@ void esvg::Line::display(int32_t _spacing) {
SVG_DEBUG(spacingDist(_spacing) << "Line " << m_startPos << " to " << m_stopPos);
}
void esvg::Line::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
void esvg::Line::draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
SVG_VERBOSE(spacingDist(_level) << "DRAW esvg::Line");
# if 0
esvg::RenderPath path;

2
esvg/Line.h
View File

@ -21,7 +21,7 @@ namespace esvg {
~Line();
virtual bool parse(const std::shared_ptr<exml::Element>& _element, mat2& _parentTrans, vec2& _sizeMax);
virtual void display(int32_t _spacing);
virtual void aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
virtual void draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
};
};

303
esvg/Path.cpp
View File

@ -86,185 +86,153 @@ bool esvg::Path::parse(const std::shared_ptr<exml::Element>& _element, mat2& _pa
for( const char *sss=extractCmd(elementXML, command, listDot);
sss != nullptr;
sss=extractCmd(sss, command, listDot) ) {
PathBasic pathElement;
bool relative = false;
switch(command) {
case 'M': // Move to (absolute)
case 'L': // Line to (absolute)
case 'V': // Vertical Line to (absolute)
case 'H': // Horizantal Line to (absolute)
case 'Q': // Quadratic Bezier curve (absolute)
case 'T': // smooth quadratic Bezier curve to (absolute)
case 'C': // curve to (absolute)
case 'S': // smooth curve to (absolute)
case 'A': // elliptical Arc (absolute)
case 'Z': // closepath (absolute)
pathElement.m_relative = false;
break;
default : // else (relative)
pathElement.m_relative = true;
break;
}
switch(command) {
case 'M': // Move to (absolute)
case 'm': // Move to (relative)
relative = true;
case 'M': // Move to (absolute)
// 2 Elements ...
if(listDot.size()%2 != 0) {
SVG_WARNING("the PATH command "<< command << " has not the good number of element = " << listDot.size() );
break;
}
pathElement.m_cmd = esvg::path_moveTo;
if (listDot.size() >= 2) {
pathElement.m_element[0] = listDot[0];
pathElement.m_element[1] = listDot[1];
m_listElement.push_back(pathElement);
m_listElement.moveTo(relative,
vec2(listDot[0], listDot[1]));
}
pathElement.m_cmd = esvg::path_lineTo;
for(int32_t iii=2; iii<listDot.size(); iii+=2) {
pathElement.m_element[0] = listDot[iii];
pathElement.m_element[1] = listDot[iii+1];
m_listElement.push_back(pathElement);
m_listElement.lineTo(relative,
vec2(listDot[iii], listDot[iii+1]));
}
break;
case 'L': // Line to (absolute)
case 'l': // Line to (relative)
relative = true;
case 'L': // Line to (absolute)
// 2 Elements ...
if(listDot.size()%2 != 0) {
SVG_WARNING("the PATH command "<< command << " has not the good number of element = " << listDot.size() );
break;
}
pathElement.m_cmd = esvg::path_lineTo;
for(int32_t iii=0; iii<listDot.size(); iii+=2) {
pathElement.m_element[0] = listDot[iii];
pathElement.m_element[1] = listDot[iii+1];
m_listElement.push_back(pathElement);
m_listElement.lineTo(relative,
vec2(listDot[iii], listDot[iii+1]));
}
break;
case 'V': // Vertical Line to (absolute)
case 'v': // Vertical Line to (relative)
relative = true;
case 'V': // Vertical Line to (absolute)
// 1 Element ...
if(listDot.size() == 0) {
SVG_WARNING("the PATH command "<< command << " has not the good number of element = " << listDot.size() );
break;
}
pathElement.m_cmd = esvg::path_lineToV;
for(int32_t iii=0; iii<listDot.size(); iii+=1) {
pathElement.m_element[0] = listDot[iii];
m_listElement.push_back(pathElement);
m_listElement.lineToV(relative,
listDot[iii]);
}
break;
case 'H': // Horizantal Line to (absolute)
case 'h': // Horizantal Line to (relative)
relative = true;
case 'H': // Horizantal Line to (absolute)
// 1 Element ...
if(listDot.size() == 0) {
SVG_WARNING("the PATH command "<< command << " has not the good number of element = " << listDot.size() );
break;
}
pathElement.m_cmd = esvg::path_lineToH;
for(int32_t iii=0; iii<listDot.size(); iii+=1) {
pathElement.m_element[0] = listDot[iii];
m_listElement.push_back(pathElement);
m_listElement.lineToH(relative,
listDot[iii]);
}
break;
case 'Q': // Quadratic Bezier curve (absolute)
case 'q': // Quadratic Bezier curve (relative)
relative = true;
case 'Q': // Quadratic Bezier curve (absolute)
// 4 Elements ...
if(listDot.size()%4 != 0) {
SVG_WARNING("the PATH command "<< command << " has not the good number of element = " << listDot.size() );
break;
}
pathElement.m_cmd = esvg::path_bezierCurveTo;
for(int32_t iii=0; iii<listDot.size(); iii+=4) {
pathElement.m_element[0] = listDot[iii];
pathElement.m_element[1] = listDot[iii+1];
pathElement.m_element[2] = listDot[iii+2];
pathElement.m_element[3] = listDot[iii+3];
m_listElement.push_back(pathElement);
m_listElement.bezierCurveTo(relative,
vec2(listDot[iii],listDot[iii+1]),
vec2(listDot[iii+2],listDot[iii+3]));
}
break;
case 'T': // smooth quadratic Bezier curve to (absolute)
case 't': // smooth quadratic Bezier curve to (relative)
relative = true;
case 'T': // smooth quadratic Bezier curve to (absolute)
// 2 Elements ...
if(listDot.size()%2 != 0) {
SVG_WARNING("the PATH command "<< command << " has not the good number of element = " << listDot.size() );
break;
}
pathElement.m_cmd = esvg::path_bezierSmothCurveTo;
for(int32_t iii=0; iii<listDot.size(); iii+=2) {
pathElement.m_element[0] = listDot[iii];
pathElement.m_element[1] = listDot[iii+1];
m_listElement.push_back(pathElement);
m_listElement.bezierSmoothCurveTo(relative,
vec2(listDot[iii],listDot[iii+1]));
}
break;
case 'C': // curve to (absolute)
case 'c': // curve to (relative)
relative = true;
case 'C': // curve to (absolute)
// 6 Elements ...
if(listDot.size()%6 != 0) {
SVG_WARNING("the PATH command "<< command << " has not the good number of element = " << listDot.size() );
break;
}
pathElement.m_cmd = path_curveTo;
for(int32_t iii=0; iii<listDot.size(); iii+=6) {
pathElement.m_element[0] = listDot[iii];
pathElement.m_element[1] = listDot[iii+1];
pathElement.m_element[2] = listDot[iii+2];
pathElement.m_element[3] = listDot[iii+3];
pathElement.m_element[4] = listDot[iii+4];
pathElement.m_element[5] = listDot[iii+5];
m_listElement.push_back(pathElement);
m_listElement.curveTo(relative,
vec2(listDot[iii],listDot[iii+1]),
vec2(listDot[iii+2],listDot[iii+3]),
vec2(listDot[iii+4],listDot[iii+5]));
}
break;
case 'S': // smooth curve to (absolute)
case 's': // smooth curve to (relative)
relative = true;
case 'S': // smooth curve to (absolute)
// 4 Elements ...
if(listDot.size()%4 != 0) {
SVG_WARNING("the PATH command "<< command << " has not the good number of element = " << listDot.size() );
break;
}
pathElement.m_cmd = esvg::path_smothCurveTo;
for(int32_t iii=0; iii<listDot.size(); iii+=4) {
pathElement.m_element[0] = listDot[iii];
pathElement.m_element[1] = listDot[iii+1];
pathElement.m_element[2] = listDot[iii+2];
pathElement.m_element[3] = listDot[iii+3];
m_listElement.push_back(pathElement);
m_listElement.smoothCurveTo(relative, vec2(listDot[iii],listDot[iii+1]), vec2(listDot[iii+2],listDot[iii+3]));
}
break;
case 'A': // elliptical Arc (absolute)
case 'a': // elliptical Arc (relative)
relative = true;
case 'A': // elliptical Arc (absolute)
// 7 Elements ...
if(listDot.size()%7 != 0) {
SVG_WARNING("the PATH command "<< command << " has not the good number of element = " << listDot.size() );
break;
}
pathElement.m_cmd = esvg::path_elliptic;
for(int32_t iii=0; iii<listDot.size(); iii+=7) {
pathElement.m_element[0] = listDot[iii];
pathElement.m_element[1] = listDot[iii+1];
pathElement.m_element[2] = listDot[iii+2];
pathElement.m_element[3] = listDot[iii+3];
pathElement.m_element[4] = listDot[iii+4];
pathElement.m_element[5] = listDot[iii+5];
pathElement.m_element[6] = listDot[iii+6];
m_listElement.push_back(pathElement);
m_listElement.ellipticTo(relative,
listDot[iii],
listDot[iii+1],
listDot[iii+2],
listDot[iii+3],
listDot[iii+4],
listDot[iii+5],
listDot[iii+6]);
}
break;
case 'Z': // closepath (absolute)
case 'z': // closepath (relative)
relative = true;
case 'Z': // closepath (absolute)
// 0 Element ...
if(listDot.size() != 0) {
SVG_WARNING("the PATH command "<< command << " has not the good number of element = " << listDot.size() );
break;
}
pathElement.m_cmd = esvg::path_stop;
m_listElement.push_back(pathElement);
m_listElement.stop(relative);
break;
default:
SVG_ERROR ("Unknow error : \"" << command << "\"");
@ -275,62 +243,7 @@ bool esvg::Path::parse(const std::shared_ptr<exml::Element>& _element, mat2& _pa
}
void esvg::Path::display(int32_t _spacing) {
SVG_DEBUG(spacingDist(_spacing) << "Path");
for(int32_t iii=0; iii<m_listElement.size(); iii++) {
switch (m_listElement[iii].m_cmd) {
case esvg::path_stop:
SVG_DEBUG(spacingDist(_spacing+4) << "STOP");
break;
case esvg::path_moveTo:
SVG_DEBUG(spacingDist(_spacing+4) << "MOVETO (" << m_listElement[iii].m_element[0] << "," << m_listElement[iii].m_element[1] << ")" );
break;
case esvg::path_lineTo:
SVG_DEBUG(spacingDist(_spacing+4) << "LINETO (" << m_listElement[iii].m_element[0] << "," << m_listElement[iii].m_element[1] << ")" );
break;
case esvg::path_lineToH:
SVG_DEBUG(spacingDist(_spacing+4) << "LINETO_H (" << m_listElement[iii].m_element[0] << ")" );
break;
case esvg::path_lineToV:
SVG_DEBUG(spacingDist(_spacing+4) << "LINETO_V (" << m_listElement[iii].m_element[0] << ")" );
break;
case esvg::path_curveTo:
SVG_DEBUG(spacingDist(_spacing+4) << "CURVETO (" << m_listElement[iii].m_element[0] <<
"," << m_listElement[iii].m_element[1] <<
"," << m_listElement[iii].m_element[2] <<
"," << m_listElement[iii].m_element[3] <<
"," << m_listElement[iii].m_element[4] <<
"," << m_listElement[iii].m_element[5] << ")" );
break;
case esvg::path_smothCurveTo:
SVG_DEBUG(spacingDist(_spacing+4) << "SMOTH_CURVETO (" << m_listElement[iii].m_element[0] <<
"," << m_listElement[iii].m_element[1] <<
"," << m_listElement[iii].m_element[2] <<
"," << m_listElement[iii].m_element[3] << ")" );
break;
case esvg::path_bezierCurveTo:
SVG_DEBUG(spacingDist(_spacing+4) << "BEZIER_CURVETO (" << m_listElement[iii].m_element[0] <<
"," << m_listElement[iii].m_element[1] <<
"," << m_listElement[iii].m_element[2] <<
"," << m_listElement[iii].m_element[3] << ")" );
break;
case esvg::path_bezierSmothCurveTo:
SVG_DEBUG(spacingDist(_spacing+4) << "BEZIER_SMOTH_CURVETO (" << m_listElement[iii].m_element[0] << "," << m_listElement[iii].m_element[1] << ")" );
break;
case esvg::path_elliptic:
SVG_DEBUG(spacingDist(_spacing+4) << "ELLIPTIC (" << m_listElement[iii].m_element[0] <<
"," << m_listElement[iii].m_element[1] <<
"," << m_listElement[iii].m_element[2] <<
"," << m_listElement[iii].m_element[3] <<
"," << m_listElement[iii].m_element[4] <<
"," << m_listElement[iii].m_element[5] <<
"," << m_listElement[iii].m_element[6] << ")" );
// show explanation at : http://www.w3.org/TR/SVG/paths.html#PathDataEllipticalArcCommands
break;
default:
SVG_DEBUG(spacingDist(_spacing+4) << "????" );
break;
}
}
m_listElement.display(_spacing);
}
class Segment {
@ -825,7 +738,7 @@ Weighter createWeighter(ivec2 _size, int32_t _subSamplingCount, const std::vecto
void esvg::Path::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
void esvg::Path::draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
SVG_VERBOSE(spacingDist(_level) << "DRAW esvg::Path");
vec2 lastPosition(0.0f, 0.0f);
std::vector<PointRender> listPoints;
@ -834,10 +747,10 @@ void esvg::Path::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t
int32_t recurtionMax = 10;
float threshold = 0.25f;
// Foreach element, we move in the path:
for(int32_t iii=0; iii<m_listElement.size(); iii++) {
switch (m_listElement[iii].m_cmd) {
case esvg::path_stop:
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::path_stop");
for(int32_t iii=0; iii<m_listElement.m_listElement.size(); iii++) {
switch (m_listElement.m_listElement[iii].getType()) {
case esvg::render::path_stop:
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::render::path_stop");
// TODO : Check if the z value mean that the path will cycle ...
if (listPoints.size() != 0) {
if (PathStart == false) {
@ -849,8 +762,8 @@ void esvg::Path::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t
}
// nothing alse to do ...
break;
case esvg::path_moveTo:
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::path_moveTo");
case esvg::render::path_moveTo:
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::render::path_moveTo");
// stop last path
if (listPoints.size() != 0) {
if (PathStart == true) {
@ -860,53 +773,53 @@ void esvg::Path::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t
}
PathStart = true;
// create a new one
if (m_listElement[iii].m_relative == false) {
if (m_listElement.m_listElement[iii].getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
}
lastPosition += vec2(m_listElement[iii].m_element[0], m_listElement[iii].m_element[1]);
lastPosition += m_listElement.m_listElement[iii].getPos();
listPoints.push_back(PointRender(lastPosition, PointRender::typePoint_start));
break;
case esvg::path_lineTo:
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::path_lineTo");
case esvg::render::path_lineTo:
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::render::path_lineTo");
// If no previous point, we need to create the last point has start ...
if (PathStart == false) {
listPoints.push_back(PointRender(lastPosition, PointRender::typePoint_join));
PathStart = true;
}
if (m_listElement[iii].m_relative == false) {
if (m_listElement.m_listElement[iii].getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
}
lastPosition += vec2(m_listElement[iii].m_element[0], m_listElement[iii].m_element[1]);
lastPosition += m_listElement.m_listElement[iii].getPos();
listPoints.push_back(PointRender(lastPosition, PointRender::typePoint_start));
break;
case esvg::path_lineToH:
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::path_lineToH");
case esvg::render::path_lineToH:
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::render::path_lineToH");
// If no previous point, we need to create the last point has start ...
if (PathStart == false) {
listPoints.push_back(PointRender(lastPosition, PointRender::typePoint_join));
PathStart = true;
}
if (m_listElement[iii].m_relative == false) {
if (m_listElement.m_listElement[iii].getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
}
lastPosition += vec2(m_listElement[iii].m_element[0], 0.0f);
lastPosition += m_listElement.m_listElement[iii].getPos();
listPoints.push_back(PointRender(lastPosition, PointRender::typePoint_start));
break;
case esvg::path_lineToV:
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::path_lineToV");
case esvg::render::path_lineToV:
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::render::path_lineToV");
// If no previous point, we need to create the last point has start ...
if (PathStart == false) {
listPoints.push_back(PointRender(lastPosition, PointRender::typePoint_join));
PathStart = true;
}
if (m_listElement[iii].m_relative == false) {
if (m_listElement.m_listElement[iii].getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
}
lastPosition += vec2(0.0, m_listElement[iii].m_element[1]);
lastPosition += m_listElement.m_listElement[iii].getPos();
listPoints.push_back(PointRender(lastPosition, PointRender::typePoint_start));
break;
case esvg::path_curveTo:
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::path_curveTo");
case esvg::render::path_curveTo:
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::render::path_curveTo");
// If no previous point, we need to create the last point has start ...
if (PathStart == false) {
listPoints.push_back(PointRender(lastPosition, PointRender::typePoint_join));
@ -914,12 +827,12 @@ void esvg::Path::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t
}
{
vec2 lastPosStore(lastPosition);
if (m_listElement[iii].m_relative == false) {
if (m_listElement.m_listElement[iii].getRelative() == false) {
lastPosition = vec2(0.0f, 0.0f);
}
vec2 pos1 = lastPosition + vec2(m_listElement[iii].m_element[0], m_listElement[iii].m_element[1]);
vec2 pos2 = lastPosition + vec2(m_listElement[iii].m_element[2], m_listElement[iii].m_element[3]);
vec2 pos = lastPosition + vec2(m_listElement[iii].m_element[4], m_listElement[iii].m_element[5]);
vec2 pos1 = lastPosition + m_listElement.m_listElement[iii].getPos1();;
vec2 pos2 = lastPosition + m_listElement.m_listElement[iii].getPos2();;
vec2 pos = lastPosition + m_listElement.m_listElement[iii].getPos();;
interpolateCubicBezier(listPoints,
recurtionMax,
threshold,
@ -932,47 +845,47 @@ void esvg::Path::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t
lastPosition = pos;
}
break;
case esvg::path_smothCurveTo:
SVG_TODO(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::path_smothCurveTo");
case esvg::render::path_smoothCurveTo:
SVG_TODO(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::render::path_smoothCurveTo");
/*
path.curve4SmoothTo(m_listElement[iii].m_relative,
vec2(m_listElement[iii].m_element[0],
m_listElement[iii].m_element[1]),
vec2(m_listElement[iii].m_element[2],
m_listElement[iii].m_element[3]) );
path.curve4SmoothTo(m_listElement.m_listElement[iii].getRelative(),
vec2(m_listElement.m_listElement[iii].m_element[0],
m_listElement.m_listElement[iii].m_element[1]),
vec2(m_listElement.m_listElement[iii].m_element[2],
m_listElement.m_listElement[iii].m_element[3]) );
*/
break;
case esvg::path_bezierCurveTo:
SVG_TODO(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::path_bezierCurveTo");
case esvg::render::path_bezierCurveTo:
SVG_TODO(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::render::path_bezierCurveTo");
/*
path.curve3To(m_listElement[iii].m_relative,
vec2(m_listElement[iii].m_element[0],
m_listElement[iii].m_element[1]),
vec2(m_listElement[iii].m_element[2],
m_listElement[iii].m_element[3]) );
path.curve3To(m_listElement.m_listElement[iii].getRelative(),
vec2(m_listElement.m_listElement[iii].m_element[0],
m_listElement.m_listElement[iii].m_element[1]),
vec2(m_listElement.m_listElement[iii].m_element[2],
m_listElement.m_listElement[iii].m_element[3]) );
*/
break;
case esvg::path_bezierSmothCurveTo:
SVG_TODO(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::path_bezierSmothCurveTo");
case esvg::render::path_bezierSmoothCurveTo:
SVG_TODO(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::render::path_bezierSmoothCurveTo");
/*
path.curve3SmoothTo(m_listElement[iii].m_relative,
vec2(m_listElement[iii].m_element[0],
m_listElement[iii].m_element[1]) );
path.curve3SmoothTo(m_listElement.m_listElement[iii].getRelative(),
vec2(m_listElement.m_listElement[iii].m_element[0],
m_listElement.m_listElement[iii].m_element[1]) );
*/
break;
case esvg::path_elliptic:
case esvg::render::path_elliptic:
/*
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::path_elliptic");
path.ellipticTo(m_listElement[iii].m_relative,
m_listElement[iii].m_element[0],
m_listElement[iii].m_element[1],
m_listElement[iii].m_element[2],
m_listElement[iii].m_element[3],
m_listElement[iii].m_element[4],
m_listElement[iii].m_element[5],
m_listElement[iii].m_element[6] );
SVG_VERBOSE(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::render::path_elliptic");
path.ellipticTo(m_listElement.m_listElement[iii].getRelative(),
m_listElement.m_listElement[iii].m_element[0],
m_listElement.m_listElement[iii].m_element[1],
m_listElement.m_listElement[iii].m_element[2],
m_listElement.m_listElement[iii].m_element[3],
m_listElement.m_listElement[iii].m_element[4],
m_listElement.m_listElement[iii].m_element[5],
m_listElement.m_listElement[iii].m_element[6] );
*/
SVG_TODO(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::path_elliptic");
SVG_TODO(spacingDist(_level+1) << "[" << iii << "] Draw : esvg::render::path_elliptic");
break;
default:
SVG_ERROR(spacingDist(_level+1) << "[" << iii << "] Unknow PATH commant (internal error)");

31
esvg/Path.h
View File

@ -10,41 +10,18 @@
#define __ESVG_PATH_H__
#include <esvg/Base.h>
#include <esvg/RenderPath.h>
#include <esvg/render/Path.h>
namespace esvg {
enum pathProperty{
path_stop,
path_moveTo,
path_lineTo,
path_lineToH,
path_lineToV,
path_curveTo,
path_smothCurveTo,
path_bezierCurveTo,
path_bezierSmothCurveTo,
path_elliptic
};
class PathBasic {
public:
PathBasic() : m_cmd(esvg::path_stop), m_relative(false) {
for(int32_t iii=0; iii<7; ++iii) {
m_element[iii] = 0;
}
}
enum pathProperty m_cmd;
bool m_relative;
float m_element[7];
};
class Path : public esvg::Base {
private:
std::vector<PathBasic> m_listElement;
public:
esvg::render::Path m_listElement;
public:
Path(PaintState _parentPaintState);
~Path();
virtual bool parse(const std::shared_ptr<exml::Element>& _element, mat2& _parentTrans, vec2& _sizeMax);
virtual void display(int32_t _spacing);
virtual void aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
virtual void draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
};
};

2
esvg/Polygon.cpp
View File

@ -64,7 +64,7 @@ void esvg::Polygon::display(int32_t _spacing) {
SVG_DEBUG(spacingDist(_spacing) << "Polygon nbPoint=" << m_listPoint.size());
}
void esvg::Polygon::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
void esvg::Polygon::draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
SVG_VERBOSE(spacingDist(_level) << "DRAW esvg::Polygon");
#if 0

2
esvg/Polygon.h
View File

@ -28,7 +28,7 @@ namespace esvg {
~Polygon();
virtual bool parse(const std::shared_ptr<exml::Element>& _element, mat2& _parentTrans, vec2& _sizeMax);
virtual void display(int32_t _spacing);
virtual void aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
virtual void draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
};
};

2
esvg/Polyline.cpp
View File

@ -57,7 +57,7 @@ void esvg::Polyline::display(int32_t _spacing) {
}
void esvg::Polyline::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
void esvg::Polyline::draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
SVG_VERBOSE(spacingDist(_level) << "DRAW esvg::Polyline");

2
esvg/Polyline.h
View File

@ -21,7 +21,7 @@ namespace esvg {
~Polyline();
virtual bool parse(const std::shared_ptr<exml::Element>& _element, mat2& _parentTrans, vec2& _sizeMax);
virtual void display(int32_t _spacing);
virtual void aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
virtual void draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
};
};

2
esvg/Rectangle.cpp
View File

@ -56,7 +56,7 @@ void esvg::Rectangle::display(int32_t _spacing) {
SVG_DEBUG(spacingDist(_spacing) << "Rectangle : pos=" << m_position << " size=" << m_size << " corner=" << m_roundedCorner);
}
void esvg::Rectangle::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
void esvg::Rectangle::draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level) {
SVG_VERBOSE(spacingDist(_level) << "DRAW esvg::Rectangle");
#if 0

2
esvg/Rectangle.h
View File

@ -22,7 +22,7 @@ namespace esvg {
~Rectangle();
virtual bool parse(const std::shared_ptr<exml::Element>& _element, mat2& _parentTrans, vec2& _sizeMax);
virtual void display(int32_t _spacing);
virtual void aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
virtual void draw(esvg::Renderer& _myRenderer, mat2& _basicTrans, int32_t _level);
};
};

103
esvg/RenderPath.cpp
View File

@ -1,103 +0,0 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#include <esvg/debug.h>
#include <esvg/RenderPath.h>
void esvg::RenderPath::clear() {
m_points.clear();
}
void esvg::RenderPath::stop() {
SVG_TODO("Must be implemented");
}
void esvg::RenderPath::addPoint(const vec2& _pos) {
m_points.push_back(_pos);
}
void esvg::RenderPath::moveTo(bool _relative, vec2 _pos) {
if(_relative == true) {
_pos = relativeToAbsolute(_pos);
}
if (m_points.size() > 0) {
m_points.back() = _pos;
} else {
addPoint(_pos);
}
}
vec2 esvg::RenderPath::relativeToAbsolute(const vec2& _value) {
vec2 out(_value);
if (m_points.size() > 0) {
out += m_points.back();
}
return out;
}
void esvg::RenderPath::lineTo(bool _relative, vec2 _pos) {
if(_relative == true) {
_pos = relativeToAbsolute(_pos);
}
vec2 pos;
vec2 delta;
if (m_points.size() > 0) {
vec2 oldPos = m_points.back();
vec2 delta = _pos - oldPos;
// create a basic bezier curve ...
addPoint(oldPos + delta*0.3333f);
addPoint(oldPos - delta*0.3333f);
addPoint(_pos);
} else {
SVG_ERROR("try to lineTo whith no previous point ...");
}
}
void esvg::RenderPath::curve3SmoothTo(bool _relative, vec2 _pos) {
if(_relative == true) {
_pos = relativeToAbsolute(_pos);
}
SVG_TODO("later ...");
}
void esvg::RenderPath::curve3To(bool _relative, vec2 _pos1, vec2 _pos) {
if(_relative == true) {
_pos1 = relativeToAbsolute(_pos1);
_pos = relativeToAbsolute(_pos);
}
SVG_TODO("later ...");
}
void esvg::RenderPath::curve4SmoothTo(bool _relative, vec2 _pos2, vec2 _pos) {
if(_relative == true) {
_pos2 = relativeToAbsolute(_pos2);
_pos = relativeToAbsolute(_pos);
}
SVG_TODO("later ...");
}
void esvg::RenderPath::curve4To(bool _relative, vec2 _pos1, vec2 _pos2, vec2 _pos) {
if(_relative == true) {
_pos1 = relativeToAbsolute(_pos1);
_pos2 = relativeToAbsolute(_pos2);
_pos = relativeToAbsolute(_pos);
}
addPoint(_pos1);
addPoint(_pos2);
addPoint(_pos);
}
void esvg::RenderPath::display() {
SVG_VERBOSE("PATH : ");
for (uint32_t iii=0; iii<m_points.size()-1; iii+=3) {
SVG_VERBOSE(" point: " << m_points[iii]);
SVG_VERBOSE(" v: " << m_points[iii+1]);
SVG_VERBOSE(" v: " << m_points[iii+2]);
}
SVG_VERBOSE(" point: " << m_points.back());
}

45
esvg/RenderPath.h
View File

@ -1,45 +0,0 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#ifndef __ESVG_RENDERER_PATH_H__
#define __ESVG_RENDERER_PATH_H__
#include <etk/types.h>
#include <etk/math/Vector2D.h>
namespace esvg {
class RenderPath {
public:
std::vector<vec2> m_points;
public:
RenderPath() {
}
~RenderPath() {
}
void clear();
void stop();
void addPoint(const vec2& _pos);
void moveTo(bool _relative, vec2 _pos);
void lineTo(bool _relative, vec2 _pos);
void curve4To(bool _relative, vec2 _pos1, vec2 _pos2, vec2 _pos);
void curve4SmoothTo(bool _relative, vec2 _pos2, vec2 _pos);
void curve3To(bool _relative, vec2 _pos1, vec2 _pos);
void curve3SmoothTo(bool _relative, vec2 _pos);
//void ellipticTo(bool _relative, 7 values ...);
vec2 relativeToAbsolute(const vec2& _value);
void display();
};
};
#endif

8
esvg/esvg.cpp
View File

@ -56,11 +56,11 @@ void esvg::Document::displayDebug() {
}
void esvg::Document::aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans)
void esvg::Document::draw(esvg::Renderer& _myRenderer, mat2& _basicTrans)
{
for (int32_t iii=0; iii<m_subElementList.size(); iii++) {
if (m_subElementList[iii] != nullptr) {
m_subElementList[iii]->aggDraw(_myRenderer, _basicTrans);
m_subElementList[iii]->draw(_myRenderer, _basicTrans);
}
}
}
@ -89,7 +89,7 @@ void esvg::Document::generateTestFile()
//basicTrans *= etk::mat2Translate(vec2(width/3, height/3));
aggDraw(*m_renderedElement, basicTrans);
draw(*m_renderedElement, basicTrans);
std::string tmpFileOut = "yyy_out_";
tmpFileOut += m_fileName;
tmpFileOut += ".ppm";
@ -124,7 +124,7 @@ void esvg::Document::generateAnImage(int32_t _sizeX, int32_t _sizeY) {
//basicTrans *= etk::mat2Translate(vec2(width*0.3, height/2));
//basicTrans *= etk::mat2Translate(vec2(width/3, height/3));
aggDraw(*m_renderedElement, basicTrans);
draw(*m_renderedElement, basicTrans);
std::string tmpFileOut = "zzz_out_test.ppm";
m_renderedElement->writePpm(tmpFileOut);
}

2
esvg/esvg.h
View File

@ -71,7 +71,7 @@ namespace esvg {
void generateAnImage(int32_t _sizeX, int32_t _sizeY);
//void generateAnImage(ivec2 _size, draw::Image& _output);
//void generateAnImage(draw::Image& _output);
virtual void aggDraw(esvg::Renderer& _myRenderer, mat2& _basicTrans);
virtual void draw(esvg::Renderer& _myRenderer, mat2& _basicTrans);
uint8_t* getPointerOnData();
uint32_t getSizeOnData();
vec2 getDefinedSize() {

12
esvg/render/Element.cpp Normal file
View File

@ -0,0 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#include <esvg/render/Element.h>
#include <esvg/debug.h>

95
esvg/render/Element.h Normal file
View File

@ -0,0 +1,95 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#ifndef __ESVG_RENDER_ELEMENT_H__
#define __ESVG_RENDER_ELEMENT_H__
#include <etk/types.h>
#include <etk/math/Vector2D.h>
namespace esvg {
namespace render {
enum path {
path_stop,
path_moveTo,
path_lineTo,
path_lineToH,
path_lineToV,
path_curveTo,
path_smoothCurveTo,
path_bezierCurveTo,
path_bezierSmoothCurveTo,
path_elliptic
};
class Element {
public:
Element(enum path _type, bool _relative=false) :
m_cmd(_type),
m_relative(_relative) {
}
virtual ~Element() { }
private:
enum path m_cmd;
public:
enum path getType() const {
return m_cmd;
}
protected:
bool m_relative;
public:
bool getRelative() const {
return m_relative;
}
void setRelative(bool _relative) {
m_relative = _relative;
}
protected:
vec2 m_pos;
public:
const vec2& getPos() const {
return m_pos;
}
void setPos(const vec2& _val) {
m_pos = _val;
}
protected:
vec2 m_pos1;
public:
const vec2& getPos1() const {
return m_pos1;
}
void setPos1(const vec2& _val) {
m_pos1 = _val;
}
protected:
vec2 m_pos2;
public:
const vec2& getPos2() const {
return m_pos2;
}
void setPos2(const vec2& _val) {
m_pos2 = _val;
}
};
}
}
#endif
#include <esvg/render/ElementStop.h>
#include <esvg/render/ElementMoveTo.h>
#include <esvg/render/ElementLineTo.h>
#include <esvg/render/ElementLineToH.h>
#include <esvg/render/ElementLineToV.h>
#include <esvg/render/ElementCurveTo.h>
#include <esvg/render/ElementSmoothCurveTo.h>
#include <esvg/render/ElementBezierCurveTo.h>
#include <esvg/render/ElementBezierSmoothCurveTo.h>
#include <esvg/render/ElementElliptic.h>

12
esvg/render/ElementBezierCurveTo.cpp Normal file
View File

@ -0,0 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#include <esvg/render/Element.h>
#include <esvg/debug.h>

30
esvg/render/ElementBezierCurveTo.h Normal file
View File

@ -0,0 +1,30 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#ifndef __ESVG_RENDER_ELEMENT_BEZIER_CURVE_TO_H__
#define __ESVG_RENDER_ELEMENT_BEZIER_CURVE_TO_H__
#include <etk/types.h>
#include <etk/math/Vector2D.h>
#include <esvg/render/Element.h>
namespace esvg {
namespace render {
class ElementBezierCurveTo : public Element {
public:
ElementBezierCurveTo(bool _relative, const vec2& _pos1, const vec2& _pos):
Element(esvg::render::path_bezierCurveTo, _relative) {
m_pos = _pos;
m_pos1 = _pos1;
}
};
}
}
#endif

12
esvg/render/ElementBezierSmoothCurveTo.cpp Normal file
View File

@ -0,0 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#include <esvg/render/Element.h>
#include <esvg/debug.h>

29
esvg/render/ElementBezierSmoothCurveTo.h Normal file
View File

@ -0,0 +1,29 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#ifndef __ESVG_RENDER_ELEMENT_BEZIER_SMOOTH_CURVE_TO_H__
#define __ESVG_RENDER_ELEMENT_BEZIER_SMOOTH_CURVE_TO_H__
#include <etk/types.h>
#include <etk/math/Vector2D.h>
#include <esvg/render/Element.h>
namespace esvg {
namespace render {
class ElementBezierSmoothCurveTo : public Element {
public:
ElementBezierSmoothCurveTo(bool _relative, const vec2& _pos):
Element(esvg::render::path_bezierSmoothCurveTo, _relative) {
m_pos = _pos;
}
};
}
}
#endif

12
esvg/render/ElementCurveTo.cpp Normal file
View File

@ -0,0 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#include <esvg/render/Element.h>
#include <esvg/debug.h>

31
esvg/render/ElementCurveTo.h Normal file
View File

@ -0,0 +1,31 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#ifndef __ESVG_RENDER_ELEMENT_CURVE_TO_H__
#define __ESVG_RENDER_ELEMENT_CURVE_TO_H__
#include <etk/types.h>
#include <etk/math/Vector2D.h>
#include <esvg/render/Element.h>
namespace esvg {
namespace render {
class ElementCurveTo : public Element {
public:
ElementCurveTo(bool _relative, const vec2& _pos1, const vec2& _pos2, const vec2& _pos):
Element(esvg::render::path_curveTo, _relative) {
m_pos = _pos;
m_pos1 = _pos1;
m_pos2 = _pos2;
}
};
}
}
#endif

12
esvg/render/ElementElliptic.cpp Normal file
View File

@ -0,0 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#include <esvg/render/Element.h>
#include <esvg/debug.h>

29
esvg/render/ElementElliptic.h Normal file
View File

@ -0,0 +1,29 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#ifndef __ESVG_RENDER_ELEMENT_ELLIPTIC_H__
#define __ESVG_RENDER_ELEMENT_ELLIPTIC_H__
#include <etk/types.h>
#include <etk/math/Vector2D.h>
#include <esvg/render/Element.h>
namespace esvg {
namespace render {
class ElementElliptic : public Element {
public:
ElementElliptic(bool _relative, float _val0, float _val1, float _val2, float _val3, float _val4, float _val5, float _val6):
Element(esvg::render::path_elliptic, _relative) {
// TODO ... later ...
}
};
}
}
#endif

12
esvg/render/ElementLineTo.cpp Normal file
View File

@ -0,0 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#include <esvg/render/Element.h>
#include <esvg/debug.h>

29
esvg/render/ElementLineTo.h Normal file
View File

@ -0,0 +1,29 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#ifndef __ESVG_RENDER_ELEMENT_LINE_TO_H__
#define __ESVG_RENDER_ELEMENT_LINE_TO_H__
#include <etk/types.h>
#include <etk/math/Vector2D.h>
#include <esvg/render/Element.h>
namespace esvg {
namespace render {
class ElementLineTo : public Element {
public:
ElementLineTo(bool _relative, const vec2& _pos):
Element(esvg::render::path_lineTo, _relative) {
m_pos = _pos;
}
};
}
}
#endif

12
esvg/render/ElementLineToH.cpp Normal file
View File

@ -0,0 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#include <esvg/render/Element.h>
#include <esvg/debug.h>

29
esvg/render/ElementLineToH.h Normal file
View File

@ -0,0 +1,29 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#ifndef __ESVG_RENDER_ELEMENT_LINE_TO_H_H__
#define __ESVG_RENDER_ELEMENT_LINE_TO_H_H__
#include <etk/types.h>
#include <etk/math/Vector2D.h>
#include <esvg/render/Element.h>
namespace esvg {
namespace render {
class ElementLineToH : public Element {
public:
ElementLineToH(bool _relative, float _posX):
Element(esvg::render::path_lineToH, _relative) {
m_pos = vec2(_posX, 0.0f);
}
};
}
}
#endif

12
esvg/render/ElementLineToV.cpp Normal file
View File

@ -0,0 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#include <esvg/render/Element.h>
#include <esvg/debug.h>

29
esvg/render/ElementLineToV.h Normal file
View File

@ -0,0 +1,29 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#ifndef __ESVG_RENDER_ELEMENT_LINE_TO_V_H__
#define __ESVG_RENDER_ELEMENT_LINE_TO_V_H__
#include <etk/types.h>
#include <etk/math/Vector2D.h>
#include <esvg/render/Element.h>
namespace esvg {
namespace render {
class ElementLineToV : public Element {
public:
ElementLineToV(bool _relative, float _posY):
Element(esvg::render::path_lineToV, _relative) {
m_pos = vec2(0.0f, _posY);
}
};
}
}
#endif

12
esvg/render/ElementMoveTo.cpp Normal file
View File

@ -0,0 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#include <esvg/render/Element.h>
#include <esvg/debug.h>

29
esvg/render/ElementMoveTo.h Normal file
View File

@ -0,0 +1,29 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#ifndef __ESVG_RENDER_ELEMENT_MOVE_TO_H__
#define __ESVG_RENDER_ELEMENT_MOVE_TO_H__
#include <etk/types.h>
#include <etk/math/Vector2D.h>
#include <esvg/render/Element.h>
namespace esvg {
namespace render {
class ElementMoveTo : public Element {
public:
ElementMoveTo(bool _relative, const vec2& _pos):
Element(esvg::render::path_moveTo, _relative) {
m_pos = _pos;
}
};
}
}
#endif

12
esvg/render/ElementSmoothCurveTo.cpp Normal file
View File

@ -0,0 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#include <esvg/render/Element.h>
#include <esvg/debug.h>

30
esvg/render/ElementSmoothCurveTo.h Normal file
View File

@ -0,0 +1,30 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#ifndef __ESVG_RENDER_ELEMENT_SMOOTH_CURVE_TO_H__
#define __ESVG_RENDER_ELEMENT_SMOOTH_CURVE_TO_H__
#include <etk/types.h>
#include <etk/math/Vector2D.h>
#include <esvg/render/Element.h>
namespace esvg {
namespace render {
class ElementSmoothCurveTo : public Element {
public:
ElementSmoothCurveTo(bool _relative, const vec2& _pos2, const vec2& _pos):
Element(esvg::render::path_smoothCurveTo, _relative) {
m_pos = _pos;
m_pos2 = _pos2;
}
};
}
}
#endif

12
esvg/render/ElementStop.cpp Normal file
View File

@ -0,0 +1,12 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#include <esvg/render/Element.h>
#include <esvg/debug.h>

29
esvg/render/ElementStop.h Normal file
View File

@ -0,0 +1,29 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#ifndef __ESVG_RENDER_ELEMENT_STOP_H__
#define __ESVG_RENDER_ELEMENT_STOP_H__
#include <etk/types.h>
#include <etk/math/Vector2D.h>
#include <esvg/render/Element.h>
namespace esvg {
namespace render {
class ElementStop : public Element {
public:
ElementStop(bool _relative=false):
Element(esvg::render::path_stop, _relative) {
}
};
}
}
#endif

105
esvg/render/Path.cpp Normal file
View File

@ -0,0 +1,105 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#include <esvg/debug.h>
#include <esvg/render/Path.h>
#include <esvg/render/Element.h>
void esvg::render::Path::clear() {
m_listElement.clear();
}
void esvg::render::Path::stop(bool _relative) {
m_listElement.push_back(esvg::render::ElementStop(_relative));
}
void esvg::render::Path::moveTo(bool _relative, const vec2& _pos) {
m_listElement.push_back(esvg::render::ElementMoveTo(_relative, _pos));
}
void esvg::render::Path::lineTo(bool _relative, const vec2& _pos) {
m_listElement.push_back(esvg::render::ElementLineTo(_relative, _pos));
}
void esvg::render::Path::lineToH(bool _relative, float _posX) {
m_listElement.push_back(esvg::render::ElementLineToH(_relative, _posX));
}
void esvg::render::Path::lineToV(bool _relative, float _posY) {
m_listElement.push_back(esvg::render::ElementLineToV(_relative, _posY));
}
void esvg::render::Path::curveTo(bool _relative, const vec2& _pos1, const vec2& _pos2, const vec2& _pos) {
m_listElement.push_back(esvg::render::ElementCurveTo(_relative, _pos1, _pos2, _pos));
}
void esvg::render::Path::smoothCurveTo(bool _relative, const vec2& _pos2, const vec2& _pos) {
m_listElement.push_back(esvg::render::ElementSmoothCurveTo(_relative, _pos2, _pos));
}
void esvg::render::Path::bezierCurveTo(bool _relative, const vec2& _pos1, const vec2& _pos) {
m_listElement.push_back(esvg::render::ElementBezierCurveTo(_relative, _pos1, _pos));
}
void esvg::render::Path::bezierSmoothCurveTo(bool _relative, const vec2& _pos) {
m_listElement.push_back(esvg::render::ElementBezierSmoothCurveTo(_relative, _pos));
}
void esvg::render::Path::ellipticTo(bool _relative, float _val0, float _val1, float _val2, float _val3, float _val4, float _val5, float _val6) {
m_listElement.push_back(esvg::render::ElementElliptic(_relative, _val0, _val1, _val2, _val3, _val4, _val5, _val6));
}
static const char* spacingDist(int32_t _spacing) {
static const char *tmpValue = " ";
if (_spacing>20) {
_spacing = 20;
}
return tmpValue + 20*4 - _spacing*4;
}
void esvg::render::Path::display(int32_t _spacing) {
SVG_DEBUG(spacingDist(_spacing) << "Path");
for(auto &it : m_listElement) {
switch (it.getType()) {
case esvg::render::path_stop:
SVG_DEBUG(spacingDist(_spacing+4) << "STOP");
break;
case esvg::render::path_moveTo:
SVG_DEBUG(spacingDist(_spacing+4) << "MOVETO " << it.getPos() );
break;
case esvg::render::path_lineTo:
SVG_DEBUG(spacingDist(_spacing+4) << "LINETO " << it.getPos() );
break;
case esvg::render::path_lineToH:
SVG_DEBUG(spacingDist(_spacing+4) << "LINETO_H " << it.getPos().x());
break;
case esvg::render::path_lineToV:
SVG_DEBUG(spacingDist(_spacing+4) << "LINETO_V " << it.getPos().y() );
break;
case esvg::render::path_curveTo:
SVG_DEBUG(spacingDist(_spacing+4) << "CURVETO " << it.getPos2() << " " << it.getPos1() << " " << it.getPos() );
break;
case esvg::render::path_smoothCurveTo:
SVG_DEBUG(spacingDist(_spacing+4) << "SMOOTH_CURVETO " << it.getPos2() << " " << it.getPos() );
break;
case esvg::render::path_bezierCurveTo:
SVG_DEBUG(spacingDist(_spacing+4) << "BEZIER_CURVETO " << it.getPos1() << " " << it.getPos() );
break;
case esvg::render::path_bezierSmoothCurveTo:
SVG_DEBUG(spacingDist(_spacing+4) << "BEZIER_SMOOTH_CURVETO " << it.getPos() );
break;
case esvg::render::path_elliptic:
SVG_DEBUG(spacingDist(_spacing+4) << "ELLIPTIC ???");
// show explanation at : http://www.w3.org/TR/SVG/paths.html#PathDataEllipticalArcCommands
break;
default:
SVG_DEBUG(spacingDist(_spacing+4) << "????" );
break;
}
}
}

45
esvg/render/Path.h Normal file
View File

@ -0,0 +1,45 @@
/**
* @author Edouard DUPIN
*
* @copyright 2011, Edouard DUPIN, all right reserved
*
* @license APACHE v2.0 (see license file)
*/
#ifndef __ESVG_RENDER_PATH_H__
#define __ESVG_RENDER_PATH_H__
#include <etk/types.h>
#include <etk/math/Vector2D.h>
#include <esvg/render/Element.h>
namespace esvg {
namespace render {
class Path {
public:
std::vector<esvg::render::Element> m_listElement;
public:
Path() {
}
~Path() {
}
void clear();
void stop(bool _relative);
void moveTo(bool _relative, const vec2& _pos);
void lineTo(bool _relative, const vec2& _pos);
void lineToH(bool _relative, float _posX);
void lineToV(bool _relative, float _posY);
void curveTo(bool _relative, const vec2& _pos1, const vec2& _pos2, const vec2& _pos);
void smoothCurveTo(bool _relative, const vec2& _pos2, const vec2& _pos);
void bezierCurveTo(bool _relative, const vec2& _pos1, const vec2& _pos);
void bezierSmoothCurveTo(bool _relative, const vec2& _pos);
void ellipticTo(bool _relative, float _val0, float _val1, float _val2, float _val3, float _val4, float _val5, float _val6);
void display(int32_t _spacing);
};
}
}
#endif

29
lutin_esvg.py
View File

@ -40,9 +40,20 @@ def create(target, module_name):
'esvg/Polyline.cpp',
'esvg/Rectangle.cpp',
'esvg/Renderer.cpp',
'esvg/RenderPath.cpp',
'esvg/Stroking.cpp',
'esvg/Text.cpp'
'esvg/Text.cpp',
'esvg/render/Path.cpp',
'esvg/render/Element.cpp',
'esvg/render/ElementStop.cpp',
'esvg/render/ElementMoveTo.cpp',
'esvg/render/ElementLineTo.cpp',
'esvg/render/ElementLineToH.cpp',
'esvg/render/ElementLineToV.cpp',
'esvg/render/ElementCurveTo.cpp',
'esvg/render/ElementSmoothCurveTo.cpp',
'esvg/render/ElementBezierCurveTo.cpp',
'esvg/render/ElementBezierSmoothCurveTo.cpp',
'esvg/render/ElementElliptic.cpp'
])
my_module.add_header_file([
@ -58,7 +69,19 @@ def create(target, module_name):
'esvg/Rectangle.h',
'esvg/Renderer.h',
'esvg/Stroking.h',
'esvg/Text.h'
'esvg/Text.h',
'esvg/render/Path.h',
'esvg/render/Element.h',
'esvg/render/ElementStop.h',
'esvg/render/ElementMoveTo.h',
'esvg/render/ElementLineTo.h',
'esvg/render/ElementLineToH.h',
'esvg/render/ElementLineToV.h',
'esvg/render/ElementCurveTo.h',
'esvg/render/ElementSmoothCurveTo.h',
'esvg/render/ElementBezierCurveTo.h',
'esvg/render/ElementBezierSmoothCurveTo.h',
'esvg/render/ElementElliptic.h'
])
my_module.add_path(tools.get_current_path(__file__))