KHR_draco_mesh_compression

extensions/Khronos/KHR_draco_mesh_compression/ALTERNATIVE.md

@@ -0,0 +1,14 @@
+## Alternative Approach
+
+We also thought about other designs for adding geometry compression as an extension, but we don't think they are as good as the proposed one. We will describe one here in case someone is interested.
+
+
+The idea is to add an extension object `decompressedBuffer` to `bufferView` instead of `primitive`. See the following picture for the structure of the alternative approach.
+`decompressedBuffer` will work like `bufferView` but pointing to compressed data. The extension will basically declare that the data pointed by the `bufferView` is compressed geometry data. Then for bottom-up loading, the process is to decompress the data when the `bufferView` is loaded, and store the data as a normal buffer of `bufferView`. So after decompression `bufferView` should work the same with or without the extension. For top-down loading, when `accessor` requires the data through `bufferView` the first time, the loader needs to look at the decompressed mesh data of `bufferView` instead of regular `bufferView` --> `buffer` approach.
+
+
+The advantage of this alternative approch is that it has less impact on the modularity of layers of standard glTF spec. For example, for bottom-up loading, it only requires to load `decompressedBuffer` between `buffer` and `bufferView` so that it could replace the data used by `bufferView`. However, it will change the `bufferView` that its `buffer` property will not be used any more. Another disadvantage is that it is not good for high level understanding and looks hacky. The proposed approach is mush easier to understand and the structure is clear since the compression is applied on the mesh/primitive objects. But we are definitely open to discussions about the choice we made.
+
+
+**Figure 2**: Structure of extension.
+![](figures/decompressed.png)

extensions/Khronos/KHR_draco_mesh_compression/README.md

@@ -0,0 +1,139 @@
+# KHR_draco_mesh_compression
+
+## Contributors
+
+* Fan Zhang, Google, <mailto:zhafang@google.com>
+* Ondrej Stava, Google, <mailto:ostava@google.com>
+* Frank Galligan, Google, <mailto:fgalligan@google.com>
+* Kai Ninomiya, Google, <mailto:kainino@google.com>
+* Patrick Cozzi, Cesium, [@pjcozzi](https://twitter.com/pjcozzi)
+
+## Status
+
+Draft
+
+## Dependencies
+
+Written against the glTF 2.0 spec.
+
+## Overview
+
+This extension defines a schema to use [Draco geometry compression](https://github.com/google/draco) libraries in glTF format. This allows glTF to support streaming compressed geometry data instead of the raw data.
+
+The [conformance](#conformance) section specifies what an implementation must do when encountering this extension, and how the extension interacts with the attributes defined in the base specification.
+
+## glTF Schema Updates
+
+Draco geometry compression library could be used for `primitive` by adding an `extension` property to a primitive, and defining its `KHR_draco_mesh_compression` property.
+
+The following picture shows the structure of the schema update. 
+
+**Figure 1**: Structure of geometry compression extension.
+![](figures/structure.png)
+
+In general, we will use the extension to point to the buffer that contains the compressed data. One of the requirements is that a loader/engine should be able to load the glTF assets no matter it supports the extension or not. To achieve that, all the existing components of the glTF specification stays the same when the extension exists, so that a loader doesn't support decoding compressed assets could just ignore the extension.
+
+Usage of the extension must be listed in the `extensionUsed`. 
+
+```javascript
+"extensionsUsed" : [
+    "KHR_draco_mesh_compression"
+]
+
+```
+
+The extension then could be used like the following, note that all other nodes stay the same
+except `primitives`:
+
+```javascript
+
+"mesh" : {
+    "primitives" : [
+        {
+            "attributes" : {
+                "POSITION" : 11,
+                "NORMAL" : 12,
+                "TEXCOORD_0" : 13,
+            },
+            "indices" : 10,
+            "mode" : 4
+            "extensions" : {
+                "KHR_draco_mesh_compression" : {
+                    "bufferView" : 5,
+                    "attributes" : [
+                        "POSITION",
+                        "NORMAL",
+                        "TEXCOORD_0"
+                    ],
+                    "version" : "0.9.1"
+                }
+            }
+        },
+    ]
+}
+
+"bufferViews" : [
+    // ...
+    // bufferView of Id 5
+    {
+        "buffer" : 10,
+        "byteOffset" : 1024,
+        "byteLength" : 10000
+    }
+    // ...
+}
+
+```
+We will explain each of the property in the following sections.
+#### bufferView
+The `bufferView` property points to the buffer containing compressed data. The data should be passed to a mesh decoder and decompressed to a
+mesh.
+
+#### version
+The version of Draco encoder used to compress the mesh. This is used for verifying compatibility of Draco encoder and decoder. With this property, the loader could easily determine if the current decoder supports decoding the data. Currently, Draco supports backward compatibility. So decoding is supported if the version of asset is <= Draco decoder version. For more detail, please check version support status on [Draco project](https://github.com/google/draco).
+
+### attributes
+`attributes` defines the attributes stored in the decompressed geometry. E.g, in the example above, `POSITION`, `NORMAL` and `TEXCOORD_0`.
+
+#### Restrictions on geometry type
+When using this extension, the `mode` of `primitive` could only be one of
+`POINTS`, `TRIANGLES` and `TRIANGLE_STRIP` and the mesh data will be decoded accordingly. For example, if `mode` is `POINTS`, then the
+decompressed geometry will be a point cloud.
+
+### JSON Schema
+
+For full details on the `KHR_draco_mesh_compression` extension properties, see the schema:
+
+* [extension property](schema/node.KHR_draco_mesh_compression.schema.json) `KHR_draco_mesh_compression` extensions object.
+
+## Conformance
+
+To process this extension, there are some changes need to be made in loading a glTF asset.
+* Check if the extension is supported. If not then load the glTF asset ignoring the compression extension properties in `primitive`.
+    * If `KHR_draco_mesh_compression` is in `extensionsUsed` then to verify if the loader supports decoding the compression extension.
+    * Check `version` property and verify the version of encoder used for the mesh is compatible with the current decoder.
+* When encountering a `primitive` with the extension the first time, you must process the extension first. Get the data from the pointed `bufferView` in the extension and decompress the data to a geometry of a specific format, e.g. Draco geometry.
+* Then, process `attributes` and `indices` properties of the `primitive`. When loading each `accessor`, go to the previously decoded geometry in the `primitive` to get indices and attributes data. A loader could use the decompressed data to overwrite `accessors` or render the decompressed geometry directly (e.g. ThreeJS).
+
+It is pretty straightforward for top-down loading of a glTF asset, e.g. only
+decompress the geometry data when a `primitive` is met for the first time. However, for
+bottom-up loading, loading `accessor` before `primitive` will not get the data. It could only be handled when processing its parent `primitive`. This is based on the consideration that it will rarely happen that
+loading an `accessor` without knowing its parent `primitive`. And it should be
+easy enough to change the loader to ignore `accessor` without `bufferView` in glTF 2.0. But we are
+definitely open to change this if there actually are some use cases that require
+loading `accessor` independently. 
+
+For effectiveness, it is also valid to not support the fallback which is provided in the above specification, e.g. not providing the data buffer for uncompressed assets. To do that, a glTF file could just ignored the `bufferViews` of `accessors` belong to a `primitive`. This is valid because in glTF 2.0, `bufferView` is not required in `accessor`, although if it is not present, it will be used with `sparse` field to act as a sparse accessor. In this case, Draco must be considered a required extension and should report error if a loader doens't support it.
+
+## Resources
+
+* [Draco Open Source Library](https://github.com/google/draco)
+* [ThreeJS
+  Loader](https://github.com/mrdoob/three.js/blob/dev/examples/js/loaders/DRACOLoader.js)
+  and
+  [example](https://github.com/mrdoob/three.js/blob/dev/examples/webgl_loader_draco.html)
+
+
+# Appendix: Alternative Approach
+
+See [ALTERNATIVE.md](ALTERNATIVE.md).

extensions/Khronos/KHR_draco_mesh_compression/schema/node.KHR_draco_mesh_compression.schema.json

@@ -0,0 +1,27 @@
+{
+    "$schema" : "http://json-schema.org/draft-04/schema",
+    "title" : "KHR_draco_mesh_compression extension",
+    "type" : "object",
+    "properties" : {
+        "bufferView" : {
+            "allOf" : [ { "$ref" : "glTFid.schema.json" } ],
+            "description" : "The index of the bufferView."
+        },
+        "attributes" : {
+            "type" : "array",
+            "description" : "The attributes stored in the compressed geometry.",
+            "items" : {
+                "type" : "string",
+            },
+            "minItems" : 1,
+            "maxItems" : 8,
+            "gltf_detailedDescription" : "It is used to define the attributes stored in the compressed geometry."
+        },
+        "version" : {
+            "type" : "string",
+            "description" : "The version of Draco encoder that is used on the compressed geometry data."
+        },
+    },
+    "additionalProperties" : false,
+    "required" : ["bufferView", "attributes"]
+}

extensions/README.md

@@ -7,6 +7,7 @@
 
 #### Draft Khronos extensions
 _Draft Khronos extensions are not ratified yet._
+* [KHR_draco_mesh_compression](Khronos/KHR_draco_mesh_compression/README.md)
 * [KHR_materials_common](Khronos/KHR_materials_common/README.md)
 * [KHR_technique_webgl](Khronos/KHR_technique_webgl/README.md)