/* JSRF Decompilation: JSRF/Core.hpp
Game and GameObj classes that form the foundation of the JSRF game code.
*/

#ifndef CORE_HPP
#define CORE_HPP

#include "../Smilebit/MMatrix.hpp"
#include "../Std.hpp"
#include "../XDK/D3D.hpp"
#include "../XDK/Win32.hpp"


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

// Base class of most objects (and everything in g_game->objects)
class GameObj {
	enum GameObjFlags {
		GOF_SOMETHINGLINKED_ALTLIST    = 1 <<  0,
		GOF_SKIPDRAWCHILDREN           = 1 << 16,
		GOF_SKIPDRAWASCHILD            = 1 << 18,
		GOF_SKIPDRAWASROOT             = 1 << 22,
		GOF_EXCLUDEFROMSOMETHINGLINKED = 1 << 30,
		GOF_DELETEAFTEREXEC            = 1 << 31
	} flags;

	// Position in g_game->objects array
	// Different indices and ranges are dedicated to different kinds of
	// objecs.
	enum GameObjIndex {
		OBJ_NOTINDEXED = -1, // Not stored in array
		OBJ_DIRECTOR   =  0
		// TODO
	} index;

	unsigned  otherBitfield;
	float     reverseSortKey; // Sign flipped to produced sortKey
	unsigned  sortKey;        // Four-level key, one byte each
	D3DVECTOR someTranslation;

	// Links forming a tree of objects
	GameObj * parent;
	GameObj * firstChild;
	GameObj * prevSibling;
	GameObj * nextSibling;

	// Some kind of linked list walked during rendering
	GameObj *     somethingLinkedNext;
	GameObj * *   somethingLinkedPrevNext;
	GameObj * * * somethingLinkedEndNextPtr;

	// Another linked list sort of arrangement
	GameObj * someKindOfNextObj;

public:
	virtual ~GameObj();
	GameObj(GameObj * parent, GameObjIndex index, GameObjFlags flags);

	// 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 execDefault();
	virtual void postExecDefault();
	virtual void drawDefault();

	virtual void execEvent();
	virtual void postExecEvent();
	virtual void drawEvent();

	virtual void execCoveredPause();
	virtual void postExecCoveredPause();
	virtual void drawCoveredPause();

	virtual void execFreezeCam();
	virtual void postExecFreezeCam();
	virtual void drawFreezeCam();

	virtual void execUncoveredPause();
	virtual void postExecUncoveredPause();
	virtual void drawUncoveredPause();

	// TODO: non-virtual methods
};

// Top-level globally-accessible "god object" that runs the main loop and
// provides global access to most other objects and many variables
extern class Game {
	char         unknown0x4[4];
	unsigned     unknown0x8;
	unsigned *   unknown0xC;
	int          initState;
	unsigned     unknown0x14;
	BOOL         drawProfilingInfo;
	int          unknown0x1C;
	BOOL         logosStarted;
	BOOL         fatalErr;

	D3DCOLOR     colour;
	D3DCOLOR     ambientColour;
	D3DCOLOR     shadowColour;
	D3DCOLOR     bgColour;
	D3DCOLOR     bgColourFallback;
	BOOL         useFallbackBgColour;

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

	BOOL         setCoveredPauseNextFrame;
	BOOL         unsetCoveredPauseNextFrame;
	BOOL         setEventNextFrame;
	BOOL         unsetEventNextFrame;
	BOOL         setFreezeCamNextFrame;
	BOOL         unsetFreezeCamNextFrame;
	BOOL         setUncoveredPauseNextFrame;
	BOOL         unsetUncoveredPauseNextFrame;

	unsigned     unknown0x70;
	BOOL         skipDraw;
	int          zeroedByExec;
	GraphicsPerformanceCounters perfCounters;

	enum DrawMode {
		DRAW_YES,
		DRAW_WAITVBLANK,
		DRAW_NO
	} drawMode;

	// Globally accessible objects and variables
	GameObj  *   objects[7668];
	unsigned     globals[461]; // Items may be any 32-bit type, e.g. ptr

	GameObj  *   somethingLinkedBHead;
	GameObj  * * somethingLinkedBEndNext;

	GameObj  *   somethingLinkedAHead;
	GameObj  * * somethingLinkedAEndNext;

	GameObj  *   sortedLinkedListHead;
	GameObj  * * sortedLinkedListEndNext;

	GameObj  *   linkedListsByKeyHeads  [256];
	GameObj  * * linkedListByKeyEndNexts[256];

	LARGE_INTEGER execPerfCount;
	LARGE_INTEGER drawPerfCount;

	unsigned     unknown0x87C8;
	unsigned     unknown0x87CC;
	unsigned     frameCnt1;
	unsigned     unknown0x87D4;
	unsigned     unknown0x87D8;
	GameObj  *   rootExecObj;
	int          frameCnt2;
	int          frameCnt3;
	unsigned     gameObjCnt;
	GameObj  *   rootDrawObj;
	int          unknown0x87F0;
	int          unknown0x87F4;
	Mat4         unknown0x87F8;
	unsigned     unknown0x8838;
	unsigned     unknown0x883C;

public:
	Game(unsigned *, unsigned);
	virtual ~Game();

	void initExecRootObj();
	void mainLoop();
	// TODO: other methods
} * g_game;


#endif