Handle live resource not being there even if it shouldn't be missing

* I was a little conflicted about this, as the resources present in logs
  should be determinable - if a function marks it as referenced then the
  serialised version of that function should expect the resource to be
  present, and if it's not then there's a bug and we can't properly replay.
* However I am tempted to say that instead of likely crashing due to an
  invalid NULL pointer suddenly appearing somewhere, we should instead try
  to continue even if a resource isn't available.

renderdoc/core/resource_manager.h

@@ -1110,8 +1110,11 @@ ResourceType ResourceManager<ResourceType, RecordType>::GetLiveResource(Resource
 
 	if(m_InframeResourceMap.find(origid) != m_InframeResourceMap.end())
 		return m_InframeResourceMap[origid];
+	
+	if(m_LiveResourceMap.find(origid) != m_LiveResourceMap.end())
+		return m_LiveResourceMap[origid];
 
-	return m_LiveResourceMap[origid];
+	return (ResourceType)RecordType::NullResource;
 }
 
 template<typename ResourceType, typename RecordType>

renderdoc/driver/d3d11/d3d11_context1_wrap.cpp

@@ -295,7 +295,9 @@ bool WrappedID3D11DeviceContext::Serialise_CopySubresourceRegion1(ID3D11Resource
 	SERIALISE_ELEMENT_OPT(D3D11_BOX, SourceBox, *pSrcBox, HasSourceBox);
 	SERIALISE_ELEMENT(UINT, flags, CopyFlags);
 
-	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(Destination))
+	if(m_State <= EXECUTING &&
+		 m_pDevice->GetResourceManager()->HasLiveResource(Destination) &&
+		 m_pDevice->GetResourceManager()->HasLiveResource(Source))
 	{
 		D3D11_BOX *box = &SourceBox;
 		if(!HasSourceBox)
@@ -367,7 +369,7 @@ bool WrappedID3D11DeviceContext::Serialise_ClearView(ID3D11View *pView, const FL
 	SERIALISE_ELEMENT(uint32_t, numRects, NumRects);
 	SERIALISE_ELEMENT_ARR(D3D11_RECT, rects, pRect, NumRects);
 
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(View))
 	{
 		ID3D11View *wrapped = (ID3D11View *)m_pDevice->GetResourceManager()->GetLiveResource(View);
 
@@ -513,7 +515,10 @@ bool WrappedID3D11DeviceContext::Serialise_VSSetConstantBuffers1(UINT StartSlot_
 		
 		if(m_State <= EXECUTING)
 		{
-			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+			if(m_pDevice->GetResourceManager()->HasLiveResource(id))
+				Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+			else
+				Buffers[i] = NULL;
 			Offsets[i] = offs;
 			Counts[i] = count;
 		}
@@ -613,7 +618,10 @@ bool WrappedID3D11DeviceContext::Serialise_HSSetConstantBuffers1(UINT StartSlot_
 		
 		if(m_State <= EXECUTING)
 		{
-			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+			if(m_pDevice->GetResourceManager()->HasLiveResource(id))
+				Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+			else
+				Buffers[i] = NULL;
 			Offsets[i] = offs;
 			Counts[i] = count;
 		}
@@ -714,7 +722,10 @@ bool WrappedID3D11DeviceContext::Serialise_DSSetConstantBuffers1(UINT StartSlot_
 		
 		if(m_State <= EXECUTING)
 		{
-			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+			if(m_pDevice->GetResourceManager()->HasLiveResource(id))
+				Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+			else
+				Buffers[i] = NULL;
 			Offsets[i] = offs;
 			Counts[i] = count;
 		}
@@ -815,7 +826,10 @@ bool WrappedID3D11DeviceContext::Serialise_GSSetConstantBuffers1(UINT StartSlot_
 		
 		if(m_State <= EXECUTING)
 		{
-			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+			if(m_pDevice->GetResourceManager()->HasLiveResource(id))
+				Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+			else
+				Buffers[i] = NULL;
 			Offsets[i] = offs;
 			Counts[i] = count;
 		}
@@ -916,7 +930,10 @@ bool WrappedID3D11DeviceContext::Serialise_PSSetConstantBuffers1(UINT StartSlot_
 		
 		if(m_State <= EXECUTING)
 		{
-			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+			if(m_pDevice->GetResourceManager()->HasLiveResource(id))
+				Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+			else
+				Buffers[i] = NULL;
 			Offsets[i] = offs;
 			Counts[i] = count;
 		}
@@ -1017,7 +1034,10 @@ bool WrappedID3D11DeviceContext::Serialise_CSSetConstantBuffers1(UINT StartSlot_
 		
 		if(m_State <= EXECUTING)
 		{
-			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+			if(m_pDevice->GetResourceManager()->HasLiveResource(id))
+				Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+			else
+				Buffers[i] = NULL;
 			Offsets[i] = offs;
 			Counts[i] = count;
 		}

renderdoc/driver/d3d11/d3d11_context_wrap.cpp

@@ -318,7 +318,7 @@ bool WrappedID3D11DeviceContext::Serialise_IASetInputLayout(ID3D11InputLayout *p
 {
 	SERIALISE_ELEMENT(ResourceId, InputLayout, GetIDForResource(pInputLayout));
 
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(InputLayout))
 	{
 		pInputLayout = (ID3D11InputLayout *)m_pDevice->GetResourceManager()->GetLiveResource(InputLayout);
 		m_CurrentPipelineState->ChangeRefRead(m_CurrentPipelineState->IA.Layout, pInputLayout);
@@ -364,8 +364,10 @@ bool WrappedID3D11DeviceContext::Serialise_IASetVertexBuffers(UINT StartSlot_, U
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppVertexBuffers[i]));
 		
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Buffers[i] = NULL;
 	}
 	
 	if(m_State <= EXECUTING)
@@ -429,7 +431,7 @@ bool WrappedID3D11DeviceContext::Serialise_IASetIndexBuffer(ID3D11Buffer *pIndex
 	SERIALISE_ELEMENT(DXGI_FORMAT, Format, Format_);
 	SERIALISE_ELEMENT(uint32_t, Offset, Offset_);
 	
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(Buffer))
 	{
 		pIndexBuffer = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(Buffer);
 		m_CurrentPipelineState->ChangeRefRead(m_CurrentPipelineState->IA.IndexBuffer, pIndexBuffer);
@@ -577,8 +579,10 @@ bool WrappedID3D11DeviceContext::Serialise_VSSetConstantBuffers(UINT StartSlot_,
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppConstantBuffers[i]));
 		
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Buffers[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -640,8 +644,10 @@ bool WrappedID3D11DeviceContext::Serialise_VSSetShaderResources(UINT StartSlot_,
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppShaderResourceViews[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Views[i] = (ID3D11ShaderResourceView *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Views[i] = NULL;
 	}
 	
 	if(m_State <= EXECUTING)
@@ -706,8 +712,10 @@ bool WrappedID3D11DeviceContext::Serialise_VSSetSamplers(UINT StartSlot_, UINT N
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppSamplers[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Sampler[i] = (ID3D11SamplerState *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Sampler[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -763,8 +771,10 @@ bool WrappedID3D11DeviceContext::Serialise_VSSetShader(ID3D11VertexShader *pShad
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppClassInstances[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Instances[i] = (ID3D11ClassInstance *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Instances[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -775,7 +785,9 @@ bool WrappedID3D11DeviceContext::Serialise_VSSetShader(ID3D11VertexShader *pShad
 		for(UINT i=0; i < NumClassInstances; i++)
 			Instances[i] = UNWRAP(WrappedID3D11ClassInstance, Instances[i]);
 
-		ID3D11DeviceChild *pShader = (ID3D11DeviceChild *)m_pDevice->GetResourceManager()->GetLiveResource(Shader);
+		ID3D11DeviceChild *pShader = NULL;
+		if(m_pDevice->GetResourceManager()->HasLiveResource(Shader))
+			pShader = (ID3D11DeviceChild *)m_pDevice->GetResourceManager()->GetLiveResource(Shader);
 		m_CurrentPipelineState->ChangeRefRead(m_CurrentPipelineState->VS.Shader, pShader);
 		m_pRealContext->VSSetShader(UNWRAP(WrappedID3D11Shader<ID3D11VertexShader>, pShader), Instances, NumClassInstances);
 		VerifyState();
@@ -923,8 +935,10 @@ bool WrappedID3D11DeviceContext::Serialise_HSSetConstantBuffers(UINT StartSlot_,
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppConstantBuffers[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Buffers[i] = NULL;
 	}
 	
 	if(m_State <= EXECUTING)
@@ -989,8 +1003,10 @@ bool WrappedID3D11DeviceContext::Serialise_HSSetShaderResources(UINT StartSlot_,
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppShaderResourceViews[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Views[i] = (ID3D11ShaderResourceView *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Views[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -1055,8 +1071,10 @@ bool WrappedID3D11DeviceContext::Serialise_HSSetSamplers(UINT StartSlot_, UINT N
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppSamplers[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Sampler[i] = (ID3D11SamplerState *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Sampler[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -1112,8 +1130,10 @@ bool WrappedID3D11DeviceContext::Serialise_HSSetShader(ID3D11HullShader *pShader
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppClassInstances[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Instances[i] = (ID3D11ClassInstance *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Instances[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -1124,7 +1144,9 @@ bool WrappedID3D11DeviceContext::Serialise_HSSetShader(ID3D11HullShader *pShader
 		for(UINT i=0; i < NumClassInstances; i++)
 			Instances[i] = UNWRAP(WrappedID3D11ClassInstance, Instances[i]);
 
-		ID3D11DeviceChild *pShader = (ID3D11DeviceChild *)m_pDevice->GetResourceManager()->GetLiveResource(Shader);
+		ID3D11DeviceChild *pShader = NULL;
+		if(m_pDevice->GetResourceManager()->HasLiveResource(Shader))
+			pShader = (ID3D11DeviceChild *)m_pDevice->GetResourceManager()->GetLiveResource(Shader);
 		m_CurrentPipelineState->ChangeRefRead(m_CurrentPipelineState->HS.Shader, pShader);
 		m_pRealContext->HSSetShader(UNWRAP(WrappedID3D11Shader<ID3D11HullShader>, pShader), Instances, NumClassInstances);
 		VerifyState();
@@ -1272,8 +1294,10 @@ bool WrappedID3D11DeviceContext::Serialise_DSSetConstantBuffers(UINT StartSlot_,
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppConstantBuffers[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Buffers[i] = NULL;
 	}
 	
 	if(m_State <= EXECUTING)
@@ -1337,8 +1361,10 @@ bool WrappedID3D11DeviceContext::Serialise_DSSetShaderResources(UINT StartSlot_,
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppShaderResourceViews[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Views[i] = (ID3D11ShaderResourceView *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Views[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -1403,8 +1429,10 @@ bool WrappedID3D11DeviceContext::Serialise_DSSetSamplers(UINT StartSlot_, UINT N
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppSamplers[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Sampler[i] = (ID3D11SamplerState *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Sampler[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -1460,8 +1488,10 @@ bool WrappedID3D11DeviceContext::Serialise_DSSetShader(ID3D11DomainShader *pShad
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppClassInstances[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Instances[i] = (ID3D11ClassInstance *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Instances[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -1472,7 +1502,9 @@ bool WrappedID3D11DeviceContext::Serialise_DSSetShader(ID3D11DomainShader *pShad
 		for(UINT i=0; i < NumClassInstances; i++)
 			Instances[i] = UNWRAP(WrappedID3D11ClassInstance, Instances[i]);
 
-		ID3D11DeviceChild *pShader = (ID3D11DeviceChild *)m_pDevice->GetResourceManager()->GetLiveResource(Shader);
+		ID3D11DeviceChild *pShader = NULL;
+		if(m_pDevice->GetResourceManager()->HasLiveResource(Shader))
+			pShader = (ID3D11DeviceChild *)m_pDevice->GetResourceManager()->GetLiveResource(Shader);
 		m_CurrentPipelineState->ChangeRefRead(m_CurrentPipelineState->DS.Shader, pShader);
 		m_pRealContext->DSSetShader(UNWRAP(WrappedID3D11Shader<ID3D11DomainShader>, pShader), Instances, NumClassInstances);
 		VerifyState();
@@ -1620,8 +1652,10 @@ bool WrappedID3D11DeviceContext::Serialise_GSSetConstantBuffers(UINT StartSlot_,
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppConstantBuffers[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Buffers[i] = NULL;
 	}
 	
 	if(m_State <= EXECUTING)
@@ -1685,8 +1719,10 @@ bool WrappedID3D11DeviceContext::Serialise_GSSetShaderResources(UINT StartSlot_,
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppShaderResourceViews[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Views[i] = (ID3D11ShaderResourceView *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Views[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -1751,8 +1787,10 @@ bool WrappedID3D11DeviceContext::Serialise_GSSetSamplers(UINT StartSlot_, UINT N
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppSamplers[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Sampler[i] = (ID3D11SamplerState *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Sampler[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -1808,8 +1846,10 @@ bool WrappedID3D11DeviceContext::Serialise_GSSetShader(ID3D11GeometryShader *pSh
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppClassInstances[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Instances[i] = (ID3D11ClassInstance *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Instances[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -1820,7 +1860,9 @@ bool WrappedID3D11DeviceContext::Serialise_GSSetShader(ID3D11GeometryShader *pSh
 		for(UINT i=0; i < NumClassInstances; i++)
 			Instances[i] = UNWRAP(WrappedID3D11ClassInstance, Instances[i]);
 
-		ID3D11DeviceChild *pShader = (ID3D11DeviceChild *)m_pDevice->GetResourceManager()->GetLiveResource(Shader);
+		ID3D11DeviceChild *pShader = NULL;
+		if(m_pDevice->GetResourceManager()->HasLiveResource(Shader))
+			pShader = (ID3D11DeviceChild *)m_pDevice->GetResourceManager()->GetLiveResource(Shader);
 		m_CurrentPipelineState->ChangeRefRead(m_CurrentPipelineState->GS.Shader, pShader);
 		m_pRealContext->GSSetShader(UNWRAP(WrappedID3D11Shader<ID3D11GeometryShader>, pShader), Instances, NumClassInstances);
 		VerifyState();
@@ -1893,8 +1935,10 @@ bool WrappedID3D11DeviceContext::Serialise_SOSetTargets(UINT NumBuffers_, ID3D11
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppSOTargets[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Buffers[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -2108,7 +2152,7 @@ bool WrappedID3D11DeviceContext::Serialise_RSSetState(ID3D11RasterizerState *pRa
 {
 	SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(pRasterizerState));
 	
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 	{
 		ID3D11DeviceChild *live = m_pDevice->GetResourceManager()->GetLiveResource(id);
 #if defined(INCLUDE_D3D_11_1)
@@ -2272,8 +2316,10 @@ bool WrappedID3D11DeviceContext::Serialise_PSSetConstantBuffers(UINT StartSlot_,
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppConstantBuffers[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Buffers[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -2335,8 +2381,10 @@ bool WrappedID3D11DeviceContext::Serialise_PSSetShaderResources(UINT StartSlot_,
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppShaderResourceViews[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Views[i] = (ID3D11ShaderResourceView *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Views[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -2399,8 +2447,10 @@ bool WrappedID3D11DeviceContext::Serialise_PSSetSamplers(UINT StartSlot_, UINT N
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppSamplers[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Sampler[i] = (ID3D11SamplerState *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Sampler[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -2453,8 +2503,10 @@ bool WrappedID3D11DeviceContext::Serialise_PSSetShader(ID3D11PixelShader *pShade
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppClassInstances[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Instances[i] = (ID3D11ClassInstance *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Instances[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -2465,7 +2517,9 @@ bool WrappedID3D11DeviceContext::Serialise_PSSetShader(ID3D11PixelShader *pShade
 		for(UINT i=0; i < NumClassInstances; i++)
 			Instances[i] = UNWRAP(WrappedID3D11ClassInstance, Instances[i]);
 
-		ID3D11DeviceChild *pShader = (ID3D11DeviceChild *)m_pDevice->GetResourceManager()->GetLiveResource(Shader);
+		ID3D11DeviceChild *pShader = NULL;
+		if(m_pDevice->GetResourceManager()->HasLiveResource(Shader))
+			pShader = (ID3D11DeviceChild *)m_pDevice->GetResourceManager()->GetLiveResource(Shader);
 		m_CurrentPipelineState->ChangeRefRead(m_CurrentPipelineState->PS.Shader, pShader);
 		m_pRealContext->PSSetShader(UNWRAP(WrappedID3D11Shader<ID3D11PixelShader>, pShader), Instances, NumClassInstances);
 		VerifyState();
@@ -2996,7 +3050,7 @@ bool WrappedID3D11DeviceContext::Serialise_OMSetBlendState(ID3D11BlendState *pBl
 
 	SERIALISE_ELEMENT(uint32_t, SampleMask, SampleMask_);
 
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(State))
 	{
 		ID3D11DeviceChild *live = m_pDevice->GetResourceManager()->GetLiveResource(State);
 #if defined(INCLUDE_D3D_11_1)
@@ -3062,7 +3116,7 @@ bool WrappedID3D11DeviceContext::Serialise_OMSetDepthStencilState(ID3D11DepthSte
 	SERIALISE_ELEMENT(ResourceId, State, GetIDForResource(pDepthStencilState));
 	SERIALISE_ELEMENT(uint32_t, StencilRef, StencilRef_&0xff);
 
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(State))
 	{
 		pDepthStencilState = (ID3D11DepthStencilState *)m_pDevice->GetResourceManager()->GetLiveResource(State);
 		m_CurrentPipelineState->ChangeRefRead(m_CurrentPipelineState->OM.DepthStencilState, pDepthStencilState);
@@ -3484,7 +3538,7 @@ bool WrappedID3D11DeviceContext::Serialise_DrawIndexedInstancedIndirect(ID3D11Bu
 	SERIALISE_ELEMENT(ResourceId, BufferForArgs, GetIDForResource(pBufferForArgs));
 	SERIALISE_ELEMENT(uint32_t, AlignedByteOffsetForArgs, AlignedByteOffsetForArgs_);
 	
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(BufferForArgs))
 	{
 		m_pRealContext->DrawIndexedInstancedIndirect(UNWRAP(WrappedID3D11Buffer, m_pDevice->GetResourceManager()->GetLiveResource(BufferForArgs)), AlignedByteOffsetForArgs);
 	}
@@ -3497,21 +3551,30 @@ bool WrappedID3D11DeviceContext::Serialise_DrawIndexedInstancedIndirect(ID3D11Bu
 	{
 		AddEvent(DRAW, desc);
 		
-		ID3D11Buffer *argBuffer = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(BufferForArgs);
-
-		vector<byte> args = m_pDevice->GetDebugManager()->GetBufferData(argBuffer, AlignedByteOffsetForArgs, 5*sizeof(uint32_t));
-		uint32_t *uargs = (uint32_t *)&args[0];
-
-		string name = "DrawIndexedInstancedIndirect(<" + ToStr::Get(uargs[0])
-						+ ", " + ToStr::Get(uargs[1]) + ">)";
-
+		ID3D11Buffer *argBuffer = NULL;
+		
 		FetchDrawcall draw;
+
+		string name = "DrawIndexedInstancedIndirect(-, -)";
+
+		if(m_pDevice->GetResourceManager()->HasLiveResource(BufferForArgs))
+		{
+			ID3D11Buffer *argBuffer = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(BufferForArgs);
+
+			vector<byte> args = m_pDevice->GetDebugManager()->GetBufferData(argBuffer, AlignedByteOffsetForArgs, 5*sizeof(uint32_t));
+			uint32_t *uargs = (uint32_t *)&args[0];
+
+			name = "DrawIndexedInstancedIndirect(<" + ToStr::Get(uargs[0])
+			                   + ", " + ToStr::Get(uargs[1]) + ">)";
+
+			draw.numIndices = uargs[0];
+			draw.numInstances = uargs[1];
+			draw.indexOffset = uargs[2];
+			draw.vertexOffset = uargs[3];
+			draw.instanceOffset = uargs[4];
+		}
+
 		draw.name = widen(name);
-		draw.numIndices = uargs[0];
-		draw.numInstances = uargs[1];
-		draw.indexOffset = uargs[2];
-		draw.vertexOffset = uargs[3];
-		draw.instanceOffset = uargs[4];
 
 		draw.flags |= eDraw_Drawcall|eDraw_Instanced|eDraw_UseIBuffer|eDraw_Indirect;
 
@@ -3555,7 +3618,7 @@ bool WrappedID3D11DeviceContext::Serialise_DrawInstancedIndirect(ID3D11Buffer *p
 	SERIALISE_ELEMENT(ResourceId, BufferForArgs, GetIDForResource(pBufferForArgs));
 	SERIALISE_ELEMENT(uint32_t, AlignedByteOffsetForArgs, AlignedByteOffsetForArgs_);
 	
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(BufferForArgs))
 	{
 		m_pRealContext->DrawInstancedIndirect(UNWRAP(WrappedID3D11Buffer, m_pDevice->GetResourceManager()->GetLiveResource(BufferForArgs)), AlignedByteOffsetForArgs);
 	}
@@ -3568,20 +3631,26 @@ bool WrappedID3D11DeviceContext::Serialise_DrawInstancedIndirect(ID3D11Buffer *p
 	{
 		AddEvent(DRAW, desc);
 		
-		ID3D11Buffer *argBuffer = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(BufferForArgs);
-
-		vector<byte> args = m_pDevice->GetDebugManager()->GetBufferData(argBuffer, AlignedByteOffsetForArgs, 4*sizeof(uint32_t));
-		uint32_t *uargs = (uint32_t *)&args[0];
-
-		string name = "DrawInstancedIndirect(<" + ToStr::Get(uargs[0])
-						+ ", " + ToStr::Get(uargs[1]) + ">)";
-
 		FetchDrawcall draw;
+		
+		string name = "DrawInstancedIndirect(-, -)";
+		if(m_pDevice->GetResourceManager()->HasLiveResource(BufferForArgs))
+		{
+			ID3D11Buffer *argBuffer = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(BufferForArgs);
+
+			vector<byte> args = m_pDevice->GetDebugManager()->GetBufferData(argBuffer, AlignedByteOffsetForArgs, 4*sizeof(uint32_t));
+			uint32_t *uargs = (uint32_t *)&args[0];
+
+			name = "DrawInstancedIndirect(<" + ToStr::Get(uargs[0])
+							+ ", " + ToStr::Get(uargs[1]) + ">)";
+
+			draw.numIndices = uargs[0];
+			draw.numInstances = uargs[1];
+			draw.vertexOffset = uargs[2];
+			draw.instanceOffset = uargs[3];
+		}
+
 		draw.name = widen(name);
-		draw.numIndices = uargs[0];
-		draw.numInstances = uargs[1];
-		draw.vertexOffset = uargs[2];
-		draw.instanceOffset = uargs[3];
 
 		draw.flags |= eDraw_Drawcall|eDraw_Instanced|eDraw_Indirect;
 
@@ -3746,8 +3815,10 @@ bool WrappedID3D11DeviceContext::Serialise_CSSetConstantBuffers(UINT StartSlot_,
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppConstantBuffers[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Buffers[i] = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Buffers[i] = NULL;
 	}
 	
 	if(m_State <= EXECUTING)
@@ -3811,8 +3882,10 @@ bool WrappedID3D11DeviceContext::Serialise_CSSetShaderResources(UINT StartSlot_,
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppShaderResourceViews[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Views[i] = (ID3D11ShaderResourceView *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Views[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -3952,8 +4025,10 @@ bool WrappedID3D11DeviceContext::Serialise_CSSetSamplers(UINT StartSlot_, UINT N
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppSamplers[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Sampler[i] = (ID3D11SamplerState *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Sampler[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -4008,8 +4083,10 @@ bool WrappedID3D11DeviceContext::Serialise_CSSetShader(ID3D11ComputeShader *pSha
 	{
 		SERIALISE_ELEMENT(ResourceId, id, GetIDForResource(ppClassInstances[i]));
 
-		if(m_State <= EXECUTING)
+		if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(id))
 			Instances[i] = (ID3D11ClassInstance *)m_pDevice->GetResourceManager()->GetLiveResource(id);
+		else
+			Instances[i] = NULL;
 	}
 
 	if(m_State <= EXECUTING)
@@ -4019,8 +4096,10 @@ bool WrappedID3D11DeviceContext::Serialise_CSSetShader(ID3D11ComputeShader *pSha
 
 		for(UINT i=0; i < NumClassInstances; i++)
 			Instances[i] = UNWRAP(WrappedID3D11ClassInstance, Instances[i]);
-
-		ID3D11DeviceChild *pShader = (ID3D11DeviceChild *)m_pDevice->GetResourceManager()->GetLiveResource(Shader);
+		
+		ID3D11DeviceChild *pShader = NULL;
+		if(m_pDevice->GetResourceManager()->HasLiveResource(Shader))
+			pShader = (ID3D11DeviceChild *)m_pDevice->GetResourceManager()->GetLiveResource(Shader);
 		m_CurrentPipelineState->ChangeRefRead(m_CurrentPipelineState->CS.Shader, pShader);
 		m_pRealContext->CSSetShader(UNWRAP(WrappedID3D11Shader<ID3D11ComputeShader>, pShader), Instances, NumClassInstances);
 		VerifyState();
@@ -4234,7 +4313,7 @@ bool WrappedID3D11DeviceContext::Serialise_DispatchIndirect(ID3D11Buffer *pBuffe
 	SERIALISE_ELEMENT(ResourceId, BufferForArgs, GetIDForResource(pBufferForArgs));
 	SERIALISE_ELEMENT(uint32_t, AlignedByteOffsetForArgs, AlignedByteOffsetForArgs_);
 	
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(BufferForArgs))
 	{
 		m_pRealContext->DispatchIndirect(UNWRAP(WrappedID3D11Buffer, m_pDevice->GetResourceManager()->GetLiveResource(BufferForArgs)), AlignedByteOffsetForArgs);
 	}
@@ -4247,16 +4326,21 @@ bool WrappedID3D11DeviceContext::Serialise_DispatchIndirect(ID3D11Buffer *pBuffe
 	{
 		AddEvent(DISPATCH_INDIRECT, desc);
 		
-		ID3D11Buffer *argBuffer = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(BufferForArgs);
-
-		vector<byte> args = m_pDevice->GetDebugManager()->GetBufferData(argBuffer, AlignedByteOffsetForArgs, 5*sizeof(uint32_t));
-		uint32_t *uargs = (uint32_t *)&args[0];
-
-		string name = "DispatchIndirect(<" + ToStr::Get(uargs[0])
-						+ ", " + ToStr::Get(uargs[1]) + 
-						+ ", " + ToStr::Get(uargs[2]) + ">)";
-
 		FetchDrawcall draw;
+
+		string name = "DispatchIndirect(-, -, -)";
+		if(m_pDevice->GetResourceManager()->HasLiveResource(BufferForArgs))
+		{
+			ID3D11Buffer *argBuffer = (ID3D11Buffer *)m_pDevice->GetResourceManager()->GetLiveResource(BufferForArgs);
+
+			vector<byte> args = m_pDevice->GetDebugManager()->GetBufferData(argBuffer, AlignedByteOffsetForArgs, 5*sizeof(uint32_t));
+			uint32_t *uargs = (uint32_t *)&args[0];
+
+			name = "DispatchIndirect(<" + ToStr::Get(uargs[0])
+							+ ", " + ToStr::Get(uargs[1]) + 
+							+ ", " + ToStr::Get(uargs[2]) + ">)";
+		}
+
 		draw.name = widen(name);
 		draw.flags |= eDraw_Dispatch|eDraw_Indirect;
 
@@ -4479,7 +4563,9 @@ bool WrappedID3D11DeviceContext::Serialise_CopySubresourceRegion( ID3D11Resource
 	SERIALISE_ELEMENT(uint8_t, HasSourceBox, pSrcBox != NULL);
 	SERIALISE_ELEMENT_OPT(D3D11_BOX, SourceBox, *pSrcBox, HasSourceBox);
 
-	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(Destination))
+	if(m_State <= EXECUTING &&
+		 m_pDevice->GetResourceManager()->HasLiveResource(Destination) &&
+		 m_pDevice->GetResourceManager()->HasLiveResource(Source))
 	{
 		D3D11_BOX *box = &SourceBox;
 		if(!HasSourceBox)
@@ -4582,7 +4668,9 @@ bool WrappedID3D11DeviceContext::Serialise_CopyResource(ID3D11Resource *pDstReso
 	SERIALISE_ELEMENT(ResourceId, Destination, GetIDForResource(pDstResource));
 	SERIALISE_ELEMENT(ResourceId, Source, GetIDForResource(pSrcResource));
 
-	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(Destination))
+	if(m_State <= EXECUTING &&
+		 m_pDevice->GetResourceManager()->HasLiveResource(Destination) &&
+		 m_pDevice->GetResourceManager()->HasLiveResource(Source))
 	{
 		m_pRealContext->CopyResource(m_pDevice->GetResourceManager()->UnwrapResource((ID3D11Resource*)m_pDevice->GetResourceManager()->GetLiveResource(Destination)),
 											m_pDevice->GetResourceManager()->UnwrapResource((ID3D11Resource*)m_pDevice->GetResourceManager()->GetLiveResource(Source)));
@@ -4928,7 +5016,9 @@ bool WrappedID3D11DeviceContext::Serialise_CopyStructureCount(ID3D11Buffer *pDst
 	SERIALISE_ELEMENT(uint32_t, DestAlignedByteOffset, DstAlignedByteOffset);
 	SERIALISE_ELEMENT(ResourceId, SourceView, GetIDForResource(pSrcView));
 
-	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(DestBuffer))
+	if(m_State <= EXECUTING &&
+		 m_pDevice->GetResourceManager()->HasLiveResource(DestBuffer) &&
+		 m_pDevice->GetResourceManager()->HasLiveResource(SourceView))
 	{
 		m_pRealContext->CopyStructureCount(UNWRAP(WrappedID3D11Buffer, m_pDevice->GetResourceManager()->GetLiveResource(DestBuffer)),
 											DestAlignedByteOffset,
@@ -4993,7 +5083,9 @@ bool WrappedID3D11DeviceContext::Serialise_ResolveSubresource(ID3D11Resource *pD
 	SERIALISE_ELEMENT(uint32_t, SourceSubresource, SrcSubresource);
 	SERIALISE_ELEMENT(DXGI_FORMAT, Format, Format_);
 
-	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(DestResource))
+	if(m_State <= EXECUTING &&
+		 m_pDevice->GetResourceManager()->HasLiveResource(DestResource) &&
+		 m_pDevice->GetResourceManager()->HasLiveResource(SourceResource))
 	{
 		m_pRealContext->ResolveSubresource(m_pDevice->GetResourceManager()->UnwrapResource((ID3D11Resource*)m_pDevice->GetResourceManager()->GetLiveResource(DestResource)),
 												DestSubresource,
@@ -5173,7 +5265,7 @@ bool WrappedID3D11DeviceContext::Serialise_ClearRenderTargetView(ID3D11RenderTar
 
 	m_pSerialiser->Serialise<4>("ColorRGBA", Color);
 
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(View))
 	{
 		m_pRealContext->ClearRenderTargetView(UNWRAP(WrappedID3D11RenderTargetView, m_pDevice->GetResourceManager()->GetLiveResource(View)), Color);
 	}
@@ -5200,8 +5292,9 @@ bool WrappedID3D11DeviceContext::Serialise_ClearRenderTargetView(ID3D11RenderTar
 
 		AddDrawcall(draw, true);
 
-		m_ResourceUses[((WrappedID3D11RenderTargetView *)m_pDevice->GetResourceManager()->GetLiveResource(View))->GetResourceResID()]
-			.push_back(EventUsage(m_CurEventID, eUsage_Clear));
+		if(m_pDevice->GetResourceManager()->HasLiveResource(View))
+			m_ResourceUses[((WrappedID3D11RenderTargetView *)m_pDevice->GetResourceManager()->GetLiveResource(View))->GetResourceResID()]
+				.push_back(EventUsage(m_CurEventID, eUsage_Clear));
 	}
 
 	return true;
@@ -5322,8 +5415,9 @@ bool WrappedID3D11DeviceContext::Serialise_ClearUnorderedAccessViewUint(ID3D11Un
 
 		AddDrawcall(draw, true);
 
-		m_ResourceUses[((WrappedID3D11UnorderedAccessView *)m_pDevice->GetResourceManager()->GetLiveResource(View))->GetResourceResID()]
-			.push_back(EventUsage(m_CurEventID, eUsage_Clear));
+		if(m_pDevice->GetResourceManager()->HasLiveResource(View))
+			m_ResourceUses[((WrappedID3D11UnorderedAccessView *)m_pDevice->GetResourceManager()->GetLiveResource(View))->GetResourceResID()]
+				.push_back(EventUsage(m_CurEventID, eUsage_Clear));
 	}
 
 	return true;
@@ -5439,8 +5533,9 @@ bool WrappedID3D11DeviceContext::Serialise_ClearUnorderedAccessViewFloat(ID3D11U
 
 		AddDrawcall(draw, true);
 
-		m_ResourceUses[((WrappedID3D11UnorderedAccessView *)m_pDevice->GetResourceManager()->GetLiveResource(View))->GetResourceResID()]
-			.push_back(EventUsage(m_CurEventID, eUsage_Clear));
+		if(m_pDevice->GetResourceManager()->HasLiveResource(View))
+			m_ResourceUses[((WrappedID3D11UnorderedAccessView *)m_pDevice->GetResourceManager()->GetLiveResource(View))->GetResourceResID()]
+				.push_back(EventUsage(m_CurEventID, eUsage_Clear));
 	}
 
 	return true;
@@ -5553,9 +5648,10 @@ bool WrappedID3D11DeviceContext::Serialise_ClearDepthStencilView(ID3D11DepthSten
 		draw.debugMessages = debugMessages;
 
 		AddDrawcall(draw, true);
-
-		m_ResourceUses[((WrappedID3D11DepthStencilView *)m_pDevice->GetResourceManager()->GetLiveResource(View))->GetResourceResID()]
-			.push_back(EventUsage(m_CurEventID, eUsage_Clear));
+		
+		if(m_pDevice->GetResourceManager()->HasLiveResource(View))
+			m_ResourceUses[((WrappedID3D11DepthStencilView *)m_pDevice->GetResourceManager()->GetLiveResource(View))->GetResourceResID()]
+				.push_back(EventUsage(m_CurEventID, eUsage_Clear));
 	}
 
 	return true;
@@ -5667,7 +5763,7 @@ bool WrappedID3D11DeviceContext::Serialise_Begin(ID3D11Asynchronous *pAsync)
 		SERIALISE_ELEMENT(D3D11_QUERY, QueryType, qt);
 	}
 
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(Async))
 	{
 		//m_pImmediateContext->Begin((ID3D11Asynchronous *)m_pDevice->GetResourceManager()->GetLiveResource(Async));
 	}
@@ -5722,7 +5818,7 @@ bool WrappedID3D11DeviceContext::Serialise_End(ID3D11Asynchronous *pAsync)
 		SERIALISE_ELEMENT(D3D11_QUERY, QueryType, qt);
 	}
 
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(Async))
 	{
 		//m_pImmediateContext->End((ID3D11Asynchronous *)m_pDevice->GetResourceManager()->GetLiveResource(Async));
 	}
@@ -5776,7 +5872,7 @@ bool WrappedID3D11DeviceContext::Serialise_SetPredication(ID3D11Predicate *pPred
 	SERIALISE_ELEMENT(ResourceId, Predicate, GetIDForResource(pPredicate));
 	SERIALISE_ELEMENT(uint8_t, PredicateValue, PredicateValue_ == TRUE);
 
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(Predicate))
 	{
 		m_pRealContext->SetPredication(UNWRAP(WrappedID3D11Predicate, m_pDevice->GetResourceManager()->GetLiveResource(Predicate)), PredicateValue);
 	}
@@ -5810,7 +5906,7 @@ bool WrappedID3D11DeviceContext::Serialise_SetResourceMinLOD(ID3D11Resource *pRe
 	SERIALISE_ELEMENT(ResourceId, Resource, GetIDForResource(pResource));
 	SERIALISE_ELEMENT(float, MinLOD, MinLOD_);
 
-	if(m_State <= EXECUTING)
+	if(m_State <= EXECUTING && m_pDevice->GetResourceManager()->HasLiveResource(Resource))
 	{
 		m_pRealContext->SetResourceMinLOD((ID3D11Resource *)m_pDevice->GetResourceManager()->GetLiveResource(Resource), MinLOD);
 	}
@@ -6104,8 +6200,6 @@ bool WrappedID3D11DeviceContext::Serialise_Map(ID3D11Resource *pResource, UINT S
 		RDCASSERT(m_OpenMaps.find(MappedResource(Resource, Subresource)) == m_OpenMaps.end());
 
 		ID3D11Resource *resMap = pResource;
-		if(m_pDevice->GetResourceManager()->HasLiveResource(Resource))
-			resMap = (ID3D11Resource *)m_pDevice->GetResourceManager()->GetLiveResource(Resource);
 
 		RDCASSERT(resMap);
 		

renderdoc/driver/d3d11/d3d11_debug.cpp

@@ -3423,77 +3423,83 @@ bool D3D11DebugManager::RenderTexture(TextureDisplay cfg, bool blendAlpha)
 			RDCASSERT(dxbc);
 			RDCASSERT(dxbc->m_Type == D3D11_SHVER_PIXEL_SHADER);
 
-			WrappedID3D11Shader<ID3D11PixelShader> *wrapped = (WrappedID3D11Shader<ID3D11PixelShader> *)m_WrappedDevice->GetResourceManager()->GetLiveResource(cfg.CustomShader);
-
-			customPS = wrapped->GetReal();
-
-			for(size_t i=0; i < dxbc->m_CBuffers.size(); i++)
+			WrappedID3D11Shader<ID3D11PixelShader> *wrapped = NULL;
+			
+			if(m_WrappedDevice->GetResourceManager()->HasLiveResource(cfg.CustomShader))
 			{
-				const DXBC::CBuffer &cbuf = dxbc->m_CBuffers[i];
-				if(cbuf.name == "$Globals")
+				WrappedID3D11Shader<ID3D11PixelShader> *wrapped =
+						(WrappedID3D11Shader<ID3D11PixelShader> *)m_WrappedDevice->GetResourceManager()->GetLiveResource(cfg.CustomShader);
+
+				customPS = wrapped->GetReal();
+
+				for(size_t i=0; i < dxbc->m_CBuffers.size(); i++)
 				{
-					float *cbufData = new float[cbuf.descriptor.byteSize/sizeof(float) + 1];
-					byte *byteData = (byte *)cbufData;
-
-					for(size_t v=0; v < cbuf.variables.size(); v++)
+					const DXBC::CBuffer &cbuf = dxbc->m_CBuffers[i];
+					if(cbuf.name == "$Globals")
 					{
-						const DXBC::CBufferVariable &var = cbuf.variables[v];
+						float *cbufData = new float[cbuf.descriptor.byteSize/sizeof(float) + 1];
+						byte *byteData = (byte *)cbufData;
 
-						if(var.name == "RENDERDOC_TexDim")
+						for(size_t v=0; v < cbuf.variables.size(); v++)
 						{
-							if(var.type.descriptor.rows == 1 &&
-								var.type.descriptor.cols == 4 &&
-								var.type.descriptor.type == DXBC::VARTYPE_UINT)
-							{
-								uint32_t *d = (uint32_t *)(byteData + var.descriptor.offset);
+							const DXBC::CBufferVariable &var = cbuf.variables[v];
 
-								d[0] = details.texWidth;
-								d[1] = details.texHeight;
-								d[2] = details.texType == D3D11DebugManager::eTexType_3D ? details.texDepth : details.texArraySize;
-								d[3] = details.texMips;
+							if(var.name == "RENDERDOC_TexDim")
+							{
+								if(var.type.descriptor.rows == 1 &&
+									var.type.descriptor.cols == 4 &&
+									var.type.descriptor.type == DXBC::VARTYPE_UINT)
+								{
+									uint32_t *d = (uint32_t *)(byteData + var.descriptor.offset);
+
+									d[0] = details.texWidth;
+									d[1] = details.texHeight;
+									d[2] = details.texType == D3D11DebugManager::eTexType_3D ? details.texDepth : details.texArraySize;
+									d[3] = details.texMips;
+								}
+								else
+								{
+									RDCWARN("Custom shader: Variable recognised but type wrong, expected uint4: %hs", var.name.c_str());
+								}
+							}
+							else if(var.name == "RENDERDOC_SelectedMip")
+							{
+								if(var.type.descriptor.rows == 1 &&
+									var.type.descriptor.cols == 1 &&
+									var.type.descriptor.type == DXBC::VARTYPE_UINT)
+								{
+									uint32_t *d = (uint32_t *)(byteData + var.descriptor.offset);
+
+									d[0] = cfg.mip;
+								}
+								else
+								{
+									RDCWARN("Custom shader: Variable recognised but type wrong, expected uint: %hs", var.name.c_str());
+								}
+							}
+							else if(var.name == "RENDERDOC_TextureType")
+							{
+								if(var.type.descriptor.rows == 1 &&
+									var.type.descriptor.cols == 1 &&
+									var.type.descriptor.type == DXBC::VARTYPE_UINT)
+								{
+									uint32_t *d = (uint32_t *)(byteData + var.descriptor.offset);
+
+									d[0] = details.texType;
+								}
+								else
+								{
+									RDCWARN("Custom shader: Variable recognised but type wrong, expected uint: %hs", var.name.c_str());
+								}
 							}
 							else
 							{
-								RDCWARN("Custom shader: Variable recognised but type wrong, expected uint4: %hs", var.name.c_str());
+								RDCWARN("Custom shader: Variable not recognised: %hs", var.name.c_str());
 							}
 						}
-						else if(var.name == "RENDERDOC_SelectedMip")
-						{
-							if(var.type.descriptor.rows == 1 &&
-								var.type.descriptor.cols == 1 &&
-								var.type.descriptor.type == DXBC::VARTYPE_UINT)
-							{
-								uint32_t *d = (uint32_t *)(byteData + var.descriptor.offset);
 
-								d[0] = cfg.mip;
-							}
-							else
-							{
-								RDCWARN("Custom shader: Variable recognised but type wrong, expected uint: %hs", var.name.c_str());
-							}
-						}
-						else if(var.name == "RENDERDOC_TextureType")
-						{
-							if(var.type.descriptor.rows == 1 &&
-								var.type.descriptor.cols == 1 &&
-								var.type.descriptor.type == DXBC::VARTYPE_UINT)
-							{
-								uint32_t *d = (uint32_t *)(byteData + var.descriptor.offset);
-
-								d[0] = details.texType;
-							}
-							else
-							{
-								RDCWARN("Custom shader: Variable recognised but type wrong, expected uint: %hs", var.name.c_str());
-							}
-						}
-						else
-						{
-							RDCWARN("Custom shader: Variable not recognised: %hs", var.name.c_str());
-						}
+						customBuff = MakeCBuffer(cbufData, cbuf.descriptor.byteSize);
 					}
-
-					customBuff = MakeCBuffer(cbufData, cbuf.descriptor.byteSize);
 				}
 			}
 		}

renderdoc/driver/d3d11/d3d11_device.cpp

@@ -1371,15 +1371,15 @@ bool WrappedID3D11Device::Serialise_InitialState(ID3D11DeviceChild *res)
 	else if(type == Resource_Texture1D)
 	{
 		WrappedID3D11Texture1D *tex1D = (WrappedID3D11Texture1D *)res;
-		if(m_State < WRITING)
+		if(m_State < WRITING && m_ResourceManager->HasLiveResource(Id))
 			tex1D = (WrappedID3D11Texture1D *)m_ResourceManager->GetLiveResource(Id);
 		
 		D3D11ResourceRecord *record = NULL;
 		if(m_State >= WRITING)
 			record = m_ResourceManager->GetResourceRecord(Id);
 
-		D3D11_TEXTURE1D_DESC desc;
-		tex1D->GetDesc(&desc);
+		D3D11_TEXTURE1D_DESC desc = {0};
+		if(tex1D) tex1D->GetDesc(&desc);
 		
 		SERIALISE_ELEMENT(uint32_t, numSubresources, desc.MipLevels*desc.ArraySize);
 		
@@ -1398,7 +1398,7 @@ bool WrappedID3D11Device::Serialise_InitialState(ID3D11DeviceChild *res)
 			{
 				inmemBuffer = new byte[GetByteSize(desc.Width, 1, 1, desc.Format, 0)];
 			}
-			else
+			else if(tex1D)
 			{
 				subData = new D3D11_SUBRESOURCE_DATA[numSubresources];
 			}
@@ -1407,7 +1407,7 @@ bool WrappedID3D11Device::Serialise_InitialState(ID3D11DeviceChild *res)
 
 			for(UINT sub = 0; sub < numSubresources; sub++)
 			{
-				UINT mip = GetMipForSubresource(tex1D, sub);
+				UINT mip = tex1D ? GetMipForSubresource(tex1D, sub) : 0;
 				
 				if(m_State >= WRITING)
 				{
@@ -1443,15 +1443,22 @@ bool WrappedID3D11Device::Serialise_InitialState(ID3D11DeviceChild *res)
 					size_t len = 0;
 					m_pSerialiser->SerialiseBuffer("", data, len);
 
-					subData[sub].pSysMem = data;
-					subData[sub].SysMemPitch = GetByteSize(desc.Width, 1, 1, desc.Format, mip);
-					subData[sub].SysMemSlicePitch = GetByteSize(desc.Width, 1, 1, desc.Format, mip);
+					if(tex1D)
+					{
+						subData[sub].pSysMem = data;
+						subData[sub].SysMemPitch = GetByteSize(desc.Width, 1, 1, desc.Format, mip);
+						subData[sub].SysMemSlicePitch = GetByteSize(desc.Width, 1, 1, desc.Format, mip);
+					}
+					else
+					{
+						SAFE_DELETE_ARRAY(data);
+					}
 				}
 			}
 
 			SAFE_DELETE_ARRAY(inmemBuffer);
 			
-			if(m_State < WRITING)
+			if(m_State < WRITING && tex1D)
 			{
 				// We don't need to bind this, but IMMUTABLE requires at least one
 				// BindFlags.
@@ -1481,15 +1488,15 @@ bool WrappedID3D11Device::Serialise_InitialState(ID3D11DeviceChild *res)
 	else if(type == Resource_Texture2D)
 	{
 		WrappedID3D11Texture2D *tex2D = (WrappedID3D11Texture2D *)res;
-		if(m_State < WRITING)
+		if(m_State < WRITING && m_ResourceManager->HasLiveResource(Id))
 			tex2D = (WrappedID3D11Texture2D *)m_ResourceManager->GetLiveResource(Id);
 		
 		D3D11ResourceRecord *record = NULL;
 		if(m_State >= WRITING)
 			record = m_ResourceManager->GetResourceRecord(Id);
 
-		D3D11_TEXTURE2D_DESC desc;
-		tex2D->GetDesc(&desc);
+		D3D11_TEXTURE2D_DESC desc = {0};
+		if(tex2D) tex2D->GetDesc(&desc);
 
 		SERIALISE_ELEMENT(uint32_t, numSubresources, desc.MipLevels*desc.ArraySize);
 
@@ -1533,7 +1540,7 @@ bool WrappedID3D11Device::Serialise_InitialState(ID3D11DeviceChild *res)
 			{
 				inmemBuffer = new byte[GetByteSize(desc.Width, desc.Height, 1, desc.Format, 0)];
 			}
-			else
+			else if(tex2D)
 			{
 				subData = new D3D11_SUBRESOURCE_DATA[numSubresources];
 			}
@@ -1542,7 +1549,7 @@ bool WrappedID3D11Device::Serialise_InitialState(ID3D11DeviceChild *res)
 
 			for(UINT sub = 0; sub < numSubresources; sub++)
 			{
-				UINT mip = GetMipForSubresource(tex2D, sub);
+				UINT mip = tex2D ? GetMipForSubresource(tex2D, sub) : 0;
 				
 				if(m_State >= WRITING)
 				{
@@ -1583,15 +1590,22 @@ bool WrappedID3D11Device::Serialise_InitialState(ID3D11DeviceChild *res)
 					size_t len = 0;
 					m_pSerialiser->SerialiseBuffer("", data, len);
 
-					subData[sub].pSysMem = data;
-					subData[sub].SysMemPitch = GetByteSize(desc.Width, 1, 1, desc.Format, mip);
-					subData[sub].SysMemSlicePitch = GetByteSize(desc.Width, desc.Height, 1, desc.Format, mip);
+					if(tex2D)
+					{
+						subData[sub].pSysMem = data;
+						subData[sub].SysMemPitch = GetByteSize(desc.Width, 1, 1, desc.Format, mip);
+						subData[sub].SysMemSlicePitch = GetByteSize(desc.Width, desc.Height, 1, desc.Format, mip);
+					}
+					else
+					{
+						SAFE_DELETE_ARRAY(data);
+					}
 				}
 			}
 
 			SAFE_DELETE_ARRAY(inmemBuffer);
 			
-			if(m_State < WRITING)
+			if(m_State < WRITING && tex2D)
 			{
 				// We don't need to bind this, but IMMUTABLE requires at least one
 				// BindFlags.
@@ -1667,15 +1681,15 @@ bool WrappedID3D11Device::Serialise_InitialState(ID3D11DeviceChild *res)
 	else if(type == Resource_Texture3D)
 	{
 		WrappedID3D11Texture3D *tex3D = (WrappedID3D11Texture3D *)res;
-		if(m_State < WRITING)
+		if(m_State < WRITING && m_ResourceManager->HasLiveResource(Id))
 			tex3D = (WrappedID3D11Texture3D *)m_ResourceManager->GetLiveResource(Id);
 		
 		D3D11ResourceRecord *record = NULL;
 		if(m_State >= WRITING)
 			record = m_ResourceManager->GetResourceRecord(Id);
 
-		D3D11_TEXTURE3D_DESC desc;
-		tex3D->GetDesc(&desc);
+		D3D11_TEXTURE3D_DESC desc = {0};
+		if(tex3D) tex3D->GetDesc(&desc);
 		
 		SERIALISE_ELEMENT(uint32_t, numSubresources, desc.MipLevels);
 		
@@ -1694,7 +1708,7 @@ bool WrappedID3D11Device::Serialise_InitialState(ID3D11DeviceChild *res)
 			{
 				inmemBuffer = new byte[GetByteSize(desc.Width, desc.Height, desc.Depth, desc.Format, 0)];
 			}
-			else
+			else if(tex3D)
 			{
 				subData = new D3D11_SUBRESOURCE_DATA[numSubresources];
 			}
@@ -1703,7 +1717,7 @@ bool WrappedID3D11Device::Serialise_InitialState(ID3D11DeviceChild *res)
 
 			for(UINT sub = 0; sub < numSubresources; sub++)
 			{
-				UINT mip = GetMipForSubresource(tex3D, sub);
+				UINT mip = tex3D ? GetMipForSubresource(tex3D, sub) : 0;
 				
 				if(m_State >= WRITING)
 				{
@@ -1755,15 +1769,22 @@ bool WrappedID3D11Device::Serialise_InitialState(ID3D11DeviceChild *res)
 					size_t len = 0;
 					m_pSerialiser->SerialiseBuffer("", data, len);
 
-					subData[sub].pSysMem = data;
-					subData[sub].SysMemPitch = GetByteSize(desc.Width, 1, 1, desc.Format, mip);
-					subData[sub].SysMemSlicePitch = GetByteSize(desc.Width, desc.Height, 1, desc.Format, mip);
+					if(tex3D)
+					{
+						subData[sub].pSysMem = data;
+						subData[sub].SysMemPitch = GetByteSize(desc.Width, 1, 1, desc.Format, mip);
+						subData[sub].SysMemSlicePitch = GetByteSize(desc.Width, desc.Height, 1, desc.Format, mip);
+					}
+					else
+					{
+						SAFE_DELETE_ARRAY(data);
+					}
 				}
 			}
 
 			SAFE_DELETE_ARRAY(inmemBuffer);
 			
-			if(m_State < WRITING)
+			if(m_State < WRITING && tex3D)
 			{
 				// We don't need to bind this, but IMMUTABLE requires at least one
 				// BindFlags.

renderdoc/driver/d3d11/d3d11_device_wrap.cpp

@@ -1162,10 +1162,12 @@ bool WrappedID3D11Device::Serialise_CreateVertexShader(
 	
 	if(m_State == READING)
 	{
+		ID3D11ClassLinkage *linkage = NULL;
+		if(GetResourceManager()->HasLiveResource(pLinkage))
+			linkage = UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage));
+
 		ID3D11VertexShader *ret;
-		HRESULT hr = m_pDevice->CreateVertexShader(ShaderBytecode, (size_t)BytecodeLen,
-													UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)),
-													&ret);
+		HRESULT hr = m_pDevice->CreateVertexShader(ShaderBytecode, (size_t)BytecodeLen, linkage, &ret);
 
 		if(FAILED(hr))
 		{
@@ -1244,10 +1246,12 @@ bool WrappedID3D11Device::Serialise_CreateGeometryShader(
 	
 	if(m_State == READING)
 	{
+		ID3D11ClassLinkage *linkage = NULL;
+		if(GetResourceManager()->HasLiveResource(pLinkage))
+			linkage = UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage));
+
 		ID3D11GeometryShader *ret;
-		HRESULT hr = m_pDevice->CreateGeometryShader(ShaderBytecode, (size_t)BytecodeLen,
-													UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)),
-													&ret);
+		HRESULT hr = m_pDevice->CreateGeometryShader(ShaderBytecode, (size_t)BytecodeLen, linkage, &ret);
 
 		if(FAILED(hr))
 		{
@@ -1341,13 +1345,13 @@ bool WrappedID3D11Device::Serialise_CreateGeometryShaderWithStreamOutput(
 	
 	if(m_State == READING)
 	{
+		ID3D11ClassLinkage *linkage = NULL;
+		if(GetResourceManager()->HasLiveResource(pLinkage))
+			linkage = UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage));
+
 		ID3D11GeometryShader *ret;
 		HRESULT hr = m_pDevice->CreateGeometryShaderWithStreamOutput(ShaderBytecode, (size_t)BytecodeLen,
-														SODecl, numEntries,
-														BufStrides, numStrides,
-														RastStream,
-														UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)),
-														&ret);
+		                                           SODecl, numEntries, BufStrides, numStrides, RastStream, linkage, &ret);
 
 		if(FAILED(hr))
 		{
@@ -1439,10 +1443,12 @@ bool WrappedID3D11Device::Serialise_CreatePixelShader(
 	
 	if(m_State == READING)
 	{
+		ID3D11ClassLinkage *linkage = NULL;
+		if(GetResourceManager()->HasLiveResource(pLinkage))
+			linkage = UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage));
+
 		ID3D11PixelShader *ret;
-		HRESULT hr = m_pDevice->CreatePixelShader(ShaderBytecode, (size_t)BytecodeLen,
-													UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)),
-													&ret);
+		HRESULT hr = m_pDevice->CreatePixelShader(ShaderBytecode, (size_t)BytecodeLen, linkage, &ret);
 
 		if(FAILED(hr))
 		{
@@ -1521,10 +1527,12 @@ bool WrappedID3D11Device::Serialise_CreateHullShader(
 	
 	if(m_State == READING)
 	{
+		ID3D11ClassLinkage *linkage = NULL;
+		if(GetResourceManager()->HasLiveResource(pLinkage))
+			linkage = UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage));
+
 		ID3D11HullShader *ret;
-		HRESULT hr = m_pDevice->CreateHullShader(ShaderBytecode, (size_t)BytecodeLen,
-													UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)),
-													&ret);
+		HRESULT hr = m_pDevice->CreateHullShader(ShaderBytecode, (size_t)BytecodeLen, linkage, &ret);
 
 		if(FAILED(hr))
 		{
@@ -1603,10 +1611,12 @@ bool WrappedID3D11Device::Serialise_CreateDomainShader(
 	
 	if(m_State == READING)
 	{
+		ID3D11ClassLinkage *linkage = NULL;
+		if(GetResourceManager()->HasLiveResource(pLinkage))
+			linkage = UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage));
+
 		ID3D11DomainShader *ret;
-		HRESULT hr = m_pDevice->CreateDomainShader(ShaderBytecode, (size_t)BytecodeLen,
-													UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)),
-													&ret);
+		HRESULT hr = m_pDevice->CreateDomainShader(ShaderBytecode, (size_t)BytecodeLen, linkage, &ret);
 
 		if(FAILED(hr))
 		{
@@ -1685,10 +1695,12 @@ bool WrappedID3D11Device::Serialise_CreateComputeShader(
 
 	if(m_State == READING)
 	{
+		ID3D11ClassLinkage *linkage = NULL;
+		if(GetResourceManager()->HasLiveResource(pLinkage))
+			linkage = UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage));
+
 		ID3D11ComputeShader *ret;
-		HRESULT hr = m_pDevice->CreateComputeShader(ShaderBytecode, (size_t)BytecodeLen,
-													UNWRAP(WrappedID3D11ClassLinkage, (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage)),
-													&ret);
+		HRESULT hr = m_pDevice->CreateComputeShader(ShaderBytecode, (size_t)BytecodeLen, linkage, &ret);
 
 		if(FAILED(hr))
 		{
@@ -1770,7 +1782,7 @@ bool WrappedID3D11Device::Serialise_CreateClassInstance(LPCSTR pClassTypeName,
 	SERIALISE_ELEMENT(ResourceId, pLinkage, linkage->GetResourceID());
 	SERIALISE_ELEMENT(ResourceId, instance, GetIDForResource(inst));
 
-	if(m_State == READING)
+	if(m_State == READING && GetResourceManager()->HasLiveResource(pLinkage))
 	{
 		ID3D11ClassLinkage *wrappedLink = (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage);
 		ID3D11ClassLinkage *realLink = UNWRAP(WrappedID3D11ClassLinkage, wrappedLink);
@@ -1830,7 +1842,7 @@ bool WrappedID3D11Device::Serialise_GetClassInstance(LPCSTR pClassInstanceName,
 	SERIALISE_ELEMENT(ResourceId, pLinkage, linkage->GetResourceID());
 	SERIALISE_ELEMENT(ResourceId, instance, GetIDForResource(inst));
 	
-	if(m_State == READING)
+	if(m_State == READING && GetResourceManager()->HasLiveResource(pLinkage))
 	{
 		ID3D11ClassLinkage *wrappedLink = (ID3D11ClassLinkage *)GetResourceManager()->GetLiveResource(pLinkage);
 		ID3D11ClassLinkage *realLink = UNWRAP(WrappedID3D11ClassLinkage, wrappedLink);

renderdoc/driver/d3d11/d3d11_renderstate.cpp

@@ -440,20 +440,36 @@ void D3D11RenderState::Serialise(LogState m_State, WrappedID3D11Device *device)
 {
 	SERIALISE_ELEMENT(ResourceId, IALayout, GetIDForResource(IA.Layout));
 	if(m_State < WRITING)
-		IA.Layout = (ID3D11InputLayout *)device->GetResourceManager()->GetLiveResource(IALayout);
+	{
+		if(device->GetResourceManager()->HasLiveResource(IALayout))
+			IA.Layout = (ID3D11InputLayout *)device->GetResourceManager()->GetLiveResource(IALayout);
+		else
+			IA.Layout = NULL;
+	}
 
 	m_pSerialiser->Serialise("IA.Topo", IA.Topo);
 
 	SERIALISE_ELEMENT(ResourceId, IAIndexBuffer, GetIDForResource(IA.IndexBuffer));
 	if(m_State < WRITING)
-		IA.IndexBuffer = (ID3D11Buffer *)device->GetResourceManager()->GetLiveResource(IAIndexBuffer);
+	{
+		if(device->GetResourceManager()->HasLiveResource(IAIndexBuffer))
+			IA.IndexBuffer = (ID3D11Buffer *)device->GetResourceManager()->GetLiveResource(IAIndexBuffer);
+		else
+			IA.IndexBuffer = NULL;
+	}
 
 	for(int i=0; i < D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT; i++)
 	{
 		ResourceId VB;
 		if(m_State >= WRITING) VB = GetIDForResource(IA.VBs[i]);
 		m_pSerialiser->Serialise("IA.VBs", VB);
-		if(m_State < WRITING) IA.VBs[i] = (ID3D11Buffer *)device->GetResourceManager()->GetLiveResource(VB);
+		if(m_State < WRITING)
+		{
+			if(device->GetResourceManager()->HasLiveResource(VB))
+				IA.VBs[i] = (ID3D11Buffer *)device->GetResourceManager()->GetLiveResource(VB);
+			else
+				IA.VBs[i] = NULL;
+		}
 	}
 
 	m_pSerialiser->Serialise<D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT>("IA.Strides", IA.Strides);
@@ -467,14 +483,25 @@ void D3D11RenderState::Serialise(LogState m_State, WrappedID3D11Device *device)
 	{
 		SERIALISE_ELEMENT(ResourceId, Shader, GetIDForResource(sh->Shader));
 		if(m_State < WRITING)
-			sh->Shader = (ID3D11DeviceChild *)device->GetResourceManager()->GetLiveResource(Shader);
+		{
+			if(device->GetResourceManager()->HasLiveResource(Shader))
+				sh->Shader = (ID3D11DeviceChild *)device->GetResourceManager()->GetLiveResource(Shader);
+			else
+				sh->Shader = NULL;
+		}
 
 		for(int i=0; i < D3D11_COMMONSHADER_CONSTANT_BUFFER_API_SLOT_COUNT; i++)
 		{
 			ResourceId id;
 			if(m_State >= WRITING) id = GetIDForResource(sh->ConstantBuffers[i]);
 			m_pSerialiser->Serialise((string(names[s]) + ".ConstantBuffers").c_str(), id);
-			if(m_State < WRITING) sh->ConstantBuffers[i] = (ID3D11Buffer *)device->GetResourceManager()->GetLiveResource(id);
+			if(m_State < WRITING)
+			{
+				if(device->GetResourceManager()->HasLiveResource(id))
+					sh->ConstantBuffers[i] = (ID3D11Buffer *)device->GetResourceManager()->GetLiveResource(id);
+				else
+					sh->ConstantBuffers[i] = NULL;
+			}
 			
 			m_pSerialiser->Serialise((string(names[s]) + ".CBOffsets").c_str(), sh->CBOffsets[i]);
 			m_pSerialiser->Serialise((string(names[s]) + ".CBCounts").c_str(), sh->CBCounts[i]);
@@ -485,7 +512,13 @@ void D3D11RenderState::Serialise(LogState m_State, WrappedID3D11Device *device)
 			ResourceId id;
 			if(m_State >= WRITING) id = GetIDForResource(sh->Samplers[i]);
 			m_pSerialiser->Serialise((string(names[s]) + ".Samplers").c_str(), id);
-			if(m_State < WRITING) sh->Samplers[i] = (ID3D11SamplerState *)device->GetResourceManager()->GetLiveResource(id);
+			if(m_State < WRITING)
+			{
+				if(device->GetResourceManager()->HasLiveResource(id)) 
+					sh->Samplers[i] = (ID3D11SamplerState *)device->GetResourceManager()->GetLiveResource(id);
+				else
+					sh->Samplers[i] = NULL;
+			}
 		}
 
 		for(int i=0; i < D3D11_COMMONSHADER_INPUT_RESOURCE_SLOT_COUNT; i++)
@@ -493,7 +526,13 @@ void D3D11RenderState::Serialise(LogState m_State, WrappedID3D11Device *device)
 			ResourceId id;
 			if(m_State >= WRITING) id = GetIDForResource(sh->SRVs[i]);
 			m_pSerialiser->Serialise((string(names[s]) + ".SRVs").c_str(), id);
-			if(m_State < WRITING) sh->SRVs[i] = (ID3D11ShaderResourceView *)device->GetResourceManager()->GetLiveResource(id);
+			if(m_State < WRITING)
+			{
+				if(device->GetResourceManager()->HasLiveResource(id)) 
+					sh->SRVs[i] = (ID3D11ShaderResourceView *)device->GetResourceManager()->GetLiveResource(id);
+				else
+					sh->SRVs[i] = NULL;
+			}
 		}
 
 		for(int i=0; i < D3D11_PS_CS_UAV_REGISTER_COUNT; i++)
@@ -501,7 +540,13 @@ void D3D11RenderState::Serialise(LogState m_State, WrappedID3D11Device *device)
 			ResourceId id;
 			if(m_State >= WRITING) id = GetIDForResource(sh->UAVs[i]);
 			m_pSerialiser->Serialise((string(names[s]) + ".UAVs").c_str(), id);
-			if(m_State < WRITING) sh->UAVs[i] = (ID3D11UnorderedAccessView *)device->GetResourceManager()->GetLiveResource(id);
+			if(m_State < WRITING)
+			{
+				if(device->GetResourceManager()->HasLiveResource(id)) 
+					sh->UAVs[i] = (ID3D11UnorderedAccessView *)device->GetResourceManager()->GetLiveResource(id);
+				else
+					sh->UAVs[i] = NULL;
+			}
 		}
 		
 		for(int i=0; i < D3D11_SHADER_MAX_INTERFACES; i++)
@@ -509,7 +554,13 @@ void D3D11RenderState::Serialise(LogState m_State, WrappedID3D11Device *device)
 			ResourceId id;
 			if(m_State >= WRITING) id = GetIDForResource(sh->Instances[i]);
 			m_pSerialiser->Serialise((string(names[s]) + ".Instances").c_str(), id);
-			if(m_State < WRITING) sh->Instances[i] = (ID3D11ClassInstance *)device->GetResourceManager()->GetLiveResource(id);
+			if(m_State < WRITING)
+			{
+				if(device->GetResourceManager()->HasLiveResource(id)) 
+					sh->Instances[i] = (ID3D11ClassInstance *)device->GetResourceManager()->GetLiveResource(id);
+				else
+					sh->Instances[i] = NULL;
+			}
 		}
 
 		sh++;
@@ -520,14 +571,25 @@ void D3D11RenderState::Serialise(LogState m_State, WrappedID3D11Device *device)
 		ResourceId id;
 		if(m_State >= WRITING) id = GetIDForResource(SO.Buffers[i]);
 		m_pSerialiser->Serialise("SO.Buffers", id);
-		if(m_State < WRITING) SO.Buffers[i] = (ID3D11Buffer *)device->GetResourceManager()->GetLiveResource(id);
+		if(m_State < WRITING)
+		{
+			if(device->GetResourceManager()->HasLiveResource(id)) 
+				SO.Buffers[i] = (ID3D11Buffer *)device->GetResourceManager()->GetLiveResource(id);
+			else
+				SO.Buffers[i] = NULL;
+		}
 
 		m_pSerialiser->Serialise("SO.Offsets", SO.Offsets[i]);
 	}
 
 	SERIALISE_ELEMENT(ResourceId, RSState, GetIDForResource(RS.State));
 	if(m_State < WRITING)
-		RS.State = (ID3D11RasterizerState *)device->GetResourceManager()->GetLiveResource(RSState);
+	{
+		if(device->GetResourceManager()->HasLiveResource(RSState)) 
+			RS.State = (ID3D11RasterizerState *)device->GetResourceManager()->GetLiveResource(RSState);
+		else
+			RS.State = NULL;
+	}
 
 	m_pSerialiser->Serialise("RS.NumViews", RS.NumViews);
 	m_pSerialiser->Serialise("RS.NumScissors", RS.NumScissors);
@@ -536,20 +598,35 @@ void D3D11RenderState::Serialise(LogState m_State, WrappedID3D11Device *device)
 	
 	SERIALISE_ELEMENT(ResourceId, OMDepthStencilState, GetIDForResource(OM.DepthStencilState));
 	if(m_State < WRITING)
-		OM.DepthStencilState = (ID3D11DepthStencilState *)device->GetResourceManager()->GetLiveResource(OMDepthStencilState);
+	{
+		if(device->GetResourceManager()->HasLiveResource(OMDepthStencilState)) 
+			OM.DepthStencilState = (ID3D11DepthStencilState *)device->GetResourceManager()->GetLiveResource(OMDepthStencilState);
+		else
+			OM.DepthStencilState = NULL;
+	}
 
 	m_pSerialiser->Serialise("OM.StencRef", OM.StencRef);
 
 	SERIALISE_ELEMENT(ResourceId, OMBlendState, GetIDForResource(OM.BlendState));
 	if(m_State < WRITING)
-		OM.BlendState = (ID3D11BlendState *)device->GetResourceManager()->GetLiveResource(OMBlendState);
+	{
+		if(device->GetResourceManager()->HasLiveResource(OMBlendState)) 
+			OM.BlendState = (ID3D11BlendState *)device->GetResourceManager()->GetLiveResource(OMBlendState);
+		else
+			OM.BlendState = NULL;
+	}
 
 	m_pSerialiser->Serialise<4>("OM.BlendFactor", OM.BlendFactor);
 	m_pSerialiser->Serialise("OM.SampleMask", OM.SampleMask);
 
 	SERIALISE_ELEMENT(ResourceId, OMDepthView, GetIDForResource(OM.DepthView));
 	if(m_State < WRITING)
-		OM.DepthView = (ID3D11DepthStencilView *)device->GetResourceManager()->GetLiveResource(OMDepthView);
+	{
+		if(device->GetResourceManager()->HasLiveResource(OMDepthView)) 
+			OM.DepthView = (ID3D11DepthStencilView *)device->GetResourceManager()->GetLiveResource(OMDepthView);
+		else
+			OM.DepthView = NULL;
+	}
 
 	m_pSerialiser->Serialise("OM.UAVStartSlot", OM.UAVStartSlot);
 
@@ -558,7 +635,13 @@ void D3D11RenderState::Serialise(LogState m_State, WrappedID3D11Device *device)
 		ResourceId UAV;
 		if(m_State >= WRITING) UAV = GetIDForResource(OM.UAVs[i]);
 		m_pSerialiser->Serialise("OM.UAVs", UAV);
-		if(m_State < WRITING) OM.UAVs[i] = (ID3D11UnorderedAccessView *)device->GetResourceManager()->GetLiveResource(UAV);
+		if(m_State < WRITING)
+		{
+			if(device->GetResourceManager()->HasLiveResource(UAV)) 
+				OM.UAVs[i] = (ID3D11UnorderedAccessView *)device->GetResourceManager()->GetLiveResource(UAV);
+			else
+				OM.UAVs[i] = NULL;
+		}
 	}
 
 	for(int i=0; i < D3D11_SIMULTANEOUS_RENDER_TARGET_COUNT; i++)
@@ -566,7 +649,13 @@ void D3D11RenderState::Serialise(LogState m_State, WrappedID3D11Device *device)
 		ResourceId RTV;
 		if(m_State >= WRITING) RTV = GetIDForResource(OM.RenderTargets[i]);
 		m_pSerialiser->Serialise("OM.RenderTargets", RTV);
-		if(m_State < WRITING) OM.RenderTargets[i] = (ID3D11RenderTargetView *)device->GetResourceManager()->GetLiveResource(RTV);
+		if(m_State < WRITING)
+		{
+			if(device->GetResourceManager()->HasLiveResource(RTV)) 
+				OM.RenderTargets[i] = (ID3D11RenderTargetView *)device->GetResourceManager()->GetLiveResource(RTV);
+			else
+				OM.RenderTargets[i] = NULL;
+		}
 	}
 
 	if(m_State < WRITING)

renderdoc/driver/d3d11/d3d11_replay.cpp

@@ -289,16 +289,22 @@ ShaderReflection *D3D11Replay::GetShader(ResourceId id)
 
 void D3D11Replay::FreeTargetResource(ResourceId id)
 {
-	ID3D11DeviceChild *resource = m_pDevice->GetResourceManager()->GetLiveResource(id);
+	if(m_pDevice->GetResourceManager()->HasLiveResource(id))
+	{
+		ID3D11DeviceChild *resource = m_pDevice->GetResourceManager()->GetLiveResource(id);
 
-	SAFE_RELEASE(resource);
+		SAFE_RELEASE(resource);
+	}
 }
 
 void D3D11Replay::FreeCustomShader(ResourceId id)
 {
-	ID3D11DeviceChild *resource = m_pDevice->GetResourceManager()->GetLiveResource(id);
+	if(m_pDevice->GetResourceManager()->HasLiveResource(id))
+	{
+		ID3D11DeviceChild *resource = m_pDevice->GetResourceManager()->GetLiveResource(id);
 
-	SAFE_RELEASE(resource);
+		SAFE_RELEASE(resource);
+	}
 }
 
 vector<FetchFrameRecord> D3D11Replay::GetFrameRecord()