#include "iwa_floorbumpfx.h"

#include "tparamuiconcept.h"

#include "iwa_fresnel.h"

#include <qmatrix></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);

};

QList<qpointf> getSubPointsList(int subAmount,</qpointf>

                                const Iwa_FloorBumpFx::FloorBumpVars &vars) {

  QList<qpointf> ret;</qpointf>

  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 pixel="" raster,="" typename=""></typename>

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);</qpointf>

    // 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);</qpointf>

  //-----------

  // 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);