GabsPuNs-Project_Zenith_Main/Minecraft.World/C4JThread.h

#pragma once
#include <queue>

typedef int (C4JThreadStartFunc)(void* lpThreadParameter);

class Level;

#define CPU_CORE_MAIN_THREAD 0

#define CPU_CORE_CHUNK_REBUILD_A 1
#define CPU_CORE_SAVE_THREAD_A 1

#define CPU_CORE_TILE_UPDATE 2

#define CPU_CORE_CONNECTIONS 3
#define CPU_CORE_UI_SCENE 3

#define CPU_CORE_CHUNK_UPDATE 4

#define CPU_CORE_CHUNK_REBUILD_B 5
#define CPU_CORE_SAVE_THREAD_B 5

#define CPU_CORE_REMOVE_PLAYER 6
#define CPU_CORE_POST_PROCESSING 6

#define CPU_CORE_SERVER 7

#define CPU_CORE_CHUNK_REBUILD_C 8
#define CPU_CORE_SAVE_THREAD_C 8

class C4JThread
{
public:

	class Event
	{
	public:
		enum EMode
		{
			e_modeAutoClear,
			e_modeManualClear
		};
		Event(EMode mode = e_modeAutoClear);
		~Event();
		void Set();
		void Clear();
		DWORD WaitForSignal(int timeoutMs);

	private:
		EMode	m_mode;
		HANDLE m_event;
	};

	class EventArray
	{
	public:
		enum EMode
		{
			e_modeAutoClear,
			e_modeManualClear
		};

		EventArray(int size, EMode mode = e_modeAutoClear);
		~EventArray();

		void Set(int index);
		void Clear(int index);
		void SetAll();
		void ClearAll();
		DWORD WaitForAll(int timeoutMs);
		DWORD WaitForAny(int timeoutMs);
		DWORD WaitForSingle(int index, int timeoutMs);

	private:
		int		m_size;
		EMode	m_mode;

		HANDLE*	m_events;
	};

	class EventQueue
	{
		typedef void (UpdateFunc)(void* lpParameter);
		typedef void (ThreadInitFunc)();

		C4JThread*				m_thread;
		std::queue<void*>		m_queue;
		C4JThread::EventArray*	m_startEvent;
		C4JThread::Event*		m_finishedEvent;
		CRITICAL_SECTION		m_critSect;
		UpdateFunc*				m_updateFunc;
		ThreadInitFunc*			m_threadInitFunc;
		char					m_threadName[64];
		int						m_processor;
		int						m_priority;
		void init();
		static int threadFunc(void* lpParam);
		void threadPoll();

	public:
		EventQueue(UpdateFunc* updateFunc, ThreadInitFunc threadInitFunc, const char* szThreadName);
		void setProcessor(int proc) { m_processor = proc; if(m_thread) m_thread->SetProcessor(proc); }
		void setPriority(int priority) { m_priority = priority; if(m_thread) m_thread->SetPriority(priority); }
		void sendEvent(Level* pLevel);
		void waitForFinish();
	};

	C4JThread(C4JThreadStartFunc* startFunc, void* param, const char* threadName, int stackSize = 0);
	C4JThread( const char* mainThreadName ); // only used for the main thread
	~C4JThread();

	void Run();
	bool isRunning() { return m_isRunning; }
	bool hasStarted() { return m_hasStarted; }
	void SetProcessor(int proc);
	void SetPriority(int priority);
	DWORD WaitForCompletion(int timeoutMs);
	int GetExitCode();
	char* getName() { return m_threadName; }
	static void Sleep(int millisecs);
	static C4JThread* getCurrentThread();
	static bool isMainThread();
	static char* getCurrentThreadName() { return getCurrentThread()->getName(); }

private:
	void*				m_threadParam;
	C4JThreadStartFunc*	m_startFunc;
	int					m_stackSize;
	char				m_threadName[64];
	bool				m_isRunning;
	bool				m_hasStarted;
	int					m_exitCode;
	int64_t				m_lastSleepTime;
	static std::vector<C4JThread*> ms_threadList;
	static CRITICAL_SECTION ms_threadListCS;

	static C4JThread	m_mainThread;

	DWORD m_threadID;
	HANDLE m_threadHandle;
	Event			*m_completionFlag;
	static DWORD WINAPI	entryPoint(LPVOID lpParam);
};
void SetThreadName( DWORD dwThreadID, LPCSTR szThreadName );


class CriticalSectionScopeLock
{
	CRITICAL_SECTION* m_pCS;
public:
	CriticalSectionScopeLock(CRITICAL_SECTION* pCS) { m_pCS = pCS; EnterCriticalSection(m_pCS); }
	~CriticalSectionScopeLock() { LeaveCriticalSection(m_pCS); }
};