WriteSettings constructor is now public.

reversed c# 8 feature.
split runtime files.

Author: vpenades

src/SharpGLTF.Core/Runtime/Drawables.cs

@@ -0,0 +1,132 @@
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using System.Text;
+
+namespace SharpGLTF.Runtime
+{
+    /// <summary>
+    /// Defines a reference to a drawable mesh
+    /// </summary>
+    abstract class DrawableReference
+    {
+        #region lifecycle
+
+        protected DrawableReference(Schema2.Node node)
+        {
+            _LogicalMeshIndex = node.Mesh.LogicalIndex;
+        }
+
+        #endregion
+
+        #region data
+
+        private readonly int _LogicalMeshIndex;
+
+        #endregion
+
+        #region properties
+
+        /// <summary>
+        /// Gets the index of a <see cref="Schema2.Mesh"/> in <see cref="Schema2.ModelRoot.LogicalMeshes"/>
+        /// </summary>
+        public int LogicalMeshIndex => _LogicalMeshIndex;
+
+        #endregion
+
+        #region API
+
+        public abstract Transforms.IGeometryTransform CreateGeometryTransform();
+
+        public abstract void UpdateGeometryTransform(Transforms.IGeometryTransform geoxform, IReadOnlyList<NodeInstance> instances);
+
+        #endregion
+    }
+
+    /// <summary>
+    /// Defines a reference to a drawable rigid mesh
+    /// </summary>
+    sealed class RigidDrawableReference : DrawableReference
+    {
+        #region lifecycle
+
+        internal RigidDrawableReference(Schema2.Node node, Func<Schema2.Node, int> indexFunc)
+            : base(node)
+        {
+            _NodeIndex = indexFunc(node);
+        }
+
+        #endregion
+
+        #region data
+
+        private readonly int _NodeIndex;
+
+        #endregion
+
+        #region API
+
+        public override Transforms.IGeometryTransform CreateGeometryTransform() { return new Transforms.RigidTransform(); }
+
+        public override void UpdateGeometryTransform(Transforms.IGeometryTransform rigidTransform, IReadOnlyList<NodeInstance> instances)
+        {
+            var node = instances[_NodeIndex];
+
+            var statxform = (Transforms.RigidTransform)rigidTransform;
+            statxform.Update(node.WorldMatrix);
+            statxform.Update(node.MorphWeights, false);
+        }
+
+        #endregion
+    }
+
+    /// <summary>
+    /// Defines a reference to a drawable skinned mesh
+    /// </summary>
+    sealed class SkinnedDrawableReference : DrawableReference
+    {
+        #region lifecycle
+
+        internal SkinnedDrawableReference(Schema2.Node node, Func<Schema2.Node, int> indexFunc)
+            : base(node)
+        {
+            var skin = node.Skin;
+
+            _MorphNodeIndex = indexFunc(node);
+
+            _JointsNodeIndices = new int[skin.JointsCount];
+            _BindMatrices = new Matrix4x4[skin.JointsCount];
+
+            for (int i = 0; i < _JointsNodeIndices.Length; ++i)
+            {
+                var (j, ibm) = skin.GetJoint(i);
+
+                _JointsNodeIndices[i] = indexFunc(j);
+                _BindMatrices[i] = ibm;
+            }
+        }
+
+        #endregion
+
+        #region data
+
+        private readonly int _MorphNodeIndex;
+        private readonly int[] _JointsNodeIndices;
+        private readonly Matrix4x4[] _BindMatrices;
+
+        #endregion
+
+        #region API
+
+        public override Transforms.IGeometryTransform CreateGeometryTransform() { return new Transforms.SkinnedTransform(); }
+
+        public override void UpdateGeometryTransform(Transforms.IGeometryTransform skinnedTransform, IReadOnlyList<NodeInstance> instances)
+        {
+            var skinxform = (Transforms.SkinnedTransform)skinnedTransform;
+            skinxform.Update(_JointsNodeIndices.Length, idx => _BindMatrices[idx], idx => instances[_JointsNodeIndices[idx]].WorldMatrix);
+            skinxform.Update(instances[_MorphNodeIndex].MorphWeights, false);
+        }
+
+        #endregion
+    }
+}

src/SharpGLTF.Core/Runtime/NodeInstance.cs

@@ -0,0 +1,118 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+using SharpGLTF.Transforms;
+
+using XFORM = System.Numerics.Matrix4x4;
+
+namespace SharpGLTF.Runtime
+{
+    /// <summary>
+    /// Defines a node of a scene graph in <see cref="SceneInstance"/>
+    /// </summary>
+    [System.Diagnostics.DebuggerDisplay("{Name}")]
+    public sealed class NodeInstance
+    {
+        #region lifecycle
+
+        internal NodeInstance(NodeTemplate template, NodeInstance parent)
+        {
+            _Template = template;
+            _Parent = parent;
+        }
+
+        #endregion
+
+        #region data
+
+        private readonly NodeTemplate _Template;
+        private readonly NodeInstance _Parent;
+
+        private XFORM _LocalMatrix;
+        private XFORM? _WorldMatrix;
+
+        private SparseWeight8 _MorphWeights;
+
+        #endregion
+
+        #region properties
+
+        public String Name => _Template.Name;
+
+        public NodeInstance VisualParent => _Parent;
+
+        public SparseWeight8 MorphWeights
+        {
+            get => _MorphWeights;
+            set => _MorphWeights = value;
+        }
+
+        public XFORM LocalMatrix
+        {
+            get => _LocalMatrix;
+            set
+            {
+                _LocalMatrix = value;
+                _WorldMatrix = null;
+            }
+        }
+
+        public XFORM WorldMatrix
+        {
+            get => _GetWorldMatrix();
+            set => _SetWorldMatrix(value);
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether any of the transforms down the scene tree has been modified.
+        /// </summary>
+        private bool TransformChainIsDirty
+        {
+            get
+            {
+                if (!_WorldMatrix.HasValue) return true;
+
+                return _Parent == null ? false : _Parent.TransformChainIsDirty;
+            }
+        }
+
+        #endregion
+
+        #region API
+
+        private XFORM _GetWorldMatrix()
+        {
+            if (!TransformChainIsDirty) return _WorldMatrix.Value;
+
+            _WorldMatrix = _Parent == null ? _LocalMatrix : XFORM.Multiply(_LocalMatrix, _Parent.WorldMatrix);
+
+            return _WorldMatrix.Value;
+        }
+
+        private void _SetWorldMatrix(XFORM xform)
+        {
+            if (_Parent == null) { LocalMatrix = xform; return; }
+
+            XFORM.Invert(_Parent._GetWorldMatrix(), out XFORM ipwm);
+
+            LocalMatrix = XFORM.Multiply(xform, ipwm);
+        }
+
+        public void SetPoseTransform() { SetAnimationFrame(-1, 0); }
+
+        public void SetAnimationFrame(int trackLogicalIndex, float time)
+        {
+            this.MorphWeights = _Template.GetMorphWeights(trackLogicalIndex, time);
+            this.LocalMatrix = _Template.GetLocalMatrix(trackLogicalIndex, time);
+        }
+
+        public void SetAnimationFrame(ReadOnlySpan<int> track, ReadOnlySpan<float> time, ReadOnlySpan<float> weight)
+        {
+            this.MorphWeights = _Template.GetMorphWeights(track, time, weight);
+            this.LocalMatrix = _Template.GetLocalMatrix(track, time, weight);
+        }
+
+        #endregion
+    }
+}