diff --git a/configure.py b/configure.py index b930d607..61d65144 100755 --- a/configure.py +++ b/configure.py @@ -1100,7 +1100,7 @@ def MatchingFor(*versions): Object(Matching, "Kameda/PrintDvdError.cpp"), Object(NonMatching, "Kameda/Race2D.cpp"), Object(Matching, "Kameda/ReadPrintMessage.cpp"), - Object(NonMatching, "Kameda/PrintProgressive.cpp"), + Object(Matching, "Kameda/PrintProgressive.cpp"), Object(NonMatching, "Kameda/PrintMemoryCard.cpp"), Object(NonMatching, "Kameda/PreRace2D.cpp"), Object(Matching, "Kameda/Go2D.cpp"), diff --git a/include/Kameda/PrintProgressive.h b/include/Kameda/PrintProgressive.h index 286456f2..724e027e 100644 --- a/include/Kameda/PrintProgressive.h +++ b/include/Kameda/PrintProgressive.h @@ -1,13 +1,18 @@ #ifndef PRINTPROGRESSIVE_H #define PRINTPROGRESSIVE_H -#include +#include "JSystem/J2D/J2DGrafContext.h" +#include "JSystem/J2D/J2DPane.h" +#include "JSystem/J2D/J2DPicture.h" +#include "JSystem/J2D/J2DScreen.h" +#include "JSystem/JKernel/JKRArchive.h" +#include "JSystem/JKernel/JKRHeap.h" #include "types.h" class PrintProgressive { public: - enum MessageID // according to debug test screen + enum MessageID // according to debug test screen { mcShow_Dialog, mcSet_Option1, @@ -15,29 +20,54 @@ class PrintProgressive mcShow_Logo, mcShow_Set }; - PrintProgressive(JKRHeap *); // 0x8016aac4 - void init(MessageID); // 0x8016b138 - void draw(); // 0x8016b65c - void calc(int); // 0x8016b6dc - void isMessage(); // 0x8016bc28 - void isChoice(); // 0x8016bcbc - void getCounter(); // 0x8016bd48 - // Inline/Unused + + PrintProgressive(JKRHeap *heap); // 0x8016aac4 ~PrintProgressive(); + + void init(MessageID messageID); // 0x8016b138 + void draw(); // 0x8016b65c void calc_bck(); void calc_texChange(); - void setCounter(int); + void calc(int param); // 0x8016b6dc + bool isMessage(); // 0x8016bc28 + bool isChoice(); // 0x8016bcbc + s32 getCounter(); // 0x8016bd48 + void setCounter(int counter); - int getState() { return _68; } - int getOption() { return _6c; } + int getState() { return mState; } + int getOption() { return mOption; } private: - // TODO - u8 _0[0x64]; - MessageID mMsgId; - int _68; - int _6c; - u8 _70[0x94 -0x70]; -}; // Size: 0x94 + void *mColorRes; // 0x0 + void *mProgressiveScanRes; // 0x4 + void *mYesNoRes; // 0x8 + J2DOrthoGraph *mOrthoGraph; // 0xc + JKRArchive *mArchive; // 0x10 + J2DScreen *mScreenLogo; // 0x14 + J2DScreen *mScreenProgressive; // 0x18 + J2DPicture *mPane; // 0x1c + J2DTextBox *mTextBox; // 0x20 + J2DTextBox *mTextBoxYes; // 0x24 + J2DTextBox *mTextBoxNo; // 0x28 + J2DTextBox *mTextBoxNum; // 0x2c + J2DPicture *mPictureYes; // 0x30 + J2DPicture *mPictureNo; // 0x34 + J2DPicture *mPictureNintendo; // 0x38 + J2DPicture *mPictureDolby; // 0x3c + J2DAnmTransform *mTransform; // 0x40 + J2DAnmColor *mColors[4]; // 0x44 + J2DAnmTextureSRTKey *mSTRKey; // 0x54 + s32 mTransformFrame; // 0x58 + s32 mSTRKeyFrame; // 0x5c + s32 mFrame; // 0x60 + MessageID mMsgId; // 0x64 + int mState; // 0x68 + int mOption; // 0x6c + s32 mColorsFrame; // 0x70 + J2DTextBox::TFontSize mFontSize; // 0x74 + J2DTextBox::TFontSize mFontSizeYes; // 0x7c + J2DTextBox::TFontSize mFontSizeNo; // 0x84 + u8 _8c[8]; // 0x8c +}; // Size: 0x94 -#endif // PRINTPROGRESSIVE_H +#endif // PRINTPROGRESSIVE_H diff --git a/src/Kameda/PrintProgressive.cpp b/src/Kameda/PrintProgressive.cpp index 8eb1311b..5306a2ec 100644 --- a/src/Kameda/PrintProgressive.cpp +++ b/src/Kameda/PrintProgressive.cpp @@ -1,17 +1,524 @@ #include "Kameda/PrintProgressive.h" -PrintProgressive::PrintProgressive(JKRHeap *) {} +#include "Osako/kartPad.h" +#include "string.h" -void PrintProgressive::init(PrintProgressive::MessageID) {} +#include "Inagaki/GameAudioMain.h" +#include "JSystem/J2D/J2DAnmLoader.h" +#include "JSystem/J2D/J2DPicture.h" +#include "JSystem/JAudio/JASFakeMatch.h" // For static initializer +#include "JSystem/JKernel/JKRArchive.h" +#include "JSystem/JKernel/JKRFileLoader.h" +#include "JSystem/JUtility/JUTAssert.h" +#include "Kameda/ReadPrintMessage.h" +#include "Osako/FontMgr.h" +#include "Osako/ResMgr.h" +#include "Osako/system.h" -void PrintProgressive::draw() {} +PrintProgressive::PrintProgressive(JKRHeap *heap) +{ + mOrthoGraph = System::getJ2DOrtho(); -void PrintProgressive::calc(int) {} + mArchive = JKRMountArchive(ResMgr::getPtr(ResMgr::mcArcSystem, "Screen/progressive.arc"), + heap, + JKRArchive::MOUNT_DIRECTION_HEAD); -void PrintProgressive::isMessage() {} + mScreenLogo = new (heap, 0) J2DScreen(); + mScreenLogo->J2DScreen::set("NintendoLogo.blo", 0x40000, mArchive); -void PrintProgressive::isChoice() {} + mScreenProgressive = new (heap, 0) J2DScreen(); + mScreenProgressive->J2DScreen::set("progressive.blo", 0x40000, mArchive); -void PrintProgressive::getCounter() {} + mTransform = (J2DAnmTransform *)J2DAnmLoaderDataBase::load( + JKRFileLoader::getGlbResource("Progressive.bck", mArchive)); + mScreenProgressive->setAnimation(mTransform); -#include "JSystem/JAudio/JASFakeMatch.h" + { + J2DPicture *pane = (J2DPicture *)mScreenProgressive->search('n_an'); +#line 49 + JUT_ASSERT(pane->getTypeID() == J2DPane_Picture); + mPane = pane; + } + + mTextBox = (J2DTextBox *)mScreenProgressive->search('T_tx1'); + mTextBox->setFont(FontMgr::mspResFont); + mTextBox->getFontSize(mFontSize); + + mTextBoxYes = (J2DTextBox *)mScreenProgressive->search('T_yes'); + mTextBoxYes->setFont(FontMgr::mspResFont); + mTextBoxYes->getFontSize(mFontSizeYes); + + mTextBoxNo = (J2DTextBox *)mScreenProgressive->search('T_no'); + mTextBoxNo->setFont(FontMgr::mspResFont); + mTextBoxNo->getFontSize(mFontSizeNo); + + mTextBoxNum = (J2DTextBox *)mScreenProgressive->search('Num1'); + mTextBoxNum->setFont(FontMgr::mspResFont); + + { + J2DPicture *pane = (J2DPicture *)mScreenProgressive->search('lyes'); +#line 66 + JUT_ASSERT(pane->getTypeID() == J2DPane_Picture); + mPictureYes = pane; + } + mPictureYes->setAnimation(mTransform); + + { + J2DPicture *pane = (J2DPicture *)mScreenProgressive->search('lno'); +#line 72 + JUT_ASSERT(pane->getTypeID() == J2DPane_Picture); + mPictureNo = pane; + } + mPictureNo->setAnimation(mTransform); + + { + J2DPicture *pane = (J2DPicture *)mScreenLogo->search('m_nin1'); +#line 78 + JUT_ASSERT(pane->getTypeID() == J2DPane_Picture); + mPictureNintendo = pane; + } + + { + J2DPicture *pane = (J2DPicture *)mScreenLogo->search('Dlby0'); +#line 83 + JUT_ASSERT(pane->getTypeID() == J2DPane_Picture); + mPictureDolby = pane; + } + + void *resource = JKRGetNameResource("Progressive.bpk", mArchive); + for (int i = 0; i < 4; ++i) + { + mColors[i] = (J2DAnmColor *)J2DAnmLoaderDataBase::load(resource); + mColors[i]->searchUpdateMaterialID(mScreenProgressive); + } + + mTextBoxYes->setAnimation(mColors[0]); + mTextBoxNo->setAnimation(mColors[1]); + mPictureYes->setAnimation(mColors[2]); + mPictureNo->setAnimation(mColors[3]); + + mSTRKey = (J2DAnmTextureSRTKey *)J2DAnmLoaderDataBase::load( + JKRFileLoader::getGlbResource("Progressive.btk", mArchive)); + mScreenProgressive->setAnimation(mSTRKey); + + mColorRes = ResMgr::getPtr(ResMgr::mcColor); + mProgressiveScanRes = ResMgr::getPtr(ResMgr::mcProgressiveScan); + mYesNoRes = ResMgr::getPtr(ResMgr::mcYesNo); + + JUTColor color = + ReadPrintMessage::getColor(mColorRes, + ReadPrintMessage::getDefaultColor(mProgressiveScanRes)); + mTextBox->setFontColor(color, color); + + char buffer[512]; + for (int i = 0; i < 512; ++i) + { + buffer[i] = ' '; + } + buffer[511] = '\0'; + mTextBox->setString(buffer); + buffer[15] = '\0'; + mTextBoxYes->setString(buffer); + mTextBoxNo->setString(buffer); + buffer[1] = '\0'; + mTextBoxNum->setString(buffer); +} + +void PrintProgressive::init(PrintProgressive::MessageID messageID) +{ + mMsgId = messageID; + + mState = 2; + mColorsFrame = 0; + + if (isChoice()) + { + mOption = 0; + } + else + { + mOption = 2; + } + + if (isChoice()) + { + mPane->show(); + mTextBoxNum->show(); + } + else + { + mPane->hide(); + mTextBoxNum->hide(); + } + + if (isMessage()) + { + mTextBox->show(); + } + else + { + mTextBox->hide(); + } + + if (isMessage()) + { + int bmgMessageID = ReadPrintMessage::getBmgMessageID(mMsgId); + char *message = ReadPrintMessage::getMessage(mProgressiveScanRes, bmgMessageID); + + mTextBox->setFontSize( + mFontSize.x * ReadPrintMessage::getRate(mProgressiveScanRes, bmgMessageID) / 100.0f, + mFontSize.y * ReadPrintMessage::getRate(mProgressiveScanRes, bmgMessageID) / 100.0f); + + mTextBox->setCharSpace(ReadPrintMessage::getCharSpace(mProgressiveScanRes, bmgMessageID)); + + J2DTextBox::TFontSize fontSize; + mTextBox->getFontSize(fontSize); + char buf[512]; + ReadPrintMessage::tagCnv(message, mColorRes, fontSize, sizeof(buf), buf); + strncpy(mTextBox->getStringPtr(), buf, sizeof(buf)); + } + + { + char *message = ReadPrintMessage::getMessage(mYesNoRes, 1); + + mTextBoxYes->setFontSize(mFontSizeYes.x * ReadPrintMessage::getRate(mYesNoRes, 1) / 100.0f, + mFontSizeYes.y * ReadPrintMessage::getRate(mYesNoRes, 1) / 100.0f); + + mTextBoxYes->setCharSpace(ReadPrintMessage::getCharSpace(mYesNoRes, 1)); + + J2DTextBox::TFontSize fontSize; + mTextBoxYes->getFontSize(fontSize); + char buf[16]; + ReadPrintMessage::tagCnv(message, mColorRes, fontSize, sizeof(buf), buf); + strncpy(mTextBoxYes->getStringPtr(), buf, sizeof(buf)); + } + + { + char *message = ReadPrintMessage::getMessage(mYesNoRes, 0); + + mTextBoxNo->setFontSize(mFontSizeNo.x * ReadPrintMessage::getRate(mYesNoRes, 0) / 100.0f, + mFontSizeNo.y * ReadPrintMessage::getRate(mYesNoRes, 0) / 100.0f); + + mTextBoxNo->setCharSpace(ReadPrintMessage::getCharSpace(mYesNoRes, 0)); + + J2DTextBox::TFontSize fontSize; + mTextBoxNo->getFontSize(fontSize); + char buf[16]; + ReadPrintMessage::tagCnv(message, mColorRes, fontSize, sizeof(buf), buf); + strncpy(mTextBoxNo->getStringPtr(), buf, sizeof(buf)); + } + + switch (mMsgId) + { + case mcShow_Logo: + mPictureNintendo->show(); + mPictureDolby->hide(); + break; + case mcShow_Set: + mPictureNintendo->hide(); + mPictureDolby->show(); + break; + default: + mPictureNintendo->hide(); + mPictureDolby->hide(); + break; + } + + mTransformFrame = 0; + mSTRKeyFrame = 0; + mFrame = 539; +} + +PrintProgressive::~PrintProgressive() +{ + // Unknown implementation. +} + +void PrintProgressive::draw() +{ + mOrthoGraph->setPort(); + + switch (mMsgId) + { + case mcShow_Logo: + case mcShow_Set: + mScreenLogo->draw(0.0f, 0.0f, mOrthoGraph); + break; + default: + mScreenProgressive->draw(0.0f, 0.0f, mOrthoGraph); + } +} + +void PrintProgressive::calc_bck() +{ + if (isChoice()) + { + mTransformFrame += 1; + if (mTransformFrame < 0) + { + mTransformFrame = 0; + } + if (mTransformFrame > 8) + { + mTransformFrame = 8; + } + + switch (mOption) + { + case 0: + mTransform->setFrame(mTransformFrame); + mPictureYes->animationTransform(); + mTransform->setFrame(0.0f); + mPictureNo->animationTransform(); + break; + case 1: + mTransform->setFrame(0.0f); + mPictureYes->animationTransform(); + mTransform->setFrame(mTransformFrame); + mPictureNo->animationTransform(); + break; + } + } +} + +void PrintProgressive::calc_texChange() +{ + if (isChoice()) + { + if (mFrame > 0) + { + mFrame -= 1; + } + else + { + mFrame = 0; + } + + char buff[2]; + buff[0] = getCounter() + '0'; + buff[1] = '\0'; + strcpy(mTextBoxNum->getStringPtr(), buff); + } + + if (mFrame <= 0 && mState == 2) + { + GameAudio::Main::getAudio()->startSystemSe(0x20003); + + switch (mOption) + { + case 0: + mState = 0; + break; + case 1: + mState = 1; + break; + default: +#line 328 + JUT_ASSERT(0); + } + } +} + +void PrintProgressive::calc(int param) +{ + if (param >= 0) + { + mFrame = param * 60; + } + + switch (mMsgId) + { + case mcShow_Logo: + case mcShow_Set: + return; + default: + break; + } + + if (isChoice()) + { + if (gpaGamePad[0]->testTrigger(JUTGamePad::A)) + { + if (mState == 2) + { + switch (mOption) + { + case 0: + mState = 0; + GameAudio::Main::getAudio()->startSystemSe(0x20003); + break; + case 1: + mState = 1; + GameAudio::Main::getAudio()->startSystemSe(0x2000c); + break; + default: +#line 372 + JUT_ASSERT(0); + } + } + } + else if (gpaGamePad[0]->testRepeat(JUTGamePad::MAINSTICK_LEFT)) + { + if (mState == 2) + { + switch (mOption) + { + case 1: + GameAudio::Main::getAudio()->startSystemSe(0x20000); + mOption = 0; + mColorsFrame = 0; + mTransformFrame = 0; + break; + } + } + } + else if (gpaGamePad[0]->testRepeat(JUTGamePad::MAINSTICK_RIGHT)) + { + if (mState == 2) + { + switch (mOption) + { + case 0: + GameAudio::Main::getAudio()->startSystemSe(0x20000); + mOption = 1; + mColorsFrame = 0; + mTransformFrame = 0; + break; + } + } + } + } + else + { + for (int i = 0; i < 1; ++i) // To match reference assembly; iterator not even used. + { + if (gpaGamePad[0]->testTrigger(JUTGamePad::A)) + { + if (mState == 2) + { + mState = 0; + } + } + } + } + + mSTRKeyFrame += 1; + if (mSTRKeyFrame < 0) + { + mSTRKeyFrame = 0; + } + if (mSTRKeyFrame > 359) + { + mSTRKeyFrame = 0; + } + mSTRKey->setFrame(mSTRKeyFrame); + + if (isChoice()) + { + switch (mOption) + { + case 0: + mColors[0]->setFrame(1.0f); + mColors[1]->setFrame(0.0f); + if (mColorsFrame++ + 1 >= 359) + { + mColorsFrame = 0; + } + mColors[2]->setFrame(mColorsFrame); + mColors[3]->setFrame(0.0f); + break; + case 1: + mColors[0]->setFrame(0.0f); + mColors[1]->setFrame(1.0f); + if (mColorsFrame++ + 1 >= 359) + { + mColorsFrame = 0; + } + mColors[2]->setFrame(0.0f); + mColors[3]->setFrame(mColorsFrame); + break; + default: +#line 465 + JUT_ASSERT(0); + } + } + + mScreenProgressive->animation(); + + calc_bck(); + calc_texChange(); +} + +bool PrintProgressive::isMessage() +{ + bool result; + + switch (mMsgId) + { + case mcShow_Dialog: + case mcSet_Option1: + case mcSet_Option2: + result = true; + break; + case mcShow_Logo: + case mcShow_Set: + result = false; + break; + default: +#line 497 + JUT_ASSERT(0); + } + + return result; +} + +bool PrintProgressive::isChoice() +{ + bool result; + + switch (mMsgId) + { + case mcShow_Dialog: + result = true; + break; + case mcSet_Option1: + case mcSet_Option2: + case mcShow_Logo: + case mcShow_Set: + result = false; + break; + default: +#line 524 + JUT_ASSERT(0); + } + + return result; +} + +s32 PrintProgressive::getCounter() +{ + s32 counter = -1; + + switch (mMsgId) + { + case mcShow_Dialog: + if (mFrame != 0) + { + counter = mFrame / 60 + 1; + } + else + { + counter = 0; + } + break; + default: + break; + } + + return counter; +} + +void PrintProgressive::setCounter(int counter) +{ + // Unknown implementation. +}