Better underlying storage

[Scobalula]

Currently CastArrayProperty handles all types except strings, the problem comes when we have variable types such as face indices, key frames, etc. This currently results in ugly code at runtime to do checks for which type it is.

Could possibly stored data in a raw byte buffer, with the ID, stride, etc. and allow scalar conversions at runtime using INumber from System.Numerics?

Also need a solution that caters to Vectors, maybe separate methods for them and methods for Scalars?

        // methods of CastBuffer or CastArray or keep existing CastArrayProperty name
        public TOut GetScalar<TOut>(int index) where TOut : unmanaged, INumberBase<TOut> // should handle widening via TOut.CreateChecked/CreateSaturated

        public TOut Get<TOut>(int index) where TOut : unmanaged // throw error if 

The underlying buffers should remain inaccessible (or provide a GetRawBuffer method) and the conversions should be invisible to the end user

Other solution would be to create NumericBuffer, etc.

[Scobalula]

Preferring CreateChecked as the method should throw exception if the data cannot fit in the requested data type.

[Scobalula]

Something like this with a hidden byte buffer as the underlying storage instead:

        public TOut GetScalar<TOut>(int index) where TOut : unmanaged, INumberBase<TOut>
        {
            ref byte slot = ref _data[index * _stride];

            if (KindOf<TOut>() == Identifier)
                return Unsafe.ReadUnaligned<TOut>(ref slot);

            return Identifier switch
            {
                CastPropertyIdentifier.Byte       => ConvertScalar<byte, TOut>(ref slot),
                CastPropertyIdentifier.Short      => ConvertScalar<ushort, TOut>(ref slot),
                CastPropertyIdentifier.Integer32  => ConvertScalar<uint, TOut>(ref slot),
                CastPropertyIdentifier.Integer64  => ConvertScalar<ulong, TOut>(ref slot),
                CastPropertyIdentifier.Float      => ConvertScalar<float, TOut>(ref slot),
                CastPropertyIdentifier.Double     => ConvertScalar<double, TOut>(ref slot),

                _ => throw new InvalidCastException(
                         $"Stored value is {Identifier}, not a scalar numeric type")
            };
        }

        public Vector2 GetVector2(int index)
            => GetVector<Vector2>(index, CastPropertyIdentifier.Vector2);

        public Vector3 GetVector3(int index)
            => GetVector<Vector3>(index, CastPropertyIdentifier.Vector3);

        public Vector4 GetVector4(int index)
            => GetVector<Vector4>(index, CastPropertyIdentifier.Vector4);

[Scobalula]

For now to maintain existing code, adding helper methods to some nodes:

        /// <summary>
        /// Enumerates through key frames.
        /// </summary>
        /// <returns>An enumerable collection of the key frames.</returns>
        /// <exception cref="NotSupportedException">Thrown if the underlying <see cref="CastProperty"/> type is not supported.</exception>
        public IEnumerable<double> EnumerateKeyFrames()
        {
            return KeyFrameBuffer switch
            {
                CastArrayProperty<byte> { Values: var v }   => v.Select(x => (double)x),
                CastArrayProperty<ushort> { Values: var v } => v.Select(x => (double)x),
                CastArrayProperty<uint> { Values: var v }   => v.Select(x => (double)x),
                _ => throw new NotSupportedException($"Unimplemented buffer type {KeyFrameBuffer.GetType()}")
            };
        }

This issue will involve careful consideration, especially taking into account existing code depending on the current implementation.