1089 lines
39 KiB
C++
1089 lines
39 KiB
C++
#include "iwa_flowpaintbrushfx.h"
|
||
#include "tparamuiconcept.h"
|
||
#include "tlevel.h"
|
||
#include "trop.h"
|
||
|
||
#include <random>
|
||
|
||
#include "tgl.h"
|
||
#include <QOpenGLFramebufferObject>
|
||
#include <QOffscreenSurface>
|
||
#include <QSurfaceFormat>
|
||
#include <QOpenGLContext>
|
||
#include <QImage>
|
||
#include <QOpenGLTexture>
|
||
#include <QColor>
|
||
#include <QPainter>
|
||
|
||
namespace {
|
||
|
||
inline double lerp(DoublePair range, double t) {
|
||
return range.first * (1.0 - t) + range.second * t;
|
||
}
|
||
|
||
bool strokeStackGraterThan(const BrushStroke &stroke1,
|
||
const BrushStroke &stroke2) {
|
||
return stroke1.stack > stroke2.stack;
|
||
}
|
||
|
||
} // namespace
|
||
|
||
//------------------------------------------------------------
|
||
// obtain raster data of brush tips ブラシタッチのラスターデータを取得
|
||
void Iwa_FlowPaintBrushFx::getBrushRasters(std::vector<TRasterP> &brushRasters,
|
||
TDimension &b_size, int &lastFrame,
|
||
TTile &tile,
|
||
const TRenderSettings &ri) {
|
||
// ブラシテクスチャ情報
|
||
TPointD b_offset;
|
||
const TFxTimeRegion &tr = m_brush->getTimeRegion();
|
||
lastFrame = tr.getLastFrame() + 1;
|
||
TLevelP partLevel = new TLevel();
|
||
partLevel->setName(m_brush->getAlias(0, ri));
|
||
|
||
// The particles offset must be calculated without considering the
|
||
// affine's translational component
|
||
TRenderSettings riZero(ri);
|
||
riZero.m_affine.a13 = riZero.m_affine.a23 = 0;
|
||
|
||
// Calculate the bboxes union
|
||
TRectD brushBox;
|
||
for (int t = 0; t < lastFrame; ++t) {
|
||
TRectD inputBox;
|
||
m_brush->getBBox(t, inputBox, riZero);
|
||
brushBox += inputBox;
|
||
}
|
||
if (brushBox.isEmpty()) {
|
||
lastFrame = 0;
|
||
return;
|
||
}
|
||
if (brushBox == TConsts::infiniteRectD) brushBox *= ri.m_cameraBox;
|
||
|
||
b_size.lx = (int)brushBox.getLx() + 1;
|
||
b_size.ly = (int)brushBox.getLy() + 1;
|
||
b_offset = TPointD(0.5 * (brushBox.x0 + brushBox.x1),
|
||
0.5 * (brushBox.y0 + brushBox.y1));
|
||
|
||
for (int t = 0; t < lastFrame; ++t) {
|
||
TRasterP ras;
|
||
std::string alias;
|
||
TRasterImageP rimg;
|
||
rimg = partLevel->frame(t);
|
||
if (rimg) {
|
||
ras = rimg->getRaster();
|
||
} else {
|
||
alias = "BRUSH: " + m_brush->getAlias(t, ri);
|
||
rimg = TImageCache::instance()->get(alias, false);
|
||
if (rimg) {
|
||
ras = rimg->getRaster();
|
||
|
||
// Check that the raster resolution is sufficient for our purposes
|
||
if (ras->getLx() < b_size.lx || ras->getLy() < b_size.ly)
|
||
ras = 0;
|
||
else
|
||
b_size = TDimension(ras->getLx(), ras->getLy());
|
||
}
|
||
}
|
||
if (!ras) {
|
||
TTile auxTile;
|
||
TRenderSettings auxRi(ri);
|
||
auxRi.m_bpp = 32;
|
||
m_brush->allocateAndCompute(auxTile, brushBox.getP00(), b_size, 0, t,
|
||
auxRi);
|
||
ras = auxTile.getRaster();
|
||
addRenderCache(alias, TRasterImageP(ras));
|
||
}
|
||
if (ras) brushRasters.push_back(ras);
|
||
}
|
||
}
|
||
|
||
//------------------------------------------------------------
|
||
|
||
template <typename RASTER, typename PIXEL>
|
||
void Iwa_FlowPaintBrushFx::setFlowTileToBuffer(const RASTER flowRas,
|
||
double2 *buf) {
|
||
double2 *buf_p = buf;
|
||
for (int j = 0; j < flowRas->getLy(); j++) {
|
||
PIXEL *pix = flowRas->pixels(j);
|
||
for (int i = 0; i < flowRas->getLx(); i++, pix++, buf_p++) {
|
||
double val = double(pix->r) / double(PIXEL::maxChannelValue);
|
||
(*buf_p).x = val * 2.0 - 1.0;
|
||
val = double(pix->g) / double(PIXEL::maxChannelValue);
|
||
(*buf_p).y = val * 2.0 - 1.0;
|
||
}
|
||
}
|
||
}
|
||
|
||
//------------------------------------------------------------
|
||
|
||
template <typename RASTER, typename PIXEL>
|
||
void Iwa_FlowPaintBrushFx::setAreaTileToBuffer(const RASTER areaRas,
|
||
double *buf) {
|
||
double *buf_p = buf;
|
||
for (int j = 0; j < areaRas->getLy(); j++) {
|
||
PIXEL *pix = areaRas->pixels(j);
|
||
for (int i = 0; i < areaRas->getLx(); i++, pix++, buf_p++) {
|
||
(*buf_p) = double(pix->m) / double(PIXEL::maxChannelValue);
|
||
}
|
||
}
|
||
}
|
||
|
||
//------------------------------------------------------------
|
||
|
||
template <typename RASTER, typename PIXEL>
|
||
void Iwa_FlowPaintBrushFx::setColorTileToBuffer(const RASTER colorRas,
|
||
colorRGBA *buf) {
|
||
colorRGBA *buf_p = buf;
|
||
for (int j = 0; j < colorRas->getLy(); j++) {
|
||
PIXEL *pix = colorRas->pixels(j);
|
||
for (int i = 0; i < colorRas->getLx(); i++, pix++, buf_p++) {
|
||
(*buf_p).r = double(pix->r) / double(PIXEL::maxChannelValue);
|
||
(*buf_p).g = double(pix->g) / double(PIXEL::maxChannelValue);
|
||
(*buf_p).b = double(pix->b) / double(PIXEL::maxChannelValue);
|
||
(*buf_p).a = double(pix->m) / double(PIXEL::maxChannelValue);
|
||
}
|
||
}
|
||
}
|
||
|
||
//------------------------------------------------------------
|
||
template <typename RASTER, typename PIXEL>
|
||
void Iwa_FlowPaintBrushFx::setOutRaster(const RASTER outRas, double *buf) {
|
||
double *buf_p = buf;
|
||
for (int j = 0; j < outRas->getLy(); j++) {
|
||
PIXEL *pix = outRas->pixels(j);
|
||
for (int i = 0; i < outRas->getLx(); i++, pix++, buf_p++) {
|
||
typename PIXEL::Channel val =
|
||
(typename PIXEL::Channel)(*buf_p * double(PIXEL::maxChannelValue));
|
||
pix->r = val;
|
||
pix->g = val;
|
||
pix->b = val;
|
||
pix->m = PIXEL::maxChannelValue;
|
||
}
|
||
}
|
||
}
|
||
|
||
//------------------------------------------------------------
|
||
Iwa_FlowPaintBrushFx::Iwa_FlowPaintBrushFx()
|
||
: m_h_density(10.0)
|
||
, m_v_density(10.0)
|
||
, m_pos_randomness(1.0)
|
||
, m_pos_wobble(0.0)
|
||
, m_tip_width(DoublePair(0.02, 0.05))
|
||
, m_tip_length(DoublePair(0.08, 0.2))
|
||
, m_tip_alpha(DoublePair(0.8, 1.0))
|
||
, m_tip_joints(3)
|
||
, m_bidirectional(true)
|
||
, m_width_randomness(0.0)
|
||
, m_length_randomness(0.0)
|
||
, m_angle_randomness(0.0)
|
||
, m_sustain_width_to_skew(0.0)
|
||
, m_anti_jaggy(false)
|
||
, m_origin_pos(TPointD(0.0, 0.0))
|
||
, m_horizontal_pos(TPointD(100.0, 0.0))
|
||
, m_vertical_pos(TPointD(0.0, 100.0))
|
||
, m_curve_point(TPointD(0.0, 0.0))
|
||
, m_fill_gap_size(0.0)
|
||
, m_reference_frame(0.0)
|
||
, m_reference_prevalence(0.0)
|
||
, m_random_seed(1)
|
||
, m_sortBy(new TIntEnumParam(NoSort, "None")) {
|
||
addInputPort("Brush", m_brush);
|
||
addInputPort("Flow", m_flow);
|
||
addInputPort("Area", m_area);
|
||
addInputPort("Color", m_color);
|
||
|
||
bindParam(this, "h_density", m_h_density);
|
||
bindParam(this, "v_density", m_v_density);
|
||
bindParam(this, "pos_randomness", m_pos_randomness);
|
||
bindParam(this, "pos_wobble", m_pos_wobble);
|
||
bindParam(this, "tip_width", m_tip_width);
|
||
bindParam(this, "tip_length", m_tip_length);
|
||
bindParam(this, "tip_alpha", m_tip_alpha);
|
||
bindParam(this, "tip_joints", m_tip_joints);
|
||
bindParam(this, "bidirectional", m_bidirectional);
|
||
|
||
bindParam(this, "width_randomness", m_width_randomness);
|
||
bindParam(this, "length_randomness", m_length_randomness);
|
||
bindParam(this, "angle_randomness", m_angle_randomness);
|
||
bindParam(this, "sustain_width_to_skew", m_sustain_width_to_skew);
|
||
bindParam(this, "anti_jaggy", m_anti_jaggy);
|
||
|
||
bindParam(this, "origin_pos", m_origin_pos);
|
||
bindParam(this, "horizontal_pos", m_horizontal_pos);
|
||
bindParam(this, "vertical_pos", m_vertical_pos);
|
||
bindParam(this, "curve_point", m_curve_point);
|
||
bindParam(this, "fill_gap_size", m_fill_gap_size);
|
||
|
||
bindParam(this, "reference_frame", m_reference_frame);
|
||
bindParam(this, "reference_prevalence", m_reference_prevalence);
|
||
|
||
bindParam(this, "random_seed", m_random_seed);
|
||
bindParam(this, "sort_by", m_sortBy);
|
||
|
||
m_h_density->setValueRange(1.0, 300.0);
|
||
m_v_density->setValueRange(1.0, 300.0);
|
||
m_pos_randomness->setValueRange(0.0, 2.0);
|
||
m_pos_wobble->setValueRange(0.0, 1.0);
|
||
m_tip_width->getMin()->setValueRange(0.0, 1.0);
|
||
m_tip_width->getMax()->setValueRange(0.0, 1.0);
|
||
m_tip_length->getMin()->setValueRange(0.0, 1.0);
|
||
m_tip_length->getMax()->setValueRange(0.0, 1.0);
|
||
m_tip_alpha->getMin()->setValueRange(0.0, 1.0);
|
||
m_tip_alpha->getMax()->setValueRange(0.0, 1.0);
|
||
m_tip_joints->setValueRange(0, 20);
|
||
|
||
m_width_randomness->setValueRange(0.0, 0.9);
|
||
m_length_randomness->setValueRange(0.0, 0.9);
|
||
m_angle_randomness->setValueRange(0.0, 180.0); // degree
|
||
|
||
m_sustain_width_to_skew->setValueRange(0.0, 1.0);
|
||
|
||
m_origin_pos->getX()->setMeasureName("fxLength");
|
||
m_origin_pos->getY()->setMeasureName("fxLength");
|
||
m_horizontal_pos->getX()->setMeasureName("fxLength");
|
||
m_horizontal_pos->getY()->setMeasureName("fxLength");
|
||
m_vertical_pos->getX()->setMeasureName("fxLength");
|
||
m_vertical_pos->getY()->setMeasureName("fxLength");
|
||
m_curve_point->getX()->setValueRange(-0.5, 0.5);
|
||
m_curve_point->getY()->setValueRange(-0.5, 0.5);
|
||
|
||
m_fill_gap_size->setMeasureName("fxLength");
|
||
m_fill_gap_size->setValueRange(0.0, 50.0);
|
||
|
||
m_reference_frame->setValueRange(0, (std::numeric_limits<double>::max)());
|
||
m_reference_prevalence->setValueRange(0.0, 1.0);
|
||
m_random_seed->setValueRange(0, (std::numeric_limits<int>::max)());
|
||
m_sortBy->addItem(Smaller, "Size - Smaller on Top");
|
||
m_sortBy->addItem(Larger, "Size - Larger on Top");
|
||
m_sortBy->addItem(Darker, "Brightness - Darker on Top");
|
||
m_sortBy->addItem(Brighter, "Brightness - Brighter on Top");
|
||
m_sortBy->addItem(Random, "Random");
|
||
|
||
// Version 1 (development version) : strokes are placed upward direction if
|
||
// there is no Flow input.
|
||
// Version 2: strokes are directed parallel to the
|
||
// vertical vector of the parallelogram if there is no Flow input.
|
||
setFxVersion(2);
|
||
}
|
||
|
||
//------------------------------------------------------------
|
||
bool Iwa_FlowPaintBrushFx::doGetBBox(double frame, TRectD &bBox,
|
||
const TRenderSettings &info) {
|
||
if (!m_brush.isConnected()) {
|
||
bBox = TRectD();
|
||
return false;
|
||
}
|
||
TPointD origin_pos = m_origin_pos->getValue(frame);
|
||
TPointD horiz_pos = m_horizontal_pos->getValue(frame);
|
||
TPointD vert_pos = m_vertical_pos->getValue(frame);
|
||
TPointD opposite_pos = horiz_pos + vert_pos - origin_pos;
|
||
bBox = boundingBox(origin_pos, horiz_pos, vert_pos, opposite_pos);
|
||
return true;
|
||
}
|
||
|
||
//--------------------------------------------------------------
|
||
double Iwa_FlowPaintBrushFx::getSizePixelAmount(const double val,
|
||
const TAffine affine) {
|
||
/*--- Convert to vector --- */
|
||
TPointD vect;
|
||
vect.x = val;
|
||
vect.y = 0.0;
|
||
/*--- Apply geometrical transformation ---*/
|
||
// For the following lines I referred to lines 586-592 of
|
||
// sources/stdfx/motionblurfx.cpp
|
||
TAffine aff(affine);
|
||
aff.a13 = aff.a23 = 0; /* ignore translation */
|
||
vect = aff * vect;
|
||
/*--- return the length of the vector ---*/
|
||
return sqrt(vect.x * vect.x + vect.y * vect.y);
|
||
}
|
||
//------------------------------------------------------------
|
||
|
||
FlowPaintBrushFxParam Iwa_FlowPaintBrushFx::getParam(
|
||
TTile &tile, double frame, const TRenderSettings &ri) {
|
||
FlowPaintBrushFxParam p;
|
||
|
||
TAffine aff = ri.m_affine;
|
||
p.origin_pos = aff * m_origin_pos->getValue(frame);
|
||
p.horiz_pos = aff * m_horizontal_pos->getValue(frame);
|
||
p.vert_pos = aff * m_vertical_pos->getValue(frame);
|
||
TPointD opposite_pos = p.horiz_pos + p.vert_pos - p.origin_pos;
|
||
p.bbox = boundingBox(p.origin_pos, p.horiz_pos, p.vert_pos, opposite_pos);
|
||
p.dim.lx = (int)p.bbox.getLx() + 1;
|
||
p.dim.ly = (int)p.bbox.getLy() + 1;
|
||
p.origin_pos -= p.bbox.getP00();
|
||
p.horiz_pos -= p.bbox.getP00();
|
||
p.vert_pos -= p.bbox.getP00();
|
||
|
||
p.fill_gap_size =
|
||
(int)getSizePixelAmount(m_fill_gap_size->getValue(frame), aff);
|
||
|
||
p.h_density = m_h_density->getValue(frame);
|
||
p.v_density = m_v_density->getValue(frame);
|
||
p.pos_randomness = m_pos_randomness->getValue(frame);
|
||
p.pos_wobble = m_pos_wobble->getValue(frame);
|
||
|
||
p.random_seed = m_random_seed->getValue();
|
||
p.tipLength = m_tip_length->getValue(frame);
|
||
p.tipWidth = m_tip_width->getValue(frame);
|
||
p.tipAlpha = m_tip_alpha->getValue(frame);
|
||
p.width_random = m_width_randomness->getValue(frame);
|
||
p.length_random = m_length_randomness->getValue(frame);
|
||
p.angle_random = m_angle_randomness->getValue(frame);
|
||
|
||
p.reso = m_tip_joints->getValue();
|
||
p.anti_jaggy = m_anti_jaggy->getValue();
|
||
|
||
p.hVec = p.horiz_pos - p.origin_pos;
|
||
p.vVec = p.vert_pos - p.origin_pos;
|
||
p.vVec_unit = double2{normalize(p.vVec).x, normalize(p.vVec).y};
|
||
|
||
p.brushAff = TAffine(p.hVec.x, p.vVec.x, p.origin_pos.x, p.hVec.y, p.vVec.y,
|
||
p.origin_pos.y);
|
||
return p;
|
||
}
|
||
|
||
//------------------------------------------------------------
|
||
|
||
void Iwa_FlowPaintBrushFx::fillGapByDilateAndErode(double *buf,
|
||
const TDimension &dim,
|
||
const int fill_gap_size) {
|
||
TRasterGR8P tmp_buf_ras = TRasterGR8P(dim.lx * dim.ly * sizeof(double), 1);
|
||
tmp_buf_ras->lock();
|
||
double *tmp_buf = (double *)tmp_buf_ras->getRawData();
|
||
|
||
// dilate, then erode
|
||
for (int mode = 0; mode < 2; mode++) {
|
||
for (int i = 0; i < fill_gap_size; i++) {
|
||
double *fromBuf = (i % 2 == 0) ? buf : tmp_buf;
|
||
double *toBuf = (i % 2 == 0) ? tmp_buf : buf;
|
||
|
||
double *to_p = toBuf;
|
||
double *frm_p = fromBuf;
|
||
for (int y = 0; y < dim.ly; y++) {
|
||
double *n_up =
|
||
(y == 0) ? &fromBuf[y * dim.lx] : &fromBuf[(y - 1) * dim.lx];
|
||
double *n_dn = (y == dim.ly - 1) ? &fromBuf[y * dim.lx]
|
||
: &fromBuf[(y + 1) * dim.lx];
|
||
for (int x = 0; x < dim.lx; x++, n_up++, n_dn++, to_p++, frm_p++) {
|
||
if (mode == 0) {
|
||
*to_p = std::max(*frm_p, *n_up);
|
||
*to_p = std::max(*to_p, *n_dn);
|
||
if (x != 0) *to_p = std::max(*to_p, *(frm_p - 1));
|
||
if (x != dim.lx - 1) *to_p = std::max(*to_p, *(frm_p + 1));
|
||
} else {
|
||
*to_p = std::min(*frm_p, *n_up);
|
||
*to_p = std::min(*to_p, *n_dn);
|
||
if (x != 0) *to_p = std::min(*to_p, *(frm_p - 1));
|
||
if (x != dim.lx - 1) *to_p = std::min(*to_p, *(frm_p + 1));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 奇数回のフィルタリングの場合、計算結果はtmp_bufに入っているのでbufにコピーする
|
||
if (fill_gap_size % 2 == 1) {
|
||
memcpy(buf, tmp_buf, dim.lx * dim.ly * sizeof(double));
|
||
}
|
||
|
||
tmp_buf_ras->unlock();
|
||
}
|
||
|
||
//------------------------------------------------------------
|
||
void Iwa_FlowPaintBrushFx::computeBrushVertices(
|
||
QVector<BrushVertex> &brushVertices, QList<BrushStroke> &brushStrokes,
|
||
FlowPaintBrushFxParam &p, TTile &tile, double frame,
|
||
const TRenderSettings &ri) {
|
||
// 固定するタッチ：基準フレームのArea、Colorを用いて生成、カレントフレームのFlowを用いて流す
|
||
// 動かすタッチ：Area、Color、Flowすべてカレントフレームを用いる。
|
||
int referenceFrame = (int)std::round(m_reference_frame->getValue(frame)) - 1;
|
||
double reference_prevalence = m_reference_prevalence->getValue(frame);
|
||
bool bidirectional = m_bidirectional->getValue();
|
||
|
||
FlowPaintBrushFxParam pivP =
|
||
getParam(tile, referenceFrame, ri); // TODO: ここ、二度手間防げる
|
||
pivP.lastFrame = p.lastFrame;
|
||
FlowPaintBrushFxParam *param[2] = {&p, &pivP};
|
||
|
||
double ref_frame[2] = {frame, (double)referenceFrame};
|
||
double2 *flow_buf[2] = {nullptr};
|
||
double *area_buf[2] = {nullptr};
|
||
colorRGBA *color_buf[2] = {nullptr};
|
||
TRasterGR8P flow_buf_ras[2], area_buf_ras[2], color_buf_ras[2];
|
||
|
||
TRaster32P ras32 = tile.getRaster();
|
||
TRaster64P ras64 = tile.getRaster();
|
||
|
||
// それぞれの参照画像を取得
|
||
for (int f = 0; f < 2; f++) {
|
||
// Referenceフレームはフレームが-1又はprevalenceが０の場合計算しない
|
||
int tmp_f = ref_frame[f];
|
||
if (f == 1 && (tmp_f < 0 || reference_prevalence == 0.0)) continue;
|
||
|
||
// まず、Flowを計算
|
||
if (m_flow.isConnected()) {
|
||
// obtain Flow memory buffer (XY)
|
||
TTile flowTile;
|
||
m_flow->allocateAndCompute(flowTile, param[f]->bbox.getP00(),
|
||
param[f]->dim, tile.getRaster(), tmp_f, ri);
|
||
// allocate buffer
|
||
flow_buf_ras[f] =
|
||
TRasterGR8P(param[f]->dim.lx * param[f]->dim.ly * sizeof(double2), 1);
|
||
flow_buf_ras[f]->lock();
|
||
flow_buf[f] = (double2 *)flow_buf_ras[f]->getRawData();
|
||
if (ras32)
|
||
setFlowTileToBuffer<TRaster32P, TPixel32>(flowTile.getRaster(),
|
||
flow_buf[f]);
|
||
else if (ras64)
|
||
setFlowTileToBuffer<TRaster64P, TPixel64>(flowTile.getRaster(),
|
||
flow_buf[f]);
|
||
}
|
||
// カレントフレームはprevalenceが１の場合Flowのみ計算
|
||
if (f == 0 && reference_prevalence == 1.0) continue;
|
||
// AreaとColorを計算
|
||
if (m_area.isConnected()) {
|
||
TTile areaTile;
|
||
m_area->allocateAndCompute(areaTile, param[f]->bbox.getP00(),
|
||
param[f]->dim, tile.getRaster(), tmp_f, ri);
|
||
// allocate buffer
|
||
area_buf_ras[f] =
|
||
TRasterGR8P(param[f]->dim.lx * param[f]->dim.ly * sizeof(double), 1);
|
||
area_buf_ras[f]->lock();
|
||
area_buf[f] = (double *)area_buf_ras[f]->getRawData();
|
||
if (ras32)
|
||
setAreaTileToBuffer<TRaster32P, TPixel32>(areaTile.getRaster(),
|
||
area_buf[f]);
|
||
else if (ras64)
|
||
setAreaTileToBuffer<TRaster64P, TPixel64>(areaTile.getRaster(),
|
||
area_buf[f]);
|
||
|
||
// 間をうめる
|
||
if (param[f]->fill_gap_size > 0)
|
||
fillGapByDilateAndErode(area_buf[f], param[f]->dim,
|
||
param[f]->fill_gap_size);
|
||
}
|
||
if (m_color.isConnected()) {
|
||
TTile colorTile;
|
||
m_color->allocateAndCompute(colorTile, param[f]->bbox.getP00(),
|
||
param[f]->dim, tile.getRaster(), tmp_f, ri);
|
||
// allocate buffer
|
||
color_buf_ras[f] = TRasterGR8P(
|
||
param[f]->dim.lx * param[f]->dim.ly * sizeof(colorRGBA), 1);
|
||
color_buf_ras[f]->lock();
|
||
color_buf[f] = (colorRGBA *)color_buf_ras[f]->getRawData();
|
||
if (ras32)
|
||
setColorTileToBuffer<TRaster32P, TPixel32>(colorTile.getRaster(),
|
||
color_buf[f]);
|
||
else if (ras64)
|
||
setColorTileToBuffer<TRaster64P, TPixel64>(colorTile.getRaster(),
|
||
color_buf[f]);
|
||
}
|
||
}
|
||
|
||
enum FRAMETYPE { CURRENT = 0, REFERENCE };
|
||
|
||
auto getFlow = [&](TPointD pos, FRAMETYPE fType) {
|
||
if (!flow_buf[fType]) {
|
||
if (getFxVersion() == 1)
|
||
return double2{0, 1};
|
||
else
|
||
return param[CURRENT]->vVec_unit;
|
||
}
|
||
int u = (int)std::round(pos.x);
|
||
int v = (int)std::round(pos.y);
|
||
if (u < 0 || u >= param[fType]->dim.lx || v < 0 ||
|
||
v >= param[fType]->dim.ly) {
|
||
if (getFxVersion() == 1)
|
||
return double2{0, 1};
|
||
else
|
||
return param[CURRENT]->vVec_unit;
|
||
}
|
||
return flow_buf[fType][v * param[fType]->dim.lx + u];
|
||
};
|
||
auto getArea = [&](TPointD pos, FRAMETYPE fType) {
|
||
if (!area_buf[fType]) return 1.0;
|
||
int u = (int)std::round(pos.x);
|
||
int v = (int)std::round(pos.y);
|
||
if (u < 0 || u >= param[fType]->dim.lx || v < 0 ||
|
||
v >= param[fType]->dim.ly)
|
||
return 0.0;
|
||
return area_buf[fType][v * param[fType]->dim.lx + u];
|
||
};
|
||
auto getColor = [&](TPointD pos, FRAMETYPE fType) {
|
||
if (!color_buf[fType]) return colorRGBA{1.0, 1.0, 1.0, 1.0};
|
||
int u = (int)std::round(pos.x);
|
||
int v = (int)std::round(pos.y);
|
||
if (u < 0 || u >= param[fType]->dim.lx || v < 0 ||
|
||
v >= param[fType]->dim.ly)
|
||
return colorRGBA{1.0, 1.0, 1.0, 0.0};
|
||
return color_buf[fType][v * param[fType]->dim.lx + u];
|
||
};
|
||
|
||
// ランダムの設定
|
||
std::mt19937_64 mt, mt_cur; // , mt_ref;
|
||
mt.seed(p.random_seed);
|
||
mt_cur.seed(
|
||
(unsigned int)(p.random_seed +
|
||
(int)std::round(frame))); // フレーム毎にバラつかせる動き
|
||
std::uniform_real_distribution<> random01(0.0, 1.0);
|
||
std::uniform_int_distribution<> random_textureId(0, p.lastFrame - 1);
|
||
std::uniform_real_distribution<> random_plusminus1(-1.0, 1.0);
|
||
|
||
// タッチの頂点座標を登録していく
|
||
double v_incr = 1.0 / p.v_density;
|
||
double h_incr = 1.0 / p.h_density;
|
||
double v_base_pos = v_incr * 0.5;
|
||
double segmentAmount = (double)p.reso * 2 - 1;
|
||
|
||
int id = 0; // Mapのキーになる通し番号
|
||
for (int v = 0; v < (int)p.v_density; v++, v_base_pos += v_incr) {
|
||
double h_base_pos = h_incr * 0.5;
|
||
for (int h = 0; h < (int)p.h_density; h++, h_base_pos += h_incr, id++) {
|
||
BrushStroke brushStroke;
|
||
|
||
// referenceかカレントか
|
||
FRAMETYPE frameType =
|
||
(referenceFrame >= 0 && random01(mt) <= reference_prevalence)
|
||
? REFERENCE
|
||
: CURRENT;
|
||
|
||
double pos_x = h_base_pos;
|
||
double pos_y = v_base_pos;
|
||
if (frameType == CURRENT) {
|
||
pos_x += (random01(mt) - 0.5) * p.pos_randomness * h_incr;
|
||
pos_y += (random01(mt) - 0.5) * p.pos_randomness * v_incr;
|
||
} else { // REFERENCE case
|
||
pos_x += (random01(mt) - 0.5) * pivP.pos_randomness * h_incr;
|
||
pos_y += (random01(mt) - 0.5) * pivP.pos_randomness * v_incr;
|
||
}
|
||
if (pos_x < 0.0 || pos_x > 1.0 || pos_y < 0.0 || pos_y > 1.0) {
|
||
mt.discard(7); // ここ、この後のランダム生成回数分が入る
|
||
mt_cur.discard(2);
|
||
continue;
|
||
}
|
||
|
||
// Area値を拾う座標
|
||
TPointD areaSamplePos =
|
||
param[frameType]->brushAff * TPointD(pos_x, pos_y);
|
||
// 生成範囲の参照画像の輝度を取得
|
||
double areaVal = getArea(areaSamplePos, frameType);
|
||
// 発生するかしないか
|
||
if (random01(mt) > areaVal) {
|
||
mt.discard(6); // ここにも、この後のランダム生成回数分が入る
|
||
mt_cur.discard(2);
|
||
continue;
|
||
}
|
||
|
||
double2 wobble;
|
||
wobble.x = (random01(mt_cur) - 0.5) * p.pos_wobble * h_incr;
|
||
wobble.y = (random01(mt_cur) - 0.5) * p.pos_wobble * v_incr;
|
||
// 現在のセグメントのレンダリング座標
|
||
brushStroke.originPos = TPointD(pos_x + wobble.x, pos_y + wobble.y);
|
||
|
||
brushStroke.color = getColor(areaSamplePos, frameType);
|
||
double alpha = lerp(param[frameType]->tipAlpha, areaVal);
|
||
// premultiply なのでRGB値にもかける
|
||
brushStroke.color.r *= alpha;
|
||
brushStroke.color.g *= alpha;
|
||
brushStroke.color.b *= alpha;
|
||
brushStroke.color.a *= alpha;
|
||
|
||
brushStroke.length =
|
||
lerp(param[frameType]->tipLength, areaVal) *
|
||
(1.0 + random_plusminus1(mt) * param[frameType]->length_random);
|
||
brushStroke.widthHalf =
|
||
lerp(param[frameType]->tipWidth, areaVal) *
|
||
(1.0 + random_plusminus1(mt) * param[frameType]->width_random) * 0.5;
|
||
|
||
if (p.anti_jaggy) brushStroke.widthHalf *= 3.0;
|
||
|
||
brushStroke.angle =
|
||
random_plusminus1(mt) * param[frameType]->angle_random;
|
||
TAffine flow_rot = TRotation(brushStroke.angle);
|
||
|
||
brushStroke.textureId = random_textureId(mt);
|
||
brushStroke.randomVal = random01(mt);
|
||
|
||
bool inv = random01(mt) < 0.5;
|
||
brushStroke.invert = (bidirectional) ? inv : false;
|
||
|
||
// まず、芯になる部分の座標を計算する
|
||
QVector<TPointD> centerPosHalf[2];
|
||
|
||
double segLen =
|
||
brushStroke.length /
|
||
segmentAmount; // セグメントひとつ分の長さ。（ブラシ座標系）
|
||
|
||
bool tooCurve[2] = {false, false};
|
||
TPointD originFlow;
|
||
// 前後方向
|
||
for (int dir = 0; dir < 2; dir++) {
|
||
// curPosを初期位置に
|
||
TPointD curPos(brushStroke.originPos);
|
||
TPointD preFlowUV;
|
||
TPointD startFlow;
|
||
for (int s = 0; s < param[frameType]->reso; s++) {
|
||
// 現在のセグメントのレンダリング座標
|
||
TPointD samplePos = param[CURRENT]->brushAff * curPos;
|
||
|
||
// レンダリング座標から流れベクトル場を取得
|
||
double2 tmp_flow = getFlow(samplePos, CURRENT);
|
||
|
||
// 流れベクトル場をブラシ座標系に変換
|
||
TPointD flow_uv =
|
||
param[CURRENT]->brushAff.inv() * TPointD(tmp_flow.x, tmp_flow.y) -
|
||
param[CURRENT]->brushAff.inv() * TPointD(0., 0.);
|
||
if (s == 0 && dir == 0) originFlow = flow_uv;
|
||
|
||
// ベクトルを正規化
|
||
flow_uv = normalize(flow_uv);
|
||
|
||
// 戻る方向のときはベクトルを反転
|
||
if (dir == 1) flow_uv = -flow_uv;
|
||
|
||
// 流れの方向を回転
|
||
flow_uv = flow_rot * flow_uv;
|
||
|
||
if (s != 0) {
|
||
double dot = flow_uv.x * preFlowUV.x + flow_uv.y * preFlowUV.y;
|
||
if (dot < 0.0) flow_uv = -flow_uv;
|
||
|
||
double dotVsStart =
|
||
startFlow.x * flow_uv.x + startFlow.y * flow_uv.y;
|
||
if (dotVsStart < 0.3) {
|
||
tooCurve[dir] = true;
|
||
break;
|
||
}
|
||
}
|
||
preFlowUV = flow_uv;
|
||
|
||
if (s == 0) startFlow = flow_uv;
|
||
|
||
// ベクトルをセグメント長分のばし、次の点とする。最初のセグメントは半分の長さ。
|
||
TPointD nextPos = curPos + flow_uv * segLen * ((s == 0) ? 0.5 : 1.0);
|
||
|
||
// 頂点を格納
|
||
centerPosHalf[dir].push_back(nextPos);
|
||
|
||
// curPosを進める
|
||
curPos = nextPos;
|
||
}
|
||
}
|
||
|
||
if (tooCurve[0] && tooCurve[1]) continue;
|
||
// 両方滑らかな場合
|
||
if (!tooCurve[0] && !tooCurve[1]) {
|
||
brushStroke.centerPos = centerPosHalf[1];
|
||
for (auto pos : centerPosHalf[0]) brushStroke.centerPos.push_front(pos);
|
||
}
|
||
// 片方だけ急カーブの場合、滑らかな方のカーブを反対側に反転して延長する
|
||
else {
|
||
int OkId = (tooCurve[0]) ? 1 : 0;
|
||
TPointD origin(pos_x, pos_y);
|
||
TPointD okInitialVec = centerPosHalf[OkId].at(0) - origin;
|
||
double thetaDeg = std::atan2(okInitialVec.y, okInitialVec.x) / M_PI_180;
|
||
TAffine reflectAff = TTranslation(origin) * TRotation(thetaDeg) *
|
||
TScale(-1.0, 1.0) * TRotation(-thetaDeg) *
|
||
TTranslation(-origin);
|
||
brushStroke.centerPos = centerPosHalf[OkId];
|
||
for (auto pos : centerPosHalf[OkId]) {
|
||
TPointD refPos = reflectAff * pos;
|
||
brushStroke.centerPos.push_front(reflectAff * pos);
|
||
}
|
||
}
|
||
|
||
// ここで、基準フレームの流れの向きに従ってテクスチャの向きをそろえてみる
|
||
if (referenceFrame >= 0) {
|
||
TPointD referenceSamplePos =
|
||
param[REFERENCE]->brushAff * TPointD(pos_x, pos_y);
|
||
double2 reference_flow = getFlow(referenceSamplePos, REFERENCE);
|
||
// 流れベクトル場をブラシ座標系に変換
|
||
TPointD reference_flow_uv =
|
||
param[REFERENCE]->brushAff.inv() *
|
||
TPointD(reference_flow.x, reference_flow.y) -
|
||
param[REFERENCE]->brushAff.inv() * TPointD(0., 0.);
|
||
// 内積を取り、反転するか判断する
|
||
double dot = originFlow.x * reference_flow_uv.x +
|
||
originFlow.y * reference_flow_uv.y;
|
||
if (dot < 0.0) {
|
||
brushStroke.invert = !brushStroke.invert;
|
||
}
|
||
}
|
||
// 登録
|
||
brushStrokes.append(brushStroke);
|
||
}
|
||
}
|
||
|
||
// ラスターメモリ解放
|
||
for (int f = 0; f < 2; f++) {
|
||
if (flow_buf[f]) flow_buf_ras[f]->unlock();
|
||
if (area_buf[f]) area_buf_ras[f]->unlock();
|
||
if (color_buf[f]) color_buf_ras[f]->unlock();
|
||
}
|
||
|
||
// ソート
|
||
StackMode stackMode = (StackMode)m_sortBy->getValue();
|
||
if (stackMode != NoSort) {
|
||
// 大きい方が配列で前、すなわち先（下）に描かれるようにする
|
||
for (auto &stroke : brushStrokes) {
|
||
switch (stackMode) {
|
||
case Smaller:
|
||
stroke.stack = stroke.length * stroke.widthHalf;
|
||
break;
|
||
case Larger:
|
||
stroke.stack = -stroke.length * stroke.widthHalf;
|
||
break;
|
||
// Value = 0.3R 0.59G 0.11B
|
||
case Darker:
|
||
stroke.stack = 0.3 * stroke.color.r + 0.59 * stroke.color.g +
|
||
0.11 * stroke.color.b;
|
||
break;
|
||
case Brighter:
|
||
stroke.stack = -(0.3 * stroke.color.r + 0.59 * stroke.color.g +
|
||
0.11 * stroke.color.b);
|
||
break;
|
||
case Random:
|
||
stroke.stack = stroke.randomVal;
|
||
break;
|
||
}
|
||
}
|
||
qSort(brushStrokes.begin(), brushStrokes.end(), strokeStackGraterThan);
|
||
}
|
||
|
||
// タッチをせん断に対してこっち向けて太くする割合
|
||
double sustain_width_to_skew = m_sustain_width_to_skew->getValue(frame);
|
||
TPointD curve_point = m_curve_point->getValue(frame);
|
||
// 頂点座標を登録していく
|
||
for (auto stroke : brushStrokes) {
|
||
int jointCount = stroke.centerPos.size();
|
||
|
||
// 頂点位置をカーブさせてゆがめるテスト
|
||
if (curve_point != TPointD()) {
|
||
for (int s = 0; s < stroke.centerPos.size(); s++) {
|
||
TPointD p = stroke.centerPos[s];
|
||
TPointD A = (1.0 - p.x) * (1.0 - p.x) * TPointD(0.0, 0.5) +
|
||
2.0 * (1.0 - p.x) * p.x *
|
||
TPointD(0.5 + curve_point.x, 0.5 + curve_point.y) +
|
||
p.x * p.x * TPointD(1.0, 0.5);
|
||
stroke.centerPos[s] = (1.0 - p.y) * (1.0 - p.y) * TPointD(p.x, 0.0) +
|
||
2.0 * (1.0 - p.y) * p.y * TPointD(A.x, A.y) +
|
||
p.y * p.y * TPointD(p.x, 1.0);
|
||
}
|
||
}
|
||
|
||
for (int s = 0; s < jointCount; s++) {
|
||
// 前後の点
|
||
TPointD back = (s == 0) ? stroke.centerPos[0] : stroke.centerPos[s - 1];
|
||
TPointD fore = (s == jointCount - 1) ? stroke.centerPos[jointCount - 1]
|
||
: stroke.centerPos[s + 1];
|
||
TPointD vec = normalize(fore - back);
|
||
TPointD n(-vec.y * stroke.widthHalf, vec.x * stroke.widthHalf);
|
||
|
||
// ここで、テクスチャをこっちに向ける処理をいれる
|
||
if (sustain_width_to_skew > 0.0) {
|
||
// 画面座標に変換
|
||
TPointD nr = param[CURRENT]->brushAff * n -
|
||
param[CURRENT]->brushAff * TPointD(0, 0);
|
||
TPointD vr = param[CURRENT]->brushAff * vec -
|
||
param[CURRENT]->brushAff * TPointD(0, 0);
|
||
// nr と vrが垂直にちかづくように、nrを回転させる
|
||
double nr_len = norm(nr);
|
||
|
||
nr = (1.0 / nr_len) * nr;
|
||
vr = normalize(vr);
|
||
|
||
// 内積
|
||
double theta = std::acos(nr * vr);
|
||
double new_theta = sustain_width_to_skew * M_PI * 0.5 +
|
||
(1.0 - sustain_width_to_skew) * theta;
|
||
// 外積の正負から、nrがvrのどっち側にあるか判断
|
||
if (cross(vr, nr) < 0) new_theta = -new_theta;
|
||
TPointD new_nr(vr.x * cos(new_theta) - vr.y * sin(new_theta),
|
||
vr.x * sin(new_theta) + vr.y * cos(new_theta));
|
||
new_nr = nr_len * new_nr;
|
||
|
||
// ブラシ座標にもどす
|
||
n = param[CURRENT]->brushAff.inv() *
|
||
(new_nr + param[CURRENT]->brushAff * TPointD(0, 0));
|
||
}
|
||
|
||
// はじっこ
|
||
if (p.anti_jaggy && s == 0) {
|
||
TPointD edgePos = stroke.centerPos[0] * 2.0 - stroke.originPos;
|
||
brushVertices.append(
|
||
BrushVertex(edgePos + n, 0.0, (stroke.invert) ? 1.0 : 0.0));
|
||
brushVertices.append(
|
||
BrushVertex(edgePos - n, 1.0, (stroke.invert) ? 1.0 : 0.0));
|
||
}
|
||
|
||
double texCoord_v = (stroke.invert) ? 1.0 - (double(s) / segmentAmount)
|
||
: double(s) / segmentAmount;
|
||
|
||
if (p.anti_jaggy) texCoord_v = 0.25 + 0.5 * texCoord_v;
|
||
|
||
brushVertices.append(
|
||
BrushVertex(stroke.centerPos[s] + n, 0.0, texCoord_v));
|
||
brushVertices.append(
|
||
BrushVertex(stroke.centerPos[s] - n, 1.0, texCoord_v));
|
||
|
||
// 反対のはじっこ
|
||
if (p.anti_jaggy && s == jointCount - 1) {
|
||
TPointD edgePos =
|
||
stroke.centerPos[jointCount - 1] * 2.0 - stroke.originPos;
|
||
brushVertices.append(
|
||
BrushVertex(edgePos + n, 0.0, (stroke.invert) ? 0.0 : 1.0));
|
||
brushVertices.append(
|
||
BrushVertex(edgePos - n, 1.0, (stroke.invert) ? 0.0 : 1.0));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//------------------------------------------------------------
|
||
void Iwa_FlowPaintBrushFx::doCompute(TTile &tile, double frame,
|
||
const TRenderSettings &ri) {
|
||
if (!m_brush.isConnected()) {
|
||
tile.getRaster()->clear();
|
||
return;
|
||
}
|
||
|
||
TDimension b_size(0, 0);
|
||
int lastFrame = 0;
|
||
std::vector<TRasterP> brushRasters;
|
||
// ブラシタッチのラスターデータを取得
|
||
getBrushRasters(brushRasters, b_size, lastFrame, tile, ri);
|
||
|
||
if (lastFrame == 0) {
|
||
tile.getRaster()->clear();
|
||
return;
|
||
}
|
||
|
||
// パラメータ取得
|
||
FlowPaintBrushFxParam p = getParam(tile, frame, ri);
|
||
p.lastFrame = lastFrame;
|
||
|
||
int vCount = p.reso * 4;
|
||
// 上下にマージン用の頂点を追加
|
||
if (p.anti_jaggy) vCount += 4;
|
||
|
||
QVector<BrushVertex> brushVertices;
|
||
QList<BrushStroke> brushStrokes;
|
||
computeBrushVertices(brushVertices, brushStrokes, p, tile, frame, ri);
|
||
|
||
GLfloat m[16] = {(float)p.hVec.x,
|
||
(float)p.hVec.y,
|
||
0.f,
|
||
0.f,
|
||
(float)p.vVec.x,
|
||
(float)p.vVec.y,
|
||
0.f,
|
||
0.f,
|
||
0.f,
|
||
0.f,
|
||
1.f,
|
||
0.f,
|
||
(float)p.origin_pos.x,
|
||
(float)p.origin_pos.y,
|
||
0.f,
|
||
1.f};
|
||
|
||
QOpenGLContext *context = new QOpenGLContext();
|
||
if (QOpenGLContext::currentContext())
|
||
context->setShareContext(QOpenGLContext::currentContext());
|
||
context->setFormat(QSurfaceFormat::defaultFormat());
|
||
context->create();
|
||
context->makeCurrent(ri.m_offScreenSurface.get());
|
||
|
||
// テクスチャの確保
|
||
std::vector<QOpenGLTexture *> brushTextures;
|
||
for (auto texRas : brushRasters) {
|
||
QImage texImg(texRas->getRawData(), b_size.lx, b_size.ly,
|
||
QImage::Format_RGBA8888);
|
||
// 横幅を3倍にする（左右にx1のマージン）
|
||
if (p.anti_jaggy) {
|
||
QImage resizedImage(texImg.width() * 3, texImg.height() * 2,
|
||
QImage::Format_RGBA8888);
|
||
QPainter painter(&resizedImage);
|
||
painter.setCompositionMode(QPainter::CompositionMode_Source);
|
||
painter.fillRect(resizedImage.rect(), Qt::transparent);
|
||
painter.setCompositionMode(QPainter::CompositionMode_SourceOver);
|
||
painter.drawImage(QPoint(texImg.width(), texImg.height() / 2), texImg);
|
||
painter.end();
|
||
texImg = resizedImage;
|
||
}
|
||
|
||
QOpenGLTexture *texture = new QOpenGLTexture(texImg.rgbSwapped());
|
||
texture->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
|
||
texture->setMagnificationFilter(QOpenGLTexture::Linear);
|
||
brushTextures.push_back(texture);
|
||
}
|
||
|
||
TDimensionI outDim = tile.getRaster()->getSize();
|
||
|
||
// 描画
|
||
{
|
||
std::unique_ptr<QOpenGLFramebufferObject> fb(
|
||
new QOpenGLFramebufferObject(p.dim.lx, p.dim.ly));
|
||
|
||
fb->bind();
|
||
|
||
glViewport(0, 0, p.dim.lx, p.dim.ly);
|
||
glClearColor(0, 0, 0, 0);
|
||
glClear(GL_COLOR_BUFFER_BIT);
|
||
|
||
glMatrixMode(GL_PROJECTION);
|
||
glLoadIdentity();
|
||
gluOrtho2D(0, p.dim.lx, 0, p.dim.ly);
|
||
|
||
glMatrixMode(GL_MODELVIEW);
|
||
|
||
glLoadIdentity();
|
||
glLoadMatrixf(m);
|
||
|
||
glDisable(GL_POLYGON_SMOOTH);
|
||
glEnable(GL_BLEND);
|
||
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
|
||
glEnable(GL_TEXTURE_2D);
|
||
|
||
glEnableClientState(GL_VERTEX_ARRAY);
|
||
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
|
||
{
|
||
glVertexPointer(2, GL_DOUBLE, sizeof(BrushVertex), brushVertices.data());
|
||
glTexCoordPointer(2, GL_DOUBLE, sizeof(BrushVertex),
|
||
(double *)brushVertices.data() + 2);
|
||
}
|
||
|
||
int first = 0;
|
||
|
||
for (auto stroke : brushStrokes) {
|
||
brushTextures[stroke.textureId]->bind();
|
||
|
||
glColor4d(stroke.color.r, stroke.color.g, stroke.color.b, stroke.color.a);
|
||
glDrawArrays(GL_TRIANGLE_STRIP, first, vCount);
|
||
first += vCount;
|
||
}
|
||
|
||
glFlush();
|
||
|
||
glDisableClientState(GL_VERTEX_ARRAY);
|
||
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
|
||
|
||
QImage img =
|
||
fb->toImage().scaled(QSize(p.dim.lx, p.dim.ly), Qt::IgnoreAspectRatio,
|
||
Qt::SmoothTransformation);
|
||
// y座標は上下反転していることに注意！！
|
||
QRect subRect(tile.m_pos.x - (int)std::round(p.bbox.getP00().x),
|
||
(int)std::round(p.bbox.getP01().y) - tile.m_pos.y - outDim.ly,
|
||
outDim.lx, outDim.ly);
|
||
QImage subImg = img.copy(subRect);
|
||
|
||
TRaster32P ras32 = tile.getRaster();
|
||
TRaster64P ras64 = tile.getRaster();
|
||
TRaster32P resultRas;
|
||
if (ras32)
|
||
resultRas = ras32;
|
||
else if (ras64) {
|
||
resultRas = TRaster32P(outDim.lx, outDim.ly);
|
||
resultRas->lock();
|
||
}
|
||
|
||
for (int y = 0; y < outDim.ly; y++) {
|
||
QRgb *rgb_p =
|
||
reinterpret_cast<QRgb *>(subImg.scanLine(outDim.ly - 1 - y));
|
||
TPixel32 *dst_p = resultRas->pixels(y);
|
||
for (int x = 0; x < outDim.lx; x++, rgb_p++, dst_p++) {
|
||
(*dst_p).r = (unsigned char)qRed(*rgb_p);
|
||
(*dst_p).g = (unsigned char)qGreen(*rgb_p);
|
||
(*dst_p).b = (unsigned char)qBlue(*rgb_p);
|
||
(*dst_p).m = (unsigned char)qAlpha(*rgb_p);
|
||
}
|
||
}
|
||
|
||
if (ras64) {
|
||
TRop::convert(ras64, resultRas);
|
||
resultRas->unlock();
|
||
}
|
||
|
||
fb->release();
|
||
}
|
||
context->deleteLater();
|
||
|
||
for (auto tex : brushTextures) {
|
||
delete tex;
|
||
}
|
||
}
|
||
|
||
//------------------------------------------------------------
|
||
|
||
void Iwa_FlowPaintBrushFx::getParamUIs(TParamUIConcept *&concepts,
|
||
int &length) {
|
||
concepts = new TParamUIConcept[length = 4];
|
||
|
||
concepts[0].m_type = TParamUIConcept::POINT;
|
||
concepts[0].m_label = "Origin";
|
||
concepts[0].m_params.push_back(m_origin_pos);
|
||
|
||
concepts[1].m_type = TParamUIConcept::POINT;
|
||
concepts[1].m_label = "Horizontal Range";
|
||
concepts[1].m_params.push_back(m_horizontal_pos);
|
||
|
||
concepts[2].m_type = TParamUIConcept::POINT;
|
||
concepts[2].m_label = "Vertical Range";
|
||
concepts[2].m_params.push_back(m_vertical_pos);
|
||
|
||
concepts[3].m_type = TParamUIConcept::PARALLELOGRAM;
|
||
concepts[3].m_params.push_back(m_origin_pos);
|
||
concepts[3].m_params.push_back(m_horizontal_pos);
|
||
concepts[3].m_params.push_back(m_vertical_pos);
|
||
concepts[3].m_params.push_back(m_curve_point);
|
||
}
|
||
|
||
//------------------------------------------------------------
|
||
|
||
std::string Iwa_FlowPaintBrushFx::getAlias(double frame,
|
||
const TRenderSettings &info) const {
|
||
double refFrame = m_reference_frame->getValue(frame);
|
||
double prevalence = m_reference_prevalence->getValue(frame);
|
||
if (refFrame < 0 || prevalence == 0.0) {
|
||
// check if the brush is wobbled
|
||
double wobble = m_pos_wobble->getValue(frame);
|
||
std::string alias = TStandardRasterFx::getAlias(frame, info);
|
||
if (areAlmostEqual(wobble, 0.0))
|
||
return alias;
|
||
else {
|
||
alias.insert(getFxType().length() + 1, std::to_string(frame) + ",");
|
||
return alias;
|
||
}
|
||
}
|
||
|
||
std::string alias = getFxType();
|
||
alias += "[";
|
||
|
||
// alias degli effetti connessi alle porte di input separati da virgole
|
||
// una porta non connessa da luogo a un alias vuoto (stringa vuota)
|
||
for (int i = 0; i < getInputPortCount(); ++i) {
|
||
TFxPort *port = getInputPort(i);
|
||
if (port->isConnected()) {
|
||
TRasterFxP ifx = port->getFx();
|
||
assert(ifx);
|
||
alias += ifx->getAlias(frame, info);
|
||
// add alias of flow, area and color map in the reference frame
|
||
if (getInputPortName(i) != "Brush") {
|
||
alias += ",";
|
||
alias += ifx->getAlias(refFrame, info);
|
||
}
|
||
}
|
||
alias += ",";
|
||
}
|
||
|
||
std::string paramalias("");
|
||
for (int i = 0; i < getParams()->getParamCount(); ++i) {
|
||
TParam *param = getParams()->getParam(i);
|
||
paramalias += param->getName() + "=" + param->getValueAlias(frame, 3);
|
||
}
|
||
|
||
return alias + std::to_string(frame) + "," + std::to_string(getIdentifier()) +
|
||
paramalias + "]";
|
||
}
|
||
|
||
FX_PLUGIN_IDENTIFIER(Iwa_FlowPaintBrushFx, "iwa_FlowPaintBrushFx")
|