Vector2f CTextureManager::GetTextureSize( ID3D11ShaderResourceView* aResourceView, bool aNormalize) const
{
ID3D11Resource* resource = nullptr;
aResourceView->GetResource(&resource);
if (!resource)
{
return Vector2f(0, 0);
}
ID3D11Texture2D* txt = reinterpret_cast<ID3D11Texture2D*>( resource );
D3D11_TEXTURE2D_DESC desc;
txt->GetDesc( &desc );
Vector2f size(static_cast<float>(desc.Width), static_cast<float>(desc.Height));
resource->Release();
Vector2<float> windowSize;
windowSize.x = static_cast<float>(CEngine::GetInstance()->GetWindowSize().y);
windowSize.y = static_cast<float>(CEngine::GetInstance()->GetWindowSize().y);
if (aNormalize)
{
return size / windowSize;
}
return size;
}
void HackerContext::FrameAnalysisClearUAV(ID3D11UnorderedAccessView *uav)
{
UINT values[4] = {0,0,0,0};
ID3D11Resource *resource = NULL;
// FIXME: Do this before each draw/dispatch call instead of when UAVs
// are assigned to fix assigned render targets not being cleared, and
// work better with frame analysis triggers
if (!(G->cur_analyse_options & FrameAnalysisOptions::CLEAR_RT))
return;
// Use the address of the resource rather than the view to determine if
// we have seen it before so we don't clear a render target that is
// simply used as several different types of views:
uav->GetResource(&resource);
if (!resource)
return;
resource->Release(); // Don't need the object, only the address
if (G->frame_analysis_seen_rts.count(resource))
return;
G->frame_analysis_seen_rts.insert(resource);
mOrigContext->ClearUnorderedAccessViewUint(uav, values);
}
void screenshot(const string& name)
{
#ifndef WINSTORE_SUPPORT
CreateDirectoryA("screenshots", 0);
time_t t = std::time(nullptr);
struct tm time_info;
localtime_s(&time_info, &t);
stringstream ss("");
if (name.length() <= 0)
ss << "screenshots/sc_" << std::put_time(&time_info, "%d-%m-%Y %H-%M-%S") << ".png";
else
ss << name;
wstringstream wss(L"");
wss << ss.str().c_str();
ID3D11Resource* res = nullptr;
wiRenderer::renderTargetView->GetResource(&res);
HRESULT h = SaveWICTextureToFile(wiRenderer::immediateContext, res, GUID_ContainerFormatPng, wss.str().c_str());
if (FAILED(h))
wiBackLog::post("Screenshot failed");
else
{
ss << " Saved successfully!";
wiBackLog::post(ss.str().c_str());
}
res->Release();
#endif
}
void HackerContext::FrameAnalysisClearRT(ID3D11RenderTargetView *target)
{
FLOAT colour[4] = {0,0,0,0};
ID3D11Resource *resource = NULL;
// FIXME: Do this before each draw call instead of when render targets
// are assigned to fix assigned render targets not being cleared, and
// work better with frame analysis triggers
if (!(G->cur_analyse_options & FrameAnalysisOptions::CLEAR_RT))
return;
// Use the address of the resource rather than the view to determine if
// we have seen it before so we don't clear a render target that is
// simply used as several different types of views:
target->GetResource(&resource);
if (!resource)
return;
resource->Release(); // Don't need the object, only the address
if (G->frame_analysis_seen_rts.count(resource))
return;
G->frame_analysis_seen_rts.insert(resource);
mOrigContext->ClearRenderTargetView(target, colour);
}
HRESULT D3D11Object::CreateEnvironmentMap( LPCSTR sFileName, ID3D11ShaderResourceView** ppSRV )
{
HRESULT hr = S_OK;
ID3D11Resource* pRes = NULL;
ID3D11Texture2D* pCubeTexture = NULL;
ID3D11ShaderResourceView* pCubeRV = NULL;
D3DX11_IMAGE_LOAD_INFO LoadInfo;
LoadInfo.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE;
D3DX11CreateTextureFromFileA( m_pDevice, sFileName, &LoadInfo, NULL, &pRes, NULL );
if( pRes )
{
printf("Create environment mapping %s\n", sFileName);
D3D11_TEXTURE2D_DESC desc;
ZeroMemory( &desc, sizeof( D3D11_TEXTURE2D_DESC ) );
pRes->QueryInterface( __uuidof( ID3D11Texture2D ), ( LPVOID* )&pCubeTexture );
pCubeTexture->GetDesc( &desc );
SAFE_RELEASE( pRes );
D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
ZeroMemory( &SRVDesc, sizeof( SRVDesc ) );
SRVDesc.Format = desc.Format;
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
SRVDesc.TextureCube.MipLevels = desc.MipLevels;
SRVDesc.TextureCube.MostDetailedMip = 0;
hr = m_pDevice->CreateShaderResourceView( pCubeTexture, &SRVDesc, ppSRV );
}
return hr;
}
void MyD3DAssets::loadPSTexture(int textureIndex)
{
ID3D11ShaderResourceView *view = nullptr;
context->base->PSGetShaderResources(textureIndex, 1, &view);
if (view == nullptr)
{
PSTexture.free();
}
else
{
ID3D11Resource *textureResource = nullptr;
view->GetResource(&textureResource);
ID3D11Texture2D* texture = nullptr;
HRESULT hr = textureResource->QueryInterface(__uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&texture));
if (texture == nullptr || FAILED(hr))
{
PSTexture.free();
g_logger->logErrorFile << "textureResource->QueryInterface failed" << endl;
}
else
{
readTexture(texture, PSTexture);
texture->Release();
}
textureResource->Release();
view->Release();
}
}
void initAll(ID3D11Device& device,
ID3D11DeviceContext& context,
ShaderResources& shaderResources)
{
assert(shaderResources.mDiffuseMapSRV == nullptr);
assert(shaderResources.mCSResultsSRV == nullptr);
assert(shaderResources.mCSResultsUAV == nullptr);
ID3D11Resource* texture = nullptr;
//
// Diffuse Map
//
HRESULT result = CreateDDSTextureFromFile(&device,
L"Resources/Textures/brick.dds",
&texture,
&shaderResources.mDiffuseMapSRV);
DxErrorChecker(result);
texture->Release();
//
// Create compute shader texture
//
D3D11_TEXTURE2D_DESC groupResultsTexDesc;
groupResultsTexDesc.Width = 512;
groupResultsTexDesc.Height = 512;
groupResultsTexDesc.MipLevels = 1;
groupResultsTexDesc.ArraySize = 1;
groupResultsTexDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
groupResultsTexDesc.SampleDesc.Count = 1;
groupResultsTexDesc.SampleDesc.Quality = 0;
groupResultsTexDesc.Usage = D3D11_USAGE_DEFAULT;
groupResultsTexDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_UNORDERED_ACCESS;
groupResultsTexDesc.CPUAccessFlags = 0;
groupResultsTexDesc.MiscFlags = 0;
ID3D11Texture2D* groupResultsTex = nullptr;
assert(Globals::gDirect3DData.mDevice);
result = device.CreateTexture2D(&groupResultsTexDesc, 0, &groupResultsTex);
DxErrorChecker(result);
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
srvDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MostDetailedMip = 0;
srvDesc.Texture2D.MipLevels = 1;
result = device.CreateTexture2D(&groupResultsTexDesc, 0, &groupResultsTex);
result = device.CreateShaderResourceView(groupResultsTex, &srvDesc, &shaderResources.mCSResultsSRV);
D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc;
uavDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
uavDesc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D;
uavDesc.Texture2D.MipSlice = 0;
result = device.CreateUnorderedAccessView(groupResultsTex, &uavDesc, &shaderResources.mCSResultsUAV);
// Views save a reference to the texture so we can release our reference.
groupResultsTex->Release();
}
void LoadSkybox(ID3D11Device* d3dDevice, LPCWSTR fileName)
{
ID3D11Resource* resource = 0;
HRESULT hr;
hr = D3DX11CreateTextureFromFile(d3dDevice, fileName, 0, 0, &resource, 0);
assert(SUCCEEDED(hr));
d3dDevice->CreateShaderResourceView(resource, 0, &gSkyboxSRV);
resource->Release();
}
//-------------------------------------------------------------------------------
void D3D11RenderSystem::CopyFrameBufferToTexture( D3D11Texture* pTexture )
{
ID3D11Resource* pSrcTex = nullptr;
m_pRenderTargetView->GetResource(&pSrcTex);
m_pDeviceContext->CopyResource(pTexture->GetInternalTex(), pSrcTex);
pSrcTex->Release();
pTexture->CreateSRV();
}
int32 CGameObject::Initialize()
{
ApplyShader();
D3D11_BLEND_DESC blendDesc = {};
blendDesc.RenderTarget[0].BlendEnable = true;
blendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
blendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
blendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
blendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_SRC_ALPHA;
blendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
blendDesc.RenderTarget[0].RenderTargetWriteMask = 0x0F;
float blendFactor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
theDevice->CreateBlendState( &blendDesc, &m_alphaBlendState );
theContext->OMSetBlendState( m_alphaBlendState, blendFactor, 0xFFFFFFFF );
D3D11_SAMPLER_DESC samplerDesc = {};
samplerDesc.AddressU = samplerDesc.AddressV = samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
// samplerDesc.Filter = D3D11_FILTER_ANISOTROPIC;
// samplerDesc.MaxAnisotropy = 4;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
HR( theDevice->CreateSamplerState( &samplerDesc, &m_pTextureSampler ) );
ID3D11Resource* pcolorTex = 00;
m_material.GetDiffuse()->GetResource( &pcolorTex );
D3D11_TEXTURE2D_DESC colorTexDesc = {};
(reinterpret_cast<ID3D11Texture2D*>(pcolorTex))->GetDesc( &colorTexDesc );
pcolorTex->Release();
BuildBuffers();
D3D11_SAMPLER_DESC colorMapDesc = {};
colorMapDesc.AddressU = colorMapDesc.AddressV = colorMapDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
colorMapDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
colorMapDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
// colorMapDesc.Filter = D3D11_FILTER_ANISOTROPIC;
// colorMapDesc.MaxAnisotropy = 4;
colorMapDesc.MaxLOD = D3D11_FLOAT32_MAX;
HR( theDevice->CreateSamplerState( &colorMapDesc, &m_pTextureSampler ) );
m_pFXWorld = m_effect->GetVariableByName( "gWorld" )->AsMatrix();
m_pFXTexture = m_effect->GetVariableByName( "gTexture" )->AsShaderResource();
m_pFXTextureSampler = m_effect->GetVariableByName( "gTextureSampler" )->AsSampler();
return 0;
}
bool xD11BaseTexture::saveToFile(const wchar_t* fileName)
{
D3DX11_IMAGE_FILE_FORMAT fFormat = xD11ConstLexer::GetDX11ImageFileFormat(fileName);
if((int)fFormat == -1)
return false;
ID3D11Resource* pResource = this->GetD11Resource();
if(pResource == NULL)
return false;
HRESULT hr = D3DX11SaveTextureToFileW(m_pD11RenderApi->d11DeviceContext() , pResource , fFormat , fileName);
pResource->Release();
return SUCCEEDED(hr);
}
HRESULT LoadSkyboxFromFile(LPCSTR file, ID3D11Device* pd3dDevice)
{
HRESULT hr;
D3DX11_IMAGE_INFO SrcInfo;
hr = D3DX11GetImageInfoFromFile(file, NULL, &SrcInfo, NULL);
D3DX11_IMAGE_LOAD_INFO texLoadInfo;
texLoadInfo.Width = SrcInfo.Width;
texLoadInfo.Height = SrcInfo.Height;
texLoadInfo.Depth = SrcInfo.Depth;
texLoadInfo.FirstMipLevel = 0;
texLoadInfo.MipLevels = SrcInfo.MipLevels;
texLoadInfo.Usage = D3D11_USAGE_DEFAULT;
texLoadInfo.BindFlags = D3D11_BIND_SHADER_RESOURCE;
texLoadInfo.CpuAccessFlags = 0;
texLoadInfo.MiscFlags = SrcInfo.MiscFlags;
texLoadInfo.Format = SrcInfo.Format;
texLoadInfo.Filter = D3DX11_FILTER_TRIANGLE;
texLoadInfo.MipFilter = D3DX11_FILTER_TRIANGLE;
texLoadInfo.pSrcInfo = &SrcInfo;
ID3D11Resource *pRes = NULL;
D3DX11CreateTextureFromFile(pd3dDevice, file, &texLoadInfo, NULL, &pRes, NULL);
if (pRes)
{
ID3D11Texture2D* texture;
pRes->QueryInterface(__uuidof(ID3D11Texture2D), (LPVOID*)&texture);
D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
ZeroMemory(&SRVDesc, sizeof(SRVDesc));
SRVDesc.Format = texLoadInfo.Format;
SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
SRVDesc.Texture2D.MostDetailedMip = 0;
SRVDesc.Texture2D.MipLevels = texLoadInfo.MipLevels;
ID3D11ShaderResourceView* textureRview;
pd3dDevice->CreateShaderResourceView(texture, &SRVDesc, &textureRview);
g_Skybox.OnD3D11CreateDevice(pd3dDevice, 1, texture, textureRview);
// Sky box class holds references.
//SAFE_RELEASE(texture);
//SAFE_RELEASE(textureRview);
}
SAFE_RELEASE(pRes);
return S_OK;
}
void Tiles::Init(ID3D11Device* dev, std::wstring fileName, XMFLOAT2 tileSize)
{
ID3D11Resource* resource = 0;
ID3D11Texture2D* texture2D = 0;
dev_ = dev;
D3DX11CreateShaderResourceViewFromFile(dev, fileName.c_str(), NULL, NULL, &texture_, NULL);
texture_->GetResource(&resource);
resource->QueryInterface(&texture2D);
D3D11_TEXTURE2D_DESC desc;
texture2D->GetDesc(&desc);
TextureHeight = desc.Height / tileSize.y;
TextureWidth = desc.Width / tileSize.x;
}
void FD3D12CommandContext::CheckIfSRVIsResolved(FD3D12ShaderResourceView* SRV)
{
// MSFT: Seb: TODO: Make this work on 12
#if CHECK_SRV_TRANSITIONS
if (GRHIThread || !SRV)
{
return;
}
static const auto CheckSRVCVar = IConsoleManager::Get().FindTConsoleVariableDataInt(TEXT("r.CheckSRVTransitions"));
if (!CheckSRVCVar->GetValueOnRenderThread())
{
return;
}
ID3D11Resource* SRVResource = nullptr;
SRV->GetResource(&SRVResource);
int32 MipLevel;
int32 NumMips;
int32 ArraySlice;
int32 NumSlices;
GetMipAndSliceInfoFromSRV(SRV, MipLevel, NumMips, ArraySlice, NumSlices);
//d3d uses -1 to mean 'all mips'
int32 LastMip = MipLevel + NumMips - 1;
int32 LastSlice = ArraySlice + NumSlices - 1;
TArray<FUnresolvedRTInfo> RTInfoArray;
UnresolvedTargets.MultiFind(SRVResource, RTInfoArray);
for (int32 InfoIndex = 0; InfoIndex < RTInfoArray.Num(); ++InfoIndex)
{
const FUnresolvedRTInfo& RTInfo = RTInfoArray[InfoIndex];
int32 RTLastMip = RTInfo.MipLevel + RTInfo.NumMips - 1;
ensureMsgf((MipLevel == -1 || NumMips == -1) || (LastMip < RTInfo.MipLevel || MipLevel > RTLastMip), TEXT("SRV is set to read mips in range %i to %i. Target %s is unresolved for mip %i"), MipLevel, LastMip, *RTInfo.ResourceName.ToString(), RTInfo.MipLevel);
ensureMsgf(NumMips != -1, TEXT("SRV is set to read all mips. Target %s is unresolved for mip %i"), *RTInfo.ResourceName.ToString(), RTInfo.MipLevel);
int32 RTLastSlice = RTInfo.ArraySlice + RTInfo.ArraySize - 1;
ensureMsgf((ArraySlice == -1 || LastSlice == -1) || (LastSlice < RTInfo.ArraySlice || ArraySlice > RTLastSlice), TEXT("SRV is set to read slices in range %i to %i. Target %s is unresolved for mip %i"), ArraySlice, LastSlice, *RTInfo.ResourceName.ToString(), RTInfo.ArraySlice);
ensureMsgf(ArraySlice == -1 || NumSlices != -1, TEXT("SRV is set to read all slices. Target %s is unresolved for slice %i"));
}
SRVResource->Release();
#endif
}
void Entity::LoadTexture(ID3D11Device* device , std::wstring texFilename)
{
HR(D3DX11CreateShaderResourceViewFromFile(device, texFilename.c_str(), 0, 0, &mTexSRV, 0));
//GRAB TEXTURES WIDTH AND HEIGHT .. USED LATER FOR ANIMATION PURPOSES
ID3D11Resource* resource = 0;
ID3D11Texture2D* texture2D = 0;
mTexSRV->GetResource(&resource);
resource->QueryInterface(&texture2D);
D3D11_TEXTURE2D_DESC desc;
texture2D->GetDesc(&desc);
mTexWidth = desc.Width;
mTexHeight = desc.Height;
ReleaseCOM(resource);
ReleaseCOM(texture2D);
}
//-----------------------------------------------------------------------------
CPUTTexture *CPUTTextureDX11::CreateTexture( const cString &name, const cString &absolutePathAndFilename, bool loadAsSRGB )
{
// TODO: Delegate to derived class. We don't currently have CPUTTextureDX11
ID3D11ShaderResourceView *pShaderResourceView = NULL;
ID3D11Resource *pTexture = NULL;
ID3D11Device *pD3dDevice= CPUT_DX11::GetDevice();
CPUTResult result = CreateNativeTexture( pD3dDevice, absolutePathAndFilename, &pShaderResourceView, &pTexture, loadAsSRGB );
ASSERT( CPUTSUCCESS(result), _L("Error loading texture: '")+absolutePathAndFilename );
CPUTTextureDX11 *pNewTexture = new CPUTTextureDX11();
pNewTexture->mName = name;
pNewTexture->SetTextureAndShaderResourceView( pTexture, pShaderResourceView );
pTexture->Release();
pShaderResourceView->Release();
CPUTAssetLibrary::GetAssetLibrary()->AddTexture( absolutePathAndFilename, pNewTexture);
return pNewTexture;
}
//----------------------------------------------------------------------------//
void Direct3D11Texture::initialiseShaderResourceView()
{
if (!d_texture)
return;
D3D11_TEXTURE2D_DESC tex_desc;
d_texture->GetDesc(&tex_desc);
ID3D11Resource* resource = 0;
d_texture->QueryInterface(__uuidof(ID3D11Resource),
reinterpret_cast<LPVOID*>(&resource));
D3D11_SHADER_RESOURCE_VIEW_DESC srvd;
srvd.Format = tex_desc.Format;
srvd.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvd.Texture2D.MostDetailedMip = 0;
srvd.Texture2D.MipLevels = tex_desc.MipLevels;
d_device.d_device->CreateShaderResourceView(resource, &srvd, &d_resourceView);
resource->Release();
}
void HackerContext::DumpUAVs(bool compute)
{
UINT i;
NvAPI_Status nvret;
ID3D11UnorderedAccessView *uavs[D3D11_PS_CS_UAV_REGISTER_COUNT];
ID3D11Resource *resource;
wchar_t filename[MAX_PATH];
HRESULT hr;
if (analyse_options & FrameAnalysisOptions::STEREO) {
// Enable reverse stereo blit for all resources we are about to dump:
nvret = NvAPI_Stereo_ReverseStereoBlitControl(mHackerDevice->mStereoHandle, true);
if (nvret != NVAPI_OK) {
LogInfo("DumpStereoResource failed to enable reverse stereo blit\n");
// Continue anyway, we should still be able to dump in 2D...
}
}
mOrigContext->CSGetUnorderedAccessViews(0, D3D11_PS_CS_UAV_REGISTER_COUNT, uavs);
for (i = 0; i < D3D11_PS_CS_UAV_REGISTER_COUNT; ++i) {
if (!uavs[i])
continue;
uavs[i]->GetResource(&resource);
if (!resource) {
uavs[i]->Release();
continue;
}
hr = FrameAnalysisFilename(filename, MAX_PATH, compute, true, false, i);
if (SUCCEEDED(hr))
DumpResource(resource, filename);
resource->Release();
uavs[i]->Release();
}
if (analyse_options & FrameAnalysisOptions::STEREO)
NvAPI_Stereo_ReverseStereoBlitControl(mHackerDevice->mStereoHandle, false);
}
void ResourcesManager::initAll(ID3D11Device* device, ID3D11DeviceContext* context)
{
assert(device);
assert(context);
ID3D11Resource* texture = nullptr;
// Create grass texture shader resource view
HRESULT result = CreateDDSTextureFromFile(device, L"Resources/Textures/sand.dds", &texture, &mSandSRV);
DxErrorChecker(result);
// Create sky cube map shader resource view
result = CreateDDSTextureFromFile(device, L"Resources/Textures/desertcube1024.dds", &texture, &mSkyCubeMapSRV);
DxErrorChecker(result);
// Create sphere diffuse map texture
result = CreateDDSTextureFromFile(device, L"Resources/Textures/stone.dds", &texture, &mSphereDiffuseMapSRV);
DxErrorChecker(result);
texture->Release();
}
void Texture2D::Load(D3DRenderer* renderer, const wchar_t* filePath)
{
ID3D11Resource* textureResource;
ID3D11ShaderResourceView* textureSRV;
DirectX::CreateDDSTextureFromFile(renderer->device(), NULL, filePath, &textureResource, &textureSRV);
if (textureResource == NULL || textureSRV == NULL)
{
char errStr[256];
std::wstring errorPathw(filePath);
std::string errorPath(errorPathw.begin(), errorPathw.end());
sprintf(errStr, "Failed to load texture %s.", errorPath.c_str());
NE_CRITICAL(errStr, "Texture2D");
return;
}
D3D11_RESOURCE_DIMENSION dimension;
textureResource->GetType(&dimension);
if (dimension != D3D11_RESOURCE_DIMENSION_TEXTURE2D)
{
ReleaseCOM(textureSRV);
ReleaseCOM(textureResource);
NE_CRITICAL("Invalid texture dimension.", "Texture2D");
}
mpTexture = static_cast<ID3D11Texture2D*>(textureResource);
mpResourceView = textureSRV;
D3D11_TEXTURE2D_DESC texDesc;
mpTexture->GetDesc(&texDesc);//This should just be switched out for a get file data function when I get DirectXTex set up
mWidth = texDesc.Width;
mHeight = texDesc.Height;
}
//-- SetRenderTarget ----------------------------------------------------------
//
//-----------------------------------------------------------------------------
void Renderer::SetRenderTarget(TextureDX* texture)
{
if (texture == NULL || texture->GetRenderTarget() == NULL)
return;
ID3D11Texture2D* pTexture = texture->GetTexture();
D3D11_TEXTURE2D_DESC txDesc, dtxDesc;
pTexture->GetDesc(&txDesc);
ID3D11Resource* pResource = NULL; ID3D11Texture2D* pDepthTexture = NULL;
g_depthView->GetResource(&pResource);
pResource->QueryInterface(__uuidof(ID3D11Texture2D), reinterpret_cast<void**>(&pDepthTexture));
pDepthTexture->GetDesc(&dtxDesc);
pDepthTexture->Release();
pResource->Release();
// depth view dimension must be equals render target dimension
if (txDesc.Width != dtxDesc.Width || txDesc.Height != dtxDesc.Height)
{
SAFE_RELEASE( g_depthView );
CD3D11_TEXTURE2D_DESC depthBufferDesc(DXGI_FORMAT_D24_UNORM_S8_UINT, txDesc.Width, txDesc.Height, 1, 1, D3D11_BIND_DEPTH_STENCIL);
m_pD3D11Device->CreateTexture2D(&depthBufferDesc, NULL, &pDepthTexture);
CD3D11_DEPTH_STENCIL_VIEW_DESC viewDesc(D3D11_DSV_DIMENSION_TEXTURE2D);
m_pD3D11Device->CreateDepthStencilView(pDepthTexture, &viewDesc, &g_depthView);
pDepthTexture->Release();
}
else
m_pD3D11Contex->ClearDepthStencilView(g_depthView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0, 0);
ID3D11RenderTargetView* rtView = texture->GetRenderTarget();
// change view port to render target dimension like dx9 does
CD3D11_VIEWPORT vp(pTexture, rtView);
m_pD3D11Contex->RSSetViewports(1, &vp);
m_pD3D11Contex->OMSetRenderTargets(1, &rtView, g_depthView);
} // SetRenderTarget
void ResourcesManager::initAll(ID3D11Device* device, ID3D11DeviceContext* context)
{
assert(device);
assert(context);
ID3D11Resource* texture = nullptr;
// Create diffuse and normal maps
HRESULT result = CreateDDSTextureFromFile(device, L"Resources/Textures/wood1.dds", &texture, &mFloorDiffuseMapSRV);
DxErrorChecker(result);
result = CreateDDSTextureFromFile(device, L"Resources/Textures/wood1Normal.dds", &texture, &mFloorNormalMapSRV);
DxErrorChecker(result);
result = CreateDDSTextureFromFile(device, L"Resources/Textures/brick.dds", &texture, &mCylinderDiffuseMapSRV);
DxErrorChecker(result);
result = CreateDDSTextureFromFile(device, L"Resources/Textures/brickNormal.dds", &texture, &mCylinderNormalMapSRV);
DxErrorChecker(result);
texture->Release();
}
void myD3D11DeviceContext::readRenderTarget(Bitmap &result)
{
ID3D11RenderTargetView *view;
assets->context->base->OMGetRenderTargets(1, &view, nullptr);
ID3D11Resource *resource;
view->GetResource(&resource);
ID3D11Texture2D *inputTexture;
HRESULT hr = resource->QueryInterface(__uuidof(ID3D11Texture2D), (void **)&inputTexture);
if (FAILED(hr))
{
g_logger->logErrorFile << "QueryInterface failed to cast to a texture" << endl;
}
else
{
readTexture(inputTexture, result);
}
view->Release();
}
ID3D11VideoProcessorInputView* CProcessorHD::GetInputView(ID3D11View* view)
{
ID3D11VideoProcessorInputView* inputView = nullptr;
if (m_context) // we have own context so the view will be processor input view
{
inputView = reinterpret_cast<ID3D11VideoProcessorInputView*>(view);
inputView->AddRef(); // it will be released in Render method
return inputView;
}
// the view came from decoder
ID3D11VideoDecoderOutputView* decoderView = reinterpret_cast<ID3D11VideoDecoderOutputView*>(view);
if (!decoderView)
{
CLog::Log(LOGERROR, __FUNCTION__" - cannot get view.");
return nullptr;
}
ID3D11Resource* resource = nullptr;
D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC vdovd;
decoderView->GetDesc(&vdovd);
decoderView->GetResource(&resource);
D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC vpivd = { 0 };
vpivd.FourCC = 0; // if zero, the driver uses the DXGI format; must be 0 on level 9.x
vpivd.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
vpivd.Texture2D.ArraySlice = vdovd.Texture2D.ArraySlice;
vpivd.Texture2D.MipSlice = 0;
if (FAILED(m_pVideoDevice->CreateVideoProcessorInputView(resource, m_pEnumerator, &vpivd, &inputView)))
{
CLog::Log(LOGERROR, __FUNCTION__" - cannot create processor view.");
}
resource->Release();
return inputView;
}
// ----------------------------------------------------------------------------------------------
Texture* TextureLib::LoadEmbeddedTexture(ID3D11Device* device, const wchar_t* name)
{
assert(s_Inst != NULL);
Imple* pImple = s_Inst->m_pImple;
typedef std::pair<std::wstring, Texture*> NameTexPair;
const wchar_t* resType = L"Texture";
HRESULT hr = E_FAIL;
Texture* tex = NULL;
ID3D11Resource* dxresource = NULL;
ID3D11ShaderResourceView* dxTexView = NULL;
uint32_t resSize = 0;
uint8_t* data = (uint8_t*)ResUtil::LoadResource(resType, name, &resSize);
hr = CreateWICTextureFromMemory(device,
NULL,
data,
resSize,
&dxresource,
&dxTexView);
free(data);
if (!Logger::IsFailureLog(hr, L"Error loading %s\n", name))
{
D3D11_RESOURCE_DIMENSION resDim = D3D11_RESOURCE_DIMENSION_UNKNOWN;
dxresource->GetType(&resDim);
assert(resDim == D3D11_RESOURCE_DIMENSION_TEXTURE2D);
ID3D11Texture2D* dxTex = NULL;
hr = dxresource->QueryInterface(__uuidof(ID3D11Texture2D), (void**)&dxTex);
dxresource->Release();
assert(dxTex);
tex = new Texture(dxTex, dxTexView);
auto insertResult = pImple->m_textures.insert(NameTexPair(name, tex));
assert(insertResult.second);
}
return tex;
}
ModelDefinition *ModelFactory::create2D_Model(ID3D11ShaderResourceView *p_Texture)
{
ModelDefinition *model = new ModelDefinition();
ID3D11Resource *resource;
ID3D11Texture2D *texture;
D3D11_TEXTURE2D_DESC textureDesc;
p_Texture->GetResource(&resource);
resource->QueryInterface(&texture);
texture->GetDesc(&textureDesc);
Vector2 halfSize(textureDesc.Width * 0.5f, textureDesc.Height * 0.5f);
SAFE_RELEASE(texture);
SAFE_RELEASE(resource);
create2D_VertexBuffer(model, halfSize);
model->diffuseTexture.push_back(make_pair(std::string("Text"), p_Texture));
model->materialSets.resize(1);
model->materialSets[0].first = "default";
model->materialSets[0].second.push_back(ModelDefinition::Material(0, 6, 0));
model->is2D = true;
model->isAnimated = false;
return model;
}
ID3D11VideoProcessorInputView* CProcessorHD::GetInputView(CRenderBuffer* view) const
{
ID3D11VideoProcessorInputView* inputView = nullptr;
D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC vpivd = { 0, D3D11_VPIV_DIMENSION_TEXTURE2D,{ 0, 0 } };
if (view->format == BUFFER_FMT_D3D11_BYPASS)
{
// the view cames from decoder
ID3D11VideoDecoderOutputView* decoderView = reinterpret_cast<ID3D11VideoDecoderOutputView*>(view->GetHWView());
if (!decoderView)
{
CLog::Log(LOGERROR, "%s: cannot get decoder view.", __FUNCTION__);
return nullptr;
}
ID3D11Resource* resource = nullptr;
D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC vdovd;
decoderView->GetDesc(&vdovd);
decoderView->GetResource(&resource);
vpivd.Texture2D.ArraySlice = vdovd.Texture2D.ArraySlice;
if (FAILED(m_pVideoDevice->CreateVideoProcessorInputView(resource, m_pEnumerator, &vpivd, &inputView)))
CLog::Log(LOGERROR, "%s: cannot create processor input view.", __FUNCTION__);
resource->Release();
}
else if (view->format == BUFFER_FMT_D3D11_NV12
|| view->format == BUFFER_FMT_D3D11_P010
|| view->format == BUFFER_FMT_D3D11_P016)
{
if (FAILED(m_pVideoDevice->CreateVideoProcessorInputView(view->GetResource(), m_pEnumerator, &vpivd, &inputView)))
CLog::Log(LOGERROR, "%s: cannot create processor input view.", __FUNCTION__);
}
return inputView;
}
bool PerlinFire::LoadTexture2D(ID3D11Device * pd3dDevice, LPCWSTR fileName, ID3D11Texture2D ** tex, ID3D11ShaderResourceView ** texRV)
{
HRESULT hr;
ID3D11Resource * pRes = NULL;
D3DX11CreateTextureFromFile( pd3dDevice, fileName, NULL, NULL, &pRes, &hr );
pRes->QueryInterface( __uuidof(ID3D11Texture2D), (LPVOID*) tex);
D3D11_TEXTURE2D_DESC desc;
(*tex)->GetDesc(& desc);
D3D11_SHADER_RESOURCE_VIEW_DESC descSRV;
ZeroMemory( &descSRV, sizeof(descSRV) );
descSRV.Format = desc.Format;
descSRV.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
descSRV.Texture2D.MipLevels = desc.MipLevels;
pd3dDevice->CreateShaderResourceView( *tex, &descSRV, texRV );
pRes->Release();
return true;
}
ID3D11VideoProcessorInputView* CProcessorHD::GetInputView(ID3D11View* view)
{
ID3D11VideoProcessorInputView* inputView = nullptr;
if (m_eViewType == PROCESSOR_VIEW_TYPE_PROCESSOR)
{
inputView = reinterpret_cast<ID3D11VideoProcessorInputView*>(view);
inputView->AddRef(); // it will be released later
}
else if (m_eViewType == PROCESSOR_VIEW_TYPE_DECODER)
{
// the view cames from decoder
ID3D11VideoDecoderOutputView* decoderView = reinterpret_cast<ID3D11VideoDecoderOutputView*>(view);
if (!decoderView)
{
CLog::Log(LOGERROR, "%s - cannot get view.", __FUNCTION__);
return nullptr;
}
ID3D11Resource* resource = nullptr;
D3D11_VIDEO_DECODER_OUTPUT_VIEW_DESC vdovd;
decoderView->GetDesc(&vdovd);
decoderView->GetResource(&resource);
D3D11_VIDEO_PROCESSOR_INPUT_VIEW_DESC vpivd = { { 0 } };
vpivd.FourCC = 0;
vpivd.ViewDimension = D3D11_VPIV_DIMENSION_TEXTURE2D;
vpivd.Texture2D.ArraySlice = vdovd.Texture2D.ArraySlice;
vpivd.Texture2D.MipSlice = 0;
if (FAILED(m_pVideoDevice->CreateVideoProcessorInputView(resource, m_pEnumerator, &vpivd, &inputView)))
CLog::Log(LOGERROR, "%s - cannot create processor view.", __FUNCTION__);
resource->Release();
}
return inputView;
}
bool Texture::LoadTexture(const std::wstring& fileName, ID3D11Device* device)
{
DirectX::CreateWICTextureFromFile(device, fileName.c_str(), nullptr, &mTexture);
if (mTexture != nullptr)
{
ID3D11Resource* res = nullptr;
ID3D11Texture2D* texture2d = nullptr;
D3D11_TEXTURE2D_DESC desc;
mTexture->GetResource(&res);
res->QueryInterface(&texture2d);
texture2d->GetDesc(&desc);
mTextureDimensions.x = (float)desc.Width;
mTextureDimensions.y = (float)desc.Height;
ZEPHYR_RELEASEOBJECT(res);
ZEPHYR_RELEASEOBJECT(texture2d);
return true;
}
return false;
}
