void FMODSoundBrowser::FillEventsTree(const DAVA::Vector<DAVA::String> & names) { ui->treeWidget->clear(); DAVA::int32 eventsCount = names.size(); for(DAVA::int32 i = 0; i < eventsCount; i++) { const DAVA::String & eventPath = names[i]; DAVA::Vector<DAVA::String> tokens; DAVA::Split(eventPath, "/", tokens); DAVA::int32 tokensCount = tokens.size(); QTreeWidgetItem * currentItem = ui->treeWidget->invisibleRootItem(); for(DAVA::int32 j = 0; j < tokensCount; j++) { QString currentToken = QString(tokens[j].c_str()); DAVA::int32 childrenCount = currentItem->childCount(); QTreeWidgetItem * findedItem = 0; for(DAVA::int32 k = 0; k < childrenCount; k++) { QTreeWidgetItem * currentChild = currentItem->child(k); if(currentChild->text(0) == currentToken) { findedItem = currentChild; break; } } bool isEvent = (j == tokensCount-1); if(findedItem == 0) { findedItem = new QTreeWidgetItem(currentItem); currentItem->addChild(findedItem); findedItem->setText(0, currentToken); if(isEvent) { findedItem->setIcon(0, QIcon(":/QtIcons/sound.png")); findedItem->setData(0, Qt::UserRole, QString(eventPath.c_str())); } else { findedItem->setIcon(0, QIcon(":/QtIcons/sound_group.png")); } } currentItem = findedItem; } } }
void TextureCache::setConverted(const DAVA::TextureDescriptor *descriptor, DAVA::eGPUFamily gpu, DAVA::Vector<QImage>& images) { if( NULL != descriptor && gpu > DAVA::GPU_UNKNOWN && gpu < DAVA::GPU_FAMILY_COUNT) { DAVA::Vector<QImage> tmpImages; for(int i = 0; i < (int)images.size(); ++i) { tmpImages.push_back(images[i]); } cacheConverted[gpu][descriptor] = CacheEntity(tmpImages, curConvertedWeight[gpu]++); // reached max count if(cacheConverted[gpu].size() > maxConvertedCount) { int weightToRemove = curConvertedWeight[gpu] - maxConvertedCount; QMapIterator<const DAVA::TextureDescriptor*, CacheEntity> iter(cacheConverted[gpu]); while(iter.hasNext()) { iter.next(); if(iter.value().weight < weightToRemove) { cacheConverted[gpu].remove(iter.key()); } } } } }
void TextureCache::setOriginal(const DAVA::TextureDescriptor *descriptor, DAVA::Vector<QImage>& images) { if(NULL != descriptor) { DAVA::Vector<QImage> tmpImages; for(size_t i = 0; i < images.size(); ++i) { tmpImages.push_back(images[i]); } cacheOriginal[descriptor] = CacheEntity(tmpImages, curOriginalWeight++); // reached max count if(cacheOriginal.size() > maxOrigCount) { int weightToRemove = curOriginalWeight - maxOrigCount; QMapIterator<const DAVA::TextureDescriptor*, CacheEntity> iter(cacheOriginal); while(iter.hasNext()) { iter.next(); if(iter.value().weight < weightToRemove) { cacheOriginal.remove(iter.key()); } } } } }
void FMODSoundBrowser::SelectItemAndExpandTreeByEventName(const DAVA::String & eventName) { DAVA::Vector<DAVA::String> tokens; DAVA::Split(eventName, "/", tokens); DAVA::int32 tokensCount = tokens.size(); QTreeWidgetItem * currentItem = ui->treeWidget->invisibleRootItem(); for(DAVA::int32 i = 0; i < tokensCount; i++) { QString currentToken = QString(tokens[i].c_str()); DAVA::int32 childrenCount = currentItem->childCount(); QTreeWidgetItem * findedItem = 0; for(DAVA::int32 k = 0; k < childrenCount; k++) { QTreeWidgetItem * currentChild = currentItem->child(k); if(currentChild->text(0) == currentToken) { findedItem = currentChild; findedItem->setExpanded(true); break; } } if(!findedItem) return; currentItem = findedItem; } currentItem->setSelected(true); }
void TextureBrowser::updateInfoOriginal(const DAVA::Vector<QImage> &images) { if(NULL != curTexture && NULL != curDescriptor) { char tmp[1024]; const char *formatStr = DAVA::Texture::GetPixelFormatString(DAVA::FORMAT_RGBA8888); int datasize = 0; int filesize = 0; for(size_t i = 0; i < images.size(); ++i) { datasize += images[i].width() * images[i].height() * DAVA::Texture::GetPixelFormatSizeInBytes(DAVA::FORMAT_RGBA8888); } if(!curDescriptor->IsCubeMap()) { filesize = QFileInfo(curDescriptor->GetSourceTexturePathname().GetAbsolutePathname().c_str()).size(); } else { DAVA::Vector<DAVA::String> faceNames; CubemapUtils::GenerateFaceNames(curDescriptor->pathname.GetAbsolutePathname(), faceNames); for(size_t i = 0; i < faceNames.size(); ++i) { filesize += QFileInfo(faceNames[i].c_str()).size(); } } sprintf(tmp, "Format\t: %s\nSize\t: %dx%d\nData size\t: %s\nFile size\t: %s", formatStr, images[0].width(), images[0].height(), SizeInBytesToString(datasize).c_str(), SizeInBytesToString(filesize).c_str()); ui->labelOriginalFormat->setText(tmp); } else { ui->labelOriginalFormat->setText(""); } }
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; }
int32 SceneHelper::EnumerateModifiedTextures(DAVA::Scene *forScene, DAVA::Map<DAVA::Texture *, DAVA::Vector< DAVA::eGPUFamily> > &textures) { int32 retValue = 0; textures.clear(); TexturesMap allTextures; EnumerateSceneTextures(forScene, allTextures, EXCLUDE_NULL); for(TexturesMap::iterator it = allTextures.begin(); it != allTextures.end(); ++it) { DAVA::Texture * texture = it->second; if(NULL == texture) { continue; } DAVA::TextureDescriptor *descriptor = texture->GetDescriptor(); if(NULL == descriptor) { continue; } DVASSERT(descriptor->compression); DAVA::Vector< DAVA::eGPUFamily> markedGPUs; for(int i = 0; i < DAVA::GPU_DEVICE_COUNT; ++i) { eGPUFamily gpu = (eGPUFamily)i; if(GPUFamilyDescriptor::IsFormatSupported(gpu, (PixelFormat)descriptor->compression[gpu].format)) { FilePath texPath = descriptor->GetSourceTexturePathname(); if(texPath.Exists() && !descriptor->IsCompressedTextureActual(gpu)) { markedGPUs.push_back(gpu); retValue++; } } } if(markedGPUs.size() > 0) { textures[texture] = markedGPUs; } } return retValue; }
void RecentFilesManager::SetFileToRecent(const DAVA::String& file) { DAVA::Vector<String> vectorToSave = GetRecentFiles(); DAVA::FilePath filePath(file); DAVA::String stringToInsert = filePath.GetAbsolutePathname(); //check present set to avoid duplicates vectorToSave.erase(std::remove(vectorToSave.begin(), vectorToSave.end(), stringToInsert), vectorToSave.end()); vectorToSave.insert(vectorToSave.begin(), stringToInsert); uint32 recentFilesMaxCount = SettingsManager::GetValue(Settings::General_RecentFilesCount).AsInt32(); DAVA::uint32 size = vectorToSave.size() > recentFilesMaxCount ? recentFilesMaxCount : vectorToSave.size(); KeyedArchive* archive = new KeyedArchive(); for (DAVA::uint32 i = 0; i < size; ++i) { archive->SetString(Format("%d",i), vectorToSave[i]); } SettingsManager::SetValue(Settings::Internal_RecentFiles, DAVA::VariantType(archive)); SafeRelease( archive); }
void SceneTreeItemEntity::DoSync(QStandardItem *rootItem, DAVA::Entity *entity) { if(NULL != rootItem && NULL != entity) { DAVA::int32 i; QSet<DAVA::Entity *> entitiesSet; QSet<DAVA::ParticleLayer *> layersSet; DAVA::ParticleEmitter *emitter = DAVA::GetEmitter(entity); DAVA::Vector<DAVA::ParticleLayer*> *emitterLayers = NULL; // remember all entity childs for(i = 0; i < entity->GetChildrenCount(); ++i) { entitiesSet.insert(entity->GetChild(i)); } // remember all particle layers if(NULL != emitter) { emitterLayers = &emitter->GetLayers(); for(size_t i = 0; i < emitterLayers->size(); ++i) { layersSet.insert(emitterLayers->operator[](i)); } } // remove items that are not in set for(int i = 0; i < rootItem->rowCount(); ++i) { bool doRemove = true; SceneTreeItem *childItem = (SceneTreeItem *) rootItem->child(i); if(childItem->ItemType() == SceneTreeItem::EIT_Entity) { SceneTreeItemEntity *entityItem = (SceneTreeItemEntity *) childItem; if(entitiesSet.contains(entityItem->entity)) { doRemove = false; } } else if(childItem->ItemType() == SceneTreeItem::EIT_Layer) { SceneTreeItemParticleLayer *layerItem = (SceneTreeItemParticleLayer *) childItem; if(layersSet.contains(layerItem->layer)) { doRemove = false; } } if(doRemove) { rootItem->removeRow(i); i--; } } entitiesSet.clear(); layersSet.clear(); // add entities int row = 0; for(int i = 0; i < entity->GetChildrenCount(); ++i) { bool repeatStep; DAVA::Entity *childEntity = entity->GetChild(i); do { SceneTreeItem *item = (SceneTreeItem *) rootItem->child(row); DAVA::Entity *itemEntity = SceneTreeItemEntity::GetEntity(item); repeatStep = false; // remove items that we already add while(entitiesSet.contains(itemEntity)) { rootItem->removeRow(row); item = (SceneTreeItem *) rootItem->child(row); itemEntity = SceneTreeItemEntity::GetEntity(item); } // append entity that isn't in child items list if(NULL == item) { rootItem->appendRow(new SceneTreeItemEntity(childEntity)); } else if(childEntity != itemEntity) { // now we should decide what to do: remove item or insert it // calc len until itemEntity will be found in real entity childs int lenUntilRealEntity = 0; for(int j = i; j < entity->GetChildrenCount(); ++j) { if(entity->GetChild(j) == itemEntity) { lenUntilRealEntity = j - i; break; } } // calc len until current real entity child will be found in current item childs int lenUntilItem = 0; for(int j = i; j < rootItem->rowCount(); ++j) { SceneTreeItem *itm = (SceneTreeItem *) rootItem->child(j); DAVA::Entity *itmEn = SceneTreeItemEntity::GetEntity(itm); if(childEntity == itmEn) { lenUntilItem = j - i; break; } } if(lenUntilRealEntity >= lenUntilItem) { rootItem->removeRow(row); repeatStep = true; } else { rootItem->insertRow(row, new SceneTreeItemEntity(childEntity)); } } else { DoSync(item, itemEntity); } } while(repeatStep); // remember that we add that entity entitiesSet.insert(childEntity); row++; } // add layers if(NULL != emitterLayers) { for(size_t i = 0; i < emitterLayers->size(); ++i) { bool repeatStep; DAVA::ParticleLayer* childLayer = emitterLayers->operator[](i); do { SceneTreeItem *item = (SceneTreeItem *) rootItem->child(row); DAVA::ParticleLayer *itemLayer = SceneTreeItemParticleLayer::GetLayer(item); repeatStep = false; // remove items that we already add while(layersSet.contains(itemLayer)) { rootItem->removeRow(row); SceneTreeItem *item = (SceneTreeItem *) rootItem->child(row); DAVA::ParticleLayer *itemLayer = SceneTreeItemParticleLayer::GetLayer(item); } if(NULL == item) { rootItem->appendRow(new SceneTreeItemParticleLayer(emitter, childLayer)); } else if(childLayer != itemLayer) { // now we should decide what to do: remove layer or insert it // calc len until itemEntity will be found in real int lenUntilRealLayer = 0; for(int j = i; j < (int) emitterLayers->size(); ++j) { if(emitterLayers->operator[](j) == itemLayer) { lenUntilRealLayer = j - i; break; } } // calc len until current real entity child will be found in current item childs int lenUntilItem = 0; for(int j = i; j < rootItem->rowCount(); ++j) { SceneTreeItem *itm = (SceneTreeItem *) rootItem->child(j); DAVA::ParticleLayer *itmLay = SceneTreeItemParticleLayer::GetLayer(itm); if(childLayer == itmLay) { lenUntilItem = j - i; break; } } if(lenUntilRealLayer >= lenUntilItem) { rootItem->removeRow(row); repeatStep = true; } else { rootItem->insertRow(row, new SceneTreeItemParticleLayer(emitter, childLayer)); } } else { SceneTreeItemParticleLayer::DoSync(item, itemLayer); } } while (repeatStep); row++; layersSet.insert(childLayer); } } // remove all other rows if(row < rootItem->rowCount()) { rootItem->removeRows(row, rootItem->rowCount() - row); } } }
QWidget* ActionItemEditDelegate::createEditor(QWidget *parent, const QStyleOptionViewItem &option, const QModelIndex &index) const { QWidget* editor = NULL; switch(index.column()) { case COLUMN_ACTION_TYPE: { QComboBox* combo = new QComboBox(parent); combo->setFrame(false); for(int i = 1; i < ACTION_NAME_COUNT - 1; ++i) //do not add sound aciton { combo->addItem(ACTION_TYPE_NAME[i]); } editor = combo; break; } case COLUMN_ENTITY_NAME: { DAVA::Entity* parentEntity = targetComponent->GetEntity(); DAVA::Vector<DAVA::Entity*> allChildren; parentEntity->GetChildNodes(allChildren); DAVA::Vector<DAVA::String> childrenNames; childrenNames.push_back(parentEntity->GetName()); for(int i = 0; i < allChildren.size(); ++i) { childrenNames.push_back(allChildren[i]->GetName()); } std::sort(childrenNames.begin(), childrenNames.end()); childrenNames.erase(std::unique(childrenNames.begin(), childrenNames.end()), childrenNames.end()); QComboBox* combo = new QComboBox(parent); combo->setFrame(false); for(int i = 0; i < childrenNames.size(); ++i) { combo->addItem(childrenNames[i].c_str()); } editor = combo; break; } case COLUMN_DELAY: { QDoubleSpinBox* spinBox = new QDoubleSpinBox(parent); spinBox->setMinimum(0.0f); spinBox->setMaximum(3600.f); spinBox->setSingleStep(0.01f); editor = spinBox; break; } case COLUMN_SWITCH_INDEX: { QSpinBox* spinBox = new QSpinBox(parent); spinBox->setMinimum(-1); spinBox->setMaximum(128); spinBox->setSingleStep(1); editor = spinBox; break; } case COLUMN_STOPAFTERNREPEATS_INDEX: { QSpinBox* spinBox = new QSpinBox(parent); spinBox->setMinimum(-1); spinBox->setMaximum(100000); spinBox->setSingleStep(1); editor = spinBox; break; } case COLUMN_STOPWHENEMPTY_INDEX: { QComboBox* combo = new QComboBox(parent); combo->setFrame(false); combo->addItem("Yes"); combo->addItem("No"); editor = combo; break; } } DVASSERT(editor); return editor; }
void TextureBrowser::setTexture(DAVA::Texture *texture, DAVA::TextureDescriptor *descriptor) { curTexture = texture; curDescriptor = descriptor; // color channels to default value ui->actionColorR->setChecked(true); ui->actionColorG->setChecked(true); ui->actionColorB->setChecked(true); ui->actionColorA->setChecked(true); ui->textureAreaOriginal->setColorChannel(TextureScrollArea::ChannelAll); ui->textureAreaConverted->setColorChannel(TextureScrollArea::ChannelAll); ui->textureAreaOriginal->resetTexturePosZoom(); ui->textureAreaConverted->resetTexturePosZoom(); toolbarZoomSlider->setValue(0); // disable texture views by default ui->textureAreaOriginal->setEnabled(false); ui->textureAreaConverted->setEnabled(false); ui->convertToolButton->setEnabled(false); // set texture to properties control. // this should be done as a first step ui->textureProperties->setTextureDescriptor(curDescriptor); ui->textureProperties->setTextureGPU(curTextureView); updatePropertiesWarning(); // if texture is ok - set it and enable texture views if(NULL != curTexture) { // enable convert button ui->convertToolButton->setEnabled(true); // load original image // check if image is in cache DAVA::Vector<QImage> images = TextureCache::Instance()->getOriginal(curDescriptor); if(images.size() > 0 && !images[0].isNull()) { // image is in cache, so set it immediately (by calling image-ready slot) textureReadyOriginal(curDescriptor, images); } else { // set empty info DAVA::Vector<QImage> emptyImages; emptyImages.push_back(QImage()); updateInfoOriginal(emptyImages); // there is no image in cache - start loading it in different thread. image-ready slot will be called ui->textureAreaOriginal->setImage(QImage()); TextureConvertor::Instance()->GetOriginal(curDescriptor); // show loading bar ui->textureAreaOriginal->waitbarShow(true); } } else { // no texture - set empty images to original/PVR views ui->textureAreaOriginal->setImage(QImage()); ui->textureAreaConverted->setImage(QImage()); } }
void CubeMapTextureBrowser::ReloadTextures(const DAVA::String& rootPath) { cubeListItemDelegate.ClearCache(); ui->listTextures->clear(); ui->listTextures->setVisible(false); ui->loadingWidget->setVisible(true); this->paintEvent(NULL); ui->loadingWidget->update(); QApplication::processEvents(); QApplication::flush(); this->setUpdatesEnabled(false); QDir dir(rootPath.c_str()); QStringList filesList = dir.entryList(QStringList("*.tex")); size_t cubemapTextures = 0; if(filesList.size() > 0) { DAVA::Vector<CubeListItemDelegate::ListItemInfo> cubemapList; FilePath fp = rootPath; for(int i = 0; i < filesList.size(); ++i) { QString str = filesList.at(i); fp.ReplaceFilename(str.toStdString()); DAVA::TextureDescriptor* texDesc = DAVA::TextureDescriptor::CreateFromFile(fp); if(texDesc && texDesc->IsCubeMap()) { CubeListItemDelegate::ListItemInfo itemInfo; itemInfo.path = fp; itemInfo.valid = ValidateTextureAndFillThumbnails(fp, itemInfo.icons, itemInfo.actualSize); if(itemInfo.valid) { cubemapList.push_back(itemInfo); } else { //non-valid items should be always at the beginning of the list cubemapList.insert(cubemapList.begin(), itemInfo); } } SafeDelete(texDesc); } cubeListItemDelegate.UpdateCache(cubemapList); for(size_t i = 0; i < cubemapList.size(); ++i) { CubeListItemDelegate::ListItemInfo& itemInfo = cubemapList[i]; QListWidgetItem* listItem = new QListWidgetItem(); listItem->setData(Qt::CheckStateRole, false); listItem->setData(CUBELIST_DELEGATE_ITEMFULLPATH, itemInfo.path.GetAbsolutePathname().c_str()); listItem->setData(CUBELIST_DELEGATE_ITEMFILENAME, itemInfo.path.GetFilename().c_str()); ui->listTextures->addItem(listItem); } cubemapTextures = cubemapList.size(); ui->listTextures->setCurrentItem(ui->listTextures->item(0)); } this->setUpdatesEnabled(true); ui->listTextures->setVisible(cubemapTextures > 0); ui->loadingWidget->setVisible(false); UpdateCheckedState(); }
void CubeMapTextureBrowser::OnDeleteSelectedItemsClicked() { int checkedItemCount = GetCheckedItemsCount(); int answer = MB_FLAG_NO; if(checkedItemCount > 0) { QString text = QString("%1 item(s) will be deleted. Continue?").arg(QString().setNum(checkedItemCount)); answer = ShowQuestion("Confirmation", text.toStdString(), MB_FLAG_YES | MB_FLAG_NO, MB_FLAG_NO); } if(MB_FLAG_YES == answer) { DAVA::Vector<DAVA::String> failedToRemove; int itemCount = ui->listTextures->count(); for(int i = 0; i < itemCount; ++i) { QListWidgetItem* item = ui->listTextures->item(i); bool checkedState = item->data(Qt::CheckStateRole).toBool(); if(checkedState) { FilePath fp = item->data(CUBELIST_DELEGATE_ITEMFULLPATH).toString().toStdString(); if(fp.Exists()) { DAVA::Vector<DAVA::String> faceNames; CubemapUtils::GenerateFaceNames(fp.GetAbsolutePathname(), faceNames); for(size_t faceIndex = 0; faceIndex < faceNames.size(); ++faceIndex) { FilePath hackTex = faceNames[faceIndex]; hackTex.ReplaceExtension(".tex"); QFile::remove(hackTex.GetAbsolutePathname().c_str()); bool removeResult = QFile::remove(faceNames[faceIndex].c_str()); if(!removeResult) { failedToRemove.push_back(faceNames[faceIndex]); } } bool removeResult = QFile::remove(fp.GetAbsolutePathname().c_str()); if(!removeResult) { failedToRemove.push_back(fp.GetAbsolutePathname().c_str()); } } } } if(failedToRemove.size() > 0) { DAVA::String fileList; int count = failedToRemove.size(); for(int i = 0; i < count; ++i) { fileList += failedToRemove[i]; fileList += "\n"; } DAVA::String message = "Failed to remove the following files. Please delete them manually.\n"; message += fileList; ShowErrorDialog(message); } QString path = ui->textRootPath->text(); ReloadTexturesFromUI(path); UpdateCheckedState(); } }