public SkyboxGeneratorContext(SkyboxAsset skybox)
{
if (skybox == null) throw new ArgumentNullException(nameof(skybox));
Skybox = skybox;
Services = new ServiceRegistry();
Content = new ContentManager(Services);
GraphicsDevice = GraphicsDevice.New();
GraphicsDeviceService = new GraphicsDeviceServiceLocal(Services, GraphicsDevice);
EffectSystem = new EffectSystem(Services);
EffectSystem.Initialize();
((IContentable)EffectSystem).LoadContent();
((EffectCompilerCache)EffectSystem.Compiler).CompileEffectAsynchronously = false;
RenderContext = RenderContext.GetShared(Services);
RenderDrawContext = new RenderDrawContext(Services, RenderContext, new GraphicsContext(new CommandList(GraphicsDevice), new ResourceGroupAllocator(GraphicsDevice)));
}
/// <summary>
/// The method to override containing the actual command code. It is called by the <see cref="DoCommand" /> function
/// </summary>
/// <param name="commandContext">The command context.</param>
/// <returns>Task{ResultStatus}.</returns>
protected override async Task<ResultStatus> DoCommandOverride(ICommandContext commandContext)
{
var assetManager = new ContentManager();
while (Interlocked.Increment(ref spawnedCommands) >= 2)
{
Interlocked.Decrement(ref spawnedCommands);
await Task.Delay(1, CancellationToken);
}
try
{
object exportedObject;
switch (Mode)
{
case ExportMode.Animation:
exportedObject = ExportAnimation(commandContext, assetManager);
break;
case ExportMode.Skeleton:
exportedObject = ExportSkeleton(commandContext, assetManager);
break;
case ExportMode.Model:
exportedObject = ExportModel(commandContext, assetManager);
break;
default:
commandContext.Logger.Error("Unknown export type [{0}] {1}", Mode, ContextAsString);
return ResultStatus.Failed;
}
if (exportedObject != null)
assetManager.Save(Location, exportedObject);
commandContext.Logger.Verbose("The {0} has been successfully imported.", ContextAsString);
return ResultStatus.Successful;
}
catch (Exception ex)
{
commandContext.Logger.Error("Unexpected error while importing {0}", ex, ContextAsString);
return ResultStatus.Failed;
}
finally
{
Interlocked.Decrement(ref spawnedCommands);
}
}
protected abstract Skeleton LoadSkeleton(ICommandContext commandContext, ContentManager contentManager);
protected abstract Dictionary<string, AnimationClip> LoadAnimation(ICommandContext commandContext, ContentManager contentManager);
protected abstract Rendering.Model LoadModel(ICommandContext commandContext, ContentManager contentManager);
private unsafe object ExportAnimation(ICommandContext commandContext, ContentManager contentManager)
{
// Read from model file
var modelSkeleton = LoadSkeleton(commandContext, contentManager); // we get model skeleton to compare it to real skeleton we need to map to
var animationClips = LoadAnimation(commandContext, contentManager);
AnimationClip animationClip = null;
if (animationClips.Count > 0)
{
animationClip = new AnimationClip();
AnimationClip rootMotionAnimationClip = null;
// If root motion is explicitely enabled, or if there is no skeleton, try to find root node and apply animation directly on TransformComponent
if ((AnimationRootMotion || SkeletonUrl == null) && modelSkeleton.Nodes.Length >= 1)
{
// No skeleton, map root node only
// TODO: For now, it seems to be located on node 1 in FBX files. Need to check if always the case, and what happens with Assimp
var rootNode0 = modelSkeleton.Nodes.Length >= 1 ? modelSkeleton.Nodes[0].Name : null;
var rootNode1 = modelSkeleton.Nodes.Length >= 2 ? modelSkeleton.Nodes[1].Name : null;
if ((rootNode0 != null && animationClips.TryGetValue(rootNode0, out rootMotionAnimationClip))
|| (rootNode1 != null && animationClips.TryGetValue(rootNode1, out rootMotionAnimationClip)))
{
foreach (var channel in rootMotionAnimationClip.Channels)
{
var curve = rootMotionAnimationClip.Curves[channel.Value.CurveIndex];
// Root motion
var channelName = channel.Key;
if (channelName.StartsWith("Transform."))
{
animationClip.AddCurve($"[TransformComponent.Key]." + channelName.Replace("Transform.", string.Empty), curve);
}
// Also apply Camera curves
// TODO: Add some other curves?
if (channelName.StartsWith("Camera."))
{
animationClip.AddCurve($"[CameraComponent.Key]." + channelName.Replace("Camera.", string.Empty), curve);
}
}
// Take max of durations
if (animationClip.Duration < rootMotionAnimationClip.Duration)
animationClip.Duration = rootMotionAnimationClip.Duration;
}
}
// Load asset reference skeleton
if (SkeletonUrl != null)
{
var skeleton = contentManager.Load<Skeleton>(SkeletonUrl);
var skeletonMapping = new SkeletonMapping(skeleton, modelSkeleton);
// Process missing nodes
foreach (var nodeAnimationClipEntry in animationClips)
{
var nodeName = nodeAnimationClipEntry.Key;
var nodeAnimationClip = nodeAnimationClipEntry.Value;
var nodeIndex = modelSkeleton.Nodes.IndexOf(x => x.Name == nodeName);
// Node doesn't exist in skeleton? skip it
if (nodeIndex == -1 || skeletonMapping.SourceToSource[nodeIndex] != nodeIndex)
continue;
// Skip root motion node (if any)
if (nodeAnimationClip == rootMotionAnimationClip)
continue;
// Find parent node
var parentNodeIndex = modelSkeleton.Nodes[nodeIndex].ParentIndex;
if (parentNodeIndex != -1 && skeletonMapping.SourceToSource[parentNodeIndex] != parentNodeIndex)
{
// Some nodes were removed, we need to concat the anim curves
var currentNodeIndex = nodeIndex;
var nodesToMerge = new List<Tuple<ModelNodeDefinition, AnimationBlender, AnimationClipEvaluator>>();
while (currentNodeIndex != -1 && currentNodeIndex != skeletonMapping.SourceToSource[parentNodeIndex])
{
AnimationClip animationClipToMerge;
AnimationClipEvaluator animationClipEvaluator = null;
AnimationBlender animationBlender = null;
if (animationClips.TryGetValue(modelSkeleton.Nodes[currentNodeIndex].Name, out animationClipToMerge))
{
animationBlender = new AnimationBlender();
animationClipEvaluator = animationBlender.CreateEvaluator(animationClipToMerge);
}
nodesToMerge.Add(Tuple.Create(modelSkeleton.Nodes[currentNodeIndex], animationBlender, animationClipEvaluator));
currentNodeIndex = modelSkeleton.Nodes[currentNodeIndex].ParentIndex;
}
// Put them in proper parent to children order
nodesToMerge.Reverse();
// Find all key times
// TODO: We should detect discontinuities and keep them
var animationKeysSet = new HashSet<CompressedTimeSpan>();
foreach (var node in nodesToMerge)
{
foreach (var curve in node.Item3.Clip.Curves)
{
foreach (CompressedTimeSpan time in curve.Keys)
{
animationKeysSet.Add(time);
}
}
}
// Sort key times
var animationKeys = animationKeysSet.ToList();
animationKeys.Sort();
var animationOperations = new FastList<AnimationOperation>();
var combinedAnimationClip = new AnimationClip();
var translationCurve = new AnimationCurve<Vector3>();
var rotationCurve = new AnimationCurve<Quaternion>();
var scaleCurve = new AnimationCurve<Vector3>();
// Evaluate at every key frame
foreach (var animationKey in animationKeys)
{
var matrix = Matrix.Identity;
// Evaluate node
foreach (var node in nodesToMerge)
{
// Get default position
var modelNodeDefinition = node.Item1;
// Compute
AnimationClipResult animationClipResult = null;
animationOperations.Clear();
animationOperations.Add(AnimationOperation.NewPush(node.Item3, animationKey));
node.Item2.Compute(animationOperations, ref animationClipResult);
var updateMemberInfos = new List<UpdateMemberInfo>();
foreach (var channel in animationClipResult.Channels)
updateMemberInfos.Add(new UpdateMemberInfo { Name = channel.PropertyName, DataOffset = channel.Offset });
// TODO: Cache this
var compiledUpdate = UpdateEngine.Compile(typeof(ModelNodeDefinition), updateMemberInfos);
unsafe
{
fixed (byte* data = animationClipResult.Data)
UpdateEngine.Run(modelNodeDefinition, compiledUpdate, (IntPtr)data, null);
}
Matrix localMatrix;
TransformComponent.CreateMatrixTRS(ref modelNodeDefinition.Transform.Position, ref modelNodeDefinition.Transform.Rotation, ref modelNodeDefinition.Transform.Scale,
out localMatrix);
matrix = Matrix.Multiply(localMatrix, matrix);
}
// Done evaluating, let's decompose matrix
TransformTRS transform;
matrix.Decompose(out transform.Scale, out transform.Rotation, out transform.Position);
// Create a key
translationCurve.KeyFrames.Add(new KeyFrameData<Vector3>(animationKey, transform.Position));
rotationCurve.KeyFrames.Add(new KeyFrameData<Quaternion>(animationKey, transform.Rotation));
scaleCurve.KeyFrames.Add(new KeyFrameData<Vector3>(animationKey, transform.Scale));
}
combinedAnimationClip.AddCurve($"{nameof(ModelNodeTransformation.Transform)}.{nameof(TransformTRS.Position)}", translationCurve);
combinedAnimationClip.AddCurve($"{nameof(ModelNodeTransformation.Transform)}.{nameof(TransformTRS.Rotation)}", rotationCurve);
combinedAnimationClip.AddCurve($"{nameof(ModelNodeTransformation.Transform)}.{nameof(TransformTRS.Scale)}", scaleCurve);
nodeAnimationClip = combinedAnimationClip;
}
foreach (var channel in nodeAnimationClip.Channels)
{
var curve = nodeAnimationClip.Curves[channel.Value.CurveIndex];
// TODO: Root motion
var channelName = channel.Key;
if (channelName.StartsWith("Transform."))
{
animationClip.AddCurve($"[ModelComponent.Key].Skeleton.NodeTransformations[{skeletonMapping.SourceToTarget[nodeIndex]}]." + channelName, curve);
}
}
// Take max of durations
if (animationClip.Duration < nodeAnimationClip.Duration)
animationClip.Duration = nodeAnimationClip.Duration;
}
}
}
if (animationClip == null)
{
commandContext.Logger.Info("File {0} has an empty animation.", SourcePath);
}
else
{
if (animationClip.Duration.Ticks == 0)
{
commandContext.Logger.Warning("File {0} has a 0 tick long animation.", SourcePath);
}
// Optimize and set common parameters
animationClip.RepeatMode = AnimationRepeatMode;
animationClip.Optimize();
}
return animationClip;
}
private object ExportSkeleton(ICommandContext commandContext, ContentManager contentManager)
{
var skeleton = LoadSkeleton(commandContext, contentManager);
var modelNodes = new HashSet<string>(skeleton.Nodes.Select(x => x.Name));
var skeletonNodes = new HashSet<string>(SkeletonNodesWithPreserveInfo.Select(x => x.Key));
// List missing nodes on both sides, to display warnings
var missingNodesInModel = new HashSet<string>(skeletonNodes);
missingNodesInModel.ExceptWith(modelNodes);
var missingNodesInAsset = new HashSet<string>(modelNodes);
missingNodesInAsset.ExceptWith(skeletonNodes);
// Output warnings if skeleton was not properly reimported from latest FBX
if (missingNodesInAsset.Count > 0)
commandContext.Logger.Warning($"{missingNodesInAsset.Count} node(s) were present in model [{SourcePath}] but not in asset [{Location}], please reimport: {string.Join(", ", missingNodesInAsset)}");
if (missingNodesInModel.Count > 0)
commandContext.Logger.Warning($"{missingNodesInModel.Count} node(s) were present in asset [{Location}] but not in model [{SourcePath}], please reimport: {string.Join(", ", missingNodesInModel)}");
// Build node mapping to expected structure
var optimizedNodes = new HashSet<string>(SkeletonNodesWithPreserveInfo.Where(x => !x.Value).Select(x => x.Key));
// Refresh skeleton updater with loaded skeleton (to be able to compute matrices)
var hierarchyUpdater = new SkeletonUpdater(skeleton);
hierarchyUpdater.UpdateMatrices();
// Removed optimized nodes
var filteredSkeleton = new Skeleton { Nodes = skeleton.Nodes.Where(x => !optimizedNodes.Contains(x.Name)).ToArray() };
// Fix parent indices (since we removed some nodes)
for (int i = 0; i < filteredSkeleton.Nodes.Length; ++i)
{
var parentIndex = filteredSkeleton.Nodes[i].ParentIndex;
if (parentIndex != -1)
{
// Find appropriate parent to map to
var newParentIndex = -1;
while (newParentIndex == -1 && parentIndex != -1)
{
var nodeName = skeleton.Nodes[parentIndex].Name;
parentIndex = skeleton.Nodes[parentIndex].ParentIndex;
newParentIndex = filteredSkeleton.Nodes.IndexOf(x => x.Name == nodeName);
}
filteredSkeleton.Nodes[i].ParentIndex = newParentIndex;
}
}
// Generate mapping
var skeletonMapping = new SkeletonMapping(filteredSkeleton, skeleton);
// Children of remapped nodes need to have their matrices updated
for (int i = 0; i < skeleton.Nodes.Length; ++i)
{
// Skip node if it doesn't exist in source skeleton
if (skeletonMapping.SourceToSource[i] != i)
continue;
var node = skeleton.Nodes[i];
var filteredIndex = skeletonMapping.SourceToTarget[i];
var oldParentIndex = node.ParentIndex;
if (oldParentIndex != -1 && skeletonMapping.SourceToSource[oldParentIndex] != oldParentIndex)
{
// Compute matrix for intermediate missing nodes
var transformMatrix = CombineMatricesFromNodeIndices(hierarchyUpdater.NodeTransformations, skeletonMapping.SourceToSource[oldParentIndex], oldParentIndex);
var localMatrix = hierarchyUpdater.NodeTransformations[i].LocalMatrix;
// Combine it with local matrix, and use that instead in the new skeleton; resulting node should be same position as before optimized nodes were removed
localMatrix = Matrix.Multiply(localMatrix, transformMatrix);
localMatrix.Decompose(out filteredSkeleton.Nodes[filteredIndex].Transform.Scale, out filteredSkeleton.Nodes[filteredIndex].Transform.Rotation, out filteredSkeleton.Nodes[filteredIndex].Transform.Position);
}
}
return filteredSkeleton;
}
private object ExportModel(ICommandContext commandContext, ContentManager contentManager)
{
// Read from model file
var modelSkeleton = LoadSkeleton(commandContext, contentManager); // we get model skeleton to compare it to real skeleton we need to map to
var model = LoadModel(commandContext, contentManager);
// Apply materials
foreach (var modelMaterial in Materials)
{
if (modelMaterial.MaterialInstance?.Material == null)
{
commandContext.Logger.Warning($"The material [{modelMaterial.Name}] is null in the list of materials.");
continue;
}
model.Materials.Add(modelMaterial.MaterialInstance);
}
model.BoundingBox = BoundingBox.Empty;
foreach (var mesh in model.Meshes)
{
if (TessellationAEN)
{
// TODO: Generate AEN model view
commandContext.Logger.Error("TessellationAEN is not supported in {0}", ContextAsString);
}
}
SkeletonMapping skeletonMapping;
Skeleton skeleton;
if (SkeletonUrl != null)
{
// Load skeleton and process it
skeleton = contentManager.Load<Skeleton>(SkeletonUrl);
// Assign skeleton to model
model.Skeleton = AttachedReferenceManager.CreateProxyObject<Skeleton>(Guid.Empty, SkeletonUrl);
}
else
{
skeleton = null;
}
skeletonMapping = new SkeletonMapping(skeleton, modelSkeleton);
// Refresh skeleton updater with model skeleton
var hierarchyUpdater = new SkeletonUpdater(modelSkeleton);
hierarchyUpdater.UpdateMatrices();
// Move meshes in the new nodes
foreach (var mesh in model.Meshes)
{
// Check if there was a remap using model skeleton
if (skeletonMapping.SourceToSource[mesh.NodeIndex] != mesh.NodeIndex)
{
// Transform vertices
var transformationMatrix = CombineMatricesFromNodeIndices(hierarchyUpdater.NodeTransformations, skeletonMapping.SourceToSource[mesh.NodeIndex], mesh.NodeIndex);
mesh.Draw.VertexBuffers[0].TransformBuffer(ref transformationMatrix);
// Check if geometry is inverted, to know if we need to reverse winding order
// TODO: What to do if there is no index buffer? We should create one... (not happening yet)
if (mesh.Draw.IndexBuffer == null)
throw new InvalidOperationException();
Matrix rotation;
Vector3 scale, translation;
if (transformationMatrix.Decompose(out scale, out rotation, out translation)
&& scale.X * scale.Y * scale.Z < 0)
{
mesh.Draw.ReverseWindingOrder();
}
}
// Update new node index using real asset skeleton
mesh.NodeIndex = skeletonMapping.SourceToTarget[mesh.NodeIndex];
}
// Merge meshes with same parent nodes, material and skinning
var meshesByNodes = model.Meshes.GroupBy(x => x.NodeIndex).ToList();
foreach (var meshesByNode in meshesByNodes)
{
// This logic to detect similar material is kept from old code; this should be reviewed/improved at some point
foreach (var meshesPerDrawCall in meshesByNode.GroupBy(x => x,
new AnonymousEqualityComparer<Mesh>((x, y) =>
x.MaterialIndex == y.MaterialIndex // Same material
&& ArrayExtensions.ArraysEqual(x.Skinning?.Bones, y.Skinning?.Bones) // Same bones
&& CompareParameters(model, x, y) // Same parameters
&& CompareShadowOptions(model, x, y), // Same shadow parameters
x => 0)).ToList())
{
if (meshesPerDrawCall.Count() == 1)
{
// Nothing to group, skip to next entry
continue;
}
// Remove old meshes
foreach (var mesh in meshesPerDrawCall)
{
model.Meshes.Remove(mesh);
}
// Add new combined mesh(es)
var baseMesh = meshesPerDrawCall.First();
var newMeshList = meshesPerDrawCall.Select(x => x.Draw).ToList().GroupDrawData(Allow32BitIndex);
foreach (var generatedMesh in newMeshList)
{
model.Meshes.Add(new Mesh(generatedMesh, baseMesh.Parameters)
{
MaterialIndex = baseMesh.MaterialIndex,
Name = baseMesh.Name,
Draw = generatedMesh,
NodeIndex = baseMesh.NodeIndex,
Skinning = baseMesh.Skinning,
});
}
}
}
// Remap skinning
foreach (var skinning in model.Meshes.Select(x => x.Skinning).Where(x => x != null).Distinct())
{
// Update node mapping
// Note: we only remap skinning matrices, but we could directly remap skinning bones instead
for (int i = 0; i < skinning.Bones.Length; ++i)
{
var nodeIndex = skinning.Bones[i].NodeIndex;
var newNodeIndex = skeletonMapping.SourceToSource[nodeIndex];
skinning.Bones[i].NodeIndex = skeletonMapping.SourceToTarget[nodeIndex];
// If it was remapped, we also need to update matrix
if (newNodeIndex != nodeIndex)
{
var transformationMatrix = CombineMatricesFromNodeIndices(hierarchyUpdater.NodeTransformations, newNodeIndex, nodeIndex);
skinning.Bones[i].LinkToMeshMatrix = Matrix.Multiply(skinning.Bones[i].LinkToMeshMatrix, transformationMatrix);
}
}
}
// split the meshes if necessary
model.Meshes = SplitExtensions.SplitMeshes(model.Meshes, Allow32BitIndex);
// Refresh skeleton updater with asset skeleton
hierarchyUpdater = new SkeletonUpdater(skeleton);
hierarchyUpdater.UpdateMatrices();
// bounding boxes
var modelBoundingBox = model.BoundingBox;
var modelBoundingSphere = model.BoundingSphere;
foreach (var mesh in model.Meshes)
{
var vertexBuffers = mesh.Draw.VertexBuffers;
if (vertexBuffers.Length > 0)
{
// Compute local mesh bounding box (no node transformation)
Matrix matrix = Matrix.Identity;
mesh.BoundingBox = vertexBuffers[0].ComputeBounds(ref matrix, out mesh.BoundingSphere);
// Compute model bounding box (includes node transformation)
hierarchyUpdater.GetWorldMatrix(mesh.NodeIndex, out matrix);
BoundingSphere meshBoundingSphere;
var meshBoundingBox = vertexBuffers[0].ComputeBounds(ref matrix, out meshBoundingSphere);
BoundingBox.Merge(ref modelBoundingBox, ref meshBoundingBox, out modelBoundingBox);
BoundingSphere.Merge(ref modelBoundingSphere, ref meshBoundingSphere, out modelBoundingSphere);
}
// TODO: temporary Always try to compact
mesh.Draw.CompactIndexBuffer();
}
model.BoundingBox = modelBoundingBox;
model.BoundingSphere = modelBoundingSphere;
// merges all the Draw VB and IB together to produce one final VB and IB by entity.
var sizeVertexBuffer = model.Meshes.SelectMany(x => x.Draw.VertexBuffers).Select(x => x.Buffer.GetSerializationData().Content.Length).Sum();
var sizeIndexBuffer = 0;
foreach (var x in model.Meshes)
{
// Let's be aligned (if there was 16bit indices before, we might be off)
if (x.Draw.IndexBuffer.Is32Bit && sizeIndexBuffer % 4 != 0)
sizeIndexBuffer += 2;
sizeIndexBuffer += x.Draw.IndexBuffer.Buffer.GetSerializationData().Content.Length;
}
var vertexBuffer = new BufferData(BufferFlags.VertexBuffer, new byte[sizeVertexBuffer]);
var indexBuffer = new BufferData(BufferFlags.IndexBuffer, new byte[sizeIndexBuffer]);
// Note: reusing same instance, to avoid having many VB with same hash but different URL
var vertexBufferSerializable = vertexBuffer.ToSerializableVersion();
var indexBufferSerializable = indexBuffer.ToSerializableVersion();
var vertexBufferNextIndex = 0;
var indexBufferNextIndex = 0;
foreach (var drawMesh in model.Meshes.Select(x => x.Draw))
{
// the index buffer
var oldIndexBuffer = drawMesh.IndexBuffer.Buffer.GetSerializationData().Content;
// Let's be aligned (if there was 16bit indices before, we might be off)
if (drawMesh.IndexBuffer.Is32Bit && indexBufferNextIndex % 4 != 0)
indexBufferNextIndex += 2;
Array.Copy(oldIndexBuffer, 0, indexBuffer.Content, indexBufferNextIndex, oldIndexBuffer.Length);
drawMesh.IndexBuffer = new IndexBufferBinding(indexBufferSerializable, drawMesh.IndexBuffer.Is32Bit, drawMesh.IndexBuffer.Count, indexBufferNextIndex);
indexBufferNextIndex += oldIndexBuffer.Length;
// the vertex buffers
for (int index = 0; index < drawMesh.VertexBuffers.Length; index++)
{
var vertexBufferBinding = drawMesh.VertexBuffers[index];
var oldVertexBuffer = vertexBufferBinding.Buffer.GetSerializationData().Content;
Array.Copy(oldVertexBuffer, 0, vertexBuffer.Content, vertexBufferNextIndex, oldVertexBuffer.Length);
drawMesh.VertexBuffers[index] = new VertexBufferBinding(vertexBufferSerializable, vertexBufferBinding.Declaration, vertexBufferBinding.Count, vertexBufferBinding.Stride,
vertexBufferNextIndex);
vertexBufferNextIndex += oldVertexBuffer.Length;
}
}
// Convert to Entity
return model;
}