#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")