#include "UnityPrefix.h"
#include "Runtime/GfxDevice/GfxDevice.h"
#include "Runtime/Shaders/GraphicsCaps.h"
#include "D3D11Context.h"
#include "D3D11VBO.h"
#include "External/shaderlab/Library/program.h"
#include "Runtime/GfxDevice/ChannelAssigns.h"
#include "Runtime/GfxDevice/GpuProgramParamsApply.h"
#include "External/shaderlab/Library/TextureBinding.h"
#include "External/shaderlab/Library/properties.h"
#include "D3D11Utils.h"
#include "GpuProgramsD3D11.h"
#include "ShaderPatchingD3D11.h"
#include "TimerQueryD3D11.h"
#include "PlatformDependent/Win/SmartComPointer.h"
#include "PlatformDependent/Win/WinUnicode.h"
#include "Runtime/Camera/CameraUtil.h"
#include "Runtime/Graphics/GraphicsHelper.h"
#include "Runtime/Graphics/Image.h"
#include "Runtime/Utilities/ArrayUtility.h"
#include "Runtime/Misc/Plugins.h"
#if UNITY_EDITOR
#include "D3D11Window.h"
#endif
#include "Runtime/GfxDevice/d3d11/StreamOutSkinnedMesh.h"

class GfxDeviceD3D11;

namespace ShaderLab {
	TexEnv* GetTexEnvForBinding( const TextureBinding& binding, const PropertySheet* props ); // pass.cpp
}


#include "GfxDeviceD3D11.h"

extern const InputSignatureD3D11* g_CurrentVSInputD3D11;
extern ID3D11InputLayout* g_ActiveInputLayoutD3D11;
extern D3D11_PRIMITIVE_TOPOLOGY g_ActiveTopologyD3D11;


static ShaderLab::FastPropertyName kSLPropFogCB = ShaderLab::Property ("UnityFogPatchCB");



static const D3D11_COMPARISON_FUNC kCmpFuncD3D11[] = {
	D3D11_COMPARISON_ALWAYS, D3D11_COMPARISON_NEVER, D3D11_COMPARISON_LESS, D3D11_COMPARISON_EQUAL, D3D11_COMPARISON_LESS_EQUAL, D3D11_COMPARISON_GREATER, D3D11_COMPARISON_NOT_EQUAL, D3D11_COMPARISON_GREATER_EQUAL, D3D11_COMPARISON_ALWAYS
};

static const D3D11_STENCIL_OP kStencilOpD3D11[] = {
	D3D11_STENCIL_OP_KEEP, D3D11_STENCIL_OP_ZERO, D3D11_STENCIL_OP_REPLACE, D3D11_STENCIL_OP_INCR_SAT,
	D3D11_STENCIL_OP_DECR_SAT, D3D11_STENCIL_OP_INVERT, D3D11_STENCIL_OP_INCR, D3D11_STENCIL_OP_DECR
};

// Graphics device requires access to reset render textures
bool RebindActiveRenderTargets (TexturesD3D11* textures);

DXGI_FORMAT GetRenderTextureFormat (RenderTextureFormat format, bool sRGB);
DXGI_FORMAT GetShaderResourceViewFormat (RenderTextureFormat format, bool sRGB);
extern DXGI_FORMAT kD3D11RenderResourceFormats[kRTFormatCount];
extern DXGI_FORMAT kD3D11RenderTextureFormatsNorm[kRTFormatCount];


bool SetTopologyD3D11 (GfxPrimitiveType topology, GfxDevice& device, ID3D11DeviceContext* ctx);
void SetInputLayoutD3D11 (ID3D11DeviceContext* ctx, ID3D11InputLayout* layout);


// --------------------------------------------------------------------------


ResolveTexturePool::ResolveTexturePool()
:	m_UseCounter(0)
{
	memset (m_Entries, 0, sizeof(m_Entries));
}

void ResolveTexturePool::Clear()
{
	for (int i = 0; i < ARRAY_SIZE(m_Entries); ++i)
	{
		SAFE_RELEASE(m_Entries[i].texture);
		SAFE_RELEASE(m_Entries[i].srv);
	}
}

ResolveTexturePool::Entry* ResolveTexturePool::GetResolveTexture (int width, int height, RenderTextureFormat fmt, bool sRGB)
{
	++m_UseCounter;

	// check if we have a suitable temporary resolve texture already?
	int newIndex = -1;
	int lruIndex = 0;
	int lruScore = 0;
	for (int i = 0; i < ARRAY_SIZE(m_Entries); ++i)
	{
		Entry& e = m_Entries[i];
		if (e.width == width && e.height == height && e.format == fmt && e.sRGB == sRGB)
		{
			Assert (e.texture);
			Assert (e.srv);
			e.lastUse = m_UseCounter;
			return &e;
		}

		if (e.width == 0)
		{
			// unused slot
			Assert (e.height == 0 && !e.texture && !e.srv);
			if (newIndex == -1)
				newIndex = i;
		}
		else
		{
			// used slot
			if (m_UseCounter - e.lastUse > lruScore)
			{
				lruIndex = i;
				lruScore = m_UseCounter - e.lastUse;
			}
		}
	}

	// if all slots are used; release least recently used
	if (newIndex == -1)
	{
		Entry& e = m_Entries[lruIndex];
		Assert (e.texture);
		e.width = e.height = 0;
		SAFE_RELEASE(e.texture);
		SAFE_RELEASE(e.srv);
		newIndex = lruIndex;
	}

	Entry& ee = m_Entries[newIndex];

	// create texture & SRV in this slot

	ID3D11Device* dev = GetD3D11Device();
	D3D11_TEXTURE2D_DESC tDesc;
	tDesc.Width = width;
	tDesc.Height = height;
	tDesc.MipLevels = 1;
	tDesc.ArraySize = 1;
	tDesc.Format = (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0 ? kD3D11RenderResourceFormats[fmt] : kD3D11RenderTextureFormatsNorm[fmt]);

	tDesc.SampleDesc.Count = 1;
	tDesc.SampleDesc.Quality = 0;
	tDesc.Usage = D3D11_USAGE_DEFAULT;
	tDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
	// 9.x feature levels require the resolved texture to also have a render target flag, otherwise
	// CopySubresourceRegion will silently corrupt runtime/driver state.
	if (gGraphicsCaps.d3d11.featureLevel < kDX11Level10_0)
		tDesc.BindFlags |= D3D11_BIND_RENDER_TARGET;

	tDesc.CPUAccessFlags = 0;
	tDesc.MiscFlags = 0;

	HRESULT hr = dev->CreateTexture2D (&tDesc, NULL, &ee.texture);
	if (FAILED(hr))
		return NULL;
	SetDebugNameD3D11 (ee.texture, Format("ResolveTexture2D-%dx%d", width, height));

	D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
	srvDesc.Format = GetShaderResourceViewFormat (fmt, (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0) ? sRGB : false);
	srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
	srvDesc.Texture2D.MostDetailedMip = 0;
	srvDesc.Texture2D.MipLevels = 1;
	hr = dev->CreateShaderResourceView (ee.texture, &srvDesc, &ee.srv);
	if (FAILED(hr))
		return NULL;
	SetDebugNameD3D11 (ee.srv, Format("ResolveTexture2D-SRV-%dx%d", width, height));

	ee.width = width;
	ee.height = height;
	ee.format = fmt;
	ee.sRGB = sRGB;
	ee.lastUse = m_UseCounter;

	return &ee;
}


// --------------------------------------------------------------------------


static FixedFunctionProgramD3D11* GetFixedFunctionProgram11 (FFProgramCacheD3D11& cache, const FixedFunctionStateD3D11& state)
{
	// Do we have one for this state already?
	FFProgramCacheD3D11::iterator cachedProgIt = cache.find (state);
	if (cachedProgIt != cache.end())
		return cachedProgIt->second;

	// Don't have one yet, create it
	FixedFunctionProgramD3D11* ffProg = new FixedFunctionProgramD3D11 (state);
	cache.insert (std::make_pair(state, ffProg));
	return ffProg;
}



// --------------------------------------------------------------------------



void GfxDeviceD3D11::SetupDeferredDepthStencilState ()
{
	ID3D11DepthStencilState* dss = m_CurrDSState;
	if (!dss)
	{
		DepthStencilState state;
		memset (&state, 0, sizeof(state));
		if (m_CurrDepthState)
			state.d = *m_CurrDepthState;
		if (m_CurrStencilState)
			state.s = *m_CurrStencilState;

		CachedDepthStencilStates::iterator it = m_CachedDepthStencilStates.find(state);
		if (it == m_CachedDepthStencilStates.end())
		{
			D3D11_DEPTH_STENCIL_DESC desc;
			memset (&desc, 0, sizeof(desc));
			if (m_CurrDepthState)
			{
				desc.DepthEnable = TRUE;
				desc.DepthWriteMask = (m_CurrDepthState->sourceState.depthWrite ? D3D11_DEPTH_WRITE_MASK_ALL : D3D11_DEPTH_WRITE_MASK_ZERO);
				desc.DepthFunc = kCmpFuncD3D11[m_CurrDepthState->sourceState.depthFunc];
			}
			if (m_CurrStencilState)
			{
				desc.StencilEnable = m_CurrStencilState->sourceState.stencilEnable;
				desc.StencilReadMask = m_CurrStencilState->sourceState.readMask;
				desc.StencilWriteMask = m_CurrStencilState->sourceState.writeMask;
				desc.FrontFace.StencilFunc = kCmpFuncD3D11[m_CurrStencilState->sourceState.stencilFuncFront];
				desc.FrontFace.StencilFailOp = kStencilOpD3D11[m_CurrStencilState->sourceState.stencilFailOpFront];
				desc.FrontFace.StencilDepthFailOp = kStencilOpD3D11[m_CurrStencilState->sourceState.stencilZFailOpFront];
				desc.FrontFace.StencilPassOp = kStencilOpD3D11[m_CurrStencilState->sourceState.stencilPassOpFront];
				desc.BackFace.StencilFunc = kCmpFuncD3D11[m_CurrStencilState->sourceState.stencilFuncBack];
				desc.BackFace.StencilFailOp = kStencilOpD3D11[m_CurrStencilState->sourceState.stencilFailOpBack];
				desc.BackFace.StencilDepthFailOp = kStencilOpD3D11[m_CurrStencilState->sourceState.stencilZFailOpBack];
				desc.BackFace.StencilPassOp = kStencilOpD3D11[m_CurrStencilState->sourceState.stencilPassOpBack];
			}

			ID3D11DepthStencilState* d3dstate = NULL;
			HRESULT hr = GetD3D11Device()->CreateDepthStencilState (&desc, &d3dstate);
			Assert(SUCCEEDED(hr));
			SetDebugNameD3D11 (d3dstate, Format("DepthStencilState-%d-%d", desc.DepthWriteMask, desc.DepthFunc));
			it = m_CachedDepthStencilStates.insert (std::make_pair(state, d3dstate)).first;
		}
		dss = it->second;
	}
	if (dss != m_CurrDSState || m_StencilRef != m_CurrStencilRef)
	{
		GetD3D11Context()->OMSetDepthStencilState (dss, m_StencilRef);
		m_CurrDSState = dss;
		m_CurrStencilRef = m_StencilRef;
	}
}

void GfxDeviceD3D11::SetupDeferredRasterState ()
{
	// raster state; needs to be deferred due to cull winding / scissor / wireframe
	// not known at creation time
	if (!m_CurrRasterState)
		return;

	ID3D11RasterizerState* rss = m_CurrRSState;
	if (!rss)
	{
		FinalRasterState11 rsKey;
		memcpy (&rsKey.raster, &m_CurrRasterState->sourceState, sizeof(rsKey.raster));
		rsKey.backface = (m_CurrRasterState->sourceState.cullMode != kCullOff) && ((m_AppBackfaceMode==m_UserBackfaceMode) == m_InvertProjMatrix);
		rsKey.wireframe = m_Wireframe;
		rsKey.scissor = m_Scissor;

		CachedFinalRasterStates::iterator it = m_CachedFinalRasterStates.find(rsKey);
		if (it == m_CachedFinalRasterStates.end())
		{
			D3D11_RASTERIZER_DESC desc;
			memset (&desc, 0, sizeof(desc));

			desc.FrontCounterClockwise = rsKey.backface ? TRUE : FALSE;
			//TODO: wtf??? DepthBias doesn't work at 9.1
			if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0)
				desc.DepthBias = rsKey.raster.sourceState.depthBias;
			desc.SlopeScaledDepthBias = rsKey.raster.sourceState.slopeScaledDepthBias;
			desc.ScissorEnable = m_Scissor;
			desc.MultisampleEnable = TRUE; // only applies to line drawing in MSAA; if set to FALSE lines will be aliased even when MSAA is used
			desc.DepthClipEnable = TRUE;
			desc.FillMode = rsKey.wireframe ? D3D11_FILL_WIREFRAME : D3D11_FILL_SOLID;
			switch (rsKey.raster.sourceState.cullMode)
			{
			case kCullOff: desc.CullMode = D3D11_CULL_NONE; break;
			case kCullFront: desc.CullMode = D3D11_CULL_FRONT; break;
			case kCullBack: desc.CullMode = D3D11_CULL_BACK; break;
			default: AssertIf("Unsupported cull mode!");
			}
			ID3D11RasterizerState* d3dstate = NULL;
			HRESULT hr = GetD3D11Device()->CreateRasterizerState (&desc, &d3dstate);
			Assert(SUCCEEDED(hr));
			SetDebugNameD3D11 (d3dstate, Format("RasterizerState-%d-%d", desc.FrontCounterClockwise, desc.FillMode));
			it = m_CachedFinalRasterStates.insert (std::make_pair(rsKey, d3dstate)).first;
		}
		rss = it->second;
	}
	if (rss != m_CurrRSState)
	{
		GetD3D11Context()->RSSetState (rss);
		m_CurrRSState = rss;
	}
}


void UpdateChannelBindingsD3D11 (const ChannelAssigns& channels)
{
	DX11_LOG_ENTER_FUNCTION("UpdateChannelBindingsD3D11");
	GfxDeviceD3D11& device = static_cast<GfxDeviceD3D11&>(GetRealGfxDevice());
	if (!device.IsShaderActive(kShaderVertex))
	{
		const int maxTexCoords = gGraphicsCaps.maxTexCoords; // fetch here once
		UInt64 textureSources = device.m_FFState.texUnitSources;
		for (int i = 0; i < maxTexCoords; ++i)
		{
			UInt32 source = (textureSources >> (i*4)) & 0xF;
			if (source > kTexSourceUV7)
				continue;
			ShaderChannel texCoordChannel = channels.GetSourceForTarget ((VertexComponent)(kVertexCompTexCoord0 + i));
			if (texCoordChannel == kShaderChannelTexCoord0)
				textureSources = textureSources & ~(0xFUL<<i*4) | (UInt64(kTexSourceUV0)<<i*4);
			else if (texCoordChannel == kShaderChannelTexCoord1)
				textureSources = textureSources & ~(0xFUL<<i*4) | (UInt64(kTexSourceUV1)<<i*4);
			else if (texCoordChannel != kShaderChannelNone) {
				AssertString( "Bad texcoord index" );
			}
		}
		device.m_FFState.texUnitSources = textureSources;
	}

	device.m_FFState.useUniformInsteadOfVertexColor = !(channels.GetTargetMap() & (1<<kVertexCompColor));
}


struct SetValuesFunctorD3D11
{
	SetValuesFunctorD3D11(GfxDevice& device, ConstantBuffersD3D11& cbs) : m_Device(device), m_CBs(cbs) { }
	GfxDevice& m_Device;
	ConstantBuffersD3D11& m_CBs;
	void SetVectorVal (ShaderType shaderType, ShaderParamType type, int index, const float* ptr, int cols, const GpuProgramParameters& params, int cbIndex)
	{
		const GpuProgramParameters::ConstantBuffer& cb = params.GetConstantBuffers()[cbIndex];
		int idx = m_CBs.FindAndBindCB (cb.m_Name.index, shaderType, cb.m_BindIndex, cb.m_Size);
		if (type != kShaderParamInt)
			m_CBs.SetCBConstant (idx, index, ptr, cols*4);
		else
		{
			int vali[4] = {ptr[0], ptr[1], ptr[2], ptr[3]};
			m_CBs.SetCBConstant (idx, index, vali, cols*4);
		}
	}
	void SetMatrixVal (ShaderType shaderType, int index, const Matrix4x4f* ptr, int rows, const GpuProgramParameters& params, int cbIndex)
	{
		DebugAssert(rows == 4);
		const GpuProgramParameters::ConstantBuffer& cb = params.GetConstantBuffers()[cbIndex];
		int idx = m_CBs.FindAndBindCB (cb.m_Name.index, shaderType, cb.m_BindIndex, cb.m_Size);
		m_CBs.SetCBConstant (idx, index, ptr, 64);
	}
	void SetTextureVal (ShaderType shaderType, int index, int samplerIndex, TextureDimension dim, TextureID texID)
	{
		m_Device.SetTexture (shaderType, index, samplerIndex, texID, dim, std::numeric_limits<float>::infinity());
	}
};


void GfxDeviceD3D11::BeforeDrawCall( bool immediateMode )
{
	DX11_LOG_ENTER_FUNCTION("GfxDeviceD3D11::BeforeDrawCall");
	ID3D11DeviceContext* ctx = GetD3D11Context();
	HRESULT hr;

	SetupDeferredSRGBWrite ();
	SetupDeferredDepthStencilState ();
	SetupDeferredRasterState ();

	m_TransformState.UpdateWorldViewMatrix (m_BuiltinParamValues);

	if (m_FogParams.mode != kFogDisabled)
	{
		float diff    = m_FogParams.mode == kFogLinear ? m_FogParams.end - m_FogParams.start : 0.0f;
		float invDiff = Abs(diff) > 0.0001f ? 1.0f/diff : 0.0f;
		Vector4f fogParams(m_FogParams.density * 1.2011224087f,
			m_FogParams.density * 1.4426950408f,
			m_FogParams.mode == kFogLinear ? -invDiff : 0.0f,
			m_FogParams.mode == kFogLinear ? m_FogParams.end * invDiff : 0.0f
		);
		m_BuiltinParamValues.SetVectorParam(kShaderVecFFFogParams, fogParams);
		m_BuiltinParamValues.SetVectorParam(kShaderVecFFFogColor, m_FogParams.color);
	}

	void* shader[kShaderTypeCount];
	for (int pt = 0; pt < kShaderTypeCount; ++pt)
	{
		shader[pt] = NULL;
		m_BuiltinParamIndices[pt] = &m_NullParamIndices;
	}

	if (m_ActiveGpuProgram[kShaderVertex] && m_ActiveGpuProgram[kShaderFragment])
	{
		// Programmable shaders
		const bool haveDomainShader = m_ActiveGpuProgram[kShaderDomain];
		bool resetToNoFog = false;
		for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt)
		{
			if (m_ActiveGpuProgram[pt])
			{
				DebugAssert (!m_ActiveGpuProgram[pt] || m_ActiveGpuProgram[pt]->GetImplType() == pt);
				m_BuiltinParamIndices[pt] = &m_ActiveGpuProgramParams[pt]->GetBuiltinParams();
				D3D11CommonShader* prog = static_cast<D3D11CommonShader*>(m_ActiveGpuProgram[pt]);
				shader[pt] = prog->GetShader(m_FogParams.mode, haveDomainShader, resetToNoFog);
				if (resetToNoFog)
					m_FogParams.mode = kFogDisabled;
			}
		}

		// Apply fog parameters if needed
		if (m_FogParams.mode > kFogDisabled)
		{
			const int cbIndex = m_CBs.FindAndBindCB (kSLPropFogCB.index, kShaderFragment, k11FogConstantBufferBind, k11FogSize*16);

			m_CBs.SetCBConstant (cbIndex, k11FogColor*16, m_FogParams.color.GetPtr(), 16);

			float params[4];
			params[0] = m_FogParams.density * 1.2011224087f ; // density / sqrt(ln(2))
			params[1] = m_FogParams.density * 1.4426950408f; // density / ln(2)
			if (m_FogParams.mode == kFogLinear)
			{
				float diff = m_FogParams.end - m_FogParams.start;
				float invDiff = Abs(diff) > 0.0001f ? 1.0f/diff : 0.0f;
				params[2] = -invDiff;
				params[3] = m_FogParams.end * invDiff;
			}
			else
			{
				params[2] = 0.0f;
				params[3] = 0.0f;
			}
			m_CBs.SetCBConstant (cbIndex, k11FogParams*16, params, 16);
		}
	}
	else
	{
		// Emulate fixed function
		m_FFState.fogMode = m_FogParams.mode;
		FixedFunctionProgramD3D11* program = GetFixedFunctionProgram11 (m_FFPrograms, m_FFState);

		shader[kShaderVertex] = program->GetVertexShader();
		shader[kShaderFragment] = program->GetPixelShader();

		program->ApplyFFGpuProgram (m_BuiltinParamValues, m_CBs);

		m_BuiltinParamIndices[kShaderVertex] = &program->GetVPMatrices();
	}

	// Set D3D shaders
	for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt)
	{
		if (m_ActiveShaders[pt] == shader[pt])
			continue;
		switch (pt) {
		case kShaderVertex: D3D11_CALL(ctx->VSSetShader ((ID3D11VertexShader*)shader[pt], NULL, 0)); break;
		case kShaderFragment: D3D11_CALL(ctx->PSSetShader ((ID3D11PixelShader*)shader[pt], NULL, 0)); break;
		case kShaderGeometry: D3D11_CALL(ctx->GSSetShader ((ID3D11GeometryShader*)shader[pt], NULL, 0)); break;
		case kShaderHull: D3D11_CALL(ctx->HSSetShader ((ID3D11HullShader*)shader[pt], NULL, 0)); break;
		case kShaderDomain: D3D11_CALL(ctx->DSSetShader ((ID3D11DomainShader*)shader[pt], NULL, 0)); break;
		}
		m_ActiveShaders[pt] = shader[pt];
	}

	// Set Unity built-in parameters
	bool anyGpuIndexValid;
	int gpuIndex[kShaderTypeCount];

#define SET_BUILTIN_MATRIX_BEGIN(idx) \
	anyGpuIndexValid = false; \
	for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt) { \
		int gi = m_BuiltinParamIndices[pt]->mat[idx].gpuIndex; \
		if (gi >= 0) anyGpuIndexValid = true; \
		gpuIndex[pt] = gi; \
	} \
	if (anyGpuIndexValid)

#define SET_BUILTIN_MATRIX_END(idx,mtx) \
	for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt) { \
		int gi = gpuIndex[pt]; \
		if (gi >= 0) m_CBs.SetBuiltinCBConstant (m_BuiltinParamIndices[pt]->mat[idx].cbID, gi, mtx.GetPtr(), sizeof(mtx)); \
	}


	// MVP matrix
	SET_BUILTIN_MATRIX_BEGIN(kShaderInstanceMatMVP)
	{
		Matrix4x4f mat;
		MultiplyMatrices4x4 (&m_BuiltinParamValues.GetMatrixParam(kShaderMatProj), &m_TransformState.worldViewMatrix, &mat);
		SET_BUILTIN_MATRIX_END(kShaderInstanceMatMVP,mat);
	}
	// MV matrix
	SET_BUILTIN_MATRIX_BEGIN(kShaderInstanceMatMV)
	{
		Matrix4x4f& mat = m_TransformState.worldViewMatrix;
		SET_BUILTIN_MATRIX_END(kShaderInstanceMatMV,mat);
	}
	// Transpose MV matrix
	SET_BUILTIN_MATRIX_BEGIN(kShaderInstanceMatTransMV)
	{
		Matrix4x4f mat;
		TransposeMatrix4x4 (&m_TransformState.worldViewMatrix, &mat);
		SET_BUILTIN_MATRIX_END(kShaderInstanceMatTransMV,mat);
	}
	// Inverse transpose of MV matrix
	SET_BUILTIN_MATRIX_BEGIN(kShaderInstanceMatInvTransMV)
	{
		Matrix4x4f mat;
		Matrix4x4f::Invert_Full (m_TransformState.worldViewMatrix, mat);
		if (true) //@TODO m_VertexData.normalization == kNormalizationScale)
		{
			// Inverse transpose of modelview should be scaled by uniform
			// normal scale (this will match state.matrix.invtrans.modelview
			// and gl_NormalMatrix in OpenGL)
			float scale = Magnitude (m_TransformState.worldMatrix.GetAxisX());
			mat.Get (0, 0) *= scale;
			mat.Get (1, 0) *= scale;
			mat.Get (2, 0) *= scale;
			mat.Get (0, 1) *= scale;
			mat.Get (1, 1) *= scale;
			mat.Get (2, 1) *= scale;
			mat.Get (0, 2) *= scale;
			mat.Get (1, 2) *= scale;
			mat.Get (2, 2) *= scale;
		}
		Matrix4x4f transposed;
		TransposeMatrix4x4 (&mat, &transposed);
		SET_BUILTIN_MATRIX_END(kShaderInstanceMatInvTransMV,transposed);
	}
	// M matrix
	SET_BUILTIN_MATRIX_BEGIN(kShaderInstanceMatM)
	{
		Matrix4x4f& mat = m_TransformState.worldMatrix;
		SET_BUILTIN_MATRIX_END(kShaderInstanceMatM,mat);
	}
	// Inverse M matrix
	SET_BUILTIN_MATRIX_BEGIN(kShaderInstanceMatInvM)
	{
		Matrix4x4f mat = m_TransformState.worldMatrix;
		if (true) //@TODO m_VertexData.normalization == kNormalizationScale)
		{
			// Kill scale in the world matrix before inverse
			float invScale = m_BuiltinParamValues.GetInstanceVectorParam(kShaderInstanceVecScale).w;
			mat.Get (0, 0) *= invScale;
			mat.Get (1, 0) *= invScale;
			mat.Get (2, 0) *= invScale;
			mat.Get (0, 1) *= invScale;
			mat.Get (1, 1) *= invScale;
			mat.Get (2, 1) *= invScale;
			mat.Get (0, 2) *= invScale;
			mat.Get (1, 2) *= invScale;
			mat.Get (2, 2) *= invScale;
		}
		Matrix4x4f inverseMat;
		Matrix4x4f::Invert_General3D (mat, inverseMat);
		SET_BUILTIN_MATRIX_END(kShaderInstanceMatInvM,inverseMat);
	}

	// Set instance vector parameters
	for (int i = 0; i < kShaderInstanceVecCount; ++i)
	{
		for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt)
		{
			int gi = m_BuiltinParamIndices[pt]->vec[i].gpuIndex;
			if (gi >= 0)
			{
				m_CBs.SetBuiltinCBConstant (m_BuiltinParamIndices[pt]->vec[i].cbID, gi, m_BuiltinParamValues.GetInstanceVectorParam((ShaderBuiltinInstanceVectorParam)i).GetPtr(), m_BuiltinParamIndices[pt]->vec[i].dim*4);
			}
		}
	}

	// Texture matrices for vertex shader
	for( int i = 0; i < 8; ++i )
	{
		const BuiltinShaderParamIndices::MatrixParamData* matParam = &m_BuiltinParamIndices[kShaderVertex]->mat[kShaderInstanceMatTexture0 + i];
		if (matParam->gpuIndex >= 0)
		{
			const Matrix4x4f& mat = m_TextureUnits[i].matrix;
			m_CBs.SetBuiltinCBConstant (matParam->cbID, matParam->gpuIndex, mat.GetPtr(), sizeof(mat));
		}
	}

	// Material properties
	SetValuesFunctorD3D11 setValuesFunc(*this, m_CBs);
	ApplyMaterialPropertyBlockValues(m_MaterialProperties, m_ActiveGpuProgram, m_ActiveGpuProgramParams, setValuesFunc);

	///@TODO the rest

	m_CBs.UpdateBuffers ();
}

static const D3D11_BLEND kBlendModeD3D11[] = {
	D3D11_BLEND_ZERO, D3D11_BLEND_ONE, D3D11_BLEND_DEST_COLOR, D3D11_BLEND_SRC_COLOR, D3D11_BLEND_INV_DEST_COLOR, D3D11_BLEND_SRC_ALPHA, D3D11_BLEND_INV_SRC_COLOR,
	D3D11_BLEND_DEST_ALPHA, D3D11_BLEND_INV_DEST_ALPHA, D3D11_BLEND_SRC_ALPHA_SAT, D3D11_BLEND_INV_SRC_ALPHA,
};
static const D3D11_BLEND kBlendModeAlphaD3D11[] = {
	D3D11_BLEND_ZERO, D3D11_BLEND_ONE, D3D11_BLEND_DEST_ALPHA, D3D11_BLEND_SRC_ALPHA, D3D11_BLEND_INV_DEST_ALPHA, D3D11_BLEND_SRC_ALPHA, D3D11_BLEND_INV_SRC_ALPHA,
	D3D11_BLEND_DEST_ALPHA, D3D11_BLEND_INV_DEST_ALPHA, D3D11_BLEND_SRC_ALPHA_SAT, D3D11_BLEND_INV_SRC_ALPHA,
};
static const D3D11_BLEND_OP kBlendOpD3D11[] = {
	D3D11_BLEND_OP_ADD, D3D11_BLEND_OP_SUBTRACT, D3D11_BLEND_OP_REV_SUBTRACT, D3D11_BLEND_OP_MIN, D3D11_BLEND_OP_MAX,
	/* ADD for all the logic op modes, used for fallback.*/
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,
	D3D11_BLEND_OP_ADD,

};

static const D3D11_LOGIC_OP kLogicOpD3D11[] = {
	/* Zeroes for the blend modes */
	D3D11_LOGIC_OP_CLEAR,
	D3D11_LOGIC_OP_CLEAR,
	D3D11_LOGIC_OP_CLEAR,
	D3D11_LOGIC_OP_CLEAR,
	D3D11_LOGIC_OP_CLEAR,
	/* Actual logic ops */
	D3D11_LOGIC_OP_CLEAR,
	D3D11_LOGIC_OP_SET,
	D3D11_LOGIC_OP_COPY,
	D3D11_LOGIC_OP_COPY_INVERTED,
	D3D11_LOGIC_OP_NOOP,
	D3D11_LOGIC_OP_INVERT,
	D3D11_LOGIC_OP_AND,
	D3D11_LOGIC_OP_NAND,
	D3D11_LOGIC_OP_OR,
	D3D11_LOGIC_OP_NOR,
	D3D11_LOGIC_OP_XOR,
	D3D11_LOGIC_OP_EQUIV,
	D3D11_LOGIC_OP_AND_REVERSE,
	D3D11_LOGIC_OP_AND_INVERTED,
	D3D11_LOGIC_OP_OR_REVERSE,
	D3D11_LOGIC_OP_OR_INVERTED
};



DeviceBlendState* GfxDeviceD3D11::CreateBlendState (const GfxBlendState& state)
{
	std::pair<CachedBlendStates::iterator, bool> result = m_CachedBlendStates.insert(std::make_pair(state, DeviceBlendStateD3D11()));
	if (!result.second)
		return &result.first->second;

	DeviceBlendStateD3D11& d3dstate = result.first->second;
	memcpy (&d3dstate.sourceState, &state, sizeof(d3dstate.sourceState));

	// DX11.1 logic ops, falls through to ADD blendop if not supported
	if(state.blendOp >= kBlendOpLogicalClear && state.blendOp <= kBlendOpLogicalOrInverted
		&& gGraphicsCaps.hasBlendLogicOps)
	{
		D3D11_BLEND_DESC1 desc;
		memset (&desc, 0, sizeof(desc));
		if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0)
			desc.AlphaToCoverageEnable = state.alphaToMask;

		desc.IndependentBlendEnable = FALSE;

		D3D11_RENDER_TARGET_BLEND_DESC1& dst = desc.RenderTarget[0];

		dst.BlendEnable = false;
		dst.LogicOpEnable = true;

		dst.LogicOp = kLogicOpD3D11[state.blendOp];

		DWORD d3dmask = 0;
		const UInt8 mask = state.renderTargetWriteMask;
		if( mask & kColorWriteR ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_RED;
		if( mask & kColorWriteG ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_GREEN;
		if( mask & kColorWriteB ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_BLUE;
		if( mask & kColorWriteA ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_ALPHA;
		dst.RenderTargetWriteMask = d3dmask;
		// GetD3D11_1Device cannot return null if we're running on DX11 and have gGraphicsCaps.hasBlendLogicOps, so no need to check.

		ID3D11BlendState1 *blendObj = NULL;
		HRESULT hr = GetD3D11_1Device()->CreateBlendState1 (&desc, &blendObj);
		d3dstate.deviceState = blendObj;
		AssertIf(FAILED(hr));
		SetDebugNameD3D11 (d3dstate.deviceState, Format("BlendState-%d-%d", dst.SrcBlend, dst.DestBlend));

	}
	else
	{
		D3D11_BLEND_DESC desc;
		memset (&desc, 0, sizeof(desc));
		if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0)
			desc.AlphaToCoverageEnable = state.alphaToMask;
		desc.IndependentBlendEnable = FALSE;

		D3D11_RENDER_TARGET_BLEND_DESC& dst = desc.RenderTarget[0];
		dst.BlendEnable = state.srcBlend != kBlendOne || state.dstBlend != kBlendZero || state.srcBlendAlpha != kBlendOne || state.dstBlendAlpha != kBlendZero;
		dst.SrcBlend = kBlendModeD3D11[state.srcBlend];
		dst.DestBlend = kBlendModeD3D11[state.dstBlend];
		dst.BlendOp = kBlendOpD3D11[state.blendOp];
		dst.SrcBlendAlpha = kBlendModeAlphaD3D11[state.srcBlendAlpha];
		dst.DestBlendAlpha = kBlendModeAlphaD3D11[state.dstBlendAlpha];
		dst.BlendOpAlpha = kBlendOpD3D11[state.blendOpAlpha];

		DWORD d3dmask = 0;
		const UInt8 mask = state.renderTargetWriteMask;
		if( mask & kColorWriteR ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_RED;
		if( mask & kColorWriteG ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_GREEN;
		if( mask & kColorWriteB ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_BLUE;
		if( mask & kColorWriteA ) d3dmask |= D3D11_COLOR_WRITE_ENABLE_ALPHA;
		dst.RenderTargetWriteMask = d3dmask;
		HRESULT hr = GetD3D11Device()->CreateBlendState (&desc, &d3dstate.deviceState);
		AssertIf(FAILED(hr));
		SetDebugNameD3D11 (d3dstate.deviceState, Format("BlendState-%d-%d", dst.SrcBlend, dst.DestBlend));

	}


	return &result.first->second;
}


DeviceDepthState* GfxDeviceD3D11::CreateDepthState(const GfxDepthState& state)
{
	std::pair<CachedDepthStates::iterator, bool> result = m_CachedDepthStates.insert(std::make_pair(state, DeviceDepthState()));
	if (!result.second)
		return &result.first->second;

	DeviceDepthState& st = result.first->second;
	memcpy(&st.sourceState, &state, sizeof(st.sourceState));
	return &result.first->second;
}

DeviceStencilState* GfxDeviceD3D11::CreateStencilState(const GfxStencilState& state)
{
	std::pair<CachedStencilStates::iterator, bool> result = m_CachedStencilStates.insert(std::make_pair(state, DeviceStencilState()));
	if (!result.second)
		return &result.first->second;

	DeviceStencilState& st = result.first->second;
	memcpy(&st.sourceState, &state, sizeof(state));
	return &result.first->second;
}


DeviceRasterState* GfxDeviceD3D11::CreateRasterState(const GfxRasterState& state)
{
	std::pair<CachedRasterStates::iterator, bool> result = m_CachedRasterStates.insert(std::make_pair(state, DeviceRasterState()));
	if (!result.second)
		return &result.first->second;

	DeviceRasterState& st = result.first->second;
	memcpy(&st.sourceState, &state, sizeof(state));
	return &result.first->second;
}


void GfxDeviceD3D11::SetBlendState(const DeviceBlendState* state, float alphaRef)
{
	if (state != m_CurrBlendState)
	{
		m_CurrBlendState = state;
		DeviceBlendStateD3D11* devstate = (DeviceBlendStateD3D11*)state;
		GetD3D11Context()->OMSetBlendState (devstate->deviceState, NULL, 0xFFFFFFFF);
	}

	// alpha test
	m_FFState.alphaTest = state->sourceState.alphaTest;
	m_BuiltinParamValues.SetVectorParam(kShaderVecFFAlphaTestRef, Vector4f(alphaRef, alphaRef, alphaRef, alphaRef));
}


void GfxDeviceD3D11::SetRasterState(const DeviceRasterState* state)
{
	if (m_CurrRasterState != state)
	{
		m_CurrRasterState = state;
		m_CurrRSState = NULL;
	}
}


void GfxDeviceD3D11::SetDepthState (const DeviceDepthState* state)
{
	if (m_CurrDepthState != state)
	{
		m_CurrDepthState = state;
		m_CurrDSState = NULL;
	}
}

void GfxDeviceD3D11::SetStencilState(const DeviceStencilState* state, int stencilRef)
{
	if (m_CurrStencilState != state)
	{
		m_CurrStencilState = state;
		m_CurrDSState = NULL;
	}
	m_StencilRef = stencilRef;
}

void GfxDeviceD3D11::SetupDeferredSRGBWrite()
{
	if (m_SRGBWrite == m_ActualSRGBWrite)
		return;

	// sRGB write is not just a render state on DX11; we need to actually rebind the render target views with
	// a different format. Looks like some drivers do not optimize useless RT changes away, causing
	// a lot of performance being wasted. So only apply sRGB write change when actually needed.
	m_ActualSRGBWrite = m_SRGBWrite;
	RebindActiveRenderTargets (&m_Textures);
}

void GfxDeviceD3D11::SetSRGBWrite (bool enable)
{
	m_SRGBWrite = enable;
}

bool GfxDeviceD3D11::GetSRGBWrite ()
{
	return m_SRGBWrite;
}

void GfxDeviceD3D11::DiscardContents (RenderSurfaceHandle& rs)
{
#	if UNITY_WINRT // WSA/WP8 guaranteed to have DX11.1 runtime, needed for DiscardResource

	if(!rs.IsValid())
		return;

	RenderSurfaceD3D11 *surf = reinterpret_cast<RenderSurfaceD3D11*>( rs.object );
	if (surf->m_Texture)
	{
		ID3D11DeviceContext1 * ctx = (ID3D11DeviceContext1 *)GetD3D11Context();
		DX11_CHK(ctx->DiscardResource(surf->m_Texture));
	}

#	endif
}

GfxDevice* CreateD3D11GfxDevice()
{
	if( !InitializeD3D11() )
		return NULL;

	gGraphicsCaps.InitD3D11();

	GfxDeviceD3D11* device = UNITY_NEW_AS_ROOT(GfxDeviceD3D11(), kMemGfxDevice, "D3D11GfxDevice", "");
	return device;
}


GfxDeviceD3D11::GfxDeviceD3D11()
{
	m_DynamicVBO = NULL;
	InvalidateState();
	ResetFrameStats();

	m_Renderer = kGfxRendererD3D11;
	m_UsesOpenGLTextureCoords = false;
	m_UsesHalfTexelOffset = false;
	m_IsThreadable = true;

	m_MaxBufferedFrames = -1; // no limiting

	m_Viewport[0] = m_Viewport[1] = m_Viewport[2] = m_Viewport[3] = 0;
	m_ScissorRect[0] = m_ScissorRect[1] = m_ScissorRect[2] = m_ScissorRect[3] = 0;
	m_CurrTargetWidth = 0;
	m_CurrTargetHeight = 0;
	m_CurrWindowWidth = 0;
	m_CurrWindowHeight = 0;

	m_InvertProjMatrix = false;
	m_AppBackfaceMode = false;
	m_UserBackfaceMode = false;
	m_Wireframe = false;
	m_Scissor = false;
	m_SRGBWrite = false;
	m_ActualSRGBWrite = false;

	m_FramebufferDepthFormat = kDepthFormat24;

	// constant buffer for fog params
	m_CBs.SetCBInfo (kSLPropFogCB.index, k11FogSize*16);

	extern RenderSurfaceBase* DummyColorBackBuferD3D11();
	SetBackBufferColorSurface(DummyColorBackBuferD3D11());

	extern RenderSurfaceBase* DummyDepthBackBuferD3D11();
	SetBackBufferDepthSurface(DummyDepthBackBuferD3D11());
}

GfxDeviceD3D11::~GfxDeviceD3D11()
{
#if !ENABLE_GFXDEVICE_REMOTE_PROCESS_WORKER
	PluginsSetGraphicsDevice (GetD3D11Device(), kGfxRendererD3D11, kGfxDeviceEventShutdown);
#endif

	StreamOutSkinningInfo::CleanUp();

#if ENABLE_PROFILER
	g_TimerQueriesD3D11.ReleaseAllQueries();
#endif

	D3D11VBO::CleanupSharedBuffers();
	if( m_DynamicVBO )
		delete m_DynamicVBO;
	for (FFProgramCacheD3D11::iterator it = m_FFPrograms.begin(); it != m_FFPrograms.end(); ++it)
		delete it->second;
	for (CachedBlendStates::iterator it = m_CachedBlendStates.begin(); it != m_CachedBlendStates.end(); ++it)
		it->second.deviceState->Release();
	for (CachedDepthStencilStates::iterator it = m_CachedDepthStencilStates.begin(); it != m_CachedDepthStencilStates.end(); ++it)
		it->second->Release();
	for (CachedFinalRasterStates::iterator it = m_CachedFinalRasterStates.begin(); it != m_CachedFinalRasterStates.end(); ++it)
		it->second->Release();
	m_Imm.Cleanup();
	m_VertexDecls.Clear();
	m_CBs.Clear();
	m_Textures.ClearTextureResources();
	m_Resolves.Clear();
	DestroyD3D11Device();
	CleanupD3D11();
}


void GfxDeviceD3D11::InvalidateState()
{
	g_ActiveInputLayoutD3D11 = NULL;
	g_CurrentVSInputD3D11 = NULL;
	g_ActiveTopologyD3D11 = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED;

	m_TransformState.Invalidate(m_BuiltinParamValues);

	m_FogParams.Invalidate();

	//m_State.Invalidate(*this);
	m_Imm.Invalidate();
	//m_VSConstantCache.Invalidate();
	//m_PSConstantCache.Invalidate();

	memset (&m_FFState, 0, sizeof(m_FFState));
	m_FFState.useUniformInsteadOfVertexColor = true;

	m_CurrBlendState = NULL;
	m_CurrRasterState = NULL;
	m_CurrDepthState = NULL;
	m_CurrStencilState = NULL;
	m_CurrRSState = NULL;
	m_CurrDSState = NULL;
	m_CurrStencilRef = -1;

	for (int pt = 0; pt < kShaderTypeCount; ++pt)
	{
		m_ActiveGpuProgram[pt] = NULL;
		m_ActiveGpuProgramParams[pt] = NULL;
		m_ActiveShaders[pt] = NULL;
		for (int i = 0; i < kMaxSupportedTextureUnits; ++i)
		{
			m_ActiveTextures[pt][i].m_ID = -1;
			m_ActiveSamplers[pt][i].m_ID = -1;
		}
	}

	m_Textures.InvalidateSamplers();
	m_CBs.InvalidateState();

	ID3D11DeviceContext* ctx = GetD3D11Context(true);
	if (ctx)
	{
		D3D11_CALL(ctx->VSSetShader (NULL, NULL, 0));
		D3D11_CALL(ctx->PSSetShader (NULL, NULL, 0));
		D3D11_CALL(ctx->GSSetShader (NULL, NULL, 0));
		D3D11_CALL(ctx->HSSetShader (NULL, NULL, 0));
		D3D11_CALL(ctx->DSSetShader (NULL, NULL, 0));
	}
}


void GfxDeviceD3D11::Clear (UInt32 clearFlags, const float color[4], float depth, int stencil)
{
	DX11_LOG_ENTER_FUNCTION("Clear(%d, (%.2f, %.2f, %.2f, %.2f), %.2f, %d)", clearFlags, color[0], color[1], color[2], color[3], depth, stencil);
	SetupDeferredSRGBWrite ();
	ID3D11DeviceContext* ctx = GetD3D11Context();

	if ((clearFlags & kGfxClearColor) && g_D3D11CurrRT)
		DX11_CHK(ctx->ClearRenderTargetView (g_D3D11CurrRT, color));
	if ((clearFlags & kGfxClearDepthStencil) && g_D3D11CurrDS)
	{
		UINT flags = 0;
		if (clearFlags & kGfxClearDepth)
			flags |= D3D11_CLEAR_DEPTH;
		if (clearFlags & kGfxClearStencil)
			flags |= D3D11_CLEAR_STENCIL;
		DX11_CHK(ctx->ClearDepthStencilView (g_D3D11CurrDS, flags, depth, stencil));
	}
}

void GfxDeviceD3D11::SetUserBackfaceMode( bool enable )
{
	if (m_UserBackfaceMode != enable)
	{
		m_UserBackfaceMode = enable;
		m_CurrRSState = NULL;
	}
}

void GfxDeviceD3D11::SetWireframe (bool wire)
{
	if (m_Wireframe != wire)
	{
		m_Wireframe = wire;
		m_CurrRSState = NULL;
	}
}

bool GfxDeviceD3D11::GetWireframe() const
{
	return m_Wireframe;
}



void GfxDeviceD3D11::SetInvertProjectionMatrix( bool enable )
{
	if (m_InvertProjMatrix == enable)
		return;

	m_InvertProjMatrix = enable;

	// When setting up "invert" flag, invert the matrix as well.
	Matrix4x4f& m = m_BuiltinParamValues.GetWritableMatrixParam(kShaderMatProj);
	m.Get(1,1) = -m.Get(1,1);
	m.Get(1,3) = -m.Get(1,3);
	m_TransformState.dirtyFlags |= TransformState::kProjDirty;

	m_CurrRSState = NULL;
}

bool GfxDeviceD3D11::GetInvertProjectionMatrix() const
{
	return m_InvertProjMatrix;
}

void GfxDeviceD3D11::SetWorldMatrix( const float matrix[16] )
{
	CopyMatrix( matrix, m_TransformState.worldMatrix.GetPtr() );
	m_TransformState.dirtyFlags |= TransformState::kWorldDirty;
}

void GfxDeviceD3D11::SetViewMatrix( const float matrix[16] )
{
	m_TransformState.SetViewMatrix (matrix, m_BuiltinParamValues);
}

void GfxDeviceD3D11::SetProjectionMatrix (const Matrix4x4f& matrix)
{
	Matrix4x4f& m = m_BuiltinParamValues.GetWritableMatrixParam(kShaderMatProj);
	CopyMatrix (matrix.GetPtr(), m.GetPtr());
	CopyMatrix (matrix.GetPtr(), m_TransformState.projectionMatrixOriginal.GetPtr());
	CalculateDeviceProjectionMatrix (m, m_UsesOpenGLTextureCoords, m_InvertProjMatrix);
	m_TransformState.dirtyFlags |= TransformState::kProjDirty;
}

void GfxDeviceD3D11::GetMatrix( float outMatrix[16] ) const
{
	m_TransformState.UpdateWorldViewMatrix (m_BuiltinParamValues);
	CopyMatrix (m_TransformState.worldViewMatrix.GetPtr(), outMatrix);
}

const float* GfxDeviceD3D11::GetWorldMatrix() const
{
	return m_TransformState.worldMatrix.GetPtr();
}

const float* GfxDeviceD3D11::GetViewMatrix() const
{
	return m_BuiltinParamValues.GetMatrixParam(kShaderMatView).GetPtr();
}

const float* GfxDeviceD3D11::GetProjectionMatrix() const
{
	return m_TransformState.projectionMatrixOriginal.GetPtr();
}

const float* GfxDeviceD3D11::GetDeviceProjectionMatrix() const
{
	return m_BuiltinParamValues.GetMatrixParam(kShaderMatProj).GetPtr();
}


void GfxDeviceD3D11::SetNormalizationBackface( NormalizationMode mode, bool backface )
{
	if (m_AppBackfaceMode != backface)
	{
		m_AppBackfaceMode = backface;
		m_CurrRSState = NULL;
	}
}

void GfxDeviceD3D11::SetFFLighting( bool on, bool separateSpecular, ColorMaterialMode colorMaterial )
{
	DX11_LOG_ENTER_FUNCTION("SetFFLighting(%s, %s, %d)", GetDX11BoolString(on), GetDX11BoolString(separateSpecular), colorMaterial);
	DebugAssert(colorMaterial!=kColorMatUnknown);
	m_FFState.lightingEnabled = on;
	m_FFState.specularEnabled = on && separateSpecular;
	m_FFState.colorMaterial = colorMaterial;
}

void GfxDeviceD3D11::SetMaterial( const float ambient[4], const float diffuse[4], const float specular[4], const float emissive[4], const float shininess )
{
	DX11_LOG_ENTER_FUNCTION("SetMaterial((%.2f, %.2f, %.2f, %.2f), (%.2f, %.2f, %.2f, %.2f), (%.2f, %.2f, %.2f, %.2f), (%.2f, %.2f, %.2f, %.2f), %.2f)",
		ambient[0], ambient[1], ambient[2], ambient[3],
		diffuse[0], diffuse[1], diffuse[2], diffuse[3],
		specular[0], specular[1], specular[2], specular[3],
		emissive[0], emissive[1], emissive[2], emissive[3],
		shininess);

	float glshine = clamp01 (shininess) * 128.0f;

	m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatAmbient, Vector4f(ambient[0], ambient[1], ambient[2], 1.0F));
	m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatDiffuse, Vector4f(diffuse));
	m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatSpecular, Vector4f(specular[0], specular[1], specular[2], glshine));
	m_BuiltinParamValues.SetVectorParam(kShaderVecFFMatEmission, Vector4f(emissive[0], emissive[1], emissive[2], 1.0F));
}


void GfxDeviceD3D11::SetColor( const float color[4] )
{
	m_BuiltinParamValues.SetVectorParam(kShaderVecFFColor, Vector4f(color));
}



void GfxDeviceD3D11::SetViewport( int x, int y, int width, int height )
{
	DX11_LOG_ENTER_FUNCTION("SetViewport(%d, %d, %d, %d)", x, y, width, height);
	m_Viewport[0] = x;
	m_Viewport[1] = y;
	m_Viewport[2] = width;
	m_Viewport[3] = height;

	D3D11_VIEWPORT view;
	view.TopLeftX = x;
	view.TopLeftY = y;
	view.Width = width;
	view.Height = height;
	view.MinDepth = 0.0f;
	view.MaxDepth = 1.0f;
	ID3D11DeviceContext* ctx = GetD3D11Context();
	//@TODO
	//if( !dev ) // happens on startup, when deleting all render textures
	//	return;
	ctx->RSSetViewports (1, &view);
}

void GfxDeviceD3D11::GetViewport( int* port ) const
{
	port[0] = m_Viewport[0];
	port[1] = m_Viewport[1];
	port[2] = m_Viewport[2];
	port[3] = m_Viewport[3];
}


void GfxDeviceD3D11::SetScissorRect (int x, int y, int width, int height)
{
	DX11_LOG_ENTER_FUNCTION("SetScissorRect(%d, %d, %d, %d)", x, y, width, height);
	if (!m_Scissor)
	{
		m_Scissor = true;
		m_CurrRSState = NULL;
	}

	m_ScissorRect[0] = x;
	m_ScissorRect[1] = y;
	m_ScissorRect[2] = width;
	m_ScissorRect[3] = height;

	D3D11_RECT rc;
	rc.left = x;
	rc.top = y;
	rc.right = x + width;
	rc.bottom = y + height;
	GetD3D11Context()->RSSetScissorRects (1, &rc);
}

void GfxDeviceD3D11::DisableScissor()
{
	if (m_Scissor)
	{
		m_Scissor = false;
		m_CurrRSState = NULL;
	}
}

bool GfxDeviceD3D11::IsScissorEnabled() const
{
	return m_Scissor;
}

void GfxDeviceD3D11::GetScissorRect (int scissor[4]) const
{
	scissor[0] = m_ScissorRect[0];
	scissor[1] = m_ScissorRect[1];
	scissor[2] = m_ScissorRect[2];
	scissor[3] = m_ScissorRect[3];
}


struct TextureCombiners11
{
	const ShaderLab::TextureBinding* texEnvs;
	int count;
};

bool GfxDeviceD3D11::IsCombineModeSupported( unsigned int combiner )
{
	return true;
}

TextureCombinersHandle GfxDeviceD3D11::CreateTextureCombiners (int count, const ShaderLab::TextureBinding* texEnvs, const ShaderLab::PropertySheet* props, bool hasVertexColorOrLighting, bool usesAddSpecular)
{
	DX11_LOG_ENTER_FUNCTION("CreateTextureCombiners()");
	if (count > gGraphicsCaps.maxTexUnits)
		return TextureCombinersHandle(NULL);

	TextureCombiners11* combiners = new TextureCombiners11();
	combiners->texEnvs = texEnvs;
	combiners->count = count;
	return TextureCombinersHandle(combiners);
}

void GfxDeviceD3D11::DeleteTextureCombiners (TextureCombinersHandle& textureCombiners)
{
	DX11_LOG_ENTER_FUNCTION("DeleteTextureCombiners()");
	TextureCombiners11* combiners = OBJECT_FROM_HANDLE(textureCombiners,TextureCombiners11);
	delete combiners;
	textureCombiners.Reset();
}

void GfxDeviceD3D11::SetTextureCombinersThreadable( TextureCombinersHandle textureCombiners, const TexEnvData* texEnvData, const Vector4f* texColors )
{
	DX11_LOG_ENTER_FUNCTION("SetTextureCombinersThreadable()");
	TextureCombiners11* combiners = OBJECT_FROM_HANDLE(textureCombiners,TextureCombiners11);
	Assert (combiners);

	const int count = std::min(combiners->count, gGraphicsCaps.maxTexUnits);
	m_FFState.texUnitCount = count;
	for (int i = 0; i < count; ++i)
	{
		const ShaderLab::TextureBinding& binding = combiners->texEnvs[i];
		ApplyTexEnvData (i, i, texEnvData[i]);
		m_BuiltinParamValues.SetVectorParam ((BuiltinShaderVectorParam)(kShaderVecFFTextureEnvColor0 + i), texColors[i]);
		m_FFState.texUnitColorCombiner[i] = binding.m_CombColor;
		m_FFState.texUnitAlphaCombiner[i] = binding.m_CombAlpha;
	}

	// unused textures
	UInt32 mask = (1<<count)-1;
	m_FFState.texUnitCube &= mask;
	m_FFState.texUnit3D &= mask;
	m_FFState.texUnitProjected &= mask;
}

void GfxDeviceD3D11::SetTextureCombiners( TextureCombinersHandle textureCombiners, const ShaderLab::PropertySheet* props )
{
	DX11_LOG_ENTER_FUNCTION("SetTextureCombiners()");
	TextureCombiners11* combiners = OBJECT_FROM_HANDLE(textureCombiners,TextureCombiners11);
	Assert(combiners);

	const int count = std::min(combiners->count, gGraphicsCaps.maxTexUnits);

	// Fill in arrays
	TexEnvData* texEnvData;
	ALLOC_TEMP (texEnvData, TexEnvData, count);
	for (int i = 0; i < count; ++i)
	{
		const ShaderLab::TextureBinding& binding = combiners->texEnvs[i];
		ShaderLab::TexEnv *te = ShaderLab::GetTexEnvForBinding(binding, props);
		Assert(te != NULL);
		te->PrepareData (binding.m_TextureName.index, binding.m_MatrixName, props, &texEnvData[i]);
	}

	Vector4f* texColors;
	ALLOC_TEMP (texColors, Vector4f, count);
	for (int i = 0; i < count; ++i)
	{
		const ShaderLab::TextureBinding& binding = combiners->texEnvs[i];
		texColors[i] = binding.GetTexColor().Get (props);
	}
	GfxDeviceD3D11::SetTextureCombinersThreadable (textureCombiners, texEnvData, texColors);
}



void UnbindTextureD3D11 (TextureID texture)
{
	DX11_LOG_ENTER_FUNCTION("UnbindTextureD3D11(%d)", texture.m_ID);
	GfxDeviceD3D11& device = static_cast<GfxDeviceD3D11&>(GetRealGfxDevice());
	ID3D11DeviceContext* ctx = GetD3D11Context();

	for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt)
	{
		for (int i = 0; i < kMaxSupportedTextureUnits; ++i)
		{
			if (device.m_ActiveTextures[pt][i]==texture)
			{
				ID3D11ShaderResourceView* srv = NULL;
				switch (pt) {
				case kShaderVertex:   ctx->VSSetShaderResources (i, 1, &srv); break;
				case kShaderFragment: ctx->PSSetShaderResources (i, 1, &srv); break;
				case kShaderGeometry: ctx->GSSetShaderResources (i, 1, &srv); break;
				case kShaderHull:     ctx->HSSetShaderResources (i, 1, &srv); break;
				case kShaderDomain:   ctx->DSSetShaderResources (i, 1, &srv); break;
				default: AssertString("unknown shader type");
				}
				device.m_ActiveTextures[pt][i].m_ID = -1;
			}
			if (device.m_ActiveSamplers[pt][i]==texture)
			{
				device.m_ActiveSamplers[pt][i].m_ID = -1;
			}
		}
	}
}



void GfxDeviceD3D11::SetTexture (ShaderType shaderType, int unit, int samplerUnit, TextureID texture, TextureDimension dim, float bias)
{
	DebugAssertIf (dim < kTexDim2D || dim > kTexDimCUBE);
	DebugAssertIf (unit < 0 || unit >= kMaxSupportedTextureUnits);

	// WP8 seems to have a driver bug (?) with occasionally losing texture state; can't do redundant bind early out here.
	// Repros on Shadowgun flyby on Nokia Not For Sale.
	#if !UNITY_WP8
	if (m_ActiveTextures[shaderType][unit] == texture && (samplerUnit >= 0 && m_ActiveSamplers[shaderType][samplerUnit] == texture))
		return;
	#endif

	if (m_Textures.SetTexture (shaderType, unit, samplerUnit, texture, bias))
	{
		m_Stats.AddUsedTexture(texture);
		m_ActiveTextures[shaderType][unit] = texture;
		if (samplerUnit >= 0)
			m_ActiveSamplers[shaderType][samplerUnit] = texture;
	}

	if (shaderType == kShaderFragment && unit < kMaxSupportedTextureCoords)
	{
		if (m_FFState.texUnitCount <= unit)
			m_FFState.texUnitCount = unit+1;

		UInt32 mask = 1<<unit;
		if (dim==kTexDimCUBE)
			m_FFState.texUnitCube |= mask;
		else
			m_FFState.texUnitCube &= ~mask;
		if (dim==kTexDim3D)
			m_FFState.texUnit3D |= mask;
		else
			m_FFState.texUnit3D &= ~mask;
	}
}


void GfxDeviceD3D11::SetTextureTransform( int unit, TextureDimension dim, TexGenMode texGen, bool identity, const float matrix[16])
{
	Assert (unit >= 0 && unit < kMaxSupportedTextureCoords);

	TextureSourceD3D11 texSource = texGen == kTexGenDisabled ? kTexSourceUV0 : static_cast<TextureSourceD3D11>(texGen + kTexSourceUV7);
	m_FFState.texUnitSources = m_FFState.texUnitSources & ~(15<<(unit*4)) | (UInt64(texSource)<<(unit*4));

	if (identity)
		m_TextureUnits[unit].matrix.SetIdentity();
	else
		CopyMatrix (matrix, m_TextureUnits[unit].matrix.GetPtr());

	// Detect if we have a projective texture matrix
	m_FFState.texUnitProjected &= ~(1<<unit);
	if (!identity && dim==kTexDim2D)
	{
		if (matrix[3] != 0.0f || matrix[7] != 0.0f || matrix[11] != 0.0f || matrix[15] != 1.0f)
			m_FFState.texUnitProjected |= (1<<unit);
	}
}

void GfxDeviceD3D11::SetTextureParams( TextureID texture, TextureDimension texDim, TextureFilterMode filter, TextureWrapMode wrap, int anisoLevel, bool hasMipMap, TextureColorSpace colorSpace )
{
	UnbindTextureD3D11 (texture);
	m_Textures.SetTextureParams (texture, texDim, filter, wrap, anisoLevel, hasMipMap, colorSpace);
}



void GfxDeviceD3D11::SetShadersThreadable (GpuProgram* programs[kShaderTypeCount], const GpuProgramParameters* params[kShaderTypeCount], UInt8 const * const paramsBuffer[kShaderTypeCount])
{
	for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt)
	{
		m_ActiveGpuProgram[pt] = programs[pt];
		m_ActiveGpuProgramParams[pt] = params[pt];
	}

	// Apply programmable shader parameters
	if (m_ActiveGpuProgram[kShaderVertex] && m_ActiveGpuProgram[kShaderFragment])
	{
		for (int pt = kShaderVertex; pt < kShaderTypeCount; ++pt)
		{
			if (m_ActiveGpuProgram[pt])
			{
				DebugAssert (!m_ActiveGpuProgram[pt] || m_ActiveGpuProgram[pt]->GetImplType() == pt);
				D3D11CommonShader* prog = static_cast<D3D11CommonShader*>(m_ActiveGpuProgram[pt]);
				m_ActiveGpuProgram[pt]->ApplyGpuProgram (*params[pt], paramsBuffer[pt]);
			}
		}
	}
}


bool GfxDeviceD3D11::IsShaderActive( ShaderType type ) const
{
	return (m_ActiveGpuProgram[type] != 0);
}

void GfxDeviceD3D11::DestroySubProgram( ShaderLab::SubProgram* subprogram )
{
	delete subprogram;
}

void GfxDeviceD3D11::SetConstantBufferInfo (int id, int size)
{
	m_CBs.SetCBInfo (id, size);
}

void GfxDeviceD3D11::DisableLights( int startLight )
{
	startLight = std::min (startLight, gGraphicsCaps.maxLights);
	m_FFState.lightCount = startLight;
	
	const Vector4f black(0.0F, 0.0F, 0.0F, 0.0F);
	const Vector4f zpos(0.0F, 0.0F, 1.0F, 0.0F);
	for (int i = startLight; i < gGraphicsCaps.maxLights; ++i)
	{
		m_BuiltinParamValues.SetVectorParam(BuiltinShaderVectorParam(kShaderVecLight0Position + i), zpos);
		m_BuiltinParamValues.SetVectorParam(BuiltinShaderVectorParam(kShaderVecLight0Diffuse + i), black);
	}
}

void GfxDeviceD3D11::SetLight( int light, const GfxVertexLight& data)
{
	if (light >= gGraphicsCaps.maxLights)
		return;
	SetupVertexLightParams (light, data);
}

void GfxDeviceD3D11::SetAmbient( const float ambient[4] )
{
	m_BuiltinParamValues.SetVectorParam(kShaderVecLightModelAmbient, Vector4f(ambient));
}


void GfxDeviceD3D11::EnableFog (const GfxFogParams& fog)
{
	DebugAssert (fog.mode > kFogDisabled);
	m_FogParams = fog;

	//@TODO: fog DXBC patching not implemented for 9.x level; and something still wrong with FF shaders in 9.x level as well
	// (e.g. crashes WARP). Just disable fog for now.
	if (gGraphicsCaps.d3d11.featureLevel < kDX11Level10_0)
		m_FogParams.mode = kFogDisabled;
}

void GfxDeviceD3D11::DisableFog()
{
	m_FogParams.mode = kFogDisabled;
	m_FogParams.density = 0.0f;
}


VBO* GfxDeviceD3D11::CreateVBO()
{
	VBO* vbo = new D3D11VBO();
	OnCreateVBO(vbo);
	return vbo;
}

void GfxDeviceD3D11::DeleteVBO( VBO* vbo )
{
	OnDeleteVBO(vbo);
	delete vbo;
}

DynamicVBO&	GfxDeviceD3D11::GetDynamicVBO()
{
	if( !m_DynamicVBO ) {
		m_DynamicVBO = new DynamicD3D11VBO( 1024 * 1024, 65536 ); // initial 1 MiB VB, 64 KiB IB
	}
	return *m_DynamicVBO;
}

/*
void GfxDeviceD3D11::ResetDynamicResources()
{
	delete m_DynamicVBO;
	m_DynamicVBO = NULL;

	CleanupEventQueries ();

	for( ListIterator<D3D11VBO*> i = m_DynamicVBOs.begin(); i != m_DynamicVBOs.end(); ++i )
	{
		D3D11VBO* vbo = *i;
		vbo->ResetDynamicVB();
	}
}
*/

GfxDeviceD3D11& GetD3D11GfxDevice()
{
	GfxDevice& device = GetRealGfxDevice();
	DebugAssert(device.GetRenderer() == kGfxRendererD3D11);
	return static_cast<GfxDeviceD3D11&>(device);
}


ID3D11InputLayout* GetD3D11VertexDeclaration (const ChannelInfoArray& channels)
{
	GfxDevice& device = GetRealGfxDevice();
	DebugAssert(device.GetRenderer() == kGfxRendererD3D11);
	GfxDeviceD3D11* deviceD3D = static_cast<GfxDeviceD3D11*>( &device );
	return deviceD3D->GetVertexDecls().GetVertexDecl (channels, g_CurrentVSInputD3D11);
}

const InputSignatureD3D11* GetD3D11InputSignature (void* code, unsigned length)
{
	GfxDevice& device = GetRealGfxDevice();
	DebugAssert(device.GetRenderer() == kGfxRendererD3D11);
	GfxDeviceD3D11* deviceD3D = static_cast<GfxDeviceD3D11*>( &device );
	return deviceD3D->GetVertexDecls().GetShaderInputSignature (code, length);
}

ConstantBuffersD3D11& GetD3D11ConstantBuffers (GfxDevice& device)
{
	Assert (device.GetRenderer() == kGfxRendererD3D11);
	GfxDeviceD3D11& deviceD3D = static_cast<GfxDeviceD3D11&>(device);
	return deviceD3D.GetConstantBuffers();
}

TexturesD3D11& GetD3D11Textures (GfxDevice& device)
{
	Assert (device.GetRenderer() == kGfxRendererD3D11);
	GfxDeviceD3D11& deviceD3D = static_cast<GfxDeviceD3D11&>(device);
	return deviceD3D.GetTextures();
}


// ---------- render textures


RenderSurfaceHandle CreateRenderColorSurfaceD3D11( TextureID textureID, int width, int height, int samples, int depth, TextureDimension dim, UInt32 createFlags, RenderTextureFormat format, TexturesD3D11& textures);
RenderSurfaceHandle CreateRenderDepthSurfaceD3D11( TextureID textureID, int width, int height, int samples, TextureDimension dim, DepthBufferFormat depthFormat, UInt32 createFlags, TexturesD3D11& textures);
void DestroyRenderSurfaceD3D11 (RenderSurfaceHandle& rsHandle, TexturesD3D11& textures);
bool SetRenderTargetD3D11 (int count, RenderSurfaceHandle* colorHandles, RenderSurfaceHandle depthHandle, int mipLevel, CubemapFace face, int* outTargetWidth, int* outTargetHeight, TexturesD3D11* textures);
RenderSurfaceHandle GetActiveRenderColorSurfaceD3D11(int index);
RenderSurfaceHandle GetActiveRenderDepthSurfaceD3D11();
RenderSurfaceHandle GetActiveRenderColorSurfaceBBD3D11();

RenderSurfaceHandle GfxDeviceD3D11::CreateRenderColorSurface (TextureID textureID, int width, int height, int samples, int depth, TextureDimension dim, RenderTextureFormat format, UInt32 createFlags)
{
	DX11_LOG_ENTER_FUNCTION("CreateRenderColorSurface(%d, %d, %d, %d, %d)", textureID.m_ID, width, height, format, createFlags);
	return CreateRenderColorSurfaceD3D11 (textureID, width, height, samples, depth, dim, createFlags, format, m_Textures);
}
RenderSurfaceHandle GfxDeviceD3D11::CreateRenderDepthSurface (TextureID textureID, int width, int height, int samples, TextureDimension dim, DepthBufferFormat depthFormat, UInt32 createFlags)
{
	DX11_LOG_ENTER_FUNCTION("CreateRenderDepthSurface(%d, %d, %d, %d, %d, %d)", textureID.m_ID, width, height, dim, depthFormat, createFlags);
	return CreateRenderDepthSurfaceD3D11 (textureID, width, height, samples, dim, depthFormat, createFlags, m_Textures);
}
void GfxDeviceD3D11::DestroyRenderSurface (RenderSurfaceHandle& rs)
{
	DX11_LOG_ENTER_FUNCTION("DestroyRenderSurface()");
	DestroyRenderSurfaceD3D11 (rs, m_Textures);
}
void GfxDeviceD3D11::SetRenderTargets (int count, RenderSurfaceHandle* colorHandles, RenderSurfaceHandle depthHandle, int mipLevel, CubemapFace face)
{
	DX11_LOG_ENTER_FUNCTION("SetRenderTargets(%i, c0=%p, d=%p, mip=%i, f=%i)", count, colorHandles[0].object, depthHandle.object, mipLevel, face);
	SetupDeferredSRGBWrite ();
	m_CurrTargetWidth = m_CurrWindowWidth;
	m_CurrTargetHeight = m_CurrWindowHeight;
	if (SetRenderTargetD3D11 (count, colorHandles, depthHandle, mipLevel, face, &m_CurrTargetWidth, &m_CurrTargetHeight, &m_Textures))
	{
		// changing render target might mean different color clear flags; so reset current state
		m_CurrBlendState = NULL;
	}
}

void GfxDeviceD3D11::ResolveDepthIntoTexture (RenderSurfaceHandle colorHandle, RenderSurfaceHandle depthHandle)
{
	DX11_LOG_ENTER_FUNCTION("ResolveDepthIntoTexture(%p, %p)", colorHandle.object, depthHandle.object);
	RenderSurfaceD3D11* depthSurf = reinterpret_cast<RenderSurfaceD3D11*>(depthHandle.object);
	TexturesD3D11::D3D11Texture* destTexture = m_Textures.GetTexture (depthSurf->textureID);
	DebugAssert (destTexture);
	if (!destTexture)
		return;
	DebugAssert (g_D3D11CurrDepthRT);
	if (!g_D3D11CurrDepthRT || !g_D3D11CurrDepthRT->m_Texture)
		return;

	GetD3D11Context()->CopyResource (destTexture->m_Texture, g_D3D11CurrDepthRT->m_Texture);
}


void GfxDeviceD3D11::ResolveColorSurface (RenderSurfaceHandle srcHandle, RenderSurfaceHandle dstHandle)
{
	Assert (srcHandle.IsValid());
	Assert (dstHandle.IsValid());
	RenderColorSurfaceD3D11* src = reinterpret_cast<RenderColorSurfaceD3D11*>(srcHandle.object);
	RenderColorSurfaceD3D11* dst = reinterpret_cast<RenderColorSurfaceD3D11*>(dstHandle.object);
	if (!src->colorSurface || !dst->colorSurface)
	{
		WarningString("RenderTexture: Resolving non-color surfaces.");
		return;
	}
	if (src->dim != dst->dim)
	{
		WarningString("RenderTexture: Resolving surfaces of different types.");
		return;
	}
	if (src->format != dst->format)
	{
		WarningString("RenderTexture: Resolving surfaces of different formats.");
		return;
	}
	if (src->width != dst->width || src->height != dst->height)
	{
		WarningString("RenderTexture: Resolving surfaces of different sizes.");
		return;
	}

	ID3D11DeviceContext* ctx = GetD3D11Context();
	if (src->samples <= 1 && dst->samples <= 1)
	{
		ctx->CopyResource (dst->m_Texture, src->m_Texture);
	}
	else
	{
		extern DXGI_FORMAT kD3D11RenderTextureFormatsNorm[kRTFormatCount];
		ctx->ResolveSubresource (dst->m_Texture, 0, src->m_Texture, 0, kD3D11RenderTextureFormatsNorm[dst->format]);
		if ((dst->flags & kSurfaceCreateMipmap) &&
			(dst->flags & kSurfaceCreateAutoGenMips) &&
			dst->m_SRViewForMips)
		{
			ctx->GenerateMips (dst->m_SRViewForMips);
	}
	}
}


RenderSurfaceHandle GfxDeviceD3D11::GetActiveRenderColorSurface(int index)
{
	DX11_LOG_ENTER_FUNCTION("GetActiveRenderColorSurface(%d)", index);
	return GetActiveRenderColorSurfaceD3D11(index);
}
RenderSurfaceHandle GfxDeviceD3D11::GetActiveRenderDepthSurface()
{
	DX11_LOG_ENTER_FUNCTION("GetActiveRenderDepthSurface");
	return GetActiveRenderDepthSurfaceD3D11();
}
void GfxDeviceD3D11::SetSurfaceFlags (RenderSurfaceHandle surf, UInt32 flags, UInt32 keepFlags)
{
}


// ---------- uploading textures

void GfxDeviceD3D11::UploadTexture2D( TextureID texture, TextureDimension dimension, UInt8* srcData, int srcSize, int width, int height, TextureFormat format, int mipCount, UInt32 uploadFlags, int skipMipLevels, TextureUsageMode usageMode, TextureColorSpace colorSpace )
{
	DX11_LOG_ENTER_FUNCTION("UploadTexture2D(%d, %d, <srcData>, %d, %d, %d, %d, %d, %d, %d)",
		texture.m_ID, dimension, width, height, format, mipCount, uploadFlags, skipMipLevels, usageMode);
	UnbindTextureD3D11 (texture);
	m_Textures.UploadTexture2D (texture, dimension, srcData, width, height, format, mipCount, uploadFlags, skipMipLevels, usageMode, colorSpace);
}
void GfxDeviceD3D11::UploadTextureSubData2D( TextureID texture, UInt8* srcData, int srcSize, int mipLevel, int x, int y, int width, int height, TextureFormat format, TextureColorSpace colorSpace )
{
	DX11_LOG_ENTER_FUNCTION("UploadTextureSubData2D(%d, <srcData>, ...)", texture.m_ID)
	m_Textures.UploadTextureSubData2D (texture, srcData, mipLevel, x, y, width, height, format, colorSpace);
}
void GfxDeviceD3D11::UploadTextureCube( TextureID texture, UInt8* srcData, int srcSize, int faceDataSize, int size, TextureFormat format, int mipCount, UInt32 uploadFlags, TextureColorSpace colorSpace )
{
	DX11_LOG_ENTER_FUNCTION("UploadTextureCube(%d, <srcData>, ...)", texture.m_ID)
	UnbindTextureD3D11 (texture);
	m_Textures.UploadTextureCube (texture, srcData, faceDataSize, size, format, mipCount, uploadFlags, colorSpace);
}
void GfxDeviceD3D11::UploadTexture3D( TextureID texture, UInt8* srcData, int srcSize, int width, int height, int depth, TextureFormat format, int mipCount, UInt32 uploadFlags )
{
	DX11_LOG_ENTER_FUNCTION("UploadTexture3D(%d, <srcData>, ...)", texture.m_ID)
	UnbindTextureD3D11 (texture);
	m_Textures.UploadTexture3D (texture, srcData, width, height, depth, format, mipCount, uploadFlags);
}
void GfxDeviceD3D11::DeleteTexture( TextureID texture )
{
	DX11_LOG_ENTER_FUNCTION("DeleteTexture(%d)", texture.m_ID)
	UnbindTextureD3D11 (texture);
	m_Textures.DeleteTexture (texture);
}


// ---------- context

GfxDevice::PresentMode GfxDeviceD3D11::GetPresentMode()
{
	return kPresentBeforeUpdate;
}

void GfxDeviceD3D11::BeginFrame()
{
	DX11_LOG_OUTPUT("*****************************************");
	DX11_LOG_OUTPUT("*****************************************");
	DX11_LOG_OUTPUT("*****************************************");
	DX11_LOG_ENTER_FUNCTION("BeginFrame()");
	DX11_MARK_FRAME_BEGIN();
	m_InsideFrame = true;

	#if UNITY_WINRT
	ActivateD3D11BackBuffer(this);	// ?!-
	#endif
}



void GfxDeviceD3D11::EndFrame()
{
	DX11_LOG_ENTER_FUNCTION("EndFrame()");
	DX11_MARK_FRAME_END();
	m_InsideFrame = false;
}

bool GfxDeviceD3D11::IsValidState()
{
	return true;
}

void GfxDeviceD3D11::PresentFrame()
{
	#if !UNITY_WP8
	IDXGISwapChain* swapChain = GetD3D11SwapChain();
	if (swapChain)
		swapChain->Present (GetD3D11SyncInterval(), 0);
	#endif
	m_CBs.NewFrame();
}

void GfxDeviceD3D11::FinishRendering()
{
	// not needed on D3D
}



// ---------- immediate mode rendering

// we break very large immediate mode submissions into multiple batches internally
const int kMaxImmediateVerticesPerDraw = 8192;


ImmediateModeD3D11::ImmediateModeD3D11()
:	m_VB(NULL)
,	m_VBUsedBytes(0)
,	m_VBStartVertex(0)
{
}

ImmediateModeD3D11::~ImmediateModeD3D11()
{
	Assert (!m_VB);
}

void ImmediateModeD3D11::Cleanup()
{
	REGISTER_EXTERNAL_GFX_DEALLOCATION(m_VB);
	SAFE_RELEASE(m_VB);
	m_VBUsedBytes = 0;
}


void ImmediateModeD3D11::Invalidate()
{
	m_Vertices.clear();
	memset( &m_Current, 0, sizeof(m_Current) );
	m_HadColor = false;
}

void GfxDeviceD3D11::ImmediateVertex( float x, float y, float z )
{
	// If the current batch is becoming too large, internally end it and begin it again.
	size_t currentSize = m_Imm.m_Vertices.size();
	if( currentSize >= kMaxImmediateVerticesPerDraw - 4 )
	{
		GfxPrimitiveType mode = m_Imm.m_Mode;
		// For triangles, break batch when multiple of 3's is reached.
		if( mode == kPrimitiveTriangles && currentSize % 3 == 0 )
		{
			bool hadColor = m_Imm.m_HadColor;
			ImmediateEnd();
			ImmediateBegin( mode );
			m_Imm.m_HadColor = hadColor;
		}
		// For other primitives, break on multiple of 4's.
		// NOTE: This won't quite work for triangle strips, but we'll just pretend
		// that will never happen.
		else if( mode != kPrimitiveTriangles && currentSize % 4 == 0 )
		{
			bool hadColor = m_Imm.m_HadColor;
			ImmediateEnd();
			ImmediateBegin( mode );
			m_Imm.m_HadColor = hadColor;
		}
	}
	Vector3f& vert = m_Imm.m_Current.vertex;
	vert.x = x;
	vert.y = y;
	vert.z = z;
	m_Imm.m_Vertices.push_back( m_Imm.m_Current );
}

void GfxDeviceD3D11::ImmediateNormal( float x, float y, float z )
{
	m_Imm.m_Current.normal.x = x;
	m_Imm.m_Current.normal.y = y;
	m_Imm.m_Current.normal.z = z;
}

void GfxDeviceD3D11::ImmediateColor( float r, float g, float b, float a )
{
	m_Imm.m_Current.color.Set (ColorRGBAf(r,g,b,a));
	m_Imm.m_HadColor = true;
}

void GfxDeviceD3D11::ImmediateTexCoordAll( float x, float y, float z )
{
	for( int i = 0; i < 8; ++i )
	{
		Vector3f& uv = m_Imm.m_Current.texCoords[i];
		uv.x = x;
		uv.y = y;
		uv.z = z;
	}
}

void GfxDeviceD3D11::ImmediateTexCoord( int unit, float x, float y, float z )
{
	if( unit < 0 || unit >= 8 )
	{
		ErrorString( "Invalid unit for texcoord" );
		return;
	}
	Vector3f& uv = m_Imm.m_Current.texCoords[unit];
	uv.x = x;
	uv.y = y;
	uv.z = z;
}

void GfxDeviceD3D11::ImmediateBegin( GfxPrimitiveType type )
{
	m_Imm.m_Mode = type;
	m_Imm.m_Vertices.clear();
	m_Imm.m_HadColor = false;
}

bool GfxDeviceD3D11::ImmediateEndSetup()
{
	if( m_Imm.m_Vertices.empty() )
		return false;

	HRESULT hr = S_OK;
	ID3D11DeviceContext* ctx = GetD3D11Context();

	// vertex buffer
	const int kImmediateVBSize = kMaxImmediateVerticesPerDraw * sizeof(ImmediateVertexD3D11);
	if (!m_Imm.m_VB)
	{
		ID3D11Device* dev = GetD3D11Device();
		D3D11_BUFFER_DESC desc;
		desc.ByteWidth = kImmediateVBSize;
		desc.Usage = D3D11_USAGE_DYNAMIC;
		desc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
		desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
		desc.MiscFlags = 0;
		desc.StructureByteStride = 0;
		hr = dev->CreateBuffer (&desc, NULL, &m_Imm.m_VB);
		REGISTER_EXTERNAL_GFX_ALLOCATION_REF(m_Imm.m_VB,kImmediateVBSize,this);
		SetDebugNameD3D11 (m_Imm.m_VB, "VertexBufferImmediate");
		m_Imm.m_VBUsedBytes = 0;
		m_Imm.m_VBStartVertex = 0;
	}

	const ImmediateVertexD3D11* vb = &m_Imm.m_Vertices[0];
	const int vertexCount = m_Imm.m_Vertices.size();
	const int vertexDataSize = vertexCount * sizeof(vb[0]);
	D3D11_MAPPED_SUBRESOURCE mapped;

	if (m_Imm.m_VBUsedBytes + vertexDataSize > kImmediateVBSize)
	{
		D3D11_CALL_HR(ctx->Map (m_Imm.m_VB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped));
		m_Imm.m_VBUsedBytes = 0;
	}
	else
	{
		D3D11_CALL_HR(ctx->Map (m_Imm.m_VB, 0, D3D11_MAP_WRITE_NO_OVERWRITE, 0, &mapped));
	}
	m_Imm.m_VBStartVertex = m_Imm.m_VBUsedBytes / sizeof(vb[0]);

	memcpy ((UInt8*)mapped.pData + m_Imm.m_VBUsedBytes, vb, vertexDataSize);
	D3D11_CALL_HR(ctx->Unmap (m_Imm.m_VB, 0));
	m_Imm.m_VBUsedBytes += vertexDataSize;

	UINT strides = sizeof(vb[0]);
	UINT offsets = 0;
	D3D11_CALL (ctx->IASetVertexBuffers(0, 1, &m_Imm.m_VB, &strides, &offsets));


	m_FFState.useUniformInsteadOfVertexColor = !m_Imm.m_HadColor;
	if (!IsShaderActive(kShaderVertex))
	{
		UInt64 textureSources = m_FFState.texUnitSources;
		for (int i = 0; i < gGraphicsCaps.maxTexCoords; ++i)
		{
			UInt32 source = (textureSources >> (i*4)) & 0xF;
			// In immediate mode, each texcoord binds to it's own stage, unless we have texgen
			// on some of them.
			if (source <= kTexSourceUV7)
			{
				textureSources = textureSources & ~(0xFUL<<i*4) | (UInt64(kTexSourceUV0+i) << i*4);
			}
		}
		m_FFState.texUnitSources = textureSources;
	}

	BeforeDrawCall (true);
	return true;
}


void GfxDeviceD3D11::ImmediateEndDraw()
{
	ID3D11DeviceContext* ctx = GetD3D11Context();
	int vertexCount = m_Imm.m_Vertices.size();

	// vertex layout
	ID3D11InputLayout* inputLayout = m_VertexDecls.GetImmVertexDecl (g_CurrentVSInputD3D11);
	if (inputLayout)
	{
		SetInputLayoutD3D11 (ctx, inputLayout);
		if (SetTopologyD3D11 (m_Imm.m_Mode, *this, ctx))
		{

			// draw
			switch (m_Imm.m_Mode)
			{
			case kPrimitiveTriangles:
				D3D11_CALL(ctx->Draw (vertexCount, m_Imm.m_VBStartVertex));
				m_Stats.AddDrawCall (vertexCount / 3, vertexCount);
				break;
			case kPrimitiveTriangleStripDeprecated:
				D3D11_CALL(ctx->Draw (vertexCount, m_Imm.m_VBStartVertex));
				m_Stats.AddDrawCall (vertexCount - 2, vertexCount);
				break;
			case kPrimitiveQuads:
				GetDynamicVBO(); // ensure it's created
				D3D11_CALL(ctx->IASetIndexBuffer (m_DynamicVBO->GetQuadsIB(), DXGI_FORMAT_R16_UINT, 0));
				D3D11_CALL(ctx->DrawIndexed (vertexCount/4*6, 0, m_Imm.m_VBStartVertex));
				m_Stats.AddDrawCall( vertexCount / 4 * 2, vertexCount );
				break;
			case kPrimitiveLines:
				D3D11_CALL(ctx->Draw (vertexCount, m_Imm.m_VBStartVertex));
				m_Stats.AddDrawCall( vertexCount / 2, vertexCount );
				break;
			default:
				AssertString("ImmediateEnd: unknown draw mode");
			}
		}
	}

	// clear vertices
	m_Imm.m_Vertices.clear();
}


void GfxDeviceD3D11::ImmediateEnd()
{
	if (ImmediateEndSetup())
		ImmediateEndDraw();
}


typedef SmartComPointer<ID3D11RenderTargetView> RTVPointer;
typedef SmartComPointer<ID3D11Resource> ResourcePointer;
typedef SmartComPointer<ID3D11Texture2D> Texture2DPointer;


bool GfxDeviceD3D11::CaptureScreenshot( int left, int bottom, int width, int height, UInt8* rgba32 )
{
	DX11_LOG_ENTER_FUNCTION("CaptureScreenshot(%d, %d, %dx%d)", left, bottom, width, height);
	HRESULT hr;
	ID3D11DeviceContext* ctx = GetD3D11Context();

	SetupDeferredSRGBWrite ();

	RenderSurfaceHandle currColorSurface = GetActiveRenderColorSurfaceBBD3D11();
	RenderColorSurfaceD3D11* colorSurf = reinterpret_cast<RenderColorSurfaceD3D11*>(currColorSurface.object);
	if (!colorSurf)
		return false;

	RTVPointer rtView;
	ctx->OMGetRenderTargets (1, &rtView, NULL);
	if (!rtView)
		return false;

	ResourcePointer rtRes;
	rtView->GetResource (&rtRes);
	if (!rtRes)
		return false;

	D3D11_RESOURCE_DIMENSION rtType;
	rtRes->GetType (&rtType);
	if (rtType != D3D11_RESOURCE_DIMENSION_TEXTURE2D)
		return false;

	ID3D11Texture2D* rtTex = static_cast<ID3D11Texture2D*>((ID3D11Resource*)rtRes);
	D3D11_TEXTURE2D_DESC rtDesc;
	rtTex->GetDesc (&rtDesc);
	if (rtDesc.Format != DXGI_FORMAT_R8G8B8A8_UNORM &&
		rtDesc.Format != DXGI_FORMAT_R8G8B8A8_TYPELESS &&
		rtDesc.Format != DXGI_FORMAT_R8G8B8A8_UNORM_SRGB &&
		rtDesc.Format != DXGI_FORMAT_B8G8R8A8_UNORM)
		return false;

	ID3D11Device* dev = GetD3D11Device();
	ResolveTexturePool::Entry* resolved = NULL;
	if (rtDesc.SampleDesc.Count != 1)
	{
		resolved = m_Resolves.GetResolveTexture (rtDesc.Width, rtDesc.Height, colorSurf->format, m_SRGBWrite);
		if (!resolved)
			return false;

		ctx->ResolveSubresource (resolved->texture, 0, rtTex, 0, rtDesc.Format);
		rtTex = resolved->texture;
	}

	Texture2DPointer stagingTex;
	D3D11_TEXTURE2D_DESC stagingDesc;
	stagingDesc.Width = width;
	stagingDesc.Height = height;
	stagingDesc.MipLevels = 1;
	stagingDesc.ArraySize = 1;

	bool useRGBA = rtDesc.Format == DXGI_FORMAT_R8G8B8A8_UNORM ||
		rtDesc.Format == DXGI_FORMAT_R8G8B8A8_TYPELESS ||
		rtDesc.Format == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;

	stagingDesc.Format = useRGBA ? DXGI_FORMAT_R8G8B8A8_UNORM : DXGI_FORMAT_B8G8R8A8_UNORM;
	stagingDesc.SampleDesc.Count = 1;
	stagingDesc.SampleDesc.Quality = 0;
	stagingDesc.Usage = D3D11_USAGE_STAGING;
	stagingDesc.BindFlags = 0;
	stagingDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
	stagingDesc.MiscFlags = 0;
	hr = dev->CreateTexture2D (&stagingDesc, NULL, &stagingTex);
	if (FAILED(hr))
		return false;
	SetDebugNameD3D11 (stagingTex, Format("CaptureScreenshot-Texture2D-%dx%d", width, height));

	D3D11_BOX srcBox;
	srcBox.left = left;
	srcBox.right = left + width; 
#if UNITY_WP8
	/* In WP8 m_CurrTargetHeight seems not to match 
	*  ID3D11DeviceContext height */
	srcBox.top = bottom;
	srcBox.bottom = bottom + height;
#else
	srcBox.top = m_CurrTargetHeight - (bottom + height);
	srcBox.bottom = m_CurrTargetHeight - (bottom);
#endif
	srcBox.front = 0;
	srcBox.back = 1;
	ctx->CopySubresourceRegion (stagingTex, 0, 0, 0, 0, rtTex, 0, &srcBox);

	D3D11_MAPPED_SUBRESOURCE mapped;
	hr = ctx->Map (stagingTex, 0, D3D11_MAP_READ, 0, &mapped);
	if (FAILED(hr))
		return false;

	rgba32 += (height-1) * width * sizeof(UInt32);
	const UInt8* src = (const UInt8*)mapped.pData;
	for (int y = 0; y < height; ++y)
	{
		if (useRGBA)
		{
			memcpy (rgba32, src, width*4);
		}
		else
		{
			for (int x = 0; x < width*4; x +=4)
			{
				rgba32[x] = src[x + 2];
				rgba32[x + 1] = src[x + 1];
				rgba32[x + 2] = src[x + 0];
				rgba32[x + 3] = src[x + 3];
			}
		}

		rgba32 -= width * sizeof(UInt32);
		src += mapped.RowPitch;
	}


	ctx->Unmap (stagingTex, 0);
	return true;
}



bool GfxDeviceD3D11::ReadbackImage( ImageReference& image, int left, int bottom, int width, int height, int destX, int destY )
{
	Assert (image.GetFormat() == kTexFormatARGB32 || image.GetFormat() == kTexFormatRGB24);

	SetupDeferredSRGBWrite ();

	HRESULT hr;
	ID3D11DeviceContext* ctx = GetD3D11Context();

	RenderSurfaceHandle currColorSurface = GetActiveRenderColorSurfaceBBD3D11();
	RenderColorSurfaceD3D11* colorSurf = reinterpret_cast<RenderColorSurfaceD3D11*>(currColorSurface.object);
	if (!colorSurf)
		return false;

	RTVPointer rtView;
	ctx->OMGetRenderTargets (1, &rtView, NULL);
	if (!rtView)
		return false;

	ResourcePointer rtRes;
	rtView->GetResource (&rtRes);
	if (!rtRes)
		return false;

	D3D11_RESOURCE_DIMENSION rtType;
	rtRes->GetType (&rtType);
	if (rtType != D3D11_RESOURCE_DIMENSION_TEXTURE2D)
		return false;

	ID3D11Texture2D* rtTex = static_cast<ID3D11Texture2D*>((ID3D11Resource*)rtRes);
	D3D11_TEXTURE2D_DESC rtDesc;
	rtTex->GetDesc (&rtDesc);
	if (rtDesc.Format != DXGI_FORMAT_R8G8B8A8_UNORM && rtDesc.Format != DXGI_FORMAT_R8G8B8A8_TYPELESS && rtDesc.Format != DXGI_FORMAT_R8G8B8A8_UNORM_SRGB)
		return false;

	ID3D11Device* dev = GetD3D11Device();
	ResolveTexturePool::Entry* resolved = NULL;
	if (rtDesc.SampleDesc.Count != 1)
	{
		resolved = m_Resolves.GetResolveTexture (rtDesc.Width, rtDesc.Height, colorSurf->format, m_SRGBWrite);
		if (!resolved)
			return false;

		ctx->ResolveSubresource (resolved->texture, 0, rtTex, 0, rtDesc.Format);
		rtTex = resolved->texture;
	}

	Texture2DPointer stagingTex;
	D3D11_TEXTURE2D_DESC stagingDesc;
	stagingDesc.Width = width;
	stagingDesc.Height = height;
	stagingDesc.MipLevels = 1;
	stagingDesc.ArraySize = 1;
	stagingDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
	stagingDesc.SampleDesc.Count = 1;
	stagingDesc.SampleDesc.Quality = 0;
	stagingDesc.Usage = D3D11_USAGE_STAGING;
	stagingDesc.BindFlags = 0;
	stagingDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
	stagingDesc.MiscFlags = 0;
	hr = dev->CreateTexture2D (&stagingDesc, NULL, &stagingTex);
	if (FAILED(hr))
		return false;
	SetDebugNameD3D11 (stagingTex, Format("Readback-Texture2D-%dx%d", width, height));

	D3D11_BOX srcBox;
	srcBox.left = left;
	srcBox.right = left + width;
	srcBox.top = m_CurrTargetHeight - (bottom + height);
	srcBox.bottom = m_CurrTargetHeight - (bottom);
	srcBox.front = 0;
	srcBox.back = 1;
	ctx->CopySubresourceRegion (stagingTex, 0, 0, 0, 0, rtTex, 0, &srcBox);

	D3D11_MAPPED_SUBRESOURCE mapped;
	hr = ctx->Map (stagingTex, 0, D3D11_MAP_READ, 0, &mapped);
	if (FAILED(hr))
		return false;

	const UInt8* src = (const UInt8*)mapped.pData;

	if (image.GetFormat() == kTexFormatARGB32)
	{
		for (int y = height-1; y >= 0; --y)
		{
			const UInt32* srcPtr = (const UInt32*)src;
			UInt32* dstPtr = (UInt32*)(image.GetRowPtr(destY+y) + destX * 4);
			for (int x = 0; x < width; ++x)
			{
				UInt32 abgrCol = *srcPtr;
				UInt32 bgraCol = ((abgrCol & 0x00FFFFFF) << 8) | ((abgrCol&0xFF000000) >> 24);
				*dstPtr = bgraCol;
				++srcPtr;
				++dstPtr;
			}
			src += mapped.RowPitch;
		}
	}
	else if (image.GetFormat() == kTexFormatRGB24)
	{
		for (int y = height-1; y >= 0; --y)
		{
			const UInt32* srcPtr = (const UInt32*)src;
			UInt8* dstPtr = image.GetRowPtr(destY+y) + destX * 3;
			for (int x = 0; x < width; ++x)
			{
				UInt32 abgrCol = *srcPtr;
				dstPtr[0] = (abgrCol & 0x000000FF);
				dstPtr[1] = (abgrCol & 0x0000FF00) >> 8;
				dstPtr[2] = (abgrCol & 0x00FF0000) >> 16;
				++srcPtr;
				dstPtr += 3;
			}
			src += mapped.RowPitch;
		}
	}
	ctx->Unmap (stagingTex, 0);
	return true;
}

void GfxDeviceD3D11::GrabIntoRenderTexture(RenderSurfaceHandle rtHandle, RenderSurfaceHandle rd, int x, int y, int width, int height)
{
	DX11_LOG_ENTER_FUNCTION("GrabIntoRenderTexture(%p, %p, %d, %d, %dx%d)", rtHandle.object, rd.object, x, y, width, height);
	if (!rtHandle.IsValid())
		return;
	if (!g_D3D11CurrColorRT)
		return;
	RenderSurfaceHandle currColorSurface = GetActiveRenderColorSurfaceBBD3D11();
	RenderColorSurfaceD3D11* colorSurf = reinterpret_cast<RenderColorSurfaceD3D11*>(currColorSurface.object);
	if (!colorSurf)
		return;
	const bool sRGB = (gGraphicsCaps.d3d11.featureLevel >= kDX11Level10_0) ? (colorSurf->flags & kSurfaceCreateSRGB) : false;

	RenderColorSurfaceD3D11* renderTexture = reinterpret_cast<RenderColorSurfaceD3D11*>(rtHandle.object);
	TexturesD3D11::D3D11Texture* texturePointer = m_Textures.GetTexture (renderTexture->textureID);
	if (!texturePointer)
		return;

	SetupDeferredSRGBWrite ();

	ID3D11Resource* srcResource = g_D3D11CurrColorRT->m_Texture;
	ID3D11Texture2D* srcTex = static_cast<ID3D11Texture2D*>(srcResource);
	D3D11_TEXTURE2D_DESC rtDesc;
	srcTex->GetDesc (&rtDesc);
	Assert (rtDesc.Width == colorSurf->width && rtDesc.Height == colorSurf->height);

	ID3D11DeviceContext* ctx = GetD3D11Context();
	ResolveTexturePool::Entry* resolved = NULL;
	if (rtDesc.SampleDesc.Count != 1)
	{
		resolved = m_Resolves.GetResolveTexture (rtDesc.Width, rtDesc.Height, colorSurf->format, sRGB);
		if (!resolved)
			return;

		ctx->ResolveSubresource (resolved->texture, 0, srcResource, 0, GetRenderTextureFormat(colorSurf->format, sRGB));
		srcResource = resolved->texture;
	}

	ID3D11Texture2D* dstTex = static_cast<ID3D11Texture2D*>(texturePointer->m_Texture);
	D3D11_TEXTURE2D_DESC dstDesc;
	dstTex->GetDesc (&dstDesc);

	if (GetBPPFromDXGIFormat(rtDesc.Format) == GetBPPFromDXGIFormat(dstDesc.Format))
	{
		D3D11_BOX srcBox;
		srcBox.left = x;
		srcBox.right = x + width;
		srcBox.top = m_CurrTargetHeight - (y + height);
		srcBox.bottom = m_CurrTargetHeight - (y);
		srcBox.front = 0;
		srcBox.back = 1;

		ctx->CopySubresourceRegion (texturePointer->m_Texture, 0, 0, 0, 0, srcResource, 0, &srcBox);
	}
	else
	{
		// formats not compatible; have to draw a quad into destination, sampling the source texture
		RenderColorSurfaceD3D11* currRT = g_D3D11CurrColorRT;
		int oldTargetHeight = m_CurrTargetHeight;
		int oldView[4];
		GetViewport (oldView);
		bool oldScissor = IsScissorEnabled();
		int oldScissorRect[4];
		GetScissorRect (oldScissorRect);

		SetViewport (0, 0, dstDesc.Width, dstDesc.Height);
		DisableScissor ();

		RenderSurfaceHandle currColor = GetActiveRenderColorSurface(0);
		RenderSurfaceHandle currDepth = GetActiveRenderDepthSurface();
		SetRenderTargets (1, &rtHandle, rd, 0, kCubeFaceUnknown);

		const float u0 = x / float(rtDesc.Width);
		const float u1 = (x+width) / float(rtDesc.Width);
		const float v0 = (rtDesc.Height - y) / float(rtDesc.Height);
		const float v1 = (rtDesc.Height - (y+height)) / float(rtDesc.Height);

		ID3D11ShaderResourceView* srv = currRT ? currRT->m_SRView : NULL;
		if (resolved)
			srv = resolved->srv;

		DrawQuad (u0, v0, u1, v1, 0.0f, srv);
		SetRenderTargets (1, &currColor, currDepth, 0, kCubeFaceUnknown);
		SetViewport (oldView[0], oldView[1], oldView[2], oldView[3]);
		if (oldScissor)
			SetScissorRect (oldScissorRect[0], oldScissorRect[1], oldScissorRect[2], oldScissorRect[3]);
	}
}

void GfxDeviceD3D11::DrawQuad (float u0, float v0, float u1, float v1, float z, ID3D11ShaderResourceView* texture)
{
	// Can't use DeviceMVPMatricesState since that tries to get potentially threaded device.
	// We need to access our own device directly.
	Matrix4x4f	m_World, m_View, m_Proj;
	CopyMatrix(GetViewMatrix(), m_View.GetPtr());
	CopyMatrix(GetWorldMatrix(), m_World.GetPtr());
	CopyMatrix(GetProjectionMatrix(), m_Proj.GetPtr());

	// Can't use LoadFullScreenOrthoMatrix for the same reason.
	Matrix4x4f matrix;
	matrix.SetOrtho(0.0f, 1.0f, 0.0f, 1.0f, -1.0f, 100.0f);
	SetProjectionMatrix (matrix);
	SetViewMatrix (Matrix4x4f::identity.GetPtr()); // implicitly sets world to identity

	DisableFog ();

	SetFFLighting (false, false, kColorMatDisabled);
	DisableLights (0);

	ShaderLab::SubProgram* programs[kShaderTypeCount] = {0};
	GraphicsHelper::SetShaders (*this, programs, NULL);

	GfxBlendState blendDesc;
	DeviceBlendState* blendState = CreateBlendState(blendDesc);
	SetBlendState (blendState, 0.0f);

	GfxDepthState depthDesc; depthDesc.depthWrite = false; depthDesc.depthFunc = kFuncAlways;
	DeviceDepthState* depthState = CreateDepthState(depthDesc);
	SetDepthState (depthState);

	GfxRasterState rasterDesc; rasterDesc.cullMode = kCullOff;
	DeviceRasterState* rasterState = CreateRasterState(rasterDesc);
	SetRasterState (rasterState);

	ShaderLab::TextureBinding texEnv;
	texEnv.m_TextureName.index = kShaderTexEnvWhite | ShaderLab::FastPropertyName::kBuiltinTexEnvMask;
	TextureCombinersHandle combiners = CreateTextureCombiners (1, &texEnv, NULL, false, false);

	// Can't call SetTextureCombiners here since that expects to be called on main thread,
	// and we might be on the device thread here. So do the work manually and call
	// SetTextureCombinersThreadable.

	TexEnvData texEnvData;
	memset(&texEnvData, 0, sizeof(texEnvData));
	texEnvData.textureID = TextureID();
	texEnvData.texDim = kTexDim2D;
	texEnvData.texGen = kTexGenDisabled;
	texEnvData.identityMatrix = true;
	Vector4f texColors;
	texColors.Set(1,1,1,1);
	SetTextureCombinersThreadable (combiners, &texEnvData, &texColors);

	ImmediateBegin (kPrimitiveQuads);
	ImmediateTexCoord(0,u0,v0,0.0f); ImmediateVertex (0.0f, 0.0f, z);
	ImmediateTexCoord(0,u0,v1,0.0f); ImmediateVertex (0.0f, 1.0f, z);
	ImmediateTexCoord(0,u1,v1,0.0f); ImmediateVertex (1.0f, 1.0f, z);
	ImmediateTexCoord(0,u1,v0,0.0f); ImmediateVertex (1.0f, 0.0f, z);
	if (ImmediateEndSetup ())
	{
		ID3D11SamplerState* sampler = m_Textures.GetSampler (kSamplerPointClamp);
		Assert (sampler);
		ID3D11DeviceContext* ctx = GetD3D11Context();
		ctx->PSSetShaderResources (0, 1, &texture);
		ctx->PSSetSamplers (0, 1, &sampler);
		m_Textures.InvalidateSampler (kShaderFragment, 0);
		m_ActiveTextures[kShaderFragment][0].m_ID = -1;
		m_ActiveSamplers[kShaderFragment][0].m_ID = -1;

		ImmediateEndDraw ();

		ID3D11ShaderResourceView* nullTex = NULL;
		ctx->PSSetShaderResources (0, 1, &nullTex);
	}

	// restore matrices
	SetViewMatrix(m_View.GetPtr());
	SetWorldMatrix(m_World.GetPtr());
	SetProjectionMatrix(m_Proj);
}

void* GfxDeviceD3D11::GetNativeGfxDevice()
{
	return GetD3D11Device();
}

void* GfxDeviceD3D11::GetNativeTexturePointer(TextureID id)
{
	TexturesD3D11::D3D11Texture* tex = m_Textures.GetTexture(id);
	if (!tex)
		return NULL;
	return tex->m_Texture;
}

intptr_t GfxDeviceD3D11::CreateExternalTextureFromNative(intptr_t nativeTex)
{
	return m_Textures.RegisterNativeTexture((ID3D11ShaderResourceView*)nativeTex);
}

void GfxDeviceD3D11::UpdateExternalTextureFromNative(TextureID tex, intptr_t nativeTex)
{
	m_Textures.UpdateNativeTexture(tex, (ID3D11ShaderResourceView*)nativeTex);
}


#if ENABLE_PROFILER

void GfxDeviceD3D11::BeginProfileEvent (const char* name)
{
	if (g_D3D11BeginEventFunc)
	{
		wchar_t wideName[100];
		UTF8ToWide (name, wideName, 100);
		g_D3D11BeginEventFunc (0, wideName);
	}
}

void GfxDeviceD3D11::EndProfileEvent ()
{
	if (g_D3D11EndEventFunc)
	{
		g_D3D11EndEventFunc ();
	}
}

GfxTimerQuery* GfxDeviceD3D11::CreateTimerQuery()
{
	Assert(gGraphicsCaps.hasTimerQuery);
	return g_TimerQueriesD3D11.CreateTimerQuery();
}

void GfxDeviceD3D11::DeleteTimerQuery(GfxTimerQuery* query)
{
	delete query;
}

void GfxDeviceD3D11::BeginTimerQueries()
{
	if(!gGraphicsCaps.hasTimerQuery)
		return;

	g_TimerQueriesD3D11.BeginTimerQueries();
	}

void GfxDeviceD3D11::EndTimerQueries()
{
	if(!gGraphicsCaps.hasTimerQuery)
		return;

	g_TimerQueriesD3D11.EndTimerQueries();
}

#endif // ENABLE_PROFILER


// -------- editor only functions

#if UNITY_EDITOR

void GfxDeviceD3D11::SetAntiAliasFlag (bool aa)
{
}


void GfxDeviceD3D11::DrawUserPrimitives (GfxPrimitiveType type, int vertexCount, UInt32 vertexChannels, const void* data, int stride)
{
	if (vertexCount == 0)
		return;

	Assert(vertexCount <= 60000); // TODO: handle this by multi-batching

	Assert(data && vertexCount >= 0 && vertexChannels != 0);

	DynamicD3D11VBO& vbo = static_cast<DynamicD3D11VBO&>(GetDynamicVBO());

	void* vbPtr;
	//@TODO: hack to pass kDrawTriangleStrip, but we only need that to determine if we need index buffer or not (we don't)
	if (!vbo.GetChunk(vertexChannels, vertexCount, 0, DynamicVBO::kDrawTriangleStrip, &vbPtr, NULL))
		return;
	memcpy (vbPtr, data, vertexCount * stride);
	vbo.ReleaseChunk (vertexCount, 0);

	vbo.DrawChunkUserPrimitives (type);
}

int GfxDeviceD3D11::GetCurrentTargetAA() const
{
	return 0; //@TODO
}

GfxDeviceWindow* GfxDeviceD3D11::CreateGfxWindow (HWND window, int width, int height, DepthBufferFormat depthFormat, int antiAlias)
{
	return new D3D11Window(window, width, height, depthFormat, antiAlias);
}

static ID3D11Texture2D* FindD3D11TextureByID (TextureID tid)
{
	GfxDevice& device = GetRealGfxDevice();
	if (device.GetRenderer() != kGfxRendererD3D11)
		return NULL;
	GfxDeviceD3D11& dev = static_cast<GfxDeviceD3D11&>(device);
	TexturesD3D11::D3D11Texture* basetex = dev.GetTextures().GetTexture(tid);
	if (!basetex || !basetex->m_Texture)
		return NULL;
	D3D11_RESOURCE_DIMENSION dim = D3D11_RESOURCE_DIMENSION_UNKNOWN;
	basetex->m_Texture->GetType(&dim);
	if (dim != D3D11_RESOURCE_DIMENSION_TEXTURE2D)
		return NULL;
	return static_cast<ID3D11Texture2D*>(basetex->m_Texture);
}

HDC AcquireHDCForTextureD3D11 (TextureID tid, int& outWidth, int& outHeight)
{
	ID3D11Texture2D* tex = FindD3D11TextureByID (tid);
	if (!tex)
		return NULL;

	D3D11_TEXTURE2D_DESC desc;
	tex->GetDesc (&desc);
	outWidth = desc.Width;
	outHeight = desc.Height;

	IDXGISurface1* dxgiSurface = NULL;
	tex->QueryInterface(__uuidof(IDXGISurface1), (void**)(&dxgiSurface));
	HDC dc = NULL;
	if (dxgiSurface)
	{
		dxgiSurface->GetDC (false, &dc);
		dxgiSurface->Release();
	}
	return dc;
}

void ReleaseHDCForTextureD3D11 (TextureID tid, HDC dc)
{
	ID3D11Texture2D* tex = FindD3D11TextureByID (tid);
	if (!tex)
		return;

	IDXGISurface1* dxgiSurface = NULL;
	tex->QueryInterface(__uuidof(IDXGISurface1), (void**)(&dxgiSurface));
	if (dxgiSurface)
	{
		dxgiSurface->ReleaseDC(NULL);
		dxgiSurface->Release();
	}
}

#endif // UNITY_EDITOR


int GfxDeviceD3D11::GetCurrentTargetWidth() const
{
	return m_CurrTargetWidth;
}

int GfxDeviceD3D11::GetCurrentTargetHeight() const
{
	return m_CurrTargetHeight;
}

void GfxDeviceD3D11::SetCurrentTargetSize(int width, int height)
{
	m_CurrTargetWidth = width;
	m_CurrTargetHeight = height;
}

void GfxDeviceD3D11::SetCurrentWindowSize(int width, int height)
{
	m_CurrWindowWidth = m_CurrTargetWidth = width;
	m_CurrWindowHeight = m_CurrTargetHeight = height;
}


// ----------------------------------------------------------------------

void GfxDeviceD3D11::SetComputeBuffer11 (ShaderType shaderType, int unit, ComputeBufferID bufferHandle)
{
	ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(bufferHandle);
	ID3D11ShaderResourceView* srv = buffer ? buffer->srv : NULL;
	ID3D11DeviceContext* ctx = GetD3D11Context();
	switch (shaderType) {
	case kShaderVertex:   ctx->VSSetShaderResources (unit, 1, &srv); break;
	case kShaderFragment: ctx->PSSetShaderResources (unit, 1, &srv); break;
	case kShaderGeometry: ctx->GSSetShaderResources (unit, 1, &srv); break;
	case kShaderHull:     ctx->HSSetShaderResources (unit, 1, &srv); break;
	case kShaderDomain:   ctx->DSSetShaderResources (unit, 1, &srv); break;
	default: AssertString("unknown shader type");
	}
	m_ActiveTextures[shaderType][unit].m_ID = 0;
}


void GfxDeviceD3D11::SetComputeBufferData (ComputeBufferID bufferHandle, const void* data, size_t size)
{
	if (!data || !size)
		return;
	ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(bufferHandle);
	if (!buffer || !buffer->buffer)
		return;

	ID3D11DeviceContext* ctx = GetD3D11Context();
	D3D11_BOX box;
	box.left = 0;
	box.top = 0;
	box.front = 0;
	box.right = size;
	box.bottom = 1;
	box.back = 1;
	ctx->UpdateSubresource (buffer->buffer, 0, &box, data, 0, 0);
}


void GfxDeviceD3D11::GetComputeBufferData (ComputeBufferID bufferHandle, void* dest, size_t destSize)
{
	if (!dest || !destSize)
		return;
	ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(bufferHandle);
	if (!buffer || !buffer->buffer)
		return;

	ID3D11DeviceContext* ctx = GetD3D11Context();

	ID3D11Buffer* cpuBuffer = NULL;
	D3D11_BUFFER_DESC desc;
	ZeroMemory (&desc, sizeof(desc));
	buffer->buffer->GetDesc (&desc);
	desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
	desc.Usage = D3D11_USAGE_STAGING;
	desc.BindFlags = 0;
	desc.MiscFlags = 0;
	HRESULT hr = GetD3D11Device()->CreateBuffer(&desc, NULL, &cpuBuffer);
	if (FAILED(hr))
		return;
	SetDebugNameD3D11 (cpuBuffer, Format("CSGetData-Staging-%d", desc.ByteWidth));

	ctx->CopyResource (cpuBuffer, buffer->buffer);

	D3D11_MAPPED_SUBRESOURCE mapped;
	hr = ctx->Map (cpuBuffer, 0, D3D11_MAP_READ, 0, &mapped);
	if (SUCCEEDED(hr))
	{
		memcpy (dest, mapped.pData, destSize);
		ctx->Unmap (cpuBuffer, 0);
	}
	SAFE_RELEASE (cpuBuffer);
}



void GfxDeviceD3D11::CopyComputeBufferCount (ComputeBufferID srcBuffer, ComputeBufferID dstBuffer, UInt32 dstOffset)
{
	ComputeBuffer11* src = m_Textures.GetComputeBuffer(srcBuffer);
	if (!src || !src->uav)
		return;
	ComputeBuffer11* dst = m_Textures.GetComputeBuffer(dstBuffer);
	if (!dst || !dst->buffer)
		return;
	ID3D11DeviceContext* ctx = GetD3D11Context();
	ctx->CopyStructureCount (dst->buffer, dstOffset, src->uav);
}



void GfxDeviceD3D11::SetRandomWriteTargetTexture (int index, TextureID tid)
{
	void SetRandomWriteTargetTextureD3D11 (int index, TextureID tid);
	SetRandomWriteTargetTextureD3D11 (index, tid);
}

void GfxDeviceD3D11::SetRandomWriteTargetBuffer (int index, ComputeBufferID bufferHandle)
{
	void SetRandomWriteTargetBufferD3D11 (int index, ComputeBufferID bufferHandle);
	SetRandomWriteTargetBufferD3D11 (index, bufferHandle);
}

void GfxDeviceD3D11::ClearRandomWriteTargets ()
{
	void ClearRandomWriteTargetsD3D11 (TexturesD3D11* textures);
	ClearRandomWriteTargetsD3D11 (&m_Textures);
}


ComputeProgramHandle GfxDeviceD3D11::CreateComputeProgram (const UInt8* code, size_t codeSize)
{
	ComputeProgramHandle cpHandle;
	if (gGraphicsCaps.d3d11.featureLevel < kDX11Level11_0)
		return cpHandle;

	ID3D11Device* dev = GetD3D11Device();
	HRESULT hr;
	ID3D11ComputeShader* cs = NULL;
	hr = dev->CreateComputeShader (code, codeSize, NULL, &cs);
	if (FAILED(hr))
		return cpHandle;
	SetDebugNameD3D11 (cs, Format("ComputeShader-%d", (int)codeSize));

	cpHandle.object = cs;
	return cpHandle;
}

void GfxDeviceD3D11::DestroyComputeProgram (ComputeProgramHandle& cpHandle)
{
	if (!cpHandle.IsValid())
		return;

	ID3D11ComputeShader* cs = reinterpret_cast<ID3D11ComputeShader*>(cpHandle.object);
	SAFE_RELEASE(cs);
	cpHandle.Reset();
}

void GfxDeviceD3D11::CreateComputeConstantBuffers (unsigned count, const UInt32* sizes, ConstantBufferHandle* outCBs)
{
	ID3D11Device* dev = GetD3D11Device();
	HRESULT hr;

	D3D11_BUFFER_DESC desc;
	desc.Usage = D3D11_USAGE_DYNAMIC;
	desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
	desc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
	desc.MiscFlags = 0;
	desc.StructureByteStride = 0;
	for (unsigned i = 0; i < count; ++i)
	{
		desc.ByteWidth = sizes[i];
		ID3D11Buffer* cb = NULL;
		hr = dev->CreateBuffer (&desc, NULL, &cb);
		if (cb)
			REGISTER_EXTERNAL_GFX_ALLOCATION_REF(cb,sizes[i],this);
		Assert (SUCCEEDED(hr));
		outCBs[i].object = cb;

		SetDebugNameD3D11 (cb, Format("CSConstantBuffer-%d-%d", i, sizes[i]));
	}
}

void GfxDeviceD3D11::DestroyComputeConstantBuffers (unsigned count, ConstantBufferHandle* cbs)
{
	for (unsigned i = 0; i < count; ++i)
	{
		ID3D11Buffer* cb = reinterpret_cast<ID3D11Buffer*>(cbs[i].object);
		REGISTER_EXTERNAL_GFX_DEALLOCATION(cb);
		SAFE_RELEASE(cb);
		cbs[i].Reset();
	}
}


void GfxDeviceD3D11::CreateComputeBuffer (ComputeBufferID id, size_t count, size_t stride, UInt32 flags)
{
	ComputeBuffer11 buffer;
	buffer.buffer = NULL;
	buffer.srv = NULL;
	buffer.uav = NULL;
	if (gGraphicsCaps.d3d11.featureLevel < kDX11Level10_0)
		return;

	ID3D11Device* dev = GetD3D11Device();
	HRESULT hr;

	// buffer
	D3D11_BUFFER_DESC bufferDesc;
	memset (&bufferDesc, 0, sizeof(bufferDesc));
	bufferDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
	if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level11_0)
		bufferDesc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS;
	bufferDesc.ByteWidth = count * stride;
	if (flags & kCBFlagDrawIndirect)
		bufferDesc.MiscFlags = (gGraphicsCaps.d3d11.featureLevel >= kDX11Level11_0 ? D3D11_RESOURCE_MISC_DRAWINDIRECT_ARGS : 0);
	else if (flags & kCBFlagRaw)
		bufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_ALLOW_RAW_VIEWS;
	else
		bufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
	bufferDesc.StructureByteStride = stride;
	bufferDesc.Usage = D3D11_USAGE_DEFAULT;
	hr = dev->CreateBuffer (&bufferDesc, NULL, &buffer.buffer);
	if (buffer.buffer)
		REGISTER_EXTERNAL_GFX_ALLOCATION_REF(buffer.buffer,count * stride,this);
	Assert (SUCCEEDED(hr));
	SetDebugNameD3D11 (buffer.buffer, Format("ComputeBuffer-%dx%d", (int)count, (int)stride));

	// unordered access view, only on DX11+ HW
	if (gGraphicsCaps.d3d11.featureLevel >= kDX11Level11_0 && !(flags & kCBFlagDrawIndirect))
	{
		D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc; 
		memset (&uavDesc, 0, sizeof(uavDesc));
		uavDesc.Format = (flags & kCBFlagRaw) ? DXGI_FORMAT_R32_TYPELESS : DXGI_FORMAT_UNKNOWN;
		uavDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
		uavDesc.Buffer.FirstElement = 0;
		uavDesc.Buffer.NumElements = count;
		uavDesc.Buffer.Flags = flags & kCBFlagTypeMask;
		hr = dev->CreateUnorderedAccessView (buffer.buffer, &uavDesc, &buffer.uav);
		Assert (SUCCEEDED(hr));
		SetDebugNameD3D11 (buffer.uav, Format("ComputeBuffer-UAV-%dx%d", (int)count, (int)stride));

		// shader resource view
		D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
		memset (&srvDesc, 0, sizeof(srvDesc));
		if (flags & kCBFlagRaw)
		{
			srvDesc.Format = DXGI_FORMAT_R32_TYPELESS;
			srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFEREX;
			srvDesc.BufferEx.FirstElement = 0;
			srvDesc.BufferEx.NumElements = count;
			srvDesc.BufferEx.Flags = D3D11_BUFFEREX_SRV_FLAG_RAW;
		}
		else
		{
			srvDesc.Format = DXGI_FORMAT_UNKNOWN;
			srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
			srvDesc.Buffer.FirstElement = 0;
			srvDesc.Buffer.NumElements = count;
		}
		hr = dev->CreateShaderResourceView (buffer.buffer, &srvDesc, &buffer.srv);
		Assert (SUCCEEDED(hr));
		SetDebugNameD3D11 (buffer.uav, Format("ComputeBuffer-SRV-%dx%d", (int)count, (int)stride));
	}

	m_Textures.AddComputeBuffer (id, buffer);
}


void GfxDeviceD3D11::DestroyComputeBuffer (ComputeBufferID handle)
{
	if (!handle.IsValid())
		return;

	ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(handle);
	if (buffer)
	{
		REGISTER_EXTERNAL_GFX_DEALLOCATION(buffer->buffer);
		SAFE_RELEASE(buffer->buffer);
		SAFE_RELEASE(buffer->srv);
		SAFE_RELEASE(buffer->uav);
	}
	m_Textures.RemoveComputeBuffer (handle);
}


void GfxDeviceD3D11::UpdateComputeConstantBuffers (unsigned count, ConstantBufferHandle* cbs,  UInt32 cbDirty, size_t dataSize, const UInt8* data, const UInt32* cbSizes, const UInt32* cbOffsets, const int* bindPoints)
{
	ID3D11DeviceContext* ctx = GetD3D11Context();

	// go over constant buffers in use
	for (unsigned i = 0; i < count; ++i)
	{
		if (bindPoints[i] < 0)
			continue; // CB not going to be used, no point in updating it

		ID3D11Buffer* cb = reinterpret_cast<ID3D11Buffer*>(cbs[i].object);

		// update buffer if dirty
		UInt32 dirtyMask = (1<<i);
		if (cbDirty & dirtyMask)
		{
			D3D11_MAPPED_SUBRESOURCE mapped;
			HRESULT hr;
			hr = ctx->Map (cb, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
			Assert (SUCCEEDED(hr));
			memcpy (mapped.pData, data + cbOffsets[i], cbSizes[i]);
			ctx->Unmap (cb, 0);
		}

		// bind it
		ctx->CSSetConstantBuffers (bindPoints[i], 1, &cb);
	}
}



void GfxDeviceD3D11::UpdateComputeResources (
	unsigned texCount, const TextureID* textures, const int* texBindPoints,
	unsigned samplerCount, const unsigned* samplers,
	unsigned inBufferCount, const ComputeBufferID* inBuffers, const int* inBufferBindPoints,
	unsigned outBufferCount, const ComputeBufferID* outBuffers, const TextureID* outTextures, const UInt32* outBufferBindPoints)
{
	ID3D11DeviceContext* ctx = GetD3D11Context();

	for (unsigned i = 0; i < texCount; ++i)
	{
		if (textures[i].m_ID == 0)
			continue;
		TexturesD3D11::D3D11Texture* tex = m_Textures.GetTexture (textures[i]);
		if (!tex)
			continue;

		// if texture is bound as render target: unbind it (set backbuffer as RT)
		if ((g_D3D11CurrColorRT && g_D3D11CurrColorRT->m_Texture == tex->m_Texture) ||
			(g_D3D11CurrDepthRT && g_D3D11CurrDepthRT->m_Texture == tex->m_Texture))
		{
			RenderSurfaceHandle defaultColor = GetBackBufferColorSurface();
			RenderSurfaceHandle defaultDepth = GetBackBufferDepthSurface();
			SetRenderTargets (1, &defaultColor, defaultDepth, 0, kCubeFaceUnknown);
		}
		ctx->CSSetShaderResources (texBindPoints[i] & 0xFFFF, 1, &tex->m_SRV);
		unsigned samplerBindPoint = (texBindPoints[i] >> 16) & 0xFFFF;
		if (samplerBindPoint != 0xFFFF)
		{
			ID3D11SamplerState* smp = m_Textures.GetSampler(tex->m_Sampler);
			ctx->CSSetSamplers (samplerBindPoint, 1, &smp);
		}
	}

	for (unsigned i = 0; i < samplerCount; ++i)
	{
		BuiltinSamplerState type = (BuiltinSamplerState)((samplers[i] & 0xFFFF0000) >> 16);
		unsigned bindPoint = samplers[i] & 0xFFFF;
		ID3D11SamplerState* smp = m_Textures.GetSampler (type);
		Assert (smp);
		ctx->CSSetSamplers (bindPoint, 1, &smp);
	}

	for (unsigned i = 0; i < inBufferCount; ++i)
	{
		ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(inBuffers[i]);
		if (!buffer)
			continue;
		ctx->CSSetShaderResources (inBufferBindPoints[i], 1, &buffer->srv);
	}

	for (unsigned i = 0; i < outBufferCount; ++i)
	{
		ID3D11UnorderedAccessView* uav = NULL;
		if (outBufferBindPoints[i] & 0x80000000)
		{
			// UAV comes from texture
			if (outTextures[i].m_ID == 0)
				continue;
			TexturesD3D11::D3D11Texture* tex = m_Textures.GetTexture (outTextures[i]);
			if (!tex || !tex->m_UAV)
				continue;
			uav = tex->m_UAV;
		}
		else
		{
			// UAV is raw buffer
			if (!outBuffers[i].IsValid())
				continue;
			ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(outBuffers[i]);
			if (!buffer)
				continue;
			uav = buffer->uav;
		}
		UINT uavInitialCounts[] = { -1 }; // keeps current offsets for Appendable/Consumeable UAVs
		ctx->CSSetUnorderedAccessViews (outBufferBindPoints[i] & 0x7FFFFFFF, 1, &uav, uavInitialCounts);
	}
}



void GfxDeviceD3D11::DispatchComputeProgram (ComputeProgramHandle cpHandle, unsigned threadsX, unsigned threadsY, unsigned threadsZ)
{
	if (!cpHandle.IsValid())
		return;

	ID3D11DeviceContext* ctx = GetD3D11Context();
	ID3D11ComputeShader* cs = reinterpret_cast<ID3D11ComputeShader*>(cpHandle.object);
	ctx->CSSetShader (cs, NULL, 0);
	ctx->Dispatch (threadsX, threadsY, threadsZ);


	// DEBUG: readback output UAV contents
	#if 0 && !UNITY_RELEASE
	ID3D11UnorderedAccessView* uav;
	ctx->CSGetUnorderedAccessViews (0, 1, &uav);
	ID3D11Buffer* res;
	uav->GetResource ((ID3D11Resource**)&res);

	ID3D11Buffer* debugbuf = NULL;
	D3D11_BUFFER_DESC desc;
	ZeroMemory (&desc, sizeof(desc));
	res->GetDesc (&desc);
	desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
	desc.Usage = D3D11_USAGE_STAGING;
	desc.BindFlags = 0;
	desc.MiscFlags = 0;
	GetD3D11Device()->CreateBuffer(&desc, NULL, &debugbuf);
	ctx->CopyResource (debugbuf, res);

	D3D11_MAPPED_SUBRESOURCE mapped;
	ctx->Map(debugbuf, 0, D3D11_MAP_READ, 0, &mapped);
	ctx->Unmap(debugbuf, 0);
	SAFE_RELEASE(debugbuf);
	#endif

	ID3D11UnorderedAccessView* nullUAVs[8] = {0};
	ctx->CSSetUnorderedAccessViews (0, 8, nullUAVs, NULL);
}


// ----------------------------------------------------------------------


void GfxDeviceD3D11::DrawNullGeometry (GfxPrimitiveType topology, int vertexCount, int instanceCount)
{
	ID3D11DeviceContext* ctx = GetD3D11Context();
	UINT strides = 0;
	UINT offsets = 0;
	ID3D11Buffer* vb = NULL;
	D3D11_CALL (ctx->IASetVertexBuffers(0, 1, &vb, &strides, &offsets));

	BeforeDrawCall (false);

	// vertex layout
	SetInputLayoutD3D11 (ctx, NULL);

	// draw
	if (!SetTopologyD3D11 (topology, *this, ctx))
		return;
	if (instanceCount > 1)
	{
		D3D11_CALL (ctx->DrawInstanced (vertexCount, instanceCount, 0, 0));
	}
	else
	{
		D3D11_CALL (ctx->Draw (vertexCount, 0));
	}
}

void GfxDeviceD3D11::DrawNullGeometryIndirect (GfxPrimitiveType topology, ComputeBufferID bufferHandle, UInt32 bufferOffset)
{
	if (gGraphicsCaps.d3d11.featureLevel < kDX11Level11_0)
		return;

	ID3D11DeviceContext* ctx = GetD3D11Context();
	UINT strides = 0;
	UINT offsets = 0;
	ID3D11Buffer* vb = NULL;
	D3D11_CALL (ctx->IASetVertexBuffers(0, 1, &vb, &strides, &offsets));

	BeforeDrawCall (false);

	// vertex layout
	SetInputLayoutD3D11 (ctx, NULL);

	// draw
	if (!SetTopologyD3D11 (topology, *this, ctx))
		return;
	ComputeBuffer11* buffer = m_Textures.GetComputeBuffer(bufferHandle);
	if (!buffer || !buffer->buffer)
		return;
	D3D11_CALL (ctx->DrawInstancedIndirect (buffer->buffer, bufferOffset));
}


// GPU skinning functionality
GPUSkinningInfo * GfxDeviceD3D11::CreateGPUSkinningInfo()
{
	// stream-out requires at least DX10.0
	if (gGraphicsCaps.d3d11.featureLevel < kDX11Level10_0)
		return NULL;

	return new StreamOutSkinningInfo();
}

void	GfxDeviceD3D11::DeleteGPUSkinningInfo(GPUSkinningInfo *info)
{
	delete reinterpret_cast<StreamOutSkinningInfo *>(info);
}

// All actual functionality is performed in StreamOutSkinningInfo, just forward the calls
void GfxDeviceD3D11::SkinOnGPU( GPUSkinningInfo * info, bool lastThisFrame )
{
	reinterpret_cast<StreamOutSkinningInfo *>(info)->SkinMesh(lastThisFrame);
}

void GfxDeviceD3D11::UpdateSkinSourceData(GPUSkinningInfo *info, const void *vertData, const BoneInfluence *skinData, bool dirty)
{
	reinterpret_cast<StreamOutSkinningInfo *>(info)->UpdateSourceData(vertData, skinData, dirty);
}

void GfxDeviceD3D11::UpdateSkinBonePoses(GPUSkinningInfo *info, const int boneCount, const Matrix4x4f* poses)
{
	reinterpret_cast<StreamOutSkinningInfo *>(info)->UpdateSourceBones(boneCount, poses);
}


// ----------------------------------------------------------------------
//  verification of state

#if GFX_DEVICE_VERIFY_ENABLE


void GfxDeviceD3D11::VerifyState()
{
}
#endif // GFX_DEVICE_VERIFY_ENABLE