#ifndef I_RENDERER
#define I_RENDERER

#include "render/ITexture2D.h"
#include "render/RenderParams.h"
#include <winerror.h>
#include "LString.h"
#include <math/Rectangle.h>

#include "render/IVertexBuffer.h"
#include "render/IIndexBuffer.h"
#include "render/IInputLayout.h"
#include "render/IShader.h"
#include "render/IMacroDefine.h"
#include "render/IConstantBuffer.h"
#include "ISwapChain.h"
#include "IMesh.h"
#include "camera/Camera.h"
//#include "render/IMaterial.h"
#include "render/IBlendState.h"
#include "render/IDepthStencilState.h"
#include "Rectangle2D.h"
#include "render/IRenderTargetView.h"
#include "render/ITextureSampler.h"
#include "render/IRasterizerState.h"
#include "Types.h"
#include "render/Enums.h"
#include "DisplayMode.h"
#include "render/ISurface.h"

namespace LifeGraphics
{
	class IMaterial;
	enum PassType
	{
		PT_RENDER_SHADOW_MAP = 1 << 0,
		PT_LIGHTING = 1 << 1,
		PT_COMPOSE_FINAL = 1 << 2,
		PT_COMPOSE_G_BUF = 1 << 3,
		PT_ENV_MAP = 1 << 4,
		PT_RENDER_SHADOW_MAP_PSSM = 1 << 5,
	};

	struct PassDesc
	{
		Camera* camera;
		Frustum* frustum;
		PassType type;
		IMesh* mesh;
		uint32 subset;
		uint32 flags;
		ITexture2D* colorTarget;
		ITexture2D* depthTarget;
		ITexture2D* colorTarget1;
		std::vector<IGraphicsNode*> objectList;
	};

	class LIFE_EXPORTS IRenderer
	{
	public:
		IRenderer();
		virtual ~IRenderer();
		virtual void BeginCleanup() = 0;
		virtual void EndCleanup() = 0;
		virtual HRESULT Open(RenderParams params);
		virtual void Close();
		//virtual void ClearBuffers(int flags, int rtColor, float zValue, int stencilValue) = 0;
		virtual void ClearRenderTarget(ITexture2D* tex, LifeMath::float4* color) = 0;
		virtual void ClearDepthStencil(ITexture2D* tex, float zValue, int stencilValue) = 0;
		virtual void ClearDepthStencil(ITexture2D* tex, int flag, float zValue, int stencilValue) = 0;

		virtual void ClearRenderTarget(ISurface* target, LifeMath::float4* color) = 0;
		virtual void ClearDepthStencil(ISurface* target, int flag, float zValue, int stencilValue) = 0;

		virtual ITexture2D* CreateRenderTarget(int width, int height, int format) = 0;
		virtual ITexture2D* CreateRenderTargetCube(int size, int format) = 0;
		virtual ITexture2D* CreateDepthTarget(int width, int height, int format) = 0;
		virtual ITexture2D* CreateDepthTargetCube(int width, int format) = 0;
		virtual const String &GetRendererName() const = 0;
		virtual ITexture2D* LoadTexture2D(LifeCore::IDataStreamPtr src) = 0;
		virtual ITexture2D* CreateTexture2D(int canRead, int canWrite, int width, int height, int format) = 0;
		virtual void RenderToTexture() = 0;
		virtual void RenderToTextureNoPs() = 0;
		virtual void RenderToTextureNoShader() = 0;
		virtual IVertexBuffer* CreateVertexBuffer(int size, void* data, int stride) = 0;
		virtual IVertexBuffer* CreateVertexBufferDynamic(int size, int stride) = 0;

		virtual IIndexBuffer* CreateIndexBuffer(int size, void* data, int sixteenBit) = 0;
		virtual IIndexBuffer* CreateIndexBufferDynamic(int size, bool sixteenBit) = 0;
		virtual IInputLayout* CreateInputLayout(IInputElement* elements, int elementCount, IShader* vertexShader) = 0;

		virtual ITextureSampler* CreateTextureSampler(ISamplerDescription* desc) = 0;

		virtual IShader* CompileVertexShader(const char* pData, int length) = 0;
		virtual IShader* CompileVertexShader(LifeCore::IDataStreamPtr stream) = 0;
		virtual IShader* CompileVertexShader(LifeCore::IDataStreamPtr stream, std::vector<IMacroDefine>* defines) = 0;

		virtual IShader* CompilePixelShader(const char* pData, int length) = 0;
		virtual IShader* CompilePixelShader(LifeCore::IDataStreamPtr stream) = 0;
		virtual IShader* CompilePixelShader(LifeCore::IDataStreamPtr stream, std::vector<IMacroDefine>* defines) = 0;

		virtual IConstantBuffer* CreateConstantBuffer(int size) = 0;

		virtual void SetVSConstantBuffer(IConstantBuffer* buffer, int slot) = 0;
		virtual void SetPSConstantBuffer(IConstantBuffer* buffer, int slot) = 0;

		virtual void SetInputLayout(IInputLayout* layout) = 0;
		virtual void RenderMesh(IMesh* mesh) = 0;

		virtual void SetMaterial(IMaterial* material) = 0;

		virtual void SetTargets(ITexture2D* colorTarget, ITexture2D* depthTarget) = 0;

		virtual void SetTargets(ISurface* colorTarget, ISurface* depthTarget) = 0;

		virtual void SetCubeTarget(ITexture2D* colorTarget, ITexture2D* depthTarget, int faceIndex) = 0;

		virtual void SetTargets(ITexture2D** colorTargets, int targetCount, ITexture2D* depthTarget) = 0;

		virtual void UnbindRenderTargets() = 0;

		virtual void SetColorTarget(ITexture2D* colorTarget) = 0;
		virtual void SetDepthTarget(ITexture2D* depthTarget) = 0;

		virtual void SetVertexBuffer(IVertexBuffer* vb) = 0;
		virtual void SetIndexBuffer(IIndexBuffer* ib) = 0;

		virtual void SetPrimitiveTopology(PRIMITIVE_TOPOLOGY topology) = 0;

		virtual void SetPSTextureNULL(int slot) = 0;
		virtual void DrawIndexed(int offset, int length) = 0;
		virtual void DrawIndexed(int offset, int length, int baseVertex) = 0;

		virtual void SetPSTextureSampler(ITextureSampler* sampler, int slot) = 0;
		virtual void SetVertexShader(IShader* shader) = 0;
		virtual void SetPixelShader(IShader* shader) = 0;

		virtual void SetPSTexture(ITexture2D* texture, int slot) = 0;
		virtual void SetPSTextureCube(ITexture2D* texture, int slot) = 0;
		virtual void SetPSTexture(ITexture2D* texture, ITexture2D* texture2, int start, int count) = 0;

		virtual void SetVSTexture(ITexture2D* texture, int slot) = 0;

		virtual void UnbindResourcesPS() = 0;

		virtual void Draw(int vertexCount, int vertexOffset) = 0;

		virtual IBlendState* CreateBlendState(bool blendEnable, bool atocEnable, BLEND_OP blendOperation, BLEND_SRC srcBlend, BLEND_SRC dstBlend, uint8 colorMask) = 0;

		virtual void SetBlendState(IBlendState* state) = 0;

		virtual IDepthStencilState* CreateDSState(bool zEnable, bool zWrite, COMPARISON_FUNC zFunc) = 0;

		virtual IDepthStencilState* CreateDSState(bool zEnable, bool zWrite, COMPARISON_FUNC zFunc, bool stencil, int stencilMask, int stencilFunc, int stencilFail, int depthFail, int depthFailBack, int stencilPass) = 0;

		virtual void SetDepthStencilState(IDepthStencilState* state, UINT sref = 0) = 0;

		virtual void SetScissorRectangle(const LifeMath::Rect2i& rect) = 0;

		virtual void SetViewport(const LifeMath::Rect2i& rect) = 0;

		virtual void SetViewport(const LifeMath::Rect2i& rect, float minDepth, float maxDepth) = 0;

		virtual void VerticalBlur(ITexture2D* src, ITexture2D* dst, int numSamples) = 0;

		virtual IShader* CompileUserShaderPS(char* data) = 0;

		virtual IRasterizerState* CreateRasterizerState(FILL_MODE mode) = 0;
		virtual IRasterizerState* CreateRasterizerState(FILL_MODE mode, CULL_MODE cmode) = 0;

		virtual void SetRasterizerState(IRasterizerState* state) = 0;

		virtual void SetVertexBuffer(IVertexBuffer** vb, int count) = 0;

		virtual void DrawIndexedInstanced(int offset, int length, int instanceCnt) = 0;
		virtual void DrawIndexedInstanced(int offset, int length, int baseVertex, int instanceCnt) = 0;

		virtual void DownSample2x2(ITexture2D* src, ITexture2D* dst, ITexture2D* depth) = 0;
		virtual void BlurGaussH(ITexture2D* src, ITexture2D* dst, ITexture2D* depth) = 0;
		virtual void BlurGaussV(ITexture2D* src, ITexture2D* dst, ITexture2D* depth) = 0;
		virtual int GetDisplayModes(LifeCore::DisplayMode** modeList) = 0;

        virtual ISwapChain* CreateSwapChain(LifeCore::IRenderWindow* window) = 0;

	protected:
		RenderParams g_params;
	};

	enum RENDERER_TYPE
	{
		RT_DIRECTX_10 = 1 << 0,
		RT_DIRECTX_9 = 1 << 1,
		RT_OPENGL = 1 << 2,
		RT_SOFTWARE = 1 << 3,
		RT_DIRECTX_11 = 1 << 4,
	};
}

#endif