bool XMLElement::SetVariantValue(const Variant& value)
{
switch (value.GetType())
{
case VAR_RESOURCEREF:
return SetResourceRef(value.GetResourceRef());
case VAR_RESOURCEREFLIST:
return SetResourceRefList(value.GetResourceRefList());
case VAR_VARIANTVECTOR:
return SetVariantVector(value.GetVariantVector());
case VAR_VARIANTMAP:
return SetVariantMap(value.GetVariantMap());
default:
return SetAttribute("value", value.ToString().CString());
}
}
void JSONValue::AddVariantValue(const Variant& value)
{
switch (value.GetType())
{
case VAR_RESOURCEREF:
AddResourceRef(value.GetResourceRef());
break;
case VAR_RESOURCEREFLIST:
AddResourceRefList(value.GetResourceRefList());
break;
case VAR_VARIANTVECTOR:
case VAR_VARIANTMAP:
LOGERROR("Unsupported value type");
break;
default:
AddString(value.ToString());
}
}
void ScriptInstance::OnSetAttribute(const AttributeInfo& attr, const Variant& src)
{
if (attr.mode_ & (AM_NODEID | AM_COMPONENTID))
{
// The component / node to which the ID refers to may not be in the scene yet, and furthermore the ID must go through the
// SceneResolver first. Delay searching for the object to ApplyAttributes
AttributeInfo* attrPtr = const_cast<AttributeInfo*>(&attr);
idAttributes_[attrPtr] = src.GetUInt();
}
else if (attr.type_ == VAR_RESOURCEREF && attr.ptr_)
{
Resource*& resourcePtr = *(reinterpret_cast<Resource**>(attr.ptr_));
// Decrease reference count of the old object if any, then increment the new
if (resourcePtr)
resourcePtr->ReleaseRef();
const ResourceRef& ref = src.GetResourceRef();
resourcePtr = GetSubsystem<ResourceCache>()->GetResource(ref.type_, ref.name_);
if (resourcePtr)
resourcePtr->AddRef();
}
else
Serializable::OnSetAttribute(attr, src);
}
bool Serializer::WriteVariantData(const Variant& value)
{
switch (value.GetType())
{
case VAR_NONE:
return true;
case VAR_INT:
return WriteInt(value.GetInt());
case VAR_BOOL:
return WriteBool(value.GetBool());
case VAR_FLOAT:
return WriteFloat(value.GetFloat());
case VAR_VECTOR2:
return WriteVector2(value.GetVector2());
case VAR_VECTOR3:
return WriteVector3(value.GetVector3());
case VAR_VECTOR4:
return WriteVector4(value.GetVector4());
case VAR_QUATERNION:
return WriteQuaternion(value.GetQuaternion());
case VAR_COLOR:
return WriteColor(value.GetColor());
case VAR_STRING:
return WriteString(value.GetString());
case VAR_BUFFER:
return WriteBuffer(value.GetBuffer());
// Serializing pointers is not supported. Write null
case VAR_VOIDPTR:
case VAR_PTR:
return WriteUInt(0);
case VAR_RESOURCEREF:
return WriteResourceRef(value.GetResourceRef());
case VAR_RESOURCEREFLIST:
return WriteResourceRefList(value.GetResourceRefList());
case VAR_VARIANTVECTOR:
return WriteVariantVector(value.GetVariantVector());
case VAR_VARIANTMAP:
return WriteVariantMap(value.GetVariantMap());
case VAR_INTRECT:
return WriteIntRect(value.GetIntRect());
case VAR_INTVECTOR2:
return WriteIntVector2(value.GetIntVector2());
case VAR_MATRIX3:
return WriteMatrix3(value.GetMatrix3());
case VAR_MATRIX3X4:
return WriteMatrix3x4(value.GetMatrix3x4());
case VAR_MATRIX4:
return WriteMatrix4(value.GetMatrix4());
default:
return false;
}
}
void JSONValue::SetVariantValue(const Variant& variant, Context* context)
{
if (!IsNull())
{
LOGWARNING("JsonValue is not null");
}
switch (variant.GetType())
{
case VAR_BOOL:
*this = variant.GetBool();
return;
case VAR_INT:
*this = variant.GetInt();
return;
case VAR_FLOAT:
*this = variant.GetFloat();
return;
case VAR_DOUBLE:
*this = variant.GetDouble();
return;
case VAR_STRING:
*this = variant.GetString();
return;
case VAR_VARIANTVECTOR:
SetVariantVector(variant.GetVariantVector(), context);
return;
case VAR_VARIANTMAP:
SetVariantMap(variant.GetVariantMap(), context);
return;
case VAR_RESOURCEREF:
{
if (!context)
{
LOGERROR("Context must not null for ResourceRef");
return;
}
const ResourceRef& ref = variant.GetResourceRef();
*this = String(context->GetTypeName(ref.type_)) + ";" + ref.name_;
}
return;
case VAR_RESOURCEREFLIST:
{
if (!context)
{
LOGERROR("Context must not null for ResourceRefList");
return;
}
const ResourceRefList& refList = variant.GetResourceRefList();
String str(context->GetTypeName(refList.type_));
for (unsigned i = 0; i < refList.names_.Size(); ++i)
{
str += ";";
str += refList.names_[i];
}
*this = str;
}
return;
case VAR_STRINGVECTOR:
{
const StringVector& vector = variant.GetStringVector();
Resize(vector.Size());
for (unsigned i = 0; i < vector.Size(); ++i)
(*this)[i] = vector[i];
}
return;
default:
*this = variant.ToString();
}
}
void Scene::PreloadResources(File* file, bool isSceneFile)
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
// Read node ID (not needed)
/*unsigned nodeID = */file->ReadUInt();
// Read Node or Scene attributes; these do not include any resources
const Vector<AttributeInfo>* attributes = context_->GetAttributes(isSceneFile ? Scene::GetTypeStatic() : Node::GetTypeStatic());
assert(attributes);
for (unsigned i = 0; i < attributes->Size(); ++i)
{
const AttributeInfo& attr = attributes->At(i);
if (!(attr.mode_ & AM_FILE))
continue;
Variant varValue = file->ReadVariant(attr.type_);
}
// Read component attributes
unsigned numComponents = file->ReadVLE();
for (unsigned i = 0; i < numComponents; ++i)
{
VectorBuffer compBuffer(*file, file->ReadVLE());
StringHash compType = compBuffer.ReadStringHash();
// Read component ID (not needed)
/*unsigned compID = */compBuffer.ReadUInt();
attributes = context_->GetAttributes(compType);
if (attributes)
{
for (unsigned j = 0; j < attributes->Size(); ++j)
{
const AttributeInfo& attr = attributes->At(j);
if (!(attr.mode_ & AM_FILE))
continue;
Variant varValue = compBuffer.ReadVariant(attr.type_);
if (attr.type_ == VAR_RESOURCEREF)
{
const ResourceRef& ref = varValue.GetResourceRef();
// Sanitate resource name beforehand so that when we get the background load event, the name matches exactly
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)
{
const ResourceRefList& refList = varValue.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));
}
}
}
}
}
}
// Read child nodes
unsigned numChildren = file->ReadVLE();
for (unsigned i = 0; i < numChildren; ++i)
PreloadResources(file, false);
}
