protected override void OnUpdate()
{
Entities.ForEach((DeformDebugComponent deformMesh) =>
{
Debug.Assert(deformMesh.GetComponentsInChildren <SkinnedMeshRenderer>().Length == 1, "More than one SMR in DeformDebug component children");
var meshRenderer = deformMesh.GetComponentInChildren <SkinnedMeshRenderer>();
var entity = GetPrimaryEntity(meshRenderer);
var bones = meshRenderer.bones;
DstEntityManager.AddBuffer <RotatingBoneTransform>(entity);
DstEntityManager.AddBuffer <ModifiedTransform>(entity);
var rotatingBonesArray = DstEntityManager.GetBuffer <RotatingBoneTransform>(entity);
var movedTransformsArray = DstEntityManager.GetBuffer <ModifiedTransform>(entity);
rotatingBonesArray.ResizeUninitialized(bones.Length);
movedTransformsArray.ResizeUninitialized(bones.Length);
for (int boneIndex = 0; boneIndex != bones.Length; ++boneIndex)
{
var bone = meshRenderer.bones[boneIndex];
var boneMovementComponent = new RotatingBoneTransform
{
Value = meshRenderer.bones[boneIndex].localToWorldMatrix
};
var rotationObject = bone.GetComponent <RotateTransformComponent>();
boneMovementComponent.DoTheThing = rotationObject != null;
if (rotationObject)
{
boneMovementComponent.Degrees = rotationObject.Degrees;
}
rotatingBonesArray[boneIndex] = boneMovementComponent;
}
var sharedMesh = meshRenderer.sharedMesh;
if (sharedMesh.boneWeights.Length > 0 && sharedMesh.bindposes.Length > 0)
{
DstEntityManager.AddBuffer <BindPose>(entity);
var bindPoseArray = DstEntityManager.GetBuffer <BindPose>(entity);
bindPoseArray.ResizeUninitialized(bones.Length);
for (int boneIndex = 0; boneIndex != bones.Length; ++boneIndex)
{
var bindPose = meshRenderer.sharedMesh.bindposes[boneIndex];
bindPoseArray[boneIndex] = new BindPose {
Value = bindPose
};
}
}
if (sharedMesh.blendShapeCount > 0)
{
DstEntityManager.AddComponentData(entity, new UpdateBlendWeightData {
Value = 0.3f
});
}
});
}
protected override void OnUpdate()
{
Entities.ForEach((SkinnedMesh meshRenderer) =>
{
var entity = GetPrimaryEntity(meshRenderer.SkinnedMeshRenderer);
Entity rigEntity = GetPrimaryEntity(meshRenderer.Rig);
var animatedSkinMatricesArray = DstEntityManager.AddBuffer <AnimatedLocalToRoot>(rigEntity);
animatedSkinMatricesArray.ResizeUninitialized(meshRenderer.Rig.Bones.Length);
DstEntityManager.AddComponentData(entity, new SkinnedMeshRigEntity {
Value = rigEntity
});
DstEntityManager.AddComponentData(entity, new LocalToWorld());
DstEntityManager.AddComponentData(entity, new BoneIndexOffset());
DstEntityManager.AddBuffer <SkinnedMeshToRigIndex>(entity);
DstEntityManager.AddBuffer <BindPose>(entity);
DstEntityManager.AddBuffer <SkinMatrix>(entity);
var skeletonIndexArray = DstEntityManager.GetBuffer <SkinnedMeshToRigIndex>(entity);
var bindPoseArray = DstEntityManager.GetBuffer <BindPose>(entity);
var skinMatrices = DstEntityManager.GetBuffer <SkinMatrix>(entity);
var smBones = meshRenderer.SkinnedMeshRenderer.bones;
skeletonIndexArray.ResizeUninitialized(smBones.Length);
bindPoseArray.ResizeUninitialized(smBones.Length);
skinMatrices.ResizeUninitialized(smBones.Length);
var skBones = meshRenderer.Rig.Bones;
for (int j = 0; j != smBones.Length; ++j)
{
var remap = new SkinnedMeshToRigIndex {
Value = -1
};
for (int k = 0; k != skBones.Length; ++k)
{
if (smBones[j] == skBones[k])
{
remap.Value = k;
break;
}
}
skeletonIndexArray[j] = remap;
var bindPose = meshRenderer.SkinnedMeshRenderer.sharedMesh.bindposes[j];
bindPoseArray[j] = new BindPose {
Value = bindPose
};
var skinMat = math.mul(meshRenderer.SkinnedMeshRenderer.bones[j].localToWorldMatrix, bindPose);
skinMatrices[j] = new SkinMatrix {
Value = new float3x4(skinMat.c0.xyz, skinMat.c1.xyz, skinMat.c2.xyz, skinMat.c3.xyz)
};
}
});
}
protected override void OnUpdate()
{
Entities.ForEach((DeformationsSampleAuthoring deformMesh, SkinnedMeshRenderer renderer) =>
{
var entity = GetPrimaryEntity(renderer);
// Only execute this if we have a valid skinning setup
var bones = renderer.bones;
var hasSkinning = bones.Length > 0 && renderer.sharedMesh.bindposes.Length > 0;
if (hasSkinning)
{
// Setup Reference to root
var rootBone = renderer.rootBone ? renderer.rootBone : renderer.transform;
var rootEntity = GetPrimaryEntity(rootBone);
DstEntityManager.AddComponentData(entity, new RootEntity {
Value = rootEntity
});
// World to local is required for root space conversion of the SkinMatrices
DstEntityManager.AddComponent <WorldToLocal>(rootEntity);
DstEntityManager.AddComponent <RootTag>(rootEntity);
DstEntityManager.AddBuffer <BoneEntity>(entity);
var boneEntityArray = DstEntityManager.GetBuffer <BoneEntity>(entity);
boneEntityArray.ResizeUninitialized(bones.Length);
for (int boneIndex = 0; boneIndex < bones.Length; ++boneIndex)
{
var bone = renderer.bones[boneIndex];
var boneEntity = GetPrimaryEntity(bone);
boneEntityArray[boneIndex] = new BoneEntity {
Value = boneEntity
};
}
// Store the bindpose for each bone
DstEntityManager.AddBuffer <BindPose>(entity);
var bindPoseArray = DstEntityManager.GetBuffer <BindPose>(entity);
bindPoseArray.ResizeUninitialized(bones.Length);
for (int boneIndex = 0; boneIndex != bones.Length; ++boneIndex)
{
var bindPose = renderer.sharedMesh.bindposes[boneIndex];
bindPoseArray[boneIndex] = new BindPose {
Value = bindPose
};
}
// Add tags to the bones so we can find them later
// when computing the SkinMatrices
for (int boneIndex = 0; boneIndex < bones.Length; ++boneIndex)
{
var bone = renderer.bones[boneIndex];
var boneEntity = GetPrimaryEntity(bone);
DstEntityManager.AddComponentData(boneEntity, new BoneTag());
}
}
// Override the material color of the deformation materials
var c = deformMesh.Color.linear;
var color = new float4(c.r, c.g, c.b, c.a);
foreach (var rendererEntity in GetEntities(renderer))
{
if (DstEntityManager.HasComponent <RenderMesh>(rendererEntity))
{
DstEntityManager.AddComponentData(rendererEntity, new HDRPMaterialPropertyBaseColor {
Value = color
});
}
}
});
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
if (HasLODData(container.ExportVersion))
{
node.Add(LODDataName, LODData.ExportYAML(container));
}
else
{
if (HasUse16bitIndices(container.ExportVersion))
{
node.Add(Use16BitIndicesName, Use16BitIndices);
}
if (IsIndexBufferFirst(container.ExportVersion))
{
node.Add(IndexBufferName, IndexBuffer.ExportYAML());
}
node.Add(SubMeshesName, SubMeshes.ExportYAML(container));
}
if (HasBlendShapes(container.ExportVersion))
{
if (HasBlendChannels(container.ExportVersion))
{
node.Add(ShapesName, Shapes.ExportYAML(container));
}
else
{
node.Add(ShapesName, BlendShapes.ExportYAML(container));
node.Add(ShapeVerticesName, ShapeVertices.ExportYAML(container));
}
}
if (HasBindPose(container.ExportVersion))
{
if (IsBindPoseFirst(container.ExportVersion))
{
node.Add(BindPoseName, BindPose.ExportYAML(container));
}
}
if (HasBoneNameHashes(container.ExportVersion))
{
node.Add(BoneNameHashesName, BoneNameHashes.ExportYAML(true));
node.Add(RootBoneNameHashName, RootBoneNameHash);
}
if (HasBonesAABB(container.ExportVersion))
{
node.Add(BonesAABBName, BonesAABB.ExportYAML(container));
node.Add(VariableBoneCountWeightsName, VariableBoneCountWeights.ExportYAML(container));
}
if (HasMeshCompression(container.ExportVersion))
{
node.Add(MeshCompressionName, (byte)MeshCompression);
}
if (HasStreamCompression(container.ExportVersion))
{
node.Add(StreamCompressionName, StreamCompression);
}
if (HasIsReadable(container.ExportVersion))
{
node.Add(IsReadableName, IsReadable);
node.Add(KeepVerticesName, KeepVertices);
node.Add(KeepIndicesName, KeepIndices);
}
if (HasIndexFormat(container.ExportVersion))
{
node.Add(IndexFormatName, (int)IndexFormat);
}
if (!HasLODData(container.ExportVersion))
{
if (!IsIndexBufferFirst(container.ExportVersion))
{
node.Add(IndexBufferName, IndexBuffer.ExportYAML());
}
}
if (HasVertexData(container.ExportVersion))
{
if (!IsOnlyVertexData(container.ExportVersion))
{
if (MeshCompression != MeshCompression.Off)
{
node.Add(VerticesName, Vertices.ExportYAML(container));
}
}
}
else
{
node.Add(VerticesName, Vertices.ExportYAML(container));
}
if (HasSkin(container.ExportVersion))
{
node.Add(SkinName, Skin.ExportYAML(container));
}
if (HasBindPose(container.ExportVersion))
{
if (!IsBindPoseFirst(container.ExportVersion))
{
node.Add(BindPoseName, BindPose.ExportYAML(container));
}
}
if (HasVertexData(container.ExportVersion))
{
if (IsOnlyVertexData(container.ExportVersion))
{
node.Add(VertexDataName, VertexData.ExportYAML(container));
}
else
{
if (MeshCompression == MeshCompression.Off)
{
node.Add(VertexDataName, VertexData.ExportYAML(container));
}
else
{
node.Add(UVName, UV.ExportYAML(container));
node.Add(UV1Name, UV1.ExportYAML(container));
node.Add(TangentsName, Tangents.ExportYAML(container));
node.Add(NormalsName, Normals.ExportYAML(container));
node.Add(ColorsName, Colors.ExportYAML(container));
}
}
}
else
{
node.Add(UVName, UV.ExportYAML(container));
if (HasUV1(container.ExportVersion))
{
node.Add(UV1Name, UV1.ExportYAML(container));
}
if (HasTangentSpace(container.ExportVersion))
{
node.Add(TangentSpaceName, Tangents.ExportYAML(container));
}
else
{
node.Add(TangentsName, Tangents.ExportYAML(container));
node.Add(NormalsName, Normals.ExportYAML(container));
}
}
if (HasCompressedMesh(container.ExportVersion))
{
node.Add(CompressedMeshName, CompressedMesh.ExportYAML(container));
}
node.Add(LocalAABBName, LocalAABB.ExportYAML(container));
if (!HasVertexData(container.ExportVersion))
{
node.Add(ColorsName, Colors.ExportYAML(container));
}
if (HasCollisionTriangles(container.ExportVersion))
{
node.Add(CollisionTrianglesName, CollisionTriangles.ExportYAML(true));
node.Add(CollisionVertexCountName, CollisionVertexCount);
}
if (HasMeshUsageFlags(container.ExportVersion))
{
node.Add(MeshUsageFlagsName, MeshUsageFlags);
}
if (HasCollision(container.ExportVersion))
{
node.Add(BakedConvexCollisionMeshName, CollisionData.BakedConvexCollisionMesh.ExportYAML());
node.Add(BakedTriangleCollisionMeshName, CollisionData.BakedTriangleCollisionMesh.ExportYAML());
}
if (HasMeshMetrics(container.ExportVersion))
{
node.Add(MeshMetricsName + "[0]", MeshMetrics[0]);
node.Add(MeshMetricsName + "[1]", MeshMetrics[1]);
}
if (HasMeshOptimization(container.ExportVersion, container.ExportFlags))
{
if (IsMeshOptimizationFlags(container.ExportVersion))
{
node.Add(MeshOptimizationFlagsName, (int)MeshOptimizationFlags);
}
else
{
node.Add(MeshOptimizedName, MeshOptimized);
}
}
if (HasStreamData(container.ExportVersion))
{
StreamingInfo streamData = new StreamingInfo(true);
node.Add(StreamDataName, streamData.ExportYAML(container));
}
return(node);
}
public override void Write(AssetWriter writer)
{
base.Write(writer);
if (HasLODData(writer.Version))
{
LODData.Write(writer);
}
else
{
if (HasUse16bitIndices(writer.Version))
{
writer.Write(Use16BitIndices);
}
if (IsIndexBufferFirst(writer.Version))
{
IndexBuffer.Write(writer);
writer.AlignStream(AlignType.Align4);
}
SubMeshes.Write(writer);
}
if (HasBlendShapes(writer.Version))
{
if (HasBlendChannels(writer.Version))
{
Shapes.Write(writer);
}
else
{
BlendShapes.Write(writer);
writer.AlignStream(AlignType.Align4);
ShapeVertices.Write(writer);
}
}
if (HasBindPose(writer.Version))
{
if (IsBindPoseFirst(writer.Version))
{
BindPose.Write(writer);
}
}
if (HasBoneNameHashes(writer.Version))
{
BoneNameHashes.Write(writer);
writer.Write(RootBoneNameHash);
}
if (HasBonesAABB(writer.Version))
{
BonesAABB.Write(writer);
VariableBoneCountWeights.Write(writer);
}
if (HasMeshCompression(writer.Version))
{
writer.Write((byte)MeshCompression);
}
if (HasStreamCompression(writer.Version))
{
writer.Write(StreamCompression);
}
if (HasIsReadable(writer.Version))
{
writer.Write(IsReadable);
writer.Write(KeepVertices);
writer.Write(KeepIndices);
}
if (IsAlignFlags(writer.Version))
{
writer.AlignStream(AlignType.Align4);
}
if (HasIndexFormat(writer.Version))
{
if (IsIndexFormatCondition(writer.Version))
{
if (MeshCompression == MeshCompression.Off)
{
writer.Write((int)IndexFormat);
}
}
else
{
writer.Write((int)IndexFormat);
}
}
if (!HasLODData(writer.Version))
{
if (!IsIndexBufferFirst(writer.Version))
{
IndexBuffer.Write(writer);
writer.AlignStream(AlignType.Align4);
}
}
if (HasVertexData(writer.Version))
{
if (!IsOnlyVertexData(writer.Version))
{
if (MeshCompression != MeshCompression.Off)
{
Vertices.Write(writer);
}
}
}
else
{
Vertices.Write(writer);
}
if (HasSkin(writer.Version))
{
Skin.Write(writer);
}
if (HasBindPose(writer.Version))
{
if (!IsBindPoseFirst(writer.Version))
{
BindPose.Write(writer);
}
}
if (HasVertexData(writer.Version))
{
if (IsOnlyVertexData(writer.Version))
{
VertexData.Write(writer);
}
else
{
if (MeshCompression == MeshCompression.Off)
{
VertexData.Write(writer);
}
else
{
UV.Write(writer);
UV1.Write(writer);
Tangents.Write(writer);
Normals.Write(writer);
Colors.Write(writer);
}
}
}
else
{
UV.Write(writer);
if (HasUV1(writer.Version))
{
UV1.Write(writer);
}
if (HasTangentSpace(writer.Version))
{
TangentSpace.Write(writer);
}
else
{
Tangents.Write(writer);
Normals.Write(writer);
}
}
if (IsAlignVertex(writer.Version))
{
writer.AlignStream(AlignType.Align4);
}
if (HasCompressedMesh(writer.Version))
{
CompressedMesh.Write(writer);
}
LocalAABB.Write(writer);
if (!HasVertexData(writer.Version))
{
Colors.Write(writer);
}
if (HasCollisionTriangles(writer.Version))
{
CollisionTriangles.Write(writer);
writer.Write(CollisionVertexCount);
}
if (HasMeshUsageFlags(writer.Version))
{
writer.Write(MeshUsageFlags);
}
if (HasCollision(writer.Version))
{
CollisionData.Write(writer);
}
if (HasMeshMetrics(writer.Version))
{
writer.Write(MeshMetrics[0]);
writer.Write(MeshMetrics[1]);
}
#if UNIVERSAL
if (HasMeshOptimization(writer.Version, writer.Flags))
{
if (IsMeshOptimizationFlags(writer.Version))
{
writer.Write((int)MeshOptimizationFlags);
}
else
{
writer.Write(MeshOptimized);
}
}
#endif
if (HasStreamData(writer.Version))
{
writer.AlignStream(AlignType.Align4);
StreamData.Write(writer);
}
}
void ConvertSkinnedMeshRenderes(RigBasedAssetAuthoring assetAuthoring, Entity assetEntity,
RigComponent rigComponent)
{
var skinnedMeshRenderers = assetAuthoring.GetComponentsInChildren <SkinnedMeshRenderer>();
if (skinnedMeshRenderers.Length > 0)
{
DstEntityManager.AddBuffer <RigBasedAsset.SkinnedMeshRenderer>(assetEntity);
}
foreach (var meshRenderer in skinnedMeshRenderers)
{
var skinEntity = GetPrimaryEntity(meshRenderer.gameObject);
//var skinEntity = conversionSystem.CreateAdditionalEntity(meshRenderer);
#if UNITY_EDITOR
DstEntityManager.SetName(skinEntity, "Entity " + skinEntity.Index + " Skin_" + meshRenderer.gameObject.name);
#endif
var skinRendererBuffer = DstEntityManager.GetBuffer <RigBasedAsset.SkinnedMeshRenderer>(assetEntity);
skinRendererBuffer.Add(new RigBasedAsset.SkinnedMeshRenderer {
Value = skinEntity,
});
//var rigEntity = GetPrimaryEntity(src.Rig);
//DstEntityManager.AddComponentData(entity, new SkinnedMeshComponentData { RigEntity = rigEntity });
DstEntityManager.AddComponentData(skinEntity, new SkinnedMeshRigEntity {
Value = assetEntity
});
DstEntityManager.AddComponentData(skinEntity, new LocalToWorld());
DstEntityManager.AddComponentData(skinEntity, new BoneIndexOffset());
DstEntityManager.AddBuffer <SkinnedMeshToRigIndex>(skinEntity);
DstEntityManager.AddBuffer <BindPose>(skinEntity);
DstEntityManager.AddBuffer <SkinMatrix>(skinEntity);
var skeletonIndexArray = DstEntityManager.GetBuffer <SkinnedMeshToRigIndex>(skinEntity);
var bindPoseArray = DstEntityManager.GetBuffer <BindPose>(skinEntity);
var skinMatrices = DstEntityManager.GetBuffer <SkinMatrix>(skinEntity);
var smBones = meshRenderer.bones;
skeletonIndexArray.ResizeUninitialized(smBones.Length);
bindPoseArray.ResizeUninitialized(smBones.Length);
skinMatrices.ResizeUninitialized(smBones.Length);
//GameDebug.Log("skin smBones");
//for (int i = 0; i < smBones.Length; i++)
//{
// var relativePath = RigGenerator.ComputeRelativePath(smBones[i], transform);
// var id = (StringHash)relativePath;
// GameDebug.Log(" " + i + ":" + id.Id + " path:" + relativePath);
//}
for (int j = 0; j != smBones.Length; ++j)
{
var remap = new SkinnedMeshToRigIndex {
Value = -1
};
var smBoneRelativePath = RigGenerator.ComputeRelativePath(smBones[j], assetAuthoring.transform);
var smBoneId = (StringHash)smBoneRelativePath;
for (int k = 0; k != rigComponent.Bones.Length; ++k)
{
var relativePath = RigGenerator.ComputeRelativePath(rigComponent.Bones[k], rigComponent.transform);
var id = (StringHash)relativePath;
if (smBoneId.Equals(id))
{
remap.Value = k;
break;
}
}
skeletonIndexArray[j] = remap;
var bindPose = meshRenderer.sharedMesh.bindposes[j];
bindPoseArray[j] = new BindPose {
Value = bindPose
};
var skinMat = math.mul(meshRenderer.bones[j].localToWorldMatrix, bindPose);
skinMatrices[j] = new SkinMatrix {
Value = new float3x4(skinMat.c0.xyz, skinMat.c1.xyz, skinMat.c2.xyz, skinMat.c3.xyz)
};
}
}
}
public override void Read(EndianStream stream)
{
base.Read(stream);
Quality = stream.ReadInt32();
UpdateWhenOffscreen = stream.ReadBoolean();
if (IsReadSkinNormals)
{
SkinNormals = stream.ReadBoolean();
}
if (IsReadSkinMotionVector)
{
SkinnedMotionVectors = stream.ReadBoolean();
}
stream.AlignStream(AlignType.Align4);
if (IsReadOffscreen)
{
DisableAnimationWhenOffscreen.Read(stream);
}
Mesh.Read(stream);
int bonesCount = stream.ReadInt32();
m_bones = new PPtr <Transform> [bonesCount];
for (int i = 0; i < bonesCount; i++)
{
PPtr <Transform> bone = new PPtr <Transform>(AssetsFile);
bone.Read(stream);
m_bones[i] = bone;
}
stream.AlignStream(AlignType.Align4);
if (IsReadBindPose)
{
BindPose.Read(stream);
}
if (IsReadAABB)
{
if (IsReadWeights)
{
int weightCount = stream.ReadInt32();
m_blendShapeWeights = new float[weightCount];
for (int i = 0; i < weightCount; i++)
{
float weight = stream.ReadSingle();
m_blendShapeWeights[i] = weight;
}
}
if (IsReadRootBone)
{
RootBone.Read(stream);
}
AABB.Read(stream);
DirtyAABB = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
}
