Files
SatyandClaude Opus 5.5 e2038cdec5 Services: port Profile, TextBlock, Camera, particles and ribbons
Profile, TextBlock, Camera (+CameraInt.h), ParticleSystem2 (emitters,
track sampling, sort queue), RibbonEmitter, GfxSingletonManager managers
and the v1 CParticleEmitter destructor. All pass or approved with
explained diffs; 0 fails. Callee-cleanup helpers declared __stdcall,
float->int paths use CMath::fint_ (binary uses fistp). CLightning fields
named only; it is WoW/Common code. _Triage CAngle removed, Camera.h
repointed to CameraInt.h. CM2SceneRender Render calls cast for the new
signature. Services links freetype for the Gxu font headers.

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>
2026-09-27 03:08:52 +02:00

542 lines
19 KiB
C++

#include <cmath>
#include <cstddef>
#include <cstdint>
#include "Engine/Source/Services/RibbonEmitter.h"
#include "Engine/Source/Base/Handle.h"
#include "Engine/Source/Gx/CGxDevice/CGxDevice.h"
#include "Engine/Source/Gx/Gx.h"
#include "Engine/Source/Services/Texture.h"
#include "Engine/Source/ShaderEffect/ShaderEffect.h"
#include "Engine/Source/Storm/H/storm.h"
#include "Engine/Source/Tempest/C44Matrix.h"
#include "Engine/Source/Tempest/C4Vector.h"
// STATIC: 0x00B2D658
static int32_t s_ribbonRenderEnable = 1;
// INLINED
CRibbonMat::CRibbonMat() {
this->m_lit = 1;
this->m_fogged = 1;
this->m_depthTest = 1;
this->m_depthWrite = 1;
this->m_cull = 1;
this->m_blendMode = 0;
}
// VERIFY: 68bb48ac manual
// OFFSET: 0x0097F510
void CRibbonEmitter::ConvertTexSlotToTexCoords() {
uint32_t cols = this->m_cols;
uint32_t row = this->m_texSlot / cols;
float u = (this->m_texSlot % cols) * this->m_texCellU + this->m_texCoords.minY;
this->m_texSlotCoords.minY = u;
float v = row * this->m_texCellV + this->m_texCoords.minX;
this->m_texSlotCoords.minX = v;
this->m_texSlotCoords.maxY = u + this->m_texCellU;
this->m_texSlotCoords.maxX = v + this->m_texCellV;
}
// VERIFY: 507021d0 manual
// OFFSET: 0x0097F570
void CRibbonEmitter::SetDataEnabled(int32_t enabled) {
this->m_flags ^= (this->m_flags ^ (4 * enabled)) & 0x4;
if (!(this->m_flags & 0x4)) {
this->m_flags &= ~0x1;
}
}
// VERIFY: 2a6d93b6 manual
// OFFSET: 0x0097F5B0
void CRibbonEmitter::SetUserEnabled(uint32_t enabled) {
this->m_flags ^= (this->m_flags ^ (8 * enabled)) & 0x8;
if (!(this->m_flags & 0x8)) {
this->m_flags &= ~0x1;
}
}
// VERIFY: f8d931dc auto
// OFFSET: 0x0097F5F0
void CRibbonEmitter::SetTexSlot(uint32_t slot) {
if (this->m_texSlot != slot) {
this->m_texSlot = slot;
this->ConvertTexSlotToTexCoords();
}
}
// VERIFY: a4ee293a auto
// OFFSET: 0x0097F610
void CRibbonEmitter::SetAbove(float above) {
this->m_above = above;
}
// VERIFY: 3fe02f2e auto
// OFFSET: 0x0097F620
void CRibbonEmitter::SetBelow(float below) {
this->m_below = below;
}
// VERIFY: ca13231a auto
// OFFSET: 0x0097F630
void CRibbonEmitter::SetGravity(float gravity) {
this->m_gravity = gravity;
}
// VERIFY: bfe848c9 auto
// OFFSET: 0x0097F640
int32_t CRibbonEmitter::IsDead() {
return this->m_readPos == this->m_writePos;
}
// VERIFY: 6515ce90 manual
// OFFSET: 0x0097F700
void CRibbonEmitter::InitInterpDeltas() {
float dz = this->m_prevPos.z - this->m_currPos.z;
float dy = this->m_prevPos.y - this->m_currPos.y;
float dx = this->m_prevPos.x - this->m_currPos.x;
float distance = sqrt(dx * dx + (dy * dy + dz * dz));
this->m_startBelow = C3Vector(this->m_prevPos.x - this->m_prevUp.x * this->m_below, this->m_prevPos.y - this->m_prevUp.y * this->m_below, this->m_prevPos.z - this->m_below * this->m_prevUp.z);
this->m_endBelow = C3Vector(this->m_currPos.x - this->m_currUp.x * this->m_below, this->m_currPos.y - this->m_currUp.y * this->m_below, this->m_currPos.z - this->m_below * this->m_currUp.z);
this->m_startAbove = C3Vector(this->m_above * this->m_prevUp.x + this->m_prevPos.x, this->m_prevUp.y * this->m_above + this->m_prevPos.y, this->m_above * this->m_prevUp.z + this->m_prevPos.z);
this->m_endAbove = C3Vector(this->m_currUp.x * this->m_above + this->m_currPos.x, this->m_currUp.y * this->m_above + this->m_currPos.y, this->m_above * this->m_currUp.z + this->m_currPos.z);
this->m_startTangent = C3Vector(this->m_prevDir.x * distance, this->m_prevDir.y * distance, this->m_prevDir.z * distance);
this->m_endTangent = C3Vector(this->m_currDir.x * distance, this->m_currDir.y * distance, distance * this->m_currDir.z);
}
// VERIFY: 946634b1 manual
// OFFSET: 0x0097F900
void CRibbonEmitter::CloseTextureHandles() {
uint32_t count = this->m_textures.Count();
for (uint32_t i = 0; i < count; i++) {
if (this->m_textures[i]) {
HandleClose(reinterpret_cast<HOBJECT>(this->m_textures[i]));
}
}
}
// VERIFY: 684a7387 manual
// OFFSET: 0x0097F940
void CRibbonEmitter::SetPos(const C44Matrix& transform, const C3Vector& position, const C44Matrix* frameOfReference) {
if (!(this->m_flags & 0x4) || !(this->m_flags & 0x8)) {
return;
}
C44Matrix matrix = transform;
matrix.d0 = position.x + matrix.d0;
matrix.d1 = position.y + matrix.d1;
matrix.d2 = position.z + matrix.d2;
if (frameOfReference) {
matrix *= frameOfReference->AffineInverse();
}
this->m_localPos = position;
if (this->m_flags & 0x1) {
this->m_prevPos = this->m_currPos;
this->m_prevDir = this->m_currDir;
this->m_prevUp = this->m_currUp;
} else {
this->m_prevDir = C3Vector(matrix.c0, matrix.c1, matrix.c2);
this->m_edgeFraction = 0.0f;
this->m_prevUp = C3Vector(matrix.b0, matrix.b1, matrix.b2);
this->m_prevPos = C3Vector(matrix.d0, matrix.d1, matrix.d2);
this->m_flags |= 0x1;
}
this->m_currPos = C3Vector(matrix.d0, matrix.d1, matrix.d2);
this->m_currDir = C3Vector(matrix.c0, matrix.c1, matrix.c2);
this->m_currUp = C3Vector(matrix.b0, matrix.b1, matrix.b2);
}
// VERIFY: 139ccf62 manual
// OFFSET: 0x0097FAD0
int32_t CRibbonEmitter::ReplaceTexture(uint32_t type, CTexture* texture) {
int32_t replaced = 0;
for (uint32_t i = 0; i < this->m_textureTypes.Count(); i++) {
if (this->m_textureTypes[i] == type) {
if (this->m_textures[i]) {
HandleClose(reinterpret_cast<HOBJECT>(this->m_textures[i]));
}
replaced++;
this->m_textures[i] = reinterpret_cast<CTexture*>(HandleDuplicate(reinterpret_cast<HOBJECT>(texture)));
}
}
return replaced;
}
// VERIFY: b358630b auto
// OFFSET: 0x0097FB60
void CRibbonEmitter::SetColor(float r, float g, float b) {
this->m_color.Set(this->m_color.a * 255.0f, r, g, b);
}
// VERIFY: f4dee58f manual
// OFFSET: 0x0097FBA0
void CRibbonEmitter::SetAlpha(float alpha) {
this->m_color.a = static_cast<uint8_t>(static_cast<int32_t>(alpha * 255.0f + 0.5f));
}
// VERIFY: a976a0e7 manual
// OFFSET: 0x0097FBE0
void CRibbonEmitter::ChangeFrameOfReference(const C44Matrix* matrix) {
const C44Matrix& m = *matrix;
this->m_prevPos *= m;
this->m_prevDir = C3Vector(this->m_prevDir.y * m.b0 + this->m_prevDir.z * m.c0 + this->m_prevDir.x * m.a0, m.c1 * this->m_prevDir.z + this->m_prevDir.x * m.a1 + m.b1 * this->m_prevDir.y, this->m_prevDir.y * m.b2 + m.a2 * this->m_prevDir.x + this->m_prevDir.z * m.c2);
this->m_prevUp = C3Vector(this->m_prevUp.y * m.b0 + this->m_prevUp.x * m.a0 + this->m_prevUp.z * m.c0, m.c1 * this->m_prevUp.z + m.b1 * this->m_prevUp.y + this->m_prevUp.x * m.a1, this->m_prevUp.x * m.a2 + this->m_prevUp.z * m.c2 + this->m_prevUp.y * m.b2);
this->m_currPos *= m;
this->m_currDir = C3Vector(this->m_currDir.z * m.c0 + this->m_currDir.y * m.b0 + this->m_currDir.x * m.a0, this->m_currDir.x * m.a1 + m.c1 * this->m_currDir.z + m.b1 * this->m_currDir.y, this->m_currDir.z * m.c2 + this->m_currDir.y * m.b2 + this->m_currDir.x * m.a2);
this->m_currUp = C3Vector(this->m_currUp.x * m.a0 + this->m_currUp.y * m.b0 + this->m_currUp.z * m.c0, this->m_currUp.x * m.a1 + this->m_currUp.z * m.c1 + this->m_currUp.y * m.b1, this->m_currUp.z * m.c2 + this->m_currUp.y * m.b2 + m.a2 * this->m_currUp.x);
for (uint32_t i = 0; i < this->m_vertices.Count(); i++) {
this->m_vertices.m_data[i].p *= m;
}
}
// VERIFY: b79ec970 auto
// OFFSET: 0x0097FE40
uint32_t CRibbonEmitter::GetNumBatches() {
return this->m_materials.Count();
}
// VERIFY: a63fdf92 manual
// OFFSET: 0x0097FE50
uint32_t CRibbonEmitter::GetNumPrimitives() {
if (this->m_readPos >= this->m_writePos) {
return 2 * (this->m_writePos + this->m_edgeAges.Count() - this->m_readPos);
}
return 2 * (this->m_writePos - this->m_readPos);
}
// VERIFY: bcdbf864 manual
// OFFSET: 0x0097FEF0
void CRibbonEmitter::InterpEdge(float age, float t, uint32_t advance) {
CGxVertexPCT* vertex = &this->m_vertices.m_data[2 * this->m_writePos];
float s = 1.0f - t;
vertex[0].p.x = (this->m_endBelow.x - s * this->m_endTangent.x) * t + (this->m_startTangent.x * t + this->m_startBelow.x) * s;
vertex[0].p.y = (this->m_endBelow.y - this->m_endTangent.y * s) * t + (this->m_startBelow.y + this->m_startTangent.y * t) * s;
vertex[0].p.z = (this->m_endBelow.z - s * this->m_endTangent.z) * t + (this->m_startBelow.z + this->m_startTangent.z * t) * s;
vertex[1].p.x = (this->m_endAbove.x - this->m_endTangent.x * s) * t + (t * this->m_startTangent.x + this->m_startAbove.x) * s;
vertex[1].p.y = (this->m_endAbove.y - this->m_endTangent.y * s) * t + (this->m_startTangent.y * t + this->m_startAbove.y) * s;
vertex[1].p.z = s * (t * this->m_startTangent.z + this->m_startAbove.z) + (this->m_endAbove.z - s * this->m_endTangent.z) * t;
this->m_edgeAges.m_data[this->m_writePos] = age;
this->m_writePos += advance;
if (this->m_writePos >= this->m_edgeAges.Count()) {
this->m_writePos -= this->m_edgeAges.Count();
}
}
// VERIFY: b2cbdd07 manual
// OFFSET: 0x00980090
void CRibbonEmitter::Update(float deltaTime, int32_t suppressNewEdges) {
float dt = deltaTime;
float start = 1.0f;
if (!(this->m_flags & 0x10) && this->m_edgesPerSec > 0.0f) {
dt = 1.0f / this->m_edgesPerSec + 0.000099999997f;
}
if (dt < 0.0f) {
dt = 0.0f;
} else if (this->m_edgeLifetime <= dt) {
dt = this->m_edgeLifetime;
}
while (this->m_readPos != this->m_writePos) {
if (this->m_edgeAges.m_data[this->m_readPos] + dt <= this->m_edgeLifetime) {
break;
}
if (++this->m_readPos >= this->m_edgeAges.Count()) {
this->m_readPos -= this->m_edgeAges.Count();
}
}
if (!suppressNewEdges && (this->m_flags & 0x4) && (this->m_flags & 0x8) && (this->m_flags & 0x1)) {
float target = dt * this->m_edgesPerSec + this->m_edgeFraction;
CImVector color = this->m_color;
if (g_theGxDevicePtr->Caps().m_colorFormat == GxCF_rgba) {
color.b = this->m_color.r;
color.g = this->m_color.g;
color.r = this->m_color.b;
color.a = this->m_color.a;
}
this->InitInterpDeltas();
if (target >= 1.0f) {
float scale = 1.0f / (target - this->m_edgeFraction);
int64_t steps = static_cast<int64_t>(floor(target - 1.0f));
for (int32_t count = static_cast<int32_t>(steps) + 1; count; count--) {
float t = (start - this->m_edgeFraction) * scale;
this->m_vertices.m_data[2 * this->m_writePos].c = color;
this->m_vertices.m_data[2 * this->m_writePos + 1].c = color;
this->InterpEdge(-(t * dt), t, 1);
start = start + 1.0f;
}
}
this->m_edgeFraction = target - floor(target);
this->InterpEdge(0.0f, 1.0f, 0);
CGxVertexPCT* vertex = &this->m_vertices.m_data[2 * this->m_writePos];
vertex[0].tc.x = this->m_texSlotCoords.minY;
vertex[0].tc.y = this->m_texSlotCoords.minX;
vertex[1].tc.x = this->m_texSlotCoords.minY;
vertex[1].tc.y = this->m_texSlotCoords.maxX;
vertex[0].c = color;
vertex[1].c = color;
}
this->m_worldBounds.b.x = 3.4028235e38f;
this->m_worldBounds.b.y = 3.4028235e38f;
this->m_worldBounds.b.z = 3.4028235e38f;
this->m_worldBounds.t.x = -3.4028235e38f;
this->m_worldBounds.t.y = -3.4028235e38f;
this->m_worldBounds.t.z = -3.4028235e38f;
for (uint32_t i = this->m_readPos; i != this->m_writePos;) {
CGxVertexPCT* vertex = &this->m_vertices.m_data[2 * i];
float drop = (this->m_edgeAges.m_data[i] * 2.0f + dt) * this->m_gravity * dt;
vertex[0].p.z = vertex[0].p.z + drop;
vertex[1].p.z = drop + vertex[1].p.z;
for (uint32_t j = 0; j < 2; j++) {
const C3Vector& p = vertex[j].p;
if (this->m_worldBounds.b.x > p.x) {
this->m_worldBounds.b.x = p.x;
}
if (this->m_worldBounds.b.y > p.y) {
this->m_worldBounds.b.y = p.y;
}
if (this->m_worldBounds.b.z > p.z) {
this->m_worldBounds.b.z = p.z;
}
if (this->m_worldBounds.t.x < p.x) {
this->m_worldBounds.t.x = p.x;
}
if (this->m_worldBounds.t.y < p.y) {
this->m_worldBounds.t.y = p.y;
}
if (this->m_worldBounds.t.z < p.z) {
this->m_worldBounds.t.z = p.z;
}
}
this->m_edgeAges.m_data[i] = dt + this->m_edgeAges.m_data[i];
float u = this->m_edgeAges.m_data[i] * this->m_texCellU * this->m_invEdgeLifetime + this->m_texSlotCoords.minY;
vertex[0].tc.x = u;
vertex[0].tc.y = this->m_texSlotCoords.minX;
vertex[1].tc.x = u;
vertex[1].tc.y = this->m_texSlotCoords.maxX;
if (++i >= this->m_edgeAges.Count()) {
i -= this->m_edgeAges.Count();
}
}
this->m_flags = (this->m_flags & ~0x30) | 0x10;
}
// VERIFY: 05a5de95 manual
// OFFSET: 0x00980510
static void DuplicateTextures(const TSGrowableArray<CTexture*>& source, TSGrowableArray<CTexture*>& dest) {
uint32_t count = source.m_count;
dest.SetCount(count);
for (uint32_t i = 0; i < count; i++) {
dest.m_data[i] = reinterpret_cast<CTexture*>(HandleDuplicate(reinterpret_cast<HOBJECT>(source.m_data[i])));
}
}
// VERIFY: 6449e9b3 manual
// OFFSET: 0x00980590
CRibbonEmitter::~CRibbonEmitter() {
this->CloseTextureHandles();
this->m_flags &= ~0x2;
}
// VERIFY: 459f4678 auto
// OFFSET: 0x00980630
CRibbonEmitter::CRibbonEmitter() {
this->m_refCount = 1;
this->m_texSlotCoords.minX = 0.0f;
this->m_texSlotCoords.minY = 0.0f;
this->m_texSlotCoords.maxX = 0.0f;
this->m_texSlotCoords.maxY = 0.0f;
this->m_worldBounds.b.x = 3.4028235e38f;
this->m_worldBounds.b.y = 3.4028235e38f;
this->m_worldBounds.b.z = 3.4028235e38f;
this->m_worldBounds.t.x = -3.4028235e38f;
this->m_worldBounds.t.y = -3.4028235e38f;
this->m_worldBounds.t.z = -3.4028235e38f;
this->m_texCoords.minX = 0.0f;
this->m_texCoords.minY = 0.0f;
this->m_texCoords.maxX = 0.0f;
this->m_texCoords.maxY = 0.0f;
this->m_flags &= ~0x12;
}
// VERIFY: 85ed808e manual
// OFFSET: 0x009808A0
void CRibbonEmitter::Initialize(float edgesPerSecond, float edgeLifetime, const CImVector& color, const TSGrowableArray<CTexture*>& textures, const TSGrowableArray<CRibbonMat>& materials, const TSGrowableArray<uint32_t>& textureTypes, const CAaRect& texCoords, uint32_t rows, uint32_t cols) {
float edgesPerSec = ceil(edgesPerSecond);
if (edgeLifetime < 0.25f) {
edgeLifetime = 0.25f;
}
uint32_t edgeCount = static_cast<uint32_t>(ceil(edgesPerSec * edgeLifetime) + 2.0f);
this->m_edgeAges.SetCount(edgeCount);
this->m_flags &= ~0x1;
this->m_edgeFraction = 0.0f;
this->m_readPos = 0;
this->m_writePos = 0;
this->m_vertices.SetCount(2 * edgeCount);
this->m_indices.SetCount(4 * edgeCount);
for (uint32_t i = 0; i < this->m_indices.Count(); i++) {
this->m_indices.m_data[i] = i % (2 * edgeCount);
}
this->m_invEdgeLifetime = 1.0f / edgeLifetime;
this->m_texCellU = (texCoords.maxY - texCoords.minY) / cols;
this->m_texCellV = (texCoords.maxX - texCoords.minX) / rows;
this->m_invTexCellU = 1.0f / this->m_texCellU;
this->m_invTexCellV = 1.0f / this->m_texCellV;
this->m_edgesPerSec = edgesPerSec;
this->m_edgeLifetime = edgeLifetime;
this->m_color = color;
this->m_materials = materials;
DuplicateTextures(textures, this->m_textures);
this->m_textureTypes = textureTypes;
this->m_texCoords = texCoords;
this->m_rows = rows;
this->m_cols = cols;
this->m_texSlot = 0;
this->ConvertTexSlotToTexCoords();
this->m_flags |= 0xE;
this->m_above = 10.0f;
this->m_below = 10.0f;
this->m_gravity = 0.0f;
}
// VERIFY: 6008d884 auto
// OFFSET: 0x00980B50
void CRibbonEmitter::DecRef() {
if (this->m_refCount-- == 1) {
delete this;
}
}
// VERIFY: b28c0986 manual
// OFFSET: 0x00980B70
int32_t CRibbonEmitter::Render(const C44Matrix* frameOfReference) {
if (!s_ribbonRenderEnable || this->m_readPos == this->m_writePos) {
return 0;
}
C44Matrix world;
if (frameOfReference) {
world = *frameOfReference;
}
world.d0 = world.d0 - this->m_localPos.x;
world.d1 = world.d1 - this->m_localPos.y;
world.d2 = world.d2 - this->m_localPos.z;
g_theGxDevicePtr->XformPushAndSet(GxXform_World, world);
CGxBuf* vertexBuf = g_theGxDevicePtr->BufStream(GxPoolTarget_Vertex, sizeof(CGxVertexPCT), this->m_vertices.Count());
CGxBuf* indexBuf = g_theGxDevicePtr->BufStream(GxPoolTarget_Index, sizeof(uint16_t), this->m_indices.Count());
GxBufData(vertexBuf, this->m_vertices.m_data, sizeof(CGxVertexPCT) * this->m_vertices.Count(), 0);
GxPrimVertexPtr(vertexBuf, GxVBF_PCT);
uint32_t indexCount;
if (this->m_readPos >= this->m_writePos) {
indexCount = 2 * (this->m_writePos + this->m_edgeAges.Count() - this->m_readPos) + 2;
} else {
indexCount = 2 * (this->m_writePos - this->m_readPos) + 2;
}
GxBufData(indexBuf, &this->m_indices.m_data[2 * this->m_readPos], sizeof(uint16_t) * indexCount, 0);
g_theGxDevicePtr->PrimIndexPtr(indexBuf);
CGxBatch batch;
batch.m_primType = GxPrim_TriangleStrip;
batch.m_start = 0;
batch.m_count = indexCount;
batch.m_minIndex = 0;
batch.m_maxIndex = this->m_vertices.Count() - 1;
for (uint32_t i = 0; i < this->m_materials.Count(); i++) {
g_theGxDevicePtr->RsPush();
const CRibbonMat& material = this->m_materials.m_data[i];
C4Vector emissive;
if (material.m_lit) {
emissive.x = 0.0f;
emissive.y = 0.0f;
emissive.z = 0.0f;
emissive.w = 0.0f;
} else {
emissive.x = 1.0f;
emissive.y = 1.0f;
emissive.z = 1.0f;
emissive.w = 0.0f;
}
CShaderEffect::SetEmissive(emissive);
CShaderEffect::SetFogEnabled(material.m_fogged);
CShaderEffect::SetLightingEnabled(material.m_lit);
g_theGxDevicePtr->RsSet(GxRs_DepthTest, static_cast<int32_t>(material.m_depthTest));
g_theGxDevicePtr->RsSet(GxRs_DepthWrite, static_cast<int32_t>(material.m_depthWrite));
g_theGxDevicePtr->RsSet(GxRs_Culling, static_cast<int32_t>(material.m_cull));
g_theGxDevicePtr->RsSet(GxRs_BlendingMode, static_cast<int32_t>(material.m_blendMode));
CShaderEffect::SetAlphaRefDefault();
CGxTex* gxTex = TextureGetGxTex(this->m_textures.m_data[i], 0, nullptr);
if (gxTex) {
g_theGxDevicePtr->RsSet(GxRs_Texture0, gxTex);
GxTexSetWrap(gxTex, GxTex_Clamp, GxTex_Clamp);
CShaderEffect::SetDefaultShaders(0);
CShaderEffect::UpdateWorldViewMatrix();
g_theGxDevicePtr->Draw(&batch, 1);
}
g_theGxDevicePtr->RsPop();
}
GxXformPop(GxXform_World);
return 1;
}