409 lines
10 KiB
C++
409 lines
10 KiB
C++
|
|
||
|
|
||
|
#include "tstroke.h"
|
||
|
#include "tvectorrenderdata.h"
|
||
|
#include "tgl.h"
|
||
|
#include "tstrokeoutline.h"
|
||
|
#include "tsimplecolorstyles.h"
|
||
|
#include "tpalette.h"
|
||
|
#include "tregion.h"
|
||
|
#include "tregionoutline.h"
|
||
|
#include "tmathutil.h"
|
||
|
#include "tlevel_io.h"
|
||
|
#include "tenv.h"
|
||
|
|
||
|
#include "tvectorbrushstyle.h"
|
||
|
|
||
|
//**********************************************************************
|
||
|
// Vector Brush Style static members
|
||
|
//**********************************************************************
|
||
|
|
||
|
TFilePath TVectorBrushStyle::m_rootDir = TFilePath();
|
||
|
|
||
|
//**********************************************************************
|
||
|
// Vector Brush Prop declaration
|
||
|
//**********************************************************************
|
||
|
|
||
|
class VectorBrushProp : public TStrokeProp
|
||
|
{
|
||
|
TVectorBrushStyle *m_style;
|
||
|
TVectorImageP m_brush;
|
||
|
TRectD m_brushBox;
|
||
|
|
||
|
std::vector<TStrokeOutline> m_strokeOutlines;
|
||
|
std::vector<TRegionOutline> m_regionOutlines;
|
||
|
double m_pixelSize;
|
||
|
|
||
|
public:
|
||
|
VectorBrushProp(const TStroke *stroke, TVectorBrushStyle *style);
|
||
|
|
||
|
TStrokeProp *clone(const TStroke *stroke) const;
|
||
|
|
||
|
void draw(const TVectorRenderData &rd);
|
||
|
void draw(TFlash &flash) {}
|
||
|
|
||
|
const TColorStyle *getColorStyle() const;
|
||
|
|
||
|
private:
|
||
|
// not implemented
|
||
|
VectorBrushProp(const VectorBrushProp &);
|
||
|
VectorBrushProp &operator=(const VectorBrushProp &);
|
||
|
};
|
||
|
|
||
|
//**********************************************************************
|
||
|
// Vector Brush Prop implementation
|
||
|
//**********************************************************************
|
||
|
|
||
|
VectorBrushProp::VectorBrushProp(const TStroke *stroke, TVectorBrushStyle *style)
|
||
|
: TStrokeProp(stroke), m_style(style), m_brush(style->getImage()), m_brushBox(m_brush->getBBox()), m_pixelSize(.0)
|
||
|
{
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
TStrokeProp *VectorBrushProp::clone(const TStroke *stroke) const
|
||
|
{
|
||
|
return new VectorBrushProp(stroke, m_style);
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
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();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
const TColorStyle *VectorBrushProp::getColorStyle() const
|
||
|
{
|
||
|
return m_style;
|
||
|
}
|
||
|
|
||
|
//**********************************************************************
|
||
|
// Vector Brush Style implementation
|
||
|
//**********************************************************************
|
||
|
|
||
|
TVectorBrushStyle::TVectorBrushStyle()
|
||
|
: m_colorCount(0)
|
||
|
{
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
TVectorBrushStyle::TVectorBrushStyle(const std::string &brushName, TVectorImageP vi)
|
||
|
: m_brush(vi)
|
||
|
{
|
||
|
loadBrush(brushName);
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
TVectorBrushStyle::~TVectorBrushStyle()
|
||
|
{
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
void TVectorBrushStyle::loadBrush(const std::string &brushName)
|
||
|
{
|
||
|
m_brushName = brushName;
|
||
|
m_colorCount = 0;
|
||
|
|
||
|
if (brushName.empty())
|
||
|
return;
|
||
|
|
||
|
if (!m_brush) {
|
||
|
//Load the image associated with fp
|
||
|
TFilePath fp(m_rootDir + TFilePath(brushName + ".pli"));
|
||
|
|
||
|
TLevelReaderP lr(fp);
|
||
|
TLevelP level = lr->loadInfo();
|
||
|
|
||
|
m_brush = lr->getFrameReader(level->begin()->first)->load();
|
||
|
assert(m_brush);
|
||
|
|
||
|
TPalette *palette = level->getPalette();
|
||
|
m_brush->setPalette(palette);
|
||
|
}
|
||
|
|
||
|
assert(m_brush);
|
||
|
m_colorCount = m_brush->getPalette()->getStyleInPagesCount() - 1; //No transparent
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
TColorStyle *TVectorBrushStyle::clone() const
|
||
|
{
|
||
|
TVectorImageP brush;
|
||
|
if (m_brush) {
|
||
|
//Clone m_brush and its palette
|
||
|
brush = m_brush->clone(); //NOTE: This does NOT clone the palette, too.
|
||
|
brush->setPalette(m_brush->getPalette()->clone());
|
||
|
}
|
||
|
|
||
|
TVectorBrushStyle *theClone = new TVectorBrushStyle(m_brushName, brush);
|
||
|
theClone->assignNames(this);
|
||
|
theClone->setFlags(getFlags());
|
||
|
|
||
|
return theClone;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
QString TVectorBrushStyle::getDescription() const
|
||
|
{
|
||
|
return "VectorBrushStyle";
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
TStrokeProp *TVectorBrushStyle::makeStrokeProp(const TStroke *stroke)
|
||
|
{
|
||
|
return new VectorBrushProp(stroke, this);
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
void TVectorBrushStyle::saveData(TOutputStreamInterface &osi) const
|
||
|
{
|
||
|
osi << m_brushName;
|
||
|
|
||
|
//Save palette
|
||
|
osi << m_colorCount;
|
||
|
|
||
|
TPalette *pal = m_brush->getPalette();
|
||
|
assert(pal);
|
||
|
|
||
|
int p, pagesCount = pal->getPageCount();
|
||
|
for (p = 0; p < pagesCount; ++p) {
|
||
|
TPalette::Page *page = pal->getPage(p);
|
||
|
|
||
|
int s, stylesCount = page->getStyleCount();
|
||
|
for (s = 0; s < stylesCount; ++s)
|
||
|
osi << page->getStyle(s)->getMainColor();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
void TVectorBrushStyle::loadData(TInputStreamInterface &isi)
|
||
|
{
|
||
|
std::string str;
|
||
|
isi >> str;
|
||
|
|
||
|
assert(!str.empty());
|
||
|
loadBrush(str);
|
||
|
|
||
|
int colorCount;
|
||
|
isi >> colorCount;
|
||
|
|
||
|
if (colorCount != m_colorCount)
|
||
|
return; //Palette mismatch! Just skip palette loading...
|
||
|
|
||
|
//WARNING: Is it needed to read all colors nonetheless?
|
||
|
|
||
|
//Load palette colors
|
||
|
TPalette *pal = m_brush->getPalette();
|
||
|
assert(pal);
|
||
|
|
||
|
TPixel32 color;
|
||
|
|
||
|
int p, pagesCount = pal->getPageCount();
|
||
|
for (p = 0; p < pagesCount; ++p) {
|
||
|
TPalette::Page *page = pal->getPage(p);
|
||
|
|
||
|
int s, stylesCount = page->getStyleCount();
|
||
|
for (s = 0; s < stylesCount; ++s) {
|
||
|
isi >> color;
|
||
|
page->getStyle(s)->setMainColor(color);
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
int TVectorBrushStyle::getColorStyleId(int index) const
|
||
|
{
|
||
|
if (index < 0)
|
||
|
return 1;
|
||
|
|
||
|
++index; //Skipping transparent
|
||
|
|
||
|
TPalette *pal = m_brush->getPalette();
|
||
|
assert(pal);
|
||
|
|
||
|
int p, pagesCount = pal->getPageCount();
|
||
|
for (p = 0; p < pagesCount; ++p) {
|
||
|
TPalette::Page *page = pal->getPage(p);
|
||
|
|
||
|
int stylesCount = page->getStyleCount();
|
||
|
if (index - stylesCount < 0)
|
||
|
break;
|
||
|
|
||
|
index -= stylesCount;
|
||
|
}
|
||
|
|
||
|
if (p >= pagesCount)
|
||
|
return -1;
|
||
|
|
||
|
TPalette::Page *page = pal->getPage(p);
|
||
|
return page->getStyleId(index);
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
TPixel32 TVectorBrushStyle::getMainColor() const
|
||
|
{
|
||
|
if (!m_brush)
|
||
|
return TPixel32::Transparent;
|
||
|
|
||
|
TPalette *pal = m_brush->getPalette();
|
||
|
return pal->getStyle(1)->getMainColor();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
void TVectorBrushStyle::setMainColor(const TPixel32 &color)
|
||
|
{
|
||
|
if (!m_brush)
|
||
|
return;
|
||
|
|
||
|
TPalette *pal = m_brush->getPalette();
|
||
|
pal->getStyle(1)->setMainColor(color);
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
int TVectorBrushStyle::getColorParamCount() const
|
||
|
{
|
||
|
return m_colorCount;
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
TPixel32 TVectorBrushStyle::getColorParamValue(int index) const
|
||
|
{
|
||
|
TPalette *pal = m_brush->getPalette();
|
||
|
assert(pal);
|
||
|
|
||
|
int styleId = getColorStyleId(index);
|
||
|
if (styleId < 0)
|
||
|
styleId = 1;
|
||
|
|
||
|
return pal->getStyle(styleId)->getMainColor();
|
||
|
}
|
||
|
|
||
|
//-----------------------------------------------------------------
|
||
|
|
||
|
void TVectorBrushStyle::setColorParamValue(int index, const TPixel32 &color)
|
||
|
{
|
||
|
TPalette *pal = m_brush->getPalette();
|
||
|
assert(pal);
|
||
|
|
||
|
int styleId = getColorStyleId(index);
|
||
|
if (styleId < 0)
|
||
|
styleId = 1;
|
||
|
|
||
|
return pal->getStyle(styleId)->setMainColor(color);
|
||
|
}
|
||
|
|
||
|
//**************************************************************
|
||
|
// Vector Style global declaration instance
|
||
|
//**************************************************************
|
||
|
|
||
|
namespace
|
||
|
{
|
||
|
TColorStyle::Declaration declaration(new TVectorBrushStyle());
|
||
|
}
|