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

// Iwa_Particle for Marnie

// based on ParticlesFx by Digital Video

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

#include "tfxparam.h"

#include "trop.h"

#include "iwa_particles.h"

#include "iwa_particlesengine.h"

#include "hsvutil.h"

#include "timage_io.h"

#include "tofflinegl.h"

/*-----------------------------------------------------------------*/

void Iwa_Particle::create_Animation(const particles_values &values, int first,

                                    int last) {

  switch (values.animation_val) {

  case Iwa_TiledParticlesFx::ANIM_CYCLE:

  case Iwa_TiledParticlesFx::ANIM_S_CYCLE:

    animswing = 0; /*frame <0 perche' c'e' il preroll dialmeno un frame*/

    break;

  case Iwa_TiledParticlesFx::ANIM_SR_CYCLE:

    animswing = random.getFloat() > 0.5 ? 1 : 0;

    break;

  }

}

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

Iwa_Particle::Iwa_Particle(

    int g_lifetime, int seed, std::map<int, *="" ttile=""> porttiles,</int,>

    const particles_values &values, const particles_ranges &ranges, int howmany,

    int first, int level, int last, float posx, float posy,

    bool isUpward,       /*- 初期向き -*/

    int initSourceFrame) /*- Level内の初期フレーム位置 -*/

{

  double random_s_a_range, random_speed;

  std::map<int, float=""> imagereferences;</int,>

  random                 = TRandom(seed);

  float randomxreference = 0.0;

  float randomyreference = 0.0;

  /*- ここで、出発時の素材フレームが決定するので、ParticleOriginに渡す -*/

  create_Animation(values, 0, last);

  frame = initSourceFrame;

  this->level = level;

  x = posx;

  y = posy;

  /*- 粒子パラメータに参照画像が使われている場合、

          参照画像のとる値を先にまとめて得ておく -*/

  for (std::map<int, *="" ttile="">::iterator it = porttiles.begin();</int,>

       it != porttiles.end(); ++it) {

    if ((values.lifetime_ctrl_val == it->first ||

         values.speed_ctrl_val == it->first ||

         values.scale_ctrl_val == it->first ||

         values.rot_ctrl_val == it->first

         /*- Speed Angleを明るさでコントロールする場合 -*/

         || (values.speeda_ctrl_val == it->first &&

             !values.speeda_use_gradient_val)) &&

        it->second->getRaster()) {

      float tmpvalue;

      get_image_reference(it->second, values, tmpvalue,

                          Iwa_TiledParticlesFx::GRAY_REF);

      imagereferences[it->first] = tmpvalue;

    }

  }

  /*- 寿命にControlが刺さっている場合は、その値に合わせて寿命を減ずる -*/

  if (values.lifetime_ctrl_val) {

    float lifetimereference = 0.0;

    lifetimereference       = imagereferences[values.lifetime_ctrl_val];

    lifetime                = g_lifetime * lifetimereference;

  } else

    lifetime = g_lifetime;

  genlifetime = lifetime;

  /*- 粒子の初期速度を得る -*/

  if (values.speed_ctrl_val &&

      (porttiles.find(values.speed_ctrl_val) != porttiles.end())) {

    float speedreference = 0.0;

    speedreference       = imagereferences[values.speed_ctrl_val];

    random_speed =

        values.speed_val.first + (ranges.speed_range) * speedreference;

  } else

    random_speed =

        values.speed_val.first + (ranges.speed_range) * random.getFloat();

  /*- 粒子の初期移動方向を得る -*/

  if (values.speeda_ctrl_val &&

      (porttiles.find(values.speeda_ctrl_val) != porttiles.end())) {

    if (values.speeda_use_gradient_val) {

      /*- 参照画像のGradientを得る関数を利用して角度を得るモード -*/

      float dir_x, dir_y;

      get_image_gravity(porttiles[values.speeda_ctrl_val], values, dir_x,

                        dir_y);

      if (dir_x == 0.0f && dir_y == 0.0f)

        random_s_a_range = values.speed_val.first;

      else

        random_s_a_range = atan2f(dir_x, -dir_y);

    } else {

      float speedareference = 0.0;

      speedareference       = imagereferences[values.speeda_ctrl_val];

      random_s_a_range =

          values.speeda_val.first + (ranges.speeda_range) * speedareference;

    }

  } else /*- Controlが無ければランダム -*/

    random_s_a_range =

        values.speeda_val.first + (ranges.speeda_range) * random.getFloat();

  /*- 移動方向から速度のX,Y成分を得る -*/

  vx = random_speed * sin(random_s_a_range);

  vy = -random_speed * cos(random_s_a_range);

  trail =

      (int)(values.trail_val.first + (ranges.trail_range) * random.getFloat());

  oldx = 0;

  oldy = 0;

  /*- 質量を指定（動きにくさ） -*/

  mass = values.mass_val.first + (ranges.mass_range) * random.getFloat();

  /*- サイズを得る -*/

  if (values.scale_ctrl_val &&

      (porttiles.find(values.scale_ctrl_val) != porttiles.end())) {

    float scalereference = 0.0f;

    scalereference       = imagereferences[values.scale_ctrl_val];

    scale = values.scale_val.first + (ranges.scale_range) * scalereference;

  } else {

    /*- ONのとき、かつ、ScaleにControlが無い場合、

            粒子サイズが小さいほど(遠くにあるので)多く分布するようになる。 -*/

    if (values.perspective_distribution_val) {

      scale =

          (values.scale_val.first * values.scale_val.second) /

          (values.scale_val.second - (ranges.scale_range) * random.getFloat());

    } else

      scale = values.scale_val.first + (ranges.scale_range) * random.getFloat();

  }

  /*- 向きを得る -*/

  if (values.rot_ctrl_val &&

      (porttiles.find(values.rot_ctrl_val) != porttiles.end())) {

    float anglereference = 0.0f;

    anglereference       = imagereferences[values.rot_ctrl_val];

    angle = -(values.rot_val.first) - (ranges.rot_range) * anglereference;

  } else

    angle = -(values.rot_val.first) - (ranges.rot_range) * random.getFloat();

  // 140212 初期粒子向き

  if (!isUpward) angle += 180.0f;

  /*- ランダムな動きのふれはば -*/

  if (values.randomx_ctrl_val)

    randomxreference = imagereferences[values.randomx_ctrl_val];

  if (values.randomy_ctrl_val)

    randomyreference = imagereferences[values.randomy_ctrl_val];

  create_Swing(values, ranges, randomxreference, randomyreference);

  create_Colors(values, ranges, porttiles);

  if (scale < 0.001f) scale = 0;

  /*- ひらひらした動き -*/

  if (values.flap_ctrl_val &&

      (porttiles.find(values.flap_ctrl_val) != porttiles.end())) {

    //*- 参照画像のGradientを得る関数を利用して角度を得る -*/

    float dir_x, dir_y;

    float norm;

    norm = get_image_gravity(porttiles[values.flap_ctrl_val], values, dir_x,

                             dir_y);

    if (dir_x == 0.0f && dir_y == 0.0f) {

      flap_theta = 0.0f;

      flap_phi   = 0.0f;

    } else {

      flap_theta = atan2f(dir_y, dir_x) * 180.0f / 3.14159f;

      flap_phi   = values.iw_flap_velocity_val * norm / mass;

    }

  } else {

    flap_theta = 0.0f;

    flap_phi   = 0.0f;

  }

  initial_x     = x;

  initial_y     = y;

  initial_angle = angle;

  initial_scale = scale;

  curlx = 0.0f;

  curly = 0.0f;

  curlz = random.getFloat();

}

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

int Iwa_Particle::check_Swing(const particles_values &values) {

  return (values.randomx_val.first || values.randomx_val.second ||

          values.randomy_val.first || values.randomy_val.second ||

          values.rotsca_val.first || values.rotsca_val.second);

}

/*-----------------------------------------------------------------*/

void Iwa_Particle::create_Swing(const particles_values &values,

                                const particles_ranges &ranges,

                                double randomxreference,

                                double randomyreference) {

  changesignx =

      (int)(values.swing_val.first + random.getFloat() * (ranges.swing_range));

  changesigny =

      (int)(values.swing_val.first + random.getFloat() * (ranges.swing_range));

  changesigna = (int)(values.rotswing_val.first +

                      random.getFloat() * (ranges.rotswing_range));

  if (values.swingmode_val == Iwa_TiledParticlesFx::SWING_SMOOTH) {

    if (values.randomx_ctrl_val)

      smswingx = abs((int)values.randomx_val.first) +

                 randomxreference * (ranges.randomx_range);

    else

      smswingx = abs((int)values.randomx_val.first) +

                 random.getFloat() * (ranges.randomx_range);

    if (values.randomy_ctrl_val)

      smswingy = abs((int)values.randomy_val.first) +

                 randomyreference * (ranges.randomy_range);

    else

      smswingy = abs((int)values.randomy_val.first) +

                 random.getFloat() * (ranges.randomy_range);

    smperiodx = changesignx;

    smperiody = changesigny;

  }

  if (values.rotswingmode_val == Iwa_TiledParticlesFx::SWING_SMOOTH) {

    smswinga  = abs((int)(values.rotsca_val.first +

                         random.getFloat() * (ranges.rotsca_range)));

    smperioda = changesigna;

  }

  signx = random.getBool() ? 1 : -1;

  signy = random.getBool() ? 1 : -1;

  signa = random.getBool() ? 1 : -1;

}

/*-----------------------------------------------------------------*/

void Iwa_Particle::create_Colors(const particles_values &values,

                                 const particles_ranges &ranges,

                                 std::map<int, *="" ttile=""> porttiles) {</int,>

  if (values.genfadecol_val) {

    TPixel32 color;

    if (values.gencol_ctrl_val &&

        (porttiles.find(values.gencol_ctrl_val) != porttiles.end()))

      get_image_reference(porttiles[values.gencol_ctrl_val], values, color);

    else

      color = values.gencol_val.getPremultipliedValue(random.getFloat());

    gencol.fadecol = values.genfadecol_val;

    if (values.gencol_spread_val) spread_color(color, values.gencol_spread_val);

    gencol.col = color;

  } else {

    gencol.col     = TPixel32::Transparent;

    gencol.fadecol = 0;

  }

  if (values.finfadecol_val) {

    TPixel32 color;

    if (values.fincol_ctrl_val &&

        (porttiles.find(values.fincol_ctrl_val) != porttiles.end()))

      get_image_reference(porttiles[values.fincol_ctrl_val], values, color);

    else

      color = values.fincol_val.getPremultipliedValue(random.getFloat());

    fincol.rangecol = (int)values.finrangecol_val;

    fincol.fadecol  = values.finfadecol_val;

    if (values.fincol_spread_val) spread_color(color, values.fincol_spread_val);

    fincol.col = color;

  } else {

    fincol.col      = TPixel32::Transparent;

    fincol.rangecol = 0;

    fincol.fadecol  = 0;

  }

  if (values.foutfadecol_val) {

    TPixel32 color;

    if (values.foutcol_ctrl_val &&

        (porttiles.find(values.foutcol_ctrl_val) != porttiles.end()))

      get_image_reference(porttiles[values.foutcol_ctrl_val], values, color);

    else

      color = values.foutcol_val.getPremultipliedValue(random.getFloat());

    ;

    foutcol.rangecol = (int)values.foutrangecol_val;

    foutcol.fadecol  = values.foutfadecol_val;

    if (values.foutcol_spread_val)

      spread_color(color, values.foutcol_spread_val);

    foutcol.col = color;

  } else {

    foutcol.col      = TPixel32::Transparent;

    foutcol.rangecol = 0;

    foutcol.fadecol  = 0;

  }

}

/*-----------------------------------------------------------------*/

/*- modify_colors_and_opacityから呼ばれる。

        lifetimeが粒子の現在の年齢。 gencol/fincol/foutcolから色を決める -*/

void Iwa_Particle::modify_colors(TPixel32 &color, double &intensity) {

  float percent = 0;

  if ((gencol.fadecol || fincol.fadecol) &&

      (genlifetime - lifetime) <= fincol.rangecol) {

    if (fincol.rangecol)

      percent = (genlifetime - lifetime) / (float)(fincol.rangecol);

    color     = blend(gencol.col, fincol.col, percent);

    intensity = gencol.fadecol + percent * (fincol.fadecol - gencol.fadecol);

  } else if (foutcol.fadecol && lifetime <= foutcol.rangecol) {

    if (foutcol.rangecol)

      percent = 1 - (lifetime - 1) / (float)(foutcol.rangecol);

    if (fincol.rangecol && fincol.fadecol) {

      color     = blend(fincol.col, foutcol.col, percent);

      intensity = fincol.fadecol + percent * (foutcol.fadecol - fincol.fadecol);

    } else {

      color     = blend(gencol.col, foutcol.col, percent);

      intensity = gencol.fadecol + percent * (foutcol.fadecol - gencol.fadecol);

    }

  } else {

    if (fincol.fadecol && fincol.rangecol) {

      color     = fincol.col;

      intensity = fincol.fadecol;

    } else {

      color     = gencol.col;

      intensity = gencol.fadecol;

    }

  }

}

/*-----------------------------------------------------------------*/

/*- do_render から呼ばれる。各粒子の描画の直前に色を決めるところ -*/

void Iwa_Particle::modify_colors_and_opacity(const particles_values &values,

                                             float curr_opacity, int dist_frame,

                                             TRaster32P raster32) {

  double intensity = 0;

  TPixel32 col;

  if (gencol.fadecol || fincol.fadecol || foutcol.fadecol) {

    modify_colors(col, intensity);

    int j;

    raster32->lock();

    for (j = 0; j < raster32->getLy(); j++) {

      TPixel32 *pix    = raster32->pixels(j);

      TPixel32 *endPix = pix + raster32->getLx();

      while (pix < endPix) {

        double factor = pix->m / 255.0;

        pix->r        = (UCHAR)(pix->r + intensity * (factor * col.r - pix->r));

        pix->g        = (UCHAR)(pix->g + intensity * (factor * col.g - pix->g));

        pix->b        = (UCHAR)(pix->b + intensity * (factor * col.b - pix->b));

        pix->m        = (UCHAR)(pix->m + intensity * (factor * col.m - pix->m));

        ++pix;

      }

    }

    raster32->unlock();

  }

  if (curr_opacity != 1.0)

    TRop::rgbmScale(raster32, raster32, 1, 1, 1, curr_opacity);

}

/*-----------------------------------------------------------------*/

void Iwa_Particle::update_Animation(const particles_values &values, int first,

                                    int last, int keep) {

  switch (values.animation_val) {

  case Iwa_TiledParticlesFx::ANIM_RANDOM:

    frame = (int)(first + random.getFloat() * (last - first));

    break;

  case Iwa_TiledParticlesFx::ANIM_R_CYCLE:

  case Iwa_TiledParticlesFx::ANIM_CYCLE:

    if (!keep || frame != keep - 1)

      frame = first + (frame + 1) % (last - first);

    break;

  case Iwa_TiledParticlesFx::ANIM_S_CYCLE:

  case Iwa_TiledParticlesFx::ANIM_SR_CYCLE:

    if (!keep || frame != keep - 1) {

      if (!animswing && frame < last - 1) {

        frame = (frame + 1);

        if (frame == last - 1) animswing = 1;

      } else

        frame = (frame - 1);

      if (frame <= first) {

        animswing = 0;

        frame     = first;

      }

    }

    break;

  }

}

/*-----------------------------------------------------------------*/

void Iwa_Particle::update_Swing(const particles_values &values,

                                const particles_ranges &ranges,

                                struct pos_dummy &dummy,

                                double randomxreference,

                                double randomyreference) {

  if (values.swingmode_val == Iwa_TiledParticlesFx::SWING_SMOOTH) {

    if (smperiodx)

      dummy.x =

          smswingx * randomxreference * sin((M_PI * changesignx) / smperiodx);

    else

      dummy.x = 0;

    if (smperiody)

      dummy.y =

          smswingy * randomyreference * sin((M_PI * changesigny) / smperiody);

    else

      dummy.y = 0;

  } else {

    if (values.randomx_ctrl_val)

      dummy.x = (values.randomx_val.first +

                 (ranges.randomx_range) * randomxreference);

    else

      dummy.x = (values.randomx_val.first +

                 (ranges.randomx_range) * random.getFloat());

    if (values.randomy_ctrl_val)

      dummy.y = (values.randomy_val.first +

                 (ranges.randomy_range) * randomyreference);

    else

      dummy.y = (values.randomy_val.first +

                 (ranges.randomy_range) * random.getFloat());

  }

  if (values.rotswingmode_val == Iwa_TiledParticlesFx::SWING_SMOOTH) {

    if (smperioda)

      dummy.a = smswinga * sin((M_PI * changesigna) / smperioda);

    else

      dummy.a = 0;

  } else

    dummy.a =

        (values.rotsca_val.first + (ranges.rotsca_range) * random.getFloat());

  if (!(genlifetime - lifetime)) {

    signx = dummy.x > 0 ? 1 : -1;

    signy = dummy.y > 0 ? 1 : -1;

    signa = dummy.a > 0 ? 1 : -1;

  } else {

    dummy.x = (fabs(dummy.x)) * signx;

    dummy.y = (fabs(dummy.y)) * signy;

    dummy.a = (fabs(dummy.a)) * signa;

  }

  changesignx--;

  changesigny--;

  changesigna--;

  if (changesignx <= 0) {

    //  if(random->getFloat()<0.5);

    signx *= -1;

    changesignx = abs((int)(values.swing_val.first) +

                      (int)(random.getFloat() * (ranges.swing_range)));

    if (values.swingmode_val == Iwa_TiledParticlesFx::SWING_SMOOTH) {

      smperiodx = changesignx;

      if (values.randomx_ctrl_val)

        smswingx = values.randomx_val.first +

                   randomxreference * (ranges.randomx_range);

      else

        smswingx = values.randomx_val.first +

                   random.getFloat() * (ranges.randomx_range);

    }

  }

  if (changesigny <= 0) {

    //  if(random->getFloat()<0.5);

    signy *= -1;

    changesigny = abs((int)(values.swing_val.first) +

                      (int)(random.getFloat() * (ranges.swing_range)));

    if (values.swingmode_val == Iwa_TiledParticlesFx::SWING_SMOOTH) {

      smperiody = changesigny;

      if (values.randomy_ctrl_val)

        smswingy = values.randomy_val.first +

                   randomyreference * (ranges.randomy_range);

      else

        smswingy = values.randomy_val.first +

                   random.getFloat() * (ranges.randomy_range);

    }

  }

  if (changesigna <= 0) {

    signa *= -1;

    changesigna = abs((int)(values.rotswing_val.first) +

                      (int)(random.getFloat() * (ranges.rotswing_range)));

    if (values.rotswingmode_val == Iwa_TiledParticlesFx::SWING_SMOOTH) {

      smperioda = changesigna;

      smswinga =

          values.rotsca_val.first + random.getFloat() * (ranges.rotsca_range);

    }

  }

}

/*-----------------------------------------------------------------*/

void Iwa_Particle::update_Scale(const particles_values &values,

                                const particles_ranges &ranges,

                                double scalereference,

                                double scalestepreference) {

  double scalestep;

  if (values.scale_ctrl_val && values.scale_ctrl_all_val)

    scale = values.scale_val.first + (ranges.scale_range) * scalereference;

  else {

    if (values.scalestep_ctrl_val)

      scalestep = values.scalestep_val.first +

                  (ranges.scalestep_range) * scalestepreference;

    else

      scalestep = values.scalestep_val.first +

                  (ranges.scalestep_range) * random.getFloat();

    if (scalestep) scale += scalestep;

  }

  if (scale < 0.001) scale = 0;

}

/*-----------------------------------------------------------------*/

void Iwa_Particle::get_image_reference(TTile *ctrl,

                                       const particles_values &values,

                                       float &imagereference, int type) {

  TRaster32P raster32 = ctrl->getRaster();

  TRaster64P raster64 = ctrl->getRaster();

  TPointD tmp(x, y);

  tmp -= ctrl->m_pos;

  imagereference = 0.0;

  if (raster32)

    raster32->lock();

  else if (raster64)

    raster64->lock();

  switch (type) {

  case Iwa_TiledParticlesFx::GRAY_REF:

    if (raster32 && tmp.x >= 0 && tmp.x < raster32->getLx() && tmp.y >= 0 &&

        troundp(tmp.y) < raster32->getLy()) {

      TPixel32 pix = raster32->pixels(troundp(tmp.y))[(int)tmp.x];

      imagereference =

          TPixelGR8::from(pix).value / (float)TPixelGR8::maxChannelValue;

    } else if (raster64 && tmp.x >= 0 && tmp.x < raster64->getLx() &&

               tmp.y >= 0 && troundp(tmp.y) < raster64->getLy()) {

      TPixel64 pix = raster64->pixels(troundp(tmp.y))[(int)tmp.x];

      imagereference =

          TPixelGR16::from(pix).value / (float)TPixelGR16::maxChannelValue;

    }

    break;

  case Iwa_TiledParticlesFx::H_REF:

    if (raster32 && tmp.x >= 0 && tmp.x < raster32->getLx() && tmp.y >= 0 &&

        tround(tmp.y) < raster32->getLy()) {

      float aux = (float)TPixel32::maxChannelValue;

      double h, s, v;

      TPixel32 pix = raster32->pixels(troundp(tmp.y))[(int)tmp.x];

      OLDRGB2HSV(pix.r / aux, pix.g / aux, pix.b / aux, &h, &s, &v);

      imagereference = (float)h / 360.0f;

    } else if (raster64 && tmp.x >= 0 && tmp.x < raster64->getLx() &&

               tmp.y >= 0 && tround(tmp.y) < raster64->getLy()) {

      float aux = (float)TPixel64::maxChannelValue;

      double h, s, v;

      TPixel64 pix = raster64->pixels(troundp(tmp.y))[(int)tmp.x];

      OLDRGB2HSV(pix.r / aux, pix.g / aux, pix.b / aux, &h, &s, &v);

      imagereference = (float)h / 360.0f;

    }

    break;

  }

  if (raster32)

    raster32->unlock();

  else if (raster64)

    raster64->unlock();

}

/*-----------------------------------------------------------------*/

/*- ベクタ長を返す -*/

float Iwa_Particle::get_image_gravity(TTile *ctrl1,

                                      const particles_values &values, float &gx,

                                      float &gy) {

  TRaster32P raster32 = ctrl1->getRaster();

  TRaster64P raster64 = ctrl1->getRaster();

  TPointD tmp(x, y);

  tmp -= ctrl1->m_pos;

  int radius = 2;

  gx         = 0;

  gy         = 0;

  float norm = 1.0f;

  if (raster32) {

    raster32->lock();

    if (raster32 && tmp.x >= radius && tmp.x < raster32->getLx() - radius &&

        tmp.y >= radius && tmp.y < raster32->getLy() - radius) {

      TPixel32 *pix = &(raster32->pixels(troundp(tmp.y))[(int)tmp.x]);

      gx += 2 * TPixelGR8::from(*(pix + 1)).value;

      gx += TPixelGR8::from(*(pix + 1 + raster32->getWrap() * 1)).value;

      gx += TPixelGR8::from(*(pix + 1 - raster32->getWrap() * 1)).value;

      gx -= 2 * TPixelGR8::from(*(pix - 1)).value;

      gx -= TPixelGR8::from(*(pix - 1 + raster32->getWrap() * 1)).value;

      gx -= TPixelGR8::from(*(pix - 1 - raster32->getWrap() * 1)).value;

      gy += 2 * TPixelGR8::from(*(pix + raster32->getWrap() * 1)).value;

      gy += TPixelGR8::from(*(pix + raster32->getWrap() * 1 + 1)).value;

      gy += TPixelGR8::from(*(pix + raster32->getWrap() * 1 - 1)).value;

      gy -= 2 * TPixelGR8::from(*(pix - raster32->getWrap() * 1)).value;

      gy -= TPixelGR8::from(*(pix - raster32->getWrap() * 1 + 1)).value;

      gy -= TPixelGR8::from(*(pix - raster32->getWrap() * 1 - 1)).value;

      norm = sqrtf(gx * gx + gy * gy);

      if (norm) {

        float inorm = 0.1f / norm;

        gx          = gx * inorm;

        gy          = gy * inorm;

      }

    }

    raster32->unlock();

    norm /= (float)(TPixelGR8::maxChannelValue);

  } else if (raster64) {

    raster64->lock();

    if (raster64 && tmp.x >= radius && tmp.x < raster64->getLx() - radius &&

        tmp.y >= radius && tmp.y < raster64->getLy() - radius) {

      TPixel64 *pix = &(raster64->pixels(troundp(tmp.y))[(int)tmp.x]);

      gx += 2 * TPixelGR16::from(*(pix + 1)).value;

      gx += TPixelGR16::from(*(pix + 1 + raster64->getWrap() * 1)).value;

      gx += TPixelGR16::from(*(pix + 1 - raster64->getWrap() * 1)).value;

      gx -= 2 * TPixelGR16::from(*(pix - 1)).value;

      gx -= TPixelGR16::from(*(pix - 1 + raster64->getWrap() * 1)).value;

      gx -= TPixelGR16::from(*(pix - 1 - raster64->getWrap() * 1)).value;

      gy += 2 * TPixelGR16::from(*(pix + raster64->getWrap() * 1)).value;

      gy += TPixelGR16::from(*(pix + raster64->getWrap() * 1 + 1)).value;

      gy += TPixelGR16::from(*(pix + raster64->getWrap() * 1 - 1)).value;

      gy -= 2 * TPixelGR16::from(*(pix - raster64->getWrap() * 1)).value;

      gy -= TPixelGR16::from(*(pix - raster64->getWrap() * 1 + 1)).value;

      gy -= TPixelGR16::from(*(pix - raster64->getWrap() * 1 - 1)).value;

      norm = sqrtf(gx * gx + gy * gy);

      if (norm) {

        float inorm = 0.1 / norm;

        gx          = gx * inorm;

        gy          = gy * inorm;

      }

    }

    raster64->unlock();

    norm /= (float)(TPixelGR16::maxChannelValue);

  }

  return norm;

}

/*-----------------------------------------------------------------*/

bool Iwa_Particle::get_image_curl(TTile *ctrl1, const particles_values &values,

                                  float &cx, float &cy) {

  TRaster32P raster32 = ctrl1->getRaster();

  TRaster64P raster64 = ctrl1->getRaster();

  TPointD tmp(x, y);

  tmp -= ctrl1->m_pos;

  int radius = 4;

  cx         = 0;

  cy         = 0;

  bool ret;

  if (raster32) {

    raster32->lock();

    if (raster32 && tmp.x >= radius + 1 &&

        tmp.x < raster32->getLx() - radius - 1 && tmp.y >= radius + 1 &&

        tmp.y < raster32->getLy() - radius - 1) {

      TPixel32 *pix = &(raster32->pixels(troundp(tmp.y))[(int)tmp.x]);

      cx = -TPixelGR8::from(*(pix + radius * raster32->getWrap())).value +

           TPixelGR8::from(*(pix - radius * raster32->getWrap())).value;

      cy = TPixelGR8::from(*(pix + radius)).value -

           TPixelGR8::from(*(pix - radius)).value;

      ret = true;

    } else

      ret = false;

    raster32->unlock();

  } else if (raster64) {

    raster64->lock();

    if (raster64 && tmp.x >= radius + 1 &&

        tmp.x < raster64->getLx() - radius - 1 && tmp.y >= radius + 1 &&

        tmp.y < raster64->getLy() - radius - 1) {

      TPixel64 *pix = &(raster64->pixels(troundp(tmp.y))[(int)tmp.x]);

      cx = -TPixelGR16::from(*(pix + radius * raster64->getWrap())).value +

           TPixelGR16::from(*(pix - radius * raster64->getWrap())).value;

      cy = TPixelGR16::from(*(pix + radius)).value -

           TPixelGR16::from(*(pix - radius)).value;

      cx /= 256.0f;

      cy /= 256.0f;

      ret = true;

    } else

      ret = false;

    raster64->unlock();

  }

  return ret;

}

/*-----------------------------------------------------------------*/

void Iwa_Particle::get_image_reference(TTile *ctrl1,

                                       const particles_values &values,

                                       TPixel32 &color) {

  TRaster32P raster32 = ctrl1->getRaster();

  TRaster64P raster64 = ctrl1->getRaster();

  TPointD tmp(x, y);

  tmp -= ctrl1->m_pos;

  if (raster32 && tmp.x >= 0 && tmp.x < raster32->getLx() && tmp.y >= 0 &&

      troundp(tmp.y) < raster32->getLy()) {

    color = raster32->pixels(troundp(tmp.y))[(int)tmp.x];

  } else if (raster64 && tmp.x >= 0 && tmp.x < raster64->getLx() &&

             tmp.y >= 0 && troundp(tmp.y) < raster64->getLy()) {

    TPixel64 pix64 = raster64->pixels(troundp(tmp.y))[(int)tmp.x];

    color = TPixel32((int)pix64.r / 256, (int)pix64.g / 256, (int)pix64.b / 256,

                     (int)pix64.m / 256);

  }

  /*- 参照画像のBBoxの外側で、粒子の色を透明にする -*/

  else

    color = TPixel32::Transparent;

}

/*-----------------------------------------------------------------*/

void Iwa_Particle::get_base_image_texture(TTile *ctrl1,

                                          const particles_values &values,

                                          TRasterP texRaster,

                                          const TRectD &texBBox,

                                          const TRenderSettings &ri) {

  /*- ベースの絵を粒子の初期位置にあわせ移動させる -*/

  TPointD pos(initial_x, initial_y);

  pos = ri.m_affine * pos;

  TRotation rotM(-initial_angle);

  TScale scaleM(1.0);

  TAffine M = TTranslation(-texBBox.getP00()) * scaleM * rotM *

              TTranslation(-pos + ctrl1->m_pos);

  TRaster32P baseRas32 = ctrl1->getRaster();

  TRaster64P baseRas64 = ctrl1->getRaster();

  if (baseRas32) {

    baseRas32->lock();

    /*- 粒子と同サイズのラスタを用意 -*/

    TRaster32P kirinukiBaseRas(texRaster->getSize());

    kirinukiBaseRas->lock();

    TRaster32P texRas32 = texRaster;

    texRas32->lock();

    /*- そこにquickput -*/

    TRop::quickPut(kirinukiBaseRas, baseRas32, M);

    /*- 粒子のRGBをベース絵で置換していく -*/

    for (int j = 0; j < texRaster->getLy(); j++) {

      TPixel32 *pix     = texRas32->pixels(j);

      TPixel32 *endPix  = pix + texRas32->getLx();

      TPixel32 *basePix = kirinukiBaseRas->pixels(j);

      while (pix < endPix) {

        double factor = pix->m / 255.0;

        pix->r        = (UCHAR)(factor * basePix->r);

        pix->g        = (UCHAR)(factor * basePix->g);

        pix->b        = (UCHAR)(factor * basePix->b);

        pix->m        = (UCHAR)(factor * basePix->m);

        ++pix;

        ++basePix;

      }

    }

    kirinukiBaseRas->unlock();

    baseRas32->unlock();

    texRas32->unlock();

  } else if (baseRas64) {

    baseRas64->lock();

    /*- 粒子と同サイズのラスタを用意 -*/

    TRaster64P kirinukiBaseRas(texRaster->getSize());

    kirinukiBaseRas->lock();

    TRaster64P texRas64 = texRaster;

    texRas64->lock();

    /*- そこにquickput -*/

    TRop::quickPut(kirinukiBaseRas, baseRas64, M);

    /*- 粒子のRGBをベース絵で置換していく -*/

    for (int j = 0; j < texRaster->getLy(); j++) {

      TPixel64 *pix     = texRas64->pixels(j);

      TPixel64 *endPix  = pix + texRas64->getLx();

      TPixel64 *basePix = kirinukiBaseRas->pixels(j);

      while (pix < endPix) {

        double factor = (double)pix->m / (double)TPixel64::maxChannelValue;

        pix->r        = (TPixel64::Channel)(factor * basePix->r);

        pix->g        = (TPixel64::Channel)(factor * basePix->g);

        pix->b        = (TPixel64::Channel)(factor * basePix->b);

        pix->m        = (TPixel64::Channel)(factor * basePix->m);

        ++pix;

        ++basePix;

      }

    }

    kirinukiBaseRas->unlock();

    baseRas64->unlock();

    texRas64->unlock();

  }

}

/*-----------------------------------------------------------------*/

void Iwa_Particle::get_base_image_color(TTile *ctrl1,

                                        const particles_values &values,

                                        TRasterP texRaster,

                                        const TRectD &texBBox,

                                        const TRenderSettings &ri) {

  /*- まず、色を拾う -*/

  TPixel32 color;

  TRaster32P baseRas32 = ctrl1->getRaster();

  TRaster64P baseRas64 = ctrl1->getRaster();

  TPointD tmp(initial_x, initial_y);

  tmp = ri.m_affine * tmp;

  tmp -= ctrl1->m_pos;

  if (baseRas32 && tmp.x >= 0 && tmp.x < baseRas32->getLx() && tmp.y >= 0 &&

      troundp(tmp.y) < baseRas32->getLy()) {

    color = baseRas32->pixels(troundp(tmp.y))[(int)tmp.x];

  } else if (baseRas64 && tmp.x >= 0 && tmp.x < baseRas64->getLx() &&

             tmp.y >= 0 && troundp(tmp.y) < baseRas64->getLy()) {

    TPixel64 pix64 = baseRas64->pixels(troundp(tmp.y))[(int)tmp.x];

    color = TPixel32((int)pix64.r / 256, (int)pix64.g / 256, (int)pix64.b / 256,

                     (int)pix64.m / 256);

  } else

    color = TPixel32::Transparent;

  TRaster32P texRas32 = texRaster;

  TRaster64P texRas64 = texRaster;

  if (texRas32) {

    texRas32->lock();

    for (int j = 0; j < texRas32->getLy(); j++) {

      TPixel32 *pix    = texRas32->pixels(j);

      TPixel32 *endPix = pix + texRas32->getLx();

      while (pix < endPix) {

        double factor = pix->m / (double)TPixel32::maxChannelValue;

        pix->r        = (UCHAR)(factor * color.r);

        pix->g        = (UCHAR)(factor * color.g);

        pix->b        = (UCHAR)(factor * color.b);

        pix->m        = (UCHAR)(factor * color.m);

        ++pix;

      }

    }

    texRas32->unlock();

  } else if (texRas64) {

    texRas64->lock();

    TPixel64 color64(color.r * 256, color.g * 256, color.b * 256,

                     color.m * 256);

    for (int j = 0; j < texRas64->getLy(); j++) {

      TPixel64 *pix    = texRas64->pixels(j);

      TPixel64 *endPix = pix + texRas64->getLx();

      while (pix < endPix) {

        double factor = pix->m / (double)TPixel64::maxChannelValue;

        pix->r        = (USHORT)(factor * color64.r);

        pix->g        = (USHORT)(factor * color64.g);

        pix->b        = (USHORT)(factor * color64.b);

        pix->m        = (USHORT)(factor * color64.m);

        ++pix;

      }

    }

    texRas64->unlock();

  }

}

/*-----------------------------------------------------------------*/

/*- 照明モードのとき、その明るさを色に格納 -*/

void Iwa_Particle::set_illuminated_colors(float illuminant,

                                          TRasterP texRaster) {

  TRaster32P texRas32 = texRaster;

  TRaster64P texRas64 = texRaster;

  if (texRas32) {

    texRas32->lock();

    TPixel32::Channel val =

        (TPixel32::Channel)(illuminant * TPixel32::maxChannelValue);

    for (int j = 0; j < texRas32->getLy(); j++) {