//--------------------------------------------------------------------
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;
}
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;
}
}
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;
}
}
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;
}
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::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);
}
}
}
}
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;
}
}
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;
}
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;
}
