Files
SatyandClaude Opus 5.5 34770ee7ab Frame: port Engine/Frame (waves 1-4), 1667 of 1669 functions
Core (CSimpleFrame + Lua, CSimpleTop/CFrameStrata/CSimpleRender/
CRenderBatch, CSimpleRegion/CBackdropGenerator/CScriptRegion), animation,
text (FontString/Font/Fontable), texture and model, buttons, EditBox,
MessageFrame/MessageScrollFrame, MovieFrame/ColorSelect/StatusBar,
Slider/ScrollFrame/HTML/HyperlinkedFrame, all Lua method tables and
RegisterScriptMethods. Layouts, vtables and sizes rebuilt from the
12340 ctors, vtables and allocator initializers; CScriptObject vtable
slots 5/6 fixed; CSimpleFontedFrame is a real secondary base. Lua error
paths return after luaL_error as in 12340 (209 sites; 5 fall through).
Binary quirks kept and documented in docs/.

Supporting additions: Event key/char/ime/focus/size event headers,
Scrn/Scrn.h (ScrnLayerCreate), DivxDecoder import declarations,
C2Vector/CRect helpers, CM2Light dtor, OsInputEnableSecureMode, stpl.h
instance addresses, FrameXML LoadXML_AnimGroup/Create_SimpleMovieFrame.
Engine->WoW includes where 12340 calls directly: CSimpleModelFFX,
StringToMouseButton, GetDeclinedWord, EmblemTextureUpdate.

Also drops stale VERIFY stamps found invalid by the harness recheck.

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

446 lines
14 KiB
C++

#include <cmath>
#include <cstdint>
#include <cstring>
#include "Engine/Source/Model2/M2Light.h"
#include "Engine/Source/Gx/CGxDevice/CGxDevice.h"
#include "Engine/Source/Gx/CGxLight.h"
#include "Engine/Source/Gx/Gx.h"
#include "Engine/Source/Model2/M2Scene.h"
#include "Engine/Source/Storm/H/storm.h"
#include "Engine/Source/Tempest/C44Matrix.h"
#include "Engine/Source/Tempest/CImVector.h"
// STATIC: 0x00AF59D4
static float s_lightGridScale = 0.05f;
// VERIFY: 45311b80 auto
// OFFSET: 0x008348D0
void CM2Light::Initialize(CM2Scene* scene) {
this->m_scene = scene;
this->m_stamp = scene ? scene->m_frameStamp - 1 : 0;
}
// VERIFY: c00e67e1 manual
// OFFSET: 0x00834900
void CM2Lighting::Initialize(CM2Scene* scene, const CAaSphere& sphere) {
memset(this, 0, sizeof(*this));
this->m_scene = scene;
this->m_flags |= 0x20;
this->m_sphere4 = sphere;
}
// VERIFY: 5a29d87b auto
// OFFSET: 0x00834940
void CM2Lighting::SetFog(const C3Vector& color, float start, float end) {
this->m_fogStart = start;
this->m_fogEnd = end;
this->m_fogScale = 1.0f / (end - start);
this->m_fogDensity = 1.0f;
this->m_fogColor = color;
}
// VERIFY: 23d655f9 auto
// OFFSET: 0x00834990
void CM2Lighting::SetFog(const C3Vector& color, float start, float end, float density) {
this->m_fogStart = start;
this->m_fogEnd = end;
this->m_fogScale = 1.0f / (end - start);
this->m_fogDensity = density;
this->m_fogColor = color;
}
// VERIFY: 90fc1f85 auto
// OFFSET: 0x008349E0
int32_t CM2Lighting::GetPointLight(uint32_t index, C3Vector& pos, C3Vector& color, C3Vector& attenuation) {
if (index >= this->m_lightCount) {
return 0;
}
CM2Light* light = this->m_lights[index];
pos = light->m_pos;
color = light->m_dirColor;
attenuation.x = light->m_constantAttenuation;
attenuation.y = light->m_linearAttenuation;
attenuation.z = light->m_quadraticAttenuation;
return 1;
}
// VERIFY: a0e7de7f auto
// OFFSET: 0x00834A40
CM2Light::CM2Light() {
this->m_scene = nullptr;
this->m_stamp = 0;
this->m_type = M2LIGHT_POINT;
this->m_constantAttenuation = 0.0f;
this->m_linearAttenuation = 0.7f;
this->m_quadraticAttenuation = 0.03f;
this->m_visible = 0;
this->m_lightPrev = nullptr;
this->m_lightNext = nullptr;
}
// INLINED
CM2Light::~CM2Light() {
this->Unlink();
}
// VERIFY: 42088760 manual
// OFFSET: 0x00834AB0
void CM2Light::Unlink() {
if (this->m_lightPrev) {
*this->m_lightPrev = this->m_lightNext;
}
if (this->m_lightNext) {
this->m_lightNext->m_lightPrev = this->m_lightPrev;
}
this->m_lightNext = nullptr;
this->m_lightPrev = nullptr;
}
// VERIFY: cc997e91 manual
// OFFSET: 0x00834AE0
void CM2Light::SetDirection(const C3Vector& dir) {
this->m_dir = dir;
this->m_dir.NormalizeSafe();
}
// VERIFY: 4eab0c16 manual
// OFFSET: 0x00834B50
void CM2Light::GxLightSet(uint32_t index) {
CGxLight light;
light.m_flags = (light.m_flags & ~1u) | (this->m_visible & 1);
if (this->m_type == M2LIGHT_DIRECT) {
light.m_flags &= ~2u;
light.m_dir = this->m_dir;
light.m_ambientColor = this->m_ambColor;
light.m_specularColor = this->m_specColor;
} else {
light.m_flags |= 2;
light.m_dir = this->m_pos;
light.m_ambientColor = C3Vector();
light.m_specularColor = C3Vector();
}
light.m_dirColor = this->m_dirColor;
light.m_constantAttenuation = this->m_constantAttenuation;
light.m_linearAttenuation = this->m_linearAttenuation;
light.m_quadraticAttenuation = this->m_quadraticAttenuation;
g_theGxDevicePtr->LightSet(index, light, C3Vector());
g_theGxDevicePtr->LightEnable(index, 1);
}
// VERIFY: a73679ed manual
// OFFSET: 0x00834C70
void CM2Light::Link() {
if (!this->m_visible || !this->m_scene) {
return;
}
if (this->m_type == M2LIGHT_POINT) {
if (!this->m_scene->m_lightGrid) {
this->m_scene->m_lightGrid = static_cast<CM2Light**>(SMemAlloc(sizeof(CM2Light*) * 64 * 64, __FILE__, __LINE__, 0));
memset(this->m_scene->m_lightGrid, 0, sizeof(CM2Light*) * 64 * 64);
}
int32_t y = static_cast<int32_t>(floor(this->m_pos.y * s_lightGridScale)) & 63;
int32_t x = static_cast<int32_t>(floor(this->m_pos.x * s_lightGridScale)) & 63;
CM2Light** head = &this->m_scene->m_lightGrid[y * 64 + x];
this->m_lightPrev = head;
this->m_lightNext = *head;
*this->m_lightPrev = this;
if (this->m_lightNext) {
this->m_lightNext->m_lightPrev = &this->m_lightNext;
}
} else if (!(this->m_scene->m_flags & 1)) {
CM2Light** head = &this->m_scene->m_lightList;
this->m_lightPrev = head;
this->m_lightNext = *head;
*head = this;
if (this->m_lightNext) {
this->m_lightNext->m_lightPrev = &this->m_lightNext;
}
}
}
// VERIFY: bb2e385b manual
// OFFSET: 0x00834D90
void CM2Lighting::AddAmbient(const C3Vector& color) {
this->m_sunAmbient += color;
}
// VERIFY: b0a37a1c manual
// OFFSET: 0x00834DC0
void CM2Lighting::AddDiffuse(const C3Vector& color, const C3Vector& dir) {
C3Vector viewDir = dir;
if (this->m_scene) {
const C44Matrix& view = this->m_scene->m_view;
viewDir.x = view.b0 * dir.y + view.c0 * dir.z + dir.x * view.a0;
viewDir.y = view.b1 * dir.y + view.a1 * dir.x + view.c1 * dir.z;
viewDir.z = view.b2 * dir.y + view.a2 * dir.x + view.c2 * dir.z;
}
this->m_vector18.x = viewDir.x * color.x + this->m_vector18.x;
this->m_vector18.y = viewDir.y * color.x + this->m_vector18.y;
this->m_vector18.z = color.x * viewDir.z + this->m_vector18.z;
this->m_vector24.x = viewDir.x * color.y + this->m_vector24.x;
this->m_vector24.y = viewDir.y * color.y + this->m_vector24.y;
this->m_vector24.z = color.y * viewDir.z + this->m_vector24.z;
this->m_vector30.x = color.z * viewDir.x + this->m_vector30.x;
this->m_vector30.y = viewDir.y * color.z + this->m_vector30.y;
this->m_vector30.z = color.z * viewDir.z + this->m_vector30.z;
float luminance = color.y * 0.71516f + color.x * 0.212671f + color.z * 0.072169f;
this->m_vector3C.x = viewDir.x * luminance + this->m_vector3C.x;
this->m_vector3C.y = viewDir.y * luminance + this->m_vector3C.y;
this->m_vector3C.z = viewDir.z * luminance + this->m_vector3C.z;
this->m_vector48 += color;
this->m_sunDir = dir;
this->m_sunDiffuse = color;
}
// VERIFY: 7d1db3b8 manual
// OFFSET: 0x00834F60
void CM2Lighting::AddLight(CM2Light* light) {
if (!light->m_visible) {
return;
}
if (light->m_type != M2LIGHT_POINT) {
this->AddAmbient(light->m_ambColor);
this->AddDiffuse(light->m_dirColor, light->m_dir);
this->m_sunSpecular += light->m_specColor;
return;
}
float dz = light->m_pos.z - this->m_sphere4.c.z;
float dy = light->m_pos.y - this->m_sphere4.c.y;
float dx = light->m_pos.x - this->m_sphere4.c.x;
float dist = dx * dx + (dy * dy + dz * dz);
uint32_t count = this->m_lightCount;
const uint32_t capacity = sizeof(this->m_lights) / sizeof(this->m_lights[0]);
if (count >= capacity) {
if (dist >= this->m_lightDist[capacity - 1]) {
return;
}
count--;
}
for (; count && dist <= this->m_lightDist[count - 1]; count--) {
this->m_lights[count] = this->m_lights[count - 1];
this->m_lightDist[count] = this->m_lightDist[count - 1];
}
this->m_lightDist[count] = dist;
this->m_lights[count] = light;
if (this->m_lightCount < capacity) {
this->m_lightCount++;
}
}
// VERIFY: 58f9ffa3 manual
// OFFSET: 0x008350A0
void CM2Lighting::CameraSpace() {
if (this->m_flags & 1) {
return;
}
if (this->m_scene) {
for (uint32_t i = 0; i < this->m_lightCount; i++) {
this->m_lights[i]->m_viewPos = this->m_lights[i]->m_pos * this->m_scene->m_view;
}
if ((this->m_flags & 0x60) == 0x60) {
float d = -this->m_liquidPlane.d;
C3Vector point(d * this->m_liquidPlane.n.x, this->m_liquidPlane.n.y * d, d * this->m_liquidPlane.n.z);
const C44Matrix& view = this->m_scene->m_view;
C3Vector normal;
normal.x = view.c0 * this->m_liquidPlane.n.z + view.b0 * this->m_liquidPlane.n.y + this->m_liquidPlane.n.x * view.a0;
normal.y = view.a1 * this->m_liquidPlane.n.x + view.c1 * this->m_liquidPlane.n.z + view.b1 * this->m_liquidPlane.n.y;
normal.z = view.a2 * this->m_liquidPlane.n.x + view.c2 * this->m_liquidPlane.n.z + view.b2 * this->m_liquidPlane.n.y;
this->m_liquidPlane.n = normal;
this->m_liquidPlane.n.NormalizeSafe();
C3Vector viewPoint = point * this->m_scene->m_view;
this->m_liquidPlane.d = -(viewPoint.z * this->m_liquidPlane.n.z + viewPoint.y * this->m_liquidPlane.n.y + this->m_liquidPlane.n.x * viewPoint.x);
}
}
this->m_flags |= 1;
}
// VERIFY: 0203843d manual
// OFFSET: 0x00835280
void CM2Lighting::SetupSunlight() {
if (this->m_flags & 2) {
return;
}
this->m_sunDir = this->m_vector3C;
if (this->m_sunDir.z * this->m_sunDir.z + this->m_sunDir.y * this->m_sunDir.y + this->m_sunDir.x * this->m_sunDir.x <= 0.00001f) {
this->m_sunDir = C3Vector(0.0f, 0.0f, -1.0f);
} else {
this->m_sunDir.NormalizeSafe();
}
float red = this->m_sunDir.z * this->m_vector18.z + this->m_sunDir.y * this->m_vector18.y + this->m_sunDir.x * this->m_vector18.x;
float green = this->m_sunDir.z * this->m_vector24.z + this->m_sunDir.y * this->m_vector24.y + this->m_sunDir.x * this->m_vector24.x;
float blue = this->m_vector30.z * this->m_sunDir.z + this->m_vector30.y * this->m_sunDir.y + this->m_vector30.x * this->m_sunDir.x;
this->m_sunDiffuse = C3Vector(red * 1.25f - this->m_vector48.x * 0.25f, green * 1.25f - this->m_vector48.y * 0.25f, 1.25f * blue - this->m_vector48.z * 0.25f);
this->m_sunAmbient += C3Vector((this->m_vector48.x - red) * 0.25f, (this->m_vector48.y - green) * 0.25f, (this->m_vector48.z - blue) * 0.25f);
this->m_flags |= 2;
}
// VERIFY: 52fc9b8b manual
// OFFSET: 0x008353D0
void CM2Lighting::SetupGxLights(const C3Vector* origin) {
CGxLight light;
light.m_flags |= 1;
this->SetupSunlight();
light.m_flags &= ~2u;
light.m_dir = this->m_sunDir;
light.m_ambientColor = this->m_sunAmbient;
light.m_dirColor = this->m_sunDiffuse;
light.m_specularColor = this->m_sunSpecular;
g_theGxDevicePtr->LightSet(0, light, C3Vector());
g_theGxDevicePtr->LightEnable(0, 1);
light.m_flags |= 2;
light.m_ambientColor = C3Vector();
light.m_specularColor = C3Vector();
uint32_t index = 1;
for (uint32_t i = this->m_lightCount; i > 0 && index < 4; i--) {
CM2Light* point = this->m_lights[i - 1];
if (origin) {
light.m_dir = point->m_pos - *origin;
} else {
light.m_dir = point->m_viewPos;
}
light.m_dirColor = point->m_dirColor;
light.m_constantAttenuation = point->m_constantAttenuation;
light.m_linearAttenuation = point->m_linearAttenuation;
light.m_quadraticAttenuation = point->m_quadraticAttenuation;
g_theGxDevicePtr->LightSet(index, light, C3Vector());
g_theGxDevicePtr->LightEnable(index, 1);
index++;
}
for (; index < 4; index++) {
g_theGxDevicePtr->LightEnable(index, 0);
}
}
// VERIFY: c72eeeeb auto
// OFFSET: 0x008355D0
int32_t CM2Lighting::GetSunLight(C3Vector& dir, C3Vector& ambient, C3Vector& diffuse, C3Vector& specular) {
this->SetupSunlight();
dir = this->m_sunDir;
ambient = this->m_sunAmbient;
diffuse = this->m_sunDiffuse;
specular = this->m_sunSpecular;
return 1;
}
// VERIFY: 0a2d28ed manual
// OFFSET: 0x00835640
void CM2Light::SetLightType(M2LIGHTTYPE type) {
if (this->m_type == type) {
return;
}
this->m_type = type;
if (this->m_visible && this->m_scene) {
this->Unlink();
this->Link();
}
}
// VERIFY: 1b918590 manual
// OFFSET: 0x00835690
void CM2Light::SetPosition(const C3Vector& pos) {
this->m_pos = pos;
if (this->m_visible && this->m_scene && this->m_type == M2LIGHT_POINT) {
this->Unlink();
this->Link();
}
}
// VERIFY: 33e205ca auto
// OFFSET: 0x008356F0
void CM2Light::SetVisible(int32_t visible) {
if (!this->m_visible == !visible) {
return;
}
this->m_visible = visible;
if (!this->m_scene) {
return;
}
if (visible) {
this->Link();
} else {
this->Unlink();
}
}
// VERIFY: 530853de manual
// OFFSET: 0x00835750
void CM2Lighting::SetupGxFog() {
if (fabs(this->m_fogScale) < 0.00000023841858f) {
GxRsSet(GxRs_Fog, 0);
return;
}
if (!g_theGxDevicePtr->Caps().m_shaderTargets[0]) {
GxRsSet(GxRs_FogStart, this->m_fogStart);
GxRsSet(GxRs_FogEnd, this->m_fogEnd);
}
float blue = this->m_fogColor.z > 0.0f ? (this->m_fogColor.z < 1.0f ? this->m_fogColor.z * 255.0f + 0.5f : 255.0f) : 0.0f;
float green = this->m_fogColor.y > 0.0f ? (this->m_fogColor.y < 1.0f ? this->m_fogColor.y * 255.0f + 0.5f : 255.0f) : 0.0f;
float red = this->m_fogColor.x > 0.0f ? (this->m_fogColor.x < 1.0f ? this->m_fogColor.x * 255.0f + 0.5f : 255.0f) : 0.0f;
CImVector color;
color.b = static_cast<uint8_t>(blue);
color.a = 0xFF;
color.g = static_cast<uint8_t>(green);
color.r = static_cast<uint8_t>(red);
GxRsSet(GxRs_FogColor, *reinterpret_cast<int32_t*>(&color));
GxRsSet(GxRs_Fog, 1);
}