void SceneHelper::CollectTextures(const DAVA::NMaterial *material, DAVA::TexturesMap &textures, TexturesEnumerateMode mode) { DAVA::uint32 texCount = material->GetTextureCount(); for(DAVA::uint32 t = 0; t < texCount; ++t) { DAVA::FilePath texturePath = material->GetTexturePath(material->GetTextureName(t)); if(!texturePath.IsEmpty() && SceneValidator::Instance()->IsPathCorrectForProject(texturePath)&&!NMaterial::IsRuntimeTexture(material->GetTextureName(t))) { if(mode == EXCLUDE_NULL) { DAVA::Texture *texture = material->GetTexture(t); if(texture && !texture->isRenderTarget) { const DAVA::FilePath & path = texture->texDescriptor->pathname; if(path != texturePath) { DAVA::Logger::Error("texture path: \"%s\"\n material (%s) path: \"%s\"\n", path.GetAbsolutePathname().c_str(), material->GetMaterialName().c_str(), texturePath.GetAbsolutePathname().c_str()); DVASSERT(path == texturePath); } textures[FILEPATH_MAP_KEY(path)] = texture; } } else if(mode == INCLUDE_NULL) { textures[FILEPATH_MAP_KEY(texturePath)] = material->GetTexture(t); } else { DVASSERT(0 && "Unknown enumeration mode"); } } } }
void CubeMapTextureBrowser::OnCreateCubemapClicked() { QString fileName = QtFileDialog::getSaveFileName(this, tr("Create Cubemap Texture"), ui->textRootPath->text(), tr("Tex File (*.tex)")); if(!fileName.isNull()) { CubemapEditorDialog dlg(this); FilePath fp = fileName.toStdString(); DAVA::FilePath rootPath = fp.GetDirectory(); dlg.InitForCreating(fp, rootPath); dlg.exec(); QString path = rootPath.GetAbsolutePathname().c_str(); ui->textRootPath->setText(path); int currentRow = ui->listTextures->currentRow(); ReloadTexturesFromUI(path); if(ui->listTextures->count() > 0 && currentRow < ui->listTextures->count()) { RestoreListSelection(currentRow); } } }
void SceneValidator::ValidateLandscapeTexture(Landscape *landscape, Landscape::eTextureLevel texLevel, Set<String> &errorsLog) { DAVA::FilePath landTexName = landscape->GetTextureName(texLevel); if(!IsTextureDescriptorPath(landTexName) && landTexName.GetAbsolutePathname().size() > 0) { landscape->SetTextureName(texLevel, TextureDescriptor::GetDescriptorPathname(landTexName)); } ValidateTexture(landscape->GetTexture(texLevel), landscape->GetTextureName(texLevel), Format("Landscape. TextureLevel %d", texLevel), errorsLog); }
void SceneHelper::CollectDescriptors(DAVA::Set<DAVA::FilePath> &descriptors, const DAVA::FilePath &pathname) { if(pathname.GetType() == FilePath::PATH_EMPTY) return; DVASSERT(pathname.IsEqualToExtension(TextureDescriptor::GetDescriptorExtension())); if(!pathname.IsEmpty() && SceneValidator::Instance()->IsPathCorrectForProject(pathname)) { descriptors.insert(pathname); } }
void SceneUtils::AddFile(const DAVA::FilePath &sourcePath) { String workingPathname = sourcePath.GetRelativePathname(dataSourceFolder); FilePath destinationPath = dataFolder + workingPathname; if(sourcePath != destinationPath) { DVASSERT(!sourcePath.IsEmpty()); DVASSERT(!destinationPath.IsEmpty()); filesForCopy[sourcePath] = destinationPath; } }
void FileListTest::RecursiveCopy(const DAVA::FilePath &src, const DAVA::FilePath &dst) { DVASSERT(src.IsDirectoryPathname() && dst.IsDirectoryPathname()); FileSystem::Instance()->CreateDirectory(dst, true); FileSystem::Instance()->CopyDirectory(src, dst); FileList fileList(src); for(int32 i = 0; i < fileList.GetCount(); ++i) { if(fileList.IsDirectory(i) && !fileList.IsNavigationDirectory(i)) { RecursiveCopy(fileList.GetPathname(i), dst + (fileList.GetFilename(i) + "/")); } } }
void CubemapEditorDialog::InitForCreating(DAVA::FilePath& textureDescriptorPath, DAVA::FilePath& root) { targetFile = textureDescriptorPath; editorMode = CubemapEditorDialog::eEditorModeCreating; rootPath = QString::fromStdString(root.GetAbsolutePathname()); ui->legend->setVisible(true); faceChanged = false; }
void UnpackHelpDoc() { DAVA::String editorVer =SettingsManager::GetValue(Settings::Internal_EditorVersion).AsString(); DAVA::FilePath docsPath = FilePath(ResourceEditor::DOCUMENTATION_PATH); if(editorVer != RESOURCE_EDITOR_VERSION || !docsPath.Exists()) { DAVA::Logger::Info("Unpacking Help..."); DAVA::ResourceArchive * helpRA = new DAVA::ResourceArchive(); if(helpRA->Open("~res:/Help.docs")) { DAVA::FileSystem::Instance()->DeleteDirectory(docsPath); DAVA::FileSystem::Instance()->CreateDirectory(docsPath, true); helpRA->UnpackToFolder(docsPath); } DAVA::SafeRelease(helpRA); } SettingsManager::SetValue(Settings::Internal_EditorVersion, VariantType(String(RESOURCE_EDITOR_VERSION))); }
void TextureBrowser::updateInfoConverted() { if(NULL != curTexture && NULL != curDescriptor) { char tmp[1024]; const char *formatStr = "Unknown"; int datasize = 0; int filesize = 0; QSize imgSize(0, 0); if(curDescriptor->compression[curTextureView].format != DAVA::FORMAT_INVALID) { DAVA::FilePath compressedTexturePath = DAVA::GPUFamilyDescriptor::CreatePathnameForGPU(curDescriptor, curTextureView); filesize = QFileInfo(compressedTexturePath.GetAbsolutePathname().c_str()).size(); formatStr = GlobalEnumMap<DAVA::PixelFormat>::Instance()->ToString(curDescriptor->compression[curTextureView].format); int w = curDescriptor->compression[curTextureView].compressToWidth; int h = curDescriptor->compression[curTextureView].compressToHeight; if(0 != w && 0 != h) { imgSize = QSize(w, h); } else { imgSize = QSize(curTexture->width, curTexture->height); } // get data size datasize = ImageTools::GetTexturePhysicalSize(curDescriptor, curTextureView); } sprintf(tmp, "Format\t: %s\nSize\t: %dx%d\nData size\t: %s\nFile size\t: %s", formatStr, imgSize.width(), imgSize.height(), SizeInBytesToString(datasize).c_str(), SizeInBytesToString(filesize).c_str()); ui->labelConvertedFormat->setText(tmp); } else { ui->labelConvertedFormat->setText(""); } }
void QtMainWindow::OpenLastProject() { if(CommandLineManager::Instance() && !CommandLineManager::Instance()->IsCommandLineModeEnabled()) { DAVA::FilePath projectPath = EditorSettings::Instance()->GetProjectPath(); if(projectPath.IsEmpty()) { projectPath = FilePath(ProjectManager::Instance()->ProjectOpenDialog().toStdString()); } if(projectPath.IsEmpty()) { QtLayer::Instance()->Quit(); } else { ProjectManager::Instance()->ProjectOpen(QString(projectPath.GetAbsolutePathname().c_str())); } } }
void CubemapEditorDialog::InitForEditing(DAVA::FilePath& textureDescriptorPath, DAVA::FilePath& root) { targetFile = textureDescriptorPath; editorMode = CubemapEditorDialog::eEditorModeEditing; rootPath = QString::fromStdString(root.GetAbsolutePathname()); LoadCubemap(targetFile.GetAbsolutePathname().c_str()); ui->buttonSave->setEnabled(false); ui->legend->setVisible(false); faceChanged = false; }
void CustomColorsSystem::SaveTexture(const DAVA::FilePath &filePath) { if(filePath.IsEmpty()) return; Sprite* customColorsSprite = drawSystem->GetCustomColorsProxy()->GetSprite(); Texture* customColorsTexture = customColorsSprite->GetTexture(); Image* image = customColorsTexture->CreateImageFromMemory(RenderState::RENDERSTATE_2D_BLEND); ImageSystem::Instance()->Save(filePath, image); SafeRelease(image); StoreSaveFileName(filePath); drawSystem->GetCustomColorsProxy()->ResetChanges(); }
bool CustomColorsSystem::LoadTexture( const DAVA::FilePath &filePath, bool createUndo /* = true */ ) { if(filePath.IsEmpty()) return false; Vector<Image*> images; ImageSystem::Instance()->Load(filePath, images); if(images.empty()) return false; Image* image = images.front(); if(image) { Texture* texture = Texture::CreateFromData(image->GetPixelFormat(), image->GetData(), image->GetWidth(), image->GetHeight(), false); Sprite* sprite = Sprite::CreateFromTexture(texture, 0, 0, texture->GetWidth(), texture->GetHeight()); if (createUndo) { StoreOriginalState(); } RenderManager::Instance()->SetRenderTarget(drawSystem->GetCustomColorsProxy()->GetSprite()); Sprite::DrawState drawState; sprite->Draw(&drawState); RenderManager::Instance()->RestoreRenderTarget(); AddRectToAccumulator(Rect(Vector2(0.f, 0.f), Vector2(texture->GetWidth(), texture->GetHeight()))); SafeRelease(sprite); SafeRelease(texture); for_each(images.begin(), images.end(), SafeRelease<Image>); if (createUndo) { ((SceneEditor2*)GetScene())->BeginBatch("Load custom colors texture"); StoreSaveFileName(filePath); CreateUndoPoint(); ((SceneEditor2*)GetScene())->EndBatch(); } } return true; }
bool CubeMapTextureBrowser::ValidateTextureAndFillThumbnails(DAVA::FilePath& fp, DAVA::Vector<QImage*>& icons, DAVA::Vector<QSize>& actualSize) { bool result = true; int width = 0; int height = 0; DAVA::Vector<DAVA::String> faceNames; CubemapUtils::GenerateFaceNames(fp.GetAbsolutePathname(), faceNames); for(size_t i = 0; i < faceNames.size(); ++i) { QImage faceImage; if(!faceImage.load(faceNames[i].c_str())) //file must be present { result = false; } if(faceImage.width() != faceImage.height() || //file must be square and be power of 2 !IsPowerOf2(faceImage.width())) { result = false; } if(0 == i) { width = faceImage.width(); height = faceImage.height(); } else if(faceImage.width() != width || //all files should be the same size faceImage.height() != height) { result = false; } //scale image and put scaled version to an array QImage scaledFaceTemp = faceImage.scaled(FACE_IMAGE_SIZE, FACE_IMAGE_SIZE); QImage* scaledFace = new QImage(scaledFaceTemp); icons.push_back(scaledFace); actualSize.push_back(QSize(faceImage.width(), faceImage.height())); } return result; }
void SceneValidator::ValidateScene(Scene *scene, const DAVA::FilePath &scenePath, Set<String> &errorsLog) { if(scene) { DAVA::String tmp = scenePath.GetAbsolutePathname(); size_t pos = tmp.find("/Data"); if(pos != String::npos) { SetPathForChecking(tmp.substr(0, pos + 1)); } ValidateSceneNode(scene, errorsLog); for (Set<Entity*>::iterator it = emptyNodesForDeletion.begin(); it != emptyNodesForDeletion.end(); ++it) { Entity * node = *it; if (node->GetParent()) { node->GetParent()->RemoveNode(node); } } for (Set<Entity *>::iterator it = emptyNodesForDeletion.begin(); it != emptyNodesForDeletion.end(); ++it) { Entity *node = *it; SafeRelease(node); } emptyNodesForDeletion.clear(); } else { errorsLog.insert(String("Scene in NULL!")); } }
void SelectPathWidgetBase::SetOpenDialogDefaultPath(const DAVA::FilePath& path) { openDialogDefaultPath = path.GetAbsolutePathname(); }
DAVA::FilePath SceneUtils::GetNewFilePath(const DAVA::FilePath &oldPathname) const { String workingPathname = oldPathname.GetRelativePathname(dataSourceFolder); return dataFolder + workingPathname; }