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

// Iwa_Particles_Engine for Marnie

// based on Particles_Engine by Digital Video

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

#include "trop.h"

#include "tfxparam.h"

#include "tofflinegl.h"

#include "tstopwatch.h"

#include "tsystem.h"

#include "timagecache.h"

#include "tconvert.h"

#include "tflash.h"

#include "trasterimage.h"

#include "timage_io.h"

#include "tcolorfunctions.h"

#include "toonz/tcolumnfx.h"

#include "iwa_particlesmanager.h"

#include "iwa_particlesengine.h"

#include "trenderer.h"

#include <qmutex></qmutex>

#include <qmutexlocker></qmutexlocker>

namespace

{

QMutex mutex;

void printTime(TStopWatch &sw, string name)

{

	ostrstream ss;

	ss << name << " : ";

	sw.print(ss);

	ss << '\n' << '\0';

	TSystem::outputDebug(ss.str());

}

};

//----

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

Iwa_Particles_Engine::Iwa_Particles_Engine(Iwa_TiledParticlesFx *parent, double frame)

	: m_parent(parent), m_frame(frame)

{

}

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

void Iwa_Particles_Engine::fill_value_struct(struct particles_values &myvalues, double frame)

{

	myvalues.source_ctrl_val = m_parent->source_ctrl_val->getValue();

	myvalues.bright_thres_val = m_parent->bright_thres_val->getValue();

	myvalues.x_pos_val = m_parent->center_val->getValue(frame).x;

	myvalues.y_pos_val = m_parent->center_val->getValue(frame).y;

	myvalues.length_val = m_parent->length_val->getValue(frame);

	myvalues.height_val = m_parent->height_val->getValue(frame);

	myvalues.maxnum_val = m_parent->maxnum_val->getValue(frame);

	myvalues.lifetime_val = m_parent->lifetime_val->getValue(frame);

	myvalues.lifetime_ctrl_val = m_parent->lifetime_ctrl_val->getValue();

	myvalues.column_lifetime_val = m_parent->column_lifetime_val->getValue();

	myvalues.startpos_val = m_parent->startpos_val->getValue();

	myvalues.randseed_val = m_parent->randseed_val->getValue();

	myvalues.gravity_val = m_parent->gravity_val->getValue(frame);

	myvalues.g_angle_val = m_parent->g_angle_val->getValue(frame);

	myvalues.gravity_ctrl_val = m_parent->gravity_ctrl_val->getValue();

	myvalues.friction_val = m_parent->friction_val->getValue(frame);

	myvalues.friction_ctrl_val = m_parent->friction_ctrl_val->getValue();

	myvalues.windint_val = m_parent->windint_val->getValue(frame);

	myvalues.windangle_val = m_parent->windangle_val->getValue(frame);

	myvalues.swingmode_val = m_parent->swingmode_val->getValue();

	myvalues.randomx_val = m_parent->randomx_val->getValue(frame);

	myvalues.randomy_val = m_parent->randomy_val->getValue(frame);

	myvalues.randomx_ctrl_val = m_parent->randomx_ctrl_val->getValue();

	myvalues.randomy_ctrl_val = m_parent->randomy_ctrl_val->getValue();

	myvalues.swing_val = m_parent->swing_val->getValue(frame);

	myvalues.speed_val = m_parent->speed_val->getValue(frame);

	myvalues.speed_ctrl_val = m_parent->speed_ctrl_val->getValue();

	myvalues.speeda_val = m_parent->speeda_val->getValue(frame);

	myvalues.speeda_ctrl_val = m_parent->speeda_ctrl_val->getValue();

	myvalues.speeda_use_gradient_val = m_parent->speeda_use_gradient_val->getValue();

	myvalues.speedscale_val = m_parent->speedscale_val->getValue();

	myvalues.toplayer_val = m_parent->toplayer_val->getValue();

	myvalues.mass_val = m_parent->mass_val->getValue(frame);

	myvalues.scale_val = m_parent->scale_val->getValue(frame);

	myvalues.scale_ctrl_val = m_parent->scale_ctrl_val->getValue();

	myvalues.scale_ctrl_all_val = m_parent->scale_ctrl_all_val->getValue();

	myvalues.rot_val = m_parent->rot_val->getValue(frame);

	myvalues.rot_ctrl_val = m_parent->rot_ctrl_val->getValue();

	myvalues.trail_val = m_parent->trail_val->getValue(frame);

	myvalues.trailstep_val = m_parent->trailstep_val->getValue(frame);

	myvalues.rotswingmode_val = m_parent->rotswingmode_val->getValue();

	myvalues.rotspeed_val = m_parent->rotspeed_val->getValue(frame);

	myvalues.rotsca_val = m_parent->rotsca_val->getValue(frame);

	myvalues.rotswing_val = m_parent->rotswing_val->getValue(frame);

	myvalues.pathaim_val = m_parent->pathaim_val->getValue();

	myvalues.opacity_val = m_parent->opacity_val->getValue(frame);

	myvalues.opacity_ctrl_val = m_parent->opacity_ctrl_val->getValue();

	myvalues.trailopacity_val = m_parent->trailopacity_val->getValue(frame);

	myvalues.scalestep_val = m_parent->scalestep_val->getValue(frame);

	myvalues.scalestep_ctrl_val = m_parent->scalestep_ctrl_val->getValue();

	myvalues.fadein_val = m_parent->fadein_val->getValue(frame);

	myvalues.fadeout_val = m_parent->fadeout_val->getValue(frame);

	myvalues.animation_val = m_parent->animation_val->getValue();

	myvalues.step_val = m_parent->step_val->getValue();

	myvalues.gencol_val = m_parent->gencol_val->getValue(frame);

	myvalues.gencol_ctrl_val = m_parent->gencol_ctrl_val->getValue();

	myvalues.gencol_spread_val = m_parent->gencol_spread_val->getValue(frame);

	myvalues.genfadecol_val = m_parent->genfadecol_val->getValue(frame);

	myvalues.fincol_val = m_parent->fincol_val->getValue(frame);

	myvalues.fincol_ctrl_val = m_parent->fincol_ctrl_val->getValue();

	myvalues.fincol_spread_val = m_parent->fincol_spread_val->getValue(frame);

	myvalues.finrangecol_val = m_parent->finrangecol_val->getValue(frame);

	myvalues.finfadecol_val = m_parent->finfadecol_val->getValue(frame);

	myvalues.foutcol_val = m_parent->foutcol_val->getValue(frame);

	myvalues.foutcol_ctrl_val = m_parent->foutcol_ctrl_val->getValue();

	myvalues.foutcol_spread_val = m_parent->foutcol_spread_val->getValue(frame);

	myvalues.foutrangecol_val = m_parent->foutrangecol_val->getValue(frame);

	myvalues.foutfadecol_val = m_parent->foutfadecol_val->getValue(frame);

	myvalues.source_gradation_val = m_parent->source_gradation_val->getValue();

	myvalues.pick_color_for_every_frame_val = m_parent->pick_color_for_every_frame_val->getValue();

	/*- 計算モード （背景＋粒子／粒子／背景／照明された粒子） -*/

	myvalues.iw_rendermode_val = m_parent->iw_rendermode_val->getValue();

	/*- 粒子に貼られる絵の素材 -*/

	myvalues.base_ctrl_val = m_parent->base_ctrl_val->getValue();

	/*- カールノイズ的な動きを与える -*/

	myvalues.curl_val = m_parent->curl_val->getValue(frame);

	myvalues.curl_ctrl_1_val = m_parent->curl_ctrl_1_val->getValue();

	myvalues.curl_ctrl_2_val = m_parent->curl_ctrl_2_val->getValue();

	/*- 粒子敷き詰め。粒子を正三角形で敷き詰めたときの、

		正三角形の一辺の長さをインチで指定する -*/

	myvalues.iw_triangleSize = m_parent->iw_triangleSize->getValue(frame);

	/*- ひらひら回転 -*/

	myvalues.flap_ctrl_val = m_parent->flap_ctrl_val->getValue();

	myvalues.iw_flap_velocity_val = m_parent->iw_flap_velocity_val->getValue(frame);

	myvalues.iw_flap_dir_sensitivity_val = m_parent->iw_flap_dir_sensitivity_val->getValue(frame);

	/*- ひらひら粒子に照明を当てる normalize_values()内で Degree → Radian 化する -*/

	myvalues.iw_light_theta_val = m_parent->iw_light_theta_val->getValue(frame);

	myvalues.iw_light_phi_val = m_parent->iw_light_phi_val->getValue(frame);

	/*- 読み込みマージン -*/

	myvalues.margin_val = m_parent->margin_val->getValue(frame);

	/*- 重力を徐々に与えるためのフレーム長 -*/

	myvalues.iw_gravityBufferFrame_val = m_parent->iw_gravityBufferFrame_val->getValue();

}

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

void Iwa_Particles_Engine::fill_range_struct(struct particles_values &values,

											 struct particles_ranges &ranges)

{

	ranges.swing_range = values.swing_val.second - values.swing_val.first;

	ranges.rotswing_range = values.rotswing_val.second - values.rotswing_val.first;

	ranges.randomx_range = values.randomx_val.second - values.randomx_val.first;

	ranges.randomy_range = values.randomy_val.second - values.randomy_val.first;

	ranges.rotsca_range = values.rotsca_val.second - values.rotsca_val.first;

	ranges.rot_range = values.rot_val.second - values.rot_val.first;

	ranges.speed_range = values.speed_val.second - values.speed_val.first;

	ranges.speeda_range = values.speeda_val.second - values.speeda_val.first;

	ranges.mass_range = values.mass_val.second - values.mass_val.first;

	ranges.scale_range = values.scale_val.second - values.scale_val.first;

	ranges.lifetime_range = values.lifetime_val.second - values.lifetime_val.first;

	ranges.scalestep_range = values.scalestep_val.second - values.scalestep_val.first;

	ranges.trail_range = (int)(values.trail_val.second - values.trail_val.first);

}

bool Iwa_Particles_Engine::port_is_used(int i, struct particles_values &values)

{

	return values.fincol_ctrl_val == i ||

		   values.foutcol_ctrl_val == i ||

		   values.friction_ctrl_val == i ||

		   values.gencol_ctrl_val == i ||

		   values.gravity_ctrl_val == i ||

		   values.opacity_ctrl_val == i ||

		   values.rot_ctrl_val == i ||

		   values.scale_ctrl_val == i ||

		   values.scalestep_ctrl_val == i ||

		   values.source_ctrl_val == i ||

		   values.speed_ctrl_val == i ||

		   values.speeda_ctrl_val == i ||

		   values.lifetime_ctrl_val == i ||

		   values.randomx_ctrl_val == i ||

		   values.randomy_ctrl_val == i ||

		   values.base_ctrl_val == i ||

		   values.curl_ctrl_1_val == i ||

		   values.curl_ctrl_2_val == i ||

		   values.flap_ctrl_val == i;

}

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

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

/*-  Startフレームからカレントフレームまで順番に回す関数 生成もここで -*/

void Iwa_Particles_Engine::roll_particles(TTile *tile,							/*-結果を格納するTile-*/

										  std::map<int, *="" ttile=""> porttiles,		/*-コントロール画像のポート番号／タイル-*/</int,>

										  const TRenderSettings &ri,			/*-現在のフレームの計算用RenderSettings-*/

										  std::list<iwa_particle> &myParticles, /*-パーティクルのリスト-*/</iwa_particle>

										  struct particles_values &values,		/*-現在のフレームでのパラメータ-*/

										  float cx,								/*- 0 で入ってくる-*/

										  float cy,								/*- 0 で入ってくる-*/

										  int frame,							/*-現在のフレーム値（forで回す値）-*/

										  int curr_frame,						/*-カレントフレーム-*/

										  int level_n,							/*-テクスチャ素材画像の数-*/

										  bool *random_level,					/*-ループの最初にfalseで入ってくる-*/

										  float dpi,							/*- 1 で入ってくる-*/

										  vector<int> lastframe,				/*-テクスチャ素材のそれぞれのカラム長-*/</int>

										  int &totalparticles,

										  QList<particleorigin> &particleOrigins,</particleorigin>

										  int genPartNum /*- 実際に生成したい粒子数 -*/

										  )

{

	particles_ranges ranges;

	int i;

	float xgravity, ygravity, windx, windy;

	/*- 風の強さ／重力の強さをX,Y成分に分ける -*/

	windx = values.windint_val * sin(values.windangle_val);

	windy = values.windint_val * cos(values.windangle_val);

	xgravity = values.gravity_val * sin(values.g_angle_val);

	ygravity = values.gravity_val * cos(values.g_angle_val);

	fill_range_struct(values, ranges);

	vector<tpointd> myregions;</tpointd>

	QList<qlist<int>> myHistogram;</qlist<int>

	std::map<int, *="" ttile="">::iterator it = porttiles.find(values.source_ctrl_val);</int,>

	/*- ソース画像にコントロールが付いていた場合 -*/

	if (values.source_ctrl_val && (it != porttiles.end()) && it->second->getRaster())

		/*- 入力画像のアルファ値に比例して発生濃度を変える -*/

		fill_single_region(myregions,

						   it->second,

						   values.bright_thres_val,

						   values.source_gradation_val,

						   myHistogram,

						   particleOrigins);

	/*- 粒子が出きったらもう出さない -*/

	int actualBirthParticles = tmin(genPartNum, particleOrigins.size());

	/*- 出発する粒子のインデックス -*/

	QList<int> leavingPartIndex;</int>

	if (myregions.size() && values.source_ctrl_val != Iwa_TiledParticlesFx::CTRL_NONE) {

		int partLeft = actualBirthParticles;

		while (partLeft > 0) {

			int PrePartLeft = partLeft;

			int potential_sum = 0;

			QList<int> myWeight;</int>

			/*- 各濃度のポテンシャルの大きさmyWeightと、合計ポテンシャルを計算 -*/

			for (int m = 0; m < 256; m++) {

				int pot = myHistogram[m].size() * m;

				myWeight.append(pot);

				potential_sum += pot;

			}

			/*- 各濃度について(濃い方から) -*/

			for (int m = 255; m > 0; m--) {

				/*- 割り当てを計算（切り上げ） -*/

				int wariate = tceil((float)(myWeight[m]) * (float)(partLeft) / (float)potential_sum);

				/*- 実際にこのポテンシャルから出発する粒子数 -*/

				int leaveNum = std::min(myHistogram.at(m).size(), wariate);

				/*- 割り当てられた粒子を頭から登録 -*/

				for (int lp = 0; lp < leaveNum; lp++) {

					/*- Histogramから減らしながら追加 -*/

					leavingPartIndex.append(myHistogram[m].takeFirst());

					/*- 残数を減らす -*/

					partLeft--;

					if (partLeft == 0)

						break;

				}

				if (partLeft == 0)

					break;

			}

			/*- ひとつも出発出来なければbreak -*/

			if (partLeft == PrePartLeft)

				break;

		}

		/*- 実際に飛び出せた粒子数 -*/

		actualBirthParticles = leavingPartIndex.size();

	} else /*- 何も刺さっていなければ、ランダムに発生させる -*/

	{

		for (int i = 0; i < actualBirthParticles; i++)

			leavingPartIndex.append(i);

	}

	/*- 動かす粒子も生まれる粒子も無い -*/

	if (myParticles.empty() && actualBirthParticles == 0) {

		std::cout << "no particles generated nor alive. returning function" << std::endl;

		return;

	}

	/*- 背景だけを描画するモードのときは、particlesOriginを更新するだけでOK -*/

	if (values.iw_rendermode_val == Iwa_TiledParticlesFx::REND_BG) {

		/*- インデックスを小さい順にならべる -*/

		qSort(leavingPartIndex.begin(), leavingPartIndex.end());

		/*- インデックス大きい方から消していく -*/

		for (int lp = leavingPartIndex.size() - 1; lp >= 0; lp--)

			particleOrigins.removeAt(leavingPartIndex.at(lp));

		return;

	}

	/*- 新規粒子の生成 -*/

	/*- 新規粒子しかない場合 -*/

	if (myParticles.empty() && actualBirthParticles) // Initial creation

	{

		/*- 新たに作るパーティクルの数だけループ -*/

		for (i = 0; i < actualBirthParticles; i++) {

			/*- 出発する粒子 -*/

			ParticleOrigin po = particleOrigins.at(leavingPartIndex.at(i));

			/*-  どのTextureレベルを使うか -*/

			int seed = (int)((std::numeric_limits<int>::max)() * values.random_val->getFloat());</int>

			/*-  Lifetimeを得る -*/

			int lifetime = 0;

			if (values.column_lifetime_val)

				lifetime = lastframe[po.level];

			else {

				lifetime = (int)(values.lifetime_val.first +

								 ranges.lifetime_range * values.random_val->getFloat());

			}

			/*- この粒子が、レンダリングするフレームでも生きているか判断し、生きているなら生成 -*/

			if (lifetime > curr_frame - frame) {

				myParticles.push_back(

					Iwa_Particle(lifetime,

								 seed,

								 porttiles,

								 values,

								 ranges,

								 totalparticles,

								 0,

								 (int)po.level,

								 lastframe[po.level],

								 po.pos[0], po.pos[1],	/*- 座標を指定して発生 -*/

								 po.isUpward,			  /*- orientation を追加 -*/

								 (int)po.initSourceFrame) /*- 素材内の初期フレーム位置 -*/

					);

			}

			totalparticles++;

		}

	}

	/*- 既存粒子を動かし、かつ新規粒子を作る -*/

	else {

		std::list<iwa_particle>::iterator it;</iwa_particle>

		for (it = myParticles.begin(); it != myParticles.end();) {

			std::list<iwa_particle>::iterator current = it;</iwa_particle>

			++it;

			Iwa_Particle &part = (*current);

			if (part.scale <= 0.0)

				continue;

			if (part.lifetime <= 0)			// Note: This is in line with the above "lifetime>curr_frame-frame"

				myParticles.erase(current); // insertion counterpart

			else {

				part.move(porttiles,

						  values,

						  ranges,

						  windx, windy,

						  xgravity, ygravity,

						  dpi,

						  lastframe[part.level]);

			}

		}

		switch (values.toplayer_val) {

		case Iwa_TiledParticlesFx::TOP_YOUNGER:

			for (i = 0; i < actualBirthParticles; i++) {

				/*- 出発する粒子 -*/

				ParticleOrigin po = particleOrigins.at(leavingPartIndex.at(i));

				int seed = (int)((std::numeric_limits<int>::max)() * values.random_val->getFloat());</int>

				int lifetime = 0;

				if (values.column_lifetime_val)

					lifetime = lastframe[po.level];

				else {

					lifetime = (int)(values.lifetime_val.first + ranges.lifetime_range * values.random_val->getFloat());

				}

				if (lifetime > curr_frame - frame) {

					myParticles.push_front(

						Iwa_Particle(lifetime,

									 seed,

									 porttiles,

									 values,

									 ranges,

									 totalparticles,

									 0,

									 (int)po.level,

									 lastframe[po.level],

									 po.pos[0], po.pos[1],

									 po.isUpward,

									 (int)po.initSourceFrame) /*- 素材内の初期フレーム位置 -*/

						);

				}

				totalparticles++;

			}

			CASE Iwa_TiledParticlesFx::TOP_RANDOM : for (i = 0; i < actualBirthParticles; i++)

			{

				double tmp = values.random_val->getFloat() * myParticles.size();

				std::list<iwa_particle>::iterator it = myParticles.begin();</iwa_particle>

				for (int j = 0; j < tmp; j++, it++)

					;

				{

					/*- 出発する粒子 -*/

					ParticleOrigin po = particleOrigins.at(leavingPartIndex.at(i));

					int seed = (int)((std::numeric_limits<int>::max)() * values.random_val->getFloat());</int>

					int lifetime = 0;

					if (values.column_lifetime_val)

						lifetime = lastframe[po.level];

					else {

						lifetime = (int)(values.lifetime_val.first + ranges.lifetime_range * values.random_val->getFloat());

					}

					if (lifetime > curr_frame - frame) {

						myParticles.insert(it,

										   Iwa_Particle(lifetime,

														seed,

														porttiles,

														values,

														ranges,

														totalparticles,

														0,

														(int)po.level,

														lastframe[po.level],

														po.pos[0], po.pos[1],

														po.isUpward,

														(int)po.initSourceFrame) /*- 素材内の初期フレーム位置 -*/

										   );

					}

					totalparticles++;

				}

			}

		DEFAULT:

			for (i = 0; i < actualBirthParticles; i++) {

				/*- 出発する粒子 -*/

				ParticleOrigin po = particleOrigins.at(leavingPartIndex.at(i));

				int seed = (int)((std::numeric_limits<int>::max)() * values.random_val->getFloat());</int>

				int lifetime = 0;

				if (values.column_lifetime_val)

					lifetime = lastframe[po.level];

				else

					lifetime = (int)(values.lifetime_val.first + ranges.lifetime_range * values.random_val->getFloat());

				if (lifetime > curr_frame - frame) {

					myParticles.push_back(

						Iwa_Particle(lifetime,

									 seed,

									 porttiles,

									 values,

									 ranges,

									 totalparticles,

									 0,

									 (int)po.level,

									 lastframe[po.level],

									 po.pos[0], po.pos[1],

									 po.isUpward,

									 (int)po.initSourceFrame) /*-  素材内の初期フレーム位置  -*/

						);

				}

				totalparticles++;

			}

		}

	}

	/*- すでに発生したparticleOriginを消去する

		インデックスを小さい順にならべる -*/

	qSort(leavingPartIndex.begin(), leavingPartIndex.end());

	/*- インデックス大きい方から消していく -*/

	for (int lp = leavingPartIndex.size() - 1; lp >= 0; lp--)

		particleOrigins.removeAt(leavingPartIndex.at(lp));

}

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

void Iwa_Particles_Engine::normalize_values(struct particles_values &values,

											const TRenderSettings &ri)

{

	double dpicorr = 1;

	TPointD pos(values.x_pos_val, values.y_pos_val);

	(values.x_pos_val) = pos.x;

	(values.y_pos_val) = pos.y;

	(values.length_val) = (values.length_val) * dpicorr;

	(values.height_val) = (values.height_val) * dpicorr;

	(values.gravity_val) = (values.gravity_val) * dpicorr * 0.1;

	(values.windint_val) = (values.windint_val) * dpicorr;

	(values.speed_val.first) = (values.speed_val.first) * dpicorr;

	(values.speed_val.second) = (values.speed_val.second) * dpicorr;

	(values.randomx_val.first) = (values.randomx_val.first) * dpicorr;

	(values.randomx_val.second) = (values.randomx_val.second) * dpicorr;

	(values.randomy_val.first) = (values.randomy_val.first) * dpicorr;

	(values.randomy_val.second) = (values.randomy_val.second) * dpicorr;

	(values.scale_val.first) = (values.scale_val.first) * 0.01;

	(values.scale_val.second) = (values.scale_val.second) * 0.01;

	(values.scalestep_val.first) = (values.scalestep_val.first) * 0.01;

	(values.scalestep_val.second) = (values.scalestep_val.second) * 0.01;

	(values.opacity_val.first) = (values.opacity_val.first) * 0.01;

	(values.opacity_val.second) = (values.opacity_val.second) * 0.01;

	(values.trailopacity_val.first) = (values.trailopacity_val.first) * 0.01;

	(values.trailopacity_val.second) = (values.trailopacity_val.second) * 0.01;

	(values.mblur_val) = (values.mblur_val) * 0.01;

	(values.friction_val) = -(values.friction_val) * 0.01;

	(values.windangle_val) = (values.windangle_val) * (TConsts::pi / 180);

	(values.g_angle_val) = (values.g_angle_val + 180) * (TConsts::pi / 180);

	(values.speeda_val.first) = (values.speeda_val.first) * (TConsts::pi / 180);

	(values.speeda_val.second) = (values.speeda_val.second) * (TConsts::pi / 180);

	if (values.step_val < 1)

		values.step_val = 1;

	values.genfadecol_val = (values.genfadecol_val) * 0.01;

	values.finfadecol_val = (values.finfadecol_val) * 0.01;

	values.foutfadecol_val = (values.foutfadecol_val) * 0.01;

	(values.curl_val) = (values.curl_val) * dpicorr * 0.1;

	/*- ひらひら粒子に照明を当てる normalize_values()内で Degree → Radian 化する -*/

	(values.iw_light_theta_val) = (values.iw_light_theta_val) * (TConsts::pi / 180);

	(values.iw_light_phi_val) = (values.iw_light_phi_val) * (TConsts::pi / 180);

	/*- 読み込みマージン -*/

	(values.margin_val) = (values.margin_val) * dpicorr;

}

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

void Iwa_Particles_Engine::render_particles(TFlash *flash,							 /*-  0 が入ってくる -*/

											TTile *tile,							 /*- 結果を格納するTile -*/

											std::vector<trasterfxport *=""> part_ports, /*- テクスチャ素材画像のポート -*/</trasterfxport>

											const TRenderSettings &ri,

											TDimension &p_size,						   /*- テクスチャ素材のバウンディングボックスの足し合わさったもの -*/

											TPointD &p_offset,						   /*- バウンディングボックス左下の座標 -*/

											std::map<int, *="" trasterfxport=""> ctrl_ports, /*- コントロール画像のポート番号／ポート -*/</int,>

											vector<tlevelp> partLevel,				   /*- テクスチャ素材のリスト -*/</tlevelp>

											float dpi,								   /*- 1 が入ってくる -*/

											int curr_frame,

											int shrink,				/*- 1 が入ってくる -*/

											double startx,			/*- 0 が入ってくる -*/

											double starty,			/*- 0 が入ってくる -*/

											double endx,			/*- 0 が入ってくる -*/

											double endy,			/*- 0 が入ってくる -*/

											vector<int> last_frame, /*- テクスチャ素材のそれぞれのカラム長 -*/</int>

											unsigned long fxId)

{

	/*- 各種パーティクルのパラメータ -*/

	struct particles_values values;

	memset(&values, 0, sizeof(values));

	/*- 現在のフレームでの各パラメータを得る -*/

	fill_value_struct(values, m_frame);

	int frame,

		intpart = 0;

	int level_n = part_ports.size();

	/*- 開始フレーム -*/

	int startframe = (int)values.startpos_val;

	float dpicorr = dpi * 0.01f,

		  fractpart = 0;

	/*- 不透明度の範囲（透明～不透明を 0～1 に正規化） -*/

	float opacity_range = (values.opacity_val.second - values.opacity_val.first) * 0.01f;

	bool random_level = false;

	bool isPrecomputingEnabled = false;

	{

		TRenderer renderer(TRenderer::instance());

		isPrecomputingEnabled = (renderer && renderer.isPrecomputingEnabled()) ? true : false;

	}

	/*- シュリンクしている場合 -*/

	float dpicorr_shrinked;

	if (values.unit_val == Iwa_TiledParticlesFx::UNIT_SMALL_INCH)

		dpicorr_shrinked = dpicorr / shrink;

	else

		dpicorr_shrinked = dpi / shrink;

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

	/*- 現在のフレームをステップ値にする -*/

	curr_frame = curr_frame / values.step_val;

	Iwa_ParticlesManager *pc = Iwa_ParticlesManager::instance();

	bool isFirstFrame = !(pc->isCached(fxId));

	// Retrieve the last rolled frame

	Iwa_ParticlesManager::FrameData *particlesData = pc->data(fxId);

	std::list<iwa_particle> myParticles;</iwa_particle>

	TRandom myRandom = m_parent->randseed_val->getValue();

	values.random_val = &myRandom;

	int totalparticles = 0;

	/*- 規則正しく並んだ（まだ出発していない）粒子情報 -*/

	QList<particleorigin> particleOrigins;</particleorigin>

	/*- 出力画像のバウンディングボックス -*/

	TRectD outTileBBox(tile->m_pos, TDimensionD(tile->getRaster()->getLx(), tile->getRaster()->getLy()));

	/*- 現在取っておいてあるデータのフレーム番号 -*/

	int pcFrame = particlesData->m_frame;

	/*- マージンをピクセル単位に換算する -*/

	double pixelMargin;

	{

		TPointD vect(values.margin_val, 0.0);

		TAffine aff(ri.m_affine);

		aff.a13 = aff.a23 = 0;

		vect = aff * vect;

		pixelMargin = sqrt(vect.x * vect.x + vect.y * vect.y);

	}

	/*- 外側にマージンを取って粒子を生成 -*/

	TRectD resourceTileBBox = outTileBBox.enlarge(pixelMargin);

	/*- 初期粒子量。これが変わっていなければ、BGはそのまま描く -*/

	int initialOriginsSize;

	if (pcFrame > curr_frame) {

		/*- データを初期化 -*/

		// Clear stored particlesData

		particlesData->clear();

		pcFrame = particlesData->m_frame;

		/*- まだ出発していない粒子情報を初期化 -*/

		initParticleOrigins(resourceTileBBox,

							particleOrigins,

							curr_frame,

							ri.m_affine,

							values,

							level_n,

							last_frame,

							pixelMargin);

		initialOriginsSize = particleOrigins.size();

	}

	else if (pcFrame >= startframe - 1) {

		myParticles = particlesData->m_particles;

		myRandom = particlesData->m_random;

		totalparticles = particlesData->m_totalParticles;

		particleOrigins = particlesData->m_particleOrigins;

		initialOriginsSize = -1;

	} else {

		/*- まだ出発していない粒子情報を初期化 -*/

		initParticleOrigins(resourceTileBBox,

							particleOrigins,

							curr_frame,

							ri.m_affine,

							values,

							level_n,

							last_frame,

							pixelMargin);

		initialOriginsSize = particleOrigins.size();

	}

	/*- スタートからカレントフレームまでループ -*/

	for (frame = startframe - 1; frame <= curr_frame; ++frame) {

		/*-  参照画像はキャッシュされてるフレームでは必要ないのでは？ -*/

		if (frame <= pcFrame)

			continue;

		int dist_frame = curr_frame - frame;

		/*- ループ内の現在のフレームでのパラメータを取得。スタートが負ならフレーム=0のときの値を格納。 -*/

		fill_value_struct(values, frame < 0 ? 0 : frame * values.step_val);

		/*- パラメータの正規化 -*/

		normalize_values(values, ri);

		/*- maxnum_valは"birth_rate"のパラメータ -*/

		intpart = (int)values.maxnum_val;

		/*- birth_rateが小数だったとき、各フレームの小数部分を足しこんだ結果の整数部分をintpartに渡す -*/

		fractpart = fractpart + values.maxnum_val - intpart;

		if ((int)fractpart) {

			values.maxnum_val += (int)fractpart;

			fractpart = fractpart - (int)fractpart;

		}

		map<int, *="" ttile=""> porttiles;</int,>

		// Perform the roll

		/*- RenderSettingsを複製して現在のフレームの計算用にする -*/

		TRenderSettings riAux(ri);

		/*- 64bitにする -*/

		riAux.m_bpp = 64;

		//riAux.m_bpp = 32;

		int r_frame; // Useful in case of negative roll frames

		if (frame < 0)

			r_frame = 0;

		else

			r_frame = frame;

		/*- コントロールに刺さっている各ポートについて -*/

		for (std::map<int, *="" trasterfxport="">::iterator it = ctrl_ports.begin(); it != ctrl_ports.end(); ++it) {</int,>

			TTile *tmp;

			/*- ポートが接続されていて、Fx内で実際に使用されていたら -*/

			if ((it->second)->isConnected() && port_is_used(it->first, values)) {

				TRectD bbox = resourceTileBBox;

				/*- 素材が存在する場合、portTilesにコントロール画像タイルを格納 -*/

				if (!bbox.isEmpty()) {

					if (frame <= pcFrame) {

						// This frame will not actually be rolled. However, it was dryComputed - so, declare the same here.

						(*it->second)->dryCompute(bbox, r_frame, riAux);

					} else {

						tmp = new TTile;

						if (isPrecomputingEnabled) {

							(*it->second)->allocateAndCompute(*tmp, bbox.getP00(), convert(bbox).getSize(), 0, r_frame, riAux);

						} else {

							string alias = "CTRL: " + (*(it->second))->getAlias(r_frame, riAux);

							TRasterImageP rimg = TImageCache::instance()->get(alias, false);

							if (rimg) {

								tmp->m_pos = bbox.getP00();

								tmp->setRaster(rimg->getRaster());

							} else {

								(*it->second)->allocateAndCompute(*tmp, bbox.getP00(), convert(bbox).getSize(), 0, r_frame, riAux);

							}

						}

						porttiles[it->first] = tmp;

					}

				}

			}

		}

		TTile baseImgTile;

		if (values.base_ctrl_val &&

			ctrl_ports.at(values.base_ctrl_val)->isConnected() &&

			port_is_used(values.base_ctrl_val, values) &&

			values.iw_rendermode_val != Iwa_TiledParticlesFx::REND_ILLUMINATED) /*- 照明モードなら、BG素材は要らない -*/

		{

			string alias = "BG_CTRL: " + (*ctrl_ports.at(values.base_ctrl_val))->getAlias(r_frame, ri);

			TRasterImageP rimg = TImageCache::instance()->get(alias, false);

			if (rimg) {

				baseImgTile.m_pos = tile->m_pos;

				baseImgTile.setRaster(rimg->getRaster());

			} else {

				/*- 出力と同じbpcにする -*/

				(*ctrl_ports.at(values.base_ctrl_val))->allocateAndCompute(baseImgTile, tile->m_pos, convert(resourceTileBBox).getSize(), tile->getRaster(), r_frame, ri);

				addRenderCache(alias, TRasterImageP(baseImgTile.getRaster()));

			}

			baseImgTile.getRaster()->lock();

		}

		// Invoke the actual rolling procedure

		roll_particles(tile,

					   porttiles,

					   riAux,

					   myParticles,

					   values,

					   0, 0,

					   frame,

					   curr_frame,

					   level_n,

					   &random_level,

					   1,

					   last_frame,

					   totalparticles,

					   particleOrigins,

					   intpart /*- 実際に生成したい粒子数 -*/

					   );

		// Store the rolled data in the particles manager

		if (!particlesData->m_calculated || particlesData->m_frame + particlesData->m_maxTrail < frame) {

			particlesData->m_frame = frame;

			particlesData->m_particles = myParticles;

			particlesData->m_random = myRandom;

			particlesData->buildMaxTrail();

			particlesData->m_calculated = true;

			particlesData->m_totalParticles = totalparticles;

			particlesData->m_particleOrigins = particleOrigins;

		}

		// Render the particles if the distance from current frame is a trail multiple

		/*- さしあたり、trailは無視する -*/

		if (dist_frame == 0) {

			//--------

			// Store the maximum particle size before the do_render cycle

			/*- 表示されている粒子のうち、各素材について最大サイズのものを記録しておく

				条件にあわせ、飛んでいる粒子と飛び立つ前の粒子の両方で記録を行う -*/

			/*-	①飛んでいる粒子 -*/

			if (values.iw_rendermode_val != Iwa_TiledParticlesFx::REND_BG) {

				std::list<iwa_particle>::iterator pt;</iwa_particle>

				for (pt = myParticles.begin(); pt != myParticles.end(); ++pt) {

					Iwa_Particle &part = *pt;

					int ndx = part.frame % last_frame[part.level];

					std::pair<int, int=""> ndxPair(part.level, ndx);</int,>

					std::map<std::pair<int, int="">, float>::iterator it =</std::pair<int,>

						partScales.find(ndxPair);

					if (it != partScales.end())

						it->second = tmax(part.scale, it->second);

					else

						partScales[ndxPair] = part.scale;

				}

			}

			/*- ②飛び立つ前の粒子がひとつでもあった場合、最大値でおきかえる -*/

			if (values.iw_rendermode_val == Iwa_TiledParticlesFx::REND_ALL ||

				values.iw_rendermode_val == Iwa_TiledParticlesFx::REND_BG) {

				for (int lev = 0; lev < level_n; lev++) {

					std::pair<int, int=""> ndxPair(lev, 0);</int,>

					std::map<std::pair<int, int="">, float>::iterator it =</std::pair<int,>

						partScales.find(ndxPair);

					if (it != partScales.end())

						it->second = tmax((float)values.scale_val.second, it->second);

					else

						partScales[ndxPair] = values.scale_val.second;

				}

			}

			//--------

			/*- ここで、出発した粒子の分、穴を開けた背景を描く -*/

			/*- スイッチがONなら -*/

			if (values.iw_rendermode_val == Iwa_TiledParticlesFx::REND_ALL ||

				values.iw_rendermode_val == Iwa_TiledParticlesFx::REND_BG) {

				/*- まだ粒子が飛び立っていない場合、そのまま背景を描く -*/

				if (initialOriginsSize == particleOrigins.size()) {

					TRop::resample(tile->getRaster(), baseImgTile.getRaster(), TAffine());

				} else {

					renderBackground(tile,

									 particleOrigins,

									 part_ports,

									 ri,

									 partLevel,

									 partScales,

									 &baseImgTile);

				}

			}

			/*- 粒子の描画。もし、背景モードなら描かない -*/

			if (values.iw_rendermode_val != Iwa_TiledParticlesFx::REND_BG) {

				if (values.toplayer_val == Iwa_TiledParticlesFx::TOP_SMALLER ||

					values.toplayer_val == Iwa_TiledParticlesFx::TOP_BIGGER)

					myParticles.sort(Iwa_ComparebySize());

				if (values.toplayer_val == Iwa_TiledParticlesFx::TOP_SMALLER) {

					int unit = 1 + (int)myParticles.size() / 100;

					int count = 0;

					std::list<iwa_particle>::iterator pt;</iwa_particle>

					for (pt = myParticles.begin(); pt != myParticles.end(); ++pt) {

						count++;

						Iwa_Particle &part = *pt;

						if (dist_frame <= part.trail &&

							part.scale > 0.0f &&

							part.lifetime > 0 &&

							part.lifetime <= part.genlifetime) // This last... shouldn't always be?

						{

							do_render(flash,

									  &part,

									  tile,

									  part_ports,

									  porttiles,

									  ri,

									  p_size,

									  p_offset,

									  last_frame[part.level],

									  partLevel,

									  values,

									  opacity_range,

									  dist_frame,

									  partScales,

									  &baseImgTile);

						}

					}

				} else {

					int unit = 1 + (int)myParticles.size() / 100;