Files
wowdecomp/WoW/Source/Game/GameClient/FFXEffects.cpp
T
SatyandClaude Opus 5.5 96e42b7e30 Port Wow link blockers (group 5): taint log, CMap load progress/hit debug, Rain SW, WowConnection accept, spell trajectory
- Taint logging (TaintEventCallback, GetTaintContext, PrintTaintEvent), real TAINTEVENT layout
- CMap::ComputeMapObjLoadProgress/ComputeDoodadLoadProgress, SetHitTestDebug + World::HitTestDebug
- CMapRenderChunk::RenderSinglePass, Rain SW patter/drop render
- WowConnection::CheckAccept + accepted-socket ctor
- Spell_C missile trajectory prepare/visuals, dest-loc visuals without caster
- SendPendingCast passes TSStackArray<CGUnit_C*> targets like the binary
- Russian declension, survey data, GameTimeSync, mirror timer, guild roster save, spellbook prefetch, small drift fixes

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

869 lines
31 KiB
C++

#include "FFXEffects.h"
#include "Engine/Source/ConsoleBase/ConsoleVar.h"
#include "Engine/Source/FFX/PassBox4.h"
#include "Engine/Source/FFX/PassGauss4.h"
#include "Engine/Source/Gx/CGxDevice/CGxDevice.h"
#include "Engine/Source/Gx/CGxPool.h"
#include "Engine/Source/Gx/CGxBuf.h"
#include "Engine/Source/Storm/H/storm.h"
#include "WoW/Source/Game/GameClient/PassDeath.h"
#include "WoW/Source/Game/GameClient/PassNetherBlur.h"
#include <cmath>
#include <cstring>
#include "Engine/Source/Gx/Gx.h"
#include "Engine/Source/Services/Texture.h"
#include "Engine/Source/Tempest/CiRect.h"
#include "Engine/Source/Tempest/CRandom.h"
#include "Engine/Source/Tempest/NTempest.h"
#include "WoW/Source/Game/GameClient/PassFogSeed.h"
#include "WoW/Source/Game/GameClient/PassPropagateFog.h"
#include "WoW/Source/Game/GameClient/PassFogCombine.h"
#include "WoW/Source/WorldClient/FrameTime.h"
#include "Engine/Source/Tempest/C44Matrix.h"
#include "Engine/Source/Tempest/CMath.h"
#include "WoW/Source/WorldClient/DayNight__DNInfo.h"
// STATIC: 0x00D38140
static uint32_t* s_seedTexels;
// VERIFY: 34ad1008 auto
// OFFSET: [0x007E82A0, 0x007E9640]
PassFogCombine::~PassFogCombine() {
for (uint32_t i = 0; i < sizeof(this->m_pixelShaders) / sizeof(this->m_pixelShaders[0]); i++) {
if (this->m_pixelShaders[i]) {
g_theGxDevicePtr->ShaderDestroy(this->m_pixelShaders[i]);
}
}
CGxBuf* vertexBuf = this->m_vertexBuf;
if (vertexBuf && vertexBuf != g_theGxDevicePtr->BufStream(vertexBuf->m_pool->m_target, 0, 0)) {
g_theGxDevicePtr->BufDestroy(vertexBuf);
}
CGxBuf* indexBuf = this->m_indexBuf;
if (indexBuf && indexBuf != g_theGxDevicePtr->BufStream(indexBuf->m_pool->m_target, 0, 0)) {
g_theGxDevicePtr->BufDestroy(indexBuf);
}
if (this->m_vertexPool) {
g_theGxDevicePtr->PoolDestroy(this->m_vertexPool);
}
if (this->m_indexPool) {
g_theGxDevicePtr->PoolDestroy(this->m_indexPool);
}
}
// VERIFY: 874a5f41 manual
// OFFSET: 0x007E86A0
PassDeath::PassDeath(FFX::Tex** inputs, uint32_t count, FFX::Tex* output, EGxBlend blend, bool unk) : FFX::Pass(inputs, count, output, blend, unk) {
this->m_useRect = 0;
this->m_shaders[0] = nullptr;
this->m_shaders[1] = nullptr;
if (g_theGxDevicePtr->Caps().m_shaderTargets[GxSh_Pixel] == 8 || g_theGxDevicePtr->Caps().m_shaderTargets[GxSh_Pixel] == 9 || g_theGxDevicePtr->Caps().m_shaderTargets[GxSh_Pixel] == 10) {
g_theGxDevicePtr->ShaderCreate(this->m_shaders, GxSh_Pixel, "Shaders\\Pixel", FFX::s_useRECT ? "FFXDeath_nvts_rect" : "FFXDeath_nvts_2d", 1);
return;
}
if (FFX::s_useRECT) {
this->m_useRect = 1;
}
g_theGxDevicePtr->ShaderCreate(this->m_shaders, GxSh_Pixel, "Shaders\\Pixel", "FFXDeath", 2);
}
// VERIFY: 5970ea32 manual
// OFFSET: [0x007E8770, 0x007E9920]
PassDeath::~PassDeath() {
for (uint32_t i = 0; i < sizeof(this->m_shaders) / sizeof(this->m_shaders[0]); i++) {
if (this->m_shaders[i]) {
g_theGxDevicePtr->ShaderDestroy(this->m_shaders[i]);
}
}
}
// VERIFY: e2aee2fe auto
// OFFSET: 0x007E8920
PassDeathNVRC::PassDeathNVRC(FFX::Tex** inputs, uint32_t count, FFX::Tex* output, EGxBlend blend, bool unk) : FFX::Pass(inputs, count, output, blend, unk) {
g_theGxDevicePtr->ShaderCreate(&this->m_shader, GxSh_Pixel, "Shaders\\Pixel", "FFXDeath_nvrc", 1);
}
// VERIFY: b3213b19 manual
// OFFSET: 0x007E9950
PassDeathNVRC::~PassDeathNVRC() {
if (this->m_shader) {
g_theGxDevicePtr->ShaderDestroy(this->m_shader);
}
}
// VERIFY: 7ab3fdf0 manual
// OFFSET: 0x007E8970
bool PassDeathNVRC::Valid() {
return this->m_shader && this->m_shader->Valid();
}
// VERIFY: 45689fc4 manual
// OFFSET: 0x007E99A0
void PassDeathNVRC::Execute() {
FFX::SetupGx(this->m_output);
FFX::SetupGeo_Quad(this->m_output->m_size, this->m_inputs[0]->m_size, this->m_inputs[0]->m_texSize, FFX::s_gridPos, FFX::s_gridTex, this->unk_002C);
CImVector color;
color.b = 0xA8;
color.g = 0x93;
color.r = 0x53;
color.a = 0xFF;
GxPrimVertexPtr(4, FFX::s_gridPos, sizeof(C3Vector), nullptr, 0, &color, 0, FFX::s_gridTex, sizeof(C2Vector), nullptr, 0);
GxPrimIndexPtr(4, FFX::s_quadIndices);
g_theGxDevicePtr->RsSet(GxRs_Texture0, TextureGetGxTex(this->m_inputs[0]->m_texture, 1, nullptr));
g_theGxDevicePtr->RsSet(GxRs_PixelShader, this->m_shader);
GxRsSet(GxRs_BlendingMode, this->m_blend);
GxUpdateAlphaRef(GxRs_AlphaRef);
g_theGxDevicePtr->Draw(&FFX::s_quadBatch, 1);
FFX::SetupReset();
}
// VERIFY: 22ef7cce manual
// OFFSET: 0x007EA260
EffectDeath::EffectDeath() {
this->m_cvar = CVar::Register("ffxDeath", "full screen death effect", 1, this->m_defaultEnabled ? "1" : "0", FFX::CVarCallback, 1, false, nullptr, false);
if (g_theGxDevicePtr->Caps().m_shaderTargets[GxSh_Pixel] == 7) {
FFX::Tex* inputs[] = { &FFX::s_full[0] };
FFX::Pass* pass = new (__FILE__, __LINE__) PassDeathNVRC(inputs, 1, &FFX::s_screen, GxBlend_Opaque, true);
this->m_passes.New(pass);
return;
}
if (g_theGxDevicePtr->Caps().m_shaderTargets[GxSh_Pixel] <= 0) {
return;
}
FFX::Tex* deathInputs[] = { &FFX::s_full[0], &FFX::s_quart[0] };
FFX::Tex* quartInputs[] = { &FFX::s_quart[0] };
FFX::Pass* pass = new (__FILE__, __LINE__) PassBox4(deathInputs, 1, &FFX::s_quart[0], GxBlend_Opaque, false);
this->m_passes.New(pass);
pass = new (__FILE__, __LINE__) PassGauss4(quartInputs, 1, &FFX::s_quart[0], GxBlend_Opaque, false);
this->m_passes.New(pass);
pass = new (__FILE__, __LINE__) PassDeath(deathInputs, 2, &FFX::s_screen, GxBlend_Opaque, true);
this->m_passes.New(pass);
}
// VERIFY: be1ec9ba manual
// OFFSET: [0x007EA420, 0x007EA920]
EffectDeath::~EffectDeath() {
for (uint32_t i = 0; i < this->m_passes.Count(); i++) {
if (this->m_passes[i]) {
delete this->m_passes[i];
}
}
}
// VERIFY: c9c9b096 manual
// OFFSET: 0x007EA470
EffectNetherWorld::EffectNetherWorld() {
this->m_cvar = CVar::Register("ffxNetherWorld", "full screen nether world effect (for invisibility)", 1, "1", FFX::CVarCallback, 1, false, nullptr, false);
if (g_theGxDevicePtr->Caps().m_shaderTargets[GxSh_Pixel] == 7 || g_theGxDevicePtr->Caps().m_shaderTargets[GxSh_Pixel] <= 0) {
return;
}
FFX::Tex* inputs[] = { &FFX::s_full[0], &FFX::s_quart[0] };
FFX::Pass* pass = new (__FILE__, __LINE__) PassNetherBlur(inputs, 1, inputs[1], GxBlend_Opaque, false);
this->m_passes.New(pass);
pass = new (__FILE__, __LINE__) PassNetherCombine(inputs, 2, &FFX::s_screen, GxBlend_Opaque, true);
this->m_passes.New(pass);
}
// VERIFY: 0058ee1b manual
// OFFSET: 0x007E80B0
PassPropagateFog::PassPropagateFog(FFX::Tex** inputs, uint32_t count, FFX::Tex* output, const C2Vector* params, EGxBlend blend, bool unk) : FFX::Pass(inputs, count, output, blend, unk) {
this->unk_005C = 0.0f;
this->m_useRect = FFX::s_useRECT != 0;
memcpy(this->m_params, params, sizeof(this->m_params));
g_theGxDevicePtr->ShaderCreate(this->m_pixelShaders, GxSh_Pixel, "Shaders\\Pixel", "FFXPropagateFog", 2);
}
// VERIFY: be1f217d manual
// OFFSET: [0x007E8140, 0x007E9050]
PassPropagateFog::~PassPropagateFog() {
for (uint32_t i = 0; i < sizeof(this->m_pixelShaders) / sizeof(this->m_pixelShaders[0]); i++) {
if (this->m_pixelShaders[i]) {
g_theGxDevicePtr->ShaderDestroy(this->m_pixelShaders[i]);
}
}
}
// VERIFY: 06969c1d auto
// OFFSET: 0x007E81B0
PassFogCombine::PassFogCombine(FFX::Tex** inputs, uint32_t count, FFX::Tex* output, EGxBlend blend, bool unk) : FFX::Pass(inputs, count, output, blend, unk) {
this->unk_004C = 0;
this->unk_0050 = 0;
this->unk_0054 = 0.0f;
this->unk_0058 = 0.0f;
this->m_vertexPool = g_theGxDevicePtr->PoolCreate(GxPoolTarget_Vertex, GxPoolUsage_Static, 34848, GxPoolHintBit_Unk0, nullptr);
this->m_indexPool = g_theGxDevicePtr->PoolCreate(GxPoolTarget_Index, GxPoolUsage_Static, 12288, GxPoolHintBit_Unk0, nullptr);
this->m_vertexBuf = g_theGxDevicePtr->BufCreate(this->m_vertexPool, 32, 1089, 0);
this->m_indexBuf = g_theGxDevicePtr->BufCreate(this->m_indexPool, 2, 6144, 0);
this->m_useRect = FFX::s_useRECT != 0;
g_theGxDevicePtr->ShaderCreate(this->m_pixelShaders, GxSh_Pixel, "Shaders\\Pixel", "FFXFogCombine", 2);
}
// VERIFY: b495395e manual
// OFFSET: 0x007E8990
PassNetherBlur::PassNetherBlur(FFX::Tex** inputs, uint32_t count, FFX::Tex* output, EGxBlend blend, bool unk) : FFX::Pass(inputs, count, output, blend, unk) {
this->m_seed.SetSeed(0);
this->m_useRect = 0;
if (FFX::s_useRECT) {
this->m_useRect = 1;
}
g_theGxDevicePtr->ShaderCreate(this->m_pixelShaders, GxSh_Pixel, "Shaders\\Pixel", "FFXNetherBlur", 2);
g_theGxDevicePtr->ShaderCreate(&this->m_vertexShader, GxSh_Vertex, "Shaders\\Vertex", "FFXNetherBlur", 1);
this->m_seed.SetSeed(0xABCDEF01);
for (uint32_t table = 0; table < 3; table++) {
for (uint32_t i = 0; i < 36; i++) {
float value = CRandom::ufloat_(this->m_seed);
this->m_noise[table][i] = fmodf(value + value - 1.0f, 1.0f);
}
}
this->m_noiseTables[0] = this->m_noise[0];
this->unk_0280 = 0.0f;
this->m_noiseTables[1] = this->m_noise[1];
this->m_noiseTables[2] = this->m_noise[2];
}
// VERIFY: 32e95e2f auto
// OFFSET: [0x007E8B30, 0x007E9AE0]
PassNetherBlur::~PassNetherBlur() {
for (uint32_t i = 0; i < sizeof(this->m_pixelShaders) / sizeof(this->m_pixelShaders[0]); i++) {
if (this->m_pixelShaders[i]) {
g_theGxDevicePtr->ShaderDestroy(this->m_pixelShaders[i]);
}
}
if (this->m_vertexShader) {
g_theGxDevicePtr->ShaderDestroy(this->m_vertexShader);
}
}
// VERIFY: 8f3d2550 auto
// OFFSET: 0x007E8B90
bool PassNetherBlur::Valid() {
if (this->m_vertexShader && this->m_vertexShader->Valid()) {
CGxShader* shader = this->m_pixelShaders[this->m_useRect];
if (shader && shader->Valid()) {
return true;
}
}
return false;
}
// VERIFY: 0c5ddefb auto
// OFFSET: 0x007E8BD0
PassNetherCombine::PassNetherCombine(FFX::Tex** inputs, uint32_t count, FFX::Tex* output, EGxBlend blend, bool unk) : FFX::Pass(inputs, count, output, blend, unk) {
this->m_useRect = 0;
if (FFX::s_useRECT) {
this->m_useRect = 1;
}
g_theGxDevicePtr->ShaderCreate(this->m_pixelShaders, GxSh_Pixel, "Shaders\\Pixel", "FFXNetherCombine", 2);
this->unk_003C = 0.0f;
}
// VERIFY: e5b4d009 manual
// OFFSET: [0x007E8C40, 0x007EA190]
PassNetherCombine::~PassNetherCombine() {
for (uint32_t i = 0; i < sizeof(this->m_pixelShaders) / sizeof(this->m_pixelShaders[0]); i++) {
if (this->m_pixelShaders[i]) {
g_theGxDevicePtr->ShaderDestroy(this->m_pixelShaders[i]);
}
}
}
// VERIFY: 2a01a46e manual
// OFFSET: 0x007E8E40
static void SeedTextureCallback(EGxTexCommand command, uint32_t width, uint32_t height, uint32_t depth, uint32_t mipLevel, void* userArg, uint32_t& texelStrideInBytes, const void*& texels) {
static float s_scaleX = 64.0f / width;
static float s_scaleY = 64.0f / height;
if (command == GxTex_Lock) {
s_seedTexels = static_cast<uint32_t*>(SMemAlloc(4 * height * width, __FILE__, __LINE__, 0));
for (uint32_t y = 0; y < height; y++) {
float fy = y * s_scaleY;
uint8_t* texel = reinterpret_cast<uint8_t*>(s_seedTexels) + 4 * width * y;
for (uint32_t x = 0; x < width; x++) {
float noise = PerlinNoise2D(x * s_scaleX, fy, 5);
texel[2] = 0xFF;
texel[1] = 0xFF;
texel[0] = 0xFF;
texel[3] = static_cast<uint8_t>((noise + 3.0f) * 0.25f * 255.0f + 0.5f);
texel += 4;
}
}
} else if (command == GxTex_Latch) {
texels = s_seedTexels;
texelStrideInBytes = 4 * width;
} else if (command == GxTex_Unlock) {
SMemFree(s_seedTexels, __FILE__, __LINE__, 0);
s_seedTexels = nullptr;
}
}
// VERIFY: dc51e0d5 manual
// OFFSET: 0x007EA5F0
EffectSwirlingFog::EffectSwirlingFog() {
this->m_fogTex.m_texture = nullptr;
this->m_fogTex.m_texSize.x = 0;
this->m_fogTex.m_texSize.y = 0;
this->m_fogTex.m_size.x = 0;
this->m_fogTex.m_size.y = 0;
this->m_seedTex.m_texture = nullptr;
this->m_seedTex.m_texSize.x = 0;
this->m_seedTex.m_texSize.y = 0;
this->m_seedTex.m_size.x = 0;
this->m_seedTex.m_size.y = 0;
C2iVector seedSize;
seedSize.x = 256;
seedSize.y = 256;
C2iVector fogSize;
fogSize.x = 256;
fogSize.y = 128;
FFX::CreateTex(this->m_seedTex, seedSize, false, false);
FFX::CreateTex(this->m_fogTex, fogSize, false, true);
TextureSetUserData(this->m_seedTex.m_texture, SeedTextureCallback, nullptr);
CiRect rect;
rect.minY = 0;
rect.minX = 0;
rect.maxY = 0;
rect.maxX = 0;
GxTexUpdate(TextureGetGxTex(this->m_seedTex.m_texture, 1, nullptr), rect, 1);
this->m_cvar = CVar::Register("ffxSpecial", "full screen test effect", 1, this->m_defaultEnabled ? "1" : "0", FFX::CVarCallback, 1, false, nullptr, false);
static C2Vector s_propagateParams[4] = {
C2Vector(-1.0f, 1.0f),
C2Vector(0.0f, 1.0f),
C2Vector(1.0f, 1.0f),
C2Vector(0.0f, 2.0f),
};
FFX::Tex* seedInputs[] = { &this->m_seedTex, &FFX::s_full[0] };
FFX::Tex* fogInputs[] = { &this->m_fogTex, &FFX::s_full[0] };
FFX::Pass* pass = new (__FILE__, __LINE__) PassFogSeed(seedInputs, 1, &this->m_fogTex, GxBlend_Opaque, false);
this->m_passes.New(pass);
pass = new (__FILE__, __LINE__) PassPropagateFog(fogInputs, 1, &this->m_fogTex, s_propagateParams, GxBlend_Opaque, false);
this->m_passes.New(pass);
pass = new (__FILE__, __LINE__) PassFogCombine(fogInputs, 2, &FFX::s_screen, GxBlend_Opaque, true);
this->m_passes.New(pass);
}
// VERIFY: 07dd5136 manual
// OFFSET: [0x007EA5A0, 0x007EA950]
EffectNetherWorld::~EffectNetherWorld() {
for (uint32_t i = 0; i < this->m_passes.Count(); i++) {
if (this->m_passes[i]) {
delete this->m_passes[i];
}
}
}
// VERIFY: 08c57bfc manual
// OFFSET: [0x007EA850, 0x007EA980]
EffectSwirlingFog::~EffectSwirlingFog() {
for (uint32_t i = 0; i < this->m_passes.Count(); i++) {
if (this->m_passes[i]) {
delete this->m_passes[i];
}
}
if (this->m_fogTex.m_texture) {
HandleClose(reinterpret_cast<HOBJECT>(this->m_fogTex.m_texture));
}
this->m_fogTex.m_texture = nullptr;
this->m_fogTex.m_texSize.x = 0;
this->m_fogTex.m_texSize.y = 0;
this->m_fogTex.m_size.x = 0;
this->m_fogTex.m_size.y = 0;
this->m_fogTex.m_texelSize.x = 0.0f;
this->m_fogTex.m_texelSize.y = 0.0f;
if (this->m_seedTex.m_texture) {
HandleClose(reinterpret_cast<HOBJECT>(this->m_seedTex.m_texture));
}
this->m_seedTex.m_texture = nullptr;
this->m_seedTex.m_texSize.x = 0;
this->m_seedTex.m_texSize.y = 0;
this->m_seedTex.m_size.x = 0;
this->m_seedTex.m_size.y = 0;
this->m_seedTex.m_texelSize.x = 0.0f;
this->m_seedTex.m_texelSize.y = 0.0f;
}
// STATIC: 0x00D38150
static float s_netherBlurPhase;
// VERIFY: 487db931 manual
// OFFSET: 0x007E9B10
void PassNetherBlur::Execute() {
float scale = 8.0f;
float elapsed = FrameTime::s_tickTimeSec;
s_netherBlurPhase = static_cast<float>(fmod(elapsed + elapsed + s_netherBlurPhase, 6.2831854820251465));
const C44Matrix* view = FFX::GetOldViewMtx();
float x = (view->c0 + view->b0) * 0.0f + view->a0;
float y = (view->c1 + view->b1) * 0.0f + view->a1;
float z = (view->c2 + view->b2) * 0.0f + view->a2;
if (fabs(z) > 0.000099999997f) {
float inv = 1.0f / z;
x *= inv;
y *= inv;
}
float invLength = 1.0f / sqrt(y * y + x * x);
x *= invLength;
y *= invLength;
float angle = static_cast<float>(acos(x));
if (y < 0.0f) {
angle = 6.2831855f - angle;
}
angle = static_cast<float>(cos(s_netherBlurPhase) * 0.5f + angle);
if (this->unk_0280 > 1.0f) {
this->unk_0280 = static_cast<float>(fmod(this->unk_0280, 1.0));
float* oldest = this->m_noiseTables[0];
this->m_noiseTables[0] = this->m_noiseTables[1];
this->m_noiseTables[1] = this->m_noiseTables[2];
this->m_noiseTables[2] = oldest;
for (uint32_t i = 0; i < 36; i++) {
uint32_t bits = (CRandom::uint32_(this->m_seed) & 0x7FFFFF) | 0x3F800000;
float random = *reinterpret_cast<float*>(&bits) - 1.0f;
this->m_noiseTables[2][i] = static_cast<float>(fmod(random + random - 1.0f, 1.0));
}
}
for (uint32_t i = 0; i < 36; i++) {
this->unk_01E4[i] = (1.0f - this->unk_0280) * this->m_noiseTables[0][i] + this->m_noiseTables[1][i] * this->unk_0280;
}
this->unk_0280 = elapsed * 1.5f + this->unk_0280;
FFX::SetupGx(this->m_output);
if (!FFX::s_useRECT) {
FFX::SetupGeo_Grid(this->m_output->m_size, this->m_inputs[0]->m_size, this->m_inputs[0]->m_texSize, FFX::s_gridPos, FFX::s_gridTex, 6, this->unk_002C);
FFX::SetupVB_PCT(36, FFX::s_gridPos, FFX::s_gridTex, this->unk_01E4);
}
g_theGxDevicePtr->PrimVertexMask(0x51);
FFX::SetupIB(6, 6);
g_theGxDevicePtr->RsSet(GxRs_VertexShader, this->m_vertexShader);
g_theGxDevicePtr->RsSet(GxRs_PixelShader, this->m_pixelShaders[this->m_useRect]);
float constants[4];
constants[0] = angle;
constants[1] = 0.0f;
constants[2] = 0.0f;
constants[3] = 0.0f;
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Vertex, 0, constants, 1);
if (FFX::s_useRECT) {
scale = 4.0f;
constants[0] = 4.0f;
constants[1] = 4.0f;
} else {
constants[0] = 8.0f * this->m_inputs[0]->m_texelSize.x;
constants[1] = this->m_inputs[0]->m_texelSize.y * 8.0f;
}
constants[2] = 0.0f;
constants[3] = 0.0f;
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Vertex, 1, constants, 1);
float convergence = g_theGxDevicePtr->StereoGetConvergence();
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Vertex, 2, &convergence, 1);
CGxTex* target = TextureGetGxTex(FFX::s_quart[1].m_texture, 1, nullptr);
GxRsSet(GxRs_ScissorTest, 0);
g_theGxDevicePtr->DeviceSetRenderTarget(GxBuffers_Color, target, 0);
GxXformSetViewport(0.0f, static_cast<float>(FFX::s_quart[1].m_size.x) / FFX::s_quart[1].m_texSize.x, 0.0f, static_cast<float>(FFX::s_quart[1].m_size.y) / FFX::s_quart[1].m_texSize.y, 0.0f, 1.0f);
GxSceneClear(1, CImVector(0xFF, 0xFF, 0xFF, 0xFF));
g_theGxDevicePtr->RsSet(GxRs_Texture0, TextureGetGxTex(this->m_inputs[0]->m_texture, 1, nullptr));
g_theGxDevicePtr->RsSet(GxRs_Texture1, TextureGetGxTex(this->m_inputs[0]->m_texture, 1, nullptr));
g_theGxDevicePtr->RsSet(GxRs_Texture2, TextureGetGxTex(this->m_inputs[0]->m_texture, 1, nullptr));
g_theGxDevicePtr->RsSet(GxRs_Texture3, TextureGetGxTex(this->m_inputs[0]->m_texture, 1, nullptr));
if (FFX::s_useRECT) {
FFX::SetupGeo_Grid(FFX::s_quart[1].m_size, this->m_inputs[0]->m_size, this->m_inputs[0]->m_texSize, FFX::s_gridPos, FFX::s_gridTex, 6, this->unk_002C);
FFX::SetupVB_PCT(36, FFX::s_gridPos, FFX::s_gridTex, this->unk_01E4);
}
g_theGxDevicePtr->Draw(&FFX::s_gridBatch, 1);
target = TextureGetGxTex(this->m_output->m_texture, 1, nullptr);
GxRsSet(GxRs_ScissorTest, 0);
g_theGxDevicePtr->DeviceSetRenderTarget(GxBuffers_Color, target, 0);
GxXformSetViewport(0.0f, static_cast<float>(this->m_output->m_size.x) / this->m_output->m_texSize.x, 0.0f, static_cast<float>(this->m_output->m_size.y) / this->m_output->m_texSize.y, 0.0f, 1.0f);
GxSceneClear(1, CImVector(0xFF, 0xFF, 0xFF, 0xFF));
g_theGxDevicePtr->RsSet(GxRs_Texture0, TextureGetGxTex(FFX::s_quart[1].m_texture, 1, nullptr));
g_theGxDevicePtr->RsSet(GxRs_Texture1, TextureGetGxTex(FFX::s_quart[1].m_texture, 1, nullptr));
g_theGxDevicePtr->RsSet(GxRs_Texture2, TextureGetGxTex(FFX::s_quart[1].m_texture, 1, nullptr));
g_theGxDevicePtr->RsSet(GxRs_Texture3, TextureGetGxTex(FFX::s_quart[1].m_texture, 1, nullptr));
if (FFX::s_useRECT) {
constants[0] = 0.0f;
constants[1] = 0.0f;
constants[2] = 0.0f;
constants[3] = 0.0f;
constants[0] = this->m_inputs[0]->m_texelSize.x / FFX::s_quart[1].m_texelSize.x * scale;
constants[1] = scale * (this->m_inputs[0]->m_texelSize.y / FFX::s_quart[1].m_texelSize.y);
constants[2] = 0.0f;
constants[3] = 0.0f;
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Vertex, 1, constants, 1);
FFX::SetupGeo_Grid(this->m_output->m_size, FFX::s_quart[1].m_size, FFX::s_quart[1].m_texSize, FFX::s_gridPos, FFX::s_gridTex, 6, this->unk_002C);
FFX::SetupVB_PCT(36, FFX::s_gridPos, FFX::s_gridTex, this->unk_01E4);
}
g_theGxDevicePtr->Draw(&FFX::s_gridBatch, 1);
FFX::SetupReset();
}
// VERIFY: 06b2c4be manual
// OFFSET: 0x007E8180
bool PassPropagateFog::Valid() {
CGxShader* shader = this->m_pixelShaders[this->m_useRect];
return shader && shader->Valid();
}
// VERIFY: 67b3055e manual
// OFFSET: 0x007E9080
void PassPropagateFog::Execute() {
FFX::SetupGx(this->m_output);
FFX::SetupGeo_Quad(this->m_output->m_size, this->m_inputs[0]->m_size, this->m_inputs[0]->m_texSize, FFX::s_gridPos, FFX::s_gridTex, this->unk_002C);
CImVector white;
*reinterpret_cast<uint32_t*>(&white) = 0xFFFFFFFF;
FFX::SetupVB_PCT4(FFX::s_gridPos, white, FFX::s_gridTex, this->m_params, this->m_inputs[0]->m_texelSize);
g_theGxDevicePtr->PrimVertexMask(0x3D1);
FFX::SetupIB();
CGxTex* texture = TextureGetGxTex(this->m_inputs[0]->m_texture, 1, nullptr);
g_theGxDevicePtr->RsSet(GxRs_Texture0, texture);
g_theGxDevicePtr->RsSet(GxRs_Texture1, texture);
g_theGxDevicePtr->RsSet(GxRs_Texture2, texture);
g_theGxDevicePtr->RsSet(GxRs_Texture3, texture);
for (int32_t state = GxRs_Texture4; state <= GxRs_Texture15; state++) {
GxRsSet(static_cast<EGxRenderState>(state), 0);
}
g_theGxDevicePtr->RsSet(GxRs_PixelShader, this->m_pixelShaders[this->m_useRect]);
float constants[4];
constants[0] = this->unk_005C;
constants[1] = constants[0];
constants[2] = constants[0];
constants[3] = constants[0];
GxShaderConstantsSet(GxSh_Pixel, 0, constants, 1);
GxRsSet(GxRs_BlendingMode, this->m_blend);
g_theGxDevicePtr->Draw(&FFX::s_quadBatch, 1);
FFX::SetupReset();
}
// VERIFY: 7f8524f4 auto
// OFFSET: 0x007E9010
void EffectSwirlingFog::SetParameters(int32_t count, const int32_t* params) {
static_cast<PassFogSeed*>(this->m_passes[0])->unk_0034 = params[0];
static_cast<PassPropagateFog*>(this->m_passes[1])->unk_005C = params[1] * 0.0039215689f;
PassFogCombine* combine = static_cast<PassFogCombine*>(this->m_passes[2]);
combine->unk_0054 = params[2] * 0.0099999998f;
combine->unk_0058 = 3.0f;
}
// VERIFY: d2fd534c auto
// OFFSET: 0x007E8E20
void EffectNetherWorld::End() {
if (this->m_passes.Count() >= 2) {
static_cast<PassNetherCombine*>(this->m_passes[1])->unk_003C = 0.0f;
}
}
// STATIC: 0x00AF4940
static float s_netherCombineConstants[4] = { 0.6f, 0.6f, 0.78f, 0.0f };
// VERIFY: e25bee7f manual
// OFFSET: 0x007E8380
static C2Vector PolarCoord(float u, float v) {
C2Vector result;
result.x = 0.0f;
result.y = 0.0f;
float dy = (v - 0.5f) * 1.4142137f;
float dx = (u - 0.5f) * 1.4142137f;
float radius = sqrt(dx * dx + dy * dy);
result.y = radius;
float c = radius == 0.0f ? 1.0f : 1.0f / radius * dy;
result.x = acos(c) * 0.31830987f;
return result;
}
// VERIFY: 59729488 manual
// OFFSET: 0x007E8410
void PassFogCombine::BuildVertices(const C2iVector& size, FFX::Tex* tex0, FFX::Tex* tex1) {
CImVector color;
*reinterpret_cast<uint32_t*>(&color) = 0xFFFFFFFF;
float halfU0 = 0.5f / tex0->m_size.x;
float halfV0 = 0.5f / tex0->m_size.y;
float halfU1 = 0.5f / tex1->m_size.x;
float halfV1 = 0.5f / tex1->m_size.y;
float stepX = size.x * 0.03125f;
float stepY = 0.03125f * size.y;
float scaleU0 = tex0->m_size.x * tex0->m_texelSize.x;
float scaleV0 = tex0->m_size.y * tex0->m_texelSize.y;
float scaleU1 = tex1->m_size.x * tex1->m_texelSize.x;
float scaleV1 = tex1->m_size.y * tex1->m_texelSize.y;
bool flip = this->unk_002C && !g_theGxDevicePtr->DeviceApi();
FFX::VertexPCT2* vertex = reinterpret_cast<FFX::VertexPCT2*>(g_theGxDevicePtr->BufLock(this->m_vertexBuf));
for (uint32_t y = 0; y <= 32; y++) {
float py = stepY * y;
float v = y * 0.03125f;
if (!flip) {
v = 1.0f - v;
}
for (uint32_t x = 0; x <= 32; x++) {
vertex->p.x = stepX * x;
vertex->p.y = py;
vertex->p.z = 0.0f;
float u = x * 0.03125f;
vertex->tc[0] = PolarCoord(u, v);
vertex->tc[0].x = vertex->tc[0].x + halfU0;
vertex->tc[0].y = vertex->tc[0].y + halfV0;
vertex->tc[0].x = vertex->tc[0].x * scaleU0;
vertex->tc[0].y = vertex->tc[0].y * scaleV0;
vertex->tc[1].x = u;
vertex->tc[1].y = v;
vertex->tc[1].x = vertex->tc[1].x + halfU1;
vertex->tc[1].y = vertex->tc[1].y + halfV1;
vertex->tc[1].x = vertex->tc[1].x * scaleU1;
vertex->tc[1].y = vertex->tc[1].y * scaleV1;
vertex->c = color;
vertex++;
}
}
CGxBuf* buf = this->m_vertexBuf;
g_theGxDevicePtr->BufUnlock(buf, 0);
buf->unk_001C = 1;
}
// VERIFY: 7f8f703f manual
// OFFSET: 0x007E8600
void PassFogCombine::BuildIndices() {
uint16_t* index = reinterpret_cast<uint16_t*>(g_theGxDevicePtr->BufLock(this->m_indexBuf));
for (uint32_t y = 0; y < 32; y++) {
for (uint32_t x = 0; x < 32; x++) {
uint16_t base = static_cast<uint16_t>(33 * y + x);
index[0] = base + 1;
index[1] = base + 33;
index[2] = base;
index[3] = base + 1;
index[4] = base + 34;
index[5] = base + 33;
index += 6;
}
}
CGxBuf* buf = this->m_indexBuf;
g_theGxDevicePtr->BufUnlock(buf, 0);
buf->unk_001C = 1;
}
// VERIFY: d096b4ea manual
// OFFSET: 0x008C2020
bool PassDeath::Valid() {
CGxShader* shader = this->m_shaders[this->m_useRect];
return (shader ? shader->Valid() : 0) != 0;
}
// VERIFY: 883cadff manual
// OFFSET: 0x007E87B0
void PassDeath::Execute() {
C2Vector texCoords0[4];
C2Vector texCoords1[4];
FFX::SetupGx(this->m_output);
FFX::SetupGeo_Quad(this->m_output->m_size, this->m_inputs[0]->m_size, this->m_inputs[0]->m_texSize, FFX::s_gridPos, texCoords0, this->unk_002C);
FFX::SetupGeo_Quad(this->m_output->m_size, this->m_inputs[1]->m_size, this->m_inputs[1]->m_texSize, FFX::s_gridPos, texCoords1, this->unk_002C);
g_theGxDevicePtr->RsSet(GxRs_Texture0, TextureGetGxTex(this->m_inputs[0]->m_texture, 1, nullptr));
g_theGxDevicePtr->RsSet(GxRs_Texture1, TextureGetGxTex(this->m_inputs[1]->m_texture, 1, nullptr));
g_theGxDevicePtr->RsSet(GxRs_PixelShader, this->m_shaders[this->m_useRect]);
CImVector color;
color.b = 0xA8;
color.g = 0x93;
color.r = 0x53;
color.a = static_cast<uint8_t>(CMath::fint_(DayNight::GetInfo()->m_bands.m_glow * 255.0f));
GxPrimVertexPtr(4, FFX::s_gridPos, sizeof(C3Vector), nullptr, 0, &color, 0, texCoords0, sizeof(C2Vector), texCoords1, sizeof(C2Vector));
GxPrimIndexPtr(4, FFX::s_quadIndices);
g_theGxDevicePtr->Draw(&FFX::s_quadBatch, 1);
FFX::SetupReset();
}
// VERIFY: 51b35afa manual
// OFFSET: 0x008C2020
bool PassNetherCombine::Valid() {
CGxShader* shader = this->m_pixelShaders[this->m_useRect];
return (shader ? shader->Valid() : 0) != 0;
}
// VERIFY: 74b70bbd manual
// OFFSET: 0x007E8C80
void PassNetherCombine::Execute() {
C2Vector texCoords0[4];
C2Vector texCoords1[4];
FFX::SetupGx(this->m_output);
FFX::SetupGeo_Quad(this->m_output->m_size, this->m_inputs[0]->m_size, this->m_inputs[0]->m_texSize, FFX::s_gridPos, texCoords0, this->unk_002C);
FFX::SetupGeo_Quad(this->m_output->m_size, this->m_inputs[1]->m_size, this->m_inputs[1]->m_texSize, FFX::s_gridPos, texCoords1, this->unk_002C);
g_theGxDevicePtr->RsSet(GxRs_Texture0, TextureGetGxTex(this->m_inputs[0]->m_texture, 1, nullptr));
g_theGxDevicePtr->RsSet(GxRs_Texture1, TextureGetGxTex(this->m_inputs[1]->m_texture, 1, nullptr));
g_theGxDevicePtr->RsSet(GxRs_PixelShader, this->m_pixelShaders[this->m_useRect]);
CImVector color;
*reinterpret_cast<uint32_t*>(&color) = 0xFFFFFFFF;
if (this->unk_003C < 0.75f) {
float fade = this->unk_003C + FrameTime::s_tickTimeSec;
this->unk_003C = fade >= 0.75f ? 0.75f : fade;
}
s_netherCombineConstants[3] = this->unk_003C;
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Pixel, 0, s_netherCombineConstants, 1);
GxPrimVertexPtr(4, FFX::s_gridPos, sizeof(C3Vector), nullptr, 0, &color, 0, texCoords0, sizeof(C2Vector), texCoords1, sizeof(C2Vector));
GxPrimIndexPtr(4, FFX::s_quadIndices);
g_theGxDevicePtr->Draw(&FFX::s_quadBatch, 1);
FFX::SetupReset();
}
// VERIFY: ff3f053e manual
// OFFSET: 0x007E8180
bool PassFogCombine::Valid() {
CGxShader* shader = this->m_pixelShaders[this->m_useRect];
return shader && shader->Valid();
}
// VERIFY: 0e25f7e9 manual
// OFFSET: 0x007E9670
void PassFogCombine::Execute() {
FFX::SetupGx(this->m_output);
bool rebuildVertices = !(this->m_vertexBuf->unk_001C && this->m_vertexBuf->unk_001D);
bool rebuildIndices = !(this->m_indexBuf->unk_001C && this->m_indexBuf->unk_001D);
const C2iVector& size = this->m_output->m_size;
if (this->unk_004C != size.x || this->unk_0050 != size.y) {
this->unk_004C = size.x;
this->unk_0050 = size.y;
this->BuildVertices(size, this->m_inputs[0], this->m_inputs[1]);
} else if (rebuildVertices) {
this->BuildVertices(size, this->m_inputs[0], this->m_inputs[1]);
}
if (rebuildIndices) {
this->BuildIndices();
}
g_theGxDevicePtr->RsSet(GxRs_Texture0, TextureGetGxTex(this->m_inputs[0]->m_texture, 1, nullptr));
g_theGxDevicePtr->RsSet(GxRs_Texture1, TextureGetGxTex(this->m_inputs[1]->m_texture, 1, nullptr));
for (int32_t rs = 23; rs < 37; rs++) {
GxRsSet(static_cast<EGxRenderState>(rs), 0);
}
g_theGxDevicePtr->RsSet(GxRs_PixelShader, this->m_pixelShaders[this->m_useRect]);
float density;
float minimum;
if (this->unk_0058 <= 0.0f) {
density = this->unk_0054;
minimum = 0.1f;
} else {
float fade = 1.0f - this->unk_0058 * 0.33333334f;
this->unk_0058 = this->unk_0058 - FrameTime::s_tickTimeSec;
if (this->unk_0058 < 0.0f) {
this->unk_0058 = 0.0f;
}
density = this->unk_0054 * fade;
minimum = fade * 0.1f;
}
float densityConstants[4] = { density, density, density, density };
float minimumConstants[4] = { minimum, minimum, minimum, minimum };
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Pixel, 0, densityConstants, 1);
g_theGxDevicePtr->ShaderConstantsSet(GxSh_Pixel, 1, minimumConstants, 1);
GxPrimVertexPtr(this->m_vertexBuf, GxVBF_PCT2);
g_theGxDevicePtr->PrimIndexPtr(this->m_indexBuf);
GxRsSet(GxRs_BlendingMode, this->m_blend);
GxUpdateAlphaRef(GxRs_AlphaRef);
CGxBatch batch;
batch.m_primType = GxPrim_Triangles;
batch.m_start = 0;
batch.m_count = 6144;
batch.m_minIndex = 0;
batch.m_maxIndex = 1088;
g_theGxDevicePtr->Draw(&batch, 1);
FFX::SetupReset();
}