//--------------------------------------------------
//--------------------------------------------------
template <> Vector4 GetAttributeValue<Vector4>(const XML::Node* in_node, const std::string& in_attributeName, const Vector4& in_defaultValue)
{
for(rapidxml::xml_attribute<>* attribute = in_node->first_attribute(); attribute != nullptr; attribute = attribute->next_attribute())
{
if (GetName(attribute) == in_attributeName)
{
return ParseVector4(GetValue(attribute));
}
}
return in_defaultValue;
}
int ParseMaterial (std::wifstream& in)
{
ObjectMaterial::OBJECT_MATERIAL_DESC md;
md.device = D3DShell::self()->getDevice();
md.dc = D3DShell::self()->getDeviceContext();
md.name = ParseLine(in);
std::wstring buffer = L"";
bool done = false;
std::vector<std::streamoff> val;
do
{
in >> buffer;
if(buffer.size())
{
if(buffer == ObjImpFormat::ambient) { ParseVector4(in, md.ambient); }
else if(buffer == ObjImpFormat::diffuse) { ParseVector4(in, md.diffuse); }
else if(buffer == ObjImpFormat::specular) { ParseVector4(in, md.specular); }
else if(buffer == ObjImpFormat::specularPower) { ParseInteger(in, md.specualarPow); }
else if(buffer == ObjImpFormat::ambientTexture) { md.ambientTexture = ParseLine(in); }
else if(buffer == ObjImpFormat::diffuseTexture) { md.diffuseTexture = ParseLine(in); }
else if(buffer == ObjImpFormat::specularTexture) { md.specularTexture = ParseLine(in); }
else if(buffer == ObjImpFormat::glowTexture) { md.glowTexture = ParseLine(in); }
else if(buffer == ObjImpFormat::normalTexture) { md.normalTexture = ParseLine(in); }
else if(buffer == ObjImpFormat::comment) { ParseLine(in, true); }
else if(buffer == ObjImpFormat::endMaterial)
{
done = true;
//Return newly created material id
return MaterialHandler::AddMaterial(md);
}
}
} while (!done || !in.eof());
return -1;
}
// ------------------------------------------------------------------------------------------------
void ColladaModelFactory::ParseEffectColor(xml_node* node, const char* name, float4* out)
{
if(node)
{
// get 'color' descendant
xml_node* parentNode = FindFirstByName(node, name);
xml_node* colorNode = FindChildByName(parentNode, "color");
if (colorNode)
{
// get 4 floats
if (!ParseVector4(colorNode, out))
{
ParseError("'%s' 'color' element has fewer than required 4 floats\n", name);
}
}
}
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
template <> Vector4 ParseValue(const std::string& in_value)
{
return ParseVector4(in_value);
}
// ------------------------------------------------------------------------------------------------
void ColladaModelFactory::GetTransform(xml_node* node, Matrix * out )
{
Matrix rotateX,rotateY,rotateZ,translate,scale;
rotateX.MakeIdentity();
rotateY.MakeIdentity();
rotateZ.MakeIdentity();
translate.MakeIdentity();
scale.MakeIdentity();
for(xml_node* child = GetChildEle(node); child != NULL; child=GetNextEle(child))
{
const char * name = (const char*)child->name();
const char * sid = GetAttributeText(child, "sid", false);
if (!name) { continue; }
if (!sid) { continue; }
if(strcmp(name, "rotate")==0)
{
if(strcmp(sid, "rotateX")==0)
{
float4 temp;
if (!ParseVector4(child, &temp))
{
ParseError("Failed to parse '%s' transform (expected 4 floats)'\n", sid);
}
else
{
rotateX = Matrix::CreateRotationX(temp.w);
}
}
else if(strcmp(sid, "rotateY")==0)
{
float4 temp;
if (!ParseVector4(child, &temp))
{
ParseError("Failed to parse '%s' transform (expected 4 floats)'\n", sid);
}
else
{
rotateY = Matrix::CreateRotationY(temp.w);
}
}
else if(strcmp(sid, "rotateZ")==0)
{
float4 temp;
if (!ParseVector4(child, &temp))
{
ParseError("Failed to parse '%s' transform (expected 4 floats)'\n", sid);
}
else
{
rotateZ = Matrix::CreateRotationZ(temp.w);
}
}
}
else if(strcmp(name, "translate")==0)
{
float3 temp;
if (!ParseVector3(child, &temp))
{
ParseError("Failed to parse '%s' transform (expected 3 floats)'\n", name);
}
else
{
translate = Matrix::CreateTranslation(temp);
}
}
else if(strcmp(name, "scale")==0)
{
float3 temp;
if (!ParseVector3(child, &temp))
{
ParseError("Failed to parse '%s' transform (expected 3 floats)'\n", name);
}
else
{
scale = Matrix::CreateScale(temp);
}
}
// unhandled transform node
else
{
Logger::Log(OutputMessageType::Warning, "Unexpected transform node, '%s'\n", name);
}
}
Matrix tmp = scale * rotateX;
tmp = tmp * rotateY;
tmp = tmp * rotateZ;
tmp = tmp * translate;
*out = tmp;
}
