TRectD SandorFxRenderData::getBBoxEnlargement(const TRectD &bbox)
{
switch (m_type) {
case BlendTz: {
//Nothing happen, unless we have color 0 among the blended ones. In such case,
//we have to enlarge the bbox proportionally to the amount param.
std::vector<std::string> items;
std::string indexes = std::string(m_argv[0]);
parseIndexes(indexes, items);
PaletteFilterFxRenderData paletteFilterData;
insertIndexes(items, &paletteFilterData);
if (paletteFilterData.m_colors.size() > 0 && *paletteFilterData.m_colors.begin() == 0)
return bbox.enlarge(m_blendParams.m_amount);
return bbox;
}
case Calligraphic:
case OutBorder:
return bbox.enlarge(m_callParams.m_thickness);
case ArtAtContour:
return bbox.enlarge(
tmax(tceil(m_controllerBBox.getLx()), tceil(m_controllerBBox.getLy())) * m_contourParams.m_maxSize);
default:
assert(false);
return bbox;
}
}
CircleBuilder(int cellLx, int cellLy, double radius, int wrap)
: MaskCellBuilder<PIXEL, GRAY>(cellLx, cellLy, radius, wrap) {
// Build the mask corresponding to a square of passed radius
GRAY *pix, *pixRev, *line, *lineEnd, *lineRev;
this->m_mask = TRasterPT<GRAY>(cellLx, cellLy);
// For each pixel in the lower-left quadrant, fill in the corresponding mask
// value.
// The other ones are filled by mirroring.
int i, j;
double lxHalf = 0.5 * cellLx, lyHalf = 0.5 * cellLy;
int lxHalfI = tceil(lxHalf), lyHalfI = tceil(lyHalf);
double val, addValX = 0.5 - lxHalf, addValY = 0.5 - lyHalf;
for (i = 0; i < lyHalfI; ++i) {
line = this->m_mask->pixels(i),
lineRev = this->m_mask->pixels(cellLy - i - 1);
lineEnd = line + cellLx;
for (j = 0, pix = line, pixRev = lineEnd - 1; j < lxHalfI;
++j, ++pix, --pixRev) {
val = tcrop(radius - sqrt(sq(i + addValX) + sq(j + addValY)), 0.0, 1.0);
*pix = *pixRev = val * GRAY::maxChannelValue;
}
memcpy(lineRev, line, cellLx * sizeof(GRAY));
}
}
void PlaneViewer::draw(TVectorImageP vi) {
TRectD bbox(vi->getBBox());
TRect bboxI(tfloor(bbox.x0), tfloor(bbox.y0), tceil(bbox.x1) - 1,
tceil(bbox.y1) - 1);
TVectorRenderData rd(TAffine(), bboxI, vi->getPalette(), 0, true, true);
tglDraw(rd, vi.getPointer());
}
TRect TRasterImageUtils::convertWorldToRaster(const TRectD &area, const TRasterImageP ri)
{
if (area.isEmpty())
return TRect();
if (!ri || !ri->getRaster())
return TRect(tfloor(area.x0), tfloor(area.y0), tfloor(area.x1) - 1, tfloor(area.y1) - 1);
TRasterP ras = ri->getRaster();
TRectD rect(area + ras->getCenterD());
return TRect(tfloor(rect.x0), tfloor(rect.y0), tceil(rect.x1) - 1, tceil(rect.y1) - 1);
}
//! Adapts image viewer's affine to display the passed viewer rect at maximized
//! ratio
void ImageViewer::adaptView(const QRect &geomRect) {
if (!m_image) return;
// Retrieve the rect in image reference and call the associated adaptView
TRect imgBounds(getImageBounds(m_image));
TRectD imgBoundsD(imgBounds.x0, imgBounds.y0, imgBounds.x1 + 1,
imgBounds.y1 + 1);
TRectD geomRectD(geomRect.left(), geomRect.top(), geomRect.right() + 1,
geomRect.bottom() + 1);
TRectD viewRectD(getImgToWidgetAffine().inv() * geomRectD);
TRect viewRect(tfloor(viewRectD.x0), tfloor(viewRectD.y0),
tceil(viewRectD.x1) - 1, tceil(viewRectD.y1) - 1);
adaptView(imgBounds, viewRect);
}
void TRop::over(const TRasterP &out, const TRasterP &up, const TPoint &pos, const TAffine &aff,
ResampleFilterType filterType)
{
if (aff.isIdentity())
//simple over with offset
TRop::over(out, up, pos);
else {
TRect rasterBounds = up->getBounds();
TRectD dbounds(rasterBounds.x0, rasterBounds.y0, rasterBounds.x1, rasterBounds.y1);
dbounds = aff * dbounds;
TRect bounds(tfloor(dbounds.x0), tfloor(dbounds.y0), tceil(dbounds.x1), tceil(dbounds.y1));
TRasterP tmp = up->create(bounds.getLx(), bounds.getLy());
resample(tmp, up, TTranslation(-dbounds.getP00()) * aff, filterType);
TRop::over(out, tmp, pos);
}
}
static D jtremdd(J jt,D a,D b){D q,x,y;
if(!a)R b;
ASSERT(!INF(b),EVNAN);
if(a==inf )R 0<=b?b:a;
if(a==infm)R 0>=b?b:a;
q=b/a; x=tfloor(q); y=tceil(q); R teq(x,y)?0:b-a*x;
}
void onDeliver()
{
if (m_error) {
m_error = false;
MsgBox(DVGui::CRITICAL, QObject::tr("There was an error saving frames for the %1 level.").arg(QString::fromStdWString(m_fp.withoutParentDir().getWideString())));
}
bool isPreview = (m_fp.getType() == "noext");
TImageCache::instance()->remove(toString(m_fp.getWideString() + L".0"));
TNotifier::instance()->notify(TSceneNameChange());
if (Preferences::instance()->isGeneratedMovieViewEnabled()) {
if (!isPreview && (Preferences::instance()->isDefaultViewerEnabled()) &&
(m_fp.getType() == "mov" || m_fp.getType() == "avi" || m_fp.getType() == "3gp")) {
QString name = QString::fromStdString(m_fp.getName());
int index;
if ((index = name.indexOf("#RENDERID")) != -1) //!quite ugly I know....
m_fp = m_fp.withName(name.left(index).toStdWString());
if (!TSystem::showDocument(m_fp)) {
QString msg(QObject::tr("It is not possible to display the file %1: no player associated with its format").arg(QString::fromStdWString(m_fp.withoutParentDir().getWideString())));
MsgBox(WARNING, msg);
}
}
else {
int r0, r1, step;
TApp *app = TApp::instance();
ToonzScene *scene = app->getCurrentScene()->getScene();
TOutputProperties &outputSettings = isPreview ? *scene->getProperties()->getPreviewProperties() : *scene->getProperties()->getOutputProperties();
outputSettings.getRange(r0, r1, step);
const TRenderSettings rs = outputSettings.getRenderSettings();
if (r0 == 0 && r1 == -1)
r0 = 0, r1 = scene->getFrameCount() - 1;
double timeStretchFactor = isPreview ? 1.0 : (double)outputSettings.getRenderSettings().m_timeStretchTo /
outputSettings.getRenderSettings().m_timeStretchFrom;
r0 = tfloor(r0 * timeStretchFactor);
r1 = tceil((r1 + 1) * timeStretchFactor) - 1;
TXsheet::SoundProperties *prop = new TXsheet::SoundProperties();
prop->m_frameRate = outputSettings.getFrameRate();
TSoundTrack *snd = app->getCurrentXsheet()->getXsheet()->makeSound(prop);
if (outputSettings.getRenderSettings().m_stereoscopic) {
assert(!isPreview);
::viewFile(m_fp.withName(m_fp.getName() + "_l"), r0 + 1, r1 + 1, step, isPreview ? rs.m_shrinkX : 1, snd, 0, false, true);
::viewFile(m_fp.withName(m_fp.getName() + "_r"), r0 + 1, r1 + 1, step, isPreview ? rs.m_shrinkX : 1, snd, 0, false, true);
} else
::viewFile(m_fp, r0 + 1, r1 + 1, step, isPreview ? rs.m_shrinkX : 1, snd, 0, false, true);
}
}
}
void TRop::over(const TRasterP &out,
const TRasterP &up,
const TAffine &aff,
ResampleFilterType filterType)
{
out->lock();
up->lock();
if (filterType == ClosestPixel || filterType == Bilinear)
::quickPut(out, up, aff, filterType);
else {
TRect rasterBounds = up->getBounds();
TRectD dbounds(rasterBounds.x0, rasterBounds.y0, rasterBounds.x1 + 1, rasterBounds.y1 + 1);
dbounds = aff * dbounds;
TRect bounds(tfloor(dbounds.x0), tfloor(dbounds.y0), tceil(dbounds.x1) - 1, tceil(dbounds.y1) - 1);
TRasterP tmp = up->create(bounds.getLx(), bounds.getLy());
resample(tmp, up, TTranslation(-bounds.x0, -bounds.y0) * aff, filterType);
over(out, tmp, bounds.getP00());
}
out->unlock();
up->unlock();
}
TAffine handledAffine(const TRenderSettings &info, double frame) {
// Return the default implementation: only the scale part of the affine
// can be handled. Rotations and other distortions would need us have to
// implement diagonal grid lines - and we don't want to!
// Also, no translational component will be dealt for the same reason.
TAffine scalePart(TRasterFx::handledAffine(info, frame));
// Plus, we want to avoid dealing with antialiases even on plain orthogonal
// lines! So, we ensure that the step size will be flattened to integer.
double stepSize = m_size->getValue(frame) + m_distance->getValue(frame);
double scale = tceil(stepSize * scalePart.a11) / stepSize;
return TScale(scale, scale);
}
void PlaneViewer::drawBackground() {
glClearColor(m_bgColorF[0], m_bgColorF[1], m_bgColorF[2], 1.0);
glClear(GL_COLOR_BUFFER_BIT);
if (m_bgColorF[0] != m_bgColorF[3] || m_bgColorF[1] != m_bgColorF[4] ||
m_bgColorF[2] != m_bgColorF[5]) {
// Cast the widget rect to world rect
TRectD rect(winToWorld(0, 0), winToWorld(width(), height()));
// Deduce chess geometry
TRect chessRect(tfloor(rect.x0 / m_chessSize),
tfloor(rect.y0 / m_chessSize), tceil(rect.x1 / m_chessSize),
tceil(rect.y1 / m_chessSize));
// Draw chess squares
glColor3f(m_bgColorF[3], m_bgColorF[4], m_bgColorF[5]);
glBegin(GL_QUADS);
int x, y;
TPointD pos;
double chessSize2 = 2.0 * m_chessSize;
for (y = chessRect.y0; y < chessRect.y1; ++y) {
pos.y = y * m_chessSize;
for (x = chessRect.x0 + ((chessRect.x0 + y) % 2), pos.x = x * m_chessSize;
x < chessRect.x1; x += 2, pos.x += chessSize2) {
glVertex2d(pos.x, pos.y);
glVertex2d(pos.x + m_chessSize, pos.y);
glVertex2d(pos.x + m_chessSize, pos.y + m_chessSize);
glVertex2d(pos.x, pos.y + m_chessSize);
}
}
glEnd();
}
}
bool doGetBBox(double frame, TRectD &bbox,
const TRenderSettings &info) override {
if (getActiveTimeRegion().contains(frame))
if (m_light.isConnected()) {
TRectD b0, b1;
bool ret = m_light->doGetBBox(frame, b0, info);
bbox = b0.enlarge(tceil(m_value->getValue(frame)));
if (m_lighted.isConnected()) {
ret = ret && m_lighted->doGetBBox(frame, b1, info);
bbox += b1;
}
return ret;
} else if (m_lighted.isConnected())
return m_lighted->doGetBBox(frame, bbox, info);
return false;
}
inline void buildLightRects(const TRectD &tileRect, TRectD &inRect,
TRectD &outRect, double blur) {
if (inRect !=
TConsts::infiniteRectD) // Could be, if the input light is a zerary Fx
makeRectCoherent(inRect, tileRect.getP00());
int blurI = tceil(blur);
// It seems that the TRop::blur does wrong with these (cuts at the borders).
// I don't know why - they would be best...
// TRectD blurOutRect((lightRect).enlarge(blurI) * tileRect);
// lightRect = ((tileRect).enlarge(blurI) * lightRect);
// So we revert to the sum of the two
outRect = inRect = ((tileRect).enlarge(blurI) * inRect) +
((inRect).enlarge(blurI) * tileRect);
}
void doCompute(TTile &tile, double frame,
const TRenderSettings &info) override {
bool isWarped = m_warped.isConnected();
if (!isWarped) return;
if (fabs(m_intensity->getValue(frame)) < 0.01) {
m_warped->compute(tile, frame, info);
return;
}
int shrink = (info.m_shrinkX + info.m_shrinkY) / 2;
double scale = sqrt(fabs(info.m_affine.det()));
double gridStep = 1.5 * m_gridStep->getValue(frame);
WarpParams params;
params.m_intensity = m_intensity->getValue(frame) / gridStep;
params.m_warperScale = scale * gridStep;
params.m_sharpen = m_sharpen->getValue();
params.m_shrink = shrink;
double period = m_period->getValue(frame) / info.m_shrinkX;
double count = m_count->getValue(frame);
double cycle = m_cycle->getValue(frame) / info.m_shrinkX;
double scaleX = m_scaleX->getValue(frame) / 100.0;
double scaleY = m_scaleY->getValue(frame) / 100.0;
double angle = -m_angle->getValue(frame);
TPointD center = m_center->getValue(frame) * (1.0 / info.m_shrinkX);
// The warper is calculated on a standard reference, with fixed dpi. This
// makes sure
// that the lattice created for the warp does not depend on camera
// transforms and resolution.
TRenderSettings warperInfo(info);
double warperScaleFactor = 1.0 / params.m_warperScale;
warperInfo.m_affine = TScale(warperScaleFactor) * info.m_affine;
// Retrieve tile's geometry
TRectD tileRect;
{
TRasterP tileRas = tile.getRaster();
tileRect =
TRectD(tile.m_pos, TDimensionD(tileRas->getLx(), tileRas->getLy()));
}
// Build the compute rect
TRectD warpedBox, warpedComputeRect, tileComputeRect;
m_warped->getBBox(frame, warpedBox, info);
getWarpComputeRects(tileComputeRect, warpedComputeRect, warpedBox, tileRect,
params);
if (tileComputeRect.getLx() <= 0 || tileComputeRect.getLy() <= 0) return;
if (warpedComputeRect.getLx() <= 0 || warpedComputeRect.getLy() <= 0)
return;
TRectD warperComputeRect(TScale(warperScaleFactor) * tileComputeRect);
double warperEnlargement = getWarperEnlargement(params);
warperComputeRect = warperComputeRect.enlarge(warperEnlargement);
warperComputeRect.x0 = tfloor(warperComputeRect.x0);
warperComputeRect.y0 = tfloor(warperComputeRect.y0);
warperComputeRect.x1 = tceil(warperComputeRect.x1);
warperComputeRect.y1 = tceil(warperComputeRect.y1);
// Compute the warped tile
TTile tileIn;
m_warped->allocateAndCompute(
tileIn, warpedComputeRect.getP00(),
TDimension(warpedComputeRect.getLx(), warpedComputeRect.getLy()),
tile.getRaster(), frame, info);
TRasterP rasIn = tileIn.getRaster();
// Compute the warper tile
TSpectrum::ColorKey colors[] = {TSpectrum::ColorKey(0, TPixel32::White),
TSpectrum::ColorKey(0.5, TPixel32::Black),
TSpectrum::ColorKey(1, TPixel32::White)};
TSpectrumParamP ripplecolors = TSpectrumParamP(tArrayCount(colors), colors);
// Build the multiradial
warperInfo.m_affine = warperInfo.m_affine * TTranslation(center) *
TRotation(angle) * TScale(scaleX, scaleY);
TAffine aff = warperInfo.m_affine.inv();
TPointD posTrasf = aff * (warperComputeRect.getP00());
TRasterP rasWarper =
rasIn->create(warperComputeRect.getLx(), warperComputeRect.getLy());
multiRadial(rasWarper, posTrasf, ripplecolors, period, count, cycle, aff,
frame);
// TImageWriter::save(TFilePath("C:\\ripple.tif"), rasWarper);
// Warp
TPointD db;
TRect rasComputeRectI(convert(tileComputeRect - tileRect.getP00(), db));
TRasterP tileRas = tile.getRaster()->extract(rasComputeRectI);
TPointD rasInPos(warpedComputeRect.getP00() - tileComputeRect.getP00());
TPointD warperPos(
(TScale(params.m_warperScale) * warperComputeRect.getP00()) -
tileComputeRect.getP00());
warp(tileRas, rasIn, rasWarper, rasInPos, warperPos, params);
}
bool RenderCommand::init(bool isPreview)
{
ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();
TSceneProperties *sprop = scene->getProperties();
/*-- Preview/Renderに応じてそれぞれのSettingを取得 --*/
TOutputProperties &outputSettings = isPreview ? *sprop->getPreviewProperties() : *sprop->getOutputProperties();
outputSettings.getRange(m_r0, m_r1, m_step);
/*-- シーン全体のレンダリングの場合、m_r1をScene長に設定 --*/
if (m_r0 == 0 && m_r1 == -1) {
m_r0 = 0;
m_r1 = scene->getFrameCount() - 1;
}
if (m_r0 < 0)
m_r0 = 0;
if (m_r1 >= scene->getFrameCount())
m_r1 = scene->getFrameCount() - 1;
if (m_r1 < m_r0) {
MsgBox(WARNING, QObject::tr("The command cannot be executed because the scene is empty."));
return false;
// throw TException("empty scene");
// non so perche', ma termina il programma
// nonostante il try all'inizio
}
// Initialize the preview case
/*TRenderSettings rs = sprop->getPreviewProperties()->getRenderSettings();
TRenderSettings rso = sprop->getOutputProperties()->getRenderSettings();
rs.m_stereoscopic=true;
rs.m_stereoscopicShift=0.05;
rso.m_stereoscopic=true;
rso.m_stereoscopicShift=0.05;
sprop->getPreviewProperties()->setRenderSettings(rs);
sprop->getOutputProperties()->setRenderSettings(rso);*/
if (isPreview) {
/*-- PreviewではTimeStretchを考慮しないので、そのままフレーム値を格納してゆく --*/
m_numFrames = (int)(m_r1 - m_r0 + 1);
m_r = m_r0;
m_stepd = m_step;
m_multimediaRender = 0;
return true;
}
// Full render case
// Read the output filepath
TFilePath fp = outputSettings.getPath();
/*-- ファイル名が指定されていない場合は、シーン名を出力ファイル名にする --*/
if (fp.getWideName() == L"")
fp = fp.withName(scene->getScenePath().getName());
/*-- ラスタ画像の場合、ファイル名にフレーム番号を追加 --*/
if (TFileType::getInfo(fp) == TFileType::RASTER_IMAGE || fp.getType() == "pct" || fp.getType() == "pic" || fp.getType() == "pict") //pct e' un formato"livello" (ha i settings di quicktime) ma fatto di diversi frames
fp = fp.withFrame(TFrameId::EMPTY_FRAME);
fp = scene->decodeFilePath(fp);
if (!TFileStatus(fp.getParentDir()).doesExist()) {
try {
TFilePath parent = fp.getParentDir();
TSystem::mkDir(parent);
DvDirModel::instance()->refreshFolder(parent.getParentDir());
} catch (TException &e) {
MsgBox(WARNING, QObject::tr("It is not possible to create folder : %1").arg(QString::fromStdString(toString(e.getMessage()))));
return false;
} catch (...) {
MsgBox(WARNING, QObject::tr("It is not possible to create a folder."));
return false;
}
}
m_fp = fp;
// Retrieve camera infos
const TCamera *camera = isPreview ? scene->getCurrentPreviewCamera() : scene->getCurrentCamera();
TDimension cameraSize = camera->getRes();
TPointD cameraDpi = camera->getDpi();
// Retrieve render interval/step/times
double stretchTo = (double)outputSettings.getRenderSettings().m_timeStretchTo;
double stretchFrom = (double)outputSettings.getRenderSettings().m_timeStretchFrom;
m_timeStretchFactor = stretchTo / stretchFrom;
m_stepd = m_step / m_timeStretchFactor;
int stretchedR0 = tfloor(m_r0 * m_timeStretchFactor);
int stretchedR1 = tceil((m_r1 + 1) * m_timeStretchFactor) - 1;
m_r = stretchedR0 / m_timeStretchFactor;
m_numFrames = (stretchedR1 - stretchedR0) / m_step + 1;
// Update the multimedia render switch
m_multimediaRender = outputSettings.getMultimediaRendering();
return true;
}
void doCompute(TTile &tile, double frame, const TRenderSettings &info)
{
bool isWarped = m_warped.isConnected();
if (!isWarped)
return;
if (fabs(m_intensity->getValue(frame)) < 0.01) {
m_warped->compute(tile, frame, info);
return;
}
int shrink = (info.m_shrinkX + info.m_shrinkY) / 2;
double scale = sqrt(fabs(info.m_affine.det()));
double gridStep = 1.5 * m_gridStep->getValue(frame);
WarpParams params;
params.m_intensity = m_intensity->getValue(frame) / gridStep;
params.m_warperScale = scale * gridStep;
params.m_sharpen = m_sharpen->getValue();
params.m_shrink = shrink;
double evolution = m_evol->getValue(frame);
double size = 100.0 / info.m_shrinkX;
TPointD pos(m_posx->getValue(frame), m_posy->getValue(frame));
//The warper is calculated on a standard reference, with fixed dpi. This makes sure
//that the lattice created for the warp does not depend on camera transforms and resolution.
TRenderSettings warperInfo(info);
double warperScaleFactor = 1.0 / params.m_warperScale;
warperInfo.m_affine = TScale(warperScaleFactor) * info.m_affine;
//Retrieve tile's geometry
TRectD tileRect;
{
TRasterP tileRas = tile.getRaster();
tileRect = TRectD(tile.m_pos, TDimensionD(tileRas->getLx(), tileRas->getLy()));
}
//Build the compute rect
TRectD warpedBox, warpedComputeRect, tileComputeRect;
m_warped->getBBox(frame, warpedBox, info);
getWarpComputeRects(tileComputeRect, warpedComputeRect, warpedBox, tileRect, params);
if (tileComputeRect.getLx() <= 0 || tileComputeRect.getLy() <= 0)
return;
if (warpedComputeRect.getLx() <= 0 || warpedComputeRect.getLy() <= 0)
return;
TRectD warperComputeRect(TScale(warperScaleFactor) * tileComputeRect);
double warperEnlargement = getWarperEnlargement(params);
warperComputeRect = warperComputeRect.enlarge(warperEnlargement);
warperComputeRect.x0 = tfloor(warperComputeRect.x0);
warperComputeRect.y0 = tfloor(warperComputeRect.y0);
warperComputeRect.x1 = tceil(warperComputeRect.x1);
warperComputeRect.y1 = tceil(warperComputeRect.y1);
//Compute the warped tile
TTile tileIn;
m_warped->allocateAndCompute(tileIn, warpedComputeRect.getP00(),
TDimension(warpedComputeRect.getLx(), warpedComputeRect.getLy()),
tile.getRaster(), frame, info);
TRasterP rasIn = tileIn.getRaster();
//Compute the warper tile
TSpectrum::ColorKey colors[] = {
TSpectrum::ColorKey(0, TPixel32::White),
TSpectrum::ColorKey(1, TPixel32::Black)};
TSpectrumParamP cloudscolors = TSpectrumParamP(tArrayCount(colors), colors);
//Build the warper
warperInfo.m_affine = warperInfo.m_affine;
TAffine aff = warperInfo.m_affine.inv();
TTile warperTile;
TRasterP rasWarper = rasIn->create(warperComputeRect.getLx(), warperComputeRect.getLy());
warperTile.m_pos = warperComputeRect.getP00();
warperTile.setRaster(rasWarper);
{
TRenderSettings info2(warperInfo);
//Now, separate the part of the affine the Fx can handle from the rest.
TAffine fxHandledAffine = handledAffine(warperInfo, frame);
info2.m_affine = fxHandledAffine;
TAffine aff = warperInfo.m_affine * fxHandledAffine.inv();
aff.a13 /= warperInfo.m_shrinkX;
aff.a23 /= warperInfo.m_shrinkY;
TRectD rectIn = aff.inv() * warperComputeRect;
//rectIn = rectIn.enlarge(getResampleFilterRadius(info)); //Needed to counter the resample filter
TRect rectInI(tfloor(rectIn.x0), tfloor(rectIn.y0), tceil(rectIn.x1) - 1, tceil(rectIn.y1) - 1);
// rasIn e' un raster dello stesso tipo di tile.getRaster()
TTile auxtile(warperTile.getRaster()->create(rectInI.getLx(), rectInI.getLy()), convert(rectInI.getP00()));
TPointD mypos(auxtile.m_pos - pos);
double scale2 = sqrt(fabs(info2.m_affine.det()));
doClouds(auxtile.getRaster(), cloudscolors, mypos, evolution, size, 0.0, 1.0, PNOISE_CLOUDS, scale2, frame);
info2.m_affine = aff;
TRasterFx::applyAffine(warperTile, auxtile, info2);
}
//Warp
TPointD db;
TRect rasComputeRectI(convert(tileComputeRect - tileRect.getP00(), db));
TRasterP tileRas = tile.getRaster()->extract(rasComputeRectI);
TPointD rasInPos(warpedComputeRect.getP00() - tileComputeRect.getP00());
TPointD warperPos((TScale(params.m_warperScale) * warperComputeRect.getP00()) - tileComputeRect.getP00());
warp(tileRas, rasIn, rasWarper, rasInPos, warperPos, params);
}
void blend(TToonzImageP ti, TRasterPT<PIXEL> rasOut,
const std::vector<BlendParam> ¶ms) {
assert(ti->getRaster()->getSize() == rasOut->getSize());
// Extract the interesting raster. It should be the savebox of passed cmap,
// plus - if
// some param has the 0 index as blending color - the intensity of that blend
// param.
unsigned int i, j;
TRect saveBox(ti->getSavebox());
int enlargement = 0;
for (i = 0; i < params.size(); ++i)
for (j = 0; j < params[i].colorsIndexes.size(); ++j)
if (params[i].colorsIndexes[j] == 0)
enlargement = std::max(enlargement, tceil(params[i].intensity));
saveBox = saveBox.enlarge(enlargement);
TRasterCM32P cmIn(ti->getRaster()->extract(saveBox));
TRasterPT<PIXEL> rasOutExtract = rasOut->extract(saveBox);
// Ensure that cmIn and rasOut have the same size
unsigned int lx = cmIn->getLx(), ly = cmIn->getLy();
// Build the pure colors infos
SelectionRaster selectionRaster(cmIn);
// Now, build a little group of BlurPatterns - and for each, one for passed
// param.
// A small number of patterns per param is needed to make the pattern look not
// ever the same.
const int blurPatternsPerParam = 10;
std::vector<BlurPatternContainer> blurGroup(params.size());
for (i = 0; i < params.size(); ++i) {
BlurPatternContainer &blurContainer = blurGroup[i];
blurContainer.reserve(blurPatternsPerParam);
for (j = 0; j < blurPatternsPerParam; ++j)
blurContainer.push_back(BlurPattern(
params[i].intensity, params[i].smoothness, params[i].stopAtCountour));
}
// Build the palette
TPalette *palette = ti->getPalette();
std::vector<TPixel32> paletteColors;
paletteColors.resize(palette->getStyleCount());
for (i = 0; i < paletteColors.size(); ++i)
paletteColors[i] = premultiply(palette->getStyle(i)->getAverageColor());
// Build the 4 auxiliary rasters for the blending procedure: they are ink /
// paint versus input / output in the blend.
// The output raster is reused to spare some memory - it should be, say, the
// inkLayer's second at the end of the overall
// blending procedure. It could be the first, without the necessity of
// clearing it before blending the layers, but things
// get more complicated when PIXEL is TPixel64...
RGBMRasterPair inkLayer, paintLayer;
TRaster32P rasOut32P_1(lx, ly, lx, (TPixel32 *)rasOut->getRawData(), false);
inkLayer.first = (params.size() % 2) ? rasOut32P_1 : TRaster32P(lx, ly);
inkLayer.second = (params.size() % 2) ? TRaster32P(lx, ly) : rasOut32P_1;
if (PIXEL::maxChannelValue >= TPixel64::maxChannelValue) {
TRaster32P rasOut32P_2(lx, ly, lx,
((TPixel32 *)rasOut->getRawData()) + lx * ly, false);
paintLayer.first = (params.size() % 2) ? rasOut32P_2 : TRaster32P(lx, ly);
paintLayer.second = (params.size() % 2) ? TRaster32P(lx, ly) : rasOut32P_2;
} else {
paintLayer.first = TRaster32P(lx, ly);
paintLayer.second = TRaster32P(lx, ly);
}
inkLayer.first->clear();
inkLayer.second->clear();
paintLayer.first->clear();
paintLayer.second->clear();
// Now, we have to perform the blur of each of the cm's pixels.
cmIn->lock();
rasOut->lock();
inkLayer.first->lock();
inkLayer.second->lock();
paintLayer.first->lock();
paintLayer.second->lock();
// Convert the initial cmIn to fullcolor ink - paint layers
buildLayers(cmIn, paletteColors, inkLayer.first, paintLayer.first);
// Perform the blend on separated ink - paint layers
for (i = 0; i < params.size(); ++i) {
if (params[i].colorsIndexes.size() == 0) continue;
selectionRaster.updateSelection(cmIn, params[i]);
doBlend(cmIn, inkLayer, paintLayer, selectionRaster, blurGroup[i]);
tswap(inkLayer.first, inkLayer.second);
tswap(paintLayer.first, paintLayer.second);
}
// Release the unnecessary rasters
inkLayer.second->unlock();
paintLayer.second->unlock();
inkLayer.second = TRaster32P();
paintLayer.second = TRaster32P();
// Clear rasOut - since it was reused to spare space...
rasOut->clear();
// Add the ink & paint layers on the output raster
double PIXELmaxChannelValue = PIXEL::maxChannelValue;
double toPIXELFactor =
PIXELmaxChannelValue / (double)TPixel32::maxChannelValue;
double inkFactor, paintFactor;
TPoint pos;
PIXEL *outPix, *outBegin = (PIXEL *)rasOutExtract->getRawData();
TPixelCM32 *cmPix, *cmBegin = (TPixelCM32 *)cmIn->getRawData();
int wrap = rasOutExtract->getWrap();
TPixel32 *inkPix = (TPixel32 *)inkLayer.first->getRawData();
TPixel32 *paintPix = (TPixel32 *)paintLayer.first->getRawData();
for (i = 0; i < ly; ++i) {
outPix = outBegin + wrap * i;
cmPix = cmBegin + wrap * i;
for (j = 0; j < lx; ++j, ++outPix, ++cmPix, ++inkPix, ++paintPix) {
getFactors(cmPix->getTone(), inkFactor, paintFactor);
outPix->r = tcrop(
toPIXELFactor * (inkFactor * inkPix->r + paintFactor * paintPix->r),
0.0, PIXELmaxChannelValue);
outPix->g = tcrop(
toPIXELFactor * (inkFactor * inkPix->g + paintFactor * paintPix->g),
0.0, PIXELmaxChannelValue);
outPix->b = tcrop(
toPIXELFactor * (inkFactor * inkPix->b + paintFactor * paintPix->b),
0.0, PIXELmaxChannelValue);
outPix->m = tcrop(
toPIXELFactor * (inkFactor * inkPix->m + paintFactor * paintPix->m),
0.0, PIXELmaxChannelValue);
}
}
inkLayer.first->unlock();
paintLayer.first->unlock();
cmIn->unlock();
rasOut->unlock();
// Destroy the auxiliary bitmaps
selectionRaster.destroy();
}
/*- render_particles から呼ばれる。粒子の数だけ繰り返し -*/
void Particles_Engine::do_render(
TFlash *flash, Particle *part, TTile *tile,
std::vector<TRasterFxPort *> part_ports, std::map<int, TTile *> porttiles,
const TRenderSettings &ri, TDimension &p_size, TPointD &p_offset,
int lastframe, std::vector<TLevelP> partLevel,
struct particles_values &values, double opacity_range, int dist_frame,
std::map<std::pair<int, int>, double> &partScales) {
// Retrieve the particle frame - that is, the *column frame* from which we are
// picking
// the particle to be rendered.
int ndx = part->frame % lastframe;
TRasterP tileRas(tile->getRaster());
std::string levelid;
double aim_angle = 0;
if (values.pathaim_val) {
double arctan = atan2(part->vy, part->vx);
aim_angle = arctan * M_180_PI;
}
// Calculate the rotational and scale components we have to apply on the
// particle
TRotation rotM(part->angle + aim_angle);
TScale scaleM(part->scale);
TAffine M(rotM * scaleM);
// Particles deal with dpi affines on their own
TAffine scaleAff(m_parent->handledAffine(ri, m_frame));
double partScale =
scaleAff.a11 * partScales[std::pair<int, int>(part->level, ndx)];
TDimensionD partResolution(0, 0);
TRenderSettings riNew(ri);
// Retrieve the bounding box in the standard reference
TRectD bbox(-5.0, -5.0, 5.0, 5.0), standardRefBBox;
if (part->level <
(int)part_ports.size() && // Not the default levelless cases
part_ports[part->level]->isConnected()) {
TRenderSettings riIdentity(ri);
riIdentity.m_affine = TAffine();
(*part_ports[part->level])->getBBox(ndx, bbox, riIdentity);
// A particle's bbox MUST be finite. Gradients and such which have an
// infinite bbox
// are just NOT rendered.
// NOTE: No fx returns half-planes or similar (ie if any coordinate is
// either
// (std::numeric_limits<double>::max)() or its opposite, then the rect IS
// THE infiniteRectD)
if (bbox == TConsts::infiniteRectD) return;
}
// Now, these are the particle rendering specifications
bbox = bbox.enlarge(3);
standardRefBBox = bbox;
riNew.m_affine = TScale(partScale);
bbox = riNew.m_affine * bbox;
/*- 縮小済みのParticleのサイズ -*/
partResolution = TDimensionD(tceil(bbox.getLx()), tceil(bbox.getLy()));
if (flash) {
if (!partLevel[part->level]->frame(ndx)) {
if (part_ports[0]->isConnected()) {
TTile auxTile;
TRaster32P tmp;
tmp = TRaster32P(p_size);
(*part_ports[0])
->allocateAndCompute(auxTile, p_offset, p_size, tmp, ndx, ri);
partLevel[part->level]->setFrame(ndx,
TRasterImageP(auxTile.getRaster()));
}
}
flash->pushMatrix();
const TAffine aff;
flash->multMatrix(scaleM * aff.place(0, 0, part->x, part->y));
// if(curr_opacity!=1.0 || part->gencol.fadecol || part->fincol.fadecol ||
// part->foutcol.fadecol)
{
TColorFader cf(TPixel32::Red, .5);
flash->draw(partLevel[part->level]->frame(ndx), &cf);
}
// flash->draw(partLevel->frame(ndx), 0);
flash->popMatrix();
} else {
TRasterP ras;
std::string alias;
TRasterImageP rimg;
if (rimg = partLevel[part->level]->frame(ndx)) {
ras = rimg->getRaster();
} else {
alias = "PART: " + (*part_ports[part->level])->getAlias(ndx, riNew);
if (rimg = TImageCache::instance()->get(alias, false)) {
ras = rimg->getRaster();
// Check that the raster resolution is sufficient for our purposes
if (ras->getLx() < partResolution.lx ||
ras->getLy() < partResolution.ly)
ras = 0;
else
partResolution = TDimensionD(ras->getLx(), ras->getLy());
}
}
// We are interested in making the relation between scale and (integer)
// resolution
// bijective - since we shall cache by using resolution as a partial
// identification parameter.
// Therefore, we find the current bbox Lx and take a unique scale out of it.
partScale = partResolution.lx / standardRefBBox.getLx();
riNew.m_affine = TScale(partScale);
bbox = riNew.m_affine * standardRefBBox;
// If no image was retrieved from the cache (or it was not scaled enough),
// calculate it
if (!ras) {
TTile auxTile;
(*part_ports[part->level])
->allocateAndCompute(auxTile, bbox.getP00(),
TDimension(partResolution.lx, partResolution.ly),
tile->getRaster(), ndx, riNew);
ras = auxTile.getRaster();
// For now, we'll just use 32 bit particles
TRaster32P rcachepart;
rcachepart = ras;
if (!rcachepart) {
rcachepart = TRaster32P(ras->getSize());
TRop::convert(rcachepart, ras);
}
ras = rcachepart;
// Finally, cache the particle
addRenderCache(alias, TRasterImageP(ras));
}
if (!ras) return; // At this point, it should never happen anyway...
// Deal with particle colors/opacity
TRaster32P rfinalpart;
double curr_opacity =
part->set_Opacity(porttiles, values, opacity_range, dist_frame);
if (curr_opacity != 1.0 || part->gencol.fadecol || part->fincol.fadecol ||
part->foutcol.fadecol) {
/*- 毎フレーム現在位置のピクセル色を参照 -*/
if (values.pick_color_for_every_frame_val && values.gencol_ctrl_val &&
(porttiles.find(values.gencol_ctrl_val) != porttiles.end()))
part->get_image_reference(porttiles[values.gencol_ctrl_val], values,
part->gencol.col);
rfinalpart = ras->clone();
part->modify_colors_and_opacity(values, curr_opacity, dist_frame,
rfinalpart);
} else
rfinalpart = ras;
// Now, let's build the particle transform before it is overed on the output
// tile
// First, complete the transform by adding the rotational and scale
// components from
// Particles parameters
M = ri.m_affine * M * TScale(1.0 / partScale);
// Then, retrieve the particle position in current reference.
TPointD pos(part->x, part->y);
pos = ri.m_affine * pos;
// Finally, add the translational component to the particle
// NOTE: p_offset is added to account for the particle relative position
// inside its level's bbox
M = TTranslation(pos - tile->m_pos) * M * TTranslation(bbox.getP00());
if (TRaster32P myras32 = tile->getRaster())
TRop::over(tileRas, rfinalpart, M);
else if (TRaster64P myras64 = tile->getRaster())
TRop::over(tileRas, rfinalpart, M);
else
throw TException("ParticlesFx: unsupported Pixel Type");
}
}
void TRop::brush(
TRaster32P ras,
const TPoint &aa,
const TPoint &bb,
int radius,
const TPixel32 &col)
{
TPoint a = aa;
TPoint b = bb;
if (a.y > b.y)
tswap(a, b); // a e' piu' in basso di b
int lx = ras->getLx();
int ly = ras->getLy();
ras->lock();
// ----- radius = 0
if (radius == 0) {
// k = +1/-1 se il rettangolo e' inclinato positivamente (0<=m)/negativamente (m<0)
// (se k<0 viene fatta una riflessione sulle ascisse prima di tornare alle
// coordinate "di schermo")
int k = 1;
int dy = b.y - a.y;
int dx = b.x - a.x;
if (dx < 0) {
dx = -dx;
k = -1;
}
assert(dx >= 0);
assert(dy >= 0);
double m; // m sara' definita solo per dx!=0)
if (dx > 0) {
m = dy / (double)dx;
}
//double length = sqrt(dx*dx + dy*dy);
const int alpha = dy, beta = -dx;
const int incE = alpha;
const int incNE = alpha + beta;
const int incN = beta;
// N.B. le coordinate sono relative ad un sist. di rif. con l'origine in a
// l'eq. della retta e' alpha * x + beta * y = 0
int yMin = tmax(a.y, 0) - a.y; // clipping y + cambio riferimento
int yMax = tmin(b.y, ly - 1) - a.y; // (trasporto dell'origine in a)
if (dx > 0 && m <= 1) {
// midpoint algorithm
TPoint segm;
if (dy == 0) // segmento orizzontale: inizializza segm
{
segm.x = 0;
segm.y = yMin;
} else // 0<m<=1 : inizializza segm
{
segm.x = tceil((yMin - 0.5) / m);
segm.y = yMin;
}
int dSegm = tfloor(alpha * (segm.x + 1) + beta * (segm.y + 0.5));
while (segm.y <= yMax) {
int count = 0; // i trati orizzontali di segm vengono disegnati in "blocco"
while (dSegm < 0 && segm.x <= dx) // Est: segm.x<=dx evita il ciclo
{ // infinito quando m=0 (incE=0)
dSegm = dSegm + incE;
segm.x++;
count++;
}
// NordEst
int xMin, xMax;
if (k > 0) {
xMin = tmax(a.x + segm.x - count, a.x, 0); // clipping x + ritorno alle
xMax = tmin(a.x + segm.x, b.x, lx - 1); // coordinate "di schermo"
} else {
xMin = tmax(a.x - segm.x, a.x - dx, 0); // clipping x + riflessione + ritorno
xMax = tmin(a.x - segm.x + count, a.x, lx - 1); // alle coordinate "di schermo"
}
TPixel32 *p = ras->pixels(segm.y + a.y) + xMin;
TPixel32 *q = p + (xMax - xMin);
while (p <= q)
*p++ = col;
dSegm = dSegm + incNE;
segm.x++;
segm.y++;
}
} else // m>1 oppure segmento verticale
{
// midpoint algorithm
TPoint segm;
if (dx == 0) // segmento verticale: inizializza segm
{
segm.x = 0;
segm.y = yMin;
} else // m>1 : inizializza segm
{
segm.x = tround(yMin / m);
segm.y = yMin;
}
int dSegm = tfloor(alpha * (segm.x + 0.5) + beta * (segm.y + 1));
while (segm.y <= yMax) {
int xMin, xMax;
if (k > 0) {
xMin = tmax(a.x + segm.x, 0); // clipping x + ritorno alle
xMax = tmin(a.x + segm.x, lx - 1); // coordinate "di schermo"
} else {
xMin = tmax(a.x - segm.x, 0); // clipping x + riflessione + ritorno
xMax = tmin(a.x - segm.x, lx - 1); // alle coordinate "di schermo"
}
TPixel32 *p = ras->pixels(segm.y + a.y) + xMin;
TPixel32 *q = p + (xMax - xMin);
while (p <= q)
*p++ = col;
if (dSegm <= 0) // NordEst
{
dSegm = dSegm + incNE;
segm.x++;
} else // Nord
{
dSegm = dSegm + incN;
}
segm.y++;
}
}
ras->unlock();
return;
}
HalfCord halfCord(radius);
int x, y;
// ----- punti iniziali coincidenti: disegna un cerchio
if (a == b) {
int yMin = tmax(a.y - radius, 0); // clipping y
int yMax = tmin(a.y + radius, ly - 1); // clipping y
for (y = yMin; y <= yMax; y++) {
int deltay = abs(y - a.y);
int xMin = tmax(a.x - halfCord.getCord(deltay), 0); // clipping x
int xMax = tmin(a.x + halfCord.getCord(deltay), lx - 1); // clipping x
TPixel32 *p = ras->pixels(y) + xMin;
TPixel32 *q = p + (xMax - xMin);
while (p <= q)
*p++ = col;
}
ras->unlock();
return;
}
// ----- rettangolo orizzontale (a.y = b.y, a.x != b.x)
if (a.y == b.y) {
int yMin = tmax((a.y - radius), 0); // clipping y
int yMax = tmin((a.y + radius), ly - 1); // clipping y
int xLeft = tmin(a.x, b.x);
int xRight = tmax(a.x, b.x);
for (y = yMin; y <= yMax; y++) {
int deltay = abs(y - a.y);
int xMin = tmax(xLeft - halfCord.getCord(deltay), 0); // clipping x
int xMax = tmin(xRight + halfCord.getCord(deltay), lx - 1); // clipping x
TPixel32 *p = ras->pixels(y) + xMin;
TPixel32 *q = p + (xMax - xMin);
while (p <= q)
*p++ = col;
}
ras->unlock();
return;
}
// ----- rettangolo verticale (a.x = b.x, a.y != b.y)
if (a.x == b.x) {
int xMin = tmax(a.x - radius, 0); // clipping x
int xMax = tmin(a.x + radius, lx - 1); // clipping x
for (x = xMin; x <= xMax; x++) {
int deltax = abs(x - a.x);
int yMin = tmax(a.y - halfCord.getCord(deltax), 0); // clipping y
int yMax = tmin(b.y + halfCord.getCord(deltax), ly - 1); // clipping y
if (yMin <= yMax) {
TPixel32 *p = ras->pixels(yMin) + x;
TPixel32 *q = ras->pixels(yMax) + x;
int wrap = ras->getWrap();
while (p <= q) {
*p = col;
p += wrap;
}
}
}
ras->unlock();
return;
}
// ----- rettangolo inclinato
// k = +1/-1 se il rettangolo e' inclinato positivamente/negativamente
int k = 1;
int dx = b.x - a.x;
if (dx < 0) {
dx = -dx;
k = -1;
}
int dy = b.y - a.y;
assert(dx > 0);
assert(dy > 0);
double length = sqrt((double)(dx * dx + dy * dy));
const double m = dy / (double)dx;
//punto di tangenza superiore nel sistema di riferimento del cerchio
TPointD up(-radius * dy / length, radius * dx / length);
//semi-ampiezza orizzontale delle "calotte" circolari
int halfAmplCap = tfloor(-up.x);
// A meno di intersezioni relative tra le diverse zone:
// le scanline della "calotta" circolare superiore sono (b.y+cutExt,b.y+radius]
// le scanline del trapezoide circolare superiore sono [b.y-cutIn,b.y+cutExt]
// le scanline del parallelogramma sono (a.y+cutIn,b.y-cutIn)
// le scanline del trapezoide circolare inferiore sono [a.y-cutExt,a.y+cutIn]
// le scanline della "calotta" circolare inferiore sono [a.y-radius,a.y-cutExt)
int cutExt, cutIn;
// vertici del parallelogramma
TPointD rightUp;
TPointD rightDown;
TPointD leftUp;
TPointD leftDown;
double mParall; //coeff. angolare parallelogramma
// NOTA BENE: halfAmplCap=0 <=> (radius=0 (caso a parte) , 1)
if (radius > 1) {
for (cutExt = radius; cutExt >= 0 && halfCord.getCord(cutExt) <= halfAmplCap; cutExt--)
;
cutIn = cutExt; // vedi else successivo
rightUp.x = dx + halfCord.getCord(cutIn);
rightUp.y = dy - cutIn;
rightDown.x = halfCord.getCord(cutIn);
rightDown.y = -cutIn;
leftUp.x = dx - halfCord.getCord(cutIn);
leftUp.y = dy + cutIn;
leftDown.x = -halfCord.getCord(cutIn);
leftDown.y = cutIn;
mParall = dy / (double)dx;
} else // N.B. cutExt != cutIn solo quando radius=1
{
cutExt = radius; // radius=1 => halfAmplCap=0 (non ci sono mai le "calotte" circolari)
cutIn = 0; // anche per radius=1 il limite "interno" dei trapezoidi circolari e' < radius
rightUp.x = dx - up.x;
rightUp.y = dy - up.y;
rightDown.x = -up.x;
rightDown.y = -up.y;
leftUp.x = dx + up.x;
leftUp.y = dy + up.y;
leftDown.x = up.x;
leftDown.y = up.y;
mParall = m;
}
// ----- riempie "calotte" circolari
// ----- riempie "calotta" circolare inferiore
int yMin = tmax(a.y - radius, 0); // clipping y
int yMax = tmin(a.y - cutExt - 1, ly - 1); // clipping y
for (y = yMin; y <= yMax; y++) {
int r = halfCord.getCord(a.y - y);
int xMin = tmax(a.x - r, 0); // clipping x
int xMax = tmin(a.x + r, lx - 1); // clipping x
TPixel32 *p = ras->pixels(y) + xMin;
TPixel32 *q = p + (xMax - xMin);
while (p <= q)
*p++ = col;
}
// ----- riempie "calotta" circolare superiore
yMin = tmax(b.y + cutExt + 1, 0); // clipping y
yMax = tmin(b.y + radius, ly - 1); // clipping y
for (y = yMin; y <= yMax; y++) {
int r = halfCord.getCord(y - b.y);
int xMin = tmax(b.x - r, 0); // clipping x
int xMax = tmin(b.x + r, lx - 1); // clipping x
TPixel32 *p = ras->pixels(y) + xMin;
TPixel32 *q = p + (xMax - xMin);
while (p <= q)
*p++ = col;
}
// ----- riempie trapezoidi
// (se k<0 viene fatta una riflessione sulle ascisse prima di tornare alle
// coordinate "di schermo")
// limite destro assoluto delle scanline trapezoide:
int xSegmMax = tround(dx - up.x); // coordinata x del punto di tangenza inferiore sul cerchio superiore
// limite sinistro assoluto delle scanline:
int xSegmMin = tround(up.x); // coordinata x del punto di tangenza superiore sul cerchio inferiore
// ----- riempie trapezoide inferiore
// N.B. le coordinate sono relative ad un sist. di rif. con l'origine sul centro
// del cerchio inferiore
yMin = tmax(a.y - cutExt, 0) - a.y; // clipping y
yMax = tmin(a.y + cutIn, b.y - cutIn - 1, ly - 1) - a.y; // clipping y
// l'eq. della retta e' alpha * x + beta * y + gammaRight = 0
const int alpha = dy, beta = -dx;
const double gammaRight = rightDown.y * dx - rightDown.x * dy;
const int incE = alpha;
const int incNE = alpha + beta;
const int incN = beta;
if (m <= 1) {
// midpoint algorithm; le scanline vengono disegnate solo
// sul NordEst. L'ultima scanline non viene disegnata
TPoint segmRight(tceil((yMin + 0.5 - rightDown.y) / mParall + rightDown.x) - 1, yMin);
int dSegmRight = tfloor(alpha * (segmRight.x + 1) + beta * (segmRight.y + 0.5) + gammaRight);
while (segmRight.y <= yMax) {
if (dSegmRight < 0) // Est
{
dSegmRight = dSegmRight + incE;
segmRight.x++;
} else // NordEst
{
int xMin, xMax;
if (k > 0) {
xMin = tmax(a.x - halfCord.getCord(abs(segmRight.y)), 0); // clipping x
xMax = tmin(a.x + tmin(segmRight.x, xSegmMax), lx - 1); // clipping x
} else {
xMin = tmax(a.x - tmin(segmRight.x, xSegmMax), 0); // clipping x + ritorno alle
xMax = tmin(a.x + halfCord.getCord(abs(segmRight.y)), lx - 1); // coordinate "di schermo"
}
TPixel32 *p = ras->pixels(segmRight.y + a.y) + xMin;
TPixel32 *q = p + (xMax - xMin);
while (p <= q)
*p++ = col;
dSegmRight = dSegmRight + incNE;
segmRight.x++;
segmRight.y++;
}
}
} else // m>1
{
// midpoint algorithm; le scanline vengono disegnate sempre
TPoint segmRight(tround((yMin - rightDown.y) / mParall + rightDown.x), yMin);
int dSegmRight = tfloor(alpha * (segmRight.x + 0.5) + beta * (segmRight.y + 1) + gammaRight);
while (segmRight.y <= yMax) {
int xMin, xMax;
if (k > 0) {
xMin = tmax(a.x - halfCord.getCord(abs(segmRight.y)), 0); // clipping x
xMax = tmin(a.x + segmRight.x, lx - 1); // clipping x
} else {
xMin = tmax(a.x - segmRight.x, 0); // clipping x + ritorno alle coordinate
xMax = tmin(a.x + halfCord.getCord(abs(segmRight.y)), lx - 1); // "di schermo"
}
TPixel32 *p = ras->pixels(segmRight.y + a.y) + xMin;
TPixel32 *q = p + (xMax - xMin);
while (p <= q)
*p++ = col;
if (dSegmRight <= 0) // NordEst
{
dSegmRight = dSegmRight + incNE;
segmRight.x++;
} else // Nord
{
dSegmRight = dSegmRight + incN;
}
segmRight.y++;
}
}
// ----- riempie trapezoide superiore
// N.B. le coordinate sono relative ad un sist. di rif. con l'origine sul centro
// del cerchio superiore
yMin = tmax(b.y - cutIn, a.y + cutIn + 1, 0) - b.y; // clipping y
yMax = tmin(b.y + cutExt, ly - 1) - b.y; // clipping y
// l'eq. della retta e' alpha * x + beta * y + gammaLeft = 0
const double gammaLeft = leftDown.y * dx - leftDown.x * dy;
if (m <= 1) {
// midpoint algorithm; le scanline vengono disegnate solo
// sul NordEst. L'ultima scanline non viene disegnata
TPoint segmLeft(tceil((yMin - 0.5 - leftDown.y) / mParall + leftDown.x), yMin);
int dSegmLeft = tfloor(alpha * (segmLeft.x + 1) + beta * (segmLeft.y + 0.5) + gammaLeft);
while (segmLeft.y <= yMax) {
int xMin, xMax;
if (k > 0) {
xMin = tmax(b.x + tmax(segmLeft.x, xSegmMin - dx), 0); // clipping x
xMax = tmin(b.x + halfCord.getCord(abs(segmLeft.y)), lx - 1); // clipping x
} else {
xMin = tmax(b.x - halfCord.getCord(abs(segmLeft.y)), 0); // clipping x + ritorno alle
xMax = tmin(b.x - tmax(segmLeft.x, xSegmMin - dx), lx - 1); // coordinate "di schermo"
}
TPixel32 *p = ras->pixels(segmLeft.y + b.y) + xMin;
TPixel32 *q = p + (xMax - xMin);
while (p <= q)
*p++ = col;
while (dSegmLeft < 0) {
dSegmLeft = dSegmLeft + incE;
segmLeft.x++;
}
dSegmLeft = dSegmLeft + incNE;
segmLeft.x++;
segmLeft.y++;
}
} else // m>1
{
// midpoint algorithm; le scanline vengono disegnate sempre
TPoint segmLeft(tround((yMin - leftDown.y) / mParall + leftDown.x), yMin);
int dSegmLeft = tfloor(alpha * (segmLeft.x + 0.5) + beta * (segmLeft.y + 1) + gammaLeft);
while (segmLeft.y <= yMax) {
int xMin, xMax;
if (k > 0) {
xMin = tmax(b.x + segmLeft.x, 0); // clipping x
xMax = tmin(b.x + halfCord.getCord(abs(segmLeft.y)), lx - 1); // clipping x
} else {
xMin = tmax(b.x - halfCord.getCord(abs(segmLeft.y)), 0); // clipping x + ritorno alle
xMax = tmin(b.x - segmLeft.x, lx - 1); // coordinate "di schermo"
}
TPixel32 *p = ras->pixels(segmLeft.y + b.y) + xMin;
TPixel32 *q = p + (xMax - xMin);
while (p <= q)
*p++ = col;
if (dSegmLeft <= 0) // NordEst
{
dSegmLeft = dSegmLeft + incNE;
segmLeft.x++;
} else // Nord
{
dSegmLeft = dSegmLeft + incN;
}
segmLeft.y++;
}
}
// ----- parallelogramma (in alternativa a "parallelogrammoide circolare")
// N.B. le coordinate sono relative ad un sist. di rif. con l'origine sul centro
// del cerchio inferiore
// retta destra di equaz. alpha * x + beta * y + gammaRight = 0
// retta sinistra di equaz. alpha * x + beta * y + gammaLeft = 0
yMin = tmax(a.y + cutIn + 1, 0) - a.y; //clipping y
yMax = tmin(b.y - cutIn - 1, ly - 1) - a.y; //clipping y
if (m <= 1) {
// midpoint algorithm; le scanline vengono disegnate solo
// sul NordEst. L'ultima scanline non viene disegnata
TPoint segmRight(tceil((yMin + 0.5 - rightDown.y) / mParall + rightDown.x) - 1, yMin);
TPoint segmLeft = TPoint(tceil((yMin - 0.5 - leftDown.y) / mParall + leftDown.x), yMin);
int dSegmRight = tfloor(alpha * (segmRight.x + 1) + beta * (segmRight.y + 0.5) + gammaRight);
int dSegmLeft = tfloor(alpha * (segmLeft.x + 1) + beta * (segmLeft.y + 0.5) + gammaLeft);
while (segmRight.y <= yMax) {
if (dSegmRight < 0) // segmRight a Est
{
dSegmRight = dSegmRight + incE;
segmRight.x++;
} else // segmRight a NordEst
{
int xMin, xMax;
if (k > 0) {
xMin = tmax(a.x + tmax(segmLeft.x, xSegmMin), 0); // clipping x
xMax = tmin(a.x + tmin(segmRight.x, xSegmMax), lx - 1); // clipping x
} else {
xMin = tmax(a.x - tmin(segmRight.x, xSegmMax), 0); // clipping x + ritorno alle
xMax = tmin(a.x - tmax(segmLeft.x, xSegmMin), lx - 1); // coordinate "di schermo"
}
TPixel32 *p = ras->pixels(segmRight.y + a.y) + xMin;
TPixel32 *q = p + (xMax - xMin);
while (p <= q)
*p++ = col;
dSegmRight = dSegmRight + incNE;
segmRight.x++;
segmRight.y++;
while (dSegmLeft < 0) // segmLeft a Est
{
dSegmLeft = dSegmLeft + incE;
segmLeft.x++;
}
// segmLeft a NordEst
dSegmLeft = dSegmLeft + incNE;
segmLeft.x++;
segmLeft.y++;
}
}
} else // m>1
{
// midpoint algorithm; le scanline vengono disegnate sempre
TPoint segmRight(tround((yMin - rightDown.y) / mParall + rightDown.x), yMin);
TPoint segmLeft(tround((yMin - leftDown.y) / mParall + leftDown.x), yMin);
int dSegmRight = tfloor(alpha * (segmRight.x + 0.5) + beta * (segmRight.y + 1) + gammaRight);
int dSegmLeft = tfloor(alpha * (segmLeft.x + 0.5) + beta * (segmLeft.y + 1) + gammaLeft);
while (segmRight.y <= yMax) {
int xMin, xMax;
if (k > 0) {
xMin = tmax(a.x + segmLeft.x, 0); // clipping x
xMax = tmin(a.x + segmRight.x, lx - 1); // clipping x
} else {
xMin = tmax(a.x - segmRight.x, 0); // clipping x + ritorno alle
xMax = tmin(a.x - segmLeft.x, lx - 1); // coordinate "di schermo"
}
TPixel32 *p = ras->pixels(segmRight.y + a.y) + xMin;
TPixel32 *q = p + (xMax - xMin);
while (p <= q)
*p++ = col;
if (dSegmRight <= 0) // segmRight a NordEst
{
dSegmRight = dSegmRight + incNE;
segmRight.x++;
} else // segmRight a Nord
{
dSegmRight = dSegmRight + incN;
}
segmRight.y++;
if (dSegmLeft <= 0) // segmLeft a NordEst
{
dSegmLeft = dSegmLeft + incNE;
segmLeft.x++;
} else // segmLeft a Nord
{
dSegmLeft = dSegmLeft + incN;
}
}
}
// ---- parallelogrammoide circolare (in alternativa a parallelogramma)
// N.B. coordinate di schermo (riflessione per k<0 )
yMin = tmax(b.y - cutIn, 0);
yMax = tmin(a.y + cutIn, ly - 1);
for (y = yMin; y <= yMax; y++) {
int xMin, xMax;
if (k > 0) {
xMin = tmax(a.x - halfCord.getCord(abs(y - a.y)), 0); // clipping x
xMax = tmin(b.x + halfCord.getCord(abs(b.y - y)), lx - 1); // clipping x
} else {
xMin = tmax(b.x - halfCord.getCord(abs(b.y - y)), 0); // clipping x + ritorno alle
xMax = tmin(a.x + halfCord.getCord(abs(y - a.y)), lx - 1); // coordinate "di schermo"
}
TPixel32 *p = ras->pixels(y) + xMin;
TPixel32 *q = p + (xMax - xMin);
while (p <= q)
*p++ = col;
}
ras->unlock();
}
TImageP ImageRasterizer::build(int imFlags, void *extData)
{
assert(!(imFlags & ~(ImageManager::dontPutInCache | ImageManager::forceRebuild)));
TDimension d(10, 10);
TPoint off(0, 0);
// Fetch image
assert(extData);
ImageLoader::BuildExtData *data = (ImageLoader::BuildExtData *)extData;
const std::string &srcImgId = data->m_sl->getImageId(data->m_fid);
TImageP img = ImageManager::instance()->getImage(srcImgId, imFlags, extData);
if (img) {
TVectorImageP vi = img;
if (vi) {
TRectD bbox = vi->getBBox();
d = TDimension(tceil(bbox.getLx()) + 1, tceil(bbox.getLy()) + 1);
off = TPoint((int)bbox.x0, (int)bbox.y0);
TPalette *vpalette = vi->getPalette();
TVectorRenderData rd(TTranslation(-off.x, -off.y), TRect(TPoint(0, 0), d), vpalette, 0, true, true);
TGlContext oldContext = tglGetCurrentContext();
// this is too slow.
{
QSurfaceFormat format;
format.setProfile(QSurfaceFormat::CompatibilityProfile);
TRaster32P ras(d);
glPushAttrib(GL_ALL_ATTRIB_BITS);
glMatrixMode(GL_MODELVIEW), glPushMatrix();
glMatrixMode(GL_PROJECTION), glPushMatrix();
{
std::unique_ptr<QOpenGLFramebufferObject> fb(new QOpenGLFramebufferObject(d.lx, d.ly));
fb->bind();
assert(glGetError() == 0);
glViewport(0, 0, d.lx, d.ly);
glClearColor(0, 0, 0, 0);
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, d.lx, 0, d.ly);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0.375, 0.375, 0.0);
assert(glGetError() == 0);
tglDraw(rd, vi.getPointer());
assert(glGetError() == 0);
assert(glGetError() == 0);
glFlush();
assert(glGetError() == 0);
QImage img = fb->toImage().scaled(QSize(d.lx, d.ly), Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
int wrap = ras->getLx() * sizeof(TPixel32);
uchar *srcPix = img.bits();
uchar *dstPix = ras->getRawData() + wrap * (d.ly - 1);
for (int y = 0; y < d.ly; y++) {
memcpy(dstPix, srcPix, wrap);
dstPix -= wrap;
srcPix += wrap;
}
fb->release();
}
glMatrixMode(GL_MODELVIEW), glPopMatrix();
glMatrixMode(GL_PROJECTION), glPopMatrix();
glPopAttrib();
tglMakeCurrent(oldContext);
TRasterImageP ri = TRasterImageP(ras);
ri->setOffset(off + ras->getCenter());
return ri;
}
}
}
// Error case: return a dummy image (is it really required?)
TRaster32P ras(d);
ras->fill(TPixel32(127, 0, 127, 127));
return TRasterImageP(ras);
}
void TColorStyle::makeIcon(const TDimension &d) {
checkErrorsByGL;
TColorStyle *style = this->clone();
checkErrorsByGL;
TPaletteP tmpPalette = new TPalette();
checkErrorsByGL;
int id = tmpPalette->addStyle(style);
checkErrorsByGL;
int contextLx = pow(2.0, tceil(log((double)d.lx) / log(2.0)));
int contextLy = pow(2.0, tceil(log((double)d.ly) / log(2.0)));
TDimension dim(contextLx, contextLy);
TOfflineGL *glContext = TOfflineGL::getStock(dim);
checkErrorsByGL;
glContext->clear(TPixel32::White);
checkErrorsByGL;
TVectorImageP img = new TVectorImage;
checkErrorsByGL;
img->setPalette(tmpPalette.getPointer());
checkErrorsByGL;
std::vector<TThickPoint> points(3);
if (isRegionStyle() && !isStrokeStyle()) {
points[0] = TThickPoint(-55, -50, 1);
points[1] = TThickPoint(0, -60, 1);
points[2] = TThickPoint(55, -50, 1);
TStroke *stroke1 = new TStroke(points);
img->addStroke(stroke1);
points[0] = TThickPoint(50, -55, 1);
points[1] = TThickPoint(60, 0, 1);
points[2] = TThickPoint(50, 55, 1);
TStroke *stroke2 = new TStroke(points);
img->addStroke(stroke2);
points[0] = TThickPoint(55, 50, 1);
points[1] = TThickPoint(0, 60, 1);
points[2] = TThickPoint(-55, 50, 1);
TStroke *stroke3 = new TStroke(points);
img->addStroke(stroke3);
points[0] = TThickPoint(-50, 55, 1);
points[1] = TThickPoint(-60, 0, 1);
points[2] = TThickPoint(-50, -55, 1);
TStroke *stroke4 = new TStroke(points);
img->addStroke(stroke4);
img->fill(TPointD(0, 0), id);
} else if (isStrokeStyle() && !isRegionStyle()) {
double rasX05 = d.lx * 0.5;
double rasY05 = d.ly * 0.5;
points[0] = TThickPoint(-rasX05, -rasY05, 7);
points[1] = TThickPoint(0, -rasY05, 9);
points[2] = TThickPoint(rasX05, rasY05, 12);
TStroke *stroke1 = new TStroke(points);
stroke1->setStyle(id);
img->addStroke(stroke1);
points.clear();
} else if (!isRasterStyle()) {
assert(isStrokeStyle() && isRegionStyle());
points[0] = TThickPoint(-60, -30, 0.5);
points[1] = TThickPoint(0, -30, 0.5);
points[2] = TThickPoint(60, -30, 0.5);
TStroke *stroke1 = new TStroke(points);
stroke1->setStyle(id);
img->addStroke(stroke1);
points[0] = TThickPoint(60, -30, 0.5);
points[1] = TThickPoint(60, 0, 0.5);
points[2] = TThickPoint(60, 30, 0.5);
TStroke *stroke2 = new TStroke(points);
stroke2->setStyle(id);
img->addStroke(stroke2);
points[0] = TThickPoint(60, 30, 0.5);
points[1] = TThickPoint(0, 30, 0.5);
points[2] = TThickPoint(-60, 30, 0.5);
TStroke *stroke3 = new TStroke(points);
stroke3->setStyle(id);
img->addStroke(stroke3);
points[0] = TThickPoint(-60, 30, 0.5);
points[1] = TThickPoint(-60, 0, 0.5);
points[2] = TThickPoint(-60, -30, 0.5);
TStroke *stroke4 = new TStroke(points);
stroke4->setStyle(id);
img->addStroke(stroke4);
img->fill(TPointD(0, 0), id);
}
TRectD bbox = img->getBBox();
checkErrorsByGL;
bbox = bbox.enlarge(TDimensionD(-10, -10));
checkErrorsByGL;
double scx = 0.9 * d.lx / bbox.getLx();
double scy = 0.9 * d.ly / bbox.getLy();
double sc = std::min(scx, scy);
double dx = (d.lx - bbox.getLx() * sc) * 0.5;
double dy = (d.ly - bbox.getLy() * sc) * 0.5;
TAffine aff =
TScale(scx, scy) * TTranslation(-bbox.getP00() + TPointD(dx, dy));
checkErrorsByGL;
if (isRegionStyle() && !isStrokeStyle()) aff = aff * TTranslation(-10, -10);
checkErrorsByGL;
const TVectorRenderData rd(aff, TRect(), tmpPalette.getPointer(), 0, true);
checkErrorsByGL;
glContext->draw(img, rd);
checkErrorsByGL;
TRect rect(d);
if (!m_icon || m_icon->getSize() != d) {
checkErrorsByGL;
m_icon = glContext->getRaster()->extract(rect)->clone();
} else {
checkErrorsByGL;
m_icon->copy(glContext->getRaster()->extract(rect));
}
}
void FreeDistortBaseFx::doCompute(TTile &tile, double frame, const TRenderSettings &ri)
{
if (!m_input.isConnected())
return;
//Upon deactivation, this fx does nothing.
if (m_deactivate->getValue()) {
m_input->compute(tile, frame, ri);
return;
}
//Get the source quad
TPointD p00_b = m_p00_b->getValue(frame);
TPointD p10_b = m_p10_b->getValue(frame);
TPointD p01_b = m_p01_b->getValue(frame);
TPointD p11_b = m_p11_b->getValue(frame);
//Get destination quad
TPointD p00_a = m_p00_a->getValue(frame);
TPointD p10_a = m_p10_a->getValue(frame);
TPointD p01_a = m_p01_a->getValue(frame);
TPointD p11_a = m_p11_a->getValue(frame);
if (m_isCastShadow) {
//Shadows are mirrored
tswap(p00_a, p01_a);
tswap(p10_a, p11_a);
}
//Get requested tile's geometry
TRasterP tileRas(tile.getRaster());
TRectD tileRect(convert(tileRas->getBounds()) + tile.m_pos);
//Call transform to get the minimal rectOnInput
TRectD inRect;
TRenderSettings riNew;
TRectD inBBox;
safeTransform(frame, 0, tileRect, ri, inRect, riNew, inBBox);
//Intersect with the bbox
inRect *= inBBox;
if (myIsEmpty(inRect))
return;
double scale = ri.m_affine.a11;
double downBlur = m_downBlur->getValue(frame) * scale;
double upBlur = m_upBlur->getValue(frame) * scale;
int brad = tceil(tmax(downBlur, upBlur));
inRect = inRect.enlarge(brad);
TDimension inRectSize(tceil(inRect.getLx()), tceil(inRect.getLy()));
TTile inTile;
m_input->allocateAndCompute(inTile, inRect.getP00(), inRectSize, tileRas, frame, riNew);
TPointD inTilePosRi = inTile.m_pos;
//Update quads by the scale factors
p00_b = riNew.m_affine * p00_b;
p10_b = riNew.m_affine * p10_b;
p01_b = riNew.m_affine * p01_b;
p11_b = riNew.m_affine * p11_b;
p00_a = ri.m_affine * p00_a;
p10_a = ri.m_affine * p10_a;
p01_a = ri.m_affine * p01_a;
p11_a = ri.m_affine * p11_a;
PerspectiveDistorter perpDistorter(
p00_b - inTile.m_pos, p10_b - inTile.m_pos, p01_b - inTile.m_pos, p11_b - inTile.m_pos,
p00_a, p10_a, p01_a, p11_a);
BilinearDistorter bilDistorter(
p00_b - inTile.m_pos, p10_b - inTile.m_pos, p01_b - inTile.m_pos, p11_b - inTile.m_pos,
p00_a, p10_a, p01_a, p11_a);
TQuadDistorter *distorter;
if (m_distortType->getValue() == PERSPECTIVE)
distorter = &perpDistorter;
else if (m_distortType->getValue() == BILINEAR)
distorter = &bilDistorter;
else
assert(0);
if (m_isCastShadow) {
TRaster32P ras32 = inTile.getRaster();
TRaster64P ras64 = inTile.getRaster();
if (ras32) {
if (m_fade->getValue(frame) > 0)
doFade(ras32, m_color->getValue(frame), m_fade->getValue(frame) / 100.0);
if (brad > 0)
doBlur(ras32, upBlur, downBlur,
m_upTransp->getValue(frame) / 100.0, m_downTransp->getValue(frame) / 100.0,
inBBox.y0 - inTile.m_pos.y, inBBox.y1 - inTile.m_pos.y);
else if (m_upTransp->getValue(frame) > 0 || m_downTransp->getValue(frame) > 0)
doTransparency(ras32, m_upTransp->getValue(frame) / 100.0, m_downTransp->getValue(frame) / 100.0,
inBBox.y0 - inTile.m_pos.y, inBBox.y1 - inTile.m_pos.y);
} else if (ras64) {
if (m_fade->getValue(frame) > 0)
doFade(ras64, toPixel64(m_color->getValue(frame)), m_fade->getValue(frame) / 100.0);
if (brad > 0)
doBlur(ras64, upBlur, downBlur,
m_upTransp->getValue(frame) / 100.0, m_downTransp->getValue(frame) / 100.0,
inBBox.y0 - inTile.m_pos.y, inBBox.y1 - inTile.m_pos.y);
else if (m_upTransp->getValue(frame) > 0 || m_downTransp->getValue(frame) > 0)
doTransparency(ras64, m_upTransp->getValue(frame) / 100.0, m_downTransp->getValue(frame) / 100.0,
inBBox.y0 - inTile.m_pos.y, inBBox.y1 - inTile.m_pos.y);
} else
assert(false);
}
distort(tileRas, inTile.getRaster(), *distorter, convert(tile.m_pos), TRop::Bilinear);
}
