// texture
TextureHandle Gfx_Texture_Load(RenderDevice* dev, const char* filename, TextureType::type type)
{
(void)type; // TODO
ID3D11Texture2D* tex_dx11 = NULL;
D3DX11_IMAGE_LOAD_INFO image_load_info;
D3D_CALL( D3DX11CreateTextureFromFileA(dev->native, filename, &image_load_info, NULL, (ID3D11Resource**)&tex_dx11, NULL) );
if( tex_dx11 == NULL ) return InvalidResourceHandle();
D3D11_TEXTURE2D_DESC desc;
tex_dx11->GetDesc(&desc);
TextureDescr tex = TextureDescr::create_2D(desc.Width, desc.Height, dx11_convert<PixelFormat::type>(desc.Format), TextureType::Tex2D);
R_ASSERT( tex.format!=PixelFormat::Unknown );
TextureDX11 res;
res.desc = tex;
res.native2D = tex_dx11;
res.srv = create_srv(dev->native, tex_dx11);
return dev->resources.textures.push(res);
}
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;
}
//////////////////////////////////////////////////////////////////////////
// texture from file
HRESULT cgl::core::CD3D11TextureFromFile::onRestore()
{
// get image info
D3DX11_IMAGE_INFO imgInfo;
HRESULT result = D3DX11GetImageInfoFromFileA(m_filename.c_str(), NULL, &imgInfo, NULL);
if (FAILED(result)) { return result;}
m_loadInfo.pSrcInfo = &imgInfo;
return D3DX11CreateTextureFromFileA(CGLAccess::D3DDevice(), m_filename.c_str(), &m_loadInfo, NULL, ptr(), NULL);
}
HRESULT D3D11Object::CreateTextureInArray( LPCSTR sFileName, D3DX11_IMAGE_LOAD_INFO* LoadInfo, ID3D11Resource** ppResource, ID3D11Resource* pDest, int iArraySlice )
{
HRESULT hr = S_OK;
if(fileExists(sFileName))
{
printf("Create texture %s\n", sFileName);
D3DX11CreateTextureFromFileA( m_pDevice, sFileName, LoadInfo, NULL, (ID3D11Resource**)(ppResource), NULL );
m_pDeviceContext->CopySubresourceRegion(pDest, D3D11CalcSubresource(0, iArraySlice, 1), 0, 0, 0, *ppResource, 0, NULL);
}
return hr;
}
void Texture::InitFromFile(const char * fileName)
{
D3DX11CreateTextureFromFileA(device,fileName,nullptr,nullptr,(ID3D11Resource**)&texture,nullptr);
if(texture != nullptr)
{
D3D11_TEXTURE2D_DESC desc;
texture->GetDesc(&desc);
width = desc.Width;
height = desc.Height;
device->CreateShaderResourceView(texture,nullptr,&view);
}
}
void DirectX11Texture::loadFromFile(const std::string& _filename)
{
destroy();
std::string fullname = DirectX11DataManager::getInstance().getDataPath(_filename);
D3DX11_IMAGE_INFO fileInfo;
D3DX11GetImageInfoFromFile( fullname.c_str(), NULL, &fileInfo, NULL );
mWidth = fileInfo.Width;
mHeight = fileInfo.Height;
D3DX11_IMAGE_LOAD_INFO loadInfo;
loadInfo.Width = fileInfo.Width;
loadInfo.Height = fileInfo.Height;
loadInfo.FirstMipLevel = 0;
loadInfo.MipLevels = fileInfo.MipLevels;
loadInfo.Usage = D3D11_USAGE_DEFAULT;
loadInfo.BindFlags = D3D11_BIND_SHADER_RESOURCE;
loadInfo.CpuAccessFlags = 0;
loadInfo.MiscFlags = 0;
loadInfo.Format = fileInfo.Format;
loadInfo.Filter = D3DX11_FILTER_NONE;
loadInfo.MipFilter = D3DX11_FILTER_NONE;
loadInfo.pSrcInfo = &fileInfo;
HRESULT hr = D3DX11CreateTextureFromFileA( mManager->mpD3DDevice, fullname.c_str(), &loadInfo, NULL, (ID3D11Resource**)&mTexture, NULL );
MYGUI_PLATFORM_ASSERT(hr == S_OK, "CreateTextureFromFile failed!");
D3D11_TEXTURE2D_DESC desc;
mTexture->GetDesc(&desc);
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
srvDesc.Format = desc.Format;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MipLevels = 1;
srvDesc.Texture2D.MostDetailedMip = 0;
hr = mManager->mpD3DDevice->CreateShaderResourceView(mTexture, &srvDesc, &mResourceView);
MYGUI_PLATFORM_ASSERT(hr == S_OK, "Create Shader ResourceView failed!");
}
void CALLBACK load_texture_from_file(ID3D11Device *pdevice, char *file_name, ID3D11ShaderResourceView **ppsrv, void *user_context)
{
HRESULT hr;
d3d11_texture2d_ptr tex;
std::string texture_path = std::string("../data/MicroscopeCity/") + std::string(file_name);
D3DX11_IMAGE_LOAD_INFO img_load_info;
D3DX11_IMAGE_INFO img_info;
D3DX11GetImageInfoFromFileA(file_name, NULL, &img_info, NULL);
img_load_info.pSrcInfo = &img_info;
V(D3DX11CreateTextureFromFileA(pdevice, texture_path.c_str(), &img_load_info, NULL, (ID3D11Resource**)&tex, &hr));
// Create shader resource view for .fx
D3D11_TEXTURE2D_DESC tex_desc;
D3D11_SHADER_RESOURCE_VIEW_DESC srv_desc;
tex->GetDesc(&tex_desc);
srv_desc.Format = tex_desc.Format;
srv_desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srv_desc.Texture2D.MostDetailedMip = 0;
srv_desc.Texture2D.MipLevels = tex_desc.MipLevels;
V(pdevice->CreateShaderResourceView(tex, &srv_desc, ppsrv));
}
//carrega uma textura 2d do disco
HRESULT ACD3D::LoadTexture(std::string path, ACTexture** ppOutTexturePtr)
{
*ppOutTexturePtr = new ACTexture();
ZeroMemory(*ppOutTexturePtr, sizeof ( ACTexture ));
ID3D11Resource* pTexture = nullptr;
//carrega a textura do arquivo
HRESULT hr = D3DX11CreateTextureFromFileA(ACD3DGlobals::G_pD3dDevice,
path.c_str(),
nullptr,
nullptr,
&pTexture,
nullptr);
if(hr != AC_OK)
{
std::string message;
switch(hr)
{
case D3D11_ERROR_FILE_NOT_FOUND: message = "[ERROR] Erro ao carregar textura. File not found: " + path; break;
case D3DERR_INVALIDCALL: message = "[ERROR] Erro ao carregar textura. Invalid call: " + path; break;
case E_INVALIDARG: message = "[ERROR] Erro ao carregar textura. Invalid argument: " + path; break;
case E_OUTOFMEMORY: message = "[ERROR] Erro ao carregar textura. Out of memory: " + path; break;
default: message = "[ERROR] Erro ao carregar textura. Unknown error: " + path;
}
MessageBoxA(nullptr, message.c_str(), "Error", MB_OK | MB_ICONERROR);
Log(const_cast<char*>(message.c_str()));
return hr;
}
//dimension type
D3D11_RESOURCE_DIMENSION type;
pTexture->GetType( &type );
switch( type )
{
case D3D11_RESOURCE_DIMENSION_TEXTURE1D:
{
D3D11_TEXTURE1D_DESC desc;
ID3D11Texture1D *pTexture1D = (ID3D11Texture1D*)pTexture;
pTexture1D->GetDesc( &desc );
//popula o actexture
(*ppOutTexturePtr)->Width = desc.Width;
(*ppOutTexturePtr)->Height = 0;
(*ppOutTexturePtr)->MipLevels = desc.MipLevels;
(*ppOutTexturePtr)->TextureType = ACTT_Texture1D;
}
break;
case D3D11_RESOURCE_DIMENSION_TEXTURE2D:
{
D3D11_TEXTURE2D_DESC desc;
ID3D11Texture2D *pTexture2D = (ID3D11Texture2D*)pTexture;
pTexture2D->GetDesc( &desc );
//popula o actexture
(*ppOutTexturePtr)->Width = desc.Width;
(*ppOutTexturePtr)->Height = desc.Height;
(*ppOutTexturePtr)->MipLevels = desc.MipLevels;
(*ppOutTexturePtr)->TextureType = ACTT_Texture2D;
}
break;
case D3D11_RESOURCE_DIMENSION_TEXTURE3D:
{
D3D11_TEXTURE3D_DESC desc;
ID3D11Texture3D *pTexture3D = (ID3D11Texture3D*)pTexture;
pTexture3D->GetDesc( &desc );
//popula o actexture
(*ppOutTexturePtr)->Width = desc.Width;
(*ppOutTexturePtr)->Height = desc.Height;
(*ppOutTexturePtr)->Depth = desc.Depth;
(*ppOutTexturePtr)->MipLevels = desc.MipLevels;
(*ppOutTexturePtr)->TextureType = ACTT_Texture3D;
}
break;
}
ID3D11ShaderResourceView* pSRV;
hr = ACD3DGlobals::G_pD3dDevice->CreateShaderResourceView( pTexture, nullptr, &pSRV );
if (FAILED ( hr ) )
{
MessageBoxA(nullptr, "[ERROR] CreateShaderResourceView. LoadTexture()", "Error", MB_OK | MB_ICONERROR);
}
//popula o actexture
(*ppOutTexturePtr)->pData = pSRV;
return AC_OK;
};
//--------------------------------------------------------------------------
D3D11Texture::D3D11Texture(const STRING& filename, eTextureType type, uint32 usage, bool bSRGB)
: Texture(type, 0, 0, 0, ePF_Unknown, usage, true)
, m_pTexture2D(nullptr)
, m_pTexture3D(nullptr)
, m_pRTV(nullptr)
, m_pSRV(nullptr)
, m_pDSV(nullptr)
, m_pTexStaging(nullptr)
{
////////////////////////////////////////////////////////////////
////////////// Load texture
HRESULT hr = S_OK;
D3DX11_IMAGE_LOAD_INFO loadInfo;
loadInfo.MipLevels = 0;
loadInfo.BindFlags = 0;
loadInfo.Format = DXGI_FORMAT_FROM_FILE;
ID3D11Resource** pTex = nullptr;
switch (GetTextureType())
{
case eTextureType_2D:
{
pTex = (ID3D11Resource**)&m_pTexture2D;
if (usage & eTextureUsage_ReadWrite)
{
loadInfo.Usage = D3D11_USAGE_STAGING;
loadInfo.CpuAccessFlags = D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ;
}
}
break;
case eTextureType_CubeMap:
{
loadInfo.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE;
pTex = (ID3D11Resource**)&m_pTexture2D;
}
break;
case eTextureType_3D:
{
pTex = (ID3D11Resource**)&m_pTexture3D;
}
break;
default: _AST(0);
}
if (filename.find(".dds") != STRING::npos)
{
if (usage & eTextureUsage_ReadWrite)
{
V(DirectX::CreateDDSTextureFromFileEx(g_pRenderSys->GetDevice(), EngineToUnicode(filename).c_str(),
4096, D3D11_USAGE_STAGING, 0, D3D11_CPU_ACCESS_READ, 0, bSRGB, pTex, nullptr));
}
else
{
V(DirectX::CreateDDSTextureFromFileEx(g_pRenderSys->GetDevice(), EngineToUnicode(filename).c_str(),
4096, D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0, bSRGB, pTex, &m_pSRV));
}
}
else
{
V(D3DX11CreateTextureFromFileA(g_pRenderSys->GetDevice(), filename.c_str(), &loadInfo, nullptr, pTex, nullptr));
if (!(usage & eTextureUsage_ReadWrite))
{
CreateSRV();
}
}
// Store texture dimension and format
switch (GetTextureType())
{
case eTextureType_2D:
case eTextureType_CubeMap:
{
D3D11_TEXTURE2D_DESC desc;
m_pTexture2D->GetDesc(&desc);
m_width = desc.Width;
m_height = desc.Height;
m_texFormat = ConvertFromDXFormat(desc.Format);
}
break;
case eTextureType_3D:
{
D3D11_TEXTURE3D_DESC desc;
m_pTexture3D->GetDesc(&desc);
m_width = desc.Width;
m_height = desc.Height;
m_texFormat = ConvertFromDXFormat(desc.Format);
}
break;
default: _AST(0);
}
}
//------------------------------------------------------------------------------------
D3D11Texture::D3D11Texture(const StringVector& vecTexNames, bool bSRGB)
: Texture(eTextureType_TextureArray, 0, 0, 0, ePF_Unknown, 0, true)
, m_pTexture2D(nullptr)
, m_pTexture3D(nullptr)
, m_pRTV(nullptr)
, m_pSRV(nullptr)
, m_pDSV(nullptr)
, m_pTexStaging(nullptr)
{
_AST(!vecTexNames.empty());
HRESULT hr = S_OK;
// First load all texture elements
std::vector<ID3D11Texture2D*> vecTexs(vecTexNames.size());
for (size_t i=0; i<vecTexNames.size(); ++i)
{
D3DX11_IMAGE_LOAD_INFO loadInfo;
loadInfo.Width = D3DX11_FROM_FILE;
loadInfo.Height = D3DX11_FROM_FILE;
loadInfo.Depth = D3DX11_FROM_FILE;
loadInfo.FirstMipLevel = 0;
loadInfo.BindFlags = 0;
loadInfo.Usage = D3D11_USAGE_STAGING; // Local res
loadInfo.MipLevels = 0;
loadInfo.CpuAccessFlags = D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ;
loadInfo.MiscFlags = 0;
loadInfo.Format = DXGI_FORMAT_FROM_FILE;
loadInfo.Filter = D3DX11_FILTER_NONE;
loadInfo.MipFilter = D3DX11_FILTER_LINEAR;
loadInfo.pSrcInfo = 0;
if (vecTexNames[i].find(".dds") != STRING::npos)
{
V(DirectX::CreateDDSTextureFromFileEx(g_pRenderSys->GetDevice(), EngineToUnicode(vecTexNames[i]).c_str(),
4096, D3D11_USAGE_STAGING, 0, D3D11_CPU_ACCESS_READ, 0, bSRGB, (ID3D11Resource**)&vecTexs[i], nullptr));
}
else
{
V(D3DX11CreateTextureFromFileA(g_pRenderSys->GetDevice(), vecTexNames[i].c_str(),
&loadInfo, nullptr, (ID3D11Resource**)&vecTexs[i], nullptr));
}
}
// Then create the texture array object
D3D11_TEXTURE2D_DESC texElementDesc;
vecTexs[0]->GetDesc(&texElementDesc);
// Store dimension and format
m_width = texElementDesc.Width;
m_height = texElementDesc.Height;
m_texFormat = ConvertFromDXFormat(texElementDesc.Format);
D3D11_TEXTURE2D_DESC texArrayDesc;
texArrayDesc.Width = texElementDesc.Width;
texArrayDesc.Height = texElementDesc.Height;
texArrayDesc.MipLevels = texElementDesc.MipLevels;
texArrayDesc.ArraySize = vecTexs.size();
texArrayDesc.Format = texElementDesc.Format;
texArrayDesc.SampleDesc.Count = 1;
texArrayDesc.SampleDesc.Quality = 0;
texArrayDesc.Usage = D3D11_USAGE_DEFAULT;
texArrayDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
texArrayDesc.CPUAccessFlags = 0;
texArrayDesc.MiscFlags = 0;
V(g_pRenderSys->GetDevice()->CreateTexture2D(&texArrayDesc, 0, &m_pTexture2D));
// Fill texture array data
ID3D11DeviceContext* dc = g_pRenderSys->GetDeviceContext();
for(size_t texElement=0; texElement<vecTexs.size(); ++texElement)
{
vecTexs[texElement]->GetDesc(&texElementDesc);
for(UINT mipLevel = 0; mipLevel < texElementDesc.MipLevels; ++mipLevel)
{
D3D11_MAPPED_SUBRESOURCE mappedTex2D;
V(dc->Map(vecTexs[texElement], mipLevel, D3D11_MAP_READ, 0, &mappedTex2D));
dc->UpdateSubresource(m_pTexture2D,
D3D11CalcSubresource(mipLevel, texElement, texElementDesc.MipLevels),
0, mappedTex2D.pData, mappedTex2D.RowPitch, mappedTex2D.DepthPitch);
dc->Unmap(vecTexs[texElement], mipLevel);
}
}
CreateSRV();
for(size_t i=0; i<vecTexs.size(); ++i)
vecTexs[i]->Release();
}
//--------------------------------------------------------------------------
D3D11Texture::D3D11Texture(const STRING& filename, eTextureType type, uint32 usage)
:m_pTexture2D(nullptr)
,m_pTexture3D(nullptr)
,m_pRenderSystem(g_env.pRenderSystem)
,m_rtView(nullptr)
,m_pSRV(nullptr)
,m_pDSV(nullptr)
,m_usage(usage)
,m_texType(type)
,m_width(0)
,m_height(0)
,m_bMipMap(true)
{
m_pd3dDevice = m_pRenderSystem->GetDevice();
if (m_pd3dDevice)
m_pd3dDevice->AddRef();
////////////////////////////////////////////////////////////////
////////////// Load texture
HRESULT hr = S_OK;
D3DX11_IMAGE_LOAD_INFO loadInfo;
loadInfo.MipLevels = 0;
ID3D11Resource** pTex = nullptr;
switch (GetTextureType())
{
case eTextureType_2D:
{
pTex = (ID3D11Resource**)&m_pTexture2D;
}
break;
case eTextureType_CubeMap:
{
loadInfo.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE;
pTex = (ID3D11Resource**)&m_pTexture2D;
}
break;
case eTextureType_3D:
{
pTex = (ID3D11Resource**)&m_pTexture3D;
}
break;
default:
assert(0);
}
V(D3DX11CreateTextureFromFileA(m_pd3dDevice, filename.c_str(), &loadInfo, nullptr,pTex, nullptr));
// Create SRV
CreateSRV();
// Store texture dimension and format
switch (GetTextureType())
{
case eTextureType_2D:
case eTextureType_CubeMap:
{
D3D11_TEXTURE2D_DESC desc;
m_pTexture2D->GetDesc(&desc);
m_width = desc.Width;
m_height = desc.Height;
m_texFormat = ConvertFromDXFormat(desc.Format);
}
break;
case eTextureType_3D:
{
D3D11_TEXTURE3D_DESC desc;
m_pTexture3D->GetDesc(&desc);
m_width = desc.Width;
m_height = desc.Height;
m_texFormat = ConvertFromDXFormat(desc.Format);
}
break;
default:
assert(0);
}
}
//------------------------------------------------------------------------------------
D3D11Texture::D3D11Texture( const StringVector& vecTexNames )
:m_pTexture2D(nullptr)
,m_pTexture3D(nullptr)
,m_pRenderSystem(g_env.pRenderSystem)
,m_rtView(nullptr)
,m_pSRV(nullptr)
,m_pDSV(nullptr)
,m_usage(0)
,m_texType(eTextureType_TextureArray)
,m_bMipMap(true)
{
m_pd3dDevice = m_pRenderSystem->GetDevice();
if (m_pd3dDevice)
m_pd3dDevice->AddRef();
assert(!vecTexNames.empty());
HRESULT hr = S_OK;
// First load all texture elements
std::vector<ID3D11Texture2D*> vecTexs(vecTexNames.size());
for (size_t i=0; i<vecTexNames.size(); ++i)
{
D3DX11_IMAGE_LOAD_INFO loadInfo;
loadInfo.Width = D3DX11_FROM_FILE;
loadInfo.Height = D3DX11_FROM_FILE;
loadInfo.Depth = D3DX11_FROM_FILE;
loadInfo.FirstMipLevel = 0;
loadInfo.BindFlags = 0;
loadInfo.Usage = D3D11_USAGE_STAGING; // Local res
loadInfo.MipLevels = 0;
loadInfo.CpuAccessFlags = D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ;
loadInfo.MiscFlags = 0;
loadInfo.Format = DXGI_FORMAT_FROM_FILE;
loadInfo.Filter = D3DX11_FILTER_NONE;
loadInfo.MipFilter = D3DX11_FILTER_LINEAR;
loadInfo.pSrcInfo = 0;
V(D3DX11CreateTextureFromFileA(m_pRenderSystem->GetDevice(), vecTexNames[i].c_str(),
&loadInfo, nullptr, (ID3D11Resource**)&vecTexs[i], nullptr));
}
// Then create the texture array object
D3D11_TEXTURE2D_DESC texElementDesc;
vecTexs[0]->GetDesc(&texElementDesc);
// Store dimension and format
m_width = texElementDesc.Width;
m_height = texElementDesc.Height;
m_texFormat = ConvertFromDXFormat(texElementDesc.Format);
D3D11_TEXTURE2D_DESC texArrayDesc;
texArrayDesc.Width = texElementDesc.Width;
texArrayDesc.Height = texElementDesc.Height;
texArrayDesc.MipLevels = texElementDesc.MipLevels;
texArrayDesc.ArraySize = vecTexs.size();
texArrayDesc.Format = texElementDesc.Format;
texArrayDesc.SampleDesc.Count = 1;
texArrayDesc.SampleDesc.Quality = 0;
texArrayDesc.Usage = D3D11_USAGE_DEFAULT;
texArrayDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
texArrayDesc.CPUAccessFlags = 0;
texArrayDesc.MiscFlags = 0;
V(m_pRenderSystem->GetDevice()->CreateTexture2D( &texArrayDesc, 0, &m_pTexture2D));
// Fill texture array data
ID3D11DeviceContext* dc = m_pRenderSystem->GetDeviceContext();
for(size_t texElement=0; texElement<vecTexs.size(); ++texElement)
{
for(UINT mipLevel = 0; mipLevel < texElementDesc.MipLevels; ++mipLevel)
{
D3D11_MAPPED_SUBRESOURCE mappedTex2D;
V(dc->Map(vecTexs[texElement], mipLevel, D3D11_MAP_READ, 0, &mappedTex2D));
dc->UpdateSubresource(m_pTexture2D,
D3D11CalcSubresource(mipLevel, texElement, texElementDesc.MipLevels),
0, mappedTex2D.pData, mappedTex2D.RowPitch, mappedTex2D.DepthPitch);
dc->Unmap(vecTexs[texElement], mipLevel);
}
}
CreateSRV();
for(size_t i=0; i<vecTexs.size(); ++i)
vecTexs[i]->Release();
}
