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; }
D3D11OcclusionQuery::D3D11OcclusionQuery() { D3D11RenderEngine const & re = *checked_cast<D3D11RenderEngine const *>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance()); ID3D11Device* d3d_device = re.D3DDevice(); D3D11_QUERY_DESC desc; desc.Query = D3D11_QUERY_OCCLUSION; desc.MiscFlags = 0; ID3D11Query* query; d3d_device->CreateQuery(&desc, &query); query_ = MakeCOMPtr(query); }
D3D11SOStatisticsQuery::D3D11SOStatisticsQuery() { D3D11RenderEngine const & re = *checked_cast<D3D11RenderEngine const *>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance()); ID3D11Device* d3d_device = re.D3DDevice(); D3D11_QUERY_DESC desc; desc.Query = D3D11_QUERY_SO_STATISTICS; desc.MiscFlags = 0; ID3D11Query* start_query; d3d_device->CreateQuery(&desc, &start_query); so_stat_query_ = MakeCOMPtr(start_query); }
D3D11ConditionalRender::D3D11ConditionalRender() { D3D11RenderEngine const & render_eng = *checked_cast<D3D11RenderEngine const *>(&Context::Instance().RenderFactoryInstance().RenderEngineInstance()); ID3D11Device* d3d_device = render_eng.D3DDevice(); D3D11_QUERY_DESC desc; desc.Query = D3D11_QUERY_OCCLUSION_PREDICATE; desc.MiscFlags = 0; ID3D11Predicate* predicate; d3d_device->CreatePredicate(&desc, &predicate); predicate_ = MakeCOMPtr(predicate); }
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); }
ID3D11ShaderResourceViewPtr const & D3D11Texture::RetriveD3DSRV(D3D11_SHADER_RESOURCE_VIEW_DESC const & desc) { char const * p = reinterpret_cast<char const *>(&desc); size_t hash_val = 0; boost::hash_range(hash_val, p, p + sizeof(desc)); KLAYGE_AUTO(iter, d3d_sr_views_.find(hash_val)); if (iter != d3d_sr_views_.end()) { return iter->second; } ID3D11ShaderResourceView* d3d_sr_view; d3d_device_->CreateShaderResourceView(this->D3DResource().get(), &desc, &d3d_sr_view); KLAYGE_AUTO(ret, d3d_sr_views_.insert(std::make_pair(hash_val, MakeCOMPtr(d3d_sr_view)))); return ret.first->second; }
ID3D11UnorderedAccessViewPtr const & D3D11Texture::RetriveD3DUAV(D3D11_UNORDERED_ACCESS_VIEW_DESC const & desc) { char const * p = reinterpret_cast<char const *>(&desc); size_t hash_val = 0; boost::hash_range(hash_val, p, p + sizeof(desc)); KLAYGE_AUTO(iter, d3d_ua_views_.find(hash_val)); if (iter != d3d_ua_views_.end()) { return iter->second; } ID3D11UnorderedAccessView* d3d_ua_view; d3d_device_->CreateUnorderedAccessView(this->D3DResource().get(), &desc, &d3d_ua_view); KLAYGE_AUTO(ret, d3d_ua_views_.insert(std::make_pair(hash_val, MakeCOMPtr(d3d_ua_view)))); return ret.first->second; }
ID3D11RenderTargetViewPtr const & D3D11Texture::RetriveD3DRTV(D3D11_RENDER_TARGET_VIEW_DESC const & desc) { char const * p = reinterpret_cast<char const *>(&desc); size_t hash_val = 0; boost::hash_range(hash_val, p, p + sizeof(desc)); KLAYGE_AUTO(iter, d3d_rt_views_.find(hash_val)); if (iter != d3d_rt_views_.end()) { return iter->second; } ID3D11RenderTargetView* rt_view; d3d_device_->CreateRenderTargetView(this->D3DResource().get(), &desc, &rt_view); KLAYGE_AUTO(ret, d3d_rt_views_.insert(std::make_pair(hash_val, MakeCOMPtr(rt_view)))); return ret.first->second; }
ID3D11DepthStencilViewPtr const & D3D11Texture::RetriveD3DDSV(D3D11_DEPTH_STENCIL_VIEW_DESC const & desc) { char const * p = reinterpret_cast<char const *>(&desc); size_t hash_val = 0; boost::hash_range(hash_val, p, p + sizeof(desc)); KLAYGE_AUTO(iter, d3d_ds_views_.find(hash_val)); if (iter != d3d_ds_views_.end()) { return iter->second; } ID3D11DepthStencilView* ds_view; d3d_device_->CreateDepthStencilView(this->D3DResource().get(), &desc, &ds_view); KLAYGE_AUTO(ret, d3d_ds_views_.insert(std::make_pair(hash_val, MakeCOMPtr(ds_view)))); return ret.first->second; }
D3D11VertexLayout::D3D11VertexLayout(const vertex_elements_type& format, void* code, uint32 signature, D3D11GraphicDevice* device, uint32 instance_start, uint32 instance_end): mSignature(0) { ID3D11InputLayout* layout = D3D11ShaderUtilities::CreateLayout( device->getD3DDevice(), code, signature, format, instance_start, instance_end); if(layout) { mLayout = MakeCOMPtr(layout); mSignature = signature; } }
DShowVMR9Allocator::DShowVMR9Allocator(HWND wnd) : wnd_(wnd), ref_count_(1), cur_surf_index_(0xFFFFFFFF) { mod_d3d9_ = ::LoadLibraryW(L"d3d9.dll"); if (nullptr == mod_d3d9_) { ::MessageBoxW(nullptr, L"Can't load d3d9.dll", L"Error", MB_OK); } if (mod_d3d9_ != nullptr) { DynamicDirect3DCreate9_ = reinterpret_cast<Direct3DCreate9Func>(::GetProcAddress(mod_d3d9_, "Direct3DCreate9")); } d3d_ = MakeCOMPtr(DynamicDirect3DCreate9_(D3D_SDK_VERSION)); this->CreateDevice(); }
// 枚举系统显卡 ///////////////////////////////////////////////////////////////////////////////// void D3D11AdapterList::Enumerate(IDXGIFactory1Ptr const & gi_factory) { // 枚举系统中的适配器 UINT adapter_no = 0; IDXGIAdapter1* dxgi_adapter = nullptr; while (gi_factory->EnumAdapters1(adapter_no, &dxgi_adapter) != DXGI_ERROR_NOT_FOUND) { if (dxgi_adapter != nullptr) { D3D11AdapterPtr adapter = MakeSharedPtr<D3D11Adapter>(adapter_no, MakeCOMPtr(dxgi_adapter)); adapter->Enumerate(); adapters_.push_back(adapter); } ++ adapter_no; } // 如果没有找到兼容的设备则抛出错误 if (adapters_.empty()) { THR(errc::function_not_supported); } }
void D3D11TextureCube::CreateHWResource(ArrayRef<ElementInitData> init_data, float4 const * clear_value_hint) { KFL_UNUSED(clear_value_hint); D3D11_TEXTURE2D_DESC desc; desc.Width = width_; desc.Height = width_; 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; if (!init_data.empty()) { BOOST_ASSERT(init_data.size() == 6 * array_size_ * num_mip_maps_); subres_data.resize(init_data.size()); for (size_t i = 0; i < init_data.size(); ++ 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; } } ID3D11Texture2D* d3d_tex; TIFHR(d3d_device_->CreateTexture2D(&desc, subres_data.data(), &d3d_tex)); d3d_texture_ = MakeCOMPtr(d3d_tex); if ((access_hint_ & (EAH_GPU_Read | EAH_Generate_Mips)) && (num_mip_maps_ > 1)) { this->RetriveD3DShaderResourceView(0, array_size_, 0, num_mip_maps_); } }
ID3D11ShaderResourceViewPtr const & D3D11Texture::RetriveD3DSRV(D3D11_SHADER_RESOURCE_VIEW_DESC const & desc) { if (this->HWResourceReady()) { char const * p = reinterpret_cast<char const *>(&desc); size_t hash_val = 0; boost::hash_range(hash_val, p, p + sizeof(desc)); auto iter = d3d_sr_views_.find(hash_val); if (iter != d3d_sr_views_.end()) { return iter->second; } ID3D11ShaderResourceView* d3d_sr_view; d3d_device_->CreateShaderResourceView(this->D3DResource(), &desc, &d3d_sr_view); return d3d_sr_views_.emplace(hash_val, MakeCOMPtr(d3d_sr_view)).first->second; } else { static ID3D11ShaderResourceViewPtr view; return view; } }
ID3D11UnorderedAccessViewPtr const & D3D11Texture::RetriveD3DUAV(D3D11_UNORDERED_ACCESS_VIEW_DESC const & desc) { if (this->HWResourceReady()) { char const * p = reinterpret_cast<char const *>(&desc); size_t hash_val = 0; boost::hash_range(hash_val, p, p + sizeof(desc)); auto iter = d3d_ua_views_.find(hash_val); if (iter != d3d_ua_views_.end()) { return iter->second; } ID3D11UnorderedAccessView* d3d_ua_view; d3d_device_->CreateUnorderedAccessView(this->D3DResource(), &desc, &d3d_ua_view); return d3d_ua_views_.emplace(hash_val, MakeCOMPtr(d3d_ua_view)).first->second; } else { static ID3D11UnorderedAccessViewPtr view; return view; } }
ID3D11RenderTargetViewPtr const & D3D11Texture::RetriveD3DRTV(D3D11_RENDER_TARGET_VIEW_DESC const & desc) { if (this->HWResourceReady()) { char const * p = reinterpret_cast<char const *>(&desc); size_t hash_val = 0; boost::hash_range(hash_val, p, p + sizeof(desc)); auto iter = d3d_rt_views_.find(hash_val); if (iter != d3d_rt_views_.end()) { return iter->second; } ID3D11RenderTargetView* rt_view; d3d_device_->CreateRenderTargetView(this->D3DResource(), &desc, &rt_view); return d3d_rt_views_.emplace(hash_val, MakeCOMPtr(rt_view)).first->second; } else { static ID3D11RenderTargetViewPtr view; return view; } }
ID3D11DepthStencilViewPtr const & D3D11Texture::RetriveD3DDSV(D3D11_DEPTH_STENCIL_VIEW_DESC const & desc) { if (this->HWResourceReady()) { char const * p = reinterpret_cast<char const *>(&desc); size_t hash_val = 0; boost::hash_range(hash_val, p, p + sizeof(desc)); auto iter = d3d_ds_views_.find(hash_val); if (iter != d3d_ds_views_.end()) { return iter->second; } ID3D11DepthStencilView* ds_view; d3d_device_->CreateDepthStencilView(this->D3DResource(), &desc, &ds_view); return d3d_ds_views_.emplace(hash_val, MakeCOMPtr(ds_view)).first->second; } else { static ID3D11DepthStencilViewPtr view; return view; } }
D3D11SamplerStateObject::D3D11SamplerStateObject(const SamplerStateDesc& desc, D3D11GraphicDevice* device): SamplerStateObject(desc) { D3D11_SAMPLER_DESC d3ddesc; ZeroMemory(&d3ddesc, sizeof(D3D11_SAMPLER_DESC)); d3ddesc.AddressU = _rs_to_tex_address( desc.address_u ); d3ddesc.AddressV = _rs_to_tex_address( desc.address_v ); d3ddesc.AddressW = _rs_to_tex_address( desc.address_w ); d3ddesc.MaxAnisotropy = desc.max_anisotropy; d3ddesc.Filter = _rs_to_filter( desc.filter ); // default values, currently not mapped in ukn d3ddesc.MinLOD = -FLT_MAX; d3ddesc.MaxLOD = FLT_MAX; d3ddesc.ComparisonFunc = D3D11_COMPARISON_NEVER; ID3D11SamplerState* samplerState; if(D3D11Debug::CHECK_RESULT(device->getD3DDevice()->CreateSamplerState(&d3ddesc, &samplerState))) { mSamplerState = MakeCOMPtr(samplerState); } else { log_error(L"D3D11SamplerStateObject: error creating sampler state"); } }
// 改变窗口大小 ///////////////////////////////////////////////////////////////////////////////// void D3D11RenderWindow::Resize(uint32_t width, uint32_t height) { width_ = width; height_ = height; // Notify viewports of resize viewport_->width = width; viewport_->height = height; RenderFactory& rf = Context::Instance().RenderFactoryInstance(); D3D11RenderEngine& d3d11_re = *checked_cast<D3D11RenderEngine*>(&rf.RenderEngineInstance()); ID3D11DeviceContextPtr d3d_imm_ctx = d3d11_re.D3DDeviceImmContext(); if (d3d_imm_ctx) { d3d_imm_ctx->ClearState(); } for (size_t i = 0; i < clr_views_.size(); ++ i) { clr_views_[i].reset(); } rs_view_.reset(); #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) render_target_view_right_eye_.reset(); depth_stencil_view_right_eye_.reset(); #endif render_target_view_.reset(); depth_stencil_view_.reset(); back_buffer_.reset(); depth_stencil_.reset(); UINT flags = 0; if (this->FullScreen()) { flags |= DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH; } this->OnUnbind(); #ifdef KLAYGE_PLATFORM_WINDOWS_DESKTOP #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) if (dxgi_sub_ver_ >= 2) { dxgi_stereo_support_ = gi_factory_2_->IsWindowedStereoEnabled() ? true : false; sc_desc1_.Width = width_; sc_desc1_.Height = height_; sc_desc1_.Stereo = (STM_LCDShutter == Context::Instance().Config().graphics_cfg.stereo_method) && dxgi_stereo_support_; } else #endif { sc_desc_.BufferDesc.Width = width_; sc_desc_.BufferDesc.Height = height_; } #else dxgi_stereo_support_ = gi_factory_2_->IsWindowedStereoEnabled() ? true : false; sc_desc1_.Width = width_; sc_desc1_.Height = height_; sc_desc1_.Stereo = (STM_LCDShutter == Context::Instance().Config().graphics_cfg.stereo_method) && dxgi_stereo_support_; #endif if (!!swap_chain_) { swap_chain_->ResizeBuffers(2, width, height, back_buffer_format_, flags); } else { ID3D11DevicePtr d3d_device = d3d11_re.D3DDevice(); #ifdef KLAYGE_PLATFORM_WINDOWS_DESKTOP #if (_WIN32_WINNT >= _WIN32_WINNT_WIN8) if (dxgi_sub_ver_ >= 2) { IDXGISwapChain1* sc = nullptr; gi_factory_2_->CreateSwapChainForHwnd(d3d_device.get(), hWnd_, &sc_desc1_, &sc_fs_desc_, nullptr, &sc); swap_chain_ = MakeCOMPtr(sc); } else #endif { IDXGISwapChain* sc = nullptr; gi_factory_->CreateSwapChain(d3d_device.get(), &sc_desc_, &sc); swap_chain_ = MakeCOMPtr(sc); } swap_chain_->SetFullscreenState(this->FullScreen(), nullptr); #else IDXGISwapChain1* sc = nullptr; gi_factory_2_->CreateSwapChainForCoreWindow(d3d_device.get(), reinterpret_cast<IUnknown*>(wnd_.Get()), &sc_desc1_, nullptr, &sc); swap_chain_ = MakeCOMPtr(sc); #endif Verify(!!swap_chain_); } this->UpdateSurfacesPtrs(); d3d11_re.ResetRenderStates(); this->OnBind(); App3DFramework& app = Context::Instance().AppInstance(); app.OnResize(width, height); }
D3D11GraphBuffer::D3D11GraphBuffer(EBufferUsage eUsage, uint32 uAccess, uint32 uBindFlag, PixelInitData const* cpInitData, PixelFormat Fmt) : CGraphBuffer(eUsage, uAccess), m_uBindFlag(uBindFlag), m_uBufSize(0), m_FmtShader(Fmt) { if ((m_uAcces & EAH_GPU_Unordered) && (m_FmtShader != EF_Unknown)) { m_uBindFlag = 0; } D3D11Render const & ren(*checked_cast<D3D11Render const *>(&MonFac::Only().InstFactory().InstRender())); m_pDevice = ren.GetD3DDevice(); m_pImmContext = ren.GetD3DDeviceImmContext(); m_uByteSize = 0; //填写 desc 结构 if (cpInitData != NULL) { D3D11_BUFFER_DESC buf_desc; this->GetD3DFlags(buf_desc.Usage, buf_desc.CPUAccessFlags, buf_desc.BindFlags, buf_desc.MiscFlags); //数据长度 buf_desc.ByteWidth = cpInitData->m_uRowPitch; m_uByteSize = cpInitData->m_uRowPitch; //缓冲格式 buf_desc.StructureByteStride = NumFormatBytes(m_FmtShader); //填充这个玩意 D3D11_SUBRESOURCE_DATA subres_init; subres_init.pSysMem = cpInitData->m_cpData; subres_init.SysMemPitch = cpInitData->m_uRowPitch; subres_init.SysMemSlicePitch = cpInitData->m_uSlicePitch; //可以开始创建 buffer ID3D11Buffer* buffer; ErO(m_pDevice->CreateBuffer(&buf_desc, &subres_init, &buffer)); m_pBuf = MakeCOMPtr(buffer); m_uBufSize = this->GetSize(); //填写buffer 详细信息 if ((m_uAcces & EAH_GPU_Read) && (m_FmtShader != EF_Unknown)) { //shader 资源 view D3D11_SHADER_RESOURCE_VIEW_DESC sr_desc; sr_desc.Format = (m_uAcces & EAH_GPU_Structured) ? DXGI_FORMAT_UNKNOWN : D3D11Mapping::MappingFormat(m_FmtShader); //资源类型 sr_desc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER; //视图访问的第一个元素 sr_desc.Buffer.ElementOffset = 0; //全部成员个数 sr_desc.Buffer.ElementWidth = m_uByteSize / NumFormatBytes(m_FmtShader); //创建buf 类型shader资源 ID3D11ShaderResourceView* d3d_sr_view; ErO(m_pDevice->CreateShaderResourceView(m_pBuf.get(), &sr_desc, &d3d_sr_view)); m_pShaderRes = MakeCOMPtr(d3d_sr_view); } //无序访问资源 view if ((m_uAcces & EAH_GPU_Unordered) && (m_FmtShader != EF_Unknown)) { D3D11_UNORDERED_ACCESS_VIEW_DESC uav_desc; //资源格式 // DXGI_FORMAT_R8_SNORM = 63,DXGI_FORMAT_R8_SINT = 64, DXGI_FORMAT_A8_UNORM 等 uav_desc.Format = DXGI_FORMAT_UNKNOWN; //资源类型 如何访问指定资源 uav_desc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER; uav_desc.Buffer.FirstElement = 0; //元素个数 uav_desc.Buffer.NumElements = this->GetSize() / buf_desc.StructureByteStride; //查看资源选项 uav_desc.Buffer.Flags = 0; //创建无序视图 ID3D11UnorderedAccessView* d3d_ua_view; ErO(m_pDevice->CreateUnorderedAccessView(m_pBuf.get(), &uav_desc, &d3d_ua_view)); m_pUnorderAcces = MakeCOMPtr(d3d_ua_view); } } }
bool D3D11RenderDevice::InitDevice(HWND hWnd, uint32_t width, uint32_t height) { RenderDevice::InitDevice(hWnd, width, height); HRESULT result; DXGI_SWAP_CHAIN_DESC swap_chain_desc; D3D_FEATURE_LEVEL feature_level; IDXGISwapChain* swap_chain = NULL; ID3D11Device* d3d_device = NULL; ID3D11DeviceContext* d3d_context = NULL; ID3D11Texture2D* back_buffer = NULL; ID3D11RenderTargetView* rtv = NULL; D3D11_TEXTURE2D_DESC depth_buffer; ID3D11Texture2D* depth_stencil_buffer = NULL; D3D11_DEPTH_STENCIL_DESC depth_stencil_desc; ID3D11DepthStencilState* depth_stencil_state = NULL; D3D11_DEPTH_STENCIL_VIEW_DESC depth_stencil_view_desc; ID3D11DepthStencilView* depth_stencil_view = NULL; D3D11_RASTERIZER_DESC rasterizer_desc; ID3D11RasterizerState* rasterizer_state_frame = NULL; ID3D11RasterizerState* rasterizer_state_solid = NULL; D3D11_VIEWPORT viewport; ZeroMemory(&swap_chain_desc, sizeof(swap_chain_desc)); swap_chain_desc.BufferCount = 1; swap_chain_desc.BufferDesc.Width = width_; swap_chain_desc.BufferDesc.Height = height_; swap_chain_desc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; swap_chain_desc.BufferDesc.RefreshRate.Numerator = 0; swap_chain_desc.BufferDesc.RefreshRate.Denominator = 1; swap_chain_desc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; swap_chain_desc.OutputWindow = hwnd_; swap_chain_desc.SampleDesc.Count = 1; swap_chain_desc.SampleDesc.Quality = 0; swap_chain_desc.Windowed = true; swap_chain_desc.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED; swap_chain_desc.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED; swap_chain_desc.SwapEffect = DXGI_SWAP_EFFECT_DISCARD; swap_chain_desc.Flags = 0; feature_level = D3D_FEATURE_LEVEL_11_0; result = D3D11CreateDeviceAndSwapChain(NULL, D3D_DRIVER_TYPE_HARDWARE, NULL, 0, &feature_level, 1, D3D11_SDK_VERSION, &swap_chain_desc, &swap_chain, &d3d_device, NULL, &d3d_context); if (FAILED(result)) return false; swap_chain_ = MakeCOMPtr(swap_chain); d3d_device_ = MakeCOMPtr(d3d_device); d3d_context_ = MakeCOMPtr(d3d_context); // back buffer result = swap_chain_->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&back_buffer); if (FAILED(result)) return false; result = d3d_device_->CreateRenderTargetView(back_buffer, NULL, &rtv); if (FAILED(result)) return false; rtv_ = MakeCOMPtr(rtv); if (back_buffer != NULL) { back_buffer->Release(); back_buffer = NULL; } // depth stencil ZeroMemory(&depth_buffer, sizeof(depth_buffer)); depth_buffer.Width = width_; depth_buffer.Height = height_; depth_buffer.MipLevels = 1; depth_buffer.ArraySize = 1; depth_buffer.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; depth_buffer.SampleDesc.Count = 1; depth_buffer.SampleDesc.Quality = 0; depth_buffer.Usage = D3D11_USAGE_DEFAULT; depth_buffer.BindFlags = D3D11_BIND_DEPTH_STENCIL; depth_buffer.CPUAccessFlags = 0; depth_buffer.MiscFlags = 0; result = d3d_device_->CreateTexture2D(&depth_buffer, NULL, &depth_stencil_buffer); if (FAILED(result)) return false; depth_stencil_buffer_ = MakeCOMPtr(depth_stencil_buffer); ZeroMemory(&depth_stencil_desc, sizeof(depth_stencil_desc)); depth_stencil_desc.DepthEnable = true; depth_stencil_desc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; depth_stencil_desc.DepthFunc = D3D11_COMPARISON_LESS; depth_stencil_desc.StencilEnable = true; depth_stencil_desc.StencilReadMask = 0xFF; depth_stencil_desc.StencilWriteMask = 0xFF; depth_stencil_desc.FrontFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; depth_stencil_desc.FrontFace.StencilDepthFailOp = D3D11_STENCIL_OP_INCR; depth_stencil_desc.FrontFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; depth_stencil_desc.FrontFace.StencilFunc = D3D11_COMPARISON_ALWAYS; depth_stencil_desc.BackFace.StencilFailOp = D3D11_STENCIL_OP_KEEP; depth_stencil_desc.BackFace.StencilDepthFailOp = D3D11_STENCIL_OP_DECR; depth_stencil_desc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP; depth_stencil_desc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS; result = d3d_device_->CreateDepthStencilState(&depth_stencil_desc, &depth_stencil_state); if (FAILED(result)) return false; depth_stencil_state_ = MakeCOMPtr(depth_stencil_state); if (FAILED(result)) return false; ZeroMemory(&depth_stencil_view_desc, sizeof(depth_stencil_view_desc)); depth_stencil_view_desc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; depth_stencil_view_desc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; depth_stencil_view_desc.Texture2D.MipSlice = 0; result = d3d_device_->CreateDepthStencilView(depth_stencil_buffer_.get(), &depth_stencil_view_desc, &depth_stencil_view); if (FAILED(result)) return false; depth_stencil_view_ = MakeCOMPtr(depth_stencil_view); d3d_context_->OMSetRenderTargets(1, &rtv, depth_stencil_view_.get()); // rasterizer // frame ZeroMemory(&rasterizer_desc, sizeof(rasterizer_desc)); rasterizer_desc.AntialiasedLineEnable = true; rasterizer_desc.CullMode = D3D11_CULL_NONE; rasterizer_desc.DepthBias = 0; rasterizer_desc.DepthBiasClamp = 0.0f; rasterizer_desc.DepthClipEnable = true; rasterizer_desc.FillMode = D3D11_FILL_WIREFRAME; rasterizer_desc.FrontCounterClockwise = false; rasterizer_desc.MultisampleEnable = false; rasterizer_desc.ScissorEnable = false; rasterizer_desc.SlopeScaledDepthBias = 0.0f; result = d3d_device_->CreateRasterizerState(&rasterizer_desc, &rasterizer_state_frame); if (FAILED(result)) return false; rasterizer_state_frame_ = MakeCOMPtr(rasterizer_state_frame); // solid //rasterizer_desc.CullMode = D3D11_CULL_BACK; rasterizer_desc.FillMode = D3D11_FILL_SOLID; result = d3d_device_->CreateRasterizerState(&rasterizer_desc, &rasterizer_state_solid); if (FAILED(result)) return false; rasterizer_state_solid_ = MakeCOMPtr(rasterizer_state_solid); // set rasterizer state if (render_mode_ == RM_WireFrame) d3d_context_->RSSetState(rasterizer_state_frame); else d3d_context_->RSSetState(rasterizer_state_solid); // viewport viewport.Width = (float)width_; viewport.Height = (float)height_; viewport.MinDepth = 0.0f; viewport.MaxDepth = 1.0f; viewport.TopLeftX = 0.0f; viewport.TopLeftY = 0.0f; d3d_context_->RSSetViewports(1, &viewport); return true; }
//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; }
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); } }
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_))); } }
D3D11SamplerStateObject::D3D11SamplerStateObject(const SamplerStateDesc& desc, ID3D11SamplerState* state): SamplerStateObject(desc), mSamplerState(MakeCOMPtr(state)) { }
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_); } }
D3D11BlendStateObject::D3D11BlendStateObject(const BlendStateDesc& desc, ID3D11BlendState* state): BlendStateObject(desc), mBlendState(MakeCOMPtr(state)) { }
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_); } }