public static AppMain.AMS_AME_RUNTIME _amCreateRuntimeEmitter(
AppMain.AMS_AME_CREATE_PARAM param)
{
AppMain.AMS_AME_RUNTIME runtime = AppMain._amAllocRuntime();
runtime.ecb = param.ecb;
runtime.node = param.node;
runtime.child_head.next = runtime.child_tail;
runtime.child_tail.prev = runtime.child_head;
runtime.work_head.next = runtime.work_tail;
runtime.work_tail.prev = runtime.work_head;
runtime.active_head.next = runtime.active_tail;
runtime.active_tail.prev = runtime.active_head;
AppMain._amAddEntry(param.ecb, runtime);
runtime.work = AppMain._amAllocRuntimeWork();
param.work = runtime.work;
int num = AppMain._am_emitter_func[(AppMain.AMD_AME_NODE_TYPE(param.node) & (int)byte.MaxValue) << 2]((object)param);
for (AppMain.AMS_AME_NODE node = param.node.child; node != null; node = node.sibling)
{
if (!AppMain.AMD_AME_IS_FIELD(node))
{
AppMain.AMS_AME_RUNTIME runtimeGroup = AppMain._amCreateRuntimeGroup(param.ecb, node);
AppMain._amConnectLinkToTail(runtime.child_tail, (AppMain.AMS_AME_LIST)runtimeGroup);
++runtime.child_num;
}
}
return(runtime);
}
private static AppMain.AMS_AME_RUNTIME _amCreateRuntimeParticle(
AppMain.AMS_AME_CREATE_PARAM param)
{
AppMain.AMS_AME_RUNTIME runtime = AppMain._amAllocRuntime();
runtime.ecb = param.ecb;
runtime.node = param.node;
runtime.state = 16384;
runtime.child_head.next = runtime.child_tail;
runtime.child_tail.prev = runtime.child_head;
runtime.work_head.next = runtime.work_tail;
runtime.work_tail.prev = runtime.work_head;
runtime.active_head.next = runtime.active_tail;
runtime.active_tail.prev = runtime.active_head;
for (AppMain.AMS_AME_NODE node = param.node.child; node != null; node = node.sibling)
{
if (AppMain.AMD_AME_IS_PARTICLE(node))
{
runtime.spawn_runtime = AppMain._amCreateRuntimeGroup(param.ecb, node);
break;
}
}
AppMain._amAddEntry(param.ecb, runtime);
param.runtime = runtime;
AppMain._amCreateParticle(param);
return(runtime);
}
public static void _amCreateEmitter(AppMain.AMS_AME_CREATE_PARAM param)
{
AppMain.AMS_AME_RUNTIME runtimeEmitter = AppMain._amCreateRuntimeEmitter(param);
runtimeEmitter.parent_runtime = param.runtime;
AppMain._amConnectLinkToTail(runtimeEmitter.work_tail, (AppMain.AMS_AME_LIST)runtimeEmitter);
++runtimeEmitter.work_num;
param.runtime = runtimeEmitter;
param.node = runtimeEmitter.node;
param.work = runtimeEmitter.work;
}
private static AppMain.AMS_AME_ECB _amEffectCreate(
AppMain.AMS_AME_HEADER header,
int attribute,
int priority)
{
AppMain.AMS_AME_ECB amsAmeEcb = AppMain._am_ecb_ref[AppMain._am_ecb_alloc];
++AppMain._am_ecb_alloc;
if (AppMain._am_ecb_alloc >= 128)
{
AppMain._am_ecb_alloc = 0;
}
amsAmeEcb.Clear();
amsAmeEcb.attribute = attribute;
amsAmeEcb.priority = priority;
amsAmeEcb.transparency = 256;
amsAmeEcb.size_rate = 1f;
AppMain.amVectorInit(ref amsAmeEcb.translate);
AppMain.amQuatInit(ref amsAmeEcb.rotate);
amsAmeEcb.bounding.Assign(header.bounding);
AppMain.AMS_AME_ECB next = (AppMain.AMS_AME_ECB)AppMain._am_ecb_head.next;
while (next != AppMain._am_ecb_tail && next.priority <= priority)
{
next = (AppMain.AMS_AME_ECB)next.next;
}
next.prev.next = (AppMain.AMS_AME_LIST)amsAmeEcb;
amsAmeEcb.prev = next.prev;
next.prev = (AppMain.AMS_AME_LIST)amsAmeEcb;
amsAmeEcb.next = (AppMain.AMS_AME_LIST)next;
AppMain.AMS_AME_CREATE_PARAM amsAmeCreateParam = new AppMain.AMS_AME_CREATE_PARAM();
AppMain.NNS_VECTOR4D amEffectCreateVec = AppMain._amEffectCreate_vec;
AppMain.AMS_AME_NODE sibling = header.node[0];
AppMain.amVectorInit(ref amEffectCreateVec);
for (; sibling != null; sibling = sibling.sibling)
{
amsAmeCreateParam.ecb = amsAmeEcb;
amsAmeCreateParam.runtime = (AppMain.AMS_AME_RUNTIME)null;
amsAmeCreateParam.node = sibling;
amsAmeCreateParam.position = amEffectCreateVec;
amsAmeCreateParam.velocity = amEffectCreateVec;
amsAmeCreateParam.parent_position = amEffectCreateVec;
amsAmeCreateParam.parent_velocity = amEffectCreateVec;
switch (AppMain.AMD_AME_SUPER_CLASS_ID(sibling))
{
case 256:
AppMain._amCreateRuntimeEmitter(amsAmeCreateParam).state |= 8192;
break;
case 512:
AppMain._amCreateRuntimeParticle(amsAmeCreateParam).state |= 8192;
break;
}
}
amsAmeEcb.skip_update = 1;
return(amsAmeEcb);
}
public static int _amInitSprite(object p)
{
AppMain.AMS_AME_CREATE_PARAM amsAmeCreateParam = (AppMain.AMS_AME_CREATE_PARAM)p;
AppMain.AMS_AME_NODE_SPRITE node = (AppMain.AMS_AME_NODE_SPRITE)amsAmeCreateParam.node;
AppMain.AMS_AME_RUNTIME_WORK_SPRITE work = (AppMain.AMS_AME_RUNTIME_WORK_SPRITE)amsAmeCreateParam.work;
work.time = -node.start_time;
AppMain.AMS_RGBA8888 colorStart = node.color_start;
colorStart.color = node.color_start.color;
colorStart.a = (byte)((int)colorStart.a * amsAmeCreateParam.ecb.transparency >> 8);
work.set_color(colorStart.color);
AppMain.amVectorAdd(work.position, amsAmeCreateParam.parent_position.Value, amsAmeCreateParam.position.Value);
AppMain.amVectorAdd(work.position, node.translate);
AppMain.amVectorScale(work.velocity, amsAmeCreateParam.parent_velocity.Value, node.inheritance_rate);
AppMain.amVectorAdd(work.velocity, amsAmeCreateParam.velocity.Value);
float z = node.size + node.size_chaos * AppMain.nnRandom();
work.set_size(z * node.scale_x_start, z * node.scale_x_start, z, 0.0f);
work.twist = node.twist_angle + node.twist_angle_chaos * AppMain.nnRandom();
if (((int)node.flag & 4) != 0 && (double)AppMain.nnRandom() > 0.5)
{
work.flag |= 4U;
}
work.twist_speed = ((int)work.flag & 4) == 0 ? node.twist_angle_speed : -node.twist_angle_speed;
if (((int)node.flag & 32768) != 0)
{
work.tex_time = 0.0f;
work.tex_no = 0;
if (((int)node.flag & 524288) != 0)
{
work.tex_no = (int)(100.0 * (double)AppMain.nnRandom()) % node.tex_anim.key_num;
}
AppMain.AMS_AME_TEX_ANIM_KEY amsAmeTexAnimKey = node.tex_anim.key_buf[work.tex_no];
work.set_st(amsAmeTexAnimKey.l, amsAmeTexAnimKey.t, amsAmeTexAnimKey.r, amsAmeTexAnimKey.b);
}
else if (((int)node.flag & 8192) != 0)
{
work.set_st(node.cropping_l, node.cropping_t, node.cropping_r, node.cropping_b);
}
else
{
work.set_st(0.0f, 0.0f, 1f, 1f);
}
if (((int)node.flag & 1048576) != 0 || ((int)node.flag & 131072) != 0 && (double)AppMain.nnRandom() > 0.5)
{
work.flag |= 8U;
work.set_st(work.st.z, work.st.y, work.st.x, work.st.w);
}
if (((int)node.flag & 2097152) != 0 || ((int)node.flag & 262144) != 0 && (double)AppMain.nnRandom() > 0.5)
{
work.flag |= 16U;
work.set_st(work.st.x, work.st.w, work.st.z, work.st.y);
}
return(0);
}
public static int _amInitLine(object p)
{
AppMain.AMS_AME_CREATE_PARAM amsAmeCreateParam = (AppMain.AMS_AME_CREATE_PARAM)p;
AppMain.AMS_AME_NODE_LINE node = (AppMain.AMS_AME_NODE_LINE)amsAmeCreateParam.node;
AppMain.AMS_AME_RUNTIME_WORK_LINE work = (AppMain.AMS_AME_RUNTIME_WORK_LINE)amsAmeCreateParam.work;
work.time = -node.start_time;
work.length = node.length_start;
work.inside_width = node.inside_width_start;
work.outside_width = node.outside_width_start;
AppMain.AMS_RGBA8888 insideColorStart = node.inside_color_start;
insideColorStart.a = (byte)((int)insideColorStart.a * amsAmeCreateParam.ecb.transparency >> 8);
work.set_inside_color(insideColorStart.color);
AppMain.AMS_RGBA8888 outsideColorStart = node.outside_color_start;
outsideColorStart.a = (byte)((int)outsideColorStart.a * amsAmeCreateParam.ecb.transparency >> 8);
work.set_outside_color(outsideColorStart.color);
AppMain.amVectorAdd(ref work.position, ref amsAmeCreateParam.parent_position.UnsafeValue, ref amsAmeCreateParam.position.UnsafeValue);
AppMain.amVectorAdd(work.position, node.translate);
AppMain.amVectorScale(work.velocity, amsAmeCreateParam.parent_velocity.Value, node.inheritance_rate);
AppMain.amVectorAdd(work.velocity, amsAmeCreateParam.velocity.Value);
if (((int)node.flag & 32768) != 0)
{
work.tex_time = 0.0f;
work.tex_no = 0;
if (((int)node.flag & 524288) != 0)
{
work.tex_no = (int)(100.0 * (double)AppMain.nnRandom()) % node.tex_anim.key_num;
}
AppMain.AMS_AME_TEX_ANIM_KEY amsAmeTexAnimKey = node.tex_anim.key_buf[work.tex_no];
work.set_st(amsAmeTexAnimKey.l, amsAmeTexAnimKey.t, amsAmeTexAnimKey.r, amsAmeTexAnimKey.b);
}
else if (((int)node.flag & 8192) != 0)
{
work.set_st(node.cropping_l, node.cropping_t, node.cropping_r, node.cropping_b);
}
else
{
work.set_st(0.0f, 0.0f, 1f, 1f);
}
if (((int)node.flag & 1048576) != 0 || ((int)node.flag & 131072) != 0 && (double)AppMain.nnRandom() > 0.5)
{
work.flag |= 8U;
work.set_st(work.st.z, work.st.y, work.st.x, work.st.w);
}
if (((int)node.flag & 2097152) != 0 || ((int)node.flag & 262144) != 0 && (double)AppMain.nnRandom() > 0.5)
{
work.flag |= 16U;
work.set_st(work.st.x, work.st.w, work.st.z, work.st.y);
}
return(0);
}
private static int _amInitDirectional(object p)
{
AppMain.AMS_AME_CREATE_PARAM amsAmeCreateParam = (AppMain.AMS_AME_CREATE_PARAM)p;
AppMain.AMS_AME_NODE_DIRECTIONAL node = (AppMain.AMS_AME_NODE_DIRECTIONAL)amsAmeCreateParam.node;
AppMain.AMS_AME_RUNTIME_WORK_DIRECTIONAL work = (AppMain.AMS_AME_RUNTIME_WORK_DIRECTIONAL)amsAmeCreateParam.work;
work.time = -node.start_time;
AppMain.amVectorAdd(ref work.position, amsAmeCreateParam.parent_position.Value, amsAmeCreateParam.position.Value);
AppMain.amVectorAdd(ref work.position, node.translate);
AppMain.amVectorScale(ref work.velocity, amsAmeCreateParam.parent_velocity.Value, node.inheritance_rate);
AppMain.amVectorAdd(ref work.velocity, amsAmeCreateParam.velocity.Value);
work.rotate = node.rotate;
work.spread = node.spread;
return(0);
}
private static int _amInitOmni(object p)
{
AppMain.AMS_AME_CREATE_PARAM amsAmeCreateParam = (AppMain.AMS_AME_CREATE_PARAM)p;
AppMain.AMS_AME_NODE_OMNI node = (AppMain.AMS_AME_NODE_OMNI)amsAmeCreateParam.node;
AppMain.AMS_AME_RUNTIME_WORK_OMNI work = (AppMain.AMS_AME_RUNTIME_WORK_OMNI)amsAmeCreateParam.work;
work.time = -node.start_time;
AppMain.amVectorAdd(ref work.position, ref amsAmeCreateParam.parent_position.UnsafeValue, ref amsAmeCreateParam.position.UnsafeValue);
AppMain.amVectorAdd(ref work.position, node.translate);
AppMain.amVectorScale(ref work.velocity, amsAmeCreateParam.parent_velocity.Value, node.inheritance_rate);
AppMain.amVectorAdd(ref work.velocity, amsAmeCreateParam.velocity.Value);
work.rotate = node.rotate;
float sizeRate = amsAmeCreateParam.ecb.size_rate;
work.offset = node.offset * sizeRate;
work.offset_chaos = node.offset_chaos * sizeRate;
return(0);
}
public static void _amCreateParticle(AppMain.AMS_AME_CREATE_PARAM param)
{
AppMain.AMS_AME_RUNTIME_WORK_MODEL runtimeWorkModel = (AppMain.AMS_AME_RUNTIME_WORK_MODEL)AppMain._amAllocRuntimeWork();
param.work = (AppMain.AMS_AME_RUNTIME_WORK)runtimeWorkModel;
int num = AppMain._am_particle_func[(AppMain.AMD_AME_NODE_TYPE(param.node) & (int)byte.MaxValue) << 2]((object)param);
if ((double)runtimeWorkModel.time < 0.0)
{
AppMain._amConnectLinkToTail(param.runtime.work_tail, (AppMain.AMS_AME_LIST)runtimeWorkModel);
++param.runtime.work_num;
}
else
{
AppMain._amConnectLinkToTail(param.runtime.active_tail, (AppMain.AMS_AME_LIST)runtimeWorkModel);
++param.runtime.active_num;
}
}
private static int _amInitSurface(object p)
{
AppMain.AMS_AME_CREATE_PARAM amsAmeCreateParam = (AppMain.AMS_AME_CREATE_PARAM)p;
AppMain.AMS_AME_NODE_SURFACE node = (AppMain.AMS_AME_NODE_SURFACE)amsAmeCreateParam.node;
AppMain.AMS_AME_RUNTIME_WORK_SURFACE work = (AppMain.AMS_AME_RUNTIME_WORK_SURFACE)amsAmeCreateParam.work;
work.time = -node.start_time;
AppMain.amVectorAdd(work.position, amsAmeCreateParam.parent_position.Value, amsAmeCreateParam.position.Value);
AppMain.amVectorAdd(work.position, node.translate);
AppMain.amVectorScale(work.velocity, amsAmeCreateParam.parent_velocity.Value, node.inheritance_rate);
AppMain.amVectorAdd(work.velocity, amsAmeCreateParam.velocity.Value);
work.rotate = node.rotate;
float sizeRate = amsAmeCreateParam.ecb.size_rate;
work.width = node.width * sizeRate;
work.height = node.height * sizeRate;
work.offset = node.offset * sizeRate;
work.offset_chaos = node.offset_chaos * sizeRate;
return(0);
}
public static int _amInitModel(object p)
{
AppMain.AMS_AME_CREATE_PARAM amsAmeCreateParam = (AppMain.AMS_AME_CREATE_PARAM)p;
AppMain.AMS_AME_NODE_MODEL node = (AppMain.AMS_AME_NODE_MODEL)amsAmeCreateParam.node;
AppMain.AMS_AME_RUNTIME_WORK_MODEL work = (AppMain.AMS_AME_RUNTIME_WORK_MODEL)amsAmeCreateParam.work;
work.time = -node.start_time;
work.scale.Assign(node.scale_start);
work.set_color(node.color_start.color);
AppMain.amVectorAdd(work.position, amsAmeCreateParam.parent_position.Value, amsAmeCreateParam.position.Value);
AppMain.amVectorAdd(work.position, node.translate);
AppMain.amVectorScale(work.velocity, amsAmeCreateParam.parent_velocity.Value, node.inheritance_rate);
AppMain.amVectorAdd(work.velocity, amsAmeCreateParam.velocity.Value);
if (((int)node.flag & 4) != 0)
{
AppMain.NNS_VECTOR4D nnsVectoR4D = new AppMain.NNS_VECTOR4D();
AppMain.amVectorRandom(nnsVectoR4D);
AppMain.NNS_QUATERNION rotate = work.rotate;
AppMain.amQuatRotAxisToQuat(ref rotate, nnsVectoR4D, (float)((double)AppMain.nnRandom() * 2.0 * 3.14159274101257));
work.rotate = rotate;
}
else
{
work.rotate = node.rotate;
}
if (((int)node.flag & 8) != 0)
{
AppMain.NNS_VECTOR4D pDst = new AppMain.NNS_VECTOR4D();
AppMain.amVectorRandom(pDst);
work.set_rotate_axis(pDst.x, pDst.y, pDst.z, node.rotate_axis.w);
}
else
{
work.rotate_axis.Assign(node.rotate_axis);
}
return(0);
}
public static void _amCreateSpawnParticle(
AppMain.AMS_AME_RUNTIME runtime,
AppMain.AMS_AME_RUNTIME_WORK work)
{
AppMain.NNS_VECTOR4D pVec = new AppMain.NNS_VECTOR4D();
AppMain.amVectorInit(pVec);
AppMain.AMS_AME_CREATE_PARAM amsAmeCreateParam = AppMain.GlobalPool <AppMain.AMS_AME_CREATE_PARAM> .Alloc();
amsAmeCreateParam.ecb = runtime.ecb;
amsAmeCreateParam.runtime = runtime.spawn_runtime;
amsAmeCreateParam.node = runtime.spawn_runtime.node;
amsAmeCreateParam.position = pVec;
amsAmeCreateParam.velocity = pVec;
amsAmeCreateParam.parent_position = work.position;
amsAmeCreateParam.parent_velocity = work.velocity;
if ((runtime.state & 8192) != 0)
{
runtime.spawn_runtime.state |= 8192;
}
AppMain._amCreateParticle(amsAmeCreateParam);
if (AppMain.AMD_AME_NODE_TYPE(runtime.node) == AppMain.AMD_AME_NODE_TYPE(amsAmeCreateParam.node))
{
AppMain.AMS_AME_NODE node1 = runtime.node;
AppMain.AMS_AME_NODE node2 = amsAmeCreateParam.node;
switch (AppMain.AMD_AME_NODE_TYPE(amsAmeCreateParam.node))
{
case 512:
AppMain.AMS_AME_RUNTIME_WORK_SIMPLE_SPRITE workSimpleSprite = (AppMain.AMS_AME_RUNTIME_WORK_SIMPLE_SPRITE)work;
AppMain.AMS_AME_RUNTIME_WORK_SIMPLE_SPRITE work1 = (AppMain.AMS_AME_RUNTIME_WORK_SIMPLE_SPRITE)amsAmeCreateParam.work;
if (((int)node1.flag & (int)node2.flag & 131072) != 0 && (((int)workSimpleSprite.flag ^ (int)work1.flag) & 8) != 0)
{
work1.flag ^= 8U;
work1.set_st(work1.st.z, work1.st.y, work1.st.x, work1.st.w);
}
if (((int)node1.flag & (int)node2.flag & 262144) != 0 && (((int)workSimpleSprite.flag ^ (int)work1.flag) & 16) != 0)
{
work1.flag ^= 16U;
work1.set_st(work1.st.x, work1.st.w, work1.st.z, work1.st.y);
break;
}
break;
case 513:
AppMain.AMS_AME_RUNTIME_WORK_SPRITE runtimeWorkSprite = (AppMain.AMS_AME_RUNTIME_WORK_SPRITE)work;
AppMain.AMS_AME_RUNTIME_WORK_SPRITE work2 = (AppMain.AMS_AME_RUNTIME_WORK_SPRITE)amsAmeCreateParam.work;
if (((int)node1.flag & (int)node2.flag & 4) != 0)
{
if (((int)runtimeWorkSprite.flag & 4) != 0)
{
work2.flag |= 4U;
}
else
{
work2.flag &= 4294967291U;
}
}
if (((int)node1.flag & (int)node2.flag & 131072) != 0 && (((int)runtimeWorkSprite.flag ^ (int)work2.flag) & 8) != 0)
{
work2.flag ^= 8U;
work2.set_st(work2.st.z, work2.st.y, work2.st.x, work2.st.w);
}
if (((int)node1.flag & (int)node2.flag & 262144) != 0 && (((int)runtimeWorkSprite.flag ^ (int)work2.flag) & 16) != 0)
{
work2.flag ^= 16U;
work2.set_st(work2.st.x, work2.st.w, work2.st.z, work2.st.y);
break;
}
break;
case 514:
AppMain.AMS_AME_RUNTIME_WORK_LINE ameRuntimeWorkLine = (AppMain.AMS_AME_RUNTIME_WORK_LINE)work;
AppMain.AMS_AME_RUNTIME_WORK_LINE work3 = (AppMain.AMS_AME_RUNTIME_WORK_LINE)amsAmeCreateParam.work;
if (((int)node1.flag & (int)node2.flag & 131072) != 0 && (((int)ameRuntimeWorkLine.flag ^ (int)work3.flag) & 8) != 0)
{
work3.flag ^= 8U;
work3.set_st(work3.st.z, work3.st.y, work3.st.x, work3.st.w);
}
if (((int)node1.flag & (int)node2.flag & 262144) != 0 && (((int)ameRuntimeWorkLine.flag ^ (int)work3.flag) & 16) != 0)
{
work3.flag ^= 16U;
work3.set_st(work3.st.x, work3.st.w, work3.st.z, work3.st.y);
break;
}
break;
case 515:
AppMain.AMS_AME_RUNTIME_WORK_PLANE runtimeWorkPlane = (AppMain.AMS_AME_RUNTIME_WORK_PLANE)work;
AppMain.AMS_AME_RUNTIME_WORK_PLANE work4 = (AppMain.AMS_AME_RUNTIME_WORK_PLANE)amsAmeCreateParam.work;
if (((int)node1.flag & (int)node2.flag & 131072) != 0 && (((int)runtimeWorkPlane.flag ^ (int)work4.flag) & 8) != 0)
{
work4.flag ^= 8U;
work4.set_st(work4.st.z, work4.st.y, work4.st.x, work4.st.w);
}
if (((int)node1.flag & (int)node2.flag & 262144) != 0 && (((int)runtimeWorkPlane.flag ^ (int)work4.flag) & 16) != 0)
{
work4.flag ^= 16U;
work4.set_st(work4.st.x, work4.st.w, work4.st.z, work4.st.y);
break;
}
break;
}
}
AppMain.GlobalPool <AppMain.AMS_AME_CREATE_PARAM> .Release(amsAmeCreateParam);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(pVec);
}
private static int _amUpdateOmni(object r)
{
AppMain.AMS_AME_RUNTIME amsAmeRuntime1 = (AppMain.AMS_AME_RUNTIME)r;
AppMain.AMS_AME_NODE_OMNI node = (AppMain.AMS_AME_NODE_OMNI)amsAmeRuntime1.node;
AppMain.AMS_AME_RUNTIME_WORK_OMNI work = (AppMain.AMS_AME_RUNTIME_WORK_OMNI)amsAmeRuntime1.work;
work.time += AppMain._am_unit_frame;
if ((double)work.time <= 0.0)
{
return(0);
}
if ((double)node.life != -1.0 && (double)work.time >= (double)node.life)
{
return(1);
}
AppMain.NNS_VECTOR4D amEffectVel = AppMain._amEffect_vel;
AppMain.amVectorScale(ref amEffectVel, work.velocity, AppMain._am_unit_time);
AppMain.amVectorAdd(ref work.position, amEffectVel);
float sizeRate = amsAmeRuntime1.ecb.size_rate;
work.offset = node.offset * sizeRate;
work.offset_chaos = node.offset_chaos * sizeRate;
AppMain.NNS_VECTOR4D amEffectPosition = AppMain._amEffect_position;
AppMain.NNS_VECTOR4D amEffectVelocity = AppMain._amEffect_velocity;
AppMain.NNS_VECTOR4D amEffectDirection = AppMain._amEffect_direction;
AppMain.AMS_AME_LIST next = amsAmeRuntime1.child_head.next;
for (AppMain.AMS_AME_LIST childTail = amsAmeRuntime1.child_tail; next != childTail; next = next.next)
{
AppMain.AMS_AME_RUNTIME amsAmeRuntime2 = (AppMain.AMS_AME_RUNTIME)next;
amsAmeRuntime2.amount += node.frequency * AppMain._am_unit_frame;
while ((double)amsAmeRuntime2.amount >= 1.0)
{
--amsAmeRuntime2.amount;
++amsAmeRuntime2.count;
if ((double)node.max_count != -1.0 && (double)((int)amsAmeRuntime2.work_num + (int)amsAmeRuntime2.active_num) < (double)node.max_count)
{
AppMain.AMS_AME_CREATE_PARAM effectCreateParam = AppMain._amEffect_create_param;
effectCreateParam.Clear();
AppMain.amVectorRandom(ref amEffectDirection);
AppMain.amVectorScale(ref amEffectVelocity, amEffectDirection, work.offset + work.offset_chaos * AppMain.nnRandom());
amEffectPosition.Assign(amEffectVelocity);
AppMain.amVectorScale(ref amEffectVelocity, amEffectDirection, node.speed + node.speed_chaos * AppMain.nnRandom());
effectCreateParam.ecb = amsAmeRuntime1.ecb;
effectCreateParam.runtime = amsAmeRuntime2;
effectCreateParam.node = amsAmeRuntime2.node;
effectCreateParam.parent_position = work.position;
effectCreateParam.parent_velocity = work.velocity;
effectCreateParam.position = amEffectPosition;
effectCreateParam.velocity = amEffectVelocity;
switch (AppMain.AMD_AME_SUPER_CLASS_ID(amsAmeRuntime2.node))
{
case 256:
AppMain._amCreateEmitter(effectCreateParam);
continue;
case 512:
AppMain._amCreateParticle(effectCreateParam);
continue;
default:
continue;
}
}
}
}
return(0);
}
private void amEffectCreateParticle(AppMain.AMS_AME_CREATE_PARAM param)
{
AppMain._amCreateParticle(param);
}
private static int _amUpdateCircle(object rr)
{
AppMain.AMS_AME_RUNTIME amsAmeRuntime1 = (AppMain.AMS_AME_RUNTIME)rr;
AppMain.AMS_AME_NODE_CIRCLE node = (AppMain.AMS_AME_NODE_CIRCLE)amsAmeRuntime1.node;
AppMain.AMS_AME_RUNTIME_WORK_CIRCLE work = (AppMain.AMS_AME_RUNTIME_WORK_CIRCLE)amsAmeRuntime1.work;
work.time += AppMain._am_unit_frame;
if ((double)work.time <= 0.0)
{
return(0);
}
if ((double)node.life != -1.0 && (double)work.time >= (double)node.life)
{
return(1);
}
AppMain.NNS_VECTOR4D nnsVectoR4D1 = new AppMain.NNS_VECTOR4D();
AppMain.amVectorScale(nnsVectoR4D1, work.velocity, AppMain._am_unit_time);
AppMain.amVectorAdd(work.position, nnsVectoR4D1);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D1);
float sizeRate = amsAmeRuntime1.ecb.size_rate;
work.spread += node.spread_variation * AppMain._am_unit_time;
if ((double)node.radius_variation != 0.0)
{
work.radius += node.radius_variation * AppMain._am_unit_time;
}
else
{
work.radius = node.radius * sizeRate;
}
work.offset = node.offset * sizeRate;
work.offset_chaos = node.offset_chaos * sizeRate;
AppMain.NNS_MATRIX amUpdateCircleMtx = AppMain._amUpdateCircle_mtx;
AppMain.nnMakeUnitMatrix(amUpdateCircleMtx);
AppMain.amMatrixPush(amUpdateCircleMtx);
AppMain.NNS_QUATERNION rotate = work.rotate;
AppMain.amQuatToMatrix((AppMain.NNS_MATRIX)null, ref rotate, null);
work.rotate = rotate;
AppMain.NNS_VECTOR4D nnsVectoR4D2 = new AppMain.NNS_VECTOR4D();
AppMain.NNS_VECTOR4D nnsVectoR4D3 = new AppMain.NNS_VECTOR4D();
AppMain.NNS_VECTOR4D nnsVectoR4D4 = new AppMain.NNS_VECTOR4D();
AppMain.AMS_AME_LIST next = amsAmeRuntime1.child_head.next;
for (AppMain.AMS_AME_LIST childTail = amsAmeRuntime1.child_tail; next != childTail; next = next.next)
{
AppMain.AMS_AME_RUNTIME amsAmeRuntime2 = (AppMain.AMS_AME_RUNTIME)next;
amsAmeRuntime2.amount += node.frequency * AppMain._am_unit_frame;
while ((double)amsAmeRuntime2.amount >= 1.0)
{
--amsAmeRuntime2.amount;
++amsAmeRuntime2.count;
if ((double)node.max_count != -1.0 && (double)((int)amsAmeRuntime2.work_num + (int)amsAmeRuntime2.active_num) < (double)node.max_count)
{
AppMain.AMS_AME_CREATE_PARAM amsAmeCreateParam = new AppMain.AMS_AME_CREATE_PARAM();
AppMain.amVectorSet(nnsVectoR4D4, 0.0f, 1f, 0.0f);
float radius = work.radius;
int angle = (int)((double)AppMain.nnRandom() * 10000000.0);
if (((int)node.flag & 1) == 0)
{
radius *= AppMain.nnRandom();
}
else if (((int)node.flag & 2) != 0)
{
int maxCount = (int)node.max_count;
angle = (int)((long)((int)ushort.MaxValue / maxCount) * ((long)amsAmeRuntime2.count % (long)maxCount));
}
float pSn;
float pCs;
AppMain.amSinCos(angle, out pSn, out pCs);
AppMain.amVectorSet(nnsVectoR4D2, pSn * radius, 0.0f, pCs * radius);
AppMain.NNS_VECTOR4D nnsVectoR4D5 = new AppMain.NNS_VECTOR4D();
AppMain.NNS_QUATERNION pQuat = new AppMain.NNS_QUATERNION();
AppMain.amVectorOuterProduct(nnsVectoR4D5, nnsVectoR4D4, nnsVectoR4D2);
double num = (double)AppMain.amVectorUnit(nnsVectoR4D5);
AppMain.amQuatRotAxisToQuat(ref pQuat, nnsVectoR4D5, AppMain.NNM_DEGtoRAD((int)work.spread));
AppMain.amQuatMultiVector(nnsVectoR4D4, nnsVectoR4D4, ref pQuat, null);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D5);
AppMain.amMatrixCalcVector(nnsVectoR4D2, nnsVectoR4D2);
AppMain.amMatrixCalcVector(nnsVectoR4D4, nnsVectoR4D4);
AppMain.amVectorScale(nnsVectoR4D3, nnsVectoR4D4, work.offset + work.offset_chaos * AppMain.nnRandom());
AppMain.amVectorAdd(nnsVectoR4D2, nnsVectoR4D3);
AppMain.amVectorScale(nnsVectoR4D3, nnsVectoR4D4, node.speed + node.speed_chaos * AppMain.nnRandom());
amsAmeCreateParam.ecb = amsAmeRuntime1.ecb;
amsAmeCreateParam.runtime = amsAmeRuntime2;
amsAmeCreateParam.node = amsAmeRuntime2.node;
amsAmeCreateParam.parent_position = work.position;
amsAmeCreateParam.parent_velocity = work.velocity;
amsAmeCreateParam.position = nnsVectoR4D2;
amsAmeCreateParam.velocity = nnsVectoR4D3;
switch (AppMain.AMD_AME_NODE_TYPE(amsAmeRuntime2.node) & 65280)
{
case 256:
AppMain._amCreateEmitter(amsAmeCreateParam);
continue;
case 512:
AppMain._amCreateParticle(amsAmeCreateParam);
continue;
default:
continue;
}
}
}
}
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D2);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D3);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D4);
AppMain.amMatrixPop();
return(0);
}
private static int _amUpdateSurface(object r)
{
AppMain.AMS_AME_RUNTIME amsAmeRuntime1 = (AppMain.AMS_AME_RUNTIME)r;
AppMain.AMS_AME_NODE_SURFACE node = (AppMain.AMS_AME_NODE_SURFACE)amsAmeRuntime1.node;
AppMain.AMS_AME_RUNTIME_WORK_SURFACE work = (AppMain.AMS_AME_RUNTIME_WORK_SURFACE)amsAmeRuntime1.work;
work.time += AppMain._am_unit_frame;
if ((double)work.time <= 0.0)
{
return(0);
}
if ((double)node.life != -1.0 && (double)work.time >= (double)node.life)
{
return(1);
}
AppMain.NNS_VECTOR4D amEffectVel = AppMain._amEffect_vel;
AppMain.amVectorScale(amEffectVel, work.velocity, AppMain._am_unit_time);
AppMain.amVectorAdd(work.position, amEffectVel);
float sizeRate = amsAmeRuntime1.ecb.size_rate;
if ((double)node.width_variation != 0.0 || (double)node.height_variation != 0.0)
{
work.width += node.width_variation * AppMain._am_unit_time;
work.height += node.height_variation * AppMain._am_unit_time;
}
else
{
work.width = node.width * sizeRate;
work.height = node.height * sizeRate;
}
work.offset = node.offset * sizeRate;
work.offset_chaos = node.offset_chaos * sizeRate;
AppMain.NNS_MATRIX amEffectMtx = AppMain._amEffect_mtx;
AppMain.nnMakeUnitMatrix(amEffectMtx);
AppMain.amMatrixPush(amEffectMtx);
AppMain.NNS_QUATERNION rotate = work.rotate;
AppMain.amQuatToMatrix((AppMain.NNS_MATRIX)null, ref rotate, null);
work.rotate = rotate;
AppMain.NNS_VECTOR4D amEffectPosition = AppMain._amEffect_position;
AppMain.NNS_VECTOR4D amEffectVelocity = AppMain._amEffect_velocity;
AppMain.NNS_VECTOR4D amEffectDirection = AppMain._amEffect_direction;
AppMain.AMS_AME_LIST next = amsAmeRuntime1.child_head.next;
for (AppMain.AMS_AME_LIST childTail = amsAmeRuntime1.child_tail; next != childTail; next = next.next)
{
AppMain.AMS_AME_RUNTIME amsAmeRuntime2 = (AppMain.AMS_AME_RUNTIME)next;
amsAmeRuntime2.amount += node.frequency * AppMain._am_unit_frame;
while ((double)amsAmeRuntime2.amount >= 1.0)
{
--amsAmeRuntime2.amount;
++amsAmeRuntime2.count;
if ((double)node.max_count != -1.0 && (double)((int)amsAmeRuntime2.work_num + (int)amsAmeRuntime2.active_num) < (double)node.max_count)
{
AppMain.AMS_AME_CREATE_PARAM effectCreateParam = AppMain._amEffect_create_param;
AppMain.amVectorSet(amEffectDirection, 0.0f, 1f, 0.0f);
float num1 = (float)((double)AppMain.nnRandom() / 2.0 + (double)AppMain.nnRandom() * 0.5);
float x = (float)((double)work.width * (double)num1 - (double)work.width * 0.5);
float num2 = (float)((double)AppMain.nnRandom() / 2.0 + (double)AppMain.nnRandom() * 0.5);
float z = (float)((double)work.height * (double)num2 - (double)work.height * 0.5);
if (((int)node.flag & 1) != 0)
{
float num3 = AppMain.nnRandom();
bool flag = false;
if ((double)AppMain.nnRandom() > 0.5)
{
flag = true;
}
if ((double)num3 > 0.5)
{
float num4 = work.width * 0.5f;
x = (double)num4 <= 0.0 || !flag ? num4 : -num4;
}
else
{
float num4 = work.height * 0.5f;
z = (double)num4 <= 0.0 || !flag ? num4 : -num4;
}
}
AppMain.amVectorSet(amEffectPosition, x, 0.0f, z);
AppMain.amMatrixCalcPoint(amEffectPosition, amEffectPosition);
AppMain.amMatrixCalcPoint(amEffectDirection, amEffectDirection);
AppMain.amVectorScale(amEffectVelocity, amEffectDirection, work.offset + work.offset_chaos * AppMain.nnRandom());
AppMain.amVectorAdd(amEffectPosition, amEffectVelocity);
AppMain.amVectorScale(amEffectVelocity, amEffectDirection, node.speed + node.speed_chaos * AppMain.nnRandom());
effectCreateParam.ecb = amsAmeRuntime1.ecb;
effectCreateParam.runtime = amsAmeRuntime2;
effectCreateParam.node = amsAmeRuntime2.node;
effectCreateParam.parent_position = work.position;
effectCreateParam.parent_velocity = work.velocity;
effectCreateParam.position = amEffectPosition;
effectCreateParam.velocity = amEffectVelocity;
switch (AppMain.AMD_AME_NODE_TYPE(amsAmeRuntime2.node) & 65280)
{
case 256:
AppMain._amCreateEmitter(effectCreateParam);
continue;
case 512:
AppMain._amCreateParticle(effectCreateParam);
continue;
default:
continue;
}
}
}
}
AppMain.amMatrixPop();
return(0);
}
private static int _amUpdateDirectional(object r)
{
AppMain.AMS_AME_RUNTIME amsAmeRuntime1 = (AppMain.AMS_AME_RUNTIME)r;
AppMain.AMS_AME_NODE_DIRECTIONAL node = (AppMain.AMS_AME_NODE_DIRECTIONAL)amsAmeRuntime1.node;
AppMain.AMS_AME_RUNTIME_WORK_DIRECTIONAL runtimeWorkDirectional = new AppMain.AMS_AME_RUNTIME_WORK_DIRECTIONAL(amsAmeRuntime1.work);
runtimeWorkDirectional.time += AppMain._am_unit_frame;
if ((double)runtimeWorkDirectional.time <= 0.0)
{
return(0);
}
if ((double)node.life != -1.0 && (double)runtimeWorkDirectional.time >= (double)node.life)
{
return(1);
}
AppMain.NNS_VECTOR4D amEffectVel = AppMain._amEffect_vel;
AppMain.amVectorScale(ref amEffectVel, runtimeWorkDirectional.velocity, AppMain._am_unit_time);
AppMain.amVectorAdd(ref runtimeWorkDirectional.position, amEffectVel);
runtimeWorkDirectional.spread += node.spread_variation * AppMain._am_unit_time;
AppMain.NNS_MATRIX amEffectMtx = AppMain._amEffect_mtx;
AppMain.nnMakeUnitMatrix(amEffectMtx);
AppMain.amMatrixPush(amEffectMtx);
AppMain.NNS_QUATERNION rotate = runtimeWorkDirectional.rotate;
AppMain.amQuatToMatrix((AppMain.NNS_MATRIX)null, ref rotate, null);
runtimeWorkDirectional.rotate = rotate;
AppMain.AMS_AME_LIST next = amsAmeRuntime1.child_head.next;
AppMain.AMS_AME_LIST childTail = amsAmeRuntime1.child_tail;
AppMain.NNS_VECTOR4D amEffectPosition = AppMain._amEffect_position;
AppMain.NNS_VECTOR4D amEffectVelocity = AppMain._amEffect_velocity;
AppMain.NNS_VECTOR4D amEffectDirection = AppMain._amEffect_direction;
for (; next != childTail; next = next.next)
{
AppMain.AMS_AME_RUNTIME amsAmeRuntime2 = (AppMain.AMS_AME_RUNTIME)next;
amsAmeRuntime2.amount += node.frequency * AppMain._am_unit_frame;
while ((double)amsAmeRuntime2.amount >= 1.0)
{
--amsAmeRuntime2.amount;
++amsAmeRuntime2.count;
if ((double)node.max_count != -1.0 && (double)((int)amsAmeRuntime2.work_num + (int)amsAmeRuntime2.active_num) < (double)node.max_count)
{
AppMain.AMS_AME_CREATE_PARAM effectCreateParam = AppMain._amEffect_create_param;
effectCreateParam.Clear();
AppMain.amEffectRandomConeVectorDeg(ref amEffectDirection, runtimeWorkDirectional.spread);
AppMain.amMatrixCalcPoint(amEffectDirection, amEffectDirection);
AppMain.amVectorScale(ref amEffectVelocity, ref amEffectDirection, node.offset + node.offset_chaos * AppMain.nnRandom());
amEffectPosition.Assign(amEffectVelocity);
AppMain.amVectorScale(ref amEffectVelocity, ref amEffectDirection, node.speed + node.speed_chaos * AppMain.nnRandom());
effectCreateParam.ecb = amsAmeRuntime1.ecb;
effectCreateParam.runtime = amsAmeRuntime2;
effectCreateParam.node = amsAmeRuntime2.node;
effectCreateParam.parent_position = runtimeWorkDirectional.position;
effectCreateParam.parent_velocity = runtimeWorkDirectional.velocity;
effectCreateParam.position = amEffectPosition;
effectCreateParam.velocity = amEffectVelocity;
switch (AppMain.AMD_AME_SUPER_CLASS_ID(amsAmeRuntime2.node))
{
case 256:
AppMain._amCreateEmitter(effectCreateParam);
continue;
case 512:
AppMain._amCreateParticle(effectCreateParam);
continue;
default:
continue;
}
}
}
}
AppMain.amMatrixPop();
return(0);
}
public static int _amInitPlane(object p)
{
AppMain.AMS_AME_CREATE_PARAM amsAmeCreateParam = (AppMain.AMS_AME_CREATE_PARAM)p;
AppMain.AMS_AME_NODE_PLANE node = (AppMain.AMS_AME_NODE_PLANE)amsAmeCreateParam.node;
AppMain.AMS_AME_RUNTIME_WORK_PLANE work = (AppMain.AMS_AME_RUNTIME_WORK_PLANE)amsAmeCreateParam.work;
work.time = -node.start_time;
AppMain.AMS_RGBA8888 colorStart = node.color_start;
work.set_color(colorStart.r, colorStart.g, colorStart.b, (byte)((int)colorStart.a * amsAmeCreateParam.ecb.transparency >> 8));
AppMain.amVectorAdd(work.position, amsAmeCreateParam.parent_position.Value, amsAmeCreateParam.position.Value);
AppMain.amVectorAdd(work.position, node.translate);
AppMain.amVectorScale(work.velocity, amsAmeCreateParam.parent_velocity.Value, node.inheritance_rate);
AppMain.amVectorAdd(work.velocity, amsAmeCreateParam.velocity.Value);
if (((int)node.flag & 4) != 0)
{
AppMain.NNS_VECTOR4D nnsVectoR4D = new AppMain.NNS_VECTOR4D();
float radian = (float)((double)AppMain.nnRandom() * 2.0 * 3.14159274101257);
AppMain.amVectorRandom(nnsVectoR4D);
AppMain.NNS_QUATERNION rotate = work.rotate;
AppMain.amQuatRotAxisToQuat(ref rotate, nnsVectoR4D, radian);
work.rotate = rotate;
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D);
}
else
{
work.rotate = node.rotate;
}
if (((int)node.flag & 8) != 0)
{
AppMain.NNS_VECTOR4D pDst = new AppMain.NNS_VECTOR4D();
AppMain.amVectorRandom(pDst);
work.set_rotate_axis(pDst.x, pDst.y, pDst.z, node.rotate_axis.w);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(pDst);
}
else
{
work.rotate_axis.Assign(node.rotate_axis);
}
float z = node.size + node.size_chaos * AppMain.nnRandom();
work.set_size(z * node.scale_x_start, z * node.scale_y_start, z, 0.0f);
if (((int)node.flag & 32768) != 0)
{
work.tex_time = 0.0f;
work.tex_no = 0;
if (((int)node.flag & 524288) != 0)
{
work.tex_no = (int)(100.0 * (double)AppMain.nnRandom()) % node.tex_anim.key_num;
}
AppMain.AMS_AME_TEX_ANIM_KEY amsAmeTexAnimKey = node.tex_anim.key_buf[work.tex_no];
work.set_st(amsAmeTexAnimKey.l, amsAmeTexAnimKey.t, amsAmeTexAnimKey.r, amsAmeTexAnimKey.b);
}
else if (((int)node.flag & 8192) != 0)
{
work.set_st(node.cropping_l, node.cropping_t, node.cropping_r, node.cropping_b);
}
else
{
work.set_st(0.0f, 0.0f, 1f, 1f);
}
if (((int)node.flag & 1048576) != 0 || ((int)node.flag & 131072) != 0 && (double)AppMain.nnRandom() > 0.5)
{
work.flag |= 8U;
work.set_st(work.st.z, work.st.y, work.st.x, work.st.w);
}
if (((int)node.flag & 2097152) != 0 || ((int)node.flag & 262144) != 0 && (double)AppMain.nnRandom() > 0.5)
{
work.flag |= 16U;
work.set_st(work.st.x, work.st.w, work.st.z, work.st.y);
}
return(0);
}
