mirror/dusklight
1
0
Fork 0
mirror of https://github.com/TwilitRealm/dusklight synced 2026-05-31 00:45:24 -04:00
Code Issues Packages Projects Releases Wiki Activity
Files
bafde816ebe3533d22974280e640f0207fb172e7
dusklight/libs/JSystem/src/J2DGraph/J2DWindowEx.cpp
T
qwertyquerty 767ba3bb14 Ongoing gameplay dev (#49) 
* launch.json cwd

* bodge to load gci for testing

* stub card stat

* gameplay bodges

* viewport, ub fixes

* add release with debug info cmake variant

* be fixes, sound stub

* viewport h

* d_msg_flow BE

* be fopAcM_createItemFromEnemyID

* update launch configuration to use iso

* more audio stubs

* Attempt to set viewport and get messages for brightness check

* skip opening scene again, fixed JMessage::TResourceContainer::TCResource::Do_destroy

* add guards for viewport changes

* moar endian swapping to get Link sitting in PROC_OPENING_SCENE and for dialogues

* BE d_msg_class i_data

* stub bgm start

* fix div by 0 error (for now)

* TEMP_BROKEN in d_menu_ring

* REQUIRES_GX_LINES

* properly stub renderingAmap::draw with REQUIRES_GX_LINES

* better stubbing outside of stubs

* fix event data getting swapped multiple times

* evil draw vp fix

* Stub log imgui

This redirects all spammy logs to an imgui window that is cleared per frame.

This fixes the serious performance dip of the logging, and makes the regular log readable.

* Oops move those optimization changes I accidentally committed behind a flag

DUSK_SELECTED_OPT

* gx_line macro in map

* fix audio stubbing

* switch to CARD API aurora impl

* remove kabufuda from link libs

* refactor imgui stuff and add input viewer

* merge stub log with refactor

* accidentally committed a metaforce header shh

* basic map loader

* ImGuiConsole: Add missing <thread> include

* you may now play as luigi (you may now load stages with bridges)

* bloom fix

* bloom leak fix

* cloud shadow fix

* add soft reset button to imgui menu

* if it broke dont not fix it

* i swear i committed this

* BE swap indMtx in JPAResource::setPTev

* wnark ct fix

* frsqrte implementation from kinoko

* Fix Clang compile error in JAISeq::prepare_getSeqData_

* Add endian conversions to dMsgFlow_c::getInitNodeIndex

This fixes a freeze when Fado tries to stop you from leaving the
starting area.

* Add RAII GXTexObj wrapper; fix almost all leaks

* Update aurora for indirect texturing

* Update aurora for CARD fix

* Fix Clang build

* More d_msg_flow endian fixes

Fixes softlock when trying to talk to Fado and possibly other NPCs.

* no frame limiter

* get pause menu working

* proper frame limiting

* particle pointer size fix

* improve map loader a bit

---------

Co-authored-by: Jasper St. Pierre <jstpierre@mecheye.net>
Co-authored-by: TakaRikka <takarikka@outlook.com>
Co-authored-by: CraftyBoss <talibabdulmaalik@gmail.com>
Co-authored-by: Luke Street <luke@street.dev>
Co-authored-by: Lurs <2795933+Lurs@users.noreply.github.com>
Co-authored-by: PJB3005 <pieterjan.briers+git@gmail.com>
Co-authored-by: tgsm <doodrabbit@hotmail.com>
Co-authored-by: Max Roncace <me@caseif.net>
Co-authored-by: Phillip Stephens <antidote.crk@gmail.com>
2026-03-12 04:01:03 -07:00

864 lines
29 KiB
C++
Raw Blame History

#include "JSystem/JSystem.h" // IWYU pragma: keep
#include "JSystem/J2DGraph/J2DWindowEx.h"
#include "JSystem/JUtility/JUTTexture.h"
#include "JSystem/JSupport/JSURandomInputStream.h"
#include "dusk/endian.h"
struct J2DWindowExDef {
BE(u32) field_0x0[4];
BE(u16) field_0x10[4];
u8 field_0x18;
u8 field_0x19;
BE(u16) field_0x1A;
BE(u16) field_0x1C;
BE(u16) field_0x1E;
BE(u16) field_0x20;
BE(u16) field_0x22;
BE(u16) field_0x24;
BE(u16) field_0x26;
BE(u16) field_0x28[4];
BE(u32) field_0x30[4];
};
STATIC_ASSERT(sizeof(J2DWindowExDef) == 0x40);
J2DWindowEx::J2DWindowEx(J2DPane* param_0, JSURandomInputStream* param_1, u32 param_2,
J2DMaterial* param_3) : J2DWindow() {
mAnmVisibilityFull = NULL;
mAnmVtxColor = NULL;
s32 position = param_1->getPosition();
BE(int) uStack_88[2];
param_1->read(uStack_88, 8);
mKind = uStack_88[0];
s32 iVar2 = param_1->getPosition();
BE(int) auStack_90[2];
param_1->peek(auStack_90, 8);
makePaneExStream(param_0, param_1);
param_1->seek(iVar2 + auStack_90[1], JSUStreamSeekFrom_SET);
J2DWindowExDef auStack_70;
param_1->read(&auStack_70, sizeof(J2DWindowExDef));
JUtility::TColor* colors[4] = {
&field_0x128,
&field_0x12C,
&field_0x130,
&field_0x134
};
for (int i = 0; i < 4; i++) {
field_0x158[i] = auStack_70.field_0x10[i];
mFrameMaterial[i] = 0;
if (field_0x158[i] != 0xffff) {
mFrameMaterial[i] = param_3 + field_0x158[i];
(param_3 + field_0x158[i])->field_0x4 = this;
}
field_0x168[i] = auStack_70.field_0x28[i];
*(colors[i]) = JUtility::TColor(auStack_70.field_0x30[i]);
}
field_0x144 = auStack_70.field_0x18;
field_0x114.set(auStack_70.field_0x1A, auStack_70.field_0x1C,
auStack_70.field_0x1A + auStack_70.field_0x1E,
auStack_70.field_0x1C + auStack_70.field_0x20);
field_0x166 = auStack_70.field_0x22;
field_0x164 = auStack_70.field_0x24;
mContentsMaterial = NULL;
if (field_0x164 != 0xffff) {
mContentsMaterial = &param_3[field_0x164];
param_3[field_0x164].field_0x4 = this;
}
param_1->seek(position + uStack_88[1], JSUStreamSeekFrom_SET);
rewriteAlpha();
field_0x100 = NULL;
field_0x104 = NULL;
field_0x108 = NULL;
field_0x10c = NULL;
mPalette = NULL;
field_0x110 = NULL;
field_0x170 = 0;
setMinSize();
}
static void dummy(J2DTexGenBlock* block) {
block->setTexCoord(0, J2DTexCoord());
}
void J2DWindowEx::setMinSize() {
field_0x140 = 1;
field_0x142 = 1;
if (mFrameMaterial[0] == NULL) return;
if (mFrameMaterial[1] == NULL) return;
if (mFrameMaterial[2] == NULL) return;
if (mFrameMaterial[3] == NULL) return;
if (mFrameMaterial[0]->getTevBlock() == NULL) return;
if (mFrameMaterial[1]->getTevBlock() == NULL) return;
if (mFrameMaterial[2]->getTevBlock() == NULL) return;
if (mFrameMaterial[3]->getTevBlock() == NULL) return;
if (mFrameMaterial[0]->getTevBlock()->getTexture(0) == NULL) return;
if (mFrameMaterial[1]->getTevBlock()->getTexture(0) == NULL) return;
if (mFrameMaterial[2]->getTevBlock()->getTexture(0) == NULL) return;
if (mFrameMaterial[3]->getTevBlock()->getTexture(0) == NULL) return;
field_0x140 = mFrameMaterial[0]->getTevBlock()->getTexture(0)->getWidth()
+ mFrameMaterial[1]->getTevBlock()->getTexture(0)->getWidth();
field_0x142 = mFrameMaterial[0]->getTevBlock()->getTexture(0)->getHeight()
+ mFrameMaterial[2]->getTevBlock()->getTexture(0)->getHeight();
}
J2DWindowEx::~J2DWindowEx() {
for (u8 i = 0; i < 4; i++) {
if (field_0x170 & (1 << i)) {
JKR_DELETE(mFrameMaterial[i]);
}
}
if (field_0x170 & 0x10) {
JKR_DELETE(mContentsMaterial);
}
}
void J2DWindowEx::drawSelf(f32 param_0, f32 param_1, f32 (*param_2)[3][4]) {
JGeometry::TBox2<f32> aTStack_50(mBounds);
Mtx auStack_40;
aTStack_50.addPos(JGeometry::TVec2<f32>(param_0, param_1));
MTXConcat(*param_2, mGlobalMtx, auStack_40);
GXLoadPosMtxImm(auStack_40, 0);
draw_private(aTStack_50, field_0x114);
clip(field_0x114);
}
void J2DWindowEx::draw_private(JGeometry::TBox2<f32> const& param_0,
JGeometry::TBox2<f32> const& param_1) {
if (param_0.getWidth() >= field_0x140 && param_0.getHeight() >= field_0x142) {
JUTTexture* textures[4];
bool foundNullTexture = false;
for (int i = 0; i < 4; i++) {
if (mFrameMaterial[i] == NULL) {
return;
}
if (mFrameMaterial[i]->getTevBlock() == NULL) {
return;
}
textures[i] = mFrameMaterial[i]->getTevBlock()->getTexture(0);
if (textures[i] == NULL) {
foundNullTexture = true;
}
}
JGeometry::TBox2<f32> aTStack_38(param_1);
aTStack_38.addPos(param_0.i);
drawContents(aTStack_38);
GXClearVtxDesc();
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
if (!foundNullTexture) {
f32 minX = param_0.i.x;
f32 minY = param_0.i.y;
f32 f31 = param_0.f.x - textures[3]->getWidth();
f32 f30 = param_0.f.y - textures[3]->getHeight();
f32 maxX0 = minX + textures[0]->getWidth();
f32 maxY0 = minY + textures[0]->getHeight();
u16 r29 = (field_0x144 & 0x80 ? (u16)0 : (u16)0x8000);
u16 r28 = (field_0x144 & 0x40 ? (u16)0 : (u16)0x8000);
drawFrameTexture(minX, minY, textures[0]->getWidth(), textures[0]->getHeight(), r29, r28,
0x8000 - r29, 0x8000 - r28, mFrameMaterial[0], true);
bool r9 = mFrameMaterial[1] != mFrameMaterial[0];
r29 = field_0x144 & 0x20 ? (u16)0 : (u16)0x8000;
r28 = field_0x144 & 0x10 ? (u16)0 : (u16)0x8000;
drawFrameTexture(f31, minY, textures[3]->getWidth(), textures[0]->getHeight(), r29, r28,
0x8000 - r29, 0x8000 - r28, mFrameMaterial[1], r9);
r29 = field_0x144 & 0x20 ? (u16)0x8000 : (u16)0;
u16 sp_30 = r29;
r28 = field_0x144 & 0x10 ? (u16)0 : (u16)0x8000;
drawFrameTexture(maxX0, minY, f31 - maxX0, textures[0]->getHeight(), r29, r28, sp_30,
r28 ^ 0x8000, mFrameMaterial[1], false);
r9 = mFrameMaterial[3] != mFrameMaterial[1];
r29 = field_0x144 & 0x2 ? (u16)0 : (u16)0x8000;
r28 = field_0x144 & 0x1 ? (u16)0 : (u16)0x8000;
drawFrameTexture(f31, f30, textures[3]->getWidth(), textures[3]->getHeight(), r29, r28,
0x8000 - r29, 0x8000 - r28, mFrameMaterial[3], r9);
r29 = field_0x144 & 0x2 ? (u16)0x8000 : (u16)0;
sp_30 = r29;
r28 = field_0x144 & 0x1 ? (u16)0 : (u16)0x8000;
drawFrameTexture(maxX0, f30, f31 - maxX0, textures[3]->getHeight(), r29, r28, sp_30,
r28 ^ 0x8000, mFrameMaterial[3], false);
r29 = field_0x144 & 0x2 ? (u16)0 : (u16)0x8000;
r28 = field_0x144 & 0x1 ? (u16)0x8000 : (u16)0;
u16 sp_2E = r28;
drawFrameTexture(f31, maxY0, textures[3]->getWidth(), f30 - maxY0, r29, r28, r29 ^ 0x8000,
sp_2E, mFrameMaterial[3], false);
r9 = mFrameMaterial[2] != mFrameMaterial[3];
r29 = field_0x144 & 0x8 ? (u16)0 : (u16)0x8000;
r28 = field_0x144 & 0x4 ? (u16)0 : (u16)0x8000;
drawFrameTexture(minX, f30, textures[0]->getWidth(), textures[3]->getHeight(), r29, r28,
0x8000 - r29, 0x8000 - r28, mFrameMaterial[2], r9);
r29 = field_0x144 & 0x8 ? (u16)0 : (u16)0x8000;
r28 = field_0x144 & 0x4 ? (u16)0x8000 : (u16)0;
sp_2E = r28;
drawFrameTexture(minX, maxY0, textures[0]->getWidth(), f30 - maxY0, r29, r28, r29 ^ 0x8000,
sp_2E, mFrameMaterial[2], false);
}
GXSetTevOp(GX_TEVSTAGE0, GX_PASSCLR);
GXSetTevOrder(GX_TEVSTAGE0, GX_TEXCOORD_NULL, GX_TEXMAP_NULL, GX_COLOR0A0);
GXSetNumTexGens(0);
GXSetVtxDesc(GX_VA_TEX0, GX_NONE);
}
}
static f32 dummy_literal() {
return 0.0f;
}
void J2DWindowEx::drawContents(JGeometry::TBox2<f32> const& param_1) {
if (!param_1.isValid() || mContentsMaterial == NULL) {
return;
}
if (!mContentsMaterial->isVisible()) {
return;
}
mContentsMaterial->setGX();
GXClearVtxDesc();
GXSetVtxDesc(GX_VA_POS, GX_DIRECT);
GXSetVtxDesc(GX_VA_CLR0, GX_DIRECT);
JUtility::TColor TStack_b4(field_0x128);
JUtility::TColor TStack_b8(field_0x130);
JUtility::TColor TStack_bc(field_0x12C);
JUtility::TColor TStack_c0(field_0x134);
if (mContentsMaterial->getColorBlock()->getColorChan(1)->getMatSrc() == 1) {
if (mContentsMaterial->getMaterialAlphaCalc() == 1) {
TStack_b4.a = (TStack_b4.a * mColorAlpha) / 0xff;
TStack_b8.a = (TStack_b8.a * mColorAlpha) / 0xff;
TStack_bc.a = (TStack_bc.a * mColorAlpha) / 0xff;
TStack_c0.a = (TStack_c0.a * mColorAlpha) / 0xff;
}
} else if (mIsInfluencedAlpha) {
GXSetChanMatColor(GX_ALPHA0, JUtility::TColor(mColorAlpha));
}
bool bVar5 = false;
f32 in_f31;
f32 in_f30;
f32 in_f29;
f32 in_f28;
if (mContentsMaterial->getTevBlock() != NULL) {
if (mContentsMaterial->getTevBlock()->getTexture(0)) {
bVar5 = true;
GXSetVtxDesc(GX_VA_TEX0, GX_DIRECT);
f32 dVar15 = mContentsMaterial->getTevBlock()->getTexture(0)->getWidth();
f32 dVar14 = mContentsMaterial->getTevBlock()->getTexture(0)->getHeight();
f32 dVar12 = param_1.getWidth();
f32 dVar13 = param_1.getHeight();
in_f31 = -(dVar12 / dVar15 - 1.0f) / 2;
in_f30 = -((dVar13 / dVar14) - 1.0f) / 2;
in_f29 = in_f31 + (dVar12 / dVar15);
in_f28 = in_f30 + (dVar13 / dVar14);
}
}
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_F32, 0);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_CLR_RGBA, GX_F32, 0);
GXBegin(GX_QUADS, GX_VTXFMT0, 4);
GXPosition3f32(param_1.i.x, param_1.i.y,
0.0f);
GXColor1u32(TStack_b4);
if (bVar5) {
GXTexCoord2f32(in_f31, in_f30);
}
GXPosition3f32(param_1.f.x, param_1.i.y,
0.0f);
GXColor1u32(TStack_bc);
if (bVar5) {
GXTexCoord2f32(in_f29, in_f30);
}
GXPosition3f32(param_1.f.x, param_1.f.y,
0.0f);
GXColor1u32(TStack_c0);
if (bVar5) {
GXTexCoord2f32(in_f29, in_f28);
}
GXPosition3f32(param_1.i.x, param_1.f.y,
0.0f);
GXColor1u32(TStack_b8);
if (bVar5) {
GXTexCoord2f32(in_f31, in_f28);
}
GXEnd();
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_TEX0, GX_CLR_RGBA, GX_RGBX8, 0xf);
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_RGBA4, 0);
}
void J2DWindowEx::drawFrameTexture(f32 param_1, f32 param_2, f32 param_3, f32 param_4, u16 param_5,
u16 param_6, u16 param_7, u16 param_8, J2DMaterial* param_9,
bool param_10) {
if (param_9 != NULL && param_9->isVisible()) {
f32 dVar15 = param_1 + param_3;
f32 dVar14 = param_2 + param_4;
if (param_10) {
param_9->setGX();
}
JUtility::TColor aTStack_84(0xffffffff);
J2DPane* parentPane = getParentPane();
if (param_9->getColorBlock()->getColorChan(1)->getMatSrc() == 1) {
if (param_9->getMaterialAlphaCalc() == 1) {
u8 uVar11 = 0xff;
if (param_9->getColorBlock()->getMatColor(0) != 0) {
uVar11 = param_9->getColorBlock()->getMatColor(0)->a;
}
if (parentPane != NULL && mIsInfluencedAlpha != 0) {
uVar11 = ((uVar11 * parentPane->mColorAlpha) / 0xff);
}
aTStack_84 = JUtility::TColor((u32)uVar11 | 0xffffff00);
}
} else if (parentPane != NULL && mIsInfluencedAlpha != 0 && param_10) {
u8 matColorAlpha = param_9->getColorBlock()->getMatColor(0)->a;
matColorAlpha = matColorAlpha * parentPane->mColorAlpha / 0xff;
GXSetChanMatColor(GX_ALPHA0, JUtility::TColor(matColorAlpha));
}
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_F32, 0);
GXBegin(GX_QUADS, GX_VTXFMT0, 4);
GXPosition3f32(param_1, param_2, 0.0f);
GXColor1u32(aTStack_84);
GXTexCoord2u16(param_7, param_8);
GXPosition3f32(dVar15, param_2, 0.0f);
GXColor1u32(aTStack_84);
GXTexCoord2u16(param_5, param_8);
GXPosition3f32(dVar15, dVar14, 0.0f);
GXColor1u32(aTStack_84);
GXTexCoord2u16(param_5, param_6);
GXPosition3f32(param_1, dVar14, 0.0f);
GXColor1u32(aTStack_84);
GXTexCoord2u16(param_7, param_6);
GXEnd();
GXSetVtxAttrFmt(GX_VTXFMT0, GX_VA_POS, GX_CLR_RGBA, GX_RGBA4, 0);
}
}
void J2DWindowEx::draw(JGeometry::TBox2<f32> const& param_1) {
bool isMissingTexture = false;
JUTTexture* local_68[4];
for (int i = 0; i < 4; i++) {
if (mFrameMaterial[i] == NULL) {
return;
}
if (mFrameMaterial[i]->getTevBlock() == NULL) {
return;
}
local_68[i] = mFrameMaterial[i]->getTevBlock()->getTexture(0);
if (local_68[i] == NULL) {
isMissingTexture = true;
}
}
JGeometry::TBox2<f32> aTStack_78;
if (!isMissingTexture) {
aTStack_78.set(local_68[0]->getWidth(), local_68[0]->getHeight(),
param_1.getWidth() - local_68[1]->getWidth(),
param_1.getHeight() - local_68[2]->getHeight());
} else {
aTStack_78.set(0.0f, 0.0f, param_1.getWidth(), param_1.getHeight());
}
draw(param_1, aTStack_78);
}
void J2DWindowEx::draw(JGeometry::TBox2<f32> const& param_1, JGeometry::TBox2<f32> const& param_2) {
rewriteAlpha();
mColorAlpha = mAlpha;
makeMatrix(param_1.i.x, param_1.i.y, 0.0f, 0.0f);
GXLoadPosMtxImm(mPositionMtx, 0);
GXSetCurrentMtx(0);
JGeometry::TBox2<f32> aTStack_70(0.0f, 0.0f, param_1.getWidth(), param_1.getHeight());
draw_private(aTStack_70, param_2);
for (int i = GX_TEV_SWAP0; i < GX_MAX_TEVSWAP; i++) {
GXSetTevSwapModeTable((GXTevSwapSel)i, GX_CH_RED, GX_CH_GREEN, GX_CH_BLUE, GX_CH_ALPHA);
}
GXSetNumIndStages(0);
for (int i = GX_TEVSTAGE0; i < GX_MAX_TEVSTAGE; i++) {
GXSetTevDirect((GXTevStageID)i);
}
Mtx auStack_60;
MTXIdentity(auStack_60);
GXLoadPosMtxImm(auStack_60, 0);
}
void J2DWindowEx::setTevOrder(bool param_0) {
u16 local_28[2];
if (!param_0) {
local_28[0] = (u16)4;
local_28[1] = (u16)0xffff;
} else {
local_28[0] = (u16)0xff;
local_28[1] = (u16)0xff04;
}
for (u8 i = 0; i < 2; i++) {
J2DTevOrderInfo info;
info.mTexCoord = local_28[i] >> 8;
info.mTexMap = local_28[i] >> 8;
info.mColor = local_28[i] & 0xff;
J2DTevOrder local_30(info);
for (int j = 0; j < 4; j++) {
if (mFrameMaterial[j]->getTevBlock()->getMaxStage() > i) {
mFrameMaterial[j]->getTevBlock()->setTevOrder(i, local_30);
}
}
}
}
void J2DWindowEx::setTevStage(bool param_1) {
for (int i = 0; i < 4; i++) {
J2DTevStage* pJVar3 = mFrameMaterial[i]->getTevBlock()->getTevStage(0);
const JUTTexture* this_00 = mFrameMaterial[i]->getTevBlock()->getTexture(0);
bool bVar1 = false;
if (this_00 != NULL && ((s32)this_00->getFormat() == 0 || (s32)this_00->getFormat() == 1) &&
this_00->getTransparency() == 0)
{
bVar1 = true;
}
if (!param_1) {
setStage(pJVar3, bVar1 ? STAGE_ENUM_1 : STAGE_ENUM_0);
} else {
setStage(pJVar3, bVar1 ? STAGE_ENUM_4 : STAGE_ENUM_3);
pJVar3 = mFrameMaterial[i]->getTevBlock()->getTevStage(1);
setStage(pJVar3, STAGE_ENUM_2);
}
}
}
static u8 const lit_1557[16] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static u8 const lit_1566[16] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static u8 const lit_1575[16] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static u8 const lit_1581[16] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static u8 const lit_1587[16] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static u8 const lit_1596[16] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static u8 const lit_1605[16] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
static u8 const lit_1612[16] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
};
void J2DWindowEx::setStage(J2DTevStage* param_0, J2DWindowEx::stage_enum param_1) {
s8 local_30[6][4] = {
{0x0f, 0x08, 0x0a, 0x0f}, {0x0f, 0x08, 0x0a, 0x0f}, {0x0f, 0x0a, 0x00, 0x0f},
{0x02, 0x04, 0x08, 0x0f}, {0x02, 0x04, 0x08, 0x0f}, {0x0f, 0x0f, 0x0f, 0x0a},
};
s8 local_48[6][4] = {
{0x07, 0x04, 0x05, 0x07}, {0x05, 0x07, 0x07, 0x07}, {0x07, 0x05, 0x00, 0x07},
{0x01, 0x02, 0x04, 0x07}, {0x07, 0x07, 0x07, 0x02}, {0x07, 0x07, 0x07, 0x05},
};
s8 local_68[6][5] = {
{0, 0, 0, 1, 0}, {0, 0, 0, 1, 0}, {0, 0, 0, 1, 0},
{0, 0, 0, 1, 0}, {0, 0, 0, 1, 0}, {0, 0, 0, 1, 0},
};
param_0->setTevColorAB(local_30[param_1][0], local_30[param_1][1]);
param_0->setTevColorCD(local_30[param_1][2], local_30[param_1][3]);
param_0->setTevColorOp(local_68[param_1][0], local_68[param_1][1], local_68[param_1][2],
local_68[param_1][3], local_68[param_1][4]);
param_0->setAlphaABCD(local_48[param_1][0], local_48[param_1][1], local_48[param_1][2],
local_48[param_1][3]);
param_0->setTevAlphaOp(local_68[param_1][0], local_68[param_1][1], local_68[param_1][2],
local_68[param_1][3], local_68[param_1][4]);
}
bool J2DWindowEx::setBlack(JUtility::TColor i_black) {
JUtility::TColor black, white;
if (!getBlackWhite(&black, &white)) {
return false;
}
return setBlackWhite(i_black, white);
}
bool J2DWindowEx::setWhite(JUtility::TColor i_white) {
JUtility::TColor black, white;
if (!getBlackWhite(&black, &white)) {
return false;
}
return setBlackWhite(black, i_white);
}
// NONMATCHING - J2DGXColorS10 issue
bool J2DWindowEx::setBlackWhite(JUtility::TColor black, JUtility::TColor white) {
for (int i = 0; i < 4; i++) {
if (mFrameMaterial[i] == NULL) {
return false;
}
if (mFrameMaterial[i]->getTevBlock() == NULL) {
return false;
}
}
if (!isSetBlackWhite(black, white)) {
return false;
}
bool bVar1 = (u32)black != 0 || (u32)white != 0xffffffff;
u8 uVar3 = bVar1 ? 2 : 1;
for (int i = 0; i < 4; i++) {
mFrameMaterial[i]->getTevBlock()->setTevStageNum(uVar3);
}
setTevOrder(bVar1);
setTevStage(bVar1);
if (bVar1) {
J2DGXColorS10 color0, color1;
color0.r = black.r;
color0.g = black.g;
color0.b = black.b;
color0.a = black.a;
color1.r = white.r;
color1.g = white.g;
color1.b = white.b;
color1.a = white.a;
for (int i = 0; i < 4; i++) {
mFrameMaterial[i]->getTevBlock()->setTevColor(0, color0);
mFrameMaterial[i]->getTevBlock()->setTevColor(1, color1);
}
}
return true;
}
bool J2DWindowEx::getBlackWhite(JUtility::TColor* o_black, JUtility::TColor* o_white) const {
if (mFrameMaterial[0] == NULL) {
return false;
}
if (mFrameMaterial[0]->getTevBlock() == NULL) {
return false;
}
u32 stageNum = mFrameMaterial[0]->getTevBlock()->getTevStageNum();
bool cVar6 = stageNum == 1 ? false : true;
*o_black = JUtility::TColor(0);
*o_white = JUtility::TColor(0xffffffff);
if (cVar6) {
J2DGXColorS10 color0 = *mFrameMaterial[0]->getTevBlock()->getTevColor(0);
J2DGXColorS10 color1 = *mFrameMaterial[0]->getTevBlock()->getTevColor(1);
#define FAST_GX_COLOR_U32(r, g, b, a) (((u8)(r) << 0x18) | ((u8)(g) << 0x10) | ((u8)(b) << 0x8) | ((u8)(a)))
*o_black = JUtility::TColor(FAST_GX_COLOR_U32(color0.r, color0.g, color0.b, color0.a));
*o_white = JUtility::TColor(FAST_GX_COLOR_U32(color1.r, color1.g, color1.b, color1.a));
}
return true;
}
bool J2DWindowEx::isSetBlackWhite(JUtility::TColor param_0, JUtility::TColor param_1) const {
if ((u32)param_0 == 0 && (u32)param_1 == 0xffffffff) {
return true;
}
for (int i = 0; i < 4; i++) {
u8 stage = mFrameMaterial[i]->getTevBlock()->getMaxStage();
if (stage == 1) {
return false;
}
}
return true;
}
JUtility::TColor J2DWindowEx::getBlack() const {
JUtility::TColor black, white;
if (!getBlackWhite(&black, &white)) {
return JUtility::TColor(0);
}
return black;
}
JUtility::TColor J2DWindowEx::getWhite() const {
JUtility::TColor black, white;
if (!getBlackWhite(&black, &white)) {
return JUtility::TColor(0xffffffff);
}
return white;
}
void J2DWindowEx::setAlpha(u8 param_0) {
mAlpha = param_0;
for (int i = 0; i < 4; i++) {
if (mFrameMaterial[i] != NULL) {
if (mFrameMaterial[i]->getColorBlock()->getMatColor(0) != NULL) {
mFrameMaterial[i]->getColorBlock()->getMatColor(0)->a = param_0;
}
}
}
if (mContentsMaterial != NULL) {
if (mContentsMaterial->getColorBlock()->getMatColor(0) != 0) {
mContentsMaterial->getColorBlock()->getMatColor(0)->a = param_0;
}
}
}
void J2DWindowEx::setCullBack(GXCullMode param_0) {
mCullMode = param_0;
for (int i = 0; i < 4; i++) {
if (mFrameMaterial[i] != NULL) {
mFrameMaterial[i]->getColorBlock()->setCullMode(param_0);
}
}
if (mContentsMaterial != NULL) {
mContentsMaterial->getColorBlock()->setCullMode(param_0);
}
J2DPane::setCullBack(param_0);
}
void J2DWindowEx::rewriteAlpha() {
if (mContentsMaterial != NULL) {
mAlpha = mContentsMaterial->getColorBlock()->getMatColor(0)->a;
}
}
JUTTexture* J2DWindowEx::getFrameTexture(u8 param_0, u8 param_1) const {
J2DMaterial* frameMaterial = getFrameMaterial(param_0);
if (frameMaterial != NULL && frameMaterial->getTevBlock() != NULL) {
return frameMaterial->getTevBlock()->getTexture(param_1);
}
return NULL;
}
JUTTexture* J2DWindowEx::getContentsTexture(u8 param_0) const {
J2DMaterial* frameMaterial = getContentsMaterial();
if (frameMaterial != NULL && frameMaterial->getTevBlock() != NULL) {
return frameMaterial->getTevBlock()->getTexture(param_0);
}
return NULL;
}
bool J2DWindowEx::isUsed(ResTIMG const* timg) {
for (u8 i = 0; i < 4; i++) {
if (mFrameMaterial[i] != NULL && mFrameMaterial[i]->getTevBlock() != NULL) {
for (u32 j = 0; j < 8; j++) {
JUTTexture* texture = mFrameMaterial[i]->getTevBlock()->getTexture(j);
if (texture != NULL && texture->getTexInfo() == timg) {
return true;
}
}
}
}
if (mContentsMaterial != NULL && mContentsMaterial->getTevBlock() != NULL) {
for (u32 j = 0; j < 8; j++) {
JUTTexture* texture = mContentsMaterial->getTevBlock()->getTexture(j);
if (texture != NULL && texture->getTexInfo() == timg) {
return true;
}
}
}
return J2DPane::isUsed(timg);
}
void J2DWindowEx::setAnimation(J2DAnmColor* anmColor) {
for (u8 i = 0; i < 4; i++) {
if (isNeedSetAnm(i)) {
mFrameMaterial[i]->setAnimation(anmColor);
}
}
if (mContentsMaterial != NULL) {
mContentsMaterial->setAnimation(anmColor);
}
}
void J2DWindowEx::setAnimation(J2DAnmTextureSRTKey* param_0) {
for (u8 i = 0; i < 4; i++) {
if (isNeedSetAnm(i)) {
mFrameMaterial[i]->setAnimation(param_0);
}
}
if (mContentsMaterial != NULL) {
mContentsMaterial->setAnimation(param_0);
}
}
void J2DWindowEx::setAnimation(J2DAnmTexPattern* param_0) {
for (u8 i = 0; i < 4; i++) {
if (isNeedSetAnm(i)) {
mFrameMaterial[i]->setAnimation(param_0);
}
}
if (mContentsMaterial != NULL) {
mContentsMaterial->setAnimation(param_0);
}
}
void J2DWindowEx::setAnimation(J2DAnmTevRegKey* param_0) {
for (u8 i = 0; i < 4; i++) {
if (isNeedSetAnm(i)) {
mFrameMaterial[i]->setAnimation(param_0);
}
}
if (mContentsMaterial != NULL) {
mContentsMaterial->setAnimation(param_0);
}
}
bool J2DWindowEx::isNeedSetAnm(u8 param_0) {
for (u8 i = 0; i < param_0; i++) {
if (mFrameMaterial[i] == mFrameMaterial[param_0]) {
return false;
}
}
return mFrameMaterial[param_0] != NULL;
}
void J2DWindowEx::setAnimation(J2DAnmVisibilityFull* param_0) {
mAnmVisibilityFull = param_0;
}
void J2DWindowEx::setAnimation(J2DAnmVtxColor* param_0) {
mAnmVtxColor = param_0;
field_0x17c = 0;
if (param_0 != NULL) {
u16 uVar3 = param_0->getAnmTableNum(0);
for (u8 i = 0; i < 4; i++) {
if (field_0x168[i] != 0xffff) {
for (u16 j = 0; j < uVar3; j++) {
J3DAnmVtxColorIndexData* puVar1 = param_0->getAnmVtxColorIndexData(0, j);
BE(u16)* indexPointer2 =
param_0->getVtxColorIndexPointer(0) + (uintptr_t)puVar1->mpData;
for (u16 k = 0; k < puVar1->mNum; k++) {
if (indexPointer2[k] == field_0x168[i]) {
mAnmVtxColor = param_0;
field_0x17c |= 1 << i;
goto nexti;
}
}
}
}
nexti:;
}
}
if (field_0x17c == 0) {
mAnmVtxColor = NULL;
}
}
const J2DAnmTransform* J2DWindowEx::animationPane(J2DAnmTransform const* param_0) {
if (mAnmVisibilityFull != 0 && field_0x166 != 0xffff) {
u8 visibility;
mAnmVisibilityFull->getVisibility(field_0x166, &visibility);
if (visibility) {
J2DPane::show();
} else {
J2DPane::hide();
}
}
JUtility::TColor* local_38[4] = {
&field_0x128,
&field_0x12C,
&field_0x130,
&field_0x134,
};
if (mAnmVtxColor != NULL) {
u16 uVar3 = mAnmVtxColor->getAnmTableNum(0);
for (u8 i = 0; i < 4; i++) {
if ((field_0x17c & (1 << i))) {
for (u16 j = 0; j < uVar3; j++) {
J3DAnmVtxColorIndexData* puVar1 = mAnmVtxColor->getAnmVtxColorIndexData(0, j);
BE(u16)* indexPointer2 =
mAnmVtxColor->getVtxColorIndexPointer(0) + (uintptr_t)puVar1->mpData;
for (u16 k = 0; k < puVar1->mNum; k++) {
if (indexPointer2[k] == field_0x168[i]) {
mAnmVtxColor->getColor(0, j, local_38[i]);
goto nexti;
}
}
}
}
nexti:;
}
}
return J2DPane::animationPane(param_0);
}
J2DMaterial* J2DWindowEx::getFrameMaterial(u8 index) const {
if (index >= 4) {
return NULL;
}
return mFrameMaterial[index];
}
J2DMaterial* J2DWindowEx::getContentsMaterial() const {
return mContentsMaterial;
}
void J2DWindowEx::getMaterial(J2DWindow::TMaterial& param_0) const {
param_0.field_0x0 = mFrameMaterial[0];
param_0.field_0x4 = mFrameMaterial[1];
param_0.field_0x8 = mFrameMaterial[2];
param_0.field_0xc = mFrameMaterial[3];
param_0.field_0x10 = mContentsMaterial;
}
void J2DWindowEx::draw(f32 param_0, f32 param_1, f32 param_2, f32 param_3) {
draw(JGeometry::TBox2<f32>(JGeometry::TVec2<f32>(param_0, param_1),
JGeometry::TVec2<f32>(param_0 + param_2, param_1 + param_3)));
}
void J2DWindowEx::setCullBack(bool param_0) {
GXCullMode mode;
if (param_0) {
mode = GX_CULL_BACK;
} else {
mode = GX_CULL_NONE;
}
setCullBack(mode);
}
bool J2DWindowEx::isUsed(ResFONT const* param_0) {
return J2DPane::isUsed(param_0);
}
void J2DWindowEx::setAnimation(J2DAnmBase* param_0) {
J2DPane::setAnimation(param_0);
}
Reference in New Issue View Git Blame Copy Permalink