//==============================================================================
static ANKI_USE_RESULT Error xmlU32(
const XmlElement& el_, const CString& str, U32& out)
{
Error err = ErrorCode::NONE;
XmlElement el;
err = el_.getChildElementOptional(str, el);
if(err || !el)
{
return err;
}
I64 tmp;
err = el.getI64(tmp);
if(!err)
{
out = static_cast<U32>(tmp);
}
return err;
}
//==============================================================================
Error Material::parseMaterialTag(const XmlElement& materialEl,
ResourceInitializer& rinit)
{
Error err = ErrorCode::NONE;
XmlElement el;
// levelsOfDetail
//
XmlElement lodEl;
ANKI_CHECK(materialEl.getChildElementOptional("levelsOfDetail", lodEl));
if(lodEl)
{
I64 tmp;
ANKI_CHECK(lodEl.getI64(tmp));
m_lodsCount = (tmp < 1) ? 1 : tmp;
}
else
{
m_lodsCount = 1;
}
// shadow
//
XmlElement shadowEl;
ANKI_CHECK(materialEl.getChildElementOptional("shadow", shadowEl));
if(shadowEl)
{
I64 tmp;
ANKI_CHECK(shadowEl.getI64(tmp));
m_shadow = tmp;
}
// blendFunctions
//
XmlElement blendFunctionsEl;
ANKI_CHECK(
materialEl.getChildElementOptional("blendFunctions", blendFunctionsEl));
if(blendFunctionsEl)
{
CString cstr;
// sFactor
ANKI_CHECK(blendFunctionsEl.getChildElement("sFactor", el));
ANKI_CHECK(el.getText(cstr));
m_blendingSfactor = blendToEnum(cstr);
if(m_blendingSfactor == 0)
{
return ErrorCode::USER_DATA;
}
// dFactor
ANKI_CHECK(blendFunctionsEl.getChildElement("dFactor", el));
ANKI_CHECK(el.getText(cstr));
m_blendingDfactor = blendToEnum(cstr);
if(m_blendingDfactor == 0)
{
return ErrorCode::USER_DATA;
}
}
else
{
m_passesCount = 2;
}
// depthTesting
//
XmlElement depthTestingEl;
ANKI_CHECK(
materialEl.getChildElementOptional("depthTesting", depthTestingEl));
if(depthTestingEl)
{
I64 tmp;
ANKI_CHECK(depthTestingEl.getI64(tmp));
m_depthTesting = tmp;
}
// wireframe
//
XmlElement wireframeEl;
ANKI_CHECK(materialEl.getChildElementOptional("wireframe", wireframeEl));
if(wireframeEl)
{
I64 tmp;
ANKI_CHECK(wireframeEl.getI64(tmp));
m_wireframe = tmp;
}
// shaderProgram
//
ANKI_CHECK(materialEl.getChildElement("programs", el));
MaterialProgramCreator loader(rinit.m_tempAlloc);
ANKI_CHECK(loader.parseProgramsTag(el));
m_tessellation = loader.hasTessellation();
U tessCount = m_tessellation ? 2 : 1;
// Alloc program vector
ANKI_CHECK(m_progs.create(rinit.m_alloc,
countShaders(ShaderType::VERTEX)
+ countShaders(ShaderType::TESSELLATION_CONTROL)
+ countShaders(ShaderType::TESSELLATION_EVALUATION)
+ countShaders(ShaderType::GEOMETRY)
+ countShaders(ShaderType::FRAGMENT)));
// Aloc progam descriptors
m_pplines.resize(m_passesCount * m_lodsCount * tessCount);
m_hash = 0;
for(ShaderType shader = ShaderType::VERTEX;
shader <= ShaderType::FRAGMENT;
++shader)
{
Bool isTessellationShader = shader == ShaderType::TESSELLATION_CONTROL
|| shader == ShaderType::TESSELLATION_EVALUATION;
if(!m_tessellation && isTessellationShader)
{
// Skip tessellation if not enabled
continue;
}
if(shader == ShaderType::GEOMETRY)
{
// Skip geometry for now
continue;
}
for(U level = 0; level < m_lodsCount; ++level)
{
if(level > 0 && isTessellationShader)
{
continue;
}
for(U pid = 0; pid < m_passesCount; ++pid)
{
for(U tess = 0; tess < tessCount; ++tess)
{
if(tess == 0 && isTessellationShader)
{
continue;
}
if(tess > 0 && shader == ShaderType::FRAGMENT)
{
continue;
}
TempResourceString src;
TempResourceString::ScopeDestroyer srcd(
&src, rinit.m_tempAlloc);
ANKI_CHECK(src.sprintf(
rinit.m_tempAlloc,
"%s\n"
"#define LOD %u\n"
"#define PASS %u\n"
"#define TESSELLATION %u\n"
"%s\n",
&rinit.m_resources._getShadersPrependedSource()[0],
level, pid, tess, &loader.getProgramSource(shader)[0]));
TempResourceString filename;
TempResourceString::ScopeDestroyer filenamed(
&filename, rinit.m_tempAlloc);
ANKI_CHECK(createProgramSourceToCache(src, filename));
RenderingKey key((Pass)pid, level, tess);
ProgramResourcePointer& progr = getProgram(key, shader);
ANKI_CHECK(
progr.load(filename.toCString(), &rinit.m_resources));
// Update the hash
m_hash ^= computeHash(&src[0], src.getLength());
}
}
}
}
ANKI_CHECK(populateVariables(loader));
// Get uniform block size
ANKI_ASSERT(m_progs.getSize() > 0);
m_shaderBlockSize = loader.getUniformBlockSize();
return err;
}
//==============================================================================
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;
}
