//Shutdown Buffers Function (Release Index and Vertex Buffer)
void CModel::ShutdownBuffers() {

	ModelProperties* currentModel = GetModel();

	//Get List of SubMeshs
	vector<CMesh::SubMesh*> subMeshList = currentModel->Mesh->GetSubMeshList();

	//Iterate through SubMeshes
	for (int subMeshCount = 0; subMeshCount < currentModel->Mesh->GetSubMeshNum(); subMeshCount++) {
		CMesh::SubMesh* currentMesh = subMeshList[subMeshCount];

		ID3D11Buffer* VertexBuffer = currentMesh->VertexBuffer;
		ID3D11Buffer* IndexBuffer = currentMesh->IndexBuffer;

		//Release Buffers
		if (IndexBuffer) {
			IndexBuffer->Release();
			IndexBuffer = 0;
		}

		if (VertexBuffer) {
			VertexBuffer->Release();
			VertexBuffer = 0;
		}

	}

	return;
}
Beispiel #2
0
MF_API void MFVertex_UnlockIndexBuffer(MFIndexBuffer *pIndexBuffer)
{
	MFDebug_Assert(pIndexBuffer, "NULL index buffer");
	MFDebug_Assert(pIndexBuffer->bLocked, "Index buffer not locked!");

	ID3D11Buffer *pIB = (ID3D11Buffer*)pIndexBuffer->pPlatformData;
	if(pIB)
		pIB->Release();

	D3D11_BUFFER_DESC bd;
	MFZeroMemory(&bd, sizeof(bd));
	bd.Usage = D3D11_USAGE_IMMUTABLE;
	bd.ByteWidth = sizeof(WORD) * pIndexBuffer->numIndices;
	bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
	
	D3D11_SUBRESOURCE_DATA initData;
	MFZeroMemory(&initData, sizeof(initData));
	initData.pSysMem = pIndexBuffer->pLocked;

	HRESULT hr = g_pd3dDevice->CreateBuffer(&bd, &initData, &pIB);
	MFDebug_Assert(SUCCEEDED(hr), "Couldn't create index buffer!");
	if (FAILED(hr))
		return;

	pIndexBuffer->pPlatformData = pIB;

	MFHeap_Free(pIndexBuffer->pLocked);

	pIndexBuffer->pLocked = NULL;
	pIndexBuffer->bLocked = false;
}
// Create vertex/index buffers
HRESULT CFW1GlyphVertexDrawer::createBuffers() {
	// Create vertex buffer
	D3D11_BUFFER_DESC vertexBufferDesc;
	ID3D11Buffer *pVertexBuffer;
	
	ZeroMemory(&vertexBufferDesc, sizeof(vertexBufferDesc));
	vertexBufferDesc.ByteWidth = m_vertexBufferSize;
	vertexBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
	vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
	vertexBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
	
	HRESULT hResult = m_pDevice->CreateBuffer(&vertexBufferDesc, NULL, &pVertexBuffer);
	if(FAILED(hResult)) {
		m_lastError = L"Failed to create vertex buffer";
	}
	else {
		// Create index buffer
		D3D11_BUFFER_DESC indexBufferDesc;
		D3D11_SUBRESOURCE_DATA initData;
		ID3D11Buffer *pIndexBuffer;
		
		ZeroMemory(&indexBufferDesc, sizeof(indexBufferDesc));
		indexBufferDesc.ByteWidth = sizeof(UINT16) * m_maxIndexCount;
		indexBufferDesc.Usage = D3D11_USAGE_IMMUTABLE;
		indexBufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
		
		UINT16 *indices = new UINT16[m_maxIndexCount];
		for(UINT i=0; i < m_maxIndexCount/6; ++i) {
			indices[i*6] = static_cast<UINT16>(i*4);
			indices[i*6+1] = static_cast<UINT16>(i*4+1);
			indices[i*6+2] = static_cast<UINT16>(i*4+2);
			indices[i*6+3] = static_cast<UINT16>(i*4+1);
			indices[i*6+4] = static_cast<UINT16>(i*4+3);
			indices[i*6+5] = static_cast<UINT16>(i*4+2);
		}
		
		ZeroMemory(&initData, sizeof(initData));
		initData.pSysMem = indices;
		
		hResult = m_pDevice->CreateBuffer(&indexBufferDesc, &initData, &pIndexBuffer);
		if(FAILED(hResult)) {
			m_lastError = L"Failed to create index buffer";
		}
		else {
			// Success
			m_pVertexBuffer = pVertexBuffer;
			m_pIndexBuffer = pIndexBuffer;
			
			hResult = S_OK;
		}
		
		delete[] indices;
		
		if(FAILED(hResult))
			pVertexBuffer->Release();
	}
	
	return hResult;
}
Beispiel #4
0
VertexBufferState MyD3DAssets::getActiveVertexBuffer()
{
    VertexBufferState result;
    ID3D11Buffer *buffer;
    context->base->IAGetVertexBuffers(0, 1, &buffer, &result.stride, &result.offset);
    result.buffer = getBuffer(buffer);
    buffer->Release();
    return result;
}
Beispiel #5
0
IndexBufferState MyD3DAssets::getActiveIndexBuffer()
{
    IndexBufferState result;
    ID3D11Buffer *buffer;
    context->base->IAGetIndexBuffer(&buffer, nullptr, &result.offset);
    result.buffer = getBuffer(buffer);
    buffer->Release();
    return result;
}
void services::Direct3D11Graphics::draw(
	const Vertex vertexes[],
	int vertexesSize,
	const wchar_t* texture,
	void* vertex,
	void* geometry,
	void* pixel
)
{
	ID3D11Buffer* vertexBuffer;
	ID3D11ShaderResourceView* texResource;
	
	loadTexture( texture, texResource );
	setShaderResource( (UINT16)pixel, 0, texResource );

	D3D11_SAMPLER_DESC samplerDesc;
	samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
	samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
	samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
	samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
	samplerDesc.MipLODBias = 0;
	samplerDesc.MaxAnisotropy = 0;
	samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
	samplerDesc.BorderColor[0] = 0.f;
	samplerDesc.BorderColor[1] = 0.f;
	samplerDesc.BorderColor[2] = 0.f;
	samplerDesc.BorderColor[3] = 0.f;
	samplerDesc.MinLOD = 0;
	samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
	setSamplerState( (UINT16)pixel, 0, samplerDesc );

	if ( (UINT16)vertex != _currentVertex && vertex >= 0 )
	{
		_currentVertex = (UINT16)vertex;
		useShader<ID3D11VertexShader>( (UINT16)vertex );
	}
	if ( (UINT16)geometry != _currentGeometry && geometry >= 0 )
	{
		_currentGeometry = (UINT16)geometry;
		useShader<ID3D11GeometryShader>( (UINT16)geometry );
	}
	useShader<ID3D11PixelShader>( (UINT16)pixel );

	_createVertexBuffer( vertexes, vertexesSize, vertexBuffer );

	_deviceContext->IASetPrimitiveTopology(
		D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST
	);
	
	// Draw
	_deviceContext->Draw( vertexesSize, 0 );

	// Clean
	vertexBuffer->Release();
};
Beispiel #7
0
	int Release() {
		if (VS)
			VS->Release();
		if (PS)
			PS->Release();
		if (inputLayout)
			inputLayout->Release();
		if (vertexBuffer)
			vertexBuffer->Release();
		return 0;
	}
Beispiel #8
0
const BufferCPU* MyD3DAssets::getPSConstantBuffer()
{
    ID3D11Buffer *constantBuffer = nullptr;
    context->base->PSGetConstantBuffers(0, 1, &constantBuffer);

    if (constantBuffer == nullptr)
    {
        return nullptr;
    }

    if (buffers.count((UINT64)constantBuffer) == 0)
    {
        g_logger->logErrorFile << "Failed to find buffer: " << constantBuffer << endl;
        constantBuffer->Release();
        return nullptr;
    }

    constantBuffer->Release();
    return buffers.find((UINT64)constantBuffer)->second;
}
Beispiel #9
0
DX11ScratchStructuredArray::DX11ScratchStructuredArray(const FromElementSize& arguments):
element_count_(arguments.element_count),
element_size_(arguments.element_size){

	ID3D11Buffer* buffer;
	ID3D11Buffer* staging;

	ID3D11ShaderResourceView* srv;
	ID3D11UnorderedAccessView* uav;

	auto& device = *DX11Graphics::GetInstance().GetDevice();



	THROW_ON_FAIL(::MakeStagingBuffer(device,
									  static_cast<unsigned int>(element_count_),
									  static_cast<unsigned int>(element_size_),
									  true,
									  &staging));

	auto guard = make_scope_guard([&staging] {

		if (staging) {

			staging->Release();

		}

	});

	THROW_ON_FAIL(::MakeStructuredBuffer(device,
										 static_cast<unsigned int>(element_count_),
										 static_cast<unsigned int>(element_size_),
										 false,
										 &buffer,
										 &srv,
										 &uav));

	shader_resource_view_ = COMMove(&srv);
	unordered_access_view_ = COMMove(&uav);
	buffer_ = COMMove(&buffer);
	readback_buffer_ = COMMove(&staging);

	raw_buffer_ = new char[element_size_ * element_count_];

	guard.Dismiss();

}
Beispiel #10
0
unsigned int queryVSInvocations(ID3D11Device* device, ID3D11DeviceContext* context, const unsigned int* indices, size_t index_count)
{
	if (index_count == 0)
		return 0;

	ID3D11Buffer* ib = 0;

	{
		D3D11_BUFFER_DESC bd = {};

		bd.Usage = D3D11_USAGE_DYNAMIC;
		bd.ByteWidth = index_count * 4;
		bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
		bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;

		device->CreateBuffer(&bd, 0, &ib);

		D3D11_MAPPED_SUBRESOURCE ms;
		context->Map(ib, 0, D3D11_MAP_WRITE_DISCARD, 0, &ms);
		memcpy(ms.pData, indices, index_count * 4);
		context->Unmap(ib, 0);
	}

	context->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	context->IASetIndexBuffer(ib, DXGI_FORMAT_R32_UINT, 0);

	D3D11_QUERY_DESC qdesc = {D3D11_QUERY_PIPELINE_STATISTICS};
	ID3D11Query* query = 0;
	device->CreateQuery(&qdesc, &query);

	context->Begin(query);
	context->DrawIndexed(index_count, 0, 0);
	context->End(query);

	D3D11_QUERY_DATA_PIPELINE_STATISTICS stats = {};
	while (S_FALSE == context->GetData(query, &stats, sizeof(stats), 0))
		;

	query->Release();
	ib->Release();

	assert(stats.IAVertices == index_count);

	return stats.VSInvocations;
}
Beispiel #11
0
void TgcDX11Effect::dispose()
{
	//Constant buffers
	for (unordered_map<string, ID3D11Buffer*>::iterator it = this->dxConstantBuffers.begin(); it != this->dxConstantBuffers.end(); ++it) 
	{
		ID3D11Buffer* cBuffer = it->second;
		if(cBuffer)
		{
			cBuffer->Release();
			cBuffer = 0;
		}
	}

	//Sampler states
	for (unordered_map<string, ID3D11SamplerState*>::iterator it = this->dxSampleStates.begin(); it != this->dxSampleStates.end(); ++it) 
	{
		ID3D11SamplerState* sampler = it->second;
		if(sampler)
		{
			sampler->Release();
			sampler = 0;
		}
	}

	//vertexShaderBuffer
	if(this->vertexShaderBuffer)
	{
		this->vertexShaderBuffer->Release();
		this->vertexShaderBuffer = 0;
	}

	//vertexShader
	if(this->vertexShader)
	{
		this->vertexShader->Release();
		this->vertexShader = 0;
	}

	//pixelShader
	if(this->pixelShader)
	{
		this->pixelShader->Release();
		this->pixelShader = 0;
	}
}
void services::Direct3D11Graphics::createConstantBuffer(
	UINT16 shader,
	UINT16 slot,
	int size
)
{
	D3D11_BUFFER_DESC bufferDesc;
	HRESULT hr;
	ID3D11Buffer* buffer;
	pair<map<UINT16, ID3D11Buffer*>::const_iterator, bool> ret;

	map<UINT16, map<UINT16, ID3D11Buffer*>>::iterator constBuffer =
		_constantBuffers.find( shader );
	if ( constBuffer == _constantBuffers.end() )
	{
		throw;
	}
	
	bufferDesc.ByteWidth = size;
	bufferDesc.Usage = D3D11_USAGE_DEFAULT;
	bufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
	bufferDesc.CPUAccessFlags = 0;
	bufferDesc.MiscFlags = 0;
	bufferDesc.StructureByteStride = 0;
	
	hr = _device->CreateBuffer( &bufferDesc, 0, &buffer );

	if ( FAILED(hr) )
	{
		throw "Erreur buffer matrice";
	}

	ret = constBuffer->second.insert(
		pair<UINT16, ID3D11Buffer*>(
			slot,
			buffer
		)
	);
	if ( !ret.second )
	{
		buffer->Release();
		throw;
	}
};
Beispiel #13
0
void DebugDraw::DrawAll(bool changesTyplogyBack)
{
	if (numVerts > 0) {
		//Ge the old typology so we can set it back.
		D3D11_PRIMITIVE_TOPOLOGY oldTypology;
		deviceContext->IAGetPrimitiveTopology(&oldTypology);

		D3D11_BUFFER_DESC vbd;
		vbd.Usage = D3D11_USAGE_DYNAMIC;
		vbd.ByteWidth = sizeof(DebugVertex) * numVerts;
		vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
		vbd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
		vbd.MiscFlags = 0;
		vbd.StructureByteStride = 0;

		D3D11_SUBRESOURCE_DATA initialVertexData;
		initialVertexData.pSysMem = vertices;
		ID3D11Buffer* vertexBuffer;
		device->CreateBuffer(&vbd, &initialVertexData, &vertexBuffer);

		UINT stride = sizeof(DebugVertex);
		UINT offset = 0;
		deviceContext->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);

		deviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
		vertexShader->SetMatrix4x4(0, DirectX::XMFLOAT4X4(1, 0, 0, 0,
			0, 1, 0, 0,
			0, 0, 1, 0,
			0, 0, 0, 1));
		vertexShader->SetMatrix4x4(1, camera->GetViewMatrix());
		vertexShader->SetMatrix4x4(2, camera->GetProjectionMatrix());
		vertexShader->SetShader(true);
		pixelShader->SetShader(true);
		deviceContext->Draw(numVerts, 0);
		if (changesTyplogyBack) {
			deviceContext->IASetPrimitiveTopology(oldTypology);
		}
		vertexBuffer->Release();
		numVerts = 0;
	}
}
Beispiel #14
0
MF_API void MFVertex_UnlockVertexBuffer(MFVertexBuffer *pVertexBuffer)
{
	MFDebug_Assert(pVertexBuffer, "Null vertex buffer");

	ID3D11Buffer *pVB = (ID3D11Buffer*)pVertexBuffer->pPlatformData;
	if(pVertexBuffer->bufferType == MFVBType_Dynamic)
	{
		g_pImmediateContext->Unmap(pVB, 0);
	}
	else
	{
		if(pVB)
			pVB->Release();

		D3D11_BUFFER_DESC bd;
		MFZeroMemory(&bd, sizeof(bd));
		bd.Usage = D3D11_USAGE_IMMUTABLE;
		bd.ByteWidth = pVertexBuffer->pVertexDeclatation->pElementData[0].stride * pVertexBuffer->numVerts;
		bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;

		D3D11_SUBRESOURCE_DATA initData;
		MFZeroMemory(&initData, sizeof(initData));
		initData.pSysMem = pVertexBuffer->pLocked;
	
		HRESULT hr = g_pd3dDevice->CreateBuffer(&bd, &initData, &pVB);
		MFDebug_Assert(SUCCEEDED(hr), "Couldn't create vertex buffer!");
		if(FAILED(hr))
		{
			pVertexBuffer->pPlatformData = NULL;
			return;
		}

		pVertexBuffer->pPlatformData = pVB;

		MFHeap_Free(pVertexBuffer->pLocked);
	}

	pVertexBuffer->pLocked = NULL;
	pVertexBuffer->bLocked = false;
}
static ID3D11Buffer *
genTextureBuffer(ID3D11DeviceContext *deviceContext, int size, void const * data) {

    D3D11_BUFFER_DESC hBufferDesc;
    hBufferDesc.ByteWidth = size;
    hBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    hBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_SHADER_RESOURCE;
    hBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    hBufferDesc.MiscFlags = 0;
    hBufferDesc.StructureByteStride = sizeof(float);

    HRESULT hr;
    ID3D11Buffer *buffer;
    ID3D11Device *device;
    deviceContext->GetDevice(&device);
    hr = device->CreateBuffer(&hBufferDesc, NULL, &buffer);
    if (FAILED(hr)) {
        Far::Error(Far::FAR_RUNTIME_ERROR,
                 "Fail in CreateBuffer\n");
        return 0;
    }

    D3D11_MAPPED_SUBRESOURCE resource;
    hr = deviceContext->Map(buffer, 0,
                            D3D11_MAP_WRITE_DISCARD, 0, &resource);
    if (FAILED(hr)) {
        Far::Error(Far::FAR_RUNTIME_ERROR,
                 "Fail in Map buffer\n");
        buffer->Release();
        return 0;
    }
    memcpy(resource.pData, data, size);
    deviceContext->Unmap(buffer, 0);

    return buffer;
}
Beispiel #16
0
void MFVertex_DestroyIndexBufferPlatformSpecific(MFIndexBuffer *pIndexBuffer)
{
	ID3D11Buffer *pIB = (ID3D11Buffer*)pIndexBuffer->pPlatformData;
	if(pIB)
		pIB->Release();
}
Beispiel #17
0
void MFVertex_DestroyVertexBufferPlatformSpecific(MFVertexBuffer *pVertexBuffer)
{
	ID3D11Buffer *pVB = (ID3D11Buffer*)pVertexBuffer->pPlatformData;
	if(pVB)
		pVB->Release();
}
	virtual ~dx11ShaderBufferCache()
	{
		if (VBO)
			VBO->Release();
	}
Beispiel #19
0
void SuzanneDX::RenderShadowMaps()
{
	D3D11_TEXTURE2D_DESC shadowMapDesc;
	ZeroMemory(&shadowMapDesc, sizeof(shadowMapDesc));
	shadowMapDesc.Width = SHADOW_RESOLUTION;
	shadowMapDesc.Height = SHADOW_RESOLUTION;
	shadowMapDesc.MipLevels = 1;
	shadowMapDesc.ArraySize = 1;
	shadowMapDesc.Format = DXGI_FORMAT_R24G8_TYPELESS;
	shadowMapDesc.SampleDesc.Count = 1;
	shadowMapDesc.SampleDesc.Quality = 0;
	shadowMapDesc.Usage = D3D11_USAGE_DEFAULT;
	shadowMapDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE;
	shadowMapDesc.CPUAccessFlags = 0;
	shadowMapDesc.MiscFlags = 0;

	D3D11_DEPTH_STENCIL_VIEW_DESC shadowMapDsvDesc;
	ZeroMemory(&shadowMapDsvDesc, sizeof(shadowMapDsvDesc));
	shadowMapDsvDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
	shadowMapDsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
	shadowMapDsvDesc.Texture2D.MipSlice = 0;

	D3D11_SHADER_RESOURCE_VIEW_DESC shadowMapResourceDesc;
	ZeroMemory(&shadowMapResourceDesc, sizeof(shadowMapResourceDesc));
	shadowMapResourceDesc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS;
	shadowMapResourceDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
	shadowMapResourceDesc.Texture2D.MipLevels = 1;
	shadowMapResourceDesc.Texture2D.MostDetailedMip = 0;

	D3D11_VIEWPORT shadowMapViewport;
	shadowMapViewport.Width = (FLOAT)SHADOW_RESOLUTION;
	shadowMapViewport.Height = (FLOAT)SHADOW_RESOLUTION;
	shadowMapViewport.MinDepth = 0.0f;
	shadowMapViewport.MaxDepth = 1.0f;
	shadowMapViewport.TopLeftX = 0;
	shadowMapViewport.TopLeftY = 0;
	mDeviceContext->RSSetViewports(1, &shadowMapViewport);

	XMMATRIX shadowViewProjectionMatrices[NUMBER_OF_LIGHTS];
	for (int i = 0; i < NUMBER_OF_LIGHTS; ++i)
	{
		ID3D11Texture2D* shadowMap;
		mDevice->CreateTexture2D(&shadowMapDesc, NULL, &shadowMap);

		ID3D11DepthStencilView* shadowMapDsv;
		mDevice->CreateDepthStencilView(shadowMap, &shadowMapDsvDesc, &shadowMapDsv);

		mDevice->CreateShaderResourceView(shadowMap, &shadowMapResourceDesc, &shadowMapResources[i]);

		mDeviceContext->OMSetRenderTargets(0, 0, shadowMapDsv);
		mDeviceContext->ClearDepthStencilView(shadowMapDsv, D3D11_CLEAR_DEPTH, 1.0f, 0);

		XMVECTOR lightInvDir = XMVector3Normalize(XMVectorSet(lighting.lights[i].position.x, lighting.lights[i].position.y, lighting.lights[i].position.z, 1.0f));
		XMMATRIX shadowProjectionMatrix = XMMatrixOrthographicRH(20, 20, -10, 20);
		XMMATRIX shadowViewMatrix = XMMatrixLookAtRH(lightInvDir, XMVectorSet(0, 0, 0, 1), XMVectorSet(0, 1, 0, 1));
		shadowViewProjectionMatrices[i] = shadowViewMatrix * shadowProjectionMatrix;

		ID3D11Buffer* shadowViewProjectionMatrixBuffer = DXUtil::CreateMatrixBuffer(mDevice, shadowViewProjectionMatrices[i]);
		mDeviceContext->VSSetConstantBuffers(shadowViewProjectionMatrixBufferSlot, 1, &shadowViewProjectionMatrixBuffer);

		UINT stride = sizeof(Vertex);
		UINT offset = 0;
		for (ModelDX model : models)
		{
			mDeviceContext->IASetVertexBuffers(0, 1, &model.vertexBuffer, &stride, &offset);
			mDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
			mDeviceContext->IASetInputLayout(model.inputLayout);

			mDeviceContext->VSSetShader(shadowVertexShader, 0, 0);
			mDeviceContext->PSSetShader(shadowPixelShader, 0, 0);

			mDeviceContext->VSSetConstantBuffers(modelMatrixBufferSlot, 1, &model.modelMatrixBuffer);

			mDeviceContext->Draw(model.vertexCount, 0);
		}

		shadowMap->Release();
		shadowMapDsv->Release();
		shadowViewProjectionMatrixBuffer->Release();
	}

	mDeviceContext->OMSetRenderTargets(1, &mRenderTargetView, mDepthStencilView);
	mDeviceContext->RSSetViewports(1, &mViewport);

	D3D11_BUFFER_DESC matrixDesc;
	ZeroMemory(&matrixDesc, sizeof(matrixDesc));
	matrixDesc.ByteWidth = sizeof(XMMATRIX) * NUMBER_OF_LIGHTS;
	matrixDesc.Usage = D3D11_USAGE_DEFAULT;
	matrixDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
	matrixDesc.CPUAccessFlags = 0;

	D3D11_SUBRESOURCE_DATA matrixData;
	ZeroMemory(&matrixData, sizeof(matrixData));
	matrixData.pSysMem = &shadowViewProjectionMatrices[0];

	ID3D11Buffer* matrixBuffer;
	mDevice->CreateBuffer(&matrixDesc, &matrixData, &matrixBuffer);

	mDeviceContext->VSSetConstantBuffers(shadowViewProjectionMatrixBufferSlot, 1, &matrixBuffer);
	matrixBuffer->Release();

	XMMATRIX biasMatrix = XMMatrixSet(
		0.5, 0.0, 0.0, 0.0,
		0.0, 0.5, 0.0, 0.0,
		0.0, 0.0, 1.0, 0.0,
		0.5, 0.5, 0.0, 1.0
		);

	ID3D11Buffer* shadowBiasMatrixBuffer = DXUtil::CreateMatrixBuffer(mDevice, biasMatrix);
	mDeviceContext->VSSetConstantBuffers(shadowBiasMatrixBufferSlot, 1, &shadowBiasMatrixBuffer);
	shadowBiasMatrixBuffer->Release();
}
Beispiel #20
0
bool SuzanneDX::InitScene()
{
	XMStoreFloat4(&up, XMVectorSet(0.0f, 1.0f, 0.0f, 1.0f));
	XMStoreFloat4(&eye, XMVectorSet(3.0f, 3.0f, 5.0f, 1.0f));
	XMStoreFloat4(&right, XMVectorSet(1.0f, 0.0f, 0.0f, 1.0f));
	XMStoreFloat4(&center, XMVectorSet(0.0f, 0.0f, 0.0f, 1.0f));

	ID3D11RasterizerState1 *rasterizerState;
	D3D11_RASTERIZER_DESC1 rasterizerDesc;
	ZeroMemory(&rasterizerDesc, sizeof(rasterizerDesc));
	rasterizerDesc.CullMode = D3D11_CULL_BACK;
	rasterizerDesc.FillMode = D3D11_FILL_SOLID;
	rasterizerDesc.FrontCounterClockwise = true;

	mDevice->CreateRasterizerState1(&rasterizerDesc, &rasterizerState);
	mDeviceContext->RSSetState(rasterizerState);
	rasterizerState->Release();

	// COMPILE SHADERS
	D3DCompileFromFile(Util::s2ws(shaderPath + "TestSceneVert.hlsl").c_str(), NULL, NULL, "vertexShader", "vs_5_0", NULL, NULL, &vertexShaderBuffer, NULL);
	D3DCompileFromFile(Util::s2ws(shaderPath + "TestSceneFrag.hlsl").c_str(), NULL, NULL, "pixelShader", "ps_5_0", NULL, NULL, &pixelShaderBuffer, NULL);
	mDevice->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertexShader);
	mDevice->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixelShader);

	D3DCompileFromFile(Util::s2ws(shaderPath + "ShadowMappingVert.hlsl").c_str(), NULL, NULL, "vertexShader", "vs_5_0", NULL, NULL, &shadowVertexShaderBuffer, NULL);
	D3DCompileFromFile(Util::s2ws(shaderPath + "ShadowMappingFrag.hlsl").c_str(), NULL, NULL, "pixelShader", "ps_5_0", NULL, NULL, &shadowPixelShaderBuffer, NULL);
	mDevice->CreateVertexShader(shadowVertexShaderBuffer->GetBufferPointer(), shadowVertexShaderBuffer->GetBufferSize(), NULL, &shadowVertexShader);
	mDevice->CreatePixelShader(shadowPixelShaderBuffer->GetBufferPointer(), shadowPixelShaderBuffer->GetBufferSize(), NULL, &shadowPixelShader);

	// PREPARE MODELS
	std::vector<D3D11_INPUT_ELEMENT_DESC> vertexLayout;
	vertexLayout.push_back({ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 });
	vertexLayout.push_back({ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, sizeof(Vertex().position), D3D11_INPUT_PER_VERTEX_DATA, 0 });

	XMMATRIX modelMatrix;

	modelMatrix = XMMatrixTranslation(0.0f, 1.0f, 0.0f);
	models.push_back(ModelDX(modelPath + "monkey.bin", modelPath + "monkey2.mtl", mDevice, vertexShaderBuffer, vertexLayout, modelMatrix, true));

	modelMatrix = XMMatrixScaling(5.0f, 5.0f, 5.0f);
	models.push_back(ModelDX(modelPath + "plane.bin", modelPath + "plane.mtl", mDevice, vertexShaderBuffer, vertexLayout, modelMatrix, true));

	// PREPARE LIGHTING
	lighting.ambient = Vector4(0.1f, 0.1f, 0.1f, 1.0f);

	Light light1;
	light1.position = Vector4(-5.0f, 5.0f, 5.0f, 0.0f);
	light1.diffuse = Vector4(0.5f, 0.5f, 0.5f, 1.0f);
	light1.specular = Vector4(0.5f, 0.5f, 0.5f, 1.0f);

	Light light2;
	light2.position = Vector4(5.0f, 5.0f, 5.0f, 0.0f);
	light2.diffuse = Vector4(0.5f, 0.5f, 0.5f, 1.0f);
	light2.specular = Vector4(0.5f, 0.5f, 0.5f, 1.0f);

	lighting.lights[0] = light1;
	lighting.lights[1] = light2;

	D3D11_BUFFER_DESC lightDesc;
	ZeroMemory(&lightDesc, sizeof(lightDesc));
	lightDesc.ByteWidth = sizeof(Lighting);
	lightDesc.Usage = D3D11_USAGE_DEFAULT;
	lightDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
	lightDesc.CPUAccessFlags = 0;

	D3D11_SUBRESOURCE_DATA lightData;
	ZeroMemory(&lightData, sizeof(lightData));
	lightData.pSysMem = &lighting;

	ID3D11Buffer* lightBuffer;
	mDevice->CreateBuffer(&lightDesc, &lightData, &lightBuffer);
	mDeviceContext->VSSetConstantBuffers(lightBufferSlot, 1, &lightBuffer);
	mDeviceContext->PSSetConstantBuffers(lightBufferSlot, 1, &lightBuffer);
	lightBuffer->Release();

	RenderShadowMaps();

	D3D11_SAMPLER_DESC samplerDesc;
	ZeroMemory(&samplerDesc, sizeof(samplerDesc));
	samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_BORDER;
	samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_BORDER;
	samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_BORDER;
	samplerDesc.BorderColor[0] = 1.0f;
	samplerDesc.BorderColor[1] = 1.0f;
	samplerDesc.BorderColor[2] = 1.0f;
	samplerDesc.BorderColor[3] = 1.0f;
	samplerDesc.MinLOD = 0.f;
	samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
	samplerDesc.MipLODBias = 0.f;
	samplerDesc.MaxAnisotropy = 0;
	samplerDesc.ComparisonFunc = D3D11_COMPARISON_LESS_EQUAL;
	samplerDesc.Filter = D3D11_FILTER_COMPARISON_MIN_MAG_MIP_LINEAR;

	mDevice->CreateSamplerState(&samplerDesc, &shadowMapSamplerState);

	// PREPARE MATERIAL BUFFER
	D3D11_BUFFER_DESC materialDesc;
	ZeroMemory(&materialDesc, sizeof(materialDesc));
	materialDesc.ByteWidth = sizeof(Material);
	materialDesc.Usage = D3D11_USAGE_DEFAULT;
	materialDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
	materialDesc.CPUAccessFlags = 0;

	mDevice->CreateBuffer(&materialDesc, NULL, &materialBuffer);
	mDeviceContext->PSSetConstantBuffers(materialBufferSlot, 1, &materialBuffer);

	// PREPARE VIEW AND PROJECTION
	XMMATRIX viewMatrix = XMMatrixLookAtRH(XMLoadFloat4(&eye), XMLoadFloat4(&center), XMLoadFloat4(&up));
	viewMatrixBuffer = DXUtil::CreateMatrixBuffer(mDevice, viewMatrix);
	mDeviceContext->VSSetConstantBuffers(viewMatrixBufferSlot, 1, &viewMatrixBuffer);

	XMMATRIX projectionMatrix = XMMatrixPerspectiveFovRH(XMConvertToRadians(60.0f), 800 / 800, 1.0f, 500.0f);
	ID3D11Buffer* projectionMatrixBuffer = DXUtil::CreateMatrixBuffer(mDevice, projectionMatrix);
	mDeviceContext->VSSetConstantBuffers(projectionMatrixBufferSlot, 1, &projectionMatrixBuffer);
	projectionMatrixBuffer->Release();

	mDeviceContext->PSSetShaderResources(0, 2, &shadowMapResources[0]);
	mDeviceContext->PSSetSamplers(0, 1, &shadowMapSamplerState);

	return true;
}
Beispiel #21
0
//
// Draw frame into backbuffer
//
DUPL_RETURN OUTPUTMANAGER::DrawFrame()
{
    HRESULT hr;

    // If window was resized, resize swapchain
    if (m_NeedsResize)
    {
        DUPL_RETURN Ret = ResizeSwapChain();
        if (Ret != DUPL_RETURN_SUCCESS)
        {
            return Ret;
        }
        m_NeedsResize = false;
    }

    // Vertices for drawing whole texture
    VERTEX Vertices[NUMVERTICES] =
    {
        {XMFLOAT3(-1.0f, -1.0f, 0), XMFLOAT2(0.0f, 1.0f)},
        {XMFLOAT3(-1.0f, 1.0f, 0), XMFLOAT2(0.0f, 0.0f)},
        {XMFLOAT3(1.0f, -1.0f, 0), XMFLOAT2(1.0f, 1.0f)},
        {XMFLOAT3(1.0f, -1.0f, 0), XMFLOAT2(1.0f, 1.0f)},
        {XMFLOAT3(-1.0f, 1.0f, 0), XMFLOAT2(0.0f, 0.0f)},
        {XMFLOAT3(1.0f, 1.0f, 0), XMFLOAT2(1.0f, 0.0f)},
    };

    D3D11_TEXTURE2D_DESC FrameDesc;
    m_SharedSurf->GetDesc(&FrameDesc);

    D3D11_SHADER_RESOURCE_VIEW_DESC ShaderDesc;
    ShaderDesc.Format = FrameDesc.Format;
    ShaderDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
    ShaderDesc.Texture2D.MostDetailedMip = FrameDesc.MipLevels - 1;
    ShaderDesc.Texture2D.MipLevels = FrameDesc.MipLevels;

    // Create new shader resource view
    ID3D11ShaderResourceView* ShaderResource = nullptr;
    hr = m_Device->CreateShaderResourceView(m_SharedSurf, &ShaderDesc, &ShaderResource);
    if (FAILED(hr))
    {
        return ProcessFailure(m_Device, L"Failed to create shader resource when drawing a frame", L"Error", hr, SystemTransitionsExpectedErrors);
    }

    // Set resources
    UINT Stride = sizeof(VERTEX);
    UINT Offset = 0;
    FLOAT blendFactor[4] = {0.f, 0.f, 0.f, 0.f};
    m_DeviceContext->OMSetBlendState(nullptr, blendFactor, 0xffffffff);
    m_DeviceContext->OMSetRenderTargets(1, &m_RTV, nullptr);
    m_DeviceContext->VSSetShader(m_VertexShader, nullptr, 0);
    m_DeviceContext->PSSetShader(m_PixelShader, nullptr, 0);
    m_DeviceContext->PSSetShaderResources(0, 1, &ShaderResource);
    m_DeviceContext->PSSetSamplers(0, 1, &m_SamplerLinear);
    m_DeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

    D3D11_BUFFER_DESC BufferDesc;
    RtlZeroMemory(&BufferDesc, sizeof(BufferDesc));
    BufferDesc.Usage = D3D11_USAGE_DEFAULT;
    BufferDesc.ByteWidth = sizeof(VERTEX) * NUMVERTICES;
    BufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    BufferDesc.CPUAccessFlags = 0;
    D3D11_SUBRESOURCE_DATA InitData;
    RtlZeroMemory(&InitData, sizeof(InitData));
    InitData.pSysMem = Vertices;

    ID3D11Buffer* VertexBuffer = nullptr;

    // Create vertex buffer
    hr = m_Device->CreateBuffer(&BufferDesc, &InitData, &VertexBuffer);
    if (FAILED(hr))
    {
        ShaderResource->Release();
        ShaderResource = nullptr;
        return ProcessFailure(m_Device, L"Failed to create vertex buffer when drawing a frame", L"Error", hr, SystemTransitionsExpectedErrors);
    }
    m_DeviceContext->IASetVertexBuffers(0, 1, &VertexBuffer, &Stride, &Offset);

    // Draw textured quad onto render target
    m_DeviceContext->Draw(NUMVERTICES, 0);

    VertexBuffer->Release();
    VertexBuffer = nullptr;

    // Release shader resource
    ShaderResource->Release();
    ShaderResource = nullptr;

    return DUPL_RETURN_SUCCESS;
}
int _tmain(int /*argc*/, _TCHAR* /*argv[]*/)
{
    // GROUP_SIZE_X defined in kernel.hlsl must match the 
    // groupSize declared here.
    size_t const groupSize = 512;
    size_t const numGroups = 16;
    size_t const dimension = numGroups*groupSize;

    // Create a D3D11 device and immediate context. 
    // TODO: The code below uses the default video adapter, with the
    // default set of feature levels.  Please see the MSDN docs if 
    // you wish to control which adapter and feature level are used.
    D3D_FEATURE_LEVEL featureLevel;
    ID3D11Device* device = nullptr;
    ID3D11DeviceContext* context = nullptr;
    HRESULT hr = D3D11CreateDevice(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 
        NULL, NULL, 0, D3D11_SDK_VERSION, &device, 
        &featureLevel, &context);
    if (FAILED(hr))
    {
        printf("D3D11CreateDevice failed with return code %x\n", hr);
        return hr;
    }

    // Create system memory and fill it with our initial data.  Note that
    // these data structures aren't really necessary , it's just a demonstration
    // of how you can take existing data structures you might have and copy
    // their data to/from GPU computations.
    std::vector<float> x(dimension);
    std::vector<float> y(dimension);
    std::vector<float> z(dimension);
    float const a = 2.0f;
    for (size_t i = 0; i < dimension; ++ i)
    {
        x[i] = static_cast<float>(i);
        y[i] = 100 - static_cast<float>(i);
    }

    // Create structured buffers for the "x" and "y" vectors.
    D3D11_BUFFER_DESC inputBufferDesc;
    inputBufferDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
    // The buffers are read-only by the GPU, writeable by the CPU.
    // TODO: If you will never again upate the data in a GPU buffer,
    // you might want to look at using a D3D11_SUBRESOURCE_DATA here to
    // provide the initialization data instead of doing the mapping 
    // and copying that happens below.
    inputBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
    inputBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    inputBufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
    inputBufferDesc.StructureByteStride = sizeof(float);
    inputBufferDesc.ByteWidth = sizeof(float) * dimension;
    ID3D11Buffer* xBuffer = nullptr;
    hr = device->CreateBuffer(&inputBufferDesc, NULL, &xBuffer);
    if (FAILED(hr))
    {
        printf("CreateBuffer failed for x buffer with return code %x\n", hr);
        return hr;
    }
    // We can re-use inputBufferDesc here because the layout and usage of the x
    // and y buffers is exactly the same.
    ID3D11Buffer* yBuffer = nullptr;
    hr = device->CreateBuffer(&inputBufferDesc, NULL, &yBuffer);
    if (FAILED(hr))
    {
        printf("CreateBuffer failed for x buffer with return code %x\n", hr);
        return hr;
    }

    // Create shader resource views for the "x" and "y" buffers.
    // TODO: You can optionally provide a D3D11_SHADER_RESOURCE_VIEW_DESC
    // as the second parameter if you need to use only part of the buffer
    // inside the compute shader.
    ID3D11ShaderResourceView* xSRV = nullptr;
    hr = device->CreateShaderResourceView(xBuffer, NULL, &xSRV);
    if (FAILED(hr))
    {
        printf("CreateShaderResourceView failed for x buffer with return code %x\n", hr);
        return hr;
    }

    ID3D11ShaderResourceView* ySRV = nullptr;
    hr = device->CreateShaderResourceView(yBuffer, NULL, &ySRV);
    if (FAILED(hr))
    {
        printf("CreateShaderResourceView failed for y buffer with return code %x\n", hr);
        return hr;
    }

    // Create a structured buffer for the "z" vector.  This buffer needs to be 
    // writeable by the GPU, so we can't create it with CPU read/write access.
    D3D11_BUFFER_DESC outputBufferDesc;
    outputBufferDesc.BindFlags = D3D11_BIND_UNORDERED_ACCESS 
        | D3D11_BIND_SHADER_RESOURCE;
    outputBufferDesc.Usage = D3D11_USAGE_DEFAULT;
    outputBufferDesc.CPUAccessFlags = 0;
    outputBufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
    outputBufferDesc.StructureByteStride = sizeof(float);
    outputBufferDesc.ByteWidth = sizeof(float) * dimension;
    ID3D11Buffer* zBuffer = nullptr;
    hr = device->CreateBuffer(&outputBufferDesc, NULL, &zBuffer);
    if (FAILED(hr))
    {
        printf("CreateBuffer failed for z buffer with return code %x\n", hr);
        return hr;
    }

    // Create an unordered access view for the "z" vector.  
    D3D11_UNORDERED_ACCESS_VIEW_DESC outputUAVDesc;
    outputUAVDesc.Buffer.FirstElement = 0;        
    outputUAVDesc.Buffer.Flags = 0;            
    outputUAVDesc.Buffer.NumElements = dimension;
    outputUAVDesc.Format = DXGI_FORMAT_UNKNOWN;    
    outputUAVDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;   
    ID3D11UnorderedAccessView* zBufferUAV;
    hr = device->CreateUnorderedAccessView(zBuffer, 
        &outputUAVDesc, &zBufferUAV);
    if (FAILED(hr))
    {
        printf("CreateUnorderedAccessView failed for z buffer with return code %x\n", hr);
        return hr;
    }

    // Create a staging buffer, which will be used to copy back from zBuffer.
    D3D11_BUFFER_DESC stagingBufferDesc;
    stagingBufferDesc.BindFlags = 0;
    stagingBufferDesc.Usage = D3D11_USAGE_STAGING;  
    stagingBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
    stagingBufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
    stagingBufferDesc.StructureByteStride = sizeof(float);
    stagingBufferDesc.ByteWidth = sizeof(float) * dimension;
    ID3D11Buffer* stagingBuffer;
    hr = device->CreateBuffer(&stagingBufferDesc, NULL, &stagingBuffer);
    if (FAILED(hr))
    {
        printf("CreateBuffer failed for staging buffer with return code %x\n", hr);
        return hr;
    }

    // Create a constant buffer (this buffer is used to pass the constant 
    // value 'a' to the kernel as cbuffer Constants).
    D3D11_BUFFER_DESC cbDesc;
    cbDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
    cbDesc.Usage = D3D11_USAGE_DYNAMIC;  
    cbDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    cbDesc.MiscFlags = 0;
    // Even though the constant buffer only has one float, DX expects
    // ByteWidth to be a multiple of 4 floats (i.e., one 128-bit register).
    cbDesc.ByteWidth = sizeof(float)*4;
    ID3D11Buffer* constantBuffer = nullptr;
    hr = device->CreateBuffer( &cbDesc, NULL, &constantBuffer);
    if (FAILED(hr))
    {
        printf("CreateBuffer failed for constant buffer with return code %x\n", hr);
        return hr;
    }

    // Map the constant buffer and set the constant value 'a'.
    D3D11_MAPPED_SUBRESOURCE mappedResource;
    context->Map(constantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
    float* constants = reinterpret_cast<float*>(mappedResource.pData);
    constants[0] = a;
    constants = nullptr;
    context->Unmap(constantBuffer, 0);

    // Map the x buffer and copy our data into it.
    context->Map(xBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
    float* xvalues = reinterpret_cast<float*>(mappedResource.pData);
    memcpy(xvalues, &x[0], sizeof(float)*x.size());
    xvalues = nullptr;
    context->Unmap(xBuffer, 0);

    // Map the y buffer and copy our data into it.
    context->Map(yBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
    float* yvalues = reinterpret_cast<float*>(mappedResource.pData);
    memcpy(yvalues, &y[0], sizeof(float)*y.size());
    yvalues = nullptr;
    context->Unmap(yBuffer, 0);

    // Compile the compute shader into a blob.
    ID3DBlob* errorBlob = nullptr;
    ID3DBlob* shaderBlob = nullptr;
    hr = D3DX11CompileFromFile(L"kernel.hlsl", NULL, NULL, "saxpy", "cs_4_0",
        D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &shaderBlob, &errorBlob, NULL);
    if (FAILED(hr))
    {
        // Print out the error message if there is one.
        if (errorBlob)
        {
            char const* message = (char*)errorBlob->GetBufferPointer();
            printf("kernel.hlsl failed to compile; error message:\n");
            printf("%s\n", message);
            errorBlob->Release();
        }
        return hr;
    }

    // Create a shader object from the compiled blob.
    ID3D11ComputeShader* computeShader;
    hr = device->CreateComputeShader(shaderBlob->GetBufferPointer(), 
        shaderBlob->GetBufferSize(), NULL, &computeShader);
    if (FAILED(hr))
    {
        printf("CreateComputeShader failed with return code %x\n", hr);
        return hr;
    }

    // Make the shader active.
    context->CSSetShader(computeShader, NULL, 0);

    // Attach the z buffer to the output via its unordered access view.
    UINT initCounts = 0xFFFFFFFF;
    context->CSSetUnorderedAccessViews(0, 1, &zBufferUAV, &initCounts);

    // Attach the input buffers via their shader resource views.
    context->CSSetShaderResources(0, 1, &xSRV);
    context->CSSetShaderResources(1, 1, &ySRV);

    // Attach the constant buffer
    context->CSSetConstantBuffers(0, 1, &constantBuffer);

    // Execute the shader, in 'numGroups' groups of 'groupSize' threads each.
    context->Dispatch(numGroups, 1, 1);

    // Copy the z buffer to the staging buffer so that we can 
    // retrieve the data for accesss by the CPU.
    context->CopyResource(stagingBuffer, zBuffer);

    // Map the staging buffer for reading.
    context->Map(stagingBuffer, 0, D3D11_MAP_READ, 0, &mappedResource);
    float* zData = reinterpret_cast<float*>(mappedResource.pData);
    memcpy(&z[0], zData, sizeof(float)*z.size());
    zData = nullptr;
    context->Unmap(stagingBuffer, 0);

    // Now compare the GPU results against expected values.
    bool resultOK = true;
    for (size_t i = 0; i < x.size(); ++ i)
    {
        // NOTE: This comparison assumes the GPU produces *exactly* the 
        // same result as the CPU.  In general, this will not be the case
        // with floating-point calculations.
        float const expected = a*x[i] + y[i];
        if (z[i] != expected)
        {
            printf("Unexpected result at position %lu: expected %.7e, got %.7e\n",
                i, expected, z[i]);
            resultOK = false;
        }
    }

    if (!resultOK)
    {
        printf("GPU results differed from the CPU results.\n");
        OutputDebugStringA("GPU results differed from the CPU results.\n");
        return 1;
    }

    printf("GPU output matched the CPU results.\n");
    OutputDebugStringA("GPU output matched the CPU results.\n");

    // Disconnect everything from the pipeline.
    ID3D11UnorderedAccessView* nullUAV = nullptr;
    context->CSSetUnorderedAccessViews( 0, 1, &nullUAV, &initCounts);
    ID3D11ShaderResourceView* nullSRV = nullptr;
    context->CSSetShaderResources(0, 1, &nullSRV);
    context->CSSetShaderResources(1, 1, &nullSRV);
    ID3D11Buffer* nullBuffer = nullptr;
    context->CSSetConstantBuffers(0, 1, &nullBuffer);

    // Release resources.  Again, note that none of the error checks above
    // release resources that have been allocated up to this point, so the 
    // sample doesn't clean up after itself correctly unless everything succeeds.
    computeShader->Release();
    shaderBlob->Release();
    constantBuffer->Release();
    stagingBuffer->Release();
    zBufferUAV->Release();
    zBuffer->Release();
    xSRV->Release();
    xBuffer->Release();
    ySRV->Release();
    yBuffer->Release();
    context->Release();
    device->Release();

    return 0;
}
Beispiel #23
0
 void* VertexBuffer::MapDeviceBuffer(EAccessFlags access, unsigned int offset, unsigned int size)
    {
        OGSAssertReturnPtr((offset+size) <= (unsigned int)mOwnerBuffer->CapacityInFloats()); 
        OGSAssertReturnPtr(mMapAccess == EAccessNone); // must not already be mapped

        OGSAssertReturnPtr(mBuffer != NULL);

        //get d3d11 access flag and map flag, also check if it need a copy operation
        D3D11_MAP map;
        unsigned int cpu_access = 0;
        bool needcopy = false;

        // This is the only assertion we can make on the mAccess, because we do not follow the DX11 spec.
        // For example, to map a buffer with D3D11_MAP_READ map flag, DX11 spec requires D3D11_CPU_ACCESS_READ 
        // CPU access flag and D3D11_USAGE_STAGING usage flag in creation time, but we do not.
        if (mOwnerBuffer->Access() == EAccessNone)
        {
            Sys::Warning(L"DX11: Cannot map a buffer created with no CPU access.");
            return NULL;
        }

        D3D11_BUFFER_DESC desc;
        mBuffer->GetDesc(&desc);

        switch (access)
        {
        case ReadOnly:
            {
                map = D3D11_MAP_READ;
                cpu_access = D3D11_CPU_ACCESS_READ;

                //only staging usage can be mapped by CPU read
                if (desc.Usage != D3D11_USAGE_STAGING) 
                    needcopy = true;
                break;
            }
        case ReadWrite:
            {
                map = D3D11_MAP_READ_WRITE;
                cpu_access = D3D11_CPU_ACCESS_READ|D3D11_CPU_ACCESS_WRITE;

                //only staging usage can be mapped by CPU read
                if (desc.Usage != D3D11_USAGE_STAGING) 
                    needcopy = true;
                break;
            }
        case WriteOnly:  
            {
                map = D3D11_MAP_WRITE;
                cpu_access = D3D11_CPU_ACCESS_WRITE;

                //only dynamic/staging usage can be mapped by CPU write
                if (desc.Usage != D3D11_USAGE_STAGING)
                    needcopy = true;
                break;
            }
        case WriteDiscard:
            {
                map = D3D11_MAP_WRITE_DISCARD;
                cpu_access = D3D11_CPU_ACCESS_WRITE;

                //only dynamic usage can be mapped by CPU write discard
                if (desc.Usage != D3D11_USAGE_DYNAMIC)
                {
                    Sys::Warning(L"Can't map this map with access flag WriteDiscard.");
                    return NULL;
                }
                break;
            }
        case WriteNoOverwrite: 
            {
                map = D3D11_MAP_WRITE_NO_OVERWRITE;
                cpu_access = D3D11_CPU_ACCESS_WRITE;

                //only dynamic usage can be mapped by CPU write no overwrite
                if (desc.Usage != D3D11_USAGE_DYNAMIC)
                {
                    Sys::Warning(L"Can't map this map with access flag WriteNoOverwrite.");
                    return NULL;
                }
                break;
            }
        default: ErrorReturnPtr();
        }


        // set up the buffer to map
        ID3D11Buffer* buffer = mBuffer;

        //get dx11 device and context
        ID3D11Device* pDevice = (ID3D11Device*)(mVD->GPUDevice());

        if (needcopy)
        {
            //warning information
            // It turns out this condition is fine for DX10 (or at least no worse that DX9),
            // i.e. it's normal to do this sort of mapping, according to Adam. Warning removed.
            //Sys::Warning(L"Mapping flag doesn't match resource usage,the map will be a low performance operation");

            //check if staging buffer in NULL, or the vertex buffer is in map now
            OGSAssertReturnPtr(mStagingBuffer == NULL);

            //create staging buffer description
            D3D11_BUFFER_DESC bufferDesc;

            bufferDesc.ByteWidth = sizeof(float) * mOwnerBuffer->CapacityInFloats();
            bufferDesc.BindFlags = 0; // can't bind a staging resource
            bufferDesc.Usage     = D3D11_USAGE_STAGING;
            bufferDesc.CPUAccessFlags = cpu_access;
            bufferDesc.MiscFlags = 0;

            //create a staging buffer for data-copy
            HRESULT hr;
            OGS_DEVICECALLDX11(pDevice->CreateBuffer( &bufferDesc, NULL, &buffer ), return NULL);

            if ( FAILED(hr)|| buffer == NULL )
            {
                OGS_INTERPRET_ERROR_CODE_DX11( L"CreateBuffer() staging buffer", hr );
                return NULL;
            }

            {
                // Use lock in virtual device to protect device context operation
                VD_TRYTOLOCK(mVD);

                // copy the vb to the staging buffer
                DX_IMMEDIATECONTEXT(mVD)->CopyResource( buffer, mBuffer );
            }
            mStagingBuffer = buffer;

            // add the size of staging buffer to memory monitor
            OGS::Objects::ObjModel::MemoryMonitor().AddToDeviceMemory(mOwnerBuffer->CapacityInFloats() * sizeof(float));
        }

        HRESULT hr;
        // now map the buffer or the staging buffer
        D3D11_MAPPED_SUBRESOURCE mappedSub;
        {
            //TODO DX11 MULTITHREADING
            // Buffers with DYNAMIC_USAGE flags can be Mapped/Unmapped on a Deferred Context.
            // But there are some restrictions on how WRITE_DISCARD and WRITE_NO_OVERWRITE flags should be used.
            // We currently don't support all workflows for using WRITE_DISCARD and WRITE_NO_OVERWRITE in Deferred Context.
            // Once this support is enabled we can do Map/Unmap on Deferred Context.
            {
                // Use lock in virtual device to protect device context operation
                VD_TRYTOLOCK(mVD);
                hr=DX_IMMEDIATECONTEXT(mVD)->Map( buffer, 0, map, 0, &mappedSub );
            }
        }

        if( FAILED(hr) ) { 
            OGS_INTERPRET_ERROR_CODE_DX11( L"Map() vertex", hr );

            //release created staging buffer
            if (mStagingBuffer)
            {
                buffer->Release();
                mStagingBuffer = NULL;
            }

            if(hr == DXGI_ERROR_DEVICE_REMOVED)
            {
                // The video card has been physically removed from the system, a driver upgrade for the
                // GPU has occurred, or the GPU driver was disabled.
                // At this point we need to release this and the device will have to be recreated by
                // the client application using the DeviceRemovedCB() callback.
                // See http://msdn.microsoft.com/en-us/library/windows/desktop/bb509553(v=vs.85).aspx
                OGSAssert(mVD != NULL);
                ID3D11Device * const pDevice = static_cast<ID3D11Device * const>(mVD->GPUDevice());

                static_cast<DeviceContextDx11*>(mVD)->OnDeviceRemoved(pDevice);
            }

            return NULL;
        }
        float* dstBuffer = (float*)mappedSub.pData;

        mMapAccess = access;
        mOwnerBuffer->MappedBuffer(dstBuffer);

        return dstBuffer + offset;
    }
Beispiel #24
0
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR cmdLine, int cmdShow)
{
	DXTInputHandlerDefault inputHandler;
	DXTWindowEventHandlerDefault eventHandler;
	DXTWindow window(hInstance, &inputHandler, &eventHandler);

	DXTRenderParams params;
	params.Extent = { 800, 600 };
	params.UseVSync = true;
	params.Windowed = true;

	HRESULT result;
	result = window.Initialize(params, "DXT Example (DirectX 11)");

	if (SUCCEEDED(result))
	{
		ID3D11Device* device;
		ID3D11DeviceContext* context;
		IDXGISwapChain* swapChain;
		result = DXTInitDevice(params, &window, &swapChain, &device, &context);

		if (SUCCEEDED(result))
		{
			eventHandler.SetSwapChain(swapChain);

			FLOAT clearColor[] = { 0.5f, 0.5f, 1.0f, 1.0f };
			D3D11_INPUT_ELEMENT_DESC inputDesc[] =
			{
				{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
				{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, sizeof(float) * 3, D3D11_INPUT_PER_VERTEX_DATA, 0 },
				{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, sizeof(float) * 5, D3D11_INPUT_PER_VERTEX_DATA, 0 },
			};
			UINT elementCount = 3;
			UINT stride = 8 * sizeof(FLOAT);
			UINT offset = 0;
			UINT indexCount = 0;
			FLOAT deltaTime = 0.016f;

			DXTSphericalCamera camera;
			DXTFirstPersonCameraController cameraController(&camera, &inputHandler);
			inputHandler.AddInputInterface(&cameraController);
			cameraController.Velocity = 40.0f;
			cameraController.RotationVelocity = 0.005f;
			camera.Position = DirectX::XMFLOAT3(20.0f, 20.0f, 20.0f);
			camera.LookAt(DirectX::XMFLOAT3(0.0f, 0.0f, 0.0f));

			ID3D11RenderTargetView* renderTargetView;
			ID3D11Texture2D* depthBuffer;
			ID3D11DepthStencilView* depthBufferView;
			ID3D11VertexShader* vertexShader;
			ID3D11PixelShader* pixelShader;
			DXTBytecodeBlob vertexBytecode;
			ID3D11DepthStencilState* depthState;
			ID3D11RasterizerState* rasterizerState;
			ID3D11Buffer* vertexBuffer;
			ID3D11Buffer* indexBuffer;
			ID3D11InputLayout* inputLayout;
			ID3D11Buffer* transformBuffer;

			DXTCreateRenderTargetFromBackBuffer(swapChain, device, &renderTargetView);
			DXTCreateDepthStencilBuffer(device, params.Extent.Width, params.Extent.Height, DXGI_FORMAT_D24_UNORM_S8_UINT, &depthBuffer, &depthBufferView);
			DXTVertexShaderFromFile(device, "VertexShader.cso", &vertexShader, &vertexBytecode);
			DXTPixelShaderFromFile(device, "PixelShader.cso", &pixelShader);
			DXTCreateDepthStencilStateDepthTestEnabled(device, &depthState);
			DXTCreateRasterizerStateSolid(device, &rasterizerState);
			DXTLoadStaticMeshFromFile(device, "mesh.ase", DXTVertexAttributePosition | DXTVertexAttributeUV | DXTVertexAttributeNormal,
				DXTIndexTypeShort, &vertexBuffer, &indexBuffer, &indexCount);
			DXTCreateBuffer(device, sizeof(DirectX::XMFLOAT4X4) * 2, D3D11_BIND_CONSTANT_BUFFER, D3D11_CPU_ACCESS_WRITE, D3D11_USAGE_DYNAMIC, &transformBuffer);

			device->CreateInputLayout(inputDesc, elementCount, vertexBytecode.Bytecode, vertexBytecode.BytecodeLength, &inputLayout);
			vertexBytecode.Destroy();

			window.Present(false);

			while (!window.QuitMessageReceived())
			{
				window.MessagePump();

				if (inputHandler.IsKeyDown(VK_ESCAPE))
					break;

				cameraController.Update(deltaTime);

				XMFLOAT4X4 ViewProj;
				XMFLOAT4X4 World;
				camera.GetViewProjectionMatrix(&ViewProj, params.Extent);
				XMStoreFloat4x4(&World, XMMatrixIdentity());

				D3D11_MAPPED_SUBRESOURCE subres;
				context->Map(transformBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &subres);
				XMFLOAT4X4* ptr = (XMFLOAT4X4*)subres.pData;
				ptr[0] = World;
				ptr[1] = ViewProj;
				context->Unmap(transformBuffer, 0);

				D3D11_VIEWPORT viewport = { 0.0f, 0.0f, (FLOAT)params.Extent.Width, (FLOAT)params.Extent.Height, 0.0f, 1.0f };
				context->ClearRenderTargetView(renderTargetView, clearColor);
				context->ClearDepthStencilView(depthBufferView, D3D11_CLEAR_DEPTH, 1.0f, 0);
				context->OMSetDepthStencilState(depthState, 0);
				context->OMSetRenderTargets(1, &renderTargetView, depthBufferView);
				context->RSSetState(rasterizerState);
				context->RSSetViewports(1, &viewport);
				context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
				context->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
				context->IASetIndexBuffer(indexBuffer, DXGI_FORMAT_R16_UINT, 0);
				context->IASetInputLayout(inputLayout);
				context->VSSetShader(vertexShader, nullptr, 0);
				context->PSSetShader(pixelShader, nullptr, 0);
				context->VSSetConstantBuffers(0, 1, &transformBuffer);
				
				context->DrawIndexed(indexCount, 0, 0);

				swapChain->Present(1, 0);
			}

			swapChain->SetFullscreenState(false, nullptr);
			
			transformBuffer->Release();
			depthBufferView->Release();
			depthBuffer->Release();
			inputLayout->Release();
			vertexBuffer->Release();
			indexBuffer->Release();
			depthState->Release();
			rasterizerState->Release();
			vertexShader->Release();
			pixelShader->Release();
			renderTargetView->Release();
			swapChain->Release();
			context->Release();
			device->Release();
		}

		window.Destroy();
	}
}
Beispiel #25
0
bool ContentPackage::LoadMesh(const std::string& contentLocation, StaticMesh** meshOut)
{
    OutputDebugString("Loading resource ");
    OutputDebugString(contentLocation.c_str());
    OutputDebugString("\n");

    if (vertexStrideFloat == 0)
    {
        OutputDebugString("Vertex layout has not been set!\n");
        return false;
    }

    auto findResult = staticMeshes.find(contentLocation);
    if (findResult != staticMeshes.end())
    {
        *meshOut = findResult->second;
        return true;
    }

    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile(contentLocation.c_str(),
                           (aiProcessPreset_TargetRealtime_Fast |
                            aiProcess_FlipUVs |
                            aiProcess_PreTransformVertices));

    if (scene == nullptr)
        return false;

    float* meshData = nullptr;

    if (!scene->HasMeshes())
    {
        OutputDebugString("Scene does not have meshes!\n");
        return false;
    }

    size_t dataSize = 0;
    for (size_t i = 0; i < scene->mNumMeshes; ++i)
    {
        auto mesh = scene->mMeshes[i];
        if (!mesh->HasPositions() && (offsets.position != VERTEX_ATTRIBUTE_DISABLED))
        {
            OutputDebugString("Mesh is missing positions!\n");
            return false;
        }

        if (!mesh->HasTextureCoords(0) && (offsets.texCoord != VERTEX_ATTRIBUTE_DISABLED))
        {
            OutputDebugString("Mesh is missing texture coordinates at location 0!\n");
            return false;
        }

        if (!mesh->HasNormals() && (offsets.normal != VERTEX_ATTRIBUTE_DISABLED))
        {
            OutputDebugString("Mesh is missing normals!\n");
            return false;
        }

        if (!mesh->HasTangentsAndBitangents() && ((offsets.tangent != VERTEX_ATTRIBUTE_DISABLED) ||
                (offsets.bitangent != VERTEX_ATTRIBUTE_DISABLED)))
        {
            OutputDebugString("Mesh is missing tangets or bitangents!\n");
            return false;
        }

        dataSize += mesh->mNumVertices;
    }

    dataSize *= vertexStrideFloat;
    meshData = new float[dataSize];

    DXGI_FORMAT indexFormat;
    if (dataSize <= UINT16_MAX)
        indexFormat = DXGI_FORMAT_R16_UINT;
    else
        indexFormat = DXGI_FORMAT_R32_UINT;

    size_t meshOffset = 0;
    for (size_t i = 0; i < scene->mNumMeshes; ++i)
    {
        auto mesh = scene->mMeshes[i];
        size_t meshDataSize = vertexStrideFloat * mesh->mNumVertices;
        if (offsets.position != VERTEX_ATTRIBUTE_DISABLED)
        {
            for (size_t dataLoc = meshOffset + offsets.position, vertexId = offsets.position,
                    end = meshOffset + meshDataSize;
                    dataLoc < end;
                    dataLoc += vertexStrideFloat, ++vertexId)
            {
                meshData[dataLoc] = mesh->mVertices[vertexId].x;
                meshData[dataLoc + 1] = mesh->mVertices[vertexId].y;
                meshData[dataLoc + 2] = mesh->mVertices[vertexId].z;
            }
        }

        if (offsets.texCoord != VERTEX_ATTRIBUTE_DISABLED)
        {
            for (size_t dataLoc = meshOffset + offsets.texCoord, vertexId = 0,
                    end = meshOffset + meshDataSize;
                    dataLoc < end;
                    dataLoc += vertexStrideFloat, ++vertexId)
            {
                meshData[dataLoc] = mesh->mTextureCoords[0][vertexId].x;
                meshData[dataLoc + 1] = mesh->mTextureCoords[0][vertexId].y;
            }
        }

        if (offsets.normal != VERTEX_ATTRIBUTE_DISABLED)
        {
            for (size_t dataLoc = meshOffset + offsets.normal, vertexId = 0,
                    end = meshOffset + meshDataSize;
                    dataLoc < end;
                    dataLoc += vertexStrideFloat, ++vertexId)
            {
                meshData[dataLoc] = mesh->mNormals[vertexId].x;
                meshData[dataLoc + 1] = mesh->mNormals[vertexId].y;
                meshData[dataLoc + 2] = mesh->mNormals[vertexId].z;
            }
        }

        if (offsets.tangent != VERTEX_ATTRIBUTE_DISABLED)
        {
            for (size_t dataLoc = meshOffset + offsets.tangent, vertexId = 0,
                    end = meshOffset + meshDataSize;
                    dataLoc < end;
                    dataLoc += vertexStrideFloat, ++vertexId)
            {
                meshData[dataLoc] = mesh->mTangents[vertexId].x;
                meshData[dataLoc + 1] = mesh->mTangents[vertexId].y;
                meshData[dataLoc + 2] = mesh->mTangents[vertexId].z;
            }
        }

        if (offsets.bitangent != VERTEX_ATTRIBUTE_DISABLED)
        {
            for (size_t dataLoc = meshOffset + offsets.bitangent, vertexId = 0,
                    end = meshOffset + meshDataSize;
                    dataLoc < end;
                    dataLoc += vertexStrideFloat, ++vertexId)
            {
                meshData[dataLoc] = mesh->mBitangents[vertexId].x;
                meshData[dataLoc + 1] = mesh->mBitangents[vertexId].y;
                meshData[dataLoc + 2] = mesh->mBitangents[vertexId].z;
            }
        }

        meshOffset += mesh->mNumVertices * vertexStrideFloat;
    }

    size_t indexCount = 0;
    for (size_t i = 0; i < scene->mNumMeshes; ++i)
        indexCount += scene->mMeshes[i]->mNumFaces * 3;

    void* meshIndices = nullptr;
    if (indexFormat == DXGI_FORMAT_R16_UINT)
    {
        uint16_t* meshIndices16 = new uint16_t[indexCount];
        meshIndices = meshIndices16;

        size_t indexOffset = 0;
        meshOffset = 0;
        for (size_t i = 0; i < scene->mNumMeshes; ++i)
        {
            auto mesh = scene->mMeshes[i];
            for (size_t faceId = 0, indexId = indexOffset; faceId < mesh->mNumFaces; ++faceId)
            {
                meshIndices16[indexId++] = mesh->mFaces[faceId].mIndices[0] + static_cast<uint16_t>(meshOffset);
                meshIndices16[indexId++] = mesh->mFaces[faceId].mIndices[1] + static_cast<uint16_t>(meshOffset);
                meshIndices16[indexId++] = mesh->mFaces[faceId].mIndices[2] + static_cast<uint16_t>(meshOffset);
            }
            indexOffset += mesh->mNumFaces * 3;
            meshOffset += mesh->mNumVertices * vertexStrideFloat;
        }
    }
    else
    {
        uint32_t* meshIndices32 = new uint32_t[indexCount];
        meshIndices = meshIndices32;

        size_t indexOffset = 0;
        meshOffset = 0;
        for (size_t i = 0; i < scene->mNumMeshes; ++i)
        {
            auto mesh = scene->mMeshes[i];
            for (size_t faceId = 0, indexId = indexOffset; faceId < mesh->mNumFaces; ++faceId)
            {
                meshIndices32[indexId++] = mesh->mFaces[faceId].mIndices[0] + meshOffset;
                meshIndices32[indexId++] = mesh->mFaces[faceId].mIndices[1] + meshOffset;
                meshIndices32[indexId++] = mesh->mFaces[faceId].mIndices[2] + meshOffset;
            }
            indexOffset += mesh->mNumFaces * 3;
            meshOffset += mesh->mNumVertices * vertexStrideFloat;
        }
    }

    D3D11_BUFFER_DESC bufferDesc;
    bufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
    bufferDesc.ByteWidth = sizeof(float) * dataSize;
    bufferDesc.CPUAccessFlags = 0;
    bufferDesc.MiscFlags = 0;
    bufferDesc.StructureByteStride = 0;
    bufferDesc.Usage = D3D11_USAGE_IMMUTABLE;

    D3D11_SUBRESOURCE_DATA bufferData;
    ZeroMemory(&bufferData, sizeof(bufferData));
    bufferData.pSysMem = meshData;

    ID3D11Buffer* vertexBuffer;
    HRESULT result = device->CreateBuffer(&bufferDesc, &bufferData, &vertexBuffer);
    if (FAILED(result))
    {
        delete[] meshData;
        delete[] meshIndices;
        return false;
    }

    bufferDesc.BindFlags = D3D11_BIND_INDEX_BUFFER;
    if (indexFormat == DXGI_FORMAT_R16_UINT)
        bufferDesc.ByteWidth = indexCount * sizeof(uint16_t);
    else
        bufferDesc.ByteWidth = indexCount * sizeof(uint32_t);
    bufferData.pSysMem = meshIndices;

    ID3D11Buffer* indexBuffer;
    result = device->CreateBuffer(&bufferDesc, &bufferData, &indexBuffer);

    delete[] meshData;
    delete[] meshIndices;

    if (FAILED(result))
    {
        vertexBuffer->Release();
        return false;
    }

    auto infinity = numeric_limits<float>::infinity();
    Bounds bounds = { { infinity, infinity, infinity }, { -infinity, -infinity, -infinity } };

    for (size_t i = 0; i < scene->mNumMeshes; ++i)
    {
        auto mesh = scene->mMeshes[i];
        for (size_t vertexId = 0; vertexId < mesh->mNumVertices; ++vertexId)
        {
            auto vertex = mesh->mVertices[vertexId];
            if (vertex.x > bounds.Upper.x)
                bounds.Upper.x = vertex.x;
            if (vertex.y > bounds.Upper.y)
                bounds.Upper.y = vertex.y;
            if (vertex.z > bounds.Upper.z)
                bounds.Upper.z = vertex.z;

            if (vertex.x < bounds.Lower.x)
                bounds.Lower.x = vertex.x;
            if (vertex.y < bounds.Lower.y)
                bounds.Lower.y = vertex.y;
            if (vertex.z < bounds.Lower.z)
                bounds.Lower.z = vertex.z;
        }
    }

    stringstream strstream;
    strstream << "Computed Mesh Bounds : { (" << bounds.Lower.x << ", " << bounds.Lower.y << ", " <<
              bounds.Lower.z << "), (" << bounds.Upper.x << ", " << bounds.Upper.y << ", " << bounds.Upper.z <<
              ") }\n";
    OutputDebugString(strstream.str().c_str());

    *meshOut = new StaticMesh(vertexBuffer, indexBuffer, indexCount, 0, bounds, indexFormat);
    staticMeshes[contentLocation] = *meshOut;

#if defined(ENABLE_DIRECT3D_DEBUG) && defined(ENABLE_NAMED_OBJECTS)
    stringstream strstreamVert;
    strstreamVert << contentLocation << " : Vertex Buffer";
    SetDebugObjectName(vertexBuffer, strstreamVert.str());

    stringstream strstreamIndex;
    strstreamIndex << contentLocation << " : Index Buffer";
    SetDebugObjectName(indexBuffer, strstreamIndex.str());
#endif

    return true;
}
Beispiel #26
0
bool TestTriangleStripsDX::InitScene()
{
	XMStoreFloat4(&up, XMVectorSet(0.0f, 1.0f, 0.0f, 1.0f));
	XMStoreFloat4(&eye, XMVectorSet(0.0f, 18.0f, 18.0f, 1.0f));
	XMStoreFloat4(&right, XMVectorSet(1.0f, 0.0f, 0.0f, 1.0f));
	XMStoreFloat4(&center, XMVectorSet(0.0f, 0.0f, 0.0f, 1.0f));

	bg[0] = bgColor.r;
	bg[1] = bgColor.g;
	bg[2] = bgColor.b;
	bg[3] = bgColor.a;

	ID3D11RasterizerState1 *rasterizerState;
	D3D11_RASTERIZER_DESC1 rasterizerDesc;
	ZeroMemory(&rasterizerDesc, sizeof(rasterizerDesc));
	rasterizerDesc.CullMode = D3D11_CULL_NONE;
	rasterizerDesc.FillMode = D3D11_FILL_SOLID;
	rasterizerDesc.FrontCounterClockwise = true;

	mDevice->CreateRasterizerState1(&rasterizerDesc, &rasterizerState);
	mDeviceContext->RSSetState(rasterizerState);
	rasterizerState->Release();

	BinaryIO::ReadVector4s(binaryPath + "triangle_strip_plane.bin", vertices);

	D3D11_INPUT_ELEMENT_DESC vertexLayout[] =
	{
		{ "POSITION", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
	};

	D3DCompileFromFile(Util::s2ws(shaderPath + "TestTriangleStripsVert.hlsl").c_str(), NULL, NULL, "vertexShader", "vs_5_0", NULL, NULL, &vertexShaderBuffer, NULL);
	D3DCompileFromFile(Util::s2ws(shaderPath + "TestTriangleStripsFrag.hlsl").c_str(), NULL, NULL, "pixelShader", "ps_5_0", NULL, NULL, &pixelShaderBuffer, NULL);
	mDevice->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertexShader);
	mDevice->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixelShader);

	D3D11_BUFFER_DESC vertexBufferDesc;
	ZeroMemory(&vertexBufferDesc, sizeof(vertexBufferDesc));
	vertexBufferDesc.ByteWidth = vertices.size() * sizeof(Vector4);
	vertexBufferDesc.Usage = D3D11_USAGE_DEFAULT;
	vertexBufferDesc.BindFlags = D3D11_BIND_VERTEX_BUFFER;

	D3D11_SUBRESOURCE_DATA vertexBufferData;
	ZeroMemory(&vertexBufferData, sizeof(vertexBufferData));
	vertexBufferData.pSysMem = &vertices[0];

	mDevice->CreateBuffer(&vertexBufferDesc, &vertexBufferData, &vertexBuffer);

	mDevice->CreateInputLayout(vertexLayout, 1, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &inputLayout);

	// UPLOAD MVP MATRICES
	XMMATRIX modelMatrix = XMMatrixIdentity();
	XMMATRIX viewMatrix = XMMatrixLookAtRH(XMLoadFloat4(&eye), XMLoadFloat4(&center), XMLoadFloat4(&up));
	XMMATRIX projectionMatrix = XMMatrixPerspectiveFovRH(XMConvertToRadians(60.0f), 800 / 800, 1.0f, 500.0f);

	ID3D11Buffer* modelMatrixBuffer = DXUtil::CreateMatrixBuffer(mDevice, modelMatrix);
	mDeviceContext->VSSetConstantBuffers(modelMatrixBufferSlot, 1, &modelMatrixBuffer);
	modelMatrixBuffer->Release();

	viewMatrixBuffer = DXUtil::CreateMatrixBuffer(mDevice, viewMatrix);
	mDeviceContext->VSSetConstantBuffers(viewMatrixBufferSlot, 1, &viewMatrixBuffer);
	viewMatrixBuffer->Release();

	ID3D11Buffer* projectionMatrixBuffer = DXUtil::CreateMatrixBuffer(mDevice, projectionMatrix);
	mDeviceContext->VSSetConstantBuffers(projectionMatrixBufferSlot, 1, &projectionMatrixBuffer);
	projectionMatrixBuffer->Release();

	return true;
}