1 //-------------------------------------------------------------------------------------
4 // DirectX Texture Library - Direct3D 11 helpers
6 // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
7 // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
8 // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
11 // Copyright (c) Microsoft Corporation. All rights reserved.
13 // http://go.microsoft.com/fwlink/?LinkId=248926
14 //-------------------------------------------------------------------------------------
16 #include "DirectXTexP.h"
23 static HRESULT _Capture( _In_ ID3D11DeviceContext* pContext, _In_ ID3D11Resource* pSource, _In_ const TexMetadata& metadata,
24 _In_ const ScratchImage& result )
26 if ( !pContext || !pSource || !result.GetPixels() )
29 if ( metadata.dimension == TEX_DIMENSION_TEXTURE3D )
31 //--- Volume texture ----------------------------------------------------------
32 assert( metadata.arraySize == 1 );
34 size_t height = metadata.height;
35 size_t depth = metadata.depth;
37 for( size_t level = 0; level < metadata.mipLevels; ++level )
39 UINT dindex = D3D11CalcSubresource( static_cast<UINT>( level ), 0, static_cast<UINT>( metadata.mipLevels ) );
41 D3D11_MAPPED_SUBRESOURCE mapped;
42 HRESULT hr = pContext->Map( pSource, dindex, D3D11_MAP_READ, 0, &mapped );
46 const uint8_t* pslice = reinterpret_cast<const uint8_t*>( mapped.pData );
49 pContext->Unmap( pSource, dindex );
53 size_t lines = ComputeScanlines( metadata.format, height );
55 for( size_t slice = 0; slice < depth; ++slice )
57 const Image* img = result.GetImage( level, 0, slice );
60 pContext->Unmap( pSource, dindex );
66 pContext->Unmap( pSource, dindex );
70 const uint8_t* sptr = pslice;
71 uint8_t* dptr = img->pixels;
72 for( size_t h = 0; h < lines; ++h )
74 size_t msize = std::min<size_t>( img->rowPitch, mapped.RowPitch );
75 memcpy_s( dptr, img->rowPitch, sptr, msize );
76 sptr += mapped.RowPitch;
77 dptr += img->rowPitch;
80 pslice += mapped.DepthPitch;
83 pContext->Unmap( pSource, dindex );
93 //--- 1D or 2D texture --------------------------------------------------------
94 assert( metadata.depth == 1 );
96 for( size_t item = 0; item < metadata.arraySize; ++item )
98 size_t height = metadata.height;
100 for( size_t level = 0; level < metadata.mipLevels; ++level )
102 UINT dindex = D3D11CalcSubresource( static_cast<UINT>( level ), static_cast<UINT>( item ), static_cast<UINT>( metadata.mipLevels ) );
104 D3D11_MAPPED_SUBRESOURCE mapped;
105 HRESULT hr = pContext->Map( pSource, dindex, D3D11_MAP_READ, 0, &mapped );
109 const Image* img = result.GetImage( level, item, 0 );
112 pContext->Unmap( pSource, dindex );
118 pContext->Unmap( pSource, dindex );
122 size_t lines = ComputeScanlines( metadata.format, height );
124 const uint8_t* sptr = reinterpret_cast<const uint8_t*>( mapped.pData );
125 uint8_t* dptr = img->pixels;
126 for( size_t h = 0; h < lines; ++h )
128 size_t msize = std::min<size_t>( img->rowPitch, mapped.RowPitch );
129 memcpy_s( dptr, img->rowPitch, sptr, msize );
130 sptr += mapped.RowPitch;
131 dptr += img->rowPitch;
134 pContext->Unmap( pSource, dindex );
146 //=====================================================================================
148 //=====================================================================================
150 //-------------------------------------------------------------------------------------
151 // Determine if given texture metadata is supported on the given device
152 //-------------------------------------------------------------------------------------
153 bool IsSupportedTexture( ID3D11Device* pDevice, const TexMetadata& metadata )
158 D3D_FEATURE_LEVEL fl = pDevice->GetFeatureLevel();
161 DXGI_FORMAT fmt = metadata.format;
163 if ( !IsValid( fmt ) )
171 case DXGI_FORMAT_BC4_TYPELESS:
172 case DXGI_FORMAT_BC4_UNORM:
173 case DXGI_FORMAT_BC4_SNORM:
174 case DXGI_FORMAT_BC5_TYPELESS:
175 case DXGI_FORMAT_BC5_UNORM:
176 case DXGI_FORMAT_BC5_SNORM:
177 if ( fl < D3D_FEATURE_LEVEL_10_0 )
181 case DXGI_FORMAT_BC6H_TYPELESS:
182 case DXGI_FORMAT_BC6H_UF16:
183 case DXGI_FORMAT_BC6H_SF16:
184 case DXGI_FORMAT_BC7_TYPELESS:
185 case DXGI_FORMAT_BC7_UNORM:
186 case DXGI_FORMAT_BC7_UNORM_SRGB:
187 if ( fl < D3D_FEATURE_LEVEL_11_0 )
192 // Validate miplevel count
193 if ( metadata.mipLevels > D3D11_REQ_MIP_LEVELS )
196 // Validate array size, dimension, and width/height
197 size_t arraySize = metadata.arraySize;
198 size_t iWidth = metadata.width;
199 size_t iHeight = metadata.height;
200 size_t iDepth = metadata.depth;
202 // Most cases are known apriori based on feature level, but we use this for robustness to handle the few optional cases
203 UINT formatSupport = 0;
204 pDevice->CheckFormatSupport( fmt, &formatSupport );
206 switch ( metadata.dimension )
208 case TEX_DIMENSION_TEXTURE1D:
209 if ( !(formatSupport & D3D11_FORMAT_SUPPORT_TEXTURE1D) )
212 if ( (arraySize > D3D11_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION)
213 || (iWidth > D3D11_REQ_TEXTURE1D_U_DIMENSION) )
216 if ( fl < D3D_FEATURE_LEVEL_11_0 )
218 if ( (arraySize > D3D10_REQ_TEXTURE1D_ARRAY_AXIS_DIMENSION)
219 || (iWidth > D3D10_REQ_TEXTURE1D_U_DIMENSION) )
222 if ( fl < D3D_FEATURE_LEVEL_10_0 )
224 if ( (arraySize > 1) || (iWidth > 4096 /*D3D_FL9_3_REQ_TEXTURE1D_U_DIMENSION*/) )
227 if ( (fl < D3D_FEATURE_LEVEL_9_3) && (iWidth > 2048 /*D3D_FL9_1_REQ_TEXTURE1D_U_DIMENSION*/ ) )
233 case TEX_DIMENSION_TEXTURE2D:
234 if ( metadata.miscFlags & TEX_MISC_TEXTURECUBE )
236 if ( !(formatSupport & D3D11_FORMAT_SUPPORT_TEXTURECUBE) )
239 if ( (arraySize > D3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION)
240 || (iWidth > D3D11_REQ_TEXTURECUBE_DIMENSION)
241 || (iHeight > D3D11_REQ_TEXTURECUBE_DIMENSION))
244 if ( fl < D3D_FEATURE_LEVEL_11_0 )
246 if ( (arraySize > D3D10_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION)
247 || (iWidth > D3D10_REQ_TEXTURECUBE_DIMENSION)
248 || (iHeight > D3D10_REQ_TEXTURECUBE_DIMENSION))
251 if ( (fl < D3D_FEATURE_LEVEL_10_1) && (arraySize != 6) )
254 if ( fl < D3D_FEATURE_LEVEL_10_0 )
256 if ( (iWidth > 4096 /*D3D_FL9_3_REQ_TEXTURECUBE_DIMENSION*/ )
257 || (iHeight > 4096 /*D3D_FL9_3_REQ_TEXTURECUBE_DIMENSION*/ ) )
260 if ( (fl < D3D_FEATURE_LEVEL_9_3)
261 && ( (iWidth > 512 /*D3D_FL9_1_REQ_TEXTURECUBE_DIMENSION*/)
262 || (iHeight > 512 /*D3D_FL9_1_REQ_TEXTURECUBE_DIMENSION*/) ) )
267 else // Not a cube map
269 if ( !(formatSupport & D3D11_FORMAT_SUPPORT_TEXTURE2D) )
272 if ( (arraySize > D3D11_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION)
273 || (iWidth > D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION)
274 || (iHeight > D3D11_REQ_TEXTURE2D_U_OR_V_DIMENSION))
277 if ( fl < D3D_FEATURE_LEVEL_11_0 )
279 if ( (arraySize > D3D10_REQ_TEXTURE2D_ARRAY_AXIS_DIMENSION)
280 || (iWidth > D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION)
281 || (iHeight > D3D10_REQ_TEXTURE2D_U_OR_V_DIMENSION))
284 if ( fl < D3D_FEATURE_LEVEL_10_0 )
287 || (iWidth > 4096 /*D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION*/)
288 || (iHeight > 4096 /*D3D_FL9_3_REQ_TEXTURE2D_U_OR_V_DIMENSION*/) )
291 if ( (fl < D3D_FEATURE_LEVEL_9_3)
292 && ( (iWidth > 2048 /*D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION*/)
293 || (iHeight > 2048 /*D3D_FL9_1_REQ_TEXTURE2D_U_OR_V_DIMENSION*/) ) )
300 case TEX_DIMENSION_TEXTURE3D:
301 if ( !(formatSupport & D3D11_FORMAT_SUPPORT_TEXTURE3D) )
305 || (iWidth > D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION)
306 || (iHeight > D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION)
307 || (iDepth > D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION) )
310 if ( fl < D3D_FEATURE_LEVEL_11_0 )
312 if ( (iWidth > D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION)
313 || (iHeight > D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION)
314 || (iDepth > D3D10_REQ_TEXTURE3D_U_V_OR_W_DIMENSION) )
317 if ( fl < D3D_FEATURE_LEVEL_10_0 )
319 if ( (iWidth > 256 /*D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION*/)
320 || (iHeight > 256 /*D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION*/)
321 || (iDepth > 256 /*D3D_FL9_1_REQ_TEXTURE3D_U_V_OR_W_DIMENSION*/) )
328 // Not a supported dimension
336 //-------------------------------------------------------------------------------------
337 // Create a texture resource
338 //-------------------------------------------------------------------------------------
339 HRESULT CreateTexture( ID3D11Device* pDevice, const Image* srcImages, size_t nimages, const TexMetadata& metadata,
340 ID3D11Resource** ppResource )
342 if ( !pDevice || !srcImages || !nimages || !ppResource )
345 if ( !metadata.mipLevels || !metadata.arraySize )
349 if ( (metadata.width > 0xFFFFFFFF) || (metadata.height > 0xFFFFFFFF)
350 || (metadata.mipLevels > 0xFFFFFFFF) || (metadata.arraySize > 0xFFFFFFFF) )
354 std::unique_ptr<D3D11_SUBRESOURCE_DATA[]> initData( new D3D11_SUBRESOURCE_DATA[ metadata.mipLevels * metadata.arraySize ] );
356 return E_OUTOFMEMORY;
358 // Fill out subresource array
359 if ( metadata.dimension == TEX_DIMENSION_TEXTURE3D )
361 //--- Volume case -------------------------------------------------------------
362 if ( !metadata.depth )
366 if ( metadata.depth > 0xFFFFFFFF )
370 if ( metadata.arraySize > 1 )
371 // Direct3D 11 doesn't support arrays of 3D textures
372 return HRESULT_FROM_WIN32( ERROR_NOT_SUPPORTED );
374 size_t depth = metadata.depth;
377 for( size_t level = 0; level < metadata.mipLevels; ++level )
379 size_t index = metadata.ComputeIndex( level, 0, 0 );
380 if ( index >= nimages )
383 const Image& img = srcImages[ index ];
385 if ( img.format != metadata.format )
391 // Verify pixels in image 1 .. (depth-1) are exactly image->slicePitch apart
392 // For 3D textures, this relies on all slices of the same miplevel being continous in memory
393 // (this is how ScratchImage lays them out), which is why we just give the 0th slice to Direct3D 11
394 const uint8_t* pSlice = img.pixels + img.slicePitch;
395 for( size_t slice = 1; slice < depth; ++slice )
397 size_t tindex = metadata.ComputeIndex( level, 0, slice );
398 if ( tindex >= nimages )
401 const Image& timg = srcImages[ tindex ];
406 if ( timg.pixels != pSlice
407 || timg.format != metadata.format
408 || timg.rowPitch != img.rowPitch
409 || timg.slicePitch != img.slicePitch )
412 pSlice = timg.pixels + img.slicePitch;
415 assert( idx < (metadata.mipLevels * metadata.arraySize) );
417 initData[idx].pSysMem = img.pixels;
418 initData[idx].SysMemPitch = static_cast<DWORD>( img.rowPitch );
419 initData[idx].SysMemSlicePitch = static_cast<DWORD>( img.slicePitch );
428 //--- 1D or 2D texture case ---------------------------------------------------
430 for( size_t item = 0; item < metadata.arraySize; ++item )
432 for( size_t level = 0; level < metadata.mipLevels; ++level )
434 size_t index = metadata.ComputeIndex( level, item, 0 );
435 if ( index >= nimages )
438 const Image& img = srcImages[ index ];
440 if ( img.format != metadata.format )
446 assert( idx < (metadata.mipLevels * metadata.arraySize) );
448 initData[idx].pSysMem = img.pixels;
449 initData[idx].SysMemPitch = static_cast<DWORD>( img.rowPitch );
450 initData[idx].SysMemSlicePitch = static_cast<DWORD>( img.slicePitch );
456 // Create texture using static initialization data
459 switch ( metadata.dimension )
461 case TEX_DIMENSION_TEXTURE1D:
463 D3D11_TEXTURE1D_DESC desc;
464 desc.Width = static_cast<UINT>( metadata.width );
465 desc.MipLevels = static_cast<UINT>( metadata.mipLevels );
466 desc.ArraySize = static_cast<UINT>( metadata.arraySize );
467 desc.Format = metadata.format;
468 desc.Usage = D3D11_USAGE_DEFAULT;
469 desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
470 desc.CPUAccessFlags = 0;
473 hr = pDevice->CreateTexture1D( &desc, initData.get(), reinterpret_cast<ID3D11Texture1D**>(ppResource) );
477 case TEX_DIMENSION_TEXTURE2D:
479 D3D11_TEXTURE2D_DESC desc;
480 desc.Width = static_cast<UINT>( metadata.width );
481 desc.Height = static_cast<UINT>( metadata.height );
482 desc.MipLevels = static_cast<UINT>( metadata.mipLevels );
483 desc.ArraySize = static_cast<UINT>( metadata.arraySize );
484 desc.Format = metadata.format;
485 desc.SampleDesc.Count = 1;
486 desc.SampleDesc.Quality = 0;
487 desc.Usage = D3D11_USAGE_DEFAULT;
488 desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
489 desc.CPUAccessFlags = 0;
490 desc.MiscFlags = (metadata.miscFlags & TEX_MISC_TEXTURECUBE) ? D3D11_RESOURCE_MISC_TEXTURECUBE : 0;
492 hr = pDevice->CreateTexture2D( &desc, initData.get(), reinterpret_cast<ID3D11Texture2D**>(ppResource) );
496 case TEX_DIMENSION_TEXTURE3D:
498 D3D11_TEXTURE3D_DESC desc;
499 desc.Width = static_cast<UINT>( metadata.width );
500 desc.Height = static_cast<UINT>( metadata.height );
501 desc.Depth = static_cast<UINT>( metadata.depth );
502 desc.MipLevels = static_cast<UINT>( metadata.mipLevels );
503 desc.Format = metadata.format;
504 desc.Usage = D3D11_USAGE_DEFAULT;
505 desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
506 desc.CPUAccessFlags = 0;
509 hr = pDevice->CreateTexture3D( &desc, initData.get(), reinterpret_cast<ID3D11Texture3D**>(ppResource) );
518 //-------------------------------------------------------------------------------------
519 // Create a shader resource view and associated texture
520 //-------------------------------------------------------------------------------------
521 HRESULT CreateShaderResourceView( ID3D11Device* pDevice, const Image* srcImages, size_t nimages, const TexMetadata& metadata,
522 ID3D11ShaderResourceView** ppSRV )
527 ScopedObject<ID3D11Resource> resource;
528 HRESULT hr = CreateTexture( pDevice, srcImages, nimages, metadata, &resource );
532 assert( !resource.IsNull() );
534 D3D11_SHADER_RESOURCE_VIEW_DESC SRVDesc;
535 memset( &SRVDesc, 0, sizeof(SRVDesc) );
536 SRVDesc.Format = metadata.format;
538 switch ( metadata.dimension )
540 case TEX_DIMENSION_TEXTURE1D:
541 if ( metadata.arraySize > 1 )
543 SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1DARRAY;
544 SRVDesc.Texture1DArray.MipLevels = static_cast<UINT>( metadata.mipLevels );
545 SRVDesc.Texture1DArray.ArraySize = static_cast<UINT>( metadata.arraySize );
549 SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE1D;
550 SRVDesc.Texture1D.MipLevels = static_cast<UINT>( metadata.mipLevels );
554 case TEX_DIMENSION_TEXTURE2D:
555 if ( metadata.miscFlags & TEX_MISC_TEXTURECUBE )
557 if (metadata.arraySize > 6)
559 assert( (metadata.arraySize % 6) == 0 );
560 SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBEARRAY;
561 SRVDesc.TextureCubeArray.MipLevels = static_cast<UINT>( metadata.mipLevels );
562 SRVDesc.TextureCubeArray.NumCubes = static_cast<UINT>( metadata.arraySize / 6 );
566 SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
567 SRVDesc.TextureCube.MipLevels = static_cast<UINT>( metadata.mipLevels );
570 else if ( metadata.arraySize > 1 )
572 SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
573 SRVDesc.Texture2DArray.MipLevels = static_cast<UINT>( metadata.mipLevels );
574 SRVDesc.Texture2DArray.ArraySize = static_cast<UINT>( metadata.arraySize );
578 SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
579 SRVDesc.Texture2D.MipLevels = static_cast<UINT>( metadata.mipLevels );
583 case TEX_DIMENSION_TEXTURE3D:
584 assert( metadata.arraySize == 1 );
585 SRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
586 SRVDesc.Texture3D.MipLevels = static_cast<UINT>( metadata.mipLevels );
593 hr = pDevice->CreateShaderResourceView( resource.Get(), &SRVDesc, ppSRV );
603 //-------------------------------------------------------------------------------------
604 // Save a texture resource to a DDS file in memory/on disk
605 //-------------------------------------------------------------------------------------
606 HRESULT CaptureTexture( ID3D11Device* pDevice, ID3D11DeviceContext* pContext, ID3D11Resource* pSource, ScratchImage& result )
608 if ( !pDevice || !pContext || !pSource )
611 D3D11_RESOURCE_DIMENSION resType = D3D11_RESOURCE_DIMENSION_UNKNOWN;
612 pSource->GetType( &resType );
618 case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
620 ScopedObject<ID3D11Texture1D> pTexture;
621 hr = pSource->QueryInterface( __uuidof(ID3D11Texture1D), (void**) &pTexture );
625 assert( pTexture.Get() );
627 D3D11_TEXTURE1D_DESC desc;
628 pTexture->GetDesc( &desc );
632 desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
633 desc.Usage = D3D11_USAGE_STAGING;
635 ScopedObject<ID3D11Texture1D> pStaging;
636 hr = pDevice->CreateTexture1D( &desc, 0, &pStaging );
640 assert( pStaging.Get() );
642 pContext->CopyResource( pStaging.Get(), pSource );
645 mdata.width = desc.Width;
646 mdata.height = mdata.depth = 1;
647 mdata.arraySize = desc.ArraySize;
648 mdata.mipLevels = desc.MipLevels;
650 mdata.format = desc.Format;
651 mdata.dimension = TEX_DIMENSION_TEXTURE1D;
653 hr = result.Initialize( mdata );
657 hr = _Capture( pContext, pStaging.Get(), mdata, result );
661 case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
663 ScopedObject<ID3D11Texture2D> pTexture;
664 hr = pSource->QueryInterface( __uuidof(ID3D11Texture2D), (void**) &pTexture );
668 assert( pTexture.Get() );
670 D3D11_TEXTURE2D_DESC desc;
671 pTexture->GetDesc( &desc );
673 ScopedObject<ID3D11Texture2D> pStaging;
674 if ( desc.SampleDesc.Count > 1 )
676 desc.SampleDesc.Count = 1;
677 desc.SampleDesc.Quality = 0;
679 ScopedObject<ID3D11Texture2D> pTemp;
680 hr = pDevice->CreateTexture2D( &desc, 0, &pTemp );
684 assert( pTemp.Get() );
686 DXGI_FORMAT fmt = desc.Format;
687 if ( IsTypeless(fmt) )
689 // Assume a UNORM if it exists otherwise use FLOAT
690 fmt = MakeTypelessUNORM( fmt );
691 fmt = MakeTypelessFLOAT( fmt );
695 hr = pDevice->CheckFormatSupport( fmt, &support );
699 if ( !(support & D3D11_FORMAT_SUPPORT_MULTISAMPLE_RESOLVE) )
705 for( UINT item = 0; item < desc.ArraySize; ++item )
707 for( UINT level = 0; level < desc.MipLevels; ++level )
709 UINT index = D3D11CalcSubresource( level, item, desc.MipLevels );
711 pContext->ResolveSubresource( pTemp.Get(), index, pSource, index, fmt );
716 desc.MiscFlags &= D3D11_RESOURCE_MISC_TEXTURECUBE;
717 desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
718 desc.Usage = D3D11_USAGE_STAGING;
720 hr = pDevice->CreateTexture2D( &desc, 0, &pStaging );
724 assert( pStaging.Get() );
726 pContext->CopyResource( pStaging.Get(), pTemp.Get() );
731 desc.MiscFlags &= D3D11_RESOURCE_MISC_TEXTURECUBE;
732 desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
733 desc.Usage = D3D11_USAGE_STAGING;
735 hr = pDevice->CreateTexture2D( &desc, 0, &pStaging );
739 assert( pStaging.Get() );
741 pContext->CopyResource( pStaging.Get(), pSource );
745 mdata.width = desc.Width;
746 mdata.height = desc.Height;
748 mdata.arraySize = desc.ArraySize;
749 mdata.mipLevels = desc.MipLevels;
750 mdata.miscFlags = (desc.MiscFlags & D3D11_RESOURCE_MISC_TEXTURECUBE) ? TEX_MISC_TEXTURECUBE : 0;
751 mdata.format = desc.Format;
752 mdata.dimension = TEX_DIMENSION_TEXTURE2D;
754 hr = result.Initialize( mdata );
758 hr = _Capture( pContext, pStaging.Get(), mdata, result );
762 case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
764 ScopedObject<ID3D11Texture3D> pTexture;
765 hr = pSource->QueryInterface( __uuidof(ID3D11Texture3D), (void**) &pTexture );
769 assert( pTexture.Get() );
771 D3D11_TEXTURE3D_DESC desc;
772 pTexture->GetDesc( &desc );
776 desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
777 desc.Usage = D3D11_USAGE_STAGING;
779 ScopedObject<ID3D11Texture3D> pStaging;
780 hr = pDevice->CreateTexture3D( &desc, 0, &pStaging );
784 assert( pStaging.Get() );
786 pContext->CopyResource( pStaging.Get(), pSource );
789 mdata.width = desc.Width;
790 mdata.height = desc.Height;
791 mdata.depth = desc.Depth;
793 mdata.mipLevels = desc.MipLevels;
795 mdata.format = desc.Format;
796 mdata.dimension = TEX_DIMENSION_TEXTURE3D;
798 hr = result.Initialize( mdata );
802 hr = _Capture( pContext, pStaging.Get(), mdata, result );