Пример #1
0
	void GeometryShaderData::PreDraw(ID3D11Device1& device, ID3D11DeviceContext1& context) {
		ASSERT(mShader);

		context.GSSetShader(mShader, nullptr, 0);

		// Set constant buffers
		ID3D11Buffer* const cBuffers[] = { mCBuffer.mBuffer };
		mCBuffer.CopyDataToBuffer(device);
		context.GSSetConstantBuffers(0, ARRAYSIZE(cBuffers), cBuffers);
	}
Пример #2
0
	void VertexShaderData::PostDraw(ID3D11DeviceContext1& context) {
		context.IASetInputLayout(nullptr);
		context.VSSetShader(nullptr, nullptr, 0);

		ID3D11Buffer* vertexBuffers[] = { nullptr };
		const unsigned int stride[] = { 0 };
		const unsigned int offset[] = { 0 };
		context.IASetVertexBuffers(0, 1, vertexBuffers, stride, offset);

		ID3D11Buffer* const cBuffers[] = { nullptr };
		context.VSSetConstantBuffers(0, ARRAYSIZE(cBuffers), cBuffers);
	}
Пример #3
0
bool CDXVAContext::CreateSurfaces(D3D11_VIDEO_DECODER_DESC format, unsigned int count, unsigned int alignment, ID3D11VideoDecoderOutputView **surfaces) const
{
  HRESULT hr = S_OK;
  ID3D11Device* pDevice = g_Windowing.Get3D11Device();
  ID3D11DeviceContext1* pContext = g_Windowing.GetImmediateContext();

  unsigned bindFlags = D3D11_BIND_DECODER;

  if (g_Windowing.IsFormatSupport(format.OutputFormat, D3D11_FORMAT_SUPPORT_SHADER_SAMPLE))
    bindFlags |= D3D11_BIND_SHADER_RESOURCE;

  CD3D11_TEXTURE2D_DESC texDesc(format.OutputFormat, 
                                FFALIGN(format.SampleWidth, alignment), 
                                FFALIGN(format.SampleHeight, alignment), 
                                count, 1, bindFlags);

  ID3D11Texture2D *texture = nullptr;
  if (FAILED(pDevice->CreateTexture2D(&texDesc, NULL, &texture)))
  {
    CLog::LogF(LOGERROR, "failed creating decoder texture array.");
    return false;
  }

  D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC vdovDesc;
  vdovDesc.DecodeProfile = format.Guid;
  vdovDesc.Texture2D.ArraySlice = 0;
  vdovDesc.ViewDimension = D3D11_VDOV_DIMENSION_TEXTURE2D;
  float clearColor[] = { 0.0625f, 0.5f, 0.5f, 1.0f }; // black color in YUV

  size_t i;
  for (i = 0; i < count; ++i)
  {
    vdovDesc.Texture2D.ArraySlice = D3D11CalcSubresource(0, i, texDesc.MipLevels);
    hr = m_service->CreateVideoDecoderOutputView(texture, &vdovDesc, &surfaces[i]);
    if (FAILED(hr))
    {
      CLog::LogF(LOGERROR, "failed creating surfaces.");
      break;
    }
    pContext->ClearView(surfaces[i], clearColor, nullptr, 0);
  }
  SAFE_RELEASE(texture);

  if (FAILED(hr))
  {
    for (size_t j = 0; j < i; ++j)
      SAFE_RELEASE(surfaces[j]);
  }

  return SUCCEEDED(hr);
}
Пример #4
0
	void VertexShaderData::Draw(ID3D11DeviceContext1& context) {
		ASSERT(mInputLayout);
		ASSERT(mShader);
		ASSERT(mVertexBuffer);
		ASSERT(mVertexCount > 0);
		context.Draw(mVertexCount, 0);
	}
Пример #5
0
	void VertexShaderData::PreDraw(ID3D11Device1& device, ID3D11DeviceContext1& context) {
		ASSERT(mInputLayout);
		ASSERT(mShader);
		ASSERT(mVertexBuffer);
		ASSERT(mVertexCount > 0);

		context.IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

		context.IASetInputLayout(mInputLayout);

		context.VSSetShader(mShader, nullptr, 0);

		const unsigned int stride = sizeof(VertexData);
		const unsigned int offset = 0;
		context.IASetVertexBuffers(0, 1, &mVertexBuffer, &stride, &offset);

		// Set constant buffers
		ID3D11Buffer* const cBuffers[] = { mCBuffer.mBuffer };
		mCBuffer.CopyDataToBuffer(device);
		context.VSSetConstantBuffers(0, ARRAYSIZE(cBuffers), cBuffers);
	}
Пример #6
0
	void Drawer::Draw(ID3D11Device1& device,
					  ID3D11DeviceContext1& context,
					  const XMMATRIX& view,
					  const XMMATRIX& proj) {
		const XMMATRIX world = XMLoadFloat4x4(&mWorld);
		XMStoreFloat4x4(&mVertexShaderData.WorldViewProjection(), XMMatrixTranspose(world * view * proj));

		context.RSSetState(GlobalResources::gInstance->NoCullRS());

		mVertexShaderData.PreDraw(device, context);
		mPixelShaderData.PreDraw(device, context);
		mVertexShaderData.Draw(context);
		mVertexShaderData.PostDraw(context);
		mPixelShaderData.PostDraw(context);
	}
Пример #7
0
	void GeometryShaderData::PostDraw(ID3D11DeviceContext1& context) {
		context.GSSetShader(nullptr, nullptr, 0);
		ID3D11Buffer* const cBuffers[] = { nullptr };
		context.GSSetConstantBuffers(0, ARRAYSIZE(cBuffers), cBuffers);
	}
Пример #8
0
	void PixelShaderData::PostDraw(ID3D11DeviceContext1& context) {
		context.PSSetShader(nullptr, nullptr, 0);
	}
Пример #9
0
	void PixelShaderData::PreDraw(ID3D11Device1& /*device*/, ID3D11DeviceContext1& context) {
		ASSERT(mShader);
		context.PSSetShader(mShader, nullptr, 0);
	}
Пример #10
0
void BBWin8Game::CreateD3dDevice(){

	CoreWindow ^window=CoreWindow::GetForCurrentThread();

	int width=DipsToPixels( window->Bounds.Width );
	int height=DipsToPixels( window->Bounds.Height );

#if WINDOWS_8
	switch( DisplayProperties::CurrentOrientation ){
	case DisplayOrientations::Portrait:
	case DisplayOrientations::PortraitFlipped:
		std::swap( width,height );
		break;
	}
#endif

	UINT creationFlags=D3D11_CREATE_DEVICE_BGRA_SUPPORT;
	
#ifdef _DEBUG
	creationFlags|=D3D11_CREATE_DEVICE_DEBUG;
#endif

#if WINDOWS_8	
	D3D_FEATURE_LEVEL featureLevels[]={
		D3D_FEATURE_LEVEL_11_1,
		D3D_FEATURE_LEVEL_11_0,
		D3D_FEATURE_LEVEL_10_1,
		D3D_FEATURE_LEVEL_10_0,
		D3D_FEATURE_LEVEL_9_3,
		D3D_FEATURE_LEVEL_9_2,
		D3D_FEATURE_LEVEL_9_1
	};
#elif WINDOWS_PHONE_8
	D3D_FEATURE_LEVEL featureLevels[]={
		D3D_FEATURE_LEVEL_11_1,
		D3D_FEATURE_LEVEL_11_0,
		D3D_FEATURE_LEVEL_10_1,
		D3D_FEATURE_LEVEL_10_0,
		D3D_FEATURE_LEVEL_9_3
	};
#endif
	
	ID3D11Device *device;
	ID3D11DeviceContext *context;

	DXASS( D3D11CreateDevice( 
		0,
		D3D_DRIVER_TYPE_HARDWARE,
		0,
		creationFlags,
		featureLevels,
		ARRAYSIZE(featureLevels),
		D3D11_SDK_VERSION,
		&device,
		&_featureLevel,
		&context ) );
		
	DXASS( device->QueryInterface( __uuidof( ID3D11Device1 ),(void**)&_d3dDevice ) );
	DXASS( context->QueryInterface( __uuidof( ID3D11DeviceContext1 ),(void**)&_d3dContext ) );
	
	device->Release();
	context->Release();
	
	//create swap chain
	
	if( _swapChain ){

		DXASS( _swapChain->ResizeBuffers( 2,width,height,DXGI_FORMAT_B8G8R8A8_UNORM,0 ) );

	}else{

#if WINDOWS_8
		DXGI_SWAP_CHAIN_DESC1 swapChainDesc={0};
		swapChainDesc.Width=width;
		swapChainDesc.Height=height;
		swapChainDesc.Format=DXGI_FORMAT_B8G8R8A8_UNORM;
		swapChainDesc.Stereo=false;
		swapChainDesc.SampleDesc.Count=1;
		swapChainDesc.SampleDesc.Quality=0;
		swapChainDesc.BufferUsage=DXGI_USAGE_RENDER_TARGET_OUTPUT;
		swapChainDesc.BufferCount=2;
		swapChainDesc.Scaling=DXGI_SCALING_NONE;
		swapChainDesc.SwapEffect=DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
		swapChainDesc.Flags=0;
#elif WINDOWS_PHONE_8
		DXGI_SWAP_CHAIN_DESC1 swapChainDesc={0};
		swapChainDesc.Width=width;
		swapChainDesc.Height=height;
		swapChainDesc.Format=DXGI_FORMAT_B8G8R8A8_UNORM;
		swapChainDesc.Stereo=false;
		swapChainDesc.SampleDesc.Count=1;
		swapChainDesc.SampleDesc.Quality=0;
		swapChainDesc.BufferUsage=DXGI_USAGE_RENDER_TARGET_OUTPUT;
		swapChainDesc.BufferCount=1;
		swapChainDesc.Scaling=DXGI_SCALING_STRETCH;
		swapChainDesc.SwapEffect=DXGI_SWAP_EFFECT_DISCARD;
		swapChainDesc.Flags=0;
#endif
		IDXGIDevice1 *dxgiDevice;
		DXASS( _d3dDevice->QueryInterface( __uuidof( IDXGIDevice1 ),(void**)&dxgiDevice ) );
		
		IDXGIAdapter *dxgiAdapter;
		DXASS( dxgiDevice->GetAdapter( &dxgiAdapter ) );

		IDXGIFactory2 *dxgiFactory;
		DXASS( dxgiAdapter->GetParent( __uuidof( IDXGIFactory2 ),(void**)&dxgiFactory ) );
	
		DXASS( dxgiFactory->CreateSwapChainForCoreWindow( _d3dDevice,(IUnknown*)window,&swapChainDesc,0,&_swapChain ) );

		DXASS( dxgiDevice->SetMaximumFrameLatency( 1 ) );
		
		dxgiFactory->Release();
		dxgiAdapter->Release();
		dxgiDevice->Release();
	}
	
	// Create a render target view of the swap chain back buffer.
	//
	ID3D11Texture2D *backBuffer;
	DXASS( _swapChain->GetBuffer( 0,__uuidof( ID3D11Texture2D ),(void**)&backBuffer ) );
	DXASS( _d3dDevice->CreateRenderTargetView( backBuffer,0,&_renderTargetView ) );
	backBuffer->Release();

/*
	// Create a depth stencil view
	//
	D3D11_TEXTURE2D_DESC dsdesc;
	ZEROMEM( dsdesc );
	dsdesc.Width=width;
	dsdesc.Height=height;
	dsdesc.MipLevels=1;
	dsdesc.ArraySize=1;
	dsdesc.Format=DXGI_FORMAT_D24_UNORM_S8_UINT;
	dsdesc.SampleDesc.Count=1;
	dsdesc.SampleDesc.Quality=0;
	dsdesc.Usage=D3D11_USAGE_DEFAULT;
	dsdesc.BindFlags=D3D11_BIND_DEPTH_STENCIL;
	dsdesc.CpuAccessFlags=0;
	dsdesc.MiscFlags=0;
	ID3D11Texture2D *depthStencil;
	DXASS( _d3dDevice->CreateTexture2D( &dsdesc,0,&depthStencil ) );
	DXASS( _d3dDevice->CreateDepthStencilView( depthStencil,0,&_depthStencilView ) );
	depthStencil->Release();
*/

	D3D11_VIEWPORT viewport={ 0,0,width,height,0,1 };
	_d3dContext->RSSetViewports( 1,&viewport );
}
Пример #11
0
void DeviceGraphicsDX11Geometry::drawRange	(const DTuint first_tri, const DTuint num)
{
	// If there are VBO's
    DeviceGraphicsDX11Renderer *renderer = checkedCast<DeviceGraphicsDX11Renderer*>(System::getRenderer());

    ID3D11DeviceContext1 *context = renderer->getD3D11Context();

    ID3D11Buffer* buffers[D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT] = {NULL};
    UINT strides[D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT] = {0};
    UINT offsets[D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT] = {0};

	// If there are VBO's
	if (_normal_stream) {
        buffers[ShaderResource::ATTRIB_NORMAL] = _normal_stream->getBuffer();
        		
		if (_normal_stream->getFormat() == DeviceGraphicsDX11DataStream::FMT_3_FLOAT)		strides[ShaderResource::ATTRIB_NORMAL] = sizeof(DTfloat) * 3;
		else if (_normal_stream->getFormat() == DeviceGraphicsDX11DataStream::FMT_2_FLOAT)	strides[ShaderResource::ATTRIB_NORMAL] = sizeof(DTfloat) * 2;
		else if (_normal_stream->getFormat() == DeviceGraphicsDX11DataStream::FMT_4_FLOAT)	strides[ShaderResource::ATTRIB_NORMAL] = sizeof(DTfloat) * 4;
    }
	
	if (_color_stream) {
        buffers[ShaderResource::ATTRIB_COLOR] = _color_stream->getBuffer();

		if (_color_stream->getFormat() == DeviceGraphicsDX11DataStream::FMT_4_FLOAT)	    strides[ShaderResource::ATTRIB_COLOR] = sizeof(DTfloat) * 4;
		else if (_color_stream->getFormat() == DeviceGraphicsDX11DataStream::FMT_3_FLOAT)   strides[ShaderResource::ATTRIB_COLOR] = sizeof(DTfloat) * 3;
		else if (_color_stream->getFormat() == DeviceGraphicsDX11DataStream::FMT_4_BYTE)	strides[ShaderResource::ATTRIB_COLOR] = sizeof(DTubyte) * 4;
	}
        
	if (_weights_strength_stream) {
        buffers[ShaderResource::ATTRIB_WEIGHTS_STRENGTH] = _weights_strength_stream->getBuffer();

		if (_weights_strength_stream->getFormat() == DeviceGraphicsDX11DataStream::FMT_4_FLOAT)	    strides[ShaderResource::ATTRIB_WEIGHTS_STRENGTH] = sizeof(DTfloat) * 4;
	}

	if (_weights_index_stream) {
        buffers[ShaderResource::ATTRIB_WEIGHTS_INDEX] = _weights_index_stream->getBuffer();
		
        if (_weights_index_stream->getFormat() == DeviceGraphicsDX11DataStream::FMT_4_USHORT)	    strides[ShaderResource::ATTRIB_WEIGHTS_INDEX] = sizeof(DTushort) * 4;
	}

	DTint num_units = min2(4,System::getRenderer()->getNumTextureUnits());
	for (DTint unit = 0; unit < num_units; ++unit) {
			
		if (_texcoord_stream[unit]) {
            buffers[ShaderResource::ATTRIB_TEXCOORD0+unit] = _texcoord_stream[unit]->getBuffer();
						
			if (_texcoord_stream[unit]->getFormat() == DeviceGraphicsDX11DataStream::FMT_2_FLOAT)		strides[ShaderResource::ATTRIB_TEXCOORD0+unit] = sizeof(DTfloat) * 2;
			else if (_texcoord_stream[unit]->getFormat() == DeviceGraphicsDX11DataStream::FMT_3_FLOAT)	strides[ShaderResource::ATTRIB_TEXCOORD0+unit] = sizeof(DTfloat) * 3;
			else if (_texcoord_stream[unit]->getFormat() == DeviceGraphicsDX11DataStream::FMT_4_FLOAT)	strides[ShaderResource::ATTRIB_TEXCOORD0+unit] = sizeof(DTfloat) * 4;
		}
	}


	if (_vertex_stream) {
        buffers[ShaderResource::ATTRIB_POSITION] = _vertex_stream->getBuffer();
		
		if (_vertex_stream->getFormat() == DeviceGraphicsDX11DataStream::FMT_3_FLOAT)		strides[ShaderResource::ATTRIB_POSITION] = sizeof(DTfloat) * 3;
		else if (_vertex_stream->getFormat() == DeviceGraphicsDX11DataStream::FMT_2_FLOAT)	strides[ShaderResource::ATTRIB_POSITION] = sizeof(DTfloat) * 2;
		else if (_vertex_stream->getFormat() == DeviceGraphicsDX11DataStream::FMT_4_FLOAT)	strides[ShaderResource::ATTRIB_POSITION] = sizeof(DTfloat) * 4;
	}
	
    // Bind the streams
    context->IASetVertexBuffers(0,ShaderResource::NUM_ATTRIBS,buffers,strides,offsets);

	// draw if there is an index stream
	if (_index_stream) {
        context->IASetIndexBuffer(_index_stream->getBuffer(), DXGI_FORMAT_R16_UINT, 0);
        context->DrawIndexed(num*3,first_tri*3,0);
	}
	
}