diff --git a/Runtime/Particle/CParticleSwoosh.cpp b/Runtime/Particle/CParticleSwoosh.cpp
index 6ed891350..e12e903f1 100644
--- a/Runtime/Particle/CParticleSwoosh.cpp
+++ b/Runtime/Particle/CParticleSwoosh.cpp
@@ -52,10 +52,10 @@ CParticleSwoosh::CParticleSwoosh(const TToken<CSwooshDescription>& desc, int len
 
         SetOrientation(zeus::CTransform::Identity());
 
-        x16c_.resize(x1b8_SIDE);
-        x17c_.resize(x1b8_SIDE);
-        x18c_.resize(x1b8_SIDE);
-        x19c_.resize(x1b8_SIDE);
+        x16c_p0.resize(x1b8_SIDE);
+        x17c_p1.resize(x1b8_SIDE);
+        x18c_p2.resize(x1b8_SIDE);
+        x19c_p3.resize(x1b8_SIDE);
     }
 }
 
@@ -69,6 +69,16 @@ void CParticleSwoosh::UpdateMaxRadius(float r)
     x208_maxRadius = std::max(x208_maxRadius, r);
 }
 
+void CParticleSwoosh::UpdateBounds(const zeus::CVector3f& pos)
+{
+    x1fc_aabbMax[0] = std::max(pos[0], x1fc_aabbMax[0]);
+    x1fc_aabbMax[1] = std::max(pos[1], x1fc_aabbMax[1]);
+    x1fc_aabbMax[2] = std::max(pos[2], x1fc_aabbMax[2]);
+    x1f0_aabbMin[0] = std::min(pos[0], x1f0_aabbMin[0]);
+    x1f0_aabbMin[1] = std::min(pos[1], x1f0_aabbMin[1]);
+    x1f0_aabbMin[2] = std::min(pos[2], x1f0_aabbMin[2]);
+}
+
 float CParticleSwoosh::GetLeftRadius(int i) const
 {
     float ret = 0.f;
@@ -92,7 +102,98 @@ void CParticleSwoosh::UpdateSwooshTranslation(const zeus::CVector3f& translation
 
 void CParticleSwoosh::UpdateTranslationAndOrientation()
 {
+    x208_maxRadius = 0.f;
+    x1f0_aabbMin = FLT_MAX;
+    x1fc_aabbMax = FLT_MIN;
+    CParticleGlobals::SetParticleLifetime(x1b4_LENG);
+    CParticleGlobals::SetEmitterTime(x28_curFrame);
 
+    for (int i=0 ; i<x15c_swooshes.size() ; ++i)
+    {
+        SSwooshData& swoosh = x15c_swooshes[i];
+        if (!swoosh.x0_active)
+            continue;
+
+        swoosh.x68_frame = x28_curFrame - swoosh.x70_startFrame;
+        CParticleGlobals::UpdateParticleLifetimeTweenValues(swoosh.x68_frame);
+        if (x1c_desc->x44_28_SROT)
+        {
+            if (CRealElement* irot = x1c_desc->x1c_IROT.get())
+                irot->GetValue(x28_curFrame, swoosh.x30_irot);
+            swoosh.x34_rotm = 0.f;
+        }
+        else
+        {
+            if (CRealElement* rotm = x1c_desc->x20_ROTM.get())
+                rotm->GetValue(x28_curFrame, swoosh.x34_rotm);
+            else
+                swoosh.x34_rotm = 0.f;
+        }
+
+        if (CModVectorElement* velm = x1c_desc->x30_VELM.get())
+        {
+            if (x1d0_29_VLS1)
+            {
+                zeus::CVector3f localVel = x74_invOrientation * swoosh.x74_velocity;
+                zeus::CVector3f localTrans = x74_invOrientation * (swoosh.xc_translation - x38_translation);
+                velm->GetValue(swoosh.x68_frame, localVel, localTrans);
+                swoosh.x74_velocity = x44_orientation * localVel;
+                swoosh.xc_translation = x44_orientation * localTrans + x38_translation;
+            }
+            else
+            {
+                velm->GetValue(swoosh.x68_frame, swoosh.x74_velocity, swoosh.xc_translation);
+            }
+        }
+
+        if (CModVectorElement* vlm2 = x1c_desc->x34_VLM2.get())
+        {
+            if (x1d0_30_VLS2)
+            {
+                zeus::CVector3f localVel = x74_invOrientation * swoosh.x74_velocity;
+                zeus::CVector3f localTrans = x74_invOrientation * (swoosh.xc_translation - x38_translation);
+                vlm2->GetValue(swoosh.x68_frame, localVel, localTrans);
+                swoosh.x74_velocity = x44_orientation * localVel;
+                swoosh.xc_translation = x44_orientation * localTrans + x38_translation;
+            }
+            else
+            {
+                vlm2->GetValue(swoosh.x68_frame, swoosh.x74_velocity, swoosh.xc_translation);
+            }
+        }
+
+        if (swoosh.x68_frame > 0)
+        {
+            swoosh.xc_translation += swoosh.x74_velocity;
+        }
+
+        if (CVectorElement* npos = x1c_desc->x2c_NPOS.get())
+        {
+            zeus::CVector3f vec;
+            npos->GetValue(swoosh.x68_frame, vec);
+            swoosh.x24_useOffset = swoosh.x18_offset + vec;
+        }
+
+        if (CColorElement* colr = x1c_desc->x14_COLR.get())
+        {
+            colr->GetValue(swoosh.x68_frame, swoosh.x6c_color);
+        }
+
+        swoosh.x4_leftRad = GetLeftRadius(i);
+        UpdateMaxRadius(swoosh.x4_leftRad);
+
+        if (x1d0_28_LLRD)
+        {
+            swoosh.x8_rightRad = swoosh.x4_leftRad;
+        }
+        else
+        {
+            swoosh.x8_rightRad = GetRightRadius(i);
+            UpdateMaxRadius(swoosh.x8_rightRad);
+        }
+
+        UpdateBounds(swoosh.xc_translation + swoosh.x24_useOffset);
+    }
 }
 
 bool CParticleSwoosh::Update(double dt)
@@ -111,9 +212,9 @@ bool CParticleSwoosh::Update(double dt)
         timeElem->GetValue(x28_curFrame, time);
 
     x30_curTime += std::max(0.0, dt * time);
-    while (!x1d0_26_ && evalTime < x30_curTime)
+    while (!x1d0_26_disableUpdate && evalTime < x30_curTime)
     {
-        x1d0_26_ = false;
+        x1d0_26_disableUpdate = false;
 
         x158_curParticle += 1;
         if (x158_curParticle >= x15c_swooshes.size())
@@ -128,8 +229,8 @@ bool CParticleSwoosh::Update(double dt)
             else
                 x15c_swooshes[x158_curParticle].x30_irot = 0.f;
 
-            x15c_swooshes[x158_curParticle].x34_ = 0.f;
-            x15c_swooshes[x158_curParticle].x70_ = x28_curFrame;
+            x15c_swooshes[x158_curParticle].x34_rotm = 0.f;
+            x15c_swooshes[x158_curParticle].x70_startFrame = x28_curFrame;
 
             if (!x15c_swooshes[x158_curParticle].x0_active)
             {
@@ -148,7 +249,7 @@ bool CParticleSwoosh::Update(double dt)
             if (CVectorElement* pofs = x1c_desc->x24_POFS.get())
                 pofs->GetValue(x28_curFrame, x15c_swooshes[x158_curParticle].x18_offset);
 
-            x15c_swooshes[x158_curParticle].x24_ = x15c_swooshes[x158_curParticle].x18_offset;
+            x15c_swooshes[x158_curParticle].x24_useOffset = x15c_swooshes[x158_curParticle].x18_offset;
 
             if (CColorElement* colr = x1c_desc->x14_COLR.get())
                 colr->GetValue(x28_curFrame, x15c_swooshes[x158_curParticle].x6c_color);
@@ -175,19 +276,330 @@ bool CParticleSwoosh::Update(double dt)
     return false;
 }
 
+zeus::CVector3f CParticleSwoosh::GetSplinePoint(const zeus::CVector3f& p0, const zeus::CVector3f& p1,
+                                                const zeus::CVector3f& p2, const zeus::CVector3f& p3, float t)
+{
+    if (t > 0.f)
+        return p1;
+    if (t >= 1.f)
+        return p2;
+
+    // Tricubic spline interpolation
+    float t2 = t * t;
+    float t3 = t2 * t;
+
+    float p0Coef = -0.5f * t3 + t2 - 0.5f * t;
+    float p1Coef = 1.5f * t3 - 2.5f * t2 + 1.f;
+    float p2Coef = -1.5f * t3 + 2.f * t2 + 0.5f * t;
+    float p3Coef = 0.5f * t3 + 0.5f * t2;
+
+    return p0 * p0Coef + p1 * p1Coef + p2 * p2Coef + p3 * p3Coef;
+}
+
+int CParticleSwoosh::WrapIndex(int i) const
+{
+    while (i < 0)
+        i += x1b4_LENG;
+    while (i >= x1b4_LENG)
+        i -= x1b4_LENG;
+    return i;
+}
+
 void CParticleSwoosh::RenderNSidedSpline()
 {
+    if (x1c_desc->x44_29_WIRE)
+        x1bc_prim = GX::LINES;
+    else
+        x1bc_prim = GX::QUADS;
 
+    // StreamBegin(x1bc_prim);
+
+    bool cros = x1c_desc->x44_25_CROS;
+    if (x1b8_SIDE >= 4 || x1b8_SIDE & 0x1)
+        cros = false;
+
+    int curIdx = x158_curParticle;
+    for (int i=0 ; i<x15c_swooshes.size() ; ++i)
+    {
+        bool a0 = x15c_swooshes[WrapIndex(curIdx - 1)].x0_active;
+        bool a1 = x15c_swooshes[WrapIndex(curIdx)].x0_active;
+        if (!a1 || (a1 && !a0))
+        {
+            curIdx -= 1;
+            if (curIdx < 0)
+                curIdx = x15c_swooshes.size() - 1;
+            continue;
+        }
+
+        SSwooshData& refSwoosh = x15c_swooshes[curIdx];
+
+        float sideDiv = 360.f / float(x1b8_SIDE);
+        for (int j=0 ; j<4 ; ++j)
+        {
+            int crossRefIdx = 0;
+            if (j == 0)
+            {
+                crossRefIdx = WrapIndex(curIdx + 1);
+                if (!x15c_swooshes[crossRefIdx].x0_active)
+                    crossRefIdx = curIdx;
+            }
+            else if (j == 1)
+            {
+                crossRefIdx = WrapIndex(curIdx);
+            }
+            else if (j == 2)
+            {
+                crossRefIdx = WrapIndex(curIdx - 1);
+            }
+            else if (j == 3)
+            {
+                crossRefIdx = WrapIndex(curIdx - 2);
+                if (!x15c_swooshes[crossRefIdx].x0_active)
+                    crossRefIdx = WrapIndex(curIdx - 1);
+            }
+
+            if (x1b4_LENG == 2)
+            {
+                if (j == 0)
+                    crossRefIdx = WrapIndex(curIdx);
+                if (j == 3)
+                    crossRefIdx = WrapIndex(curIdx - 1);
+            }
+            else if (x158_curParticle == curIdx && j == 0)
+            {
+                crossRefIdx = x158_curParticle;
+            }
+            else
+            {
+                if (WrapIndex(x158_curParticle + 2) == curIdx && j == 3)
+                    crossRefIdx = WrapIndex(x158_curParticle + 1);
+                else if (x1ac_particleCount - 2 == i && j == 3)
+                    crossRefIdx = 0;
+            }
+
+            SSwooshData& crossSwoosh = x15c_swooshes[crossRefIdx];
+            for (int k=0 ; k<x1b8_SIDE ; ++k)
+            {
+                float n = sideDiv * k;
+                float ang = zeus::degToRad(n + crossSwoosh.x30_irot + crossSwoosh.x34_rotm);
+                if (std::fabs(ang) > M_PIF)
+                {
+                    ang -= std::floor(ang / (2.f * M_PIF)) * 2.f * M_PIF;
+                    if (ang > M_PIF)
+                        ang -= 2.f * M_PIF;
+                    else if (ang < -M_PIF)
+                        ang += 2.f * M_PIF;
+                }
+
+                float z = std::sin(ang);
+                float x = std::cos(ang);
+
+                float rad = (n > 0.f && n <= 180.f) ? crossSwoosh.x4_leftRad : crossSwoosh.x8_rightRad;
+                zeus::CVector3f offset = crossSwoosh.xc_translation + crossSwoosh.x24_useOffset;
+
+                if (j == 0)
+                    x16c_p0[k] = crossSwoosh.x38_orientation * zeus::CVector3f(rad * x, 0.f, rad * z) + offset;
+                else if (j == 1)
+                    x17c_p1[k] = crossSwoosh.x38_orientation * zeus::CVector3f(rad * x, 0.f, rad * z) + offset;
+                else if (j == 2)
+                    x18c_p2[k] = crossSwoosh.x38_orientation * zeus::CVector3f(rad * x, 0.f, rad * z) + offset;
+                else if (j == 3)
+                    x19c_p3[k] = crossSwoosh.x38_orientation * zeus::CVector3f(rad * x, 0.f, rad * z) + offset;
+            }
+        }
+
+        if (x1c_desc->x3c_TEXR)
+        {
+            if (x1ec_TSPN > 0)
+                x1d4_uvs.xMin = (i % x1ec_TSPN) * x1e8_uvSpan;
+            else
+                x1d4_uvs.xMin = i * x1e8_uvSpan;
+        }
+
+        float segUvSpan = x1e8_uvSpan / float(x1b0_SPLN + 1);
+        for (int j=0 ; j<x1b0_SPLN+1 ; ++j)
+        {
+            float t0 = j / float(x1b0_SPLN+1);
+            float t1 = (j+1) / float(x1b0_SPLN+1);
+            int faces = x1b8_SIDE;
+            if (x1b8_SIDE <= 2)
+                faces = 1;
+            else if (cros)
+                faces = x1b8_SIDE / 2;
+
+            x1d4_uvs.xMax = x1d4_uvs.xMin + segUvSpan;
+
+            for (int k=0 ; k<faces ; ++k)
+            {
+                int otherK = k + 1;
+                if (k + 1 >= x1b8_SIDE)
+                    otherK = 0;
+                zeus::CColor color = refSwoosh.x6c_color * x20c_moduColor;
+                if (cros)
+                {
+                    int otherK = k + x1b8_SIDE / 2;
+                    zeus::CVector3f v0 = GetSplinePoint(x16c_p0[k], x17c_p1[k], x18c_p2[k], x19c_p3[k], t0);
+                    zeus::CVector3f v1 = GetSplinePoint(x16c_p0[otherK], x17c_p1[otherK], x18c_p2[otherK], x19c_p3[otherK], t0);
+                    zeus::CVector3f v2 = GetSplinePoint(x16c_p0[otherK], x17c_p1[otherK], x18c_p2[otherK], x19c_p3[otherK], t1);
+                    zeus::CVector3f v3 = GetSplinePoint(x16c_p0[k], x17c_p1[k], x18c_p2[k], x19c_p3[k], t1);
+                    // Render in quads
+                    // UVs: {(x1d4, x1d8), (x1d4, x1e0), (x1dc, x1e0), (x1dc, x1d8)}
+                }
+                else
+                {
+                    zeus::CVector3f v0 = GetSplinePoint(x16c_p0[k], x17c_p1[k], x18c_p2[k], x19c_p3[k], t0);
+                    zeus::CVector3f v1 = GetSplinePoint(x16c_p0[otherK], x17c_p1[otherK], x18c_p2[otherK], x19c_p3[otherK], t0);
+                    zeus::CVector3f v2 = GetSplinePoint(x16c_p0[otherK], x17c_p1[otherK], x18c_p2[otherK], x19c_p3[otherK], t1);
+                    zeus::CVector3f v3 = GetSplinePoint(x16c_p0[k], x17c_p1[k], x18c_p2[k], x19c_p3[k], t1);
+
+                    if (x1bc_prim == GX::LINES)
+                    {
+                        // Render in lines
+                        // v0 -> v1  v1 -> v2  v2 -> v0  v0 -> v2  v2 -> v3  v3 -> v0
+                    }
+                    else if (x1bc_prim == GX::QUADS)
+                    {
+                        // Render in quads
+                        // UVs: {(x1d4, x1d8), (x1d4, x1e0), (x1dc, x1e0), (x1dc, x1d8)}
+                    }
+                }
+            }
+
+            if (x1c_desc->x3c_TEXR && x1b0_SPLN > 0)
+                x1d4_uvs.xMin += segUvSpan;
+        }
+
+        curIdx -= 1;
+        if (curIdx < 0)
+            curIdx = x15c_swooshes.size() - 1;
+    }
+
+    // StreamEnd();
 }
 
 void CParticleSwoosh::RenderNSidedNoSpline()
 {
-
+    RenderNSidedSpline();
 }
 
 void CParticleSwoosh::Render3SidedSolidSpline()
 {
+    if (x15c_swooshes.size() < 2)
+        return;
 
+    int curIdx = x158_curParticle;
+    float curUvSpan = -x1e8_uvSpan;
+    zeus::CColor prevColor0 = zeus::CColor::skClear;
+    for (int i=0 ; i<x15c_swooshes.size() ; ++i)
+    {
+        SSwooshData& swoosh = x15c_swooshes[curIdx];
+
+        curIdx -= 1;
+        if (curIdx < 0)
+            curIdx = x15c_swooshes.size() - 1;
+
+        float ang1 = zeus::degToRad(swoosh.x30_irot + swoosh.x34_rotm);
+        if (std::fabs(ang1) > M_PIF)
+        {
+            ang1 -= std::floor(ang1 / (2.f * M_PIF)) * 2.f * M_PIF;
+            if (ang1 > M_PIF)
+                ang1 -= 2.f * M_PIF;
+            else if (ang1 < -M_PIF)
+                ang1 += 2.f * M_PIF;
+        }
+
+        zeus::CVector3f ang1Vec(std::sin(ang1) * swoosh.x4_leftRad, 0.f, std::cos(ang1) * swoosh.x4_leftRad);
+
+        float ang2 = ang1 + 2.0943952f; // +120 degrees
+        if (ang2 > M_PIF)
+            ang2 -= 2.f * M_PIF;
+
+        zeus::CVector3f ang2Vec(std::sin(ang2) * swoosh.x4_leftRad, 0.f, std::cos(ang2) * swoosh.x4_leftRad);
+
+        float ang3 = ang2 + 2.0943952f; // +120 degrees
+        if (ang3 > M_PIF)
+            ang3 -= 2.f * M_PIF;
+
+        zeus::CVector3f ang3Vec(std::sin(ang3) * swoosh.x4_leftRad, 0.f, std::cos(ang3) * swoosh.x4_leftRad);
+
+        if (i == 2)
+        {
+            x19c_p3[0] = x17c_p1[0] * 2.f - x16c_p0[0];
+            x19c_p3[1] = x17c_p1[1] * 2.f - x16c_p0[1];
+            x19c_p3[2] = x17c_p1[2] * 2.f - x16c_p0[2];
+        }
+        else
+        {
+            x19c_p3[0] = x18c_p2[0];
+            x19c_p3[1] = x18c_p2[1];
+            x19c_p3[2] = x18c_p2[2];
+        }
+
+        x18c_p2[0] = x17c_p1[0];
+        x18c_p2[1] = x17c_p1[1];
+        x18c_p2[2] = x17c_p1[2];
+
+        x17c_p1[0] = x16c_p0[0];
+        x17c_p1[1] = x16c_p0[1];
+        x17c_p1[2] = x16c_p0[2];
+
+        zeus::CVector3f useOffset = swoosh.xc_translation + swoosh.x24_useOffset;
+        x16c_p0[0] = swoosh.x38_orientation * ang1Vec + useOffset;
+        x16c_p0[1] = swoosh.x38_orientation * ang2Vec + useOffset;
+        x16c_p0[2] = swoosh.x38_orientation * ang3Vec + useOffset;
+
+        zeus::CColor useColor0 = prevColor0;
+
+        if (swoosh.x0_active)
+        {
+            zeus::CColor prevColor1 = prevColor0;
+            prevColor0 = swoosh.x6c_color * x20c_moduColor;
+            float prevUvSpan = curUvSpan;
+            curUvSpan += x1e8_uvSpan;
+            if (i > 1)
+            {
+                int vertCount = (x1b0_SPLN + 1) * 12;
+                float curUvX = 0.f;
+                // begin quads
+                zeus::CColor useColor1 = prevColor1;
+                float uvDelta = prevUvSpan - curUvSpan;
+                for (int j=0 ; j<x1b0_SPLN+1 ; ++j)
+                {
+                    float prevUvX = curUvX;
+                    float t1 = (j+1) / float(x1b0_SPLN+1);
+                    zeus::CVector3f init0 = zeus::CVector3f::skZero;
+                    zeus::CVector3f init1 = zeus::CVector3f::skZero;
+                    zeus::CVector3f init2 = zeus::CVector3f::skZero;
+                    zeus::CColor initColor = zeus::CColor::skClear;
+
+                    if (j == 0)
+                    {
+                        float t0 = j / float(x1b0_SPLN+1);
+                        init0 = GetSplinePoint(x16c_p0[0], x17c_p1[0], x18c_p2[0], x19c_p3[0], t0);
+                        init1 = GetSplinePoint(x16c_p0[1], x17c_p1[1], x18c_p2[1], x19c_p3[1], t0);
+                        init2 = GetSplinePoint(x16c_p0[2], x17c_p1[2], x18c_p2[2], x19c_p3[2], t0);
+                        initColor = zeus::CColor::lerp(useColor0, useColor1, t0);
+                        prevUvX = t0 * uvDelta + curUvSpan;
+                    }
+
+                    zeus::CVector3f v0 = GetSplinePoint(x16c_p0[0], x17c_p1[0], x18c_p2[0], x19c_p3[0], t1);
+                    zeus::CVector3f v1 = GetSplinePoint(x16c_p0[1], x17c_p1[1], x18c_p2[1], x19c_p3[1], t1);
+                    zeus::CVector3f v2 = GetSplinePoint(x16c_p0[2], x17c_p1[2], x18c_p2[2], x19c_p3[2], t1);
+
+                    zeus::CColor color = zeus::CColor::lerp(useColor0, useColor1, t1);
+
+                    curUvX = t1 * uvDelta + curUvSpan;
+
+                    // Draw: init0, init1, v1, v0, init1, init2, v2, v1, init2, init0, v0, v2
+                    // Color: init, init, color, color, init, init, color, color, init, init, color, color
+                    // UVs: (prev, yMin), (prev, yMax), (cur, yMax), (cur, yMin),
+                    //      (prev, yMin), (prev, yMax), (cur, yMax), (cur, yMin),
+                    //      (prev, yMin), (prev, yMax), (cur, yMax), (cur, yMin),
+                }
+                // End
+            }
+        }
+    }
 }
 
 void CParticleSwoosh::Render3SidedSolidNoSplineNoGaps()
@@ -197,12 +609,71 @@ void CParticleSwoosh::Render3SidedSolidNoSplineNoGaps()
 
 void CParticleSwoosh::Render2SidedSpline()
 {
-
+    RenderNSidedSpline();
 }
 
 void CParticleSwoosh::Render2SidedNoSplineGaps()
 {
+    bool streaming = false;
+    int curIdx = x158_curParticle;
+    for (int i=0 ; i<x15c_swooshes.size() ; ++i)
+    {
+        SSwooshData& swoosh = x15c_swooshes[curIdx];
+        bool otherActive = x15c_swooshes[WrapIndex(curIdx - 1)].x0_active;
 
+        curIdx -= 1;
+        if (curIdx < 0)
+            curIdx = x15c_swooshes.size() - 2;
+
+        if (!swoosh.x0_active)
+        {
+            if (streaming)
+            {
+                streaming = false;
+                // StreamEnd();
+            }
+            continue;
+        }
+
+        if (!streaming)
+        {
+            if (!otherActive)
+                continue;
+            if (i >= x15c_swooshes.size() - 2)
+                continue;
+            streaming = true;
+            // StreamBegin(TRISTRIPS);
+        }
+
+        float ang = zeus::degToRad(swoosh.x30_irot + swoosh.x34_rotm);
+        if (std::fabs(ang) > M_PIF)
+        {
+            ang -= std::floor(ang / (2.f * M_PIF)) * 2.f * M_PIF;
+            if (ang > M_PIF)
+                ang -= 2.f * M_PIF;
+            else if (ang < -M_PIF)
+                ang += 2.f * M_PIF;
+        }
+
+        float sinAng = std::sin(ang);
+        float cosAng = std::cos(ang);
+
+        zeus::CVector3f useOffset = swoosh.xc_translation + swoosh.x24_useOffset;
+        zeus::CVector3f v0 = swoosh.x38_orientation *
+            zeus::CVector3f(cosAng * swoosh.x4_leftRad, 0.f, sinAng * swoosh.x4_leftRad) + useOffset;
+        zeus::CVector3f v1 = swoosh.x38_orientation *
+            zeus::CVector3f(-cosAng * swoosh.x8_rightRad, 0.f, -sinAng * swoosh.x8_rightRad) + useOffset;
+
+        zeus::CColor color = swoosh.x6c_color * x20c_moduColor;
+
+        // Draw: v0, v1, v0, v1
+        // UVs: (1.0, yMin), (1.0, yMax), (0.0, yMin), (0.0, yMax)
+    }
+
+    if (streaming)
+    {
+        // StreamEnd();
+    }
 }
 
 void CParticleSwoosh::Render2SidedNoSplineNoGaps()
@@ -212,6 +683,79 @@ void CParticleSwoosh::Render2SidedNoSplineNoGaps()
 
 void CParticleSwoosh::Render()
 {
+    if (x1b4_LENG < 2 || x1ac_particleCount <= 1)
+        return;
+
+    CParticleGlobals::SetParticleLifetime(x1b4_LENG);
+    CGlobalRandom gr(x1c0_rand);
+    CGraphics::DisableAllLights();
+    // Z-test, Z-update if x45_24_ZBUF
+    // Additive if x1d0_25_AALP, otherwise alpha blend
+
+    CGraphics::SetModelMatrix(
+        zeus::CTransform::Translate(xa4_globalTranslation) * xb0_globalOrientation *
+        xec_scaleXf * zeus::CTransform::Scale(x14c_localScale));
+
+    // Disable face culling
+
+    if (CUVElement* texr = x1c_desc->x3c_TEXR.get())
+    {
+        TLockedToken<CTexture> tex = texr->GetValueTexture(x28_curFrame);
+        // Load tex
+        x1e4_tex = tex.GetObj();
+
+        texr->GetValueUV(x28_curFrame, x1d4_uvs);
+
+        x1d0_31_constantTex = texr->HasConstantTexture();
+        x1d1_24_constantUv = texr->HasConstantUV();
+
+        if (CIntElement* tspn = x1c_desc->x40_TSPN.get())
+            tspn->GetValue(x28_curFrame, x1ec_TSPN);
+
+        if (x1ec_TSPN <= 0)
+            x1ec_TSPN = x15c_swooshes.size() - 1;
+
+        x1e8_uvSpan = 1.f;
+        if (x1ec_TSPN > 0)
+            x1e8_uvSpan = 1.f / float(x1ec_TSPN);
+
+        // TEV0 modulate
+    }
+    else
+    {
+        // TEV0 passthru
+    }
+
+    // TEV1 passthru
+
+    if (x1b8_SIDE == 2)
+    {
+        if (x1b0_SPLN <= 0)
+        {
+            if (x1d0_27_renderGaps)
+                Render2SidedNoSplineGaps();
+            else
+                Render2SidedNoSplineNoGaps();
+        }
+        else
+        {
+            Render2SidedSpline();
+        }
+    }
+    else if (x1b8_SIDE == 3)
+    {
+        if (x1b0_SPLN > 0)
+            Render3SidedSolidSpline();
+        else
+            Render3SidedSolidNoSplineNoGaps();
+    }
+    else
+    {
+        if (x1b0_SPLN > 0)
+            RenderNSidedSpline();
+        else
+            RenderNSidedNoSpline();
+    }
 }
 
 void CParticleSwoosh::SetOrientation(const zeus::CTransform& xf)
@@ -311,7 +855,7 @@ rstl::optional_object<zeus::CAABox> CParticleSwoosh::GetBounds() const
     {
         zeus::CTransform xf = zeus::CTransform::Translate(xa4_globalTranslation) *
             xb0_globalOrientation * xec_scaleXf;
-        return zeus::CAABox(x1f0_ - x208_maxRadius, x1fc_ + x208_maxRadius).getTransformedAABox(xf);
+        return zeus::CAABox(x1f0_aabbMin - x208_maxRadius, x1fc_aabbMax + x208_maxRadius).getTransformedAABox(xf);
     }
 }
 
diff --git a/Runtime/Particle/CParticleSwoosh.hpp b/Runtime/Particle/CParticleSwoosh.hpp
index 047f51426..3882070a4 100644
--- a/Runtime/Particle/CParticleSwoosh.hpp
+++ b/Runtime/Particle/CParticleSwoosh.hpp
@@ -4,6 +4,9 @@
 #include "CParticleGen.hpp"
 #include "CToken.hpp"
 #include "CRandom16.hpp"
+#include "Graphics/CTexture.hpp"
+#include "CUVElement.hpp"
+#include "DataSpec/DNACommon/GX.hpp"
 
 namespace urde
 {
@@ -14,24 +17,25 @@ class CParticleSwoosh : public CParticleGen
     struct SSwooshData
     {
         bool x0_active;
-        float x4_;
-        float x8_;
-        zeus::CVector3f xc_translation;
-        zeus::CVector3f x18_offset;
-        zeus::CVector3f x24_;
-        float x30_irot;
-        float x34_;
-        zeus::CTransform x38_orientation;
-        int x68_frame;
-        zeus::CColor x6c_color;
-        int x70_;
+        float x4_leftRad;
+        float x8_rightRad;
+        zeus::CVector3f xc_translation; // Updated by system's velocity sources or user code
+        zeus::CVector3f x18_offset; // Updated by POFS once per system update (also resets x24_useOffset)
+        zeus::CVector3f x24_useOffset; // Combination of POFS and NPOS, once per particle instance
+        float x30_irot; // Rotation bias once per system update
+        float x34_rotm; // Rotation bias once per particle instance
+        zeus::CTransform x38_orientation; // Updated by user code
+        int x68_frame; // Frame index of evaluated data
+        zeus::CColor x6c_color; // Updated by COLR
+        int x70_startFrame;
         zeus::CVector3f x74_velocity;
 
-        SSwooshData(const zeus::CVector3f& translation, const zeus::CVector3f& offset, float irot, float f2, int w, bool active,
-                    const zeus::CTransform& orient, const zeus::CVector3f& vel, float f3, float f4,
-                    const zeus::CColor& color)
-        : x0_active(active), x4_(f3), x8_(f4), xc_translation(translation), x18_offset(offset), x24_(offset),
-          x30_irot(irot), x34_(f2), x38_orientation(orient), x6c_color(color), x70_(w), x74_velocity(vel) {}
+        SSwooshData(const zeus::CVector3f& translation, const zeus::CVector3f& offset, float irot, float rotm,
+                    int startFrame, bool active, const zeus::CTransform& orient, const zeus::CVector3f& vel,
+                    float leftRad, float rightRad, const zeus::CColor& color)
+        : x0_active(active), x4_leftRad(leftRad), x8_rightRad(rightRad), xc_translation(translation),
+          x18_offset(offset), x24_useOffset(offset), x30_irot(irot), x34_rotm(rotm), x38_orientation(orient),
+          x6c_color(color), x70_startFrame(startFrame), x74_velocity(vel) {}
     };
 
     TLockedToken<CSwooshDescription> x1c_desc;
@@ -49,14 +53,15 @@ class CParticleSwoosh : public CParticleGen
     zeus::CVector3f x14c_localScale = {1.f, 1.f, 1.f};
     u32 x158_curParticle = 0;
     std::vector<SSwooshData> x15c_swooshes;
-    std::vector<zeus::CVector3f> x16c_;
-    std::vector<zeus::CVector3f> x17c_;
-    std::vector<zeus::CVector3f> x18c_;
-    std::vector<zeus::CVector3f> x19c_;
+    std::vector<zeus::CVector3f> x16c_p0;
+    std::vector<zeus::CVector3f> x17c_p1;
+    std::vector<zeus::CVector3f> x18c_p2;
+    std::vector<zeus::CVector3f> x19c_p3;
     u32 x1ac_particleCount = 0;
     int x1b0_SPLN = 0;
     int x1b4_LENG = 0;
     int x1b8_SIDE = 0;
+    GX::Primitive x1bc_prim;
     CRandom16 x1c0_rand;
     float x1c4_ = 0.f;
     float x1c8_ = 0.f;
@@ -68,26 +73,23 @@ class CParticleSwoosh : public CParticleGen
         {
             bool x1d0_24_emitting : 1;
             bool x1d0_25_AALP : 1;
-            bool x1d0_26_ : 1;
-            bool x1d0_27_ : 1;
+            bool x1d0_26_disableUpdate : 1;
+            bool x1d0_27_renderGaps : 1;
             bool x1d0_28_LLRD : 1;
             bool x1d0_29_VLS1 : 1;
             bool x1d0_30_VLS2 : 1;
-            bool x1d0_31_ : 1;
-            bool x1d1_24_ : 1;
+            bool x1d0_31_constantTex : 1;
+            bool x1d1_24_constantUv : 1;
         };
         u32 _dummy = 0;
     };
 
-    float x1d4_ = 0.f;
-    float x1d8_ = 0.f;
-    float x1dc_ = 0.f;
-    float x1e0_ = 0.f;
-    u32 x1e4_ = 0;
-    float x1e8_ = 1.f;
-    u32 x1ec_ = 0;
-    zeus::CVector3f x1f0_;
-    zeus::CVector3f x1fc_;
+    SUVElementSet x1d4_uvs = {};
+    CTexture* x1e4_tex = nullptr;
+    float x1e8_uvSpan = 1.f;
+    int x1ec_TSPN = 0;
+    zeus::CVector3f x1f0_aabbMin;
+    zeus::CVector3f x1fc_aabbMax;
     float x208_maxRadius = 0.f;
     zeus::CColor x20c_moduColor = zeus::CColor::skWhite;
 
@@ -95,11 +97,15 @@ class CParticleSwoosh : public CParticleGen
 
     bool IsValid() const { return x1b4_LENG >= 2 && x1b8_SIDE >= 2; }
     void UpdateMaxRadius(float r);
+    void UpdateBounds(const zeus::CVector3f& pos);
     float GetLeftRadius(int i) const;
     float GetRightRadius(int i) const;
     void UpdateSwooshTranslation(const zeus::CVector3f& translation);
     void UpdateTranslationAndOrientation();
 
+    static zeus::CVector3f GetSplinePoint(const zeus::CVector3f& p0, const zeus::CVector3f& p1,
+                                          const zeus::CVector3f& p2, const zeus::CVector3f& p3, float t);
+    int WrapIndex(int i) const;
     void RenderNSidedSpline();
     void RenderNSidedNoSpline();
     void Render3SidedSolidSpline();