//==============================================================================
void Material::load(const CString& filename, ResourceInitializer& init)
{
try
{
m_vars = std::move(ResourceVector<MaterialVariable*>(init.m_alloc));
Dictionary<MaterialVariable*> dict(10,
Dictionary<MaterialVariable*>::hasher(),
Dictionary<MaterialVariable*>::key_equal(),
init.m_alloc);
m_varDict = std::move(dict);
m_progs =
std::move(ResourceVector<ProgramResourcePointer>(init.m_alloc));
m_pplines =
std::move(ResourceVector<GlProgramPipelineHandle>(init.m_alloc));
XmlDocument doc;
doc.loadFile(filename, init.m_tempAlloc);
parseMaterialTag(doc.getChildElement("material"), init);
}
catch(std::exception& e)
{
throw ANKI_EXCEPTION("Failed to load material") << e;
}
}
Error CollisionResource::load(const ResourceFilename& filename)
{
XmlElement el;
XmlDocument doc;
ANKI_CHECK(openFileParseXml(filename, doc));
XmlElement collEl;
ANKI_CHECK(doc.getChildElement("collisionShape", collEl));
ANKI_CHECK(collEl.getChildElement("type", el));
CString type;
ANKI_CHECK(el.getText(type));
XmlElement valEl;
ANKI_CHECK(collEl.getChildElement("value", valEl));
PhysicsWorld& physics = getManager().getPhysicsWorld();
PhysicsCollisionShapeInitInfo csInit;
if(type == "sphere")
{
F64 tmp;
ANKI_CHECK(valEl.getF64(tmp));
m_physicsShape = physics.newInstance<PhysicsSphere>(csInit, tmp);
}
else if(type == "box")
{
Vec3 extend;
ANKI_CHECK(valEl.getVec3(extend));
m_physicsShape = physics.newInstance<PhysicsBox>(csInit, extend);
}
else if(type == "staticMesh")
{
CString meshfname;
ANKI_CHECK(valEl.getText(meshfname));
MeshLoader loader(&getManager());
ANKI_CHECK(loader.load(meshfname));
m_physicsShape = physics.newInstance<PhysicsTriangleSoup>(csInit,
reinterpret_cast<const Vec3*>(loader.getVertexData()),
loader.getVertexSize(),
reinterpret_cast<const U16*>(loader.getIndexData()),
loader.getHeader().m_totalIndicesCount);
}
else
{
ANKI_LOGE("Incorrect collision type");
return ErrorCode::USER_DATA;
}
return ErrorCode::NONE;
}
//==============================================================================
Error Material::load(const CString& filename, ResourceInitializer& init)
{
Error err = ErrorCode::NONE;
m_resources = &init.m_resources;
XmlDocument doc;
ANKI_CHECK(doc.loadFile(filename, init.m_tempAlloc));
XmlElement el;
ANKI_CHECK(doc.getChildElement("material", el));
ANKI_CHECK(parseMaterialTag(el , init));
return err;
}
Error Skeleton::load(const ResourceFilename& filename)
{
XmlDocument doc;
ANKI_CHECK(openFileParseXml(filename, doc));
XmlElement rootEl;
ANKI_CHECK(doc.getChildElement("skeleton", rootEl));
XmlElement bonesEl;
ANKI_CHECK(rootEl.getChildElement("bones", bonesEl));
// count the bones count
XmlElement boneEl;
U32 bonesCount = 0;
ANKI_CHECK(bonesEl.getChildElement("bone", boneEl));
ANKI_CHECK(boneEl.getSiblingElementsCount(bonesCount));
++bonesCount;
m_bones.create(getAllocator(), bonesCount);
// Load every bone
bonesCount = 0;
do
{
Bone& bone = m_bones[bonesCount++];
// <name>
XmlElement nameEl;
ANKI_CHECK(boneEl.getChildElement("name", nameEl));
CString tmp;
ANKI_CHECK(nameEl.getText(tmp));
bone.m_name.create(getAllocator(), tmp);
// <transform>
XmlElement trfEl;
ANKI_CHECK(boneEl.getChildElement("transform", trfEl));
ANKI_CHECK(trfEl.getMat4(bone.m_transform));
// Advance
ANKI_CHECK(boneEl.getNextSiblingElement("bone", boneEl));
} while(boneEl);
return ErrorCode::NONE;
}
//==============================================================================
void Skeleton::load(const CString& filename, ResourceInitializer& init)
{
XmlDocument doc;
doc.loadFile(filename, init.m_tempAlloc);
XmlElement rootEl = doc.getChildElement("skeleton");
XmlElement bonesEl = rootEl.getChildElement("bones");
// count the bones count
U bonesCount = 0;
XmlElement boneEl = bonesEl.getChildElement("bone");
do
{
++bonesCount;
boneEl = boneEl.getNextSiblingElement("bone");
} while(boneEl);
// Alloc the vector
m_bones = std::move(ResourceVector<Bone>(init.m_alloc));
m_bones.resize(bonesCount, Bone(init.m_alloc));
// Load every bone
boneEl = bonesEl.getChildElement("bone");
bonesCount = 0;
do
{
Bone& bone = m_bones[bonesCount++];
// <name>
XmlElement nameEl = boneEl.getChildElement("name");
bone.m_name = nameEl.getText();
// <transform>
XmlElement trfEl = boneEl.getChildElement("transform");
bone.m_transform = trfEl.getMat4();
// Advance
boneEl = boneEl.getNextSiblingElement("bone");
} while(boneEl);
}
//==============================================================================
Error ParticleEmitterResource::load(const CString& filename)
{
U32 tmp;
XmlDocument doc;
ANKI_CHECK(doc.loadFile(filename, getTempAllocator()));
XmlElement rel; // Root element
ANKI_CHECK(doc.getChildElement("particleEmitter", rel));
// XML load
//
ANKI_CHECK(xmlF32(rel, "life", m_particle.m_life));
ANKI_CHECK(xmlF32(rel, "lifeDeviation", m_particle.m_lifeDeviation));
ANKI_CHECK(xmlF32(rel, "mass", m_particle.m_mass));
ANKI_CHECK(xmlF32(rel, "massDeviation", m_particle.m_massDeviation));
ANKI_CHECK(xmlF32(rel, "size", m_particle.m_size));
ANKI_CHECK(xmlF32(rel, "sizeDeviation", m_particle.m_sizeDeviation));
ANKI_CHECK(xmlF32(rel, "sizeAnimation", m_particle.m_sizeAnimation));
ANKI_CHECK(xmlF32(rel, "alpha", m_particle.m_alpha));
ANKI_CHECK(xmlF32(rel, "alphaDeviation", m_particle.m_alphaDeviation));
tmp = m_particle.m_alphaAnimation;
ANKI_CHECK(xmlU32(rel, "alphaAnimationEnabled", tmp));
m_particle.m_alphaAnimation = tmp;
ANKI_CHECK(xmlVec3(rel, "forceDirection", m_particle.m_forceDirection));
ANKI_CHECK(xmlVec3(rel, "forceDirectionDeviation",
m_particle.m_forceDirectionDeviation));
ANKI_CHECK(xmlF32(rel, "forceMagnitude", m_particle.m_forceMagnitude));
ANKI_CHECK(xmlF32(rel, "forceMagnitudeDeviation",
m_particle.m_forceMagnitudeDeviation));
ANKI_CHECK(xmlVec3(rel, "gravity", m_particle.m_gravity));
ANKI_CHECK(xmlVec3(rel, "gravityDeviation", m_particle.m_gravityDeviation));
ANKI_CHECK(xmlVec3(rel, "startingPosition", m_particle.m_startingPos));
ANKI_CHECK(xmlVec3(rel, "startingPositionDeviation",
m_particle.m_startingPosDeviation));
ANKI_CHECK(xmlU32(rel, "maxNumberOfParticles", m_maxNumOfParticles));
ANKI_CHECK(xmlF32(rel, "emissionPeriod", m_emissionPeriod));
ANKI_CHECK(xmlU32(rel, "particlesPerEmittion", m_particlesPerEmittion));
tmp = m_usePhysicsEngine;
ANKI_CHECK(xmlU32(rel, "usePhysicsEngine", tmp));
m_usePhysicsEngine = tmp;
XmlElement el;
CString cstr;
ANKI_CHECK(rel.getChildElement("material", el));
ANKI_CHECK(el.getText(cstr));
ANKI_CHECK(m_material.load(cstr, &getManager()));
// sanity checks
//
static const char* ERROR = "Particle emmiter: "
"Incorrect or missing value %s";
if(m_particle.m_life <= 0.0)
{
ANKI_LOGE(ERROR, "life");
return ErrorCode::USER_DATA;
}
if(m_particle.m_life - m_particle.m_lifeDeviation <= 0.0)
{
ANKI_LOGE(ERROR, "lifeDeviation");
return ErrorCode::USER_DATA;
}
if(m_particle.m_size <= 0.0)
{
ANKI_LOGE(ERROR, "size");
return ErrorCode::USER_DATA;
}
if(m_maxNumOfParticles < 1)
{
ANKI_LOGE(ERROR, "maxNumOfParticles");
return ErrorCode::USER_DATA;
}
if(m_emissionPeriod <= 0.0)
{
ANKI_LOGE(ERROR, "emissionPeriod");
return ErrorCode::USER_DATA;
}
if(m_particlesPerEmittion < 1)
{
ANKI_LOGE(ERROR, "particlesPerEmission");
return ErrorCode::USER_DATA;
}
// Calc some stuff
//
updateFlags();
return ErrorCode::NONE;
}
//==============================================================================
Error Animation::load(const ResourceFilename& filename)
{
XmlElement el;
I64 tmp;
F64 ftmp;
m_startTime = MAX_F32;
F32 maxTime = MIN_F32;
// Document
XmlDocument doc;
ANKI_CHECK(openFileParseXml(filename, doc));
XmlElement rootel;
ANKI_CHECK(doc.getChildElement("animation", rootel));
// Count the number of identity keys. If all of the keys are identities
// drop a vector
U identPosCount = 0;
U identRotCount = 0;
U identScaleCount = 0;
// <repeat>
XmlElement repel;
ANKI_CHECK(rootel.getChildElementOptional("repeat", repel));
if(repel)
{
ANKI_CHECK(repel.getI64(tmp));
m_repeat = tmp;
}
else
{
m_repeat = false;
}
// <channels>
XmlElement channelsEl;
ANKI_CHECK(rootel.getChildElement("channels", channelsEl));
XmlElement chEl;
ANKI_CHECK(channelsEl.getChildElement("channel", chEl));
U32 channelCount = 0;
ANKI_CHECK(chEl.getSiblingElementsCount(channelCount));
if(channelCount == 0)
{
ANKI_LOGE("Didn't found any channels");
return ErrorCode::USER_DATA;
}
m_channels.create(getAllocator(), channelCount);
// For all channels
channelCount = 0;
do
{
AnimationChannel& ch = m_channels[channelCount];
// <name>
ANKI_CHECK(chEl.getChildElement("name", el));
CString strtmp;
ANKI_CHECK(el.getText(strtmp));
ch.m_name.create(getAllocator(), strtmp);
XmlElement keysEl, keyEl;
// <positionKeys>
ANKI_CHECK(chEl.getChildElementOptional("positionKeys", keysEl));
if(keysEl)
{
ANKI_CHECK(keysEl.getChildElement("key", keyEl));
U32 count = 0;
ANKI_CHECK(keyEl.getSiblingElementsCount(count));
ch.m_positions.create(getAllocator(), count);
count = 0;
do
{
Key<Vec3>& key = ch.m_positions[count++];
// <time>
ANKI_CHECK(keyEl.getChildElement("time", el));
ANKI_CHECK(el.getF64(ftmp));
key.m_time = ftmp;
m_startTime = std::min(m_startTime, key.m_time);
maxTime = std::max(maxTime, key.m_time);
// <value>
ANKI_CHECK(keyEl.getChildElement("value", el));
ANKI_CHECK(el.getVec3(key.m_value));
// Check ident
if(key.m_value == Vec3(0.0))
{
++identPosCount;
}
// Move to next
ANKI_CHECK(keyEl.getNextSiblingElement("key", keyEl));
} while(keyEl);
}
// <rotationKeys>
ANKI_CHECK(chEl.getChildElement("rotationKeys", keysEl));
if(keysEl)
{
ANKI_CHECK(keysEl.getChildElement("key", keyEl));
U32 count = 0;
ANKI_CHECK(keysEl.getSiblingElementsCount(count));
ch.m_rotations.create(getAllocator(), count);
count = 0;
do
{
Key<Quat>& key = ch.m_rotations[count++];
// <time>
ANKI_CHECK(keyEl.getChildElement("time", el));
ANKI_CHECK(el.getF64(ftmp));
key.m_time = ftmp;
m_startTime = std::min(m_startTime, key.m_time);
maxTime = std::max(maxTime, key.m_time);
// <value>
Vec4 tmp2;
ANKI_CHECK(keyEl.getChildElement("value", el));
ANKI_CHECK(el.getVec4(tmp2));
key.m_value = Quat(tmp2);
// Check ident
if(key.m_value == Quat::getIdentity())
{
++identRotCount;
}
// Move to next
ANKI_CHECK(keyEl.getNextSiblingElement("key", keyEl));
} while(keyEl);
}
// <scalingKeys>
ANKI_CHECK(chEl.getChildElementOptional("scalingKeys", keysEl));
if(keysEl)
{
ANKI_CHECK(keysEl.getChildElement("key", keyEl));
U32 count = 0;
ANKI_CHECK(keyEl.getSiblingElementsCount(count));
ch.m_scales.create(getAllocator(), count);
count = 0;
do
{
Key<F32>& key = ch.m_scales[count++];
// <time>
ANKI_CHECK(keyEl.getChildElement("time", el));
ANKI_CHECK(el.getF64(ftmp));
key.m_time = ftmp;
m_startTime = std::min(m_startTime, key.m_time);
maxTime = std::max(maxTime, key.m_time);
// <value>
ANKI_CHECK(keyEl.getChildElement("value", el));
ANKI_CHECK(el.getF64(ftmp));
key.m_value = ftmp;
// Check ident
if(isZero(key.m_value - 1.0))
{
++identScaleCount;
}
// Move to next
ANKI_CHECK(keyEl.getNextSiblingElement("key", keyEl));
} while(keyEl);
}
// Remove identity vectors
if(identPosCount == ch.m_positions.getSize())
{
ch.m_positions.destroy(getAllocator());
}
if(identRotCount == ch.m_rotations.getSize())
{
ch.m_rotations.destroy(getAllocator());
}
if(identScaleCount == ch.m_scales.getSize())
{
ch.m_scales.destroy(getAllocator());
}
// Move to next channel
++channelCount;
ANKI_CHECK(chEl.getNextSiblingElement("channel", chEl));
} while(chEl);
m_duration = maxTime - m_startTime;
return ErrorCode::NONE;
}
Error TextureAtlasResource::load(const ResourceFilename& filename, Bool async)
{
XmlDocument doc;
ANKI_CHECK(openFileParseXml(filename, doc));
XmlElement rootel, el;
//
// <textureAtlas>
//
ANKI_CHECK(doc.getChildElement("textureAtlas", rootel));
//
// <texture>
//
ANKI_CHECK(rootel.getChildElement("texture", el));
CString texFname;
ANKI_CHECK(el.getText(texFname));
ANKI_CHECK(getManager().loadResource<TextureResource>(texFname, m_tex, async));
m_size[0] = m_tex->getWidth();
m_size[1] = m_tex->getHeight();
//
// <subTextureMargin>
//
ANKI_CHECK(rootel.getChildElement("subTextureMargin", el));
I64 margin = 0;
ANKI_CHECK(el.getNumber(margin));
if(margin >= I(m_tex->getWidth()) || margin >= I(m_tex->getHeight()) || margin < 0)
{
ANKI_RESOURCE_LOGE("Too big margin %d", U(margin));
return Error::USER_DATA;
}
m_margin = margin;
//
// <subTextures>
//
// Get counts
PtrSize namesSize = 0;
PtrSize subTexesCount = 0;
XmlElement subTexesEl, subTexEl;
ANKI_CHECK(rootel.getChildElement("subTextures", subTexesEl));
ANKI_CHECK(subTexesEl.getChildElement("subTexture", subTexEl));
do
{
ANKI_CHECK(subTexEl.getChildElement("name", el));
CString name;
ANKI_CHECK(el.getText(name));
if(name.getLength() < 1)
{
ANKI_RESOURCE_LOGE("Something wrong with the <name> tag. Probably empty");
return Error::USER_DATA;
}
namesSize += name.getLength() + 1;
++subTexesCount;
ANKI_CHECK(subTexEl.getNextSiblingElement("subTexture", subTexEl));
} while(subTexEl);
// Allocate
m_subTexNames.create(getAllocator(), namesSize);
m_subTexes.create(getAllocator(), subTexesCount);
// Iterate again and populate
subTexesCount = 0;
char* names = &m_subTexNames[0];
ANKI_CHECK(subTexesEl.getChildElement("subTexture", subTexEl));
do
{
ANKI_CHECK(subTexEl.getChildElement("name", el));
CString name;
ANKI_CHECK(el.getText(name));
memcpy(names, &name[0], name.getLength() + 1);
m_subTexes[subTexesCount].m_name = names;
ANKI_CHECK(subTexEl.getChildElement("uv", el));
Vec4 uv;
ANKI_CHECK(el.getVec4(uv));
m_subTexes[subTexesCount].m_uv = {{uv[0], uv[1], uv[2], uv[3]}};
names += name.getLength() + 1;
++subTexesCount;
ANKI_CHECK(subTexEl.getNextSiblingElement("subTexture", subTexEl));
} while(subTexEl);
return Error::NONE;
}
