Esempio n. 1
0
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;
    }
}
Esempio n. 2
0
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());
}
Esempio n. 3
0
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;
    }
}
Esempio n. 4
0
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;
    }
}
Esempio n. 5
0
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;
	}