#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;

      }

    }

    std::sort(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,