JSON Parsing Improvements

[atteneder]

The Problem

glTFast currently has two JSON parsing backends.

1. JsonUtility
2. Newtonsoft JSON (added in 6.0.0)

JsonUtility is fast, has few GC allocations and a low build-size overhead, but it requires two-pass parsing to ensure non-present object properties are null and it does not grant access to meta-data that's unknown at build-time.

Newtonsoft JSON on the other hand allows accessing arbitrary data in extras, extensions or elsewhere, but is slower and has a large build-size overhead. On top of that it was necessary to drive another abstraction layer into the de-serialization (schema) classes which is complicated and has already introduces API breaking barriers that are hard to overcome.

There's also #734 which needs to be addressed/is a hard requirement.

Solutions

The important metrics of potential solutions are:

• Parsing Speed
• Memory allocations
• Build-size overhead
• Impact on code complexity (especially de-serialization classes)

The ideal scenario is one JSON parser that wins in all categories and replaces both JsonUtility and Newtonsoft JSON.

The next best alternative would be to replace Newtonsoft JSON only.

Requirements

• Works with currently supported Unity versions.
• Generic, so that it works with data structures not known at build-time.
• Data is consumable for add-on development (Access to arbitrary JSON meta-data #734).

Nice-to-haves

• Ability to consume streams (System.IO.Stream).
• Backwards compatible with older Unity versions.
• Parse _n type properties into one array. (e.g. TEXCOORD_0, TEXCOORD_1...TEXCOORD_n; see spec).

Misc.

In order to avoid reflection for generic de-serialization, we should investigate into source generators.

Alternatives

There's a bunch of JSON parsers out there we should consider or maybe take a page out of their book.

• UniJSON from UniVRM.
• Utf8Json
• Jil
• SimpleJSON

[mikeskydev]

I can't find it now, but years ago I looked into the relative speeds of JsonUtility vs Newtonsoft vs System.Text.Json for the purpose of parsing arbitrary extensions in glTFast. System.Text.Json was much faster than Newtonsoft, but not as fast as JsonUtility, iirc.

Found it: #226 (comment)

[atteneder]

@mikeskydev thanks for the reminder, I've added it to the list.

SimpleJSON seems to do de-serialization into an intermediate format (JSONNode) only and not casting to a custom type (like GLTFast.Schema.Root).

IIRC, System.Text.Json is not available in Unity (leaving aside packing nuget dll into a project, which is not an option for a supported package).