@dcl/protocol 1.0.0-2731649607.commit-890a990 → 1.0.0-27574288540.commit-f0df3e0

package/protoc-gen-bitwise/generator_csharp.js

@@ -0,0 +1,215 @@
+'use strict'
+
+/**
+ * C# code generator for the protoc-gen-bitwise plugin.
+ *
+ * For every proto message that contains at least one uint32 field annotated
+ * with [(quantized)], this module emits a C# partial class that adds a computed
+ * float property named {FieldName}Quantized. The getter decodes the stored
+ * uint32 to a float; the setter encodes a float back to a uint32. Standard
+ * protobuf handles serialization of the uint32 wire field; this class adds a
+ * typed float accessor on top.
+ *
+ * Only uint32 fields are supported. bit_packed and unannotated fields are
+ * passed through without generating any accessor.
+ *
+ * Port of the original generator_csharp.py — output is intended to be
+ * byte-for-byte identical.
+ */
+
+const { getFieldOptions } = require('./options')
+
+// FieldDescriptorProto type/label constants.
+const TYPE_UINT32 = 13
+const LABEL_REPEATED = 3
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Mirrors Python str.capitalize(): upper-first, lowercase the rest. */
+function capitalize(word) {
+  if (word.length === 0) return ''
+  return word[0].toUpperCase() + word.slice(1).toLowerCase()
+}
+
+/** position_x -> PositionX */
+function snakeToPascal(name) {
+  return name.split('_').map(capitalize).join('')
+}
+
+/** decentraland.kernel.comms.v3 -> Decentraland.Kernel.Comms.V3 */
+function packageToNamespace(pkg) {
+  if (!pkg) return 'Generated'
+  return pkg.split('.').map(capitalize).join('.')
+}
+
+/**
+ * Format a number with C printf %g semantics at `precision` significant digits:
+ * shortest of fixed/scientific, with trailing zeros and a trailing dot removed.
+ * Reproduces Python's `f'{value:.{precision}g}'`.
+ */
+function formatG(value, precision) {
+  if (precision <= 0) precision = 1
+  if (value === 0) return '0'
+  if (!Number.isFinite(value)) return value > 0 ? 'inf' : 'nan'
+
+  const negative = value < 0
+  const v = Math.abs(value)
+
+  // Correctly-rounded scientific form yields the decimal exponent X (handling
+  // carry such as 9.999 -> 1.0e+1).
+  const sci = v.toExponential(precision - 1)
+  const eIdx = sci.indexOf('e')
+  const X = parseInt(sci.slice(eIdx + 1), 10)
+
+  let result
+  if (X >= -4 && X < precision) {
+    // Fixed notation with (precision - 1 - X) fraction digits.
+    const fractionDigits = precision - 1 - X
+    result = v.toFixed(fractionDigits >= 0 ? fractionDigits : 0)
+    if (result.indexOf('.') !== -1) {
+      result = result.replace(/0+$/, '').replace(/\.$/, '')
+    }
+  } else {
+    // Scientific notation; printf prints at least two exponent digits.
+    let mantissa = sci.slice(0, eIdx)
+    if (mantissa.indexOf('.') !== -1) {
+      mantissa = mantissa.replace(/0+$/, '').replace(/\.$/, '')
+    }
+    const expSign = X < 0 ? '-' : '+'
+    let expDigits = String(Math.abs(X))
+    if (expDigits.length < 2) expDigits = '0' + expDigits
+    result = mantissa + 'e' + expSign + expDigits
+  }
+
+  return (negative ? '-' : '') + result
+}
+
+/** Format a value as a C# float literal (e.g. -100.0f). */
+function formatFloat(value) {
+  let text = formatG(value, 8)
+  if (text.indexOf('.') === -1 && text.indexOf('e') === -1 && text.indexOf('E') === -1) {
+    text += '.0'
+  }
+  return text + 'f'
+}
+
+/** Format a quantization step size for a doc comment (e.g. "≈ 0.003"). */
+function formatStep(step) {
+  return '≈ ' + formatG(step, 6)
+}
+
+// ---------------------------------------------------------------------------
+// Per-message code generation
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate a C# partial class for a proto message, or null if it has no
+ * quantized uint32 fields. Returns an array of lines (no trailing newline).
+ */
+function generateMessage(msgProto, indent) {
+  const i = indent || '    '
+  const props = []
+
+  for (const field of msgProto.field) {
+    // Repeated/map fields are not supported.
+    if (field.label === LABEL_REPEATED) continue
+    // Only uint32 fields are candidates for quantized accessors.
+    if (field.type !== TYPE_UINT32) continue
+
+    const { quantized } = getFieldOptions(field.optionsRaw)
+    if (quantized === null) continue
+
+    const step = (quantized.max - quantized.min) / ((1 << quantized.bits) - 1)
+
+    props.push({
+      propName: snakeToPascal(field.name),
+      mn: formatFloat(quantized.min),
+      mx: formatFloat(quantized.max),
+      bits: quantized.bits,
+      step,
+    })
+  }
+
+  if (props.length === 0) return null
+
+  const backings = []
+  const lines = []
+  lines.push(`public partial class ${msgProto.name}`)
+  lines.push('{')
+
+  for (const { propName, mn, mx, bits, step } of props) {
+    const backing = '_' + propName[0].toLowerCase() + propName.slice(1)
+    backings.push(backing)
+    lines.push(`${i}private float? ${backing};`)
+    lines.push(
+      `${i}/// <summary>Float accessor for <see cref="${propName}"/>. Range [${mn}, ${mx}], ${bits} bits, step ${formatStep(step)}.</summary>`,
+    )
+    lines.push(`${i}public float ${propName}Quantized`)
+    lines.push(`${i}{`)
+    lines.push(`${i}${i}get => ${backing} ??= Quantize.Decode(${propName}, ${mn}, ${mx}, ${bits});`)
+    lines.push(`${i}${i}set { ${backing} = value; ${propName} = Quantize.Encode(value, ${mn}, ${mx}, ${bits}); }`)
+    lines.push(`${i}}`)
+    lines.push('')
+  }
+
+  lines.push(`${i}/// <summary>Clears all cached decoded values. Call after mutating raw uint32 fields directly.</summary>`)
+  lines.push(`${i}public void ResetDecodedCache()`)
+  lines.push(`${i}{`)
+  for (const backing of backings) {
+    lines.push(`${i}${i}${backing} = null;`)
+  }
+  lines.push(`${i}}`)
+
+  lines.push('}')
+  return lines
+}
+
+// ---------------------------------------------------------------------------
+// Per-file code generation (public entry point)
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate a C# source file for a FileDescriptorProto, or null if the file
+ * contains no quantized uint32 fields.
+ * @returns {{name: string, content: string} | null}
+ */
+function generateCsharp(fileProto) {
+  const namespace = packageToNamespace(fileProto.package)
+
+  const protoFile = fileProto.name.split('/').pop()
+  const stem = snakeToPascal(protoFile.replace('.proto', ''))
+  const outName = `${stem}.Bitwise.cs`
+
+  const header = [
+    '// <auto-generated>',
+    '//   Generated by protoc-gen-bitwise. DO NOT EDIT.',
+    `//   Source: ${fileProto.name}`,
+    '// </auto-generated>',
+    '',
+    'using Decentraland.Networking.Bitwise;',
+    '',
+    `namespace ${namespace}`,
+    '{',
+  ]
+  const footer = ['', `} // namespace ${namespace}`]
+
+  const body = []
+  for (const msg of fileProto.messageType) {
+    const msgLines = generateMessage(msg)
+    if (msgLines === null) continue
+    // Indent each line by 4 spaces (inside the namespace block).
+    for (const line of msgLines) {
+      body.push(line ? '    ' + line : '')
+    }
+    body.push('')
+  }
+
+  if (body.length === 0) return null
+
+  const content = header.concat(body, footer).join('\n') + '\n'
+  return { name: outName, content }
+}
+
+module.exports = { generateCsharp }

package/protoc-gen-bitwise/options.js

@@ -0,0 +1,108 @@
+'use strict'
+
+/**
+ * Parser for the custom bitwise field options defined in options.proto.
+ *
+ * The descriptor decoder hands us the raw serialized FieldOptions bytes (it
+ * declares `options` as opaque bytes). We walk those bytes looking for the two
+ * custom extension field numbers — protobuf preserves unknown/unregistered
+ * extension bytes, so they are always present even though no runtime here knows
+ * the extension schema. This mirrors the original options_pb2.py.
+ *
+ * Wire format: tag = (field_number << 3) | wire_type
+ *   wire_type 0 = varint, 1 = 64-bit, 2 = length-delimited, 5 = 32-bit
+ */
+
+const { readVarint, skipField } = require('./wire')
+
+// Extension field numbers as defined in options.proto.
+const QUANTIZED_FIELD_NUMBER = 50001
+const BIT_PACKED_FIELD_NUMBER = 50002
+
+/** Parse a serialized QuantizedFloatOptions message: { min, max, bits }. */
+function parseQuantized(data) {
+  const opts = { min: 0.0, max: 0.0, bits: 0 }
+  let pos = 0
+  while (pos < data.length) {
+    let tag
+    ;[tag, pos] = readVarint(data, pos)
+    const fieldNum = tag >>> 3
+    const wireType = tag & 0x7
+    if (fieldNum === 1 && wireType === 5) {
+      // min (float)
+      opts.min = data.readFloatLE(pos)
+      pos += 4
+    } else if (fieldNum === 2 && wireType === 5) {
+      // max (float)
+      opts.max = data.readFloatLE(pos)
+      pos += 4
+    } else if (fieldNum === 3 && wireType === 0) {
+      // bits (uint32)
+      ;[opts.bits, pos] = readVarint(data, pos)
+    } else {
+      pos = skipField(data, pos, wireType)
+    }
+  }
+  return opts
+}
+
+/** Parse a serialized BitPackedOptions message: { bits }. */
+function parseBitPacked(data) {
+  const opts = { bits: 0 }
+  let pos = 0
+  while (pos < data.length) {
+    let tag
+    ;[tag, pos] = readVarint(data, pos)
+    const fieldNum = tag >>> 3
+    const wireType = tag & 0x7
+    if (fieldNum === 1 && wireType === 0) {
+      // bits (uint32)
+      ;[opts.bits, pos] = readVarint(data, pos)
+    } else {
+      pos = skipField(data, pos, wireType)
+    }
+  }
+  return opts
+}
+
+/**
+ * Extract custom bitwise options from raw FieldOptions bytes.
+ *
+ * @param {Buffer|null} optionsRaw serialized FieldOptions, or null when unset.
+ * @returns {{quantized: object|null, bitPacked: object|null}}
+ */
+function getFieldOptions(optionsRaw) {
+  if (!optionsRaw || optionsRaw.length === 0) {
+    return { quantized: null, bitPacked: null }
+  }
+
+  let quantized = null
+  let bitPacked = null
+  let pos = 0
+
+  while (pos < optionsRaw.length) {
+    let tag
+    ;[tag, pos] = readVarint(optionsRaw, pos)
+    const fieldNum = tag >>> 3
+    const wireType = tag & 0x7
+
+    if (wireType === 2) {
+      let len
+      ;[len, pos] = readVarint(optionsRaw, pos)
+      const valueBytes = optionsRaw.subarray(pos, pos + len)
+      pos += len
+      if (fieldNum === QUANTIZED_FIELD_NUMBER) {
+        quantized = parseQuantized(valueBytes)
+      } else if (fieldNum === BIT_PACKED_FIELD_NUMBER) {
+        bitPacked = parseBitPacked(valueBytes)
+      }
+      // else: unknown length-delimited field — already consumed.
+    } else {
+      pos = skipField(optionsRaw, pos, wireType)
+    }
+  }
+
+  return { quantized, bitPacked }
+}
+
+module.exports = { getFieldOptions }

package/protoc-gen-bitwise/plugin.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+'use strict'
+
+/**
+ * protoc-gen-bitwise — protoc plugin that generates C# bitwise serialization code.
+ *
+ * Protocol:
+ *   1. protoc writes a serialised CodeGeneratorRequest to this process's stdin.
+ *   2. This plugin reads it, generates C# partial classes with float accessor
+ *      properties for every message that carries [(quantized)] field annotations.
+ *   3. A serialised CodeGeneratorResponse is written to stdout.
+ *
+ * Implemented in plain Node with a self-contained protobuf wire codec (see
+ * wire.js) so it runs with only `node` on PATH — no npm install required, even
+ * when invoked directly from a sibling checkout.
+ *
+ * Usage (from project root):
+ *   protoc \
+ *     --proto_path=proto \
+ *     --bitwise_out=generated/ \
+ *     --plugin=protoc-gen-bitwise=protoc-gen-bitwise/plugin.js \
+ *     proto/my_messages.proto
+ *
+ * On Windows, protoc needs an executable wrapper, e.g. a .cmd that runs:
+ *   node "<path>\protoc-gen-bitwise\plugin.js" %*
+ */
+
+const { decodeRequest, encodeResponse } = require('./wire')
+const { generateCsharp } = require('./generator_csharp')
+
+// CodeGeneratorResponse.Feature.FEATURE_PROTO3_OPTIONAL — advertised so protoc
+// does not reject the plugin when the schema uses proto3 `optional` fields.
+const FEATURE_PROTO3_OPTIONAL = 1
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    process.stdin.on('data', (chunk) => chunks.push(chunk))
+    process.stdin.on('end', () => resolve(Buffer.concat(chunks)))
+    process.stdin.on('error', reject)
+  })
+}
+
+async function main() {
+  const requestBytes = await readStdin()
+  const request = decodeRequest(requestBytes)
+
+  // Lookup map for all file descriptors (parity with the Python plugin).
+  const fileByName = new Map()
+  for (const file of request.protoFile) fileByName.set(file.name, file)
+
+  const files = []
+  let error = null
+
+  for (const fileName of request.fileToGenerate) {
+    // Skip the options definition file itself — it has no messages to generate.
+    if (fileName === 'decentraland/common/options.proto') continue
+
+    const fileProto = fileByName.get(fileName)
+    if (!fileProto) continue
+
+    try {
+      const generated = generateCsharp(fileProto)
+      if (generated) files.push(generated)
+    } catch (exc) {
+      error = `protoc-gen-bitwise: error processing ${fileName}: ${exc && exc.message ? exc.message : exc}`
+    }
+  }
+
+  const response = encodeResponse({
+    error,
+    supportedFeatures: FEATURE_PROTO3_OPTIONAL,
+    files,
+  })
+
+  // Let the write flush before the process exits (do not call process.exit()).
+  process.stdout.write(response)
+}
+
+main().catch((exc) => {
+  const response = encodeResponse({
+    error: `protoc-gen-bitwise: ${exc && exc.stack ? exc.stack : exc}`,
+    supportedFeatures: FEATURE_PROTO3_OPTIONAL,
+    files: [],
+  })
+  process.stdout.write(response)
+})

package/protoc-gen-bitwise/runtime/cs/BitReader.cs

@@ -0,0 +1,112 @@
+// Decentraland.Networking.Bitwise — BitReader
+// Copy this file into your Unity project alongside generated *.Bitwise.cs files.
+
+using System;
+
+namespace Decentraland.Networking.Bitwise
+{
+    /// <summary>
+    /// Reads bits from a byte buffer, MSB first within each byte (big-endian bit
+    /// order).  Symmetric counterpart of <see cref="BitWriter"/>: every
+    /// Write… call has a corresponding Read… call with identical arguments that
+    /// reproduces the original value.
+    /// </summary>
+    public sealed class BitReader
+    {
+        private readonly byte[] _buffer;
+        private int _bitPos;
+
+        /// <param name="buffer">Source buffer filled by a <see cref="BitWriter"/>.</param>
+        public BitReader(byte[] buffer)
+        {
+            _buffer = buffer ?? throw new ArgumentNullException(nameof(buffer));
+            _bitPos = 0;
+        }
+
+        /// <summary>Current read position in bits.</summary>
+        public int BitPosition => _bitPos;
+
+        /// <summary>
+        /// Returns <c>true</c> when all written bits have been consumed
+        /// (i.e. <see cref="BitPosition"/> has reached the end of the buffer).
+        /// </summary>
+        public bool IsAtEnd => _bitPos >= _buffer.Length * 8;
+
+        // -----------------------------------------------------------------
+        // Core primitive
+        // -----------------------------------------------------------------
+
+        /// <summary>
+        /// Reads <paramref name="bits"/> bits and returns them as the
+        /// least-significant bits of a <see cref="uint"/>, MSB first.
+        /// </summary>
+        public uint ReadBits(int bits)
+        {
+            uint value = 0;
+            for (int i = bits - 1; i >= 0; i--)
+            {
+                int byteIdx = _bitPos / 8;
+                int bitIdx  = 7 - (_bitPos % 8);
+
+                if ((_buffer[byteIdx] >> bitIdx & 1) == 1)
+                    value |= 1u << i;
+
+                _bitPos++;
+            }
+            return value;
+        }
+
+        // -----------------------------------------------------------------
+        // Quantized float
+        // -----------------------------------------------------------------
+
+        /// <summary>
+        /// Reads a quantized float encoded with <see cref="BitWriter.WriteQuantizedFloat"/>.
+        /// Arguments must match those used during encoding exactly.
+        /// </summary>
+        public float ReadQuantizedFloat(float min, float max, int bits)
+        {
+            uint  maxQ       = (1u << bits) - 1;
+            uint  quantized  = ReadBits(bits);
+            float normalized = (float)quantized / maxQ;
+            return min + normalized * (max - min);
+        }
+
+        // -----------------------------------------------------------------
+        // Standard IEEE 754 helpers
+        // -----------------------------------------------------------------
+
+        /// <summary>Reads a 32-bit IEEE 754 float written by <see cref="BitWriter.WriteFloat"/>.</summary>
+        public float ReadFloat()
+        {
+            uint bits = ReadBits(32);
+            byte[] bytes =
+            {
+                (byte)(bits        & 0xFF),
+                (byte)((bits >> 8)  & 0xFF),
+                (byte)((bits >> 16) & 0xFF),
+                (byte)((bits >> 24) & 0xFF),
+            };
+            return BitConverter.ToSingle(bytes, 0);
+        }
+
+        /// <summary>Reads a 64-bit IEEE 754 double written by <see cref="BitWriter.WriteDouble"/>.</summary>
+        public double ReadDouble()
+        {
+            uint hi = ReadBits(32);
+            uint lo = ReadBits(32);
+            byte[] bytes =
+            {
+                (byte)(lo         & 0xFF),
+                (byte)((lo >> 8)  & 0xFF),
+                (byte)((lo >> 16) & 0xFF),
+                (byte)((lo >> 24) & 0xFF),
+                (byte)(hi         & 0xFF),
+                (byte)((hi >> 8)  & 0xFF),
+                (byte)((hi >> 16) & 0xFF),
+                (byte)((hi >> 24) & 0xFF),
+            };
+            return BitConverter.ToDouble(bytes, 0);
+        }
+    }
+}

package/protoc-gen-bitwise/runtime/cs/BitWriter.cs

@@ -0,0 +1,117 @@
+// Decentraland.Networking.Bitwise — BitWriter
+// Copy this file into your Unity project alongside generated *.Bitwise.cs files.
+
+using System;
+
+namespace Decentraland.Networking.Bitwise
+{
+    /// <summary>
+    /// Writes bits into a pre-allocated byte buffer, MSB first within each byte
+    /// (big-endian bit order).  This matches the layout expected by
+    /// <see cref="BitReader"/> so that encode → decode is always a round-trip no-op.
+    /// </summary>
+    public sealed class BitWriter
+    {
+        private readonly byte[] _buffer;
+        private int _bitPos;
+
+        /// <param name="buffer">Destination buffer (must be large enough for all writes).</param>
+        public BitWriter(byte[] buffer)
+        {
+            _buffer = buffer ?? throw new ArgumentNullException(nameof(buffer));
+            _bitPos = 0;
+        }
+
+        /// <summary>Current write position in bits.</summary>
+        public int BitPosition => _bitPos;
+
+        /// <summary>Number of bytes written (rounded up to the nearest byte).</summary>
+        public int ByteLength => (_bitPos + 7) / 8;
+
+        /// <summary>Returns a copy of the written bytes (trimmed to <see cref="ByteLength"/>).</summary>
+        public byte[] ToArray()
+        {
+            var result = new byte[ByteLength];
+            Array.Copy(_buffer, result, ByteLength);
+            return result;
+        }
+
+        // -----------------------------------------------------------------
+        // Core primitive
+        // -----------------------------------------------------------------
+
+        /// <summary>
+        /// Writes the <paramref name="bits"/> least-significant bits of
+        /// <paramref name="value"/>, MSB first.
+        /// </summary>
+        public void WriteBits(uint value, int bits)
+        {
+            for (int i = bits - 1; i >= 0; i--)
+            {
+                int byteIdx = _bitPos / 8;
+                int bitIdx  = 7 - (_bitPos % 8);
+
+                if ((value >> i & 1u) == 1u)
+                    _buffer[byteIdx] |=  (byte)(1 << bitIdx);
+                else
+                    _buffer[byteIdx] &= (byte)~(1 << bitIdx);
+
+                _bitPos++;
+            }
+        }
+
+        // -----------------------------------------------------------------
+        // Quantized float
+        // -----------------------------------------------------------------
+
+        /// <summary>
+        /// Quantizes <paramref name="value"/> into <paramref name="bits"/> bits
+        /// using the range [<paramref name="min"/>, <paramref name="max"/>] and
+        /// writes it to the buffer.
+        ///
+        /// Uses <c>Math.Round</c> (banker's rounding → ties-to-even) to guarantee
+        /// that encode → decode is a round-trip no-op.
+        /// </summary>
+        public void WriteQuantizedFloat(float value, float min, float max, int bits)
+        {
+            uint  maxQ       = (1u << bits) - 1;
+            float clamped    = Math.Clamp(value, min, max);
+            float normalized = (clamped - min) / (max - min);
+            uint  quantized  = (uint)Math.Round(normalized * maxQ);
+            WriteBits(quantized, bits);
+        }
+
+        // -----------------------------------------------------------------
+        // Standard IEEE 754 helpers (used for un-annotated float/double fields)
+        // -----------------------------------------------------------------
+
+        /// <summary>Writes a 32-bit IEEE 754 float (4 bytes).</summary>
+        public void WriteFloat(float value)
+        {
+            byte[] bytes = BitConverter.GetBytes(value);
+            // GetBytes is little-endian on all platforms; write MSB first.
+            uint bits = (uint)bytes[0]
+                      | ((uint)bytes[1] << 8)
+                      | ((uint)bytes[2] << 16)
+                      | ((uint)bytes[3] << 24);
+            WriteBits(bits, 32);
+        }
+
+        /// <summary>Writes a 64-bit IEEE 754 double (8 bytes).</summary>
+        public void WriteDouble(double value)
+        {
+            byte[] bytes = BitConverter.GetBytes(value);
+            uint lo = (uint)bytes[0]
+                    | ((uint)bytes[1] << 8)
+                    | ((uint)bytes[2] << 16)
+                    | ((uint)bytes[3] << 24);
+            uint hi = (uint)bytes[4]
+                    | ((uint)bytes[5] << 8)
+                    | ((uint)bytes[6] << 16)
+                    | ((uint)bytes[7] << 24);
+            // Write high 32 bits first so the bit stream is big-endian at word level too.
+            WriteBits(hi, 32);
+            WriteBits(lo, 32);
+        }
+    }
+}

package/protoc-gen-bitwise/runtime/cs/Quantize.cs

@@ -0,0 +1,35 @@
+// Decentraland.Networking.Bitwise — Quantize
+// Copy this file into your project alongside generated *.Bitwise.cs files.
+// ReSharper disable once RedundantUsingDirective
+
+using System;
+
+namespace Decentraland.Networking.Bitwise
+    // ReSharper disable once ArrangeNamespaceBody
+{
+    /// <summary>
+    ///     Static helpers for quantizing float values to/from unsigned integers.
+    ///     Intended for use with protobuf uint32 fields: the integer is transmitted
+    ///     as a protobuf varint, while the float accessor lives in a generated partial class.
+    /// </summary>
+    public static class Quantize
+    {
+        /// <summary>
+        ///     Encodes <paramref name="value" /> to a quantized <see cref="uint" />.
+        ///     Values outside [<paramref name="min" />, <paramref name="max" />] are clamped.
+        /// </summary>
+        public static uint Encode(float value, float min, float max, int bits)
+        {
+            var steps = (1u << bits) - 1;
+            var t = Math.Clamp((value - min) / (max - min), 0f, 1f);
+            return (uint)MathF.Round(t * steps);
+        }
+
+        /// <summary>Decodes a quantized <see cref="uint" /> back to a float.</summary>
+        public static float Decode(uint encoded, float min, float max, int bits)
+        {
+            var steps = (1u << bits) - 1;
+            return (float)encoded / steps * (max - min) + min;
+        }
+    }
+}