#include "stdafx.h"
#include "RCKShaderWrapper.h"

//-----------------------------------------------------------------------------
RCKShaderWrapper::RCKShaderWrapper(ShaderManagerWrapper *man, XArray<WCKShader>& WCKShaderArray) :
	m_ShaderManagerWrapper(man)
{
	m_CurrentShaderManager	= m_ShaderManagerWrapper->GetCurrentShaderManager();
	m_CurrentRCKShader		= NULL;
	m_WCKShaderArray		= WCKShaderArray;

	int shaderNum = WCKShaderArray.Size();

	for (int i = 0 ; i < shaderNum ; i++) {
		switch(WCKShaderArray[i].type) {
	#ifndef macintosh	
		case CKSM_HLSL:
			((RCKShader*)WCKShaderArray[i].shader)->m_ShaderName = &m_ShaderName;
			if (m_CurrentShaderManager->m_Type == CKSM_HLSL)
				m_CurrentRCKShader = WCKShaderArray[i].shader;
			break;
	#endif		
		case CKSM_CGFX:
	#if defined(MULTIPLESHADERMANAGER) // !macintosh
			((RCKShaderCG*)WCKShaderArray[i].shader)->m_ShaderName = &m_ShaderName;
	#else
			((RCKShaderCG*)WCKShaderArray[i].shader)->SetName(m_ShaderName);
	#endif
			if (m_CurrentShaderManager->m_Type == CKSM_CGFX)
				m_CurrentRCKShader = WCKShaderArray[i].shader;
			break;
		default:
			XASSERT(WCKShaderArray[i].type != CKSM_HLSL && WCKShaderArray[i].type != CKSM_CGFX);
			break;
		}
	}
	XASSERT(m_CurrentRCKShader);

	m_Save = TRUE;
	m_ListInEditor = TRUE;
}

//-----------------------------------------------------------------------------
RCKShaderWrapper::~RCKShaderWrapper()
{
	for (int i=0 ; i < m_WCKShaderArray.Size() ; i++) {
		delete m_WCKShaderArray[i].shader;
	}
	m_WCKShaderArray.Clear();
}

//-----------------------------------------------------------------------------
CKBOOL	RCKShaderWrapper::IsSupported() const
{
	return m_CurrentRCKShader->IsSupported();
}

//-----------------------------------------------------------------------------
int		RCKShaderWrapper::Begin( CKRenderContext* rc )
{
	PIXE("RCKShaderWrapper::Begin");
	return m_CurrentRCKShader->Begin(rc);
}

//-----------------------------------------------------------------------------
void	RCKShaderWrapper::BeginPass( CKDWORD Num, CKRenderContext* rc )
{
	PIXE("RCKShaderWrapper::BeginPass");
	m_CurrentRCKShader->BeginPass(Num, rc);
}

//-----------------------------------------------------------------------------
void	RCKShaderWrapper::EndPass( CKRenderContext* rc )
{
	PIXE("RCKShaderWrapper::EndPass");
	m_CurrentRCKShader->EndPass(rc);
}


//-----------------------------------------------------------------------------
void	RCKShaderWrapper::CommitChanges( CKRenderContext* rc )
{
	PIXE("RCKShaderWrapper::CommitChanges");
	m_CurrentRCKShader->CommitChanges(rc);
}

//-----------------------------------------------------------------------------
void	RCKShaderWrapper::End( CKRenderContext* rc )
{
	PIXE("RCKShaderWrapper::End");
	m_CurrentRCKShader->End(rc);
}

//-----------------------------------------------------------------------------
void	RCKShaderWrapper::SetTechnique( const XString& iTechName )
{
	PIXE("RCKShaderWrapper::SetTechnique");
	m_CurrentRCKShader->SetTechnique(iTechName);
}

//-----------------------------------------------------------------------------
void	RCKShaderWrapper::SetTechnique( int iTechIndex )
{
	PIXE("RCKShaderWrapper::SetTechnique");
	m_CurrentRCKShader->SetTechnique(iTechIndex);
}

//-----------------------------------------------------------------------------
int 
RCKShaderWrapper::GetTechniquesCount()	const
{
	return m_CurrentRCKShader->GetTechniquesCount();
}

//-----------------------------------------------------------------------------
bool	
RCKShaderWrapper::GetTechIndexByName( const XString& iTechName, int& oPos ) const
{
	//--- Tech Name Should be the same for all Render Contexts
	return m_CurrentRCKShader->GetTechIndexByName(iTechName, oPos);
}

//-----------------------------------------------------------------------------
void 
RCKShaderWrapper::GetTechniqueInfo( int iTechIndex, TechniqueInfo& oTechInfo )	const
{
	m_CurrentRCKShader->GetTechniqueInfo(iTechIndex, oTechInfo);
}

//-----------------------------------------------------------------------------
bool	RCKShaderWrapper::FindNextValidTechnique( int& ioTechIndex, XString* oTechName ) const
{
	return m_CurrentRCKShader->FindNextValidTechnique(ioTechIndex, oTechName);
}

//-----------------------------------------------------------------------------
int				
RCKShaderWrapper::GetTechniqueEnumValue( const XString& iTechName ) const
{
	return m_CurrentRCKShader->GetTechniqueEnumValue(iTechName);
}

//-----------------------------------------------------------------------------
void
RCKShaderWrapper::GetTechniqueEnumString( int num, XString& oName ) const
{
	m_CurrentRCKShader->GetTechniqueEnumString(num, oName);
}

//-----------------------------------------------------------------------------
int		
RCKShaderWrapper::GetPassCount( int iTechIndex ) const
{
	return m_CurrentRCKShader->GetPassCount(iTechIndex);
}

//-----------------------------------------------------------------------------
void	
RCKShaderWrapper::GetPassInfo( int iTechIndex, int iPassIndex, PassInfo& oPassInfo ) const
{
	m_CurrentRCKShader->GetPassInfo(iTechIndex, iPassIndex, oPassInfo);
}

//-----------------------------------------------------------------------------
bool	
RCKShaderWrapper::GetPassIndexByName( int iTechIndex, const char* iPassName, int& oPos ) const
{
	return m_CurrentRCKShader->GetPassIndexByName(iTechIndex, iPassName, oPos);
}

//-----------------------------------------------------------------------------
// Effect parameters feature
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Execute Exposed Params Meanings 
void	RCKShaderWrapper::SetParameters(const XArray<CKParameterLocal*>& params)
{

	PIXE("RCKShaderWrapper::SetParameters");
	m_CurrentRCKShader->SetParameters(params);
}

//-----------------------------------------------------------------------------
// Execute Params Meanings (non-exposed)
// called by SetValuesOfUsedAutomatics()
//
void RCKShaderWrapper::ExecuteMeanings( CK3dEntity* iEnt, CKMaterial* iMat, CKMaterialShader* iMatShader, CKRenderContext* iRC )
{
	PIXE("RCKShaderWrapper::ExecuteMeanings");
	m_CurrentRCKShader->ExecuteMeanings(iEnt, iMat, iMatShader, iRC);
}

//-----------------------------------------------------------------------------
void RCKShaderWrapper::ExecutePerPassMeanings( CK3dEntity* iEnt, CKMaterial* iMat, CKMaterialShader* iMatShader, CKRenderContext* iRC )
{
	PIXE("RCKShaderWrapper::ExecutePerPassMeanings");
	m_CurrentRCKShader->ExecutePerPassMeanings(iEnt, iMat, iMatShader, iRC);
}

//-----------------------------------------------------------------------------
int RCKShaderWrapper::GetAutoParameterCount( CKRenderContext* rc )
{
	return m_CurrentRCKShader->GetAutoParameterCount(rc);
}

//-----------------------------------------------------------------------------
int RCKShaderWrapper::GetExposedParameterCount( CKRenderContext* rc )
{
	return m_CurrentRCKShader->GetExposedParameterCount(rc);
}

//-----------------------------------------------------------------------------
void RCKShaderWrapper::GetAutoParameterInfo( int paramIndex, ParamInfo& paramInfo, CKRenderContext* rc )
{
	if(m_CurrentRCKShader->GetHideFlag()) return;
	m_CurrentRCKShader->GetAutoParameterInfo(paramIndex, paramInfo, rc);
}

//-----------------------------------------------------------------------------
void RCKShaderWrapper::GetExposedParameterInfo( int paramIndex, ParamInfo& paramInfo, CKRenderContext* rc )
{
	if(m_CurrentRCKShader->GetHideFlag()) return;
	m_CurrentRCKShader->GetExposedParameterInfo(paramIndex, paramInfo, rc);
}

//-----------------------------------------------------------------------------
bool RCKShaderWrapper::LinkParameters(int& CompID, XArray<CKParameterLocal*>& params, CKBOOL cleanup)
{
	return m_CurrentRCKShader->LinkParameters(CompID, params, cleanup);
}

//-----------------------------------------------------------------------------
bool	
RCKShaderWrapper::LinkTechnique( int& CompID, const XString& iTechName, BOOL iFNVT, int& oTechIndex )
{
	return m_CurrentRCKShader->LinkTechnique(CompID, iTechName, iFNVT, oTechIndex);
}

//-----------------------------------------------------------------------------
// Compiling
//-----------------------------------------------------------------------------
void	RCKShaderWrapper::Compile(CKContext* Context)
{
	switch(m_CurrentShaderManager->m_Type) {
	#ifndef macintosh
	case CKSM_HLSL:
		((RCKShader*)m_CurrentRCKShader)->Compile(Context);
		break;
	#endif
	case CKSM_CGFX:
		((RCKShaderCG*)m_CurrentRCKShader)->Compile(Context);
		break;
	default:
		XASSERT(0);
		break;
	} 
}

//-----------------------------------------------------------------------------
// Registering
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
CKSTRING	RCKShaderWrapper::GetClassName()
{
	return "Shader";
}