void TemplateLoader::LoadType<Record::STimeOfDay>(Ptr<IO::XmlReader> &xmlReader, Record::STimeOfDay &ref, const Util::StringAtom &attr, Component::TemplateContainer &container){
Util::String value = xmlReader->GetString(attr.Value());
Util::Array<Util::String> vectors;
value.Tokenize(Util::String(","), vectors);
switch (vectors.Size()) {
case 3:
ref.second= vectors[2].AsInt();
case 2:
ref.minute = vectors[1].AsInt();
case 1:
ref.hour = vectors[0].AsInt();
default:
break;
}
}
void LoadComplexType(Ptr<IO::XmlReader> &xmlReader, TYPE &ref, const Util::StringAtom &attr, TemplateContainer& container){
// load value from attr
Util::Array<Util::String> attrs = xmlReader->GetAttrs();
for (int idx = 0; idx < attrs.Size(); ++idx) {
Util::StringAtom nodeName = attrs[idx];
if (nodeName != TemplateLoader::IdAttr && nodeName != TemplateLoader::ParentAttr
&& nodeName != TemplateLoader::ParentAttr && nodeName != TemplateLoader::DefaultAttr
&& nodeName != TemplateLoader::IndexAttr ) {
LoadRecordBody<TYPE>(xmlReader, nodeName, nodeName, ref, container);
}
}
// load value from body
if(xmlReader->SetToFirstChild()) do {
Util::StringAtom nodeName = xmlReader->GetCurrentNodeName();
LoadRecordBody<TYPE>(xmlReader, nodeName, attr, ref, container);
} while (xmlReader->SetToNextChild());
}
void TemplateLoader::LoadType<Record::SFloatRangeMirror>(Ptr<IO::XmlReader> &xmlReader, Record::SFloatRangeMirror &ref, const Util::StringAtom &attr, Component::TemplateContainer &container){
Util::String value = xmlReader->GetString(attr.Value());
Util::Array<Util::String> vectors;
value.Tokenize(Util::String(","), vectors);
switch (vectors.Size()) {
case 4:
ref.positiveMin = AsFloat(vectors[3]);
case 3:
ref.positiveMax = AsFloat(vectors[2]);
case 2:
ref.negtiveMin = AsFloat(vectors[1]);
case 1:
ref.negtiveMax = AsFloat(vectors[0]);
default:
break;
}
}
void TemplateLoader::LoadType<Record::SColor>(Ptr<IO::XmlReader> &xmlReader, Record::SColor &ref, const Util::StringAtom &attr, Component::TemplateContainer &container){
Util::String value = xmlReader->GetString(attr.Value());
Util::Array<Util::String> colors;
value.Tokenize(Util::String(","), colors);
switch (colors.Size()) {
case 4:
ref.a = colors[3].AsInt();
case 3:
ref.b = colors[2].AsInt();
case 2:
ref.g = colors[1].AsInt();
case 1:
ref.r = colors[0].AsInt();
default:
break;
}
}
void TemplateLoader::LoadType<Record::SRotator>(Ptr<IO::XmlReader> &xmlReader, Record::SRotator &ref, const Util::StringAtom &attr, Component::TemplateContainer &container){
Util::String value = xmlReader->GetString(attr.Value());
Util::Array<Util::String> vectors;
value.Tokenize(Util::String(","), vectors);
switch (vectors.Size()) {
case 3:
ref.pitch = AsFloat(vectors[2]);
ref.roll = AsFloat(vectors[1]);
ref.yaw = AsFloat(vectors[0]);
break;
case 2:
ref.roll = AsFloat(vectors[1]);
ref.yaw = AsFloat(vectors[0]);
break;
case 1:
float vf = AsFloat(vectors[0]);
ref.roll = ref.yaw = ref.pitch = vf;
break;
}
}
//--------------------------------------------------------------------
Ptr<TransformNode> Nebula3Writer::writeSkinGeometryData( const NodeData& instanceNodeData,const SkinData& skinData,GeometryData& geometryData )
{
Ptr<TransformNode> transformNode = TransformNode::Create();
MeshBuilder meshBuilder;
Util::String meshFilename ="msh:" + geometryData.mGeometryName;meshFilename.Append(".nvx2");
for (int groupIndex=0;groupIndex<geometryData.mMeshDatas.Size();groupIndex++)
{
/// 设置基本信息
GeometryData::MeshData& meshData = geometryData.mMeshDatas[groupIndex];
Ptr<CharacterSkinNode> shapeNode = CharacterSkinNode::Create();
Util::String shapeName(geometryData.mGeometryName);
shapeName.Append("_s_");
shapeName.AppendInt(groupIndex);
shapeNode->SetName(shapeName);
shapeNode->SetPrimitiveGroupIndex(groupIndex);
shapeNode->SetMeshResourceId(meshFilename);
this->writeMaterialData(instanceNodeData,geometryData,groupIndex,shapeNode.upcast<ModelNode>());
for (int j=0;j< meshData.positionIndices.Size();j+=3 )
{
MeshBuilderVertex vertex01,vertex02,vertex03;
vertex01.SetComponent(MeshBuilderVertex::CoordIndex,geometryData.mPositions[meshData.positionIndices[j]]);
vertex02.SetComponent(MeshBuilderVertex::CoordIndex,geometryData.mPositions[meshData.positionIndices[j+1]]);
vertex03.SetComponent(MeshBuilderVertex::CoordIndex,geometryData.mPositions[meshData.positionIndices[j+2]]);
if( !meshData.normalIndices.IsEmpty())
{
vertex01.SetComponent(MeshBuilderVertex::NormalIndex,geometryData.mNormals[meshData.normalIndices[j]]);
vertex02.SetComponent(MeshBuilderVertex::NormalIndex,geometryData.mNormals[meshData.normalIndices[j+1]]);
vertex03.SetComponent(MeshBuilderVertex::NormalIndex,geometryData.mNormals[meshData.normalIndices[j+2]]);
}
if( !meshData.mDiffMapUVs.IsEmpty())
{
vertex01.SetComponent(MeshBuilderVertex::Uv0Index,meshData.mDiffMapUVs[meshData.mDiffMapIndices[j]]);
vertex02.SetComponent(MeshBuilderVertex::Uv0Index,meshData.mDiffMapUVs[meshData.mDiffMapIndices[j+1]]);
vertex03.SetComponent(MeshBuilderVertex::Uv0Index,meshData.mDiffMapUVs[meshData.mDiffMapIndices[j+2]]);
}
if( !geometryData.mJointIndices.IsEmpty())
{
vertex01.SetComponent(MeshBuilderVertex::JIndicesIndex,geometryData.mJointIndices[meshData.positionIndices[j]]);
vertex01.SetComponent(MeshBuilderVertex::WeightsIndex,geometryData.mWeights[meshData.positionIndices[j]]);
vertex02.SetComponent(MeshBuilderVertex::JIndicesIndex,geometryData.mJointIndices[meshData.positionIndices[j+1]]);
vertex02.SetComponent(MeshBuilderVertex::WeightsIndex,geometryData.mWeights[meshData.positionIndices[j+1]]);
vertex03.SetComponent(MeshBuilderVertex::JIndicesIndex,geometryData.mJointIndices[meshData.positionIndices[j+2]]);
vertex03.SetComponent(MeshBuilderVertex::WeightsIndex,geometryData.mWeights[meshData.positionIndices[j+2]]);
}
meshBuilder.AddVertex(vertex01);
size_t indices01 = meshBuilder.GetNumVertices() -1;
meshBuilder.AddVertex(vertex02);
size_t indices02 = meshBuilder.GetNumVertices() -1;
meshBuilder.AddVertex(vertex03);
size_t indices03 = meshBuilder.GetNumVertices() -1;
MeshBuilderTriangle triangle;
triangle.SetGroupId(groupIndex);
triangle.SetVertexIndices(indices01,indices02,indices03);
meshBuilder.AddTriangle(triangle);
}///end for
transformNode->AddChild(shapeNode.upcast<ModelNode>());
}///end for
/// 保存模型文件
if( !MeshBuilderSaver::SaveNvx2(meshFilename,meshBuilder,Platform::Win32) )
{
n_error("Save [%s] Failed!\n",meshFilename);
}///end if
Math::bbox boundingbox = meshBuilder.ComputeBoundingBox();
transformNode->SetName(geometryData.mGeometryName);
transformNode->SetBoundingBox(boundingbox);
Util::Array<Ptr<ModelNode>> shapeNodes = transformNode->GetChildren();
for (int i=0;i<shapeNodes.Size();i++)
{
shapeNodes[i]->SetBoundingBox(boundingbox);
}///end for
/// 设置位置信息
//Math::vector outTranslate;Math::quaternion outRotate;Math::vector outScale;
//Math::matrix44 matTemp = this->getGeometryMatrix(instanceNodeData.nodeUniqueId);
//matTemp.decompose(outScale,outRotate,outTranslate);
//transformNode->SetPosition(outTranslate);
//transformNode->SetRotation(outRotate);
//transformNode->SetScale(outScale);
return transformNode;
}
