JAHostIO, JAWExtSystem debug (#2985)

include/JSystem/J2DGraph/J2DOrthoGraph.h

@@ -19,8 +19,8 @@ public:
     virtual s32 getGrafType() const { return 1; }
     virtual void setLookat();
 
-    f32 getWidthPower() const { return mBounds.getWidth() / mOrtho.getWidth(); }
-    f32 getHeightPower() const { return mBounds.getHeight() / mOrtho.getHeight(); }
+    f32 getWidthPower() { return mBounds.getWidth() / mOrtho.getWidth(); }
+    f32 getHeightPower() { return mBounds.getHeight() / mOrtho.getHeight(); }
 
     void setOrtho(f32 x, f32 y, f32 width, f32 height, f32 far, f32 near) {
         JGeometry::TBox2<f32> ortho(x, y, x + width, y + height);

include/JSystem/J2DGraph/J2DPrint.h

@@ -40,6 +40,11 @@ public:
 
     virtual ~J2DPrint();
 
+    JUTFont* getFont() const { return mFont; }
+    f32 getCursorV() const { return mCursorV; }
+    void setCharColor(JUtility::TColor color) { mCharColor = color; }
+    void setGradColor(JUtility::TColor color) { mGradColor = color; }
+
     f32 print_va(u8 alpha, const char* fmt, va_list args) {
         return J2DPrint_print_alpha_va(this, alpha, fmt, args);
     }

include/JSystem/J2DGraph/J2DTevs.h

@@ -256,15 +256,15 @@ public:
 private:
     /* 0x0 */ u32 mFlags;
 
-    GXIndTexStageID getIndStage() const { return (GXIndTexStageID)(mFlags & 0x03); }
-    GXIndTexFormat getIndFormat() const { return (GXIndTexFormat)((mFlags >> 2) & 0x03); }
-    GXIndTexBiasSel getBiasSel() const { return (GXIndTexBiasSel)((mFlags >> 4) & 0x07); }
-    GXIndTexWrap getWrapS() const { return (GXIndTexWrap)((mFlags >> 8) & 0x07); }
-    GXIndTexWrap getWrapT() const { return (GXIndTexWrap)((mFlags >> 11) & 0x07); }
-    GXIndTexMtxID getMtxSel() const { return (GXIndTexMtxID)((mFlags >> 16) & 0x0F); }
-    GXBool getPrev() const { return (GXBool)((mFlags >> 20) & 0x01); }
-    GXBool getLod() const { return (GXBool)((mFlags >> 21) & 0x01); }
-    GXIndTexAlphaSel getAlphaSel() const { return (GXIndTexAlphaSel)((mFlags >> 22) & 0x03); }
+    u8 getIndStage() const { return (mFlags & 0x03); }
+    u8 getIndFormat() const { return (mFlags >> 2) & 0x03; }
+    u8 getBiasSel() const { return (mFlags >> 4) & 0x07; }
+    u8 getWrapS() const { return (mFlags >> 8) & 0x07; }
+    u8 getWrapT() const { return (mFlags >> 11) & 0x07; }
+    u8 getMtxSel() const { return (mFlags >> 16) & 0x0F; }
+    u8 getPrev() const { return (mFlags >> 20) & 0x01; }
+    u8 getLod() const { return (mFlags >> 21) & 0x01; }
+    u8 getAlphaSel() const { return (mFlags >> 22) & 0x03; }
 };
 
 /**

include/JSystem/J2DGraph/J2DTextBox.h

@@ -171,7 +171,9 @@ public:
     /* 0x0130 */ u8 mFlags;
     /* 0x0131 */ bool mTextFontOwned;
     /* 0x0132 */ u16 mStringLength;
+#if PLATFORM_GCN
     /* 0x0134 */ u8 field_0x134[4];
+#endif
 };  // Size: 0x138
 
 #endif /* J2DTEXTBOX_H */

include/JSystem/J2DGraph/J2DWindow.h

@@ -7,6 +7,13 @@
 class JSURandomInputStream;
 class JUTTexture;
 
+enum J2DTextureBase {
+    TEXTUREBASE_0 = 0,
+};
+
+enum J2DWindowMirror {
+};
+
 /**
  * @ingroup jsystem-j2d
  * 
@@ -32,8 +39,12 @@ public:
     J2DWindow(J2DPane*, JSURandomInputStream*, J2DMaterial*);
     J2DWindow(J2DPane*, JSURandomInputStream*, JKRArchive*);
     J2DWindow();
+    J2DWindow(u64, const JGeometry::TBox2<f32>&, const char*, J2DTextureBase, const ResTLUT*);
+    void initiate(const ResTIMG*, const ResTIMG*, const ResTIMG*, const ResTIMG*, const ResTLUT*, J2DWindowMirror, const JGeometry::TBox2<f32>&);
     void private_readStream(J2DPane*, JSURandomInputStream*, JKRArchive*);
+    void initinfo();
     void initinfo2();
+    static J2DWindowMirror convertMirror(J2DTextureBase);
     void draw_private(JGeometry::TBox2<f32> const&, JGeometry::TBox2<f32> const&);
     void setContentsColor(JUtility::TColor, JUtility::TColor, JUtility::TColor,
                                          JUtility::TColor);

include/JSystem/JAHNodeLib/JAHSoundPlayerNode.h

@@ -0,0 +1,11 @@
+#ifndef JAHSOUNDPLAYERNODE_H
+#define JAHSOUNDPLAYERNODE_H
+
+#include "JSystem/JAHostIO/JAHFrameNode.h"
+
+class JAHSoundPlayerNode : public JAHFrameNode {
+public:
+    JAHSoundPlayerNode();
+};
+
+#endif /* JAHSOUNDPLAYERNODE_H */

include/JSystem/JAHostIO/JAHFrameNode.h

@@ -0,0 +1,29 @@
+#ifndef JAHFRAMENODE_H
+#define JAHFRAMENODE_H
+
+#include "dolphin/types.h"
+#include "JSystem/JAHostIO/JAHioNode.h"
+
+class JAHVirtualNode;
+
+class JAHFrameNode : public JAHioNode {
+public:
+    JAHFrameNode(const char*);
+    /* vt[07] */ virtual ~JAHFrameNode();
+    /* vt[02] */ virtual void listenPropertyEvent(const JORPropertyEvent*);
+    /* vt[05] */ virtual void genMessage(JORMContext*);
+    /* vt[06] */ virtual void listenNodeEvent(const JORNodeEvent*);
+    /* vt[0C] */ virtual s32 getNodeType();
+    /* vt[11] */ virtual void onCurrentNodeFrame();
+    /* vt[12] */ virtual void onFrame();
+
+    void framework();
+    void currentFramework();
+
+    JSULink<JAHFrameNode>* getFrameNodeLink() { return &mFrameNodeLink; }
+
+    /* 0x44 */ JSUTree<JAHVirtualNode> mTree;
+    /* 0x60 */ JSULink<JAHFrameNode> mFrameNodeLink;
+};
+
+#endif /* JAHFRAMENODE_H */

include/JSystem/JAHostIO/JAHPubDefine.h

@@ -0,0 +1,29 @@
+#ifndef JAHPUBDEFINE_H
+#define JAHPUBDEFINE_H
+
+#include "JSystem/JUtility/JUTAssert.h"
+
+template<class T>
+class JAHSingletonBase {
+public:
+    JAHSingletonBase() { sInstance = (T*)this; }
+    virtual ~JAHSingletonBase() { sInstance = NULL; }
+
+    static T* newInstance() {
+        JUT_ASSERT(82, sInstance==NULL);
+        if (!sInstance) {
+            sInstance = new T();
+        }
+        JUT_ASSERT(85, sInstance!=NULL);
+        return sInstance;
+    }
+
+    static T* getIns() {
+        JUT_ASSERT(110, sInstance);
+        return sInstance;
+    }
+
+    static T* sInstance;
+};
+
+#endif /* JAHPUBDEFINE_H */

include/JSystem/JAHostIO/JAHUTableEdit.h

@@ -0,0 +1,11 @@
+#ifndef JAHUTABLEDIT_H
+#define JAHUTABLEDIT_H
+
+#include "JSystem/JAHostIO/JAHVirtualNode.h"
+
+class JAHUSeBox : public JAHVirtualNode {
+public:
+    JAHUSeBox();
+};
+
+#endif /* JAHUTABLEDIT_H */

include/JSystem/JAHostIO/JAHVirtualNode.h

@@ -0,0 +1,23 @@
+#ifndef JAHVIRTUALNODE_H
+#define JAHVIRTUALNODE_H
+
+#include "JSystem/JAHostIO/JAHioNode.h"
+#include "JSystem/JSupport/JSUList.h"
+
+class JAHControl;
+
+class JAHVirtualNode {
+public:
+    JAHVirtualNode();
+    virtual void updateNode();
+    virtual void message(JAHControl&);
+    virtual void onFrame();
+    virtual void onCurrentNodeFrame();
+    virtual void propertyEvent(JAH_P_Event, u32);
+    virtual void nodeEvent(JAH_N_Event);
+
+    /* 0x04 */ JSUTree<JAHVirtualNode> mTree;
+    /* 0x20 */ char mName[32];
+};
+
+#endif /* JAHVIRTUALNODE_H */

include/JSystem/JAHostIO/JAHioMessage.h

@@ -0,0 +1,52 @@
+#ifndef JAHIOMESSAGE_H
+#define JAHIOMESSAGE_H
+
+#include "dolphin/types.h"
+
+class JAHioNode;
+class JORMContext;
+
+class JAHControl {
+public:
+    JAHControl(JORMContext*, JAHioNode*);
+    void returnY(u16);
+    void indent(s8);
+    void makeComment(const char*, u32, u8, u32);
+
+    static u16 getLineHeight() { return smLineHeight; }
+    static u16 getContWidth() { return smContWidth; }
+    static u16 getIntervalX() { return smIntX; }
+    static u16 getNameWidth() { return smNameWidth; }
+
+    static u16 smButtonWidth[];
+    static u16 smCommentWidth[];
+    static u16 smComboWidth[];
+    static u16 smYTop;
+    static u16 smXLeft;
+    static u16 smIndentSize;
+    static u16 smLineHeight;
+    static u16 smContWidth;
+    static u16 smIntX;
+    static u16 smIntY;
+    static u16 smNameWidth;
+
+    u16 getX() { return mX; }
+    u16 getY() { return mY; }
+    JORMContext* getContext() { return mContext; }
+
+    void tabX(u16 param_1) {
+        mX += param_1 + smIntX;
+    }
+    void returnYDirectSize(u16 param_1) {
+        mY += param_1;
+        mX = smXLeft + field_0x4 * smIndentSize;
+    }
+
+    /* 0x00 */ u16 mX;
+    /* 0x02 */ u16 mY;
+    /* 0x04 */ u16 field_0x4;
+    /* 0x08 */ JORMContext* mContext;
+    /* 0x0C */ JAHioNode* mNode;
+};
+
+#endif /* JAHIOMESSAGE_H */

include/JSystem/JAHostIO/JAHioMgr.h

@@ -0,0 +1,28 @@
+#ifndef JAHIOMGR_H
+#define JAHIOMGR_H
+
+#include "JSystem/JAHostIO/JAHPubDefine.h"
+#include "JSystem/JSupport/JSUList.h"
+
+class JAHFrameNode;
+class JAHioNode;
+class JORReflexible;
+
+class JAHioMgr : public JAHSingletonBase<JAHioMgr> {
+public:
+    JAHioMgr();
+    void init_OnGame();
+    bool isGameMode();
+    void appendRootNode(JORReflexible*, JAHioNode*);
+    void appendFrameNode(JAHioNode*);
+    void removeFrameNode(JAHioNode*);
+    u32 framework();
+
+    u32 getNodeSysType() { return field_0x8; }
+
+    /* 0x04 */ s32 field_0x4;
+    /* 0x08 */ u32 field_0x8;
+    JSUList<JAHFrameNode> field_0xc;
+};
+
+#endif /* JAHIOMGR_H */

include/JSystem/JAHostIO/JAHioNode.h

@@ -0,0 +1,55 @@
+#ifndef JAHIONODE_H
+#define JAHIONODE_H
+
+#include "JSystem/JHostIO/JORReflexible.h"
+#include "JSystem/JSupport/JSUList.h"
+
+enum JAH_N_Event {
+    JAH_N_EVENT0 = 0,
+    JAH_N_EVENT1 = 1,
+    JAH_N_EVENT2 = 2,
+};
+
+enum JAH_P_Event {
+    JAH_P_EVENT0 = 0,
+    JAH_P_EVENT1 = 1,
+};
+
+class JAHControl;
+
+class JAHioNode : public JORReflexible {
+public:
+    JAHioNode(const char*);
+    /* vt[07] */ virtual ~JAHioNode();
+    /* vt[02] */ virtual void listenPropertyEvent(const JORPropertyEvent*);
+    /* vt[05] */ virtual void genMessage(JORMContext*);
+    /* vt[06] */ virtual void listenNodeEvent(const JORNodeEvent*);
+    /* vt[08] */ virtual void message(JAHControl&) {}
+    /* vt[09] */ virtual void appendNode(JAHioNode*, const char*);
+    /* vt[0A] */ virtual void prependNode(JAHioNode*, const char*);
+    /* vt[0B] */ virtual void removeNode(JAHioNode*);
+    /* vt[0C] */ virtual s32 getNodeType() { return 0; }
+    /* vt[0D] */ virtual u32 getNodeKind() const;
+    /* vt[0E] */ virtual u32 getNodeIcon() const { return 0; }
+    /* vt[0F] */ virtual void propertyEvent(JAH_P_Event, u32) {}
+    /* vt[10] */ virtual void nodeEvent(JAH_N_Event) {}
+    void updateNode();
+    void setNodeName(const char*);
+    void generateRealChildren(JORMContext*);
+    void generateTempChildren(JORMContext*);
+    JAHioNode* getParent();
+
+    static JAHioNode* getCurrentNode() { return smCurrentNode; }
+
+    static JAHioNode* smCurrentNode;
+
+    JSUTree<JAHioNode>* getTree() { return &mTree; }
+    char* getNodeName() { return mName; }
+    void setLastChild(JAHioNode* node) { mLastChild = node; }
+
+    /* 0x04 */ JSUTree<JAHioNode> mTree;
+    /* 0x20 */ char mName[32];
+    /* 0x40 */ JAHioNode* mLastChild;
+};
+
+#endif /* JAHIONODE_H */

include/JSystem/JAHostIO/JAHioUtil.h

@@ -0,0 +1,10 @@
+#ifndef JAHIOUTIL_H
+#define JAHIOUTIL_H
+
+namespace JAHioUtil {
+    char* getString(const char* msg, ...);
+
+    extern char mStringBuffer[];
+}
+
+#endif /* JAHIOUTIL_H */

include/JSystem/JAWExtSystem/JAWExtSystem.h

@@ -0,0 +1,49 @@
+#ifndef JAWEXTSYSTEM_H
+#define JAWEXTSYSTEM_H
+
+#include "JSystem/JAWExtSystem/JAWSystem.h"
+#include "JSystem/JGadget/std-list.h"
+
+class JAWWindow;
+class JUTGamePad;
+
+namespace JAWExtSystem {
+    BOOL registWindow(u32, JAWWindow*, int, int);
+    BOOL destroyWindow(u32, JAWWindow*);
+    void nextPage();
+    void prevPage();
+    void nextWindow();
+    void prevWindow();
+    void draw();
+    void padProc(const JUTGamePad&);
+
+    class TSystemInterface : public JAWSystemInterface {
+    public:
+        TSystemInterface() {}
+        virtual BOOL registWindow(u32 param_1, JAWWindow* param_2, int param_3, int param_4) {
+            return JAWExtSystem::registWindow(param_1, param_2, param_3, param_4);
+        }
+        virtual BOOL destroyWindow(u32 param_1, JAWWindow* param_2) {
+            return JAWExtSystem::destroyWindow(param_1, param_2);
+        }
+        virtual void setForegroundWindow(JAWWindow*) {}
+    };
+
+    class TCurrentHeap {
+    public:
+        TCurrentHeap(const TSystemInterface& interface) {
+            heap = JKRGetCurrentHeap();
+            JKRSetCurrentHeap(interface.getCurrentHeap());
+        }
+        ~TCurrentHeap() { JKRSetCurrentHeap(heap); }
+
+        /* 0x00 */ JKRHeap* heap;
+    };
+
+    extern JGadget::TList<JAWWindow*> sPage[128];
+    extern TSystemInterface sInterface;
+    extern s32 sCurrentPage;
+    extern u8 lbl_80748E44;
+}
+
+#endif  /* JAWEXTSYSTEM_H */

include/JSystem/JAWExtSystem/JAWGraphContext.h

@@ -0,0 +1,43 @@
+#ifndef JAWGRAPHCONTEXT_H
+#define JAWGRAPHCONTEXT_H
+
+#include "JSystem/JUtility/TColor.h"
+#include "JSystem/JGeometry.h"
+
+class J2DPrint;
+class JUTResFont;
+
+class JAWGraphContext {
+public:
+    JAWGraphContext();
+    ~JAWGraphContext();
+    void reset();
+    void color(u8, u8, u8, u8);
+    void color(const JUtility::TColor&);
+    void locate(int, int);
+    void print(char const*, ...);
+    void print(int, int, const char*, ...);
+    void color(const JUtility::TColor&, const JUtility::TColor&, const JUtility::TColor&, const JUtility::TColor&);
+    void fillBox(const JGeometry::TBox2<f32>&);
+    void drawFrame(const JGeometry::TBox2<f32>&);
+    void line(const JGeometry::TVec2<f32>&, const JGeometry::TVec2<f32>&);
+    void setGXforPrint();
+    void setGXforDraw();
+
+    /* 0x00 */ J2DPrint* field_0x0;
+    /* 0x04 */ JUtility::TColor field_0x4;
+    /* 0x08 */ JUtility::TColor field_0x8;
+    /* 0x0C */ JUtility::TColor field_0xc;
+    /* 0x10 */ JUtility::TColor field_0x10;
+    /* 0x14 */ u8 mParentAlpha;
+    /* 0x15 */ u8 field_0x15;
+    /* 0x16 */ u8 field_0x16;
+    /* 0x18 */ int field_0x18;
+
+    void setParentAlpha(u8 alpha) { mParentAlpha = alpha; }
+
+    static JUTResFont* sFont;
+    static bool lbl_8074CD30;
+};
+
+#endif /* JAWGRAPHCONTEXT_H */

include/JSystem/JAWExtSystem/JAWSystem.h

@@ -0,0 +1,22 @@
+#ifndef JAWSYSTEM_H
+#define JAWSYSTEM_H
+
+#include "JSystem/JKernel/JKRHeap.h"
+
+class JAWWindow;
+
+class JAWSystemInterface {
+public:
+    JAWSystemInterface();
+    virtual BOOL registWindow(u32, JAWWindow*, int, int) = 0;
+    virtual BOOL destroyWindow(u32, JAWWindow*) = 0;
+    virtual void setForegroundWindow(JAWWindow*) = 0;
+
+    /* 0x04 */ JKRHeap* mHeap;
+
+    JKRHeap* getCurrentHeap() const;
+
+    static JAWSystemInterface* sInstance;
+};
+
+#endif /* JAWSYSTEM_H */

include/JSystem/JAWExtSystem/JAWWindow.h

@@ -0,0 +1,112 @@
+#ifndef JAWWINDOW_H
+#define JAWWINDOW_H
+
+#include "JSystem/JAWExtSystem/JAWGraphContext.h"
+#include "JSystem/J2DGraph/J2DTextBox.h"
+#include "JSystem/J2DGraph/J2DWindow.h"
+#include "JSystem/JGeometry.h"
+
+class JAWGraphContext;
+class JUTGamePad;
+
+class JUTPoint {
+public:
+    JUTPoint(int i_x, int i_y) {
+        x = i_x;
+        y = i_y;
+    }
+
+    /* 0x00*/ int x;
+    /* 0x04*/ int y;
+};
+
+class JAWWindow {
+public:
+    class TJ2DWindowDraw : public J2DWindow {
+    public:
+        TJ2DWindowDraw(u32, const JGeometry::TBox2<f32>&, const char*);
+
+        void drawPane(int x, int y, const J2DGrafContext* p_grafCtx) {
+            J2DPane::draw(x, y, p_grafCtx, true, true);
+            calcMtx();
+        }
+    };
+
+    class TWindowText : public J2DPane {
+    public:
+        TWindowText(JAWWindow*);
+        virtual void drawSelf(f32, f32);
+        virtual void drawSelf(f32, f32, Mtx*);
+
+        /* 0x0FC */ JAWGraphContext field_0xfc;
+        /* 0x118 */ JAWWindow* m_pParent;
+        /* 0x11C */ JUTPoint field_0x11c;
+    };
+
+    JAWWindow(const char*, int, int);
+    virtual ~JAWWindow();
+    virtual void onDraw(JAWGraphContext*);
+    virtual BOOL onInit();
+    virtual void frameWork() {}
+    virtual void onPadProc(const JUTGamePad&) {}
+    virtual void onTrigA(const JUTGamePad&) {}
+    virtual void onTrigB(const JUTGamePad&) {}
+    virtual void onTrigX(const JUTGamePad&) {}
+    virtual void onTrigY(const JUTGamePad&) {}
+    virtual void onTrigMenu(const JUTGamePad&) {}
+    virtual void onTrigL(const JUTGamePad&) {}
+    virtual void onTrigZ(const JUTGamePad&) {}
+    virtual void onTrigUp(const JUTGamePad&) {}
+    virtual void onTrigDown(const JUTGamePad&) {}
+    virtual void onTrigLeft(const JUTGamePad&) {}
+    virtual void onTrigRight(const JUTGamePad&) {}
+    virtual void onReleaseA(const JUTGamePad&) {}
+    virtual void onReleaseB(const JUTGamePad&) {}
+    virtual void onReleaseX(const JUTGamePad&) {}
+    virtual void onReleaseY(const JUTGamePad&) {}
+    virtual void onReleaseMenu(const JUTGamePad&) {}
+    virtual void onReleaseL(const JUTGamePad&) {}
+    virtual void onReleaseZ(const JUTGamePad&) {}
+    virtual void onReleaseUp(const JUTGamePad&) {}
+    virtual void onReleaseDown(const JUTGamePad&) {}
+    virtual void onReleaseLeft(const JUTGamePad&) {}
+    virtual void onReleaseRight(const JUTGamePad&) {}
+    virtual void onKeyA(const JUTGamePad&) {}
+    virtual void onKeyB(const JUTGamePad&) {}
+    virtual void onKeyX(const JUTGamePad&) {}
+    virtual void onKeyY(const JUTGamePad&) {}
+    virtual void onKeyMenu(const JUTGamePad&) {}
+    virtual void onKeyL(const JUTGamePad&) {}
+    virtual void onKeyZ(const JUTGamePad&) {}
+    virtual void onKeyUp(const JUTGamePad&) {}
+    virtual void onKeyDown(const JUTGamePad&) {}
+    virtual void onKeyLeft(const JUTGamePad&) {}
+    virtual void onKeyRight(const JUTGamePad&) {}
+
+    BOOL initIf();
+    void setTitleColor(const JUtility::TColor&, const JUtility::TColor&);
+    void setWindowColor(const JUtility::TColor&, const JUtility::TColor&, const JUtility::TColor&, const JUtility::TColor&);
+    void move(f32, f32);
+    void addPosition(f32, f32);
+    void addSize(f32, f32);
+    static JUtility::TColor convJudaColor(u16);
+    void padProc(const JUTGamePad&);
+
+    /* 0x004 */ Mtx mMatrix;
+    /* 0x034 */ u8 field_0x34[0x38 - 0x34];
+    /* 0x038 */ TJ2DWindowDraw field_0x38;
+    /* 0x180 */ J2DTextBox field_0x180;
+    /* 0x2B0 */ TWindowText field_0x2b0;
+    /* 0x3D8 */ JUtility::TColor field_0x3d8;
+    /* 0x3DC */ JUtility::TColor field_0x3dc;
+    /* 0x3E0 */ JUtility::TColor field_0x3e0;
+    /* 0x3E4 */ JUtility::TColor field_0x3e4;
+    /* 0x3E8 */ int field_0x3e8;
+    /* 0x3EC */ u8 field_0x3ec;
+
+    void setMatrix(Mtx mtx) { MTXCopy(mtx, mMatrix); }
+    void setAlpha(u8 alpha) { field_0x38.setAlpha(alpha); }
+    void draw(int x, int y, const J2DGrafContext* p_grafCtx) { field_0x38.drawPane(x, y, p_grafCtx); }
+};
+
+#endif /* JAWWINDOW_H */

include/JSystem/JAWExtSystem/JAWWindow3D.h

@@ -0,0 +1,10 @@
+#ifndef JAWWINDOW3D_H
+#define JAWWINDOW3D_H
+
+#include "JSystem/JGeometry.h"
+
+namespace JAWWindow3D {
+    extern JGeometry::TVec2<f32> sPtOrigin;
+}
+
+#endif /* JAWWINDOW3D_H */

include/JSystem/JAWWinLib/JAWBankView.h

@@ -0,0 +1,20 @@
+#ifndef JAWBANKVIEW_H
+#define JAWBANKVIEW_H
+
+#include "JSystem/JAWExtSystem/JAWWindow.h"
+
+class JAWBankView : public JAWWindow {
+public:
+    JAWBankView();
+
+    /* 0x3F0 */ int field_0x3f0;
+    /* 0x3F4 */ int field_0x3f4;
+    /* 0x3F8 */ int field_0x3f8;
+    /* 0x3FC */ int field_0x3fc;
+    /* 0x400 */ u8 field_0x400;
+    /* 0x404 */ int field_0x404;
+    /* 0x408 */ f32 field_0x408;
+    /* 0x40C */ u8 field_0x40c[4];
+};
+
+#endif /* JAWBANKVIEW_H */