void RenderTargetInfo::Load(const XMLElement& element)
{
name_ = element.GetAttribute("name");
tag_ = element.GetAttribute("tag");
if (element.HasAttribute("enabled"))
enabled_ = element.GetBool("enabled");
String formatName = element.GetAttribute("format");
format_ = Graphics::GetFormat(formatName);
if (element.HasAttribute("filter"))
filtered_ = element.GetBool("filter");
if (element.HasAttribute("srgb"))
sRGB_ = element.GetBool("srgb");
if (element.HasAttribute("size"))
size_ = element.GetIntVector2("size");
if (element.HasAttribute("sizedivisor"))
{
size_ = element.GetIntVector2("sizedivisor");
sizeMode_ = SIZE_VIEWPORTDIVISOR;
}
if (element.HasAttribute("rtsizedivisor"))
{
size_ = element.GetIntVector2("rtsizedivisor");
sizeMode_ = SIZE_RENDERTARGETDIVISOR;
}
if (element.HasAttribute("width"))
size_.x_ = element.GetInt("width");
if (element.HasAttribute("height"))
size_.y_ = element.GetInt("height");
}
bool ObjectAnimation::LoadXML(const XMLElement& source)
{
attributeAnimationInfos_.Clear();
XMLElement animElem;
animElem = source.GetChild("attributeanimation");
while (animElem)
{
String name = animElem.GetAttribute("name");
SharedPtr<ValueAnimation> animation(new ValueAnimation(context_));
if (!animation->LoadXML(animElem))
return false;
String wrapModeString = animElem.GetAttribute("wrapmode");
WrapMode wrapMode = WM_LOOP;
for (int i = 0; i <= WM_CLAMP; ++i)
{
if (wrapModeString == wrapModeNames[i])
{
wrapMode = (WrapMode)i;
break;
}
}
float speed = animElem.GetFloat("speed");
AddAttributeAnimation(name, animation, wrapMode, speed);
animElem = animElem.GetNext("attributeanimation");
}
return true;
}
// ----------------------------------------------------------------------------
bool InputMapping::LoadInputMapping(XMLFile* config)
{
XMLElement contextElement = config->GetRoot().GetChild("context");
if(!contextElement)
return false;
while(contextElement)
{
String contextName = contextElement.GetAttribute("name");
if(contextName == "3rd person controls")
{
XMLElement mappingElement = contextElement.GetChild("mapping");
while(mappingElement)
{
String action = mappingElement.GetAttribute("action");
String device = mappingElement.GetAttribute("device");
int value = mappingElement.GetInt("value");
SetMapping(contextName, device, action, value);
mappingElement = mappingElement.GetNext("mapping");
}
}
contextElement = contextElement.GetNext("context");
}
return true;
}
ShaderPrecache::ShaderPrecache(Context* context, const String& fileName) :
Object(context),
fileName_(fileName),
xmlFile_(context)
{
if (GetSubsystem<FileSystem>()->FileExists(fileName))
{
// If file exists, read the already listed combinations
File source(context_, fileName);
xmlFile_.Load(source);
XMLElement shader = xmlFile_.GetRoot().GetChild("shader");
while (shader)
{
String oldCombination = shader.GetAttribute("vs") + " " + shader.GetAttribute("vsdefines") + " " +
shader.GetAttribute("ps") + " " + shader.GetAttribute("psdefines");
usedCombinations_.Insert(oldCombination);
shader = shader.GetNext("shader");
}
}
// If no file yet or loading failed, create the root element now
if (!xmlFile_.GetRoot())
xmlFile_.CreateRoot("shaders");
LOGINFO("Begin dumping shaders to " + fileName_);
}
bool UnknownComponent::LoadXML(const XMLElement& source, bool setInstanceDefault)
{
useXML_ = true;
xmlAttributes_.Clear();
xmlAttributeInfos_.Clear();
binaryAttributes_.Clear();
XMLElement attrElem = source.GetChild("attribute");
while (attrElem)
{
AttributeInfo attr;
attr.mode_ = AM_FILE;
attr.name_ = attrElem.GetAttribute("name");
attr.type_ = VAR_STRING;
if (!attr.name_.Empty())
{
String attrValue = attrElem.GetAttribute("value");
attr.defaultValue_ = String::EMPTY;
xmlAttributeInfos_.Push(attr);
xmlAttributes_.Push(attrValue);
}
attrElem = attrElem.GetNext("attribute");
}
// Fix up pointers to the attributes after all have been read
for (unsigned i = 0; i < xmlAttributeInfos_.Size(); ++i)
xmlAttributeInfos_[i].ptr_ = &xmlAttributes_[i];
return true;
}
bool Material::BeginLoad(Deserializer& source)
{
// In headless mode, do not actually load the material, just return success
Graphics* graphics = GetSubsystem<Graphics>();
if (!graphics)
return true;
loadXMLFile_ = new XMLFile(context_);
if (loadXMLFile_->Load(source))
{
// If async loading, scan the XML content beforehand for technique & texture resources
// and request them to also be loaded. Can not do anything else at this point
if (GetAsyncLoadState() == ASYNC_LOADING)
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
XMLElement rootElem = loadXMLFile_->GetRoot();
XMLElement techniqueElem = rootElem.GetChild("technique");
while (techniqueElem)
{
cache->BackgroundLoadResource<Technique>(techniqueElem.GetAttribute("name"), true, this);
techniqueElem = techniqueElem.GetNext("technique");
}
XMLElement textureElem = rootElem.GetChild("texture");
while (textureElem)
{
String name = textureElem.GetAttribute("name");
// Detect cube maps by file extension: they are defined by an XML file
/// \todo Differentiate with 3D textures by actually reading the XML content
if (GetExtension(name) == ".xml")
{
#ifdef DESKTOP_GRAPHICS
TextureUnit unit = TU_DIFFUSE;
if (textureElem.HasAttribute("unit"))
unit = ParseTextureUnitName(textureElem.GetAttribute("unit"));
if (unit == TU_VOLUMEMAP)
cache->BackgroundLoadResource<Texture3D>(name, true, this);
else
#endif
cache->BackgroundLoadResource<TextureCube>(name, true, this);
}
else
cache->BackgroundLoadResource<Texture2D>(name, true, this);
textureElem = textureElem.GetNext("texture");
}
}
return true;
}
else
{
ResetToDefaults();
loadXMLFile_.Reset();
return false;
}
}
bool DropDownList::FilterPopupImplicitAttributes(XMLElement& dest) const
{
if (!Menu::FilterPopupImplicitAttributes(dest))
return false;
// Window popup
if (dest.GetAttribute("style").empty() && !dest.SetAttribute("style", "none"))
return false;
if (!RemoveChildXML(dest, "Layout Mode", "Vertical"))
return false;
if (!RemoveChildXML(dest, "Size"))
return false;
// ListView
XMLElement childElem = dest.GetChild("element");
if (!childElem)
return false;
if (!listView_->FilterAttributes(childElem))
return false;
if (childElem.GetAttribute("style").empty() && !childElem.SetAttribute("style", "none"))
return false;
if (!RemoveChildXML(childElem, "Focus Mode", "NotFocusable"))
return false;
if (!RemoveChildXML(childElem, "Auto Show/Hide Scrollbars", "false"))
return false;
// Horizontal scroll bar
XMLElement hScrollElem = childElem.GetChild("element");
// Vertical scroll bar
XMLElement vScrollElem = hScrollElem.GetNext("element");
// Scroll panel
XMLElement panelElem = vScrollElem.GetNext("element");
if (hScrollElem && !hScrollElem.GetParent().RemoveChild(hScrollElem))
return false;
if (vScrollElem && !vScrollElem.GetParent().RemoveChild(vScrollElem))
return false;
if (panelElem)
{
if (panelElem.GetAttribute("style").empty() && !panelElem.SetAttribute("style", "none"))
return false;
// Item container
XMLElement containerElem = panelElem.GetChild("element");
if (containerElem)
{
if (containerElem.GetAttribute("style").empty() && !containerElem.SetAttribute("style", "none"))
return false;
}
}
return true;
}
void RenderTargetInfo::Load(const XMLElement& element)
{
name_ = element.GetAttribute("name");
tag_ = element.GetAttribute("tag");
if (element.HasAttribute("enabled"))
enabled_ = element.GetBool("enabled");
if (element.HasAttribute("cubemap"))
cubemap_ = element.GetBool("cubemap");
String formatName = element.GetAttribute("format");
format_ = Graphics::GetFormat(formatName);
if (element.HasAttribute("filter"))
filtered_ = element.GetBool("filter");
if (element.HasAttribute("srgb"))
sRGB_ = element.GetBool("srgb");
if (element.HasAttribute("persistent"))
persistent_ = element.GetBool("persistent");
if (element.HasAttribute("size"))
size_ = element.GetVector2("size");
if (element.HasAttribute("sizedivisor"))
{
size_ = element.GetVector2("sizedivisor");
sizeMode_ = SIZE_VIEWPORTDIVISOR;
}
else if (element.HasAttribute("rtsizedivisor"))
{
// Deprecated rtsizedivisor mode, acts the same as sizedivisor mode now
URHO3D_LOGWARNING("Deprecated rtsizedivisor mode used in rendertarget definition");
size_ = element.GetVector2("rtsizedivisor");
sizeMode_ = SIZE_VIEWPORTDIVISOR;
}
else if (element.HasAttribute("sizemultiplier"))
{
size_ = element.GetVector2("sizemultiplier");
sizeMode_ = SIZE_VIEWPORTMULTIPLIER;
}
if (element.HasAttribute("width"))
size_.x_ = element.GetFloat("width");
if (element.HasAttribute("height"))
size_.y_ = element.GetFloat("height");
if (element.HasAttribute("multisample"))
multiSample_ = Clamp(element.GetInt("multisample"), 1, 16);
if (element.HasAttribute("autoresolve"))
autoResolve_ = element.GetBool("autoresolve");
}
bool ValueAnimation::LoadXML(const XMLElement& source)
{
valueType_ = VAR_NONE;
eventFrames_.Clear();
String interpMethodString = source.GetAttribute("interpolationmethod");
InterpMethod method = (InterpMethod)GetStringListIndex(interpMethodString.CString(), interpMethodNames, IM_LINEAR);
SetInterpolationMethod(method);
if (interpolationMethod_ == IM_SPLINE)
splineTension_ = source.GetFloat("splinetension");
XMLElement keyFrameElem = source.GetChild("keyframe");
while (keyFrameElem)
{
float time = keyFrameElem.GetFloat("time");
Variant value = keyFrameElem.GetVariant();
SetKeyFrame(time, value);
keyFrameElem = keyFrameElem.GetNext("keyframe");
}
XMLElement eventFrameElem = source.GetChild("eventframe");
while (eventFrameElem)
{
float time = eventFrameElem.GetFloat("time");
unsigned eventType = eventFrameElem.GetUInt("eventtype");
VariantMap eventData = eventFrameElem.GetChild("eventdata").GetVariantMap();
SetEventFrame(time, StringHash(eventType), eventData);
eventFrameElem = eventFrameElem.GetNext("eventframe");
}
return true;
}
bool SpriteSheet2D::BeginLoadFromXMLFile(Deserializer& source)
{
loadXMLFile_ = new XMLFile(context_);
if (!loadXMLFile_->Load(source))
{
URHO3D_LOGERROR("Could not load sprite sheet");
loadXMLFile_.Reset();
return false;
}
SetMemoryUse(source.GetSize());
XMLElement rootElem = loadXMLFile_->GetRoot("TextureAtlas");
if (!rootElem)
{
URHO3D_LOGERROR("Invalid sprite sheet");
loadXMLFile_.Reset();
return false;
}
// If we're async loading, request the texture now. Finish during EndLoad().
loadTextureName_ = GetParentPath(GetName()) + rootElem.GetAttribute("imagePath");
if (GetAsyncLoadState() == ASYNC_LOADING)
GetSubsystem<ResourceCache>()->BackgroundLoadResource<Texture2D>(loadTextureName_, true, this);
return true;
}
bool TmxImageLayer2D::Load(const XMLElement& element, const TileMapInfo2D& info)
{
LoadInfo(element);
XMLElement imageElem = element.GetChild("image");
if (!imageElem)
return false;
position_ = Vector2(0.0f, info.GetMapHeight());
source_ = imageElem.GetAttribute("source");
String textureFilePath = GetParentPath(tmxFile_->GetName()) + source_;
ResourceCache* cache = tmxFile_->GetSubsystem<ResourceCache>();
SharedPtr<Texture2D> texture(cache->GetResource<Texture2D>(textureFilePath));
if (!texture)
{
URHO3D_LOGERROR("Could not load texture " + textureFilePath);
return false;
}
sprite_ = new Sprite2D(tmxFile_->GetContext());
sprite_->SetTexture(texture);
sprite_->SetRectangle(IntRect(0, 0, texture->GetWidth(), texture->GetHeight()));
// Set image hot spot at left top
sprite_->SetHotSpot(Vector2(0.0f, 1.0f));
if (element.HasChild("properties"))
LoadPropertySet(element.GetChild("properties"));
return true;
}
bool Texture2DArray::BeginLoad(Deserializer& source)
{
ResourceCache* cache = context_->resourceCache();
// In headless mode, do not actually load the texture, just return success
if (!graphics_)
return true;
// If device is lost, retry later
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Texture load while device is lost");
dataPending_ = true;
return true;
}
cache->ResetDependencies(this);
QString texPath, texName, texExt;
SplitPath(GetName(), texPath, texName, texExt);
loadParameters_ = (new XMLFile(context_));
if (!loadParameters_->Load(source))
{
loadParameters_.Reset();
return false;
}
loadImages_.clear();
XMLElement textureElem = loadParameters_->GetRoot();
XMLElement layerElem = textureElem.GetChild("layer");
while (layerElem)
{
QString name = layerElem.GetAttribute("name");
// If path is empty, add the XML file path
if (GetPath(name).isEmpty())
name = texPath + name;
loadImages_.push_back(cache->GetTempResource<Image>(name));
cache->StoreResourceDependency(this, name);
layerElem = layerElem.GetNext("layer");
}
// Precalculate mip levels if async loading
if (GetAsyncLoadState() == ASYNC_LOADING)
{
for (unsigned i = 0; i < loadImages_.size(); ++i)
{
if (loadImages_[i])
loadImages_[i]->PrecalculateLevels();
}
}
return true;
}
bool Animatable::LoadXML(const XMLElement& source, bool setInstanceDefault)
{
if (!Serializable::LoadXML(source, setInstanceDefault))
return false;
SetObjectAnimation(0);
attributeAnimationInfos_.Clear();
XMLElement elem = source.GetChild("objectanimation");
if (elem)
{
SharedPtr<ObjectAnimation> objectAnimation(new ObjectAnimation(context_));
if (!objectAnimation->LoadXML(elem))
return false;
SetObjectAnimation(objectAnimation);
}
elem = source.GetChild("attributeanimation");
while (elem)
{
String name = elem.GetAttribute("name");
SharedPtr<ValueAnimation> attributeAnimation(new ValueAnimation(context_));
if (!attributeAnimation->LoadXML(elem))
return false;
String wrapModeString = source.GetAttribute("wrapmode");
WrapMode wrapMode = WM_LOOP;
for (int i = 0; i <= WM_CLAMP; ++i)
{
if (wrapModeString == wrapModeNames[i])
{
wrapMode = (WrapMode)i;
break;
}
}
float speed = elem.GetFloat("speed");
SetAttributeAnimation(name, attributeAnimation, wrapMode, speed);
elem = elem.GetNext("attributeanimation");
}
return true;
}
bool TmxFile2D::BeginLoad(Deserializer& source)
{
if (GetName().Empty())
SetName(source.GetName());
loadXMLFile_ = new XMLFile(context_);
if (!loadXMLFile_->Load(source))
{
URHO3D_LOGERROR("Load XML failed " + source.GetName());
loadXMLFile_.Reset();
return false;
}
XMLElement rootElem = loadXMLFile_->GetRoot("map");
if (!rootElem)
{
URHO3D_LOGERROR("Invalid tmx file " + source.GetName());
loadXMLFile_.Reset();
return false;
}
// If we're async loading, request the texture now. Finish during EndLoad().
if (GetAsyncLoadState() == ASYNC_LOADING)
{
for (XMLElement tileSetElem = rootElem.GetChild("tileset"); tileSetElem; tileSetElem = tileSetElem.GetNext("tileset"))
{
// Tile set defined in TSX file
if (tileSetElem.HasAttribute("source"))
{
String source = tileSetElem.GetAttribute("source");
SharedPtr<XMLFile> tsxXMLFile = LoadTSXFile(source);
if (!tsxXMLFile)
return false;
tsxXMLFiles_[source] = tsxXMLFile;
String textureFilePath =
GetParentPath(GetName()) + tsxXMLFile->GetRoot("tileset").GetChild("image").GetAttribute("source");
GetSubsystem<ResourceCache>()->BackgroundLoadResource<Texture2D>(textureFilePath, true, this);
}
else
{
String textureFilePath = GetParentPath(GetName()) + tileSetElem.GetChild("image").GetAttribute("source");
GetSubsystem<ResourceCache>()->BackgroundLoadResource<Texture2D>(textureFilePath, true, this);
}
}
for (XMLElement imageLayerElem = rootElem.GetChild("imagelayer"); imageLayerElem;
imageLayerElem = imageLayerElem.GetNext("imagelayer"))
{
String textureFilePath = GetParentPath(GetName()) + imageLayerElem.GetChild("image").GetAttribute("source");
GetSubsystem<ResourceCache>()->BackgroundLoadResource<Texture2D>(textureFilePath, true, this);
}
}
return true;
}
void TmxLayer2D::LoadInfo(const XMLElement& element)
{
name_ = element.GetAttribute("name");
width_ = element.GetInt("width");
height_ = element.GetInt("height");
if (element.HasAttribute("visible"))
visible_ = element.GetInt("visible") != 0;
else
visible_ = true;
}
void ShaderPrecache::LoadShaders(Graphics* graphics, Deserializer& source)
{
LOGDEBUG("Begin precaching shaders");
XMLFile xmlFile(graphics->GetContext());
xmlFile.Load(source);
XMLElement shader = xmlFile.GetRoot().GetChild("shader");
while (shader)
{
ShaderVariation* vs = graphics->GetShader(VS, shader.GetAttribute("vs"), shader.GetAttribute("vsdefines"));
ShaderVariation* ps = graphics->GetShader(PS, shader.GetAttribute("ps"), shader.GetAttribute("psdefines"));
// Set the shaders active to actually compile them
graphics->SetShaders(vs, ps);
shader = shader.GetNext("shader");
}
LOGDEBUG("End precaching shaders");
}
bool TextureCube::Load(Deserializer& source)
{
PROFILE(LoadTextureCube);
ResourceCache* cache = GetSubsystem<ResourceCache>();
// In headless mode, do not actually load the texture, just return success
Graphics* graphics = GetSubsystem<Graphics>();
if (!graphics)
return true;
// If device is lost, retry later
if (graphics_->IsDeviceLost())
{
LOGWARNING("Texture load while device is lost");
dataPending_ = true;
return true;
}
// If over the texture budget, see if materials can be freed to allow textures to be freed
CheckTextureBudget(GetTypeStatic());
String texPath, texName, texExt;
SplitPath(GetName(), texPath, texName, texExt);
SharedPtr<XMLFile> xml(new XMLFile(context_));
if (!xml->Load(source))
return false;
LoadParameters(xml);
XMLElement textureElem = xml->GetRoot();
XMLElement faceElem = textureElem.GetChild("face");
unsigned faces = 0;
while (faceElem && faces < MAX_CUBEMAP_FACES)
{
String name = faceElem.GetAttribute("name");
String faceTexPath, faceTexName, faceTexExt;
SplitPath(name, faceTexPath, faceTexName, faceTexExt);
// If path is empty, add the XML file path
if (faceTexPath.Empty())
name = texPath + name;
SharedPtr<Image> image(cache->GetResource<Image>(name));
Load((CubeMapFace)faces, image);
++faces;
faceElem = faceElem.GetNext("face");
}
return true;
}
bool XMLFile::BeginLoad(Deserializer& source)
{
unsigned dataSize = source.GetSize();
if (!dataSize && !source.GetName().Empty())
{
URHO3D_LOGERROR("Zero sized XML data in " + source.GetName());
return false;
}
SharedArrayPtr<char> buffer(new char[dataSize]);
if (source.Read(buffer.Get(), dataSize) != dataSize)
return false;
if (!document_->load_buffer(buffer.Get(), dataSize))
{
URHO3D_LOGERROR("Could not parse XML data from " + source.GetName());
document_->reset();
return false;
}
XMLElement rootElem = GetRoot();
String inherit = rootElem.GetAttribute("inherit");
if (!inherit.Empty())
{
// The existence of this attribute indicates this is an RFC 5261 patch file
ResourceCache* cache = GetSubsystem<ResourceCache>();
// If being async loaded, GetResource() is not safe, so use GetTempResource() instead
XMLFile* inheritedXMLFile = GetAsyncLoadState() == ASYNC_DONE ? cache->GetResource<XMLFile>(inherit) :
cache->GetTempResource<XMLFile>(inherit);
if (!inheritedXMLFile)
{
URHO3D_LOGERRORF("Could not find inherited XML file: %s", inherit.CString());
return false;
}
// Patch this XMLFile and leave the original inherited XMLFile as it is
pugi::xml_document* patchDocument = document_;
document_ = new pugi::xml_document();
document_->reset(*inheritedXMLFile->document_);
Patch(rootElem);
delete patchDocument;
// Store resource dependencies so we know when to reload/repatch when the inherited resource changes
cache->StoreResourceDependency(this, inherit);
// Approximate patched data size
dataSize += inheritedXMLFile->GetMemoryUse();
}
// Note: this probably does not reflect internal data structure size accurately
SetMemoryUse(dataSize);
return true;
}
void ShaderPrecache::LoadShaders(Graphics* graphics, Deserializer& source)
{
LOGDEBUG("Begin precaching shaders");
XMLFile xmlFile(graphics->GetContext());
xmlFile.Load(source);
XMLElement shader = xmlFile.GetRoot().GetChild("shader");
while (shader)
{
String vsDefines = shader.GetAttribute("vsdefines");
String psDefines = shader.GetAttribute("psdefines");
// Check for illegal variations on OpenGL ES and skip them
#ifdef GL_ES_VERSION_2_0
if (
#ifndef __EMSCRIPTEN__
vsDefines.Contains("INSTANCED") ||
#endif
(psDefines.Contains("POINTLIGHT") && psDefines.Contains("SHADOW")))
{
shader = shader.GetNext("shader");
continue;
}
#endif
ShaderVariation* vs = graphics->GetShader(VS, shader.GetAttribute("vs"), vsDefines);
ShaderVariation* ps = graphics->GetShader(PS, shader.GetAttribute("ps"), psDefines);
// Set the shaders active to actually compile them
graphics->SetShaders(vs, ps);
shader = shader.GetNext("shader");
}
LOGDEBUG("End precaching shaders");
}
bool TmxTileLayer2D::Load(const XMLElement& element, const TileMapInfo2D& info)
{
LoadInfo(element);
XMLElement dataElem = element.GetChild("data");
if (!dataElem)
{
URHO3D_LOGERROR("Could not find data in layer");
return false;
}
if (dataElem.HasAttribute("encoding") && dataElem.GetAttribute("encoding") != "xml")
{
URHO3D_LOGERROR("Encoding not support now");
return false;
}
XMLElement tileElem = dataElem.GetChild("tile");
tiles_.Resize((unsigned)(width_ * height_));
for (int y = 0; y < height_; ++y)
{
for (int x = 0; x < width_; ++x)
{
if (!tileElem)
return false;
int gid = tileElem.GetInt("gid");
if (gid > 0)
{
SharedPtr<Tile2D> tile(new Tile2D());
tile->gid_ = gid;
tile->sprite_ = tmxFile_->GetTileSprite(gid);
tile->propertySet_ = tmxFile_->GetTilePropertySet(gid);
tiles_[y * width_ + x] = tile;
}
tileElem = tileElem.GetNext("tile");
}
}
if (element.HasChild("properties"))
LoadPropertySet(element.GetChild("properties"));
return true;
}
bool SpriteSheet2D::EndLoadFromXMLFile()
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
texture_ = cache->GetResource<Texture2D>(loadTextureName_);
if (!texture_)
{
URHO3D_LOGERROR("Could not load texture " + loadTextureName_);
loadXMLFile_.Reset();
loadTextureName_.Clear();
return false;
}
XMLElement rootElem = loadXMLFile_->GetRoot("TextureAtlas");
XMLElement subTextureElem = rootElem.GetChild("SubTexture");
while (subTextureElem)
{
String name = subTextureElem.GetAttribute("name");
int x = subTextureElem.GetInt("x");
int y = subTextureElem.GetInt("y");
int width = subTextureElem.GetInt("width");
int height = subTextureElem.GetInt("height");
IntRect rectangle(x, y, x + width, y + height);
Vector2 hotSpot(0.5f, 0.5f);
IntVector2 offset(0, 0);
if (subTextureElem.HasAttribute("frameWidth") && subTextureElem.HasAttribute("frameHeight"))
{
offset.x_ = subTextureElem.GetInt("frameX");
offset.y_ = subTextureElem.GetInt("frameY");
int frameWidth = subTextureElem.GetInt("frameWidth");
int frameHeight = subTextureElem.GetInt("frameHeight");
hotSpot.x_ = ((float)offset.x_ + frameWidth / 2) / width;
hotSpot.y_ = 1.0f - ((float)offset.y_ + frameHeight / 2) / height;
}
DefineSprite(name, rectangle, hotSpot, offset);
subTextureElem = subTextureElem.GetNext("SubTexture");
}
loadXMLFile_.Reset();
loadTextureName_.Clear();
return true;
}
VariantMap XMLElement::GetVariantMap() const
{
VariantMap ret;
XMLElement variantElem = GetChild("variant");
while (variantElem)
{
// If this is a manually edited map, user can not be expected to calculate hashes manually. Also accept "name" attribute
if (variantElem.HasAttribute("name"))
ret[StringHash(variantElem.GetAttribute("name"))] = variantElem.GetVariant();
else if (variantElem.HasAttribute("hash"))
ret[StringHash(variantElem.GetUInt("hash"))] = variantElem.GetVariant();
variantElem = variantElem.GetNext("variant");
}
return ret;
}
bool Node::LoadXML(const XMLElement& source, SceneResolver& resolver, bool readChildren, bool rewriteIDs, CreateMode mode)
{
// Remove all children and components first in case this is not a fresh load
RemoveAllChildren();
RemoveAllComponents();
if (!Serializable::LoadXML(source))
return false;
XMLElement compElem = source.GetChild("component");
while (compElem)
{
String typeName = compElem.GetAttribute("type");
unsigned compID = compElem.GetInt("id");
Component* newComponent = CreateComponent(typeName,
(mode == REPLICATED && compID < FIRST_LOCAL_ID) ? REPLICATED : LOCAL, rewriteIDs ? 0 : compID);
if (newComponent)
{
resolver.AddComponent(compID, newComponent);
if (!newComponent->LoadXML(compElem))
return false;
}
compElem = compElem.GetNext("component");
}
if (!readChildren)
return true;
XMLElement childElem = source.GetChild("node");
while (childElem)
{
unsigned nodeID = childElem.GetInt("id");
Node* newNode = CreateChild(rewriteIDs ? 0 : nodeID, (mode == REPLICATED && nodeID < FIRST_LOCAL_ID) ? REPLICATED :
LOCAL);
resolver.AddNode(nodeID, newNode);
if (!newNode->LoadXML(childElem, resolver, readChildren, rewriteIDs, mode))
return false;
childElem = childElem.GetNext("node");
}
return true;
}
EditorIconCache::EditorIconCache(Context* context)
: Object(context)
{
ResourceCache* cache = ui::GetSystemUI()->GetSubsystem<ResourceCache>();
auto* icons = cache->GetResource<XMLFile>("UI/EditorIcons.xml");
if (icons == nullptr)
return;
XMLElement root = icons->GetRoot();
for (XMLElement element = root.GetChild("element"); element.NotNull(); element = element.GetNext("element"))
{
ea::string type = element.GetAttribute("type");
if (type.empty())
{
URHO3D_LOGERROR("EditorIconCache.xml contains icon entry without a \"type\" attribute.");
continue;
}
XPathResultSet texture = element.SelectPrepared(XPathQuery("attribute[@name=\"Texture\"]"));
if (texture.Empty())
{
URHO3D_LOGERROR("EditorIconCache.xml contains icon entry without a \"Texture\".");
continue;
}
XPathResultSet rect = element.SelectPrepared(XPathQuery("attribute[@name=\"Image Rect\"]"));
if (rect.Empty())
{
URHO3D_LOGERROR("EditorIconCache.xml contains icon entry without a \"Image Rect\".");
continue;
}
IconData data;
data.textureRef_ = texture.FirstResult().GetVariantValue(VAR_RESOURCEREF).GetResourceRef();
data.rect_ = rect.FirstResult().GetVariantValue(VAR_INTRECT).GetIntRect();
iconCache_[type] = data;
}
}
bool Texture3D::BeginLoad(Deserializer& source)
{
auto* cache = GetSubsystem<ResourceCache>();
// In headless mode, do not actually load the texture, just return success
if (!graphics_)
return true;
// If device is lost, retry later
if (graphics_->IsDeviceLost())
{
URHO3D_LOGWARNING("Texture load while device is lost");
dataPending_ = true;
return true;
}
String texPath, texName, texExt;
SplitPath(GetName(), texPath, texName, texExt);
cache->ResetDependencies(this);
loadParameters_ = new XMLFile(context_);
if (!loadParameters_->Load(source))
{
loadParameters_.Reset();
return false;
}
XMLElement textureElem = loadParameters_->GetRoot();
XMLElement volumeElem = textureElem.GetChild("volume");
XMLElement colorlutElem = textureElem.GetChild("colorlut");
if (volumeElem)
{
String name = volumeElem.GetAttribute("name");
String volumeTexPath, volumeTexName, volumeTexExt;
SplitPath(name, volumeTexPath, volumeTexName, volumeTexExt);
// If path is empty, add the XML file path
if (volumeTexPath.Empty())
name = texPath + name;
loadImage_ = cache->GetTempResource<Image>(name);
// Precalculate mip levels if async loading
if (loadImage_ && GetAsyncLoadState() == ASYNC_LOADING)
loadImage_->PrecalculateLevels();
cache->StoreResourceDependency(this, name);
return true;
}
else if (colorlutElem)
{
String name = colorlutElem.GetAttribute("name");
String colorlutTexPath, colorlutTexName, colorlutTexExt;
SplitPath(name, colorlutTexPath, colorlutTexName, colorlutTexExt);
// If path is empty, add the XML file path
if (colorlutTexPath.Empty())
name = texPath + name;
SharedPtr<File> file = GetSubsystem<ResourceCache>()->GetFile(name);
loadImage_ = new Image(context_);
if (!loadImage_->LoadColorLUT(*(file.Get())))
{
loadParameters_.Reset();
loadImage_.Reset();
return false;
}
// Precalculate mip levels if async loading
if (loadImage_ && GetAsyncLoadState() == ASYNC_LOADING)
loadImage_->PrecalculateLevels();
cache->StoreResourceDependency(this, name);
return true;
}
URHO3D_LOGERROR("Texture3D XML data for " + GetName() + " did not contain either volume or colorlut element");
return false;
}
bool SpriteSheet2D::Load(Deserializer& source)
{
spriteMapping_.Clear();
SharedPtr<XMLFile> xmlFile(new XMLFile(context_));
if(!xmlFile->Load(source))
{
LOGERROR("Could not load sprite sheet");
return false;
}
SetMemoryUse(source.GetSize());
XMLElement rootElem = xmlFile->GetRoot();
if (!rootElem)
{
LOGERROR("Invalid sprite sheet");
return false;
}
if (rootElem.GetName() == "spritesheet")
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
String textureFileName = rootElem.GetAttribute("texture");
texture_ = cache->GetResource<Texture2D>(textureFileName, false);
// If texture not found, try get in current directory
if (!texture_)
texture_ = cache->GetResource<Texture2D>(GetParentPath(GetName()) + textureFileName);
if (!texture_)
{
LOGERROR("Cound not load texture");
return false;
}
XMLElement spriteElem = rootElem.GetChild("sprite");
while (spriteElem)
{
String name = spriteElem.GetAttribute("name");
IntRect rectangle = spriteElem.GetIntRect("rectangle");
Vector2 hotSpot(0.5f, 0.5f);
if (spriteElem.HasAttribute("hotspot"))
hotSpot = spriteElem.GetVector2("hotspot");
DefineSprite(name, rectangle, hotSpot);
spriteElem = spriteElem.GetNext("sprite");
}
}
// Sparrow Starling texture atlas
else if (rootElem.GetName() == "TextureAtlas")
{
String textureFileName = rootElem.GetAttribute("imagePath");
ResourceCache* cache = GetSubsystem<ResourceCache>();
texture_ = cache->GetResource<Texture2D>(textureFileName, false);
// If texture not found, try get in current directory
if (!texture_)
texture_ = cache->GetResource<Texture2D>(GetParentPath(GetName()) + textureFileName);
if (!texture_)
{
LOGERROR("Cound not load texture");
return false;
}
XMLElement subTextureElem = rootElem.GetChild("SubTexture");
while (subTextureElem)
{
String name = subTextureElem.GetAttribute("name");
int x = subTextureElem.GetInt("x");
int y = subTextureElem.GetInt("y");
int width = subTextureElem.GetInt("width");
int height = subTextureElem.GetInt("height");
IntRect rectangle(x, y, x + width, y + height);
Vector2 hotSpot(0.5f, 0.5f);
if (subTextureElem.HasAttribute("frameWidth") && subTextureElem.HasAttribute("frameHeight"))
{
int frameX = subTextureElem.GetInt("frameX");
int frameY = subTextureElem.GetInt("frameY");
int frameWidth = subTextureElem.GetInt("frameWidth");
int frameHeight = subTextureElem.GetInt("frameHeight");
hotSpot.x_ = ((float)frameX + frameWidth / 2) / width;
hotSpot.y_ = 1.0f - ((float)frameY + frameHeight / 2) / height;
}
DefineSprite(name, rectangle, hotSpot);
subTextureElem = subTextureElem.GetNext("SubTexture");
}
}
else
{
LOGERROR("Invalid sprite sheet file");
return false;
}
return true;
}
bool Technique::BeginLoad(Deserializer& source)
{
passes_.Clear();
SetMemoryUse(sizeof(Technique));
SharedPtr<XMLFile> xml(new XMLFile(context_));
if (!xml->Load(source))
return false;
XMLElement rootElem = xml->GetRoot();
if (rootElem.HasAttribute("sm3"))
isSM3_ = rootElem.GetBool("sm3");
String globalVS = rootElem.GetAttribute("vs");
String globalPS = rootElem.GetAttribute("ps");
String globalVSDefines = rootElem.GetAttribute("vsdefines");
String globalPSDefines = rootElem.GetAttribute("psdefines");
// End with space so that the pass-specific defines can be appended
if (!globalVSDefines.Empty())
globalVSDefines += ' ';
if (!globalPSDefines.Empty())
globalPSDefines += ' ';
bool globalAlphaMask = false;
if (rootElem.HasAttribute("alphamask"))
globalAlphaMask = rootElem.GetBool("alphamask");
unsigned numPasses = 0;
XMLElement passElem = rootElem.GetChild("pass");
while (passElem)
{
if (passElem.HasAttribute("name"))
{
StringHash nameHash(passElem.GetAttribute("name"));
Pass* newPass = CreatePass(nameHash);
++numPasses;
if (passElem.HasAttribute("sm3"))
newPass->SetIsSM3(passElem.GetBool("sm3"));
// Append global defines only when pass does not redefine the shader
if (passElem.HasAttribute("vs"))
{
newPass->SetVertexShader(passElem.GetAttribute("vs"));
newPass->SetVertexShaderDefines(passElem.GetAttribute("vsdefines"));
}
else
{
newPass->SetVertexShader(globalVS);
newPass->SetVertexShaderDefines(globalVSDefines + passElem.GetAttribute("vsdefines"));
}
if (passElem.HasAttribute("ps"))
{
newPass->SetPixelShader(passElem.GetAttribute("ps"));
newPass->SetPixelShaderDefines(passElem.GetAttribute("psdefines"));
}
else
{
newPass->SetPixelShader(globalPS);
newPass->SetPixelShaderDefines(globalPSDefines + passElem.GetAttribute("psdefines"));
}
if (passElem.HasAttribute("lighting"))
{
String lighting = passElem.GetAttributeLower("lighting");
newPass->SetLightingMode((PassLightingMode)GetStringListIndex(lighting.CString(), lightingModeNames,
LIGHTING_UNLIT));
}
if (passElem.HasAttribute("blend"))
{
String blend = passElem.GetAttributeLower("blend");
newPass->SetBlendMode((BlendMode)GetStringListIndex(blend.CString(), blendModeNames, BLEND_REPLACE));
}
if (passElem.HasAttribute("depthtest"))
{
String depthTest = passElem.GetAttributeLower("depthtest");
if (depthTest == "false")
newPass->SetDepthTestMode(CMP_ALWAYS);
else
newPass->SetDepthTestMode((CompareMode)GetStringListIndex(depthTest.CString(), compareModeNames, CMP_LESS));
}
if (passElem.HasAttribute("depthwrite"))
newPass->SetDepthWrite(passElem.GetBool("depthwrite"));
if (passElem.HasAttribute("alphamask"))
newPass->SetAlphaMask(passElem.GetBool("alphamask"));
else
newPass->SetAlphaMask(globalAlphaMask);
}
else
LOGERROR("Missing pass name");
passElem = passElem.GetNext("pass");
}
// Calculate memory use now
SetMemoryUse(sizeof(Technique) + numPasses * sizeof(Pass));
return true;
}
bool Technique::BeginLoad(Deserializer& source)
{
passes_.clear();
cloneTechniques_.clear();
SetMemoryUse(sizeof(Technique));
ea::shared_ptr<XMLFile> xml(context_->CreateObject<XMLFile>());
if (!xml->Load(source))
return false;
XMLElement rootElem = xml->GetRoot();
if (rootElem.HasAttribute("desktop"))
isDesktop_ = rootElem.GetBool("desktop");
ea::string globalVS = rootElem.GetAttribute("vs");
ea::string globalPS = rootElem.GetAttribute("ps");
ea::string globalVSDefines = rootElem.GetAttribute("vsdefines");
ea::string globalPSDefines = rootElem.GetAttribute("psdefines");
// End with space so that the pass-specific defines can be appended
if (!globalVSDefines.empty())
globalVSDefines += ' ';
if (!globalPSDefines.empty())
globalPSDefines += ' ';
XMLElement passElem = rootElem.GetChild("pass");
while (passElem)
{
if (passElem.HasAttribute("name"))
{
Pass* newPass = CreatePass(passElem.GetAttribute("name"));
if (passElem.HasAttribute("desktop"))
newPass->SetIsDesktop(passElem.GetBool("desktop"));
// Append global defines only when pass does not redefine the shader
if (passElem.HasAttribute("vs"))
{
newPass->SetVertexShader(passElem.GetAttribute("vs"));
newPass->SetVertexShaderDefines(passElem.GetAttribute("vsdefines"));
}
else
{
newPass->SetVertexShader(globalVS);
newPass->SetVertexShaderDefines(globalVSDefines + passElem.GetAttribute("vsdefines"));
}
if (passElem.HasAttribute("ps"))
{
newPass->SetPixelShader(passElem.GetAttribute("ps"));
newPass->SetPixelShaderDefines(passElem.GetAttribute("psdefines"));
}
else
{
newPass->SetPixelShader(globalPS);
newPass->SetPixelShaderDefines(globalPSDefines + passElem.GetAttribute("psdefines"));
}
newPass->SetVertexShaderDefineExcludes(passElem.GetAttribute("vsexcludes"));
newPass->SetPixelShaderDefineExcludes(passElem.GetAttribute("psexcludes"));
if (passElem.HasAttribute("lighting"))
{
ea::string lighting = passElem.GetAttributeLower("lighting");
newPass->SetLightingMode((PassLightingMode)GetStringListIndex(lighting.c_str(), lightingModeNames,
LIGHTING_UNLIT));
}
if (passElem.HasAttribute("blend"))
{
ea::string blend = passElem.GetAttributeLower("blend");
newPass->SetBlendMode((BlendMode)GetStringListIndex(blend.c_str(), blendModeNames, BLEND_REPLACE));
}
if (passElem.HasAttribute("cull"))
{
ea::string cull = passElem.GetAttributeLower("cull");
newPass->SetCullMode((CullMode)GetStringListIndex(cull.c_str(), cullModeNames, MAX_CULLMODES));
}
if (passElem.HasAttribute("depthtest"))
{
ea::string depthTest = passElem.GetAttributeLower("depthtest");
if (depthTest == "false")
newPass->SetDepthTestMode(CMP_ALWAYS);
else
newPass->SetDepthTestMode((CompareMode)GetStringListIndex(depthTest.c_str(), compareModeNames, CMP_LESS));
}
if (passElem.HasAttribute("depthwrite"))
newPass->SetDepthWrite(passElem.GetBool("depthwrite"));
if (passElem.HasAttribute("alphatocoverage"))
newPass->SetAlphaToCoverage(passElem.GetBool("alphatocoverage"));
}
else
URHO3D_LOGERROR("Missing pass name");
passElem = passElem.GetNext("pass");
}
return true;
}
void PropertySet2D::Load(const XMLElement& element)
{
assert(element.GetName() == "properties");
for (XMLElement propertyElem = element.GetChild("property"); propertyElem; propertyElem = propertyElem.GetNext("property"))
nameToValueMapping_[propertyElem.GetAttribute("name")] = propertyElem.GetAttribute("value");
}
bool Menu::LoadXML(const XMLElement& source, XMLFile* styleFile)
{
// Apply the style first, but only for non-internal elements
if (!internal_ && styleFile)
{
// Use style override if defined, otherwise type name
String styleName = source.GetAttribute("style");
if (styleName.Empty())
styleName = GetTypeName();
SetStyle(styleFile, styleName);
}
// Then load rest of the attributes from the source
if (!Serializable::LoadXML(source))
return false;
unsigned nextInternalChild = 0;
// Load child elements. Internal elements are not to be created as they already exist
XMLElement childElem = source.GetChild("element");
while (childElem)
{
bool internalElem = childElem.GetBool("internal");
bool popupElem = childElem.GetBool("popup");
String typeName = childElem.GetAttribute("type");
if (typeName.Empty())
typeName = "UIElement";
UIElement* child = 0;
if (!internalElem)
{
if (!popupElem)
child = CreateChild(ShortStringHash(typeName));
else
{
// Do not add the popup element as a child even temporarily, as that can break layouts
SharedPtr<UIElement> popup = DynamicCast<UIElement>(context_->CreateObject(ShortStringHash(typeName)));
if (!popup)
LOGERROR("Could not create popup element type " + ShortStringHash(typeName).ToString());
else
{
child = popup;
SetPopup(popup);
}
}
}
else
{
// An internal popup element should already exist
if (popupElem)
child = popup_;
else
{
for (unsigned i = nextInternalChild; i < children_.Size(); ++i)
{
if (children_[i]->IsInternal() && children_[i]->GetTypeName() == typeName)
{
child = children_[i];
nextInternalChild = i + 1;
break;
}
}
if (!child)
LOGWARNING("Could not find matching internal child element of type " + typeName + " in " + GetTypeName());
}
}
if (child)
{
if (!child->LoadXML(childElem, styleFile))
return false;
}
childElem = childElem.GetNext("element");
}
ApplyAttributes();
return true;
}
