4639 lines
130 KiB
C++
4639 lines
130 KiB
C++
|
|
|
|
// TnzCore includes
|
|
#include "tcolorfunctions.h"
|
|
#include "trandom.h"
|
|
#include "tcurves.h"
|
|
#include "tvectorrenderdata.h"
|
|
#include "tmathutil.h"
|
|
#include "colorfxutils.h"
|
|
#include "tpixelutils.h"
|
|
#include "tconvert.h"
|
|
|
|
// tcg includes
|
|
#include "tcg/tcg_misc.h"
|
|
|
|
// Qt includes
|
|
#include <QCoreApplication>
|
|
#include <QStringList>
|
|
|
|
#include "strokestyles.h"
|
|
|
|
using namespace std;
|
|
|
|
#define MINTHICK 1.0
|
|
|
|
//=============================================================================
|
|
|
|
namespace {
|
|
|
|
template <class T>
|
|
class TOptimizedStrokePropT final : public TStrokeProp {
|
|
protected:
|
|
double m_pixelSize;
|
|
|
|
TOptimizedStrokeStyleT<T> *m_colorStyle;
|
|
T m_data;
|
|
|
|
public:
|
|
TOptimizedStrokePropT(const TStroke *stroke,
|
|
TOptimizedStrokeStyleT<T> *style);
|
|
~TOptimizedStrokePropT() { m_colorStyle->release(); }
|
|
|
|
const TColorStyle *getColorStyle() const override;
|
|
|
|
TStrokeProp *clone(const TStroke *stroke) const override;
|
|
void draw(const TVectorRenderData &rd) override;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
TOptimizedStrokePropT<T>::TOptimizedStrokePropT(
|
|
const TStroke *stroke, TOptimizedStrokeStyleT<T> *style)
|
|
: TStrokeProp(stroke), m_colorStyle(style), m_pixelSize(0) {
|
|
m_styleVersionNumber = style->getVersionNumber();
|
|
m_colorStyle->addRef();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
const TColorStyle *TOptimizedStrokePropT<T>::getColorStyle() const {
|
|
return m_colorStyle;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
TStrokeProp *TOptimizedStrokePropT<T>::clone(const TStroke *stroke) const {
|
|
TOptimizedStrokePropT<T> *prop =
|
|
new TOptimizedStrokePropT<T>(stroke, m_colorStyle);
|
|
prop->m_strokeChanged = m_strokeChanged;
|
|
prop->m_data = m_data;
|
|
return prop;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
void TOptimizedStrokePropT<T>::draw(
|
|
const TVectorRenderData
|
|
&rd) /*assenza di const non e' una dimenticanza! Alcune sottoclassi
|
|
devono ridefinire questo metodo e serbve che non sia const*/
|
|
{
|
|
if (rd.m_clippingRect != TRect() && !rd.m_is3dView &&
|
|
!convert(rd.m_aff * m_stroke->getBBox()).overlaps(rd.m_clippingRect))
|
|
return;
|
|
|
|
glPushMatrix();
|
|
tglMultMatrix(rd.m_aff);
|
|
|
|
double pixelSize = sqrt(tglGetPixelSize2());
|
|
if (m_strokeChanged ||
|
|
m_styleVersionNumber != m_colorStyle->getVersionNumber() ||
|
|
!isAlmostZero(pixelSize - m_pixelSize, 1e-5)) {
|
|
m_strokeChanged = false;
|
|
m_pixelSize = pixelSize;
|
|
m_styleVersionNumber = m_colorStyle->getVersionNumber();
|
|
m_colorStyle->computeData(m_data, m_stroke, rd.m_cf);
|
|
}
|
|
|
|
m_colorStyle->drawStroke(rd.m_cf, m_data, m_stroke);
|
|
|
|
glPopMatrix();
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
template <class T>
|
|
TStrokeProp *TOptimizedStrokeStyleT<T>::makeStrokeProp(const TStroke *stroke) {
|
|
return new TOptimizedStrokePropT<T>(stroke, this);
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
inline void tglNormal(const T3DPointD &p) { glNormal3d(p.x, p.y, p.z); }
|
|
|
|
inline void tglVertex(const T3DPointD &p) { glVertex3d(p.x, p.y, p.z); }
|
|
|
|
//=============================================================================
|
|
|
|
TFurStrokeStyle::TFurStrokeStyle()
|
|
: m_color(TPixel32::Black)
|
|
, m_angle(120.0)
|
|
, m_length(1.0)
|
|
, m_cs(0.0)
|
|
, m_sn(0.0) {
|
|
double rad = m_angle * M_PI_180;
|
|
m_cs = cos(rad);
|
|
m_sn = sin(rad);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TFurStrokeStyle::clone() const {
|
|
return new TFurStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TFurStrokeStyle::getParamCount() const { return 2; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TFurStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TFurStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return index == 0 ? QCoreApplication::translate("TFurStrokeStyle", "Angle")
|
|
: QCoreApplication::translate("TFurStrokeStyle", "Size");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TFurStrokeStyle::getParamRange(int index, double &min, double &max) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
if (index == 0) {
|
|
min = 0.0;
|
|
max = 180.0;
|
|
} else {
|
|
min = 0.0;
|
|
max = 1.0;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TFurStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return index == 0 ? m_angle : m_length;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TFurStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < getParamCount());
|
|
if (index == 0) {
|
|
m_angle = value;
|
|
double rad = m_angle * M_PI_180;
|
|
m_cs = cos(rad);
|
|
m_sn = sin(rad);
|
|
} else
|
|
m_length = value;
|
|
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void TFurStrokeStyle::computeData(Points &positions, const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
double length = stroke->getLength();
|
|
|
|
double s = 0.0;
|
|
double ds = 4;
|
|
double vs = 1;
|
|
TRandom rnd;
|
|
|
|
positions.clear();
|
|
positions.reserve(tceil(length / ds) + 1);
|
|
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
TPointD u = stroke->getSpeed(w);
|
|
if (norm2(u) == 0.0) {
|
|
s += 0.5;
|
|
continue;
|
|
}
|
|
u = normalize(u);
|
|
TPointD v = rotate90(u);
|
|
|
|
double length = 0;
|
|
if (pos.thick)
|
|
length = m_length * pos.thick;
|
|
else
|
|
length = 1.0;
|
|
|
|
vs = -vs;
|
|
|
|
positions.push_back(pos);
|
|
double q = 0.01 * (rnd.getFloat() * 2 - 1);
|
|
positions.push_back(pos + length * ((m_cs + q) * u + (vs * m_sn) * v));
|
|
|
|
s += ds;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void TFurStrokeStyle::drawStroke(const TColorFunction *cf, Points &positions,
|
|
const TStroke *stroke) const {
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
|
|
tglColor(color);
|
|
|
|
for (UINT i = 0; i < positions.size(); i += 2) {
|
|
glBegin(GL_LINE_STRIP);
|
|
tglColor(color);
|
|
tglVertex(positions[i]);
|
|
glColor4d(1, 1, 1, 0.0);
|
|
tglVertex(positions[i + 1]);
|
|
glEnd();
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TChainStrokeStyle::TChainStrokeStyle(const TPixel32 &color) : m_color(color) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TChainStrokeStyle::TChainStrokeStyle() : m_color(TPixel32(20, 10, 0)) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TChainStrokeStyle::clone() const {
|
|
return new TChainStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TChainStrokeStyle::computeData(Points &data, const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
// TStroke *stroke = getStroke();
|
|
double length = stroke->getLength();
|
|
|
|
// spessore della catena = spessore "medio" dello stroke
|
|
double thickness =
|
|
0.25 *
|
|
(stroke->getThickPoint(0).thick + stroke->getThickPoint(1.0 / 3.0).thick +
|
|
stroke->getThickPoint(2.0 / 3.0).thick + stroke->getThickPoint(1).thick);
|
|
|
|
if (thickness == 0) thickness = 0.1;
|
|
double ringHeight = thickness;
|
|
double ringWidth = 1.5 * ringHeight;
|
|
|
|
// distanza fra i centri degli anelli
|
|
double ringDistance = 2 * 1.2 * ringWidth;
|
|
|
|
// distanza fra il centro dell'anello e il punto di attacco dell'anello
|
|
// trasversale
|
|
// double joinPos = 0.45 * ringWidth;
|
|
|
|
TPointD oldPos;
|
|
// bool firstRing = true;
|
|
double s = 0;
|
|
|
|
data.clear();
|
|
data.reserve(tceil(length / ringDistance) * 2 + 2);
|
|
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
// if(w<0) {s+=0.1; continue;} // per tamponare il baco della
|
|
// getParameterAtLength()
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
TPointD u = stroke->getSpeed(w);
|
|
if (norm2(u) == 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // non dovrebbe succedere mai, ma per prudenza....
|
|
u = normalize(u);
|
|
|
|
data.push_back(pos);
|
|
data.push_back(u);
|
|
|
|
// se e' il caso unisco la catena alla precedente
|
|
s += ringDistance;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TChainStrokeStyle::drawStroke(const TColorFunction *cf, Points &data,
|
|
const TStroke *stroke) const {
|
|
// TStroke *stroke = getStroke();
|
|
// double length = stroke->getLength();
|
|
|
|
// spessore della catena = spessore "medio" dello stroke
|
|
double thickness =
|
|
0.25 *
|
|
(stroke->getThickPoint(0).thick + stroke->getThickPoint(1.0 / 3.0).thick +
|
|
stroke->getThickPoint(2.0 / 3.0).thick + stroke->getThickPoint(1).thick);
|
|
|
|
if (thickness * thickness < 4 * tglGetPixelSize2()) {
|
|
TCenterLineStrokeStyle *appStyle =
|
|
new TCenterLineStrokeStyle(m_color, 0x0, thickness);
|
|
appStyle->drawStroke(cf, stroke);
|
|
delete appStyle;
|
|
return;
|
|
}
|
|
|
|
assert(thickness);
|
|
double ringHeight = thickness;
|
|
double ringWidth = 1.5 * ringHeight;
|
|
|
|
// distanza fra i centri degli anelli
|
|
// double ringDistance = 2 * 1.2 * ringWidth;
|
|
|
|
// distanza fra il centro dell'anello e il punto di attacco dell'anello
|
|
// trasversale
|
|
double joinPos = 0.45 * ringWidth;
|
|
|
|
// definisco la forma dell'anello della catena
|
|
GLuint ringId;
|
|
ringId = glGenLists(1);
|
|
double a = .6, b = .6;
|
|
glNewList(ringId, GL_COMPILE);
|
|
glPushMatrix();
|
|
glScaled(ringWidth, ringHeight, 1);
|
|
glBegin(GL_LINE_STRIP);
|
|
glVertex2d(1, b);
|
|
glVertex2d(a, 1);
|
|
glVertex2d(-a, 1);
|
|
glVertex2d(-1, b);
|
|
glVertex2d(-1, -b);
|
|
glVertex2d(-a, -1);
|
|
glVertex2d(a, -1);
|
|
glVertex2d(1, -b);
|
|
glVertex2d(1, b);
|
|
glEnd();
|
|
glPopMatrix();
|
|
glEndList();
|
|
|
|
// disegno la catena
|
|
|
|
if (cf)
|
|
tglColor((*cf)(m_color));
|
|
else
|
|
tglColor(m_color);
|
|
|
|
TPointD oldPos;
|
|
// bool firstRing = true;
|
|
// double s = 0;
|
|
for (UINT i = 0; i < data.size(); i += 2) {
|
|
TPointD pos = data[i];
|
|
TPointD u = data[i + 1];
|
|
TPointD v = rotate90(u);
|
|
|
|
// disegno un anello della catena
|
|
glPushMatrix();
|
|
TAffine aff(u.x, v.x, pos.x, u.y, v.y, pos.y);
|
|
tglMultMatrix(aff);
|
|
glCallList(ringId);
|
|
glPopMatrix();
|
|
|
|
// se e' il caso unisco la catena alla precedente
|
|
if (i != 0) {
|
|
TPointD q = pos - u * joinPos;
|
|
tglDrawSegment(oldPos, q);
|
|
}
|
|
|
|
oldPos = pos + u * joinPos;
|
|
}
|
|
|
|
glDeleteLists(ringId, 1);
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TSprayStrokeStyle::TSprayStrokeStyle()
|
|
: m_color(TPixel32::Blue), m_blend(0.5), m_intensity(10.0), m_radius(0.3) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TSprayStrokeStyle::clone() const {
|
|
return new TSprayStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TSprayStrokeStyle::getParamCount() const { return 3; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TSprayStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TSprayStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 3);
|
|
QString value;
|
|
switch (index) {
|
|
case 0:
|
|
value = QCoreApplication::translate("TSprayStrokeStyle", "Border Fade");
|
|
break;
|
|
case 1:
|
|
value = QCoreApplication::translate("TSprayStrokeStyle", "Density");
|
|
break;
|
|
case 2:
|
|
value = QCoreApplication::translate("TSprayStrokeStyle", "Size");
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSprayStrokeStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 3);
|
|
switch (index) {
|
|
case 0:
|
|
min = 0.0;
|
|
max = 1.0;
|
|
break;
|
|
case 1:
|
|
min = 0.0;
|
|
max = 100.0;
|
|
break;
|
|
case 2:
|
|
min = 0.0;
|
|
max = 1.0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TSprayStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 3);
|
|
double value = 0;
|
|
switch (index) {
|
|
case 0:
|
|
value = m_blend;
|
|
break;
|
|
case 1:
|
|
value = m_intensity;
|
|
break;
|
|
case 2:
|
|
value = m_radius;
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSprayStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 3);
|
|
switch (index) {
|
|
case 0:
|
|
m_blend = value;
|
|
break;
|
|
case 1:
|
|
m_intensity = value;
|
|
break;
|
|
case 2:
|
|
m_radius = value;
|
|
break;
|
|
}
|
|
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSprayStrokeStyle::drawStroke(const TColorFunction *cf,
|
|
const TStroke *stroke) const {
|
|
// TStroke *stroke = getStroke();
|
|
double length = stroke->getLength();
|
|
double step = 4;
|
|
|
|
double blend = m_blend; // distanza che controlla da dove il gessetto
|
|
// comincia il fade out (0, 1)
|
|
double intensity = m_intensity; // quanti punti vengono disegnati ad ogni
|
|
// step
|
|
double radius = m_radius;
|
|
double decay = 1 - blend;
|
|
bool fill = 0;
|
|
TPointD pos1;
|
|
TRandom rnd;
|
|
TPixelD dcolor;
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
dcolor = toPixelD(color);
|
|
double s = 0;
|
|
double minthickness = MINTHICK * sqrt(tglGetPixelSize2());
|
|
double thickness = 0;
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
// if(w<0) {s+=0.1; continue;} // per tamponare il baco della
|
|
// getParameterAtLength()
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
TPointD u = stroke->getSpeed(w);
|
|
double normu = norm2(u);
|
|
if (normu == 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // non dovrebbe succedere mai, ma per prudenza....
|
|
u = normalize(u);
|
|
TPointD v = rotate90(u);
|
|
TPointD shift;
|
|
if (pos.thick < MINTHICK)
|
|
thickness = minthickness;
|
|
else
|
|
thickness = pos.thick;
|
|
for (int i = 0; i < intensity; i++) {
|
|
double vrandnorm = (0.5 - rnd.getFloat()) * 2;
|
|
double randomv = vrandnorm * pos.thick;
|
|
double randomu = (0.5 - rnd.getFloat()) * step;
|
|
shift = u * randomu + v * randomv;
|
|
pos1 = pos + shift;
|
|
double mod = fabs(vrandnorm);
|
|
if (mod < decay)
|
|
glColor4d(dcolor.r, dcolor.g, dcolor.b, rnd.getFloat() * dcolor.m);
|
|
else
|
|
glColor4d(dcolor.r, dcolor.g, dcolor.b,
|
|
rnd.getFloat() * (1 - mod) * dcolor.m);
|
|
if (fill)
|
|
tglDrawDisk(pos1, radius * thickness * rnd.getFloat());
|
|
else
|
|
tglDrawCircle(pos1, radius * thickness * rnd.getFloat());
|
|
}
|
|
s += step;
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TGraphicPenStrokeStyle::TGraphicPenStrokeStyle()
|
|
: m_color(TPixel32::Black), m_intensity(10.0) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TGraphicPenStrokeStyle::clone() const {
|
|
return new TGraphicPenStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TGraphicPenStrokeStyle::getParamCount() const { return 1; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TGraphicPenStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TGraphicPenStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 1);
|
|
|
|
return QCoreApplication::translate("TGraphicPenStrokeStyle", "Density");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TGraphicPenStrokeStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 1);
|
|
min = 0.0;
|
|
max = 10.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TGraphicPenStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 1);
|
|
return m_intensity;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TGraphicPenStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 1);
|
|
m_intensity = value;
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TGraphicPenStrokeStyle::computeData(DrawmodePointsMatrix &data,
|
|
const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
data.clear();
|
|
double length = stroke->getLength();
|
|
double step = 10;
|
|
TPointD pos1, pos2;
|
|
TRandom rnd;
|
|
double intensity = m_intensity;
|
|
data.reserve(tceil(length / 10.0));
|
|
double s = 0;
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
// if(w<0) {s+=0.1; continue;} // per tamponare il baco della
|
|
// getParameterAtLength()
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
TPointD u = stroke->getSpeed(w);
|
|
double normu = norm2(u);
|
|
if (normu == 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // non dovrebbe succedere mai, ma per prudenza....
|
|
u = normalize(u);
|
|
TPointD v = rotate90(u);
|
|
TPointD shift;
|
|
Points tmpPoints;
|
|
tmpPoints.clear();
|
|
GLenum drawMode;
|
|
for (int i = 0; i < intensity; i++) {
|
|
if (pos.thick) {
|
|
drawMode = GL_LINES;
|
|
tmpPoints.reserve((int)(intensity * 2 + 1));
|
|
double randomv = (0.5 - rnd.getFloat()) * pos.thick;
|
|
double randomu = (0.5 - rnd.getFloat()) * step;
|
|
shift = randomu * u + randomv * v;
|
|
pos1 = pos + shift + v * (pos.thick);
|
|
pos2 = pos + shift - v * (pos.thick);
|
|
tmpPoints.push_back(pos1);
|
|
tmpPoints.push_back(pos2);
|
|
} else {
|
|
drawMode = GL_POINTS;
|
|
tmpPoints.reserve((int)(intensity + 1));
|
|
tmpPoints.push_back((TPointD)pos);
|
|
}
|
|
}
|
|
if (!tmpPoints.empty()) {
|
|
assert(drawMode == GL_POINTS || drawMode == GL_LINES);
|
|
data.push_back(make_pair(drawMode, tmpPoints));
|
|
}
|
|
s += step;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TGraphicPenStrokeStyle::drawStroke(const TColorFunction *cf,
|
|
DrawmodePointsMatrix &data,
|
|
const TStroke *stroke) const {
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
tglColor(color);
|
|
|
|
DrawmodePointsMatrix::iterator it1 = data.begin();
|
|
for (; it1 != data.end(); ++it1) {
|
|
if (it1->first == GL_LINES) {
|
|
Points::iterator it2 = it1->second.begin();
|
|
glBegin(GL_LINES);
|
|
for (; it2 != it1->second.end(); ++it2) tglVertex(*it2);
|
|
glEnd();
|
|
} else {
|
|
assert(it1->first == GL_POINTS);
|
|
Points::iterator it2 = it1->second.begin();
|
|
glBegin(GL_POINTS);
|
|
for (; it2 != it1->second.end(); ++it2) tglVertex(*it2);
|
|
glEnd();
|
|
}
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
namespace {
|
|
double inline get_line_slope(double meter, double inmax, double linemax,
|
|
double outmax) {
|
|
if (meter <= inmax)
|
|
return meter / inmax;
|
|
else if (meter <= inmax + linemax)
|
|
return 1;
|
|
else if (meter <= inmax + linemax + outmax)
|
|
return (inmax + linemax - meter) / outmax + 1;
|
|
else
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TDottedLineStrokeStyle::TDottedLineStrokeStyle()
|
|
: m_color(TPixel32::Black)
|
|
, m_in(10.0)
|
|
, m_line(50.0)
|
|
, m_out(10.0)
|
|
, m_blank(10.0) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TDottedLineStrokeStyle::clone() const {
|
|
return new TDottedLineStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TDottedLineStrokeStyle::getParamCount() const { return 4; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TDottedLineStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TDottedLineStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 4);
|
|
QString value;
|
|
switch (index) {
|
|
case 0:
|
|
value = QCoreApplication::translate("TDottedLineStrokeStyle", "Fade In");
|
|
break;
|
|
case 1:
|
|
value = QCoreApplication::translate("TDottedLineStrokeStyle", "Dash");
|
|
break;
|
|
case 2:
|
|
value = QCoreApplication::translate("TDottedLineStrokeStyle", "Fade Out");
|
|
break;
|
|
case 3:
|
|
value = QCoreApplication::translate("TDottedLineStrokeStyle", "Gap");
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TDottedLineStrokeStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 4);
|
|
switch (index) {
|
|
case 0:
|
|
min = 1.0;
|
|
max = 100.0;
|
|
break;
|
|
case 1:
|
|
min = 1.0;
|
|
max = 100.0;
|
|
break;
|
|
case 2:
|
|
min = 1.;
|
|
max = 100.0;
|
|
break;
|
|
case 3:
|
|
min = 0.0;
|
|
max = 100.0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TDottedLineStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 4);
|
|
double value = 0;
|
|
switch (index) {
|
|
case 0:
|
|
value = m_in;
|
|
break;
|
|
case 1:
|
|
value = m_line;
|
|
break;
|
|
case 2:
|
|
value = m_out;
|
|
break;
|
|
case 3:
|
|
value = m_blank;
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TDottedLineStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 4);
|
|
switch (index) {
|
|
case 0:
|
|
m_in = value;
|
|
break;
|
|
case 1:
|
|
m_line = value;
|
|
break;
|
|
case 2:
|
|
m_out = value;
|
|
break;
|
|
case 3:
|
|
m_blank = value;
|
|
break;
|
|
}
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TDottedLineStrokeStyle::computeData(Points &positions,
|
|
const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
double length = stroke->getLength();
|
|
|
|
double step = 5.0;
|
|
double linemax = m_line;
|
|
double inmax = (m_in / 100);
|
|
double outmax = (m_out / 100);
|
|
double blankmax = m_blank;
|
|
double total = 0;
|
|
TRandom rnd;
|
|
|
|
positions.clear();
|
|
positions.reserve(tceil(length / step) + 1);
|
|
|
|
TPointD oldPos1, oldPos2, oldPos3, oldPos4, pos1, pos2, pos3, pos4;
|
|
// bool firstRing = true;
|
|
double s = 0;
|
|
double meter = 0;
|
|
double center = 0;
|
|
double slopetmp = 0;
|
|
double minthickness = MINTHICK * sqrt(tglGetPixelSize2());
|
|
double thickness = 0;
|
|
double line = 0, in = 0, out = 0, blank = 0;
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
if (w < 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // per tamponare il baco della getParameterAtLength()
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
|
|
if (pos.thick < MINTHICK)
|
|
thickness = minthickness;
|
|
else
|
|
thickness = pos.thick;
|
|
if (meter >= total) {
|
|
meter = 0;
|
|
|
|
line = linemax * (1 + rnd.getFloat()) * thickness;
|
|
if (line > length - s) line = length - s;
|
|
in = inmax * line;
|
|
out = outmax * line;
|
|
line = line - in - out;
|
|
blank = blankmax * (1 + rnd.getFloat()) * thickness;
|
|
if (in + out > length) {
|
|
in = rnd.getFloat() * (length / 2);
|
|
out = length - in;
|
|
line = 0;
|
|
}
|
|
total = in + line + out + blank;
|
|
} else if (meter > in + line + out + step) {
|
|
s += step;
|
|
meter += step;
|
|
continue;
|
|
}
|
|
TPointD u = stroke->getSpeed(w);
|
|
if (norm2(u) == 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // non dovrebbe succedere mai, ma per prudenza....
|
|
u = normalize(u);
|
|
double slope = 0;
|
|
slope = get_line_slope(meter, in, line, out);
|
|
slopetmp = slope;
|
|
TPointD v = rotate90(u) * (thickness)*slope;
|
|
if (pos.thick * slope < 1)
|
|
center = 0.0;
|
|
else
|
|
center = 0.5;
|
|
pos1 = pos + v;
|
|
pos2 = pos + v * 0.5;
|
|
pos3 = pos - v * 0.5;
|
|
pos4 = pos - v;
|
|
|
|
positions.push_back(pos1);
|
|
positions.push_back(pos2);
|
|
positions.push_back(pos3);
|
|
positions.push_back(pos4);
|
|
|
|
s += step;
|
|
meter += step;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TDottedLineStrokeStyle::drawStroke(const TColorFunction *cf,
|
|
Points &positions,
|
|
const TStroke *stroke) const {
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
|
|
for (UINT i = 4; i < positions.size(); i += 4) {
|
|
glBegin(GL_QUAD_STRIP);
|
|
glColor4ub(color.r, color.g, color.b, 0);
|
|
tglVertex(positions[i - 4]);
|
|
tglVertex(positions[i]);
|
|
glColor4ub(color.r, color.g, color.b, color.m);
|
|
tglVertex(positions[i - 3]);
|
|
tglVertex(positions[i + 1]);
|
|
tglVertex(positions[i - 2]);
|
|
tglVertex(positions[i + 2]);
|
|
glColor4ub(color.r, color.g, color.b, 0);
|
|
tglVertex(positions[i - 1]);
|
|
tglVertex(positions[i + 3]);
|
|
glEnd();
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TRopeStrokeStyle::TRopeStrokeStyle()
|
|
: m_color(TPixel32(255, 135, 0)), m_bend(0.4) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TRopeStrokeStyle::clone() const {
|
|
return new TRopeStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TRopeStrokeStyle::getParamCount() const { return 1; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TRopeStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TRopeStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 1);
|
|
return QCoreApplication::translate("TRopeStrokeStyle", "Tilt");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRopeStrokeStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 1);
|
|
min = -1.0;
|
|
max = 1.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TRopeStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 1);
|
|
return m_bend;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRopeStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 1);
|
|
m_bend = value;
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRopeStrokeStyle::computeData(Points &positions, const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
double length = stroke->getLength();
|
|
// spessore della catena = spessore "medio" dello stroke
|
|
double step = 10.0;
|
|
double bend;
|
|
double bump;
|
|
double bump_max = step / 4;
|
|
|
|
positions.clear();
|
|
positions.reserve(tceil(length / step) + 1);
|
|
|
|
TPointD oldPos1, oldPos2;
|
|
bool firstRing = true;
|
|
double s = 0;
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
if (w < 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // per tamponare il baco della getParameterAtLength()
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
TPointD u = stroke->getSpeed(w);
|
|
if (norm2(u) == 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // non dovrebbe succedere mai, ma per prudenza....
|
|
u = normalize(u);
|
|
bend = pos.thick * m_bend;
|
|
bump = pos.thick * 0.3;
|
|
if (bump >= bump_max) bump = bump_max;
|
|
TPointD v = rotate90(u) * pos.thick;
|
|
TPointD v1 = v * 0.2;
|
|
if (firstRing) {
|
|
firstRing = false;
|
|
} else {
|
|
positions.push_back(pos + (bend + bump) * u + v - v1);
|
|
positions.push_back(pos + (bend)*u + v);
|
|
positions.push_back(oldPos1 + (bump)*u + v1);
|
|
positions.push_back(oldPos1);
|
|
positions.push_back(oldPos2);
|
|
positions.push_back(oldPos2 + bump * u - v1);
|
|
positions.push_back(pos + u * (-bend) - v);
|
|
positions.push_back(pos + u * (bump - bend) - v + v1);
|
|
}
|
|
oldPos1 = pos + (bend + bump) * u + v - v1;
|
|
oldPos2 = pos + u * (bump - bend) - v + v1;
|
|
s += step;
|
|
}
|
|
positions.push_back(oldPos1);
|
|
positions.push_back(oldPos2);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TRopeStrokeStyle::drawStroke(const TColorFunction *cf, Points &positions,
|
|
const TStroke *stroke) const {
|
|
if (positions.size() <= 1) return;
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
|
|
// GLuint rope_id;
|
|
|
|
TPixel32 blackcolor(TPixel32::Black);
|
|
if (cf)
|
|
blackcolor = (*(cf))(blackcolor);
|
|
else
|
|
blackcolor = blackcolor;
|
|
|
|
// rope_id = glGenLists(1);
|
|
|
|
static const int stride = sizeof(TPointD);
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
|
|
UINT i = 0;
|
|
for (; i < positions.size() - 2; i += 8) {
|
|
/*
|
|
glNewList(rope_id,GL_COMPILE);
|
|
tglVertex(positions[i]);
|
|
tglVertex(positions[i+1]);
|
|
tglVertex(positions[i+2]);
|
|
tglVertex(positions[i+3]);
|
|
tglVertex(positions[i+4]);
|
|
tglVertex(positions[i+5]);
|
|
tglVertex(positions[i+6]);
|
|
tglVertex(positions[i+7]);
|
|
glEndList();
|
|
*/
|
|
tglColor(color);
|
|
// glBegin(GL_POLYGON);
|
|
|
|
glVertexPointer(2, GL_DOUBLE, stride, &positions[i]);
|
|
glDrawArrays(GL_POLYGON, 0, 8);
|
|
|
|
// glCallList(rope_id);
|
|
// glEnd();
|
|
|
|
tglColor(blackcolor);
|
|
|
|
// glBegin(GL_LINE_STRIP);
|
|
glVertexPointer(2, GL_DOUBLE, stride, &positions[i]);
|
|
glDrawArrays(GL_LINE_STRIP, 0, 8);
|
|
|
|
// glCallList(rope_id);
|
|
// glEnd();
|
|
}
|
|
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
|
|
glBegin(GL_LINE_STRIP);
|
|
tglVertex(positions[i]);
|
|
tglVertex(positions[i + 1]);
|
|
glEnd();
|
|
|
|
// glDeleteLists(rope_id,1);
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TCrystallizeStrokeStyle::TCrystallizeStrokeStyle()
|
|
: m_color(TPixel32(255, 150, 150, 255)), m_period(10.0), m_opacity(0.5) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TCrystallizeStrokeStyle::clone() const {
|
|
return new TCrystallizeStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TCrystallizeStrokeStyle::getParamCount() const { return 2; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TCrystallizeStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TCrystallizeStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 2);
|
|
return index == 0
|
|
? QCoreApplication::translate("TCrystallizeStrokeStyle", "Crease")
|
|
: QCoreApplication::translate("TCrystallizeStrokeStyle",
|
|
"Opacity");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TCrystallizeStrokeStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 2);
|
|
if (index == 0) {
|
|
min = 1.0;
|
|
max = 100.0;
|
|
} else {
|
|
min = 0.0;
|
|
max = 1.0;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TCrystallizeStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 2);
|
|
return index == 0 ? m_period : m_opacity;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TCrystallizeStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 2);
|
|
if (index == 0)
|
|
m_period = value;
|
|
else
|
|
m_opacity = value;
|
|
|
|
// updateVersionNumber(); non serve perche' i parametri vengono sfrutttati
|
|
// direttamente nella draw
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TCrystallizeStrokeStyle::computeData(Points &positions,
|
|
const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
double length = stroke->getLength();
|
|
double step = 10.0;
|
|
TRandom rnd;
|
|
positions.clear();
|
|
positions.reserve(tceil((length + 1) / step));
|
|
double s = 0;
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
if (w < 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // per tamponare il baco della getParameterAtLength()
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
TPointD u = stroke->getSpeed(w);
|
|
if (norm2(u) == 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // non dovrebbe succedere mai, ma per prudenza....
|
|
u = normalize(u);
|
|
TPointD v = rotate90(u) * (pos.thick / 2);
|
|
positions.push_back(pos + v * (1 + rnd.getFloat()) +
|
|
u * 2 * rnd.getFloat());
|
|
positions.push_back(pos - v * (1 + rnd.getFloat()) -
|
|
u * 2 * rnd.getFloat());
|
|
s += step;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TCrystallizeStrokeStyle::drawStroke(const TColorFunction *cf,
|
|
Points &positions,
|
|
const TStroke *stroke) const {
|
|
// double length = stroke->getLength();
|
|
double step = 10.0;
|
|
double period = (101 - m_period) * step;
|
|
double counter = 0;
|
|
double opacity = m_opacity;
|
|
TRandom rnd;
|
|
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
|
|
TPixelD dcolor = toPixelD(color);
|
|
// double s = 0;
|
|
|
|
glBegin(GL_QUAD_STRIP);
|
|
for (int i = 0; i < (int)positions.size() / 2; i++) {
|
|
if (counter > period) counter = 0;
|
|
glColor4d(dcolor.r, dcolor.g, dcolor.b,
|
|
(opacity + (counter / period) * rnd.getFloat()) * dcolor.m);
|
|
tglVertex(positions[i * 2]);
|
|
tglVertex(positions[i * 2 + 1]);
|
|
counter += step;
|
|
}
|
|
glEnd();
|
|
counter = 0;
|
|
glColor4d(dcolor.r, dcolor.g, dcolor.b, dcolor.m);
|
|
for (int j = 1; j < (int)positions.size() / 2; j++) {
|
|
glBegin(GL_LINES);
|
|
tglVertex(positions[(j - 1) * 2]);
|
|
tglVertex(positions[j * 2]);
|
|
glEnd();
|
|
glBegin(GL_LINES);
|
|
tglVertex(positions[(j - 1) * 2 + 1]);
|
|
tglVertex(positions[j * 2 + 1]);
|
|
glEnd();
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
namespace {
|
|
|
|
class Stripe {
|
|
public:
|
|
TPointD oldpos1;
|
|
TPointD oldpos2;
|
|
TPointD pos1;
|
|
TPointD pos2;
|
|
int phase;
|
|
TPixel32 color;
|
|
Stripe();
|
|
void drawpolygon();
|
|
void drawlines(TPixel32 blackcolor);
|
|
void addToSegment(vector<TSegment> *sv, vector<TSegment> &scontour,
|
|
TPixel32 *colors);
|
|
};
|
|
|
|
Stripe::Stripe() {
|
|
oldpos1 = TPointD(0, 0);
|
|
oldpos2 = TPointD(0, 0);
|
|
pos1 = TPointD(0, 0);
|
|
pos2 = TPointD(0, 0);
|
|
color = TPixel32(0, 0, 0);
|
|
phase = 0;
|
|
}
|
|
|
|
void Stripe::drawpolygon() {
|
|
tglColor(color);
|
|
glBegin(GL_POLYGON);
|
|
tglVertex(oldpos1);
|
|
tglVertex(pos1);
|
|
tglVertex(pos2);
|
|
tglVertex(oldpos2);
|
|
glEnd();
|
|
}
|
|
|
|
void Stripe::addToSegment(vector<TSegment> *sv, vector<TSegment> &scontour,
|
|
TPixel32 *colors) {
|
|
TPointD p0 = (oldpos1 + oldpos2) * 0.5;
|
|
TPointD p1 = (pos1 + pos2) * 0.5;
|
|
// TPointD p0=oldpos1;
|
|
// TPointD p1=pos1;
|
|
if (color == colors[0]) sv[0].push_back(TSegment(p0, p1));
|
|
if (color == colors[1]) sv[1].push_back(TSegment(p0, p1));
|
|
if (color == colors[2]) sv[2].push_back(TSegment(p0, p1));
|
|
|
|
scontour.push_back(TSegment(oldpos1, pos1));
|
|
scontour.push_back(TSegment(oldpos2, pos2));
|
|
}
|
|
|
|
void Stripe::drawlines(TPixel32 blackcolor) {
|
|
tglColor(blackcolor);
|
|
glBegin(GL_LINE_STRIP);
|
|
tglVertex(oldpos1);
|
|
tglVertex(pos1);
|
|
glEnd();
|
|
glBegin(GL_LINE_STRIP);
|
|
tglVertex(pos2);
|
|
tglVertex(oldpos2);
|
|
glEnd();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TBraidStrokeStyle::TBraidStrokeStyle()
|
|
: m_period(80.0)
|
|
|
|
{
|
|
m_colors[0] = TPixel32::Red;
|
|
m_colors[1] = TPixel32::Green;
|
|
m_colors[2] = TPixel32::Blue;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TBraidStrokeStyle::clone() const {
|
|
return new TBraidStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TBraidStrokeStyle::getParamCount() const { return 1; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TBraidStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TBraidStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 1);
|
|
|
|
return QCoreApplication::translate("TBraidStrokeStyle", "Twirl");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBraidStrokeStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 1);
|
|
min = 1.0;
|
|
max = 100.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TBraidStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 1);
|
|
return m_period;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBraidStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 1);
|
|
m_period = value;
|
|
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TPixel32 TBraidStrokeStyle::getColorParamValue(int index) const {
|
|
TPixel32 tmp;
|
|
switch (index) {
|
|
case (0):
|
|
tmp = m_colors[0];
|
|
break;
|
|
case (1):
|
|
tmp = m_colors[1];
|
|
break;
|
|
case (2):
|
|
tmp = m_colors[2];
|
|
break;
|
|
}
|
|
return tmp;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBraidStrokeStyle::setColorParamValue(int index, const TPixel32 &color) {
|
|
switch (index) {
|
|
case (0):
|
|
m_colors[0] = color;
|
|
break;
|
|
case (1):
|
|
m_colors[1] = color;
|
|
break;
|
|
case (2):
|
|
m_colors[2] = color;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBraidStrokeStyle::loadData(int ids, TInputStreamInterface &is) {
|
|
if (ids != 112)
|
|
throw TException("Braid stroke style: unknown obsolete format");
|
|
|
|
is >> m_colors[0] >> m_period;
|
|
|
|
m_period /= 10.0;
|
|
m_colors[0] = TPixel32::Red;
|
|
m_colors[1] = TPixel32::Green;
|
|
m_colors[2] = TPixel32::Blue;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBraidStrokeStyle::drawStroke(const TColorFunction *cf,
|
|
const TStroke *stroke) const {
|
|
double length = stroke->getLength();
|
|
const int ntick = 81;
|
|
const double stripethickness = 0.3;
|
|
int period = (int)(101 - m_period) * 20;
|
|
double step = period / (double)ntick;
|
|
double freq = M_2PI / ntick;
|
|
int swapcount = 0;
|
|
int count = 0;
|
|
bool firstRing = true;
|
|
double s = 0;
|
|
double swap;
|
|
vector<Stripe> braid;
|
|
vector<double> ssin;
|
|
int k = 0;
|
|
TPixel32 colors[3];
|
|
for (k = 0; k < 3; k++) {
|
|
if (cf)
|
|
colors[k] = (*(cf))(m_colors[k]);
|
|
else
|
|
colors[k] = m_colors[k];
|
|
}
|
|
TPixel32 blackcolor = TPixel32::Black;
|
|
if (cf) blackcolor = (*(cf))(blackcolor);
|
|
|
|
for (k = 0; k < 3; k++) {
|
|
Stripe tmp;
|
|
tmp.phase = (ntick * k) / 3;
|
|
tmp.color = colors[k];
|
|
braid.push_back(tmp);
|
|
}
|
|
|
|
for (int z = 0; z < ntick; z++) {
|
|
double tmpsin = sin(z * freq);
|
|
ssin.push_back(tmpsin);
|
|
}
|
|
while (s <= length) {
|
|
count++;
|
|
double w = stroke->getParameterAtLength(s);
|
|
if (w < 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // per tamponare il baco della getParameterAtLength()
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
TPointD u = stroke->getSpeed(w);
|
|
if (norm2(u) == 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // non dovrebbe succedere mai, ma per prudenza....
|
|
u = normalize(u);
|
|
TPointD v = rotate90(u) * pos.thick;
|
|
TPointD v1 = v * stripethickness;
|
|
v = v * 0.5;
|
|
// int modper=(int)s%(int)period;
|
|
if (firstRing) {
|
|
firstRing = false;
|
|
swap = 0;
|
|
for (int j = 0; j < (int)braid.size(); j++) {
|
|
int tmp = (count + braid[j].phase) % ntick;
|
|
braid[j].oldpos1 = pos + v * ssin[tmp];
|
|
braid[j].oldpos2 = pos + v * ssin[tmp] + v1;
|
|
}
|
|
} else {
|
|
for (int i = 0; i < (int)braid.size(); i++) {
|
|
int tmp = (count + braid[i].phase) % ntick;
|
|
braid[i].pos1 = pos + v * ssin[tmp];
|
|
braid[i].pos2 = pos + v * ssin[tmp] + v1;
|
|
braid[i].drawpolygon();
|
|
braid[i].drawlines(blackcolor);
|
|
braid[i].oldpos1 = pos + v * ssin[tmp];
|
|
braid[i].oldpos2 = pos + v * ssin[tmp] + v1;
|
|
}
|
|
}
|
|
s += step;
|
|
swap += step;
|
|
if (swap > (period / 3.0)) {
|
|
swapcount++;
|
|
std::swap(braid[0], braid[1 + (swapcount & 1)]);
|
|
swap -= period / 3.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TSketchStrokeStyle::TSketchStrokeStyle()
|
|
: m_color(TPixel32(100, 100, 150, 127)), m_density(0.4) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TSketchStrokeStyle::clone() const {
|
|
return new TSketchStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TSketchStrokeStyle::getParamCount() const { return 1; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TSketchStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TSketchStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 1);
|
|
|
|
return QCoreApplication::translate("TSketchStrokeStyle", "Density");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSketchStrokeStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 1);
|
|
min = 0.0;
|
|
max = 1.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TSketchStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 1);
|
|
return m_density;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSketchStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 1);
|
|
m_density = value;
|
|
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSketchStrokeStyle::drawStroke(const TColorFunction *cf,
|
|
const TStroke *stroke) const {
|
|
double length = stroke->getLength();
|
|
if (length <= 0) return;
|
|
|
|
int count = (int)(length * m_density);
|
|
|
|
double maxDw = std::min(1.0, 20.0 / length);
|
|
double minDw = 1.0 / length;
|
|
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
|
|
tglColor(color);
|
|
|
|
TRandom rnd;
|
|
|
|
for (int i = 0; i < count; i++) {
|
|
double r = rnd.getFloat();
|
|
double dw = (1 - r) * minDw + r * maxDw;
|
|
double wmin = dw, wmax = 1 - dw;
|
|
if (wmin >= wmax) continue;
|
|
r = rnd.getFloat();
|
|
double w = (1 - r) * wmin + r * wmax;
|
|
|
|
double w0 = w - dw;
|
|
double w1 = w + dw;
|
|
|
|
TThickPoint p0 = stroke->getThickPoint(w0);
|
|
TThickPoint p1 = stroke->getThickPoint(w1);
|
|
double d01 = tdistance(p0, p1);
|
|
if (d01 == 0) continue;
|
|
|
|
int count = (int)(d01);
|
|
|
|
TPointD v0 = stroke->getSpeed(w0);
|
|
TPointD v1 = stroke->getSpeed(w1);
|
|
|
|
if (norm2(v0) == 0 || norm2(v1) == 0)
|
|
continue; // non dovrebbe succedere mai, ma....
|
|
v0 = rotate90(normalize(v0));
|
|
v1 = rotate90(normalize(v1));
|
|
|
|
double delta = 0.5 * (rnd.getFloat() - 0.5) * (p0.thick + p1.thick);
|
|
double d = 0.1 * d01;
|
|
double delta0 = delta - d;
|
|
double delta1 = delta + d;
|
|
|
|
glBegin(GL_LINE_STRIP);
|
|
tglVertex(p0 + v0 * delta0);
|
|
for (int j = 1; j < count; j++) {
|
|
double t = j / (double)count;
|
|
w = (1 - t) * w0 + t * w1;
|
|
TPointD v = rotate90(normalize(stroke->getSpeed(w)));
|
|
assert(0 <= w && w <= 1);
|
|
TPointD p = stroke->getPoint(w);
|
|
double delta_t = (1 - t) * delta0 + t * delta1;
|
|
tglVertex(p + v * delta_t);
|
|
}
|
|
tglVertex(p1 + v1 * delta1);
|
|
glEnd();
|
|
}
|
|
glColor4d(0, 0, 0, 1);
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TBubbleStrokeStyle::TBubbleStrokeStyle()
|
|
: m_color0(TPixel32::Red), m_color1(TPixel32::Green) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TBubbleStrokeStyle::clone() const {
|
|
return new TBubbleStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBubbleStrokeStyle::loadData(int ids, TInputStreamInterface &is) {
|
|
if (ids != 114)
|
|
throw TException("Bubble stroke style: unknown obsolete format");
|
|
|
|
m_color0 = TPixel32::Red;
|
|
m_color1 = TPixel32::Green;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBubbleStrokeStyle::drawStroke(const TColorFunction *cf,
|
|
const TStroke *stroke) const {
|
|
double length = stroke->getLength();
|
|
if (length <= 0) return;
|
|
|
|
TRandom rnd(0);
|
|
|
|
TPixel32 color0, color1;
|
|
if (cf) {
|
|
color0 = (*(cf))(m_color0);
|
|
color1 = (*(cf))(m_color1);
|
|
} else {
|
|
color0 = m_color0;
|
|
color1 = m_color1;
|
|
}
|
|
|
|
double minthickness = MINTHICK * sqrt(tglGetPixelSize2());
|
|
double thickness = 0;
|
|
for (double s = 0; s < length; s += 5) {
|
|
TPointD p = stroke->getPointAtLength(s);
|
|
double w = stroke->getParameterAtLength(s);
|
|
if (w < 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // per tamponare il baco della getParameterAtLength()
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
int toff = rnd.getInt(0, 999);
|
|
int t = (m_currentFrame + toff) % 1000;
|
|
TRandom rnd2(t >> 2);
|
|
p += 2 * TPointD(-0.5 + rnd2.getFloat(), -0.5 + rnd2.getFloat());
|
|
if (pos.thick < MINTHICK)
|
|
thickness = minthickness;
|
|
else
|
|
thickness = pos.thick;
|
|
tglColor(blend(color0, color1, rnd.getFloat()));
|
|
double radius = (t & ((int)(thickness)));
|
|
tglDrawCircle(p, radius);
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TTissueStrokeStyle::TTissueStrokeStyle()
|
|
: m_color(TPixel32::Black), m_density(3.0), m_border(1.0) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TTissueStrokeStyle::clone() const {
|
|
return new TTissueStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TTissueStrokeStyle::getParamCount() const { return 2; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TTissueStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TTissueStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 2);
|
|
return index == 0
|
|
? QCoreApplication::translate("TTissueStrokeStyle", "Density")
|
|
: QCoreApplication::translate("TTissueStrokeStyle", "Border Size");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TTissueStrokeStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 2);
|
|
if (index == 0) {
|
|
min = 2.0;
|
|
max = 10.0;
|
|
} else {
|
|
min = 0.0;
|
|
max = 1.0;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TTissueStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 2);
|
|
return index == 0 ? m_density : m_border;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TTissueStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 2);
|
|
if (index == 0)
|
|
m_density = value;
|
|
else
|
|
m_border = value;
|
|
|
|
updateVersionNumber();
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TTissueStrokeStyle::computeData(PointMatrix &data, const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
data.clear();
|
|
double length = stroke->getLength();
|
|
double step = 5.0;
|
|
double border = m_border;
|
|
TPointD pos1, oldPos1;
|
|
TRandom rnd;
|
|
double increment = 0.0;
|
|
int intensity = (int)m_density + 2;
|
|
vector<TPointD> points;
|
|
vector<TPointD> oldpoints;
|
|
double s = 0;
|
|
bool firstRing = true;
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
if (w < 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // per tamponare il baco della getParameterAtLength()
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
TPointD u = stroke->getSpeed(w);
|
|
if (norm2(u) == 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // non dovrebbe succedere mai, ma per prudenza....
|
|
u = normalize(u);
|
|
TPointD v = rotate90(u);
|
|
increment = (2 * pos.thick) / (intensity - 1);
|
|
for (int i = 1; i < intensity - 1; i++) {
|
|
pos1 = pos + v * (-pos.thick + i * increment);
|
|
points.push_back(pos1);
|
|
}
|
|
if (firstRing) {
|
|
firstRing = false;
|
|
} else {
|
|
Points tmpPoints1;
|
|
tmpPoints1.clear();
|
|
tmpPoints1.reserve(intensity);
|
|
|
|
for (int i = 1; i < intensity - 1; i++) {
|
|
pos1 = points[i - 1];
|
|
oldPos1 = oldpoints[i - 1];
|
|
tmpPoints1.push_back(oldPos1);
|
|
tmpPoints1.push_back(pos1);
|
|
}
|
|
data.push_back(tmpPoints1);
|
|
if (increment > 1) {
|
|
int count = tceil(step / increment + 1);
|
|
Points tmpPoints2;
|
|
tmpPoints2.clear();
|
|
tmpPoints2.reserve(count);
|
|
double startpoint = -step - increment / 2.0;
|
|
for (int j = 1; j < step / increment + 1; j++) {
|
|
tmpPoints2.push_back(points[0] -
|
|
v * border * increment * rnd.getFloat() +
|
|
u * (startpoint + j * (increment)));
|
|
tmpPoints2.push_back(points[intensity - 3] +
|
|
v * border * increment * rnd.getFloat() +
|
|
u * (startpoint + j * (increment)));
|
|
}
|
|
data.push_back(tmpPoints2);
|
|
}
|
|
}
|
|
oldpoints = points;
|
|
points.clear();
|
|
s += step;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TTissueStrokeStyle::drawStroke(const TColorFunction *cf, PointMatrix &data,
|
|
const TStroke *stroke) const {
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
|
|
tglColor(color);
|
|
|
|
PointMatrix::iterator it1 = data.begin();
|
|
for (; it1 != data.end(); ++it1) {
|
|
glBegin(GL_LINES);
|
|
Points::iterator it2 = (*it1).begin();
|
|
for (; it2 != (*it1).end(); ++it2) {
|
|
tglVertex(*it2);
|
|
}
|
|
glEnd();
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TBiColorStrokeStyle::TBiColorStrokeStyle()
|
|
: m_color0(TPixel32::Red), m_color1(TPixel32::Black) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TBiColorStrokeStyle::clone() const {
|
|
return new TBiColorStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBiColorStrokeStyle::loadData(TInputStreamInterface &is) {
|
|
is >> m_color0 >> m_color1 >> m_parameter;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBiColorStrokeStyle::saveData(TOutputStreamInterface &os) const {
|
|
os << m_color0 << m_color1 << m_parameter;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBiColorStrokeStyle::drawRegion(const TColorFunction *cf,
|
|
const bool antiAliasing,
|
|
TRegionOutline &boundary) const {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBiColorStrokeStyle::loadData(int ids, TInputStreamInterface &is) {
|
|
if (ids != 115 && ids != 119)
|
|
throw TException("Bicolor stroke style: unknown obsolete format");
|
|
|
|
is >> m_color0 >> m_parameter;
|
|
|
|
m_color1 = TPixel32::Black;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBiColorStrokeStyle::drawStroke(const TColorFunction *cf,
|
|
TStrokeOutline *outline,
|
|
const TStroke *stroke) const {
|
|
TPixel32 color0 = m_color0;
|
|
TPixel32 color1 = m_color1;
|
|
|
|
if (cf) {
|
|
color0 = (*(cf))(m_color0);
|
|
color1 = (*(cf))(m_color1);
|
|
} else {
|
|
color0 = m_color0;
|
|
color1 = m_color1;
|
|
}
|
|
|
|
UINT i;
|
|
|
|
const std::vector<TOutlinePoint> &v = outline->getArray();
|
|
|
|
if (v.empty()) return;
|
|
|
|
// outline with antialiasing
|
|
glBegin(GL_LINE_STRIP);
|
|
tglColor(color0);
|
|
for (i = 0; i < v.size(); i += 2) glVertex2dv(&v[i].x);
|
|
glEnd();
|
|
|
|
glBegin(GL_LINE_STRIP);
|
|
tglColor(color1);
|
|
for (i = 1; i < v.size(); i += 2) glVertex2dv(&v[i].x);
|
|
glEnd();
|
|
|
|
glBegin(GL_QUAD_STRIP);
|
|
for (i = 0; i < v.size(); i += 2) {
|
|
tglColor(color0);
|
|
glVertex2dv(&v[i].x);
|
|
tglColor(color1);
|
|
glVertex2dv(&v[i + 1].x);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TNormal2StrokeStyle::TNormal2StrokeStyle()
|
|
: m_color(TPixel32::Yellow)
|
|
, m_lightx(45.0)
|
|
, m_lighty(200.0)
|
|
, m_shininess(50.0)
|
|
, m_metal(0.5)
|
|
, m_bend(1.0) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TNormal2StrokeStyle::clone() const {
|
|
return new TNormal2StrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TNormal2StrokeStyle::getParamCount() const { return 5; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TNormal2StrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TNormal2StrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 5);
|
|
QString value;
|
|
switch (index) {
|
|
case 0:
|
|
value = QCoreApplication::translate("TNormal2StrokeStyle", "Light X Pos");
|
|
break;
|
|
case 1:
|
|
value = QCoreApplication::translate("TNormal2StrokeStyle", "Light Y Pos");
|
|
break;
|
|
case 2:
|
|
value = QCoreApplication::translate("TNormal2StrokeStyle", "Shininess");
|
|
break;
|
|
case 3:
|
|
value = QCoreApplication::translate("TNormal2StrokeStyle", "Plastic");
|
|
break;
|
|
case 4:
|
|
value = QCoreApplication::translate("TNormal2StrokeStyle", "Bump");
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TNormal2StrokeStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 5);
|
|
switch (index) {
|
|
case 0:
|
|
min = -100.0;
|
|
max = 100.0;
|
|
break;
|
|
case 1:
|
|
min = -100.0;
|
|
max = 100.0;
|
|
break;
|
|
case 2:
|
|
min = 0.1;
|
|
max = 128.0;
|
|
break;
|
|
case 3:
|
|
min = 0.0;
|
|
max = 1.0;
|
|
break;
|
|
case 4:
|
|
min = 0.0;
|
|
max = 1.0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TNormal2StrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 5);
|
|
double value;
|
|
switch (index) {
|
|
case 0:
|
|
value = m_lightx;
|
|
break;
|
|
case 1:
|
|
value = m_lighty;
|
|
break;
|
|
case 2:
|
|
value = m_shininess;
|
|
break;
|
|
case 3:
|
|
value = m_metal;
|
|
break;
|
|
case 4:
|
|
value = m_bend;
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TNormal2StrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 5);
|
|
switch (index) {
|
|
case 0:
|
|
m_lightx = value;
|
|
break;
|
|
case 1:
|
|
m_lighty = value;
|
|
break;
|
|
case 2:
|
|
m_shininess = value;
|
|
break;
|
|
case 3:
|
|
m_metal = value;
|
|
break;
|
|
case 4:
|
|
m_bend = value;
|
|
break;
|
|
}
|
|
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TNormal2StrokeStyle::loadData(int ids, TInputStreamInterface &is) {
|
|
if (ids != 121)
|
|
throw TException("Normal stroke style: unknown obsolete format");
|
|
|
|
is >> m_color >> m_lightx >> m_lighty >> m_shininess >> m_metal;
|
|
m_bend = 1.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TNormal2StrokeStyle::drawRegion(const TColorFunction *cf,
|
|
const bool antiAliasing,
|
|
TRegionOutline &boundary) const {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TNormal2StrokeStyle::drawStroke(const TColorFunction *cf,
|
|
TStrokeOutline *outline,
|
|
const TStroke *stroke) const {
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
TPixelD dcolor;
|
|
dcolor = toPixelD(color);
|
|
UINT i;
|
|
double bend = 2 * m_bend;
|
|
const std::vector<TOutlinePoint> &v = outline->getArray();
|
|
if (v.empty()) return;
|
|
vector<T3DPointD> normal;
|
|
|
|
GLfloat light_position[] = {(float)(m_lightx), (float)(m_lighty), 100.0, 0.0};
|
|
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
|
|
glEnable(GL_LIGHTING);
|
|
glEnable(GL_LIGHT0);
|
|
glEnable(GL_NORMALIZE);
|
|
GLfloat mat_ambient[] = {(float)dcolor.r, (float)dcolor.g, (float)dcolor.b,
|
|
1.0};
|
|
GLfloat mat_specular[] = {(float)(m_metal * (1 - dcolor.r) + dcolor.r),
|
|
(float)(m_metal * (1 - dcolor.g) + dcolor.g),
|
|
(float)(m_metal * (1 - dcolor.b) + dcolor.b), 1.0};
|
|
GLfloat mat_shininess[] = {(float)m_shininess};
|
|
|
|
glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
|
|
glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
|
|
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, mat_ambient);
|
|
|
|
// glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
|
|
|
|
// outline with antialiasing
|
|
glBegin(GL_LINE_STRIP);
|
|
for (i = 0; i < v.size(); i += 2) {
|
|
T3DPointD pointa(v[i].x, v[i].y, 0);
|
|
T3DPointD pointb(v[i + 1].x, v[i + 1].y, 0);
|
|
T3DPointD d = pointb - pointa;
|
|
if (norm2(d) > 0.0) d = normalize(d);
|
|
normal.push_back(d);
|
|
T3DPointD pointaNormal = T3DPointD(0, 0, 1) - bend * d;
|
|
tglNormal(pointaNormal);
|
|
tglVertex(pointa);
|
|
}
|
|
glEnd();
|
|
|
|
int normalcounter = 0;
|
|
glBegin(GL_LINE_STRIP);
|
|
for (i = 1; i < v.size(); i += 2) {
|
|
T3DPointD pointa(v[i].x, v[i].y, 0);
|
|
T3DPointD pointaNormal =
|
|
T3DPointD(0, 0, 1) + bend * normal[normalcounter++];
|
|
tglNormal(pointaNormal);
|
|
tglVertex(pointa);
|
|
}
|
|
glEnd();
|
|
|
|
normalcounter = 0;
|
|
for (i = 0; i <= v.size() - 4; i += 2) {
|
|
glBegin(GL_QUAD_STRIP);
|
|
T3DPointD olda(v[i].x, v[i].y, 0);
|
|
T3DPointD oldb(v[i + 1].x, v[i + 1].y, 0);
|
|
T3DPointD oldcenter = 0.5 * (olda + oldb);
|
|
T3DPointD oldcenterNormal(0, 0, 1);
|
|
T3DPointD oldaNormal = T3DPointD(0, 0, 1) - bend * normal[normalcounter];
|
|
T3DPointD oldbNormal = T3DPointD(0, 0, 1) + bend * normal[normalcounter];
|
|
T3DPointD a(v[i + 2].x, v[i + 2].y, 0);
|
|
T3DPointD b(v[i + 3].x, v[i + 3].y, 0);
|
|
T3DPointD center = 0.5 * (a + b);
|
|
T3DPointD centerNormal(0, 0, 1);
|
|
T3DPointD aNormal = T3DPointD(0, 0, 1) - bend * normal[normalcounter++];
|
|
T3DPointD bNormal = T3DPointD(0, 0, 1) + bend * normal[normalcounter];
|
|
tglNormal(oldaNormal);
|
|
tglVertex(olda);
|
|
tglNormal(aNormal);
|
|
tglVertex(a);
|
|
tglNormal(oldcenterNormal);
|
|
tglVertex(oldcenter);
|
|
tglNormal(centerNormal);
|
|
tglVertex(center);
|
|
tglNormal(oldbNormal);
|
|
tglVertex(oldb);
|
|
tglNormal(bNormal);
|
|
tglVertex(b);
|
|
glEnd();
|
|
}
|
|
|
|
glDisable(GL_NORMALIZE);
|
|
glDisable(GL_LIGHTING);
|
|
glDisable(GL_LIGHT0);
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
namespace {
|
|
double get_inout_intensityslope(double in, double out, double t) {
|
|
if (out < in) out = in;
|
|
if (t < in)
|
|
return t / in;
|
|
else if (t > out)
|
|
return (t - 1) / (out - 1);
|
|
else
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TChalkStrokeStyle2::TChalkStrokeStyle2()
|
|
: m_color(TPixel32::Black)
|
|
, m_blend(1.0)
|
|
, m_intensity(50.0)
|
|
, m_in(0.25)
|
|
, m_out(0.25)
|
|
, m_noise(0.0) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TChalkStrokeStyle2::clone() const {
|
|
return new TChalkStrokeStyle2(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TChalkStrokeStyle2::getParamCount() const { return 5; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TChalkStrokeStyle2::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TChalkStrokeStyle2::getParamNames(int index) const {
|
|
assert(0 <= index && index < 5);
|
|
QString value;
|
|
switch (index) {
|
|
case 0:
|
|
value = QCoreApplication::translate("TChalkStrokeStyle2", "Border Fade");
|
|
break;
|
|
case 1:
|
|
value = QCoreApplication::translate("TChalkStrokeStyle2", "Density");
|
|
break;
|
|
case 2:
|
|
value = QCoreApplication::translate("TChalkStrokeStyle2", "Fade In");
|
|
break;
|
|
case 3:
|
|
value = QCoreApplication::translate("TChalkStrokeStyle2", "Fade Out");
|
|
break;
|
|
case 4:
|
|
value = QCoreApplication::translate("TChalkStrokeStyle2", "Noise");
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TChalkStrokeStyle2::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 5);
|
|
switch (index) {
|
|
case 0:
|
|
min = 0.0;
|
|
max = 1.0;
|
|
break;
|
|
case 1:
|
|
min = 0.0;
|
|
max = 100.0;
|
|
break;
|
|
case 2:
|
|
min = 0.0;
|
|
max = 1.0;
|
|
break;
|
|
case 3:
|
|
min = 0.0;
|
|
max = 1.0;
|
|
break;
|
|
case 4:
|
|
min = 0.0;
|
|
max = 1.0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TChalkStrokeStyle2::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 5);
|
|
double value = 0;
|
|
switch (index) {
|
|
case 0:
|
|
value = m_blend;
|
|
break;
|
|
case 1:
|
|
value = m_intensity;
|
|
break;
|
|
case 2:
|
|
value = m_in;
|
|
break;
|
|
case 3:
|
|
value = m_out;
|
|
break;
|
|
case 4:
|
|
value = m_noise;
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TChalkStrokeStyle2::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 5);
|
|
switch (index) {
|
|
case 0:
|
|
m_blend = value;
|
|
break;
|
|
case 1:
|
|
m_intensity = value;
|
|
break;
|
|
case 2:
|
|
m_in = value;
|
|
break;
|
|
case 3:
|
|
m_out = value;
|
|
break;
|
|
case 4:
|
|
m_noise = value;
|
|
break;
|
|
}
|
|
|
|
// updateVersionNumber(); non serve perche' i parametri vengono sfrutttati
|
|
// direttamente nella draw
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TChalkStrokeStyle2::loadData(int ids, TInputStreamInterface &is) {
|
|
if (ids != 105)
|
|
throw TException("chalk stroke style: unknown obsolete format");
|
|
m_in = 0.0, m_out = 0.0, m_noise = 0.0;
|
|
|
|
is >> m_color >> m_blend >> m_intensity;
|
|
m_blend = 1 - m_blend;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TChalkStrokeStyle2::computeData(Doubles &data, const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
double length = stroke->getLength();
|
|
double step = 4;
|
|
double s = 0;
|
|
|
|
data.clear();
|
|
data.reserve(tceil(length / step) * 6 + 6);
|
|
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
// if(w<0) {s+=0.1; continue;} // per tamponare il baco della
|
|
// getParameterAtLength()
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
TPointD u = stroke->getSpeed(w);
|
|
double normu = norm2(u);
|
|
if (normu == 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // non dovrebbe succedere mai, ma per prudenza....
|
|
u = normalize(u);
|
|
|
|
data.push_back(pos.x);
|
|
data.push_back(pos.y);
|
|
data.push_back(pos.thick);
|
|
data.push_back(u.x);
|
|
data.push_back(u.y);
|
|
data.push_back(s / length);
|
|
|
|
s += step;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TChalkStrokeStyle2::drawStroke(const TColorFunction *cf, Doubles &data,
|
|
const TStroke *stroke) const {
|
|
double step = 4;
|
|
|
|
double blend = m_blend; // distanza che controlla da dove il gessetto
|
|
// comincia il fade out (0, 1)
|
|
double intensitymax =
|
|
m_intensity; // quanti punti vengono disegnati ad ogni step
|
|
|
|
TRandom rnd;
|
|
TRandom rnd_noise;
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
TPixelD dcolor;
|
|
dcolor = toPixelD(color);
|
|
double mattedcolor = 0.5 * dcolor.m;
|
|
|
|
double noise = 0;
|
|
double noiseslope = 0;
|
|
double tmpnoise = 0;
|
|
|
|
GLuint chalkId;
|
|
chalkId = glGenLists(1);
|
|
glNewList(chalkId, GL_COMPILE);
|
|
glBegin(GL_QUADS);
|
|
glVertex2d(1, 1);
|
|
glVertex2d(-1, 1);
|
|
glVertex2d(-1, -1);
|
|
glVertex2d(1, -1);
|
|
glEnd();
|
|
glEndList();
|
|
|
|
for (UINT i = 0; i < data.size(); i += 6) {
|
|
TThickPoint pos;
|
|
pos.x = data[i];
|
|
pos.y = data[i + 1];
|
|
pos.thick = data[i + 2];
|
|
TPointD u;
|
|
u.x = data[i + 3];
|
|
u.y = data[i + 4];
|
|
TPointD v = rotate90(u);
|
|
|
|
TPointD shift;
|
|
double intslope = get_inout_intensityslope(m_in, 1 - m_out, data[i + 5]);
|
|
double transpslope = (intslope / blend) * dcolor.m;
|
|
if (m_noise) {
|
|
if (tmpnoise <= 0) {
|
|
noise = (100 / m_noise) * rnd_noise.getFloat();
|
|
tmpnoise = noise;
|
|
}
|
|
noiseslope = get_inout_intensityslope(0.5, 0.5, tmpnoise / noise);
|
|
tmpnoise -= step;
|
|
} else
|
|
noiseslope = 1;
|
|
|
|
for (int i = 0; i < intensitymax * intslope * noiseslope; i++) {
|
|
double vrandnorm = rnd.getFloat(-1.0, 1.0);
|
|
double randomv = vrandnorm * pos.thick * noiseslope;
|
|
double randomu = (0.5 - rnd.getFloat()) * step;
|
|
shift = pos + u * randomu + v * randomv;
|
|
double mod = fabs(vrandnorm);
|
|
if (mod > 1 - blend)
|
|
glColor4d(dcolor.r, dcolor.g, dcolor.b,
|
|
(double)rnd.getFloat() * ((1 - mod) * transpslope));
|
|
else
|
|
glColor4d(dcolor.r, dcolor.g, dcolor.b, mattedcolor);
|
|
glPushMatrix();
|
|
glTranslated(shift.x, shift.y, 0.0);
|
|
glCallList(chalkId);
|
|
glPopMatrix();
|
|
}
|
|
}
|
|
|
|
glDeleteLists(chalkId, 1);
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TBlendStrokeStyle2::TBlendStrokeStyle2()
|
|
: m_color(TPixel32::Red), m_blend(1.0), m_in(0.25), m_out(0.25) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TBlendStrokeStyle2::clone() const {
|
|
return new TBlendStrokeStyle2(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TBlendStrokeStyle2::getParamCount() const { return 3; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TBlendStrokeStyle2::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TBlendStrokeStyle2::getParamNames(int index) const {
|
|
assert(0 <= index && index < 3);
|
|
QString value;
|
|
switch (index) {
|
|
case 0:
|
|
value = QCoreApplication::translate("TBlendStrokeStyle2", "Border Fade");
|
|
break;
|
|
case 1:
|
|
value = QCoreApplication::translate("TBlendStrokeStyle2", "Fade In");
|
|
break;
|
|
case 2:
|
|
value = QCoreApplication::translate("TBlendStrokeStyle2", "Fade Out");
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBlendStrokeStyle2::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 3);
|
|
min = 0.0;
|
|
max = 1.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TBlendStrokeStyle2::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 3);
|
|
double value = 0;
|
|
switch (index) {
|
|
case 0:
|
|
value = m_blend;
|
|
break;
|
|
case 1:
|
|
value = m_in;
|
|
break;
|
|
case 2:
|
|
value = m_out;
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBlendStrokeStyle2::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 3);
|
|
switch (index) {
|
|
case 0:
|
|
m_blend = value;
|
|
break;
|
|
case 1:
|
|
m_in = value;
|
|
break;
|
|
case 2:
|
|
m_out = value;
|
|
break;
|
|
}
|
|
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBlendStrokeStyle2::loadData(int ids, TInputStreamInterface &is) {
|
|
if (ids != 110)
|
|
throw TException("Blend stroke style: unknown obsolete format");
|
|
m_in = 0.0, m_out = 0.0;
|
|
is >> m_color >> m_blend;
|
|
m_blend = 1 - m_blend;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBlendStrokeStyle2::computeData(PointsAndDoubles &data,
|
|
const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
data.clear();
|
|
// TStroke *stroke = getStroke();
|
|
double length = stroke->getLength();
|
|
double step = 10.0;
|
|
TPointD pos1, pos2, pos3, pos4, oldPos1, oldPos2, oldPos3, oldPos4;
|
|
double oldintslope;
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
TPixelD dcolor;
|
|
dcolor = toPixelD(color);
|
|
bool firstRing = true;
|
|
double s = 0;
|
|
double maxfactor = 2 * m_blend / step; // max definisce il numero di
|
|
// intervalli in cui la regione viene
|
|
// divisa
|
|
// per evitare il problema del blend poco efficiente sui triangoli
|
|
double minthickness = MINTHICK * sqrt(tglGetPixelSize2());
|
|
double thickness = 0;
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
if (w < 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // per tamponare il baco della getParameterAtLength()
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
TPointD u = stroke->getSpeed(w);
|
|
if (norm2(u) == 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // non dovrebbe succedere mai, ma per prudenza....
|
|
u = normalize(u);
|
|
if (pos.thick < MINTHICK)
|
|
thickness = minthickness;
|
|
else
|
|
thickness = pos.thick;
|
|
TPointD v = rotate90(u) * thickness;
|
|
|
|
TPointD v1 = v * (1 - m_blend);
|
|
pos1 = pos + v;
|
|
pos2 = pos + v1;
|
|
pos3 = pos - v1;
|
|
pos4 = pos - v;
|
|
double intslope =
|
|
get_inout_intensityslope(m_in, 1 - m_out, s / length) * dcolor.m;
|
|
if (firstRing) {
|
|
firstRing = false;
|
|
} else {
|
|
int max = (int)(maxfactor * thickness);
|
|
double invmax = 1.0 / max;
|
|
data.push_back(make_pair(oldPos1, 0.0));
|
|
data.push_back(make_pair(pos1, 0.0));
|
|
int i;
|
|
for (i = 1; i < max; i++) {
|
|
data.push_back(make_pair(i * (oldPos2 - oldPos1) * invmax + oldPos1,
|
|
(i * oldintslope) * invmax));
|
|
data.push_back(make_pair(i * (pos2 - pos1) * invmax + pos1,
|
|
(i * intslope) * invmax));
|
|
}
|
|
|
|
data.push_back(make_pair(oldPos2, oldintslope));
|
|
data.push_back(make_pair(pos2, intslope));
|
|
data.push_back(make_pair(oldPos3, oldintslope));
|
|
data.push_back(make_pair(pos3, intslope));
|
|
|
|
for (i = 0; i < max; i++) {
|
|
data.push_back(make_pair(i * (oldPos4 - oldPos3) * invmax + oldPos3,
|
|
(oldintslope * invmax) * (max - i)));
|
|
data.push_back(make_pair(i * (pos4 - pos3) * invmax + pos3,
|
|
(intslope * invmax) * (max - i)));
|
|
}
|
|
|
|
data.push_back(make_pair(oldPos4, 0.0));
|
|
data.push_back(make_pair(pos4, 0.0));
|
|
}
|
|
oldPos1 = pos1;
|
|
oldPos2 = pos2;
|
|
oldPos3 = pos3;
|
|
oldPos4 = pos4;
|
|
oldintslope = intslope;
|
|
s += step;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TBlendStrokeStyle2::drawStroke(const TColorFunction *cf,
|
|
PointsAndDoubles &data,
|
|
const TStroke *stroke) const {
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
TPixelD dcolor;
|
|
dcolor = toPixelD(color);
|
|
|
|
PointsAndDoubles::iterator it = data.begin();
|
|
glBegin(GL_QUAD_STRIP);
|
|
for (; it != data.end(); ++it) {
|
|
glColor4d(dcolor.r, dcolor.g, dcolor.b, it->second);
|
|
tglVertex(it->first);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TTwirlStrokeStyle::TTwirlStrokeStyle()
|
|
: m_color(TPixel32::Green), m_period(30.0), m_blend(0.5) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TTwirlStrokeStyle::clone() const {
|
|
return new TTwirlStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TTwirlStrokeStyle::getParamCount() const { return 2; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TTwirlStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TTwirlStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 2);
|
|
return index == 0 ? QCoreApplication::translate("TTwirlStrokeStyle", "Twirl")
|
|
: QCoreApplication::translate("TTwirlStrokeStyle", "Shade");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TTwirlStrokeStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 2);
|
|
if (index == 0) {
|
|
min = 1.0;
|
|
max = 100.0;
|
|
} else {
|
|
min = 0.0;
|
|
max = 1.0;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TTwirlStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 2);
|
|
return index == 0 ? m_period : m_blend;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TTwirlStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 2);
|
|
if (index == 0)
|
|
m_period = value;
|
|
else
|
|
m_blend = value;
|
|
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TTwirlStrokeStyle::computeData(Doubles &data, const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
double length = stroke->getLength();
|
|
double step = 5.0;
|
|
double period = 10 * (102 - m_period);
|
|
double hperiod = period / 2;
|
|
double blendval = 0;
|
|
TRandom rnd;
|
|
|
|
data.clear();
|
|
data.reserve(tceil(length / step) + 1);
|
|
|
|
double s = 0;
|
|
TPointD app;
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
if (w < 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // per tamponare il baco della getParameterAtLength()
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
TPointD u = stroke->getSpeed(w);
|
|
if (norm2(u) == 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // non dovrebbe succedere mai, ma per prudenza....
|
|
u = normalize(u);
|
|
TPointD v = rotate90(u) * (pos.thick);
|
|
double shift = sin((M_PI / hperiod) * s);
|
|
|
|
app = pos + v * shift;
|
|
data.push_back(app.x);
|
|
data.push_back(app.y);
|
|
app = pos - v * shift;
|
|
data.push_back(app.x);
|
|
data.push_back(app.y);
|
|
|
|
blendval = get_inout_intensityslope(
|
|
m_blend, 1.0 - m_blend, (s - ((int)(s / hperiod) * hperiod)) / hperiod);
|
|
data.push_back(blendval);
|
|
s += step;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TTwirlStrokeStyle::drawStroke(const TColorFunction *cf, Doubles &data,
|
|
const TStroke *stroke) const {
|
|
TPixel32 blackcolor = TPixel32::Black;
|
|
|
|
TPixel32 color;
|
|
if (cf) {
|
|
color = (*(cf))(m_color);
|
|
blackcolor = (*(cf))(blackcolor);
|
|
} else {
|
|
color = m_color;
|
|
}
|
|
blackcolor.m = m_color.m;
|
|
|
|
TPointD app;
|
|
UINT i = 0;
|
|
|
|
glBegin(GL_QUAD_STRIP);
|
|
for (; i < data.size(); i += 5) {
|
|
tglColor(blend(blackcolor, color, data[i + 4]));
|
|
app.x = data[i];
|
|
app.y = data[i + 1];
|
|
tglVertex(app);
|
|
app.x = data[i + 2];
|
|
app.y = data[i + 3];
|
|
tglVertex(app);
|
|
}
|
|
glEnd();
|
|
|
|
for (i = 5; i < data.size(); i += 5) {
|
|
tglColor(blend(color, blackcolor, data[i + 4]));
|
|
glBegin(GL_LINES);
|
|
app.x = data[i - 5];
|
|
app.y = data[i - 4];
|
|
tglVertex(app);
|
|
app.x = data[i];
|
|
app.y = data[i + 1];
|
|
tglVertex(app);
|
|
glEnd();
|
|
glBegin(GL_LINES);
|
|
app.x = data[i - 3];
|
|
app.y = data[i - 2];
|
|
tglVertex(app);
|
|
app.x = data[i + 2];
|
|
app.y = data[i + 3];
|
|
tglVertex(app);
|
|
glEnd();
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TSawToothStrokeStyle::TSawToothStrokeStyle(TPixel32 color, double parameter)
|
|
: m_color(color), m_parameter(parameter) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TSawToothStrokeStyle::clone() const {
|
|
return new TSawToothStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSawToothStrokeStyle::computeOutline(
|
|
const TStroke *stroke, TStrokeOutline &outline,
|
|
TOutlineUtil::OutlineParameter param) const {
|
|
param.m_lengthStep = m_parameter;
|
|
TOutlineStyle::computeOutline(stroke, outline, param);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSawToothStrokeStyle::drawStroke(const TColorFunction *cf,
|
|
TStrokeOutline *outline,
|
|
const TStroke *stroke) const {
|
|
UINT i;
|
|
int counter = 0;
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
tglColor(color);
|
|
const std::vector<TOutlinePoint> &v = outline->getArray();
|
|
if (v.empty()) return;
|
|
double old[2];
|
|
// outline with antialiasing
|
|
glBegin(GL_LINE_STRIP);
|
|
for (i = 0; i < v.size() - 2; i += 2) {
|
|
if (0 != v[i].stepCount) {
|
|
if (counter) {
|
|
glVertex2dv(old);
|
|
glVertex2dv(&v[i].x);
|
|
glVertex2dv(&v[i + 1].x);
|
|
glVertex2dv(old);
|
|
}
|
|
old[0] = v[i].x;
|
|
old[1] = v[i].y;
|
|
counter++;
|
|
}
|
|
}
|
|
glEnd();
|
|
counter = 0;
|
|
glBegin(GL_TRIANGLES);
|
|
for (i = 0; i < v.size() - 2; i += 2) {
|
|
if (0 != v[i].stepCount) {
|
|
if (counter) {
|
|
glVertex2dv(old);
|
|
glVertex2dv(&v[i].x);
|
|
glVertex2dv(&v[i + 1].x);
|
|
}
|
|
old[0] = v[i].x;
|
|
old[1] = v[i].y;
|
|
counter++;
|
|
}
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TSawToothStrokeStyle::getParamCount() const { return 1; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TSawToothStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TSawToothStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 1);
|
|
|
|
return QCoreApplication::translate("TSawToothStrokeStyle", "Distance");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSawToothStrokeStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 1);
|
|
min = 0.1;
|
|
max = 100.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TSawToothStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 1);
|
|
return m_parameter;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSawToothStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 1);
|
|
m_parameter = value;
|
|
updateVersionNumber(); // questo si chiama per ogno cambiamento di parametro
|
|
// per cui di deve ricalcolare l'outline
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TMultiLineStrokeStyle2::TMultiLineStrokeStyle2()
|
|
: m_color0(TPixel32(0, 255, 0))
|
|
, m_color1(TPixel32(0, 0, 0))
|
|
, m_intensity(0.2)
|
|
, m_length(20.0)
|
|
, m_thick(0.3)
|
|
, m_noise(0.5) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TMultiLineStrokeStyle2::clone() const {
|
|
return new TMultiLineStrokeStyle2(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace {
|
|
|
|
typedef struct {
|
|
TPointD u, v;
|
|
TThickPoint p;
|
|
} myLineData;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TMultiLineStrokeStyle2::getParamCount() const { return 4; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TMultiLineStrokeStyle2::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TMultiLineStrokeStyle2::getParamNames(int index) const {
|
|
assert(0 <= index && index < 4);
|
|
QString value;
|
|
switch (index) {
|
|
case 0:
|
|
value = QCoreApplication::translate("TMultiLineStrokeStyle2", "Density");
|
|
break;
|
|
case 1:
|
|
value = QCoreApplication::translate("TMultiLineStrokeStyle2", "Size");
|
|
break;
|
|
case 2:
|
|
value = QCoreApplication::translate("TMultiLineStrokeStyle2", "Thickness");
|
|
break;
|
|
case 3:
|
|
value = QCoreApplication::translate("TMultiLineStrokeStyle2", "Noise");
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TMultiLineStrokeStyle2::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 4);
|
|
switch (index) {
|
|
case 0:
|
|
min = 0.0;
|
|
max = 1.0;
|
|
break;
|
|
case 1:
|
|
min = 0.0;
|
|
max = 100.0;
|
|
break;
|
|
case 2:
|
|
min = 0.0;
|
|
max = 1.0;
|
|
break;
|
|
case 3:
|
|
min = 0.0;
|
|
max = 1.0;
|
|
break;
|
|
}
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TMultiLineStrokeStyle2::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 4);
|
|
double value = 0;
|
|
switch (index) {
|
|
case 0:
|
|
value = m_intensity;
|
|
break;
|
|
case 1:
|
|
value = m_length;
|
|
break;
|
|
case 2:
|
|
value = m_thick;
|
|
break;
|
|
case 3:
|
|
value = m_noise;
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TMultiLineStrokeStyle2::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 4);
|
|
switch (index) {
|
|
case 0:
|
|
m_intensity = value;
|
|
break;
|
|
case 1:
|
|
m_length = value;
|
|
break;
|
|
case 2:
|
|
m_thick = value;
|
|
break;
|
|
case 3:
|
|
m_noise = value;
|
|
break;
|
|
}
|
|
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TMultiLineStrokeStyle2::loadData(int ids, TInputStreamInterface &is) {
|
|
if (ids != 118 && ids != 128)
|
|
throw TException("Multi Line stroke style: unknown obsolete format");
|
|
if (ids == 118) {
|
|
m_length = 20.0, m_thick = 0.3, m_noise = 0.0;
|
|
is >> m_color0 >> m_intensity;
|
|
m_color1 = TPixel32::Black;
|
|
} else {
|
|
is >> m_color0 >> m_intensity >> m_length >> m_thick >> m_noise;
|
|
m_color1 = TPixel32::Black;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TMultiLineStrokeStyle2::computeData(BlendAndPoints &data,
|
|
const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
// TStroke *stroke = getStroke();
|
|
double length = stroke->getLength();
|
|
double step = 4.0;
|
|
int maxlength = (int)m_length;
|
|
double factor = 0;
|
|
TRandom rnd;
|
|
|
|
vector<myLineData> LineData;
|
|
myLineData Data;
|
|
double s = 0;
|
|
|
|
double minthickness = MINTHICK * sqrt(tglGetPixelSize2());
|
|
double thickness = 0;
|
|
double strokethick = m_thick;
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
if (w < 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // per tamponare il baco della getParameterAtLength()
|
|
Data.p = stroke->getThickPoint(w);
|
|
Data.u = stroke->getSpeed(w);
|
|
if (norm2(Data.u) == 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // non dovrebbe succedere mai, ma per prudenza....
|
|
Data.u = normalize(Data.u);
|
|
if (Data.p.thick < MINTHICK)
|
|
thickness = minthickness;
|
|
else
|
|
thickness = Data.p.thick;
|
|
Data.v = rotate90(Data.u) * thickness;
|
|
|
|
LineData.push_back(Data);
|
|
s += step;
|
|
}
|
|
|
|
BlendAndPoint appData;
|
|
|
|
data.clear();
|
|
data.reserve(LineData.size());
|
|
|
|
for (int i = 0; i < m_intensity * LineData.size(); i++) {
|
|
appData.points.clear();
|
|
int start = rnd.getInt(0, LineData.size());
|
|
int end = start + maxlength + rnd.getInt(0, maxlength);
|
|
if (end > (int)LineData.size()) end = LineData.size();
|
|
double halfcount = (end - start) / 2.0;
|
|
double vshift = (0.5 - rnd.getFloat());
|
|
|
|
appData.blend = rnd.getFloat();
|
|
|
|
for (int j = 0; j < (end - start); j++) {
|
|
if (j < halfcount)
|
|
factor = j / halfcount;
|
|
else
|
|
factor = 1 - (j - halfcount) / halfcount;
|
|
appData.points.push_back(
|
|
LineData[j + start].p +
|
|
LineData[j + start].v *
|
|
(vshift -
|
|
strokethick * factor * (1 - m_noise * (1 - rnd.getFloat()))));
|
|
appData.points.push_back(
|
|
LineData[j + start].p +
|
|
LineData[j + start].v *
|
|
(vshift +
|
|
strokethick * factor * (1 - m_noise * (1 - rnd.getFloat()))));
|
|
}
|
|
data.push_back(appData);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TMultiLineStrokeStyle2::drawStroke(const TColorFunction *cf,
|
|
BlendAndPoints &data,
|
|
const TStroke *stroke) const {
|
|
TPixel32 color0, color1;
|
|
if (cf) {
|
|
color0 = (*(cf))(m_color0);
|
|
color1 = (*(cf))(m_color1);
|
|
} else {
|
|
color0 = m_color0;
|
|
color1 = m_color1;
|
|
}
|
|
|
|
glEnable(GL_POLYGON_SMOOTH);
|
|
|
|
for (UINT i = 0; i < data.size(); i++) {
|
|
tglColor(blend(color0, color1, data[i].blend));
|
|
|
|
glBegin(GL_QUAD_STRIP);
|
|
for (UINT j = 0; j < data[i].points.size(); j++)
|
|
tglVertex(data[i].points[j]);
|
|
|
|
glEnd();
|
|
}
|
|
glDisable(GL_POLYGON_SMOOTH);
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TZigzagStrokeStyle::TZigzagStrokeStyle()
|
|
: m_color(TPixel32(0, 0, 0))
|
|
, m_minDist(0.5)
|
|
, m_maxDist(6.0)
|
|
, m_minAngle(30.0)
|
|
, m_maxAngle(60.0)
|
|
, m_thickness(1.0) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TZigzagStrokeStyle::clone() const {
|
|
return new TZigzagStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TZigzagStrokeStyle::getParamCount() const { return 5; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TZigzagStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TZigzagStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 5);
|
|
QString value;
|
|
switch (index) {
|
|
case 0:
|
|
value = QCoreApplication::translate("TZigzagStrokeStyle", "Min Distance");
|
|
break;
|
|
case 1:
|
|
value = QCoreApplication::translate("TZigzagStrokeStyle", "Max Distance");
|
|
break;
|
|
case 2:
|
|
value = QCoreApplication::translate("TZigzagStrokeStyle", "Min Angle");
|
|
break;
|
|
case 3:
|
|
value = QCoreApplication::translate("TZigzagStrokeStyle", "Max Angle");
|
|
break;
|
|
case 4:
|
|
value = QCoreApplication::translate("TZigzagStrokeStyle", "Thickness");
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TZigzagStrokeStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 5);
|
|
switch (index) {
|
|
case 0:
|
|
min = 0.5;
|
|
max = 50.0;
|
|
break;
|
|
case 1:
|
|
min = 0.5;
|
|
max = 50.0;
|
|
break;
|
|
case 2:
|
|
min = -90.0;
|
|
max = 90.0;
|
|
break;
|
|
case 3:
|
|
min = -90.0;
|
|
max = 90.0;
|
|
break;
|
|
case 4:
|
|
min = 0.0;
|
|
max = 3.0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TZigzagStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 5);
|
|
double value = 0;
|
|
switch (index) {
|
|
case 0:
|
|
value = m_minDist;
|
|
break;
|
|
case 1:
|
|
value = m_maxDist;
|
|
break;
|
|
case 2:
|
|
value = m_minAngle;
|
|
break;
|
|
case 3:
|
|
value = m_maxAngle;
|
|
break;
|
|
case 4:
|
|
value = m_thickness;
|
|
break;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TZigzagStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 5);
|
|
switch (index) {
|
|
case 0:
|
|
m_minDist = value;
|
|
break;
|
|
case 1:
|
|
m_maxDist = value;
|
|
break;
|
|
case 2:
|
|
m_minAngle = value;
|
|
break;
|
|
case 3:
|
|
m_maxAngle = value;
|
|
break;
|
|
case 4:
|
|
m_thickness = value;
|
|
break;
|
|
}
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool TZigzagStrokeStyle::getZigZagPosition(const TStroke *stroke, TRandom &rnd,
|
|
const double s, const int first,
|
|
const double minTranslLength,
|
|
TThickPoint &pos,
|
|
TThickPoint &pos1) const {
|
|
double w = stroke->getParameterAtLength(s);
|
|
pos = stroke->getThickPoint(w);
|
|
TPointD u = stroke->getSpeed(w);
|
|
if (norm2(u) < TConsts::epsilon) return false;
|
|
u = normalize(u);
|
|
TPointD uu = u;
|
|
double angle =
|
|
m_minAngle + (m_maxAngle - m_minAngle) * (double)rnd.getUInt(101) * 0.01;
|
|
TRotation rotM(angle);
|
|
u = rotM * u;
|
|
double maxTranslLength = angle == 90 ? 1.0 : 2.0;
|
|
if (angle > 30 && angle < 90) {
|
|
double rta = 1.0 / tan(degree2rad(angle));
|
|
maxTranslLength = sqrt(sq(rta) + 1.0);
|
|
}
|
|
double r =
|
|
(minTranslLength + (maxTranslLength - minTranslLength) * rnd.getFloat()) *
|
|
pos.thick * first;
|
|
pos = pos + r * u;
|
|
pos1 = pos + uu * m_thickness;
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TZigzagStrokeStyle::setRealMinMax() const {
|
|
TZigzagStrokeStyle *ncpthis = const_cast<TZigzagStrokeStyle *>(this);
|
|
double minDist = std::min(m_minDist, m_maxDist);
|
|
double maxDist = std::max(m_minDist, m_maxDist);
|
|
double minAngle = std::min(m_minAngle, m_maxAngle);
|
|
double maxAngle = std::max(m_minAngle, m_maxAngle);
|
|
ncpthis->m_minDist = minDist;
|
|
ncpthis->m_maxDist = maxDist;
|
|
ncpthis->m_minAngle = minAngle;
|
|
ncpthis->m_maxAngle = maxAngle;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TZigzagStrokeStyle::computeData(Points &points, const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
assert(glGetError() == GL_NO_ERROR);
|
|
assert(!!stroke);
|
|
double length = stroke->getLength();
|
|
if (length <= 0) return;
|
|
|
|
setRealMinMax();
|
|
// e.g minimum translation length is the half of the thickness
|
|
const double minTranslLength = 0.7;
|
|
// const bool isTransparent=m_color.m<255;
|
|
|
|
int first = 1;
|
|
TThickPoint pos;
|
|
TThickPoint pos1;
|
|
TRandom rnd;
|
|
|
|
points.clear();
|
|
points.reserve(tceil(length / m_minDist) * 2 + 2);
|
|
|
|
for (double s = 0.0; s <= length; first = -first) {
|
|
if (getZigZagPosition(stroke, rnd, s, first, minTranslLength, pos, pos1)) {
|
|
// TRectD rec(pos.x,pos.y,pos1.x,pos1.y);
|
|
points.push_back(pos);
|
|
points.push_back(pos1);
|
|
}
|
|
s += m_minDist + (m_maxDist - m_minDist) * (double)rnd.getUInt(101) * 0.01;
|
|
}
|
|
if (getZigZagPosition(stroke, rnd, length - TConsts::epsilon, first,
|
|
minTranslLength, pos, pos1)) {
|
|
points.push_back(pos);
|
|
points.push_back(pos1);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TZigzagStrokeStyle::drawStroke(const TColorFunction *cf, Points &points,
|
|
const TStroke *stroke) const {
|
|
if (points.size() <= 1) return;
|
|
TPixel32 color;
|
|
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
|
|
tglColor(m_color);
|
|
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
|
|
glVertexPointer(2, GL_DOUBLE, sizeof(TPointD), &points[0]);
|
|
glDrawArrays(GL_QUAD_STRIP, 0, points.size());
|
|
/*
|
|
glBegin(GL_QUAD_STRIP);
|
|
for(UINT i=0; i<rects.size(); i++)
|
|
{
|
|
tglVertex(rects[i].getP00());
|
|
tglVertex(rects[i].getP11());
|
|
}
|
|
glEnd();
|
|
*/
|
|
|
|
glVertexPointer(2, GL_DOUBLE, sizeof(TPointD) * 2, &points[0]);
|
|
glDrawArrays(GL_LINE_STRIP, 0, points.size() / 2);
|
|
|
|
glVertexPointer(2, GL_DOUBLE, sizeof(TPointD) * 2, &points[1]);
|
|
glDrawArrays(GL_LINE_STRIP, 0, points.size() / 2);
|
|
|
|
glVertexPointer(2, GL_DOUBLE, sizeof(TPointD), &points[0]);
|
|
glDrawArrays(GL_LINES, 0, points.size());
|
|
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
// drawBLines(rects);
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TSinStrokeStyle::TSinStrokeStyle()
|
|
: m_color(TPixel32::Black), m_frequency(10.0), m_thick(0.4) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TSinStrokeStyle::clone() const {
|
|
return new TSinStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TSinStrokeStyle::getParamCount() const { return 2; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TSinStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TSinStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 2);
|
|
return index == 0
|
|
? QCoreApplication::translate("TSinStrokeStyle", "Frequency")
|
|
: QCoreApplication::translate("TZigzTSinStrokeStyleagStrokeStyle",
|
|
"Thickness");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSinStrokeStyle::getParamRange(int index, double &min, double &max) const {
|
|
assert(0 <= index && index < 2);
|
|
if (index == 0) {
|
|
min = 1.0;
|
|
max = 20.0;
|
|
} else {
|
|
min = 0.0;
|
|
max = 1.0;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TSinStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 2);
|
|
return index == 0 ? m_frequency : m_thick;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSinStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 2);
|
|
if (index == 0)
|
|
m_frequency = value;
|
|
else
|
|
m_thick = value;
|
|
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSinStrokeStyle::computeData(Points &positions, const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
double length = stroke->getLength();
|
|
double step = 5.0;
|
|
|
|
positions.clear();
|
|
positions.reserve(tceil((length + 1) / step));
|
|
|
|
double frequency = m_frequency / 100;
|
|
;
|
|
double s = 0;
|
|
// bool firstRing = true;
|
|
double thick = 1 - m_thick;
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
// if(w<0) {s+=0.1; continue;} // per tamponare il baco della
|
|
// getParameterAtLength()
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
TPointD u = stroke->getSpeed(w);
|
|
double normu = norm2(u);
|
|
if (normu == 0) {
|
|
s += 0.1;
|
|
continue;
|
|
} // non dovrebbe succedere mai, ma per prudenza....
|
|
u = normalize(u);
|
|
TPointD v = rotate90(u);
|
|
double sinvalue = sin(frequency * s);
|
|
positions.push_back(pos + v * pos.thick * sinvalue);
|
|
positions.push_back(pos + v * thick * pos.thick * sinvalue);
|
|
s += step;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TSinStrokeStyle::drawStroke(const TColorFunction *cf,
|
|
std::vector<TPointD> &positions,
|
|
const TStroke *stroke) const {
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
tglColor(color);
|
|
|
|
glBegin(GL_QUAD_STRIP);
|
|
int i = 0;
|
|
for (; i < (int)positions.size(); i += 2) {
|
|
tglVertex(positions[i]);
|
|
tglVertex(positions[i + 1]);
|
|
}
|
|
glEnd();
|
|
glBegin(GL_LINE_STRIP);
|
|
for (i = 0; i < (int)positions.size(); i += 2) {
|
|
tglVertex(positions[i]);
|
|
}
|
|
glEnd();
|
|
glBegin(GL_LINE_STRIP);
|
|
for (i = 1; i < (int)positions.size() - 1; i += 2) {
|
|
tglVertex(positions[i]);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TFriezeStrokeStyle2::TFriezeStrokeStyle2()
|
|
: m_color(TPixel32::Black), m_parameter(0.7), m_thick(0.3) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TFriezeStrokeStyle2::clone() const {
|
|
return new TFriezeStrokeStyle2(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TFriezeStrokeStyle2::getParamCount() const { return 2; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TFriezeStrokeStyle2::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TFriezeStrokeStyle2::getParamNames(int index) const {
|
|
assert(0 <= index && index < 2);
|
|
if (index == 0)
|
|
return QCoreApplication::translate("TFriezeStrokeStyle2", "Twirl");
|
|
else
|
|
return QCoreApplication::translate("TFriezeStrokeStyle2", "Thickness");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TFriezeStrokeStyle2::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 2);
|
|
if (index == 0) {
|
|
min = -1.0;
|
|
max = 1.0;
|
|
} else {
|
|
min = 0.0;
|
|
max = 1.0;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TFriezeStrokeStyle2::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 2);
|
|
if (index == 0)
|
|
return m_parameter;
|
|
else
|
|
return m_thick;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TFriezeStrokeStyle2::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 2);
|
|
if (index == 0)
|
|
m_parameter = value;
|
|
else
|
|
m_thick = value;
|
|
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TFriezeStrokeStyle2::loadData(int ids, TInputStreamInterface &is) {
|
|
if (ids != 102)
|
|
throw TException("Frieze stroke style: unknown obsolete format");
|
|
m_thick = 0.0;
|
|
is >> m_color >> m_parameter;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TFriezeStrokeStyle2::computeData(Points &positions, const TStroke *stroke,
|
|
const TColorFunction *cf) const {
|
|
// TStroke *stroke = getStroke();
|
|
double length = stroke->getLength();
|
|
|
|
double ds = 0.5;
|
|
|
|
positions.clear();
|
|
positions.reserve(tceil((length + 1) / ds));
|
|
|
|
double s = 0.01;
|
|
double lastS = 0;
|
|
double phi = 0;
|
|
double lastW = 0;
|
|
double thick = 1 - m_thick;
|
|
vector<TPointD> points;
|
|
while (s <= length) {
|
|
double w = stroke->getParameterAtLength(s);
|
|
if (w < lastW) {
|
|
s += 0.1;
|
|
continue;
|
|
}
|
|
lastW = w;
|
|
TThickPoint pos = stroke->getThickPoint(w);
|
|
TPointD u = normalize(stroke->getSpeed(w));
|
|
TPointD v = rotate90(u);
|
|
|
|
double thickness = pos.thick; // 5; //(1-t)*40 + t * 10;
|
|
|
|
if (thickness > 0) {
|
|
double omega = M_PI / thickness;
|
|
|
|
double q = 0.5 * (1 - cos(phi));
|
|
double theta = M_PI_2 - M_PI * m_parameter * q;
|
|
double r = thickness * sin(phi);
|
|
double r1 = r * thick;
|
|
double costheta = cos(theta);
|
|
double sintheta = sin(theta);
|
|
positions.push_back(pos + u * (r * costheta) + v * (r * sintheta));
|
|
positions.push_back(pos + u * (r1 * costheta) + v * (r1 * sintheta));
|
|
phi += (s - lastS) * omega;
|
|
lastS = s;
|
|
} else {
|
|
positions.push_back(pos);
|
|
positions.push_back(pos);
|
|
}
|
|
|
|
s += ds;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TFriezeStrokeStyle2::drawStroke(const TColorFunction *cf,
|
|
Points &positions,
|
|
const TStroke *stroke) const {
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(m_color);
|
|
else
|
|
color = m_color;
|
|
tglColor(color);
|
|
|
|
glBegin(GL_QUAD_STRIP);
|
|
int i = 0;
|
|
for (; i < (int)positions.size(); i += 2) {
|
|
tglVertex(positions[i]);
|
|
tglVertex(positions[i + 1]);
|
|
}
|
|
glEnd();
|
|
glBegin(GL_LINE_STRIP);
|
|
for (i = 0; i < (int)positions.size(); i += 2) {
|
|
tglVertex(positions[i]);
|
|
}
|
|
glEnd();
|
|
glBegin(GL_LINE_STRIP);
|
|
for (i = 1; i < (int)positions.size() - 1; i += 2) {
|
|
tglVertex(positions[i]);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TDualColorStrokeStyle2::TDualColorStrokeStyle2(TPixel32 color0, TPixel32 color1,
|
|
double parameter)
|
|
: m_color0(color0), m_color1(color1), m_parameter(parameter) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TDualColorStrokeStyle2::clone() const {
|
|
return new TDualColorStrokeStyle2(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TDualColorStrokeStyle2::computeOutline(
|
|
const TStroke *stroke, TStrokeOutline &outline,
|
|
TOutlineUtil::OutlineParameter param) const {
|
|
param.m_lengthStep = m_parameter;
|
|
TOutlineStyle::computeOutline(stroke, outline, param);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TDualColorStrokeStyle2::drawStroke(const TColorFunction *cf,
|
|
TStrokeOutline *outline,
|
|
const TStroke *stroke) const {
|
|
UINT i;
|
|
const std::vector<TOutlinePoint> &v = outline->getArray();
|
|
TPixel32 colorv[2];
|
|
|
|
if (cf) {
|
|
colorv[0] = (*(cf))(m_color0);
|
|
colorv[1] = (*(cf))(m_color1);
|
|
} else {
|
|
colorv[0] = m_color0;
|
|
colorv[1] = m_color1;
|
|
}
|
|
int colorindex = 0;
|
|
if (v.empty()) return;
|
|
glBegin(GL_LINE_STRIP);
|
|
tglColor(colorv[0]);
|
|
for (i = 0; i < v.size(); i += 2) {
|
|
glVertex2dv(&v[i].x);
|
|
if (0 != v[i].stepCount) {
|
|
colorindex++;
|
|
tglColor(colorv[colorindex & 1]);
|
|
glVertex2dv(&v[i].x);
|
|
}
|
|
}
|
|
glEnd();
|
|
|
|
colorindex = 0;
|
|
glBegin(GL_LINE_STRIP);
|
|
tglColor(colorv[0]);
|
|
for (i = 1; i < v.size(); i += 2) {
|
|
glVertex2dv(&v[i].x);
|
|
if (0 != v[i].stepCount) {
|
|
colorindex++;
|
|
tglColor(colorv[colorindex & 1]);
|
|
glVertex2dv(&v[i].x);
|
|
}
|
|
}
|
|
glEnd();
|
|
|
|
colorindex = 0;
|
|
glBegin(GL_QUAD_STRIP);
|
|
tglColor(colorv[0]);
|
|
for (i = 0; i < v.size(); i += 2) {
|
|
glVertex2dv(&v[i].x);
|
|
glVertex2dv(&v[i + 1].x);
|
|
if (0 != v[i].stepCount) {
|
|
colorindex++;
|
|
tglColor(colorv[colorindex & 1]);
|
|
glVertex2dv(&v[i].x);
|
|
glVertex2dv(&v[i + 1].x);
|
|
}
|
|
}
|
|
glEnd();
|
|
|
|
// antialias delle linee normali
|
|
tglColor(colorv[0]);
|
|
for (i = 0; i < v.size(); i += 2) {
|
|
if (0 != v[i].stepCount) {
|
|
glBegin(GL_LINES);
|
|
glVertex2dv(&v[i].x);
|
|
glVertex2dv(&v[i + 1].x);
|
|
glEnd();
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TDualColorStrokeStyle2::getParamCount() const { return 1; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TDualColorStrokeStyle2::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TDualColorStrokeStyle2::getParamNames(int index) const {
|
|
assert(0 <= index && index < 1);
|
|
|
|
return QCoreApplication::translate("TDualColorStrokeStyle2", "Distance");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TDualColorStrokeStyle2::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 1);
|
|
min = 1.0;
|
|
max = 100.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TDualColorStrokeStyle2::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 1);
|
|
return m_parameter;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TDualColorStrokeStyle2::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 1);
|
|
m_parameter = value;
|
|
updateVersionNumber(); // questo si chiama per ogno cambiamento di parametro
|
|
// per cui di deve ricalcolare l'outline
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TLongBlendStrokeStyle2::TLongBlendStrokeStyle2(TPixel32 color0, TPixel32 color1,
|
|
double parameter)
|
|
: m_color0(color0), m_color1(color1), m_parameter(parameter) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TLongBlendStrokeStyle2::clone() const {
|
|
return new TLongBlendStrokeStyle2(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TLongBlendStrokeStyle2::computeOutline(
|
|
const TStroke *stroke, TStrokeOutline &outline,
|
|
TOutlineUtil::OutlineParameter param) const {
|
|
param.m_lengthStep = m_parameter;
|
|
TOutlineStyle::computeOutline(stroke, outline, param);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TLongBlendStrokeStyle2::drawStroke(const TColorFunction *cf,
|
|
TStrokeOutline *outline,
|
|
const TStroke *stroke) const {
|
|
TPixel32 color0, color1;
|
|
if (cf) {
|
|
color0 = (*(cf))(m_color0);
|
|
color1 = (*(cf))(m_color1);
|
|
} else {
|
|
color0 = m_color0;
|
|
color1 = m_color1;
|
|
}
|
|
UINT i;
|
|
|
|
const std::vector<TOutlinePoint> &v = outline->getArray();
|
|
if (v.empty()) return;
|
|
|
|
// outline with antialiasing
|
|
glBegin(GL_LINE_STRIP);
|
|
int mystepCount = 0;
|
|
|
|
double totallength = stroke->getLength();
|
|
double ntick = totallength / m_parameter + 1;
|
|
tglColor(color0);
|
|
for (i = 0; i < v.size(); i += 2) {
|
|
if (0 != v[i].stepCount) {
|
|
tglColor(blend(color0, color1, (double)mystepCount / ntick));
|
|
mystepCount++;
|
|
}
|
|
glVertex2dv(&v[i].x);
|
|
}
|
|
glEnd();
|
|
|
|
glBegin(GL_LINE_STRIP);
|
|
mystepCount = 0;
|
|
tglColor(color0);
|
|
for (i = 1; i < v.size(); i += 2) {
|
|
if (0 != v[i].stepCount) {
|
|
tglColor(blend(color0, color1, (double)mystepCount / ntick));
|
|
mystepCount++;
|
|
}
|
|
glVertex2dv(&v[i].x);
|
|
}
|
|
glEnd();
|
|
|
|
glBegin(GL_QUAD_STRIP);
|
|
mystepCount = 0;
|
|
tglColor(color0);
|
|
for (i = 0; i < v.size(); i += 2) {
|
|
if (0 != v[i].stepCount) {
|
|
tglColor(blend(color0, color1, (double)mystepCount / ntick));
|
|
mystepCount++;
|
|
}
|
|
glVertex2dv(&v[i].x);
|
|
glVertex2dv(&v[i + 1].x);
|
|
}
|
|
glEnd();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TLongBlendStrokeStyle2::getParamCount() const { return 1; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TLongBlendStrokeStyle2::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TLongBlendStrokeStyle2::getParamNames(int index) const {
|
|
assert(0 <= index && index < 1);
|
|
|
|
return QCoreApplication::translate("TLongBlendStrokeStyle2",
|
|
"Distance"); // W_Watercolor_Distance
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TLongBlendStrokeStyle2::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 1);
|
|
min = 0.1;
|
|
max = 100.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TLongBlendStrokeStyle2::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 1);
|
|
return m_parameter;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TLongBlendStrokeStyle2::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 1);
|
|
m_parameter = value;
|
|
updateVersionNumber(); // questo si chiama per ogno cambiamento di parametro
|
|
// per cui di deve ricalcolare l'outline
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
#ifdef _DEBUG
|
|
|
|
OutlineViewerStyle::OutlineViewerStyle(TPixel32 color, double parameter0,
|
|
double parameter1, double parameter2,
|
|
double parameter3)
|
|
: TSolidColorStyle(color)
|
|
, m_boolPar(false)
|
|
, m_intPar(1)
|
|
, m_enumPar(2)
|
|
, m_pathPar("testPath") {
|
|
m_parameter[0] = parameter0;
|
|
m_parameter[1] = parameter1;
|
|
m_parameter[2] = parameter2;
|
|
m_parameter[3] = parameter3;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *OutlineViewerStyle::clone() const {
|
|
return new OutlineViewerStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int OutlineViewerStyle::getParamCount() const { return 8; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType OutlineViewerStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
static const TColorStyle::ParamType types[8] = {
|
|
TColorStyle::DOUBLE, TColorStyle::DOUBLE, TColorStyle::DOUBLE,
|
|
TColorStyle::DOUBLE, TColorStyle::BOOL, TColorStyle::INT,
|
|
TColorStyle::ENUM, TColorStyle::FILEPATH};
|
|
|
|
return types[index];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString OutlineViewerStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 8);
|
|
|
|
switch (index) {
|
|
case 0:
|
|
return QCoreApplication::translate("OutlineViewerStyle", "Control Point");
|
|
case 1:
|
|
return QCoreApplication::translate("OutlineViewerStyle", "Center Line");
|
|
case 2:
|
|
return QCoreApplication::translate("OutlineViewerStyle", "Outline Mode");
|
|
case 3:
|
|
return QCoreApplication::translate("OutlineViewerStyle", "Distance");
|
|
case 4:
|
|
return "Bool";
|
|
case 5:
|
|
return "Int";
|
|
case 6:
|
|
return "Enum";
|
|
case 7:
|
|
return "Path";
|
|
}
|
|
|
|
assert(0);
|
|
return QCoreApplication::translate("OutlineViewerStyle", "distance");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void OutlineViewerStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 4);
|
|
switch (index) {
|
|
case 0:
|
|
min = 0.0;
|
|
max = 2.99;
|
|
break;
|
|
case 1:
|
|
min = 0.0;
|
|
max = 1.99;
|
|
break;
|
|
case 2:
|
|
min = 0.0;
|
|
max = 3.99;
|
|
break;
|
|
case 3:
|
|
min = 3.0;
|
|
max = 100.0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void OutlineViewerStyle::getParamRange(int index, int &min, int &max) const {
|
|
assert(5 <= index && index < 7);
|
|
switch (index) {
|
|
case 5:
|
|
min = 0, max = 10;
|
|
break;
|
|
case 6:
|
|
min = 0, max = 4;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void OutlineViewerStyle::getParamRange(int index,
|
|
QStringList &enumItems) const {
|
|
enumItems << "Prova 1"
|
|
<< "Prova 2"
|
|
<< "Prova 3"
|
|
<< "Prova 4";
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool OutlineViewerStyle::getParamValue(TColorStyle::bool_tag, int index) const {
|
|
assert(index == 4);
|
|
return m_boolPar;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int OutlineViewerStyle::getParamValue(TColorStyle::int_tag, int index) const {
|
|
assert(5 <= index && index < 7);
|
|
return (index == 5) ? m_intPar : m_enumPar;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double OutlineViewerStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 4);
|
|
return m_parameter[index];
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TFilePath OutlineViewerStyle::getParamValue(TColorStyle::TFilePath_tag,
|
|
int index) const {
|
|
assert(index == 7);
|
|
return m_pathPar;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void OutlineViewerStyle::setParamValue(int index, bool value) {
|
|
assert(index == 4);
|
|
m_boolPar = value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void OutlineViewerStyle::setParamValue(int index, int value) {
|
|
assert(5 <= index && index < 7);
|
|
(index == 5) ? m_intPar = value : m_enumPar = value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void OutlineViewerStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 4);
|
|
|
|
if (index >= 2 && (int)m_parameter[index] != (int)value) // cambia l'outline
|
|
{
|
|
updateVersionNumber();
|
|
}
|
|
|
|
m_parameter[index] = value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void OutlineViewerStyle::setParamValue(int index, const TFilePath &value) {
|
|
assert(index == 7);
|
|
m_pathPar = value;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void OutlineViewerStyle::loadData(TInputStreamInterface &is) {
|
|
TPixel32 color;
|
|
is >> color;
|
|
TSolidColorStyle::setMainColor(color);
|
|
is >> m_parameter[0];
|
|
is >> m_parameter[1];
|
|
is >> m_parameter[2];
|
|
is >> m_parameter[3];
|
|
|
|
int boolPar;
|
|
is >> boolPar;
|
|
m_boolPar = boolPar;
|
|
is >> m_intPar;
|
|
is >> m_enumPar;
|
|
std::string str;
|
|
is >> str;
|
|
m_pathPar = TFilePath(::to_wstring(str));
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void OutlineViewerStyle::saveData(TOutputStreamInterface &os) const {
|
|
os << TSolidColorStyle::getMainColor();
|
|
os << m_parameter[0];
|
|
os << m_parameter[1];
|
|
os << m_parameter[2];
|
|
os << m_parameter[3];
|
|
|
|
os << int(m_boolPar);
|
|
os << m_intPar;
|
|
os << m_enumPar;
|
|
os << ::to_string(m_pathPar.getWideString());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void OutlineViewerStyle::computeOutline(
|
|
const TStroke *stroke, TStrokeOutline &outline,
|
|
TOutlineUtil::OutlineParameter param) const {
|
|
if (m_parameter[2] >= 1.0) {
|
|
param.m_lengthStep = (m_parameter[2] >= 3.0) ? m_parameter[3] : 0;
|
|
|
|
TOutlineStyle::computeOutline(stroke, outline, param);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
namespace {
|
|
|
|
void drawOutline(TStrokeOutline *outline, bool cut) {
|
|
const std::vector<TOutlinePoint> &v = outline->getArray();
|
|
|
|
if (v.empty()) return;
|
|
|
|
UINT i;
|
|
// outline with antialiasing
|
|
glBegin(GL_LINE_STRIP);
|
|
for (i = 0; i < v.size(); i += 2) glVertex2dv(&v[i].x);
|
|
glEnd();
|
|
|
|
glBegin(GL_LINE_STRIP);
|
|
for (i = 1; i < v.size(); i += 2) glVertex2dv(&v[i].x);
|
|
glEnd();
|
|
|
|
if (cut) {
|
|
static const int stride = sizeof(TOutlinePoint);
|
|
glEnableClientState(GL_VERTEX_ARRAY);
|
|
glVertexPointer(2, GL_DOUBLE, stride, &v[0]);
|
|
glDrawArrays(GL_LINES, 0, v.size());
|
|
glDisableClientState(GL_VERTEX_ARRAY);
|
|
}
|
|
}
|
|
|
|
void drawControlPoints(const TStroke *stroke, bool allPoints) {
|
|
int i;
|
|
TPointD p;
|
|
glPointSize(4.0);
|
|
glBegin(GL_POINTS);
|
|
|
|
if (allPoints) {
|
|
int n = stroke->getControlPointCount();
|
|
for (i = 0; i < n; ++i) {
|
|
p = stroke->getControlPoint(i);
|
|
glColor3d((i + 1) & 1, i & 1, 0.0);
|
|
glVertex2d(p.x, p.y);
|
|
}
|
|
} else {
|
|
int n = stroke->getChunkCount();
|
|
for (i = 0; i < n; ++i) {
|
|
const TThickQuadratic *chunk = stroke->getChunk(i);
|
|
p = chunk->getP0();
|
|
glColor3d(1.0, 0.0, 0.0);
|
|
glVertex2d(p.x, p.y);
|
|
}
|
|
const TThickQuadratic *chunk = stroke->getChunk(n - 1);
|
|
glColor3d(1.0, 0.0, 0.0);
|
|
p = chunk->getP2();
|
|
glVertex2d(p.x, p.y);
|
|
}
|
|
|
|
glEnd();
|
|
}
|
|
|
|
void drawCenterline(const TStroke *stroke) {
|
|
glBegin(GL_LINE_STRIP);
|
|
int n = stroke->getChunkCount();
|
|
int i = 0;
|
|
for (i = 0; i < n; ++i) {
|
|
const TThickQuadratic *chunk = stroke->getChunk(i);
|
|
double length = chunk->getLength(0, 1);
|
|
int maxCount = std::max(tceil(length / (5 * sqrt(tglGetPixelSize2()))), 1);
|
|
double deltaT = 1.0 / maxCount;
|
|
double t = 0;
|
|
for (t = 0; t < 1 + (deltaT / 2); t += deltaT) {
|
|
TPointD point = chunk->getPoint(t);
|
|
glVertex2d(point.x, point.y);
|
|
}
|
|
}
|
|
glEnd();
|
|
return;
|
|
}
|
|
}
|
|
//------------------------------------------------------------
|
|
|
|
void OutlineViewerStyle::drawStroke(const TColorFunction *cf,
|
|
TStrokeOutline *outline,
|
|
const TStroke *stroke) const {
|
|
TPixel32 color;
|
|
if (cf)
|
|
color = (*(cf))(getMainColor());
|
|
else
|
|
color = getMainColor();
|
|
|
|
tglColor(color);
|
|
|
|
if (m_parameter[1] >= 1.0) drawCenterline(stroke);
|
|
|
|
if (m_parameter[2] >= 1.0) drawOutline(outline, m_parameter[2] >= 2.0);
|
|
|
|
if (m_parameter[0] >= 1.0) drawControlPoints(stroke, m_parameter[0] >= 2.0);
|
|
}
|
|
|
|
#endif
|
|
|
|
//=============================================================================
|
|
|
|
TMatrioskaStrokeProp::TMatrioskaStrokeProp(const TStroke *stroke,
|
|
TMatrioskaStrokeStyle *style)
|
|
: TStrokeProp(stroke)
|
|
, m_colorStyle(style)
|
|
, m_outline()
|
|
, m_outlinePixelSize(0) {
|
|
m_styleVersionNumber = m_colorStyle->getVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStrokeProp *TMatrioskaStrokeProp::clone(const TStroke *stroke) const {
|
|
TMatrioskaStrokeProp *prop = new TMatrioskaStrokeProp(stroke, m_colorStyle);
|
|
prop->m_strokeChanged = m_strokeChanged;
|
|
prop->m_outline = m_outline;
|
|
prop->m_outlinePixelSize = m_outlinePixelSize;
|
|
return prop;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
const TColorStyle *TMatrioskaStrokeProp::getColorStyle() const {
|
|
return m_colorStyle;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace {
|
|
void recomputeStrokes(const TStroke *stroke, vector<TStroke *> &strokes,
|
|
int strokeNumber) {
|
|
clearPointerContainer(strokes);
|
|
|
|
strokes.resize(strokeNumber);
|
|
|
|
int nCP = stroke->getControlPointCount();
|
|
|
|
double reduction;
|
|
|
|
for (int strokeId = 0; strokeId != strokeNumber; strokeId++) {
|
|
strokes[strokeId] = new TStroke(*stroke);
|
|
|
|
reduction = ((double)strokeId + 0.5) / (double)(strokeNumber + 0.5);
|
|
|
|
for (int i = 0; i < nCP; i++) {
|
|
TThickPoint tp = strokes[strokeId]->getControlPoint(i);
|
|
tp.thick *= reduction;
|
|
strokes[strokeId]->setControlPoint(i, tp);
|
|
}
|
|
}
|
|
}
|
|
|
|
void recomputeOutlines(const TStroke *stroke, vector<TStroke *> &strokes,
|
|
vector<TStrokeOutline> &outlines,
|
|
const TSolidColorStyle *style) {
|
|
TOutlineUtil::OutlineParameter param;
|
|
int strokeNumber = strokes.size();
|
|
outlines.resize(strokeNumber + 1);
|
|
int strokeId;
|
|
for (strokeId = 0; strokeId != strokeNumber; strokeId++) {
|
|
outlines[strokeId].getArray().clear();
|
|
style->computeOutline(strokes[strokeId], outlines[strokeId], param);
|
|
}
|
|
outlines[strokeId].getArray().clear();
|
|
style->computeOutline(stroke, outlines[strokeId], param);
|
|
}
|
|
};
|
|
|
|
void TMatrioskaStrokeProp::draw(const TVectorRenderData &rd) {
|
|
if (rd.m_clippingRect != TRect() && !rd.m_is3dView &&
|
|
!convert(rd.m_aff * m_stroke->getBBox()).overlaps(rd.m_clippingRect))
|
|
return;
|
|
|
|
int strokeId;
|
|
glPushMatrix();
|
|
tglMultMatrix(rd.m_aff);
|
|
|
|
double pixelSize = sqrt(tglGetPixelSize2());
|
|
int strokeNumber =
|
|
(int)(m_colorStyle->getParamValue(TColorStyle::double_tag(), 0)) - 1;
|
|
|
|
if (m_strokeChanged || (UINT)strokeNumber != m_appStrokes.size()) {
|
|
m_strokeChanged = false;
|
|
m_outlinePixelSize = pixelSize;
|
|
recomputeStrokes(m_stroke, m_appStrokes, strokeNumber);
|
|
recomputeOutlines(m_stroke, m_appStrokes, m_outline, m_colorStyle);
|
|
} else if (!isAlmostZero(pixelSize - m_outlinePixelSize, 1e-5)
|
|
// || m_styleVersionNumber != m_colorStyle->getVersionNumber()
|
|
) {
|
|
m_strokeChanged = false;
|
|
m_outlinePixelSize = pixelSize;
|
|
recomputeOutlines(m_stroke, m_appStrokes, m_outline, m_colorStyle);
|
|
}
|
|
|
|
m_colorStyle->drawStroke(rd.m_cf, &m_outline[m_appStrokes.size()], m_stroke);
|
|
|
|
TSolidColorStyle appStyle(m_colorStyle->getColorParamValue(1));
|
|
|
|
// if(m_colorStyle->isAlternate())
|
|
// {
|
|
|
|
for (strokeId = strokeNumber - 1; strokeId >= 0; strokeId--) {
|
|
if ((m_appStrokes.size() - strokeId) & 1)
|
|
appStyle.drawStroke(rd.m_cf, &m_outline[strokeId],
|
|
m_appStrokes[strokeId]);
|
|
else
|
|
m_colorStyle->drawStroke(rd.m_cf, &m_outline[strokeId],
|
|
m_appStrokes[strokeId]);
|
|
}
|
|
|
|
// }
|
|
// else
|
|
// {
|
|
// TPixel32 color0=m_colorStyle->getColorParamValue(0);
|
|
// TPixel32 color1=m_colorStyle->getColorParamValue(1);
|
|
|
|
// for(strokeId=strokeNumber-1; strokeId>=0;strokeId--)
|
|
// {
|
|
// double r2=(double)strokeId/(double)(strokeNumber);
|
|
// double r1=1-r2;
|
|
// TPixel32 color((int)(color0.r*r2+color1.r*r1),
|
|
// (int)(color0.g*r2+color1.g*r1),
|
|
// (int)(color0.b*r2+color1.b*r1),
|
|
// (int)(color0.m*r2+color1.m*r1)
|
|
// );
|
|
|
|
// appStyle.setMainColor(color);
|
|
// appStyle.drawStroke(rd.m_cf,
|
|
// &m_outline[strokeId],m_appStrokes[strokeId]);
|
|
// }
|
|
|
|
// }
|
|
|
|
glPopMatrix();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TMatrioskaStrokeProp::~TMatrioskaStrokeProp() {
|
|
clearPointerContainer(m_appStrokes);
|
|
}
|
|
|
|
//=============================================================================
|
|
|
|
TMatrioskaStrokeStyle::TMatrioskaStrokeStyle(TPixel32 color1, TPixel32 color2,
|
|
double parameter, bool alternate)
|
|
: TSolidColorStyle(color1), m_color2(color2), m_parameter(parameter) {}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle *TMatrioskaStrokeStyle::clone() const {
|
|
return new TMatrioskaStrokeStyle(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TStrokeProp *TMatrioskaStrokeStyle::makeStrokeProp(const TStroke *stroke) {
|
|
return new TMatrioskaStrokeProp(stroke, this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
int TMatrioskaStrokeStyle::getParamCount() const { return 1; }
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TColorStyle::ParamType TMatrioskaStrokeStyle::getParamType(int index) const {
|
|
assert(0 <= index && index < getParamCount());
|
|
return TColorStyle::DOUBLE;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString TMatrioskaStrokeStyle::getParamNames(int index) const {
|
|
assert(0 <= index && index < 1);
|
|
|
|
// if(index)
|
|
// return "alter/gradual";
|
|
// else
|
|
|
|
return QCoreApplication::translate("TMatrioskaStrokeStyle", "Stripes");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TMatrioskaStrokeStyle::getParamRange(int index, double &min,
|
|
double &max) const {
|
|
assert(0 <= index && index < 1);
|
|
|
|
// if(index)
|
|
// {
|
|
// min = 0;
|
|
// max = 1;
|
|
// }
|
|
// else
|
|
// {
|
|
|
|
min = 1.0;
|
|
max = 10.0;
|
|
//}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
double TMatrioskaStrokeStyle::getParamValue(TColorStyle::double_tag,
|
|
int index) const {
|
|
assert(0 <= index && index < 1);
|
|
|
|
// if(index)
|
|
// return (m_alternate)? 0 : 1;
|
|
// else
|
|
|
|
return m_parameter;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TMatrioskaStrokeStyle::setParamValue(int index, double value) {
|
|
assert(0 <= index && index < 1);
|
|
|
|
// if(index)
|
|
// m_alternate = value<0.5;
|
|
// else
|
|
|
|
m_parameter = value;
|
|
|
|
updateVersionNumber();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TPixel32 TMatrioskaStrokeStyle::getColorParamValue(int index) const {
|
|
assert(0 <= index && index < 2);
|
|
TPixel32 tmp;
|
|
switch (index) {
|
|
case (0):
|
|
tmp = TSolidColorStyle::getMainColor();
|
|
break;
|
|
case (1):
|
|
tmp = m_color2;
|
|
break;
|
|
}
|
|
return tmp;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void TMatrioskaStrokeStyle::setColorParamValue(int index,
|
|
const TPixel32 &color) {
|
|
assert(0 <= index && index < 2);
|
|
switch (index) {
|
|
case (0):
|
|
TSolidColorStyle::setMainColor(color);
|
|
break;
|
|
case (1):
|
|
m_color2 = color;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void TMatrioskaStrokeStyle::loadData(TInputStreamInterface &is) {
|
|
TSolidColorStyle::loadData(is);
|
|
is >> m_parameter;
|
|
is >> m_color2;
|
|
}
|
|
|
|
//------------------------------------------------------------
|
|
|
|
void TMatrioskaStrokeStyle::saveData(TOutputStreamInterface &os) const {
|
|
TSolidColorStyle::saveData(os);
|
|
os << m_parameter;
|
|
os << m_color2;
|
|
}
|