607 lines
15 KiB
C++
607 lines
15 KiB
C++
|
|
|
|
#include "tgl.h"
|
|
#include "tvectorgl.h"
|
|
#include "tregion.h"
|
|
#include "tregionprop.h"
|
|
#include "tstrokeutil.h"
|
|
#include "tvectorrenderdata.h"
|
|
#include "tvectorimage.h"
|
|
#include "tpalette.h"
|
|
#include "tcolorfunctions.h"
|
|
#include "tsimplecolorstyles.h"
|
|
#include "tthreadmessage.h"
|
|
#include "tstrokeprop.h"
|
|
|
|
#include "tconvert.h"
|
|
#include "tcurves.h"
|
|
#include "tstrokeoutline.h"
|
|
|
|
#ifndef _WIN32
|
|
#define CALLBACK
|
|
#endif
|
|
|
|
#ifndef checkErrorsByGL
|
|
#define checkErrorsByGL \
|
|
{ \
|
|
GLenum err = glGetError(); \
|
|
assert(err != GL_INVALID_ENUM); \
|
|
assert(err != GL_INVALID_VALUE); \
|
|
assert(err != GL_INVALID_OPERATION); \
|
|
assert(err != GL_STACK_OVERFLOW); \
|
|
assert(err != GL_STACK_UNDERFLOW); \
|
|
assert(err != GL_OUT_OF_MEMORY); \
|
|
assert(err == GL_NO_ERROR); \
|
|
}
|
|
#endif
|
|
|
|
#undef checkErrorsByGL
|
|
#define checkErrorsByGL
|
|
|
|
using namespace std;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/*
|
|
DV_EXPORT_API void mylog(std::string s)
|
|
{
|
|
static TThread::Mutex mutex;
|
|
QMutexLocker sl(mutex);
|
|
std::ofstream os("C:\\gmt\\buttami\\bu.txt", std::ios::app);
|
|
|
|
LARGE_INTEGER ticksPerSecond;
|
|
LARGE_INTEGER tick;
|
|
static LARGE_INTEGER firstTick;
|
|
static bool firstTime = true;
|
|
long dt = 0;
|
|
|
|
QueryPerformanceFrequency(&ticksPerSecond);
|
|
QueryPerformanceCounter(&tick);
|
|
if(firstTime) {firstTick = tick;firstTime=false;}
|
|
else
|
|
{
|
|
dt = (long)(1000000*(tick.QuadPart-firstTick.QuadPart)/ticksPerSecond.QuadPart);
|
|
}
|
|
os << dt << ":" << s << std::endl;
|
|
}
|
|
*/
|
|
|
|
//=============================================================================
|
|
#ifdef _DEBUG
|
|
|
|
bool checkQuadraticDistance(TStroke *stroke, bool checkThickness)
|
|
{
|
|
UINT i, qCount = stroke->getChunkCount();
|
|
const TThickQuadratic *q;
|
|
TThickPoint p1, p2, p3;
|
|
|
|
//se i punti coincidono e' una stroke puntiforme ed e' ammessa
|
|
if (qCount == 1)
|
|
return true;
|
|
|
|
for (i = 0; i != qCount; i++) {
|
|
q = stroke->getChunk(i);
|
|
p1 = q->getThickP0();
|
|
p2 = q->getThickP1();
|
|
p3 = q->getThickP2();
|
|
|
|
if (areAlmostEqual(p1.x, p2.x) && areAlmostEqual(p2.x, p3.x) &&
|
|
areAlmostEqual(p1.y, p2.y) && areAlmostEqual(p2.y, p3.y) &&
|
|
(!checkThickness ||
|
|
(areAlmostEqual(p1.thick, p2.thick) && areAlmostEqual(p2.thick, p3.thick))))
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void drawControlPoints(const TVectorRenderData &rd, TStroke *stroke, double pixelSize, bool allPoints = true)
|
|
{
|
|
int i;
|
|
TPointD p;
|
|
glPushMatrix();
|
|
|
|
tglMultMatrix(rd.m_aff);
|
|
|
|
glPointSize(2.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();
|
|
glPopMatrix();
|
|
}
|
|
|
|
#endif
|
|
|
|
//=============================================================================
|
|
|
|
/*TPixel TransparencyCheckBlackBgInk = TPixel(255,255,255);
|
|
TPixel TransparencyCheckWhiteBgInk = TPixel(0,0,0);
|
|
TPixel TransparencyCheckPaint = TPixel(127,127,127);*/
|
|
static int Index = 0;
|
|
void tglDraw(const TVectorRenderData &rd, TRegion *r, bool pushAttribs)
|
|
{
|
|
checkErrorsByGL;
|
|
assert(r);
|
|
checkErrorsByGL;
|
|
if (!r)
|
|
return;
|
|
bool alphaChannel = rd.m_alphaChannel;
|
|
checkErrorsByGL;
|
|
|
|
int j = 0;
|
|
bool visible = false;
|
|
int colorCount = 0;
|
|
|
|
TColorStyleP style;
|
|
if (rd.m_paintCheckEnabled && r->getStyle() == rd.m_colorCheckIndex) {
|
|
static TSolidColorStyle *redColor = new TSolidColorStyle();
|
|
redColor->addRef();
|
|
redColor->setMainColor(TPixel::Red);
|
|
style = redColor;
|
|
} else if (rd.m_tcheckEnabled) {
|
|
static TSolidColorStyle *color = new TSolidColorStyle();
|
|
color->addRef();
|
|
color->setMainColor(rd.m_tCheckPaint);
|
|
style = color;
|
|
} else
|
|
style = rd.m_palette->getStyle(r->getStyle());
|
|
|
|
colorCount = style->getColorParamCount();
|
|
if (colorCount == 0) { //for example texture
|
|
visible = true;
|
|
} else {
|
|
visible = false;
|
|
for (j = 0; j < colorCount && !visible; j++) {
|
|
TPixel32 color = style->getColorParamValue(j);
|
|
if (rd.m_cf)
|
|
color = (*(rd.m_cf))(color);
|
|
if (color.m != 0)
|
|
visible = true;
|
|
}
|
|
}
|
|
if (visible) {
|
|
TRegionProp *prop = r->getProp(/*rd.m_palette*/);
|
|
///questo codice satva dentro tregion::getprop/////
|
|
int styleId = r->getStyle();
|
|
if (styleId) {
|
|
// TColorStyle * style = rd.m_palette->getStyle(styleId);
|
|
if (!style->isRegionStyle() || style->isEnabled() == false) {
|
|
prop = 0;
|
|
} else {
|
|
//Warning: The same remark of stroke props holds here.
|
|
if (!prop || style.getPointer() != prop->getColorStyle()) {
|
|
r->setProp(style->makeRegionProp(r));
|
|
prop = r->getProp();
|
|
}
|
|
}
|
|
}
|
|
|
|
////// draw
|
|
if (prop) {
|
|
if (pushAttribs)
|
|
glPushAttrib(GL_ALL_ATTRIB_BITS);
|
|
|
|
tglEnableLineSmooth(true);
|
|
//#define DRAW_EDGE_NUMBERS
|
|
#ifdef DRAW_EDGE_NUMBERS
|
|
glPushMatrix();
|
|
tglMultMatrix(rd.m_aff);
|
|
switch (Index % 7) {
|
|
case 0:
|
|
tglColor(TPixel::Red);
|
|
break;
|
|
case 1:
|
|
tglColor(TPixel::Green);
|
|
break;
|
|
case 2:
|
|
tglColor(TPixel::Blue);
|
|
break;
|
|
case 3:
|
|
tglColor(TPixel::Cyan);
|
|
break;
|
|
case 4:
|
|
tglColor(TPixel::Magenta);
|
|
break;
|
|
case 5:
|
|
tglColor(TPixel::Yellow);
|
|
break;
|
|
case 6:
|
|
tglColor(TPixel::Black);
|
|
break;
|
|
default:
|
|
tglColor(TPixel::Red);
|
|
break;
|
|
}
|
|
|
|
Index++;
|
|
if (rIndex == 2) {
|
|
double y = r->getEdge(0)->m_s->getThickPoint((r->getEdge(0)->m_w0 + r->getEdge(0)->m_w1) / 2.0).y;
|
|
tglDrawSegment(TPointD(-1000, y), TPointD(1000, y));
|
|
}
|
|
|
|
for (int i = 0; i < (int)r->getEdgeCount(); i++) {
|
|
TEdge *e = r->getEdge(i);
|
|
TPointD p = e->m_s->getPoint(0.8 * e->m_w0 + 0.2 * e->m_w1);
|
|
if (i == 0)
|
|
tglDrawText(p, (QString::number(rIndex) + QString("-0")).toStdString());
|
|
else
|
|
tglDrawText(p, QString::number(i).toStdString());
|
|
if (e->m_index == 3) {
|
|
tglColor(TPixel::Black);
|
|
TStroke *s = e->m_s;
|
|
drawPoint(s->getChunk(0)->getP0(), .3);
|
|
tglColor(TPixel::Red);
|
|
tglDrawText(s->getChunk(0)->getP0(), QString::number(0).toStdString());
|
|
for (int ii = 0; ii < s->getChunkCount(); ii++) {
|
|
drawPoint(s->getChunk(ii)->getP2(), .3);
|
|
if (ii < s->getChunkCount() - 1) {
|
|
tglColor(TPixel::Red);
|
|
tglDrawText(s->getChunk(ii)->getP2(), QString::number(ii + 1).toStdString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
glPopMatrix();
|
|
#endif
|
|
|
|
if (alphaChannel) {
|
|
GLboolean red, green, blue, alpha;
|
|
tglGetColorMask(red, green, blue, alpha);
|
|
|
|
//Draw RGB channels
|
|
tglEnableBlending(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glColorMask(red, green, blue, GL_FALSE);
|
|
prop->draw(rd);
|
|
|
|
//Draw Matte channel
|
|
tglEnableBlending(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
|
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, alpha);
|
|
prop->draw(rd);
|
|
|
|
glColorMask(red, green, blue, alpha);
|
|
} else {
|
|
//pezza: in render, le aree fillate dei custom styles sparivano.
|
|
if (!rd.m_isOfflineRender || !rd.m_isImagePattern)
|
|
tglRgbOnlyColorMask(); //RGB components only
|
|
|
|
prop->draw(rd);
|
|
}
|
|
|
|
if (pushAttribs)
|
|
glPopAttrib();
|
|
}
|
|
}
|
|
|
|
for (UINT i = 0; i < r->getSubregionCount(); i++)
|
|
tglDraw(rd, r->getSubregion(i), pushAttribs);
|
|
checkErrorsByGL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void tglDrawMask(const TVectorRenderData &rd1, const TVectorImage *vim)
|
|
{
|
|
UINT i;
|
|
assert(vim);
|
|
if (!vim)
|
|
return;
|
|
TVectorRenderData rd(rd1);
|
|
|
|
glPushAttrib(GL_ALL_ATTRIB_BITS);
|
|
|
|
if (!rd.m_palette) {
|
|
TPalette *vPalette = vim->getPalette();
|
|
assert(vPalette);
|
|
rd.m_palette = vPalette;
|
|
}
|
|
for (i = 0; i < vim->getRegionCount(); i++)
|
|
tglDraw(rd, vim->getRegion(i), false);
|
|
|
|
glPopAttrib();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
namespace
|
|
{
|
|
bool isOThick(const TStroke *s)
|
|
{
|
|
int i;
|
|
for (i = 0; i < s->getControlPointCount(); i++)
|
|
if (s->getControlPoint(i).thick != 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void tglDraw(const TVectorRenderData &rd, const TStroke *s, bool pushAttribs)
|
|
{
|
|
assert(s);
|
|
if (!s)
|
|
return;
|
|
|
|
TStrokeProp *prop = 0;
|
|
bool pushedAttribs = false;
|
|
|
|
try {
|
|
TColorStyleP style;
|
|
TStroke *stroke = const_cast<TStroke *>(s);
|
|
if (rd.m_inkCheckEnabled && s->getStyle() == rd.m_colorCheckIndex) {
|
|
static TSolidColorStyle *redColor = new TSolidColorStyle();
|
|
redColor->addRef();
|
|
redColor->setMainColor(TPixel::Red);
|
|
style = redColor;
|
|
} else if (rd.m_tcheckEnabled) {
|
|
static TSolidColorStyle *color = new TSolidColorStyle();
|
|
color->addRef();
|
|
color->setMainColor(rd.m_tCheckInk);
|
|
style = color;
|
|
} else
|
|
style = rd.m_palette->getStyle(stroke->getStyle());
|
|
|
|
if (!rd.m_show0ThickStrokes && isOThick(s) && dynamic_cast<TSolidColorStyle *>(style.getPointer()) // This is probably to exclude TCenterlineStrokeStyle-like styles
|
|
&& !rd.m_tcheckEnabled) // I wonder why this?
|
|
return;
|
|
|
|
// const TStroke& stroke = *s; //serve???
|
|
|
|
assert(rd.m_palette);
|
|
|
|
prop = s->getProp(/*rd.m_palette*/);
|
|
/////questo codice stava dentro tstroke::getprop/////////
|
|
if (prop)
|
|
prop->getMutex()->lock();
|
|
|
|
if (!style->isStrokeStyle() || style->isEnabled() == false) {
|
|
if (prop)
|
|
prop->getMutex()->unlock();
|
|
|
|
prop = 0;
|
|
} else {
|
|
//Warning: the following pointers check is conceptually wrong - we
|
|
//keep it because the props maintain SMART POINTER-like reference to
|
|
//the associated style. This prevents the style from being destroyed
|
|
//while still referenced by the prop.
|
|
if (!prop || style.getPointer() != prop->getColorStyle()) {
|
|
if (prop)
|
|
prop->getMutex()->unlock();
|
|
|
|
stroke->setProp(style->makeStrokeProp(stroke));
|
|
prop = stroke->getProp();
|
|
if (prop)
|
|
prop->getMutex()->lock();
|
|
}
|
|
}
|
|
|
|
//--------- draw ------------
|
|
if (!prop)
|
|
return;
|
|
|
|
if (pushAttribs)
|
|
glPushAttrib(GL_ALL_ATTRIB_BITS), pushedAttribs = true;
|
|
|
|
bool alphaChannel = rd.m_alphaChannel, antialias = rd.m_antiAliasing;
|
|
TVectorImagePatternStrokeProp *aux = dynamic_cast<TVectorImagePatternStrokeProp *>(prop);
|
|
if (aux) //gli image pattern vettoriali tornano in questa funzione....non facendo il corpo dell'else'si evita di disegnarli due volte!
|
|
prop->draw(rd);
|
|
else {
|
|
if (antialias)
|
|
tglEnableLineSmooth(true);
|
|
else
|
|
tglEnableLineSmooth(false);
|
|
|
|
if (alphaChannel) {
|
|
GLboolean red, green, blue, alpha;
|
|
tglGetColorMask(red, green, blue, alpha);
|
|
|
|
//Draw RGB channels
|
|
tglEnableBlending(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
glColorMask(red, green, blue, GL_FALSE);
|
|
prop->draw(rd);
|
|
|
|
//Draw Matte channel
|
|
tglEnableBlending(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
|
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, alpha);
|
|
prop->draw(rd);
|
|
|
|
glColorMask(red, green, blue, alpha);
|
|
} else {
|
|
tglEnableBlending(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
|
|
prop->draw(rd);
|
|
}
|
|
}
|
|
|
|
if (pushAttribs)
|
|
glPopAttrib(), pushedAttribs = false;
|
|
|
|
prop->getMutex()->unlock();
|
|
//---------------------
|
|
} catch (...) {
|
|
if (prop)
|
|
prop->getMutex()->unlock();
|
|
if (pushedAttribs)
|
|
glPopAttrib();
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
|
|
void tglDoDraw(const TVectorRenderData &rd, TRegion *r)
|
|
{
|
|
bool visible = false;
|
|
int colorCount = 0;
|
|
if (!r)
|
|
return;
|
|
|
|
TColorStyleP style = rd.m_palette->getStyle(r->getStyle());
|
|
colorCount = style->getColorParamCount();
|
|
if (colorCount == 0) //for example texture
|
|
visible = true;
|
|
else {
|
|
visible = false;
|
|
for (int j = 0; j < colorCount && !visible; j++) {
|
|
TPixel32 color = style->getColorParamValue(j);
|
|
if (rd.m_cf)
|
|
color = (*(rd.m_cf))(color);
|
|
if (color.m != 0)
|
|
visible = true;
|
|
}
|
|
}
|
|
if (visible)
|
|
tglDraw(rd, r, false);
|
|
else
|
|
for (UINT j = 0; j < r->getSubregionCount(); j++)
|
|
tglDraw(rd, r->getSubregion(j), false);
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
|
|
void tglDoDraw(const TVectorRenderData &rd, const TStroke *s)
|
|
{
|
|
bool visible = false;
|
|
int colorCount = 0;
|
|
|
|
const TPalette *palette = rd.m_palette;
|
|
|
|
int styleId = s->getStyle();
|
|
//assert(0<=styleId && styleId<stylesCount);
|
|
TColorStyleP style = palette->getStyle(styleId);
|
|
assert(style);
|
|
colorCount = style->getColorParamCount();
|
|
if (colorCount == 0)
|
|
visible = true;
|
|
else {
|
|
visible = false;
|
|
for (int j = 0; j < style->getColorParamCount() && !visible; j++) {
|
|
TPixel32 color = style->getColorParamValue(j);
|
|
if (rd.m_cf)
|
|
color = (*(rd.m_cf))(color);
|
|
if (color.m != 0)
|
|
visible = true;
|
|
}
|
|
}
|
|
#if DISEGNO_OUTLINE == 0
|
|
if (visible)
|
|
#endif
|
|
tglDraw(rd, s, false);
|
|
|
|
#ifdef _DEBUG
|
|
//drawControlPoints(rd, vim->getStroke(i), sqrt(tglGetPixelSize2()), true);
|
|
//assert(checkQuadraticDistance(vim->getStroke(i),true));
|
|
#endif
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
|
|
namespace
|
|
{
|
|
|
|
void doDraw(const TVectorImage *vim, const TVectorRenderData &_rd, bool drawEnteredGroup)
|
|
{
|
|
static TOnionFader *fade = new TOnionFader(TPixel::White, 0.5);
|
|
|
|
TVectorRenderData rd(_rd);
|
|
|
|
if (!rd.m_palette) {
|
|
TPalette *vPalette = vim->getPalette();
|
|
rd.m_palette = vPalette;
|
|
if (!vPalette)
|
|
return;
|
|
}
|
|
|
|
if (!drawEnteredGroup && !rd.m_isIcon && vim->isInsideGroup() > 0)
|
|
rd.m_cf = fade;
|
|
|
|
TVectorRenderData rdRegions = rd;
|
|
|
|
/*if (rd.m_drawRegions && rd.m_isImagePattern)//gli image pattern hanno bisogno dell'antialiasig per le linee, ma sulle aree ci sarebbero un sacco di assert
|
|
rdRegions.m_alphaChannel = rdRegions.m_antiAliasing = false;*/
|
|
UINT strokeIndex = 0;
|
|
Index = 0;
|
|
|
|
while (strokeIndex < vim->getStrokeCount()) // ogni ciclo di while disegna un gruppo
|
|
{
|
|
int currStrokeIndex = strokeIndex;
|
|
if (!rd.m_isIcon && vim->isInsideGroup() > 0 &&
|
|
((drawEnteredGroup && !vim->isEnteredGroupStroke(strokeIndex)) ||
|
|
!drawEnteredGroup && vim->isEnteredGroupStroke(strokeIndex))) {
|
|
while (strokeIndex < vim->getStrokeCount() && vim->sameGroup(strokeIndex, currStrokeIndex))
|
|
strokeIndex++;
|
|
continue;
|
|
}
|
|
|
|
if (rd.m_drawRegions)
|
|
for (UINT regionIndex = 0; regionIndex < vim->getRegionCount(); regionIndex++)
|
|
if (vim->sameGroupStrokeAndRegion(currStrokeIndex, regionIndex))
|
|
tglDoDraw(rdRegions, vim->getRegion(regionIndex));
|
|
while (strokeIndex < vim->getStrokeCount() && vim->sameGroup(strokeIndex, currStrokeIndex)) {
|
|
#if DISEGNO_OUTLINE == 1
|
|
CurrStrokeIndex = strokeIndex;
|
|
CurrVimg = vim;
|
|
#endif
|
|
tglDoDraw(rd, vim->getStroke(strokeIndex));
|
|
strokeIndex++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//------------------------------------------------------------------------------------
|
|
|
|
void tglDraw(const TVectorRenderData &rd, const TVectorImage *vim)
|
|
{
|
|
assert(vim);
|
|
if (!vim)
|
|
return;
|
|
|
|
QMutexLocker sl(vim->getMutex());
|
|
|
|
checkErrorsByGL;
|
|
checkErrorsByGL;
|
|
|
|
glPushAttrib(GL_ALL_ATTRIB_BITS);
|
|
|
|
//if(!rd.m_palette) rd.m_palette = vim->getPalette();
|
|
//mylog("tglDraw start; mutex=" + toString((unsigned long)&vim->getMutex()));
|
|
|
|
glEnable(GL_ALPHA_TEST);
|
|
glAlphaFunc(GL_GREATER, 0);
|
|
|
|
doDraw(vim, rd, false);
|
|
if (!rd.m_isIcon && vim->isInsideGroup() > 0)
|
|
doDraw(vim, rd, true);
|
|
|
|
glDisable(GL_ALPHA_TEST);
|
|
|
|
glPopAttrib();
|
|
|
|
#ifdef _DEBUG
|
|
vim->drawAutocloses(rd);
|
|
#endif
|
|
checkErrorsByGL;
|
|
//mylog("tglDraw stop");
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|