bool NavigationLine::CreateDeviceObjects() { if (!m_visible) return true; ID3DXBuffer* errors = 0; HRESULT hr; hr = D3DXCreateTextureFromFileA(g_pDevice, m_textureFile.c_str(), &m_lineTexture); if (FAILED(hr)) { DebugSpewAlways("Failed to load texture!"); InvalidateDeviceObjects(); return false; } hr = D3DXCreateEffectFromFileA(g_pDevice, m_shaderFile.c_str(), NULL, NULL, 0, NULL, &m_effect, &errors); if (FAILED(hr)) { if (errors) { DebugSpewAlways("Effect error: %s", errors->GetBufferPointer()); errors->Release(); errors = nullptr; } InvalidateDeviceObjects(); return false; } D3DVERTEXELEMENT9 vertexElements[] = { { 0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 }, { 0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0 }, { 0, 24, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 }, { 0, 40, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 1 }, D3DDECL_END() }; hr = g_pDevice->CreateVertexDeclaration(vertexElements, &m_vDeclaration); if (FAILED(hr)) { InvalidateDeviceObjects(); return false; } m_effect->SetTexture("lineTexture", m_lineTexture); m_loaded = true; return true; }
CAnimationModel::~CAnimationModel() { InvalidateDeviceObjects(); DeleteDeviceObjects(); SAFE_DELETE_ARRAY( m_pXFileName ); }
void CWndAbout::OnDestroy() { InvalidateDeviceObjects(); DeleteDeviceObjects(); SAFE_DELETE(m_pFont); }
void CTailEffectBelt::Destroy( void ) { InvalidateDeviceObjects(); SAFE_RELEASE( m_pTexture ); SAFE_DELETE_ARRAY( m_pPool ); Init(); }
void CStdGL::Clear() { NoPrimaryClipper(); // cannot unlock TexMgr here or we can't preserve textures across GL reinitialization as required when changing multisampling InvalidateDeviceObjects(); NoPrimaryClipper(); RenderTarget = NULL; // Clear all shaders SpriteShader.Clear(); SpriteShaderMod2.Clear(); SpriteShaderBase.Clear(); SpriteShaderBaseMod2.Clear(); SpriteShaderBaseOverlay.Clear(); SpriteShaderBaseOverlayMod2.Clear(); SpriteShaderLight.Clear(); SpriteShaderLightMod2.Clear(); SpriteShaderLightBase.Clear(); SpriteShaderLightBaseMod2.Clear(); SpriteShaderLightBaseOverlay.Clear(); SpriteShaderLightBaseOverlayMod2.Clear(); SpriteShaderLightBaseNormal.Clear(); SpriteShaderLightBaseNormalMod2.Clear(); SpriteShaderLightBaseNormalOverlay.Clear(); SpriteShaderLightBaseNormalOverlayMod2.Clear(); // clear context if (pCurrCtx) pCurrCtx->Deselect(); pMainCtx=0; C4Draw::Clear(); }
BOOL CDxtexApp::HandlePossibleLostDevice(VOID) { HRESULT hr; if( !m_bDeviceLost ) return TRUE; // ok to render hr = m_pd3ddev->TestCooperativeLevel(); if( hr == D3DERR_DEVICELOST ) return FALSE; // not ready to reset, but not ok to render if( hr == D3DERR_DEVICENOTRESET ) { InvalidateDeviceObjects(); D3DPRESENT_PARAMETERS presentParams; ZeroMemory(&presentParams, sizeof(presentParams)); presentParams.Windowed = TRUE; presentParams.SwapEffect = D3DSWAPEFFECT_COPY; presentParams.BackBufferWidth = 8; presentParams.BackBufferHeight = 8; presentParams.BackBufferFormat = D3DFMT_UNKNOWN; hr = m_pd3ddev->Reset( &presentParams ); if( FAILED( hr ) ) return FALSE; RestoreDeviceObjects(); m_bDeviceLost = FALSE; } return TRUE; }
void CDirect3D::DestroyD3D(void) { #if D3D_THREAD // Kill child thread if(thread != NULL) { Wait(false); thread_run = false; thread_command = D3D_IDLE; LeaveCriticalSection(&cs); SDL_SemPost(thread_sem); SDL_WaitThread(thread, NULL); thread = NULL; } #endif InvalidateDeviceObjects(); // Delete D3D device SAFE_RELEASE(pD3DDevice9); SAFE_RELEASE(pD3D9); if(modes) { free(modes); modes = NULL; } }
void CTailEffectModel::Destroy( void ) { InvalidateDeviceObjects(); m_pModel->DeleteDeviceObjects(); SAFE_DELETE(m_pModel); m_vecTail.clear(); Init(); }
void Terrain::RestoreDeviceObjects(void) { InvalidateDeviceObjects(); LoadTexture(); LoadTerrainFromFile(m_sTerrainFile.c_str()); /*if (FAILED(m_pd3dDevice->CreateVertexBuffer(m_uNumVertices * sizeof(TerrainVertex), D3DUSAGE_WRITEONLY, TerrainVertex::FVF_Flags, D3DPOOL_MANAGED, &m_pVertexBuffer, 0))) { return; } TerrainVertex *pVertices = NULL; if (SUCCEEDED(m_pVertexBuffer->Lock(0, 0, (void **)&pVertices, 0))) { float fStartX = -m_fTerrainWidth / 2.0f, fEndX = m_fTerrainWidth / 2.0f; float fStartZ = m_fTerrainDepth / 2.0f, fEndZ = -m_fTerrainDepth / 2.0f; float fTextureU = 10.0f / (float)m_uCellsPerRow; float fTextureV = 10.0f / (float)m_uCellsPerCol; int nIndex = 0, i = 0; for (float z = fStartZ; z >= fEndZ; z -= m_fCellsSpace, ++i) { int j = 0; for (float x = fStartX; x <= fEndX; x += m_fCellsSpace, ++j) { nIndex = i * m_uCellsPerRow + j; pVertices[nIndex] = TerrainVertex(x, m_vHeightData[nIndex], z, j * fTextureU, i * fTextureV); ++nIndex; } } m_pVertexBuffer->Unlock(); }*/ UINT uWidth = (int)sqrt((float)m_uNumVertices); if (FAILED(m_pd3dDevice->CreateVertexBuffer(m_uNumVertices * sizeof(Vertex), D3DUSAGE_WRITEONLY, Vertex::FVF_Flags, D3DPOOL_MANAGED, &m_pVertexBuffer, 0))) { return; } Vertex *pVertices = NULL; if (SUCCEEDED(m_pVertexBuffer->Lock(0, 0, (void **)&pVertices, 0))) { GenerateTerrainVertex(pVertices, &m_vHeightData[0], uWidth, uWidth); m_pVertexBuffer->Unlock(); } m_uNumIndices = GetIndicesNum(uWidth, uWidth); if (FAILED(m_pd3dDevice->CreateIndexBuffer(m_uNumIndices * sizeof(int), D3DUSAGE_WRITEONLY, D3DFMT_INDEX32, D3DPOOL_MANAGED, &m_pIndexBuffer, 0))) { return; } int *pIndices = NULL; if (SUCCEEDED(m_pIndexBuffer->Lock(0, 0, (void **)&pIndices, 0))) { GenerateIndices(pIndices, uWidth, uWidth); m_pIndexBuffer->Unlock(); } ZeroMemory(&m_d3dMaterial, sizeof(D3DMATERIAL9)); m_d3dMaterial.Ambient = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f); m_d3dMaterial.Diffuse = D3DXCOLOR(0.8f, 0.8f, 0.8f, 1.0f); m_d3dMaterial.Specular = D3DXCOLOR(0.3f, 0.3f, 0.3f, 1.0f); m_d3dMaterial.Emissive = D3DXCOLOR(0.0f, 0.0f, 0.0f, 1.0f); m_d3dMaterial.Power = 0.0f; }
//----------------------------------------------------------------------------- // Name: ~CParticleSystem() // Desc: //----------------------------------------------------------------------------- ParticleSystem::~ParticleSystem() { InvalidateDeviceObjects(); while( m_pFreeList ) { Particle *pParticle = m_pFreeList; m_pFreeList = pParticle->m_pNext; delete pParticle; } m_pFreeList = NULL; }
//----------------------------------------------------------------------------- // Name: // Desc: //----------------------------------------------------------------------------- HRESULT CD3DMesh::Destroy() { InvalidateDeviceObjects(); for( UINT i=0; i<m_dwNumMaterials; i++ ) SAFE_RELEASE( m_pTextures[i] ); SAFE_DELETE_ARRAY( m_pTextures ); SAFE_DELETE_ARRAY( m_pMaterials ); SAFE_RELEASE( m_pSysMemMesh ); m_dwNumMaterials = 0L; return S_OK; }
void NavigationLine::SetVisible(bool visible) { if (m_visible != visible) { m_visible = visible; if (m_visible) { m_needsUpdate = true; CreateDeviceObjects(); } else InvalidateDeviceObjects(); } }
//----------------------------------------------------------------------------- // Name: ~CParticleSystem() // Desc: //----------------------------------------------------------------------------- CParticleSystem::~CParticleSystem() { InvalidateDeviceObjects(); while( m_pPlanes ) // Repeat till null... { Plane *pPlane = m_pPlanes; // Hold onto the first one m_pPlanes = pPlane->m_pNext; // Move down to the next one delete pPlane; // Delete the one we're holding } Particle* pParticle = 0; while( m_pActiveList ) { pParticle = m_pActiveList; m_pActiveList = pParticle->m_pNext; delete pParticle; } m_pActiveList = NULL; while( m_pFreeList ) { Particle *pParticle = m_pFreeList; m_pFreeList = pParticle->m_pNext; delete pParticle; } m_pFreeList = NULL; if( m_chTexFile != NULL ) { delete [] m_chTexFile; m_chTexFile = NULL; } if( m_ptexParticle != NULL ) m_ptexParticle->Release(); }
HRESULT CDirect3D::RestoreDeviceObjects(void) { unsigned int vertexbuffersize = sizeof(TLVERTEX) * 4; preProcess = false; #if C_D3DSHADERS if(psActive) { // Set up pixel shaders LoadPixelShader(); if(psEffect && psEffect->hasPreprocess()) { #if LOG_D3D LOG_MSG("D3D:Pixel shader preprocess active"); #endif preProcess = true; vertexbuffersize = sizeof(TLVERTEX) * 8; } } #endif // Initialize vertex pD3DDevice9->SetFVF(D3DFVF_TLVERTEX); // Create vertex buffer if(FAILED(pD3DDevice9->CreateVertexBuffer(vertexbuffersize, D3DUSAGE_WRITEONLY, D3DFVF_TLVERTEX, D3DPOOL_MANAGED, &vertexBuffer, NULL))) { LOG_MSG("D3D:Failed to create Vertex Buffer"); return E_FAIL; } // Lock vertex buffer and set vertices CreateVertex(); pD3DDevice9->SetStreamSource(0, vertexBuffer, 0, sizeof(TLVERTEX)); // Turn off culling pD3DDevice9->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE); // Turn off D3D lighting pD3DDevice9->SetRenderState(D3DRS_LIGHTING, false); // Turn off the zbuffer pD3DDevice9->SetRenderState(D3DRS_ZENABLE, false); CreateDisplayTexture(); SetupSceneScaled(); if(!psActive) { pD3DDevice9->SetTexture(0, lpTexture); // Disable Shaders pD3DDevice9->SetVertexShader(0); pD3DDevice9->SetPixelShader(0); pD3DDevice9->SetTransform(D3DTS_PROJECTION, &m_matProj); pD3DDevice9->SetTransform(D3DTS_VIEW, &m_matView); pD3DDevice9->SetTransform(D3DTS_WORLD, &m_matWorld); } #if C_D3DSHADERS else if(psEffect) { if(preProcess) { // Projection is (0,0,0) -> (1,1,1) D3DXMatrixOrthoOffCenterLH(&m_matPreProj, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f); // Align texels with pixels D3DXMatrixTranslation(&m_matPreView, -0.5f/dwTexWidth, 0.5f/dwTexHeight, 0.0f); // Identity for world D3DXMatrixIdentity(&m_matPreWorld); } else if(FAILED(psEffect->SetMatrices(m_matProj, m_matView, m_matWorld))) { LOG_MSG("D3D:Set matrices failed."); InvalidateDeviceObjects(); return E_FAIL; } } #endif return S_OK; }
void ImGuiDX9::Shutdown() { InvalidateDeviceObjects(); ImGui::DestroyContext(); }
CWndCredit::~CWndCredit() { InvalidateDeviceObjects(); DeleteDeviceObjects(); }
NavigationLine::~NavigationLine() { InvalidateDeviceObjects(); }
HRESULT CWndGHTeleporter::DeleteDeviceObjects() { CWndNeuz::DeleteDeviceObjects(); return InvalidateDeviceObjects(); }
void Shutdown() { InvalidateDeviceObjects(); ImGui::Shutdown(); glDeleteProgram(g_ShaderHandle); }
//----------------------------------------------------------------------------- // Name: Initialize3DEnvironment() // Desc: Usually this function is not overridden. Here's what this function does: // - Sets the windowed flag to be either windowed or fullscreen // - Sets parameters for z-buffer depth and back buffer // - Creates the D3D device // - Sets the window position (if windowed, that is) // - Makes some determinations as to the abilites of the driver (HAL, etc) // - Sets up some cursor stuff // - Calls InitDeviceObjects() // - Calls RestoreDeviceObjects() // - If all goes well, m_bActive is set to TRUE, and the function returns // - Otherwise, initialization is reattempted using the reference device //----------------------------------------------------------------------------- HRESULT CMyD3DApplication::Initialize3DEnvironment() { HRESULT hr; D3DAdapterInfo* pAdapterInfo = m_d3dSettings.PAdapterInfo(); D3DDeviceInfo* pDeviceInfo = m_d3dSettings.PDeviceInfo(); m_bWindowed = m_d3dSettings.IsWindowed; // Prepare window for possible windowed/fullscreen change AdjustWindowForChange(); // Set up the presentation parameters BuildPresentParamsFromSettings(); if( pDeviceInfo->Caps.PrimitiveMiscCaps & D3DPMISCCAPS_NULLREFERENCE ) { // Warn user about null ref device that can't render anything DisplayErrorMsg( D3DAPPERR_NULLREFDEVICE, 0 ); } DWORD behaviorFlags; if (m_d3dSettings.GetVertexProcessingType() == SOFTWARE_VP) behaviorFlags = D3DCREATE_SOFTWARE_VERTEXPROCESSING; else if (m_d3dSettings.GetVertexProcessingType() == MIXED_VP) behaviorFlags = D3DCREATE_MIXED_VERTEXPROCESSING; else if (m_d3dSettings.GetVertexProcessingType() == HARDWARE_VP) behaviorFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING; else if (m_d3dSettings.GetVertexProcessingType() == PURE_HARDWARE_VP) behaviorFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING | D3DCREATE_PUREDEVICE; else behaviorFlags = 0; // TODO: throw exception // Add multithreaded flag if requested by app if( m_bCreateMultithreadDevice ) behaviorFlags |= D3DCREATE_MULTITHREADED; // Create the device hr = m_pD3D->CreateDevice( m_d3dSettings.AdapterOrdinal(), pDeviceInfo->DevType, m_hWndFocus, behaviorFlags, &m_d3dpp, &m_pd3dDevice ); if( SUCCEEDED(hr) ) { // When moving from fullscreen to windowed mode, it is important to // adjust the window size after recreating the device rather than // beforehand to ensure that you get the window size you want. For // example, when switching from 640x480 fullscreen to windowed with // a 1000x600 window on a 1024x768 desktop, it is impossible to set // the window size to 1000x600 until after the display mode has // changed to 1024x768, because windows cannot be larger than the // desktop. if( m_bWindowed ) { SetWindowPos( m_hWnd, HWND_NOTOPMOST, m_rcWindowBounds.left, m_rcWindowBounds.top, ( m_rcWindowBounds.right - m_rcWindowBounds.left ), ( m_rcWindowBounds.bottom - m_rcWindowBounds.top ), SWP_HIDEWINDOW ); } // Store device Caps m_pd3dDevice->GetDeviceCaps( &m_d3dCaps ); m_dwCreateFlags = behaviorFlags; // Store device description if( pDeviceInfo->DevType == D3DDEVTYPE_REF ) lstrcpy( m_strDeviceStats, TEXT("REF") ); else if( pDeviceInfo->DevType == D3DDEVTYPE_HAL ) lstrcpy( m_strDeviceStats, TEXT("HAL") ); else if( pDeviceInfo->DevType == D3DDEVTYPE_SW ) lstrcpy( m_strDeviceStats, TEXT("SW") ); if( behaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING && behaviorFlags & D3DCREATE_PUREDEVICE ) { if( pDeviceInfo->DevType == D3DDEVTYPE_HAL ) lstrcat( m_strDeviceStats, TEXT(" (pure hw vp)") ); else lstrcat( m_strDeviceStats, TEXT(" (simulated pure hw vp)") ); } else if( behaviorFlags & D3DCREATE_HARDWARE_VERTEXPROCESSING ) { if( pDeviceInfo->DevType == D3DDEVTYPE_HAL ) lstrcat( m_strDeviceStats, TEXT(" (hw vp)") ); else lstrcat( m_strDeviceStats, TEXT(" (simulated hw vp)") ); } else if( behaviorFlags & D3DCREATE_MIXED_VERTEXPROCESSING ) { if( pDeviceInfo->DevType == D3DDEVTYPE_HAL ) lstrcat( m_strDeviceStats, TEXT(" (mixed vp)") ); else lstrcat( m_strDeviceStats, TEXT(" (simulated mixed vp)") ); } else if( behaviorFlags & D3DCREATE_SOFTWARE_VERTEXPROCESSING ) { lstrcat( m_strDeviceStats, TEXT(" (sw vp)") ); } if( pDeviceInfo->DevType == D3DDEVTYPE_HAL ) { // Be sure not to overflow m_strDeviceStats when appending the adapter // description, since it can be long. Note that the adapter description // is initially CHAR and must be converted to TCHAR. lstrcat( m_strDeviceStats, TEXT(": ") ); const int cchDesc = sizeof(pAdapterInfo->AdapterIdentifier.Description); TCHAR szDescription[cchDesc]; DXUtil_ConvertAnsiStringToGenericCch( szDescription, pAdapterInfo->AdapterIdentifier.Description, cchDesc ); int maxAppend = sizeof(m_strDeviceStats) / sizeof(TCHAR) - lstrlen( m_strDeviceStats ) - 1; _tcsncat( m_strDeviceStats, szDescription, maxAppend ); } // Store render target surface desc LPDIRECT3DSURFACE9 pBackBuffer = NULL; m_pd3dDevice->GetBackBuffer( 0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer ); pBackBuffer->GetDesc( &m_d3dsdBackBuffer ); pBackBuffer->Release(); // Set up the fullscreen cursor if( m_bShowCursorWhenFullscreen && !m_bWindowed ) { HCURSOR hCursor; #ifdef _WIN64 hCursor = (HCURSOR)GetClassLongPtr( m_hWnd, GCLP_HCURSOR ); #else hCursor = (HCURSOR)ULongToHandle( GetClassLong( m_hWnd, GCL_HCURSOR ) ); #endif D3DUtil_SetDeviceCursor( m_pd3dDevice, hCursor, true ); m_pd3dDevice->ShowCursor( true ); } // Confine cursor to fullscreen window if( m_bClipCursorWhenFullscreen ) { if (!m_bWindowed ) { RECT rcWindow; GetWindowRect( m_hWnd, &rcWindow ); ClipCursor( &rcWindow ); } else { ClipCursor( NULL ); } } // Initialize the app's device-dependent objects hr = InitDeviceObjects(); if( FAILED(hr) ) { DeleteDeviceObjects(); } else { m_bDeviceObjectsInited = true; hr = RestoreDeviceObjects(); if( FAILED(hr) ) { InvalidateDeviceObjects(); } else { m_bDeviceObjectsRestored = true; return S_OK; } } // Cleanup before we try again Cleanup3DEnvironment(); } // If that failed, fall back to the reference rasterizer if( hr != D3DAPPERR_MEDIANOTFOUND && hr != HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND ) && pDeviceInfo->DevType == D3DDEVTYPE_HAL ) { if (FindBestWindowedMode(false, true)) { m_bWindowed = true; AdjustWindowForChange(); // Make sure main window isn't topmost, so error message is visible SetWindowPos( m_hWnd, HWND_NOTOPMOST, m_rcWindowBounds.left, m_rcWindowBounds.top, ( m_rcWindowBounds.right - m_rcWindowBounds.left ), ( m_rcWindowBounds.bottom - m_rcWindowBounds.top ), SWP_SHOWWINDOW ); // Let the user know we are switching from HAL to the reference rasterizer DisplayErrorMsg( hr, MSGWARN_SWITCHEDTOREF ); hr = Initialize3DEnvironment(); } } return hr; }
void Shutdown() { InvalidateDeviceObjects(); ImGui::Shutdown(); }
HRESULT CCollectingWnd::DeleteDeviceObjects() { CWndBase::DeleteDeviceObjects(); return InvalidateDeviceObjects(); }
//----------------------------------------------------------------------------- // Name: MsgProc() // Desc: Message proc function to handle key and menu input //----------------------------------------------------------------------------- LRESULT CMyD3DApplication::MsgProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam ) { // Pass mouse messages to the ArcBall so it can build internal matrices m_ArcBall.HandleMouseMessages( hWnd, uMsg, wParam, lParam ); // Trap the context menu if( WM_CONTEXTMENU==uMsg ) return 0; if( uMsg == WM_COMMAND ) { // Toggle mesh optimization if( LOWORD(wParam) == IDM_SHOWNONOPTIMIZEDMESH ) { m_bShowVertexCacheOptimized = FALSE; m_bShowStripReordered = FALSE; CheckMenuItem( GetMenu(hWnd), IDM_SHOWNONOPTIMIZEDMESH, MF_CHECKED ); CheckMenuItem( GetMenu(hWnd), IDM_SHOWVCACHEOPTIMIZED, MF_UNCHECKED ); CheckMenuItem( GetMenu(hWnd), IDM_SHOWSTRIPREORDERED, MF_UNCHECKED ); } else if( LOWORD(wParam) == IDM_SHOWVCACHEOPTIMIZED ) { m_bShowVertexCacheOptimized = TRUE; m_bShowStripReordered = FALSE; CheckMenuItem( GetMenu(hWnd), IDM_SHOWNONOPTIMIZEDMESH, MF_UNCHECKED ); CheckMenuItem( GetMenu(hWnd), IDM_SHOWVCACHEOPTIMIZED, MF_CHECKED ); CheckMenuItem( GetMenu(hWnd), IDM_SHOWSTRIPREORDERED, MF_UNCHECKED ); } else if( LOWORD(wParam) == IDM_SHOWSTRIPREORDERED ) { m_bShowVertexCacheOptimized = FALSE; m_bShowStripReordered = TRUE; CheckMenuItem( GetMenu(hWnd), IDM_SHOWNONOPTIMIZEDMESH, MF_UNCHECKED ); CheckMenuItem( GetMenu(hWnd), IDM_SHOWVCACHEOPTIMIZED, MF_UNCHECKED ); CheckMenuItem( GetMenu(hWnd), IDM_SHOWSTRIPREORDERED, MF_CHECKED ); } // Toggle strips else if( LOWORD(wParam) == IDM_SHOWTRILIST ) { m_bShowStrips = FALSE; m_bShowSingleStrip = FALSE; CheckMenuItem( GetMenu(hWnd), IDM_SHOWTRILIST, MF_CHECKED ); CheckMenuItem( GetMenu(hWnd), IDM_SHOWONESTRIP, MF_UNCHECKED ); CheckMenuItem( GetMenu(hWnd), IDM_SHOWMANYSTRIPS, MF_UNCHECKED ); } else if( LOWORD(wParam) == IDM_SHOWONESTRIP ) { m_bShowStrips = FALSE; m_bShowSingleStrip = TRUE; CheckMenuItem( GetMenu(hWnd), IDM_SHOWTRILIST, MF_UNCHECKED ); CheckMenuItem( GetMenu(hWnd), IDM_SHOWONESTRIP, MF_CHECKED ); CheckMenuItem( GetMenu(hWnd), IDM_SHOWMANYSTRIPS, MF_UNCHECKED ); } else if( LOWORD(wParam) == IDM_SHOWMANYSTRIPS ) { m_bShowStrips = TRUE; m_bShowSingleStrip = FALSE; CheckMenuItem( GetMenu(hWnd), IDM_SHOWTRILIST, MF_UNCHECKED ); CheckMenuItem( GetMenu(hWnd), IDM_SHOWONESTRIP, MF_UNCHECKED ); CheckMenuItem( GetMenu(hWnd), IDM_SHOWMANYSTRIPS, MF_CHECKED ); } // Toggle vertex buffer mode else if( LOWORD(wParam) == IDM_DYNAMICVB ) { if (m_dwMemoryOptions == D3DXMESH_DYNAMIC) { m_dwMemoryOptions = D3DXMESH_MANAGED; CheckMenuItem( GetMenu(hWnd), IDM_DYNAMICVB, MF_UNCHECKED ); } else { m_dwMemoryOptions = D3DXMESH_DYNAMIC; CheckMenuItem( GetMenu(hWnd), IDM_DYNAMICVB, MF_CHECKED ); } // Destroy and recreate everything InvalidateDeviceObjects(); RestoreDeviceObjects(); } else if( LOWORD(wParam) == IDM_FORCE32BYTEVERTEX ) { m_bForce32ByteFVF = !m_bForce32ByteFVF; CheckMenuItem( GetMenu(hWnd), IDM_FORCE32BYTEVERTEX, m_bForce32ByteFVF ? MF_CHECKED : MF_UNCHECKED ); // Destroy and recreate everything InvalidateDeviceObjects(); DeleteDeviceObjects(); InitDeviceObjects(); RestoreDeviceObjects(); } // Handle the open file command else if( LOWORD(wParam) == IDM_OPENFILE ) { TCHAR g_strFilename[512] = _T(""); // Display the OpenFileName dialog. Then, try to load the specified file OPENFILENAME ofn = { sizeof(OPENFILENAME), NULL, NULL, _T(".X Files (.x)\0*.x\0\0"), NULL, 0, 1, m_strMeshFilename, 512, g_strFilename, 512, m_strInitialDir, _T("Open Mesh File"), OFN_FILEMUSTEXIST, 0, 1, NULL, 0, NULL, NULL }; if( TRUE == GetOpenFileName( &ofn ) ) { _tcscpy( m_strInitialDir, m_strMeshFilename ); TCHAR* pLastSlash = _tcsrchr( m_strInitialDir, _T('\\') ); if( pLastSlash ) *pLastSlash = 0; SetCurrentDirectory( m_strInitialDir ); // Destroy and recreate everything InvalidateDeviceObjects(); DeleteDeviceObjects(); InitDeviceObjects(); RestoreDeviceObjects(); } } else if ((LOWORD(wParam) >= ID_OPTIONS_DISPLAY1) && (LOWORD(wParam) <= ID_OPTIONS_DISPLAY36)) { // uncheck old item CheckMenuItem( GetMenu(hWnd), ID_OPTIONS_DISPLAY1 + (m_cObjectsPerSide-1), MF_UNCHECKED ); // calc new item m_cObjectsPerSide = LOWORD(wParam) - ID_OPTIONS_DISPLAY1 + 1; // check new item CheckMenuItem( GetMenu(hWnd), ID_OPTIONS_DISPLAY1 + (m_cObjectsPerSide-1), MF_CHECKED ); } } return CD3DApplication::MsgProc( hWnd, uMsg, wParam, lParam ); }
void CParticles::Destroy( void ) { InvalidateDeviceObjects(); SAFE_RELEASE( m_pParticleTexture ); SAFE_DELETE_ARRAY( m_pPool ); }
//----------------------------------------------------------------------------- // Name: ~CD3DFont() // Desc: Font class destructor //----------------------------------------------------------------------------- CD3DFont::~CD3DFont() { InvalidateDeviceObjects(); DeleteDeviceObjects(); }
HRESULT CDirect3D::Resize3DEnvironment(void) { // Release all vidmem objects HRESULT hr; #if LOG_D3D LOG_MSG("D3D:Resize3DEnvironment() called"); #endif if(FAILED(hr=InvalidateDeviceObjects())) { LOG_MSG("D3D:Failed to invalidate objects"); return hr; } // Reset the device reset_device: Bitu i = 20; // Don't bother too much, when device is already lost if(deviceLost) i = 5; deviceLost = false; if(FAILED(hr=pD3DDevice9->Reset(&d3dpp))) { if(hr==D3DERR_DEVICELOST) { while((hr=pD3DDevice9->TestCooperativeLevel()) != D3DERR_DEVICENOTRESET) { if(hr==D3DERR_DRIVERINTERNALERROR) { LOG_MSG("D3D:Driver internal error when resetting device!"); return hr; } #if LOG_D3D LOG_MSG("D3D:Wait for D3D device to become available..."); #endif Sleep(50); i--; if(i == 0) { deviceLost = true; #if LOG_D3D LOG_MSG("D3D:Giving up on D3D wait..."); #endif // Return ok or dosbox will quit, we'll try to reset the device later return S_OK; } } #if LOG_D3D LOG_MSG("D3D:Performing another reset..."); #endif goto reset_device; } else { LOG_MSG("D3D:Failed to reset device!"); return hr; } } backbuffer_clear_countdown = 2; if (d3dpp.BackBufferCount == 2) backbuffer_clear_countdown++; #if 0 // Clear all backbuffers pD3DDevice9->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0); pD3DDevice9->Present(NULL, NULL, NULL, NULL); pD3DDevice9->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0); if(d3dpp.BackBufferCount == 2) { pD3DDevice9->Present(NULL, NULL, NULL, NULL); pD3DDevice9->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, 0), 1.0f, 0); } #endif #if LOG_D3D LOG_MSG("D3D:Mode: %dx%d (x %.2fx%.2f) --> scaled size: %dx%d", dwWidth, dwHeight, (float)dwScaledWidth/dwWidth, (float)dwScaledHeight/dwHeight, dwScaledWidth, dwScaledHeight); #endif return RestoreDeviceObjects(); }
RenderHandler::~RenderHandler() { InvalidateDeviceObjects(); }
~ModelData() { InvalidateDeviceObjects(); }
RenderObj::~RenderObj() { InvalidateDeviceObjects(); }