bool UnknownComponent::LoadJSON(const JSONValue& source, bool setInstanceDefault)
{
useXML_ = true;
xmlAttributes_.Clear();
xmlAttributeInfos_.Clear();
binaryAttributes_.Clear();
JSONArray attributesArray = source.Get("attributes").GetArray();
for (unsigned i = 0; i < attributesArray.Size(); i++)
{
const JSONValue& attrVal = attributesArray.At(i);
AttributeInfo attr;
attr.mode_ = AM_FILE;
attr.name_ = attrVal.Get("name").GetString();
attr.type_ = VAR_STRING;
if (!attr.name_.Empty())
{
String attrValue = attrVal.Get("value").GetString();
attr.defaultValue_ = String::EMPTY;
xmlAttributeInfos_.Push(attr);
xmlAttributes_.Push(attrValue);
}
}
// 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 Animation::BeginLoad(Deserializer& source)
{
unsigned memoryUse = sizeof(Animation);
// Check ID
if (source.ReadFileID() != "UANI")
{
URHO3D_LOGERROR(source.GetName() + " is not a valid animation file");
return false;
}
// Read name and length
animationName_ = source.ReadString();
animationNameHash_ = animationName_;
length_ = source.ReadFloat();
tracks_.Clear();
unsigned tracks = source.ReadUInt();
memoryUse += tracks * sizeof(AnimationTrack);
// Read tracks
for (unsigned i = 0; i < tracks; ++i)
{
AnimationTrack* newTrack = CreateTrack(source.ReadString());
newTrack->channelMask_ = source.ReadUByte();
unsigned keyFrames = source.ReadUInt();
newTrack->keyFrames_.Resize(keyFrames);
memoryUse += keyFrames * sizeof(AnimationKeyFrame);
// Read keyframes of the track
for (unsigned j = 0; j < keyFrames; ++j)
{
AnimationKeyFrame& newKeyFrame = newTrack->keyFrames_[j];
newKeyFrame.time_ = source.ReadFloat();
if (newTrack->channelMask_ & CHANNEL_POSITION)
newKeyFrame.position_ = source.ReadVector3();
if (newTrack->channelMask_ & CHANNEL_ROTATION)
newKeyFrame.rotation_ = source.ReadQuaternion();
if (newTrack->channelMask_ & CHANNEL_SCALE)
newKeyFrame.scale_ = source.ReadVector3();
}
}
// Optionally read triggers from an XML file
ResourceCache* cache = GetSubsystem<ResourceCache>();
String xmlName = ReplaceExtension(GetName(), ".xml");
SharedPtr<XMLFile> file(cache->GetTempResource<XMLFile>(xmlName, false));
if (file)
{
XMLElement rootElem = file->GetRoot();
XMLElement triggerElem = rootElem.GetChild("trigger");
while (triggerElem)
{
if (triggerElem.HasAttribute("normalizedtime"))
AddTrigger(triggerElem.GetFloat("normalizedtime"), true, triggerElem.GetVariant());
else if (triggerElem.HasAttribute("time"))
AddTrigger(triggerElem.GetFloat("time"), false, triggerElem.GetVariant());
triggerElem = triggerElem.GetNext("trigger");
}
memoryUse += triggers_.Size() * sizeof(AnimationTriggerPoint);
SetMemoryUse(memoryUse);
return true;
}
// Optionally read triggers from a JSON file
String jsonName = ReplaceExtension(GetName(), ".json");
SharedPtr<JSONFile> jsonFile(cache->GetTempResource<JSONFile>(jsonName, false));
if (jsonFile)
{
const JSONValue& rootVal = jsonFile->GetRoot();
JSONArray triggerArray = rootVal.Get("triggers").GetArray();
for (unsigned i = 0; i < triggerArray.Size(); i++)
{
const JSONValue& triggerValue = triggerArray.At(i);
JSONValue normalizedTimeValue = triggerValue.Get("normalizedTime");
if (!normalizedTimeValue.IsNull())
AddTrigger(normalizedTimeValue.GetFloat(), true, triggerValue.GetVariant());
else
{
JSONValue timeVal = triggerValue.Get("time");
if (!timeVal.IsNull())
AddTrigger(timeVal.GetFloat(), false, triggerValue.GetVariant());
}
}
memoryUse += triggers_.Size() * sizeof(AnimationTriggerPoint);
SetMemoryUse(memoryUse);
return true;
}
SetMemoryUse(memoryUse);
return true;
}
void Scene::PreloadResourcesJSON(const JSONValue& value)
{
// If not threaded, can not background load resources, so rather load synchronously later when needed
#ifdef URHO3D_THREADING
ResourceCache* cache = GetSubsystem<ResourceCache>();
// Node or Scene attributes do not include any resources; therefore skip to the components
JSONArray componentArray = value.Get("components").GetArray();
for (unsigned i = 0; i < componentArray.Size(); i++)
{
const JSONValue& compValue = componentArray.At(i);
String typeName = compValue.Get("type").GetString();
const Vector<AttributeInfo>* attributes = context_->GetAttributes(StringHash(typeName));
if (attributes)
{
JSONArray attributesArray = compValue.Get("attributes").GetArray();
unsigned startIndex = 0;
for (unsigned j = 0; j < attributesArray.Size(); j++)
{
const JSONValue& attrVal = attributesArray.At(j);
String name = attrVal.Get("name").GetString();
unsigned i = startIndex;
unsigned attempts = attributes->Size();
while (attempts)
{
const AttributeInfo& attr = attributes->At(i);
if ((attr.mode_ & AM_FILE) && !attr.name_.Compare(name, true))
{
if (attr.type_ == VAR_RESOURCEREF)
{
ResourceRef ref = attrVal.Get("value").GetVariantValue(attr.type_).GetResourceRef();
String name = cache->SanitateResourceName(ref.name_);
bool success = cache->BackgroundLoadResource(ref.type_, name);
if (success)
{
++asyncProgress_.totalResources_;
asyncProgress_.resources_.Insert(StringHash(name));
}
}
else if (attr.type_ == VAR_RESOURCEREFLIST)
{
ResourceRefList refList = attrVal.Get("value").GetVariantValue(attr.type_).GetResourceRefList();
for (unsigned k = 0; k < refList.names_.Size(); ++k)
{
String name = cache->SanitateResourceName(refList.names_[k]);
bool success = cache->BackgroundLoadResource(refList.type_, name);
if (success)
{
++asyncProgress_.totalResources_;
asyncProgress_.resources_.Insert(StringHash(name));
}
}
}
startIndex = (i + 1) % attributes->Size();
break;
}
else
{
i = (i + 1) % attributes->Size();
--attempts;
}
}
}
}
}
JSONArray childrenArray = value.Get("children").GetArray();
for (unsigned i = 0; i < childrenArray.Size(); i++)
{
const JSONValue& childVal = childrenArray.At(i);
PreloadResourcesJSON(childVal);
}
#endif
}
