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_);
}
}
