3bfa549e8b
- using std::string; - using std::wstring; - using std::ostream; - using std::istream; - using std::iostream; - using std::ostrstream; - using std::istrstream; - using std::fstream;
531 lines
11 KiB
C++
531 lines
11 KiB
C++
#include "ext/OverallDesigner.h"
|
|
//#include "ext/StrokeParametricDeformer.h"
|
|
#include "ext/StrokeDeformation.h"
|
|
#include "ext/SmoothDeformation.h"
|
|
#include "ext/CornerDeformation.h"
|
|
#include "ext/StraightCornerDeformation.h"
|
|
#include "ext/Selector.h"
|
|
#include "ext/ContextStatus.h"
|
|
|
|
#include "tcurves.h"
|
|
|
|
#include <tstroke.h>
|
|
#include <tgl.h>
|
|
#include <tgeometry.h>
|
|
#include <drawutil.h>
|
|
#include <sstream>
|
|
|
|
/*
|
|
#ifdef _DEBUG
|
|
#undef _DEBUG
|
|
#define RESTORE_DEBUG
|
|
#endif
|
|
//*/
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace
|
|
{
|
|
void extglDrawText(const TPointD &p,
|
|
const std::string &s,
|
|
void *character = GLUT_BITMAP_TIMES_ROMAN_10)
|
|
{
|
|
glPushMatrix();
|
|
glTranslated(p.x, p.y, 0);
|
|
if (character <= GLUT_STROKE_MONO_ROMAN) {
|
|
double factor = 0.07;
|
|
glScaled(factor, factor, factor);
|
|
for (int i = 0; i < (int)s.size(); i++)
|
|
glutStrokeCharacter(character, s[i]);
|
|
} else
|
|
for (int i = 0; i < (int)s.size(); i++)
|
|
glutBitmapCharacter(character, s[i]);
|
|
|
|
glPopMatrix();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void drawSign(const TPointD &p,
|
|
const TPointD &v,
|
|
double size)
|
|
{
|
|
if (size == 0.0)
|
|
return;
|
|
size = fabs(size);
|
|
|
|
TPointD v90 = rotate90(v);
|
|
TPointD v270 = rotate270(v);
|
|
|
|
glBegin(GL_LINES);
|
|
glVertex2d(p.x, p.y);
|
|
v90 = normalize(v90);
|
|
v90 = v90 * size;
|
|
v90 = p + v90;
|
|
glVertex2d(v90.x, v90.y);
|
|
glEnd();
|
|
glBegin(GL_LINES);
|
|
glVertex2d(p.x, p.y);
|
|
v270 = normalize(v270);
|
|
v270 = v270 * size;
|
|
v270 = p + v270;
|
|
glVertex2d(v270.x, v270.y);
|
|
glEnd();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void drawCross(const TPointD &p,
|
|
double size)
|
|
{
|
|
TPointD
|
|
v1 = TPointD(1, 1);
|
|
TPointD
|
|
v2 = TPointD(1, -1);
|
|
|
|
drawSign(p, v1, size);
|
|
drawSign(p, v2, size);
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
/**
|
|
* Try to verify if it is possible to call
|
|
* some method of this stroke.
|
|
*/
|
|
bool isValid(const TStroke *s)
|
|
{
|
|
if (!s)
|
|
return false;
|
|
const int
|
|
cpCount = s->getControlPointCount();
|
|
int
|
|
i;
|
|
for (i = 0;
|
|
i < cpCount;
|
|
++i)
|
|
s->getControlPoint(i);
|
|
const int
|
|
chunkCount = s->getChunkCount();
|
|
for (i = 0;
|
|
i < chunkCount;
|
|
++i)
|
|
s->getChunk(i);
|
|
return true;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void showCP(const TStroke *s,
|
|
double pixelSize)
|
|
{
|
|
if (!s)
|
|
return;
|
|
|
|
// show control points
|
|
const int
|
|
countCP = s->getControlPointCount();
|
|
TThickPoint
|
|
p1;
|
|
|
|
for (int i = 0;
|
|
i < countCP;
|
|
++i) {
|
|
p1 = s->getControlPoint(i);
|
|
if (i & 1)
|
|
glColor3d(1.0, 0.0, 0.0);
|
|
else
|
|
glColor3d(1.0, 1.0, 0.0);
|
|
|
|
drawCross(convert(p1),
|
|
p1.thick * pixelSize);
|
|
tglDrawCircle(convert(p1),
|
|
p1.thick * pixelSize);
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void drawStrokeCenterLine(const TStroke *stroke,
|
|
double pixelSize,
|
|
const ToonzExt::Interval &vals)
|
|
{
|
|
double
|
|
from = vals.first,
|
|
to = vals.second;
|
|
|
|
if (!stroke ||
|
|
pixelSize < 0.0)
|
|
return;
|
|
|
|
from = std::max(std::min(from, 1.0), 0.0);
|
|
to = std::max(std::min(to, 1.0), 0.0);
|
|
|
|
if (from < to) {
|
|
drawStrokeCenterline(*stroke,
|
|
pixelSize,
|
|
from,
|
|
to);
|
|
} else {
|
|
drawStrokeCenterline(*stroke,
|
|
pixelSize,
|
|
from,
|
|
1.0);
|
|
drawStrokeCenterline(*stroke,
|
|
pixelSize,
|
|
0.0,
|
|
to);
|
|
}
|
|
tglDrawDisk(stroke->getPoint(from),
|
|
5.0 * pixelSize);
|
|
tglDrawDisk(stroke->getPoint(to),
|
|
5.0 * pixelSize);
|
|
|
|
#ifdef _DEBUG
|
|
glColor3d(1.0, 0.0, 0.0);
|
|
tglDrawDisk(stroke->getPoint(0.0),
|
|
9.0 * pixelSize);
|
|
#endif
|
|
}
|
|
|
|
//---------------------------------------------------------------------------
|
|
|
|
void showCorners(const TStroke *s,
|
|
int cornerSize,
|
|
double pixelSize)
|
|
{
|
|
if (!s)
|
|
return;
|
|
|
|
const TPointD
|
|
offset(20, 20);
|
|
|
|
// show corners
|
|
std::vector<double>
|
|
corners;
|
|
|
|
ToonzExt::cornersDetector(s,
|
|
cornerSize,
|
|
corners);
|
|
if (corners.empty())
|
|
return;
|
|
|
|
int
|
|
i,
|
|
size = corners.size();
|
|
|
|
glColor3d(0.8, 1.0, 0.3);
|
|
// find interval with corner like extremes
|
|
for (i = 0;
|
|
i < size;
|
|
++i) {
|
|
double
|
|
tmp = corners[i];
|
|
TPointD
|
|
pnt = s->getPoint(tmp);
|
|
double
|
|
large = 5.0;
|
|
drawCross(pnt,
|
|
large * pixelSize);
|
|
|
|
glColor3d(0.7, 0.7, 0.7);
|
|
std::ostringstream oss;
|
|
oss << "[" << tmp << "]";
|
|
extglDrawText(TPointD(pnt.x, pnt.y) + offset, oss.str());
|
|
}
|
|
|
|
corners.clear();
|
|
|
|
ToonzExt::straightCornersDetector(s,
|
|
corners);
|
|
if (corners.empty())
|
|
return;
|
|
|
|
size = corners.size();
|
|
glColor3d(0.8, 1.0, 0.3);
|
|
// find interval with corner like extremes
|
|
for (i = 0;
|
|
i < size;
|
|
++i) {
|
|
double
|
|
tmp = corners[i];
|
|
TPointD
|
|
pnt = s->getPoint(tmp);
|
|
double
|
|
large = 5.0;
|
|
drawCross(pnt,
|
|
large * pixelSize);
|
|
|
|
glColor3d(0.7, 0.2, 0.2);
|
|
std::ostringstream oss;
|
|
oss << "[" << tmp << "]";
|
|
extglDrawText(TPointD(pnt.x, pnt.y) - offset, oss.str());
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ToonzExt::OverallDesigner::OverallDesigner(int x,
|
|
int y)
|
|
: x_(x), y_(y)
|
|
{
|
|
pixelSize_ = sqrt(this->getPixelSize2());
|
|
scale_ = pixelSize_ != 0.0 ? pixelSize_ : 1.0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ToonzExt::OverallDesigner::~OverallDesigner()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ToonzExt::OverallDesigner::draw(ToonzExt::SmoothDeformation *sd)
|
|
{
|
|
#ifdef _DEBUG
|
|
glPushMatrix();
|
|
{
|
|
this->setPosition();
|
|
TCubic c;
|
|
c.setP0(TPointD(0.0, 0.0));
|
|
c.setP1(TPointD(4.0, 12.0));
|
|
c.setP2(TPointD(12.0, 12.0));
|
|
c.setP3(TPointD(16.0, 0.0));
|
|
glColor3d(1.0, 0.0, 1.0);
|
|
tglDraw(c, 100, GL_LINE);
|
|
}
|
|
glPopMatrix();
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ToonzExt::OverallDesigner::draw(ToonzExt::CornerDeformation *sd)
|
|
{
|
|
#ifdef _DEBUG
|
|
glPushMatrix();
|
|
{
|
|
this->setPosition();
|
|
TCubic c;
|
|
c.setP0(TPointD(0.0, 0.0));
|
|
c.setP1(TPointD(0.0, 12.0));
|
|
c.setP2(TPointD(6.0, 12.0));
|
|
c.setP3(TPointD(12.0, 12.0));
|
|
glColor3d(1.0, 0.0, 1.0);
|
|
tglDraw(c, 100, GL_LINE);
|
|
c.setP0(TPointD(12.0, 12.0));
|
|
c.setP1(TPointD(6.0, 8.0));
|
|
c.setP2(TPointD(6.0, 4.0));
|
|
c.setP3(TPointD(12.0, 0.0));
|
|
tglDraw(c, 100, GL_LINE);
|
|
}
|
|
glPopMatrix();
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ToonzExt::OverallDesigner::draw(ToonzExt::StraightCornerDeformation *sd)
|
|
{
|
|
#ifdef _DEBUG
|
|
glPushMatrix();
|
|
{
|
|
this->setPosition();
|
|
glColor3d(0.0, 1.0, 1.0);
|
|
glBegin(GL_LINE_STRIP);
|
|
tglVertex(TPointD(0.0, 0.0));
|
|
tglVertex(TPointD(8.0, 12.0));
|
|
tglVertex(TPointD(16.0, 0.0));
|
|
glEnd();
|
|
}
|
|
glPopMatrix();
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ToonzExt::OverallDesigner::draw(ToonzExt::StrokeDeformation *sd)
|
|
{
|
|
if (sd) {
|
|
const TStroke *
|
|
s;
|
|
|
|
//glColor3d(1.0,0.0,1.0);
|
|
s = sd->getCopiedStroke();
|
|
if (s) {
|
|
const ContextStatus *
|
|
status = sd->getStatus();
|
|
double
|
|
w = 0.0,
|
|
pixelSize = 1.0;
|
|
|
|
if (status) {
|
|
w = status->w_;
|
|
pixelSize = status->pixelSize_ < 0 ? 1.0 : status->pixelSize_;
|
|
}
|
|
#ifdef _DEBUG
|
|
drawCross(s->getPoint(0),
|
|
2 * pixelSize);
|
|
|
|
tglDrawCircle(s->getPoint(w), 8 * pixelSize);
|
|
drawCross(s->getPoint(w), 8 * pixelSize);
|
|
#endif
|
|
ToonzExt::Interval
|
|
ex = sd->getExtremes();
|
|
drawStrokeCenterLine(s,
|
|
pixelSize_,
|
|
ex);
|
|
if (status) {
|
|
#ifdef _DEBUG
|
|
glColor3d(0, 0, 0);
|
|
showCorners(s,
|
|
status->cornerSize_,
|
|
pixelSize);
|
|
|
|
glColor3d(0, 0, 0);
|
|
TPointD
|
|
offset = normalize(TPointD(1.0, 1.0)) * 20.0;
|
|
std::ostringstream oss;
|
|
oss << "(" << this->x_
|
|
<< "," << this->y_
|
|
<< ")\n{" << w
|
|
<< ",{" << sd->getExtremes().first
|
|
<< "," << sd->getExtremes().second
|
|
<< "}}";
|
|
extglDrawText(TPointD(x_, y_) + offset, oss.str());
|
|
|
|
glColor3d(0.5, 1.0, 0.5);
|
|
showCP(s,
|
|
pixelSize);
|
|
#endif
|
|
}
|
|
}
|
|
|
|
/*
|
|
glColor3d(1.0,1.0,0.0);
|
|
s = sd->getStroke();
|
|
if(s)
|
|
{
|
|
drawCross( s->getPoint(0),
|
|
4);
|
|
|
|
drawStrokeCenterLine(s,
|
|
pixelSize_,
|
|
ToonzExt::Interval(0,1));
|
|
}
|
|
*/
|
|
|
|
s = sd->getTransformedStroke();
|
|
|
|
glColor3d(1.0, 0.0, 0.0);
|
|
if (s) {
|
|
#ifdef _DEBUG
|
|
isValid(s);
|
|
#endif
|
|
drawStrokeCenterline(*s,
|
|
pixelSize_);
|
|
}
|
|
|
|
#ifdef _DEBUG
|
|
{
|
|
const TStroke
|
|
*c = sd->getCopiedStroke(),
|
|
*s = sd->getStroke();
|
|
if (c && s) {
|
|
//glColor3d(1,1,0);
|
|
//tglDrawDisk(s->getPoint(0.0),
|
|
// 5*pixelSize_);
|
|
|
|
int count = std::min(c->getControlPointCount(),
|
|
s->getControlPointCount());
|
|
for (int i = 0;
|
|
i < count;
|
|
++i) {
|
|
TThickPoint
|
|
ccp = c->getControlPoint(i);
|
|
TThickPoint
|
|
scp = s->getControlPoint(i);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ToonzExt::OverallDesigner::setPosition()
|
|
{
|
|
TPointD
|
|
offset(1, -1);
|
|
offset = normalize(offset) * (20.0 * scale_);
|
|
glTranslated(x_ + offset.x,
|
|
y_ + offset.y,
|
|
0.0);
|
|
glScalef(scale_,
|
|
scale_,
|
|
scale_);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ToonzExt::OverallDesigner::draw(ToonzExt::Selector *selector)
|
|
{
|
|
if (!selector)
|
|
return;
|
|
|
|
const TStroke *
|
|
ref = selector->getStroke();
|
|
|
|
if (!ref)
|
|
return;
|
|
|
|
double
|
|
length_at_w = ref->getLength(selector->getW()),
|
|
emi_selector_length = selector->getLength() * 0.5,
|
|
stroke_length = ref->getLength();
|
|
|
|
ToonzExt::Interval
|
|
interval;
|
|
|
|
if (ref->isSelfLoop()) {
|
|
interval.first = length_at_w - emi_selector_length;
|
|
if (interval.first < 0.0)
|
|
interval.first = stroke_length + interval.first;
|
|
|
|
interval.first = ref->getParameterAtLength(interval.first);
|
|
|
|
interval.second = length_at_w + emi_selector_length;
|
|
if (interval.second > stroke_length)
|
|
interval.second = interval.second - stroke_length;
|
|
|
|
interval.second = ref->getParameterAtLength(interval.second);
|
|
} else {
|
|
interval.first = ref->getParameterAtLength(std::max(0.0, length_at_w - emi_selector_length));
|
|
interval.second = ref->getParameterAtLength(std::min(stroke_length, length_at_w + emi_selector_length));
|
|
}
|
|
|
|
float
|
|
prev_line_width = 1.0;
|
|
|
|
glGetFloatv(GL_LINE_WIDTH,
|
|
&prev_line_width);
|
|
|
|
glLineWidth(2.0);
|
|
drawStrokeCenterLine(ref,
|
|
pixelSize_,
|
|
interval);
|
|
glLineWidth(prev_line_width);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// End Of File
|
|
//-----------------------------------------------------------------------------
|
|
/*
|
|
#ifdef RESTORE_DEBUG
|
|
#undef RESTORE_DEBUG
|
|
#define _DEBUG 1
|
|
#endif
|
|
//*/
|