//--------------------------------------------------------------------
	Ptr<CharacterNode> Nebula3Writer::writeCharacterData( const NodeData& instanceNodeData,CharacterData& characterData )
	{
		if( !this->mGeometryDatas.Contains(characterData.geometryUniqueId) ||
			!this->mSkinDatas.Contains(characterData.skinUniqueId) )
		{
			n_error("CharacterData Not have geometryData or SkinData!\n");
		}

		GeometryData& geometryData = this->mGeometryDatas[characterData.geometryUniqueId];
		SkinData& skinData = this->mSkinDatas[characterData.skinUniqueId];
		/// 设置骨架基本信息		
		characterData.RootTransform = instanceNodeData.bind_matrix;
		characterData.characterName = instanceNodeData.nodeName;

		/// 建立骨骼
		this->buildSkeleton(characterData,skinData);
		this->buildSkinWeights(characterData,skinData,geometryData);		
		
		/// 建立骨骼节点
		Ptr<CharacterNode> characterNode = CharacterNode::Create();
		characterNode->SetName(characterData.characterName);

		/// 为骨骼节点添加骨骼
		Util::Array<IndexT> boneIndices;
		const JointMaps& characterJoints = characterData.characterJoints;
		const Util::Array<COLLADAFW::UniqueId>& jointKeys = characterJoints.KeysAsArray();
		for (int i=0;i<jointKeys.Size();i++)
		{
			const COLLADAFW::UniqueId& jointId = jointKeys[i];
			characterNode->AddJoint( jointId,characterJoints[jointId] );
			//if( characterData.inverseMatrixs.Contains(jointId))
			boneIndices.Append( characterJoints[jointId].GetJointIndex());
		}///end for

		/// 为骨骼节点添加蒙皮信息
		Ptr<TransformNode> transformNode = this->writeSkinGeometryData(instanceNodeData,skinData,geometryData);
		Util::Array<Ptr<ModelNode>> shapeNodes = transformNode->GetChildren();
		for (int i=0;i< shapeNodes.Size();i++)
		{
			const Ptr<CharacterSkinNode>& skinNode = shapeNodes[i].downcast<CharacterSkinNode>();
			IndexT groupIndex = skinNode->GetPrimitiveGroupIndex();
			skinNode->AddFragment(groupIndex,boneIndices);					
		}///end for

		Util::String animResId = this->writeAnimationData(characterData,characterJoints);
		characterNode->SetAnimationResourceId(animResId);
		characterNode->AddChild(transformNode.upcast<ModelNode>());
		characterNode->AddSkin(transformNode->GetName().AsString());	

		//Math::vector outTranslate;Math::quaternion outRotate;Math::vector outScale;		
		//Math::matrix44 matTemp = characterData.RootTransform;
		//matTemp.decompose(outScale,outRotate,outTranslate);	
		//characterNode->SetPosition(outTranslate);
		//characterNode->SetRotation(outRotate);
		//characterNode->SetScale(outScale);
		return characterNode;
	}
示例#2
0
void TemplateLoader::LoadType<Record::SActorTerm>(Ptr<IO::XmlReader> &xmlReader, Record::SActorTerm &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 2:
            ref.value = vectors[1];
        case 1:
            ref.type = EEActorTermType::Value(vectors[0]);
        default:
            break;
    }
}
示例#3
0
void TemplateLoader::LoadType<Record::SBaseRange>(Ptr<IO::XmlReader> &xmlReader, Record::SBaseRange &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 2:
            ref.range = vectors[1].AsInt();
        case 1:
            ref.base = vectors[0].AsInt();
        default:
            break;
    }
}
示例#4
0
int DERPEditor::net_client_send_id(lua_State *L)
{
    if (lua_gettop(L) == 4)
    {
        lua_getfield(L, -4, "instance");
        Client* client = *(Client**)lua_touserdata(L, -1);

        int channel = 0;

        if (lua_isstring(L, -3))
        {
            const char* type = lua_tolstring(L, -3, NULL);

            // Fetch the number connected to the string.
            Util::Array<char*>* tags = LuaApp::GetInstance()->m_net->GetTags();

            int i;
            for (i=0; i < tags->size(); i++)
            {
                if (strcmp((*tags)[i], type) == 0)
                    // Found it.
                    break;
            }

            if (i == tags->size())
                // Couldn't find it.
                channel = 0;
            else
                channel = i;

            const char* message = lua_tolstring(L, -2, NULL);
            const char* id = lua_tolstring(L, -4, NULL);
            client->SendID(id, channel, message, strlen(message)+1);
        }
        else if (lua_isnumber(L, -3))
        {
            const char* message = lua_tolstring(L, -2, NULL);
            client->SendID(lua_tolstring(L, -4, NULL), lua_tonumber(L, -3)
                           , message, strlen(message)+1);
        }

        return 0;
    }
    else
    {
        lua_pushstring(L, "Invalid arguments passed to send_id function!");
        lua_error(L);
    }

    return 0;
}
示例#5
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());
}
示例#6
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;
    }
}
示例#7
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;
    }
}
示例#8
0
void TemplateLoader::LoadType<Record::STargetFilters>(Ptr<IO::XmlReader> &xmlReader, Record::STargetFilters &ref,
                                                          const Util::StringAtom &attr, Component::TemplateContainer &container){
    
    Util::String value = xmlReader->GetString(attr.Value());
    Util::Array<Util::String> filterGroups;
    value.Tokenize(Util::String(";"), filterGroups);
    for (IndexT gpIdx = 0; gpIdx < filterGroups.Size(); ++gpIdx) {
        const Util::String& filters = filterGroups[gpIdx];
        if (filters != "-" && filters.Length() > 0) {
            Record::ETargetFilterState state = (Record::ETargetFilterState)(gpIdx);
            Util::Array<Util::String> filtersToTarget;
            filters.Tokenize(Util::String(","), filtersToTarget);
            for (IndexT filterIdx = 0; filterIdx < filtersToTarget.Size(); ++filterIdx) {
                Record::ETargetFilter filter = Record::EETargetFilter::Value(filtersToTarget[filterIdx]);
                ref.Filters.Add(filter, state);
            }
        }
    }
}
示例#9
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;
    }
}
示例#10
0
int DERPEditor::net_gettags(lua_State *L)
{
    if (lua_gettop(L) == 0)
    {
        Util::Array<char*>* tags = LuaApp::GetInstance()->m_net->GetTags();

        lua_newtable(L);

        for(int i=0; i<tags->size(); i++)
        {
            lua_pushnumber(L, i);
            lua_setfield(L, -2, (*tags)[i]);
        }

        return 1;
    }
    else
    {
        lua_pushstring(L, "Invalid arguments passed to gettags function!");
        lua_error(L);
    }

    return 0;
}
示例#11
0
	void SkeletonComponent::GetReferenceResourceId(Util::Array<Resources::ReferenceResource>& list) const
	{
		list.Append(Resources::ReferenceResource(m_SkelID, Resources::RR_Unknown));
		Super::GetReferenceResourceId(list);
	}
	//--------------------------------------------------------------------
	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;
	}