// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/> // Copyright (C) 2010 Winch Gate Property Limited // // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU Affero General Public License as // published by the Free Software Foundation, either version 3 of the // License, or (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU Affero General Public License for more details. // // You should have received a copy of the GNU Affero General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // particle_dlg.cpp : implementation file // #include "std_afx.h" #include "object_viewer.h" #include "particle_dlg.h" #include "editable_range.h" #include "located_properties.h" #include "particle_system_edit.h" #include "skippable_message_box.h" #include "main_frame.h" // // TODO : remove these include when the test system will be removed #include "nel/3d/particle_system.h" #include "nel/3d/ps_force.h" #include "nel/3d/ps_emitter.h" #include "nel/3d/ps_particle.h" #include "nel/3d/ps_util.h" #include "nel/3d/ps_zone.h" #include "nel/3d/ps_color.h" #include "nel/3d/ps_float.h" #include "nel/3d/ps_int.h" #include "nel/3d/ps_plane_basis_maker.h" #include "nel/3d/particle_system_model.h" #include "nel/3d/particle_system_shape.h" #include "nel/3d/texture_file.h" #include "nel/3d/texture_grouped.h" #include "nel/3d/nelu.h" #include "nel/3d/font_manager.h" #include "nel/3d/font_generator.h" // #include "nel/misc/file.h" #include "start_stop_particle_system.h" // #include "save_options_dlg.h" #include "create_file_dlg.h" using namespace NL3D; //************************************************************************************************************************** CParticleDlg::CParticleDlg(class CObjectViewer* main, CWnd *pParent, CMainFrame* mainFrame, CAnimationDlg *animDLG) : CDialog(CParticleDlg::IDD, pParent), MainFrame(mainFrame), CurrentRightPane(NULL), _ActiveNode(NULL), _ObjView(main), _EmptyBBox(true), _AutoUpdateBBox(false), _PW(NULL) { //{{AFX_DATA_INIT(CParticleDlg) // NOTE: the ClassWizard will add member initialization here //}}AFX_DATA_INIT nlverify (FontManager = main->getFontManager()); nlverify (FontGenerator = main->getFontGenerator()); NL3D::CParticleSystem::setSerializeIdentifierFlag(true); // serialize identifiers for edition ParticleTreeCtrl = new CParticleTreeCtrl(this); StartStopDlg = new CStartStopParticleSystem(this, animDLG); /** register us, so that our 'go' method will be called * this gives us a chance to display a bbox when needed */ _ObjView->registerMainLoopCallBack(this); } //************************************************************************************************************************** BOOL CParticleDlg::Create( UINT nIDTemplate, CWnd* pParentWnd /*= NULL*/ ) { if (!CDialog::Create(nIDTemplate, pParentWnd)) return FALSE; return TRUE; } //************************************************************************************************************************** void CParticleDlg::moveElement(const NLMISC::CMatrix &mat) { ParticleTreeCtrl->moveElement(mat); } //************************************************************************************************************************** NLMISC::CMatrix CParticleDlg::getElementMatrix(void) const { return ParticleTreeCtrl->getElementMatrix(); } //************************************************************************************************************************** CParticleDlg::~CParticleDlg() { _ObjView->removeMainLoopCallBack(this); delete ParticleTreeCtrl; delete CurrentRightPane; delete StartStopDlg; if (_PW) _PW->setModificationCallback(NULL); delete _PW; } //************************************************************************************************************************** void CParticleDlg::DoDataExchange(CDataExchange* pDX) { CDialog::DoDataExchange(pDX); //{{AFX_DATA_MAP(CParticleDlg) //}}AFX_DATA_MAP } BEGIN_MESSAGE_MAP(CParticleDlg, CDialog) //{{AFX_MSG_MAP(CParticleDlg) ON_WM_DESTROY() ON_WM_SIZE() ON_WM_SHOWWINDOW() ON_WM_CHAR() ON_COMMAND(IDM_CREATE_NEW_PS_WORKSPACE, OnCreateNewPsWorkspace) ON_COMMAND(IDM_LOAD_PS_WORKSPACE, OnLoadPSWorkspace) ON_COMMAND(IDM_SAVE_ALL_PS_WORKSPACE, OnSaveAllPsWorkspace) ON_COMMAND(IDM_SAVE_PS_WORKSPACE, OnSavePsWorkspace) ON_COMMAND(IDM_VIEW_PS_FILENAME, OnViewPsFilename) //}}AFX_MSG_MAP END_MESSAGE_MAP() //************************************************************************************************************************** void CParticleDlg::OnDestroy() { checkModifiedWorkSpace(); if (CurrentRightPane) { CurrentRightPane->DestroyWindow(); delete CurrentRightPane; CurrentRightPane = NULL; } setRegisterWindowState (this, REGKEY_OBJ_PARTICLE_DLG); CDialog::OnDestroy(); } //************************************************************************************************************************** BOOL CParticleDlg::OnInitDialog() { CDialog::OnInitDialog(); CRect r; GetWindowRect(&r); ParticleTreeCtrl->Create(WS_VISIBLE | WS_TABSTOP | WS_CHILD | WS_BORDER | TVS_HASBUTTONS | TVS_LINESATROOT | TVS_HASLINES | TVS_SHOWSELALWAYS | TVS_EDITLABELS | TVS_DISABLEDRAGDROP , r, this, 0x1005); ParticleTreeCtrl->init(); ParticleTreeCtrl->ShowWindow(SW_SHOW); StartStopDlg->Create(IDD_PARTICLE_SYSTEM_START_STOP, this); // create menu bar that allow to create / load a particle workspace CMenu menu; menu.LoadMenu(MAKEINTRESOURCE(IDR_PARTICLE_DLG_MENU)); this->SetMenu(&menu); menu.Detach(); updateMenu(); // _StatusBar.Create(this); UINT indicators = ID_PS_EDITOR_STATUS; _StatusBar.SetIndicators(&indicators, 1); _StatusBar.SetPaneInfo(0, ID_PS_EDITOR_STATUS, SBPS_NORMAL, computeStatusBarWidth()); RepositionBars(AFX_IDW_CONTROLBAR_FIRST, AFX_IDW_CONTROLBAR_LAST, ID_PS_EDITOR_STATUS); return TRUE; // return TRUE unless you set the focus to a control // EXCEPTION: OCX Property Pages should return FALSE } //************************************************************************************************************************** void CParticleDlg::setStatusBarText(CString &str) { _StatusBar.SetPaneText(0, str, TRUE); } //************************************************************************************************************************** void CParticleDlg::OnSize(UINT nType, int cx, int cy) { AFX_MANAGE_STATE(AfxGetStaticModuleState()); bool blocked = false; if (ParticleTreeCtrl->m_hWnd && this->m_hWnd) { CRect r = getTreeRect(cx, cy); ParticleTreeCtrl->MoveWindow(&r); if (CurrentRightPane) { CurrentRightPane->MoveWindow(r.right + 10, r.top, r.right + CurrRightPaneWidth + 10, r.top + CurrRightPaneHeight); } CDialog::OnSize(nType, cx, cy); if (IsWindow(_StatusBar)) { _StatusBar.SetPaneInfo(0, ID_PS_EDITOR_STATUS, SBPS_NORMAL, computeStatusBarWidth()); RepositionBars(AFX_IDW_CONTROLBAR_FIRST, AFX_IDW_CONTROLBAR_LAST, ID_PS_EDITOR_STATUS); } } } //************************************************************************************************************************** CRect CParticleDlg::getTreeRect(int cx, int cy) const { const uint ox = 0, oy = 10; if (CurrentRightPane) { CRect res(ox, oy, cx - CurrRightPaneWidth - 10, cy - 20); return res; } else { CRect res(ox, oy, cx - 10, cy - 20); return res; } } //************************************************************************************************************************** void CParticleDlg::setRightPane(CWnd *pane) { AFX_MANAGE_STATE(AfxGetStaticModuleState()); if (CurrentRightPane) { CurrentRightPane->DestroyWindow(); } delete CurrentRightPane; CurrentRightPane = pane; RECT r; if (pane) { pane->ShowWindow(SW_SHOW); CurrentRightPane->GetClientRect(&r); CurrRightPaneWidth = r.right; CurrRightPaneHeight = r.bottom; } GetClientRect(&r); this->SendMessage(WM_SIZE, SIZE_RESTORED, r.right + (r.bottom << 16)); GetWindowRect(&r); this->MoveWindow(&r); if (CurrentRightPane) { CurrentRightPane->Invalidate(); } this->Invalidate(); ParticleTreeCtrl->Invalidate(); } //************************************************************************************************************************** LRESULT CParticleDlg::WindowProc(UINT message, WPARAM wParam, LPARAM lParam) { if (message == WM_GETMINMAXINFO) { sint cx = 150, cy = 150; if (CurrentRightPane) { RECT r; CurrentRightPane->GetClientRect(&r); cx += CurrRightPaneWidth; if (cy < (CurrRightPaneHeight + 20) ) cy = CurrRightPaneHeight + 20; } MINMAXINFO *inf = (MINMAXINFO *) lParam; inf->ptMinTrackSize.x = cx; inf->ptMinTrackSize.y = cy; } return CDialog::WindowProc(message, wParam, lParam); } //************************************************************************************************************************** void CParticleDlg::OnShowWindow(BOOL bShow, UINT nStatus) { CDialog::OnShowWindow(bShow, nStatus); StartStopDlg->ShowWindow(bShow); } //************************************************************************************************************************** void CParticleDlg::goPostRender() { NL3D::CParticleSystem *currPS = _ActiveNode ? _ActiveNode->getPSPointer() : NULL; if (!currPS) return; if (StartStopDlg->isBBoxDisplayEnabled() && currPS) { NL3D::CNELU::Driver->setupModelMatrix(currPS->getSysMat()); if (_AutoUpdateBBox) { NLMISC::CAABBox currBBox; currPS->forceComputeBBox(currBBox); if (_EmptyBBox) { _EmptyBBox = false; _CurrBBox = currBBox; } else { NL3D::CPSUtil::displayBBox(NL3D::CNELU::Driver, _CurrBBox, CRGBA::Blue); _CurrBBox = NLMISC::CAABBox::computeAABBoxUnion(currBBox, _CurrBBox); } currPS->setPrecomputedBBox(_CurrBBox); } else { currPS->getLastComputedBBox(_CurrBBox); } NL3D::CPSUtil::displayBBox(NL3D::CNELU::Driver, _CurrBBox, currPS->getAutoComputeBBox() ? CRGBA::White : CRGBA::Red); } // copy user matrix into current fx nlassert(_ObjView); _ActiveNode->getPSModel()->setUserMatrix(_ObjView->getFXUserMatrix()); } //************************************************************************************************************************** void CParticleDlg::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) { if (nChar == (UINT) 'p' || nChar == (UINT) 'P' || nChar == (UINT) ' ') { // simulate a start / stop on the system StartStopDlg->toggle(); } CDialog::OnChar(nChar, nRepCnt, nFlags); } //************************************************************************************************************************** const NLMISC::CMatrix &CParticleDlg::getPSMatrix() const { if (!getActivePSM()) return NLMISC::CMatrix::Identity; return getActivePSM()->getMatrix(); } //************************************************************************************************************************** const NLMISC::CMatrix &CParticleDlg::getPSWorldMatrix() const { if (!getActivePSM()) return NLMISC::CMatrix::Identity; return getActivePSM()->getWorldMatrix(); } //************************************************************************************************************************** void CParticleDlg::setPSMatrix(const NLMISC::CMatrix &mat) { if (!getActivePSM()) return; getActivePSM()->setMatrix(mat); } //************************************************************************************************************************** void CParticleDlg::setPSWorldMatrix(const NLMISC::CMatrix &mat) { if (!getActivePSM()) return; CMatrix invParentMat = getActivePSM()->getMatrix() * getActivePSM()->getWorldMatrix().inverted(); invParentMat.normalize(CMatrix::XYZ); CMatrix newMat = invParentMat * mat; newMat.normalize(CMatrix::XYZ); getActivePSM()->setMatrix(newMat); } //************************************************************************************************************************** void CParticleDlg::stickPSToSkeleton(CParticleWorkspace::CNode *node, NL3D::CSkeletonModel *skel, uint bone, const std::string &parentSkelName, const std::string &parentBoneName) { if (!node) return; node->stickPSToSkeleton(skel, bone, parentSkelName, parentBoneName); if (skel) { if (_ObjView->getMainFrame()->MouseMoveType == CMainFrame::MoveFX) { _ObjView->getMainFrame()->OnEditMovecamera(); } _ObjView->getMainFrame()->ToolBar.Invalidate(); } } //************************************************************************************************************************** void CParticleDlg::unstickPSFromSkeleton(CParticleWorkspace::CNode *node) { if (!node) return; node->unstickPSFromSkeleton(); _ObjView->getMainFrame()->ToolBar.Invalidate(); } //************************************************************************************************************************** bool CParticleDlg::savePS(HWND parent, CParticleWorkspace::CNode &psNode, bool askToContinueWhenError) { return savePSAs(parent, psNode, psNode.getFullPath(), askToContinueWhenError); } //************************************************************************************************************************** bool CParticleDlg::savePSAs(HWND parent, CParticleWorkspace::CNode &psNode ,const std::string &fullPath, bool askToContinueWhenError) { nlassert(psNode.getPSPointer()); if (psNode.getResetAutoCountFlag() && psNode.getPSPointer()->getAutoCountFlag()) { MessageBox(psNode.getFilename().c_str() + getStrRsc(IDS_AUTO_COUNT_ERROR), getStrRsc(IDS_WARNING), MB_ICONEXCLAMATION); return false; } StartStopDlg->stop(); try { psNode.savePSAs(fullPath); psNode.setModified(false); setStatusBarText(CString(fullPath.c_str()) + " " + getStrRsc(IDS_SAVED)); } catch (NLMISC::Exception &e) { if (askToContinueWhenError) { int result = ::MessageBox(parent, CString(e.what()) + getStrRsc(IDS_CONTINUE_SAVING) , getStrRsc(IDS_ERROR), MB_ICONEXCLAMATION); return result == MB_OK; } else { ::MessageBox(parent, e.what(), getStrRsc(IDS_ERROR), MB_ICONEXCLAMATION); return false; } } return true; } //************************************************************************************************************************** bool CParticleDlg::loadPS(HWND parent, CParticleWorkspace::CNode &psNode, TLoadPSBehav behav) { bool loadingOK = true; try { if (!psNode.loadPS()) { loadingOK = false; switch(behav) { case Silent: return false; // no op case ReportError: ::MessageBox(parent, (LPCTSTR) (CString(psNode.getFilename().c_str()) + " : " + getStrRsc(IDS_COULDNT_INSTANCIATE_PS)), getStrRsc(IDS_ERROR), MB_OK|MB_ICONEXCLAMATION); return true; break; case ReportErrorSkippable: { CSkippableMessageBox mb(getStrRsc(IDS_ERROR), CString(psNode.getFilename().c_str()) + " : " + getStrRsc(IDS_COULDNT_INSTANCIATE_PS), CWnd::FromHandle(parent)); mb.DoModal(); return !mb.getBypassFlag(); } break; default: nlassert(0); break; } } else { setStatusBarText(CString(psNode.getFullPath().c_str()) + " " + getStrRsc(IDS_LOADED)); } } catch (NLMISC::Exception &e) { switch(behav) { case Silent: return false; // no op case ReportError: ::MessageBox(parent, e.what(), getStrRsc(IDS_ERROR), MB_OK|MB_ICONEXCLAMATION); return true; break; case ReportErrorSkippable: { CSkippableMessageBox mb(getStrRsc(IDS_ERROR), CString(e.what()), CWnd::FromHandle(parent)); mb.DoModal(); return !mb.getBypassFlag(); } break; default: nlassert(0); break; } } if (psNode.getPSPointer()->hasLoop()) { localizedMessageBox(parent, IDS_FX_HAS_LOOP, IDS_WARNING, MB_OK|MB_ICONEXCLAMATION); } return behav != Silent; } //************************************************************************************************************************** void CParticleDlg::checkModifiedWorkSpace() { if (_PW) { // see if current tree has been changed if (_PW->isModified()) { int result = localizedMessageBox(*this, IDS_PS_WORKSPACE_MODIFIED, IDS_PARTICLE_EDITOR, MB_YESNO|MB_ICONQUESTION); if (result == IDYES) { saveWorkspaceStructure(); } } if (_PW->isContentModified()) { saveWorkspaceContent(true); } } } //************************************************************************************************************************** void CParticleDlg::closeWorkspace() { setActiveNode(NULL); ParticleTreeCtrl->setActiveNode(NULL); ParticleTreeCtrl->reset(); delete _PW; _PW = NULL; } //************************************************************************************************************************** void CParticleDlg::OnCreateNewPsWorkspace() { checkModifiedWorkSpace(); // ask name of the new workspace to create CCreateFileDlg cf(getStrRsc(IDS_CHOOSE_WORKSPACE_NAME), "", "pws"); INT_PTR result = cf.DoModal(); if (result = IDOK) { if (cf.touchFile()) { CParticleWorkspace *newPW = new CParticleWorkspace; newPW->setModificationCallback(ParticleTreeCtrl); newPW->init(_ObjView, cf.getFullPath(), _ObjView->getFontManager(), _ObjView->getFontGenerator()); // save empty workspace try { newPW->save(); } catch(NLMISC::EStream &e) { MessageBox(e.what(), getStrRsc(IDS_ERROR), MB_ICONEXCLAMATION); } closeWorkspace(); _PW = newPW; ParticleTreeCtrl->buildTreeFromWorkSpace(*_PW); } } } //************************************************************************************************************************** void CParticleDlg::OnLoadPSWorkspace() { checkModifiedWorkSpace(); static const char BASED_CODE szFilter[] = "particle workspaces(*.pws)|*.pws||"; CFileDialog fd( TRUE, ".pws", "*.pws", 0, szFilter); INT_PTR result = fd.DoModal(); if (result != IDOK) return; loadWorkspace((LPCTSTR) fd.GetPathName()); } //************************************************************************************************************************** void CParticleDlg::loadWorkspace(const std::string &fullPath) { // Add to the path std::auto_ptr<CParticleWorkspace> newPW(new CParticleWorkspace); newPW->init(_ObjView, fullPath, _ObjView->getFontManager(), _ObjView->getFontGenerator()); newPW->setModificationCallback(ParticleTreeCtrl); // save empty workspace try { newPW->load(); setStatusBarText(CString(newPW->getFilename().c_str()) + " " + getStrRsc(IDS_LOADED)); } catch(NLMISC::EStream &e) { MessageBox(e.what(), getStrRsc(IDS_ERROR), MB_ICONEXCLAMATION); setStatusBarText(CString(e.what())); return; } // try to load each ps CParticleWorkspace::CNode *firstLoadedNode = NULL; bool displayErrorMsg = true; for(uint k = 0; k < newPW->getNumNode(); ++k) { displayErrorMsg = loadPS(*this, *newPW->getNode(k), displayErrorMsg ? ReportErrorSkippable : Silent); if (newPW->getNode(k)->isLoaded() && !firstLoadedNode) { firstLoadedNode = newPW->getNode(k); } } closeWorkspace(); _PW = newPW.release(); ParticleTreeCtrl->buildTreeFromWorkSpace(*_PW); setActiveNode(firstLoadedNode); ParticleTreeCtrl->setActiveNode(firstLoadedNode); ParticleTreeCtrl->expandRoot(); setStatusBarText(getStrRsc(IDS_READY)); } //************************************************************************************************************************** void CParticleDlg::OnSaveAllPsWorkspace() { saveWorkspaceStructure(); saveWorkspaceContent(false); } //************************************************************************************************************************** void CParticleDlg::OnSavePsWorkspace() { saveWorkspaceStructure(); saveWorkspaceContent(true); } //************************************************************************************************************************** void CParticleDlg::saveWorkspaceStructure() { nlassert(_PW); try { _PW->save(); setStatusBarText(CString(_PW->getFilename().c_str()) + " " + getStrRsc(IDS_SAVED)); } catch(NLMISC::EStream &e) { localizedMessageBox(*this, e.what(), IDS_ERROR, MB_ICONEXCLAMATION); setStatusBarText(CString(e.what())); } } //************************************************************************************************************************** void CParticleDlg::saveWorkspaceContent(bool askToSaveModifiedPS) { StartStopDlg->stop(); bool saveAll = !askToSaveModifiedPS; // check each component of the tree for(uint k = 0; k < _PW->getNumNode(); ++k) { if (_PW->getNode(k)->isModified()) { if (saveAll) { bool keepSaving = savePS(*this, *_PW->getNode(k), k != _PW->getNumNode()); if (!keepSaving) break; } else { // ask if the user wants to save the ps, or save all ps CString mess; mess = CString(_PW->getNode(k)->getFilename().c_str()) + getStrRsc(IDS_SAVE_MODIFIED_PS); CSaveOptionsDlg sop(getStrRsc(IDS_SAVE_FILE), mess, this); sop.DoModal(); bool saveThisFile = false; bool stop = false; switch(sop.getChoice()) { case CSaveOptionsDlg::Yes: saveThisFile = true; break; case CSaveOptionsDlg::No: saveThisFile = false; break; case CSaveOptionsDlg::SaveAll: saveAll = true; break; case CSaveOptionsDlg::Stop: stop = true; break; default: nlassert(0); } if (stop) break; if (saveAll || saveThisFile) { bool keepSaving = savePS(*this, *_PW->getNode(k), k != _PW->getNumNode()); if (!keepSaving) break; } } } } setStatusBarText(getStrRsc(IDS_READY)); } //************************************************************************************************************************** void CParticleDlg::setActiveNode(CParticleWorkspace::CNode *node) { if (node == _ActiveNode) return; _ActiveNode = node; StartStopDlg->setActiveNode(node); if(MainFrame->isMoveFX()) { if (node) { _ObjView->getMouseListener().setModelMatrix(node->getPSModel()->getMatrix()); } else { _ObjView->getMouseListener().setModelMatrix(NLMISC::CMatrix::Identity); } } else if(MainFrame->isMoveFXUserMatrix()) { if (node) { _ObjView->getMouseListener().setModelMatrix(node->getPSModel()->getUserMatrix()); } else { _ObjView->getMouseListener().setModelMatrix(NLMISC::CMatrix::Identity); } } } //************************************************************************************************************************** NL3D::CParticleSystemModel *CParticleDlg::getModelFromPS(NL3D::CParticleSystem *ps) const { if (!ps) return NULL; if (!_PW) return NULL; CParticleWorkspace::CNode *node = _PW->getNodeFromPS(ps); if (!node) return NULL; return node->getPSModel(); } //************************************************************************************************************************** uint CParticleDlg::computeStatusBarWidth() const { nlassert(ParticleTreeCtrl); CRect tcRect; ParticleTreeCtrl->GetClientRect(&tcRect); if (!CurrentRightPane) return (uint) std::max((sint) tcRect.Width() - 16, (sint) 0); return (uint) std::max((sint) tcRect.Width() - 4, (sint) 0); } //************************************************************************************************************************** void CParticleDlg::OnViewPsFilename() { ParticleTreeCtrl->setViewFilenameFlag(!ParticleTreeCtrl->getViewFilenameFlag()); updateMenu(); } //************************************************************************************************************************** void CParticleDlg::updateMenu() { if (!ParticleTreeCtrl) return; CMenu *menu = GetMenu(); if (!menu) return; // update the view menu menu->CheckMenuItem(IDM_VIEW_PS_FILENAME, MF_BYCOMMAND|(ParticleTreeCtrl->getViewFilenameFlag() ? MF_CHECKED : 0)); }