/* JSRF Decompilation: JSRF/Action.hpp
CActMan and CActBase classes that form the foundation of the JSRF game code.
*/

#ifndef ACTION_HPP
#define ACTION_HPP

#include "../MUSASHI/MMatrix.hpp"
#include "../XDK/CRT/stddef.h"
#include "../XDK/D3D.h"
#include "../XDK/Win32.h"


// TODO; move to header for Graphics COM object in Smilebit libraries
struct SGraphicsPerformanceCounters {
	unsigned fps;
	unsigned trianglesPerSecond;
	unsigned frameTriangleCnt;
	unsigned unknown0xC;
	unsigned unknown0x10;
	unsigned unknown0x14;
};

// TODO: Just here to get delinking working until we make dedicated source
// files for these classes
struct CSysColiManager {
	CSysColiManager();
	virtual ~CSysColiManager();
};
struct UnknownGlobal {
	UnknownGlobal();
	virtual ~UnknownGlobal();
};
struct UnknownStatic02 {
	UnknownStatic02();
	virtual ~UnknownStatic02();
};
struct UnknownStatic04 {
	UnknownStatic04();
	virtual ~UnknownStatic04();
};
struct UnknownStatic05 {
	UnknownStatic05();
	virtual ~UnknownStatic05();
};
struct UnknownStatic06 {
	UnknownStatic06();
	virtual ~UnknownStatic06();
};
struct UnknownStatic07 {
	UnknownStatic07();
	virtual ~UnknownStatic07();
};
struct UnknownStatic09 {
	UnknownStatic09();
	virtual ~UnknownStatic09();
};
struct UnknownStatic13 {
	char   unknown1[0x274];
	void * unknown2;
	void * unknown3;
};
struct UnknownStatic16 {
	UnknownStatic16();
	virtual ~UnknownStatic16();
};
struct UnknownStatic17 {
	UnknownStatic17();
	virtual ~UnknownStatic17();
};
struct UnknownStatic18 {
	UnknownStatic18();
	virtual ~UnknownStatic18();
};
struct UnknownStatic19 {
	UnknownStatic19();
	virtual ~UnknownStatic19();
};
struct UnknownStatic24 {
	UnknownStatic24();
	virtual ~UnknownStatic24();
};
struct UnknownStatic27 {
	UnknownStatic27();
	virtual ~UnknownStatic27();
	void * unknown[3];
};
struct SGraphicsSetting {
	unsigned    countedIfZero;
	char      * name;
	float       unknown[3];
	float       value;
	unsigned    index;
};
struct SGraphicsSettings {
	float            * settings;
	unsigned           settingsArrSizeInBytes;
	unsigned           unknown1;
	unsigned           unknown2;
	unsigned           srcArrZeroCnt;
	SGraphicsSetting * srcItemsMarked0;
	unsigned         * offsetsFromPrevSrcItemMarked0;
};
enum eGRAPHICSSETTINGTYPE {
	eGRAPHICSSETTINGTYPE_WARP = 0x0,
	eGRAPHICSSETTINGTYPE_WARP_X = 0x1,
	eGRAPHICSSETTINGTYPE_WARP_Y = 0x2,
	eGRAPHICSSETTINGTYPE_WARP_Z = 0x3,
	eGRAPHICSSETTINGTYPE_GO = 0x4,
	eGRAPHICSSETTINGTYPE_MEMORY = 0x5,
	eGRAPHICSSETTINGTYPE_DRAW = 0x6,
	eGRAPHICSSETTINGTYPE_COLOR = 0x7,
	eGRAPHICSSETTINGTYPE_COLOR_R = 0x8,
	eGRAPHICSSETTINGTYPE_COLOR_G = 0x9,
	eGRAPHICSSETTINGTYPE_COLOR_B = 0xa,
	eGRAPHICSSETTINGTYPE_AMBIENT = 0xb,
	eGRAPHICSSETTINGTYPE_AMBIENT_R = 0xc,
	eGRAPHICSSETTINGTYPE_AMBIENT_G = 0xd,
	eGRAPHICSSETTINGTYPE_AMBIENT_B = 0xe,
	eGRAPHICSSETTINGTYPE_SHADOWCOLOR = 0xf,
	eGRAPHICSSETTINGTYPE_SHADOWCOLOR_A = 0x10,
	eGRAPHICSSETTINGTYPE_SHADOWCOLOR_R = 0x11,
	eGRAPHICSSETTINGTYPE_SHADOWCOLOR_G = 0x12,
	eGRAPHICSSETTINGTYPE_SHADOWCOLOR_B = 0x13,
	eGRAPHICSSETTINGTYPE_BGCOLOR = 0x14,
	eGRAPHICSSETTINGTYPE_BGCOLOR_R = 0x15,
	eGRAPHICSSETTINGTYPE_BGCOLOR_G = 0x16,
	eGRAPHICSSETTINGTYPE_BGCOLOR_B = 0x17,
	eGRAPHICSSETTINGTYPE_MIPMAPLOD = 0x18,
	eGRAPHICSSETTINGTYPE_MIPMAPLOD_BIAS = 0x19,
	eGRAPHICSSETTINGTYPE_G_CONTRAST = 0x1a,
	eGRAPHICSSETTINGTYPE_G_CONTRAST_R = 0x1b,
	eGRAPHICSSETTINGTYPE_G_CONTRAST_G = 0x1c,
	eGRAPHICSSETTINGTYPE_G_CONTRAST_B = 0x1d,
	eGRAPHICSSETTINGTYPE_G_LUMINANCE = 0x1e,
	eGRAPHICSSETTINGTYPE_G_LUMINANCE_R = 0x1f,
	eGRAPHICSSETTINGTYPE_G_LUMINANCE_G = 0x20,
	eGRAPHICSSETTINGTYPE_G_LUMINANCE_B = 0x21,
	eGRAPHICSSETTINGTYPE_GRIND = 0x22,
	eGRAPHICSSETTINGTYPE_GRIND_NS = 0x23,
	eGRAPHICSSETTINGTYPE_GRIND_XS = 0x24,
	eGRAPHICSSETTINGTYPE_GRIND_NR = 0x25,
	eGRAPHICSSETTINGTYPE_GRIND_XR = 0x26,
	eGRAPHICSSETTINGTYPE_GIZA_NO = 0x27,
	eGRAPHICSSETTINGTYPE_GIZA_NO_T = 0x28,
	eGRAPHICSSETTINGTYPE_GIZA_SPEED = 0x29,
	eGRAPHICSSETTINGTYPE_GIZA_SPEED_R = 0x2a,
	eGRAPHICSSETTINGTYPE_GIZA_SPEED_T = 0x2b,
	eGRAPHICSSETTINGTYPE_GIZA_SPEED_S = 0x2c,
	eGRAPHICSSETTINGTYPE_GIZA_GRIND = 0x2d,
	eGRAPHICSSETTINGTYPE_GIZA_GRIND_R = 0x2e,
	eGRAPHICSSETTINGTYPE_GIZA_GRIND_T = 0x2f,
	eGRAPHICSSETTINGTYPE_GIZA_GRIND_S = 0x30,
	eGRAPHICSSETTINGTYPE_GIZA_NORMAL = 0x31,
	eGRAPHICSSETTINGTYPE_GIZA_NORMAL_R = 0x32,
	eGRAPHICSSETTINGTYPE_GIZA_NORMAL_T = 0x33,
	eGRAPHICSSETTINGTYPE_GIZA_NORMAL_S = 0x34,
	eGRAPHICSSETTINGTYPE_GIZA_SDASH = 0x35,
	eGRAPHICSSETTINGTYPE_GIZA_SDASH_R = 0x36,
	eGRAPHICSSETTINGTYPE_GIZA_SDASH_T = 0x37,
	eGRAPHICSSETTINGTYPE_GIZA_SDASH_S = 0x38,
	eGRAPHICSSETTINGTYPE_GIZA_CAMZ = 0x39,
	eGRAPHICSSETTINGTYPE_GIZA_CAMZ_ND = 0x3a,
	eGRAPHICSSETTINGTYPE_GIZA_CAMZ_XD = 0x3b,
	eGRAPHICSSETTINGTYPE_GIZA_CAMZ_NR = 0x3c,
	eGRAPHICSSETTINGTYPE_GIZA_CAMZ_XR = 0x3d,
	eGRAPHICSSETTINGTYPE_GIZA_CAMTRT = 0x3e,
	eGRAPHICSSETTINGTYPE_GIZA_CAMTRT_ND = 0x3f,
	eGRAPHICSSETTINGTYPE_GIZA_CAMTRT_XD = 0x40,
	eGRAPHICSSETTINGTYPE_GIZA_CAMTRT_NR = 0x41,
	eGRAPHICSSETTINGTYPE_GIZA_CAMTRT_XR = 0x42,
	eGRAPHICSSETTINGTYPE_GIZA_CAMANG_NA = 0x43,
	eGRAPHICSSETTINGTYPE_GIZA_CAMANG_XA = 0x44,
	eGRAPHICSSETTINGTYPE_GIZA_CAMANG_NR = 0x45,
	eGRAPHICSSETTINGTYPE_GIZA_CAMANG_XR = 0x46,
	eGRAPHICSSETTINGTYPE_GIZA_MESH = 0x47,
	eGRAPHICSSETTINGTYPE_GIZA_MESH_IP = 0x48,
	eGRAPHICSSETTINGTYPE_GIZA_MESH_AP = 0x49,
	eGRAPHICSSETTINGTYPE_GIZA_MESH_BA = 0x4a,
	eGRAPHICSSETTINGTYPE_GIZA_CAMALPHA = 0x4b,
	eGRAPHICSSETTINGTYPE_GIZA_CAMALPHA_ENABLE = 0x4c,
	eGRAPHICSSETTINGTYPE_DIST = 0x4d,
	eGRAPHICSSETTINGTYPE_FOG = 0x4e,
	eGRAPHICSSETTINGTYPE_FOG_ENABLE = 0x4f,
	eGRAPHICSSETTINGTYPE_FOG_R = 0x50,
	eGRAPHICSSETTINGTYPE_FOG_G = 0x51,
	eGRAPHICSSETTINGTYPE_FOG_B = 0x52,
	eGRAPHICSSETTINGTYPE_FOG_RANGE = 0x53,
	eGRAPHICSSETTINGTYPE_FOG_RANGE_NEAR = 0x54,
	eGRAPHICSSETTINGTYPE_FOG_RANGE_FAR = 0x55,
	eGRAPHICSSETTINGTYPE_POWER = 0x56,
	eGRAPHICSSETTINGTYPE_WIRE_FRAME = 0x57,
	eGRAPHICSSETTINGTYPE_WIRE_FRAME_ENABLE = 0x58,
	eGRAPHICSSETTINGTYPE_TEXTURE = 0x59,
	eGRAPHICSSETTINGTYPE_TEXTURE_NO = 0x5a,
	eGRAPHICSSETTINGTYPE_SCREENGAUGE = 0x5b,
	eGRAPHICSSETTINGTYPE_SCREENGAUGE_ENABLE = 0x5c,
	eGRAPHICSSETTINGTYPE_OWARI = 0x5d,
	eGRAPHICSSETTINGTYPE_COUNT = 0x5e,
};


enum eACTFLAG {
	eACTFLAG_CAMERA               = 1 <<  0,
	eACTFLAG_SKIPDRAWINGSOMETHING = 1 <<  1,
	eACTFLAG_NODRAWPHASE2         = 1 << 16,
	eACTFLAG_DRAWTREE2            = 1 << 18,
	eACTFLAG_DRAWFIRST            = 1 << 22,
	eACTFLAG_CAMERACHILD          = 1 << 30,
	eACTFLAG_DELETE               = 1 << 31
};

// Position in g_lpActMan->objects array
// Different indices and ranges are dedicated to different kinds of
// objecs.
enum eACTID {
	eACTID_NOTINDEXED = -1, // Not stored in array
	eACTID_DIRECTOR   =  0,
	// TODO

	eACTID_NUM        = 0x1DF4
};

// Base class of most objects (and everything in g_lpActMan->objects)
struct CActBase {
	eACTFLAG m_ActFlag;
	eACTID   m_ActID;

	DWORD    m_dwDrawChildMask;
	float    m_fZ;
	DWORD    m_dwZSort; // Four-level key, one byte each
	float    m_vSomeTranslation[3];

	// Links forming a tree of objects for exec phase
	CActBase * m_lpParent;
	CActBase * m_lpChild;
	CActBase * m_lpSiblingBefore;
	CActBase * m_lpSiblingNext;

	// Some data structures used for draw phrase
	CActBase *     m_lpDrawNext;
	CActBase * *   m_lplpDrawBeforePtr;
	CActBase * * * m_lplplpDrawLastPtr;

	CActBase * m_lpZSort;

	virtual ~CActBase();

	void recursiveExec0Default();
	void drawManyDefault(
		eACTFLAG flagFilterAny1,
		int      drawArg1,
		int      drawArg2,
		eACTFLAG flagFilterAll,
		unsigned otherBitfieldFilterAny,
		eACTFLAG flagFilterNone,
		eACTFLAG flagFilterAny2
	);
	void drawTreeDefault1();
	void drawTreeDefault2();

	void recursiveExec0Event();
	void drawManyEvent(
		eACTFLAG flagFilterAny1,
		int      drawArg1,
		int      drawArg2,
		eACTFLAG flagFilterAll,
		unsigned otherBitfieldFilterAny,
		eACTFLAG flagFilterNone,
		eACTFLAG flagFilterAny2
	);
	void drawTreeEvent1();
	void drawTreeEvent2();

	void recursiveExec0CoveredPause();
	void drawManyCoveredPause(
		eACTFLAG flagFilterAny1,
		int      drawArg1,
		int      drawArg2,
		eACTFLAG flagFilterAll,
		unsigned otherBitfieldFilterAny,
		eACTFLAG flagFilterNone,
		eACTFLAG flagFilterAny2
	);
	void drawTreeCoveredPause1();
	void drawTreeCoveredPause2();

	void recursiveExec0FreezeCam();
	void drawManyFreezeCam(
		eACTFLAG flagFilterAny1,
		int      drawArg1,
		int      drawArg2,
		eACTFLAG flagFilterAll,
		unsigned otherBitfieldFilterAny,
		eACTFLAG flagFilterNone,
		eACTFLAG flagFilterAny2
	);
	void drawTreeFreezeCam1();
	void drawTreeFreezeCam2();

	void recursiveExec0UncoveredPause();
	void drawManyUncoveredPause(
		eACTFLAG flagFilterAny1,
		int      drawArg1,
		int      drawArg2,
		eACTFLAG flagFilterAll,
		unsigned otherBitfieldFilterAny,
		eACTFLAG flagFilterNone,
		eACTFLAG flagFilterAny2
	);
	void drawTreeUncoveredPause1();
	void drawTreeUncoveredPause2();

	void       insertActionTreeSub(CActBase * lpSibling, CActBase * lpParent);
	void       deleteActionChild(CActBase * lpChild);
	CActBase * getParentAction();

	void SetDelete(CActBase * lpAct);
	void SetDeleteChild(CActBase * lpChild);

	// Each frame, one of these trios of methods is called depending on
	// which state the game is in
	// Default implementation of each does nothing; inheriting objects
	// override these methods to run some code during each phase of each
	// frame.
	virtual void Exec0Default();
	virtual void Exec1Default();
	virtual void DrawListDefault(unsigned);

	virtual void Exec0Event();
	virtual void Exec1Event();
	virtual void DrawListEvent(unsigned);

	virtual void Exec0CoveredPause();
	virtual void Exec1CoveredPause();
	virtual void DrawListCoveredPause(unsigned);

	virtual void Exec0FreezeCam();
	virtual void Exec1FreezeCam();
	virtual void DrawListFreezeCam(unsigned);

	virtual void Exec0UncoveredPause();
	virtual void Exec1UncoveredPause();
	virtual void DrawListUncoveredPause(unsigned);

	void recursiveExec1Default();
	void recursiveExec1Event();
	void recursiveExec1CoveredPause();
	void recursiveExec1FreezeCam();
	void recursiveExec1UncoveredPause();

	void insertActionTree(CActBase * lpParent);

	CActBase(CActBase * lpParent, eACTID ActID, eACTFLAG ActFlag);
};

// There's a big array of possible arguments for draw methods with these
struct SDrawFuncArgs {
	eACTFLAG flagFilterAny;
	int      arg1;
	int      arg2;
};

// Base class of objects serving as the head of a tree of objects to draw
// recursively
struct CDrawBase : CActBase {
	float    unknown0x44[3];
	float    unknown0x50[3];
	float    unknown0x5C[3];
	float    unknown0x68[3];
	unsigned unknown0x74;
	unsigned unknown0x78;
	unsigned unknown0x7C;
	unsigned unknown0x80;
	float    m_fViewport[4];
	eACTID   m_SomeActID;

	void copySomeVectors();
	CDrawBase(CActBase * lpParent, eACTID ActID, eACTFLAG ActFlag);
	virtual ~CDrawBase();
};

struct CPlayer : CActBase {
	unsigned unknown0x44;
	unsigned unknown0x48;

	CPlayer(CActBase * lpParent, eACTID ActID, eACTFLAG ActFlag);
	virtual ~CPlayer();
};

// Top-level globally-accessible "god object" that runs the main loop and
// provides global access to most other objects and many variables
enum eDRAWMODE {
	eDRAWMODE_YES,
	eDRAWMODE_WAITVBLANK,
	eDRAWMODE_NO
};

enum eGLOBAL {
};

#pragma pack(4)
struct CActMan {
	char         unknown0x4[4];
	unsigned     unknown0x8;
	unsigned *   unknown0xC;
	HRESULT      m_InitState;
	unsigned     unknown0x14;
	BOOL         m_bDrawProfilingInfo;
	int          unknown0x1C;
	BOOL         m_bLogosStarted;
	BOOL         m_bFatal;

	D3DCOLOR     m_Color;
	D3DCOLOR     m_AmbientColor;
	D3DCOLOR     m_ShadowColor;
	D3DCOLOR     m_BgColor;
	D3DCOLOR     m_BgColorFallback;
	BOOL         m_bUseFallbackBgColor;

	// Game state used to select CActBase methods to call in main loop
	// If multiple states are activated, the precedence is
	//     coveredPause > Event > FreezeCam > UncoveredPause > Default
	BOOL         m_bCoveredPause;   // Game paused with world not visible
	BOOL         m_bEvent;          // Events (cutscenes)
	BOOL         m_bFreezeCam;      // Time-frozen camera shots
	BOOL         m_bUncoveredPause; // Game paused with world visible, or
	                                // automatic pause at start of mission

	BOOL         m_bCoveredPauseNextFrame;
	BOOL         m_bNoCoveredPauseNextFrame;
	BOOL         m_bEventNextFrame;
	BOOL         m_bNoEventNextFrame;
	BOOL         m_bFreezeCamNextFrame;
	BOOL         m_bNoFreezeCamNextFrame;
	BOOL         m_bUncoveredPauseNextFrame;
	BOOL         m_bNoUncoveredPauseNextFrame;

	BOOL         m_bDrawChildren;
	BOOL         m_bSkipDraw;
	BOOL         m_bRunSomeExtraDrawListCode;
	SGraphicsPerformanceCounters m_PerfCounters;

	eDRAWMODE m_DrawMode;

	// Globally accessible objects and variables
	CActBase  *   m_lpActTbl[7668];
	DWORD         m_Globals[461]; // Items may be any 32-bit type, e.g. ptr

	CDrawBase *   m_lpCamRoot;
	CDrawBase * * m_lplpCamPtr;

	CActBase  *   m_lpDrawRoot;
	CActBase  * * m_lplpDrawPtr;

	CActBase  *   m_lpDrawSortRoot;
	CActBase  * * m_lplpDrawSortPtr;

	CActBase  *   m_lpDrawSortBinRoots[256];
	CActBase  * * m_lplpDrawSortBinPtrs[256];

	unsigned unknown0x87B4;

	LARGE_INTEGER m_ExecPerfCount;
	LARGE_INTEGER m_DrawPerfCount;

	unsigned     unknown0x87C8;
	unsigned     unknown0x87CC;
	DWORD        m_dwFrameCount_MAYBE;
	unsigned     unknown0x87D4;
	unsigned     unknown0x87D8;
	CActBase  *  m_lpActExecRoot;
	DWORD        m_dwAnimCount_MAYBE;
	DWORD        m_dwAnimStep_MAYBE;
	DWORD        m_dwActCount;
	CDrawBase *  m_pCurrentDraw;
	eACTID       m_CurrentDrawActID;
	eACTID       m_CurrentDrawSomeActID;
	Mat4         m_mParentMatrix;
	unsigned     unknown0x8838;
	unsigned     unknown0x883C;

	CActMan(unsigned *, unsigned);
	virtual ~CActMan();
	void ActionExec();
	void drawOne(CActBase * lpAct, unsigned);
	void drawListSub(
		eACTFLAG flagFilterAny1,
		int      drawArg1,
		int      drawArg2,
		eACTFLAG flagFilterAll,
		unsigned otherBitfieldFilterAny,
		eACTFLAG flagFilterNone,
		eACTFLAG flagFilterAny2
	);
	void drawTree1(CActBase * lpAct);

	void setCoveredPauseNextFrame  (BOOL bVal);
	void setEventNextFrame         (BOOL bVal);
	void setFreezeCamNextFrame     (BOOL bVal);
	void setUncoveredPauseNextFrame(BOOL bVal);

	void DrawChildren();
	void DrawSkip();
	void Fatal();
	void SetDrawMode(eDRAWMODE Mode);

	void  SetGlobal(eGLOBAL Index, DWORD dwVal);
	DWORD GetGlobal(eGLOBAL Index);

	void InsertDrawList(CActBase * lpAct);
	void DeleteDrawList(CActBase * lpAct);

	void       InsertActionExecList(eACTID ActID , CActBase * lpAct);
	void       FreeActID           (eACTID ActID);
	CActBase * GetAction           (eACTID ActID);
	int        GetFreeActionID     (eACTID Min   , eACTID Max);
	BOOL       ActionIDAvail       (eACTID ActID);
	void       SwapActID           (eACTID ActID1, eACTID ActID2);

	void ClearScreen();
	void EnableSomeExtraDrawListCode();
	void SetLogosStarted(BOOL bVal);

	void       initSortDrawList();
	CActBase * getSortList();
	void       InsertDrawSortList(CActBase * lpAct);
	void       SortListSub(unsigned char ucSortKeyBitOffset);

	void SetFallbackBgColor(D3DCOLOR Color, BOOL bUseFallback);
	void Init();
	void drawMany(eACTFLAG flagFilterAll, BOOL);
	void sortDrawList();
	void drawSub();
	void draw();
	void IdleSub();
	int  Idle();
};
extern CActMan * g_lpActMan;

// Root of the exec GameObj tree
struct CActRoot : CActBase {
	CActRoot(CActBase * lpParent, eACTID ActID, eACTFLAG ActFlag);
	virtual ~CActRoot();
};

void SetActionDelete(eACTID ActID);


#endif