void TextureListModel::setHighlight(DAVA::Entity *node)
{
beginResetModel();
textureDescriptorsHighlight.clear();
DAVA::Map<DAVA::String, DAVA::Texture *> texturesInNode;
SceneDataManager::EnumerateTextures(node, texturesInNode);
for(DAVA::Map<DAVA::String, DAVA::Texture *>::iterator t = texturesInNode.begin(); t != texturesInNode.end(); ++t)
{
const DAVA::String descPath = t->first;
for(int i = 0; i < textureDescriptorsAll.size(); ++i)
{
if(textureDescriptorsAll[i]->pathname == descPath)
{
textureDescriptorsHighlight.push_back(textureDescriptorsAll[i]);
}
}
}
if(curFilterBySelectedNode)
{
applyFilterAndSort();
}
endResetModel();
}
void TextureListModel::setScene(DAVA::Scene *scene)
{
beginResetModel();
clear();
DAVA::Map<DAVA::String, DAVA::Texture *> texturesInNode;
SceneDataManager::EnumerateTextures(scene, texturesInNode);
for(DAVA::Map<DAVA::String, DAVA::Texture *>::iterator t = texturesInNode.begin(); t != texturesInNode.end(); ++t)
{
const DAVA::String descPath = t->first;
// if there is no the same descriptor and this file exists
if(DAVA::FileSystem::Instance()->IsFile(descPath))
{
DAVA::TextureDescriptor * descriptor = DAVA::TextureDescriptor::CreateFromFile(descPath);
if(NULL != descriptor)
{
textureDescriptorsAll.push_back(descriptor);
texturesAll[descriptor] = t->second;
}
}
}
applyFilterAndSort();
endResetModel();
}
bool QtPropertyDataDavaKeyedArcive::UpdateValueInternal()
{
// update children
{
QSet<QtPropertyData *> dataToRemove;
// at first step of sync we mark (placing to vector) items to remove
for(int i = 0; i < ChildCount(); ++i)
{
QPair<QString, QtPropertyData *> pair = ChildGet(i);
if(NULL != pair.second)
{
dataToRemove.insert(pair.second);
}
}
// as second step we go throught keyed archive and add new data items,
// and remove deleting mark from items that are still in archive
if(NULL != curArchive)
{
DAVA::Map<DAVA::String, DAVA::VariantType*> data = curArchive->GetArchieveData();
DAVA::Map<DAVA::String, DAVA::VariantType*>::iterator i = data.begin();
for(; i != data.end(); ++i)
{
QtPropertyData *childData = ChildGet(i->first.c_str());
// this key already in items list
if(NULL != childData)
{
// remove deleting mark
dataToRemove.remove(childData);
}
// create new child data
else
{
ChildCreate(i->first.c_str(), i->second);
}
}
}
// delete all marked items
QSetIterator<QtPropertyData *> it(dataToRemove);
while(it.hasNext())
{
ChildRemove(it.next());
}
}
return false;
}
void TextureDescriptorUtils::SetCompressionParams( const FilePath &descriptorPathname, const DAVA::Map<DAVA::eGPUFamily, DAVA::TextureDescriptor::Compression> & compressionParams, bool convertionEnabled, bool force)
{
TextureDescriptor *descriptor = TextureDescriptor::CreateFromFile(descriptorPathname);
if(!descriptor) return;
auto endIt = compressionParams.end();
for(auto it = compressionParams.begin(); it != endIt; ++it)
{
eGPUFamily gpu = it->first;
if(force || (descriptor->compression[gpu].format == FORMAT_INVALID))
{
descriptor->compression[gpu] = it->second;
if(convertionEnabled)
{
ImageTools::ConvertImage(descriptor, gpu, (PixelFormat)descriptor->compression[gpu].format);
}
}
}
descriptor->Save();
SafeRelease(descriptor);
}
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 QtPropertyDataDavaVariant::ChildsCreate()
{
switch(curVariantValue.type)
{
case DAVA::VariantType::TYPE_KEYED_ARCHIVE:
{
DAVA::KeyedArchive *archive = curVariantValue.AsKeyedArchive();
DAVA::Map<DAVA::String, DAVA::VariantType*> data = archive->GetArchieveData();
DAVA::Map<DAVA::String, DAVA::VariantType*>::iterator i = data.begin();
for(; i != data.end(); ++i)
{
ChildAdd(i->first.c_str(), new QtPropertyDataDavaVariant(*(i->second)));
}
}
break;
case DAVA::VariantType::TYPE_MATRIX2:
break;
case DAVA::VariantType::TYPE_MATRIX3:
break;
case DAVA::VariantType::TYPE_MATRIX4:
break;
case DAVA::VariantType::TYPE_VECTOR2:
{
DAVA::Vector2 vec = curVariantValue.AsVector2();
ChildAdd("X", vec.x);
ChildAdd("Y", vec.y);
}
break;
case DAVA::VariantType::TYPE_VECTOR3:
{
DAVA::Vector3 vec = curVariantValue.AsVector3();
ChildAdd("X", vec.x);
ChildAdd("Y", vec.y);
ChildAdd("Z", vec.z);
}
break;
case DAVA::VariantType::TYPE_VECTOR4:
{
DAVA::Vector4 vec = curVariantValue.AsVector4();
ChildAdd("X", vec.x);
ChildAdd("Y", vec.y);
ChildAdd("Z", vec.z);
ChildAdd("W", vec.w);
}
break;
case DAVA::VariantType::TYPE_COLOR:
{
// DAVA::Color color = curVariantValue.AsColor();
// ChildAdd("R", color.r);
// ChildAdd("G", color.g);
// ChildAdd("B", color.b);
// ChildAdd("A", color.a);
}
break;
case DAVA::VariantType::TYPE_AABBOX3:
{
DAVA::AABBox3 box = curVariantValue.AsAABBox3();
ChildAdd("min", FromVector3(box.min));
ChildAdd("max", FromVector3(box.max));
QtPropertyData* min = ChildGet("min");
min->SetFlags(FLAG_IS_NOT_EDITABLE);
min->ChildAdd("X", box.min.x);
min->ChildAdd("Y", box.min.y);
min->ChildAdd("Z", box.min.z);
QtPropertyData* max = ChildGet("max");
max->SetFlags(FLAG_IS_NOT_EDITABLE);
max->ChildAdd("X", box.max.x);
max->ChildAdd("Y", box.max.y);
max->ChildAdd("Z", box.max.z);
}
break;
}
}
