LifeProject/LifeGraphics/render/RendererSoftware.h

#ifndef RendererSoftware_h__
#define RendererSoftware_h__

#include "Globals.h"
#include "render/IRenderer.h"
#include "math/LifeMath.h"
#include <Build.h>
#include "render/software/ITexture2DS.h"
#include "render/software/IVertexBufferS.h"
#include "render/software/IIndexBufferS.h"

#include "render/RenderParams.h"
#include <PluginServer.h>
#include "render/software/IVertexShaderS.h"
#include "render/software/IPixelShaderS.h"
#include "render/software/IInputLayoutS.h"
#include "render/software/IBlendStateS.h"
#include "math/LifeMath.h"
#include "render/software/IRasterizerStateS.h"
#include "render/software/ITextureSamplerS.h"

namespace LifeGraphics
{
	class RendererSoftware : public IRenderer
	{
	public:
		RendererSoftware(){};
		~RendererSoftware(){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 std::string &GetRendererName() const {
			static String sName("LifeEngine software graphics driver");
			return sName;
		}
		ITexture2D* CreateRenderTarget(int width, int height, int format);
		ITexture2D* CreateDepthTarget(int width, int height, int format);
		ITexture2D* LoadTexture2D(LifeCore::IDataStream* 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(LifeCore::IDataStream* stream);
		IShader* CompileVertexShader(LifeCore::IDataStream* stream, std::vector<IMacroDefine>* defines);

		IShader* CompilePixelShader(LifeCore::IDataStream* stream);
		IShader* CompilePixelShader(LifeCore::IDataStream* 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 SwapBuffers();
		void RenderMesh(IMesh* mesh);

		void SetCamera(Camera* camera);
		void SetMaterial(IMaterial* material);

		void SetTargets(ITexture2D* colorTarget, ITexture2D* depthTarget);

		void SetDefaultTargets();

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

		void SetPrimitiveTopology(PRIMITIVE_TOPOLOGY topology);

		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);

		void SetDepthStencilState(IDepthStencilState* state);

		void SetScissorRectangle(const Rectangle2D& rect);

		void SetViewport(const Rectangle2D& 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);

		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 Rectangle2D& rect, float minDepth, float maxDepth);

		IRasterizerState* CreateRasterizerState(FILL_MODE mode, CULL_MODE cmode);

		void BeginCleanup();
		void EndCleanup();

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

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

	private:
		struct SimpleVertex
		{
			LifeMath::float4 Pos;
			LifeMath::float2 TC;
		};
		//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;
		LifeMath::float4x4 wvp;
		//ID3D11Buffer* fsQuadBuffer;
		//ID3D11PixelShader* psQuad;
		//ID3D11VertexShader* vsQuad;
		//ID3D11InputLayout* fsQuadLayout;
		//ID3D11SamplerState* samplerLinear;
		//ID3D11SamplerState* samplerPoint;
		//ID3D11Texture2D* pBuffer;
		//ID3D11Texture2D* dBuf;
		Camera* cam;

		//ID3D11PixelShader* psVerticalBlur;

		IConstantBuffer* vbBuffer;
	};
}

#endif // RendererSoftware_h__