Started copying JStudio progress from pikmin2

2026-06-18 07:05:27 -04:00 · 2024-03-04 18:28:09 -05:00
parent 47f60f2733
commit cddc3efdcd
16 changed files with 715 additions and 89 deletions
@@ -0,0 +1,44 @@
+#ifndef JMESSAGE_CONTROL_H
+#define JMESSAGE_CONTROL_H
+
+#include "JSystem/JMessage/processor.h"
+#include "dolphin/types.h"
+
+namespace JMessage {
+struct TControl {
+    TControl();
+    virtual ~TControl();
+
+    void reset();
+    int update();
+    void render();
+    int setMessageCode(u16, u16);
+    int setMessageID(u32, u32, bool*);
+
+    bool isReady_update_() const { return pMessageText_begin_ != 0 && pSequenceProcessor_ != NULL; }
+    bool isReady_render_() const { return field_0x20 != 0 && pRenderingProcessor_ != NULL; }
+
+    TProcessor* getProcessor() const {
+        return pSequenceProcessor_ != NULL ? (TProcessor*)pSequenceProcessor_ :
+                                             (TProcessor*)pRenderingProcessor_;
+    }
+
+    const char* getMessageText_begin() const { return pMessageText_begin_; }
+    void* getMessageEntry() const { return pEntry_; }
+    void setSequenceProcessor(TSequenceProcessor* processor) { pSequenceProcessor_ = processor; }
+    void setRenderingProcessor(TRenderingProcessor* processor) { pRenderingProcessor_ = processor; }
+
+    /* 0x04 */ TSequenceProcessor* pSequenceProcessor_;
+    /* 0x08 */ TRenderingProcessor* pRenderingProcessor_;
+    /* 0x0C */ u16 messageCode_;
+    /* 0x0E */ u16 field_0xe;
+    /* 0x10 */ const TResource* pResourceCache_;
+    /* 0x14 */ void* pEntry_;
+    /* 0x18 */ const char* pMessageText_begin_;
+    /* 0x1C */ const char* pszText_update_current_;
+    /* 0x20 */ const char* field_0x20;
+    /* 0x24 */ TProcessor::TStack_ oStack_renderingProcessor_;
+};
+};  // namespace JMessage
+
+#endif /* JMESSAGE_CONTROL_H */
@@ -0,0 +1,195 @@
+#ifndef JMESSAGE_PROCESSOR_H
+#define JMESSAGE_PROCESSOR_H
+
+#include "JSystem/JMessage/resource.h"
+#include "dolphin/types.h"
+
+namespace JMessage {
+
+struct TReference;
+struct TControl;
+struct TResource;
+
+struct TProcessor {
+	typedef bool (*OnCharacterEndCallBack)(TProcessor*);
+	typedef void (*OnSelectBeginCallBack)(TProcessor*);
+	typedef const char* (*ProcessOnSelectCallBack)(TProcessor*);
+
+	struct TStack_ {
+		TStack_() { clear(); }
+
+		TStack_(const TStack_& other)
+		{
+			mSize = other.mSize;
+			for (int i = 0; i < mSize; i++) {
+				mStack[i] = mStack[i];
+			}
+		}
+
+		inline bool empty() const { return mSize == 0; }
+		inline bool isPushable() const { return mSize < 4; }
+		inline void clear() { mSize = 0; }
+
+		inline u32 getMaxSize() const { return 4; }
+		inline u32 getSize() const { return mSize; }
+		inline const char* getTop() const { return mStack[mSize - 1]; }
+
+		inline void push(const char* str)
+		{
+			mStack[mSize] = str;
+			mSize++;
+		}
+
+		inline void pop() { mSize--; }
+
+		u32 mSize;             // _00
+		const char* mStack[4]; // _04
+	};
+
+	struct TProcess {
+		struct TProcessData {
+			ProcessOnSelectCallBack mSelectCallback; // _00
+			const char* mBase;                       // _04
+			const void* mOffset;                     // _08
+			u32 mRest;                               // _0C
+		};
+
+		TProcess() { reset_normal(); }
+
+		void reset_normal() { mEndCallback = process_onCharacterEnd_normal_; }
+		void reset_select() { mEndCallback = process_onCharacterEnd_select_; }
+
+		OnCharacterEndCallBack mEndCallback; // _00
+		TProcessData mData;                  // _04
+	};
+
+	virtual ~TProcessor();                                     // _08
+	virtual void do_reset();                                   // _0C
+	virtual void do_character(int);                            // _10
+	virtual bool do_tag(u32, const void*, u32);                // _14
+	virtual bool do_systemTagCode(u16, const void*, u32);      // _18
+	virtual void do_select_begin(u32);                         // _1C
+	virtual void do_select_end();                              // _20
+	virtual void do_select_separate();                         // _24
+	virtual void do_reset_(const char*) = 0;                   // _28
+	virtual bool do_setBegin_isReady_() const;                 // _2C
+	virtual void do_begin_(const void*, const char*)      = 0; // _30
+	virtual void do_end_()                                = 0; // _34
+	virtual bool do_tag_(u32, const void*, u32)           = 0; // _38
+	virtual void do_systemTagCode_(u16, const void*, u32) = 0; // _3C
+
+	void setBegin_messageCode(u16, u16);
+	void setBegin_messageID(u32, u32, bool*);
+	void setBegin_messageCode(u32); // weak
+	TResource* getResource_groupID(u16) const;
+	u32 toMessageCode_messageID(u32, u32, bool*) const;
+	char* on_message_limited(u16) const;         // weak
+	char* on_message(u32) const;                 // weak
+	char* getMessageText_messageCode(u32) const; // weak
+	static bool process_onCharacterEnd_normal_(TProcessor*);
+	static bool process_onCharacterEnd_select_(TProcessor*);
+	static const char* process_onSelect_limited_(TProcessor*);
+	static const char* process_onSelect_(TProcessor*);
+	void reset_(const char*);
+
+	int setBegin_messageEntryText(const TResource* resource, const void* entry, const char* param_2)
+	{
+		mResourceCache = resource;
+		reset_(param_2);
+		do_begin_(entry, param_2);
+		return TRUE;
+	}
+
+	const TResource* getResourceCache() const { return mResourceCache; }
+	const char* getCurrent() const { return mCurrent; }
+	const TReference* getReference() const { return mReference; }
+
+	// Unused/inlined:
+	void pushCurrent(const char*);
+	const char* popCurrent();
+	void on_select_begin(OnSelectBeginCallBack* p1, const char* p2, const void* p3, const char* p4, u32 p5);
+	void on_select_end();
+	void on_select_separate();
+	void on_tag_();
+	void process_character_();
+
+	// _00 = VTBL
+	const TReference* mReference;    // _04
+	const TResource* mResourceCache; // _08
+	const char* mCurrent;            // _0C
+	TStack_ mStack;                   // _10
+	TProcess mProcess;               // _24
+};
+
+struct TSequenceProcessor : public TProcessor {
+	typedef void OnJumpRegisterCallBack(TSequenceProcessor*);
+	typedef void OnBranchRegisterCallBack(TSequenceProcessor*, u32);
+	typedef void* ProcessOnJumpCallBack(const TSequenceProcessor*);
+
+	TSequenceProcessor(const TReference*, TControl*);
+
+	virtual ~TSequenceProcessor();                         // _08
+	virtual void do_reset_(const char*);                   // _28
+	virtual bool do_setBegin_isReady_() const;             // _2C
+	virtual void do_begin_(const void*, const char*);      // _30
+	virtual void do_end_();                                // _34
+	virtual bool do_tag_(u32, const void*, u32);           // _38
+	virtual void do_systemTagCode_(u16, const void*, u32); // _3C
+	virtual void do_begin(const void*, const char*);       // _40
+	virtual void do_end();                                 // _44
+	virtual bool do_isReady();                             // _48
+	virtual bool do_jump_isReady();                        // _4C
+	virtual void do_jump(const void*, const char*);        // _50
+	virtual void do_branch_query(u16);                     // _54
+	virtual int do_branch_queryResult();                   // _58
+	virtual void do_branch(const void*, const char*);      // _5C
+
+	char* process(const char*);
+	bool on_isReady();
+	void on_jump_isReady();
+	void on_jump(const void*, const char*);
+	void on_branch_queryResult();
+	void on_branch(const void*, const char*);
+	void process_onJump_limited_(const TSequenceProcessor*);
+	static void* process_onJump_(const TSequenceProcessor*);
+	void process_onBranch_limited_(const TSequenceProcessor*, u32);
+	void process_onBranch_(const TSequenceProcessor*, u32);
+
+	// Unused/inlined:
+	const char* toString_status(int);
+	int toValue_status(const char*);
+	void on_jump_register(OnJumpRegisterCallBack*, const void*, u32);
+	void on_branch_register(OnBranchRegisterCallBack*, const void*, const void*, u32);
+	void on_branch_query(u16);
+	void process_setMessageIndex_reserved_(u16);
+	void process_setMessageCode_(const TSequenceProcessor*, u16, u16);
+
+	// _00     = VTBL
+	// _00-_38 = TProcessor
+	TControl* _38;              // _38
+	int _3C;                    // _3C
+	ProcessOnJumpCallBack* _40; // _40 - processorCallBack(void*, ulong) pointer?
+	u32 _44;                    // _44
+	u32 _48;                    // _48
+};
+
+struct TRenderingProcessor : public TProcessor {
+	TRenderingProcessor(const TReference*);
+
+	virtual ~TRenderingProcessor();                        // _08
+	virtual void do_reset_(const char*);                   // _28
+	virtual void do_begin_(const void*, const char*);      // _30
+	virtual void do_end_();                                // _34
+	virtual bool do_tag_(u32, const void*, u32);           // _38
+	virtual void do_systemTagCode_(u16, const void*, u32); // _3C
+	virtual void do_begin(const void*, const char*);       // _40
+	virtual void do_end();                                 // _44
+
+	void process(const char*);
+
+	// _00     = VTBL
+	// _00-_38 = TProcessor
+};
+} // namespace JMessage
+
+#endif /* JMESSAGE_PROCESSOR_H */
@@ -183,6 +183,9 @@ public:
    void setGlobalRTMatrix(MtxP mtx) {
        JPASetRMtxTVecfromMtx(mtx, mGlobalRotation, mGlobalTranslation);
    }
+    void setGlobalSRTMatrix(MtxP mtx) {
+        JPASetRMtxSTVecfromMtx(mtx, mGlobalRotation, mGlobalDynamicsScale, mGlobalTranslation);
+    }
    void setGlobalRotation(const JGeometry::TVec3<s16>& rot) {
        JPAGetXYZRotateMtx(rot.x, rot.y, rot.z, mGlobalRotation);
    }
@@ -290,7 +293,6 @@ public:
    void setGlobalParticleHeightScale(f32) {}
    void setGlobalParticleScale(f32, f32) {}
    void setGlobalParticleWidthScale(f32) {}
-    void setGlobalSRTMatrix(MtxP) {}

    static JPAEmitterInfo emtrInfo;

@@ -30,8 +30,10 @@ struct TFactory : public stb::TFactory {

 class TControl : public stb::TControl {
 public:
-    struct TTransform_translation_rotation_scaling {};
    struct TTransform_position {};
+    struct TTransform_position_direction {};
+    struct TTransform_translation_rotation {};
+    struct TTransform_translation_rotation_scaling {};

    TControl();
    virtual ~TControl();
@@ -47,7 +49,9 @@ public:
        fvb_destroyObject_all();
    }

+    bool transformOnSet_isEnabled() const { return mTransformOnSet; }
    void transformOnSet_enable(bool param_0) { mTransformOnSet = param_0; }
+    bool transformOnGet_isEnabled() const { return mTransformOnGet; }
    void transformOnGet_enable(bool param_0) { mTransformOnGet = param_0; }

    void transform_enable(bool param_0) {
@@ -60,6 +64,10 @@ public:
        transformOnGet_setOrigin(xyz, rotY);
    }

+    f32 transformOnSet_getRotationY() const { return mTransformOnSet_RotationY; }
+    CMtxP transformOnSet_getMatrix() const { return mTransformOnSet_Matrix; }
+    CMtxP transformOnGet_getMatrix() const { return mTransformOnGet_Matrix; }
+
    void setSecondPerFrame(f64 param_0) { mSecondPerFrame = param_0; }
    f64 getSecondPerFrame() const { return mSecondPerFrame; }

@@ -87,6 +95,33 @@ public:
        } 
        return obj->referFunctionValue();
    }
+    
+    void fvb_getObjectContainer() const {}
+    void fvb_referControl() {}
+    void fvb_removeObject_all() {}
+    void stb_getObjectContainer() const {}
+    void stb_referObjectContainer() {}
+    void stb_removeObject(JStudio::TObject*) {}
+    void transformOnGet_transform(const JStudio::TControl::TTransform_position&, JStudio::TControl::TTransform_position*) const {}
+    void transformOnGet_transform(const JStudio::TControl::TTransform_position_direction&, JStudio::TControl::TTransform_position_direction*) const {}
+    void transformOnGet_transform(const JStudio::TControl::TTransform_translation_rotation&, JStudio::TControl::TTransform_translation_rotation*) const {}
+    void transformOnGet_transformDirection(const Vec&, Vec*) const {}
+    void transformOnGet_transformRotation(const Vec&, Vec*) const {}
+    void transformOnGet_transformTranslation(const Vec&, Vec*) const {}
+    void transformOnGet_transform_ifEnabled(const JStudio::TControl::TTransform_position_direction&, JStudio::TControl::TTransform_position_direction*) const {}
+    void transformOnGet_transform_ifEnabled(const JStudio::TControl::TTransform_translation_rotation&, JStudio::TControl::TTransform_translation_rotation*) const {}
+    void transformOnSet_transform(const JStudio::TControl::TTransform_position&, JStudio::TControl::TTransform_position*) const {}
+    void transformOnSet_transform(const JStudio::TControl::TTransform_position_direction&, JStudio::TControl::TTransform_position_direction*) const {}
+    void transformOnSet_transform(const JStudio::TControl::TTransform_translation_rotation&, JStudio::TControl::TTransform_translation_rotation*) const {}
+    void transformOnSet_transform(CMtxP, MtxP) const {}
+    void transformOnSet_transformDirection(const Vec&, Vec*) const {}
+    void transformOnSet_transformDirection_ifEnabled(const Vec&, Vec*) const {}
+    void transformOnSet_transformRotation(const Vec&, Vec*) const {}
+    void transformOnSet_transformTranslation(const Vec&, Vec*) const {}
+    void transformOnSet_transformTranslation_ifEnabled(const Vec&, Vec*) const {}
+    void transformOnSet_transform_ifEnabled(const JStudio::TControl::TTransform_position_direction&, JStudio::TControl::TTransform_position_direction*) const {}
+    void transformOnSet_transform_ifEnabled(const JStudio::TControl::TTransform_translation_rotation&, JStudio::TControl::TTransform_translation_rotation*) const {}
+    void transformOnSet_transform_ifEnabled(CMtxP, MtxP) const {}

    /* 0x58 */ f64 mSecondPerFrame;
    /* 0x60 */ fvb::TControl fvb_Control;
@@ -14,6 +14,7 @@ namespace data {
        UNK_0x3 = 0x3,
        UNK_0x10 = 0x10,
        UNK_0x12 = 0x12,
+        UNK_0x18 = 0x18,
        UNK_0x19 = 0x19,
    };
 };
@@ -108,6 +109,7 @@ public:

    TAdaptor* getAdaptor() { return mpAdaptor; }
    TControl* getControl() { return (TControl*)stb::TObject::getControl(); }
+    const TControl* getControl() const { return (const TControl*)stb::TObject::getControl(); }

    void prepareAdaptor() {
        if (mpAdaptor != NULL) {
@@ -133,10 +135,22 @@ public:
 };

 struct TAdaptor {
-    struct TSetVariableValue_immediate {
-        u32 field_0x0;
-        f32 field_0x4;
-    };
+	inline TAdaptor(TVariableValue* values, int count)
+	    : pValue_(values)
+	    , u(count)
+	{
+	}
+
+	struct TSetVariableValue_immediate {
+		inline TSetVariableValue_immediate(u32 p1, f32 p2)
+		    : _00(p1)
+		    , _04(p2)
+		{
+		}
+
+		u32 _00; // _00
+		f32 _04; // _04
+	};
    typedef void (*setVarFunc)(JStudio::TAdaptor*, JStudio::TObject*, u32, void const*, u32);
    virtual ~TAdaptor() = 0;
    virtual void adaptor_do_prepare(const JStudio::TObject*);
@@ -277,6 +291,11 @@ struct TObject_light : public TObject {
 };

 struct TAdaptor_message : public TAdaptor {
+	inline TAdaptor_message()
+	    : TAdaptor(NULL, 0)
+	{
+	}
+
    virtual ~TAdaptor_message() = 0;
 };

@@ -289,17 +308,22 @@ struct TObject_message : public TObject {
 };

 struct TAdaptor_particle : public TAdaptor {
+	TAdaptor_particle()
+	    : TAdaptor(mValue, ARRAY_SIZE(mValue))
+	    , mValue()
+	{
+	}
    virtual ~TAdaptor_particle() = 0;

    /* 0x10 */ TVariableValue mValue[20];

-    static u8 const sauVariableValue_3_TRANSLATION_XYZ[12];
-    static u8 const sauVariableValue_3_ROTATION_XYZ[12];
-    static u8 const sauVariableValue_3_SCALING_XYZ[12];
-    static u8 const sauVariableValue_3_COLOR_RGB[12];
-    static u8 const sauVariableValue_4_COLOR_RGBA[16];
-    static u8 const sauVariableValue_3_COLOR1_RGB[12];
-    static u8 const sauVariableValue_4_COLOR1_RGBA[16];
+    static u32 const sauVariableValue_3_TRANSLATION_XYZ[12];
+    static u32 const sauVariableValue_3_ROTATION_XYZ[12];
+    static u32 const sauVariableValue_3_SCALING_XYZ[12];
+    static u32 const sauVariableValue_3_COLOR_RGB[12];
+    static u32 const sauVariableValue_4_COLOR_RGBA[16];
+    static u32 const sauVariableValue_3_COLOR1_RGB[12];
+    static u32 const sauVariableValue_4_COLOR1_RGBA[16];
 };

 struct TObject_particle : public TObject {
@@ -0,0 +1,34 @@
+#ifndef JSTUDIO_JMESSAGE_CONTROL_H
+#define JSTUDIO_JMESSAGE_CONTROL_H
+
+#include "JSystem/JStudio/JStudio/jstudio-object.h"
+#include "JSystem/JMessage/control.h"
+
+namespace JStudio_JMessage {
+struct TCreateObject_base : JStudio::TCreateObject {
+	virtual ~TCreateObject_base() = 0;                                                                       // _08
+	virtual bool create(JStudio::TObject** newObject, const JStudio::stb::data::TParse_TBlock_object& data); // _0C
+	virtual JMessage::TControl* find(const JStudio::stb::data::TParse_TBlock_object&) = 0;                   // _10
+};
+} // namespace JStudio_JMessage
+
+namespace JStudio_JMessage {
+struct TCreateObject : public TCreateObject_base {
+	TCreateObject(JMessage::TControl* control) { mControl = control; }
+
+	virtual ~TCreateObject();                                                          // _08
+	virtual JMessage::TControl* find(const JStudio::stb::data::TParse_TBlock_object&); // _10
+
+	JMessage::TControl* mControl; // _0C
+};
+
+struct TAdaptor_message : public JStudio::TAdaptor_message {
+	virtual ~TAdaptor_message();                                                       // _08
+	virtual void adaptor_do_MESSAGE(JStudio::data::TEOperationData, const void*, u32); // _20
+
+	TAdaptor_message(JMessage::TControl*);
+	JMessage::TControl* mControl; // _10
+};
+} // namespace JStudio_JMessage
+
+#endif /* JSTUDIO_JMESSAGE_CONTROL_H */
@@ -0,0 +1,6 @@
+#ifndef OBJECT_MESSAGE_H
+#define OBJECT_MESSAGE_H
+
+#include "JSystem/JStudio/JStudio_JMessage/control.h"
+
+#endif /* OBJECT_MESSAGE_H */
@@ -0,0 +1,67 @@
+#ifndef JSTUDIO_JPARTICLE_CONTROL_H
+#define JSTUDIO_JPARTICLE_CONTROL_H
+
+#include "JSystem/JParticle/JPAParticle.h"
+#include "JSystem/JStage/JSGSystem.h"
+#include "JSystem/JStudio/JStudio/jstudio-object.h"
+
+namespace JStudio_JParticle {
+struct TCreateObject : public JStudio::TCreateObject {
+    TCreateObject(JPAEmitterManager* p_emitMgr, const JStage::TSystem* p_system) {
+        pJPAEmitterManager_ = p_emitMgr;
+        pJSGSystem_ = p_system;
+        mPermit_onExit_notEnd = false;
+    }
+
+    virtual ~TCreateObject();
+    virtual bool create(JStudio::TObject**, JStudio::stb::data::TParse_TBlock_object const&);
+
+    /* 0x0C */ JPAEmitterManager* pJPAEmitterManager_;
+    /* 0x10 */ const JStage::TSystem* pJSGSystem_;
+    /* 0x14 */ bool mPermit_onExit_notEnd;
+};
+
+struct TAdaptor_particle : public JStudio::TAdaptor_particle {
+	struct TJPACallback_ : JPACallBackBase<JPABaseEmitter*> {
+		inline TJPACallback_(TAdaptor_particle* adaptor)
+		    : mAdaptor(adaptor)
+		    , mObject(NULL)
+		{
+		}
+
+		virtual ~TJPACallback_() { }           // _08 (weak)
+		virtual void execute(JPABaseEmitter*); // _0C
+
+		TAdaptor_particle* mAdaptor;     // _04
+		const JStudio::TObject* mObject; // _08
+	};
+
+    TAdaptor_particle(JPAEmitterManager*, const JStage::TSystem*);
+    void beginParticle_fadeIn_();
+    void endParticle_fadeOut_(u32);
+
+    virtual ~TAdaptor_particle();
+    virtual void adaptor_do_prepare(const JStudio::TObject*);
+    virtual void adaptor_do_end(const JStudio::TObject*);
+    virtual void adaptor_do_update(const JStudio::TObject*, u32);
+    virtual void adaptor_do_PARTICLE(JStudio::data::TEOperationData, void const*, u32);
+    virtual void adaptor_do_PARENT(JStudio::data::TEOperationData, void const*, u32);
+    virtual void adaptor_do_PARENT_NODE(JStudio::data::TEOperationData, void const*, u32);
+    virtual void adaptor_do_PARENT_ENABLE(JStudio::data::TEOperationData, void const*, u32);
+
+	/* 0x19C */ JPAEmitterManager* mEmitterManager;
+	/* 0x1A0 */ JPABaseEmitter* mEmitter;
+	/* 0x1A4 */ TJPACallback_ mCallback;
+	/* 0x1B0 */ int _188;
+	/* 0x1B4 */ u32 _18C;
+	/* 0x1B8 */ u32 _190;
+	/* 0x1BC */ u32 _194;
+	/* 0x1C0 */ const JStage::TSystem* mSystem;
+	/* 0x1C4 */ JStage::TObject* _19C;
+	/* 0x1C8 */ u32 _1A0;
+	/* 0x1CC */ bool _1A4;
+};  // Size: 0x1D0
+
+};  // namespace JStudio_JParticle
+
+#endif /* JSTUDIO_JPARTICLE_CONTROL_H */
@@ -0,0 +1,6 @@
+#ifndef OBJECT_PARTICLE_H
+#define OBJECT_PARTICLE_H
+
+#include "JSystem/JStudio/JStudio_JParticle/control.h"
+
+#endif /* OBJECT_PARTICLE_H */