TombEngine/TR5Main/Renderer/Renderer11.h

#pragma once

#include <vector>
#include <string>
#include <array>
#include "Enums.h"

#include <D3D11.h>

#include <SimpleMath.h>
#include <CommonStates.h>
#include <DirectXHelpers.h>
#include <Effects.h>
#include <GeometricPrimitive.h>
#include <PostProcess.h>
#include <PrimitiveBatch.h>
#include <ScreenGrab.h>
#include <SpriteBatch.h>
#include <SpriteFont.h>
#include <VertexTypes.h>
#include <WICTextureLoader.h>

#include "..\Global\global.h"

#define PI 3.14159265358979323846f
#define RADIAN 0.01745329252f

#define DX11_RELEASE(x) if (x != NULL) x->Release()
#define DX11_DELETE(x) if (x != NULL) { delete x; x = NULL; }

using namespace DirectX;
using namespace DirectX::SimpleMath;
using namespace std;

template <class T>
class PreallocatedVector 
{
private:
	T**			m_objects;
	int		m_maxItems;
	int		m_numItems;
	int		m_startSize;

public:
	PreallocatedVector()
	{
		m_objects = NULL;
		m_maxItems = 0;
		m_startSize = 0;
		m_numItems = 0;
	}

	~PreallocatedVector()
	{
		free(m_objects);
	}

	inline void Reserve(int numItems)
	{
		m_objects = (T**)malloc(sizeof(T*) * numItems);
		ZeroMemory(m_objects, sizeof(T*) * m_maxItems);
		m_maxItems = numItems;
		m_numItems = 0;
		m_startSize = numItems;
	}

	inline void Clear()
	{
		m_numItems = 0;
		ZeroMemory(m_objects, sizeof(T*) * m_maxItems);
	}

	inline int Size()
	{
		return m_numItems;
	}

	inline void Sort(int(*compareFunc)(T*, T*))
	{
		qsort(m_objects, m_numItems, sizeof(T), compareFunc);
	}

	inline T*& operator[] (int x) {
		if (x >= m_maxItems)
			return m_objects[0];
		return m_objects[x];
	}

	inline void Add(T* value)
	{
		if (m_numItems >= m_maxItems)
			return;
		m_objects[m_numItems++] = value;
	}
};

template <class T, class U>
class PreallocatedDictionary
{
private:
	T**			m_keys;
	U**			m_objects;
	int		m_maxItems;
	int		m_numItems;
	int		m_startSize;

public:
	PreallocatedDictionary()
	{
		m_keys = NULL;
		m_objects = NULL;
		m_maxItems = 0;
		m_startSize = 0;
		m_numItems = 0;
	}

	~PreallocatedDictionary()
	{
		free(m_keys);
		free(m_objects);
	}

	inline void Reserve(int numItems)
	{
		m_keys = (T**)malloc(sizeof(T*) * numItems);
		m_objects = (U**)malloc(sizeof(U*) * numItems);
		ZeroMemory(m_keys, sizeof(T*) * m_maxItems);
		ZeroMemory(m_objects, sizeof(U*) * m_maxItems);
		m_maxItems = numItems;
		m_numItems = 0;
		m_startSize = numItems;
	}

	inline void Clear()
	{
		m_numItems = 0;
		ZeroMemory(m_keys, sizeof(T*) * m_maxItems);
		ZeroMemory(m_objects, sizeof(T*) * m_maxItems);
	}

	inline int Size()
	{
		return m_numItems;
	}

	inline T*& operator[] (int x) {
		return m_objects[x];
	}

	inline bool KeyExists(T* key)
	{
		for (int i = 0; i < m_numItems; i++)
			if (m_keys[i] == key)
				return true;
		return false;
	}

	inline U* Get(T* key)
	{
		for (int i = 0; i < m_numItems; i++)
			if (m_keys[i] == key)
				return m_objects[i];
		return NULL;
	}

	inline void Add(T* key, U* value)
	{
		m_keys[m_numItems] = key;
		m_objects[m_numItems++] = value;
	}
};

struct RendererDisplayMode {
	int Width;
	int Height;
	int RefreshRate;
};

struct RendererVideoAdapter {
	string Name;
	int Index;
	vector<RendererDisplayMode> DisplayModes;
};

struct RendererVertex {
	Vector3 Position;
	Vector3 Normal;
	Vector2 UV;
	Vector4 Color;
	float Bone;
};

class RenderTarget2D
{
public:
	ID3D11RenderTargetView*	RenderTargetView;
	ID3D11ShaderResourceView* ShaderResourceView;
	ID3D11Texture2D* Texture;
	ID3D11DepthStencilView*	DepthStencilView;
	ID3D11Texture2D* DepthStencilTexture;
	bool IsValid = false;

	RenderTarget2D()
	{

	}

	static RenderTarget2D* Create(ID3D11Device* device, int w, int h, DXGI_FORMAT format)
	{
		RenderTarget2D* rt = new RenderTarget2D();

		D3D11_TEXTURE2D_DESC desc;
		desc.Width = w;
		desc.Height = h;
		desc.MipLevels = 1;
		desc.ArraySize = 1;
		desc.Format = format;
		desc.SampleDesc.Count = 1;
		desc.SampleDesc.Quality = 0;
		desc.Usage = D3D11_USAGE_DEFAULT;
		desc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
		desc.CPUAccessFlags = 0;
		desc.MiscFlags = 0;

		rt->Texture = NULL;
		HRESULT res = device->CreateTexture2D(&desc, NULL, &rt->Texture);
		if (FAILED(res))
			return NULL;

		D3D11_RENDER_TARGET_VIEW_DESC viewDesc;
		viewDesc.Format = desc.Format;
		viewDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
		viewDesc.Texture2D.MipSlice = 0;

		res = device->CreateRenderTargetView(rt->Texture, &viewDesc, &rt->RenderTargetView);
		if (FAILED(res))
			return NULL;

		// Setup the description of the shader resource view.
		D3D11_SHADER_RESOURCE_VIEW_DESC shaderDesc;
		shaderDesc.Format = desc.Format;
		shaderDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
		shaderDesc.Texture2D.MostDetailedMip = 0;
		shaderDesc.Texture2D.MipLevels = 1;

		res = device->CreateShaderResourceView(rt->Texture, &shaderDesc, &rt->ShaderResourceView);
		if (FAILED(res))
			return NULL;

		D3D11_TEXTURE2D_DESC depthTexDesc;
		ZeroMemory(&depthTexDesc, sizeof(D3D11_TEXTURE2D_DESC));
		depthTexDesc.Width = w;
		depthTexDesc.Height = h;
		depthTexDesc.MipLevels = 1;
		depthTexDesc.ArraySize = 1;
		depthTexDesc.SampleDesc.Count = 1;
		depthTexDesc.SampleDesc.Quality = 0;
		depthTexDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
		depthTexDesc.Usage = D3D11_USAGE_DEFAULT;
		depthTexDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
		depthTexDesc.CPUAccessFlags = 0;
		depthTexDesc.MiscFlags = 0;

		rt->DepthStencilTexture = NULL;
		res = device->CreateTexture2D(&depthTexDesc, NULL, &rt->DepthStencilTexture);
		if (FAILED(res))
			return NULL;

		D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;
		ZeroMemory(&dsvDesc, sizeof(D3D11_DEPTH_STENCIL_VIEW_DESC));
		dsvDesc.Format = depthTexDesc.Format;
		dsvDesc.Flags = 0;
		dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
		dsvDesc.Texture2D.MipSlice = 0;

		rt->DepthStencilView = NULL;
		res = device->CreateDepthStencilView(rt->DepthStencilTexture, &dsvDesc, &rt->DepthStencilView);
		if (FAILED(res))
			return NULL;

		return rt;
	}

	~RenderTarget2D()
	{
		DX11_RELEASE(RenderTargetView);
		DX11_RELEASE(ShaderResourceView);
		DX11_RELEASE(Texture);
		DX11_RELEASE(DepthStencilView);
		DX11_RELEASE(DepthStencilTexture);
	}
};

class Texture2D
{
public:
	ID3D11ShaderResourceView* ShaderResourceView;
	ID3D11Texture2D* Texture;

	Texture2D()
	{		
		
	}

	~Texture2D()
	{
		DX11_RELEASE(ShaderResourceView);
		DX11_RELEASE(Texture);
	}

	static Texture2D* LoadFromByteArray(ID3D11Device* device, int w, int h, byte* data)
	{
		Texture2D* texture = new Texture2D();

		D3D11_TEXTURE2D_DESC desc;
		desc.Width = w;
		desc.Height = h;
		desc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
		desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
		desc.MiscFlags = 0;
		desc.MipLevels = 1;
		desc.ArraySize = 1;
		desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
		desc.SampleDesc.Count = 1;
		desc.SampleDesc.Quality = 0;
		desc.Usage = D3D11_USAGE_DYNAMIC;
		
		D3D11_SUBRESOURCE_DATA subresourceData; 
		subresourceData.pSysMem = data; 
		subresourceData.SysMemPitch = w * 4; 
		subresourceData.SysMemSlicePitch = 0;
		
		HRESULT res = device->CreateTexture2D(&desc, &subresourceData, &texture->Texture);
		if (FAILED(res))
			return NULL;

		D3D11_SHADER_RESOURCE_VIEW_DESC shaderDesc;
		shaderDesc.Format = desc.Format;
		shaderDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
		shaderDesc.Texture2D.MostDetailedMip = 0;
		shaderDesc.Texture2D.MipLevels = 1;

		res = device->CreateShaderResourceView(texture->Texture, &shaderDesc, &texture->ShaderResourceView);
		if (FAILED(res))
			return NULL;
		
		return texture;
	}

	static Texture2D* LoadFromFile(ID3D11Device* device, const char* fileName)
	{
		Texture2D* texture = new Texture2D();

		wchar_t buffer[255];
		size_t converted = 0;
		mbstowcs_s(&converted, buffer, fileName, strlen(fileName));

		ID3D11Resource* resource = NULL;
		ID3D11DeviceContext* context = NULL;
		device->GetImmediateContext(&context);

		HRESULT res = CreateWICTextureFromFile(device, context, &buffer[0], &resource, &texture->ShaderResourceView, (size_t)0);
		if (FAILED(res))
			return NULL;

		resource->QueryInterface(IID_ID3D11Texture2D, (void **)&texture->Texture);
		
		return texture;
	}
};

class VertexBuffer
{
public:
	ID3D11Buffer* Buffer;

	VertexBuffer()
	{

	}

	~VertexBuffer()
	{
		DX11_RELEASE(Buffer);
	}

	static VertexBuffer* Create(ID3D11Device* device, int numVertices, RendererVertex* vertices)
	{
		HRESULT res;

		VertexBuffer* vb = new VertexBuffer();

		D3D11_BUFFER_DESC desc;
		ZeroMemory(&desc, sizeof(desc));

		desc.Usage = D3D11_USAGE_DYNAMIC;   
		desc.ByteWidth = sizeof(RendererVertex) * numVertices; 
		desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;  
		desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; 

		res = device->CreateBuffer(&desc, NULL, &vb->Buffer);
		if (FAILED(res))
			return NULL;

		if (vertices != NULL)
		{
			ID3D11DeviceContext* context = NULL;
			device->GetImmediateContext(&context);

			D3D11_MAPPED_SUBRESOURCE ms;

			res = context->Map(vb->Buffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
			if (FAILED(res))
				return NULL;

			memcpy(ms.pData, vertices, sizeof(RendererVertex) * numVertices);

			context->Unmap(vb->Buffer, NULL);
		}

		return vb;
	}
};

class IndexBuffer
{
public:
	ID3D11Buffer* Buffer;

	IndexBuffer()
	{

	}

	~IndexBuffer()
	{
		DX11_RELEASE(Buffer);
	}

	static IndexBuffer* Create(ID3D11Device* device, int numIndices, int* indices)
	{
		HRESULT res;

		IndexBuffer* ib = new IndexBuffer();

		D3D11_BUFFER_DESC desc;
		ZeroMemory(&desc, sizeof(desc));

		desc.Usage = D3D11_USAGE_DYNAMIC;
		desc.ByteWidth = sizeof(int) * numIndices;
		desc.BindFlags = D3D11_BIND_INDEX_BUFFER;
		desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
		
		res = device->CreateBuffer(&desc, NULL, &ib->Buffer);
		if (FAILED(res))
			return NULL;

		if (indices != NULL)
		{
			ID3D11DeviceContext* context = NULL;
			device->GetImmediateContext(&context);

			D3D11_MAPPED_SUBRESOURCE ms;

			res = context->Map(ib->Buffer, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
			if (FAILED(res))
				return NULL;

			memcpy(ms.pData, indices, sizeof(int) * numIndices);

			context->Unmap(ib->Buffer, NULL);
		}

		return ib;
	}
};

struct RendererStringToDraw
{
	float X;
	float Y;
	int Flags;
	wstring String;
	Vector3 Color;
};

struct RendererPolygon 
{
	byte Shape;
	int AnimatedSet;
	int TextureId;
	int Distance;
	int Indices[4];
};

struct RendererBone 
{
	Vector3 Translation;
	Matrix GlobalTransform;
	Matrix Transform;
	Vector3 GlobalTranslation;
	vector<RendererBone*> Children;
	RendererBone* Parent;
	int Index;
	Vector3 ExtraRotation;
	byte ExtraRotationFlags;

	RendererBone(int index)
	{
		Index = index;
		ExtraRotationFlags = 0;
		Translation = Vector3(0, 0, 0);
		ExtraRotation = Vector3(0, 0, 0);
	}
};

struct RendererLight {
	Vector3 Position;
	float Type;
	Vector3 Color;
	float Dynamic;
	Vector4 Direction;
	float Intensity;
	float In;
	float Out;
	float Range;

	RendererLight()
	{
		Dynamic = false;
	}
};

struct ShaderLight {
	Vector4 Position;
	Vector4 Color;
	Vector4 Direction;
	float Intensity;
	float In;
	float Out;
	float Range;
};

struct CCameraMatrixBuffer
{
	Matrix View;
	Matrix Projection;
};

struct CItemBuffer
{
	Matrix World;
	Matrix BonesMatrices[32];
	Vector4 Position;
	Vector4 AmbientLight;
};

struct CStaticBuffer
{
	Matrix World;
	Vector4 Position;
	Vector4 Color;
};

struct CShadowLightBuffer {
	ShaderLight Light;
	Matrix LightViewProjection;
	int CastShadows;
	float Padding[15];
};

struct CLightBuffer {
	ShaderLight Lights[NUM_LIGHTS_PER_BUFFER];
	int NumLights;
	Vector3 CameraPosition;
};

struct CMiscBuffer {
	int AlphaTest;
	int Caustics;
	float Padding[14];
};

struct RendererAnimatedTexture 
{
	int Id;
	Vector2 UV[4];
};

struct RendererAnimatedTextureSet 
{
	int NumTextures;
	RendererAnimatedTexture** Textures;

	~RendererAnimatedTextureSet()
	{
		for (int i = 0; i < NumTextures; i++)
			delete Textures[i];
		free(Textures);
	}
};

struct RendererBucket
{
	vector<RendererVertex>		Vertices;
	vector<int>				Indices;
	vector<RendererPolygon>		Polygons;
	vector<RendererPolygon>		AnimatedPolygons;
	int						StartVertex;
	int						StartIndex;
	int						NumTriangles;
	int						NumVertices;
	int						NumIndices;
};

struct RendererStatic {
	int Id;
	short RoomIndex;
	MESH_INFO* Mesh;
	Matrix World;
};

struct RendererRoom 
{
	ROOM_INFO* Room;
	Vector4 AmbientLight;
	RendererBucket Buckets[NUM_BUCKETS];
	RendererBucket AnimatedBuckets[NUM_BUCKETS];
	vector<RendererLight> Lights;
	vector<RendererStatic> Statics;
	bool Visited;
	float Distance;
	int RoomNumber;
	PreallocatedVector<RendererLight> LightsToDraw;
};

struct RendererRoomNode {
	short From;
	short To;
	Vector4 ClipPort;
};

struct RendererItem {
	int Id;
	ITEM_INFO* Item;
	Matrix World;
	Matrix AnimationTransforms[32];
	int NumMeshes;
	PreallocatedVector<RendererLight> Lights;
};

struct RendererMesh
{
	RendererBucket				Buckets[NUM_BUCKETS];
	RendererBucket				AnimatedBuckets[NUM_BUCKETS];
	vector<Vector3>				Positions;
};

struct RendererEffect {
	int Id;
	FX_INFO* Effect;
	Matrix World;
	RendererMesh* Mesh;
	PreallocatedVector<RendererLight> Lights;
};

struct RendererObject
{
	int Id;
	vector<RendererMesh*>		ObjectMeshes;
	RendererBone*				Skeleton;
	vector<Matrix>				AnimationTransforms;
	vector<Matrix>				BindPoseTransforms;
	vector<RendererBone*>		LinearizedBones;
	bool						DoNotDraw;
	bool						HasDataInBucket[NUM_BUCKETS];
	bool						HasDataInAnimatedBucket[NUM_BUCKETS];

	~RendererObject()
	{
		/*for (int i = 0; i < ObjectMeshes.size(); i++)
			delete ObjectMeshes[i];*/
		for (int i = 0; i < LinearizedBones.size(); i++)
			delete LinearizedBones[i];
	}
};

struct RendererSprite {
	int Width;
	int Height;
	Vector2 UV[4];
};

struct RendererSpriteSequence {
	int Id;
	RendererSprite** SpritesList;
	int NumSprites;

	RendererSpriteSequence(int id, int num)
	{
		Id = id;
		NumSprites = num;
		SpritesList = (RendererSprite**)malloc(sizeof(RendererSprite*) * num);
	}

	~RendererSpriteSequence()
	{
		/*for (int i = 0; i < NumSprites; i++)
			delete SpritesList[i];
		free(SpritesList);*/
	}
};

struct RendererSpriteToDraw {
	RENDERER_SPRITE_TYPE Type;
	RendererSprite* Sprite;
	float Distance;
	float Scale;
	float X, Y, Z;
	float X1, Y1, Z1;
	float X2, Y2, Z2;
	float X3, Y3, Z3;
	float X4, Y4, Z4;
	byte R;
	byte G;
	byte B;
	float Rotation;
	float Width;
	float Height;
	BLEND_MODES BlendMode;
};

struct RendererLine3D {
	float X1;
	float Y1;
	float Z1;
	float X2;
	float Y2;
	float Z2;
	byte R;
	byte G;
	byte B;
};

struct RendererWeatherParticle {
	float X, Y, Z;
	float AngleH;
	float AngleV;
	float Size;
	short Room;
	bool Reset;
	bool Draw;
};

struct RendererUnderwaterDustParticle {
	float X, Y, Z;
	short Life;
	short Room;
	bool Reset;
};

struct RendererLine2D {
	Vector2 Vertices[2];
	Vector4 Color;
};

class Renderer11
{
private:
	// Core DX11 objects
	ID3D11Device*									m_device = NULL;
	ID3D11DeviceContext*							m_context = NULL;
	IDXGISwapChain*									m_swapChain = NULL;
	IDXGIDevice*									m_dxgiDevice = NULL;
	CommonStates*									m_states = NULL;
	ID3D11InputLayout*								m_inputLayout = NULL;
	D3D11_VIEWPORT									m_viewport;
	D3D11_VIEWPORT									m_shadowMapViewport;
	Viewport*										m_viewportToolkit;
	vector<RendererVideoAdapter>					m_adapters;

	// Main back buffer
	ID3D11RenderTargetView*							m_backBufferRTV;
	ID3D11Texture2D*								m_backBufferTexture;

	ID3D11DepthStencilState*						m_depthStencilState;
	ID3D11DepthStencilView*							m_depthStencilView;
	ID3D11Texture2D*								m_depthStencilTexture;

	RenderTarget2D*									m_dumpScreenRenderTarget;
	RenderTarget2D*									m_renderTarget;
	RenderTarget2D*									m_currentRenderTarget;
	RenderTarget2D*									m_shadowMap;

	// Shaders
	ID3D11VertexShader*								m_vsRooms;
	ID3D11PixelShader*								m_psRooms;
	ID3D11VertexShader*								m_vsItems;
	ID3D11PixelShader*								m_psItems;
	ID3D11VertexShader*								m_vsHairs;
	ID3D11PixelShader*								m_psHairs;
	ID3D11VertexShader*								m_vsStatics;
	ID3D11PixelShader*								m_psStatics;
	ID3D11VertexShader*								m_vsSky;
	ID3D11PixelShader*								m_psSky;
	ID3D11VertexShader*								m_vsSprites;
	ID3D11PixelShader*								m_psSprites;
	ID3D11VertexShader*								m_vsSolid;
	ID3D11PixelShader*								m_psSolid;
	ID3D11VertexShader*								m_vsInventory;
	ID3D11PixelShader*								m_psInventory;
	ID3D11VertexShader*								m_vsFullScreenQuad;
	ID3D11PixelShader*								m_psFullScreenQuad;
	ID3D11VertexShader*								m_vsShadowMap;
	ID3D11PixelShader*								m_psShadowMap;

	// Constant buffers
	CCameraMatrixBuffer								m_stCameraMatrices;
	ID3D11Buffer*									m_cbCameraMatrices;
	CItemBuffer										m_stItem;
	ID3D11Buffer*									m_cbItem;
	CStaticBuffer									m_stStatic;
	ID3D11Buffer*									m_cbStatic;
	CLightBuffer									m_stLights;
	ID3D11Buffer*									m_cbLights;
	CMiscBuffer										m_stMisc;
	ID3D11Buffer*									m_cbMisc;
	CShadowLightBuffer   							m_stShadowMap;
	ID3D11Buffer*									m_cbShadowMap;

	// Text and sprites
	SpriteFont*										m_gameFont;
	SpriteBatch*									m_spriteBatch;
	vector<RendererStringToDraw>					m_strings;
	int												m_blinkColorValue;
	int												m_blinkColorDirection;
	PrimitiveBatch<RendererVertex>*					m_primitiveBatch;

	// System resources
	Texture2D*										m_caustics[NUM_CAUSTICS_TEXTURES];
	Texture2D*										m_binocularsTexture;
	Texture2D*										m_whiteTexture;

	// Level data
	Texture2D*										m_titleScreen;
	Texture2D*										m_loadScreen;
	Texture2D*										m_textureAtlas;
	Texture2D*										m_skyTexture;
	Texture2D*										m_logo;
	VertexBuffer*									m_roomsVertexBuffer;
	IndexBuffer*									m_roomsIndexBuffer;
	VertexBuffer*									m_moveablesVertexBuffer;
	IndexBuffer*									m_moveablesIndexBuffer;
	VertexBuffer*									m_staticsVertexBuffer;
	IndexBuffer*									m_staticsIndexBuffer;
	RendererRoom**									m_rooms;
	Matrix											m_hairsMatrices[12];
	short											m_normalLaraSkinJointRemap[15][32];
	short											m_youngLaraSkinJointRemap[15][32];
	short											m_laraSkinJointRemap[15][32];
	short											m_numHairVertices;
	short											m_numHairIndices;
	vector<RendererVertex>							m_hairVertices;
	vector<short>									m_hairIndices;
	PreallocatedVector<RendererRoom>				m_roomsToDraw;
	PreallocatedVector<RendererItem>				m_itemsToDraw;
	PreallocatedVector<RendererEffect>			    m_effectsToDraw;
	PreallocatedVector<RendererStatic>				m_staticsToDraw;
	PreallocatedVector<RendererLight>				m_lightsToDraw;
	PreallocatedVector<RendererLight>				m_dynamicLights;
	PreallocatedVector<RendererSpriteToDraw>		m_spritesToDraw;
	PreallocatedVector<RendererLine3D>				m_lines3DToDraw;
	PreallocatedVector<RendererLine2D>				m_lines2DToDraw;
	PreallocatedVector<RendererLight>				m_tempItemLights;
	RendererSpriteToDraw*							m_spritesBuffer;
	int												m_nextSprite;
	RendererLine3D*									m_lines3DBuffer;
	int												m_nextLine3D;
	RendererLine2D*									m_lines2DBuffer;
	int												m_nextLine2D;
	RendererLight*									m_shadowLight;
	RendererObject**								m_moveableObjects;
	RendererObject**								m_staticObjects;
	RendererSprite**								m_sprites;
	int												m_numMoveables;
	int												m_numStatics;
	int												m_numSprites;
	int												m_numSpritesSequences;
	RendererSpriteSequence**						m_spriteSequences;
	unordered_map<unsigned int, RendererMesh*>		m_meshPointersToMesh;
	Matrix											m_LaraWorldMatrix;
	RendererAnimatedTextureSet**					m_animatedTextureSets;
	int												m_numAnimatedTextureSets;
	int												m_currentCausticsFrame;
	RendererUnderwaterDustParticle					m_underwaterDustParticles[NUM_UNDERWATER_DUST_PARTICLES];
	bool											m_firstUnderwaterDustParticles = true;
	vector<RendererMesh*>							m_meshes;

	// Debug variables
	int												m_numDrawCalls = 0;

	// Preallocated pools of objects for avoiding new/delete
	// Items and effects are safe (can't be more than 1024 items in TR), 
	// lights should be oversized (eventually ignore lights more than MAX_LIGHTS)
	RendererItem									m_items[NUM_ITEMS];
	RendererEffect									m_effects[NUM_ITEMS];
	RendererLight									m_lights[MAX_LIGHTS];
	int												m_nextLight;
	int												m_currentY;

	// Times for debug
	int												m_timeUpdate;
	int												m_timeDraw;
	int												m_timeFrame;

	// Others
	bool											m_firstWeather;
	RendererWeatherParticle							m_rain[NUM_RAIN_DROPS];
	RendererWeatherParticle							m_snow[NUM_SNOW_PARTICLES];
	RENDERER_FADE_STATUS							m_fadeStatus;
	float											m_fadeFactor;
	int												m_progress;
	bool											m_enableCinematicBars = false;
	int												m_pickupRotation;

	// Private functions
	bool											drawScene(bool dump);
	bool											drawAllStrings();
	ID3D11VertexShader*								compileVertexShader(const char* fileName, const char* function, const char* model, ID3D10Blob** bytecode);
	ID3D11GeometryShader*							compileGeometryShader(const char* fileName);
	ID3D11PixelShader*								compilePixelShader(const char* fileName, const char* function, const char* model, ID3D10Blob** bytecode);
	ID3D11ComputeShader*							compileComputeShader(const char* fileName);
	ID3D11Buffer*									createConstantBuffer(int size);
	int												getAnimatedTextureInfo(short textureId);
	void											initialiseHairRemaps();
	RendererMesh*									getRendererMeshFromTrMesh(RendererObject* obj, short* meshPtr, short* refMeshPtr, short boneIndex, int isJoints, int isHairs);
	void											fromTrAngle(Matrix* matrix, short* frameptr, int index);
	void											buildHierarchy(RendererObject* obj);
	void											buildHierarchyRecursive(RendererObject* obj, RendererBone* node, RendererBone* parentNode);
	void											updateAnimation(RendererItem* item, RendererObject* obj, short** frmptr, short frac, short rate, int mask);
	bool											printDebugMessage(int x, int y, int alpha, byte r, byte g, byte b, LPCSTR Message);
	bool											checkPortal(short roomIndex, short* portal, Vector4* viewPort, Vector4* clipPort);
	void											getVisibleRooms(int from, int to, Vector4* viewPort, bool water, int count);
	void											collectRooms();
	inline void										collectItems(short roomNumber);
	inline void										collectStatics(short roomNumber);
	inline void										collectLightsForRoom(short roomNumber);
	inline void										collectLightsForItem(short roomNumber, RendererItem* item);
	inline void										collectLightsForEffect(short roomNumber, RendererEffect* effect);
	inline void										collectEffects(short roomNumber);
	void											prepareLights();
	void											clearSceneItems();
	bool											updateConstantBuffer(ID3D11Buffer* buffer, void* data, int size);
	void											updateLaraAnimations();
	void											updateItemsAnimations();
	void											updateEffects();
	int												getFrame(short animation, short frame, short** framePtr, int* rate);
	bool											drawAmbientCubeMap(short roomNumber);
	bool											sphereBoxIntersection(Vector3 boxMin, Vector3 boxMax, Vector3 sphereCentre, float sphereRadius);
	bool											drawHorizonAndSky();
	bool											drawRooms(bool transparent, bool animated);
	bool											drawStatics(bool transparent);
	bool											drawItems(bool transparent, bool animated);
	bool											drawAnimatingItem(RendererItem* item, bool transparent, bool animated);
	bool											drawWaterfalls();
	bool											drawShadowMap();
	bool											drawObjectOn2DPosition(short x, short y, short objectNum, short rotX, short rotY, short rotZ);
	bool											drawLara(bool transparent, bool shadowMap);
	void											printDebugMessage(LPCSTR message, ...);
	void											drawFires();
	void											drawSparks();
	void											drawSmokes();
	void											drawBlood();
	void											drawDrips();
	void											drawBubbles();
	bool											drawEffects(bool transparent);
	bool											drawEffect(RendererEffect* effect, bool transparent);
	void											drawSplahes();
	bool											drawSprites();
	bool											drawLines3D();
	bool											drawLines2D();
	bool											drawOverlays();
	bool											drawRopes();
	bool											drawBats();
	bool											drawRats();
	bool											drawSpiders();
	bool											drawGunFlashes();
	bool											drawGunShells();
	bool											drawBar(int x, int y, int w, int h, int percent, int color1, int color2);
	void											insertLine2D(int x1, int y1, int x2, int y2, byte r, byte g, byte b, byte a);
	bool											drawDebris(bool transparent);
	int												drawInventoryScene();
	int												drawFinalPass();
	void											updateAnimatedTextures();
	void											createBillboardMatrix(Matrix* out, Vector3* particlePos, Vector3* cameraPos, float rotation);
	void											drawShockwaves();
	void											drawRipples();
	void											drawUnderwaterDust();	
	bool											doRain();
	bool											doSnow();
	bool											drawFullScreenQuad(ID3D11ShaderResourceView* texture, Vector3 color, bool cinematicBars);
	bool											drawFullScreenImage(ID3D11ShaderResourceView* texture, float fade);
	bool											isRoomUnderwater(short roomNumber);
	bool											isInRoom(int x, int y, int z, short roomNumber);
	void											addSpriteBillboard(RendererSprite* sprite, float x, float y, float z, byte r, byte g, byte b, float rotation, float scale, float width, float height, BLEND_MODES blendMode);
	void											addSprite3D(RendererSprite* sprite, float x1, float y1, float z1, float x2, float y2, float z2, float x3, float y3, float z3, float x4, float y4, float z4, byte r, byte g, byte b, float rotation, float scale, float width, float height, BLEND_MODES blendMode);
	void											addLine3D(int x1, int y1, int z1, int x2, int y2, int z2, byte r, byte g, byte b);
	bool											drawColoredQuad(int x, int y, int w, int h, Vector4 color);
	bool											initialiseScreen(int w, int h, int refreshRate, bool windowed, HWND handle, bool reset);

public:
	Matrix											View;
	Matrix											Projection;
	Matrix											ViewProjection;
	float											FieldOfView;
	int												ScreenWidth;
	int												ScreenHeight;
	bool											Windowed;
	int												NumTexturePages;

	Renderer11();
	~Renderer11();

	bool											Create();
	bool											EnumerateVideoModes();
	bool											Initialise(int w, int h, int refreshRate, bool windowed, HWND handle);
	int												Draw();
	bool											PrepareDataForTheRenderer();
	void											UpdateCameraMatrices(float posX, float posY, float posZ, float targetX, float targetY, float targetZ, float roll, float fov);
	int												DumpGameScene();
	int												DrawInventory();
	int												DrawPickup(short objectNum);
	int												SyncRenderer();
	bool											PrintString(int x, int y, char* string, D3DCOLOR color, int flags);
	void											DrawDashBar();
	void											DrawHealthBar(int percentual);
	void											DrawAirBar(int percentual);
	void											ClearDynamicLights();
	void											AddDynamicLight(int x, int y, int z, short falloff, byte r, byte g, byte b);
	void											FreeRendererData();
	void											EnableCinematicBars(bool value);
	void											FadeIn();
	void											FadeOut();
	void											DrawLoadingScreen(char* fileName);
	void											UpdateProgress(float value);
	bool											IsFading();
	void											GetLaraBonePosition(Vector3* pos, int bone);
	bool											ToggleFullScreen();
	bool											IsFullsScreen();
	vector<RendererVideoAdapter>*					GetAdapters();
	bool											DoTitleImage();
	bool											ChangeScreenResolution(int width, int height, int frequency, bool windowed);
};