void ShiftTraceTool::drawControlRect() {
if (m_ghostIndex < 0 || m_ghostIndex > 1) return;
int row = m_row[m_ghostIndex];
if (row < 0) return;
int col = TApp::instance()->getCurrentColumn()->getColumnIndex();
TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();
TXshCell cell = xsh->getCell(row, col);
if (cell.isEmpty()) return;
TImageP img = cell.getImage(false);
if (!img) return;
TRectD box;
if (TRasterImageP ri = img) {
TRasterP ras = ri->getRaster();
box =
(convert(ras->getBounds()) - ras->getCenterD()) * ri->getSubsampling();
} else if (TToonzImageP ti = img) {
TRasterP ras = ti->getRaster();
box =
(convert(ras->getBounds()) - ras->getCenterD()) * ti->getSubsampling();
} else if (TVectorImageP vi = img) {
box = vi->getBBox();
} else {
return;
}
glPushMatrix();
tglMultMatrix(getGhostAff());
TPixel32 color;
color = m_highlightedGadget == TranslateGadget ? TPixel32(200, 100, 100)
: TPixel32(120, 120, 120);
tglColor(color);
glBegin(GL_LINE_STRIP);
glVertex2d(box.x0, box.y0);
glVertex2d(box.x1, box.y0);
glVertex2d(box.x1, box.y1);
glVertex2d(box.x0, box.y1);
glVertex2d(box.x0, box.y0);
glEnd();
color =
m_highlightedGadget == 2000 ? TPixel32(200, 100, 100) : TPixel32::White;
double r = 4 * sqrt(tglGetPixelSize2());
drawDot(box.getP00(), r, color);
drawDot(box.getP01(), r, color);
drawDot(box.getP10(), r, color);
drawDot(box.getP11(), r, color);
if (m_curveStatus == NoCurve) {
color =
m_highlightedGadget == 2001 ? TPixel32(200, 100, 100) : TPixel32::White;
TPointD c = m_center[m_ghostIndex];
drawDot(c, r, color);
}
glPopMatrix();
}
void MorphTool::draw()
{
m_pixelSize = sqrt(tglGetPixelSize2());
if (m_vi2) {
TVectorRenderData rd(TTranslation(10, 10), TRect(), 0, 0);
tglDraw(rd, m_vi2.getPointer());
}
double u = m_pixelSize * 5;
for (int i = 0; i < (int)deformation.m_controlPoints.size(); i++) {
TPointD p = deformation.m_controlPoints[i];
bool selected = deformation.m_selected == i;
bool base = (i & 1) == 0;
if (base)
if (selected)
glColor3d(0.8, 0.8, 0.1);
else
glColor3d(0.5, 0.5, 0.1);
else if (selected)
glColor3d(0.8, 0.3, 0.1);
else
glColor3d(0.5, 0.1, 0.1);
double r = base ? u * 2 : u * 1;
tglDrawDisk(p, r);
glColor3d(0, 0, 0);
tglDrawCircle(p, r);
}
glColor3f(0, 1, 0);
for (int i = 0; i + 1 < (int)deformation.m_controlPoints.size(); i += 2) {
TPointD a = deformation.m_controlPoints[i];
TPointD b = deformation.m_controlPoints[i + 1];
tglDrawSegment(a, b);
}
/*
deformation.update();
glBegin(GL_LINES);
for(double x = -200; x<=200; x+=20)
for(double y = -200; y<=200; y+=20)
{
TPointD p0(x,y);
TPointD p1 = deformation.apply(p0);
glColor3d(0,1,0);
tglVertex(p0);
glColor3d(1,0,0);
tglVertex(p1);
}
glEnd();
*/
}
void ShiftTraceTool::drawCurve() {
if (m_curveStatus == NoCurve) return;
double r = 4 * sqrt(tglGetPixelSize2());
double u = getPixelSize();
if (m_curveStatus == TwoPointsCurve) {
TPixel32 color =
m_highlightedGadget == 1000 ? TPixel32(200, 100, 100) : TPixel32::White;
drawDot(m_p0, r, color);
glColor3d(0.2, 0.2, 0.2);
tglDrawSegment(m_p0, m_p1);
drawDot(m_p1, r, TPixel32::Red);
} else if (m_curveStatus == ThreePointsCurve) {
TPixel32 color =
m_highlightedGadget == 1000 ? TPixel32(200, 100, 100) : TPixel32::White;
drawDot(m_p0, r, color);
color =
m_highlightedGadget == 1001 ? TPixel32(200, 100, 100) : TPixel32::White;
drawDot(m_p1, r, color);
glColor3d(0.2, 0.2, 0.2);
TPointD center;
if (circumCenter(center, m_p0, m_p1, m_p2)) {
double radius = norm(center - m_p1);
glBegin(GL_LINE_STRIP);
int n = 100;
for (int i = 0; i < n; i++) {
double t = (double)i / n;
TPointD p = (1 - t) * m_p0 + t * m_p2;
p = center + radius * normalize(p - center);
tglVertex(p);
}
for (int i = 0; i < n; i++) {
double t = (double)i / n;
TPointD p = (1 - t) * m_p2 + t * m_p1;
p = center + radius * normalize(p - center);
tglVertex(p);
}
glEnd();
} else {
tglDrawSegment(m_p0, m_p1);
}
color =
m_highlightedGadget == 1002 ? TPixel32(200, 100, 100) : TPixel32::White;
drawDot(m_p2, r, color);
}
}
void tglDraw(const TRectD &rect,
const std::vector<TRaster32P> &textures,
bool blending)
{
double pixelSize2 = tglGetPixelSize2();
// level e' la minore potenza di 2 maggiore di sqrt(pixelSize2)
unsigned int level = 1;
while (pixelSize2 * level * level <= 1.0)
level <<= 1;
unsigned int texturesCount = (int)textures.size();
if (level > texturesCount)
level = texturesCount;
level = texturesCount - level;
tglDraw(rect, textures[level], blending);
}
void OutlineStrokeProp::draw(const TVectorRenderData &rd) {
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());
#ifdef _DEBUG
if (m_stroke->isCenterLine() && m_colorStyle->getTagId() != 99)
#else
if (m_stroke->isCenterLine())
#endif
{
TCenterLineStrokeStyle *appStyle =
new TCenterLineStrokeStyle(m_colorStyle->getAverageColor(), 0, 0);
appStyle->drawStroke(rd.m_cf, m_stroke);
delete appStyle;
} else {
if (!isAlmostZero(pixelSize - m_outlinePixelSize, 1e-5) ||
m_strokeChanged ||
m_styleVersionNumber != m_colorStyle->getVersionNumber()) {
m_strokeChanged = false;
m_outlinePixelSize = pixelSize;
TOutlineUtil::OutlineParameter param;
m_outline.getArray().clear();
m_colorStyle->computeOutline(m_stroke, m_outline, param);
// TOutlineStyle::StrokeOutlineModifier *modifier =
// m_colorStyle->getStrokeOutlineModifier();
// if(modifier)
// modifier->modify(m_outline);
m_styleVersionNumber = m_colorStyle->getVersionNumber();
}
m_colorStyle->drawStroke(rd.m_cf, &m_outline, m_stroke);
}
glPopMatrix();
}
void VectorBrushProp::draw(const TVectorRenderData &rd)
{
//Ensure that the stroke overlaps our clipping rect
if (rd.m_clippingRect != TRect() && !rd.m_is3dView &&
!convert(rd.m_aff * m_stroke->getBBox()).overlaps(rd.m_clippingRect))
return;
TPaletteP palette(m_brush->getPalette());
if (!palette)
return;
static TOutlineUtil::OutlineParameter param; //unused, but requested
//Build a solid color style to draw each m_vi's stroke with.
TSolidColorStyle colorStyle;
//Push the specified rd affine before drawing
glPushMatrix();
tglMultMatrix(rd.m_aff);
//1. If necessary, build the outlines
double currentPixelSize = sqrt(tglGetPixelSize2());
bool differentPixelSize = !isAlmostZero(currentPixelSize - m_pixelSize, 1e-5);
m_pixelSize = currentPixelSize;
int i, viRegionsCount = m_brush->getRegionCount(), viStrokesCount = m_brush->getStrokeCount();
if (differentPixelSize || m_strokeChanged) {
m_strokeChanged = false;
//1a. First, the regions
m_regionOutlines.resize(viRegionsCount);
for (i = 0; i < viRegionsCount; ++i) {
TRegionOutline &outline = m_regionOutlines[i];
const TRegion *brushRegion = m_brush->getRegion(i);
//Build the outline
outline.clear();
TOutlineUtil::makeOutline(*getStroke(), *brushRegion, m_brushBox,
outline);
}
//1b. Then, the strokes
m_strokeOutlines.resize(viStrokesCount);
for (i = 0; i < viStrokesCount; ++i) {
TStrokeOutline &outline = m_strokeOutlines[i];
const TStroke *brushStroke = m_brush->getStroke(i);
outline.getArray().clear();
TOutlineUtil::makeOutline(*getStroke(), *brushStroke, m_brushBox,
outline, param);
}
}
//2. Draw the outlines
UINT s, t, r,
strokesCount = m_brush->getStrokeCount(),
regionCount = m_brush->getRegionCount();
for (s = 0; s < strokesCount; s = t) //Each cycle draws a group
{
//A vector image stores group strokes with consecutive indices.
//2a. First, draw regions in the strokeIdx-th stroke's group
for (r = 0; r < regionCount; ++r) {
if (m_brush->sameGroupStrokeAndRegion(s, r)) {
const TRegion *brushRegion = m_brush->getRegion(r);
const TColorStyle *brushStyle =
palette->getStyle(brushRegion->getStyle());
assert(brushStyle);
//Draw the outline
colorStyle.setMainColor(brushStyle->getMainColor());
colorStyle.drawRegion(0, false, m_regionOutlines[r]);
}
}
//2b. Then, draw all strokes in strokeIdx-th stroke's group
for (t = s; t < strokesCount && m_brush->sameGroup(s, t); ++t) {
const TStroke *brushStroke = m_brush->getStroke(t);
const TColorStyle *brushStyle =
palette->getStyle(brushStroke->getStyle());
if (!brushStyle)
continue;
colorStyle.setMainColor(brushStyle->getMainColor());
colorStyle.drawStroke(0, &m_strokeOutlines[t], brushStroke); //brushStroke unused but requested
}
}
glPopMatrix();
}
double
ToonzExt::Designer::getPixelSize2() const
{
return tglGetPixelSize2();
}
