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 _amApplyDrag(
AppMain.AMS_AME_ECB ecb,
AppMain.AMS_AME_NODE node,
AppMain.AMS_AME_RUNTIME_WORK work)
{
AppMain.AMS_AME_NODE_DRAG amsAmeNodeDrag = (AppMain.AMS_AME_NODE_DRAG)node;
float amUnitTime = AppMain._am_unit_time;
AppMain.NNS_VECTOR4D nnsVectoR4D1 = new AppMain.NNS_VECTOR4D();
AppMain.NNS_VECTOR4D nnsVectoR4D2 = new AppMain.NNS_VECTOR4D();
AppMain.NNS_VECTOR4D nnsVectoR4D3 = new AppMain.NNS_VECTOR4D();
AppMain.amVectorCopy(nnsVectoR4D3, amsAmeNodeDrag.position);
if (((int)amsAmeNodeDrag.flag & 1) != 0)
{
AppMain.amVectorAdd(nnsVectoR4D3, ecb.translate);
}
AppMain.amVectorSub(nnsVectoR4D2, work.position, nnsVectoR4D3);
double num = (double)AppMain.amVectorUnit(nnsVectoR4D2);
AppMain.amVectorScale(nnsVectoR4D1, nnsVectoR4D2, (float)((double)amsAmeNodeDrag.magnitude * (double)amUnitTime * (double)amUnitTime * 0.5));
AppMain.amVectorAdd(work.position, nnsVectoR4D1);
AppMain.amVectorScale(nnsVectoR4D1, nnsVectoR4D2, amsAmeNodeDrag.magnitude * amUnitTime);
AppMain.amVectorAdd(work.velocity, nnsVectoR4D1);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D1);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D2);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D3);
}
private static uint _amEffectSetMaterial(
AppMain.AMS_AME_RUNTIME runtime,
ref int blend,
int NodeBlend)
{
AppMain.AMS_AME_NODE node = runtime.node;
uint num = 0;
if (((int)node.flag & 1) != 0)
{
num |= 8389632U;
switch (NodeBlend)
{
case 50:
blend = 0;
break;
case 162:
blend = 1;
break;
case 674:
blend = 2;
break;
}
}
return(num);
}
public static void _amApplyVortex(
AppMain.AMS_AME_ECB ecb,
AppMain.AMS_AME_NODE node,
AppMain.AMS_AME_RUNTIME_WORK work)
{
AppMain.AMS_AME_NODE_VORTEX amsAmeNodeVortex = (AppMain.AMS_AME_NODE_VORTEX)node;
AppMain.NNS_VECTOR4D nnsVectoR4D1 = new AppMain.NNS_VECTOR4D();
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.amVectorCopy(nnsVectoR4D1, amsAmeNodeVortex.position);
AppMain.amVectorCopy(nnsVectoR4D3, amsAmeNodeVortex.axis);
if (((int)amsAmeNodeVortex.flag & 1) != 0)
{
AppMain.amVectorAdd(nnsVectoR4D1, ecb.translate);
}
if (((int)amsAmeNodeVortex.flag & 2) != 0)
{
AppMain.amQuatMultiVector(nnsVectoR4D3, nnsVectoR4D3, ref ecb.rotate, null);
}
AppMain.amVectorSub(nnsVectoR4D2, work.position, nnsVectoR4D1);
AppMain.amVectorOuterProduct(nnsVectoR4D4, nnsVectoR4D3, nnsVectoR4D2);
AppMain.amVectorScale(nnsVectoR4D2, nnsVectoR4D4, AppMain._am_unit_time);
AppMain.amVectorAdd(work.velocity, nnsVectoR4D2);
AppMain.amVectorOuterProduct(nnsVectoR4D4, nnsVectoR4D3, nnsVectoR4D4);
AppMain.amVectorScale(nnsVectoR4D2, nnsVectoR4D4, AppMain._am_unit_time);
AppMain.amVectorAdd(work.velocity, nnsVectoR4D2);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D1);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D2);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D3);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D4);
}
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 AppMain.AMS_AME_ECB amEffectCreate(
AppMain.AMS_AME_NODE node,
int attribute,
int priority)
{
AppMain.mppAssertNotImpl();
return((AppMain.AMS_AME_ECB)null);
}
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 void Clear()
{
this.ecb = (AppMain.AMS_AME_ECB)null;
this.runtime = (AppMain.AMS_AME_RUNTIME)null;
this.node = (AppMain.AMS_AME_NODE)null;
this.work = (AppMain.AMS_AME_RUNTIME_WORK)null;
this.position = default;
this.velocity = default;
this.parent_position = default;
this.parent_velocity = default;
}
public static void _amApplyNoise(
AppMain.AMS_AME_ECB ecb,
AppMain.AMS_AME_NODE node,
AppMain.AMS_AME_RUNTIME_WORK work)
{
AppMain.AMS_AME_NODE_NOISE amsAmeNodeNoise = (AppMain.AMS_AME_NODE_NOISE)node;
float num = amsAmeNodeNoise.magnitude * AppMain._am_unit_time;
AppMain.SNNS_VECTOR4D pSrc;
pSrc.x = (AppMain.nnRandom() - 0.5f) * num * amsAmeNodeNoise.axis.x;
pSrc.y = (AppMain.nnRandom() - 0.5f) * num * amsAmeNodeNoise.axis.y;
pSrc.z = (AppMain.nnRandom() - 0.5f) * num * amsAmeNodeNoise.axis.z;
pSrc.w = 1f;
AppMain.amVectorAdd(work.position, ref pSrc);
}
public static void _amApplyUniform(
AppMain.AMS_AME_ECB ecb,
AppMain.AMS_AME_NODE node,
AppMain.AMS_AME_RUNTIME_WORK work)
{
AppMain.AMS_AME_NODE_UNIFORM amsAmeNodeUniform = (AppMain.AMS_AME_NODE_UNIFORM)node;
float amUnitTime = AppMain._am_unit_time;
AppMain.NNS_VECTOR4D nnsVectoR4D = new AppMain.NNS_VECTOR4D();
AppMain.amVectorScale(nnsVectoR4D, amsAmeNodeUniform.direction, amsAmeNodeUniform.magnitude * amUnitTime);
if (((int)amsAmeNodeUniform.flag & 2) != 0)
{
AppMain.amQuatMultiVector(nnsVectoR4D, nnsVectoR4D, ref ecb.rotate, null);
}
AppMain.amVectorAdd(work.position, nnsVectoR4D);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D);
}
private static void fillAMENodeBegin(
AppMain.AMS_AME_NODE node,
short id,
short type,
uint flag,
char[] name,
int child_offset,
int sibling_offset,
int parent_offset)
{
node.id = id;
node.type = type;
node.flag = flag;
Array.Copy((Array)name, 0, (Array)node.name, 0, 12);
node.child_offset = child_offset;
node.sibling_offset = sibling_offset;
node.parent_offset = parent_offset;
}
private static int _amEffectSetDrawMode(
AppMain.AMS_AME_RUNTIME runtime,
AppMain.AMS_PARAM_DRAW_PRIMITIVE param,
int NodeBlend)
{
AppMain.AMS_AME_NODE node = runtime.node;
int num = 0;
param.ablend = num;
param.aTest = ((int)node.flag & 2) == 0 ? (short)0 : (short)1;
param.zMask = ((int)node.flag & 33554432) == 0 ? (short)0 : (short)1;
param.zTest = ((int)node.flag & 16777216) != 0 ? (short)1 : (short)0;
if (((int)node.flag & 1) != 0)
{
num = 1;
param.ablend = num;
switch (NodeBlend)
{
case 50:
param.bldSrc = 770;
param.bldDst = 771;
param.bldMode = 32774;
break;
case 162:
param.bldSrc = 770;
param.bldDst = 1;
param.bldMode = 32774;
break;
case 674:
param.bldSrc = 770;
param.bldDst = 1;
param.bldMode = 32779;
break;
}
}
return(num);
}
public static void _amApplyGravity(
AppMain.AMS_AME_ECB ecb,
AppMain.AMS_AME_NODE node,
AppMain.AMS_AME_RUNTIME_WORK work)
{
AppMain.AMS_AME_NODE_GRAVITY amsAmeNodeGravity = (AppMain.AMS_AME_NODE_GRAVITY)node;
float amUnitTime = AppMain._am_unit_time;
AppMain.NNS_VECTOR4D nnsVectoR4D1 = new AppMain.NNS_VECTOR4D();
AppMain.NNS_VECTOR4D nnsVectoR4D2 = new AppMain.NNS_VECTOR4D();
AppMain.amVectorCopy(nnsVectoR4D2, amsAmeNodeGravity.direction);
if (((int)amsAmeNodeGravity.flag & 2) != 0)
{
AppMain.amQuatMultiVector(nnsVectoR4D2, nnsVectoR4D2, ref ecb.rotate, null);
}
AppMain.amVectorScale(nnsVectoR4D1, nnsVectoR4D2, (float)((double)amsAmeNodeGravity.magnitude * (double)amUnitTime * (double)amUnitTime * 0.5));
AppMain.amVectorAdd(work.position, nnsVectoR4D1);
AppMain.amVectorScale(nnsVectoR4D1, nnsVectoR4D2, amsAmeNodeGravity.magnitude * amUnitTime);
AppMain.amVectorAdd(work.velocity, nnsVectoR4D1);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D1);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D2);
}
private AppMain.AMS_AME_NODE amEffectSearchNode(AppMain.AMS_AME_NODE node, int id)
{
AppMain.mppAssertNotImpl();
AppMain.AMS_AME_NODE amsAmeNode = (AppMain.AMS_AME_NODE)null;
if ((int)node.id == id)
{
return(node);
}
if (node.child != null)
{
amsAmeNode = this.amEffectSearchNode(node.child, id);
if (amsAmeNode != null)
{
return(amsAmeNode);
}
}
if (node.sibling != null)
{
amsAmeNode = this.amEffectSearchNode(node.sibling, id);
}
return(amsAmeNode);
}
public new void Clear()
{
this.next = (AppMain.AMS_AME_LIST)null;
this.prev = (AppMain.AMS_AME_LIST)null;
this.state = 0;
this.amount = 0.0f;
this.count = 0U;
this.ecb = (AppMain.AMS_AME_ECB)null;
this.node = (AppMain.AMS_AME_NODE)null;
this.parent_runtime = (AppMain.AMS_AME_RUNTIME)null;
this.spawn_runtime = (AppMain.AMS_AME_RUNTIME)null;
this.work = (AppMain.AMS_AME_RUNTIME_WORK)null;
this.child_head.Clear();
this.child_tail.Clear();
this.child_num = 0;
this.work_head.Clear();
this.work_tail.Clear();
this.active_head.Clear();
this.active_tail.Clear();
this.work_num = (short)0;
this.active_num = (short)0;
this.texlist = (AppMain.NNS_TEXLIST)null;
}
public static void _amApplyRadial(
AppMain.AMS_AME_ECB ecb,
AppMain.AMS_AME_NODE node,
AppMain.AMS_AME_RUNTIME_WORK work)
{
AppMain.AMS_AME_NODE_RADIAL amsAmeNodeRadial = (AppMain.AMS_AME_NODE_RADIAL)node;
float amUnitTime = AppMain._am_unit_time;
AppMain.NNS_VECTOR4D nnsVectoR4D1 = new AppMain.NNS_VECTOR4D();
AppMain.NNS_VECTOR4D nnsVectoR4D2 = new AppMain.NNS_VECTOR4D();
AppMain.amVectorCopy(nnsVectoR4D2, amsAmeNodeRadial.position);
if (((int)amsAmeNodeRadial.flag & 1) != 0)
{
AppMain.amVectorAdd(nnsVectoR4D2, ecb.translate);
}
AppMain.amVectorSub(nnsVectoR4D1, work.position, nnsVectoR4D2);
float num1 = 1f / (float)Math.Pow((double)AppMain.amVectorScalor(nnsVectoR4D1), (double)amsAmeNodeRadial.attenuation);
double num2 = (double)AppMain.amVectorScaleUnit(nnsVectoR4D1, nnsVectoR4D1, amsAmeNodeRadial.magnitude * num1 * amUnitTime);
AppMain.amVectorAdd(work.position, nnsVectoR4D1);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D1);
//AppMain.GlobalPool<AppMain.NNS_VECTOR4D>.Release(nnsVectoR4D2);
}
public static AppMain.AMS_AME_RUNTIME _amCreateRuntimeGroup(
AppMain.AMS_AME_ECB ecb,
AppMain.AMS_AME_NODE node)
{
AppMain.AMS_AME_RUNTIME runtime = AppMain._amAllocRuntime();
runtime.ecb = ecb;
runtime.node = 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;
for (AppMain.AMS_AME_NODE node1 = node.child; node1 != null; node1 = node1.sibling)
{
if (AppMain.AMD_AME_IS_PARTICLE(node1))
{
runtime.spawn_runtime = AppMain._amCreateRuntimeGroup(ecb, node1);
break;
}
}
AppMain._amAddEntry(ecb, runtime);
return(runtime);
}
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 AppMain.AMS_AME_ECB amEffectCreate(AppMain.AMS_AME_NODE node)
{
return(this.amEffectCreate(node, 0, 0));
}
public static void amEffectUpdate(AppMain.AMS_AME_ECB ecb)
{
if (ecb.entry_num <= 0)
{
return;
}
if (ecb.skip_update != 0)
{
ecb.skip_update = 0;
}
for (AppMain.AMS_AME_ENTRY amsAmeEntry = ecb.entry_head; amsAmeEntry != null; amsAmeEntry = (AppMain.AMS_AME_ENTRY)amsAmeEntry.next)
{
AppMain.AMS_AME_RUNTIME runtime = amsAmeEntry.runtime;
AppMain.AMS_AME_NODE node1 = runtime.node;
int num1 = AppMain.AMD_AME_NODE_TYPE(node1);
if ((runtime.state & 16384) != 0 && (int)runtime.work_num + (int)runtime.active_num == 0)
{
if (runtime.spawn_runtime != null)
{
runtime.spawn_runtime.state |= 16384;
}
runtime.state |= 32768;
}
else
{
switch (num1 & 65280)
{
case 256:
if (runtime.work != null)
{
AppMain.AmeDelegateFunc ameDelegateFunc = AppMain._am_emitter_func[((num1 & (int)byte.MaxValue) << 2) + 1];
if (runtime.work != null)
{
if (ameDelegateFunc((object)runtime) != 0)
{
runtime.state |= 32768;
AppMain.AMS_AME_LIST next = runtime.child_head.next;
for (AppMain.AMS_AME_LIST childTail = runtime.child_tail; next != childTail; next = next.next)
{
((AppMain.AMS_AME_RUNTIME)next).state |= 16384;
}
if (runtime.parent_runtime != null)
{
AppMain.amEffectDisconnectLink((AppMain.AMS_AME_LIST)runtime);
--runtime.parent_runtime.work_num;
continue;
}
continue;
}
for (AppMain.AMS_AME_NODE node2 = node1.child; node2 != null; node2 = node2.sibling)
{
if (AppMain.AMD_AME_IS_FIELD(node2))
{
AppMain._am_field_func[AppMain.AMD_AME_NODE_TYPE(node2) & (int)byte.MaxValue](runtime.ecb, node2, runtime.work);
}
}
continue;
}
continue;
}
continue;
case 512:
if (runtime.work_num != (short)0)
{
AppMain.AMS_AME_RUNTIME_WORK next = (AppMain.AMS_AME_RUNTIME_WORK)runtime.work_head.next;
AppMain.AMS_AME_RUNTIME_WORK workTail = (AppMain.AMS_AME_RUNTIME_WORK)runtime.work_tail;
while (next != workTail)
{
AppMain.AMS_AME_RUNTIME_WORK amsAmeRuntimeWork = next;
next = (AppMain.AMS_AME_RUNTIME_WORK)next.next;
amsAmeRuntimeWork.time += AppMain._am_unit_frame;
if ((double)amsAmeRuntimeWork.time > 0.0)
{
amsAmeRuntimeWork.time -= AppMain._am_unit_frame;
AppMain.amEffectDisconnectLink((AppMain.AMS_AME_LIST)amsAmeRuntimeWork);
AppMain._amConnectLinkToTail(runtime.active_tail, (AppMain.AMS_AME_LIST)amsAmeRuntimeWork);
--runtime.work_num;
++runtime.active_num;
}
}
}
int num2 = AppMain._am_particle_func[((num1 & (int)byte.MaxValue) << 2) + 1]((object)runtime);
AppMain.AMS_AME_RUNTIME_WORK next1 = (AppMain.AMS_AME_RUNTIME_WORK)runtime.active_head.next;
AppMain.AMS_AME_LIST activeTail = runtime.active_tail;
AppMain.AMS_AME_RUNTIME_WORK work;
for (AppMain.AMS_AME_LIST next2 = runtime.active_head.next; next2 != activeTail; next2 = work.next)
{
work = (AppMain.AMS_AME_RUNTIME_WORK)next2;
for (AppMain.AMS_AME_NODE node2 = node1.child; node2 != null; node2 = node2.sibling)
{
if (AppMain.AMD_AME_IS_FIELD(node2))
{
AppMain._am_field_func[AppMain.AMD_AME_NODE_TYPE(node2) & (int)byte.MaxValue](runtime.ecb, node2, work);
}
}
}
continue;
default:
continue;
}
}
}
for (AppMain.AMS_AME_ENTRY entry = ecb.entry_head; entry != null; entry = (AppMain.AMS_AME_ENTRY)entry.next)
{
if ((entry.runtime.state & 32768) != 0)
{
AppMain._amFreeRuntime(entry.runtime);
AppMain._amDelEntry(ecb, entry);
}
}
if (ecb.entry_num != 0)
{
return;
}
AppMain.amEffectDelete(ecb);
}
public static int AMD_AME_NODE_TYPE(AppMain.AMS_AME_NODE node)
{
return((int)node.type);
}
public static bool AMD_AME_IS_PARTICLE(AppMain.AMS_AME_NODE node)
{
return(AppMain.AMD_AME_SUPER_CLASS_ID(node) == 512);
}
public static bool AMD_AME_IS_EMITTER(AppMain.AMS_AME_NODE node)
{
return(AppMain.AMD_AME_SUPER_CLASS_ID(node) == 256);
}
public static int AMD_AME_CLASS_ID(AppMain.AMS_AME_NODE node)
{
return((int)(ushort)node.type & (int)byte.MaxValue);
}
public static int AMD_AME_SUPER_CLASS_ID(AppMain.AMS_AME_NODE node)
{
return((int)(ushort)node.type & 65280);
}
public static bool AMD_AME_IS_FIELD(AppMain.AMS_AME_NODE node)
{
return(AppMain.AMD_AME_SUPER_CLASS_ID(node) == 768);
}
public static AppMain.AMS_AME_HEADER readAMEfile(BinaryReader br)
{
AppMain.AMS_AME_HEADER amsAmeHeader = new AppMain.AMS_AME_HEADER();
amsAmeHeader.file_id = br.ReadBytes(4);
amsAmeHeader.file_version = br.ReadInt32();
amsAmeHeader.node_num = br.ReadInt32();
amsAmeHeader.node_ofst = br.ReadUInt32();
amsAmeHeader.bounding.center.x = br.ReadSingle();
amsAmeHeader.bounding.center.y = br.ReadSingle();
amsAmeHeader.bounding.center.z = br.ReadSingle();
amsAmeHeader.bounding.center.w = br.ReadSingle();
amsAmeHeader.bounding.radius = br.ReadSingle();
amsAmeHeader.bounding.radius2 = br.ReadSingle();
br.BaseStream.Seek(8L, SeekOrigin.Current);
br.BaseStream.Seek(16L, SeekOrigin.Current);
amsAmeHeader.node = new AppMain.AMS_AME_NODE[amsAmeHeader.node_num];
br.BaseStream.Seek((long)amsAmeHeader.node_ofst, SeekOrigin.Begin);
Dictionary <uint, AppMain.AMS_AME_NODE> dictionary = new Dictionary <uint, AppMain.AMS_AME_NODE>(amsAmeHeader.node_num);
for (int index1 = 0; index1 < amsAmeHeader.node_num; ++index1)
{
uint index2 = (uint)br.BaseStream.Position + 15U & 4294967280U;
if ((long)index2 < br.BaseStream.Length)
{
br.BaseStream.Seek((long)index2, SeekOrigin.Begin);
short id = br.ReadInt16();
AppMain.AME_AME_NODE_TYPE ameAmeNodeType = (AppMain.AME_AME_NODE_TYPE)br.ReadInt16();
uint flag = br.ReadUInt32();
char[] name = br.ReadChars(12);
int child_offset = br.ReadInt32();
int sibling_offset = br.ReadInt32();
int parent_offset = br.ReadInt32();
switch (ameAmeNodeType)
{
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_OMNI:
AppMain.AMS_AME_NODE_OMNI amsAmeNodeOmni = new AppMain.AMS_AME_NODE_OMNI();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)amsAmeNodeOmni, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, amsAmeNodeOmni.translate);
AppMain.readQuaternion(br, ref amsAmeNodeOmni.rotate);
amsAmeNodeOmni.inheritance_rate = br.ReadSingle();
amsAmeNodeOmni.life = br.ReadSingle();
amsAmeNodeOmni.start_time = br.ReadSingle();
amsAmeNodeOmni.offset = br.ReadSingle();
amsAmeNodeOmni.offset_chaos = br.ReadSingle();
amsAmeNodeOmni.speed = br.ReadSingle();
amsAmeNodeOmni.speed_chaos = br.ReadSingle();
amsAmeNodeOmni.max_count = br.ReadSingle();
amsAmeNodeOmni.frequency = br.ReadSingle();
dictionary[index2] = (AppMain.AMS_AME_NODE)amsAmeNodeOmni;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)amsAmeNodeOmni;
break;
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_DIRECTIONAL:
AppMain.AMS_AME_NODE_DIRECTIONAL ameNodeDirectional = new AppMain.AMS_AME_NODE_DIRECTIONAL();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)ameNodeDirectional, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, ameNodeDirectional.translate);
AppMain.readQuaternion(br, ref ameNodeDirectional.rotate);
ameNodeDirectional.inheritance_rate = br.ReadSingle();
ameNodeDirectional.life = br.ReadSingle();
ameNodeDirectional.start_time = br.ReadSingle();
ameNodeDirectional.offset = br.ReadSingle();
ameNodeDirectional.offset_chaos = br.ReadSingle();
ameNodeDirectional.speed = br.ReadSingle();
ameNodeDirectional.speed_chaos = br.ReadSingle();
ameNodeDirectional.max_count = br.ReadSingle();
ameNodeDirectional.frequency = br.ReadSingle();
ameNodeDirectional.spread = br.ReadSingle();
ameNodeDirectional.spread_variation = br.ReadSingle();
dictionary[index2] = (AppMain.AMS_AME_NODE)ameNodeDirectional;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)ameNodeDirectional;
break;
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_SURFACE:
AppMain.AMS_AME_NODE_SURFACE amsAmeNodeSurface = new AppMain.AMS_AME_NODE_SURFACE();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)amsAmeNodeSurface, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, amsAmeNodeSurface.translate);
AppMain.readQuaternion(br, ref amsAmeNodeSurface.rotate);
amsAmeNodeSurface.inheritance_rate = br.ReadSingle();
amsAmeNodeSurface.life = br.ReadSingle();
amsAmeNodeSurface.start_time = br.ReadSingle();
amsAmeNodeSurface.offset = br.ReadSingle();
amsAmeNodeSurface.offset_chaos = br.ReadSingle();
amsAmeNodeSurface.speed = br.ReadSingle();
amsAmeNodeSurface.speed_chaos = br.ReadSingle();
amsAmeNodeSurface.max_count = br.ReadSingle();
amsAmeNodeSurface.frequency = br.ReadSingle();
amsAmeNodeSurface.width = br.ReadSingle();
amsAmeNodeSurface.width_variation = br.ReadSingle();
amsAmeNodeSurface.height = br.ReadSingle();
amsAmeNodeSurface.height_variation = br.ReadSingle();
dictionary[index2] = (AppMain.AMS_AME_NODE)amsAmeNodeSurface;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)amsAmeNodeSurface;
break;
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_CIRCLE:
AppMain.AMS_AME_NODE_CIRCLE amsAmeNodeCircle = new AppMain.AMS_AME_NODE_CIRCLE();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)amsAmeNodeCircle, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, amsAmeNodeCircle.translate);
AppMain.readQuaternion(br, ref amsAmeNodeCircle.rotate);
amsAmeNodeCircle.inheritance_rate = br.ReadSingle();
amsAmeNodeCircle.life = br.ReadSingle();
amsAmeNodeCircle.start_time = br.ReadSingle();
amsAmeNodeCircle.offset = br.ReadSingle();
amsAmeNodeCircle.offset_chaos = br.ReadSingle();
amsAmeNodeCircle.speed = br.ReadSingle();
amsAmeNodeCircle.speed_chaos = br.ReadSingle();
amsAmeNodeCircle.max_count = br.ReadSingle();
amsAmeNodeCircle.frequency = br.ReadSingle();
amsAmeNodeCircle.spread = br.ReadSingle();
amsAmeNodeCircle.spread_variation = br.ReadSingle();
amsAmeNodeCircle.radius = br.ReadSingle();
amsAmeNodeCircle.radius_variation = br.ReadSingle();
dictionary[index2] = (AppMain.AMS_AME_NODE)amsAmeNodeCircle;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)amsAmeNodeCircle;
break;
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_SIMPLE_SPRITE:
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_SPRITE:
AppMain.AMS_AME_NODE_SPRITE amsAmeNodeSprite = new AppMain.AMS_AME_NODE_SPRITE();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)amsAmeNodeSprite, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, amsAmeNodeSprite.translate);
AppMain.readQuaternion(br, ref amsAmeNodeSprite.rotate);
amsAmeNodeSprite.z_bias = br.ReadSingle();
amsAmeNodeSprite.inheritance_rate = br.ReadSingle();
amsAmeNodeSprite.life = br.ReadSingle();
amsAmeNodeSprite.start_time = br.ReadSingle();
amsAmeNodeSprite.size = br.ReadSingle();
amsAmeNodeSprite.size_chaos = br.ReadSingle();
amsAmeNodeSprite.scale_x_start = br.ReadSingle();
amsAmeNodeSprite.scale_x_end = br.ReadSingle();
amsAmeNodeSprite.scale_y_start = br.ReadSingle();
amsAmeNodeSprite.scale_y_end = br.ReadSingle();
amsAmeNodeSprite.twist_angle = br.ReadSingle();
amsAmeNodeSprite.twist_angle_chaos = br.ReadSingle();
amsAmeNodeSprite.twist_angle_speed = br.ReadSingle();
amsAmeNodeSprite.color_start.color = br.ReadUInt32();
amsAmeNodeSprite.color_end.color = br.ReadUInt32();
amsAmeNodeSprite.blend = br.ReadInt32();
amsAmeNodeSprite.texture_slot = br.ReadInt16();
amsAmeNodeSprite.texture_id = br.ReadInt16();
amsAmeNodeSprite.cropping_l = br.ReadSingle();
amsAmeNodeSprite.cropping_t = br.ReadSingle();
amsAmeNodeSprite.cropping_r = br.ReadSingle();
amsAmeNodeSprite.cropping_b = br.ReadSingle();
amsAmeNodeSprite.scroll_u = br.ReadSingle();
amsAmeNodeSprite.scroll_v = br.ReadSingle();
amsAmeNodeSprite.tex_anim = AppMain.readTexAnim(br);
dictionary[index2] = (AppMain.AMS_AME_NODE)amsAmeNodeSprite;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)amsAmeNodeSprite;
break;
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_LINE:
AppMain.AMS_AME_NODE_LINE amsAmeNodeLine = new AppMain.AMS_AME_NODE_LINE();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)amsAmeNodeLine, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, amsAmeNodeLine.translate);
AppMain.readQuaternion(br, ref amsAmeNodeLine.rotate);
amsAmeNodeLine.z_bias = br.ReadSingle();
amsAmeNodeLine.inheritance_rate = br.ReadSingle();
amsAmeNodeLine.life = br.ReadSingle();
amsAmeNodeLine.start_time = br.ReadSingle();
amsAmeNodeLine.length_start = br.ReadSingle();
amsAmeNodeLine.length_end = br.ReadSingle();
amsAmeNodeLine.inside_width_start = br.ReadSingle();
amsAmeNodeLine.inside_width_end = br.ReadSingle();
amsAmeNodeLine.outside_width_start = br.ReadSingle();
amsAmeNodeLine.outside_width_end = br.ReadSingle();
amsAmeNodeLine.inside_color_start.color = br.ReadUInt32();
amsAmeNodeLine.inside_color_end.color = br.ReadUInt32();
amsAmeNodeLine.outside_color_start.color = br.ReadUInt32();
amsAmeNodeLine.outside_color_end.color = br.ReadUInt32();
amsAmeNodeLine.blend = br.ReadInt32();
amsAmeNodeLine.texture_slot = br.ReadInt16();
amsAmeNodeLine.texture_id = br.ReadInt16();
amsAmeNodeLine.cropping_l = br.ReadSingle();
amsAmeNodeLine.cropping_t = br.ReadSingle();
amsAmeNodeLine.cropping_r = br.ReadSingle();
amsAmeNodeLine.cropping_b = br.ReadSingle();
amsAmeNodeLine.scroll_u = br.ReadSingle();
amsAmeNodeLine.scroll_v = br.ReadSingle();
amsAmeNodeLine.tex_anim = AppMain.readTexAnim(br);
dictionary[index2] = (AppMain.AMS_AME_NODE)amsAmeNodeLine;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)amsAmeNodeLine;
break;
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_PLANE:
AppMain.AMS_AME_NODE_PLANE amsAmeNodePlane = new AppMain.AMS_AME_NODE_PLANE();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)amsAmeNodePlane, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, amsAmeNodePlane.translate);
AppMain.readQuaternion(br, ref amsAmeNodePlane.rotate);
AppMain.readVector4(br, amsAmeNodePlane.rotate_axis);
amsAmeNodePlane.z_bias = br.ReadSingle();
amsAmeNodePlane.inheritance_rate = br.ReadSingle();
amsAmeNodePlane.life = br.ReadSingle();
amsAmeNodePlane.start_time = br.ReadSingle();
amsAmeNodePlane.size = br.ReadSingle();
amsAmeNodePlane.size_chaos = br.ReadSingle();
amsAmeNodePlane.scale_x_start = br.ReadSingle();
amsAmeNodePlane.scale_x_end = br.ReadSingle();
amsAmeNodePlane.scale_y_start = br.ReadSingle();
amsAmeNodePlane.scale_y_end = br.ReadSingle();
amsAmeNodePlane.color_start.color = br.ReadUInt32();
amsAmeNodePlane.color_end.color = br.ReadUInt32();
amsAmeNodePlane.blend = br.ReadInt32();
amsAmeNodePlane.texture_slot = br.ReadInt16();
amsAmeNodePlane.texture_id = br.ReadInt16();
amsAmeNodePlane.cropping_l = br.ReadSingle();
amsAmeNodePlane.cropping_t = br.ReadSingle();
amsAmeNodePlane.cropping_r = br.ReadSingle();
amsAmeNodePlane.cropping_b = br.ReadSingle();
amsAmeNodePlane.scroll_u = br.ReadSingle();
amsAmeNodePlane.scroll_v = br.ReadSingle();
amsAmeNodePlane.tex_anim = AppMain.readTexAnim(br);
dictionary[index2] = (AppMain.AMS_AME_NODE)amsAmeNodePlane;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)amsAmeNodePlane;
break;
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_MODEL:
AppMain.AMS_AME_NODE_MODEL amsAmeNodeModel = new AppMain.AMS_AME_NODE_MODEL();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)amsAmeNodeModel, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, amsAmeNodeModel.translate);
AppMain.readQuaternion(br, ref amsAmeNodeModel.rotate);
AppMain.readVector4(br, amsAmeNodeModel.rotate_axis);
AppMain.readVector4(br, amsAmeNodeModel.scale_start);
AppMain.readVector4(br, amsAmeNodeModel.scale_end);
amsAmeNodeModel.z_bias = br.ReadSingle();
amsAmeNodeModel.inheritance_rate = br.ReadSingle();
amsAmeNodeModel.life = br.ReadSingle();
amsAmeNodeModel.start_time = br.ReadSingle();
amsAmeNodeModel.model_name = br.ReadChars(8);
amsAmeNodeModel.lod = br.ReadInt32();
amsAmeNodeModel.color_start.color = br.ReadUInt32();
amsAmeNodeModel.color_end.color = br.ReadUInt32();
amsAmeNodeModel.blend = br.ReadInt32();
amsAmeNodeModel.scroll_u = br.ReadSingle();
amsAmeNodeModel.scroll_v = br.ReadSingle();
dictionary[index2] = (AppMain.AMS_AME_NODE)amsAmeNodeModel;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)amsAmeNodeModel;
break;
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_GRAVITY:
AppMain.AMS_AME_NODE_GRAVITY amsAmeNodeGravity = new AppMain.AMS_AME_NODE_GRAVITY();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)amsAmeNodeGravity, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, amsAmeNodeGravity.direction);
amsAmeNodeGravity.magnitude = br.ReadSingle();
dictionary[index2] = (AppMain.AMS_AME_NODE)amsAmeNodeGravity;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)amsAmeNodeGravity;
break;
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_UNIFORM:
AppMain.AMS_AME_NODE_UNIFORM amsAmeNodeUniform = new AppMain.AMS_AME_NODE_UNIFORM();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)amsAmeNodeUniform, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, amsAmeNodeUniform.direction);
amsAmeNodeUniform.magnitude = br.ReadSingle();
dictionary[index2] = (AppMain.AMS_AME_NODE)amsAmeNodeUniform;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)amsAmeNodeUniform;
break;
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_RADIAL:
AppMain.AMS_AME_NODE_RADIAL amsAmeNodeRadial = new AppMain.AMS_AME_NODE_RADIAL();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)amsAmeNodeRadial, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, amsAmeNodeRadial.position);
amsAmeNodeRadial.magnitude = br.ReadSingle();
amsAmeNodeRadial.attenuation = br.ReadSingle();
dictionary[index2] = (AppMain.AMS_AME_NODE)amsAmeNodeRadial;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)amsAmeNodeRadial;
break;
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_VORTEX:
AppMain.AMS_AME_NODE_VORTEX amsAmeNodeVortex = new AppMain.AMS_AME_NODE_VORTEX();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)amsAmeNodeVortex, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, amsAmeNodeVortex.position);
AppMain.readVector4(br, amsAmeNodeVortex.axis);
dictionary[index2] = (AppMain.AMS_AME_NODE)amsAmeNodeVortex;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)amsAmeNodeVortex;
break;
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_DRAG:
AppMain.AMS_AME_NODE_DRAG amsAmeNodeDrag = new AppMain.AMS_AME_NODE_DRAG();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)amsAmeNodeDrag, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, amsAmeNodeDrag.position);
amsAmeNodeDrag.magnitude = br.ReadSingle();
dictionary[index2] = (AppMain.AMS_AME_NODE)amsAmeNodeDrag;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)amsAmeNodeDrag;
break;
case AppMain.AME_AME_NODE_TYPE.AME_AME_NODE_TYPE_NOISE:
AppMain.AMS_AME_NODE_NOISE amsAmeNodeNoise = new AppMain.AMS_AME_NODE_NOISE();
AppMain.fillAMENodeBegin((AppMain.AMS_AME_NODE)amsAmeNodeNoise, id, (short)ameAmeNodeType, flag, name, child_offset, sibling_offset, parent_offset);
AppMain.readVector4(br, amsAmeNodeNoise.axis);
amsAmeNodeNoise.magnitude = br.ReadSingle();
dictionary[index2] = (AppMain.AMS_AME_NODE)amsAmeNodeNoise;
amsAmeHeader.node[index1] = (AppMain.AMS_AME_NODE)amsAmeNodeNoise;
break;
}
}
else
{
break;
}
}
foreach (KeyValuePair <uint, AppMain.AMS_AME_NODE> keyValuePair in dictionary)
{
AppMain.AMS_AME_NODE amsAmeNode = keyValuePair.Value;
if (amsAmeNode.child_offset != 0)
{
amsAmeNode.child = dictionary[(uint)amsAmeNode.child_offset];
}
if (amsAmeNode.parent_offset != 0)
{
amsAmeNode.parent = dictionary[(uint)amsAmeNode.parent_offset];
}
if (amsAmeNode.sibling_offset != 0)
{
amsAmeNode.sibling = dictionary[(uint)amsAmeNode.sibling_offset];
}
}
return(amsAmeHeader);
}
