#ifndef RendererDX11_h__
#define RendererDX11_h__

#include "Globals.h"
#include <render/IRenderer.h>
#include "math/LifeMath.h"
#include <Build.h>
#include "ITexture2D11.h"
#include <d3dcompiler.h>
#include "render/dx11/IVertexBuffer11.h"
#include "render/dx11/IIndexBuffer11.h"
#include "Globals.h"

#include "render/RenderParams.h"
#include <PluginServer.h>
#include <d3d11.h>
#include <dxgi.h>
#include <d3dx11.h>
#include "render/dx11/IVertexShader11.h"
#include "render/dx11/IPixelShader11.h"
#include "render/dx11/IInputLayout11.h"
#include "render/dx11/IBlendState11.h"
#include "math/LifeMath.h"
#include "render/dx11/IRasterizerState11.h"
#include "render/dx11/ITextureSampler11.h"
#include "render/dx11/ISurface11.h"

#include "render/dx11/ISwapChain11.h"

namespace LifeGraphics
{
	struct SimpleVertex
	{
		LifeMath::float4 Pos;
		LifeMath::float2 TC;
	};
	class RendererDX11 : public IRenderer
	{
	public:
		RendererDX11(){};
		~RendererDX11(){printf("Destroying renderer...");Close();};
		virtual HRESULT Open(RenderParams params);
		virtual void Close();
		//virtual void ClearBuffers(int flags, int rtColor, float zValue, int stencilValue);
		virtual const String& GetRendererName() const {
			static String sName("DirectX11 graphics driver");
			return sName;
		}

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

		ITexture2D* CreateRenderTarget(int width, int height, int format);
		ITexture2D* CreateDepthTarget(int width, int height, int format);
		ITexture2D* LoadTexture2D(LifeCore::IDataStreamPtr src);
		ITexture2D* CreateTexture2D(int canRead, int canWrite, int width, int height, int format);
		void RenderToTexture();
		void RenderToTextureNoPs();
		void RenderToTextureNoShader();
		IVertexBuffer* CreateVertexBuffer(int size, void* data, int stride);
		IVertexBuffer* CreateVertexBufferDynamic(int size, int stride);
		IIndexBuffer* CreateIndexBuffer(int size, void* data, int sixteenBit);
		IIndexBuffer* CreateIndexBufferDynamic(int size, bool sixteenBit);
		IInputLayout* CreateInputLayout(IInputElement* elements, int elementCount, IShader* vertexShader);

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

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

		IConstantBuffer* CreateConstantBuffer(int size);

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

		void SetInputLayout(IInputLayout* layout);
		void RenderMesh(IMesh* mesh);

		void SetMaterial(IMaterial* material);

		void SetTargets(ITexture2D* colorTarget, ITexture2D* depthTarget);
		void SetTargets(ISurface* colorTarget, ISurface* depthTarget);
		void SetCubeTarget(ITexture2D* colorTarget, ITexture2D* depthTarget, int faceIndex);

		void SetVertexBuffer(IVertexBuffer* vb);
		void SetIndexBuffer(IIndexBuffer* ib);

		void SetPrimitiveTopology(PRIMITIVE_TOPOLOGY topology);
		void SetPSTextureCube(ITexture2D* texture, int slot);
		void DrawIndexed(int offset, int length);

		void SetVertexShader(IShader* shader);
		void SetPixelShader(IShader* shader);

		void SetPSTexture(ITexture2D* texture, int slot);
		void SetVSTexture(ITexture2D* texture, int slot);

		void UnbindResourcesPS();

		void Draw(int vertexCount, int vertexOffset);

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

		void SetBlendState(IBlendState* state);

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

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

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

		void SetScissorRectangle(const LifeMath::Rect2i& rect);

		void SetViewport(const LifeMath::Rect2i& rect);

		ITexture2D* CreateRenderTargetCube(int size, int format);

		ITexture2D* CreateDepthTargetCube(int width, int format);

		void SetPSTextureNULL(int slot);

		void SetPSTextureSampler(ITextureSampler* sampler, int slot);

		ITextureSampler* CreateTextureSampler(ISamplerDescription* desc);

		void SetColorTarget(ITexture2D* colorTarget);
		void SetDepthTarget(ITexture2D* depthTarget);

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

		void SetPSTexture(ITexture2D* texture, ITexture2D* texture2, int start, int count);

		IShader* CompileUserShaderPS(char* data);

		IVertexBuffer11* testVb;

		IRasterizerState* CreateRasterizerState(FILL_MODE mode);

		void DrawIndexed(int offset, int length, int baseVertex);

		void SetRasterizerState(IRasterizerState* state);

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

		void UnbindRenderTargets();

		void SetVertexBuffer(IVertexBuffer** vb, int count);

		void DrawIndexedInstanced(int offset, int length, int instanceCnt);

		void DrawIndexedInstanced(int offset, int length, int baseVertex, int instanceCnt);

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

		IRasterizerState* CreateRasterizerState(FILL_MODE mode, CULL_MODE cmode);

		void DownSample2x2(ITexture2D* src, ITexture2D* dst, ITexture2D* depth);
		void BlurGaussH(ITexture2D* src, ITexture2D* dst, ITexture2D* depth);
		void BlurGaussV(ITexture2D* src, ITexture2D* dst, ITexture2D* depth);

		void BeginCleanup();
		void EndCleanup();

		void ClearRenderTarget(ITexture2D* tex, LifeMath::float4* color);
		void ClearDepthStencil(ITexture2D* tex, float zValue, int stencilValue);
		void ClearDepthStencil(ITexture2D* tex, int flag, float zValue, int stencilValue);

		int GetDisplayModes(LifeCore::DisplayMode** modeList);

        ISwapChain* CreateSwapChain(LifeCore::IRenderWindow* window);
	private:

		IShader* ds2x2;
		IConstantBuffer* ds2x2cb;

		IDXGIAdapter* pDXGIAdapter;
		IDXGIDevice* pDXGIDevice;
		IDXGIOutput* pDXGIOutput;

		ID3D11RasterizerState* rState;
		ID3D11Device* g_pDevice;
		ID3D11DeviceContext* g_pDeviceContext;
		//IDXGISwapChain* g_pSwapChain;

		//ID3D11RenderTargetView* g_pBackBuffer;
		//ID3D11DepthStencilView* g_pDepthBuffer;

		//ID3D11RenderTargetView* currentBackBuffer;
		//ID3D11DepthStencilView* currentDepthBuffer;

		D3D_FEATURE_LEVEL g_pFeatureLevel;
		D3D_DRIVER_TYPE g_driverType;
		ID3D11Buffer* fsQuadBuffer;
		ID3D11PixelShader* psQuad;
		ID3D11VertexShader* vsQuad;
		ID3D11InputLayout* fsQuadLayout;
		ID3D11SamplerState* samplerLinear;
		ID3D11SamplerState* samplerPoint;
		//ID3D11Texture2D* pBuffer;
		//ID3D11Texture2D* dBuf;
		//Camera* cam;

		ID3D11PixelShader* psVerticalBlur;

		IConstantBuffer* vbBuffer;

		IDXGIFactory* pFactory;
	};
}
#endif // RendererDX11_h__