Exemplo n.º 1
0
D3D11BlendStateObject::D3D11BlendStateObject(BlendStateDesc const & desc)
    : BlendStateObject(desc)
{
    D3D11RenderEngine& re = *checked_cast<D3D11RenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
    RenderDeviceCaps const & caps = re.DeviceCaps();

    D3D11_BLEND_DESC d3d_desc;
    d3d_desc.AlphaToCoverageEnable = desc.alpha_to_coverage_enable;
    d3d_desc.IndependentBlendEnable = caps.independent_blend_support ? desc.independent_blend_enable : false;
    for (int i = 0; i < 8; ++ i)
    {
        uint32_t const rt_index = caps.independent_blend_support ? i : 0;

        d3d_desc.RenderTarget[i].BlendEnable = desc.blend_enable[rt_index];
        d3d_desc.RenderTarget[i].SrcBlend = D3D11Mapping::Mapping(desc.src_blend[rt_index]);
        d3d_desc.RenderTarget[i].DestBlend = D3D11Mapping::Mapping(desc.dest_blend[rt_index]);
        d3d_desc.RenderTarget[i].BlendOp = D3D11Mapping::Mapping(desc.blend_op[rt_index]);
        d3d_desc.RenderTarget[i].SrcBlendAlpha = D3D11Mapping::Mapping(desc.src_blend_alpha[rt_index]);
        d3d_desc.RenderTarget[i].DestBlendAlpha = D3D11Mapping::Mapping(desc.dest_blend_alpha[rt_index]);
        d3d_desc.RenderTarget[i].BlendOpAlpha = D3D11Mapping::Mapping(desc.blend_op_alpha[rt_index]);
        d3d_desc.RenderTarget[i].RenderTargetWriteMask = static_cast<UINT8>(D3D11Mapping::MappingColorMask(desc.color_write_mask[rt_index]));
    }

    ID3D11Device* d3d_device = re.D3DDevice().get();

    if (re.D3D11RuntimeSubVer() >= 1)
    {
        ID3D11Device1* d3d_device_1 = static_cast<ID3D11Device1*>(d3d_device);
        D3D11_BLEND_DESC1 d3d_desc1;
        d3d_desc1.AlphaToCoverageEnable = d3d_desc.AlphaToCoverageEnable;
        d3d_desc1.IndependentBlendEnable = d3d_desc.IndependentBlendEnable;
        for (int i = 0; i < 8; ++ i)
        {
            uint32_t const rt_index = caps.independent_blend_support ? i : 0;

            d3d_desc1.RenderTarget[i].BlendEnable = d3d_desc.RenderTarget[i].BlendEnable;
            d3d_desc1.RenderTarget[i].LogicOpEnable = desc.logic_op_enable[i];
            d3d_desc1.RenderTarget[i].SrcBlend = d3d_desc.RenderTarget[i].SrcBlend;
            d3d_desc1.RenderTarget[i].DestBlend = d3d_desc.RenderTarget[i].DestBlend;
            d3d_desc1.RenderTarget[i].BlendOp = d3d_desc.RenderTarget[i].BlendOp;
            d3d_desc1.RenderTarget[i].SrcBlendAlpha = d3d_desc.RenderTarget[i].SrcBlendAlpha;
            d3d_desc1.RenderTarget[i].DestBlendAlpha = d3d_desc.RenderTarget[i].DestBlendAlpha;
            d3d_desc1.RenderTarget[i].BlendOpAlpha = d3d_desc.RenderTarget[i].BlendOpAlpha;
            d3d_desc1.RenderTarget[i].LogicOp
                = caps.logic_op_support ? D3D11Mapping::Mapping(desc.logic_op[rt_index]) : D3D11_LOGIC_OP_NOOP;
            d3d_desc1.RenderTarget[i].RenderTargetWriteMask = d3d_desc.RenderTarget[i].RenderTargetWriteMask;
        }

        ID3D11BlendState1* blend_state;
        TIF(d3d_device_1->CreateBlendState1(&d3d_desc1, &blend_state));
        blend_state_ = MakeCOMPtr(blend_state);
    }
    else
    {
        ID3D11BlendState* blend_state;
        TIF(d3d_device->CreateBlendState(&d3d_desc, &blend_state));
        blend_state_ = MakeCOMPtr(blend_state);
    }
}
Exemplo n.º 2
0
	TexturePtr DShowVMR9Allocator::PresentTexture()
	{
		unique_lock<mutex> lock(mutex_);

		if (FAILED(d3d_device_->TestCooperativeLevel()))
		{
			return TexturePtr();
		}

		if (cur_surf_index_ < surfaces_.size())
		{
			TIF(d3d_device_->GetRenderTargetData(surfaces_[cur_surf_index_], cache_surf_.get()));

			D3DLOCKED_RECT d3dlocked_rc;
			TIF(cache_surf_->LockRect(&d3dlocked_rc, nullptr, D3DLOCK_NOSYSLOCK | D3DLOCK_READONLY));

			uint32_t const width = present_tex_->Width(0);
			uint32_t const height = present_tex_->Height(0);
			uint32_t const texel_size = NumFormatBytes(present_tex_->Format());

			uint8_t const * src = static_cast<uint8_t const *>(d3dlocked_rc.pBits);
			{
				ElementFormat fmt = present_tex_->Format();
				Texture::Mapper mapper(*present_tex_, 0, 0, TMA_Write_Only, 0, 0, width, height);
				uint8_t* dst = mapper.Pointer<uint8_t>();
				if ((EF_ARGB8 == fmt) || (EF_ARGB8_SRGB == fmt))
				{
					for (uint32_t y = 0; y < height; ++ y)
					{
						std::memcpy(dst, src, width * texel_size);
						dst += mapper.RowPitch();
						src += d3dlocked_rc.Pitch;
					}
				}
				else
				{
					BOOST_ASSERT((EF_ABGR8 == fmt) || (EF_ABGR8_SRGB == fmt));

					for (uint32_t y = 0; y < height; ++ y)
					{
						for (uint32_t x = 0; x < width; ++ x)
						{
							dst[x * 4 + 0] = src[x * 4 + 2];
							dst[x * 4 + 1] = src[x * 4 + 1];
							dst[x * 4 + 2] = src[x * 4 + 0];
							dst[x * 4 + 3] = src[x * 4 + 3];
						}
						dst += mapper.RowPitch();
						src += d3dlocked_rc.Pitch;
					}
				}
			}

			TIF(cache_surf_->UnlockRect());
		}

		return present_tex_;
	}
Exemplo n.º 3
0
	// 构造函数
	/////////////////////////////////////////////////////////////////////////////////
	DSAudioEngine::DSAudioEngine()
	{
		mod_dsound_ = ::LoadLibraryEx(TEXT("dsound.dll"), nullptr, 0);
		if (nullptr == mod_dsound_)
		{
			::MessageBoxW(nullptr, L"Can't load dsound.dll", L"Error", MB_OK);
		}

		if (mod_dsound_ != nullptr)
		{
			DynamicDirectSoundCreate_ = reinterpret_cast<DirectSoundCreateFunc>(::GetProcAddress(mod_dsound_, "DirectSoundCreate"));
		}

		IDirectSound* dsound(nullptr);
		TIF(DynamicDirectSoundCreate_(&DSDEVID_DefaultPlayback, &dsound, nullptr));
		dsound_ = MakeCOMPtr(dsound);

		TIF(dsound_->SetCooperativeLevel(::GetForegroundWindow(), DSSCL_PRIORITY));

		DSBUFFERDESC desc;
		std::memset(&desc, 0, sizeof(desc));
		desc.dwSize  = sizeof(desc);
		desc.dwFlags = DSBCAPS_CTRL3D | DSBCAPS_PRIMARYBUFFER;

		IDirectSoundBuffer* pDSBPrimary(nullptr);
		TIF(dsound_->CreateSoundBuffer(&desc, &pDSBPrimary, nullptr));

		WAVEFORMATEX wfx;
		std::memset(&wfx, 0, sizeof(wfx));
		wfx.wFormatTag		= WAVE_FORMAT_PCM;
		wfx.nChannels		= 2;
		wfx.nSamplesPerSec	= 22050;
		wfx.wBitsPerSample	= 16;
		wfx.nBlockAlign		= wfx.wBitsPerSample * wfx.nChannels / 8;
		wfx.nAvgBytesPerSec	= wfx.nSamplesPerSec * wfx.nBlockAlign;

		TIF(pDSBPrimary->SetFormat(&wfx));

		IDirectSound3DListener* ds3dListener;
		TIF(pDSBPrimary->QueryInterface(IID_IDirectSound3DListener,
			reinterpret_cast<void**>(&ds3dListener)));
		ds3dListener_ = MakeCOMPtr(ds3dListener);


		this->SetListenerPos(float3(0, 0, 0));
		this->SetListenerVel(float3(0, 0, 0));
		this->SetListenerOri(float3(0, 0, 1), float3(0, 1, 0));

		pDSBPrimary->Release();
	}
Exemplo n.º 4
0
	// 缓冲区复位以便于从头播放
	/////////////////////////////////////////////////////////////////////////////////
	void DSMusicBuffer::DoReset()
	{
		this->writePos_	= 0;

		dataSource_->Reset();

		// 锁定缓冲区
		uint8_t* lockedBuffer;			// 指向缓冲区锁定的内存的指针
		DWORD lockedBufferSize;		// 锁定的内存大小
		TIF(buffer_->Lock(0, fillSize_ * fillCount_,
			reinterpret_cast<void**>(&lockedBuffer), &lockedBufferSize, nullptr, nullptr, 0));

		std::vector<uint8_t> data(fillSize_ * fillCount_);
		data.resize(dataSource_->Read(&data[0], fillSize_ * fillCount_));

		if (data.empty())
		{
			// 如果音频数据空白,用静音填充
			std::fill_n(lockedBuffer, lockedBufferSize, 0);
		}
		else
		{
			// 如果数据源比缓冲区小,则用音频数据填充缓冲区
			std::copy(data.begin(), data.end(), lockedBuffer);

			// 剩下的区域用空白填充
			std::fill_n(lockedBuffer + data.size(), lockedBufferSize - data.size(), 0);
		}

		// 缓冲区解锁
		buffer_->Unlock(lockedBuffer, lockedBufferSize, nullptr, 0);

		buffer_->SetCurrentPosition(0);
	}
Exemplo n.º 5
0
	void DShowVMR9Allocator::CreateDevice()
	{
		memset(&d3dpp_, 0, sizeof(d3dpp_));
		d3dpp_.Windowed = true;
		d3dpp_.hDeviceWindow = wnd_;
		d3dpp_.SwapEffect = D3DSWAPEFFECT_DISCARD;
		d3dpp_.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;

		D3DCAPS9 caps;
		d3d_->GetDeviceCaps(0, D3DDEVTYPE_HAL, &caps);
		uint32_t vp_mode;
		if ((caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) != 0)
		{
			vp_mode = D3DCREATE_HARDWARE_VERTEXPROCESSING;
			if ((caps.DevCaps & D3DDEVCAPS_PUREDEVICE) != 0)
			{
				vp_mode |= D3DCREATE_PUREDEVICE;
			}
		}
		else
		{
			vp_mode = D3DCREATE_SOFTWARE_VERTEXPROCESSING;
		}

		IDirect3DDevice9* d3d_device;
		TIF(d3d_->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL,
			wnd_, vp_mode | D3DCREATE_FPU_PRESERVE | D3DCREATE_MULTITHREADED,
			&d3dpp_, &d3d_device));
		d3d_device_ = MakeCOMPtr(d3d_device);
	}
Exemplo n.º 6
0
	void D3D11RenderWindow::SwapBuffers()
	{
		if (swap_chain_)
		{
			TIF(swap_chain_->Present(sync_interval_, 0));

#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
			if (dxgi_sub_ver_ >= 2)
			{
				RenderFactory& rf = Context::Instance().RenderFactoryInstance();
				D3D11RenderEngine& d3d11_re = *checked_cast<D3D11RenderEngine*>(&rf.RenderEngineInstance());
				ID3D11DeviceContextPtr d3d_imm_ctx = d3d11_re.D3DDeviceImmContext();
				ID3D11DeviceContext1Ptr const & d3d_imm_ctx_1 = static_pointer_cast<ID3D11DeviceContext1>(d3d_imm_ctx);
				d3d_imm_ctx_1->DiscardView(render_target_view_.get());
				if (depth_stencil_view_)
				{
					d3d_imm_ctx_1->DiscardView(depth_stencil_view_.get());
				}
				if (render_target_view_right_eye_)
				{
					d3d_imm_ctx_1->DiscardView(render_target_view_right_eye_.get());
				}
				if (depth_stencil_view_right_eye_)
				{
					d3d_imm_ctx_1->DiscardView(depth_stencil_view_right_eye_.get());
				}
			}
#endif
		}
	}
Exemplo n.º 7
0
D3D11DepthStencilStateObject::D3D11DepthStencilStateObject(DepthStencilStateDesc const & desc)
    : DepthStencilStateObject(desc)
{
    D3D11_DEPTH_STENCIL_DESC d3d_desc;
    d3d_desc.DepthEnable = desc.depth_enable;
    d3d_desc.DepthWriteMask = D3D11Mapping::Mapping(desc.depth_write_mask);
    d3d_desc.DepthFunc = D3D11Mapping::Mapping(desc.depth_func);
    d3d_desc.StencilEnable = desc.front_stencil_enable;
    d3d_desc.StencilReadMask = static_cast<uint8_t>(desc.front_stencil_read_mask);
    d3d_desc.StencilWriteMask = static_cast<uint8_t>(desc.front_stencil_write_mask);
    d3d_desc.FrontFace.StencilFailOp = D3D11Mapping::Mapping(desc.front_stencil_fail);
    d3d_desc.FrontFace.StencilDepthFailOp = D3D11Mapping::Mapping(desc.front_stencil_depth_fail);
    d3d_desc.FrontFace.StencilPassOp = D3D11Mapping::Mapping(desc.front_stencil_pass);
    d3d_desc.FrontFace.StencilFunc = D3D11Mapping::Mapping(desc.front_stencil_func);
    d3d_desc.BackFace.StencilFailOp = D3D11Mapping::Mapping(desc.back_stencil_fail);
    d3d_desc.BackFace.StencilDepthFailOp = D3D11Mapping::Mapping(desc.back_stencil_depth_fail);
    d3d_desc.BackFace.StencilPassOp = D3D11Mapping::Mapping(desc.back_stencil_pass);
    d3d_desc.BackFace.StencilFunc = D3D11Mapping::Mapping(desc.back_stencil_func);

    ID3D11Device* d3d_device = checked_cast<D3D11RenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance())->D3DDevice().get();

    ID3D11DepthStencilState* ds_state;
    TIF(d3d_device->CreateDepthStencilState(&d3d_desc, &ds_state));
    depth_stencil_state_ = MakeCOMPtr(ds_state);
}
Exemplo n.º 8
0
D3D11RasterizerStateObject::D3D11RasterizerStateObject(RasterizerStateDesc const & desc)
    : RasterizerStateObject(desc)
{
    D3D11RenderEngine& re = *checked_cast<D3D11RenderEngine*>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
    ID3D11Device* d3d_device = re.D3DDevice().get();

    D3D11_RASTERIZER_DESC d3d_desc;
    d3d_desc.FillMode = D3D11Mapping::Mapping(desc.polygon_mode);
    d3d_desc.CullMode = D3D11Mapping::Mapping(desc.cull_mode);
    d3d_desc.FrontCounterClockwise = desc.front_face_ccw;
    d3d_desc.DepthBias = static_cast<int>(desc.polygon_offset_units);
    d3d_desc.DepthBiasClamp = desc.polygon_offset_units;
    d3d_desc.SlopeScaledDepthBias = desc.polygon_offset_factor;
    d3d_desc.DepthClipEnable = re.DeviceFeatureLevel() >= D3D_FEATURE_LEVEL_10_0 ? desc.depth_clip_enable : true;
    d3d_desc.ScissorEnable = desc.scissor_enable;
    d3d_desc.MultisampleEnable = desc.multisample_enable;
    d3d_desc.AntialiasedLineEnable = false;

    if (re.D3D11RuntimeSubVer() >= 1)
    {
        ID3D11Device1* d3d_device_1 = static_cast<ID3D11Device1*>(d3d_device);
        D3D11_RASTERIZER_DESC1 d3d_desc1;
        d3d_desc1.FillMode = d3d_desc.FillMode;
        d3d_desc1.CullMode = d3d_desc.CullMode;
        d3d_desc1.FrontCounterClockwise = d3d_desc.FrontCounterClockwise;
        d3d_desc1.DepthBias = d3d_desc.DepthBias;
        d3d_desc1.DepthBiasClamp = d3d_desc.DepthBiasClamp;
        d3d_desc1.SlopeScaledDepthBias = d3d_desc.SlopeScaledDepthBias;
        d3d_desc1.DepthClipEnable = d3d_desc.DepthClipEnable;
        d3d_desc1.ScissorEnable = d3d_desc.ScissorEnable;
        d3d_desc1.MultisampleEnable = d3d_desc.MultisampleEnable;
        d3d_desc1.AntialiasedLineEnable = d3d_desc.AntialiasedLineEnable;
        d3d_desc1.ForcedSampleCount = 0;

        ID3D11RasterizerState1* rasterizer_state;
        TIF(d3d_device_1->CreateRasterizerState1(&d3d_desc1, &rasterizer_state));
        rasterizer_state_ = MakeCOMPtr(rasterizer_state);
    }
    else
    {
        ID3D11RasterizerState* rasterizer_state;
        TIF(d3d_device->CreateRasterizerState(&d3d_desc, &rasterizer_state));
        rasterizer_state_ = MakeCOMPtr(rasterizer_state);
    }
}
Exemplo n.º 9
0
	void D3D11TextureCube::MapCube(uint32_t array_index, CubeFaces face, uint32_t level, TextureMapAccess tma,
			uint32_t x_offset, uint32_t y_offset, uint32_t /*width*/, uint32_t /*height*/,
			void*& data, uint32_t& row_pitch)
	{
		D3D11_MAPPED_SUBRESOURCE mapped;
		TIF(d3d_imm_ctx_->Map(d3dTextureCube_.get(), D3D11CalcSubresource(level, array_index * 6 + face - CF_Positive_X, num_mip_maps_),
			D3D11Mapping::Mapping(tma, type_, access_hint_, num_mip_maps_), 0, &mapped));
		uint8_t* p = static_cast<uint8_t*>(mapped.pData);
		data = p + y_offset * mapped.RowPitch + x_offset * NumFormatBytes(format_);
		row_pitch = mapped.RowPitch;
	}
Exemplo n.º 10
0
	HRESULT DShowVMR9Allocator::PresentImage(DWORD_PTR dwUserID, VMR9PresentationInfo* lpPresInfo)
	{
		if (dwUserID != USER_ID)
		{
			return S_OK;
		}

		// parameter validation
		if (nullptr == lpPresInfo)
		{
			return E_POINTER;
		}
		else
		{
			if (nullptr == lpPresInfo->lpSurf)
			{
				return E_POINTER;
			}
		}

		unique_lock<mutex> lock(mutex_);

		cur_surf_index_ = 0xFFFFFFFF;
		for (uint32_t i = 0; i < surfaces_.size(); ++ i)
		{
			if (surfaces_[i] == lpPresInfo->lpSurf)
			{
				cur_surf_index_ = i;
				break;
			}
		}

		if (D3DERR_DEVICENOTRESET == d3d_device_->TestCooperativeLevel())
		{
			cache_surf_.reset();

			for (size_t i = 0; i < surfaces_.size(); ++ i)
			{
				if (surfaces_[i] != nullptr)
				{
					surfaces_[i]->Release();
					surfaces_[i] = nullptr;
				}
			}

			this->CreateDevice();

			HMONITOR hMonitor = d3d_->GetAdapterMonitor(D3DADAPTER_DEFAULT);
			TIF(vmr_surf_alloc_notify_->ChangeD3DDevice(d3d_device_.get(), hMonitor));
		}

		return S_OK;
	}
Exemplo n.º 11
0
	void D3D11Texture3D::Map3D(uint32_t array_index, uint32_t level, TextureMapAccess tma,
			uint32_t x_offset, uint32_t y_offset, uint32_t z_offset,
			uint32_t /*width*/, uint32_t /*height*/, uint32_t /*depth*/,
			void*& data, uint32_t& row_pitch, uint32_t& slice_pitch)
	{
		D3D11_MAPPED_SUBRESOURCE mapped;
		TIF(d3d_imm_ctx_->Map(d3dTexture3D_.get(), D3D11CalcSubresource(level, array_index, num_mip_maps_), D3D11Mapping::Mapping(tma, type_, access_hint_, num_mip_maps_), 0, &mapped));
		uint8_t* p = static_cast<uint8_t*>(mapped.pData);
		data = p + z_offset * mapped.DepthPitch + y_offset * mapped.RowPitch + x_offset * NumFormatBytes(format_);
		row_pitch = mapped.RowPitch;
		slice_pitch = mapped.DepthPitch;
	}
Exemplo n.º 12
0
	HRESULT DShowVMR9Allocator::AdviseNotify(IVMRSurfaceAllocatorNotify9* lpIVMRSurfAllocNotify)
	{
		unique_lock<mutex> lock(mutex_);

		vmr_surf_alloc_notify_ = MakeCOMPtr(lpIVMRSurfAllocNotify);
		vmr_surf_alloc_notify_->AddRef();

		HMONITOR hMonitor = d3d_->GetAdapterMonitor(D3DADAPTER_DEFAULT);
		TIF(vmr_surf_alloc_notify_->SetD3DDevice(d3d_device_.get(), hMonitor));

		return S_OK;
	}
Exemplo n.º 13
0
	void DSMusicBuffer::LoopUpdateBuffer()
	{
		unique_lock<mutex> lock(play_mutex_);
		while (!played_)
		{
			play_cond_.wait(lock);
		}
		played_ = false;

		while (!stopped_)
		{
			// 锁定缓冲区
			uint8_t* lockedBuffer;			// 指向缓冲区锁定的内存的指针
			DWORD lockedBufferSize;		// 锁定的内存大小
			TIF(buffer_->Lock(fillSize_ * writePos_, fillSize_,
				reinterpret_cast<void**>(&lockedBuffer), &lockedBufferSize,
				nullptr, nullptr, 0));

			std::vector<uint8_t> data(fillSize_);
			data.resize(dataSource_->Read(&data[0], fillSize_));

			if (data.empty())
			{
				if (loop_)
				{
					stopped_ = false;
					this->Reset();
				}
				else
				{
					stopped_ = true;
				}
			}
			else
			{
				std::copy(data.begin(), data.end(), lockedBuffer);

				std::fill_n(lockedBuffer + data.size(), lockedBufferSize - data.size(), 0);
			}

			// 缓冲区解锁
			buffer_->Unlock(lockedBuffer, lockedBufferSize, nullptr, 0);

			// 形成环形缓冲区
			++ writePos_;
			writePos_ %= fillCount_;

			Sleep(1000 / PreSecond);
		}
	}
Exemplo n.º 14
0
D3D11SamplerStateObject::D3D11SamplerStateObject(SamplerStateDesc const & desc)
    : SamplerStateObject(desc)
{
    D3D11RenderEngine const & render_eng = *checked_cast<D3D11RenderEngine const *>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
    ID3D11Device* d3d_device = render_eng.D3DDevice().get();
    D3D_FEATURE_LEVEL feature_level = render_eng.DeviceFeatureLevel();

    D3D11_SAMPLER_DESC d3d_desc;
    d3d_desc.Filter = D3D11Mapping::Mapping(desc.filter);
    TexAddressingMode addr_mode_u = desc.addr_mode_u;
    if ((feature_level <= D3D_FEATURE_LEVEL_9_2) && (TAM_Border == desc.addr_mode_u))
    {
        addr_mode_u = TAM_Clamp;
    }
    d3d_desc.AddressU = D3D11Mapping::Mapping(addr_mode_u);
    TexAddressingMode addr_mode_v = desc.addr_mode_v;
    if ((feature_level <= D3D_FEATURE_LEVEL_9_2) && (TAM_Border == desc.addr_mode_u))
    {
        addr_mode_v = TAM_Clamp;
    }
    d3d_desc.AddressV = D3D11Mapping::Mapping(addr_mode_v);
    TexAddressingMode addr_mode_w = desc.addr_mode_w;
    if ((feature_level <= D3D_FEATURE_LEVEL_9_2) && (TAM_Border == desc.addr_mode_u))
    {
        addr_mode_w = TAM_Clamp;
    }
    d3d_desc.AddressW = D3D11Mapping::Mapping(addr_mode_w);
    d3d_desc.MipLODBias = desc.mip_map_lod_bias;
    d3d_desc.MaxAnisotropy = (feature_level <= D3D_FEATURE_LEVEL_9_1) ? 1 : desc.max_anisotropy;
    d3d_desc.ComparisonFunc = D3D11Mapping::Mapping(desc.cmp_func);
    d3d_desc.BorderColor[0] = desc.border_clr.r();
    d3d_desc.BorderColor[1] = desc.border_clr.g();
    d3d_desc.BorderColor[2] = desc.border_clr.b();
    d3d_desc.BorderColor[3] = desc.border_clr.a();
    if (feature_level <= D3D_FEATURE_LEVEL_9_3)
    {
        d3d_desc.MinLOD = floor(desc.min_lod);
        d3d_desc.MaxLOD = std::numeric_limits<float>::max();
    }
    else
    {
        d3d_desc.MinLOD = desc.min_lod;
        d3d_desc.MaxLOD = desc.max_lod;
    }

    ID3D11SamplerState* sampler_state;
    TIF(d3d_device->CreateSamplerState(&d3d_desc, &sampler_state));
    sampler_state_ = MakeCOMPtr(sampler_state);
}
Exemplo n.º 15
0
	// 构造函数。建立一个可以用于流式播放的缓冲区
	/////////////////////////////////////////////////////////////////////////////////
	DSMusicBuffer::DSMusicBuffer(AudioDataSourcePtr const & dataSource, uint32_t bufferSeconds, float volume)
					: MusicBuffer(dataSource),
						writePos_(0),
						played_(false), stopped_(true)
	{
		WAVEFORMATEX wfx(WaveFormatEx(dataSource));
		fillSize_	= wfx.nAvgBytesPerSec / PreSecond;
		fillCount_	= bufferSeconds * PreSecond;

		bool const mono(1 == wfx.nChannels);

		shared_ptr<IDirectSound> const & dsound = checked_cast<DSAudioEngine const *>(&Context::Instance().AudioFactoryInstance().AudioEngineInstance())->DSound();

		// 建立 DirectSound 缓冲区,要尽量减少使用建立标志,
		// 因为使用太多不必要的标志会影响硬件加速性能
		DSBUFFERDESC dsbd;
		std::memset(&dsbd, 0, sizeof(dsbd));
		dsbd.dwSize = sizeof(dsbd);
		dsbd.dwFlags = DSBCAPS_CTRLVOLUME;
		if (mono)
		{
			dsbd.dwFlags |= DSBCAPS_CTRL3D | DSBCAPS_MUTE3DATMAXDISTANCE;
			dsbd.guid3DAlgorithm	= GUID_NULL;
		}
		dsbd.dwBufferBytes		= fillSize_ * fillCount_;
		dsbd.lpwfxFormat		= &wfx;

		// DirectSound只能播放PCM数据。其他格式可能不能工作。
		IDirectSoundBuffer* buffer;
		TIF(dsound->CreateSoundBuffer(&dsbd, &buffer, nullptr));
		buffer_ = MakeCOMPtr(buffer);

		if (mono)
		{
			IDirectSound3DBuffer* ds3DBuffer;
			buffer_->QueryInterface(IID_IDirectSound3DBuffer,
				reinterpret_cast<void**>(&ds3DBuffer));
			ds3DBuffer_ = MakeCOMPtr(ds3DBuffer);
		}

		this->Position(float3::Zero());
		this->Velocity(float3::Zero());
		this->Direction(float3::Zero());

		this->Volume(volume);

		this->Reset();
	}
Exemplo n.º 16
0
	void Extract7z(ResIdentifierPtr const & archive_is,
							   std::string const & password,
							   std::string const & extract_file_path,
		std::shared_ptr<std::ostream> const & os)
	{
		std::shared_ptr<IInArchive> archive;
		uint32_t real_index;
		GetArchiveIndex(archive, real_index, archive_is, password, extract_file_path);
		if (real_index != 0xFFFFFFFF)
		{
			std::shared_ptr<ISequentialOutStream> out_stream = MakeCOMPtr(new COutStream);
			checked_pointer_cast<COutStream>(out_stream)->Attach(os);

			std::shared_ptr<IArchiveExtractCallback> ecb = MakeCOMPtr(new CArchiveExtractCallback);
			checked_pointer_cast<CArchiveExtractCallback>(ecb)->Init(password, out_stream);

			TIF(archive->Extract(&real_index, 1, false, ecb.get()));
		}
	}
Exemplo n.º 17
0
	void* D3D11GraphicsBuffer::Map(BufferAccess ba)
	{
		BOOST_ASSERT(buffer_);

		D3D11_MAP type;
		switch (ba)
		{
		case BA_Read_Only:
			type = D3D11_MAP_READ;
			break;

		case BA_Write_Only:
			if ((EAH_CPU_Write == access_hint_) || ((EAH_CPU_Write | EAH_GPU_Read) == access_hint_))
			{
				type = D3D11_MAP_WRITE_DISCARD;
			}
			else
			{
				type = D3D11_MAP_WRITE;
			}
			break;

		case BA_Read_Write:
			type = D3D11_MAP_READ_WRITE;
			break;

		case BA_Write_No_Overwrite:
			type = D3D11_MAP_WRITE_NO_OVERWRITE;
			break;

		default:
			BOOST_ASSERT(false);
			type = D3D11_MAP_READ;
			break;
		}

		D3D11_MAPPED_SUBRESOURCE mapped;
		TIF(d3d_imm_ctx_->Map(buffer_.get(), 0, type, 0, &mapped));
		return mapped.pData;
	}
Exemplo n.º 18
0
	D3D11Texture3D::D3D11Texture3D(uint32_t width, uint32_t height, uint32_t depth, uint32_t numMipMaps, uint32_t array_size, ElementFormat format,
						uint32_t sample_count, uint32_t sample_quality, uint32_t access_hint, ElementInitData const * init_data)
					: D3D11Texture(TT_3D, sample_count, sample_quality, access_hint)
	{
		BOOST_ASSERT(1 == array_size);

		if (0 == numMipMaps)
		{
			num_mip_maps_ = 1;
			uint32_t w = width;
			uint32_t h = height;
			uint32_t d = depth;
			while ((w != 1) || (h != 1) || (d != 1))
			{
				++ num_mip_maps_;

				w = std::max<uint32_t>(1U, w / 2);
				h = std::max<uint32_t>(1U, h / 2);
				d = std::max<uint32_t>(1U, d / 2);
			}
		}
		else
		{
			num_mip_maps_ = numMipMaps;
		}

		D3D11RenderEngine const & re = *checked_cast<D3D11RenderEngine const *>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
		if (re.DeviceFeatureLevel() <= D3D_FEATURE_LEVEL_9_3)
		{
			if ((num_mip_maps_ > 1) && (((width & (width - 1)) != 0) || ((height & (height - 1)) != 0) || ((depth & (depth - 1)) != 0)))
			{
				// height or width is not a power of 2 and multiple mip levels are specified. This is not supported at feature levels below 10.0.
				num_mip_maps_ = 1;
			}
		}

		array_size_ = array_size;
		format_		= format;
		widths_.assign(1, width);
		heights_.assign(1, height);
		depthes_.assign(1, depth);

		desc_.Width = width;
		desc_.Height = height;
		desc_.Depth = depth;
		desc_.MipLevels = num_mip_maps_;
		desc_.Format = D3D11Mapping::MappingFormat(format_);

		this->GetD3DFlags(desc_.Usage, desc_.BindFlags, desc_.CPUAccessFlags, desc_.MiscFlags);

		std::vector<D3D11_SUBRESOURCE_DATA> subres_data(num_mip_maps_);
		if (init_data != nullptr)
		{
			for (uint32_t i = 0; i < num_mip_maps_; ++ i)
			{
				subres_data[i].pSysMem = init_data[i].data;
				subres_data[i].SysMemPitch = init_data[i].row_pitch;
				subres_data[i].SysMemSlicePitch = init_data[i].slice_pitch;
			}
		}

		ID3D11Texture3D* d3d_tex;
		TIF(d3d_device_->CreateTexture3D(&desc_, (init_data != nullptr) ? &subres_data[0] : nullptr, &d3d_tex));
		d3dTexture3D_ = MakeCOMPtr(d3d_tex);

		this->UpdateParams();

		if ((access_hint & (EAH_GPU_Read | EAH_Generate_Mips)) && (num_mip_maps_ > 1))
		{
			this->RetriveD3DShaderResourceView(0, array_size_, 0, num_mip_maps_);
		}
	}
Exemplo n.º 19
0
	void D3D11GraphicsBuffer::CreateBuffer(D3D11_SUBRESOURCE_DATA const * subres_init)
	{
		D3D11_BUFFER_DESC desc;
		this->GetD3DFlags(desc.Usage, desc.CPUAccessFlags, desc.BindFlags, desc.MiscFlags);
		desc.ByteWidth = size_in_byte_;
		desc.StructureByteStride = NumFormatBytes(fmt_as_shader_res_);

		ID3D11Buffer* buffer;
		TIF(d3d_device_->CreateBuffer(&desc, subres_init, &buffer));
		buffer_ = MakeCOMPtr(buffer);

		if ((access_hint_ & EAH_GPU_Read) && (fmt_as_shader_res_ != EF_Unknown))
		{
			D3D11_SHADER_RESOURCE_VIEW_DESC sr_desc;
			sr_desc.Format = (access_hint_ & EAH_GPU_Structured) ? DXGI_FORMAT_UNKNOWN : D3D11Mapping::MappingFormat(fmt_as_shader_res_);
			sr_desc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
			sr_desc.Buffer.ElementOffset = 0;
			sr_desc.Buffer.ElementWidth = size_in_byte_ / desc.StructureByteStride;

			ID3D11ShaderResourceView* d3d_sr_view;
			TIF(d3d_device_->CreateShaderResourceView(buffer_.get(), &sr_desc, &d3d_sr_view));
			d3d_sr_view_ = MakeCOMPtr(d3d_sr_view);
		}

		if ((access_hint_ & EAH_GPU_Unordered) && (fmt_as_shader_res_ != EF_Unknown))
		{
			D3D11_UNORDERED_ACCESS_VIEW_DESC uav_desc;
			if (access_hint_ & EAH_Raw)
			{
				uav_desc.Format = DXGI_FORMAT_R32_TYPELESS;
			}
			else if (access_hint_ & EAH_GPU_Structured)
			{
				uav_desc.Format = DXGI_FORMAT_UNKNOWN;
			}
			else
			{
				uav_desc.Format = D3D11Mapping::MappingFormat(fmt_as_shader_res_);
			}
			uav_desc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
			uav_desc.Buffer.FirstElement = 0;
			uav_desc.Buffer.NumElements = size_in_byte_ / desc.StructureByteStride;
			uav_desc.Buffer.Flags = 0;
			if (access_hint_ & EAH_Raw)
			{
				uav_desc.Buffer.Flags |= D3D11_BUFFER_UAV_FLAG_RAW;
			}
			if (access_hint_ & EAH_Append)
			{
				uav_desc.Buffer.Flags |= D3D11_BUFFER_UAV_FLAG_APPEND;
			}
			if (access_hint_ & EAH_Counter)
			{
				uav_desc.Buffer.Flags |= D3D11_BUFFER_UAV_FLAG_COUNTER;
			}

			ID3D11UnorderedAccessView* d3d_ua_view;
			TIF(d3d_device_->CreateUnorderedAccessView(buffer_.get(), &uav_desc, &d3d_ua_view));
			d3d_ua_view_ = MakeCOMPtr(d3d_ua_view);
		}
	}
Exemplo n.º 20
0
	void D3D11RenderWindow::UpdateSurfacesPtrs()
	{
		RenderFactory& rf = Context::Instance().RenderFactoryInstance();
		D3D11RenderEngine& d3d11_re = *checked_cast<D3D11RenderEngine*>(&rf.RenderEngineInstance());
		ID3D11DevicePtr d3d_device = d3d11_re.D3DDevice();

		// Create a render target view
		ID3D11Texture2D* back_buffer;
		TIF(swap_chain_->GetBuffer(0, IID_ID3D11Texture2D, reinterpret_cast<void**>(&back_buffer)));
		back_buffer_ = MakeCOMPtr(back_buffer);
		D3D11_TEXTURE2D_DESC bb_desc;
		back_buffer_->GetDesc(&bb_desc);

		D3D11_RENDER_TARGET_VIEW_DESC rtv_desc;
		rtv_desc.Format = bb_desc.Format;
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
		if (dxgi_sub_ver_ >= 2)
		{
			if (bb_desc.SampleDesc.Count > 1)
			{
				rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY;
				rtv_desc.Texture2DMSArray.FirstArraySlice = 0;
				rtv_desc.Texture2DMSArray.ArraySize = 1;
			}
			else
			{
				rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
				rtv_desc.Texture2DArray.MipSlice = 0;
				rtv_desc.Texture2DArray.FirstArraySlice = 0;
				rtv_desc.Texture2DArray.ArraySize = 1;
			}
		}
		else
#endif
		{
			if (bb_desc.SampleDesc.Count > 1)
			{
				rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
			}
			else
			{
				rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
				rtv_desc.Texture2D.MipSlice = 0;
			}
		}
		ID3D11RenderTargetView* render_target_view;
		TIF(d3d_device->CreateRenderTargetView(back_buffer_.get(), &rtv_desc, &render_target_view));
		render_target_view_ = MakeCOMPtr(render_target_view);

#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
		bool stereo = (STM_LCDShutter == Context::Instance().Config().graphics_cfg.stereo_method) && dxgi_stereo_support_;

		if (stereo)
		{
			if (bb_desc.SampleDesc.Count > 1)
			{
				rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY;
				rtv_desc.Texture2DMSArray.FirstArraySlice = 1;
				rtv_desc.Texture2DMSArray.ArraySize = 1;
			}
			else
			{
				rtv_desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY;
				rtv_desc.Texture2DArray.MipSlice = 0;
				rtv_desc.Texture2DArray.FirstArraySlice = 1;
				rtv_desc.Texture2DArray.ArraySize = 1;
			}
			TIF(d3d_device->CreateRenderTargetView(back_buffer_.get(), &rtv_desc, &render_target_view));
			render_target_view_right_eye_ = MakeCOMPtr(render_target_view);
		}
#else
		bool stereo = false;
#endif

		if (depth_stencil_format_ != DXGI_FORMAT_UNKNOWN)
		{
			// Create depth stencil texture
			D3D11_TEXTURE2D_DESC ds_desc;
			ds_desc.Width = this->Width();
			ds_desc.Height = this->Height();
			ds_desc.MipLevels = 1;
			ds_desc.ArraySize = stereo ? 2 : 1;
			ds_desc.Format = depth_stencil_format_;
			ds_desc.SampleDesc.Count = bb_desc.SampleDesc.Count;
			ds_desc.SampleDesc.Quality = bb_desc.SampleDesc.Quality;
			ds_desc.Usage = D3D11_USAGE_DEFAULT;
			ds_desc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
			ds_desc.CPUAccessFlags = 0;
			ds_desc.MiscFlags = 0;
			ID3D11Texture2D* depth_stencil;
			TIF(d3d_device->CreateTexture2D(&ds_desc, nullptr, &depth_stencil));
			depth_stencil_ = MakeCOMPtr(depth_stencil);

			// Create the depth stencil view
			D3D11_DEPTH_STENCIL_VIEW_DESC dsv_desc;
			dsv_desc.Format = depth_stencil_format_;
			dsv_desc.Flags = 0;
#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
			if (dxgi_sub_ver_ >= 2)
			{
				if (bb_desc.SampleDesc.Count > 1)
				{
					dsv_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY;
					dsv_desc.Texture2DMSArray.FirstArraySlice = 0;
					dsv_desc.Texture2DMSArray.ArraySize = 1;
				}
				else
				{
					dsv_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY;
					dsv_desc.Texture2DArray.MipSlice = 0;
					dsv_desc.Texture2DArray.FirstArraySlice = 0;
					dsv_desc.Texture2DArray.ArraySize = 1;
				}
			}
			else
#endif
			{
				if (bb_desc.SampleDesc.Count > 1)
				{
					dsv_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMS;
				}
				else
				{
					dsv_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
					dsv_desc.Texture2D.MipSlice = 0;
				}
			}
			ID3D11DepthStencilView* depth_stencil_view;
			TIF(d3d_device->CreateDepthStencilView(depth_stencil_.get(), &dsv_desc, &depth_stencil_view));
			depth_stencil_view_ = MakeCOMPtr(depth_stencil_view);

#if (_WIN32_WINNT >= _WIN32_WINNT_WIN8)
			if (stereo)
			{
				if (bb_desc.SampleDesc.Count > 1)
				{
					dsv_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY;
					dsv_desc.Texture2DMSArray.FirstArraySlice = 1;
					dsv_desc.Texture2DMSArray.ArraySize = 1;
				}
				else
				{
					dsv_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY;
					dsv_desc.Texture2DArray.MipSlice = 0;
					dsv_desc.Texture2DArray.FirstArraySlice = 1;
					dsv_desc.Texture2DArray.ArraySize = 1;
				}
				TIF(d3d_device->CreateDepthStencilView(depth_stencil_.get(), &dsv_desc, &depth_stencil_view));
				depth_stencil_view_right_eye_ = MakeCOMPtr(depth_stencil_view);
			}
#endif
		}

		if (!!stereo_amd_qb_ext_)
		{
			stereo_amd_right_eye_height_ = stereo_amd_qb_ext_->GetLineOffset(swap_chain_.get());
		}

		this->Attach(ATT_Color0, MakeSharedPtr<D3D11RenderTargetRenderView>(render_target_view_,
			this->Width(), this->Height(), D3D11Mapping::MappingFormat(back_buffer_format_)));
		if (depth_stencil_view_)
		{
			this->Attach(ATT_DepthStencil, MakeSharedPtr<D3D11DepthStencilRenderView>(depth_stencil_view_,
				this->Width(), this->Height(), D3D11Mapping::MappingFormat(depth_stencil_format_)));
		}
	}
Exemplo n.º 21
0
	D3D11TextureCube::D3D11TextureCube(uint32_t size, uint32_t numMipMaps, uint32_t array_size, ElementFormat format,
						uint32_t sample_count, uint32_t sample_quality, uint32_t access_hint, ElementInitData const * init_data)
					: D3D11Texture(TT_Cube, sample_count, sample_quality, access_hint)
	{
		if (0 == numMipMaps)
		{
			num_mip_maps_ = 1;
			uint32_t w = size;
			while (w != 1)
			{
				++ num_mip_maps_;

				w = std::max<uint32_t>(1U, w / 2);
			}
		}
		else
		{
			num_mip_maps_ = numMipMaps;
		}

		D3D11RenderEngine const & re = *checked_cast<D3D11RenderEngine const *>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance());
		if (re.DeviceFeatureLevel() <= D3D_FEATURE_LEVEL_9_3)
		{
			if ((num_mip_maps_ > 1) && ((size & (size - 1)) != 0))
			{
				// height or width is not a power of 2 and multiple mip levels are specified. This is not supported at feature levels below 10.0.
				num_mip_maps_ = 1;
			}
		}

		array_size_ = array_size;
		format_		= format;
		widths_.assign(1, size);

		desc_.Width = size;
		desc_.Height = size;
		desc_.MipLevels = num_mip_maps_;
		desc_.ArraySize = 6 * array_size_;
		desc_.Format = D3D11Mapping::MappingFormat(format_);
		desc_.SampleDesc.Count = 1;
		desc_.SampleDesc.Quality = 0;

		this->GetD3DFlags(desc_.Usage, desc_.BindFlags, desc_.CPUAccessFlags, desc_.MiscFlags);
		desc_.MiscFlags |= D3D11_RESOURCE_MISC_TEXTURECUBE;

		std::vector<D3D11_SUBRESOURCE_DATA> subres_data(6 * num_mip_maps_);
		if (init_data != nullptr)
		{
			for (int face = 0; face < 6; ++ face)
			{
				for (uint32_t i = 0; i < num_mip_maps_; ++ i)
				{
					subres_data[face * num_mip_maps_ + i].pSysMem = init_data[face * num_mip_maps_ + i].data;
					subres_data[face * num_mip_maps_ + i].SysMemPitch = init_data[face * num_mip_maps_ + i].row_pitch;
					subres_data[face * num_mip_maps_ + i].SysMemSlicePitch = init_data[face * num_mip_maps_ + i].slice_pitch;
				}
			}
		}

		ID3D11Texture2D* d3d_tex;
		TIF(d3d_device_->CreateTexture2D(&desc_, (init_data != nullptr) ? &subres_data[0] : nullptr, &d3d_tex));
		d3dTextureCube_ = MakeCOMPtr(d3d_tex);

		this->UpdateParams();

		if ((access_hint & (EAH_GPU_Read | EAH_Generate_Mips)) && (num_mip_maps_ > 1))
		{
			this->RetriveD3DShaderResourceView(0, array_size_, 0, num_mip_maps_);
		}
	}
Exemplo n.º 22
0
	//IVMRSurfaceAllocator9
	HRESULT DShowVMR9Allocator::InitializeDevice(DWORD_PTR dwUserID,
				VMR9AllocationInfo* lpAllocInfo, DWORD* lpNumBuffers)
	{
		if (dwUserID != USER_ID)
		{
			return S_OK;
		}

		if (nullptr == lpNumBuffers)
		{
			return E_POINTER;
		}

		if (!vmr_surf_alloc_notify_)
		{
			return E_FAIL;
		}

		HRESULT hr = S_OK;

		// NOTE:
		// we need to make sure that we create textures because
		// surfaces can not be textured onto a primitive.
		lpAllocInfo->dwFlags |= VMR9AllocFlag_TextureSurface;

		this->DeleteSurfaces();
		surfaces_.resize(*lpNumBuffers);
		hr = vmr_surf_alloc_notify_->AllocateSurfaceHelper(lpAllocInfo, lpNumBuffers, &surfaces_[0]);

		// If we couldn't create a texture surface and
		// the format is not an alpha format,
		// then we probably cannot create a texture.
		// So what we need to do is create a private texture
		// and copy the decoded images onto it.
		if (FAILED(hr) && !(lpAllocInfo->dwFlags & VMR9AllocFlag_3DRenderTarget))
		{
			this->DeleteSurfaces();

			lpAllocInfo->dwFlags &= ~VMR9AllocFlag_TextureSurface;
			lpAllocInfo->dwFlags |= VMR9AllocFlag_OffscreenSurface;

			TIF(vmr_surf_alloc_notify_->AllocateSurfaceHelper(lpAllocInfo, lpNumBuffers, &surfaces_[0]));
		}


		RenderFactory& rf = Context::Instance().RenderFactoryInstance();
		ElementFormat fmt;
		if (Context::Instance().Config().graphics_cfg.gamma)
		{
			if (rf.RenderEngineInstance().DeviceCaps().texture_format_support(EF_ABGR8_SRGB))
			{
				fmt = EF_ABGR8_SRGB;
			}
			else
			{
				if (rf.RenderEngineInstance().DeviceCaps().texture_format_support(EF_ARGB8_SRGB))
				{
					fmt = EF_ARGB8_SRGB;
				}
				else
				{
					if (rf.RenderEngineInstance().DeviceCaps().texture_format_support(EF_ABGR8))
					{
						fmt = EF_ABGR8;
					}
					else
					{
						BOOST_ASSERT(rf.RenderEngineInstance().DeviceCaps().texture_format_support(EF_ARGB8));

						fmt = EF_ARGB8;
					}
				}
			}
		}
		else
		{
			if (rf.RenderEngineInstance().DeviceCaps().texture_format_support(EF_ABGR8))
			{
				fmt = EF_ABGR8;
			}
			else
			{
				BOOST_ASSERT(rf.RenderEngineInstance().DeviceCaps().texture_format_support(EF_ARGB8));

				fmt = EF_ARGB8;
			}
		}
		present_tex_ = rf.MakeTexture2D(lpAllocInfo->dwWidth, lpAllocInfo->dwHeight, 1, 1, fmt, 1, 0, EAH_CPU_Write | EAH_GPU_Read, nullptr);

		IDirect3DSurface9* surf;
		TIF(d3d_device_->CreateOffscreenPlainSurface(lpAllocInfo->dwWidth, lpAllocInfo->dwHeight,
			D3DFMT_X8R8G8B8, D3DPOOL_SYSTEMMEM, &surf, nullptr));
		cache_surf_ = MakeCOMPtr(surf);

		return S_OK;
	}