diff --git a/Source/Contents/Effects/EffectPrimitiveColor.cpp b/Source/Contents/Effects/EffectPrimitiveColor.cpp
index 8c20ad93..2086b660 100644
--- a/Source/Contents/Effects/EffectPrimitiveColor.cpp
+++ b/Source/Contents/Effects/EffectPrimitiveColor.cpp
@@ -5,8 +5,8 @@
 // OFFSET: 0x00BC5E00
 // FUNCTION: fn_19849
 void EffectPrimitiveState::ProcessAlpha() {
-  const int current = this->unknown_01E0;
-  const bool valuesAndLimit = this->unknown_0158 != 0;
+  const int current = this->stateCnt;
+  const bool valuesAndLimit = this->chRadiSpeed != 0;
 
   if (valuesAndLimit || this->unknown_014C.y != 0) {
     auto index = this->unknown_01D8;
@@ -25,7 +25,7 @@ void EffectPrimitiveState::ProcessAlpha() {
 
       if (valuesAndLimit) {
         this->alpha = value;
-        this->unknown_02D4 = this->unknown_0258[2][index];
+        this->maxAlpha = this->unknown_0258[2][index];
       } else {
         this->alphaSpeed = value;
       }
@@ -34,39 +34,39 @@ void EffectPrimitiveState::ProcessAlpha() {
     }
   }
 
-  const float lower = this->unknown_02D8;
+  const float lower = this->minAlpha;
 
-  if ((this->flags & 0x80u) != 0) {
-    const bool below = this->alphaSpeed >= 0.0f ? this->alpha < this->unknown_02D4 : lower < this->alpha;
+  if ((this->pattern & 0x80u) != 0) {
+    const bool below = this->alphaSpeed >= 0.0f ? this->alpha < this->maxAlpha : lower < this->alpha;
 
     if (!below) {
       this->alphaSpeed *= -1.0f;
     }
   }
 
-  if (this->unknown_015C == 0) {
+  if (this->isDisappear == 0) {
     const int parentRemaining = this->master->state.lifetime - this->master->state.unknown_0178;
-    const int remaining = this->lifetime - current;
+    const int remaining = this->duration - current;
 
     if (remaining > parentRemaining + 1) {
-      this->unknown_015C = 1;
-      this->flags &= ~0x80u;
+      this->isDisappear = 1;
+      this->pattern &= ~0x80u;
       this->alphaSpeed = -(this->alpha / static_cast<float>(parentRemaining));
     }
   }
 
-  if (current == this->unknown_01F0) {
-    this->flags &= ~0x80u;
-    const int remaining = this->lifetime - current;
+  if (current == this->fadeOutCnt) {
+    this->pattern &= ~0x80u;
+    const int remaining = this->duration - current;
     this->alphaSpeed = -(this->alpha / static_cast<float>(remaining)) * this->alphaDelta;
   }
 
   const float sum = this->alphaSpeed + this->alpha;
   const float minimum = lower > sum ? lower : sum;
-  const float bounded = this->unknown_02D4 < minimum ? this->unknown_02D4 : minimum;
+  const float bounded = this->maxAlpha < minimum ? this->maxAlpha : minimum;
   this->alpha = bounded;
   const auto alpha = static_cast<std::uint32_t>(TruncateToInt(bounded));
   const auto color =
     ((alpha * 256u + static_cast<unsigned char>(this->red)) * 256u + static_cast<unsigned char>(this->green)) * 256u + static_cast<unsigned char>(this->blue);
-  this->unknown_01C0 = color;
+  this->argb = color;
 }
diff --git a/Source/Contents/Effects/EffectPrimitiveMotion.cpp b/Source/Contents/Effects/EffectPrimitiveMotion.cpp
index 3c9ddd3c..08624b2f 100644
--- a/Source/Contents/Effects/EffectPrimitiveMotion.cpp
+++ b/Source/Contents/Effects/EffectPrimitiveMotion.cpp
@@ -97,88 +97,88 @@ namespace {
 // OFFSET: 0x00BB8C50
 // FUNCTION: fn_19785
 bool MoveEffectPrimitive(EffectPrimitiveState& particle, RenderObjectState& render, EffectMotionContext& context) {
-  particle.origin = {
-    context.parentRender.position.x + particle.velocity.x, context.parentRender.position.y + particle.velocity.y,
-    context.parentRender.position.z + particle.velocity.z
+  particle.orgPos = {
+    context.parentRender.position.x + particle.deltaPos2.x, context.parentRender.position.y + particle.deltaPos2.y,
+    context.parentRender.position.z + particle.deltaPos2.z
   };
 
-  if (particle.unknown_0200 == particle.unknown_01E0) {
+  if (particle.changePoint == particle.stateCnt) {
     particle.unknown_0138 = 1;
     constexpr float sentinel = 0.0001f;
 
-    if (particle.unknown_02C8 != sentinel) {
-      particle.unknown_0358 = particle.unknown_02C8;
+    if (particle.changeWidthSpeed != sentinel) {
+      particle.widthSpeed = particle.changeWidthSpeed;
     }
 
-    if (particle.unknown_02CC != sentinel) {
-      particle.unknown_0364 = particle.unknown_02CC;
+    if (particle.changeHeightSpeed != sentinel) {
+      particle.heightSpeed = particle.changeHeightSpeed;
     }
 
-    if (particle.unknown_029C != sentinel) {
-      particle.unknown_02BC = particle.unknown_029C;
+    if (particle.changeSpeed != sentinel) {
+      particle.speed = particle.changeSpeed;
     }
 
-    if (particle.unknown_02C4 != sentinel) {
-      particle.unknown_035C = particle.unknown_02C4;
+    if (particle.changeWidthAccel != sentinel) {
+      particle.widthAccel = particle.changeWidthAccel;
     }
 
-    if (particle.unknown_02D0 != sentinel) {
-      particle.unknown_0368 = particle.unknown_02D0;
+    if (particle.changeHeightAccel != sentinel) {
+      particle.heightAccel = particle.changeHeightAccel;
     }
 
-    if (particle.unknown_02A0 != sentinel) {
-      particle.unknown_02C0 = particle.unknown_02A0;
+    if (particle.changeAccel != sentinel) {
+      particle.accel = particle.changeAccel;
     }
 
-    if (particle.unknown_02A4.x != sentinel) {
-      particle.unknown_0370.x = particle.unknown_02A4.x;
+    if (particle.changeSpeed3d.x != sentinel) {
+      particle.speed3d.x = particle.changeSpeed3d.x;
     }
 
-    if (particle.unknown_02A4.y != sentinel) {
-      particle.unknown_0370.y = particle.unknown_02A4.y;
+    if (particle.changeSpeed3d.y != sentinel) {
+      particle.speed3d.y = particle.changeSpeed3d.y;
     }
 
-    if (particle.unknown_02A4.z != sentinel) {
-      particle.unknown_0370.z = particle.unknown_02A4.z;
+    if (particle.changeSpeed3d.z != sentinel) {
+      particle.speed3d.z = particle.changeSpeed3d.z;
     }
 
-    particle.unknown_02C8 = sentinel;
-    particle.unknown_02CC = sentinel;
-    particle.unknown_029C = sentinel;
-    particle.unknown_02C4 = sentinel;
-    particle.unknown_02D0 = sentinel;
-    particle.unknown_02A0 = sentinel;
-    particle.unknown_02A4 = {sentinel, sentinel, sentinel};
-    particle.unknown_02B0 = {sentinel, sentinel, sentinel};
+    particle.changeWidthSpeed = sentinel;
+    particle.changeHeightSpeed = sentinel;
+    particle.changeSpeed = sentinel;
+    particle.changeWidthAccel = sentinel;
+    particle.changeHeightAccel = sentinel;
+    particle.changeAccel = sentinel;
+    particle.changeSpeed3d = {sentinel, sentinel, sentinel};
+    particle.changeAccel3d = {sentinel, sentinel, sentinel};
   }
 
-  particle.unknown_0370.x = particle.unknown_0370.x + particle.unknown_03AC.x;
-  particle.unknown_0370.y = particle.unknown_03AC.y + particle.unknown_0370.y;
-  particle.unknown_0370.z = particle.unknown_03AC.z + particle.unknown_0370.z;
-  particle.unknown_0358 = particle.unknown_035C + particle.unknown_0358;
-  particle.unknown_02BC = particle.unknown_02C0 + particle.unknown_02BC;
-  particle.unknown_0364 = particle.unknown_0368 + particle.unknown_0364;
-  particle.unknown_0330 = particle.unknown_033C + particle.unknown_0330;
-  particle.unknown_0334 = particle.unknown_0340 + particle.unknown_0334;
+  particle.speed3d.x = particle.speed3d.x + particle.deltaPosAccel.x;
+  particle.speed3d.y = particle.deltaPosAccel.y + particle.speed3d.y;
+  particle.speed3d.z = particle.deltaPosAccel.z + particle.speed3d.z;
+  particle.widthSpeed = particle.widthAccel + particle.widthSpeed;
+  particle.speed = particle.accel + particle.speed;
+  particle.heightSpeed = particle.heightAccel + particle.heightSpeed;
+  particle.longSpeed = particle.longAccel + particle.longSpeed;
+  particle.latiSpeed = particle.latiAccel + particle.latiSpeed;
 
-  if ((particle.flags & 0x400u) != 0) {
-    particle.unknown_0370 = {};
-    particle.unknown_0370 = Forward(particle.unknown_02BC, particle.matrix1);
-    particle.offset.x = particle.unknown_0370.x + particle.offset.x;
-    particle.offset.z = particle.unknown_0370.z + particle.offset.z;
-    particle.offset.y = particle.unknown_0370.y + particle.offset.y;
-  } else if ((particle.flags & 0x100u) != 0) {
-    particle.offset.x = particle.unknown_0370.x + particle.offset.x;
-    particle.offset.y = particle.unknown_0370.y + particle.offset.y;
-    particle.offset.z = particle.unknown_0370.z + particle.offset.z;
+  if ((particle.pattern & 0x400u) != 0) {
+    particle.speed3d = {};
+    particle.speed3d = Forward(particle.speed, particle.transform);
+    particle.deltaPos.x = particle.speed3d.x + particle.deltaPos.x;
+    particle.deltaPos.z = particle.speed3d.z + particle.deltaPos.z;
+    particle.deltaPos.y = particle.speed3d.y + particle.deltaPos.y;
+  } else if ((particle.pattern & 0x100u) != 0) {
+    particle.deltaPos.x = particle.speed3d.x + particle.deltaPos.x;
+    particle.deltaPos.y = particle.speed3d.y + particle.deltaPos.y;
+    particle.deltaPos.z = particle.speed3d.z + particle.deltaPos.z;
   } else {
-    particle.unknown_0370 = Forward(particle.unknown_02BC, particle.matrix1);
-    particle.offset.x = particle.unknown_0370.x + particle.offset.x;
-    particle.offset.z = particle.unknown_0370.z + particle.offset.z;
-    particle.offset.y = particle.unknown_0370.y + particle.offset.y;
+    particle.speed3d = Forward(particle.speed, particle.transform);
+    particle.deltaPos.x = particle.speed3d.x + particle.deltaPos.x;
+    particle.deltaPos.z = particle.speed3d.z + particle.deltaPos.z;
+    particle.deltaPos.y = particle.speed3d.y + particle.deltaPos.y;
   }
 
-  if ((particle.flags & 0x400u) != 0) {
+  if ((particle.pattern & 0x400u) != 0) {
     const float x = particle.master->state.offset[0] - render.position.x;
     const float z = particle.master->state.offset[2] - render.position.z;
     const float distance = std::sqrt(z * z + x * x);
@@ -188,86 +188,86 @@ bool MoveEffectPrimitive(EffectPrimitiveState& particle, RenderObjectState& rend
       return false;
     }
 
-    particle.unknown_030C = render.angle;
+    particle.longitude = render.angle;
   }
 
-  render.position.x = particle.origin.x + particle.offset.x;
-  render.position.y = particle.offset.y + particle.origin.y;
-  render.position.z = particle.offset.z + particle.origin.z;
-  particle.unknown_0354 = particle.unknown_0358 + particle.unknown_0354;
-  particle.unknown_0360 = particle.unknown_0364 + particle.unknown_0360;
-  particle.unknown_030C = particle.unknown_030C + particle.unknown_0330;
-  particle.unknown_0310 = particle.unknown_0310 + particle.unknown_0334;
+  render.position.x = particle.orgPos.x + particle.deltaPos.x;
+  render.position.y = particle.deltaPos.y + particle.orgPos.y;
+  render.position.z = particle.deltaPos.z + particle.orgPos.z;
+  particle.widthSize = particle.widthSpeed + particle.widthSize;
+  particle.heightSize = particle.heightSpeed + particle.heightSize;
+  particle.longitude = particle.longitude + particle.longSpeed;
+  particle.latitude = particle.latitude + particle.latiSpeed;
 
-  if (!(particle.unknown_0360 <= particle.unknown_036C)) {
-    particle.unknown_0368 = 0;
-    particle.unknown_0364 = 0;
+  if (!(particle.heightSize <= particle.maxHeightSize)) {
+    particle.heightAccel = 0;
+    particle.heightSpeed = 0;
   }
 
   struct matrix matrix;
 
-  if ((particle.flags & 0x200u) != 0) {
+  if ((particle.pattern & 0x200u) != 0) {
     matrix.MakeZRotation(context.cameraPitch);
-  } else if ((particle.flags & 0x40u) != 0) {
-    particle.unknown_030C = context.cameraYaw + 90.0f;
-    particle.unknown_0314 = context.cameraPitch;
-    matrix.MakeXRotation(GetRadian(TruncateToInt(particle.unknown_0310)));
-    matrix.AppendZRotation(GetRadian(TruncateToInt(particle.unknown_0314)));
+  } else if ((particle.pattern & 0x40u) != 0) {
+    particle.longitude = context.cameraYaw + 90.0f;
+    particle.roll = context.cameraPitch;
+    matrix.MakeXRotation(GetRadian(TruncateToInt(particle.latitude)));
+    matrix.AppendZRotation(GetRadian(TruncateToInt(particle.roll)));
   } else {
-    matrix.MakeZRotation(GetRadian(TruncateToInt(particle.unknown_0314)));
-    matrix.AppendXRotation(GetRadian(TruncateToInt(particle.unknown_0310)));
+    matrix.MakeZRotation(GetRadian(TruncateToInt(particle.roll)));
+    matrix.AppendXRotation(GetRadian(TruncateToInt(particle.latitude)));
   }
 
-  const float angle = (particle.flags & 0x200u) != 0 ? render.angle : particle.unknown_030C;
+  const float angle = (particle.pattern & 0x200u) != 0 ? render.angle : particle.longitude;
   matrix.AppendYRotation(GetRadian(TruncateToInt(angle)));
-  std::memcpy(particle.matrix2, matrix.values, sizeof(particle.matrix2));
+  std::memcpy(particle.rotTransform, matrix.values, sizeof(particle.rotTransform));
 
-  if ((particle.flags & 2u) != 0) {
-    const auto index = particle.unknown_01D4;
-    particle.unknown_01D4 = index + 1u == 10u ? 0u : index + 1u;
+  if ((particle.pattern & 2u) != 0) {
+    const auto index = particle.chCnt;
+    particle.chCnt = index + 1u == 10u ? 0u : index + 1u;
     const float offset = static_cast<float>(static_cast<int>(index)) / 10.0f;
-    particle.unknown_02E4 = offset;
-    particle.unknown_02E8 = offset + 1.0f;
+    particle.v1 = offset;
+    particle.v2 = offset + 1.0f;
   }
 
-  if ((particle.flags & 0x10u) != 0) {
-    particle.master->state.offset[0] = particle.velocity.x + particle.offset.x;
-    particle.master->state.offset[1] = particle.offset.y + particle.velocity.y;
-    particle.master->state.offset[2] = particle.offset.z + particle.velocity.z;
+  if ((particle.pattern & 0x10u) != 0) {
+    particle.master->state.offset[0] = particle.deltaPos2.x + particle.deltaPos.x;
+    particle.master->state.offset[1] = particle.deltaPos.y + particle.deltaPos2.y;
+    particle.master->state.offset[2] = particle.deltaPos.z + particle.deltaPos2.z;
   }
 
-  if ((particle.flags & 4u) != 0 && render.position.y > context.ground.Height(render.position.x, render.position.z)) {
-    particle.flags &= ~4u;
-    particle.unknown_01E0 = particle.lifetime - 25;
-    particle.unknown_02BC = 0;
+  if ((particle.pattern & 4u) != 0 && render.position.y > context.ground.Height(render.position.x, render.position.z)) {
+    particle.pattern &= ~4u;
+    particle.stateCnt = particle.duration - 25;
+    particle.speed = 0;
     particle.master->state.unknown_0170 = 1;
   }
 
-  const int frame = particle.unknown_01E0;
+  const int frame = particle.stateCnt;
 
-  if ((particle.flags & 0x20u) != 0 && frame % static_cast<int>(particle.unknown_01CC) == 0) {
-    particle.unknown_0364 *= -1.0f;
+  if ((particle.pattern & 0x20u) != 0 && frame % static_cast<int>(particle.type) == 0) {
+    particle.heightSpeed *= -1.0f;
   }
 
-  const bool wrap254 = (particle.flags & 0x800u) != 0;
+  const bool wrap254 = (particle.pattern & 0x800u) != 0;
   const bool gated = wrap254 && (particle.red == 254 || particle.green == 254 || particle.blue == 254);
   bool advance = true;
 
   if (gated) {
-    if (particle.unknown_0234 != 0) {
-      ++particle.unknown_01FC;
+    if (particle.RGBCycleDelay != 0) {
+      ++particle.RGBCycleCnt;
     }
 
-    advance = particle.unknown_0234 == particle.unknown_01FC;
+    advance = particle.RGBCycleDelay == particle.RGBCycleCnt;
   }
 
   if (advance) {
-    particle.red += particle.unknown_0248;
-    particle.green += particle.unknown_024C;
-    particle.blue += particle.unknown_0250;
+    particle.red += particle.redSpeed;
+    particle.green += particle.greenSpeed;
+    particle.blue += particle.blueSpeed;
 
     if (gated) {
-      particle.unknown_01FC = 0;
+      particle.RGBCycleCnt = 0;
     }
   }
 
@@ -283,13 +283,13 @@ bool MoveEffectPrimitive(EffectPrimitiveState& particle, RenderObjectState& rend
 
   particle.ProcessAlpha();
 
-  if (particle.unknown_01E0 % particle.unknown_01E8 == 0) {
+  if (particle.stateCnt % particle.animSpeed == 0) {
     const auto next = render.curMotion + 1u;
     render.curMotion = next;
 
-    if (particle.unknown_0254 != 0) {
-      render.curMotion = static_cast<int>(next) % static_cast<int>(particle.textureCount);
-    } else if (next == particle.textureCount) {
+    if (particle.repeatAnim != 0) {
+      render.curMotion = static_cast<int>(next) % static_cast<int>(particle.totalTexture);
+    } else if (next == particle.totalTexture) {
       return false;
     }
   }
@@ -309,8 +309,8 @@ bool UpdateEffectPrimitive15(EffectPrimitiveState& particle, RenderObjectState&
   }
 
   MoveEffectPrimitive(particle, render, context);
-  ++particle.unknown_01E0;
-  return particle.unknown_01E0 <= particle.lifetime;
+  ++particle.stateCnt;
+  return particle.stateCnt <= particle.duration;
 }
 
 // OFFSET: 0x00BB6180
@@ -341,7 +341,7 @@ bool Prim3DCasting4(EffectPrimitiveState& particle, RenderObjectState& render, E
     slot.maxHeight = height;
     slot.riseAngle = static_cast<std::int16_t>(static_cast<int>(90.0f - height * 9.0f));
 
-    if (slot.process >= particle.lifetime - 40) {
+    if (slot.process >= particle.duration - 40) {
       slot.alphaB -= 3;
 
       if (slot.alphaB < 0) {
@@ -428,53 +428,53 @@ bool Prim3DCasting5(EffectPrimitiveState& particle, RenderObjectState& render, E
 // OFFSET: 0x00BB6820
 // FUNCTION: fn_19777
 bool Prim3DCylinder(EffectPrimitiveState& particle, RenderObjectState& render, EffectMotionContext& context) {
-  particle.origin = {
-    context.parentRender.position.x + particle.velocity.x, context.parentRender.position.y + particle.velocity.y,
-    context.parentRender.position.z + particle.velocity.z
+  particle.orgPos = {
+    context.parentRender.position.x + particle.deltaPos2.x, context.parentRender.position.y + particle.deltaPos2.y,
+    context.parentRender.position.z + particle.deltaPos2.z
   };
 
-  particle.unknown_02BC = particle.unknown_02C0 + particle.unknown_02BC;
-  particle.unknown_0334 = particle.unknown_0340 + particle.unknown_0334;
-  particle.unknown_0364 = particle.unknown_0368 + particle.unknown_0364;
-  particle.unknown_0310 = particle.unknown_0334 + particle.unknown_0310;
-  particle.unknown_0300 = particle.unknown_0308 + particle.unknown_0300;
-  particle.unknown_02FC = particle.unknown_0304 + particle.unknown_02FC;
-  particle.unknown_0330 = particle.unknown_033C + particle.unknown_0330;
-  particle.unknown_030C = particle.unknown_0330 + particle.unknown_030C;
+  particle.speed = particle.accel + particle.speed;
+  particle.latiSpeed = particle.latiAccel + particle.latiSpeed;
+  particle.heightSpeed = particle.heightAccel + particle.heightSpeed;
+  particle.latitude = particle.latiSpeed + particle.latitude;
+  particle.outerSpeed = particle.outerAccel + particle.outerSpeed;
+  particle.innerSpeed = particle.innerAccel + particle.innerSpeed;
+  particle.longSpeed = particle.longAccel + particle.longSpeed;
+  particle.longitude = particle.longSpeed + particle.longitude;
 
-  struct matrix& matrix = *reinterpret_cast<struct matrix*>(particle.matrix1);
-  matrix.MakeXRotation(GetRadian(static_cast<int>(particle.unknown_0310)));
-  matrix.AppendYRotation(GetRadian(static_cast<int>(particle.unknown_030C)));
+  struct matrix& matrix = *reinterpret_cast<struct matrix*>(particle.transform);
+  matrix.MakeXRotation(GetRadian(static_cast<int>(particle.latitude)));
+  matrix.AppendYRotation(GetRadian(static_cast<int>(particle.longitude)));
 
-  particle.unknown_0370 = Upward(particle.unknown_02BC, particle.matrix1);
-  particle.offset.y = particle.unknown_0370.y + particle.offset.y;
-  particle.offset.x = particle.unknown_0370.x + particle.offset.x;
-  particle.offset.z = particle.unknown_0370.z + particle.offset.z;
-  particle.unknown_030C = particle.unknown_0330 + particle.unknown_030C;
-  particle.unknown_02F4 += particle.unknown_02FC;
-  render.position.x = particle.offset.x + particle.origin.x;
-  render.position.y = particle.offset.y + particle.origin.y;
-  render.position.z = particle.offset.z + particle.origin.z;
-  particle.unknown_02F8 += particle.unknown_0300;
-  particle.unknown_0360 = particle.unknown_0364 + particle.unknown_0360;
+  particle.speed3d = Upward(particle.speed, particle.transform);
+  particle.deltaPos.y = particle.speed3d.y + particle.deltaPos.y;
+  particle.deltaPos.x = particle.speed3d.x + particle.deltaPos.x;
+  particle.deltaPos.z = particle.speed3d.z + particle.deltaPos.z;
+  particle.longitude = particle.longSpeed + particle.longitude;
+  particle.innerSize += particle.innerSpeed;
+  render.position.x = particle.deltaPos.x + particle.orgPos.x;
+  render.position.y = particle.deltaPos.y + particle.orgPos.y;
+  render.position.z = particle.deltaPos.z + particle.orgPos.z;
+  particle.outerSize += particle.outerSpeed;
+  particle.heightSize = particle.heightSpeed + particle.heightSize;
 
-  if (particle.unknown_0360 > particle.unknown_036C) {
-    particle.unknown_0360 = particle.unknown_036C;
+  if (particle.heightSize > particle.maxHeightSize) {
+    particle.heightSize = particle.maxHeightSize;
   }
 
-  if ((particle.flags & 1u) != 0 && particle.unknown_01E0 == particle.unknown_01F0) {
-    particle.unknown_0300 = -(particle.unknown_02F8 / static_cast<float>(particle.lifetime - particle.unknown_01E0 + 1));
+  if ((particle.pattern & 1u) != 0 && particle.stateCnt == particle.fadeOutCnt) {
+    particle.outerSpeed = -(particle.outerSize / static_cast<float>(particle.duration - particle.stateCnt + 1));
   }
 
   particle.ProcessAlpha();
 
-  if (particle.unknown_01E0 % particle.unknown_01E8 == 0) {
+  if (particle.stateCnt % particle.animSpeed == 0) {
     const auto next = render.curMotion + 1u;
     render.curMotion = next;
 
-    if (particle.unknown_0254 != 0) {
-      render.curMotion = static_cast<int>(next) % static_cast<int>(particle.textureCount);
-    } else if (next == particle.textureCount) {
+    if (particle.repeatAnim != 0) {
+      render.curMotion = static_cast<int>(next) % static_cast<int>(particle.totalTexture);
+    } else if (next == particle.totalTexture) {
       return false;
     }
   }
@@ -485,49 +485,49 @@ bool Prim3DCylinder(EffectPrimitiveState& particle, RenderObjectState& render, E
 // OFFSET: 0x00BB6B30
 // FUNCTION: fn_19778
 bool Prim3DCylinderHalf(EffectPrimitiveState& particle, RenderObjectState& render, EffectMotionContext& context) {
-  particle.origin = {
-    context.parentRender.position.x + particle.velocity.x, context.parentRender.position.y + particle.velocity.y,
-    context.parentRender.position.z + particle.velocity.z
+  particle.orgPos = {
+    context.parentRender.position.x + particle.deltaPos2.x, context.parentRender.position.y + particle.deltaPos2.y,
+    context.parentRender.position.z + particle.deltaPos2.z
   };
 
-  particle.unknown_02BC = particle.unknown_02C0 + particle.unknown_02BC;
-  particle.unknown_0300 = particle.unknown_0308 + particle.unknown_0300;
-  particle.unknown_02FC = particle.unknown_0304 + particle.unknown_02FC;
-  particle.unknown_0364 = particle.unknown_0368 + particle.unknown_0364;
+  particle.speed = particle.accel + particle.speed;
+  particle.outerSpeed = particle.outerAccel + particle.outerSpeed;
+  particle.innerSpeed = particle.innerAccel + particle.innerSpeed;
+  particle.heightSpeed = particle.heightAccel + particle.heightSpeed;
 
-  struct matrix& matrix = *reinterpret_cast<struct matrix*>(particle.matrix1);
-  matrix.MakeXRotation(GetRadian(static_cast<int>(particle.unknown_0310)));
-  matrix.AppendYRotation(GetRadian(static_cast<int>(particle.unknown_030C)));
+  struct matrix& matrix = *reinterpret_cast<struct matrix*>(particle.transform);
+  matrix.MakeXRotation(GetRadian(static_cast<int>(particle.latitude)));
+  matrix.AppendYRotation(GetRadian(static_cast<int>(particle.longitude)));
 
-  particle.unknown_0370 = Upward(particle.unknown_02BC, particle.matrix1);
-  particle.offset.x = particle.unknown_0370.x + particle.offset.x;
-  particle.offset.y = particle.unknown_0370.y + particle.offset.y;
-  particle.offset.z = particle.unknown_0370.z + particle.offset.z;
-  render.position.x = particle.offset.x + particle.origin.x;
-  render.position.y = particle.offset.y + particle.origin.y;
-  render.position.z = particle.offset.z + particle.origin.z;
-  particle.unknown_030C = particle.unknown_0330 + particle.unknown_030C;
-  particle.unknown_02F8 = particle.unknown_0300 + particle.unknown_02F8;
-  particle.unknown_02F4 = particle.unknown_02FC + particle.unknown_02F4;
-  particle.unknown_0360 += particle.unknown_0364;
+  particle.speed3d = Upward(particle.speed, particle.transform);
+  particle.deltaPos.x = particle.speed3d.x + particle.deltaPos.x;
+  particle.deltaPos.y = particle.speed3d.y + particle.deltaPos.y;
+  particle.deltaPos.z = particle.speed3d.z + particle.deltaPos.z;
+  render.position.x = particle.deltaPos.x + particle.orgPos.x;
+  render.position.y = particle.deltaPos.y + particle.orgPos.y;
+  render.position.z = particle.deltaPos.z + particle.orgPos.z;
+  particle.longitude = particle.longSpeed + particle.longitude;
+  particle.outerSize = particle.outerSpeed + particle.outerSize;
+  particle.innerSize = particle.innerSpeed + particle.innerSize;
+  particle.heightSize += particle.heightSpeed;
 
-  if (particle.unknown_0360 > particle.unknown_036C) {
-    particle.unknown_0360 = particle.unknown_036C;
+  if (particle.heightSize > particle.maxHeightSize) {
+    particle.heightSize = particle.maxHeightSize;
   }
 
-  if ((particle.flags & 1u) != 0 && particle.unknown_01E0 == particle.unknown_01F0) {
-    particle.unknown_0300 = -(particle.unknown_02F8 / static_cast<float>(particle.lifetime - particle.unknown_01E0 + 1));
+  if ((particle.pattern & 1u) != 0 && particle.stateCnt == particle.fadeOutCnt) {
+    particle.outerSpeed = -(particle.outerSize / static_cast<float>(particle.duration - particle.stateCnt + 1));
   }
 
   particle.ProcessAlpha();
 
-  if (particle.unknown_01E0 % particle.unknown_01E8 == 0) {
+  if (particle.stateCnt % particle.animSpeed == 0) {
     const auto next = render.curMotion + 1u;
     render.curMotion = next;
 
-    if (particle.unknown_0254 != 0) {
-      render.curMotion = static_cast<int>(next) % static_cast<int>(particle.textureCount);
-    } else if (next == particle.textureCount) {
+    if (particle.repeatAnim != 0) {
+      render.curMotion = static_cast<int>(next) % static_cast<int>(particle.totalTexture);
+    } else if (next == particle.totalTexture) {
       return false;
     }
   }
@@ -538,34 +538,34 @@ bool Prim3DCylinderHalf(EffectPrimitiveState& particle, RenderObjectState& rende
 // OFFSET: 0x00BB8610
 // FUNCTION: fn_19784
 void AdvanceEffectPrimitive(EffectPrimitiveState& particle, RenderObjectState& render, EffectMotionContext& context) {
-  particle.origin = {
-    context.parentRender.position.x + particle.velocity.x, context.parentRender.position.y + particle.velocity.y,
-    context.parentRender.position.z + particle.velocity.z
+  particle.orgPos = {
+    context.parentRender.position.x + particle.deltaPos2.x, context.parentRender.position.y + particle.deltaPos2.y,
+    context.parentRender.position.z + particle.deltaPos2.z
   };
 
-  if (particle.unknown_01E0 == particle.unknown_0200) {
-    particle.unknown_02BC = particle.unknown_029C;
-    particle.unknown_02C0 = particle.unknown_02A0;
+  if (particle.stateCnt == particle.changePoint) {
+    particle.speed = particle.changeSpeed;
+    particle.accel = particle.changeAccel;
   }
 
-  particle.unknown_02BC = particle.unknown_02C0 + particle.unknown_02BC;
-  particle.unknown_0370 = Forward(particle.unknown_02BC, particle.matrix1);
-  particle.offset.x = particle.unknown_0370.x + particle.offset.x;
-  particle.offset.y = particle.unknown_0370.y + particle.offset.y;
-  particle.offset.z = particle.unknown_0370.z + particle.offset.z;
-  render.position.x = particle.offset.x + particle.origin.x;
-  render.position.y = particle.offset.y + particle.origin.y;
-  render.position.z = particle.offset.z + particle.origin.z;
+  particle.speed = particle.accel + particle.speed;
+  particle.speed3d = Forward(particle.speed, particle.transform);
+  particle.deltaPos.x = particle.speed3d.x + particle.deltaPos.x;
+  particle.deltaPos.y = particle.speed3d.y + particle.deltaPos.y;
+  particle.deltaPos.z = particle.speed3d.z + particle.deltaPos.z;
+  render.position.x = particle.deltaPos.x + particle.orgPos.x;
+  render.position.y = particle.deltaPos.y + particle.orgPos.y;
+  render.position.z = particle.deltaPos.z + particle.orgPos.z;
 
-  if ((particle.flags & 1u) != 0 && particle.unknown_01E0 == static_cast<int>(particle.unknown_01D4)) {
-    particle.unknown_02C0 = 0;
-    particle.unknown_02BC = 0;
+  if ((particle.pattern & 1u) != 0 && particle.stateCnt == static_cast<int>(particle.chCnt)) {
+    particle.accel = 0;
+    particle.speed = 0;
   }
 
-  if ((particle.flags & 2u) != 0) {
-    if (particle.unknown_01E0 == particle.lifetime - 30) {
-      particle.unknown_02BC = particle.unknown_02A4.y;
-      particle.unknown_02C0 = particle.unknown_02B0.y;
+  if ((particle.pattern & 2u) != 0) {
+    if (particle.stateCnt == particle.duration - 30) {
+      particle.speed = particle.changeSpeed3d.y;
+      particle.accel = particle.changeAccel3d.y;
     }
   } else {
     particle.ProcessAlpha();
@@ -577,20 +577,20 @@ void AdvanceEffectPrimitive(EffectPrimitiveState& particle, RenderObjectState& r
 bool CEffectPrim::AnimMotion() {
   CActRes* action = this->render.action;
 
-  if (this->state.unknown_01E0 % this->state.unknown_01E8 != 0) {
+  if (this->state.stateCnt % this->state.animSpeed != 0) {
     return true;
   }
 
   const unsigned animation = static_cast<unsigned>(this->render.previousAnimation);
   ++this->render.curMotion;
 
-  if (this->state.unknown_0254 != 0) {
+  if (this->state.repeatAnim != 0) {
     this->render.curMotion =
       static_cast<std::uint32_t>(static_cast<int>(this->render.curMotion) % static_cast<int>(action->FrameCount(animation)));
     return true;
   }
 
-  if ((this->state.flags & 0x800u) != 0) {
+  if ((this->state.pattern & 0x800u) != 0) {
     if (this->render.curMotion == action->FrameCount(animation)) {
       --this->render.curMotion;
     }
@@ -610,7 +610,7 @@ bool CEffectPrim::UpdateFireWall() {
   this->render.position.z = master->render.position.z;
 
   for (int index = 0; index < 4; ++index) {
-    if (this->state.scale == 3.0f && index < 3) {
+    if (this->state.size == 3.0f && index < 3) {
       index = 3;
     }
 
@@ -630,7 +630,7 @@ bool CEffectPrim::UpdateFireWall() {
       slot.rotStart = static_cast<std::int16_t>(slot.rotStart - 360);
     }
 
-    const int limit = this->state.lifetime - 40;
+    const int limit = this->state.duration - 40;
     bool grown = false;
 
     if (slot.process < limit) {
@@ -733,7 +733,7 @@ bool CEffectPrim::UpdateStoneCurse() {
   this->render.position.z = master->render.position.z;
 
   for (int index = 0; index < 4; ++index) {
-    if (this->state.scale == 3.0f && index < 3) {
+    if (this->state.size == 3.0f && index < 3) {
       index = 3;
     }
 
@@ -753,7 +753,7 @@ bool CEffectPrim::UpdateStoneCurse() {
       slot.rotStart = static_cast<std::int16_t>(slot.rotStart - 360);
     }
 
-    if (slot.process < this->state.lifetime - 40) {
+    if (slot.process < this->state.duration - 40) {
       if (slot.process < 20 && slot.alphaT != 1) {
         if (index == 3) {
           this->state.slots[3].alphaB = static_cast<std::int16_t>(this->state.slots[3].alphaB + 8);
@@ -804,55 +804,55 @@ bool CEffectPrim::UpdateStoneCurse() {
 // FUNCTION: fn_19776
 void CEffectPrim::Prim3DCircle() {
   const CRagEffect* master = this->state.master;
-  this->state.origin.x = master->render.position.x + this->state.velocity.x;
-  this->state.origin.y = master->render.position.y + this->state.velocity.y;
-  this->state.origin.z = master->render.position.z + this->state.velocity.z;
+  this->state.orgPos.x = master->render.position.x + this->state.deltaPos2.x;
+  this->state.orgPos.y = master->render.position.y + this->state.deltaPos2.y;
+  this->state.orgPos.z = master->render.position.z + this->state.deltaPos2.z;
 
   float base;
 
-  if (this->state.unknown_0200 == this->state.unknown_01E0) {
-    this->state.unknown_0350 = this->state.unknown_02A0;
-    base = this->state.unknown_029C;
+  if (this->state.changePoint == this->state.stateCnt) {
+    this->state.radiusAccel = this->state.changeAccel;
+    base = this->state.changeSpeed;
   } else {
-    base = this->state.unknown_034C;
+    base = this->state.radiusSpeed;
   }
 
-  const float horizontal = base + this->state.unknown_0350;
-  const float forwardX = this->state.unknown_033C + this->state.unknown_0330;
-  this->state.unknown_02BC = this->state.unknown_02C0 + this->state.unknown_02BC;
-  const float forwardZ = this->state.unknown_0304 + this->state.unknown_02FC;
-  this->state.unknown_0330 = forwardX;
-  const float angle = forwardX + this->state.unknown_030C;
-  this->state.unknown_034C = horizontal;
-  const float side = horizontal + this->state.unknown_0348;
-  this->state.unknown_02FC = forwardZ;
-  const float vertical = forwardZ + this->state.unknown_02F4;
-  this->state.unknown_030C = angle;
-  this->state.unknown_0348 = side;
-  this->state.unknown_02F4 = vertical;
+  const float horizontal = base + this->state.radiusAccel;
+  const float forwardX = this->state.longAccel + this->state.longSpeed;
+  this->state.speed = this->state.accel + this->state.speed;
+  const float forwardZ = this->state.innerAccel + this->state.innerSpeed;
+  this->state.longSpeed = forwardX;
+  const float angle = forwardX + this->state.longitude;
+  this->state.radiusSpeed = horizontal;
+  const float side = horizontal + this->state.radius;
+  this->state.innerSpeed = forwardZ;
+  const float vertical = forwardZ + this->state.innerSize;
+  this->state.longitude = angle;
+  this->state.radius = side;
+  this->state.innerSize = vertical;
 
-  reinterpret_cast<struct matrix*>(this->state.matrix1)->MakeXRotation(GetRadian(static_cast<int>(this->state.unknown_0310)));
-  reinterpret_cast<struct matrix*>(this->state.matrix1)->AppendYRotation(GetRadian(static_cast<int>(this->state.unknown_030C)));
+  reinterpret_cast<struct matrix*>(this->state.transform)->MakeXRotation(GetRadian(static_cast<int>(this->state.latitude)));
+  reinterpret_cast<struct matrix*>(this->state.transform)->AppendYRotation(GetRadian(static_cast<int>(this->state.longitude)));
 
-  const float distance = this->state.unknown_02BC;
-  this->state.unknown_0370 = Forward(distance, this->state.matrix1);
-  const float offsetX = this->state.unknown_0370.x + this->state.offset.x;
-  const float offsetY = this->state.unknown_0370.y + this->state.offset.y;
-  const float offsetZ = this->state.unknown_0370.z + this->state.offset.z;
-  this->state.offset.x = offsetX;
-  this->state.offset.y = offsetY;
-  this->state.offset.z = offsetZ;
-  this->render.position.x = offsetX + this->state.origin.x;
-  this->render.position.y = offsetY + this->state.origin.y;
-  this->render.position.z = offsetZ + this->state.origin.z;
+  const float distance = this->state.speed;
+  this->state.speed3d = Forward(distance, this->state.transform);
+  const float offsetX = this->state.speed3d.x + this->state.deltaPos.x;
+  const float offsetY = this->state.speed3d.y + this->state.deltaPos.y;
+  const float offsetZ = this->state.speed3d.z + this->state.deltaPos.z;
+  this->state.deltaPos.x = offsetX;
+  this->state.deltaPos.y = offsetY;
+  this->state.deltaPos.z = offsetZ;
+  this->render.position.x = offsetX + this->state.orgPos.x;
+  this->render.position.y = offsetY + this->state.orgPos.y;
+  this->render.position.z = offsetZ + this->state.orgPos.z;
 
-  float scale = this->state.unknown_02F4;
+  float scale = this->state.innerSize;
 
-  if ((this->state.flags & 1u) != 0 || scale > this->state.unknown_0348) {
-    scale = this->state.unknown_0348;
+  if ((this->state.pattern & 1u) != 0 || scale > this->state.radius) {
+    scale = this->state.radius;
   }
 
-  this->state.scale = scale;
+  this->state.size = scale;
   this->state.ProcessAlpha();
   this->ShiftSegment();
 }
@@ -1225,7 +1225,7 @@ void CEffectPrim::PrimEffectTexture_Ani() {
   if (slot.process % frameTicks == 0) {
     ++slot.flag1[0];
 
-    if (slot.flag1[0] >= static_cast<int>(this->state.textureCount)) {
+    if (slot.flag1[0] >= static_cast<int>(this->state.totalTexture)) {
       slot.flag1[0] = 0;
     }
   }
@@ -1492,8 +1492,8 @@ void CEffectPrim::PrimSMA() {
     }
 
     if (slot.process == 1) {
-      const float x = this->state.offset.x - this->render.position.x;
-      const float z = this->state.offset.z - this->render.position.z;
+      const float x = this->state.deltaPos.x - this->render.position.x;
+      const float z = this->state.deltaPos.z - this->render.position.z;
       Get_Angle(x, z, &slot.rotStart);
     }
 
@@ -1619,8 +1619,8 @@ void CEffectPrim::PrimShieldBoomerang() {
   }
 
   if (slot.process == 1) {
-    const float rx = this->state.offset.x - slot.vecBNow.x;
-    const float rz = this->state.offset.z - slot.vecBNow.z;
+    const float rx = this->state.deltaPos.x - slot.vecBNow.x;
+    const float rz = this->state.deltaPos.z - slot.vecBNow.z;
     Get_Angle(rx, rz, &slot.rotStart);
   }
 
@@ -1719,13 +1719,13 @@ bool CEffectPrim::PrimKouenka() {
 
     slot.vecBPre.x += 0.15f * g_sinTable[static_cast<int>(slot.height[0])];
     slot.vecBPre.z += 0.15f * g_sinTable[static_cast<int>(slot.height[2])];
-    this->state.offset = slot.vecBPre;
+    this->state.deltaPos = slot.vecBPre;
   }
 
-  this->render.position = this->state.offset;
+  this->render.position = this->state.deltaPos;
 
-  if ((this->state.flags & 0x20) != 0) {
-    this->state.unknown_0314 = this->render.angle - static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->camera.yaw;
+  if ((this->state.pattern & 0x20) != 0) {
+    this->state.roll = this->render.angle - static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->camera.yaw;
   }
 
   this->state.ProcessAlpha();
@@ -1781,13 +1781,13 @@ bool CEffectPrim::PrimSakura() {
       slot.vecBPre.z = this->render.position.z + Random(300) - 150;
     }
 
-    this->state.offset = slot.vecBPre;
+    this->state.deltaPos = slot.vecBPre;
   }
 
-  this->render.position = this->state.offset;
+  this->render.position = this->state.deltaPos;
 
-  if ((this->state.flags & 0x20) != 0) {
-    this->state.unknown_0314 = this->render.angle - static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->camera.yaw;
+  if ((this->state.pattern & 0x20) != 0) {
+    this->state.roll = this->render.angle - static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->camera.yaw;
   }
 
   this->state.ProcessAlpha();
@@ -1822,8 +1822,8 @@ void CEffectPrim::PrimTeiHit2() {
     }
 
     if (slot.process == 1) {
-      const float rx = this->state.offset.x - this->render.position.x;
-      const float rz = this->state.offset.z - this->render.position.z;
+      const float rx = this->state.deltaPos.x - this->render.position.x;
+      const float rz = this->state.deltaPos.z - this->render.position.z;
       Get_Angle(rx, rz, &slot.rotStart);
       slot.rotStart += Random(60) - 30;
 
@@ -1865,7 +1865,7 @@ bool CEffectPrim::PrimSuperAngel() {
     ++slot.process;
     slot.vecBNow.y -= 0.1f;
     slot.vecBPre = slot.vecBNow;
-    this->state.offset = slot.vecBPre;
+    this->state.deltaPos = slot.vecBPre;
 
     float& alpha = this->state.alpha;
     const char kind = slot.flag1[0];
@@ -1993,9 +1993,9 @@ bool CEffectPrim::PrimSuperAngel() {
     }
   }
 
-  this->render.position.x = this->state.offset.x;
-  this->render.position.y = this->state.offset.y;
-  this->render.position.z = this->state.offset.z;
+  this->render.position.x = this->state.deltaPos.x;
+  this->render.position.y = this->state.deltaPos.y;
+  this->render.position.z = this->state.deltaPos.z;
   this->ShiftSegment();
   return true;
 }
@@ -2056,8 +2056,8 @@ void CEffectPrim::PrimTanji2() {
   }
 
   if (slot.process == 1) {
-    const float rx = this->state.offset.x - slot.vecBNow.x;
-    const float rz = this->state.offset.z - slot.vecBNow.z;
+    const float rx = this->state.deltaPos.x - slot.vecBNow.x;
+    const float rz = this->state.deltaPos.z - slot.vecBNow.z;
     Get_Angle(rx, rz, &slot.rotStart);
   }
 
@@ -2145,7 +2145,7 @@ bool CEffectPrim::PrimGhost() {
     }
 
     slot.vecBPre.y += slot.maxHeight * g_sinTable[slot.riseAngle];
-    this->state.offset = slot.vecBPre;
+    this->state.deltaPos = slot.vecBPre;
 
     const CView* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera;
     int angle = slot.rotStart + static_cast<int>(view->camera.yaw);
@@ -2179,7 +2179,7 @@ bool CEffectPrim::PrimGhost() {
     }
   }
 
-  this->render.position = this->state.offset;
+  this->render.position = this->state.deltaPos;
   this->state.ProcessAlpha();
   this->ShiftSegment();
   return this->AnimMotion();
@@ -2229,8 +2229,8 @@ void CEffectPrim::PrimThrowItem() {
   }
 
   if (slot.process == 1) {
-    const float x = this->state.offset.x - slot.vecBNow.x;
-    const float z = this->state.offset.z - slot.vecBNow.z;
+    const float x = this->state.deltaPos.x - slot.vecBNow.x;
+    const float z = this->state.deltaPos.z - slot.vecBNow.z;
     Get_Angle(x, z, &slot.rotStart);
   }
 
@@ -2368,97 +2368,97 @@ void CEffectPrim::PrimWaterFall() {
 // FUNCTION: fn_19779
 bool CEffectPrim::Prim3DParticle() {
   const CRagEffect* master = this->state.master;
-  this->state.origin.x = master->render.position.x + this->state.velocity.x;
-  this->state.origin.y = master->render.position.y + this->state.velocity.y;
-  this->state.origin.z = master->render.position.z + this->state.velocity.z;
+  this->state.orgPos.x = master->render.position.x + this->state.deltaPos2.x;
+  this->state.orgPos.y = master->render.position.y + this->state.deltaPos2.y;
+  this->state.orgPos.z = master->render.position.z + this->state.deltaPos2.z;
 
-  const int frame = this->state.unknown_01E0;
+  const int frame = this->state.stateCnt;
 
-  if (frame == this->state.unknown_0200) {
-    this->state.unknown_0370 = this->state.unknown_02A4;
-    this->state.unknown_03AC = this->state.unknown_02B0;
+  if (frame == this->state.changePoint) {
+    this->state.speed3d = this->state.changeSpeed3d;
+    this->state.deltaPosAccel = this->state.changeAccel3d;
   }
 
-  float vertical = this->state.unknown_02C0 + this->state.unknown_02BC;
-  float lateral = this->state.unknown_0320 + this->state.unknown_031C;
-  std::uint32_t flags = this->state.flags;
-  this->state.unknown_02BC = vertical;
-  this->state.unknown_031C = lateral;
+  float vertical = this->state.accel + this->state.speed;
+  float lateral = this->state.sizeAccel + this->state.sizeSpeed;
+  std::uint32_t flags = this->state.pattern;
+  this->state.speed = vertical;
+  this->state.sizeSpeed = lateral;
 
   if ((flags & 0x400u) != 0) {
-    const float z = this->state.unknown_03AC.z + this->state.unknown_0370.z;
-    const float x = this->state.unknown_03AC.x + this->state.unknown_0370.x;
-    const float y = this->state.unknown_03AC.y + this->state.unknown_0370.y;
-    this->state.unknown_0370.z = z;
-    this->state.offset.z = z + this->state.offset.z;
-    this->state.unknown_0370.x = x;
-    this->state.offset.x = x + this->state.offset.x;
-    this->state.unknown_0370.y = y;
-    this->state.offset.y = y + this->state.offset.y;
-    this->state.unknown_0314 = this->state.unknown_0338 + this->state.unknown_0314;
-    this->state.scale = lateral + this->state.scale;
-  } else if ((flags & 1u) != 0 || frame > this->state.unknown_01EC) {
-    const float side = lateral + this->state.scale;
-    this->state.unknown_0370 = Forward(vertical, this->state.matrix1);
-    this->state.offset.x = this->state.unknown_0370.x + this->state.offset.x;
-    this->state.offset.y = this->state.unknown_0370.y + this->state.offset.y;
-    this->state.offset.z = this->state.unknown_0370.z + this->state.offset.z;
-    this->state.scale = side;
-    this->state.unknown_0314 = this->state.unknown_0338 + this->state.unknown_0314;
+    const float z = this->state.deltaPosAccel.z + this->state.speed3d.z;
+    const float x = this->state.deltaPosAccel.x + this->state.speed3d.x;
+    const float y = this->state.deltaPosAccel.y + this->state.speed3d.y;
+    this->state.speed3d.z = z;
+    this->state.deltaPos.z = z + this->state.deltaPos.z;
+    this->state.speed3d.x = x;
+    this->state.deltaPos.x = x + this->state.deltaPos.x;
+    this->state.speed3d.y = y;
+    this->state.deltaPos.y = y + this->state.deltaPos.y;
+    this->state.roll = this->state.rollSpeed + this->state.roll;
+    this->state.size = lateral + this->state.size;
+  } else if ((flags & 1u) != 0 || frame > this->state.fadeInCnt) {
+    const float side = lateral + this->state.size;
+    this->state.speed3d = Forward(vertical, this->state.transform);
+    this->state.deltaPos.x = this->state.speed3d.x + this->state.deltaPos.x;
+    this->state.deltaPos.y = this->state.speed3d.y + this->state.deltaPos.y;
+    this->state.deltaPos.z = this->state.speed3d.z + this->state.deltaPos.z;
+    this->state.size = side;
+    this->state.roll = this->state.rollSpeed + this->state.roll;
   }
 
-  flags = this->state.flags;
+  flags = this->state.pattern;
 
   if ((flags & 2u) != 0) {
-    if (this->state.unknown_01E0 % this->state.unknown_01D4 == 0) {
-      this->state.unknown_01D4 = rand() % 8 + 12;
-      this->state.unknown_03A0.x = static_cast<float>(rand() % 5 + 5) / 100.0f;
-      this->state.unknown_03A0.z = static_cast<float>(rand() % 5 + 5) / 100.0f;
+    if (this->state.stateCnt % this->state.chCnt == 0) {
+      this->state.chCnt = rand() % 8 + 12;
+      this->state.deltaPos3.x = static_cast<float>(rand() % 5 + 5) / 100.0f;
+      this->state.deltaPos3.z = static_cast<float>(rand() % 5 + 5) / 100.0f;
 
       if (rand() % 2 == 0) {
-        this->state.unknown_03A0.x = -this->state.unknown_03A0.x;
+        this->state.deltaPos3.x = -this->state.deltaPos3.x;
       }
 
       if (rand() % 2 == 0) {
-        this->state.unknown_03A0.z = -this->state.unknown_03A0.z;
+        this->state.deltaPos3.z = -this->state.deltaPos3.z;
       }
     }
 
-    flags = this->state.flags;
-    this->state.offset.x = this->state.unknown_03A0.x + this->state.offset.x;
+    flags = this->state.pattern;
+    this->state.deltaPos.x = this->state.deltaPos3.x + this->state.deltaPos.x;
   }
 
-  if ((flags & 4u) != 0 && this->state.unknown_01E0 % this->state.unknown_01D4 == 0) {
-    this->state.unknown_02BC = static_cast<float>(rand() % 35 + 15) / 100.0f;
-    this->state.unknown_030C = static_cast<float>(rand() % 80) + (this->state.unknown_030C - 40.0f);
-    this->state.unknown_0310 = static_cast<float>(rand() % 80) + (this->state.unknown_0310 - 40.0f);
-    reinterpret_cast<struct matrix*>(this->state.matrix1)->MakeYRotation(GetRadian(static_cast<int>(this->state.unknown_030C)));
-    reinterpret_cast<struct matrix*>(this->state.matrix1)->AppendXRotation(GetRadian(static_cast<int>(this->state.unknown_0310)));
-    flags = this->state.flags;
-    this->state.unknown_01D4 = rand() % 10 + 5;
+  if ((flags & 4u) != 0 && this->state.stateCnt % this->state.chCnt == 0) {
+    this->state.speed = static_cast<float>(rand() % 35 + 15) / 100.0f;
+    this->state.longitude = static_cast<float>(rand() % 80) + (this->state.longitude - 40.0f);
+    this->state.latitude = static_cast<float>(rand() % 80) + (this->state.latitude - 40.0f);
+    reinterpret_cast<struct matrix*>(this->state.transform)->MakeYRotation(GetRadian(static_cast<int>(this->state.longitude)));
+    reinterpret_cast<struct matrix*>(this->state.transform)->AppendXRotation(GetRadian(static_cast<int>(this->state.latitude)));
+    flags = this->state.pattern;
+    this->state.chCnt = rand() % 10 + 5;
   }
 
-  if ((flags & 8u) != 0 && this->state.unknown_01E0 % this->state.unknown_01D4 == 0) {
-    this->state.unknown_030C = static_cast<float>(rand() % 10) + (this->state.unknown_030C - 5.0f);
-    this->state.unknown_0310 = static_cast<float>(rand() % 10) + (this->state.unknown_0310 - 5.0f);
-    reinterpret_cast<struct matrix*>(this->state.matrix1)->MakeXRotation(GetRadian(static_cast<int>(this->state.unknown_0310)));
-    reinterpret_cast<struct matrix*>(this->state.matrix1)->AppendYRotation(GetRadian(static_cast<int>(this->state.unknown_030C)));
-    this->state.unknown_01D4 = rand() % 15 + 5;
+  if ((flags & 8u) != 0 && this->state.stateCnt % this->state.chCnt == 0) {
+    this->state.longitude = static_cast<float>(rand() % 10) + (this->state.longitude - 5.0f);
+    this->state.latitude = static_cast<float>(rand() % 10) + (this->state.latitude - 5.0f);
+    reinterpret_cast<struct matrix*>(this->state.transform)->MakeXRotation(GetRadian(static_cast<int>(this->state.latitude)));
+    reinterpret_cast<struct matrix*>(this->state.transform)->AppendYRotation(GetRadian(static_cast<int>(this->state.longitude)));
+    this->state.chCnt = rand() % 15 + 5;
   }
 
   this->render.position = {
-    this->state.offset.x + this->state.origin.x, this->state.offset.y + this->state.origin.y,
-    this->state.offset.z + this->state.origin.z
+    this->state.deltaPos.x + this->state.orgPos.x, this->state.deltaPos.y + this->state.orgPos.y,
+    this->state.deltaPos.z + this->state.orgPos.z
   };
 
-  if ((this->state.flags & 0x100u) != 0) {
+  if ((this->state.pattern & 0x100u) != 0) {
     if (3.0f >= this->CalcDist(this->state.master->state.offset[0], this->state.master->state.offset[2])) {
       return false;
     }
   }
 
-  if ((this->state.flags & 0x20u) != 0) {
-    this->state.unknown_0314 = this->render.angle - static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->camera.yaw;
+  if ((this->state.pattern & 0x20u) != 0) {
+    this->state.roll = this->render.angle - static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->camera.yaw;
   }
 
   this->state.ProcessAlpha();
@@ -2471,28 +2471,28 @@ bool CEffectPrim::Prim3DParticle() {
 bool CEffectPrim::Prim3DParticleGravity() {
   CGameMode* mode = static_cast<CGameMode*>(g_modeMgr.GetGameMode());
   const CRagEffect* master = this->state.master;
-  this->state.origin.z = master->render.position.z + this->state.velocity.z;
-  this->state.origin.y = master->render.position.y + this->state.velocity.y;
-  this->state.origin.x = master->render.position.x + this->state.velocity.x;
-  this->state.unknown_02EC = this->state.unknown_02F0 + this->state.unknown_02EC;
+  this->state.orgPos.z = master->render.position.z + this->state.deltaPos2.z;
+  this->state.orgPos.y = master->render.position.y + this->state.deltaPos2.y;
+  this->state.orgPos.x = master->render.position.x + this->state.deltaPos2.x;
+  this->state.gravSpeed = this->state.gravAccel + this->state.gravSpeed;
 
-  const float speed = this->state.unknown_02C0 + this->state.unknown_02BC;
-  this->state.unknown_02BC = speed < 0.0f ? 0.0f : speed;
-  this->state.unknown_0370 = Forward(this->state.unknown_02BC, this->state.matrix1);
+  const float speed = this->state.accel + this->state.speed;
+  this->state.speed = speed < 0.0f ? 0.0f : speed;
+  this->state.speed3d = Forward(this->state.speed, this->state.transform);
 
-  this->state.offset.x = this->state.unknown_0370.x + this->state.offset.x;
-  this->state.offset.y = this->state.offset.y + this->state.unknown_02EC;
-  this->state.offset.z = this->state.unknown_0370.z + this->state.offset.z;
+  this->state.deltaPos.x = this->state.speed3d.x + this->state.deltaPos.x;
+  this->state.deltaPos.y = this->state.deltaPos.y + this->state.gravSpeed;
+  this->state.deltaPos.z = this->state.speed3d.z + this->state.deltaPos.z;
 
-  this->render.position.x = this->state.offset.x + this->state.origin.x;
-  this->render.position.y = this->state.offset.y + this->state.origin.y;
-  this->render.position.z = this->state.offset.z + this->state.origin.z;
-  this->state.scale = this->state.unknown_031C + this->state.scale;
+  this->render.position.x = this->state.deltaPos.x + this->state.orgPos.x;
+  this->render.position.y = this->state.deltaPos.y + this->state.orgPos.y;
+  this->render.position.z = this->state.deltaPos.z + this->state.orgPos.z;
+  this->state.size = this->state.sizeSpeed + this->state.size;
 
-  if (this->state.unknown_02EC > 0.0f && this->render.position.y > mode->scene->terrain->Grid().Height(this->render.position.x, this->render.position.z)) {
-    this->state.unknown_02EC = this->state.unknown_02EC / -1.5f;
+  if (this->state.gravSpeed > 0.0f && this->render.position.y > mode->scene->terrain->Grid().Height(this->render.position.x, this->render.position.z)) {
+    this->state.gravSpeed = this->state.gravSpeed / -1.5f;
 
-    if (this->state.unknown_0208 == 1) {
+    if (this->state.playWaveType == 1) {
       char name[52];
       std::sprintf(name, "effect\\EF_Coin%d.wav", rand() % 3 + 1);
       const auto* player = reinterpret_cast<const CRenderObject*>(static_cast<CGameMode*>(g_modeMgr.GetGameMode())->scene->player);
@@ -2512,181 +2512,181 @@ bool CEffectPrim::Prim3DParticleGravity() {
 bool CEffectPrim::Prim3DTextureNoMaster() {
   EffectPrimitiveState& particle = this->state;
   const vector3d origin{
-    particle.origin.x + particle.velocity.x, particle.origin.y + particle.velocity.y, particle.origin.z + particle.velocity.z
+    particle.orgPos.x + particle.deltaPos2.x, particle.orgPos.y + particle.deltaPos2.y, particle.orgPos.z + particle.deltaPos2.z
   };
 
-  if (particle.unknown_0200 == particle.unknown_01E0) {
+  if (particle.changePoint == particle.stateCnt) {
     constexpr float sentinel = 0.0001f;
 
-    if (particle.unknown_02C8 != sentinel) {
-      particle.unknown_0358 = particle.unknown_02C8;
+    if (particle.changeWidthSpeed != sentinel) {
+      particle.widthSpeed = particle.changeWidthSpeed;
     }
 
-    if (particle.unknown_02CC != sentinel) {
-      particle.unknown_0364 = particle.unknown_02CC;
+    if (particle.changeHeightSpeed != sentinel) {
+      particle.heightSpeed = particle.changeHeightSpeed;
     }
 
-    if (particle.unknown_029C != sentinel) {
-      particle.unknown_02BC = particle.unknown_029C;
+    if (particle.changeSpeed != sentinel) {
+      particle.speed = particle.changeSpeed;
     }
 
-    if (particle.unknown_02C4 != sentinel) {
-      particle.unknown_035C = particle.unknown_02C4;
+    if (particle.changeWidthAccel != sentinel) {
+      particle.widthAccel = particle.changeWidthAccel;
     }
 
-    if (particle.unknown_02D0 != sentinel) {
-      particle.unknown_0368 = particle.unknown_02D0;
+    if (particle.changeHeightAccel != sentinel) {
+      particle.heightAccel = particle.changeHeightAccel;
     }
 
-    if (particle.unknown_02A0 != sentinel) {
-      particle.unknown_02C0 = particle.unknown_02A0;
+    if (particle.changeAccel != sentinel) {
+      particle.accel = particle.changeAccel;
     }
 
-    if (particle.unknown_02A4.x != sentinel) {
-      particle.unknown_0370.x = particle.unknown_02A4.x;
+    if (particle.changeSpeed3d.x != sentinel) {
+      particle.speed3d.x = particle.changeSpeed3d.x;
     }
 
-    if (particle.unknown_02A4.y != sentinel) {
-      particle.unknown_0370.y = particle.unknown_02A4.y;
+    if (particle.changeSpeed3d.y != sentinel) {
+      particle.speed3d.y = particle.changeSpeed3d.y;
     }
 
-    if (particle.unknown_02A4.z != sentinel) {
-      particle.unknown_0370.z = particle.unknown_02A4.z;
+    if (particle.changeSpeed3d.z != sentinel) {
+      particle.speed3d.z = particle.changeSpeed3d.z;
     }
 
-    if (particle.unknown_02B0.x != sentinel) {
-      particle.unknown_03AC.x = particle.unknown_02B0.x;
+    if (particle.changeAccel3d.x != sentinel) {
+      particle.deltaPosAccel.x = particle.changeAccel3d.x;
     }
 
-    if (particle.unknown_02B0.y != sentinel) {
-      particle.unknown_03AC.y = particle.unknown_02B0.y;
+    if (particle.changeAccel3d.y != sentinel) {
+      particle.deltaPosAccel.y = particle.changeAccel3d.y;
     }
 
-    if (particle.unknown_02B0.z != sentinel) {
-      particle.unknown_03AC.z = particle.unknown_02B0.z;
+    if (particle.changeAccel3d.z != sentinel) {
+      particle.deltaPosAccel.z = particle.changeAccel3d.z;
     }
   }
 
-  particle.unknown_0370.x = particle.unknown_03AC.x + particle.unknown_0370.x;
-  particle.unknown_0370.y = particle.unknown_03AC.y + particle.unknown_0370.y;
-  particle.unknown_0370.z = particle.unknown_03AC.z + particle.unknown_0370.z;
-  particle.unknown_02BC = particle.unknown_02C0 + particle.unknown_02BC;
-  particle.unknown_0358 = particle.unknown_035C + particle.unknown_0358;
-  particle.unknown_0364 = particle.unknown_0364 + particle.unknown_0368;
-  particle.unknown_0330 = particle.unknown_033C + particle.unknown_0330;
-  particle.unknown_0334 = particle.unknown_0340 + particle.unknown_0334;
+  particle.speed3d.x = particle.deltaPosAccel.x + particle.speed3d.x;
+  particle.speed3d.y = particle.deltaPosAccel.y + particle.speed3d.y;
+  particle.speed3d.z = particle.deltaPosAccel.z + particle.speed3d.z;
+  particle.speed = particle.accel + particle.speed;
+  particle.widthSpeed = particle.widthAccel + particle.widthSpeed;
+  particle.heightSpeed = particle.heightSpeed + particle.heightAccel;
+  particle.longSpeed = particle.longAccel + particle.longSpeed;
+  particle.latiSpeed = particle.latiAccel + particle.latiSpeed;
 
-  if ((particle.flags & 0x400u) != 0) {
-    particle.unknown_0370 = {};
-    particle.unknown_0370 = Forward(particle.unknown_02BC, particle.matrix1);
-    particle.offset.x = particle.unknown_0370.x + particle.offset.x;
-    particle.offset.y = particle.unknown_0370.y + particle.offset.y;
-    particle.offset.z = particle.unknown_0370.z + particle.offset.z;
-  } else if ((particle.flags & 0x100u) != 0) {
-    particle.offset.x = particle.unknown_0370.x + particle.offset.x;
-    particle.offset.y = particle.unknown_0370.y + particle.offset.y;
-    particle.offset.z = particle.unknown_0370.z + particle.offset.z;
+  if ((particle.pattern & 0x400u) != 0) {
+    particle.speed3d = {};
+    particle.speed3d = Forward(particle.speed, particle.transform);
+    particle.deltaPos.x = particle.speed3d.x + particle.deltaPos.x;
+    particle.deltaPos.y = particle.speed3d.y + particle.deltaPos.y;
+    particle.deltaPos.z = particle.speed3d.z + particle.deltaPos.z;
+  } else if ((particle.pattern & 0x100u) != 0) {
+    particle.deltaPos.x = particle.speed3d.x + particle.deltaPos.x;
+    particle.deltaPos.y = particle.speed3d.y + particle.deltaPos.y;
+    particle.deltaPos.z = particle.speed3d.z + particle.deltaPos.z;
   } else {
-    particle.unknown_0370 = Forward(particle.unknown_02BC, particle.matrix1);
-    particle.offset.x = particle.unknown_0370.x + particle.offset.x;
-    particle.offset.y = particle.unknown_0370.y + particle.offset.y;
-    particle.offset.z = particle.unknown_0370.z + particle.offset.z;
+    particle.speed3d = Forward(particle.speed, particle.transform);
+    particle.deltaPos.x = particle.speed3d.x + particle.deltaPos.x;
+    particle.deltaPos.y = particle.speed3d.y + particle.deltaPos.y;
+    particle.deltaPos.z = particle.speed3d.z + particle.deltaPos.z;
   }
 
-  if ((particle.flags & 0x400u) != 0) {
+  if ((particle.pattern & 0x400u) != 0) {
     if (3.0f >= this->CalcDist(particle.master->state.offset[0], particle.master->state.offset[2])) {
       particle.unknown_014C.x = std::bit_cast<float>(1u);
       return false;
     }
 
-    particle.unknown_030C = this->render.angle;
+    particle.longitude = this->render.angle;
   }
 
-  this->render.position.x = origin.x + particle.offset.x;
-  this->render.position.y = origin.y + particle.offset.y;
-  this->render.position.z = origin.z + particle.offset.z;
-  particle.unknown_0354 = particle.unknown_0354 + particle.unknown_0358;
-  particle.unknown_0360 = particle.unknown_0360 + particle.unknown_0364;
-  particle.unknown_030C = particle.unknown_0330 + particle.unknown_030C;
-  particle.unknown_0310 = particle.unknown_0334 + particle.unknown_0310;
+  this->render.position.x = origin.x + particle.deltaPos.x;
+  this->render.position.y = origin.y + particle.deltaPos.y;
+  this->render.position.z = origin.z + particle.deltaPos.z;
+  particle.widthSize = particle.widthSize + particle.widthSpeed;
+  particle.heightSize = particle.heightSize + particle.heightSpeed;
+  particle.longitude = particle.longSpeed + particle.longitude;
+  particle.latitude = particle.latiSpeed + particle.latitude;
 
-  if (!(particle.unknown_0360 <= particle.unknown_036C)) {
-    particle.unknown_0368 = 0;
-    particle.unknown_0364 = 0;
+  if (!(particle.heightSize <= particle.maxHeightSize)) {
+    particle.heightAccel = 0;
+    particle.heightSpeed = 0;
   }
 
-  auto& rotation = *reinterpret_cast<struct matrix*>(particle.matrix2);
+  auto& rotation = *reinterpret_cast<struct matrix*>(particle.rotTransform);
   float angle;
 
-  if ((particle.flags & 0x200u) != 0) {
+  if ((particle.pattern & 0x200u) != 0) {
     const CView* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera;
     rotation.MakeZRotation(view->camera.pitch);
     angle = this->render.angle;
   } else {
-    if ((particle.flags & 0x40u) != 0) {
+    if ((particle.pattern & 0x40u) != 0) {
       const CView* view = static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera;
-      particle.unknown_030C = view->camera.yaw + 90.0f;
-      particle.unknown_0314 = view->camera.pitch;
-      rotation.MakeXRotation(GetRadian(static_cast<int>(particle.unknown_0310)));
-      rotation.AppendZRotation(GetRadian(static_cast<int>(particle.unknown_0314)));
+      particle.longitude = view->camera.yaw + 90.0f;
+      particle.roll = view->camera.pitch;
+      rotation.MakeXRotation(GetRadian(static_cast<int>(particle.latitude)));
+      rotation.AppendZRotation(GetRadian(static_cast<int>(particle.roll)));
     } else {
-      rotation.MakeZRotation(GetRadian(static_cast<int>(particle.unknown_0314)));
-      rotation.AppendXRotation(GetRadian(static_cast<int>(particle.unknown_0310)));
+      rotation.MakeZRotation(GetRadian(static_cast<int>(particle.roll)));
+      rotation.AppendXRotation(GetRadian(static_cast<int>(particle.latitude)));
     }
 
-    angle = particle.unknown_030C;
+    angle = particle.longitude;
   }
 
   rotation.AppendYRotation(GetRadian(static_cast<int>(angle)));
 
-  if ((particle.flags & 2u) != 0) {
-    const auto index = particle.unknown_01D4;
-    particle.unknown_01D4 = index + 1u == 10u ? 0u : index + 1u;
+  if ((particle.pattern & 2u) != 0) {
+    const auto index = particle.chCnt;
+    particle.chCnt = index + 1u == 10u ? 0u : index + 1u;
     const float offset = static_cast<float>(static_cast<int>(index)) / 10.0f;
-    particle.unknown_02E4 = offset;
-    particle.unknown_02E8 = offset + 1.0f;
+    particle.v1 = offset;
+    particle.v2 = offset + 1.0f;
   }
 
-  if ((particle.flags & 0x10u) != 0) {
-    particle.master->state.offset[0] = particle.velocity.x + particle.offset.x;
-    particle.master->state.offset[1] = particle.offset.y + particle.velocity.y;
-    particle.master->state.offset[2] = particle.offset.z + particle.velocity.z;
+  if ((particle.pattern & 0x10u) != 0) {
+    particle.master->state.offset[0] = particle.deltaPos2.x + particle.deltaPos.x;
+    particle.master->state.offset[1] = particle.deltaPos.y + particle.deltaPos2.y;
+    particle.master->state.offset[2] = particle.deltaPos.z + particle.deltaPos2.z;
   }
 
-  if ((particle.flags & 4u) != 0) {
+  if ((particle.pattern & 4u) != 0) {
     CGameMode* mode = static_cast<CGameMode*>(g_modeMgr.GetGameMode());
 
     if (this->render.position.y > mode->scene->terrain->Grid().Height(this->render.position.x, this->render.position.z)) {
-      particle.flags &= ~4u;
-      particle.unknown_01E0 = particle.lifetime - 25;
-      particle.unknown_02BC = 0;
+      particle.pattern &= ~4u;
+      particle.stateCnt = particle.duration - 25;
+      particle.speed = 0;
       particle.master->state.unknown_0170 = 1;
     }
   }
 
-  if ((particle.flags & 0x20u) != 0 && particle.unknown_01E0 % static_cast<int>(particle.unknown_01CC) == 0) {
-    particle.unknown_0364 *= -1.0f;
+  if ((particle.pattern & 0x20u) != 0 && particle.stateCnt % static_cast<int>(particle.type) == 0) {
+    particle.heightSpeed *= -1.0f;
   }
 
-  const bool wrap254 = (particle.flags & 0x800u) != 0;
+  const bool wrap254 = (particle.pattern & 0x800u) != 0;
   const bool gated = wrap254 && (particle.red == 254 || particle.blue == 254 || particle.green == 254);
   bool advance = true;
 
   if (gated) {
-    if (particle.unknown_0234 != 0) {
-      ++particle.unknown_01FC;
+    if (particle.RGBCycleDelay != 0) {
+      ++particle.RGBCycleCnt;
     }
 
-    advance = particle.unknown_0234 == particle.unknown_01FC;
+    advance = particle.RGBCycleDelay == particle.RGBCycleCnt;
   }
 
   if (advance) {
-    particle.red += particle.unknown_0248;
-    particle.green += particle.unknown_024C;
-    particle.blue += particle.unknown_0250;
+    particle.red += particle.redSpeed;
+    particle.green += particle.greenSpeed;
+    particle.blue += particle.blueSpeed;
 
     if (gated) {
-      particle.unknown_01FC = 0;
+      particle.RGBCycleCnt = 0;
     }
   }
 
@@ -2702,13 +2702,13 @@ bool CEffectPrim::Prim3DTextureNoMaster() {
 
   particle.ProcessAlpha();
 
-  if (particle.unknown_01E0 % particle.unknown_01E8 == 0) {
+  if (particle.stateCnt % particle.animSpeed == 0) {
     const auto next = this->render.curMotion + 1u;
     this->render.curMotion = next;
 
-    if (particle.unknown_0254 != 0) {
-      this->render.curMotion = static_cast<int>(next) % static_cast<int>(particle.textureCount);
-    } else if (next == particle.textureCount) {
+    if (particle.repeatAnim != 0) {
+      this->render.curMotion = static_cast<int>(next) % static_cast<int>(particle.totalTexture);
+    } else if (next == particle.totalTexture) {
       return false;
     }
   }
@@ -2719,90 +2719,90 @@ bool CEffectPrim::Prim3DTextureNoMaster() {
 // OFFSET: 0x00BB78A0
 // FUNCTION: fn_19781
 bool CEffectPrim::Prim3DParticleNoMaster() {
-  float positionX = this->state.origin.x + this->state.velocity.x;
-  const float positionY = this->state.origin.y + this->state.velocity.y;
-  const float positionZ = this->state.origin.z + this->state.velocity.z;
-  const int frame = this->state.unknown_01E0;
+  float positionX = this->state.orgPos.x + this->state.deltaPos2.x;
+  const float positionY = this->state.orgPos.y + this->state.deltaPos2.y;
+  const float positionZ = this->state.orgPos.z + this->state.deltaPos2.z;
+  const int frame = this->state.stateCnt;
 
-  if (frame == this->state.unknown_0200) {
-    this->state.unknown_0370 = this->state.unknown_02A4;
-    this->state.unknown_03AC = this->state.unknown_02B0;
+  if (frame == this->state.changePoint) {
+    this->state.speed3d = this->state.changeSpeed3d;
+    this->state.deltaPosAccel = this->state.changeAccel3d;
   }
 
-  float vertical = this->state.unknown_02C0 + this->state.unknown_02BC;
-  float lateral = this->state.unknown_0320 + this->state.unknown_031C;
-  std::uint32_t flags = this->state.flags;
-  this->state.unknown_02BC = vertical;
-  this->state.unknown_031C = lateral;
+  float vertical = this->state.accel + this->state.speed;
+  float lateral = this->state.sizeAccel + this->state.sizeSpeed;
+  std::uint32_t flags = this->state.pattern;
+  this->state.speed = vertical;
+  this->state.sizeSpeed = lateral;
 
   if ((flags & 0x400u) != 0) {
-    const float z = this->state.unknown_03AC.z + this->state.unknown_0370.z;
-    const float x = this->state.unknown_03AC.x + this->state.unknown_0370.x;
-    const float y = this->state.unknown_03AC.y + this->state.unknown_0370.y;
-    this->state.unknown_0370.z = z;
-    this->state.offset.z = z + this->state.offset.z;
-    this->state.unknown_0370.x = x;
-    this->state.offset.x = x + this->state.offset.x;
-    this->state.unknown_0370.y = y;
-    this->state.offset.y = y + this->state.offset.y;
-    this->state.unknown_0314 = this->state.unknown_0338 + this->state.unknown_0314;
-    this->state.scale = lateral + this->state.scale;
-  } else if ((flags & 1u) != 0 || frame > this->state.unknown_01EC) {
-    const float side = lateral + this->state.scale;
-    this->state.unknown_0370 = Forward(vertical, this->state.matrix1);
-    this->state.offset.x = this->state.unknown_0370.x + this->state.offset.x;
-    this->state.offset.y = this->state.unknown_0370.y + this->state.offset.y;
-    this->state.offset.z = this->state.unknown_0370.z + this->state.offset.z;
-    this->state.scale = side;
-    this->state.unknown_0314 = this->state.unknown_0338 + this->state.unknown_0314;
+    const float z = this->state.deltaPosAccel.z + this->state.speed3d.z;
+    const float x = this->state.deltaPosAccel.x + this->state.speed3d.x;
+    const float y = this->state.deltaPosAccel.y + this->state.speed3d.y;
+    this->state.speed3d.z = z;
+    this->state.deltaPos.z = z + this->state.deltaPos.z;
+    this->state.speed3d.x = x;
+    this->state.deltaPos.x = x + this->state.deltaPos.x;
+    this->state.speed3d.y = y;
+    this->state.deltaPos.y = y + this->state.deltaPos.y;
+    this->state.roll = this->state.rollSpeed + this->state.roll;
+    this->state.size = lateral + this->state.size;
+  } else if ((flags & 1u) != 0 || frame > this->state.fadeInCnt) {
+    const float side = lateral + this->state.size;
+    this->state.speed3d = Forward(vertical, this->state.transform);
+    this->state.deltaPos.x = this->state.speed3d.x + this->state.deltaPos.x;
+    this->state.deltaPos.y = this->state.speed3d.y + this->state.deltaPos.y;
+    this->state.deltaPos.z = this->state.speed3d.z + this->state.deltaPos.z;
+    this->state.size = side;
+    this->state.roll = this->state.rollSpeed + this->state.roll;
   }
 
-  flags = this->state.flags;
+  flags = this->state.pattern;
 
   if ((flags & 2u) != 0) {
-    if (this->state.unknown_01E0 % this->state.unknown_01D4 == 0) {
-      this->state.unknown_01D4 = rand() % 8 + 12;
-      this->state.unknown_03A0.x = static_cast<float>(rand() % 5 + 5) / 100.0f;
-      this->state.unknown_03A0.z = static_cast<float>(rand() % 5 + 5) / 100.0f;
+    if (this->state.stateCnt % this->state.chCnt == 0) {
+      this->state.chCnt = rand() % 8 + 12;
+      this->state.deltaPos3.x = static_cast<float>(rand() % 5 + 5) / 100.0f;
+      this->state.deltaPos3.z = static_cast<float>(rand() % 5 + 5) / 100.0f;
 
       if (rand() % 2 == 0) {
-        this->state.unknown_03A0.x = -this->state.unknown_03A0.x;
+        this->state.deltaPos3.x = -this->state.deltaPos3.x;
       }
 
       if (rand() % 2 == 0) {
-        this->state.unknown_03A0.z = -this->state.unknown_03A0.z;
+        this->state.deltaPos3.z = -this->state.deltaPos3.z;
       }
     }
 
-    flags = this->state.flags;
-    this->state.offset.x = this->state.unknown_03A0.x + this->state.offset.x;
+    flags = this->state.pattern;
+    this->state.deltaPos.x = this->state.deltaPos3.x + this->state.deltaPos.x;
   }
 
-  if ((flags & 4u) != 0 && this->state.unknown_01E0 % this->state.unknown_01D4 == 0) {
-    this->state.unknown_02BC = static_cast<float>(rand() % 35 + 15) / 100.0f;
-    this->state.unknown_030C = static_cast<float>(rand() % 80) + (this->state.unknown_030C - 40.0f);
-    this->state.unknown_0310 = static_cast<float>(rand() % 80) + (this->state.unknown_0310 - 40.0f);
-    reinterpret_cast<struct matrix*>(this->state.matrix1)->MakeYRotation(GetRadian(static_cast<int>(this->state.unknown_030C)));
-    reinterpret_cast<struct matrix*>(this->state.matrix1)->AppendXRotation(GetRadian(static_cast<int>(this->state.unknown_0310)));
-    this->state.unknown_01D4 = rand() % 10 + 5;
-    flags = this->state.flags;
+  if ((flags & 4u) != 0 && this->state.stateCnt % this->state.chCnt == 0) {
+    this->state.speed = static_cast<float>(rand() % 35 + 15) / 100.0f;
+    this->state.longitude = static_cast<float>(rand() % 80) + (this->state.longitude - 40.0f);
+    this->state.latitude = static_cast<float>(rand() % 80) + (this->state.latitude - 40.0f);
+    reinterpret_cast<struct matrix*>(this->state.transform)->MakeYRotation(GetRadian(static_cast<int>(this->state.longitude)));
+    reinterpret_cast<struct matrix*>(this->state.transform)->AppendXRotation(GetRadian(static_cast<int>(this->state.latitude)));
+    this->state.chCnt = rand() % 10 + 5;
+    flags = this->state.pattern;
   }
 
-  if ((flags & 8u) != 0 && this->state.unknown_01E0 % this->state.unknown_01D4 == 0) {
-    this->state.unknown_030C = static_cast<float>(rand() % 10) + (this->state.unknown_030C - 5.0f);
-    this->state.unknown_0310 = static_cast<float>(rand() % 10) + (this->state.unknown_0310 - 5.0f);
-    reinterpret_cast<struct matrix*>(this->state.matrix1)->MakeXRotation(GetRadian(static_cast<int>(this->state.unknown_0310)));
-    reinterpret_cast<struct matrix*>(this->state.matrix1)->AppendYRotation(GetRadian(static_cast<int>(this->state.unknown_030C)));
-    this->state.unknown_01D4 = rand() % 15 + 5;
-    flags = this->state.flags;
+  if ((flags & 8u) != 0 && this->state.stateCnt % this->state.chCnt == 0) {
+    this->state.longitude = static_cast<float>(rand() % 10) + (this->state.longitude - 5.0f);
+    this->state.latitude = static_cast<float>(rand() % 10) + (this->state.latitude - 5.0f);
+    reinterpret_cast<struct matrix*>(this->state.transform)->MakeXRotation(GetRadian(static_cast<int>(this->state.latitude)));
+    reinterpret_cast<struct matrix*>(this->state.transform)->AppendYRotation(GetRadian(static_cast<int>(this->state.longitude)));
+    this->state.chCnt = rand() % 15 + 5;
+    flags = this->state.pattern;
   }
 
-  this->render.position.x = positionX + this->state.offset.x;
-  this->render.position.y = positionY + this->state.offset.y;
-  this->render.position.z = positionZ + this->state.offset.z;
+  this->render.position.x = positionX + this->state.deltaPos.x;
+  this->render.position.y = positionY + this->state.deltaPos.y;
+  this->render.position.z = positionZ + this->state.deltaPos.z;
 
   if ((flags & 0x20u) != 0) {
-    this->state.unknown_0314 = this->render.angle - static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->camera.yaw;
+    this->state.roll = this->render.angle - static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->camera.yaw;
   }
 
   this->state.ProcessAlpha();
@@ -2814,33 +2814,33 @@ bool CEffectPrim::Prim3DParticleNoMaster() {
 // FUNCTION: fn_19782
 bool CEffectPrim::Prim3DParticleOrbit() {
   const CRagEffect* master = this->state.master;
-  this->state.origin = {master->render.position.x, master->render.position.y, master->render.position.z};
+  this->state.orgPos = {master->render.position.x, master->render.position.y, master->render.position.z};
 
-  const float lateral = this->state.unknown_033C + this->state.unknown_0330;
-  float vertical = this->state.unknown_02EC + this->state.unknown_02F0;
-  const float spread = this->state.unknown_034C + this->state.unknown_0350;
-  this->state.unknown_0330 = lateral;
-  const float angle = lateral + this->state.unknown_030C;
-  this->state.unknown_02EC = vertical;
-  vertical = vertical + this->state.velocity.y;
-  const float side = spread + this->state.unknown_0348;
-  this->state.unknown_030C = angle;
-  this->state.velocity.y = vertical;
-  this->state.unknown_0348 = side;
+  const float lateral = this->state.longAccel + this->state.longSpeed;
+  float vertical = this->state.gravSpeed + this->state.gravAccel;
+  const float spread = this->state.radiusSpeed + this->state.radiusAccel;
+  this->state.longSpeed = lateral;
+  const float angle = lateral + this->state.longitude;
+  this->state.gravSpeed = vertical;
+  vertical = vertical + this->state.deltaPos2.y;
+  const float side = spread + this->state.radius;
+  this->state.longitude = angle;
+  this->state.deltaPos2.y = vertical;
+  this->state.radius = side;
 
-  const float moveX = this->state.origin.x + this->state.velocity.x;
-  this->state.origin.y = vertical + this->state.origin.y;
-  this->state.origin.x = moveX;
-  this->state.origin.z = this->state.velocity.z + this->state.origin.z;
-  const int frame = this->state.unknown_01E0;
-  this->state.unknown_0314 = this->state.unknown_0338 + this->state.unknown_0314;
+  const float moveX = this->state.orgPos.x + this->state.deltaPos2.x;
+  this->state.orgPos.y = vertical + this->state.orgPos.y;
+  this->state.orgPos.x = moveX;
+  this->state.orgPos.z = this->state.deltaPos2.z + this->state.orgPos.z;
+  const int frame = this->state.stateCnt;
+  this->state.roll = this->state.rollSpeed + this->state.roll;
 
-  if (frame == this->state.unknown_0200) {
-    this->state.unknown_02EC = this->state.unknown_029C;
-    this->state.unknown_02F0 = this->state.unknown_02A0;
+  if (frame == this->state.changePoint) {
+    this->state.gravSpeed = this->state.changeSpeed;
+    this->state.gravAccel = this->state.changeAccel;
   }
 
-  if (this->state.unknown_0158 != 0) {
+  if (this->state.chRadiSpeed != 0) {
     int index = this->state.unknown_01D8;
     const std::uint32_t count = static_cast<std::uint32_t>(this->state.unknown_0258[0].size());
 
@@ -2850,24 +2850,24 @@ bool CEffectPrim::Prim3DParticleOrbit() {
     }
 
     if (static_cast<float>(frame) == this->state.unknown_0258[0][index]) {
-      this->state.unknown_034C = this->state.unknown_0258[1][index];
-      this->state.unknown_0350 = this->state.unknown_0258[2][index];
+      this->state.radiusSpeed = this->state.unknown_0258[1][index];
+      this->state.radiusAccel = this->state.unknown_0258[2][index];
       this->state.unknown_01D8 = index + 1;
     }
   }
 
-  reinterpret_cast<struct matrix*>(this->state.matrix1)->MakeYRotation(GetRadian(static_cast<int>(this->state.unknown_030C)));
+  reinterpret_cast<struct matrix*>(this->state.transform)->MakeYRotation(GetRadian(static_cast<int>(this->state.longitude)));
 
-  const float distance = this->state.unknown_0348;
-  this->state.offset = Forward(distance, this->state.matrix1);
-  this->render.position.x = this->state.offset.x + this->state.origin.x;
-  this->render.position.y = this->state.offset.y + this->state.origin.y;
-  this->render.position.z = this->state.offset.z + this->state.origin.z;
+  const float distance = this->state.radius;
+  this->state.deltaPos = Forward(distance, this->state.transform);
+  this->render.position.x = this->state.deltaPos.x + this->state.orgPos.x;
+  this->render.position.y = this->state.deltaPos.y + this->state.orgPos.y;
+  this->render.position.z = this->state.deltaPos.z + this->state.orgPos.z;
 
-  this->state.scale = this->state.unknown_031C + this->state.scale;
-  const float rotation = this->state.unknown_0334 + this->state.unknown_0310;
-  this->state.unknown_0310 = rotation;
-  reinterpret_cast<struct matrix*>(this->state.matrix1)->AppendZRotation(rotation);
+  this->state.size = this->state.sizeSpeed + this->state.size;
+  const float rotation = this->state.latiSpeed + this->state.latitude;
+  this->state.latitude = rotation;
+  reinterpret_cast<struct matrix*>(this->state.transform)->AppendZRotation(rotation);
 
   this->state.ProcessAlpha();
   this->ShiftSegment();
@@ -2878,33 +2878,33 @@ bool CEffectPrim::Prim3DParticleOrbit() {
 // FUNCTION: fn_19783
 bool CEffectPrim::Prim3DParticleSpline() {
   const CRagEffect* master = this->state.master;
-  this->state.origin = {
-    master->render.position.x + this->state.velocity.x, master->render.position.y + this->state.velocity.y,
-    master->render.position.z + this->state.velocity.z
+  this->state.orgPos = {
+    master->render.position.x + this->state.deltaPos2.x, master->render.position.y + this->state.deltaPos2.y,
+    master->render.position.z + this->state.deltaPos2.z
   };
 
-  const int angle = static_cast<int>(this->state.unknown_0314);
-  const float lateral = this->state.unknown_0334;
-  this->state.unknown_0334 = lateral + this->state.unknown_0340;
-  this->state.unknown_0310 = lateral + this->state.unknown_0310;
-  this->state.unknown_02BC = this->state.unknown_02C0 + this->state.unknown_02BC;
-  this->state.unknown_02EC = this->state.unknown_02F0 + this->state.unknown_02EC;
+  const int angle = static_cast<int>(this->state.roll);
+  const float lateral = this->state.latiSpeed;
+  this->state.latiSpeed = lateral + this->state.latiAccel;
+  this->state.latitude = lateral + this->state.latitude;
+  this->state.speed = this->state.accel + this->state.speed;
+  this->state.gravSpeed = this->state.gravAccel + this->state.gravSpeed;
 
-  const float distance = this->state.unknown_02BC - this->state.unknown_02EC;
-  this->state.unknown_0370 = Forward(distance, this->state.matrix1);
-  reinterpret_cast<struct matrix*>(this->state.matrix2)->MakeTransform(this->state.unknown_0290, GetRadian(angle));
+  const float distance = this->state.speed - this->state.gravSpeed;
+  this->state.speed3d = Forward(distance, this->state.transform);
+  reinterpret_cast<struct matrix*>(this->state.rotTransform)->MakeTransform(this->state.rotAxis, GetRadian(angle));
 
-  const float move = this->state.unknown_0310;
-  this->state.unknown_03A0 = Lift(move, this->state.matrix2);
-  this->state.scale = this->state.unknown_031C + this->state.scale;
+  const float move = this->state.latitude;
+  this->state.deltaPos3 = Lift(move, this->state.rotTransform);
+  this->state.size = this->state.sizeSpeed + this->state.size;
 
-  this->state.offset.x = this->state.offset.x - this->state.unknown_0370.x;
-  this->state.offset.y = this->state.offset.y - this->state.unknown_0370.y;
-  this->state.offset.z = this->state.offset.z - this->state.unknown_0370.z;
+  this->state.deltaPos.x = this->state.deltaPos.x - this->state.speed3d.x;
+  this->state.deltaPos.y = this->state.deltaPos.y - this->state.speed3d.y;
+  this->state.deltaPos.z = this->state.deltaPos.z - this->state.speed3d.z;
 
-  this->render.position.x = this->state.offset.x + this->state.origin.x + this->state.unknown_03A0.x;
-  this->render.position.y = this->state.offset.y + this->state.origin.y + this->state.unknown_03A0.y;
-  this->render.position.z = this->state.offset.z + this->state.origin.z + this->state.unknown_03A0.z;
+  this->render.position.x = this->state.deltaPos.x + this->state.orgPos.x + this->state.deltaPos3.x;
+  this->render.position.y = this->state.deltaPos.y + this->state.orgPos.y + this->state.deltaPos3.y;
+  this->render.position.z = this->state.deltaPos.z + this->state.orgPos.z + this->state.deltaPos3.z;
 
   this->state.ProcessAlpha();
   this->ShiftSegment();
@@ -2914,7 +2914,7 @@ bool CEffectPrim::Prim3DParticleSpline() {
 // OFFSET: 0x00BE6FE0
 // FUNCTION: fn_19931
 void CEffectPrim::ShiftSegment() {
-  const int count = this->state.unknown_01F4;
+  const int count = this->state.numSegment;
 
   for (int index = count - 1; index > 0; --index) {
     EffectPrimitiveRecord& record = this->state.records[index];
@@ -2934,7 +2934,7 @@ void CEffectPrim::ShiftSegment() {
     const std::uint32_t green = static_cast<unsigned char>(this->state.green);
     const std::uint32_t blue = static_cast<unsigned char>(this->state.blue);
     record.color = (static_cast<std::uint32_t>(static_cast<int>(record.alpha)) << 24) | (red << 16) | (green << 8) | blue;
-    record.scale = this->state.scale - this->state.scale / static_cast<float>(count) * static_cast<float>(index) * 0.5f;
+    record.scale = this->state.size - this->state.size / static_cast<float>(count) * static_cast<float>(index) * 0.5f;
   }
 
   EffectPrimitiveRecord& first = this->state.records[0];
@@ -2943,13 +2943,13 @@ void CEffectPrim::ShiftSegment() {
   first.position.z = this->render.position.z;
 
   for (int corner = 0; corner < 4; ++corner) {
-    first.corners[corner] = this->state.corners[corner];
+    first.corners[corner] = this->state.segPos[corner];
   }
 
-  first.unknown_003C = this->state.unknown_0348;
-  first.scale = this->state.scale;
-  first.angle = this->state.unknown_030C;
-  std::memcpy(first.matrix, this->state.matrix1, sizeof(first.matrix));
+  first.unknown_003C = this->state.radius;
+  first.scale = this->state.size;
+  first.angle = this->state.longitude;
+  std::memcpy(first.matrix, this->state.transform, sizeof(first.matrix));
   first.alpha = this->state.alpha;
 
   const std::uint32_t red = static_cast<unsigned char>(this->state.red);
@@ -3837,10 +3837,10 @@ void CEffectPrim::PrimSTIN4() {
 
     const CRenderObject* target;
 
-    if (this->state.offset.y == static_cast<float>(g_session.m_aid)) {
+    if (this->state.deltaPos.y == static_cast<float>(g_session.m_aid)) {
       target = reinterpret_cast<const CRenderObject*>(gameMode->scene->player);
     } else {
-      target = gameMode->scene->GetGameActorByAID(static_cast<std::uint32_t>(this->state.offset.y));
+      target = gameMode->scene->GetGameActorByAID(static_cast<std::uint32_t>(this->state.deltaPos.y));
     }
 
     if (target == nullptr) {
@@ -4153,7 +4153,7 @@ void CEffectPrim::PrimGI1() {
       if (slot.alphaB <= 0) {
         slot.alphaB = 0;
 
-        if (process < this->state.lifetime - 30) {
+        if (process < this->state.duration - 30) {
           slot.distance = 3.37f;
           slot.riseAngle = 74;
         }
diff --git a/Source/Contents/Effects/EffectPrimitiveRecords.cpp b/Source/Contents/Effects/EffectPrimitiveRecords.cpp
index e30c45de..47dc4203 100644
--- a/Source/Contents/Effects/EffectPrimitiveRecords.cpp
+++ b/Source/Contents/Effects/EffectPrimitiveRecords.cpp
@@ -8,14 +8,14 @@
 // OFFSET: 0x00BAE670
 // FUNCTION: fn_19768
 void CEffectPrim::InitSegment() {
-  for (int index = 0; index < this->state.unknown_01F4; ++index) {
+  for (int index = 0; index < this->state.numSegment; ++index) {
     EffectPrimitiveRecord& record = this->state.records[index];
     record.position = this->render.position;
-    std::memcpy(record.corners, this->state.corners, sizeof(record.corners));
-    record.unknown_003C = this->state.unknown_0348;
-    record.scale = this->state.scale;
-    record.angle = this->state.unknown_030C;
-    std::memcpy(record.matrix, this->state.matrix1, sizeof(record.matrix));
+    std::memcpy(record.corners, this->state.segPos, sizeof(record.corners));
+    record.unknown_003C = this->state.radius;
+    record.scale = this->state.size;
+    record.angle = this->state.longitude;
+    std::memcpy(record.matrix, this->state.transform, sizeof(record.matrix));
     record.alpha = this->state.alpha;
     record.red = this->state.red;
     record.green = this->state.green;
diff --git a/Source/Contents/Effects/EffectPrimitiveRendering.cpp b/Source/Contents/Effects/EffectPrimitiveRendering.cpp
index 0b317ba8..df80acdf 100644
--- a/Source/Contents/Effects/EffectPrimitiveRendering.cpp
+++ b/Source/Contents/Effects/EffectPrimitiveRendering.cpp
@@ -21,21 +21,21 @@
 // OFFSET: 0x00BCD960
 // FUNCTION: fn_19865
 void DrawEffectPrimitive15(EffectPrimitiveState& particle, const RenderObjectState& render, EffectPrimitiveRenderContext& context) {
-  const float width = particle.unknown_0354;
+  const float width = particle.widthSize;
   const float left = -width;
-  float top = -particle.unknown_0360;
-  float bottom = particle.unknown_0360;
+  float top = -particle.heightSize;
+  float bottom = particle.heightSize;
 
-  if ((particle.flags & 0x80u) != 0) {
+  if ((particle.pattern & 0x80u) != 0) {
     top = top + top;
     bottom = 0.0f;
   }
 
-  if ((particle.flags & 8u) != 0) {
+  if ((particle.pattern & 8u) != 0) {
     bottom = 0.0f;
   }
 
-  const float* matrix = particle.matrix2;
+  const float* matrix = particle.rotTransform;
   const float zeroX = matrix[0] * 0.0f;
   const float zeroY = matrix[1] * 0.0f;
   const float zeroZ = matrix[2] * 0.0f;
@@ -61,8 +61,8 @@ void DrawEffectPrimitive15(EffectPrimitiveState& particle, const RenderObjectSta
 
   constexpr unsigned indices[2][3] = {{0, 1, 2}, {3, 2, 1}};
   constexpr float u[2][3] = {{0, 1, 0}, {1, 0, 1}};
-  const float vTop = particle.unknown_02E4;
-  const float vBottom = particle.unknown_02E8;
+  const float vTop = particle.v1;
+  const float vBottom = particle.v2;
   const float v[2][3] = {{vTop, vTop, vBottom}, {vBottom, vBottom, vTop}};
 
   for (unsigned triangleIndex = 0; triangleIndex < 2; ++triangleIndex) {
@@ -75,7 +75,7 @@ void DrawEffectPrimitive15(EffectPrimitiveState& particle, const RenderObjectSta
       context.projection.Project(position, context.cameraMatrix, projected);
       RenderVertex& vertex = triangle.vertices[vertexIndex];
       vertex = projected;
-      vertex.diffuse = particle.unknown_01C0;
+      vertex.diffuse = particle.argb;
       vertex.u = u[triangleIndex][vertexIndex];
       vertex.v = v[triangleIndex][vertexIndex];
     }
@@ -88,7 +88,7 @@ void DrawEffectPrimitive15(EffectPrimitiveState& particle, const RenderObjectSta
 
     if (triangle.Visible()) {
       context.queues.SubmitTriangle(
-        triangle, static_cast<std::uint16_t>(particle.unknown_01C4), context.commands, context.depthAlpha, context.depthStart, context.depthEnd
+        triangle, static_cast<std::uint16_t>(particle.renderFlag), context.commands, context.depthAlpha, context.depthStart, context.depthEnd
       );
     }
   }
@@ -204,7 +204,7 @@ void CEffectPrim::RenderTeiRect(
 
     if (triangle.Visible()) {
       g_renderer->queues.SubmitTriangle(
-        triangle, static_cast<std::uint16_t>(this->state.unknown_01C4), g_renderer->commands, g_renderer->fog.supported != 0, g_depthStart, g_depthEnd
+        triangle, static_cast<std::uint16_t>(this->state.renderFlag), g_renderer->commands, g_renderer->fog.supported != 0, g_depthStart, g_depthEnd
       );
       ++*rpCnt;
     }
@@ -227,7 +227,7 @@ void CEffectPrim::RenderTeiRect(
   int blue = 255;
   float textureV = 1.0f;
 
-  switch (static_cast<int>(this->state.scale)) {
+  switch (static_cast<int>(this->state.size)) {
   case 0:
     blend = 6;
     break;
@@ -500,7 +500,7 @@ void CEffectPrim::RenderTeiRect(
 
     if (triangle.Visible()) {
       g_renderer->queues.SubmitTriangle(
-        triangle, static_cast<std::uint16_t>(this->state.unknown_01C4), g_renderer->commands, g_renderer->fog.supported != 0, g_depthStart, g_depthEnd
+        triangle, static_cast<std::uint16_t>(this->state.renderFlag), g_renderer->commands, g_renderer->fog.supported != 0, g_depthStart, g_depthEnd
       );
       ++*rpCnt;
     }
@@ -579,7 +579,7 @@ void CEffectPrim::RenderTeiRect(
 
     if (triangle.Visible()) {
       g_renderer->queues.SubmitTriangle(
-        triangle, static_cast<std::uint16_t>(this->state.unknown_01C4), g_renderer->commands, g_renderer->fog.supported != 0, g_depthStart, g_depthEnd
+        triangle, static_cast<std::uint16_t>(this->state.renderFlag), g_renderer->commands, g_renderer->fog.supported != 0, g_depthStart, g_depthEnd
       );
       ++*rpCnt;
     }
@@ -1306,7 +1306,7 @@ void CEffectPrim::RenderSMA2(matrix& wtm) {
       const float sn1 = g_sinTable[angle];
       const float rx = g_cosTable[slot.riseAngle] * slot.height[order];
       const float ry = g_sinTable[slot.riseAngle] * slot.height[order];
-      const vector3d& delta = this->state.offset;
+      const vector3d& delta = this->state.deltaPos;
       const vector3d vec2{cs1 * slot.distance + delta.x, delta.y + 0.0f, sn1 * slot.distance + delta.z};
       const vector3d vec4{cs1 * rx + cs1 * slot.distance + delta.x, delta.y - ry, sn1 * rx + sn1 * slot.distance + delta.z};
 
diff --git a/Source/Contents/Effects/EffectPrimitiveState.cpp b/Source/Contents/Effects/EffectPrimitiveState.cpp
index 0a253355..b2b3a06b 100644
--- a/Source/Contents/Effects/EffectPrimitiveState.cpp
+++ b/Source/Contents/Effects/EffectPrimitiveState.cpp
@@ -17,111 +17,111 @@ EffectPrimitiveSlot::EffectPrimitiveSlot() {
 // INLINED
 EffectPrimitiveState::EffectPrimitiveState(RenderObjectState& render) {
   this->textures = nullptr;
-  this->unknown_0208 = 0;
-  this->unknown_0148 = 0;
-  this->unknown_01CC = 0;
+  this->playWaveType = 0;
+  this->playWaveName = 0;
   this->type = 0;
-  this->flags = 0;
-  this->unknown_01C4 = 1;
+  this->count = 0;
+  this->pattern = 0;
+  this->renderFlag = 1;
   this->unknown_014C.x = 0;
   this->unknown_014C.y = 0;
   this->unknown_014C.z = 0;
-  this->unknown_0158 = 0;
-  this->unknown_015C = 0;
+  this->chRadiSpeed = 0;
+  this->isDisappear = 0;
   this->unknown_0138 = 0;
   this->master = nullptr;
-  this->unknown_01D4 = 0;
+  this->chCnt = 0;
   this->unknown_01D8 = 0;
-  this->unknown_01E0 = 0;
-  this->unknown_0348 = 0;
-  this->unknown_028C = 0;
-  this->unknown_0288 = 36.0f;
+  this->stateCnt = 0;
+  this->radius = 0;
+  this->minRadius = 0;
+  this->arcAngle = 36.0f;
   render.angle = 0;
-  this->unknown_01F8 = 180;
-  this->scale = 1.0f;
-  this->unknown_02F4 = 0;
-  this->unknown_02F8 = 0;
-  this->unknown_0354 = 0.0f;
-  this->unknown_0360 = 0.0f;
-  this->unknown_036C = 100.0f;
-  this->unknown_02BC = 0.0f;
-  this->unknown_031C = 0.0f;
-  this->unknown_034C = 0.0f;
-  this->unknown_0300 = 0;
-  this->unknown_02FC = 0;
-  this->unknown_0330 = 0;
-  this->unknown_0334 = 0;
-  this->unknown_0338 = 0;
-  this->unknown_0358 = 0.0f;
-  this->unknown_0364 = 0.0f;
+  this->validAngle = 180;
+  this->size = 1.0f;
+  this->innerSize = 0;
+  this->outerSize = 0;
+  this->widthSize = 0.0f;
+  this->heightSize = 0.0f;
+  this->maxHeightSize = 100.0f;
+  this->speed = 0.0f;
+  this->sizeSpeed = 0.0f;
+  this->radiusSpeed = 0.0f;
+  this->outerSpeed = 0;
+  this->innerSpeed = 0;
+  this->longSpeed = 0;
+  this->latiSpeed = 0;
+  this->rollSpeed = 0;
+  this->widthSpeed = 0.0f;
+  this->heightSpeed = 0.0f;
   this->alphaSpeed = 0.0f;
-  this->unknown_02EC = 0;
-  this->unknown_02C0 = 0.0f;
-  this->unknown_0320 = 0;
-  this->unknown_0350 = 0.0f;
-  this->unknown_02F0 = 0;
-  this->unknown_033C = 0;
-  this->unknown_0340 = 0;
-  this->unknown_0344 = 0;
-  this->unknown_0308 = 0;
-  this->unknown_0304 = 0;
-  this->unknown_035C = 0;
-  this->unknown_0368 = 0;
+  this->gravSpeed = 0;
+  this->accel = 0.0f;
+  this->sizeAccel = 0;
+  this->radiusAccel = 0.0f;
+  this->gravAccel = 0;
+  this->longAccel = 0;
+  this->latiAccel = 0;
+  this->rollAccel = 0;
+  this->outerAccel = 0;
+  this->innerAccel = 0;
+  this->widthAccel = 0;
+  this->heightAccel = 0;
   this->red = 255;
   this->green = 255;
   this->blue = 255;
-  this->unknown_0248 = 0;
-  this->unknown_024C = 0;
-  this->unknown_0250 = 0;
-  this->unknown_0200 = -1;
-  this->unknown_02C8 = 0.0001f;
-  this->unknown_02CC = 0.0001f;
-  this->unknown_029C = 0.0001f;
-  this->unknown_02A4.x = 0;
-  this->unknown_02A4.y = 0;
-  this->unknown_02A4.z = 0;
-  this->unknown_02B0.x = 0;
-  this->unknown_02B0.y = 0;
-  this->unknown_02B0.z = 0;
-  this->unknown_02C4 = 0.0001f;
-  this->unknown_02D0 = 0.0001f;
-  this->unknown_02A0 = 0.0001f;
-  this->unknown_01FC = 0;
-  this->unknown_0234 = 0;
-  this->unknown_0238 = 0;
-  this->unknown_030C = 0;
-  this->unknown_0310 = 0;
-  this->unknown_0314 = 0.0f;
-  this->lifetime = 100;
-  this->unknown_01EC = -1;
-  this->unknown_01F0 = -1;
-  this->unknown_01C0 = -1;
+  this->redSpeed = 0;
+  this->greenSpeed = 0;
+  this->blueSpeed = 0;
+  this->changePoint = -1;
+  this->changeWidthSpeed = 0.0001f;
+  this->changeHeightSpeed = 0.0001f;
+  this->changeSpeed = 0.0001f;
+  this->changeSpeed3d.x = 0;
+  this->changeSpeed3d.y = 0;
+  this->changeSpeed3d.z = 0;
+  this->changeAccel3d.x = 0;
+  this->changeAccel3d.y = 0;
+  this->changeAccel3d.z = 0;
+  this->changeWidthAccel = 0.0001f;
+  this->changeHeightAccel = 0.0001f;
+  this->changeAccel = 0.0001f;
+  this->RGBCycleCnt = 0;
+  this->RGBCycleDelay = 0;
+  this->commonPattern = 0;
+  this->longitude = 0;
+  this->latitude = 0;
+  this->roll = 0.0f;
+  this->duration = 100;
+  this->fadeInCnt = -1;
+  this->fadeOutCnt = -1;
+  this->argb = -1;
   this->alpha = 254.0f;
   this->alphaDelta = 1.0f;
-  this->unknown_02D4 = 254.0f;
-  this->unknown_02D8 = 0;
-  this->unknown_0254 = 1;
-  this->unknown_01F4 = 1;
-  this->unknown_01E8 = 4;
+  this->maxAlpha = 254.0f;
+  this->minAlpha = 0;
+  this->repeatAnim = 1;
+  this->numSegment = 1;
+  this->animSpeed = 4;
   render.previousAnimation = 0;
   render.curMotion = 0;
-  this->textureCount = 1;
-  this->unknown_02E4 = 0;
+  this->totalTexture = 1;
+  this->v1 = 0;
   this->unknown_02DC = 0;
-  this->unknown_02E8 = 1.0f;
-  this->unknown_02E0 = 1.0f;
+  this->v2 = 1.0f;
+  this->u2 = 1.0f;
   this->unknown_01C8[0] = 0;
   this->unknown_FA10 = 0;
   this->unknown_FA14 = 0;
 
-  this->unknown_0370 = {};
-  this->origin = {};
-  this->offset = {};
-  this->velocity = {};
-  this->unknown_03A0 = {};
-  this->unknown_03AC = {};
+  this->speed3d = {};
+  this->orgPos = {};
+  this->deltaPos = {};
+  this->deltaPos2 = {};
+  this->deltaPos3 = {};
+  this->deltaPosAccel = {};
 
-  for (vector3d& corner : this->corners) {
+  for (vector3d& corner : this->segPos) {
     corner = {};
   }
 
@@ -139,8 +139,8 @@ EffectPrimitiveState::EffectPrimitiveState(RenderObjectState& render) {
     }
   }
 
-  std::memcpy(this->matrix1, g_identityMatrix, sizeof(g_identityMatrix));
-  std::memcpy(this->matrix2, g_identityMatrix, sizeof(g_identityMatrix));
+  std::memcpy(this->transform, g_identityMatrix, sizeof(g_identityMatrix));
+  std::memcpy(this->rotTransform, g_identityMatrix, sizeof(g_identityMatrix));
   std::memset(this->slots, 0, sizeof(this->slots));
 }
 
@@ -200,15 +200,15 @@ void __stdcall Get_Angle(float x, float y, std::int16_t* angle) {
 void EffectPrimitiveState::Initialize(
   RenderObjectState& render, CRagEffect& master, const RenderObjectState& masterRender, int type, float x, float y, float z
 ) {
-  const float first = x + this->offset.x;
+  const float first = x + this->deltaPos.x;
   this->master = &master;
-  this->type = type;
-  this->offset.x = first;
-  this->offset.y = y + this->offset.y;
-  this->offset.z = z + this->offset.z;
-  this->origin = {masterRender.position.x, masterRender.position.y, masterRender.position.z};
-  render.position.x = this->origin.x;
-  render.position.y = this->origin.y;
-  render.position.z = this->origin.z;
-  this->unknown_013C = 0;
+  this->count = type;
+  this->deltaPos.x = first;
+  this->deltaPos.y = y + this->deltaPos.y;
+  this->deltaPos.z = z + this->deltaPos.z;
+  this->orgPos = {masterRender.position.x, masterRender.position.y, masterRender.position.z};
+  render.position.x = this->orgPos.x;
+  render.position.y = this->orgPos.y;
+  render.position.z = this->orgPos.z;
+  this->isChangeProcessed = 0;
 }
diff --git a/Source/Contents/Effects/EffectPrimitiveState.h b/Source/Contents/Effects/EffectPrimitiveState.h
index 5f7d0713..48fee631 100644
--- a/Source/Contents/Effects/EffectPrimitiveState.h
+++ b/Source/Contents/Effects/EffectPrimitiveState.h
@@ -61,105 +61,105 @@ struct EffectPrimitiveState {
   void GetColorOverride(unsigned char* red, unsigned char* green, unsigned char* blue);
 
   /* 0138 */ std::uint32_t unknown_0138;
-  /* 013C */ std::uint32_t unknown_013C;
+  /* 013C */ std::uint32_t isChangeProcessed;
   /* 0140 */ CRagEffect* master;
   /* 0144 */ CTexture** textures;
-  /* 0148 */ std::uint32_t unknown_0148;
+  /* 0148 */ std::uint32_t playWaveName;
   /* 014C */ vector3d unknown_014C;
-  /* 0158 */ std::uint32_t unknown_0158;
-  /* 015C */ std::uint32_t unknown_015C;
-  /* 0160 */ float matrix1[12];
-  /* 0190 */ float matrix2[12];
-  /* 01C0 */ std::uint32_t unknown_01C0;
-  /* 01C4 */ std::uint32_t unknown_01C4;
+  /* 0158 */ std::uint32_t chRadiSpeed;
+  /* 015C */ std::uint32_t isDisappear;
+  /* 0160 */ float transform[12];
+  /* 0190 */ float rotTransform[12];
+  /* 01C0 */ std::uint32_t argb;
+  /* 01C4 */ std::uint32_t renderFlag;
   /* 01C8 */ unsigned char unknown_01C8[4];
-  /* 01CC */ std::uint32_t unknown_01CC;
-  /* 01D0 */ int type;
-  /* 01D4 */ std::uint32_t unknown_01D4;
+  /* 01CC */ std::uint32_t type;
+  /* 01D0 */ int count;
+  /* 01D4 */ std::uint32_t chCnt;
   /* 01D8 */ int unknown_01D8;
-  /* 01DC */ std::uint32_t flags;
-  /* 01E0 */ int unknown_01E0;
-  /* 01E4 */ int lifetime;
-  /* 01E8 */ int unknown_01E8;
-  /* 01EC */ int unknown_01EC;
-  /* 01F0 */ int unknown_01F0;
-  /* 01F4 */ int unknown_01F4;
-  /* 01F8 */ int unknown_01F8;
-  /* 01FC */ std::uint32_t unknown_01FC;
-  /* 0200 */ int unknown_0200;
-  /* 0204 */ unsigned textureCount;
-  /* 0208 */ std::uint32_t unknown_0208;
+  /* 01DC */ std::uint32_t pattern;
+  /* 01E0 */ int stateCnt;
+  /* 01E4 */ int duration;
+  /* 01E8 */ int animSpeed;
+  /* 01EC */ int fadeInCnt;
+  /* 01F0 */ int fadeOutCnt;
+  /* 01F4 */ int numSegment;
+  /* 01F8 */ int validAngle;
+  /* 01FC */ std::uint32_t RGBCycleCnt;
+  /* 0200 */ int changePoint;
+  /* 0204 */ unsigned totalTexture;
+  /* 0208 */ std::uint32_t playWaveType;
   /* 020C */ unsigned char unknown_020C[40];
-  /* 0234 */ std::uint32_t unknown_0234;
-  /* 0238 */ std::uint32_t unknown_0238;
+  /* 0234 */ std::uint32_t RGBCycleDelay;
+  /* 0238 */ std::uint32_t commonPattern;
   /* 023C */ int red;
   /* 0240 */ int green;
   /* 0244 */ int blue;
-  /* 0248 */ int unknown_0248;
-  /* 024C */ int unknown_024C;
-  /* 0250 */ int unknown_0250;
-  /* 0254 */ unsigned char unknown_0254;
+  /* 0248 */ int redSpeed;
+  /* 024C */ int greenSpeed;
+  /* 0250 */ int blueSpeed;
+  /* 0254 */ unsigned char repeatAnim;
   /* 0255 */ unsigned char unknown_0255[3];
   /* 0258 */ std::vector<float> unknown_0258[4];
-  /* 0288 */ float unknown_0288;
-  /* 028C */ std::uint32_t unknown_028C;
-  /* 0290 */ float unknown_0290[3];
-  /* 029C */ float unknown_029C;
-  /* 02A0 */ float unknown_02A0;
-  /* 02A4 */ vector3d unknown_02A4;
-  /* 02B0 */ vector3d unknown_02B0;
-  /* 02BC */ float unknown_02BC;
-  /* 02C0 */ float unknown_02C0;
-  /* 02C4 */ float unknown_02C4;
-  /* 02C8 */ float unknown_02C8;
-  /* 02CC */ float unknown_02CC;
-  /* 02D0 */ float unknown_02D0;
-  /* 02D4 */ float unknown_02D4;
-  /* 02D8 */ float unknown_02D8;
+  /* 0288 */ float arcAngle;
+  /* 028C */ std::uint32_t minRadius;
+  /* 0290 */ float rotAxis[3];
+  /* 029C */ float changeSpeed;
+  /* 02A0 */ float changeAccel;
+  /* 02A4 */ vector3d changeSpeed3d;
+  /* 02B0 */ vector3d changeAccel3d;
+  /* 02BC */ float speed;
+  /* 02C0 */ float accel;
+  /* 02C4 */ float changeWidthAccel;
+  /* 02C8 */ float changeWidthSpeed;
+  /* 02CC */ float changeHeightSpeed;
+  /* 02D0 */ float changeHeightAccel;
+  /* 02D4 */ float maxAlpha;
+  /* 02D8 */ float minAlpha;
   /* 02DC */ std::uint32_t unknown_02DC;
-  /* 02E0 */ float unknown_02E0;
-  /* 02E4 */ float unknown_02E4;
-  /* 02E8 */ float unknown_02E8;
-  /* 02EC */ float unknown_02EC;
-  /* 02F0 */ float unknown_02F0;
-  /* 02F4 */ float unknown_02F4;
-  /* 02F8 */ float unknown_02F8;
-  /* 02FC */ float unknown_02FC;
-  /* 0300 */ float unknown_0300;
-  /* 0304 */ float unknown_0304;
-  /* 0308 */ float unknown_0308;
-  /* 030C */ float unknown_030C;
-  /* 0310 */ float unknown_0310;
-  /* 0314 */ float unknown_0314;
-  /* 0318 */ float scale;
-  /* 031C */ float unknown_031C;
-  /* 0320 */ float unknown_0320;
+  /* 02E0 */ float u2;
+  /* 02E4 */ float v1;
+  /* 02E8 */ float v2;
+  /* 02EC */ float gravSpeed;
+  /* 02F0 */ float gravAccel;
+  /* 02F4 */ float innerSize;
+  /* 02F8 */ float outerSize;
+  /* 02FC */ float innerSpeed;
+  /* 0300 */ float outerSpeed;
+  /* 0304 */ float innerAccel;
+  /* 0308 */ float outerAccel;
+  /* 030C */ float longitude;
+  /* 0310 */ float latitude;
+  /* 0314 */ float roll;
+  /* 0318 */ float size;
+  /* 031C */ float sizeSpeed;
+  /* 0320 */ float sizeAccel;
   /* 0324 */ float alpha;
   /* 0328 */ float alphaSpeed;
   /* 032C */ float alphaDelta;
-  /* 0330 */ float unknown_0330;
-  /* 0334 */ float unknown_0334;
-  /* 0338 */ float unknown_0338;
-  /* 033C */ float unknown_033C;
-  /* 0340 */ float unknown_0340;
-  /* 0344 */ float unknown_0344;
-  /* 0348 */ float unknown_0348;
-  /* 034C */ float unknown_034C;
-  /* 0350 */ float unknown_0350;
-  /* 0354 */ float unknown_0354;
-  /* 0358 */ float unknown_0358;
-  /* 035C */ float unknown_035C;
-  /* 0360 */ float unknown_0360;
-  /* 0364 */ float unknown_0364;
-  /* 0368 */ float unknown_0368;
-  /* 036C */ float unknown_036C;
-  /* 0370 */ vector3d unknown_0370;
-  /* 037C */ vector3d origin;
-  /* 0388 */ vector3d offset;
-  /* 0394 */ vector3d velocity;
-  /* 03A0 */ vector3d unknown_03A0;
-  /* 03AC */ vector3d unknown_03AC;
-  /* 03B8 */ vector3d corners[4];
+  /* 0330 */ float longSpeed;
+  /* 0334 */ float latiSpeed;
+  /* 0338 */ float rollSpeed;
+  /* 033C */ float longAccel;
+  /* 0340 */ float latiAccel;
+  /* 0344 */ float rollAccel;
+  /* 0348 */ float radius;
+  /* 034C */ float radiusSpeed;
+  /* 0350 */ float radiusAccel;
+  /* 0354 */ float widthSize;
+  /* 0358 */ float widthSpeed;
+  /* 035C */ float widthAccel;
+  /* 0360 */ float heightSize;
+  /* 0364 */ float heightSpeed;
+  /* 0368 */ float heightAccel;
+  /* 036C */ float maxHeightSize;
+  /* 0370 */ vector3d speed3d;
+  /* 037C */ vector3d orgPos;
+  /* 0388 */ vector3d deltaPos;
+  /* 0394 */ vector3d deltaPos2;
+  /* 03A0 */ vector3d deltaPos3;
+  /* 03AC */ vector3d deltaPosAccel;
+  /* 03B8 */ vector3d segPos[4];
   /* 03E8 */ EffectPrimitiveSlot slots[4];
   /* 06B8 */ EffectPrimitiveRecord records[50];
   /* 2210 */ RenderTriangle triangles[512];
diff --git a/Source/Contents/Effects/PartyEffect.cpp b/Source/Contents/Effects/PartyEffect.cpp
index 48a5bf94..38371c68 100644
--- a/Source/Contents/Effects/PartyEffect.cpp
+++ b/Source/Contents/Effects/PartyEffect.cpp
@@ -42,15 +42,15 @@ bool UpdatePartyEffect(
     CEffectPrim* particle = CreateEffectParticle(self, render, 15, 0, 0, 0, worldObjects);
     effect.unknown_11C84 = &particle->state;
     EffectPrimitiveState& state = *effect.unknown_11C84;
-    state.lifetime = 9999;
-    state.unknown_030C = 0;
-    state.unknown_0314 = 90.0f;
-    state.unknown_0354 = 4.0f;
-    state.unknown_0360 = 4.0f;
+    state.duration = 9999;
+    state.longitude = 0;
+    state.roll = 90.0f;
+    state.widthSize = 4.0f;
+    state.heightSize = 4.0f;
     state.red = 50;
     state.blue = 253;
     state.green = 50;
-    const auto bytes = state.textureCount >> 30 != 0 ? std::numeric_limits<std::size_t>::max() : static_cast<std::size_t>(4u * state.textureCount);
+    const auto bytes = state.totalTexture >> 30 != 0 ? std::numeric_limits<std::size_t>::max() : static_cast<std::size_t>(4u * state.totalTexture);
 
     state.textures = static_cast<CTexture**>(::operator new(bytes));
     state.textures[0] = textures.Load("effect\\party.tga", 0, false, true, false);
diff --git a/Source/Contents/Effects/RagEffect.cpp b/Source/Contents/Effects/RagEffect.cpp
index 8a24b8dd..dc306e3b 100644
--- a/Source/Contents/Effects/RagEffect.cpp
+++ b/Source/Contents/Effects/RagEffect.cpp
@@ -82,7 +82,7 @@ static vector3d RotatedForward(const float* matrix, float distance) {
 
 // INLINED
 static void AllocateTextures(EffectPrimitiveState& particle) {
-  const auto bytes = particle.textureCount >> 30 != 0 ? std::numeric_limits<std::size_t>::max() : static_cast<std::size_t>(4u * particle.textureCount);
+  const auto bytes = particle.totalTexture >> 30 != 0 ? std::numeric_limits<std::size_t>::max() : static_cast<std::size_t>(4u * particle.totalTexture);
   particle.textures = static_cast<CTexture**>(::operator new(bytes));
 }
 
@@ -106,33 +106,33 @@ void CRagEffect::BloodDrain() {
 
   for (int angle = -90; angle < 180; angle += 90) {
     this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 8, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-    this->state.unknown_11C84->lifetime = 60;
-    this->state.unknown_11C84->velocity = {0.0f, -10.0f, 0.0f};
-    this->state.unknown_11C84->unknown_0348 = Owner(this->state.unknown_11C84).CalcDist(this->state.offset[0], this->state.offset[2]);
+    this->state.unknown_11C84->duration = 60;
+    this->state.unknown_11C84->deltaPos2 = {0.0f, -10.0f, 0.0f};
+    this->state.unknown_11C84->radius = Owner(this->state.unknown_11C84).CalcDist(this->state.offset[0], this->state.offset[2]);
     Owner(this->state.unknown_11C84).Face(this->state.offset[0], this->state.offset[2]);
-    this->state.unknown_11C84->unknown_030C = -Owner(this->state.unknown_11C84).render.angle;
-    const float speed = this->state.unknown_11C84->unknown_0348 / this->state.unknown_11C84->lifetime;
-    this->state.unknown_11C84->unknown_02BC = speed + speed;
-    this->state.unknown_11C84->unknown_02EC = 2.0f;
-    const float rise = -(this->state.unknown_11C84->unknown_02EC / this->state.unknown_11C84->lifetime);
-    this->state.unknown_11C84->unknown_02F0 = rise + rise;
-    this->state.unknown_11C84->unknown_0334 = -2.0f;
-    const float spread = -(this->state.unknown_11C84->unknown_0334 / this->state.unknown_11C84->lifetime);
-    this->state.unknown_11C84->unknown_0340 = spread + spread;
-    this->state.unknown_11C84->unknown_0314 = static_cast<float>(angle);
+    this->state.unknown_11C84->longitude = -Owner(this->state.unknown_11C84).render.angle;
+    const float speed = this->state.unknown_11C84->radius / this->state.unknown_11C84->duration;
+    this->state.unknown_11C84->speed = speed + speed;
+    this->state.unknown_11C84->gravSpeed = 2.0f;
+    const float rise = -(this->state.unknown_11C84->gravSpeed / this->state.unknown_11C84->duration);
+    this->state.unknown_11C84->gravAccel = rise + rise;
+    this->state.unknown_11C84->latiSpeed = -2.0f;
+    const float spread = -(this->state.unknown_11C84->latiSpeed / this->state.unknown_11C84->duration);
+    this->state.unknown_11C84->latiAccel = spread + spread;
+    this->state.unknown_11C84->roll = static_cast<float>(angle);
     EffectPrimitiveState& particle = *this->state.unknown_11C84;
-    reinterpret_cast<matrix*>(particle.matrix1)->MakeYRotation(GetRadian(static_cast<int>(particle.unknown_030C)));
-    this->state.unknown_11C84->unknown_03A0 = RotatedForward(this->state.unknown_11C84->matrix1, 1.0f);
-    this->state.unknown_11C84->unknown_0290[0] = this->state.unknown_11C84->unknown_03A0.x;
-    this->state.unknown_11C84->unknown_0290[1] = this->state.unknown_11C84->unknown_03A0.y;
-    this->state.unknown_11C84->unknown_0290[2] = this->state.unknown_11C84->unknown_03A0.z;
+    reinterpret_cast<matrix*>(particle.transform)->MakeYRotation(GetRadian(static_cast<int>(particle.longitude)));
+    this->state.unknown_11C84->deltaPos3 = RotatedForward(this->state.unknown_11C84->transform, 1.0f);
+    this->state.unknown_11C84->rotAxis[0] = this->state.unknown_11C84->deltaPos3.x;
+    this->state.unknown_11C84->rotAxis[1] = this->state.unknown_11C84->deltaPos3.y;
+    this->state.unknown_11C84->rotAxis[2] = this->state.unknown_11C84->deltaPos3.z;
     this->state.unknown_11C84->red = 100;
     this->state.unknown_11C84->green = 100;
     this->state.unknown_11C84->blue = 250;
-    this->state.unknown_11C84->scale = 1.7f;
+    this->state.unknown_11C84->size = 1.7f;
     Owner(this->state.unknown_11C84).SetSpriteName(ResourceMgr::Instance(), "이팩트\\particle1.spr");
     Owner(this->state.unknown_11C84).SetActionName(ResourceMgr::Instance(), "이팩트\\particle1.act");
-    this->state.unknown_11C84->unknown_01F4 = 7;
+    this->state.unknown_11C84->numSegment = 7;
     Owner(this->state.unknown_11C84).InitSegment();
   }
 }
@@ -148,11 +148,11 @@ void CRagEffect::FireBall() {
 
   PlayEffectWave(*this, "effect\\EF_FireBall.wav");
   this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 5, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-  this->state.unknown_11C84->lifetime = 20;
-  this->state.unknown_11C84->flags |= 0x120u;
-  this->state.unknown_11C84->velocity = {0.0f, -15.0f, 0.0f};
+  this->state.unknown_11C84->duration = 20;
+  this->state.unknown_11C84->pattern |= 0x120u;
+  this->state.unknown_11C84->deltaPos2 = {0.0f, -15.0f, 0.0f};
   Owner(this->state.unknown_11C84).Face(this->state.offset[0], this->state.offset[2]);
-  this->state.unknown_11C84->unknown_030C = -Owner(this->state.unknown_11C84).render.angle;
+  this->state.unknown_11C84->longitude = -Owner(this->state.unknown_11C84).render.angle;
   Owner(this->state.unknown_11C84).render.angle = 180.0f - Owner(this->state.unknown_11C84).render.angle;
 
   if (Owner(this->state.unknown_11C84).render.angle < 0.0f) {
@@ -160,10 +160,10 @@ void CRagEffect::FireBall() {
   }
 
   CEffectPrim& particle = Owner(this->state.unknown_11C84);
-  particle.state.unknown_02BC = -(particle.CalcDist(this->state.offset[0], this->state.offset[2]) / particle.state.lifetime);
-  reinterpret_cast<matrix*>(this->state.unknown_11C84->matrix1)->MakeYRotation(GetRadian(static_cast<int>(this->state.unknown_11C84->unknown_030C)));
-  this->state.unknown_11C84->scale = 1.3f;
-  this->state.unknown_11C84->unknown_01E8 = 1;
+  particle.state.speed = -(particle.CalcDist(this->state.offset[0], this->state.offset[2]) / particle.state.duration);
+  reinterpret_cast<matrix*>(this->state.unknown_11C84->transform)->MakeYRotation(GetRadian(static_cast<int>(this->state.unknown_11C84->longitude)));
+  this->state.unknown_11C84->size = 1.3f;
+  this->state.unknown_11C84->animSpeed = 1;
 
   if (this->state.unknown_0178 != 20) {
     this->state.unknown_11C84->red = 246;
@@ -220,36 +220,36 @@ void CRagEffect::FrostDiver(TextureCache& textures, char type) {
 
   this->render.position = saved;
   this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 9, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-  this->state.unknown_11C84->lifetime = 40;
-  this->state.unknown_11C84->flags |= 1u;
+  this->state.unknown_11C84->duration = 40;
+  this->state.unknown_11C84->pattern |= 1u;
   this->state.unknown_11C84->slots[0].flag1[0] = type == 3 ? 3 : 0;
   const int angle = std::max(rand() % 360, 0);
   const float distance = static_cast<float>(std::max(rand() % 10, 0) + 5) / 10.0f;
   const float sine = ClientSine(angle);
   const float cosine = ClientCosine(angle);
-  this->state.unknown_11C84->velocity.y = 30.0f;
-  this->state.unknown_11C84->velocity.x = sine * distance;
-  this->state.unknown_11C84->velocity.z = -distance * cosine;
-  vector3d& velocity = this->state.unknown_11C84->velocity;
+  this->state.unknown_11C84->deltaPos2.y = 30.0f;
+  this->state.unknown_11C84->deltaPos2.x = sine * distance;
+  this->state.unknown_11C84->deltaPos2.z = -distance * cosine;
+  vector3d& velocity = this->state.unknown_11C84->deltaPos2;
   velocity.x = this->state.unknown_018C[3] + velocity.x;
   velocity.y = this->state.unknown_018C[4] + velocity.y;
   velocity.z = this->state.unknown_018C[5] + velocity.z;
-  this->state.unknown_11C84->scale = static_cast<float>(std::max(rand() % 40, 0) + 60) / 100.0f;
-  this->state.unknown_11C84->unknown_0360 = static_cast<float>(std::max(rand() % 30, 0) + 150) / 10.0f;
-  this->state.unknown_11C84->unknown_030C = static_cast<float>(std::max(rand() % 360, 0));
-  this->state.unknown_11C84->unknown_0310 = static_cast<float>(std::max(rand() % 30, 0) + 75);
+  this->state.unknown_11C84->size = static_cast<float>(std::max(rand() % 40, 0) + 60) / 100.0f;
+  this->state.unknown_11C84->heightSize = static_cast<float>(std::max(rand() % 30, 0) + 150) / 10.0f;
+  this->state.unknown_11C84->longitude = static_cast<float>(std::max(rand() % 360, 0));
+  this->state.unknown_11C84->latitude = static_cast<float>(std::max(rand() % 30, 0) + 75);
   EffectPrimitiveState& tilt = *this->state.unknown_11C84;
-  reinterpret_cast<matrix*>(tilt.matrix1)->MakeXRotation(GetRadian(static_cast<int>(tilt.unknown_0310)));
+  reinterpret_cast<matrix*>(tilt.transform)->MakeXRotation(GetRadian(static_cast<int>(tilt.latitude)));
   EffectPrimitiveState& turn = *this->state.unknown_11C84;
-  reinterpret_cast<matrix*>(turn.matrix1)->AppendYRotation(GetRadian(static_cast<int>(turn.unknown_030C)));
+  reinterpret_cast<matrix*>(turn.transform)->AppendYRotation(GetRadian(static_cast<int>(turn.longitude)));
   EffectPrimitiveState& copy = *this->state.unknown_11C84;
-  std::memcpy(copy.matrix2, copy.matrix1, sizeof(copy.matrix2));
-  this->state.unknown_11C84->unknown_02BC = 3.0f;
+  std::memcpy(copy.rotTransform, copy.transform, sizeof(copy.rotTransform));
+  this->state.unknown_11C84->speed = 3.0f;
   EffectPrimitiveState& slow = *this->state.unknown_11C84;
-  const float decay = -(slow.unknown_02BC / slow.lifetime);
-  slow.unknown_02C0 = decay + decay;
-  this->state.unknown_11C84->unknown_01D4 = 20;
-  this->state.unknown_11C84->unknown_01F0 = this->state.unknown_11C84->lifetime - 10;
+  const float decay = -(slow.speed / slow.duration);
+  slow.accel = decay + decay;
+  this->state.unknown_11C84->chCnt = 20;
+  this->state.unknown_11C84->fadeOutCnt = this->state.unknown_11C84->duration - 10;
   AllocateTextures(*this->state.unknown_11C84);
   CTexture* texture = textures.Load("effect\\ice.tga", 0, false, true, false);
   this->state.unknown_11C84->textures[0] = texture;
@@ -294,33 +294,33 @@ void CRagEffect::GrimTooth(TextureCache& textures) {
 
   this->render.position = saved;
   this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 9, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-  this->state.unknown_11C84->flags |= 1u;
-  this->state.unknown_11C84->lifetime = 40;
+  this->state.unknown_11C84->pattern |= 1u;
+  this->state.unknown_11C84->duration = 40;
   const int angle = std::max(rand() % 360, 0);
   rand();
   ClientSine(angle);
   ClientCosine(angle);
-  this->state.unknown_11C84->velocity = {0.0f, 20.0f, 0.0f};
-  vector3d& velocity = this->state.unknown_11C84->velocity;
+  this->state.unknown_11C84->deltaPos2 = {0.0f, 20.0f, 0.0f};
+  vector3d& velocity = this->state.unknown_11C84->deltaPos2;
   velocity.x = this->state.unknown_018C[3] + velocity.x;
   velocity.y = this->state.unknown_018C[4] + velocity.y;
   velocity.z = this->state.unknown_018C[5] + velocity.z;
-  this->state.unknown_11C84->scale = static_cast<float>(std::max(rand() % 40, 0) + 60) / 100.0f;
-  this->state.unknown_11C84->unknown_0360 = 10.0f;
-  this->state.unknown_11C84->unknown_030C = static_cast<float>(std::max(rand() % 360, 0));
-  this->state.unknown_11C84->unknown_0310 = static_cast<float>(std::max(rand() % 30, 0) + 75);
+  this->state.unknown_11C84->size = static_cast<float>(std::max(rand() % 40, 0) + 60) / 100.0f;
+  this->state.unknown_11C84->heightSize = 10.0f;
+  this->state.unknown_11C84->longitude = static_cast<float>(std::max(rand() % 360, 0));
+  this->state.unknown_11C84->latitude = static_cast<float>(std::max(rand() % 30, 0) + 75);
   EffectPrimitiveState& tilt = *this->state.unknown_11C84;
-  reinterpret_cast<matrix*>(tilt.matrix1)->MakeXRotation(GetRadian(static_cast<int>(tilt.unknown_0310)));
+  reinterpret_cast<matrix*>(tilt.transform)->MakeXRotation(GetRadian(static_cast<int>(tilt.latitude)));
   EffectPrimitiveState& turn = *this->state.unknown_11C84;
-  reinterpret_cast<matrix*>(turn.matrix1)->AppendYRotation(GetRadian(static_cast<int>(turn.unknown_030C)));
+  reinterpret_cast<matrix*>(turn.transform)->AppendYRotation(GetRadian(static_cast<int>(turn.longitude)));
   EffectPrimitiveState& copy = *this->state.unknown_11C84;
-  std::memcpy(copy.matrix2, copy.matrix1, sizeof(copy.matrix2));
-  this->state.unknown_11C84->unknown_02BC = 3.0f;
+  std::memcpy(copy.rotTransform, copy.transform, sizeof(copy.rotTransform));
+  this->state.unknown_11C84->speed = 3.0f;
   EffectPrimitiveState& slow = *this->state.unknown_11C84;
-  const float decay = -(slow.unknown_02BC / slow.lifetime);
-  slow.unknown_02C0 = decay + decay;
-  this->state.unknown_11C84->unknown_01D4 = 6;
-  this->state.unknown_11C84->unknown_01F0 = this->state.unknown_11C84->lifetime - 10;
+  const float decay = -(slow.speed / slow.duration);
+  slow.accel = decay + decay;
+  this->state.unknown_11C84->chCnt = 6;
+  this->state.unknown_11C84->fadeOutCnt = this->state.unknown_11C84->duration - 10;
   AllocateTextures(*this->state.unknown_11C84);
   CTexture* texture = textures.Load("effect\\stone.bmp", 0, false, true, false);
   this->state.unknown_018C[3] = this->state.unknown_018C[3] - this->state.unknown_018C[0];
@@ -345,52 +345,52 @@ void CRagEffect::Hit4(const RenderProjection& projection, TextureCache& textures
   const int facing = static_cast<int>(180.0f - this->state.parent->render.angle);
   const int direction = facing < 0 ? facing + 360 : facing;
   this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 13, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-  this->state.unknown_11C84->lifetime = 15;
-  this->state.unknown_11C84->unknown_030C = static_cast<float>(direction);
-  this->state.unknown_11C84->unknown_0310 = -90.0f;
+  this->state.unknown_11C84->duration = 15;
+  this->state.unknown_11C84->longitude = static_cast<float>(direction);
+  this->state.unknown_11C84->latitude = -90.0f;
   EffectPrimitiveState& tilt = *this->state.unknown_11C84;
-  reinterpret_cast<matrix*>(tilt.matrix1)->MakeXRotation(GetRadian(static_cast<int>(tilt.unknown_0310)));
+  reinterpret_cast<matrix*>(tilt.transform)->MakeXRotation(GetRadian(static_cast<int>(tilt.latitude)));
   EffectPrimitiveState& turn = *this->state.unknown_11C84;
-  reinterpret_cast<matrix*>(turn.matrix1)->AppendYRotation(GetRadian(static_cast<int>(turn.unknown_030C)));
-  this->state.unknown_11C84->velocity = {0.0f, -10.0f, 0.0f};
-  this->state.unknown_11C84->unknown_02BC = 0.7f;
+  reinterpret_cast<matrix*>(turn.transform)->AppendYRotation(GetRadian(static_cast<int>(turn.longitude)));
+  this->state.unknown_11C84->deltaPos2 = {0.0f, -10.0f, 0.0f};
+  this->state.unknown_11C84->speed = 0.7f;
   EffectPrimitiveState& slow = *this->state.unknown_11C84;
-  slow.unknown_02C0 = -(slow.unknown_02BC / slow.lifetime) * 0.5f;
-  this->state.unknown_11C84->unknown_02F8 = 4.0f;
-  this->state.unknown_11C84->unknown_02F4 = 0.5f;
-  this->state.unknown_11C84->unknown_0364 = 0.25f;
-  this->state.unknown_11C84->unknown_0368 = 0.15f;
-  const int lifetime = this->state.unknown_11C84->lifetime;
-  this->state.unknown_11C84->unknown_01F0 = lifetime - lifetime / 3;
+  slow.accel = -(slow.speed / slow.duration) * 0.5f;
+  this->state.unknown_11C84->outerSize = 4.0f;
+  this->state.unknown_11C84->innerSize = 0.5f;
+  this->state.unknown_11C84->heightSpeed = 0.25f;
+  this->state.unknown_11C84->heightAccel = 0.15f;
+  const int lifetime = this->state.unknown_11C84->duration;
+  this->state.unknown_11C84->fadeOutCnt = lifetime - lifetime / 3;
   AllocateTextures(*this->state.unknown_11C84);
   CTexture* texture = textures.Load("effect\\lens2.tga", 0, false, true, false);
   this->state.unknown_11C84->textures[0] = texture;
 
   for (int count = 5; count != 0; --count) {
     this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 5, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-    this->state.unknown_11C84->unknown_030C = static_cast<float>(direction - 40 + std::max(rand() % 80, 0));
-    this->state.unknown_11C84->unknown_0310 = static_cast<float>(std::max(rand() % 100, 0) - 50);
+    this->state.unknown_11C84->longitude = static_cast<float>(direction - 40 + std::max(rand() % 80, 0));
+    this->state.unknown_11C84->latitude = static_cast<float>(std::max(rand() % 100, 0) - 50);
     EffectPrimitiveState& yaw = *this->state.unknown_11C84;
-    reinterpret_cast<matrix*>(yaw.matrix1)->MakeYRotation(GetRadian(static_cast<int>(yaw.unknown_030C)));
+    reinterpret_cast<matrix*>(yaw.transform)->MakeYRotation(GetRadian(static_cast<int>(yaw.longitude)));
     EffectPrimitiveState& pitch = *this->state.unknown_11C84;
-    reinterpret_cast<matrix*>(pitch.matrix1)->AppendXRotation(GetRadian(static_cast<int>(pitch.unknown_0310)));
+    reinterpret_cast<matrix*>(pitch.transform)->AppendXRotation(GetRadian(static_cast<int>(pitch.latitude)));
     EffectPrimitiveState& spark = *this->state.unknown_11C84;
-    spark.unknown_03A0 = RotatedForward(spark.matrix1, static_cast<float>(std::max(rand() % 4, 0) + 4));
+    spark.deltaPos3 = RotatedForward(spark.transform, static_cast<float>(std::max(rand() % 4, 0) + 4));
     EffectPrimitiveState& moving = *this->state.unknown_11C84;
-    moving.velocity.x = moving.unknown_03A0.x + 0.0f;
-    moving.velocity.y = moving.unknown_03A0.y - 10.0f;
-    moving.velocity.z = moving.unknown_03A0.z + 0.0f;
-    this->state.unknown_11C84->unknown_02BC = static_cast<float>(std::max(rand() % 90, 0) + 60) / 100.0f;
-    this->state.unknown_11C84->lifetime = std::max(rand() % 24, 0) + 6;
+    moving.deltaPos2.x = moving.deltaPos3.x + 0.0f;
+    moving.deltaPos2.y = moving.deltaPos3.y - 10.0f;
+    moving.deltaPos2.z = moving.deltaPos3.z + 0.0f;
+    this->state.unknown_11C84->speed = static_cast<float>(std::max(rand() % 90, 0) + 60) / 100.0f;
+    this->state.unknown_11C84->duration = std::max(rand() % 24, 0) + 6;
     EffectPrimitiveState& fading = *this->state.unknown_11C84;
-    fading.unknown_02C0 = -(fading.unknown_02BC / fading.lifetime) * 0.5f;
-    this->state.unknown_11C84->scale = static_cast<float>(std::max(rand() % 100, 0) + 60) / 100.0f;
+    fading.accel = -(fading.speed / fading.duration) * 0.5f;
+    this->state.unknown_11C84->size = static_cast<float>(std::max(rand() % 100, 0) + 60) / 100.0f;
     EffectPrimitiveState& shrinking = *this->state.unknown_11C84;
-    shrinking.unknown_031C = -(shrinking.scale / shrinking.lifetime);
-    this->state.unknown_11C84->unknown_01F0 = 0;
+    shrinking.sizeSpeed = -(shrinking.size / shrinking.duration);
+    this->state.unknown_11C84->fadeOutCnt = 0;
     Owner(this->state.unknown_11C84).SetSpriteName(ResourceMgr::Instance(), "이팩트\\particle1.spr");
     Owner(this->state.unknown_11C84).SetActionName(ResourceMgr::Instance(), "이팩트\\particle1.act");
-    this->state.unknown_11C84->unknown_01F4 = 3;
+    this->state.unknown_11C84->numSegment = 3;
     Owner(this->state.unknown_11C84).InitSegment();
   }
 }
@@ -451,31 +451,31 @@ void CRagEffect::SoulStrike(char F1) {
   const int index = frame / 11;
   PlayEffectWave(*this, "effect\\EF_SoulStrike.wav");
   this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 8, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-  this->state.unknown_11C84->lifetime = 40;
-  this->state.unknown_11C84->velocity = {0.0f, -10.0f, 0.0f};
-  this->state.unknown_11C84->unknown_0348 = Owner(this->state.unknown_11C84).CalcDist(this->state.offset[0], this->state.offset[2]);
+  this->state.unknown_11C84->duration = 40;
+  this->state.unknown_11C84->deltaPos2 = {0.0f, -10.0f, 0.0f};
+  this->state.unknown_11C84->radius = Owner(this->state.unknown_11C84).CalcDist(this->state.offset[0], this->state.offset[2]);
   Owner(this->state.unknown_11C84).Face(this->state.offset[0], this->state.offset[2]);
-  this->state.unknown_11C84->unknown_030C = -Owner(this->state.unknown_11C84).render.angle;
-  this->state.unknown_11C84->unknown_02BC = this->state.unknown_11C84->unknown_0348 / this->state.unknown_11C84->lifetime;
-  this->state.unknown_11C84->unknown_02EC = 3.5f;
-  const float rise = -(this->state.unknown_11C84->unknown_02EC / this->state.unknown_11C84->lifetime);
-  this->state.unknown_11C84->unknown_02F0 = rise + rise;
-  this->state.unknown_11C84->unknown_0334 = -2.0f;
-  const float spread = -(this->state.unknown_11C84->unknown_0334 / this->state.unknown_11C84->lifetime);
-  this->state.unknown_11C84->unknown_0340 = spread + spread;
-  this->state.unknown_11C84->unknown_0314 = static_cast<float>(base + step * index);
+  this->state.unknown_11C84->longitude = -Owner(this->state.unknown_11C84).render.angle;
+  this->state.unknown_11C84->speed = this->state.unknown_11C84->radius / this->state.unknown_11C84->duration;
+  this->state.unknown_11C84->gravSpeed = 3.5f;
+  const float rise = -(this->state.unknown_11C84->gravSpeed / this->state.unknown_11C84->duration);
+  this->state.unknown_11C84->gravAccel = rise + rise;
+  this->state.unknown_11C84->latiSpeed = -2.0f;
+  const float spread = -(this->state.unknown_11C84->latiSpeed / this->state.unknown_11C84->duration);
+  this->state.unknown_11C84->latiAccel = spread + spread;
+  this->state.unknown_11C84->roll = static_cast<float>(base + step * index);
   EffectPrimitiveState& particle = *this->state.unknown_11C84;
-  reinterpret_cast<matrix*>(particle.matrix1)->MakeYRotation(GetRadian(static_cast<int>(particle.unknown_030C)));
-  this->state.unknown_11C84->unknown_03A0 = RotatedForward(this->state.unknown_11C84->matrix1, 1.0f);
-  this->state.unknown_11C84->unknown_0290[0] = this->state.unknown_11C84->unknown_03A0.x;
-  this->state.unknown_11C84->unknown_0290[1] = this->state.unknown_11C84->unknown_03A0.y;
-  this->state.unknown_11C84->unknown_0290[2] = this->state.unknown_11C84->unknown_03A0.z;
-  this->state.unknown_11C84->scale = 2.75f;
+  reinterpret_cast<matrix*>(particle.transform)->MakeYRotation(GetRadian(static_cast<int>(particle.longitude)));
+  this->state.unknown_11C84->deltaPos3 = RotatedForward(this->state.unknown_11C84->transform, 1.0f);
+  this->state.unknown_11C84->rotAxis[0] = this->state.unknown_11C84->deltaPos3.x;
+  this->state.unknown_11C84->rotAxis[1] = this->state.unknown_11C84->deltaPos3.y;
+  this->state.unknown_11C84->rotAxis[2] = this->state.unknown_11C84->deltaPos3.z;
+  this->state.unknown_11C84->size = 2.75f;
   const char* action = F1 != 0 ? "이팩트\\particle5.act" : "이팩트\\particle1.act";
   const char* sprite = F1 != 0 ? "이팩트\\particle5.spr" : "이팩트\\particle1.spr";
   Owner(this->state.unknown_11C84).SetSpriteName(ResourceMgr::Instance(), sprite);
   Owner(this->state.unknown_11C84).SetActionName(ResourceMgr::Instance(), action);
-  this->state.unknown_11C84->unknown_01F4 = 12;
+  this->state.unknown_11C84->numSegment = 12;
   Owner(this->state.unknown_11C84).InitSegment();
 }
 
@@ -490,11 +490,11 @@ void CRagEffect::SpearBmr() {
 
   PlayEffectWave(*this, "effect\\EF_FireBall.wav");
   this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 5, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-  this->state.unknown_11C84->lifetime = 15;
-  this->state.unknown_11C84->flags |= 0x120u;
-  this->state.unknown_11C84->velocity = {0.0f, -15.0f, 0.0f};
+  this->state.unknown_11C84->duration = 15;
+  this->state.unknown_11C84->pattern |= 0x120u;
+  this->state.unknown_11C84->deltaPos2 = {0.0f, -15.0f, 0.0f};
   Owner(this->state.unknown_11C84).Face(this->state.offset[0], this->state.offset[2]);
-  this->state.unknown_11C84->unknown_030C = -Owner(this->state.unknown_11C84).render.angle;
+  this->state.unknown_11C84->longitude = -Owner(this->state.unknown_11C84).render.angle;
   Owner(this->state.unknown_11C84).render.angle = 180.0f - Owner(this->state.unknown_11C84).render.angle;
 
   if (Owner(this->state.unknown_11C84).render.angle < 0.0f) {
@@ -502,10 +502,10 @@ void CRagEffect::SpearBmr() {
   }
 
   CEffectPrim& particle = Owner(this->state.unknown_11C84);
-  particle.state.unknown_02BC = -(particle.CalcDist(this->state.offset[0], this->state.offset[2]) / particle.state.lifetime);
-  reinterpret_cast<matrix*>(this->state.unknown_11C84->matrix1)->MakeYRotation(GetRadian(static_cast<int>(this->state.unknown_11C84->unknown_030C)));
-  this->state.unknown_11C84->scale = 1.0f;
-  this->state.unknown_11C84->unknown_01E8 = 1;
+  particle.state.speed = -(particle.CalcDist(this->state.offset[0], this->state.offset[2]) / particle.state.duration);
+  reinterpret_cast<matrix*>(this->state.unknown_11C84->transform)->MakeYRotation(GetRadian(static_cast<int>(this->state.unknown_11C84->longitude)));
+  this->state.unknown_11C84->size = 1.0f;
+  this->state.unknown_11C84->animSpeed = 1;
 
   if (this->state.unknown_0178 != 0) {
     if (this->state.unknown_0178 == 4) {
@@ -529,20 +529,20 @@ void CRagEffect::SprayPond(TextureCache& textures) {
   if (this->state.unknown_0178 == 0) {
     for (int angle = 0; angle < 360; angle += 45) {
       this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 15, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-      this->state.unknown_11C84->flags = 2;
-      this->state.unknown_11C84->lifetime = 130;
+      this->state.unknown_11C84->pattern = 2;
+      this->state.unknown_11C84->duration = 130;
       EffectPrimitiveState& yaw = *this->state.unknown_11C84;
-      reinterpret_cast<matrix*>(yaw.matrix1)->MakeYRotation(GetRadian(static_cast<int>(static_cast<float>(angle) + 22.5f)));
+      reinterpret_cast<matrix*>(yaw.transform)->MakeYRotation(GetRadian(static_cast<int>(static_cast<float>(angle) + 22.5f)));
       EffectPrimitiveState& moving = *this->state.unknown_11C84;
-      const vector3d edge = RotatedForward(moving.matrix1, 12.2f);
-      moving.velocity.x = edge.x + 0.0f;
-      moving.velocity.y = edge.y - 2.0f;
-      moving.velocity.z = edge.z + 0.0f;
+      const vector3d edge = RotatedForward(moving.transform, 12.2f);
+      moving.deltaPos2.x = edge.x + 0.0f;
+      moving.deltaPos2.y = edge.y - 2.0f;
+      moving.deltaPos2.z = edge.z + 0.0f;
       EffectPrimitiveState& facing = *this->state.unknown_11C84;
-      reinterpret_cast<matrix*>(facing.matrix2)->MakeYRotation(GetRadian(static_cast<int>(static_cast<float>(angle + 90) + 22.5f)));
+      reinterpret_cast<matrix*>(facing.rotTransform)->MakeYRotation(GetRadian(static_cast<int>(static_cast<float>(angle + 90) + 22.5f)));
       this->state.unknown_11C84->alpha = 120.0f;
-      this->state.unknown_11C84->unknown_0354 = 5.0f;
-      this->state.unknown_11C84->unknown_0360 = 2.7f;
+      this->state.unknown_11C84->widthSize = 5.0f;
+      this->state.unknown_11C84->heightSize = 2.7f;
       AllocateTextures(*this->state.unknown_11C84);
       this->state.unknown_11C84->textures[0] = textures.Load("effect\\pond_water.bmp", 0, false, true, false);
     }
@@ -551,22 +551,22 @@ void CRagEffect::SprayPond(TextureCache& textures) {
   if (this->state.unknown_0178 % 10 == 0) {
     for (int angle = 0; angle < 360; angle += 45) {
       this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 15, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-      this->state.unknown_11C84->lifetime = 30;
+      this->state.unknown_11C84->duration = 30;
       EffectPrimitiveState& yaw = *this->state.unknown_11C84;
-      reinterpret_cast<matrix*>(yaw.matrix1)->MakeYRotation(GetRadian(static_cast<int>(static_cast<float>(angle) + 22.5f)));
+      reinterpret_cast<matrix*>(yaw.transform)->MakeYRotation(GetRadian(static_cast<int>(static_cast<float>(angle) + 22.5f)));
       EffectPrimitiveState& moving = *this->state.unknown_11C84;
-      const vector3d edge = RotatedForward(moving.matrix1, 13.8f);
-      moving.velocity.x = edge.x;
-      moving.velocity.y = edge.y;
-      moving.velocity.z = edge.z;
+      const vector3d edge = RotatedForward(moving.transform, 13.8f);
+      moving.deltaPos2.x = edge.x;
+      moving.deltaPos2.y = edge.y;
+      moving.deltaPos2.z = edge.z;
       EffectPrimitiveState& roll = *this->state.unknown_11C84;
-      reinterpret_cast<matrix*>(roll.matrix2)->MakeZRotation(GetRadian(90));
+      reinterpret_cast<matrix*>(roll.rotTransform)->MakeZRotation(GetRadian(90));
       EffectPrimitiveState& facing = *this->state.unknown_11C84;
-      reinterpret_cast<matrix*>(facing.matrix2)->AppendYRotation(GetRadian(static_cast<int>(static_cast<float>(angle + 90) + 22.5f)));
+      reinterpret_cast<matrix*>(facing.rotTransform)->AppendYRotation(GetRadian(static_cast<int>(static_cast<float>(angle + 90) + 22.5f)));
       this->state.unknown_11C84->alpha = 100.0f;
-      this->state.unknown_11C84->unknown_01F0 = 0;
-      this->state.unknown_11C84->unknown_0354 = 5.5f;
-      this->state.unknown_11C84->unknown_0360 = 1.0f;
+      this->state.unknown_11C84->fadeOutCnt = 0;
+      this->state.unknown_11C84->widthSize = 5.5f;
+      this->state.unknown_11C84->heightSize = 1.0f;
       AllocateTextures(*this->state.unknown_11C84);
       this->state.unknown_11C84->textures[0] = textures.Load("effect\\alpha_down.tga", 0, false, true, false);
     }
@@ -574,18 +574,18 @@ void CRagEffect::SprayPond(TextureCache& textures) {
 
   if (this->state.unknown_0178 % 20 == 0) {
     this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 12, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-    this->state.unknown_11C84->lifetime = 25;
-    this->state.unknown_11C84->unknown_0348 = 13.0f;
-    this->state.unknown_11C84->unknown_0288 = 10.0f;
-    this->state.unknown_11C84->scale = 1.25f;
-    this->state.unknown_11C84->unknown_0310 = 90.0f;
+    this->state.unknown_11C84->duration = 25;
+    this->state.unknown_11C84->radius = 13.0f;
+    this->state.unknown_11C84->arcAngle = 10.0f;
+    this->state.unknown_11C84->size = 1.25f;
+    this->state.unknown_11C84->latitude = 90.0f;
     EffectPrimitiveState& tilt = *this->state.unknown_11C84;
-    reinterpret_cast<matrix*>(tilt.matrix1)->MakeXRotation(GetRadian(static_cast<int>(tilt.unknown_0310)));
-    this->state.unknown_11C84->unknown_034C = 0.25f;
+    reinterpret_cast<matrix*>(tilt.transform)->MakeXRotation(GetRadian(static_cast<int>(tilt.latitude)));
+    this->state.unknown_11C84->radiusSpeed = 0.25f;
     EffectPrimitiveState& growing = *this->state.unknown_11C84;
-    growing.unknown_0350 = -(growing.unknown_034C / growing.lifetime);
+    growing.radiusAccel = -(growing.radiusSpeed / growing.duration);
     this->state.unknown_11C84->alpha = 100.0f;
-    this->state.unknown_11C84->unknown_01F0 = 0;
+    this->state.unknown_11C84->fadeOutCnt = 0;
     Owner(this->state.unknown_11C84).InitSegment();
     AllocateTextures(*this->state.unknown_11C84);
     this->state.unknown_11C84->textures[0] = textures.Load("effect\\alpha_center.tga", 0, false, true, false);
@@ -603,27 +603,27 @@ void CRagEffect::WaterBall2() {
   this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 8, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
   Owner(this->state.unknown_11C84).SetSpriteName(ResourceMgr::Instance(), "이팩트\\Waterball.spr");
   Owner(this->state.unknown_11C84).SetActionName(ResourceMgr::Instance(), "이팩트\\Waterball.act");
-  this->state.unknown_11C84->lifetime = 40;
-  this->state.unknown_11C84->velocity = {0.0f, -10.0f, 0.0f};
-  this->state.unknown_11C84->unknown_0348 = Owner(this->state.unknown_11C84).CalcDist(this->state.offset[0], this->state.offset[2]);
+  this->state.unknown_11C84->duration = 40;
+  this->state.unknown_11C84->deltaPos2 = {0.0f, -10.0f, 0.0f};
+  this->state.unknown_11C84->radius = Owner(this->state.unknown_11C84).CalcDist(this->state.offset[0], this->state.offset[2]);
   Owner(this->state.unknown_11C84).Face(this->state.offset[0], this->state.offset[2]);
-  this->state.unknown_11C84->unknown_030C = -Owner(this->state.unknown_11C84).render.angle;
-  this->state.unknown_11C84->unknown_02BC = this->state.unknown_11C84->unknown_0348 / this->state.unknown_11C84->lifetime;
-  this->state.unknown_11C84->unknown_02EC = 3.5f;
-  const float rise = -(this->state.unknown_11C84->unknown_02EC / this->state.unknown_11C84->lifetime);
-  this->state.unknown_11C84->unknown_02F0 = rise + rise;
-  this->state.unknown_11C84->unknown_0334 = -2.0f;
-  const float spread = -(this->state.unknown_11C84->unknown_0334 / this->state.unknown_11C84->lifetime);
-  this->state.unknown_11C84->unknown_0340 = spread + spread;
-  this->state.unknown_11C84->unknown_0314 = 0.0f;
+  this->state.unknown_11C84->longitude = -Owner(this->state.unknown_11C84).render.angle;
+  this->state.unknown_11C84->speed = this->state.unknown_11C84->radius / this->state.unknown_11C84->duration;
+  this->state.unknown_11C84->gravSpeed = 3.5f;
+  const float rise = -(this->state.unknown_11C84->gravSpeed / this->state.unknown_11C84->duration);
+  this->state.unknown_11C84->gravAccel = rise + rise;
+  this->state.unknown_11C84->latiSpeed = -2.0f;
+  const float spread = -(this->state.unknown_11C84->latiSpeed / this->state.unknown_11C84->duration);
+  this->state.unknown_11C84->latiAccel = spread + spread;
+  this->state.unknown_11C84->roll = 0.0f;
   EffectPrimitiveState& particle = *this->state.unknown_11C84;
-  reinterpret_cast<matrix*>(particle.matrix1)->MakeYRotation(GetRadian(static_cast<int>(particle.unknown_030C)));
-  this->state.unknown_11C84->unknown_03A0 = RotatedForward(this->state.unknown_11C84->matrix1, 1.0f);
-  this->state.unknown_11C84->unknown_0290[0] = this->state.unknown_11C84->unknown_03A0.x;
-  this->state.unknown_11C84->unknown_0290[1] = this->state.unknown_11C84->unknown_03A0.y;
-  this->state.unknown_11C84->unknown_0290[2] = this->state.unknown_11C84->unknown_03A0.z;
-  this->state.unknown_11C84->scale = 0.75f;
-  this->state.unknown_11C84->unknown_01F4 = 12;
+  reinterpret_cast<matrix*>(particle.transform)->MakeYRotation(GetRadian(static_cast<int>(particle.longitude)));
+  this->state.unknown_11C84->deltaPos3 = RotatedForward(this->state.unknown_11C84->transform, 1.0f);
+  this->state.unknown_11C84->rotAxis[0] = this->state.unknown_11C84->deltaPos3.x;
+  this->state.unknown_11C84->rotAxis[1] = this->state.unknown_11C84->deltaPos3.y;
+  this->state.unknown_11C84->rotAxis[2] = this->state.unknown_11C84->deltaPos3.z;
+  this->state.unknown_11C84->size = 0.75f;
+  this->state.unknown_11C84->numSegment = 12;
   Owner(this->state.unknown_11C84).InitSegment();
 }
 
@@ -641,14 +641,14 @@ void CRagEffect::Yufitel(TextureCache& textures, char F1) {
   }
 
   this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 15, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-  this->state.unknown_11C84->lifetime = 20;
-  this->state.unknown_11C84->flags |= 0x40u;
-  this->state.unknown_11C84->flags |= 0x400u;
-  this->state.unknown_11C84->unknown_01C4 |= 2u;
-  this->state.unknown_11C84->unknown_0354 = 3.5f;
-  this->state.unknown_11C84->unknown_0360 = 3.5f;
+  this->state.unknown_11C84->duration = 20;
+  this->state.unknown_11C84->pattern |= 0x40u;
+  this->state.unknown_11C84->pattern |= 0x400u;
+  this->state.unknown_11C84->renderFlag |= 2u;
+  this->state.unknown_11C84->widthSize = 3.5f;
+  this->state.unknown_11C84->heightSize = 3.5f;
   Owner(this->state.unknown_11C84).Face(this->state.offset[0], this->state.offset[2]);
-  this->state.unknown_11C84->unknown_030C = -Owner(this->state.unknown_11C84).render.angle;
+  this->state.unknown_11C84->longitude = -Owner(this->state.unknown_11C84).render.angle;
   Owner(this->state.unknown_11C84).render.angle = 180.0f - Owner(this->state.unknown_11C84).render.angle;
 
   if (Owner(this->state.unknown_11C84).render.angle < 0.0f) {
@@ -656,23 +656,23 @@ void CRagEffect::Yufitel(TextureCache& textures, char F1) {
   }
 
   CEffectPrim& center = Owner(this->state.unknown_11C84);
-  center.state.unknown_02BC = -(center.CalcDist(this->state.offset[0], this->state.offset[2]) / center.state.lifetime);
-  reinterpret_cast<matrix*>(this->state.unknown_11C84->matrix1)->MakeYRotation(GetRadian(static_cast<int>(this->state.unknown_11C84->unknown_030C)));
-  this->state.unknown_11C84->velocity.y = -5.0f;
+  center.state.speed = -(center.CalcDist(this->state.offset[0], this->state.offset[2]) / center.state.duration);
+  reinterpret_cast<matrix*>(this->state.unknown_11C84->transform)->MakeYRotation(GetRadian(static_cast<int>(this->state.unknown_11C84->longitude)));
+  this->state.unknown_11C84->deltaPos2.y = -5.0f;
   this->state.unknown_11C84->alpha = 170.0f;
   AllocateTextures(*this->state.unknown_11C84);
   this->state.unknown_11C84->textures[0] =
     F1 != 0 ? textures.Load("effect\\twirl_soft.bmp", 0, false, true, false) : textures.Load("effect\\thunder_center.bmp", 0, false, true, false);
   this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 15, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-  this->state.unknown_11C84->lifetime = 20;
-  this->state.unknown_11C84->flags = 0x40u;
-  this->state.unknown_11C84->flags |= 0x400u;
-  this->state.unknown_11C84->unknown_01C4 |= 2u;
-  this->state.unknown_11C84->unknown_0254 = 1;
-  this->state.unknown_11C84->unknown_0354 = 4.5f;
-  this->state.unknown_11C84->unknown_0360 = 4.5f;
+  this->state.unknown_11C84->duration = 20;
+  this->state.unknown_11C84->pattern = 0x40u;
+  this->state.unknown_11C84->pattern |= 0x400u;
+  this->state.unknown_11C84->renderFlag |= 2u;
+  this->state.unknown_11C84->repeatAnim = 1;
+  this->state.unknown_11C84->widthSize = 4.5f;
+  this->state.unknown_11C84->heightSize = 4.5f;
   Owner(this->state.unknown_11C84).Face(this->state.offset[0], this->state.offset[2]);
-  this->state.unknown_11C84->unknown_030C = -Owner(this->state.unknown_11C84).render.angle;
+  this->state.unknown_11C84->longitude = -Owner(this->state.unknown_11C84).render.angle;
   Owner(this->state.unknown_11C84).render.angle = 180.0f - Owner(this->state.unknown_11C84).render.angle;
 
   if (Owner(this->state.unknown_11C84).render.angle < 0.0f) {
@@ -680,11 +680,11 @@ void CRagEffect::Yufitel(TextureCache& textures, char F1) {
   }
 
   CEffectPrim& ball = Owner(this->state.unknown_11C84);
-  ball.state.unknown_02BC = -(ball.CalcDist(this->state.offset[0], this->state.offset[2]) / ball.state.lifetime);
-  reinterpret_cast<matrix*>(this->state.unknown_11C84->matrix1)->MakeYRotation(GetRadian(static_cast<int>(this->state.unknown_11C84->unknown_030C)));
-  this->state.unknown_11C84->velocity.y = -5.0f;
-  this->state.unknown_11C84->unknown_01E8 = 1;
-  this->state.unknown_11C84->textureCount = 6;
+  ball.state.speed = -(ball.CalcDist(this->state.offset[0], this->state.offset[2]) / ball.state.duration);
+  reinterpret_cast<matrix*>(this->state.unknown_11C84->transform)->MakeYRotation(GetRadian(static_cast<int>(this->state.unknown_11C84->longitude)));
+  this->state.unknown_11C84->deltaPos2.y = -5.0f;
+  this->state.unknown_11C84->animSpeed = 1;
+  this->state.unknown_11C84->totalTexture = 6;
   AllocateTextures(*this->state.unknown_11C84);
 
   if (F1 != 0) {
@@ -718,11 +718,11 @@ void CRagEffect::AirTexture(TextureCache& textures, const char* name) {
   }
 
   this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 98, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-  this->state.unknown_11C84->unknown_01C4 = 5;
-  this->state.unknown_11C84->lifetime = this->state.lifetime;
+  this->state.unknown_11C84->renderFlag = 5;
+  this->state.unknown_11C84->duration = this->state.lifetime;
   AllocateTextures(*this->state.unknown_11C84);
   this->state.unknown_11C84->textures[0] = textures.Load(name, 0, false, true, false);
-  this->state.unknown_11C84->scale = 0.0f;
+  this->state.unknown_11C84->size = 0.0f;
   this->state.unknown_11C84->slots[0].life = 1;
   this->state.unknown_11C84->slots[0].process = 0;
   this->state.unknown_11C84->slots[0].distance = 5.0f;
@@ -757,42 +757,42 @@ void CRagEffect::EnergyDrain2() {
 
   for (int angle = -90; angle < 180; angle += 90) {
     this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 8, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
-    this->state.unknown_11C84->lifetime = 60;
+    this->state.unknown_11C84->duration = 60;
     const float deltaZ = this->state.offset[2] - this->render.position.z;
     EffectPrimitiveState& launched = *this->state.unknown_11C84;
-    launched.velocity.x = this->state.offset[0] - this->render.position.x;
-    launched.velocity.z = deltaZ;
-    launched.velocity.y = -10.0f;
-    this->state.unknown_11C84->unknown_0348 = Owner(this->state.unknown_11C84).CalcDist(
+    launched.deltaPos2.x = this->state.offset[0] - this->render.position.x;
+    launched.deltaPos2.z = deltaZ;
+    launched.deltaPos2.y = -10.0f;
+    this->state.unknown_11C84->radius = Owner(this->state.unknown_11C84).CalcDist(
       this->state.offset[0] - (this->state.offset[0] - this->render.position.x) * 0.5f,
       this->state.offset[2] - (this->state.offset[2] - this->render.position.z) * 0.5f
     );
     Owner(this->state.unknown_11C84).Face(
       (this->render.position.x + this->render.position.x) - this->state.offset[0], (this->render.position.z + this->render.position.z) - this->state.offset[2]
     );
-    this->state.unknown_11C84->unknown_030C = -Owner(this->state.unknown_11C84).render.angle;
-    const float speed = this->state.unknown_11C84->unknown_0348 / this->state.unknown_11C84->lifetime;
-    this->state.unknown_11C84->unknown_02BC = speed + speed;
-    this->state.unknown_11C84->unknown_02EC = 2.0f;
-    const float rise = -(this->state.unknown_11C84->unknown_02EC / this->state.unknown_11C84->lifetime);
-    this->state.unknown_11C84->unknown_02F0 = rise + rise;
-    this->state.unknown_11C84->unknown_0334 = -2.0f;
-    const float spread = -(this->state.unknown_11C84->unknown_0334 / this->state.unknown_11C84->lifetime);
-    this->state.unknown_11C84->unknown_0340 = spread + spread;
-    this->state.unknown_11C84->unknown_0314 = static_cast<float>(angle);
+    this->state.unknown_11C84->longitude = -Owner(this->state.unknown_11C84).render.angle;
+    const float speed = this->state.unknown_11C84->radius / this->state.unknown_11C84->duration;
+    this->state.unknown_11C84->speed = speed + speed;
+    this->state.unknown_11C84->gravSpeed = 2.0f;
+    const float rise = -(this->state.unknown_11C84->gravSpeed / this->state.unknown_11C84->duration);
+    this->state.unknown_11C84->gravAccel = rise + rise;
+    this->state.unknown_11C84->latiSpeed = -2.0f;
+    const float spread = -(this->state.unknown_11C84->latiSpeed / this->state.unknown_11C84->duration);
+    this->state.unknown_11C84->latiAccel = spread + spread;
+    this->state.unknown_11C84->roll = static_cast<float>(angle);
     EffectPrimitiveState& particle = *this->state.unknown_11C84;
-    reinterpret_cast<matrix*>(particle.matrix1)->MakeYRotation(GetRadian(static_cast<int>(particle.unknown_030C)));
-    this->state.unknown_11C84->unknown_03A0 = RotatedForward(this->state.unknown_11C84->matrix1, 1.0f);
-    this->state.unknown_11C84->unknown_0290[0] = this->state.unknown_11C84->unknown_03A0.x;
-    this->state.unknown_11C84->unknown_0290[1] = this->state.unknown_11C84->unknown_03A0.y;
-    this->state.unknown_11C84->unknown_0290[2] = this->state.unknown_11C84->unknown_03A0.z;
+    reinterpret_cast<matrix*>(particle.transform)->MakeYRotation(GetRadian(static_cast<int>(particle.longitude)));
+    this->state.unknown_11C84->deltaPos3 = RotatedForward(this->state.unknown_11C84->transform, 1.0f);
+    this->state.unknown_11C84->rotAxis[0] = this->state.unknown_11C84->deltaPos3.x;
+    this->state.unknown_11C84->rotAxis[1] = this->state.unknown_11C84->deltaPos3.y;
+    this->state.unknown_11C84->rotAxis[2] = this->state.unknown_11C84->deltaPos3.z;
     this->state.unknown_11C84->red = std::max(rand() % 81, 0) + 160;
     this->state.unknown_11C84->green = std::max(rand() % 81, 0) + 160;
     this->state.unknown_11C84->blue = 255;
-    this->state.unknown_11C84->scale = static_cast<float>(std::max(rand() % 6, 0)) * 0.1f + 1.5f;
+    this->state.unknown_11C84->size = static_cast<float>(std::max(rand() % 6, 0)) * 0.1f + 1.5f;
     Owner(this->state.unknown_11C84).SetSpriteName(ResourceMgr::Instance(), "이팩트\\particle1.spr");
     Owner(this->state.unknown_11C84).SetActionName(ResourceMgr::Instance(), "이팩트\\particle1.act");
-    this->state.unknown_11C84->unknown_01F4 = 7;
+    this->state.unknown_11C84->numSegment = 7;
     Owner(this->state.unknown_11C84).InitSegment();
   }
 }
@@ -988,21 +988,21 @@ bool CRagEffect::Aspersio() {
     this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 7, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
     this->state.lifetime = 400;
     EffectPrimitiveState& particle = *this->state.unknown_11C84;
-    particle.lifetime = 40;
-    particle.unknown_0348 = 1.5f;
-    particle.unknown_02EC = 0.19f;
-    particle.unknown_02F0 = 0.01f;
-    particle.unknown_030C = static_cast<float>(std::max(rand() % 360, 0));
-    particle.scale = 1.2f;
-    reinterpret_cast<matrix*>(particle.matrix1)->MakeYRotation(GetRadian(static_cast<int>(particle.unknown_030C)));
-    const float* m = particle.matrix1;
-    const float distance = particle.unknown_0348;
-    particle.velocity = {
+    particle.duration = 40;
+    particle.radius = 1.5f;
+    particle.gravSpeed = 0.19f;
+    particle.gravAccel = 0.01f;
+    particle.longitude = static_cast<float>(std::max(rand() % 360, 0));
+    particle.size = 1.2f;
+    reinterpret_cast<matrix*>(particle.transform)->MakeYRotation(GetRadian(static_cast<int>(particle.longitude)));
+    const float* m = particle.transform;
+    const float distance = particle.radius;
+    particle.deltaPos2 = {
       (m[0] * 0.0f - m[3] * 30.0f) + distance * m[6] + m[9],
       (m[1] * 0.0f - m[4] * 30.0f) + distance * m[7] + m[10],
       (m[2] * 0.0f - m[5] * 30.0f) + distance * m[8] + m[11]
     };
-    particle.unknown_01F0 = 30;
+    particle.fadeOutCnt = 30;
     Owner(&particle).SetSpriteName(ResourceMgr::Instance(), "이팩트\\particle1.spr");
     Owner(&particle).SetActionName(ResourceMgr::Instance(), "이팩트\\particle1.act");
     Owner(&particle).InitSegment();
@@ -1028,18 +1028,18 @@ void CRagEffect::Blessing(TextureCache& textures) {
     PlayEffectWave(*this, "effect\\EF_Blessing.wav");
     this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 12, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
     EffectPrimitiveState& ring = *this->state.unknown_11C84;
-    ring.lifetime = this->state.lifetime;
-    ring.flags |= 1u;
-    ring.unknown_01C4 |= 0x200u;
-    ring.unknown_0348 = 10.0f;
-    ring.unknown_0310 = 90.0f;
+    ring.duration = this->state.lifetime;
+    ring.pattern |= 1u;
+    ring.renderFlag |= 0x200u;
+    ring.radius = 10.0f;
+    ring.latitude = 90.0f;
     ring.red = 32;
     ring.green = 176;
     ring.blue = 232;
     ring.alpha = 0.0f;
-    ring.unknown_02D4 = 100.0f;
-    ring.alphaSpeed = ring.unknown_02D4 / 30.0f;
-    ring.unknown_01F0 = ring.lifetime - 30;
+    ring.maxAlpha = 100.0f;
+    ring.alphaSpeed = ring.maxAlpha / 30.0f;
+    ring.fadeOutCnt = ring.duration - 30;
     Owner(&ring).InitSegment();
     AllocateTextures(ring);
     ring.textures[0] = textures.Load("effect\\alpha_down.tga", 0, false, true, false);
@@ -1048,10 +1048,10 @@ void CRagEffect::Blessing(TextureCache& textures) {
   if (this->state.unknown_0178 % 3 == 0 && this->state.unknown_0178 < 10) {
     this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 5, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
     EffectPrimitiveState& wing = *this->state.unknown_11C84;
-    wing.lifetime = this->state.lifetime;
-    wing.unknown_01E8 = 2;
+    wing.duration = this->state.lifetime;
+    wing.animSpeed = 2;
     wing.alpha = static_cast<float>(this->state.unknown_0178 * -6 + 200);
-    wing.velocity = {0.0f, -25.0f, 0.0f};
+    wing.deltaPos2 = {0.0f, -25.0f, 0.0f};
     Owner(&wing).SetSpriteName(ResourceMgr::Instance(), "이팩트\\축복.spr");
     Owner(&wing).SetActionName(ResourceMgr::Instance(), "이팩트\\축복.act");
     Owner(&wing).InitSegment();
@@ -1060,23 +1060,23 @@ void CRagEffect::Blessing(TextureCache& textures) {
   if (this->state.unknown_0178 % 4 == 0) {
     this->state.unknown_11C84 = &CreateEffectParticle(*this, this->render, 5, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
     EffectPrimitiveState& spark = *this->state.unknown_11C84;
-    spark.lifetime = 80;
-    spark.flags |= 0x80u;
-    reinterpret_cast<matrix*>(spark.matrix1)->MakeYRotation(GetRadian(std::max(rand() % 360, 0)));
-    const float* m = spark.matrix1;
+    spark.duration = 80;
+    spark.pattern |= 0x80u;
+    reinterpret_cast<matrix*>(spark.transform)->MakeYRotation(GetRadian(std::max(rand() % 360, 0)));
+    const float* m = spark.transform;
     const float distance = static_cast<float>(std::max(rand() % 7, 0) + 2);
-    spark.velocity = {
+    spark.deltaPos2 = {
       (m[0] * 0.0f - m[3] * 25.0f) + distance * m[6] + m[9],
       (m[1] * 0.0f - m[4] * 25.0f) + distance * m[7] + m[10],
       (m[2] * 0.0f - m[5] * 25.0f) + distance * m[8] + m[11]
     };
-    reinterpret_cast<matrix*>(spark.matrix1)->MakeXRotation(GetRadian(-90));
-    spark.unknown_02BC = static_cast<float>(std::max(rand() % 20, 0) + 20) / 100.0f;
-    spark.unknown_02C0 = -(spark.unknown_02BC / static_cast<float>(spark.lifetime)) * 0.5f;
+    reinterpret_cast<matrix*>(spark.transform)->MakeXRotation(GetRadian(-90));
+    spark.speed = static_cast<float>(std::max(rand() % 20, 0) + 20) / 100.0f;
+    spark.accel = -(spark.speed / static_cast<float>(spark.duration)) * 0.5f;
     spark.alpha = 0.0f;
-    spark.scale = 0.5f;
-    spark.unknown_01F0 = spark.lifetime - spark.lifetime / 5;
-    spark.alphaSpeed = spark.unknown_02D4 / 10.0f;
+    spark.size = 0.5f;
+    spark.fadeOutCnt = spark.duration - spark.duration / 5;
+    spark.alphaSpeed = spark.maxAlpha / 10.0f;
     Owner(&spark).SetActionName(ResourceMgr::Instance(), "이팩트\\particle6.act");
     Owner(&spark).SetSpriteName(ResourceMgr::Instance(), "이팩트\\particle6.spr");
     Owner(&spark).InitSegment();
@@ -1087,19 +1087,19 @@ void CRagEffect::Blessing(TextureCache& textures) {
 static __forceinline void SpawnBottomQuad(CRagEffect& effect, TextureCache& textures, const vector3d& velocity, int angle) {
   effect.state.unknown_11C84 = &CreateEffectParticle(effect, effect.render, 15, 0.0f, 0.0f, 0.0f, WorldObjects())->state;
   EffectPrimitiveState& quad = *effect.state.unknown_11C84;
-  quad.lifetime = 9999;
-  quad.unknown_0238 = 1;
-  quad.flags = 0x28;
-  quad.unknown_01CC = 0x32;
-  quad.velocity = velocity;
-  quad.unknown_030C = static_cast<float>(angle);
-  quad.unknown_0354 = 5.0f;
-  quad.unknown_0360 = 15.0f;
-  quad.unknown_0364 = 0.25f;
+  quad.duration = 9999;
+  quad.commonPattern = 1;
+  quad.pattern = 0x28;
+  quad.type = 0x32;
+  quad.deltaPos2 = velocity;
+  quad.longitude = static_cast<float>(angle);
+  quad.widthSize = 5.0f;
+  quad.heightSize = 15.0f;
+  quad.heightSpeed = 0.25f;
   quad.alpha = 0.0f;
-  quad.unknown_02D4 = 180.0f;
-  quad.alphaSpeed = quad.unknown_02D4 / 6.0f;
-  quad.unknown_01F0 = quad.lifetime - 35;
+  quad.maxAlpha = 180.0f;
+  quad.alphaSpeed = quad.maxAlpha / 6.0f;
+  quad.fadeOutCnt = quad.duration - 35;
   AllocateTextures(quad);
   quad.textures[0] = textures.Load("effect\\magic_violet.tga", 0, false, true, false);
 }