DotRecastNetSim/src/DotRecast.Core/ByteBuffer.cs

using System;
using System.Buffers.Binary;

namespace DotRecast.Core
{


public class ByteBuffer
{
    private ByteOrder _order;
    private byte[] _bytes;
    private int _position;

    public ByteBuffer(byte[] bytes)
    {
        _order = BitConverter.IsLittleEndian
            ? ByteOrder.LITTLE_ENDIAN
            : ByteOrder.BIG_ENDIAN;

        _bytes = bytes;
        _position = 0;
    }

    public ByteOrder order()
    {
        return _order;
    }

    public void order(ByteOrder order)
    {
        _order = order;
    }

    public int limit() {
        return _bytes.Length - _position;
    }
    
    public int remaining() {
        int rem = limit();
        return rem > 0 ? rem : 0;
    }


    public void position(int pos)
    {
        _position = pos;
    }

    public int position()
    {
        return _position;
    }

    public Span<byte> ReadBytes(int length)
    {
        var nextPos = _position + length;
        (nextPos, _position) = (_position, nextPos);

        return _bytes.AsSpan(nextPos, length);
    }

    public byte get()
    {
        var span = ReadBytes(1);
        return span[0];
    }

    public short getShort()
    {
        var span = ReadBytes(2);
        if (_order == ByteOrder.BIG_ENDIAN)
        {
            return BinaryPrimitives.ReadInt16BigEndian(span);
        }
        else
        {
            return BinaryPrimitives.ReadInt16LittleEndian(span);
        }
    }


    public int getInt()
    {
        var span = ReadBytes(4);
        if (_order == ByteOrder.BIG_ENDIAN)
        {
            return BinaryPrimitives.ReadInt32BigEndian(span);
        }
        else
        {
            return BinaryPrimitives.ReadInt32LittleEndian(span);
        }
    }

    public float getFloat()
    {
        var span = ReadBytes(4);
        if (_order == ByteOrder.BIG_ENDIAN && BitConverter.IsLittleEndian)
        {
            span.Reverse();
        }
        else if (_order == ByteOrder.LITTLE_ENDIAN && !BitConverter.IsLittleEndian)
        {
            span.Reverse();
        }

        return BitConverter.ToSingle(span);
    }

    public long getLong()
    {
        var span = ReadBytes(8);
        if (_order == ByteOrder.BIG_ENDIAN)
        {
            return BinaryPrimitives.ReadInt64BigEndian(span);
        }
        else
        {
            return BinaryPrimitives.ReadInt64LittleEndian(span);
        }
    }
    
    public void putFloat(float v)
    {
        // ?
    }

    public void putInt(int v)
    {
        // ?
    }
}
}