//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======//
//
// Purpose: 
//
// $NoKeywords: $
//
//===========================================================================//

#ifndef SHADERDEVICEDX10_H
#define SHADERDEVICEDX10_H

#ifdef _WIN32
#pragma once
#endif


#include "shaderdevicebase.h"
#include "tier1/utlvector.h"
#include "tier1/utlrbtree.h"
#include "tier1/utllinkedlist.h"


//-----------------------------------------------------------------------------
// Forward declaration
//-----------------------------------------------------------------------------
struct IDXGIFactory;
struct IDXGIAdapter;
struct IDXGIOutput;
struct IDXGISwapChain;
struct ID3D10Device;
struct ID3D10RenderTargetView;
struct ID3D10VertexShader;
struct ID3D10PixelShader;
struct ID3D10GeometryShader;
struct ID3D10InputLayout;
struct ID3D10ShaderReflection;


//-----------------------------------------------------------------------------
// The Base implementation of the shader device
//-----------------------------------------------------------------------------
class CShaderDeviceMgrDx10 : public CShaderDeviceMgrBase
{
	typedef CShaderDeviceMgrBase BaseClass;

public:
	// constructor, destructor
	CShaderDeviceMgrDx10();
	virtual ~CShaderDeviceMgrDx10();

	// Methods of IAppSystem
	virtual bool Connect( CreateInterfaceFn factory );
	virtual void Disconnect();
	virtual InitReturnVal_t Init();
	virtual void Shutdown();

	// Methods of IShaderDeviceMgr
	virtual int	 GetAdapterCount() const;
	virtual void GetAdapterInfo( int adapter, MaterialAdapterInfo_t& info ) const;
	virtual int	 GetModeCount( int nAdapter ) const;
	virtual void GetModeInfo( ShaderDisplayMode_t* pInfo, int nAdapter, int mode ) const;
	virtual void GetCurrentModeInfo( ShaderDisplayMode_t* pInfo, int nAdapter ) const;
	virtual bool SetAdapter( int nAdapter, int nFlags );
	virtual CreateInterfaceFn SetMode( void *hWnd, int nAdapter, const ShaderDeviceInfo_t& mode );

private:
	// Returns the screen resolution
	virtual void GetDesktopResolution( int *pWidth, int *pHeight, int nAdapter ) const;

	// Initialize adapter information
	void InitAdapterInfo();

	// Determines hardware caps from D3D
	bool ComputeCapsFromD3D( HardwareCaps_t *pCaps, IDXGIAdapter *pAdapter, IDXGIOutput *pOutput );

	// Returns the amount of video memory in bytes for a particular adapter
	virtual int GetVidMemBytes( int nAdapter ) const;

	// Returns the appropriate adapter output to use
	IDXGIOutput* GetAdapterOutput( int nAdapter ) const;

	// Returns the adapter interface for a particular adapter
	IDXGIAdapter* GetAdapter( int nAdapter ) const;

	// Used to enumerate adapters, attach to windows
	IDXGIFactory *m_pDXGIFactory;

	friend class CShaderDeviceDx10;
};


//-----------------------------------------------------------------------------
// The Dx10 implementation of the shader device
//-----------------------------------------------------------------------------
class CShaderDeviceDx10 : public CShaderDeviceBase
{
public:
	// constructor, destructor
	CShaderDeviceDx10();
	virtual ~CShaderDeviceDx10();

public:
	// Methods of IShaderDevice
	virtual bool IsUsingGraphics() const;
	virtual int GetCurrentAdapter() const;
	virtual ImageFormat GetBackBufferFormat() const;
	virtual void GetBackBufferDimensions( int& width, int& height ) const;
	virtual void SpewDriverInfo() const;
	virtual void Present();
	virtual IShaderBuffer* CompileShader( const char *pProgram, size_t nBufLen, const char *pShaderVersion );
	virtual VertexShaderHandle_t CreateVertexShader( IShaderBuffer *pShader );
	virtual void DestroyVertexShader( VertexShaderHandle_t hShader );
	virtual GeometryShaderHandle_t CreateGeometryShader( IShaderBuffer* pShaderBuffer );
	virtual void DestroyGeometryShader( GeometryShaderHandle_t hShader );
	virtual PixelShaderHandle_t CreatePixelShader( IShaderBuffer* pShaderBuffer );
	virtual void DestroyPixelShader( PixelShaderHandle_t hShader );
	virtual void ReleaseResources( bool bReleaseManagedResources = true ) {}
	virtual void ReacquireResources() {}
	virtual IMesh* CreateStaticMesh( VertexFormat_t format, const char *pTextureBudgetGroup, IMaterial * pMaterial, VertexStreamSpec_t *pStreamSpec );
	virtual void DestroyStaticMesh( IMesh* mesh );
	virtual IVertexBuffer *CreateVertexBuffer( ShaderBufferType_t type, VertexFormat_t fmt, int nVertexCount, const char *pTextureBudgetGroup );
	virtual void DestroyVertexBuffer( IVertexBuffer *pVertexBuffer );
	virtual IIndexBuffer *CreateIndexBuffer( ShaderBufferType_t type, MaterialIndexFormat_t fmt, int nIndexCount, const char *pTextureBudgetGroup );
	virtual void DestroyIndexBuffer( IIndexBuffer *pIndexBuffer );
	virtual IVertexBuffer *GetDynamicVertexBuffer( int nStreamID, VertexFormat_t vertexFormat, bool bBuffered = true );
	virtual IIndexBuffer *GetDynamicIndexBuffer();
	virtual void SetHardwareGammaRamp( float fGamma, float fGammaTVRangeMin, float fGammaTVRangeMax, float fGammaTVExponent, bool bTVEnabled );

	// A special path used to tick the front buffer while loading on the 360
	virtual void EnableNonInteractiveMode( MaterialNonInteractiveMode_t mode, ShaderNonInteractiveInfo_t *pInfo ) {}
	virtual void RefreshFrontBufferNonInteractive( ) {}
	virtual void HandleThreadEvent( uint32 threadEvent ) {}

public:
	// Methods of CShaderDeviceBase
	virtual bool InitDevice( void *hWnd, int nAdapter, const ShaderDeviceInfo_t& mode );
	virtual void ShutdownDevice();
	virtual bool IsDeactivated() const { return false; }

	// Other public methods
	ID3D10VertexShader* GetVertexShader( VertexShaderHandle_t hShader ) const;
	ID3D10GeometryShader* GetGeometryShader( GeometryShaderHandle_t hShader ) const;
	ID3D10PixelShader* GetPixelShader( PixelShaderHandle_t hShader ) const;
	ID3D10InputLayout* GetInputLayout( VertexShaderHandle_t hShader, VertexFormat_t format );

private:
	struct InputLayout_t
	{
		ID3D10InputLayout *m_pInputLayout;
		VertexFormat_t m_VertexFormat;
	};

	typedef CUtlRBTree< InputLayout_t, unsigned short > InputLayoutDict_t;

	static bool InputLayoutLessFunc( const InputLayout_t &lhs, const InputLayout_t &rhs )	
	{ 
		return ( lhs.m_VertexFormat < rhs.m_VertexFormat );	
	}

	struct VertexShader_t
	{
		ID3D10VertexShader *m_pShader;
		ID3D10ShaderReflection *m_pInfo;
		void *m_pByteCode;
		size_t m_nByteCodeLen;
		InputLayoutDict_t m_InputLayouts;

		VertexShader_t() : m_InputLayouts( 0, 0, InputLayoutLessFunc ) {}
	};

	struct GeometryShader_t
	{
		ID3D10GeometryShader *m_pShader;
		ID3D10ShaderReflection *m_pInfo;
	};

	struct PixelShader_t
	{
		ID3D10PixelShader *m_pShader;
		ID3D10ShaderReflection *m_pInfo;
	};

	typedef CUtlFixedLinkedList< VertexShader_t >::IndexType_t VertexShaderIndex_t;
	typedef CUtlFixedLinkedList< GeometryShader_t >::IndexType_t GeometryShaderIndex_t;
	typedef CUtlFixedLinkedList< PixelShader_t >::IndexType_t PixelShaderIndex_t;

	void SetupHardwareCaps();
	void ReleaseInputLayouts( VertexShaderIndex_t nIndex );

	IDXGIOutput *m_pOutput;
	ID3D10Device *m_pDevice;	
	IDXGISwapChain *m_pSwapChain;
	ID3D10RenderTargetView *m_pRenderTargetView;

	CUtlFixedLinkedList< VertexShader_t > m_VertexShaderDict;
	CUtlFixedLinkedList< GeometryShader_t > m_GeometryShaderDict;
	CUtlFixedLinkedList< PixelShader_t > m_PixelShaderDict;

	friend ID3D10Device *D3D10Device();
	friend IDXGISwapChain *D3D10SwapChain();
	friend ID3D10RenderTargetView *D3D10RenderTargetView();
};


//-----------------------------------------------------------------------------
// Inline methods of CShaderDeviceDx10
//-----------------------------------------------------------------------------
inline ID3D10VertexShader* CShaderDeviceDx10::GetVertexShader( VertexShaderHandle_t hShader ) const
{
	if ( hShader != VERTEX_SHADER_HANDLE_INVALID )
		return m_VertexShaderDict[ (VertexShaderIndex_t)hShader ].m_pShader;
	return NULL;
}

inline ID3D10GeometryShader* CShaderDeviceDx10::GetGeometryShader( GeometryShaderHandle_t hShader ) const
{
	if ( hShader != GEOMETRY_SHADER_HANDLE_INVALID )
		return m_GeometryShaderDict[ (GeometryShaderIndex_t)hShader ].m_pShader;
	return NULL;
}

inline ID3D10PixelShader* CShaderDeviceDx10::GetPixelShader( PixelShaderHandle_t hShader ) const
{
	if ( hShader != PIXEL_SHADER_HANDLE_INVALID )
		return m_PixelShaderDict[ (PixelShaderIndex_t)hShader ].m_pShader;
	return NULL;
}


//-----------------------------------------------------------------------------
// Singleton
//-----------------------------------------------------------------------------
extern CShaderDeviceDx10* g_pShaderDeviceDx10;


//-----------------------------------------------------------------------------
// Utility methods
//-----------------------------------------------------------------------------
inline ID3D10Device *D3D10Device()
{
	return g_pShaderDeviceDx10->m_pDevice;	
}

inline IDXGISwapChain *D3D10SwapChain()
{
	return g_pShaderDeviceDx10->m_pSwapChain;	
}

inline ID3D10RenderTargetView *D3D10RenderTargetView()
{
	return g_pShaderDeviceDx10->m_pRenderTargetView;	
}


#endif // SHADERDEVICEDX10_H