Texture2D::Texture2D( Device& _Device, ID3D11Texture2D& _Texture, const IPixelFormatDescriptor& _Format )
: Component( _Device )
, m_Format( _Format )
, m_bIsDepthStencil( false )
, m_bIsCubeMap( false )
, m_pCachedDepthStencilView( NULL )
{
D3D11_TEXTURE2D_DESC Desc;
_Texture.GetDesc( &Desc );
m_Width = Desc.Width;
m_Height = Desc.Height;
m_ArraySize = Desc.ArraySize;
m_MipLevelsCount = Desc.MipLevels;
for ( int ShaderStageIndex=0; ShaderStageIndex < 6; ShaderStageIndex++ )
m_LastAssignedSlots[ShaderStageIndex] = -1;
m_LastAssignedSlotsUAV = -1;
m_pTexture = &_Texture;
}
void ml::D3D11GraphicsDevice::captureBackBufferInternal(Bitmap &result)
{
ID3D11Texture2D* frameBuffer;
D3D_VALIDATE(m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&frameBuffer));
D3D11_TEXTURE2D_DESC desc;
frameBuffer->GetDesc(&desc);
if(m_captureBuffer == nullptr)
{
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
desc.Usage = D3D11_USAGE_STAGING;
D3D_VALIDATE(m_device->CreateTexture2D(&desc, nullptr, &m_captureBuffer));
}
m_context->CopyResource( m_captureBuffer, frameBuffer );
result.allocate(desc.Height, desc.Width);
D3D11_MAPPED_SUBRESOURCE resource;
UINT subresource = D3D11CalcSubresource( 0, 0, 0 );
HRESULT hr = m_context->Map( m_captureBuffer, subresource, D3D11_MAP_READ_WRITE, 0, &resource );
const BYTE *data = (BYTE *)resource.pData;
//resource.pData; // TEXTURE DATA IS HERE
for( UINT row = 0; row < desc.Height; row++ )
{
memcpy( &result(row, 0), data + resource.RowPitch * row, desc.Width * sizeof(RGBColor) );
}
m_context->Unmap(m_captureBuffer, subresource);
}
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;
}
HRESULT getWindowSize(ComPtr<IUnknown>& iWindow, int& width, int& height)
{
ComPtr<IWinPhone8XamlD3DWindow> iPhoneWindow;
HRESULT result = getIPhoneXamlWindow(iWindow, &iPhoneWindow);
if (SUCCEEDED(result))
{
ID3D11Texture2D* backBuffer;
result = iPhoneWindow->getBackBuffer(&backBuffer);
if(SUCCEEDED(result))
{
D3D11_TEXTURE2D_DESC backBufferDesc;
backBuffer->GetDesc(&backBufferDesc);
width = backBufferDesc.Width;
height = backBufferDesc.Height;
}
backBuffer->Release();
}
else
{
winrt::getCurrentWindowDimensions(width, height);
}
return result;
}
// テクスチャロード
int LoadTexture( TCHAR *szFileName, TEX_PICTURE *pTexPic, int nWidth, int nHeight,
int nTexWidth, int nTexHeight )
{
HRESULT hr;
D3DX11_IMAGE_LOAD_INFO liLoadInfo;
ID3D11Texture2D *pTexture;
ZeroMemory( &liLoadInfo, sizeof( D3DX11_IMAGE_LOAD_INFO ) );
liLoadInfo.Width = nTexWidth;
liLoadInfo.Height = nTexHeight;
liLoadInfo.BindFlags = D3D11_BIND_SHADER_RESOURCE;
liLoadInfo.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
hr = D3DX11CreateShaderResourceViewFromFile( g_pd3dDevice, szFileName, &liLoadInfo,
NULL, &( pTexPic->pSRViewTexture ), NULL );
if ( FAILED( hr ) ) {
return hr;
}
pTexPic->pSRViewTexture->GetResource( ( ID3D11Resource ** )&( pTexture ) );
pTexture->GetDesc( &( pTexPic->tdDesc ) );
pTexture->Release();
pTexPic->nWidth = nWidth;
pTexPic->nHeight = nHeight;
return S_OK;
}
unsigned Texture2D::GetSizeInBytes()
{
ID3D11Texture2D *texture = GetTexture();
D3D11_TEXTURE2D_DESC desc;
texture->GetDesc(&desc);
return desc.Width * desc.Height * GetFormatSize(desc.Format) * desc.SampleDesc.Count;
}
void MyD3DAssets::readTexture(ID3D11Texture2D *inputTexture, Bitmap &result)
{
ID3D11Texture2D *stagingTexture = getStagingTexture(inputTexture);
D3D11_TEXTURE2D_DESC desc;
stagingTexture->GetDesc(&desc);
if (result.getWidth() != desc.Width || result.getHeight() != desc.Height)
result.allocate(desc.Width, desc.Height);
for (auto &p : result)
p.value = ml::vec4uc(50, 100, 150, 255);
context->base->CopyResource(stagingTexture, inputTexture);
D3D11_MAPPED_SUBRESOURCE resource;
UINT subresource = D3D11CalcSubresource(0, 0, 0);
HRESULT hr = context->base->Map(stagingTexture, subresource, D3D11_MAP_READ, 0, &resource);
const BYTE *data = (BYTE *)resource.pData;
for (UINT y = 0; y < desc.Height; y++)
{
memcpy(&result(0U, y), data + resource.RowPitch * y, desc.Width * sizeof(ml::vec4uc));
}
context->base->Unmap(stagingTexture, subresource);
}
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;
}
// ********************************************************************* //
// Fill this rendertarget with an already existing resources.
RenderTarget::RenderTarget( ID3D11RenderTargetView* _targetView,
ID3D11DepthStencilView* _depthStencil,
uint _flags ) :
m_textureView(nullptr),
m_DSTextureView(nullptr),
m_targetView(_targetView),
m_depthBufferRef(_depthStencil),
m_lastTextureSlot(0xffffffff),
m_DSLastTextureSlot(0xffffffff)
{
Assert((_targetView!=nullptr) ^ ((_flags & CREATION_FLAGS::NO_TARGET) == CREATION_FLAGS::NO_TARGET));
Assert((_depthStencil!=nullptr) ^ ((_flags & CREATION_FLAGS::NO_DEPTH) == CREATION_FLAGS::NO_DEPTH));
// Not implemented, yet...
Assert( (_flags & CREATION_FLAGS::DEPTH_TEXTURE_VIEW) != CREATION_FLAGS::DEPTH_TEXTURE_VIEW );
Assert( (_flags & CREATION_FLAGS::TARGET_TEXTURE_VIEW) != CREATION_FLAGS::TARGET_TEXTURE_VIEW );
ID3D11Texture2D* pTex;
_targetView->GetResource( (ID3D11Resource**)&pTex );
D3D11_TEXTURE2D_DESC Desc;
pTex->GetDesc( &Desc );
pTex->Release();
CreateViewPort( Desc.Width, Desc.Height );
}
static bool grabFrameD3D11(IDXGISwapChain *swap)
{
ID3D11Device *device = 0;
ID3D11DeviceContext *context = 0;
ID3D11Texture2D *tex = 0, *captureTex = 0;
if (FAILED(swap->GetBuffer(0, IID_ID3D11Texture2D, (void**)&tex)))
return false;
D3D11_TEXTURE2D_DESC desc;
tex->GetDevice(&device);
tex->GetDesc(&desc);
// re-creating the capture staging texture each frame is definitely not the most efficient
// way to handle things, but it frees me of all kind of resource management trouble, so
// here goes...
desc.MipLevels = 1;
desc.ArraySize = 1;
desc.SampleDesc.Count = 1;
desc.SampleDesc.Quality = 0;
desc.Usage = D3D11_USAGE_STAGING;
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
desc.MiscFlags = 0;
if(FAILED(device->CreateTexture2D(&desc,0,&captureTex)))
printLog("video/d3d11: couldn't create staging texture for gpu->cpu download!\n");
else
setCaptureResolution(desc.Width,desc.Height);
device->GetImmediateContext(&context);
context->CopySubresourceRegion(captureTex,0,0,0,0,tex,0,0);
D3D11_MAPPED_SUBRESOURCE mapped;
bool grabOk = false;
if(captureTex && SUCCEEDED(context->Map(captureTex,0,D3D11_MAP_READ,0,&mapped)))
{
switch(desc.Format)
{
case DXGI_FORMAT_R8G8B8A8_UNORM:
blitAndFlipRGBAToCaptureData((unsigned char *) mapped.pData,mapped.RowPitch);
grabOk = true;
break;
default:
printLog("video/d3d11: unsupported backbuffer format, can't grab pixels!\n");
break;
}
context->Unmap(captureTex,0);
}
tex->Release();
if(captureTex) captureTex->Release();
context->Release();
device->Release();
return grabOk;
}
void Renderer::createRenderTarget() {
ID3D11Texture2D* backBuffer;
m_swapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**) &backBuffer);
m_device->CreateRenderTargetView(backBuffer, nullptr, &m_renderTargetView);
backBuffer->GetDesc(&m_backBufferDesc);
backBuffer->Release();
}
void GFXD3D11TextureTarget::attachTexture( RenderSlot slot, GFXCubemap *tex, U32 face, U32 mipLevel/*=0*/ )
{
GFXDEBUGEVENT_SCOPE( GFXPCD3D11TextureTarget_attachTexture_Cubemap, ColorI::RED );
AssertFatal(slot < MaxRenderSlotId, "GFXD3D11TextureTarget::attachTexture - out of range slot.");
// Mark state as dirty so device can know to update.
invalidateState();
// Release what we had, it's definitely going to change.
SAFE_RELEASE(mTargetViews[slot]);
SAFE_RELEASE(mTargets[slot]);
SAFE_RELEASE(mTargetSRViews[slot]);
mResolveTargets[slot] = NULL;
// Cast the texture object to D3D...
AssertFatal(!tex || static_cast<GFXD3D11Cubemap*>(tex), "GFXD3DTextureTarget::attachTexture - invalid cubemap object.");
if(slot == Color0)
{
mTargetSize = Point2I::Zero;
mTargetFormat = GFXFormatR8G8B8A8;
}
// Are we clearing?
if(!tex)
{
// Yup - just exit, it'll stay NULL.
return;
}
GFXD3D11Cubemap *cube = static_cast<GFXD3D11Cubemap*>(tex);
mTargets[slot] = cube->get2DTex();
mTargets[slot]->AddRef();
mTargetViews[slot] = cube->getRTView(face);
mTargetViews[slot]->AddRef();
mTargetSRViews[slot] = cube->getSRView();
mTargetSRViews[slot]->AddRef();
// Update surface size
if(slot == Color0)
{
ID3D11Texture2D *surface = mTargets[Color0];
if ( surface )
{
D3D11_TEXTURE2D_DESC sd;
surface->GetDesc(&sd);
mTargetSize = Point2I(sd.Width, sd.Height);
S32 format = sd.Format;
GFXREVERSE_LOOKUP( GFXD3D11TextureFormat, GFXFormat, format );
mTargetFormat = (GFXFormat)format;
}
}
}
BYTE* getImageData(ID3D11ShaderResourceView* shaderResourceView,int* nWidth,int* nHeight) {
ID3D11Resource* resource = NULL;;
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
if (shaderResourceView) {
shaderResourceView->GetResource(&resource);
shaderResourceView->GetDesc(&srvDesc);
}
else {
return NULL;
}
ID3D11Texture2D* tex = (ID3D11Texture2D*)resource;
if (tex) {
D3D11_TEXTURE2D_DESC description;
tex->GetDesc(&description);
description.BindFlags = 0;
description.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
description.Usage = D3D11_USAGE_STAGING;
ID3D11Texture2D* texTemp = NULL;
HRESULT hr = ctx->device->CreateTexture2D(&description, NULL, &texTemp);
if (FAILED(hr)) {
if (texTemp) {
texTemp->Release();
texTemp = NULL;
}
return NULL;
}
ctx->deviceContext->CopyResource(texTemp, tex);
D3D11_MAPPED_SUBRESOURCE mapped;
unsigned int subresource = 0;
hr = ctx->deviceContext->Map(texTemp, 0, D3D11_MAP_READ, 0, &mapped);
if (FAILED(hr)) {
texTemp->Release();
texTemp = NULL;
return NULL;
}
*nWidth = description.Width;
*nHeight = description.Height;
const int pitch = mapped.RowPitch;
BYTE* source = (BYTE*)(mapped.pData);
BYTE* dest = new BYTE[(*nWidth)*(*nHeight) * 4];
BYTE* destTemp = dest;
for (int i = 0; i < *nHeight; ++i)
{
memcpy(destTemp, source, *nWidth * 4);
source += pitch;
destTemp += *nWidth * 4;
}
ctx->deviceContext->Unmap(texTemp, 0);
return dest;
}
else
return NULL;
}
void GFXD3D11WindowTarget::resolveTo(GFXTextureObject *tex)
{
GFXDEBUGEVENT_SCOPE(GFXPCD3D11WindowTarget_resolveTo, ColorI::RED);
D3D11_TEXTURE2D_DESC desc;
ID3D11Texture2D* surf = ((GFXD3D11TextureObject*)(tex))->get2DTex();
surf->GetDesc(&desc);
D3D11DEVICECONTEXT->ResolveSubresource(surf, 0, D3D11->mDeviceBackbuffer, 0, desc.Format);
}
void FXAA::PreRender(Shader* shader, GraphicsEngineParams engParams)
{
HRESULT hr = S_OK;
//get the surface/texture from the swap chain
ID3D11Texture2D* backBufferTex;
this->gSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&backBufferTex);
//get texture description
D3D11_TEXTURE2D_DESC texDesc;
backBufferTex->GetDesc(&texDesc);
//change bindflag for use as a shader resource
texDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
//create texture
ID3D11Texture2D* sceneTex;
hr = this->gDevice->CreateTexture2D(&texDesc, NULL, &sceneTex);
if(FAILED(hr))
{
MaloW::Debug("FXAA: Failed to create texture");
}
//get resource from the render target view of the backbuffer
ID3D11RenderTargetView* backBufferRTV = NULL;
this->gDeviceContext->OMGetRenderTargets(1, &backBufferRTV, NULL);
ID3D11Resource* backBufferRTVResource = NULL;
backBufferRTV->GetResource(&backBufferRTVResource);
//copy data from the resource to the scene texture
this->gDeviceContext->CopyResource(sceneTex, backBufferRTVResource);
//create shader resource view
ID3D11ShaderResourceView* sceneSRV;
hr = this->gDevice->CreateShaderResourceView(sceneTex, NULL, &sceneSRV);
if(FAILED(hr))
{
MaloW::Debug("FXAA: Failed to create shader resource view");
}
//set shader variables
shader->SetResource("sceneTex", sceneSRV);
shader->SetInt("FXAAPreset", this->mPreset);
shader->SetFloat4("rcpFrame", D3DXVECTOR4(1.0f / engParams.windowWidth, 1.0f / engParams.windowHeight, 0.0f, 0.0f));
//apply pass
shader->Apply(0);
//release
SAFE_RELEASE(backBufferTex);
SAFE_RELEASE(sceneTex);
SAFE_RELEASE(backBufferRTV);
SAFE_RELEASE(backBufferRTVResource);
SAFE_RELEASE(sceneSRV);
}
void ColorBuffer::InitializeDisplayBuffer(ID3D11RenderTargetView* renderTarget)
{
rtv_ = renderTarget;
rtv_->GetResource(&resource_);
ID3D11Texture2D* texture = (ID3D11Texture2D*)resource_;
D3D11_TEXTURE2D_DESC desc;
texture->GetDesc(&desc);
width_ = desc.Width;
height_ = desc.Height;
depth_ = desc.ArraySize;
}
void Texture::LoadFromMemory(const void* data, uint32_t size)
{
DirectX::CreateDDSTextureFromMemory(GraphicsCore::GetDevice(), reinterpret_cast<const byte*>(data), static_cast<size_t>(size), &resource_, &srv_);
// 2D only
ID3D11Texture2D* texture = (ID3D11Texture2D*)resource_;
D3D11_TEXTURE2D_DESC desc;
texture->GetDesc(&desc);
width_ = desc.Width;
height_ = desc.Height;
depth_ = desc.ArraySize;
}
//----------------------------------------------------------------------------
DX11TextureRT::DX11TextureRT(ID3D11Device* device,
DX11TextureRT const* dxSharedTexture)
:
DX11Texture2(dxSharedTexture->GetTexture()),
mRTView(nullptr)
{
ID3D11Texture2D* dxShared = dxSharedTexture->CreateSharedDXObject(device);
mDXObject = dxShared;
D3D11_TEXTURE2D_DESC desc;
dxShared->GetDesc(&desc);
CreateRTView(device, desc);
}
//-- 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 D3D11HardwarePixelBuffer::blitToMemory(const Image::Box &srcBox, const PixelBox &dst)
{
// Decide on pixel format of temp surface
PixelFormat tmpFormat = mFormat;
if(D3D11Mappings::_getPF(dst.format) != DXGI_FORMAT_UNKNOWN)
{
tmpFormat = dst.format;
}
assert(srcBox.getDepth() == 1 && dst.getDepth() == 1);
//This is a pointer to the texture we're trying to copy
//Only implemented for 2D at the moment...
ID3D11Texture2D *textureResource = mParentTexture->GetTex2D();
// get the description of the texture
D3D11_TEXTURE2D_DESC desc = {0};
textureResource->GetDesc( &desc );
//Alter the description to set up a staging texture
desc.Usage = D3D11_USAGE_STAGING;
//This texture is not bound to any part of the pipeline
desc.BindFlags = 0;
//Allow CPU Access
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
//No Misc Flags
desc.MiscFlags = 0;
//Create the staging texture
ID3D11Texture2D* pStagingTexture = NULL;
mDevice->CreateTexture2D( &desc, NULL, &pStagingTexture );
//Copy our texture into the staging texture
mDevice.GetImmediateContext()->CopyResource( pStagingTexture, textureResource );
//Create a mapped resource and map the staging texture to the resource
D3D11_MAPPED_SUBRESOURCE mapped = {0};
mDevice.GetImmediateContext()->Map( pStagingTexture, 0, D3D11_MAP_READ , 0, &mapped );
// read the data out of the texture.
unsigned int rPitch = mapped.RowPitch;
BYTE *data = ((BYTE *)mapped.pData);
//Using existing OGRE functions
DXGI_MAPPED_RECT lrect;
lrect.pBits = data;
lrect.Pitch = rPitch;
PixelBox locked(dst.getWidth(), dst.getHeight(), dst.getDepth(), tmpFormat);
fromD3DLock(locked, lrect);
PixelUtil::bulkPixelConversion(locked, dst);
//Release the staging texture
mDevice.GetImmediateContext()->Unmap( pStagingTexture, 0 );
pStagingTexture->Release();
}
void RenderTarget::CreateViewport(ID3D11Texture2D& texture, D3D11_VIEWPORT* viewport) {
// Set the viewport
D3D11_TEXTURE2D_DESC textureDesc;
texture.GetDesc(&textureDesc);
ZeroMemory(viewport, sizeof(D3D11_VIEWPORT));
viewport->TopLeftX = 0;
viewport->TopLeftY = 0;
viewport->Width = float(textureDesc.Width);
viewport->Height = float(textureDesc.Height);
// TODO: make sure these are the same as the values for the zbuffer
viewport->MinDepth = 0.0f;
viewport->MaxDepth = 1.0f;
}
DX11Texture2::DX11Texture2(ID3D11Device* device,
DX11Texture2 const* dxSharedTexture)
:
DX11TextureSingle(dxSharedTexture->GetTexture())
{
ID3D11Texture2D* dxShared = dxSharedTexture->CreateSharedDXObject(device);
mDXObject = dxShared;
D3D11_TEXTURE2D_DESC desc;
dxShared->GetDesc(&desc);
CreateSRView(device, desc);
if (dxSharedTexture->GetTexture()->GetUsage() == Resource::SHADER_OUTPUT)
{
CreateUAView(device, desc);
}
}
void Texture::LoadFromFile(const char* fileName)
{
wchar_t buffer[255] = { 0 };
size_t size;
mbstowcs_s(&size, buffer, fileName, sizeof(buffer));
auto hr = DirectX::CreateDDSTextureFromFile(GraphicsCore::GetDevice(), buffer, &resource_, &srv_);
THROW_IF_FAILED(hr);
// 2D only
ID3D11Texture2D* texture = (ID3D11Texture2D*)resource_;
D3D11_TEXTURE2D_DESC desc;
texture->GetDesc(&desc);
width_ = desc.Width;
height_ = desc.Height;
depth_ = desc.ArraySize;
}
XMFLOAT2 const ShaderResourceView::CalPicSize(std::wstring filePath) const
{
ID3D11ShaderResourceView* pISpriteSRV = GetSRV(filePath);
ID3D11Texture2D* pISpriteTex;
float TextureWidth = 0.0f,TextureHeight = 0.0f;
pISpriteSRV->GetResource( (ID3D11Resource**) &pISpriteTex);
D3D11_TEXTURE2D_DESC SpriteTexDesc;
pISpriteTex->GetDesc(&SpriteTexDesc);
TextureWidth = static_cast<float>(SpriteTexDesc.Width);
TextureHeight = static_cast<float>(SpriteTexDesc.Height);
SAFE_RELEASE(pISpriteTex);
return XMFLOAT2(TextureWidth,TextureHeight);
}
bool TextureCache::TCacheEntry::Save(const std::string& filename, u32 level)
{
// TODO: Somehow implement this (D3DX11 doesn't support dumping individual LODs)
static bool warn_once = true;
if (level && warn_once)
{
WARN_LOG(VIDEO, "Dumping individual LOD not supported by D3D11 backend!");
warn_once = false;
return false;
}
ID3D11Texture2D* pNewTexture = nullptr;
ID3D11Texture2D* pSurface = texture->GetTex();
D3D11_TEXTURE2D_DESC desc;
pSurface->GetDesc(&desc);
if (desc.Format != DXGI_FORMAT_R8G8B8A8_UNORM)
{
// Do not support compressed texture dump right now
return false;
}
desc.BindFlags = 0;
desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE;
desc.Usage = D3D11_USAGE_STAGING;
HRESULT hr = D3D::device->CreateTexture2D(&desc, nullptr, &pNewTexture);
bool saved_png = false;
if (SUCCEEDED(hr) && pNewTexture)
{
D3D::context->CopyResource(pNewTexture, pSurface);
D3D11_MAPPED_SUBRESOURCE map;
hr = D3D::context->Map(pNewTexture, 0, D3D11_MAP_READ_WRITE, 0, &map);
if (SUCCEEDED(hr))
{
saved_png = TextureToPng((u8*)map.pData, map.RowPitch, filename, desc.Width, desc.Height);
D3D::context->Unmap(pNewTexture, 0);
}
SAFE_RELEASE(pNewTexture);
}
return saved_png;
}
void App::OnSizeTerrain()
{
if (!device) return;
if (!g_pTerrainEffect) return;
HRESULT hr;
ID3D11Texture2D* pBackBuffer;
hr = swapChain->GetBuffer( 0, __uuidof( *pBackBuffer ), ( LPVOID* )&pBackBuffer );
DXGI_SURFACE_DESC pBBufferSurfaceDesc;
ZeroMemory( &pBBufferSurfaceDesc, sizeof( DXGI_SURFACE_DESC ) );
if( SUCCEEDED( hr ) )
{
D3D11_TEXTURE2D_DESC TexDesc;
pBackBuffer->GetDesc( &TexDesc );
pBBufferSurfaceDesc.Width = ( UINT )TexDesc.Width;
pBBufferSurfaceDesc.Height = ( UINT )TexDesc.Height;
pBBufferSurfaceDesc.Format = TexDesc.Format;
pBBufferSurfaceDesc.SampleDesc = TexDesc.SampleDesc;
SAFE_RELEASE( pBackBuffer );
}
ID3DX11EffectVectorVariable* pScreenSize = g_pTerrainEffect->GetVariableByName("g_screenSize")->AsVector();
if (pScreenSize)
{
D3DXVECTOR2 v((float) pBBufferSurfaceDesc.Width, (float) pBBufferSurfaceDesc.Height);
pScreenSize->SetFloatVector(v);
}
g_Skybox.OnD3D11ResizedSwapChain(&pBBufferSurfaceDesc);
unsigned int n = 1;
context->RSGetViewports(&n, &g_BackBufferVP);
g_ScreenSize = D3DXVECTOR2((float) pBBufferSurfaceDesc.Width, (float) pBBufferSurfaceDesc.Height);
float aspectRatio = g_ScreenSize.x / g_ScreenSize.y;
ActiveCam_->setFOV(RAD2DEG(noMath::PI / 3));
ActiveCam_->setNear(CLIP_NEAR);
ActiveCam_->setFar(CLIP_FAR);
ActiveCam_->SetAspect(aspectRatio);
ActiveCam_->ComputeProjection();
}
void App::ResizeSNBTerrain()
{
if (!terrainload_) return;
if (!device) return;
HRESULT hr;
ID3D11Texture2D* pBackBuffer;
hr = swapChain->GetBuffer( 0, __uuidof( *pBackBuffer ), ( LPVOID* )&pBackBuffer );
DXGI_SURFACE_DESC pBBufferSurfaceDesc;
ZeroMemory( &pBBufferSurfaceDesc, sizeof( DXGI_SURFACE_DESC ) );
if( SUCCEEDED( hr ) )
{
D3D11_TEXTURE2D_DESC TexDesc;
pBackBuffer->GetDesc( &TexDesc );
pBBufferSurfaceDesc.Width = ( UINT )TexDesc.Width;
pBBufferSurfaceDesc.Height = ( UINT )TexDesc.Height;
pBBufferSurfaceDesc.Format = TexDesc.Format;
pBBufferSurfaceDesc.SampleDesc = TexDesc.SampleDesc;
SAFE_RELEASE( pBackBuffer );
}
float fAspectRatio = pBBufferSurfaceDesc.Width / ( FLOAT )pBBufferSurfaceDesc.Height;
/*pcamera_->setFOV(RAD2DEG(noMath::PI / 4));
pcamera_->setNear(CLIP_NEAR);
pcamera_->setFar(CLIP_FAR);*/
ActiveCam_->SetAspect(fAspectRatio);
ActiveCam_->ComputeProjection();
//g_Camera.SetProjParams( noMath::PI / 4, fAspectRatio, 50.f, 250000.0f );
g_TerrainDX11Render.OnD3D11ResizedSwapChain( device, swapChain, &pBBufferSurfaceDesc, NULL );
BaseCamera* pCam = GetApp()->ActiveCam_;
D3DXMATRIX mProj;
//D3DXMATRIX mView;
const unsigned int size16 = sizeof(float) * 16;
//memcpy(&mView, pCam->getViewMatrix(), size16);
memcpy(&mProj, pCam->getProjectionMatrix(), size16);
g_TerrainDX11Render.SetViewFrustumParams( pBBufferSurfaceDesc.Width, pBBufferSurfaceDesc.Height, mProj );
}
void SetTarget(ID3D11Texture2D* pTarget)
{
if (pTarget == this->pTarget)
{
return;
}
else
{
this->pTarget = pTarget;
}
D3D11_TEXTURE2D_DESC texDesc;
pTarget->GetDesc(&texDesc);
sizeX = texDesc.Width; sizeY = texDesc.Height;
pRenderTargetView = nullptr;
D3D11_RENDER_TARGET_VIEW_DESC desc;
ZeroMemory(&desc, sizeof(desc));
desc.Format = texDesc.Format;
desc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
desc.Texture2D.MipSlice = 1;
HRESULT hr = pDevice->CreateRenderTargetView(pTarget,&desc , &pRenderTargetView);
if (FAILED(hr))
{
throw std::exception("CreateRenderTargetView failed.");
}
ID3D11RenderTargetView* targets[] =
{
pRenderTargetView
};
GetImmediateContext()->OMSetRenderTargets(1,targets, nullptr);
D3D11_VIEWPORT vps[] = {
{ 0,0,texDesc.Width,texDesc.Height,0,1 }
};
GetImmediateContext()->RSSetViewports(1, vps);
float const clearColor[] = { 0.0f, 0.0f, 0.0f, 0.0f };
GetImmediateContext()->ClearRenderTargetView(pRenderTargetView, clearColor);
}
void D3D11CanvasWindowGraphics::CreateSwapChainResources()
{
ID3D11Device* pDevice = m_driver->GetD3D11Device();
// Get back buffer RTV
ID3D11Texture2D* texture = NULL;
CHECK_HR(m_swapChain->GetBuffer(0, IID_PPV_ARGS(&texture)));
D3D11_TEXTURE2D_DESC t2dd;
texture->GetDesc(&t2dd);
CHECK_HR(pDevice->CreateRenderTargetView(texture, NULL, m_backBufferRTV.Receive()));
SafeRelease(texture);
// Create Direct2D render target
m_d2dTarget = D2DTarget::Create(m_driver->GetD2DFactory(),
pDevice, m_driver->GetD3D10Device(), t2dd.Width, t2dd.Height);
}
void DxSprite::BeginBatch(ID3D11ShaderResourceView * texSRV)
{
assert( Initialized );
BatchTexSRV = texSRV;
BatchTexSRV->AddRef( );
ID3D11Resource * resource = 0;
BatchTexSRV->GetResource(&resource);
ID3D11Texture2D * tex = reinterpret_cast<ID3D11Texture2D*>(resource);
D3D11_TEXTURE2D_DESC texDesc;
tex->GetDesc(&texDesc);
SAFE_RELEASE(resource)
TexWidth = texDesc.Width;
TexHeight = texDesc.Height;
SpriteList.clear( );
}
