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;
}
HRESULT InitFont11( ID3D11Device* pd3d11Device, ID3D11InputLayout* pInputLayout )
{
HRESULT hr = S_OK;
CHAR str[MAX_PATH] = "UI\\Font.dds";
//V_RETURN( DXUTFindDXSDKMediaFileCch( str, MAX_PATH, L"UI\\Font.dds" ) );
if (pd3d11Device->GetFeatureLevel() < D3D_FEATURE_LEVEL_10_0 ) {
D3DX11_IMAGE_INFO dii;
D3DX11GetImageInfoFromFile( str, NULL, &dii, NULL );
D3DX11_IMAGE_LOAD_INFO dili;
dili.BindFlags = D3DX11_DEFAULT;
dili.CpuAccessFlags = D3DX11_DEFAULT;
dili.Depth = D3DX11_DEFAULT;
dili.Filter = D3DX11_DEFAULT;
dili.FirstMipLevel = 0;
dili.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
dili.Height = D3DX11_DEFAULT;
dili.MipFilter = D3DX11_DEFAULT;
dili.MipLevels = 1;
dili.MiscFlags = D3DX11_DEFAULT;
dili.pSrcInfo = &dii;
dili.Usage = D3D11_USAGE_DEFAULT ;
dili.Width = D3DX11_DEFAULT;
D3DX11CreateShaderResourceViewFromFile( pd3d11Device, str, &dili, NULL, &g_pFont11, &hr) ;
}
else
{
D3DX11CreateShaderResourceViewFromFile( pd3d11Device, str, NULL, NULL, &g_pFont11, &hr);
}
#if defined(PROFILE) || defined(DEBUG)
if (g_pFont11)
{
ID3D11Resource *pRes = NULL;
g_pFont11->GetResource( &pRes );
SAFE_RELEASE( pRes );
}
#endif
g_pInputLayout11 = pInputLayout;
return hr;
}
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!");
}
// テクスチャロード
int LoadTexture( TCHAR *szFileName, TEX_PICTURE *pTexPic )
{
HRESULT hr;
D3DX11_IMAGE_INFO ImageInfo;
D3DX11_IMAGE_LOAD_INFO liLoadInfo;
ID3D11Texture2D *pTexture;
int nTexWidth, nTexHeight;
// 画像情報取得
hr = D3DX11GetImageInfoFromFile( szFileName, NULL, &ImageInfo, NULL );
if ( FAILED( hr ) ) {
return hr;
}
nTexWidth = ( int )pow( 2.0, floor( log( ( double )ImageInfo.Width ) / log( 2.0 ) + 1.01 ) );
if ( ( nTexWidth / 2 ) == ImageInfo.Width ) nTexWidth /= 2;
nTexHeight = ( int )pow( 2.0, floor( log( ( double )ImageInfo.Height ) / log( 2.0 ) + 1.01 ) );
if ( ( nTexHeight / 2 ) == ImageInfo.Height ) nTexHeight /= 2;
// ロード
ZeroMemory( &liLoadInfo, sizeof( D3DX11_IMAGE_LOAD_INFO ) );
liLoadInfo.Width = nTexWidth;
liLoadInfo.Height = nTexHeight;
liLoadInfo.BindFlags = D3D11_BIND_SHADER_RESOURCE;
liLoadInfo.Format = ImageInfo.Format;
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 = ImageInfo.Width;
pTexPic->nHeight = ImageInfo.Height;
return S_OK;
}
// |----------------------------------------------------------------------------|
// | Initialize |
// |----------------------------------------------------------------------------|
bool Texture::Initialize(WCHAR* filename)
{
DebugLog ("Texture::Initialize() called.", DB_GRAPHICS, 1);
HRESULT result;
// Get device
ID3D11Device* device = D3DManager::GetRef()->GetDevice();
// Get original image dimmensions
D3DX11_IMAGE_INFO info;
D3DX11GetImageInfoFromFile(filename, 0, &info, &result);
m_width = info.Width;
m_height = info.Height;
// Load the texture in.
result = D3DX11CreateShaderResourceViewFromFile(device, filename, NULL, NULL, &m_shaderResourceView, NULL);
if(FAILED(result))
{
DebugPopup(L"Could not find texture file.");
return false;
}
return true;
}
CPUTResult CPUTTextureDX11::CreateNativeTexture(
ID3D11Device *pD3dDevice,
const cString &fileName,
ID3D11ShaderResourceView **ppShaderResourceView,
ID3D11Resource **ppTexture,
bool ForceLoadAsSRGB
){
CPUTResult result;
HRESULT hr;
// Set up loading structure
//
// Indicate all texture parameters should come from the file
D3DX11_IMAGE_LOAD_INFO LoadInfo;
ZeroMemory(&LoadInfo, sizeof(D3DX11_IMAGE_LOAD_INFO));
LoadInfo.Width = D3DX11_FROM_FILE;
LoadInfo.Height = D3DX11_FROM_FILE;
LoadInfo.Depth = D3DX11_FROM_FILE;
LoadInfo.FirstMipLevel = D3DX11_FROM_FILE;
LoadInfo.MipLevels = D3DX11_FROM_FILE;
// LoadInfo.Usage = D3D11_USAGE_IMMUTABLE; // TODO: maintain a "mappable" flag? Set immutable if not mappable?
LoadInfo.Usage = D3D11_USAGE_DEFAULT;
LoadInfo.BindFlags = D3D11_BIND_SHADER_RESOURCE;
LoadInfo.CpuAccessFlags = 0;
LoadInfo.MiscFlags = 0;
LoadInfo.MipFilter = D3DX11_FROM_FILE;
LoadInfo.pSrcInfo = NULL;
LoadInfo.Format = (DXGI_FORMAT) D3DX11_FROM_FILE;
LoadInfo.Filter = D3DX11_FILTER_NONE;
// if we're 'forcing' load of sRGB data, we need to verify image is sRGB
// or determine image format that best matches the non-sRGB source format in hopes that the conversion will be faster
// and data preserved
if(true == ForceLoadAsSRGB)
{
// get the source image info
D3DX11_IMAGE_INFO SrcInfo;
hr = D3DX11GetImageInfoFromFile(fileName.c_str(), NULL, &SrcInfo, NULL);
ASSERT( SUCCEEDED(hr), _L(" - Error loading texture '")+fileName+_L("'.") );
// find a closest equivalent sRGB format
result = GetSRGBEquivalent(SrcInfo.Format, LoadInfo.Format);
ASSERT( CPUTSUCCESS(result), _L("Error loading texture '")+fileName+_L("'. It is specified this texture must load as sRGB, but the source image is in a format that cannot be converted to sRGB.\n") );
// set filtering mode to interpret 'in'-coming data as sRGB, and storing it 'out' on an sRGB surface
//
// As it stands, we don't have any tools that support sRGB output in DXT compressed textures.
// If we later support a format that does provide sRGB, then the filter 'in' flag will need to be removed
LoadInfo.Filter = D3DX11_FILTER_NONE | D3DX11_FILTER_SRGB_IN | D3DX11_FILTER_SRGB_OUT;
#if 0
// DWM: TODO: We want to catch the cases where the loader needs to do work.
// This happens if the texture's pixel format isn't supported by DXGI.
// TODO: how to determine?
// if a runtime conversion must happen report a performance warning error.
// Note: choosing not to assert here, as this will be a common issue.
if( SrcInfo.Format != LoadInfo.Format)
{
cString dxgiName = GetDXGIFormatString(SrcInfo.Format);
cString errorString = _T(__FUNCTION__);
errorString += _L("- PERFORMANCE WARNING: '") + fileName
+_L("' has an image format ")+dxgiName
+_L(" but must be run-time converted to ")+GetDXGIFormatString(LoadInfo.Format)
+_L(" based on requested sRGB target buffer.\n");
TRACE( errorString.c_str() );
}
#endif
}
//hr = D3DX11CreateTextureFromFile( pD3dDevice, fileName.c_str(), &LoadInfo, NULL, ppTexture, NULL );
hr = MyCreateTextureFromFile( pD3dDevice, fileName.c_str(), &LoadInfo, NULL, ppTexture, NULL );
ASSERT( SUCCEEDED(hr), _L("Failed to load texture: ") + fileName );
CPUTSetDebugName( *ppTexture, fileName );
hr = pD3dDevice->CreateShaderResourceView( *ppTexture, NULL, ppShaderResourceView );
ASSERT( SUCCEEDED(hr), _L("Failed to create texture shader resource view.") );
CPUTSetDebugName( *ppShaderResourceView, fileName );
return CPUT_SUCCESS;
}
INT_PTR CALLBACK ConfigureBitmapTransitionProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch(message)
{
case WM_INITDIALOG:
{
ConfigBitmapInfo *configInfo = (ConfigBitmapInfo*)lParam;
SetWindowLongPtr(hwnd, DWLP_USER, (LONG_PTR)configInfo);
LocalizeWindow(hwnd);
//--------------------------
HWND hwndTemp = GetDlgItem(hwnd, IDC_BITMAPS);
StringList bitmapList;
configInfo->data->GetStringList(TEXT("bitmap"), bitmapList);
for(UINT i=0; i<bitmapList.Num(); i++)
{
CTSTR lpBitmap = bitmapList[i];
if(OSFileExists(lpBitmap))
SendMessage(hwndTemp, LB_ADDSTRING, 0, (LPARAM)lpBitmap);
}
//--------------------------
hwndTemp = GetDlgItem(hwnd, IDC_TRANSITIONTIME);
UINT transitionTime = configInfo->data->GetInt(TEXT("transitionTime"));
SendMessage(hwndTemp, UDM_SETRANGE32, MIN_TRANSITION_TIME, MAX_TRANSITION_TIME);
if(!transitionTime)
transitionTime = 10;
SendMessage(hwndTemp, UDM_SETPOS32, 0, transitionTime);
EnableWindow(GetDlgItem(hwnd, IDC_REPLACE), FALSE);
EnableWindow(GetDlgItem(hwnd, IDC_REMOVE), FALSE);
EnableWindow(GetDlgItem(hwnd, IDC_MOVEUPWARD), FALSE);
EnableWindow(GetDlgItem(hwnd, IDC_MOVEDOWNWARD), FALSE);
//--------------------------
BOOL bFadeInOnly = configInfo->data->GetInt(TEXT("fadeInOnly"), 1);
BOOL bDisableFading = configInfo->data->GetInt(TEXT("disableFading"));
BOOL bRandomize = configInfo->data->GetInt(TEXT("randomize"));
SendMessage(GetDlgItem(hwnd, IDC_FADEINONLY), BM_SETCHECK, bFadeInOnly ? BST_CHECKED : BST_UNCHECKED, 0);
SendMessage(GetDlgItem(hwnd, IDC_DISABLEFADING), BM_SETCHECK, bDisableFading ? BST_CHECKED : BST_UNCHECKED, 0);
SendMessage(GetDlgItem(hwnd, IDC_RANDOMIZE), BM_SETCHECK, bRandomize ? BST_CHECKED : BST_UNCHECKED, 0);
EnableWindow(GetDlgItem(hwnd, IDC_FADEINONLY), !bDisableFading);
return TRUE;
}
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDC_ADD:
{
TSTR lpFile = (TSTR)Allocate(32*1024*sizeof(TCHAR));
zero(lpFile, 32*1024*sizeof(TCHAR));
OPENFILENAME ofn;
zero(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.lpstrFile = lpFile;
ofn.hwndOwner = hwnd;
ofn.nMaxFile = 32*1024*sizeof(TCHAR);
ofn.lpstrFilter = TEXT("All Formats (*.bmp;*.dds;*.jpg;*.png;*.gif)\0*.bmp;*.dds;*.jpg;*.png;*.gif\0");
ofn.nFilterIndex = 1;
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_ALLOWMULTISELECT | OFN_EXPLORER;
TCHAR curDirectory[MAX_PATH+1];
GetCurrentDirectory(MAX_PATH, curDirectory);
BOOL bOpenFile = GetOpenFileName(&ofn);
TCHAR newDirectory[MAX_PATH+1];
GetCurrentDirectory(MAX_PATH, newDirectory);
SetCurrentDirectory(curDirectory);
if(bOpenFile)
{
TSTR lpCurFile = lpFile+ofn.nFileOffset;
while(lpCurFile && *lpCurFile)
{
String strPath;
strPath << newDirectory << TEXT("\\") << lpCurFile;
SendMessage(GetDlgItem(hwnd, IDC_BITMAPS), LB_ADDSTRING, 0, (LPARAM)strPath.Array());
lpCurFile += slen(lpCurFile)+1;
}
}
Free(lpFile);
break;
}
case IDC_BITMAPS:
if(HIWORD(wParam) == LBN_SELCHANGE)
{
EnableWindow(GetDlgItem(hwnd, IDC_REPLACE), TRUE);
EnableWindow(GetDlgItem(hwnd, IDC_REMOVE), TRUE);
EnableWindow(GetDlgItem(hwnd, IDC_MOVEUPWARD), TRUE);
EnableWindow(GetDlgItem(hwnd, IDC_MOVEDOWNWARD), TRUE);
}
break;
case IDC_REMOVE:
{
UINT curSel = (UINT)SendMessage(GetDlgItem(hwnd, IDC_BITMAPS), LB_GETCURSEL, 0, 0);
if(curSel != LB_ERR)
{
SendMessage(GetDlgItem(hwnd, IDC_BITMAPS), LB_DELETESTRING, curSel, 0);
EnableWindow(GetDlgItem(hwnd, IDC_REPLACE), FALSE);
EnableWindow(GetDlgItem(hwnd, IDC_REMOVE), FALSE);
EnableWindow(GetDlgItem(hwnd, IDC_MOVEUPWARD), FALSE);
EnableWindow(GetDlgItem(hwnd, IDC_MOVEDOWNWARD), FALSE);
}
}
break;
case IDC_MOVEUPWARD:
{
HWND hwndBitmaps = GetDlgItem(hwnd, IDC_BITMAPS);
UINT curSel = (UINT)SendMessage(hwndBitmaps, LB_GETCURSEL, 0, 0);
if(curSel != LB_ERR)
{
if(curSel > 0)
{
String strText = GetLBText(hwndBitmaps, curSel);
SendMessage(hwndBitmaps, LB_DELETESTRING, curSel, 0);
SendMessage(hwndBitmaps, LB_INSERTSTRING, --curSel, (LPARAM)strText.Array());
PostMessage(hwndBitmaps, LB_SETCURSEL, curSel, 0);
}
}
}
break;
case IDC_MOVEDOWNWARD:
{
HWND hwndBitmaps = GetDlgItem(hwnd, IDC_BITMAPS);
UINT numBitmaps = (UINT)SendMessage(hwndBitmaps, LB_GETCOUNT, 0, 0);
UINT curSel = (UINT)SendMessage(hwndBitmaps, LB_GETCURSEL, 0, 0);
if(curSel != LB_ERR)
{
if(curSel < (numBitmaps-1))
{
String strText = GetLBText(hwndBitmaps, curSel);
SendMessage(hwndBitmaps, LB_DELETESTRING, curSel, 0);
SendMessage(hwndBitmaps, LB_INSERTSTRING, ++curSel, (LPARAM)strText.Array());
PostMessage(hwndBitmaps, LB_SETCURSEL, curSel, 0);
}
}
}
break;
case IDC_DISABLEFADING:
{
BOOL bDisableFading = SendMessage(GetDlgItem(hwnd, IDC_DISABLEFADING), BM_GETCHECK, 0, 0) == BST_CHECKED;
EnableWindow(GetDlgItem(hwnd, IDC_FADEINONLY), !bDisableFading);
}
break;
case IDOK:
{
HWND hwndBitmaps = GetDlgItem(hwnd, IDC_BITMAPS);
UINT numBitmaps = (UINT)SendMessage(hwndBitmaps, LB_GETCOUNT, 0, 0);
if(!numBitmaps)
{
OBSMessageBox(hwnd, Str("Sources.TransitionSource.Empty"), NULL, 0);
break;
}
//---------------------------
StringList bitmapList;
for(UINT i=0; i<numBitmaps; i++)
bitmapList << GetLBText(hwndBitmaps, i);
ConfigBitmapInfo *configInfo = (ConfigBitmapInfo*)GetWindowLongPtr(hwnd, DWLP_USER);
D3DX11_IMAGE_INFO ii;
if(SUCCEEDED(D3DX11GetImageInfoFromFile(bitmapList[0], NULL, &ii, NULL)))
{
configInfo->cx = ii.Width;
configInfo->cy = ii.Height;
}
else
{
configInfo->cx = configInfo->cy = 32;
AppWarning(TEXT("ConfigureBitmapTransitionSource: could not get image info for bitmap '%s'"), bitmapList[0].Array());
}
configInfo->data->SetStringList(TEXT("bitmap"), bitmapList);
UINT transitionTime = (UINT)SendMessage(GetDlgItem(hwnd, IDC_TRANSITIONTIME), UDM_GETPOS32, 0, 0);
configInfo->data->SetInt(TEXT("transitionTime"), transitionTime);
BOOL bFadeInOnly = SendMessage(GetDlgItem(hwnd, IDC_FADEINONLY), BM_GETCHECK, 0, 0) == BST_CHECKED;
BOOL bDisableFading = SendMessage(GetDlgItem(hwnd, IDC_DISABLEFADING), BM_GETCHECK, 0, 0) == BST_CHECKED;
BOOL bRandomize = SendMessage(GetDlgItem(hwnd, IDC_RANDOMIZE), BM_GETCHECK, 0, 0) == BST_CHECKED;
configInfo->data->SetInt(TEXT("fadeInOnly"), bFadeInOnly);
configInfo->data->SetInt(TEXT("disableFading"), bDisableFading);
configInfo->data->SetInt(TEXT("randomize"), bRandomize);
}
case IDCANCEL:
EndDialog(hwnd, LOWORD(wParam));
break;
}
break;
}
return 0;
}
