mirror of https://github.com/AxioDL/metaforce.git
1015 lines
35 KiB
C++
1015 lines
35 KiB
C++
#include "CParticleSwoosh.hpp"
|
|
#include "CSwooshDescription.hpp"
|
|
#include "CParticleGlobals.hpp"
|
|
#include <chrono>
|
|
|
|
namespace urde {
|
|
|
|
int CParticleSwoosh::g_ParticleSystemAliveCount = 0;
|
|
|
|
CParticleSwoosh::CParticleSwoosh(const TToken<CSwooshDescription>& desc, int leng)
|
|
: x1c_desc(desc)
|
|
, x1c0_rand(x1c_desc->x45_26_CRND ? std::chrono::duration_cast<std::chrono::microseconds>(
|
|
std::chrono::steady_clock::now().time_since_epoch())
|
|
.count()
|
|
: 99) {
|
|
x1d0_24_emitting = true;
|
|
++g_ParticleSystemAliveCount;
|
|
|
|
if (leng > 0)
|
|
x1b4_LENG = leng;
|
|
else if (CIntElement* leng = x1c_desc->x10_LENG.get())
|
|
leng->GetValue(0, x1b4_LENG);
|
|
x1b4_LENG += 1;
|
|
|
|
if (CIntElement* side = x1c_desc->x18_SIDE.get())
|
|
side->GetValue(0, x1b8_SIDE);
|
|
|
|
x1d0_28_LLRD = x1c_desc->x44_24_LLRD;
|
|
x1d0_29_VLS1 = x1c_desc->x44_26_VLS1;
|
|
x1d0_30_VLS2 = x1c_desc->x44_27_VLS2;
|
|
|
|
if (IsValid()) {
|
|
if (CIntElement* pslt = x1c_desc->x0_PSLT.get())
|
|
pslt->GetValue(0, x2c_PSLT);
|
|
else
|
|
x2c_PSLT = INT_MAX;
|
|
|
|
x1d0_25_AALP = x1c_desc->x44_31_AALP;
|
|
|
|
if (CIntElement* spln = x1c_desc->x38_SPLN.get())
|
|
spln->GetValue(0, x1b0_SPLN);
|
|
if (x1b0_SPLN < 0)
|
|
x1b0_SPLN = 0;
|
|
|
|
x15c_swooshes.clear();
|
|
x15c_swooshes.reserve(x1b4_LENG);
|
|
for (int i = 0; i < x1b4_LENG; ++i)
|
|
x15c_swooshes.emplace_back(zeus::skZero3f, zeus::skZero3f, 0.f, 0.f, 0, false,
|
|
zeus::CTransform(), zeus::skZero3f, 0.f, 0.f,
|
|
zeus::skClear);
|
|
|
|
SetOrientation(zeus::CTransform());
|
|
|
|
x16c_p0.resize(x1b8_SIDE);
|
|
x17c_p1.resize(x1b8_SIDE);
|
|
x18c_p2.resize(x1b8_SIDE);
|
|
x19c_p3.resize(x1b8_SIDE);
|
|
|
|
if (x1c_desc->x44_29_WIRE) {
|
|
int maxVerts = x1b4_LENG * (x1b0_SPLN + 1) * x1b8_SIDE * 12;
|
|
m_lineRenderer.reset(
|
|
new CLineRenderer(CLineRenderer::EPrimitiveMode::Lines, maxVerts * 2, nullptr, x1d0_25_AALP));
|
|
} else {
|
|
int maxVerts = x1b4_LENG * (x1b0_SPLN + 1) * x1b8_SIDE * 4;
|
|
m_cachedVerts.reserve(maxVerts);
|
|
CGraphics::CommitResources([&](boo::IGraphicsDataFactory::Context& ctx) {
|
|
m_vertBuf = ctx.newDynamicBuffer(boo::BufferUse::Vertex, sizeof(CParticleSwooshShaders::Vert), maxVerts);
|
|
m_uniformBuf = ctx.newDynamicBuffer(boo::BufferUse::Uniform, sizeof(zeus::CMatrix4f), 1);
|
|
CParticleSwooshShaders::BuildShaderDataBinding(ctx, *this);
|
|
return true;
|
|
} BooTrace);
|
|
}
|
|
}
|
|
}
|
|
|
|
CParticleSwoosh::~CParticleSwoosh() { --g_ParticleSystemAliveCount; }
|
|
|
|
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], float(x1fc_aabbMax[0]));
|
|
x1fc_aabbMax[1] = std::max(pos[1], float(x1fc_aabbMax[1]));
|
|
x1fc_aabbMax[2] = std::max(pos[2], float(x1fc_aabbMax[2]));
|
|
x1f0_aabbMin[0] = std::min(pos[0], float(x1f0_aabbMin[0]));
|
|
x1f0_aabbMin[1] = std::min(pos[1], float(x1f0_aabbMin[1]));
|
|
x1f0_aabbMin[2] = std::min(pos[2], float(x1f0_aabbMin[2]));
|
|
}
|
|
|
|
float CParticleSwoosh::GetLeftRadius(int i) const {
|
|
float ret = 0.f;
|
|
if (CRealElement* lrad = x1c_desc->x8_LRAD.get())
|
|
lrad->GetValue(x15c_swooshes[i].x68_frame, ret);
|
|
return ret;
|
|
}
|
|
|
|
float CParticleSwoosh::GetRightRadius(int i) const {
|
|
float ret = 0.f;
|
|
if (CRealElement* rrad = x1c_desc->xc_RRAD.get())
|
|
rrad->GetValue(x15c_swooshes[i].x68_frame, ret);
|
|
return ret;
|
|
}
|
|
|
|
void CParticleSwoosh::UpdateSwooshTranslation(const zeus::CVector3f& translation) {
|
|
x15c_swooshes[x158_curParticle].xc_translation = x11c_invScaleXf * translation;
|
|
}
|
|
|
|
void CParticleSwoosh::UpdateTranslationAndOrientation() {
|
|
x208_maxRadius = 0.f;
|
|
x1f0_aabbMin = zeus::CVector3f(FLT_MAX);
|
|
x1fc_aabbMax = zeus::CVector3f(-FLT_MAX);
|
|
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) {
|
|
if (!IsValid())
|
|
return false;
|
|
|
|
CParticleGlobals::SetParticleLifetime(x1b4_LENG);
|
|
CParticleGlobals::SetEmitterTime(x28_curFrame);
|
|
CParticleGlobals::UpdateParticleLifetimeTweenValues(0);
|
|
CGlobalRandom gr(x1c0_rand);
|
|
|
|
double evalTime = x28_curFrame / 60.0;
|
|
float time = 1.f;
|
|
if (CRealElement* timeElem = x1c_desc->x4_TIME.get())
|
|
timeElem->GetValue(x28_curFrame, time);
|
|
|
|
x30_curTime += std::max(0.0, dt * time);
|
|
while (x1d0_26_forceOneUpdate || evalTime < x30_curTime) {
|
|
x1d0_26_forceOneUpdate = false;
|
|
|
|
x158_curParticle += 1;
|
|
if (x158_curParticle >= x15c_swooshes.size())
|
|
x158_curParticle = 0;
|
|
|
|
if (x1d0_24_emitting && x28_curFrame < x2c_PSLT) {
|
|
UpdateSwooshTranslation(x38_translation);
|
|
|
|
if (CRealElement* irot = x1c_desc->x1c_IROT.get())
|
|
irot->GetValue(x28_curFrame, x15c_swooshes[x158_curParticle].x30_irot);
|
|
else
|
|
x15c_swooshes[x158_curParticle].x30_irot = 0.f;
|
|
|
|
x15c_swooshes[x158_curParticle].x34_rotm = 0.f;
|
|
x15c_swooshes[x158_curParticle].x70_startFrame = x28_curFrame;
|
|
|
|
if (!x15c_swooshes[x158_curParticle].x0_active) {
|
|
x1ac_particleCount += 1;
|
|
x15c_swooshes[x158_curParticle].x0_active = true;
|
|
}
|
|
|
|
x15c_swooshes[x158_curParticle].x38_orientation = x44_orientation;
|
|
|
|
if (CVectorElement* ivel = x1c_desc->x28_IVEL.get()) {
|
|
ivel->GetValue(x28_curFrame, x15c_swooshes[x158_curParticle].x74_velocity);
|
|
x15c_swooshes[x158_curParticle].x74_velocity = x44_orientation * x15c_swooshes[x158_curParticle].x74_velocity;
|
|
}
|
|
|
|
if (CVectorElement* pofs = x1c_desc->x24_POFS.get())
|
|
pofs->GetValue(x28_curFrame, 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);
|
|
else
|
|
x15c_swooshes[x158_curParticle].x6c_color = zeus::skWhite;
|
|
|
|
int tspn = 0;
|
|
if (CIntElement* tspnElem = x1c_desc->x40_TSPN.get())
|
|
tspnElem->GetValue(x28_curFrame, tspn);
|
|
x1cc_TSPN = tspn;
|
|
} else if (x15c_swooshes[x158_curParticle].x0_active) {
|
|
x1ac_particleCount = std::max(0, int(x1ac_particleCount) - 1);
|
|
x15c_swooshes[x158_curParticle].x0_active = false;
|
|
}
|
|
|
|
UpdateTranslationAndOrientation();
|
|
|
|
evalTime += (1.0 / 60.0);
|
|
x28_curFrame += 1;
|
|
}
|
|
|
|
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;
|
|
m_lineRenderer->Reset();
|
|
} else {
|
|
x1bc_prim = GX::QUADS;
|
|
}
|
|
|
|
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);
|
|
|
|
m_cachedVerts.push_back({v0, {x1d4_uvs.xMin, x1d4_uvs.yMin}, color});
|
|
m_cachedVerts.push_back({v1, {x1d4_uvs.xMin, x1d4_uvs.yMax}, color});
|
|
m_cachedVerts.push_back({v2, {x1d4_uvs.xMax, x1d4_uvs.yMin}, color});
|
|
m_cachedVerts.push_back({v3, {x1d4_uvs.xMax, x1d4_uvs.yMax}, color});
|
|
CGraphics::DrawArray(m_cachedVerts.size() - 4, 4);
|
|
} 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) {
|
|
m_lineRenderer->AddVertex(v0, color, 1.f);
|
|
m_lineRenderer->AddVertex(v1, color, 1.f);
|
|
m_lineRenderer->AddVertex(v1, color, 1.f);
|
|
m_lineRenderer->AddVertex(v2, color, 1.f);
|
|
m_lineRenderer->AddVertex(v2, color, 1.f);
|
|
m_lineRenderer->AddVertex(v0, color, 1.f);
|
|
m_lineRenderer->AddVertex(v0, color, 1.f);
|
|
m_lineRenderer->AddVertex(v2, color, 1.f);
|
|
m_lineRenderer->AddVertex(v2, color, 1.f);
|
|
m_lineRenderer->AddVertex(v3, color, 1.f);
|
|
m_lineRenderer->AddVertex(v3, color, 1.f);
|
|
m_lineRenderer->AddVertex(v0, color, 1.f);
|
|
} else if (x1bc_prim == GX::QUADS) {
|
|
m_cachedVerts.push_back({v0, {x1d4_uvs.xMin, x1d4_uvs.yMin}, color});
|
|
m_cachedVerts.push_back({v1, {x1d4_uvs.xMin, x1d4_uvs.yMax}, color});
|
|
m_cachedVerts.push_back({v2, {x1d4_uvs.xMax, x1d4_uvs.yMin}, color});
|
|
m_cachedVerts.push_back({v3, {x1d4_uvs.xMax, x1d4_uvs.yMax}, color});
|
|
CGraphics::DrawArray(m_cachedVerts.size() - 4, 4);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (x1c_desc->x3c_TEXR && x1b0_SPLN > 0)
|
|
x1d4_uvs.xMin += segUvSpan;
|
|
}
|
|
|
|
curIdx -= 1;
|
|
if (curIdx < 0)
|
|
curIdx = x15c_swooshes.size() - 1;
|
|
}
|
|
|
|
if (x1bc_prim == GX::LINES)
|
|
m_lineRenderer->Render();
|
|
}
|
|
|
|
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::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 uv1 = 0.f;
|
|
zeus::CColor useColor1 = prevColor1;
|
|
zeus::CVector3f v01 = zeus::skZero3f;
|
|
zeus::CVector3f v11 = zeus::skZero3f;
|
|
zeus::CVector3f v21 = zeus::skZero3f;
|
|
zeus::CColor c1 = zeus::skClear;
|
|
float uvDelta = prevUvSpan - curUvSpan;
|
|
for (int j = 0; j < x1b0_SPLN + 1; ++j) {
|
|
float uv0 = uv1;
|
|
float t1 = (j + 1) / float(x1b0_SPLN + 1);
|
|
zeus::CVector3f v00 = v01;
|
|
zeus::CVector3f v10 = v11;
|
|
zeus::CVector3f v20 = v21;
|
|
zeus::CColor c0 = c1;
|
|
|
|
if (j == 0) {
|
|
float t0 = j / float(x1b0_SPLN + 1);
|
|
v00 = GetSplinePoint(x16c_p0[0], x17c_p1[0], x18c_p2[0], x19c_p3[0], t0);
|
|
v10 = GetSplinePoint(x16c_p0[1], x17c_p1[1], x18c_p2[1], x19c_p3[1], t0);
|
|
v20 = GetSplinePoint(x16c_p0[2], x17c_p1[2], x18c_p2[2], x19c_p3[2], t0);
|
|
c0 = zeus::CColor::lerp(useColor0, useColor1, t0);
|
|
uv0 = t0 * uvDelta + curUvSpan;
|
|
}
|
|
|
|
v01 = GetSplinePoint(x16c_p0[0], x17c_p1[0], x18c_p2[0], x19c_p3[0], t1);
|
|
v11 = GetSplinePoint(x16c_p0[1], x17c_p1[1], x18c_p2[1], x19c_p3[1], t1);
|
|
v21 = GetSplinePoint(x16c_p0[2], x17c_p1[2], x18c_p2[2], x19c_p3[2], t1);
|
|
c1 = zeus::CColor::lerp(useColor0, useColor1, t1);
|
|
uv1 = t1 * uvDelta + curUvSpan;
|
|
|
|
m_cachedVerts.push_back({v00, {uv0, x1d4_uvs.yMin}, c0});
|
|
m_cachedVerts.push_back({v10, {uv0, x1d4_uvs.yMax}, c0});
|
|
m_cachedVerts.push_back({v01, {uv1, x1d4_uvs.yMin}, c1});
|
|
m_cachedVerts.push_back({v11, {uv1, x1d4_uvs.yMax}, c1});
|
|
CGraphics::DrawArray(m_cachedVerts.size() - 4, 4);
|
|
|
|
m_cachedVerts.push_back({v10, {uv0, x1d4_uvs.yMin}, c0});
|
|
m_cachedVerts.push_back({v20, {uv0, x1d4_uvs.yMax}, c0});
|
|
m_cachedVerts.push_back({v11, {uv1, x1d4_uvs.yMin}, c1});
|
|
m_cachedVerts.push_back({v21, {uv1, x1d4_uvs.yMax}, c1});
|
|
CGraphics::DrawArray(m_cachedVerts.size() - 4, 4);
|
|
|
|
m_cachedVerts.push_back({v20, {uv0, x1d4_uvs.yMin}, c0});
|
|
m_cachedVerts.push_back({v00, {uv0, x1d4_uvs.yMax}, c0});
|
|
m_cachedVerts.push_back({v21, {uv1, x1d4_uvs.yMin}, c1});
|
|
m_cachedVerts.push_back({v01, {uv1, x1d4_uvs.yMax}, c1});
|
|
CGraphics::DrawArray(m_cachedVerts.size() - 4, 4);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CParticleSwoosh::Render3SidedSolidNoSplineNoGaps() {
|
|
if (x15c_swooshes.size() < 2)
|
|
return;
|
|
|
|
zeus::CVector3f p0[2];
|
|
zeus::CVector3f p1[2];
|
|
zeus::CVector3f p2[2];
|
|
|
|
int curIdx = x158_curParticle;
|
|
bool lastActive = false;
|
|
zeus::CColor c0 = zeus::skClear;
|
|
float uv0 = -x1e8_uvSpan;
|
|
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);
|
|
|
|
zeus::CVector3f useOffset = swoosh.xc_translation + swoosh.x24_useOffset;
|
|
p0[i & 1] = swoosh.x38_orientation * ang1Vec + useOffset;
|
|
p1[i & 1] = swoosh.x38_orientation * ang2Vec + useOffset;
|
|
p2[i & 1] = swoosh.x38_orientation * ang3Vec + useOffset;
|
|
|
|
if (!swoosh.x0_active) {
|
|
lastActive = false;
|
|
continue;
|
|
}
|
|
|
|
if (!lastActive) {
|
|
lastActive = true;
|
|
continue;
|
|
}
|
|
|
|
lastActive = true;
|
|
zeus::CColor c1 = c0;
|
|
c0 = swoosh.x6c_color * x20c_moduColor;
|
|
|
|
float uv1 = uv0;
|
|
uv0 += x1e8_uvSpan;
|
|
|
|
m_cachedVerts.push_back({p0[i & 1], {uv0, x1d4_uvs.yMin}, c0});
|
|
m_cachedVerts.push_back({p1[i & 1], {uv0, x1d4_uvs.yMax}, c0});
|
|
m_cachedVerts.push_back({p0[!(i & 1)], {uv1, x1d4_uvs.yMin}, c1});
|
|
m_cachedVerts.push_back({p1[!(i & 1)], {uv1, x1d4_uvs.yMax}, c1});
|
|
CGraphics::DrawArray(m_cachedVerts.size() - 4, 4);
|
|
|
|
m_cachedVerts.push_back({p1[i & 1], {uv0, x1d4_uvs.yMin}, c0});
|
|
m_cachedVerts.push_back({p2[i & 1], {uv0, x1d4_uvs.yMax}, c0});
|
|
m_cachedVerts.push_back({p1[!(i & 1)], {uv1, x1d4_uvs.yMin}, c1});
|
|
m_cachedVerts.push_back({p2[!(i & 1)], {uv1, x1d4_uvs.yMax}, c1});
|
|
CGraphics::DrawArray(m_cachedVerts.size() - 4, 4);
|
|
|
|
m_cachedVerts.push_back({p2[i & 1], {uv0, x1d4_uvs.yMin}, c0});
|
|
m_cachedVerts.push_back({p0[i & 1], {uv0, x1d4_uvs.yMax}, c0});
|
|
m_cachedVerts.push_back({p2[!(i & 1)], {uv1, x1d4_uvs.yMin}, c1});
|
|
m_cachedVerts.push_back({p0[!(i & 1)], {uv1, x1d4_uvs.yMax}, c1});
|
|
CGraphics::DrawArray(m_cachedVerts.size() - 4, 4);
|
|
}
|
|
}
|
|
|
|
void CParticleSwoosh::Render2SidedSpline() { RenderNSidedSpline(); }
|
|
|
|
void CParticleSwoosh::Render2SidedNoSplineGaps() {
|
|
int drawStart = 0;
|
|
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;
|
|
CGraphics::DrawArray(drawStart, m_cachedVerts.size() - drawStart);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (!streaming) {
|
|
if (!otherActive)
|
|
continue;
|
|
if (i >= x15c_swooshes.size() - 2)
|
|
continue;
|
|
streaming = true;
|
|
drawStart = m_cachedVerts.size();
|
|
}
|
|
|
|
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;
|
|
|
|
m_cachedVerts.push_back({v0, {1.f, x1d4_uvs.yMin}, color});
|
|
m_cachedVerts.push_back({v1, {1.f, x1d4_uvs.yMax}, color});
|
|
m_cachedVerts.push_back({v0, {0.f, x1d4_uvs.yMin}, color});
|
|
m_cachedVerts.push_back({v1, {0.f, x1d4_uvs.yMax}, color});
|
|
}
|
|
|
|
if (streaming)
|
|
CGraphics::DrawArray(drawStart, m_cachedVerts.size() - drawStart);
|
|
}
|
|
|
|
void CParticleSwoosh::Render2SidedNoSplineNoGaps() {
|
|
int drawStart = 0;
|
|
int curIdx = x158_curParticle;
|
|
int particleCount = x1ac_particleCount;
|
|
float uvOffset = 0.f;
|
|
if (x1c_desc->x3c_TEXR) {
|
|
if (x1c_desc->x45_25_ORNT) {
|
|
zeus::CVector3f camToParticle =
|
|
((zeus::CTransform::Translate(xa4_globalTranslation) * xb0_globalOrientation * xec_scaleXf).inverse() *
|
|
CGraphics::g_ViewMatrix)
|
|
.origin;
|
|
zeus::CVector3f dotVec = zeus::skZero3f;
|
|
|
|
for (int i = 0; i < x15c_swooshes.size(); ++i) {
|
|
SSwooshData& swoosh = x15c_swooshes[curIdx];
|
|
|
|
curIdx -= 1;
|
|
if (curIdx < 0)
|
|
curIdx = x15c_swooshes.size() - 1;
|
|
|
|
if (swoosh.x0_active) {
|
|
particleCount -= 1;
|
|
int otherIdx = curIdx - 1;
|
|
if (otherIdx < 0)
|
|
otherIdx = x15c_swooshes.size() - 1;
|
|
|
|
SSwooshData& otherSwoosh = x15c_swooshes[otherIdx];
|
|
|
|
zeus::CVector3f delta = otherSwoosh.xc_translation - swoosh.xc_translation;
|
|
if (otherIdx == x158_curParticle)
|
|
delta = swoosh.xc_translation - x15c_swooshes[(curIdx + 1) % x15c_swooshes.size()].xc_translation;
|
|
|
|
if (delta.canBeNormalized()) {
|
|
zeus::CVector3f deltaCross = delta.cross(camToParticle - swoosh.xc_translation);
|
|
if (deltaCross.canBeNormalized()) {
|
|
deltaCross.normalize();
|
|
dotVec = (deltaCross.dot(dotVec) < 0.f ? -1.f : 1.f) * deltaCross;
|
|
zeus::CVector3f useOffset = swoosh.xc_translation + swoosh.x24_useOffset;
|
|
zeus::CVector3f v0 = dotVec * swoosh.x4_leftRad + useOffset;
|
|
zeus::CVector3f v1 = dotVec * -swoosh.x8_rightRad + useOffset;
|
|
|
|
zeus::CColor color = swoosh.x6c_color * x20c_moduColor;
|
|
|
|
m_cachedVerts.push_back({v0, {uvOffset, x1d4_uvs.yMin}, color});
|
|
m_cachedVerts.push_back({v1, {uvOffset, x1d4_uvs.yMax}, color});
|
|
if (uvOffset >= 1.f && particleCount) {
|
|
CGraphics::DrawArray(drawStart, m_cachedVerts.size() - drawStart);
|
|
drawStart = m_cachedVerts.size();
|
|
uvOffset -= 1.f;
|
|
m_cachedVerts.push_back({v0, {uvOffset, x1d4_uvs.yMin}, color});
|
|
m_cachedVerts.push_back({v1, {uvOffset, x1d4_uvs.yMax}, color});
|
|
}
|
|
|
|
if (x1ec_TSPN > 0)
|
|
uvOffset += x1e8_uvSpan;
|
|
else
|
|
uvOffset = i * x1e8_uvSpan;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (int i = 0; i < x15c_swooshes.size(); ++i) {
|
|
SSwooshData& swoosh = x15c_swooshes[curIdx];
|
|
|
|
curIdx -= 1;
|
|
if (curIdx < 0)
|
|
curIdx = x15c_swooshes.size() - 1;
|
|
|
|
if (swoosh.x0_active) {
|
|
particleCount -= 1;
|
|
|
|
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;
|
|
|
|
m_cachedVerts.push_back({v0, {uvOffset, x1d4_uvs.yMin}, color});
|
|
m_cachedVerts.push_back({v1, {uvOffset, x1d4_uvs.yMax}, color});
|
|
if (uvOffset >= 1.f && particleCount) {
|
|
CGraphics::DrawArray(drawStart, m_cachedVerts.size() - drawStart);
|
|
drawStart = m_cachedVerts.size();
|
|
uvOffset -= 1.f;
|
|
m_cachedVerts.push_back({v0, {uvOffset, x1d4_uvs.yMin}, color});
|
|
m_cachedVerts.push_back({v1, {uvOffset, x1d4_uvs.yMax}, color});
|
|
}
|
|
|
|
if (x1ec_TSPN > 0)
|
|
uvOffset += x1e8_uvSpan;
|
|
else
|
|
uvOffset = i * x1e8_uvSpan;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
for (int i = 0; i < x15c_swooshes.size(); ++i) {
|
|
SSwooshData& swoosh = x15c_swooshes[curIdx];
|
|
|
|
curIdx -= 1;
|
|
if (curIdx < 0)
|
|
curIdx = x15c_swooshes.size() - 1;
|
|
|
|
if (swoosh.x0_active) {
|
|
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;
|
|
m_cachedVerts.push_back({v0, {}, color});
|
|
m_cachedVerts.push_back({v1, {}, color});
|
|
}
|
|
}
|
|
}
|
|
|
|
CGraphics::DrawArray(drawStart, m_cachedVerts.size() - drawStart);
|
|
}
|
|
|
|
void CParticleSwoosh::Render(const CActorLights*) {
|
|
if (x1b4_LENG < 2 || x1ac_particleCount <= 1)
|
|
return;
|
|
|
|
m_cachedVerts.clear();
|
|
if (m_dataBind)
|
|
CGraphics::SetShaderDataBinding(m_dataBind);
|
|
|
|
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();
|
|
}
|
|
|
|
zeus::CMatrix4f mvp = CGraphics::GetPerspectiveProjectionMatrix(true) * CGraphics::g_GXModelView.toMatrix4f();
|
|
m_uniformBuf->load(&mvp, sizeof(zeus::CMatrix4f));
|
|
if (m_cachedVerts.size())
|
|
m_vertBuf->load(m_cachedVerts.data(), m_cachedVerts.size() * sizeof(CParticleSwooshShaders::Vert));
|
|
}
|
|
|
|
void CParticleSwoosh::SetOrientation(const zeus::CTransform& xf) {
|
|
x44_orientation = xf;
|
|
x74_invOrientation = xf.inverse();
|
|
x15c_swooshes[x158_curParticle].x38_orientation = xf;
|
|
}
|
|
|
|
void CParticleSwoosh::SetTranslation(const zeus::CVector3f& translation) {
|
|
x38_translation = translation;
|
|
UpdateSwooshTranslation(x38_translation);
|
|
}
|
|
|
|
void CParticleSwoosh::SetGlobalOrientation(const zeus::CTransform& xf) { xb0_globalOrientation = xf.getRotation(); }
|
|
|
|
void CParticleSwoosh::SetGlobalTranslation(const zeus::CVector3f& translation) { xa4_globalTranslation = translation; }
|
|
|
|
void CParticleSwoosh::SetGlobalScale(const zeus::CVector3f& scale) {
|
|
xe0_globalScale = scale;
|
|
xec_scaleXf = zeus::CTransform::Scale(scale);
|
|
x11c_invScaleXf = zeus::CTransform::Scale(1.f / scale);
|
|
}
|
|
|
|
void CParticleSwoosh::SetLocalScale(const zeus::CVector3f& scale) { x14c_localScale = scale; }
|
|
|
|
void CParticleSwoosh::SetParticleEmission(bool e) { x1d0_24_emitting = e; }
|
|
|
|
void CParticleSwoosh::SetModulationColor(const zeus::CColor& color) { x20c_moduColor = color; }
|
|
|
|
const zeus::CTransform& CParticleSwoosh::GetOrientation() const { return x44_orientation; }
|
|
|
|
const zeus::CVector3f& CParticleSwoosh::GetTranslation() const { return x38_translation; }
|
|
|
|
const zeus::CTransform& CParticleSwoosh::GetGlobalOrientation() const { return xb0_globalOrientation; }
|
|
|
|
const zeus::CVector3f& CParticleSwoosh::GetGlobalTranslation() const { return xa4_globalTranslation; }
|
|
|
|
const zeus::CVector3f& CParticleSwoosh::GetGlobalScale() const { return xe0_globalScale; }
|
|
|
|
const zeus::CColor& CParticleSwoosh::GetModulationColor() const { return x20c_moduColor; }
|
|
|
|
bool CParticleSwoosh::IsSystemDeletable() const {
|
|
if (x1d0_24_emitting && x28_curFrame < x2c_PSLT)
|
|
return false;
|
|
|
|
if (GetParticleCount() >= 2)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
rstl::optional<zeus::CAABox> CParticleSwoosh::GetBounds() const {
|
|
if (GetParticleCount() <= 1) {
|
|
zeus::CVector3f trans = x38_translation + xa4_globalTranslation;
|
|
return zeus::CAABox(trans, trans);
|
|
} else {
|
|
zeus::CTransform xf = zeus::CTransform::Translate(xa4_globalTranslation) * xb0_globalOrientation * xec_scaleXf;
|
|
return zeus::CAABox(x1f0_aabbMin - x208_maxRadius, x1fc_aabbMax + x208_maxRadius).getTransformedAABox(xf);
|
|
}
|
|
}
|
|
|
|
u32 CParticleSwoosh::GetParticleCount() const { return x1ac_particleCount; }
|
|
|
|
bool CParticleSwoosh::SystemHasLight() const { return false; }
|
|
|
|
CLight CParticleSwoosh::GetLight() const {
|
|
return CLight::BuildLocalAmbient(zeus::skZero3f, zeus::skWhite);
|
|
}
|
|
|
|
bool CParticleSwoosh::GetParticleEmission() const { return x1d0_24_emitting; }
|
|
|
|
void CParticleSwoosh::DestroyParticles() {
|
|
// Empty
|
|
}
|
|
|
|
} // namespace urde
|