@dcl/protocol 1.0.0-28974105118.commit-a598406 → 1.0.0-28980486989.commit-1e80e43

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,70 @@
+// 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;
+        }
+
+        /// <summary>
+        ///     Encodes <paramref name="value" /> with a power-law curve into an
+        ///     (<paramref name="bits" /> - 1)-bit linear unorm magnitude plus a sign bit. The magnitude is
+        ///     <c>(|value| / max)^(1/pow)</c>, so the inverse <see cref="DecodePower" /> reconstructs
+        ///     <c>sign * max * u^pow</c>. Zero is representable exactly; <paramref name="pow" /> &gt; 1
+        ///     concentrates resolution near zero. Magnitudes outside [0, <paramref name="max" />] are
+        ///     clamped.
+        ///     <para>
+        ///     The encoded layout puts the magnitude in the high bits and the sign in the LSB
+        ///     (<c>(magnitude &lt;&lt; 1) | sign</c>). This keeps the varint cost a function of
+        ///     magnitude rather than direction — a small <c>|value|</c> of either sign stays in a
+        ///     single varint byte. Zero canonicalizes to <c>0</c> (a zero magnitude never sets the
+        ///     sign bit), so proto3 still omits a stopped field entirely.
+        ///     </para>
+        /// </summary>
+        public static uint EncodePower(float value, float max, float pow, int bits)
+        {
+            var magnitudeSteps = (1u << (bits - 1)) - 1;
+            var t = Math.Clamp(MathF.Abs(value) / max, 0f, 1f);
+            var u = MathF.Pow(t, 1f / pow);
+            var magnitude = (uint)MathF.Round(u * magnitudeSteps);
+            var sign = value < 0f && magnitude != 0u ? 1u : 0u;
+            return (magnitude << 1) | sign;
+        }
+
+        /// <summary>Decodes a power-law quantized <see cref="uint" /> back to a float (inverse of
+        /// <see cref="EncodePower" />).</summary>
+        public static float DecodePower(uint encoded, float max, float pow, int bits)
+        {
+            var magnitudeSteps = (1u << (bits - 1)) - 1;
+            var u = (float)(encoded >> 1) / magnitudeSteps;
+            var magnitude = max * MathF.Pow(u, pow);
+            return (encoded & 1u) != 0 ? -magnitude : magnitude;
+        }
+    }
+}

package/protoc-gen-bitwise/wire.js

@@ -0,0 +1,239 @@
+'use strict'
+
+/**
+ * Self-contained protobuf wire-format codec for protoc-gen-bitwise.
+ *
+ * The plugin only needs a tiny slice of the descriptor/plugin schemas, so
+ * rather than pull in a protobuf runtime (which would force every consumer —
+ * including the sibling Pulse checkout that runs this file directly off disk —
+ * to `npm install` the protocol repo) we decode the handful of fields we care
+ * about by walking the wire format directly. This mirrors the original Python
+ * plugin, which already hand-parsed FieldOptions for the same reason.
+ *
+ * Decoded subset:
+ *   CodeGeneratorRequest { file_to_generate = 1; proto_file = 15; }
+ *   FileDescriptorProto  { name = 1; package = 2; message_type = 4; }
+ *   DescriptorProto      { name = 1; field = 2; }
+ *   FieldDescriptorProto { name = 1; label = 4; type = 5; options = 8 (raw bytes); }
+ *
+ * Encoded subset:
+ *   CodeGeneratorResponse { error = 1; supported_features = 2; file = 15; }
+ *   CodeGeneratorResponse.File { name = 1; content = 15; }
+ *
+ * Wire types: 0 = varint, 1 = 64-bit, 2 = length-delimited, 5 = 32-bit.
+ */
+
+// ---------------------------------------------------------------------------
+// Low-level readers
+// ---------------------------------------------------------------------------
+
+/** Decode a protobuf varint at `pos`. Returns [value, newPos]. */
+function readVarint(buf, pos) {
+  let result = 0
+  let shift = 0
+  let byte
+  do {
+    byte = buf[pos++]
+    // Multiplication (not <<) keeps values correct past 32 bits.
+    result += (byte & 0x7f) * Math.pow(2, shift)
+    shift += 7
+  } while (byte & 0x80)
+  return [result, pos]
+}
+
+/** Advance `pos` past a field of the given wire type. Returns newPos. */
+function skipField(buf, pos, wireType) {
+  switch (wireType) {
+    case 0: // varint
+      return readVarint(buf, pos)[1]
+    case 1: // 64-bit
+      return pos + 8
+    case 2: {
+      // length-delimited
+      const [length, next] = readVarint(buf, pos)
+      return next + length
+    }
+    case 5: // 32-bit
+      return pos + 4
+    default:
+      // Groups (3/4) are deprecated and never appear in descriptors.
+      return pos
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Request decoding
+// ---------------------------------------------------------------------------
+
+function decodeFieldDescriptor(buf) {
+  const field = { name: '', label: 0, type: 0, optionsRaw: null }
+  let pos = 0
+  while (pos < buf.length) {
+    let tag
+    ;[tag, pos] = readVarint(buf, pos)
+    const fieldNum = tag >>> 3
+    const wireType = tag & 0x7
+    if (fieldNum === 1 && wireType === 2) {
+      let len
+      ;[len, pos] = readVarint(buf, pos)
+      field.name = buf.toString('utf8', pos, pos + len)
+      pos += len
+    } else if (fieldNum === 4 && wireType === 0) {
+      ;[field.label, pos] = readVarint(buf, pos)
+    } else if (fieldNum === 5 && wireType === 0) {
+      ;[field.type, pos] = readVarint(buf, pos)
+    } else if (fieldNum === 8 && wireType === 2) {
+      let len
+      ;[len, pos] = readVarint(buf, pos)
+      // Keep the raw FieldOptions bytes so custom extensions survive (the
+      // descriptor schema doesn't know about ext 50001/50002).
+      field.optionsRaw = buf.subarray(pos, pos + len)
+      pos += len
+    } else {
+      pos = skipField(buf, pos, wireType)
+    }
+  }
+  return field
+}
+
+function decodeDescriptor(buf) {
+  const message = { name: '', field: [] }
+  let pos = 0
+  while (pos < buf.length) {
+    let tag
+    ;[tag, pos] = readVarint(buf, pos)
+    const fieldNum = tag >>> 3
+    const wireType = tag & 0x7
+    if (fieldNum === 1 && wireType === 2) {
+      let len
+      ;[len, pos] = readVarint(buf, pos)
+      message.name = buf.toString('utf8', pos, pos + len)
+      pos += len
+    } else if (fieldNum === 2 && wireType === 2) {
+      let len
+      ;[len, pos] = readVarint(buf, pos)
+      message.field.push(decodeFieldDescriptor(buf.subarray(pos, pos + len)))
+      pos += len
+    } else {
+      // nested_type / enum_type / etc. are intentionally ignored — the
+      // generator only walks top-level messages, matching the Python plugin.
+      pos = skipField(buf, pos, wireType)
+    }
+  }
+  return message
+}
+
+function decodeFileDescriptor(buf) {
+  const file = { name: '', package: '', messageType: [] }
+  let pos = 0
+  while (pos < buf.length) {
+    let tag
+    ;[tag, pos] = readVarint(buf, pos)
+    const fieldNum = tag >>> 3
+    const wireType = tag & 0x7
+    if (fieldNum === 1 && wireType === 2) {
+      let len
+      ;[len, pos] = readVarint(buf, pos)
+      file.name = buf.toString('utf8', pos, pos + len)
+      pos += len
+    } else if (fieldNum === 2 && wireType === 2) {
+      let len
+      ;[len, pos] = readVarint(buf, pos)
+      file.package = buf.toString('utf8', pos, pos + len)
+      pos += len
+    } else if (fieldNum === 4 && wireType === 2) {
+      let len
+      ;[len, pos] = readVarint(buf, pos)
+      file.messageType.push(decodeDescriptor(buf.subarray(pos, pos + len)))
+      pos += len
+    } else {
+      pos = skipField(buf, pos, wireType)
+    }
+  }
+  return file
+}
+
+/** Decode a serialized CodeGeneratorRequest. */
+function decodeRequest(buf) {
+  const request = { fileToGenerate: [], protoFile: [] }
+  let pos = 0
+  while (pos < buf.length) {
+    let tag
+    ;[tag, pos] = readVarint(buf, pos)
+    const fieldNum = tag >>> 3
+    const wireType = tag & 0x7
+    if (fieldNum === 1 && wireType === 2) {
+      let len
+      ;[len, pos] = readVarint(buf, pos)
+      request.fileToGenerate.push(buf.toString('utf8', pos, pos + len))
+      pos += len
+    } else if (fieldNum === 15 && wireType === 2) {
+      let len
+      ;[len, pos] = readVarint(buf, pos)
+      request.protoFile.push(decodeFileDescriptor(buf.subarray(pos, pos + len)))
+      pos += len
+    } else {
+      pos = skipField(buf, pos, wireType)
+    }
+  }
+  return request
+}
+
+// ---------------------------------------------------------------------------
+// Response encoding
+// ---------------------------------------------------------------------------
+
+/** Encode an unsigned integer as a protobuf varint Buffer. */
+function encodeVarint(value) {
+  const bytes = []
+  let v = value
+  while (v > 0x7f) {
+    bytes.push((v & 0x7f) | 0x80)
+    v = Math.floor(v / 128)
+  }
+  bytes.push(v & 0x7f)
+  return Buffer.from(bytes)
+}
+
+function encodeTag(fieldNum, wireType) {
+  return encodeVarint((fieldNum << 3) | wireType)
+}
+
+/** Encode a length-delimited (string/bytes) field: tag + length + payload. */
+function encodeLengthDelimited(fieldNum, payload) {
+  const buf = Buffer.isBuffer(payload) ? payload : Buffer.from(payload, 'utf8')
+  return Buffer.concat([encodeTag(fieldNum, 2), encodeVarint(buf.length), buf])
+}
+
+function encodeFile(file) {
+  return Buffer.concat([
+    encodeLengthDelimited(1, file.name), // name = 1
+    encodeLengthDelimited(15, file.content), // content = 15
+  ])
+}
+
+/**
+ * Encode a CodeGeneratorResponse.
+ * @param {{error?: string|null, supportedFeatures?: number, files?: Array<{name:string,content:string}>}} response
+ */
+function encodeResponse(response) {
+  const parts = []
+  if (response.error != null) {
+    parts.push(encodeLengthDelimited(1, response.error)) // error = 1
+  }
+  if (response.supportedFeatures != null) {
+    parts.push(encodeTag(2, 0)) // supported_features = 2 (varint)
+    parts.push(encodeVarint(response.supportedFeatures))
+  }
+  for (const file of response.files || []) {
+    parts.push(encodeLengthDelimited(15, encodeFile(file))) // file = 15
+  }
+  return Buffer.concat(parts)
+}
+
+module.exports = {
+  readVarint,
+  skipField,
+  decodeRequest,
+  encodeResponse,
+}

package/proto/buf.yaml

@@ -1,47 +0,0 @@
-version: v1
-breaking:
-  use:
-    - WIRE_JSON
-  ignore:
-    - google
-lint:
-  use:
-    - DIRECTORY_SAME_PACKAGE
-    - PACKAGE_DEFINED
-    - PACKAGE_DIRECTORY_MATCH
-    - PACKAGE_SAME_DIRECTORY
-    - ENUM_PASCAL_CASE
-    - ENUM_VALUE_UPPER_SNAKE_CASE
-    - FIELD_LOWER_SNAKE_CASE
-    - MESSAGE_PASCAL_CASE
-    - ONEOF_LOWER_SNAKE_CASE
-    - PACKAGE_LOWER_SNAKE_CASE
-    - RPC_PASCAL_CASE
-    - SERVICE_PASCAL_CASE
-    - PACKAGE_SAME_CSHARP_NAMESPACE
-    - PACKAGE_SAME_GO_PACKAGE
-    - PACKAGE_SAME_JAVA_MULTIPLE_FILES
-    - PACKAGE_SAME_JAVA_PACKAGE
-    - PACKAGE_SAME_PHP_NAMESPACE
-    - PACKAGE_SAME_RUBY_PACKAGE
-    - PACKAGE_SAME_SWIFT_PREFIX
-    - ENUM_FIRST_VALUE_ZERO
-    - ENUM_NO_ALLOW_ALIAS
-    - IMPORT_NO_WEAK
-    - IMPORT_NO_PUBLIC
-    - IMPORT_USED
-    - FILE_LOWER_SNAKE_CASE
-    # Ignored:the default value is used
-    # - ENUM_ZERO_VALUE_SUFFIX
-    # Ignored: if a prefix is needed in the target language, implement a preprocessor
-    # - ENUM_VALUE_PREFIX
-    # Not wished
-    # - PACKAGE_VERSION_SUFFIX
-    # TODO: See if this needs to be added
-    # - RPC_REQUEST_RESPONSE_UNIQUE
-    # - RPC_REQUEST_STANDARD_NAME
-    # - RPC_RESPONSE_STANDARD_NAME
-    # - SERVICE_SUFFIX
-  ignore:
-    - google
-    - decentraland/renderer/engine_interface.proto

package/proto/google/LICENSE

@@ -1,27 +0,0 @@
-Copyright 2014, Google Inc.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-    * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/proto/google/README.md

@@ -1 +0,0 @@
-This folder contains stripped and pre-parsed definitions of common Google types. These files are not used by protobuf.js directly but are here so you can use or include them where required.

package/proto/google/api/annotations.json

@@ -1,83 +0,0 @@
-{
-  "nested": {
-    "google": {
-      "nested": {
-        "api": {
-          "nested": {
-            "http": {
-              "type": "HttpRule",
-              "id": 72295728,
-              "extend": "google.protobuf.MethodOptions"
-            },
-            "HttpRule": {
-              "oneofs": {
-                "pattern": {
-                  "oneof": [
-                    "get",
-                    "put",
-                    "post",
-                    "delete",
-                    "patch",
-                    "custom"
-                  ]
-                }
-              },
-              "fields": {
-                "get": {
-                  "type": "string",
-                  "id": 2
-                },
-                "put": {
-                  "type": "string",
-                  "id": 3
-                },
-                "post": {
-                  "type": "string",
-                  "id": 4
-                },
-                "delete": {
-                  "type": "string",
-                  "id": 5
-                },
-                "patch": {
-                  "type": "string",
-                  "id": 6
-                },
-                "custom": {
-                  "type": "CustomHttpPattern",
-                  "id": 8
-                },
-                "selector": {
-                  "type": "string",
-                  "id": 1
-                },
-                "body": {
-                  "type": "string",
-                  "id": 7
-                },
-                "additionalBindings": {
-                  "rule": "repeated",
-                  "type": "HttpRule",
-                  "id": 11
-                }
-              }
-            }
-          }
-        },
-        "protobuf": {
-          "nested": {
-            "MethodOptions": {
-              "fields": {},
-              "extensions": [
-                [
-                  1000,
-                  536870911
-                ]
-              ]
-            }
-          }
-        }
-      }
-    }
-  }
-}

package/proto/google/api/annotations.proto

@@ -1,11 +0,0 @@
-syntax = "proto3";
-
-package google.api;
-
-import "google/api/http.proto";
-import "google/protobuf/descriptor.proto";
-
-extend google.protobuf.MethodOptions {
-
-    HttpRule http = 72295728;
-}

package/proto/google/api/http.json

@@ -1,86 +0,0 @@
-{
-  "nested": {
-    "google": {
-      "nested": {
-        "api": {
-          "nested": {
-            "Http": {
-              "fields": {
-                "rules": {
-                  "rule": "repeated",
-                  "type": "HttpRule",
-                  "id": 1
-                }
-              }
-            },
-            "HttpRule": {
-              "oneofs": {
-                "pattern": {
-                  "oneof": [
-                    "get",
-                    "put",
-                    "post",
-                    "delete",
-                    "patch",
-                    "custom"
-                  ]
-                }
-              },
-              "fields": {
-                "get": {
-                  "type": "string",
-                  "id": 2
-                },
-                "put": {
-                  "type": "string",
-                  "id": 3
-                },
-                "post": {
-                  "type": "string",
-                  "id": 4
-                },
-                "delete": {
-                  "type": "string",
-                  "id": 5
-                },
-                "patch": {
-                  "type": "string",
-                  "id": 6
-                },
-                "custom": {
-                  "type": "CustomHttpPattern",
-                  "id": 8
-                },
-                "selector": {
-                  "type": "string",
-                  "id": 1
-                },
-                "body": {
-                  "type": "string",
-                  "id": 7
-                },
-                "additionalBindings": {
-                  "rule": "repeated",
-                  "type": "HttpRule",
-                  "id": 11
-                }
-              }
-            },
-            "CustomHttpPattern": {
-              "fields": {
-                "kind": {
-                  "type": "string",
-                  "id": 1
-                },
-                "path": {
-                  "type": "string",
-                  "id": 2
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}