#include "iwa_floorbumpfx.h"
 
#include "tparamuiconcept.h"
#include "iwa_fresnel.h"
 
#include <QMatrix>
 
namespace {
 
inline double cross(const QPointF a, const QPointF b) {
  return a.x() * b.y() - a.y() * b.x();
};
 
inline float lerp(const float v1, const float v2, const float r) {
  return v1 * (1.0f - r) + v2 * r;
};
inline QPointF lerpUV(const QPointF p1, const QPointF p2, const float r) {
  return p1 * (1.0 - r) + p2 * r;
};
float4 lerp4(const float4 v1, const float4 v2, const float r) {
  return float4{v1.x * (1.0f - r) + v2.x * r, v1.y * (1.0f - r) + v2.y * r,
                v1.z * (1.0f - r) + v2.z * r, v1.w * (1.0f - r) + v2.w * r};
};
 
inline QVector3D lerpPos(const QVector3D v1, const QVector3D v2,
                         const float r) {
  return (v1 * (1.0 - r) + v2 * r);
};
 
inline QVector3D lerpNormal(const QVector3D v1, const QVector3D v2,
                            const float r) {
  return lerpPos(v1, v2, r).normalized();
};
 
inline float fresnelFactor(const float radian) {
  float degree = radian / M_PI_180;
  if (degree < 0.0f)
    return fresnel[0];
  else if (degree >= 90.0f)
    return fresnel[90];
  int id      = int(std::floor(degree));
  float ratio = degree - float(id);
  return lerp(fresnel[id], fresnel[id + 1], ratio);
};
 
inline bool isTextureUsed(int renderMode) {
  return renderMode == Iwa_FloorBumpFx::TextureMode         // Texture
         || renderMode == Iwa_FloorBumpFx::RefractionMode   // Refraction
         || renderMode == Iwa_FloorBumpFx::ReflectionMode;  // Reflection
}
 
// pixel height projected on the projection plane
inline double getVPos(const QPointF &zyPos,
                      const Iwa_FloorBumpFx::FloorBumpVars &vars) {
  QPointF a1   = QPointF(0, vars.P_y) - zyPos;
  QPointF a2   = vars.A - vars.B;
  QPointF b1   = vars.A - zyPos;
  QPointF b2   = vars.B - zyPos;
  double s1    = cross(b2, a1) / 2.0;
  double s2    = cross(a1, b1) / 2.0;
  double ratio = s1 / (s1 + s2);
  return vars.H * ratio;
};
 
inline float4 getSourcePix(QPointF p, float4 *source_host,
                           const Iwa_FloorBumpFx::FloorBumpVars &vars) {
  auto source = [&](QPoint p) {
    return source_host[p.y() * vars.sourceDim.lx + p.x()];
  };
 
  QPointF uv = (p + QPointF(vars.margin, vars.margin)) * vars.precision;
  int inc_x = 1, inc_y = 1;
  if (uv.x() < 0.0)
    uv.setX(0.0);
  else if (uv.x() >= vars.sourceDim.lx - 1) {
    uv.setX(vars.sourceDim.lx - 1);
    inc_x = 0;
  }
  if (uv.y() < 0.0)
    uv.setY(0.0);
  else if (uv.y() >= vars.sourceDim.ly - 1) {
    uv.setY(vars.sourceDim.ly - 1);
    inc_y = 0;
  }
  QPoint p00(int(std::floor(uv.x())), int(std::floor(uv.y())));
  QPointF frac = uv - QPointF(p00);
  if (frac.isNull()) return source(p00);
  QPoint p01 = p00 + QPoint(inc_x, 0);
  QPoint p10 = p00 + QPoint(0, inc_y);
  QPoint p11 = p00 + QPoint(inc_x, inc_y);
 
  return lerp4(lerp4(source(p00), source(p01), frac.x()),
               lerp4(source(p10), source(p11), frac.x()), frac.y());
};
 
inline float getMapValue(QPointF p, float *map_host,
                         const Iwa_FloorBumpFx::FloorBumpVars &vars) {
  auto map = [&](QPoint p) { return map_host[p.y() * vars.refDim.lx + p.x()]; };
  QPointF uv = p + QPointF(vars.margin, vars.margin);
  int inc_x = 1, inc_y = 1;
  if (uv.x() < 0.0)
    uv.setX(0.0);
  else if (uv.x() >= vars.refDim.lx - 1) {
    uv.setX(vars.refDim.lx - 1);
    inc_x = 0;
  }
  if (uv.y() < 0.0)
    uv.setY(0.0);
  else if (uv.y() >= vars.refDim.ly - 1) {
    uv.setY(vars.refDim.ly - 1);
    inc_y = 0;
  }
  QPoint p00(int(std::floor(uv.x())), int(std::floor(uv.y())));
  QPointF frac = uv - QPointF(p00);
  if (frac.isNull()) return map(p00);
  QPoint p01 = p00 + QPoint(inc_x, 0);
  QPoint p10 = p00 + QPoint(0, inc_y);
  QPoint p11 = p00 + QPoint(inc_x, inc_y);
 
  return lerp(lerp(map(p00), map(p01), frac.x()),
              lerp(map(p10), map(p11), frac.x()), frac.y());
};
 
// compute horizontal position of the projected point on the projection
// plane
inline double getXPos(QVector3D pos,
                      const Iwa_FloorBumpFx::FloorBumpVars &vars) {
  double angle_Q = vars.angle_el - atan((vars.P_y - pos.y()) / pos.z());
  double dist =
      vars.d_PT * cos(vars.angle_el - angle_Q) / (cos(angle_Q) * pos.z());
  return pos.x() * dist + double(vars.resultDim.lx) * 0.5;
};
 
inline float4 getTextureOffsetColor(double preTexOff, double texOff,
                                    float ratio) {
  float val = lerp(preTexOff, texOff, ratio);
  return float4{val, val, val, 1.0};
};
inline float4 getDiffuseColor(QVector3D n,
                              const Iwa_FloorBumpFx::FloorBumpVars &vars) {
  float val = QVector3D::dotProduct(n, vars.sunVec);
  if (val < 0.0) val = 0.0;
  return float4{val, val, val, 1.0};
};
inline float4 getDiffuseDifferenceColor(
    QVector3D n, QVector3D base_n, const Iwa_FloorBumpFx::FloorBumpVars &vars) {
  float val      = QVector3D::dotProduct(n, vars.sunVec);
  float base_val = QVector3D::dotProduct(base_n, vars.sunVec);
  val            = (val - base_val) * 0.5 + 0.5;
  if (val < 0.0)
    val = 0.0;
  else if (val > 1.0)
    val = 1.0;
  return float4{val, val, val, 1.0};
};
inline float4 getSpecularColor(QVector3D n, QVector3D pos,
                               const Iwa_FloorBumpFx::FloorBumpVars &vars) {
  QVector3D halfVector =
      ((vars.eyePos - pos).normalized() + vars.sunVec).normalized();
  float val = QVector3D::dotProduct(n, halfVector);
  if (val < 0.0) val = 0.0;
  val = std::pow(val, 50.0);
  return float4{val, val, val, 1.0};
};
inline float4 getSpecularDifferenceColor(
    QVector3D n, QVector3D base_n, QVector3D pos, QVector3D base_pos,
    const Iwa_FloorBumpFx::FloorBumpVars &vars) {
  QVector3D halfVector =
      ((vars.eyePos - pos).normalized() + vars.sunVec).normalized();
  float ang = std::acos(QVector3D::dotProduct(n, halfVector));
  halfVector =
      ((vars.eyePos - base_pos).normalized() + vars.sunVec).normalized();
  float base_ang = std::acos(QVector3D::dotProduct(base_n, halfVector));
  float val      = std::abs(ang - base_ang) / M_PI_2;
  if (val > 1.0) val = 1.0;
  return float4{val, val, val, 1.0};
};
inline float4 getFresnelColor(QVector3D n, QVector3D pos,
                              const Iwa_FloorBumpFx::FloorBumpVars &vars) {
  float angle =
      acos(QVector3D::dotProduct(n, (vars.eyePos - pos).normalized()));
  float val = (fresnelFactor(angle) - vars.base_fresnel_ref) /
              (1.0f - vars.base_fresnel_ref);
  if (val < 0.0) val = 0.0;
  return float4{val, val, val, 1.0};
};
inline float4 getFresnelDifferenceColor(
    QVector3D n, QVector3D base_n, QVector3D pos,
    const Iwa_FloorBumpFx::FloorBumpVars &vars) {
  float val =
      getFresnelColor(n, pos, vars).x - getFresnelColor(base_n, pos, vars).x;
  if (val < 0.0) val = 0.0;
  return float4{val, val, val, 1.0};
};
// currently the texture is assumed as an image of the bottom WITHOUT WATER.
// would it be nice to have a mode to handle the texture as
// an image of the bottom refracted on the surface WITHOUT WAVES?
inline float4 getRefractionColor(QVector3D n, QVector3D pos,
                                 float4 *source_host,
                                 const Iwa_FloorBumpFx::FloorBumpVars &vars) {
  QVector3D eyeVec = (vars.eyePos - pos).normalized();
  // incident angle
  float n_eye       = QVector3D::dotProduct(n, eyeVec);
  double angle_inci = acos(n_eye);
  // refraction angle
  double angle_refr = asin(sin(angle_inci) / vars.r_index);
  QVector3D refrRay =
      sin(angle_refr) * (n_eye * n - eyeVec).normalized() - cos(angle_refr) * n;
  double travelLength = -(vars.depth + pos.y()) / refrRay.y();
  QVector3D bottomPos = pos + refrRay * travelLength;
  return getSourcePix(
      QPointF(getXPos(bottomPos, vars),
              getVPos(QPointF(bottomPos.z(), bottomPos.y()), vars)),
      source_host, vars);
};
 
inline float4 getReflectionColor(QVector3D n, QVector3D pos,
                                 float4 *source_host,
                                 const Iwa_FloorBumpFx::FloorBumpVars &vars) {
  // draw nothing behind the reflected object
  if (vars.distance > 0.0 && pos.z() >= vars.distance)
    return float4{0.0, 0.0, 0.0, 0.0};
  QVector3D eyeVec = (vars.eyePos - pos).normalized();
  QVector3D refVec = -eyeVec + 2.0 * QVector3D::dotProduct(eyeVec, n) * n;
  if (refVec.z() <= 0.0) return float4{0.0, 0.0, 0.0, 0.0};
  // if the object is at infinite length, compute the reflected UV by
  // using only the angles of reflection vector
  if (vars.distance < 0.0) {
    double angle_ref_azim = asin(refVec.x());
    double angle_ref_elev = asin(refVec.y());
    double ref_v =
        vars.d_PT * tan(vars.angle_el - angle_ref_elev) + vars.H / 2.0;
    double ref_u =
        vars.d_PT * tan(angle_ref_azim) / cos(vars.angle_el - angle_ref_elev) +
        vars.W / 2.0;
    return getSourcePix(QPointF(ref_u, ref_v), source_host, vars);
  }
  // compute the reflected UV
  double length      = (vars.distance - pos.z()) / refVec.z();
  QVector3D boardPos = pos + length * refVec;
  // invert Y coordinate since the texture image is already vertically
  // "reflected"
  boardPos.setY(-boardPos.y());
  return getSourcePix(
      QPointF(getXPos(boardPos, vars),
              getVPos(QPointF(boardPos.z(), boardPos.y()), vars)),
      source_host, vars);
};
 
inline float4 getColor(QVector3D pre_n, QVector3D cur_n, QVector3D pre_p,
                       QVector3D cur_p, float ratio, float4 *source_host,
                       const Iwa_FloorBumpFx::FloorBumpVars &vars,
                       QVector3D pre_base_n   = QVector3D(0, 1, 0),
                       QVector3D cur_base_n   = QVector3D(0, 1, 0),
                       QVector3D pre_base_pos = QVector3D(),
                       QVector3D cur_base_pos = QVector3D()) {
  if (vars.renderMode == Iwa_FloorBumpFx::DiffuseMode) {
    if (vars.differenceMode)
      return getDiffuseDifferenceColor(
          lerpNormal(pre_n, cur_n, ratio),
          lerpNormal(pre_base_n, cur_base_n, ratio), vars);
    else
      return getDiffuseColor(lerpNormal(pre_n, cur_n, ratio), vars);
  } else if (vars.renderMode == Iwa_FloorBumpFx::SpecularMode) {
    if (vars.differenceMode)
      return getSpecularDifferenceColor(
          lerpNormal(pre_n, cur_n, ratio),
          lerpNormal(pre_base_n, cur_base_n, ratio),
          lerpPos(pre_p, cur_p, ratio),
          lerpPos(pre_base_pos, cur_base_pos, ratio), vars);
    else
      return getSpecularColor(lerpNormal(pre_n, cur_n, ratio),
                              lerpPos(pre_p, cur_p, ratio), vars);
  } else if (vars.renderMode == Iwa_FloorBumpFx::FresnelMode) {
    if (vars.differenceMode)
      return getFresnelDifferenceColor(
          lerpNormal(pre_n, cur_n, ratio),
          lerpNormal(pre_base_n, cur_base_n, ratio),
          lerpPos(pre_p, cur_p, ratio), vars);
    else
      return getFresnelColor(lerpNormal(pre_n, cur_n, ratio),
                             lerpPos(pre_p, cur_p, ratio), vars);
  } else if (vars.renderMode == Iwa_FloorBumpFx::RefractionMode)
    return getRefractionColor(lerpNormal(pre_n, cur_n, ratio),
                              lerpPos(pre_p, cur_p, ratio), source_host, vars);
  else if (vars.renderMode == Iwa_FloorBumpFx::ReflectionMode)
    return getReflectionColor(lerpNormal(pre_n, cur_n, ratio),
                              lerpPos(pre_p, cur_p, ratio), source_host, vars);
  return float4();
};
 
QList<QPointF> getSubPointsList(int subAmount,
                                const Iwa_FloorBumpFx::FloorBumpVars &vars) {
  QList<QPointF> ret;
  if (!areAlmostEqual(vars.textureOffsetAmount, 0.0)) {
    for (int su = -subAmount; su <= subAmount; su++) {
      double sub_u = float(su) / float(subAmount);
      for (int sv = -subAmount; sv <= subAmount; sv++) {
        double sub_v = float(sv) / float(subAmount);
        // 円の外ならcontinue
        if (sub_u * sub_u + sub_v * sub_v > 1.0) continue;
        if (su == 0 && sv == 0) continue;
        ret.append(QPointF(vars.spread * sub_u, vars.spread * sub_v));
      }
    }
  }
  return ret;
}
 
}  // namespace
 
//------------------------------------
 
Iwa_FloorBumpFx::Iwa_FloorBumpFx()
    : m_renderMode(new TIntEnumParam(TextureMode, "Texture"))
    , m_eyeLevel(0.0)
    , m_drawLevel(-50.0)
    , m_fov(30)
    , m_cameraAltitude(0.0)
    , m_waveHeight(10.0)
    , m_differenceMode(false)
    , m_textureOffsetAmount(0.0)
    , m_textureOffsetSpread(10.0)
    , m_sourcePrecision(300.0 / 162.5)
    , m_souceMargin(0.0)
    , m_displacement(0.0)
    , m_lightAzimuth(-135.0)
    , m_lightElevation(30.0)  // default angle_elev will shade horizontal plane
                              // 50% gray (cos(60)=0.5)
    , m_depth(30.0)
    , m_refractiveIndex(1.33333)
    , m_distanceLevel(-100.0) {
  addInputPort("Height", m_heightRef);
  addInputPort("Texture", m_texture);
  addInputPort("Displacement", m_dispRef);
  bindParam(this, "renderMode", m_renderMode);
  bindParam(this, "fov", m_fov);
  bindParam(this, "cameraAltitude", m_cameraAltitude);
  bindParam(this, "eyeLevel", m_eyeLevel);
  bindParam(this, "drawLevel", m_drawLevel);
  bindParam(this, "waveHeight", m_waveHeight);
  bindParam(this, "differenceMode", m_differenceMode);
  bindParam(this, "textureOffsetAmount", m_textureOffsetAmount);
  bindParam(this, "textureOffsetSpread", m_textureOffsetSpread);
  bindParam(this, "sourcePrecision", m_sourcePrecision);
  bindParam(this, "souceMargin", m_souceMargin);
  bindParam(this, "displacement", m_displacement);
  bindParam(this, "lightAzimuth", m_lightAzimuth);
  bindParam(this, "lightElevation", m_lightElevation);
  bindParam(this, "depth", m_depth);
  bindParam(this, "refractiveIndex", m_refractiveIndex);
  bindParam(this, "distanceLevel", m_distanceLevel);
 
  m_renderMode->addItem(DiffuseMode, "Diffuse");
  m_renderMode->addItem(SpecularMode, "Specular");
  m_renderMode->addItem(FresnelMode, "Fresnel reflectivity");
  m_renderMode->addItem(RefractionMode, "Refraction");
  m_renderMode->addItem(ReflectionMode, "Reflection");
 
  m_fov->setValueRange(10, 90);
  m_cameraAltitude->setMeasureName("fxLength");
  m_cameraAltitude->setValueRange(0.0, 300.0);
  m_eyeLevel->setMeasureName("fxLength");
  m_drawLevel->setMeasureName("fxLength");
 
  m_waveHeight->setMeasureName("fxLength");
  m_waveHeight->setValueRange(-1000.0, 1000.0);
  m_textureOffsetAmount->setMeasureName("fxLength");
  m_textureOffsetAmount->setValueRange(-2000.0, 2000.0);
  m_textureOffsetSpread->setMeasureName("fxLength");
  m_textureOffsetSpread->setValueRange(1.0, 300.0);
 
  m_sourcePrecision->setValueRange(1.0, 2.0);
  m_souceMargin->setMeasureName("fxLength");
  m_souceMargin->setValueRange(0.0, 100.0);
  m_displacement->setMeasureName("fxLength");
  m_displacement->setValueRange(-50.0, 50.0);
 
  m_lightAzimuth->setValueRange(-360.0, 360.0);
  m_lightElevation->setValueRange(0.0, 90.0);
 
  m_depth->setMeasureName("fxLength");
  m_depth->setValueRange(0.0, 1000.0);
  m_refractiveIndex->setValueRange(1.0, 3.0);
 
  m_distanceLevel->setMeasureName("fxLength");
}
 
//------------------------------------
 
bool Iwa_FloorBumpFx::doGetBBox(double frame, TRectD &bBox,
                                const TRenderSettings &info) {
  if (m_heightRef.isConnected()) {
    bool ret = m_heightRef->doGetBBox(frame, bBox, info);
    if (ret) bBox = TConsts::infiniteRectD;
    return ret;
  }
  return false;
}
 
//------------------------------------
 
bool Iwa_FloorBumpFx::canHandle(const TRenderSettings &info, double frame) {
  return false;
}
 
//------------------------------------------------------------
// convert output values (in float4) to channel value
//------------------------------------------------------------
template <typename RASTER, typename PIXEL>
void Iwa_FloorBumpFx::setOutputRaster(float4 *srcMem, const RASTER dstRas,
                                      TDimensionI dim, int drawLevel) {
  typename PIXEL::Channel halfChan =
      (typename PIXEL::Channel)(PIXEL::maxChannelValue / 2);
 
  dstRas->fill(PIXEL::Transparent);
 
  for (int j = 0; j < drawLevel; j++) {
    if (j >= dstRas->getLy()) break;
 
    PIXEL *pix     = dstRas->pixels(j);
    float4 *chan_p = &srcMem[j];
    for (int i = 0; i < dstRas->getLx(); i++, chan_p += drawLevel, pix++) {
      float val;
      val    = (*chan_p).x * (float)PIXEL::maxChannelValue + 0.5f;
      pix->r = (typename PIXEL::Channel)((val > (float)PIXEL::maxChannelValue)
                                             ? (float)PIXEL::maxChannelValue
                                             : val);
      val    = (*chan_p).y * (float)PIXEL::maxChannelValue + 0.5f;
      pix->g = (typename PIXEL::Channel)((val > (float)PIXEL::maxChannelValue)
                                             ? (float)PIXEL::maxChannelValue
                                             : val);
      val    = (*chan_p).z * (float)PIXEL::maxChannelValue + 0.5f;
      pix->b = (typename PIXEL::Channel)((val > (float)PIXEL::maxChannelValue)
                                             ? (float)PIXEL::maxChannelValue
                                             : val);
      val    = (*chan_p).w * (float)PIXEL::maxChannelValue + 0.5f;
      pix->m = (typename PIXEL::Channel)((val > (float)PIXEL::maxChannelValue)
                                             ? (float)PIXEL::maxChannelValue
                                             : val);
    }
  }
}
 
//------------------------------------
 
inline void Iwa_FloorBumpFx::initVars(FloorBumpVars &vars, TTile &tile,
                                      const TRenderSettings &settings,
                                      double frame) {
  TAffine aff       = settings.m_affine;
  double factor     = sqrt(std::abs(settings.m_affine.det()));
  double eyeLevel   = m_eyeLevel->getValue(frame) * factor;
  double refLevel   = m_drawLevel->getValue(frame) * factor;
  vars.waveHeight   = m_waveHeight->getValue(frame) * factor;
  vars.displacement = m_displacement->getValue(frame) * factor;
  if (eyeLevel - 1.0 < refLevel) refLevel = eyeLevel - 1.0;
  int drawHeight = std::max(refLevel, vars.waveHeight) - tile.m_pos.y;
  vars.refHeight = int(refLevel - tile.m_pos.y);
  // convert the pixel coordinate from the bottom-left of the camera box
  eyeLevel = eyeLevel - (tile.m_pos.y + tile.getRaster()->getCenterD().y) +
             settings.m_cameraBox.getLy() / 2.0;
  refLevel = refLevel - (tile.m_pos.y + tile.getRaster()->getCenterD().y) +
             settings.m_cameraBox.getLy() / 2.0;
 
  TRectD rectOut(tile.m_pos, TDimensionD(tile.getRaster()->getLx(),
                                         tile.getRaster()->getLy()));
  vars.outDim    = TDimensionI(rectOut.getLx(), rectOut.getLy());
  vars.resultDim = TDimensionI(rectOut.getLx(),
                               std::min(drawHeight, tile.getRaster()->getLy()));
 
  // get texture image
  vars.margin    = tceil(m_souceMargin->getValue(frame) * factor);
  vars.precision = m_sourcePrecision->getValue(frame);
 
  // add margins to all ends and multiply by precision value
  vars.sourceDim = TDimensionI(
      tceil(vars.precision * double(vars.resultDim.lx + vars.margin * 2)),
      tceil(vars.precision * double(vars.resultDim.ly + vars.margin * 2)));
  // only add margins for height image
  vars.refDim = TDimensionI(vars.resultDim.lx + vars.margin * 2,
                            vars.refHeight + vars.margin * 2);
 
  // collecting parameters
  double angle_halfFov = m_fov->getValue(frame) * M_PI_180 / 2.0;
  vars.textureOffsetAmount =
      100.0 * m_textureOffsetAmount->getValue(frame) * factor * factor;
  vars.spread = m_textureOffsetSpread->getValue(frame) * factor;
  if (vars.spread < 1.0) vars.spread = 1.0;
  vars.camAltitude    = m_cameraAltitude->getValue(frame) * factor;
  vars.differenceMode = m_differenceMode->getValue();
 
  // making pixels in gray128 to be zero level height
  // ( 128/255. IT'S NOT 0.5! )
  vars.zeroLevel = double(128) / double(TPixel32::maxChannelValue);
 
  vars.H = settings.m_cameraBox.getLy();
  vars.W = settings.m_cameraBox.getLx();
 
  double el = eyeLevel - vars.H / 2.0;
  // angle between the optical axis and the horizontal axis
  vars.angle_el =
      std::atan(2.0 * el * tan(angle_halfFov) / double(vars.outDim.ly));
  // distance between the Eye (P) and
  // the center of bottom edge of the projection plane (B)
  double d_PB = double(vars.outDim.ly) / (2.0 * sin(angle_halfFov));
  // Y coordinate of the Eye position (P)
  vars.P_y = vars.camAltitude + d_PB * sin((angle_halfFov) + vars.angle_el);
  // distance from the Eye (P) to the center of the projection plane (T)
  vars.d_PT = vars.H / (2.0 * tan(angle_halfFov));
 
  QMatrix cam_tilt;
  cam_tilt.rotate(-vars.angle_el / M_PI_180);
  // Z-Y position of the center of top edge of the projection plane (A)
  vars.A =
      cam_tilt.map(QPointF(vars.d_PT, vars.H / 2.0)) + QPointF(0, vars.P_y);
  // Z-Y position of the center of bottom edge of the projection plane (B)
  vars.B =
      cam_tilt.map(QPointF(vars.d_PT, -vars.H / 2.0)) + QPointF(0, vars.P_y);
 
  vars.C_z    = vars.P_y / tan(angle_halfFov + vars.angle_el);
  vars.eyePos = QVector3D(0.0, vars.P_y, 0.0);
 
  switch (vars.renderMode) {
    // for shading modes ( diffuse & specular )
  case DiffuseMode:
  case SpecularMode: {
    double angle_azim = m_lightAzimuth->getValue(frame) * M_PI_180;
    double angle_elev = m_lightElevation->getValue(frame) * M_PI_180;
    vars.sunVec = QVector3D(sin(angle_azim) * cos(angle_elev), sin(angle_elev),
                            cos(angle_azim) * cos(angle_elev));
    break;
  }
  case FresnelMode: {  // for fresnel mode
    double angle_base     = 0.5 * M_PI - (angle_halfFov + vars.angle_el);
    vars.base_fresnel_ref = fresnelFactor(angle_base);
    break;
  }
  case RefractionMode: {
    // for refraction mode
    vars.depth   = m_depth->getValue(frame) * factor;
    vars.r_index = m_refractiveIndex->getValue(frame);
    break;
  }
  case ReflectionMode: {
    // for reflection mode
    double distanceLevel = m_distanceLevel->getValue(frame) * factor;
    double angle_dl      = atan(distanceLevel / vars.d_PT);
    // Z-axis distance to the reflected object.
    // distance = -1 means the object is at infinity
    vars.distance = (angle_dl >= vars.angle_el)
                        ? -1
                        : vars.P_y / tan(vars.angle_el - angle_dl);
    break;
  }
  }
}
//------------------------------------
 
void Iwa_FloorBumpFx::doCompute_CPU(TTile &tile, const double frame,
                                    const TRenderSettings &settings,
                                    const FloorBumpVars &vars,
                                    float4 *source_host, float *ref_host,
                                    float4 *result_host) {
  //-----------
  // Texture Mode
  if (vars.renderMode == TextureMode) {
    // テクスチャの勾配を調べるサンプリング点
    int subAmount = 10;  // これ、パラメータ化するか…？
    QList<QPointF> subPoints = getSubPointsList(subAmount, vars);
 
    // render pixels in column-major order, from bottom to top
    for (int i = 0; i < vars.resultDim.lx; i++) {
      // cancel check
      if (settings.m_isCanceled && *settings.m_isCanceled) return;
 
      double maxVPos         = 0.0;  // maximum height of drawn pixels
      double preVPos         = 0.0;  // height of the previous segment
      QPointF preUV          = QPointF(i, -vars.margin);
      float4 *result_p       = &result_host[i * vars.resultDim.ly];
      float4 *end_p          = &result_host[(i + 1) * vars.resultDim.ly - 1];
      float preTextureOffset = 0.0;
 
      bool backled   = false;
      double preGrad = 100.0;
 
      // get height pixels from bottom to top
      for (int j = -vars.margin; j < vars.refHeight; j++) {
        // angle between the light axis and the line between (Q) and the eye (P)
        // (Q) is a point on the projection plane at distance of j from (B)
        double angle_Q =
            std::atan((float(j) - (vars.outDim.ly / 2.0)) / vars.d_PT);
        // (R) is an intersection between the XZ plane and the line P->Q
        double R_z = vars.P_y / tan(vars.angle_el - angle_Q);
 
        // compute (S), a point on the bumped surface in Y-axis direction from
        // (R)
        float refVal =
            getMapValue(QPointF(double(i), double(j)), ref_host, vars);
        QPointF S(R_z, vars.waveHeight * (refVal - vars.zeroLevel) * 2.0);
        // height of (S) projected on the projection plane
        double vPos = getVPos(S, vars);
 
        // UV coordinate of the texture image
        QPointF currentUV;
        float currentTextureOffset = 0.0;
        if (areAlmostEqual(vars.textureOffsetAmount, 0.0))
          currentUV = QPointF(double(i), getVPos(QPointF(R_z, 0), vars));
        else {
          // length of (1,0,0) vector on the XZ plane, projected on the
          // projection plane
          double dist = (vars.d_PT * sin(vars.angle_el - angle_Q)) / vars.P_y *
                        cos(angle_Q);
          // approximate the gradient by difference of the heights of neighbor
          // points
 
          // compute gradient of the height image
          QPointF offset;
          for (const QPointF &subPoint : subPoints) {
            // この地点のRefの値を取る
            QPointF subRefPos(double(i) + dist * subPoint.x(),
                              getVPos(QPointF(R_z + subPoint.y(), 0), vars));
 
            int sign_u = (subPoint.x() > 0) - (subPoint.x() < 0);  // -1, 0, 1
            int sign_v = (subPoint.y() > 0) - (subPoint.y() < 0);  // -1, 0, 1
 
            float subRefValue = getMapValue(subRefPos, ref_host, vars);
            offset += subRefValue * QPointF(sign_u, sign_v);
          }
 
          offset *= 1.0 / float(subPoints.count() - subAmount);  // サンプル数
          offset *= vars.textureOffsetAmount /
                    (vars.spread * (0.5 + 0.5 / float(subAmount)));  // 距離
          currentUV = QPointF(double(i) + offset.x() * dist,
                              getVPos(QPointF(R_z + offset.y(), 0), vars));
          if (vars.differenceMode)
            currentTextureOffset =
                std::sqrt(offset.x() * offset.x() + offset.y() * offset.y()) /
                vars.textureOffsetAmount;
        }
 
        // continue if the current point is behind the forward bumps
        if (vPos <= maxVPos) {
          preVPos          = vPos;
          preUV            = currentUV;
          preTextureOffset = currentTextureOffset;
          continue;
        }
 
        // putting colors on pixels
        int currentY       = int(std::floor(maxVPos));
        float current_frac = maxVPos - float(currentY);
        int toY            = int(std::floor(vPos));
        float to_frac      = vPos - float(toY);
        // if the entire current segment is in the same pixel,
        // then add colors with percentage of the fraction part
        if (currentY == toY) {
          float ratio = to_frac - current_frac;
          if (vars.differenceMode)
            *result_p += getTextureOffsetColor(preTextureOffset,
                                               currentTextureOffset, 0.5) *
                         ratio;
          else
            *result_p +=
                getSourcePix(lerpUV(preUV, currentUV, 0.5), source_host, vars) *
                ratio;
          preVPos          = vPos;
          maxVPos          = vPos;
          preUV            = currentUV;
          preTextureOffset = currentTextureOffset;
          continue;
        }
 
        // fill fraction part of the start pixel (currentY)
        float k =
            (maxVPos + (1.0 - current_frac) / 2.0 - preVPos) / (vPos - preVPos);
        float ratio = 1.0 - current_frac;
        if (vars.differenceMode)
          *result_p +=
              getTextureOffsetColor(preTextureOffset, currentTextureOffset, k) *
              ratio;
        else
          *result_p +=
              getSourcePix(lerpUV(preUV, currentUV, k), source_host, vars) *
              ratio;
 
        if (result_p == end_p) break;
        result_p++;
 
        // fill pixels between currentY and toY
        for (int y = currentY + 1; y < toY; y++) {
          k = (float(y) + 0.5 - preVPos) / (vPos - preVPos);
          if (vars.differenceMode)
            *result_p += getTextureOffsetColor(preTextureOffset,
                                               currentTextureOffset, k);
          else
            *result_p =
                getSourcePix(lerpUV(preUV, currentUV, k), source_host, vars);
          if (result_p == end_p) break;
          result_p++;
        }
 
        // fill fraction part of the end pixel (toY)
        k = (float(toY) + to_frac * 0.5 - preVPos) / (vPos - preVPos);
        if (vars.differenceMode)
          *result_p +=
              getTextureOffsetColor(preTextureOffset, currentTextureOffset, k) *
              to_frac;
        else
          *result_p +=
              getSourcePix(lerpUV(preUV, currentUV, k), source_host, vars) *
              to_frac;
 
        preVPos          = vPos;
        maxVPos          = vPos;
        preUV            = currentUV;
        preTextureOffset = currentTextureOffset;
      }
    }
  }
  // Other modes
  // (Diffuse, Specular, Fresnel, Refraction, Reflection)
  else {
    // render pixels in column-major order, from bottom to top
    for (int i = 0; i < vars.resultDim.lx; i++) {
      // cancel check
      if (settings.m_isCanceled && *settings.m_isCanceled) return;
 
      double maxVPos = 0.0;  // maximum height of drawn pixels
      double preVPos = 0.0;  // height of the previous segment
      QVector3D preNormal(0, 1, 0);
      QVector3D prePos(i, 0,
                       vars.C_z);  // actually the x coordinate is not i at the
                                   // initial position.., but no problem.
      float4 *result_p = &result_host[i * vars.resultDim.ly];
      float4 *end_p    = &result_host[(i + 1) * vars.resultDim.ly - 1];
      // get height pixels from bottom to top
      for (int j = -vars.margin; j < vars.refHeight; j++) {
        // angle between the light axis and the line between (Q) and the eye (P)
        // (Q) is a point on the projection plane at distance of j from (B)
        double angle_Q =
            std::atan((float(j) - (vars.outDim.ly / 2.0)) / vars.d_PT);
        // (R) is an intersection between the XZ plane and the line P->Q
        double R_z = vars.P_y / tan(vars.angle_el - angle_Q);
        // In reflection mode, do not draw surface behind the Distance Level
        if (vars.renderMode == ReflectionMode && vars.distance > 0.0 &&
            R_z >= vars.distance)
          break;
        // compute normal vector from cross-product of surface vectors
        QVector3D currentNormal;
        // length of (1,0,0) vector on the XZ plane, projected on the projection
        // plane
        double dist = (vars.d_PT * sin(vars.angle_el - angle_Q)) / vars.P_y *
                      cos(angle_Q);
        double xRefGrad =
            getMapValue(QPointF(double(i) + dist, double(j)), ref_host, vars) -
            getMapValue(QPointF(double(i) - dist, double(j)), ref_host, vars);
        double zRefGrad =
            getMapValue(QPointF(double(i), getVPos(QPointF(R_z + 1, 0), vars)),
                        ref_host, vars) -
            getMapValue(QPointF(double(i), getVPos(QPointF(R_z - 1, 0), vars)),
                        ref_host, vars);
        currentNormal.setX(-xRefGrad * vars.waveHeight * 2.0);
        currentNormal.setY(4.0);
        currentNormal.setZ(-zRefGrad * vars.waveHeight * 2.0);
        currentNormal.normalize();
 
        // compute (S), a point on the bumped surface in Y-axis direction from
        // (R)
        float refVal =
            getMapValue(QPointF(double(i), double(j)), ref_host, vars);
        QPointF S(R_z, vars.waveHeight * (refVal - vars.zeroLevel) * 2.0);
        // height of (S) projected on the projection plane
        double vPos = getVPos(S, vars);
        QVector3D currentPos(double(i - vars.resultDim.lx / 2) / dist, S.y(),
                             S.x());
 
        // continue if the current point is behind the forward bumps
        if (vPos <= maxVPos) {
          preVPos   = vPos;
          preNormal = currentNormal;
          prePos    = currentPos;
          continue;
        }
 
        // putting colors on pixels
        int currentY       = int(std::floor(maxVPos));
        float current_frac = maxVPos - float(currentY);
        int toY            = int(std::floor(vPos));
        float to_frac      = vPos - float(toY);
        // if the entire current segment is in the same pixel,
        // then add colors with percentage of the fraction part
        if (currentY == toY) {
          float ratio = to_frac - current_frac;
          *result_p += getColor(preNormal, currentNormal, prePos, currentPos,
                                0.5, source_host, vars) *
                       ratio;
          preVPos   = vPos;
          maxVPos   = vPos;
          preNormal = currentNormal;
          prePos    = currentPos;
          continue;
        }
 
        // fill fraction part of the start pixel (currentY)
        float k =
            (maxVPos + (1.0 - current_frac) / 2.0 - preVPos) / (vPos - preVPos);
        float4 color = getColor(preNormal, currentNormal, prePos, currentPos, k,
                                source_host, vars);
        float ratio  = 1.0 - current_frac;
        *result_p += color * ratio;
 
        if (result_p == end_p) break;
        result_p++;
 
        // fill pixels between currentY and toY
        for (int y = currentY + 1; y < toY; y++) {
          k         = (float(y) + 0.5 - preVPos) / (vPos - preVPos);
          *result_p = getColor(preNormal, currentNormal, prePos, currentPos, k,
                               source_host, vars);
          if (result_p == end_p) break;
          result_p++;
        }
 
        // fill fraction part of the end pixel (toY)
        k     = (float(toY) + to_frac * 0.5 - preVPos) / (vPos - preVPos);
        color = getColor(preNormal, currentNormal, prePos, currentPos, k,
                         source_host, vars);
        *result_p += color * to_frac;
 
        preVPos   = vPos;
        maxVPos   = vPos;
        preNormal = currentNormal;
        prePos    = currentPos;
      }
    }
  }
}
 
//------------------------------------
 
void Iwa_FloorBumpFx::doCompute_with_Displacement(
    TTile &tile, const double frame, const TRenderSettings &settings,
    const FloorBumpVars &vars, float4 *source_host, float *ref_host,
    float *disp_host, float4 *result_host) {
  //----- Lambdas ------
 
  // テクスチャの勾配を調べるサンプリング点
  int subAmount            = 10;  // これ、パラメータ化するか…？
  QList<QPointF> subPoints = getSubPointsList(subAmount, vars);
 
  //-----------
  // Texture Mode
  if (vars.renderMode == TextureMode) {
    // render pixels in column-major order, from bottom to top
    for (int i = 0; i < vars.resultDim.lx; i++) {
      // cancel check
      if (settings.m_isCanceled && *settings.m_isCanceled) return;
 
      double maxVPos         = 0.0;  // maximum height of drawn pixels
      double preVPos         = 0.0;  // height of the previous segment
      QPointF preUV          = QPointF(i, -vars.margin);
      float4 *result_p       = &result_host[i * vars.resultDim.ly];
      float4 *end_p          = &result_host[(i + 1) * vars.resultDim.ly - 1];
      float preTextureOffset = 0.0;
      // get height pixels from bottom to top
      for (int j = -vars.margin; j < vars.refHeight; j++) {
        // angle between the light axis and the line between (Q) and the eye (P)
        // (Q) is a point on the projection plane at distance of j from (B)
        double angle_Q =
            std::atan((float(j) - (vars.outDim.ly / 2.0)) / vars.d_PT);
        // (R) is an intersection between the XZ plane and the line P->Q
        double R_z = vars.P_y / tan(vars.angle_el - angle_Q);
 
        // compute (S), a point on the bumped surface in Y-axis direction from
        // (R)
        float refVal =
            getMapValue(QPointF(double(i), double(j)), ref_host, vars);
        QPointF S(R_z, vars.waveHeight * (refVal - vars.zeroLevel) * 2.0);
 
        // length of (1,0,0) vector on the XZ plane, projected on the
        // projection plane
        double dist = (vars.d_PT * sin(vars.angle_el - angle_Q)) / vars.P_y *
                      cos(angle_Q);
 
        // UV coordinate of the texture image
        QVector3D uvOffset;
        float currentTextureOffset = 0.0;
        if (vars.textureOffsetAmount == 0.0) {
          // currentUV = QPointF(double(i), getVPos(QPointF(R_z, 0)));
        } else {
          // approximate the gradient by difference of the heights of neighbor
          // points
 
          // compute gradient of the height image
          QPointF offset;
          for (const QPointF &subPoint : subPoints) {
            // この地点のRefの値を取る
            QPointF subRefPos(double(i) + dist * subPoint.x(),
                              getVPos(QPointF(R_z + subPoint.y(), 0), vars));
 
            int sign_u = (subPoint.x() > 0) - (subPoint.x() < 0);  // -1, 0, 1
            int sign_v = (subPoint.y() > 0) - (subPoint.y() < 0);  // -1, 0, 1
 
            float subRefValue = getMapValue(subRefPos, ref_host, vars);
            offset += subRefValue * QPointF(sign_u, sign_v);
          }
          offset *= 1.0 / float(subPoints.count() - subAmount);  // サンプル数
          offset *= vars.textureOffsetAmount /
                    (vars.spread * (0.5 + 0.5 / float(subAmount)));  // 距離
 
          uvOffset.setX(offset.x() * dist);
          uvOffset.setZ(offset.y());
          // currentUV = QPointF(double(i) + offset.x() * dist,
          //   getVPos(QPointF(R_z + offset.y(), 0)));
          if (vars.differenceMode)
            currentTextureOffset =
                1000 *
                std::sqrt(offset.x() * offset.x() + offset.y() * offset.y()) /
                vars.textureOffsetAmount;
        }
        QPointF currentDispUV =
            QPointF(double(i) + uvOffset.x(),
                    getVPos(QPointF(R_z + uvOffset.z(), 0), vars));
 
        // この地点の変位の値を取得する
        float dispValue  = getMapValue(currentDispUV, disp_host, vars);
        float dispHeight = dispValue * vars.displacement;
 
        // この地点の法線を取得
        QVector3D currentNormal;
        double xRefGrad =
            getMapValue(QPointF(double(i) + dist, double(j)), ref_host, vars) -
            getMapValue(QPointF(double(i) - dist, double(j)), ref_host, vars);
        double zRefGrad =
            getMapValue(QPointF(double(i), getVPos(QPointF(R_z + 1, 0), vars)),
                        ref_host, vars) -
            getMapValue(QPointF(double(i), getVPos(QPointF(R_z - 1, 0), vars)),
                        ref_host, vars);
        currentNormal.setX(-xRefGrad * vars.waveHeight * 2.0);
        currentNormal.setY(4.0);
        currentNormal.setZ(-zRefGrad * vars.waveHeight * 2.0);
        currentNormal.normalize();
 
        // 変位後の表面座標 (M)
        // ※法線のX成分は強引にY座標の変位に持ち込んで近似する
        float dispXY = std::sqrt(currentNormal.x() * currentNormal.x() +
                                 currentNormal.y() * currentNormal.y());
        QPointF M    = S + QPointF(currentNormal.z(), dispXY) * dispHeight;
        // float dispXRatio = std::sqrt(currentNormal.x()*currentNormal.x() +
        // currentNormal.y()*currentNormal.y()) / currentNormal.y(); QPointF M =
        // S + QPointF(currentNormal.z(), currentNormal.y()* dispXRatio) *
        // dispHeight;
 
        // height of (M) projected on the projection plane
        double vPos = getVPos(M, vars);
 
        uvOffset.setY(dispHeight);
        QPointF currentUV =
            QPointF(double(i) + uvOffset.x(),
                    getVPos(QPointF(R_z + uvOffset.z(), uvOffset.y()), vars));
 
        // 手前のDisplacementで隠されている部分かどうかの判定
        bool isBehind = false;
 
        if (preUV.y() > currentUV.y()) isBehind = true;
        /*
        if ((vars.displacement > 0.0 && dispValue < 1.0) ||
            (vars.displacement < 0.0 && dispValue > 0.0)) {
          QPointF dUV     = (currentDispUV - currentUV) * 0.1;
          QPointF tmpUV   = currentUV + dUV;
          float dHeight   = dispHeight * 0.1;
          float tmpHeight = dHeight;
          for (int k = 1; k < 10; k++, tmpUV += dUV, tmpHeight += dHeight) {
            if (getMapValue(tmpUV, disp_host, vars) * vars.displacement >
                tmpHeight) {
              isBehind = true;
              break;
            }
          }
        }*/
 
        // continue if the current point is behind the forward bumps
        if (vPos <= maxVPos) {
          preVPos = vPos;
          if (!isBehind) preUV = currentUV;
          preTextureOffset = currentTextureOffset;
          continue;
        }
 
        // putting colors on pixels
        int currentY       = int(std::floor(maxVPos));
        float current_frac = maxVPos - float(currentY);
        int toY            = int(std::floor(vPos));
        float to_frac      = vPos - float(toY);
        // if the entire current segment is in the same pixel,
        // then add colors with percentage of the fraction part
        if (currentY == toY) {
          if (!isBehind) {
            float ratio = to_frac - current_frac;
            if (vars.differenceMode)
              *result_p += getTextureOffsetColor(preTextureOffset,
                                                 currentTextureOffset, 0.5) *
                           ratio;
            else
              *result_p += getSourcePix(lerpUV(preUV, currentUV, 0.5),
                                        source_host, vars) *
                           ratio;
            preUV = currentUV;
          }
          preVPos          = vPos;
          maxVPos          = vPos;
          preTextureOffset = currentTextureOffset;
          continue;
        }
 
        // fill fraction part of the start pixel (currentY)
        if (!isBehind) {
          float k = (maxVPos + (1.0 - current_frac) / 2.0 - preVPos) /
                    (vPos - preVPos);
          float ratio = 1.0 - current_frac;
          if (vars.differenceMode)
            *result_p += getTextureOffsetColor(preTextureOffset,
                                               currentTextureOffset, k) *
                         ratio;
          else
            *result_p +=
                getSourcePix(lerpUV(preUV, currentUV, k), source_host, vars) *
                ratio;
        }
 
        if (result_p == end_p) break;
        result_p++;
 
        // fill pixels between currentY and toY
        for (int y = currentY + 1; y < toY; y++) {
          if (!isBehind) {
            float k = (float(y) + 0.5 - preVPos) / (vPos - preVPos);
            if (vars.differenceMode)
              *result_p += getTextureOffsetColor(preTextureOffset,
                                                 currentTextureOffset, k);
            else
              *result_p =
                  getSourcePix(lerpUV(preUV, currentUV, k), source_host, vars);
          }
          if (result_p == end_p) break;
          result_p++;
        }
 
        // fill fraction part of the end pixel (toY)
        if (!isBehind) {
          float k = (float(toY) + to_frac * 0.5 - preVPos) / (vPos - preVPos);
          if (vars.differenceMode)
            *result_p += getTextureOffsetColor(preTextureOffset,
                                               currentTextureOffset, k) *
                         to_frac;
          else
            *result_p +=
                getSourcePix(lerpUV(preUV, currentUV, k), source_host, vars) *
                to_frac;
          preUV = currentUV;
        }
 
        preVPos          = vPos;
        maxVPos          = vPos;
        preTextureOffset = currentTextureOffset;
      }
    }
  }
  // Other modes
  // (Diffuse, Specular, Fresnel, Refraction, Reflection)
  else {
    // render pixels in column-major order, from bottom to top
    for (int i = 0; i < vars.resultDim.lx; i++) {
      // cancel check
      if (settings.m_isCanceled && *settings.m_isCanceled) return;
 
      double maxVPos = 0.0;  // maximum height of drawn pixels
      double preVPos = 0.0;  // height of the previous segment
      QVector3D preDispNormal(0, 1, 0);
      QVector3D preBaseNormal(0, 1, 0);
      QVector3D prePos(i, 0,
                       vars.C_z);  // actually the x coordinate is not i at the
                                   // initial position.., but no problem.
      QVector3D preBasePos(i, 0, vars.C_z);
 
      float4 *result_p = &result_host[i * vars.resultDim.ly];
      float4 *end_p    = &result_host[(i + 1) * vars.resultDim.ly - 1];
      // get height pixels from bottom to top
      for (int j = -vars.margin; j < vars.refHeight; j++) {
        // angle between the light axis and the line between (Q) and the eye (P)
        // (Q) is a point on the projection plane at distance of j from (B)
        double angle_Q =
            std::atan((float(j) - (vars.outDim.ly / 2.0)) / vars.d_PT);
        // (R) is an intersection between the XZ plane and the line P->Q
        double R_z = vars.P_y / tan(vars.angle_el - angle_Q);
        // In reflection mode, do not draw surface behind the Distance Level
        if (vars.renderMode == ReflectionMode && vars.distance > 0.0 &&
            R_z >= vars.distance)
          break;
 
        // compute (S), a point on the bumped surface in Y-axis direction from
        // (R)
        float refVal =
            getMapValue(QPointF(double(i), double(j)), ref_host, vars);
        QPointF S(R_z, vars.waveHeight * (refVal - vars.zeroLevel) * 2.0);
        // length of (1,0,0) vector on the XZ plane, projected on the projection
        // plane
        double dist = (vars.d_PT * sin(vars.angle_el - angle_Q)) / vars.P_y *
                      cos(angle_Q);
 
        // UV coordinate of the texture image
        QVector3D uvOffset;
        if (vars.textureOffsetAmount == 0.0) {
          // currentUV = QPointF(double(i), getVPos(QPointF(R_z, 0)));
        } else {
          // approximate the gradient by difference of the heights of neighbor
          // points
 
          // compute gradient of the height image
          QPointF offset;
          for (const QPointF &subPoint : subPoints) {
            // この地点のRefの値を取る
            QPointF subRefPos(double(i) + dist * subPoint.x(),
                              getVPos(QPointF(R_z + subPoint.y(), 0), vars));
 
            int sign_u = (subPoint.x() > 0) - (subPoint.x() < 0);  // -1, 0, 1
            int sign_v = (subPoint.y() > 0) - (subPoint.y() < 0);  // -1, 0, 1
 
            float subRefValue = getMapValue(subRefPos, ref_host, vars);
            offset += subRefValue * QPointF(sign_u, sign_v);
          }
          offset *= 1.0 / float(subPoints.count() - subAmount);  // サンプル数
          offset *= vars.textureOffsetAmount /
                    (vars.spread * (0.5 + 0.5 / float(subAmount)));  // 距離
 
          uvOffset.setX(offset.x() * dist);
          uvOffset.setZ(offset.y());
          // currentUV = QPointF(double(i) + offset.x() * dist,
          //   getVPos(QPointF(R_z + offset.y(), 0)));
        }
        QPointF currentDispUV =
            QPointF(double(i) + uvOffset.x(),
                    getVPos(QPointF(R_z + uvOffset.z(), 0), vars));
 
        // この地点の変位の値を取得する
        float dispHeight =
            getMapValue(currentDispUV, disp_host, vars) * vars.displacement;
 
        // compute normal vector from cross-product of surface vectors
        QVector3D rightPos(
            1.0,
            getMapValue(QPointF(double(i) + dist, double(j)), ref_host, vars) *
                vars.waveHeight,
            0.0);
        QVector3D leftPos(
            -1.0,
            getMapValue(QPointF(double(i) - dist, double(j)), ref_host, vars) *
                vars.waveHeight,
            0.0);
        QVector3D farPos(
            0.0,
            getMapValue(QPointF(double(i), getVPos(QPointF(R_z + 1, 0), vars)),
                        ref_host, vars) *
                vars.waveHeight,
            1.0);
        QVector3D nearPos(
            0.0,
            getMapValue(QPointF(double(i), getVPos(QPointF(R_z - 1, 0), vars)),
                        ref_host, vars) *
                vars.waveHeight,
            -1.0);
        // 左手系座標なので外積を反転する
        QVector3D currentNormal =
            -QVector3D::crossProduct(rightPos - leftPos, farPos - nearPos);
        currentNormal.normalize();
 
        // 変位後の表面座標 (M)
        // ※法線のX成分は強引にY座標の変位に持ち込んで近似する
        float dispXY = std::sqrt(currentNormal.x() * currentNormal.x() +
                                 currentNormal.y() * currentNormal.y());
        QPointF M    = S + QPointF(currentNormal.z(), dispXY) * dispHeight;
 
        // 前後左右の座標に変位を加える
        QPointF rightDispUV = currentDispUV + QPointF(dist, 0);
        QPointF leftDispUV  = currentDispUV + QPointF(-dist, 0);
        QPointF farDispUV(currentDispUV.x(),
                          getVPos(QPointF(R_z + uvOffset.z() + 1, 0), vars));
        QPointF nearDispUV(currentDispUV.x(),
                           getVPos(QPointF(R_z + uvOffset.z() - 1, 0), vars));
        float rightDispHeight =
            getMapValue(rightDispUV, disp_host, vars) * vars.displacement;
        float leftDispHeight =
            getMapValue(leftDispUV, disp_host, vars) * vars.displacement;
        float farDispHeight =
            getMapValue(farDispUV, disp_host, vars) * vars.displacement;
        float nearDispHeight =
            getMapValue(nearDispUV, disp_host, vars) * vars.displacement;
 
        rightPos += currentNormal * rightDispHeight;
        leftPos += currentNormal * leftDispHeight;
        farPos += currentNormal * farDispHeight;
        nearPos += currentNormal * nearDispHeight;
 
        // 外積で法線を求める 左手系座標なので外積を反転する
        QVector3D dispNormal =
            -QVector3D::crossProduct(rightPos - leftPos, farPos - nearPos);
        dispNormal.normalize();
 
        // height of (M) projected on the projection plane
        double vPos = getVPos(M, vars);
        QVector3D currentPos(double(i - vars.resultDim.lx / 2) / dist, M.y(),
                             M.x());
 
        // Diffuse差分取得のために、変形無しの状態の法線を取得する
        QVector3D baseNormal;
        // Specular差分取得のために、変形無しの状態の位置も取得
        QVector3D basePos;
        if (vars.differenceMode) {
          baseNormal = -QVector3D::crossProduct(
              QVector3D(2.0, rightDispHeight - leftDispHeight, 0.0),
              QVector3D(0.0, farDispHeight - nearDispHeight, 2.0));
          basePos = QVector3D(currentPos.x() + uvOffset.x() / dist, dispHeight,
                              currentPos.z() + uvOffset.z());
        }
 
        // continue if the current point is behind the forward bumps
        if (vPos <= maxVPos) {
          preVPos       = vPos;
          preDispNormal = dispNormal;
          preBaseNormal = baseNormal;
          prePos        = currentPos;
          preBasePos    = basePos;
          continue;
        }
 
        // putting colors on pixels
        int currentY       = int(std::floor(maxVPos));
        float current_frac = maxVPos - float(currentY);
        int toY            = int(std::floor(vPos));
        float to_frac      = vPos - float(toY);
        // if the entire current segment is in the same pixel,
        // then add colors with percentage of the fraction part
        if (currentY == toY) {
          float ratio = to_frac - current_frac;
          *result_p += getColor(preDispNormal, dispNormal, prePos, currentPos,
                                0.5, source_host, vars, preBaseNormal,
                                baseNormal, preBasePos, basePos) *
                       ratio;
          preVPos       = vPos;
          maxVPos       = vPos;
          preDispNormal = dispNormal;
          preBaseNormal = baseNormal;
          prePos        = currentPos;
          preBasePos    = basePos;
          continue;
        }
 
        // fill fraction part of the start pixel (currentY)
        float k =
            (maxVPos + (1.0 - current_frac) / 2.0 - preVPos) / (vPos - preVPos);
        float4 color = getColor(preDispNormal, dispNormal, prePos, currentPos,
                                k, source_host, vars, preBaseNormal, baseNormal,
                                preBasePos, basePos);
        float ratio  = 1.0 - current_frac;
        *result_p += color * ratio;
 
        if (result_p == end_p) break;
        result_p++;
 
        // fill pixels between currentY and toY
        for (int y = currentY + 1; y < toY; y++) {
          k         = (float(y) + 0.5 - preVPos) / (vPos - preVPos);
          *result_p = getColor(preDispNormal, dispNormal, prePos, currentPos, k,
                               source_host, vars, preBaseNormal, baseNormal,
                               preBasePos, basePos);
          if (result_p == end_p) break;
          result_p++;
        }
 
        // fill fraction part of the end pixel (toY)
        k     = (float(toY) + to_frac * 0.5 - preVPos) / (vPos - preVPos);
        color = getColor(preDispNormal, dispNormal, prePos, currentPos, k,
                         source_host, vars, preBaseNormal, baseNormal,
                         preBasePos, basePos);
        *result_p += color * to_frac;
 
        preVPos       = vPos;
        maxVPos       = vPos;
        preDispNormal = dispNormal;
        preBaseNormal = baseNormal;
        prePos        = currentPos;
        preBasePos    = basePos;
      }
    }
  }
}
 
//------------------------------------------------------------
// convert input tile's channel values to float4 values
//------------------------------------------------------------
 
template <typename RASTER, typename PIXEL>
void Iwa_FloorBumpFx::setSourceRaster(const RASTER srcRas, float4 *srcMem,
                                      TDimensionI dim) {
  float4 *s_p = srcMem;
  for (int j = 0; j < dim.ly; j++) {
    PIXEL *s_pix = srcRas->pixels(j);
    for (int i = 0; i < dim.lx; i++, s_pix++, s_p++) {
      (*s_p).x = (float)s_pix->r / (float)PIXEL::maxChannelValue;
      (*s_p).y = (float)s_pix->g / (float)PIXEL::maxChannelValue;
      (*s_p).z = (float)s_pix->b / (float)PIXEL::maxChannelValue;
      (*s_p).w = (float)s_pix->m / (float)PIXEL::maxChannelValue;
    }
  }
}
 
void Iwa_FloorBumpFx::setRefRaster(const TRaster64P refRas, float *refMem,
                                   TDimensionI dim, bool isRef) {
  float zeroLevel =
      (isRef) ? float(128) / float(TPixel32::maxChannelValue) : 0.0;
  float *r_p = refMem;
  for (int j = 0; j < dim.ly; j++) {
    TPixel64 *r_pix = refRas->pixels(j);
    for (int i = 0; i < dim.lx; i++, r_pix++, r_p++) {
      float r = (float)r_pix->r / (float)TPixel64::maxChannelValue;
      float g = (float)r_pix->g / (float)TPixel64::maxChannelValue;
      float b = (float)r_pix->b / (float)TPixel64::maxChannelValue;
      float m = (float)r_pix->m / (float)TPixel64::maxChannelValue;
      // taking brightness
      float brightness = 0.298912f * r + 0.586610f * g + 0.114478f * b;
      (*r_p)           = brightness * m + zeroLevel * (1.0 - m);
    }
  }
}
 
//------------------------------------
 
void Iwa_FloorBumpFx::doCompute(TTile &tile, double frame,
                                const TRenderSettings &rend_sets) {
  FloorBumpVars vars;
  vars.renderMode = m_renderMode->getValue();
  if ((isTextureUsed(vars.renderMode) && !m_texture.isConnected()) ||
      !m_heightRef.isConnected()) {
    tile.getRaster()->clear();
    return;
  }
 
  initVars(vars, tile, rend_sets, frame);
 
  // メモリの確保
  float4 *source_host = nullptr;
  float *ref_host;
  float *disp_host = nullptr;
 
  TRasterGR8P source_host_ras;
  if (isTextureUsed(vars.renderMode)) {
    source_host_ras =
        TRasterGR8P(vars.sourceDim.lx * sizeof(float4), vars.sourceDim.ly);
    source_host_ras->lock();
    source_host = (float4 *)source_host_ras->getRawData();
  }
 
  TRasterGR8P ref_host_ras(vars.refDim.lx * sizeof(float), vars.refDim.ly);
  ref_host_ras->lock();
  ref_host = (float *)ref_host_ras->getRawData();
 
  TRasterGR8P disp_host_ras;
  if (vars.displacement != 0.0 &&
      m_dispRef.isConnected()) {  // renderMode すべてに対応させるかはTBD
    disp_host_ras = TRasterGR8P(vars.refDim.lx * sizeof(float), vars.refDim.ly);
    disp_host_ras->lock();
    disp_host = (float *)disp_host_ras->getRawData();
  }
 
  // 画像の取得、格納
  {
    if (isTextureUsed(vars.renderMode)) {
      TRenderSettings source_sets(rend_sets);
      TPointD sourceTilePos =
          (tile.m_pos - TPointD(vars.margin, vars.margin)) * vars.precision;
      source_sets.m_affine *= TScale(vars.precision, vars.precision);
 
      TTile sourceTile;
      m_texture->allocateAndCompute(sourceTile, sourceTilePos, vars.sourceDim,
                                    tile.getRaster(), frame, source_sets);
 
      TRaster32P ras32 = (TRaster32P)sourceTile.getRaster();
      TRaster64P ras64 = (TRaster64P)sourceTile.getRaster();
      if (ras32)
        setSourceRaster<TRaster32P, TPixel32>(ras32, source_host,
                                              vars.sourceDim);
      else if (ras64)
        setSourceRaster<TRaster64P, TPixel64>(ras64, source_host,
                                              vars.sourceDim);
    }
    // height image is always computed in 16bpc regardless of the current render
    // settings in order to get smooth gradient
    TRenderSettings ref_sets(rend_sets);
    TPointD refTilePos = tile.m_pos - TPointD(vars.margin, vars.margin);
    ref_sets.m_bpp     = 64;
    TTile refTile;
    m_heightRef->allocateAndCompute(refTile, refTilePos, vars.refDim,
                                    TRasterP(), frame, ref_sets);
    setRefRaster((TRaster64P)refTile.getRaster(), ref_host, vars.refDim, true);
 
    // disp imageも同様
    if (disp_host) {
      TTile dispTile;
      m_dispRef->allocateAndCompute(dispTile, refTilePos, vars.refDim,
                                    TRasterP(), frame, ref_sets);
      setRefRaster((TRaster64P)dispTile.getRaster(), disp_host, vars.refDim,
                   false);
    }
  }
 
  // prepare the memory for result image
  TRasterGR8P result_host_ras(vars.resultDim.lx * sizeof(float4),
                              vars.resultDim.ly);
  float4 *result_host;
  result_host_ras->lock();
  result_host = (float4 *)result_host_ras->getRawData();
 
  // compute
  if (disp_host) {
    doCompute_with_Displacement(tile, frame, rend_sets, vars, source_host,
                                ref_host, disp_host, result_host);
  } else {
    doCompute_CPU(tile, frame, rend_sets, vars, source_host, ref_host,
                  result_host);
  }
 
  if (isTextureUsed(vars.renderMode)) source_host_ras->unlock();
  ref_host_ras->unlock();
  if (disp_host) disp_host_ras->unlock();
 
  // cancel check
  if (rend_sets.m_isCanceled && *rend_sets.m_isCanceled) {
    tile.getRaster()->clear();
    return;
  }
 
  // output the result
  TRaster32P outRas32 = (TRaster32P)tile.getRaster();
  TRaster64P outRas64 = (TRaster64P)tile.getRaster();
  if (outRas32)
    setOutputRaster<TRaster32P, TPixel32>(result_host, outRas32, vars.outDim,
                                          vars.resultDim.ly);
  else if (outRas64)
    setOutputRaster<TRaster64P, TPixel64>(result_host, outRas64, vars.outDim,
                                          vars.resultDim.ly);
 
  result_host_ras->unlock();
}
 
//------------------------------------
 
void Iwa_FloorBumpFx::getParamUIs(TParamUIConcept *&concepts, int &length) {
  concepts = new TParamUIConcept[length = 3];
 
  concepts[0].m_type  = TParamUIConcept::VERTICAL_POS;
  concepts[0].m_label = "Eye Level";
  concepts[0].m_params.push_back(m_eyeLevel);
 
  concepts[1].m_type  = TParamUIConcept::VERTICAL_POS;
  concepts[1].m_label = "Draw Level";
  concepts[1].m_params.push_back(m_drawLevel);
 
  concepts[2].m_type  = TParamUIConcept::VERTICAL_POS;
  concepts[2].m_label = "Distance Level";
  concepts[2].m_params.push_back(m_distanceLevel);
  concepts[2].m_params.push_back(m_renderMode);
}
 
//------------------------------------
 
FX_PLUGIN_IDENTIFIER(Iwa_FloorBumpFx, "iwa_FloorBumpFx")