821 lines
26 KiB
C++
Executable File
821 lines
26 KiB
C++
Executable File
|
|
//
|
|
// Copyright (C) : Please refer to the COPYRIGHT file distributed
|
|
// with this source distribution.
|
|
//
|
|
// This program is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU General Public License
|
|
// as published by the Free Software Foundation; either version 2
|
|
// of the License, or (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program; if not, write to the Free Software
|
|
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "StrokeRep.h"
|
|
#include "Stroke.h"
|
|
#include "StrokeRenderer.h"
|
|
#include "StrokeAdvancedIterators.h"
|
|
#include "StrokeIterators.h"
|
|
|
|
using namespace std;
|
|
|
|
//
|
|
// STROKE VERTEX REP
|
|
/////////////////////////////////////
|
|
StrokeVertexRep::StrokeVertexRep(const StrokeVertexRep& iBrother){
|
|
_point2d = iBrother._point2d;
|
|
_texCoord = iBrother._texCoord;
|
|
_color = iBrother._color;
|
|
_alpha = iBrother._alpha;
|
|
}
|
|
|
|
//
|
|
// STRIP
|
|
/////////////////////////////////////
|
|
|
|
Strip::Strip(const vector<StrokeVertex*>& iStrokeVertices, bool hasTips, bool beginTip, bool endTip){
|
|
createStrip(iStrokeVertices);
|
|
if (!hasTips)
|
|
computeTexCoord (iStrokeVertices);
|
|
else
|
|
computeTexCoordWithTips (iStrokeVertices, beginTip, endTip);
|
|
}
|
|
Strip::Strip(const Strip& iBrother){
|
|
if(!iBrother._vertices.empty()){
|
|
for(vertex_container::const_iterator v=iBrother._vertices.begin(), vend=iBrother._vertices.end();
|
|
v!=vend;
|
|
++v){
|
|
_vertices.push_back(new StrokeVertexRep(**v));
|
|
}
|
|
}
|
|
_averageThickness = iBrother._averageThickness;
|
|
}
|
|
|
|
Strip::~Strip(){
|
|
if(!_vertices.empty()){
|
|
for(vertex_container::iterator v=_vertices.begin(), vend=_vertices.end();
|
|
v!=vend;
|
|
++v){
|
|
delete (*v);
|
|
}
|
|
_vertices.clear();
|
|
}
|
|
}
|
|
|
|
//////////////////////////
|
|
// Strip creation
|
|
//////////////////////////
|
|
#define EPS_SINGULARITY_RENDERER 0.05
|
|
#define ZERO 0.00001
|
|
#define MAX_RATIO_LENGTH_SINGU 2
|
|
#define HUGE_COORD 1e4
|
|
|
|
bool notValid (Vec2r p)
|
|
{
|
|
return (p[0]!=p[0]) || (p[1]!=p[1]) || (fabs(p[0])>HUGE_COORD) || (fabs(p[1])>HUGE_COORD)
|
|
|| (p[0] <-HUGE_COORD) || (p[1]<-HUGE_COORD);
|
|
}
|
|
|
|
real crossP(const Vec2r& A, const Vec2r& B){
|
|
return A[0]*B[1] - A[1]*B[0];
|
|
}
|
|
|
|
void
|
|
Strip::createStrip (const vector<StrokeVertex*>& iStrokeVertices)
|
|
{
|
|
//computeParameterization();
|
|
if (iStrokeVertices.size() <2)
|
|
{
|
|
cerr << "Warning: strip has less than 2 vertices" << endl;
|
|
return;
|
|
}
|
|
_vertices.reserve(2*iStrokeVertices.size());
|
|
if(!_vertices.empty()){
|
|
for(vertex_container::iterator v=_vertices.begin(), vend=_vertices.end();
|
|
v!=vend;
|
|
++v){
|
|
delete (*v);
|
|
}
|
|
_vertices.clear();
|
|
}
|
|
_averageThickness=0.0;
|
|
|
|
vector<StrokeVertex*>::const_iterator v ,vend, v2, vPrev;
|
|
StrokeVertex *sv, *sv2, *svPrev;
|
|
|
|
//special case of first vertex
|
|
v=iStrokeVertices.begin();
|
|
sv=*v;
|
|
vPrev=v; //in case the stroke has only 2 vertices;
|
|
++v; sv2=*v;
|
|
Vec2r dir(sv2->getPoint()-sv->getPoint());
|
|
Vec2r orthDir(-dir[1], dir[0]);
|
|
if (orthDir.norm() > ZERO)
|
|
orthDir.normalize();
|
|
const float *thickness = sv->attribute().getThickness();
|
|
_vertices.push_back(new StrokeVertexRep(sv->getPoint()+thickness[1]*orthDir));
|
|
_vertices.push_back(new StrokeVertexRep(sv->getPoint()-thickness[0]*orthDir));
|
|
|
|
Vec2r stripDir(orthDir);
|
|
// check whether the orientation
|
|
// was user defined
|
|
if(sv->attribute().isAttributeAvailableVec2f("orientation")){
|
|
Vec2r userDir = sv->attribute().getAttributeVec2f("orientation");
|
|
userDir.normalize();
|
|
Vec2r t(orthDir[1], -orthDir[0]);
|
|
real dp1 = userDir*orthDir;
|
|
real dp2 = userDir*t;
|
|
real h = (thickness[1]+thickness[0])/dp1;
|
|
real x = fabs(h*dp2/2.0);
|
|
if(dp1>0){
|
|
//i'm in the upper part of the unit circle
|
|
if(dp2>0){
|
|
//i'm in the upper-right part of the unit circle
|
|
// i must move vertex 1
|
|
_vertices[1]->setPoint2d(_vertices[0]->point2d()-userDir*(h));
|
|
//_vertices[0]->setPoint2d(_vertices[0]->point2d()+t*x);
|
|
//_vertices[1]->setPoint2d(_vertices[1]->point2d()-t*x);
|
|
}else{
|
|
//i'm in the upper-left part of the unit circle
|
|
// i must move vertex 0
|
|
_vertices[0]->setPoint2d(_vertices[1]->point2d()+userDir*(h));
|
|
//_vertices[0]->setPoint2d(_vertices[0]->point2d()-t*x);
|
|
//_vertices[1]->setPoint2d(_vertices[1]->point2d()+t*x);
|
|
}
|
|
}else{
|
|
//i'm in the lower part of the unit circle
|
|
if(dp2>0){
|
|
//i'm in the lower-right part of the unit circle
|
|
// i must move vertex 0
|
|
//_vertices[0]->setPoint2d(_vertices[1]->point2d()-userDir*(h));
|
|
_vertices[0]->setPoint2d(_vertices[0]->point2d()-t*x);
|
|
//_vertices[1]->setPoint2d(_vertices[1]->point2d()+t*x);
|
|
}else{
|
|
//i'm in the lower-left part of the unit circle
|
|
// i must move vertex 1
|
|
_vertices[1]->setPoint2d(_vertices[0]->point2d()+userDir*(h));
|
|
//_vertices[0]->setPoint2d(_vertices[0]->point2d()-t*x);
|
|
//_vertices[1]->setPoint2d(_vertices[1]->point2d()-t*x);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Vec2r userDir = _stroke->getBeginningOrientation();
|
|
// if(userDir != Vec2r(0,0)){
|
|
// userDir.normalize();
|
|
// real o1 = (orthDir*userDir);
|
|
// real o2 = crossP(orthDir,userDir);
|
|
// real orientation = o1 * o2;
|
|
// if(orientation > 0){
|
|
// // then the vertex to move is v0
|
|
// if(o1 > 0)
|
|
// _vertex[0]=_vertex[1]+userDir;
|
|
// else
|
|
// _vertex[0]=_vertex[1]-userDir;
|
|
// }
|
|
// if(orientation < 0){
|
|
// // then we must move v1
|
|
// if(o1 < 0)
|
|
// _vertex[1]=_vertex[0]+userDir;
|
|
// else
|
|
// _vertex[1]=_vertex[0]-userDir;
|
|
// }
|
|
// }
|
|
|
|
int i=2; //2 because we have already processed the first vertex
|
|
|
|
for(vend=iStrokeVertices.end();
|
|
v!=vend;
|
|
v++){
|
|
v2=v; ++v2;
|
|
if (v2==vend) break;
|
|
sv= (*v); sv2 = (*v2); svPrev=(*vPrev);
|
|
Vec2r p(sv->getPoint()), p2(sv2->getPoint()), pPrev(svPrev->getPoint());
|
|
|
|
//direction and orthogonal vector to the next segment
|
|
Vec2r dir(p2-p);
|
|
float dirNorm=dir.norm();
|
|
dir.normalize();
|
|
Vec2r orthDir(-dir[1], dir[0]);
|
|
Vec2r stripDir = orthDir;
|
|
if(sv->attribute().isAttributeAvailableVec2f("orientation")){
|
|
Vec2r userDir = sv->attribute().getAttributeVec2f("orientation");
|
|
userDir.normalize();
|
|
real dp = userDir*orthDir;
|
|
if(dp<0)
|
|
userDir = userDir*(-1.f);
|
|
stripDir = userDir;
|
|
}
|
|
|
|
//direction and orthogonal vector to the previous segment
|
|
Vec2r dirPrev(p-pPrev);
|
|
float dirPrevNorm=dirPrev.norm();
|
|
dirPrev.normalize();
|
|
Vec2r orthDirPrev(-dirPrev[1], dirPrev[0]);
|
|
Vec2r stripDirPrev = orthDirPrev;
|
|
if(svPrev->attribute().isAttributeAvailableVec2f("orientation")){
|
|
Vec2r userDir = svPrev->attribute().getAttributeVec2f("orientation");
|
|
userDir.normalize();
|
|
real dp = userDir*orthDir;
|
|
if(dp<0)
|
|
userDir = userDir*(-1.f);
|
|
stripDirPrev = userDir;
|
|
}
|
|
|
|
const float *thickness = sv->attribute().getThickness();
|
|
_averageThickness+=thickness[0]+thickness[1];
|
|
Vec2r pInter;
|
|
int interResult;
|
|
|
|
interResult=GeomUtils::intersect2dLine2dLine(Vec2r(pPrev+thickness[1]*stripDirPrev), Vec2r(p+thickness[1]*stripDirPrev),
|
|
Vec2r(p+thickness[1]*stripDir), Vec2r(p2+thickness[1]*stripDir),
|
|
pInter);
|
|
|
|
if (interResult==GeomUtils::DO_INTERSECT)
|
|
_vertices.push_back(new StrokeVertexRep(pInter));
|
|
else
|
|
_vertices.push_back(new StrokeVertexRep(p+thickness[1]*stripDir));
|
|
++i;
|
|
|
|
interResult=GeomUtils::intersect2dLine2dLine(Vec2r(pPrev-thickness[0]*stripDirPrev), Vec2r(p-thickness[0]*stripDirPrev),
|
|
Vec2r(p-thickness[0]*stripDir), Vec2r(p2-thickness[0]*stripDir),
|
|
pInter);
|
|
if (interResult==GeomUtils::DO_INTERSECT)
|
|
_vertices.push_back(new StrokeVertexRep(pInter));
|
|
else
|
|
_vertices.push_back(new StrokeVertexRep(p-thickness[0]*stripDir));
|
|
++i;
|
|
|
|
// if the angle is obtuse, we simply average the directions to avoid the singularity
|
|
stripDir=stripDir+stripDirPrev;
|
|
if ((dirNorm<ZERO) || (dirPrevNorm<ZERO) || (stripDir.norm() < ZERO)) {
|
|
stripDir[0] = 0;
|
|
stripDir[1] = 0;
|
|
}else
|
|
stripDir.normalize();
|
|
|
|
Vec2r vec_tmp(_vertices[i-2]->point2d()-p);
|
|
if ((vec_tmp.norm() > thickness[1]*MAX_RATIO_LENGTH_SINGU) ||
|
|
(dirNorm<ZERO) || (dirPrevNorm<ZERO) ||
|
|
notValid(_vertices[i-2]->point2d())
|
|
|| (fabs(stripDir * dir) < EPS_SINGULARITY_RENDERER))
|
|
_vertices[i-2]->setPoint2d(p+thickness[1]*stripDir);
|
|
|
|
vec_tmp = _vertices[i-1]->point2d()-p;
|
|
if ((vec_tmp.norm() > thickness[1]*MAX_RATIO_LENGTH_SINGU) ||
|
|
(dirNorm<ZERO) || (dirPrevNorm<ZERO) ||
|
|
notValid(_vertices[i-1]->point2d())
|
|
|| (fabs(stripDir * dir)<EPS_SINGULARITY_RENDERER))
|
|
_vertices[i-1]->setPoint2d(p-thickness[0]*stripDir);
|
|
|
|
vPrev=v;
|
|
} // end of for
|
|
|
|
//special case of last vertex
|
|
sv=*v;
|
|
sv2=*vPrev;
|
|
dir=Vec2r (sv->getPoint()-sv2->getPoint());
|
|
orthDir=Vec2r(-dir[1], dir[0]);
|
|
if (orthDir.norm() > ZERO)
|
|
orthDir.normalize();
|
|
const float *thicknessLast = sv->attribute().getThickness();
|
|
_vertices.push_back(new StrokeVertexRep(sv->getPoint()+thicknessLast[1]*orthDir));
|
|
++i;
|
|
_vertices.push_back(new StrokeVertexRep(sv->getPoint()-thicknessLast[0]*orthDir));
|
|
int n = i;
|
|
++i;
|
|
|
|
// check whether the orientation
|
|
// was user defined
|
|
if(sv->attribute().isAttributeAvailableVec2f("orientation")){
|
|
Vec2r userDir = sv->attribute().getAttributeVec2f("orientation");
|
|
userDir.normalize();
|
|
Vec2r t(orthDir[1], -orthDir[0]);
|
|
real dp1 = userDir*orthDir;
|
|
real dp2 = userDir*t;
|
|
real h = (thicknessLast[1]+thicknessLast[0])/dp1;
|
|
real x = fabs(h*dp2/2.0);
|
|
if(dp1>0){
|
|
//i'm in the upper part of the unit circle
|
|
if(dp2>0){
|
|
//i'm in the upper-right part of the unit circle
|
|
// i must move vertex n-1
|
|
_vertices[n-1]->setPoint2d(_vertices[n]->point2d()-userDir*(h));
|
|
//_vertices[n-1]->setPoint2d(_vertices[n-1]->point2d()+t*x);
|
|
//_vertices[n]->setPoint2d(_vertices[n]->point2d()-t*x);
|
|
}else{
|
|
//i'm in the upper-left part of the unit circle
|
|
// i must move vertex n
|
|
_vertices[n]->setPoint2d(_vertices[n-1]->point2d()+userDir*(h));
|
|
//_vertices[n-1]->setPoint2d(_vertices[n-1]->point2d()-t*x);
|
|
//_vertices[n]->setPoint2d(_vertices[n]->point2d()+t*x);
|
|
}
|
|
}else{
|
|
//i'm in the lower part of the unit circle
|
|
if(dp2>0){
|
|
//i'm in the lower-right part of the unit circle
|
|
// i must move vertex n
|
|
_vertices[n]->setPoint2d(_vertices[n-1]->point2d()-userDir*(h));
|
|
//_vertices[n-1]->setPoint2d(_vertices[n-1]->point2d()-t*x);
|
|
//_vertices[n]->setPoint2d(_vertices[n]->point2d()+t*x);
|
|
}else{
|
|
//i'm in the lower-left part of the unit circle
|
|
// i must move vertex n-1
|
|
_vertices[n-1]->setPoint2d(_vertices[n]->point2d()+userDir*(h));
|
|
//_vertices[n-1]->setPoint2d(_vertices[n-1]->point2d()+t*x);
|
|
//_vertices[n]->setPoint2d(_vertices[n]->point2d()-t*x);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// check whether the orientation of the extremity
|
|
// was user defined
|
|
// userDir = _stroke->getEndingOrientation();
|
|
// if(userDir != Vec2r(0,0)){
|
|
// userDir.normalize();
|
|
// real o1 = (orthDir*userDir);
|
|
// real o2 = crossP(orthDir,userDir);
|
|
// real orientation = o1 * o2;
|
|
// if(orientation > 0){
|
|
// // then the vertex to move is vn
|
|
// if(o1 < 0)
|
|
// _vertex[n]=_vertex[n-1]+userDir;
|
|
// else
|
|
// _vertex[n]=_vertex[n-1]-userDir;
|
|
// }
|
|
// if(orientation < 0){
|
|
// // then we must move vn-1
|
|
// if(o1 > 0)
|
|
// _vertex[n-1]=_vertex[n]+userDir;
|
|
// else
|
|
// _vertex[n-1]=_vertex[n]-userDir;
|
|
// }
|
|
// }
|
|
|
|
_averageThickness/=float(iStrokeVertices.size()-2);
|
|
//I did not use the first and last vertex for the average
|
|
if (iStrokeVertices.size()<3)
|
|
_averageThickness=0.5*(thicknessLast[1]+thicknessLast[0]+thickness[0]+thickness[1]);
|
|
|
|
if (i!=2*iStrokeVertices.size())
|
|
cerr << "Warning: problem with stripe size\n";
|
|
|
|
cleanUpSingularities (iStrokeVertices);
|
|
}
|
|
|
|
// CLEAN UP
|
|
/////////////////////////
|
|
|
|
void
|
|
Strip::cleanUpSingularities (const vector<StrokeVertex*>& iStrokeVertices)
|
|
{
|
|
int k;
|
|
unsigned sizeStrip = _vertices.size();
|
|
|
|
for (k=0; k<sizeStrip; k++)
|
|
if (notValid(_vertices[k]->point2d()))
|
|
{
|
|
cerr << "Warning: strip vertex " << k << " non valid" << endl;
|
|
return;
|
|
}
|
|
|
|
//return;
|
|
if (iStrokeVertices.size()<2) return;
|
|
int i=0, j;
|
|
vector<StrokeVertex*>::const_iterator v ,vend, v2, vPrev;
|
|
StrokeVertex *sv, *sv2, *svPrev;
|
|
|
|
bool singu1=false, singu2=false;
|
|
int timeSinceSingu1=0, timeSinceSingu2=0;
|
|
|
|
//special case of first vertex
|
|
v=iStrokeVertices.begin();
|
|
for(vend=iStrokeVertices.end();
|
|
v!=vend;
|
|
v++)
|
|
{
|
|
v2=v; ++v2;
|
|
if (v2==vend) break;
|
|
sv= (*v); sv2 = (*v2);
|
|
Vec2r p(sv->getPoint()), p2(sv2->getPoint());
|
|
|
|
Vec2r dir(p2-p);
|
|
if (dir.norm() > ZERO)
|
|
dir.normalize();
|
|
Vec2r dir1, dir2;
|
|
dir1=_vertices[2*i+2]->point2d()-_vertices[2*i]->point2d();
|
|
dir2=_vertices[2*i+3]->point2d()-_vertices[2*i+1]->point2d();
|
|
|
|
if ((dir1 * dir) < -ZERO)
|
|
{
|
|
singu1=true;
|
|
timeSinceSingu1++;
|
|
}
|
|
else
|
|
{
|
|
if (singu1)
|
|
{
|
|
int toto=i-timeSinceSingu1;
|
|
if (toto<0)
|
|
cerr << "Stephane dit \"Toto\"" << endl;
|
|
//traverse all the vertices of the singularity and average them
|
|
Vec2r avP(0.0,0.0);
|
|
for (j=i-timeSinceSingu1; j<i+1; j++)
|
|
avP=Vec2r(avP+_vertices[2*j]->point2d());
|
|
avP=Vec2r(1.0/float(timeSinceSingu1+1)*avP);
|
|
for (j=i-timeSinceSingu1; j<i+1; j++)
|
|
_vertices[2*j]->setPoint2d(avP);
|
|
//_vertex[2*j]=_vertex[2*i];
|
|
singu1=false; timeSinceSingu1=0;
|
|
}
|
|
}
|
|
if ((dir2 * dir) < -ZERO)
|
|
{
|
|
singu2=true;
|
|
timeSinceSingu2++;
|
|
}
|
|
else
|
|
{
|
|
if (singu2)
|
|
{
|
|
int toto=i-timeSinceSingu2;
|
|
if (toto<0)
|
|
cerr << "Stephane dit \"Toto\"" << endl;
|
|
//traverse all the vertices of the singularity and average them
|
|
Vec2r avP(0.0,0.0);
|
|
for (j=i-timeSinceSingu2; j<i+1; j++)
|
|
avP=Vec2r(avP+_vertices[2*j+1]->point2d());
|
|
avP=Vec2r(1.0/float(timeSinceSingu2+1)*avP);
|
|
for (j=i-timeSinceSingu2; j<i+1; j++)
|
|
_vertices[2*j+1]->setPoint2d(avP);
|
|
//_vertex[2*j+1]=_vertex[2*i+1];
|
|
singu2=false; timeSinceSingu2=0;
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
|
|
if (singu1)
|
|
{
|
|
//traverse all the vertices of the singularity and average them
|
|
Vec2r avP(0.0,0.0);
|
|
for (int j=i-timeSinceSingu1; j<i; j++)
|
|
avP=Vec2r(avP+_vertices[2*j]->point2d());
|
|
avP=Vec2r(1.0/float(timeSinceSingu1)*avP);
|
|
for (j=i-timeSinceSingu1; j<i; j++)
|
|
_vertices[2*j]->setPoint2d(avP);
|
|
}
|
|
if (singu2)
|
|
{
|
|
//traverse all the vertices of the singularity and average them
|
|
Vec2r avP(0.0,0.0);
|
|
for (j=i-timeSinceSingu2; j<i; j++)
|
|
avP=Vec2r(avP+_vertices[2*j+1]->point2d());
|
|
avP=Vec2r(1.0/float(timeSinceSingu2)*avP);
|
|
for (j=i-timeSinceSingu2; j<i; j++)
|
|
_vertices[2*j+1]->setPoint2d(avP);
|
|
}
|
|
|
|
|
|
for (k=0; k<sizeStrip; k++)
|
|
if (notValid(_vertices[k]->point2d()))
|
|
{
|
|
cerr << "Warning: strip vertex " << k << " non valid after cleanup"<<endl;
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
// Texture coordinates
|
|
////////////////////////////////
|
|
|
|
void
|
|
Strip::computeTexCoord (const vector<StrokeVertex*>& iStrokeVertices)
|
|
{
|
|
vector<StrokeVertex*>::const_iterator v ,vend;
|
|
StrokeVertex *sv;
|
|
int i=0;
|
|
for(v=iStrokeVertices.begin(), vend=iStrokeVertices.end();
|
|
v!=vend; v++)
|
|
{
|
|
sv= (*v);
|
|
_vertices[i]->setTexCoord(Vec2r((real)(sv->curvilinearAbscissa() / _averageThickness),0));
|
|
_vertices[i]->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
|
|
_vertices[i]->setAlpha(sv->attribute().getAlpha());
|
|
i++;
|
|
_vertices[i]->setTexCoord(Vec2r((real)(sv->curvilinearAbscissa() / _averageThickness),1));
|
|
_vertices[i]->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
|
|
_vertices[i]->setAlpha(sv->attribute().getAlpha());
|
|
i++;
|
|
// cerr<<"col=("<<sv->attribute().getColor()[0]<<", "
|
|
// <<sv->attribute().getColor()[1]<<", "<<sv->attribute().getColor()[2]<<")"<<endl;
|
|
}
|
|
}
|
|
|
|
void
|
|
Strip::computeTexCoordWithTips (const vector<StrokeVertex*>& iStrokeVertices, bool tipBegin, bool tipEnd)
|
|
{
|
|
unsigned int sizeStrip = _vertices.size()+8; //for the transition between the tip and the body
|
|
vector<StrokeVertex*>::const_iterator v ,vend;
|
|
StrokeVertex *sv;
|
|
|
|
v=iStrokeVertices.begin();
|
|
vend=iStrokeVertices.end();
|
|
float l=(*v)->strokeLength()/_averageThickness;
|
|
int tiles=int(l);
|
|
float fact=(float(tiles)+0.5)/l;
|
|
float uTip2=float(tiles)+0.25;
|
|
float u=0;
|
|
float uPrev;
|
|
int i=0;
|
|
float t;
|
|
StrokeVertexRep *tvRep1, *tvRep2;
|
|
|
|
// cerr<<"l="<<l<<" tiles="<<tiles<<" _averageThicnkess="
|
|
// <<_averageThickness<<" strokeLength="<<(*v)->strokeLength()<<endl;
|
|
//
|
|
vector<StrokeVertexRep*>::iterator currentSV = _vertices.begin();
|
|
StrokeVertexRep *svRep;
|
|
if(tipBegin){
|
|
for(;v!=vend; v++)
|
|
{
|
|
sv= (*v);
|
|
svRep = *currentSV;
|
|
u=sv->curvilinearAbscissa()/_averageThickness*fact;
|
|
if (u>0.25) break;
|
|
|
|
|
|
svRep->setTexCoord(Vec2r((real)u, 0.5));
|
|
svRep->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
|
|
svRep->setAlpha(sv->attribute().getAlpha());
|
|
i++;
|
|
++currentSV;
|
|
|
|
svRep = *currentSV;
|
|
svRep->setTexCoord(Vec2r((real)u, 1));
|
|
svRep->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
|
|
svRep->setAlpha(sv->attribute().getAlpha());
|
|
i++;
|
|
++currentSV;
|
|
uPrev=u;
|
|
}
|
|
//first transition vertex
|
|
|
|
if (fabs(u-uPrev)>ZERO)
|
|
t= (0.25-uPrev)/(u-uPrev);
|
|
else t=0;
|
|
//if (!tiles) t=0.5;
|
|
tvRep1 = new StrokeVertexRep(Vec2r((1-t)*_vertices[i-2]->point2d()+t*_vertices[i]->point2d()));
|
|
tvRep1->setTexCoord(Vec2r(0.25,0.5));
|
|
tvRep1->setColor(Vec3r((1-t)*_vertices[i-2]->color()+
|
|
t*Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2])));
|
|
tvRep1->setAlpha((1-t)*_vertices[i-2]->alpha()+t*sv->attribute().getAlpha());
|
|
i++;
|
|
|
|
tvRep2 = new StrokeVertexRep(Vec2r((1-t)*_vertices[i-2]->point2d()+t*_vertices[i]->point2d()));
|
|
tvRep2->setTexCoord(Vec2r(0.25,1));
|
|
tvRep2->setColor(Vec3r((1-t)*_vertices[i-2]->color()+
|
|
t*Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2])));
|
|
tvRep2->setAlpha((1-t)*_vertices[i-2]->alpha()+t*sv->attribute().getAlpha());
|
|
i++;
|
|
|
|
currentSV = _vertices.insert(currentSV, tvRep1);
|
|
++currentSV;
|
|
currentSV = _vertices.insert(currentSV, tvRep2);
|
|
++currentSV;
|
|
|
|
//copy the vertices with different texture coordinates
|
|
tvRep1 = new StrokeVertexRep(_vertices[i-2]->point2d());
|
|
tvRep1->setTexCoord(Vec2r(0.25,0));
|
|
tvRep1->setColor(_vertices[i-2]->color());
|
|
tvRep1->setAlpha(_vertices[i-2]->alpha());
|
|
i++;
|
|
|
|
tvRep2 = new StrokeVertexRep(_vertices[i-2]->point2d());
|
|
tvRep2->setTexCoord(Vec2r(0.25,0.5));
|
|
tvRep2->setColor(_vertices[i-2]->color());
|
|
tvRep2->setAlpha(_vertices[i-2]->alpha());
|
|
i++;
|
|
|
|
currentSV = _vertices.insert(currentSV, tvRep1);
|
|
++currentSV;
|
|
currentSV = _vertices.insert(currentSV, tvRep2);
|
|
++currentSV;
|
|
}
|
|
uPrev=0;
|
|
|
|
//body of the stroke
|
|
for(;v!=vend; v++)
|
|
{
|
|
sv= (*v);
|
|
svRep = *currentSV;
|
|
u=sv->curvilinearAbscissa()/_averageThickness*fact-0.25;
|
|
if (u>tiles) break;
|
|
|
|
svRep->setTexCoord(Vec2r((real)u, 0));
|
|
svRep->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
|
|
svRep->setAlpha(sv->attribute().getAlpha());
|
|
i++;
|
|
++currentSV;
|
|
|
|
svRep = *currentSV;
|
|
svRep->setTexCoord(Vec2r((real)u, 0.5));
|
|
svRep->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
|
|
svRep->setAlpha(sv->attribute().getAlpha());
|
|
i++;
|
|
++currentSV;
|
|
|
|
uPrev=u;
|
|
}
|
|
if(tipEnd){
|
|
//second transition vertex
|
|
if ((fabs(u-uPrev)>ZERO))
|
|
t= (float(tiles)-uPrev)/(u-uPrev);
|
|
else t=0;
|
|
|
|
tvRep1 = new StrokeVertexRep(Vec2r((1-t)*_vertices[i-2]->point2d()+t*_vertices[i]->point2d()));
|
|
tvRep1->setTexCoord(Vec2r((real)tiles,0));
|
|
tvRep1->setColor(Vec3r((1-t)*_vertices[i-2]->color()+
|
|
t*Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2])));
|
|
tvRep1->setAlpha((1-t)*_vertices[i-2]->alpha()+t*sv->attribute().getAlpha());
|
|
i++;
|
|
|
|
tvRep2 = new StrokeVertexRep(Vec2r((1-t)*_vertices[i-2]->point2d()+t*_vertices[i]->point2d()));
|
|
tvRep2->setTexCoord(Vec2r((real)tiles,0.5));
|
|
tvRep2->setColor(Vec3r((1-t)*_vertices[i-2]->color()+
|
|
t*Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2])));
|
|
tvRep2->setAlpha((1-t)*_vertices[i-2]->alpha()+t*sv->attribute().getAlpha());
|
|
i++;
|
|
|
|
currentSV = _vertices.insert(currentSV, tvRep1);
|
|
++currentSV;
|
|
currentSV = _vertices.insert(currentSV, tvRep2);
|
|
++currentSV;
|
|
|
|
//copy the vertices with different texture coordinates
|
|
tvRep1 = new StrokeVertexRep(_vertices[i-2]->point2d());
|
|
tvRep1->setTexCoord(Vec2r(0.75,0.5));
|
|
tvRep1->setColor(_vertices[i-2]->color());
|
|
tvRep1->setAlpha(_vertices[i-2]->alpha());
|
|
i++;
|
|
|
|
tvRep2 = new StrokeVertexRep(_vertices[i-2]->point2d());
|
|
tvRep2->setTexCoord(Vec2r(0.75,1));
|
|
tvRep2->setColor(_vertices[i-2]->color());
|
|
tvRep2->setAlpha(_vertices[i-2]->alpha());
|
|
i++;
|
|
|
|
currentSV = _vertices.insert(currentSV, tvRep1);
|
|
++currentSV;
|
|
currentSV = _vertices.insert(currentSV, tvRep2);
|
|
++currentSV;
|
|
|
|
//end tip
|
|
for(;v!=vend; v++)
|
|
{
|
|
sv= (*v);
|
|
svRep = *currentSV;
|
|
u=0.75+sv->curvilinearAbscissa()/_averageThickness*fact-float(tiles)-0.25;
|
|
|
|
svRep->setTexCoord(Vec2r((real)u, 0.5));
|
|
svRep->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
|
|
svRep->setAlpha(sv->attribute().getAlpha());
|
|
i++;
|
|
++currentSV;
|
|
|
|
svRep = *currentSV;
|
|
svRep->setTexCoord(Vec2r((real)u, 1));
|
|
svRep->setColor(Vec3r(sv->attribute().getColor()[0],sv->attribute().getColor()[1],sv->attribute().getColor()[2]));
|
|
svRep->setAlpha(sv->attribute().getAlpha());
|
|
i++;
|
|
++currentSV;
|
|
}
|
|
}
|
|
//cerr<<"u="<<u<<" i="<<i<<"/"<<_sizeStrip<<endl;;
|
|
|
|
// for (i=0; i<_sizeStrip; i++)
|
|
// _alpha[i]=1.0;
|
|
|
|
// for (i=0; i<_sizeStrip; i++)
|
|
// cerr<<"("<<_texCoord[i][0]<<", "<<_texCoord[i][1]<<") ";
|
|
// cerr<<endl;
|
|
|
|
|
|
// Vec2r vec_tmp;
|
|
// for (i=0; i<_sizeStrip/2; i++)
|
|
// vec_tmp = _vertex[2*i] - _vertex[2*i+1];
|
|
// if (vec_tmp.norm() > 4*_averageThickness)
|
|
// cerr << "Warning (from Fredo): There is a pb in the texture coordinates computation" << endl;
|
|
}
|
|
|
|
//
|
|
// StrokeRep
|
|
/////////////////////////////////////
|
|
|
|
StrokeRep::StrokeRep()
|
|
{
|
|
_stroke = 0;
|
|
_strokeType=Stroke::OPAQUE_MEDIUM;
|
|
TextureManager * ptm = TextureManager::getInstance();
|
|
if(ptm)
|
|
_textureId = ptm->getDefaultTextureId();
|
|
// _averageTextureAlpha=0.5; //default value
|
|
// if (_strokeType==OIL_STROKE)
|
|
// _averageTextureAlpha=0.75;
|
|
// if (_strokeType>=NO_BLEND_STROKE)
|
|
// _averageTextureAlpha=1.0
|
|
}
|
|
|
|
StrokeRep::StrokeRep(Stroke *iStroke)
|
|
{
|
|
_stroke = iStroke;
|
|
_strokeType = iStroke->getMediumType();
|
|
_textureId = iStroke->getTextureId();
|
|
if(_textureId == 0){
|
|
TextureManager * ptm = TextureManager::getInstance();
|
|
if(ptm)
|
|
_textureId = ptm->getDefaultTextureId();
|
|
}
|
|
|
|
// _averageTextureAlpha=0.5; //default value
|
|
// if (_strokeType==OIL_STROKE)
|
|
// _averageTextureAlpha=0.75;
|
|
// if (_strokeType>=NO_BLEND_STROKE)
|
|
// _averageTextureAlpha=1.0;
|
|
create();
|
|
}
|
|
|
|
StrokeRep::StrokeRep(const StrokeRep& iBrother)
|
|
{
|
|
int i=0;
|
|
_stroke = iBrother._stroke;
|
|
_strokeType=iBrother._strokeType;
|
|
_textureId = iBrother._textureId;
|
|
for(vector<Strip*>::const_iterator s=iBrother._strips.begin(), send=iBrother._strips.end();
|
|
s!=send;
|
|
++s){
|
|
_strips.push_back(new Strip(**s));
|
|
}
|
|
}
|
|
|
|
|
|
StrokeRep::~StrokeRep()
|
|
{
|
|
if(!_strips.empty()){
|
|
for(vector<Strip*>::iterator s=_strips.begin(), send=_strips.end();
|
|
s!=send;
|
|
++s){
|
|
delete (*s);
|
|
}
|
|
_strips.clear();
|
|
}
|
|
}
|
|
|
|
void StrokeRep::create(){
|
|
vector<StrokeVertex*> strip;
|
|
StrokeInternal::StrokeVertexIterator v = _stroke->strokeVerticesBegin();
|
|
StrokeInternal::StrokeVertexIterator vend = _stroke->strokeVerticesEnd();
|
|
|
|
bool first=true;
|
|
bool end=false;
|
|
while(v!=vend){
|
|
while((v!=vend) && (!(*v).attribute().isVisible())){
|
|
++v;
|
|
first = false;
|
|
}
|
|
while( (v!=vend) && ((*v).attribute().isVisible()) ) {
|
|
strip.push_back(&(*v));
|
|
++v;
|
|
}
|
|
if(v!=vend){
|
|
// add the last vertex and create
|
|
strip.push_back(&(*v));
|
|
}else{
|
|
end=true;
|
|
}
|
|
if((!strip.empty()) && (strip.size()>1) ){
|
|
_strips.push_back(new Strip(strip, _stroke->hasTips(), first, end));
|
|
strip.clear();
|
|
}
|
|
first = false;
|
|
}
|
|
}
|
|
|
|
void StrokeRep::Render(const StrokeRenderer *iRenderer)
|
|
{
|
|
iRenderer->RenderStrokeRep(this);
|
|
}
|
|
|
|
|
|
|