// 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/>. #include "std_afx.h" #include "object_viewer.h" #include "main_frame.h" #include "snapshot_tool_dlg.h" #include "choose_name.h" #include "object_viewer.h" // #include "nel/misc/path.h" #include "nel/misc/algo.h" #include "nel/misc/file.h" // #include "nel/3d/u_scene.h" #include "nel/3d/u_driver.h" // #include "nel/3d/driver.h" #include "nel/3d/driver_user.h" #include "nel/3d/shape_bank.h" #include "nel/3d/camera.h" #include "nel/3d/texture_multi_file.h" #include "nel/3d/mesh_base.h" #include "nel/3d/particle_system.h" #include "nel/3d/particle_system_shape.h" #include "nel/3d/particle_system_model.h" #define NEL_OV_SNAPSHOT_TOOL_REGKEY "Software\\Nevrax\\nel\\object_viewer\\snapshot_dlg" using namespace NLMISC; using namespace NL3D; ///////////////////////////////////////////////////////////////////////////// // CSnapshotToolDlg dialog //**************************************************************************************** CSnapshotToolDlg::CSnapshotToolDlg(CObjectViewer *ov, CWnd* pParent /*=NULL*/) : CDialog(CSnapshotToolDlg::IDD, pParent) { nlassert(ov); _ObjectViewer = ov; //{{AFX_DATA_INIT(CSnapshotToolDlg) m_OutputPath = _T(""); m_InputPath = _T(""); m_RecurseSubFolder = FALSE; m_OutputHeight = 100; m_OutputWidth = 160; m_Format = -1; m_OutputPathOption = -1; m_DumpTextureSets = FALSE; m_ViewBack = FALSE; m_ViewBottom = FALSE; m_ViewFront = FALSE; m_ViewLeft = FALSE; m_ViewRight = FALSE; m_ViewTop = FALSE; m_PostFixViewName = FALSE; //}}AFX_DATA_INIT } //**************************************************************************************** CSnapshotToolDlg::~CSnapshotToolDlg() { } //**************************************************************************************** void CSnapshotToolDlg::DoDataExchange(CDataExchange* pDX) { CDialog::DoDataExchange(pDX); //{{AFX_DATA_MAP(CSnapshotToolDlg) DDX_Control(pDX, IDC_LOG, m_Log); DDX_Control(pDX, IDC_FILTERS, m_Filters); DDX_Text(pDX, IDC_OUTPUT_PATH, m_OutputPath); DDX_Text(pDX, IDC_INPUT_PATH, m_InputPath); DDX_Check(pDX, IDC_RECURSE_SUBFOLDER, m_RecurseSubFolder); DDX_Text(pDX, IDC_HEIGHT, m_OutputHeight); DDV_MinMaxUInt(pDX, m_OutputHeight, 1, 1024); DDX_Text(pDX, IDC_WIDTH, m_OutputWidth); DDV_MinMaxUInt(pDX, m_OutputWidth, 1, 1024); DDX_CBIndex(pDX, IDC_FORMAT, m_Format); DDX_CBIndex(pDX, IDC_OUTPUTPATH_OPTION, m_OutputPathOption); DDX_Check(pDX, IDC_DUMP_TEXTURE_SETS, m_DumpTextureSets); DDX_Check(pDX, IDC_VIEW_BACK, m_ViewBack); DDX_Check(pDX, IDC_VIEW_BOTTOM, m_ViewBottom); DDX_Check(pDX, IDC_VIEW_FRONT, m_ViewFront); DDX_Check(pDX, IDC_VIEW_LEFT, m_ViewLeft); DDX_Check(pDX, IDC_VIEW_RIGHT, m_ViewRight); DDX_Check(pDX, IDC_VIEW_TOP, m_ViewTop); DDX_Check(pDX, IDC_POSTFIX_VIEWNAME, m_PostFixViewName); //}}AFX_DATA_MAP } //**************************************************************************************** void CSnapshotToolDlg::stringFromRegistry(HKEY hKey, const char *name, CString &dest, const CString &defaultStr) { DWORD type; DWORD size; LONG result = RegQueryValueEx(hKey, name, NULL, &type, NULL, &size); if (type != REG_SZ || result != ERROR_SUCCESS || size == 0) { dest = defaultStr; return; } std::string tmpDest; tmpDest.resize(size); result = RegQueryValueEx(hKey, name, NULL, &type, (unsigned char *) &tmpDest[0], &size); if (result != ERROR_SUCCESS) { dest = defaultStr; return; } dest = tmpDest.c_str(); } //**************************************************************************************** template <class T, class U> void integralTypeFromRegistry(HKEY hKey, const char *name, T &dest, const U &defaultValue) { if (hKey == 0) { dest = defaultValue; return; } DWORD type; DWORD size; LONG result = RegQueryValueEx(hKey, name, NULL, &type, NULL, &size); if (type != REG_DWORD || result != ERROR_SUCCESS || size == 0) { dest = (T) defaultValue; return; } DWORD value; result = RegQueryValueEx(hKey, name, NULL, &type, LPBYTE(&value), &size); if (result != ERROR_SUCCESS) { dest = defaultValue; return; } dest = (T) value; } //**************************************************************************************** void CSnapshotToolDlg::fromRegistry() { HKEY hKey = 0; RegOpenKeyEx(HKEY_CURRENT_USER, NEL_OV_SNAPSHOT_TOOL_REGKEY, 0, KEY_READ, &hKey); stringFromRegistry(hKey, "InputPath", m_InputPath, ""); stringFromRegistry(hKey, "OutputPath", m_OutputPath, ""); CString filters; stringFromRegistry(hKey, "Filters", filters, "*.shape"); std::string stdFilters((LPCTSTR) filters); std::vector<std::string> filterList; NLMISC::splitString(stdFilters, ",", filterList); m_Filters.ResetContent(); for (uint k = 0; k < filterList.size(); ++k) { m_Filters.AddString(filterList[k].c_str()); } integralTypeFromRegistry(hKey, "RecurseSubFolder", (int &) m_RecurseSubFolder, FALSE); integralTypeFromRegistry(hKey, "DumpTextureSets", (int &) m_DumpTextureSets, TRUE); integralTypeFromRegistry(hKey, "PostFixViewName", (int &) m_PostFixViewName, TRUE); integralTypeFromRegistry(hKey, "ViewBack", (int &) m_ViewBack, FALSE); integralTypeFromRegistry(hKey, "ViewBottom", (int &) m_ViewBottom, FALSE); integralTypeFromRegistry(hKey, "ViewFront", (int &) m_ViewFront, TRUE); integralTypeFromRegistry(hKey, "ViewLeft", (int &) m_ViewLeft, FALSE); integralTypeFromRegistry(hKey, "ViewRight", (int &) m_ViewRight, FALSE); integralTypeFromRegistry(hKey, "ViewTop", (int &) m_ViewTop, FALSE); integralTypeFromRegistry(hKey, "OutputWidth", m_OutputWidth, 128); integralTypeFromRegistry(hKey, "OutputHeight", m_OutputHeight, 128); integralTypeFromRegistry(hKey, "Format", m_Format, 0); integralTypeFromRegistry(hKey, "OutputPathOption", m_OutputPathOption, 1); UpdateData(FALSE); updateUIEnabledState(); } //**************************************************************************************** void CSnapshotToolDlg::toRegistry() { UpdateData(); HKEY hKey; if (RegCreateKey(HKEY_CURRENT_USER, NEL_OV_SNAPSHOT_TOOL_REGKEY, &hKey)==ERROR_SUCCESS) { RegSetValueEx(hKey, "InputPath", 0, REG_SZ, (unsigned char *) (LPCTSTR) m_InputPath, m_InputPath.GetLength() + 1); RegSetValueEx(hKey, "OutputPath", 0, REG_SZ, (unsigned char *) (LPCTSTR) m_OutputPath, m_OutputPath.GetLength() + 1); CString filters; for (uint k = 0; k < (uint) m_Filters.GetCount(); ++k) { if (k!=0) filters += ","; CString filter; m_Filters.GetText(k, filter); filters += filter; } RegSetValueEx(hKey, "Filters", 0, REG_SZ, (unsigned char *) (LPCTSTR) filters, filters.GetLength() + 1); DWORD recurseSubFolder = m_RecurseSubFolder; DWORD dumpTextureSets = m_DumpTextureSets; DWORD views [] = { m_ViewBack, m_ViewBottom, m_ViewFront, m_ViewLeft, m_ViewRight, m_ViewTop }; DWORD width = (DWORD) m_OutputWidth; DWORD height = (DWORD) m_OutputHeight; DWORD format = m_Format; DWORD outputPathOption = m_OutputPathOption; DWORD postFixViewName = m_PostFixViewName; integralTypeFromRegistry(hKey, "PostFixViewName", (int &) m_PostFixViewName, TRUE); RegSetValueEx(hKey, "ViewBack", 0, REG_DWORD, (const BYTE *) &m_ViewBack, sizeof(DWORD)); RegSetValueEx(hKey, "ViewBottom", 0, REG_DWORD, (const BYTE *) &m_ViewBottom, sizeof(DWORD)); RegSetValueEx(hKey, "ViewFront", 0, REG_DWORD, (const BYTE *) &m_ViewFront, sizeof(DWORD)); RegSetValueEx(hKey, "ViewLeft", 0, REG_DWORD, (const BYTE *) &m_ViewLeft, sizeof(DWORD)); RegSetValueEx(hKey, "ViewRight", 0, REG_DWORD, (const BYTE *) &m_ViewRight, sizeof(DWORD)); RegSetValueEx(hKey, "ViewTop", 0, REG_DWORD, (const BYTE *) &m_ViewTop, sizeof(DWORD)); RegSetValueEx(hKey, "RecurseSubFolder", 0, REG_DWORD, (const BYTE *) &recurseSubFolder, sizeof(DWORD)); RegSetValueEx(hKey, "DumpTextureSets", 0, REG_DWORD, (const BYTE *) &dumpTextureSets, sizeof(DWORD)); RegSetValueEx(hKey, "OutputWidth", 0, REG_DWORD, (const BYTE *) &width, sizeof(DWORD)); RegSetValueEx(hKey, "OutputHeight", 0, REG_DWORD, (const BYTE *) &height, sizeof(DWORD)); RegSetValueEx(hKey, "Format", 0, REG_DWORD, (const BYTE *) &format, sizeof(DWORD)); RegSetValueEx(hKey, "OutputPathOption", 0, REG_DWORD, (const BYTE *) &outputPathOption, sizeof(DWORD)); } } BEGIN_MESSAGE_MAP(CSnapshotToolDlg, CDialog) //{{AFX_MSG_MAP(CSnapshotToolDlg) ON_BN_CLICKED(IDC_BROWSE_INPUT_PATH, OnBrowseInputPath) ON_BN_CLICKED(IDC_BROWSE_OUTPUT_PATH, OnBrowseOutputPath) ON_BN_CLICKED(IDC_GO, OnGo) ON_BN_CLICKED(IDC_ADD_FILTER, OnAddFilter) ON_BN_CLICKED(IDC_REMOVE_FILTER, OnRemoveFilter) ON_BN_CLICKED(IDC_EDIT_FILTER, OnEditFilter) ON_WM_CLOSE() ON_EN_CHANGE(IDC_WIDTH, OnChangeWidth) ON_EN_KILLFOCUS(IDC_HEIGHT, OnKillfocusHeight) ON_EN_KILLFOCUS(IDC_WIDTH, OnKillfocusWidth) ON_CBN_SELCHANGE(IDC_OUTPUTPATH_OPTION, OnSelchangeOutputpathOption) ON_CBN_SELCHANGE(IDC_FORMAT, OnSelchangeFormat) ON_BN_CLICKED(IDC_CLOSE, OnCloseButton) ON_WM_TIMER() ON_BN_CLICKED(IDC_STOP, OnStopSnapshots) ON_BN_CLICKED(IDC_VIEW_FRONT, OnViewFront) ON_BN_CLICKED(IDC_VIEW_LEFT, OnViewLeft) ON_BN_CLICKED(IDC_VIEW_RIGHT, OnViewRight) ON_BN_CLICKED(IDC_VIEW_TOP, OnViewTop) ON_BN_CLICKED(IDC_VIEW_ALL, OnViewAll) ON_BN_CLICKED(IDC_VIEW_NONE, OnViewNone) ON_BN_CLICKED(IDC_POSTFIX_VIEWNAME, OnPostFixViewName) //}}AFX_MSG_MAP END_MESSAGE_MAP() ///////////////////////////////////////////////////////////////////////////// // CSnapshotToolDlg message handlers //**************************************************************************************** BOOL CSnapshotToolDlg::OnInitDialog() { CDialog::OnInitDialog(); fromRegistry(); SetTimer(1, 10, NULL); return TRUE; // return TRUE unless you set the focus to a control // EXCEPTION: OCX Property Pages should return FALSE } //**************************************************************************************** void CSnapshotToolDlg::OnClose() { toRegistry(); CDialog::OnClose(); } //**************************************************************************************** void CSnapshotToolDlg::OnBrowseInputPath() { browseFolder(getStrRsc(IDS_CHOOSE_SNAPSHOT_INPUT_PATH), m_InputPath, this->m_hWnd); UpdateData(FALSE); toRegistry(); } //**************************************************************************************** void CSnapshotToolDlg::OnBrowseOutputPath() { browseFolder(getStrRsc(IDS_CHOOSE_SNAPSHOT_OUTPUT_PATH), m_OutputPath, this->m_hWnd); UpdateData(FALSE); toRegistry(); } //**************************************************************************************** void CSnapshotToolDlg::OnAddFilter() { CChooseName cn("*.shape", this); if (cn.DoModal() == IDOK && !cn.m_Name.IsEmpty()) { m_Filters.AddString(cn.m_Name); } toRegistry(); } //**************************************************************************************** void CSnapshotToolDlg::OnRemoveFilter() { if (m_Filters.GetCurSel() != LB_ERR) { m_Filters.DeleteString(m_Filters.GetCurSel()); } } //**************************************************************************************** void CSnapshotToolDlg::OnEditFilter() { if (m_Filters.GetCurSel() != LB_ERR) { CString current; m_Filters.GetText(m_Filters.GetCurSel(), current); CChooseName cn((LPCTSTR) current, this); if (cn.DoModal() == IDOK && !cn.m_Name.IsEmpty()) { int curSel = m_Filters.GetCurSel(); m_Filters.DeleteString(m_Filters.GetCurSel()); m_Filters.InsertString(curSel, cn.m_Name); m_Filters.SetCurSel(curSel); } } toRegistry(); } //**************************************************************************************** uint CSnapshotToolDlg::getSelectedViewCount() { UpdateData(); return (m_ViewBack ? 1 : 0) + (m_ViewBottom ? 1 : 0) + (m_ViewFront ? 1 : 0) + (m_ViewLeft ? 1 : 0) + (m_ViewRight ? 1 : 0) + (m_ViewTop ? 1 : 0); } //**************************************************************************************** void CSnapshotToolDlg::updateUIEnabledState() { BOOL enabled = _FilteredFiles.empty() ? TRUE : FALSE; m_Filters.EnableWindow(enabled); GetDlgItem(IDC_INPUT_PATH)->EnableWindow(enabled); GetDlgItem(IDC_BROWSE_INPUT_PATH)->EnableWindow(enabled); GetDlgItem(IDC_OUTPUT_PATH)->EnableWindow(enabled && m_OutputPathOption == OutputPath_Custom); GetDlgItem(IDC_BROWSE_OUTPUT_PATH)->EnableWindow(enabled); GetDlgItem(IDC_RECURSE_SUBFOLDER)->EnableWindow(enabled); GetDlgItem(IDC_OUTPUTPATH_OPTION)->EnableWindow(enabled); GetDlgItem(IDC_FILTERS)->EnableWindow(enabled); GetDlgItem(IDC_ADD_FILTER)->EnableWindow(enabled); GetDlgItem(IDC_REMOVE_FILTER)->EnableWindow(enabled); GetDlgItem(IDC_EDIT_FILTER)->EnableWindow(enabled); GetDlgItem(IDC_WIDTH)->EnableWindow(enabled); GetDlgItem(IDC_HEIGHT)->EnableWindow(enabled); GetDlgItem(IDC_FORMAT)->EnableWindow(enabled); GetDlgItem(IDC_GO)->EnableWindow(enabled); GetDlgItem(IDC_DUMP_TEXTURE_SETS)->EnableWindow(enabled); GetDlgItem(IDC_STOP)->EnableWindow(!enabled); GetDlgItem(IDC_POSTFIX_VIEWNAME)->EnableWindow((enabled && getSelectedViewCount() == 1) ? TRUE : FALSE); //GetDlgItem(IDC_CLOSE)->EnaleWindow(enabled); } //**************************************************************************************** void CSnapshotToolDlg::OnGo() { UpdateData(); if (getSelectedViewCount() == 0) { MessageBox(getStrRsc(IDS_SNAPSHOT_NO_VIEW_SELECTED), getStrRsc(IDS_OBJECT_VIEWER), MB_ICONEXCLAMATION); return; } if (m_InputPath.IsEmpty()) { MessageBox(getStrRsc(IDS_SNAPSHOT_EMPTY_INPUT_PATH), getStrRsc(IDS_OBJECT_VIEWER), MB_ICONEXCLAMATION); return; } if (!NLMISC::CFile::isDirectory(LPCTSTR(m_InputPath))) { MessageBox(getStrRsc(IDS_SNAPSHOT_EMPTY_INPUT_PATH_NOT_FOUND), getStrRsc(IDS_OBJECT_VIEWER), MB_ICONEXCLAMATION); return; } if (m_OutputPathOption == OutputPath_Custom && m_OutputPath.IsEmpty()) { MessageBox(getStrRsc(IDS_SNAPSHOT_EMPTY_OUTPUT_PATH), getStrRsc(IDS_OBJECT_VIEWER), MB_ICONEXCLAMATION); return; } if (m_OutputPathOption == OutputPath_Custom && !NLMISC::CFile::isDirectory(LPCTSTR(m_OutputPath))) { if (MessageBox(getStrRsc(IDS_SNAPSHOT_CREATE_OUTPUT_DIRECTORY), getStrRsc(IDS_OBJECT_VIEWER), MB_OKCANCEL) != IDOK) { return; } if(!NLMISC::CFile::createDirectoryTree(LPCTSTR(m_OutputPath))) { MessageBox(getStrRsc(IDS_SNAPSHOT_OUTPUT_PATH_CREATION_FAILED), getStrRsc(IDS_OBJECT_VIEWER), MB_ICONEXCLAMATION); return; } } // make sure that the screen can contains the window client area RECT desktopSize; ::GetClientRect(::GetDesktopWindow(), &desktopSize); if (desktopSize.right < LONG(m_OutputWidth) || desktopSize.bottom < LONG(m_OutputHeight)) { MessageBox(getStrRsc(IDS_DESKTOP_TOO_SMALL_FOR_SNAPSHOT), getStrRsc(IDS_OBJECT_VIEWER), MB_ICONEXCLAMATION); return; } m_Log.ResetContent(); m_Log.AddString(getStrRsc(IDS_GETTING_PATH_CONTENT)); std::vector<std::string> files; CPath::getPathContent((LPCTSTR) m_InputPath, m_RecurseSubFolder == TRUE, false, true, files); if (files.empty()) { m_Log.AddString(getStrRsc(IDS_SNAPSHOT_NO_FILES_FOUND)); return; } _FilteredFiles.clear(); for (uint k = 0; k < files.size(); ++k) { for (uint l = 0; l < uint(m_Filters.GetCount()); ++l) { CString wildCard; m_Filters.GetText(l, wildCard); wildCard.MakeLower(); if (testWildCard(toLower(NLMISC::CFile::getFilename(files[k])).c_str(), (LPCTSTR) wildCard)) { _FilteredFiles.push_back(files[k]); break; } } } if (_FilteredFiles.empty()) { m_Log.AddString(getStrRsc(IDS_SNAPSHOT_NO_FILTER_MATCH_FOUND)); return; } m_Log.AddString(toString("%d", (int) _FilteredFiles.size()).c_str() + getStrRsc(IDS_SNAPSHOT_FILES_TO_PROCESS)); updateUIEnabledState(); } //**************************************************************************************** void CSnapshotToolDlg::OnChangeWidth() { // TODO: If this is a RICHEDIT control, the control will not // send this notification unless you override the CDialog::OnInitDialog() // function and call CRichEditCtrl().SetEventMask() // with the ENM_CHANGE flag ORed into the mask. // TODO: Add your control notification handler code here } //**************************************************************************************** void CSnapshotToolDlg::OnKillfocusHeight() { toRegistry(); } //**************************************************************************************** void CSnapshotToolDlg::OnKillfocusWidth() { toRegistry(); } //**************************************************************************************** void CSnapshotToolDlg::OnSelchangeOutputpathOption() { toRegistry(); updateUIEnabledState(); } //**************************************************************************************** void CSnapshotToolDlg::OnSelchangeFormat() { toRegistry(); } //**************************************************************************************** void CSnapshotToolDlg::OnCloseButton() { toRegistry(); SendMessage(WM_CLOSE); } //**************************************************************************************** void CSnapshotToolDlg::setCamFromView(uint view, CCamera *cam, const CAABBox &bbox) { static const CVector camBackDir[] = { -CVector::J, CVector::I, -CVector::I, CVector::K, -CVector::K, CVector::J }; const float viewDistScale = 3.f; CVector halfSize = bbox.getHalfSize(); if (view == SnapshotAngle_Top) // top { CMatrix camMat; camMat.setRot(CVector::I, -CVector::K, CVector::J); camMat.setPos(bbox.getCenter() + viewDistScale * CVector::K); cam->setMatrix(camMat); } else if (view == SnapshotAngle_Bottom) { CMatrix camMat; camMat.setRot(CVector::I, CVector::K, -CVector::J); camMat.setPos(bbox.getCenter() - viewDistScale * CVector::K); cam->setMatrix(camMat); } else { // standard lookat for other directions cam->lookAt(bbox.getCenter() + viewDistScale * maxof(halfSize.x, halfSize.y, halfSize.z) * camBackDir[view], bbox.getCenter()); } } //**************************************************************************************** std::string CSnapshotToolDlg::viewToString(uint view) { switch(view) { case SnapshotAngle_Front: return "front"; case SnapshotAngle_Right: return "right"; case SnapshotAngle_Left: return "left"; case SnapshotAngle_Top: return "top"; case SnapshotAngle_Bottom: return "bottom"; case SnapshotAngle_Back: return "back"; } nlassert(0); return ""; } //**************************************************************************************** void CSnapshotToolDlg::OnTimer(UINT_PTR nIDEvent) { if (_FilteredFiles.empty()) return; if (nIDEvent == 1) { // resize the window if needed HWND wnd = (HWND) NL3D::CNELU::Driver->getDisplay(); CScene scene(true /* small scene */); scene.initDefaultRoots(); scene.setDriver(CNELU::Driver); scene.initQuadGridClipManager(); NL3D::CViewport vp; vp.init(0.f, 0.f, 1.f, 1.f); scene.setViewport(vp); scene.enableLightingSystem(true); scene.setAmbientGlobal(CRGBA::White); CShapeBank sb; scene.setShapeBank(&sb); CCamera *cam= safe_cast<CCamera *>(scene.createModel(CameraId)); scene.setCam(cam); cam->setFrustum(0.1f, 0.1f, 0.1f, 5000.f); try { CShapeStream ss; m_Log.AddString(_FilteredFiles[0].c_str()); CIFile stream(_FilteredFiles[0]); ss.serial(stream); nlassert(ss.getShapePointer()); CAABBox bbox; ss.getShapePointer()->getAABBox(bbox); sb.add("shape", ss.getShapePointer()); CTransformShape *model = scene.createInstance("shape"); CMatrix initTM = model->getMatrix(); model->setTransformMode(CTransform::DirectMatrix); initTM.setPos(CVector::Null); model->setMatrix(initTM); CVector newBBoxCenter = initTM * bbox.getCenter(); CVector newBBoxHalfSize = initTM.mulVector(bbox.getHalfSize()); bbox.setCenter(newBBoxCenter); bbox.setHalfSize(newBBoxHalfSize); if (model) { CMeshBaseInstance *mbi = dynamic_cast<CMeshBaseInstance *>(model); uint textureSetCount = 1; CMeshBase *mb = dynamic_cast<CMeshBase *>((IShape *) model->Shape); CMesh *mesh = dynamic_cast<CMesh *>((IShape *) model->Shape); if (m_DumpTextureSets && mbi) { if (mb) { const uint numMat = mb->getNbMaterial(); // see which material are selectable for(uint k = 0; k < numMat; ++k) { CMaterial &mat = mb->getMaterial(k); for(uint l = 0; l < IDRV_MAT_MAXTEXTURES; ++l) { CTextureMultiFile *tmf = dynamic_cast<CTextureMultiFile *>(mat.getTexture(l)); if (tmf) { textureSetCount = std::max(textureSetCount, (uint) tmf->getNumFileName()); } } } } } // for particle systems : simulate until half duration, then capture bbox CParticleSystemModel *psm = dynamic_cast<CParticleSystemModel *>(model); if (psm) { psm->forceInstanciate(); CParticleSystem *ps = psm->getPS(); if (ps) { float duration = ps->evalDuration(); float deltaT = .5f * ps->getTimeTheshold(); for (float date = 0.f; date < duration * 0.5f; date += deltaT) { ps->setSysMat(&CMatrix::Identity); ps->step(CParticleSystem::Anim, deltaT, *safe_cast<CParticleSystemShape *>((IShape *) psm->Shape), *psm); } ps->computeBBox(bbox); } } cam->setTransformMode(ITransformable::DirectMatrix); BOOL views[] = { m_ViewFront, m_ViewRight, m_ViewLeft, m_ViewTop, m_ViewBottom, m_ViewBack }; for (uint viewIndex = 0; viewIndex < 6; ++viewIndex) { if (!views[viewIndex]) continue; setCamFromView(viewIndex, cam, bbox); for (uint textureSet = 0; textureSet < textureSetCount; ++textureSet) { if (mbi) { mbi->selectTextureSet(textureSet); } CNELU::Driver->clear2D(_ObjectViewer->getBackGroundColor()); CNELU::Driver->clearZBuffer(); scene.render(); NLMISC::CBitmap snapshot; CNELU::Driver->getBuffer(snapshot); if (snapshot.getWidth() == 0 || snapshot.getHeight() == 0) { m_Log.AddString(getStrRsc(IDS_SNAPSHOT_NO_CONTENT_RETRIEVED)); } else { snapshot.resample(m_OutputWidth, m_OutputHeight); size_t lastPoint = _FilteredFiles[0].find_last_of('.'); std::string outputFilename = _FilteredFiles[0].substr(0, lastPoint); if (textureSetCount > 1) { outputFilename += toString("_%u", (unsigned int) textureSet); } if (getSelectedViewCount() != 1 || m_PostFixViewName) { outputFilename += "_" + viewToString(viewIndex); } outputFilename += (m_Format == OutputFormat_Tga ? ".tga" : ".jpg"); switch(m_OutputPathOption) { case OutputPath_Custom: // custom output path outputFilename = LPCTSTR(m_OutputPath) + std::string("\\") + NLMISC::CFile::getFilename(outputFilename); break; case OutputPath_SameAsInput: // Input path outputFilename = LPCTSTR(m_InputPath) + std::string("\\") + NLMISC::CFile::getFilename(outputFilename); break; case OutputPath_CurrShapeDirectory: // current path // no op break; } COFile output(outputFilename); if (m_Format == OutputFormat_Tga) { snapshot.writeTGA(output); } else { snapshot.writeJPG(output); } } CNELU::Driver->swapBuffers(); } } scene.deleteInstance(model); } sb.reset(); } catch(std::exception &e) { nlwarning(e.what()); } _FilteredFiles.pop_front(); if (_FilteredFiles.empty()) { m_Log.AddString(getStrRsc(IDS_SNAPSHOT_FINISHED)); updateUIEnabledState(); } } CDialog::OnTimer(nIDEvent); } //**************************************************************************************** void CSnapshotToolDlg::OnStopSnapshots() { _FilteredFiles.clear(); updateUIEnabledState(); } //**************************************************************************************** void CSnapshotToolDlg::OnViewFront() { toRegistry(); updateUIEnabledState(); } //**************************************************************************************** void CSnapshotToolDlg::OnViewLeft() { toRegistry(); updateUIEnabledState(); } //**************************************************************************************** void CSnapshotToolDlg::OnViewRight() { toRegistry(); updateUIEnabledState(); } //**************************************************************************************** void CSnapshotToolDlg::OnViewTop() { toRegistry(); updateUIEnabledState(); } //**************************************************************************************** void CSnapshotToolDlg::OnViewAll() { m_ViewBack = TRUE; m_ViewBottom = TRUE; m_ViewFront = TRUE; m_ViewLeft = TRUE; m_ViewRight = TRUE; m_ViewTop = TRUE; UpdateData(FALSE); toRegistry(); updateUIEnabledState(); } //**************************************************************************************** void CSnapshotToolDlg::OnViewNone() { m_ViewBack = FALSE; m_ViewBottom = FALSE; m_ViewFront = FALSE; m_ViewLeft = FALSE; m_ViewRight = FALSE; m_ViewTop = FALSE; UpdateData(FALSE); toRegistry(); updateUIEnabledState(); } //**************************************************************************************** void CSnapshotToolDlg::OnPostFixViewName() { toRegistry(); }