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());
}
}
}
}
}
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 SceneHelper::EnumerateMaterialInstances(DAVA::Entity *forNode, DAVA::Vector<DAVA::NMaterial *> &materials)
{
uint32 childrenCount = forNode->GetChildrenCount();
for(uint32 i = 0; i < childrenCount; ++i)
EnumerateMaterialInstances(forNode->GetChild(i), materials);
RenderObject * ro = GetRenderObject(forNode);
if(!ro) return;
uint32 batchCount = ro->GetRenderBatchCount();
for(uint32 i = 0; i < batchCount; ++i)
materials.push_back(ro->GetRenderBatch(i)->GetMaterial());
}
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;
}
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();
}
}