#pragma once
#pragma warning( disable : 4786)

/*RenderStateManager.h - John Dexter - 21/6/2005

  This class implements functionality to do 2 things:
  1)Maintain the D3D render & texture stage states in a reliable way
  2)Reduce the number of D3D Renderstate and TextureStagestate changes
*/

#define SIZE_D3DRS 174
#define SIZE_D3DTSS 29
#define NUM_TEXTURE_STAGES 8
//#define NOT_SET 0xffffffff

/*#ifdef _DEBUG
	#define RENDER_STATE_MANAGER_DBG
#else #ifdef RENDER_STATE_MANAGER_DBG
	#undef RENDER_STATE_MANAGER_DBG
#endif
*/
#include <vector>
#include <d3d.h>
#include "class logger.h"

class RenderState
{
public:
	D3DRENDERSTATETYPE m_State;
	DWORD m_Value;
	RenderState(D3DRENDERSTATETYPE state,DWORD value) : m_State(state),m_Value(value)
	{}
};
class TextureStageState
{
public:
	DWORD m_Stage;
	D3DTEXTURESTAGESTATETYPE m_State;
	DWORD m_Value;
	TextureStageState(DWORD stage,D3DTEXTURESTAGESTATETYPE state,DWORD value) : m_Stage(stage),m_State(state),m_Value(value)
	{}
};

typedef std::vector<RenderState> RenderStateVector;
typedef std::vector<TextureStageState> TextureStageStateVector;

class RenderStateManager
{
private:
	IDirect3DDevice8 *m_Device;
	//The D3D Device to set the states on
	DWORD m_RenderStates[SIZE_D3DRS];
	//the current set of D3D render states which are required
	DWORD m_TextureStageStates[NUM_TEXTURE_STAGES][SIZE_D3DTSS];
	//the current set of D3D texture stage states which are required for each stage

	std::vector<RenderStateVector> m_RenderStateStack;
	//the render states which have been pushed onto the stack
	std::vector<TextureStageStateVector> m_TextureStageStateStack;
	//the TextureStage states which have been pushed onto the stack
#ifdef RENDER_STATE_MANAGER_DBG
	unsigned m_NumRenderStateCalls,m_NumRenderRedundantStateCalls,m_NumTextureStageStateCalls,m_NumTextureStageRedundantStateCalls;
	unsigned m_NumConsecutiveRenderPushes,m_NumConsecutiveTextureStagePushes;
#endif
public:
	RenderStateManager(IDirect3DDevice8 *device) : m_Device(device)
	{
		int i,j;
		for(i=0; i<SIZE_D3DRS; ++i)
			m_Device->GetRenderState((D3DRENDERSTATETYPE)i,&m_RenderStates);
		
		for(i=0; i<SIZE_D3DTSS; ++i)
		for(j=0;j<NUM_TEXTURE_STAGES; ++j)
			m_Device->GetTextureStageState(j,(D3DTEXTURESTAGESTATETYPE)i,&m_TextureStageStates[j]);
	}
	//initialise with defaults
	
	~RenderStateManager(){}

/*	pass in a set of states and their desired values. The current values for these
	set of states are recorded, and the new values applied */
	void PushRenderStateBlock(const RenderStateVector &block)
	{
		RenderStateVector currentState;
		//build a list of the current values for each state which is to change
		for(RenderStateVector::const_iterator I=block.begin();I!=block.end();++I)
		{
			const RenderState &rs = *I;
			if(rs.m_Value != m_RenderStates[rs.m_State])
			{
				currentState.push_back(RenderState(rs.m_State,m_RenderStates[rs.m_State]));
				//set and record the new value for this state
				m_RenderStates[rs.m_State]=rs.m_Value;
				m_Device->SetRenderState(rs.m_State,rs.m_Value);
			}
		#ifdef RENDER_STATE_MANAGER_DBG
			else
				++m_NumRenderRedundantStateCalls;
			++m_NumRenderStateCalls;
		#endif
		}
		//store the previous settings to restore later
		if(!currentState.empty())
			m_RenderStateStack.push_back(currentState);

	#ifdef RENDER_STATE_MANAGER_DBG
		++m_NumConsecutiveRenderPushes;
		if(m_NumConsecutiveRenderPushes > 1)
		{
			sprintf(Logger::buffer,"RenderStateManager::PushRenderStateBlock : %d consecutive pushes",m_NumConsecutiveRenderPushes);
			Logger::OutputLine();
		}
	#endif
	}

/*	gets the last set of states set, and restores the previous values */
	void PopRenderStateBlock()
	{
		if(m_RenderStateStack.empty())
			return;
		RenderStateVector &popState = m_RenderStateStack.back();
		for(RenderStateVector::iterator I=popState.begin();I!=popState.end();++I)
		{
			RenderState &rs = *I;
			//set and record the new value for this state
			m_RenderStates[rs.m_State]=rs.m_Value;
			m_Device->SetRenderState(rs.m_State,rs.m_Value);
		}
		m_RenderStateStack.pop_back();
	#ifdef RENDER_STATE_MANAGER_DBG
		m_NumConsecutiveRenderPushes = 0;
	#endif
	}


/*	pass in a set of stage states and their desired values. The current values for these
	set of states are recorded, and the new values applied */
	void PushTextureStageStateBlock(const TextureStageStateVector &block)
	{
		TextureStageStateVector currentState;
		//build a list of the current values for each state which is to change
		for(TextureStageStateVector::const_iterator I=block.begin();I!=block.end();++I)
		{
			const TextureStageState &tss = *I;
			if(tss.m_Value != m_TextureStageStates[tss.m_Stage][tss.m_State])
			{
				currentState.push_back(TextureStageState(tss.m_Stage,tss.m_State,m_TextureStageStates[tss.m_Stage][tss.m_State]));
				//set and record the new value for this state
				m_TextureStageStates[tss.m_Stage][tss.m_State]=tss.m_Value;
				m_Device->SetTextureStageState(tss.m_Stage,tss.m_State,tss.m_Value);
			}
		#ifdef RENDER_STATE_MANAGER_DBG
			else
				++m_NumTextureStageRedundantStateCalls;
			++m_NumTextureStageStateCalls;
		#endif
		}
		//store the previous settings to restore later
		if(!currentState.empty())
			m_TextureStageStateStack.push_back(currentState);
	#ifdef RENDER_STATE_MANAGER_DBG
		++m_NumConsecutiveTextureStagePushes;
		if(m_NumConsecutiveTextureStagePushes > 1)
		{
			sprintf(Logger::buffer,"RenderStateManager::PushTextureStageStateBlock : %d consecutive pushes",
				m_NumConsecutiveTextureStagePushes);
			Logger::OutputLine();
		}
	#endif
	}

/*	gets the last set of states set, and restores the previous values */
	void PopTextureStageStateBlock()
	{
		if(m_TextureStageStateStack.empty())
			return;
		TextureStageStateVector &popState = m_TextureStageStateStack.back();
		for(TextureStageStateVector::iterator I=popState.begin();I!=popState.end();++I)
		{
			TextureStageState &tss = *I;
			//set and record the new value for this state
			m_TextureStageStates[tss.m_Stage][tss.m_State]=tss.m_Value;
			m_Device->SetTextureStageState(tss.m_Stage,tss.m_State,tss.m_Value);
		}
		m_TextureStageStateStack.pop_back();
	#ifdef RENDER_STATE_MANAGER_DBG
		m_NumConsecutiveTextureStagePushes = 0;
	#endif
	}


	void BeginScene()
	{
#ifdef RENDER_STATE_MANAGER_DBG
		m_NumRenderStateCalls=0;
		m_NumRenderRedundantStateCalls=0;
		m_NumTextureStageStateCalls=0;
		m_NumTextureStageRedundantStateCalls=0;
		m_NumConsecutiveRenderPushes = 0;
		m_NumConsecutiveTextureStagePushes = 0;
#endif
	}
	void EndScene()
	{
#ifdef RENDER_STATE_MANAGER_DBG
//		sprintf(Logger::buffer,"RenderStateManager::EndScene : Render %u/%u, TextureStage %u/%u",
//				m_NumRenderRedundantStateCalls,m_NumRenderStateCalls,m_NumTextureStageRedundantStateCalls,m_NumTextureStageStateCalls);
//		Logger::OutputLine();
#endif
	}
};