//! Returns the affine transform from image reference to widget's pixel one.
TAffine ImageViewer::getImgToWidgetAffine(const TRectD &geom) const {
TPointD geomCenter((geom.x0 + geom.x1) * 0.5, (geom.y0 + geom.y1) * 0.5);
QRect widGeom(rect());
TPointD viewerCenter((widGeom.left() + widGeom.right() + 1) * 0.5,
(widGeom.top() + widGeom.bottom() + 1) * 0.5);
return TAffine(TAffine(1.0, 0.0, 0.0, 0.0, -1.0, height()) *
TTranslation(viewerCenter) * m_viewAff *
TTranslation(-geomCenter));
}
TAffine TTool::getCurrentColumnParentMatrix() const {
if (!m_application) return TAffine();
TFrameHandle *fh = m_application->getCurrentFrame();
if (fh->isEditingLevel()) return TAffine();
int frame = fh->getFrame();
int columnIndex = m_application->getCurrentColumn()->getColumnIndex();
TXsheet *xsh = m_application->getCurrentXsheet()->getXsheet();
TStageObjectId parentId =
xsh->getStageObjectParent(TStageObjectId::ColumnId(columnIndex));
return xsh->getPlacement(parentId, frame);
}
void CleanupSwatch::enable(bool state)
{
m_enabled = state;
if (!m_enabled) {
m_resampledRaster = TRasterP();
//m_lastRasCleanupped = TRasterP();
m_origRaster = TRasterP();
m_viewAff = TAffine();
m_resampleAff = TAffine();
m_leftSwatch->updateRaster();
m_rightSwatch->updateRaster();
}
}
void OnionSkinMask::clear() {
m_fos.clear();
m_mos.clear();
m_shiftTraceStatus = DISABLED;
m_ghostAff[0] = TAffine();
m_ghostAff[1] = TAffine();
m_ghostCenter[0] = TPointD();
m_ghostCenter[1] = TPointD();
m_ghostFrame[0] = 0;
m_ghostFrame[1] = 0;
}
TAffine TTool::getCurrentObjectParentMatrix() const {
if (!m_application) return TAffine();
TXsheet *xsh = m_application->getCurrentXsheet()->getXsheet();
int frame = m_application->getCurrentFrame()->getFrame();
TStageObjectId currentObjectId =
m_application->getCurrentObject()->getObjectId();
if (currentObjectId == TStageObjectId::NoneId) return TAffine();
TStageObjectId parentId = xsh->getStageObjectParent(currentObjectId);
if (parentId == TStageObjectId::NoneId)
return TAffine();
else
return xsh->getPlacement(parentId, frame);
}
void CleanupSwatch::CleanupSwatchArea::keyPressEvent(QKeyEvent *event)
{
if (!m_sw->m_resampledRaster || m_sw->m_lx == 0 || m_sw->m_ly == 0)
return;
int key = event->key();
if (key != '+' && key != '-' && key != '0')
return;
if (key == '0')
m_sw->m_viewAff = TAffine();
else {
bool forward = (key == '+');
double currZoomScale = sqrt(m_sw->m_viewAff.det());
double factor = getQuantizedZoomFactor(currZoomScale, forward);
double minZoom = tmin((double)m_sw->m_lx / m_sw->m_resampledRaster->getLx(), (double)m_sw->m_ly / m_sw->m_resampledRaster->getLy());
if ((!forward && factor < minZoom) || (forward && factor > 40.0))
return;
TPointD delta(0.5 * width(), 0.5 * height());
m_sw->m_viewAff = (TTranslation(delta) * TScale(factor / currZoomScale) * TTranslation(-delta)) * m_sw->m_viewAff;
}
m_sw->m_leftSwatch->updateRaster();
m_sw->m_rightSwatch->updateRaster();
}
TAffine ShiftTraceTool::getGhostAff()
{
if (0 <= m_ghostIndex && m_ghostIndex < 2)
return m_aff[m_ghostIndex] * m_dpiAff;
else
return TAffine();
}
bool doGetBBox(double frame, TRectD &bBox,
const TRenderSettings &ri) override {
if (m_input.isConnected() && m_controller.isConnected()) {
TRectD controlBox, inputBox;
TRenderSettings ri2(ri);
ri2.m_affine = TAffine();
m_controller->getBBox(frame, controlBox, ri2);
TRenderSettings ri3(ri);
int shrink = tround((ri.m_shrinkX + ri.m_shrinkY) / 2.0);
// Should be there no need for the alias...
SandorFxRenderData *artContourData =
buildRenderData(frame, shrink, controlBox, "");
ri3.m_data.push_back(artContourData);
return m_input->doGetBBox(frame, bBox, ri3);
} else if (m_input.isConnected()) {
m_input->doGetBBox(frame, bBox, ri);
return false;
}
bBox = TRectD();
return false;
}
void updateLevel()
{
TTool::Application *app = TTool::getApplication();
if (!app->getCurrentLevel()->getLevel())
return;
TXshSimpleLevelP xl = app->getCurrentLevel()->getLevel()->getSimpleLevel();
if (app->getCurrentFrame()->getFrameType() != TFrameHandle::LevelFrame)
return;
TFrameId fid = app->getCurrentFrame()->getFid();
TVectorImageP src = xl->getFrame(fid, true);
int count = src->getStrokeCount();
for (int i = 1; i < 10; i++) {
++fid;
if (!xl->isFid(fid)) {
TVectorImageP vi = new TVectorImage();
xl->setFrame(fid, vi);
}
TVectorImageP vi = xl->getFrame(fid, true);
TVectorImageP dst = src->clone();
deform(dst.getPointer(), src.getPointer(), (double)i / (double)9);
count = dst->getStrokeCount();
vi->mergeImage(dst, TAffine());
app->getCurrentTool()->getTool()->notifyImageChanged(fid);
}
}
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());
}
DrawableTextureDataP texture_utils::getTextureData(const TXsheet *xsh,
int frame) {
// Check if an xsheet texture already exists
const std::string &texId = ::getImageId(xsh, frame);
DrawableTextureDataP data(
TTexturesStorage::instance()->getTextureData(texId));
if (data) return data;
// No available texture - we must build and load it
TRaster32P tex(
1024,
1024); // Fixed texture size. It's the same that currently happens with
// vector images' textures - and justified since this is camstand
// mode, and besides we want to make sure that textures are limited.
// Retrieve the sub-xsheet bbox (world coordinates of the sub-xsheet)
TRectD bbox(xsh->getBBox(frame));
// Since xsh represents a sub-xsheet, its camera affine must be applied
const TAffine &cameraAff =
xsh->getPlacement(xsh->getStageObjectTree()->getCurrentCameraId(), frame);
bbox = (cameraAff.inv() * bbox).enlarge(1.0);
// Render the xsheet on the specified bbox
#ifdef MACOSX
xsh->getScene()->renderFrame(tex, frame, xsh, bbox, TAffine());
#else
// The call below will change context (I know, it's a shame :( )
TGlContext currentContext = tglGetCurrentContext();
{
tglDoneCurrent(currentContext);
xsh->getScene()->renderFrame(tex, frame, xsh, bbox, TAffine());
tglMakeCurrent(currentContext);
}
#endif
TRop::depremultiply(tex); // Stored textures are rendered nonpremultiplied
// Store the texture for future retrieval
return TTexturesStorage::instance()->loadTexture(texId, tex, bbox);
}
QScriptValue ImageBuilder::add(QScriptValue imgArg) {
Image *simg = 0;
QScriptValue err = checkImage(context(), imgArg, simg);
if (err.isError()) return err;
QString errStr = add(simg->getImg(), TAffine());
if (errStr != "")
return context()->throwError(
tr("%1 : %2").arg(errStr).arg(imgArg.toString()));
else
return context()->thisObject();
}
FlashMovieGenerator(const TFilePath &fp, const TDimension cameraSize,
TOutputProperties &properties)
: Imp(fp, cameraSize, properties.getFrameRate())
, m_flash(cameraSize.lx, cameraSize.ly, 0, properties.getFrameRate(),
properties.getFileFormatProperties("swf"))
, m_frameIndex(0)
, m_sceneIndex(0)
, m_frameCountLoader(0)
, m_screenSaverMode(false) {
TPointD center(0.5 * cameraSize.lx, 0.5 * cameraSize.ly);
m_viewAff = TAffine();
m_screenSaverMode = fp.getType() == "scr";
}
void ImageViewer::zoomQt(bool forward, bool reset) {
double scale2 = m_viewAff.det();
if (reset)
setViewAff(TAffine());
else if (((scale2 < 100000 || !forward) &&
(scale2 > 0.001 * 0.05 || forward))) {
double oldZoomScale = sqrt(scale2);
double zoomScale =
reset ? 1 : ImageUtils::getQuantizedZoomFactor(oldZoomScale, forward);
setViewAff(TScale(zoomScale / oldZoomScale) * m_viewAff);
}
update();
}
void ShiftTraceTool::clearData() {
m_ghostIndex = 0;
m_curveStatus = NoCurve;
m_gadget = NoGadget;
m_highlightedGadget = NoGadget;
m_box = TRectD();
for (int i = 0; i < 2; i++) {
m_row[i] = -1;
m_aff[i] = TAffine();
m_center[i] = TPointD();
}
}
TAffine TTool::getCurrentObjectParentMatrix2() const {
TTool::Application *app = m_application;
TFrameHandle *fh = app->getCurrentFrame();
if (fh->isEditingLevel()) return TAffine();
int frame = fh->getFrame();
TXsheet *xsh = app->getCurrentXsheet()->getXsheet();
TStageObjectId id = app->getCurrentObject()->getObjectId();
double objZ = xsh->getZ(id, frame);
TStageObjectId parentId = xsh->getStageObjectParent(id);
if (parentId == TStageObjectId::NoneId) return TAffine();
id = parentId;
TAffine objPlacement = xsh->getPlacement(id, frame);
TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();
TStageObject *camera = xsh->getStageObject(cameraId);
TAffine cameraPlacement = camera->getPlacement(frame);
double cameraZ = camera->getZ(frame);
TAffine placement;
TStageObject::perspective(placement, cameraPlacement, cameraZ, objPlacement,
objZ, 0);
return placement;
}
TAffine TTool::getColumnMatrix(int columnIndex) const {
if (!m_application) return TAffine();
TFrameHandle *fh = m_application->getCurrentFrame();
if (fh->isEditingLevel()) return TAffine();
int frame = fh->getFrame();
TXsheet *xsh = m_application->getCurrentXsheet()->getXsheet();
TStageObjectId columnId = TStageObjectId::ColumnId(columnIndex);
TAffine columnPlacement = xsh->getPlacement(columnId, frame);
double columnZ = xsh->getZ(columnId, frame);
TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();
TStageObject *camera = xsh->getStageObject(cameraId);
TAffine cameraPlacement = camera->getPlacement(frame);
double cameraZ = camera->getZ(frame);
TStageObject *object = xsh->getStageObject(columnId);
TAffine placement;
TStageObject::perspective(placement, cameraPlacement, cameraZ,
columnPlacement, columnZ,
object->getGlobalNoScaleZ());
return placement;
}
void ShiftTraceTool::updateData()
{
TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();
int row = TApp::instance()->getCurrentFrame()->getFrame();
int col = TApp::instance()->getCurrentColumn()->getColumnIndex();
TXshCell cell = xsh->getCell(row, col);
m_box = TRectD();
for (int i = 0; i < 2; i++)
m_row[i] = -1;
m_dpiAff = TAffine();
// we must find the prev (m_row[0]) and next (m_row[1]) reference images
// (either might not exist)
// see also stage.cpp, StageBuilder::addCellWithOnionSkin
if (cell.isEmpty()) {
// current cell is empty. search for the prev ref img
int r = row - 1;
while (r >= 0 && xsh->getCell(r, col).getSimpleLevel() == 0)
r--;
if (r >= 0)
m_row[0] = r;
// else prev drawing doesn't exist : nothing to do
} else {
// current cell is not empty
// search for prev ref img
TXshSimpleLevel *sl = cell.getSimpleLevel();
int r = row - 1;
if (r >= 0) {
TXshCell otherCell = xsh->getCell(r, col);
if (otherCell.getSimpleLevel() == sl) {
// find the span start
while (r - 1 >= 0 && xsh->getCell(r - 1, col) == otherCell)
r--;
m_row[0] = r;
}
}
// search for next ref img
r = row + 1;
while (xsh->getCell(r, col) == cell)
r++;
// first cell after the current span has the same level
if (xsh->getCell(r, col).getSimpleLevel() == sl)
m_row[1] = r;
}
updateBox();
}
void Iwa_TiledParticlesFx::doDryCompute(TRectD &rect, double frame, const TRenderSettings &info)
{
Iwa_ParticlesManager *pc = Iwa_ParticlesManager::instance();
unsigned long fxId = getIdentifier();
int inputPortCount = getInputPortCount();
int i,
j,
curr_frame = frame, /*- 現在のフレーム -*/
startframe = startpos_val->getValue(); /*- Particesの開始フレーム -*/
TRenderSettings infoOnInput(info);
infoOnInput.m_affine = TAffine(); // Using the standard reference - indep. from cameras.
infoOnInput.m_bpp = 64; // Control ports rendered at 32 bit - since not visible.
for (i = startframe - 1; i <= curr_frame; ++i) {
double frame = tmax(0, i);
for (j = 0; j < inputPortCount; ++j) {
TFxPort *port = getInputPort(j);
std::string tmpName = getInputPortName(j);
if (port->isConnected()) {
TRasterFxP fx = port->getFx();
// Now, consider that source ports work different than control ones
QString portName = QString::fromStdString(tmpName);
if (portName.startsWith("C")) {
// Control ports are calculated from start to current frame, since
// particle mechanics at current frame is influenced by previous ones
// (and therefore by all previous control images).
TRectD bbox;
fx->getBBox(frame, bbox, infoOnInput);
if (bbox == TConsts::infiniteRectD)
bbox = info.m_affine.inv() * rect;
fx->dryCompute(bbox, frame, infoOnInput);
} else if (portName.startsWith("T")) {
// Particles handle source ports caching procedures on its own.
}
}
}
}
}
//
// Compute m_aff[0] and m_aff[1] according to the current curve
//
void ShiftTraceTool::updateCurveAffs() {
if (m_curveStatus != ThreePointsCurve) {
m_aff[0] = m_aff[1] = TAffine();
} else {
double phi0 = 0, phi1 = 0;
TPointD center;
if (circumCenter(center, m_p0, m_p1, m_p2)) {
TPointD v0 = normalize(m_p0 - center);
TPointD v1 = normalize(m_p1 - center);
TPointD v2 = normalize(m_p2 - center);
TPointD u0(-v0.y, v0.x);
TPointD u1(-v1.y, v1.x);
phi0 = atan2((v2 * u0), (v2 * v0)) * 180.0 / 3.1415;
phi1 = atan2((v2 * u1), (v2 * v1)) * 180.0 / 3.1415;
}
m_aff[0] = TTranslation(m_p2 - m_p0) * TRotation(m_p0, phi0);
m_aff[1] = TTranslation(m_p2 - m_p1) * TRotation(m_p1, phi1);
}
}
/*- 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 Particles_Engine::render_particles(
TFlash *flash, TTile *tile, std::vector<TRasterFxPort *> part_ports,
const TRenderSettings &ri, TDimension &p_size, TPointD &p_offset,
std::map<int, TRasterFxPort *> ctrl_ports, std::vector<TLevelP> partLevel,
float dpi, int curr_frame, int shrink, double startx, double starty,
double endx, double endy, std::vector<int> last_frame, unsigned long fxId) {
int frame, startframe, intpart = 0, level_n = 0;
struct particles_values values;
double dpicorr = dpi * 0.01, fractpart = 0, dpicorr_shrinked = 0,
opacity_range = 0;
bool random_level = false;
level_n = part_ports.size();
bool isPrecomputingEnabled = false;
{
TRenderer renderer(TRenderer::instance());
isPrecomputingEnabled =
(renderer && renderer.isPrecomputingEnabled()) ? true : false;
}
memset(&values, 0, sizeof(values));
/*- 現在のフレームでの各種パラメータを得る -*/
fill_value_struct(values, m_frame);
/*- 不透明度の範囲（透明〜不透明を 0〜1 に正規化）-*/
opacity_range = (values.opacity_val.second - values.opacity_val.first) * 0.01;
/*- 開始フレーム -*/
startframe = (int)values.startpos_val;
if (values.unit_val == ParticlesFx::UNIT_SMALL_INCH)
dpicorr_shrinked = dpicorr / shrink;
else
dpicorr_shrinked = dpi / shrink;
std::map<std::pair<int, int>, double> partScales;
curr_frame = curr_frame / values.step_val;
ParticlesManager *pc = ParticlesManager::instance();
// Retrieve the last rolled frame
ParticlesManager::FrameData *particlesData = pc->data(fxId);
std::list<Particle> myParticles;
TRandom myRandom;
values.random_val = &myRandom;
myRandom = m_parent->randseed_val->getValue();
int totalparticles = 0;
int pcFrame = particlesData->m_frame;
if (pcFrame > curr_frame) {
// Clear stored particlesData
particlesData->clear();
pcFrame = particlesData->m_frame;
} else if (pcFrame >= startframe - 1) {
myParticles = particlesData->m_particles;
myRandom = particlesData->m_random;
totalparticles = particlesData->m_totalParticles;
}
/*- スタートからカレントフレームまでループ -*/
for (frame = startframe - 1; frame <= curr_frame; ++frame) {
int dist_frame = curr_frame - frame;
/*-
* ループ内の現在のフレームでのパラメータを取得。スタートが負ならフレーム=0のときの値を格納
* -*/
fill_value_struct(values, frame < 0 ? 0 : frame * values.step_val);
/*- パラメータの正規化 -*/
normalize_values(values, ri);
/*- maxnum_valは"birth_rate"のパラメータ -*/
intpart = (int)values.maxnum_val;
/*-
* /birth_rateが小数だったとき、各フレームの小数部分を足しこんだ結果の整数部分をintpartに渡す。
* -*/
fractpart = fractpart + values.maxnum_val - intpart;
if ((int)fractpart) {
values.maxnum_val += (int)fractpart;
fractpart = fractpart - (int)fractpart;
}
std::map<int, TTile *> porttiles;
// Perform the roll
/*- RenderSettingsを複製して現在のフレームの計算用にする -*/
TRenderSettings riAux(ri);
riAux.m_affine = TAffine();
riAux.m_bpp = 32;
int r_frame; // Useful in case of negative roll frames
if (frame < 0)
r_frame = 0;
else
r_frame = frame;
/*- 出力画像のバウンディングボックス -*/
TRectD outTileBBox(tile->m_pos, TDimensionD(tile->getRaster()->getLx(),
tile->getRaster()->getLy()));
/*- Controlに刺さっている各ポートについて -*/
for (std::map<int, TRasterFxPort *>::iterator it = ctrl_ports.begin();
it != ctrl_ports.end(); ++it) {
TTile *tmp;
/*- ポートが接続されていて、Fx内で実際に使用されていたら -*/
if ((it->second)->isConnected() && port_is_used(it->first, values)) {
TRectD bbox;
(*(it->second))->getBBox(r_frame, bbox, riAux);
/*- 素材が存在する場合、portTilesにコントロール画像タイルを格納 -*/
if (!bbox.isEmpty()) {
if (bbox == TConsts::infiniteRectD) // There could be an infinite
// bbox - deal with it
bbox = ri.m_affine.inv() * outTileBBox;
if (frame <= pcFrame) {
// This frame will not actually be rolled. However, it was
// dryComputed - so, declare the same here.
(*it->second)->dryCompute(bbox, r_frame, riAux);
} else {
tmp = new TTile;
if (isPrecomputingEnabled)
(*it->second)
->allocateAndCompute(*tmp, bbox.getP00(),
convert(bbox).getSize(), 0, r_frame,
riAux);
else {
std::string alias =
"CTRL: " + (*(it->second))->getAlias(r_frame, riAux);
TRasterImageP rimg = TImageCache::instance()->get(alias, false);
if (rimg) {
tmp->m_pos = bbox.getP00();
tmp->setRaster(rimg->getRaster());
} else {
(*it->second)
->allocateAndCompute(*tmp, bbox.getP00(),
convert(bbox).getSize(), 0, r_frame,
riAux);
addRenderCache(alias, TRasterImageP(tmp->getRaster()));
}
}
porttiles[it->first] = tmp;
}
}
}
}
if (frame > pcFrame) {
// Invoke the actual rolling procedure
roll_particles(tile, porttiles, riAux, myParticles, values, 0, 0, frame,
curr_frame, level_n, &random_level, 1, last_frame,
totalparticles);
// Store the rolled data in the particles manager
if (!particlesData->m_calculated ||
particlesData->m_frame + particlesData->m_maxTrail < frame) {
particlesData->m_frame = frame;
particlesData->m_particles = myParticles;
particlesData->m_random = myRandom;
particlesData->buildMaxTrail();
particlesData->m_calculated = true;
particlesData->m_totalParticles = totalparticles;
}
}
// Render the particles if the distance from current frame is a trail
// multiple
if (frame >= startframe - 1 &&
!(dist_frame %
(values.trailstep_val > 1.0 ? (int)values.trailstep_val : 1))) {
// Store the maximum particle size before the do_render cycle
std::list<Particle>::iterator pt;
for (pt = myParticles.begin(); pt != myParticles.end(); ++pt) {
Particle &part = *pt;
int ndx = part.frame % last_frame[part.level];
std::pair<int, int> ndxPair(part.level, ndx);
std::map<std::pair<int, int>, double>::iterator it =
partScales.find(ndxPair);
if (it != partScales.end())
it->second = std::max(part.scale, it->second);
else
partScales[ndxPair] = part.scale;
}
if (values.toplayer_val == ParticlesFx::TOP_SMALLER ||
values.toplayer_val == ParticlesFx::TOP_BIGGER)
myParticles.sort(ComparebySize());
if (values.toplayer_val == ParticlesFx::TOP_SMALLER) {
std::list<Particle>::iterator pt;
for (pt = myParticles.begin(); pt != myParticles.end(); ++pt) {
Particle &part = *pt;
if (dist_frame <= part.trail && part.scale && part.lifetime > 0 &&
part.lifetime <=
part.genlifetime) // This last... shouldn't always be?
{
do_render(flash, &part, tile, part_ports, porttiles, ri, p_size,
p_offset, last_frame[part.level], partLevel, values,
opacity_range, dist_frame, partScales);
}
}
} else {
std::list<Particle>::reverse_iterator pt;
for (pt = myParticles.rbegin(); pt != myParticles.rend(); ++pt) {
Particle &part = *pt;
if (dist_frame <= part.trail && part.scale && part.lifetime > 0 &&
part.lifetime <= part.genlifetime) // Same here..?
{
do_render(flash, &part, tile, part_ports, porttiles, ri, p_size,
p_offset, last_frame[part.level], partLevel, values,
opacity_range, dist_frame, partScales);
}
}
}
}
std::map<int, TTile *>::iterator it;
for (it = porttiles.begin(); it != porttiles.end(); ++it) delete it->second;
}
}
NaAffineFx::NaAffineFx(bool isDpiAffine)
: m_aff(TAffine()), m_isDpiAffine(isDpiAffine) {
addInputPort("source", m_port);
setName(L"Geometry-NaAffineFx");
}
/*! Update image viewer, reset current matrix trasformation, current position
and update view.
*/
void ImageViewer::updateImageViewer() {
setViewAff(TAffine());
m_pos = QPoint(0, 0);
update();
}
void TglTessellator::tessellate(const TColorFunction *cf, const bool antiAliasing, TRegionOutline &outline, TRaster32P texture)
{
//QMutexLocker sl(m_mutex);
checkErrorsByGL;
glEnable(GL_TEXTURE_2D);
glColor4d(1, 1, 1, 1);
checkErrorsByGL;
TextureInfoForGL texInfo;
int pow2Lx = tcg::numeric_ops::GE_2Power((unsigned int)texture->getLx());
int pow2Ly = tcg::numeric_ops::GE_2Power((unsigned int)texture->getLy());
TAffine aff;
if (texture->getLx() != pow2Lx || texture->getLy() != pow2Ly) {
TRaster32P r(pow2Lx, pow2Ly);
aff = TScale((double)pow2Lx / texture->getLx(), (double)pow2Ly / texture->getLy());
TRop::resample(r, texture, aff.place(texture->getCenterD(), r->getCenterD()));
texture = r;
glPushMatrix();
tglMultMatrix(aff.inv());
}
// If GL_BRGA isn't present make a proper texture to use (... obsolete?)
texture->lock();
TRasterP texImage = prepareTexture(texture, texInfo);
checkErrorsByGL;
if (texImage != texture)
texImage->lock();
assert(texImage->getLx() == texImage->getWrap());
GLuint texId;
glGenTextures(1, &texId); // Generate a texture name
checkErrorsByGL;
glBindTexture(GL_TEXTURE_2D, texId); // Bind it 'active'
checkErrorsByGL;
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // These must be invoked
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // on a bound texture
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); //
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); //
checkErrorsByGL;
glTexEnvf(GL_TEXTURE_ENV, // This too ?
GL_TEXTURE_ENV_MODE, // Better here anyway
GL_MODULATE); //
checkErrorsByGL;
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
checkErrorsByGL;
glTexImage2D(GL_TEXTURE_2D,
0, // one level only
texInfo.internalformat, // pixel channels count
texInfo.width, // width
texInfo.height, // height
0, // border size
texInfo.type, // pixel format // crappy names
texInfo.format, // pixel data type // oh, SO much
texImage->getRawData());
checkErrorsByGL;
texture->unlock();
if (texImage != texture)
texImage->unlock();
TglTessellator::GLTess glTess;
gluTessCallback(glTess.m_tess, GLU_TESS_VERTEX, (GluCallback)tessellateTexture);
checkErrorsByGL;
//------------------------//
if (aff != TAffine())
doTessellate(glTess, cf, antiAliasing, outline, aff); // Tessellate & render
else
doTessellate(glTess, cf, antiAliasing, outline); // Tessellate & render
checkErrorsByGL;
//------------------------//
if (aff != TAffine())
glPopMatrix();
glDeleteTextures(1, &texId); // Delete & unbind texture
checkErrorsByGL;
glDisable(GL_TEXTURE_2D);
checkErrorsByGL;
}
void CAffineLens::UpdateDoublesRHS( double *D, int cam, bool inv )
{
TAffine T = TAffine( D ) * (inv ? Ti : Tf)[cam];
T.CopyOut( D );
}
TAffine CleanupSwatch::CleanupSwatchArea::getFinalAff()
{
return m_sw->m_viewAff * TAffine().place(m_sw->m_resampledRaster->getCenterD(), m_r->getCenterD());
}
