#ifndef __KAMEK_GAME_H
#define __KAMEK_GAME_H

#include <common.h>
#include <rvl/mtx.h>
#include <rvl/GXEnum.h>
#include <rvl/vifuncs.h>
#include <rvl/arc.h>


extern "C" {
int strlen(const char *str);

float atan(float x);
float atan2(float y, float x);

float cos(float x);
float sin(float x);
}

bool DVD_Start();
bool DVD_End();
bool DVD_StillLoading(void *dvdclass2);
void DVD_LoadFile(void *dvdclass, char *folder, char *file, void *callbackData);
void DVD_FreeFile(void *dvdclass2, char *file);

extern void *DVDClass;

inline void *GetDVDClass() {
	return DVDClass;
}

inline void *GetDVDClass2() {
	return (void*)(((u32)GetDVDClass())+4);
}

void *DVD_GetFile(void *dvdclass2, const char *arc, const char *file);


extern int Player_Active[4];
extern int Player_ID[4];
extern int Player_Powerup[4];
extern int Player_Flags[4];
extern int Player_Lives[4];
extern int Player_Coins[4];

struct StartLevelInfo {
	int maybeUnused;
	unsigned char unk1; // 0x04
	unsigned char unk2; // 0x05
	unsigned char unk3; // 0x06
	unsigned char unk4; // 0x07
	unsigned int purpose; // 0x08
	unsigned char world1; // 0x0C
	unsigned char level1; // 0x0D
	unsigned char world2; // 0x0E
	unsigned char level2; // 0x0F
};

extern void *GameMgr;
inline void *GetGameMgr() {
	return GameMgr;
}

bool QueryPlayerAvailability(int id);
void DoStartLevel(void *gameMgr, StartLevelInfo *sl);
void SetSomeConditionShit(int world, int level, unsigned int bits);

bool IsWideScreen();

#define GAMEMGR_GET_AFC(gmgr) (*((bool*)(((u32)(gmgr))+0xAFC)))


#define COND_COIN1 1
#define COND_COIN2 2
#define COND_COIN3 4
#define COND_NORMAL 0x10
#define COND_SECRET 0x20
#define COND_SGNORMAL 0x80
#define COND_SGSECRET 0x100

class SaveFirstBlock {
public:
	char titleID[4];			// 0x00
	u8 field_00;				// 0x04
	u8 field_01;				// 0x05
	u8 current_file;			// 0x06
	u8 field_03;				// 0x07
	u16 freemode_fav[10][0x2A];	// 0x08
	u16 coinbtl_fav[10][0x2A];	// 0x350
	u16 bitfield;				// 0x698
	u16 field_69A;				// 0x69A
	u32 checksum;				// 0x69C
};

class SaveBlock {
public:
	u8 field_00;				// 0x00
	u8 field_01;				// 0x01
	u8 bitfield;				// 0x02
	u8 current_world;			// 0x03
	u8 field_04;				// 0x04
	u8 current_path_node;		// 0x05
	u8 field_06;				// 0x06
	u8 switch_on;				// 0x07
	u8 field_08;				// 0x08
	u8 powerups_available[7];	// 0x09
	u8 toad_level_idx[10];		// 0x10
	u8 player_continues[4];		// 0x1A
	u8 player_coins[4];			// 0x1E
	u8 player_lives[4];			// 0x22
	u8 player_flags[4];			// 0x26
	u8 player_type[4];			// 0x2A
	u8 player_powerup[4];		// 0x2E
	u8 worlds_available[10];	// 0x32
	u32 ambush_countdown[10];	// 0x3C
	u16 field_64;				// 0x64
	u16 credits_hiscore;		// 0x66
	u16 score;					// 0x68
	u32 completions[10][0x2A];	// 0x6C
	u8 hint_movie_bought[70];	// 0x6FC
	u8 toad_location[10];		// 0x742
	u8 field_74C[10][4];		// 0x74C
	u8 field_774[10][4];		// 0x774
	u8 field_79C[10][4];		// 0x79C
	u8 death_counts[10][0x2A];	// 0x7C4
	u8 death_count_3_4_switch;	// 0x968
	u8 pad[0x13];				// 0x969
	u32 checksum;				// 0x97C

	u32 GetLevelCondition(int world, int level);
	bool CheckLevelCondition(int world, int level, int cond);
	bool CheckIfCoinCollected(int world, int level, int num);
};

class SaveFile {
public:
	u32 field_00;
	u32 field_04;
	u32 field_08;
	u32 field_0C;
	u32 field_10;
	u32 field_14;
	u32 field_18;
	u32 field_1C;

	// Real Savefile starts here
	SaveFirstBlock header;
	SaveBlock blocks[3];
	SaveBlock quickSave[3];

	SaveBlock *GetBlock(int id);
	SaveBlock *GetQSBlock(int id);

	bool CheckIfWriting(); // 0x800E0540
};

class SaveHandler {
public:
	u8 unknown[0x70];
	u32 CurrentState;
	u32 CurrentError;
	u32 field_7C;
};

extern SaveFile *SaveFileInstance;
extern SaveHandler *SaveHandlerInstance;

inline SaveFile *GetSaveFile() {
	return SaveFileInstance;
}

inline SaveHandler *GetSaveHandler() {
	return SaveHandlerInstance;
}

#define WPAD_DOWN	0x0001 // Actually Left, but rotated
#define WPAD_UP		0x0002 // Actually Right, but rotated
#define WPAD_RIGHT	0x0004 // Actually Down, but rotated
#define WPAD_LEFT	0x0008 // Actually Up, but rotated
#define WPAD_PLUS	0x0010
#define WPAD_TWO	0x0100
#define WPAD_ONE	0x0200
#define WPAD_B		0x0400
#define WPAD_A		0x0800
#define WPAD_MINUS	0x1000
#define WPAD_HOME	0x8000

struct RemoconMngClass {
	void *vtable;
	void *controllers[4];
};

/*
 * Ok, here's how the remocon/wiimote shit works:
 * Remocon is a NSMB-specific class, it handles the different control methods
 * and D-pad directions and such automatically.
 *
 * Wiimote is a generic class (part of EGG) -- well it's not actually called
 * that, but who cares. It handles different types of controllers. Only
 * query it if whatever you're accessing is control type dependent.
 */

extern RemoconMngClass *RemoconMng;
extern int ActiveWiimoteID;
extern void *ActiveWiimote;

inline RemoconMngClass *GetRemoconMng() {
	return RemoconMng;
}

inline int GetActiveWiimoteID() {
	return ActiveWiimoteID;
}

inline void *GetActiveRemocon() {
	return GetRemoconMng()->controllers[GetActiveWiimoteID()];
}

inline void *GetActiveWiimote() {
	return ActiveWiimote;
}

inline unsigned int Remocon_GetButtons(void *self) {
	return *((unsigned int*)((u32)self+0x18));
}

inline unsigned int Remocon_GetPressed(void *self) {
	return *((unsigned int*)((u32)self+0x1C));
}

typedef bool (*__Wiimote_TestButtons_type)(void*, unsigned int);
inline bool Wiimote_TestButtons(void *self, unsigned int btns) {
	VF_BEGIN(__Wiimote_TestButtons_type, self, 8, 0)
		return VF_CALL(self, btns);
	VF_END;
}

int SearchForIndexOfPlayerID(int id);

bool CheckIfContinueShouldBeActivated();

bool CheckIfMenuShouldBeCancelledForSpecifiedWiimote(int num);

void StartTitleScreenStage(bool realDemo, int sceneParam);

bool CheckIfWeCantDoStuff();

u32 QueryGlobal5758(u32 check);

void SaveGame(void *classDoesntMatter, bool isQuick);

#include <actors.h>
void *CreateParentedObject(short classID, void *parent, int settings, char something);
void *CreateChildObject(short classID, void *parent, int settings, int unk1, int unk2);


#define WIPE_FADE 0
#define WIPE_CIRCLE 1
#define WIPE_BOWSER 2
#define WIPE_WAVY 3
#define WIPE_MARIO 4
#define WIPE_CIRCLE_s 5

void ActivateWipe(int type);

typedef void (*ScreenDrawFunc)();

extern ScreenDrawFunc *CurrentDrawFunc;
void WorldMapDrawFunc();
void GameSetupDrawFunc();

void GameSetup__LoadScene(void *self); // 0x80919560
void FreeScene(int id);

void WpadShit(int unk); // 0x8016F780

void *BgTexMng__LoadAnimTile(void *self, int tileset, short tile, char *name, char *delays, char reverse); // 0x80087B60

extern void *GameHeaps[];



namespace nw4r {

namespace ut {
	// this isn't 100% accurate because it doesn't use templates
	// or detail::LinkListImpl, but oh well
	// I don't need the methods anyway.

	class LinkListNode {
	public:
		LinkListNode *next;
		LinkListNode *prev;
	};

	class LinkList {
	public:
		int count;
		LinkListNode initialNode;
	};

	class Color : public GXColor { };

	class Rect {
	public:
		f32 left;
		f32 top;
		f32 right;
		f32 bottom;
	};

	template <class T>
	class TagProcessorBase { };
}

namespace lyt {
	class Pane; // forward declaration
	class DrawInfo;

	class AnimTransform; // I'll do these later
	class AnimResource;
	class AnimationLink;
	class ResourceAccessor;
	class GroupContainer;

	class Layout {
	public:
		Layout();
		virtual ~Layout();

		virtual bool Build(const void *data, ResourceAccessor *resAcc);

		virtual AnimTransform *CreateAnimTransform();
		virtual AnimTransform *CreateAnimTransform(const void *data, ResourceAccessor *resAcc);
		virtual AnimTransform *CreateAnimTransform(const AnimResource &res, ResourceAccessor *resAcc);

		virtual void BindAnimation(AnimTransform *anim);
		virtual void UnbindAnimation(AnimTransform *anim);
		virtual void UnbindAllAnimation();
		virtual bool BindAnimationAuto(const AnimResource &res, ResourceAccessor *resAcc);

		virtual void SetAnimationEnable(AnimTransform *anim, bool unk);

		virtual void CalculateMtx(const DrawInfo &info);

		virtual void/*?*/ Draw(const DrawInfo &info);
		virtual void/*?*/ Animate(ulong flag);

		virtual void/*?*/ SetTagProcessor(ut::TagProcessorBase<wchar_t> *tagProc);

		ut::LinkList animations;

		Pane *rootPane;
		GroupContainer *groupContainer;

		float width;
		float height;
	};


	class DrawInfo {
	public:
		DrawInfo();
		virtual ~DrawInfo();

		Mtx matrix;
		float left;
		float top;
		float right;
		float bottom;
		float scaleX;
		float scaleY;
		float alpha;
		u8 _50; // this is actually a bitfield. todo: investigate how CW handles bitfields, and so on
	};


	class Material {
	public:
		// ...
	};

	class Pane {
	public:
		//Pane(nw4r::lyt::res::Pane const *); // todo: this struct
		Pane(void *);
		~Pane();

		virtual void *GetRuntimeTypeInfo() const;
		virtual void CalculateMtx(const DrawInfo &info);

		virtual void Draw(const DrawInfo &info);
		virtual void DrawSelf(const DrawInfo &info);
		virtual void Animate(ulong flag);
		virtual void AnimateSelf(ulong flag);

		virtual ut::Color GetVtxColor(ulong id) const;
		virtual void SetVtxColor(ulong id, ut::Color color);
		virtual uchar GetColorElement(ulong id) const;
		virtual void SetColorElement(ulong id, uchar value);
		virtual uchar GetVtxColorElement(ulong id) const;
		virtual void SetVtxColorElement(ulong id, uchar value);

		virtual Pane *FindPaneByName(const char *name, bool recursive);
		virtual Material *FindMaterialByName(const char *name, bool recursive);

		virtual void/*?*/ BindAnimation(AnimTransform *anim, bool unk1, bool unk2);
		virtual void UnbindAnimation(AnimTransform *anim, bool unk);
		virtual void UnbindAllAnimation(bool unk);
		virtual void UnbindAnimationSelf(AnimTransform *anim);

		virtual ut::LinkListNode *FindAnimationLinkSelf(AnimTransform *anim);
		virtual ut::LinkListNode *FindAnimationLinkSelf(const AnimResource &anim);

		virtual void SetAnimationEnable(AnimTransform *anim, bool unk1, bool unk2);
		virtual void SetAnimationEnable(const AnimResource &anim, bool unk1, bool unk2);

		virtual ulong GetMaterialNum() const;
		virtual Material *GetMaterial() const;
		virtual Material *GetMaterial(ulong id) const;

		virtual void LoadMtx(const DrawInfo &info);

		void AppendChild(Pane *child);

		ut::Rect GetPaneRect(const DrawInfo &info) const;

		ut::LinkListNode *AddAnimationLink(AnimationLink *link);

		Vec2 GetVtxPos() const;


		ut::LinkListNode parentLink;
		Pane *parent;

		ut::LinkList children;
		ut::LinkList animations;

		Material *material;

		Vec trans;
		Vec rotate;
		Vec2 scale;
		Vec2 size;

		Mtx calcMtx;
		Mtx effectiveMtx;

		float _B4;

		u8 alpha;
		u8 effectiveAlpha;
		u8 origin;
		u8 flag;

		char name[0x14];
		char userdata[8];

		u8 _D5;
		u8 paneIsOwnedBySomeoneElse;
		u8 _D7;
	};

	class TextBox : public Pane {
	public:
		TextBox(void *, void *); // todo: TextBox((res::TextBox const *,ResBlockSet const &))
		~TextBox();

		void *GetRuntimeTypeInfo() const;

		void DrawSelf(const DrawInfo &info);

		ut::Color GetVtxColor(ulong id) const;
		void SetVtxColor(ulong id, ut::Color color);
		uchar GetVtxColorElement(ulong id) const;
		void SetVtxColorElement(ulong id, uchar value);

		virtual void LoadMtx(const DrawInfo &info);

		virtual void AllocStringBuffer(u16 size);
		virtual void FreeStringBuffer();

		virtual u16 SetString(const wchar_t *str, u16 destOffset);
		virtual u16 SetString(const wchar_t *str, u16 destOffset, u16 length);

		wchar_t *stringBuf;

		ut::Color colour1, colour2;
		void *font; // actually a ut::ResFont or whatever

		float fontSizeX, fontSizeY;
		float lineSpace, charSpace;

		void *tagProc; // actually a TagProcessor

		u16 bufferLength;
		u16 stringLength;

		u8 alignment;
		u8 flags;
	};
}



namespace g3d {
struct CameraData
{
enum Flag
    {
FLAG_CAMERA_LOOKAT          = 0x00000001,
FLAG_CAMERA_ROTATE = 0x00000002,
FLAG_CAMERA_AIM    = 0x00000004,
MASK_CAMERA        = 0x00000007,

FLAG_CMTX_VALID    = 0x00000008,

FLAG_PROJ_FLUSTUM  = 0x00000010,
FLAG_PROJ_PERSP    = 0x00000020,
FLAG_PROJ_ORTHO    = 0x00000040,
MASK_PROJ          = 0x00000070,

FLAG_PMTX_VALID             = 0x00000080,

FLAG_VIEWPORT_JITTER_ABOVE  = 0x00000100
    };

Mtx  cameraMtx;
Mtx44  projMtx;

u32 flags;

VEC3   cameraPos;
VEC3   cameraUp;
VEC3   cameraTarget;
VEC3   cameraRotate;
f32    cameraTwist;

GXProjectionType    projType;
f32                 projFovy;
f32                 projAspect;
f32                 projNear;
f32                 projFar;
f32                 projTop;
f32                 projBottom;
f32                 projLeft;
f32                 projRight;

f32                 lightScaleS;
f32                 lightScaleT;
f32                 lightTransS;
f32                 lightTransT;

VEC2   viewportOrigin;
VEC2   viewportSize;
f32    viewportNear;
f32    viewportFar;

u32    scissorX;
u32    scissorY;
u32    scissorWidth;
u32    scissorHeight;

s32    scissorOffsetX;
s32    scissorOffsetY;
};

/* Correct camera
cameraMtx:
1.0 0.0 0.0 -0.0
0.0 1.0 0.0 -0.0
0.0 0.0 1.0 -6000.0

projMtx:
0.002345 0.000000  0.000000 -1.000000
0.000000 0.004386  0.000000 -1.000000
0.000000 0.000000 -0.000005 -0.500000
0.000000 0.000000  0.000000  1.000000

flags: 000000C9 : FLAG_CAMERA_LOOKAT | FLAG_CMTX_VALID | FLAG_PROJ_ORTHO | FLAG_PMTX_VALID

cameraPos: {0, 0, 15}
cameraUp: {0, 1, 0}
cameraTarget: {0, 0, 0}
cameraRotate: {0, 0, 0}
cameraTwist: 0

projType: 1
projFovy: 60
projAspect: 1.333333
projNear: -100000
projFar: 100000
projTop: 456
projBottom: 0
projLeft: 0
projRight: 853

lightScaleS: 0.5
lightScaleT: 0.5
lightTransS: 0.5
lightTransT: 0.5

viewportOrigin: {0,0}
viewportSize: {640,456}
viewportNear: 0
viewportFar: 1

scissorX: 0
scissorY: 0
scissorWidth: 0x280
scissorHeight: 0x1C8

scissorOffsetX: 0
scissorOffsetY: 0
*/

class Camera {
public:
	enum PostureType { POSTURE_LOOKAT, POSTURE_ROTATE, POSTURE_AIM };
	struct PostureInfo
	{
	PostureType tp;
	VEC3   cameraUp;
	VEC3   cameraTarget;
	VEC3   cameraRotate;
	f32         cameraTwist;
	};
private:
	CameraData *data;
public:
	Camera(CameraData *pCamera);
	void Init();
	void Init(u16 efbWidth, u16 efbHeight, u16 xfbWidth, u16 xfbHeight, u16 viWidth, u16 viHeight);
	//void SetPosition(f32 x, f32 y, f32 z);
	void SetPosition(const VEC3 &pos);
	//void GetPosition(f32 *px, f32 *py, f32 *pz) const;
	void GetPosition(VEC3 *pPos) const;
	void SetPosture(const PostureInfo &info);
	//void GetPosture(PostureInfo *info) const;
	void SetCameraMtxDirectly(const Mtx &mtx);
	void GetCameraMtx(Mtx *pMtx) const;
	void SetOrtho(f32 top, f32 bottom, f32 left, f32 right, f32 near, f32 far);
	//void SetFrustum(f32 top, f32 bottom, f32 left, f32 right, f32 near, f32 far);
	void SetPerspective(f32 fovy, f32 aspect, f32 near, f32 far);
	void SetProjectionMtxDirectly(const Mtx44 *pMtx);
	void GetProjectionMtx(Mtx44 *pMtx) const;
	//GXProjectionType GetProjectionType() const;
	void SetScissor(u32 xOrigin, u32 yOrigin, u32 width, u32 height);
	void SetScissorBoxOffset(s32 xOffset, s32 yOffset);
	//void GetScissor(u32 *xOrigin, u32 *yOrigin, u32 *width, u32 *height);
	void SetViewport(f32 xOrigin, f32 yOrigin, f32 width, f32 height);
	//void SetViewport(f32 xOrigin, f32 yOrigin, f32 width, f32 height, f32 near, f32 far);
	void SetViewportZRange(f32 near, f32 far);
	void SetViewportJitter(u32 field);
	//void SetViewportJitter(f32 xOrigin, f32 yOrigin, f32 width, f32 height, f32 near, f32 far, u32 field);
	void GetViewport(f32 *xOrigin, f32 *yOrigin, f32 *width, f32 *height, f32 *near, f32 *far) const;
	void GXSetViewport() const;
	void GXSetProjection() const;
	void GXSetScissor() const;
	void GXSetScissorBoxOffset() const;
};

namespace G3DState {
	GXRenderModeObj *GetRenderModeObj();
}
}
}


nw4r::g3d::CameraData *GetCameraByID(int id);

int GetCurrentCameraID(); // 80164C80
void SetCurrentCameraID(int id); // 80164C90

void LinkScene(int id); // 80164D50
void UnlinkScene(int id); // 80164CD0

void SceneCalcWorld(int sceneID); // 80164E10
void SceneCameraStuff(int sceneID); // 80164EA0

void CalcMaterial(); // 80164E90
void DrawOpa(); // 80164F70
void DrawXlu(); // 80164F80

bool ChangeAlphaUpdate(bool enable); // 802D3270

void DoSpecialDrawing1(); // 8006CAE0
void DoSpecialDrawing2(); // 8006CB40

void SetupLYTDrawing(); // 80163360
void ClearLayoutDrawList(); // 801632B0

void DrawAllLayoutsBeforeX(int x); // 80163440
void DrawAllLayoutsAfterX(int x); // 801634D0
void DrawAllLayoutsAfterXandBeforeY(int x, int y); // 80163560

void RenderEffects(int v1, int v2); // 80093F10

void RemoveAllFromScnRoot(); // 80164FB0
void Reset3DState(); // 80165000

extern "C" void GXDrawDone(); // 801C4FE0



namespace m2d {
	class Base_c /*: public nw4r::ut::Link what's this? */ {
	public:
		u32 _00;
		u32 _04;

		Base_c();
		virtual ~Base_c();
		virtual void _vf0C();

		u8 _0C;
	};

	class Simple_c : public Base_c {
	public:
		nw4r::lyt::Layout layout;
		nw4r::lyt::DrawInfo drawInfo;

		u32 _84;
		float _88;
		float _8C;
		float _90;
		u32 _94;

		Simple_c();
		~Simple_c();

		void _vf0C();
		virtual void _vf10();
		virtual void _vf14();
	};
}



namespace EGG {
	class Frustum {
	public:
		GXProjectionType projType;
		int isCentered;
		float width;
		float height;
		float fovy;
		float dunno;
		float near;
		float far;
		float center_x_maybe;
		float center_y_maybe;
		float x_direction;
		float unk2;
		float unk3;
		short some_flag_bit;


		// isCentered might actually be isNotCentered, dunno
		Frustum(GXProjectionType projType, Vec2 size, bool isCentered, float near, float far); // 802C6D20
		Frustum(Frustum &f); // 802C6D90
		virtual ~Frustum(); // 802C75F0

		virtual void loadDirectly(); // 802C7050
		virtual void loadIntoCamera(nw4r::g3d::Camera cam); // 802C7070

		void setOrtho(float top, float bottom, float left, float right, float near, float far); // 802C6DD0

		void setFovy(float newFovy); // 802C6F60

		void getCenterPointsBasedOnPos(float x, float y, float *destX, float *destY); // 802C6FD0

		// no idea what this does
		float getSomethingForPerspective(float blah); // 802C7020


	protected:
		// not all of these might be protected, dunno

		void copyAllFields(Frustum &f); // 802C6EE0

		void saveSomething(float f1, float f2, float f3, float f4); // 802C70C0
		void loadSomething(float *f1, float *f2, float *f3, float *f4); // 802C70E0

		void loadPerspective(); // 802C7110
		void loadOrtho(); // 802C7140

		void setCameraPerspective(nw4r::g3d::Camera cam); // 802C7170
		void setCameraOrtho(nw4r::g3d::Camera cam); // 802C71E0

		void getPerspectiveProjMtx(Mtx44 *mtx); // 802C7250
		void getPerspectiveProjv(float *ptr); // 802C72E0
		void getOrthoProjv(float *ptr); // 802C73A0

		void getOrthoVars(float *top, float *bottom, float *left, float *right); // 802C7480
	};
}




struct LinkListEntry {
	LinkListEntry *prev;
	LinkListEntry *next;
	void *owned_obj;
};


struct LinkList {
	LinkListEntry *first;
	LinkListEntry *last;
	// PTMF goes here, but I don't know how to represent it
};


struct OrderedLinkListEntry : LinkListEntry {
	u16 order;
	u16 _;
};


struct TreeNode {
	TreeNode *parent;
	TreeNode *child;
	TreeNode *prev;
	TreeNode *next;
	void *owned_obj;
};


struct Tree {
	TreeNode *firstNode;
	// PTMF goes here, but I don't know how to represent it
};


typedef bool (*ChainedFunc)(void*);

class FunctionChain {
public:
	ChainedFunc *functions;
	u16 count;
	u16 current;

	void setup(ChainedFunc *functions, u16 count); // 8015F740
};


class fBase_c {
public:
	u32 id;
	u32 settings;
	u16 name;
	u8 _A;
	u8 _B;
	u8 _C;
	u8 _D;
	u8 base_type;
	u8 _F;
	TreeNode link_connect;
	OrderedLinkListEntry link_execute;
	OrderedLinkListEntry link_draw;
	LinkListEntry link_IDlookup;
	u32 _50;
	u32 _54;
	u32 _58;
	u32 heap;

	fBase_c();

	virtual int onCreate();
	virtual int beforeCreate();
	virtual int afterCreate();

	virtual int onDelete();
	virtual int beforeDelete();
	virtual int afterDelete();

	virtual int onExecute();
	virtual int beforeExecute();
	virtual int afterExecute();

	virtual int onDraw();
	virtual int beforeDraw();
	virtual int afterDraw();

	virtual void willBeDeleted();

	virtual bool moreHeapShit(u32 size, void *parentHeap);
	virtual bool createHeap(u32 size, void *parentHeap);
	virtual void heapCreated();

	virtual ~fBase_c();

	void Delete();

	fBase_c *GetParent();
	fBase_c *GetChild();
	fBase_c *GetNext();

	bool hasUninitialisedProcesses();	// 80162B60
};

class dBase_c : public fBase_c {
public:
	u32 _64;
	const char *explanation_string;
	const char *name_string;

	dBase_c();

	int beforeCreate();
	int afterCreate();
	int beforeDelete();
	int afterDelete();
	int beforeExecute();
	int afterExecute();
	int beforeDraw();
	int afterDraw();

	~dBase_c();

	virtual const char *GetExplanationString();
};

class dScene_c : public dBase_c {
public:
	FunctionChain *ptrToInitChain;

	dScene_c();

	int beforeCreate();
	int afterCreate();
	int beforeDelete();
	int afterDelete();
	int beforeExecute();
	int afterExecute();
	int beforeDraw();
	int afterDraw();

	~dScene_c();


	void setInitChain(FunctionChain &initChain) {
		ptrToInitChain = &initChain;
	}
};

class dActor_c : public dBase_c {
public:
	LinkListEntry link_actor;
	Mtx matrix;
	Vec pos;
	Vec last_pos;
	Vec pos_delta;
	Vec _D0;
	Vec scale;
	Vec speed;
	Vec max_speed;
	S16Vec rot;
	S16Vec _106;
	u32 _10C;
	u32 _110;
	float y_speed_inc;
	u32 _118;
	float x_speed_inc;
	u32 _120;
	bool visible;

	dActor_c();

	virtual void specialDraw1();
	virtual void specialDraw2();
	virtual int _vf58();
	virtual void _vf5C();

	~dActor_c();
};



class dPlayerModelBase_c {
	// dunno what's public and what's private here
	// don't really care
public:
	dPlayerModelBase_c(u8 player_id);		// 800D5420
	virtual ~dPlayerModelBase_c();			// 800D55D0

	char allocator[28]; // actually a mHeapAllocatorSubclass but I don't have that
	u32 _20;
	u32 _24;
	char someAnimation[2][0x38]; // actually PlayerAnim's
	char yetAnotherAnimation[40]; // actually m3d::banm_c afaics -- is it even 40 bytes?
	Vec someVector[2]; // maybe not an array
	Vec headOffs;
	Vec scale;
	u8 player_id_1;
	u8 player_id_2;
	u8 powerup_id;
	u8 powerup_tex;
	int current_anim;
	int last_anim_maybe;
	u32 _15C;
	int someFlags;
	u32 _164;
	u32 _168; // related to jump_strings
	u32 _16C;
	u32 _170;
	u32 _174;
	u8 _178;
	char padding[3]; // not needed?
	u32 model_visibility_flags_maybe;
	u32 mode_maybe;
	float _184;
	float _188;
	u32 _18C;
	char someArray[6][12]; // some unknown class/struct
	char _1D8[0x24];
	short _1FC;
	short _1FE;
	short _200;
	char padding_[2]; // not needed?
	u32 _204;
	u32 _208;

	virtual int _vf0C();						// 800D6DA0
	virtual void prepare();					// 800D5720
	virtual void finaliseModel();				// 800D5740
	virtual void update();						// 800D5750
	virtual void update3DStuff();				// 800D5760
	virtual void _vf20();						// 800D6D90
	virtual void draw();						// 800D5C70
	virtual int getCurrentModel();				// 800D5870
	virtual int getCurrentResFile();			// 800D62D0
	virtual void setPowerup(u8 powerup_id);	// 800D5730
	virtual void setPowerupTexture();			// 800D5CC0
	virtual void _vf38();						// 800D6D80
	virtual void _vf3C();						// 800BD750
	virtual void _vf40();						// 800D6D70
	virtual void _vf44();						// 800D6D60
	virtual void _vf48();						// 800BD740
	virtual void _vf4C();						// 800BD730
	virtual void getModelMatrix(u32 unk, MtxPtr dest);	// 800D5820
	virtual int _vf54();						// 80318D0C
	virtual bool _vf58(int type, char *buf, bool unk); // 800D6930
	virtual void startAnimation(int id, float frame, float unk, float updateRate);	// 800D5EC0
	virtual int _vf60();						// 800D6920
	virtual void _vf64(int id, float unk1, float unk2, float unk3); // 800D62F0
	virtual void _vf68(int id, float unk);		// 800D63E0
	virtual void _vf6C();						// 800D62E0
	virtual void _vf70();						// 800D6690
	virtual void _vf74();						// 800D66A0
	virtual void _vf78();						// 800D66B0
	virtual void SomethingRelatedToPenguinAnims();	// 800D66C0
	virtual void _vf80();						// 800D6A20
	virtual void _vf84(float frame);			// 800D5D00
	virtual void _vf88(float frame);			// 800D5D70
	virtual void _vf8C(float updateRate);		// 800D5D80
	virtual void setUpdateRateForAnim1(float updateRate);	// 800D5DF0
	virtual void _vf94();						// 800D6D40
	virtual int _vf98();						// 800D6D30
	virtual void _vf9C();						// 800D6D20
	virtual int _vfA0();						// 800D6D10
	virtual void _vfA4();						// 800D6D00
	virtual int _vfA8();						// 800D6CF0
	virtual void _vfAC(bool blah);						// 800BD720

	// I won't even bother with non-virtual functions....
};


class dPlayerModelHandler_c {
public:
	dPlayerModelHandler_c(u8 player_id);	// 800D6DB0
	virtual ~dPlayerModelHandler_c();		// 800D6EF0

	dPlayerModelBase_c *mdlClass;	// might be dPlayerModel_c ?

	int loadModel(u8 player_id, int powerup_id, int unk);	// 800D6EE0
	void update();											// 800D6F80
	void setMatrix(Mtx matrix);								// 800D6FA0
	void setSRT(Vec position, S16Vec rotation, Vec scale);	// 800D7030
	void callVF20();										// 800D70F0
	void draw();											// 800D7110

private:
	int hasMatrix;	// might be bool ?

	void allocPlayerClass(u8 player_id);					// 800D6E00
};


class mTexture_c {
public:
	mTexture_c();	// 802C0D20
	mTexture_c(u16 width, u16 height, GXTexFmt format);	// 802C0D70

	// vtable is at 80350450
	virtual ~mTexture_c();	// 802C0DB0
	virtual void setFlagTo1();	// 802C0E20

	void setImageBuffer(void *buffer);	// 802C0E30
	void load(GXTexMapID id);			// 802C0E50
	void makeTexObj(GXTexObj *obj);		// 802C0E90
	void flushDC();						// 802C0F10

	void makeRadialGradient();			// 802C0F60 parameters unknown yet
	void makeLinearGradient(int type, char size, u16 startPos, u16 endPos,
			GXColor begin, GXColor end, bool startAtCenter);	// 802C1120
	// "type" should be enum once I figure it out
	// reverse might not be accurate

	void allocateBuffer(/* EGG::Heap */void *heap = 0);	// 802C14D0

	void plotPixel(u16 x, u16 y, GXColor pixel);	// 802C1570


	u16 width;
	u16 height;
	u8 flags;
	u8 format;
	u8 wrapS;
	u8 wrapT;
	u8 minFilter;
	u8 magFilter;

private:
	void *buffer;
	void *myBuffer;
};


class dDvdLoader_c {
public:
	dDvdLoader_c();				// 8008F140
	virtual ~dDvdLoader_c();	// 8008F170

	void *load(const char *filename, u8 unk = 0, void *heap = 0);	// 8008F1B0

	bool close();	// 8008F2B0 -- Frees command, DON'T USE THIS unless you free the buffer yourself
	bool unload();	// 8008F310 -- Frees command and buffer, USE THIS

	int size;
	void *command;	// really mDvd_toMainRam_c
	void *heap;		// really EGG::Heap
	void *buffer;

private:
	virtual void freeBuffer();	// 8008F380
	void freeCommand();			// 8008F3F0
};



// More layout crap
// This file REALLY needs to be reorganised.

namespace nw4r {
namespace lyt {

	class ResourceAccessor {
	public:
		ResourceAccessor();
		virtual ~ResourceAccessor();

		virtual void *GetResource(u32 dirKey, const char *filename, u32 *sizePtr) = 0;
		virtual void *GetFont(const char *name);
	};

	class ArcResourceAccessor : public ResourceAccessor {
	public:
		ArcResourceAccessor();
		~ArcResourceAccessor();

		bool Attach(void *data, const char *rootDirName);
		void *GetResource(u32 dirKey, const char *filename, u32 *sizePtr);
		void *GetFont(const char *name);

		ARCHandle arc;
		u32 unk_20;
		ut::LinkList list; // 0x24
		char rootDirName[0x80]; // 0x30
		// class ends at 0xB0
	};

}
}

namespace m2d {
	class ResAcc_c {
	public:
		ResAcc_c();
		virtual ~ResAcc_c();
		virtual void initialSetup();

		nw4r::lyt::ResourceAccessor *resAccPtr; // 0x04
		u32 unk_08; // 0x08
		nw4r::lyt::ArcResourceAccessor resAcc; // 0x0C
		// class ends at 0xBC
	};

	class ResAccLoader_c : public ResAcc_c {
	public:
		ResAccLoader_c();
		~ResAccLoader_c();

		void *buffer;
		dDvdLoader_c loader; // 0xC0
		// ends at 0xD4

		bool loadArc(const char *path);
		bool loadArc(const char *path, u8 unk);
		void free();
	};

	class EmbedLayoutBase_c {
	public:
		u32 unk_00;
		u32 unk_04;

		EmbedLayoutBase_c();
		virtual ~EmbedLayoutBase_c();

		virtual void draw();
		virtual void update();
		virtual bool build(const char *brlytPath, ResAcc_c *resAcc);

		nw4r::lyt::Pane *getRootPane();
		nw4r::lyt::Pane *findPaneByName(const char *name) const;
		nw4r::lyt::TextBox *findTextBoxByName(const char *name) const;
		nw4r::lyt::Pane *findPictureByName(const char *name) const; // TODO: change to others
		nw4r::lyt::Pane *findWindowByName(const char *name) const;

		void animate();
		void calculateMtx();

		u8 drawOrder;

		nw4r::lyt::Layout layout; // 0x10
		nw4r::lyt::DrawInfo drawInfo; // 0x30
		void *unk_84; // 0x84 -- a ResAcc? referenced in Build()
		float posX; // 0x88
		float posY; // 0x8C
		float clipX; // 0x90
		float clipY; // 0x94
		float clipWidth; // 0x98
		float clipHeight; // 0x9C
		bool clippingEnabled; // 0xA0
		u32 hasAnimations; // 0xA4
		u32 unk_A8; // 0xA8
	};

	class EmbedLayout_c : public EmbedLayoutBase_c {
	public:
		EmbedLayout_c();
		~EmbedLayout_c();

		bool build(const char *brlytPath, ResAcc_c *resAcc);

		bool loadArc(const char *name, bool isLangSpecific);
		bool loadArc(const char *name, u8 unk, bool isLangSpecific);

		bool loadArcForRegion(const char *name); // uses EU/Layout/$name

		// there's also a NedEU one, but should it really be listed here...?

		// does NSMBW even use consts? I have no idea. maybe not

		void getPanes(const char **names, nw4r::lyt::Pane *output, int count) const;
		void getWindows(const char **names, nw4r::lyt::Pane *output, int count) const; // TODO: change to others
		void getPictures(const char **names, nw4r::lyt::Pane *output, int count) const;
		void getTextBoxes(const char **names, nw4r::lyt::TextBox *output, int count) const;

		void setLangStrings(const char **names, const int *msgIDs, int category, int count);

		void loadAnimations(const char **names, int count);
		void loadGroups(const char **names, int *animLinkIDs, int count);

		void enableNonLoopAnim(int num, bool goToLastFrame = false);
		void enableLoopAnim(int num);
		void resetAnim(int num, bool goToLastFrame = false);
		void disableAnim(int num);
		void disableAllAnimations();

		bool isAnimOn(int num = -1);
		bool isAnyAnimOn();

		void execAnimations();

		ResAccLoader_c loader; // 0xAC
		void *brlanHandlers; // 0x180
		void *grpHandlers; // 0x184
		bool *animsEnabled; // 0x188
		int brlanCount; // 0x18C
		int grpCount; // 0x190
		int lastAnimTouched; // 0x194

	private:
		void fixTextBoxesRecursively(nw4r::lyt::Pane *pane);
	};
}


#endif