From 7c9cddf7860c6f7e242ca0dce3334cf2328a8022 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Fri, 15 Jan 2021 17:25:36 +0000
Subject: [PATCH 01/30] Draco test file

2CylinderEngine from https://github.com/KhronosGroup/glTF-Sample-Models
---
 test/models/glTF2/draco/2CylinderEngine.bin  |  Bin 0 -> 155392 bytes
 test/models/glTF2/draco/2CylinderEngine.gltf | 4758 ++++++++++++++++++
 2 files changed, 4758 insertions(+)
 create mode 100644 test/models/glTF2/draco/2CylinderEngine.bin
 create mode 100644 test/models/glTF2/draco/2CylinderEngine.gltf

diff --git a/test/models/glTF2/draco/2CylinderEngine.bin b/test/models/glTF2/draco/2CylinderEngine.bin
new file mode 100644
index 0000000000000000000000000000000000000000..8ea9b3204865f3c4a7e70b206e2b3f78a7cf5127
GIT binary patch
literal 155392
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

literal 0
HcmV?d00001

diff --git a/test/models/glTF2/draco/2CylinderEngine.gltf b/test/models/glTF2/draco/2CylinderEngine.gltf
new file mode 100644
index 000000000..6cd29325d
--- /dev/null
+++ b/test/models/glTF2/draco/2CylinderEngine.gltf
@@ -0,0 +1,4758 @@
+{
+  "asset": {
+    "generator": "COLLADA2GLTF",
+    "version": "2.0"
+  },
+  "scene": 0,
+  "scenes": [
+    {
+      "nodes": [
+        81,
+        0
+      ]
+    }
+  ],
+  "nodes": [
+    {
+      "children": [
+        80,
+        79,
+        78,
+        77,
+        76,
+        75,
+        74,
+        73,
+        13,
+        10,
+        7,
+        4,
+        1
+      ]
+    },
+    {
+      "children": [
+        3,
+        2
+      ],
+      "matrix": [
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        136.860107421875,
+        -64.45372009277344,
+        -36.179630279541016,
+        1
+      ]
+    },
+    {
+      "mesh": 0,
+      "matrix": [
+        -1,
+        8.979318677493353e-11,
+        0,
+        0,
+        -8.979318677493353e-11,
+        -1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        -294.67718505859375,
+        73.97987365722656,
+        16.17963218688965,
+        1
+      ]
+    },
+    {
+      "mesh": 1,
+      "matrix": [
+        0.9995650053024292,
+        0.029493184760212895,
+        0,
+        0,
+        -0.029493184760212895,
+        0.9995650053024292,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        -45.315460205078125,
+        -24.617263793945316,
+        -26.320369720458984,
+        1
+      ]
+    },
+    {
+      "children": [
+        6,
+        5
+      ],
+      "matrix": [
+        -1,
+        8.979318677493353e-11,
+        0,
+        0,
+        -8.979318677493353e-11,
+        -1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        -136.860107421875,
+        64.45372009277344,
+        3.8203670978546143,
+        1
+      ]
+    },
+    {
+      "mesh": 0,
+      "matrix": [
+        -1,
+        8.979318677493353e-11,
+        0,
+        0,
+        -8.979318677493353e-11,
+        -1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        -294.67718505859375,
+        73.97987365722656,
+        16.17963218688965,
+        1
+      ]
+    },
+    {
+      "mesh": 1,
+      "matrix": [
+        0.9995650053024292,
+        0.029493184760212895,
+        0,
+        0,
+        -0.029493184760212895,
+        0.9995650053024292,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        -45.315460205078125,
+        -24.617263793945316,
+        -26.32036781311035,
+        1
+      ]
+    },
+    {
+      "children": [
+        9,
+        8
+      ],
+      "matrix": [
+        -0.5,
+        -0.8660253882408142,
+        0,
+        0,
+        0.8660253882408142,
+        -0.5,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        18.09818458557129,
+        -69.69783782958984,
+        -105.559814453125,
+        1
+      ]
+    },
+    {
+      "mesh": 2,
+      "matrix": [
+        -0.9390941858291626,
+        0.3436597883701325,
+        0,
+        0,
+        -0.3436597883701325,
+        -0.9390941858291626,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        -51.311012268066406,
+        -50.52240753173828,
+        -18.440185546875,
+        1
+      ]
+    },
+    {
+      "mesh": 3,
+      "matrix": [
+        -0.9390941858291626,
+        0.3436597883701325,
+        0,
+        0,
+        -0.3436597883701325,
+        -0.9390941858291626,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        -51.311012268066406,
+        -50.52240753173828,
+        107.559814453125,
+        1
+      ]
+    },
+    {
+      "children": [
+        12,
+        11
+      ],
+      "matrix": [
+        0.7071067690849304,
+        -0.7071067690849304,
+        0,
+        0,
+        0.7071067690849304,
+        0.7071067690849304,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        47.17867660522461,
+        -52.821327209472656,
+        -88.94477081298828,
+        1
+      ]
+    },
+    {
+      "mesh": 4,
+      "matrix": [
+        -0.4234085381031037,
+        -0.9059388637542723,
+        -7.575183536001616e-11,
+        0,
+        -0.9059388637542723,
+        0.4234085381031037,
+        -4.821281221478735e-11,
+        0,
+        7.575183536001616e-11,
+        4.821281221478735e-11,
+        -1,
+        0,
+        -90.59386444091795,
+        -24.379817962646488,
+        -40.05522918701172,
+        1
+      ]
+    },
+    {
+      "mesh": 5,
+      "matrix": [
+        -1.877404400829619e-7,
+        -1.194886607436274e-7,
+        1,
+        0,
+        -0.905938446521759,
+        0.42340943217277527,
+        -1.194886607436274e-7,
+        0,
+        -0.42340943217277527,
+        -0.905938446521759,
+        -1.877404400829619e-7,
+        0,
+        -30.2958984375,
+        -52.56131362915039,
+        25.05522727966309,
+        1
+      ]
+    },
+    {
+      "children": [
+        72,
+        71,
+        70,
+        69,
+        68,
+        67,
+        66,
+        65,
+        14
+      ]
+    },
+    {
+      "children": [
+        64,
+        63,
+        62,
+        61,
+        60,
+        59,
+        58,
+        57,
+        56,
+        43,
+        29,
+        15
+      ],
+      "matrix": [
+        -2.430540746445331e-7,
+        0.0000014087579529586949,
+        -1,
+        0,
+        -1,
+        -2.430540746445331e-7,
+        2.4305373358402004e-7,
+        0,
+        -2.4305373358402004e-7,
+        1,
+        0.0000014087580666455324,
+        0,
+        -48.26182556152344,
+        -59.11042404174805,
+        34.595985412597656,
+        1
+      ]
+    },
+    {
+      "children": [
+        28,
+        27,
+        16
+      ],
+      "matrix": [
+        -0.4546820223331452,
+        0.6541662216186523,
+        -0.6044260263442993,
+        0,
+        0.8696397542953491,
+        0.4726206660270691,
+        -0.1426759660243988,
+        0,
+        0.19233042001724243,
+        -0.590505063533783,
+        -0.7837810516357422,
+        0,
+        14.898193359375,
+        85.82951354980469,
+        -48.034645080566406,
+        1
+      ]
+    },
+    {
+      "children": [
+        26,
+        25,
+        24,
+        23,
+        22,
+        21,
+        20,
+        19,
+        18,
+        17
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        0.8450329899787903,
+        0.005398945417255163,
+        -0.5346869230270386,
+        0,
+        -0.4710906744003296,
+        0.4805830717086792,
+        -0.7396712303161621,
+        0,
+        0.25296804308891296,
+        0.8769326210021973,
+        0.4086519181728363,
+        0,
+        -74.0894775390625,
+        71.41646575927734,
+        -157.91323852539065,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        -0.7145451903343201,
+        -0.1154177337884903,
+        0.6900028586387634,
+        0,
+        -0.6522517800331116,
+        0.4665486216545105,
+        -0.5974110960960388,
+        0,
+        -0.25296807289123535,
+        -0.8769327998161316,
+        -0.4086515009403229,
+        0,
+        122.53109741210938,
+        86.64814758300781,
+        -312.3133850097656,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        0.8450329899787903,
+        0.005398945417255163,
+        -0.5346869230270386,
+        0,
+        -0.4710906744003296,
+        0.4805830717086792,
+        -0.7396712303161621,
+        0,
+        0.25296804308891296,
+        0.8769326210021973,
+        0.4086519181728363,
+        0,
+        -69.3792953491211,
+        71.78133392333984,
+        -161.61203002929688,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        -0.7145451903343201,
+        -0.1154177337884903,
+        0.6900028586387634,
+        0,
+        -0.6522517800331116,
+        0.4665486216545105,
+        -0.5974110960960388,
+        0,
+        -0.25296807289123535,
+        -0.8769327998161316,
+        -0.4086515009403229,
+        0,
+        127.24127197265624,
+        87.01302337646484,
+        -316.0121765136719,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        0.8450329899787903,
+        0.005398945417255163,
+        -0.5346869230270386,
+        0,
+        -0.4710906744003296,
+        0.4805830717086792,
+        -0.7396712303161621,
+        0,
+        0.25296804308891296,
+        0.8769326210021973,
+        0.4086519181728363,
+        0,
+        -64.66907501220703,
+        72.14624786376953,
+        -165.310791015625,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        -0.7145451903343201,
+        -0.1154177337884903,
+        0.6900028586387634,
+        0,
+        -0.6522517800331116,
+        0.4665486216545105,
+        -0.5974110960960388,
+        0,
+        -0.25296807289123535,
+        -0.8769327998161316,
+        -0.4086515009403229,
+        0,
+        131.9515380859375,
+        87.37792205810547,
+        -319.7109680175781,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        0.8450329899787903,
+        0.005398945417255163,
+        -0.5346869230270386,
+        0,
+        -0.4710906744003296,
+        0.4805830717086792,
+        -0.7396712303161621,
+        0,
+        0.25296804308891296,
+        0.8769326210021973,
+        0.4086519181728363,
+        0,
+        -59.958885192871094,
+        72.5111312866211,
+        -169.00955200195312,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        -0.7145451903343201,
+        -0.1154177337884903,
+        0.6900028586387634,
+        0,
+        -0.6522517800331116,
+        0.4665486216545105,
+        -0.5974110960960388,
+        0,
+        -0.25296807289123535,
+        -0.8769327998161316,
+        -0.4086515009403229,
+        0,
+        136.66165161132812,
+        87.74280548095703,
+        -323.4097595214844,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        0.8450329899787903,
+        0.005398945417255163,
+        -0.5346869230270386,
+        0,
+        -0.4710906744003296,
+        0.4805830717086792,
+        -0.7396712303161621,
+        0,
+        0.25296804308891296,
+        0.8769326210021973,
+        0.4086519181728363,
+        0,
+        -55.24869537353516,
+        72.87601470947266,
+        -172.70831298828125,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        -0.7145451903343201,
+        -0.1154177337884903,
+        0.6900028586387634,
+        0,
+        -0.6522517800331116,
+        0.4665486216545105,
+        -0.5974110960960388,
+        0,
+        -0.25296807289123535,
+        -0.8769327998161316,
+        -0.4086515009403229,
+        0,
+        141.37188720703125,
+        88.10767364501953,
+        -327.1084899902344,
+        1
+      ]
+    },
+    {
+      "mesh": 7,
+      "matrix": [
+        0.7850325703620911,
+        0.06081420928239823,
+        -0.6164620518684387,
+        0,
+        -0.13561886548995972,
+        0.9878994822502136,
+        -0.07524696737527847,
+        0,
+        0.6044265031814575,
+        0.14267520606517792,
+        0.7837808728218079,
+        0,
+        -5.746735095977783,
+        -250.409912109375,
+        -86.68790435791016,
+        1
+      ]
+    },
+    {
+      "mesh": 8,
+      "matrix": [
+        0.785033106803894,
+        0.06081344559788704,
+        -0.616461455821991,
+        0,
+        -0.3681585192680359,
+        -0.7545340061187744,
+        -0.5432658195495605,
+        0,
+        -0.4981790184974671,
+        0.6534371972084045,
+        -0.569945216178894,
+        0,
+        34.187137603759766,
+        252.666015625,
+        65.06369018554688,
+        1
+      ]
+    },
+    {
+      "children": [
+        42,
+        41,
+        30
+      ],
+      "matrix": [
+        0.4546822011470794,
+        0.6541662216186523,
+        0.604425847530365,
+        0,
+        -0.8696396350860596,
+        0.4726209044456482,
+        0.14267593622207642,
+        0,
+        -0.1923305094242096,
+        -0.5905048847198486,
+        0.7837811708450317,
+        0,
+        91.87051391601564,
+        80.63255310058594,
+        166.26089477539065,
+        1
+      ]
+    },
+    {
+      "children": [
+        40,
+        39,
+        38,
+        37,
+        36,
+        35,
+        34,
+        33,
+        32,
+        31
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        0.8620702028274536,
+        -0.015319700352847576,
+        -0.506557285785675,
+        0,
+        -0.4340354502201081,
+        0.4936883449554444,
+        -0.7535814642906189,
+        0,
+        0.26162606477737427,
+        0.8695039749145508,
+        0.41894471645355225,
+        0,
+        -77.39921569824219,
+        74.49835205078125,
+        -159.90199279785156,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        -0.6893031001091003,
+        -0.13550062477588654,
+        0.7116886973381042,
+        0,
+        -0.6755834221839905,
+        0.47497618198394775,
+        -0.5639013051986694,
+        0,
+        -0.2616262137889862,
+        -0.8695039749145508,
+        -0.4189445376396179,
+        0,
+        115.9541015625,
+        89.47693634033203,
+        -311.7364501953125,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        0.8620702028274536,
+        -0.015319700352847576,
+        -0.506557285785675,
+        0,
+        -0.4340354502201081,
+        0.4936883449554444,
+        -0.7535814642906189,
+        0,
+        0.26162606477737427,
+        0.8695039749145508,
+        0.41894471645355225,
+        0,
+        -71.11894989013672,
+        74.98487091064453,
+        -164.83367919921875,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        -0.6893031001091003,
+        -0.13550062477588654,
+        0.7116886973381042,
+        0,
+        -0.6755834221839905,
+        0.47497618198394775,
+        -0.5639013051986694,
+        0,
+        -0.2616262137889862,
+        -0.8695039749145508,
+        -0.4189445376396179,
+        0,
+        122.234375,
+        89.96346282958984,
+        -316.668212890625,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        0.8620702028274536,
+        -0.015319700352847576,
+        -0.506557285785675,
+        0,
+        -0.4340354502201081,
+        0.4936883449554444,
+        -0.7535814642906189,
+        0,
+        0.26162606477737427,
+        0.8695039749145508,
+        0.41894471645355225,
+        0,
+        -64.83870697021484,
+        75.47139739990234,
+        -169.76536560058597,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        -0.6893031001091003,
+        -0.13550062477588654,
+        0.7116886973381042,
+        0,
+        -0.6755834221839905,
+        0.47497618198394775,
+        -0.5639013051986694,
+        0,
+        -0.2616262137889862,
+        -0.8695039749145508,
+        -0.4189445376396179,
+        0,
+        128.51461791992188,
+        90.44998931884766,
+        -321.5999145507813,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        0.8620702028274536,
+        -0.015319700352847576,
+        -0.506557285785675,
+        0,
+        -0.4340354502201081,
+        0.4936883449554444,
+        -0.7535814642906189,
+        0,
+        0.26162606477737427,
+        0.8695039749145508,
+        0.41894471645355225,
+        0,
+        -58.558441162109375,
+        75.9579086303711,
+        -174.6970672607422,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        -0.6893031001091003,
+        -0.13550062477588654,
+        0.7116886973381042,
+        0,
+        -0.6755834221839905,
+        0.47497618198394775,
+        -0.5639013051986694,
+        0,
+        -0.2616262137889862,
+        -0.8695039749145508,
+        -0.4189445376396179,
+        0,
+        134.79489135742188,
+        90.9365005493164,
+        -326.5315856933594,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        0.8620702028274536,
+        -0.015319700352847576,
+        -0.506557285785675,
+        0,
+        -0.4340354502201081,
+        0.4936883449554444,
+        -0.7535814642906189,
+        0,
+        0.26162606477737427,
+        0.8695039749145508,
+        0.41894471645355225,
+        0,
+        -52.27817535400391,
+        76.44441223144531,
+        -179.62875366210938,
+        1
+      ]
+    },
+    {
+      "mesh": 6,
+      "matrix": [
+        -0.6893031001091003,
+        -0.13550062477588654,
+        0.7116886973381042,
+        0,
+        -0.6755834221839905,
+        0.47497618198394775,
+        -0.5639013051986694,
+        0,
+        -0.2616262137889862,
+        -0.8695039749145508,
+        -0.4189445376396179,
+        0,
+        141.07516479492188,
+        91.42301940917967,
+        -331.4632263183594,
+        1
+      ]
+    },
+    {
+      "mesh": 7,
+      "matrix": [
+        0.7850325703620911,
+        0.06081420928239823,
+        -0.6164620518684387,
+        0,
+        -0.13561886548995972,
+        0.9878994822502136,
+        -0.07524696737527847,
+        0,
+        0.6044265031814575,
+        0.14267520606517792,
+        0.7837808728218079,
+        0,
+        -1.248520016670227,
+        -250.06192016601565,
+        -90.22713470458984,
+        1
+      ]
+    },
+    {
+      "mesh": 8,
+      "matrix": [
+        0.7850322723388672,
+        0.06081392988562584,
+        -0.6164625287055969,
+        0,
+        -0.3924780488014221,
+        -0.7211048007011414,
+        -0.5709367990493774,
+        0,
+        -0.4792549908161164,
+        0.6901518106460571,
+        -0.5422223806381226,
+        0,
+        45.59693908691406,
+        243.51312255859375,
+        69.38878631591797,
+        1
+      ]
+    },
+    {
+      "children": [
+        55,
+        54,
+        49,
+        44
+      ],
+      "matrix": [
+        0.9999974370002748,
+        0,
+        -0.0022710729390382767,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0.0022710729390382767,
+        0,
+        0.9999974370002748,
+        0,
+        -0.13409000635147095,
+        -12.999988555908203,
+        0.12365700304508208,
+        1
+      ]
+    },
+    {
+      "children": [
+        48,
+        47,
+        46,
+        45
+      ],
+      "matrix": [
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        -0.000007999999979801942,
+        -0.000011000000085914508,
+        -99.9995346069336,
+        1
+      ]
+    },
+    {
+      "mesh": 9,
+      "matrix": [
+        0.9999974370002748,
+        0,
+        0.002270043129101396,
+        0,
+        0,
+        1,
+        0,
+        0,
+        -0.002270043129101396,
+        0,
+        0.9999974370002748,
+        0,
+        49.7321662902832,
+        344.3533630371094,
+        79.59915161132812,
+        1
+      ]
+    },
+    {
+      "mesh": 10,
+      "matrix": [
+        0.9999974370002748,
+        1.0191530236923485e-13,
+        0.0022699993569403887,
+        0,
+        -1.0191530236923485e-13,
+        -1,
+        8.97931243248884e-11,
+        0,
+        0.0022699993569403887,
+        -8.97931243248884e-11,
+        -0.9999974370002748,
+        0,
+        49.69811248779297,
+        257.12298583984375,
+        94.59911346435548,
+        1
+      ]
+    },
+    {
+      "mesh": 11,
+      "matrix": [
+        0.9986716508865356,
+        -4.959933574966158e-10,
+        -0.051525991410017014,
+        0,
+        -0.051525991410017014,
+        -1.9239376314317272e-8,
+        -0.9986716508865356,
+        0,
+        -4.959933574966158e-10,
+        1,
+        -1.9239376314317272e-8,
+        0,
+        67.53964233398438,
+        326.7381286621094,
+        297.74066162109375,
+        1
+      ]
+    },
+    {
+      "mesh": 11,
+      "matrix": [
+        0.9986629486083984,
+        -1.884843170429917e-9,
+        -0.05169397220015526,
+        0,
+        -0.05169397220015526,
+        -7.287438563707839e-8,
+        -0.9986629486083984,
+        0,
+        -1.884843170429917e-9,
+        1,
+        -7.287438563707839e-8,
+        0,
+        17.574960708618164,
+        326.7381286621094,
+        297.6291809082031,
+        1
+      ]
+    },
+    {
+      "children": [
+        53,
+        52,
+        51,
+        50
+      ]
+    },
+    {
+      "mesh": 9,
+      "matrix": [
+        0.9999974370002748,
+        0,
+        0.002270043129101396,
+        0,
+        0,
+        1,
+        0,
+        0,
+        -0.002270043129101396,
+        0,
+        0.9999974370002748,
+        0,
+        49.50515365600586,
+        344.3533630371094,
+        79.59934997558594,
+        1
+      ]
+    },
+    {
+      "mesh": 10,
+      "matrix": [
+        0.9999974370002748,
+        1.0191530236923485e-13,
+        0.0022699993569403887,
+        0,
+        -1.0191530236923485e-13,
+        -1,
+        8.97931243248884e-11,
+        0,
+        0.0022699993569403887,
+        -8.97931243248884e-11,
+        -0.9999974370002748,
+        0,
+        49.47110366821289,
+        257.1229553222656,
+        94.59931182861328,
+        1
+      ]
+    },
+    {
+      "mesh": 11,
+      "matrix": [
+        0.9984543323516846,
+        -6.428584886641885e-10,
+        -0.05557801201939583,
+        0,
+        -0.05557801201939583,
+        -2.311567648405344e-8,
+        -0.9984543323516846,
+        0,
+        -6.428584886641885e-10,
+        1,
+        -2.311567648405344e-8,
+        0,
+        68.16710662841797,
+        326.7381286621094,
+        297.7886657714844,
+        1
+      ]
+    },
+    {
+      "mesh": 11,
+      "matrix": [
+        0.998445212841034,
+        5.507552747197052e-10,
+        -0.05574197694659233,
+        0,
+        -0.05574197694659233,
+        1.97455189976381e-8,
+        -0.998445212841034,
+        0,
+        5.507552747197052e-10,
+        1,
+        1.97455189976381e-8,
+        0,
+        18.201759338378906,
+        326.7381286621094,
+        297.6770324707031,
+        1
+      ]
+    },
+    {
+      "mesh": 12,
+      "matrix": [
+        -0.9999873638153076,
+        -0.004487415309995413,
+        -0.0022699744440615177,
+        0,
+        0.004487401805818081,
+        -0.999989926815033,
+        0.000011093182365584651,
+        0,
+        -0.0022700014524161816,
+        9.06754564766743e-7,
+        0.9999974370002748,
+        0,
+        -29.98022842407227,
+        768.69921875,
+        -20.581327438354492,
+        1
+      ]
+    },
+    {
+      "mesh": 12,
+      "matrix": [
+        -0.9999850392341614,
+        -0.004973169881850481,
+        -0.002269970485940576,
+        0,
+        0.004973156377673149,
+        -0.9999876618385316,
+        0.00001164450713986298,
+        0,
+        -0.0022700002882629637,
+        3.554153522600245e-7,
+        0.9999974370002748,
+        0,
+        48.794708251953125,
+        768.6771850585938,
+        -20.40250396728516,
+        1
+      ]
+    },
+    {
+      "mesh": 13,
+      "matrix": [
+        -0.8213930726051331,
+        0.3830228745937348,
+        0.4226191341876984,
+        0,
+        -0.3830228745937348,
+        0.17860689759254456,
+        -0.9063073992729188,
+        0,
+        -0.4226191341876984,
+        -0.9063073992729188,
+        4.807415265872805e-8,
+        0,
+        -141.64085388183597,
+        388.6727600097656,
+        122.00779724121094,
+        1
+      ]
+    },
+    {
+      "mesh": 13,
+      "matrix": [
+        -0.8213450312614441,
+        -0.38299909234046936,
+        0.42273396253585815,
+        0,
+        -0.38312679529190075,
+        -0.1786557286977768,
+        -0.9062538146972656,
+        0,
+        0.4226182401180268,
+        -0.906307816505432,
+        7.823305168130901e-7,
+        0,
+        -270.7940673828125,
+        145.4340057373047,
+        122.04411315917967,
+        1
+      ]
+    },
+    {
+      "mesh": 14,
+      "matrix": [
+        1,
+        -0.000060999998822808266,
+        -0.000001000000338535756,
+        0,
+        0.000001000000338535756,
+        9.44896494381453e-10,
+        1,
+        0,
+        -0.000060999998822808266,
+        -1,
+        1.0058964772241552e-9,
+        0,
+        51.087928771972656,
+        325.7384033203125,
+        91.09835815429688,
+        1
+      ]
+    },
+    {
+      "mesh": 15,
+      "matrix": [
+        1,
+        0,
+        0,
+        0,
+        0,
+        4.4896641959724086e-11,
+        -1,
+        0,
+        0,
+        1,
+        4.4896641959724086e-11,
+        0,
+        24.52630043029785,
+        213.73817443847656,
+        283.0735778808594,
+        1
+      ]
+    },
+    {
+      "mesh": 16,
+      "matrix": [
+        0.9026297926902772,
+        -0.4304177761077881,
+        0,
+        0,
+        0.4304177761077881,
+        0.9026297926902772,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        353.9793395996094,
+        330.9040222167969,
+        -5.389931201934815,
+        1
+      ]
+    },
+    {
+      "mesh": 17,
+      "matrix": [
+        0.9026297330856324,
+        0.4304178953170777,
+        0,
+        0,
+        -0.4304178953170777,
+        0.9026297330856324,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        277.7611083984375,
+        580.0806274414062,
+        -5.3898539543151855,
+        1
+      ]
+    },
+    {
+      "mesh": 18,
+      "matrix": [
+        1,
+        0,
+        0,
+        0,
+        0,
+        4.4896641959724086e-11,
+        1,
+        0,
+        0,
+        -1,
+        4.4896641959724086e-11,
+        0,
+        49.58733749389649,
+        175.73818969726565,
+        89.59835815429688,
+        1
+      ]
+    },
+    {
+      "mesh": 19,
+      "matrix": [
+        0.9999933242797852,
+        -1.649976856532565e-11,
+        0.003653998486697674,
+        0,
+        0.003653998486697674,
+        9.031045244967117e-9,
+        -0.9999933242797852,
+        0,
+        -1.649976856532565e-11,
+        1,
+        9.031045244967117e-9,
+        0,
+        81.19497680664062,
+        247.73817443847656,
+        220.1460723876953,
+        1
+      ]
+    },
+    {
+      "mesh": 19,
+      "matrix": [
+        0.9999898672103882,
+        -4.353116391658807e-12,
+        -0.004497999791055918,
+        0,
+        -0.004497999791055918,
+        -1.9355692604250407e-9,
+        -0.9999898672103882,
+        0,
+        -4.353116391658807e-12,
+        1,
+        -1.9355692604250407e-9,
+        0,
+        -23.12494468688965,
+        247.73817443847656,
+        220.35459899902344,
+        1
+      ]
+    },
+    {
+      "mesh": 20,
+      "matrix": [
+        -2.907086411596538e-7,
+        0.7071071863174438,
+        -0.7071064114570618,
+        0,
+        7.018321639407077e-7,
+        -0.7071064114570618,
+        -0.7071071863174438,
+        0,
+        -1,
+        -7.018321639407077e-7,
+        -2.907086411596538e-7,
+        0,
+        65,
+        128.71702575683597,
+        -3.270524024963379,
+        1
+      ]
+    },
+    {
+      "mesh": 21,
+      "matrix": [
+        4.4896641959724086e-11,
+        0,
+        -1,
+        0,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        4.4896641959724086e-11,
+        0,
+        223.9999847412109,
+        31.98792839050293,
+        23.50873374938965,
+        1
+      ]
+    },
+    {
+      "mesh": 22,
+      "matrix": [
+        4.4896641959724086e-11,
+        0,
+        -1,
+        0,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        4.4896641959724086e-11,
+        0,
+        223.9999847412109,
+        30.487924575805664,
+        25.008731842041016,
+        1
+      ]
+    },
+    {
+      "mesh": 23,
+      "matrix": [
+        1.1084333451094608e-10,
+        -0.0009251347510144116,
+        -0.9999995827674866,
+        0,
+        2.396268712345773e-7,
+        -0.9999995827674866,
+        0.0009251347510144116,
+        0,
+        -1,
+        -2.396268712345773e-7,
+        1.1084333451094608e-10,
+        0,
+        -295,
+        21.498876571655277,
+        0.49255698919296265,
+        1
+      ]
+    },
+    {
+      "mesh": 23,
+      "matrix": [
+        5.062397168131838e-10,
+        0.002356505487114191,
+        -0.9999971985816956,
+        0,
+        -4.2965237412317947e-7,
+        -0.9999971985816956,
+        -0.002356505487114191,
+        0,
+        -1,
+        4.2965237412317947e-7,
+        5.062397168131838e-10,
+        0,
+        -295,
+        21.60527801513672,
+        -105.32867431640624,
+        1
+      ]
+    },
+    {
+      "mesh": 24,
+      "matrix": [
+        -1,
+        6.349337028366264e-11,
+        6.349337028366264e-11,
+        0,
+        -6.349337028366264e-11,
+        -2.220446049250313e-16,
+        -1,
+        0,
+        -6.349337028366264e-11,
+        -1,
+        -2.220446049250313e-16,
+        0,
+        -126.93566131591795,
+        0.000003000000106112566,
+        36.558841705322266,
+        1
+      ]
+    },
+    {
+      "mesh": 25,
+      "matrix": [
+        1,
+        0,
+        0,
+        0,
+        0,
+        4.4896641959724086e-11,
+        1,
+        0,
+        0,
+        -1,
+        4.4896641959724086e-11,
+        0,
+        126.93566131591795,
+        -0.00005299999975250103,
+        -36.5588493347168,
+        1
+      ]
+    },
+    {
+      "mesh": 26
+    },
+    {
+      "mesh": 27,
+      "matrix": [
+        -0.9861037135124208,
+        0.16613073647022247,
+        0,
+        0,
+        -0.16613073647022247,
+        -0.9861037135124208,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        -71.01806640625,
+        -22.193012237548828,
+        -20,
+        1
+      ]
+    },
+    {
+      "mesh": 27,
+      "matrix": [
+        0.9861037135124208,
+        -0.16613082587718964,
+        0,
+        0,
+        0.16613082587718964,
+        0.9861037135124208,
+        0,
+        0,
+        0,
+        0,
+        1,
+        0,
+        71.01806640625,
+        22.19301414489746,
+        22,
+        1
+      ]
+    },
+    {
+      "mesh": 28,
+      "matrix": [
+        4.4896641959724086e-11,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        0,
+        -1,
+        0,
+        4.4896641959724086e-11,
+        0,
+        -100,
+        -66.15117645263672,
+        -5.627896785736084,
+        1
+      ]
+    },
+    {
+      "mesh": 28,
+      "matrix": [
+        4.4896641959724086e-11,
+        0,
+        1,
+        0,
+        0,
+        1,
+        0,
+        0,
+        -1,
+        0,
+        4.4896641959724086e-11,
+        0,
+        -100,
+        -66.15116882324219,
+        14.372098922729492,
+        1
+      ]
+    },
+    {
+      "mesh": 28,
+      "matrix": [
+        -2.220446049250313e-16,
+        6.349337028366264e-11,
+        1,
+        0,
+        -6.349337028366264e-11,
+        -1,
+        6.349337028366264e-11,
+        0,
+        1,
+        -6.349337028366264e-11,
+        -2.220446049250313e-16,
+        0,
+        100,
+        -133.8488311767578,
+        34.37212753295899,
+        1
+      ]
+    },
+    {
+      "mesh": 28,
+      "matrix": [
+        -2.220446049250313e-16,
+        6.349337028366264e-11,
+        1,
+        0,
+        -6.349337028366264e-11,
+        -1,
+        6.349337028366264e-11,
+        0,
+        1,
+        -6.349337028366264e-11,
+        -2.220446049250313e-16,
+        0,
+        100,
+        -133.8488311767578,
+        54.37212371826172,
+        1
+      ]
+    },
+    {
+      "mesh": 23,
+      "matrix": [
+        5.062397168131838e-10,
+        0.002356505487114191,
+        -0.9999971985816956,
+        0,
+        -4.2965237412317947e-7,
+        -0.9999971985816956,
+        -0.002356505487114191,
+        0,
+        -1,
+        4.2965237412317947e-7,
+        5.062397168131838e-10,
+        0,
+        -295,
+        123.80779266357422,
+        -100.10150146484376,
+        1
+      ]
+    },
+    {
+      "mesh": 23,
+      "matrix": [
+        5.062397168131838e-10,
+        0.002356505487114191,
+        -0.9999971985816956,
+        0,
+        -4.2965237412317947e-7,
+        -0.9999971985816956,
+        -0.002356505487114191,
+        0,
+        -1,
+        4.2965237412317947e-7,
+        5.062397168131838e-10,
+        0,
+        -295,
+        132.1395263671875,
+        -3.9833459854125977,
+        1
+      ]
+    },
+    {
+      "matrix": [
+        0.7071067690849304,
+        -2.1563657526257887e-7,
+        -0.7071068286895752,
+        0,
+        -0.3312943577766419,
+        0.883452296257019,
+        -0.33129459619522095,
+        0,
+        0.6246951818466187,
+        0.4685211479663849,
+        0.6246950030326843,
+        0,
+        1005.9874267578124,
+        766.3170776367188,
+        953.3455810546876,
+        1
+      ],
+      "camera": 0
+    }
+  ],
+  "cameras": [
+    {
+      "perspective": {
+        "aspectRatio": 1,
+        "yfov": 0.3143463730812073,
+        "zfar": 1000000,
+        "znear": 0.04999999701976776
+      },
+      "type": "perspective"
+    }
+  ],
+  "meshes": [
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 1,
+            "POSITION": 2
+          },
+          "indices": 0,
+          "mode": 4,
+          "material": 0,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 0,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        },
+        {
+          "attributes": {
+            "NORMAL": 4,
+            "POSITION": 5
+          },
+          "indices": 3,
+          "mode": 4,
+          "material": 1,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 1,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "Piston_123-844_0_Parts_1"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 7,
+            "POSITION": 8
+          },
+          "indices": 6,
+          "mode": 4,
+          "material": 2,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 2,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_24"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 10,
+            "POSITION": 11
+          },
+          "indices": 9,
+          "mode": 4,
+          "material": 3,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 3,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_23"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 13,
+            "POSITION": 14
+          },
+          "indices": 12,
+          "mode": 4,
+          "material": 4,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 4,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_22"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 16,
+            "POSITION": 17
+          },
+          "indices": 15,
+          "mode": 4,
+          "material": 5,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 5,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_21"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 19,
+            "POSITION": 20
+          },
+          "indices": 18,
+          "mode": 4,
+          "material": 6,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 6,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_20"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 22,
+            "POSITION": 23
+          },
+          "indices": 21,
+          "mode": 4,
+          "material": 7,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 7,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        },
+        {
+          "attributes": {
+            "NORMAL": 25,
+            "POSITION": 26
+          },
+          "indices": 24,
+          "mode": 4,
+          "material": 8,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 8,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        },
+        {
+          "attributes": {
+            "NORMAL": 28,
+            "POSITION": 29
+          },
+          "indices": 27,
+          "mode": 4,
+          "material": 9,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 9,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "Spring_Link__0_Parts_1"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 31,
+            "POSITION": 32
+          },
+          "indices": 30,
+          "mode": 4,
+          "material": 10,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 10,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_19"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 34,
+            "POSITION": 35
+          },
+          "indices": 33,
+          "mode": 4,
+          "material": 11,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 11,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_18"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 37,
+            "POSITION": 38
+          },
+          "indices": 36,
+          "mode": 4,
+          "material": 12,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 12,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_17"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 40,
+            "POSITION": 41
+          },
+          "indices": 39,
+          "mode": 4,
+          "material": 13,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 13,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_16"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 43,
+            "POSITION": 44
+          },
+          "indices": 42,
+          "mode": 4,
+          "material": 14,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 14,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_15"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 46,
+            "POSITION": 47
+          },
+          "indices": 45,
+          "mode": 4,
+          "material": 15,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 15,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_14"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 49,
+            "POSITION": 50
+          },
+          "indices": 48,
+          "mode": 4,
+          "material": 16,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 16,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_13"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 52,
+            "POSITION": 53
+          },
+          "indices": 51,
+          "mode": 4,
+          "material": 17,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 17,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_12"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 55,
+            "POSITION": 56
+          },
+          "indices": 54,
+          "mode": 4,
+          "material": 18,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 18,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_11"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 58,
+            "POSITION": 59
+          },
+          "indices": 57,
+          "mode": 4,
+          "material": 19,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 19,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_10"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 61,
+            "POSITION": 62
+          },
+          "indices": 60,
+          "mode": 4,
+          "material": 20,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 20,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_9"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 64,
+            "POSITION": 65
+          },
+          "indices": 63,
+          "mode": 4,
+          "material": 21,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 21,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_8"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 67,
+            "POSITION": 68
+          },
+          "indices": 66,
+          "mode": 4,
+          "material": 22,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 22,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_7"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 70,
+            "POSITION": 71
+          },
+          "indices": 69,
+          "mode": 4,
+          "material": 23,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 23,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_6"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 73,
+            "POSITION": 74
+          },
+          "indices": 72,
+          "mode": 4,
+          "material": 24,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 24,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_5"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 76,
+            "POSITION": 77
+          },
+          "indices": 75,
+          "mode": 4,
+          "material": 25,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 25,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_4"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 79,
+            "POSITION": 80
+          },
+          "indices": 78,
+          "mode": 4,
+          "material": 26,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 26,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 82,
+            "POSITION": 83
+          },
+          "indices": 81,
+          "mode": 4,
+          "material": 27,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 27,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_3"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 85,
+            "POSITION": 86
+          },
+          "indices": 84,
+          "mode": 4,
+          "material": 28,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 28,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_2"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 88,
+            "POSITION": 89
+          },
+          "indices": 87,
+          "mode": 4,
+          "material": 29,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 29,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "body_1"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 91,
+            "POSITION": 92
+          },
+          "indices": 90,
+          "mode": 4,
+          "material": 30,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 30,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        },
+        {
+          "attributes": {
+            "NORMAL": 94,
+            "POSITION": 95
+          },
+          "indices": 93,
+          "mode": 4,
+          "material": 31,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 31,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "rod_123-699_0_Parts_1"
+    },
+    {
+      "primitives": [
+        {
+          "attributes": {
+            "NORMAL": 97,
+            "POSITION": 98
+          },
+          "indices": 96,
+          "mode": 4,
+          "material": 32,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 32,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        },
+        {
+          "attributes": {
+            "NORMAL": 100,
+            "POSITION": 101
+          },
+          "indices": 99,
+          "mode": 4,
+          "material": 33,
+          "extensions": {
+            "KHR_draco_mesh_compression": {
+              "bufferView": 33,
+              "attributes": {
+                "NORMAL": 0,
+                "POSITION": 1
+              }
+            }
+          }
+        }
+      ],
+      "name": "Lifter_123-923_0_Parts_1"
+    }
+  ],
+  "accessors": [
+    {
+      "componentType": 5123,
+      "count": 8250,
+      "max": [
+        2011
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 2019,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 2019,
+      "max": [
+        63.40448572208197,
+        56.08839293136558,
+        46.562239366912465
+      ],
+      "min": [
+        -43.18272974063667,
+        -37.02586557437691,
+        -46.552019138830026
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 5034,
+      "max": [
+        1295
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 1296,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.0085841421987496
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.0071021323110545
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 1296,
+      "max": [
+        53.40421474812726,
+        56.071585904462886,
+        46.48897622932617
+      ],
+      "min": [
+        31.823853243486322,
+        -37.01927877555665,
+        -46.51102377067383
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 792,
+      "max": [
+        263
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 264,
+      "max": [
+        1.007843137254902,
+        1.0085841421987496,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.0071021323110545,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 264,
+      "max": [
+        -242.44321321264732,
+        107.60525894351395,
+        85.04152418172936
+      ],
+      "min": [
+        -264.53407789266686,
+        85.55591844522377,
+        -0.04152418172936004
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 1530,
+      "max": [
+        669
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 670,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 670,
+      "max": [
+        36.0150846938826,
+        35.77556925980009,
+        10.029517132302988
+      ],
+      "min": [
+        -36.0150846938826,
+        -36.008523414585724,
+        -15.035153816197054
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 5640,
+      "max": [
+        1552
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 1553,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 1553,
+      "max": [
+        63.07857825014145,
+        35.09330727894479,
+        113.6238397655105
+      ],
+      "min": [
+        -63.114142805061284,
+        -35.1238397655105,
+        -140.1238397655105
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 7716,
+      "max": [
+        2469
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 2470,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 2470,
+      "max": [
+        69.04801049765925,
+        -31.053647338091963,
+        10.071605568696185
+      ],
+      "min": [
+        -69.04801049765925,
+        -168.94747796592097,
+        -15.067396789163162
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 4098,
+      "max": [
+        1381
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 1382,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 1382,
+      "max": [
+        177.51338138775995,
+        -14.20547458143659,
+        19.069568473767465
+      ],
+      "min": [
+        -76.2342905064123,
+        -55.691794778873245,
+        -19.19691791730097
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 123,
+      "max": [
+        42
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 43,
+      "max": [
+        0.9906806646608843,
+        1.0070963205075736,
+        0.01101498323328376
+      ],
+      "min": [
+        -1.0078373254514208,
+        -1.0070963205075734,
+        -1.0078373254514208
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 43,
+      "max": [
+        131.15477841018057,
+        -35.545531343237386,
+        5.002442598925256
+      ],
+      "min": [
+        129.4474017614263,
+        -37.25290799199166,
+        -0.002442598925256473
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 123,
+      "max": [
+        42
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 43,
+      "max": [
+        1.0070963205075736,
+        1.0088496505045428,
+        0.01101498323328376
+      ],
+      "min": [
+        -1.0070963205075734,
+        -0.9896683396077623,
+        -1.0078373254514208
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 43,
+      "max": [
+        131.1979414917052,
+        -61.503653814691305,
+        5.002442598925256
+      ],
+      "min": [
+        129.40507388056693,
+        -63.29652142582955,
+        -0.002442598925256473
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 4842,
+      "max": [
+        869
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 870,
+      "max": [
+        1.007843137254902,
+        1.0085841421987496,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.0071021323110545,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 870,
+      "max": [
+        132.31635282932984,
+        -34.386640562682715,
+        15.020499208466157
+      ],
+      "min": [
+        128.28646279779014,
+        -64.4129848340458,
+        -0.014654145569235276
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 870,
+      "max": [
+        293
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 294,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.0085841421987496
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.0071021323110545
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 294,
+      "max": [
+        181.61274291738744,
+        312.1717225425583,
+        18.017225856249894
+      ],
+      "min": [
+        71.50526092782741,
+        276.06033752694856,
+        -18.040421979277088
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 1860,
+      "max": [
+        623
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 624,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.0085841421987496
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.0071021323110545
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 624,
+      "max": [
+        211.18447328091366,
+        300.2211685217935,
+        15.996206279842227
+      ],
+      "min": [
+        202.14881133660492,
+        268.18990325555023,
+        -16.003793720157773
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 1140,
+      "max": [
+        407
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 408,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 408,
+      "max": [
+        54.5927169438275,
+        -38.58734297088489,
+        15.041035661944308
+      ],
+      "min": [
+        -44.50400997361265,
+        -80.66355205735289,
+        -0.04836345872007816
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 972,
+      "max": [
+        339
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 340,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 340,
+      "max": [
+        54.5927169438275,
+        -48.557050929514446,
+        15.041035661944308
+      ],
+      "min": [
+        -44.50400997361265,
+        -61.66354824265562,
+        -0.04836345872007816
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 924,
+      "max": [
+        323
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 324,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 324,
+      "max": [
+        30.590223082694763,
+        217.20610309520697,
+        0.03957010258915261
+      ],
+      "min": [
+        15.514013996226764,
+        202.12989400873897,
+        -81.03957010258915
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 276,
+      "max": [
+        95
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 96,
+      "max": [
+        1.007843137254902,
+        1.0085841421987496,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.0071021323110545,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 96,
+      "max": [
+        -36.645295939331355,
+        469.697984852905,
+        115.05618740840252
+      ],
+      "min": [
+        -49.735184448197465,
+        456.60809634403887,
+        -0.056179779008009044
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 1044,
+      "max": [
+        347
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 348,
+      "max": [
+        1.007843137254902,
+        1.0085841421987496,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.0071021323110545,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 348,
+      "max": [
+        -278.36243962379683,
+        -55.606046437168914,
+        65.03175378602833
+      ],
+      "min": [
+        -296.43034387391896,
+        -73.64219690126271,
+        -0.03175378602833415
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 4956,
+      "max": [
+        1408
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 1413,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 1413,
+      "max": [
+        105.10791280622533,
+        60.12821201982295,
+        75.09822780246203
+      ],
+      "min": [
+        -98.09043386335424,
+        -124.12875631208472,
+        2.208630534457648
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 8016,
+      "max": [
+        1939
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 1942,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 1942,
+      "max": [
+        40.90842442589384,
+        233.18429666620733,
+        70.04825886669074
+      ],
+      "min": [
+        19.24019328174675,
+        214.74940959034052,
+        -28.834158982657552
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 9060,
+      "max": [
+        1753
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 1755,
+      "max": [
+        1.007843137254902,
+        1.0078551177885018,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007831156721302,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 1755,
+      "max": [
+        -252.50384356000683,
+        -164.048902242313,
+        85.04152418172936
+      ],
+      "min": [
+        -330.486256847745,
+        -199.21988416708095,
+        -0.04152418172936004
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 9036,
+      "max": [
+        1748
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 1750,
+      "max": [
+        1.007843137254902,
+        1.0078551177885018,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007831156721302,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 1750,
+      "max": [
+        -248.42355181196,
+        -164.048902242313,
+        85.04152418172936
+      ],
+      "min": [
+        -326.40596509969816,
+        -199.21988416708095,
+        -0.04152418172936004
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 17556,
+      "max": [
+        5473
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 5481,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 5481,
+      "max": [
+        113.11425593030935,
+        59.855536590859444,
+        0.1265035907873937
+      ],
+      "min": [
+        -103.09678461683279,
+        -120.79517176282887,
+        -82.49587061536795
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 1080,
+      "max": [
+        371
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 372,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 372,
+      "max": [
+        37.66338539496246,
+        226.16108321770844,
+        0.01221434663549914
+      ],
+      "min": [
+        13.639934536067813,
+        202.1610813103598,
+        -17.011724475773008
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 672,
+      "max": [
+        239
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 240,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 240,
+      "max": [
+        -25.825387825194838,
+        156.20804847317555,
+        0.11235955801600994
+      ],
+      "min": [
+        -189.08382562246916,
+        -7.050389324098782,
+        -230.1123748168051
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 4974,
+      "max": [
+        1413
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 1417,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 1417,
+      "max": [
+        105.10791280622533,
+        60.12821201982295,
+        147.79042774791185
+      ],
+      "min": [
+        -98.09043386335424,
+        -124.12875631208472,
+        74.90083047990748
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 17094,
+      "max": [
+        5363
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 5370,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 5370,
+      "max": [
+        113.11425593030935,
+        59.855536590859444,
+        82.51410393259917
+      ],
+      "min": [
+        -103.09678461683279,
+        -120.79517176282887,
+        -0.10827027355617846
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 564,
+      "max": [
+        191
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 192,
+      "max": [
+        1.007843137254902,
+        1.0085841421987496,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.0071021323110545,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 192,
+      "max": [
+        -25.82539396188174,
+        81.21283311941708,
+        0.11235955801600994
+      ],
+      "min": [
+        -39.083821807771876,
+        67.95440527352694,
+        -230.1123748168051
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 27684,
+      "max": [
+        8617
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 8618,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 8618,
+      "max": [
+        99.19769106530887,
+        151.65165664419408,
+        80.1123499066642
+      ],
+      "min": [
+        -62.028483884184325,
+        -38.53396941885229,
+        -80.09281875356908
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 27684,
+      "max": [
+        8617
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 8618,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 8618,
+      "max": [
+        99.19769106530887,
+        151.65165664419408,
+        80.1123499066642
+      ],
+      "min": [
+        -62.028483884184325,
+        -38.53396941885229,
+        -80.09281875356908
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 14874,
+      "max": [
+        3671
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 3677,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 3677,
+      "max": [
+        95.09045272998597,
+        90.13237496708217,
+        113.11231703168892
+      ],
+      "min": [
+        -95.13237496708216,
+        -181.10393258426967,
+        -120.13237496708216
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 3903,
+      "max": [
+        1280
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 1289,
+      "max": [
+        1.007843137254902,
+        1.007843137254902,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.007843137254902,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 1289,
+      "max": [
+        111.14250709746136,
+        30.73910905421507,
+        10.093795798729847
+      ],
+      "min": [
+        -71.0353141042973,
+        -43.41233207915083,
+        -10.088910600879336
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 960,
+      "max": [
+        179
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 180,
+      "max": [
+        1.007843137254902,
+        1.0085841421987496,
+        1.007843137254902
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.0071021323110545,
+        -1.007843137254902
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 180,
+      "max": [
+        76.1074352818812,
+        2.5916090654523174,
+        7.037701616068263
+      ],
+      "min": [
+        -11.853575761922698,
+        -15.223822649129728,
+        -7.042928751119475
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 423,
+      "max": [
+        142
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 143,
+      "max": [
+        1.007843137254902,
+        1.0085841421987496,
+        1.011764705882353
+      ],
+      "min": [
+        -1.007843137254902,
+        -1.0071021323110545,
+        -0.00784313725490196
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 143,
+      "max": [
+        -16.588934008994798,
+        -26.062883441367845,
+        0.03972677911964695
+      ],
+      "min": [
+        -32.16183142389504,
+        -41.635780856268084,
+        -81.3604436370298
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5123,
+      "count": 2163,
+      "max": [
+        385
+      ],
+      "min": [
+        0
+      ],
+      "type": "SCALAR"
+    },
+    {
+      "componentType": 5126,
+      "count": 386,
+      "max": [
+        0.782551365740159,
+        0.7822283681701212,
+        -0.6225824215832878
+      ],
+      "min": [
+        -0.7819053706000832,
+        -0.7822283681701211,
+        -1.0060873802970438
+      ],
+      "type": "VEC3"
+    },
+    {
+      "componentType": 5126,
+      "count": 386,
+      "max": [
+        -16.616233825683587,
+        -26.091251526102532,
+        -81.31242564601553
+      ],
+      "min": [
+        -32.123733367696296,
+        -41.60632308937599,
+        -85.00757202126074
+      ],
+      "type": "VEC3"
+    }
+  ],
+  "materials": [
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.8500000238418579,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_20",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0,
+          0,
+          0,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_21",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.5609999895095825,
+          0,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_17",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.5609999895095825,
+          0,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_17",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0,
+          0.42500001192092896,
+          0.42500001192092896,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_22",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.5609999895095825,
+          0,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_17",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0,
+          0.42500001192092896,
+          0.42500001192092896,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_22",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.5609999895095825,
+          0,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_17",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0,
+          0,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_18",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0,
+          0.5609999895095825,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_23",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0,
+          0,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_16",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0,
+          0,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_16",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.8500000238418579,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_20",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.8500000238418579,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_20",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0,
+          0,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_16",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0,
+          0,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_16",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.5609999895095825,
+          0,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_17",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0,
+          0.5609999895095825,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_23",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.8500000238418579,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_20",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.5609999895095825,
+          0,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_17",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.5609999895095825,
+          0,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_17",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.8500000238418579,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_20",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0,
+          0,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_16",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0,
+          0.42500001192092896,
+          0.42500001192092896,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_22",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0,
+          0.5609999895095825,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_23",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.8500000238418579,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_20",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0,
+          0,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_16",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.8500000238418579,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_20",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.8500000238418579,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_20",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.8500000238418579,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_20",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.8500000238418579,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_19",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.8500000238418579,
+          0.8500000238418579,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_20",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0.5609999895095825,
+          0,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_17",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    },
+    {
+      "pbrMetallicRoughness": {
+        "baseColorFactor": [
+          0.8500000238418579,
+          0,
+          0,
+          1
+        ],
+        "metallicFactor": 0,
+        "roughnessFactor": 1
+      },
+      "emissiveFactor": [
+        0,
+        0,
+        0
+      ],
+      "name": "Material_18",
+      "alphaMode": "OPAQUE",
+      "doubleSided": false
+    }
+  ],
+  "bufferViews": [
+    {
+      "buffer": 0,
+      "byteOffset": 0,
+      "byteLength": 7048
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 7048,
+      "byteLength": 3418
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 10468,
+      "byteLength": 749
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 11220,
+      "byteLength": 1576
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 12796,
+      "byteLength": 4477
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 17276,
+      "byteLength": 6111
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 23388,
+      "byteLength": 3514
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 26904,
+      "byteLength": 296
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 27200,
+      "byteLength": 298
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 27500,
+      "byteLength": 2063
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 29564,
+      "byteLength": 879
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 30444,
+      "byteLength": 1716
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 32160,
+      "byteLength": 1119
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 33280,
+      "byteLength": 936
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 34216,
+      "byteLength": 839
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 35056,
+      "byteLength": 352
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 35408,
+      "byteLength": 984
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 36392,
+      "byteLength": 4746
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 41140,
+      "byteLength": 4936
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 46076,
+      "byteLength": 6002
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 52080,
+      "byteLength": 5976
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 58056,
+      "byteLength": 14759
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 72816,
+      "byteLength": 1052
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 73868,
+      "byteLength": 690
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 74560,
+      "byteLength": 4754
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 79316,
+      "byteLength": 14406
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 93724,
+      "byteLength": 494
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 94220,
+      "byteLength": 21649
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 115872,
+      "byteLength": 21709
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 137584,
+      "byteLength": 11596
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 149180,
+      "byteLength": 3313
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 152496,
+      "byteLength": 936
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 153432,
+      "byteLength": 419
+    },
+    {
+      "buffer": 0,
+      "byteOffset": 153852,
+      "byteLength": 1540
+    }
+  ],
+  "buffers": [
+    {
+      "name": "2CylinderEngine",
+      "byteLength": 155392,
+      "uri": "2CylinderEngine.bin"
+    }
+  ],
+  "extensionsRequired": [
+    "KHR_draco_mesh_compression"
+  ],
+  "extensionsUsed": [
+    "KHR_draco_mesh_compression"
+  ]
+}

From deac3a9f6c6a4417144586ed28a1f474fea97984 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Wed, 20 Jan 2021 10:14:20 +0000
Subject: [PATCH 02/30] Add Draco 1.4.1 sources

Upstream: https://github.com/google/draco
---
 contrib/draco/.clang-format                   |    5 +
 contrib/draco/.cmake-format.py                |  102 ++
 contrib/draco/.gitignore                      |    1 +
 contrib/draco/.ruby-version                   |    1 +
 contrib/draco/.travis.yml                     |   31 +
 contrib/draco/AUTHORS                         |    7 +
 contrib/draco/BUILDING.md                     |  301 ++++
 contrib/draco/CMAKE.md                        |  106 ++
 contrib/draco/CMakeLists.txt                  |  958 +++++++++++++
 contrib/draco/CONTRIBUTING.md                 |   27 +
 contrib/draco/LICENSE                         |  252 ++++
 contrib/draco/README.md                       |  478 +++++++
 contrib/draco/cmake/DracoConfig.cmake         |    3 +
 contrib/draco/cmake/FindDraco.cmake           |   56 +
 contrib/draco/cmake/compiler_flags.cmake      |  220 +++
 contrib/draco/cmake/compiler_tests.cmake      |  103 ++
 .../draco/cmake/draco-config.cmake.template   |    2 +
 contrib/draco/cmake/draco.pc.template         |   11 +
 .../draco/cmake/draco_build_definitions.cmake |  117 ++
 contrib/draco/cmake/draco_cpu_detection.cmake |   28 +
 contrib/draco/cmake/draco_emscripten.cmake    |  185 +++
 contrib/draco/cmake/draco_features.cmake      |   63 +
 contrib/draco/cmake/draco_flags.cmake         |  238 ++++
 contrib/draco/cmake/draco_helpers.cmake       |  110 ++
 contrib/draco/cmake/draco_install.cmake       |   79 ++
 contrib/draco/cmake/draco_intrinsics.cmake    |   96 ++
 contrib/draco/cmake/draco_options.cmake       |  239 ++++
 contrib/draco/cmake/draco_sanitizer.cmake     |   32 +
 contrib/draco/cmake/draco_targets.cmake       |  349 +++++
 contrib/draco/cmake/draco_test_config.h.cmake |   13 +
 contrib/draco/cmake/draco_tests.cmake         |  133 ++
 contrib/draco/cmake/draco_variables.cmake     |   64 +
 contrib/draco/cmake/sanitizers.cmake          |   19 +
 .../cmake/toolchains/aarch64-linux-gnu.cmake  |   14 +
 .../cmake/toolchains/android-ndk-common.cmake |   23 +
 contrib/draco/cmake/toolchains/android.cmake  |   39 +
 .../cmake/toolchains/arm-ios-common.cmake     |   17 +
 .../toolchains/arm-linux-gnueabihf.cmake      |   15 +
 .../toolchains/arm64-android-ndk-libcpp.cmake |   16 +
 .../draco/cmake/toolchains/arm64-ios.cmake    |   14 +
 .../cmake/toolchains/arm64-linux-gcc.cmake    |   18 +
 .../toolchains/armv7-android-ndk-libcpp.cmake |   16 +
 .../draco/cmake/toolchains/armv7-ios.cmake    |   14 +
 .../cmake/toolchains/armv7-linux-gcc.cmake    |   24 +
 .../draco/cmake/toolchains/armv7s-ios.cmake   |   14 +
 contrib/draco/cmake/toolchains/i386-ios.cmake |   15 +
 .../toolchains/x86-android-ndk-libcpp.cmake   |   16 +
 .../x86_64-android-ndk-libcpp.cmake           |   16 +
 .../draco/cmake/toolchains/x86_64-ios.cmake   |   15 +
 contrib/draco/cmake/util.cmake                |   79 ++
 .../src/draco/animation/keyframe_animation.cc |   54 +
 .../src/draco/animation/keyframe_animation.h  |  107 ++
 .../animation/keyframe_animation_decoder.cc   |   30 +
 .../animation/keyframe_animation_decoder.h    |   34 +
 .../animation/keyframe_animation_encoder.cc   |   28 +
 .../animation/keyframe_animation_encoder.h    |   39 +
 .../keyframe_animation_encoding_test.cc       |  168 +++
 .../animation/keyframe_animation_test.cc      |  102 ++
 .../attribute_octahedron_transform.cc         |  145 ++
 .../attribute_octahedron_transform.h          |   81 ++
 .../attribute_quantization_transform.cc       |  260 ++++
 .../attribute_quantization_transform.h        |  102 ++
 .../draco/attributes/attribute_transform.cc   |   40 +
 .../draco/attributes/attribute_transform.h    |   76 +
 .../attributes/attribute_transform_data.h     |   71 +
 .../attributes/attribute_transform_type.h     |   30 +
 .../draco/attributes/geometry_attribute.cc    |  102 ++
 .../src/draco/attributes/geometry_attribute.h |  350 +++++
 .../src/draco/attributes/geometry_indices.h   |   54 +
 .../src/draco/attributes/point_attribute.cc   |  225 +++
 .../src/draco/attributes/point_attribute.h    |  190 +++
 .../draco/attributes/point_attribute_test.cc  |  128 ++
 .../attributes/attributes_decoder.cc          |  127 ++
 .../attributes/attributes_decoder.h           |   97 ++
 .../attributes/attributes_decoder_interface.h |   62 +
 .../attributes/attributes_encoder.cc          |   49 +
 .../attributes/attributes_encoder.h           |  154 +++
 .../attributes/kd_tree_attributes_decoder.cc  |  556 ++++++++
 .../attributes/kd_tree_attributes_decoder.h   |   46 +
 .../attributes/kd_tree_attributes_encoder.cc  |  305 ++++
 .../attributes/kd_tree_attributes_encoder.h   |   51 +
 .../attributes/kd_tree_attributes_shared.h    |   28 +
 .../compression/attributes/linear_sequencer.h |   51 +
 .../mesh_attribute_indices_encoding_data.h    |   58 +
 .../attributes/normal_compression_utils.h     |  360 +++++
 .../compression/attributes/point_d_vector.h   |  279 ++++
 .../attributes/point_d_vector_test.cc         |  360 +++++
 .../compression/attributes/points_sequencer.h |   63 +
 ..._constrained_multi_parallelogram_decoder.h |  231 ++++
 ..._constrained_multi_parallelogram_encoder.h |  414 ++++++
 ...e_constrained_multi_parallelogram_shared.h |   34 +
 .../mesh_prediction_scheme_data.h             |   72 +
 .../mesh_prediction_scheme_decoder.h          |   46 +
 .../mesh_prediction_scheme_encoder.h          |   46 +
 ...ediction_scheme_geometric_normal_decoder.h |  172 +++
 ...ediction_scheme_geometric_normal_encoder.h |  180 +++
 ...n_scheme_geometric_normal_predictor_area.h |  117 ++
 ...n_scheme_geometric_normal_predictor_base.h |   96 ++
 ...ction_scheme_multi_parallelogram_decoder.h |  126 ++
 ...ction_scheme_multi_parallelogram_encoder.h |  133 ++
 ..._prediction_scheme_parallelogram_decoder.h |   98 ++
 ..._prediction_scheme_parallelogram_encoder.h |  111 ++
 ...h_prediction_scheme_parallelogram_shared.h |   78 ++
 ...esh_prediction_scheme_tex_coords_decoder.h |  344 +++++
 ...esh_prediction_scheme_tex_coords_encoder.h |  318 +++++
 ...ction_scheme_tex_coords_portable_decoder.h |  143 ++
 ...ction_scheme_tex_coords_portable_encoder.h |  133 ++
 ...ion_scheme_tex_coords_portable_predictor.h |  263 ++++
 .../prediction_scheme_decoder.h               |   90 ++
 .../prediction_scheme_decoder_factory.h       |  194 +++
 .../prediction_scheme_decoder_interface.h     |   53 +
 .../prediction_scheme_decoding_transform.h    |   65 +
 .../prediction_scheme_delta_decoder.h         |   65 +
 .../prediction_scheme_delta_encoder.h         |   69 +
 .../prediction_scheme_encoder.h               |   90 ++
 .../prediction_scheme_encoder_factory.cc      |   85 ++
 .../prediction_scheme_encoder_factory.h       |  129 ++
 .../prediction_scheme_encoder_interface.h     |   55 +
 .../prediction_scheme_encoding_transform.h    |   77 ++
 .../prediction_scheme_factory.h               |   85 ++
 .../prediction_scheme_interface.h             |   60 +
 ...ahedron_canonicalized_decoding_transform.h |  118 ++
 ...ahedron_canonicalized_encoding_transform.h |  116 ++
 ..._octahedron_canonicalized_transform_base.h |  102 ++
 ...octahedron_canonicalized_transform_test.cc |  192 +++
 ...eme_normal_octahedron_decoding_transform.h |  103 ++
 ...eme_normal_octahedron_encoding_transform.h |  105 ++
 ..._scheme_normal_octahedron_transform_base.h |   90 ++
 ...scheme_normal_octahedron_transform_test.cc |   71 +
 ...rediction_scheme_wrap_decoding_transform.h |   88 ++
 ...rediction_scheme_wrap_encoding_transform.h |   81 ++
 .../prediction_scheme_wrap_transform_base.h   |  120 ++
 .../sequential_attribute_decoder.cc           |  118 ++
 .../attributes/sequential_attribute_decoder.h |   86 ++
 ...equential_attribute_decoders_controller.cc |  149 ++
 ...sequential_attribute_decoders_controller.h |   61 +
 .../sequential_attribute_encoder.cc           |  108 ++
 .../attributes/sequential_attribute_encoder.h |  134 ++
 ...equential_attribute_encoders_controller.cc |  159 +++
 ...sequential_attribute_encoders_controller.h |  115 ++
 .../sequential_integer_attribute_decoder.cc   |  240 ++++
 .../sequential_integer_attribute_decoder.h    |   76 +
 .../sequential_integer_attribute_encoder.cc   |  233 ++++
 .../sequential_integer_attribute_encoder.h    |   67 +
 ...uential_integer_attribute_encoding_test.cc |   64 +
 .../sequential_normal_attribute_decoder.cc    |   76 +
 .../sequential_normal_attribute_decoder.h     |   83 ++
 .../sequential_normal_attribute_encoder.cc    |   57 +
 .../sequential_normal_attribute_encoder.h     |   82 ++
 ...quential_quantization_attribute_decoder.cc |   88 ++
 ...equential_quantization_attribute_decoder.h |   52 +
 ...quential_quantization_attribute_encoder.cc |   86 ++
 ...equential_quantization_attribute_encoder.h |   52 +
 .../adaptive_rans_bit_coding_shared.h         |   43 +
 .../bit_coders/adaptive_rans_bit_decoder.cc   |   70 +
 .../bit_coders/adaptive_rans_bit_decoder.h    |   54 +
 .../bit_coders/adaptive_rans_bit_encoder.cc   |   59 +
 .../bit_coders/adaptive_rans_bit_encoder.h    |   61 +
 .../bit_coders/direct_bit_decoder.cc          |   54 +
 .../bit_coders/direct_bit_decoder.h           |   90 ++
 .../bit_coders/direct_bit_encoder.cc          |   39 +
 .../bit_coders/direct_bit_encoder.h           |   89 ++
 .../bit_coders/folded_integer_bit_decoder.h   |   77 ++
 .../bit_coders/folded_integer_bit_encoder.h   |   82 ++
 .../bit_coders/rans_bit_decoder.cc            |   82 ++
 .../compression/bit_coders/rans_bit_decoder.h |   55 +
 .../bit_coders/rans_bit_encoder.cc            |  125 ++
 .../compression/bit_coders/rans_bit_encoder.h |   57 +
 .../bit_coders/rans_coding_test.cc            |    9 +
 .../bit_coders/symbol_bit_decoder.cc          |   49 +
 .../bit_coders/symbol_bit_decoder.h           |   36 +
 .../bit_coders/symbol_bit_encoder.cc          |   30 +
 .../bit_coders/symbol_bit_encoder.h           |   36 +
 .../compression/config/compression_shared.h   |  155 +++
 .../compression/config/decoder_options.h      |   34 +
 .../config/decoder_options_test.cc            |   67 +
 .../draco/compression/config/draco_options.h  |  249 ++++
 .../compression/config/encoder_options.h      |   97 ++
 .../compression/config/encoding_features.h    |   39 +
 contrib/draco/src/draco/compression/decode.cc |  135 ++
 contrib/draco/src/draco/compression/decode.h  |   80 ++
 .../src/draco/compression/decode_test.cc      |  169 +++
 contrib/draco/src/draco/compression/encode.cc |   96 ++
 contrib/draco/src/draco/compression/encode.h  |  140 ++
 .../draco/src/draco/compression/encode_base.h |  131 ++
 .../src/draco/compression/encode_test.cc      |  407 ++++++
 .../draco/src/draco/compression/entropy/ans.h |  527 +++++++
 .../compression/entropy/rans_symbol_coding.h  |   53 +
 .../compression/entropy/rans_symbol_decoder.h |  164 +++
 .../compression/entropy/rans_symbol_encoder.h |  290 ++++
 .../compression/entropy/shannon_entropy.cc    |  147 ++
 .../compression/entropy/shannon_entropy.h     |  110 ++
 .../entropy/shannon_entropy_test.cc           |   58 +
 .../compression/entropy/symbol_coding_test.cc |  170 +++
 .../compression/entropy/symbol_decoding.cc    |  181 +++
 .../compression/entropy/symbol_decoding.h     |   29 +
 .../compression/entropy/symbol_encoding.cc    |  376 +++++
 .../compression/entropy/symbol_encoding.h     |   47 +
 .../src/draco/compression/expert_encode.cc    |  182 +++
 .../src/draco/compression/expert_encode.h     |  147 ++
 .../draco/compression/mesh/mesh_decoder.cc    |   37 +
 .../src/draco/compression/mesh/mesh_decoder.h |   68 +
 .../mesh/mesh_edgebreaker_decoder.cc          |   70 +
 .../mesh/mesh_edgebreaker_decoder.h           |   54 +
 .../mesh/mesh_edgebreaker_decoder_impl.cc     | 1231 +++++++++++++++++
 .../mesh/mesh_edgebreaker_decoder_impl.h      |  228 +++
 .../mesh_edgebreaker_decoder_impl_interface.h |   47 +
 .../mesh/mesh_edgebreaker_encoder.cc          |  195 +++
 .../mesh/mesh_edgebreaker_encoder.h           |   73 +
 .../mesh/mesh_edgebreaker_encoder_impl.cc     |  854 ++++++++++++
 .../mesh/mesh_edgebreaker_encoder_impl.h      |  210 +++
 .../mesh_edgebreaker_encoder_impl_interface.h |   57 +
 .../mesh/mesh_edgebreaker_encoding_test.cc    |  247 ++++
 .../mesh/mesh_edgebreaker_shared.h            |  131 ++
 .../mesh/mesh_edgebreaker_traversal_decoder.h |  201 +++
 .../mesh/mesh_edgebreaker_traversal_encoder.h |  139 ++
 ...edgebreaker_traversal_predictive_decoder.h |  134 ++
 ...edgebreaker_traversal_predictive_encoder.h |  172 +++
 ...sh_edgebreaker_traversal_valence_decoder.h |  215 +++
 ...sh_edgebreaker_traversal_valence_encoder.h |  226 +++
 .../draco/compression/mesh/mesh_encoder.cc    |   34 +
 .../src/draco/compression/mesh/mesh_encoder.h |   84 ++
 .../compression/mesh/mesh_encoder_test.cc     |  116 ++
 .../mesh/mesh_sequential_decoder.cc           |  169 +++
 .../mesh/mesh_sequential_decoder.h            |   39 +
 .../mesh/mesh_sequential_encoder.cc           |  132 ++
 .../mesh/mesh_sequential_encoder.h            |   57 +
 .../mesh/traverser/depth_first_traverser.h    |  172 +++
 .../max_prediction_degree_traverser.h         |  226 +++
 ...mesh_attribute_indices_encoding_observer.h |   76 +
 .../mesh/traverser/mesh_traversal_sequencer.h |  113 ++
 .../mesh/traverser/traverser_base.h           |   87 ++
 .../dynamic_integer_points_kd_tree_decoder.cc |   26 +
 .../dynamic_integer_points_kd_tree_decoder.h  |  330 +++++
 .../dynamic_integer_points_kd_tree_encoder.cc |   26 +
 .../dynamic_integer_points_kd_tree_encoder.h  |  371 +++++
 .../algorithms/float_points_tree_decoder.cc   |  152 ++
 .../algorithms/float_points_tree_decoder.h    |  141 ++
 .../algorithms/float_points_tree_encoder.cc   |   94 ++
 .../algorithms/float_points_tree_encoder.h    |  126 ++
 .../integer_points_kd_tree_decoder.cc         |   45 +
 .../integer_points_kd_tree_decoder.h          |  314 +++++
 .../integer_points_kd_tree_encoder.cc         |   45 +
 .../integer_points_kd_tree_encoder.h          |  404 ++++++
 .../point_cloud_compression_method.h          |   34 +
 .../algorithms/point_cloud_types.h            |   76 +
 .../algorithms/quantize_points_3.h            |   84 ++
 .../point_cloud/algorithms/queuing_policy.h   |   75 +
 .../point_cloud/point_cloud_decoder.cc        |  199 +++
 .../point_cloud/point_cloud_decoder.h         |  118 ++
 .../point_cloud/point_cloud_encoder.cc        |  306 ++++
 .../point_cloud/point_cloud_encoder.h         |  158 +++
 .../point_cloud_kd_tree_decoder.cc            |   40 +
 .../point_cloud/point_cloud_kd_tree_decoder.h |   31 +
 .../point_cloud_kd_tree_encoder.cc            |   43 +
 .../point_cloud/point_cloud_kd_tree_encoder.h |   45 +
 .../point_cloud_kd_tree_encoding_test.cc      |  458 ++++++
 .../point_cloud_sequential_decoder.cc         |   42 +
 .../point_cloud_sequential_decoder.h          |   33 +
 .../point_cloud_sequential_encoder.cc         |   49 +
 .../point_cloud_sequential_encoder.h          |   43 +
 .../point_cloud_sequential_encoding_test.cc   |   92 ++
 contrib/draco/src/draco/core/bit_utils.cc     |   36 +
 contrib/draco/src/draco/core/bit_utils.h      |  124 ++
 contrib/draco/src/draco/core/bounding_box.cc  |   30 +
 contrib/draco/src/draco/core/bounding_box.h   |   72 +
 .../src/draco/core/buffer_bit_coding_test.cc  |  115 ++
 contrib/draco/src/draco/core/cycle_timer.cc   |   49 +
 contrib/draco/src/draco/core/cycle_timer.h    |   50 +
 contrib/draco/src/draco/core/data_buffer.cc   |   61 +
 contrib/draco/src/draco/core/data_buffer.h    |   82 ++
 .../draco/src/draco/core/decoder_buffer.cc    |   72 +
 contrib/draco/src/draco/core/decoder_buffer.h |  216 +++
 contrib/draco/src/draco/core/divide.cc        |   88 ++
 contrib/draco/src/draco/core/divide.h         |   42 +
 .../draco/src/draco/core/draco_index_type.h   |  183 +++
 .../src/draco/core/draco_index_type_vector.h  |   83 ++
 .../draco/src/draco/core/draco_test_base.h    |   11 +
 .../draco/src/draco/core/draco_test_utils.cc  |   80 ++
 .../draco/src/draco/core/draco_test_utils.h   |   93 ++
 contrib/draco/src/draco/core/draco_types.cc   |   61 +
 contrib/draco/src/draco/core/draco_types.h    |   52 +
 contrib/draco/src/draco/core/draco_version.h  |   27 +
 .../draco/src/draco/core/encoder_buffer.cc    |   93 ++
 contrib/draco/src/draco/core/encoder_buffer.h |  152 ++
 contrib/draco/src/draco/core/hash_utils.cc    |   58 +
 contrib/draco/src/draco/core/hash_utils.h     |   64 +
 contrib/draco/src/draco/core/macros.h         |  119 ++
 contrib/draco/src/draco/core/math_utils.h     |   55 +
 .../draco/src/draco/core/math_utils_test.cc   |   22 +
 contrib/draco/src/draco/core/options.cc       |   94 ++
 contrib/draco/src/draco/core/options.h        |  150 ++
 .../src/draco/core/quantization_utils.cc      |   42 +
 .../draco/src/draco/core/quantization_utils.h |   82 ++
 .../src/draco/core/quantization_utils_test.cc |   91 ++
 contrib/draco/src/draco/core/status.h         |   77 ++
 contrib/draco/src/draco/core/status_or.h      |   81 ++
 contrib/draco/src/draco/core/status_test.cc   |   38 +
 .../draco/src/draco/core/varint_decoding.h    |   81 ++
 .../draco/src/draco/core/varint_encoding.h    |   61 +
 contrib/draco/src/draco/core/vector_d.h       |  355 +++++
 contrib/draco/src/draco/core/vector_d_test.cc |  306 ++++
 .../draco/src/draco/io/file_reader_factory.cc |   45 +
 .../draco/src/draco/io/file_reader_factory.h  |   34 +
 .../src/draco/io/file_reader_factory_test.cc  |   85 ++
 .../src/draco/io/file_reader_interface.h      |   32 +
 .../src/draco/io/file_reader_test_common.h    |   13 +
 contrib/draco/src/draco/io/file_utils.cc      |  110 ++
 contrib/draco/src/draco/io/file_utils.h       |   73 +
 contrib/draco/src/draco/io/file_utils_test.cc |   69 +
 .../draco/src/draco/io/file_writer_factory.cc |   45 +
 .../draco/src/draco/io/file_writer_factory.h  |   34 +
 .../src/draco/io/file_writer_factory_test.cc  |   70 +
 .../src/draco/io/file_writer_interface.h      |   26 +
 .../draco/src/draco/io/file_writer_utils.cc   |   57 +
 .../draco/src/draco/io/file_writer_utils.h    |   38 +
 contrib/draco/src/draco/io/mesh_io.cc         |   87 ++
 contrib/draco/src/draco/io/mesh_io.h          |  107 ++
 contrib/draco/src/draco/io/obj_decoder.cc     |  708 ++++++++++
 contrib/draco/src/draco/io/obj_decoder.h      |  129 ++
 .../draco/src/draco/io/obj_decoder_test.cc    |  193 +++
 contrib/draco/src/draco/io/obj_encoder.cc     |  346 +++++
 contrib/draco/src/draco/io/obj_encoder.h      |   92 ++
 .../draco/src/draco/io/obj_encoder_test.cc    |  110 ++
 contrib/draco/src/draco/io/parser_utils.cc    |  260 ++++
 contrib/draco/src/draco/io/parser_utils.h     |   66 +
 contrib/draco/src/draco/io/ply_decoder.cc     |  320 +++++
 contrib/draco/src/draco/io/ply_decoder.h      |   69 +
 .../draco/src/draco/io/ply_decoder_test.cc    |   93 ++
 contrib/draco/src/draco/io/ply_encoder.cc     |  211 +++
 contrib/draco/src/draco/io/ply_encoder.h      |   54 +
 .../draco/src/draco/io/ply_property_reader.h  |   96 ++
 .../draco/src/draco/io/ply_property_writer.h  |   94 ++
 contrib/draco/src/draco/io/ply_reader.cc      |  312 +++++
 contrib/draco/src/draco/io/ply_reader.h       |  155 +++
 contrib/draco/src/draco/io/ply_reader_test.cc |  143 ++
 contrib/draco/src/draco/io/point_cloud_io.cc  |   58 +
 contrib/draco/src/draco/io/point_cloud_io.h   |   89 ++
 .../draco/src/draco/io/point_cloud_io_test.cc |  115 ++
 .../draco/src/draco/io/stdio_file_reader.cc   |   96 ++
 .../draco/src/draco/io/stdio_file_reader.h    |   48 +
 .../src/draco/io/stdio_file_reader_test.cc    |   49 +
 .../draco/src/draco/io/stdio_file_writer.cc   |   59 +
 .../draco/src/draco/io/stdio_file_writer.h    |   42 +
 .../src/draco/io/stdio_file_writer_test.cc    |   38 +
 .../animation_decoder_webidl_wrapper.cc       |  101 ++
 .../animation_decoder_webidl_wrapper.h        |   73 +
 .../animation_encoder_webidl_wrapper.cc       |   89 ++
 .../animation_encoder_webidl_wrapper.h        |   66 +
 .../emscripten/decoder_functions.js           |   33 +
 .../emscripten/decoder_webidl_wrapper.cc      |  363 +++++
 .../emscripten/decoder_webidl_wrapper.h       |  330 +++++
 .../draco_animation_decoder_glue_wrapper.cc   |   28 +
 .../draco_animation_encoder_glue_wrapper.cc   |   25 +
 .../draco_animation_web_decoder.idl           |   52 +
 .../draco_animation_web_encoder.idl           |   34 +
 .../emscripten/draco_decoder_glue_wrapper.cc  |   28 +
 .../emscripten/draco_encoder_glue_wrapper.cc  |   25 +
 .../emscripten/draco_web_decoder.idl          |  283 ++++
 .../emscripten/draco_web_encoder.idl          |  208 +++
 .../emscripten/encoder_webidl_wrapper.cc      |  359 +++++
 .../emscripten/encoder_webidl_wrapper.h       |  186 +++
 .../draco/javascript/emscripten/finalize.js   |   22 +
 .../javascript/emscripten/prepareCallbacks.js |   38 +
 .../draco/javascript/emscripten/version.js    |   29 +
 .../draco/src/draco/maya/draco_maya_plugin.cc |  265 ++++
 .../draco/src/draco/maya/draco_maya_plugin.h  |   81 ++
 contrib/draco/src/draco/mesh/corner_table.cc  |  441 ++++++
 contrib/draco/src/draco/mesh/corner_table.h   |  396 ++++++
 .../src/draco/mesh/corner_table_iterators.h   |  289 ++++
 contrib/draco/src/draco/mesh/mesh.cc          |   40 +
 contrib/draco/src/draco/mesh/mesh.h           |  152 ++
 .../src/draco/mesh/mesh_are_equivalent.cc     |  205 +++
 .../src/draco/mesh/mesh_are_equivalent.h      |   71 +
 .../draco/mesh/mesh_are_equivalent_test.cc    |   98 ++
 .../draco/mesh/mesh_attribute_corner_table.cc |  211 +++
 .../draco/mesh/mesh_attribute_corner_table.h  |  196 +++
 contrib/draco/src/draco/mesh/mesh_cleanup.cc  |  251 ++++
 contrib/draco/src/draco/mesh/mesh_cleanup.h   |   65 +
 .../draco/src/draco/mesh/mesh_cleanup_test.cc |  192 +++
 .../src/draco/mesh/mesh_misc_functions.cc     |   63 +
 .../src/draco/mesh/mesh_misc_functions.h      |   98 ++
 .../draco/src/draco/mesh/mesh_stripifier.cc   |  102 ++
 .../draco/src/draco/mesh/mesh_stripifier.h    |  260 ++++
 .../draco/mesh/triangle_soup_mesh_builder.cc  |   89 ++
 .../draco/mesh/triangle_soup_mesh_builder.h   |   63 +
 .../mesh/triangle_soup_mesh_builder_test.cc   |  197 +++
 contrib/draco/src/draco/mesh/valence_cache.h  |  142 ++
 .../src/draco/metadata/geometry_metadata.cc   |   44 +
 .../src/draco/metadata/geometry_metadata.h    |  140 ++
 contrib/draco/src/draco/metadata/metadata.cc  |  132 ++
 contrib/draco/src/draco/metadata/metadata.h   |  208 +++
 .../src/draco/metadata/metadata_decoder.cc    |  148 ++
 .../src/draco/metadata/metadata_decoder.h     |   42 +
 .../src/draco/metadata/metadata_encoder.cc    |   97 ++
 .../src/draco/metadata/metadata_encoder.h     |   41 +
 .../draco/metadata/metadata_encoder_test.cc   |  167 +++
 .../draco/src/draco/metadata/metadata_test.cc |  157 +++
 .../src/draco/point_cloud/point_cloud.cc      |  275 ++++
 .../draco/src/draco/point_cloud/point_cloud.h |  244 ++++
 .../draco/point_cloud/point_cloud_builder.cc  |   76 +
 .../draco/point_cloud/point_cloud_builder.h   |   80 ++
 .../point_cloud/point_cloud_builder_test.cc   |  171 +++
 .../src/draco/point_cloud/point_cloud_test.cc |  132 ++
 .../draco/src/draco/tools/draco_decoder.cc    |  168 +++
 .../draco/src/draco/tools/draco_encoder.cc    |  369 +++++
 contrib/draco/src/draco/tools/fuzz/build.sh   |   35 +
 .../tools/fuzz/draco_mesh_decoder_fuzzer.cc   |   29 +
 ...h_decoder_without_dequantization_fuzzer.cc |   30 +
 .../tools/fuzz/draco_pc_decoder_fuzzer.cc     |   29 +
 ...c_decoder_without_dequantization_fuzzer.cc |   30 +
 .../src/draco/unity/draco_unity_plugin.cc     |  407 ++++++
 .../src/draco/unity/draco_unity_plugin.h      |  154 +++
 .../draco/unity/draco_unity_plugin_test.cc    |  243 ++++
 414 files changed, 51476 insertions(+)
 create mode 100644 contrib/draco/.clang-format
 create mode 100644 contrib/draco/.cmake-format.py
 create mode 100644 contrib/draco/.gitignore
 create mode 100644 contrib/draco/.ruby-version
 create mode 100644 contrib/draco/.travis.yml
 create mode 100644 contrib/draco/AUTHORS
 create mode 100644 contrib/draco/BUILDING.md
 create mode 100644 contrib/draco/CMAKE.md
 create mode 100644 contrib/draco/CMakeLists.txt
 create mode 100644 contrib/draco/CONTRIBUTING.md
 create mode 100644 contrib/draco/LICENSE
 create mode 100644 contrib/draco/README.md
 create mode 100644 contrib/draco/cmake/DracoConfig.cmake
 create mode 100644 contrib/draco/cmake/FindDraco.cmake
 create mode 100644 contrib/draco/cmake/compiler_flags.cmake
 create mode 100644 contrib/draco/cmake/compiler_tests.cmake
 create mode 100644 contrib/draco/cmake/draco-config.cmake.template
 create mode 100644 contrib/draco/cmake/draco.pc.template
 create mode 100644 contrib/draco/cmake/draco_build_definitions.cmake
 create mode 100644 contrib/draco/cmake/draco_cpu_detection.cmake
 create mode 100644 contrib/draco/cmake/draco_emscripten.cmake
 create mode 100644 contrib/draco/cmake/draco_features.cmake
 create mode 100644 contrib/draco/cmake/draco_flags.cmake
 create mode 100644 contrib/draco/cmake/draco_helpers.cmake
 create mode 100644 contrib/draco/cmake/draco_install.cmake
 create mode 100644 contrib/draco/cmake/draco_intrinsics.cmake
 create mode 100644 contrib/draco/cmake/draco_options.cmake
 create mode 100644 contrib/draco/cmake/draco_sanitizer.cmake
 create mode 100644 contrib/draco/cmake/draco_targets.cmake
 create mode 100644 contrib/draco/cmake/draco_test_config.h.cmake
 create mode 100644 contrib/draco/cmake/draco_tests.cmake
 create mode 100644 contrib/draco/cmake/draco_variables.cmake
 create mode 100644 contrib/draco/cmake/sanitizers.cmake
 create mode 100644 contrib/draco/cmake/toolchains/aarch64-linux-gnu.cmake
 create mode 100644 contrib/draco/cmake/toolchains/android-ndk-common.cmake
 create mode 100644 contrib/draco/cmake/toolchains/android.cmake
 create mode 100644 contrib/draco/cmake/toolchains/arm-ios-common.cmake
 create mode 100644 contrib/draco/cmake/toolchains/arm-linux-gnueabihf.cmake
 create mode 100644 contrib/draco/cmake/toolchains/arm64-android-ndk-libcpp.cmake
 create mode 100644 contrib/draco/cmake/toolchains/arm64-ios.cmake
 create mode 100644 contrib/draco/cmake/toolchains/arm64-linux-gcc.cmake
 create mode 100644 contrib/draco/cmake/toolchains/armv7-android-ndk-libcpp.cmake
 create mode 100644 contrib/draco/cmake/toolchains/armv7-ios.cmake
 create mode 100644 contrib/draco/cmake/toolchains/armv7-linux-gcc.cmake
 create mode 100644 contrib/draco/cmake/toolchains/armv7s-ios.cmake
 create mode 100644 contrib/draco/cmake/toolchains/i386-ios.cmake
 create mode 100644 contrib/draco/cmake/toolchains/x86-android-ndk-libcpp.cmake
 create mode 100644 contrib/draco/cmake/toolchains/x86_64-android-ndk-libcpp.cmake
 create mode 100644 contrib/draco/cmake/toolchains/x86_64-ios.cmake
 create mode 100644 contrib/draco/cmake/util.cmake
 create mode 100644 contrib/draco/src/draco/animation/keyframe_animation.cc
 create mode 100644 contrib/draco/src/draco/animation/keyframe_animation.h
 create mode 100644 contrib/draco/src/draco/animation/keyframe_animation_decoder.cc
 create mode 100644 contrib/draco/src/draco/animation/keyframe_animation_decoder.h
 create mode 100644 contrib/draco/src/draco/animation/keyframe_animation_encoder.cc
 create mode 100644 contrib/draco/src/draco/animation/keyframe_animation_encoder.h
 create mode 100644 contrib/draco/src/draco/animation/keyframe_animation_encoding_test.cc
 create mode 100644 contrib/draco/src/draco/animation/keyframe_animation_test.cc
 create mode 100644 contrib/draco/src/draco/attributes/attribute_octahedron_transform.cc
 create mode 100644 contrib/draco/src/draco/attributes/attribute_octahedron_transform.h
 create mode 100644 contrib/draco/src/draco/attributes/attribute_quantization_transform.cc
 create mode 100644 contrib/draco/src/draco/attributes/attribute_quantization_transform.h
 create mode 100644 contrib/draco/src/draco/attributes/attribute_transform.cc
 create mode 100644 contrib/draco/src/draco/attributes/attribute_transform.h
 create mode 100644 contrib/draco/src/draco/attributes/attribute_transform_data.h
 create mode 100644 contrib/draco/src/draco/attributes/attribute_transform_type.h
 create mode 100644 contrib/draco/src/draco/attributes/geometry_attribute.cc
 create mode 100644 contrib/draco/src/draco/attributes/geometry_attribute.h
 create mode 100644 contrib/draco/src/draco/attributes/geometry_indices.h
 create mode 100644 contrib/draco/src/draco/attributes/point_attribute.cc
 create mode 100644 contrib/draco/src/draco/attributes/point_attribute.h
 create mode 100644 contrib/draco/src/draco/attributes/point_attribute_test.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/attributes_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/attributes_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/attributes_decoder_interface.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/attributes_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/attributes_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/kd_tree_attributes_shared.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/linear_sequencer.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/mesh_attribute_indices_encoding_data.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/normal_compression_utils.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/point_d_vector.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/point_d_vector_test.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/points_sequencer.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_test.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_test.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoding_test.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/rans_coding_test.cc
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/config/compression_shared.h
 create mode 100644 contrib/draco/src/draco/compression/config/decoder_options.h
 create mode 100644 contrib/draco/src/draco/compression/config/decoder_options_test.cc
 create mode 100644 contrib/draco/src/draco/compression/config/draco_options.h
 create mode 100644 contrib/draco/src/draco/compression/config/encoder_options.h
 create mode 100644 contrib/draco/src/draco/compression/config/encoding_features.h
 create mode 100644 contrib/draco/src/draco/compression/decode.cc
 create mode 100644 contrib/draco/src/draco/compression/decode.h
 create mode 100644 contrib/draco/src/draco/compression/decode_test.cc
 create mode 100644 contrib/draco/src/draco/compression/encode.cc
 create mode 100644 contrib/draco/src/draco/compression/encode.h
 create mode 100644 contrib/draco/src/draco/compression/encode_base.h
 create mode 100644 contrib/draco/src/draco/compression/encode_test.cc
 create mode 100644 contrib/draco/src/draco/compression/entropy/ans.h
 create mode 100644 contrib/draco/src/draco/compression/entropy/rans_symbol_coding.h
 create mode 100644 contrib/draco/src/draco/compression/entropy/rans_symbol_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/entropy/rans_symbol_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/entropy/shannon_entropy.cc
 create mode 100644 contrib/draco/src/draco/compression/entropy/shannon_entropy.h
 create mode 100644 contrib/draco/src/draco/compression/entropy/shannon_entropy_test.cc
 create mode 100644 contrib/draco/src/draco/compression/entropy/symbol_coding_test.cc
 create mode 100644 contrib/draco/src/draco/compression/entropy/symbol_decoding.cc
 create mode 100644 contrib/draco/src/draco/compression/entropy/symbol_decoding.h
 create mode 100644 contrib/draco/src/draco/compression/entropy/symbol_encoding.cc
 create mode 100644 contrib/draco/src/draco/compression/entropy/symbol_encoding.h
 create mode 100644 contrib/draco/src/draco/compression/expert_encode.cc
 create mode 100644 contrib/draco/src/draco/compression/expert_encode.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.cc
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.cc
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoding_test.cc
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_shared.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_encoder_test.cc
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/traverser/depth_first_traverser.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/traverser/max_prediction_degree_traverser.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/traverser/mesh_traversal_sequencer.h
 create mode 100644 contrib/draco/src/draco/compression/mesh/traverser/traverser_base.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_compression_method.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_types.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/quantize_points_3.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/algorithms/queuing_policy.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoding_test.cc
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.cc
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.cc
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.h
 create mode 100644 contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoding_test.cc
 create mode 100644 contrib/draco/src/draco/core/bit_utils.cc
 create mode 100644 contrib/draco/src/draco/core/bit_utils.h
 create mode 100644 contrib/draco/src/draco/core/bounding_box.cc
 create mode 100644 contrib/draco/src/draco/core/bounding_box.h
 create mode 100644 contrib/draco/src/draco/core/buffer_bit_coding_test.cc
 create mode 100644 contrib/draco/src/draco/core/cycle_timer.cc
 create mode 100644 contrib/draco/src/draco/core/cycle_timer.h
 create mode 100644 contrib/draco/src/draco/core/data_buffer.cc
 create mode 100644 contrib/draco/src/draco/core/data_buffer.h
 create mode 100644 contrib/draco/src/draco/core/decoder_buffer.cc
 create mode 100644 contrib/draco/src/draco/core/decoder_buffer.h
 create mode 100644 contrib/draco/src/draco/core/divide.cc
 create mode 100644 contrib/draco/src/draco/core/divide.h
 create mode 100644 contrib/draco/src/draco/core/draco_index_type.h
 create mode 100644 contrib/draco/src/draco/core/draco_index_type_vector.h
 create mode 100644 contrib/draco/src/draco/core/draco_test_base.h
 create mode 100644 contrib/draco/src/draco/core/draco_test_utils.cc
 create mode 100644 contrib/draco/src/draco/core/draco_test_utils.h
 create mode 100644 contrib/draco/src/draco/core/draco_types.cc
 create mode 100644 contrib/draco/src/draco/core/draco_types.h
 create mode 100644 contrib/draco/src/draco/core/draco_version.h
 create mode 100644 contrib/draco/src/draco/core/encoder_buffer.cc
 create mode 100644 contrib/draco/src/draco/core/encoder_buffer.h
 create mode 100644 contrib/draco/src/draco/core/hash_utils.cc
 create mode 100644 contrib/draco/src/draco/core/hash_utils.h
 create mode 100644 contrib/draco/src/draco/core/macros.h
 create mode 100644 contrib/draco/src/draco/core/math_utils.h
 create mode 100644 contrib/draco/src/draco/core/math_utils_test.cc
 create mode 100644 contrib/draco/src/draco/core/options.cc
 create mode 100644 contrib/draco/src/draco/core/options.h
 create mode 100644 contrib/draco/src/draco/core/quantization_utils.cc
 create mode 100644 contrib/draco/src/draco/core/quantization_utils.h
 create mode 100644 contrib/draco/src/draco/core/quantization_utils_test.cc
 create mode 100644 contrib/draco/src/draco/core/status.h
 create mode 100644 contrib/draco/src/draco/core/status_or.h
 create mode 100644 contrib/draco/src/draco/core/status_test.cc
 create mode 100644 contrib/draco/src/draco/core/varint_decoding.h
 create mode 100644 contrib/draco/src/draco/core/varint_encoding.h
 create mode 100644 contrib/draco/src/draco/core/vector_d.h
 create mode 100644 contrib/draco/src/draco/core/vector_d_test.cc
 create mode 100644 contrib/draco/src/draco/io/file_reader_factory.cc
 create mode 100644 contrib/draco/src/draco/io/file_reader_factory.h
 create mode 100644 contrib/draco/src/draco/io/file_reader_factory_test.cc
 create mode 100644 contrib/draco/src/draco/io/file_reader_interface.h
 create mode 100644 contrib/draco/src/draco/io/file_reader_test_common.h
 create mode 100644 contrib/draco/src/draco/io/file_utils.cc
 create mode 100644 contrib/draco/src/draco/io/file_utils.h
 create mode 100644 contrib/draco/src/draco/io/file_utils_test.cc
 create mode 100644 contrib/draco/src/draco/io/file_writer_factory.cc
 create mode 100644 contrib/draco/src/draco/io/file_writer_factory.h
 create mode 100644 contrib/draco/src/draco/io/file_writer_factory_test.cc
 create mode 100644 contrib/draco/src/draco/io/file_writer_interface.h
 create mode 100644 contrib/draco/src/draco/io/file_writer_utils.cc
 create mode 100644 contrib/draco/src/draco/io/file_writer_utils.h
 create mode 100644 contrib/draco/src/draco/io/mesh_io.cc
 create mode 100644 contrib/draco/src/draco/io/mesh_io.h
 create mode 100644 contrib/draco/src/draco/io/obj_decoder.cc
 create mode 100644 contrib/draco/src/draco/io/obj_decoder.h
 create mode 100644 contrib/draco/src/draco/io/obj_decoder_test.cc
 create mode 100644 contrib/draco/src/draco/io/obj_encoder.cc
 create mode 100644 contrib/draco/src/draco/io/obj_encoder.h
 create mode 100644 contrib/draco/src/draco/io/obj_encoder_test.cc
 create mode 100644 contrib/draco/src/draco/io/parser_utils.cc
 create mode 100644 contrib/draco/src/draco/io/parser_utils.h
 create mode 100644 contrib/draco/src/draco/io/ply_decoder.cc
 create mode 100644 contrib/draco/src/draco/io/ply_decoder.h
 create mode 100644 contrib/draco/src/draco/io/ply_decoder_test.cc
 create mode 100644 contrib/draco/src/draco/io/ply_encoder.cc
 create mode 100644 contrib/draco/src/draco/io/ply_encoder.h
 create mode 100644 contrib/draco/src/draco/io/ply_property_reader.h
 create mode 100644 contrib/draco/src/draco/io/ply_property_writer.h
 create mode 100644 contrib/draco/src/draco/io/ply_reader.cc
 create mode 100644 contrib/draco/src/draco/io/ply_reader.h
 create mode 100644 contrib/draco/src/draco/io/ply_reader_test.cc
 create mode 100644 contrib/draco/src/draco/io/point_cloud_io.cc
 create mode 100644 contrib/draco/src/draco/io/point_cloud_io.h
 create mode 100644 contrib/draco/src/draco/io/point_cloud_io_test.cc
 create mode 100644 contrib/draco/src/draco/io/stdio_file_reader.cc
 create mode 100644 contrib/draco/src/draco/io/stdio_file_reader.h
 create mode 100644 contrib/draco/src/draco/io/stdio_file_reader_test.cc
 create mode 100644 contrib/draco/src/draco/io/stdio_file_writer.cc
 create mode 100644 contrib/draco/src/draco/io/stdio_file_writer.h
 create mode 100644 contrib/draco/src/draco/io/stdio_file_writer_test.cc
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.cc
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.h
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.cc
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.h
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/decoder_functions.js
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.cc
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.h
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/draco_animation_decoder_glue_wrapper.cc
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/draco_animation_encoder_glue_wrapper.cc
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/draco_animation_web_decoder.idl
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/draco_animation_web_encoder.idl
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/draco_decoder_glue_wrapper.cc
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/draco_encoder_glue_wrapper.cc
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/draco_web_decoder.idl
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/draco_web_encoder.idl
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.cc
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.h
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/finalize.js
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/prepareCallbacks.js
 create mode 100644 contrib/draco/src/draco/javascript/emscripten/version.js
 create mode 100644 contrib/draco/src/draco/maya/draco_maya_plugin.cc
 create mode 100644 contrib/draco/src/draco/maya/draco_maya_plugin.h
 create mode 100644 contrib/draco/src/draco/mesh/corner_table.cc
 create mode 100644 contrib/draco/src/draco/mesh/corner_table.h
 create mode 100644 contrib/draco/src/draco/mesh/corner_table_iterators.h
 create mode 100644 contrib/draco/src/draco/mesh/mesh.cc
 create mode 100644 contrib/draco/src/draco/mesh/mesh.h
 create mode 100644 contrib/draco/src/draco/mesh/mesh_are_equivalent.cc
 create mode 100644 contrib/draco/src/draco/mesh/mesh_are_equivalent.h
 create mode 100644 contrib/draco/src/draco/mesh/mesh_are_equivalent_test.cc
 create mode 100644 contrib/draco/src/draco/mesh/mesh_attribute_corner_table.cc
 create mode 100644 contrib/draco/src/draco/mesh/mesh_attribute_corner_table.h
 create mode 100644 contrib/draco/src/draco/mesh/mesh_cleanup.cc
 create mode 100644 contrib/draco/src/draco/mesh/mesh_cleanup.h
 create mode 100644 contrib/draco/src/draco/mesh/mesh_cleanup_test.cc
 create mode 100644 contrib/draco/src/draco/mesh/mesh_misc_functions.cc
 create mode 100644 contrib/draco/src/draco/mesh/mesh_misc_functions.h
 create mode 100644 contrib/draco/src/draco/mesh/mesh_stripifier.cc
 create mode 100644 contrib/draco/src/draco/mesh/mesh_stripifier.h
 create mode 100644 contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.cc
 create mode 100644 contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.h
 create mode 100644 contrib/draco/src/draco/mesh/triangle_soup_mesh_builder_test.cc
 create mode 100644 contrib/draco/src/draco/mesh/valence_cache.h
 create mode 100644 contrib/draco/src/draco/metadata/geometry_metadata.cc
 create mode 100644 contrib/draco/src/draco/metadata/geometry_metadata.h
 create mode 100644 contrib/draco/src/draco/metadata/metadata.cc
 create mode 100644 contrib/draco/src/draco/metadata/metadata.h
 create mode 100644 contrib/draco/src/draco/metadata/metadata_decoder.cc
 create mode 100644 contrib/draco/src/draco/metadata/metadata_decoder.h
 create mode 100644 contrib/draco/src/draco/metadata/metadata_encoder.cc
 create mode 100644 contrib/draco/src/draco/metadata/metadata_encoder.h
 create mode 100644 contrib/draco/src/draco/metadata/metadata_encoder_test.cc
 create mode 100644 contrib/draco/src/draco/metadata/metadata_test.cc
 create mode 100644 contrib/draco/src/draco/point_cloud/point_cloud.cc
 create mode 100644 contrib/draco/src/draco/point_cloud/point_cloud.h
 create mode 100644 contrib/draco/src/draco/point_cloud/point_cloud_builder.cc
 create mode 100644 contrib/draco/src/draco/point_cloud/point_cloud_builder.h
 create mode 100644 contrib/draco/src/draco/point_cloud/point_cloud_builder_test.cc
 create mode 100644 contrib/draco/src/draco/point_cloud/point_cloud_test.cc
 create mode 100644 contrib/draco/src/draco/tools/draco_decoder.cc
 create mode 100644 contrib/draco/src/draco/tools/draco_encoder.cc
 create mode 100644 contrib/draco/src/draco/tools/fuzz/build.sh
 create mode 100644 contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_fuzzer.cc
 create mode 100644 contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_without_dequantization_fuzzer.cc
 create mode 100644 contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_fuzzer.cc
 create mode 100644 contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_without_dequantization_fuzzer.cc
 create mode 100644 contrib/draco/src/draco/unity/draco_unity_plugin.cc
 create mode 100644 contrib/draco/src/draco/unity/draco_unity_plugin.h
 create mode 100644 contrib/draco/src/draco/unity/draco_unity_plugin_test.cc

diff --git a/contrib/draco/.clang-format b/contrib/draco/.clang-format
new file mode 100644
index 000000000..533d35e6d
--- /dev/null
+++ b/contrib/draco/.clang-format
@@ -0,0 +1,5 @@
+---
+Language:        Cpp
+BasedOnStyle: Google
+PointerAlignment: Right
+...
diff --git a/contrib/draco/.cmake-format.py b/contrib/draco/.cmake-format.py
new file mode 100644
index 000000000..64f2495b4
--- /dev/null
+++ b/contrib/draco/.cmake-format.py
@@ -0,0 +1,102 @@
+# Generated with cmake-format 0.5.1
+# How wide to allow formatted cmake files
+line_width = 80
+
+# How many spaces to tab for indent
+tab_size = 2
+
+# If arglists are longer than this, break them always
+max_subargs_per_line = 10
+
+# If true, separate flow control names from their parentheses with a space
+separate_ctrl_name_with_space = False
+
+# If true, separate function names from parentheses with a space
+separate_fn_name_with_space = False
+
+# If a statement is wrapped to more than one line, than dangle the closing
+# parenthesis on its own line
+dangle_parens = False
+
+# What character to use for bulleted lists
+bullet_char = '*'
+
+# What character to use as punctuation after numerals in an enumerated list
+enum_char = '.'
+
+# What style line endings to use in the output.
+line_ending = u'unix'
+
+# Format command names consistently as 'lower' or 'upper' case
+command_case = u'lower'
+
+# Format keywords consistently as 'lower' or 'upper' case
+keyword_case = u'unchanged'
+
+# Specify structure for custom cmake functions
+additional_commands = {
+  "foo": {
+    "flags": [
+      "BAR",
+      "BAZ"
+    ],
+    "kwargs": {
+      "HEADERS": "*",
+      "DEPENDS": "*",
+      "SOURCES": "*"
+    }
+  }
+}
+
+# A list of command names which should always be wrapped
+always_wrap = []
+
+# Specify the order of wrapping algorithms during successive reflow attempts
+algorithm_order = [0, 1, 2, 3, 4]
+
+# If true, the argument lists which are known to be sortable will be sorted
+# lexicographicall
+autosort = False
+
+# enable comment markup parsing and reflow
+enable_markup = True
+
+# If comment markup is enabled, don't reflow the first comment block in
+# eachlistfile. Use this to preserve formatting of your
+# copyright/licensestatements.
+first_comment_is_literal = False
+
+# If comment markup is enabled, don't reflow any comment block which matchesthis
+# (regex) pattern. Default is `None` (disabled).
+literal_comment_pattern = None
+
+# Regular expression to match preformat fences in comments
+# default=r'^\s*([`~]{3}[`~]*)(.*)$'
+fence_pattern = u'^\\s*([`~]{3}[`~]*)(.*)$'
+
+# Regular expression to match rulers in comments
+# default=r'^\s*[^\w\s]{3}.*[^\w\s]{3}$'
+ruler_pattern = u'^\\s*[^\\w\\s]{3}.*[^\\w\\s]{3}$'
+
+# If true, emit the unicode byte-order mark (BOM) at the start of the file
+emit_byteorder_mark = False
+
+# If a comment line starts with at least this many consecutive hash characters,
+# then don't lstrip() them off. This allows for lazy hash rulers where the first
+# hash char is not separated by space
+hashruler_min_length = 10
+
+# If true, then insert a space between the first hash char and remaining hash
+# chars in a hash ruler, and normalize its length to fill the column
+canonicalize_hashrulers = True
+
+# Specify the encoding of the input file. Defaults to utf-8.
+input_encoding = u'utf-8'
+
+# Specify the encoding of the output file. Defaults to utf-8. Note that cmake
+# only claims to support utf-8 so be careful when using anything else
+output_encoding = u'utf-8'
+
+# A dictionary containing any per-command configuration overrides. Currently
+# only `command_case` is supported.
+per_command = {}
diff --git a/contrib/draco/.gitignore b/contrib/draco/.gitignore
new file mode 100644
index 000000000..522866ee2
--- /dev/null
+++ b/contrib/draco/.gitignore
@@ -0,0 +1 @@
+docs/_site
diff --git a/contrib/draco/.ruby-version b/contrib/draco/.ruby-version
new file mode 100644
index 000000000..276cbf9e2
--- /dev/null
+++ b/contrib/draco/.ruby-version
@@ -0,0 +1 @@
+2.3.0
diff --git a/contrib/draco/.travis.yml b/contrib/draco/.travis.yml
new file mode 100644
index 000000000..e9ef7123f
--- /dev/null
+++ b/contrib/draco/.travis.yml
@@ -0,0 +1,31 @@
+cache: ccache
+language: cpp
+matrix:
+  include:
+    - os: linux
+      dist: xenial
+      compiler: clang
+    - os: linux
+      dist: xenial
+      compiler: gcc
+    - os: osx
+      compiler: clang
+
+addons:
+  apt:
+    packages:
+    - cmake
+
+script:
+  # Output version info for compilers, cmake, and make
+  - ${CC} -v
+  - ${CXX} -v
+  - cmake --version
+  - make --version
+  # Clone googletest
+  - pushd .. && git clone https://github.com/google/googletest.git && popd
+  # Configure and build
+  - mkdir _travis_build && cd _travis_build
+  - cmake -G "Unix Makefiles" -DENABLE_TESTS=ON ..
+  - make -j10
+  - ./draco_tests
diff --git a/contrib/draco/AUTHORS b/contrib/draco/AUTHORS
new file mode 100644
index 000000000..67f63a671
--- /dev/null
+++ b/contrib/draco/AUTHORS
@@ -0,0 +1,7 @@
+# This is the list of Draco authors for copyright purposes.
+#
+# This does not necessarily list everyone who has contributed code, since in
+# some cases, their employer may be the copyright holder.  To see the full list
+# of contributors, see the revision history in source control.
+Google Inc.
+and other contributors
diff --git a/contrib/draco/BUILDING.md b/contrib/draco/BUILDING.md
new file mode 100644
index 000000000..d33917b88
--- /dev/null
+++ b/contrib/draco/BUILDING.md
@@ -0,0 +1,301 @@
+_**Contents**_
+
+  * [CMake Basics](#cmake-basics)
+  * [Mac OS X](#mac-os-x)
+  * [Windows](#windows)
+  * [CMake Build Configuration](#cmake-build-configuration)
+    * [Debugging and Optimization](#debugging-and-optimization)
+    * [Googletest Integration](#googletest-integration)
+    * [Javascript Encoder/Decoder](#javascript-encoderdecoder)
+    * [WebAssembly Decoder](#webassembly-decoder)
+    * [WebAssembly Mesh Only Decoder](#webassembly-mesh-only-decoder)
+    * [WebAssembly Point Cloud Only Decoder](#webassembly-point-cloud-only-decoder)
+    * [iOS Builds](#ios-builds)
+  * [Android Studio Project Integration](#android-studio-project-integration)
+  * [Native Android Builds](#native-android-builds)
+  * [vcpkg](#vcpkg)
+
+Building
+========
+For all platforms, you must first generate the project/make files and then
+compile the examples.
+
+CMake Basics
+------------
+
+To generate project/make files for the default toolchain on your system, run
+`cmake` from a directory where you would like to generate build files, and pass
+it the path to your Draco repository.
+
+E.g. Starting from Draco root.
+
+~~~~~ bash
+$ mkdir build_dir && cd build_dir
+$ cmake ../
+~~~~~
+
+On Windows, the above command will produce Visual Studio project files for the
+newest Visual Studio detected on the system. On Mac OS X and Linux systems,
+the above command will produce a `makefile`.
+
+To control what types of projects are generated, add the `-G` parameter to the
+`cmake` command. This argument must be followed by the name of a generator.
+Running `cmake` with the `--help` argument will list the available
+generators for your system.
+
+Mac OS X
+---------
+
+On Mac OS X, run the following command to generate Xcode projects:
+
+~~~~~ bash
+$ cmake ../ -G Xcode
+~~~~~
+
+Windows
+-------
+
+On a Windows box you would run the following command to generate Visual Studio
+2019 projects:
+
+~~~~~ bash
+C:\Users\nobody> cmake ../ -G "Visual Studio 16 2019" -A Win32
+~~~~~
+
+To generate 64-bit Windows Visual Studio 2019 projects:
+
+~~~~~ bash
+C:\Users\nobody> cmake ../ -G "Visual Studio 16 2019" -A x64
+~~~~~
+
+
+CMake Build Configuration
+-------------------------
+
+Debugging and Optimization
+--------------------------
+
+Unlike Visual Studio and Xcode projects, the build configuration for make
+builds is controlled when you run `cmake`. The following examples demonstrate
+various build configurations.
+
+Omitting the build type produces makefiles that use release build flags
+by default:
+
+~~~~~ bash
+$ cmake ../
+~~~~~
+
+A makefile using release (optimized) flags is produced like this:
+
+~~~~~ bash
+$ cmake ../ -DCMAKE_BUILD_TYPE=Release
+~~~~~
+
+A release build with debug info can be produced as well:
+
+~~~~~ bash
+$ cmake ../ -DCMAKE_BUILD_TYPE=RelWithDebInfo
+~~~~~
+
+And your standard debug build will be produced using:
+
+~~~~~ bash
+$ cmake ../ -DCMAKE_BUILD_TYPE=Debug
+~~~~~
+
+To enable the use of sanitizers when the compiler in use supports them, set the
+sanitizer type when running CMake:
+
+~~~~~ bash
+$ cmake ../ -DDRACO_SANITIZE=address
+~~~~~
+
+Googletest Integration
+----------------------
+
+Draco includes testing support built using Googletest. To enable Googletest unit
+test support the DRACO_TESTS cmake variable must be turned on at cmake
+generation time:
+
+~~~~~ bash
+$ cmake ../ -DDRACO_TESTS=ON
+~~~~~
+
+When cmake is used as shown in the above example the googletest directory must
+be a sibling of the Draco repository root directory. To run the tests execute
+`draco_tests` from your build output directory.
+
+WebAssembly Decoder
+-------------------
+
+The WebAssembly decoder can be built using the existing cmake build file by
+passing the path the Emscripten's cmake toolchain file at cmake generation time
+in the CMAKE_TOOLCHAIN_FILE variable and enabling the WASM build option.
+In addition, the EMSCRIPTEN environment variable must be set to the local path
+of the parent directory of the Emscripten tools directory.
+
+~~~~~ bash
+# Make the path to emscripten available to cmake.
+$ export EMSCRIPTEN=/path/to/emscripten/tools/parent
+
+# Emscripten.cmake can be found within your Emscripten installation directory,
+# it should be the subdir: cmake/Modules/Platform/Emscripten.cmake
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=/path/to/Emscripten.cmake -DDRACO_WASM=ON
+
+# Build the WebAssembly decoder.
+$ make
+
+# Run the Javascript wrapper through Closure.
+$ java -jar closure.jar --compilation_level SIMPLE --js draco_decoder.js --js_output_file draco_wasm_wrapper.js
+
+~~~~~
+
+WebAssembly Mesh Only Decoder
+-----------------------------
+
+~~~~~ bash
+
+# cmake command line for mesh only WebAssembly decoder.
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=/path/to/Emscripten.cmake -DDRACO_WASM=ON -DDRACO_POINT_CLOUD_COMPRESSION=OFF
+
+~~~~~
+
+WebAssembly Point Cloud Only Decoder
+-----------------------------
+
+~~~~~ bash
+
+# cmake command line for point cloud only WebAssembly decoder.
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=/path/to/Emscripten.cmake -DDRACO_WASM=ON -DDRACO_MESH_COMPRESSION=OFF
+
+~~~~~
+
+Javascript Encoder/Decoder
+------------------
+
+The javascript encoder and decoder can be built using the existing cmake build
+file by passing the path the Emscripten's cmake toolchain file at cmake
+generation time in the CMAKE_TOOLCHAIN_FILE variable.
+In addition, the EMSCRIPTEN environment variable must be set to the local path
+of the parent directory of the Emscripten tools directory.
+
+*Note* The WebAssembly decoder should be favored over the JavaScript decoder.
+
+~~~~~ bash
+# Make the path to emscripten available to cmake.
+$ export EMSCRIPTEN=/path/to/emscripten/tools/parent
+
+# Emscripten.cmake can be found within your Emscripten installation directory,
+# it should be the subdir: cmake/Modules/Platform/Emscripten.cmake
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=/path/to/Emscripten.cmake
+
+# Build the Javascript encoder and decoder.
+$ make
+~~~~~
+
+iOS Builds
+---------------------
+These are the basic commands needed to build Draco for iOS targets.
+~~~~~ bash
+
+#arm64
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/arm64-ios.cmake
+$ make
+
+#x86_64
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/x86_64-ios.cmake
+$ make
+
+#armv7
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/armv7-ios.cmake
+$ make
+
+#i386
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/i386-ios.cmake
+$ make
+~~~~~~
+
+After building for each target the libraries can be merged into a single
+universal/fat library using lipo, and then used in iOS applications.
+
+
+Native Android Builds
+---------------------
+
+It's sometimes useful to build Draco command line tools and run them directly on
+Android devices via adb.
+
+~~~~~ bash
+# This example is for armeabi-v7a.
+$ cmake ../ -DCMAKE_TOOLCHAIN_FILE=../cmake/toolchains/android.cmake \
+  -DDRACO_ANDROID_NDK_PATH=path/to/ndk -DANDROID_ABI=armeabi-v7a
+$ make
+
+# See the android.cmake toolchain file for additional ANDROID_ABI options and
+# other configurable Android variables.
+~~~~~
+
+After building the tools they can be moved to an android device via the use of
+`adb push`, and then run within an `adb shell` instance.
+
+
+Android Studio Project Integration
+----------------------------------
+
+Tested on Android Studio 3.5.3.
+
+
+Draco - Static Library
+----------------------
+
+To include Draco in an existing or new Android Studio project, reference it
+from the `cmake` file of an existing native project that has a minimum SDK
+version of 18 or higher. The project must support C++11.
+To add Draco to your project:
+
+  1. Create a new "Native C++" project.
+
+  2. Add the following somewhere within the `CMakeLists.txt` for your project
+     before the `add_library()` for your project's native-lib:
+
+     ~~~~~ cmake
+     # Note "/path/to/draco" must be changed to the path where you have cloned
+     # the Draco sources.
+
+     add_subdirectory(/path/to/draco
+                      ${CMAKE_BINARY_DIR}/draco_build)
+     include_directories("${CMAKE_BINARY_DIR}" /path/to/draco)
+     ~~~~~
+
+  3. Add the library target "draco" to the `target_link_libraries()` call for
+     your project's native-lib. The `target_link_libraries()` call for an
+     empty activity native project looks like this after the addition of
+     Draco:
+
+     ~~~~~ cmake
+     target_link_libraries( # Specifies the target library.
+                            native-lib
+
+                            # Tells cmake this build depends on libdraco.
+                            draco
+
+                            # Links the target library to the log library
+                            # included in the NDK.
+                            ${log-lib} )
+
+vcpkg
+---------------------
+You can download and install Draco using the
+[vcpkg](https://github.com/Microsoft/vcpkg/) dependency manager:
+
+    git clone https://github.com/Microsoft/vcpkg.git
+    cd vcpkg
+    ./bootstrap-vcpkg.sh
+    ./vcpkg integrate install
+    vcpkg install draco
+
+The Draco port in vcpkg is kept up to date by Microsoft team members and
+community contributors. If the version is out of date, please
+[create an issue or pull request](https://github.com/Microsoft/vcpkg) on the
+vcpkg repository.
diff --git a/contrib/draco/CMAKE.md b/contrib/draco/CMAKE.md
new file mode 100644
index 000000000..392c6ce40
--- /dev/null
+++ b/contrib/draco/CMAKE.md
@@ -0,0 +1,106 @@
+# CMake Build System Overview
+
+[TOC]
+
+This document provides a general layout of the Draco CMake build system.
+
+## Core Build System Files
+
+These files are listed in order of interest to maintainers of the build system.
+
+-   `CMakeLists.txt` is the main driver of the build system. It's responsible
+    for defining targets and source lists, surfacing build system options, and
+    tying the components of the build system together.
+
+-   `cmake/draco_build_definitions.cmake` defines the macro
+    `draco_set_build_definitions()`, which is called from `CMakeLists.txt` to
+    configure include paths, compiler and linker flags, library settings,
+    platform speficic configuration, and other build system settings that
+    depend on optional build configurations.
+
+-   `cmake/draco_targets.cmake` defines the macros `draco_add_library()` and
+    `draco_add_executable()` which are used to create all targets in the CMake
+    build. These macros attempt to behave in a manner that loosely mirrors the
+    blaze `cc_library()` and `cc_binary()` commands. Note that
+    `draco_add_executable()` is also used for tests.
+
+-   `cmake/draco_emscripten.cmake` handles Emscripten SDK integration. It
+    defines several Emscripten specific macros that are required to build the
+    Emscripten specific targets defined in `CMakeLists.txt`.
+
+-   `cmake/draco_flags.cmake` defines macros related to compiler and linker
+    flags. Testing macros, macros for isolating flags to specific source files,
+    and the main flag configuration function for the library are defined here.
+
+-   `cmake/draco_options.cmake` defines macros that control optional features
+    of draco, and help track draco library and build system options.
+
+-   `cmake/draco_install.cmake` defines the draco install target.
+
+-   `cmake/draco_cpu_detection.cmake` determines the optimization types to
+    enable based on target system processor as reported by CMake.
+
+-   `cmake/draco_intrinsics.cmake` manages flags for source files that use
+    intrinsics. It handles detection of whether flags are necessary, and the
+    application of the flags to the sources that need them when they are
+    required.
+
+## Helper and Utility Files
+
+-   `.cmake-format.py` Defines coding style for cmake-format.
+
+-   `cmake/draco_helpers.cmake` defines utility macros.
+
+-   `cmake/draco_sanitizer.cmake` defines the `draco_configure_sanitizer()`
+    macro, which implements support for `DRACO_SANITIZE`. It handles the
+    compiler and linker flags necessary for using sanitizers like asan and msan.
+
+-   `cmake/draco_variables.cmake` defines macros for tracking and control of
+    draco build system variables.
+
+## Toolchain Files
+
+These files help facilitate cross compiling of draco for various targets.
+
+-   `cmake/toolchains/aarch64-linux-gnu.cmake` provides cross compilation
+    support for arm64 targets.
+
+-   `cmake/toolchains/android.cmake` provides cross compilation support for
+    Android targets.
+
+-   `cmake/toolchains/arm-linux-gnueabihf.cmake` provides cross compilation
+    support for armv7 targets.
+
+-   `cmake/toolchains/arm64-ios.cmake`, `cmake/toolchains/armv7-ios.cmake`,
+    and `cmake/toolchains/armv7s-ios.cmake` provide support for iOS.
+
+-   `cmake/toolchains/arm64-linux-gcc.cmake` and
+    `cmake/toolchains/armv7-linux-gcc.cmake` are deprecated, but remain for
+    compatibility. `cmake/toolchains/android.cmake` should be used instead.
+
+-   `cmake/toolchains/arm64-android-ndk-libcpp.cmake`,
+    `cmake/toolchains/armv7-android-ndk-libcpp.cmake`,
+    `cmake/toolchains/x86-android-ndk-libcpp.cmake`, and
+    `cmake/toolchains/x86_64-android-ndk-libcpp.cmake` are deprecated, but
+    remain for compatibility. `cmake/toolchains/android.cmake` should be used
+    instead.
+
+-   `cmake/toolchains/i386-ios.cmake` and `cmake/toolchains/x86_64-ios.cmake`
+    provide support for the iOS simulator.
+
+-   `cmake/toolchains/android-ndk-common.cmake` and
+    `cmake/toolchains/arm-ios-common.cmake` are support files used by other
+    toolchain files.
+
+## Template Files
+
+These files are inputs to the CMake build and are used to generate inputs to the
+build system output by CMake.
+
+-   `cmake/draco-config.cmake.template` is used to produce
+    draco-config.cmake. draco-config.cmake can be used by CMake to find draco
+    when another CMake project depends on draco.
+
+-   `cmake/draco.pc.template` is used to produce draco's pkg-config file.
+    Some build systems use pkg-config to configure include and library paths
+    when they depend upon third party libraries like draco.
diff --git a/contrib/draco/CMakeLists.txt b/contrib/draco/CMakeLists.txt
new file mode 100644
index 000000000..3da2c664a
--- /dev/null
+++ b/contrib/draco/CMakeLists.txt
@@ -0,0 +1,958 @@
+cmake_minimum_required(VERSION 3.12 FATAL_ERROR)
+
+# Draco requires C++11.
+set(CMAKE_CXX_STANDARD 11)
+project(draco C CXX)
+
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release)
+endif()
+
+set(draco_root "${CMAKE_CURRENT_SOURCE_DIR}")
+set(draco_src_root "${draco_root}/src/draco")
+set(draco_build "${CMAKE_BINARY_DIR}")
+
+if("${draco_root}" STREQUAL "${draco_build}")
+  message(
+    FATAL_ERROR "Building from within the Draco source tree is not supported.\n"
+                "Hint: Run these commands\n"
+                "$ rm -rf CMakeCache.txt CMakeFiles\n"
+                "$ mkdir -p ../draco_build\n" "$ cd ../draco_build\n"
+                "And re-run CMake from the draco_build directory.")
+endif()
+
+include(CMakePackageConfigHelpers)
+include(FindPythonInterp)
+include("${draco_root}/cmake/draco_build_definitions.cmake")
+include("${draco_root}/cmake/draco_cpu_detection.cmake")
+include("${draco_root}/cmake/draco_emscripten.cmake")
+include("${draco_root}/cmake/draco_flags.cmake")
+include("${draco_root}/cmake/draco_helpers.cmake")
+include("${draco_root}/cmake/draco_install.cmake")
+include("${draco_root}/cmake/draco_intrinsics.cmake")
+include("${draco_root}/cmake/draco_options.cmake")
+include("${draco_root}/cmake/draco_sanitizer.cmake")
+include("${draco_root}/cmake/draco_targets.cmake")
+include("${draco_root}/cmake/draco_tests.cmake")
+include("${draco_root}/cmake/draco_variables.cmake")
+
+# C++ and linker flags.
+draco_track_configuration_variable(DRACO_CXX_FLAGS)
+draco_track_configuration_variable(DRACO_EXE_LINKER_FLAGS)
+
+# Sanitizer integration.
+draco_track_configuration_variable(DRACO_SANITIZE)
+
+# Generated source file directory.
+draco_track_configuration_variable(DRACO_GENERATED_SOURCES_DIRECTORY)
+
+# Controls use of std::mutex and absl::Mutex in ThreadPool.
+draco_track_configuration_variable(DRACO_THREADPOOL_USE_STD_MUTEX)
+
+if(DRACO_VERBOSE)
+  draco_dump_cmake_flag_variables()
+  draco_dump_tracked_configuration_variables()
+  draco_dump_options()
+endif()
+
+# Compiler/linker flags must be lists, but come in from the environment as
+# strings. Break them up:
+if(NOT "${DRACO_CXX_FLAGS}" STREQUAL "")
+  separate_arguments(DRACO_CXX_FLAGS)
+endif()
+if(NOT "${DRACO_EXE_LINKER_FLAGS}" STREQUAL "")
+  separate_arguments(DRACO_EXE_LINKER_FLAGS)
+endif()
+
+draco_reset_target_lists()
+draco_setup_options()
+draco_set_build_definitions()
+draco_set_cxx_flags()
+draco_generate_features_h()
+
+# Draco source file listing variables.
+list(APPEND draco_attributes_sources
+            "${draco_src_root}/attributes/attribute_octahedron_transform.cc"
+            "${draco_src_root}/attributes/attribute_octahedron_transform.h"
+            "${draco_src_root}/attributes/attribute_quantization_transform.cc"
+            "${draco_src_root}/attributes/attribute_quantization_transform.h"
+            "${draco_src_root}/attributes/attribute_transform.cc"
+            "${draco_src_root}/attributes/attribute_transform.h"
+            "${draco_src_root}/attributes/attribute_transform_data.h"
+            "${draco_src_root}/attributes/attribute_transform_type.h"
+            "${draco_src_root}/attributes/geometry_attribute.cc"
+            "${draco_src_root}/attributes/geometry_attribute.h"
+            "${draco_src_root}/attributes/geometry_indices.h"
+            "${draco_src_root}/attributes/point_attribute.cc"
+            "${draco_src_root}/attributes/point_attribute.h")
+
+list(
+  APPEND
+    draco_compression_attributes_dec_sources
+    "${draco_src_root}/compression/attributes/attributes_decoder.cc"
+    "${draco_src_root}/compression/attributes/attributes_decoder.h"
+    "${draco_src_root}/compression/attributes/kd_tree_attributes_decoder.cc"
+    "${draco_src_root}/compression/attributes/kd_tree_attributes_decoder.h"
+    "${draco_src_root}/compression/attributes/kd_tree_attributes_shared.h"
+    "${draco_src_root}/compression/attributes/mesh_attribute_indices_encoding_data.h"
+    "${draco_src_root}/compression/attributes/normal_compression_utils.h"
+    "${draco_src_root}/compression/attributes/point_d_vector.h"
+    "${draco_src_root}/compression/attributes/sequential_attribute_decoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_attribute_decoder.h"
+    "${draco_src_root}/compression/attributes/sequential_attribute_decoders_controller.cc"
+    "${draco_src_root}/compression/attributes/sequential_attribute_decoders_controller.h"
+    "${draco_src_root}/compression/attributes/sequential_integer_attribute_decoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_integer_attribute_decoder.h"
+    "${draco_src_root}/compression/attributes/sequential_normal_attribute_decoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_normal_attribute_decoder.h"
+    "${draco_src_root}/compression/attributes/sequential_quantization_attribute_decoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_quantization_attribute_decoder.h"
+  )
+
+list(
+  APPEND
+    draco_compression_attributes_enc_sources
+    "${draco_src_root}/compression/attributes/attributes_encoder.cc"
+    "${draco_src_root}/compression/attributes/attributes_encoder.h"
+    "${draco_src_root}/compression/attributes/kd_tree_attributes_encoder.cc"
+    "${draco_src_root}/compression/attributes/kd_tree_attributes_encoder.h"
+    "${draco_src_root}/compression/attributes/linear_sequencer.h"
+    "${draco_src_root}/compression/attributes/points_sequencer.h"
+    "${draco_src_root}/compression/attributes/sequential_attribute_encoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_attribute_encoder.h"
+    "${draco_src_root}/compression/attributes/sequential_attribute_encoders_controller.cc"
+    "${draco_src_root}/compression/attributes/sequential_attribute_encoders_controller.h"
+    "${draco_src_root}/compression/attributes/sequential_integer_attribute_encoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_integer_attribute_encoder.h"
+    "${draco_src_root}/compression/attributes/sequential_normal_attribute_encoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_normal_attribute_encoder.h"
+    "${draco_src_root}/compression/attributes/sequential_quantization_attribute_encoder.cc"
+    "${draco_src_root}/compression/attributes/sequential_quantization_attribute_encoder.h"
+  )
+
+
+list(
+  APPEND
+    draco_compression_attributes_pred_schemes_dec_sources
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_factory.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h"
+  )
+
+list(
+  APPEND
+    draco_compression_attributes_pred_schemes_enc_sources
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.cc"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_factory.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h"
+  )
+
+list(
+  APPEND
+    draco_compression_bit_coders_sources
+    "${draco_src_root}/compression/bit_coders/adaptive_rans_bit_coding_shared.h"
+    "${draco_src_root}/compression/bit_coders/adaptive_rans_bit_decoder.cc"
+    "${draco_src_root}/compression/bit_coders/adaptive_rans_bit_decoder.h"
+    "${draco_src_root}/compression/bit_coders/adaptive_rans_bit_encoder.cc"
+    "${draco_src_root}/compression/bit_coders/adaptive_rans_bit_encoder.h"
+    "${draco_src_root}/compression/bit_coders/direct_bit_decoder.cc"
+    "${draco_src_root}/compression/bit_coders/direct_bit_decoder.h"
+    "${draco_src_root}/compression/bit_coders/direct_bit_encoder.cc"
+    "${draco_src_root}/compression/bit_coders/direct_bit_encoder.h"
+    "${draco_src_root}/compression/bit_coders/folded_integer_bit_decoder.h"
+    "${draco_src_root}/compression/bit_coders/folded_integer_bit_encoder.h"
+    "${draco_src_root}/compression/bit_coders/rans_bit_decoder.cc"
+    "${draco_src_root}/compression/bit_coders/rans_bit_decoder.h"
+    "${draco_src_root}/compression/bit_coders/rans_bit_encoder.cc"
+    "${draco_src_root}/compression/bit_coders/rans_bit_encoder.h"
+    "${draco_src_root}/compression/bit_coders/symbol_bit_decoder.cc"
+    "${draco_src_root}/compression/bit_coders/symbol_bit_decoder.h"
+    "${draco_src_root}/compression/bit_coders/symbol_bit_encoder.cc"
+    "${draco_src_root}/compression/bit_coders/symbol_bit_encoder.h")
+
+list(APPEND draco_enc_config_sources
+            "${draco_src_root}/compression/config/compression_shared.h"
+            "${draco_src_root}/compression/config/draco_options.h"
+            "${draco_src_root}/compression/config/encoder_options.h"
+            "${draco_src_root}/compression/config/encoding_features.h")
+
+list(APPEND draco_dec_config_sources
+            "${draco_src_root}/compression/config/compression_shared.h"
+            "${draco_src_root}/compression/config/decoder_options.h"
+            "${draco_src_root}/compression/config/draco_options.h")
+
+list(APPEND draco_compression_decode_sources
+            "${draco_src_root}/compression/decode.cc"
+            "${draco_src_root}/compression/decode.h")
+
+list(APPEND draco_compression_encode_sources
+            "${draco_src_root}/compression/encode.cc"
+            "${draco_src_root}/compression/encode.h"
+            "${draco_src_root}/compression/encode_base.h"
+            "${draco_src_root}/compression/expert_encode.cc"
+            "${draco_src_root}/compression/expert_encode.h")
+
+list(
+  APPEND
+    draco_compression_mesh_traverser_sources
+    "${draco_src_root}/compression/mesh/traverser/depth_first_traverser.h"
+    "${draco_src_root}/compression/mesh/traverser/max_prediction_degree_traverser.h"
+    "${draco_src_root}/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h"
+    "${draco_src_root}/compression/mesh/traverser/mesh_traversal_sequencer.h"
+    "${draco_src_root}/compression/mesh/traverser/traverser_base.h")
+
+list(
+  APPEND
+    draco_compression_mesh_dec_sources
+    "${draco_src_root}/compression/mesh/mesh_decoder.cc"
+    "${draco_src_root}/compression/mesh/mesh_decoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_decoder.cc"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_decoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_decoder_impl.cc"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_decoder_impl.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_shared.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_traversal_decoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h"
+    "${draco_src_root}/compression/mesh/mesh_sequential_decoder.cc"
+    "${draco_src_root}/compression/mesh/mesh_sequential_decoder.h")
+
+list(
+  APPEND
+    draco_compression_mesh_enc_sources
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_encoder.cc"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_encoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_encoder_impl.cc"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_encoder_impl.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_shared.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_traversal_encoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h"
+    "${draco_src_root}/compression/mesh/mesh_encoder.cc"
+    "${draco_src_root}/compression/mesh/mesh_encoder.h"
+    "${draco_src_root}/compression/mesh/mesh_sequential_encoder.cc"
+    "${draco_src_root}/compression/mesh/mesh_sequential_encoder.h")
+
+list(
+  APPEND
+    draco_compression_point_cloud_dec_sources
+    "${draco_src_root}/compression/point_cloud/point_cloud_decoder.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_decoder.h"
+    "${draco_src_root}/compression/point_cloud/point_cloud_kd_tree_decoder.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_kd_tree_decoder.h"
+    "${draco_src_root}/compression/point_cloud/point_cloud_sequential_decoder.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_sequential_decoder.h"
+  )
+
+list(
+  APPEND
+    draco_compression_point_cloud_enc_sources
+    "${draco_src_root}/compression/point_cloud/point_cloud_encoder.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_encoder.h"
+    "${draco_src_root}/compression/point_cloud/point_cloud_kd_tree_encoder.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_kd_tree_encoder.h"
+    "${draco_src_root}/compression/point_cloud/point_cloud_sequential_encoder.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_sequential_encoder.h"
+  )
+
+list(APPEND draco_compression_entropy_sources
+            "${draco_src_root}/compression/entropy/ans.h"
+            "${draco_src_root}/compression/entropy/rans_symbol_coding.h"
+            "${draco_src_root}/compression/entropy/rans_symbol_decoder.h"
+            "${draco_src_root}/compression/entropy/rans_symbol_encoder.h"
+            "${draco_src_root}/compression/entropy/shannon_entropy.cc"
+            "${draco_src_root}/compression/entropy/shannon_entropy.h"
+            "${draco_src_root}/compression/entropy/symbol_decoding.cc"
+            "${draco_src_root}/compression/entropy/symbol_decoding.h"
+            "${draco_src_root}/compression/entropy/symbol_encoding.cc"
+            "${draco_src_root}/compression/entropy/symbol_encoding.h")
+
+list(APPEND draco_core_sources
+            "${draco_src_root}/core/bit_utils.cc"
+            "${draco_src_root}/core/bit_utils.h"
+            "${draco_src_root}/core/bounding_box.cc"
+            "${draco_src_root}/core/bounding_box.h"
+            "${draco_src_root}/core/cycle_timer.cc"
+            "${draco_src_root}/core/cycle_timer.h"
+            "${draco_src_root}/core/data_buffer.cc"
+            "${draco_src_root}/core/data_buffer.h"
+            "${draco_src_root}/core/decoder_buffer.cc"
+            "${draco_src_root}/core/decoder_buffer.h"
+            "${draco_src_root}/core/divide.cc"
+            "${draco_src_root}/core/divide.h"
+            "${draco_src_root}/core/draco_index_type.h"
+            "${draco_src_root}/core/draco_index_type_vector.h"
+            "${draco_src_root}/core/draco_types.cc"
+            "${draco_src_root}/core/draco_types.h"
+            "${draco_src_root}/core/encoder_buffer.cc"
+            "${draco_src_root}/core/encoder_buffer.h"
+            "${draco_src_root}/core/hash_utils.cc"
+            "${draco_src_root}/core/hash_utils.h"
+            "${draco_src_root}/core/macros.h"
+            "${draco_src_root}/core/math_utils.h"
+            "${draco_src_root}/core/options.cc"
+            "${draco_src_root}/core/options.h"
+            "${draco_src_root}/core/quantization_utils.cc"
+            "${draco_src_root}/core/quantization_utils.h"
+            "${draco_src_root}/core/status.h"
+            "${draco_src_root}/core/status_or.h"
+            "${draco_src_root}/core/varint_decoding.h"
+            "${draco_src_root}/core/varint_encoding.h"
+            "${draco_src_root}/core/vector_d.h")
+
+list(APPEND draco_io_sources
+            "${draco_src_root}/io/file_reader_factory.cc"
+            "${draco_src_root}/io/file_reader_factory.h"
+            "${draco_src_root}/io/file_reader_interface.h"
+            "${draco_src_root}/io/file_utils.cc"
+            "${draco_src_root}/io/file_utils.h"
+            "${draco_src_root}/io/file_writer_factory.cc"
+            "${draco_src_root}/io/file_writer_factory.h"
+            "${draco_src_root}/io/file_writer_interface.h"
+            "${draco_src_root}/io/file_writer_utils.h"
+            "${draco_src_root}/io/file_writer_utils.cc"
+            "${draco_src_root}/io/mesh_io.cc"
+            "${draco_src_root}/io/mesh_io.h"
+            "${draco_src_root}/io/obj_decoder.cc"
+            "${draco_src_root}/io/obj_decoder.h"
+            "${draco_src_root}/io/obj_encoder.cc"
+            "${draco_src_root}/io/obj_encoder.h"
+            "${draco_src_root}/io/parser_utils.cc"
+            "${draco_src_root}/io/parser_utils.h"
+            "${draco_src_root}/io/ply_decoder.cc"
+            "${draco_src_root}/io/ply_decoder.h"
+            "${draco_src_root}/io/ply_encoder.cc"
+            "${draco_src_root}/io/ply_encoder.h"
+            "${draco_src_root}/io/ply_property_reader.h"
+            "${draco_src_root}/io/ply_property_writer.h"
+            "${draco_src_root}/io/ply_reader.cc"
+            "${draco_src_root}/io/ply_reader.h"
+            "${draco_src_root}/io/point_cloud_io.cc"
+            "${draco_src_root}/io/point_cloud_io.h"
+            "${draco_src_root}/io/stdio_file_reader.cc"
+            "${draco_src_root}/io/stdio_file_reader.h"
+            "${draco_src_root}/io/stdio_file_writer.cc"
+            "${draco_src_root}/io/stdio_file_writer.h")
+
+list(APPEND draco_mesh_sources
+            "${draco_src_root}/mesh/corner_table.cc"
+            "${draco_src_root}/mesh/corner_table.h"
+            "${draco_src_root}/mesh/corner_table_iterators.h"
+            "${draco_src_root}/mesh/mesh.cc"
+            "${draco_src_root}/mesh/mesh.h"
+            "${draco_src_root}/mesh/mesh_are_equivalent.cc"
+            "${draco_src_root}/mesh/mesh_are_equivalent.h"
+            "${draco_src_root}/mesh/mesh_attribute_corner_table.cc"
+            "${draco_src_root}/mesh/mesh_attribute_corner_table.h"
+            "${draco_src_root}/mesh/mesh_cleanup.cc"
+            "${draco_src_root}/mesh/mesh_cleanup.h"
+            "${draco_src_root}/mesh/mesh_misc_functions.cc"
+            "${draco_src_root}/mesh/mesh_misc_functions.h"
+            "${draco_src_root}/mesh/mesh_stripifier.cc"
+            "${draco_src_root}/mesh/mesh_stripifier.h"
+            "${draco_src_root}/mesh/triangle_soup_mesh_builder.cc"
+            "${draco_src_root}/mesh/triangle_soup_mesh_builder.h"
+            "${draco_src_root}/mesh/valence_cache.h")
+
+list(APPEND draco_point_cloud_sources
+            "${draco_src_root}/point_cloud/point_cloud.cc"
+            "${draco_src_root}/point_cloud/point_cloud.h"
+            "${draco_src_root}/point_cloud/point_cloud_builder.cc"
+            "${draco_src_root}/point_cloud/point_cloud_builder.h")
+
+list(
+  APPEND
+    draco_points_common_sources
+    "${draco_src_root}/compression/point_cloud/algorithms/point_cloud_compression_method.h"
+    "${draco_src_root}/compression/point_cloud/algorithms/point_cloud_types.h"
+    "${draco_src_root}/compression/point_cloud/algorithms/quantize_points_3.h"
+    "${draco_src_root}/compression/point_cloud/algorithms/queuing_policy.h")
+
+list(
+  APPEND
+    draco_points_dec_sources
+    "${draco_src_root}/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.cc"
+    "${draco_src_root}/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h"
+    "${draco_src_root}/compression/point_cloud/algorithms/float_points_tree_decoder.cc"
+    "${draco_src_root}/compression/point_cloud/algorithms/float_points_tree_decoder.h"
+  )
+
+list(
+  APPEND
+    draco_points_enc_sources
+    "${draco_src_root}/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.cc"
+    "${draco_src_root}/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h"
+    "${draco_src_root}/compression/point_cloud/algorithms/float_points_tree_encoder.cc"
+    "${draco_src_root}/compression/point_cloud/algorithms/float_points_tree_encoder.h"
+  )
+
+list(APPEND draco_metadata_sources
+            "${draco_src_root}/metadata/geometry_metadata.cc"
+            "${draco_src_root}/metadata/geometry_metadata.h"
+            "${draco_src_root}/metadata/metadata.cc"
+            "${draco_src_root}/metadata/metadata.h")
+
+list(APPEND draco_metadata_enc_sources
+            "${draco_src_root}/metadata/metadata_encoder.cc"
+            "${draco_src_root}/metadata/metadata_encoder.h")
+
+list(APPEND draco_metadata_dec_sources
+            "${draco_src_root}/metadata/metadata_decoder.cc"
+            "${draco_src_root}/metadata/metadata_decoder.h")
+
+list(APPEND draco_animation_sources
+            "${draco_src_root}/animation/keyframe_animation.cc"
+            "${draco_src_root}/animation/keyframe_animation.h")
+
+list(APPEND draco_animation_enc_sources
+            "${draco_src_root}/animation/keyframe_animation_encoder.cc"
+            "${draco_src_root}/animation/keyframe_animation_encoder.h")
+
+list(APPEND draco_animation_dec_sources
+            "${draco_src_root}/animation/keyframe_animation_decoder.cc"
+            "${draco_src_root}/animation/keyframe_animation_decoder.h")
+
+list(
+  APPEND draco_js_dec_sources
+         "${draco_src_root}/javascript/emscripten/decoder_webidl_wrapper.cc"
+         "${draco_src_root}/javascript/emscripten/draco_decoder_glue_wrapper.cc"
+  )
+
+list(
+  APPEND draco_js_enc_sources
+         "${draco_src_root}/javascript/emscripten/draco_encoder_glue_wrapper.cc"
+         "${draco_src_root}/javascript/emscripten/encoder_webidl_wrapper.cc")
+
+list(
+  APPEND
+    draco_animation_js_dec_sources
+    "${draco_src_root}/javascript/emscripten/animation_decoder_webidl_wrapper.cc"
+    "${draco_src_root}/javascript/emscripten/draco_animation_decoder_glue_wrapper.cc"
+  )
+
+list(
+  APPEND
+    draco_animation_js_enc_sources
+    "${draco_src_root}/javascript/emscripten/animation_encoder_webidl_wrapper.cc"
+    "${draco_src_root}/javascript/emscripten/draco_animation_encoder_glue_wrapper.cc"
+  )
+
+list(APPEND draco_unity_plug_sources
+            "${draco_src_root}/unity/draco_unity_plugin.cc"
+            "${draco_src_root}/unity/draco_unity_plugin.h")
+
+list(APPEND draco_maya_plug_sources
+            "${draco_src_root}/maya/draco_maya_plugin.cc"
+            "${draco_src_root}/maya/draco_maya_plugin.h")
+
+#
+# Draco targets.
+#
+if(EMSCRIPTEN AND DRACO_JS_GLUE)
+  # Draco decoder and encoder "executable" targets in various flavors for
+  # Emsscripten.
+  list(APPEND draco_decoder_src
+              ${draco_attributes_sources}
+              ${draco_compression_attributes_dec_sources}
+              ${draco_compression_attributes_pred_schemes_dec_sources}
+              ${draco_compression_bit_coders_sources}
+              ${draco_compression_decode_sources}
+              ${draco_compression_entropy_sources}
+              ${draco_compression_mesh_traverser_sources}
+              ${draco_compression_mesh_dec_sources}
+              ${draco_compression_point_cloud_dec_sources}
+              ${draco_core_sources}
+              ${draco_dec_config_sources}
+              ${draco_js_dec_sources}
+              ${draco_mesh_sources}
+              ${draco_metadata_dec_sources}
+              ${draco_metadata_sources}
+              ${draco_point_cloud_sources}
+              ${draco_points_dec_sources})
+
+  list(APPEND draco_encoder_src
+              ${draco_attributes_sources}
+              ${draco_compression_attributes_enc_sources}
+              ${draco_compression_attributes_pred_schemes_enc_sources}
+              ${draco_compression_bit_coders_sources}
+              ${draco_compression_encode_sources}
+              ${draco_compression_entropy_sources}
+              ${draco_compression_mesh_traverser_sources}
+              ${draco_compression_mesh_enc_sources}
+              ${draco_compression_point_cloud_enc_sources}
+              ${draco_core_sources}
+              ${draco_enc_config_sources}
+              ${draco_js_enc_sources}
+              ${draco_mesh_sources}
+              ${draco_metadata_enc_sources}
+              ${draco_metadata_sources}
+              ${draco_point_cloud_sources}
+              ${draco_points_enc_sources})
+
+  list(APPEND draco_js_dec_idl
+              "${draco_src_root}/javascript/emscripten/draco_web_decoder.idl")
+  list(APPEND draco_js_enc_idl
+              "${draco_src_root}/javascript/emscripten/draco_web_encoder.idl")
+  list(
+    APPEND
+      draco_animation_js_dec_idl
+      "${draco_src_root}/javascript/emscripten/draco_animation_web_decoder.idl")
+  list(
+    APPEND
+      draco_animation_js_enc_idl
+      "${draco_src_root}/javascript/emscripten/draco_animation_web_encoder.idl")
+  list(APPEND draco_pre_link_js_sources
+              "${draco_src_root}/javascript/emscripten/prepareCallbacks.js"
+              "${draco_src_root}/javascript/emscripten/version.js")
+  list(APPEND draco_post_link_js_sources
+              "${draco_src_root}/javascript/emscripten/finalize.js")
+  list(APPEND draco_post_link_js_decoder_sources ${draco_post_link_js_sources}
+              "${draco_src_root}/javascript/emscripten/decoder_functions.js")
+
+  set(draco_decoder_glue_path "${draco_build}/glue_decoder")
+  set(draco_encoder_glue_path "${draco_build}/glue_encoder")
+
+  draco_generate_emscripten_glue(INPUT_IDL ${draco_js_dec_idl} OUTPUT_PATH
+                                 ${draco_decoder_glue_path})
+  draco_generate_emscripten_glue(INPUT_IDL ${draco_js_enc_idl} OUTPUT_PATH
+                                 ${draco_encoder_glue_path})
+
+  if(DRACO_DECODER_ATTRIBUTE_DEDUPLICATION)
+    list(APPEND draco_decoder_features
+                "DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED"
+                "DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED")
+  endif()
+
+  draco_add_emscripten_executable(NAME
+                                  draco_decoder
+                                  SOURCES
+                                  ${draco_decoder_src}
+                                  DEFINES
+                                  ${draco_defines}
+                                  FEATURES
+                                  ${draco_decoder_features}
+                                  INCLUDES
+                                  ${draco_include_paths}
+                                  LINK_FLAGS
+                                  "-sEXPORT_NAME=\"DracoDecoderModule\""
+                                  GLUE_PATH
+                                  ${draco_decoder_glue_path}
+                                  PRE_LINK_JS_SOURCES
+                                  ${draco_pre_link_js_sources}
+                                  POST_LINK_JS_SOURCES
+                                  ${draco_post_link_js_decoder_sources})
+
+  draco_add_emscripten_executable(
+    NAME
+    draco_encoder
+    SOURCES
+    ${draco_encoder_src}
+    DEFINES
+    ${draco_defines}
+    FEATURES
+    DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+    DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+    INCLUDES
+    ${draco_include_paths}
+    LINK_FLAGS
+    "-sEXPORT_NAME=\"DracoEncoderModule\""
+    GLUE_PATH
+    ${draco_encoder_glue_path}
+    PRE_LINK_JS_SOURCES
+    ${draco_pre_link_js_sources}
+    POST_LINK_JS_SOURCES
+    ${draco_post_link_js_sources})
+
+  if(DRACO_ANIMATION_ENCODING)
+    set(draco_anim_decoder_glue_path "${draco_build}/glue_animation_decoder")
+    set(draco_anim_encoder_glue_path "${draco_build}/glue_animation_encoder")
+
+    draco_generate_emscripten_glue(INPUT_IDL ${draco_animation_js_dec_idl}
+                                   OUTPUT_PATH ${draco_anim_decoder_glue_path})
+    draco_generate_emscripten_glue(INPUT_IDL ${draco_animation_js_enc_idl}
+                                   OUTPUT_PATH ${draco_anim_encoder_glue_path})
+
+    draco_add_emscripten_executable(
+      NAME
+      draco_animation_decoder
+      SOURCES
+      ${draco_animation_dec_sources}
+      ${draco_animation_js_dec_sources}
+      ${draco_animation_sources}
+      ${draco_decoder_src}
+      DEFINES
+      ${draco_defines}
+      INCLUDES
+      ${draco_include_paths}
+      LINK_FLAGS
+      "-sEXPORT_NAME=\"DracoAnimationDecoderModule\""
+      GLUE_PATH
+      ${draco_anim_decoder_glue_path}
+      PRE_LINK_JS_SOURCES
+      ${draco_pre_link_js_sources}
+      POST_LINK_JS_SOURCES
+      ${draco_post_link_js_decoder_sources})
+
+    draco_add_emscripten_executable(
+      NAME
+      draco_animation_encoder
+      SOURCES
+      ${draco_animation_enc_sources}
+      ${draco_animation_js_enc_sources}
+      ${draco_animation_sources}
+      ${draco_encoder_src}
+      DEFINES
+      ${draco_defines}
+      INCLUDES
+      ${draco_include_paths}
+      LINK_FLAGS
+      "-sEXPORT_NAME=\"DracoAnimationEncoderModule\""
+      GLUE_PATH
+      ${draco_anim_encoder_glue_path}
+      PRE_LINK_JS_SOURCES
+      ${draco_pre_link_js_sources}
+      POST_LINK_JS_SOURCES
+      ${draco_post_link_js_sources})
+  endif()
+else()
+  # Standard Draco libs, encoder and decoder. Object collections that mirror the
+  # Draco directory structure.
+  draco_add_library(NAME draco_attributes TYPE OBJECT SOURCES
+                    ${draco_attributes_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME
+                    draco_compression_attributes_dec
+                    OBJECT
+                    ${draco_compression_attributes_dec_sources}
+                    TYPE
+                    OBJECT
+                    SOURCES
+                    ${draco_compression_attributes_dec_sources}
+                    DEFINES
+                    ${draco_defines}
+                    INCLUDES
+                    ${draco_include_paths})
+  draco_add_library(NAME draco_compression_attributes_enc TYPE OBJECT SOURCES
+                    ${draco_compression_attributes_enc_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_attributes_pred_schemes_dec TYPE
+                    OBJECT SOURCES
+                    ${draco_compression_attributes_pred_schemes_dec_sources})
+  draco_add_library(NAME draco_compression_attributes_pred_schemes_enc TYPE
+                    OBJECT SOURCES
+                    ${draco_compression_attributes_pred_schemes_enc_sources}
+                    DEFINES ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_bit_coders TYPE OBJECT SOURCES
+                    ${draco_compression_bit_coders_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_enc_config TYPE OBJECT SOURCES
+                    ${draco_enc_config_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_dec_config TYPE OBJECT SOURCES
+                    ${draco_dec_config_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_decode TYPE OBJECT SOURCES
+                    ${draco_compression_decode_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_encode TYPE OBJECT SOURCES
+                    ${draco_compression_encode_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_entropy TYPE OBJECT SOURCES
+                    ${draco_compression_entropy_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_mesh_traverser TYPE OBJECT SOURCES
+                    ${draco_compression_mesh_traverser_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_mesh_dec TYPE OBJECT SOURCES
+                    ${draco_compression_mesh_dec_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_mesh_enc TYPE OBJECT SOURCES
+                    ${draco_compression_mesh_enc_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_point_cloud_dec TYPE OBJECT SOURCES
+                    ${draco_compression_point_cloud_dec_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_compression_point_cloud_enc TYPE OBJECT SOURCES
+                    ${draco_compression_point_cloud_enc_sources} DEFINES
+                    ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_core TYPE OBJECT SOURCES ${draco_core_sources}
+                    DEFINES ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_io TYPE OBJECT SOURCES ${draco_io_sources}
+                    DEFINES ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_mesh TYPE OBJECT SOURCES ${draco_mesh_sources}
+                    DEFINES ${draco_defines} INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_metadata_dec TYPE OBJECT SOURCES
+                    ${draco_metadata_dec_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_metadata_enc TYPE OBJECT SOURCES
+                    ${draco_metadata_enc_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_metadata TYPE OBJECT SOURCES
+                    ${draco_metadata_sources} DEFINES ${draco_defines} INCLUDES
+                    ${draco_include_paths})
+  draco_add_library(NAME draco_animation_dec TYPE OBJECT SOURCES
+                    ${draco_animation_dec_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_animation_enc TYPE OBJECT SOURCES
+                    ${draco_animation_enc_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME draco_animation TYPE OBJECT SOURCES
+                    ${draco_animation_sources} DEFINES ${draco_defines} INCLUDES
+                    ${draco_include_paths})
+  draco_add_library(NAME draco_point_cloud TYPE OBJECT SOURCES
+                    ${draco_point_cloud_sources} DEFINES ${draco_defines}
+                    INCLUDES ${draco_include_paths})
+  draco_add_library(NAME
+                    draco_points_dec
+                    TYPE
+                    OBJECT
+                    SOURCES
+                    ${draco_points_common_sources}
+                    ${draco_points_dec_sources}
+                    DEFINES
+                    ${draco_defines}
+                    INCLUDES
+                    ${draco_include_paths})
+  draco_add_library(NAME
+                    draco_points_enc
+                    TYPE
+                    OBJECT
+                    SOURCES
+                    ${draco_points_common_sources}
+                    ${draco_points_enc_sources}
+                    DEFINES
+                    ${draco_defines}
+                    INCLUDES
+                    ${draco_include_paths})
+
+  set(draco_object_library_deps
+      draco_attributes
+      draco_compression_attributes_dec
+      draco_compression_attributes_enc
+      draco_compression_attributes_pred_schemes_dec
+      draco_compression_attributes_pred_schemes_enc
+      draco_compression_bit_coders
+      draco_compression_decode
+      draco_compression_encode
+      draco_compression_entropy
+      draco_compression_mesh_dec
+      draco_compression_mesh_enc
+      draco_compression_point_cloud_dec
+      draco_compression_point_cloud_enc
+      draco_core
+      draco_dec_config
+      draco_enc_config
+      draco_io
+      draco_mesh
+      draco_metadata
+      draco_metadata_dec
+      draco_metadata_enc
+      draco_animation
+      draco_animation_dec
+      draco_animation_enc
+      draco_point_cloud
+      draco_points_dec
+      draco_points_enc)
+
+  # Library targets that consume the object collections.
+  if(MSVC OR WIN32)
+    # In order to produce a DLL and import library the Windows tools require
+    # that the exported symbols are part of the DLL target. The unfortunate side
+    # effect of this is that a single configuration cannot output both the
+    # static library and the DLL: This results in an either/or situation.
+    # Windows users of the draco build can have a DLL and an import library,
+    # or they can have a static library; they cannot have both from a single
+    # configuration of the build.
+    if(BUILD_SHARED_LIBS)
+      set(draco_lib_type SHARED)
+    else()
+      set(draco_lib_type STATIC)
+    endif()
+    draco_add_library(NAME
+                      draco
+                      OUTPUT_NAME
+                      draco
+                      TYPE
+                      ${draco_lib_type}
+                      DEFINES
+                      ${draco_defines}
+                      INCLUDES
+                      ${draco_include_paths}
+                      OBJLIB_DEPS
+                      ${draco_object_library_deps})
+
+  else()
+    draco_add_library(NAME
+                      draco_static
+                      OUTPUT_NAME
+                      draco
+                      TYPE
+                      STATIC
+                      DEFINES
+                      ${draco_defines}
+                      INCLUDES
+                      ${draco_include_paths}
+                      OBJLIB_DEPS
+                      ${draco_object_library_deps})
+
+    if(BUILD_SHARED_LIBS)
+      draco_add_library(NAME
+                        draco_shared
+                        SOURCES
+                        "${draco_src_root}/core/draco_version.h"
+                        OUTPUT_NAME
+                        draco
+                        TYPE
+                        SHARED
+                        DEFINES
+                        ${draco_defines}
+                        INCLUDES
+                        ${draco_include_paths}
+                        LIB_DEPS
+                        draco_static)
+    endif()
+  endif()
+
+  if(DRACO_UNITY_PLUGIN)
+    if(IOS)
+      set(unity_decoder_lib_type STATIC)
+    else()
+      set(unity_decoder_lib_type MODULE)
+    endif()
+
+    draco_add_library(NAME draco_unity_plugin TYPE OBJECT SOURCES
+                      ${draco_unity_plug_sources} DEFINES ${draco_defines}
+                      INCLUDES ${draco_include_paths})
+
+    draco_add_library(NAME
+                      dracodec_unity
+                      TYPE
+                      ${unity_decoder_lib_type}
+                      DEFINES
+                      ${draco_defines}
+                      INCLUDES
+                      ${draco_include_paths}
+                      OBJLIB_DEPS
+                      draco_unity_plugin
+                      LIB_DEPS
+                      ${draco_plugin_dependency})
+
+    # For Mac, we need to build a .bundle for the unity plugin.
+    if(APPLE)
+      set_target_properties(dracodec_unity PROPERTIES BUNDLE true)
+    elseif(NOT unity_decoder_lib_type STREQUAL STATIC)
+      set_target_properties(dracodec_unity
+                            PROPERTIES SOVERSION ${DRACO_SOVERSION})
+    endif()
+  endif()
+
+  if(DRACO_MAYA_PLUGIN)
+    draco_add_library(NAME draco_maya_plugin TYPE OBJECT SOURCES
+                      ${draco_maya_plug_sources} DEFINES ${draco_defines}
+                      INCLUDES ${draco_include_paths})
+
+    draco_add_library(NAME
+                      draco_maya_wrapper
+                      TYPE
+                      MODULE
+                      DEFINES
+                      ${draco_defines}
+                      INCLUDES
+                      ${draco_include_paths}
+                      OBJLIB_DEPS
+                      draco_maya_plugin
+                      LIB_DEPS
+                      ${draco_plugin_dependency})
+
+    # For Mac, we need to build a .bundle for the plugin.
+    if(APPLE)
+      set_target_properties(draco_maya_wrapper PROPERTIES BUNDLE true)
+    else()
+      set_target_properties(draco_maya_wrapper
+                            PROPERTIES SOVERSION ${DRACO_SOVERSION})
+    endif()
+  endif()
+
+  # Draco app targets.
+  draco_add_executable(NAME
+                       draco_decoder
+                       SOURCES
+                       "${draco_src_root}/tools/draco_decoder.cc"
+                       ${draco_io_sources}
+                       DEFINES
+                       ${draco_defines}
+                       INCLUDES
+                       ${draco_include_paths}
+                       LIB_DEPS
+                       ${draco_dependency})
+
+  draco_add_executable(NAME
+                       draco_encoder
+                       SOURCES
+                       "${draco_src_root}/tools/draco_encoder.cc"
+                       ${draco_io_sources}
+                       DEFINES
+                       ${draco_defines}
+                       INCLUDES
+                       ${draco_include_paths}
+                       LIB_DEPS
+                       ${draco_dependency})
+
+  draco_setup_install_target()
+  draco_setup_test_targets()
+endif()
+
+if(DRACO_VERBOSE)
+  draco_dump_cmake_flag_variables()
+  draco_dump_tracked_configuration_variables()
+  draco_dump_options()
+endif()
diff --git a/contrib/draco/CONTRIBUTING.md b/contrib/draco/CONTRIBUTING.md
new file mode 100644
index 000000000..b7bab3447
--- /dev/null
+++ b/contrib/draco/CONTRIBUTING.md
@@ -0,0 +1,27 @@
+Want to contribute? Great! First, read this page (including the small print at the end).
+
+### Before you contribute
+Before we can use your code, you must sign the
+[Google Individual Contributor License Agreement](https://cla.developers.google.com/about/google-individual)
+(CLA), which you can do online. The CLA is necessary mainly because you own the
+copyright to your changes, even after your contribution becomes part of our
+codebase, so we need your permission to use and distribute your code. We also
+need to be sure of various other things—for instance that you'll tell us if you
+know that your code infringes on other people's patents. You don't have to sign
+the CLA until after you've submitted your code for review and a member has
+approved it, but you must do it before we can put your code into our codebase.
+Before you start working on a larger contribution, you should get in touch with
+us first through the issue tracker with your idea so that we can help out and
+possibly guide you. Coordinating up front makes it much easier to avoid
+frustration later on.
+
+### Code reviews
+All submissions, including submissions by project members, require review. We
+use GitHub pull requests for this purpose.
+Please make sure that your code conforms with our
+[coding style guidelines](https://google.github.io/styleguide/cppguide.html).
+
+### The small print
+Contributions made by corporations are covered by a different agreement than
+the one above, the
+[Software Grant and Corporate Contributor License Agreement](https://cla.developers.google.com/about/google-corporate).
diff --git a/contrib/draco/LICENSE b/contrib/draco/LICENSE
new file mode 100644
index 000000000..301095454
--- /dev/null
+++ b/contrib/draco/LICENSE
@@ -0,0 +1,252 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
+--------------------------------------------------------------------------------
+Files: docs/assets/js/ASCIIMathML.js
+
+Copyright (c) 2014 Peter Jipsen and other ASCIIMathML.js contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+--------------------------------------------------------------------------------
+Files: docs/assets/css/pygments/*
+
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org>
diff --git a/contrib/draco/README.md b/contrib/draco/README.md
new file mode 100644
index 000000000..add66edcb
--- /dev/null
+++ b/contrib/draco/README.md
@@ -0,0 +1,478 @@
+<p align="center">
+<img width="350px" src="docs/artwork/draco3d-vert.svg" />
+</p>
+
+![Build Status: master](https://travis-ci.org/google/draco.svg?branch=master)
+
+News
+=======
+### Version 1.4.1 release
+* Using the versioned gstatic.com WASM and Javascript decoders is now
+  recommended. To use v1.4.1, use this URL:
+  * https://www.gstatic.com/draco/versioned/decoders/1.4.1/*
+    * Replace the * with the files to load. E.g.
+    * https://gstatic.com/draco/versioned/decoders/1.4.1/draco_decoder.js
+  * This works with the v1.3.6 and v1.4.0 releases, and will work with future
+    Draco releases.
+* Bug fixes
+
+### Version 1.4.0 release
+* WASM and JavaScript decoders are hosted from a static URL.
+  * It is recommended to always pull your Draco WASM and JavaScript decoders from this URL:
+  * https://www.gstatic.com/draco/v1/decoders/*
+    * Replace * with the files to load. E.g.
+    * https://www.gstatic.com/draco/v1/decoders/draco_decoder_gltf.wasm
+  * Users will benefit from having the Draco decoder in cache as more sites start using the static URL
+* Changed npm modules to use WASM, which increased performance by ~200%.
+* Updated Emscripten to 2.0.
+  * This causes the Draco codec modules to return a promise instead of the module directly.
+  * Please see the example code on how to handle the promise.
+* Changed NORMAL quantization default to 8.
+* Added new array API to decoder and deprecated DecoderBuffer.
+  * See PR https://github.com/google/draco/issues/513 for more information.
+* Changed WASM/JavaScript behavior of catching exceptions.
+  * See issue https://github.com/google/draco/issues/629 for more information.
+* Code cleanup.
+* Emscripten builds now disable NODEJS_CATCH_EXIT and NODEJS_CATCH_REJECTION.
+  * Authors of a CLI tool might want to add their own error handlers.
+* Added Maya plugin builds.
+* Unity plugin builds updated.
+  * Builds are now stored as archives.
+  * Added iOS build.
+  * Unity users may want to look into https://github.com/atteneder/DracoUnity.
+* Bug fixes.
+
+### Version 1.3.6 release
+* WASM and JavaScript decoders are now hosted from a static URL
+  * It is recommended to always pull your Draco WASM and JavaScript decoders from this URL:
+  * https://www.gstatic.com/draco/v1/decoders/*
+    * Replace * with the files to load. E.g.
+    * https://www.gstatic.com/draco/v1/decoders/draco_decoder_gltf.wasm
+  * Users will benefit from having the Draco decoder in cache as more sites start using the static URL
+* Changed web examples to pull Draco decoders from static URL
+* Added new API to Draco WASM decoder, which increased performance by ~15%
+* Decreased Draco WASM decoder size by ~20%
+* Added support for generic and multiple attributes to Draco Unity plug-ins
+* Added new API to Draco Unity, which increased decoder performance by ~15%
+* Changed quantization defaults:
+  * POSITION: 11
+  * NORMAL: 7
+  * TEX_COORD: 10
+  * COLOR: 8
+  * GENERIC: 8
+* Code cleanup
+* Bug fixes
+
+### Version 1.3.5 release
+* Added option to build Draco for Universal Scene Description
+* Code cleanup
+* Bug fixes
+
+### Version 1.3.4 release
+* Released Draco Animation code
+* Fixes for Unity
+* Various file location and name changes
+
+### Version 1.3.3 release
+* Added ExpertEncoder to the Javascript API
+  * Allows developers to set quantization options per attribute id
+* Bug fixes
+
+### Version 1.3.2 release
+* Bug fixes
+
+### Version 1.3.1 release
+* Fix issue with multiple attributes when skipping an attribute transform
+
+### Version 1.3.0 release
+* Improved kD-tree based point cloud encoding
+  * Now applicable to point clouds with any number of attributes
+  * Support for all integer attribute types and quantized floating point types
+* Improved mesh compression up to 10% (on average ~2%)
+  * For meshes, the 1.3.0 bitstream is fully compatible with 1.2.x decoders
+* Improved Javascript API
+  * Added support for all signed and unsigned integer types
+  * Added support for point clouds to our Javascript encoder API
+* Added support for integer properties to the PLY decoder
+* Bug fixes
+
+### Previous releases
+https://github.com/google/draco/releases
+
+Description
+===========
+
+Draco is a library for compressing and decompressing 3D geometric [meshes] and
+[point clouds]. It is intended to improve the storage and transmission of 3D
+graphics.
+
+Draco was designed and built for compression efficiency and speed. The code
+supports compressing points, connectivity information, texture coordinates,
+color information, normals, and any other generic attributes associated with
+geometry. With Draco, applications using 3D graphics can be significantly
+smaller without compromising visual fidelity. For users, this means apps can
+now be downloaded faster, 3D graphics in the browser can load quicker, and VR
+and AR scenes can now be transmitted with a fraction of the bandwidth and
+rendered quickly.
+
+Draco is released as C++ source code that can be used to compress 3D graphics
+as well as C++ and Javascript decoders for the encoded data.
+
+
+_**Contents**_
+
+  * [Building](#building)
+  * [Usage](#usage)
+    * [Unity](#unity)
+    * [WASM and JavaScript Decoders](#WASM-and-JavaScript-Decoders)
+    * [Command Line Applications](#command-line-applications)
+    * [Encoding Tool](#encoding-tool)
+    * [Encoding Point Clouds](#encoding-point-clouds)
+    * [Decoding Tool](#decoding-tool)
+    * [C++ Decoder API](#c-decoder-api)
+    * [Javascript Encoder API](#javascript-encoder-api)
+    * [Javascript Decoder API](#javascript-decoder-api)
+    * [Javascript Decoder Performance](#javascript-decoder-performance)
+    * [Metadata API](#metadata-api)
+    * [NPM Package](#npm-package)
+    * [three.js Renderer Example](#threejs-renderer-example)
+  * [Support](#support)
+  * [License](#license)
+  * [References](#references)
+
+
+Building
+========
+See [BUILDING](BUILDING.md) for building instructions.
+
+
+Usage
+======
+
+Unity
+-----
+For the best information about using Unity with Draco please visit https://github.com/atteneder/DracoUnity
+
+For a simple example of using Unity with Draco see [README](unity/README.md) in the unity folder.
+
+WASM and JavaScript Decoders
+----------------------------
+
+It is recommended to always pull your Draco WASM and JavaScript decoders from:
+
+~~~~~ bash
+https://www.gstatic.com/draco/v1/decoders/
+~~~~~
+
+Users will benefit from having the Draco decoder in cache as more sites start using the static URL.
+
+Command Line Applications
+------------------------
+
+The default target created from the build files will be the `draco_encoder`
+and `draco_decoder` command line applications. For both applications, if you
+run them without any arguments or `-h`, the applications will output usage and
+options.
+
+Encoding Tool
+-------------
+
+`draco_encoder` will read OBJ or PLY files as input, and output Draco-encoded
+files. We have included Stanford's [Bunny] mesh for testing. The basic command
+line looks like this:
+
+~~~~~ bash
+./draco_encoder -i testdata/bun_zipper.ply -o out.drc
+~~~~~
+
+A value of `0` for the quantization parameter will not perform any quantization
+on the specified attribute. Any value other than `0` will quantize the input
+values for the specified attribute to that number of bits. For example:
+
+~~~~~ bash
+./draco_encoder -i testdata/bun_zipper.ply -o out.drc -qp 14
+~~~~~
+
+will quantize the positions to 14 bits (default is 11 for the position
+coordinates).
+
+In general, the more you quantize your attributes the better compression rate
+you will get. It is up to your project to decide how much deviation it will
+tolerate. In general, most projects can set quantization values of about `11`
+without any noticeable difference in quality.
+
+The compression level (`-cl`) parameter turns on/off different compression
+features.
+
+~~~~~ bash
+./draco_encoder -i testdata/bun_zipper.ply -o out.drc -cl 8
+~~~~~
+
+In general, the highest setting, `10`, will have the most compression but
+worst decompression speed. `0` will have the least compression, but best
+decompression speed. The default setting is `7`.
+
+Encoding Point Clouds
+---------------------
+
+You can encode point cloud data with `draco_encoder` by specifying the
+`-point_cloud` parameter. If you specify the `-point_cloud` parameter with a
+mesh input file, `draco_encoder` will ignore the connectivity data and encode
+the positions from the mesh file.
+
+~~~~~ bash
+./draco_encoder -point_cloud -i testdata/bun_zipper.ply -o out.drc
+~~~~~
+
+This command line will encode the mesh input as a point cloud, even though the
+input might not produce compression that is representative of other point
+clouds. Specifically, one can expect much better compression rates for larger
+and denser point clouds.
+
+Decoding Tool
+-------------
+
+`draco_decoder` will read Draco files as input, and output OBJ or PLY files.
+The basic command line looks like this:
+
+~~~~~ bash
+./draco_decoder -i in.drc -o out.obj
+~~~~~
+
+C++ Decoder API
+-------------
+
+If you'd like to add decoding to your applications you will need to include
+the `draco_dec` library. In order to use the Draco decoder you need to
+initialize a `DecoderBuffer` with the compressed data. Then call
+`DecodeMeshFromBuffer()` to return a decoded mesh object or call
+`DecodePointCloudFromBuffer()` to return a decoded `PointCloud` object. For
+example:
+
+~~~~~ cpp
+draco::DecoderBuffer buffer;
+buffer.Init(data.data(), data.size());
+
+const draco::EncodedGeometryType geom_type =
+    draco::GetEncodedGeometryType(&buffer);
+if (geom_type == draco::TRIANGULAR_MESH) {
+  unique_ptr<draco::Mesh> mesh = draco::DecodeMeshFromBuffer(&buffer);
+} else if (geom_type == draco::POINT_CLOUD) {
+  unique_ptr<draco::PointCloud> pc = draco::DecodePointCloudFromBuffer(&buffer);
+}
+~~~~~
+
+Please see [src/draco/mesh/mesh.h](src/draco/mesh/mesh.h) for the full `Mesh` class interface and
+[src/draco/point_cloud/point_cloud.h](src/draco/point_cloud/point_cloud.h) for the full `PointCloud` class interface.
+
+
+Javascript Encoder API
+----------------------
+The Javascript encoder is located in `javascript/draco_encoder.js`. The encoder
+API can be used to compress mesh and point cloud. In order to use the encoder,
+you need to first create an instance of `DracoEncoderModule`. Then use this
+instance to create `MeshBuilder` and `Encoder` objects. `MeshBuilder` is used
+to construct a mesh from geometry data that could be later compressed by
+`Encoder`. First create a mesh object using `new encoderModule.Mesh()` . Then,
+use `AddFacesToMesh()` to add indices to the mesh and use
+`AddFloatAttributeToMesh()` to add attribute data to the mesh, e.g. position,
+normal, color and texture coordinates. After a mesh is constructed, you could
+then use `EncodeMeshToDracoBuffer()` to compress the mesh. For example:
+
+~~~~~ js
+const mesh = {
+  indices : new Uint32Array(indices),
+  vertices : new Float32Array(vertices),
+  normals : new Float32Array(normals)
+};
+
+const encoderModule = DracoEncoderModule();
+const encoder = new encoderModule.Encoder();
+const meshBuilder = new encoderModule.MeshBuilder();
+const dracoMesh = new encoderModule.Mesh();
+
+const numFaces = mesh.indices.length / 3;
+const numPoints = mesh.vertices.length;
+meshBuilder.AddFacesToMesh(dracoMesh, numFaces, mesh.indices);
+
+meshBuilder.AddFloatAttributeToMesh(dracoMesh, encoderModule.POSITION,
+  numPoints, 3, mesh.vertices);
+if (mesh.hasOwnProperty('normals')) {
+  meshBuilder.AddFloatAttributeToMesh(
+    dracoMesh, encoderModule.NORMAL, numPoints, 3, mesh.normals);
+}
+if (mesh.hasOwnProperty('colors')) {
+  meshBuilder.AddFloatAttributeToMesh(
+    dracoMesh, encoderModule.COLOR, numPoints, 3, mesh.colors);
+}
+if (mesh.hasOwnProperty('texcoords')) {
+  meshBuilder.AddFloatAttributeToMesh(
+    dracoMesh, encoderModule.TEX_COORD, numPoints, 3, mesh.texcoords);
+}
+
+if (method === "edgebreaker") {
+  encoder.SetEncodingMethod(encoderModule.MESH_EDGEBREAKER_ENCODING);
+} else if (method === "sequential") {
+  encoder.SetEncodingMethod(encoderModule.MESH_SEQUENTIAL_ENCODING);
+}
+
+const encodedData = new encoderModule.DracoInt8Array();
+// Use default encoding setting.
+const encodedLen = encoder.EncodeMeshToDracoBuffer(dracoMesh,
+                                                   encodedData);
+encoderModule.destroy(dracoMesh);
+encoderModule.destroy(encoder);
+encoderModule.destroy(meshBuilder);
+
+~~~~~
+Please see [src/draco/javascript/emscripten/draco_web_encoder.idl](src/draco/javascript/emscripten/draco_web_encoder.idl) for the full API.
+
+Javascript Decoder API
+----------------------
+
+The Javascript decoder is located in [javascript/draco_decoder.js](javascript/draco_decoder.js). The
+Javascript decoder can decode mesh and point cloud. In order to use the
+decoder, you must first create an instance of `DracoDecoderModule`. The
+instance is then used to create `DecoderBuffer` and `Decoder` objects. Set
+the encoded data in the `DecoderBuffer`. Then call `GetEncodedGeometryType()`
+to identify the type of geometry, e.g. mesh or point cloud. Then call either
+`DecodeBufferToMesh()` or `DecodeBufferToPointCloud()`, which will return
+a Mesh object or a point cloud. For example:
+
+~~~~~ js
+// Create the Draco decoder.
+const decoderModule = DracoDecoderModule();
+const buffer = new decoderModule.DecoderBuffer();
+buffer.Init(byteArray, byteArray.length);
+
+// Create a buffer to hold the encoded data.
+const decoder = new decoderModule.Decoder();
+const geometryType = decoder.GetEncodedGeometryType(buffer);
+
+// Decode the encoded geometry.
+let outputGeometry;
+let status;
+if (geometryType == decoderModule.TRIANGULAR_MESH) {
+  outputGeometry = new decoderModule.Mesh();
+  status = decoder.DecodeBufferToMesh(buffer, outputGeometry);
+} else {
+  outputGeometry = new decoderModule.PointCloud();
+  status = decoder.DecodeBufferToPointCloud(buffer, outputGeometry);
+}
+
+// You must explicitly delete objects created from the DracoDecoderModule
+// or Decoder.
+decoderModule.destroy(outputGeometry);
+decoderModule.destroy(decoder);
+decoderModule.destroy(buffer);
+~~~~~
+
+Please see [src/draco/javascript/emscripten/draco_web_decoder.idl](src/draco/javascript/emscripten/draco_web_decoder.idl) for the full API.
+
+Javascript Decoder Performance
+------------------------------
+
+The Javascript decoder is built with dynamic memory. This will let the decoder
+work with all of the compressed data. But this option is not the fastest.
+Pre-allocating the memory sees about a 2x decoder speed improvement. If you
+know all of your project's memory requirements, you can turn on static memory
+by changing `CMakeLists.txt` accordingly.
+
+Metadata API
+------------
+Starting from v1.0, Draco provides metadata functionality for encoding data
+other than geometry. It could be used to encode any custom data along with the
+geometry. For example, we can enable metadata functionality to encode the name
+of attributes, name of sub-objects and customized information.
+For one mesh and point cloud, it can have one top-level geometry metadata class.
+The top-level metadata then can have hierarchical metadata. Other than that,
+the top-level metadata can have metadata for each attribute which is called
+attribute metadata. The attribute metadata should be initialized with the
+correspondent attribute id within the mesh. The metadata API is provided both
+in C++ and Javascript.
+For example, to add metadata in C++:
+
+~~~~~ cpp
+draco::PointCloud pc;
+// Add metadata for the geometry.
+std::unique_ptr<draco::GeometryMetadata> metadata =
+  std::unique_ptr<draco::GeometryMetadata>(new draco::GeometryMetadata());
+metadata->AddEntryString("description", "This is an example.");
+pc.AddMetadata(std::move(metadata));
+
+// Add metadata for attributes.
+draco::GeometryAttribute pos_att;
+pos_att.Init(draco::GeometryAttribute::POSITION, nullptr, 3,
+             draco::DT_FLOAT32, false, 12, 0);
+const uint32_t pos_att_id = pc.AddAttribute(pos_att, false, 0);
+
+std::unique_ptr<draco::AttributeMetadata> pos_metadata =
+    std::unique_ptr<draco::AttributeMetadata>(
+        new draco::AttributeMetadata(pos_att_id));
+pos_metadata->AddEntryString("name", "position");
+
+// Directly add attribute metadata to geometry.
+// You can do this without explicitly add |GeometryMetadata| to mesh.
+pc.AddAttributeMetadata(pos_att_id, std::move(pos_metadata));
+~~~~~
+
+To read metadata from a geometry in C++:
+
+~~~~~ cpp
+// Get metadata for the geometry.
+const draco::GeometryMetadata *pc_metadata = pc.GetMetadata();
+
+// Request metadata for a specific attribute.
+const draco::AttributeMetadata *requested_pos_metadata =
+  pc.GetAttributeMetadataByStringEntry("name", "position");
+~~~~~
+
+Please see [src/draco/metadata](src/draco/metadata) and [src/draco/point_cloud](src/draco/point_cloud) for the full API.
+
+NPM Package
+-----------
+Draco NPM NodeJS package is located in [javascript/npm/draco3d](javascript/npm/draco3d). Please see the
+doc in the folder for detailed usage.
+
+three.js Renderer Example
+-------------------------
+
+Here's an [example] of a geometric compressed with Draco loaded via a
+Javascript decoder using the `three.js` renderer.
+
+Please see the [javascript/example/README.md](javascript/example/README.md) file for more information.
+
+Support
+=======
+
+For questions/comments please email <draco-3d-discuss@googlegroups.com>
+
+If you have found an error in this library, please file an issue at
+<https://github.com/google/draco/issues>
+
+Patches are encouraged, and may be submitted by forking this project and
+submitting a pull request through GitHub. See [CONTRIBUTING] for more detail.
+
+License
+=======
+Licensed under the Apache License, Version 2.0 (the "License"); you may not
+use this file except in compliance with the License. You may obtain a copy of
+the License at
+
+<http://www.apache.org/licenses/LICENSE-2.0>
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+License for the specific language governing permissions and limitations under
+the License.
+
+References
+==========
+[example]:https://storage.googleapis.com/demos.webmproject.org/draco/draco_loader_throw.html
+[meshes]: https://en.wikipedia.org/wiki/Polygon_mesh
+[point clouds]: https://en.wikipedia.org/wiki/Point_cloud
+[Bunny]: https://graphics.stanford.edu/data/3Dscanrep/
+[CONTRIBUTING]: https://raw.githubusercontent.com/google/draco/master/CONTRIBUTING.md
+
+Bunny model from Stanford's graphic department <https://graphics.stanford.edu/data/3Dscanrep/>
diff --git a/contrib/draco/cmake/DracoConfig.cmake b/contrib/draco/cmake/DracoConfig.cmake
new file mode 100644
index 000000000..be5e1faef
--- /dev/null
+++ b/contrib/draco/cmake/DracoConfig.cmake
@@ -0,0 +1,3 @@
+@PACKAGE_INIT@
+set_and_check(draco_INCLUDE_DIR "@PACKAGE_draco_include_install_dir@")
+set_and_check(draco_LIBRARY_DIR "@PACKAGE_draco_lib_install_dir@")
diff --git a/contrib/draco/cmake/FindDraco.cmake b/contrib/draco/cmake/FindDraco.cmake
new file mode 100644
index 000000000..0a9193065
--- /dev/null
+++ b/contrib/draco/cmake/FindDraco.cmake
@@ -0,0 +1,56 @@
+# Finddraco
+#
+# Locates draco and sets the following variables:
+#
+# draco_FOUND draco_INCLUDE_DIRS draco_LIBARY_DIRS draco_LIBRARIES
+# draco_VERSION_STRING
+#
+# draco_FOUND is set to YES only when all other variables are successfully
+# configured.
+
+unset(draco_FOUND)
+unset(draco_INCLUDE_DIRS)
+unset(draco_LIBRARY_DIRS)
+unset(draco_LIBRARIES)
+unset(draco_VERSION_STRING)
+
+mark_as_advanced(draco_FOUND)
+mark_as_advanced(draco_INCLUDE_DIRS)
+mark_as_advanced(draco_LIBRARY_DIRS)
+mark_as_advanced(draco_LIBRARIES)
+mark_as_advanced(draco_VERSION_STRING)
+
+set(draco_version_file_no_prefix "draco/src/draco/core/draco_version.h")
+
+# Set draco_INCLUDE_DIRS
+find_path(draco_INCLUDE_DIRS NAMES "${draco_version_file_no_prefix}")
+
+# Extract the version string from draco_version.h.
+if(draco_INCLUDE_DIRS)
+  set(draco_version_file
+      "${draco_INCLUDE_DIRS}/draco/src/draco/core/draco_version.h")
+  file(STRINGS "${draco_version_file}" draco_version REGEX "kdracoVersion")
+  list(GET draco_version 0 draco_version)
+  string(REPLACE "static const char kdracoVersion[] = " "" draco_version
+                 "${draco_version}")
+  string(REPLACE ";" "" draco_version "${draco_version}")
+  string(REPLACE "\"" "" draco_version "${draco_version}")
+  set(draco_VERSION_STRING ${draco_version})
+endif()
+
+# Find the library.
+if(BUILD_SHARED_LIBS)
+  find_library(draco_LIBRARIES NAMES draco.dll libdraco.dylib libdraco.so)
+else()
+  find_library(draco_LIBRARIES NAMES draco.lib libdraco.a)
+endif()
+
+# Store path to library.
+get_filename_component(draco_LIBRARY_DIRS ${draco_LIBRARIES} DIRECTORY)
+
+if(draco_INCLUDE_DIRS
+   AND draco_LIBRARY_DIRS
+   AND draco_LIBRARIES
+   AND draco_VERSION_STRING)
+  set(draco_FOUND YES)
+endif()
diff --git a/contrib/draco/cmake/compiler_flags.cmake b/contrib/draco/cmake/compiler_flags.cmake
new file mode 100644
index 000000000..8750e6f7d
--- /dev/null
+++ b/contrib/draco/cmake/compiler_flags.cmake
@@ -0,0 +1,220 @@
+if(DRACO_CMAKE_COMPILER_FLAGS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_COMPILER_FLAGS_CMAKE_ 1)
+
+include(CheckCCompilerFlag)
+include(CheckCXXCompilerFlag)
+include("${draco_root}/cmake/compiler_tests.cmake")
+
+# Strings used to cache failed C/CXX flags.
+set(DRACO_FAILED_C_FLAGS)
+set(DRACO_FAILED_CXX_FLAGS)
+
+# Checks C compiler for support of $c_flag. Adds $c_flag to $CMAKE_C_FLAGS when
+# the compile test passes. Caches $c_flag in $DRACO_FAILED_C_FLAGS when the test
+# fails.
+macro(add_c_flag_if_supported c_flag)
+  unset(C_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_C_FLAGS}" "${c_flag}" C_FLAG_FOUND)
+  unset(C_FLAG_FAILED CACHE)
+  string(FIND "${DRACO_FAILED_C_FLAGS}" "${c_flag}" C_FLAG_FAILED)
+
+  if(${C_FLAG_FOUND} EQUAL -1 AND ${C_FLAG_FAILED} EQUAL -1)
+    unset(C_FLAG_SUPPORTED CACHE)
+    message("Checking C compiler flag support for: " ${c_flag})
+    check_c_compiler_flag("${c_flag}" C_FLAG_SUPPORTED)
+    if(${C_FLAG_SUPPORTED})
+      set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${c_flag}" CACHE STRING "")
+    else()
+      set(DRACO_FAILED_C_FLAGS
+          "${DRACO_FAILED_C_FLAGS} ${c_flag}"
+          CACHE STRING "" FORCE)
+    endif()
+  endif()
+endmacro()
+
+# Checks C++ compiler for support of $cxx_flag. Adds $cxx_flag to
+# $CMAKE_CXX_FLAGS when the compile test passes. Caches $c_flag in
+# $DRACO_FAILED_CXX_FLAGS when the test fails.
+macro(add_cxx_flag_if_supported cxx_flag)
+  unset(CXX_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_CXX_FLAGS}" "${cxx_flag}" CXX_FLAG_FOUND)
+  unset(CXX_FLAG_FAILED CACHE)
+  string(FIND "${DRACO_FAILED_CXX_FLAGS}" "${cxx_flag}" CXX_FLAG_FAILED)
+
+  if(${CXX_FLAG_FOUND} EQUAL -1 AND ${CXX_FLAG_FAILED} EQUAL -1)
+    unset(CXX_FLAG_SUPPORTED CACHE)
+    message("Checking CXX compiler flag support for: " ${cxx_flag})
+    check_cxx_compiler_flag("${cxx_flag}" CXX_FLAG_SUPPORTED)
+    if(${CXX_FLAG_SUPPORTED})
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${cxx_flag}" CACHE STRING "")
+    else()
+      set(DRACO_FAILED_CXX_FLAGS
+          "${DRACO_FAILED_CXX_FLAGS} ${cxx_flag}"
+          CACHE STRING "" FORCE)
+    endif()
+  endif()
+endmacro()
+
+# Convenience method for adding a flag to both the C and C++ compiler command
+# lines.
+macro(add_compiler_flag_if_supported flag)
+  add_c_flag_if_supported(${flag})
+  add_cxx_flag_if_supported(${flag})
+endmacro()
+
+# Checks C compiler for support of $c_flag and terminates generation when
+# support is not present.
+macro(require_c_flag c_flag update_c_flags)
+  unset(C_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_C_FLAGS}" "${c_flag}" C_FLAG_FOUND)
+
+  if(${C_FLAG_FOUND} EQUAL -1)
+    unset(HAVE_C_FLAG CACHE)
+    message("Checking C compiler flag support for: " ${c_flag})
+    check_c_compiler_flag("${c_flag}" HAVE_C_FLAG)
+    if(NOT ${HAVE_C_FLAG})
+      message(
+        FATAL_ERROR "${PROJECT_NAME} requires support for C flag: ${c_flag}.")
+    endif()
+    if(${update_c_flags})
+      set(CMAKE_C_FLAGS "${c_flag} ${CMAKE_C_FLAGS}" CACHE STRING "" FORCE)
+    endif()
+  endif()
+endmacro()
+
+# Checks CXX compiler for support of $cxx_flag and terminates generation when
+# support is not present.
+macro(require_cxx_flag cxx_flag update_cxx_flags)
+  unset(CXX_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_CXX_FLAGS}" "${cxx_flag}" CXX_FLAG_FOUND)
+
+  if(${CXX_FLAG_FOUND} EQUAL -1)
+    unset(HAVE_CXX_FLAG CACHE)
+    message("Checking CXX compiler flag support for: " ${cxx_flag})
+    check_cxx_compiler_flag("${cxx_flag}" HAVE_CXX_FLAG)
+    if(NOT ${HAVE_CXX_FLAG})
+      message(
+        FATAL_ERROR
+          "${PROJECT_NAME} requires support for CXX flag: ${cxx_flag}.")
+    endif()
+    if(${update_cxx_flags})
+      set(CMAKE_CXX_FLAGS
+          "${cxx_flag} ${CMAKE_CXX_FLAGS}"
+          CACHE STRING "" FORCE)
+    endif()
+  endif()
+endmacro()
+
+# Checks for support of $flag by both the C and CXX compilers. Terminates
+# generation when support is not present in both compilers.
+macro(require_compiler_flag flag update_cmake_flags)
+  require_c_flag(${flag} ${update_cmake_flags})
+  require_cxx_flag(${flag} ${update_cmake_flags})
+endmacro()
+
+# Checks only non-MSVC targets for support of $c_flag and terminates generation
+# when support is not present.
+macro(require_c_flag_nomsvc c_flag update_c_flags)
+  if(NOT MSVC)
+    require_c_flag(${c_flag} ${update_c_flags})
+  endif()
+endmacro()
+
+# Checks only non-MSVC targets for support of $cxx_flag and terminates
+# generation when support is not present.
+macro(require_cxx_flag_nomsvc cxx_flag update_cxx_flags)
+  if(NOT MSVC)
+    require_cxx_flag(${cxx_flag} ${update_cxx_flags})
+  endif()
+endmacro()
+
+# Checks only non-MSVC targets for support of $flag by both the C and CXX
+# compilers. Terminates generation when support is not present in both
+# compilers.
+macro(require_compiler_flag_nomsvc flag update_cmake_flags)
+  require_c_flag_nomsvc(${flag} ${update_cmake_flags})
+  require_cxx_flag_nomsvc(${flag} ${update_cmake_flags})
+endmacro()
+
+# Adds $flag to assembler command line.
+macro(append_as_flag flag)
+  unset(AS_FLAG_FOUND CACHE)
+  string(FIND "${DRACO_AS_FLAGS}" "${flag}" AS_FLAG_FOUND)
+
+  if(${AS_FLAG_FOUND} EQUAL -1)
+    set(DRACO_AS_FLAGS "${DRACO_AS_FLAGS} ${flag}")
+  endif()
+endmacro()
+
+# Adds $flag to the C compiler command line.
+macro(append_c_flag flag)
+  unset(C_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_C_FLAGS}" "${flag}" C_FLAG_FOUND)
+
+  if(${C_FLAG_FOUND} EQUAL -1)
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}")
+  endif()
+endmacro()
+
+# Adds $flag to the CXX compiler command line.
+macro(append_cxx_flag flag)
+  unset(CXX_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_CXX_FLAGS}" "${flag}" CXX_FLAG_FOUND)
+
+  if(${CXX_FLAG_FOUND} EQUAL -1)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
+  endif()
+endmacro()
+
+# Adds $flag to the C and CXX compiler command lines.
+macro(append_compiler_flag flag)
+  append_c_flag(${flag})
+  append_cxx_flag(${flag})
+endmacro()
+
+# Adds $flag to the executable linker command line.
+macro(append_exe_linker_flag flag)
+  unset(LINKER_FLAG_FOUND CACHE)
+  string(FIND "${CMAKE_EXE_LINKER_FLAGS}" "${flag}" LINKER_FLAG_FOUND)
+
+  if(${LINKER_FLAG_FOUND} EQUAL -1)
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${flag}")
+  endif()
+endmacro()
+
+# Adds $flag to the link flags for $target.
+function(append_link_flag_to_target target flags)
+  unset(target_link_flags)
+  get_target_property(target_link_flags ${target} LINK_FLAGS)
+
+  if(target_link_flags)
+    unset(link_flag_found)
+    string(FIND "${target_link_flags}" "${flags}" link_flag_found)
+
+    if(NOT ${link_flag_found} EQUAL -1)
+      return()
+    endif()
+
+    set(target_link_flags "${target_link_flags} ${flags}")
+  else()
+    set(target_link_flags "${flags}")
+  endif()
+
+  set_target_properties(${target} PROPERTIES LINK_FLAGS ${target_link_flags})
+endfunction()
+
+# Adds $flag to executable linker flags, and makes sure C/CXX builds still work.
+macro(require_linker_flag flag)
+  append_exe_linker_flag(${flag})
+
+  unset(c_passed)
+  draco_check_c_compiles("LINKER_FLAG_C_TEST(${flag})" "" c_passed)
+  unset(cxx_passed)
+  draco_check_cxx_compiles("LINKER_FLAG_CXX_TEST(${flag})" "" cxx_passed)
+
+  if(NOT c_passed OR NOT cxx_passed)
+    message(FATAL_ERROR "Linker flag test for ${flag} failed.")
+  endif()
+endmacro()
diff --git a/contrib/draco/cmake/compiler_tests.cmake b/contrib/draco/cmake/compiler_tests.cmake
new file mode 100644
index 000000000..e781a6537
--- /dev/null
+++ b/contrib/draco/cmake/compiler_tests.cmake
@@ -0,0 +1,103 @@
+if(DRACO_CMAKE_COMPILER_TESTS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_COMPILER_TESTS_CMAKE_ 1)
+
+include(CheckCSourceCompiles)
+include(CheckCXXSourceCompiles)
+
+# The basic main() macro used in all compile tests.
+set(DRACO_C_MAIN "\nint main(void) { return 0; }")
+set(DRACO_CXX_MAIN "\nint main() { return 0; }")
+
+# Strings containing the names of passed and failed tests.
+set(DRACO_C_PASSED_TESTS)
+set(DRACO_C_FAILED_TESTS)
+set(DRACO_CXX_PASSED_TESTS)
+set(DRACO_CXX_FAILED_TESTS)
+
+macro(draco_push_var var new_value)
+  set(SAVED_${var} ${var})
+  set(${var} ${new_value})
+endmacro()
+
+macro(draco_pop_var var)
+  set(var ${SAVED_${var}})
+  unset(SAVED_${var})
+endmacro()
+
+# Confirms $test_source compiles and stores $test_name in one of
+# $DRACO_C_PASSED_TESTS or $DRACO_C_FAILED_TESTS depending on out come. When the
+# test passes $result_var is set to 1. When it fails $result_var is unset. The
+# test is not run if the test name is found in either of the passed or failed
+# test variables.
+macro(draco_check_c_compiles test_name test_source result_var)
+  unset(C_TEST_PASSED CACHE)
+  unset(C_TEST_FAILED CACHE)
+  string(FIND "${DRACO_C_PASSED_TESTS}" "${test_name}" C_TEST_PASSED)
+  string(FIND "${DRACO_C_FAILED_TESTS}" "${test_name}" C_TEST_FAILED)
+  if(${C_TEST_PASSED} EQUAL -1 AND ${C_TEST_FAILED} EQUAL -1)
+    unset(C_TEST_COMPILED CACHE)
+    message("Running C compiler test: ${test_name}")
+    check_c_source_compiles("${test_source} ${DRACO_C_MAIN}" C_TEST_COMPILED)
+    set(${result_var} ${C_TEST_COMPILED})
+
+    if(${C_TEST_COMPILED})
+      set(DRACO_C_PASSED_TESTS "${DRACO_C_PASSED_TESTS} ${test_name}")
+    else()
+      set(DRACO_C_FAILED_TESTS "${DRACO_C_FAILED_TESTS} ${test_name}")
+      message("C Compiler test ${test_name} failed.")
+    endif()
+  elseif(NOT ${C_TEST_PASSED} EQUAL -1)
+    set(${result_var} 1)
+  else() # ${C_TEST_FAILED} NOT EQUAL -1
+    unset(${result_var})
+  endif()
+endmacro()
+
+# Confirms $test_source compiles and stores $test_name in one of
+# $DRACO_CXX_PASSED_TESTS or $DRACO_CXX_FAILED_TESTS depending on out come. When
+# the test passes $result_var is set to 1. When it fails $result_var is unset.
+# The test is not run if the test name is found in either of the passed or
+# failed test variables.
+macro(draco_check_cxx_compiles test_name test_source result_var)
+  unset(CXX_TEST_PASSED CACHE)
+  unset(CXX_TEST_FAILED CACHE)
+  string(FIND "${DRACO_CXX_PASSED_TESTS}" "${test_name}" CXX_TEST_PASSED)
+  string(FIND "${DRACO_CXX_FAILED_TESTS}" "${test_name}" CXX_TEST_FAILED)
+  if(${CXX_TEST_PASSED} EQUAL -1 AND ${CXX_TEST_FAILED} EQUAL -1)
+    unset(CXX_TEST_COMPILED CACHE)
+    message("Running CXX compiler test: ${test_name}")
+    check_cxx_source_compiles("${test_source} ${DRACO_CXX_MAIN}"
+                              CXX_TEST_COMPILED)
+    set(${result_var} ${CXX_TEST_COMPILED})
+
+    if(${CXX_TEST_COMPILED})
+      set(DRACO_CXX_PASSED_TESTS "${DRACO_CXX_PASSED_TESTS} ${test_name}")
+    else()
+      set(DRACO_CXX_FAILED_TESTS "${DRACO_CXX_FAILED_TESTS} ${test_name}")
+      message("CXX Compiler test ${test_name} failed.")
+    endif()
+  elseif(NOT ${CXX_TEST_PASSED} EQUAL -1)
+    set(${result_var} 1)
+  else() # ${CXX_TEST_FAILED} NOT EQUAL -1
+    unset(${result_var})
+  endif()
+endmacro()
+
+# Convenience macro that confirms $test_source compiles as C and C++.
+# $result_var is set to 1 when both tests are successful, and 0 when one or both
+# tests fail. Note: This macro is intended to be used to write to result
+# variables that are expanded via configure_file(). $result_var is set to 1 or 0
+# to allow direct usage of the value in generated source files.
+macro(draco_check_source_compiles test_name test_source result_var)
+  unset(C_PASSED)
+  unset(CXX_PASSED)
+  draco_check_c_compiles(${test_name} ${test_source} C_PASSED)
+  draco_check_cxx_compiles(${test_name} ${test_source} CXX_PASSED)
+  if(${C_PASSED} AND ${CXX_PASSED})
+    set(${result_var} 1)
+  else()
+    set(${result_var} 0)
+  endif()
+endmacro()
diff --git a/contrib/draco/cmake/draco-config.cmake.template b/contrib/draco/cmake/draco-config.cmake.template
new file mode 100644
index 000000000..ca4a456bf
--- /dev/null
+++ b/contrib/draco/cmake/draco-config.cmake.template
@@ -0,0 +1,2 @@
+set(DRACO_INCLUDE_DIRS "@DRACO_INCLUDE_DIRS@")
+set(DRACO_LIBRARIES "draco")
diff --git a/contrib/draco/cmake/draco.pc.template b/contrib/draco/cmake/draco.pc.template
new file mode 100644
index 000000000..b8ae48212
--- /dev/null
+++ b/contrib/draco/cmake/draco.pc.template
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: @PROJECT_NAME@
+Description: Draco geometry de(com)pression library.
+Version: @DRACO_VERSION@
+Cflags: -I${includedir}
+Libs: -L${libdir} -ldraco
+Libs.private: @CMAKE_THREAD_LIBS_INIT@
diff --git a/contrib/draco/cmake/draco_build_definitions.cmake b/contrib/draco/cmake/draco_build_definitions.cmake
new file mode 100644
index 000000000..c1ada6206
--- /dev/null
+++ b/contrib/draco/cmake/draco_build_definitions.cmake
@@ -0,0 +1,117 @@
+if(DRACO_CMAKE_DRACO_BUILD_DEFINITIONS_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_BUILD_DEFINITIONS_CMAKE_
+set(DRACO_CMAKE_DRACO_BUILD_DEFINITIONS_CMAKE_ 1)
+
+# Utility for controlling the main draco library dependency. This changes in
+# shared builds, and when an optional target requires a shared library build.
+macro(set_draco_target)
+  if(MSVC OR WIN32)
+    set(draco_dependency draco)
+    set(draco_plugin_dependency ${draco_dependency})
+  else()
+    if(BUILD_SHARED_LIBS)
+      set(draco_dependency draco_shared)
+    else()
+      set(draco_dependency draco_static)
+    endif()
+    set(draco_plugin_dependency draco_static)
+  endif()
+
+  if(BUILD_SHARED_LIBS)
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+  endif()
+endmacro()
+
+# Configures flags and sets build system globals.
+macro(draco_set_build_definitions)
+  string(TOLOWER "${CMAKE_BUILD_TYPE}" build_type_lowercase)
+
+  if(build_type_lowercase MATCHES "rel" AND DRACO_FAST)
+    if(MSVC)
+      list(APPEND draco_msvc_cxx_flags "/Ox")
+    else()
+      list(APPEND draco_base_cxx_flags "-O3")
+    endif()
+  endif()
+
+  draco_load_version_info()
+  set(DRACO_SOVERSION 1)
+
+  list(APPEND draco_include_paths "${draco_root}" "${draco_root}/src"
+              "${draco_build}")
+
+  if(DRACO_ABSL)
+    list(APPEND draco_include_path "${draco_root}/third_party/abseil-cpp")
+  endif()
+
+
+  list(APPEND draco_gtest_include_paths
+              "${draco_root}/../googletest/googlemock/include"
+              "${draco_root}/../googletest/googlemock"
+              "${draco_root}/../googletest/googletest/include"
+              "${draco_root}/../googletest/googletest")
+  list(APPEND draco_test_include_paths ${draco_include_paths}
+              ${draco_gtest_include_paths})
+  list(APPEND draco_defines "DRACO_CMAKE=1"
+              "DRACO_FLAGS_SRCDIR=\"${draco_root}\""
+              "DRACO_FLAGS_TMPDIR=\"/tmp\"")
+
+  if(MSVC OR WIN32)
+    list(APPEND draco_defines "_CRT_SECURE_NO_DEPRECATE=1" "NOMINMAX=1")
+
+    if(BUILD_SHARED_LIBS)
+      set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE)
+    endif()
+  endif()
+
+  if(ANDROID)
+    if(CMAKE_ANDROID_ARCH_ABI STREQUAL "armeabi-v7a")
+      set(CMAKE_ANDROID_ARM_MODE ON)
+    endif()
+  endif()
+
+  set_draco_target()
+
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "6")
+      # Quiet warnings in copy-list-initialization where {} elision has always
+      # been allowed.
+      list(APPEND draco_clang_cxx_flags "-Wno-missing-braces")
+    endif()
+  endif()
+
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "7")
+      if(CMAKE_SYSTEM_PROCESSOR STREQUAL "armv7")
+        # Quiet gcc 6 vs 7 abi warnings:
+        # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=77728
+        list(APPEND draco_base_cxx_flags "-Wno-psabi")
+        list(APPEND ABSL_GCC_FLAGS "-Wno-psabi")
+      endif()
+    endif()
+  endif()
+
+  # Source file names ending in these suffixes will have the appropriate
+  # compiler flags added to their compile commands to enable intrinsics.
+  set(draco_neon_source_file_suffix "neon.cc")
+  set(draco_sse4_source_file_suffix "sse4.cc")
+
+  if((${CMAKE_CXX_COMPILER_ID}
+      STREQUAL
+      "GNU"
+      AND ${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 5)
+     OR (${CMAKE_CXX_COMPILER_ID}
+         STREQUAL
+         "Clang"
+         AND ${CMAKE_CXX_COMPILER_VERSION} VERSION_LESS 4))
+    message(
+      WARNING "GNU/GCC < v5 or Clang/LLVM < v4, ENABLING COMPATIBILITY MODE.")
+    draco_enable_feature(FEATURE "DRACO_OLD_GCC")
+  endif()
+
+  if(EMSCRIPTEN)
+    draco_check_emscripten_environment()
+    draco_get_required_emscripten_flags(FLAG_LIST_VAR draco_base_cxx_flags)
+  endif()
+endmacro()
diff --git a/contrib/draco/cmake/draco_cpu_detection.cmake b/contrib/draco/cmake/draco_cpu_detection.cmake
new file mode 100644
index 000000000..96e4a289b
--- /dev/null
+++ b/contrib/draco/cmake/draco_cpu_detection.cmake
@@ -0,0 +1,28 @@
+if(DRACO_CMAKE_DRACO_CPU_DETECTION_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_CPU_DETECTION_CMAKE_
+set(DRACO_CMAKE_DRACO_CPU_DETECTION_CMAKE_ 1)
+
+# Detect optimizations available for the current target CPU.
+macro(draco_optimization_detect)
+  if(DRACO_ENABLE_OPTIMIZATIONS)
+    string(TOLOWER "${CMAKE_SYSTEM_PROCESSOR}" cpu_lowercase)
+    if(cpu_lowercase MATCHES "^arm|^aarch64")
+      set(draco_have_neon ON)
+    elseif(cpu_lowercase MATCHES "^x86|amd64")
+      set(draco_have_sse4 ON)
+    endif()
+  endif()
+
+  if(draco_have_neon AND DRACO_ENABLE_NEON)
+    list(APPEND draco_defines "DRACO_ENABLE_NEON=1")
+  else()
+    list(APPEND draco_defines "DRACO_ENABLE_NEON=0")
+  endif()
+
+  if(draco_have_sse4 AND DRACO_ENABLE_SSE4_1)
+    list(APPEND draco_defines "DRACO_ENABLE_SSE4_1=1")
+  else()
+    list(APPEND draco_defines "DRACO_ENABLE_SSE4_1=0")
+  endif()
+endmacro()
diff --git a/contrib/draco/cmake/draco_emscripten.cmake b/contrib/draco/cmake/draco_emscripten.cmake
new file mode 100644
index 000000000..10c935043
--- /dev/null
+++ b/contrib/draco/cmake/draco_emscripten.cmake
@@ -0,0 +1,185 @@
+if(DRACO_CMAKE_DRACO_EMSCRIPTEN_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_EMSCRIPTEN_CMAKE_
+
+# Checks environment for Emscripten prerequisites.
+macro(draco_check_emscripten_environment)
+  if(NOT PYTHONINTERP_FOUND)
+    message(
+      FATAL_ERROR
+        "Python required for Emscripten builds, but cmake cannot find it.")
+  endif()
+  if(NOT EXISTS "$ENV{EMSCRIPTEN}")
+    message(
+      FATAL_ERROR
+        "The EMSCRIPTEN environment variable must be set. See README.md.")
+  endif()
+endmacro()
+
+# Obtains the required Emscripten flags for Draco targets.
+macro(draco_get_required_emscripten_flags)
+  set(em_FLAG_LIST_VAR)
+  set(em_flags)
+  set(em_single_arg_opts FLAG_LIST_VAR)
+  set(em_multi_arg_opts)
+  cmake_parse_arguments(em "${em_flags}" "${em_single_arg_opts}"
+                        "${em_multi_arg_opts}" ${ARGN})
+  if(NOT em_FLAG_LIST_VAR)
+    message(FATAL "draco_get_required_emscripten_flags: FLAG_LIST_VAR required")
+  endif()
+
+  if(DRACO_JS_GLUE)
+    unset(required_flags)
+    list(APPEND ${em_FLAG_LIST_VAR} "-sALLOW_MEMORY_GROWTH=1")
+    list(APPEND ${em_FLAG_LIST_VAR} "-Wno-almost-asm")
+    list(APPEND ${em_FLAG_LIST_VAR} "--memory-init-file" "0")
+    list(APPEND ${em_FLAG_LIST_VAR} "-fno-omit-frame-pointer")
+    list(APPEND ${em_FLAG_LIST_VAR} "-sMODULARIZE=1")
+    list(APPEND ${em_FLAG_LIST_VAR} "-sNO_FILESYSTEM=1")
+    list(APPEND ${em_FLAG_LIST_VAR} "-sEXPORTED_RUNTIME_METHODS=[]")
+    list(APPEND ${em_FLAG_LIST_VAR} "-sPRECISE_F32=1")
+    list(APPEND ${em_FLAG_LIST_VAR} "-sNODEJS_CATCH_EXIT=0")
+    list(APPEND ${em_FLAG_LIST_VAR} "-sNODEJS_CATCH_REJECTION=0")
+
+    if(DRACO_FAST)
+      list(APPEND ${em_FLAG_LIST_VAR} "--llvm-lto" "1")
+    endif()
+    if(DRACO_WASM)
+      list(APPEND ${em_FLAG_LIST_VAR} "-sWASM=1")
+    else()
+      list(APPEND ${em_FLAG_LIST_VAR} "-sWASM=0")
+    endif()
+    if(DRACO_IE_COMPATIBLE)
+      list(APPEND ${em_FLAG_LIST_VAR} "-sLEGACY_VM_SUPPORT=1")
+    endif()
+  endif()
+endmacro()
+
+# Macro for generating C++ glue code from IDL for Emscripten targets. Executes
+# python to generate the C++ binding, and establishes dendency: $OUTPUT_PATH.cpp
+# on $INPUT_IDL.
+macro(draco_generate_emscripten_glue)
+  set(glue_flags)
+  set(glue_single_arg_opts INPUT_IDL OUTPUT_PATH)
+  set(glue_multi_arg_opts)
+  cmake_parse_arguments(glue "${glue_flags}" "${glue_single_arg_opts}"
+                        "${glue_multi_arg_opts}" ${ARGN})
+
+  if(DRACO_VERBOSE GREATER 1)
+    message("--------- draco_generate_emscripten_glue -----------\n"
+            "glue_INPUT_IDL=${glue_INPUT_IDL}\n"
+            "glue_OUTPUT_PATH=${glue_OUTPUT_PATH}\n" ]
+            "----------------------------------------------------\n")
+  endif()
+
+  if(NOT glue_INPUT_IDL OR NOT glue_OUTPUT_PATH)
+    message(
+      FATAL_ERROR
+        "draco_generate_emscripten_glue: INPUT_IDL and OUTPUT_PATH required.")
+  endif()
+
+  # Generate the glue source.
+  execute_process(COMMAND ${PYTHON_EXECUTABLE}
+                          $ENV{EMSCRIPTEN}/tools/webidl_binder.py
+                          ${glue_INPUT_IDL} ${glue_OUTPUT_PATH})
+  if(NOT EXISTS "${glue_OUTPUT_PATH}.cpp")
+    message(FATAL_ERROR "JS glue generation failed for ${glue_INPUT_IDL}.")
+  endif()
+
+  # Create a dependency so that it regenerated on edits.
+  add_custom_command(OUTPUT "${glue_OUTPUT_PATH}.cpp"
+                     COMMAND ${PYTHON_EXECUTABLE}
+                             $ENV{EMSCRIPTEN}/tools/webidl_binder.py
+                             ${glue_INPUT_IDL} ${glue_OUTPUT_PATH}
+                     DEPENDS ${draco_js_dec_idl}
+                     COMMENT "Generating ${glue_OUTPUT_PATH}.cpp."
+                     WORKING_DIRECTORY ${draco_build}
+                     VERBATIM)
+endmacro()
+
+# Wrapper for draco_add_executable() that handles the extra work necessary for
+# emscripten targets when generating JS glue:
+#
+# ~~~
+# - Set source level dependency on the C++ binding.
+# - Pre/Post link emscripten magic.
+#
+# Required args:
+#   - GLUE_PATH: Base path for glue file. Used to generate .cpp and .js files.
+#   - PRE_LINK_JS_SOURCES: em_link_pre_js() source files.
+#   - POST_LINK_JS_SOURCES: em_link_post_js() source files.
+# Optional args:
+#   - FEATURES:
+# ~~~
+macro(draco_add_emscripten_executable)
+  unset(emexe_NAME)
+  unset(emexe_FEATURES)
+  unset(emexe_SOURCES)
+  unset(emexe_DEFINES)
+  unset(emexe_INCLUDES)
+  unset(emexe_LINK_FLAGS)
+  set(optional_args)
+  set(single_value_args NAME GLUE_PATH)
+  set(multi_value_args SOURCES DEFINES FEATURES INCLUDES LINK_FLAGS
+                       PRE_LINK_JS_SOURCES POST_LINK_JS_SOURCES)
+
+  cmake_parse_arguments(emexe "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT
+     (emexe_GLUE_PATH
+      AND emexe_POST_LINK_JS_SOURCES
+      AND emexe_PRE_LINK_JS_SOURCES))
+    message(FATAL
+            "draco_add_emscripten_executable: GLUE_PATH PRE_LINK_JS_SOURCES "
+            "POST_LINK_JS_SOURCES args required.")
+  endif()
+
+  if(DRACO_VERBOSE GREATER 1)
+    message("--------- draco_add_emscripten_executable ---------\n"
+            "emexe_NAME=${emexe_NAME}\n"
+            "emexe_SOURCES=${emexe_SOURCES}\n"
+            "emexe_DEFINES=${emexe_DEFINES}\n"
+            "emexe_INCLUDES=${emexe_INCLUDES}\n"
+            "emexe_LINK_FLAGS=${emexe_LINK_FLAGS}\n"
+            "emexe_GLUE_PATH=${emexe_GLUE_PATH}\n"
+            "emexe_FEATURES=${emexe_FEATURES}\n"
+            "emexe_PRE_LINK_JS_SOURCES=${emexe_PRE_LINK_JS_SOURCES}\n"
+            "emexe_POST_LINK_JS_SOURCES=${emexe_POST_LINK_JS_SOURCES}\n"
+            "----------------------------------------------------\n")
+  endif()
+
+  # The Emscripten linker needs the C++ flags in addition to whatever has been
+  # passed in with the target.
+  list(APPEND emexe_LINK_FLAGS ${DRACO_CXX_FLAGS})
+
+  if(DRACO_GLTF)
+    draco_add_executable(NAME
+                         ${emexe_NAME}
+                         OUTPUT_NAME
+                         ${emexe_NAME}_gltf
+                         SOURCES
+                         ${emexe_SOURCES}
+                         DEFINES
+                         ${emexe_DEFINES}
+                         INCLUDES
+                         ${emexe_INCLUDES}
+                         LINK_FLAGS
+                         ${emexe_LINK_FLAGS})
+  else()
+    draco_add_executable(NAME ${emexe_NAME} SOURCES ${emexe_SOURCES} DEFINES
+                         ${emexe_DEFINES} INCLUDES ${emexe_INCLUDES} LINK_FLAGS
+                         ${emexe_LINK_FLAGS})
+  endif()
+
+  foreach(feature ${emexe_FEATURES})
+    draco_enable_feature(FEATURE ${feature} TARGETS ${emexe_NAME})
+  endforeach()
+
+  set_property(SOURCE ${emexe_SOURCES}
+               APPEND
+               PROPERTY OBJECT_DEPENDS "${emexe_GLUE_PATH}.cpp")
+  em_link_pre_js(${emexe_NAME} ${emexe_PRE_LINK_JS_SOURCES})
+  em_link_post_js(${emexe_NAME} "${emexe_GLUE_PATH}.js"
+                  ${emexe_POST_LINK_JS_SOURCES})
+endmacro()
diff --git a/contrib/draco/cmake/draco_features.cmake b/contrib/draco/cmake/draco_features.cmake
new file mode 100644
index 000000000..be444bf24
--- /dev/null
+++ b/contrib/draco/cmake/draco_features.cmake
@@ -0,0 +1,63 @@
+if(DRACO_CMAKE_DRACO_FEATURES_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_DRACO_FEATURES_CMAKE_ 1)
+
+set(draco_features_file_name "${draco_build_dir}/draco/draco_features.h")
+set(draco_features_list)
+
+# Macro that handles tracking of Draco preprocessor symbols for the purpose of
+# producing draco_features.h.
+#
+# draco_enable_feature(FEATURE <feature_name> [TARGETS <target_name>]) FEATURE
+# is required. It should be a Draco preprocessor symbol. TARGETS is optional. It
+# can be one or more draco targets.
+#
+# When the TARGETS argument is not present the preproc symbol is added to
+# draco_features.h. When it is draco_features.h is unchanged, and
+# target_compile_options() is called for each target specified.
+macro(draco_enable_feature)
+  set(def_flags)
+  set(def_single_arg_opts FEATURE)
+  set(def_multi_arg_opts TARGETS)
+  cmake_parse_arguments(DEF "${def_flags}" "${def_single_arg_opts}"
+                        "${def_multi_arg_opts}" ${ARGN})
+  if("${DEF_FEATURE}" STREQUAL "")
+    message(FATAL_ERROR "Empty FEATURE passed to draco_enable_feature().")
+  endif()
+
+  # Do nothing/return early if $DEF_FEATURE is already in the list.
+  list(FIND draco_features_list ${DEF_FEATURE} df_index)
+  if(NOT df_index EQUAL -1)
+    return()
+  endif()
+
+  list(LENGTH DEF_TARGETS df_targets_list_length)
+  if(${df_targets_list_length} EQUAL 0)
+    list(APPEND draco_features_list ${DEF_FEATURE})
+  else()
+    foreach(target ${DEF_TARGETS})
+      target_compile_definitions(${target} PRIVATE ${DEF_FEATURE})
+    endforeach()
+  endif()
+endmacro()
+
+# Function for generating draco_features.h.
+function(draco_generate_features_h)
+  file(WRITE "${draco_features_file_name}.new"
+       "// GENERATED FILE -- DO NOT EDIT\n\n" "#ifndef DRACO_FEATURES_H_\n"
+       "#define DRACO_FEATURES_H_\n\n")
+
+  foreach(feature ${draco_features_list})
+    file(APPEND "${draco_features_file_name}.new" "#define ${feature}\n")
+  endforeach()
+
+  file(APPEND "${draco_features_file_name}.new"
+       "\n#endif  // DRACO_FEATURES_H_")
+
+  # Will replace ${draco_features_file_name} only if the file content has
+  # changed. This prevents forced Draco rebuilds after CMake runs.
+  configure_file("${draco_features_file_name}.new"
+                 "${draco_features_file_name}")
+  file(REMOVE "${draco_features_file_name}.new")
+endfunction()
diff --git a/contrib/draco/cmake/draco_flags.cmake b/contrib/draco/cmake/draco_flags.cmake
new file mode 100644
index 000000000..cb9d489e6
--- /dev/null
+++ b/contrib/draco/cmake/draco_flags.cmake
@@ -0,0 +1,238 @@
+if(DRACO_CMAKE_DRACO_FLAGS_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_FLAGS_CMAKE_
+set(DRACO_CMAKE_DRACO_FLAGS_CMAKE_ 1)
+
+include(CheckCXXCompilerFlag)
+include(CheckCXXSourceCompiles)
+
+# Adds compiler flags specified by FLAGS to the sources specified by SOURCES:
+#
+# draco_set_compiler_flags_for_sources(SOURCES <sources> FLAGS <flags>)
+macro(draco_set_compiler_flags_for_sources)
+  unset(compiler_SOURCES)
+  unset(compiler_FLAGS)
+  unset(optional_args)
+  unset(single_value_args)
+  set(multi_value_args SOURCES FLAGS)
+  cmake_parse_arguments(compiler "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT (compiler_SOURCES AND compiler_FLAGS))
+    draco_die("draco_set_compiler_flags_for_sources: SOURCES and "
+              "FLAGS required.")
+  endif()
+
+  set_source_files_properties(${compiler_SOURCES} PROPERTIES COMPILE_FLAGS
+                              ${compiler_FLAGS})
+
+  if(DRACO_VERBOSE GREATER 1)
+    foreach(source ${compiler_SOURCES})
+      foreach(flag ${compiler_FLAGS})
+        message("draco_set_compiler_flags_for_sources: source:${source} "
+                "flag:${flag}")
+      endforeach()
+    endforeach()
+  endif()
+endmacro()
+
+# Tests compiler flags stored in list(s) specified by FLAG_LIST_VAR_NAMES, adds
+# flags to $DRACO_CXX_FLAGS when tests pass. Terminates configuration if
+# FLAG_REQUIRED is specified and any flag check fails.
+#
+# ~~~
+# draco_test_cxx_flag(<FLAG_LIST_VAR_NAMES <flag list variable(s)>>
+#                       [FLAG_REQUIRED])
+# ~~~
+macro(draco_test_cxx_flag)
+  unset(cxx_test_FLAG_LIST_VAR_NAMES)
+  unset(cxx_test_FLAG_REQUIRED)
+  unset(single_value_args)
+  set(optional_args FLAG_REQUIRED)
+  set(multi_value_args FLAG_LIST_VAR_NAMES)
+  cmake_parse_arguments(cxx_test "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT cxx_test_FLAG_LIST_VAR_NAMES)
+    draco_die("draco_test_cxx_flag: FLAG_LIST_VAR_NAMES required")
+  endif()
+
+  unset(cxx_flags)
+  foreach(list_var ${cxx_test_FLAG_LIST_VAR_NAMES})
+    if(DRACO_VERBOSE)
+      message("draco_test_cxx_flag: adding ${list_var} to cxx_flags")
+    endif()
+    list(APPEND cxx_flags ${${list_var}})
+  endforeach()
+
+  if(DRACO_VERBOSE)
+    message("CXX test: all flags: ${cxx_flags}")
+  endif()
+
+  unset(all_cxx_flags)
+  list(APPEND all_cxx_flags ${DRACO_CXX_FLAGS} ${cxx_flags})
+
+  # Turn off output from check_cxx_source_compiles. Print status directly
+  # instead since the logging messages from check_cxx_source_compiles can be
+  # quite confusing.
+  set(CMAKE_REQUIRED_QUIET TRUE)
+
+  # Run the actual compile test.
+  unset(draco_all_cxx_flags_pass CACHE)
+  message("--- Running combined CXX flags test, flags: ${all_cxx_flags}")
+  check_cxx_compiler_flag("${all_cxx_flags}" draco_all_cxx_flags_pass)
+
+  if(cxx_test_FLAG_REQUIRED AND NOT draco_all_cxx_flags_pass)
+    draco_die("Flag test failed for required flag(s): "
+              "${all_cxx_flags} and FLAG_REQUIRED specified.")
+  endif()
+
+  if(draco_all_cxx_flags_pass)
+    # Test passed: update the global flag list used by the draco target creation
+    # wrappers.
+    set(DRACO_CXX_FLAGS ${cxx_flags})
+    list(REMOVE_DUPLICATES DRACO_CXX_FLAGS)
+
+    if(DRACO_VERBOSE)
+      message("DRACO_CXX_FLAGS=${DRACO_CXX_FLAGS}")
+    endif()
+
+    message("--- Passed combined CXX flags test")
+  else()
+    message("--- Failed combined CXX flags test, testing flags individually.")
+
+    if(cxx_flags)
+      message("--- Testing flags from $cxx_flags: " "${cxx_flags}")
+      foreach(cxx_flag ${cxx_flags})
+        # Since 3.17.0 check_cxx_compiler_flag() sets a normal variable at
+        # parent scope while check_cxx_source_compiles() continues to set an
+        # internal cache variable, so we unset both to avoid the failure /
+        # success state persisting between checks. This has been fixed in newer
+        # CMake releases, but 3.17 is pretty common: we will need this to avoid
+        # weird build breakages while the fix propagates.
+        unset(cxx_flag_test_passed)
+        unset(cxx_flag_test_passed CACHE)
+        message("--- Testing flag: ${cxx_flag}")
+        check_cxx_compiler_flag("${cxx_flag}" cxx_flag_test_passed)
+
+        if(cxx_flag_test_passed)
+          message("--- Passed test for ${cxx_flag}")
+        else()
+          list(REMOVE_ITEM cxx_flags ${cxx_flag})
+          message("--- Failed test for ${cxx_flag}, flag removed.")
+        endif()
+      endforeach()
+
+      set(DRACO_CXX_FLAGS ${cxx_flags})
+    endif()
+  endif()
+
+  if(DRACO_CXX_FLAGS)
+    list(REMOVE_DUPLICATES DRACO_CXX_FLAGS)
+  endif()
+endmacro()
+
+# Tests executable linker flags stored in list specified by FLAG_LIST_VAR_NAME,
+# adds flags to $DRACO_EXE_LINKER_FLAGS when test passes. Terminates
+# configuration when flag check fails. draco_set_cxx_flags() must be called
+# before calling this macro because it assumes $DRACO_CXX_FLAGS contains only
+# valid CXX flags.
+#
+# draco_test_exe_linker_flag(<FLAG_LIST_VAR_NAME <flag list variable)>)
+macro(draco_test_exe_linker_flag)
+  unset(link_FLAG_LIST_VAR_NAME)
+  unset(optional_args)
+  unset(multi_value_args)
+  set(single_value_args FLAG_LIST_VAR_NAME)
+  cmake_parse_arguments(link "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT link_FLAG_LIST_VAR_NAME)
+    draco_die("draco_test_link_flag: FLAG_LIST_VAR_NAME required")
+  endif()
+
+  draco_set_and_stringify(DEST linker_flags SOURCE_VARS
+                          ${link_FLAG_LIST_VAR_NAME})
+
+  if(DRACO_VERBOSE)
+    message("EXE LINKER test: all flags: ${linker_flags}")
+  endif()
+
+  # Tests of $DRACO_CXX_FLAGS have already passed. Include them with the linker
+  # test.
+  draco_set_and_stringify(DEST CMAKE_REQUIRED_FLAGS SOURCE_VARS DRACO_CXX_FLAGS)
+
+  # Cache the global exe linker flags.
+  if(CMAKE_EXE_LINKER_FLAGS)
+    set(cached_CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS})
+    draco_set_and_stringify(DEST CMAKE_EXE_LINKER_FLAGS SOURCE ${linker_flags})
+  endif()
+
+  draco_set_and_stringify(DEST CMAKE_EXE_LINKER_FLAGS SOURCE ${linker_flags}
+                          ${CMAKE_EXE_LINKER_FLAGS})
+
+  # Turn off output from check_cxx_source_compiles. Print status directly
+  # instead since the logging messages from check_cxx_source_compiles can be
+  # quite confusing.
+  set(CMAKE_REQUIRED_QUIET TRUE)
+
+  message("--- Running EXE LINKER test for flags: ${linker_flags}")
+
+  unset(linker_flag_test_passed CACHE)
+  set(draco_cxx_main "\nint main() { return 0; }")
+  check_cxx_source_compiles("${draco_cxx_main}" linker_flag_test_passed)
+
+  if(NOT linker_flag_test_passed)
+    draco_die("EXE LINKER test failed.")
+  endif()
+
+  message("--- Passed EXE LINKER flag test.")
+
+  # Restore cached global exe linker flags.
+  if(cached_CMAKE_EXE_LINKER_FLAGS)
+    set(CMAKE_EXE_LINKER_FLAGS ${cached_CMAKE_EXE_LINKER_FLAGS})
+  else()
+    unset(CMAKE_EXE_LINKER_FLAGS)
+  endif()
+endmacro()
+
+# Runs the draco compiler tests. This macro builds up the list of list var(s)
+# that is passed to draco_test_cxx_flag().
+#
+# Note: draco_set_build_definitions() must be called before this macro.
+macro(draco_set_cxx_flags)
+  unset(cxx_flag_lists)
+
+  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+    list(APPEND cxx_flag_lists draco_base_cxx_flags)
+  endif()
+
+  # Append clang flags after the base set to allow -Wno* overrides to take
+  # effect. Some of the base flags may enable a large set of warnings, e.g.,
+  # -Wall.
+  if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+    list(APPEND cxx_flag_lists draco_clang_cxx_flags)
+  endif()
+
+  if(MSVC)
+    list(APPEND cxx_flag_lists draco_msvc_cxx_flags)
+  endif()
+
+  draco_set_and_stringify(DEST cxx_flags SOURCE_VARS ${cxx_flag_lists})
+  if(DRACO_VERBOSE)
+    message("draco_set_cxx_flags: internal CXX flags: ${cxx_flags}")
+  endif()
+
+  if(DRACO_CXX_FLAGS)
+    list(APPEND cxx_flag_lists DRACO_CXX_FLAGS)
+    if(DRACO_VERBOSE)
+      message("draco_set_cxx_flags: user CXX flags: ${DRACO_CXX_FLAGS}")
+    endif()
+  endif()
+
+  draco_set_and_stringify(DEST cxx_flags SOURCE_VARS ${cxx_flag_lists})
+
+  if(cxx_flags)
+    draco_test_cxx_flag(FLAG_LIST_VAR_NAMES ${cxx_flag_lists})
+  endif()
+endmacro()
diff --git a/contrib/draco/cmake/draco_helpers.cmake b/contrib/draco/cmake/draco_helpers.cmake
new file mode 100644
index 000000000..0b3b804cf
--- /dev/null
+++ b/contrib/draco/cmake/draco_helpers.cmake
@@ -0,0 +1,110 @@
+if(DRACO_CMAKE_DRACO_HELPERS_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_HELPERS_CMAKE_
+set(DRACO_CMAKE_DRACO_HELPERS_CMAKE_ 1)
+
+# Kills build generation using message(FATAL_ERROR) and outputs all data passed
+# to the console via use of $ARGN.
+macro(draco_die)
+  message(FATAL_ERROR ${ARGN})
+endmacro()
+
+# Converts semi-colon delimited list variable(s) to string. Output is written to
+# variable supplied via the DEST parameter. Input is from an expanded variable
+# referenced by SOURCE and/or variable(s) referenced by SOURCE_VARS.
+macro(draco_set_and_stringify)
+  set(optional_args)
+  set(single_value_args DEST SOURCE_VAR)
+  set(multi_value_args SOURCE SOURCE_VARS)
+  cmake_parse_arguments(sas "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT sas_DEST OR NOT (sas_SOURCE OR sas_SOURCE_VARS))
+    draco_die("draco_set_and_stringify: DEST and at least one of SOURCE "
+              "SOURCE_VARS required.")
+  endif()
+
+  unset(${sas_DEST})
+
+  if(sas_SOURCE)
+    # $sas_SOURCE is one or more expanded variables, just copy the values to
+    # $sas_DEST.
+    set(${sas_DEST} "${sas_SOURCE}")
+  endif()
+
+  if(sas_SOURCE_VARS)
+    # $sas_SOURCE_VARS is one or more variable names. Each iteration expands a
+    # variable and appends it to $sas_DEST.
+    foreach(source_var ${sas_SOURCE_VARS})
+      set(${sas_DEST} "${${sas_DEST}} ${${source_var}}")
+    endforeach()
+
+    # Because $sas_DEST can be empty when entering this scope leading whitespace
+    # can be introduced to $sas_DEST on the first iteration of the above loop.
+    # Remove it:
+    string(STRIP "${${sas_DEST}}" ${sas_DEST})
+  endif()
+
+  # Lists in CMake are simply semicolon delimited strings, so stringification is
+  # just a find and replace of the semicolon.
+  string(REPLACE ";" " " ${sas_DEST} "${${sas_DEST}}")
+
+  if(DRACO_VERBOSE GREATER 1)
+    message("draco_set_and_stringify: ${sas_DEST}=${${sas_DEST}}")
+  endif()
+endmacro()
+
+# Creates a dummy source file in $DRACO_GENERATED_SOURCES_DIRECTORY and adds it
+# to the specified target. Optionally adds its path to a list variable.
+#
+# draco_create_dummy_source_file(<TARGET <target> BASENAME <basename of file>>
+# [LISTVAR <list variable>])
+macro(draco_create_dummy_source_file)
+  set(optional_args)
+  set(single_value_args TARGET BASENAME LISTVAR)
+  set(multi_value_args)
+  cmake_parse_arguments(cdsf "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT cdsf_TARGET OR NOT cdsf_BASENAME)
+    draco_die("draco_create_dummy_source_file: TARGET and BASENAME required.")
+  endif()
+
+  if(NOT DRACO_GENERATED_SOURCES_DIRECTORY)
+    set(DRACO_GENERATED_SOURCES_DIRECTORY "${draco_build}/gen_src")
+  endif()
+
+  set(dummy_source_dir "${DRACO_GENERATED_SOURCES_DIRECTORY}")
+  set(dummy_source_file
+      "${dummy_source_dir}/draco_${cdsf_TARGET}_${cdsf_BASENAME}.cc")
+  set(dummy_source_code
+      "// Generated file. DO NOT EDIT!\n"
+      "// C++ source file created for target ${cdsf_TARGET}.\n"
+      "void draco_${cdsf_TARGET}_${cdsf_BASENAME}_dummy_function(void)\;\n"
+      "void draco_${cdsf_TARGET}_${cdsf_BASENAME}_dummy_function(void) {}\n")
+  file(WRITE "${dummy_source_file}" ${dummy_source_code})
+
+  target_sources(${cdsf_TARGET} PRIVATE ${dummy_source_file})
+
+  if(cdsf_LISTVAR)
+    list(APPEND ${cdsf_LISTVAR} "${dummy_source_file}")
+  endif()
+endmacro()
+
+# Loads the version string from $draco_source/draco/version.h and sets
+# $DRACO_VERSION.
+macro(draco_load_version_info)
+  file(STRINGS "${draco_src_root}/core/draco_version.h" version_file_strings)
+  foreach(str ${version_file_strings})
+    if(str MATCHES "char kDracoVersion")
+      string(FIND "${str}" "\"" open_quote_pos)
+      string(FIND "${str}" ";" semicolon_pos)
+      math(EXPR open_quote_pos "${open_quote_pos} + 1")
+      math(EXPR close_quote_pos "${semicolon_pos} - 1")
+      math(EXPR version_string_length "${close_quote_pos} - ${open_quote_pos}")
+      string(SUBSTRING "${str}" ${open_quote_pos} ${version_string_length}
+                       DRACO_VERSION)
+      break()
+    endif()
+  endforeach()
+endmacro()
diff --git a/contrib/draco/cmake/draco_install.cmake b/contrib/draco/cmake/draco_install.cmake
new file mode 100644
index 000000000..5c63ecb4a
--- /dev/null
+++ b/contrib/draco/cmake/draco_install.cmake
@@ -0,0 +1,79 @@
+if(DRACO_CMAKE_DRACO_INSTALL_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_INSTALL_CMAKE_
+set(DRACO_CMAKE_DRACO_INSTALL_CMAKE_ 1)
+
+# Sets up the draco install targets. Must be called after the static library
+# target is created.
+macro(draco_setup_install_target)
+  include(GNUInstallDirs)
+
+  # pkg-config: draco.pc
+  set(prefix "${CMAKE_INSTALL_PREFIX}")
+  set(exec_prefix "\${prefix}")
+  set(libdir "\${prefix}/${CMAKE_INSTALL_LIBDIR}")
+  set(includedir "\${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+  set(draco_lib_name "draco")
+
+  configure_file("${draco_root}/cmake/draco.pc.template"
+                 "${draco_build}/draco.pc" @ONLY NEWLINE_STYLE UNIX)
+  install(FILES "${draco_build}/draco.pc"
+          DESTINATION "${prefix}/${CMAKE_INSTALL_LIBDIR}/pkgconfig")
+
+  # CMake config: draco-config.cmake
+  set(DRACO_INCLUDE_DIRS "${prefix}/${CMAKE_INSTALL_INCLUDEDIR}")
+  configure_file("${draco_root}/cmake/draco-config.cmake.template"
+                 "${draco_build}/draco-config.cmake" @ONLY NEWLINE_STYLE UNIX)
+  install(
+    FILES "${draco_build}/draco-config.cmake"
+    DESTINATION "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_DATAROOTDIR}/cmake")
+
+  foreach(file ${draco_sources})
+    if(file MATCHES "h$")
+      list(APPEND draco_api_includes ${file})
+    endif()
+  endforeach()
+
+  # Strip $draco_src_root from the file paths: we need to install relative to
+  # $include_directory.
+  list(TRANSFORM draco_api_includes REPLACE "${draco_src_root}/" "")
+  set(include_directory "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}")
+
+  foreach(draco_api_include ${draco_api_includes})
+    get_filename_component(file_directory ${draco_api_include} DIRECTORY)
+    set(target_directory "${include_directory}/draco/${file_directory}")
+    install(FILES ${draco_src_root}/${draco_api_include}
+            DESTINATION "${target_directory}")
+  endforeach()
+
+  install(
+    FILES "${draco_build}/draco/draco_features.h"
+    DESTINATION "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_INCLUDEDIR}/draco/")
+
+  install(TARGETS draco_decoder DESTINATION
+                  "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}")
+  install(TARGETS draco_encoder DESTINATION
+                  "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_BINDIR}")
+
+  if(WIN32)
+    install(TARGETS draco DESTINATION
+                    "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+  else()
+    install(TARGETS draco_static DESTINATION
+                    "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+    if(BUILD_SHARED_LIBS)
+      install(TARGETS draco_shared DESTINATION
+                      "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+    endif()
+  endif()
+
+  if(DRACO_UNITY_PLUGIN)
+    install(TARGETS dracodec_unity DESTINATION
+                    "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+  endif()
+  if(DRACO_MAYA_PLUGIN)
+    install(TARGETS draco_maya_wrapper DESTINATION
+                    "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}")
+  endif()
+
+endmacro()
diff --git a/contrib/draco/cmake/draco_intrinsics.cmake b/contrib/draco/cmake/draco_intrinsics.cmake
new file mode 100644
index 000000000..9011c0de5
--- /dev/null
+++ b/contrib/draco/cmake/draco_intrinsics.cmake
@@ -0,0 +1,96 @@
+if(DRACO_CMAKE_DRACO_INTRINSICS_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_INTRINSICS_CMAKE_
+set(DRACO_CMAKE_DRACO_INTRINSICS_CMAKE_ 1)
+
+# Returns the compiler flag for the SIMD intrinsics suffix specified by the
+# SUFFIX argument via the variable specified by the VARIABLE argument:
+# draco_get_intrinsics_flag_for_suffix(SUFFIX <suffix> VARIABLE <var name>)
+macro(draco_get_intrinsics_flag_for_suffix)
+  unset(intrinsics_SUFFIX)
+  unset(intrinsics_VARIABLE)
+  unset(optional_args)
+  unset(multi_value_args)
+  set(single_value_args SUFFIX VARIABLE)
+  cmake_parse_arguments(intrinsics "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT (intrinsics_SUFFIX AND intrinsics_VARIABLE))
+    message(FATAL_ERROR "draco_get_intrinsics_flag_for_suffix: SUFFIX and "
+                        "VARIABLE required.")
+  endif()
+
+  if(intrinsics_SUFFIX MATCHES "neon")
+    if(NOT MSVC)
+      set(${intrinsics_VARIABLE} "${DRACO_NEON_INTRINSICS_FLAG}")
+    endif()
+  elseif(intrinsics_SUFFIX MATCHES "sse4")
+    if(NOT MSVC)
+      set(${intrinsics_VARIABLE} "-msse4.1")
+    endif()
+  else()
+    message(FATAL_ERROR "draco_get_intrinsics_flag_for_suffix: Unknown "
+                        "instrinics suffix: ${intrinsics_SUFFIX}")
+  endif()
+
+  if(DRACO_VERBOSE GREATER 1)
+    message("draco_get_intrinsics_flag_for_suffix: "
+            "suffix:${intrinsics_SUFFIX} flag:${${intrinsics_VARIABLE}}")
+  endif()
+endmacro()
+
+# Processes source files specified by SOURCES and adds intrinsics flags as
+# necessary: draco_process_intrinsics_sources(SOURCES <sources>)
+#
+# Detects requirement for intrinsics flags using source file name suffix.
+# Currently supports only SSE4.1.
+macro(draco_process_intrinsics_sources)
+  unset(arg_TARGET)
+  unset(arg_SOURCES)
+  unset(optional_args)
+  set(single_value_args TARGET)
+  set(multi_value_args SOURCES)
+  cmake_parse_arguments(arg "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+  if(NOT (arg_TARGET AND arg_SOURCES))
+    message(FATAL_ERROR "draco_process_intrinsics_sources: TARGET and "
+                        "SOURCES required.")
+  endif()
+
+  if(DRACO_ENABLE_SSE4_1 AND draco_have_sse4)
+    unset(sse4_sources)
+    list(APPEND sse4_sources ${arg_SOURCES})
+
+    list(FILTER sse4_sources INCLUDE REGEX
+         "${draco_sse4_source_file_suffix}$")
+
+    if(sse4_sources)
+      unset(sse4_flags)
+      draco_get_intrinsics_flag_for_suffix(SUFFIX
+                                             ${draco_sse4_source_file_suffix}
+                                             VARIABLE sse4_flags)
+      if(sse4_flags)
+        draco_set_compiler_flags_for_sources(SOURCES ${sse4_sources} FLAGS
+                                               ${sse4_flags})
+      endif()
+    endif()
+  endif()
+
+  if(DRACO_ENABLE_NEON AND draco_have_neon)
+    unset(neon_sources)
+    list(APPEND neon_sources ${arg_SOURCES})
+    list(FILTER neon_sources INCLUDE REGEX
+         "${draco_neon_source_file_suffix}$")
+
+    if(neon_sources AND DRACO_NEON_INTRINSICS_FLAG)
+      unset(neon_flags)
+      draco_get_intrinsics_flag_for_suffix(SUFFIX
+                                             ${draco_neon_source_file_suffix}
+                                             VARIABLE neon_flags)
+      if(neon_flags)
+        draco_set_compiler_flags_for_sources(SOURCES ${neon_sources} FLAGS
+                                               ${neon_flags})
+      endif()
+    endif()
+  endif()
+endmacro()
diff --git a/contrib/draco/cmake/draco_options.cmake b/contrib/draco/cmake/draco_options.cmake
new file mode 100644
index 000000000..832bfb69f
--- /dev/null
+++ b/contrib/draco/cmake/draco_options.cmake
@@ -0,0 +1,239 @@
+if(DRACO_CMAKE_DRACO_OPTIONS_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_OPTIONS_CMAKE_
+set(DRACO_CMAKE_DRACO_OPTIONS_CMAKE_)
+
+set(draco_features_file_name "${draco_build}/draco/draco_features.h")
+set(draco_features_list)
+
+# Simple wrapper for CMake's builtin option command that tracks draco's build
+# options in the list variable $draco_options.
+macro(draco_option)
+  unset(option_NAME)
+  unset(option_HELPSTRING)
+  unset(option_VALUE)
+  unset(optional_args)
+  unset(multi_value_args)
+  set(single_value_args NAME HELPSTRING VALUE)
+  cmake_parse_arguments(option "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(NOT (option_NAME AND option_HELPSTRING AND DEFINED option_VALUE))
+    message(FATAL_ERROR "draco_option: NAME HELPSTRING and VALUE required.")
+  endif()
+
+  option(${option_NAME} ${option_HELPSTRING} ${option_VALUE})
+
+  if(DRACO_VERBOSE GREATER 2)
+    message("--------- draco_option ---------\n" "option_NAME=${option_NAME}\n"
+            "option_HELPSTRING=${option_HELPSTRING}\n"
+            "option_VALUE=${option_VALUE}\n"
+            "------------------------------------------\n")
+  endif()
+
+  list(APPEND draco_options ${option_NAME})
+  list(REMOVE_DUPLICATES draco_options)
+endmacro()
+
+# Dumps the $draco_options list via CMake message command.
+macro(draco_dump_options)
+  foreach(option_name ${draco_options})
+    message("${option_name}: ${${option_name}}")
+  endforeach()
+endmacro()
+
+# Set default options.
+macro(draco_set_default_options)
+  draco_option(NAME DRACO_FAST HELPSTRING "Try to build faster libs." VALUE OFF)
+  draco_option(NAME DRACO_JS_GLUE HELPSTRING
+               "Enable JS Glue and JS targets when using Emscripten." VALUE ON)
+  draco_option(NAME DRACO_IE_COMPATIBLE HELPSTRING
+               "Enable support for older IE builds when using Emscripten." VALUE
+               OFF)
+  draco_option(NAME DRACO_MESH_COMPRESSION HELPSTRING "Enable mesh compression."
+               VALUE ON)
+  draco_option(NAME DRACO_POINT_CLOUD_COMPRESSION HELPSTRING
+               "Enable point cloud compression." VALUE ON)
+  draco_option(NAME DRACO_PREDICTIVE_EDGEBREAKER HELPSTRING
+               "Enable predictive edgebreaker." VALUE ON)
+  draco_option(NAME DRACO_STANDARD_EDGEBREAKER HELPSTRING
+               "Enable stand edgebreaker." VALUE ON)
+  draco_option(NAME DRACO_BACKWARDS_COMPATIBILITY HELPSTRING
+               "Enable backwards compatibility." VALUE ON)
+  draco_option(NAME DRACO_DECODER_ATTRIBUTE_DEDUPLICATION HELPSTRING
+               "Enable attribute deduping." VALUE OFF)
+  draco_option(NAME DRACO_TESTS HELPSTRING "Enables tests." VALUE OFF)
+  draco_option(NAME DRACO_WASM HELPSTRING "Enables WASM support." VALUE OFF)
+  draco_option(NAME DRACO_UNITY_PLUGIN HELPSTRING
+               "Build plugin library for Unity." VALUE OFF)
+  draco_option(NAME DRACO_ANIMATION_ENCODING HELPSTRING "Enable animation."
+               VALUE OFF)
+  draco_option(NAME DRACO_GLTF HELPSTRING "Support GLTF." VALUE OFF)
+  draco_option(NAME DRACO_MAYA_PLUGIN HELPSTRING
+               "Build plugin library for Maya." VALUE OFF)
+  draco_check_deprecated_options()
+endmacro()
+
+# Warns when a deprecated option is used and sets the option that replaced it.
+macro(draco_handle_deprecated_option)
+  unset(option_OLDNAME)
+  unset(option_NEWNAME)
+  unset(optional_args)
+  unset(multi_value_args)
+  set(single_value_args OLDNAME NEWNAME)
+  cmake_parse_arguments(option "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if("${${option_OLDNAME}}")
+    message(WARNING "${option_OLDNAME} is deprecated. Use ${option_NEWNAME}.")
+    set(${option_NEWNAME} ${${option_OLDNAME}})
+  endif()
+endmacro()
+
+# Checks for use of deprecated options.
+macro(draco_check_deprecated_options)
+  draco_handle_deprecated_option(OLDNAME ENABLE_EXTRA_SPEED NEWNAME DRACO_FAST)
+  draco_handle_deprecated_option(OLDNAME ENABLE_JS_GLUE NEWNAME DRACO_JS_GLUE)
+  draco_handle_deprecated_option(OLDNAME ENABLE_MESH_COMPRESSION NEWNAME
+                                 DRACO_MESH_COMPRESSION)
+  draco_handle_deprecated_option(OLDNAME ENABLE_POINT_CLOUD_COMPRESSION NEWNAME
+                                 DRACO_POINT_CLOUD_COMPRESSION)
+  draco_handle_deprecated_option(OLDNAME ENABLE_PREDICTIVE_EDGEBREAKER NEWNAME
+                                 DRACO_PREDICTIVE_EDGEBREAKER)
+  draco_handle_deprecated_option(OLDNAME ENABLE_STANDARD_EDGEBREAKER NEWNAME
+                                 DRACO_STANDARD_EDGEBREAKER)
+  draco_handle_deprecated_option(OLDNAME ENABLE_BACKWARDS_COMPATIBILITY NEWNAME
+                                 DRACO_BACKWARDS_COMPATIBILITY)
+  draco_handle_deprecated_option(OLDNAME ENABLE_DECODER_ATTRIBUTE_DEDUPLICATION
+                                 NEWNAME DRACO_DECODER_ATTRIBUTE_DEDUPLICATION)
+  draco_handle_deprecated_option(OLDNAME ENABLE_TESTS NEWNAME DRACO_TESTS)
+  draco_handle_deprecated_option(OLDNAME ENABLE_WASM NEWNAME DRACO_WASM)
+  draco_handle_deprecated_option(OLDNAME BUILD_UNITY_PLUGIN NEWNAME
+                                 DRACO_UNITY_PLUGIN)
+  draco_handle_deprecated_option(OLDNAME BUILD_ANIMATION_ENCODING NEWNAME
+                                 DRACO_ANIMATION_ENCODING)
+  draco_handle_deprecated_option(OLDNAME BUILD_FOR_GLTF NEWNAME DRACO_GLTF)
+  draco_handle_deprecated_option(OLDNAME BUILD_MAYA_PLUGIN NEWNAME
+                                 DRACO_MAYA_PLUGIN)
+  draco_handle_deprecated_option(OLDNAME BUILD_USD_PLUGIN NEWNAME
+                                 BUILD_SHARED_LIBS)
+
+endmacro()
+
+# Macro for setting Draco features based on user configuration. Features enabled
+# by this macro are Draco global.
+macro(draco_set_optional_features)
+  if(DRACO_GLTF)
+    # Override settings when building for GLTF.
+    draco_enable_feature(FEATURE "DRACO_MESH_COMPRESSION_SUPPORTED")
+    draco_enable_feature(FEATURE "DRACO_NORMAL_ENCODING_SUPPORTED")
+    draco_enable_feature(FEATURE "DRACO_STANDARD_EDGEBREAKER_SUPPORTED")
+  else()
+    if(DRACO_POINT_CLOUD_COMPRESSION)
+      draco_enable_feature(FEATURE "DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED")
+    endif()
+    if(DRACO_MESH_COMPRESSION)
+      draco_enable_feature(FEATURE "DRACO_MESH_COMPRESSION_SUPPORTED")
+      draco_enable_feature(FEATURE "DRACO_NORMAL_ENCODING_SUPPORTED")
+
+      if(DRACO_STANDARD_EDGEBREAKER)
+        draco_enable_feature(FEATURE "DRACO_STANDARD_EDGEBREAKER_SUPPORTED")
+      endif()
+      if(DRACO_PREDICTIVE_EDGEBREAKER)
+        draco_enable_feature(FEATURE "DRACO_PREDICTIVE_EDGEBREAKER_SUPPORTED")
+      endif()
+    endif()
+
+    if(DRACO_BACKWARDS_COMPATIBILITY)
+      draco_enable_feature(FEATURE "DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED")
+    endif()
+
+
+    if(NOT EMSCRIPTEN)
+      # For now, enable deduplication for both encoder and decoder.
+      # TODO(ostava): Support for disabling attribute deduplication for the C++
+      # decoder is planned in future releases.
+      draco_enable_feature(FEATURE
+                           DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED)
+      draco_enable_feature(FEATURE
+                           DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED)
+    endif()
+  endif()
+
+  if(DRACO_UNITY_PLUGIN)
+    draco_enable_feature(FEATURE "DRACO_UNITY_PLUGIN")
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+  endif()
+
+  if(DRACO_MAYA_PLUGIN)
+    draco_enable_feature(FEATURE "DRACO_MAYA_PLUGIN")
+    set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+  endif()
+
+endmacro()
+
+# Macro that handles tracking of Draco preprocessor symbols for the purpose of
+# producing draco_features.h.
+#
+# ~~~
+# draco_enable_feature(FEATURE <feature_name> [TARGETS <target_name>])
+# ~~~
+#
+# FEATURE  is required. It should be a Draco preprocessor symbol. TARGETS is
+# optional. It can be one or more draco targets.
+#
+# When the TARGETS argument is not present the preproc symbol is added to
+# draco_features.h. When it is draco_features.h is unchanged, and
+# target_compile_options() is called for each target specified.
+macro(draco_enable_feature)
+  set(def_flags)
+  set(def_single_arg_opts FEATURE)
+  set(def_multi_arg_opts TARGETS)
+  cmake_parse_arguments(DEF "${def_flags}" "${def_single_arg_opts}"
+                        "${def_multi_arg_opts}" ${ARGN})
+  if("${DEF_FEATURE}" STREQUAL "")
+    message(FATAL_ERROR "Empty FEATURE passed to draco_enable_feature().")
+  endif()
+
+  # Do nothing/return early if $DEF_FEATURE is already in the list.
+  list(FIND draco_features_list ${DEF_FEATURE} df_index)
+  if(NOT df_index EQUAL -1)
+    return()
+  endif()
+
+  list(LENGTH DEF_TARGETS df_targets_list_length)
+  if(${df_targets_list_length} EQUAL 0)
+    list(APPEND draco_features_list ${DEF_FEATURE})
+  else()
+    foreach(target ${DEF_TARGETS})
+      target_compile_definitions(${target} PRIVATE ${DEF_FEATURE})
+    endforeach()
+  endif()
+endmacro()
+
+# Function for generating draco_features.h.
+function(draco_generate_features_h)
+  file(WRITE "${draco_features_file_name}.new"
+       "// GENERATED FILE -- DO NOT EDIT\n\n" "#ifndef DRACO_FEATURES_H_\n"
+       "#define DRACO_FEATURES_H_\n\n")
+
+  foreach(feature ${draco_features_list})
+    file(APPEND "${draco_features_file_name}.new" "#define ${feature}\n")
+  endforeach()
+
+  file(APPEND "${draco_features_file_name}.new"
+       "\n#endif  // DRACO_FEATURES_H_")
+
+  # Will replace ${draco_features_file_name} only if the file content has
+  # changed. This prevents forced Draco rebuilds after CMake runs.
+  configure_file("${draco_features_file_name}.new"
+                 "${draco_features_file_name}")
+  file(REMOVE "${draco_features_file_name}.new")
+endfunction()
+
+# Sets default options for the build and processes user controlled options to
+# compute enabled features.
+macro(draco_setup_options)
+  draco_set_default_options()
+  draco_set_optional_features()
+endmacro()
diff --git a/contrib/draco/cmake/draco_sanitizer.cmake b/contrib/draco/cmake/draco_sanitizer.cmake
new file mode 100644
index 000000000..ca8e23176
--- /dev/null
+++ b/contrib/draco/cmake/draco_sanitizer.cmake
@@ -0,0 +1,32 @@
+if(DRACO_CMAKE_DRACO_SANITIZER_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_SANITIZER_CMAKE_
+set(DRACO_CMAKE_DRACO_SANITIZER_CMAKE_ 1)
+
+# Handles the details of enabling sanitizers.
+macro(draco_configure_sanitizer)
+  if(DRACO_SANITIZE AND NOT MSVC)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+      if(DRACO_SANITIZE MATCHES "cfi")
+        list(APPEND DRACO_CXX_FLAGS "-flto" "-fno-sanitize-trap=cfi")
+        list(APPEND DRACO_EXE_LINKER_FLAGS "-flto" "-fno-sanitize-trap=cfi"
+                    "-fuse-ld=gold")
+      endif()
+
+      if(${CMAKE_SIZEOF_VOID_P} EQUAL 4
+         AND DRACO_SANITIZE MATCHES "integer|undefined")
+        list(APPEND DRACO_EXE_LINKER_FLAGS "--rtlib=compiler-rt" "-lgcc_s")
+      endif()
+    endif()
+
+    list(APPEND DRACO_CXX_FLAGS "-fsanitize=${DRACO_SANITIZE}")
+    list(APPEND DRACO_EXE_LINKER_FLAGS "-fsanitize=${DRACO_SANITIZE}")
+
+    # Make sanitizer callstacks accurate.
+    list(APPEND DRACO_CXX_FLAGS "-fno-omit-frame-pointer"
+                "-fno-optimize-sibling-calls")
+
+    draco_test_cxx_flag(FLAG_LIST_VAR_NAMES DRACO_CXX_FLAGS FLAG_REQUIRED)
+    draco_test_exe_linker_flag(FLAG_LIST_VAR_NAME DRACO_EXE_LINKER_FLAGS)
+  endif()
+endmacro()
diff --git a/contrib/draco/cmake/draco_targets.cmake b/contrib/draco/cmake/draco_targets.cmake
new file mode 100644
index 000000000..6dfa6a0c4
--- /dev/null
+++ b/contrib/draco/cmake/draco_targets.cmake
@@ -0,0 +1,349 @@
+if(DRACO_CMAKE_DRACO_TARGETS_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_TARGETS_CMAKE_
+set(DRACO_CMAKE_DRACO_TARGETS_CMAKE_ 1)
+
+# Resets list variables used to track draco targets.
+macro(draco_reset_target_lists)
+  unset(draco_targets)
+  unset(draco_exe_targets)
+  unset(draco_lib_targets)
+  unset(draco_objlib_targets)
+  unset(draco_module_targets)
+  unset(draco_sources)
+  unset(draco_test_targets)
+endmacro()
+
+# Creates an executable target. The target name is passed as a parameter to the
+# NAME argument, and the sources passed as a parameter to the SOURCES argument:
+# draco_add_executable(NAME <name> SOURCES <sources> [optional args])
+#
+# Optional args:
+# cmake-format: off
+#   - OUTPUT_NAME: Override output file basename. Target basename defaults to
+#     NAME.
+#   - TEST: Flag. Presence means treat executable as a test.
+#   - DEFINES: List of preprocessor macro definitions.
+#   - INCLUDES: list of include directories for the target.
+#   - COMPILE_FLAGS: list of compiler flags for the target.
+#   - LINK_FLAGS: List of linker flags for the target.
+#   - OBJLIB_DEPS: List of CMake object library target dependencies.
+#   - LIB_DEPS: List of CMake library dependencies.
+# cmake-format: on
+#
+# Sources passed to this macro are added to $draco_test_sources when TEST is
+# specified. Otherwise sources are added to $draco_sources.
+#
+# Targets passed to this macro are always added to the $draco_targets list. When
+# TEST is specified targets are also added to the $draco_test_targets list.
+# Otherwise targets are added to $draco_exe_targets.
+macro(draco_add_executable)
+  unset(exe_TEST)
+  unset(exe_TEST_DEFINES_MAIN)
+  unset(exe_NAME)
+  unset(exe_OUTPUT_NAME)
+  unset(exe_SOURCES)
+  unset(exe_DEFINES)
+  unset(exe_INCLUDES)
+  unset(exe_COMPILE_FLAGS)
+  unset(exe_LINK_FLAGS)
+  unset(exe_OBJLIB_DEPS)
+  unset(exe_LIB_DEPS)
+  set(optional_args TEST)
+  set(single_value_args NAME OUTPUT_NAME)
+  set(multi_value_args SOURCES DEFINES INCLUDES COMPILE_FLAGS LINK_FLAGS
+                       OBJLIB_DEPS LIB_DEPS)
+
+  cmake_parse_arguments(exe "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(DRACO_VERBOSE GREATER 1)
+    message("--------- draco_add_executable ---------\n"
+            "exe_TEST=${exe_TEST}\n"
+            "exe_TEST_DEFINES_MAIN=${exe_TEST_DEFINES_MAIN}\n"
+            "exe_NAME=${exe_NAME}\n"
+            "exe_OUTPUT_NAME=${exe_OUTPUT_NAME}\n"
+            "exe_SOURCES=${exe_SOURCES}\n"
+            "exe_DEFINES=${exe_DEFINES}\n"
+            "exe_INCLUDES=${exe_INCLUDES}\n"
+            "exe_COMPILE_FLAGS=${exe_COMPILE_FLAGS}\n"
+            "exe_LINK_FLAGS=${exe_LINK_FLAGS}\n"
+            "exe_OBJLIB_DEPS=${exe_OBJLIB_DEPS}\n"
+            "exe_LIB_DEPS=${exe_LIB_DEPS}\n"
+            "------------------------------------------\n")
+  endif()
+
+  if(NOT (exe_NAME AND exe_SOURCES))
+    message(FATAL_ERROR "draco_add_executable: NAME and SOURCES required.")
+  endif()
+
+  list(APPEND draco_targets ${exe_NAME})
+  if(exe_TEST)
+    list(APPEND draco_test_targets ${exe_NAME})
+    list(APPEND draco_test_sources ${exe_SOURCES})
+  else()
+    list(APPEND draco_exe_targets ${exe_NAME})
+    list(APPEND draco_sources ${exe_SOURCES})
+  endif()
+
+  add_executable(${exe_NAME} ${exe_SOURCES})
+
+  if(exe_OUTPUT_NAME)
+    set_target_properties(${exe_NAME} PROPERTIES OUTPUT_NAME ${exe_OUTPUT_NAME})
+  endif()
+
+  draco_process_intrinsics_sources(TARGET ${exe_NAME} SOURCES ${exe_SOURCES})
+
+  if(exe_DEFINES)
+    target_compile_definitions(${exe_NAME} PRIVATE ${exe_DEFINES})
+  endif()
+
+  if(exe_INCLUDES)
+    target_include_directories(${exe_NAME} PRIVATE ${exe_INCLUDES})
+  endif()
+
+  if(exe_COMPILE_FLAGS OR DRACO_CXX_FLAGS)
+    target_compile_options(${exe_NAME}
+                           PRIVATE ${exe_COMPILE_FLAGS} ${DRACO_CXX_FLAGS})
+  endif()
+
+  if(exe_LINK_FLAGS OR DRACO_EXE_LINKER_FLAGS)
+    if(${CMAKE_VERSION} VERSION_LESS "3.13")
+      set(link_flags ${exe_LINK_FLAGS} ${DRACO_EXE_LINKER_FLAGS})
+      set_target_properties(${exe_NAME}
+                            PROPERTIES LINK_FLAGS ${exe_LINK_FLAGS}
+                                       ${DRACO_EXE_LINKER_FLAGS})
+    else()
+      target_link_options(${exe_NAME} PRIVATE ${exe_LINK_FLAGS}
+                          ${DRACO_EXE_LINKER_FLAGS})
+    endif()
+  endif()
+
+  if(exe_OBJLIB_DEPS)
+    foreach(objlib_dep ${exe_OBJLIB_DEPS})
+      target_sources(${exe_NAME} PRIVATE $<TARGET_OBJECTS:${objlib_dep}>)
+    endforeach()
+  endif()
+
+  if(CMAKE_THREAD_LIBS_INIT)
+    list(APPEND exe_LIB_DEPS ${CMAKE_THREAD_LIBS_INIT})
+  endif()
+
+  if(BUILD_SHARED_LIBS AND (MSVC OR WIN32))
+    target_compile_definitions(${lib_NAME} PRIVATE "DRACO_BUILDING_DLL=0")
+  endif()
+
+  if(exe_LIB_DEPS)
+    unset(exe_static)
+    if("${CMAKE_EXE_LINKER_FLAGS} ${DRACO_EXE_LINKER_FLAGS}" MATCHES "static")
+      set(exe_static ON)
+    endif()
+
+    if(exe_static AND CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+      # Third party dependencies can introduce dependencies on system and test
+      # libraries. Since the target created here is an executable, and CMake
+      # does not provide a method of controlling order of link dependencies,
+      # wrap all of the dependencies of this target in start/end group flags to
+      # ensure that dependencies of third party targets can be resolved when
+      # those dependencies happen to be resolved by dependencies of the current
+      # target.
+      list(INSERT exe_LIB_DEPS 0 -Wl,--start-group)
+      list(APPEND exe_LIB_DEPS -Wl,--end-group)
+    endif()
+    target_link_libraries(${exe_NAME} PRIVATE ${exe_LIB_DEPS})
+  endif()
+endmacro()
+
+# Creates a library target of the specified type. The target name is passed as a
+# parameter to the NAME argument, the type as a parameter to the TYPE argument,
+# and the sources passed as a parameter to the SOURCES argument:
+# draco_add_library(NAME <name> TYPE <type> SOURCES <sources> [optional args])
+#
+# Optional args:
+# cmake-format: off
+#   - OUTPUT_NAME: Override output file basename. Target basename defaults to
+#     NAME. OUTPUT_NAME is ignored when BUILD_SHARED_LIBS is enabled and CMake
+#     is generating a build for which MSVC or WIN32 are true. This is to avoid
+#     output basename collisions with DLL import libraries.
+#   - TEST: Flag. Presence means treat library as a test.
+#   - DEFINES: List of preprocessor macro definitions.
+#   - INCLUDES: list of include directories for the target.
+#   - COMPILE_FLAGS: list of compiler flags for the target.
+#   - LINK_FLAGS: List of linker flags for the target.
+#   - OBJLIB_DEPS: List of CMake object library target dependencies.
+#   - LIB_DEPS: List of CMake library dependencies.
+#   - PUBLIC_INCLUDES: List of include paths to export to dependents.
+# cmake-format: on
+#
+# Sources passed to the macro are added to the lists tracking draco sources:
+# cmake-format: off
+#   - When TEST is specified sources are added to $draco_test_sources.
+#   - Otherwise sources are added to $draco_sources.
+# cmake-format: on
+#
+# Targets passed to this macro are added to the lists tracking draco targets:
+# cmake-format: off
+#   - Targets are always added to $draco_targets.
+#   - When the TEST flag is specified, targets are added to
+#     $draco_test_targets.
+#   - When TEST is not specified:
+#     - Libraries of type SHARED are added to $draco_dylib_targets.
+#     - Libraries of type OBJECT are added to $draco_objlib_targets.
+#     - Libraries of type STATIC are added to $draco_lib_targets.
+# cmake-format: on
+macro(draco_add_library)
+  unset(lib_TEST)
+  unset(lib_NAME)
+  unset(lib_OUTPUT_NAME)
+  unset(lib_TYPE)
+  unset(lib_SOURCES)
+  unset(lib_DEFINES)
+  unset(lib_INCLUDES)
+  unset(lib_COMPILE_FLAGS)
+  unset(lib_LINK_FLAGS)
+  unset(lib_OBJLIB_DEPS)
+  unset(lib_LIB_DEPS)
+  unset(lib_PUBLIC_INCLUDES)
+  unset(lib_TARGET_PROPERTIES)
+  set(optional_args TEST)
+  set(single_value_args NAME OUTPUT_NAME TYPE)
+  set(multi_value_args SOURCES DEFINES INCLUDES COMPILE_FLAGS LINK_FLAGS
+                       OBJLIB_DEPS LIB_DEPS PUBLIC_INCLUDES TARGET_PROPERTIES)
+
+  cmake_parse_arguments(lib "${optional_args}" "${single_value_args}"
+                        "${multi_value_args}" ${ARGN})
+
+  if(DRACO_VERBOSE GREATER 1)
+    message("--------- draco_add_library ---------\n"
+            "lib_TEST=${lib_TEST}\n"
+            "lib_NAME=${lib_NAME}\n"
+            "lib_OUTPUT_NAME=${lib_OUTPUT_NAME}\n"
+            "lib_TYPE=${lib_TYPE}\n"
+            "lib_SOURCES=${lib_SOURCES}\n"
+            "lib_DEFINES=${lib_DEFINES}\n"
+            "lib_INCLUDES=${lib_INCLUDES}\n"
+            "lib_COMPILE_FLAGS=${lib_COMPILE_FLAGS}\n"
+            "lib_LINK_FLAGS=${lib_LINK_FLAGS}\n"
+            "lib_OBJLIB_DEPS=${lib_OBJLIB_DEPS}\n"
+            "lib_LIB_DEPS=${lib_LIB_DEPS}\n"
+            "lib_PUBLIC_INCLUDES=${lib_PUBLIC_INCLUDES}\n"
+            "---------------------------------------\n")
+  endif()
+
+  if(NOT (lib_NAME AND lib_TYPE))
+    message(FATAL_ERROR "draco_add_library: NAME and TYPE required.")
+  endif()
+
+  list(APPEND draco_targets ${lib_NAME})
+  if(lib_TEST)
+    list(APPEND draco_test_targets ${lib_NAME})
+    list(APPEND draco_test_sources ${lib_SOURCES})
+  else()
+    list(APPEND draco_sources ${lib_SOURCES})
+    if(lib_TYPE STREQUAL MODULE)
+      list(APPEND draco_module_targets ${lib_NAME})
+    elseif(lib_TYPE STREQUAL OBJECT)
+      list(APPEND draco_objlib_targets ${lib_NAME})
+    elseif(lib_TYPE STREQUAL SHARED)
+      list(APPEND draco_dylib_targets ${lib_NAME})
+    elseif(lib_TYPE STREQUAL STATIC)
+      list(APPEND draco_lib_targets ${lib_NAME})
+    else()
+      message(WARNING "draco_add_library: Unhandled type: ${lib_TYPE}")
+    endif()
+  endif()
+
+  add_library(${lib_NAME} ${lib_TYPE} ${lib_SOURCES})
+  if(lib_SOURCES)
+    draco_process_intrinsics_sources(TARGET ${lib_NAME} SOURCES ${lib_SOURCES})
+  endif()
+
+  if(lib_OUTPUT_NAME)
+    if(NOT (BUILD_SHARED_LIBS AND (MSVC OR WIN32)))
+      set_target_properties(${lib_NAME}
+                            PROPERTIES OUTPUT_NAME ${lib_OUTPUT_NAME})
+    endif()
+  endif()
+
+  if(lib_DEFINES)
+    target_compile_definitions(${lib_NAME} PRIVATE ${lib_DEFINES})
+  endif()
+
+  if(lib_INCLUDES)
+    target_include_directories(${lib_NAME} PRIVATE ${lib_INCLUDES})
+  endif()
+
+  if(lib_PUBLIC_INCLUDES)
+    target_include_directories(${lib_NAME} PUBLIC ${lib_PUBLIC_INCLUDES})
+  endif()
+
+  if(lib_COMPILE_FLAGS OR DRACO_CXX_FLAGS)
+    target_compile_options(${lib_NAME}
+                           PRIVATE ${lib_COMPILE_FLAGS} ${DRACO_CXX_FLAGS})
+  endif()
+
+  if(lib_LINK_FLAGS)
+    set_target_properties(${lib_NAME} PROPERTIES LINK_FLAGS ${lib_LINK_FLAGS})
+  endif()
+
+  if(lib_OBJLIB_DEPS)
+    foreach(objlib_dep ${lib_OBJLIB_DEPS})
+      target_sources(${lib_NAME} PRIVATE $<TARGET_OBJECTS:${objlib_dep}>)
+    endforeach()
+  endif()
+
+  if(lib_LIB_DEPS)
+    if(lib_TYPE STREQUAL STATIC)
+      set(link_type PUBLIC)
+    else()
+      set(link_type PRIVATE)
+      if(lib_TYPE STREQUAL SHARED AND CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+        # The draco shared object uses the static draco as input to turn it into
+        # a shared object. Include everything from the static library in the
+        # shared object.
+        if(APPLE)
+          list(INSERT lib_LIB_DEPS 0 -Wl,-force_load)
+        else()
+          list(INSERT lib_LIB_DEPS 0 -Wl,--whole-archive)
+          list(APPEND lib_LIB_DEPS -Wl,--no-whole-archive)
+        endif()
+      endif()
+    endif()
+    target_link_libraries(${lib_NAME} ${link_type} ${lib_LIB_DEPS})
+  endif()
+
+  if(NOT MSVC AND lib_NAME MATCHES "^lib")
+    # Non-MSVC generators prepend lib to static lib target file names. Libdraco
+    # already includes lib in its name. Avoid naming output files liblib*.
+    set_target_properties(${lib_NAME} PROPERTIES PREFIX "")
+  endif()
+
+  if(lib_TYPE STREQUAL SHARED AND NOT MSVC)
+    set_target_properties(${lib_NAME} PROPERTIES SOVERSION ${DRACO_SOVERSION})
+  endif()
+
+  if(BUILD_SHARED_LIBS AND (MSVC OR WIN32))
+    if(lib_TYPE STREQUAL SHARED)
+      target_compile_definitions(${lib_NAME} PRIVATE "DRACO_BUILDING_DLL=1")
+    else()
+      target_compile_definitions(${lib_NAME} PRIVATE "DRACO_BUILDING_DLL=0")
+    endif()
+  endif()
+
+  # Determine if $lib_NAME is a header only target.
+  unset(sources_list)
+  if(lib_SOURCES)
+    set(sources_list ${lib_SOURCES})
+    list(FILTER sources_list INCLUDE REGEX cc$)
+  endif()
+
+  if(NOT sources_list)
+    if(NOT XCODE)
+      # This is a header only target. Tell CMake the link language.
+      set_target_properties(${lib_NAME} PROPERTIES LINKER_LANGUAGE CXX)
+    else()
+      # The Xcode generator ignores LINKER_LANGUAGE. Add a dummy cc file.
+      draco_create_dummy_source_file(TARGET ${lib_NAME} BASENAME ${lib_NAME})
+    endif()
+  endif()
+endmacro()
diff --git a/contrib/draco/cmake/draco_test_config.h.cmake b/contrib/draco/cmake/draco_test_config.h.cmake
new file mode 100644
index 000000000..77a574123
--- /dev/null
+++ b/contrib/draco/cmake/draco_test_config.h.cmake
@@ -0,0 +1,13 @@
+#ifndef DRACO_TESTING_DRACO_TEST_CONFIG_H_
+#define DRACO_TESTING_DRACO_TEST_CONFIG_H_
+
+// If this file is named draco_test_config.h.cmake:
+// This file is used as input at cmake generation time.
+
+// If this file is named draco_test_config.h:
+// GENERATED FILE, DO NOT EDIT. SEE ABOVE.
+
+#define DRACO_TEST_DATA_DIR "${DRACO_TEST_DATA_DIR}"
+#define DRACO_TEST_TEMP_DIR "${DRACO_TEST_TEMP_DIR}"
+
+#endif  // DRACO_TESTING_DRACO_TEST_CONFIG_H_
diff --git a/contrib/draco/cmake/draco_tests.cmake b/contrib/draco/cmake/draco_tests.cmake
new file mode 100644
index 000000000..a6dfc5b57
--- /dev/null
+++ b/contrib/draco/cmake/draco_tests.cmake
@@ -0,0 +1,133 @@
+if(DRACO_CMAKE_DRACO_TESTS_CMAKE)
+  return()
+endif()
+set(DRACO_CMAKE_DRACO_TESTS_CMAKE 1)
+
+# The factory tests are in a separate target to avoid breaking tests that rely
+# on file I/O via the factories. The fake reader and writer implementations
+# interfere with normal file I/O function.
+set(draco_factory_test_sources
+    "${draco_src_root}/io/file_reader_factory_test.cc"
+    "${draco_src_root}/io/file_writer_factory_test.cc")
+
+list(
+  APPEND
+    draco_test_sources
+    "${draco_src_root}/animation/keyframe_animation_encoding_test.cc"
+    "${draco_src_root}/animation/keyframe_animation_test.cc"
+    "${draco_src_root}/attributes/point_attribute_test.cc"
+    "${draco_src_root}/compression/attributes/point_d_vector_test.cc"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_test.cc"
+    "${draco_src_root}/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_test.cc"
+    "${draco_src_root}/compression/attributes/sequential_integer_attribute_encoding_test.cc"
+    "${draco_src_root}/compression/bit_coders/rans_coding_test.cc"
+    "${draco_src_root}/compression/decode_test.cc"
+    "${draco_src_root}/compression/encode_test.cc"
+    "${draco_src_root}/compression/entropy/shannon_entropy_test.cc"
+    "${draco_src_root}/compression/entropy/symbol_coding_test.cc"
+    "${draco_src_root}/compression/mesh/mesh_edgebreaker_encoding_test.cc"
+    "${draco_src_root}/compression/mesh/mesh_encoder_test.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_kd_tree_encoding_test.cc"
+    "${draco_src_root}/compression/point_cloud/point_cloud_sequential_encoding_test.cc"
+    "${draco_src_root}/core/buffer_bit_coding_test.cc"
+    "${draco_src_root}/core/draco_test_base.h"
+    "${draco_src_root}/core/draco_test_utils.cc"
+    "${draco_src_root}/core/draco_test_utils.h"
+    "${draco_src_root}/core/math_utils_test.cc"
+    "${draco_src_root}/core/quantization_utils_test.cc"
+    "${draco_src_root}/core/status_test.cc"
+    "${draco_src_root}/core/vector_d_test.cc"
+    "${draco_src_root}/io/file_reader_test_common.h"
+    "${draco_src_root}/io/file_utils_test.cc"
+    "${draco_src_root}/io/stdio_file_reader_test.cc"
+    "${draco_src_root}/io/stdio_file_writer_test.cc"
+    "${draco_src_root}/io/obj_decoder_test.cc"
+    "${draco_src_root}/io/obj_encoder_test.cc"
+    "${draco_src_root}/io/ply_decoder_test.cc"
+    "${draco_src_root}/io/ply_reader_test.cc"
+    "${draco_src_root}/io/point_cloud_io_test.cc"
+    "${draco_src_root}/mesh/mesh_are_equivalent_test.cc"
+    "${draco_src_root}/mesh/mesh_cleanup_test.cc"
+    "${draco_src_root}/mesh/triangle_soup_mesh_builder_test.cc"
+    "${draco_src_root}/metadata/metadata_encoder_test.cc"
+    "${draco_src_root}/metadata/metadata_test.cc"
+    "${draco_src_root}/point_cloud/point_cloud_builder_test.cc"
+    "${draco_src_root}/point_cloud/point_cloud_test.cc")
+
+list(APPEND draco_gtest_all
+            "${draco_root}/../googletest/googletest/src/gtest-all.cc")
+list(APPEND draco_gtest_main
+            "${draco_root}/../googletest/googletest/src/gtest_main.cc")
+
+macro(draco_setup_test_targets)
+  if(DRACO_TESTS)
+    if(NOT (EXISTS ${draco_gtest_all} AND EXISTS ${draco_gtest_main}))
+      message(FATAL "googletest must be a sibling directory of ${draco_root}.")
+    endif()
+
+    list(APPEND draco_test_defines GTEST_HAS_PTHREAD=0)
+
+    draco_add_library(TEST
+                      NAME
+                      draco_gtest
+                      TYPE
+                      STATIC
+                      SOURCES
+                      ${draco_gtest_all}
+                      DEFINES
+                      ${draco_defines}
+                      ${draco_test_defines}
+                      INCLUDES
+                      ${draco_test_include_paths})
+
+    draco_add_library(TEST
+                      NAME
+                      draco_gtest_main
+                      TYPE
+                      STATIC
+                      SOURCES
+                      ${draco_gtest_main}
+                      DEFINES
+                      ${draco_defines}
+                      ${draco_test_defines}
+                      INCLUDES
+                      ${draco_test_include_paths})
+
+    set(DRACO_TEST_DATA_DIR "${draco_root}/testdata")
+    set(DRACO_TEST_TEMP_DIR "${draco_build}/draco_test_temp")
+    file(MAKE_DIRECTORY "${DRACO_TEST_TEMP_DIR}")
+
+    # Sets DRACO_TEST_DATA_DIR and DRACO_TEST_TEMP_DIR.
+    configure_file("${draco_root}/cmake/draco_test_config.h.cmake"
+                   "${draco_build}/testing/draco_test_config.h")
+
+    # Create the test targets.
+    draco_add_executable(NAME
+                         draco_tests
+                         SOURCES
+                         ${draco_test_sources}
+                         DEFINES
+                         ${draco_defines}
+                         ${draco_test_defines}
+                         INCLUDES
+                         ${draco_test_include_paths}
+                         LIB_DEPS
+                         draco_static
+                         draco_gtest
+                         draco_gtest_main)
+
+    draco_add_executable(NAME
+                         draco_factory_tests
+                         SOURCES
+                         ${draco_factory_test_sources}
+                         DEFINES
+                         ${draco_defines}
+                         ${draco_test_defines}
+                         INCLUDES
+                         ${draco_test_include_paths}
+                         LIB_DEPS
+                         draco_static
+                         draco_gtest
+                         draco_gtest_main)
+  endif()
+endmacro()
diff --git a/contrib/draco/cmake/draco_variables.cmake b/contrib/draco/cmake/draco_variables.cmake
new file mode 100644
index 000000000..8dbc77a53
--- /dev/null
+++ b/contrib/draco/cmake/draco_variables.cmake
@@ -0,0 +1,64 @@
+if(DRACO_CMAKE_DRACO_VARIABLES_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_DRACO_VARIABLES_CMAKE_
+set(DRACO_CMAKE_DRACO_VARIABLES_CMAKE_ 1)
+
+# Halts generation when $variable_name does not refer to a directory that
+# exists.
+macro(draco_variable_must_be_directory variable_name)
+  if("${variable_name}" STREQUAL "")
+    message(
+      FATAL_ERROR
+        "Empty variable_name passed to draco_variable_must_be_directory.")
+  endif()
+
+  if("${${variable_name}}" STREQUAL "")
+    message(
+      FATAL_ERROR
+        "Empty variable ${variable_name} is required to build draco.")
+  endif()
+
+  if(NOT IS_DIRECTORY "${${variable_name}}")
+    message(
+      FATAL_ERROR
+        "${variable_name}, which is ${${variable_name}}, does not refer to a\n"
+        "directory.")
+  endif()
+endmacro()
+
+# Adds $var_name to the tracked variables list.
+macro(draco_track_configuration_variable var_name)
+  if(DRACO_VERBOSE GREATER 2)
+    message("---- draco_track_configuration_variable ----\n"
+            "var_name=${var_name}\n"
+            "----------------------------------------------\n")
+  endif()
+
+  list(APPEND draco_configuration_variables ${var_name})
+  list(REMOVE_DUPLICATES draco_configuration_variables)
+endmacro()
+
+# Logs current C++ and executable linker flags via the CMake message command.
+macro(draco_dump_cmake_flag_variables)
+  unset(flag_variables)
+  list(APPEND flag_variables "CMAKE_CXX_FLAGS_INIT" "CMAKE_CXX_FLAGS"
+              "CMAKE_EXE_LINKER_FLAGS_INIT" "CMAKE_EXE_LINKER_FLAGS")
+  if(CMAKE_BUILD_TYPE)
+    list(APPEND flag_variables "CMAKE_BUILD_TYPE"
+                "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}_INIT"
+                "CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}"
+                "CMAKE_EXE_LINKER_FLAGS_${CMAKE_BUILD_TYPE}_INIT"
+                "CMAKE_EXE_LINKER_FLAGS_${CMAKE_BUILD_TYPE}")
+  endif()
+  foreach(flag_variable ${flag_variables})
+    message("${flag_variable}:${${flag_variable}}")
+  endforeach()
+endmacro()
+
+# Dumps the variables tracked in $draco_configuration_variables via the CMake
+# message command.
+macro(draco_dump_tracked_configuration_variables)
+  foreach(config_variable ${draco_configuration_variables})
+    message("${config_variable}:${${config_variable}}")
+  endforeach()
+endmacro()
diff --git a/contrib/draco/cmake/sanitizers.cmake b/contrib/draco/cmake/sanitizers.cmake
new file mode 100644
index 000000000..e720bc045
--- /dev/null
+++ b/contrib/draco/cmake/sanitizers.cmake
@@ -0,0 +1,19 @@
+if(DRACO_CMAKE_SANITIZERS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_SANITIZERS_CMAKE_ 1)
+
+if(MSVC OR NOT SANITIZE)
+  return()
+endif()
+
+include("${draco_root}/cmake/compiler_flags.cmake")
+
+string(TOLOWER ${SANITIZE} SANITIZE)
+
+# Require the sanitizer requested.
+require_linker_flag("-fsanitize=${SANITIZE}")
+require_compiler_flag("-fsanitize=${SANITIZE}" YES)
+
+# Make callstacks accurate.
+require_compiler_flag("-fno-omit-frame-pointer -fno-optimize-sibling-calls" YES)
diff --git a/contrib/draco/cmake/toolchains/aarch64-linux-gnu.cmake b/contrib/draco/cmake/toolchains/aarch64-linux-gnu.cmake
new file mode 100644
index 000000000..87e0b4a45
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/aarch64-linux-gnu.cmake
@@ -0,0 +1,14 @@
+if(DRACO_CMAKE_TOOLCHAINS_AARCH64_LINUX_GNU_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_TOOLCHAINS_AARCH64_LINUX_GNU_CMAKE_
+set(DRACO_CMAKE_TOOLCHAINS_AARCH64_LINUX_GNU_CMAKE_ 1)
+
+set(CMAKE_SYSTEM_NAME "Linux")
+
+if("${CROSS}" STREQUAL "")
+  set(CROSS aarch64-linux-gnu-)
+endif()
+
+set(CMAKE_CXX_COMPILER ${CROSS}g++)
+set(CMAKE_CXX_FLAGS_INIT "-march=armv8-a")
+set(CMAKE_SYSTEM_PROCESSOR "aarch64")
diff --git a/contrib/draco/cmake/toolchains/android-ndk-common.cmake b/contrib/draco/cmake/toolchains/android-ndk-common.cmake
new file mode 100644
index 000000000..5126d6e29
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/android-ndk-common.cmake
@@ -0,0 +1,23 @@
+if(DRACO_CMAKE_TOOLCHAINS_ANDROID_NDK_COMMON_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ANDROID_NDK_COMMON_CMAKE_ 1)
+
+# Toolchain files do not have access to cached variables:
+# https://gitlab.kitware.com/cmake/cmake/issues/16170. Set an intermediate
+# environment variable when loaded the first time.
+if(DRACO_ANDROID_NDK_PATH)
+  set(ENV{DRACO_ANDROID_NDK_PATH} "${DRACO_ANDROID_NDK_PATH}")
+else()
+  set(DRACO_ANDROID_NDK_PATH "$ENV{DRACO_ANDROID_NDK_PATH}")
+endif()
+
+set(CMAKE_SYSTEM_NAME Android)
+
+if(NOT CMAKE_ANDROID_STL_TYPE)
+  set(CMAKE_ANDROID_STL_TYPE c++_static)
+endif()
+
+if(NOT CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION)
+  set(CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION clang)
+endif()
diff --git a/contrib/draco/cmake/toolchains/android.cmake b/contrib/draco/cmake/toolchains/android.cmake
new file mode 100644
index 000000000..b8f576d5e
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/android.cmake
@@ -0,0 +1,39 @@
+if(DRACO_CMAKE_TOOLCHAINS_ANDROID_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_TOOLCHAINS_ANDROID_CMAKE_
+
+# Additional ANDROID_* settings are available, see:
+# https://developer.android.com/ndk/guides/cmake#variables
+
+if(NOT ANDROID_PLATFORM)
+  set(ANDROID_PLATFORM android-21)
+endif()
+
+# Choose target architecture with:
+#
+# -DANDROID_ABI={armeabi-v7a,armeabi-v7a with NEON,arm64-v8a,x86,x86_64}
+if(NOT ANDROID_ABI)
+  set(ANDROID_ABI arm64-v8a)
+endif()
+
+# Force arm mode for 32-bit targets (instead of the default thumb) to improve
+# performance.
+if(NOT ANDROID_ARM_MODE)
+  set(ANDROID_ARM_MODE arm)
+endif()
+
+# Toolchain files do not have access to cached variables:
+# https://gitlab.kitware.com/cmake/cmake/issues/16170. Set an intermediate
+# environment variable when loaded the first time.
+if(DRACO_ANDROID_NDK_PATH)
+  set(ENV{DRACO_ANDROID_NDK_PATH} "${DRACO_ANDROID_NDK_PATH}")
+else()
+  set(DRACO_ANDROID_NDK_PATH "$ENV{DRACO_ANDROID_NDK_PATH}")
+endif()
+
+if(NOT DRACO_ANDROID_NDK_PATH)
+  message(FATAL_ERROR "DRACO_ANDROID_NDK_PATH not set.")
+  return()
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/contrib/draco/cmake/toolchains/arm-ios-common.cmake b/contrib/draco/cmake/toolchains/arm-ios-common.cmake
new file mode 100644
index 000000000..65326d1c2
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/arm-ios-common.cmake
@@ -0,0 +1,17 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM_IOS_COMMON_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_ARM_IOS_COMMON_CMAKE_ 1)
+
+set(CMAKE_SYSTEM_NAME "Darwin")
+if(CMAKE_OSX_SDK)
+  set(CMAKE_OSX_SYSROOT ${CMAKE_OSX_SDK})
+else()
+  set(CMAKE_OSX_SYSROOT iphoneos)
+endif()
+set(CMAKE_C_COMPILER clang)
+set(CMAKE_C_COMPILER_ARG1 "-arch ${CMAKE_SYSTEM_PROCESSOR}")
+set(CMAKE_CXX_COMPILER clang++)
+set(CMAKE_CXX_COMPILER_ARG1 "-arch ${CMAKE_SYSTEM_PROCESSOR}")
+
+# TODO(tomfinegan): Handle bit code embedding.
diff --git a/contrib/draco/cmake/toolchains/arm-linux-gnueabihf.cmake b/contrib/draco/cmake/toolchains/arm-linux-gnueabihf.cmake
new file mode 100644
index 000000000..6e45969e9
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/arm-linux-gnueabihf.cmake
@@ -0,0 +1,15 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM_LINUX_GNUEABIHF_CMAKE_)
+  return()
+endif() # DRACO_CMAKE_TOOLCHAINS_ARM_LINUX_GNUEABIHF_CMAKE_
+set(DRACO_CMAKE_TOOLCHAINS_ARM_LINUX_GNUEABIHF_CMAKE_ 1)
+
+set(CMAKE_SYSTEM_NAME "Linux")
+
+if("${CROSS}" STREQUAL "")
+  set(CROSS arm-linux-gnueabihf-)
+endif()
+
+set(CMAKE_CXX_COMPILER ${CROSS}g++)
+set(CMAKE_CXX_FLAGS_INIT "-march=armv7-a -marm")
+set(CMAKE_SYSTEM_PROCESSOR "armv7")
+set(DRACO_NEON_INTRINSICS_FLAG "-mfpu=neon")
diff --git a/contrib/draco/cmake/toolchains/arm64-android-ndk-libcpp.cmake b/contrib/draco/cmake/toolchains/arm64-android-ndk-libcpp.cmake
new file mode 100644
index 000000000..4b6d366f0
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/arm64-android-ndk-libcpp.cmake
@@ -0,0 +1,16 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM64_ANDROID_NDK_LIBCPP_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARM64_ANDROID_NDK_LIBCPP_CMAKE_ 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/android-ndk-common.cmake")
+
+if(NOT ANDROID_PLATFORM)
+  set(ANROID_PLATFORM android-21)
+endif()
+
+if(NOT ANDROID_ABI)
+  set(ANDROID_ABI arm64-v8a)
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/contrib/draco/cmake/toolchains/arm64-ios.cmake b/contrib/draco/cmake/toolchains/arm64-ios.cmake
new file mode 100644
index 000000000..c4ec7e3fa
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/arm64-ios.cmake
@@ -0,0 +1,14 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM64_IOS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARM64_IOS_CMAKE_ 1)
+
+if(XCODE)
+  # TODO(tomfinegan): Handle arm builds in Xcode.
+  message(FATAL_ERROR "This toolchain does not support Xcode.")
+endif()
+
+set(CMAKE_SYSTEM_PROCESSOR "arm64")
+set(CMAKE_OSX_ARCHITECTURES "arm64")
+
+include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
diff --git a/contrib/draco/cmake/toolchains/arm64-linux-gcc.cmake b/contrib/draco/cmake/toolchains/arm64-linux-gcc.cmake
new file mode 100644
index 000000000..046ff0139
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/arm64-linux-gcc.cmake
@@ -0,0 +1,18 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARM64_LINUX_GCC_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARM64_LINUX_GCC_CMAKE_ 1)
+
+set(CMAKE_SYSTEM_NAME "Linux")
+
+if("${CROSS}" STREQUAL "")
+  # Default the cross compiler prefix to something known to work.
+  set(CROSS aarch64-linux-gnu-)
+endif()
+
+set(CMAKE_C_COMPILER ${CROSS}gcc)
+set(CMAKE_CXX_COMPILER ${CROSS}g++)
+set(AS_EXECUTABLE ${CROSS}as)
+set(CMAKE_C_COMPILER_ARG1 "-march=armv8-a")
+set(CMAKE_CXX_COMPILER_ARG1 "-march=armv8-a")
+set(CMAKE_SYSTEM_PROCESSOR "arm64")
diff --git a/contrib/draco/cmake/toolchains/armv7-android-ndk-libcpp.cmake b/contrib/draco/cmake/toolchains/armv7-android-ndk-libcpp.cmake
new file mode 100644
index 000000000..80ee98b18
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/armv7-android-ndk-libcpp.cmake
@@ -0,0 +1,16 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARMV7_ANDROID_NDK_LIBCPP_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARMV7_ANDROID_NDK_LIBCPP_CMAKE_ 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/android-ndk-common.cmake")
+
+if(NOT ANDROID_PLATFORM)
+  set(ANDROID_PLATFORM android-18)
+endif()
+
+if(NOT ANDROID_ABI)
+  set(ANDROID_ABI armeabi-v7a)
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/contrib/draco/cmake/toolchains/armv7-ios.cmake b/contrib/draco/cmake/toolchains/armv7-ios.cmake
new file mode 100644
index 000000000..8ddd6997b
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/armv7-ios.cmake
@@ -0,0 +1,14 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARMV7_IOS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARMV7_IOS_CMAKE_ 1)
+
+if(XCODE)
+  # TODO(tomfinegan): Handle arm builds in Xcode.
+  message(FATAL_ERROR "This toolchain does not support Xcode.")
+endif()
+
+set(CMAKE_SYSTEM_PROCESSOR "armv7")
+set(CMAKE_OSX_ARCHITECTURES "armv7")
+
+include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
diff --git a/contrib/draco/cmake/toolchains/armv7-linux-gcc.cmake b/contrib/draco/cmake/toolchains/armv7-linux-gcc.cmake
new file mode 100644
index 000000000..9c9472319
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/armv7-linux-gcc.cmake
@@ -0,0 +1,24 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARMV7_LINUX_GCC_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARMV7_LINUX_GCC_CMAKE_ 1)
+
+set(CMAKE_SYSTEM_NAME "Linux")
+
+if("${CROSS}" STREQUAL "")
+  # Default the cross compiler prefix to something known to work.
+  set(CROSS arm-linux-gnueabihf-)
+endif()
+
+if(NOT ${CROSS} MATCHES hf-$)
+  set(DRACO_EXTRA_TOOLCHAIN_FLAGS "-mfloat-abi=softfp")
+endif()
+
+set(CMAKE_C_COMPILER ${CROSS}gcc)
+set(CMAKE_CXX_COMPILER ${CROSS}g++)
+set(AS_EXECUTABLE ${CROSS}as)
+set(CMAKE_C_COMPILER_ARG1
+    "-march=armv7-a -mfpu=neon ${DRACO_EXTRA_TOOLCHAIN_FLAGS}")
+set(CMAKE_CXX_COMPILER_ARG1
+    "-march=armv7-a -mfpu=neon ${DRACO_EXTRA_TOOLCHAIN_FLAGS}")
+set(CMAKE_SYSTEM_PROCESSOR "armv7")
diff --git a/contrib/draco/cmake/toolchains/armv7s-ios.cmake b/contrib/draco/cmake/toolchains/armv7s-ios.cmake
new file mode 100644
index 000000000..b433025ba
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/armv7s-ios.cmake
@@ -0,0 +1,14 @@
+if(DRACO_CMAKE_TOOLCHAINS_ARMV7S_IOS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_ARMV7S_IOS_CMAKE_ 1)
+
+if(XCODE)
+  # TODO(tomfinegan): Handle arm builds in Xcode.
+  message(FATAL_ERROR "This toolchain does not support Xcode.")
+endif()
+
+set(CMAKE_SYSTEM_PROCESSOR "armv7s")
+set(CMAKE_OSX_ARCHITECTURES "armv7s")
+
+include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
diff --git a/contrib/draco/cmake/toolchains/i386-ios.cmake b/contrib/draco/cmake/toolchains/i386-ios.cmake
new file mode 100644
index 000000000..e9a105591
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/i386-ios.cmake
@@ -0,0 +1,15 @@
+if(DRACO_CMAKE_TOOLCHAINS_i386_IOS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_i386_IOS_CMAKE_ 1)
+
+if(XCODE)
+  # TODO(tomfinegan): Handle arm builds in Xcode.
+  message(FATAL_ERROR "This toolchain does not support Xcode.")
+endif()
+
+set(CMAKE_SYSTEM_PROCESSOR "i386")
+set(CMAKE_OSX_ARCHITECTURES "i386")
+set(CMAKE_OSX_SDK "iphonesimulator")
+
+include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
diff --git a/contrib/draco/cmake/toolchains/x86-android-ndk-libcpp.cmake b/contrib/draco/cmake/toolchains/x86-android-ndk-libcpp.cmake
new file mode 100644
index 000000000..d43383640
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/x86-android-ndk-libcpp.cmake
@@ -0,0 +1,16 @@
+if(DRACO_CMAKE_TOOLCHAINS_X86_ANDROID_NDK_LIBCPP_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_X86_ANDROID_NDK_LIBCPP_CMAKE_ 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/android-ndk-common.cmake")
+
+if(NOT ANDROID_PLATFORM)
+  set(ANDROID_PLATFORM android-18)
+endif()
+
+if(NOT ANDROID_ABI)
+  set(ANDROID_ABI x86)
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/contrib/draco/cmake/toolchains/x86_64-android-ndk-libcpp.cmake b/contrib/draco/cmake/toolchains/x86_64-android-ndk-libcpp.cmake
new file mode 100644
index 000000000..d6fabeacc
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/x86_64-android-ndk-libcpp.cmake
@@ -0,0 +1,16 @@
+if(DRACO_CMAKE_TOOLCHAINS_X86_64_ANDROID_NDK_LIBCPP_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_X86_64_ANDROID_NDK_LIBCPP_CMAKE_ 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/android-ndk-common.cmake")
+
+if(NOT ANDROID_PLATFORM)
+  set(ANDROID_PLATFORM android-21)
+endif()
+
+if(NOT ANDROID_ABI)
+  set(ANDROID_ABI x86_64)
+endif()
+
+include("${DRACO_ANDROID_NDK_PATH}/build/cmake/android.toolchain.cmake")
diff --git a/contrib/draco/cmake/toolchains/x86_64-ios.cmake b/contrib/draco/cmake/toolchains/x86_64-ios.cmake
new file mode 100644
index 000000000..4c50a72a2
--- /dev/null
+++ b/contrib/draco/cmake/toolchains/x86_64-ios.cmake
@@ -0,0 +1,15 @@
+if(DRACO_CMAKE_TOOLCHAINS_X86_64_IOS_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_TOOLCHAINS_X86_64_IOS_CMAKE_ 1)
+
+if(XCODE)
+  # TODO(tomfinegan): Handle arm builds in Xcode.
+  message(FATAL_ERROR "This toolchain does not support Xcode.")
+endif()
+
+set(CMAKE_SYSTEM_PROCESSOR "x86_64")
+set(CMAKE_OSX_ARCHITECTURES "x86_64")
+set(CMAKE_OSX_SDK "iphonesimulator")
+
+include("${CMAKE_CURRENT_LIST_DIR}/arm-ios-common.cmake")
diff --git a/contrib/draco/cmake/util.cmake b/contrib/draco/cmake/util.cmake
new file mode 100644
index 000000000..813146a62
--- /dev/null
+++ b/contrib/draco/cmake/util.cmake
@@ -0,0 +1,79 @@
+if(DRACO_CMAKE_UTIL_CMAKE_)
+  return()
+endif()
+set(DRACO_CMAKE_UTIL_CMAKE_ 1)
+
+# Creates dummy source file in $draco_build_dir named $basename.$extension and
+# returns the full path to the dummy source file via the $out_file_path
+# parameter.
+function(create_dummy_source_file basename extension out_file_path)
+  set(dummy_source_file "${draco_build_dir}/${basename}.${extension}")
+  file(WRITE "${dummy_source_file}.new"
+       "// Generated file. DO NOT EDIT!\n"
+       "// ${target_name} needs a ${extension} file to force link language, \n"
+       "// or to silence a harmless CMake warning: Ignore me.\n"
+       "void ${target_name}_dummy_function(void) {}\n")
+
+  # Will replace ${dummy_source_file} only if the file content has changed.
+  # This prevents forced Draco rebuilds after CMake runs.
+  configure_file("${dummy_source_file}.new" "${dummy_source_file}")
+  file(REMOVE "${dummy_source_file}.new")
+
+  set(${out_file_path} ${dummy_source_file} PARENT_SCOPE)
+endfunction()
+
+# Convenience function for adding a dummy source file to $target_name using
+# $extension as the file extension. Wraps create_dummy_source_file().
+function(add_dummy_source_file_to_target target_name extension)
+  create_dummy_source_file("${target_name}" "${extension}" "dummy_source_file")
+  target_sources(${target_name} PRIVATE ${dummy_source_file})
+endfunction()
+
+# Extracts the version number from $version_file and returns it to the user via
+# $version_string_out_var. This is achieved by finding the first instance of the
+# kDracoVersion variable and then removing everything but the string literal
+# assigned to the variable. Quotes and semicolon are stripped from the returned
+# string.
+function(extract_version_string version_file version_string_out_var)
+  file(STRINGS "${version_file}" draco_version REGEX "kDracoVersion")
+  list(GET draco_version 0 draco_version)
+  string(REPLACE "static const char kDracoVersion[] = " "" draco_version
+                 "${draco_version}")
+  string(REPLACE ";" "" draco_version "${draco_version}")
+  string(REPLACE "\"" "" draco_version "${draco_version}")
+  set("${version_string_out_var}" "${draco_version}" PARENT_SCOPE)
+endfunction()
+
+# Sets CMake compiler launcher to $launcher_name when $launcher_name is found in
+# $PATH. Warns user about ignoring build flag $launcher_flag when $launcher_name
+# is not found in $PATH.
+function(set_compiler_launcher launcher_flag launcher_name)
+  find_program(launcher_path "${launcher_name}")
+  if(launcher_path)
+    set(CMAKE_C_COMPILER_LAUNCHER "${launcher_path}" PARENT_SCOPE)
+    set(CMAKE_CXX_COMPILER_LAUNCHER "${launcher_path}" PARENT_SCOPE)
+    message("--- Using ${launcher_name} as compiler launcher.")
+  else()
+    message(
+      WARNING "--- Cannot find ${launcher_name}, ${launcher_flag} ignored.")
+  endif()
+endfunction()
+
+# Terminates CMake execution when $var_name is unset in the environment. Sets
+# CMake variable to the value of the environment variable when the variable is
+# present in the environment.
+macro(require_variable var_name)
+  if("$ENV{${var_name}}" STREQUAL "")
+    message(FATAL_ERROR "${var_name} must be set in environment.")
+  endif()
+  set_variable_if_unset(${var_name} "")
+endmacro()
+
+# Sets $var_name to $default_value if not already set.
+macro(set_variable_if_unset var_name default_value)
+  if(NOT "$ENV{${var_name}}" STREQUAL "")
+    set(${var_name} $ENV{${var_name}})
+  elseif(NOT ${var_name})
+    set(${var_name} ${default_value})
+  endif()
+endmacro()
diff --git a/contrib/draco/src/draco/animation/keyframe_animation.cc b/contrib/draco/src/draco/animation/keyframe_animation.cc
new file mode 100644
index 000000000..eaf94a330
--- /dev/null
+++ b/contrib/draco/src/draco/animation/keyframe_animation.cc
@@ -0,0 +1,54 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/animation/keyframe_animation.h"
+
+namespace draco {
+
+KeyframeAnimation::KeyframeAnimation() {}
+
+bool KeyframeAnimation::SetTimestamps(
+    const std::vector<TimestampType> &timestamp) {
+  // Already added attributes.
+  const int32_t num_frames = timestamp.size();
+  if (num_attributes() > 0) {
+    // Timestamp attribute could be added only once.
+    if (timestamps()->size()) {
+      return false;
+    } else {
+      // Check if the number of frames is consistent with
+      // the existing keyframes.
+      if (num_frames != num_points()) {
+        return false;
+      }
+    }
+  } else {
+    // This is the first attribute.
+    set_num_frames(num_frames);
+  }
+
+  // Add attribute for time stamp data.
+  std::unique_ptr<PointAttribute> timestamp_att =
+      std::unique_ptr<PointAttribute>(new PointAttribute());
+  timestamp_att->Init(GeometryAttribute::GENERIC, 1, DT_FLOAT32, false,
+                      num_frames);
+  for (PointIndex i(0); i < num_frames; ++i) {
+    timestamp_att->SetAttributeValue(timestamp_att->mapped_index(i),
+                                     &timestamp[i.value()]);
+  }
+  this->SetAttribute(kTimestampId, std::move(timestamp_att));
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/animation/keyframe_animation.h b/contrib/draco/src/draco/animation/keyframe_animation.h
new file mode 100644
index 000000000..a7afb2b81
--- /dev/null
+++ b/contrib/draco/src/draco/animation/keyframe_animation.h
@@ -0,0 +1,107 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ANIMATION_KEYFRAME_ANIMATION_H_
+#define DRACO_ANIMATION_KEYFRAME_ANIMATION_H_
+
+#include <vector>
+
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Class for holding keyframe animation data. It will have two or more
+// attributes as a point cloud. The first attribute is always the timestamp
+// of the animation. Each KeyframeAnimation could have multiple animations with
+// the same number of frames. Each animation will be treated as a point
+// attribute.
+class KeyframeAnimation : public PointCloud {
+ public:
+  // Force time stamp to be float type.
+  using TimestampType = float;
+
+  KeyframeAnimation();
+
+  // Animation must have only one timestamp attribute.
+  // This function must be called before adding any animation data.
+  // Returns false if timestamp already exists.
+  bool SetTimestamps(const std::vector<TimestampType> &timestamp);
+
+  // Returns an id for the added animation data. This id will be used to
+  // identify this animation.
+  // Returns -1 if error, e.g. number of frames is not consistent.
+  // Type |T| should be consistent with |DataType|, e.g:
+  //    float - DT_FLOAT32,
+  //    int32_t - DT_INT32, ...
+  template <typename T>
+  int32_t AddKeyframes(DataType data_type, uint32_t num_components,
+                       const std::vector<T> &data);
+
+  const PointAttribute *timestamps() const {
+    return GetAttributeByUniqueId(kTimestampId);
+  }
+  const PointAttribute *keyframes(int32_t animation_id) const {
+    return GetAttributeByUniqueId(animation_id);
+  }
+
+  // Number of frames should be equal to number points in the point cloud.
+  void set_num_frames(int32_t num_frames) { set_num_points(num_frames); }
+  int32_t num_frames() const { return static_cast<int32_t>(num_points()); }
+
+  int32_t num_animations() const { return num_attributes() - 1; }
+
+ private:
+  // Attribute id of timestamp is fixed to 0.
+  static constexpr int32_t kTimestampId = 0;
+};
+
+template <typename T>
+int32_t KeyframeAnimation::AddKeyframes(DataType data_type,
+                                        uint32_t num_components,
+                                        const std::vector<T> &data) {
+  // TODO(draco-eng): Verify T is consistent with |data_type|.
+  if (num_components == 0) {
+    return -1;
+  }
+  // If timestamps is not added yet, then reserve attribute 0 for timestamps.
+  if (!num_attributes()) {
+    // Add a temporary attribute with 0 points to fill attribute id 0.
+    std::unique_ptr<PointAttribute> temp_att =
+        std::unique_ptr<PointAttribute>(new PointAttribute());
+    temp_att->Init(GeometryAttribute::GENERIC, num_components, data_type, false,
+                   0);
+    this->AddAttribute(std::move(temp_att));
+
+    set_num_frames(data.size() / num_components);
+  }
+
+  if (data.size() != num_components * num_frames()) {
+    return -1;
+  }
+
+  std::unique_ptr<PointAttribute> keyframe_att =
+      std::unique_ptr<PointAttribute>(new PointAttribute());
+  keyframe_att->Init(GeometryAttribute::GENERIC, num_components, data_type,
+                     false, num_frames());
+  const size_t stride = num_components;
+  for (PointIndex i(0); i < num_frames(); ++i) {
+    keyframe_att->SetAttributeValue(keyframe_att->mapped_index(i),
+                                    &data[i.value() * stride]);
+  }
+  return this->AddAttribute(std::move(keyframe_att));
+}
+
+}  // namespace draco
+
+#endif  // DRACO_ANIMATION_KEYFRAME_ANIMATION_H_
diff --git a/contrib/draco/src/draco/animation/keyframe_animation_decoder.cc b/contrib/draco/src/draco/animation/keyframe_animation_decoder.cc
new file mode 100644
index 000000000..20659468d
--- /dev/null
+++ b/contrib/draco/src/draco/animation/keyframe_animation_decoder.cc
@@ -0,0 +1,30 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/animation/keyframe_animation_decoder.h"
+
+namespace draco {
+
+Status KeyframeAnimationDecoder::Decode(const DecoderOptions &options,
+                                        DecoderBuffer *in_buffer,
+                                        KeyframeAnimation *animation) {
+  const auto status = PointCloudSequentialDecoder::Decode(
+      options, in_buffer, static_cast<PointCloud *>(animation));
+  if (!status.ok()) {
+    return status;
+  }
+  return OkStatus();
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/animation/keyframe_animation_decoder.h b/contrib/draco/src/draco/animation/keyframe_animation_decoder.h
new file mode 100644
index 000000000..fdf086b3a
--- /dev/null
+++ b/contrib/draco/src/draco/animation/keyframe_animation_decoder.h
@@ -0,0 +1,34 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ANIMATION_KEYFRAME_ANIMATION_DECODER_H_
+#define DRACO_ANIMATION_KEYFRAME_ANIMATION_DECODER_H_
+
+#include "draco/animation/keyframe_animation.h"
+#include "draco/compression/point_cloud/point_cloud_sequential_decoder.h"
+
+namespace draco {
+
+// Class for decoding keyframe animation.
+class KeyframeAnimationDecoder : private PointCloudSequentialDecoder {
+ public:
+  KeyframeAnimationDecoder(){};
+
+  Status Decode(const DecoderOptions &options, DecoderBuffer *in_buffer,
+                KeyframeAnimation *animation);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ANIMATION_KEYFRAME_ANIMATION_DECODER_H_
diff --git a/contrib/draco/src/draco/animation/keyframe_animation_encoder.cc b/contrib/draco/src/draco/animation/keyframe_animation_encoder.cc
new file mode 100644
index 000000000..f7d84f310
--- /dev/null
+++ b/contrib/draco/src/draco/animation/keyframe_animation_encoder.cc
@@ -0,0 +1,28 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/animation/keyframe_animation_encoder.h"
+
+namespace draco {
+
+KeyframeAnimationEncoder::KeyframeAnimationEncoder() {}
+
+Status KeyframeAnimationEncoder::EncodeKeyframeAnimation(
+    const KeyframeAnimation &animation, const EncoderOptions &options,
+    EncoderBuffer *out_buffer) {
+  SetPointCloud(animation);
+  return Encode(options, out_buffer);
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/animation/keyframe_animation_encoder.h b/contrib/draco/src/draco/animation/keyframe_animation_encoder.h
new file mode 100644
index 000000000..6096c79fa
--- /dev/null
+++ b/contrib/draco/src/draco/animation/keyframe_animation_encoder.h
@@ -0,0 +1,39 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ANIMATION_KEYFRAME_ANIMATION_ENCODER_H_
+#define DRACO_ANIMATION_KEYFRAME_ANIMATION_ENCODER_H_
+
+#include "draco/animation/keyframe_animation.h"
+#include "draco/compression/point_cloud/point_cloud_sequential_encoder.h"
+
+namespace draco {
+
+// Class for encoding keyframe animation. It takes KeyframeAnimation as a
+// PointCloud and compress it. It's mostly a wrapper around PointCloudEncoder so
+// that the animation module could be separated from geometry compression when
+// exposed to developers.
+class KeyframeAnimationEncoder : private PointCloudSequentialEncoder {
+ public:
+  KeyframeAnimationEncoder();
+
+  // Encode an animation to a buffer.
+  Status EncodeKeyframeAnimation(const KeyframeAnimation &animation,
+                                 const EncoderOptions &options,
+                                 EncoderBuffer *out_buffer);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ANIMATION_KEYFRAME_ANIMATION_ENCODER_H_
diff --git a/contrib/draco/src/draco/animation/keyframe_animation_encoding_test.cc b/contrib/draco/src/draco/animation/keyframe_animation_encoding_test.cc
new file mode 100644
index 000000000..4a6491f9d
--- /dev/null
+++ b/contrib/draco/src/draco/animation/keyframe_animation_encoding_test.cc
@@ -0,0 +1,168 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/animation/keyframe_animation.h"
+#include "draco/animation/keyframe_animation_decoder.h"
+#include "draco/animation/keyframe_animation_encoder.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+
+namespace draco {
+
+class KeyframeAnimationEncodingTest : public ::testing::Test {
+ protected:
+  KeyframeAnimationEncodingTest() {}
+
+  bool CreateAndAddTimestamps(int32_t num_frames) {
+    timestamps_.resize(num_frames);
+    for (int i = 0; i < timestamps_.size(); ++i)
+      timestamps_[i] = static_cast<draco::KeyframeAnimation::TimestampType>(i);
+    return keyframe_animation_.SetTimestamps(timestamps_);
+  }
+
+  int32_t CreateAndAddAnimationData(int32_t num_frames,
+                                    uint32_t num_components) {
+    // Create and add animation data with.
+    animation_data_.resize(num_frames * num_components);
+    for (int i = 0; i < animation_data_.size(); ++i)
+      animation_data_[i] = static_cast<float>(i);
+    return keyframe_animation_.AddKeyframes(draco::DT_FLOAT32, num_components,
+                                            animation_data_);
+  }
+
+  template <int num_components_t>
+  void CompareAnimationData(const KeyframeAnimation &animation0,
+                            const KeyframeAnimation &animation1,
+                            bool quantized) {
+    ASSERT_EQ(animation0.num_frames(), animation1.num_frames());
+    ASSERT_EQ(animation0.num_animations(), animation1.num_animations());
+
+    if (quantized) {
+      // TODO(hemmer) : Add test for stable quantization.
+      // Quantization will result in slightly different values.
+      // Skip comparing values.
+      return;
+    }
+
+    // Compare time stamp.
+    const auto timestamp_att0 = animation0.timestamps();
+    const auto timestamp_att1 = animation0.timestamps();
+    for (int i = 0; i < animation0.num_frames(); ++i) {
+      std::array<float, 1> att_value0;
+      std::array<float, 1> att_value1;
+      ASSERT_TRUE((timestamp_att0->GetValue<float, 1>(
+          draco::AttributeValueIndex(i), &att_value0)));
+      ASSERT_TRUE((timestamp_att1->GetValue<float, 1>(
+          draco::AttributeValueIndex(i), &att_value1)));
+      ASSERT_FLOAT_EQ(att_value0[0], att_value1[0]);
+    }
+
+    for (int animation_id = 1; animation_id < animation0.num_animations();
+         ++animation_id) {
+      // Compare keyframe data.
+      const auto keyframe_att0 = animation0.keyframes(animation_id);
+      const auto keyframe_att1 = animation1.keyframes(animation_id);
+      ASSERT_EQ(keyframe_att0->num_components(),
+                keyframe_att1->num_components());
+      for (int i = 0; i < animation0.num_frames(); ++i) {
+        std::array<float, num_components_t> att_value0;
+        std::array<float, num_components_t> att_value1;
+        ASSERT_TRUE((keyframe_att0->GetValue<float, num_components_t>(
+            draco::AttributeValueIndex(i), &att_value0)));
+        ASSERT_TRUE((keyframe_att1->GetValue<float, num_components_t>(
+            draco::AttributeValueIndex(i), &att_value1)));
+        for (int j = 0; j < att_value0.size(); ++j) {
+          ASSERT_FLOAT_EQ(att_value0[j], att_value1[j]);
+        }
+      }
+    }
+  }
+
+  template <int num_components_t>
+  void TestKeyframeAnimationEncoding() {
+    TestKeyframeAnimationEncoding<num_components_t>(false);
+  }
+
+  template <int num_components_t>
+  void TestKeyframeAnimationEncoding(bool quantized) {
+    // Encode animation class.
+    draco::EncoderBuffer buffer;
+    draco::KeyframeAnimationEncoder encoder;
+    EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+    if (quantized) {
+      // Set quantization for timestamps.
+      options.SetAttributeInt(0, "quantization_bits", 20);
+      // Set quantization for keyframes.
+      for (int i = 1; i <= keyframe_animation_.num_animations(); ++i) {
+        options.SetAttributeInt(i, "quantization_bits", 20);
+      }
+    }
+
+    ASSERT_TRUE(
+        encoder.EncodeKeyframeAnimation(keyframe_animation_, options, &buffer)
+            .ok());
+
+    draco::DecoderBuffer dec_decoder;
+    draco::KeyframeAnimationDecoder decoder;
+    DecoderBuffer dec_buffer;
+    dec_buffer.Init(buffer.data(), buffer.size());
+
+    // Decode animation class.
+    std::unique_ptr<KeyframeAnimation> decoded_animation(
+        new KeyframeAnimation());
+    DecoderOptions dec_options;
+    ASSERT_TRUE(
+        decoder.Decode(dec_options, &dec_buffer, decoded_animation.get()).ok());
+
+    // Verify if animation before and after compression is identical.
+    CompareAnimationData<num_components_t>(keyframe_animation_,
+                                           *decoded_animation, quantized);
+  }
+
+  draco::KeyframeAnimation keyframe_animation_;
+  std::vector<draco::KeyframeAnimation::TimestampType> timestamps_;
+  std::vector<float> animation_data_;
+};
+
+TEST_F(KeyframeAnimationEncodingTest, OneComponent) {
+  const int num_frames = 1;
+  ASSERT_TRUE(CreateAndAddTimestamps(num_frames));
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 1), 1);
+  TestKeyframeAnimationEncoding<1>();
+}
+
+TEST_F(KeyframeAnimationEncodingTest, ManyComponents) {
+  const int num_frames = 100;
+  ASSERT_TRUE(CreateAndAddTimestamps(num_frames));
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 100), 1);
+  TestKeyframeAnimationEncoding<100>();
+}
+
+TEST_F(KeyframeAnimationEncodingTest, ManyComponentsWithQuantization) {
+  const int num_frames = 100;
+  ASSERT_TRUE(CreateAndAddTimestamps(num_frames));
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 4), 1);
+  // Test compression with quantization.
+  TestKeyframeAnimationEncoding<4>(true);
+}
+
+TEST_F(KeyframeAnimationEncodingTest, MultipleAnimations) {
+  const int num_frames = 5;
+  ASSERT_TRUE(CreateAndAddTimestamps(num_frames));
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 3), 1);
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 3), 2);
+  TestKeyframeAnimationEncoding<3>();
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/animation/keyframe_animation_test.cc b/contrib/draco/src/draco/animation/keyframe_animation_test.cc
new file mode 100644
index 000000000..bc92b25ff
--- /dev/null
+++ b/contrib/draco/src/draco/animation/keyframe_animation_test.cc
@@ -0,0 +1,102 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/animation/keyframe_animation.h"
+
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+class KeyframeAnimationTest : public ::testing::Test {
+ protected:
+  KeyframeAnimationTest() {}
+
+  bool CreateAndAddTimestamps(int32_t num_frames) {
+    timestamps_.resize(num_frames);
+    for (int i = 0; i < timestamps_.size(); ++i)
+      timestamps_[i] = static_cast<draco::KeyframeAnimation::TimestampType>(i);
+    return keyframe_animation_.SetTimestamps(timestamps_);
+  }
+
+  int32_t CreateAndAddAnimationData(int32_t num_frames,
+                                    uint32_t num_components) {
+    // Create and add animation data with.
+    animation_data_.resize(num_frames * num_components);
+    for (int i = 0; i < animation_data_.size(); ++i)
+      animation_data_[i] = static_cast<float>(i);
+    return keyframe_animation_.AddKeyframes(draco::DT_FLOAT32, num_components,
+                                            animation_data_);
+  }
+
+  template <int num_components_t>
+  void CompareAnimationData() {
+    // Compare time stamp.
+    const auto timestamp_att = keyframe_animation_.timestamps();
+    for (int i = 0; i < timestamps_.size(); ++i) {
+      std::array<float, 1> att_value;
+      ASSERT_TRUE((timestamp_att->GetValue<float, 1>(
+          draco::AttributeValueIndex(i), &att_value)));
+      ASSERT_FLOAT_EQ(att_value[0], i);
+    }
+
+    // Compare keyframe data.
+    const auto keyframe_att = keyframe_animation_.keyframes(1);
+    for (int i = 0; i < animation_data_.size() / num_components_t; ++i) {
+      std::array<float, num_components_t> att_value;
+      ASSERT_TRUE((keyframe_att->GetValue<float, num_components_t>(
+          draco::AttributeValueIndex(i), &att_value)));
+      for (int j = 0; j < num_components_t; ++j) {
+        ASSERT_FLOAT_EQ(att_value[j], i * num_components_t + j);
+      }
+    }
+  }
+
+  template <int num_components_t>
+  void TestKeyframeAnimation(int32_t num_frames) {
+    ASSERT_TRUE(CreateAndAddTimestamps(num_frames));
+    ASSERT_EQ(CreateAndAddAnimationData(num_frames, num_components_t), 1);
+    CompareAnimationData<num_components_t>();
+  }
+
+  draco::KeyframeAnimation keyframe_animation_;
+  std::vector<draco::KeyframeAnimation::TimestampType> timestamps_;
+  std::vector<float> animation_data_;
+};
+
+// Test animation with 1 component and 10 frames.
+TEST_F(KeyframeAnimationTest, OneComponent) { TestKeyframeAnimation<1>(10); }
+
+// Test animation with 4 component and 10 frames.
+TEST_F(KeyframeAnimationTest, FourComponent) { TestKeyframeAnimation<4>(10); }
+
+// Test adding animation data before timestamp.
+TEST_F(KeyframeAnimationTest, AddingAnimationFirst) {
+  ASSERT_EQ(CreateAndAddAnimationData(5, 1), 1);
+  ASSERT_TRUE(CreateAndAddTimestamps(5));
+}
+
+// Test adding timestamp more than once.
+TEST_F(KeyframeAnimationTest, ErrorAddingTimestampsTwice) {
+  ASSERT_TRUE(CreateAndAddTimestamps(5));
+  ASSERT_FALSE(CreateAndAddTimestamps(5));
+}
+// Test animation with multiple animation data.
+TEST_F(KeyframeAnimationTest, MultipleAnimationData) {
+  const int num_frames = 5;
+  ASSERT_TRUE(CreateAndAddTimestamps(num_frames));
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 1), 1);
+  ASSERT_EQ(CreateAndAddAnimationData(num_frames, 2), 2);
+}
+
+}  // namespace
diff --git a/contrib/draco/src/draco/attributes/attribute_octahedron_transform.cc b/contrib/draco/src/draco/attributes/attribute_octahedron_transform.cc
new file mode 100644
index 000000000..51c3bb6c8
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/attribute_octahedron_transform.cc
@@ -0,0 +1,145 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "draco/attributes/attribute_octahedron_transform.h"
+
+#include "draco/attributes/attribute_transform_type.h"
+#include "draco/compression/attributes/normal_compression_utils.h"
+
+namespace draco {
+
+bool AttributeOctahedronTransform::InitFromAttribute(
+    const PointAttribute &attribute) {
+  const AttributeTransformData *const transform_data =
+      attribute.GetAttributeTransformData();
+  if (!transform_data ||
+      transform_data->transform_type() != ATTRIBUTE_OCTAHEDRON_TRANSFORM) {
+    return false;  // Wrong transform type.
+  }
+  quantization_bits_ = transform_data->GetParameterValue<int32_t>(0);
+  return true;
+}
+
+void AttributeOctahedronTransform::CopyToAttributeTransformData(
+    AttributeTransformData *out_data) const {
+  out_data->set_transform_type(ATTRIBUTE_OCTAHEDRON_TRANSFORM);
+  out_data->AppendParameterValue(quantization_bits_);
+}
+
+bool AttributeOctahedronTransform::TransformAttribute(
+    const PointAttribute &attribute, const std::vector<PointIndex> &point_ids,
+    PointAttribute *target_attribute) {
+  return GeneratePortableAttribute(attribute, point_ids,
+                                   target_attribute->size(), target_attribute);
+}
+
+bool AttributeOctahedronTransform::InverseTransformAttribute(
+    const PointAttribute &attribute, PointAttribute *target_attribute) {
+  if (target_attribute->data_type() != DT_FLOAT32) {
+    return false;
+  }
+
+  const int num_points = target_attribute->size();
+  const int num_components = target_attribute->num_components();
+  if (num_components != 3) {
+    return false;
+  }
+  constexpr int kEntrySize = sizeof(float) * 3;
+  float att_val[3];
+  const int32_t *source_attribute_data = reinterpret_cast<const int32_t *>(
+      attribute.GetAddress(AttributeValueIndex(0)));
+  uint8_t *target_address =
+      target_attribute->GetAddress(AttributeValueIndex(0));
+  OctahedronToolBox octahedron_tool_box;
+  if (!octahedron_tool_box.SetQuantizationBits(quantization_bits_)) {
+    return false;
+  }
+  for (uint32_t i = 0; i < num_points; ++i) {
+    const int32_t s = *source_attribute_data++;
+    const int32_t t = *source_attribute_data++;
+    octahedron_tool_box.QuantizedOctahedralCoordsToUnitVector(s, t, att_val);
+
+    // Store the decoded floating point values into the attribute buffer.
+    std::memcpy(target_address, att_val, kEntrySize);
+    target_address += kEntrySize;
+  }
+  return true;
+}
+
+void AttributeOctahedronTransform::SetParameters(int quantization_bits) {
+  quantization_bits_ = quantization_bits;
+}
+
+bool AttributeOctahedronTransform::EncodeParameters(
+    EncoderBuffer *encoder_buffer) const {
+  if (is_initialized()) {
+    encoder_buffer->Encode(static_cast<uint8_t>(quantization_bits_));
+    return true;
+  }
+  return false;
+}
+
+bool AttributeOctahedronTransform::DecodeParameters(
+    const PointAttribute &attribute, DecoderBuffer *decoder_buffer) {
+  uint8_t quantization_bits;
+  if (!decoder_buffer->Decode(&quantization_bits)) {
+    return false;
+  }
+  quantization_bits_ = quantization_bits;
+  return true;
+}
+
+bool AttributeOctahedronTransform::GeneratePortableAttribute(
+    const PointAttribute &attribute, const std::vector<PointIndex> &point_ids,
+    int num_points, PointAttribute *target_attribute) const {
+  DRACO_DCHECK(is_initialized());
+
+  // Quantize all values in the order given by point_ids into portable
+  // attribute.
+  int32_t *const portable_attribute_data = reinterpret_cast<int32_t *>(
+      target_attribute->GetAddress(AttributeValueIndex(0)));
+  float att_val[3];
+  int32_t dst_index = 0;
+  OctahedronToolBox converter;
+  if (!converter.SetQuantizationBits(quantization_bits_)) {
+    return false;
+  }
+  if (!point_ids.empty()) {
+    for (uint32_t i = 0; i < point_ids.size(); ++i) {
+      const AttributeValueIndex att_val_id =
+          attribute.mapped_index(point_ids[i]);
+      attribute.GetValue(att_val_id, att_val);
+      // Encode the vector into a s and t octahedral coordinates.
+      int32_t s, t;
+      converter.FloatVectorToQuantizedOctahedralCoords(att_val, &s, &t);
+      portable_attribute_data[dst_index++] = s;
+      portable_attribute_data[dst_index++] = t;
+    }
+  } else {
+    for (PointIndex i(0); i < num_points; ++i) {
+      const AttributeValueIndex att_val_id = attribute.mapped_index(i);
+      attribute.GetValue(att_val_id, att_val);
+      // Encode the vector into a s and t octahedral coordinates.
+      int32_t s, t;
+      converter.FloatVectorToQuantizedOctahedralCoords(att_val, &s, &t);
+      portable_attribute_data[dst_index++] = s;
+      portable_attribute_data[dst_index++] = t;
+    }
+  }
+
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/attributes/attribute_octahedron_transform.h b/contrib/draco/src/draco/attributes/attribute_octahedron_transform.h
new file mode 100644
index 000000000..21a1725bb
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/attribute_octahedron_transform.h
@@ -0,0 +1,81 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_OCTAHEDRON_TRANSFORM_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_OCTAHEDRON_TRANSFORM_H_
+
+#include "draco/attributes/attribute_transform.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Attribute transform for attributes transformed to octahedral coordinates.
+class AttributeOctahedronTransform : public AttributeTransform {
+ public:
+  AttributeOctahedronTransform() : quantization_bits_(-1) {}
+
+  // Return attribute transform type.
+  AttributeTransformType Type() const override {
+    return ATTRIBUTE_OCTAHEDRON_TRANSFORM;
+  }
+  // Try to init transform from attribute.
+  bool InitFromAttribute(const PointAttribute &attribute) override;
+  // Copy parameter values into the provided AttributeTransformData instance.
+  void CopyToAttributeTransformData(
+      AttributeTransformData *out_data) const override;
+
+  bool TransformAttribute(const PointAttribute &attribute,
+                          const std::vector<PointIndex> &point_ids,
+                          PointAttribute *target_attribute) override;
+
+  bool InverseTransformAttribute(const PointAttribute &attribute,
+                                 PointAttribute *target_attribute) override;
+
+  // Set number of quantization bits.
+  void SetParameters(int quantization_bits);
+
+  // Encode relevant parameters into buffer.
+  bool EncodeParameters(EncoderBuffer *encoder_buffer) const override;
+
+  bool DecodeParameters(const PointAttribute &attribute,
+                        DecoderBuffer *decoder_buffer) override;
+
+  bool is_initialized() const { return quantization_bits_ != -1; }
+  int32_t quantization_bits() const { return quantization_bits_; }
+
+ protected:
+  DataType GetTransformedDataType(
+      const PointAttribute &attribute) const override {
+    return DT_UINT32;
+  }
+  int GetTransformedNumComponents(
+      const PointAttribute &attribute) const override {
+    return 2;
+  }
+
+  // Perform the actual transformation.
+  bool GeneratePortableAttribute(const PointAttribute &attribute,
+                                 const std::vector<PointIndex> &point_ids,
+                                 int num_points,
+                                 PointAttribute *target_attribute) const;
+
+ private:
+  int32_t quantization_bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_ATTRIBUTE_OCTAHEDRON_TRANSFORM_H_
diff --git a/contrib/draco/src/draco/attributes/attribute_quantization_transform.cc b/contrib/draco/src/draco/attributes/attribute_quantization_transform.cc
new file mode 100644
index 000000000..a7f93a488
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/attribute_quantization_transform.cc
@@ -0,0 +1,260 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/attributes/attribute_quantization_transform.h"
+
+#include "draco/attributes/attribute_transform_type.h"
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+bool AttributeQuantizationTransform::InitFromAttribute(
+    const PointAttribute &attribute) {
+  const AttributeTransformData *const transform_data =
+      attribute.GetAttributeTransformData();
+  if (!transform_data ||
+      transform_data->transform_type() != ATTRIBUTE_QUANTIZATION_TRANSFORM) {
+    return false;  // Wrong transform type.
+  }
+  int32_t byte_offset = 0;
+  quantization_bits_ = transform_data->GetParameterValue<int32_t>(byte_offset);
+  byte_offset += 4;
+  min_values_.resize(attribute.num_components());
+  for (int i = 0; i < attribute.num_components(); ++i) {
+    min_values_[i] = transform_data->GetParameterValue<float>(byte_offset);
+    byte_offset += 4;
+  }
+  range_ = transform_data->GetParameterValue<float>(byte_offset);
+  return true;
+}
+
+// Copy parameter values into the provided AttributeTransformData instance.
+void AttributeQuantizationTransform::CopyToAttributeTransformData(
+    AttributeTransformData *out_data) const {
+  out_data->set_transform_type(ATTRIBUTE_QUANTIZATION_TRANSFORM);
+  out_data->AppendParameterValue(quantization_bits_);
+  for (int i = 0; i < min_values_.size(); ++i) {
+    out_data->AppendParameterValue(min_values_[i]);
+  }
+  out_data->AppendParameterValue(range_);
+}
+
+bool AttributeQuantizationTransform::TransformAttribute(
+    const PointAttribute &attribute, const std::vector<PointIndex> &point_ids,
+    PointAttribute *target_attribute) {
+  if (point_ids.empty()) {
+    GeneratePortableAttribute(attribute, target_attribute->size(),
+                              target_attribute);
+  } else {
+    GeneratePortableAttribute(attribute, point_ids, target_attribute->size(),
+                              target_attribute);
+  }
+  return true;
+}
+
+bool AttributeQuantizationTransform::InverseTransformAttribute(
+    const PointAttribute &attribute, PointAttribute *target_attribute) {
+  if (target_attribute->data_type() != DT_FLOAT32) {
+    return false;
+  }
+
+  // Convert all quantized values back to floats.
+  const int32_t max_quantized_value =
+      (1u << static_cast<uint32_t>(quantization_bits_)) - 1;
+  const int num_components = target_attribute->num_components();
+  const int entry_size = sizeof(float) * num_components;
+  const std::unique_ptr<float[]> att_val(new float[num_components]);
+  int quant_val_id = 0;
+  int out_byte_pos = 0;
+  Dequantizer dequantizer;
+  if (!dequantizer.Init(range_, max_quantized_value)) {
+    return false;
+  }
+  const int32_t *const source_attribute_data =
+      reinterpret_cast<const int32_t *>(
+          attribute.GetAddress(AttributeValueIndex(0)));
+
+  const int num_values = target_attribute->size();
+
+  for (uint32_t i = 0; i < num_values; ++i) {
+    for (int c = 0; c < num_components; ++c) {
+      float value =
+          dequantizer.DequantizeFloat(source_attribute_data[quant_val_id++]);
+      value = value + min_values_[c];
+      att_val[c] = value;
+    }
+    // Store the floating point value into the attribute buffer.
+    target_attribute->buffer()->Write(out_byte_pos, att_val.get(), entry_size);
+    out_byte_pos += entry_size;
+  }
+  return true;
+}
+
+bool AttributeQuantizationTransform::IsQuantizationValid(
+    int quantization_bits) {
+  // Currently we allow only up to 30 bit quantization.
+  return quantization_bits >= 1 && quantization_bits <= 30;
+}
+
+bool AttributeQuantizationTransform::SetParameters(int quantization_bits,
+                                                   const float *min_values,
+                                                   int num_components,
+                                                   float range) {
+  if (!IsQuantizationValid(quantization_bits)) {
+    return false;
+  }
+  quantization_bits_ = quantization_bits;
+  min_values_.assign(min_values, min_values + num_components);
+  range_ = range;
+  return true;
+}
+
+bool AttributeQuantizationTransform::ComputeParameters(
+    const PointAttribute &attribute, const int quantization_bits) {
+  if (quantization_bits_ != -1) {
+    return false;  // already initialized.
+  }
+  if (!IsQuantizationValid(quantization_bits)) {
+    return false;
+  }
+  quantization_bits_ = quantization_bits;
+
+  const int num_components = attribute.num_components();
+  range_ = 0.f;
+  min_values_ = std::vector<float>(num_components, 0.f);
+  const std::unique_ptr<float[]> max_values(new float[num_components]);
+  const std::unique_ptr<float[]> att_val(new float[num_components]);
+  // Compute minimum values and max value difference.
+  attribute.GetValue(AttributeValueIndex(0), att_val.get());
+  attribute.GetValue(AttributeValueIndex(0), min_values_.data());
+  attribute.GetValue(AttributeValueIndex(0), max_values.get());
+
+  for (AttributeValueIndex i(1); i < static_cast<uint32_t>(attribute.size());
+       ++i) {
+    attribute.GetValue(i, att_val.get());
+    for (int c = 0; c < num_components; ++c) {
+      if (min_values_[c] > att_val[c]) {
+        min_values_[c] = att_val[c];
+      }
+      if (max_values[c] < att_val[c]) {
+        max_values[c] = att_val[c];
+      }
+    }
+  }
+  for (int c = 0; c < num_components; ++c) {
+    if (std::isnan(min_values_[c]) || std::isinf(min_values_[c]) ||
+        std::isnan(max_values[c]) || std::isinf(max_values[c])) {
+      return false;
+    }
+    const float dif = max_values[c] - min_values_[c];
+    if (dif > range_) {
+      range_ = dif;
+    }
+  }
+
+  // In case all values are the same, initialize the range to unit length. This
+  // will ensure that all values are quantized properly to the same value.
+  if (range_ == 0.f) {
+    range_ = 1.f;
+  }
+
+  return true;
+}
+
+bool AttributeQuantizationTransform::EncodeParameters(
+    EncoderBuffer *encoder_buffer) const {
+  if (is_initialized()) {
+    encoder_buffer->Encode(min_values_.data(),
+                           sizeof(float) * min_values_.size());
+    encoder_buffer->Encode(range_);
+    encoder_buffer->Encode(static_cast<uint8_t>(quantization_bits_));
+    return true;
+  }
+  return false;
+}
+
+bool AttributeQuantizationTransform::DecodeParameters(
+    const PointAttribute &attribute, DecoderBuffer *decoder_buffer) {
+  min_values_.resize(attribute.num_components());
+  if (!decoder_buffer->Decode(&min_values_[0],
+                              sizeof(float) * min_values_.size())) {
+    return false;
+  }
+  if (!decoder_buffer->Decode(&range_)) {
+    return false;
+  }
+  uint8_t quantization_bits;
+  if (!decoder_buffer->Decode(&quantization_bits)) {
+    return false;
+  }
+  if (!IsQuantizationValid(quantization_bits)) {
+    return false;
+  }
+  quantization_bits_ = quantization_bits;
+  return true;
+}
+
+void AttributeQuantizationTransform::GeneratePortableAttribute(
+    const PointAttribute &attribute, int num_points,
+    PointAttribute *target_attribute) const {
+  DRACO_DCHECK(is_initialized());
+
+  const int num_components = attribute.num_components();
+
+  // Quantize all values using the order given by point_ids.
+  int32_t *const portable_attribute_data = reinterpret_cast<int32_t *>(
+      target_attribute->GetAddress(AttributeValueIndex(0)));
+  const uint32_t max_quantized_value = (1 << (quantization_bits_)) - 1;
+  Quantizer quantizer;
+  quantizer.Init(range(), max_quantized_value);
+  int32_t dst_index = 0;
+  const std::unique_ptr<float[]> att_val(new float[num_components]);
+  for (PointIndex i(0); i < num_points; ++i) {
+    const AttributeValueIndex att_val_id = attribute.mapped_index(i);
+    attribute.GetValue(att_val_id, att_val.get());
+    for (int c = 0; c < num_components; ++c) {
+      const float value = (att_val[c] - min_values()[c]);
+      const int32_t q_val = quantizer.QuantizeFloat(value);
+      portable_attribute_data[dst_index++] = q_val;
+    }
+  }
+}
+
+void AttributeQuantizationTransform::GeneratePortableAttribute(
+    const PointAttribute &attribute, const std::vector<PointIndex> &point_ids,
+    int num_points, PointAttribute *target_attribute) const {
+  DRACO_DCHECK(is_initialized());
+
+  const int num_components = attribute.num_components();
+
+  // Quantize all values using the order given by point_ids.
+  int32_t *const portable_attribute_data = reinterpret_cast<int32_t *>(
+      target_attribute->GetAddress(AttributeValueIndex(0)));
+  const uint32_t max_quantized_value = (1 << (quantization_bits_)) - 1;
+  Quantizer quantizer;
+  quantizer.Init(range(), max_quantized_value);
+  int32_t dst_index = 0;
+  const std::unique_ptr<float[]> att_val(new float[num_components]);
+  for (uint32_t i = 0; i < point_ids.size(); ++i) {
+    const AttributeValueIndex att_val_id = attribute.mapped_index(point_ids[i]);
+    attribute.GetValue(att_val_id, att_val.get());
+    for (int c = 0; c < num_components; ++c) {
+      const float value = (att_val[c] - min_values()[c]);
+      const int32_t q_val = quantizer.QuantizeFloat(value);
+      portable_attribute_data[dst_index++] = q_val;
+    }
+  }
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/attributes/attribute_quantization_transform.h b/contrib/draco/src/draco/attributes/attribute_quantization_transform.h
new file mode 100644
index 000000000..f1122b680
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/attribute_quantization_transform.h
@@ -0,0 +1,102 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_QUANTIZATION_TRANSFORM_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_QUANTIZATION_TRANSFORM_H_
+
+#include <vector>
+
+#include "draco/attributes/attribute_transform.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Attribute transform for quantized attributes.
+class AttributeQuantizationTransform : public AttributeTransform {
+ public:
+  AttributeQuantizationTransform() : quantization_bits_(-1), range_(0.f) {}
+  // Return attribute transform type.
+  AttributeTransformType Type() const override {
+    return ATTRIBUTE_QUANTIZATION_TRANSFORM;
+  }
+  // Try to init transform from attribute.
+  bool InitFromAttribute(const PointAttribute &attribute) override;
+  // Copy parameter values into the provided AttributeTransformData instance.
+  void CopyToAttributeTransformData(
+      AttributeTransformData *out_data) const override;
+
+  bool TransformAttribute(const PointAttribute &attribute,
+                          const std::vector<PointIndex> &point_ids,
+                          PointAttribute *target_attribute) override;
+
+  bool InverseTransformAttribute(const PointAttribute &attribute,
+                                 PointAttribute *target_attribute) override;
+
+  bool SetParameters(int quantization_bits, const float *min_values,
+                     int num_components, float range);
+
+  bool ComputeParameters(const PointAttribute &attribute,
+                         const int quantization_bits);
+
+  // Encode relevant parameters into buffer.
+  bool EncodeParameters(EncoderBuffer *encoder_buffer) const override;
+
+  bool DecodeParameters(const PointAttribute &attribute,
+                        DecoderBuffer *decoder_buffer) override;
+
+  int32_t quantization_bits() const { return quantization_bits_; }
+  float min_value(int axis) const { return min_values_[axis]; }
+  const std::vector<float> &min_values() const { return min_values_; }
+  float range() const { return range_; }
+  bool is_initialized() const { return quantization_bits_ != -1; }
+
+ protected:
+  // Create portable attribute using 1:1 mapping between points in the input and
+  // output attribute.
+  void GeneratePortableAttribute(const PointAttribute &attribute,
+                                 int num_points,
+                                 PointAttribute *target_attribute) const;
+
+  // Create portable attribute using custom mapping between input and output
+  // points.
+  void GeneratePortableAttribute(const PointAttribute &attribute,
+                                 const std::vector<PointIndex> &point_ids,
+                                 int num_points,
+                                 PointAttribute *target_attribute) const;
+
+  DataType GetTransformedDataType(
+      const PointAttribute &attribute) const override {
+    return DT_UINT32;
+  }
+  int GetTransformedNumComponents(
+      const PointAttribute &attribute) const override {
+    return attribute.num_components();
+  }
+
+  static bool IsQuantizationValid(int quantization_bits);
+
+ private:
+  int32_t quantization_bits_;
+
+  // Minimal dequantized value for each component of the attribute.
+  std::vector<float> min_values_;
+
+  // Bounds of the dequantized attribute (max delta over all components).
+  float range_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTE_DEQUANTIZATION_TRANSFORM_H_
diff --git a/contrib/draco/src/draco/attributes/attribute_transform.cc b/contrib/draco/src/draco/attributes/attribute_transform.cc
new file mode 100644
index 000000000..174e6b822
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/attribute_transform.cc
@@ -0,0 +1,40 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/attributes/attribute_transform.h"
+
+namespace draco {
+
+bool AttributeTransform::TransferToAttribute(PointAttribute *attribute) const {
+  std::unique_ptr<AttributeTransformData> transform_data(
+      new AttributeTransformData());
+  this->CopyToAttributeTransformData(transform_data.get());
+  attribute->SetAttributeTransformData(std::move(transform_data));
+  return true;
+}
+
+std::unique_ptr<PointAttribute> AttributeTransform::InitTransformedAttribute(
+    const PointAttribute &src_attribute, int num_entries) {
+  const int num_components = GetTransformedNumComponents(src_attribute);
+  const DataType dt = GetTransformedDataType(src_attribute);
+  GeometryAttribute va;
+  va.Init(src_attribute.attribute_type(), nullptr, num_components, dt, false,
+          num_components * DataTypeLength(dt), 0);
+  std::unique_ptr<PointAttribute> transformed_attribute(new PointAttribute(va));
+  transformed_attribute->Reset(num_entries);
+  transformed_attribute->SetIdentityMapping();
+  return transformed_attribute;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/attributes/attribute_transform.h b/contrib/draco/src/draco/attributes/attribute_transform.h
new file mode 100644
index 000000000..62aad60db
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/attribute_transform.h
@@ -0,0 +1,76 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_H_
+
+#include "draco/attributes/attribute_transform_data.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Virtual base class for various attribute transforms, enforcing common
+// interface where possible.
+class AttributeTransform {
+ public:
+  virtual ~AttributeTransform() = default;
+
+  // Return attribute transform type.
+  virtual AttributeTransformType Type() const = 0;
+  // Try to init transform from attribute.
+  virtual bool InitFromAttribute(const PointAttribute &attribute) = 0;
+  // Copy parameter values into the provided AttributeTransformData instance.
+  virtual void CopyToAttributeTransformData(
+      AttributeTransformData *out_data) const = 0;
+  bool TransferToAttribute(PointAttribute *attribute) const;
+
+  // Applies the transform to |attribute| and stores the result in
+  // |target_attribute|. |point_ids| is an optional vector that can be used to
+  // remap values during the transform.
+  virtual bool TransformAttribute(const PointAttribute &attribute,
+                                  const std::vector<PointIndex> &point_ids,
+                                  PointAttribute *target_attribute) = 0;
+
+  // Applies an inverse transform to |attribute| and stores the result in
+  // |target_attribute|. In this case, |attribute| is an attribute that was
+  // already transformed (e.g. quantized) and |target_attribute| is the
+  // attribute before the transformation.
+  virtual bool InverseTransformAttribute(const PointAttribute &attribute,
+                                         PointAttribute *target_attribute) = 0;
+
+  // Encodes all data needed by the transformation into the |encoder_buffer|.
+  virtual bool EncodeParameters(EncoderBuffer *encoder_buffer) const = 0;
+
+  // Decodes all data needed to transform |attribute| back to the original
+  // format.
+  virtual bool DecodeParameters(const PointAttribute &attribute,
+                                DecoderBuffer *decoder_buffer) = 0;
+
+  // Initializes a transformed attribute that can be used as target in the
+  // TransformAttribute() function call.
+  virtual std::unique_ptr<PointAttribute> InitTransformedAttribute(
+      const PointAttribute &src_attribute, int num_entries);
+
+ protected:
+  virtual DataType GetTransformedDataType(
+      const PointAttribute &attribute) const = 0;
+  virtual int GetTransformedNumComponents(
+      const PointAttribute &attribute) const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_ATTRIBUTE_OCTAHEDRON_TRANSFORM_H_
diff --git a/contrib/draco/src/draco/attributes/attribute_transform_data.h b/contrib/draco/src/draco/attributes/attribute_transform_data.h
new file mode 100644
index 000000000..96ed07320
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/attribute_transform_data.h
@@ -0,0 +1,71 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_DATA_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_DATA_H_
+
+#include <memory>
+
+#include "draco/attributes/attribute_transform_type.h"
+#include "draco/core/data_buffer.h"
+
+namespace draco {
+
+// Class for holding parameter values for an attribute transform of a
+// PointAttribute. This can be for example quantization data for an attribute
+// that holds quantized values. This class provides only a basic storage for
+// attribute transform parameters and it should be accessed only through wrapper
+// classes for a specific transform (e.g. AttributeQuantizationTransform).
+class AttributeTransformData {
+ public:
+  AttributeTransformData() : transform_type_(ATTRIBUTE_INVALID_TRANSFORM) {}
+  AttributeTransformData(const AttributeTransformData &data) = default;
+
+  // Returns the type of the attribute transform that is described by the class.
+  AttributeTransformType transform_type() const { return transform_type_; }
+  void set_transform_type(AttributeTransformType type) {
+    transform_type_ = type;
+  }
+
+  // Returns a parameter value on a given |byte_offset|.
+  template <typename DataTypeT>
+  DataTypeT GetParameterValue(int byte_offset) const {
+    DataTypeT out_data;
+    buffer_.Read(byte_offset, &out_data, sizeof(DataTypeT));
+    return out_data;
+  }
+
+  // Sets a parameter value on a given |byte_offset|.
+  template <typename DataTypeT>
+  void SetParameterValue(int byte_offset, const DataTypeT &in_data) {
+    if (byte_offset + sizeof(DataTypeT) > buffer_.data_size()) {
+      buffer_.Resize(byte_offset + sizeof(DataTypeT));
+    }
+    buffer_.Write(byte_offset, &in_data, sizeof(DataTypeT));
+  }
+
+  // Sets a parameter value at the end of the |buffer_|.
+  template <typename DataTypeT>
+  void AppendParameterValue(const DataTypeT &in_data) {
+    SetParameterValue(static_cast<int>(buffer_.data_size()), in_data);
+  }
+
+ private:
+  AttributeTransformType transform_type_;
+  DataBuffer buffer_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_DATA_H_
diff --git a/contrib/draco/src/draco/attributes/attribute_transform_type.h b/contrib/draco/src/draco/attributes/attribute_transform_type.h
new file mode 100644
index 000000000..51ce6f333
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/attribute_transform_type.h
@@ -0,0 +1,30 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_TYPE_H_
+#define DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_TYPE_H_
+
+namespace draco {
+
+// List of all currently supported attribute transforms.
+enum AttributeTransformType {
+  ATTRIBUTE_INVALID_TRANSFORM = -1,
+  ATTRIBUTE_NO_TRANSFORM = 0,
+  ATTRIBUTE_QUANTIZATION_TRANSFORM = 1,
+  ATTRIBUTE_OCTAHEDRON_TRANSFORM = 2,
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_ATTRIBUTE_TRANSFORM_TYPE_H_
diff --git a/contrib/draco/src/draco/attributes/geometry_attribute.cc b/contrib/draco/src/draco/attributes/geometry_attribute.cc
new file mode 100644
index 000000000..b62478426
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/geometry_attribute.cc
@@ -0,0 +1,102 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/attributes/geometry_attribute.h"
+
+namespace draco {
+
+GeometryAttribute::GeometryAttribute()
+    : buffer_(nullptr),
+      num_components_(1),
+      data_type_(DT_FLOAT32),
+      byte_stride_(0),
+      byte_offset_(0),
+      attribute_type_(INVALID),
+      unique_id_(0) {}
+
+void GeometryAttribute::Init(GeometryAttribute::Type attribute_type,
+                             DataBuffer *buffer, int8_t num_components,
+                             DataType data_type, bool normalized,
+                             int64_t byte_stride, int64_t byte_offset) {
+  buffer_ = buffer;
+  if (buffer) {
+    buffer_descriptor_.buffer_id = buffer->buffer_id();
+    buffer_descriptor_.buffer_update_count = buffer->update_count();
+  }
+  num_components_ = num_components;
+  data_type_ = data_type;
+  normalized_ = normalized;
+  byte_stride_ = byte_stride;
+  byte_offset_ = byte_offset;
+  attribute_type_ = attribute_type;
+}
+
+bool GeometryAttribute::CopyFrom(const GeometryAttribute &src_att) {
+  num_components_ = src_att.num_components_;
+  data_type_ = src_att.data_type_;
+  normalized_ = src_att.normalized_;
+  byte_stride_ = src_att.byte_stride_;
+  byte_offset_ = src_att.byte_offset_;
+  attribute_type_ = src_att.attribute_type_;
+  buffer_descriptor_ = src_att.buffer_descriptor_;
+  unique_id_ = src_att.unique_id_;
+  if (src_att.buffer_ == nullptr) {
+    buffer_ = nullptr;
+  } else {
+    if (buffer_ == nullptr) {
+      return false;
+    }
+    buffer_->Update(src_att.buffer_->data(), src_att.buffer_->data_size());
+  }
+  return true;
+}
+
+bool GeometryAttribute::operator==(const GeometryAttribute &va) const {
+  if (attribute_type_ != va.attribute_type_) {
+    return false;
+  }
+  // It's OK to compare just the buffer descriptors here. We don't need to
+  // compare the buffers themselves.
+  if (buffer_descriptor_.buffer_id != va.buffer_descriptor_.buffer_id) {
+    return false;
+  }
+  if (buffer_descriptor_.buffer_update_count !=
+      va.buffer_descriptor_.buffer_update_count) {
+    return false;
+  }
+  if (num_components_ != va.num_components_) {
+    return false;
+  }
+  if (data_type_ != va.data_type_) {
+    return false;
+  }
+  if (byte_stride_ != va.byte_stride_) {
+    return false;
+  }
+  if (byte_offset_ != va.byte_offset_) {
+    return false;
+  }
+  return true;
+}
+
+void GeometryAttribute::ResetBuffer(DataBuffer *buffer, int64_t byte_stride,
+                                    int64_t byte_offset) {
+  buffer_ = buffer;
+  buffer_descriptor_.buffer_id = buffer->buffer_id();
+  buffer_descriptor_.buffer_update_count = buffer->update_count();
+  byte_stride_ = byte_stride;
+  byte_offset_ = byte_offset;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/attributes/geometry_attribute.h b/contrib/draco/src/draco/attributes/geometry_attribute.h
new file mode 100644
index 000000000..f4d099b1b
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/geometry_attribute.h
@@ -0,0 +1,350 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_
+#define DRACO_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_
+
+#include <array>
+#include <limits>
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/data_buffer.h"
+#include "draco/core/hash_utils.h"
+
+namespace draco {
+
+// The class provides access to a specific attribute which is stored in a
+// DataBuffer, such as normals or coordinates. However, the GeometryAttribute
+// class does not own the buffer and the buffer itself may store other data
+// unrelated to this attribute (such as data for other attributes in which case
+// we can have multiple GeometryAttributes accessing one buffer). Typically,
+// all attributes for a point (or corner, face) are stored in one block, which
+// is advantageous in terms of memory access. The length of the entire block is
+// given by the byte_stride, the position where the attribute starts is given by
+// the byte_offset, the actual number of bytes that the attribute occupies is
+// given by the data_type and the number of components.
+class GeometryAttribute {
+ public:
+  // Supported attribute types.
+  enum Type {
+    INVALID = -1,
+    // Named attributes start here. The difference between named and generic
+    // attributes is that for named attributes we know their purpose and we
+    // can apply some special methods when dealing with them (e.g. during
+    // encoding).
+    POSITION = 0,
+    NORMAL,
+    COLOR,
+    TEX_COORD,
+    // A special id used to mark attributes that are not assigned to any known
+    // predefined use case. Such attributes are often used for a shader specific
+    // data.
+    GENERIC,
+    // Total number of different attribute types.
+    // Always keep behind all named attributes.
+    NAMED_ATTRIBUTES_COUNT,
+  };
+
+  GeometryAttribute();
+  // Initializes and enables the attribute.
+  void Init(Type attribute_type, DataBuffer *buffer, int8_t num_components,
+            DataType data_type, bool normalized, int64_t byte_stride,
+            int64_t byte_offset);
+  bool IsValid() const { return buffer_ != nullptr; }
+
+  // Copies data from the source attribute to the this attribute.
+  // This attribute must have a valid buffer allocated otherwise the operation
+  // is going to fail and return false.
+  bool CopyFrom(const GeometryAttribute &src_att);
+
+  // Function for getting a attribute value with a specific format.
+  // Unsafe. Caller must ensure the accessed memory is valid.
+  // T is the attribute data type.
+  // att_components_t is the number of attribute components.
+  template <typename T, int att_components_t>
+  std::array<T, att_components_t> GetValue(
+      AttributeValueIndex att_index) const {
+    // Byte address of the attribute index.
+    const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value();
+    std::array<T, att_components_t> out;
+    buffer_->Read(byte_pos, &(out[0]), sizeof(out));
+    return out;
+  }
+
+  // Function for getting a attribute value with a specific format.
+  // T is the attribute data type.
+  // att_components_t is the number of attribute components.
+  template <typename T, int att_components_t>
+  bool GetValue(AttributeValueIndex att_index,
+                std::array<T, att_components_t> *out) const {
+    // Byte address of the attribute index.
+    const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value();
+    // Check we are not reading past end of data.
+    if (byte_pos + sizeof(*out) > buffer_->data_size()) {
+      return false;
+    }
+    buffer_->Read(byte_pos, &((*out)[0]), sizeof(*out));
+    return true;
+  }
+
+  // Returns the byte position of the attribute entry in the data buffer.
+  inline int64_t GetBytePos(AttributeValueIndex att_index) const {
+    return byte_offset_ + byte_stride_ * att_index.value();
+  }
+
+  inline const uint8_t *GetAddress(AttributeValueIndex att_index) const {
+    const int64_t byte_pos = GetBytePos(att_index);
+    return buffer_->data() + byte_pos;
+  }
+  inline uint8_t *GetAddress(AttributeValueIndex att_index) {
+    const int64_t byte_pos = GetBytePos(att_index);
+    return buffer_->data() + byte_pos;
+  }
+  inline bool IsAddressValid(const uint8_t *address) const {
+    return ((buffer_->data() + buffer_->data_size()) > address);
+  }
+
+  // Fills out_data with the raw value of the requested attribute entry.
+  // out_data must be at least byte_stride_ long.
+  void GetValue(AttributeValueIndex att_index, void *out_data) const {
+    const int64_t byte_pos = byte_offset_ + byte_stride_ * att_index.value();
+    buffer_->Read(byte_pos, out_data, byte_stride_);
+  }
+
+  // Sets a value of an attribute entry. The input value must be allocated to
+  // cover all components of a single attribute entry.
+  void SetAttributeValue(AttributeValueIndex entry_index, const void *value) {
+    const int64_t byte_pos = entry_index.value() * byte_stride();
+    buffer_->Write(byte_pos, value, byte_stride());
+  }
+
+  // DEPRECATED: Use
+  //   ConvertValue(AttributeValueIndex att_id,
+  //               int out_num_components,
+  //               OutT *out_val);
+  //
+  // Function for conversion of a attribute to a specific output format.
+  // OutT is the desired data type of the attribute.
+  // out_att_components_t is the number of components of the output format.
+  // Returns false when the conversion failed.
+  template <typename OutT, int out_att_components_t>
+  bool ConvertValue(AttributeValueIndex att_id, OutT *out_val) const {
+    return ConvertValue(att_id, out_att_components_t, out_val);
+  }
+
+  // Function for conversion of a attribute to a specific output format.
+  // |out_val| needs to be able to store |out_num_components| values.
+  // OutT is the desired data type of the attribute.
+  // Returns false when the conversion failed.
+  template <typename OutT>
+  bool ConvertValue(AttributeValueIndex att_id, int8_t out_num_components,
+                    OutT *out_val) const {
+    if (out_val == nullptr) {
+      return false;
+    }
+    switch (data_type_) {
+      case DT_INT8:
+        return ConvertTypedValue<int8_t, OutT>(att_id, out_num_components,
+                                               out_val);
+      case DT_UINT8:
+        return ConvertTypedValue<uint8_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_INT16:
+        return ConvertTypedValue<int16_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_UINT16:
+        return ConvertTypedValue<uint16_t, OutT>(att_id, out_num_components,
+                                                 out_val);
+      case DT_INT32:
+        return ConvertTypedValue<int32_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_UINT32:
+        return ConvertTypedValue<uint32_t, OutT>(att_id, out_num_components,
+                                                 out_val);
+      case DT_INT64:
+        return ConvertTypedValue<int64_t, OutT>(att_id, out_num_components,
+                                                out_val);
+      case DT_UINT64:
+        return ConvertTypedValue<uint64_t, OutT>(att_id, out_num_components,
+                                                 out_val);
+      case DT_FLOAT32:
+        return ConvertTypedValue<float, OutT>(att_id, out_num_components,
+                                              out_val);
+      case DT_FLOAT64:
+        return ConvertTypedValue<double, OutT>(att_id, out_num_components,
+                                               out_val);
+      case DT_BOOL:
+        return ConvertTypedValue<bool, OutT>(att_id, out_num_components,
+                                             out_val);
+      default:
+        // Wrong attribute type.
+        return false;
+    }
+  }
+
+  // Function for conversion of a attribute to a specific output format.
+  // The |out_value| must be able to store all components of a single attribute
+  // entry.
+  // OutT is the desired data type of the attribute.
+  // Returns false when the conversion failed.
+  template <typename OutT>
+  bool ConvertValue(AttributeValueIndex att_index, OutT *out_value) const {
+    return ConvertValue<OutT>(att_index, num_components_, out_value);
+  }
+
+  // Utility function. Returns |attribute_type| as std::string.
+  static std::string TypeToString(Type attribute_type) {
+    switch (attribute_type) {
+      case INVALID:
+        return "INVALID";
+      case POSITION:
+        return "POSITION";
+      case NORMAL:
+        return "NORMAL";
+      case COLOR:
+        return "COLOR";
+      case TEX_COORD:
+        return "TEX_COORD";
+      case GENERIC:
+        return "GENERIC";
+      default:
+        return "UNKNOWN";
+    }
+  }
+
+  bool operator==(const GeometryAttribute &va) const;
+
+  // Returns the type of the attribute indicating the nature of the attribute.
+  Type attribute_type() const { return attribute_type_; }
+  void set_attribute_type(Type type) { attribute_type_ = type; }
+  // Returns the data type that is stored in the attribute.
+  DataType data_type() const { return data_type_; }
+  // Returns the number of components that are stored for each entry.
+  // For position attribute this is usually three (x,y,z),
+  // while texture coordinates have two components (u,v).
+  int8_t num_components() const { return num_components_; }
+  // Indicates whether the data type should be normalized before interpretation,
+  // that is, it should be divided by the max value of the data type.
+  bool normalized() const { return normalized_; }
+  // The buffer storing the entire data of the attribute.
+  const DataBuffer *buffer() const { return buffer_; }
+  // Returns the number of bytes between two attribute entries, this is, at
+  // least size of the data types times number of components.
+  int64_t byte_stride() const { return byte_stride_; }
+  // The offset where the attribute starts within the block of size byte_stride.
+  int64_t byte_offset() const { return byte_offset_; }
+  void set_byte_offset(int64_t byte_offset) { byte_offset_ = byte_offset; }
+  DataBufferDescriptor buffer_descriptor() const { return buffer_descriptor_; }
+  uint32_t unique_id() const { return unique_id_; }
+  void set_unique_id(uint32_t id) { unique_id_ = id; }
+
+ protected:
+  // Sets a new internal storage for the attribute.
+  void ResetBuffer(DataBuffer *buffer, int64_t byte_stride,
+                   int64_t byte_offset);
+
+ private:
+  // Function for conversion of an attribute to a specific output format given a
+  // format of the stored attribute.
+  // T is the stored attribute data type.
+  // OutT is the desired data type of the attribute.
+  template <typename T, typename OutT>
+  bool ConvertTypedValue(AttributeValueIndex att_id, int8_t out_num_components,
+                         OutT *out_value) const {
+    const uint8_t *src_address = GetAddress(att_id);
+
+    // Convert all components available in both the original and output formats.
+    for (int i = 0; i < std::min(num_components_, out_num_components); ++i) {
+      if (!IsAddressValid(src_address)) {
+        return false;
+      }
+      const T in_value = *reinterpret_cast<const T *>(src_address);
+
+      // Make sure the in_value fits within the range of values that OutT
+      // is able to represent. Perform the check only for integral types.
+      if (std::is_integral<T>::value && std::is_integral<OutT>::value) {
+        static constexpr OutT kOutMin =
+            std::is_signed<T>::value ? std::numeric_limits<OutT>::lowest() : 0;
+        if (in_value < kOutMin || in_value > std::numeric_limits<OutT>::max()) {
+          return false;
+        }
+      }
+
+      out_value[i] = static_cast<OutT>(in_value);
+      // When converting integer to floating point, normalize the value if
+      // necessary.
+      if (std::is_integral<T>::value && std::is_floating_point<OutT>::value &&
+          normalized_) {
+        out_value[i] /= static_cast<OutT>(std::numeric_limits<T>::max());
+      }
+      // TODO(ostava): Add handling of normalized attributes when converting
+      // between different integer representations. If the attribute is
+      // normalized, integer values should be converted as if they represent 0-1
+      // range. E.g. when we convert uint16 to uint8, the range <0, 2^16 - 1>
+      // should be converted to range <0, 2^8 - 1>.
+      src_address += sizeof(T);
+    }
+    // Fill empty data for unused output components if needed.
+    for (int i = num_components_; i < out_num_components; ++i) {
+      out_value[i] = static_cast<OutT>(0);
+    }
+    return true;
+  }
+
+  DataBuffer *buffer_;
+  // The buffer descriptor is stored at the time the buffer is attached to this
+  // attribute. The purpose is to detect if any changes happened to the buffer
+  // since the time it was attached.
+  DataBufferDescriptor buffer_descriptor_;
+  int8_t num_components_;
+  DataType data_type_;
+  bool normalized_;
+  int64_t byte_stride_;
+  int64_t byte_offset_;
+
+  Type attribute_type_;
+
+  // Unique id of this attribute. No two attributes could have the same unique
+  // id. It is used to identify each attribute, especially when there are
+  // multiple attribute of the same type in a point cloud.
+  uint32_t unique_id_;
+
+  friend struct GeometryAttributeHasher;
+};
+
+// Hashing support
+
+// Function object for using Attribute as a hash key.
+struct GeometryAttributeHasher {
+  size_t operator()(const GeometryAttribute &va) const {
+    size_t hash = HashCombine(va.buffer_descriptor_.buffer_id,
+                              va.buffer_descriptor_.buffer_update_count);
+    hash = HashCombine(va.num_components_, hash);
+    hash = HashCombine(static_cast<int8_t>(va.data_type_), hash);
+    hash = HashCombine(static_cast<int8_t>(va.attribute_type_), hash);
+    hash = HashCombine(va.byte_stride_, hash);
+    return HashCombine(va.byte_offset_, hash);
+  }
+};
+
+// Function object for using GeometryAttribute::Type as a hash key.
+struct GeometryAttributeTypeHasher {
+  size_t operator()(const GeometryAttribute::Type &at) const {
+    return static_cast<size_t>(at);
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_GEOMETRY_ATTRIBUTE_H_
diff --git a/contrib/draco/src/draco/attributes/geometry_indices.h b/contrib/draco/src/draco/attributes/geometry_indices.h
new file mode 100644
index 000000000..80e43e30a
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/geometry_indices.h
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_GEOMETRY_INDICES_H_
+#define DRACO_ATTRIBUTES_GEOMETRY_INDICES_H_
+
+#include <inttypes.h>
+
+#include <limits>
+
+#include "draco/core/draco_index_type.h"
+
+namespace draco {
+
+// Index of an attribute value entry stored in a GeometryAttribute.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, AttributeValueIndex)
+// Index of a point in a PointCloud.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, PointIndex)
+// Vertex index in a Mesh or CornerTable.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, VertexIndex)
+// Corner index that identifies a corner in a Mesh or CornerTable.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, CornerIndex)
+// Face index for Mesh and CornerTable.
+DEFINE_NEW_DRACO_INDEX_TYPE(uint32_t, FaceIndex)
+
+// Constants denoting invalid indices.
+static constexpr AttributeValueIndex kInvalidAttributeValueIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr PointIndex kInvalidPointIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr VertexIndex kInvalidVertexIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr CornerIndex kInvalidCornerIndex(
+    std::numeric_limits<uint32_t>::max());
+static constexpr FaceIndex kInvalidFaceIndex(
+    std::numeric_limits<uint32_t>::max());
+
+// TODO(ostava): Add strongly typed indices for attribute id and unique
+// attribute id.
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_GEOMETRY_INDICES_H_
diff --git a/contrib/draco/src/draco/attributes/point_attribute.cc b/contrib/draco/src/draco/attributes/point_attribute.cc
new file mode 100644
index 000000000..b28f860c1
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/point_attribute.cc
@@ -0,0 +1,225 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/attributes/point_attribute.h"
+
+#include <unordered_map>
+
+using std::unordered_map;
+
+// Shortcut for typed conditionals.
+template <bool B, class T, class F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+
+namespace draco {
+
+PointAttribute::PointAttribute()
+    : num_unique_entries_(0), identity_mapping_(false) {}
+
+PointAttribute::PointAttribute(const GeometryAttribute &att)
+    : GeometryAttribute(att),
+      num_unique_entries_(0),
+      identity_mapping_(false) {}
+
+void PointAttribute::Init(Type attribute_type, int8_t num_components,
+                          DataType data_type, bool normalized,
+                          size_t num_attribute_values) {
+  attribute_buffer_ = std::unique_ptr<DataBuffer>(new DataBuffer());
+  GeometryAttribute::Init(attribute_type, attribute_buffer_.get(),
+                          num_components, data_type, normalized,
+                          DataTypeLength(data_type) * num_components, 0);
+  Reset(num_attribute_values);
+  SetIdentityMapping();
+}
+
+void PointAttribute::CopyFrom(const PointAttribute &src_att) {
+  if (buffer() == nullptr) {
+    // If the destination attribute doesn't have a valid buffer, create it.
+    attribute_buffer_ = std::unique_ptr<DataBuffer>(new DataBuffer());
+    ResetBuffer(attribute_buffer_.get(), 0, 0);
+  }
+  if (!GeometryAttribute::CopyFrom(src_att)) {
+    return;
+  }
+  identity_mapping_ = src_att.identity_mapping_;
+  num_unique_entries_ = src_att.num_unique_entries_;
+  indices_map_ = src_att.indices_map_;
+  if (src_att.attribute_transform_data_) {
+    attribute_transform_data_ = std::unique_ptr<AttributeTransformData>(
+        new AttributeTransformData(*src_att.attribute_transform_data_));
+  } else {
+    attribute_transform_data_ = nullptr;
+  }
+}
+
+bool PointAttribute::Reset(size_t num_attribute_values) {
+  if (attribute_buffer_ == nullptr) {
+    attribute_buffer_ = std::unique_ptr<DataBuffer>(new DataBuffer());
+  }
+  const int64_t entry_size = DataTypeLength(data_type()) * num_components();
+  if (!attribute_buffer_->Update(nullptr, num_attribute_values * entry_size)) {
+    return false;
+  }
+  // Assign the new buffer to the parent attribute.
+  ResetBuffer(attribute_buffer_.get(), entry_size, 0);
+  num_unique_entries_ = static_cast<uint32_t>(num_attribute_values);
+  return true;
+}
+
+void PointAttribute::Resize(size_t new_num_unique_entries) {
+  num_unique_entries_ = static_cast<uint32_t>(new_num_unique_entries);
+  attribute_buffer_->Resize(new_num_unique_entries * byte_stride());
+}
+
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+AttributeValueIndex::ValueType PointAttribute::DeduplicateValues(
+    const GeometryAttribute &in_att) {
+  return DeduplicateValues(in_att, AttributeValueIndex(0));
+}
+
+AttributeValueIndex::ValueType PointAttribute::DeduplicateValues(
+    const GeometryAttribute &in_att, AttributeValueIndex in_att_offset) {
+  AttributeValueIndex::ValueType unique_vals = 0;
+  switch (in_att.data_type()) {
+    // Currently we support only float, uint8, and uint16 arguments.
+    case DT_FLOAT32:
+      unique_vals = DeduplicateTypedValues<float>(in_att, in_att_offset);
+      break;
+    case DT_INT8:
+      unique_vals = DeduplicateTypedValues<int8_t>(in_att, in_att_offset);
+      break;
+    case DT_UINT8:
+    case DT_BOOL:
+      unique_vals = DeduplicateTypedValues<uint8_t>(in_att, in_att_offset);
+      break;
+    case DT_UINT16:
+      unique_vals = DeduplicateTypedValues<uint16_t>(in_att, in_att_offset);
+      break;
+    case DT_INT16:
+      unique_vals = DeduplicateTypedValues<int16_t>(in_att, in_att_offset);
+      break;
+    case DT_UINT32:
+      unique_vals = DeduplicateTypedValues<uint32_t>(in_att, in_att_offset);
+      break;
+    case DT_INT32:
+      unique_vals = DeduplicateTypedValues<int32_t>(in_att, in_att_offset);
+      break;
+    default:
+      return -1;  // Unsupported data type.
+  }
+  if (unique_vals == 0) {
+    return -1;  // Unexpected error.
+  }
+  return unique_vals;
+}
+
+// Helper function for calling UnifyDuplicateAttributes<T,num_components_t>
+// with the correct template arguments.
+// Returns the number of unique attribute values.
+template <typename T>
+AttributeValueIndex::ValueType PointAttribute::DeduplicateTypedValues(
+    const GeometryAttribute &in_att, AttributeValueIndex in_att_offset) {
+  // Select the correct method to call based on the number of attribute
+  // components.
+  switch (in_att.num_components()) {
+    case 1:
+      return DeduplicateFormattedValues<T, 1>(in_att, in_att_offset);
+    case 2:
+      return DeduplicateFormattedValues<T, 2>(in_att, in_att_offset);
+    case 3:
+      return DeduplicateFormattedValues<T, 3>(in_att, in_att_offset);
+    case 4:
+      return DeduplicateFormattedValues<T, 4>(in_att, in_att_offset);
+    default:
+      return 0;
+  }
+}
+
+template <typename T, int num_components_t>
+AttributeValueIndex::ValueType PointAttribute::DeduplicateFormattedValues(
+    const GeometryAttribute &in_att, AttributeValueIndex in_att_offset) {
+  // We want to detect duplicates using a hash map but we cannot hash floating
+  // point numbers directly so bit-copy floats to the same sized integers and
+  // hash them.
+
+  // First we need to determine which int type to use (1, 2, 4 or 8 bytes).
+  // Note, this is done at compile time using std::conditional struct.
+  // Conditional is in form <bool-expression, true, false>. If bool-expression
+  // is true the "true" branch is used and vice versa. All at compile time.
+  typedef conditional_t<sizeof(T) == 1, uint8_t,
+                        conditional_t<sizeof(T) == 2, uint16_t,
+                                      conditional_t<sizeof(T) == 4, uint32_t,
+                                                    /*else*/ uint64_t>>>
+      HashType;
+
+  AttributeValueIndex unique_vals(0);
+  typedef std::array<T, num_components_t> AttributeValue;
+  typedef std::array<HashType, num_components_t> AttributeHashableValue;
+  // Hash map storing index of the first attribute with a given value.
+  unordered_map<AttributeHashableValue, AttributeValueIndex,
+                HashArray<AttributeHashableValue>>
+      value_to_index_map;
+  AttributeValue att_value;
+  AttributeHashableValue hashable_value;
+  IndexTypeVector<AttributeValueIndex, AttributeValueIndex> value_map(
+      num_unique_entries_);
+  for (AttributeValueIndex i(0); i < num_unique_entries_; ++i) {
+    const AttributeValueIndex att_pos = i + in_att_offset;
+    att_value = in_att.GetValue<T, num_components_t>(att_pos);
+    // Convert the value to hashable type. Bit-copy real attributes to integers.
+    memcpy(&(hashable_value[0]), &(att_value[0]), sizeof(att_value));
+
+    // Check if the given attribute value has been used before already.
+    auto it = value_to_index_map.find(hashable_value);
+    if (it != value_to_index_map.end()) {
+      // Duplicated value found. Update index mapping.
+      value_map[i] = it->second;
+    } else {
+      // New unique value.
+      // Update the hash map with a new entry pointing to the latest unique
+      // vertex index.
+      value_to_index_map.insert(
+          std::pair<AttributeHashableValue, AttributeValueIndex>(hashable_value,
+                                                                 unique_vals));
+      // Add the unique value to the mesh builder.
+      SetAttributeValue(unique_vals, &att_value);
+      // Update index mapping.
+      value_map[i] = unique_vals;
+
+      ++unique_vals;
+    }
+  }
+  if (unique_vals == num_unique_entries_) {
+    return unique_vals.value();  // Nothing has changed.
+  }
+  if (is_mapping_identity()) {
+    // Change identity mapping to the explicit one.
+    // The number of points is equal to the number of old unique values.
+    SetExplicitMapping(num_unique_entries_);
+    // Update the explicit map.
+    for (uint32_t i = 0; i < num_unique_entries_; ++i) {
+      SetPointMapEntry(PointIndex(i), value_map[AttributeValueIndex(i)]);
+    }
+  } else {
+    // Update point to value map using the mapping between old and new values.
+    for (PointIndex i(0); i < static_cast<uint32_t>(indices_map_.size()); ++i) {
+      SetPointMapEntry(i, value_map[indices_map_[i]]);
+    }
+  }
+  num_unique_entries_ = unique_vals.value();
+  return num_unique_entries_;
+}
+#endif
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/attributes/point_attribute.h b/contrib/draco/src/draco/attributes/point_attribute.h
new file mode 100644
index 000000000..ee3662031
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/point_attribute.h
@@ -0,0 +1,190 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_ATTRIBUTES_POINT_ATTRIBUTE_H_
+#define DRACO_ATTRIBUTES_POINT_ATTRIBUTE_H_
+
+#include <memory>
+
+#include "draco/attributes/attribute_transform_data.h"
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/core/draco_index_type_vector.h"
+#include "draco/core/hash_utils.h"
+#include "draco/core/macros.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for storing point specific data about each attribute. In general,
+// multiple points stored in a point cloud can share the same attribute value
+// and this class provides the necessary mapping between point ids and attribute
+// value ids.
+class PointAttribute : public GeometryAttribute {
+ public:
+  PointAttribute();
+  explicit PointAttribute(const GeometryAttribute &att);
+
+  // Make sure the move constructor is defined (needed for better performance
+  // when new attributes are added to PointCloud).
+  PointAttribute(PointAttribute &&attribute) = default;
+  PointAttribute &operator=(PointAttribute &&attribute) = default;
+
+  // Initializes a point attribute. By default the attribute will be set to
+  // identity mapping between point indices and attribute values. To set custom
+  // mapping use SetExplicitMapping() function.
+  void Init(Type attribute_type, int8_t num_components, DataType data_type,
+            bool normalized, size_t num_attribute_values);
+
+  // Copies attribute data from the provided |src_att| attribute.
+  void CopyFrom(const PointAttribute &src_att);
+
+  // Prepares the attribute storage for the specified number of entries.
+  bool Reset(size_t num_attribute_values);
+
+  size_t size() const { return num_unique_entries_; }
+  AttributeValueIndex mapped_index(PointIndex point_index) const {
+    if (identity_mapping_) {
+      return AttributeValueIndex(point_index.value());
+    }
+    return indices_map_[point_index];
+  }
+  DataBuffer *buffer() const { return attribute_buffer_.get(); }
+  bool is_mapping_identity() const { return identity_mapping_; }
+  size_t indices_map_size() const {
+    if (is_mapping_identity()) {
+      return 0;
+    }
+    return indices_map_.size();
+  }
+
+  const uint8_t *GetAddressOfMappedIndex(PointIndex point_index) const {
+    return GetAddress(mapped_index(point_index));
+  }
+
+  // Sets the new number of unique attribute entries for the attribute. The
+  // function resizes the attribute storage to hold |num_attribute_values|
+  // entries.
+  // All previous entries with AttributeValueIndex < |num_attribute_values|
+  // are preserved. Caller needs to ensure that the PointAttribute is still
+  // valid after the resizing operation (that is, each point is mapped to a
+  // valid attribute value).
+  void Resize(size_t new_num_unique_entries);
+
+  // Functions for setting the type of mapping between point indices and
+  // attribute entry ids.
+  // This function sets the mapping to implicit, where point indices are equal
+  // to attribute entry indices.
+  void SetIdentityMapping() {
+    identity_mapping_ = true;
+    indices_map_.clear();
+  }
+  // This function sets the mapping to be explicitly using the indices_map_
+  // array that needs to be initialized by the caller.
+  void SetExplicitMapping(size_t num_points) {
+    identity_mapping_ = false;
+    indices_map_.resize(num_points, kInvalidAttributeValueIndex);
+  }
+
+  // Set an explicit map entry for a specific point index.
+  void SetPointMapEntry(PointIndex point_index,
+                        AttributeValueIndex entry_index) {
+    DRACO_DCHECK(!identity_mapping_);
+    indices_map_[point_index] = entry_index;
+  }
+
+  // Same as GeometryAttribute::GetValue(), but using point id as the input.
+  // Mapping to attribute value index is performed automatically.
+  void GetMappedValue(PointIndex point_index, void *out_data) const {
+    return GetValue(mapped_index(point_index), out_data);
+  }
+
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  // Deduplicate |in_att| values into |this| attribute. |in_att| can be equal
+  // to |this|.
+  // Returns -1 if the deduplication failed.
+  AttributeValueIndex::ValueType DeduplicateValues(
+      const GeometryAttribute &in_att);
+
+  // Same as above but the values read from |in_att| are sampled with the
+  // provided offset |in_att_offset|.
+  AttributeValueIndex::ValueType DeduplicateValues(
+      const GeometryAttribute &in_att, AttributeValueIndex in_att_offset);
+#endif
+
+  // Set attribute transform data for the attribute. The data is used to store
+  // the type and parameters of the transform that is applied on the attribute
+  // data (optional).
+  void SetAttributeTransformData(
+      std::unique_ptr<AttributeTransformData> transform_data) {
+    attribute_transform_data_ = std::move(transform_data);
+  }
+  const AttributeTransformData *GetAttributeTransformData() const {
+    return attribute_transform_data_.get();
+  }
+
+ private:
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  template <typename T>
+  AttributeValueIndex::ValueType DeduplicateTypedValues(
+      const GeometryAttribute &in_att, AttributeValueIndex in_att_offset);
+  template <typename T, int COMPONENTS_COUNT>
+  AttributeValueIndex::ValueType DeduplicateFormattedValues(
+      const GeometryAttribute &in_att, AttributeValueIndex in_att_offset);
+#endif
+
+  // Data storage for attribute values. GeometryAttribute itself doesn't own its
+  // buffer so we need to allocate it here.
+  std::unique_ptr<DataBuffer> attribute_buffer_;
+
+  // Mapping between point ids and attribute value ids.
+  IndexTypeVector<PointIndex, AttributeValueIndex> indices_map_;
+  AttributeValueIndex::ValueType num_unique_entries_;
+  // Flag when the mapping between point ids and attribute values is identity.
+  bool identity_mapping_;
+
+  // If an attribute contains transformed data (e.g. quantized), we can specify
+  // the attribute transform here and use it to transform the attribute back to
+  // its original format.
+  std::unique_ptr<AttributeTransformData> attribute_transform_data_;
+
+  friend struct PointAttributeHasher;
+};
+
+// Hash functor for the PointAttribute class.
+struct PointAttributeHasher {
+  size_t operator()(const PointAttribute &attribute) const {
+    GeometryAttributeHasher base_hasher;
+    size_t hash = base_hasher(attribute);
+    hash = HashCombine(attribute.identity_mapping_, hash);
+    hash = HashCombine(attribute.num_unique_entries_, hash);
+    hash = HashCombine(attribute.indices_map_.size(), hash);
+    if (!attribute.indices_map_.empty()) {
+      const uint64_t indices_hash = FingerprintString(
+          reinterpret_cast<const char *>(attribute.indices_map_.data()),
+          attribute.indices_map_.size());
+      hash = HashCombine(indices_hash, hash);
+    }
+    if (attribute.attribute_buffer_ != nullptr) {
+      const uint64_t buffer_hash = FingerprintString(
+          reinterpret_cast<const char *>(attribute.attribute_buffer_->data()),
+          attribute.attribute_buffer_->data_size());
+      hash = HashCombine(buffer_hash, hash);
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_ATTRIBUTES_POINT_ATTRIBUTE_H_
diff --git a/contrib/draco/src/draco/attributes/point_attribute_test.cc b/contrib/draco/src/draco/attributes/point_attribute_test.cc
new file mode 100644
index 000000000..4ae23fb3c
--- /dev/null
+++ b/contrib/draco/src/draco/attributes/point_attribute_test.cc
@@ -0,0 +1,128 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/attributes/point_attribute.h"
+
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+class PointAttributeTest : public ::testing::Test {
+ protected:
+  PointAttributeTest() {}
+};
+
+TEST_F(PointAttributeTest, TestCopy) {
+  // This test verifies that PointAttribute can copy data from another point
+  // attribute.
+  draco::PointAttribute pa;
+  pa.Init(draco::GeometryAttribute::POSITION, 1, draco::DT_INT32, false, 10);
+
+  for (int32_t i = 0; i < 10; ++i) {
+    pa.SetAttributeValue(draco::AttributeValueIndex(i), &i);
+  }
+
+  pa.set_unique_id(12);
+
+  draco::PointAttribute other_pa;
+  other_pa.CopyFrom(pa);
+
+  draco::PointAttributeHasher hasher;
+  ASSERT_EQ(hasher(pa), hasher(other_pa));
+  ASSERT_EQ(pa.unique_id(), other_pa.unique_id());
+
+  // The hash function does not actually compute the hash from attribute values,
+  // so ensure the data got copied correctly as well.
+  for (int32_t i = 0; i < 10; ++i) {
+    int32_t data;
+    other_pa.GetValue(draco::AttributeValueIndex(i), &data);
+    ASSERT_EQ(data, i);
+  }
+}
+
+TEST_F(PointAttributeTest, TestGetValueFloat) {
+  draco::PointAttribute pa;
+  pa.Init(draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32, false, 5);
+  float points[3];
+  for (int32_t i = 0; i < 5; ++i) {
+    points[0] = i * 3.0;
+    points[1] = (i * 3.0) + 1.0;
+    points[2] = (i * 3.0) + 2.0;
+    pa.SetAttributeValue(draco::AttributeValueIndex(i), &points);
+  }
+
+  for (int32_t i = 0; i < 5; ++i) {
+    pa.GetValue(draco::AttributeValueIndex(i), &points);
+    ASSERT_FLOAT_EQ(points[0], i * 3.0);
+    ASSERT_FLOAT_EQ(points[1], (i * 3.0) + 1.0);
+    ASSERT_FLOAT_EQ(points[2], (i * 3.0) + 2.0);
+  }
+}
+
+TEST_F(PointAttributeTest, TestGetArray) {
+  draco::PointAttribute pa;
+  pa.Init(draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32, false, 5);
+  float points[3];
+  for (int32_t i = 0; i < 5; ++i) {
+    points[0] = i * 3.0;
+    points[1] = (i * 3.0) + 1.0;
+    points[2] = (i * 3.0) + 2.0;
+    pa.SetAttributeValue(draco::AttributeValueIndex(i), &points);
+  }
+
+  for (int32_t i = 0; i < 5; ++i) {
+    std::array<float, 3> att_value;
+    att_value = pa.GetValue<float, 3>(draco::AttributeValueIndex(i));
+    ASSERT_FLOAT_EQ(att_value[0], i * 3.0);
+    ASSERT_FLOAT_EQ(att_value[1], (i * 3.0) + 1.0);
+    ASSERT_FLOAT_EQ(att_value[2], (i * 3.0) + 2.0);
+  }
+  for (int32_t i = 0; i < 5; ++i) {
+    std::array<float, 3> att_value;
+    EXPECT_TRUE(
+        (pa.GetValue<float, 3>(draco::AttributeValueIndex(i), &att_value)));
+    ASSERT_FLOAT_EQ(att_value[0], i * 3.0);
+    ASSERT_FLOAT_EQ(att_value[1], (i * 3.0) + 1.0);
+    ASSERT_FLOAT_EQ(att_value[2], (i * 3.0) + 2.0);
+  }
+}
+
+TEST_F(PointAttributeTest, TestArrayReadError) {
+  draco::PointAttribute pa;
+  pa.Init(draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32, false, 5);
+  float points[3];
+  for (int32_t i = 0; i < 5; ++i) {
+    points[0] = i * 3.0;
+    points[1] = (i * 3.0) + 1.0;
+    points[2] = (i * 3.0) + 2.0;
+    pa.SetAttributeValue(draco::AttributeValueIndex(i), &points);
+  }
+
+  std::array<float, 3> att_value;
+  EXPECT_FALSE(
+      (pa.GetValue<float, 3>(draco::AttributeValueIndex(5), &att_value)));
+}
+
+TEST_F(PointAttributeTest, TestResize) {
+  draco::PointAttribute pa;
+  pa.Init(draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32, false, 5);
+  ASSERT_EQ(pa.size(), 5);
+  ASSERT_EQ(pa.buffer()->data_size(), 4 * 3 * 5);
+
+  pa.Resize(10);
+  ASSERT_EQ(pa.size(), 10);
+  ASSERT_EQ(pa.buffer()->data_size(), 4 * 3 * 10);
+}
+
+}  // namespace
diff --git a/contrib/draco/src/draco/compression/attributes/attributes_decoder.cc b/contrib/draco/src/draco/compression/attributes/attributes_decoder.cc
new file mode 100644
index 000000000..007dd2f43
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/attributes_decoder.cc
@@ -0,0 +1,127 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/attributes_decoder.h"
+
+#include "draco/core/varint_decoding.h"
+
+namespace draco {
+
+AttributesDecoder::AttributesDecoder()
+    : point_cloud_decoder_(nullptr), point_cloud_(nullptr) {}
+
+bool AttributesDecoder::Init(PointCloudDecoder *decoder, PointCloud *pc) {
+  point_cloud_decoder_ = decoder;
+  point_cloud_ = pc;
+  return true;
+}
+
+bool AttributesDecoder::DecodeAttributesDecoderData(DecoderBuffer *in_buffer) {
+  // Decode and create attributes.
+  uint32_t num_attributes;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (point_cloud_decoder_->bitstream_version() <
+      DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!in_buffer->Decode(&num_attributes)) {
+      return false;
+    }
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_attributes, in_buffer)) {
+      return false;
+    }
+  }
+
+  // Check that decoded number of attributes is valid.
+  if (num_attributes == 0) {
+    return false;
+  }
+  if (num_attributes > 5 * in_buffer->remaining_size()) {
+    // The decoded number of attributes is unreasonably high, because at least
+    // five bytes of attribute descriptor data per attribute are expected.
+    return false;
+  }
+
+  // Decode attribute descriptor data.
+  point_attribute_ids_.resize(num_attributes);
+  PointCloud *pc = point_cloud_;
+  for (uint32_t i = 0; i < num_attributes; ++i) {
+    // Decode attribute descriptor data.
+    uint8_t att_type, data_type, num_components, normalized;
+    if (!in_buffer->Decode(&att_type)) {
+      return false;
+    }
+    if (!in_buffer->Decode(&data_type)) {
+      return false;
+    }
+    if (!in_buffer->Decode(&num_components)) {
+      return false;
+    }
+    if (!in_buffer->Decode(&normalized)) {
+      return false;
+    }
+    if (att_type >= GeometryAttribute::NAMED_ATTRIBUTES_COUNT) {
+      return false;
+    }
+    if (data_type == DT_INVALID || data_type >= DT_TYPES_COUNT) {
+      return false;
+    }
+
+    // Check decoded attribute descriptor data.
+    if (num_components == 0) {
+      return false;
+    }
+
+    // Add the attribute to the point cloud.
+    const DataType draco_dt = static_cast<DataType>(data_type);
+    GeometryAttribute ga;
+    ga.Init(static_cast<GeometryAttribute::Type>(att_type), nullptr,
+            num_components, draco_dt, normalized > 0,
+            DataTypeLength(draco_dt) * num_components, 0);
+    uint32_t unique_id;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (point_cloud_decoder_->bitstream_version() <
+        DRACO_BITSTREAM_VERSION(1, 3)) {
+      uint16_t custom_id;
+      if (!in_buffer->Decode(&custom_id)) {
+        return false;
+      }
+      // TODO(draco-eng): Add "custom_id" to attribute metadata.
+      unique_id = static_cast<uint32_t>(custom_id);
+      ga.set_unique_id(unique_id);
+    } else
+#endif
+    {
+      if (!DecodeVarint(&unique_id, in_buffer)) {
+        return false;
+      }
+      ga.set_unique_id(unique_id);
+    }
+    const int att_id = pc->AddAttribute(
+        std::unique_ptr<PointAttribute>(new PointAttribute(ga)));
+    pc->attribute(att_id)->set_unique_id(unique_id);
+    point_attribute_ids_[i] = att_id;
+
+    // Update the inverse map.
+    if (att_id >=
+        static_cast<int32_t>(point_attribute_to_local_id_map_.size())) {
+      point_attribute_to_local_id_map_.resize(att_id + 1, -1);
+    }
+    point_attribute_to_local_id_map_[att_id] = i;
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/attributes_decoder.h b/contrib/draco/src/draco/compression/attributes/attributes_decoder.h
new file mode 100644
index 000000000..5b2bb2cfe
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/attributes_decoder.h
@@ -0,0 +1,97 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_H_
+
+#include <vector>
+
+#include "draco/compression/attributes/attributes_decoder_interface.h"
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/draco_features.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Base class for decoding one or more attributes that were encoded with a
+// matching AttributesEncoder. It is a basic implementation of
+// AttributesDecoderInterface that provides functionality that is shared between
+// all AttributesDecoders.
+class AttributesDecoder : public AttributesDecoderInterface {
+ public:
+  AttributesDecoder();
+  virtual ~AttributesDecoder() = default;
+
+  // Called after all attribute decoders are created. It can be used to perform
+  // any custom initialization.
+  bool Init(PointCloudDecoder *decoder, PointCloud *pc) override;
+
+  // Decodes any attribute decoder specific data from the |in_buffer|.
+  bool DecodeAttributesDecoderData(DecoderBuffer *in_buffer) override;
+
+  int32_t GetAttributeId(int i) const override {
+    return point_attribute_ids_[i];
+  }
+  int32_t GetNumAttributes() const override {
+    return static_cast<int32_t>(point_attribute_ids_.size());
+  }
+  PointCloudDecoder *GetDecoder() const override {
+    return point_cloud_decoder_;
+  }
+
+  // Decodes attribute data from the source buffer.
+  bool DecodeAttributes(DecoderBuffer *in_buffer) override {
+    if (!DecodePortableAttributes(in_buffer)) {
+      return false;
+    }
+    if (!DecodeDataNeededByPortableTransforms(in_buffer)) {
+      return false;
+    }
+    if (!TransformAttributesToOriginalFormat()) {
+      return false;
+    }
+    return true;
+  }
+
+ protected:
+  int32_t GetLocalIdForPointAttribute(int32_t point_attribute_id) const {
+    const int id_map_size =
+        static_cast<int>(point_attribute_to_local_id_map_.size());
+    if (point_attribute_id >= id_map_size) {
+      return -1;
+    }
+    return point_attribute_to_local_id_map_[point_attribute_id];
+  }
+  virtual bool DecodePortableAttributes(DecoderBuffer *in_buffer) = 0;
+  virtual bool DecodeDataNeededByPortableTransforms(DecoderBuffer *in_buffer) {
+    return true;
+  }
+  virtual bool TransformAttributesToOriginalFormat() { return true; }
+
+ private:
+  // List of attribute ids that need to be decoded with this decoder.
+  std::vector<int32_t> point_attribute_ids_;
+
+  // Map between point attribute id and the local id (i.e., the inverse of the
+  // |point_attribute_ids_|.
+  std::vector<int32_t> point_attribute_to_local_id_map_;
+
+  PointCloudDecoder *point_cloud_decoder_;
+  PointCloud *point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/attributes_decoder_interface.h b/contrib/draco/src/draco/compression/attributes/attributes_decoder_interface.h
new file mode 100644
index 000000000..8e5cf52ac
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/attributes_decoder_interface.h
@@ -0,0 +1,62 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_INTERFACE_H_
+
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+class PointCloudDecoder;
+
+// Interface class for decoding one or more attributes that were encoded with a
+// matching AttributesEncoder. It provides only the basic interface
+// that is used by the PointCloudDecoder. The actual decoding must be
+// implemented in derived classes using the DecodeAttributes() method.
+class AttributesDecoderInterface {
+ public:
+  AttributesDecoderInterface() = default;
+  virtual ~AttributesDecoderInterface() = default;
+
+  // Called after all attribute decoders are created. It can be used to perform
+  // any custom initialization.
+  virtual bool Init(PointCloudDecoder *decoder, PointCloud *pc) = 0;
+
+  // Decodes any attribute decoder specific data from the |in_buffer|.
+  virtual bool DecodeAttributesDecoderData(DecoderBuffer *in_buffer) = 0;
+
+  // Decode attribute data from the source buffer. Needs to be implemented by
+  // the derived classes.
+  virtual bool DecodeAttributes(DecoderBuffer *in_buffer) = 0;
+
+  virtual int32_t GetAttributeId(int i) const = 0;
+  virtual int32_t GetNumAttributes() const = 0;
+  virtual PointCloudDecoder *GetDecoder() const = 0;
+
+  // Returns an attribute containing data processed by the attribute transform.
+  // (see TransformToPortableFormat() method). This data is guaranteed to be
+  // same for encoder and decoder and it can be used by predictors.
+  virtual const PointAttribute *GetPortableAttribute(
+      int32_t /* point_attribute_id */) {
+    return nullptr;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_DECODER_INTERFACE_H_
diff --git a/contrib/draco/src/draco/compression/attributes/attributes_encoder.cc b/contrib/draco/src/draco/compression/attributes/attributes_encoder.cc
new file mode 100644
index 000000000..797c62f30
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/attributes_encoder.cc
@@ -0,0 +1,49 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/attributes_encoder.h"
+
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+AttributesEncoder::AttributesEncoder()
+    : point_cloud_encoder_(nullptr), point_cloud_(nullptr) {}
+
+AttributesEncoder::AttributesEncoder(int att_id) : AttributesEncoder() {
+  AddAttributeId(att_id);
+}
+
+bool AttributesEncoder::Init(PointCloudEncoder *encoder, const PointCloud *pc) {
+  point_cloud_encoder_ = encoder;
+  point_cloud_ = pc;
+  return true;
+}
+
+bool AttributesEncoder::EncodeAttributesEncoderData(EncoderBuffer *out_buffer) {
+  // Encode data about all attributes.
+  EncodeVarint(num_attributes(), out_buffer);
+  for (uint32_t i = 0; i < num_attributes(); ++i) {
+    const int32_t att_id = point_attribute_ids_[i];
+    const PointAttribute *const pa = point_cloud_->attribute(att_id);
+    out_buffer->Encode(static_cast<uint8_t>(pa->attribute_type()));
+    out_buffer->Encode(static_cast<uint8_t>(pa->data_type()));
+    out_buffer->Encode(static_cast<uint8_t>(pa->num_components()));
+    out_buffer->Encode(static_cast<uint8_t>(pa->normalized()));
+    EncodeVarint(pa->unique_id(), out_buffer);
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/attributes_encoder.h b/contrib/draco/src/draco/compression/attributes/attributes_encoder.h
new file mode 100644
index 000000000..9de846ae6
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/attributes_encoder.h
@@ -0,0 +1,154 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_ENCODER_H_
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+class PointCloudEncoder;
+
+// Base class for encoding one or more attributes of a PointCloud (or other
+// geometry). This base class provides only the basic interface that is used
+// by the PointCloudEncoder.
+class AttributesEncoder {
+ public:
+  AttributesEncoder();
+  // Constructs an attribute encoder associated with a given point attribute.
+  explicit AttributesEncoder(int point_attrib_id);
+  virtual ~AttributesEncoder() = default;
+
+  // Called after all attribute encoders are created. It can be used to perform
+  // any custom initialization, including setting up attribute dependencies.
+  // Note: no data should be encoded in this function, because the decoder may
+  // process encoders in a different order from the decoder.
+  virtual bool Init(PointCloudEncoder *encoder, const PointCloud *pc);
+
+  // Encodes data needed by the target attribute decoder.
+  virtual bool EncodeAttributesEncoderData(EncoderBuffer *out_buffer);
+
+  // Returns a unique identifier of the given encoder type, that is used during
+  // decoding to construct the corresponding attribute decoder.
+  virtual uint8_t GetUniqueId() const = 0;
+
+  // Encode attribute data to the target buffer.
+  virtual bool EncodeAttributes(EncoderBuffer *out_buffer) {
+    if (!TransformAttributesToPortableFormat()) {
+      return false;
+    }
+    if (!EncodePortableAttributes(out_buffer)) {
+      return false;
+    }
+    // Encode data needed by portable transforms after the attribute is encoded.
+    // This corresponds to the order in which the data is going to be decoded by
+    // the decoder.
+    if (!EncodeDataNeededByPortableTransforms(out_buffer)) {
+      return false;
+    }
+    return true;
+  }
+
+  // Returns the number of attributes that need to be encoded before the
+  // specified attribute is encoded.
+  // Note that the attribute is specified by its point attribute id.
+  virtual int NumParentAttributes(int32_t /* point_attribute_id */) const {
+    return 0;
+  }
+
+  virtual int GetParentAttributeId(int32_t /* point_attribute_id */,
+                                   int32_t /* parent_i */) const {
+    return -1;
+  }
+
+  // Marks a given attribute as a parent of another attribute.
+  virtual bool MarkParentAttribute(int32_t /* point_attribute_id */) {
+    return false;
+  }
+
+  // Returns an attribute containing data processed by the attribute transform.
+  // (see TransformToPortableFormat() method). This data is guaranteed to be
+  // encoded losslessly and it can be safely used for predictors.
+  virtual const PointAttribute *GetPortableAttribute(
+      int32_t /* point_attribute_id */) {
+    return nullptr;
+  }
+
+  void AddAttributeId(int32_t id) {
+    point_attribute_ids_.push_back(id);
+    if (id >= static_cast<int32_t>(point_attribute_to_local_id_map_.size())) {
+      point_attribute_to_local_id_map_.resize(id + 1, -1);
+    }
+    point_attribute_to_local_id_map_[id] =
+        static_cast<int32_t>(point_attribute_ids_.size()) - 1;
+  }
+
+  // Sets new attribute point ids (replacing the existing ones).
+  void SetAttributeIds(const std::vector<int32_t> &point_attribute_ids) {
+    point_attribute_ids_.clear();
+    point_attribute_to_local_id_map_.clear();
+    for (int32_t att_id : point_attribute_ids) {
+      AddAttributeId(att_id);
+    }
+  }
+
+  int32_t GetAttributeId(int i) const { return point_attribute_ids_[i]; }
+  uint32_t num_attributes() const {
+    return static_cast<uint32_t>(point_attribute_ids_.size());
+  }
+  PointCloudEncoder *encoder() const { return point_cloud_encoder_; }
+
+ protected:
+  // Transforms the input attribute data into a form that should be losslessly
+  // encoded (transform itself can be lossy).
+  virtual bool TransformAttributesToPortableFormat() { return true; }
+
+  // Losslessly encodes data of all portable attributes.
+  // Precondition: All attributes must have been transformed into portable
+  // format at this point (see TransformAttributesToPortableFormat() method).
+  virtual bool EncodePortableAttributes(EncoderBuffer *out_buffer) = 0;
+
+  // Encodes any data needed to revert the transform to portable format for each
+  // attribute (e.g. data needed for dequantization of quantized values).
+  virtual bool EncodeDataNeededByPortableTransforms(EncoderBuffer *out_buffer) {
+    return true;
+  }
+
+  int32_t GetLocalIdForPointAttribute(int32_t point_attribute_id) const {
+    const int id_map_size =
+        static_cast<int>(point_attribute_to_local_id_map_.size());
+    if (point_attribute_id >= id_map_size) {
+      return -1;
+    }
+    return point_attribute_to_local_id_map_[point_attribute_id];
+  }
+
+ private:
+  // List of attribute ids that need to be encoded with this encoder.
+  std::vector<int32_t> point_attribute_ids_;
+
+  // Map between point attribute id and the local id (i.e., the inverse of the
+  // |point_attribute_ids_|.
+  std::vector<int32_t> point_attribute_to_local_id_map_;
+
+  PointCloudEncoder *point_cloud_encoder_;
+  const PointCloud *point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_ATTRIBUTES_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.cc b/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.cc
new file mode 100644
index 000000000..e4d53485d
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.cc
@@ -0,0 +1,556 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/kd_tree_attributes_decoder.h"
+
+#include "draco/compression/attributes/kd_tree_attributes_shared.h"
+#include "draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h"
+#include "draco/compression/point_cloud/algorithms/float_points_tree_decoder.h"
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+#include "draco/core/draco_types.h"
+#include "draco/core/varint_decoding.h"
+
+namespace draco {
+
+// attribute, offset_dimensionality, data_type, data_size, num_components
+using AttributeTuple =
+    std::tuple<PointAttribute *, uint32_t, DataType, uint32_t, uint32_t>;
+
+// Output iterator that is used to decode values directly into the data buffer
+// of the modified PointAttribute.
+// The extension of this iterator beyond the DT_UINT32 concerns itself only with
+// the size of the data for efficiency, not the type.  DataType is conveyed in
+// but is an unused field populated for any future logic/special casing.
+// DT_UINT32 and all other 4-byte types are naturally supported from the size of
+// data in the kd tree encoder.  DT_UINT16 and DT_UINT8 are supported by way
+// of byte copies into a temporary memory buffer.
+template <class CoeffT>
+class PointAttributeVectorOutputIterator {
+  typedef PointAttributeVectorOutputIterator<CoeffT> Self;
+
+ public:
+  PointAttributeVectorOutputIterator(
+      PointAttributeVectorOutputIterator &&that) = default;
+
+  explicit PointAttributeVectorOutputIterator(
+      const std::vector<AttributeTuple> &atts)
+      : attributes_(atts), point_id_(0) {
+    DRACO_DCHECK_GE(atts.size(), 1);
+    uint32_t required_decode_bytes = 0;
+    for (auto index = 0; index < attributes_.size(); index++) {
+      const AttributeTuple &att = attributes_[index];
+      required_decode_bytes = (std::max)(required_decode_bytes,
+                                         std::get<3>(att) * std::get<4>(att));
+    }
+    memory_.resize(required_decode_bytes);
+    data_ = memory_.data();
+  }
+
+  const Self &operator++() {
+    ++point_id_;
+    return *this;
+  }
+
+  // We do not want to do ANY copying of this constructor so this particular
+  // operator is disabled for performance reasons.
+  // Self operator++(int) {
+  //   Self copy = *this;
+  //   ++point_id_;
+  //   return copy;
+  // }
+
+  Self &operator*() { return *this; }
+  // Still needed in some cases.
+  // TODO(hemmer): remove.
+  // hardcoded to 3 based on legacy usage.
+  const Self &operator=(const VectorD<CoeffT, 3> &val) {
+    DRACO_DCHECK_EQ(attributes_.size(), 1);  // Expect only ONE attribute.
+    AttributeTuple &att = attributes_[0];
+    PointAttribute *attribute = std::get<0>(att);
+    const uint32_t &offset = std::get<1>(att);
+    DRACO_DCHECK_EQ(offset, 0);  // expected to be zero
+    attribute->SetAttributeValue(attribute->mapped_index(point_id_),
+                                 &val[0] + offset);
+    return *this;
+  }
+  // Additional operator taking std::vector as argument.
+  const Self &operator=(const std::vector<CoeffT> &val) {
+    for (auto index = 0; index < attributes_.size(); index++) {
+      AttributeTuple &att = attributes_[index];
+      PointAttribute *attribute = std::get<0>(att);
+      const uint32_t &offset = std::get<1>(att);
+      const uint32_t &data_size = std::get<3>(att);
+      const uint32_t &num_components = std::get<4>(att);
+      const uint32_t *data_source = val.data() + offset;
+      if (data_size < 4) {  // handle uint16_t, uint8_t
+        // selectively copy data bytes
+        uint8_t *data_counter = data_;
+        for (uint32_t index = 0; index < num_components;
+             index += 1, data_counter += data_size) {
+          std::memcpy(data_counter, data_source + index, data_size);
+        }
+        // redirect to copied data
+        data_source = reinterpret_cast<uint32_t *>(data_);
+      }
+      const AttributeValueIndex avi = attribute->mapped_index(point_id_);
+      if (avi >= static_cast<uint32_t>(attribute->size())) {
+        return *this;
+      }
+      attribute->SetAttributeValue(avi, data_source);
+    }
+    return *this;
+  }
+
+ private:
+  // preallocated memory for buffering different data sizes.  Never reallocated.
+  std::vector<uint8_t> memory_;
+  uint8_t *data_;
+  std::vector<AttributeTuple> attributes_;
+  PointIndex point_id_;
+
+  // NO COPY
+  PointAttributeVectorOutputIterator(
+      const PointAttributeVectorOutputIterator &that) = delete;
+  PointAttributeVectorOutputIterator &operator=(
+      PointAttributeVectorOutputIterator const &) = delete;
+};
+
+KdTreeAttributesDecoder::KdTreeAttributesDecoder() {}
+
+bool KdTreeAttributesDecoder::DecodePortableAttributes(
+    DecoderBuffer *in_buffer) {
+  if (in_buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 3)) {
+    // Old bitstream does everything in the
+    // DecodeDataNeededByPortableTransforms() method.
+    return true;
+  }
+  uint8_t compression_level = 0;
+  if (!in_buffer->Decode(&compression_level)) {
+    return false;
+  }
+  const int32_t num_points = GetDecoder()->point_cloud()->num_points();
+
+  // Decode data using the kd tree decoding into integer (portable) attributes.
+  // We first need to go over all attributes and create a new portable storage
+  // for those attributes that need it (floating point attributes that have to
+  // be dequantized after decoding).
+
+  const int num_attributes = GetNumAttributes();
+  uint32_t total_dimensionality = 0;  // position is a required dimension
+  std::vector<AttributeTuple> atts(num_attributes);
+
+  for (int i = 0; i < GetNumAttributes(); ++i) {
+    const int att_id = GetAttributeId(i);
+    PointAttribute *const att = GetDecoder()->point_cloud()->attribute(att_id);
+    // All attributes have the same number of values and identity mapping
+    // between PointIndex and AttributeValueIndex.
+    att->Reset(num_points);
+    att->SetIdentityMapping();
+
+    PointAttribute *target_att = nullptr;
+    if (att->data_type() == DT_UINT32 || att->data_type() == DT_UINT16 ||
+        att->data_type() == DT_UINT8) {
+      // We can decode to these attributes directly.
+      target_att = att;
+    } else if (att->data_type() == DT_INT32 || att->data_type() == DT_INT16 ||
+               att->data_type() == DT_INT8) {
+      // Prepare storage for data that is used to convert unsigned values back
+      // to the signed ones.
+      for (int c = 0; c < att->num_components(); ++c) {
+        min_signed_values_.push_back(0);
+      }
+      target_att = att;
+    } else if (att->data_type() == DT_FLOAT32) {
+      // Create a portable attribute that will hold the decoded data. We will
+      // dequantize the decoded data to the final attribute later on.
+      const int num_components = att->num_components();
+      GeometryAttribute va;
+      va.Init(att->attribute_type(), nullptr, num_components, DT_UINT32, false,
+              num_components * DataTypeLength(DT_UINT32), 0);
+      std::unique_ptr<PointAttribute> port_att(new PointAttribute(va));
+      port_att->SetIdentityMapping();
+      port_att->Reset(num_points);
+      quantized_portable_attributes_.push_back(std::move(port_att));
+      target_att = quantized_portable_attributes_.back().get();
+    } else {
+      // Unsupported type.
+      return false;
+    }
+    // Add attribute to the output iterator used by the core algorithm.
+    const DataType data_type = target_att->data_type();
+    const uint32_t data_size = (std::max)(0, DataTypeLength(data_type));
+    const uint32_t num_components = target_att->num_components();
+    atts[i] = std::make_tuple(target_att, total_dimensionality, data_type,
+                              data_size, num_components);
+    total_dimensionality += num_components;
+  }
+  PointAttributeVectorOutputIterator<uint32_t> out_it(atts);
+
+  switch (compression_level) {
+    case 0: {
+      DynamicIntegerPointsKdTreeDecoder<0> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    case 1: {
+      DynamicIntegerPointsKdTreeDecoder<1> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    case 2: {
+      DynamicIntegerPointsKdTreeDecoder<2> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    case 3: {
+      DynamicIntegerPointsKdTreeDecoder<3> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    case 4: {
+      DynamicIntegerPointsKdTreeDecoder<4> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    case 5: {
+      DynamicIntegerPointsKdTreeDecoder<5> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    case 6: {
+      DynamicIntegerPointsKdTreeDecoder<6> decoder(total_dimensionality);
+      if (!decoder.DecodePoints(in_buffer, out_it)) {
+        return false;
+      }
+      break;
+    }
+    default:
+      return false;
+  }
+  return true;
+}
+
+bool KdTreeAttributesDecoder::DecodeDataNeededByPortableTransforms(
+    DecoderBuffer *in_buffer) {
+  if (in_buffer->bitstream_version() >= DRACO_BITSTREAM_VERSION(2, 3)) {
+    // Decode quantization data for each attribute that need it.
+    // TODO(ostava): This should be moved to AttributeQuantizationTransform.
+    std::vector<float> min_value;
+    for (int i = 0; i < GetNumAttributes(); ++i) {
+      const int att_id = GetAttributeId(i);
+      const PointAttribute *const att =
+          GetDecoder()->point_cloud()->attribute(att_id);
+      if (att->data_type() == DT_FLOAT32) {
+        const int num_components = att->num_components();
+        min_value.resize(num_components);
+        if (!in_buffer->Decode(&min_value[0], sizeof(float) * num_components)) {
+          return false;
+        }
+        float max_value_dif;
+        if (!in_buffer->Decode(&max_value_dif)) {
+          return false;
+        }
+        uint8_t quantization_bits;
+        if (!in_buffer->Decode(&quantization_bits) || quantization_bits > 31) {
+          return false;
+        }
+        AttributeQuantizationTransform transform;
+        if (!transform.SetParameters(quantization_bits, min_value.data(),
+                                     num_components, max_value_dif)) {
+          return false;
+        }
+        const int num_transforms =
+            static_cast<int>(attribute_quantization_transforms_.size());
+        if (!transform.TransferToAttribute(
+                quantized_portable_attributes_[num_transforms].get())) {
+          return false;
+        }
+        attribute_quantization_transforms_.push_back(transform);
+      }
+    }
+
+    // Decode transform data for signed integer attributes.
+    for (int i = 0; i < min_signed_values_.size(); ++i) {
+      int32_t val;
+      if (!DecodeVarint(&val, in_buffer)) {
+        return false;
+      }
+      min_signed_values_[i] = val;
+    }
+    return true;
+  }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  // Handle old bitstream
+  // Figure out the total dimensionality of the point cloud
+  const uint32_t attribute_count = GetNumAttributes();
+  uint32_t total_dimensionality = 0;  // position is a required dimension
+  std::vector<AttributeTuple> atts(attribute_count);
+  for (auto attribute_index = 0;
+       static_cast<uint32_t>(attribute_index) < attribute_count;
+       attribute_index += 1)  // increment the dimensionality as needed...
+  {
+    const int att_id = GetAttributeId(attribute_index);
+    PointAttribute *const att = GetDecoder()->point_cloud()->attribute(att_id);
+    const DataType data_type = att->data_type();
+    const uint32_t data_size = (std::max)(0, DataTypeLength(data_type));
+    const uint32_t num_components = att->num_components();
+    if (data_size > 4) {
+      return false;
+    }
+
+    atts[attribute_index] = std::make_tuple(
+        att, total_dimensionality, data_type, data_size, num_components);
+    // everything is treated as 32bit in the encoder.
+    total_dimensionality += num_components;
+  }
+
+  const int att_id = GetAttributeId(0);
+  PointAttribute *const att = GetDecoder()->point_cloud()->attribute(att_id);
+  att->SetIdentityMapping();
+  // Decode method
+  uint8_t method;
+  if (!in_buffer->Decode(&method)) {
+    return false;
+  }
+  if (method == KdTreeAttributesEncodingMethod::kKdTreeQuantizationEncoding) {
+    uint8_t compression_level = 0;
+    if (!in_buffer->Decode(&compression_level)) {
+      return false;
+    }
+    uint32_t num_points = 0;
+    if (!in_buffer->Decode(&num_points)) {
+      return false;
+    }
+    att->Reset(num_points);
+    FloatPointsTreeDecoder decoder;
+    decoder.set_num_points_from_header(num_points);
+    PointAttributeVectorOutputIterator<float> out_it(atts);
+    if (!decoder.DecodePointCloud(in_buffer, out_it)) {
+      return false;
+    }
+  } else if (method == KdTreeAttributesEncodingMethod::kKdTreeIntegerEncoding) {
+    uint8_t compression_level = 0;
+    if (!in_buffer->Decode(&compression_level)) {
+      return false;
+    }
+    if (6 < compression_level) {
+      DRACO_LOGE(
+          "KdTreeAttributesDecoder: compression level %i not supported.\n",
+          compression_level);
+      return false;
+    }
+
+    uint32_t num_points;
+    if (!in_buffer->Decode(&num_points)) {
+      return false;
+    }
+
+    for (auto attribute_index = 0;
+         static_cast<uint32_t>(attribute_index) < attribute_count;
+         attribute_index += 1) {
+      const int att_id = GetAttributeId(attribute_index);
+      PointAttribute *const attr =
+          GetDecoder()->point_cloud()->attribute(att_id);
+      attr->Reset(num_points);
+      attr->SetIdentityMapping();
+    };
+
+    PointAttributeVectorOutputIterator<uint32_t> out_it(atts);
+
+    switch (compression_level) {
+      case 0: {
+        DynamicIntegerPointsKdTreeDecoder<0> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      case 1: {
+        DynamicIntegerPointsKdTreeDecoder<1> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      case 2: {
+        DynamicIntegerPointsKdTreeDecoder<2> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      case 3: {
+        DynamicIntegerPointsKdTreeDecoder<3> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      case 4: {
+        DynamicIntegerPointsKdTreeDecoder<4> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      case 5: {
+        DynamicIntegerPointsKdTreeDecoder<5> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      case 6: {
+        DynamicIntegerPointsKdTreeDecoder<6> decoder(total_dimensionality);
+        if (!decoder.DecodePoints(in_buffer, out_it)) {
+          return false;
+        }
+        break;
+      }
+      default:
+        return false;
+    }
+  } else {
+    // Invalid method.
+    return false;
+  }
+  return true;
+#else
+  return false;
+#endif
+}
+
+template <typename SignedDataTypeT>
+bool KdTreeAttributesDecoder::TransformAttributeBackToSignedType(
+    PointAttribute *att, int num_processed_signed_components) {
+  typedef typename std::make_unsigned<SignedDataTypeT>::type UnsignedType;
+  std::vector<UnsignedType> unsigned_val(att->num_components());
+  std::vector<SignedDataTypeT> signed_val(att->num_components());
+
+  for (AttributeValueIndex avi(0); avi < static_cast<uint32_t>(att->size());
+       ++avi) {
+    att->GetValue(avi, &unsigned_val[0]);
+    for (int c = 0; c < att->num_components(); ++c) {
+      // Up-cast |unsigned_val| to int32_t to ensure we don't overflow it for
+      // smaller data types.
+      signed_val[c] = static_cast<SignedDataTypeT>(
+          static_cast<int32_t>(unsigned_val[c]) +
+          min_signed_values_[num_processed_signed_components + c]);
+    }
+    att->SetAttributeValue(avi, &signed_val[0]);
+  }
+  return true;
+}
+
+bool KdTreeAttributesDecoder::TransformAttributesToOriginalFormat() {
+  if (quantized_portable_attributes_.empty() && min_signed_values_.empty()) {
+    return true;
+  }
+  int num_processed_quantized_attributes = 0;
+  int num_processed_signed_components = 0;
+  // Dequantize attributes that needed it.
+  for (int i = 0; i < GetNumAttributes(); ++i) {
+    const int att_id = GetAttributeId(i);
+    PointAttribute *const att = GetDecoder()->point_cloud()->attribute(att_id);
+    if (att->data_type() == DT_INT32 || att->data_type() == DT_INT16 ||
+        att->data_type() == DT_INT8) {
+      std::vector<uint32_t> unsigned_val(att->num_components());
+      std::vector<int32_t> signed_val(att->num_components());
+      // Values are stored as unsigned in the attribute, make them signed again.
+      if (att->data_type() == DT_INT32) {
+        if (!TransformAttributeBackToSignedType<int32_t>(
+                att, num_processed_signed_components)) {
+          return false;
+        }
+      } else if (att->data_type() == DT_INT16) {
+        if (!TransformAttributeBackToSignedType<int16_t>(
+                att, num_processed_signed_components)) {
+          return false;
+        }
+      } else if (att->data_type() == DT_INT8) {
+        if (!TransformAttributeBackToSignedType<int8_t>(
+                att, num_processed_signed_components)) {
+          return false;
+        }
+      }
+      num_processed_signed_components += att->num_components();
+    } else if (att->data_type() == DT_FLOAT32) {
+      // TODO(ostava): This code should be probably moved out to attribute
+      // transform and shared with the SequentialQuantizationAttributeDecoder.
+
+      const PointAttribute *const src_att =
+          quantized_portable_attributes_[num_processed_quantized_attributes]
+              .get();
+
+      const AttributeQuantizationTransform &transform =
+          attribute_quantization_transforms_
+              [num_processed_quantized_attributes];
+
+      num_processed_quantized_attributes++;
+
+      if (GetDecoder()->options()->GetAttributeBool(
+              att->attribute_type(), "skip_attribute_transform", false)) {
+        // Attribute transform should not be performed. In this case, we replace
+        // the output geometry attribute with the portable attribute.
+        // TODO(ostava): We can potentially avoid this copy by introducing a new
+        // mechanism that would allow to use the final attributes as portable
+        // attributes for predictors that may need them.
+        att->CopyFrom(*src_att);
+        continue;
+      }
+
+      // Convert all quantized values back to floats.
+      const int32_t max_quantized_value =
+          (1u << static_cast<uint32_t>(transform.quantization_bits())) - 1;
+      const int num_components = att->num_components();
+      const int entry_size = sizeof(float) * num_components;
+      const std::unique_ptr<float[]> att_val(new float[num_components]);
+      int quant_val_id = 0;
+      int out_byte_pos = 0;
+      Dequantizer dequantizer;
+      if (!dequantizer.Init(transform.range(), max_quantized_value)) {
+        return false;
+      }
+      const uint32_t *const portable_attribute_data =
+          reinterpret_cast<const uint32_t *>(
+              src_att->GetAddress(AttributeValueIndex(0)));
+      for (uint32_t i = 0; i < src_att->size(); ++i) {
+        for (int c = 0; c < num_components; ++c) {
+          float value = dequantizer.DequantizeFloat(
+              portable_attribute_data[quant_val_id++]);
+          value = value + transform.min_value(c);
+          att_val[c] = value;
+        }
+        // Store the floating point value into the attribute buffer.
+        att->buffer()->Write(out_byte_pos, att_val.get(), entry_size);
+        out_byte_pos += entry_size;
+      }
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.h b/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.h
new file mode 100644
index 000000000..87338d6b0
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_decoder.h
@@ -0,0 +1,46 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_DECODER_H_
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/attributes/attributes_decoder.h"
+
+namespace draco {
+
+// Decodes attributes encoded with the KdTreeAttributesEncoder.
+class KdTreeAttributesDecoder : public AttributesDecoder {
+ public:
+  KdTreeAttributesDecoder();
+
+ protected:
+  bool DecodePortableAttributes(DecoderBuffer *in_buffer) override;
+  bool DecodeDataNeededByPortableTransforms(DecoderBuffer *in_buffer) override;
+  bool TransformAttributesToOriginalFormat() override;
+
+ private:
+  template <typename SignedDataTypeT>
+  bool TransformAttributeBackToSignedType(PointAttribute *att,
+                                          int num_processed_signed_components);
+
+  std::vector<AttributeQuantizationTransform>
+      attribute_quantization_transforms_;
+  std::vector<int32_t> min_signed_values_;
+  std::vector<std::unique_ptr<PointAttribute>> quantized_portable_attributes_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.cc b/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.cc
new file mode 100644
index 000000000..b70deb9e0
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.cc
@@ -0,0 +1,305 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/kd_tree_attributes_encoder.h"
+
+#include "draco/compression/attributes/kd_tree_attributes_shared.h"
+#include "draco/compression/attributes/point_d_vector.h"
+#include "draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h"
+#include "draco/compression/point_cloud/algorithms/float_points_tree_encoder.h"
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+KdTreeAttributesEncoder::KdTreeAttributesEncoder() : num_components_(0) {}
+
+KdTreeAttributesEncoder::KdTreeAttributesEncoder(int att_id)
+    : AttributesEncoder(att_id), num_components_(0) {}
+
+bool KdTreeAttributesEncoder::TransformAttributesToPortableFormat() {
+  // Convert any of the input attributes into a format that can be processed by
+  // the kd tree encoder (quantization of floating attributes for now).
+  const size_t num_points = encoder()->point_cloud()->num_points();
+  int num_components = 0;
+  for (uint32_t i = 0; i < num_attributes(); ++i) {
+    const int att_id = GetAttributeId(i);
+    const PointAttribute *const att =
+        encoder()->point_cloud()->attribute(att_id);
+    num_components += att->num_components();
+  }
+  num_components_ = num_components;
+
+  // Go over all attributes and quantize them if needed.
+  for (uint32_t i = 0; i < num_attributes(); ++i) {
+    const int att_id = GetAttributeId(i);
+    const PointAttribute *const att =
+        encoder()->point_cloud()->attribute(att_id);
+    if (att->data_type() == DT_FLOAT32) {
+      // Quantization path.
+      AttributeQuantizationTransform attribute_quantization_transform;
+      const int quantization_bits = encoder()->options()->GetAttributeInt(
+          att_id, "quantization_bits", -1);
+      if (quantization_bits < 1) {
+        return false;
+      }
+      if (encoder()->options()->IsAttributeOptionSet(att_id,
+                                                     "quantization_origin") &&
+          encoder()->options()->IsAttributeOptionSet(att_id,
+                                                     "quantization_range")) {
+        // Quantization settings are explicitly specified in the provided
+        // options.
+        std::vector<float> quantization_origin(att->num_components());
+        encoder()->options()->GetAttributeVector(att_id, "quantization_origin",
+                                                 att->num_components(),
+                                                 &quantization_origin[0]);
+        const float range = encoder()->options()->GetAttributeFloat(
+            att_id, "quantization_range", 1.f);
+        attribute_quantization_transform.SetParameters(
+            quantization_bits, quantization_origin.data(),
+            att->num_components(), range);
+      } else {
+        // Compute quantization settings from the attribute values.
+        if (!attribute_quantization_transform.ComputeParameters(
+                *att, quantization_bits)) {
+          return false;
+        }
+      }
+      attribute_quantization_transforms_.push_back(
+          attribute_quantization_transform);
+      // Store the quantized attribute in an array that will be used when we do
+      // the actual encoding of the data.
+      auto portable_att =
+          attribute_quantization_transform.InitTransformedAttribute(*att,
+                                                                    num_points);
+      attribute_quantization_transform.TransformAttribute(*att, {},
+                                                          portable_att.get());
+      quantized_portable_attributes_.push_back(std::move(portable_att));
+    } else if (att->data_type() == DT_INT32 || att->data_type() == DT_INT16 ||
+               att->data_type() == DT_INT8) {
+      // For signed types, find the minimum value for each component. These
+      // values are going to be used to transform the attribute values to
+      // unsigned integers that can be processed by the core kd tree algorithm.
+      std::vector<int32_t> min_value(att->num_components(),
+                                     std::numeric_limits<int32_t>::max());
+      std::vector<int32_t> act_value(att->num_components());
+      for (AttributeValueIndex avi(0); avi < static_cast<uint32_t>(att->size());
+           ++avi) {
+        att->ConvertValue<int32_t>(avi, &act_value[0]);
+        for (int c = 0; c < att->num_components(); ++c) {
+          if (min_value[c] > act_value[c]) {
+            min_value[c] = act_value[c];
+          }
+        }
+      }
+      for (int c = 0; c < att->num_components(); ++c) {
+        min_signed_values_.push_back(min_value[c]);
+      }
+    }
+  }
+  return true;
+}
+
+bool KdTreeAttributesEncoder::EncodeDataNeededByPortableTransforms(
+    EncoderBuffer *out_buffer) {
+  // Store quantization settings for all attributes that need it.
+  for (int i = 0; i < attribute_quantization_transforms_.size(); ++i) {
+    attribute_quantization_transforms_[i].EncodeParameters(out_buffer);
+  }
+
+  // Encode data needed for transforming signed integers to unsigned ones.
+  for (int i = 0; i < min_signed_values_.size(); ++i) {
+    EncodeVarint<int32_t>(min_signed_values_[i], out_buffer);
+  }
+  return true;
+}
+
+bool KdTreeAttributesEncoder::EncodePortableAttributes(
+    EncoderBuffer *out_buffer) {
+  // Encode the data using the kd tree encoder algorithm. The data is first
+  // copied to a PointDVector that provides all the API expected by the core
+  // encoding algorithm.
+
+  // We limit the maximum value of compression_level to 6 as we don't currently
+  // have viable algorithms for higher compression levels.
+  uint8_t compression_level =
+      std::min(10 - encoder()->options()->GetSpeed(), 6);
+  DRACO_DCHECK_LE(compression_level, 6);
+
+  if (compression_level == 6 && num_components_ > 15) {
+    // Don't use compression level for CL >= 6. Axis selection is currently
+    // encoded using 4 bits.
+    compression_level = 5;
+  }
+
+  out_buffer->Encode(compression_level);
+
+  // Init PointDVector. The number of dimensions is equal to the total number
+  // of dimensions across all attributes.
+  const int num_points = encoder()->point_cloud()->num_points();
+  PointDVector<uint32_t> point_vector(num_points, num_components_);
+
+  int num_processed_components = 0;
+  int num_processed_quantized_attributes = 0;
+  int num_processed_signed_components = 0;
+  // Copy data to the point vector.
+  for (uint32_t i = 0; i < num_attributes(); ++i) {
+    const int att_id = GetAttributeId(i);
+    const PointAttribute *const att =
+        encoder()->point_cloud()->attribute(att_id);
+    const PointAttribute *source_att = nullptr;
+    if (att->data_type() == DT_UINT32 || att->data_type() == DT_UINT16 ||
+        att->data_type() == DT_UINT8 || att->data_type() == DT_INT32 ||
+        att->data_type() == DT_INT16 || att->data_type() == DT_INT8) {
+      // Use the original attribute.
+      source_att = att;
+    } else if (att->data_type() == DT_FLOAT32) {
+      // Use the portable (quantized) attribute instead.
+      source_att =
+          quantized_portable_attributes_[num_processed_quantized_attributes]
+              .get();
+      num_processed_quantized_attributes++;
+    } else {
+      // Unsupported data type.
+      return false;
+    }
+
+    if (source_att == nullptr) {
+      return false;
+    }
+
+    // Copy source_att to the vector.
+    if (source_att->data_type() == DT_UINT32) {
+      // If the data type is the same as the one used by the point vector, we
+      // can directly copy individual elements.
+      for (PointIndex pi(0); pi < num_points; ++pi) {
+        const AttributeValueIndex avi = source_att->mapped_index(pi);
+        const uint8_t *const att_value_address = source_att->GetAddress(avi);
+        point_vector.CopyAttribute(source_att->num_components(),
+                                   num_processed_components, pi.value(),
+                                   att_value_address);
+      }
+    } else if (source_att->data_type() == DT_INT32 ||
+               source_att->data_type() == DT_INT16 ||
+               source_att->data_type() == DT_INT8) {
+      // Signed values need to be converted to unsigned before they are stored
+      // in the point vector.
+      std::vector<int32_t> signed_point(source_att->num_components());
+      std::vector<uint32_t> unsigned_point(source_att->num_components());
+      for (PointIndex pi(0); pi < num_points; ++pi) {
+        const AttributeValueIndex avi = source_att->mapped_index(pi);
+        source_att->ConvertValue<int32_t>(avi, &signed_point[0]);
+        for (int c = 0; c < source_att->num_components(); ++c) {
+          unsigned_point[c] =
+              signed_point[c] -
+              min_signed_values_[num_processed_signed_components + c];
+        }
+
+        point_vector.CopyAttribute(source_att->num_components(),
+                                   num_processed_components, pi.value(),
+                                   &unsigned_point[0]);
+      }
+      num_processed_signed_components += source_att->num_components();
+    } else {
+      // If the data type of the attribute is different, we have to convert the
+      // value before we put it to the point vector.
+      std::vector<uint32_t> point(source_att->num_components());
+      for (PointIndex pi(0); pi < num_points; ++pi) {
+        const AttributeValueIndex avi = source_att->mapped_index(pi);
+        source_att->ConvertValue<uint32_t>(avi, &point[0]);
+        point_vector.CopyAttribute(source_att->num_components(),
+                                   num_processed_components, pi.value(),
+                                   point.data());
+      }
+    }
+    num_processed_components += source_att->num_components();
+  }
+
+  // Compute the maximum bit length needed for the kd tree encoding.
+  int num_bits = 0;
+  const uint32_t *data = point_vector[0];
+  for (int i = 0; i < num_points * num_components_; ++i) {
+    if (data[i] > 0) {
+      const int msb = MostSignificantBit(data[i]) + 1;
+      if (msb > num_bits) {
+        num_bits = msb;
+      }
+    }
+  }
+
+  switch (compression_level) {
+    case 6: {
+      DynamicIntegerPointsKdTreeEncoder<6> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    case 5: {
+      DynamicIntegerPointsKdTreeEncoder<5> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    case 4: {
+      DynamicIntegerPointsKdTreeEncoder<4> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    case 3: {
+      DynamicIntegerPointsKdTreeEncoder<3> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    case 2: {
+      DynamicIntegerPointsKdTreeEncoder<2> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    case 1: {
+      DynamicIntegerPointsKdTreeEncoder<1> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    case 0: {
+      DynamicIntegerPointsKdTreeEncoder<0> points_encoder(num_components_);
+      if (!points_encoder.EncodePoints(point_vector.begin(), point_vector.end(),
+                                       num_bits, out_buffer)) {
+        return false;
+      }
+      break;
+    }
+    // Compression level and/or encoding speed seem wrong.
+    default:
+      return false;
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.h b/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.h
new file mode 100644
index 000000000..80748e0bf
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_encoder.h
@@ -0,0 +1,51 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_ENCODER_H_
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/attributes/attributes_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+
+namespace draco {
+
+// Encodes all attributes of a given PointCloud using one of the available
+// Kd-tree compression methods.
+// See compression/point_cloud/point_cloud_kd_tree_encoder.h for more details.
+class KdTreeAttributesEncoder : public AttributesEncoder {
+ public:
+  KdTreeAttributesEncoder();
+  explicit KdTreeAttributesEncoder(int att_id);
+
+  uint8_t GetUniqueId() const override { return KD_TREE_ATTRIBUTE_ENCODER; }
+
+ protected:
+  bool TransformAttributesToPortableFormat() override;
+  bool EncodePortableAttributes(EncoderBuffer *out_buffer) override;
+  bool EncodeDataNeededByPortableTransforms(EncoderBuffer *out_buffer) override;
+
+ private:
+  std::vector<AttributeQuantizationTransform>
+      attribute_quantization_transforms_;
+  // Min signed values are used to transform signed integers into unsigned ones
+  // (by subtracting the min signed value for each component).
+  std::vector<int32_t> min_signed_values_;
+  std::vector<std::unique_ptr<PointAttribute>> quantized_portable_attributes_;
+  int num_components_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_shared.h b/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_shared.h
new file mode 100644
index 000000000..94841a91d
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/kd_tree_attributes_shared.h
@@ -0,0 +1,28 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_SHARED_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_SHARED_H_
+
+namespace draco {
+
+// Defines types of kD-tree compression
+enum KdTreeAttributesEncodingMethod {
+  kKdTreeQuantizationEncoding = 0,
+  kKdTreeIntegerEncoding
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_KD_TREE_ATTRIBUTES_SHARED_H_
diff --git a/contrib/draco/src/draco/compression/attributes/linear_sequencer.h b/contrib/draco/src/draco/compression/attributes/linear_sequencer.h
new file mode 100644
index 000000000..7d9b52641
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/linear_sequencer.h
@@ -0,0 +1,51 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_LINEAR_SEQUENCER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_LINEAR_SEQUENCER_H_
+
+#include "draco/compression/attributes/points_sequencer.h"
+
+namespace draco {
+
+// A simple sequencer that generates a linear sequence [0, num_points - 1].
+// I.e., the order of the points is preserved for the input data.
+class LinearSequencer : public PointsSequencer {
+ public:
+  explicit LinearSequencer(int32_t num_points) : num_points_(num_points) {}
+
+  bool UpdatePointToAttributeIndexMapping(PointAttribute *attribute) override {
+    attribute->SetIdentityMapping();
+    return true;
+  }
+
+ protected:
+  bool GenerateSequenceInternal() override {
+    if (num_points_ < 0) {
+      return false;
+    }
+    out_point_ids()->resize(num_points_);
+    for (int i = 0; i < num_points_; ++i) {
+      out_point_ids()->at(i) = PointIndex(i);
+    }
+    return true;
+  }
+
+ private:
+  int32_t num_points_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_LINEAR_SEQUENCER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/mesh_attribute_indices_encoding_data.h b/contrib/draco/src/draco/compression/attributes/mesh_attribute_indices_encoding_data.h
new file mode 100644
index 000000000..9a358e447
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/mesh_attribute_indices_encoding_data.h
@@ -0,0 +1,58 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_MESH_ATTRIBUTE_INDICES_ENCODING_DATA_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_MESH_ATTRIBUTE_INDICES_ENCODING_DATA_H_
+
+#include <inttypes.h>
+
+#include <vector>
+
+#include "draco/attributes/geometry_indices.h"
+
+namespace draco {
+
+// Data used for encoding and decoding of mesh attributes.
+struct MeshAttributeIndicesEncodingData {
+  MeshAttributeIndicesEncodingData() : num_values(0) {}
+
+  void Init(int num_vertices) {
+    vertex_to_encoded_attribute_value_index_map.resize(num_vertices);
+
+    // We expect to store one value for each vertex.
+    encoded_attribute_value_index_to_corner_map.reserve(num_vertices);
+  }
+
+  // Array for storing the corner ids in the order their associated attribute
+  // entries were encoded/decoded. For every encoded attribute value entry we
+  // store exactly one corner. I.e., this is the mapping between an encoded
+  // attribute entry ids and corner ids. This map is needed for example by
+  // prediction schemes. Note that not all corners are included in this map,
+  // e.g., if multiple corners share the same attribute value, only one of these
+  // corners will be usually included.
+  std::vector<CornerIndex> encoded_attribute_value_index_to_corner_map;
+
+  // Map for storing encoding order of attribute entries for each vertex.
+  // i.e. Mapping between vertices and their corresponding attribute entry ids
+  // that are going to be used by the decoder.
+  // -1 if an attribute entry hasn't been encoded/decoded yet.
+  std::vector<int32_t> vertex_to_encoded_attribute_value_index_map;
+
+  // Total number of encoded/decoded attribute entries.
+  int num_values;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_MESH_ATTRIBUTE_INDICES_ENCODING_DATA_H_
diff --git a/contrib/draco/src/draco/compression/attributes/normal_compression_utils.h b/contrib/draco/src/draco/compression/attributes/normal_compression_utils.h
new file mode 100644
index 000000000..8a6f25b66
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/normal_compression_utils.h
@@ -0,0 +1,360 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Utilities for converting unit vectors to octahedral coordinates and back.
+// For more details about octahedral coordinates, see for example Cigolle
+// et al.'14 “A Survey of Efficient Representations for Independent Unit
+// Vectors”.
+//
+// In short this is motivated by an octahedron inscribed into a sphere. The
+// direction of the normal vector can be defined by a point on the octahedron.
+// On the right hemisphere (x > 0) this point is projected onto the x = 0 plane,
+// that is, the right side of the octahedron forms a diamond like shape. The
+// left side of the octahedron is also projected onto the x = 0 plane, however,
+// in this case we flap the triangles of the diamond outward. Afterwards we
+// shift the resulting square such that all values are positive.
+//
+// Important values in this file:
+// * q: number of quantization bits
+// * max_quantized_value: the max value representable with q bits (odd)
+// * max_value: max value of the diamond = max_quantized_value - 1  (even)
+// * center_value: center of the diamond after shift
+//
+// Note that the parameter space is somewhat periodic, e.g. (0, 0) ==
+// (max_value, max_value), which is also why the diamond is one smaller than the
+// maximal representable value in order to have an odd range of values.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_NORMAL_COMPRESSION_UTILS_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_NORMAL_COMPRESSION_UTILS_H_
+
+#include <inttypes.h>
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+class OctahedronToolBox {
+ public:
+  OctahedronToolBox()
+      : quantization_bits_(-1),
+        max_quantized_value_(-1),
+        max_value_(-1),
+        dequantization_scale_(1.f),
+        center_value_(-1) {}
+
+  bool SetQuantizationBits(int32_t q) {
+    if (q < 2 || q > 30) {
+      return false;
+    }
+    quantization_bits_ = q;
+    max_quantized_value_ = (1 << quantization_bits_) - 1;
+    max_value_ = max_quantized_value_ - 1;
+    dequantization_scale_ = 2.f / max_value_;
+    center_value_ = max_value_ / 2;
+    return true;
+  }
+  bool IsInitialized() const { return quantization_bits_ != -1; }
+
+  // Convert all edge points in the top left and bottom right quadrants to
+  // their corresponding position in the bottom left and top right quadrants.
+  // Convert all corner edge points to the top right corner.
+  inline void CanonicalizeOctahedralCoords(int32_t s, int32_t t, int32_t *out_s,
+                                           int32_t *out_t) const {
+    if ((s == 0 && t == 0) || (s == 0 && t == max_value_) ||
+        (s == max_value_ && t == 0)) {
+      s = max_value_;
+      t = max_value_;
+    } else if (s == 0 && t > center_value_) {
+      t = center_value_ - (t - center_value_);
+    } else if (s == max_value_ && t < center_value_) {
+      t = center_value_ + (center_value_ - t);
+    } else if (t == max_value_ && s < center_value_) {
+      s = center_value_ + (center_value_ - s);
+    } else if (t == 0 && s > center_value_) {
+      s = center_value_ - (s - center_value_);
+    }
+
+    *out_s = s;
+    *out_t = t;
+  }
+
+  // Converts an integer vector to octahedral coordinates.
+  // Precondition: |int_vec| abs sum must equal center value.
+  inline void IntegerVectorToQuantizedOctahedralCoords(const int32_t *int_vec,
+                                                       int32_t *out_s,
+                                                       int32_t *out_t) const {
+    DRACO_DCHECK_EQ(
+        std::abs(int_vec[0]) + std::abs(int_vec[1]) + std::abs(int_vec[2]),
+        center_value_);
+    int32_t s, t;
+    if (int_vec[0] >= 0) {
+      // Right hemisphere.
+      s = (int_vec[1] + center_value_);
+      t = (int_vec[2] + center_value_);
+    } else {
+      // Left hemisphere.
+      if (int_vec[1] < 0) {
+        s = std::abs(int_vec[2]);
+      } else {
+        s = (max_value_ - std::abs(int_vec[2]));
+      }
+      if (int_vec[2] < 0) {
+        t = std::abs(int_vec[1]);
+      } else {
+        t = (max_value_ - std::abs(int_vec[1]));
+      }
+    }
+    CanonicalizeOctahedralCoords(s, t, out_s, out_t);
+  }
+
+  template <class T>
+  void FloatVectorToQuantizedOctahedralCoords(const T *vector, int32_t *out_s,
+                                              int32_t *out_t) const {
+    const double abs_sum = std::abs(static_cast<double>(vector[0])) +
+                           std::abs(static_cast<double>(vector[1])) +
+                           std::abs(static_cast<double>(vector[2]));
+
+    // Adjust values such that abs sum equals 1.
+    double scaled_vector[3];
+    if (abs_sum > 1e-6) {
+      // Scale needed to project the vector to the surface of an octahedron.
+      const double scale = 1.0 / abs_sum;
+      scaled_vector[0] = vector[0] * scale;
+      scaled_vector[1] = vector[1] * scale;
+      scaled_vector[2] = vector[2] * scale;
+    } else {
+      scaled_vector[0] = 1.0;
+      scaled_vector[1] = 0;
+      scaled_vector[2] = 0;
+    }
+
+    // Scale vector such that the sum equals the center value.
+    int32_t int_vec[3];
+    int_vec[0] =
+        static_cast<int32_t>(floor(scaled_vector[0] * center_value_ + 0.5));
+    int_vec[1] =
+        static_cast<int32_t>(floor(scaled_vector[1] * center_value_ + 0.5));
+    // Make sure the sum is exactly the center value.
+    int_vec[2] = center_value_ - std::abs(int_vec[0]) - std::abs(int_vec[1]);
+    if (int_vec[2] < 0) {
+      // If the sum of first two coordinates is too large, we need to decrease
+      // the length of one of the coordinates.
+      if (int_vec[1] > 0) {
+        int_vec[1] += int_vec[2];
+      } else {
+        int_vec[1] -= int_vec[2];
+      }
+      int_vec[2] = 0;
+    }
+    // Take care of the sign.
+    if (scaled_vector[2] < 0) {
+      int_vec[2] *= -1;
+    }
+
+    IntegerVectorToQuantizedOctahedralCoords(int_vec, out_s, out_t);
+  }
+
+  // Normalize |vec| such that its abs sum is equal to the center value;
+  template <class T>
+  void CanonicalizeIntegerVector(T *vec) const {
+    static_assert(std::is_integral<T>::value, "T must be an integral type.");
+    static_assert(std::is_signed<T>::value, "T must be a signed type.");
+    const int64_t abs_sum = static_cast<int64_t>(std::abs(vec[0])) +
+                            static_cast<int64_t>(std::abs(vec[1])) +
+                            static_cast<int64_t>(std::abs(vec[2]));
+
+    if (abs_sum == 0) {
+      vec[0] = center_value_;  // vec[1] == v[2] == 0
+    } else {
+      vec[0] =
+          (static_cast<int64_t>(vec[0]) * static_cast<int64_t>(center_value_)) /
+          abs_sum;
+      vec[1] =
+          (static_cast<int64_t>(vec[1]) * static_cast<int64_t>(center_value_)) /
+          abs_sum;
+      if (vec[2] >= 0) {
+        vec[2] = center_value_ - std::abs(vec[0]) - std::abs(vec[1]);
+      } else {
+        vec[2] = -(center_value_ - std::abs(vec[0]) - std::abs(vec[1]));
+      }
+    }
+  }
+
+  inline void QuantizedOctahedralCoordsToUnitVector(int32_t in_s, int32_t in_t,
+                                                    float *out_vector) const {
+    OctahedralCoordsToUnitVector(in_s * dequantization_scale_ - 1.f,
+                                 in_t * dequantization_scale_ - 1.f,
+                                 out_vector);
+  }
+
+  // |s| and |t| are expected to be signed values.
+  inline bool IsInDiamond(const int32_t &s, const int32_t &t) const {
+    // Expect center already at origin.
+    DRACO_DCHECK_LE(s, center_value_);
+    DRACO_DCHECK_LE(t, center_value_);
+    DRACO_DCHECK_GE(s, -center_value_);
+    DRACO_DCHECK_GE(t, -center_value_);
+    return std::abs(s) + std::abs(t) <= center_value_;
+  }
+
+  void InvertDiamond(int32_t *s, int32_t *t) const {
+    // Expect center already at origin.
+    DRACO_DCHECK_LE(*s, center_value_);
+    DRACO_DCHECK_LE(*t, center_value_);
+    DRACO_DCHECK_GE(*s, -center_value_);
+    DRACO_DCHECK_GE(*t, -center_value_);
+    int32_t sign_s = 0;
+    int32_t sign_t = 0;
+    if (*s >= 0 && *t >= 0) {
+      sign_s = 1;
+      sign_t = 1;
+    } else if (*s <= 0 && *t <= 0) {
+      sign_s = -1;
+      sign_t = -1;
+    } else {
+      sign_s = (*s > 0) ? 1 : -1;
+      sign_t = (*t > 0) ? 1 : -1;
+    }
+
+    const int32_t corner_point_s = sign_s * center_value_;
+    const int32_t corner_point_t = sign_t * center_value_;
+    *s = 2 * *s - corner_point_s;
+    *t = 2 * *t - corner_point_t;
+    if (sign_s * sign_t >= 0) {
+      int32_t temp = *s;
+      *s = -*t;
+      *t = -temp;
+    } else {
+      std::swap(*s, *t);
+    }
+    *s = (*s + corner_point_s) / 2;
+    *t = (*t + corner_point_t) / 2;
+  }
+
+  void InvertDirection(int32_t *s, int32_t *t) const {
+    // Expect center already at origin.
+    DRACO_DCHECK_LE(*s, center_value_);
+    DRACO_DCHECK_LE(*t, center_value_);
+    DRACO_DCHECK_GE(*s, -center_value_);
+    DRACO_DCHECK_GE(*t, -center_value_);
+    *s *= -1;
+    *t *= -1;
+    this->InvertDiamond(s, t);
+  }
+
+  // For correction values.
+  int32_t ModMax(int32_t x) const {
+    if (x > this->center_value()) {
+      return x - this->max_quantized_value();
+    }
+    if (x < -this->center_value()) {
+      return x + this->max_quantized_value();
+    }
+    return x;
+  }
+
+  // For correction values.
+  int32_t MakePositive(int32_t x) const {
+    DRACO_DCHECK_LE(x, this->center_value() * 2);
+    if (x < 0) {
+      return x + this->max_quantized_value();
+    }
+    return x;
+  }
+
+  int32_t quantization_bits() const { return quantization_bits_; }
+  int32_t max_quantized_value() const { return max_quantized_value_; }
+  int32_t max_value() const { return max_value_; }
+  int32_t center_value() const { return center_value_; }
+
+ private:
+  inline void OctahedralCoordsToUnitVector(float in_s_scaled, float in_t_scaled,
+                                           float *out_vector) const {
+    // Background about the encoding:
+    //   A normal is encoded in a normalized space <s, t> depicted below. The
+    //   encoding correponds to an octahedron that is unwrapped to a 2D plane.
+    //   During encoding, a normal is projected to the surface of the octahedron
+    //   and the projection is then unwrapped to the 2D plane. Decoding is the
+    //   reverse of this process.
+    //   All points in the central diamond are located on triangles on the
+    //   right "hemisphere" of the octahedron while all points outside of the
+    //   diamond are on the left hemisphere (basically, they would have to be
+    //   wrapped along the diagonal edges to form the octahedron). The central
+    //   point corresponds to the right most vertex of the octahedron and all
+    //   corners of the plane correspond to the left most vertex of the
+    //   octahedron.
+    //
+    // t
+    // ^ *-----*-----*
+    // | |    /|\    |
+    //   |   / | \   |
+    //   |  /  |  \  |
+    //   | /   |   \ |
+    //   *-----*---- *
+    //   | \   |   / |
+    //   |  \  |  /  |
+    //   |   \ | /   |
+    //   |    \|/    |
+    //   *-----*-----*  --> s
+
+    // Note that the input |in_s_scaled| and |in_t_scaled| are already scaled to
+    // <-1, 1> range. This way, the central point is at coordinate (0, 0).
+    float y = in_s_scaled;
+    float z = in_t_scaled;
+
+    // Remaining coordinate can be computed by projecting the (y, z) values onto
+    // the surface of the octahedron.
+    const float x = 1.f - abs(y) - abs(z);
+
+    // |x| is essentially a signed distance from the diagonal edges of the
+    // diamond shown on the figure above. It is positive for all points in the
+    // diamond (right hemisphere) and negative for all points outside the
+    // diamond (left hemisphere). For all points on the left hemisphere we need
+    // to update their (y, z) coordinates to account for the wrapping along
+    // the edges of the diamond.
+    float x_offset = -x;
+    x_offset = x_offset < 0 ? 0 : x_offset;
+
+    // This will do nothing for the points on the right hemisphere but it will
+    // mirror the (y, z) location along the nearest diagonal edge of the
+    // diamond.
+    y += y < 0 ? x_offset : -x_offset;
+    z += z < 0 ? x_offset : -x_offset;
+
+    // Normalize the computed vector.
+    const float norm_squared = x * x + y * y + z * z;
+    if (norm_squared < 1e-6) {
+      out_vector[0] = 0;
+      out_vector[1] = 0;
+      out_vector[2] = 0;
+    } else {
+      const float d = 1.0f / std::sqrt(norm_squared);
+      out_vector[0] = x * d;
+      out_vector[1] = y * d;
+      out_vector[2] = z * d;
+    }
+  }
+
+  int32_t quantization_bits_;
+  int32_t max_quantized_value_;
+  int32_t max_value_;
+  float dequantization_scale_;
+  int32_t center_value_;
+};
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_NORMAL_COMPRESSION_UTILS_H_
diff --git a/contrib/draco/src/draco/compression/attributes/point_d_vector.h b/contrib/draco/src/draco/compression/attributes/point_d_vector.h
new file mode 100644
index 000000000..3b115d500
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/point_d_vector.h
@@ -0,0 +1,279 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_POINT_D_VECTOR_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_POINT_D_VECTOR_H_
+
+#include <cstring>
+#include <memory>
+#include <vector>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// The main class of this file is PointDVector providing an interface similar to
+// std::vector<PointD> for arbitrary number of dimensions (without a template
+// argument). PointDVectorIterator is a random access iterator, which allows for
+// compatibility with existing algorithms. PseudoPointD provides for a view on
+// the individual items in a contiguous block of memory, which is compatible
+// with the swap function and is returned by a dereference of
+// PointDVectorIterator. Swap functions provide for compatibility/specialization
+// that allows these classes to work with currently utilized STL functions.
+
+// This class allows for swap functionality from the RandomIterator
+// It seems problematic to bring this inside PointDVector due to templating.
+template <typename internal_t>
+class PseudoPointD {
+ public:
+  PseudoPointD(internal_t *mem, internal_t dimension)
+      : mem_(mem), dimension_(dimension) {}
+
+  // Specifically copies referenced memory
+  void swap(PseudoPointD &other) noexcept {
+    for (internal_t dim = 0; dim < dimension_; dim += 1) {
+      std::swap(mem_[dim], other.mem_[dim]);
+    }
+  }
+
+  PseudoPointD(const PseudoPointD &other)
+      : mem_(other.mem_), dimension_(other.dimension_) {}
+
+  const internal_t &operator[](const size_t &n) const {
+    DRACO_DCHECK_LT(n, dimension_);
+    return mem_[n];
+  }
+  internal_t &operator[](const size_t &n) {
+    DRACO_DCHECK_LT(n, dimension_);
+    return mem_[n];
+  }
+
+  bool operator==(const PseudoPointD &other) const {
+    for (auto dim = 0; dim < dimension_; dim += 1) {
+      if (mem_[dim] != other.mem_[dim]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  bool operator!=(const PseudoPointD &other) const {
+    return !this->operator==(other);
+  }
+
+ private:
+  internal_t *const mem_;
+  const internal_t dimension_;
+};
+
+// It seems problematic to bring this inside PointDVector due to templating.
+template <typename internal_t>
+void swap(draco::PseudoPointD<internal_t> &&a,
+          draco::PseudoPointD<internal_t> &&b) noexcept {
+  a.swap(b);
+};
+template <typename internal_t>
+void swap(draco::PseudoPointD<internal_t> &a,
+          draco::PseudoPointD<internal_t> &b) noexcept {
+  a.swap(b);
+};
+
+template <typename internal_t>
+class PointDVector {
+ public:
+  PointDVector(const uint32_t n_items, const uint32_t dimensionality)
+      : n_items_(n_items),
+        dimensionality_(dimensionality),
+        item_size_bytes_(dimensionality * sizeof(internal_t)),
+        data_(n_items * dimensionality),
+        data0_(data_.data()) {}
+  // random access iterator
+  class PointDVectorIterator
+      : public std::iterator<std::random_access_iterator_tag, size_t, size_t> {
+    friend class PointDVector;
+
+   public:
+    // std::iter_swap is called inside of std::partition and needs this
+    // specialized support
+    PseudoPointD<internal_t> operator*() const {
+      return PseudoPointD<internal_t>(vec_->data0_ + item_ * dimensionality_,
+                                      dimensionality_);
+    }
+    const PointDVectorIterator &operator++() {
+      item_ += 1;
+      return *this;
+    }
+    const PointDVectorIterator &operator--() {
+      item_ -= 1;
+      return *this;
+    }
+    PointDVectorIterator operator++(int32_t) {
+      PointDVectorIterator copy(*this);
+      item_ += 1;
+      return copy;
+    }
+    PointDVectorIterator operator--(int32_t) {
+      PointDVectorIterator copy(*this);
+      item_ -= 1;
+      return copy;
+    }
+    PointDVectorIterator &operator=(const PointDVectorIterator &other) {
+      this->item_ = other.item_;
+      return *this;
+    }
+
+    bool operator==(const PointDVectorIterator &ref) const {
+      return item_ == ref.item_;
+    }
+    bool operator!=(const PointDVectorIterator &ref) const {
+      return item_ != ref.item_;
+    }
+    bool operator<(const PointDVectorIterator &ref) const {
+      return item_ < ref.item_;
+    }
+    bool operator>(const PointDVectorIterator &ref) const {
+      return item_ > ref.item_;
+    }
+    bool operator<=(const PointDVectorIterator &ref) const {
+      return item_ <= ref.item_;
+    }
+    bool operator>=(const PointDVectorIterator &ref) const {
+      return item_ >= ref.item_;
+    }
+
+    PointDVectorIterator operator+(const int32_t &add) const {
+      PointDVectorIterator copy(vec_, item_ + add);
+      return copy;
+    }
+    PointDVectorIterator &operator+=(const int32_t &add) {
+      item_ += add;
+      return *this;
+    }
+    PointDVectorIterator operator-(const int32_t &sub) const {
+      PointDVectorIterator copy(vec_, item_ - sub);
+      return copy;
+    }
+    size_t operator-(const PointDVectorIterator &sub) const {
+      return (item_ - sub.item_);
+    }
+
+    PointDVectorIterator &operator-=(const int32_t &sub) {
+      item_ -= sub;
+      return *this;
+    }
+
+    internal_t *operator[](const size_t &n) const {
+      return vec_->data0_ + (item_ + n) * dimensionality_;
+    }
+
+   protected:
+    explicit PointDVectorIterator(PointDVector *vec, size_t start_item)
+        : item_(start_item), vec_(vec), dimensionality_(vec->dimensionality_) {}
+
+   private:
+    size_t item_;  // this counts the item that should be referenced.
+    PointDVector *const vec_;        // the thing that we're iterating on
+    const uint32_t dimensionality_;  // local copy from vec_
+  };
+
+  PointDVectorIterator begin() { return PointDVectorIterator(this, 0); }
+  PointDVectorIterator end() { return PointDVectorIterator(this, n_items_); }
+
+  // operator[] allows for unprotected user-side usage of operator[] on the
+  // return value AS IF it were a natively indexable type like Point3*
+  internal_t *operator[](const uint32_t index) {
+    DRACO_DCHECK_LT(index, n_items_);
+    return data0_ + index * dimensionality_;
+  }
+  const internal_t *operator[](const uint32_t index) const {
+    DRACO_DCHECK_LT(index, n_items_);
+    return data0_ + index * dimensionality_;
+  }
+
+  uint32_t size() const { return n_items_; }
+  size_t GetBufferSize() const { return data_.size(); }
+
+  // copy a single contiguous 'item' from one PointDVector into this one.
+  void CopyItem(const PointDVector &source, const internal_t source_index,
+                const internal_t destination_index) {
+    DRACO_DCHECK(&source != this ||
+                 (&source == this && source_index != destination_index));
+    DRACO_DCHECK_LT(destination_index, n_items_);
+    DRACO_DCHECK_LT(source_index, source.n_items_);
+
+    // DRACO_DCHECK_EQ(source.n_items_, n_items_); // not technically necessary
+    DRACO_DCHECK_EQ(source.dimensionality_, dimensionality_);
+
+    const internal_t *ref = source[source_index];
+    internal_t *const dest = this->operator[](destination_index);
+    std::memcpy(dest, ref, item_size_bytes_);
+  }
+
+  // Copy data directly off of an attribute buffer interleaved into internal
+  // memory.
+  void CopyAttribute(
+      // The dimensionality of the attribute being integrated
+      const internal_t attribute_dimensionality,
+      // The offset in dimensions to insert this attribute.
+      const internal_t offset_dimensionality, const internal_t index,
+      // The direct pointer to the data
+      const void *const attribute_item_data) {
+    // chunk copy
+    const size_t copy_size = sizeof(internal_t) * attribute_dimensionality;
+
+    // a multiply and add can be optimized away with an iterator
+    std::memcpy(data0_ + index * dimensionality_ + offset_dimensionality,
+                attribute_item_data, copy_size);
+  }
+  // Copy data off of a contiguous buffer interleaved into internal memory
+  void CopyAttribute(
+      // The dimensionality of the attribute being integrated
+      const internal_t attribute_dimensionality,
+      // The offset in dimensions to insert this attribute.
+      const internal_t offset_dimensionality,
+      const internal_t *const attribute_mem) {
+    DRACO_DCHECK_LT(offset_dimensionality,
+                    dimensionality_ - attribute_dimensionality);
+    // degenerate case block copy the whole buffer.
+    if (dimensionality_ == attribute_dimensionality) {
+      DRACO_DCHECK_EQ(offset_dimensionality, 0);
+      const size_t copy_size =
+          sizeof(internal_t) * attribute_dimensionality * n_items_;
+      std::memcpy(data0_, attribute_mem, copy_size);
+    } else {  // chunk copy
+      const size_t copy_size = sizeof(internal_t) * attribute_dimensionality;
+      internal_t *internal_data;
+      const internal_t *attribute_data;
+      internal_t item;
+      for (internal_data = data0_ + offset_dimensionality,
+          attribute_data = attribute_mem, item = 0;
+           item < n_items_; internal_data += dimensionality_,
+          attribute_data += attribute_dimensionality, item += 1) {
+        std::memcpy(internal_data, attribute_data, copy_size);
+      }
+    }
+  }
+
+ private:
+  // internal parameters.
+  const uint32_t n_items_;
+  const uint32_t dimensionality_;  // The dimension of the points in the buffer
+  const uint32_t item_size_bytes_;
+  std::vector<internal_t> data_;  // contiguously stored data.  Never resized.
+  internal_t *const data0_;       // raw pointer to base data.
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_POINT_D_VECTOR_H_
diff --git a/contrib/draco/src/draco/compression/attributes/point_d_vector_test.cc b/contrib/draco/src/draco/compression/attributes/point_d_vector_test.cc
new file mode 100644
index 000000000..59f28f80b
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/point_d_vector_test.cc
@@ -0,0 +1,360 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/point_d_vector.h"
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/core/draco_test_base.h"
+
+namespace draco {
+
+class PointDVectorTest : public ::testing::Test {
+ protected:
+  template <typename PT>
+  void TestIntegrity() {}
+  template <typename PT>
+  void TestSize() {
+    for (uint32_t n_items = 0; n_items <= 10; ++n_items) {
+      for (uint32_t dimensionality = 1; dimensionality <= 10;
+           ++dimensionality) {
+        draco::PointDVector<PT> var(n_items, dimensionality);
+        ASSERT_EQ(n_items, var.size());
+        ASSERT_EQ(n_items * dimensionality, var.GetBufferSize());
+      }
+    }
+  }
+  template <typename PT>
+  void TestContentsContiguous() {
+    for (uint32_t n_items = 1; n_items <= 1000; n_items *= 10) {
+      for (uint32_t dimensionality = 1; dimensionality < 10;
+           dimensionality += 2) {
+        for (uint32_t att_dimensionality = 1;
+             att_dimensionality <= dimensionality; att_dimensionality += 2) {
+          for (uint32_t offset_dimensionality = 0;
+               offset_dimensionality < dimensionality - att_dimensionality;
+               ++offset_dimensionality) {
+            PointDVector<PT> var(n_items, dimensionality);
+
+            std::vector<PT> att(n_items * att_dimensionality);
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                att[val * att_dimensionality + att_dim] = val;
+              }
+            }
+            const PT *const attribute_data = att.data();
+
+            var.CopyAttribute(att_dimensionality, offset_dimensionality,
+                              attribute_data);
+
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                ASSERT_EQ(var[val][offset_dimensionality + att_dim], val);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  template <typename PT>
+  void TestContentsDiscrete() {
+    for (uint32_t n_items = 1; n_items <= 1000; n_items *= 10) {
+      for (uint32_t dimensionality = 1; dimensionality < 10;
+           dimensionality += 2) {
+        for (uint32_t att_dimensionality = 1;
+             att_dimensionality <= dimensionality; att_dimensionality += 2) {
+          for (uint32_t offset_dimensionality = 0;
+               offset_dimensionality < dimensionality - att_dimensionality;
+               ++offset_dimensionality) {
+            PointDVector<PT> var(n_items, dimensionality);
+
+            std::vector<PT> att(n_items * att_dimensionality);
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                att[val * att_dimensionality + att_dim] = val;
+              }
+            }
+            const PT *const attribute_data = att.data();
+
+            for (PT item = 0; item < n_items; item += 1) {
+              var.CopyAttribute(att_dimensionality, offset_dimensionality, item,
+                                attribute_data + item * att_dimensionality);
+            }
+
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                ASSERT_EQ(var[val][offset_dimensionality + att_dim], val);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  template <typename PT>
+  void TestContentsCopy() {
+    for (uint32_t n_items = 1; n_items <= 1000; n_items *= 10) {
+      for (uint32_t dimensionality = 1; dimensionality < 10;
+           dimensionality += 2) {
+        for (uint32_t att_dimensionality = 1;
+             att_dimensionality <= dimensionality; att_dimensionality += 2) {
+          for (uint32_t offset_dimensionality = 0;
+               offset_dimensionality < dimensionality - att_dimensionality;
+               ++offset_dimensionality) {
+            PointDVector<PT> var(n_items, dimensionality);
+            PointDVector<PT> dest(n_items, dimensionality);
+
+            std::vector<PT> att(n_items * att_dimensionality);
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                att[val * att_dimensionality + att_dim] = val;
+              }
+            }
+            const PT *const attribute_data = att.data();
+
+            var.CopyAttribute(att_dimensionality, offset_dimensionality,
+                              attribute_data);
+
+            for (PT item = 0; item < n_items; item += 1) {
+              dest.CopyItem(var, item, item);
+            }
+
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                ASSERT_EQ(var[val][offset_dimensionality + att_dim], val);
+                ASSERT_EQ(dest[val][offset_dimensionality + att_dim], val);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  template <typename PT>
+  void TestIterator() {
+    for (uint32_t n_items = 1; n_items <= 1000; n_items *= 10) {
+      for (uint32_t dimensionality = 1; dimensionality < 10;
+           dimensionality += 2) {
+        for (uint32_t att_dimensionality = 1;
+             att_dimensionality <= dimensionality; att_dimensionality += 2) {
+          for (uint32_t offset_dimensionality = 0;
+               offset_dimensionality < dimensionality - att_dimensionality;
+               ++offset_dimensionality) {
+            PointDVector<PT> var(n_items, dimensionality);
+            PointDVector<PT> dest(n_items, dimensionality);
+
+            std::vector<PT> att(n_items * att_dimensionality);
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                att[val * att_dimensionality + att_dim] = val;
+              }
+            }
+            const PT *const attribute_data = att.data();
+
+            var.CopyAttribute(att_dimensionality, offset_dimensionality,
+                              attribute_data);
+
+            for (PT item = 0; item < n_items; item += 1) {
+              dest.CopyItem(var, item, item);
+            }
+
+            auto V0 = var.begin();
+            auto VE = var.end();
+            auto D0 = dest.begin();
+            auto DE = dest.end();
+
+            while (V0 != VE && D0 != DE) {
+              ASSERT_EQ(*D0, *V0);  // compare PseudoPointD
+              // verify elemental values
+              for (auto index = 0; index < dimensionality; index += 1) {
+                ASSERT_EQ((*D0)[index], (*V0)[index]);
+              }
+              ++V0;
+              ++D0;
+            }
+
+            for (PT val = 0; val < n_items; val += 1) {
+              for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+                ASSERT_EQ(var[val][offset_dimensionality + att_dim], val);
+                ASSERT_EQ(dest[val][offset_dimensionality + att_dim], val);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  template <typename PT>
+  void TestPoint3Iterator() {
+    for (uint32_t n_items = 1; n_items <= 1000; n_items *= 10) {
+      const uint32_t dimensionality = 3;
+      // for (uint32_t dimensionality = 1; dimensionality < 10;
+      //      dimensionality += 2) {
+      const uint32_t att_dimensionality = 3;
+      // for (uint32_t att_dimensionality = 1;
+      //      att_dimensionality <= dimensionality; att_dimensionality += 2) {
+      for (uint32_t offset_dimensionality = 0;
+           offset_dimensionality < dimensionality - att_dimensionality;
+           ++offset_dimensionality) {
+        PointDVector<PT> var(n_items, dimensionality);
+        PointDVector<PT> dest(n_items, dimensionality);
+
+        std::vector<PT> att(n_items * att_dimensionality);
+        std::vector<draco::Point3ui> att3(n_items);
+        for (PT val = 0; val < n_items; val += 1) {
+          att3[val][0] = val;
+          att3[val][1] = val;
+          att3[val][2] = val;
+          for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+            att[val * att_dimensionality + att_dim] = val;
+          }
+        }
+        const PT *const attribute_data = att.data();
+
+        var.CopyAttribute(att_dimensionality, offset_dimensionality,
+                          attribute_data);
+
+        for (PT item = 0; item < n_items; item += 1) {
+          dest.CopyItem(var, item, item);
+        }
+
+        auto aV0 = att3.begin();
+        auto aVE = att3.end();
+        auto V0 = var.begin();
+        auto VE = var.end();
+        auto D0 = dest.begin();
+        auto DE = dest.end();
+
+        while (aV0 != aVE && V0 != VE && D0 != DE) {
+          ASSERT_EQ(*D0, *V0);  // compare PseudoPointD
+          // verify elemental values
+          for (auto index = 0; index < dimensionality; index += 1) {
+            ASSERT_EQ((*D0)[index], (*V0)[index]);
+            ASSERT_EQ((*D0)[index], (*aV0)[index]);
+            ASSERT_EQ((*aV0)[index], (*V0)[index]);
+          }
+          ++aV0;
+          ++V0;
+          ++D0;
+        }
+
+        for (PT val = 0; val < n_items; val += 1) {
+          for (PT att_dim = 0; att_dim < att_dimensionality; att_dim += 1) {
+            ASSERT_EQ(var[val][offset_dimensionality + att_dim], val);
+            ASSERT_EQ(dest[val][offset_dimensionality + att_dim], val);
+          }
+        }
+      }
+    }
+  }
+
+  void TestPseudoPointDSwap() {
+    draco::Point3ui val = {0, 1, 2};
+    draco::Point3ui dest = {10, 11, 12};
+    draco::PseudoPointD<uint32_t> val_src1(&val[0], 3);
+    draco::PseudoPointD<uint32_t> dest_src1(&dest[0], 3);
+
+    ASSERT_EQ(val_src1[0], 0);
+    ASSERT_EQ(val_src1[1], 1);
+    ASSERT_EQ(val_src1[2], 2);
+    ASSERT_EQ(dest_src1[0], 10);
+    ASSERT_EQ(dest_src1[1], 11);
+    ASSERT_EQ(dest_src1[2], 12);
+
+    ASSERT_NE(val_src1, dest_src1);
+
+    swap(val_src1, dest_src1);
+
+    ASSERT_EQ(dest_src1[0], 0);
+    ASSERT_EQ(dest_src1[1], 1);
+    ASSERT_EQ(dest_src1[2], 2);
+    ASSERT_EQ(val_src1[0], 10);
+    ASSERT_EQ(val_src1[1], 11);
+    ASSERT_EQ(val_src1[2], 12);
+
+    ASSERT_NE(val_src1, dest_src1);
+  }
+  void TestPseudoPointDEquality() {
+    draco::Point3ui val = {0, 1, 2};
+    draco::Point3ui dest = {0, 1, 2};
+    draco::PseudoPointD<uint32_t> val_src1(&val[0], 3);
+    draco::PseudoPointD<uint32_t> val_src2(&val[0], 3);
+    draco::PseudoPointD<uint32_t> dest_src1(&dest[0], 3);
+    draco::PseudoPointD<uint32_t> dest_src2(&dest[0], 3);
+
+    ASSERT_EQ(val_src1, val_src1);
+    ASSERT_EQ(val_src1, val_src2);
+    ASSERT_EQ(dest_src1, val_src1);
+    ASSERT_EQ(dest_src1, val_src2);
+    ASSERT_EQ(val_src2, val_src1);
+    ASSERT_EQ(val_src2, val_src2);
+    ASSERT_EQ(dest_src2, val_src1);
+    ASSERT_EQ(dest_src2, val_src2);
+
+    for (auto i = 0; i < 3; i++) {
+      ASSERT_EQ(val_src1[i], val_src1[i]);
+      ASSERT_EQ(val_src1[i], val_src2[i]);
+      ASSERT_EQ(dest_src1[i], val_src1[i]);
+      ASSERT_EQ(dest_src1[i], val_src2[i]);
+      ASSERT_EQ(val_src2[i], val_src1[i]);
+      ASSERT_EQ(val_src2[i], val_src2[i]);
+      ASSERT_EQ(dest_src2[i], val_src1[i]);
+      ASSERT_EQ(dest_src2[i], val_src2[i]);
+    }
+  }
+  void TestPseudoPointDInequality() {
+    draco::Point3ui val = {0, 1, 2};
+    draco::Point3ui dest = {1, 2, 3};
+    draco::PseudoPointD<uint32_t> val_src1(&val[0], 3);
+    draco::PseudoPointD<uint32_t> val_src2(&val[0], 3);
+    draco::PseudoPointD<uint32_t> dest_src1(&dest[0], 3);
+    draco::PseudoPointD<uint32_t> dest_src2(&dest[0], 3);
+
+    ASSERT_EQ(val_src1, val_src1);
+    ASSERT_EQ(val_src1, val_src2);
+    ASSERT_NE(dest_src1, val_src1);
+    ASSERT_NE(dest_src1, val_src2);
+    ASSERT_EQ(val_src2, val_src1);
+    ASSERT_EQ(val_src2, val_src2);
+    ASSERT_NE(dest_src2, val_src1);
+    ASSERT_NE(dest_src2, val_src2);
+
+    for (auto i = 0; i < 3; i++) {
+      ASSERT_EQ(val_src1[i], val_src1[i]);
+      ASSERT_EQ(val_src1[i], val_src2[i]);
+      ASSERT_NE(dest_src1[i], val_src1[i]);
+      ASSERT_NE(dest_src1[i], val_src2[i]);
+      ASSERT_EQ(val_src2[i], val_src1[i]);
+      ASSERT_EQ(val_src2[i], val_src2[i]);
+      ASSERT_NE(dest_src2[i], val_src1[i]);
+      ASSERT_NE(dest_src2[i], val_src2[i]);
+    }
+  }
+};
+
+TEST_F(PointDVectorTest, VectorTest) {
+  TestSize<uint32_t>();
+  TestContentsDiscrete<uint32_t>();
+  TestContentsContiguous<uint32_t>();
+  TestContentsCopy<uint32_t>();
+  TestIterator<uint32_t>();
+  TestPoint3Iterator<uint32_t>();
+}
+TEST_F(PointDVectorTest, PseudoPointDTest) {
+  TestPseudoPointDSwap();
+  TestPseudoPointDEquality();
+  TestPseudoPointDInequality();
+}
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/points_sequencer.h b/contrib/draco/src/draco/compression/attributes/points_sequencer.h
new file mode 100644
index 000000000..2f4f7e16d
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/points_sequencer.h
@@ -0,0 +1,63 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_POINTS_SEQUENCER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_POINTS_SEQUENCER_H_
+
+#include <vector>
+
+#include "draco/attributes/point_attribute.h"
+
+namespace draco {
+
+// Class for generating a sequence of point ids that can be used to encode
+// or decode attribute values in a specific order.
+// See sequential_attribute_encoders/decoders_controller.h for more details.
+class PointsSequencer {
+ public:
+  PointsSequencer() : out_point_ids_(nullptr) {}
+  virtual ~PointsSequencer() = default;
+
+  // Fills the |out_point_ids| with the generated sequence of point ids.
+  bool GenerateSequence(std::vector<PointIndex> *out_point_ids) {
+    out_point_ids_ = out_point_ids;
+    return GenerateSequenceInternal();
+  }
+
+  // Appends a point to the sequence.
+  void AddPointId(PointIndex point_id) { out_point_ids_->push_back(point_id); }
+
+  // Sets the correct mapping between point ids and value ids. I.e., the inverse
+  // of the |out_point_ids|. In general, |out_point_ids_| does not contain
+  // sufficient information to compute the inverse map, because not all point
+  // ids are necessarily contained within the map.
+  // Must be implemented for sequencers that are used by attribute decoders.
+  virtual bool UpdatePointToAttributeIndexMapping(PointAttribute * /* attr */) {
+    return false;
+  }
+
+ protected:
+  // Method that needs to be implemented by the derived classes. The
+  // implementation is responsible for filling |out_point_ids_| with the valid
+  // sequence of point ids.
+  virtual bool GenerateSequenceInternal() = 0;
+  std::vector<PointIndex> *out_point_ids() const { return out_point_ids_; }
+
+ private:
+  std::vector<PointIndex> *out_point_ids_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_POINTS_SEQUENCER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h
new file mode 100644
index 000000000..36c124baa
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h
@@ -0,0 +1,231 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_DECODER_H_
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/core/varint_decoding.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for predictions encoded with the constrained multi-parallelogram
+// encoder. See the corresponding encoder for more details about the prediction
+// method.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeConstrainedMultiParallelogramDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeDecoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+
+  explicit MeshPredictionSchemeConstrainedMultiParallelogramDecoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+  MeshPredictionSchemeConstrainedMultiParallelogramDecoder(
+      const PointAttribute *attribute, const TransformT &transform,
+      const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+
+ private:
+  typedef constrained_multi_parallelogram::Mode Mode;
+  static constexpr int kMaxNumParallelograms =
+      constrained_multi_parallelogram::kMaxNumParallelograms;
+  // Crease edges are used to store whether any given edge should be used for
+  // parallelogram prediction or not. New values are added in the order in which
+  // the edges are processed. For better compression, the flags are stored in
+  // in separate contexts based on the number of available parallelograms at a
+  // given vertex.
+  std::vector<bool> is_crease_edge_[kMaxNumParallelograms];
+  Mode selected_mode_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
+    DataTypeT, TransformT, MeshDataT>::
+    ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                          int /* size */, int num_components,
+                          const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(num_components);
+
+  // Predicted values for all simple parallelograms encountered at any given
+  // vertex.
+  std::vector<DataTypeT> pred_vals[kMaxNumParallelograms];
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    pred_vals[i].resize(num_components, 0);
+  }
+  this->transform().ComputeOriginalValue(pred_vals[0].data(), in_corr,
+                                         out_data);
+
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  // Current position in the |is_crease_edge_| array for each context.
+  std::vector<int> is_crease_edge_pos(kMaxNumParallelograms, 0);
+
+  // Used to store predicted value for multi-parallelogram prediction.
+  std::vector<DataTypeT> multi_pred_vals(num_components);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 1; p < corner_map_size; ++p) {
+    const CornerIndex start_corner_id =
+        this->mesh_data().data_to_corner_map()->at(p);
+
+    CornerIndex corner_id(start_corner_id);
+    int num_parallelograms = 0;
+    bool first_pass = true;
+    while (corner_id != kInvalidCornerIndex) {
+      if (ComputeParallelogramPrediction(
+              p, corner_id, table, *vertex_to_data_map, out_data,
+              num_components, &(pred_vals[num_parallelograms][0]))) {
+        // Parallelogram prediction applied and stored in
+        // |pred_vals[num_parallelograms]|
+        ++num_parallelograms;
+        // Stop processing when we reach the maximum number of allowed
+        // parallelograms.
+        if (num_parallelograms == kMaxNumParallelograms) {
+          break;
+        }
+      }
+
+      // Proceed to the next corner attached to the vertex. First swing left
+      // and if we reach a boundary, swing right from the start corner.
+      if (first_pass) {
+        corner_id = table->SwingLeft(corner_id);
+      } else {
+        corner_id = table->SwingRight(corner_id);
+      }
+      if (corner_id == start_corner_id) {
+        break;
+      }
+      if (corner_id == kInvalidCornerIndex && first_pass) {
+        first_pass = false;
+        corner_id = table->SwingRight(start_corner_id);
+      }
+    }
+
+    // Check which of the available parallelograms are actually used and compute
+    // the final predicted value.
+    int num_used_parallelograms = 0;
+    if (num_parallelograms > 0) {
+      for (int i = 0; i < num_components; ++i) {
+        multi_pred_vals[i] = 0;
+      }
+      // Check which parallelograms are actually used.
+      for (int i = 0; i < num_parallelograms; ++i) {
+        const int context = num_parallelograms - 1;
+        const int pos = is_crease_edge_pos[context]++;
+        if (is_crease_edge_[context].size() <= pos) {
+          return false;
+        }
+        const bool is_crease = is_crease_edge_[context][pos];
+        if (!is_crease) {
+          ++num_used_parallelograms;
+          for (int j = 0; j < num_components; ++j) {
+            multi_pred_vals[j] += pred_vals[i][j];
+          }
+        }
+      }
+    }
+    const int dst_offset = p * num_components;
+    if (num_used_parallelograms == 0) {
+      // No parallelogram was valid.
+      // We use the last decoded point as a reference.
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeOriginalValue(
+          out_data + src_offset, in_corr + dst_offset, out_data + dst_offset);
+    } else {
+      // Compute the correction from the predicted value.
+      for (int c = 0; c < num_components; ++c) {
+        multi_pred_vals[c] /= num_used_parallelograms;
+      }
+      this->transform().ComputeOriginalValue(
+          multi_pred_vals.data(), in_corr + dst_offset, out_data + dst_offset);
+    }
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
+    DataTypeT, TransformT, MeshDataT>::DecodePredictionData(DecoderBuffer
+                                                                *buffer) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    // Decode prediction mode.
+    uint8_t mode;
+    if (!buffer->Decode(&mode)) {
+      return false;
+    }
+
+    if (mode != Mode::OPTIMAL_MULTI_PARALLELOGRAM) {
+      // Unsupported mode.
+      return false;
+    }
+  }
+#endif
+
+  // Encode selected edges using separate rans bit coder for each context.
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    uint32_t num_flags;
+    if (!DecodeVarint<uint32_t>(&num_flags, buffer)) {
+      return false;
+    }
+    if (num_flags > 0) {
+      is_crease_edge_[i].resize(num_flags);
+      RAnsBitDecoder decoder;
+      if (!decoder.StartDecoding(buffer)) {
+        return false;
+      }
+      for (uint32_t j = 0; j < num_flags; ++j) {
+        is_crease_edge_[i][j] = decoder.DecodeNextBit();
+      }
+      decoder.EndDecoding();
+    }
+  }
+  return MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                     MeshDataT>::DecodePredictionData(buffer);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h
new file mode 100644
index 000000000..77df8ee24
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h
@@ -0,0 +1,414 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_ENCODER_H_
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/entropy/shannon_entropy.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+// Compared to standard multi-parallelogram, constrained multi-parallelogram can
+// explicitly select which of the available parallelograms are going to be used
+// for the prediction by marking crease edges between two triangles. This
+// requires storing extra data, but it allows the predictor to avoid using
+// parallelograms that would lead to poor predictions. For improved efficiency,
+// our current implementation limits the maximum number of used parallelograms
+// to four, which covers >95% of the cases (on average, there are only two
+// parallelograms available for any given vertex).
+// All bits of the explicitly chosen configuration are stored together in a
+// single context chosen by the total number of parallelograms available to
+// choose from.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeConstrainedMultiParallelogramEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeEncoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+
+  explicit MeshPredictionSchemeConstrainedMultiParallelogramEncoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+  MeshPredictionSchemeConstrainedMultiParallelogramEncoder(
+      const PointAttribute *attribute, const TransformT &transform,
+      const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        selected_mode_(Mode::OPTIMAL_MULTI_PARALLELOGRAM) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+
+ private:
+  // Function used to compute number of bits needed to store overhead of the
+  // predictor. In this case, we consider overhead to be all bits that mark
+  // whether a parallelogram should be used for prediction or not. The input
+  // to this method is the total number of parallelograms that were evaluated so
+  // far(total_parallelogram), and the number of parallelograms we decided to
+  // use for prediction (total_used_parallelograms).
+  // Returns number of bits required to store the overhead.
+  int64_t ComputeOverheadBits(int64_t total_used_parallelograms,
+                              int64_t total_parallelogram) const {
+    // For now we assume RAns coding for the bits where the total required size
+    // is directly correlated to the binary entropy of the input stream.
+    // TODO(ostava): This should be generalized in case we use other binary
+    // coding scheme.
+    const double entropy = ComputeBinaryShannonEntropy(
+        static_cast<uint32_t>(total_parallelogram),
+        static_cast<uint32_t>(total_used_parallelograms));
+
+    // Round up to the nearest full bit.
+    return static_cast<int64_t>(
+        ceil(static_cast<double>(total_parallelogram) * entropy));
+  }
+
+  // Struct that contains data used for measuring the error of each available
+  // parallelogram configuration.
+  struct Error {
+    Error() : num_bits(0), residual_error(0) {}
+
+    // Primary metric: number of bits required to store the data as a result of
+    // the selected prediction configuration.
+    int num_bits;
+    // Secondary metric: absolute difference of residuals for the given
+    // configuration.
+    int residual_error;
+
+    bool operator<(const Error &e) const {
+      if (num_bits < e.num_bits) {
+        return true;
+      }
+      if (num_bits > e.num_bits) {
+        return false;
+      }
+      return residual_error < e.residual_error;
+    }
+  };
+
+  // Computes error for predicting |predicted_val| instead of |actual_val|.
+  // Error is computed as the number of bits needed to encode the difference
+  // between the values.
+  Error ComputeError(const DataTypeT *predicted_val,
+                     const DataTypeT *actual_val, int *out_residuals,
+                     int num_components) {
+    Error error;
+
+    for (int i = 0; i < num_components; ++i) {
+      const int dif = (predicted_val[i] - actual_val[i]);
+      error.residual_error += std::abs(dif);
+      out_residuals[i] = dif;
+      // Entropy needs unsigned symbols, so convert the signed difference to an
+      // unsigned symbol.
+      entropy_symbols_[i] = ConvertSignedIntToSymbol(dif);
+    }
+
+    // Generate entropy data for case that this configuration was used.
+    // Note that the entropy stream is NOT updated in this case.
+    const auto entropy_data =
+        entropy_tracker_.Peek(entropy_symbols_.data(), num_components);
+
+    error.num_bits = entropy_tracker_.GetNumberOfDataBits(entropy_data) +
+                     entropy_tracker_.GetNumberOfRAnsTableBits(entropy_data);
+    return error;
+  }
+
+  typedef constrained_multi_parallelogram::Mode Mode;
+  static constexpr int kMaxNumParallelograms =
+      constrained_multi_parallelogram::kMaxNumParallelograms;
+  // Crease edges are used to store whether any given edge should be used for
+  // parallelogram prediction or not. New values are added in the order in which
+  // the edges are processed. For better compression, the flags are stored in
+  // in separate contexts based on the number of available parallelograms at a
+  // given vertex.
+  // TODO(draco-eng) reconsider std::vector<bool> (performance/space).
+  std::vector<bool> is_crease_edge_[kMaxNumParallelograms];
+  Mode selected_mode_;
+
+  ShannonEntropyTracker entropy_tracker_;
+
+  // Temporary storage for symbols that are fed into the |entropy_stream|.
+  // Always contains only |num_components| entries.
+  std::vector<uint32_t> entropy_symbols_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramEncoder<
+    DataTypeT, TransformT, MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(in_data, size, num_components);
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  // Predicted values for all simple parallelograms encountered at any given
+  // vertex.
+  std::vector<DataTypeT> pred_vals[kMaxNumParallelograms];
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    pred_vals[i].resize(num_components);
+  }
+  // Used to store predicted value for various multi-parallelogram predictions
+  // (combinations of simple parallelogram predictions).
+  std::vector<DataTypeT> multi_pred_vals(num_components);
+  entropy_symbols_.resize(num_components);
+
+  // Struct for holding data about prediction configuration for different sets
+  // of used parallelograms.
+  struct PredictionConfiguration {
+    PredictionConfiguration()
+        : error(), configuration(0), num_used_parallelograms(0) {}
+    Error error;
+    uint8_t configuration;  // Bitfield, 1 use parallelogram, 0 don't use it.
+    int num_used_parallelograms;
+    std::vector<DataTypeT> predicted_value;
+    std::vector<int32_t> residuals;
+  };
+
+  // Bit-field used for computing permutations of excluded edges
+  // (parallelograms).
+  bool exluded_parallelograms[kMaxNumParallelograms];
+
+  // Data about the number of used parallelogram and total number of available
+  // parallelogram for each context. Used to compute overhead needed for storing
+  // the parallelogram choices made by the encoder.
+  int64_t total_used_parallelograms[kMaxNumParallelograms] = {0};
+  int64_t total_parallelograms[kMaxNumParallelograms] = {0};
+
+  std::vector<int> current_residuals(num_components);
+
+  // We start processing the vertices from the end because this prediction uses
+  // data from previous entries that could be overwritten when an entry is
+  // processed.
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size()) - 1;
+       p > 0; --p) {
+    const CornerIndex start_corner_id =
+        this->mesh_data().data_to_corner_map()->at(p);
+
+    // Go over all corners attached to the vertex and compute the predicted
+    // value from the parallelograms defined by their opposite faces.
+    CornerIndex corner_id(start_corner_id);
+    int num_parallelograms = 0;
+    bool first_pass = true;
+    while (corner_id != kInvalidCornerIndex) {
+      if (ComputeParallelogramPrediction(
+              p, corner_id, table, *vertex_to_data_map, in_data, num_components,
+              &(pred_vals[num_parallelograms][0]))) {
+        // Parallelogram prediction applied and stored in
+        // |pred_vals[num_parallelograms]|
+        ++num_parallelograms;
+        // Stop processing when we reach the maximum number of allowed
+        // parallelograms.
+        if (num_parallelograms == kMaxNumParallelograms) {
+          break;
+        }
+      }
+
+      // Proceed to the next corner attached to the vertex. First swing left
+      // and if we reach a boundary, swing right from the start corner.
+      if (first_pass) {
+        corner_id = table->SwingLeft(corner_id);
+      } else {
+        corner_id = table->SwingRight(corner_id);
+      }
+      if (corner_id == start_corner_id) {
+        break;
+      }
+      if (corner_id == kInvalidCornerIndex && first_pass) {
+        first_pass = false;
+        corner_id = table->SwingRight(start_corner_id);
+      }
+    }
+
+    // Offset to the target (destination) vertex.
+    const int dst_offset = p * num_components;
+    Error error;
+
+    // Compute all prediction errors for all possible configurations of
+    // available parallelograms.
+
+    // Variable for holding the best configuration that has been found so far.
+    PredictionConfiguration best_prediction;
+
+    // Compute delta coding error (configuration when no parallelogram is
+    // selected).
+    const int src_offset = (p - 1) * num_components;
+    error = ComputeError(in_data + src_offset, in_data + dst_offset,
+                         &current_residuals[0], num_components);
+
+    if (num_parallelograms > 0) {
+      total_parallelograms[num_parallelograms - 1] += num_parallelograms;
+      const int64_t new_overhead_bits =
+          ComputeOverheadBits(total_used_parallelograms[num_parallelograms - 1],
+                              total_parallelograms[num_parallelograms - 1]);
+      error.num_bits += new_overhead_bits;
+    }
+
+    best_prediction.error = error;
+    best_prediction.configuration = 0;
+    best_prediction.num_used_parallelograms = 0;
+    best_prediction.predicted_value.assign(
+        in_data + src_offset, in_data + src_offset + num_components);
+    best_prediction.residuals.assign(current_residuals.begin(),
+                                     current_residuals.end());
+
+    // Compute prediction error for different cases of used parallelograms.
+    for (int num_used_parallelograms = 1;
+         num_used_parallelograms <= num_parallelograms;
+         ++num_used_parallelograms) {
+      // Mark all parallelograms as excluded.
+      std::fill(exluded_parallelograms,
+                exluded_parallelograms + num_parallelograms, true);
+      // TODO(draco-eng) maybe this should be another std::fill.
+      // Mark the first |num_used_parallelograms| as not excluded.
+      for (int j = 0; j < num_used_parallelograms; ++j) {
+        exluded_parallelograms[j] = false;
+      }
+      // Permute over the excluded edges and compute error for each
+      // configuration (permutation of excluded parallelograms).
+      do {
+        // Reset the multi-parallelogram predicted values.
+        for (int j = 0; j < num_components; ++j) {
+          multi_pred_vals[j] = 0;
+        }
+        uint8_t configuration = 0;
+        for (int j = 0; j < num_parallelograms; ++j) {
+          if (exluded_parallelograms[j]) {
+            continue;
+          }
+          for (int c = 0; c < num_components; ++c) {
+            multi_pred_vals[c] += pred_vals[j][c];
+          }
+          // Set jth bit of the configuration.
+          configuration |= (1 << j);
+        }
+
+        for (int j = 0; j < num_components; ++j) {
+          multi_pred_vals[j] /= num_used_parallelograms;
+        }
+        error = ComputeError(multi_pred_vals.data(), in_data + dst_offset,
+                             &current_residuals[0], num_components);
+        if (num_parallelograms > 0) {
+          const int64_t new_overhead_bits = ComputeOverheadBits(
+              total_used_parallelograms[num_parallelograms - 1] +
+                  num_used_parallelograms,
+              total_parallelograms[num_parallelograms - 1]);
+
+          // Add overhead bits to the total error.
+          error.num_bits += new_overhead_bits;
+        }
+        if (error < best_prediction.error) {
+          best_prediction.error = error;
+          best_prediction.configuration = configuration;
+          best_prediction.num_used_parallelograms = num_used_parallelograms;
+          best_prediction.predicted_value.assign(multi_pred_vals.begin(),
+                                                 multi_pred_vals.end());
+          best_prediction.residuals.assign(current_residuals.begin(),
+                                           current_residuals.end());
+        }
+      } while (std::next_permutation(
+          exluded_parallelograms, exluded_parallelograms + num_parallelograms));
+    }
+    if (num_parallelograms > 0) {
+      total_used_parallelograms[num_parallelograms - 1] +=
+          best_prediction.num_used_parallelograms;
+    }
+
+    // Update the entropy stream by adding selected residuals as symbols to the
+    // stream.
+    for (int i = 0; i < num_components; ++i) {
+      entropy_symbols_[i] =
+          ConvertSignedIntToSymbol(best_prediction.residuals[i]);
+    }
+    entropy_tracker_.Push(entropy_symbols_.data(), num_components);
+
+    for (int i = 0; i < num_parallelograms; ++i) {
+      if ((best_prediction.configuration & (1 << i)) == 0) {
+        // Parallelogram not used, mark the edge as crease.
+        is_crease_edge_[num_parallelograms - 1].push_back(true);
+      } else {
+        // Parallelogram used. Add it to the predicted value and mark the
+        // edge as not a crease.
+        is_crease_edge_[num_parallelograms - 1].push_back(false);
+      }
+    }
+    this->transform().ComputeCorrection(in_data + dst_offset,
+                                        best_prediction.predicted_value.data(),
+                                        out_corr + dst_offset);
+  }
+  // First element is always fixed because it cannot be predicted.
+  for (int i = 0; i < num_components; ++i) {
+    pred_vals[0][i] = static_cast<DataTypeT>(0);
+  }
+  this->transform().ComputeCorrection(in_data, pred_vals[0].data(), out_corr);
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeConstrainedMultiParallelogramEncoder<
+    DataTypeT, TransformT, MeshDataT>::EncodePredictionData(EncoderBuffer
+                                                                *buffer) {
+  // Encode selected edges using separate rans bit coder for each context.
+  for (int i = 0; i < kMaxNumParallelograms; ++i) {
+    // |i| is the context based on the number of available parallelograms, which
+    // is always equal to |i + 1|.
+    const int num_used_parallelograms = i + 1;
+    EncodeVarint<uint32_t>(is_crease_edge_[i].size(), buffer);
+    if (is_crease_edge_[i].size()) {
+      RAnsBitEncoder encoder;
+      encoder.StartEncoding();
+      // Encode the crease edge flags in the reverse vertex order that is needed
+      // be the decoder. Note that for the currently supported mode, each vertex
+      // has exactly |num_used_parallelograms| edges that need to be encoded.
+      for (int j = static_cast<int>(is_crease_edge_[i].size()) -
+                   num_used_parallelograms;
+           j >= 0; j -= num_used_parallelograms) {
+        // Go over all edges of the current vertex.
+        for (int k = 0; k < num_used_parallelograms; ++k) {
+          encoder.EncodeBit(is_crease_edge_[i][j + k]);
+        }
+      }
+      encoder.EndEncoding(buffer);
+    }
+  }
+  return MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                     MeshDataT>::EncodePredictionData(buffer);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h
new file mode 100644
index 000000000..c7a4e351a
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_shared.h
@@ -0,0 +1,34 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_SHARED_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_SHARED_H_
+
+namespace draco {
+
+// Data shared between constrained multi-parallelogram encoder and decoder.
+namespace constrained_multi_parallelogram {
+
+enum Mode {
+  // Selects the optimal multi-parallelogram from up to 4 available
+  // parallelograms.
+  OPTIMAL_MULTI_PARALLELOGRAM = 0,
+};
+
+static constexpr int kMaxNumParallelograms = 4;
+
+}  // namespace constrained_multi_parallelogram
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_CONSTRAINED_MULTI_PARALLELOGRAM_SHARED_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h
new file mode 100644
index 000000000..2960a5e71
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h
@@ -0,0 +1,72 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DATA_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DATA_H_
+
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class stores data about the connectivity data of the mesh and information
+// about how the connectivity was encoded/decoded.
+template <class CornerTableT>
+class MeshPredictionSchemeData {
+ public:
+  typedef CornerTableT CornerTable;
+  MeshPredictionSchemeData()
+      : mesh_(nullptr),
+        corner_table_(nullptr),
+        vertex_to_data_map_(nullptr),
+        data_to_corner_map_(nullptr) {}
+
+  void Set(const Mesh *mesh, const CornerTable *table,
+           const std::vector<CornerIndex> *data_to_corner_map,
+           const std::vector<int32_t> *vertex_to_data_map) {
+    mesh_ = mesh;
+    corner_table_ = table;
+    data_to_corner_map_ = data_to_corner_map;
+    vertex_to_data_map_ = vertex_to_data_map;
+  }
+
+  const Mesh *mesh() const { return mesh_; }
+  const CornerTable *corner_table() const { return corner_table_; }
+  const std::vector<int32_t> *vertex_to_data_map() const {
+    return vertex_to_data_map_;
+  }
+  const std::vector<CornerIndex> *data_to_corner_map() const {
+    return data_to_corner_map_;
+  }
+  bool IsInitialized() const {
+    return mesh_ != nullptr && corner_table_ != nullptr &&
+           vertex_to_data_map_ != nullptr && data_to_corner_map_ != nullptr;
+  }
+
+ private:
+  const Mesh *mesh_;
+  const CornerTable *corner_table_;
+
+  // Mapping between vertices and their encoding order. I.e. when an attribute
+  // entry on a given vertex was encoded.
+  const std::vector<int32_t> *vertex_to_data_map_;
+
+  // Array that stores which corner was processed when a given attribute entry
+  // was encoded or decoded.
+  const std::vector<CornerIndex> *data_to_corner_map_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DATA_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h
new file mode 100644
index 000000000..6694a981c
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h
@@ -0,0 +1,46 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+
+namespace draco {
+
+// Base class for all mesh prediction scheme decoders that use the mesh
+// connectivity data. |MeshDataT| can be any class that provides the same
+// interface as the PredictionSchemeMeshData class.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeDecoder
+    : public PredictionSchemeDecoder<DataTypeT, TransformT> {
+ public:
+  typedef MeshDataT MeshData;
+  MeshPredictionSchemeDecoder(const PointAttribute *attribute,
+                              const TransformT &transform,
+                              const MeshDataT &mesh_data)
+      : PredictionSchemeDecoder<DataTypeT, TransformT>(attribute, transform),
+        mesh_data_(mesh_data) {}
+
+ protected:
+  const MeshData &mesh_data() const { return mesh_data_; }
+
+ private:
+  MeshData mesh_data_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h
new file mode 100644
index 000000000..ab3c81a39
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h
@@ -0,0 +1,46 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+
+namespace draco {
+
+// Base class for all mesh prediction scheme encoders that use the mesh
+// connectivity data. |MeshDataT| can be any class that provides the same
+// interface as the PredictionSchemeMeshData class.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeEncoder
+    : public PredictionSchemeEncoder<DataTypeT, TransformT> {
+ public:
+  typedef MeshDataT MeshData;
+  MeshPredictionSchemeEncoder(const PointAttribute *attribute,
+                              const TransformT &transform,
+                              const MeshDataT &mesh_data)
+      : PredictionSchemeEncoder<DataTypeT, TransformT>(attribute, transform),
+        mesh_data_(mesh_data) {}
+
+ protected:
+  const MeshData &mesh_data() const { return mesh_data_; }
+
+ private:
+  MeshData mesh_data_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h
new file mode 100644
index 000000000..da1387a30
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h
@@ -0,0 +1,172 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// See MeshPredictionSchemeGeometricNormalEncoder for documentation.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeGeometricNormalDecoder(const PointAttribute *attribute,
+                                             const TransformT &transform,
+                                             const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+ private:
+  MeshPredictionSchemeGeometricNormalDecoder() {}
+
+ public:
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_GEOMETRIC_NORMAL;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    if (!octahedron_tool_box_.IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+  void SetQuantizationBits(int q) {
+    octahedron_tool_box_.SetQuantizationBits(q);
+  }
+
+ private:
+  MeshPredictionSchemeGeometricNormalPredictorArea<DataTypeT, TransformT,
+                                                   MeshDataT>
+      predictor_;
+  OctahedronToolBox octahedron_tool_box_;
+  RAnsBitDecoder flip_normal_bit_decoder_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalDecoder<
+    DataTypeT, TransformT,
+    MeshDataT>::ComputeOriginalValues(const CorrType *in_corr,
+                                      DataTypeT *out_data, int /* size */,
+                                      int num_components,
+                                      const PointIndex *entry_to_point_id_map) {
+  this->SetQuantizationBits(this->transform().quantization_bits());
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  DRACO_DCHECK(this->IsInitialized());
+
+  // Expecting in_data in octahedral coordinates, i.e., portable attribute.
+  DRACO_DCHECK_EQ(num_components, 2);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+
+  VectorD<int32_t, 3> pred_normal_3d;
+  int32_t pred_normal_oct[2];
+
+  for (int data_id = 0; data_id < corner_map_size; ++data_id) {
+    const CornerIndex corner_id =
+        this->mesh_data().data_to_corner_map()->at(data_id);
+    predictor_.ComputePredictedValue(corner_id, pred_normal_3d.data());
+
+    // Compute predicted octahedral coordinates.
+    octahedron_tool_box_.CanonicalizeIntegerVector(pred_normal_3d.data());
+    DRACO_DCHECK_EQ(pred_normal_3d.AbsSum(),
+                    octahedron_tool_box_.center_value());
+    if (flip_normal_bit_decoder_.DecodeNextBit()) {
+      pred_normal_3d = -pred_normal_3d;
+    }
+    octahedron_tool_box_.IntegerVectorToQuantizedOctahedralCoords(
+        pred_normal_3d.data(), pred_normal_oct, pred_normal_oct + 1);
+
+    const int data_offset = data_id * 2;
+    this->transform().ComputeOriginalValue(
+        pred_normal_oct, in_corr + data_offset, out_data + data_offset);
+  }
+  flip_normal_bit_decoder_.EndDecoding();
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalDecoder<
+    DataTypeT, TransformT, MeshDataT>::DecodePredictionData(DecoderBuffer
+                                                                *buffer) {
+  // Get data needed for transform
+  if (!this->transform().DecodeTransformData(buffer)) {
+    return false;
+  }
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    uint8_t prediction_mode;
+    if (!buffer->Decode(&prediction_mode)) {
+      return false;
+    }
+
+    if (!predictor_.SetNormalPredictionMode(
+            NormalPredictionMode(prediction_mode))) {
+      return false;
+    }
+  }
+#endif
+
+  // Init normal flips.
+  if (!flip_normal_bit_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h
new file mode 100644
index 000000000..cf146f83a
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h
@@ -0,0 +1,180 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+
+namespace draco {
+
+// Prediction scheme for normals based on the underlying geometry.
+// At a smooth vertices normals are computed by weighting the normals of
+// adjacent faces with the area of these faces. At seams, the same approach
+// applies for seam corners.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeGeometricNormalEncoder(const PointAttribute *attribute,
+                                             const TransformT &transform,
+                                             const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_GEOMETRIC_NORMAL;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+
+ private:
+  void SetQuantizationBits(int q) {
+    DRACO_DCHECK_GE(q, 2);
+    DRACO_DCHECK_LE(q, 30);
+    octahedron_tool_box_.SetQuantizationBits(q);
+  }
+  MeshPredictionSchemeGeometricNormalPredictorArea<DataTypeT, TransformT,
+                                                   MeshDataT>
+      predictor_;
+
+  OctahedronToolBox octahedron_tool_box_;
+  RAnsBitEncoder flip_normal_bit_encoder_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalEncoder<DataTypeT, TransformT,
+                                                MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex *entry_to_point_id_map) {
+  this->SetQuantizationBits(this->transform().quantization_bits());
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  DRACO_DCHECK(this->IsInitialized());
+  // Expecting in_data in octahedral coordinates, i.e., portable attribute.
+  DRACO_DCHECK_EQ(num_components, 2);
+
+  flip_normal_bit_encoder_.StartEncoding();
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+
+  VectorD<int32_t, 3> pred_normal_3d;
+  VectorD<int32_t, 2> pos_pred_normal_oct;
+  VectorD<int32_t, 2> neg_pred_normal_oct;
+  VectorD<int32_t, 2> pos_correction;
+  VectorD<int32_t, 2> neg_correction;
+  for (int data_id = 0; data_id < corner_map_size; ++data_id) {
+    const CornerIndex corner_id =
+        this->mesh_data().data_to_corner_map()->at(data_id);
+    predictor_.ComputePredictedValue(corner_id, pred_normal_3d.data());
+
+    // Compute predicted octahedral coordinates.
+    octahedron_tool_box_.CanonicalizeIntegerVector(pred_normal_3d.data());
+    DRACO_DCHECK_EQ(pred_normal_3d.AbsSum(),
+                    octahedron_tool_box_.center_value());
+
+    // Compute octahedral coordinates for both possible directions.
+    octahedron_tool_box_.IntegerVectorToQuantizedOctahedralCoords(
+        pred_normal_3d.data(), pos_pred_normal_oct.data(),
+        pos_pred_normal_oct.data() + 1);
+    pred_normal_3d = -pred_normal_3d;
+    octahedron_tool_box_.IntegerVectorToQuantizedOctahedralCoords(
+        pred_normal_3d.data(), neg_pred_normal_oct.data(),
+        neg_pred_normal_oct.data() + 1);
+
+    // Choose the one with the best correction value.
+    const int data_offset = data_id * 2;
+    this->transform().ComputeCorrection(in_data + data_offset,
+                                        pos_pred_normal_oct.data(),
+                                        pos_correction.data());
+    this->transform().ComputeCorrection(in_data + data_offset,
+                                        neg_pred_normal_oct.data(),
+                                        neg_correction.data());
+    pos_correction[0] = octahedron_tool_box_.ModMax(pos_correction[0]);
+    pos_correction[1] = octahedron_tool_box_.ModMax(pos_correction[1]);
+    neg_correction[0] = octahedron_tool_box_.ModMax(neg_correction[0]);
+    neg_correction[1] = octahedron_tool_box_.ModMax(neg_correction[1]);
+    if (pos_correction.AbsSum() < neg_correction.AbsSum()) {
+      flip_normal_bit_encoder_.EncodeBit(false);
+      (out_corr + data_offset)[0] =
+          octahedron_tool_box_.MakePositive(pos_correction[0]);
+      (out_corr + data_offset)[1] =
+          octahedron_tool_box_.MakePositive(pos_correction[1]);
+    } else {
+      flip_normal_bit_encoder_.EncodeBit(true);
+      (out_corr + data_offset)[0] =
+          octahedron_tool_box_.MakePositive(neg_correction[0]);
+      (out_corr + data_offset)[1] =
+          octahedron_tool_box_.MakePositive(neg_correction[1]);
+    }
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeGeometricNormalEncoder<
+    DataTypeT, TransformT, MeshDataT>::EncodePredictionData(EncoderBuffer
+                                                                *buffer) {
+  if (!this->transform().EncodeTransformData(buffer)) {
+    return false;
+  }
+
+  // Encode normal flips.
+  flip_normal_bit_encoder_.EndEncoding(buffer);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h
new file mode 100644
index 000000000..775eded6b
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_area.h
@@ -0,0 +1,117 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_AREA_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_AREA_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h"
+
+namespace draco {
+
+// This predictor estimates the normal via the surrounding triangles of the
+// given corner. Triangles are weighted according to their area.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalPredictorArea
+    : public MeshPredictionSchemeGeometricNormalPredictorBase<
+          DataTypeT, TransformT, MeshDataT> {
+  typedef MeshPredictionSchemeGeometricNormalPredictorBase<
+      DataTypeT, TransformT, MeshDataT>
+      Base;
+
+ public:
+  explicit MeshPredictionSchemeGeometricNormalPredictorArea(const MeshDataT &md)
+      : Base(md) {
+    this->SetNormalPredictionMode(TRIANGLE_AREA);
+  };
+  virtual ~MeshPredictionSchemeGeometricNormalPredictorArea() {}
+
+  // Computes predicted octahedral coordinates on a given corner.
+  void ComputePredictedValue(CornerIndex corner_id,
+                             DataTypeT *prediction) override {
+    DRACO_DCHECK(this->IsInitialized());
+    typedef typename MeshDataT::CornerTable CornerTable;
+    const CornerTable *const corner_table = this->mesh_data_.corner_table();
+    // Going to compute the predicted normal from the surrounding triangles
+    // according to the connectivity of the given corner table.
+    VertexCornersIterator<CornerTable> cit(corner_table, corner_id);
+    // Position of central vertex does not change in loop.
+    const VectorD<int64_t, 3> pos_cent = this->GetPositionForCorner(corner_id);
+    // Computing normals for triangles and adding them up.
+
+    VectorD<int64_t, 3> normal;
+    CornerIndex c_next, c_prev;
+    while (!cit.End()) {
+      // Getting corners.
+      if (this->normal_prediction_mode_ == ONE_TRIANGLE) {
+        c_next = corner_table->Next(corner_id);
+        c_prev = corner_table->Previous(corner_id);
+      } else {
+        c_next = corner_table->Next(cit.Corner());
+        c_prev = corner_table->Previous(cit.Corner());
+      }
+      const VectorD<int64_t, 3> pos_next = this->GetPositionForCorner(c_next);
+      const VectorD<int64_t, 3> pos_prev = this->GetPositionForCorner(c_prev);
+
+      // Computing delta vectors to next and prev.
+      const VectorD<int64_t, 3> delta_next = pos_next - pos_cent;
+      const VectorD<int64_t, 3> delta_prev = pos_prev - pos_cent;
+
+      // Computing cross product.
+      const VectorD<int64_t, 3> cross = CrossProduct(delta_next, delta_prev);
+
+      // Prevent signed integer overflows by doing math as unsigned.
+      auto normal_data = reinterpret_cast<uint64_t *>(normal.data());
+      auto cross_data = reinterpret_cast<const uint64_t *>(cross.data());
+      normal_data[0] = normal_data[0] + cross_data[0];
+      normal_data[1] = normal_data[1] + cross_data[1];
+      normal_data[2] = normal_data[2] + cross_data[2];
+
+      cit.Next();
+    }
+
+    // Convert to int32_t, make sure entries are not too large.
+    constexpr int64_t upper_bound = 1 << 29;
+    if (this->normal_prediction_mode_ == ONE_TRIANGLE) {
+      const int32_t abs_sum = static_cast<int32_t>(normal.AbsSum());
+      if (abs_sum > upper_bound) {
+        const int64_t quotient = abs_sum / upper_bound;
+        normal = normal / quotient;
+      }
+    } else {
+      const int64_t abs_sum = normal.AbsSum();
+      if (abs_sum > upper_bound) {
+        const int64_t quotient = abs_sum / upper_bound;
+        normal = normal / quotient;
+      }
+    }
+    DRACO_DCHECK_LE(normal.AbsSum(), upper_bound);
+    prediction[0] = static_cast<int32_t>(normal[0]);
+    prediction[1] = static_cast<int32_t>(normal[1]);
+    prediction[2] = static_cast<int32_t>(normal[2]);
+  }
+  bool SetNormalPredictionMode(NormalPredictionMode mode) override {
+    if (mode == ONE_TRIANGLE) {
+      this->normal_prediction_mode_ = mode;
+      return true;
+    } else if (mode == TRIANGLE_AREA) {
+      this->normal_prediction_mode_ = mode;
+      return true;
+    }
+    return false;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_AREA_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h
new file mode 100644
index 000000000..a554dda96
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_predictor_base.h
@@ -0,0 +1,96 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_BASE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_BASE_H_
+
+#include <math.h>
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/math_utils.h"
+#include "draco/core/vector_d.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/corner_table_iterators.h"
+
+namespace draco {
+
+// Base class for geometric normal predictors using position attribute.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeGeometricNormalPredictorBase {
+ protected:
+  explicit MeshPredictionSchemeGeometricNormalPredictorBase(const MeshDataT &md)
+      : pos_attribute_(nullptr),
+        entry_to_point_id_map_(nullptr),
+        mesh_data_(md) {}
+  virtual ~MeshPredictionSchemeGeometricNormalPredictorBase() {}
+
+ public:
+  void SetPositionAttribute(const PointAttribute &position_attribute) {
+    pos_attribute_ = &position_attribute;
+  }
+  void SetEntryToPointIdMap(const PointIndex *map) {
+    entry_to_point_id_map_ = map;
+  }
+  bool IsInitialized() const {
+    if (pos_attribute_ == nullptr) {
+      return false;
+    }
+    if (entry_to_point_id_map_ == nullptr) {
+      return false;
+    }
+    return true;
+  }
+
+  virtual bool SetNormalPredictionMode(NormalPredictionMode mode) = 0;
+  virtual NormalPredictionMode GetNormalPredictionMode() const {
+    return normal_prediction_mode_;
+  }
+
+ protected:
+  VectorD<int64_t, 3> GetPositionForDataId(int data_id) const {
+    DRACO_DCHECK(this->IsInitialized());
+    const auto point_id = entry_to_point_id_map_[data_id];
+    const auto pos_val_id = pos_attribute_->mapped_index(point_id);
+    VectorD<int64_t, 3> pos;
+    pos_attribute_->ConvertValue(pos_val_id, &pos[0]);
+    return pos;
+  }
+  VectorD<int64_t, 3> GetPositionForCorner(CornerIndex ci) const {
+    DRACO_DCHECK(this->IsInitialized());
+    const auto corner_table = mesh_data_.corner_table();
+    const auto vert_id = corner_table->Vertex(ci).value();
+    const auto data_id = mesh_data_.vertex_to_data_map()->at(vert_id);
+    return GetPositionForDataId(data_id);
+  }
+  VectorD<int32_t, 2> GetOctahedralCoordForDataId(int data_id,
+                                                  const DataTypeT *data) const {
+    DRACO_DCHECK(this->IsInitialized());
+    const int data_offset = data_id * 2;
+    return VectorD<int32_t, 2>(data[data_offset], data[data_offset + 1]);
+  }
+  // Computes predicted octahedral coordinates on a given corner.
+  virtual void ComputePredictedValue(CornerIndex corner_id,
+                                     DataTypeT *prediction) = 0;
+
+  const PointAttribute *pos_attribute_;
+  const PointIndex *entry_to_point_id_map_;
+  MeshDataT mesh_data_;
+  NormalPredictionMode normal_prediction_mode_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_GEOMETRIC_NORMAL_PREDICTOR_BASE_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h
new file mode 100644
index 000000000..fc82e0a8f
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h
@@ -0,0 +1,126 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for predictions encoded by multi-parallelogram encoding scheme.
+// See the corresponding encoder for method description.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeMultiParallelogramDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeDecoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+
+  explicit MeshPredictionSchemeMultiParallelogramDecoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute) {}
+  MeshPredictionSchemeMultiParallelogramDecoder(const PointAttribute *attribute,
+                                                const TransformT &transform,
+                                                const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_MULTI_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeMultiParallelogramDecoder<DataTypeT, TransformT,
+                                                   MeshDataT>::
+    ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                          int /* size */, int num_components,
+                          const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(num_components);
+
+  // For storage of prediction values (already initialized to zero).
+  std::unique_ptr<DataTypeT[]> pred_vals(new DataTypeT[num_components]());
+  std::unique_ptr<DataTypeT[]> parallelogram_pred_vals(
+      new DataTypeT[num_components]());
+
+  this->transform().ComputeOriginalValue(pred_vals.get(), in_corr, out_data);
+
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 1; p < corner_map_size; ++p) {
+    const CornerIndex start_corner_id =
+        this->mesh_data().data_to_corner_map()->at(p);
+
+    CornerIndex corner_id(start_corner_id);
+    int num_parallelograms = 0;
+    for (int i = 0; i < num_components; ++i) {
+      pred_vals[i] = static_cast<DataTypeT>(0);
+    }
+    while (corner_id != kInvalidCornerIndex) {
+      if (ComputeParallelogramPrediction(
+              p, corner_id, table, *vertex_to_data_map, out_data,
+              num_components, parallelogram_pred_vals.get())) {
+        for (int c = 0; c < num_components; ++c) {
+          pred_vals[c] += parallelogram_pred_vals[c];
+        }
+        ++num_parallelograms;
+      }
+
+      // Proceed to the next corner attached to the vertex.
+      corner_id = table->SwingRight(corner_id);
+      if (corner_id == start_corner_id) {
+        corner_id = kInvalidCornerIndex;
+      }
+    }
+
+    const int dst_offset = p * num_components;
+    if (num_parallelograms == 0) {
+      // No parallelogram was valid.
+      // We use the last decoded point as a reference.
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeOriginalValue(
+          out_data + src_offset, in_corr + dst_offset, out_data + dst_offset);
+    } else {
+      // Compute the correction from the predicted value.
+      for (int c = 0; c < num_components; ++c) {
+        pred_vals[c] /= num_parallelograms;
+      }
+      this->transform().ComputeOriginalValue(
+          pred_vals.get(), in_corr + dst_offset, out_data + dst_offset);
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_DECODER_H_
+#endif
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h
new file mode 100644
index 000000000..301b357d4
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h
@@ -0,0 +1,133 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+
+namespace draco {
+
+// Multi parallelogram prediction predicts attribute values using information
+// from all opposite faces to the predicted vertex, compared to the standard
+// prediction scheme, where only one opposite face is used (see
+// prediction_scheme_parallelogram.h). This approach is generally slower than
+// the standard parallelogram prediction, but it usually results in better
+// prediction (5 - 20% based on the quantization level. Better gains can be
+// achieved when more aggressive quantization is used).
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeMultiParallelogramEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeEncoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+
+  explicit MeshPredictionSchemeMultiParallelogramEncoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute) {}
+  MeshPredictionSchemeMultiParallelogramEncoder(const PointAttribute *attribute,
+                                                const TransformT &transform,
+                                                const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_MULTI_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeMultiParallelogramEncoder<DataTypeT, TransformT,
+                                                   MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(in_data, size, num_components);
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  // For storage of prediction values (already initialized to zero).
+  std::unique_ptr<DataTypeT[]> pred_vals(new DataTypeT[num_components]());
+  std::unique_ptr<DataTypeT[]> parallelogram_pred_vals(
+      new DataTypeT[num_components]());
+
+  // We start processing from the end because this prediction uses data from
+  // previous entries that could be overwritten when an entry is processed.
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size() - 1);
+       p > 0; --p) {
+    const CornerIndex start_corner_id =
+        this->mesh_data().data_to_corner_map()->at(p);
+
+    // Go over all corners attached to the vertex and compute the predicted
+    // value from the parallelograms defined by their opposite faces.
+    CornerIndex corner_id(start_corner_id);
+    int num_parallelograms = 0;
+    for (int i = 0; i < num_components; ++i) {
+      pred_vals[i] = static_cast<DataTypeT>(0);
+    }
+    while (corner_id != kInvalidCornerIndex) {
+      if (ComputeParallelogramPrediction(
+              p, corner_id, table, *vertex_to_data_map, in_data, num_components,
+              parallelogram_pred_vals.get())) {
+        for (int c = 0; c < num_components; ++c) {
+          pred_vals[c] += parallelogram_pred_vals[c];
+        }
+        ++num_parallelograms;
+      }
+
+      // Proceed to the next corner attached to the vertex.
+      corner_id = table->SwingRight(corner_id);
+      if (corner_id == start_corner_id) {
+        corner_id = kInvalidCornerIndex;
+      }
+    }
+    const int dst_offset = p * num_components;
+    if (num_parallelograms == 0) {
+      // No parallelogram was valid.
+      // We use the last encoded point as a reference.
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeCorrection(
+          in_data + dst_offset, in_data + src_offset, out_corr + dst_offset);
+    } else {
+      // Compute the correction from the predicted value.
+      for (int c = 0; c < num_components; ++c) {
+        pred_vals[c] /= num_parallelograms;
+      }
+      this->transform().ComputeCorrection(in_data + dst_offset, pred_vals.get(),
+                                          out_corr + dst_offset);
+    }
+  }
+  // First element is always fixed because it cannot be predicted.
+  for (int i = 0; i < num_components; ++i) {
+    pred_vals[i] = static_cast<DataTypeT>(0);
+  }
+  this->transform().ComputeCorrection(in_data, pred_vals.get(), out_corr);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_MULTI_PARALLELOGRAM_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h
new file mode 100644
index 000000000..4d47ddf30
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h
@@ -0,0 +1,98 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+
+namespace draco {
+
+// Decoder for attribute values encoded with the standard parallelogram
+// prediction. See the description of the corresponding encoder for more
+// details.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeParallelogramDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeDecoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+  explicit MeshPredictionSchemeParallelogramDecoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute) {}
+  MeshPredictionSchemeParallelogramDecoder(const PointAttribute *attribute,
+                                           const TransformT &transform,
+                                           const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeParallelogramDecoder<DataTypeT, TransformT,
+                                              MeshDataT>::
+    ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                          int /* size */, int num_components,
+                          const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(num_components);
+
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+
+  // For storage of prediction values (already initialized to zero).
+  std::unique_ptr<DataTypeT[]> pred_vals(new DataTypeT[num_components]());
+
+  // Restore the first value.
+  this->transform().ComputeOriginalValue(pred_vals.get(), in_corr, out_data);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 1; p < corner_map_size; ++p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    const int dst_offset = p * num_components;
+    if (!ComputeParallelogramPrediction(p, corner_id, table,
+                                        *vertex_to_data_map, out_data,
+                                        num_components, pred_vals.get())) {
+      // Parallelogram could not be computed, Possible because some of the
+      // vertices are not valid (not encoded yet).
+      // We use the last encoded point as a reference (delta coding).
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeOriginalValue(
+          out_data + src_offset, in_corr + dst_offset, out_data + dst_offset);
+    } else {
+      // Apply the parallelogram prediction.
+      this->transform().ComputeOriginalValue(
+          pred_vals.get(), in_corr + dst_offset, out_data + dst_offset);
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h
new file mode 100644
index 000000000..f00801932
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h
@@ -0,0 +1,111 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h"
+
+namespace draco {
+
+// Parallelogram prediction predicts an attribute value V from three vertices
+// on the opposite face to the predicted vertex. The values on the three
+// vertices are used to construct a parallelogram V' = O - A - B, where O is the
+// value on the opposite vertex, and A, B are values on the shared vertices:
+//     V
+//    / \
+//   /   \
+//  /     \
+// A-------B
+//  \     /
+//   \   /
+//    \ /
+//     O
+//
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeParallelogramEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeEncoder<DataTypeT, TransformT>::CorrType;
+  using CornerTable = typename MeshDataT::CornerTable;
+  explicit MeshPredictionSchemeParallelogramEncoder(
+      const PointAttribute *attribute)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute) {}
+  MeshPredictionSchemeParallelogramEncoder(const PointAttribute *attribute,
+                                           const TransformT &transform,
+                                           const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_PARALLELOGRAM;
+  }
+
+  bool IsInitialized() const override {
+    return this->mesh_data().IsInitialized();
+  }
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeParallelogramEncoder<DataTypeT, TransformT,
+                                              MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex * /* entry_to_point_id_map */) {
+  this->transform().Init(in_data, size, num_components);
+  // For storage of prediction values (already initialized to zero).
+  std::unique_ptr<DataTypeT[]> pred_vals(new DataTypeT[num_components]());
+
+  // We start processing from the end because this prediction uses data from
+  // previous entries that could be overwritten when an entry is processed.
+  const CornerTable *const table = this->mesh_data().corner_table();
+  const std::vector<int32_t> *const vertex_to_data_map =
+      this->mesh_data().vertex_to_data_map();
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size() - 1);
+       p > 0; --p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    const int dst_offset = p * num_components;
+    if (!ComputeParallelogramPrediction(p, corner_id, table,
+                                        *vertex_to_data_map, in_data,
+                                        num_components, pred_vals.get())) {
+      // Parallelogram could not be computed, Possible because some of the
+      // vertices are not valid (not encoded yet).
+      // We use the last encoded point as a reference (delta coding).
+      const int src_offset = (p - 1) * num_components;
+      this->transform().ComputeCorrection(
+          in_data + dst_offset, in_data + src_offset, out_corr + dst_offset);
+    } else {
+      // Apply the parallelogram prediction.
+      this->transform().ComputeCorrection(in_data + dst_offset, pred_vals.get(),
+                                          out_corr + dst_offset);
+    }
+  }
+  // First element is always fixed because it cannot be predicted.
+  for (int i = 0; i < num_components; ++i) {
+    pred_vals[i] = static_cast<DataTypeT>(0);
+  }
+  this->transform().ComputeCorrection(in_data, pred_vals.get(), out_corr);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h
new file mode 100644
index 000000000..fd10fb524
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_shared.h
@@ -0,0 +1,78 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Shared functionality for different parallelogram prediction schemes.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_SHARED_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_SHARED_H_
+
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// TODO(draco-eng) consolidate Vertex/next/previous queries to one call
+// (performance).
+template <class CornerTableT>
+inline void GetParallelogramEntries(
+    const CornerIndex ci, const CornerTableT *table,
+    const std::vector<int32_t> &vertex_to_data_map, int *opp_entry,
+    int *next_entry, int *prev_entry) {
+  // One vertex of the input |table| correspond to exactly one attribute value
+  // entry. The |table| can be either CornerTable for per-vertex attributes,
+  // or MeshAttributeCornerTable for attributes with interior seams.
+  *opp_entry = vertex_to_data_map[table->Vertex(ci).value()];
+  *next_entry = vertex_to_data_map[table->Vertex(table->Next(ci)).value()];
+  *prev_entry = vertex_to_data_map[table->Vertex(table->Previous(ci)).value()];
+}
+
+// Computes parallelogram prediction for a given corner and data entry id.
+// The prediction is stored in |out_prediction|.
+// Function returns false when the prediction couldn't be computed, e.g. because
+// not all entry points were available.
+template <class CornerTableT, typename DataTypeT>
+inline bool ComputeParallelogramPrediction(
+    int data_entry_id, const CornerIndex ci, const CornerTableT *table,
+    const std::vector<int32_t> &vertex_to_data_map, const DataTypeT *in_data,
+    int num_components, DataTypeT *out_prediction) {
+  const CornerIndex oci = table->Opposite(ci);
+  if (oci == kInvalidCornerIndex) {
+    return false;
+  }
+  int vert_opp, vert_next, vert_prev;
+  GetParallelogramEntries<CornerTableT>(oci, table, vertex_to_data_map,
+                                        &vert_opp, &vert_next, &vert_prev);
+  if (vert_opp < data_entry_id && vert_next < data_entry_id &&
+      vert_prev < data_entry_id) {
+    // Apply the parallelogram prediction.
+    const int v_opp_off = vert_opp * num_components;
+    const int v_next_off = vert_next * num_components;
+    const int v_prev_off = vert_prev * num_components;
+    for (int c = 0; c < num_components; ++c) {
+      const int64_t in_data_next_off = in_data[v_next_off + c];
+      const int64_t in_data_prev_off = in_data[v_prev_off + c];
+      const int64_t in_data_opp_off = in_data[v_opp_off + c];
+      const int64_t result =
+          (in_data_next_off + in_data_prev_off) - in_data_opp_off;
+
+      out_prediction[c] = static_cast<DataTypeT>(result);
+    }
+    return true;
+  }
+  return false;  // Not all data is available for prediction
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_PARALLELOGRAM_SHARED_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h
new file mode 100644
index 000000000..02cf7e60f
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h
@@ -0,0 +1,344 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_DECODER_H_
+
+#include <math.h>
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/core/varint_decoding.h"
+#include "draco/core/vector_d.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Decoder for predictions of UV coordinates encoded by our specialized texture
+// coordinate predictor. See the corresponding encoder for more details. Note
+// that this predictor is not portable and should not be used anymore. See
+// MeshPredictionSchemeTexCoordsPortableEncoder/Decoder for a portable version
+// of this prediction scheme.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeTexCoordsDecoder(const PointAttribute *attribute,
+                                       const TransformT &transform,
+                                       const MeshDataT &mesh_data, int version)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        pos_attribute_(nullptr),
+        entry_to_point_id_map_(nullptr),
+        num_components_(0),
+        version_(version) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_TEX_COORDS_DEPRECATED;
+  }
+
+  bool IsInitialized() const override {
+    if (pos_attribute_ == nullptr) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att == nullptr) {
+      return false;
+    }
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    pos_attribute_ = att;
+    return true;
+  }
+
+ protected:
+  Vector3f GetPositionForEntryId(int entry_id) const {
+    const PointIndex point_id = entry_to_point_id_map_[entry_id];
+    Vector3f pos;
+    pos_attribute_->ConvertValue(pos_attribute_->mapped_index(point_id),
+                                 &pos[0]);
+    return pos;
+  }
+
+  Vector2f GetTexCoordForEntryId(int entry_id, const DataTypeT *data) const {
+    const int data_offset = entry_id * num_components_;
+    return Vector2f(static_cast<float>(data[data_offset]),
+                    static_cast<float>(data[data_offset + 1]));
+  }
+
+  void ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                             int data_id);
+
+ private:
+  const PointAttribute *pos_attribute_;
+  const PointIndex *entry_to_point_id_map_;
+  std::unique_ptr<DataTypeT[]> predicted_value_;
+  int num_components_;
+  // Encoded / decoded array of UV flips.
+  std::vector<bool> orientations_;
+  int version_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT, MeshDataT>::
+    ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                          int /* size */, int num_components,
+                          const PointIndex *entry_to_point_id_map) {
+  num_components_ = num_components;
+  entry_to_point_id_map_ = entry_to_point_id_map;
+  predicted_value_ =
+      std::unique_ptr<DataTypeT[]>(new DataTypeT[num_components]);
+  this->transform().Init(num_components);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 0; p < corner_map_size; ++p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    ComputePredictedValue(corner_id, out_data, p);
+
+    const int dst_offset = p * num_components;
+    this->transform().ComputeOriginalValue(
+        predicted_value_.get(), in_corr + dst_offset, out_data + dst_offset);
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT, MeshDataT>::
+    DecodePredictionData(DecoderBuffer *buffer) {
+  // Decode the delta coded orientations.
+  uint32_t num_orientations = 0;
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    if (!buffer->Decode(&num_orientations)) {
+      return false;
+    }
+  } else {
+    if (!DecodeVarint(&num_orientations, buffer)) {
+      return false;
+    }
+  }
+  if (num_orientations == 0) {
+    return false;
+  }
+  orientations_.resize(num_orientations);
+  bool last_orientation = true;
+  RAnsBitDecoder decoder;
+  if (!decoder.StartDecoding(buffer)) {
+    return false;
+  }
+  for (uint32_t i = 0; i < num_orientations; ++i) {
+    if (!decoder.DecodeNextBit()) {
+      last_orientation = !last_orientation;
+    }
+    orientations_[i] = last_orientation;
+  }
+  decoder.EndDecoding();
+  return MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                     MeshDataT>::DecodePredictionData(buffer);
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+void MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT, MeshDataT>::
+    ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                          int data_id) {
+  // Compute the predicted UV coordinate from the positions on all corners
+  // of the processed triangle. For the best prediction, the UV coordinates
+  // on the next/previous corners need to be already encoded/decoded.
+  const CornerIndex next_corner_id =
+      this->mesh_data().corner_table()->Next(corner_id);
+  const CornerIndex prev_corner_id =
+      this->mesh_data().corner_table()->Previous(corner_id);
+  // Get the encoded data ids from the next and previous corners.
+  // The data id is the encoding order of the UV coordinates.
+  int next_data_id, prev_data_id;
+
+  int next_vert_id, prev_vert_id;
+  next_vert_id =
+      this->mesh_data().corner_table()->Vertex(next_corner_id).value();
+  prev_vert_id =
+      this->mesh_data().corner_table()->Vertex(prev_corner_id).value();
+
+  next_data_id = this->mesh_data().vertex_to_data_map()->at(next_vert_id);
+  prev_data_id = this->mesh_data().vertex_to_data_map()->at(prev_vert_id);
+
+  if (prev_data_id < data_id && next_data_id < data_id) {
+    // Both other corners have available UV coordinates for prediction.
+    const Vector2f n_uv = GetTexCoordForEntryId(next_data_id, data);
+    const Vector2f p_uv = GetTexCoordForEntryId(prev_data_id, data);
+    if (p_uv == n_uv) {
+      // We cannot do a reliable prediction on degenerated UV triangles.
+      predicted_value_[0] = static_cast<int>(p_uv[0]);
+      predicted_value_[1] = static_cast<int>(p_uv[1]);
+      return;
+    }
+
+    // Get positions at all corners.
+    const Vector3f tip_pos = GetPositionForEntryId(data_id);
+    const Vector3f next_pos = GetPositionForEntryId(next_data_id);
+    const Vector3f prev_pos = GetPositionForEntryId(prev_data_id);
+    // Use the positions of the above triangle to predict the texture coordinate
+    // on the tip corner C.
+    // Convert the triangle into a new coordinate system defined by orthogonal
+    // bases vectors S, T, where S is vector prev_pos - next_pos and T is an
+    // perpendicular vector to S in the same plane as vector the
+    // tip_pos - next_pos.
+    // The transformed triangle in the new coordinate system is then going to
+    // be represented as:
+    //
+    //        1 ^
+    //          |
+    //          |
+    //          |   C
+    //          |  /  \
+    //          | /      \
+    //          |/          \
+    //          N--------------P
+    //          0              1
+    //
+    // Where next_pos point (N) is at position (0, 0), prev_pos point (P) is
+    // at (1, 0). Our goal is to compute the position of the tip_pos point (C)
+    // in this new coordinate space (s, t).
+    //
+    const Vector3f pn = prev_pos - next_pos;
+    const Vector3f cn = tip_pos - next_pos;
+    const float pn_norm2_squared = pn.SquaredNorm();
+    // Coordinate s of the tip corner C is simply the dot product of the
+    // normalized vectors |pn| and |cn| (normalized by the length of |pn|).
+    // Since both of these vectors are normalized, we don't need to perform the
+    // normalization explicitly and instead we can just use the squared norm
+    // of |pn| as a denominator of the resulting dot product of non normalized
+    // vectors.
+    float s, t;
+    // |pn_norm2_squared| can be exactly 0 when the next_pos and prev_pos are
+    // the same positions (e.g. because they were quantized to the same
+    // location).
+    if (version_ < DRACO_BITSTREAM_VERSION(1, 2) || pn_norm2_squared > 0) {
+      s = pn.Dot(cn) / pn_norm2_squared;
+      // To get the coordinate t, we can use formula:
+      //      t = |C-N - (P-N) * s| / |P-N|
+      // Do not use std::sqrt to avoid changes in the bitstream.
+      t = sqrt((cn - pn * s).SquaredNorm() / pn_norm2_squared);
+    } else {
+      s = 0;
+      t = 0;
+    }
+
+    // Now we need to transform the point (s, t) to the texture coordinate space
+    // UV. We know the UV coordinates on points N and P (N_UV and P_UV). Lets
+    // denote P_UV - N_UV = PN_UV. PN_UV is then 2 dimensional vector that can
+    // be used to define transformation from the normalized coordinate system
+    // to the texture coordinate system using a 3x3 affine matrix M:
+    //
+    //  M = | PN_UV[0]  -PN_UV[1]  N_UV[0] |
+    //      | PN_UV[1]   PN_UV[0]  N_UV[1] |
+    //      | 0          0         1       |
+    //
+    // The predicted point C_UV in the texture space is then equal to
+    // C_UV = M * (s, t, 1). Because the triangle in UV space may be flipped
+    // around the PN_UV axis, we also need to consider point C_UV' = M * (s, -t)
+    // as the prediction.
+    const Vector2f pn_uv = p_uv - n_uv;
+    const float pnus = pn_uv[0] * s + n_uv[0];
+    const float pnut = pn_uv[0] * t;
+    const float pnvs = pn_uv[1] * s + n_uv[1];
+    const float pnvt = pn_uv[1] * t;
+    Vector2f predicted_uv;
+
+    // When decoding the data, we already know which orientation to use.
+    const bool orientation = orientations_.back();
+    orientations_.pop_back();
+    if (orientation)
+      predicted_uv = Vector2f(pnus - pnvt, pnvs + pnut);
+    else
+      predicted_uv = Vector2f(pnus + pnvt, pnvs - pnut);
+
+    if (std::is_integral<DataTypeT>::value) {
+      // Round the predicted value for integer types.
+      if (std::isnan(predicted_uv[0])) {
+        predicted_value_[0] = INT_MIN;
+      } else {
+        predicted_value_[0] = static_cast<int>(floor(predicted_uv[0] + 0.5));
+      }
+      if (std::isnan(predicted_uv[1])) {
+        predicted_value_[1] = INT_MIN;
+      } else {
+        predicted_value_[1] = static_cast<int>(floor(predicted_uv[1] + 0.5));
+      }
+    } else {
+      predicted_value_[0] = static_cast<int>(predicted_uv[0]);
+      predicted_value_[1] = static_cast<int>(predicted_uv[1]);
+    }
+    return;
+  }
+  // Else we don't have available textures on both corners. For such case we
+  // can't use positions for predicting the uv value and we resort to delta
+  // coding.
+  int data_offset = 0;
+  if (prev_data_id < data_id) {
+    // Use the value on the previous corner as the prediction.
+    data_offset = prev_data_id * num_components_;
+  }
+  if (next_data_id < data_id) {
+    // Use the value on the next corner as the prediction.
+    data_offset = next_data_id * num_components_;
+  } else {
+    // None of the other corners have a valid value. Use the last encoded value
+    // as the prediction if possible.
+    if (data_id > 0) {
+      data_offset = (data_id - 1) * num_components_;
+    } else {
+      // We are encoding the first value. Predict 0.
+      for (int i = 0; i < num_components_; ++i) {
+        predicted_value_[i] = 0;
+      }
+      return;
+    }
+  }
+  for (int i = 0; i < num_components_; ++i) {
+    predicted_value_[i] = data[data_offset + i];
+  }
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_DECODER_H_
+#endif
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h
new file mode 100644
index 000000000..813b72ae3
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h
@@ -0,0 +1,318 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_ENCODER_H_
+
+#include <math.h>
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/core/varint_encoding.h"
+#include "draco/core/vector_d.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Prediction scheme designed for predicting texture coordinates from known
+// spatial position of vertices. For good parametrization, the ratios between
+// triangle edge lengths should be about the same in both the spatial and UV
+// coordinate spaces, which makes the positions a good predictor for the UV
+// coordinates.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeTexCoordsEncoder(const PointAttribute *attribute,
+                                       const TransformT &transform,
+                                       const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        pos_attribute_(nullptr),
+        entry_to_point_id_map_(nullptr),
+        num_components_(0) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_TEX_COORDS_DEPRECATED;
+  }
+
+  bool IsInitialized() const override {
+    if (pos_attribute_ == nullptr) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    pos_attribute_ = att;
+    return true;
+  }
+
+ protected:
+  Vector3f GetPositionForEntryId(int entry_id) const {
+    const PointIndex point_id = entry_to_point_id_map_[entry_id];
+    Vector3f pos;
+    pos_attribute_->ConvertValue(pos_attribute_->mapped_index(point_id),
+                                 &pos[0]);
+    return pos;
+  }
+
+  Vector2f GetTexCoordForEntryId(int entry_id, const DataTypeT *data) const {
+    const int data_offset = entry_id * num_components_;
+    return Vector2f(static_cast<float>(data[data_offset]),
+                    static_cast<float>(data[data_offset + 1]));
+  }
+
+  void ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                             int data_id);
+
+ private:
+  const PointAttribute *pos_attribute_;
+  const PointIndex *entry_to_point_id_map_;
+  std::unique_ptr<DataTypeT[]> predicted_value_;
+  int num_components_;
+  // Encoded / decoded array of UV flips.
+  std::vector<bool> orientations_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsEncoder<DataTypeT, TransformT, MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex *entry_to_point_id_map) {
+  num_components_ = num_components;
+  entry_to_point_id_map_ = entry_to_point_id_map;
+  predicted_value_ =
+      std::unique_ptr<DataTypeT[]>(new DataTypeT[num_components]);
+  this->transform().Init(in_data, size, num_components);
+  // We start processing from the end because this prediction uses data from
+  // previous entries that could be overwritten when an entry is processed.
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size()) - 1;
+       p >= 0; --p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    ComputePredictedValue(corner_id, in_data, p);
+
+    const int dst_offset = p * num_components;
+    this->transform().ComputeCorrection(
+        in_data + dst_offset, predicted_value_.get(), out_corr + dst_offset);
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsEncoder<DataTypeT, TransformT, MeshDataT>::
+    EncodePredictionData(EncoderBuffer *buffer) {
+  // Encode the delta-coded orientations using arithmetic coding.
+  const uint32_t num_orientations = static_cast<uint32_t>(orientations_.size());
+  EncodeVarint(num_orientations, buffer);
+  bool last_orientation = true;
+  RAnsBitEncoder encoder;
+  encoder.StartEncoding();
+  for (bool orientation : orientations_) {
+    encoder.EncodeBit(orientation == last_orientation);
+    last_orientation = orientation;
+  }
+  encoder.EndEncoding(buffer);
+  return MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                     MeshDataT>::EncodePredictionData(buffer);
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+void MeshPredictionSchemeTexCoordsEncoder<DataTypeT, TransformT, MeshDataT>::
+    ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                          int data_id) {
+  // Compute the predicted UV coordinate from the positions on all corners
+  // of the processed triangle. For the best prediction, the UV coordinates
+  // on the next/previous corners need to be already encoded/decoded.
+  const CornerIndex next_corner_id =
+      this->mesh_data().corner_table()->Next(corner_id);
+  const CornerIndex prev_corner_id =
+      this->mesh_data().corner_table()->Previous(corner_id);
+  // Get the encoded data ids from the next and previous corners.
+  // The data id is the encoding order of the UV coordinates.
+  int next_data_id, prev_data_id;
+
+  int next_vert_id, prev_vert_id;
+  next_vert_id =
+      this->mesh_data().corner_table()->Vertex(next_corner_id).value();
+  prev_vert_id =
+      this->mesh_data().corner_table()->Vertex(prev_corner_id).value();
+
+  next_data_id = this->mesh_data().vertex_to_data_map()->at(next_vert_id);
+  prev_data_id = this->mesh_data().vertex_to_data_map()->at(prev_vert_id);
+
+  if (prev_data_id < data_id && next_data_id < data_id) {
+    // Both other corners have available UV coordinates for prediction.
+    const Vector2f n_uv = GetTexCoordForEntryId(next_data_id, data);
+    const Vector2f p_uv = GetTexCoordForEntryId(prev_data_id, data);
+    if (p_uv == n_uv) {
+      // We cannot do a reliable prediction on degenerated UV triangles.
+      predicted_value_[0] = static_cast<int>(p_uv[0]);
+      predicted_value_[1] = static_cast<int>(p_uv[1]);
+      return;
+    }
+
+    // Get positions at all corners.
+    const Vector3f tip_pos = GetPositionForEntryId(data_id);
+    const Vector3f next_pos = GetPositionForEntryId(next_data_id);
+    const Vector3f prev_pos = GetPositionForEntryId(prev_data_id);
+    // Use the positions of the above triangle to predict the texture coordinate
+    // on the tip corner C.
+    // Convert the triangle into a new coordinate system defined by orthogonal
+    // bases vectors S, T, where S is vector prev_pos - next_pos and T is an
+    // perpendicular vector to S in the same plane as vector the
+    // tip_pos - next_pos.
+    // The transformed triangle in the new coordinate system is then going to
+    // be represented as:
+    //
+    //        1 ^
+    //          |
+    //          |
+    //          |   C
+    //          |  /  \
+    //          | /      \
+    //          |/          \
+    //          N--------------P
+    //          0              1
+    //
+    // Where next_pos point (N) is at position (0, 0), prev_pos point (P) is
+    // at (1, 0). Our goal is to compute the position of the tip_pos point (C)
+    // in this new coordinate space (s, t).
+    //
+    const Vector3f pn = prev_pos - next_pos;
+    const Vector3f cn = tip_pos - next_pos;
+    const float pn_norm2_squared = pn.SquaredNorm();
+    // Coordinate s of the tip corner C is simply the dot product of the
+    // normalized vectors |pn| and |cn| (normalized by the length of |pn|).
+    // Since both of these vectors are normalized, we don't need to perform the
+    // normalization explicitly and instead we can just use the squared norm
+    // of |pn| as a denominator of the resulting dot product of non normalized
+    // vectors.
+    float s, t;
+    // |pn_norm2_squared| can be exactly 0 when the next_pos and prev_pos are
+    // the same positions (e.g. because they were quantized to the same
+    // location).
+    if (pn_norm2_squared > 0) {
+      s = pn.Dot(cn) / pn_norm2_squared;
+      // To get the coordinate t, we can use formula:
+      //      t = |C-N - (P-N) * s| / |P-N|
+      // Do not use std::sqrt to avoid changes in the bitstream.
+      t = sqrt((cn - pn * s).SquaredNorm() / pn_norm2_squared);
+    } else {
+      s = 0;
+      t = 0;
+    }
+
+    // Now we need to transform the point (s, t) to the texture coordinate space
+    // UV. We know the UV coordinates on points N and P (N_UV and P_UV). Lets
+    // denote P_UV - N_UV = PN_UV. PN_UV is then 2 dimensional vector that can
+    // be used to define transformation from the normalized coordinate system
+    // to the texture coordinate system using a 3x3 affine matrix M:
+    //
+    //  M = | PN_UV[0]  -PN_UV[1]  N_UV[0] |
+    //      | PN_UV[1]   PN_UV[0]  N_UV[1] |
+    //      | 0          0         1       |
+    //
+    // The predicted point C_UV in the texture space is then equal to
+    // C_UV = M * (s, t, 1). Because the triangle in UV space may be flipped
+    // around the PN_UV axis, we also need to consider point C_UV' = M * (s, -t)
+    // as the prediction.
+    const Vector2f pn_uv = p_uv - n_uv;
+    const float pnus = pn_uv[0] * s + n_uv[0];
+    const float pnut = pn_uv[0] * t;
+    const float pnvs = pn_uv[1] * s + n_uv[1];
+    const float pnvt = pn_uv[1] * t;
+    Vector2f predicted_uv;
+
+    // When encoding compute both possible vectors and determine which one
+    // results in a better prediction.
+    const Vector2f predicted_uv_0(pnus - pnvt, pnvs + pnut);
+    const Vector2f predicted_uv_1(pnus + pnvt, pnvs - pnut);
+    const Vector2f c_uv = GetTexCoordForEntryId(data_id, data);
+    if ((c_uv - predicted_uv_0).SquaredNorm() <
+        (c_uv - predicted_uv_1).SquaredNorm()) {
+      predicted_uv = predicted_uv_0;
+      orientations_.push_back(true);
+    } else {
+      predicted_uv = predicted_uv_1;
+      orientations_.push_back(false);
+    }
+    if (std::is_integral<DataTypeT>::value) {
+      // Round the predicted value for integer types.
+      predicted_value_[0] = static_cast<int>(floor(predicted_uv[0] + 0.5));
+      predicted_value_[1] = static_cast<int>(floor(predicted_uv[1] + 0.5));
+    } else {
+      predicted_value_[0] = static_cast<int>(predicted_uv[0]);
+      predicted_value_[1] = static_cast<int>(predicted_uv[1]);
+    }
+    return;
+  }
+  // Else we don't have available textures on both corners. For such case we
+  // can't use positions for predicting the uv value and we resort to delta
+  // coding.
+  int data_offset = 0;
+  if (prev_data_id < data_id) {
+    // Use the value on the previous corner as the prediction.
+    data_offset = prev_data_id * num_components_;
+  }
+  if (next_data_id < data_id) {
+    // Use the value on the next corner as the prediction.
+    data_offset = next_data_id * num_components_;
+  } else {
+    // None of the other corners have a valid value. Use the last encoded value
+    // as the prediction if possible.
+    if (data_id > 0) {
+      data_offset = (data_id - 1) * num_components_;
+    } else {
+      // We are encoding the first value. Predict 0.
+      for (int i = 0; i < num_components_; ++i) {
+        predicted_value_[i] = 0;
+      }
+      return;
+    }
+  }
+  for (int i = 0; i < num_components_; ++i) {
+    predicted_value_[i] = data[data_offset + i];
+  }
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h
new file mode 100644
index 000000000..83d496639
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h
@@ -0,0 +1,143 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+
+namespace draco {
+
+// Decoder for predictions of UV coordinates encoded by our specialized and
+// portable texture coordinate predictor. See the corresponding encoder for more
+// details.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsPortableDecoder
+    : public MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeTexCoordsPortableDecoder(const PointAttribute *attribute,
+                                               const TransformT &transform,
+                                               const MeshDataT &mesh_data)
+      : MeshPredictionSchemeDecoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_TEX_COORDS_PORTABLE;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (!att || att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+
+ private:
+  MeshPredictionSchemeTexCoordsPortablePredictor<DataTypeT, MeshDataT>
+      predictor_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsPortableDecoder<
+    DataTypeT, TransformT,
+    MeshDataT>::ComputeOriginalValues(const CorrType *in_corr,
+                                      DataTypeT *out_data, int /* size */,
+                                      int num_components,
+                                      const PointIndex *entry_to_point_id_map) {
+  if (num_components != MeshPredictionSchemeTexCoordsPortablePredictor<
+                            DataTypeT, MeshDataT>::kNumComponents) {
+    return false;
+  }
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  this->transform().Init(num_components);
+
+  const int corner_map_size =
+      static_cast<int>(this->mesh_data().data_to_corner_map()->size());
+  for (int p = 0; p < corner_map_size; ++p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    if (!predictor_.template ComputePredictedValue<false>(corner_id, out_data,
+                                                          p)) {
+      return false;
+    }
+
+    const int dst_offset = p * num_components;
+    this->transform().ComputeOriginalValue(predictor_.predicted_value(),
+                                           in_corr + dst_offset,
+                                           out_data + dst_offset);
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsPortableDecoder<
+    DataTypeT, TransformT, MeshDataT>::DecodePredictionData(DecoderBuffer
+                                                                *buffer) {
+  // Decode the delta coded orientations.
+  int32_t num_orientations = 0;
+  if (!buffer->Decode(&num_orientations) || num_orientations < 0) {
+    return false;
+  }
+  predictor_.ResizeOrientations(num_orientations);
+  bool last_orientation = true;
+  RAnsBitDecoder decoder;
+  if (!decoder.StartDecoding(buffer)) {
+    return false;
+  }
+  for (int i = 0; i < num_orientations; ++i) {
+    if (!decoder.DecodeNextBit()) {
+      last_orientation = !last_orientation;
+    }
+    predictor_.set_orientation(i, last_orientation);
+  }
+  decoder.EndDecoding();
+  return MeshPredictionSchemeDecoder<DataTypeT, TransformT,
+                                     MeshDataT>::DecodePredictionData(buffer);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h
new file mode 100644
index 000000000..741ec66dc
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h
@@ -0,0 +1,133 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+
+namespace draco {
+
+// Prediction scheme designed for predicting texture coordinates from known
+// spatial position of vertices. For isometric parametrizations, the ratios
+// between triangle edge lengths should be about the same in both the spatial
+// and UV coordinate spaces, which makes the positions a good predictor for the
+// UV coordinates. Note that this may not be the optimal approach for other
+// parametrizations such as projective ones.
+template <typename DataTypeT, class TransformT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsPortableEncoder
+    : public MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT> {
+ public:
+  using CorrType = typename MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                                        MeshDataT>::CorrType;
+  MeshPredictionSchemeTexCoordsPortableEncoder(const PointAttribute *attribute,
+                                               const TransformT &transform,
+                                               const MeshDataT &mesh_data)
+      : MeshPredictionSchemeEncoder<DataTypeT, TransformT, MeshDataT>(
+            attribute, transform, mesh_data),
+        predictor_(mesh_data) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override;
+
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return MESH_PREDICTION_TEX_COORDS_PORTABLE;
+  }
+
+  bool IsInitialized() const override {
+    if (!predictor_.IsInitialized()) {
+      return false;
+    }
+    if (!this->mesh_data().IsInitialized()) {
+      return false;
+    }
+    return true;
+  }
+
+  int GetNumParentAttributes() const override { return 1; }
+
+  GeometryAttribute::Type GetParentAttributeType(int i) const override {
+    DRACO_DCHECK_EQ(i, 0);
+    (void)i;
+    return GeometryAttribute::POSITION;
+  }
+
+  bool SetParentAttribute(const PointAttribute *att) override {
+    if (att->attribute_type() != GeometryAttribute::POSITION) {
+      return false;  // Invalid attribute type.
+    }
+    if (att->num_components() != 3) {
+      return false;  // Currently works only for 3 component positions.
+    }
+    predictor_.SetPositionAttribute(*att);
+    return true;
+  }
+
+ private:
+  MeshPredictionSchemeTexCoordsPortablePredictor<DataTypeT, MeshDataT>
+      predictor_;
+};
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsPortableEncoder<DataTypeT, TransformT,
+                                                  MeshDataT>::
+    ComputeCorrectionValues(const DataTypeT *in_data, CorrType *out_corr,
+                            int size, int num_components,
+                            const PointIndex *entry_to_point_id_map) {
+  predictor_.SetEntryToPointIdMap(entry_to_point_id_map);
+  this->transform().Init(in_data, size, num_components);
+  // We start processing from the end because this prediction uses data from
+  // previous entries that could be overwritten when an entry is processed.
+  for (int p =
+           static_cast<int>(this->mesh_data().data_to_corner_map()->size() - 1);
+       p >= 0; --p) {
+    const CornerIndex corner_id = this->mesh_data().data_to_corner_map()->at(p);
+    predictor_.template ComputePredictedValue<true>(corner_id, in_data, p);
+
+    const int dst_offset = p * num_components;
+    this->transform().ComputeCorrection(in_data + dst_offset,
+                                        predictor_.predicted_value(),
+                                        out_corr + dst_offset);
+  }
+  return true;
+}
+
+template <typename DataTypeT, class TransformT, class MeshDataT>
+bool MeshPredictionSchemeTexCoordsPortableEncoder<
+    DataTypeT, TransformT, MeshDataT>::EncodePredictionData(EncoderBuffer
+                                                                *buffer) {
+  // Encode the delta-coded orientations using arithmetic coding.
+  const int32_t num_orientations = predictor_.num_orientations();
+  buffer->Encode(num_orientations);
+  bool last_orientation = true;
+  RAnsBitEncoder encoder;
+  encoder.StartEncoding();
+  for (int i = 0; i < num_orientations; ++i) {
+    const bool orientation = predictor_.orientation(i);
+    encoder.EncodeBit(orientation == last_orientation);
+    last_orientation = orientation;
+  }
+  encoder.EndEncoding(buffer);
+  return MeshPredictionSchemeEncoder<DataTypeT, TransformT,
+                                     MeshDataT>::EncodePredictionData(buffer);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h
new file mode 100644
index 000000000..f05e5ddd7
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_predictor.h
@@ -0,0 +1,263 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_PREDICTOR_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_PREDICTOR_H_
+
+#include <math.h>
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/math_utils.h"
+#include "draco/core/vector_d.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Predictor functionality used for portable UV prediction by both encoder and
+// decoder.
+template <typename DataTypeT, class MeshDataT>
+class MeshPredictionSchemeTexCoordsPortablePredictor {
+ public:
+  static constexpr int kNumComponents = 2;
+
+  explicit MeshPredictionSchemeTexCoordsPortablePredictor(const MeshDataT &md)
+      : pos_attribute_(nullptr),
+        entry_to_point_id_map_(nullptr),
+        mesh_data_(md) {}
+  void SetPositionAttribute(const PointAttribute &position_attribute) {
+    pos_attribute_ = &position_attribute;
+  }
+  void SetEntryToPointIdMap(const PointIndex *map) {
+    entry_to_point_id_map_ = map;
+  }
+  bool IsInitialized() const { return pos_attribute_ != nullptr; }
+
+  VectorD<int64_t, 3> GetPositionForEntryId(int entry_id) const {
+    const PointIndex point_id = entry_to_point_id_map_[entry_id];
+    VectorD<int64_t, 3> pos;
+    pos_attribute_->ConvertValue(pos_attribute_->mapped_index(point_id),
+                                 &pos[0]);
+    return pos;
+  }
+
+  VectorD<int64_t, 2> GetTexCoordForEntryId(int entry_id,
+                                            const DataTypeT *data) const {
+    const int data_offset = entry_id * kNumComponents;
+    return VectorD<int64_t, 2>(data[data_offset], data[data_offset + 1]);
+  }
+
+  // Computes predicted UV coordinates on a given corner. The coordinates are
+  // stored in |predicted_value_| member.
+  template <bool is_encoder_t>
+  bool ComputePredictedValue(CornerIndex corner_id, const DataTypeT *data,
+                             int data_id);
+
+  const DataTypeT *predicted_value() const { return predicted_value_; }
+  bool orientation(int i) const { return orientations_[i]; }
+  void set_orientation(int i, bool v) { orientations_[i] = v; }
+  size_t num_orientations() const { return orientations_.size(); }
+  void ResizeOrientations(int num_orientations) {
+    orientations_.resize(num_orientations);
+  }
+
+ private:
+  const PointAttribute *pos_attribute_;
+  const PointIndex *entry_to_point_id_map_;
+  DataTypeT predicted_value_[kNumComponents];
+  // Encoded / decoded array of UV flips.
+  // TODO(ostava): We should remove this and replace this with in-place encoding
+  // and decoding to avoid unnecessary copy.
+  std::vector<bool> orientations_;
+  MeshDataT mesh_data_;
+};
+
+template <typename DataTypeT, class MeshDataT>
+template <bool is_encoder_t>
+bool MeshPredictionSchemeTexCoordsPortablePredictor<
+    DataTypeT, MeshDataT>::ComputePredictedValue(CornerIndex corner_id,
+                                                 const DataTypeT *data,
+                                                 int data_id) {
+  // Compute the predicted UV coordinate from the positions on all corners
+  // of the processed triangle. For the best prediction, the UV coordinates
+  // on the next/previous corners need to be already encoded/decoded.
+  const CornerIndex next_corner_id = mesh_data_.corner_table()->Next(corner_id);
+  const CornerIndex prev_corner_id =
+      mesh_data_.corner_table()->Previous(corner_id);
+  // Get the encoded data ids from the next and previous corners.
+  // The data id is the encoding order of the UV coordinates.
+  int next_data_id, prev_data_id;
+
+  int next_vert_id, prev_vert_id;
+  next_vert_id = mesh_data_.corner_table()->Vertex(next_corner_id).value();
+  prev_vert_id = mesh_data_.corner_table()->Vertex(prev_corner_id).value();
+
+  next_data_id = mesh_data_.vertex_to_data_map()->at(next_vert_id);
+  prev_data_id = mesh_data_.vertex_to_data_map()->at(prev_vert_id);
+
+  if (prev_data_id < data_id && next_data_id < data_id) {
+    // Both other corners have available UV coordinates for prediction.
+    const VectorD<int64_t, 2> n_uv = GetTexCoordForEntryId(next_data_id, data);
+    const VectorD<int64_t, 2> p_uv = GetTexCoordForEntryId(prev_data_id, data);
+    if (p_uv == n_uv) {
+      // We cannot do a reliable prediction on degenerated UV triangles.
+      predicted_value_[0] = p_uv[0];
+      predicted_value_[1] = p_uv[1];
+      return true;
+    }
+
+    // Get positions at all corners.
+    const VectorD<int64_t, 3> tip_pos = GetPositionForEntryId(data_id);
+    const VectorD<int64_t, 3> next_pos = GetPositionForEntryId(next_data_id);
+    const VectorD<int64_t, 3> prev_pos = GetPositionForEntryId(prev_data_id);
+    // We use the positions of the above triangle to predict the texture
+    // coordinate on the tip corner C.
+    // To convert the triangle into the UV coordinate system we first compute
+    // position X on the vector |prev_pos - next_pos| that is the projection of
+    // point C onto vector |prev_pos - next_pos|:
+    //
+    //              C
+    //             /.  \
+    //            / .     \
+    //           /  .        \
+    //          N---X----------P
+    //
+    // Where next_pos is point (N), prev_pos is point (P) and tip_pos is the
+    // position of predicted coordinate (C).
+    //
+    const VectorD<int64_t, 3> pn = prev_pos - next_pos;
+    const uint64_t pn_norm2_squared = pn.SquaredNorm();
+    if (pn_norm2_squared != 0) {
+      // Compute the projection of C onto PN by computing dot product of CN with
+      // PN and normalizing it by length of PN. This gives us a factor |s| where
+      // |s = PN.Dot(CN) / PN.SquaredNorm2()|. This factor can be used to
+      // compute X in UV space |X_UV| as |X_UV = N_UV + s * PN_UV|.
+      const VectorD<int64_t, 3> cn = tip_pos - next_pos;
+      const int64_t cn_dot_pn = pn.Dot(cn);
+
+      const VectorD<int64_t, 2> pn_uv = p_uv - n_uv;
+      // Because we perform all computations with integers, we don't explicitly
+      // compute the normalized factor |s|, but rather we perform all operations
+      // over UV vectors in a non-normalized coordinate system scaled with a
+      // scaling factor |pn_norm2_squared|:
+      //
+      //      x_uv = X_UV * PN.Norm2Squared()
+      //
+      const VectorD<int64_t, 2> x_uv =
+          n_uv * pn_norm2_squared + (cn_dot_pn * pn_uv);
+
+      const int64_t pn_absmax_element =
+          std::max(std::max(std::abs(pn[0]), std::abs(pn[1])), std::abs(pn[2]));
+      if (cn_dot_pn > std::numeric_limits<int64_t>::max() / pn_absmax_element) {
+        // return false if squared length calculation would overflow.
+        return false;
+      }
+
+      // Compute squared length of vector CX in position coordinate system:
+      const VectorD<int64_t, 3> x_pos =
+          next_pos + (cn_dot_pn * pn) / pn_norm2_squared;
+      const uint64_t cx_norm2_squared = (tip_pos - x_pos).SquaredNorm();
+
+      // Compute vector CX_UV in the uv space by rotating vector PN_UV by 90
+      // degrees and scaling it with factor CX.Norm2() / PN.Norm2():
+      //
+      //     CX_UV = (CX.Norm2() / PN.Norm2()) * Rot(PN_UV)
+      //
+      // To preserve precision, we perform all operations in scaled space as
+      // explained above, so we want the final vector to be:
+      //
+      //     cx_uv = CX_UV * PN.Norm2Squared()
+      //
+      // We can then rewrite the formula as:
+      //
+      //     cx_uv = CX.Norm2() * PN.Norm2() * Rot(PN_UV)
+      //
+      VectorD<int64_t, 2> cx_uv(pn_uv[1], -pn_uv[0]);  // Rotated PN_UV.
+      // Compute CX.Norm2() * PN.Norm2()
+      const uint64_t norm_squared =
+          IntSqrt(cx_norm2_squared * pn_norm2_squared);
+      // Final cx_uv in the scaled coordinate space.
+      cx_uv = cx_uv * norm_squared;
+
+      // Predicted uv coordinate is then computed by either adding or
+      // subtracting CX_UV to/from X_UV.
+      VectorD<int64_t, 2> predicted_uv;
+      if (is_encoder_t) {
+        // When encoding, compute both possible vectors and determine which one
+        // results in a better prediction.
+        // Both vectors need to be transformed back from the scaled space to
+        // the real UV coordinate space.
+        const VectorD<int64_t, 2> predicted_uv_0((x_uv + cx_uv) /
+                                                 pn_norm2_squared);
+        const VectorD<int64_t, 2> predicted_uv_1((x_uv - cx_uv) /
+                                                 pn_norm2_squared);
+        const VectorD<int64_t, 2> c_uv = GetTexCoordForEntryId(data_id, data);
+        if ((c_uv - predicted_uv_0).SquaredNorm() <
+            (c_uv - predicted_uv_1).SquaredNorm()) {
+          predicted_uv = predicted_uv_0;
+          orientations_.push_back(true);
+        } else {
+          predicted_uv = predicted_uv_1;
+          orientations_.push_back(false);
+        }
+      } else {
+        // When decoding the data, we already know which orientation to use.
+        if (orientations_.empty()) {
+          return false;
+        }
+        const bool orientation = orientations_.back();
+        orientations_.pop_back();
+        if (orientation) {
+          predicted_uv = (x_uv + cx_uv) / pn_norm2_squared;
+        } else {
+          predicted_uv = (x_uv - cx_uv) / pn_norm2_squared;
+        }
+      }
+      predicted_value_[0] = static_cast<int>(predicted_uv[0]);
+      predicted_value_[1] = static_cast<int>(predicted_uv[1]);
+      return true;
+    }
+  }
+  // Else we don't have available textures on both corners or the position data
+  // is invalid. For such cases we can't use positions for predicting the uv
+  // value and we resort to delta coding.
+  int data_offset = 0;
+  if (prev_data_id < data_id) {
+    // Use the value on the previous corner as the prediction.
+    data_offset = prev_data_id * kNumComponents;
+  }
+  if (next_data_id < data_id) {
+    // Use the value on the next corner as the prediction.
+    data_offset = next_data_id * kNumComponents;
+  } else {
+    // None of the other corners have a valid value. Use the last encoded value
+    // as the prediction if possible.
+    if (data_id > 0) {
+      data_offset = (data_id - 1) * kNumComponents;
+    } else {
+      // We are encoding the first value. Predict 0.
+      for (int i = 0; i < kNumComponents; ++i) {
+        predicted_value_[i] = 0;
+      }
+      return true;
+    }
+  }
+  for (int i = 0; i < kNumComponents; ++i) {
+    predicted_value_[i] = data[data_offset + i];
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_MESH_PREDICTION_SCHEME_TEX_COORDS_PORTABLE_PREDICTOR_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h
new file mode 100644
index 000000000..064e1b44f
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h
@@ -0,0 +1,90 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_H_
+
+#include <type_traits>
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h"
+
+// Prediction schemes can be used during encoding and decoding of vertex
+// attributes to predict attribute values based on the previously
+// encoded/decoded data. The differences between the original and predicted
+// attribute values are used to compute correction values that can be usually
+// encoded with fewer bits compared to the original data.
+namespace draco {
+
+// Abstract base class for typed prediction schemes. It provides basic access
+// to the encoded attribute and to the supplied prediction transform.
+template <typename DataTypeT,
+          class TransformT =
+              PredictionSchemeDecodingTransform<DataTypeT, DataTypeT>>
+class PredictionSchemeDecoder : public PredictionSchemeTypedDecoderInterface<
+                                    DataTypeT, typename TransformT::CorrType> {
+ public:
+  typedef DataTypeT DataType;
+  typedef TransformT Transform;
+  // Correction type needs to be defined in the prediction transform class.
+  typedef typename Transform::CorrType CorrType;
+  explicit PredictionSchemeDecoder(const PointAttribute *attribute)
+      : PredictionSchemeDecoder(attribute, Transform()) {}
+  PredictionSchemeDecoder(const PointAttribute *attribute,
+                          const Transform &transform)
+      : attribute_(attribute), transform_(transform) {}
+
+  bool DecodePredictionData(DecoderBuffer *buffer) override {
+    if (!transform_.DecodeTransformData(buffer)) {
+      return false;
+    }
+    return true;
+  }
+
+  const PointAttribute *GetAttribute() const override { return attribute(); }
+
+  // Returns the number of parent attributes that are needed for the prediction.
+  int GetNumParentAttributes() const override { return 0; }
+
+  // Returns the type of each of the parent attribute.
+  GeometryAttribute::Type GetParentAttributeType(int /* i */) const override {
+    return GeometryAttribute::INVALID;
+  }
+
+  // Sets the required parent attribute.
+  bool SetParentAttribute(const PointAttribute * /* att */) override {
+    return false;
+  }
+
+  bool AreCorrectionsPositive() override {
+    return transform_.AreCorrectionsPositive();
+  }
+
+  PredictionSchemeTransformType GetTransformType() const override {
+    return transform_.GetType();
+  }
+
+ protected:
+  inline const PointAttribute *attribute() const { return attribute_; }
+  inline const Transform &transform() const { return transform_; }
+  inline Transform &transform() { return transform_; }
+
+ private:
+  const PointAttribute *attribute_;
+  Transform transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h
new file mode 100644
index 000000000..cf2a6ba6b
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h
@@ -0,0 +1,194 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Functions for creating prediction schemes for decoders using the provided
+// prediction method id.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_FACTORY_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_FACTORY_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_decoder.h"
+#include "draco/draco_features.h"
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_decoder.h"
+#endif
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h"
+#include "draco/compression/mesh/mesh_decoder.h"
+
+namespace draco {
+
+// Factory class for creating mesh prediction schemes. The factory implements
+// operator() that is used to create an appropriate mesh prediction scheme in
+// CreateMeshPredictionScheme() function in prediction_scheme_factory.h
+template <typename DataTypeT>
+struct MeshPredictionSchemeDecoderFactory {
+  // Operator () specialized for the wrap transform. Wrap transform can be used
+  // for all mesh prediction schemes. The specialization is done in compile time
+  // to prevent instantiations of unneeded combinations of prediction schemes +
+  // prediction transforms.
+  template <class TransformT, class MeshDataT,
+            PredictionSchemeTransformType Method>
+  struct DispatchFunctor {
+    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+        PredictionSchemeMethod method, const PointAttribute *attribute,
+        const TransformT &transform, const MeshDataT &mesh_data,
+        uint16_t bitstream_version) {
+      if (method == MESH_PREDICTION_PARALLELOGRAM) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeParallelogramDecoder<DataTypeT, TransformT,
+                                                         MeshDataT>(
+                attribute, transform, mesh_data));
+      }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      else if (method == MESH_PREDICTION_MULTI_PARALLELOGRAM) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeMultiParallelogramDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#endif
+      else if (method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeConstrainedMultiParallelogramDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      else if (method == MESH_PREDICTION_TEX_COORDS_DEPRECATED) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeTexCoordsDecoder<DataTypeT, TransformT,
+                                                     MeshDataT>(
+                attribute, transform, mesh_data, bitstream_version));
+      }
+#endif
+      else if (method == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeTexCoordsPortableDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+      else if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeGeometricNormalDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+#endif
+      return nullptr;
+    }
+  };
+
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+  // Operator () specialized for normal octahedron transforms. These transforms
+  // are currently used only by the geometric normal prediction scheme (the
+  // transform is also used by delta coding, but delta predictor is not
+  // constructed in this function).
+  template <class TransformT, class MeshDataT>
+  struct DispatchFunctor<TransformT, MeshDataT,
+                         PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED> {
+    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+        PredictionSchemeMethod method, const PointAttribute *attribute,
+        const TransformT &transform, const MeshDataT &mesh_data,
+        uint16_t bitstream_version) {
+      if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeGeometricNormalDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+      return nullptr;
+    }
+  };
+  template <class TransformT, class MeshDataT>
+  struct DispatchFunctor<TransformT, MeshDataT,
+                         PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON> {
+    std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+        PredictionSchemeMethod method, const PointAttribute *attribute,
+        const TransformT &transform, const MeshDataT &mesh_data,
+        uint16_t bitstream_version) {
+      if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+        return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+            new MeshPredictionSchemeGeometricNormalDecoder<
+                DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                  mesh_data));
+      }
+      return nullptr;
+    }
+  };
+#endif
+
+  template <class TransformT, class MeshDataT>
+  std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>> operator()(
+      PredictionSchemeMethod method, const PointAttribute *attribute,
+      const TransformT &transform, const MeshDataT &mesh_data,
+      uint16_t bitstream_version) {
+    return DispatchFunctor<TransformT, MeshDataT, TransformT::GetType()>()(
+        method, attribute, transform, mesh_data, bitstream_version);
+  }
+};
+
+// Creates a prediction scheme for a given decoder and given prediction method.
+// The prediction schemes are automatically initialized with decoder specific
+// data if needed.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForDecoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudDecoder *decoder,
+                                 const TransformT &transform) {
+  if (method == PREDICTION_NONE) {
+    return nullptr;
+  }
+  const PointAttribute *const att = decoder->point_cloud()->attribute(att_id);
+  if (decoder->GetGeometryType() == TRIANGULAR_MESH) {
+    // Cast the decoder to mesh decoder. This is not necessarily safe if there
+    // is some other decoder decides to use TRIANGULAR_MESH as the return type,
+    // but unfortunately there is not nice work around for this without using
+    // RTTI (double dispatch and similar concepts will not work because of the
+    // template nature of the prediction schemes).
+    const MeshDecoder *const mesh_decoder =
+        static_cast<const MeshDecoder *>(decoder);
+
+    auto ret = CreateMeshPredictionScheme<
+        MeshDecoder, PredictionSchemeDecoder<DataTypeT, TransformT>,
+        MeshPredictionSchemeDecoderFactory<DataTypeT>>(
+        mesh_decoder, method, att_id, transform, decoder->bitstream_version());
+    if (ret) {
+      return ret;
+    }
+    // Otherwise try to create another prediction scheme.
+  }
+  // Create delta decoder.
+  return std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>(
+      new PredictionSchemeDeltaDecoder<DataTypeT, TransformT>(att, transform));
+}
+
+// Create a prediction scheme using a default transform constructor.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeDecoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForDecoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudDecoder *decoder) {
+  return CreatePredictionSchemeForDecoder<DataTypeT, TransformT>(
+      method, att_id, decoder, TransformT());
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_FACTORY_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h
new file mode 100644
index 000000000..6f19f7fdb
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_interface.h
@@ -0,0 +1,53 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_INTERFACE_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+#include "draco/core/decoder_buffer.h"
+
+// Prediction schemes can be used during encoding and decoding of attributes
+// to predict attribute values based on the previously encoded/decoded data.
+// See prediction_scheme.h for more details.
+namespace draco {
+
+// Abstract interface for all prediction schemes used during attribute encoding.
+class PredictionSchemeDecoderInterface : public PredictionSchemeInterface {
+ public:
+  // Method that can be used to decode any prediction scheme specific data
+  // from the input buffer.
+  virtual bool DecodePredictionData(DecoderBuffer *buffer) = 0;
+};
+
+// A specialized version of the prediction scheme interface for specific
+// input and output data types.
+// |entry_to_point_id_map| is the mapping between value entries to point ids
+// of the associated point cloud, where one entry is defined as |num_components|
+// values of the |in_data|.
+// DataTypeT is the data type of input and predicted values.
+// CorrTypeT is the data type used for storing corrected values.
+template <typename DataTypeT, typename CorrTypeT = DataTypeT>
+class PredictionSchemeTypedDecoderInterface
+    : public PredictionSchemeDecoderInterface {
+ public:
+  // Reverts changes made by the prediction scheme during encoding.
+  virtual bool ComputeOriginalValues(
+      const CorrTypeT *in_corr, DataTypeT *out_data, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODER_INTERFACE_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h
new file mode 100644
index 000000000..47c1532ad
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_decoding_transform.h
@@ -0,0 +1,65 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODING_TRANSFORM_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// PredictionSchemeDecodingTransform is used to transform predicted values and
+// correction values into the final original attribute values.
+// DataTypeT is the data type of predicted values.
+// CorrTypeT is the data type used for storing corrected values. It allows
+// transforms to store corrections into a different type or format compared to
+// the predicted data.
+template <typename DataTypeT, typename CorrTypeT>
+class PredictionSchemeDecodingTransform {
+ public:
+  typedef CorrTypeT CorrType;
+  PredictionSchemeDecodingTransform() : num_components_(0) {}
+
+  void Init(int num_components) { num_components_ = num_components; }
+
+  // Computes the original value from the input predicted value and the decoded
+  // corrections. The default implementation is equal to std:plus.
+  inline void ComputeOriginalValue(const DataTypeT *predicted_vals,
+                                   const CorrTypeT *corr_vals,
+                                   DataTypeT *out_original_vals) const {
+    static_assert(std::is_same<DataTypeT, CorrTypeT>::value,
+                  "For the default prediction transform, correction and input "
+                  "data must be of the same type.");
+    for (int i = 0; i < num_components_; ++i) {
+      out_original_vals[i] = predicted_vals[i] + corr_vals[i];
+    }
+  }
+
+  // Decodes any transform specific data. Called before Init() method.
+  bool DecodeTransformData(DecoderBuffer * /* buffer */) { return true; }
+
+  // Should return true if all corrected values are guaranteed to be positive.
+  bool AreCorrectionsPositive() const { return false; }
+
+ protected:
+  int num_components() const { return num_components_; }
+
+ private:
+  int num_components_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DECODING_TRANSFORM_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h
new file mode 100644
index 000000000..ae72c7120
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_decoder.h
@@ -0,0 +1,65 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+
+namespace draco {
+
+// Decoder for values encoded with delta coding. See the corresponding encoder
+// for more details.
+template <typename DataTypeT, class TransformT>
+class PredictionSchemeDeltaDecoder
+    : public PredictionSchemeDecoder<DataTypeT, TransformT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeDecoder<DataTypeT, TransformT>::CorrType;
+  // Initialized the prediction scheme.
+  explicit PredictionSchemeDeltaDecoder(const PointAttribute *attribute)
+      : PredictionSchemeDecoder<DataTypeT, TransformT>(attribute) {}
+  PredictionSchemeDeltaDecoder(const PointAttribute *attribute,
+                               const TransformT &transform)
+      : PredictionSchemeDecoder<DataTypeT, TransformT>(attribute, transform) {}
+
+  bool ComputeOriginalValues(const CorrType *in_corr, DataTypeT *out_data,
+                             int size, int num_components,
+                             const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return PREDICTION_DIFFERENCE;
+  }
+  bool IsInitialized() const override { return true; }
+};
+
+template <typename DataTypeT, class TransformT>
+bool PredictionSchemeDeltaDecoder<DataTypeT, TransformT>::ComputeOriginalValues(
+    const CorrType *in_corr, DataTypeT *out_data, int size, int num_components,
+    const PointIndex *) {
+  this->transform().Init(num_components);
+  // Decode the original value for the first element.
+  std::unique_ptr<DataTypeT[]> zero_vals(new DataTypeT[num_components]());
+  this->transform().ComputeOriginalValue(zero_vals.get(), in_corr, out_data);
+
+  // Decode data from the front using D(i) = D(i) + D(i - 1).
+  for (int i = num_components; i < size; i += num_components) {
+    this->transform().ComputeOriginalValue(out_data + i - num_components,
+                                           in_corr + i, out_data + i);
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h
new file mode 100644
index 000000000..324afafa6
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h
@@ -0,0 +1,69 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+
+namespace draco {
+
+// Basic prediction scheme based on computing backward differences between
+// stored attribute values (also known as delta-coding). Usually works better
+// than the reference point prediction scheme, because nearby values are often
+// encoded next to each other.
+template <typename DataTypeT, class TransformT>
+class PredictionSchemeDeltaEncoder
+    : public PredictionSchemeEncoder<DataTypeT, TransformT> {
+ public:
+  using CorrType =
+      typename PredictionSchemeEncoder<DataTypeT, TransformT>::CorrType;
+  // Initialized the prediction scheme.
+  explicit PredictionSchemeDeltaEncoder(const PointAttribute *attribute)
+      : PredictionSchemeEncoder<DataTypeT, TransformT>(attribute) {}
+  PredictionSchemeDeltaEncoder(const PointAttribute *attribute,
+                               const TransformT &transform)
+      : PredictionSchemeEncoder<DataTypeT, TransformT>(attribute, transform) {}
+
+  bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrType *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) override;
+  PredictionSchemeMethod GetPredictionMethod() const override {
+    return PREDICTION_DIFFERENCE;
+  }
+  bool IsInitialized() const override { return true; }
+};
+
+template <typename DataTypeT, class TransformT>
+bool PredictionSchemeDeltaEncoder<
+    DataTypeT, TransformT>::ComputeCorrectionValues(const DataTypeT *in_data,
+                                                    CorrType *out_corr,
+                                                    int size,
+                                                    int num_components,
+                                                    const PointIndex *) {
+  this->transform().Init(in_data, size, num_components);
+  // Encode data from the back using D(i) = D(i) - D(i - 1).
+  for (int i = size - num_components; i > 0; i -= num_components) {
+    this->transform().ComputeCorrection(
+        in_data + i, in_data + i - num_components, out_corr + i);
+  }
+  // Encode correction for the first element.
+  std::unique_ptr<DataTypeT[]> zero_vals(new DataTypeT[num_components]());
+  this->transform().ComputeCorrection(in_data, zero_vals.get(), out_corr);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_DELTA_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h
new file mode 100644
index 000000000..2a211a9fc
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h
@@ -0,0 +1,90 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_H_
+
+#include <type_traits>
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h"
+
+// Prediction schemes can be used during encoding and decoding of vertex
+// attributes to predict attribute values based on the previously
+// encoded/decoded data. The differences between the original and predicted
+// attribute values are used to compute correction values that can be usually
+// encoded with fewer bits compared to the original data.
+namespace draco {
+
+// Abstract base class for typed prediction schemes. It provides basic access
+// to the encoded attribute and to the supplied prediction transform.
+template <typename DataTypeT,
+          class TransformT =
+              PredictionSchemeEncodingTransform<DataTypeT, DataTypeT>>
+class PredictionSchemeEncoder : public PredictionSchemeTypedEncoderInterface<
+                                    DataTypeT, typename TransformT::CorrType> {
+ public:
+  typedef DataTypeT DataType;
+  typedef TransformT Transform;
+  // Correction type needs to be defined in the prediction transform class.
+  typedef typename Transform::CorrType CorrType;
+  explicit PredictionSchemeEncoder(const PointAttribute *attribute)
+      : PredictionSchemeEncoder(attribute, Transform()) {}
+  PredictionSchemeEncoder(const PointAttribute *attribute,
+                          const Transform &transform)
+      : attribute_(attribute), transform_(transform) {}
+
+  bool EncodePredictionData(EncoderBuffer *buffer) override {
+    if (!transform_.EncodeTransformData(buffer)) {
+      return false;
+    }
+    return true;
+  }
+
+  const PointAttribute *GetAttribute() const override { return attribute(); }
+
+  // Returns the number of parent attributes that are needed for the prediction.
+  int GetNumParentAttributes() const override { return 0; }
+
+  // Returns the type of each of the parent attribute.
+  GeometryAttribute::Type GetParentAttributeType(int /* i */) const override {
+    return GeometryAttribute::INVALID;
+  }
+
+  // Sets the required parent attribute.
+  bool SetParentAttribute(const PointAttribute * /* att */) override {
+    return false;
+  }
+
+  bool AreCorrectionsPositive() override {
+    return transform_.AreCorrectionsPositive();
+  }
+
+  PredictionSchemeTransformType GetTransformType() const override {
+    return transform_.GetType();
+  }
+
+ protected:
+  inline const PointAttribute *attribute() const { return attribute_; }
+  inline const Transform &transform() const { return transform_; }
+  inline Transform &transform() { return transform_; }
+
+ private:
+  const PointAttribute *attribute_;
+  Transform transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.cc b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.cc
new file mode 100644
index 000000000..f410a6cd2
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.cc
@@ -0,0 +1,85 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h"
+
+namespace draco {
+
+PredictionSchemeMethod SelectPredictionMethod(
+    int att_id, const PointCloudEncoder *encoder) {
+  if (encoder->options()->GetSpeed() >= 10) {
+    // Selected fastest, though still doing some compression.
+    return PREDICTION_DIFFERENCE;
+  }
+  if (encoder->GetGeometryType() == TRIANGULAR_MESH) {
+    // Use speed setting to select the best encoding method.
+    const PointAttribute *const att = encoder->point_cloud()->attribute(att_id);
+    if (att->attribute_type() == GeometryAttribute::TEX_COORD) {
+      if (encoder->options()->GetSpeed() < 4) {
+        // Use texture coordinate prediction for speeds 0, 1, 2, 3.
+        return MESH_PREDICTION_TEX_COORDS_PORTABLE;
+      }
+    }
+    if (att->attribute_type() == GeometryAttribute::NORMAL) {
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+      if (encoder->options()->GetSpeed() < 4) {
+        // Use geometric normal prediction for speeds 0, 1, 2, 3.
+        // For this prediction, the position attribute needs to be either
+        // integer or quantized as well.
+        const int pos_att_id = encoder->point_cloud()->GetNamedAttributeId(
+            GeometryAttribute::POSITION);
+        const PointAttribute *const pos_att =
+            encoder->point_cloud()->GetNamedAttribute(
+                GeometryAttribute::POSITION);
+        if (pos_att && (IsDataTypeIntegral(pos_att->data_type()) ||
+                        encoder->options()->GetAttributeInt(
+                            pos_att_id, "quantization_bits", -1) > 0)) {
+          return MESH_PREDICTION_GEOMETRIC_NORMAL;
+        }
+      }
+#endif
+      return PREDICTION_DIFFERENCE;  // default
+    }
+    // Handle other attribute types.
+    if (encoder->options()->GetSpeed() >= 8) {
+      return PREDICTION_DIFFERENCE;
+    }
+    if (encoder->options()->GetSpeed() >= 2 ||
+        encoder->point_cloud()->num_points() < 40) {
+      // Parallelogram prediction is used for speeds 2 - 7 or when the overhead
+      // of using constrained multi-parallelogram would be too high.
+      return MESH_PREDICTION_PARALLELOGRAM;
+    }
+    // Multi-parallelogram is used for speeds 0, 1.
+    return MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM;
+  }
+  // Default option is delta coding.
+  return PREDICTION_DIFFERENCE;
+}
+
+// Returns the preferred prediction scheme based on the encoder options.
+PredictionSchemeMethod GetPredictionMethodFromOptions(
+    int att_id, const EncoderOptions &options) {
+  const int pred_type =
+      options.GetAttributeInt(att_id, "prediction_scheme", -1);
+  if (pred_type == -1) {
+    return PREDICTION_UNDEFINED;
+  }
+  if (pred_type < 0 || pred_type >= NUM_PREDICTION_SCHEMES) {
+    return PREDICTION_NONE;
+  }
+  return static_cast<PredictionSchemeMethod>(pred_type);
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h
new file mode 100644
index 000000000..40a7683aa
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h
@@ -0,0 +1,129 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Functions for creating prediction schemes for encoders using the provided
+// prediction method id.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_FACTORY_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_FACTORY_H_
+
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_constrained_multi_parallelogram_encoder.h"
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_geometric_normal_encoder.h"
+#endif
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_multi_parallelogram_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_parallelogram_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_tex_coords_portable_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_delta_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h"
+#include "draco/compression/mesh/mesh_encoder.h"
+
+namespace draco {
+
+// Selects a prediction method based on the input geometry type and based on the
+// encoder options.
+PredictionSchemeMethod SelectPredictionMethod(int att_id,
+                                              const PointCloudEncoder *encoder);
+
+// Factory class for creating mesh prediction schemes.
+template <typename DataTypeT>
+struct MeshPredictionSchemeEncoderFactory {
+  template <class TransformT, class MeshDataT>
+  std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>> operator()(
+      PredictionSchemeMethod method, const PointAttribute *attribute,
+      const TransformT &transform, const MeshDataT &mesh_data,
+      uint16_t bitstream_version) {
+    if (method == MESH_PREDICTION_PARALLELOGRAM) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeParallelogramEncoder<DataTypeT, TransformT,
+                                                       MeshDataT>(
+              attribute, transform, mesh_data));
+    } else if (method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeConstrainedMultiParallelogramEncoder<
+              DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                mesh_data));
+    } else if (method == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeTexCoordsPortableEncoder<
+              DataTypeT, TransformT, MeshDataT>(attribute, transform,
+                                                mesh_data));
+    }
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+    else if (method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+      return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+          new MeshPredictionSchemeGeometricNormalEncoder<DataTypeT, TransformT,
+                                                         MeshDataT>(
+              attribute, transform, mesh_data));
+    }
+#endif
+    return nullptr;
+  }
+};
+
+// Creates a prediction scheme for a given encoder and given prediction method.
+// The prediction schemes are automatically initialized with encoder specific
+// data if needed.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForEncoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudEncoder *encoder,
+                                 const TransformT &transform) {
+  const PointAttribute *const att = encoder->point_cloud()->attribute(att_id);
+  if (method == PREDICTION_UNDEFINED) {
+    method = SelectPredictionMethod(att_id, encoder);
+  }
+  if (method == PREDICTION_NONE) {
+    return nullptr;  // No prediction is used.
+  }
+  if (encoder->GetGeometryType() == TRIANGULAR_MESH) {
+    // Cast the encoder to mesh encoder. This is not necessarily safe if there
+    // is some other encoder decides to use TRIANGULAR_MESH as the return type,
+    // but unfortunately there is not nice work around for this without using
+    // RTTI (double dispatch and similar concepts will not work because of the
+    // template nature of the prediction schemes).
+    const MeshEncoder *const mesh_encoder =
+        static_cast<const MeshEncoder *>(encoder);
+    auto ret = CreateMeshPredictionScheme<
+        MeshEncoder, PredictionSchemeEncoder<DataTypeT, TransformT>,
+        MeshPredictionSchemeEncoderFactory<DataTypeT>>(
+        mesh_encoder, method, att_id, transform, kDracoMeshBitstreamVersion);
+    if (ret) {
+      return ret;
+    }
+    // Otherwise try to create another prediction scheme.
+  }
+  // Create delta encoder.
+  return std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>(
+      new PredictionSchemeDeltaEncoder<DataTypeT, TransformT>(att, transform));
+}
+
+// Create a prediction scheme using a default transform constructor.
+template <typename DataTypeT, class TransformT>
+std::unique_ptr<PredictionSchemeEncoder<DataTypeT, TransformT>>
+CreatePredictionSchemeForEncoder(PredictionSchemeMethod method, int att_id,
+                                 const PointCloudEncoder *encoder) {
+  return CreatePredictionSchemeForEncoder<DataTypeT, TransformT>(
+      method, att_id, encoder, TransformT());
+}
+
+// Returns the preferred prediction scheme based on the encoder options.
+PredictionSchemeMethod GetPredictionMethodFromOptions(
+    int att_id, const EncoderOptions &options);
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_FACTORY_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h
new file mode 100644
index 000000000..37aa9f76a
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_interface.h
@@ -0,0 +1,55 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_INTERFACE_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+#include "draco/core/encoder_buffer.h"
+
+// Prediction schemes can be used during encoding and decoding of attributes
+// to predict attribute values based on the previously encoded/decoded data.
+// See prediction_scheme.h for more details.
+namespace draco {
+
+// Abstract interface for all prediction schemes used during attribute encoding.
+class PredictionSchemeEncoderInterface : public PredictionSchemeInterface {
+ public:
+  // Method that can be used to encode any prediction scheme specific data
+  // into the output buffer.
+  virtual bool EncodePredictionData(EncoderBuffer *buffer) = 0;
+};
+
+// A specialized version of the prediction scheme interface for specific
+// input and output data types.
+// |entry_to_point_id_map| is the mapping between value entries to point ids
+// of the associated point cloud, where one entry is defined as |num_components|
+// values of the |in_data|.
+// DataTypeT is the data type of input and predicted values.
+// CorrTypeT is the data type used for storing corrected values.
+template <typename DataTypeT, typename CorrTypeT = DataTypeT>
+class PredictionSchemeTypedEncoderInterface
+    : public PredictionSchemeEncoderInterface {
+ public:
+  // Applies the prediction scheme when encoding the attribute.
+  // |in_data| contains value entries to be encoded.
+  // |out_corr| is an output array containing the to be encoded corrections.
+  virtual bool ComputeCorrectionValues(
+      const DataTypeT *in_data, CorrTypeT *out_corr, int size,
+      int num_components, const PointIndex *entry_to_point_id_map) = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODER_INTERFACE_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h
new file mode 100644
index 000000000..0929492aa
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_encoding_transform.h
@@ -0,0 +1,77 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODING_TRANSFORM_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// PredictionSchemeEncodingTransform is used to transform predicted values into
+// correction values.
+// CorrTypeT is the data type used for storing corrected values. It allows
+// transforms to store corrections into a different type or format compared to
+// the predicted data.
+template <typename DataTypeT, typename CorrTypeT>
+class PredictionSchemeEncodingTransform {
+ public:
+  typedef CorrTypeT CorrType;
+  PredictionSchemeEncodingTransform() : num_components_(0) {}
+
+  PredictionSchemeTransformType GetType() const {
+    return PREDICTION_TRANSFORM_DELTA;
+  }
+
+  // Performs any custom initialization of the transform for the encoder.
+  // |size| = total number of values in |orig_data| (i.e., number of entries *
+  // number of components).
+  void Init(const DataTypeT * /* orig_data */, int /* size */,
+            int num_components) {
+    num_components_ = num_components;
+  }
+
+  // Computes the corrections based on the input original values and the
+  // predicted values. The correction is always computed for all components
+  // of the input element. |val_id| is the id of the input value
+  // (i.e., element_id * num_components). The default implementation is equal to
+  // std::minus.
+  inline void ComputeCorrection(const DataTypeT *original_vals,
+                                const DataTypeT *predicted_vals,
+                                CorrTypeT *out_corr_vals) {
+    static_assert(std::is_same<DataTypeT, CorrTypeT>::value,
+                  "For the default prediction transform, correction and input "
+                  "data must be of the same type.");
+    for (int i = 0; i < num_components_; ++i) {
+      out_corr_vals[i] = original_vals[i] - predicted_vals[i];
+    }
+  }
+
+  // Encode any transform specific data.
+  bool EncodeTransformData(EncoderBuffer * /* buffer */) { return true; }
+
+  // Should return true if all corrected values are guaranteed to be positive.
+  bool AreCorrectionsPositive() const { return false; }
+
+ protected:
+  int num_components() const { return num_components_; }
+
+ private:
+  int num_components_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_ENCODING_TRANSFORM_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h
new file mode 100644
index 000000000..b36c4c8a2
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_factory.h
@@ -0,0 +1,85 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Functions for creating prediction schemes from a provided prediction method
+// name. The functions in this file can create only basic prediction schemes
+// that don't require any encoder or decoder specific data. To create more
+// sophisticated prediction schemes, use functions from either
+// prediction_scheme_encoder_factory.h  or,
+// prediction_scheme_decoder_factory.h.
+
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_FACTORY_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_FACTORY_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/attributes/prediction_schemes/mesh_prediction_scheme_data.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+template <class EncodingDataSourceT, class PredictionSchemeT,
+          class MeshPredictionSchemeFactoryT>
+std::unique_ptr<PredictionSchemeT> CreateMeshPredictionScheme(
+    const EncodingDataSourceT *source, PredictionSchemeMethod method,
+    int att_id, const typename PredictionSchemeT::Transform &transform,
+    uint16_t bitstream_version) {
+  const PointAttribute *const att = source->point_cloud()->attribute(att_id);
+  if (source->GetGeometryType() == TRIANGULAR_MESH &&
+      (method == MESH_PREDICTION_PARALLELOGRAM ||
+       method == MESH_PREDICTION_MULTI_PARALLELOGRAM ||
+       method == MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM ||
+       method == MESH_PREDICTION_TEX_COORDS_PORTABLE ||
+       method == MESH_PREDICTION_GEOMETRIC_NORMAL ||
+       method == MESH_PREDICTION_TEX_COORDS_DEPRECATED)) {
+    const CornerTable *const ct = source->GetCornerTable();
+    const MeshAttributeIndicesEncodingData *const encoding_data =
+        source->GetAttributeEncodingData(att_id);
+    if (ct == nullptr || encoding_data == nullptr) {
+      // No connectivity data found.
+      return nullptr;
+    }
+    // Connectivity data exists.
+    const MeshAttributeCornerTable *const att_ct =
+        source->GetAttributeCornerTable(att_id);
+    if (att_ct != nullptr) {
+      typedef MeshPredictionSchemeData<MeshAttributeCornerTable> MeshData;
+      MeshData md;
+      md.Set(source->mesh(), att_ct,
+             &encoding_data->encoded_attribute_value_index_to_corner_map,
+             &encoding_data->vertex_to_encoded_attribute_value_index_map);
+      MeshPredictionSchemeFactoryT factory;
+      auto ret = factory(method, att, transform, md, bitstream_version);
+      if (ret) {
+        return ret;
+      }
+    } else {
+      typedef MeshPredictionSchemeData<CornerTable> MeshData;
+      MeshData md;
+      md.Set(source->mesh(), ct,
+             &encoding_data->encoded_attribute_value_index_to_corner_map,
+             &encoding_data->vertex_to_encoded_attribute_value_index_map);
+      MeshPredictionSchemeFactoryT factory;
+      auto ret = factory(method, att, transform, md, bitstream_version);
+      if (ret) {
+        return ret;
+      }
+    }
+  }
+  return nullptr;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_FACTORY_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h
new file mode 100644
index 000000000..c9b370693
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h
@@ -0,0 +1,60 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_INTERFACE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_INTERFACE_H_
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+
+// Prediction schemes can be used during encoding and decoding of attributes
+// to predict attribute values based on the previously encoded/decoded data.
+// See prediction_scheme.h for more details.
+namespace draco {
+
+// Abstract interface for all prediction schemes used during attribute encoding.
+class PredictionSchemeInterface {
+ public:
+  virtual ~PredictionSchemeInterface() = default;
+  virtual PredictionSchemeMethod GetPredictionMethod() const = 0;
+
+  // Returns the encoded attribute.
+  virtual const PointAttribute *GetAttribute() const = 0;
+
+  // Returns true when the prediction scheme is initialized with all data it
+  // needs.
+  virtual bool IsInitialized() const = 0;
+
+  // Returns the number of parent attributes that are needed for the prediction.
+  virtual int GetNumParentAttributes() const = 0;
+
+  // Returns the type of each of the parent attribute.
+  virtual GeometryAttribute::Type GetParentAttributeType(int i) const = 0;
+
+  // Sets the required parent attribute.
+  // Returns false if the attribute doesn't meet the requirements of the
+  // prediction scheme.
+  virtual bool SetParentAttribute(const PointAttribute *att) = 0;
+
+  // Method should return true if the prediction scheme guarantees that all
+  // correction values are always positive (or at least non-negative).
+  virtual bool AreCorrectionsPositive() = 0;
+
+  // Returns the transform type used by the prediction scheme.
+  virtual PredictionSchemeTransformType GetTransformType() const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_INTERFACE_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h
new file mode 100644
index 000000000..5a6c7c2dd
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h
@@ -0,0 +1,118 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_DECODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_DECODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Class for converting correction values transformed by the canonicalized
+// normal octahedron transform back to the original values. See the
+// corresponding encoder for more details.
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform
+    : public PredictionSchemeNormalOctahedronCanonicalizedTransformBase<
+          DataTypeT> {
+ public:
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform() {}
+
+  // Dummy to fulfill concept.
+  void Init(int num_components) {}
+
+  bool DecodeTransformData(DecoderBuffer *buffer) {
+    DataTypeT max_quantized_value, center_value;
+    if (!buffer->Decode(&max_quantized_value)) {
+      return false;
+    }
+    if (!buffer->Decode(&center_value)) {
+      return false;
+    }
+    (void)center_value;
+    if (!this->set_max_quantized_value(max_quantized_value)) {
+      return false;
+    }
+    // Account for reading wrong values, e.g., due to fuzzing.
+    if (this->quantization_bits() < 2) {
+      return false;
+    }
+    if (this->quantization_bits() > 30) {
+      return false;
+    }
+    return true;
+  }
+
+  inline void ComputeOriginalValue(const DataType *pred_vals,
+                                   const CorrType *corr_vals,
+                                   DataType *out_orig_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(pred_vals[1], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[1], 2 * this->center_value());
+
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, corr_vals[0]);
+    DRACO_DCHECK_LE(0, corr_vals[1]);
+
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = Point2(corr_vals[0], corr_vals[1]);
+    const Point2 orig = ComputeOriginalValue(pred, corr);
+
+    out_orig_vals[0] = orig[0];
+    out_orig_vals[1] = orig[1];
+  }
+
+ private:
+  Point2 ComputeOriginalValue(Point2 pred, Point2 corr) const {
+    const Point2 t(this->center_value(), this->center_value());
+    pred = pred - t;
+    const bool pred_is_in_diamond = this->IsInDiamond(pred[0], pred[1]);
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+    const bool pred_is_in_bottom_left = this->IsInBottomLeft(pred);
+    const int32_t rotation_count = this->GetRotationCount(pred);
+    if (!pred_is_in_bottom_left) {
+      pred = this->RotatePoint(pred, rotation_count);
+    }
+    Point2 orig = pred + corr;
+    orig[0] = this->ModMax(orig[0]);
+    orig[1] = this->ModMax(orig[1]);
+    if (!pred_is_in_bottom_left) {
+      const int32_t reverse_rotation_count = (4 - rotation_count) % 4;
+      orig = this->RotatePoint(orig, reverse_rotation_count);
+    }
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+    }
+    orig = orig + t;
+    return orig;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_DECODING_TRANSFORM_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h
new file mode 100644
index 000000000..0dc96967b
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h
@@ -0,0 +1,116 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_ENCODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// The transform works on octahedral coordinates for normals. The square is
+// subdivided into four inner triangles (diamond) and four outer triangles. The
+// inner triangles are associated with the upper part of the octahedron and the
+// outer triangles are associated with the lower part.
+// Given a prediction value P and the actual value Q that should be encoded,
+// this transform first checks if P is outside the diamond. If so, the outer
+// triangles are flipped towards the inside and vice versa. Then it checks if p
+// is in the bottom left quadrant. If it is not, it rotates p and q accordingly.
+// The actual correction value is then based on the mapped and rotated P and Q
+// values. The inversion tends to result in shorter correction vectors and the
+// rotation makes it so that all long correction values are positive, reducing
+// the possible value range of the correction values and increasing the
+// occurrences of positive large correction values, which helps the entropy
+// encoder. This is possible since P is also known by the decoder, see also
+// ComputeCorrection and ComputeOriginalValue functions.
+// Note that the tile is not periodic, which implies that the outer edges can
+// not be identified, which requires us to use an odd number of values on each
+// axis.
+// DataTypeT is expected to be some integral type.
+//
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronCanonicalizedEncodingTransform
+    : public PredictionSchemeNormalOctahedronCanonicalizedTransformBase<
+          DataTypeT> {
+ public:
+  typedef PredictionSchemeNormalOctahedronCanonicalizedTransformBase<DataTypeT>
+      Base;
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  // We expect the mod value to be of the form 2^b-1.
+  explicit PredictionSchemeNormalOctahedronCanonicalizedEncodingTransform(
+      DataType max_quantized_value)
+      : Base(max_quantized_value) {}
+
+  // Dummy function to fulfill concept.
+  void Init(const DataTypeT *orig_data, int size, int num_components) {}
+
+  bool EncodeTransformData(EncoderBuffer *buffer) {
+    buffer->Encode(this->max_quantized_value());
+    buffer->Encode(this->center_value());
+    return true;
+  }
+
+  inline void ComputeCorrection(const DataType *orig_vals,
+                                const DataType *pred_vals,
+                                CorrType *out_corr_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(pred_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, orig_vals[0]);
+    DRACO_DCHECK_LE(0, orig_vals[1]);
+
+    const Point2 orig = Point2(orig_vals[0], orig_vals[1]);
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = ComputeCorrection(orig, pred);
+
+    out_corr_vals[0] = corr[0];
+    out_corr_vals[1] = corr[1];
+  }
+
+ private:
+  Point2 ComputeCorrection(Point2 orig, Point2 pred) const {
+    const Point2 t(this->center_value(), this->center_value());
+    orig = orig - t;
+    pred = pred - t;
+    if (!this->IsInDiamond(pred[0], pred[1])) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+    if (!this->IsInBottomLeft(pred)) {
+      const int32_t rotation_count = this->GetRotationCount(pred);
+      orig = this->RotatePoint(orig, rotation_count);
+      pred = this->RotatePoint(pred, rotation_count);
+    }
+    Point2 corr = orig - pred;
+    corr[0] = this->MakePositive(corr[0]);
+    corr[1] = this->MakePositive(corr[1]);
+    return corr;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_ENCODING_TRANSFORM_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h
new file mode 100644
index 000000000..4a1e3a67b
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_base.h
@@ -0,0 +1,102 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_TRANSFORM_BASE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_TRANSFORM_BASE_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Base class containing shared functionality used by both encoding and decoding
+// canonicalized normal octahedron prediction scheme transforms. See the
+// encoding transform for more details about the method.
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronCanonicalizedTransformBase
+    : public PredictionSchemeNormalOctahedronTransformBase<DataTypeT> {
+ public:
+  typedef PredictionSchemeNormalOctahedronTransformBase<DataTypeT> Base;
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT DataType;
+
+  PredictionSchemeNormalOctahedronCanonicalizedTransformBase() : Base() {}
+  // We expect the mod value to be of the form 2^b-1.
+  explicit PredictionSchemeNormalOctahedronCanonicalizedTransformBase(
+      DataType mod_value)
+      : Base(mod_value) {}
+
+  static constexpr PredictionSchemeTransformType GetType() {
+    return PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED;
+  }
+
+  int32_t GetRotationCount(Point2 pred) const {
+    const DataType sign_x = pred[0];
+    const DataType sign_y = pred[1];
+
+    int32_t rotation_count = 0;
+    if (sign_x == 0) {
+      if (sign_y == 0) {
+        rotation_count = 0;
+      } else if (sign_y > 0) {
+        rotation_count = 3;
+      } else {
+        rotation_count = 1;
+      }
+    } else if (sign_x > 0) {
+      if (sign_y >= 0) {
+        rotation_count = 2;
+      } else {
+        rotation_count = 1;
+      }
+    } else {
+      if (sign_y <= 0) {
+        rotation_count = 0;
+      } else {
+        rotation_count = 3;
+      }
+    }
+    return rotation_count;
+  }
+
+  Point2 RotatePoint(Point2 p, int32_t rotation_count) const {
+    switch (rotation_count) {
+      case 1:
+        return Point2(p[1], -p[0]);
+      case 2:
+        return Point2(-p[0], -p[1]);
+      case 3:
+        return Point2(-p[1], p[0]);
+      default:
+        return p;
+    }
+  }
+
+  bool IsInBottomLeft(const Point2 &p) const {
+    if (p[0] == 0 && p[1] == 0) {
+      return true;
+    }
+    return (p[0] < 0 && p[1] <= 0);
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_CANONICALIZED_TRANSFORM_BASE_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_test.cc b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_test.cc
new file mode 100644
index 000000000..8c8932f77
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_transform_test.cc
@@ -0,0 +1,192 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h"
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+class PredictionSchemeNormalOctahedronCanonicalizedTransformTest
+    : public ::testing::Test {
+ protected:
+  typedef draco::PredictionSchemeNormalOctahedronCanonicalizedEncodingTransform<
+      int32_t>
+      Transform;
+  typedef Transform::Point2 Point2;
+
+  void TestComputeCorrection(const Transform &transform, const int32_t &ox,
+                             const int32_t &oy, const int32_t &px,
+                             const int32_t &py, const int32_t &cx,
+                             const int32_t &cy) {
+    const int32_t o[2] = {ox + 7, oy + 7};
+    const int32_t p[2] = {px + 7, py + 7};
+    int32_t corr[2] = {500, 500};
+    transform.ComputeCorrection(o, p, corr);
+    ASSERT_EQ(corr[0], (cx + 15) % 15);
+    ASSERT_EQ(corr[1], (cy + 15) % 15);
+  }
+
+  void TestGetRotationCount(const Transform &transform, const Point2 &pred,
+                            const int32_t &rot_dir) {
+    const int32_t rotation_count = transform.GetRotationCount(pred);
+    ASSERT_EQ(rot_dir, rotation_count);
+  }
+
+  void TestRotateRepresentation(const Transform &transform, const Point2 &org,
+                                const Point2 &pred, const Point2 &rot_org,
+                                const Point2 &rot_pred) {
+    const int32_t rotation_count = transform.GetRotationCount(pred);
+    const Point2 res_org = transform.RotatePoint(org, rotation_count);
+    const Point2 res_pred = transform.RotatePoint(pred, rotation_count);
+    ASSERT_EQ(rot_org[0], res_org[0]);
+    ASSERT_EQ(rot_org[1], res_org[1]);
+    ASSERT_EQ(rot_pred[0], res_pred[0]);
+    ASSERT_EQ(rot_pred[1], res_pred[1]);
+  }
+};
+
+TEST_F(PredictionSchemeNormalOctahedronCanonicalizedTransformTest, Init) {
+  const Transform transform(15);
+  ASSERT_TRUE(transform.AreCorrectionsPositive());
+}
+
+TEST_F(PredictionSchemeNormalOctahedronCanonicalizedTransformTest,
+       IsInBottomLeft) {
+  const Transform transform(15);
+  ASSERT_TRUE(transform.IsInBottomLeft(Point2(0, 0)));
+  ASSERT_TRUE(transform.IsInBottomLeft(Point2(-1, -1)));
+  ASSERT_TRUE(transform.IsInBottomLeft(Point2(-7, -7)));
+
+  ASSERT_FALSE(transform.IsInBottomLeft(Point2(1, 1)));
+  ASSERT_FALSE(transform.IsInBottomLeft(Point2(7, 7)));
+  ASSERT_FALSE(transform.IsInBottomLeft(Point2(-1, 1)));
+  ASSERT_FALSE(transform.IsInBottomLeft(Point2(-7, 7)));
+  ASSERT_FALSE(transform.IsInBottomLeft(Point2(1, -1)));
+  ASSERT_FALSE(transform.IsInBottomLeft(Point2(7, -7)));
+}
+
+TEST_F(PredictionSchemeNormalOctahedronCanonicalizedTransformTest,
+       GetRotationCount) {
+  const Transform transform(15);
+  TestGetRotationCount(transform, Point2(1, 2), 2);    // top right
+  TestGetRotationCount(transform, Point2(-1, 2), 3);   // top left
+  TestGetRotationCount(transform, Point2(1, -2), 1);   // bottom right
+  TestGetRotationCount(transform, Point2(-1, -2), 0);  // bottom left
+  TestGetRotationCount(transform, Point2(0, 2), 3);    // top left
+  TestGetRotationCount(transform, Point2(0, -2), 1);   // bottom right
+  TestGetRotationCount(transform, Point2(2, 0), 2);    // top right
+  TestGetRotationCount(transform, Point2(-2, 0), 0);   // bottom left
+  TestGetRotationCount(transform, Point2(0, 0), 0);    // bottom left
+}
+
+TEST_F(PredictionSchemeNormalOctahedronCanonicalizedTransformTest,
+       RotateRepresentation) {
+  const Transform transform(15);
+  // p top left; shift clockwise by 3
+  TestRotateRepresentation(transform, Point2(1, 2), Point2(-3, 1),
+                           Point2(-2, 1), Point2(-1, -3));  // q top right
+  TestRotateRepresentation(transform, Point2(-1, -2), Point2(-3, 1),
+                           Point2(2, -1), Point2(-1, -3));  // q bottom left
+  TestRotateRepresentation(transform, Point2(1, -2), Point2(-3, 1),
+                           Point2(2, 1), Point2(-1, -3));  // q bottom right
+  TestRotateRepresentation(transform, Point2(-1, 2), Point2(-3, 1),
+                           Point2(-2, -1), Point2(-1, -3));  // q top left
+  // p top right; shift clockwise by 2 (flip)
+  TestRotateRepresentation(transform, Point2(1, 1), Point2(1, 3),
+                           Point2(-1, -1), Point2(-1, -3));  // q top right
+  TestRotateRepresentation(transform, Point2(-1, -2), Point2(1, 3),
+                           Point2(1, 2), Point2(-1, -3));  // q bottom left
+  TestRotateRepresentation(transform, Point2(-1, 2), Point2(1, 3),
+                           Point2(1, -2), Point2(-1, -3));  // q top left
+  TestRotateRepresentation(transform, Point2(1, -2), Point2(1, 3),
+                           Point2(-1, 2), Point2(-1, -3));  // q bottom right
+  // p bottom right; shift clockwise by 1
+  TestRotateRepresentation(transform, Point2(1, 2), Point2(3, -1),
+                           Point2(2, -1), Point2(-1, -3));  // q top right
+  TestRotateRepresentation(transform, Point2(1, -2), Point2(3, -1),
+                           Point2(-2, -1), Point2(-1, -3));  // q bottom right
+  TestRotateRepresentation(transform, Point2(-1, -2), Point2(3, -1),
+                           Point2(-2, 1), Point2(-1, -3));  // q bottom left
+  TestRotateRepresentation(transform, Point2(-1, 2), Point2(3, -1),
+                           Point2(2, 1), Point2(-1, -3));  // q top left
+  // p bottom left; no change
+  TestRotateRepresentation(transform, Point2(1, 2), Point2(-1, -3),
+                           Point2(1, 2), Point2(-1, -3));  // q top right
+  TestRotateRepresentation(transform, Point2(-1, 2), Point2(-1, -3),
+                           Point2(-1, 2), Point2(-1, -3));  // q top left
+  TestRotateRepresentation(transform, Point2(1, -2), Point2(-1, -3),
+                           Point2(1, -2), Point2(-1, -3));  // q bottom right
+  TestRotateRepresentation(transform, Point2(-1, -2), Point2(-1, -3),
+                           Point2(-1, -2), Point2(-1, -3));  // q bottom left
+}
+
+TEST_F(PredictionSchemeNormalOctahedronCanonicalizedTransformTest,
+       ComputeCorrection) {
+  const Transform transform(15);
+  TestComputeCorrection(transform, 0, 0, 0, 0, 0, 0);
+  TestComputeCorrection(transform, 1, 1, 1, 1, 0, 0);
+  // inside diamond; p top right
+  TestComputeCorrection(transform, 3, 4, 1, 2, -2, -2);  // q top right
+  TestComputeCorrection(transform, -3, 4, 1, 2, 4, -2);  // q top left
+  TestComputeCorrection(transform, 3, -4, 1, 2, -2, 6);  // q bottom right
+  TestComputeCorrection(transform, -3, -4, 1, 2, 4, 6);  // q bottom left
+  // inside diamond; p top left
+  TestComputeCorrection(transform, 3, 4, -1, 2, -2, 4);    // q top right
+  TestComputeCorrection(transform, -3, 4, -1, 2, -2, -2);  // q top left
+  TestComputeCorrection(transform, 3, -4, -1, 2, 6, 4);    // q bottom right
+  TestComputeCorrection(transform, -3, -4, -1, 2, 6, -2);  // q bottom left
+  // inside diamond; p bottom right
+  TestComputeCorrection(transform, 3, 4, 1, -2, 6, -2);    // q top right
+  TestComputeCorrection(transform, -3, 4, 1, -2, 6, 4);    // q top left
+  TestComputeCorrection(transform, 3, -4, 1, -2, -2, -2);  // q bottom right
+  TestComputeCorrection(transform, -3, -4, 1, -2, -2, 4);  // q bottom left
+  // inside diamond; p bottom left
+  TestComputeCorrection(transform, 3, 4, -1, -2, 4, 6);      // q top right
+  TestComputeCorrection(transform, -3, 4, -1, -2, -2, 6);    // q top left
+  TestComputeCorrection(transform, 3, -4, -1, -2, 4, -2);    // q bottom right
+  TestComputeCorrection(transform, -3, -4, -1, -2, -2, -2);  // q bottom left
+  // outside diamond; p top right
+  TestComputeCorrection(transform, 1, 2, 5, 4, -2, -4);    // q top right
+  TestComputeCorrection(transform, -1, 2, 5, 4, -7, -4);   // q top left
+  TestComputeCorrection(transform, 1, -2, 5, 4, -2, -7);   // q bottom right
+  TestComputeCorrection(transform, -1, -2, 5, 4, -7, -7);  // q bottom left
+  // outside diamond; p top left
+  TestComputeCorrection(transform, 1, 2, -5, 4, -4, -7);    // q top right
+  TestComputeCorrection(transform, -1, 2, -5, 4, -4, -2);   // q top left
+  TestComputeCorrection(transform, 1, -2, -5, 4, -7, -7);   // q bottom right
+  TestComputeCorrection(transform, -1, -2, -5, 4, -7, -2);  // q bottom left
+  // outside diamond; p bottom right
+  TestComputeCorrection(transform, 1, 2, 5, -4, -7, -2);    // q top right
+  TestComputeCorrection(transform, -1, 2, 5, -4, -7, -7);   // q top left
+  TestComputeCorrection(transform, 1, -2, 5, -4, -4, -2);   // q bottom right
+  TestComputeCorrection(transform, -1, -2, 5, -4, -4, -7);  // q bottom left
+  // outside diamond; p bottom left
+  TestComputeCorrection(transform, 1, 2, -5, -4, -7, -7);    // q top right
+  TestComputeCorrection(transform, -1, 2, -5, -4, -2, -7);   // q top left
+  TestComputeCorrection(transform, 1, -2, -5, -4, -7, -4);   // q bottom right
+  TestComputeCorrection(transform, -1, -2, -5, -4, -2, -4);  // q bottom left
+
+  TestComputeCorrection(transform, -1, -2, 7, 7, -5, -6);
+  TestComputeCorrection(transform, 0, 0, 7, 7, 7, 7);
+  TestComputeCorrection(transform, -1, -2, 0, -2, 0, 1);
+}
+
+TEST_F(PredictionSchemeNormalOctahedronCanonicalizedTransformTest, Interface) {
+  const Transform transform(15);
+  ASSERT_EQ(transform.max_quantized_value(), 15);
+  ASSERT_EQ(transform.center_value(), 7);
+  ASSERT_EQ(transform.quantization_bits(), 4);
+}
+
+}  // namespace
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h
new file mode 100644
index 000000000..a1bc4a327
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h
@@ -0,0 +1,103 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_DECODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_DECODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for converting correction values transformed by the octahedral normal
+// transform back to the original values. See the corresponding encoder for more
+// details.
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronDecodingTransform
+    : public PredictionSchemeNormalOctahedronTransformBase<DataTypeT> {
+ public:
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  PredictionSchemeNormalOctahedronDecodingTransform() {}
+
+  // Dummy function to fulfill concept.
+  void Init(int num_components) {}
+  bool DecodeTransformData(DecoderBuffer *buffer) {
+    DataTypeT max_quantized_value, center_value;
+    if (!buffer->Decode(&max_quantized_value)) {
+      return false;
+    }
+    if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      if (!buffer->Decode(&center_value)) {
+        return false;
+      }
+    }
+    (void)center_value;
+    return this->set_max_quantized_value(max_quantized_value);
+  }
+
+  inline void ComputeOriginalValue(const DataType *pred_vals,
+                                   const CorrType *corr_vals,
+                                   DataType *out_orig_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(pred_vals[1], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[0], 2 * this->center_value());
+    DRACO_DCHECK_LE(corr_vals[1], 2 * this->center_value());
+
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, corr_vals[0]);
+    DRACO_DCHECK_LE(0, corr_vals[1]);
+
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = Point2(corr_vals[0], corr_vals[1]);
+    const Point2 orig = ComputeOriginalValue(pred, corr);
+
+    out_orig_vals[0] = orig[0];
+    out_orig_vals[1] = orig[1];
+  }
+
+ private:
+  Point2 ComputeOriginalValue(Point2 pred, const Point2 &corr) const {
+    const Point2 t(this->center_value(), this->center_value());
+    pred = pred - t;
+
+    const bool pred_is_in_diamond = this->IsInDiamond(pred[0], pred[1]);
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+    Point2 orig = pred + corr;
+    orig[0] = this->ModMax(orig[0]);
+    orig[1] = this->ModMax(orig[1]);
+    if (!pred_is_in_diamond) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+    }
+    orig = orig + t;
+    return orig;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_DECODING_TRANSFORM_H_
+#endif
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h
new file mode 100644
index 000000000..4abfef669
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h
@@ -0,0 +1,105 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_ENCODING_TRANSFORM_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// The transform works on octahedral coordinates for normals. The square is
+// subdivided into four inner triangles (diamond) and four outer triangles. The
+// inner triangles are associated with the upper part of the octahedron and the
+// outer triangles are associated with the lower part.
+// Given a prediction value P and the actual value Q that should be encoded,
+// this transform first checks if P is outside the diamond. If so, the outer
+// triangles are flipped towards the inside and vice versa. The actual
+// correction value is then based on the mapped P and Q values. This tends to
+// result in shorter correction vectors.
+// This is possible since the P value is also known by the decoder, see also
+// ComputeCorrection and ComputeOriginalValue functions.
+// Note that the tile is not periodic, which implies that the outer edges can
+// not be identified, which requires us to use an odd number of values on each
+// axis.
+// DataTypeT is expected to be some integral type.
+//
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronEncodingTransform
+    : public PredictionSchemeNormalOctahedronTransformBase<DataTypeT> {
+ public:
+  typedef PredictionSchemeNormalOctahedronTransformBase<DataTypeT> Base;
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT CorrType;
+  typedef DataTypeT DataType;
+
+  // We expect the mod value to be of the form 2^b-1.
+  explicit PredictionSchemeNormalOctahedronEncodingTransform(
+      DataType max_quantized_value)
+      : Base(max_quantized_value) {}
+
+  void Init(const DataTypeT *orig_data, int size, int num_components) {}
+
+  bool EncodeTransformData(EncoderBuffer *buffer) {
+    buffer->Encode(this->max_quantized_value());
+    return true;
+  }
+
+  inline void ComputeCorrection(const DataType *orig_vals,
+                                const DataType *pred_vals,
+                                CorrType *out_corr_vals) const {
+    DRACO_DCHECK_LE(pred_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(pred_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[0], this->center_value() * 2);
+    DRACO_DCHECK_LE(orig_vals[1], this->center_value() * 2);
+    DRACO_DCHECK_LE(0, pred_vals[0]);
+    DRACO_DCHECK_LE(0, pred_vals[1]);
+    DRACO_DCHECK_LE(0, orig_vals[0]);
+    DRACO_DCHECK_LE(0, orig_vals[1]);
+
+    const Point2 orig = Point2(orig_vals[0], orig_vals[1]);
+    const Point2 pred = Point2(pred_vals[0], pred_vals[1]);
+    const Point2 corr = ComputeCorrection(orig, pred);
+
+    out_corr_vals[0] = corr[0];
+    out_corr_vals[1] = corr[1];
+  }
+
+ private:
+  Point2 ComputeCorrection(Point2 orig, Point2 pred) const {
+    const Point2 t(this->center_value(), this->center_value());
+    orig = orig - t;
+    pred = pred - t;
+
+    if (!this->IsInDiamond(pred[0], pred[1])) {
+      this->InvertDiamond(&orig[0], &orig[1]);
+      this->InvertDiamond(&pred[0], &pred[1]);
+    }
+
+    Point2 corr = orig - pred;
+    corr[0] = this->MakePositive(corr[0]);
+    corr[1] = this->MakePositive(corr[1]);
+    return corr;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_ENCODING_TRANSFORM_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h
new file mode 100644
index 000000000..c9dd7d67b
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_base.h
@@ -0,0 +1,90 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_TRANSFORM_BASE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_TRANSFORM_BASE_H_
+
+#include <cmath>
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/macros.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Base class containing shared functionality used by both encoding and decoding
+// octahedral normal prediction scheme transforms. See the encoding transform
+// for more details about the method.
+template <typename DataTypeT>
+class PredictionSchemeNormalOctahedronTransformBase {
+ public:
+  typedef VectorD<DataTypeT, 2> Point2;
+  typedef DataTypeT DataType;
+
+  PredictionSchemeNormalOctahedronTransformBase() {}
+  // We expect the mod value to be of the form 2^b-1.
+  explicit PredictionSchemeNormalOctahedronTransformBase(
+      DataType max_quantized_value) {
+    this->set_max_quantized_value(max_quantized_value);
+  }
+
+  static constexpr PredictionSchemeTransformType GetType() {
+    return PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON;
+  }
+
+  // We can return true as we keep correction values positive.
+  bool AreCorrectionsPositive() const { return true; }
+
+  inline DataTypeT max_quantized_value() const {
+    return octahedron_tool_box_.max_quantized_value();
+  }
+  inline DataTypeT center_value() const {
+    return octahedron_tool_box_.center_value();
+  }
+  inline int32_t quantization_bits() const {
+    return octahedron_tool_box_.quantization_bits();
+  }
+
+ protected:
+  inline bool set_max_quantized_value(DataTypeT max_quantized_value) {
+    if (max_quantized_value % 2 == 0) {
+      return false;
+    }
+    int q = MostSignificantBit(max_quantized_value) + 1;
+    return octahedron_tool_box_.SetQuantizationBits(q);
+  }
+
+  bool IsInDiamond(DataTypeT s, DataTypeT t) const {
+    return octahedron_tool_box_.IsInDiamond(s, t);
+  }
+  void InvertDiamond(DataTypeT *s, DataTypeT *t) const {
+    return octahedron_tool_box_.InvertDiamond(s, t);
+  }
+
+  int32_t ModMax(int32_t x) const { return octahedron_tool_box_.ModMax(x); }
+
+  // For correction values.
+  int32_t MakePositive(int32_t x) const {
+    return octahedron_tool_box_.MakePositive(x);
+  }
+
+ private:
+  OctahedronToolBox octahedron_tool_box_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_NORMAL_OCTAHEDRON_TRANSFORM_BASE_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_test.cc b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_test.cc
new file mode 100644
index 000000000..1001b19fa
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_transform_test.cc
@@ -0,0 +1,71 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_encoding_transform.h"
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+class PredictionSchemeNormalOctahedronTransformTest : public ::testing::Test {
+ protected:
+  typedef draco::PredictionSchemeNormalOctahedronEncodingTransform<int32_t>
+      Transform;
+  typedef Transform::Point2 Point2;
+
+  void TestComputeCorrection(const Transform &transform, const int32_t &ox,
+                             const int32_t &oy, const int32_t &px,
+                             const int32_t &py, const int32_t &cx,
+                             const int32_t &cy) {
+    const int32_t o[2] = {ox + 7, oy + 7};
+    const int32_t p[2] = {px + 7, py + 7};
+    int32_t corr[2] = {500, 500};
+    transform.ComputeCorrection(o, p, corr);
+    ASSERT_EQ(corr[0], (cx + 15) % 15);
+    ASSERT_EQ(corr[1], (cy + 15) % 15);
+  }
+};
+
+TEST_F(PredictionSchemeNormalOctahedronTransformTest, Init) {
+  const Transform transform(15);
+  ASSERT_TRUE(transform.AreCorrectionsPositive());
+}
+
+TEST_F(PredictionSchemeNormalOctahedronTransformTest, ComputeCorrections) {
+  const Transform transform(15);
+  // checks inside diamond
+  TestComputeCorrection(transform, 0, 0, 0, 0, 0, 0);
+  TestComputeCorrection(transform, 1, 1, 1, 1, 0, 0);
+  TestComputeCorrection(transform, 3, 4, 1, 1, 2, 3);
+  TestComputeCorrection(transform, -1, -1, -1, -1, 0, 0);
+  TestComputeCorrection(transform, -3, -4, -1, -1, -2, -3);
+  // checks outside diamond
+  TestComputeCorrection(transform, 4, 4, 4, 4, 0, 0);
+  TestComputeCorrection(transform, 5, 6, 4, 4, -2, -1);
+  TestComputeCorrection(transform, 3, 2, 4, 4, 2, 1);
+  // checks on outer edges
+  TestComputeCorrection(transform, 7, 7, 4, 4, -3, -3);
+  TestComputeCorrection(transform, 6, 7, 4, 4, -3, -2);
+  TestComputeCorrection(transform, -6, 7, 4, 4, -3, -2);
+  TestComputeCorrection(transform, 7, 6, 4, 4, -2, -3);
+  TestComputeCorrection(transform, 7, -6, 4, 4, -2, -3);
+}
+
+TEST_F(PredictionSchemeNormalOctahedronTransformTest, Interface) {
+  const Transform transform(15);
+  ASSERT_EQ(transform.max_quantized_value(), 15);
+  ASSERT_EQ(transform.center_value(), 7);
+  ASSERT_EQ(transform.quantization_bits(), 4);
+}
+
+}  // namespace
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h
new file mode 100644
index 000000000..e100c738a
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h
@@ -0,0 +1,88 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_DECODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_DECODING_TRANSFORM_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// PredictionSchemeWrapDecodingTransform unwraps values encoded with the
+// PredictionSchemeWrapEncodingTransform.
+// See prediction_scheme_wrap_transform_base.h for more details about the
+// method.
+template <typename DataTypeT, typename CorrTypeT = DataTypeT>
+class PredictionSchemeWrapDecodingTransform
+    : public PredictionSchemeWrapTransformBase<DataTypeT> {
+ public:
+  typedef CorrTypeT CorrType;
+  PredictionSchemeWrapDecodingTransform() {}
+
+  // Computes the original value from the input predicted value and the decoded
+  // corrections. Values out of the bounds of the input values are unwrapped.
+  inline void ComputeOriginalValue(const DataTypeT *predicted_vals,
+                                   const CorrTypeT *corr_vals,
+                                   DataTypeT *out_original_vals) const {
+    // For now we assume both |DataTypeT| and |CorrTypeT| are equal.
+    static_assert(std::is_same<DataTypeT, CorrTypeT>::value,
+                  "Predictions and corrections must have the same type.");
+
+    // The only valid implementation right now is for int32_t.
+    static_assert(std::is_same<DataTypeT, int32_t>::value,
+                  "Only int32_t is supported for predicted values.");
+
+    predicted_vals = this->ClampPredictedValue(predicted_vals);
+
+    // Perform the wrapping using unsigned coordinates to avoid potential signed
+    // integer overflows caused by malformed input.
+    const uint32_t *const uint_predicted_vals =
+        reinterpret_cast<const uint32_t *>(predicted_vals);
+    const uint32_t *const uint_corr_vals =
+        reinterpret_cast<const uint32_t *>(corr_vals);
+    for (int i = 0; i < this->num_components(); ++i) {
+      out_original_vals[i] =
+          static_cast<DataTypeT>(uint_predicted_vals[i] + uint_corr_vals[i]);
+      if (out_original_vals[i] > this->max_value()) {
+        out_original_vals[i] -= this->max_dif();
+      } else if (out_original_vals[i] < this->min_value()) {
+        out_original_vals[i] += this->max_dif();
+      }
+    }
+  }
+
+  bool DecodeTransformData(DecoderBuffer *buffer) {
+    DataTypeT min_value, max_value;
+    if (!buffer->Decode(&min_value)) {
+      return false;
+    }
+    if (!buffer->Decode(&max_value)) {
+      return false;
+    }
+    if (min_value > max_value) {
+      return false;
+    }
+    this->set_min_value(min_value);
+    this->set_max_value(max_value);
+    if (!this->InitCorrectionBounds()) {
+      return false;
+    }
+    return true;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_DECODING_TRANSFORM_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h
new file mode 100644
index 000000000..1f5e8b135
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h
@@ -0,0 +1,81 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_ENCODING_TRANSFORM_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_ENCODING_TRANSFORM_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// PredictionSchemeWrapEncodingTransform wraps input values using the wrapping
+// scheme described in: prediction_scheme_wrap_transform_base.h .
+template <typename DataTypeT, typename CorrTypeT = DataTypeT>
+class PredictionSchemeWrapEncodingTransform
+    : public PredictionSchemeWrapTransformBase<DataTypeT> {
+ public:
+  typedef CorrTypeT CorrType;
+  PredictionSchemeWrapEncodingTransform() {}
+
+  void Init(const DataTypeT *orig_data, int size, int num_components) {
+    PredictionSchemeWrapTransformBase<DataTypeT>::Init(num_components);
+    // Go over the original values and compute the bounds.
+    if (size == 0) {
+      return;
+    }
+    DataTypeT min_value = orig_data[0];
+    DataTypeT max_value = min_value;
+    for (int i = 1; i < size; ++i) {
+      if (orig_data[i] < min_value) {
+        min_value = orig_data[i];
+      } else if (orig_data[i] > max_value) {
+        max_value = orig_data[i];
+      }
+    }
+    this->set_min_value(min_value);
+    this->set_max_value(max_value);
+    this->InitCorrectionBounds();
+  }
+
+  // Computes the corrections based on the input original value and the
+  // predicted value. Out of bound correction values are wrapped around the max
+  // range of input values.
+  inline void ComputeCorrection(const DataTypeT *original_vals,
+                                const DataTypeT *predicted_vals,
+                                CorrTypeT *out_corr_vals) const {
+    for (int i = 0; i < this->num_components(); ++i) {
+      predicted_vals = this->ClampPredictedValue(predicted_vals);
+      out_corr_vals[i] = original_vals[i] - predicted_vals[i];
+      // Wrap around if needed.
+      DataTypeT &corr_val = out_corr_vals[i];
+      if (corr_val < this->min_correction()) {
+        corr_val += this->max_dif();
+      } else if (corr_val > this->max_correction()) {
+        corr_val -= this->max_dif();
+      }
+    }
+  }
+
+  bool EncodeTransformData(EncoderBuffer *buffer) {
+    // Store the input value range as it is needed by the decoder.
+    buffer->Encode(this->min_value());
+    buffer->Encode(this->max_value());
+    return true;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_ENCODING_TRANSFORM_H_
diff --git a/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h
new file mode 100644
index 000000000..26f61fbaf
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_transform_base.h
@@ -0,0 +1,120 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_TRANSFORM_BASE_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_TRANSFORM_BASE_H_
+
+#include <limits>
+#include <vector>
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// PredictionSchemeWrapTransform uses the min and max bounds of the original
+// data to wrap stored correction values around these bounds centered at 0,
+// i.e., when the range of the original values O is between <MIN, MAX> and
+// N = MAX-MIN, we can then store any correction X = O - P, as:
+//        X + N,   if X < -N / 2
+//        X - N,   if X > N / 2
+//        X        otherwise
+// To unwrap this value, the decoder then simply checks whether the final
+// corrected value F = P + X is out of the bounds of the input values.
+// All out of bounds values are unwrapped using
+//        F + N,   if F < MIN
+//        F - N,   if F > MAX
+// This wrapping can reduce the number of unique values, which translates to a
+// better entropy of the stored values and better compression rates.
+template <typename DataTypeT>
+class PredictionSchemeWrapTransformBase {
+ public:
+  PredictionSchemeWrapTransformBase()
+      : num_components_(0),
+        min_value_(0),
+        max_value_(0),
+        max_dif_(0),
+        max_correction_(0),
+        min_correction_(0) {}
+
+  static constexpr PredictionSchemeTransformType GetType() {
+    return PREDICTION_TRANSFORM_WRAP;
+  }
+
+  void Init(int num_components) {
+    num_components_ = num_components;
+    clamped_value_.resize(num_components);
+  }
+
+  bool AreCorrectionsPositive() const { return false; }
+
+  inline const DataTypeT *ClampPredictedValue(
+      const DataTypeT *predicted_val) const {
+    for (int i = 0; i < this->num_components(); ++i) {
+      if (predicted_val[i] > max_value_) {
+        clamped_value_[i] = max_value_;
+      } else if (predicted_val[i] < min_value_) {
+        clamped_value_[i] = min_value_;
+      } else {
+        clamped_value_[i] = predicted_val[i];
+      }
+    }
+    return &clamped_value_[0];
+  }
+
+  // TODO(hemmer): Consider refactoring to avoid this dummy.
+  int quantization_bits() const {
+    DRACO_DCHECK(false);
+    return -1;
+  }
+
+ protected:
+  bool InitCorrectionBounds() {
+    const int64_t dif =
+        static_cast<int64_t>(max_value_) - static_cast<int64_t>(min_value_);
+    if (dif < 0 || dif >= std::numeric_limits<DataTypeT>::max()) {
+      return false;
+    }
+    max_dif_ = 1 + static_cast<DataTypeT>(dif);
+    max_correction_ = max_dif_ / 2;
+    min_correction_ = -max_correction_;
+    if ((max_dif_ & 1) == 0) {
+      max_correction_ -= 1;
+    }
+    return true;
+  }
+
+  inline int num_components() const { return num_components_; }
+  inline DataTypeT min_value() const { return min_value_; }
+  inline void set_min_value(const DataTypeT &v) { min_value_ = v; }
+  inline DataTypeT max_value() const { return max_value_; }
+  inline void set_max_value(const DataTypeT &v) { max_value_ = v; }
+  inline DataTypeT max_dif() const { return max_dif_; }
+  inline DataTypeT min_correction() const { return min_correction_; }
+  inline DataTypeT max_correction() const { return max_correction_; }
+
+ private:
+  int num_components_;
+  DataTypeT min_value_;
+  DataTypeT max_value_;
+  DataTypeT max_dif_;
+  DataTypeT max_correction_;
+  DataTypeT min_correction_;
+  // This is in fact just a tmp variable to avoid reallocation.
+  mutable std::vector<DataTypeT> clamped_value_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_PREDICTION_SCHEMES_PREDICTION_SCHEME_WRAP_TRANSFORM_BASE_H_
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.cc b/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.cc
new file mode 100644
index 000000000..b4ba24f2d
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.cc
@@ -0,0 +1,118 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_attribute_decoder.h"
+
+namespace draco {
+
+SequentialAttributeDecoder::SequentialAttributeDecoder()
+    : decoder_(nullptr), attribute_(nullptr), attribute_id_(-1) {}
+
+bool SequentialAttributeDecoder::Init(PointCloudDecoder *decoder,
+                                      int attribute_id) {
+  decoder_ = decoder;
+  attribute_ = decoder->point_cloud()->attribute(attribute_id);
+  attribute_id_ = attribute_id;
+  return true;
+}
+
+bool SequentialAttributeDecoder::InitializeStandalone(
+    PointAttribute *attribute) {
+  attribute_ = attribute;
+  attribute_id_ = -1;
+  return true;
+}
+
+bool SequentialAttributeDecoder::DecodePortableAttribute(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  if (attribute_->num_components() <= 0 ||
+      !attribute_->Reset(point_ids.size())) {
+    return false;
+  }
+  if (!DecodeValues(point_ids, in_buffer)) {
+    return false;
+  }
+  return true;
+}
+
+bool SequentialAttributeDecoder::DecodeDataNeededByPortableTransform(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  // Default implementation does not apply any transform.
+  return true;
+}
+
+bool SequentialAttributeDecoder::TransformAttributeToOriginalFormat(
+    const std::vector<PointIndex> &point_ids) {
+  // Default implementation does not apply any transform.
+  return true;
+}
+
+const PointAttribute *SequentialAttributeDecoder::GetPortableAttribute() {
+  // If needed, copy point to attribute value index mapping from the final
+  // attribute to the portable attribute.
+  if (!attribute_->is_mapping_identity() && portable_attribute_ &&
+      portable_attribute_->is_mapping_identity()) {
+    portable_attribute_->SetExplicitMapping(attribute_->indices_map_size());
+    for (PointIndex i(0);
+         i < static_cast<uint32_t>(attribute_->indices_map_size()); ++i) {
+      portable_attribute_->SetPointMapEntry(i, attribute_->mapped_index(i));
+    }
+  }
+  return portable_attribute_.get();
+}
+
+bool SequentialAttributeDecoder::InitPredictionScheme(
+    PredictionSchemeInterface *ps) {
+  for (int i = 0; i < ps->GetNumParentAttributes(); ++i) {
+    const int att_id = decoder_->point_cloud()->GetNamedAttributeId(
+        ps->GetParentAttributeType(i));
+    if (att_id == -1) {
+      return false;  // Requested attribute does not exist.
+    }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+      if (!ps->SetParentAttribute(decoder_->point_cloud()->attribute(att_id))) {
+        return false;
+      }
+    } else
+#endif
+    {
+      const PointAttribute *const pa = decoder_->GetPortableAttribute(att_id);
+      if (pa == nullptr || !ps->SetParentAttribute(pa)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeDecoder::DecodeValues(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  const int32_t num_values = static_cast<uint32_t>(point_ids.size());
+  const int entry_size = static_cast<int>(attribute_->byte_stride());
+  std::unique_ptr<uint8_t[]> value_data_ptr(new uint8_t[entry_size]);
+  uint8_t *const value_data = value_data_ptr.get();
+  int out_byte_pos = 0;
+  // Decode raw attribute values in their original format.
+  for (int i = 0; i < num_values; ++i) {
+    if (!in_buffer->Decode(value_data, entry_size)) {
+      return false;
+    }
+    attribute_->buffer()->Write(out_byte_pos, value_data, entry_size);
+    out_byte_pos += entry_size;
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.h b/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.h
new file mode 100644
index 000000000..d48119465
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoder.h
@@ -0,0 +1,86 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// A base class for decoding attribute values encoded by the
+// SequentialAttributeEncoder.
+class SequentialAttributeDecoder {
+ public:
+  SequentialAttributeDecoder();
+  virtual ~SequentialAttributeDecoder() = default;
+
+  virtual bool Init(PointCloudDecoder *decoder, int attribute_id);
+
+  // Initialization for a specific attribute. This can be used mostly for
+  // standalone decoding of an attribute without an PointCloudDecoder.
+  virtual bool InitializeStandalone(PointAttribute *attribute);
+
+  // Performs lossless decoding of the portable attribute data.
+  virtual bool DecodePortableAttribute(const std::vector<PointIndex> &point_ids,
+                                       DecoderBuffer *in_buffer);
+
+  // Decodes any data needed to revert portable transform of the decoded
+  // attribute.
+  virtual bool DecodeDataNeededByPortableTransform(
+      const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer);
+
+  // Reverts transformation performed by encoder in
+  // SequentialAttributeEncoder::TransformAttributeToPortableFormat() method.
+  virtual bool TransformAttributeToOriginalFormat(
+      const std::vector<PointIndex> &point_ids);
+
+  const PointAttribute *GetPortableAttribute();
+
+  const PointAttribute *attribute() const { return attribute_; }
+  PointAttribute *attribute() { return attribute_; }
+  int attribute_id() const { return attribute_id_; }
+  PointCloudDecoder *decoder() const { return decoder_; }
+
+ protected:
+  // Should be used to initialize newly created prediction scheme.
+  // Returns false when the initialization failed (in which case the scheme
+  // cannot be used).
+  virtual bool InitPredictionScheme(PredictionSchemeInterface *ps);
+
+  // The actual implementation of the attribute decoding. Should be overridden
+  // for specialized decoders.
+  virtual bool DecodeValues(const std::vector<PointIndex> &point_ids,
+                            DecoderBuffer *in_buffer);
+
+  void SetPortableAttribute(std::unique_ptr<PointAttribute> att) {
+    portable_attribute_ = std::move(att);
+  }
+
+  PointAttribute *portable_attribute() { return portable_attribute_.get(); }
+
+ private:
+  PointCloudDecoder *decoder_;
+  PointAttribute *attribute_;
+  int attribute_id_;
+
+  // Storage for decoded portable attribute (after lossless decoding).
+  std::unique_ptr<PointAttribute> portable_attribute_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.cc b/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.cc
new file mode 100644
index 000000000..0e5e26bca
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.cc
@@ -0,0 +1,149 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_attribute_decoders_controller.h"
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+#include "draco/compression/attributes/sequential_normal_attribute_decoder.h"
+#endif
+#include "draco/compression/attributes/sequential_quantization_attribute_decoder.h"
+#include "draco/compression/config/compression_shared.h"
+
+namespace draco {
+
+SequentialAttributeDecodersController::SequentialAttributeDecodersController(
+    std::unique_ptr<PointsSequencer> sequencer)
+    : sequencer_(std::move(sequencer)) {}
+
+bool SequentialAttributeDecodersController::DecodeAttributesDecoderData(
+    DecoderBuffer *buffer) {
+  if (!AttributesDecoder::DecodeAttributesDecoderData(buffer)) {
+    return false;
+  }
+  // Decode unique ids of all sequential encoders and create them.
+  const int32_t num_attributes = GetNumAttributes();
+  sequential_decoders_.resize(num_attributes);
+  for (int i = 0; i < num_attributes; ++i) {
+    uint8_t decoder_type;
+    if (!buffer->Decode(&decoder_type)) {
+      return false;
+    }
+    // Create the decoder from the id.
+    sequential_decoders_[i] = CreateSequentialDecoder(decoder_type);
+    if (!sequential_decoders_[i]) {
+      return false;
+    }
+    if (!sequential_decoders_[i]->Init(GetDecoder(), GetAttributeId(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeDecodersController::DecodeAttributes(
+    DecoderBuffer *buffer) {
+  if (!sequencer_ || !sequencer_->GenerateSequence(&point_ids_)) {
+    return false;
+  }
+  // Initialize point to attribute value mapping for all decoded attributes.
+  const int32_t num_attributes = GetNumAttributes();
+  for (int i = 0; i < num_attributes; ++i) {
+    PointAttribute *const pa =
+        GetDecoder()->point_cloud()->attribute(GetAttributeId(i));
+    if (!sequencer_->UpdatePointToAttributeIndexMapping(pa)) {
+      return false;
+    }
+  }
+  return AttributesDecoder::DecodeAttributes(buffer);
+}
+
+bool SequentialAttributeDecodersController::DecodePortableAttributes(
+    DecoderBuffer *in_buffer) {
+  const int32_t num_attributes = GetNumAttributes();
+  for (int i = 0; i < num_attributes; ++i) {
+    if (!sequential_decoders_[i]->DecodePortableAttribute(point_ids_,
+                                                          in_buffer)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeDecodersController::
+    DecodeDataNeededByPortableTransforms(DecoderBuffer *in_buffer) {
+  const int32_t num_attributes = GetNumAttributes();
+  for (int i = 0; i < num_attributes; ++i) {
+    if (!sequential_decoders_[i]->DecodeDataNeededByPortableTransform(
+            point_ids_, in_buffer)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeDecodersController::
+    TransformAttributesToOriginalFormat() {
+  const int32_t num_attributes = GetNumAttributes();
+  for (int i = 0; i < num_attributes; ++i) {
+    // Check whether the attribute transform should be skipped.
+    if (GetDecoder()->options()) {
+      const PointAttribute *const attribute =
+          sequential_decoders_[i]->attribute();
+      const PointAttribute *const portable_attribute =
+          sequential_decoders_[i]->GetPortableAttribute();
+      if (portable_attribute &&
+          GetDecoder()->options()->GetAttributeBool(
+              attribute->attribute_type(), "skip_attribute_transform", false)) {
+        // Attribute transform should not be performed. In this case, we replace
+        // the output geometry attribute with the portable attribute.
+        // TODO(ostava): We can potentially avoid this copy by introducing a new
+        // mechanism that would allow to use the final attributes as portable
+        // attributes for predictors that may need them.
+        sequential_decoders_[i]->attribute()->CopyFrom(*portable_attribute);
+        continue;
+      }
+    }
+    if (!sequential_decoders_[i]->TransformAttributeToOriginalFormat(
+            point_ids_)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+std::unique_ptr<SequentialAttributeDecoder>
+SequentialAttributeDecodersController::CreateSequentialDecoder(
+    uint8_t decoder_type) {
+  switch (decoder_type) {
+    case SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC:
+      return std::unique_ptr<SequentialAttributeDecoder>(
+          new SequentialAttributeDecoder());
+    case SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER:
+      return std::unique_ptr<SequentialAttributeDecoder>(
+          new SequentialIntegerAttributeDecoder());
+    case SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION:
+      return std::unique_ptr<SequentialAttributeDecoder>(
+          new SequentialQuantizationAttributeDecoder());
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+    case SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS:
+      return std::unique_ptr<SequentialNormalAttributeDecoder>(
+          new SequentialNormalAttributeDecoder());
+#endif
+    default:
+      break;
+  }
+  // Unknown or unsupported decoder type.
+  return nullptr;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.h b/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.h
new file mode 100644
index 000000000..abc1f3685
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_attribute_decoders_controller.h
@@ -0,0 +1,61 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODERS_CONTROLLER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODERS_CONTROLLER_H_
+
+#include "draco/compression/attributes/attributes_decoder.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_decoder.h"
+
+namespace draco {
+
+// A basic implementation of an attribute decoder that decodes data encoded by
+// the SequentialAttributeEncodersController class. The
+// SequentialAttributeDecodersController creates a single
+// AttributeIndexedValuesDecoder for each of the decoded attribute, where the
+// type of the values decoder is determined by the unique identifier that was
+// encoded by the encoder.
+class SequentialAttributeDecodersController : public AttributesDecoder {
+ public:
+  explicit SequentialAttributeDecodersController(
+      std::unique_ptr<PointsSequencer> sequencer);
+
+  bool DecodeAttributesDecoderData(DecoderBuffer *buffer) override;
+  bool DecodeAttributes(DecoderBuffer *buffer) override;
+  const PointAttribute *GetPortableAttribute(
+      int32_t point_attribute_id) override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return nullptr;
+    }
+    return sequential_decoders_[loc_id]->GetPortableAttribute();
+  }
+
+ protected:
+  bool DecodePortableAttributes(DecoderBuffer *in_buffer) override;
+  bool DecodeDataNeededByPortableTransforms(DecoderBuffer *in_buffer) override;
+  bool TransformAttributesToOriginalFormat() override;
+  virtual std::unique_ptr<SequentialAttributeDecoder> CreateSequentialDecoder(
+      uint8_t decoder_type);
+
+ private:
+  std::vector<std::unique_ptr<SequentialAttributeDecoder>> sequential_decoders_;
+  std::vector<PointIndex> point_ids_;
+  std::unique_ptr<PointsSequencer> sequencer_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_DECODERS_CONTROLLER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.cc b/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.cc
new file mode 100644
index 000000000..6bde3eeb3
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.cc
@@ -0,0 +1,108 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_attribute_encoder.h"
+
+namespace draco {
+
+SequentialAttributeEncoder::SequentialAttributeEncoder()
+    : encoder_(nullptr),
+      attribute_(nullptr),
+      attribute_id_(-1),
+      is_parent_encoder_(false) {}
+
+bool SequentialAttributeEncoder::Init(PointCloudEncoder *encoder,
+                                      int attribute_id) {
+  encoder_ = encoder;
+  attribute_ = encoder_->point_cloud()->attribute(attribute_id);
+  attribute_id_ = attribute_id;
+  return true;
+}
+
+bool SequentialAttributeEncoder::InitializeStandalone(
+    PointAttribute *attribute) {
+  attribute_ = attribute;
+  attribute_id_ = -1;
+  return true;
+}
+
+bool SequentialAttributeEncoder::TransformAttributeToPortableFormat(
+    const std::vector<PointIndex> &point_ids) {
+  // Default implementation doesn't transform the input data.
+  return true;
+}
+
+bool SequentialAttributeEncoder::EncodePortableAttribute(
+    const std::vector<PointIndex> &point_ids, EncoderBuffer *out_buffer) {
+  // Lossless encoding of the input values.
+  if (!EncodeValues(point_ids, out_buffer)) {
+    return false;
+  }
+  return true;
+}
+
+bool SequentialAttributeEncoder::EncodeDataNeededByPortableTransform(
+    EncoderBuffer *out_buffer) {
+  // Default implementation doesn't transform the input data.
+  return true;
+}
+
+bool SequentialAttributeEncoder::EncodeValues(
+    const std::vector<PointIndex> &point_ids, EncoderBuffer *out_buffer) {
+  const int entry_size = static_cast<int>(attribute_->byte_stride());
+  const std::unique_ptr<uint8_t[]> value_data_ptr(new uint8_t[entry_size]);
+  uint8_t *const value_data = value_data_ptr.get();
+  // Encode all attribute values in their native raw format.
+  for (uint32_t i = 0; i < point_ids.size(); ++i) {
+    const AttributeValueIndex entry_id = attribute_->mapped_index(point_ids[i]);
+    attribute_->GetValue(entry_id, value_data);
+    out_buffer->Encode(value_data, entry_size);
+  }
+  return true;
+}
+
+void SequentialAttributeEncoder::MarkParentAttribute() {
+  is_parent_encoder_ = true;
+}
+
+bool SequentialAttributeEncoder::InitPredictionScheme(
+    PredictionSchemeInterface *ps) {
+  for (int i = 0; i < ps->GetNumParentAttributes(); ++i) {
+    const int att_id = encoder_->point_cloud()->GetNamedAttributeId(
+        ps->GetParentAttributeType(i));
+    if (att_id == -1) {
+      return false;  // Requested attribute does not exist.
+    }
+    parent_attributes_.push_back(att_id);
+    encoder_->MarkParentAttribute(att_id);
+  }
+  return true;
+}
+
+bool SequentialAttributeEncoder::SetPredictionSchemeParentAttributes(
+    PredictionSchemeInterface *ps) {
+  for (int i = 0; i < ps->GetNumParentAttributes(); ++i) {
+    const int att_id = encoder_->point_cloud()->GetNamedAttributeId(
+        ps->GetParentAttributeType(i));
+    if (att_id == -1) {
+      return false;  // Requested attribute does not exist.
+    }
+    if (!ps->SetParentAttribute(encoder_->GetPortableAttribute(att_id))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.h b/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.h
new file mode 100644
index 000000000..00f62db89
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoder.h
@@ -0,0 +1,134 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_interface.h"
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+namespace draco {
+
+// A base class for encoding attribute values of a single attribute using a
+// given sequence of point ids. The default implementation encodes all attribute
+// values directly to the buffer but derived classes can perform any custom
+// encoding (such as quantization) by overriding the EncodeValues() method.
+class SequentialAttributeEncoder {
+ public:
+  SequentialAttributeEncoder();
+  virtual ~SequentialAttributeEncoder() = default;
+
+  // Method that can be used for custom initialization of an attribute encoder,
+  // such as creation of prediction schemes and initialization of attribute
+  // encoder dependencies.
+  // |encoder| is the parent PointCloudEncoder,
+  // |attribute_id| is the id of the attribute that is being encoded by this
+  // encoder.
+  // This method is automatically called by the PointCloudEncoder after all
+  // attribute encoders are created and it should not be called explicitly from
+  // other places.
+  virtual bool Init(PointCloudEncoder *encoder, int attribute_id);
+
+  // Initialization for a specific attribute. This can be used mostly for
+  // standalone encoding of an attribute without an PointCloudEncoder.
+  virtual bool InitializeStandalone(PointAttribute *attribute);
+
+  // Transforms attribute data into format that is going to be encoded
+  // losslessly. The transform itself can be lossy.
+  virtual bool TransformAttributeToPortableFormat(
+      const std::vector<PointIndex> &point_ids);
+
+  // Performs lossless encoding of the transformed attribute data.
+  virtual bool EncodePortableAttribute(const std::vector<PointIndex> &point_ids,
+                                       EncoderBuffer *out_buffer);
+
+  // Encodes any data related to the portable attribute transform.
+  virtual bool EncodeDataNeededByPortableTransform(EncoderBuffer *out_buffer);
+
+  virtual bool IsLossyEncoder() const { return false; }
+
+  int NumParentAttributes() const {
+    return static_cast<int>(parent_attributes_.size());
+  }
+  int GetParentAttributeId(int i) const { return parent_attributes_[i]; }
+
+  const PointAttribute *GetPortableAttribute() const {
+    if (portable_attribute_ != nullptr) {
+      return portable_attribute_.get();
+    }
+    return attribute();
+  }
+
+  // Called when this attribute encoder becomes a parent encoder of another
+  // encoder.
+  void MarkParentAttribute();
+
+  virtual uint8_t GetUniqueId() const {
+    return SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC;
+  }
+
+  const PointAttribute *attribute() const { return attribute_; }
+  int attribute_id() const { return attribute_id_; }
+  PointCloudEncoder *encoder() const { return encoder_; }
+
+ protected:
+  // Should be used to initialize newly created prediction scheme.
+  // Returns false when the initialization failed (in which case the scheme
+  // cannot be used).
+  virtual bool InitPredictionScheme(PredictionSchemeInterface *ps);
+
+  // Sets parent attributes for a given prediction scheme. Must be called
+  // after all prediction schemes are initialized, but before the prediction
+  // scheme is used.
+  virtual bool SetPredictionSchemeParentAttributes(
+      PredictionSchemeInterface *ps);
+
+  // Encodes all attribute values in the specified order. Should be overridden
+  // for specialized  encoders.
+  virtual bool EncodeValues(const std::vector<PointIndex> &point_ids,
+                            EncoderBuffer *out_buffer);
+
+  bool is_parent_encoder() const { return is_parent_encoder_; }
+
+  void SetPortableAttribute(std::unique_ptr<PointAttribute> att) {
+    portable_attribute_ = std::move(att);
+  }
+
+  // Returns a mutable attribute that should be filled by derived encoders with
+  // the transformed version of the attribute data. To get a public const
+  // version, use the GetPortableAttribute() method.
+  PointAttribute *portable_attribute() { return portable_attribute_.get(); }
+
+ private:
+  PointCloudEncoder *encoder_;
+  const PointAttribute *attribute_;
+  int attribute_id_;
+
+  // List of attribute encoders that need to be encoded before this attribute.
+  // E.g. The parent attributes may be used to predict values used by this
+  // attribute encoder.
+  std::vector<int32_t> parent_attributes_;
+
+  bool is_parent_encoder_;
+
+  // Attribute that stores transformed data from the source attribute after it
+  // is processed through the ApplyTransform() method. Attribute data stored
+  // within this attribute is guaranteed to be encoded losslessly and it can be
+  // safely used for prediction of other attributes.
+  std::unique_ptr<PointAttribute> portable_attribute_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.cc b/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.cc
new file mode 100644
index 000000000..7d5d1eeff
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.cc
@@ -0,0 +1,159 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_attribute_encoders_controller.h"
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+#include "draco/compression/attributes/sequential_normal_attribute_encoder.h"
+#endif
+#include "draco/compression/attributes/sequential_quantization_attribute_encoder.h"
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+namespace draco {
+
+SequentialAttributeEncodersController::SequentialAttributeEncodersController(
+    std::unique_ptr<PointsSequencer> sequencer)
+    : sequencer_(std::move(sequencer)) {}
+
+SequentialAttributeEncodersController::SequentialAttributeEncodersController(
+    std::unique_ptr<PointsSequencer> sequencer, int point_attrib_id)
+    : AttributesEncoder(point_attrib_id), sequencer_(std::move(sequencer)) {}
+
+bool SequentialAttributeEncodersController::Init(PointCloudEncoder *encoder,
+                                                 const PointCloud *pc) {
+  if (!AttributesEncoder::Init(encoder, pc)) {
+    return false;
+  }
+  if (!CreateSequentialEncoders()) {
+    return false;
+  }
+  // Initialize all value encoders.
+  for (uint32_t i = 0; i < num_attributes(); ++i) {
+    const int32_t att_id = GetAttributeId(i);
+    if (!sequential_encoders_[i]->Init(encoder, att_id)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeEncodersController::EncodeAttributesEncoderData(
+    EncoderBuffer *out_buffer) {
+  if (!AttributesEncoder::EncodeAttributesEncoderData(out_buffer)) {
+    return false;
+  }
+  // Encode a unique id of every sequential encoder.
+  for (uint32_t i = 0; i < sequential_encoders_.size(); ++i) {
+    out_buffer->Encode(sequential_encoders_[i]->GetUniqueId());
+  }
+  return true;
+}
+
+bool SequentialAttributeEncodersController::EncodeAttributes(
+    EncoderBuffer *buffer) {
+  if (!sequencer_ || !sequencer_->GenerateSequence(&point_ids_)) {
+    return false;
+  }
+  return AttributesEncoder::EncodeAttributes(buffer);
+}
+
+bool SequentialAttributeEncodersController::
+    TransformAttributesToPortableFormat() {
+  for (uint32_t i = 0; i < sequential_encoders_.size(); ++i) {
+    if (!sequential_encoders_[i]->TransformAttributeToPortableFormat(
+            point_ids_)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeEncodersController::EncodePortableAttributes(
+    EncoderBuffer *out_buffer) {
+  for (uint32_t i = 0; i < sequential_encoders_.size(); ++i) {
+    if (!sequential_encoders_[i]->EncodePortableAttribute(point_ids_,
+                                                          out_buffer)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeEncodersController::
+    EncodeDataNeededByPortableTransforms(EncoderBuffer *out_buffer) {
+  for (uint32_t i = 0; i < sequential_encoders_.size(); ++i) {
+    if (!sequential_encoders_[i]->EncodeDataNeededByPortableTransform(
+            out_buffer)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialAttributeEncodersController::CreateSequentialEncoders() {
+  sequential_encoders_.resize(num_attributes());
+  for (uint32_t i = 0; i < num_attributes(); ++i) {
+    sequential_encoders_[i] = CreateSequentialEncoder(i);
+    if (sequential_encoders_[i] == nullptr) {
+      return false;
+    }
+    if (i < sequential_encoder_marked_as_parent_.size()) {
+      if (sequential_encoder_marked_as_parent_[i]) {
+        sequential_encoders_[i]->MarkParentAttribute();
+      }
+    }
+  }
+  return true;
+}
+
+std::unique_ptr<SequentialAttributeEncoder>
+SequentialAttributeEncodersController::CreateSequentialEncoder(int i) {
+  const int32_t att_id = GetAttributeId(i);
+  const PointAttribute *const att = encoder()->point_cloud()->attribute(att_id);
+
+  switch (att->data_type()) {
+    case DT_UINT8:
+    case DT_INT8:
+    case DT_UINT16:
+    case DT_INT16:
+    case DT_UINT32:
+    case DT_INT32:
+      return std::unique_ptr<SequentialAttributeEncoder>(
+          new SequentialIntegerAttributeEncoder());
+    case DT_FLOAT32:
+      if (encoder()->options()->GetAttributeInt(att_id, "quantization_bits",
+                                                -1) > 0) {
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+        if (att->attribute_type() == GeometryAttribute::NORMAL) {
+          // We currently only support normals with float coordinates
+          // and must be quantized.
+          return std::unique_ptr<SequentialAttributeEncoder>(
+              new SequentialNormalAttributeEncoder());
+        } else {
+#endif
+          return std::unique_ptr<SequentialAttributeEncoder>(
+              new SequentialQuantizationAttributeEncoder());
+#ifdef DRACO_NORMAL_ENCODING_SUPPORTED
+        }
+#endif
+      }
+      break;
+    default:
+      break;
+  }
+  // Return the default attribute encoder.
+  return std::unique_ptr<SequentialAttributeEncoder>(
+      new SequentialAttributeEncoder());
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.h b/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.h
new file mode 100644
index 000000000..13c2704ec
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_attribute_encoders_controller.h
@@ -0,0 +1,115 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODERS_CONTROLLER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODERS_CONTROLLER_H_
+
+#include "draco/compression/attributes/attributes_encoder.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_encoder.h"
+
+namespace draco {
+
+// A basic implementation of an attribute encoder that can be used to encode
+// an arbitrary set of attributes. The encoder creates a sequential attribute
+// encoder for each encoded attribute (see sequential_attribute_encoder.h) and
+// then it encodes all attribute values in an order defined by a point sequence
+// generated in the GeneratePointSequence() method. The default implementation
+// generates a linear sequence of all points, but derived classes can generate
+// any custom sequence.
+class SequentialAttributeEncodersController : public AttributesEncoder {
+ public:
+  explicit SequentialAttributeEncodersController(
+      std::unique_ptr<PointsSequencer> sequencer);
+  SequentialAttributeEncodersController(
+      std::unique_ptr<PointsSequencer> sequencer, int point_attrib_id);
+
+  bool Init(PointCloudEncoder *encoder, const PointCloud *pc) override;
+  bool EncodeAttributesEncoderData(EncoderBuffer *out_buffer) override;
+  bool EncodeAttributes(EncoderBuffer *buffer) override;
+  uint8_t GetUniqueId() const override { return BASIC_ATTRIBUTE_ENCODER; }
+
+  int NumParentAttributes(int32_t point_attribute_id) const override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return 0;
+    }
+    return sequential_encoders_[loc_id]->NumParentAttributes();
+  }
+
+  int GetParentAttributeId(int32_t point_attribute_id,
+                           int32_t parent_i) const override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return -1;
+    }
+    return sequential_encoders_[loc_id]->GetParentAttributeId(parent_i);
+  }
+
+  bool MarkParentAttribute(int32_t point_attribute_id) override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return false;
+    }
+    // Mark the attribute encoder as parent (even when if it is not created
+    // yet).
+    if (sequential_encoder_marked_as_parent_.size() <= loc_id) {
+      sequential_encoder_marked_as_parent_.resize(loc_id + 1, false);
+    }
+    sequential_encoder_marked_as_parent_[loc_id] = true;
+
+    if (sequential_encoders_.size() <= loc_id) {
+      return true;  // Sequential encoders not generated yet.
+    }
+    sequential_encoders_[loc_id]->MarkParentAttribute();
+    return true;
+  }
+
+  const PointAttribute *GetPortableAttribute(
+      int32_t point_attribute_id) override {
+    const int32_t loc_id = GetLocalIdForPointAttribute(point_attribute_id);
+    if (loc_id < 0) {
+      return nullptr;
+    }
+    return sequential_encoders_[loc_id]->GetPortableAttribute();
+  }
+
+ protected:
+  bool TransformAttributesToPortableFormat() override;
+  bool EncodePortableAttributes(EncoderBuffer *out_buffer) override;
+  bool EncodeDataNeededByPortableTransforms(EncoderBuffer *out_buffer) override;
+
+  // Creates all sequential encoders (one for each attribute associated with the
+  // encoder).
+  virtual bool CreateSequentialEncoders();
+
+  // Create a sequential encoder for a given attribute based on the attribute
+  // type
+  // and the provided encoder options.
+  virtual std::unique_ptr<SequentialAttributeEncoder> CreateSequentialEncoder(
+      int i);
+
+ private:
+  std::vector<std::unique_ptr<SequentialAttributeEncoder>> sequential_encoders_;
+
+  // Flag for each sequential attribute encoder indicating whether it was marked
+  // as parent attribute or not.
+  std::vector<bool> sequential_encoder_marked_as_parent_;
+  std::vector<PointIndex> point_ids_;
+  std::unique_ptr<PointsSequencer> sequencer_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_ATTRIBUTE_ENCODERS_CONTROLLER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.cc b/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.cc
new file mode 100644
index 000000000..83f42125a
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.cc
@@ -0,0 +1,240 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_integer_attribute_decoder.h"
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_decoding_transform.h"
+#include "draco/compression/entropy/symbol_decoding.h"
+
+namespace draco {
+
+SequentialIntegerAttributeDecoder::SequentialIntegerAttributeDecoder() {}
+
+bool SequentialIntegerAttributeDecoder::Init(PointCloudDecoder *decoder,
+                                             int attribute_id) {
+  if (!SequentialAttributeDecoder::Init(decoder, attribute_id)) {
+    return false;
+  }
+  return true;
+}
+
+bool SequentialIntegerAttributeDecoder::TransformAttributeToOriginalFormat(
+    const std::vector<PointIndex> &point_ids) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder() &&
+      decoder()->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    return true;  // Don't revert the transform here for older files.
+  }
+#endif
+  return StoreValues(static_cast<uint32_t>(point_ids.size()));
+}
+
+bool SequentialIntegerAttributeDecoder::DecodeValues(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  // Decode prediction scheme.
+  int8_t prediction_scheme_method;
+  if (!in_buffer->Decode(&prediction_scheme_method)) {
+    return false;
+  }
+  if (prediction_scheme_method != PREDICTION_NONE) {
+    int8_t prediction_transform_type;
+    if (!in_buffer->Decode(&prediction_transform_type)) {
+      return false;
+    }
+    // Check that decoded prediction scheme transform type is valid.
+    if (prediction_transform_type < PREDICTION_TRANSFORM_NONE ||
+        prediction_transform_type >= NUM_PREDICTION_SCHEME_TRANSFORM_TYPES) {
+      return false;
+    }
+    prediction_scheme_ = CreateIntPredictionScheme(
+        static_cast<PredictionSchemeMethod>(prediction_scheme_method),
+        static_cast<PredictionSchemeTransformType>(prediction_transform_type));
+  }
+
+  if (prediction_scheme_) {
+    if (!InitPredictionScheme(prediction_scheme_.get())) {
+      return false;
+    }
+  }
+
+  if (!DecodeIntegerValues(point_ids, in_buffer)) {
+    return false;
+  }
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  const int32_t num_values = static_cast<uint32_t>(point_ids.size());
+  if (decoder() &&
+      decoder()->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    // For older files, revert the transform right after we decode the data.
+    if (!StoreValues(num_values)) {
+      return false;
+    }
+  }
+#endif
+  return true;
+}
+
+std::unique_ptr<PredictionSchemeTypedDecoderInterface<int32_t>>
+SequentialIntegerAttributeDecoder::CreateIntPredictionScheme(
+    PredictionSchemeMethod method,
+    PredictionSchemeTransformType transform_type) {
+  if (transform_type != PREDICTION_TRANSFORM_WRAP) {
+    return nullptr;  // For now we support only wrap transform.
+  }
+  return CreatePredictionSchemeForDecoder<
+      int32_t, PredictionSchemeWrapDecodingTransform<int32_t>>(
+      method, attribute_id(), decoder());
+}
+
+bool SequentialIntegerAttributeDecoder::DecodeIntegerValues(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  const int num_components = GetNumValueComponents();
+  if (num_components <= 0) {
+    return false;
+  }
+  const size_t num_entries = point_ids.size();
+  const size_t num_values = num_entries * num_components;
+  PreparePortableAttribute(static_cast<int>(num_entries), num_components);
+  int32_t *const portable_attribute_data = GetPortableAttributeData();
+  if (portable_attribute_data == nullptr) {
+    return false;
+  }
+  uint8_t compressed;
+  if (!in_buffer->Decode(&compressed)) {
+    return false;
+  }
+  if (compressed > 0) {
+    // Decode compressed values.
+    if (!DecodeSymbols(static_cast<uint32_t>(num_values), num_components,
+                       in_buffer,
+                       reinterpret_cast<uint32_t *>(portable_attribute_data))) {
+      return false;
+    }
+  } else {
+    // Decode the integer data directly.
+    // Get the number of bytes for a given entry.
+    uint8_t num_bytes;
+    if (!in_buffer->Decode(&num_bytes)) {
+      return false;
+    }
+    if (num_bytes == DataTypeLength(DT_INT32)) {
+      if (portable_attribute()->buffer()->data_size() <
+          sizeof(int32_t) * num_values) {
+        return false;
+      }
+      if (!in_buffer->Decode(portable_attribute_data,
+                             sizeof(int32_t) * num_values)) {
+        return false;
+      }
+    } else {
+      if (portable_attribute()->buffer()->data_size() <
+          num_bytes * num_values) {
+        return false;
+      }
+      if (in_buffer->remaining_size() <
+          static_cast<int64_t>(num_bytes) * static_cast<int64_t>(num_values)) {
+        return false;
+      }
+      for (size_t i = 0; i < num_values; ++i) {
+        if (!in_buffer->Decode(portable_attribute_data + i, num_bytes))
+          return false;
+      }
+    }
+  }
+
+  if (num_values > 0 && (prediction_scheme_ == nullptr ||
+                         !prediction_scheme_->AreCorrectionsPositive())) {
+    // Convert the values back to the original signed format.
+    ConvertSymbolsToSignedInts(
+        reinterpret_cast<const uint32_t *>(portable_attribute_data),
+        static_cast<int>(num_values), portable_attribute_data);
+  }
+
+  // If the data was encoded with a prediction scheme, we must revert it.
+  if (prediction_scheme_) {
+    if (!prediction_scheme_->DecodePredictionData(in_buffer)) {
+      return false;
+    }
+
+    if (num_values > 0) {
+      if (!prediction_scheme_->ComputeOriginalValues(
+              portable_attribute_data, portable_attribute_data,
+              static_cast<int>(num_values), num_components, point_ids.data())) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool SequentialIntegerAttributeDecoder::StoreValues(uint32_t num_values) {
+  switch (attribute()->data_type()) {
+    case DT_UINT8:
+      StoreTypedValues<uint8_t>(num_values);
+      break;
+    case DT_INT8:
+      StoreTypedValues<int8_t>(num_values);
+      break;
+    case DT_UINT16:
+      StoreTypedValues<uint16_t>(num_values);
+      break;
+    case DT_INT16:
+      StoreTypedValues<int16_t>(num_values);
+      break;
+    case DT_UINT32:
+      StoreTypedValues<uint32_t>(num_values);
+      break;
+    case DT_INT32:
+      StoreTypedValues<int32_t>(num_values);
+      break;
+    default:
+      return false;
+  }
+  return true;
+}
+
+template <typename AttributeTypeT>
+void SequentialIntegerAttributeDecoder::StoreTypedValues(uint32_t num_values) {
+  const int num_components = attribute()->num_components();
+  const int entry_size = sizeof(AttributeTypeT) * num_components;
+  const std::unique_ptr<AttributeTypeT[]> att_val(
+      new AttributeTypeT[num_components]);
+  const int32_t *const portable_attribute_data = GetPortableAttributeData();
+  int val_id = 0;
+  int out_byte_pos = 0;
+  for (uint32_t i = 0; i < num_values; ++i) {
+    for (int c = 0; c < num_components; ++c) {
+      const AttributeTypeT value =
+          static_cast<AttributeTypeT>(portable_attribute_data[val_id++]);
+      att_val[c] = value;
+    }
+    // Store the integer value into the attribute buffer.
+    attribute()->buffer()->Write(out_byte_pos, att_val.get(), entry_size);
+    out_byte_pos += entry_size;
+  }
+}
+
+void SequentialIntegerAttributeDecoder::PreparePortableAttribute(
+    int num_entries, int num_components) {
+  GeometryAttribute va;
+  va.Init(attribute()->attribute_type(), nullptr, num_components, DT_INT32,
+          false, num_components * DataTypeLength(DT_INT32), 0);
+  std::unique_ptr<PointAttribute> port_att(new PointAttribute(va));
+  port_att->SetIdentityMapping();
+  port_att->Reset(num_entries);
+  SetPortableAttribute(std::move(port_att));
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.h b/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.h
new file mode 100644
index 000000000..ef48ed817
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_decoder.h
@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_DECODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder.h"
+#include "draco/compression/attributes/sequential_attribute_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for attributes encoded with the SequentialIntegerAttributeEncoder.
+class SequentialIntegerAttributeDecoder : public SequentialAttributeDecoder {
+ public:
+  SequentialIntegerAttributeDecoder();
+  bool Init(PointCloudDecoder *decoder, int attribute_id) override;
+
+  bool TransformAttributeToOriginalFormat(
+      const std::vector<PointIndex> &point_ids) override;
+
+ protected:
+  bool DecodeValues(const std::vector<PointIndex> &point_ids,
+                    DecoderBuffer *in_buffer) override;
+  virtual bool DecodeIntegerValues(const std::vector<PointIndex> &point_ids,
+                                   DecoderBuffer *in_buffer);
+
+  // Returns a prediction scheme that should be used for decoding of the
+  // integer values.
+  virtual std::unique_ptr<PredictionSchemeTypedDecoderInterface<int32_t>>
+  CreateIntPredictionScheme(PredictionSchemeMethod method,
+                            PredictionSchemeTransformType transform_type);
+
+  // Returns the number of integer attribute components. In general, this
+  // can be different from the number of components of the input attribute.
+  virtual int32_t GetNumValueComponents() const {
+    return attribute()->num_components();
+  }
+
+  // Called after all integer values are decoded. The implementation should
+  // use this method to store the values into the attribute.
+  virtual bool StoreValues(uint32_t num_values);
+
+  void PreparePortableAttribute(int num_entries, int num_components);
+
+  int32_t *GetPortableAttributeData() {
+    if (portable_attribute()->size() == 0) {
+      return nullptr;
+    }
+    return reinterpret_cast<int32_t *>(
+        portable_attribute()->GetAddress(AttributeValueIndex(0)));
+  }
+
+ private:
+  // Stores decoded values into the attribute with a data type AttributeTypeT.
+  template <typename AttributeTypeT>
+  void StoreTypedValues(uint32_t num_values);
+
+  std::unique_ptr<PredictionSchemeTypedDecoderInterface<int32_t>>
+      prediction_scheme_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.cc b/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.cc
new file mode 100644
index 000000000..e66a0a8a4
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.cc
@@ -0,0 +1,233 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_integer_attribute_encoder.h"
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_wrap_encoding_transform.h"
+#include "draco/compression/entropy/symbol_encoding.h"
+#include "draco/core/bit_utils.h"
+
+namespace draco {
+
+SequentialIntegerAttributeEncoder::SequentialIntegerAttributeEncoder() {}
+
+bool SequentialIntegerAttributeEncoder::Init(PointCloudEncoder *encoder,
+                                             int attribute_id) {
+  if (!SequentialAttributeEncoder::Init(encoder, attribute_id)) {
+    return false;
+  }
+  if (GetUniqueId() == SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER) {
+    // When encoding integers, this encoder currently works only for integer
+    // attributes up to 32 bits.
+    switch (attribute()->data_type()) {
+      case DT_INT8:
+      case DT_UINT8:
+      case DT_INT16:
+      case DT_UINT16:
+      case DT_INT32:
+      case DT_UINT32:
+        break;
+      default:
+        return false;
+    }
+  }
+  // Init prediction scheme.
+  const PredictionSchemeMethod prediction_scheme_method =
+      GetPredictionMethodFromOptions(attribute_id, *encoder->options());
+
+  prediction_scheme_ = CreateIntPredictionScheme(prediction_scheme_method);
+
+  if (prediction_scheme_ && !InitPredictionScheme(prediction_scheme_.get())) {
+    prediction_scheme_ = nullptr;
+  }
+
+  return true;
+}
+
+bool SequentialIntegerAttributeEncoder::TransformAttributeToPortableFormat(
+    const std::vector<PointIndex> &point_ids) {
+  if (encoder()) {
+    if (!PrepareValues(point_ids, encoder()->point_cloud()->num_points())) {
+      return false;
+    }
+  } else {
+    if (!PrepareValues(point_ids, 0)) {
+      return false;
+    }
+  }
+
+  // Update point to attribute mapping with the portable attribute if the
+  // attribute is a parent attribute (for now, we can skip it otherwise).
+  if (is_parent_encoder()) {
+    // First create map between original attribute value indices and new ones
+    // (determined by the encoding order).
+    const PointAttribute *const orig_att = attribute();
+    PointAttribute *const portable_att = portable_attribute();
+    IndexTypeVector<AttributeValueIndex, AttributeValueIndex>
+        value_to_value_map(orig_att->size());
+    for (int i = 0; i < point_ids.size(); ++i) {
+      value_to_value_map[orig_att->mapped_index(point_ids[i])] =
+          AttributeValueIndex(i);
+    }
+    if (portable_att->is_mapping_identity()) {
+      portable_att->SetExplicitMapping(encoder()->point_cloud()->num_points());
+    }
+    // Go over all points of the original attribute and update the mapping in
+    // the portable attribute.
+    for (PointIndex i(0); i < encoder()->point_cloud()->num_points(); ++i) {
+      portable_att->SetPointMapEntry(
+          i, value_to_value_map[orig_att->mapped_index(i)]);
+    }
+  }
+  return true;
+}
+
+std::unique_ptr<PredictionSchemeTypedEncoderInterface<int32_t>>
+SequentialIntegerAttributeEncoder::CreateIntPredictionScheme(
+    PredictionSchemeMethod method) {
+  return CreatePredictionSchemeForEncoder<
+      int32_t, PredictionSchemeWrapEncodingTransform<int32_t>>(
+      method, attribute_id(), encoder());
+}
+
+bool SequentialIntegerAttributeEncoder::EncodeValues(
+    const std::vector<PointIndex> &point_ids, EncoderBuffer *out_buffer) {
+  // Initialize general quantization data.
+  const PointAttribute *const attrib = attribute();
+  if (attrib->size() == 0) {
+    return true;
+  }
+
+  int8_t prediction_scheme_method = PREDICTION_NONE;
+  if (prediction_scheme_) {
+    if (!SetPredictionSchemeParentAttributes(prediction_scheme_.get())) {
+      return false;
+    }
+    prediction_scheme_method =
+        static_cast<int8_t>(prediction_scheme_->GetPredictionMethod());
+  }
+  out_buffer->Encode(prediction_scheme_method);
+  if (prediction_scheme_) {
+    out_buffer->Encode(
+        static_cast<int8_t>(prediction_scheme_->GetTransformType()));
+  }
+
+  const int num_components = portable_attribute()->num_components();
+  const int num_values =
+      static_cast<int>(num_components * portable_attribute()->size());
+  const int32_t *const portable_attribute_data = GetPortableAttributeData();
+
+  // We need to keep the portable data intact, but several encoding steps can
+  // result in changes of this data, e.g., by applying prediction schemes that
+  // change the data in place. To preserve the portable data we store and
+  // process all encoded data in a separate array.
+  std::vector<int32_t> encoded_data(num_values);
+
+  // All integer values are initialized. Process them using the prediction
+  // scheme if we have one.
+  if (prediction_scheme_) {
+    prediction_scheme_->ComputeCorrectionValues(
+        portable_attribute_data, &encoded_data[0], num_values, num_components,
+        point_ids.data());
+  }
+
+  if (prediction_scheme_ == nullptr ||
+      !prediction_scheme_->AreCorrectionsPositive()) {
+    const int32_t *const input =
+        prediction_scheme_ ? encoded_data.data() : portable_attribute_data;
+    ConvertSignedIntsToSymbols(input, num_values,
+                               reinterpret_cast<uint32_t *>(&encoded_data[0]));
+  }
+
+  if (encoder() == nullptr || encoder()->options()->GetGlobalBool(
+                                  "use_built_in_attribute_compression", true)) {
+    out_buffer->Encode(static_cast<uint8_t>(1));
+    Options symbol_encoding_options;
+    if (encoder() != nullptr) {
+      SetSymbolEncodingCompressionLevel(&symbol_encoding_options,
+                                        10 - encoder()->options()->GetSpeed());
+    }
+    if (!EncodeSymbols(reinterpret_cast<uint32_t *>(encoded_data.data()),
+                       static_cast<int>(point_ids.size()) * num_components,
+                       num_components, &symbol_encoding_options, out_buffer)) {
+      return false;
+    }
+  } else {
+    // No compression. Just store the raw integer values, using the number of
+    // bytes as needed.
+
+    // To compute the maximum bit-length, first OR all values.
+    uint32_t masked_value = 0;
+    for (uint32_t i = 0; i < static_cast<uint32_t>(num_values); ++i) {
+      masked_value |= encoded_data[i];
+    }
+    // Compute the msb of the ORed value.
+    int value_msb_pos = 0;
+    if (masked_value != 0) {
+      value_msb_pos = MostSignificantBit(masked_value);
+    }
+    const int num_bytes = 1 + value_msb_pos / 8;
+
+    out_buffer->Encode(static_cast<uint8_t>(0));
+    out_buffer->Encode(static_cast<uint8_t>(num_bytes));
+
+    if (num_bytes == DataTypeLength(DT_INT32)) {
+      out_buffer->Encode(encoded_data.data(), sizeof(int32_t) * num_values);
+    } else {
+      for (uint32_t i = 0; i < static_cast<uint32_t>(num_values); ++i) {
+        out_buffer->Encode(encoded_data.data() + i, num_bytes);
+      }
+    }
+  }
+  if (prediction_scheme_) {
+    prediction_scheme_->EncodePredictionData(out_buffer);
+  }
+  return true;
+}
+
+bool SequentialIntegerAttributeEncoder::PrepareValues(
+    const std::vector<PointIndex> &point_ids, int num_points) {
+  // Convert all values to int32_t format.
+  const PointAttribute *const attrib = attribute();
+  const int num_components = attrib->num_components();
+  const int num_entries = static_cast<int>(point_ids.size());
+  PreparePortableAttribute(num_entries, num_components, num_points);
+  int32_t dst_index = 0;
+  int32_t *const portable_attribute_data = GetPortableAttributeData();
+  for (PointIndex pi : point_ids) {
+    const AttributeValueIndex att_id = attrib->mapped_index(pi);
+    if (!attrib->ConvertValue<int32_t>(att_id,
+                                       portable_attribute_data + dst_index)) {
+      return false;
+    }
+    dst_index += num_components;
+  }
+  return true;
+}
+
+void SequentialIntegerAttributeEncoder::PreparePortableAttribute(
+    int num_entries, int num_components, int num_points) {
+  GeometryAttribute va;
+  va.Init(attribute()->attribute_type(), nullptr, num_components, DT_INT32,
+          false, num_components * DataTypeLength(DT_INT32), 0);
+  std::unique_ptr<PointAttribute> port_att(new PointAttribute(va));
+  port_att->Reset(num_entries);
+  SetPortableAttribute(std::move(port_att));
+  if (num_points) {
+    portable_attribute()->SetExplicitMapping(num_points);
+  }
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.h b/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.h
new file mode 100644
index 000000000..c1d6222ef
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoder.h
@@ -0,0 +1,67 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_ENCODER_H_
+
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder.h"
+#include "draco/compression/attributes/sequential_attribute_encoder.h"
+
+namespace draco {
+
+// Attribute encoder designed for lossless encoding of integer attributes. The
+// attribute values can be pre-processed by a prediction scheme and compressed
+// with a built-in entropy coder.
+class SequentialIntegerAttributeEncoder : public SequentialAttributeEncoder {
+ public:
+  SequentialIntegerAttributeEncoder();
+  uint8_t GetUniqueId() const override {
+    return SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER;
+  }
+
+  bool Init(PointCloudEncoder *encoder, int attribute_id) override;
+  bool TransformAttributeToPortableFormat(
+      const std::vector<PointIndex> &point_ids) override;
+
+ protected:
+  bool EncodeValues(const std::vector<PointIndex> &point_ids,
+                    EncoderBuffer *out_buffer) override;
+
+  // Returns a prediction scheme that should be used for encoding of the
+  // integer values.
+  virtual std::unique_ptr<PredictionSchemeTypedEncoderInterface<int32_t>>
+  CreateIntPredictionScheme(PredictionSchemeMethod method);
+
+  // Prepares the integer values that are going to be encoded.
+  virtual bool PrepareValues(const std::vector<PointIndex> &point_ids,
+                             int num_points);
+
+  void PreparePortableAttribute(int num_entries, int num_components,
+                                int num_points);
+
+  int32_t *GetPortableAttributeData() {
+    return reinterpret_cast<int32_t *>(
+        portable_attribute()->GetAddress(AttributeValueIndex(0)));
+  }
+
+ private:
+  // Optional prediction scheme can be used to modify the integer values in
+  // order to make them easier to compress.
+  std::unique_ptr<PredictionSchemeTypedEncoderInterface<int32_t>>
+      prediction_scheme_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_INTEGER_ATTRIBUTE_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoding_test.cc b/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoding_test.cc
new file mode 100644
index 000000000..44485e679
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_integer_attribute_encoding_test.cc
@@ -0,0 +1,64 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <numeric>
+
+#include "draco/compression/attributes/sequential_integer_attribute_decoder.h"
+#include "draco/compression/attributes/sequential_integer_attribute_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/draco_test_base.h"
+
+namespace draco {
+
+class SequentialIntegerAttributeEncodingTest : public ::testing::Test {
+ protected:
+};
+
+TEST_F(SequentialIntegerAttributeEncodingTest, DoesCompress) {
+  // This test verifies that IntegerEncoding encodes and decodes the given data.
+  const std::vector<int32_t> values{1,   8,  7,  5, 5,   5, 9,
+                                    155, -6, -9, 9, 125, 1, 0};
+  PointAttribute pa;
+  pa.Init(GeometryAttribute::GENERIC, 1, DT_INT32, false, values.size());
+  for (uint32_t i = 0; i < values.size(); ++i) {
+    pa.SetAttributeValue(AttributeValueIndex(i), &values[i]);
+  }
+  // List of point ids from 0 to point_ids.size() - 1.
+  std::vector<PointIndex> point_ids(values.size());
+  std::iota(point_ids.begin(), point_ids.end(), 0);
+
+  EncoderBuffer out_buf;
+  SequentialIntegerAttributeEncoder ie;
+  ASSERT_TRUE(ie.InitializeStandalone(&pa));
+  ASSERT_TRUE(ie.TransformAttributeToPortableFormat(point_ids));
+  ASSERT_TRUE(ie.EncodePortableAttribute(point_ids, &out_buf));
+  ASSERT_TRUE(ie.EncodeDataNeededByPortableTransform(&out_buf));
+
+  DecoderBuffer in_buf;
+  in_buf.Init(out_buf.data(), out_buf.size());
+  in_buf.set_bitstream_version(kDracoMeshBitstreamVersion);
+  SequentialIntegerAttributeDecoder id;
+  ASSERT_TRUE(id.InitializeStandalone(&pa));
+  ASSERT_TRUE(id.DecodePortableAttribute(point_ids, &in_buf));
+  ASSERT_TRUE(id.DecodeDataNeededByPortableTransform(point_ids, &in_buf));
+  ASSERT_TRUE(id.TransformAttributeToOriginalFormat(point_ids));
+
+  for (uint32_t i = 0; i < values.size(); ++i) {
+    int32_t entry_val;
+    pa.GetValue(AttributeValueIndex(i), &entry_val);
+    ASSERT_EQ(entry_val, values[i]);
+  }
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.cc b/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.cc
new file mode 100644
index 000000000..de36c1c36
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.cc
@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_normal_attribute_decoder.h"
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+
+namespace draco {
+
+SequentialNormalAttributeDecoder::SequentialNormalAttributeDecoder() {}
+
+bool SequentialNormalAttributeDecoder::Init(PointCloudDecoder *decoder,
+                                            int attribute_id) {
+  if (!SequentialIntegerAttributeDecoder::Init(decoder, attribute_id)) {
+    return false;
+  }
+  // Currently, this encoder works only for 3-component normal vectors.
+  if (attribute()->num_components() != 3) {
+    return false;
+  }
+  // Also the data type must be DT_FLOAT32.
+  if (attribute()->data_type() != DT_FLOAT32) {
+    return false;
+  }
+  return true;
+}
+
+bool SequentialNormalAttributeDecoder::DecodeIntegerValues(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder()->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    // Note: in older bitstreams, we do not have a PortableAttribute() decoded
+    // at this stage so we cannot pass it down to the DecodeParameters() call.
+    // It still works fine for octahedral transform because it does not need to
+    // use any data from the attribute.
+    if (!octahedral_transform_.DecodeParameters(*attribute(), in_buffer)) {
+      return false;
+    }
+  }
+#endif
+  return SequentialIntegerAttributeDecoder::DecodeIntegerValues(point_ids,
+                                                                in_buffer);
+}
+
+bool SequentialNormalAttributeDecoder::DecodeDataNeededByPortableTransform(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  if (decoder()->bitstream_version() >= DRACO_BITSTREAM_VERSION(2, 0)) {
+    // For newer file version, decode attribute transform data here.
+    if (!octahedral_transform_.DecodeParameters(*GetPortableAttribute(),
+                                                in_buffer)) {
+      return false;
+    }
+  }
+
+  // Store the decoded transform data in portable attribute.
+  return octahedral_transform_.TransferToAttribute(portable_attribute());
+}
+
+bool SequentialNormalAttributeDecoder::StoreValues(uint32_t num_points) {
+  // Convert all quantized values back to floats.
+  return octahedral_transform_.InverseTransformAttribute(
+      *GetPortableAttribute(), attribute());
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.h b/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.h
new file mode 100644
index 000000000..8c2d801b7
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_decoder.h
@@ -0,0 +1,83 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_DECODER_H_
+
+#include "draco/attributes/attribute_octahedron_transform.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_decoder_factory.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_decoding_transform.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_decoding_transform.h"
+#include "draco/compression/attributes/sequential_integer_attribute_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for attributes encoded with SequentialNormalAttributeEncoder.
+class SequentialNormalAttributeDecoder
+    : public SequentialIntegerAttributeDecoder {
+ public:
+  SequentialNormalAttributeDecoder();
+  bool Init(PointCloudDecoder *decoder, int attribute_id) override;
+
+ protected:
+  int32_t GetNumValueComponents() const override {
+    return 2;  // We quantize everything into two components.
+  }
+  bool DecodeIntegerValues(const std::vector<PointIndex> &point_ids,
+                           DecoderBuffer *in_buffer) override;
+  bool DecodeDataNeededByPortableTransform(
+      const std::vector<PointIndex> &point_ids,
+      DecoderBuffer *in_buffer) override;
+  bool StoreValues(uint32_t num_points) override;
+
+ private:
+  AttributeOctahedronTransform octahedral_transform_;
+
+  std::unique_ptr<PredictionSchemeTypedDecoderInterface<int32_t>>
+  CreateIntPredictionScheme(
+      PredictionSchemeMethod method,
+      PredictionSchemeTransformType transform_type) override {
+    switch (transform_type) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      case PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON: {
+        typedef PredictionSchemeNormalOctahedronDecodingTransform<int32_t>
+            Transform;
+        // At this point the decoder has not read the quantization bits,
+        // which is why we must construct the transform by default.
+        // See Transform.DecodeTransformData for more details.
+        return CreatePredictionSchemeForDecoder<int32_t, Transform>(
+            method, attribute_id(), decoder());
+      }
+#endif
+      case PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED: {
+        typedef PredictionSchemeNormalOctahedronCanonicalizedDecodingTransform<
+            int32_t>
+            Transform;
+        // At this point the decoder has not read the quantization bits,
+        // which is why we must construct the transform by default.
+        // See Transform.DecodeTransformData for more details.
+        return CreatePredictionSchemeForDecoder<int32_t, Transform>(
+            method, attribute_id(), decoder());
+      }
+      default:
+        return nullptr;  // Currently, we support only octahedron transform and
+                         // octahedron transform canonicalized.
+    }
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.cc b/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.cc
new file mode 100644
index 000000000..2e20e89e6
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.cc
@@ -0,0 +1,57 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_normal_attribute_encoder.h"
+
+#include "draco/compression/attributes/normal_compression_utils.h"
+
+namespace draco {
+
+bool SequentialNormalAttributeEncoder::Init(PointCloudEncoder *encoder,
+                                            int attribute_id) {
+  if (!SequentialIntegerAttributeEncoder::Init(encoder, attribute_id))
+    return false;
+  // Currently this encoder works only for 3-component normal vectors.
+  if (attribute()->num_components() != 3) {
+    return false;
+  }
+
+  // Initialize AttributeOctahedronTransform.
+  const int quantization_bits = encoder->options()->GetAttributeInt(
+      attribute_id, "quantization_bits", -1);
+  if (quantization_bits < 1) {
+    return false;
+  }
+  attribute_octahedron_transform_.SetParameters(quantization_bits);
+  return true;
+}
+
+bool SequentialNormalAttributeEncoder::EncodeDataNeededByPortableTransform(
+    EncoderBuffer *out_buffer) {
+  return attribute_octahedron_transform_.EncodeParameters(out_buffer);
+}
+
+bool SequentialNormalAttributeEncoder::PrepareValues(
+    const std::vector<PointIndex> &point_ids, int num_points) {
+  auto portable_att = attribute_octahedron_transform_.InitTransformedAttribute(
+      *(attribute()), point_ids.size());
+  if (!attribute_octahedron_transform_.TransformAttribute(
+          *(attribute()), point_ids, portable_att.get())) {
+    return false;
+  }
+  SetPortableAttribute(std::move(portable_att));
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.h b/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.h
new file mode 100644
index 000000000..53705c598
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_normal_attribute_encoder.h
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_ENCODER_H_
+
+#include "draco/attributes/attribute_octahedron_transform.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_encoder_factory.h"
+#include "draco/compression/attributes/prediction_schemes/prediction_scheme_normal_octahedron_canonicalized_encoding_transform.h"
+#include "draco/compression/attributes/sequential_integer_attribute_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+
+namespace draco {
+
+// Class for encoding normal vectors using an octahedral encoding, see Cigolle
+// et al.'14 “A Survey of Efficient Representations for Independent Unit
+// Vectors”. Compared to the basic quantization encoder, this encoder results
+// in a better compression rate under the same accuracy settings. Note that this
+// encoder doesn't preserve the lengths of input vectors, therefore it will not
+// work correctly when the input values are not normalized.
+class SequentialNormalAttributeEncoder
+    : public SequentialIntegerAttributeEncoder {
+ public:
+  uint8_t GetUniqueId() const override {
+    return SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS;
+  }
+  bool IsLossyEncoder() const override { return true; }
+
+  bool EncodeDataNeededByPortableTransform(EncoderBuffer *out_buffer) override;
+
+ protected:
+  bool Init(PointCloudEncoder *encoder, int attribute_id) override;
+
+  // Put quantized values in portable attribute for sequential encoding.
+  bool PrepareValues(const std::vector<PointIndex> &point_ids,
+                     int num_points) override;
+
+  std::unique_ptr<PredictionSchemeTypedEncoderInterface<int32_t>>
+  CreateIntPredictionScheme(PredictionSchemeMethod /* method */) override {
+    typedef PredictionSchemeNormalOctahedronCanonicalizedEncodingTransform<
+        int32_t>
+        Transform;
+    const int32_t quantization_bits = encoder()->options()->GetAttributeInt(
+        attribute_id(), "quantization_bits", -1);
+    const int32_t max_value = (1 << quantization_bits) - 1;
+    const Transform transform(max_value);
+    const PredictionSchemeMethod default_prediction_method =
+        SelectPredictionMethod(attribute_id(), encoder());
+    const int32_t prediction_method = encoder()->options()->GetAttributeInt(
+        attribute_id(), "prediction_scheme", default_prediction_method);
+
+    if (prediction_method == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+      return CreatePredictionSchemeForEncoder<int32_t, Transform>(
+          MESH_PREDICTION_GEOMETRIC_NORMAL, attribute_id(), encoder(),
+          transform);
+    }
+    if (prediction_method == PREDICTION_DIFFERENCE) {
+      return CreatePredictionSchemeForEncoder<int32_t, Transform>(
+          PREDICTION_DIFFERENCE, attribute_id(), encoder(), transform);
+    }
+    DRACO_DCHECK(false);  // Should never be reached.
+    return nullptr;
+  }
+
+  // Used for the conversion to quantized normals in octahedral format.
+  AttributeOctahedronTransform attribute_octahedron_transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_NORMAL_ATTRIBUTE_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.cc b/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.cc
new file mode 100644
index 000000000..3d306e7da
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.cc
@@ -0,0 +1,88 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_quantization_attribute_decoder.h"
+
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+SequentialQuantizationAttributeDecoder::
+    SequentialQuantizationAttributeDecoder() {}
+
+bool SequentialQuantizationAttributeDecoder::Init(PointCloudDecoder *decoder,
+                                                  int attribute_id) {
+  if (!SequentialIntegerAttributeDecoder::Init(decoder, attribute_id)) {
+    return false;
+  }
+  const PointAttribute *const attribute =
+      decoder->point_cloud()->attribute(attribute_id);
+  // Currently we can quantize only floating point arguments.
+  if (attribute->data_type() != DT_FLOAT32) {
+    return false;
+  }
+  return true;
+}
+
+bool SequentialQuantizationAttributeDecoder::DecodeIntegerValues(
+    const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder()->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0) &&
+      !DecodeQuantizedDataInfo()) {
+    return false;
+  }
+#endif
+  return SequentialIntegerAttributeDecoder::DecodeIntegerValues(point_ids,
+                                                                in_buffer);
+}
+
+bool SequentialQuantizationAttributeDecoder::
+    DecodeDataNeededByPortableTransform(
+        const std::vector<PointIndex> &point_ids, DecoderBuffer *in_buffer) {
+  if (decoder()->bitstream_version() >= DRACO_BITSTREAM_VERSION(2, 0)) {
+    // Decode quantization data here only for files with bitstream version 2.0+
+    if (!DecodeQuantizedDataInfo()) {
+      return false;
+    }
+  }
+
+  // Store the decoded transform data in portable attribute;
+  return quantization_transform_.TransferToAttribute(portable_attribute());
+}
+
+bool SequentialQuantizationAttributeDecoder::StoreValues(uint32_t num_points) {
+  return DequantizeValues(num_points);
+}
+
+bool SequentialQuantizationAttributeDecoder::DecodeQuantizedDataInfo() {
+  // Get attribute used as source for decoding.
+  auto att = GetPortableAttribute();
+  if (att == nullptr) {
+    // This should happen only in the backward compatibility mode. It will still
+    // work fine for this case because the only thing the quantization transform
+    // cares about is the number of components that is the same for both source
+    // and target attributes.
+    att = attribute();
+  }
+  return quantization_transform_.DecodeParameters(*att, decoder()->buffer());
+}
+
+bool SequentialQuantizationAttributeDecoder::DequantizeValues(
+    uint32_t num_values) {
+  // Convert all quantized values back to floats.
+  return quantization_transform_.InverseTransformAttribute(
+      *GetPortableAttribute(), attribute());
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.h b/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.h
new file mode 100644
index 000000000..ad372dcd8
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_decoder.h
@@ -0,0 +1,52 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_DECODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_DECODER_H_
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/attributes/sequential_integer_attribute_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for attribute values encoded with the
+// SequentialQuantizationAttributeEncoder.
+class SequentialQuantizationAttributeDecoder
+    : public SequentialIntegerAttributeDecoder {
+ public:
+  SequentialQuantizationAttributeDecoder();
+  bool Init(PointCloudDecoder *decoder, int attribute_id) override;
+
+ protected:
+  bool DecodeIntegerValues(const std::vector<PointIndex> &point_ids,
+                           DecoderBuffer *in_buffer) override;
+  bool DecodeDataNeededByPortableTransform(
+      const std::vector<PointIndex> &point_ids,
+      DecoderBuffer *in_buffer) override;
+  bool StoreValues(uint32_t num_points) override;
+
+  // Decodes data necessary for dequantizing the encoded values.
+  virtual bool DecodeQuantizedDataInfo();
+
+  // Dequantizes all values and stores them into the output attribute.
+  virtual bool DequantizeValues(uint32_t num_values);
+
+ private:
+  AttributeQuantizationTransform quantization_transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.cc b/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.cc
new file mode 100644
index 000000000..d3666f7a4
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.cc
@@ -0,0 +1,86 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/attributes/sequential_quantization_attribute_encoder.h"
+
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+SequentialQuantizationAttributeEncoder::
+    SequentialQuantizationAttributeEncoder() {}
+
+bool SequentialQuantizationAttributeEncoder::Init(PointCloudEncoder *encoder,
+                                                  int attribute_id) {
+  if (!SequentialIntegerAttributeEncoder::Init(encoder, attribute_id)) {
+    return false;
+  }
+  // This encoder currently works only for floating point attributes.
+  const PointAttribute *const attribute =
+      encoder->point_cloud()->attribute(attribute_id);
+  if (attribute->data_type() != DT_FLOAT32) {
+    return false;
+  }
+
+  // Initialize AttributeQuantizationTransform.
+  const int quantization_bits = encoder->options()->GetAttributeInt(
+      attribute_id, "quantization_bits", -1);
+  if (quantization_bits < 1) {
+    return false;
+  }
+  if (encoder->options()->IsAttributeOptionSet(attribute_id,
+                                               "quantization_origin") &&
+      encoder->options()->IsAttributeOptionSet(attribute_id,
+                                               "quantization_range")) {
+    // Quantization settings are explicitly specified in the provided options.
+    std::vector<float> quantization_origin(attribute->num_components());
+    encoder->options()->GetAttributeVector(attribute_id, "quantization_origin",
+                                           attribute->num_components(),
+                                           &quantization_origin[0]);
+    const float range = encoder->options()->GetAttributeFloat(
+        attribute_id, "quantization_range", 1.f);
+    if (!attribute_quantization_transform_.SetParameters(
+            quantization_bits, quantization_origin.data(),
+            attribute->num_components(), range)) {
+      return false;
+    }
+  } else {
+    // Compute quantization settings from the attribute values.
+    if (!attribute_quantization_transform_.ComputeParameters(
+            *attribute, quantization_bits)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool SequentialQuantizationAttributeEncoder::
+    EncodeDataNeededByPortableTransform(EncoderBuffer *out_buffer) {
+  return attribute_quantization_transform_.EncodeParameters(out_buffer);
+}
+
+bool SequentialQuantizationAttributeEncoder::PrepareValues(
+    const std::vector<PointIndex> &point_ids, int num_points) {
+  auto portable_attribute =
+      attribute_quantization_transform_.InitTransformedAttribute(
+          *attribute(), point_ids.size());
+  if (!attribute_quantization_transform_.TransformAttribute(
+          *(attribute()), point_ids, portable_attribute.get())) {
+    return false;
+  }
+  SetPortableAttribute(std::move(portable_attribute));
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.h b/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.h
new file mode 100644
index 000000000..e9762bdd6
--- /dev/null
+++ b/contrib/draco/src/draco/compression/attributes/sequential_quantization_attribute_encoder.h
@@ -0,0 +1,52 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_ENCODER_H_
+#define DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_ENCODER_H_
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/attributes/sequential_integer_attribute_encoder.h"
+
+namespace draco {
+
+class MeshEncoder;
+
+// Attribute encoder that quantizes floating point attribute values. The
+// quantized values can be optionally compressed using an entropy coding.
+class SequentialQuantizationAttributeEncoder
+    : public SequentialIntegerAttributeEncoder {
+ public:
+  SequentialQuantizationAttributeEncoder();
+  uint8_t GetUniqueId() const override {
+    return SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION;
+  }
+  bool Init(PointCloudEncoder *encoder, int attribute_id) override;
+
+  bool IsLossyEncoder() const override { return true; }
+
+  bool EncodeDataNeededByPortableTransform(EncoderBuffer *out_buffer) override;
+
+ protected:
+  // Put quantized values in portable attribute for sequential encoding.
+  bool PrepareValues(const std::vector<PointIndex> &point_ids,
+                     int num_points) override;
+
+ private:
+  // Used for the quantization.
+  AttributeQuantizationTransform attribute_quantization_transform_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ATTRIBUTES_SEQUENTIAL_QUANTIZATION_ATTRIBUTE_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h b/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h
new file mode 100644
index 000000000..faacbd5b9
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h
@@ -0,0 +1,43 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides shared functions for adaptive rANS bit coding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_CODING_SHARED_H_
+#define DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_CODING_SHARED_H_
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// Clamp the probability p to a uint8_t in the range [1,255].
+inline uint8_t clamp_probability(double p) {
+  DRACO_DCHECK_LE(p, 1.0);
+  DRACO_DCHECK_LE(0.0, p);
+  uint32_t p_int = static_cast<uint32_t>((p * 256) + 0.5);
+  p_int -= (p_int == 256);
+  p_int += (p_int == 0);
+  return static_cast<uint8_t>(p_int);
+}
+
+// Update the probability according to new incoming bit.
+inline double update_probability(double old_p, bool bit) {
+  static constexpr double w = 128.0;
+  static constexpr double w0 = (w - 1.0) / w;
+  static constexpr double w1 = 1.0 / w;
+  return old_p * w0 + (!bit) * w1;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_CODING_SHARED_H_
diff --git a/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.cc b/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.cc
new file mode 100644
index 000000000..056842c4a
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.cc
@@ -0,0 +1,70 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/bit_coders/adaptive_rans_bit_decoder.h"
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h"
+
+namespace draco {
+
+AdaptiveRAnsBitDecoder::AdaptiveRAnsBitDecoder() : p0_f_(0.5) {}
+
+AdaptiveRAnsBitDecoder::~AdaptiveRAnsBitDecoder() { Clear(); }
+
+bool AdaptiveRAnsBitDecoder::StartDecoding(DecoderBuffer *source_buffer) {
+  Clear();
+
+  uint32_t size_in_bytes;
+  if (!source_buffer->Decode(&size_in_bytes)) {
+    return false;
+  }
+  if (size_in_bytes > source_buffer->remaining_size()) {
+    return false;
+  }
+  if (ans_read_init(&ans_decoder_,
+                    reinterpret_cast<uint8_t *>(
+                        const_cast<char *>(source_buffer->data_head())),
+                    size_in_bytes) != 0) {
+    return false;
+  }
+  source_buffer->Advance(size_in_bytes);
+  return true;
+}
+
+bool AdaptiveRAnsBitDecoder::DecodeNextBit() {
+  const uint8_t p0 = clamp_probability(p0_f_);
+  const bool bit = static_cast<bool>(rabs_read(&ans_decoder_, p0));
+  p0_f_ = update_probability(p0_f_, bit);
+  return bit;
+}
+
+void AdaptiveRAnsBitDecoder::DecodeLeastSignificantBits32(int nbits,
+                                                          uint32_t *value) {
+  DRACO_DCHECK_EQ(true, nbits <= 32);
+  DRACO_DCHECK_EQ(true, nbits > 0);
+
+  uint32_t result = 0;
+  while (nbits) {
+    result = (result << 1) + DecodeNextBit();
+    --nbits;
+  }
+  *value = result;
+}
+
+void AdaptiveRAnsBitDecoder::Clear() {
+  ans_read_end(&ans_decoder_);
+  p0_f_ = 0.5;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.h b/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.h
new file mode 100644
index 000000000..a1ea011dd
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_decoder.h
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides basic classes and functions for rANS bit decoding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_DECODER_H_
+
+#include <vector>
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// Class for decoding a sequence of bits that were encoded with
+// AdaptiveRAnsBitEncoder.
+class AdaptiveRAnsBitDecoder {
+ public:
+  AdaptiveRAnsBitDecoder();
+  ~AdaptiveRAnsBitDecoder();
+
+  // Sets |source_buffer| as the buffer to decode bits from.
+  bool StartDecoding(DecoderBuffer *source_buffer);
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit();
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value);
+
+  void EndDecoding() {}
+
+ private:
+  void Clear();
+
+  AnsDecoder ans_decoder_;
+  double p0_f_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.cc b/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.cc
new file mode 100644
index 000000000..5ce9dc388
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.cc
@@ -0,0 +1,59 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/bit_coders/adaptive_rans_bit_encoder.h"
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_coding_shared.h"
+
+namespace draco {
+
+AdaptiveRAnsBitEncoder::AdaptiveRAnsBitEncoder() {}
+
+AdaptiveRAnsBitEncoder::~AdaptiveRAnsBitEncoder() { Clear(); }
+
+void AdaptiveRAnsBitEncoder::StartEncoding() { Clear(); }
+
+void AdaptiveRAnsBitEncoder::EndEncoding(EncoderBuffer *target_buffer) {
+  // Buffer for ans to write.
+  std::vector<uint8_t> buffer(bits_.size() + 16);
+  AnsCoder ans_coder;
+  ans_write_init(&ans_coder, buffer.data());
+
+  // Unfortunately we have to encode the bits in reversed order, while the
+  // probabilities that should be given are those of the forward sequence.
+  double p0_f = 0.5;
+  std::vector<uint8_t> p0s;
+  p0s.reserve(bits_.size());
+  for (bool b : bits_) {
+    p0s.push_back(clamp_probability(p0_f));
+    p0_f = update_probability(p0_f, b);
+  }
+  auto bit = bits_.rbegin();
+  auto pit = p0s.rbegin();
+  while (bit != bits_.rend()) {
+    rabs_write(&ans_coder, *bit, *pit);
+    ++bit;
+    ++pit;
+  }
+
+  const uint32_t size_in_bytes = ans_write_end(&ans_coder);
+  target_buffer->Encode(size_in_bytes);
+  target_buffer->Encode(buffer.data(), size_in_bytes);
+
+  Clear();
+}
+
+void AdaptiveRAnsBitEncoder::Clear() { bits_.clear(); }
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.h b/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.h
new file mode 100644
index 000000000..9b1832844
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/adaptive_rans_bit_encoder.h
@@ -0,0 +1,61 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides basic classes and functions for rANS bit encoding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_ENCODER_H_
+
+#include <vector>
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Class for adaptive encoding a sequence of bits using rANS.
+class AdaptiveRAnsBitEncoder {
+ public:
+  AdaptiveRAnsBitEncoder();
+  ~AdaptiveRAnsBitEncoder();
+
+  // Must be called before any Encode* function is called.
+  void StartEncoding();
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit) { bits_.push_back(bit); }
+
+  // Encode |nbits| of |value|, starting from the least significant bit.
+  // |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+    DRACO_DCHECK_EQ(true, nbits <= 32);
+    DRACO_DCHECK_EQ(true, nbits > 0);
+    uint32_t selector = (1 << (nbits - 1));
+    while (selector) {
+      EncodeBit(value & selector);
+      selector = selector >> 1;
+    }
+  }
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer);
+
+ private:
+  void Clear();
+
+  std::vector<bool> bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_ADAPTIVE_RANS_BIT_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.cc b/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.cc
new file mode 100644
index 000000000..2abe3382a
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.cc
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/bit_coders/direct_bit_decoder.h"
+
+namespace draco {
+
+DirectBitDecoder::DirectBitDecoder() : pos_(bits_.end()), num_used_bits_(0) {}
+
+DirectBitDecoder::~DirectBitDecoder() { Clear(); }
+
+bool DirectBitDecoder::StartDecoding(DecoderBuffer *source_buffer) {
+  Clear();
+  uint32_t size_in_bytes;
+  if (!source_buffer->Decode(&size_in_bytes)) {
+    return false;
+  }
+
+  // Check that size_in_bytes is > 0 and a multiple of 4 as the encoder always
+  // encodes 32 bit elements.
+  if (size_in_bytes == 0 || size_in_bytes & 0x3) {
+    return false;
+  }
+  if (size_in_bytes > source_buffer->remaining_size()) {
+    return false;
+  }
+  const uint32_t num_32bit_elements = size_in_bytes / 4;
+  bits_.resize(num_32bit_elements);
+  if (!source_buffer->Decode(bits_.data(), size_in_bytes)) {
+    return false;
+  }
+  pos_ = bits_.begin();
+  num_used_bits_ = 0;
+  return true;
+}
+
+void DirectBitDecoder::Clear() {
+  bits_.clear();
+  num_used_bits_ = 0;
+  pos_ = bits_.end();
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.h b/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.h
new file mode 100644
index 000000000..b9fbc2d6f
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/direct_bit_decoder.h
@@ -0,0 +1,90 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides direct encoding of bits with arithmetic encoder interface.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_DECODER_H_
+
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+class DirectBitDecoder {
+ public:
+  DirectBitDecoder();
+  ~DirectBitDecoder();
+
+  // Sets |source_buffer| as the buffer to decode bits from.
+  bool StartDecoding(DecoderBuffer *source_buffer);
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit() {
+    const uint32_t selector = 1 << (31 - num_used_bits_);
+    if (pos_ == bits_.end()) {
+      return false;
+    }
+    const bool bit = *pos_ & selector;
+    ++num_used_bits_;
+    if (num_used_bits_ == 32) {
+      ++pos_;
+      num_used_bits_ = 0;
+    }
+    return bit;
+  }
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value) {
+    DRACO_DCHECK_EQ(true, nbits <= 32);
+    DRACO_DCHECK_EQ(true, nbits > 0);
+    const int remaining = 32 - num_used_bits_;
+    if (nbits <= remaining) {
+      if (pos_ == bits_.end()) {
+        *value = 0;
+        return;
+      }
+      *value = (*pos_ << num_used_bits_) >> (32 - nbits);
+      num_used_bits_ += nbits;
+      if (num_used_bits_ == 32) {
+        ++pos_;
+        num_used_bits_ = 0;
+      }
+    } else {
+      if (pos_ + 1 == bits_.end()) {
+        *value = 0;
+        return;
+      }
+      const uint32_t value_l = ((*pos_) << num_used_bits_);
+      num_used_bits_ = nbits - remaining;
+      ++pos_;
+      const uint32_t value_r = (*pos_) >> (32 - num_used_bits_);
+      *value = (value_l >> (32 - num_used_bits_ - remaining)) | value_r;
+    }
+  }
+
+  void EndDecoding() {}
+
+ private:
+  void Clear();
+
+  std::vector<uint32_t> bits_;
+  std::vector<uint32_t>::const_iterator pos_;
+  uint32_t num_used_bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.cc b/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.cc
new file mode 100644
index 000000000..d39143cf5
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.cc
@@ -0,0 +1,39 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/bit_coders/direct_bit_encoder.h"
+
+namespace draco {
+
+DirectBitEncoder::DirectBitEncoder() : local_bits_(0), num_local_bits_(0) {}
+
+DirectBitEncoder::~DirectBitEncoder() { Clear(); }
+
+void DirectBitEncoder::StartEncoding() { Clear(); }
+
+void DirectBitEncoder::EndEncoding(EncoderBuffer *target_buffer) {
+  bits_.push_back(local_bits_);
+  const uint32_t size_in_byte = static_cast<uint32_t>(bits_.size()) * 4;
+  target_buffer->Encode(size_in_byte);
+  target_buffer->Encode(bits_.data(), size_in_byte);
+  Clear();
+}
+
+void DirectBitEncoder::Clear() {
+  bits_.clear();
+  local_bits_ = 0;
+  num_local_bits_ = 0;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.h b/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.h
new file mode 100644
index 000000000..705b2ca93
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/direct_bit_encoder.h
@@ -0,0 +1,89 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides direct encoding of bits with arithmetic encoder interface.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_ENCODER_H_
+
+#include <vector>
+
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+class DirectBitEncoder {
+ public:
+  DirectBitEncoder();
+  ~DirectBitEncoder();
+
+  // Must be called before any Encode* function is called.
+  void StartEncoding();
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit) {
+    if (bit) {
+      local_bits_ |= 1 << (31 - num_local_bits_);
+    }
+    num_local_bits_++;
+    if (num_local_bits_ == 32) {
+      bits_.push_back(local_bits_);
+      num_local_bits_ = 0;
+      local_bits_ = 0;
+    }
+  }
+
+  // Encode |nbits| of |value|, starting from the least significant bit.
+  // |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+    DRACO_DCHECK_EQ(true, nbits <= 32);
+    DRACO_DCHECK_EQ(true, nbits > 0);
+
+    const int remaining = 32 - num_local_bits_;
+
+    // Make sure there are no leading bits that should not be encoded and
+    // start from here.
+    value = value << (32 - nbits);
+    if (nbits <= remaining) {
+      value = value >> num_local_bits_;
+      local_bits_ = local_bits_ | value;
+      num_local_bits_ += nbits;
+      if (num_local_bits_ == 32) {
+        bits_.push_back(local_bits_);
+        local_bits_ = 0;
+        num_local_bits_ = 0;
+      }
+    } else {
+      value = value >> (32 - nbits);
+      num_local_bits_ = nbits - remaining;
+      const uint32_t value_l = value >> num_local_bits_;
+      local_bits_ = local_bits_ | value_l;
+      bits_.push_back(local_bits_);
+      local_bits_ = value << (32 - num_local_bits_);
+    }
+  }
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer);
+
+ private:
+  void Clear();
+
+  std::vector<uint32_t> bits_;
+  uint32_t local_bits_;
+  uint32_t num_local_bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_DIRECT_BIT_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_decoder.h b/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_decoder.h
new file mode 100644
index 000000000..c14058b65
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_decoder.h
@@ -0,0 +1,77 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides direct encoding of bits with arithmetic encoder interface.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_DECODER_H_
+
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// See FoldedBit32Encoder for more details.
+template <class BitDecoderT>
+class FoldedBit32Decoder {
+ public:
+  FoldedBit32Decoder() {}
+  ~FoldedBit32Decoder() {}
+
+  // Sets |source_buffer| as the buffer to decode bits from.
+  bool StartDecoding(DecoderBuffer *source_buffer) {
+    for (int i = 0; i < 32; i++) {
+      if (!folded_number_decoders_[i].StartDecoding(source_buffer)) {
+        return false;
+      }
+    }
+    return bit_decoder_.StartDecoding(source_buffer);
+  }
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit() { return bit_decoder_.DecodeNextBit(); }
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value) {
+    uint32_t result = 0;
+    for (int i = 0; i < nbits; ++i) {
+      const bool bit = folded_number_decoders_[i].DecodeNextBit();
+      result = (result << 1) + bit;
+    }
+    *value = result;
+  }
+
+  void EndDecoding() {
+    for (int i = 0; i < 32; i++) {
+      folded_number_decoders_[i].EndDecoding();
+    }
+    bit_decoder_.EndDecoding();
+  }
+
+ private:
+  void Clear() {
+    for (int i = 0; i < 32; i++) {
+      folded_number_decoders_[i].Clear();
+    }
+    bit_decoder_.Clear();
+  }
+
+  std::array<BitDecoderT, 32> folded_number_decoders_;
+  BitDecoderT bit_decoder_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_encoder.h b/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_encoder.h
new file mode 100644
index 000000000..375b38a61
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/folded_integer_bit_encoder.h
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides direct encoding of bits with arithmetic encoder interface.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_ENCODER_H_
+
+#include <vector>
+
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// This coding scheme considers every bit of an (up to) 32bit integer as a
+// separate context. This can be a significant advantage when encoding numbers
+// where it is more likely that the front bits are zero.
+// The behavior is essentially the same as other arithmetic encoding schemes,
+// the only difference is that encoding and decoding of bits must be absolutely
+// symmetric, bits handed in by EncodeBit32 must be also decoded in this way.
+// This is the FoldedBit32Encoder, see also FoldedBit32Decoder.
+template <class BitEncoderT>
+class FoldedBit32Encoder {
+ public:
+  FoldedBit32Encoder() {}
+  ~FoldedBit32Encoder() {}
+
+  // Must be called before any Encode* function is called.
+  void StartEncoding() {
+    for (int i = 0; i < 32; i++) {
+      folded_number_encoders_[i].StartEncoding();
+    }
+    bit_encoder_.StartEncoding();
+  }
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit) { bit_encoder_.EncodeBit(bit); }
+
+  // Encode |nbits| of |value|, starting from the least significant bit.
+  // |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+    uint32_t selector = 1 << (nbits - 1);
+    for (int i = 0; i < nbits; i++) {
+      const bool bit = (value & selector);
+      folded_number_encoders_[i].EncodeBit(bit);
+      selector = selector >> 1;
+    }
+  }
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer) {
+    for (int i = 0; i < 32; i++) {
+      folded_number_encoders_[i].EndEncoding(target_buffer);
+    }
+    bit_encoder_.EndEncoding(target_buffer);
+  }
+
+ private:
+  void Clear() {
+    for (int i = 0; i < 32; i++) {
+      folded_number_encoders_[i].Clear();
+    }
+    bit_encoder_.Clear();
+  }
+
+  std::array<BitEncoderT, 32> folded_number_encoders_;
+  BitEncoderT bit_encoder_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_FOLDED_INTEGER_BIT_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.cc b/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.cc
new file mode 100644
index 000000000..a9b8fb9e9
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.cc
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/varint_decoding.h"
+
+namespace draco {
+
+RAnsBitDecoder::RAnsBitDecoder() : prob_zero_(0) {}
+
+RAnsBitDecoder::~RAnsBitDecoder() { Clear(); }
+
+bool RAnsBitDecoder::StartDecoding(DecoderBuffer *source_buffer) {
+  Clear();
+
+  if (!source_buffer->Decode(&prob_zero_)) {
+    return false;
+  }
+
+  uint32_t size_in_bytes;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (source_buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    if (!source_buffer->Decode(&size_in_bytes)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&size_in_bytes, source_buffer)) {
+      return false;
+    }
+  }
+
+  if (size_in_bytes > source_buffer->remaining_size()) {
+    return false;
+  }
+
+  if (ans_read_init(&ans_decoder_,
+                    reinterpret_cast<uint8_t *>(
+                        const_cast<char *>(source_buffer->data_head())),
+                    size_in_bytes) != 0) {
+    return false;
+  }
+  source_buffer->Advance(size_in_bytes);
+  return true;
+}
+
+bool RAnsBitDecoder::DecodeNextBit() {
+  const uint8_t bit = rabs_read(&ans_decoder_, prob_zero_);
+  return bit > 0;
+}
+
+void RAnsBitDecoder::DecodeLeastSignificantBits32(int nbits, uint32_t *value) {
+  DRACO_DCHECK_EQ(true, nbits <= 32);
+  DRACO_DCHECK_EQ(true, nbits > 0);
+
+  uint32_t result = 0;
+  while (nbits) {
+    result = (result << 1) + DecodeNextBit();
+    --nbits;
+  }
+  *value = result;
+}
+
+void RAnsBitDecoder::Clear() { ans_read_end(&ans_decoder_); }
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.h b/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.h
new file mode 100644
index 000000000..25d243eac
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/rans_bit_decoder.h
@@ -0,0 +1,55 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides basic classes and functions for rANS coding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_DECODER_H_
+
+#include <vector>
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for decoding a sequence of bits that were encoded with RAnsBitEncoder.
+class RAnsBitDecoder {
+ public:
+  RAnsBitDecoder();
+  ~RAnsBitDecoder();
+
+  // Sets |source_buffer| as the buffer to decode bits from.
+  // Returns false when the data is invalid.
+  bool StartDecoding(DecoderBuffer *source_buffer);
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit();
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value);
+
+  void EndDecoding() {}
+
+ private:
+  void Clear();
+
+  AnsDecoder ans_decoder_;
+  uint8_t prob_zero_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.cc b/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.cc
new file mode 100644
index 000000000..8d00ea352
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.cc
@@ -0,0 +1,125 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+RAnsBitEncoder::RAnsBitEncoder() : local_bits_(0), num_local_bits_(0) {}
+
+RAnsBitEncoder::~RAnsBitEncoder() { Clear(); }
+
+void RAnsBitEncoder::StartEncoding() { Clear(); }
+
+void RAnsBitEncoder::EncodeBit(bool bit) {
+  if (bit) {
+    bit_counts_[1]++;
+    local_bits_ |= 1 << num_local_bits_;
+  } else {
+    bit_counts_[0]++;
+  }
+  num_local_bits_++;
+
+  if (num_local_bits_ == 32) {
+    bits_.push_back(local_bits_);
+    num_local_bits_ = 0;
+    local_bits_ = 0;
+  }
+}
+
+void RAnsBitEncoder::EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+  DRACO_DCHECK_EQ(true, nbits <= 32);
+  DRACO_DCHECK_EQ(true, nbits > 0);
+
+  const uint32_t reversed = ReverseBits32(value) >> (32 - nbits);
+  const int ones = CountOneBits32(reversed);
+  bit_counts_[0] += (nbits - ones);
+  bit_counts_[1] += ones;
+
+  const int remaining = 32 - num_local_bits_;
+
+  if (nbits <= remaining) {
+    CopyBits32(&local_bits_, num_local_bits_, reversed, 0, nbits);
+    num_local_bits_ += nbits;
+    if (num_local_bits_ == 32) {
+      bits_.push_back(local_bits_);
+      local_bits_ = 0;
+      num_local_bits_ = 0;
+    }
+  } else {
+    CopyBits32(&local_bits_, num_local_bits_, reversed, 0, remaining);
+    bits_.push_back(local_bits_);
+    local_bits_ = 0;
+    CopyBits32(&local_bits_, 0, reversed, remaining, nbits - remaining);
+    num_local_bits_ = nbits - remaining;
+  }
+}
+
+void RAnsBitEncoder::EndEncoding(EncoderBuffer *target_buffer) {
+  uint64_t total = bit_counts_[1] + bit_counts_[0];
+  if (total == 0) {
+    total++;
+  }
+
+  // The probability interval [0,1] is mapped to values of [0, 256]. However,
+  // the coding scheme can not deal with probabilities of 0 or 1, which is why
+  // we must clamp the values to interval [1, 255]. Specifically 128
+  // corresponds to 0.5 exactly. And the value can be given as uint8_t.
+  const uint32_t zero_prob_raw = static_cast<uint32_t>(
+      ((bit_counts_[0] / static_cast<double>(total)) * 256.0) + 0.5);
+
+  uint8_t zero_prob = 255;
+  if (zero_prob_raw < 255) {
+    zero_prob = static_cast<uint8_t>(zero_prob_raw);
+  }
+
+  zero_prob += (zero_prob == 0);
+
+  // Space for 32 bit integer and some extra space.
+  std::vector<uint8_t> buffer((bits_.size() + 8) * 8);
+  AnsCoder ans_coder;
+  ans_write_init(&ans_coder, buffer.data());
+
+  for (int i = num_local_bits_ - 1; i >= 0; --i) {
+    const uint8_t bit = (local_bits_ >> i) & 1;
+    rabs_write(&ans_coder, bit, zero_prob);
+  }
+  for (auto it = bits_.rbegin(); it != bits_.rend(); ++it) {
+    const uint32_t bits = *it;
+    for (int i = 31; i >= 0; --i) {
+      const uint8_t bit = (bits >> i) & 1;
+      rabs_write(&ans_coder, bit, zero_prob);
+    }
+  }
+
+  const int size_in_bytes = ans_write_end(&ans_coder);
+  target_buffer->Encode(zero_prob);
+  EncodeVarint(static_cast<uint32_t>(size_in_bytes), target_buffer);
+  target_buffer->Encode(buffer.data(), size_in_bytes);
+
+  Clear();
+}
+
+void RAnsBitEncoder::Clear() {
+  bit_counts_.assign(2, 0);
+  bits_.clear();
+  local_bits_ = 0;
+  num_local_bits_ = 0;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.h b/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.h
new file mode 100644
index 000000000..1993dd3d3
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/rans_bit_encoder.h
@@ -0,0 +1,57 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides basic classes and functions for rANS coding.
+#ifndef DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_ENCODER_H_
+
+#include <vector>
+
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Class for encoding a sequence of bits using rANS. The probability table used
+// to encode the bits is based off the total counts of bits.
+// TODO(fgalligan): Investigate using an adaptive table for more compression.
+class RAnsBitEncoder {
+ public:
+  RAnsBitEncoder();
+  ~RAnsBitEncoder();
+
+  // Must be called before any Encode* function is called.
+  void StartEncoding();
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit);
+
+  // Encode |nbits| of |value|, starting from the least significant bit.
+  // |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value);
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer);
+
+ private:
+  void Clear();
+
+  std::vector<uint64_t> bit_counts_;
+  std::vector<uint32_t> bits_;
+  uint32_t local_bits_;
+  uint32_t num_local_bits_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_RANS_BIT_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/bit_coders/rans_coding_test.cc b/contrib/draco/src/draco/compression/bit_coders/rans_coding_test.cc
new file mode 100644
index 000000000..9509ad9f3
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/rans_coding_test.cc
@@ -0,0 +1,9 @@
+#include "draco/compression/bit_coders/adaptive_rans_bit_decoder.h"
+#include "draco/compression/bit_coders/adaptive_rans_bit_encoder.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/core/draco_test_base.h"
+
+// Just including rans_coding.h and adaptive_rans_coding.h gets an asan error
+// when compiling (blaze test :rans_coding_test --config=asan)
+TEST(RansCodingTest, LinkerTest) {}
diff --git a/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.cc b/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.cc
new file mode 100644
index 000000000..8ed50ef92
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.cc
@@ -0,0 +1,49 @@
+#include "draco/compression/bit_coders/symbol_bit_decoder.h"
+
+#include "draco/compression/entropy/symbol_decoding.h"
+
+namespace draco {
+
+bool SymbolBitDecoder::StartDecoding(DecoderBuffer *source_buffer) {
+  uint32_t size;
+  if (!source_buffer->Decode(&size)) {
+    return false;
+  }
+
+  symbols_.resize(size);
+  if (!DecodeSymbols(size, 1, source_buffer, symbols_.data())) {
+    return false;
+  }
+  std::reverse(symbols_.begin(), symbols_.end());
+  return true;
+}
+
+bool SymbolBitDecoder::DecodeNextBit() {
+  uint32_t symbol;
+  DecodeLeastSignificantBits32(1, &symbol);
+  DRACO_DCHECK(symbol == 0 || symbol == 1);
+  return symbol == 1;
+}
+
+void SymbolBitDecoder::DecodeLeastSignificantBits32(int nbits,
+                                                    uint32_t *value) {
+  DRACO_DCHECK_LE(1, nbits);
+  DRACO_DCHECK_LE(nbits, 32);
+  DRACO_DCHECK_NE(value, nullptr);
+  // Testing: check to make sure there is something to decode.
+  DRACO_DCHECK_GT(symbols_.size(), 0);
+
+  (*value) = symbols_.back();
+  symbols_.pop_back();
+
+  const int discarded_bits = 32 - nbits;
+  (*value) <<= discarded_bits;
+  (*value) >>= discarded_bits;
+}
+
+void SymbolBitDecoder::Clear() {
+  symbols_.clear();
+  symbols_.shrink_to_fit();
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.h b/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.h
new file mode 100644
index 000000000..909d7174f
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/symbol_bit_decoder.h
@@ -0,0 +1,36 @@
+#ifndef DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_DECODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_DECODER_H_
+
+#include <algorithm>
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// Class for decoding bits using the symbol entropy encoding. Wraps
+// |DecodeSymbols|. Note that this uses a symbol-based encoding scheme for
+// encoding bits.
+class SymbolBitDecoder {
+ public:
+  // Sets |source_buffer| as the buffer to decode bits from.
+  bool StartDecoding(DecoderBuffer *source_buffer);
+
+  // Decode one bit. Returns true if the bit is a 1, otherwise false.
+  bool DecodeNextBit();
+
+  // Decode the next |nbits| and return the sequence in |value|. |nbits| must be
+  // > 0 and <= 32.
+  void DecodeLeastSignificantBits32(int nbits, uint32_t *value);
+
+  void EndDecoding() { Clear(); }
+
+ private:
+  void Clear();
+
+  std::vector<uint32_t> symbols_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.cc b/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.cc
new file mode 100644
index 000000000..83834236f
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.cc
@@ -0,0 +1,30 @@
+#include "draco/compression/bit_coders/symbol_bit_encoder.h"
+
+#include "draco/compression/entropy/symbol_encoding.h"
+
+namespace draco {
+
+void SymbolBitEncoder::EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+  DRACO_DCHECK_LE(1, nbits);
+  DRACO_DCHECK_LE(nbits, 32);
+
+  const int discarded_bits = 32 - nbits;
+  value <<= discarded_bits;
+  value >>= discarded_bits;
+
+  symbols_.push_back(value);
+}
+
+void SymbolBitEncoder::EndEncoding(EncoderBuffer *target_buffer) {
+  target_buffer->Encode(static_cast<uint32_t>(symbols_.size()));
+  EncodeSymbols(symbols_.data(), static_cast<int>(symbols_.size()), 1, nullptr,
+                target_buffer);
+  Clear();
+}
+
+void SymbolBitEncoder::Clear() {
+  symbols_.clear();
+  symbols_.shrink_to_fit();
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.h b/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.h
new file mode 100644
index 000000000..7f1570c1a
--- /dev/null
+++ b/contrib/draco/src/draco/compression/bit_coders/symbol_bit_encoder.h
@@ -0,0 +1,36 @@
+#ifndef DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_ENCODER_H_
+#define DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_ENCODER_H_
+
+#include <algorithm>
+#include <vector>
+
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Class for encoding bits using the symbol entropy encoding. Wraps
+// |EncodeSymbols|. Note that this uses a symbol-based encoding scheme for
+// encoding bits.
+class SymbolBitEncoder {
+ public:
+  // Must be called before any Encode* function is called.
+  void StartEncoding() { Clear(); }
+
+  // Encode one bit. If |bit| is true encode a 1, otherwise encode a 0.
+  void EncodeBit(bool bit) { EncodeLeastSignificantBits32(1, bit ? 1 : 0); }
+
+  // Encode |nbits| LSBs of |value| as a symbol. |nbits| must be > 0 and <= 32.
+  void EncodeLeastSignificantBits32(int nbits, uint32_t value);
+
+  // Ends the bit encoding and stores the result into the target_buffer.
+  void EndEncoding(EncoderBuffer *target_buffer);
+
+ private:
+  void Clear();
+
+  std::vector<uint32_t> symbols_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_BIT_CODERS_SYMBOL_BIT_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/config/compression_shared.h b/contrib/draco/src/draco/compression/config/compression_shared.h
new file mode 100644
index 000000000..c43f303bd
--- /dev/null
+++ b/contrib/draco/src/draco/compression/config/compression_shared.h
@@ -0,0 +1,155 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_CONFIG_COMPRESSION_SHARED_H_
+#define DRACO_COMPRESSION_CONFIG_COMPRESSION_SHARED_H_
+
+#include <stdint.h>
+
+#include "draco/core/macros.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Latest Draco bit-stream version.
+static constexpr uint8_t kDracoPointCloudBitstreamVersionMajor = 2;
+static constexpr uint8_t kDracoPointCloudBitstreamVersionMinor = 3;
+static constexpr uint8_t kDracoMeshBitstreamVersionMajor = 2;
+static constexpr uint8_t kDracoMeshBitstreamVersionMinor = 2;
+
+// Concatenated latest bit-stream version.
+static constexpr uint16_t kDracoPointCloudBitstreamVersion =
+    DRACO_BITSTREAM_VERSION(kDracoPointCloudBitstreamVersionMajor,
+                            kDracoPointCloudBitstreamVersionMinor);
+
+static constexpr uint16_t kDracoMeshBitstreamVersion = DRACO_BITSTREAM_VERSION(
+    kDracoMeshBitstreamVersionMajor, kDracoMeshBitstreamVersionMinor);
+
+// Currently, we support point cloud and triangular mesh encoding.
+// TODO(draco-eng) Convert enum to enum class (safety, not performance).
+enum EncodedGeometryType {
+  INVALID_GEOMETRY_TYPE = -1,
+  POINT_CLOUD = 0,
+  TRIANGULAR_MESH,
+  NUM_ENCODED_GEOMETRY_TYPES
+};
+
+// List of encoding methods for point clouds.
+enum PointCloudEncodingMethod {
+  POINT_CLOUD_SEQUENTIAL_ENCODING = 0,
+  POINT_CLOUD_KD_TREE_ENCODING
+};
+
+// List of encoding methods for meshes.
+enum MeshEncoderMethod {
+  MESH_SEQUENTIAL_ENCODING = 0,
+  MESH_EDGEBREAKER_ENCODING,
+};
+
+// List of various attribute encoders supported by our framework. The entries
+// are used as unique identifiers of the encoders and their values should not
+// be changed!
+enum AttributeEncoderType {
+  BASIC_ATTRIBUTE_ENCODER = 0,
+  MESH_TRAVERSAL_ATTRIBUTE_ENCODER,
+  KD_TREE_ATTRIBUTE_ENCODER,
+};
+
+// List of various sequential attribute encoder/decoders that can be used in our
+// pipeline. The values represent unique identifiers used by the decoder and
+// they should not be changed.
+enum SequentialAttributeEncoderType {
+  SEQUENTIAL_ATTRIBUTE_ENCODER_GENERIC = 0,
+  SEQUENTIAL_ATTRIBUTE_ENCODER_INTEGER,
+  SEQUENTIAL_ATTRIBUTE_ENCODER_QUANTIZATION,
+  SEQUENTIAL_ATTRIBUTE_ENCODER_NORMALS,
+};
+
+// List of all prediction methods currently supported by our framework.
+enum PredictionSchemeMethod {
+  // Special value indicating that no prediction scheme was used.
+  PREDICTION_NONE = -2,
+  // Used when no specific prediction scheme is required.
+  PREDICTION_UNDEFINED = -1,
+  PREDICTION_DIFFERENCE = 0,
+  MESH_PREDICTION_PARALLELOGRAM = 1,
+  MESH_PREDICTION_MULTI_PARALLELOGRAM = 2,
+  MESH_PREDICTION_TEX_COORDS_DEPRECATED = 3,
+  MESH_PREDICTION_CONSTRAINED_MULTI_PARALLELOGRAM = 4,
+  MESH_PREDICTION_TEX_COORDS_PORTABLE = 5,
+  MESH_PREDICTION_GEOMETRIC_NORMAL = 6,
+  NUM_PREDICTION_SCHEMES
+};
+
+// List of all prediction scheme transforms used by our framework.
+enum PredictionSchemeTransformType {
+  PREDICTION_TRANSFORM_NONE = -1,
+  // Basic delta transform where the prediction is computed as difference the
+  // predicted and original value.
+  PREDICTION_TRANSFORM_DELTA = 0,
+  // An improved delta transform where all computed delta values are wrapped
+  // around a fixed interval which lowers the entropy.
+  PREDICTION_TRANSFORM_WRAP = 1,
+  // Specialized transform for normal coordinates using inverted tiles.
+  PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON = 2,
+  // Specialized transform for normal coordinates using canonicalized inverted
+  // tiles.
+  PREDICTION_TRANSFORM_NORMAL_OCTAHEDRON_CANONICALIZED = 3,
+  // The number of valid (non-negative) prediction scheme transform types.
+  NUM_PREDICTION_SCHEME_TRANSFORM_TYPES
+};
+
+// List of all mesh traversal methods supported by Draco framework.
+enum MeshTraversalMethod {
+  MESH_TRAVERSAL_DEPTH_FIRST = 0,
+  MESH_TRAVERSAL_PREDICTION_DEGREE = 1,
+  NUM_TRAVERSAL_METHODS
+};
+
+// List of all variant of the edgebreaker method that is used for compression
+// of mesh connectivity.
+enum MeshEdgebreakerConnectivityEncodingMethod {
+  MESH_EDGEBREAKER_STANDARD_ENCODING = 0,
+  MESH_EDGEBREAKER_PREDICTIVE_ENCODING = 1,  // Deprecated.
+  MESH_EDGEBREAKER_VALENCE_ENCODING = 2,
+};
+
+// Draco header V1
+struct DracoHeader {
+  int8_t draco_string[5];
+  uint8_t version_major;
+  uint8_t version_minor;
+  uint8_t encoder_type;
+  uint8_t encoder_method;
+  uint16_t flags;
+};
+
+enum NormalPredictionMode {
+  ONE_TRIANGLE = 0,  // To be deprecated.
+  TRIANGLE_AREA = 1,
+};
+
+// Different methods used for symbol entropy encoding.
+enum SymbolCodingMethod {
+  SYMBOL_CODING_TAGGED = 0,
+  SYMBOL_CODING_RAW = 1,
+  NUM_SYMBOL_CODING_METHODS,
+};
+
+// Mask for setting and getting the bit for metadata in |flags| of header.
+#define METADATA_FLAG_MASK 0x8000
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_COMPRESSION_SHARED_H_
diff --git a/contrib/draco/src/draco/compression/config/decoder_options.h b/contrib/draco/src/draco/compression/config/decoder_options.h
new file mode 100644
index 000000000..3b3889993
--- /dev/null
+++ b/contrib/draco/src/draco/compression/config/decoder_options.h
@@ -0,0 +1,34 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_CONFIG_DECODER_OPTIONS_H_
+#define DRACO_COMPRESSION_CONFIG_DECODER_OPTIONS_H_
+
+#include <map>
+#include <memory>
+
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/compression/config/draco_options.h"
+
+namespace draco {
+
+// Class containing options that can be passed to PointCloudDecoder to control
+// decoding of the input geometry. The options can be specified either for the
+// whole geometry or for a specific attribute type. Each option is identified
+// by a unique name stored as an std::string.
+typedef DracoOptions<GeometryAttribute::Type> DecoderOptions;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_DECODER_OPTIONS_H_
diff --git a/contrib/draco/src/draco/compression/config/decoder_options_test.cc b/contrib/draco/src/draco/compression/config/decoder_options_test.cc
new file mode 100644
index 000000000..a5cd7f106
--- /dev/null
+++ b/contrib/draco/src/draco/compression/config/decoder_options_test.cc
@@ -0,0 +1,67 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/config/decoder_options.h"
+
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+class DecoderOptionsTest : public ::testing::Test {
+ protected:
+  DecoderOptionsTest() {}
+};
+
+TEST_F(DecoderOptionsTest, TestOptions) {
+  // This test verifies that we can update global and attribute options of the
+  // DecoderOptions class instance.
+  draco::DecoderOptions options;
+  options.SetGlobalInt("test", 3);
+  ASSERT_EQ(options.GetGlobalInt("test", -1), 3);
+
+  options.SetAttributeInt(draco::GeometryAttribute::POSITION, "test", 1);
+  options.SetAttributeInt(draco::GeometryAttribute::GENERIC, "test", 2);
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::TEX_COORD, "test", -1),
+      3);
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::POSITION, "test", -1),
+      1);
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::GENERIC, "test", -1),
+      2);
+}
+
+TEST_F(DecoderOptionsTest, TestAttributeOptionsAccessors) {
+  // This test verifies that we can query options stored in DecoderOptions
+  // class instance.
+  draco::DecoderOptions options;
+  options.SetGlobalInt("test", 1);
+  options.SetAttributeInt(draco::GeometryAttribute::POSITION, "test", 2);
+  options.SetAttributeInt(draco::GeometryAttribute::TEX_COORD, "test", 3);
+
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::POSITION, "test", -1),
+      2);
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::POSITION, "test2", -1),
+      -1);
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::TEX_COORD, "test", -1),
+      3);
+  ASSERT_EQ(
+      options.GetAttributeInt(draco::GeometryAttribute::NORMAL, "test", -1), 1);
+}
+
+}  // namespace
diff --git a/contrib/draco/src/draco/compression/config/draco_options.h b/contrib/draco/src/draco/compression/config/draco_options.h
new file mode 100644
index 000000000..2bd4a3b67
--- /dev/null
+++ b/contrib/draco/src/draco/compression/config/draco_options.h
@@ -0,0 +1,249 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_CONFIG_DRACO_OPTIONS_H_
+#define DRACO_COMPRESSION_CONFIG_DRACO_OPTIONS_H_
+
+#include <map>
+#include <memory>
+
+#include "draco/core/options.h"
+
+namespace draco {
+
+// Base option class used to control encoding and decoding. The geometry coding
+// can be controlled through the following options:
+//   1. Global options - Options specific to overall geometry or options common
+//                       for all attributes
+//   2. Per attribute options - Options specific to a given attribute.
+//                              Each attribute is identified by the template
+//                              argument AttributeKeyT that can be for example
+//                              the attribute type or the attribute id.
+//
+// Example:
+//
+//   DracoOptions<AttributeKey> options;
+//
+//   // Set an option common for all attributes.
+//   options.SetGlobalInt("some_option_name", 2);
+//
+//   // Geometry with two attributes.
+//   AttributeKey att_key0 = in_key0;
+//   AttributeKey att_key1 = in_key1;
+//
+//   options.SetAttributeInt(att_key0, "some_option_name", 3);
+//
+//   options.GetAttributeInt(att_key0, "some_option_name");  // Returns 3
+//   options.GetAttributeInt(att_key1, "some_option_name");  // Returns 2
+//   options.GetGlobalInt("some_option_name");               // Returns 2
+//
+template <typename AttributeKeyT>
+class DracoOptions {
+ public:
+  typedef AttributeKeyT AttributeKey;
+
+  // Get an option for a specific attribute key. If the option is not found in
+  // an attribute specific storage, the implementation will return a global
+  // option of the given name (if available). If the option is not found, the
+  // provided default value |default_val| is returned instead.
+  int GetAttributeInt(const AttributeKey &att_key, const std::string &name,
+                      int default_val) const;
+
+  // Sets an option for a specific attribute key.
+  void SetAttributeInt(const AttributeKey &att_key, const std::string &name,
+                       int val);
+
+  float GetAttributeFloat(const AttributeKey &att_key, const std::string &name,
+                          float default_val) const;
+  void SetAttributeFloat(const AttributeKey &att_key, const std::string &name,
+                         float val);
+  bool GetAttributeBool(const AttributeKey &att_key, const std::string &name,
+                        bool default_val) const;
+  void SetAttributeBool(const AttributeKey &att_key, const std::string &name,
+                        bool val);
+  template <typename DataTypeT>
+  bool GetAttributeVector(const AttributeKey &att_key, const std::string &name,
+                          int num_dims, DataTypeT *val) const;
+  template <typename DataTypeT>
+  void SetAttributeVector(const AttributeKey &att_key, const std::string &name,
+                          int num_dims, const DataTypeT *val);
+
+  bool IsAttributeOptionSet(const AttributeKey &att_key,
+                            const std::string &name) const;
+
+  // Gets/sets a global option that is not specific to any attribute.
+  int GetGlobalInt(const std::string &name, int default_val) const {
+    return global_options_.GetInt(name, default_val);
+  }
+  void SetGlobalInt(const std::string &name, int val) {
+    global_options_.SetInt(name, val);
+  }
+  float GetGlobalFloat(const std::string &name, float default_val) const {
+    return global_options_.GetFloat(name, default_val);
+  }
+  void SetGlobalFloat(const std::string &name, float val) {
+    global_options_.SetFloat(name, val);
+  }
+  bool GetGlobalBool(const std::string &name, bool default_val) const {
+    return global_options_.GetBool(name, default_val);
+  }
+  void SetGlobalBool(const std::string &name, bool val) {
+    global_options_.SetBool(name, val);
+  }
+  template <typename DataTypeT>
+  bool GetGlobalVector(const std::string &name, int num_dims,
+                       DataTypeT *val) const {
+    return global_options_.GetVector(name, num_dims, val);
+  }
+  template <typename DataTypeT>
+  void SetGlobalVector(const std::string &name, int num_dims,
+                       const DataTypeT *val) {
+    global_options_.SetVector(name, val, num_dims);
+  }
+  bool IsGlobalOptionSet(const std::string &name) const {
+    return global_options_.IsOptionSet(name);
+  }
+
+  // Sets or replaces attribute options with the provided |options|.
+  void SetAttributeOptions(const AttributeKey &att_key, const Options &options);
+  void SetGlobalOptions(const Options &options) { global_options_ = options; }
+
+  // Returns |Options| instance for the specified options class if it exists.
+  const Options *FindAttributeOptions(const AttributeKeyT &att_key) const;
+  const Options &GetGlobalOptions() const { return global_options_; }
+
+ private:
+  Options *GetAttributeOptions(const AttributeKeyT &att_key);
+
+  Options global_options_;
+
+  // Storage for options related to geometry attributes.
+  std::map<AttributeKey, Options> attribute_options_;
+};
+
+template <typename AttributeKeyT>
+const Options *DracoOptions<AttributeKeyT>::FindAttributeOptions(
+    const AttributeKeyT &att_key) const {
+  auto it = attribute_options_.find(att_key);
+  if (it == attribute_options_.end()) {
+    return nullptr;
+  }
+  return &it->second;
+}
+
+template <typename AttributeKeyT>
+Options *DracoOptions<AttributeKeyT>::GetAttributeOptions(
+    const AttributeKeyT &att_key) {
+  auto it = attribute_options_.find(att_key);
+  if (it != attribute_options_.end()) {
+    return &it->second;
+  }
+  Options new_options;
+  it = attribute_options_.insert(std::make_pair(att_key, new_options)).first;
+  return &it->second;
+}
+
+template <typename AttributeKeyT>
+int DracoOptions<AttributeKeyT>::GetAttributeInt(const AttributeKeyT &att_key,
+                                                 const std::string &name,
+                                                 int default_val) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options && att_options->IsOptionSet(name)) {
+    return att_options->GetInt(name, default_val);
+  }
+  return global_options_.GetInt(name, default_val);
+}
+
+template <typename AttributeKeyT>
+void DracoOptions<AttributeKeyT>::SetAttributeInt(const AttributeKeyT &att_key,
+                                                  const std::string &name,
+                                                  int val) {
+  GetAttributeOptions(att_key)->SetInt(name, val);
+}
+
+template <typename AttributeKeyT>
+float DracoOptions<AttributeKeyT>::GetAttributeFloat(
+    const AttributeKeyT &att_key, const std::string &name,
+    float default_val) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options && att_options->IsOptionSet(name)) {
+    return att_options->GetFloat(name, default_val);
+  }
+  return global_options_.GetFloat(name, default_val);
+}
+
+template <typename AttributeKeyT>
+void DracoOptions<AttributeKeyT>::SetAttributeFloat(
+    const AttributeKeyT &att_key, const std::string &name, float val) {
+  GetAttributeOptions(att_key)->SetFloat(name, val);
+}
+
+template <typename AttributeKeyT>
+bool DracoOptions<AttributeKeyT>::GetAttributeBool(const AttributeKeyT &att_key,
+                                                   const std::string &name,
+                                                   bool default_val) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options && att_options->IsOptionSet(name)) {
+    return att_options->GetBool(name, default_val);
+  }
+  return global_options_.GetBool(name, default_val);
+}
+
+template <typename AttributeKeyT>
+void DracoOptions<AttributeKeyT>::SetAttributeBool(const AttributeKeyT &att_key,
+                                                   const std::string &name,
+                                                   bool val) {
+  GetAttributeOptions(att_key)->SetBool(name, val);
+}
+
+template <typename AttributeKeyT>
+template <typename DataTypeT>
+bool DracoOptions<AttributeKeyT>::GetAttributeVector(
+    const AttributeKey &att_key, const std::string &name, int num_dims,
+    DataTypeT *val) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options && att_options->IsOptionSet(name)) {
+    return att_options->GetVector(name, num_dims, val);
+  }
+  return global_options_.GetVector(name, num_dims, val);
+}
+
+template <typename AttributeKeyT>
+template <typename DataTypeT>
+void DracoOptions<AttributeKeyT>::SetAttributeVector(
+    const AttributeKey &att_key, const std::string &name, int num_dims,
+    const DataTypeT *val) {
+  GetAttributeOptions(att_key)->SetVector(name, val, num_dims);
+}
+
+template <typename AttributeKeyT>
+bool DracoOptions<AttributeKeyT>::IsAttributeOptionSet(
+    const AttributeKey &att_key, const std::string &name) const {
+  const Options *const att_options = FindAttributeOptions(att_key);
+  if (att_options) {
+    return att_options->IsOptionSet(name);
+  }
+  return global_options_.IsOptionSet(name);
+}
+
+template <typename AttributeKeyT>
+void DracoOptions<AttributeKeyT>::SetAttributeOptions(
+    const AttributeKey &att_key, const Options &options) {
+  Options *att_options = GetAttributeOptions(att_key);
+  *att_options = options;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_DRACO_OPTIONS_H_
diff --git a/contrib/draco/src/draco/compression/config/encoder_options.h b/contrib/draco/src/draco/compression/config/encoder_options.h
new file mode 100644
index 000000000..ed1b02068
--- /dev/null
+++ b/contrib/draco/src/draco/compression/config/encoder_options.h
@@ -0,0 +1,97 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_CONFIG_ENCODER_OPTIONS_H_
+#define DRACO_COMPRESSION_CONFIG_ENCODER_OPTIONS_H_
+
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/compression/config/draco_options.h"
+#include "draco/compression/config/encoding_features.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// EncoderOptions allow users to specify so called feature options that are used
+// to inform the encoder which encoding features can be used (i.e. which
+// features are going to be available to the decoder).
+template <typename AttributeKeyT>
+class EncoderOptionsBase : public DracoOptions<AttributeKeyT> {
+ public:
+  static EncoderOptionsBase CreateDefaultOptions() {
+    EncoderOptionsBase options;
+#ifdef DRACO_STANDARD_EDGEBREAKER_SUPPORTED
+    options.SetSupportedFeature(features::kEdgebreaker, true);
+#endif
+#ifdef DRACO_PREDICTIVE_EDGEBREAKER_SUPPORTED
+    options.SetSupportedFeature(features::kPredictiveEdgebreaker, true);
+#endif
+    return options;
+  }
+  static EncoderOptionsBase CreateEmptyOptions() {
+    return EncoderOptionsBase();
+  }
+
+  // Returns speed options with default value of 5.
+  int GetEncodingSpeed() const {
+    return this->GetGlobalInt("encoding_speed", 5);
+  }
+  int GetDecodingSpeed() const {
+    return this->GetGlobalInt("decoding_speed", 5);
+  }
+
+  // Returns the maximum speed for both encoding/decoding.
+  int GetSpeed() const {
+    const int encoding_speed = this->GetGlobalInt("encoding_speed", -1);
+    const int decoding_speed = this->GetGlobalInt("decoding_speed", -1);
+    const int max_speed = std::max(encoding_speed, decoding_speed);
+    if (max_speed == -1) {
+      return 5;  // Default value.
+    }
+    return max_speed;
+  }
+
+  void SetSpeed(int encoding_speed, int decoding_speed) {
+    this->SetGlobalInt("encoding_speed", encoding_speed);
+    this->SetGlobalInt("decoding_speed", decoding_speed);
+  }
+
+  // Sets a given feature as supported or unsupported by the target decoder.
+  // Encoder will always use only supported features when encoding the input
+  // geometry.
+  void SetSupportedFeature(const std::string &name, bool supported) {
+    feature_options_.SetBool(name, supported);
+  }
+  bool IsFeatureSupported(const std::string &name) const {
+    return feature_options_.GetBool(name);
+  }
+
+  void SetFeatureOptions(const Options &options) { feature_options_ = options; }
+  const Options &GetFeaturelOptions() const { return feature_options_; }
+
+ private:
+  // Use helper methods to construct the encoder options.
+  // See CreateDefaultOptions();
+  EncoderOptionsBase() {}
+
+  // List of supported/unsupported features that can be used by the encoder.
+  Options feature_options_;
+};
+
+// Encoder options where attributes are identified by their attribute id.
+// Used to set options that are specific to a given geometry.
+typedef EncoderOptionsBase<int32_t> EncoderOptions;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_ENCODER_OPTIONS_H_
diff --git a/contrib/draco/src/draco/compression/config/encoding_features.h b/contrib/draco/src/draco/compression/config/encoding_features.h
new file mode 100644
index 000000000..d6a8b7128
--- /dev/null
+++ b/contrib/draco/src/draco/compression/config/encoding_features.h
@@ -0,0 +1,39 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File provides helpful macros that define features available for encoding
+// the input of the input geometry. These macros can be used as an input in
+// the EncoderOptions::SetSupportedFeature() method instead of the text.
+// The most recent set of features supported
+// by the default implementation is:
+//
+// kEdgebreaker
+//     - edgebreaker method for encoding meshes.
+// kPredictiveEdgebreaker
+//     - advanced version of the edgebreaker method (slower but better
+//       compression).
+//
+#ifndef DRACO_COMPRESSION_CONFIG_ENCODING_FEATURES_H_
+#define DRACO_COMPRESSION_CONFIG_ENCODING_FEATURES_H_
+
+namespace draco {
+namespace features {
+
+constexpr const char *kEdgebreaker = "standard_edgebreaker";
+constexpr const char *kPredictiveEdgebreaker = "predictive_edgebreaker";
+
+}  // namespace features
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_CONFIG_ENCODING_FEATURES_H_
diff --git a/contrib/draco/src/draco/compression/decode.cc b/contrib/draco/src/draco/compression/decode.cc
new file mode 100644
index 000000000..92ae4ff66
--- /dev/null
+++ b/contrib/draco/src/draco/compression/decode.cc
@@ -0,0 +1,135 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/decode.h"
+
+#include "draco/compression/config/compression_shared.h"
+
+#ifdef DRACO_MESH_COMPRESSION_SUPPORTED
+#include "draco/compression/mesh/mesh_edgebreaker_decoder.h"
+#include "draco/compression/mesh/mesh_sequential_decoder.h"
+#endif
+
+#ifdef DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED
+#include "draco/compression/point_cloud/point_cloud_kd_tree_decoder.h"
+#include "draco/compression/point_cloud/point_cloud_sequential_decoder.h"
+#endif
+
+namespace draco {
+
+#ifdef DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED
+StatusOr<std::unique_ptr<PointCloudDecoder>> CreatePointCloudDecoder(
+    int8_t method) {
+  if (method == POINT_CLOUD_SEQUENTIAL_ENCODING) {
+    return std::unique_ptr<PointCloudDecoder>(
+        new PointCloudSequentialDecoder());
+  } else if (method == POINT_CLOUD_KD_TREE_ENCODING) {
+    return std::unique_ptr<PointCloudDecoder>(new PointCloudKdTreeDecoder());
+  }
+  return Status(Status::DRACO_ERROR, "Unsupported encoding method.");
+}
+#endif
+
+#ifdef DRACO_MESH_COMPRESSION_SUPPORTED
+StatusOr<std::unique_ptr<MeshDecoder>> CreateMeshDecoder(uint8_t method) {
+  if (method == MESH_SEQUENTIAL_ENCODING) {
+    return std::unique_ptr<MeshDecoder>(new MeshSequentialDecoder());
+  } else if (method == MESH_EDGEBREAKER_ENCODING) {
+    return std::unique_ptr<MeshDecoder>(new MeshEdgebreakerDecoder());
+  }
+  return Status(Status::DRACO_ERROR, "Unsupported encoding method.");
+}
+#endif
+
+StatusOr<EncodedGeometryType> Decoder::GetEncodedGeometryType(
+    DecoderBuffer *in_buffer) {
+  DecoderBuffer temp_buffer(*in_buffer);
+  DracoHeader header;
+  DRACO_RETURN_IF_ERROR(PointCloudDecoder::DecodeHeader(&temp_buffer, &header));
+  if (header.encoder_type >= NUM_ENCODED_GEOMETRY_TYPES) {
+    return Status(Status::DRACO_ERROR, "Unsupported geometry type.");
+  }
+  return static_cast<EncodedGeometryType>(header.encoder_type);
+}
+
+StatusOr<std::unique_ptr<PointCloud>> Decoder::DecodePointCloudFromBuffer(
+    DecoderBuffer *in_buffer) {
+  DRACO_ASSIGN_OR_RETURN(EncodedGeometryType type,
+                         GetEncodedGeometryType(in_buffer))
+  if (type == POINT_CLOUD) {
+#ifdef DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED
+    std::unique_ptr<PointCloud> point_cloud(new PointCloud());
+    DRACO_RETURN_IF_ERROR(DecodeBufferToGeometry(in_buffer, point_cloud.get()))
+    return std::move(point_cloud);
+#endif
+  } else if (type == TRIANGULAR_MESH) {
+#ifdef DRACO_MESH_COMPRESSION_SUPPORTED
+    std::unique_ptr<Mesh> mesh(new Mesh());
+    DRACO_RETURN_IF_ERROR(DecodeBufferToGeometry(in_buffer, mesh.get()))
+    return static_cast<std::unique_ptr<PointCloud>>(std::move(mesh));
+#endif
+  }
+  return Status(Status::DRACO_ERROR, "Unsupported geometry type.");
+}
+
+StatusOr<std::unique_ptr<Mesh>> Decoder::DecodeMeshFromBuffer(
+    DecoderBuffer *in_buffer) {
+  std::unique_ptr<Mesh> mesh(new Mesh());
+  DRACO_RETURN_IF_ERROR(DecodeBufferToGeometry(in_buffer, mesh.get()))
+  return std::move(mesh);
+}
+
+Status Decoder::DecodeBufferToGeometry(DecoderBuffer *in_buffer,
+                                       PointCloud *out_geometry) {
+#ifdef DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED
+  DecoderBuffer temp_buffer(*in_buffer);
+  DracoHeader header;
+  DRACO_RETURN_IF_ERROR(PointCloudDecoder::DecodeHeader(&temp_buffer, &header))
+  if (header.encoder_type != POINT_CLOUD) {
+    return Status(Status::DRACO_ERROR, "Input is not a point cloud.");
+  }
+  DRACO_ASSIGN_OR_RETURN(std::unique_ptr<PointCloudDecoder> decoder,
+                         CreatePointCloudDecoder(header.encoder_method))
+
+  DRACO_RETURN_IF_ERROR(decoder->Decode(options_, in_buffer, out_geometry))
+  return OkStatus();
+#else
+  return Status(Status::DRACO_ERROR, "Unsupported geometry type.");
+#endif
+}
+
+Status Decoder::DecodeBufferToGeometry(DecoderBuffer *in_buffer,
+                                       Mesh *out_geometry) {
+#ifdef DRACO_MESH_COMPRESSION_SUPPORTED
+  DecoderBuffer temp_buffer(*in_buffer);
+  DracoHeader header;
+  DRACO_RETURN_IF_ERROR(PointCloudDecoder::DecodeHeader(&temp_buffer, &header))
+  if (header.encoder_type != TRIANGULAR_MESH) {
+    return Status(Status::DRACO_ERROR, "Input is not a mesh.");
+  }
+  DRACO_ASSIGN_OR_RETURN(std::unique_ptr<MeshDecoder> decoder,
+                         CreateMeshDecoder(header.encoder_method))
+
+  DRACO_RETURN_IF_ERROR(decoder->Decode(options_, in_buffer, out_geometry))
+  return OkStatus();
+#else
+  return Status(Status::DRACO_ERROR, "Unsupported geometry type.");
+#endif
+}
+
+void Decoder::SetSkipAttributeTransform(GeometryAttribute::Type att_type) {
+  options_.SetAttributeBool(att_type, "skip_attribute_transform", true);
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/decode.h b/contrib/draco/src/draco/compression/decode.h
new file mode 100644
index 000000000..5f3fad26b
--- /dev/null
+++ b/contrib/draco/src/draco/compression/decode.h
@@ -0,0 +1,80 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_DECODE_H_
+#define DRACO_COMPRESSION_DECODE_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/decoder_options.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/status_or.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class responsible for decoding of meshes and point clouds that were
+// compressed by a Draco encoder.
+class Decoder {
+ public:
+  // Returns the geometry type encoded in the input |in_buffer|.
+  // The return value is one of POINT_CLOUD, MESH or INVALID_GEOMETRY in case
+  // the input data is invalid.
+  // The decoded geometry type can be used to choose an appropriate decoding
+  // function for a given geometry type (see below).
+  static StatusOr<EncodedGeometryType> GetEncodedGeometryType(
+      DecoderBuffer *in_buffer);
+
+  // Decodes point cloud from the provided buffer. The buffer must be filled
+  // with data that was encoded with either the EncodePointCloudToBuffer or
+  // EncodeMeshToBuffer methods in encode.h. In case the input buffer contains
+  // mesh, the returned instance can be down-casted to Mesh.
+  StatusOr<std::unique_ptr<PointCloud>> DecodePointCloudFromBuffer(
+      DecoderBuffer *in_buffer);
+
+  // Decodes a triangular mesh from the provided buffer. The mesh must be filled
+  // with data that was encoded using the EncodeMeshToBuffer method in encode.h.
+  // The function will return nullptr in case the input is invalid or if it was
+  // encoded with the EncodePointCloudToBuffer method.
+  StatusOr<std::unique_ptr<Mesh>> DecodeMeshFromBuffer(
+      DecoderBuffer *in_buffer);
+
+  // Decodes the buffer into a provided geometry. If the geometry is
+  // incompatible with the encoded data. For example, when |out_geometry| is
+  // draco::Mesh while the data contains a point cloud, the function will return
+  // an error status.
+  Status DecodeBufferToGeometry(DecoderBuffer *in_buffer,
+                                PointCloud *out_geometry);
+  Status DecodeBufferToGeometry(DecoderBuffer *in_buffer, Mesh *out_geometry);
+
+  // When set, the decoder is going to skip attribute transform for a given
+  // attribute type. For example for quantized attributes, the decoder would
+  // skip the dequantization step and the returned geometry would contain an
+  // attribute with quantized values. The attribute would also contain an
+  // instance of AttributeTransform class that is used to describe the skipped
+  // transform, including all parameters that are needed to perform the
+  // transform manually.
+  void SetSkipAttributeTransform(GeometryAttribute::Type att_type);
+
+  // Returns the options instance used by the decoder that can be used by users
+  // to control the decoding process.
+  DecoderOptions *options() { return &options_; }
+
+ private:
+  DecoderOptions options_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_DECODE_H_
diff --git a/contrib/draco/src/draco/compression/decode_test.cc b/contrib/draco/src/draco/compression/decode_test.cc
new file mode 100644
index 000000000..198714690
--- /dev/null
+++ b/contrib/draco/src/draco/compression/decode_test.cc
@@ -0,0 +1,169 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/decode.h"
+
+#include <cinttypes>
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/file_utils.h"
+
+namespace {
+
+class DecodeTest : public ::testing::Test {
+ protected:
+  DecodeTest() {}
+};
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+TEST_F(DecodeTest, TestSkipAttributeTransform) {
+  const std::string file_name = "test_nm_quant.0.9.0.drc";
+  // Tests that decoders can successfully skip attribute transform.
+  std::vector<char> data;
+  ASSERT_TRUE(
+      draco::ReadFileToBuffer(draco::GetTestFileFullPath(file_name), &data));
+  ASSERT_FALSE(data.empty());
+
+  // Create a draco decoding buffer. Note that no data is copied in this step.
+  draco::DecoderBuffer buffer;
+  buffer.Init(data.data(), data.size());
+
+  draco::Decoder decoder;
+  // Make sure we skip dequantization for the position attribute.
+  decoder.SetSkipAttributeTransform(draco::GeometryAttribute::POSITION);
+
+  // Decode the input data into a geometry.
+  std::unique_ptr<draco::PointCloud> pc =
+      decoder.DecodePointCloudFromBuffer(&buffer).value();
+  ASSERT_NE(pc, nullptr);
+
+  const draco::PointAttribute *const pos_att =
+      pc->GetNamedAttribute(draco::GeometryAttribute::POSITION);
+  ASSERT_NE(pos_att, nullptr);
+
+  // Ensure the position attribute is of type int32_t and that it has a valid
+  // attribute transform.
+  ASSERT_EQ(pos_att->data_type(), draco::DT_INT32);
+  ASSERT_NE(pos_att->GetAttributeTransformData(), nullptr);
+
+  // Normal attribute should be left transformed.
+  const draco::PointAttribute *const norm_att =
+      pc->GetNamedAttribute(draco::GeometryAttribute::NORMAL);
+  ASSERT_EQ(norm_att->data_type(), draco::DT_FLOAT32);
+  ASSERT_EQ(norm_att->GetAttributeTransformData(), nullptr);
+}
+#endif
+
+void TestSkipAttributeTransformOnPointCloudWithColor(const std::string &file) {
+  std::vector<char> data;
+  ASSERT_TRUE(draco::ReadFileToBuffer(draco::GetTestFileFullPath(file), &data));
+  ASSERT_FALSE(data.empty());
+
+  // Create a draco decoding buffer. Note that no data is copied in this step.
+  draco::DecoderBuffer buffer;
+  buffer.Init(data.data(), data.size());
+
+  draco::Decoder decoder;
+  // Make sure we skip dequantization for the position attribute.
+  decoder.SetSkipAttributeTransform(draco::GeometryAttribute::POSITION);
+
+  // Decode the input data into a geometry.
+  std::unique_ptr<draco::PointCloud> pc =
+      decoder.DecodePointCloudFromBuffer(&buffer).value();
+  ASSERT_NE(pc, nullptr);
+
+  const draco::PointAttribute *const pos_att =
+      pc->GetNamedAttribute(draco::GeometryAttribute::POSITION);
+  ASSERT_NE(pos_att, nullptr);
+
+  // Ensure the position attribute is of type int32_t or uint32_t and that it
+  // has a valid attribute transform.
+  ASSERT_TRUE(pos_att->data_type() == draco::DT_INT32 ||
+              pos_att->data_type() == draco::DT_UINT32);
+  ASSERT_NE(pos_att->GetAttributeTransformData(), nullptr);
+
+  const draco::PointAttribute *const clr_att =
+      pc->GetNamedAttribute(draco::GeometryAttribute::COLOR);
+  ASSERT_EQ(clr_att->data_type(), draco::DT_UINT8);
+
+  // Ensure the color attribute was decoded correctly. Perform the decoding
+  // again without skipping the position dequantization and compare the
+  // attribute values.
+
+  draco::DecoderBuffer buffer_2;
+  buffer_2.Init(data.data(), data.size());
+
+  draco::Decoder decoder_2;
+
+  // Decode the input data into a geometry.
+  std::unique_ptr<draco::PointCloud> pc_2 =
+      decoder_2.DecodePointCloudFromBuffer(&buffer_2).value();
+  ASSERT_NE(pc_2, nullptr);
+
+  const draco::PointAttribute *const clr_att_2 =
+      pc_2->GetNamedAttribute(draco::GeometryAttribute::COLOR);
+  ASSERT_NE(clr_att_2, nullptr);
+  for (draco::PointIndex pi(0); pi < pc_2->num_points(); ++pi) {
+    // Colors should be exactly the same for both cases.
+    ASSERT_EQ(std::memcmp(clr_att->GetAddress(clr_att->mapped_index(pi)),
+                          clr_att_2->GetAddress(clr_att_2->mapped_index(pi)),
+                          clr_att->byte_stride()),
+              0);
+  }
+}
+
+TEST_F(DecodeTest, TestSkipAttributeTransformOnPointCloud) {
+  // Tests that decoders can successfully skip attribute transform on a point
+  // cloud with multiple attributes encoded with one attributes encoder.
+  TestSkipAttributeTransformOnPointCloudWithColor("pc_color.drc");
+  TestSkipAttributeTransformOnPointCloudWithColor("pc_kd_color.drc");
+}
+
+TEST_F(DecodeTest, TestSkipAttributeTransformWithNoQuantization) {
+  // Tests that decoders can successfully skip attribute transform even though
+  // the input model was not quantized (it has no attribute transform).
+  const std::string file_name = "point_cloud_no_qp.drc";
+  std::vector<char> data;
+  ASSERT_TRUE(
+      draco::ReadFileToBuffer(draco::GetTestFileFullPath(file_name), &data));
+  ASSERT_FALSE(data.empty());
+
+  // Create a draco decoding buffer. Note that no data is copied in this step.
+  draco::DecoderBuffer buffer;
+  buffer.Init(data.data(), data.size());
+
+  draco::Decoder decoder;
+  // Make sure we skip dequantization for the position attribute.
+  decoder.SetSkipAttributeTransform(draco::GeometryAttribute::POSITION);
+
+  // Decode the input data into a geometry.
+  std::unique_ptr<draco::PointCloud> pc =
+      decoder.DecodePointCloudFromBuffer(&buffer).value();
+  ASSERT_NE(pc, nullptr);
+
+  const draco::PointAttribute *const pos_att =
+      pc->GetNamedAttribute(draco::GeometryAttribute::POSITION);
+  ASSERT_NE(pos_att, nullptr);
+
+  // Ensure the position attribute is of type float32 since the attribute was
+  // not quantized.
+  ASSERT_EQ(pos_att->data_type(), draco::DT_FLOAT32);
+
+  // Make sure there is no attribute transform available for the attribute.
+  ASSERT_EQ(pos_att->GetAttributeTransformData(), nullptr);
+}
+
+}  // namespace
diff --git a/contrib/draco/src/draco/compression/encode.cc b/contrib/draco/src/draco/compression/encode.cc
new file mode 100644
index 000000000..f380aec15
--- /dev/null
+++ b/contrib/draco/src/draco/compression/encode.cc
@@ -0,0 +1,96 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/encode.h"
+
+#include "draco/compression/expert_encode.h"
+
+namespace draco {
+
+Encoder::Encoder() {}
+
+Status Encoder::EncodePointCloudToBuffer(const PointCloud &pc,
+                                         EncoderBuffer *out_buffer) {
+  ExpertEncoder encoder(pc);
+  encoder.Reset(CreateExpertEncoderOptions(pc));
+  return encoder.EncodeToBuffer(out_buffer);
+}
+
+Status Encoder::EncodeMeshToBuffer(const Mesh &m, EncoderBuffer *out_buffer) {
+  ExpertEncoder encoder(m);
+  encoder.Reset(CreateExpertEncoderOptions(m));
+  DRACO_RETURN_IF_ERROR(encoder.EncodeToBuffer(out_buffer));
+  set_num_encoded_points(encoder.num_encoded_points());
+  set_num_encoded_faces(encoder.num_encoded_faces());
+  return OkStatus();
+}
+
+EncoderOptions Encoder::CreateExpertEncoderOptions(const PointCloud &pc) const {
+  EncoderOptions ret_options = EncoderOptions::CreateEmptyOptions();
+  ret_options.SetGlobalOptions(options().GetGlobalOptions());
+  ret_options.SetFeatureOptions(options().GetFeaturelOptions());
+  // Convert type-based attribute options to specific attributes in the provided
+  // point cloud.
+  for (int i = 0; i < pc.num_attributes(); ++i) {
+    const Options *att_options =
+        options().FindAttributeOptions(pc.attribute(i)->attribute_type());
+    if (att_options) {
+      ret_options.SetAttributeOptions(i, *att_options);
+    }
+  }
+  return ret_options;
+}
+
+void Encoder::Reset(
+    const EncoderOptionsBase<GeometryAttribute::Type> &options) {
+  Base::Reset(options);
+}
+
+void Encoder::Reset() { Base::Reset(); }
+
+void Encoder::SetSpeedOptions(int encoding_speed, int decoding_speed) {
+  Base::SetSpeedOptions(encoding_speed, decoding_speed);
+}
+
+void Encoder::SetAttributeQuantization(GeometryAttribute::Type type,
+                                       int quantization_bits) {
+  options().SetAttributeInt(type, "quantization_bits", quantization_bits);
+}
+
+void Encoder::SetAttributeExplicitQuantization(GeometryAttribute::Type type,
+                                               int quantization_bits,
+                                               int num_dims,
+                                               const float *origin,
+                                               float range) {
+  options().SetAttributeInt(type, "quantization_bits", quantization_bits);
+  options().SetAttributeVector(type, "quantization_origin", num_dims, origin);
+  options().SetAttributeFloat(type, "quantization_range", range);
+}
+
+void Encoder::SetEncodingMethod(int encoding_method) {
+  Base::SetEncodingMethod(encoding_method);
+}
+
+Status Encoder::SetAttributePredictionScheme(GeometryAttribute::Type type,
+                                             int prediction_scheme_method) {
+  Status status = CheckPredictionScheme(type, prediction_scheme_method);
+  if (!status.ok()) {
+    return status;
+  }
+  options().SetAttributeInt(type, "prediction_scheme",
+                            prediction_scheme_method);
+  return status;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/encode.h b/contrib/draco/src/draco/compression/encode.h
new file mode 100644
index 000000000..bce8b34c2
--- /dev/null
+++ b/contrib/draco/src/draco/compression/encode.h
@@ -0,0 +1,140 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENCODE_H_
+#define DRACO_COMPRESSION_ENCODE_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/compression/encode_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Basic helper class for encoding geometry using the Draco compression library.
+// The class provides various methods that can be used to control several common
+// options used during the encoding, such as the number of quantization bits for
+// a given attribute. All these options are defined per attribute type, i.e.,
+// if there are more attributes of the same type (such as multiple texture
+// coordinate attributes), the same options are going to be used for all of the
+// attributes of this type. If different attributes of the same type need to
+// use different options, use ExpertEncoder in expert_encode.h.
+class Encoder
+    : public EncoderBase<EncoderOptionsBase<GeometryAttribute::Type>> {
+ public:
+  typedef EncoderBase<EncoderOptionsBase<GeometryAttribute::Type>> Base;
+
+  Encoder();
+  virtual ~Encoder() {}
+
+  // Encodes a point cloud to the provided buffer.
+  virtual Status EncodePointCloudToBuffer(const PointCloud &pc,
+                                          EncoderBuffer *out_buffer);
+
+  // Encodes a mesh to the provided buffer.
+  virtual Status EncodeMeshToBuffer(const Mesh &m, EncoderBuffer *out_buffer);
+
+  // Set encoder options used during the geometry encoding. Note that this call
+  // overwrites any modifications to the options done with the functions below,
+  // i.e., it resets the encoder.
+  void Reset(const EncoderOptionsBase<GeometryAttribute::Type> &options);
+  void Reset();
+
+  // Sets the desired encoding and decoding speed for the given options.
+  //
+  //  0 = slowest speed, but the best compression.
+  // 10 = fastest, but the worst compression.
+  // -1 = undefined.
+  //
+  // Note that both speed options affect the encoder choice of used methods and
+  // algorithms. For example, a requirement for fast decoding may prevent the
+  // encoder from using the best compression methods even if the encoding speed
+  // is set to 0. In general, the faster of the two options limits the choice of
+  // features that can be used by the encoder. Additionally, setting
+  // |decoding_speed| to be faster than the |encoding_speed| may allow the
+  // encoder to choose the optimal method out of the available features for the
+  // given |decoding_speed|.
+  void SetSpeedOptions(int encoding_speed, int decoding_speed);
+
+  // Sets the quantization compression options for a named attribute. The
+  // attribute values will be quantized in a box defined by the maximum extent
+  // of the attribute values. I.e., the actual precision of this option depends
+  // on the scale of the attribute values.
+  void SetAttributeQuantization(GeometryAttribute::Type type,
+                                int quantization_bits);
+
+  // Sets the explicit quantization compression for a named attribute. The
+  // attribute values will be quantized in a coordinate system defined by the
+  // provided origin and range (the input values should be within interval:
+  // <origin, origin + range>).
+  void SetAttributeExplicitQuantization(GeometryAttribute::Type type,
+                                        int quantization_bits, int num_dims,
+                                        const float *origin, float range);
+
+  // Sets the desired prediction method for a given attribute. By default,
+  // prediction scheme is selected automatically by the encoder using other
+  // provided options (such as speed) and input geometry type (mesh, point
+  // cloud). This function should be called only when a specific prediction is
+  // preferred (e.g., when it is known that the encoder would select a less
+  // optimal prediction for the given input data).
+  //
+  // |prediction_scheme_method| should be one of the entries defined in
+  // compression/config/compression_shared.h :
+  //
+  //   PREDICTION_NONE - use no prediction.
+  //   PREDICTION_DIFFERENCE - delta coding
+  //   MESH_PREDICTION_PARALLELOGRAM - parallelogram prediction for meshes.
+  //   MESH_PREDICTION_CONSTRAINED_PARALLELOGRAM
+  //      - better and more costly version of the parallelogram prediction.
+  //   MESH_PREDICTION_TEX_COORDS_PORTABLE
+  //      - specialized predictor for tex coordinates.
+  //   MESH_PREDICTION_GEOMETRIC_NORMAL
+  //      - specialized predictor for normal coordinates.
+  //
+  // Note that in case the desired prediction cannot be used, the default
+  // prediction will be automatically used instead.
+  Status SetAttributePredictionScheme(GeometryAttribute::Type type,
+                                      int prediction_scheme_method);
+
+  // Sets the desired encoding method for a given geometry. By default, encoding
+  // method is selected based on the properties of the input geometry and based
+  // on the other options selected in the used EncoderOptions (such as desired
+  // encoding and decoding speed). This function should be called only when a
+  // specific method is required.
+  //
+  // |encoding_method| can be one of the values defined in
+  // compression/config/compression_shared.h based on the type of the input
+  // geometry that is going to be encoded. For point clouds, allowed entries are
+  //   POINT_CLOUD_SEQUENTIAL_ENCODING
+  //   POINT_CLOUD_KD_TREE_ENCODING
+  //
+  // For meshes the input can be
+  //   MESH_SEQUENTIAL_ENCODING
+  //   MESH_EDGEBREAKER_ENCODING
+  //
+  // If the selected method cannot be used for the given input, the subsequent
+  // call of EncodePointCloudToBuffer or EncodeMeshToBuffer is going to fail.
+  void SetEncodingMethod(int encoding_method);
+
+ protected:
+  // Creates encoder options for the expert encoder used during the actual
+  // encoding.
+  EncoderOptions CreateExpertEncoderOptions(const PointCloud &pc) const;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENCODE_H_
diff --git a/contrib/draco/src/draco/compression/encode_base.h b/contrib/draco/src/draco/compression/encode_base.h
new file mode 100644
index 000000000..c501bc4fa
--- /dev/null
+++ b/contrib/draco/src/draco/compression/encode_base.h
@@ -0,0 +1,131 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENCODE_BASE_H_
+#define DRACO_COMPRESSION_ENCODE_BASE_H_
+
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/status.h"
+
+namespace draco {
+
+// Base class for our geometry encoder classes. |EncoderOptionsT| specifies
+// options class used by the encoder. Please, see encode.h and expert_encode.h
+// for more details and method descriptions.
+template <class EncoderOptionsT>
+class EncoderBase {
+ public:
+  typedef EncoderOptionsT OptionsType;
+
+  EncoderBase()
+      : options_(EncoderOptionsT::CreateDefaultOptions()),
+        num_encoded_points_(0),
+        num_encoded_faces_(0) {}
+  virtual ~EncoderBase() {}
+
+  const EncoderOptionsT &options() const { return options_; }
+  EncoderOptionsT &options() { return options_; }
+
+  // If enabled, it tells the encoder to keep track of the number of encoded
+  // points and faces (default = false).
+  // Note that this can slow down encoding for certain encoders.
+  void SetTrackEncodedProperties(bool flag);
+
+  // Returns the number of encoded points and faces during the last encoding
+  // operation. Returns 0 if SetTrackEncodedProperties() was not set.
+  size_t num_encoded_points() const { return num_encoded_points_; }
+  size_t num_encoded_faces() const { return num_encoded_faces_; }
+
+ protected:
+  void Reset(const EncoderOptionsT &options) { options_ = options; }
+
+  void Reset() { options_ = EncoderOptionsT::CreateDefaultOptions(); }
+
+  void SetSpeedOptions(int encoding_speed, int decoding_speed) {
+    options_.SetSpeed(encoding_speed, decoding_speed);
+  }
+
+  void SetEncodingMethod(int encoding_method) {
+    options_.SetGlobalInt("encoding_method", encoding_method);
+  }
+
+  void SetEncodingSubmethod(int encoding_submethod) {
+    options_.SetGlobalInt("encoding_submethod", encoding_submethod);
+  }
+
+  Status CheckPredictionScheme(GeometryAttribute::Type att_type,
+                               int prediction_scheme) const {
+    // Out of bound checks:
+    if (prediction_scheme < PREDICTION_NONE) {
+      return Status(Status::DRACO_ERROR,
+                    "Invalid prediction scheme requested.");
+    }
+    if (prediction_scheme >= NUM_PREDICTION_SCHEMES) {
+      return Status(Status::DRACO_ERROR,
+                    "Invalid prediction scheme requested.");
+    }
+    // Deprecated prediction schemes:
+    if (prediction_scheme == MESH_PREDICTION_TEX_COORDS_DEPRECATED) {
+      return Status(Status::DRACO_ERROR,
+                    "MESH_PREDICTION_TEX_COORDS_DEPRECATED is deprecated.");
+    }
+    if (prediction_scheme == MESH_PREDICTION_MULTI_PARALLELOGRAM) {
+      return Status(Status::DRACO_ERROR,
+                    "MESH_PREDICTION_MULTI_PARALLELOGRAM is deprecated.");
+    }
+    // Attribute specific checks:
+    if (prediction_scheme == MESH_PREDICTION_TEX_COORDS_PORTABLE) {
+      if (att_type != GeometryAttribute::TEX_COORD) {
+        return Status(Status::DRACO_ERROR,
+                      "Invalid prediction scheme for attribute type.");
+      }
+    }
+    if (prediction_scheme == MESH_PREDICTION_GEOMETRIC_NORMAL) {
+      if (att_type != GeometryAttribute::NORMAL) {
+        return Status(Status::DRACO_ERROR,
+                      "Invalid prediction scheme for attribute type.");
+      }
+    }
+    // TODO(hemmer): Try to enable more prediction schemes for normals.
+    if (att_type == GeometryAttribute::NORMAL) {
+      if (!(prediction_scheme == PREDICTION_DIFFERENCE ||
+            prediction_scheme == MESH_PREDICTION_GEOMETRIC_NORMAL)) {
+        return Status(Status::DRACO_ERROR,
+                      "Invalid prediction scheme for attribute type.");
+      }
+    }
+    return OkStatus();
+  }
+
+ protected:
+  void set_num_encoded_points(size_t num) { num_encoded_points_ = num; }
+  void set_num_encoded_faces(size_t num) { num_encoded_faces_ = num; }
+
+ private:
+  EncoderOptionsT options_;
+
+  size_t num_encoded_points_;
+  size_t num_encoded_faces_;
+};
+
+template <class EncoderOptionsT>
+void EncoderBase<EncoderOptionsT>::SetTrackEncodedProperties(bool flag) {
+  options_.SetGlobalBool("store_number_of_encoded_points", flag);
+  options_.SetGlobalBool("store_number_of_encoded_faces", flag);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENCODE_BASE_H_
diff --git a/contrib/draco/src/draco/compression/encode_test.cc b/contrib/draco/src/draco/compression/encode_test.cc
new file mode 100644
index 000000000..fde4f6f5b
--- /dev/null
+++ b/contrib/draco/src/draco/compression/encode_test.cc
@@ -0,0 +1,407 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "draco/compression/encode.h"
+
+#include <cinttypes>
+#include <fstream>
+#include <sstream>
+
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/compression/expert_encode.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/core/vector_d.h"
+#include "draco/io/obj_decoder.h"
+#include "draco/mesh/triangle_soup_mesh_builder.h"
+#include "draco/point_cloud/point_cloud_builder.h"
+
+namespace {
+
+class EncodeTest : public ::testing::Test {
+ protected:
+  EncodeTest() {}
+  std::unique_ptr<draco::Mesh> CreateTestMesh() const {
+    draco::TriangleSoupMeshBuilder mesh_builder;
+
+    // Create a simple mesh with one face.
+    mesh_builder.Start(1);
+
+    // Add one position attribute and two texture coordinate attributes.
+    const int32_t pos_att_id = mesh_builder.AddAttribute(
+        draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32);
+    const int32_t tex_att_id_0 = mesh_builder.AddAttribute(
+        draco::GeometryAttribute::TEX_COORD, 2, draco::DT_FLOAT32);
+    const int32_t tex_att_id_1 = mesh_builder.AddAttribute(
+        draco::GeometryAttribute::TEX_COORD, 2, draco::DT_FLOAT32);
+
+    // Initialize the attribute values.
+    mesh_builder.SetAttributeValuesForFace(
+        pos_att_id, draco::FaceIndex(0), draco::Vector3f(0.f, 0.f, 0.f).data(),
+        draco::Vector3f(1.f, 0.f, 0.f).data(),
+        draco::Vector3f(1.f, 1.f, 0.f).data());
+    mesh_builder.SetAttributeValuesForFace(
+        tex_att_id_0, draco::FaceIndex(0), draco::Vector2f(0.f, 0.f).data(),
+        draco::Vector2f(1.f, 0.f).data(), draco::Vector2f(1.f, 1.f).data());
+    mesh_builder.SetAttributeValuesForFace(
+        tex_att_id_1, draco::FaceIndex(0), draco::Vector2f(0.f, 0.f).data(),
+        draco::Vector2f(1.f, 0.f).data(), draco::Vector2f(1.f, 1.f).data());
+
+    return mesh_builder.Finalize();
+  }
+
+  std::unique_ptr<draco::PointCloud> CreateTestPointCloud() const {
+    draco::PointCloudBuilder pc_builder;
+
+    constexpr int kNumPoints = 100;
+    constexpr int kNumGenAttCoords0 = 4;
+    constexpr int kNumGenAttCoords1 = 6;
+    pc_builder.Start(kNumPoints);
+
+    // Add one position attribute and two generic attributes.
+    const int32_t pos_att_id = pc_builder.AddAttribute(
+        draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32);
+    const int32_t gen_att_id_0 = pc_builder.AddAttribute(
+        draco::GeometryAttribute::GENERIC, kNumGenAttCoords0, draco::DT_UINT32);
+    const int32_t gen_att_id_1 = pc_builder.AddAttribute(
+        draco::GeometryAttribute::GENERIC, kNumGenAttCoords1, draco::DT_UINT8);
+
+    std::vector<uint32_t> gen_att_data_0(kNumGenAttCoords0);
+    std::vector<uint32_t> gen_att_data_1(kNumGenAttCoords1);
+
+    // Initialize the attribute values.
+    for (draco::PointIndex i(0); i < kNumPoints; ++i) {
+      const float pos_coord = static_cast<float>(i.value());
+      pc_builder.SetAttributeValueForPoint(
+          pos_att_id, i,
+          draco::Vector3f(pos_coord, -pos_coord, pos_coord).data());
+
+      for (int j = 0; j < kNumGenAttCoords0; ++j) {
+        gen_att_data_0[j] = i.value();
+      }
+      pc_builder.SetAttributeValueForPoint(gen_att_id_0, i,
+                                           gen_att_data_0.data());
+
+      for (int j = 0; j < kNumGenAttCoords1; ++j) {
+        gen_att_data_1[j] = -i.value();
+      }
+      pc_builder.SetAttributeValueForPoint(gen_att_id_1, i,
+                                           gen_att_data_1.data());
+    }
+    return pc_builder.Finalize(false);
+  }
+
+  std::unique_ptr<draco::PointCloud> CreateTestPointCloudPosNorm() const {
+    draco::PointCloudBuilder pc_builder;
+
+    constexpr int kNumPoints = 20;
+    pc_builder.Start(kNumPoints);
+
+    // Add one position attribute and a normal attribute.
+    const int32_t pos_att_id = pc_builder.AddAttribute(
+        draco::GeometryAttribute::POSITION, 3, draco::DT_FLOAT32);
+    const int32_t norm_att_id = pc_builder.AddAttribute(
+        draco::GeometryAttribute::NORMAL, 3, draco::DT_FLOAT32);
+
+    // Initialize the attribute values.
+    for (draco::PointIndex i(0); i < kNumPoints; ++i) {
+      const float pos_coord = static_cast<float>(i.value());
+      pc_builder.SetAttributeValueForPoint(
+          pos_att_id, i,
+          draco::Vector3f(pos_coord, -pos_coord, pos_coord).data());
+
+      // Pseudo-random normal.
+      draco::Vector3f norm(pos_coord * 2.f, pos_coord - 2.f, pos_coord * 3.f);
+      norm.Normalize();
+      pc_builder.SetAttributeValueForPoint(norm_att_id, i, norm.data());
+    }
+
+    return pc_builder.Finalize(false);
+  }
+
+  int GetQuantizationBitsFromAttribute(const draco::PointAttribute *att) const {
+    if (att == nullptr) {
+      return -1;
+    }
+    draco::AttributeQuantizationTransform transform;
+    if (!transform.InitFromAttribute(*att)) {
+      return -1;
+    }
+    return transform.quantization_bits();
+  }
+
+  void VerifyNumQuantizationBits(const draco::EncoderBuffer &buffer,
+                                 int pos_quantization,
+                                 int tex_coord_0_quantization,
+                                 int tex_coord_1_quantization) const {
+    draco::Decoder decoder;
+
+    // Skip the dequantization for the attributes which will allow us to get
+    // the number of quantization bits used during encoding.
+    decoder.SetSkipAttributeTransform(draco::GeometryAttribute::POSITION);
+    decoder.SetSkipAttributeTransform(draco::GeometryAttribute::TEX_COORD);
+
+    draco::DecoderBuffer in_buffer;
+    in_buffer.Init(buffer.data(), buffer.size());
+    auto mesh = decoder.DecodeMeshFromBuffer(&in_buffer).value();
+    ASSERT_NE(mesh, nullptr);
+    ASSERT_EQ(GetQuantizationBitsFromAttribute(mesh->attribute(0)),
+              pos_quantization);
+    ASSERT_EQ(GetQuantizationBitsFromAttribute(mesh->attribute(1)),
+              tex_coord_0_quantization);
+    ASSERT_EQ(GetQuantizationBitsFromAttribute(mesh->attribute(2)),
+              tex_coord_1_quantization);
+  }
+
+  // Tests that the encoder returns the correct number of encoded points and
+  // faces for a given mesh or point cloud.
+  void TestNumberOfEncodedEntries(const std::string &file_name,
+                                  int32_t encoding_method) {
+    std::unique_ptr<draco::PointCloud> geometry;
+    draco::Mesh *mesh = nullptr;
+
+    if (encoding_method == draco::MESH_EDGEBREAKER_ENCODING ||
+        encoding_method == draco::MESH_SEQUENTIAL_ENCODING) {
+      std::unique_ptr<draco::Mesh> mesh_tmp =
+          draco::ReadMeshFromTestFile(file_name);
+      mesh = mesh_tmp.get();
+      if (!mesh->DeduplicateAttributeValues()) {
+        return;
+      }
+      mesh->DeduplicatePointIds();
+      geometry = std::move(mesh_tmp);
+    } else {
+      geometry = draco::ReadPointCloudFromTestFile(file_name);
+    }
+    ASSERT_NE(mesh, nullptr);
+
+    draco::Encoder encoder;
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 14);
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::TEX_COORD, 12);
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL, 10);
+
+    encoder.SetEncodingMethod(encoding_method);
+
+    encoder.SetTrackEncodedProperties(true);
+
+    draco::EncoderBuffer buffer;
+    if (mesh) {
+      encoder.EncodeMeshToBuffer(*mesh, &buffer);
+    } else {
+      encoder.EncodePointCloudToBuffer(*geometry, &buffer);
+    }
+
+    // Ensure the logged number of encoded points and faces matches the number
+    // we get from the decoder.
+
+    draco::DecoderBuffer decoder_buffer;
+    decoder_buffer.Init(buffer.data(), buffer.size());
+    draco::Decoder decoder;
+
+    if (mesh) {
+      auto maybe_mesh = decoder.DecodeMeshFromBuffer(&decoder_buffer);
+      ASSERT_TRUE(maybe_mesh.ok());
+      auto decoded_mesh = std::move(maybe_mesh).value();
+      ASSERT_NE(decoded_mesh, nullptr);
+      ASSERT_EQ(decoded_mesh->num_points(), encoder.num_encoded_points());
+      ASSERT_EQ(decoded_mesh->num_faces(), encoder.num_encoded_faces());
+    } else {
+      auto maybe_pc = decoder.DecodePointCloudFromBuffer(&decoder_buffer);
+      ASSERT_TRUE(maybe_pc.ok());
+      auto decoded_pc = std::move(maybe_pc).value();
+      ASSERT_EQ(decoded_pc->num_points(), encoder.num_encoded_points());
+    }
+  }
+};
+
+TEST_F(EncodeTest, TestExpertEncoderQuantization) {
+  // This test verifies that the expert encoder can quantize individual
+  // attributes even if they have the same type.
+  auto mesh = CreateTestMesh();
+  ASSERT_NE(mesh, nullptr);
+
+  draco::ExpertEncoder encoder(*mesh);
+  encoder.SetAttributeQuantization(0, 16);  // Position quantization.
+  encoder.SetAttributeQuantization(1, 15);  // Tex-coord 0 quantization.
+  encoder.SetAttributeQuantization(2, 14);  // Tex-coord 1 quantization.
+
+  draco::EncoderBuffer buffer;
+  encoder.EncodeToBuffer(&buffer);
+  VerifyNumQuantizationBits(buffer, 16, 15, 14);
+}
+
+TEST_F(EncodeTest, TestEncoderQuantization) {
+  // This test verifies that Encoder applies the same quantization to all
+  // attributes of the same type.
+  auto mesh = CreateTestMesh();
+  ASSERT_NE(mesh, nullptr);
+
+  draco::Encoder encoder;
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 16);
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::TEX_COORD, 15);
+
+  draco::EncoderBuffer buffer;
+  encoder.EncodeMeshToBuffer(*mesh, &buffer);
+  VerifyNumQuantizationBits(buffer, 16, 15, 15);
+}
+
+TEST_F(EncodeTest, TestLinesObj) {
+  // This test verifies that Encoder can encode file that contains only line
+  // segments (that are ignored).
+  std::unique_ptr<draco::Mesh> mesh(
+      draco::ReadMeshFromTestFile("test_lines.obj"));
+  ASSERT_NE(mesh, nullptr);
+  ASSERT_EQ(mesh->num_faces(), 0);
+  std::unique_ptr<draco::PointCloud> pc(
+      draco::ReadPointCloudFromTestFile("test_lines.obj"));
+  ASSERT_NE(pc, nullptr);
+
+  draco::Encoder encoder;
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 16);
+
+  draco::EncoderBuffer buffer;
+  ASSERT_TRUE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+}
+
+TEST_F(EncodeTest, TestQuantizedInfinity) {
+  // This test verifies that Encoder fails to encode point cloud when requesting
+  // quantization of attribute that contains infinity values.
+  std::unique_ptr<draco::PointCloud> pc(
+      draco::ReadPointCloudFromTestFile("float_inf_point_cloud.ply"));
+  ASSERT_NE(pc, nullptr);
+
+  {
+    draco::Encoder encoder;
+    encoder.SetEncodingMethod(draco::POINT_CLOUD_SEQUENTIAL_ENCODING);
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 11);
+
+    draco::EncoderBuffer buffer;
+    ASSERT_FALSE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+  }
+
+  {
+    draco::Encoder encoder;
+    encoder.SetEncodingMethod(draco::POINT_CLOUD_KD_TREE_ENCODING);
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 11);
+
+    draco::EncoderBuffer buffer;
+    ASSERT_FALSE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+  }
+}
+
+TEST_F(EncodeTest, TestUnquantizedInfinity) {
+  // This test verifies that Encoder can successfully encode point cloud when
+  // not requesting quantization of attribute that contains infinity values.
+  std::unique_ptr<draco::PointCloud> pc(
+      draco::ReadPointCloudFromTestFile("float_inf_point_cloud.ply"));
+  ASSERT_NE(pc, nullptr);
+
+  // Note that the KD tree encoding method is not applicable to float values.
+  draco::Encoder encoder;
+  encoder.SetEncodingMethod(draco::POINT_CLOUD_SEQUENTIAL_ENCODING);
+
+  draco::EncoderBuffer buffer;
+  ASSERT_TRUE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+}
+
+TEST_F(EncodeTest, TestQuantizedAndUnquantizedAttributes) {
+  // This test verifies that Encoder can successfully encode point cloud with
+  // two float attribiutes - one quantized and another unquantized. The encoder
+  // defaults to sequential encoding in this case.
+  std::unique_ptr<draco::PointCloud> pc(
+      draco::ReadPointCloudFromTestFile("float_two_att_point_cloud.ply"));
+  ASSERT_NE(pc, nullptr);
+
+  draco::Encoder encoder;
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 11);
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL, 0);
+  draco::EncoderBuffer buffer;
+  ASSERT_TRUE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+}
+
+TEST_F(EncodeTest, TestKdTreeEncoding) {
+  // This test verifies that the API can successfully encode a point cloud
+  // defined by several attributes using the kd tree method.
+  std::unique_ptr<draco::PointCloud> pc = CreateTestPointCloud();
+  ASSERT_NE(pc, nullptr);
+
+  draco::EncoderBuffer buffer;
+  draco::Encoder encoder;
+  encoder.SetEncodingMethod(draco::POINT_CLOUD_KD_TREE_ENCODING);
+  // First try it without quantizing positions which should fail.
+  ASSERT_FALSE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+
+  // Now set quantization for the position attribute which should make
+  // the encoder happy.
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION, 16);
+  ASSERT_TRUE(encoder.EncodePointCloudToBuffer(*pc, &buffer).ok());
+}
+
+TEST_F(EncodeTest, TestTrackingOfNumberOfEncodedEntries) {
+  TestNumberOfEncodedEntries("deg_faces.obj", draco::MESH_EDGEBREAKER_ENCODING);
+  TestNumberOfEncodedEntries("deg_faces.obj", draco::MESH_SEQUENTIAL_ENCODING);
+  TestNumberOfEncodedEntries("cube_att.obj", draco::MESH_EDGEBREAKER_ENCODING);
+  TestNumberOfEncodedEntries("test_nm.obj", draco::MESH_EDGEBREAKER_ENCODING);
+  TestNumberOfEncodedEntries("test_nm.obj", draco::MESH_SEQUENTIAL_ENCODING);
+  TestNumberOfEncodedEntries("cube_subd.obj",
+                             draco::POINT_CLOUD_KD_TREE_ENCODING);
+  TestNumberOfEncodedEntries("cube_subd.obj",
+                             draco::POINT_CLOUD_SEQUENTIAL_ENCODING);
+}
+
+TEST_F(EncodeTest, TestTrackingOfNumberOfEncodedEntriesNotSet) {
+  // Tests that when tracing of encoded properties is disabled, the returned
+  // number of encoded faces and points is 0.
+  std::unique_ptr<draco::Mesh> mesh(
+      draco::ReadMeshFromTestFile("cube_att.obj"));
+  ASSERT_NE(mesh, nullptr);
+
+  draco::EncoderBuffer buffer;
+  draco::Encoder encoder;
+
+  ASSERT_TRUE(encoder.EncodeMeshToBuffer(*mesh, &buffer).ok());
+  ASSERT_EQ(encoder.num_encoded_points(), 0);
+  ASSERT_EQ(encoder.num_encoded_faces(), 0);
+}
+
+TEST_F(EncodeTest, TestNoPosQuantizationNormalCoding) {
+  // Tests that we can encode and decode a file with quantized normals but
+  // non-quantized positions.
+  const auto mesh = draco::ReadMeshFromTestFile("test_nm.obj");
+  ASSERT_NE(mesh, nullptr);
+
+  // The mesh should have positions and normals.
+  ASSERT_NE(mesh->GetNamedAttribute(draco::GeometryAttribute::POSITION),
+            nullptr);
+  ASSERT_NE(mesh->GetNamedAttribute(draco::GeometryAttribute::NORMAL), nullptr);
+
+  draco::EncoderBuffer buffer;
+  draco::Encoder encoder;
+  // No quantization for positions.
+  encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL, 8);
+
+  DRACO_ASSERT_OK(encoder.EncodeMeshToBuffer(*mesh, &buffer));
+
+  draco::Decoder decoder;
+
+  draco::DecoderBuffer in_buffer;
+  in_buffer.Init(buffer.data(), buffer.size());
+  const auto decoded_mesh = decoder.DecodeMeshFromBuffer(&in_buffer).value();
+  ASSERT_NE(decoded_mesh, nullptr);
+}
+
+}  // namespace
diff --git a/contrib/draco/src/draco/compression/entropy/ans.h b/contrib/draco/src/draco/compression/entropy/ans.h
new file mode 100644
index 000000000..c71d58975
--- /dev/null
+++ b/contrib/draco/src/draco/compression/entropy/ans.h
@@ -0,0 +1,527 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_ANS_H_
+#define DRACO_COMPRESSION_ENTROPY_ANS_H_
+// An implementation of Asymmetric Numeral Systems (rANS).
+// See http://arxiv.org/abs/1311.2540v2 for more information on rANS.
+// This file is based off libvpx's ans.h.
+
+#include <vector>
+
+#define DRACO_ANS_DIVIDE_BY_MULTIPLY 1
+#if DRACO_ANS_DIVIDE_BY_MULTIPLY
+#include "draco/core/divide.h"
+#endif
+#include "draco/core/macros.h"
+
+namespace draco {
+
+#if DRACO_ANS_DIVIDE_BY_MULTIPLY
+
+#define DRACO_ANS_DIVREM(quotient, remainder, dividend, divisor) \
+  do {                                                           \
+    quotient = fastdiv(dividend, divisor);                       \
+    remainder = dividend - quotient * divisor;                   \
+  } while (0)
+#define DRACO_ANS_DIV(dividend, divisor) fastdiv(dividend, divisor)
+#else
+#define DRACO_ANS_DIVREM(quotient, remainder, dividend, divisor) \
+  do {                                                           \
+    quotient = dividend / divisor;                               \
+    remainder = dividend % divisor;                              \
+  } while (0)
+#define DRACO_ANS_DIV(dividend, divisor) ((dividend) / (divisor))
+#endif
+
+struct AnsCoder {
+  AnsCoder() : buf(nullptr), buf_offset(0), state(0) {}
+  uint8_t *buf;
+  int buf_offset;
+  uint32_t state;
+};
+
+struct AnsDecoder {
+  AnsDecoder() : buf(nullptr), buf_offset(0), state(0) {}
+  const uint8_t *buf;
+  int buf_offset;
+  uint32_t state;
+};
+
+typedef uint8_t AnsP8;
+#define DRACO_ANS_P8_PRECISION 256u
+#define DRACO_ANS_L_BASE (4096u)
+#define DRACO_ANS_IO_BASE 256
+
+static uint32_t mem_get_le16(const void *vmem) {
+  uint32_t val;
+  const uint8_t *mem = (const uint8_t *)vmem;
+
+  val = mem[1] << 8;
+  val |= mem[0];
+  return val;
+}
+
+static uint32_t mem_get_le24(const void *vmem) {
+  uint32_t val;
+  const uint8_t *mem = (const uint8_t *)vmem;
+
+  val = mem[2] << 16;
+  val |= mem[1] << 8;
+  val |= mem[0];
+  return val;
+}
+
+static inline uint32_t mem_get_le32(const void *vmem) {
+  uint32_t val;
+  const uint8_t *mem = (const uint8_t *)vmem;
+
+  val = mem[3] << 24;
+  val |= mem[2] << 16;
+  val |= mem[1] << 8;
+  val |= mem[0];
+  return val;
+}
+
+static inline void mem_put_le16(void *vmem, uint32_t val) {
+  uint8_t *mem = reinterpret_cast<uint8_t *>(vmem);
+
+  mem[0] = (val >> 0) & 0xff;
+  mem[1] = (val >> 8) & 0xff;
+}
+
+static inline void mem_put_le24(void *vmem, uint32_t val) {
+  uint8_t *mem = reinterpret_cast<uint8_t *>(vmem);
+
+  mem[0] = (val >> 0) & 0xff;
+  mem[1] = (val >> 8) & 0xff;
+  mem[2] = (val >> 16) & 0xff;
+}
+
+static inline void mem_put_le32(void *vmem, uint32_t val) {
+  uint8_t *mem = reinterpret_cast<uint8_t *>(vmem);
+
+  mem[0] = (val >> 0) & 0xff;
+  mem[1] = (val >> 8) & 0xff;
+  mem[2] = (val >> 16) & 0xff;
+  mem[3] = (val >> 24) & 0xff;
+}
+
+static inline void ans_write_init(struct AnsCoder *const ans,
+                                  uint8_t *const buf) {
+  ans->buf = buf;
+  ans->buf_offset = 0;
+  ans->state = DRACO_ANS_L_BASE;
+}
+
+static inline int ans_write_end(struct AnsCoder *const ans) {
+  uint32_t state;
+  DRACO_DCHECK_GE(ans->state, DRACO_ANS_L_BASE);
+  DRACO_DCHECK_LT(ans->state, DRACO_ANS_L_BASE * DRACO_ANS_IO_BASE);
+  state = ans->state - DRACO_ANS_L_BASE;
+  if (state < (1 << 6)) {
+    ans->buf[ans->buf_offset] = (0x00 << 6) + state;
+    return ans->buf_offset + 1;
+  } else if (state < (1 << 14)) {
+    mem_put_le16(ans->buf + ans->buf_offset, (0x01 << 14) + state);
+    return ans->buf_offset + 2;
+  } else if (state < (1 << 22)) {
+    mem_put_le24(ans->buf + ans->buf_offset, (0x02 << 22) + state);
+    return ans->buf_offset + 3;
+  } else {
+    DRACO_DCHECK(0 && "State is too large to be serialized");
+    return ans->buf_offset;
+  }
+}
+
+// rABS with descending spread.
+// p or p0 takes the place of l_s from the paper.
+// DRACO_ANS_P8_PRECISION is m.
+static inline void rabs_desc_write(struct AnsCoder *ans, int val, AnsP8 p0) {
+  const AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  const unsigned l_s = val ? p : p0;
+  unsigned quot, rem;
+  if (ans->state >=
+      DRACO_ANS_L_BASE / DRACO_ANS_P8_PRECISION * DRACO_ANS_IO_BASE * l_s) {
+    ans->buf[ans->buf_offset++] = ans->state % DRACO_ANS_IO_BASE;
+    ans->state /= DRACO_ANS_IO_BASE;
+  }
+  DRACO_ANS_DIVREM(quot, rem, ans->state, l_s);
+  ans->state = quot * DRACO_ANS_P8_PRECISION + rem + (val ? 0 : p);
+}
+
+#define DRACO_ANS_IMPL1 0
+#define UNPREDICTABLE(x) x
+static inline int rabs_desc_read(struct AnsDecoder *ans, AnsP8 p0) {
+  int val;
+#if DRACO_ANS_IMPL1
+  unsigned l_s;
+#else
+  unsigned quot, rem, x, xn;
+#endif
+  const AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  if (ans->state < DRACO_ANS_L_BASE && ans->buf_offset > 0) {
+    ans->state = ans->state * DRACO_ANS_IO_BASE + ans->buf[--ans->buf_offset];
+  }
+#if DRACO_ANS_IMPL1
+  val = ans->state % DRACO_ANS_P8_PRECISION < p;
+  l_s = val ? p : p0;
+  ans->state = (ans->state / DRACO_ANS_P8_PRECISION) * l_s +
+               ans->state % DRACO_ANS_P8_PRECISION - (!val * p);
+#else
+  x = ans->state;
+  quot = x / DRACO_ANS_P8_PRECISION;
+  rem = x % DRACO_ANS_P8_PRECISION;
+  xn = quot * p;
+  val = rem < p;
+  if (UNPREDICTABLE(val)) {
+    ans->state = xn + rem;
+  } else {
+    // ans->state = quot * p0 + rem - p;
+    ans->state = x - xn - p;
+  }
+#endif
+  return val;
+}
+
+// rABS with ascending spread.
+// p or p0 takes the place of l_s from the paper.
+// DRACO_ANS_P8_PRECISION is m.
+static inline void rabs_asc_write(struct AnsCoder *ans, int val, AnsP8 p0) {
+  const AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  const unsigned l_s = val ? p : p0;
+  unsigned quot, rem;
+  if (ans->state >=
+      DRACO_ANS_L_BASE / DRACO_ANS_P8_PRECISION * DRACO_ANS_IO_BASE * l_s) {
+    ans->buf[ans->buf_offset++] = ans->state % DRACO_ANS_IO_BASE;
+    ans->state /= DRACO_ANS_IO_BASE;
+  }
+  DRACO_ANS_DIVREM(quot, rem, ans->state, l_s);
+  ans->state = quot * DRACO_ANS_P8_PRECISION + rem + (val ? p0 : 0);
+}
+
+static inline int rabs_asc_read(struct AnsDecoder *ans, AnsP8 p0) {
+  int val;
+#if DRACO_ANS_IMPL1
+  unsigned l_s;
+#else
+  unsigned quot, rem, x, xn;
+#endif
+  const AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  if (ans->state < DRACO_ANS_L_BASE) {
+    ans->state = ans->state * DRACO_ANS_IO_BASE + ans->buf[--ans->buf_offset];
+  }
+#if DRACO_ANS_IMPL1
+  val = ans->state % DRACO_ANS_P8_PRECISION < p;
+  l_s = val ? p : p0;
+  ans->state = (ans->state / DRACO_ANS_P8_PRECISION) * l_s +
+               ans->state % DRACO_ANS_P8_PRECISION - (!val * p);
+#else
+  x = ans->state;
+  quot = x / DRACO_ANS_P8_PRECISION;
+  rem = x % DRACO_ANS_P8_PRECISION;
+  xn = quot * p;
+  val = rem >= p0;
+  if (UNPREDICTABLE(val)) {
+    ans->state = xn + rem - p0;
+  } else {
+    // ans->state = quot * p0 + rem - p0;
+    ans->state = x - xn;
+  }
+#endif
+  return val;
+}
+
+#define rabs_read rabs_desc_read
+#define rabs_write rabs_desc_write
+
+// uABS with normalization.
+static inline void uabs_write(struct AnsCoder *ans, int val, AnsP8 p0) {
+  AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  const unsigned l_s = val ? p : p0;
+  while (ans->state >=
+         DRACO_ANS_L_BASE / DRACO_ANS_P8_PRECISION * DRACO_ANS_IO_BASE * l_s) {
+    ans->buf[ans->buf_offset++] = ans->state % DRACO_ANS_IO_BASE;
+    ans->state /= DRACO_ANS_IO_BASE;
+  }
+  if (!val) {
+    ans->state = DRACO_ANS_DIV(ans->state * DRACO_ANS_P8_PRECISION, p0);
+  } else {
+    ans->state =
+        DRACO_ANS_DIV((ans->state + 1) * DRACO_ANS_P8_PRECISION + p - 1, p) - 1;
+  }
+}
+
+static inline int uabs_read(struct AnsDecoder *ans, AnsP8 p0) {
+  AnsP8 p = DRACO_ANS_P8_PRECISION - p0;
+  int s;
+  // unsigned int xp1;
+  unsigned xp, sp;
+  unsigned state = ans->state;
+  while (state < DRACO_ANS_L_BASE && ans->buf_offset > 0) {
+    state = state * DRACO_ANS_IO_BASE + ans->buf[--ans->buf_offset];
+  }
+  sp = state * p;
+  // xp1 = (sp + p) / DRACO_ANS_P8_PRECISION;
+  xp = sp / DRACO_ANS_P8_PRECISION;
+  // s = xp1 - xp;
+  s = (sp & 0xFF) >= p0;
+  if (UNPREDICTABLE(s)) {
+    ans->state = xp;
+  } else {
+    ans->state = state - xp;
+  }
+  return s;
+}
+
+static inline int uabs_read_bit(struct AnsDecoder *ans) {
+  int s;
+  unsigned state = ans->state;
+  while (state < DRACO_ANS_L_BASE && ans->buf_offset > 0) {
+    state = state * DRACO_ANS_IO_BASE + ans->buf[--ans->buf_offset];
+  }
+  s = static_cast<int>(state & 1);
+  ans->state = state >> 1;
+  return s;
+}
+
+static inline int ans_read_init(struct AnsDecoder *const ans,
+                                const uint8_t *const buf, int offset) {
+  unsigned x;
+  if (offset < 1) {
+    return 1;
+  }
+  ans->buf = buf;
+  x = buf[offset - 1] >> 6;
+  if (x == 0) {
+    ans->buf_offset = offset - 1;
+    ans->state = buf[offset - 1] & 0x3F;
+  } else if (x == 1) {
+    if (offset < 2) {
+      return 1;
+    }
+    ans->buf_offset = offset - 2;
+    ans->state = mem_get_le16(buf + offset - 2) & 0x3FFF;
+  } else if (x == 2) {
+    if (offset < 3) {
+      return 1;
+    }
+    ans->buf_offset = offset - 3;
+    ans->state = mem_get_le24(buf + offset - 3) & 0x3FFFFF;
+  } else {
+    return 1;
+  }
+  ans->state += DRACO_ANS_L_BASE;
+  if (ans->state >= DRACO_ANS_L_BASE * DRACO_ANS_IO_BASE) {
+    return 1;
+  }
+  return 0;
+}
+
+static inline int ans_read_end(struct AnsDecoder *const ans) {
+  return ans->state == DRACO_ANS_L_BASE;
+}
+
+static inline int ans_reader_has_error(const struct AnsDecoder *const ans) {
+  return ans->state < DRACO_ANS_L_BASE && ans->buf_offset == 0;
+}
+
+struct rans_sym {
+  uint32_t prob;
+  uint32_t cum_prob;  // not-inclusive.
+};
+
+// Class for performing rANS encoding using a desired number of precision bits.
+// The max number of precision bits is currently 19. The actual number of
+// symbols in the input alphabet should be (much) smaller than that, otherwise
+// the compression rate may suffer.
+template <int rans_precision_bits_t>
+class RAnsEncoder {
+ public:
+  RAnsEncoder() {}
+
+  // Provides the input buffer where the data is going to be stored.
+  inline void write_init(uint8_t *const buf) {
+    ans_.buf = buf;
+    ans_.buf_offset = 0;
+    ans_.state = l_rans_base;
+  }
+
+  // Needs to be called after all symbols are encoded.
+  inline int write_end() {
+    uint32_t state;
+    DRACO_DCHECK_GE(ans_.state, l_rans_base);
+    DRACO_DCHECK_LT(ans_.state, l_rans_base * DRACO_ANS_IO_BASE);
+    state = ans_.state - l_rans_base;
+    if (state < (1 << 6)) {
+      ans_.buf[ans_.buf_offset] = (0x00 << 6) + state;
+      return ans_.buf_offset + 1;
+    } else if (state < (1 << 14)) {
+      mem_put_le16(ans_.buf + ans_.buf_offset, (0x01 << 14) + state);
+      return ans_.buf_offset + 2;
+    } else if (state < (1 << 22)) {
+      mem_put_le24(ans_.buf + ans_.buf_offset, (0x02 << 22) + state);
+      return ans_.buf_offset + 3;
+    } else if (state < (1 << 30)) {
+      mem_put_le32(ans_.buf + ans_.buf_offset, (0x03u << 30u) + state);
+      return ans_.buf_offset + 4;
+    } else {
+      DRACO_DCHECK(0 && "State is too large to be serialized");
+      return ans_.buf_offset;
+    }
+  }
+
+  // rANS with normalization.
+  // sym->prob takes the place of l_s from the paper.
+  // rans_precision is m.
+  inline void rans_write(const struct rans_sym *const sym) {
+    const uint32_t p = sym->prob;
+    while (ans_.state >= l_rans_base / rans_precision * DRACO_ANS_IO_BASE * p) {
+      ans_.buf[ans_.buf_offset++] = ans_.state % DRACO_ANS_IO_BASE;
+      ans_.state /= DRACO_ANS_IO_BASE;
+    }
+    // TODO(ostava): The division and multiplication should be optimized.
+    ans_.state =
+        (ans_.state / p) * rans_precision + ans_.state % p + sym->cum_prob;
+  }
+
+ private:
+  static constexpr int rans_precision = 1 << rans_precision_bits_t;
+  static constexpr int l_rans_base = rans_precision * 4;
+  AnsCoder ans_;
+};
+
+struct rans_dec_sym {
+  uint32_t val;
+  uint32_t prob;
+  uint32_t cum_prob;  // not-inclusive.
+};
+
+// Class for performing rANS decoding using a desired number of precision bits.
+// The number of precision bits needs to be the same as with the RAnsEncoder
+// that was used to encode the input data.
+template <int rans_precision_bits_t>
+class RAnsDecoder {
+ public:
+  RAnsDecoder() {}
+
+  // Initializes the decoder from the input buffer. The |offset| specifies the
+  // number of bytes encoded by the encoder. A non zero return value is an
+  // error.
+  inline int read_init(const uint8_t *const buf, int offset) {
+    unsigned x;
+    if (offset < 1) {
+      return 1;
+    }
+    ans_.buf = buf;
+    x = buf[offset - 1] >> 6;
+    if (x == 0) {
+      ans_.buf_offset = offset - 1;
+      ans_.state = buf[offset - 1] & 0x3F;
+    } else if (x == 1) {
+      if (offset < 2) {
+        return 1;
+      }
+      ans_.buf_offset = offset - 2;
+      ans_.state = mem_get_le16(buf + offset - 2) & 0x3FFF;
+    } else if (x == 2) {
+      if (offset < 3) {
+        return 1;
+      }
+      ans_.buf_offset = offset - 3;
+      ans_.state = mem_get_le24(buf + offset - 3) & 0x3FFFFF;
+    } else if (x == 3) {
+      ans_.buf_offset = offset - 4;
+      ans_.state = mem_get_le32(buf + offset - 4) & 0x3FFFFFFF;
+    } else {
+      return 1;
+    }
+    ans_.state += l_rans_base;
+    if (ans_.state >= l_rans_base * DRACO_ANS_IO_BASE) {
+      return 1;
+    }
+    return 0;
+  }
+
+  inline int read_end() { return ans_.state == l_rans_base; }
+
+  inline int reader_has_error() {
+    return ans_.state < l_rans_base && ans_.buf_offset == 0;
+  }
+
+  inline int rans_read() {
+    unsigned rem;
+    unsigned quo;
+    struct rans_dec_sym sym;
+    while (ans_.state < l_rans_base && ans_.buf_offset > 0) {
+      ans_.state = ans_.state * DRACO_ANS_IO_BASE + ans_.buf[--ans_.buf_offset];
+    }
+    // |rans_precision| is a power of two compile time constant, and the below
+    // division and modulo are going to be optimized by the compiler.
+    quo = ans_.state / rans_precision;
+    rem = ans_.state % rans_precision;
+    fetch_sym(&sym, rem);
+    ans_.state = quo * sym.prob + rem - sym.cum_prob;
+    return sym.val;
+  }
+
+  // Construct a lookup table with |rans_precision| number of entries.
+  // Returns false if the table couldn't be built (because of wrong input data).
+  inline bool rans_build_look_up_table(const uint32_t token_probs[],
+                                       uint32_t num_symbols) {
+    lut_table_.resize(rans_precision);
+    probability_table_.resize(num_symbols);
+    uint32_t cum_prob = 0;
+    uint32_t act_prob = 0;
+    for (uint32_t i = 0; i < num_symbols; ++i) {
+      probability_table_[i].prob = token_probs[i];
+      probability_table_[i].cum_prob = cum_prob;
+      cum_prob += token_probs[i];
+      if (cum_prob > rans_precision) {
+        return false;
+      }
+      for (uint32_t j = act_prob; j < cum_prob; ++j) {
+        lut_table_[j] = i;
+      }
+      act_prob = cum_prob;
+    }
+    if (cum_prob != rans_precision) {
+      return false;
+    }
+    return true;
+  }
+
+ private:
+  inline void fetch_sym(struct rans_dec_sym *out, uint32_t rem) {
+    uint32_t symbol = lut_table_[rem];
+    out->val = symbol;
+    out->prob = probability_table_[symbol].prob;
+    out->cum_prob = probability_table_[symbol].cum_prob;
+  }
+
+  static constexpr int rans_precision = 1 << rans_precision_bits_t;
+  static constexpr int l_rans_base = rans_precision * 4;
+  std::vector<uint32_t> lut_table_;
+  std::vector<rans_sym> probability_table_;
+  AnsDecoder ans_;
+};
+
+#undef DRACO_ANS_DIVREM
+#undef DRACO_ANS_P8_PRECISION
+#undef DRACO_ANS_L_BASE
+#undef DRACO_ANS_IO_BASE
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_ANS_H_
diff --git a/contrib/draco/src/draco/compression/entropy/rans_symbol_coding.h b/contrib/draco/src/draco/compression/entropy/rans_symbol_coding.h
new file mode 100644
index 000000000..cd4271193
--- /dev/null
+++ b/contrib/draco/src/draco/compression/entropy/rans_symbol_coding.h
@@ -0,0 +1,53 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File providing shared functionality for RAnsSymbolEncoder and
+// RAnsSymbolDecoder (see rans_symbol_encoder.h / rans_symbol_decoder.h).
+#ifndef DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_CODING_H_
+#define DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_CODING_H_
+
+#include "draco/compression/entropy/ans.h"
+
+namespace draco {
+
+// Computes the desired precision of the rANS method for the specified number of
+// unique symbols the input data (defined by their bit_length).
+constexpr int ComputeRAnsUnclampedPrecision(int symbols_bit_length) {
+  return (3 * symbols_bit_length) / 2;
+}
+
+// Computes the desired precision clamped to guarantee a valid functionality of
+// our rANS library (which is between 12 to 20 bits).
+constexpr int ComputeRAnsPrecisionFromUniqueSymbolsBitLength(
+    int symbols_bit_length) {
+  return ComputeRAnsUnclampedPrecision(symbols_bit_length) < 12 ? 12
+         : ComputeRAnsUnclampedPrecision(symbols_bit_length) > 20
+             ? 20
+             : ComputeRAnsUnclampedPrecision(symbols_bit_length);
+}
+
+// Compute approximate frequency table size needed for storing the provided
+// symbols.
+static inline int64_t ApproximateRAnsFrequencyTableBits(
+    int32_t max_value, int num_unique_symbols) {
+  // Approximate number of bits for storing zero frequency entries using the
+  // run length encoding (with max length of 64).
+  const int64_t table_zero_frequency_bits =
+      8 * (num_unique_symbols + (max_value - num_unique_symbols) / 64);
+  return 8 * num_unique_symbols + table_zero_frequency_bits;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_CODING_H_
diff --git a/contrib/draco/src/draco/compression/entropy/rans_symbol_decoder.h b/contrib/draco/src/draco/compression/entropy/rans_symbol_decoder.h
new file mode 100644
index 000000000..10cdc6781
--- /dev/null
+++ b/contrib/draco/src/draco/compression/entropy/rans_symbol_decoder.h
@@ -0,0 +1,164 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_DECODER_H_
+#define DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_DECODER_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/entropy/rans_symbol_coding.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/varint_decoding.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// A helper class for decoding symbols using the rANS algorithm (see ans.h).
+// The class can be used to decode the probability table and the data encoded
+// by the RAnsSymbolEncoder. |unique_symbols_bit_length_t| must be the same as
+// the one used for the corresponding RAnsSymbolEncoder.
+template <int unique_symbols_bit_length_t>
+class RAnsSymbolDecoder {
+ public:
+  RAnsSymbolDecoder() : num_symbols_(0) {}
+
+  // Initialize the decoder and decode the probability table.
+  bool Create(DecoderBuffer *buffer);
+
+  uint32_t num_symbols() const { return num_symbols_; }
+
+  // Starts decoding from the buffer. The buffer will be advanced past the
+  // encoded data after this call.
+  bool StartDecoding(DecoderBuffer *buffer);
+  uint32_t DecodeSymbol() { return ans_.rans_read(); }
+  void EndDecoding();
+
+ private:
+  static constexpr int rans_precision_bits_ =
+      ComputeRAnsPrecisionFromUniqueSymbolsBitLength(
+          unique_symbols_bit_length_t);
+  static constexpr int rans_precision_ = 1 << rans_precision_bits_;
+
+  std::vector<uint32_t> probability_table_;
+  uint32_t num_symbols_;
+  RAnsDecoder<rans_precision_bits_> ans_;
+};
+
+template <int unique_symbols_bit_length_t>
+bool RAnsSymbolDecoder<unique_symbols_bit_length_t>::Create(
+    DecoderBuffer *buffer) {
+  // Check that the DecoderBuffer version is set.
+  if (buffer->bitstream_version() == 0) {
+    return false;
+  }
+  // Decode the number of alphabet symbols.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!buffer->Decode(&num_symbols_)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_symbols_, buffer)) {
+      return false;
+    }
+  }
+  probability_table_.resize(num_symbols_);
+  if (num_symbols_ == 0) {
+    return true;
+  }
+  // Decode the table.
+  for (uint32_t i = 0; i < num_symbols_; ++i) {
+    uint8_t prob_data = 0;
+    // Decode the first byte and extract the number of extra bytes we need to
+    // get, or the offset to the next symbol with non-zero probability.
+    if (!buffer->Decode(&prob_data)) {
+      return false;
+    }
+    // Token is stored in the first two bits of the first byte. Values 0-2 are
+    // used to indicate the number of extra bytes, and value 3 is a special
+    // symbol used to denote run-length coding of zero probability entries.
+    // See rans_symbol_encoder.h for more details.
+    const int token = prob_data & 3;
+    if (token == 3) {
+      const uint32_t offset = prob_data >> 2;
+      if (i + offset >= num_symbols_) {
+        return false;
+      }
+      // Set zero probability for all symbols in the specified range.
+      for (uint32_t j = 0; j < offset + 1; ++j) {
+        probability_table_[i + j] = 0;
+      }
+      i += offset;
+    } else {
+      const int extra_bytes = token;
+      uint32_t prob = prob_data >> 2;
+      for (int b = 0; b < extra_bytes; ++b) {
+        uint8_t eb;
+        if (!buffer->Decode(&eb)) {
+          return false;
+        }
+        // Shift 8 bits for each extra byte and subtract 2 for the two first
+        // bits.
+        prob |= static_cast<uint32_t>(eb) << (8 * (b + 1) - 2);
+      }
+      probability_table_[i] = prob;
+    }
+  }
+  if (!ans_.rans_build_look_up_table(&probability_table_[0], num_symbols_)) {
+    return false;
+  }
+  return true;
+}
+
+template <int unique_symbols_bit_length_t>
+bool RAnsSymbolDecoder<unique_symbols_bit_length_t>::StartDecoding(
+    DecoderBuffer *buffer) {
+  uint64_t bytes_encoded;
+  // Decode the number of bytes encoded by the encoder.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (buffer->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!buffer->Decode(&bytes_encoded)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint<uint64_t>(&bytes_encoded, buffer)) {
+      return false;
+    }
+  }
+  if (bytes_encoded > static_cast<uint64_t>(buffer->remaining_size())) {
+    return false;
+  }
+  const uint8_t *const data_head =
+      reinterpret_cast<const uint8_t *>(buffer->data_head());
+  // Advance the buffer past the rANS data.
+  buffer->Advance(bytes_encoded);
+  if (ans_.read_init(data_head, static_cast<int>(bytes_encoded)) != 0) {
+    return false;
+  }
+  return true;
+}
+
+template <int unique_symbols_bit_length_t>
+void RAnsSymbolDecoder<unique_symbols_bit_length_t>::EndDecoding() {
+  ans_.read_end();
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/entropy/rans_symbol_encoder.h b/contrib/draco/src/draco/compression/entropy/rans_symbol_encoder.h
new file mode 100644
index 000000000..4e07ec871
--- /dev/null
+++ b/contrib/draco/src/draco/compression/entropy/rans_symbol_encoder.h
@@ -0,0 +1,290 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_ENCODER_H_
+#define DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_ENCODER_H_
+
+#include <algorithm>
+#include <cmath>
+#include <cstring>
+
+#include "draco/compression/entropy/ans.h"
+#include "draco/compression/entropy/rans_symbol_coding.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+// A helper class for encoding symbols using the rANS algorithm (see ans.h).
+// The class can be used to initialize and encode probability table needed by
+// rANS, and to perform encoding of symbols into the provided EncoderBuffer.
+template <int unique_symbols_bit_length_t>
+class RAnsSymbolEncoder {
+ public:
+  RAnsSymbolEncoder()
+      : num_symbols_(0), num_expected_bits_(0), buffer_offset_(0) {}
+
+  // Creates a probability table needed by the rANS library and encode it into
+  // the provided buffer.
+  bool Create(const uint64_t *frequencies, int num_symbols,
+              EncoderBuffer *buffer);
+
+  void StartEncoding(EncoderBuffer *buffer);
+  void EncodeSymbol(uint32_t symbol) {
+    ans_.rans_write(&probability_table_[symbol]);
+  }
+  void EndEncoding(EncoderBuffer *buffer);
+
+  // rANS requires to encode the input symbols in the reverse order.
+  static constexpr bool needs_reverse_encoding() { return true; }
+
+ private:
+  // Functor used for sorting symbol ids according to their probabilities.
+  // The functor sorts symbol indices that index an underlying map between
+  // symbol ids and their probabilities. We don't sort the probability table
+  // directly, because that would require an additional indirection during the
+  // EncodeSymbol() function.
+  struct ProbabilityLess {
+    explicit ProbabilityLess(const std::vector<rans_sym> *probs)
+        : probabilities(probs) {}
+    bool operator()(int i, int j) const {
+      return probabilities->at(i).prob < probabilities->at(j).prob;
+    }
+    const std::vector<rans_sym> *probabilities;
+  };
+
+  // Encodes the probability table into the output buffer.
+  bool EncodeTable(EncoderBuffer *buffer);
+
+  static constexpr int rans_precision_bits_ =
+      ComputeRAnsPrecisionFromUniqueSymbolsBitLength(
+          unique_symbols_bit_length_t);
+  static constexpr int rans_precision_ = 1 << rans_precision_bits_;
+
+  std::vector<rans_sym> probability_table_;
+  // The number of symbols in the input alphabet.
+  uint32_t num_symbols_;
+  // Expected number of bits that is needed to encode the input.
+  uint64_t num_expected_bits_;
+
+  RAnsEncoder<rans_precision_bits_> ans_;
+  // Initial offset of the encoder buffer before any ans data was encoded.
+  uint64_t buffer_offset_;
+};
+
+template <int unique_symbols_bit_length_t>
+bool RAnsSymbolEncoder<unique_symbols_bit_length_t>::Create(
+    const uint64_t *frequencies, int num_symbols, EncoderBuffer *buffer) {
+  // Compute the total of the input frequencies.
+  uint64_t total_freq = 0;
+  int max_valid_symbol = 0;
+  for (int i = 0; i < num_symbols; ++i) {
+    total_freq += frequencies[i];
+    if (frequencies[i] > 0) {
+      max_valid_symbol = i;
+    }
+  }
+  num_symbols = max_valid_symbol + 1;
+  num_symbols_ = num_symbols;
+  probability_table_.resize(num_symbols);
+  const double total_freq_d = static_cast<double>(total_freq);
+  const double rans_precision_d = static_cast<double>(rans_precision_);
+  // Compute probabilities by rescaling the normalized frequencies into interval
+  // [1, rans_precision - 1]. The total probability needs to be equal to
+  // rans_precision.
+  int total_rans_prob = 0;
+  for (int i = 0; i < num_symbols; ++i) {
+    const uint64_t freq = frequencies[i];
+
+    // Normalized probability.
+    const double prob = static_cast<double>(freq) / total_freq_d;
+
+    // RAns probability in range of [1, rans_precision - 1].
+    uint32_t rans_prob = static_cast<uint32_t>(prob * rans_precision_d + 0.5f);
+    if (rans_prob == 0 && freq > 0) {
+      rans_prob = 1;
+    }
+    probability_table_[i].prob = rans_prob;
+    total_rans_prob += rans_prob;
+  }
+  // Because of rounding errors, the total precision may not be exactly accurate
+  // and we may need to adjust the entries a little bit.
+  if (total_rans_prob != rans_precision_) {
+    std::vector<int> sorted_probabilities(num_symbols);
+    for (int i = 0; i < num_symbols; ++i) {
+      sorted_probabilities[i] = i;
+    }
+    std::sort(sorted_probabilities.begin(), sorted_probabilities.end(),
+              ProbabilityLess(&probability_table_));
+    if (total_rans_prob < rans_precision_) {
+      // This happens rather infrequently, just add the extra needed precision
+      // to the most frequent symbol.
+      probability_table_[sorted_probabilities.back()].prob +=
+          rans_precision_ - total_rans_prob;
+    } else {
+      // We have over-allocated the precision, which is quite common.
+      // Rescale the probabilities of all symbols.
+      int32_t error = total_rans_prob - rans_precision_;
+      while (error > 0) {
+        const double act_total_prob_d = static_cast<double>(total_rans_prob);
+        const double act_rel_error_d = rans_precision_d / act_total_prob_d;
+        for (int j = num_symbols - 1; j > 0; --j) {
+          int symbol_id = sorted_probabilities[j];
+          if (probability_table_[symbol_id].prob <= 1) {
+            if (j == num_symbols - 1) {
+              return false;  // Most frequent symbol would be empty.
+            }
+            break;
+          }
+          const int32_t new_prob = static_cast<int32_t>(
+              floor(act_rel_error_d *
+                    static_cast<double>(probability_table_[symbol_id].prob)));
+          int32_t fix = probability_table_[symbol_id].prob - new_prob;
+          if (fix == 0u) {
+            fix = 1;
+          }
+          if (fix >= static_cast<int32_t>(probability_table_[symbol_id].prob)) {
+            fix = probability_table_[symbol_id].prob - 1;
+          }
+          if (fix > error) {
+            fix = error;
+          }
+          probability_table_[symbol_id].prob -= fix;
+          total_rans_prob -= fix;
+          error -= fix;
+          if (total_rans_prob == rans_precision_) {
+            break;
+          }
+        }
+      }
+    }
+  }
+
+  // Compute the cumulative probability (cdf).
+  uint32_t total_prob = 0;
+  for (int i = 0; i < num_symbols; ++i) {
+    probability_table_[i].cum_prob = total_prob;
+    total_prob += probability_table_[i].prob;
+  }
+  if (total_prob != rans_precision_) {
+    return false;
+  }
+
+  // Estimate the number of bits needed to encode the input.
+  // From Shannon entropy the total number of bits N is:
+  //   N = -sum{i : all_symbols}(F(i) * log2(P(i)))
+  // where P(i) is the normalized probability of symbol i and F(i) is the
+  // symbol's frequency in the input data.
+  double num_bits = 0;
+  for (int i = 0; i < num_symbols; ++i) {
+    if (probability_table_[i].prob == 0) {
+      continue;
+    }
+    const double norm_prob =
+        static_cast<double>(probability_table_[i].prob) / rans_precision_d;
+    num_bits += static_cast<double>(frequencies[i]) * log2(norm_prob);
+  }
+  num_expected_bits_ = static_cast<uint64_t>(ceil(-num_bits));
+  if (!EncodeTable(buffer)) {
+    return false;
+  }
+  return true;
+}
+
+template <int unique_symbols_bit_length_t>
+bool RAnsSymbolEncoder<unique_symbols_bit_length_t>::EncodeTable(
+    EncoderBuffer *buffer) {
+  EncodeVarint(num_symbols_, buffer);
+  // Use varint encoding for the probabilities (first two bits represent the
+  // number of bytes used - 1).
+  for (uint32_t i = 0; i < num_symbols_; ++i) {
+    const uint32_t prob = probability_table_[i].prob;
+    int num_extra_bytes = 0;
+    if (prob >= (1 << 6)) {
+      num_extra_bytes++;
+      if (prob >= (1 << 14)) {
+        num_extra_bytes++;
+        if (prob >= (1 << 22)) {
+          // The maximum number of precision bits is 20 so we should not really
+          // get to this point.
+          return false;
+        }
+      }
+    }
+    if (prob == 0) {
+      // When the probability of the symbol is 0, set the first two bits to 1
+      // (unique identifier) and use the remaining 6 bits to store the offset
+      // to the next symbol with non-zero probability.
+      uint32_t offset = 0;
+      for (; offset < (1 << 6) - 1; ++offset) {
+        // Note: we don't have to check whether the next symbol id is larger
+        // than num_symbols_ because we know that the last symbol always has
+        // non-zero probability.
+        const uint32_t next_prob = probability_table_[i + offset + 1].prob;
+        if (next_prob > 0) {
+          break;
+        }
+      }
+      buffer->Encode(static_cast<uint8_t>((offset << 2) | 3));
+      i += offset;
+    } else {
+      // Encode the first byte (including the number of extra bytes).
+      buffer->Encode(static_cast<uint8_t>((prob << 2) | (num_extra_bytes & 3)));
+      // Encode the extra bytes.
+      for (int b = 0; b < num_extra_bytes; ++b) {
+        buffer->Encode(static_cast<uint8_t>(prob >> (8 * (b + 1) - 2)));
+      }
+    }
+  }
+  return true;
+}
+
+template <int unique_symbols_bit_length_t>
+void RAnsSymbolEncoder<unique_symbols_bit_length_t>::StartEncoding(
+    EncoderBuffer *buffer) {
+  // Allocate extra storage just in case.
+  const uint64_t required_bits = 2 * num_expected_bits_ + 32;
+
+  buffer_offset_ = buffer->size();
+  const int64_t required_bytes = (required_bits + 7) / 8;
+  buffer->Resize(buffer_offset_ + required_bytes + sizeof(buffer_offset_));
+  uint8_t *const data =
+      reinterpret_cast<uint8_t *>(const_cast<char *>(buffer->data()));
+  ans_.write_init(data + buffer_offset_);
+}
+
+template <int unique_symbols_bit_length_t>
+void RAnsSymbolEncoder<unique_symbols_bit_length_t>::EndEncoding(
+    EncoderBuffer *buffer) {
+  char *const src = const_cast<char *>(buffer->data()) + buffer_offset_;
+
+  // TODO(fgalligan): Look into changing this to uint32_t as write_end()
+  // returns an int.
+  const uint64_t bytes_written = static_cast<uint64_t>(ans_.write_end());
+  EncoderBuffer var_size_buffer;
+  EncodeVarint(bytes_written, &var_size_buffer);
+  const uint32_t size_len = static_cast<uint32_t>(var_size_buffer.size());
+  char *const dst = src + size_len;
+  memmove(dst, src, bytes_written);
+
+  // Store the size of the encoded data.
+  memcpy(src, var_size_buffer.data(), size_len);
+
+  // Resize the buffer to match the number of encoded bytes.
+  buffer->Resize(buffer_offset_ + bytes_written + size_len);
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_RANS_SYMBOL_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/entropy/shannon_entropy.cc b/contrib/draco/src/draco/compression/entropy/shannon_entropy.cc
new file mode 100644
index 000000000..137eafe5f
--- /dev/null
+++ b/contrib/draco/src/draco/compression/entropy/shannon_entropy.cc
@@ -0,0 +1,147 @@
+#include "draco/compression/entropy/shannon_entropy.h"
+
+#include <cmath>
+#include <vector>
+
+#include "draco/compression/entropy/rans_symbol_coding.h"
+
+namespace draco {
+
+int64_t ComputeShannonEntropy(const uint32_t *symbols, int num_symbols,
+                              int max_value, int *out_num_unique_symbols) {
+  // First find frequency of all unique symbols in the input array.
+  int num_unique_symbols = 0;
+  std::vector<int> symbol_frequencies(max_value + 1, 0);
+  for (int i = 0; i < num_symbols; ++i) {
+    ++symbol_frequencies[symbols[i]];
+  }
+  double total_bits = 0;
+  double num_symbols_d = num_symbols;
+  for (int i = 0; i < max_value + 1; ++i) {
+    if (symbol_frequencies[i] > 0) {
+      ++num_unique_symbols;
+      // Compute Shannon entropy for the symbol.
+      // We don't want to use std::log2 here for Android build.
+      total_bits +=
+          symbol_frequencies[i] *
+          log2(static_cast<double>(symbol_frequencies[i]) / num_symbols_d);
+    }
+  }
+  if (out_num_unique_symbols) {
+    *out_num_unique_symbols = num_unique_symbols;
+  }
+  // Entropy is always negative.
+  return static_cast<int64_t>(-total_bits);
+}
+
+double ComputeBinaryShannonEntropy(uint32_t num_values,
+                                   uint32_t num_true_values) {
+  if (num_values == 0) {
+    return 0;
+  }
+
+  // We can exit early if the data set has 0 entropy.
+  if (num_true_values == 0 || num_values == num_true_values) {
+    return 0;
+  }
+  const double true_freq =
+      static_cast<double>(num_true_values) / static_cast<double>(num_values);
+  const double false_freq = 1.0 - true_freq;
+  return -(true_freq * std::log2(true_freq) +
+           false_freq * std::log2(false_freq));
+}
+
+ShannonEntropyTracker::ShannonEntropyTracker() {}
+
+ShannonEntropyTracker::EntropyData ShannonEntropyTracker::Peek(
+    const uint32_t *symbols, int num_symbols) {
+  return UpdateSymbols(symbols, num_symbols, false);
+}
+
+ShannonEntropyTracker::EntropyData ShannonEntropyTracker::Push(
+    const uint32_t *symbols, int num_symbols) {
+  return UpdateSymbols(symbols, num_symbols, true);
+}
+
+ShannonEntropyTracker::EntropyData ShannonEntropyTracker::UpdateSymbols(
+    const uint32_t *symbols, int num_symbols, bool push_changes) {
+  EntropyData ret_data = entropy_data_;
+  ret_data.num_values += num_symbols;
+  for (int i = 0; i < num_symbols; ++i) {
+    const uint32_t symbol = symbols[i];
+    if (frequencies_.size() <= symbol) {
+      frequencies_.resize(symbol + 1, 0);
+    }
+
+    // Update the entropy of the stream. Note that entropy of |N| values
+    // represented by |S| unique symbols is defined as:
+    //
+    //  entropy = -sum_over_S(symbol_frequency / N * log2(symbol_frequency / N))
+    //
+    // To avoid the need to recompute the entire sum when new values are added,
+    // we can instead update a so called entropy norm that is defined as:
+    //
+    //  entropy_norm = sum_over_S(symbol_frequency * log2(symbol_frequency))
+    //
+    // In this case, all we need to do is update entries on the symbols where
+    // the frequency actually changed.
+    //
+    // Note that entropy_norm and entropy can be easily transformed to the
+    // actual entropy as:
+    //
+    //  entropy = log2(N) - entropy_norm / N
+    //
+    double old_symbol_entropy_norm = 0;
+    int &frequency = frequencies_[symbol];
+    if (frequency > 1) {
+      old_symbol_entropy_norm = frequency * std::log2(frequency);
+    } else if (frequency == 0) {
+      ret_data.num_unique_symbols++;
+      if (symbol > static_cast<uint32_t>(ret_data.max_symbol)) {
+        ret_data.max_symbol = symbol;
+      }
+    }
+    frequency++;
+    const double new_symbol_entropy_norm = frequency * std::log2(frequency);
+
+    // Update the final entropy.
+    ret_data.entropy_norm += new_symbol_entropy_norm - old_symbol_entropy_norm;
+  }
+  if (push_changes) {
+    // Update entropy data of the stream.
+    entropy_data_ = ret_data;
+  } else {
+    // We are only peeking so do not update the stream.
+    // Revert changes in the frequency table.
+    for (int i = 0; i < num_symbols; ++i) {
+      const uint32_t symbol = symbols[i];
+      frequencies_[symbol]--;
+    }
+  }
+  return ret_data;
+}
+
+int64_t ShannonEntropyTracker::GetNumberOfDataBits(
+    const EntropyData &entropy_data) {
+  if (entropy_data.num_values < 2) {
+    return 0;
+  }
+  // We need to compute the number of bits required to represent the stream
+  // using the entropy norm. Note that:
+  //
+  //   entropy = log2(num_values) - entropy_norm / num_values
+  //
+  // and number of bits required for the entropy is: num_values * entropy
+  //
+  return static_cast<int64_t>(
+      ceil(entropy_data.num_values * std::log2(entropy_data.num_values) -
+           entropy_data.entropy_norm));
+}
+
+int64_t ShannonEntropyTracker::GetNumberOfRAnsTableBits(
+    const EntropyData &entropy_data) {
+  return ApproximateRAnsFrequencyTableBits(entropy_data.max_symbol + 1,
+                                           entropy_data.num_unique_symbols);
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/entropy/shannon_entropy.h b/contrib/draco/src/draco/compression/entropy/shannon_entropy.h
new file mode 100644
index 000000000..85165f4cb
--- /dev/null
+++ b/contrib/draco/src/draco/compression/entropy/shannon_entropy.h
@@ -0,0 +1,110 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_SHANNON_ENTROPY_H_
+#define DRACO_COMPRESSION_ENTROPY_SHANNON_ENTROPY_H_
+
+#include <stdint.h>
+
+#include <vector>
+
+namespace draco {
+
+// Computes an approximate Shannon entropy of symbols stored in the provided
+// input array |symbols|. The entropy corresponds to the number of bits that is
+// required to represent/store all the symbols using an optimal entropy coding
+// algorithm. See for example "A mathematical theory of communication" by
+// Shannon'48 (http://ieeexplore.ieee.org/document/6773024/).
+//
+// |max_value| is a required input that define the maximum value in the input
+// |symbols| array.
+//
+// |out_num_unique_symbols| is an optional output argument that stores the
+// number of unique symbols contained within the |symbols| array.
+// TODO(ostava): This should be renamed or the return value should be changed to
+// return the actual entropy and not the number of bits needed to represent the
+// input symbols.
+int64_t ComputeShannonEntropy(const uint32_t *symbols, int num_symbols,
+                              int max_value, int *out_num_unique_symbols);
+
+// Computes the Shannon entropy of |num_values| Boolean entries, where
+// |num_true_values| are set to true.
+// Returns entropy between 0-1.
+double ComputeBinaryShannonEntropy(uint32_t num_values,
+                                   uint32_t num_true_values);
+
+// Class that can be used to keep track of the Shannon entropy on streamed data.
+// As new symbols are pushed to the tracker, the entropy is automatically
+// recomputed. The class also support recomputing the entropy without actually
+// pushing the symbols to the tracker through the Peek() method.
+class ShannonEntropyTracker {
+ public:
+  ShannonEntropyTracker();
+
+  // Struct for holding entropy data about the symbols added to the tracker.
+  // It can be used to compute the number of bits needed to store the data using
+  // the method:
+  //   ShannonEntropyTracker::GetNumberOfDataBits(entropy_data);
+  // or to compute the approximate size of the frequency table needed by the
+  // rans coding using method:
+  //   ShannonEntropyTracker::GetNumberOfRAnsTableBits(entropy_data);
+  struct EntropyData {
+    double entropy_norm;
+    int num_values;
+    int max_symbol;
+    int num_unique_symbols;
+    EntropyData()
+        : entropy_norm(0.0),
+          num_values(0),
+          max_symbol(0),
+          num_unique_symbols(0) {}
+  };
+
+  // Adds new symbols to the tracker and recomputes the entropy accordingly.
+  EntropyData Push(const uint32_t *symbols, int num_symbols);
+
+  // Returns new entropy data for the tracker as if |symbols| were added to the
+  // tracker without actually changing the status of the tracker.
+  EntropyData Peek(const uint32_t *symbols, int num_symbols);
+
+  // Gets the number of bits needed for encoding symbols added to the tracker.
+  int64_t GetNumberOfDataBits() const {
+    return GetNumberOfDataBits(entropy_data_);
+  }
+
+  // Gets the number of bits needed for encoding frequency table using the rans
+  // encoder.
+  int64_t GetNumberOfRAnsTableBits() const {
+    return GetNumberOfRAnsTableBits(entropy_data_);
+  }
+
+  // Gets the number of bits needed for encoding given |entropy_data|.
+  static int64_t GetNumberOfDataBits(const EntropyData &entropy_data);
+
+  // Gets the number of bits needed for encoding frequency table using the rans
+  // encoder for the given |entropy_data|.
+  static int64_t GetNumberOfRAnsTableBits(const EntropyData &entropy_data);
+
+ private:
+  EntropyData UpdateSymbols(const uint32_t *symbols, int num_symbols,
+                            bool push_changes);
+
+  std::vector<int32_t> frequencies_;
+
+  EntropyData entropy_data_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_SHANNON_ENTROPY_H_
diff --git a/contrib/draco/src/draco/compression/entropy/shannon_entropy_test.cc b/contrib/draco/src/draco/compression/entropy/shannon_entropy_test.cc
new file mode 100644
index 000000000..732c7d2fb
--- /dev/null
+++ b/contrib/draco/src/draco/compression/entropy/shannon_entropy_test.cc
@@ -0,0 +1,58 @@
+#include "draco/compression/entropy/shannon_entropy.h"
+
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+TEST(ShannonEntropyTest, TestBinaryEntropy) {
+  // Test verifies that computing binary entropy works as expected.
+  ASSERT_EQ(draco::ComputeBinaryShannonEntropy(0, 0), 0);
+  ASSERT_EQ(draco::ComputeBinaryShannonEntropy(10, 0), 0);
+  ASSERT_EQ(draco::ComputeBinaryShannonEntropy(10, 10), 0);
+  ASSERT_NEAR(draco::ComputeBinaryShannonEntropy(10, 5), 1.0, 1e-4);
+}
+
+TEST(ShannonEntropyTest, TestStreamEntropy) {
+  // Test verifies that the entropy of streamed data is computed correctly.
+  const std::vector<uint32_t> symbols = {1, 5, 1, 100, 2, 1};
+
+  draco::ShannonEntropyTracker entropy_tracker;
+
+  // Nothing added, 0 entropy.
+  ASSERT_EQ(entropy_tracker.GetNumberOfDataBits(), 0);
+
+  // Try to push symbols one by one.
+  uint32_t max_symbol = 0;
+  for (int i = 0; i < symbols.size(); ++i) {
+    if (symbols[i] > max_symbol) {
+      max_symbol = symbols[i];
+    }
+    const auto entropy_data = entropy_tracker.Push(&symbols[i], 1);
+
+    const int64_t stream_entropy_bits = entropy_tracker.GetNumberOfDataBits();
+    // Ensure the returned entropy_data is in sync with the stream.
+    ASSERT_EQ(draco::ShannonEntropyTracker::GetNumberOfDataBits(entropy_data),
+              stream_entropy_bits);
+
+    // Make sure the entropy is approximately the same as the one we compute
+    // directly from all symbols.
+    const int64_t expected_entropy_bits = draco::ComputeShannonEntropy(
+        symbols.data(), i + 1, max_symbol, nullptr);
+
+    // For now hardcoded tolerance of 2 bits.
+    ASSERT_NEAR(expected_entropy_bits, stream_entropy_bits, 2);
+  }
+
+  // Compare it also to the case when we add all symbols in one call.
+  draco::ShannonEntropyTracker entropy_tracker_2;
+  entropy_tracker_2.Push(symbols.data(), symbols.size());
+  const int64_t stream_2_entropy_bits = entropy_tracker_2.GetNumberOfDataBits();
+  ASSERT_EQ(entropy_tracker.GetNumberOfDataBits(), stream_2_entropy_bits);
+
+  // Ensure that peeking does not change the entropy.
+  entropy_tracker_2.Peek(symbols.data(), 1);
+
+  ASSERT_EQ(stream_2_entropy_bits, entropy_tracker_2.GetNumberOfDataBits());
+}
+
+}  // namespace
diff --git a/contrib/draco/src/draco/compression/entropy/symbol_coding_test.cc b/contrib/draco/src/draco/compression/entropy/symbol_coding_test.cc
new file mode 100644
index 000000000..ba7166bbe
--- /dev/null
+++ b/contrib/draco/src/draco/compression/entropy/symbol_coding_test.cc
@@ -0,0 +1,170 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/entropy/symbol_decoding.h"
+#include "draco/compression/entropy/symbol_encoding.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+class SymbolCodingTest : public ::testing::Test {
+ protected:
+  SymbolCodingTest() : bitstream_version_(kDracoMeshBitstreamVersion) {}
+
+  template <class SignedIntTypeT>
+  void TestConvertToSymbolAndBack(SignedIntTypeT x) {
+    typedef typename std::make_unsigned<SignedIntTypeT>::type Symbol;
+    Symbol symbol = ConvertSignedIntToSymbol(x);
+    SignedIntTypeT y = ConvertSymbolToSignedInt(symbol);
+    ASSERT_EQ(x, y);
+  }
+
+  uint16_t bitstream_version_;
+};
+
+TEST_F(SymbolCodingTest, TestLargeNumbers) {
+  // This test verifies that SymbolCoding successfully encodes an array of large
+  // numbers.
+  const uint32_t in[] = {12345678, 1223333, 111, 5};
+  const int num_values = sizeof(in) / sizeof(uint32_t);
+  EncoderBuffer eb;
+  ASSERT_TRUE(EncodeSymbols(in, num_values, 1, nullptr, &eb));
+
+  std::vector<uint32_t> out;
+  out.resize(num_values);
+  DecoderBuffer db;
+  db.Init(eb.data(), eb.size());
+  db.set_bitstream_version(bitstream_version_);
+  ASSERT_TRUE(DecodeSymbols(num_values, 1, &db, &out[0]));
+  for (int i = 0; i < num_values; ++i) {
+    EXPECT_EQ(in[i], out[i]);
+  }
+}
+
+TEST_F(SymbolCodingTest, TestManyNumbers) {
+  // This test verifies that SymbolCoding successfully encodes an array of
+  // several numbers that repeat many times.
+
+  // Value/frequency pairs.
+  const std::pair<uint32_t, uint32_t> in[] = {
+      {12, 1500}, {1025, 31000}, {7, 1}, {9, 5}, {0, 6432}};
+
+  const int num_pairs = sizeof(in) / sizeof(std::pair<uint32_t, uint32_t>);
+
+  std::vector<uint32_t> in_values;
+  for (int i = 0; i < num_pairs; ++i) {
+    in_values.insert(in_values.end(), in[i].second, in[i].first);
+  }
+  for (int method = 0; method < NUM_SYMBOL_CODING_METHODS; ++method) {
+    // Test the encoding using all available symbol coding methods.
+    Options options;
+    SetSymbolEncodingMethod(&options, static_cast<SymbolCodingMethod>(method));
+
+    EncoderBuffer eb;
+    ASSERT_TRUE(
+        EncodeSymbols(in_values.data(), in_values.size(), 1, &options, &eb));
+    std::vector<uint32_t> out_values;
+    out_values.resize(in_values.size());
+    DecoderBuffer db;
+    db.Init(eb.data(), eb.size());
+    db.set_bitstream_version(bitstream_version_);
+    ASSERT_TRUE(DecodeSymbols(in_values.size(), 1, &db, &out_values[0]));
+    for (uint32_t i = 0; i < in_values.size(); ++i) {
+      ASSERT_EQ(in_values[i], out_values[i]);
+    }
+  }
+}
+
+TEST_F(SymbolCodingTest, TestEmpty) {
+  // This test verifies that SymbolCoding successfully encodes an empty array.
+  EncoderBuffer eb;
+  ASSERT_TRUE(EncodeSymbols(nullptr, 0, 1, nullptr, &eb));
+  DecoderBuffer db;
+  db.Init(eb.data(), eb.size());
+  db.set_bitstream_version(bitstream_version_);
+  ASSERT_TRUE(DecodeSymbols(0, 1, &db, nullptr));
+}
+
+TEST_F(SymbolCodingTest, TestOneSymbol) {
+  // This test verifies that SymbolCoding successfully encodes an a single
+  // symbol.
+  EncoderBuffer eb;
+  const std::vector<uint32_t> in(1200, 0);
+  ASSERT_TRUE(EncodeSymbols(in.data(), in.size(), 1, nullptr, &eb));
+
+  std::vector<uint32_t> out(in.size());
+  DecoderBuffer db;
+  db.Init(eb.data(), eb.size());
+  db.set_bitstream_version(bitstream_version_);
+  ASSERT_TRUE(DecodeSymbols(in.size(), 1, &db, &out[0]));
+  for (uint32_t i = 0; i < in.size(); ++i) {
+    ASSERT_EQ(in[i], out[i]);
+  }
+}
+
+TEST_F(SymbolCodingTest, TestBitLengths) {
+  // This test verifies that SymbolCoding successfully encodes symbols of
+  // various bit lengths
+  EncoderBuffer eb;
+  std::vector<uint32_t> in;
+  constexpr int bit_lengths = 18;
+  for (int i = 0; i < bit_lengths; ++i) {
+    in.push_back(1 << i);
+  }
+  std::vector<uint32_t> out(in.size());
+  for (int i = 0; i < bit_lengths; ++i) {
+    eb.Clear();
+    ASSERT_TRUE(EncodeSymbols(in.data(), i + 1, 1, nullptr, &eb));
+    DecoderBuffer db;
+    db.Init(eb.data(), eb.size());
+    db.set_bitstream_version(bitstream_version_);
+    ASSERT_TRUE(DecodeSymbols(i + 1, 1, &db, &out[0]));
+    for (int j = 0; j < i + 1; ++j) {
+      ASSERT_EQ(in[j], out[j]);
+    }
+  }
+}
+
+TEST_F(SymbolCodingTest, TestLargeNumberCondition) {
+  // This test verifies that SymbolCoding successfully encodes large symbols
+  // that are on the boundary between raw scheme and tagged scheme (18 bits).
+  EncoderBuffer eb;
+  constexpr int num_symbols = 1000000;
+  const std::vector<uint32_t> in(num_symbols, 1 << 18);
+  ASSERT_TRUE(EncodeSymbols(in.data(), in.size(), 1, nullptr, &eb));
+
+  std::vector<uint32_t> out(in.size());
+  DecoderBuffer db;
+  db.Init(eb.data(), eb.size());
+  db.set_bitstream_version(bitstream_version_);
+  ASSERT_TRUE(DecodeSymbols(in.size(), 1, &db, &out[0]));
+  for (uint32_t i = 0; i < in.size(); ++i) {
+    ASSERT_EQ(in[i], out[i]);
+  }
+}
+
+TEST_F(SymbolCodingTest, TestConversionFullRange) {
+  TestConvertToSymbolAndBack(static_cast<int8_t>(-128));
+  TestConvertToSymbolAndBack(static_cast<int8_t>(-127));
+  TestConvertToSymbolAndBack(static_cast<int8_t>(-1));
+  TestConvertToSymbolAndBack(static_cast<int8_t>(0));
+  TestConvertToSymbolAndBack(static_cast<int8_t>(1));
+  TestConvertToSymbolAndBack(static_cast<int8_t>(127));
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/entropy/symbol_decoding.cc b/contrib/draco/src/draco/compression/entropy/symbol_decoding.cc
new file mode 100644
index 000000000..93d29971c
--- /dev/null
+++ b/contrib/draco/src/draco/compression/entropy/symbol_decoding.cc
@@ -0,0 +1,181 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/entropy/symbol_decoding.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/compression/entropy/rans_symbol_decoder.h"
+
+namespace draco {
+
+template <template <int> class SymbolDecoderT>
+bool DecodeTaggedSymbols(uint32_t num_values, int num_components,
+                         DecoderBuffer *src_buffer, uint32_t *out_values);
+
+template <template <int> class SymbolDecoderT>
+bool DecodeRawSymbols(uint32_t num_values, DecoderBuffer *src_buffer,
+                      uint32_t *out_values);
+
+bool DecodeSymbols(uint32_t num_values, int num_components,
+                   DecoderBuffer *src_buffer, uint32_t *out_values) {
+  if (num_values == 0) {
+    return true;
+  }
+  // Decode which scheme to use.
+  uint8_t scheme;
+  if (!src_buffer->Decode(&scheme)) {
+    return false;
+  }
+  if (scheme == SYMBOL_CODING_TAGGED) {
+    return DecodeTaggedSymbols<RAnsSymbolDecoder>(num_values, num_components,
+                                                  src_buffer, out_values);
+  } else if (scheme == SYMBOL_CODING_RAW) {
+    return DecodeRawSymbols<RAnsSymbolDecoder>(num_values, src_buffer,
+                                               out_values);
+  }
+  return false;
+}
+
+template <template <int> class SymbolDecoderT>
+bool DecodeTaggedSymbols(uint32_t num_values, int num_components,
+                         DecoderBuffer *src_buffer, uint32_t *out_values) {
+  // Decode the encoded data.
+  SymbolDecoderT<5> tag_decoder;
+  if (!tag_decoder.Create(src_buffer)) {
+    return false;
+  }
+
+  if (!tag_decoder.StartDecoding(src_buffer)) {
+    return false;
+  }
+
+  if (num_values > 0 && tag_decoder.num_symbols() == 0) {
+    return false;  // Wrong number of symbols.
+  }
+
+  // src_buffer now points behind the encoded tag data (to the place where the
+  // values are encoded).
+  src_buffer->StartBitDecoding(false, nullptr);
+  int value_id = 0;
+  for (uint32_t i = 0; i < num_values; i += num_components) {
+    // Decode the tag.
+    const int bit_length = tag_decoder.DecodeSymbol();
+    // Decode the actual value.
+    for (int j = 0; j < num_components; ++j) {
+      uint32_t val;
+      if (!src_buffer->DecodeLeastSignificantBits32(bit_length, &val)) {
+        return false;
+      }
+      out_values[value_id++] = val;
+    }
+  }
+  tag_decoder.EndDecoding();
+  src_buffer->EndBitDecoding();
+  return true;
+}
+
+template <class SymbolDecoderT>
+bool DecodeRawSymbolsInternal(uint32_t num_values, DecoderBuffer *src_buffer,
+                              uint32_t *out_values) {
+  SymbolDecoderT decoder;
+  if (!decoder.Create(src_buffer)) {
+    return false;
+  }
+
+  if (num_values > 0 && decoder.num_symbols() == 0) {
+    return false;  // Wrong number of symbols.
+  }
+
+  if (!decoder.StartDecoding(src_buffer)) {
+    return false;
+  }
+  for (uint32_t i = 0; i < num_values; ++i) {
+    // Decode a symbol into the value.
+    const uint32_t value = decoder.DecodeSymbol();
+    out_values[i] = value;
+  }
+  decoder.EndDecoding();
+  return true;
+}
+
+template <template <int> class SymbolDecoderT>
+bool DecodeRawSymbols(uint32_t num_values, DecoderBuffer *src_buffer,
+                      uint32_t *out_values) {
+  uint8_t max_bit_length;
+  if (!src_buffer->Decode(&max_bit_length)) {
+    return false;
+  }
+  switch (max_bit_length) {
+    case 1:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<1>>(num_values, src_buffer,
+                                                         out_values);
+    case 2:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<2>>(num_values, src_buffer,
+                                                         out_values);
+    case 3:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<3>>(num_values, src_buffer,
+                                                         out_values);
+    case 4:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<4>>(num_values, src_buffer,
+                                                         out_values);
+    case 5:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<5>>(num_values, src_buffer,
+                                                         out_values);
+    case 6:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<6>>(num_values, src_buffer,
+                                                         out_values);
+    case 7:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<7>>(num_values, src_buffer,
+                                                         out_values);
+    case 8:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<8>>(num_values, src_buffer,
+                                                         out_values);
+    case 9:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<9>>(num_values, src_buffer,
+                                                         out_values);
+    case 10:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<10>>(
+          num_values, src_buffer, out_values);
+    case 11:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<11>>(
+          num_values, src_buffer, out_values);
+    case 12:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<12>>(
+          num_values, src_buffer, out_values);
+    case 13:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<13>>(
+          num_values, src_buffer, out_values);
+    case 14:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<14>>(
+          num_values, src_buffer, out_values);
+    case 15:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<15>>(
+          num_values, src_buffer, out_values);
+    case 16:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<16>>(
+          num_values, src_buffer, out_values);
+    case 17:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<17>>(
+          num_values, src_buffer, out_values);
+    case 18:
+      return DecodeRawSymbolsInternal<SymbolDecoderT<18>>(
+          num_values, src_buffer, out_values);
+    default:
+      return false;
+  }
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/entropy/symbol_decoding.h b/contrib/draco/src/draco/compression/entropy/symbol_decoding.h
new file mode 100644
index 000000000..ea11165c3
--- /dev/null
+++ b/contrib/draco/src/draco/compression/entropy/symbol_decoding.h
@@ -0,0 +1,29 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_SYMBOL_DECODING_H_
+#define DRACO_COMPRESSION_ENTROPY_SYMBOL_DECODING_H_
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// Decodes an array of symbols that was previously encoded with an entropy code.
+// Returns false on error.
+bool DecodeSymbols(uint32_t num_values, int num_components,
+                   DecoderBuffer *src_buffer, uint32_t *out_values);
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_SYMBOL_DECODING_H_
diff --git a/contrib/draco/src/draco/compression/entropy/symbol_encoding.cc b/contrib/draco/src/draco/compression/entropy/symbol_encoding.cc
new file mode 100644
index 000000000..710c96284
--- /dev/null
+++ b/contrib/draco/src/draco/compression/entropy/symbol_encoding.cc
@@ -0,0 +1,376 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/entropy/symbol_encoding.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/compression/entropy/rans_symbol_encoder.h"
+#include "draco/compression/entropy/shannon_entropy.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+constexpr int32_t kMaxTagSymbolBitLength = 32;
+constexpr int kMaxRawEncodingBitLength = 18;
+constexpr int kDefaultSymbolCodingCompressionLevel = 7;
+
+typedef uint64_t TaggedBitLengthFrequencies[kMaxTagSymbolBitLength];
+
+void SetSymbolEncodingMethod(Options *options, SymbolCodingMethod method) {
+  options->SetInt("symbol_encoding_method", method);
+}
+
+bool SetSymbolEncodingCompressionLevel(Options *options,
+                                       int compression_level) {
+  if (compression_level < 0 || compression_level > 10) {
+    return false;
+  }
+  options->SetInt("symbol_encoding_compression_level", compression_level);
+  return true;
+}
+
+// Computes bit lengths of the input values. If num_components > 1, the values
+// are processed in "num_components" sized chunks and the bit length is always
+// computed for the largest value from the chunk.
+static void ComputeBitLengths(const uint32_t *symbols, int num_values,
+                              int num_components,
+                              std::vector<uint32_t> *out_bit_lengths,
+                              uint32_t *out_max_value) {
+  out_bit_lengths->reserve(num_values);
+  *out_max_value = 0;
+  // Maximum integer value across all components.
+  for (int i = 0; i < num_values; i += num_components) {
+    // Get the maximum value for a given entry across all attribute components.
+    uint32_t max_component_value = symbols[i];
+    for (int j = 1; j < num_components; ++j) {
+      if (max_component_value < symbols[i + j]) {
+        max_component_value = symbols[i + j];
+      }
+    }
+    int value_msb_pos = 0;
+    if (max_component_value > 0) {
+      value_msb_pos = MostSignificantBit(max_component_value);
+    }
+    if (max_component_value > *out_max_value) {
+      *out_max_value = max_component_value;
+    }
+    out_bit_lengths->push_back(value_msb_pos + 1);
+  }
+}
+
+static int64_t ApproximateTaggedSchemeBits(
+    const std::vector<uint32_t> bit_lengths, int num_components) {
+  // Compute the total bit length used by all values (the length of data encode
+  // after tags).
+  uint64_t total_bit_length = 0;
+  for (size_t i = 0; i < bit_lengths.size(); ++i) {
+    total_bit_length += bit_lengths[i];
+  }
+  // Compute the number of entropy bits for tags.
+  int num_unique_symbols;
+  const int64_t tag_bits = ComputeShannonEntropy(
+      bit_lengths.data(), static_cast<int>(bit_lengths.size()), 32,
+      &num_unique_symbols);
+  const int64_t tag_table_bits =
+      ApproximateRAnsFrequencyTableBits(num_unique_symbols, num_unique_symbols);
+  return tag_bits + tag_table_bits + total_bit_length * num_components;
+}
+
+static int64_t ApproximateRawSchemeBits(const uint32_t *symbols,
+                                        int num_symbols, uint32_t max_value,
+                                        int *out_num_unique_symbols) {
+  int num_unique_symbols;
+  const int64_t data_bits = ComputeShannonEntropy(
+      symbols, num_symbols, max_value, &num_unique_symbols);
+  const int64_t table_bits =
+      ApproximateRAnsFrequencyTableBits(max_value, num_unique_symbols);
+  *out_num_unique_symbols = num_unique_symbols;
+  return table_bits + data_bits;
+}
+
+template <template <int> class SymbolEncoderT>
+bool EncodeTaggedSymbols(const uint32_t *symbols, int num_values,
+                         int num_components,
+                         const std::vector<uint32_t> &bit_lengths,
+                         EncoderBuffer *target_buffer);
+
+template <template <int> class SymbolEncoderT>
+bool EncodeRawSymbols(const uint32_t *symbols, int num_values,
+                      uint32_t max_entry_value, int32_t num_unique_symbols,
+                      const Options *options, EncoderBuffer *target_buffer);
+
+bool EncodeSymbols(const uint32_t *symbols, int num_values, int num_components,
+                   const Options *options, EncoderBuffer *target_buffer) {
+  if (num_values < 0) {
+    return false;
+  }
+  if (num_values == 0) {
+    return true;
+  }
+  if (num_components <= 0) {
+    num_components = 1;
+  }
+  std::vector<uint32_t> bit_lengths;
+  uint32_t max_value;
+  ComputeBitLengths(symbols, num_values, num_components, &bit_lengths,
+                    &max_value);
+
+  // Approximate number of bits needed for storing the symbols using the tagged
+  // scheme.
+  const int64_t tagged_scheme_total_bits =
+      ApproximateTaggedSchemeBits(bit_lengths, num_components);
+
+  // Approximate number of bits needed for storing the symbols using the raw
+  // scheme.
+  int num_unique_symbols = 0;
+  const int64_t raw_scheme_total_bits = ApproximateRawSchemeBits(
+      symbols, num_values, max_value, &num_unique_symbols);
+
+  // The maximum bit length of a single entry value that we can encode using
+  // the raw scheme.
+  const int max_value_bit_length =
+      MostSignificantBit(std::max(1u, max_value)) + 1;
+
+  int method = -1;
+  if (options != nullptr && options->IsOptionSet("symbol_encoding_method")) {
+    method = options->GetInt("symbol_encoding_method");
+  } else {
+    if (tagged_scheme_total_bits < raw_scheme_total_bits ||
+        max_value_bit_length > kMaxRawEncodingBitLength) {
+      method = SYMBOL_CODING_TAGGED;
+    } else {
+      method = SYMBOL_CODING_RAW;
+    }
+  }
+  // Use the tagged scheme.
+  target_buffer->Encode(static_cast<uint8_t>(method));
+  if (method == SYMBOL_CODING_TAGGED) {
+    return EncodeTaggedSymbols<RAnsSymbolEncoder>(
+        symbols, num_values, num_components, bit_lengths, target_buffer);
+  }
+  if (method == SYMBOL_CODING_RAW) {
+    return EncodeRawSymbols<RAnsSymbolEncoder>(symbols, num_values, max_value,
+                                               num_unique_symbols, options,
+                                               target_buffer);
+  }
+  // Unknown method selected.
+  return false;
+}
+
+template <template <int> class SymbolEncoderT>
+bool EncodeTaggedSymbols(const uint32_t *symbols, int num_values,
+                         int num_components,
+                         const std::vector<uint32_t> &bit_lengths,
+                         EncoderBuffer *target_buffer) {
+  // Create entries for entropy coding. Each entry corresponds to a different
+  // number of bits that are necessary to encode a given value. Every value
+  // has at most 32 bits. Therefore, we need 32 different entries (for
+  // bit_length [1-32]). For each entry we compute the frequency of a given
+  // bit-length in our data set.
+  TaggedBitLengthFrequencies frequencies;
+  // Set frequency for each entry to zero.
+  memset(frequencies, 0, sizeof(frequencies));
+
+  // Compute the frequencies from input data.
+  // Maximum integer value for the values across all components.
+  for (size_t i = 0; i < bit_lengths.size(); ++i) {
+    // Update the frequency of the associated entry id.
+    ++frequencies[bit_lengths[i]];
+  }
+
+  // Create one extra buffer to store raw value.
+  EncoderBuffer value_buffer;
+  // Number of expected bits we need to store the values (can be optimized if
+  // needed).
+  const uint64_t value_bits =
+      kMaxTagSymbolBitLength * static_cast<uint64_t>(num_values);
+
+  // Create encoder for encoding the bit tags.
+  SymbolEncoderT<5> tag_encoder;
+  tag_encoder.Create(frequencies, kMaxTagSymbolBitLength, target_buffer);
+
+  // Start encoding bit tags.
+  tag_encoder.StartEncoding(target_buffer);
+
+  // Also start encoding the values.
+  value_buffer.StartBitEncoding(value_bits, false);
+
+  if (tag_encoder.needs_reverse_encoding()) {
+    // Encoder needs the values to be encoded in the reverse order.
+    for (int i = num_values - num_components; i >= 0; i -= num_components) {
+      const int bit_length = bit_lengths[i / num_components];
+      tag_encoder.EncodeSymbol(bit_length);
+
+      // Values are always encoded in the normal order
+      const int j = num_values - num_components - i;
+      const int value_bit_length = bit_lengths[j / num_components];
+      for (int c = 0; c < num_components; ++c) {
+        value_buffer.EncodeLeastSignificantBits32(value_bit_length,
+                                                  symbols[j + c]);
+      }
+    }
+  } else {
+    for (int i = 0; i < num_values; i += num_components) {
+      const int bit_length = bit_lengths[i / num_components];
+      // First encode the tag.
+      tag_encoder.EncodeSymbol(bit_length);
+      // Now encode all values using the stored bit_length.
+      for (int j = 0; j < num_components; ++j) {
+        value_buffer.EncodeLeastSignificantBits32(bit_length, symbols[i + j]);
+      }
+    }
+  }
+  tag_encoder.EndEncoding(target_buffer);
+  value_buffer.EndBitEncoding();
+
+  // Append the values to the end of the target buffer.
+  target_buffer->Encode(value_buffer.data(), value_buffer.size());
+  return true;
+}
+
+template <class SymbolEncoderT>
+bool EncodeRawSymbolsInternal(const uint32_t *symbols, int num_values,
+                              uint32_t max_entry_value,
+                              EncoderBuffer *target_buffer) {
+  // Count the frequency of each entry value.
+  std::vector<uint64_t> frequencies(max_entry_value + 1, 0);
+  for (int i = 0; i < num_values; ++i) {
+    ++frequencies[symbols[i]];
+  }
+
+  SymbolEncoderT encoder;
+  encoder.Create(frequencies.data(), static_cast<int>(frequencies.size()),
+                 target_buffer);
+  encoder.StartEncoding(target_buffer);
+  // Encode all values.
+  if (SymbolEncoderT::needs_reverse_encoding()) {
+    for (int i = num_values - 1; i >= 0; --i) {
+      encoder.EncodeSymbol(symbols[i]);
+    }
+  } else {
+    for (int i = 0; i < num_values; ++i) {
+      encoder.EncodeSymbol(symbols[i]);
+    }
+  }
+  encoder.EndEncoding(target_buffer);
+  return true;
+}
+
+template <template <int> class SymbolEncoderT>
+bool EncodeRawSymbols(const uint32_t *symbols, int num_values,
+                      uint32_t max_entry_value, int32_t num_unique_symbols,
+                      const Options *options, EncoderBuffer *target_buffer) {
+  int symbol_bits = 0;
+  if (num_unique_symbols > 0) {
+    symbol_bits = MostSignificantBit(num_unique_symbols);
+  }
+  int unique_symbols_bit_length = symbol_bits + 1;
+  // Currently, we don't support encoding of more than 2^18 unique symbols.
+  if (unique_symbols_bit_length > kMaxRawEncodingBitLength) {
+    return false;
+  }
+  int compression_level = kDefaultSymbolCodingCompressionLevel;
+  if (options != nullptr &&
+      options->IsOptionSet("symbol_encoding_compression_level")) {
+    compression_level = options->GetInt("symbol_encoding_compression_level");
+  }
+
+  // Adjust the bit_length based on compression level. Lower compression levels
+  // will use fewer bits while higher compression levels use more bits. Note
+  // that this is going to work for all valid bit_lengths because the actual
+  // number of bits allocated for rANS encoding is hard coded as:
+  // std::max(12, 3 * bit_length / 2) , therefore there will be always a
+  // sufficient number of bits available for all symbols.
+  // See ComputeRAnsPrecisionFromUniqueSymbolsBitLength() for the formula.
+  // This hardcoded equation cannot be changed without changing the bitstream.
+  if (compression_level < 4) {
+    unique_symbols_bit_length -= 2;
+  } else if (compression_level < 6) {
+    unique_symbols_bit_length -= 1;
+  } else if (compression_level > 9) {
+    unique_symbols_bit_length += 2;
+  } else if (compression_level > 7) {
+    unique_symbols_bit_length += 1;
+  }
+  // Clamp the bit_length to a valid range.
+  unique_symbols_bit_length = std::min(std::max(1, unique_symbols_bit_length),
+                                       kMaxRawEncodingBitLength);
+  target_buffer->Encode(static_cast<uint8_t>(unique_symbols_bit_length));
+  // Use appropriate symbol encoder based on the maximum symbol bit length.
+  switch (unique_symbols_bit_length) {
+    case 0:
+      FALLTHROUGH_INTENDED;
+    case 1:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<1>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 2:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<2>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 3:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<3>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 4:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<4>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 5:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<5>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 6:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<6>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 7:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<7>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 8:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<8>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 9:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<9>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 10:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<10>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 11:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<11>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 12:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<12>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 13:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<13>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 14:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<14>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 15:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<15>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 16:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<16>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 17:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<17>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    case 18:
+      return EncodeRawSymbolsInternal<SymbolEncoderT<18>>(
+          symbols, num_values, max_entry_value, target_buffer);
+    default:
+      return false;
+  }
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/entropy/symbol_encoding.h b/contrib/draco/src/draco/compression/entropy/symbol_encoding.h
new file mode 100644
index 000000000..839b28b17
--- /dev/null
+++ b/contrib/draco/src/draco/compression/entropy/symbol_encoding.h
@@ -0,0 +1,47 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_ENTROPY_SYMBOL_ENCODING_H_
+#define DRACO_COMPRESSION_ENTROPY_SYMBOL_ENCODING_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/options.h"
+
+namespace draco {
+
+// Encodes an array of symbols using an entropy coding. This function
+// automatically decides whether to encode the symbol values using bit
+// length tags (see EncodeTaggedSymbols), or whether to encode them directly
+// (see EncodeRawSymbols). The symbols can be grouped into separate components
+// that can be used for better compression. |options| is an optional parameter
+// that allows more direct control over various stages of the symbol encoding
+// (see below for functions that are used to set valid options).
+// Returns false on error.
+bool EncodeSymbols(const uint32_t *symbols, int num_values, int num_components,
+                   const Options *options, EncoderBuffer *target_buffer);
+
+// Sets an option that forces symbol encoder to use the specified encoding
+// method.
+void SetSymbolEncodingMethod(Options *options, SymbolCodingMethod method);
+
+// Sets the desired compression level for symbol encoding in range <0, 10> where
+// 0 is the worst but fastest compression and 10 is the best but slowest
+// compression. If the option is not set, default value of 7 is used.
+// Returns false if an invalid level has been set.
+bool SetSymbolEncodingCompressionLevel(Options *options, int compression_level);
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_ENTROPY_SYMBOL_ENCODING_H_
diff --git a/contrib/draco/src/draco/compression/expert_encode.cc b/contrib/draco/src/draco/compression/expert_encode.cc
new file mode 100644
index 000000000..f9aec15eb
--- /dev/null
+++ b/contrib/draco/src/draco/compression/expert_encode.cc
@@ -0,0 +1,182 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/expert_encode.h"
+
+#include "draco/compression/mesh/mesh_edgebreaker_encoder.h"
+#include "draco/compression/mesh/mesh_sequential_encoder.h"
+#ifdef DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED
+#include "draco/compression/point_cloud/point_cloud_kd_tree_encoder.h"
+#include "draco/compression/point_cloud/point_cloud_sequential_encoder.h"
+#endif
+
+namespace draco {
+
+ExpertEncoder::ExpertEncoder(const PointCloud &point_cloud)
+    : point_cloud_(&point_cloud), mesh_(nullptr) {}
+
+ExpertEncoder::ExpertEncoder(const Mesh &mesh)
+    : point_cloud_(&mesh), mesh_(&mesh) {}
+
+Status ExpertEncoder::EncodeToBuffer(EncoderBuffer *out_buffer) {
+  if (point_cloud_ == nullptr) {
+    return Status(Status::DRACO_ERROR, "Invalid input geometry.");
+  }
+  if (mesh_ == nullptr) {
+    return EncodePointCloudToBuffer(*point_cloud_, out_buffer);
+  }
+  return EncodeMeshToBuffer(*mesh_, out_buffer);
+}
+
+Status ExpertEncoder::EncodePointCloudToBuffer(const PointCloud &pc,
+                                               EncoderBuffer *out_buffer) {
+#ifdef DRACO_POINT_CLOUD_COMPRESSION_SUPPORTED
+  std::unique_ptr<PointCloudEncoder> encoder;
+  const int encoding_method = options().GetGlobalInt("encoding_method", -1);
+
+  if (encoding_method == POINT_CLOUD_SEQUENTIAL_ENCODING) {
+    // Use sequential encoding if requested.
+    encoder.reset(new PointCloudSequentialEncoder());
+  } else if (encoding_method == -1 && options().GetSpeed() == 10) {
+    // Use sequential encoding if speed is at max.
+    encoder.reset(new PointCloudSequentialEncoder());
+  } else {
+    // Speed < 10, use POINT_CLOUD_KD_TREE_ENCODING if possible.
+    bool kd_tree_possible = true;
+    // Kd-Tree encoder can be currently used only when the following conditions
+    // are satisfied for all attributes:
+    //     -data type is float32 and quantization is enabled, OR
+    //     -data type is uint32, uint16, uint8 or int32, int16, int8
+    for (int i = 0; i < pc.num_attributes(); ++i) {
+      const PointAttribute *const att = pc.attribute(i);
+      if (kd_tree_possible && att->data_type() != DT_FLOAT32 &&
+          att->data_type() != DT_UINT32 && att->data_type() != DT_UINT16 &&
+          att->data_type() != DT_UINT8 && att->data_type() != DT_INT32 &&
+          att->data_type() != DT_INT16 && att->data_type() != DT_INT8) {
+        kd_tree_possible = false;
+      }
+      if (kd_tree_possible && att->data_type() == DT_FLOAT32 &&
+          options().GetAttributeInt(i, "quantization_bits", -1) <= 0) {
+        kd_tree_possible = false;  // Quantization not enabled.
+      }
+      if (!kd_tree_possible) {
+        break;
+      }
+    }
+
+    if (kd_tree_possible) {
+      // Create kD-tree encoder (all checks passed).
+      encoder.reset(new PointCloudKdTreeEncoder());
+    } else if (encoding_method == POINT_CLOUD_KD_TREE_ENCODING) {
+      // Encoding method was explicitly specified but we cannot use it for
+      // the given input (some of the checks above failed).
+      return Status(Status::DRACO_ERROR, "Invalid encoding method.");
+    }
+  }
+  if (!encoder) {
+    // Default choice.
+    encoder.reset(new PointCloudSequentialEncoder());
+  }
+  encoder->SetPointCloud(pc);
+  DRACO_RETURN_IF_ERROR(encoder->Encode(options(), out_buffer));
+
+  set_num_encoded_points(encoder->num_encoded_points());
+  set_num_encoded_faces(0);
+  return OkStatus();
+#else
+  return Status(Status::DRACO_ERROR, "Point cloud encoding is not enabled.");
+#endif
+}
+
+Status ExpertEncoder::EncodeMeshToBuffer(const Mesh &m,
+                                         EncoderBuffer *out_buffer) {
+  std::unique_ptr<MeshEncoder> encoder;
+  // Select the encoding method only based on the provided options.
+  int encoding_method = options().GetGlobalInt("encoding_method", -1);
+  if (encoding_method == -1) {
+    // For now select the edgebreaker for all options expect of speed 10
+    if (options().GetSpeed() == 10) {
+      encoding_method = MESH_SEQUENTIAL_ENCODING;
+    } else {
+      encoding_method = MESH_EDGEBREAKER_ENCODING;
+    }
+  }
+  if (encoding_method == MESH_EDGEBREAKER_ENCODING) {
+    encoder = std::unique_ptr<MeshEncoder>(new MeshEdgebreakerEncoder());
+  } else {
+    encoder = std::unique_ptr<MeshEncoder>(new MeshSequentialEncoder());
+  }
+  encoder->SetMesh(m);
+  DRACO_RETURN_IF_ERROR(encoder->Encode(options(), out_buffer));
+
+  set_num_encoded_points(encoder->num_encoded_points());
+  set_num_encoded_faces(encoder->num_encoded_faces());
+  return OkStatus();
+}
+
+void ExpertEncoder::Reset(const EncoderOptions &options) {
+  Base::Reset(options);
+}
+
+void ExpertEncoder::Reset() { Base::Reset(); }
+
+void ExpertEncoder::SetSpeedOptions(int encoding_speed, int decoding_speed) {
+  Base::SetSpeedOptions(encoding_speed, decoding_speed);
+}
+
+void ExpertEncoder::SetAttributeQuantization(int32_t attribute_id,
+                                             int quantization_bits) {
+  options().SetAttributeInt(attribute_id, "quantization_bits",
+                            quantization_bits);
+}
+
+void ExpertEncoder::SetAttributeExplicitQuantization(int32_t attribute_id,
+                                                     int quantization_bits,
+                                                     int num_dims,
+                                                     const float *origin,
+                                                     float range) {
+  options().SetAttributeInt(attribute_id, "quantization_bits",
+                            quantization_bits);
+  options().SetAttributeVector(attribute_id, "quantization_origin", num_dims,
+                               origin);
+  options().SetAttributeFloat(attribute_id, "quantization_range", range);
+}
+
+void ExpertEncoder::SetUseBuiltInAttributeCompression(bool enabled) {
+  options().SetGlobalBool("use_built_in_attribute_compression", enabled);
+}
+
+void ExpertEncoder::SetEncodingMethod(int encoding_method) {
+  Base::SetEncodingMethod(encoding_method);
+}
+
+void ExpertEncoder::SetEncodingSubmethod(int encoding_submethod) {
+  Base::SetEncodingSubmethod(encoding_submethod);
+}
+
+Status ExpertEncoder::SetAttributePredictionScheme(
+    int32_t attribute_id, int prediction_scheme_method) {
+  auto att = point_cloud_->attribute(attribute_id);
+  auto att_type = att->attribute_type();
+  const Status status =
+      CheckPredictionScheme(att_type, prediction_scheme_method);
+  if (!status.ok()) {
+    return status;
+  }
+  options().SetAttributeInt(attribute_id, "prediction_scheme",
+                            prediction_scheme_method);
+  return status;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/expert_encode.h b/contrib/draco/src/draco/compression/expert_encode.h
new file mode 100644
index 000000000..ea59393d3
--- /dev/null
+++ b/contrib/draco/src/draco/compression/expert_encode.h
@@ -0,0 +1,147 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_EXPERT_ENCODE_H_
+#define DRACO_COMPRESSION_EXPERT_ENCODE_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/compression/encode_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Advanced helper class for encoding geometry using the Draco compression
+// library. Unlike the basic Encoder (encode.h), this class allows users to
+// specify options for each attribute individually using provided attribute ids.
+// The drawback of this encoder is that it can be used to encode only one model
+// at a time, and for each new model the options need to be set again,
+class ExpertEncoder : public EncoderBase<EncoderOptions> {
+ public:
+  typedef EncoderBase<EncoderOptions> Base;
+  typedef EncoderOptions OptionsType;
+
+  explicit ExpertEncoder(const PointCloud &point_cloud);
+  explicit ExpertEncoder(const Mesh &mesh);
+
+  // Encodes the geometry provided in the constructor to the target buffer.
+  Status EncodeToBuffer(EncoderBuffer *out_buffer);
+
+  // Set encoder options used during the geometry encoding. Note that this call
+  // overwrites any modifications to the options done with the functions below.
+  void Reset(const EncoderOptions &options);
+  void Reset();
+
+  // Sets the desired encoding and decoding speed for the given options.
+  //
+  //  0 = slowest speed, but the best compression.
+  // 10 = fastest, but the worst compression.
+  // -1 = undefined.
+  //
+  // Note that both speed options affect the encoder choice of used methods and
+  // algorithms. For example, a requirement for fast decoding may prevent the
+  // encoder from using the best compression methods even if the encoding speed
+  // is set to 0. In general, the faster of the two options limits the choice of
+  // features that can be used by the encoder. Additionally, setting
+  // |decoding_speed| to be faster than the |encoding_speed| may allow the
+  // encoder to choose the optimal method out of the available features for the
+  // given |decoding_speed|.
+  void SetSpeedOptions(int encoding_speed, int decoding_speed);
+
+  // Sets the quantization compression options for a specific attribute. The
+  // attribute values will be quantized in a box defined by the maximum extent
+  // of the attribute values. I.e., the actual precision of this option depends
+  // on the scale of the attribute values.
+  void SetAttributeQuantization(int32_t attribute_id, int quantization_bits);
+
+  // Sets the explicit quantization compression for a named attribute. The
+  // attribute values will be quantized in a coordinate system defined by the
+  // provided origin and range (the input values should be within interval:
+  // <origin, origin + range>).
+  void SetAttributeExplicitQuantization(int32_t attribute_id,
+                                        int quantization_bits, int num_dims,
+                                        const float *origin, float range);
+
+  // Enables/disables built in entropy coding of attribute values. Disabling
+  // this option may be useful to improve the performance when third party
+  // compression is used on top of the Draco compression. Default: [true].
+  void SetUseBuiltInAttributeCompression(bool enabled);
+
+  // Sets the desired encoding method for a given geometry. By default, encoding
+  // method is selected based on the properties of the input geometry and based
+  // on the other options selected in the used EncoderOptions (such as desired
+  // encoding and decoding speed). This function should be called only when a
+  // specific method is required.
+  //
+  // |encoding_method| can be one of the values defined in
+  // compression/config/compression_shared.h based on the type of the input
+  // geometry that is going to be encoded. For point clouds, allowed entries are
+  //   POINT_CLOUD_SEQUENTIAL_ENCODING
+  //   POINT_CLOUD_KD_TREE_ENCODING
+  //
+  // For meshes the input can be
+  //   MESH_SEQUENTIAL_ENCODING
+  //   MESH_EDGEBREAKER_ENCODING
+  //
+  // If the selected method cannot be used for the given input, the subsequent
+  // call of EncodePointCloudToBuffer or EncodeMeshToBuffer is going to fail.
+  void SetEncodingMethod(int encoding_method);
+
+  // Sets the desired encoding submethod, only for MESH_EDGEBREAKER_ENCODING.
+  // Valid values for |encoding_submethod| are:
+  //   MESH_EDGEBREAKER_STANDARD_ENCODING
+  //   MESH_EDGEBREAKER_VALENCE_ENCODING
+  // see also compression/config/compression_shared.h.
+  void SetEncodingSubmethod(int encoding_submethod);
+
+  // Sets the desired prediction method for a given attribute. By default,
+  // prediction scheme is selected automatically by the encoder using other
+  // provided options (such as speed) and input geometry type (mesh, point
+  // cloud). This function should be called only when a specific prediction is
+  // preferred (e.g., when it is known that the encoder would select a less
+  // optimal prediction for the given input data).
+  //
+  // |prediction_scheme_method| should be one of the entries defined in
+  // compression/config/compression_shared.h :
+  //
+  //   PREDICTION_NONE - use no prediction.
+  //   PREDICTION_DIFFERENCE - delta coding
+  //   MESH_PREDICTION_PARALLELOGRAM - parallelogram prediction for meshes.
+  //   MESH_PREDICTION_CONSTRAINED_PARALLELOGRAM
+  //      - better and more costly version of the parallelogram prediction.
+  //   MESH_PREDICTION_TEX_COORDS_PORTABLE
+  //      - specialized predictor for tex coordinates.
+  //   MESH_PREDICTION_GEOMETRIC_NORMAL
+  //      - specialized predictor for normal coordinates.
+  //
+  // Note that in case the desired prediction cannot be used, the default
+  // prediction will be automatically used instead.
+  Status SetAttributePredictionScheme(int32_t attribute_id,
+                                      int prediction_scheme_method);
+
+ private:
+  Status EncodePointCloudToBuffer(const PointCloud &pc,
+                                  EncoderBuffer *out_buffer);
+
+  Status EncodeMeshToBuffer(const Mesh &m, EncoderBuffer *out_buffer);
+
+  const PointCloud *point_cloud_;
+  const Mesh *mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_EXPERT_ENCODE_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_decoder.cc b/contrib/draco/src/draco/compression/mesh/mesh_decoder.cc
new file mode 100644
index 000000000..6e48e56fb
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_decoder.cc
@@ -0,0 +1,37 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_decoder.h"
+
+namespace draco {
+
+MeshDecoder::MeshDecoder() : mesh_(nullptr) {}
+
+Status MeshDecoder::Decode(const DecoderOptions &options,
+                           DecoderBuffer *in_buffer, Mesh *out_mesh) {
+  mesh_ = out_mesh;
+  return PointCloudDecoder::Decode(options, in_buffer, out_mesh);
+}
+
+bool MeshDecoder::DecodeGeometryData() {
+  if (mesh_ == nullptr) {
+    return false;
+  }
+  if (!DecodeConnectivity()) {
+    return false;
+  }
+  return PointCloudDecoder::DecodeGeometryData();
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_decoder.h b/contrib/draco/src/draco/compression/mesh/mesh_decoder.h
new file mode 100644
index 000000000..397a679d4
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_decoder.h
@@ -0,0 +1,68 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_DECODER_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Class that reconstructs a 3D mesh from input data that was encoded by
+// MeshEncoder.
+class MeshDecoder : public PointCloudDecoder {
+ public:
+  MeshDecoder();
+
+  EncodedGeometryType GetGeometryType() const override {
+    return TRIANGULAR_MESH;
+  }
+
+  // The main entry point for mesh decoding.
+  Status Decode(const DecoderOptions &options, DecoderBuffer *in_buffer,
+                Mesh *out_mesh);
+
+  // Returns the base connectivity of the decoded mesh (or nullptr if it is not
+  // initialized).
+  virtual const CornerTable *GetCornerTable() const { return nullptr; }
+
+  // Returns the attribute connectivity data or nullptr if it does not exist.
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  // Returns the decoding data for a given attribute or nullptr when the data
+  // does not exist.
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  Mesh *mesh() const { return mesh_; }
+
+ protected:
+  bool DecodeGeometryData() override;
+  virtual bool DecodeConnectivity() = 0;
+
+ private:
+  Mesh *mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.cc b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.cc
new file mode 100644
index 000000000..427dd59f5
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.cc
@@ -0,0 +1,70 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_edgebreaker_decoder.h"
+
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h"
+
+namespace draco {
+
+MeshEdgebreakerDecoder::MeshEdgebreakerDecoder() {}
+
+bool MeshEdgebreakerDecoder::CreateAttributesDecoder(int32_t att_decoder_id) {
+  return impl_->CreateAttributesDecoder(att_decoder_id);
+}
+
+bool MeshEdgebreakerDecoder::InitializeDecoder() {
+  uint8_t traversal_decoder_type;
+  if (!buffer()->Decode(&traversal_decoder_type)) {
+    return false;
+  }
+  impl_ = nullptr;
+  if (traversal_decoder_type == MESH_EDGEBREAKER_STANDARD_ENCODING) {
+#ifdef DRACO_STANDARD_EDGEBREAKER_SUPPORTED
+    impl_ = std::unique_ptr<MeshEdgebreakerDecoderImplInterface>(
+        new MeshEdgebreakerDecoderImpl<MeshEdgebreakerTraversalDecoder>());
+#endif
+  } else if (traversal_decoder_type == MESH_EDGEBREAKER_PREDICTIVE_ENCODING) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifdef DRACO_PREDICTIVE_EDGEBREAKER_SUPPORTED
+    impl_ = std::unique_ptr<MeshEdgebreakerDecoderImplInterface>(
+        new MeshEdgebreakerDecoderImpl<
+            MeshEdgebreakerTraversalPredictiveDecoder>());
+#endif
+#endif
+  } else if (traversal_decoder_type == MESH_EDGEBREAKER_VALENCE_ENCODING) {
+    impl_ = std::unique_ptr<MeshEdgebreakerDecoderImplInterface>(
+        new MeshEdgebreakerDecoderImpl<
+            MeshEdgebreakerTraversalValenceDecoder>());
+  }
+  if (!impl_) {
+    return false;
+  }
+  if (!impl_->Init(this)) {
+    return false;
+  }
+  return true;
+}
+
+bool MeshEdgebreakerDecoder::DecodeConnectivity() {
+  return impl_->DecodeConnectivity();
+}
+
+bool MeshEdgebreakerDecoder::OnAttributesDecoded() {
+  return impl_->OnAttributesDecoded();
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.h b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.h
new file mode 100644
index 000000000..5c1617942
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder.h
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_H_
+
+#include "draco/compression/mesh/mesh_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class for decoding data encoded by MeshEdgebreakerEncoder.
+class MeshEdgebreakerDecoder : public MeshDecoder {
+ public:
+  MeshEdgebreakerDecoder();
+
+  const CornerTable *GetCornerTable() const override {
+    return impl_->GetCornerTable();
+  }
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override {
+    return impl_->GetAttributeCornerTable(att_id);
+  }
+
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override {
+    return impl_->GetAttributeEncodingData(att_id);
+  }
+
+ protected:
+  bool InitializeDecoder() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+  bool DecodeConnectivity() override;
+  bool OnAttributesDecoded() override;
+
+  std::unique_ptr<MeshEdgebreakerDecoderImplInterface> impl_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.cc b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.cc
new file mode 100644
index 000000000..0bbbea4af
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.cc
@@ -0,0 +1,1231 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl.h"
+
+#include <algorithm>
+
+#include "draco/compression/attributes/sequential_attribute_decoders_controller.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h"
+#include "draco/compression/mesh/traverser/depth_first_traverser.h"
+#include "draco/compression/mesh/traverser/max_prediction_degree_traverser.h"
+#include "draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h"
+#include "draco/compression/mesh/traverser/mesh_traversal_sequencer.h"
+#include "draco/compression/mesh/traverser/traverser_base.h"
+#include "draco/mesh/corner_table_iterators.h"
+
+namespace draco {
+
+// Types of "free" edges that are used during topology decoding.
+// A free edge is an edge that is connected to one face only.
+// All edge types are stored in the opposite_corner_id_ array, where each
+// edge "e" is uniquely identified by the opposite corner "C" in its parent
+// triangle:
+//          *
+//         /C\
+//        /   \
+//       /  e  \
+//      *-------*
+// For more description about how the edges are used, see comment inside
+// ZipConnectivity() method.
+
+template <class TraversalDecoder>
+MeshEdgebreakerDecoderImpl<TraversalDecoder>::MeshEdgebreakerDecoderImpl()
+    : decoder_(nullptr),
+      last_symbol_id_(-1),
+      last_vert_id_(-1),
+      last_face_id_(-1),
+      num_new_vertices_(0),
+      num_encoded_vertices_(0),
+      pos_data_decoder_id_(-1) {}
+
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<TraversalDecoder>::Init(
+    MeshEdgebreakerDecoder *decoder) {
+  decoder_ = decoder;
+  return true;
+}
+
+template <class TraversalDecoder>
+const MeshAttributeCornerTable *
+MeshEdgebreakerDecoderImpl<TraversalDecoder>::GetAttributeCornerTable(
+    int att_id) const {
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    const int decoder_id = attribute_data_[i].decoder_id;
+    if (decoder_id < 0 || decoder_id >= decoder_->num_attributes_decoders()) {
+      continue;
+    }
+    const AttributesDecoderInterface *const dec =
+        decoder_->attributes_decoder(decoder_id);
+    for (int j = 0; j < dec->GetNumAttributes(); ++j) {
+      if (dec->GetAttributeId(j) == att_id) {
+        if (attribute_data_[i].is_connectivity_used) {
+          return &attribute_data_[i].connectivity_data;
+        }
+        return nullptr;
+      }
+    }
+  }
+  return nullptr;
+}
+
+template <class TraversalDecoder>
+const MeshAttributeIndicesEncodingData *
+MeshEdgebreakerDecoderImpl<TraversalDecoder>::GetAttributeEncodingData(
+    int att_id) const {
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    const int decoder_id = attribute_data_[i].decoder_id;
+    if (decoder_id < 0 || decoder_id >= decoder_->num_attributes_decoders()) {
+      continue;
+    }
+    const AttributesDecoderInterface *const dec =
+        decoder_->attributes_decoder(decoder_id);
+    for (int j = 0; j < dec->GetNumAttributes(); ++j) {
+      if (dec->GetAttributeId(j) == att_id) {
+        return &attribute_data_[i].encoding_data;
+      }
+    }
+  }
+  return &pos_encoding_data_;
+}
+
+template <class TraversalDecoder>
+template <class TraverserT>
+std::unique_ptr<PointsSequencer>
+MeshEdgebreakerDecoderImpl<TraversalDecoder>::CreateVertexTraversalSequencer(
+    MeshAttributeIndicesEncodingData *encoding_data) {
+  typedef typename TraverserT::TraversalObserver AttObserver;
+  typedef typename TraverserT::CornerTable CornerTable;
+
+  const Mesh *mesh = decoder_->mesh();
+  std::unique_ptr<MeshTraversalSequencer<TraverserT>> traversal_sequencer(
+      new MeshTraversalSequencer<TraverserT>(mesh, encoding_data));
+
+  AttObserver att_observer(corner_table_.get(), mesh, traversal_sequencer.get(),
+                           encoding_data);
+
+  TraverserT att_traverser;
+  att_traverser.Init(corner_table_.get(), att_observer);
+
+  traversal_sequencer->SetTraverser(att_traverser);
+  return std::move(traversal_sequencer);
+}
+
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<TraversalDecoder>::CreateAttributesDecoder(
+    int32_t att_decoder_id) {
+  int8_t att_data_id;
+  if (!decoder_->buffer()->Decode(&att_data_id)) {
+    return false;
+  }
+  uint8_t decoder_type;
+  if (!decoder_->buffer()->Decode(&decoder_type)) {
+    return false;
+  }
+
+  if (att_data_id >= 0) {
+    if (att_data_id >= attribute_data_.size()) {
+      return false;  // Unexpected attribute data.
+    }
+
+    // Ensure that the attribute data is not mapped to a different attributes
+    // decoder already.
+    if (attribute_data_[att_data_id].decoder_id >= 0) {
+      return false;
+    }
+
+    attribute_data_[att_data_id].decoder_id = att_decoder_id;
+  } else {
+    // Assign the attributes decoder to |pos_encoding_data_|.
+    if (pos_data_decoder_id_ >= 0) {
+      return false;  // Some other decoder is already using the data. Error.
+    }
+    pos_data_decoder_id_ = att_decoder_id;
+  }
+
+  MeshTraversalMethod traversal_method = MESH_TRAVERSAL_DEPTH_FIRST;
+  if (decoder_->bitstream_version() >= DRACO_BITSTREAM_VERSION(1, 2)) {
+    uint8_t traversal_method_encoded;
+    if (!decoder_->buffer()->Decode(&traversal_method_encoded)) {
+      return false;
+    }
+    // Check that decoded traversal method is valid.
+    if (traversal_method_encoded >= NUM_TRAVERSAL_METHODS) {
+      return false;
+    }
+    traversal_method =
+        static_cast<MeshTraversalMethod>(traversal_method_encoded);
+  }
+
+  const Mesh *mesh = decoder_->mesh();
+  std::unique_ptr<PointsSequencer> sequencer;
+
+  if (decoder_type == MESH_VERTEX_ATTRIBUTE) {
+    // Per-vertex attribute decoder.
+
+    MeshAttributeIndicesEncodingData *encoding_data = nullptr;
+    if (att_data_id < 0) {
+      encoding_data = &pos_encoding_data_;
+    } else {
+      encoding_data = &attribute_data_[att_data_id].encoding_data;
+      // Mark the attribute connectivity data invalid to ensure it's not used
+      // later on.
+      attribute_data_[att_data_id].is_connectivity_used = false;
+    }
+    // Defining sequencer via a traversal scheme.
+    if (traversal_method == MESH_TRAVERSAL_PREDICTION_DEGREE) {
+      typedef MeshAttributeIndicesEncodingObserver<CornerTable> AttObserver;
+      typedef MaxPredictionDegreeTraverser<CornerTable, AttObserver>
+          AttTraverser;
+      sequencer = CreateVertexTraversalSequencer<AttTraverser>(encoding_data);
+    } else if (traversal_method == MESH_TRAVERSAL_DEPTH_FIRST) {
+      typedef MeshAttributeIndicesEncodingObserver<CornerTable> AttObserver;
+      typedef DepthFirstTraverser<CornerTable, AttObserver> AttTraverser;
+      sequencer = CreateVertexTraversalSequencer<AttTraverser>(encoding_data);
+    } else {
+      return false;  // Unsupported method
+    }
+  } else {
+    if (traversal_method != MESH_TRAVERSAL_DEPTH_FIRST) {
+      return false;  // Unsupported method.
+    }
+    if (att_data_id < 0) {
+      return false;  // Attribute data must be specified.
+    }
+
+    // Per-corner attribute decoder.
+
+    typedef MeshAttributeIndicesEncodingObserver<MeshAttributeCornerTable>
+        AttObserver;
+    typedef DepthFirstTraverser<MeshAttributeCornerTable, AttObserver>
+        AttTraverser;
+
+    MeshAttributeIndicesEncodingData *const encoding_data =
+        &attribute_data_[att_data_id].encoding_data;
+    const MeshAttributeCornerTable *const corner_table =
+        &attribute_data_[att_data_id].connectivity_data;
+
+    std::unique_ptr<MeshTraversalSequencer<AttTraverser>> traversal_sequencer(
+        new MeshTraversalSequencer<AttTraverser>(mesh, encoding_data));
+
+    AttObserver att_observer(corner_table, mesh, traversal_sequencer.get(),
+                             encoding_data);
+
+    AttTraverser att_traverser;
+    att_traverser.Init(corner_table, att_observer);
+
+    traversal_sequencer->SetTraverser(att_traverser);
+    sequencer = std::move(traversal_sequencer);
+  }
+
+  if (!sequencer) {
+    return false;
+  }
+
+  std::unique_ptr<SequentialAttributeDecodersController> att_controller(
+      new SequentialAttributeDecodersController(std::move(sequencer)));
+
+  return decoder_->SetAttributesDecoder(att_decoder_id,
+                                        std::move(att_controller));
+}
+
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<TraversalDecoder>::DecodeConnectivity() {
+  num_new_vertices_ = 0;
+  new_to_parent_vertex_map_.clear();
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    uint32_t num_new_verts;
+    if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+      if (!decoder_->buffer()->Decode(&num_new_verts)) {
+        return false;
+      }
+    } else {
+      if (!DecodeVarint(&num_new_verts, decoder_->buffer())) {
+        return false;
+      }
+    }
+    num_new_vertices_ = num_new_verts;
+  }
+#endif
+
+  uint32_t num_encoded_vertices;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!decoder_->buffer()->Decode(&num_encoded_vertices)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_encoded_vertices, decoder_->buffer())) {
+      return false;
+    }
+  }
+  num_encoded_vertices_ = num_encoded_vertices;
+
+  uint32_t num_faces;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!decoder_->buffer()->Decode(&num_faces)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_faces, decoder_->buffer())) {
+      return false;
+    }
+  }
+  if (num_faces > std::numeric_limits<CornerIndex::ValueType>::max() / 3) {
+    return false;  // Draco cannot handle this many faces.
+  }
+
+  if (static_cast<uint32_t>(num_encoded_vertices_) > num_faces * 3) {
+    return false;  // There cannot be more vertices than 3 * num_faces.
+  }
+  uint8_t num_attribute_data;
+  if (!decoder_->buffer()->Decode(&num_attribute_data)) {
+    return false;
+  }
+
+  uint32_t num_encoded_symbols;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!decoder_->buffer()->Decode(&num_encoded_symbols)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_encoded_symbols, decoder_->buffer())) {
+      return false;
+    }
+  }
+
+  if (num_faces < num_encoded_symbols) {
+    // Number of faces needs to be the same or greater than the number of
+    // symbols (it can be greater because the initial face may not be encoded as
+    // a symbol).
+    return false;
+  }
+  const uint32_t max_encoded_faces =
+      num_encoded_symbols + (num_encoded_symbols / 3);
+  if (num_faces > max_encoded_faces) {
+    // Faces can only be 1 1/3 times bigger than number of encoded symbols. This
+    // could only happen if all new encoded components started with interior
+    // triangles. E.g. A mesh with multiple tetrahedrons.
+    return false;
+  }
+
+  uint32_t num_encoded_split_symbols;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!decoder_->buffer()->Decode(&num_encoded_split_symbols)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_encoded_split_symbols, decoder_->buffer())) {
+      return false;
+    }
+  }
+
+  if (num_encoded_split_symbols > num_encoded_symbols) {
+    return false;  // Split symbols are a sub-set of all symbols.
+  }
+
+  // Decode topology (connectivity).
+  vertex_traversal_length_.clear();
+  corner_table_ = std::unique_ptr<CornerTable>(new CornerTable());
+  if (corner_table_ == nullptr) {
+    return false;
+  }
+  processed_corner_ids_.clear();
+  processed_corner_ids_.reserve(num_faces);
+  processed_connectivity_corners_.clear();
+  processed_connectivity_corners_.reserve(num_faces);
+  topology_split_data_.clear();
+  hole_event_data_.clear();
+  init_face_configurations_.clear();
+  init_corners_.clear();
+
+  last_symbol_id_ = -1;
+  last_face_id_ = -1;
+  last_vert_id_ = -1;
+
+  attribute_data_.clear();
+  // Add one attribute data for each attribute decoder.
+  attribute_data_.resize(num_attribute_data);
+
+  if (!corner_table_->Reset(
+          num_faces, num_encoded_vertices_ + num_encoded_split_symbols)) {
+    return false;
+  }
+
+  // Start with all vertices marked as holes (boundaries).
+  // Only vertices decoded with TOPOLOGY_C symbol (and the initial face) will
+  // be marked as non hole vertices. We need to allocate the array larger
+  // because split symbols can create extra vertices during the decoding
+  // process (these extra vertices are then eliminated during deduplication).
+  is_vert_hole_.assign(num_encoded_vertices_ + num_encoded_split_symbols, true);
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  int32_t topology_split_decoded_bytes = -1;
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    uint32_t encoded_connectivity_size;
+    if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+      if (!decoder_->buffer()->Decode(&encoded_connectivity_size)) {
+        return false;
+      }
+    } else {
+      if (!DecodeVarint(&encoded_connectivity_size, decoder_->buffer())) {
+        return false;
+      }
+    }
+    if (encoded_connectivity_size == 0 ||
+        encoded_connectivity_size > decoder_->buffer()->remaining_size()) {
+      return false;
+    }
+    DecoderBuffer event_buffer;
+    event_buffer.Init(
+        decoder_->buffer()->data_head() + encoded_connectivity_size,
+        decoder_->buffer()->remaining_size() - encoded_connectivity_size,
+        decoder_->buffer()->bitstream_version());
+    // Decode hole and topology split events.
+    topology_split_decoded_bytes =
+        DecodeHoleAndTopologySplitEvents(&event_buffer);
+    if (topology_split_decoded_bytes == -1) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (DecodeHoleAndTopologySplitEvents(decoder_->buffer()) == -1) {
+      return false;
+    }
+  }
+
+  traversal_decoder_.Init(this);
+  // Add one extra vertex for each split symbol.
+  traversal_decoder_.SetNumEncodedVertices(num_encoded_vertices_ +
+                                           num_encoded_split_symbols);
+  traversal_decoder_.SetNumAttributeData(num_attribute_data);
+
+  DecoderBuffer traversal_end_buffer;
+  if (!traversal_decoder_.Start(&traversal_end_buffer)) {
+    return false;
+  }
+
+  const int num_connectivity_verts = DecodeConnectivity(num_encoded_symbols);
+  if (num_connectivity_verts == -1) {
+    return false;
+  }
+
+  // Set the main buffer to the end of the traversal.
+  decoder_->buffer()->Init(traversal_end_buffer.data_head(),
+                           traversal_end_buffer.remaining_size(),
+                           decoder_->buffer()->bitstream_version());
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    // Skip topology split data that was already decoded earlier.
+    decoder_->buffer()->Advance(topology_split_decoded_bytes);
+  }
+#endif
+
+  // Decode connectivity of non-position attributes.
+  if (attribute_data_.size() > 0) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 1)) {
+      for (CornerIndex ci(0); ci < corner_table_->num_corners(); ci += 3) {
+        if (!DecodeAttributeConnectivitiesOnFaceLegacy(ci)) {
+          return false;
+        }
+      }
+
+    } else
+#endif
+    {
+      for (CornerIndex ci(0); ci < corner_table_->num_corners(); ci += 3) {
+        if (!DecodeAttributeConnectivitiesOnFace(ci)) {
+          return false;
+        }
+      }
+    }
+  }
+  traversal_decoder_.Done();
+
+  // Decode attribute connectivity.
+  // Prepare data structure for decoding non-position attribute connectivity.
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    attribute_data_[i].connectivity_data.InitEmpty(corner_table_.get());
+    // Add all seams.
+    for (int32_t c : attribute_data_[i].attribute_seam_corners) {
+      attribute_data_[i].connectivity_data.AddSeamEdge(CornerIndex(c));
+    }
+    // Recompute vertices from the newly added seam edges.
+    attribute_data_[i].connectivity_data.RecomputeVertices(nullptr, nullptr);
+  }
+
+  pos_encoding_data_.Init(corner_table_->num_vertices());
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    // For non-position attributes, preallocate the vertex to value mapping
+    // using the maximum number of vertices from the base corner table and the
+    // attribute corner table (since the attribute decoder may use either of
+    // it).
+    int32_t att_connectivity_verts =
+        attribute_data_[i].connectivity_data.num_vertices();
+    if (att_connectivity_verts < corner_table_->num_vertices()) {
+      att_connectivity_verts = corner_table_->num_vertices();
+    }
+    attribute_data_[i].encoding_data.Init(att_connectivity_verts);
+  }
+  if (!AssignPointsToCorners(num_connectivity_verts)) {
+    return false;
+  }
+  return true;
+}
+
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<TraversalDecoder>::OnAttributesDecoded() {
+  return true;
+}
+
+template <class TraversalDecoder>
+int MeshEdgebreakerDecoderImpl<TraversalDecoder>::DecodeConnectivity(
+    int num_symbols) {
+  // Algorithm does the reverse decoding of the symbols encoded with the
+  // edgebreaker method. The reverse decoding always keeps track of the active
+  // edge identified by its opposite corner (active corner). New faces are
+  // always added to this active edge. There may be multiple active corners at
+  // one time that either correspond to separate mesh components or to
+  // sub-components of one mesh that are going to be merged together using the
+  // TOPOLOGY_S symbol. We can store these active edges on a stack, because the
+  // decoder always processes only the latest active edge. TOPOLOGY_S then
+  // removes the top edge from the stack and TOPOLOGY_E adds a new edge to the
+  // stack.
+  std::vector<CornerIndex> active_corner_stack;
+
+  // Additional active edges may be added as a result of topology split events.
+  // They can be added in arbitrary order, but we always know the split symbol
+  // id they belong to, so we can address them using this symbol id.
+  std::unordered_map<int, CornerIndex> topology_split_active_corners;
+
+  // Vector used for storing vertices that were marked as isolated during the
+  // decoding process. Currently used only when the mesh doesn't contain any
+  // non-position connectivity data.
+  std::vector<VertexIndex> invalid_vertices;
+  const bool remove_invalid_vertices = attribute_data_.empty();
+
+  int max_num_vertices = static_cast<int>(is_vert_hole_.size());
+  int num_faces = 0;
+  for (int symbol_id = 0; symbol_id < num_symbols; ++symbol_id) {
+    const FaceIndex face(num_faces++);
+    // Used to flag cases where we need to look for topology split events.
+    bool check_topology_split = false;
+    const uint32_t symbol = traversal_decoder_.DecodeSymbol();
+    if (symbol == TOPOLOGY_C) {
+      // Create a new face between two edges on the open boundary.
+      // The first edge is opposite to the corner "a" from the image below.
+      // The other edge is opposite to the corner "b" that can be reached
+      // through a CCW traversal around the vertex "v".
+      // One new active boundary edge is created, opposite to the new corner
+      // "x".
+      //
+      //     *-------*
+      //    / \     / \
+      //   /   \   /   \
+      //  /     \ /     \
+      // *-------v-------*
+      //  \b    /x\    a/
+      //   \   /   \   /
+      //    \ /  C  \ /
+      //     *.......*
+
+      // Find the corner "b" from the corner "a" which is the corner on the
+      // top of the active stack.
+      if (active_corner_stack.empty()) {
+        return -1;
+      }
+
+      const CornerIndex corner_a = active_corner_stack.back();
+      const VertexIndex vertex_x =
+          corner_table_->Vertex(corner_table_->Next(corner_a));
+      const CornerIndex corner_b =
+          corner_table_->Next(corner_table_->LeftMostCorner(vertex_x));
+
+      // New tip corner.
+      const CornerIndex corner(3 * face.value());
+      // Update opposite corner mappings.
+      SetOppositeCorners(corner_a, corner + 1);
+      SetOppositeCorners(corner_b, corner + 2);
+
+      // Update vertex mapping.
+      const VertexIndex vert_a_prev =
+          corner_table_->Vertex(corner_table_->Previous(corner_a));
+      const VertexIndex vert_b_next =
+          corner_table_->Vertex(corner_table_->Next(corner_b));
+      if (vertex_x == vert_a_prev || vertex_x == vert_b_next) {
+        // Encoding is invalid, because face vertices are degenerate.
+        return -1;
+      }
+      corner_table_->MapCornerToVertex(corner, vertex_x);
+      corner_table_->MapCornerToVertex(corner + 1, vert_b_next);
+      corner_table_->MapCornerToVertex(corner + 2, vert_a_prev);
+      corner_table_->SetLeftMostCorner(vert_a_prev, corner + 2);
+      // Mark the vertex |x| as interior.
+      is_vert_hole_[vertex_x.value()] = false;
+      // Update the corner on the active stack.
+      active_corner_stack.back() = corner;
+    } else if (symbol == TOPOLOGY_R || symbol == TOPOLOGY_L) {
+      // Create a new face extending from the open boundary edge opposite to the
+      // corner "a" from the image below. Two new boundary edges are created
+      // opposite to corners "r" and "l". New active corner is set to either "r"
+      // or "l" depending on the decoded symbol. One new vertex is created
+      // at the opposite corner to corner "a".
+      //     *-------*
+      //    /a\     / \
+      //   /   \   /   \
+      //  /     \ /     \
+      // *-------v-------*
+      //  .l   r.
+      //   .   .
+      //    . .
+      //     *
+      if (active_corner_stack.empty()) {
+        return -1;
+      }
+      const CornerIndex corner_a = active_corner_stack.back();
+
+      // First corner on the new face is either corner "l" or "r".
+      const CornerIndex corner(3 * face.value());
+      CornerIndex opp_corner, corner_l, corner_r;
+      if (symbol == TOPOLOGY_R) {
+        // "r" is the new first corner.
+        opp_corner = corner + 2;
+        corner_l = corner + 1;
+        corner_r = corner;
+      } else {
+        // "l" is the new first corner.
+        opp_corner = corner + 1;
+        corner_l = corner;
+        corner_r = corner + 2;
+      }
+      SetOppositeCorners(opp_corner, corner_a);
+      // Update vertex mapping.
+      const VertexIndex new_vert_index = corner_table_->AddNewVertex();
+
+      if (corner_table_->num_vertices() > max_num_vertices) {
+        return -1;  // Unexpected number of decoded vertices.
+      }
+
+      corner_table_->MapCornerToVertex(opp_corner, new_vert_index);
+      corner_table_->SetLeftMostCorner(new_vert_index, opp_corner);
+
+      const VertexIndex vertex_r =
+          corner_table_->Vertex(corner_table_->Previous(corner_a));
+      corner_table_->MapCornerToVertex(corner_r, vertex_r);
+      // Update left-most corner on the vertex on the |corner_r|.
+      corner_table_->SetLeftMostCorner(vertex_r, corner_r);
+
+      corner_table_->MapCornerToVertex(
+          corner_l, corner_table_->Vertex(corner_table_->Next(corner_a)));
+      active_corner_stack.back() = corner;
+      check_topology_split = true;
+    } else if (symbol == TOPOLOGY_S) {
+      // Create a new face that merges two last active edges from the active
+      // stack. No new vertex is created, but two vertices at corners "p" and
+      // "n" need to be merged into a single vertex.
+      //
+      // *-------v-------*
+      //  \a   p/x\n   b/
+      //   \   /   \   /
+      //    \ /  S  \ /
+      //     *.......*
+      //
+      if (active_corner_stack.empty()) {
+        return -1;
+      }
+      const CornerIndex corner_b = active_corner_stack.back();
+      active_corner_stack.pop_back();
+
+      // Corner "a" can correspond either to a normal active edge, or to an edge
+      // created from the topology split event.
+      const auto it = topology_split_active_corners.find(symbol_id);
+      if (it != topology_split_active_corners.end()) {
+        // Topology split event. Move the retrieved edge to the stack.
+        active_corner_stack.push_back(it->second);
+      }
+      if (active_corner_stack.empty()) {
+        return -1;
+      }
+      const CornerIndex corner_a = active_corner_stack.back();
+
+      if (corner_table_->Opposite(corner_a) != kInvalidCornerIndex ||
+          corner_table_->Opposite(corner_b) != kInvalidCornerIndex) {
+        // One of the corners is already opposite to an existing face, which
+        // should not happen unless the input was tempered with.
+        return -1;
+      }
+
+      // First corner on the new face is corner "x" from the image above.
+      const CornerIndex corner(3 * face.value());
+      // Update the opposite corner mapping.
+      SetOppositeCorners(corner_a, corner + 2);
+      SetOppositeCorners(corner_b, corner + 1);
+      // Update vertices. For the vertex at corner "x", use the vertex id from
+      // the corner "p".
+      const VertexIndex vertex_p =
+          corner_table_->Vertex(corner_table_->Previous(corner_a));
+      corner_table_->MapCornerToVertex(corner, vertex_p);
+      corner_table_->MapCornerToVertex(
+          corner + 1, corner_table_->Vertex(corner_table_->Next(corner_a)));
+      const VertexIndex vert_b_prev =
+          corner_table_->Vertex(corner_table_->Previous(corner_b));
+      corner_table_->MapCornerToVertex(corner + 2, vert_b_prev);
+      corner_table_->SetLeftMostCorner(vert_b_prev, corner + 2);
+      CornerIndex corner_n = corner_table_->Next(corner_b);
+      const VertexIndex vertex_n = corner_table_->Vertex(corner_n);
+      traversal_decoder_.MergeVertices(vertex_p, vertex_n);
+      // Update the left most corner on the newly merged vertex.
+      corner_table_->SetLeftMostCorner(vertex_p,
+                                       corner_table_->LeftMostCorner(vertex_n));
+
+      // Also update the vertex id at corner "n" and all corners that are
+      // connected to it in the CCW direction.
+      while (corner_n != kInvalidCornerIndex) {
+        corner_table_->MapCornerToVertex(corner_n, vertex_p);
+        corner_n = corner_table_->SwingLeft(corner_n);
+      }
+      // Make sure the old vertex n is now mapped to an invalid corner (make it
+      // isolated).
+      corner_table_->MakeVertexIsolated(vertex_n);
+      if (remove_invalid_vertices) {
+        invalid_vertices.push_back(vertex_n);
+      }
+      active_corner_stack.back() = corner;
+    } else if (symbol == TOPOLOGY_E) {
+      const CornerIndex corner(3 * face.value());
+      const VertexIndex first_vert_index = corner_table_->AddNewVertex();
+      // Create three new vertices at the corners of the new face.
+      corner_table_->MapCornerToVertex(corner, first_vert_index);
+      corner_table_->MapCornerToVertex(corner + 1,
+                                       corner_table_->AddNewVertex());
+      corner_table_->MapCornerToVertex(corner + 2,
+                                       corner_table_->AddNewVertex());
+
+      if (corner_table_->num_vertices() > max_num_vertices) {
+        return -1;  // Unexpected number of decoded vertices.
+      }
+
+      corner_table_->SetLeftMostCorner(first_vert_index, corner);
+      corner_table_->SetLeftMostCorner(first_vert_index + 1, corner + 1);
+      corner_table_->SetLeftMostCorner(first_vert_index + 2, corner + 2);
+      // Add the tip corner to the active stack.
+      active_corner_stack.push_back(corner);
+      check_topology_split = true;
+    } else {
+      // Error. Unknown symbol decoded.
+      return -1;
+    }
+    // Inform the traversal decoder that a new corner has been reached.
+    traversal_decoder_.NewActiveCornerReached(active_corner_stack.back());
+
+    if (check_topology_split) {
+      // Check for topology splits happens only for TOPOLOGY_L, TOPOLOGY_R and
+      // TOPOLOGY_E symbols because those are the symbols that correspond to
+      // faces that can be directly connected a TOPOLOGY_S face through the
+      // topology split event.
+      // If a topology split is detected, we need to add a new active edge
+      // onto the active_corner_stack because it will be used later when the
+      // corresponding TOPOLOGY_S event is decoded.
+
+      // Symbol id used by the encoder (reverse).
+      const int encoder_symbol_id = num_symbols - symbol_id - 1;
+      EdgeFaceName split_edge;
+      int encoder_split_symbol_id;
+      while (IsTopologySplit(encoder_symbol_id, &split_edge,
+                             &encoder_split_symbol_id)) {
+        if (encoder_split_symbol_id < 0) {
+          return -1;  // Wrong split symbol id.
+        }
+        // Symbol was part of a topology split. Now we need to determine which
+        // edge should be added to the active edges stack.
+        const CornerIndex act_top_corner = active_corner_stack.back();
+        // The current symbol has one active edge (stored in act_top_corner) and
+        // two remaining inactive edges that are attached to it.
+        //              *
+        //             / \
+        //  left_edge /   \ right_edge
+        //           /     \
+        //          *.......*
+        //         active_edge
+
+        CornerIndex new_active_corner;
+        if (split_edge == RIGHT_FACE_EDGE) {
+          new_active_corner = corner_table_->Next(act_top_corner);
+        } else {
+          new_active_corner = corner_table_->Previous(act_top_corner);
+        }
+        // Add the new active edge.
+        // Convert the encoder split symbol id to decoder symbol id.
+        const int decoder_split_symbol_id =
+            num_symbols - encoder_split_symbol_id - 1;
+        topology_split_active_corners[decoder_split_symbol_id] =
+            new_active_corner;
+      }
+    }
+  }
+  if (corner_table_->num_vertices() > max_num_vertices) {
+    return -1;  // Unexpected number of decoded vertices.
+  }
+  // Decode start faces and connect them to the faces from the active stack.
+  while (active_corner_stack.size() > 0) {
+    const CornerIndex corner = active_corner_stack.back();
+    active_corner_stack.pop_back();
+    const bool interior_face =
+        traversal_decoder_.DecodeStartFaceConfiguration();
+    if (interior_face) {
+      // The start face is interior, we need to find three corners that are
+      // opposite to it. The first opposite corner "a" is the corner from the
+      // top of the active corner stack and the remaining two corners "b" and
+      // "c" are then the next corners from the left-most corners of vertices
+      // "n" and "x" respectively.
+      //
+      //           *-------*
+      //          / \     / \
+      //         /   \   /   \
+      //        /     \ /     \
+      //       *-------p-------*
+      //      / \a    . .    c/ \
+      //     /   \   .   .   /   \
+      //    /     \ .  I  . /     \
+      //   *-------n.......x------*
+      //    \     / \     / \     /
+      //     \   /   \   /   \   /
+      //      \ /     \b/     \ /
+      //       *-------*-------*
+      //
+
+      if (num_faces >= corner_table_->num_faces()) {
+        return -1;  // More faces than expected added to the mesh.
+      }
+
+      const CornerIndex corner_a = corner;
+      const VertexIndex vert_n =
+          corner_table_->Vertex(corner_table_->Next(corner_a));
+      const CornerIndex corner_b =
+          corner_table_->Next(corner_table_->LeftMostCorner(vert_n));
+
+      const VertexIndex vert_x =
+          corner_table_->Vertex(corner_table_->Next(corner_b));
+      const CornerIndex corner_c =
+          corner_table_->Next(corner_table_->LeftMostCorner(vert_x));
+
+      const VertexIndex vert_p =
+          corner_table_->Vertex(corner_table_->Next(corner_c));
+
+      const FaceIndex face(num_faces++);
+      // The first corner of the initial face is the corner opposite to "a".
+      const CornerIndex new_corner(3 * face.value());
+      SetOppositeCorners(new_corner, corner);
+      SetOppositeCorners(new_corner + 1, corner_b);
+      SetOppositeCorners(new_corner + 2, corner_c);
+
+      // Map new corners to existing vertices.
+      corner_table_->MapCornerToVertex(new_corner, vert_x);
+      corner_table_->MapCornerToVertex(new_corner + 1, vert_p);
+      corner_table_->MapCornerToVertex(new_corner + 2, vert_n);
+
+      // Mark all three vertices as interior.
+      for (int ci = 0; ci < 3; ++ci) {
+        is_vert_hole_[corner_table_->Vertex(new_corner + ci).value()] = false;
+      }
+
+      init_face_configurations_.push_back(true);
+      init_corners_.push_back(new_corner);
+    } else {
+      // The initial face wasn't interior and the traversal had to start from
+      // an open boundary. In this case no new face is added, but we need to
+      // keep record about the first opposite corner to this boundary.
+      init_face_configurations_.push_back(false);
+      init_corners_.push_back(corner);
+    }
+  }
+  if (num_faces != corner_table_->num_faces()) {
+    return -1;  // Unexpected number of decoded faces.
+  }
+
+  int num_vertices = corner_table_->num_vertices();
+  // If any vertex was marked as isolated, we want to remove it from the corner
+  // table to ensure that all vertices in range <0, num_vertices> are valid.
+  for (const VertexIndex invalid_vert : invalid_vertices) {
+    // Find the last valid vertex and swap it with the isolated vertex.
+    VertexIndex src_vert(num_vertices - 1);
+    while (corner_table_->LeftMostCorner(src_vert) == kInvalidCornerIndex) {
+      // The last vertex is invalid, proceed to the previous one.
+      src_vert = VertexIndex(--num_vertices - 1);
+    }
+    if (src_vert < invalid_vert) {
+      continue;  // No need to swap anything.
+    }
+
+    // Remap all corners mapped to |src_vert| to |invalid_vert|.
+    VertexCornersIterator<CornerTable> vcit(corner_table_.get(), src_vert);
+    for (; !vcit.End(); ++vcit) {
+      const CornerIndex cid = vcit.Corner();
+      corner_table_->MapCornerToVertex(cid, invalid_vert);
+    }
+    corner_table_->SetLeftMostCorner(invalid_vert,
+                                     corner_table_->LeftMostCorner(src_vert));
+
+    // Make the |src_vert| invalid.
+    corner_table_->MakeVertexIsolated(src_vert);
+    is_vert_hole_[invalid_vert.value()] = is_vert_hole_[src_vert.value()];
+    is_vert_hole_[src_vert.value()] = false;
+
+    // The last vertex is now invalid.
+    num_vertices--;
+  }
+  return num_vertices;
+}
+
+template <class TraversalDecoder>
+int32_t
+MeshEdgebreakerDecoderImpl<TraversalDecoder>::DecodeHoleAndTopologySplitEvents(
+    DecoderBuffer *decoder_buffer) {
+  // Prepare a new decoder from the provided buffer offset.
+  uint32_t num_topology_splits;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!decoder_buffer->Decode(&num_topology_splits)) {
+      return -1;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_topology_splits, decoder_buffer)) {
+      return -1;
+    }
+  }
+  if (num_topology_splits > 0) {
+    if (num_topology_splits >
+        static_cast<uint32_t>(corner_table_->num_faces())) {
+      return -1;
+    }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(1, 2)) {
+      for (uint32_t i = 0; i < num_topology_splits; ++i) {
+        TopologySplitEventData event_data;
+        if (!decoder_buffer->Decode(&event_data.split_symbol_id)) {
+          return -1;
+        }
+        if (!decoder_buffer->Decode(&event_data.source_symbol_id)) {
+          return -1;
+        }
+        uint8_t edge_data;
+        if (!decoder_buffer->Decode(&edge_data)) {
+          return -1;
+        }
+        event_data.source_edge = edge_data & 1;
+        topology_split_data_.push_back(event_data);
+      }
+
+    } else
+#endif
+    {
+      // Decode source and split symbol ids using delta and varint coding. See
+      // description in mesh_edgebreaker_encoder_impl.cc for more details.
+      int last_source_symbol_id = 0;
+      for (uint32_t i = 0; i < num_topology_splits; ++i) {
+        TopologySplitEventData event_data;
+        uint32_t delta;
+        if (!DecodeVarint<uint32_t>(&delta, decoder_buffer)) {
+          return -1;
+        }
+        event_data.source_symbol_id = delta + last_source_symbol_id;
+        if (!DecodeVarint<uint32_t>(&delta, decoder_buffer)) {
+          return -1;
+        }
+        if (delta > event_data.source_symbol_id) {
+          return -1;
+        }
+        event_data.split_symbol_id =
+            event_data.source_symbol_id - static_cast<int32_t>(delta);
+        last_source_symbol_id = event_data.source_symbol_id;
+        topology_split_data_.push_back(event_data);
+      }
+      // Split edges are decoded from a direct bit decoder.
+      decoder_buffer->StartBitDecoding(false, nullptr);
+      for (uint32_t i = 0; i < num_topology_splits; ++i) {
+        uint32_t edge_data;
+        if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+          decoder_buffer->DecodeLeastSignificantBits32(2, &edge_data);
+        } else {
+          decoder_buffer->DecodeLeastSignificantBits32(1, &edge_data);
+        }
+        TopologySplitEventData &event_data = topology_split_data_[i];
+        event_data.source_edge = edge_data & 1;
+      }
+      decoder_buffer->EndBitDecoding();
+    }
+  }
+  uint32_t num_hole_events = 0;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 0)) {
+    if (!decoder_buffer->Decode(&num_hole_events)) {
+      return -1;
+    }
+  } else if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(2, 1)) {
+    if (!DecodeVarint(&num_hole_events, decoder_buffer)) {
+      return -1;
+    }
+  }
+#endif
+  if (num_hole_events > 0) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (decoder_->bitstream_version() < DRACO_BITSTREAM_VERSION(1, 2)) {
+      for (uint32_t i = 0; i < num_hole_events; ++i) {
+        HoleEventData event_data;
+        if (!decoder_buffer->Decode(&event_data)) {
+          return -1;
+        }
+        hole_event_data_.push_back(event_data);
+      }
+
+    } else
+#endif
+    {
+      // Decode hole symbol ids using delta and varint coding.
+      int last_symbol_id = 0;
+      for (uint32_t i = 0; i < num_hole_events; ++i) {
+        HoleEventData event_data;
+        uint32_t delta;
+        if (!DecodeVarint<uint32_t>(&delta, decoder_buffer)) {
+          return -1;
+        }
+        event_data.symbol_id = delta + last_symbol_id;
+        last_symbol_id = event_data.symbol_id;
+        hole_event_data_.push_back(event_data);
+      }
+    }
+  }
+  return static_cast<int32_t>(decoder_buffer->decoded_size());
+}
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<TraversalDecoder>::
+    DecodeAttributeConnectivitiesOnFaceLegacy(CornerIndex corner) {
+  // Three corners of the face.
+  const CornerIndex corners[3] = {corner, corner_table_->Next(corner),
+                                  corner_table_->Previous(corner)};
+
+  for (int c = 0; c < 3; ++c) {
+    const CornerIndex opp_corner = corner_table_->Opposite(corners[c]);
+    if (opp_corner == kInvalidCornerIndex) {
+      // Don't decode attribute seams on boundary edges (every boundary edge
+      // is automatically an attribute seam).
+      for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+        attribute_data_[i].attribute_seam_corners.push_back(corners[c].value());
+      }
+      continue;
+    }
+
+    for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+      const bool is_seam = traversal_decoder_.DecodeAttributeSeam(i);
+      if (is_seam) {
+        attribute_data_[i].attribute_seam_corners.push_back(corners[c].value());
+      }
+    }
+  }
+  return true;
+}
+#endif
+
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<
+    TraversalDecoder>::DecodeAttributeConnectivitiesOnFace(CornerIndex corner) {
+  // Three corners of the face.
+  const CornerIndex corners[3] = {corner, corner_table_->Next(corner),
+                                  corner_table_->Previous(corner)};
+
+  const FaceIndex src_face_id = corner_table_->Face(corner);
+  for (int c = 0; c < 3; ++c) {
+    const CornerIndex opp_corner = corner_table_->Opposite(corners[c]);
+    if (opp_corner == kInvalidCornerIndex) {
+      // Don't decode attribute seams on boundary edges (every boundary edge
+      // is automatically an attribute seam).
+      for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+        attribute_data_[i].attribute_seam_corners.push_back(corners[c].value());
+      }
+      continue;
+    }
+    const FaceIndex opp_face_id = corner_table_->Face(opp_corner);
+    // Don't decode edges when the opposite face has been already processed.
+    if (opp_face_id < src_face_id) {
+      continue;
+    }
+
+    for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+      const bool is_seam = traversal_decoder_.DecodeAttributeSeam(i);
+      if (is_seam) {
+        attribute_data_[i].attribute_seam_corners.push_back(corners[c].value());
+      }
+    }
+  }
+  return true;
+}
+
+template <class TraversalDecoder>
+bool MeshEdgebreakerDecoderImpl<TraversalDecoder>::AssignPointsToCorners(
+    int num_connectivity_verts) {
+  // Map between the existing and deduplicated point ids.
+  // Note that at this point we have one point id for each corner of the
+  // mesh so there is corner_table_->num_corners() point ids.
+  decoder_->mesh()->SetNumFaces(corner_table_->num_faces());
+
+  if (attribute_data_.empty()) {
+    // We have connectivity for position only. In this case all vertex indices
+    // are equal to point indices.
+    for (FaceIndex f(0); f < decoder_->mesh()->num_faces(); ++f) {
+      Mesh::Face face;
+      const CornerIndex start_corner(3 * f.value());
+      for (int c = 0; c < 3; ++c) {
+        // Get the vertex index on the corner and use it as a point index.
+        const int32_t vert_id = corner_table_->Vertex(start_corner + c).value();
+        face[c] = vert_id;
+      }
+      decoder_->mesh()->SetFace(f, face);
+    }
+    decoder_->point_cloud()->set_num_points(num_connectivity_verts);
+    return true;
+  }
+  // Else we need to deduplicate multiple attributes.
+
+  // Map between point id and an associated corner id. Only one corner for
+  // each point is stored. The corners are used to sample the attribute values
+  // in the last stage of the deduplication.
+  std::vector<int32_t> point_to_corner_map;
+  // Map between every corner and their new point ids.
+  std::vector<int32_t> corner_to_point_map(corner_table_->num_corners());
+  for (int v = 0; v < corner_table_->num_vertices(); ++v) {
+    CornerIndex c = corner_table_->LeftMostCorner(VertexIndex(v));
+    if (c == kInvalidCornerIndex) {
+      continue;  // Isolated vertex.
+    }
+    CornerIndex deduplication_first_corner = c;
+    if (is_vert_hole_[v]) {
+      // If the vertex is on a boundary, start deduplication from the left most
+      // corner that is guaranteed to lie on the boundary.
+      deduplication_first_corner = c;
+    } else {
+      // If we are not on the boundary we need to find the first seam (of any
+      // attribute).
+      for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+        if (!attribute_data_[i].connectivity_data.IsCornerOnSeam(c)) {
+          continue;  // No seam for this attribute, ignore it.
+        }
+        // Else there needs to be at least one seam edge.
+
+        // At this point, we use identity mapping between corners and point ids.
+        const VertexIndex vert_id =
+            attribute_data_[i].connectivity_data.Vertex(c);
+        CornerIndex act_c = corner_table_->SwingRight(c);
+        bool seam_found = false;
+        while (act_c != c) {
+          if (act_c == kInvalidCornerIndex) {
+            return false;
+          }
+          if (attribute_data_[i].connectivity_data.Vertex(act_c) != vert_id) {
+            // Attribute seam found. Stop.
+            deduplication_first_corner = act_c;
+            seam_found = true;
+            break;
+          }
+          act_c = corner_table_->SwingRight(act_c);
+        }
+        if (seam_found) {
+          break;  // No reason to process other attributes if we found a seam.
+        }
+      }
+    }
+
+    // Do a deduplication pass over the corners on the processed vertex.
+    // At this point each corner corresponds to one point id and our goal is to
+    // merge similar points into a single point id.
+    // We do a single pass in a clockwise direction over the corners and we add
+    // a new point id whenever one of the attributes change.
+    c = deduplication_first_corner;
+    // Create a new point.
+    corner_to_point_map[c.value()] =
+        static_cast<uint32_t>(point_to_corner_map.size());
+    point_to_corner_map.push_back(c.value());
+    // Traverse in CW direction.
+    CornerIndex prev_c = c;
+    c = corner_table_->SwingRight(c);
+    while (c != kInvalidCornerIndex && c != deduplication_first_corner) {
+      bool attribute_seam = false;
+      for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+        if (attribute_data_[i].connectivity_data.Vertex(c) !=
+            attribute_data_[i].connectivity_data.Vertex(prev_c)) {
+          // Attribute index changed from the previous corner. We need to add a
+          // new point here.
+          attribute_seam = true;
+          break;
+        }
+      }
+      if (attribute_seam) {
+        corner_to_point_map[c.value()] =
+            static_cast<uint32_t>(point_to_corner_map.size());
+        point_to_corner_map.push_back(c.value());
+      } else {
+        corner_to_point_map[c.value()] = corner_to_point_map[prev_c.value()];
+      }
+      prev_c = c;
+      c = corner_table_->SwingRight(c);
+    }
+  }
+  // Add faces.
+  for (FaceIndex f(0); f < decoder_->mesh()->num_faces(); ++f) {
+    Mesh::Face face;
+    for (int c = 0; c < 3; ++c) {
+      // Remap old points to the new ones.
+      face[c] = corner_to_point_map[3 * f.value() + c];
+    }
+    decoder_->mesh()->SetFace(f, face);
+  }
+  decoder_->point_cloud()->set_num_points(
+      static_cast<uint32_t>(point_to_corner_map.size()));
+  return true;
+}
+
+template class MeshEdgebreakerDecoderImpl<MeshEdgebreakerTraversalDecoder>;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+template class MeshEdgebreakerDecoderImpl<
+    MeshEdgebreakerTraversalPredictiveDecoder>;
+#endif
+template class MeshEdgebreakerDecoderImpl<
+    MeshEdgebreakerTraversalValenceDecoder>;
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.h b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.h
new file mode 100644
index 000000000..78053f91d
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl.h
@@ -0,0 +1,228 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_H_
+
+#include <unordered_map>
+#include <unordered_set>
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/compression/mesh/traverser/mesh_traversal_sequencer.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Implementation of the edgebreaker decoder that decodes data encoded with the
+// MeshEdgebreakerEncoderImpl class. The implementation of the decoder is based
+// on the algorithm presented in Isenburg et al'02 "Spirale Reversi: Reverse
+// decoding of the Edgebreaker encoding". Note that the encoding is still based
+// on the standard edgebreaker method as presented in "3D Compression
+// Made Simple: Edgebreaker on a Corner-Table" by Rossignac at al.'01.
+// http://www.cc.gatech.edu/~jarek/papers/CornerTableSMI.pdf. One difference is
+// caused by the properties of the spirale reversi algorithm that decodes the
+// symbols from the last one to the first one. To make the decoding more
+// efficient, we encode all symbols in the reverse order, therefore the decoder
+// can process them one by one.
+// The main advantage of the spirale reversi method is that the partially
+// decoded mesh has valid connectivity data at any time during the decoding
+// process (valid with respect to the decoded portion of the mesh). The standard
+// Edgebreaker decoder used two passes (forward decoding + zipping) which not
+// only prevented us from having a valid connectivity but it was also slower.
+// The main benefit of having the valid connectivity is that we can use the
+// known connectivity to predict encoded symbols that can improve the
+// compression rate.
+template <class TraversalDecoderT>
+class MeshEdgebreakerDecoderImpl : public MeshEdgebreakerDecoderImplInterface {
+ public:
+  MeshEdgebreakerDecoderImpl();
+  bool Init(MeshEdgebreakerDecoder *decoder) override;
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override;
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override;
+
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+  bool DecodeConnectivity() override;
+  bool OnAttributesDecoded() override;
+  MeshEdgebreakerDecoder *GetDecoder() const override { return decoder_; }
+  const CornerTable *GetCornerTable() const override {
+    return corner_table_.get();
+  }
+
+ private:
+  // Creates a vertex traversal sequencer for the specified |TraverserT| type.
+  template <class TraverserT>
+  std::unique_ptr<PointsSequencer> CreateVertexTraversalSequencer(
+      MeshAttributeIndicesEncodingData *encoding_data);
+
+  // Decodes connectivity between vertices (vertex indices).
+  // Returns the number of vertices created by the decoder or -1 on error.
+  int DecodeConnectivity(int num_symbols);
+
+  // Returns true if the current symbol was part of a topology split event. This
+  // means that the current face was connected to the left edge of a face
+  // encoded with the TOPOLOGY_S symbol. |out_symbol_edge| can be used to
+  // identify which edge of the source symbol was connected to the TOPOLOGY_S
+  // symbol.
+  bool IsTopologySplit(int encoder_symbol_id, EdgeFaceName *out_face_edge,
+                       int *out_encoder_split_symbol_id) {
+    if (topology_split_data_.size() == 0) {
+      return false;
+    }
+    if (topology_split_data_.back().source_symbol_id >
+        static_cast<uint32_t>(encoder_symbol_id)) {
+      // Something is wrong; if the desired source symbol is greater than the
+      // current encoder_symbol_id, we missed it, or the input was tampered
+      // (|encoder_symbol_id| keeps decreasing).
+      // Return invalid symbol id to notify the decoder that there was an
+      // error.
+      *out_encoder_split_symbol_id = -1;
+      return true;
+    }
+    if (topology_split_data_.back().source_symbol_id != encoder_symbol_id) {
+      return false;
+    }
+    *out_face_edge =
+        static_cast<EdgeFaceName>(topology_split_data_.back().source_edge);
+    *out_encoder_split_symbol_id = topology_split_data_.back().split_symbol_id;
+    // Remove the latest split event.
+    topology_split_data_.pop_back();
+    return true;
+  }
+
+  // Decodes event data for hole and topology split events and stores them for
+  // future use.
+  // Returns the number of parsed bytes, or -1 on error.
+  int32_t DecodeHoleAndTopologySplitEvents(DecoderBuffer *decoder_buffer);
+
+  // Decodes all non-position attribute connectivity on the currently
+  // processed face.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  bool DecodeAttributeConnectivitiesOnFaceLegacy(CornerIndex corner);
+#endif
+  bool DecodeAttributeConnectivitiesOnFace(CornerIndex corner);
+
+  // Initializes mapping between corners and point ids.
+  bool AssignPointsToCorners(int num_connectivity_verts);
+
+  bool IsFaceVisited(CornerIndex corner_id) const {
+    if (corner_id < 0) {
+      return true;  // Invalid corner signalizes that the face does not exist.
+    }
+    return visited_faces_[corner_table_->Face(corner_id).value()];
+  }
+
+  void SetOppositeCorners(CornerIndex corner_0, CornerIndex corner_1) {
+    corner_table_->SetOppositeCorner(corner_0, corner_1);
+    corner_table_->SetOppositeCorner(corner_1, corner_0);
+  }
+
+  MeshEdgebreakerDecoder *decoder_;
+
+  std::unique_ptr<CornerTable> corner_table_;
+
+  // Stack used for storing corners that need to be traversed when decoding
+  // mesh vertices. New corner is added for each initial face and a split
+  // symbol, and one corner is removed when the end symbol is reached.
+  // Stored as member variable to prevent frequent memory reallocations when
+  // handling meshes with lots of disjoint components.  Originally, we used
+  // recursive functions to handle this behavior, but that can cause stack
+  // memory overflow when compressing huge meshes.
+  std::vector<CornerIndex> corner_traversal_stack_;
+
+  // Array stores the number of visited visited for each mesh traversal.
+  std::vector<int> vertex_traversal_length_;
+
+  // List of decoded topology split events.
+  std::vector<TopologySplitEventData> topology_split_data_;
+
+  // List of decoded hole events.
+  std::vector<HoleEventData> hole_event_data_;
+
+  // Configuration of the initial face for each mesh component.
+  std::vector<bool> init_face_configurations_;
+
+  // Initial corner for each traversal.
+  std::vector<CornerIndex> init_corners_;
+
+  // Id of the last processed input symbol.
+  int last_symbol_id_;
+
+  // Id of the last decoded vertex.
+  int last_vert_id_;
+
+  // Id of the last decoded face.
+  int last_face_id_;
+
+  // Array for marking visited faces.
+  std::vector<bool> visited_faces_;
+  // Array for marking visited vertices.
+  std::vector<bool> visited_verts_;
+  // Array for marking vertices on open boundaries.
+  std::vector<bool> is_vert_hole_;
+
+  // The number of new vertices added by the encoder (because of non-manifold
+  // vertices on the input mesh).
+  // If there are no non-manifold edges/vertices on the input mesh, this should
+  // be 0.
+  int num_new_vertices_;
+  // For every newly added vertex, this array stores it's mapping to the
+  // parent vertex id of the encoded mesh.
+  std::unordered_map<int, int> new_to_parent_vertex_map_;
+  // The number of vertices that were encoded (can be different from the number
+  // of vertices of the input mesh).
+  int num_encoded_vertices_;
+
+  // Array for storing the encoded corner ids in the order their associated
+  // vertices were decoded.
+  std::vector<int32_t> processed_corner_ids_;
+
+  // Array storing corners in the order they were visited during the
+  // connectivity decoding (always storing the tip corner of each newly visited
+  // face).
+  std::vector<int> processed_connectivity_corners_;
+
+  MeshAttributeIndicesEncodingData pos_encoding_data_;
+
+  // Id of an attributes decoder that uses |pos_encoding_data_|.
+  int pos_data_decoder_id_;
+
+  // Data for non-position attributes used by the decoder.
+  struct AttributeData {
+    AttributeData() : decoder_id(-1), is_connectivity_used(true) {}
+    // Id of the attribute decoder that was used to decode this attribute data.
+    int decoder_id;
+    MeshAttributeCornerTable connectivity_data;
+    // Flag that can mark the connectivity_data invalid. In such case the base
+    // corner table of the mesh should be used instead.
+    bool is_connectivity_used;
+    MeshAttributeIndicesEncodingData encoding_data;
+    // Opposite corners to attribute seam edges.
+    std::vector<int32_t> attribute_seam_corners;
+  };
+  std::vector<AttributeData> attribute_data_;
+
+  TraversalDecoderT traversal_decoder_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h
new file mode 100644
index 000000000..31fabf252
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h
@@ -0,0 +1,47 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_INTERFACE_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_INTERFACE_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Forward declaration is necessary here to avoid circular dependencies.
+class MeshEdgebreakerDecoder;
+
+// Abstract interface used by MeshEdgebreakerDecoder to interact with the actual
+// implementation of the edgebreaker decoding method.
+class MeshEdgebreakerDecoderImplInterface {
+ public:
+  virtual ~MeshEdgebreakerDecoderImplInterface() = default;
+  virtual bool Init(MeshEdgebreakerDecoder *decoder) = 0;
+
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const = 0;
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const = 0;
+  virtual bool CreateAttributesDecoder(int32_t att_decoder_id) = 0;
+  virtual bool DecodeConnectivity() = 0;
+  virtual bool OnAttributesDecoded() = 0;
+
+  virtual MeshEdgebreakerDecoder *GetDecoder() const = 0;
+  virtual const CornerTable *GetCornerTable() const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_DECODER_IMPL_INTERFACE_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.cc b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.cc
new file mode 100644
index 000000000..5aff5d8cc
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.cc
@@ -0,0 +1,195 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_edgebreaker_encoder.h"
+
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h"
+
+namespace draco {
+
+MeshEdgebreakerEncoder::MeshEdgebreakerEncoder() {}
+
+bool MeshEdgebreakerEncoder::InitializeEncoder() {
+  const bool is_standard_edgebreaker_available =
+      options()->IsFeatureSupported(features::kEdgebreaker);
+  const bool is_predictive_edgebreaker_available =
+      options()->IsFeatureSupported(features::kPredictiveEdgebreaker);
+
+  impl_ = nullptr;
+  // For tiny meshes it's usually better to use the basic edgebreaker as the
+  // overhead of the predictive one may turn out to be too big.
+  // TODO(b/111065939): Check if this can be improved.
+  const bool is_tiny_mesh = mesh()->num_faces() < 1000;
+
+  int selected_edgebreaker_method =
+      options()->GetGlobalInt("edgebreaker_method", -1);
+  if (selected_edgebreaker_method == -1) {
+    if (is_standard_edgebreaker_available &&
+        (options()->GetSpeed() >= 5 || !is_predictive_edgebreaker_available ||
+         is_tiny_mesh)) {
+      selected_edgebreaker_method = MESH_EDGEBREAKER_STANDARD_ENCODING;
+    } else {
+      selected_edgebreaker_method = MESH_EDGEBREAKER_VALENCE_ENCODING;
+    }
+  }
+
+  if (selected_edgebreaker_method == MESH_EDGEBREAKER_STANDARD_ENCODING) {
+    if (is_standard_edgebreaker_available) {
+      buffer()->Encode(
+          static_cast<uint8_t>(MESH_EDGEBREAKER_STANDARD_ENCODING));
+      impl_ = std::unique_ptr<MeshEdgebreakerEncoderImplInterface>(
+          new MeshEdgebreakerEncoderImpl<MeshEdgebreakerTraversalEncoder>());
+    }
+  } else if (selected_edgebreaker_method == MESH_EDGEBREAKER_VALENCE_ENCODING) {
+    buffer()->Encode(static_cast<uint8_t>(MESH_EDGEBREAKER_VALENCE_ENCODING));
+    impl_ = std::unique_ptr<MeshEdgebreakerEncoderImplInterface>(
+        new MeshEdgebreakerEncoderImpl<
+            MeshEdgebreakerTraversalValenceEncoder>());
+  }
+  if (!impl_) {
+    return false;
+  }
+  if (!impl_->Init(this)) {
+    return false;
+  }
+  return true;
+}
+
+bool MeshEdgebreakerEncoder::GenerateAttributesEncoder(int32_t att_id) {
+  if (!impl_->GenerateAttributesEncoder(att_id)) {
+    return false;
+  }
+  return true;
+}
+
+bool MeshEdgebreakerEncoder::EncodeAttributesEncoderIdentifier(
+    int32_t att_encoder_id) {
+  if (!impl_->EncodeAttributesEncoderIdentifier(att_encoder_id)) {
+    return false;
+  }
+  return true;
+}
+
+Status MeshEdgebreakerEncoder::EncodeConnectivity() {
+  return impl_->EncodeConnectivity();
+}
+
+void MeshEdgebreakerEncoder::ComputeNumberOfEncodedPoints() {
+  if (!impl_) {
+    return;
+  }
+  const CornerTable *const corner_table = impl_->GetCornerTable();
+  if (!corner_table) {
+    return;
+  }
+  size_t num_points =
+      corner_table->num_vertices() - corner_table->NumIsolatedVertices();
+
+  if (mesh()->num_attributes() > 1) {
+    // Gather all corner tables for all non-position attributes.
+    std::vector<const MeshAttributeCornerTable *> attribute_corner_tables;
+    for (int i = 0; i < mesh()->num_attributes(); ++i) {
+      if (mesh()->attribute(i)->attribute_type() ==
+          GeometryAttribute::POSITION) {
+        continue;
+      }
+      const MeshAttributeCornerTable *const att_corner_table =
+          GetAttributeCornerTable(i);
+      // Attribute corner table may not be used in some configurations. For
+      // these cases we can assume the attribute connectivity to be the same as
+      // the connectivity of the position data.
+      if (att_corner_table) {
+        attribute_corner_tables.push_back(att_corner_table);
+      }
+    }
+
+    // Add a new point based on the configuration of interior attribute seams
+    // (replicating what the decoder would do).
+    for (VertexIndex vi(0); vi < corner_table->num_vertices(); ++vi) {
+      if (corner_table->IsVertexIsolated(vi)) {
+        continue;
+      }
+      // Go around all corners of the vertex and keep track of the observed
+      // attribute seams.
+      const CornerIndex first_corner_index = corner_table->LeftMostCorner(vi);
+      const PointIndex first_point_index =
+          mesh()->CornerToPointId(first_corner_index);
+
+      PointIndex last_point_index = first_point_index;
+      CornerIndex last_corner_index = first_corner_index;
+      CornerIndex corner_index = corner_table->SwingRight(first_corner_index);
+      size_t num_attribute_seams = 0;
+      while (corner_index != kInvalidCornerIndex) {
+        const PointIndex point_index = mesh()->CornerToPointId(corner_index);
+        bool seam_found = false;
+        if (point_index != last_point_index) {
+          // Point index changed - new attribute seam detected.
+          seam_found = true;
+          last_point_index = point_index;
+        } else {
+          // Even though point indices matches, there still may be a seam caused
+          // by non-manifold connectivity of non-position attribute data.
+          for (int i = 0; i < attribute_corner_tables.size(); ++i) {
+            if (attribute_corner_tables[i]->Vertex(corner_index) !=
+                attribute_corner_tables[i]->Vertex(last_corner_index)) {
+              seam_found = true;
+              break;  // No need to process other attributes.
+            }
+          }
+        }
+        if (seam_found) {
+          ++num_attribute_seams;
+        }
+
+        if (corner_index == first_corner_index) {
+          break;
+        }
+
+        // Proceed to the next corner
+        last_corner_index = corner_index;
+        corner_index = corner_table->SwingRight(corner_index);
+      }
+
+      if (!corner_table->IsOnBoundary(vi) && num_attribute_seams > 0) {
+        // If the last visited point index is the same as the first point index
+        // we traveled all the way around the vertex. In this case the number of
+        // new points should be num_attribute_seams - 1
+        num_points += num_attribute_seams - 1;
+      } else {
+        // Else the vertex was either on a boundary (i.e. we couldn't travel all
+        // around the vertex), or we ended up at a different point. In both of
+        // these cases, the number of new points is equal to the number of
+        // attribute seams.
+        num_points += num_attribute_seams;
+      }
+    }
+  }
+  set_num_encoded_points(num_points);
+}
+
+void MeshEdgebreakerEncoder::ComputeNumberOfEncodedFaces() {
+  if (!impl_) {
+    return;
+  }
+  const CornerTable *const corner_table = impl_->GetCornerTable();
+  if (!corner_table) {
+    return;
+  }
+  set_num_encoded_faces(corner_table->num_faces() -
+                        corner_table->NumDegeneratedFaces());
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.h b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.h
new file mode 100644
index 000000000..70d4d5061
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder.h
@@ -0,0 +1,73 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_H_
+
+#include <unordered_map>
+
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/compression/mesh/mesh_encoder.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Class implements the edge breaker geometry compression method as described
+// in "3D Compression Made Simple: Edgebreaker on a Corner-Table" by Rossignac
+// at al.'01. http://www.cc.gatech.edu/~jarek/papers/CornerTableSMI.pdf
+class MeshEdgebreakerEncoder : public MeshEncoder {
+ public:
+  MeshEdgebreakerEncoder();
+
+  const CornerTable *GetCornerTable() const override {
+    return impl_->GetCornerTable();
+  }
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override {
+    return impl_->GetAttributeCornerTable(att_id);
+  }
+
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override {
+    return impl_->GetAttributeEncodingData(att_id);
+  }
+
+  uint8_t GetEncodingMethod() const override {
+    return MESH_EDGEBREAKER_ENCODING;
+  }
+
+ protected:
+  bool InitializeEncoder() override;
+  Status EncodeConnectivity() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  bool EncodeAttributesEncoderIdentifier(int32_t att_encoder_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+  void ComputeNumberOfEncodedFaces() override;
+
+ private:
+  // The actual implementation of the edge breaker method. The implementations
+  // are in general specializations of a template class
+  // MeshEdgebreakerEncoderImpl where the template arguments control encoding
+  // of the connectivity data. The actual implementation is selected in this
+  // class based on the provided encoding options. Because this choice is done
+  // in run-time, the actual implementation has to be hidden behind the
+  // abstract interface MeshEdgebreakerEncoderImplInterface.
+  std::unique_ptr<MeshEdgebreakerEncoderImplInterface> impl_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.cc b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.cc
new file mode 100644
index 000000000..0791dc670
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.cc
@@ -0,0 +1,854 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl.h"
+
+#include <algorithm>
+
+#include "draco/compression/attributes/sequential_attribute_encoders_controller.h"
+#include "draco/compression/mesh/mesh_edgebreaker_encoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h"
+#include "draco/compression/mesh/traverser/depth_first_traverser.h"
+#include "draco/compression/mesh/traverser/max_prediction_degree_traverser.h"
+#include "draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h"
+#include "draco/compression/mesh/traverser/mesh_traversal_sequencer.h"
+#include "draco/compression/mesh/traverser/traverser_base.h"
+#include "draco/mesh/corner_table_iterators.h"
+#include "draco/mesh/mesh_misc_functions.h"
+
+namespace draco {
+// TODO(draco-eng) consider converting 'typedef' to 'using' and deduplicate.
+typedef CornerIndex CornerIndex;
+typedef FaceIndex FaceIndex;
+typedef VertexIndex VertexIndex;
+
+template <class TraversalEncoder>
+MeshEdgebreakerEncoderImpl<TraversalEncoder>::MeshEdgebreakerEncoderImpl()
+    : encoder_(nullptr),
+      mesh_(nullptr),
+      last_encoded_symbol_id_(-1),
+      num_split_symbols_(0),
+      use_single_connectivity_(false) {}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::Init(
+    MeshEdgebreakerEncoder *encoder) {
+  encoder_ = encoder;
+  mesh_ = encoder->mesh();
+  attribute_encoder_to_data_id_map_.clear();
+
+  if (encoder_->options()->IsGlobalOptionSet("split_mesh_on_seams")) {
+    use_single_connectivity_ =
+        encoder_->options()->GetGlobalBool("split_mesh_on_seams", false);
+  } else if (encoder_->options()->GetSpeed() >= 6) {
+    // Else use default setting based on speed.
+    use_single_connectivity_ = true;
+  } else {
+    use_single_connectivity_ = false;
+  }
+  return true;
+}
+
+template <class TraversalEncoder>
+const MeshAttributeCornerTable *
+MeshEdgebreakerEncoderImpl<TraversalEncoder>::GetAttributeCornerTable(
+    int att_id) const {
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    if (attribute_data_[i].attribute_index == att_id) {
+      if (attribute_data_[i].is_connectivity_used) {
+        return &attribute_data_[i].connectivity_data;
+      }
+      return nullptr;
+    }
+  }
+  return nullptr;
+}
+
+template <class TraversalEncoder>
+const MeshAttributeIndicesEncodingData *
+MeshEdgebreakerEncoderImpl<TraversalEncoder>::GetAttributeEncodingData(
+    int att_id) const {
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    if (attribute_data_[i].attribute_index == att_id) {
+      return &attribute_data_[i].encoding_data;
+    }
+  }
+  return &pos_encoding_data_;
+}
+
+template <class TraversalEncoder>
+template <class TraverserT>
+std::unique_ptr<PointsSequencer>
+MeshEdgebreakerEncoderImpl<TraversalEncoder>::CreateVertexTraversalSequencer(
+    MeshAttributeIndicesEncodingData *encoding_data) {
+  typedef typename TraverserT::TraversalObserver AttObserver;
+  typedef typename TraverserT::CornerTable CornerTable;
+
+  std::unique_ptr<MeshTraversalSequencer<TraverserT>> traversal_sequencer(
+      new MeshTraversalSequencer<TraverserT>(mesh_, encoding_data));
+
+  AttObserver att_observer(corner_table_.get(), mesh_,
+                           traversal_sequencer.get(), encoding_data);
+
+  TraverserT att_traverser;
+  att_traverser.Init(corner_table_.get(), att_observer);
+
+  // Set order of corners to simulate the corner order of the decoder.
+  traversal_sequencer->SetCornerOrder(processed_connectivity_corners_);
+  traversal_sequencer->SetTraverser(att_traverser);
+  return std::move(traversal_sequencer);
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::GenerateAttributesEncoder(
+    int32_t att_id) {
+  // For now, either create one encoder for each attribute or use a single
+  // encoder for all attributes. Ideally we can share the same encoder for
+  // a sub-set of attributes with the same connectivity (this is especially true
+  // for per-vertex attributes).
+  if (use_single_connectivity_ && GetEncoder()->num_attributes_encoders() > 0) {
+    // We are using single connectivity and we already have an attribute
+    // encoder. Add the attribute to the encoder and return.
+    GetEncoder()->attributes_encoder(0)->AddAttributeId(att_id);
+    return true;
+  }
+  const int32_t element_type =
+      GetEncoder()->mesh()->GetAttributeElementType(att_id);
+  const PointAttribute *const att =
+      GetEncoder()->point_cloud()->attribute(att_id);
+  int32_t att_data_id = -1;
+  for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+    if (attribute_data_[i].attribute_index == att_id) {
+      att_data_id = i;
+      break;
+    }
+  }
+  MeshTraversalMethod traversal_method = MESH_TRAVERSAL_DEPTH_FIRST;
+  std::unique_ptr<PointsSequencer> sequencer;
+  if (use_single_connectivity_ ||
+      att->attribute_type() == GeometryAttribute::POSITION ||
+      element_type == MESH_VERTEX_ATTRIBUTE ||
+      (element_type == MESH_CORNER_ATTRIBUTE &&
+       attribute_data_[att_data_id].connectivity_data.no_interior_seams())) {
+    // Per-vertex attribute reached, use the basic corner table to traverse the
+    // mesh.
+    MeshAttributeIndicesEncodingData *encoding_data;
+    if (use_single_connectivity_ ||
+        att->attribute_type() == GeometryAttribute::POSITION) {
+      encoding_data = &pos_encoding_data_;
+    } else {
+      encoding_data = &attribute_data_[att_data_id].encoding_data;
+
+      // Ensure we use the correct number of vertices in the encoding data.
+      encoding_data->vertex_to_encoded_attribute_value_index_map.assign(
+          corner_table_->num_vertices(), -1);
+
+      // Mark the attribute specific connectivity data as not used as we use the
+      // position attribute connectivity data.
+      attribute_data_[att_data_id].is_connectivity_used = false;
+    }
+
+    if (GetEncoder()->options()->GetSpeed() == 0 &&
+        att->attribute_type() == GeometryAttribute::POSITION) {
+      traversal_method = MESH_TRAVERSAL_PREDICTION_DEGREE;
+      if (use_single_connectivity_ && mesh_->num_attributes() > 1) {
+        // Make sure we don't use the prediction degree traversal when we encode
+        // multiple attributes using the same connectivity.
+        // TODO(ostava): We should investigate this and see if the prediction
+        // degree can be actually used efficiently for non-position attributes.
+        traversal_method = MESH_TRAVERSAL_DEPTH_FIRST;
+      }
+    }
+    // Defining sequencer via a traversal scheme.
+    if (traversal_method == MESH_TRAVERSAL_PREDICTION_DEGREE) {
+      typedef MeshAttributeIndicesEncodingObserver<CornerTable> AttObserver;
+      typedef MaxPredictionDegreeTraverser<CornerTable, AttObserver>
+          AttTraverser;
+      sequencer = CreateVertexTraversalSequencer<AttTraverser>(encoding_data);
+    } else if (traversal_method == MESH_TRAVERSAL_DEPTH_FIRST) {
+      typedef MeshAttributeIndicesEncodingObserver<CornerTable> AttObserver;
+      typedef DepthFirstTraverser<CornerTable, AttObserver> AttTraverser;
+      sequencer = CreateVertexTraversalSequencer<AttTraverser>(encoding_data);
+    }
+  } else {
+    // Per-corner attribute encoder.
+    typedef MeshAttributeIndicesEncodingObserver<MeshAttributeCornerTable>
+        AttObserver;
+    typedef DepthFirstTraverser<MeshAttributeCornerTable, AttObserver>
+        AttTraverser;
+
+    MeshAttributeIndicesEncodingData *const encoding_data =
+        &attribute_data_[att_data_id].encoding_data;
+    const MeshAttributeCornerTable *const corner_table =
+        &attribute_data_[att_data_id].connectivity_data;
+
+    // Ensure we use the correct number of vertices in the encoding data.
+    attribute_data_[att_data_id]
+        .encoding_data.vertex_to_encoded_attribute_value_index_map.assign(
+            attribute_data_[att_data_id].connectivity_data.num_vertices(), -1);
+
+    std::unique_ptr<MeshTraversalSequencer<AttTraverser>> traversal_sequencer(
+        new MeshTraversalSequencer<AttTraverser>(mesh_, encoding_data));
+
+    AttObserver att_observer(corner_table, mesh_, traversal_sequencer.get(),
+                             encoding_data);
+
+    AttTraverser att_traverser;
+    att_traverser.Init(corner_table, att_observer);
+
+    // Set order of corners to simulate the corner order of the decoder.
+    traversal_sequencer->SetCornerOrder(processed_connectivity_corners_);
+    traversal_sequencer->SetTraverser(att_traverser);
+    sequencer = std::move(traversal_sequencer);
+  }
+
+  if (!sequencer) {
+    return false;
+  }
+
+  if (att_data_id == -1) {
+    pos_traversal_method_ = traversal_method;
+  } else {
+    attribute_data_[att_data_id].traversal_method = traversal_method;
+  }
+
+  std::unique_ptr<SequentialAttributeEncodersController> att_controller(
+      new SequentialAttributeEncodersController(std::move(sequencer), att_id));
+
+  // Update the mapping between the encoder id and the attribute data id.
+  // This will be used by the decoder to select the appropriate attribute
+  // decoder and the correct connectivity.
+  attribute_encoder_to_data_id_map_.push_back(att_data_id);
+  GetEncoder()->AddAttributesEncoder(std::move(att_controller));
+  return true;
+}  // namespace draco
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::
+    EncodeAttributesEncoderIdentifier(int32_t att_encoder_id) {
+  const int8_t att_data_id = attribute_encoder_to_data_id_map_[att_encoder_id];
+  encoder_->buffer()->Encode(att_data_id);
+
+  // Also encode the type of the encoder that we used.
+  int32_t element_type = MESH_VERTEX_ATTRIBUTE;
+  MeshTraversalMethod traversal_method;
+  if (att_data_id >= 0) {
+    const int32_t att_id = attribute_data_[att_data_id].attribute_index;
+    element_type = GetEncoder()->mesh()->GetAttributeElementType(att_id);
+    traversal_method = attribute_data_[att_data_id].traversal_method;
+  } else {
+    traversal_method = pos_traversal_method_;
+  }
+  if (element_type == MESH_VERTEX_ATTRIBUTE ||
+      (element_type == MESH_CORNER_ATTRIBUTE &&
+       attribute_data_[att_data_id].connectivity_data.no_interior_seams())) {
+    // Per-vertex encoder.
+    encoder_->buffer()->Encode(static_cast<uint8_t>(MESH_VERTEX_ATTRIBUTE));
+  } else {
+    // Per-corner encoder.
+    encoder_->buffer()->Encode(static_cast<uint8_t>(MESH_CORNER_ATTRIBUTE));
+  }
+  // Encode the mesh traversal method.
+  encoder_->buffer()->Encode(static_cast<uint8_t>(traversal_method));
+  return true;
+}
+
+template <class TraversalEncoder>
+Status MeshEdgebreakerEncoderImpl<TraversalEncoder>::EncodeConnectivity() {
+  // To encode the mesh, we need face connectivity data stored in a corner
+  // table. To compute the connectivity we must use indices associated with
+  // POSITION attribute, because they define which edges can be connected
+  // together, unless the option |use_single_connectivity_| is set in which case
+  // we break the mesh along attribute seams and use the same connectivity for
+  // all attributes.
+  if (use_single_connectivity_) {
+    corner_table_ = CreateCornerTableFromAllAttributes(mesh_);
+  } else {
+    corner_table_ = CreateCornerTableFromPositionAttribute(mesh_);
+  }
+  if (corner_table_ == nullptr ||
+      corner_table_->num_faces() == corner_table_->NumDegeneratedFaces()) {
+    // Failed to construct the corner table.
+    // TODO(ostava): Add better error reporting.
+    return Status(Status::DRACO_ERROR, "All triangles are degenerate.");
+  }
+
+  traversal_encoder_.Init(this);
+
+  // Also encode the total number of vertices that is going to be encoded.
+  // This can be different from the mesh_->num_points() + num_new_vertices,
+  // because some of the vertices of the input mesh can be ignored (e.g.
+  // vertices on degenerated faces or isolated vertices not attached to any
+  // face).
+  const uint32_t num_vertices_to_be_encoded =
+      corner_table_->num_vertices() - corner_table_->NumIsolatedVertices();
+  EncodeVarint(num_vertices_to_be_encoded, encoder_->buffer());
+
+  const uint32_t num_faces =
+      corner_table_->num_faces() - corner_table_->NumDegeneratedFaces();
+  EncodeVarint(num_faces, encoder_->buffer());
+
+  // Reset encoder data that may have been initialized in previous runs.
+  visited_faces_.assign(mesh_->num_faces(), false);
+  pos_encoding_data_.vertex_to_encoded_attribute_value_index_map.assign(
+      corner_table_->num_vertices(), -1);
+  pos_encoding_data_.encoded_attribute_value_index_to_corner_map.clear();
+  pos_encoding_data_.encoded_attribute_value_index_to_corner_map.reserve(
+      corner_table_->num_faces() * 3);
+  visited_vertex_ids_.assign(corner_table_->num_vertices(), false);
+  vertex_traversal_length_.clear();
+  last_encoded_symbol_id_ = -1;
+  num_split_symbols_ = 0;
+  topology_split_event_data_.clear();
+  face_to_split_symbol_map_.clear();
+  visited_holes_.clear();
+  vertex_hole_id_.assign(corner_table_->num_vertices(), -1);
+  processed_connectivity_corners_.clear();
+  processed_connectivity_corners_.reserve(corner_table_->num_faces());
+  pos_encoding_data_.num_values = 0;
+
+  if (!FindHoles()) {
+    return Status(Status::DRACO_ERROR, "Failed to process mesh holes.");
+  }
+
+  if (!InitAttributeData()) {
+    return Status(Status::DRACO_ERROR, "Failed to initialize attribute data.");
+  }
+
+  const uint8_t num_attribute_data =
+      static_cast<uint8_t>(attribute_data_.size());
+  encoder_->buffer()->Encode(num_attribute_data);
+  traversal_encoder_.SetNumAttributeData(num_attribute_data);
+
+  const int num_corners = corner_table_->num_corners();
+
+  traversal_encoder_.Start();
+
+  std::vector<CornerIndex> init_face_connectivity_corners;
+  // Traverse the surface starting from each unvisited corner.
+  for (int c_id = 0; c_id < num_corners; ++c_id) {
+    CornerIndex corner_index(c_id);
+    const FaceIndex face_id = corner_table_->Face(corner_index);
+    if (visited_faces_[face_id.value()]) {
+      continue;  // Face has been already processed.
+    }
+    if (corner_table_->IsDegenerated(face_id)) {
+      continue;  // Ignore degenerated faces.
+    }
+
+    CornerIndex start_corner;
+    const bool interior_config =
+        FindInitFaceConfiguration(face_id, &start_corner);
+    traversal_encoder_.EncodeStartFaceConfiguration(interior_config);
+
+    if (interior_config) {
+      // Select the correct vertex on the face as the root.
+      corner_index = start_corner;
+      const VertexIndex vert_id = corner_table_->Vertex(corner_index);
+      // Mark all vertices of a given face as visited.
+      const VertexIndex next_vert_id =
+          corner_table_->Vertex(corner_table_->Next(corner_index));
+      const VertexIndex prev_vert_id =
+          corner_table_->Vertex(corner_table_->Previous(corner_index));
+
+      visited_vertex_ids_[vert_id.value()] = true;
+      visited_vertex_ids_[next_vert_id.value()] = true;
+      visited_vertex_ids_[prev_vert_id.value()] = true;
+      // New traversal started. Initiate it's length with the first vertex.
+      vertex_traversal_length_.push_back(1);
+
+      // Mark the face as visited.
+      visited_faces_[face_id.value()] = true;
+      // Start compressing from the opposite face of the "next" corner. This way
+      // the first encoded corner corresponds to the tip corner of the regular
+      // edgebreaker traversal (essentially the initial face can be then viewed
+      // as a TOPOLOGY_C face).
+      init_face_connectivity_corners.push_back(
+          corner_table_->Next(corner_index));
+      const CornerIndex opp_id =
+          corner_table_->Opposite(corner_table_->Next(corner_index));
+      const FaceIndex opp_face_id = corner_table_->Face(opp_id);
+      if (opp_face_id != kInvalidFaceIndex &&
+          !visited_faces_[opp_face_id.value()]) {
+        if (!EncodeConnectivityFromCorner(opp_id)) {
+          return Status(Status::DRACO_ERROR,
+                        "Failed to encode mesh component.");
+        }
+      }
+    } else {
+      // Boundary configuration. We start on a boundary rather than on a face.
+      // First encode the hole that's opposite to the start_corner.
+      EncodeHole(corner_table_->Next(start_corner), true);
+      // Start processing the face opposite to the boundary edge (the face
+      // containing the start_corner).
+      if (!EncodeConnectivityFromCorner(start_corner)) {
+        return Status(Status::DRACO_ERROR, "Failed to encode mesh component.");
+      }
+    }
+  }
+  // Reverse the order of connectivity corners to match the order in which
+  // they are going to be decoded.
+  std::reverse(processed_connectivity_corners_.begin(),
+               processed_connectivity_corners_.end());
+  // Append the init face connectivity corners (which are processed in order by
+  // the decoder after the regular corners.
+  processed_connectivity_corners_.insert(processed_connectivity_corners_.end(),
+                                         init_face_connectivity_corners.begin(),
+                                         init_face_connectivity_corners.end());
+  // Encode connectivity for all non-position attributes.
+  if (attribute_data_.size() > 0) {
+    // Use the same order of corner that will be used by the decoder.
+    visited_faces_.assign(mesh_->num_faces(), false);
+    for (CornerIndex ci : processed_connectivity_corners_) {
+      EncodeAttributeConnectivitiesOnFace(ci);
+    }
+  }
+  traversal_encoder_.Done();
+
+  // Encode the number of symbols.
+  const uint32_t num_encoded_symbols =
+      static_cast<uint32_t>(traversal_encoder_.NumEncodedSymbols());
+  EncodeVarint(num_encoded_symbols, encoder_->buffer());
+
+  // Encode the number of split symbols.
+  EncodeVarint(num_split_symbols_, encoder_->buffer());
+
+  // Append the traversal buffer.
+  if (!EncodeSplitData()) {
+    return Status(Status::DRACO_ERROR, "Failed to encode split data.");
+  }
+  encoder_->buffer()->Encode(traversal_encoder_.buffer().data(),
+                             traversal_encoder_.buffer().size());
+
+  return OkStatus();
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::EncodeSplitData() {
+  uint32_t num_events =
+      static_cast<uint32_t>(topology_split_event_data_.size());
+  EncodeVarint(num_events, encoder_->buffer());
+  if (num_events > 0) {
+    // Encode split symbols using delta and varint coding. Split edges are
+    // encoded using direct bit coding.
+    int last_source_symbol_id = 0;  // Used for delta coding.
+    for (uint32_t i = 0; i < num_events; ++i) {
+      const TopologySplitEventData &event_data = topology_split_event_data_[i];
+      // Encode source symbol id as delta from the previous source symbol id.
+      // Source symbol ids are always stored in increasing order so the delta is
+      // going to be positive.
+      EncodeVarint<uint32_t>(
+          event_data.source_symbol_id - last_source_symbol_id,
+          encoder_->buffer());
+      // Encode split symbol id as delta from the current source symbol id.
+      // Split symbol id is always smaller than source symbol id so the below
+      // delta is going to be positive.
+      EncodeVarint<uint32_t>(
+          event_data.source_symbol_id - event_data.split_symbol_id,
+          encoder_->buffer());
+      last_source_symbol_id = event_data.source_symbol_id;
+    }
+    encoder_->buffer()->StartBitEncoding(num_events, false);
+    for (uint32_t i = 0; i < num_events; ++i) {
+      const TopologySplitEventData &event_data = topology_split_event_data_[i];
+      encoder_->buffer()->EncodeLeastSignificantBits32(1,
+                                                       event_data.source_edge);
+    }
+    encoder_->buffer()->EndBitEncoding();
+  }
+  return true;
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::FindInitFaceConfiguration(
+    FaceIndex face_id, CornerIndex *out_corner) const {
+  CornerIndex corner_index = CornerIndex(3 * face_id.value());
+  for (int i = 0; i < 3; ++i) {
+    if (corner_table_->Opposite(corner_index) == kInvalidCornerIndex) {
+      // If there is a boundary edge, the configuration is exterior and return
+      // the CornerIndex opposite to the first boundary edge.
+      *out_corner = corner_index;
+      return false;
+    }
+    if (vertex_hole_id_[corner_table_->Vertex(corner_index).value()] != -1) {
+      // Boundary vertex found. Find the first boundary edge attached to the
+      // point and return the corner opposite to it.
+      CornerIndex right_corner = corner_index;
+      while (right_corner != kInvalidCornerIndex) {
+        corner_index = right_corner;
+        right_corner = corner_table_->SwingRight(right_corner);
+      }
+      // |corner_index| now lies on a boundary edge and its previous corner is
+      // guaranteed to be the opposite corner of the boundary edge.
+      *out_corner = corner_table_->Previous(corner_index);
+      return false;
+    }
+    corner_index = corner_table_->Next(corner_index);
+  }
+  // Else we have an interior configuration. Return the first corner id.
+  *out_corner = corner_index;
+  return true;
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::EncodeConnectivityFromCorner(
+    CornerIndex corner_id) {
+  corner_traversal_stack_.clear();
+  corner_traversal_stack_.push_back(corner_id);
+  const int num_faces = mesh_->num_faces();
+  while (!corner_traversal_stack_.empty()) {
+    // Currently processed corner.
+    corner_id = corner_traversal_stack_.back();
+    // Make sure the face hasn't been visited yet.
+    if (corner_id == kInvalidCornerIndex ||
+        visited_faces_[corner_table_->Face(corner_id).value()]) {
+      // This face has been already traversed.
+      corner_traversal_stack_.pop_back();
+      continue;
+    }
+    int num_visited_faces = 0;
+    while (num_visited_faces < num_faces) {
+      // Mark the current face as visited.
+      ++num_visited_faces;
+      ++last_encoded_symbol_id_;
+
+      const FaceIndex face_id = corner_table_->Face(corner_id);
+      visited_faces_[face_id.value()] = true;
+      processed_connectivity_corners_.push_back(corner_id);
+      traversal_encoder_.NewCornerReached(corner_id);
+      const VertexIndex vert_id = corner_table_->Vertex(corner_id);
+      const bool on_boundary = (vertex_hole_id_[vert_id.value()] != -1);
+      if (!IsVertexVisited(vert_id)) {
+        // A new unvisited vertex has been reached. We need to store its
+        // position difference using next, prev, and opposite vertices.
+        visited_vertex_ids_[vert_id.value()] = true;
+        if (!on_boundary) {
+          // If the vertex is on boundary it must correspond to an unvisited
+          // hole and it will be encoded with TOPOLOGY_S symbol later).
+          traversal_encoder_.EncodeSymbol(TOPOLOGY_C);
+          // Move to the right triangle.
+          corner_id = GetRightCorner(corner_id);
+          continue;
+        }
+      }
+      // The current vertex has been already visited or it was on a boundary.
+      // We need to determine whether we can visit any of it's neighboring
+      // faces.
+      const CornerIndex right_corner_id = GetRightCorner(corner_id);
+      const CornerIndex left_corner_id = GetLeftCorner(corner_id);
+      const FaceIndex right_face_id = corner_table_->Face(right_corner_id);
+      const FaceIndex left_face_id = corner_table_->Face(left_corner_id);
+      if (IsRightFaceVisited(corner_id)) {
+        // Right face has been already visited.
+        // Check whether there is a topology split event.
+        if (right_face_id != kInvalidFaceIndex) {
+          CheckAndStoreTopologySplitEvent(last_encoded_symbol_id_,
+                                          face_id.value(), RIGHT_FACE_EDGE,
+                                          right_face_id.value());
+        }
+        if (IsLeftFaceVisited(corner_id)) {
+          // Both neighboring faces are visited. End reached.
+          // Check whether there is a topology split event on the left face.
+          if (left_face_id != kInvalidFaceIndex) {
+            CheckAndStoreTopologySplitEvent(last_encoded_symbol_id_,
+                                            face_id.value(), LEFT_FACE_EDGE,
+                                            left_face_id.value());
+          }
+          traversal_encoder_.EncodeSymbol(TOPOLOGY_E);
+          corner_traversal_stack_.pop_back();
+          break;  // Break from the while (num_visited_faces < num_faces) loop.
+        } else {
+          traversal_encoder_.EncodeSymbol(TOPOLOGY_R);
+          // Go to the left face.
+          corner_id = left_corner_id;
+        }
+      } else {
+        // Right face was not visited.
+        if (IsLeftFaceVisited(corner_id)) {
+          // Check whether there is a topology split event on the left face.
+          if (left_face_id != kInvalidFaceIndex) {
+            CheckAndStoreTopologySplitEvent(last_encoded_symbol_id_,
+                                            face_id.value(), LEFT_FACE_EDGE,
+                                            left_face_id.value());
+          }
+          traversal_encoder_.EncodeSymbol(TOPOLOGY_L);
+          // Left face visited, go to the right one.
+          corner_id = right_corner_id;
+        } else {
+          traversal_encoder_.EncodeSymbol(TOPOLOGY_S);
+          ++num_split_symbols_;
+          // Both neighboring faces are unvisited, we need to visit both of
+          // them.
+          if (on_boundary) {
+            // The tip vertex is on a hole boundary. If the hole hasn't been
+            // visited yet we need to encode it.
+            const int hole_id = vertex_hole_id_[vert_id.value()];
+            if (!visited_holes_[hole_id]) {
+              EncodeHole(corner_id, false);
+            }
+          }
+          face_to_split_symbol_map_[face_id.value()] = last_encoded_symbol_id_;
+          // Split the traversal.
+          // First make the top of the current corner stack point to the left
+          // face (this one will be processed second).
+          corner_traversal_stack_.back() = left_corner_id;
+          // Add a new corner to the top of the stack (right face needs to
+          // be traversed first).
+          corner_traversal_stack_.push_back(right_corner_id);
+          // Break from the while (num_visited_faces < num_faces) loop.
+          break;
+        }
+      }
+    }
+  }
+  return true;  // All corners have been processed.
+}
+
+template <class TraversalEncoder>
+int MeshEdgebreakerEncoderImpl<TraversalEncoder>::EncodeHole(
+    CornerIndex start_corner_id, bool encode_first_vertex) {
+  // We know that the start corner lies on a hole but we first need to find the
+  // boundary edge going from that vertex. It is the first edge in CW
+  // direction.
+  CornerIndex corner_id = start_corner_id;
+  corner_id = corner_table_->Previous(corner_id);
+  while (corner_table_->Opposite(corner_id) != kInvalidCornerIndex) {
+    corner_id = corner_table_->Opposite(corner_id);
+    corner_id = corner_table_->Next(corner_id);
+  }
+  const VertexIndex start_vertex_id = corner_table_->Vertex(start_corner_id);
+
+  int num_encoded_hole_verts = 0;
+  if (encode_first_vertex) {
+    visited_vertex_ids_[start_vertex_id.value()] = true;
+    ++num_encoded_hole_verts;
+  }
+
+  // corner_id is now opposite to the boundary edge.
+  // Mark the hole as visited.
+  visited_holes_[vertex_hole_id_[start_vertex_id.value()]] = true;
+  // Get the start vertex of the edge and use it as a reference.
+  VertexIndex start_vert_id =
+      corner_table_->Vertex(corner_table_->Next(corner_id));
+  // Get the end vertex of the edge.
+  VertexIndex act_vertex_id =
+      corner_table_->Vertex(corner_table_->Previous(corner_id));
+  while (act_vertex_id != start_vertex_id) {
+    // Encode the end vertex of the boundary edge.
+
+    start_vert_id = act_vertex_id;
+
+    // Mark the vertex as visited.
+    visited_vertex_ids_[act_vertex_id.value()] = true;
+    ++num_encoded_hole_verts;
+    corner_id = corner_table_->Next(corner_id);
+    // Look for the next attached open boundary edge.
+    while (corner_table_->Opposite(corner_id) != kInvalidCornerIndex) {
+      corner_id = corner_table_->Opposite(corner_id);
+      corner_id = corner_table_->Next(corner_id);
+    }
+    act_vertex_id = corner_table_->Vertex(corner_table_->Previous(corner_id));
+  }
+  return num_encoded_hole_verts;
+}
+
+template <class TraversalEncoder>
+CornerIndex MeshEdgebreakerEncoderImpl<TraversalEncoder>::GetRightCorner(
+    CornerIndex corner_id) const {
+  const CornerIndex next_corner_id = corner_table_->Next(corner_id);
+  return corner_table_->Opposite(next_corner_id);
+}
+
+template <class TraversalEncoder>
+CornerIndex MeshEdgebreakerEncoderImpl<TraversalEncoder>::GetLeftCorner(
+    CornerIndex corner_id) const {
+  const CornerIndex prev_corner_id = corner_table_->Previous(corner_id);
+  return corner_table_->Opposite(prev_corner_id);
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::IsRightFaceVisited(
+    CornerIndex corner_id) const {
+  const CornerIndex next_corner_id = corner_table_->Next(corner_id);
+  const CornerIndex opp_corner_id = corner_table_->Opposite(next_corner_id);
+  if (opp_corner_id != kInvalidCornerIndex) {
+    return visited_faces_[corner_table_->Face(opp_corner_id).value()];
+  }
+  // Else we are on a boundary.
+  return true;
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::IsLeftFaceVisited(
+    CornerIndex corner_id) const {
+  const CornerIndex prev_corner_id = corner_table_->Previous(corner_id);
+  const CornerIndex opp_corner_id = corner_table_->Opposite(prev_corner_id);
+  if (opp_corner_id != kInvalidCornerIndex) {
+    return visited_faces_[corner_table_->Face(opp_corner_id).value()];
+  }
+  // Else we are on a boundary.
+  return true;
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::FindHoles() {
+  // TODO(ostava): Add more error checking for invalid geometry data.
+  const int num_corners = corner_table_->num_corners();
+  // Go over all corners and detect non-visited open boundaries
+  for (CornerIndex i(0); i < num_corners; ++i) {
+    if (corner_table_->IsDegenerated(corner_table_->Face(i))) {
+      continue;  // Don't process corners assigned to degenerated faces.
+    }
+    if (corner_table_->Opposite(i) == kInvalidCornerIndex) {
+      // No opposite corner means no opposite face, so the opposite edge
+      // of the corner is an open boundary.
+      // Check whether we have already traversed the boundary.
+      VertexIndex boundary_vert_id =
+          corner_table_->Vertex(corner_table_->Next(i));
+      if (vertex_hole_id_[boundary_vert_id.value()] != -1) {
+        // The start vertex of the boundary edge is already assigned to an
+        // open boundary. No need to traverse it again.
+        continue;
+      }
+      // Else we found a new open boundary and we are going to traverse along it
+      // and mark all visited vertices.
+      const int boundary_id = static_cast<int>(visited_holes_.size());
+      visited_holes_.push_back(false);
+
+      CornerIndex corner_id = i;
+      while (vertex_hole_id_[boundary_vert_id.value()] == -1) {
+        // Mark the first vertex on the open boundary.
+        vertex_hole_id_[boundary_vert_id.value()] = boundary_id;
+        corner_id = corner_table_->Next(corner_id);
+        // Look for the next attached open boundary edge.
+        while (corner_table_->Opposite(corner_id) != kInvalidCornerIndex) {
+          corner_id = corner_table_->Opposite(corner_id);
+          corner_id = corner_table_->Next(corner_id);
+        }
+        // Id of the next vertex in the vertex on the hole.
+        boundary_vert_id =
+            corner_table_->Vertex(corner_table_->Next(corner_id));
+      }
+    }
+  }
+  return true;
+}
+
+template <class TraversalEncoder>
+int MeshEdgebreakerEncoderImpl<TraversalEncoder>::GetSplitSymbolIdOnFace(
+    int face_id) const {
+  auto it = face_to_split_symbol_map_.find(face_id);
+  if (it == face_to_split_symbol_map_.end()) {
+    return -1;
+  }
+  return it->second;
+}
+
+template <class TraversalEncoder>
+void MeshEdgebreakerEncoderImpl<
+    TraversalEncoder>::CheckAndStoreTopologySplitEvent(int src_symbol_id,
+                                                       int /* src_face_id */,
+                                                       EdgeFaceName src_edge,
+                                                       int neighbor_face_id) {
+  const int symbol_id = GetSplitSymbolIdOnFace(neighbor_face_id);
+  if (symbol_id == -1) {
+    return;  // Not a split symbol, no topology split event could happen.
+  }
+  TopologySplitEventData event_data;
+
+  event_data.split_symbol_id = symbol_id;
+  event_data.source_symbol_id = src_symbol_id;
+  event_data.source_edge = src_edge;
+  topology_split_event_data_.push_back(event_data);
+}
+
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<TraversalEncoder>::InitAttributeData() {
+  if (use_single_connectivity_) {
+    return true;  // All attributes use the same connectivity.
+  }
+
+  const int num_attributes = mesh_->num_attributes();
+  // Ignore the position attribute. It's decoded separately.
+  attribute_data_.resize(num_attributes - 1);
+  if (num_attributes == 1) {
+    return true;
+  }
+  int data_index = 0;
+  for (int i = 0; i < num_attributes; ++i) {
+    const int32_t att_index = i;
+    if (mesh_->attribute(att_index)->attribute_type() ==
+        GeometryAttribute::POSITION) {
+      continue;
+    }
+    const PointAttribute *const att = mesh_->attribute(att_index);
+    attribute_data_[data_index].attribute_index = att_index;
+    attribute_data_[data_index]
+        .encoding_data.encoded_attribute_value_index_to_corner_map.clear();
+    attribute_data_[data_index]
+        .encoding_data.encoded_attribute_value_index_to_corner_map.reserve(
+            corner_table_->num_corners());
+    attribute_data_[data_index].encoding_data.num_values = 0;
+    attribute_data_[data_index].connectivity_data.InitFromAttribute(
+        mesh_, corner_table_.get(), att);
+    ++data_index;
+  }
+  return true;
+}
+
+// TODO(ostava): Note that if the input mesh used the same attribute index on
+// multiple different vertices, such attribute will be duplicated using the
+// encoding below. Eventually, we may consider either using a different encoding
+// scheme for such cases, or at least deduplicating the attributes in the
+// decoder.
+template <class TraversalEncoder>
+bool MeshEdgebreakerEncoderImpl<
+    TraversalEncoder>::EncodeAttributeConnectivitiesOnFace(CornerIndex corner) {
+  // Three corners of the face.
+  const CornerIndex corners[3] = {corner, corner_table_->Next(corner),
+                                  corner_table_->Previous(corner)};
+
+  const FaceIndex src_face_id = corner_table_->Face(corner);
+  visited_faces_[src_face_id.value()] = true;
+  for (int c = 0; c < 3; ++c) {
+    const CornerIndex opp_corner = corner_table_->Opposite(corners[c]);
+    if (opp_corner == kInvalidCornerIndex) {
+      continue;  // Don't encode attribute seams on boundary edges.
+    }
+    const FaceIndex opp_face_id = corner_table_->Face(opp_corner);
+    // Don't encode edges when the opposite face has been already processed.
+    if (visited_faces_[opp_face_id.value()]) {
+      continue;
+    }
+
+    for (uint32_t i = 0; i < attribute_data_.size(); ++i) {
+      if (attribute_data_[i].connectivity_data.IsCornerOppositeToSeamEdge(
+              corners[c])) {
+        traversal_encoder_.EncodeAttributeSeam(i, true);
+      } else {
+        traversal_encoder_.EncodeAttributeSeam(i, false);
+      }
+    }
+  }
+  return true;
+}
+
+template class MeshEdgebreakerEncoderImpl<MeshEdgebreakerTraversalEncoder>;
+template class MeshEdgebreakerEncoderImpl<
+    MeshEdgebreakerTraversalPredictiveEncoder>;
+template class MeshEdgebreakerEncoderImpl<
+    MeshEdgebreakerTraversalValenceEncoder>;
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.h b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.h
new file mode 100644
index 000000000..fb3377163
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl.h
@@ -0,0 +1,210 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_H_
+
+#include <unordered_map>
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/compression/mesh/traverser/mesh_traversal_sequencer.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Class implementing the edgebreaker encoding as described in "3D Compression
+// Made Simple: Edgebreaker on a Corner-Table" by Rossignac at al.'01.
+// http://www.cc.gatech.edu/~jarek/papers/CornerTableSMI.pdf
+template <class TraversalEncoderT>
+class MeshEdgebreakerEncoderImpl : public MeshEdgebreakerEncoderImplInterface {
+ public:
+  MeshEdgebreakerEncoderImpl();
+  explicit MeshEdgebreakerEncoderImpl(
+      const TraversalEncoderT &traversal_encoder);
+  bool Init(MeshEdgebreakerEncoder *encoder) override;
+
+  const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const override;
+  const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const override;
+
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  bool EncodeAttributesEncoderIdentifier(int32_t att_encoder_id) override;
+  Status EncodeConnectivity() override;
+
+  const CornerTable *GetCornerTable() const override {
+    return corner_table_.get();
+  }
+  bool IsFaceEncoded(FaceIndex fi) const override {
+    return visited_faces_[fi.value()];
+  }
+  MeshEdgebreakerEncoder *GetEncoder() const override { return encoder_; }
+
+ private:
+  // Initializes data needed for encoding non-position attributes.
+  // Returns false on error.
+  bool InitAttributeData();
+
+  // Creates a vertex traversal sequencer for the specified |TraverserT| type.
+  template <class TraverserT>
+  std::unique_ptr<PointsSequencer> CreateVertexTraversalSequencer(
+      MeshAttributeIndicesEncodingData *encoding_data);
+
+  // Finds the configuration of the initial face that starts the traversal.
+  // Configurations are determined by location of holes around the init face
+  // and they are described in mesh_edgebreaker_shared.h.
+  // Returns true if the face configuration is interior and false if it is
+  // exterior.
+  bool FindInitFaceConfiguration(FaceIndex face_id,
+                                 CornerIndex *out_corner_id) const;
+
+  // Encodes the connectivity between vertices.
+  bool EncodeConnectivityFromCorner(CornerIndex corner_id);
+
+  // Encodes all vertices of a hole starting at start_corner_id.
+  // The vertex associated with the first corner is encoded only if
+  // |encode_first_vertex| is true.
+  // Returns the number of encoded hole vertices.
+  int EncodeHole(CornerIndex start_corner_id, bool encode_first_vertex);
+
+  // Encodes topology split data.
+  // Returns nullptr on error.
+  bool EncodeSplitData();
+
+  CornerIndex GetRightCorner(CornerIndex corner_id) const;
+  CornerIndex GetLeftCorner(CornerIndex corner_id) const;
+
+  bool IsRightFaceVisited(CornerIndex corner_id) const;
+  bool IsLeftFaceVisited(CornerIndex corner_id) const;
+  bool IsVertexVisited(VertexIndex vert_id) const {
+    return visited_vertex_ids_[vert_id.value()];
+  }
+
+  // Finds and stores data about all holes in the input mesh.
+  bool FindHoles();
+
+  // For faces encoded with symbol TOPOLOGY_S (split), this method returns
+  // the encoded symbol id or -1 if the face wasn't encoded by a split symbol.
+  int GetSplitSymbolIdOnFace(int face_id) const;
+
+  // Checks whether there is a topology split event on a neighboring face and
+  // stores the event data if necessary. For more info about topology split
+  // events, see description of TopologySplitEventData in
+  // mesh_edgebreaker_shared.h.
+  void CheckAndStoreTopologySplitEvent(int src_symbol_id, int src_face_id,
+                                       EdgeFaceName src_edge,
+                                       int neighbor_face_id);
+
+  // Encodes connectivity of all attributes on a newly traversed face.
+  bool EncodeAttributeConnectivitiesOnFace(CornerIndex corner);
+
+  // This function is used to to assign correct encoding order of attributes
+  // to unprocessed corners. The encoding order is equal to the order in which
+  // the attributes are going to be processed by the decoder and it is necessary
+  // for proper prediction of attribute values.
+  bool AssignPositionEncodingOrderToAllCorners();
+
+  // This function is used to generate encoding order for all non-position
+  // attributes.
+  // Returns false when one or more attributes failed to be processed.
+  bool GenerateEncodingOrderForAttributes();
+
+  // The main encoder that owns this class.
+  MeshEdgebreakerEncoder *encoder_;
+  // Mesh that's being encoded.
+  const Mesh *mesh_;
+  // Corner table stores the mesh face connectivity data.
+  std::unique_ptr<CornerTable> corner_table_;
+  // Stack used for storing corners that need to be traversed when encoding
+  // the connectivity. New corner is added for each initial face and a split
+  // symbol, and one corner is removed when the end symbol is reached.
+  // Stored as member variable to prevent frequent memory reallocations when
+  // handling meshes with lots of disjoint components. Originally, we used
+  // recursive functions to handle this behavior, but that can cause stack
+  // memory overflow when compressing huge meshes.
+  std::vector<CornerIndex> corner_traversal_stack_;
+  // Array for marking visited faces.
+  std::vector<bool> visited_faces_;
+
+  // Attribute data for position encoding.
+  MeshAttributeIndicesEncodingData pos_encoding_data_;
+
+  // Traversal method used for the position attribute.
+  MeshTraversalMethod pos_traversal_method_;
+
+  // Array storing corners in the order they were visited during the
+  // connectivity encoding (always storing the tip corner of each newly visited
+  // face).
+  std::vector<CornerIndex> processed_connectivity_corners_;
+
+  // Array for storing visited vertex ids of all input vertices.
+  std::vector<bool> visited_vertex_ids_;
+
+  // For each traversal, this array stores the number of visited vertices.
+  std::vector<int> vertex_traversal_length_;
+  // Array for storing all topology split events encountered during the mesh
+  // traversal.
+  std::vector<TopologySplitEventData> topology_split_event_data_;
+  // Map between face_id and symbol_id. Contains entries only for faces that
+  // were encoded with TOPOLOGY_S symbol.
+  std::unordered_map<int, int> face_to_split_symbol_map_;
+
+  // Array for marking holes that has been reached during the traversal.
+  std::vector<bool> visited_holes_;
+  // Array for mapping vertices to hole ids. If a vertex is not on a hole, the
+  // stored value is -1.
+  std::vector<int> vertex_hole_id_;
+
+  // Id of the last encoded symbol.
+  int last_encoded_symbol_id_;
+
+  // The number of encoded split symbols.
+  uint32_t num_split_symbols_;
+
+  // Struct holding data used for encoding each non-position attribute.
+  // TODO(ostava): This should be probably renamed to something better.
+  struct AttributeData {
+    AttributeData() : attribute_index(-1), is_connectivity_used(true) {}
+    int attribute_index;
+    MeshAttributeCornerTable connectivity_data;
+    // Flag that can mark the connectivity_data invalid. In such case the base
+    // corner table of the mesh should be used instead.
+    bool is_connectivity_used;
+    // Data about attribute encoding order.
+    MeshAttributeIndicesEncodingData encoding_data;
+    // Traversal method used to generate the encoding data for this attribute.
+    MeshTraversalMethod traversal_method;
+  };
+  std::vector<AttributeData> attribute_data_;
+
+  // Array storing mapping between attribute encoder id and attribute data id.
+  std::vector<int32_t> attribute_encoder_to_data_id_map_;
+
+  TraversalEncoderT traversal_encoder_;
+
+  // If set, the encoder is going to use the same connectivity for all
+  // attributes. This effectively breaks the mesh along all attribute seams.
+  // In general, this approach should be much faster compared to encoding each
+  // connectivity separately, but the decoded model may contain higher number of
+  // duplicate attribute values which may decrease the compression ratio.
+  bool use_single_connectivity_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h
new file mode 100644
index 000000000..627d51262
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h
@@ -0,0 +1,57 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_INTERFACE_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_INTERFACE_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Forward declaration is necessary here to avoid circular dependencies.
+class MeshEdgebreakerEncoder;
+
+// Abstract interface used by MeshEdgebreakerEncoder to interact with the actual
+// implementation of the edgebreaker method. The implementations are in general
+// specializations of a template class MeshEdgebreakerEncoderImpl where the
+// template arguments control encoding of the connectivity data. Because the
+// choice of the implementation is done in run-time, we need to hide it behind
+// the abstract interface MeshEdgebreakerEncoderImplInterface.
+class MeshEdgebreakerEncoderImplInterface {
+ public:
+  virtual ~MeshEdgebreakerEncoderImplInterface() = default;
+  virtual bool Init(MeshEdgebreakerEncoder *encoder) = 0;
+
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int att_id) const = 0;
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int att_id) const = 0;
+  virtual bool GenerateAttributesEncoder(int32_t att_id) = 0;
+  virtual bool EncodeAttributesEncoderIdentifier(int32_t att_encoder_id) = 0;
+  virtual Status EncodeConnectivity() = 0;
+
+  // Returns corner table of the encoded mesh.
+  virtual const CornerTable *GetCornerTable() const = 0;
+
+  // Returns true if a given face has been already encoded.
+  virtual bool IsFaceEncoded(FaceIndex fi) const = 0;
+
+  virtual MeshEdgebreakerEncoder *GetEncoder() const = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_ENCODER_IMPL_INTERFACE_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoding_test.cc b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoding_test.cc
new file mode 100644
index 000000000..831388245
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_encoding_test.cc
@@ -0,0 +1,247 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <sstream>
+
+#include "draco/compression/encode.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_encoder.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/mesh_io.h"
+#include "draco/io/obj_decoder.h"
+#include "draco/mesh/mesh_are_equivalent.h"
+#include "draco/mesh/mesh_cleanup.h"
+#include "draco/mesh/triangle_soup_mesh_builder.h"
+
+namespace draco {
+
+class MeshEdgebreakerEncodingTest : public ::testing::Test {
+ protected:
+  void TestFile(const std::string &file_name) { TestFile(file_name, -1); }
+
+  void TestFile(const std::string &file_name, int compression_level) {
+    const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+    ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+
+    TestMesh(mesh.get(), compression_level);
+  }
+
+  void TestMesh(Mesh *mesh, int compression_level) {
+    EncoderBuffer buffer;
+    MeshEdgebreakerEncoder encoder;
+    EncoderOptions encoder_options = EncoderOptions::CreateDefaultOptions();
+    encoder_options.SetSpeed(10 - compression_level, 10 - compression_level);
+    encoder.SetMesh(*mesh);
+    ASSERT_TRUE(encoder.Encode(encoder_options, &buffer).ok());
+
+    DecoderBuffer dec_buffer;
+    dec_buffer.Init(buffer.data(), buffer.size());
+    MeshEdgebreakerDecoder decoder;
+
+    std::unique_ptr<Mesh> decoded_mesh(new Mesh());
+    DecoderOptions dec_options;
+    ASSERT_TRUE(
+        decoder.Decode(dec_options, &dec_buffer, decoded_mesh.get()).ok());
+
+    // Cleanup the input mesh to make sure that input and output can be
+    // compared (edgebreaker method discards degenerated triangles and isolated
+    // vertices).
+    const MeshCleanupOptions options;
+    MeshCleanup cleanup;
+    ASSERT_TRUE(cleanup(mesh, options)) << "Failed to clean the input mesh.";
+
+    MeshAreEquivalent eq;
+    ASSERT_TRUE(eq(*mesh, *decoded_mesh.get()))
+        << "Decoded mesh is not the same as the input";
+  }
+};
+
+TEST_F(MeshEdgebreakerEncodingTest, TestNmOBJ) {
+  const std::string file_name = "test_nm.obj";
+  TestFile(file_name);
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, ThreeFacesOBJ) {
+  const std::string file_name = "extra_vertex.obj";
+  TestFile(file_name);
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestPly) {
+  // Tests whether the edgebreaker successfully encodes and decodes the test
+  // file (ply with color).
+  const std::string file_name = "test_pos_color.ply";
+  TestFile(file_name);
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestMultiAttributes) {
+  // Tests encoding of model with many attributes.
+  const std::string file_name = "cube_att.obj";
+  TestFile(file_name, 10);
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestEncoderReuse) {
+  // Tests whether the edgebreaker encoder can be reused multiple times to
+  // encode a given mesh.
+  const std::string file_name = "test_pos_color.ply";
+  const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+
+  MeshEdgebreakerEncoder encoder;
+  EncoderOptions encoder_options = EncoderOptions::CreateDefaultOptions();
+  encoder.SetMesh(*mesh);
+  EncoderBuffer buffer_0, buffer_1;
+  ASSERT_TRUE(encoder.Encode(encoder_options, &buffer_0).ok());
+  ASSERT_TRUE(encoder.Encode(encoder_options, &buffer_1).ok());
+
+  // Make sure both buffer are identical.
+  ASSERT_EQ(buffer_0.size(), buffer_1.size());
+  for (int i = 0; i < buffer_0.size(); ++i) {
+    ASSERT_EQ(buffer_0.data()[i], buffer_1.data()[i]);
+  }
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestDecoderReuse) {
+  // Tests whether the edgebreaker decoder can be reused multiple times to
+  // decode a given mesh.
+  const std::string file_name = "test_pos_color.ply";
+  const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+
+  MeshEdgebreakerEncoder encoder;
+  EncoderOptions encoder_options = EncoderOptions::CreateDefaultOptions();
+  encoder.SetMesh(*mesh);
+  EncoderBuffer buffer;
+  ASSERT_TRUE(encoder.Encode(encoder_options, &buffer).ok());
+
+  DecoderBuffer dec_buffer;
+  dec_buffer.Init(buffer.data(), buffer.size());
+
+  MeshEdgebreakerDecoder decoder;
+
+  // Decode the mesh two times.
+  std::unique_ptr<Mesh> decoded_mesh_0(new Mesh());
+  DecoderOptions dec_options;
+  ASSERT_TRUE(
+      decoder.Decode(dec_options, &dec_buffer, decoded_mesh_0.get()).ok());
+
+  dec_buffer.Init(buffer.data(), buffer.size());
+  std::unique_ptr<Mesh> decoded_mesh_1(new Mesh());
+  ASSERT_TRUE(
+      decoder.Decode(dec_options, &dec_buffer, decoded_mesh_1.get()).ok());
+
+  // Make sure both of the meshes are identical.
+  MeshAreEquivalent eq;
+  ASSERT_TRUE(eq(*decoded_mesh_0.get(), *decoded_mesh_1.get()))
+      << "Decoded meshes are not the same";
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestSingleConnectivityEncoding) {
+  // Tests whether the edgebreaker method successfully encodes a mesh with
+  // multiple attributes using single connectivity by breaking the mesh along
+  // attribute seams.
+  const std::string file_name = "cube_att.obj";
+  const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+
+  for (int i = 0; i < 2; ++i) {
+    // Set the option to enable/disable single connectivity encoding.
+    EncoderOptionsBase<GeometryAttribute::Type> options =
+        EncoderOptionsBase<GeometryAttribute::Type>::CreateDefaultOptions();
+    options.SetGlobalBool("split_mesh_on_seams", i == 0 ? true : false);
+
+    EncoderBuffer buffer;
+    draco::Encoder encoder;
+    encoder.Reset(options);
+    encoder.SetSpeedOptions(0, 0);
+    encoder.SetAttributeQuantization(GeometryAttribute::POSITION, 8);
+    encoder.SetAttributeQuantization(GeometryAttribute::TEX_COORD, 8);
+    encoder.SetAttributeQuantization(GeometryAttribute::NORMAL, 8);
+    encoder.SetEncodingMethod(MESH_EDGEBREAKER_ENCODING);
+    ASSERT_TRUE(encoder.EncodeMeshToBuffer(*mesh, &buffer).ok());
+
+    DecoderBuffer dec_buffer;
+    dec_buffer.Init(buffer.data(), buffer.size());
+
+    Decoder decoder;
+    auto dec_mesh = decoder.DecodeMeshFromBuffer(&dec_buffer).value();
+    ASSERT_NE(dec_mesh, nullptr);
+    ASSERT_EQ(dec_mesh->num_points(), 24);
+    ASSERT_EQ(dec_mesh->num_attributes(), 3);
+    ASSERT_EQ(dec_mesh->attribute(0)->size(), i == 0 ? 24 : 8);
+    ASSERT_EQ(dec_mesh->attribute(1)->size(), 24);
+    ASSERT_EQ(dec_mesh->attribute(2)->size(), 24);
+  }
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestWrongAttributeOrder) {
+  // Tests whether the edgebreaker method successfully encodes a mesh where the
+  // input attributes are in wrong order (because of their internal
+  // dependencies). In such case the attributes should be rearranged to the
+  // correct order.
+  TriangleSoupMeshBuilder mb;
+  mb.Start(1);
+  const int32_t norm_att_id =
+      mb.AddAttribute(GeometryAttribute::NORMAL, 3, DT_FLOAT32);
+  const int32_t pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+
+  mb.SetAttributeValuesForFace(
+      pos_att_id, FaceIndex(0), Vector3f(0.f, 0.f, 0.f).data(),
+      Vector3f(1.f, 0.f, 0.f).data(), Vector3f(0.f, 1.f, 0.f).data());
+
+  mb.SetAttributeValuesForFace(
+      norm_att_id, FaceIndex(0), Vector3f(0.f, 0.f, 1.f).data(),
+      Vector3f(0.f, 0.f, 0.f).data(), Vector3f(0.f, 0.f, 1.f).data());
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr);
+  ASSERT_EQ(mesh->num_attributes(), 2);
+  ASSERT_EQ(mesh->attribute(0)->attribute_type(), GeometryAttribute::NORMAL);
+  ASSERT_EQ(mesh->attribute(1)->attribute_type(), GeometryAttribute::POSITION);
+
+  EncoderBuffer buffer;
+  draco::Encoder encoder;
+  encoder.SetSpeedOptions(3, 3);
+  encoder.SetAttributeQuantization(GeometryAttribute::POSITION, 8);
+  encoder.SetAttributeQuantization(GeometryAttribute::NORMAL, 8);
+  encoder.SetEncodingMethod(MESH_EDGEBREAKER_ENCODING);
+  ASSERT_TRUE(encoder.EncodeMeshToBuffer(*mesh, &buffer).ok());
+
+  DecoderBuffer dec_buffer;
+  dec_buffer.Init(buffer.data(), buffer.size());
+
+  Decoder decoder;
+  auto dec_mesh = decoder.DecodeMeshFromBuffer(&dec_buffer).value();
+  ASSERT_NE(dec_mesh, nullptr);
+  ASSERT_EQ(dec_mesh->num_attributes(), 2);
+  ASSERT_EQ(dec_mesh->attribute(0)->attribute_type(),
+            GeometryAttribute::POSITION);
+  ASSERT_EQ(dec_mesh->attribute(1)->attribute_type(),
+            GeometryAttribute::NORMAL);
+}
+
+TEST_F(MeshEdgebreakerEncodingTest, TestDegenerateMesh) {
+  // Tests whether we can process a mesh that contains degenerate faces only.
+  const std::string file_name = "degenerate_mesh.obj";
+  const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+  EncoderBuffer buffer;
+  MeshEdgebreakerEncoder encoder;
+  EncoderOptions encoder_options = EncoderOptions::CreateDefaultOptions();
+  encoder.SetMesh(*mesh);
+  // We expect the encoding to fail as edgebreaker can only process valid faces.
+  ASSERT_FALSE(encoder.Encode(encoder_options, &buffer).ok());
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_shared.h b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_shared.h
new file mode 100644
index 000000000..cb3c29dd6
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_shared.h
@@ -0,0 +1,131 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_SHARED_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_SHARED_H_
+
+#include <stdint.h>
+
+namespace draco {
+
+// Shared declarations used by both edgebreaker encoder and decoder.
+
+// A variable length encoding for storing all possible topology configurations
+// during traversal of mesh's surface. The configurations are based on visited
+// state of neighboring triangles around a currently processed face corner.
+// Note that about half of the encountered configurations is expected to be of
+// type TOPOLOGY_C. It's guaranteed that the encoding will use at most 2 bits
+// per triangle for meshes with no holes and up to 6 bits per triangle for
+// general meshes. In addition, the encoding will take up to 4 bits per triangle
+// for each non-position attribute attached to the mesh.
+//
+//     *-------*          *-------*          *-------*
+//    / \     / \        / \     / \        / \     / \
+//   /   \   /   \      /   \   /   \      /   \   /   \
+//  /     \ /     \    /     \ /     \    /     \ /     \
+// *-------v-------*  *-------v-------*  *-------v-------*
+//  \     /x\     /          /x\     /    \     /x\
+//   \   /   \   /          /   \   /      \   /   \
+//    \ /  C  \ /          /  L  \ /        \ /  R  \
+//     *-------*          *-------*          *-------*
+//
+//     *       *
+//    / \     / \
+//   /   \   /   \
+//  /     \ /     \
+// *-------v-------*          v
+//  \     /x\     /          /x\
+//   \   /   \   /          /   \
+//    \ /  S  \ /          /  E  \
+//     *-------*          *-------*
+//
+// TODO(ostava): Get rid of the topology bit pattern. It's important only for
+// encoding but the algorithms should use EdgebreakerSymbol instead.
+enum EdgebreakerTopologyBitPattern {
+  TOPOLOGY_C = 0x0,  // 0
+  TOPOLOGY_S = 0x1,  // 1 0 0
+  TOPOLOGY_L = 0x3,  // 1 1 0
+  TOPOLOGY_R = 0x5,  // 1 0 1
+  TOPOLOGY_E = 0x7,  // 1 1 1
+  // A special symbol that's not actually encoded, but it can be used to mark
+  // the initial face that triggers the mesh encoding of a single connected
+  // component.
+  TOPOLOGY_INIT_FACE,
+  // A special value used to indicate an invalid symbol.
+  TOPOLOGY_INVALID
+};
+
+enum EdgebreakerSymbol {
+  EDGEBREAKER_SYMBOL_C = 0,
+  EDGEBREAKER_SYMBOL_S,
+  EDGEBREAKER_SYMBOL_L,
+  EDGEBREAKER_SYMBOL_R,
+  EDGEBREAKER_SYMBOL_E,
+  EDGEBREAKER_SYMBOL_INVALID
+};
+
+// Bit-length of symbols in the EdgebreakerTopologyBitPattern stored as a
+// lookup table for faster indexing.
+constexpr int32_t edge_breaker_topology_bit_pattern_length[] = {1, 3, 0, 3,
+                                                                0, 3, 0, 3};
+
+// Zero-indexed symbol id for each of topology pattern.
+constexpr EdgebreakerSymbol edge_breaker_topology_to_symbol_id[] = {
+    EDGEBREAKER_SYMBOL_C,       EDGEBREAKER_SYMBOL_S,
+    EDGEBREAKER_SYMBOL_INVALID, EDGEBREAKER_SYMBOL_L,
+    EDGEBREAKER_SYMBOL_INVALID, EDGEBREAKER_SYMBOL_R,
+    EDGEBREAKER_SYMBOL_INVALID, EDGEBREAKER_SYMBOL_E};
+
+// Reverse mapping between symbol id and topology pattern symbol.
+constexpr EdgebreakerTopologyBitPattern edge_breaker_symbol_to_topology_id[] = {
+    TOPOLOGY_C, TOPOLOGY_S, TOPOLOGY_L, TOPOLOGY_R, TOPOLOGY_E};
+
+// Types of edges used during mesh traversal relative to the tip vertex of a
+// visited triangle.
+enum EdgeFaceName : uint8_t { LEFT_FACE_EDGE = 0, RIGHT_FACE_EDGE = 1 };
+
+// Struct used for storing data about a source face that connects to an
+// already traversed face that was either the initial face or a face encoded
+// with either topology S (split) symbol. Such connection can be only caused by
+// topology changes on the traversed surface (if its genus != 0, i.e. when the
+// surface has topological handles or holes).
+// For each occurrence of such event we always encode the split symbol id,
+// source symbol id and source edge id (left, or right). There will be always
+// exactly two occurrences of this event for every topological handle on the
+// traversed mesh and one occurrence for a hole.
+struct TopologySplitEventData {
+  uint32_t split_symbol_id;
+  uint32_t source_symbol_id;
+  // We need to use uint32_t instead of EdgeFaceName because the most recent
+  // version of gcc does not allow that when optimizations are turned on.
+  uint32_t source_edge : 1;
+};
+
+// Hole event is used to store info about the first symbol that reached a
+// vertex of so far unvisited hole. This can happen only on either the initial
+// face or during a regular traversal when TOPOLOGY_S is encountered.
+struct HoleEventData {
+  int32_t symbol_id;
+  HoleEventData() : symbol_id(0) {}
+  explicit HoleEventData(int32_t sym_id) : symbol_id(sym_id) {}
+};
+
+// List of supported modes for valence based edgebreaker coding.
+enum EdgebreakerValenceCodingMode {
+  EDGEBREAKER_VALENCE_MODE_2_7 = 0,  // Use contexts for valences in range 2-7.
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_SHARED_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h
new file mode 100644
index 000000000..ce91adc87
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h
@@ -0,0 +1,201 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_DECODER_H_
+
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_decoder_impl_interface.h"
+#include "draco/compression/mesh/mesh_edgebreaker_shared.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+typedef RAnsBitDecoder BinaryDecoder;
+
+// Default implementation of the edgebreaker traversal decoder that reads the
+// traversal data directly from a buffer.
+class MeshEdgebreakerTraversalDecoder {
+ public:
+  MeshEdgebreakerTraversalDecoder()
+      : attribute_connectivity_decoders_(nullptr),
+        num_attribute_data_(0),
+        decoder_impl_(nullptr) {}
+  void Init(MeshEdgebreakerDecoderImplInterface *decoder) {
+    decoder_impl_ = decoder;
+    buffer_.Init(decoder->GetDecoder()->buffer()->data_head(),
+                 decoder->GetDecoder()->buffer()->remaining_size(),
+                 decoder->GetDecoder()->buffer()->bitstream_version());
+  }
+
+  // Returns the Draco bitstream version.
+  uint16_t BitstreamVersion() const {
+    return decoder_impl_->GetDecoder()->bitstream_version();
+  }
+
+  // Used to tell the decoder what is the number of expected decoded vertices.
+  // Ignored by default.
+  void SetNumEncodedVertices(int /* num_vertices */) {}
+
+  // Set the number of non-position attribute data for which we need to decode
+  // the connectivity.
+  void SetNumAttributeData(int num_data) { num_attribute_data_ = num_data; }
+
+  // Called before the traversal decoding is started.
+  // Returns a buffer decoder that points to data that was encoded after the
+  // traversal.
+  bool Start(DecoderBuffer *out_buffer) {
+    // Decode symbols from the main buffer decoder and face configurations from
+    // the start_face_buffer decoder.
+    if (!DecodeTraversalSymbols()) {
+      return false;
+    }
+
+    if (!DecodeStartFaces()) {
+      return false;
+    }
+
+    if (!DecodeAttributeSeams()) {
+      return false;
+    }
+    *out_buffer = buffer_;
+    return true;
+  }
+
+  // Returns the configuration of a new initial face.
+  inline bool DecodeStartFaceConfiguration() {
+    uint32_t face_configuration;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (buffer_.bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      start_face_buffer_.DecodeLeastSignificantBits32(1, &face_configuration);
+
+    } else
+#endif
+    {
+      face_configuration = start_face_decoder_.DecodeNextBit();
+    }
+    return face_configuration;
+  }
+
+  // Returns the next edgebreaker symbol that was reached during the traversal.
+  inline uint32_t DecodeSymbol() {
+    uint32_t symbol;
+    symbol_buffer_.DecodeLeastSignificantBits32(1, &symbol);
+    if (symbol == TOPOLOGY_C) {
+      return symbol;
+    }
+    // Else decode two additional bits.
+    uint32_t symbol_suffix;
+    symbol_buffer_.DecodeLeastSignificantBits32(2, &symbol_suffix);
+    symbol |= (symbol_suffix << 1);
+    return symbol;
+  }
+
+  // Called whenever a new active corner is set in the decoder.
+  inline void NewActiveCornerReached(CornerIndex /* corner */) {}
+
+  // Called whenever |source| vertex is about to be merged into the |dest|
+  // vertex.
+  inline void MergeVertices(VertexIndex /* dest */, VertexIndex /* source */) {}
+
+  // Returns true if there is an attribute seam for the next processed pair
+  // of visited faces.
+  // |attribute| is used to mark the id of the non-position attribute (in range
+  // of <0, num_attributes - 1>).
+  inline bool DecodeAttributeSeam(int attribute) {
+    return attribute_connectivity_decoders_[attribute].DecodeNextBit();
+  }
+
+  // Called when the traversal is finished.
+  void Done() {
+    if (symbol_buffer_.bit_decoder_active()) {
+      symbol_buffer_.EndBitDecoding();
+    }
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (buffer_.bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      start_face_buffer_.EndBitDecoding();
+
+    } else
+#endif
+    {
+      start_face_decoder_.EndDecoding();
+    }
+  }
+
+ protected:
+  DecoderBuffer *buffer() { return &buffer_; }
+
+  bool DecodeTraversalSymbols() {
+    uint64_t traversal_size;
+    symbol_buffer_ = buffer_;
+    if (!symbol_buffer_.StartBitDecoding(true, &traversal_size)) {
+      return false;
+    }
+    buffer_ = symbol_buffer_;
+    if (traversal_size > static_cast<uint64_t>(buffer_.remaining_size())) {
+      return false;
+    }
+    buffer_.Advance(traversal_size);
+    return true;
+  }
+
+  bool DecodeStartFaces() {
+    // Create a decoder that is set to the end of the encoded traversal data.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (buffer_.bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      start_face_buffer_ = buffer_;
+      uint64_t traversal_size;
+      if (!start_face_buffer_.StartBitDecoding(true, &traversal_size)) {
+        return false;
+      }
+      buffer_ = start_face_buffer_;
+      if (traversal_size > static_cast<uint64_t>(buffer_.remaining_size())) {
+        return false;
+      }
+      buffer_.Advance(traversal_size);
+      return true;
+    }
+#endif
+    return start_face_decoder_.StartDecoding(&buffer_);
+  }
+
+  bool DecodeAttributeSeams() {
+    // Prepare attribute decoding.
+    if (num_attribute_data_ > 0) {
+      attribute_connectivity_decoders_ = std::unique_ptr<BinaryDecoder[]>(
+          new BinaryDecoder[num_attribute_data_]);
+      for (int i = 0; i < num_attribute_data_; ++i) {
+        if (!attribute_connectivity_decoders_[i].StartDecoding(&buffer_)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+ private:
+  // Buffer that contains the encoded data.
+  DecoderBuffer buffer_;
+  DecoderBuffer symbol_buffer_;
+  BinaryDecoder start_face_decoder_;
+  DecoderBuffer start_face_buffer_;
+  std::unique_ptr<BinaryDecoder[]> attribute_connectivity_decoders_;
+  int num_attribute_data_;
+  const MeshEdgebreakerDecoderImplInterface *decoder_impl_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h
new file mode 100644
index 000000000..08cb66e4c
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h
@@ -0,0 +1,139 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_ENCODER_H_
+
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_encoder.h"
+#include "draco/compression/mesh/mesh_edgebreaker_encoder_impl_interface.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+typedef RAnsBitEncoder BinaryEncoder;
+
+// Default implementation of the edgebreaker traversal encoder. Face
+// configurations are stored directly into the output buffer and the symbols
+// are first collected and then encoded in the reverse order to make the
+// decoding faster.
+class MeshEdgebreakerTraversalEncoder {
+ public:
+  MeshEdgebreakerTraversalEncoder()
+      : encoder_impl_(nullptr),
+        attribute_connectivity_encoders_(nullptr),
+        num_attribute_data_(0) {}
+  bool Init(MeshEdgebreakerEncoderImplInterface *encoder) {
+    encoder_impl_ = encoder;
+    return true;
+  }
+
+  // Set the number of non-position attribute data for which we need to encode
+  // the connectivity.
+  void SetNumAttributeData(int num_data) { num_attribute_data_ = num_data; }
+
+  // Called before the traversal encoding is started.
+  void Start() {
+    start_face_encoder_.StartEncoding();
+    if (num_attribute_data_ > 0) {
+      // Init and start arithmetic encoders for storing configuration types
+      // of non-position attributes.
+      attribute_connectivity_encoders_ = std::unique_ptr<BinaryEncoder[]>(
+          new BinaryEncoder[num_attribute_data_]);
+      for (int i = 0; i < num_attribute_data_; ++i) {
+        attribute_connectivity_encoders_[i].StartEncoding();
+      }
+    }
+  }
+
+  // Called when a traversal starts from a new initial face.
+  inline void EncodeStartFaceConfiguration(bool interior) {
+    start_face_encoder_.EncodeBit(interior);
+  }
+
+  // Called when a new corner is reached during the traversal. No-op for the
+  // default encoder.
+  inline void NewCornerReached(CornerIndex /* corner */) {}
+
+  // Called whenever a new symbol is reached during the edgebreaker traversal.
+  inline void EncodeSymbol(EdgebreakerTopologyBitPattern symbol) {
+    // Store the symbol. It will be encoded after all symbols are processed.
+    symbols_.push_back(symbol);
+  }
+
+  // Called for every pair of connected and visited faces. |is_seam| specifies
+  // whether there is an attribute seam between the two faces.
+
+  inline void EncodeAttributeSeam(int attribute, bool is_seam) {
+    attribute_connectivity_encoders_[attribute].EncodeBit(is_seam ? 1 : 0);
+  }
+
+  // Called when the traversal is finished.
+  void Done() {
+    EncodeTraversalSymbols();
+    EncodeStartFaces();
+    EncodeAttributeSeams();
+  }
+
+  // Returns the number of encoded symbols.
+  int NumEncodedSymbols() const { return static_cast<int>(symbols_.size()); }
+
+  const EncoderBuffer &buffer() const { return traversal_buffer_; }
+
+ protected:
+  void EncodeTraversalSymbols() {
+    // Bit encode the collected symbols.
+    // Allocate enough storage for the bit encoder.
+    // It's guaranteed that each face will need only up to 3 bits.
+    traversal_buffer_.StartBitEncoding(
+        encoder_impl_->GetEncoder()->mesh()->num_faces() * 3, true);
+    for (int i = static_cast<int>(symbols_.size() - 1); i >= 0; --i) {
+      traversal_buffer_.EncodeLeastSignificantBits32(
+          edge_breaker_topology_bit_pattern_length[symbols_[i]], symbols_[i]);
+    }
+    traversal_buffer_.EndBitEncoding();
+  }
+
+  void EncodeStartFaces() {
+    start_face_encoder_.EndEncoding(&traversal_buffer_);
+  }
+
+  void EncodeAttributeSeams() {
+    if (attribute_connectivity_encoders_ != nullptr) {
+      for (int i = 0; i < num_attribute_data_; ++i) {
+        attribute_connectivity_encoders_[i].EndEncoding(&traversal_buffer_);
+      }
+    }
+  }
+
+  EncoderBuffer *GetOutputBuffer() { return &traversal_buffer_; }
+  const MeshEdgebreakerEncoderImplInterface *encoder_impl() const {
+    return encoder_impl_;
+  }
+
+ private:
+  BinaryEncoder start_face_encoder_;
+  EncoderBuffer traversal_buffer_;
+  const MeshEdgebreakerEncoderImplInterface *encoder_impl_;
+  // Symbols collected during the traversal.
+  std::vector<EdgebreakerTopologyBitPattern> symbols_;
+  // Arithmetic encoder for encoding attribute seams.
+  // One context for each non-position attribute.
+  std::unique_ptr<BinaryEncoder[]> attribute_connectivity_encoders_;
+  int num_attribute_data_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h
new file mode 100644
index 000000000..3f9004585
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_decoder.h
@@ -0,0 +1,134 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_DECODER_H_
+
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for traversal encoded with the
+// MeshEdgebreakerTraversalPredictiveEncoder. The decoder maintains valences
+// of the decoded portion of the traversed mesh and it uses them to predict
+// symbols that are about to be decoded.
+class MeshEdgebreakerTraversalPredictiveDecoder
+    : public MeshEdgebreakerTraversalDecoder {
+ public:
+  MeshEdgebreakerTraversalPredictiveDecoder()
+      : corner_table_(nullptr),
+        num_vertices_(0),
+        last_symbol_(-1),
+        predicted_symbol_(-1) {}
+  void Init(MeshEdgebreakerDecoderImplInterface *decoder) {
+    MeshEdgebreakerTraversalDecoder::Init(decoder);
+    corner_table_ = decoder->GetCornerTable();
+  }
+  void SetNumEncodedVertices(int num_vertices) { num_vertices_ = num_vertices; }
+
+  bool Start(DecoderBuffer *out_buffer) {
+    if (!MeshEdgebreakerTraversalDecoder::Start(out_buffer)) {
+      return false;
+    }
+    int32_t num_split_symbols;
+    if (!out_buffer->Decode(&num_split_symbols) || num_split_symbols < 0)
+      return false;
+    if (num_split_symbols >= num_vertices_) {
+      return false;
+    }
+    // Set the valences of all initial vertices to 0.
+    vertex_valences_.resize(num_vertices_, 0);
+    if (!prediction_decoder_.StartDecoding(out_buffer)) {
+      return false;
+    }
+    return true;
+  }
+
+  inline uint32_t DecodeSymbol() {
+    // First check if we have a predicted symbol.
+    if (predicted_symbol_ != -1) {
+      // Double check that the predicted symbol was predicted correctly.
+      if (prediction_decoder_.DecodeNextBit()) {
+        last_symbol_ = predicted_symbol_;
+        return predicted_symbol_;
+      }
+    }
+    // We don't have a predicted symbol or the symbol was mis-predicted.
+    // Decode it directly.
+    last_symbol_ = MeshEdgebreakerTraversalDecoder::DecodeSymbol();
+    return last_symbol_;
+  }
+
+  inline void NewActiveCornerReached(CornerIndex corner) {
+    const CornerIndex next = corner_table_->Next(corner);
+    const CornerIndex prev = corner_table_->Previous(corner);
+    // Update valences.
+    switch (last_symbol_) {
+      case TOPOLOGY_C:
+      case TOPOLOGY_S:
+        vertex_valences_[corner_table_->Vertex(next).value()] += 1;
+        vertex_valences_[corner_table_->Vertex(prev).value()] += 1;
+        break;
+      case TOPOLOGY_R:
+        vertex_valences_[corner_table_->Vertex(corner).value()] += 1;
+        vertex_valences_[corner_table_->Vertex(next).value()] += 1;
+        vertex_valences_[corner_table_->Vertex(prev).value()] += 2;
+        break;
+      case TOPOLOGY_L:
+        vertex_valences_[corner_table_->Vertex(corner).value()] += 1;
+        vertex_valences_[corner_table_->Vertex(next).value()] += 2;
+        vertex_valences_[corner_table_->Vertex(prev).value()] += 1;
+        break;
+      case TOPOLOGY_E:
+        vertex_valences_[corner_table_->Vertex(corner).value()] += 2;
+        vertex_valences_[corner_table_->Vertex(next).value()] += 2;
+        vertex_valences_[corner_table_->Vertex(prev).value()] += 2;
+        break;
+      default:
+        break;
+    }
+    // Compute the new predicted symbol.
+    if (last_symbol_ == TOPOLOGY_C || last_symbol_ == TOPOLOGY_R) {
+      const VertexIndex pivot =
+          corner_table_->Vertex(corner_table_->Next(corner));
+      if (vertex_valences_[pivot.value()] < 6) {
+        predicted_symbol_ = TOPOLOGY_R;
+      } else {
+        predicted_symbol_ = TOPOLOGY_C;
+      }
+    } else {
+      predicted_symbol_ = -1;
+    }
+  }
+
+  inline void MergeVertices(VertexIndex dest, VertexIndex source) {
+    // Update valences on the merged vertices.
+    vertex_valences_[dest.value()] += vertex_valences_[source.value()];
+  }
+
+ private:
+  const CornerTable *corner_table_;
+  int num_vertices_;
+  std::vector<int> vertex_valences_;
+  BinaryDecoder prediction_decoder_;
+  int last_symbol_;
+  int predicted_symbol_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_DECODER_H_
+#endif
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h
new file mode 100644
index 000000000..eb937fe80
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_predictive_encoder.h
@@ -0,0 +1,172 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_ENCODER_H_
+
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h"
+
+namespace draco {
+
+// Encoder that tries to predict the edgebreaker traversal symbols based on the
+// vertex valences of the unencoded portion of the mesh. The current prediction
+// scheme assumes that each vertex has valence 6 which can be used to predict
+// the symbol preceding the one that is currently encoded. Predictions are
+// encoded using an arithmetic coding which can lead to less than 1 bit per
+// triangle encoding for highly regular meshes.
+class MeshEdgebreakerTraversalPredictiveEncoder
+    : public MeshEdgebreakerTraversalEncoder {
+ public:
+  MeshEdgebreakerTraversalPredictiveEncoder()
+      : corner_table_(nullptr),
+        prev_symbol_(-1),
+        num_split_symbols_(0),
+        last_corner_(kInvalidCornerIndex),
+        num_symbols_(0) {}
+
+  bool Init(MeshEdgebreakerEncoderImplInterface *encoder) {
+    if (!MeshEdgebreakerTraversalEncoder::Init(encoder)) {
+      return false;
+    }
+    corner_table_ = encoder->GetCornerTable();
+    // Initialize valences of all vertices.
+    vertex_valences_.resize(corner_table_->num_vertices());
+    for (uint32_t i = 0; i < vertex_valences_.size(); ++i) {
+      vertex_valences_[i] = corner_table_->Valence(VertexIndex(i));
+    }
+    return true;
+  }
+
+  inline void NewCornerReached(CornerIndex corner) { last_corner_ = corner; }
+
+  inline int32_t ComputePredictedSymbol(VertexIndex pivot) {
+    const int valence = vertex_valences_[pivot.value()];
+    if (valence < 0) {
+      // This situation can happen only for split vertices. Returning
+      // TOPOLOGY_INVALID always cases misprediction.
+      return TOPOLOGY_INVALID;
+    }
+    if (valence < 6) {
+      return TOPOLOGY_R;
+    }
+    return TOPOLOGY_C;
+  }
+
+  inline void EncodeSymbol(EdgebreakerTopologyBitPattern symbol) {
+    ++num_symbols_;
+    // Update valences on the mesh. And compute the predicted preceding symbol.
+    // Note that the valences are computed for the so far unencoded part of the
+    // mesh. Adding a new symbol either reduces valences on the vertices or
+    // leaves the valence unchanged.
+    int32_t predicted_symbol = -1;
+    const CornerIndex next = corner_table_->Next(last_corner_);
+    const CornerIndex prev = corner_table_->Previous(last_corner_);
+    switch (symbol) {
+      case TOPOLOGY_C:
+        // Compute prediction.
+        predicted_symbol = ComputePredictedSymbol(corner_table_->Vertex(next));
+        FALLTHROUGH_INTENDED;
+      case TOPOLOGY_S:
+        // Update valences.
+        vertex_valences_[corner_table_->Vertex(next).value()] -= 1;
+        vertex_valences_[corner_table_->Vertex(prev).value()] -= 1;
+        if (symbol == TOPOLOGY_S) {
+          // Whenever we reach a split symbol, mark its tip vertex as invalid by
+          // setting the valence to a negative value. Any prediction that will
+          // use this vertex will then cause a misprediction. This is currently
+          // necessary because the decoding works in the reverse direction and
+          // the decoder doesn't know about these vertices until the split
+          // symbol is decoded at which point two vertices are merged into one.
+          // This can be most likely solved on the encoder side by splitting the
+          // tip vertex into two, but since split symbols are relatively rare,
+          // it's probably not worth doing it.
+          vertex_valences_[corner_table_->Vertex(last_corner_).value()] = -1;
+          ++num_split_symbols_;
+        }
+        break;
+      case TOPOLOGY_R:
+        // Compute prediction.
+        predicted_symbol = ComputePredictedSymbol(corner_table_->Vertex(next));
+        // Update valences.
+        vertex_valences_[corner_table_->Vertex(last_corner_).value()] -= 1;
+        vertex_valences_[corner_table_->Vertex(next).value()] -= 1;
+        vertex_valences_[corner_table_->Vertex(prev).value()] -= 2;
+        break;
+      case TOPOLOGY_L:
+        vertex_valences_[corner_table_->Vertex(last_corner_).value()] -= 1;
+        vertex_valences_[corner_table_->Vertex(next).value()] -= 2;
+        vertex_valences_[corner_table_->Vertex(prev).value()] -= 1;
+        break;
+      case TOPOLOGY_E:
+        vertex_valences_[corner_table_->Vertex(last_corner_).value()] -= 2;
+        vertex_valences_[corner_table_->Vertex(next).value()] -= 2;
+        vertex_valences_[corner_table_->Vertex(prev).value()] -= 2;
+        break;
+      default:
+        break;
+    }
+    // Flag used when it's necessary to explicitly store the previous symbol.
+    bool store_prev_symbol = true;
+    if (predicted_symbol != -1) {
+      if (predicted_symbol == prev_symbol_) {
+        predictions_.push_back(true);
+        store_prev_symbol = false;
+      } else if (prev_symbol_ != -1) {
+        predictions_.push_back(false);
+      }
+    }
+    if (store_prev_symbol && prev_symbol_ != -1) {
+      MeshEdgebreakerTraversalEncoder::EncodeSymbol(
+          static_cast<EdgebreakerTopologyBitPattern>(prev_symbol_));
+    }
+    prev_symbol_ = symbol;
+  }
+
+  void Done() {
+    // We still need to store the last encoded symbol.
+    if (prev_symbol_ != -1) {
+      MeshEdgebreakerTraversalEncoder::EncodeSymbol(
+          static_cast<EdgebreakerTopologyBitPattern>(prev_symbol_));
+    }
+    // Store the init face configurations and the explicitly encoded symbols.
+    MeshEdgebreakerTraversalEncoder::Done();
+    // Encode the number of split symbols.
+    GetOutputBuffer()->Encode(num_split_symbols_);
+    // Store the predictions.
+    BinaryEncoder prediction_encoder;
+    prediction_encoder.StartEncoding();
+    for (int i = static_cast<int>(predictions_.size()) - 1; i >= 0; --i) {
+      prediction_encoder.EncodeBit(predictions_[i]);
+    }
+    prediction_encoder.EndEncoding(GetOutputBuffer());
+  }
+
+  int NumEncodedSymbols() const { return num_symbols_; }
+
+ private:
+  const CornerTable *corner_table_;
+  std::vector<int> vertex_valences_;
+  std::vector<bool> predictions_;
+  // Previously encoded symbol.
+  int32_t prev_symbol_;
+  // The total number of encoded split symbols.
+  int32_t num_split_symbols_;
+  CornerIndex last_corner_;
+  // Explicitly count the number of encoded symbols.
+  int num_symbols_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_PREDICTIVE_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h
new file mode 100644
index 000000000..c00373727
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_decoder.h
@@ -0,0 +1,215 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_DECODER_H_
+
+#include "draco/compression/entropy/symbol_decoding.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_decoder.h"
+#include "draco/core/varint_decoding.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Decoder for traversal encoded with MeshEdgebreakerTraversalValenceEncoder.
+// The decoder maintains valences of the decoded portion of the traversed mesh
+// and it uses them to select entropy context used for decoding of the actual
+// symbols.
+class MeshEdgebreakerTraversalValenceDecoder
+    : public MeshEdgebreakerTraversalDecoder {
+ public:
+  MeshEdgebreakerTraversalValenceDecoder()
+      : corner_table_(nullptr),
+        num_vertices_(0),
+        last_symbol_(-1),
+        active_context_(-1),
+        min_valence_(2),
+        max_valence_(7) {}
+  void Init(MeshEdgebreakerDecoderImplInterface *decoder) {
+    MeshEdgebreakerTraversalDecoder::Init(decoder);
+    corner_table_ = decoder->GetCornerTable();
+  }
+  void SetNumEncodedVertices(int num_vertices) { num_vertices_ = num_vertices; }
+
+  bool Start(DecoderBuffer *out_buffer) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (BitstreamVersion() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      if (!MeshEdgebreakerTraversalDecoder::DecodeTraversalSymbols()) {
+        return false;
+      }
+    }
+#endif
+    if (!MeshEdgebreakerTraversalDecoder::DecodeStartFaces()) {
+      return false;
+    }
+    if (!MeshEdgebreakerTraversalDecoder::DecodeAttributeSeams()) {
+      return false;
+    }
+    *out_buffer = *buffer();
+
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (BitstreamVersion() < DRACO_BITSTREAM_VERSION(2, 2)) {
+      uint32_t num_split_symbols;
+      if (BitstreamVersion() < DRACO_BITSTREAM_VERSION(2, 0)) {
+        if (!out_buffer->Decode(&num_split_symbols)) {
+          return false;
+        }
+      } else {
+        if (!DecodeVarint(&num_split_symbols, out_buffer)) {
+          return false;
+        }
+      }
+      if (num_split_symbols >= static_cast<uint32_t>(num_vertices_)) {
+        return false;
+      }
+
+      int8_t mode;
+      if (!out_buffer->Decode(&mode)) {
+        return false;
+      }
+      if (mode == EDGEBREAKER_VALENCE_MODE_2_7) {
+        min_valence_ = 2;
+        max_valence_ = 7;
+      } else {
+        // Unsupported mode.
+        return false;
+      }
+
+    } else
+#endif
+    {
+      min_valence_ = 2;
+      max_valence_ = 7;
+    }
+
+    if (num_vertices_ < 0) {
+      return false;
+    }
+    // Set the valences of all initial vertices to 0.
+    vertex_valences_.resize(num_vertices_, 0);
+
+    const int num_unique_valences = max_valence_ - min_valence_ + 1;
+
+    // Decode all symbols for all contexts.
+    context_symbols_.resize(num_unique_valences);
+    context_counters_.resize(context_symbols_.size());
+    for (int i = 0; i < context_symbols_.size(); ++i) {
+      uint32_t num_symbols;
+      if (!DecodeVarint<uint32_t>(&num_symbols, out_buffer)) {
+        return false;
+      }
+      if (num_symbols > static_cast<uint32_t>(corner_table_->num_faces())) {
+        return false;
+      }
+      if (num_symbols > 0) {
+        context_symbols_[i].resize(num_symbols);
+        DecodeSymbols(num_symbols, 1, out_buffer, context_symbols_[i].data());
+        // All symbols are going to be processed from the back.
+        context_counters_[i] = num_symbols;
+      }
+    }
+    return true;
+  }
+
+  inline uint32_t DecodeSymbol() {
+    // First check if we have a valid context.
+    if (active_context_ != -1) {
+      const int context_counter = --context_counters_[active_context_];
+      if (context_counter < 0) {
+        return TOPOLOGY_INVALID;
+      }
+      const int symbol_id = context_symbols_[active_context_][context_counter];
+      last_symbol_ = edge_breaker_symbol_to_topology_id[symbol_id];
+    } else {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+      if (BitstreamVersion() < DRACO_BITSTREAM_VERSION(2, 2)) {
+        // We don't have a predicted symbol or the symbol was mis-predicted.
+        // Decode it directly.
+        last_symbol_ = MeshEdgebreakerTraversalDecoder::DecodeSymbol();
+
+      } else
+#endif
+      {
+        // The first symbol must be E.
+        last_symbol_ = TOPOLOGY_E;
+      }
+    }
+    return last_symbol_;
+  }
+
+  inline void NewActiveCornerReached(CornerIndex corner) {
+    const CornerIndex next = corner_table_->Next(corner);
+    const CornerIndex prev = corner_table_->Previous(corner);
+    // Update valences.
+    switch (last_symbol_) {
+      case TOPOLOGY_C:
+      case TOPOLOGY_S:
+        vertex_valences_[corner_table_->Vertex(next)] += 1;
+        vertex_valences_[corner_table_->Vertex(prev)] += 1;
+        break;
+      case TOPOLOGY_R:
+        vertex_valences_[corner_table_->Vertex(corner)] += 1;
+        vertex_valences_[corner_table_->Vertex(next)] += 1;
+        vertex_valences_[corner_table_->Vertex(prev)] += 2;
+        break;
+      case TOPOLOGY_L:
+        vertex_valences_[corner_table_->Vertex(corner)] += 1;
+        vertex_valences_[corner_table_->Vertex(next)] += 2;
+        vertex_valences_[corner_table_->Vertex(prev)] += 1;
+        break;
+      case TOPOLOGY_E:
+        vertex_valences_[corner_table_->Vertex(corner)] += 2;
+        vertex_valences_[corner_table_->Vertex(next)] += 2;
+        vertex_valences_[corner_table_->Vertex(prev)] += 2;
+        break;
+      default:
+        break;
+    }
+    // Compute the new context that is going to be used to decode the next
+    // symbol.
+    const int active_valence = vertex_valences_[corner_table_->Vertex(next)];
+    int clamped_valence;
+    if (active_valence < min_valence_) {
+      clamped_valence = min_valence_;
+    } else if (active_valence > max_valence_) {
+      clamped_valence = max_valence_;
+    } else {
+      clamped_valence = active_valence;
+    }
+
+    active_context_ = (clamped_valence - min_valence_);
+  }
+
+  inline void MergeVertices(VertexIndex dest, VertexIndex source) {
+    // Update valences on the merged vertices.
+    vertex_valences_[dest] += vertex_valences_[source];
+  }
+
+ private:
+  const CornerTable *corner_table_;
+  int num_vertices_;
+  IndexTypeVector<VertexIndex, int> vertex_valences_;
+  int last_symbol_;
+  int active_context_;
+
+  int min_valence_;
+  int max_valence_;
+  std::vector<std::vector<uint32_t>> context_symbols_;
+  // Points to the active symbol in each context.
+  std::vector<int> context_counters_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h
new file mode 100644
index 000000000..c492c84bb
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_edgebreaker_traversal_valence_encoder.h
@@ -0,0 +1,226 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_ENCODER_H_
+
+#include "draco/compression/entropy/symbol_encoding.h"
+#include "draco/compression/mesh/mesh_edgebreaker_traversal_encoder.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+// Predictive encoder for the Edgebreaker symbols based on valences of the
+// previously encoded vertices, following the method described in: Szymczak'02,
+// "Optimized Edgebreaker Encoding for Large and Regular Triangle Meshes". Each
+// valence is used to specify a different entropy context for encoding of the
+// symbols.
+// Encoder can operate in various predefined modes that can be used to select
+// the way in which the entropy contexts are computed (e.g. using different
+// clamping for valences, or even using different inputs to compute the
+// contexts), see EdgebreakerValenceCodingMode in mesh_edgebreaker_shared.h for
+// a list of supported modes.
+class MeshEdgebreakerTraversalValenceEncoder
+    : public MeshEdgebreakerTraversalEncoder {
+ public:
+  MeshEdgebreakerTraversalValenceEncoder()
+      : corner_table_(nullptr),
+        prev_symbol_(-1),
+        last_corner_(kInvalidCornerIndex),
+        num_symbols_(0),
+        min_valence_(2),
+        max_valence_(7) {}
+
+  bool Init(MeshEdgebreakerEncoderImplInterface *encoder) {
+    if (!MeshEdgebreakerTraversalEncoder::Init(encoder)) {
+      return false;
+    }
+    min_valence_ = 2;
+    max_valence_ = 7;
+    corner_table_ = encoder->GetCornerTable();
+
+    // Initialize valences of all vertices.
+    vertex_valences_.resize(corner_table_->num_vertices());
+    for (VertexIndex i(0); i < static_cast<uint32_t>(vertex_valences_.size());
+         ++i) {
+      vertex_valences_[i] = corner_table_->Valence(VertexIndex(i));
+    }
+
+    // Replicate the corner to vertex map from the corner table. We need to do
+    // this because the map may get updated during encoding because we add new
+    // vertices when we encounter split symbols.
+    corner_to_vertex_map_.resize(corner_table_->num_corners());
+    for (CornerIndex i(0); i < corner_table_->num_corners(); ++i) {
+      corner_to_vertex_map_[i] = corner_table_->Vertex(i);
+    }
+    const int32_t num_unique_valences = max_valence_ - min_valence_ + 1;
+
+    context_symbols_.resize(num_unique_valences);
+    return true;
+  }
+
+  inline void NewCornerReached(CornerIndex corner) { last_corner_ = corner; }
+
+  inline void EncodeSymbol(EdgebreakerTopologyBitPattern symbol) {
+    ++num_symbols_;
+    // Update valences on the mesh and compute the context that is going to be
+    // used to encode the processed symbol.
+    // Note that the valences are computed for the so far unencoded part of the
+    // mesh (i.e. the decoding is reverse). Adding a new symbol either reduces
+    // valences on the vertices or leaves the valence unchanged.
+
+    const CornerIndex next = corner_table_->Next(last_corner_);
+    const CornerIndex prev = corner_table_->Previous(last_corner_);
+
+    // Get valence on the tip corner of the active edge (outgoing edge that is
+    // going to be used in reverse decoding of the connectivity to predict the
+    // next symbol).
+    const int active_valence = vertex_valences_[corner_to_vertex_map_[next]];
+    switch (symbol) {
+      case TOPOLOGY_C:
+        // Compute prediction.
+        FALLTHROUGH_INTENDED;
+      case TOPOLOGY_S:
+        // Update valences.
+        vertex_valences_[corner_to_vertex_map_[next]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 1;
+        if (symbol == TOPOLOGY_S) {
+          // Whenever we reach a split symbol, we need to split the vertex into
+          // two and attach all corners on the left and right sides of the split
+          // vertex to the respective vertices (see image below). This is
+          // necessary since the decoder works in the reverse order and it
+          // merges the two vertices only after the split symbol is processed.
+          //
+          //     * -----
+          //    / \--------
+          //   /   \--------
+          //  /     \-------
+          // *-------v-------*
+          //  \     /c\     /
+          //   \   /   \   /
+          //    \ /n S p\ /
+          //     *.......*
+          //
+
+          // Count the number of faces on the left side of the split vertex and
+          // update the valence on the "left vertex".
+          int num_left_faces = 0;
+          CornerIndex act_c = corner_table_->Opposite(prev);
+          while (act_c != kInvalidCornerIndex) {
+            if (encoder_impl()->IsFaceEncoded(corner_table_->Face(act_c))) {
+              break;  // Stop when we reach the first visited face.
+            }
+            ++num_left_faces;
+            act_c = corner_table_->Opposite(corner_table_->Next(act_c));
+          }
+          vertex_valences_[corner_to_vertex_map_[last_corner_]] =
+              num_left_faces + 1;
+
+          // Create a new vertex for the right side and count the number of
+          // faces that should be attached to this vertex.
+          const int new_vert_id = static_cast<int>(vertex_valences_.size());
+          int num_right_faces = 0;
+
+          act_c = corner_table_->Opposite(next);
+          while (act_c != kInvalidCornerIndex) {
+            if (encoder_impl()->IsFaceEncoded(corner_table_->Face(act_c))) {
+              break;  // Stop when we reach the first visited face.
+            }
+            ++num_right_faces;
+            // Map corners on the right side to the newly created vertex.
+            corner_to_vertex_map_[corner_table_->Next(act_c)] = new_vert_id;
+            act_c = corner_table_->Opposite(corner_table_->Previous(act_c));
+          }
+          vertex_valences_.push_back(num_right_faces + 1);
+        }
+        break;
+      case TOPOLOGY_R:
+        // Update valences.
+        vertex_valences_[corner_to_vertex_map_[last_corner_]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[next]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 2;
+        break;
+      case TOPOLOGY_L:
+
+        vertex_valences_[corner_to_vertex_map_[last_corner_]] -= 1;
+        vertex_valences_[corner_to_vertex_map_[next]] -= 2;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 1;
+        break;
+      case TOPOLOGY_E:
+        vertex_valences_[corner_to_vertex_map_[last_corner_]] -= 2;
+        vertex_valences_[corner_to_vertex_map_[next]] -= 2;
+        vertex_valences_[corner_to_vertex_map_[prev]] -= 2;
+        break;
+      default:
+        break;
+    }
+
+    if (prev_symbol_ != -1) {
+      int clamped_valence;
+      if (active_valence < min_valence_) {
+        clamped_valence = min_valence_;
+      } else if (active_valence > max_valence_) {
+        clamped_valence = max_valence_;
+      } else {
+        clamped_valence = active_valence;
+      }
+
+      const int context = clamped_valence - min_valence_;
+      context_symbols_[context].push_back(
+          edge_breaker_topology_to_symbol_id[prev_symbol_]);
+    }
+
+    prev_symbol_ = symbol;
+  }
+
+  void Done() {
+    // Store the init face configurations and attribute seam data
+    MeshEdgebreakerTraversalEncoder::EncodeStartFaces();
+    MeshEdgebreakerTraversalEncoder::EncodeAttributeSeams();
+
+    // Store the contexts.
+    for (int i = 0; i < context_symbols_.size(); ++i) {
+      EncodeVarint<uint32_t>(static_cast<uint32_t>(context_symbols_[i].size()),
+                             GetOutputBuffer());
+      if (context_symbols_[i].size() > 0) {
+        EncodeSymbols(context_symbols_[i].data(),
+                      static_cast<int>(context_symbols_[i].size()), 1, nullptr,
+                      GetOutputBuffer());
+      }
+    }
+  }
+
+  int NumEncodedSymbols() const { return num_symbols_; }
+
+ private:
+  const CornerTable *corner_table_;
+  // Explicit map between corners and vertices. We cannot use the one stored
+  // in the |corner_table_| because we may need to add additional vertices to
+  // handle split symbols.
+  IndexTypeVector<CornerIndex, VertexIndex> corner_to_vertex_map_;
+  IndexTypeVector<VertexIndex, int> vertex_valences_;
+  // Previously encoded symbol.
+  int32_t prev_symbol_;
+  CornerIndex last_corner_;
+  // Explicitly count the number of encoded symbols.
+  int num_symbols_;
+
+  int min_valence_;
+  int max_valence_;
+  std::vector<std::vector<uint32_t>> context_symbols_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_EDGEBREAKER_TRAVERSAL_VALENCE_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_encoder.cc b/contrib/draco/src/draco/compression/mesh/mesh_encoder.cc
new file mode 100644
index 000000000..483ea02a7
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_encoder.cc
@@ -0,0 +1,34 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_encoder.h"
+
+namespace draco {
+
+MeshEncoder::MeshEncoder() : mesh_(nullptr), num_encoded_faces_(0) {}
+
+void MeshEncoder::SetMesh(const Mesh &m) {
+  mesh_ = &m;
+  SetPointCloud(m);
+}
+
+Status MeshEncoder::EncodeGeometryData() {
+  DRACO_RETURN_IF_ERROR(EncodeConnectivity());
+  if (options()->GetGlobalBool("store_number_of_encoded_faces", false)) {
+    ComputeNumberOfEncodedFaces();
+  }
+  return OkStatus();
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_encoder.h b/contrib/draco/src/draco/compression/mesh/mesh_encoder.h
new file mode 100644
index 000000000..30ec4fa34
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_encoder.h
@@ -0,0 +1,84 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_ENCODER_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+namespace draco {
+
+// Abstract base class for all mesh encoders. It provides some basic
+// functionality that's shared between different encoders.
+class MeshEncoder : public PointCloudEncoder {
+ public:
+  MeshEncoder();
+
+  // Sets the mesh that is going be encoded. Must be called before the Encode()
+  // method.
+  void SetMesh(const Mesh &m);
+
+  EncodedGeometryType GetGeometryType() const override {
+    return TRIANGULAR_MESH;
+  }
+
+  // Returns the number of faces that were encoded during the last Encode().
+  // function call. Valid only if "store_number_of_encoded_faces" flag was set
+  // in the provided EncoderOptions.
+  size_t num_encoded_faces() const { return num_encoded_faces_; }
+
+  // Returns the base connectivity of the encoded mesh (or nullptr if it is not
+  // initialized).
+  virtual const CornerTable *GetCornerTable() const { return nullptr; }
+
+  // Returns the attribute connectivity data or nullptr if it does not exist.
+  virtual const MeshAttributeCornerTable *GetAttributeCornerTable(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  // Returns the encoding data for a given attribute or nullptr when the data
+  // does not exist.
+  virtual const MeshAttributeIndicesEncodingData *GetAttributeEncodingData(
+      int /* att_id */) const {
+    return nullptr;
+  }
+
+  const Mesh *mesh() const { return mesh_; }
+
+ protected:
+  Status EncodeGeometryData() override;
+
+  // Needs to be implemented by the derived classes.
+  virtual Status EncodeConnectivity() = 0;
+
+  // Computes and sets the num_encoded_faces_ for the encoder.
+  virtual void ComputeNumberOfEncodedFaces() = 0;
+
+  void set_mesh(const Mesh *mesh) { mesh_ = mesh; }
+  void set_num_encoded_faces(size_t num_faces) {
+    num_encoded_faces_ = num_faces;
+  }
+
+ private:
+  const Mesh *mesh_;
+  size_t num_encoded_faces_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_encoder_test.cc b/contrib/draco/src/draco/compression/mesh/mesh_encoder_test.cc
new file mode 100644
index 000000000..55f683696
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_encoder_test.cc
@@ -0,0 +1,116 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_encoder.h"
+
+#include "draco/compression/expert_encode.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/obj_decoder.h"
+
+namespace draco {
+
+struct MeshEncoderTestParams {
+  MeshEncoderTestParams(const std::string &encoding_method, int cl)
+      : encoding_method(encoding_method), cl(cl) {}
+  std::string encoding_method;
+  int cl;
+};
+
+class MeshEncoderTest : public ::testing::TestWithParam<MeshEncoderTestParams> {
+ protected:
+  MeshEncoderTest() {}
+
+  // Fills out_method with id of the encoding method used for the test.
+  // Returns false if the encoding method is not set properly.
+  bool GetMethod(MeshEncoderMethod *out_method) const {
+    if (GetParam().encoding_method == "sequential") {
+      *out_method = MESH_SEQUENTIAL_ENCODING;
+      return true;
+    }
+    if (GetParam().encoding_method == "edgebreaker") {
+      *out_method = MESH_EDGEBREAKER_ENCODING;
+      return true;
+    }
+    return false;
+  }
+
+  void TestGolden(const std::string &file_name) {
+    // This test verifies that a given set of meshes are encoded to an expected
+    // output. This is useful for catching bugs in code changes that are not
+    // supposed to change the encoding.
+    // The test is expected to fail when the encoding is modified. In such case,
+    // the golden files need to be updated to reflect the changes.
+    MeshEncoderMethod method;
+    ASSERT_TRUE(GetMethod(&method))
+        << "Test is run for an unknown encoding method";
+
+    std::string golden_file_name = file_name;
+    golden_file_name += '.';
+    golden_file_name += GetParam().encoding_method;
+    golden_file_name += ".cl";
+    golden_file_name += std::to_string(GetParam().cl);
+    golden_file_name += ".";
+    golden_file_name += std::to_string(kDracoMeshBitstreamVersionMajor);
+    golden_file_name += ".";
+    golden_file_name += std::to_string(kDracoMeshBitstreamVersionMinor);
+    golden_file_name += ".drc";
+    const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+    ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+
+    ExpertEncoder encoder(*mesh);
+    encoder.SetEncodingMethod(method);
+    encoder.SetSpeedOptions(10 - GetParam().cl, 10 - GetParam().cl);
+    encoder.SetAttributeQuantization(0, 20);
+    for (int i = 1; i < mesh->num_attributes(); ++i) {
+      encoder.SetAttributeQuantization(i, 12);
+    }
+    EncoderBuffer buffer;
+    ASSERT_TRUE(encoder.EncodeToBuffer(&buffer).ok())
+        << "Failed encoding test mesh " << file_name << " with method "
+        << GetParam().encoding_method;
+    // Check that the encoded mesh was really encoded with the selected method.
+    DecoderBuffer decoder_buffer;
+    decoder_buffer.Init(buffer.data(), buffer.size());
+    decoder_buffer.Advance(8);  // Skip the header to the encoding method id.
+    uint8_t encoded_method;
+    ASSERT_TRUE(decoder_buffer.Decode(&encoded_method));
+    ASSERT_EQ(encoded_method, method);
+    if (!FLAGS_update_golden_files) {
+      EXPECT_TRUE(
+          CompareGoldenFile(golden_file_name, buffer.data(), buffer.size()))
+          << "Encoded data is different from the golden file. Please verify "
+             "that the encoding works as expected and update the golden file "
+             "if necessary (run the test with --update_golden_files flag).";
+    } else {
+      // Save the files into the local folder.
+      EXPECT_TRUE(
+          GenerateGoldenFile(golden_file_name, buffer.data(), buffer.size()))
+          << "Failed to generate new golden file for " << file_name;
+    }
+  }
+};
+
+TEST_P(MeshEncoderTest, EncodeGoldenMeshTestNm) { TestGolden("test_nm.obj"); }
+
+TEST_P(MeshEncoderTest, EncodeGoldenMeshCubeAtt) { TestGolden("cube_att.obj"); }
+
+INSTANTIATE_TEST_SUITE_P(
+    MeshEncoderTests, MeshEncoderTest,
+    ::testing::Values(MeshEncoderTestParams("sequential", 3),
+                      MeshEncoderTestParams("edgebreaker", 4),
+                      MeshEncoderTestParams("edgebreaker", 10)));
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.cc b/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.cc
new file mode 100644
index 000000000..be349f543
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.cc
@@ -0,0 +1,169 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_sequential_decoder.h"
+
+#include "draco/compression/attributes/linear_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_decoders_controller.h"
+#include "draco/compression/entropy/symbol_decoding.h"
+#include "draco/core/varint_decoding.h"
+
+namespace draco {
+
+MeshSequentialDecoder::MeshSequentialDecoder() {}
+
+bool MeshSequentialDecoder::DecodeConnectivity() {
+  uint32_t num_faces;
+  uint32_t num_points;
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (bitstream_version() < DRACO_BITSTREAM_VERSION(2, 2)) {
+    if (!buffer()->Decode(&num_faces)) {
+      return false;
+    }
+    if (!buffer()->Decode(&num_points)) {
+      return false;
+    }
+
+  } else
+#endif
+  {
+    if (!DecodeVarint(&num_faces, buffer())) {
+      return false;
+    }
+    if (!DecodeVarint(&num_points, buffer())) {
+      return false;
+    }
+  }
+
+  // Check that num_faces and num_points are valid values.
+  const uint64_t faces_64 = static_cast<uint64_t>(num_faces);
+  const uint64_t points_64 = static_cast<uint64_t>(num_points);
+  // Compressed sequential encoding can only handle (2^32 - 1) / 3 indices.
+  if (faces_64 > 0xffffffff / 3) {
+    return false;
+  }
+  if (faces_64 > buffer()->remaining_size() / 3) {
+    // The number of faces is unreasonably high, because face indices do not
+    // fit in the remaining size of the buffer.
+    return false;
+  }
+  if (points_64 > faces_64 * 3) {
+    return false;
+  }
+  uint8_t connectivity_method;
+  if (!buffer()->Decode(&connectivity_method)) {
+    return false;
+  }
+  if (connectivity_method == 0) {
+    if (!DecodeAndDecompressIndices(num_faces)) {
+      return false;
+    }
+  } else {
+    if (num_points < 256) {
+      // Decode indices as uint8_t.
+      for (uint32_t i = 0; i < num_faces; ++i) {
+        Mesh::Face face;
+        for (int j = 0; j < 3; ++j) {
+          uint8_t val;
+          if (!buffer()->Decode(&val)) {
+            return false;
+          }
+          face[j] = val;
+        }
+        mesh()->AddFace(face);
+      }
+    } else if (num_points < (1 << 16)) {
+      // Decode indices as uint16_t.
+      for (uint32_t i = 0; i < num_faces; ++i) {
+        Mesh::Face face;
+        for (int j = 0; j < 3; ++j) {
+          uint16_t val;
+          if (!buffer()->Decode(&val)) {
+            return false;
+          }
+          face[j] = val;
+        }
+        mesh()->AddFace(face);
+      }
+    } else if (mesh()->num_points() < (1 << 21) &&
+               bitstream_version() >= DRACO_BITSTREAM_VERSION(2, 2)) {
+      // Decode indices as uint32_t.
+      for (uint32_t i = 0; i < num_faces; ++i) {
+        Mesh::Face face;
+        for (int j = 0; j < 3; ++j) {
+          uint32_t val;
+          if (!DecodeVarint(&val, buffer())) {
+            return false;
+          }
+          face[j] = val;
+        }
+        mesh()->AddFace(face);
+      }
+    } else {
+      // Decode faces as uint32_t (default).
+      for (uint32_t i = 0; i < num_faces; ++i) {
+        Mesh::Face face;
+        for (int j = 0; j < 3; ++j) {
+          uint32_t val;
+          if (!buffer()->Decode(&val)) {
+            return false;
+          }
+          face[j] = val;
+        }
+        mesh()->AddFace(face);
+      }
+    }
+  }
+  point_cloud()->set_num_points(num_points);
+  return true;
+}
+
+bool MeshSequentialDecoder::CreateAttributesDecoder(int32_t att_decoder_id) {
+  // Always create the basic attribute decoder.
+  return SetAttributesDecoder(
+      att_decoder_id,
+      std::unique_ptr<AttributesDecoder>(
+          new SequentialAttributeDecodersController(
+              std::unique_ptr<PointsSequencer>(
+                  new LinearSequencer(point_cloud()->num_points())))));
+}
+
+bool MeshSequentialDecoder::DecodeAndDecompressIndices(uint32_t num_faces) {
+  // Get decoded indices differences that were encoded with an entropy code.
+  std::vector<uint32_t> indices_buffer(num_faces * 3);
+  if (!DecodeSymbols(num_faces * 3, 1, buffer(), indices_buffer.data())) {
+    return false;
+  }
+  // Reconstruct the indices from the differences.
+  // See MeshSequentialEncoder::CompressAndEncodeIndices() for more details.
+  int32_t last_index_value = 0;
+  int vertex_index = 0;
+  for (uint32_t i = 0; i < num_faces; ++i) {
+    Mesh::Face face;
+    for (int j = 0; j < 3; ++j) {
+      const uint32_t encoded_val = indices_buffer[vertex_index++];
+      int32_t index_diff = (encoded_val >> 1);
+      if (encoded_val & 1) {
+        index_diff = -index_diff;
+      }
+      const int32_t index_value = index_diff + last_index_value;
+      face[j] = index_value;
+      last_index_value = index_value;
+    }
+    mesh()->AddFace(face);
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.h b/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.h
new file mode 100644
index 000000000..3a86c75d5
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_sequential_decoder.h
@@ -0,0 +1,39 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_DECODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_DECODER_H_
+
+#include "draco/compression/mesh/mesh_decoder.h"
+
+namespace draco {
+
+// Class for decoding data encoded by MeshSequentialEncoder.
+class MeshSequentialDecoder : public MeshDecoder {
+ public:
+  MeshSequentialDecoder();
+
+ protected:
+  bool DecodeConnectivity() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+
+ private:
+  // Decodes face indices that were compressed with an entropy code.
+  // Returns false on error.
+  bool DecodeAndDecompressIndices(uint32_t num_faces);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.cc b/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.cc
new file mode 100644
index 000000000..02ac7779e
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.cc
@@ -0,0 +1,132 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/mesh/mesh_sequential_encoder.h"
+
+#include <cstdlib>
+
+#include "draco/compression/attributes/linear_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_encoders_controller.h"
+#include "draco/compression/entropy/symbol_encoding.h"
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+MeshSequentialEncoder::MeshSequentialEncoder() {}
+
+Status MeshSequentialEncoder::EncodeConnectivity() {
+  // Serialize indices.
+  const uint32_t num_faces = mesh()->num_faces();
+  EncodeVarint(num_faces, buffer());
+  EncodeVarint(static_cast<uint32_t>(mesh()->num_points()), buffer());
+
+  // We encode all attributes in the original (possibly duplicated) format.
+  // TODO(ostava): This may not be optimal if we have only one attribute or if
+  // all attributes share the same index mapping.
+  if (options()->GetGlobalBool("compress_connectivity", false)) {
+    // 0 = Encode compressed indices.
+    buffer()->Encode(static_cast<uint8_t>(0));
+    if (!CompressAndEncodeIndices()) {
+      return Status(Status::DRACO_ERROR, "Failed to compress connectivity.");
+    }
+  } else {
+    // 1 = Encode indices directly.
+    buffer()->Encode(static_cast<uint8_t>(1));
+    // Store vertex indices using a smallest data type that fits their range.
+    // TODO(ostava): This can be potentially improved by using a tighter
+    // fit that is not bound by a bit-length of any particular data type.
+    if (mesh()->num_points() < 256) {
+      // Serialize indices as uint8_t.
+      for (FaceIndex i(0); i < num_faces; ++i) {
+        const auto &face = mesh()->face(i);
+        buffer()->Encode(static_cast<uint8_t>(face[0].value()));
+        buffer()->Encode(static_cast<uint8_t>(face[1].value()));
+        buffer()->Encode(static_cast<uint8_t>(face[2].value()));
+      }
+    } else if (mesh()->num_points() < (1 << 16)) {
+      // Serialize indices as uint16_t.
+      for (FaceIndex i(0); i < num_faces; ++i) {
+        const auto &face = mesh()->face(i);
+        buffer()->Encode(static_cast<uint16_t>(face[0].value()));
+        buffer()->Encode(static_cast<uint16_t>(face[1].value()));
+        buffer()->Encode(static_cast<uint16_t>(face[2].value()));
+      }
+    } else if (mesh()->num_points() < (1 << 21)) {
+      // Serialize indices as varint.
+      for (FaceIndex i(0); i < num_faces; ++i) {
+        const auto &face = mesh()->face(i);
+        EncodeVarint(static_cast<uint32_t>(face[0].value()), buffer());
+        EncodeVarint(static_cast<uint32_t>(face[1].value()), buffer());
+        EncodeVarint(static_cast<uint32_t>(face[2].value()), buffer());
+      }
+    } else {
+      // Serialize faces as uint32_t (default).
+      for (FaceIndex i(0); i < num_faces; ++i) {
+        const auto &face = mesh()->face(i);
+        buffer()->Encode(face);
+      }
+    }
+  }
+  return OkStatus();
+}
+
+bool MeshSequentialEncoder::GenerateAttributesEncoder(int32_t att_id) {
+  // Create only one attribute encoder that is going to encode all points in a
+  // linear sequence.
+  if (att_id == 0) {
+    // Create a new attribute encoder only for the first attribute.
+    AddAttributesEncoder(std::unique_ptr<AttributesEncoder>(
+        new SequentialAttributeEncodersController(
+            std::unique_ptr<PointsSequencer>(
+                new LinearSequencer(point_cloud()->num_points())),
+            att_id)));
+  } else {
+    // Reuse the existing attribute encoder for other attributes.
+    attributes_encoder(0)->AddAttributeId(att_id);
+  }
+  return true;
+}
+
+bool MeshSequentialEncoder::CompressAndEncodeIndices() {
+  // Collect all indices to a buffer and encode them.
+  // Each new index is a difference from the previous value.
+  std::vector<uint32_t> indices_buffer;
+  int32_t last_index_value = 0;
+  const int num_faces = mesh()->num_faces();
+  for (FaceIndex i(0); i < num_faces; ++i) {
+    const auto &face = mesh()->face(i);
+    for (int j = 0; j < 3; ++j) {
+      const int32_t index_value = face[j].value();
+      const int32_t index_diff = index_value - last_index_value;
+      // Encode signed value to an unsigned one (put the sign to lsb pos).
+      const uint32_t encoded_val =
+          (abs(index_diff) << 1) | (index_diff < 0 ? 1 : 0);
+      indices_buffer.push_back(encoded_val);
+      last_index_value = index_value;
+    }
+  }
+  EncodeSymbols(indices_buffer.data(), static_cast<int>(indices_buffer.size()),
+                1, nullptr, buffer());
+  return true;
+}
+
+void MeshSequentialEncoder::ComputeNumberOfEncodedPoints() {
+  set_num_encoded_points(mesh()->num_points());
+}
+
+void MeshSequentialEncoder::ComputeNumberOfEncodedFaces() {
+  set_num_encoded_faces(mesh()->num_faces());
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.h b/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.h
new file mode 100644
index 000000000..672609642
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/mesh_sequential_encoder.h
@@ -0,0 +1,57 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// The encoder compresses all attribute values using an order preserving
+// attribute encoder (that can still support quantization, prediction schemes,
+// and other features).
+// The mesh connectivity data can be encoded using two modes that are controlled
+// using a global encoder options flag called "compress_connectivity"
+// 1. When "compress_connectivity" == true:
+//      All point ids are first delta coded and then compressed using an entropy
+//      coding.
+// 2. When "compress_connectivity" == false:
+//      All point ids are encoded directly using either 8, 16, or 32 bits per
+//      value based on the maximum point id value.
+
+#ifndef DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_ENCODER_H_
+#define DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_ENCODER_H_
+
+#include "draco/compression/mesh/mesh_encoder.h"
+
+namespace draco {
+
+// Class that encodes mesh data using a simple binary representation of mesh's
+// connectivity and geometry.
+// TODO(ostava): Use a better name.
+class MeshSequentialEncoder : public MeshEncoder {
+ public:
+  MeshSequentialEncoder();
+  uint8_t GetEncodingMethod() const override {
+    return MESH_SEQUENTIAL_ENCODING;
+  }
+
+ protected:
+  Status EncodeConnectivity() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+  void ComputeNumberOfEncodedFaces() override;
+
+ private:
+  // Returns false on error.
+  bool CompressAndEncodeIndices();
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_MESH_SEQUENTIAL_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/traverser/depth_first_traverser.h b/contrib/draco/src/draco/compression/mesh/traverser/depth_first_traverser.h
new file mode 100644
index 000000000..0b387ec3a
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/traverser/depth_first_traverser.h
@@ -0,0 +1,172 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_DEPTH_FIRST_TRAVERSER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_DEPTH_FIRST_TRAVERSER_H_
+
+#include <vector>
+
+#include "draco/compression/mesh/traverser/traverser_base.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Basic traverser that traverses a mesh in a DFS like fashion using the
+// CornerTable data structure. The necessary bookkeeping is available via the
+// TraverserBase. Callbacks are handled through template argument
+// TraversalObserverT.
+//
+// TraversalObserverT can perform an action on a traversal event such as newly
+// visited face, or corner, but it does not affect the traversal itself.
+//
+// Concept TraversalObserverT requires:
+//
+// public:
+// void OnNewFaceVisited(FaceIndex face);
+//    - Called whenever a previously unvisited face is reached.
+//
+// void OnNewVertexVisited(VertexIndex vert, CornerIndex corner)
+//    - Called when a new vertex is visited. |corner| is used to indicate the
+//      which of the vertex's corners has been reached.
+
+template <class CornerTableT, class TraversalObserverT>
+class DepthFirstTraverser
+    : public TraverserBase<CornerTableT, TraversalObserverT> {
+ public:
+  typedef CornerTableT CornerTable;
+  typedef TraversalObserverT TraversalObserver;
+  typedef TraverserBase<CornerTable, TraversalObserver> Base;
+
+  DepthFirstTraverser() {}
+
+  // Called before any traversing starts.
+  void OnTraversalStart() {}
+
+  // Called when all the traversing is done.
+  void OnTraversalEnd() {}
+
+  bool TraverseFromCorner(CornerIndex corner_id) {
+    if (this->IsFaceVisited(corner_id)) {
+      return true;  // Already traversed.
+    }
+
+    corner_traversal_stack_.clear();
+    corner_traversal_stack_.push_back(corner_id);
+    // For the first face, check the remaining corners as they may not be
+    // processed yet.
+    const VertexIndex next_vert =
+        this->corner_table()->Vertex(this->corner_table()->Next(corner_id));
+    const VertexIndex prev_vert =
+        this->corner_table()->Vertex(this->corner_table()->Previous(corner_id));
+    if (next_vert == kInvalidVertexIndex || prev_vert == kInvalidVertexIndex) {
+      return false;
+    }
+    if (!this->IsVertexVisited(next_vert)) {
+      this->MarkVertexVisited(next_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          next_vert, this->corner_table()->Next(corner_id));
+    }
+    if (!this->IsVertexVisited(prev_vert)) {
+      this->MarkVertexVisited(prev_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          prev_vert, this->corner_table()->Previous(corner_id));
+    }
+
+    // Start the actual traversal.
+    while (!corner_traversal_stack_.empty()) {
+      // Currently processed corner.
+      corner_id = corner_traversal_stack_.back();
+      FaceIndex face_id(corner_id.value() / 3);
+      // Make sure the face hasn't been visited yet.
+      if (corner_id == kInvalidCornerIndex || this->IsFaceVisited(face_id)) {
+        // This face has been already traversed.
+        corner_traversal_stack_.pop_back();
+        continue;
+      }
+      while (true) {
+        this->MarkFaceVisited(face_id);
+        this->traversal_observer().OnNewFaceVisited(face_id);
+        const VertexIndex vert_id = this->corner_table()->Vertex(corner_id);
+        if (vert_id == kInvalidVertexIndex) {
+          return false;
+        }
+        if (!this->IsVertexVisited(vert_id)) {
+          const bool on_boundary = this->corner_table()->IsOnBoundary(vert_id);
+          this->MarkVertexVisited(vert_id);
+          this->traversal_observer().OnNewVertexVisited(vert_id, corner_id);
+          if (!on_boundary) {
+            corner_id = this->corner_table()->GetRightCorner(corner_id);
+            face_id = FaceIndex(corner_id.value() / 3);
+            continue;
+          }
+        }
+        // The current vertex has been already visited or it was on a boundary.
+        // We need to determine whether we can visit any of it's neighboring
+        // faces.
+        const CornerIndex right_corner_id =
+            this->corner_table()->GetRightCorner(corner_id);
+        const CornerIndex left_corner_id =
+            this->corner_table()->GetLeftCorner(corner_id);
+        const FaceIndex right_face_id(
+            (right_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(right_corner_id.value() / 3)));
+        const FaceIndex left_face_id(
+            (left_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(left_corner_id.value() / 3)));
+        if (this->IsFaceVisited(right_face_id)) {
+          // Right face has been already visited.
+          if (this->IsFaceVisited(left_face_id)) {
+            // Both neighboring faces are visited. End reached.
+            corner_traversal_stack_.pop_back();
+            break;  // Break from the while (true) loop.
+          } else {
+            // Go to the left face.
+            corner_id = left_corner_id;
+            face_id = left_face_id;
+          }
+        } else {
+          // Right face was not visited.
+          if (this->IsFaceVisited(left_face_id)) {
+            // Left face visited, go to the right one.
+            corner_id = right_corner_id;
+            face_id = right_face_id;
+          } else {
+            // Both neighboring faces are unvisited, we need to visit both of
+            // them.
+
+            // Split the traversal.
+            // First make the top of the current corner stack point to the left
+            // face (this one will be processed second).
+            corner_traversal_stack_.back() = left_corner_id;
+            // Add a new corner to the top of the stack (right face needs to
+            // be traversed first).
+            corner_traversal_stack_.push_back(right_corner_id);
+            // Break from the while (true) loop.
+            break;
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+ private:
+  std::vector<CornerIndex> corner_traversal_stack_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_DEPTH_FIRST_TRAVERSER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/traverser/max_prediction_degree_traverser.h b/contrib/draco/src/draco/compression/mesh/traverser/max_prediction_degree_traverser.h
new file mode 100644
index 000000000..514193eae
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/traverser/max_prediction_degree_traverser.h
@@ -0,0 +1,226 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_MAX_PREDICTION_DEGREE_TRAVERSER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_MAX_PREDICTION_DEGREE_TRAVERSER_H_
+
+#include <vector>
+
+#include "draco/compression/mesh/traverser/traverser_base.h"
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// PredictionDegreeTraverser provides framework for traversal over a corner
+// table data structure following paper "Multi-way Geometry Encoding" by
+// Cohen-or at al.'02. The traversal is implicitly guided by prediction degree
+// of the destination vertices. A prediction degree is computed as the number of
+// possible faces that can be used as source points for traversal to the given
+// destination vertex (see image below, where faces F1 and F2 are already
+// traversed and face F0 is not traversed yet. The prediction degree of vertex
+// V is then equal to two).
+//
+//            X-----V-----o
+//           / \   / \   / \
+//          / F0\ /   \ / F2\
+//         X-----o-----o-----B
+//                \ F1/
+//                 \ /
+//                  A
+//
+// The class implements the same interface as the DepthFirstTraverser
+// (depth_first_traverser.h) and it can be controlled via the same template
+// trait classes |CornerTableT| and |TraversalObserverT|, that are used
+// for controlling and monitoring of the traversal respectively. For details,
+// please see depth_first_traverser.h.
+template <class CornerTableT, class TraversalObserverT>
+class MaxPredictionDegreeTraverser
+    : public TraverserBase<CornerTable, TraversalObserverT> {
+ public:
+  typedef CornerTableT CornerTable;
+  typedef TraversalObserverT TraversalObserver;
+  typedef TraverserBase<CornerTable, TraversalObserver> Base;
+
+  MaxPredictionDegreeTraverser() {}
+
+  // Called before any traversing starts.
+  void OnTraversalStart() {
+    prediction_degree_.resize(this->corner_table()->num_vertices(), 0);
+  }
+
+  // Called when all the traversing is done.
+  void OnTraversalEnd() {}
+
+  bool TraverseFromCorner(CornerIndex corner_id) {
+    if (prediction_degree_.size() == 0) {
+      return true;
+    }
+
+    // Traversal starts from the |corner_id|. It's going to follow either the
+    // right or the left neighboring faces to |corner_id| based on their
+    // prediction degree.
+    traversal_stacks_[0].push_back(corner_id);
+    best_priority_ = 0;
+    // For the first face, check the remaining corners as they may not be
+    // processed yet.
+    const VertexIndex next_vert =
+        this->corner_table()->Vertex(this->corner_table()->Next(corner_id));
+    const VertexIndex prev_vert =
+        this->corner_table()->Vertex(this->corner_table()->Previous(corner_id));
+    if (!this->IsVertexVisited(next_vert)) {
+      this->MarkVertexVisited(next_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          next_vert, this->corner_table()->Next(corner_id));
+    }
+    if (!this->IsVertexVisited(prev_vert)) {
+      this->MarkVertexVisited(prev_vert);
+      this->traversal_observer().OnNewVertexVisited(
+          prev_vert, this->corner_table()->Previous(corner_id));
+    }
+    const VertexIndex tip_vertex = this->corner_table()->Vertex(corner_id);
+    if (!this->IsVertexVisited(tip_vertex)) {
+      this->MarkVertexVisited(tip_vertex);
+      this->traversal_observer().OnNewVertexVisited(tip_vertex, corner_id);
+    }
+    // Start the actual traversal.
+    while ((corner_id = PopNextCornerToTraverse()) != kInvalidCornerIndex) {
+      FaceIndex face_id(corner_id.value() / 3);
+      // Make sure the face hasn't been visited yet.
+      if (this->IsFaceVisited(face_id)) {
+        // This face has been already traversed.
+        continue;
+      }
+
+      while (true) {
+        face_id = FaceIndex(corner_id.value() / 3);
+        this->MarkFaceVisited(face_id);
+        this->traversal_observer().OnNewFaceVisited(face_id);
+
+        // If the newly reached vertex hasn't been visited, mark it and notify
+        // the observer.
+        const VertexIndex vert_id = this->corner_table()->Vertex(corner_id);
+        if (!this->IsVertexVisited(vert_id)) {
+          this->MarkVertexVisited(vert_id);
+          this->traversal_observer().OnNewVertexVisited(vert_id, corner_id);
+        }
+
+        // Check whether we can traverse to the right and left neighboring
+        // faces.
+        const CornerIndex right_corner_id =
+            this->corner_table()->GetRightCorner(corner_id);
+        const CornerIndex left_corner_id =
+            this->corner_table()->GetLeftCorner(corner_id);
+        const FaceIndex right_face_id(
+            (right_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(right_corner_id.value() / 3)));
+        const FaceIndex left_face_id(
+            (left_corner_id == kInvalidCornerIndex
+                 ? kInvalidFaceIndex
+                 : FaceIndex(left_corner_id.value() / 3)));
+        const bool is_right_face_visited = this->IsFaceVisited(right_face_id);
+        const bool is_left_face_visited = this->IsFaceVisited(left_face_id);
+
+        if (!is_left_face_visited) {
+          // We can go to the left face.
+          const int priority = ComputePriority(left_corner_id);
+          if (is_right_face_visited && priority <= best_priority_) {
+            // Right face has been already visited and the priority is equal or
+            // better than the best priority. We are sure that the left face
+            // would be traversed next so there is no need to put it onto the
+            // stack.
+            corner_id = left_corner_id;
+            continue;
+          } else {
+            AddCornerToTraversalStack(left_corner_id, priority);
+          }
+        }
+        if (!is_right_face_visited) {
+          // Go to the right face.
+          const int priority = ComputePriority(right_corner_id);
+          if (priority <= best_priority_) {
+            // We are sure that the right face would be traversed next so there
+            // is no need to put it onto the stack.
+            corner_id = right_corner_id;
+            continue;
+          } else {
+            AddCornerToTraversalStack(right_corner_id, priority);
+          }
+        }
+
+        // Couldn't proceed directly to the next corner
+        break;
+      }
+    }
+    return true;
+  }
+
+ private:
+  // Retrieves the next available corner (edge) to traverse. Edges are processed
+  // based on their priorities.
+  // Returns kInvalidCornerIndex when there is no edge available.
+  CornerIndex PopNextCornerToTraverse() {
+    for (int i = best_priority_; i < kMaxPriority; ++i) {
+      if (!traversal_stacks_[i].empty()) {
+        const CornerIndex ret = traversal_stacks_[i].back();
+        traversal_stacks_[i].pop_back();
+        best_priority_ = i;
+        return ret;
+      }
+    }
+    return kInvalidCornerIndex;
+  }
+
+  inline void AddCornerToTraversalStack(CornerIndex ci, int priority) {
+    traversal_stacks_[priority].push_back(ci);
+    // Make sure that the best available priority is up to date.
+    if (priority < best_priority_) {
+      best_priority_ = priority;
+    }
+  }
+
+  // Returns the priority of traversing edge leading to |corner_id|.
+  inline int ComputePriority(CornerIndex corner_id) {
+    const VertexIndex v_tip = this->corner_table()->Vertex(corner_id);
+    // Priority 0 when traversing to already visited vertices.
+    int priority = 0;
+    if (!this->IsVertexVisited(v_tip)) {
+      const int degree = ++prediction_degree_[v_tip];
+      // Priority 1 when prediction degree > 1, otherwise 2.
+      priority = (degree > 1 ? 1 : 2);
+    }
+    // Clamp the priority to the maximum number of buckets.
+    if (priority >= kMaxPriority) {
+      priority = kMaxPriority - 1;
+    }
+    return priority;
+  }
+
+  // For efficiency reasons, the priority traversal is implemented using buckets
+  // where each buckets represent a stack of available corners for a given
+  // priority. Corners with the highest priority are always processed first.
+  static constexpr int kMaxPriority = 3;
+  std::vector<CornerIndex> traversal_stacks_[kMaxPriority];
+
+  // Keep the track of the best available priority to improve the performance
+  // of PopNextCornerToTraverse() method.
+  int best_priority_;
+
+  // Prediction degree available for each vertex.
+  IndexTypeVector<VertexIndex, int> prediction_degree_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_MAX_PREDICTION_DEGREE_TRAVERSER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h b/contrib/draco/src/draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h
new file mode 100644
index 000000000..e66dd14b2
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/traverser/mesh_attribute_indices_encoding_observer.h
@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_MESH_ATTRIBUTE_INDICES_ENCODING_OBSERVER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_MESH_ATTRIBUTE_INDICES_ENCODING_OBSERVER_H_
+
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class that can be used to generate encoding (and decoding) order of attribute
+// values based on the traversal of the encoded mesh. The class should be used
+// as the TraversalObserverT member of a Traverser class such as the
+// DepthFirstTraverser (depth_first_traverser.h).
+// TODO(hemmer): rename to AttributeIndicesCodingTraverserObserver
+template <class CornerTableT>
+class MeshAttributeIndicesEncodingObserver {
+ public:
+  MeshAttributeIndicesEncodingObserver()
+      : att_connectivity_(nullptr),
+        encoding_data_(nullptr),
+        mesh_(nullptr),
+        sequencer_(nullptr) {}
+  MeshAttributeIndicesEncodingObserver(
+      const CornerTableT *connectivity, const Mesh *mesh,
+      PointsSequencer *sequencer,
+      MeshAttributeIndicesEncodingData *encoding_data)
+      : att_connectivity_(connectivity),
+        encoding_data_(encoding_data),
+        mesh_(mesh),
+        sequencer_(sequencer) {}
+
+  // Interface for TraversalObserverT
+
+  void OnNewFaceVisited(FaceIndex /* face */) {}
+
+  inline void OnNewVertexVisited(VertexIndex vertex, CornerIndex corner) {
+    const PointIndex point_id =
+        mesh_->face(FaceIndex(corner.value() / 3))[corner.value() % 3];
+    // Append the visited attribute to the encoding order.
+    sequencer_->AddPointId(point_id);
+
+    // Keep track of visited corners.
+    encoding_data_->encoded_attribute_value_index_to_corner_map.push_back(
+        corner);
+
+    encoding_data_
+        ->vertex_to_encoded_attribute_value_index_map[vertex.value()] =
+        encoding_data_->num_values;
+
+    encoding_data_->num_values++;
+  }
+
+ private:
+  const CornerTableT *att_connectivity_;
+  MeshAttributeIndicesEncodingData *encoding_data_;
+  const Mesh *mesh_;
+  PointsSequencer *sequencer_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_MESH_ATTRIBUTE_INDICES_ENCODING_OBSERVER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/traverser/mesh_traversal_sequencer.h b/contrib/draco/src/draco/compression/mesh/traverser/mesh_traversal_sequencer.h
new file mode 100644
index 000000000..ebe1d5f7a
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/traverser/mesh_traversal_sequencer.h
@@ -0,0 +1,113 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_MESH_TRAVERSAL_SEQUENCER_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_MESH_TRAVERSAL_SEQUENCER_H_
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/compression/attributes/mesh_attribute_indices_encoding_data.h"
+#include "draco/compression/attributes/points_sequencer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Sequencer that generates point sequence in an order given by a deterministic
+// traversal on the mesh surface. Note that all attributes encoded with this
+// sequence must share the same connectivity.
+// TODO(hemmer): Consider refactoring such that this is an observer.
+template <class TraverserT>
+class MeshTraversalSequencer : public PointsSequencer {
+ public:
+  MeshTraversalSequencer(const Mesh *mesh,
+                         const MeshAttributeIndicesEncodingData *encoding_data)
+      : mesh_(mesh), encoding_data_(encoding_data), corner_order_(nullptr) {}
+  void SetTraverser(const TraverserT &t) { traverser_ = t; }
+
+  // Function that can be used to set an order in which the mesh corners should
+  // be processed. This is an optional flag used usually only by the encoder
+  // to match the same corner order that is going to be used by the decoder.
+  // Note that |corner_order| should contain only one corner per face (it can
+  // have all corners but only the first encountered corner for each face is
+  // going to be used to start a traversal). If the corner order is not set, the
+  // corners are processed sequentially based on their ids.
+  void SetCornerOrder(const std::vector<CornerIndex> &corner_order) {
+    corner_order_ = &corner_order;
+  }
+
+  bool UpdatePointToAttributeIndexMapping(PointAttribute *attribute) override {
+    const auto *corner_table = traverser_.corner_table();
+    attribute->SetExplicitMapping(mesh_->num_points());
+    const size_t num_faces = mesh_->num_faces();
+    const size_t num_points = mesh_->num_points();
+    for (FaceIndex f(0); f < static_cast<uint32_t>(num_faces); ++f) {
+      const auto &face = mesh_->face(f);
+      for (int p = 0; p < 3; ++p) {
+        const PointIndex point_id = face[p];
+        const VertexIndex vert_id =
+            corner_table->Vertex(CornerIndex(3 * f.value() + p));
+        if (vert_id == kInvalidVertexIndex) {
+          return false;
+        }
+        const AttributeValueIndex att_entry_id(
+            encoding_data_
+                ->vertex_to_encoded_attribute_value_index_map[vert_id.value()]);
+        if (point_id >= num_points || att_entry_id.value() >= num_points) {
+          // There cannot be more attribute values than the number of points.
+          return false;
+        }
+        attribute->SetPointMapEntry(point_id, att_entry_id);
+      }
+    }
+    return true;
+  }
+
+ protected:
+  bool GenerateSequenceInternal() override {
+    // Preallocate memory for storing point indices. We expect the number of
+    // points to be the same as the number of corner table vertices.
+    out_point_ids()->reserve(traverser_.corner_table()->num_vertices());
+
+    traverser_.OnTraversalStart();
+    if (corner_order_) {
+      for (uint32_t i = 0; i < corner_order_->size(); ++i) {
+        if (!ProcessCorner(corner_order_->at(i))) {
+          return false;
+        }
+      }
+    } else {
+      const int32_t num_faces = traverser_.corner_table()->num_faces();
+      for (int i = 0; i < num_faces; ++i) {
+        if (!ProcessCorner(CornerIndex(3 * i))) {
+          return false;
+        }
+      }
+    }
+    traverser_.OnTraversalEnd();
+    return true;
+  }
+
+ private:
+  bool ProcessCorner(CornerIndex corner_id) {
+    return traverser_.TraverseFromCorner(corner_id);
+  }
+
+  TraverserT traverser_;
+  const Mesh *mesh_;
+  const MeshAttributeIndicesEncodingData *encoding_data_;
+  const std::vector<CornerIndex> *corner_order_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_MESH_TRAVERSAL_SEQUENCER_H_
diff --git a/contrib/draco/src/draco/compression/mesh/traverser/traverser_base.h b/contrib/draco/src/draco/compression/mesh/traverser/traverser_base.h
new file mode 100644
index 000000000..f2f8da79d
--- /dev/null
+++ b/contrib/draco/src/draco/compression/mesh/traverser/traverser_base.h
@@ -0,0 +1,87 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_
+#define DRACO_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_
+
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Class providing the basic traversal functionality needed by traversers (such
+// as the DepthFirstTraverser, see depth_first_traverser.h). It keeps a pointer
+// to the corner table that is used for the traversal, plus it provides a basic
+// bookkeeping of visited faces and vertices during the traversal.
+template <class CornerTableT, class TraversalObserverT>
+class TraverserBase {
+ public:
+  typedef CornerTableT CornerTable;
+  typedef TraversalObserverT TraversalObserver;
+
+  TraverserBase() : corner_table_(nullptr) {}
+  virtual ~TraverserBase() = default;
+
+  virtual void Init(const CornerTable *corner_table,
+                    TraversalObserver traversal_observer) {
+    corner_table_ = corner_table;
+    is_face_visited_.assign(corner_table->num_faces(), false);
+    is_vertex_visited_.assign(corner_table_->num_vertices(), false);
+    traversal_observer_ = traversal_observer;
+  }
+
+  const CornerTable &GetCornerTable() const { return *corner_table_; }
+
+  inline bool IsFaceVisited(FaceIndex face_id) const {
+    if (face_id == kInvalidFaceIndex) {
+      return true;  // Invalid faces are always considered as visited.
+    }
+    return is_face_visited_[face_id.value()];
+  }
+
+  // Returns true if the face containing the given corner was visited.
+  inline bool IsFaceVisited(CornerIndex corner_id) const {
+    if (corner_id == kInvalidCornerIndex) {
+      return true;  // Invalid faces are always considered as visited.
+    }
+    return is_face_visited_[corner_id.value() / 3];
+  }
+
+  inline void MarkFaceVisited(FaceIndex face_id) {
+    is_face_visited_[face_id.value()] = true;
+  }
+  inline bool IsVertexVisited(VertexIndex vert_id) const {
+    return is_vertex_visited_[vert_id.value()];
+  }
+  inline void MarkVertexVisited(VertexIndex vert_id) {
+    is_vertex_visited_[vert_id.value()] = true;
+  }
+
+  inline const CornerTable *corner_table() const { return corner_table_; }
+  inline const TraversalObserverT &traversal_observer() const {
+    return traversal_observer_;
+  }
+  inline TraversalObserverT &traversal_observer() {
+    return traversal_observer_;
+  }
+
+ private:
+  const CornerTable *corner_table_;
+  TraversalObserverT traversal_observer_;
+  std::vector<bool> is_face_visited_;
+  std::vector<bool> is_vertex_visited_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_MESH_TRAVERSER_TRAVERSER_BASE_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.cc b/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.cc
new file mode 100644
index 000000000..de46f05af
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.cc
@@ -0,0 +1,26 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h"
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+
+namespace draco {
+
+template class DynamicIntegerPointsKdTreeDecoder<0>;
+template class DynamicIntegerPointsKdTreeDecoder<2>;
+template class DynamicIntegerPointsKdTreeDecoder<4>;
+template class DynamicIntegerPointsKdTreeDecoder<6>;
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h b/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h
new file mode 100644
index 000000000..87bc2b7ef
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h
@@ -0,0 +1,330 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// See dynamic_integer_points_kd_tree_encoder.h for documentation.
+
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_DECODER_H_
+
+#include <array>
+#include <memory>
+#include <stack>
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_decoder.h"
+#include "draco/compression/bit_coders/direct_bit_decoder.h"
+#include "draco/compression/bit_coders/folded_integer_bit_decoder.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+template <int compression_level_t>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy
+    : public DynamicIntegerPointsKdTreeDecoderCompressionPolicy<
+          compression_level_t - 1> {};
+
+template <>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy<0> {
+  typedef DirectBitDecoder NumbersDecoder;
+  typedef DirectBitDecoder AxisDecoder;
+  typedef DirectBitDecoder HalfDecoder;
+  typedef DirectBitDecoder RemainingBitsDecoder;
+  static constexpr bool select_axis = false;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy<2>
+    : public DynamicIntegerPointsKdTreeDecoderCompressionPolicy<1> {
+  typedef RAnsBitDecoder NumbersDecoder;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy<4>
+    : public DynamicIntegerPointsKdTreeDecoderCompressionPolicy<3> {
+  typedef FoldedBit32Decoder<RAnsBitDecoder> NumbersDecoder;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeDecoderCompressionPolicy<6>
+    : public DynamicIntegerPointsKdTreeDecoderCompressionPolicy<5> {
+  static constexpr bool select_axis = true;
+};
+
+// Decodes a point cloud encoded by DynamicIntegerPointsKdTreeEncoder.
+template <int compression_level_t>
+class DynamicIntegerPointsKdTreeDecoder {
+  static_assert(compression_level_t >= 0, "Compression level must in [0..6].");
+  static_assert(compression_level_t <= 6, "Compression level must in [0..6].");
+  typedef DynamicIntegerPointsKdTreeDecoderCompressionPolicy<
+      compression_level_t>
+      Policy;
+
+  typedef typename Policy::NumbersDecoder NumbersDecoder;
+  typedef typename Policy::AxisDecoder AxisDecoder;
+  typedef typename Policy::HalfDecoder HalfDecoder;
+  typedef typename Policy::RemainingBitsDecoder RemainingBitsDecoder;
+  typedef std::vector<uint32_t> VectorUint32;
+
+ public:
+  explicit DynamicIntegerPointsKdTreeDecoder(uint32_t dimension)
+      : bit_length_(0),
+        num_points_(0),
+        num_decoded_points_(0),
+        dimension_(dimension),
+        p_(dimension, 0),
+        axes_(dimension, 0),
+        // Init the stack with the maximum depth of the tree.
+        // +1 for a second leaf.
+        base_stack_(32 * dimension + 1, VectorUint32(dimension, 0)),
+        levels_stack_(32 * dimension + 1, VectorUint32(dimension, 0)) {}
+
+  // Decodes a integer point cloud from |buffer|.
+  template <class OutputIteratorT>
+  bool DecodePoints(DecoderBuffer *buffer, OutputIteratorT &oit);
+
+#ifndef DRACO_OLD_GCC
+  template <class OutputIteratorT>
+  bool DecodePoints(DecoderBuffer *buffer, OutputIteratorT &&oit);
+#endif  // DRACO_OLD_GCC
+
+  const uint32_t dimension() const { return dimension_; }
+
+ private:
+  uint32_t GetAxis(uint32_t num_remaining_points, const VectorUint32 &levels,
+                   uint32_t last_axis);
+
+  template <class OutputIteratorT>
+  bool DecodeInternal(uint32_t num_points, OutputIteratorT &oit);
+
+  void DecodeNumber(int nbits, uint32_t *value) {
+    numbers_decoder_.DecodeLeastSignificantBits32(nbits, value);
+  }
+
+  struct DecodingStatus {
+    DecodingStatus(uint32_t num_remaining_points_, uint32_t last_axis_,
+                   uint32_t stack_pos_)
+        : num_remaining_points(num_remaining_points_),
+          last_axis(last_axis_),
+          stack_pos(stack_pos_) {}
+
+    uint32_t num_remaining_points;
+    uint32_t last_axis;
+    uint32_t stack_pos;  // used to get base and levels
+  };
+
+  uint32_t bit_length_;
+  uint32_t num_points_;
+  uint32_t num_decoded_points_;
+  uint32_t dimension_;
+  NumbersDecoder numbers_decoder_;
+  RemainingBitsDecoder remaining_bits_decoder_;
+  AxisDecoder axis_decoder_;
+  HalfDecoder half_decoder_;
+  VectorUint32 p_;
+  VectorUint32 axes_;
+  std::vector<VectorUint32> base_stack_;
+  std::vector<VectorUint32> levels_stack_;
+};
+
+// Decodes a point cloud from |buffer|.
+#ifndef DRACO_OLD_GCC
+template <int compression_level_t>
+template <class OutputIteratorT>
+bool DynamicIntegerPointsKdTreeDecoder<compression_level_t>::DecodePoints(
+    DecoderBuffer *buffer, OutputIteratorT &&oit) {
+  OutputIteratorT local = std::forward<OutputIteratorT>(oit);
+  return DecodePoints(buffer, local);
+}
+#endif  // DRACO_OLD_GCC
+
+template <int compression_level_t>
+template <class OutputIteratorT>
+bool DynamicIntegerPointsKdTreeDecoder<compression_level_t>::DecodePoints(
+    DecoderBuffer *buffer, OutputIteratorT &oit) {
+  if (!buffer->Decode(&bit_length_)) {
+    return false;
+  }
+  if (bit_length_ > 32) {
+    return false;
+  }
+  if (!buffer->Decode(&num_points_)) {
+    return false;
+  }
+  if (num_points_ == 0) {
+    return true;
+  }
+  num_decoded_points_ = 0;
+
+  if (!numbers_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!remaining_bits_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!axis_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!half_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+
+  if (!DecodeInternal(num_points_, oit)) {
+    return false;
+  }
+
+  numbers_decoder_.EndDecoding();
+  remaining_bits_decoder_.EndDecoding();
+  axis_decoder_.EndDecoding();
+  half_decoder_.EndDecoding();
+
+  return true;
+}
+
+template <int compression_level_t>
+uint32_t DynamicIntegerPointsKdTreeDecoder<compression_level_t>::GetAxis(
+    uint32_t num_remaining_points, const VectorUint32 &levels,
+    uint32_t last_axis) {
+  if (!Policy::select_axis) {
+    return DRACO_INCREMENT_MOD(last_axis, dimension_);
+  }
+
+  uint32_t best_axis = 0;
+  if (num_remaining_points < 64) {
+    for (uint32_t axis = 1; axis < dimension_; ++axis) {
+      if (levels[best_axis] > levels[axis]) {
+        best_axis = axis;
+      }
+    }
+  } else {
+    axis_decoder_.DecodeLeastSignificantBits32(4, &best_axis);
+  }
+
+  return best_axis;
+}
+
+template <int compression_level_t>
+template <class OutputIteratorT>
+bool DynamicIntegerPointsKdTreeDecoder<compression_level_t>::DecodeInternal(
+    uint32_t num_points, OutputIteratorT &oit) {
+  typedef DecodingStatus Status;
+  base_stack_[0] = VectorUint32(dimension_, 0);
+  levels_stack_[0] = VectorUint32(dimension_, 0);
+  DecodingStatus init_status(num_points, 0, 0);
+  std::stack<Status> status_stack;
+  status_stack.push(init_status);
+
+  // TODO(hemmer): use preallocated vector instead of stack.
+  while (!status_stack.empty()) {
+    const DecodingStatus status = status_stack.top();
+    status_stack.pop();
+
+    const uint32_t num_remaining_points = status.num_remaining_points;
+    const uint32_t last_axis = status.last_axis;
+    const uint32_t stack_pos = status.stack_pos;
+    const VectorUint32 &old_base = base_stack_[stack_pos];
+    const VectorUint32 &levels = levels_stack_[stack_pos];
+
+    if (num_remaining_points > num_points) {
+      return false;
+    }
+
+    const uint32_t axis = GetAxis(num_remaining_points, levels, last_axis);
+    if (axis >= dimension_) {
+      return false;
+    }
+
+    const uint32_t level = levels[axis];
+
+    // All axes have been fully subdivided, just output points.
+    if ((bit_length_ - level) == 0) {
+      for (uint32_t i = 0; i < num_remaining_points; i++) {
+        *oit = old_base;
+        ++oit;
+        ++num_decoded_points_;
+      }
+      continue;
+    }
+
+    DRACO_DCHECK_EQ(true, num_remaining_points != 0);
+
+    // Fast decoding of remaining bits if number of points is 1 or 2.
+    if (num_remaining_points <= 2) {
+      // TODO(hemmer): axes_ not necessary, remove would change bitstream!
+      axes_[0] = axis;
+      for (uint32_t i = 1; i < dimension_; i++) {
+        axes_[i] = DRACO_INCREMENT_MOD(axes_[i - 1], dimension_);
+      }
+      for (uint32_t i = 0; i < num_remaining_points; ++i) {
+        for (uint32_t j = 0; j < dimension_; j++) {
+          p_[axes_[j]] = 0;
+          const uint32_t num_remaining_bits = bit_length_ - levels[axes_[j]];
+          if (num_remaining_bits) {
+            remaining_bits_decoder_.DecodeLeastSignificantBits32(
+                num_remaining_bits, &p_[axes_[j]]);
+          }
+          p_[axes_[j]] = old_base[axes_[j]] | p_[axes_[j]];
+        }
+        *oit = p_;
+        ++oit;
+        ++num_decoded_points_;
+      }
+      continue;
+    }
+
+    if (num_decoded_points_ > num_points_) {
+      return false;
+    }
+
+    const int num_remaining_bits = bit_length_ - level;
+    const uint32_t modifier = 1 << (num_remaining_bits - 1);
+    base_stack_[stack_pos + 1] = old_base;         // copy
+    base_stack_[stack_pos + 1][axis] += modifier;  // new base
+
+    const int incoming_bits = MostSignificantBit(num_remaining_points);
+
+    uint32_t number = 0;
+    DecodeNumber(incoming_bits, &number);
+
+    uint32_t first_half = num_remaining_points / 2 - number;
+    uint32_t second_half = num_remaining_points - first_half;
+
+    if (first_half != second_half) {
+      if (!half_decoder_.DecodeNextBit()) {
+        std::swap(first_half, second_half);
+      }
+    }
+
+    levels_stack_[stack_pos][axis] += 1;
+    levels_stack_[stack_pos + 1] = levels_stack_[stack_pos];  // copy
+    if (first_half) {
+      status_stack.push(DecodingStatus(first_half, axis, stack_pos));
+    }
+    if (second_half) {
+      status_stack.push(DecodingStatus(second_half, axis, stack_pos + 1));
+    }
+  }
+  return true;
+}
+
+extern template class DynamicIntegerPointsKdTreeDecoder<0>;
+extern template class DynamicIntegerPointsKdTreeDecoder<2>;
+extern template class DynamicIntegerPointsKdTreeDecoder<4>;
+extern template class DynamicIntegerPointsKdTreeDecoder<6>;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.cc b/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.cc
new file mode 100644
index 000000000..e7abf52c4
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.cc
@@ -0,0 +1,26 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h"
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+
+namespace draco {
+
+template class DynamicIntegerPointsKdTreeEncoder<0>;
+template class DynamicIntegerPointsKdTreeEncoder<2>;
+template class DynamicIntegerPointsKdTreeEncoder<4>;
+template class DynamicIntegerPointsKdTreeEncoder<6>;
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h b/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h
new file mode 100644
index 000000000..14fa32d70
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h
@@ -0,0 +1,371 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_ENCODER_H_
+
+#include <algorithm>
+#include <array>
+#include <memory>
+#include <stack>
+#include <vector>
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_encoder.h"
+#include "draco/compression/bit_coders/direct_bit_encoder.h"
+#include "draco/compression/bit_coders/folded_integer_bit_encoder.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+// This policy class provides several configurations for the encoder that allow
+// to trade speed vs compression rate. Level 0 is fastest while 6 is the best
+// compression rate. The decoder must select the same level.
+template <int compression_level_t>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy
+    : public DynamicIntegerPointsKdTreeEncoderCompressionPolicy<
+          compression_level_t - 1> {};
+
+template <>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy<0> {
+  typedef DirectBitEncoder NumbersEncoder;
+  typedef DirectBitEncoder AxisEncoder;
+  typedef DirectBitEncoder HalfEncoder;
+  typedef DirectBitEncoder RemainingBitsEncoder;
+  static constexpr bool select_axis = false;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy<2>
+    : public DynamicIntegerPointsKdTreeEncoderCompressionPolicy<1> {
+  typedef RAnsBitEncoder NumbersEncoder;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy<4>
+    : public DynamicIntegerPointsKdTreeEncoderCompressionPolicy<3> {
+  typedef FoldedBit32Encoder<RAnsBitEncoder> NumbersEncoder;
+};
+
+template <>
+struct DynamicIntegerPointsKdTreeEncoderCompressionPolicy<6>
+    : public DynamicIntegerPointsKdTreeEncoderCompressionPolicy<5> {
+  static constexpr bool select_axis = true;
+};
+
+// This class encodes a given integer point cloud based on the point cloud
+// compression algorithm in:
+// Olivier Devillers and Pierre-Marie Gandoin
+// "Geometric compression for interactive transmission"
+//
+// In principle the algorithm keeps on splitting the point cloud in the middle
+// while alternating the axes. In 3D this results in an Octree like structure.
+// In each step we encode the number of points in the first half.
+// The algorithm does not preserve the order of points.
+//
+// However, the algorithm here differs from the original as follows:
+// The algorithm keeps on splitting the point cloud in the middle of the axis
+// that keeps the point cloud as clustered as possible, which gives a better
+// compression rate.
+// The number of points is encode by the deviation from the half of the points
+// in the smaller half of the two. This results in a better compression rate as
+// there are more leading zeros, which is then compressed better by the
+// arithmetic encoding.
+template <int compression_level_t>
+class DynamicIntegerPointsKdTreeEncoder {
+  static_assert(compression_level_t >= 0, "Compression level must in [0..6].");
+  static_assert(compression_level_t <= 6, "Compression level must in [0..6].");
+  typedef DynamicIntegerPointsKdTreeEncoderCompressionPolicy<
+      compression_level_t>
+      Policy;
+  typedef typename Policy::NumbersEncoder NumbersEncoder;
+  typedef typename Policy::AxisEncoder AxisEncoder;
+  typedef typename Policy::HalfEncoder HalfEncoder;
+  typedef typename Policy::RemainingBitsEncoder RemainingBitsEncoder;
+  typedef std::vector<uint32_t> VectorUint32;
+
+ public:
+  explicit DynamicIntegerPointsKdTreeEncoder(uint32_t dimension)
+      : bit_length_(0),
+        dimension_(dimension),
+        deviations_(dimension, 0),
+        num_remaining_bits_(dimension, 0),
+        axes_(dimension, 0),
+        base_stack_(32 * dimension + 1, VectorUint32(dimension, 0)),
+        levels_stack_(32 * dimension + 1, VectorUint32(dimension, 0)) {}
+
+  // Encodes an integer point cloud given by [begin,end) into buffer.
+  // |bit_length| gives the highest bit used for all coordinates.
+  template <class RandomAccessIteratorT>
+  bool EncodePoints(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                    const uint32_t &bit_length, EncoderBuffer *buffer);
+
+  // Encodes an integer point cloud given by [begin,end) into buffer.
+  template <class RandomAccessIteratorT>
+  bool EncodePoints(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                    EncoderBuffer *buffer) {
+    return EncodePoints(begin, end, 32, buffer);
+  }
+
+  const uint32_t dimension() const { return dimension_; }
+
+ private:
+  template <class RandomAccessIteratorT>
+  uint32_t GetAndEncodeAxis(RandomAccessIteratorT begin,
+                            RandomAccessIteratorT end,
+                            const VectorUint32 &old_base,
+                            const VectorUint32 &levels, uint32_t last_axis);
+  template <class RandomAccessIteratorT>
+  void EncodeInternal(RandomAccessIteratorT begin, RandomAccessIteratorT end);
+
+  class Splitter {
+   public:
+    Splitter(uint32_t axis, uint32_t value) : axis_(axis), value_(value) {}
+    template <class PointT>
+    bool operator()(const PointT &a) const {
+      return a[axis_] < value_;
+    }
+
+   private:
+    const uint32_t axis_;
+    const uint32_t value_;
+  };
+
+  void EncodeNumber(int nbits, uint32_t value) {
+    numbers_encoder_.EncodeLeastSignificantBits32(nbits, value);
+  }
+
+  template <class RandomAccessIteratorT>
+  struct EncodingStatus {
+    EncodingStatus(RandomAccessIteratorT begin_, RandomAccessIteratorT end_,
+                   uint32_t last_axis_, uint32_t stack_pos_)
+        : begin(begin_),
+          end(end_),
+          last_axis(last_axis_),
+          stack_pos(stack_pos_) {
+      num_remaining_points = static_cast<uint32_t>(end - begin);
+    }
+
+    RandomAccessIteratorT begin;
+    RandomAccessIteratorT end;
+    uint32_t last_axis;
+    uint32_t num_remaining_points;
+    uint32_t stack_pos;  // used to get base and levels
+  };
+
+  uint32_t bit_length_;
+  uint32_t num_points_;
+  uint32_t dimension_;
+  NumbersEncoder numbers_encoder_;
+  RemainingBitsEncoder remaining_bits_encoder_;
+  AxisEncoder axis_encoder_;
+  HalfEncoder half_encoder_;
+  VectorUint32 deviations_;
+  VectorUint32 num_remaining_bits_;
+  VectorUint32 axes_;
+  std::vector<VectorUint32> base_stack_;
+  std::vector<VectorUint32> levels_stack_;
+};
+
+template <int compression_level_t>
+template <class RandomAccessIteratorT>
+bool DynamicIntegerPointsKdTreeEncoder<compression_level_t>::EncodePoints(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end,
+    const uint32_t &bit_length, EncoderBuffer *buffer) {
+  bit_length_ = bit_length;
+  num_points_ = static_cast<uint32_t>(end - begin);
+
+  buffer->Encode(bit_length_);
+  buffer->Encode(num_points_);
+  if (num_points_ == 0) {
+    return true;
+  }
+
+  numbers_encoder_.StartEncoding();
+  remaining_bits_encoder_.StartEncoding();
+  axis_encoder_.StartEncoding();
+  half_encoder_.StartEncoding();
+
+  EncodeInternal(begin, end);
+
+  numbers_encoder_.EndEncoding(buffer);
+  remaining_bits_encoder_.EndEncoding(buffer);
+  axis_encoder_.EndEncoding(buffer);
+  half_encoder_.EndEncoding(buffer);
+
+  return true;
+}
+template <int compression_level_t>
+template <class RandomAccessIteratorT>
+uint32_t
+DynamicIntegerPointsKdTreeEncoder<compression_level_t>::GetAndEncodeAxis(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end,
+    const VectorUint32 &old_base, const VectorUint32 &levels,
+    uint32_t last_axis) {
+  if (!Policy::select_axis) {
+    return DRACO_INCREMENT_MOD(last_axis, dimension_);
+  }
+
+  // For many points this function selects the axis that should be used
+  // for the split by keeping as many points as possible bundled.
+  // In the best case we do not split the point cloud at all.
+  // For lower number of points, we simply choose the axis that is refined the
+  // least so far.
+
+  DRACO_DCHECK_EQ(true, end - begin != 0);
+
+  uint32_t best_axis = 0;
+  if (end - begin < 64) {
+    for (uint32_t axis = 1; axis < dimension_; ++axis) {
+      if (levels[best_axis] > levels[axis]) {
+        best_axis = axis;
+      }
+    }
+  } else {
+    const uint32_t size = static_cast<uint32_t>(end - begin);
+    for (uint32_t i = 0; i < dimension_; i++) {
+      deviations_[i] = 0;
+      num_remaining_bits_[i] = bit_length_ - levels[i];
+      if (num_remaining_bits_[i] > 0) {
+        const uint32_t split =
+            old_base[i] + (1 << (num_remaining_bits_[i] - 1));
+        for (auto it = begin; it != end; ++it) {
+          deviations_[i] += ((*it)[i] < split);
+        }
+        deviations_[i] = std::max(size - deviations_[i], deviations_[i]);
+      }
+    }
+
+    uint32_t max_value = 0;
+    best_axis = 0;
+    for (uint32_t i = 0; i < dimension_; i++) {
+      // If axis can be subdivided.
+      if (num_remaining_bits_[i]) {
+        // Check if this is the better axis.
+        if (max_value < deviations_[i]) {
+          max_value = deviations_[i];
+          best_axis = i;
+        }
+      }
+    }
+    axis_encoder_.EncodeLeastSignificantBits32(4, best_axis);
+  }
+
+  return best_axis;
+}
+
+template <int compression_level_t>
+template <class RandomAccessIteratorT>
+void DynamicIntegerPointsKdTreeEncoder<compression_level_t>::EncodeInternal(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end) {
+  typedef EncodingStatus<RandomAccessIteratorT> Status;
+
+  base_stack_[0] = VectorUint32(dimension_, 0);
+  levels_stack_[0] = VectorUint32(dimension_, 0);
+  Status init_status(begin, end, 0, 0);
+  std::stack<Status> status_stack;
+  status_stack.push(init_status);
+
+  // TODO(hemmer): use preallocated vector instead of stack.
+  while (!status_stack.empty()) {
+    Status status = status_stack.top();
+    status_stack.pop();
+
+    begin = status.begin;
+    end = status.end;
+    const uint32_t last_axis = status.last_axis;
+    const uint32_t stack_pos = status.stack_pos;
+    const VectorUint32 &old_base = base_stack_[stack_pos];
+    const VectorUint32 &levels = levels_stack_[stack_pos];
+
+    const uint32_t axis =
+        GetAndEncodeAxis(begin, end, old_base, levels, last_axis);
+    const uint32_t level = levels[axis];
+    const uint32_t num_remaining_points = static_cast<uint32_t>(end - begin);
+
+    // If this happens all axis are subdivided to the end.
+    if ((bit_length_ - level) == 0) {
+      continue;
+    }
+
+    // Fast encoding of remaining bits if number of points is 1 or 2.
+    // Doing this also for 2 gives a slight additional speed up.
+    if (num_remaining_points <= 2) {
+      // TODO(hemmer): axes_ not necessary, remove would change bitstream!
+      axes_[0] = axis;
+      for (uint32_t i = 1; i < dimension_; i++) {
+        axes_[i] = DRACO_INCREMENT_MOD(axes_[i - 1], dimension_);
+      }
+      for (uint32_t i = 0; i < num_remaining_points; ++i) {
+        const auto &p = *(begin + i);
+        for (uint32_t j = 0; j < dimension_; j++) {
+          const uint32_t num_remaining_bits = bit_length_ - levels[axes_[j]];
+          if (num_remaining_bits) {
+            remaining_bits_encoder_.EncodeLeastSignificantBits32(
+                num_remaining_bits, p[axes_[j]]);
+          }
+        }
+      }
+      continue;
+    }
+
+    const uint32_t num_remaining_bits = bit_length_ - level;
+    const uint32_t modifier = 1 << (num_remaining_bits - 1);
+    base_stack_[stack_pos + 1] = old_base;  // copy
+    base_stack_[stack_pos + 1][axis] += modifier;
+    const VectorUint32 &new_base = base_stack_[stack_pos + 1];
+
+    const RandomAccessIteratorT split =
+        std::partition(begin, end, Splitter(axis, new_base[axis]));
+
+    DRACO_DCHECK_EQ(true, (end - begin) > 0);
+
+    // Encode number of points in first and second half.
+    const int required_bits = MostSignificantBit(num_remaining_points);
+
+    const uint32_t first_half = static_cast<uint32_t>(split - begin);
+    const uint32_t second_half = static_cast<uint32_t>(end - split);
+    const bool left = first_half < second_half;
+
+    if (first_half != second_half) {
+      half_encoder_.EncodeBit(left);
+    }
+
+    if (left) {
+      EncodeNumber(required_bits, num_remaining_points / 2 - first_half);
+    } else {
+      EncodeNumber(required_bits, num_remaining_points / 2 - second_half);
+    }
+
+    levels_stack_[stack_pos][axis] += 1;
+    levels_stack_[stack_pos + 1] = levels_stack_[stack_pos];  // copy
+    if (split != begin) {
+      status_stack.push(Status(begin, split, axis, stack_pos));
+    }
+    if (split != end) {
+      status_stack.push(Status(split, end, axis, stack_pos + 1));
+    }
+  }
+}
+extern template class DynamicIntegerPointsKdTreeEncoder<0>;
+extern template class DynamicIntegerPointsKdTreeEncoder<2>;
+extern template class DynamicIntegerPointsKdTreeEncoder<4>;
+extern template class DynamicIntegerPointsKdTreeEncoder<6>;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_DYNAMIC_INTEGER_POINTS_KD_TREE_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.cc b/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.cc
new file mode 100644
index 000000000..dffaa4c8d
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.cc
@@ -0,0 +1,152 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/algorithms/float_points_tree_decoder.h"
+
+#include <algorithm>
+
+#include "draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_decoder.h"
+#include "draco/compression/point_cloud/algorithms/quantize_points_3.h"
+#include "draco/core/math_utils.h"
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+struct Converter {
+  typedef std::vector<uint32_t> SourceType;
+  typedef Point3ui TargetType;
+  Point3ui operator()(const std::vector<uint32_t> &v) {
+    return Point3ui(v[0], v[1], v[2]);
+  }
+};
+
+// Output iterator that is used to decode values directly into the data buffer
+// of the modified PointAttribute.
+template <class OutputIterator, class Converter>
+class ConversionOutputIterator {
+  typedef ConversionOutputIterator<OutputIterator, Converter> Self;
+  typedef typename Converter::SourceType SourceType;
+  typedef typename Converter::TargetType TargetType;
+
+ public:
+  explicit ConversionOutputIterator(OutputIterator oit) : oit_(oit) {}
+
+  const Self &operator++() {
+    ++oit_;
+    return *this;
+  }
+  Self operator++(int) {
+    Self copy = *this;
+    ++oit_;
+    return copy;
+  }
+  Self &operator*() { return *this; }
+  const Self &operator=(const SourceType &source) {
+    *oit_ = Converter()(source);
+    return *this;
+  }
+
+ private:
+  OutputIterator oit_;
+};
+
+FloatPointsTreeDecoder::FloatPointsTreeDecoder()
+    : num_points_(0), compression_level_(0), num_points_from_header_(0) {
+  qinfo_.quantization_bits = 0;
+  qinfo_.range = 0;
+}
+
+bool FloatPointsTreeDecoder::DecodePointCloudKdTreeInternal(
+    DecoderBuffer *buffer, std::vector<Point3ui> *qpoints) {
+  if (!buffer->Decode(&qinfo_.quantization_bits)) {
+    return false;
+  }
+  if (qinfo_.quantization_bits > 31) {
+    return false;
+  }
+  if (!buffer->Decode(&qinfo_.range)) {
+    return false;
+  }
+  if (!buffer->Decode(&num_points_)) {
+    return false;
+  }
+  if (num_points_from_header_ > 0 && num_points_ != num_points_from_header_) {
+    return false;
+  }
+  if (!buffer->Decode(&compression_level_)) {
+    return false;
+  }
+
+  // Only allow compression level in [0..6].
+  if (6 < compression_level_) {
+    DRACO_LOGE("FloatPointsTreeDecoder: compression level %i not supported.\n",
+               compression_level_);
+    return false;
+  }
+
+  std::back_insert_iterator<std::vector<Point3ui>> oit_qpoints =
+      std::back_inserter(*qpoints);
+  ConversionOutputIterator<std::back_insert_iterator<std::vector<Point3ui>>,
+                           Converter>
+      oit(oit_qpoints);
+  if (num_points_ > 0) {
+    qpoints->reserve(num_points_);
+    switch (compression_level_) {
+      case 0: {
+        DynamicIntegerPointsKdTreeDecoder<0> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      case 1: {
+        DynamicIntegerPointsKdTreeDecoder<1> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      case 2: {
+        DynamicIntegerPointsKdTreeDecoder<2> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      case 3: {
+        DynamicIntegerPointsKdTreeDecoder<3> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      case 4: {
+        DynamicIntegerPointsKdTreeDecoder<4> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      case 5: {
+        DynamicIntegerPointsKdTreeDecoder<5> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      case 6: {
+        DynamicIntegerPointsKdTreeDecoder<6> qpoints_decoder(3);
+        qpoints_decoder.DecodePoints(buffer, oit);
+        break;
+      }
+      default:
+        return false;
+    }
+  }
+
+  if (qpoints->size() != num_points_) {
+    return false;
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.h b/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.h
new file mode 100644
index 000000000..4f09ed2c3
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_decoder.h
@@ -0,0 +1,141 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_DECODER_H_
+
+#include <memory>
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_compression_method.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/compression/point_cloud/algorithms/quantize_points_3.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+// Decodes a point cloud encoded by PointCloudTreeEncoder.
+class FloatPointsTreeDecoder {
+ public:
+  FloatPointsTreeDecoder();
+
+  // Decodes a point cloud from |buffer|.
+  template <class OutputIteratorT>
+  bool DecodePointCloud(DecoderBuffer *buffer, OutputIteratorT &out);
+
+#ifndef DRACO_OLD_GCC
+  template <class OutputIteratorT>
+  bool DecodePointCloud(DecoderBuffer *buffer, OutputIteratorT &&out);
+#endif  // DRACO_OLD_GCC
+
+  // Initializes a DecoderBuffer from |data|, and calls function above.
+  template <class OutputIteratorT>
+  bool DecodePointCloud(const char *data, size_t data_size,
+                        OutputIteratorT out) {
+    if (data == 0 || data_size <= 0) {
+      return false;
+    }
+
+    DecoderBuffer buffer;
+    buffer.Init(data, data_size);
+    buffer.set_bitstream_version(kDracoPointCloudBitstreamVersion);
+    return DecodePointCloud(&buffer, out);
+  }
+
+  uint32_t quantization_bits() const { return qinfo_.quantization_bits; }
+  uint32_t compression_level() const { return compression_level_; }
+  float range() const { return qinfo_.range; }
+  uint32_t num_points() const { return num_points_; }
+  uint32_t version() const { return version_; }
+  std::string identification_string() const {
+    if (method_ == KDTREE) {
+      return "FloatPointsTreeDecoder: IntegerPointsKDTreeDecoder";
+    } else {
+      return "FloatPointsTreeDecoder: Unsupported Method";
+    }
+  }
+
+  void set_num_points_from_header(uint32_t num_points) {
+    num_points_from_header_ = num_points;
+  }
+
+ private:
+  bool DecodePointCloudKdTreeInternal(DecoderBuffer *buffer,
+                                      std::vector<Point3ui> *qpoints);
+
+  static const uint32_t version_ = 3;
+  QuantizationInfo qinfo_;
+  PointCloudCompressionMethod method_;
+  uint32_t num_points_;
+  uint32_t compression_level_;
+
+  // Member variable to check if the number of points from the file header
+  // matches the number of points in the compression header. If
+  // |num_points_from_header_| is 0, do not perform the check. Defaults to 0.
+  uint32_t num_points_from_header_;
+};
+
+#ifndef DRACO_OLD_GCC
+// TODO(vytyaz): Reenable once USD migrates from GCC 4.8 to a higher version
+// that can disambiguate calls to overloaded methods taking rvalue reference.
+template <class OutputIteratorT>
+bool FloatPointsTreeDecoder::DecodePointCloud(DecoderBuffer *buffer,
+                                              OutputIteratorT &&out) {
+  OutputIteratorT local = std::forward<OutputIteratorT>(out);
+  return DecodePointCloud(buffer, local);
+}
+#endif  // DRACO_OLD_GCC
+
+template <class OutputIteratorT>
+bool FloatPointsTreeDecoder::DecodePointCloud(DecoderBuffer *buffer,
+                                              OutputIteratorT &out) {
+  std::vector<Point3ui> qpoints;
+
+  uint32_t decoded_version;
+  if (!buffer->Decode(&decoded_version)) {
+    return false;
+  }
+
+  if (decoded_version == 3) {
+    int8_t method_number;
+    if (!buffer->Decode(&method_number)) {
+      return false;
+    }
+
+    method_ = static_cast<PointCloudCompressionMethod>(method_number);
+
+    if (method_ == KDTREE) {
+      if (!DecodePointCloudKdTreeInternal(buffer, &qpoints)) {
+        return false;
+      }
+    } else {  // Unsupported method.
+      fprintf(stderr, "Method not supported. \n");
+      return false;
+    }
+  } else if (decoded_version == 2) {  // Version 2 only uses KDTREE method.
+    if (!DecodePointCloudKdTreeInternal(buffer, &qpoints)) {
+      return false;
+    }
+  } else {  // Unsupported version.
+    fprintf(stderr, "Version not supported. \n");
+    return false;
+  }
+
+  DequantizePoints3(qpoints.begin(), qpoints.end(), qinfo_, out);
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.cc b/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.cc
new file mode 100644
index 000000000..317430f2b
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.cc
@@ -0,0 +1,94 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/algorithms/float_points_tree_encoder.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include "draco/compression/point_cloud/algorithms/dynamic_integer_points_kd_tree_encoder.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+const uint32_t FloatPointsTreeEncoder::version_ = 3;
+
+FloatPointsTreeEncoder::FloatPointsTreeEncoder(
+    PointCloudCompressionMethod method)
+    : method_(method), num_points_(0), compression_level_(6) {
+  qinfo_.quantization_bits = 16;
+  qinfo_.range = 0;
+}
+
+FloatPointsTreeEncoder::FloatPointsTreeEncoder(
+    PointCloudCompressionMethod method, uint32_t quantization_bits,
+    uint32_t compression_level)
+    : method_(method), num_points_(0), compression_level_(compression_level) {
+  DRACO_DCHECK_LE(compression_level_, 6);
+  qinfo_.quantization_bits = quantization_bits;
+  qinfo_.range = 0;
+}
+
+bool FloatPointsTreeEncoder::EncodePointCloudKdTreeInternal(
+    std::vector<Point3ui> *qpoints) {
+  DRACO_DCHECK_LE(compression_level_, 6);
+  switch (compression_level_) {
+    case 0: {
+      DynamicIntegerPointsKdTreeEncoder<0> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+    case 1: {
+      DynamicIntegerPointsKdTreeEncoder<1> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+    case 2: {
+      DynamicIntegerPointsKdTreeEncoder<2> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+    case 3: {
+      DynamicIntegerPointsKdTreeEncoder<3> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+    case 4: {
+      DynamicIntegerPointsKdTreeEncoder<4> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+    case 5: {
+      DynamicIntegerPointsKdTreeEncoder<5> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+    default: {
+      DynamicIntegerPointsKdTreeEncoder<6> qpoints_encoder(3);
+      qpoints_encoder.EncodePoints(qpoints->begin(), qpoints->end(),
+                                   qinfo_.quantization_bits + 1, &buffer_);
+      break;
+    }
+  }
+
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.h b/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.h
new file mode 100644
index 000000000..26ba94f1f
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/float_points_tree_encoder.h
@@ -0,0 +1,126 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_ENCODER_H_
+
+#include <memory>
+#include <vector>
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_compression_method.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/compression/point_cloud/algorithms/quantize_points_3.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// This class encodes a given point cloud based on the point cloud compression
+// algorithm in:
+// Olivier Devillers and Pierre-Marie Gandoin
+// "Geometric compression for interactive transmission"
+//
+// In principle the algorithm keeps on splitting the point cloud in the middle
+// while alternating the axes. For 3D this results in an Octree like structure.
+// In each step we encode the number of points in the first half.
+// The algorithm uses quantization and does not preserve the order of points.
+//
+// However, the algorithm here differs from the original as follows:
+// The algorithm keeps on splitting the point cloud in the middle of the axis
+// that keeps the point cloud as clustered as possible, which gives a better
+// compression rate.
+// The number of points is encode by the deviation from the half of the points
+// in the smaller half of the two. This results in a better compression rate as
+// there are more leading zeros, which is then compressed better by the
+// arithmetic encoding.
+
+// TODO(hemmer): Remove class because it duplicates quantization code.
+class FloatPointsTreeEncoder {
+ public:
+  explicit FloatPointsTreeEncoder(PointCloudCompressionMethod method);
+  explicit FloatPointsTreeEncoder(PointCloudCompressionMethod method,
+                                  uint32_t quantization_bits,
+                                  uint32_t compression_level);
+
+  template <class InputIteratorT>
+  bool EncodePointCloud(InputIteratorT points_begin, InputIteratorT points_end);
+  EncoderBuffer *buffer() { return &buffer_; }
+
+  uint32_t version() const { return version_; }
+  uint32_t quantization_bits() const { return qinfo_.quantization_bits; }
+  uint32_t &quantization_bits() { return qinfo_.quantization_bits; }
+  uint32_t compression_level() const { return compression_level_; }
+  uint32_t &compression_level() { return compression_level_; }
+  float range() const { return qinfo_.range; }
+  uint32_t num_points() const { return num_points_; }
+  std::string identification_string() const {
+    if (method_ == KDTREE) {
+      return "FloatPointsTreeEncoder: IntegerPointsKDTreeEncoder";
+    } else {
+      return "FloatPointsTreeEncoder: Unsupported Method";
+    }
+  }
+
+ private:
+  void Clear() { buffer_.Clear(); }
+  bool EncodePointCloudKdTreeInternal(std::vector<Point3ui> *qpoints);
+
+  static const uint32_t version_;
+  QuantizationInfo qinfo_;
+  PointCloudCompressionMethod method_;
+  uint32_t num_points_;
+  EncoderBuffer buffer_;
+  uint32_t compression_level_;
+};
+
+template <class InputIteratorT>
+bool FloatPointsTreeEncoder::EncodePointCloud(InputIteratorT points_begin,
+                                              InputIteratorT points_end) {
+  Clear();
+
+  // Collect necessary data for encoding.
+  num_points_ = std::distance(points_begin, points_end);
+
+  // TODO(hemmer): Extend quantization tools to make this more automatic.
+  // Compute range of points for quantization
+  std::vector<Point3ui> qpoints;
+  qpoints.reserve(num_points_);
+  QuantizePoints3(points_begin, points_end, &qinfo_,
+                  std::back_inserter(qpoints));
+
+  // Encode header.
+  buffer()->Encode(version_);
+  buffer()->Encode(static_cast<int8_t>(method_));
+  buffer()->Encode(qinfo_.quantization_bits);
+  buffer()->Encode(qinfo_.range);
+  buffer()->Encode(num_points_);
+
+  if (method_ == KDTREE) {
+    buffer()->Encode(compression_level_);
+  }
+
+  if (num_points_ == 0) {
+    return true;
+  }
+
+  if (method_ == KDTREE) {
+    return EncodePointCloudKdTreeInternal(&qpoints);
+  } else {  // Unsupported method.
+    fprintf(stderr, "Method not supported. \n");
+    return false;
+  }
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_FLOAT_POINTS_TREE_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.cc b/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.cc
new file mode 100644
index 000000000..d0428a28e
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.cc
@@ -0,0 +1,45 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.h"
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+
+namespace draco {
+
+template class IntegerPointsKdTreeDecoder<Point3ui, 0>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 1>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 2>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 3>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 4>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 5>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 6>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 7>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 8>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 9>;
+template class IntegerPointsKdTreeDecoder<Point3ui, 10>;
+
+template class IntegerPointsKdTreeDecoder<Point4ui, 0>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 1>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 2>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 3>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 4>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 5>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 6>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 7>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 8>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 9>;
+template class IntegerPointsKdTreeDecoder<Point4ui, 10>;
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.h b/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.h
new file mode 100644
index 000000000..94e523cad
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_decoder.h
@@ -0,0 +1,314 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// TODO(hemmer): Make this a wrapper using DynamicIntegerPointsKdTreeDecoder.
+//
+// See integer_points_kd_tree_encoder.h for documentation.
+
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_DECODER_H_
+
+#include <array>
+#include <memory>
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_decoder.h"
+#include "draco/compression/bit_coders/direct_bit_decoder.h"
+#include "draco/compression/bit_coders/folded_integer_bit_decoder.h"
+#include "draco/compression/bit_coders/rans_bit_decoder.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/compression/point_cloud/algorithms/queuing_policy.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+template <int compression_level_t>
+struct IntegerPointsKdTreeDecoderCompressionPolicy
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<compression_level_t -
+                                                         1> {};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<0> {
+  typedef DirectBitDecoder NumbersDecoder;
+  typedef DirectBitDecoder AxisDecoder;
+  typedef DirectBitDecoder HalfDecoder;
+  typedef DirectBitDecoder RemainingBitsDecoder;
+  static constexpr bool select_axis = false;
+
+  template <class T>
+  using QueuingStrategy = Stack<T>;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<2>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<1> {
+  typedef RAnsBitDecoder NumbersDecoder;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<4>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<3> {
+  typedef FoldedBit32Decoder<RAnsBitDecoder> NumbersDecoder;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<6>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<5> {
+  static constexpr bool select_axis = true;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<8>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<7> {
+  typedef FoldedBit32Decoder<AdaptiveRAnsBitDecoder> NumbersDecoder;
+  template <class T>
+  using QueuingStrategy = Queue<T>;
+};
+
+template <>
+struct IntegerPointsKdTreeDecoderCompressionPolicy<10>
+    : public IntegerPointsKdTreeDecoderCompressionPolicy<9> {
+  template <class T>
+  using QueuingStrategy = PriorityQueue<T>;
+};
+
+// Decodes a point cloud encoded by IntegerPointsKdTreeEncoder.
+// |PointDiT| is a type representing a point with uint32_t coordinates.
+// must provide construction from three uint32_t and operator[].
+template <class PointDiT, int compression_level_t>
+class IntegerPointsKdTreeDecoder {
+  typedef IntegerPointsKdTreeDecoderCompressionPolicy<compression_level_t>
+      Policy;
+
+  typedef typename Policy::NumbersDecoder NumbersDecoder;
+  typedef typename Policy::AxisDecoder AxisDecoder;
+  typedef typename Policy::HalfDecoder HalfDecoder;
+  typedef typename Policy::RemainingBitsDecoder RemainingBitsDecoder;
+
+ public:
+  IntegerPointsKdTreeDecoder() : bit_length_(0) {}
+
+  // Decodes a integer point cloud from |buffer|.
+  template <class OutputIteratorT>
+  bool DecodePoints(DecoderBuffer *buffer, OutputIteratorT oit);
+
+ private:
+  // For the sake of readability of code, we decided to make this exception
+  // from the naming scheme.
+  static constexpr int D = PointTraits<PointDiT>::Dimension();
+
+  uint32_t GetAxis(uint32_t num_remaining_points, const PointDiT &base,
+                   std::array<uint32_t, D> levels, uint32_t last_axis);
+
+  template <class OutputIteratorT>
+  void DecodeInternal(uint32_t num_remaining_points, PointDiT base,
+                      std::array<uint32_t, D> levels, uint32_t last_axis,
+                      OutputIteratorT oit);
+
+  void DecodeNumber(int nbits, uint32_t *value) {
+    numbers_decoder_.DecodeLeastSignificantBits32(nbits, value);
+  }
+
+  struct DecodingStatus {
+    DecodingStatus(
+        uint32_t num_remaining_points_, const PointDiT &old_base_,
+        std::array<uint32_t, PointTraits<PointDiT>::Dimension()> levels_,
+        uint32_t last_axis_)
+        : num_remaining_points(num_remaining_points_),
+          old_base(old_base_),
+          levels(levels_),
+          last_axis(last_axis_) {}
+
+    uint32_t num_remaining_points;
+    PointDiT old_base;
+    std::array<uint32_t, D> levels;
+    uint32_t last_axis;
+    friend bool operator<(const DecodingStatus &l, const DecodingStatus &r) {
+      return l.num_remaining_points < r.num_remaining_points;
+    }
+  };
+
+  uint32_t bit_length_;
+  uint32_t num_points_;
+  NumbersDecoder numbers_decoder_;
+  RemainingBitsDecoder remaining_bits_decoder_;
+  AxisDecoder axis_decoder_;
+  HalfDecoder half_decoder_;
+};
+
+// Decodes a point cloud from |buffer|.
+template <class PointDiT, int compression_level_t>
+template <class OutputIteratorT>
+bool IntegerPointsKdTreeDecoder<PointDiT, compression_level_t>::DecodePoints(
+    DecoderBuffer *buffer, OutputIteratorT oit) {
+  if (!buffer->Decode(&bit_length_)) {
+    return false;
+  }
+  if (!buffer->Decode(&num_points_)) {
+    return false;
+  }
+  if (num_points_ == 0) {
+    return true;
+  }
+
+  if (!numbers_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!remaining_bits_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!axis_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+  if (!half_decoder_.StartDecoding(buffer)) {
+    return false;
+  }
+
+  DecodeInternal(num_points_, PointTraits<PointDiT>::Origin(),
+                 PointTraits<PointDiT>::ZeroArray(), 0, oit);
+
+  numbers_decoder_.EndDecoding();
+  remaining_bits_decoder_.EndDecoding();
+  axis_decoder_.EndDecoding();
+  half_decoder_.EndDecoding();
+
+  return true;
+}
+
+template <class PointDiT, int compression_level_t>
+uint32_t IntegerPointsKdTreeDecoder<PointDiT, compression_level_t>::GetAxis(
+    uint32_t num_remaining_points, const PointDiT & /* base */,
+    std::array<uint32_t, D> levels, uint32_t last_axis) {
+  if (!Policy::select_axis) {
+    return DRACO_INCREMENT_MOD(last_axis, D);
+  }
+
+  uint32_t best_axis = 0;
+  if (num_remaining_points < 64) {
+    for (uint32_t axis = 1; axis < D; ++axis) {
+      if (levels[best_axis] > levels[axis]) {
+        best_axis = axis;
+      }
+    }
+  } else {
+    axis_decoder_.DecodeLeastSignificantBits32(4, &best_axis);
+  }
+
+  return best_axis;
+}
+
+template <class PointDiT, int compression_level_t>
+template <class OutputIteratorT>
+void IntegerPointsKdTreeDecoder<PointDiT, compression_level_t>::DecodeInternal(
+    uint32_t num_remaining_points, PointDiT old_base,
+    std::array<uint32_t, D> levels, uint32_t last_axis, OutputIteratorT oit) {
+  DecodingStatus init_status(num_remaining_points, old_base, levels, last_axis);
+  typename Policy::template QueuingStrategy<DecodingStatus> status_q;
+  status_q.push(init_status);
+
+  while (!status_q.empty()) {
+    const DecodingStatus status = status_q.front();
+    status_q.pop();
+
+    num_remaining_points = status.num_remaining_points;
+    old_base = status.old_base;
+    levels = status.levels;
+    last_axis = status.last_axis;
+
+    const uint32_t axis =
+        GetAxis(num_remaining_points, old_base, levels, last_axis);
+
+    const uint32_t level = levels[axis];
+
+    // All axes have been fully subdivided, just output points.
+    if ((bit_length_ - level) == 0) {
+      for (int i = 0; i < static_cast<int>(num_remaining_points); i++) {
+        *oit++ = old_base;
+      }
+      continue;
+    }
+
+    DRACO_DCHECK_EQ(true, num_remaining_points != 0);
+    if (num_remaining_points <= 2) {
+      std::array<uint32_t, D> axes;
+      axes[0] = axis;
+      for (int i = 1; i < D; i++) {
+        axes[i] = DRACO_INCREMENT_MOD(axes[i - 1], D);
+      }
+
+      std::array<uint32_t, D> num_remaining_bits;
+      for (int i = 0; i < D; i++) {
+        num_remaining_bits[i] = bit_length_ - levels[axes[i]];
+      }
+
+      for (uint32_t i = 0; i < num_remaining_points; ++i) {
+        // Get remaining bits, mind the carry if not starting at x.
+        PointDiT p = PointTraits<PointDiT>::Origin();
+        for (int j = 0; j < static_cast<int>(D); j++) {
+          if (num_remaining_bits[j]) {
+            remaining_bits_decoder_.DecodeLeastSignificantBits32(
+                num_remaining_bits[j], &p[axes[j]]);
+          }
+          p[axes[j]] = old_base[axes[j]] | p[axes[j]];
+        }
+        *oit++ = p;
+      }
+      continue;
+    }
+
+    const int num_remaining_bits = bit_length_ - level;
+    const uint32_t modifier = 1 << (num_remaining_bits - 1);
+    PointDiT new_base(old_base);
+    new_base[axis] += modifier;
+
+    const int incoming_bits = MostSignificantBit(num_remaining_points);
+
+    uint32_t number = 0;
+    DecodeNumber(incoming_bits, &number);
+
+    uint32_t first_half = num_remaining_points / 2 - number;
+    uint32_t second_half = num_remaining_points - first_half;
+
+    if (first_half != second_half) {
+      if (!half_decoder_.DecodeNextBit()) {
+        std::swap(first_half, second_half);
+      }
+    }
+
+    levels[axis] += 1;
+    if (first_half) {
+      status_q.push(DecodingStatus(first_half, old_base, levels, axis));
+    }
+    if (second_half) {
+      status_q.push(DecodingStatus(second_half, new_base, levels, axis));
+    }
+  }
+}
+
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 0>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 1>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 2>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 3>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 4>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 5>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 6>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 7>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 8>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 9>;
+extern template class IntegerPointsKdTreeDecoder<Point3ui, 10>;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.cc b/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.cc
new file mode 100644
index 000000000..ee1059500
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.cc
@@ -0,0 +1,45 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.h"
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+
+namespace draco {
+
+template class IntegerPointsKdTreeEncoder<Point3ui, 0>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 1>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 2>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 3>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 4>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 5>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 6>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 7>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 8>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 9>;
+template class IntegerPointsKdTreeEncoder<Point3ui, 10>;
+
+template class IntegerPointsKdTreeEncoder<Point4ui, 0>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 1>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 2>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 3>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 4>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 5>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 6>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 7>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 8>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 9>;
+template class IntegerPointsKdTreeEncoder<Point4ui, 10>;
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.h b/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.h
new file mode 100644
index 000000000..b8811092e
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/integer_points_kd_tree_encoder.h
@@ -0,0 +1,404 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// TODO(hemmer): Make this a wrapper using DynamicIntegerPointsKdTreeEncoder.
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_ENCODER_H_
+
+#include <algorithm>
+#include <array>
+#include <memory>
+#include <vector>
+
+#include "draco/compression/bit_coders/adaptive_rans_bit_encoder.h"
+#include "draco/compression/bit_coders/direct_bit_encoder.h"
+#include "draco/compression/bit_coders/folded_integer_bit_encoder.h"
+#include "draco/compression/bit_coders/rans_bit_encoder.h"
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/compression/point_cloud/algorithms/queuing_policy.h"
+#include "draco/core/bit_utils.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/math_utils.h"
+
+namespace draco {
+
+// This policy class provides several configurations for the encoder that allow
+// to trade speed vs compression rate. Level 0 is fastest while 10 is the best
+// compression rate. The decoder must select the same level.
+template <int compression_level_t>
+struct IntegerPointsKdTreeEncoderCompressionPolicy
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<compression_level_t -
+                                                         1> {};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<0> {
+  typedef DirectBitEncoder NumbersEncoder;
+  typedef DirectBitEncoder AxisEncoder;
+  typedef DirectBitEncoder HalfEncoder;
+  typedef DirectBitEncoder RemainingBitsEncoder;
+  static constexpr bool select_axis = false;
+
+  template <class T>
+  using QueuingStrategy = Stack<T>;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<2>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<1> {
+  typedef RAnsBitEncoder NumbersEncoder;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<4>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<3> {
+  typedef FoldedBit32Encoder<RAnsBitEncoder> NumbersEncoder;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<6>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<5> {
+  static constexpr bool select_axis = true;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<8>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<7> {
+  typedef FoldedBit32Encoder<AdaptiveRAnsBitEncoder> NumbersEncoder;
+  template <class T>
+  using QueuingStrategy = Queue<T>;
+};
+
+template <>
+struct IntegerPointsKdTreeEncoderCompressionPolicy<10>
+    : public IntegerPointsKdTreeEncoderCompressionPolicy<9> {
+  template <class T>
+  using QueuingStrategy = PriorityQueue<T>;
+};
+
+// This class encodes a given integer point cloud based on the point cloud
+// compression algorithm in:
+// Olivier Devillers and Pierre-Marie Gandoin
+// "Geometric compression for interactive transmission"
+//
+// In principle the algorithm keeps on splitting the point cloud in the middle
+// while alternating the axes. In 3D this results in an Octree like structure.
+// In each step we encode the number of points in the first half.
+// The algorithm does not preserve the order of points.
+//
+// However, the algorithm here differs from the original as follows:
+// The algorithm keeps on splitting the point cloud in the middle of the axis
+// that keeps the point cloud as clustered as possible, which gives a better
+// compression rate.
+// The number of points is encode by the deviation from the half of the points
+// in the smaller half of the two. This results in a better compression rate as
+// there are more leading zeros, which is then compressed better by the
+// arithmetic encoding.
+//
+// |PointDiT| is a type representing a point with uint32_t coordinates.
+// must provide construction from three uint32_t and operator[].
+template <class PointDiT, int compression_level_t>
+class IntegerPointsKdTreeEncoder {
+  typedef IntegerPointsKdTreeEncoderCompressionPolicy<compression_level_t>
+      Policy;
+  typedef typename Policy::NumbersEncoder NumbersEncoder;
+  typedef typename Policy::AxisEncoder AxisEncoder;
+  typedef typename Policy::HalfEncoder HalfEncoder;
+  typedef typename Policy::RemainingBitsEncoder RemainingBitsEncoder;
+
+ public:
+  IntegerPointsKdTreeEncoder() : bit_length_(0) {}
+
+  // Encodes an integer point cloud given by [begin,end) into buffer.
+  // |bit_length| gives the highest bit used for all coordinates.
+  template <class RandomAccessIteratorT>
+  bool EncodePoints(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                    const uint32_t &bit_length, EncoderBuffer *buffer);
+
+  // Encodes an integer point cloud given by [begin,end) into buffer.
+  template <class RandomAccessIteratorT>
+  bool EncodePoints(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                    EncoderBuffer *buffer) {
+    return EncodePoints(begin, end, 32, buffer);
+  }
+
+ private:
+  // For the sack of readability of code, we decided to make this exception
+  // from the naming scheme.
+  static constexpr int D = PointTraits<PointDiT>::Dimension();
+  template <class RandomAccessIteratorT>
+  uint32_t GetAxis(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                   const PointDiT &old_base, std::array<uint32_t, D> levels,
+                   uint32_t last_axis);
+
+  template <class RandomAccessIteratorT>
+  void EncodeInternal(RandomAccessIteratorT begin, RandomAccessIteratorT end,
+                      PointDiT old_base, std::array<uint32_t, D> levels,
+                      uint32_t last_axis);
+
+  class Splitter {
+   public:
+    Splitter(int axis, uint32_t value) : axis_(axis), value_(value) {}
+    bool operator()(const PointDiT &a) { return a[axis_] < value_; }
+
+   private:
+    int axis_;
+    uint32_t value_;
+  };
+
+  void EncodeNumber(int nbits, uint32_t value) {
+    numbers_encoder_.EncodeLeastSignificantBits32(nbits, value);
+  }
+
+  template <class RandomAccessIteratorT>
+  struct EncodingStatus {
+    EncodingStatus(
+        RandomAccessIteratorT begin_, RandomAccessIteratorT end_,
+        const PointDiT &old_base_,
+        std::array<uint32_t, PointTraits<PointDiT>::Dimension()> levels_,
+        uint32_t last_axis_)
+        : begin(begin_),
+          end(end_),
+          old_base(old_base_),
+          levels(levels_),
+          last_axis(last_axis_) {
+      num_remaining_points = end - begin;
+    }
+
+    RandomAccessIteratorT begin;
+    RandomAccessIteratorT end;
+    PointDiT old_base;
+    std::array<uint32_t, D> levels;
+    uint32_t last_axis;
+    uint32_t num_remaining_points;
+    friend bool operator<(const EncodingStatus &l, const EncodingStatus &r) {
+      return l.num_remaining_points < r.num_remaining_points;
+    }
+  };
+
+  uint32_t bit_length_;
+  uint32_t num_points_;
+  NumbersEncoder numbers_encoder_;
+  RemainingBitsEncoder remaining_bits_encoder_;
+  AxisEncoder axis_encoder_;
+  HalfEncoder half_encoder_;
+};
+
+template <class PointDiT, int compression_level_t>
+template <class RandomAccessIteratorT>
+bool IntegerPointsKdTreeEncoder<PointDiT, compression_level_t>::EncodePoints(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end,
+    const uint32_t &bit_length, EncoderBuffer *buffer) {
+  bit_length_ = bit_length;
+  num_points_ = end - begin;
+
+  buffer->Encode(bit_length_);
+  buffer->Encode(num_points_);
+  if (num_points_ == 0) {
+    return true;
+  }
+
+  numbers_encoder_.StartEncoding();
+  remaining_bits_encoder_.StartEncoding();
+  axis_encoder_.StartEncoding();
+  half_encoder_.StartEncoding();
+
+  EncodeInternal(begin, end, PointTraits<PointDiT>::Origin(),
+                 PointTraits<PointDiT>::ZeroArray(), 0);
+
+  numbers_encoder_.EndEncoding(buffer);
+  remaining_bits_encoder_.EndEncoding(buffer);
+  axis_encoder_.EndEncoding(buffer);
+  half_encoder_.EndEncoding(buffer);
+
+  return true;
+}
+template <class PointDiT, int compression_level_t>
+template <class RandomAccessIteratorT>
+uint32_t IntegerPointsKdTreeEncoder<PointDiT, compression_level_t>::GetAxis(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end,
+    const PointDiT &old_base, std::array<uint32_t, D> levels,
+    uint32_t last_axis) {
+  if (!Policy::select_axis) {
+    return DRACO_INCREMENT_MOD(last_axis, D);
+  }
+
+  // For many points this function selects the axis that should be used
+  // for the split by keeping as many points as possible bundled.
+  // In the best case we do not split the point cloud at all.
+  // For lower number of points, we simply choose the axis that is refined the
+  // least so far.
+
+  DRACO_DCHECK_EQ(true, end - begin != 0);
+
+  uint32_t best_axis = 0;
+  if (end - begin < 64) {
+    for (uint32_t axis = 1; axis < D; ++axis) {
+      if (levels[best_axis] > levels[axis]) {
+        best_axis = axis;
+      }
+    }
+  } else {
+    const uint32_t size = (end - begin);
+    std::array<uint32_t, D> num_remaining_bits =
+        PointTraits<PointDiT>::ZeroArray();
+    for (int i = 0; i < D; i++) {
+      num_remaining_bits[i] = bit_length_ - levels[i];
+    }
+    PointDiT split(old_base);
+
+    for (int i = 0; i < D; i++) {
+      if (num_remaining_bits[i]) {
+        split[i] += 1 << (num_remaining_bits[i] - 1);
+      }
+    }
+
+    std::array<uint32_t, D> deviations = PointTraits<PointDiT>::ZeroArray();
+    for (auto it = begin; it != end; ++it) {
+      for (int i = 0; i < D; i++) {
+        deviations[i] += ((*it)[i] < split[i]);
+      }
+    }
+    for (int i = 0; i < D; i++) {
+      deviations[i] = std::max(size - deviations[i], deviations[i]);
+    }
+
+    uint32_t max_value = 0;
+    best_axis = 0;
+    for (int i = 0; i < D; i++) {
+      // If axis can be subdivided.
+      if (num_remaining_bits[i]) {
+        // Check if this is the better axis.
+        if (max_value < deviations[i]) {
+          max_value = deviations[i];
+          best_axis = i;
+        }
+      }
+    }
+    axis_encoder_.EncodeLeastSignificantBits32(4, best_axis);
+  }
+
+  return best_axis;
+}
+
+template <class PointDiT, int compression_level_t>
+template <class RandomAccessIteratorT>
+void IntegerPointsKdTreeEncoder<PointDiT, compression_level_t>::EncodeInternal(
+    RandomAccessIteratorT begin, RandomAccessIteratorT end, PointDiT old_base,
+    std::array<uint32_t, D> levels, uint32_t last_axis) {
+  EncodingStatus<RandomAccessIteratorT> init_status(begin, end, old_base,
+                                                    levels, last_axis);
+  typename Policy::template QueuingStrategy<
+      EncodingStatus<RandomAccessIteratorT>>
+      status_q;
+
+  status_q.push(init_status);
+
+  while (!status_q.empty()) {
+    EncodingStatus<RandomAccessIteratorT> status = status_q.front();
+    status_q.pop();
+
+    begin = status.begin;
+    end = status.end;
+    old_base = status.old_base;
+    levels = status.levels;
+    last_axis = status.last_axis;
+
+    const uint32_t axis = GetAxis(begin, end, old_base, levels, last_axis);
+    const uint32_t level = levels[axis];
+    const uint32_t num_remaining_points = end - begin;
+
+    // If this happens all axis are subdivided to the end.
+    if ((bit_length_ - level) == 0) {
+      continue;
+    }
+
+    // Fast encoding of remaining bits if number of points is 1.
+    // Doing this also for 2 gives a slight additional speed up.
+    if (num_remaining_points <= 2) {
+      std::array<uint32_t, D> axes;
+      axes[0] = axis;
+      for (int i = 1; i < D; i++) {
+        axes[i] = DRACO_INCREMENT_MOD(axes[i - 1], D);
+      }
+
+      std::array<uint32_t, D> num_remaining_bits;
+      for (int i = 0; i < D; i++) {
+        num_remaining_bits[i] = bit_length_ - levels[axes[i]];
+      }
+
+      for (uint32_t i = 0; i < num_remaining_points; ++i) {
+        const PointDiT &p = *(begin + i);
+        for (int j = 0; j < D; j++) {
+          if (num_remaining_bits[j]) {
+            remaining_bits_encoder_.EncodeLeastSignificantBits32(
+                num_remaining_bits[j], p[axes[j]]);
+          }
+        }
+      }
+      continue;
+    }
+
+    const uint32_t num_remaining_bits = bit_length_ - level;
+    const uint32_t modifier = 1 << (num_remaining_bits - 1);
+    PointDiT new_base(old_base);
+    new_base[axis] += modifier;
+    const RandomAccessIteratorT split =
+        std::partition(begin, end, Splitter(axis, new_base[axis]));
+
+    DRACO_DCHECK_EQ(true, (end - begin) > 0);
+
+    // Encode number of points in first and second half.
+    const int required_bits = MostSignificantBit(num_remaining_points);
+
+    const uint32_t first_half = split - begin;
+    const uint32_t second_half = end - split;
+    const bool left = first_half < second_half;
+
+    if (first_half != second_half) {
+      half_encoder_.EncodeBit(left);
+    }
+
+    if (left) {
+      EncodeNumber(required_bits, num_remaining_points / 2 - first_half);
+    } else {
+      EncodeNumber(required_bits, num_remaining_points / 2 - second_half);
+    }
+
+    levels[axis] += 1;
+    if (split != begin) {
+      status_q.push(EncodingStatus<RandomAccessIteratorT>(
+          begin, split, old_base, levels, axis));
+    }
+    if (split != end) {
+      status_q.push(EncodingStatus<RandomAccessIteratorT>(split, end, new_base,
+                                                          levels, axis));
+    }
+  }
+}
+
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 0>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 1>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 2>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 3>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 4>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 5>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 6>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 7>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 8>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 9>;
+extern template class IntegerPointsKdTreeEncoder<Point3ui, 10>;
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_INTEGER_POINTS_KD_TREE_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_compression_method.h b/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_compression_method.h
new file mode 100644
index 000000000..9541c9668
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_compression_method.h
@@ -0,0 +1,34 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_COMPRESSION_METHOD_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_COMPRESSION_METHOD_H_
+
+namespace draco {
+
+// Enum indicating the used compression method, used by Encoder and Decoder.
+enum PointCloudCompressionMethod {
+  RESERVED_POINT_CLOUD_METHOD_0 = 0,  // Reserved for internal use.
+  // Generalized version of Encoding using the Octree method by Olivier
+  // Devillers to d dimensions.
+  // "Progressive lossless compression of arbitrary simplicial complexes"
+  // https://doi.org/10.1145/566570.566591
+  KDTREE = 1,
+  RESERVED_POINT_CLOUD_METHOD_2 = 2,  // Reserved for internal use.
+  RESERVED_POINT_CLOUD_METHOD_3 = 0,  // Reserved for internal use.
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_COMPRESSION_METHOD_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_types.h b/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_types.h
new file mode 100644
index 000000000..893efbefa
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/point_cloud_types.h
@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_TYPES_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_TYPES_H_
+
+#include <inttypes.h>
+
+#include <vector>
+
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Using Eigen as this is favored by project Cartographer.
+typedef Vector3f Point3f;
+typedef Vector4f Point4f;
+typedef Vector3ui Point3ui;
+typedef Vector4ui Point4ui;
+typedef Vector5ui Point5ui;
+typedef Vector6ui Point6ui;
+typedef Vector7ui Point7ui;
+
+typedef std::vector<Point3f> PointCloud3f;
+
+template <class PointDT>
+struct PointDLess;
+
+template <class CoeffT, int dimension_t>
+struct PointDLess<VectorD<CoeffT, dimension_t>> {
+  bool operator()(const VectorD<CoeffT, dimension_t> &a,
+                  const VectorD<CoeffT, dimension_t> &b) const {
+    return a < b;
+  }
+};
+
+template <class PointDT>
+class PointTraits {};
+
+template <class CoordinateTypeT, int dimension_t>
+class PointTraits<VectorD<CoordinateTypeT, dimension_t>> {
+ public:
+  typedef VectorD<CoordinateTypeT, dimension_t> PointD;
+  typedef CoordinateTypeT CoordinateType;
+
+  static constexpr uint32_t Dimension() { return dimension_t; }
+  static PointD Origin() {
+    PointD origin;
+    for (uint32_t i = 0; i < dimension_t; i++) {
+      origin(i) = 0;
+    }
+    return origin;
+  }
+  static std::array<uint32_t, dimension_t> ZeroArray() {
+    std::array<uint32_t, dimension_t> zero;
+    for (uint32_t i = 0; i < dimension_t; i++) {
+      zero[i] = 0;
+    }
+    return zero;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_POINT_CLOUD_TYPES_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/quantize_points_3.h b/contrib/draco/src/draco/compression/point_cloud/algorithms/quantize_points_3.h
new file mode 100644
index 000000000..01943ad9e
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/quantize_points_3.h
@@ -0,0 +1,84 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUANTIZE_POINTS_3_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUANTIZE_POINTS_3_H_
+
+#include <inttypes.h>
+
+#include "draco/compression/point_cloud/algorithms/point_cloud_types.h"
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+// TODO(hemmer): Make this a stable bounding box.
+struct QuantizationInfo {
+  uint32_t quantization_bits;
+  float range;
+};
+
+template <class PointIterator, class OutputIterator>
+OutputIterator QuantizePoints3(const PointIterator &begin,
+                               const PointIterator &end, QuantizationInfo *info,
+                               OutputIterator oit) {
+  DRACO_DCHECK_GE(info->quantization_bits, 0);
+
+  float max_range = 0;
+  for (auto it = begin; it != end; ++it) {
+    max_range = std::max(std::fabs((*it)[0]), max_range);
+    max_range = std::max(std::fabs((*it)[1]), max_range);
+    max_range = std::max(std::fabs((*it)[2]), max_range);
+  }
+
+  const uint32_t max_quantized_value((1 << info->quantization_bits) - 1);
+  Quantizer quantize;
+  quantize.Init(max_range, max_quantized_value);
+  info->range = max_range;
+
+  Point3ui qpoint;
+  for (auto it = begin; it != end; ++it) {
+    // Quantize and all positive.
+    qpoint[0] = quantize((*it)[0]) + max_quantized_value;
+    qpoint[1] = quantize((*it)[1]) + max_quantized_value;
+    qpoint[2] = quantize((*it)[2]) + max_quantized_value;
+    *oit++ = (qpoint);
+  }
+
+  return oit;
+}
+
+template <class QPointIterator, class OutputIterator>
+void DequantizePoints3(const QPointIterator &begin, const QPointIterator &end,
+                       const QuantizationInfo &info, OutputIterator &oit) {
+  DRACO_DCHECK_GE(info.quantization_bits, 0);
+  DRACO_DCHECK_GE(info.range, 0);
+
+  const uint32_t quantization_bits = info.quantization_bits;
+  const float range = info.range;
+  const uint32_t max_quantized_value((1 << quantization_bits) - 1);
+  Dequantizer dequantize;
+  dequantize.Init(range, max_quantized_value);
+
+  for (auto it = begin; it != end; ++it) {
+    const float x = dequantize((*it)[0] - max_quantized_value);
+    const float y = dequantize((*it)[1] - max_quantized_value);
+    const float z = dequantize((*it)[2] - max_quantized_value);
+    *oit = Point3f(x, y, z);
+    ++oit;
+  }
+}
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUANTIZE_POINTS_3_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/algorithms/queuing_policy.h b/contrib/draco/src/draco/compression/point_cloud/algorithms/queuing_policy.h
new file mode 100644
index 000000000..2db0ea213
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/algorithms/queuing_policy.h
@@ -0,0 +1,75 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File defining a coherent interface for different queuing strategies.
+
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUEUING_POLICY_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUEUING_POLICY_H_
+
+#include <queue>
+#include <stack>
+#include <utility>
+
+namespace draco {
+
+template <class T>
+class Queue {
+ public:
+  bool empty() const { return q_.empty(); }
+  typename std::queue<T>::size_type size() const { return q_.size(); }
+  void clear() { return q_.clear(); }
+  void push(const T &value) { q_.push(value); }
+  void push(T &&value) { q_.push(std::move(value)); }
+  void pop() { q_.pop(); }
+  typename std::queue<T>::const_reference front() const { return q_.front(); }
+
+ private:
+  std::queue<T> q_;
+};
+
+template <class T>
+class Stack {
+ public:
+  bool empty() const { return s_.empty(); }
+  typename std::stack<T>::size_type size() const { return s_.size(); }
+  void clear() { return s_.clear(); }
+  void push(const T &value) { s_.push(value); }
+  void push(T &&value) { s_.push(std::move(value)); }
+  void pop() { s_.pop(); }
+  typename std::stack<T>::const_reference front() const { return s_.top(); }
+
+ private:
+  std::stack<T> s_;
+};
+
+template <class T, class Compare = std::less<T> >
+class PriorityQueue {
+  typedef std::priority_queue<T, std::vector<T>, Compare> QType;
+
+ public:
+  bool empty() const { return s_.empty(); }
+  typename QType::size_type size() const { return s_.size(); }
+  void clear() { return s_.clear(); }
+  void push(const T &value) { s_.push(value); }
+  void push(T &&value) { s_.push(std::move(value)); }
+  void pop() { s_.pop(); }
+  typename QType::const_reference front() const { return s_.top(); }
+
+ private:
+  QType s_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_ALGORITHMS_QUEUING_POLICY_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.cc b/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.cc
new file mode 100644
index 000000000..85f7bc94e
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.cc
@@ -0,0 +1,199 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+
+#include "draco/metadata/metadata_decoder.h"
+
+namespace draco {
+
+PointCloudDecoder::PointCloudDecoder()
+    : point_cloud_(nullptr),
+      buffer_(nullptr),
+      version_major_(0),
+      version_minor_(0),
+      options_(nullptr) {}
+
+Status PointCloudDecoder::DecodeHeader(DecoderBuffer *buffer,
+                                       DracoHeader *out_header) {
+  constexpr char kIoErrorMsg[] = "Failed to parse Draco header.";
+  if (!buffer->Decode(out_header->draco_string, 5)) {
+    return Status(Status::IO_ERROR, kIoErrorMsg);
+  }
+  if (memcmp(out_header->draco_string, "DRACO", 5) != 0) {
+    return Status(Status::DRACO_ERROR, "Not a Draco file.");
+  }
+  if (!buffer->Decode(&(out_header->version_major))) {
+    return Status(Status::IO_ERROR, kIoErrorMsg);
+  }
+  if (!buffer->Decode(&(out_header->version_minor))) {
+    return Status(Status::IO_ERROR, kIoErrorMsg);
+  }
+  if (!buffer->Decode(&(out_header->encoder_type))) {
+    return Status(Status::IO_ERROR, kIoErrorMsg);
+  }
+  if (!buffer->Decode(&(out_header->encoder_method))) {
+    return Status(Status::IO_ERROR, kIoErrorMsg);
+  }
+  if (!buffer->Decode(&(out_header->flags))) {
+    return Status(Status::IO_ERROR, kIoErrorMsg);
+  }
+  return OkStatus();
+}
+
+Status PointCloudDecoder::DecodeMetadata() {
+  std::unique_ptr<GeometryMetadata> metadata =
+      std::unique_ptr<GeometryMetadata>(new GeometryMetadata());
+  MetadataDecoder metadata_decoder;
+  if (!metadata_decoder.DecodeGeometryMetadata(buffer_, metadata.get())) {
+    return Status(Status::DRACO_ERROR, "Failed to decode metadata.");
+  }
+  point_cloud_->AddMetadata(std::move(metadata));
+  return OkStatus();
+}
+
+Status PointCloudDecoder::Decode(const DecoderOptions &options,
+                                 DecoderBuffer *in_buffer,
+                                 PointCloud *out_point_cloud) {
+  options_ = &options;
+  buffer_ = in_buffer;
+  point_cloud_ = out_point_cloud;
+  DracoHeader header;
+  DRACO_RETURN_IF_ERROR(DecodeHeader(buffer_, &header))
+  // Sanity check that we are really using the right decoder (mostly for cases
+  // where the Decode method was called manually outside of our main API.
+  if (header.encoder_type != GetGeometryType()) {
+    return Status(Status::DRACO_ERROR,
+                  "Using incompatible decoder for the input geometry.");
+  }
+  // TODO(ostava): We should check the method as well, but currently decoders
+  // don't expose the decoding method id.
+  version_major_ = header.version_major;
+  version_minor_ = header.version_minor;
+
+  const uint8_t max_supported_major_version =
+      header.encoder_type == POINT_CLOUD ? kDracoPointCloudBitstreamVersionMajor
+                                         : kDracoMeshBitstreamVersionMajor;
+  const uint8_t max_supported_minor_version =
+      header.encoder_type == POINT_CLOUD ? kDracoPointCloudBitstreamVersionMinor
+                                         : kDracoMeshBitstreamVersionMinor;
+
+  // Check for version compatibility.
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+  if (version_major_ < 1 || version_major_ > max_supported_major_version) {
+    return Status(Status::UNKNOWN_VERSION, "Unknown major version.");
+  }
+  if (version_major_ == max_supported_major_version &&
+      version_minor_ > max_supported_minor_version) {
+    return Status(Status::UNKNOWN_VERSION, "Unknown minor version.");
+  }
+#else
+  if (version_major_ != max_supported_major_version) {
+    return Status(Status::UNKNOWN_VERSION, "Unsupported major version.");
+  }
+  if (version_minor_ != max_supported_minor_version) {
+    return Status(Status::UNKNOWN_VERSION, "Unsupported minor version.");
+  }
+#endif
+  buffer_->set_bitstream_version(
+      DRACO_BITSTREAM_VERSION(version_major_, version_minor_));
+
+  if (bitstream_version() >= DRACO_BITSTREAM_VERSION(1, 3) &&
+      (header.flags & METADATA_FLAG_MASK)) {
+    DRACO_RETURN_IF_ERROR(DecodeMetadata())
+  }
+  if (!InitializeDecoder()) {
+    return Status(Status::DRACO_ERROR, "Failed to initialize the decoder.");
+  }
+  if (!DecodeGeometryData()) {
+    return Status(Status::DRACO_ERROR, "Failed to decode geometry data.");
+  }
+  if (!DecodePointAttributes()) {
+    return Status(Status::DRACO_ERROR, "Failed to decode point attributes.");
+  }
+  return OkStatus();
+}
+
+bool PointCloudDecoder::DecodePointAttributes() {
+  uint8_t num_attributes_decoders;
+  if (!buffer_->Decode(&num_attributes_decoders)) {
+    return false;
+  }
+  // Create all attribute decoders. This is implementation specific and the
+  // derived classes can use any data encoded in the
+  // PointCloudEncoder::EncodeAttributesEncoderIdentifier() call.
+  for (int i = 0; i < num_attributes_decoders; ++i) {
+    if (!CreateAttributesDecoder(i)) {
+      return false;
+    }
+  }
+
+  // Initialize all attributes decoders. No data is decoded here.
+  for (auto &att_dec : attributes_decoders_) {
+    if (!att_dec->Init(this, point_cloud_)) {
+      return false;
+    }
+  }
+
+  // Decode any data needed by the attribute decoders.
+  for (int i = 0; i < num_attributes_decoders; ++i) {
+    if (!attributes_decoders_[i]->DecodeAttributesDecoderData(buffer_)) {
+      return false;
+    }
+  }
+
+  // Create map between attribute and decoder ids.
+  for (int i = 0; i < num_attributes_decoders; ++i) {
+    const int32_t num_attributes = attributes_decoders_[i]->GetNumAttributes();
+    for (int j = 0; j < num_attributes; ++j) {
+      int att_id = attributes_decoders_[i]->GetAttributeId(j);
+      if (att_id >= attribute_to_decoder_map_.size()) {
+        attribute_to_decoder_map_.resize(att_id + 1);
+      }
+      attribute_to_decoder_map_[att_id] = i;
+    }
+  }
+
+  // Decode the actual attributes using the created attribute decoders.
+  if (!DecodeAllAttributes()) {
+    return false;
+  }
+
+  if (!OnAttributesDecoded()) {
+    return false;
+  }
+  return true;
+}
+
+bool PointCloudDecoder::DecodeAllAttributes() {
+  for (auto &att_dec : attributes_decoders_) {
+    if (!att_dec->DecodeAttributes(buffer_)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+const PointAttribute *PointCloudDecoder::GetPortableAttribute(
+    int32_t parent_att_id) {
+  if (parent_att_id < 0 || parent_att_id >= point_cloud_->num_attributes()) {
+    return nullptr;
+  }
+  const int32_t parent_att_decoder_id =
+      attribute_to_decoder_map_[parent_att_id];
+  return attributes_decoders_[parent_att_decoder_id]->GetPortableAttribute(
+      parent_att_id);
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.h b/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.h
new file mode 100644
index 000000000..4af7f5cd3
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_decoder.h
@@ -0,0 +1,118 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_DECODER_H_
+
+#include "draco/compression/attributes/attributes_decoder_interface.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/decoder_options.h"
+#include "draco/core/status.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Abstract base class for all point cloud and mesh decoders. It provides a
+// basic functionality that is shared between different decoders.
+class PointCloudDecoder {
+ public:
+  PointCloudDecoder();
+  virtual ~PointCloudDecoder() = default;
+
+  virtual EncodedGeometryType GetGeometryType() const { return POINT_CLOUD; }
+
+  // Decodes a Draco header int other provided |out_header|.
+  // Returns false on error.
+  static Status DecodeHeader(DecoderBuffer *buffer, DracoHeader *out_header);
+
+  // The main entry point for point cloud decoding.
+  Status Decode(const DecoderOptions &options, DecoderBuffer *in_buffer,
+                PointCloud *out_point_cloud);
+
+  bool SetAttributesDecoder(
+      int att_decoder_id, std::unique_ptr<AttributesDecoderInterface> decoder) {
+    if (att_decoder_id < 0) {
+      return false;
+    }
+    if (att_decoder_id >= static_cast<int>(attributes_decoders_.size())) {
+      attributes_decoders_.resize(att_decoder_id + 1);
+    }
+    attributes_decoders_[att_decoder_id] = std::move(decoder);
+    return true;
+  }
+
+  // Returns an attribute containing decoded data in their portable form that
+  // is guaranteed to be the same for both encoder and decoder. I.e., it returns
+  // an attribute before it was transformed back into its final form which may
+  // be slightly different (non-portable) across platforms. For example, for
+  // attributes encoded with quantization, this method returns an attribute
+  // that contains the quantized values (before the dequantization step).
+  const PointAttribute *GetPortableAttribute(int32_t point_attribute_id);
+
+  uint16_t bitstream_version() const {
+    return DRACO_BITSTREAM_VERSION(version_major_, version_minor_);
+  }
+
+  const AttributesDecoderInterface *attributes_decoder(int dec_id) {
+    return attributes_decoders_[dec_id].get();
+  }
+  int32_t num_attributes_decoders() const {
+    return static_cast<int32_t>(attributes_decoders_.size());
+  }
+
+  // Get a mutable pointer to the decoded point cloud. This is intended to be
+  // used mostly by other decoder subsystems.
+  PointCloud *point_cloud() { return point_cloud_; }
+  const PointCloud *point_cloud() const { return point_cloud_; }
+
+  DecoderBuffer *buffer() { return buffer_; }
+  const DecoderOptions *options() const { return options_; }
+
+ protected:
+  // Can be implemented by derived classes to perform any custom initialization
+  // of the decoder. Called in the Decode() method.
+  virtual bool InitializeDecoder() { return true; }
+
+  // Creates an attribute decoder.
+  virtual bool CreateAttributesDecoder(int32_t att_decoder_id) = 0;
+  virtual bool DecodeGeometryData() { return true; }
+  virtual bool DecodePointAttributes();
+
+  virtual bool DecodeAllAttributes();
+  virtual bool OnAttributesDecoded() { return true; }
+
+  Status DecodeMetadata();
+
+ private:
+  // Point cloud that is being filled in by the decoder.
+  PointCloud *point_cloud_;
+
+  std::vector<std::unique_ptr<AttributesDecoderInterface>> attributes_decoders_;
+
+  // Map between attribute id and decoder id.
+  std::vector<int32_t> attribute_to_decoder_map_;
+
+  // Input buffer holding the encoded data.
+  DecoderBuffer *buffer_;
+
+  // Bit-stream version of the encoder that encoded the input data.
+  uint8_t version_major_;
+  uint8_t version_minor_;
+
+  const DecoderOptions *options_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.cc b/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.cc
new file mode 100644
index 000000000..a1fda8d5a
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.cc
@@ -0,0 +1,306 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+#include "draco/metadata/metadata_encoder.h"
+
+namespace draco {
+
+PointCloudEncoder::PointCloudEncoder()
+    : point_cloud_(nullptr), buffer_(nullptr), num_encoded_points_(0) {}
+
+void PointCloudEncoder::SetPointCloud(const PointCloud &pc) {
+  point_cloud_ = &pc;
+}
+
+Status PointCloudEncoder::Encode(const EncoderOptions &options,
+                                 EncoderBuffer *out_buffer) {
+  options_ = &options;
+  buffer_ = out_buffer;
+
+  // Cleanup from previous runs.
+  attributes_encoders_.clear();
+  attribute_to_encoder_map_.clear();
+  attributes_encoder_ids_order_.clear();
+
+  if (!point_cloud_) {
+    return Status(Status::DRACO_ERROR, "Invalid input geometry.");
+  }
+  DRACO_RETURN_IF_ERROR(EncodeHeader())
+  DRACO_RETURN_IF_ERROR(EncodeMetadata())
+  if (!InitializeEncoder()) {
+    return Status(Status::DRACO_ERROR, "Failed to initialize encoder.");
+  }
+  if (!EncodeEncoderData()) {
+    return Status(Status::DRACO_ERROR, "Failed to encode internal data.");
+  }
+  DRACO_RETURN_IF_ERROR(EncodeGeometryData());
+  if (!EncodePointAttributes()) {
+    return Status(Status::DRACO_ERROR, "Failed to encode point attributes.");
+  }
+  if (options.GetGlobalBool("store_number_of_encoded_points", false)) {
+    ComputeNumberOfEncodedPoints();
+  }
+  return OkStatus();
+}
+
+Status PointCloudEncoder::EncodeHeader() {
+  // Encode the header according to our v1 specification.
+  // Five bytes for Draco format.
+  buffer_->Encode("DRACO", 5);
+  // Version (major, minor).
+  const uint8_t encoder_type = GetGeometryType();
+  uint8_t version_major, version_minor;
+  version_major = encoder_type == POINT_CLOUD
+                      ? kDracoPointCloudBitstreamVersionMajor
+                      : kDracoMeshBitstreamVersionMajor;
+  version_minor = encoder_type == POINT_CLOUD
+                      ? kDracoPointCloudBitstreamVersionMinor
+                      : kDracoMeshBitstreamVersionMinor;
+
+  buffer_->Encode(version_major);
+  buffer_->Encode(version_minor);
+  // Type of the encoder (point cloud, mesh, ...).
+  buffer_->Encode(encoder_type);
+  // Unique identifier for the selected encoding method (edgebreaker, etc...).
+  buffer_->Encode(GetEncodingMethod());
+  // Reserved for flags.
+  uint16_t flags = 0;
+  // First bit of |flags| is reserved for metadata.
+  if (point_cloud_->GetMetadata()) {
+    flags |= METADATA_FLAG_MASK;
+  }
+  buffer_->Encode(flags);
+  return OkStatus();
+}
+
+Status PointCloudEncoder::EncodeMetadata() {
+  if (!point_cloud_->GetMetadata()) {
+    return OkStatus();
+  }
+  MetadataEncoder metadata_encoder;
+  if (!metadata_encoder.EncodeGeometryMetadata(buffer_,
+                                               point_cloud_->GetMetadata())) {
+    return Status(Status::DRACO_ERROR, "Failed to encode metadata.");
+  }
+  return OkStatus();
+}
+
+bool PointCloudEncoder::EncodePointAttributes() {
+  if (!GenerateAttributesEncoders()) {
+    return false;
+  }
+
+  // Encode the number of attribute encoders.
+  buffer_->Encode(static_cast<uint8_t>(attributes_encoders_.size()));
+
+  // Initialize all the encoders (this is used for example to init attribute
+  // dependencies, no data is encoded in this step).
+  for (auto &att_enc : attributes_encoders_) {
+    if (!att_enc->Init(this, point_cloud_)) {
+      return false;
+    }
+  }
+
+  // Rearrange attributes to respect dependencies between individual attributes.
+  if (!RearrangeAttributesEncoders()) {
+    return false;
+  }
+
+  // Encode any data that is necessary to create the corresponding attribute
+  // decoder.
+  for (int att_encoder_id : attributes_encoder_ids_order_) {
+    if (!EncodeAttributesEncoderIdentifier(att_encoder_id)) {
+      return false;
+    }
+  }
+
+  // Also encode any attribute encoder data (such as the info about encoded
+  // attributes).
+  for (int att_encoder_id : attributes_encoder_ids_order_) {
+    if (!attributes_encoders_[att_encoder_id]->EncodeAttributesEncoderData(
+            buffer_)) {
+      return false;
+    }
+  }
+
+  // Lastly encode all the attributes using the provided attribute encoders.
+  if (!EncodeAllAttributes()) {
+    return false;
+  }
+  return true;
+}
+
+bool PointCloudEncoder::GenerateAttributesEncoders() {
+  for (int i = 0; i < point_cloud_->num_attributes(); ++i) {
+    if (!GenerateAttributesEncoder(i)) {
+      return false;
+    }
+  }
+  attribute_to_encoder_map_.resize(point_cloud_->num_attributes());
+  for (uint32_t i = 0; i < attributes_encoders_.size(); ++i) {
+    for (uint32_t j = 0; j < attributes_encoders_[i]->num_attributes(); ++j) {
+      attribute_to_encoder_map_[attributes_encoders_[i]->GetAttributeId(j)] = i;
+    }
+  }
+  return true;
+}
+
+bool PointCloudEncoder::EncodeAllAttributes() {
+  for (int att_encoder_id : attributes_encoder_ids_order_) {
+    if (!attributes_encoders_[att_encoder_id]->EncodeAttributes(buffer_)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool PointCloudEncoder::MarkParentAttribute(int32_t parent_att_id) {
+  if (parent_att_id < 0 || parent_att_id >= point_cloud_->num_attributes()) {
+    return false;
+  }
+  const int32_t parent_att_encoder_id =
+      attribute_to_encoder_map_[parent_att_id];
+  if (!attributes_encoders_[parent_att_encoder_id]->MarkParentAttribute(
+          parent_att_id)) {
+    return false;
+  }
+  return true;
+}
+
+const PointAttribute *PointCloudEncoder::GetPortableAttribute(
+    int32_t parent_att_id) {
+  if (parent_att_id < 0 || parent_att_id >= point_cloud_->num_attributes()) {
+    return nullptr;
+  }
+  const int32_t parent_att_encoder_id =
+      attribute_to_encoder_map_[parent_att_id];
+  return attributes_encoders_[parent_att_encoder_id]->GetPortableAttribute(
+      parent_att_id);
+}
+
+bool PointCloudEncoder::RearrangeAttributesEncoders() {
+  // Find the encoding order of the attribute encoders that is determined by
+  // the parent dependencies between individual encoders. Instead of traversing
+  // a graph we encode the attributes in multiple iterations where encoding of
+  // attributes that depend on other attributes may get postponed until the
+  // parent attributes are processed.
+  // This is simpler to implement than graph traversal and it automatically
+  // detects any cycles in the dependency graph.
+  // TODO(ostava): Current implementation needs to encode all attributes of a
+  // single encoder to be encoded in a single "chunk", therefore we need to sort
+  // attribute encoders before we sort individual attributes. This requirement
+  // can be lifted for encoders that can encode individual attributes separately
+  // but it will require changes in the current API.
+  attributes_encoder_ids_order_.resize(attributes_encoders_.size());
+  std::vector<bool> is_encoder_processed(attributes_encoders_.size(), false);
+  uint32_t num_processed_encoders = 0;
+  while (num_processed_encoders < attributes_encoders_.size()) {
+    // Flagged when any of the encoder get processed.
+    bool encoder_processed = false;
+    for (uint32_t i = 0; i < attributes_encoders_.size(); ++i) {
+      if (is_encoder_processed[i]) {
+        continue;  // Encoder already processed.
+      }
+      // Check if all parent encoders are already processed.
+      bool can_be_processed = true;
+      for (uint32_t p = 0; p < attributes_encoders_[i]->num_attributes(); ++p) {
+        const int32_t att_id = attributes_encoders_[i]->GetAttributeId(p);
+        for (int ap = 0;
+             ap < attributes_encoders_[i]->NumParentAttributes(att_id); ++ap) {
+          const uint32_t parent_att_id =
+              attributes_encoders_[i]->GetParentAttributeId(att_id, ap);
+          const int32_t parent_encoder_id =
+              attribute_to_encoder_map_[parent_att_id];
+          if (parent_att_id != i && !is_encoder_processed[parent_encoder_id]) {
+            can_be_processed = false;
+            break;
+          }
+        }
+      }
+      if (!can_be_processed) {
+        continue;  // Try to process the encoder in the next iteration.
+      }
+      // Encoder can be processed. Update the encoding order.
+      attributes_encoder_ids_order_[num_processed_encoders++] = i;
+      is_encoder_processed[i] = true;
+      encoder_processed = true;
+    }
+    if (!encoder_processed &&
+        num_processed_encoders < attributes_encoders_.size()) {
+      // No encoder was processed but there are still some remaining unprocessed
+      // encoders.
+      return false;
+    }
+  }
+
+  // Now for every encoder, reorder the attributes to satisfy their
+  // dependencies (an attribute may still depend on other attributes within an
+  // encoder).
+  std::vector<int32_t> attribute_encoding_order;
+  std::vector<bool> is_attribute_processed(point_cloud_->num_attributes(),
+                                           false);
+  int num_processed_attributes;
+  for (uint32_t ae_order = 0; ae_order < attributes_encoders_.size();
+       ++ae_order) {
+    const int ae = attributes_encoder_ids_order_[ae_order];
+    const int32_t num_encoder_attributes =
+        attributes_encoders_[ae]->num_attributes();
+    if (num_encoder_attributes < 2) {
+      continue;  // No need to resolve dependencies for a single attribute.
+    }
+    num_processed_attributes = 0;
+    attribute_encoding_order.resize(num_encoder_attributes);
+    while (num_processed_attributes < num_encoder_attributes) {
+      // Flagged when any of the attributes get processed.
+      bool attribute_processed = false;
+      for (int i = 0; i < num_encoder_attributes; ++i) {
+        const int32_t att_id = attributes_encoders_[ae]->GetAttributeId(i);
+        if (is_attribute_processed[i]) {
+          continue;  // Attribute already processed.
+        }
+        // Check if all parent attributes are already processed.
+        bool can_be_processed = true;
+        for (int p = 0;
+             p < attributes_encoders_[ae]->NumParentAttributes(att_id); ++p) {
+          const int32_t parent_att_id =
+              attributes_encoders_[ae]->GetParentAttributeId(att_id, p);
+          if (!is_attribute_processed[parent_att_id]) {
+            can_be_processed = false;
+            break;
+          }
+        }
+        if (!can_be_processed) {
+          continue;  // Try to process the attribute in the next iteration.
+        }
+        // Attribute can be processed. Update the encoding order.
+        attribute_encoding_order[num_processed_attributes++] = i;
+        is_attribute_processed[i] = true;
+        attribute_processed = true;
+      }
+      if (!attribute_processed &&
+          num_processed_attributes < num_encoder_attributes) {
+        // No attribute was processed but there are still some remaining
+        // unprocessed attributes.
+        return false;
+      }
+    }
+    // Update the order of the attributes within the encoder.
+    attributes_encoders_[ae]->SetAttributeIds(attribute_encoding_order);
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.h b/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.h
new file mode 100644
index 000000000..8883f17a7
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_encoder.h
@@ -0,0 +1,158 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_ENCODER_H_
+
+#include "draco/compression/attributes/attributes_encoder.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// Abstract base class for all point cloud and mesh encoders. It provides a
+// basic functionality that's shared between different encoders.
+class PointCloudEncoder {
+ public:
+  PointCloudEncoder();
+  virtual ~PointCloudEncoder() = default;
+
+  // Sets the point cloud that is going be encoded. Must be called before the
+  // Encode() method.
+  void SetPointCloud(const PointCloud &pc);
+
+  // The main entry point that encodes provided point cloud.
+  Status Encode(const EncoderOptions &options, EncoderBuffer *out_buffer);
+
+  virtual EncodedGeometryType GetGeometryType() const { return POINT_CLOUD; }
+
+  // Returns the unique identifier of the encoding method (such as Edgebreaker
+  // for mesh compression).
+  virtual uint8_t GetEncodingMethod() const = 0;
+
+  // Returns the number of points that were encoded during the last Encode()
+  // function call. Valid only if "store_number_of_encoded_points" flag was set
+  // in the provided EncoderOptions.
+  size_t num_encoded_points() const { return num_encoded_points_; }
+
+  int num_attributes_encoders() const {
+    return static_cast<int>(attributes_encoders_.size());
+  }
+  AttributesEncoder *attributes_encoder(int i) {
+    return attributes_encoders_[i].get();
+  }
+
+  // Adds a new attribute encoder, returning its id.
+  int AddAttributesEncoder(std::unique_ptr<AttributesEncoder> att_enc) {
+    attributes_encoders_.push_back(std::move(att_enc));
+    return static_cast<int>(attributes_encoders_.size() - 1);
+  }
+
+  // Marks one attribute as a parent of another attribute. Must be called after
+  // all attribute encoders are created (usually in the
+  // AttributeEncoder::Init() method).
+  bool MarkParentAttribute(int32_t parent_att_id);
+
+  // Returns an attribute containing portable version of the attribute data that
+  // is guaranteed to be encoded losslessly. This attribute can be used safely
+  // as predictor for other attributes.
+  const PointAttribute *GetPortableAttribute(int32_t point_attribute_id);
+
+  EncoderBuffer *buffer() { return buffer_; }
+  const EncoderOptions *options() const { return options_; }
+  const PointCloud *point_cloud() const { return point_cloud_; }
+
+ protected:
+  // Can be implemented by derived classes to perform any custom initialization
+  // of the encoder. Called in the Encode() method.
+  virtual bool InitializeEncoder() { return true; }
+
+  // Should be used to encode any encoder-specific data.
+  virtual bool EncodeEncoderData() { return true; }
+
+  // Encodes any global geometry data (such as the number of points).
+  virtual Status EncodeGeometryData() { return OkStatus(); }
+
+  // encode all attribute values. The attribute encoders are sorted to resolve
+  // any attribute dependencies and all the encoded data is stored into the
+  // |buffer_|.
+  // Returns false if the encoding failed.
+  virtual bool EncodePointAttributes();
+
+  // Generate attribute encoders that are going to be used for encoding
+  // point attribute data. Calls GenerateAttributesEncoder() for every attribute
+  // of the encoded PointCloud.
+  virtual bool GenerateAttributesEncoders();
+
+  // Creates attribute encoder for a specific point attribute. This function
+  // needs to be implemented by the derived classes. The derived classes need
+  // to either 1. Create a new attribute encoder and add it using the
+  // AddAttributeEncoder method, or 2. add the attribute to an existing
+  // attribute encoder (using AttributesEncoder::AddAttributeId() method).
+  virtual bool GenerateAttributesEncoder(int32_t att_id) = 0;
+
+  // Encodes any data that is necessary to recreate a given attribute encoder.
+  // Note: this is called in order in which the attribute encoders are going to
+  // be encoded.
+  virtual bool EncodeAttributesEncoderIdentifier(int32_t /* att_encoder_id */) {
+    return true;
+  }
+
+  // Encodes all the attribute data using the created attribute encoders.
+  virtual bool EncodeAllAttributes();
+
+  // Computes and sets the num_encoded_points_ for the encoder.
+  virtual void ComputeNumberOfEncodedPoints() = 0;
+
+  void set_num_encoded_points(size_t num_points) {
+    num_encoded_points_ = num_points;
+  }
+
+ private:
+  // Encodes Draco header that is the same for all encoders.
+  Status EncodeHeader();
+
+  // Encode metadata.
+  Status EncodeMetadata();
+
+  // Rearranges attribute encoders and their attributes to reflect the
+  // underlying attribute dependencies. This ensures that the attributes are
+  // encoded in the correct order (parent attributes before their children).
+  bool RearrangeAttributesEncoders();
+
+  const PointCloud *point_cloud_;
+  std::vector<std::unique_ptr<AttributesEncoder>> attributes_encoders_;
+
+  // Map between attribute id and encoder id.
+  std::vector<int32_t> attribute_to_encoder_map_;
+
+  // Encoding order of individual attribute encoders (i.e., the order in which
+  // they are processed during encoding that may be different from the order
+  // in which they were created because of attribute dependencies.
+  std::vector<int32_t> attributes_encoder_ids_order_;
+
+  // This buffer holds the final encoded data.
+  EncoderBuffer *buffer_;
+
+  const EncoderOptions *options_;
+
+  size_t num_encoded_points_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.cc b/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.cc
new file mode 100644
index 000000000..2deebbc48
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.cc
@@ -0,0 +1,40 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_kd_tree_decoder.h"
+
+#include "draco/compression/attributes/kd_tree_attributes_decoder.h"
+
+namespace draco {
+
+bool PointCloudKdTreeDecoder::DecodeGeometryData() {
+  int32_t num_points;
+  if (!buffer()->Decode(&num_points)) {
+    return false;
+  }
+  if (num_points < 0) {
+    return false;
+  }
+  point_cloud()->set_num_points(num_points);
+  return true;
+}
+
+bool PointCloudKdTreeDecoder::CreateAttributesDecoder(int32_t att_decoder_id) {
+  // Always create the basic attribute decoder.
+  return SetAttributesDecoder(
+      att_decoder_id,
+      std::unique_ptr<AttributesDecoder>(new KdTreeAttributesDecoder()));
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.h b/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.h
new file mode 100644
index 000000000..6e192f2a5
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_decoder.h
@@ -0,0 +1,31 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_DECODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+
+namespace draco {
+
+// Decodes PointCloud encoded with the PointCloudKdTreeEncoder.
+class PointCloudKdTreeDecoder : public PointCloudDecoder {
+ protected:
+  bool DecodeGeometryData() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.cc b/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.cc
new file mode 100644
index 000000000..92b6c84cd
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.cc
@@ -0,0 +1,43 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_kd_tree_encoder.h"
+
+#include "draco/compression/attributes/kd_tree_attributes_encoder.h"
+
+namespace draco {
+
+Status PointCloudKdTreeEncoder::EncodeGeometryData() {
+  const int32_t num_points = point_cloud()->num_points();
+  buffer()->Encode(num_points);
+  return OkStatus();
+}
+
+bool PointCloudKdTreeEncoder::GenerateAttributesEncoder(int32_t att_id) {
+  if (num_attributes_encoders() == 0) {
+    // Create a new attribute encoder only for the first attribute.
+    AddAttributesEncoder(std::unique_ptr<AttributesEncoder>(
+        new KdTreeAttributesEncoder(att_id)));
+    return true;
+  }
+  // Add a new attribute to the attribute encoder.
+  attributes_encoder(0)->AddAttributeId(att_id);
+  return true;
+}
+
+void PointCloudKdTreeEncoder::ComputeNumberOfEncodedPoints() {
+  set_num_encoded_points(point_cloud()->num_points());
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.h b/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.h
new file mode 100644
index 000000000..6acbb949d
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoder.h
@@ -0,0 +1,45 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_ENCODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+namespace draco {
+
+// Encodes a PointCloud using one of the available Kd-tree compression methods.
+// See FloatPointsKdTreeEncoder and DynamicIntegerPointsKdTreeEncoder for more
+// details. Currently, the input PointCloud must satisfy the following
+// requirements to use this encoder:
+//  1. PointCloud has only one attribute of type GeometryAttribute::POSITION.
+//  2. The position attribute has three components (x,y,z).
+//  3. The position values are stored as either DT_FLOAT32 or DT_UINT32.
+//  4. If the position values are stored as DT_FLOAT32, quantization needs to
+//     be enabled for the position attribute.
+class PointCloudKdTreeEncoder : public PointCloudEncoder {
+ public:
+  uint8_t GetEncodingMethod() const override {
+    return POINT_CLOUD_KD_TREE_ENCODING;
+  }
+
+ protected:
+  Status EncodeGeometryData() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_KD_TREE_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoding_test.cc b/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoding_test.cc
new file mode 100644
index 000000000..2249bb09e
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_kd_tree_encoding_test.cc
@@ -0,0 +1,458 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_kd_tree_decoder.h"
+#include "draco/compression/point_cloud/point_cloud_kd_tree_encoder.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/core/vector_d.h"
+#include "draco/io/obj_decoder.h"
+#include "draco/point_cloud/point_cloud_builder.h"
+
+namespace draco {
+
+class PointCloudKdTreeEncodingTest : public ::testing::Test {
+ protected:
+  void ComparePointClouds(const PointCloud &p0, const PointCloud &p1) const {
+    ASSERT_EQ(p0.num_points(), p1.num_points());
+    ASSERT_EQ(p0.num_attributes(), p1.num_attributes());
+    // Currently works only with one attribute.
+    ASSERT_EQ(p0.num_attributes(), p1.num_attributes());
+    for (auto index = 0; index < p0.num_attributes(); index += 1) {
+      ASSERT_EQ(p0.attribute(index)->num_components(),
+                p1.attribute(index)->num_components());
+      std::vector<double> points_0, points_1;
+      std::vector<double> att_entry_0(p0.attribute(index)->num_components());
+      std::vector<double> att_entry_1(p0.attribute(index)->num_components());
+      for (PointIndex i(0); i < p0.num_points(); ++i) {
+        p0.attribute(index)->ConvertValue(p0.attribute(index)->mapped_index(i),
+                                          &att_entry_0[0]);
+        p1.attribute(index)->ConvertValue(p1.attribute(index)->mapped_index(i),
+                                          &att_entry_1[0]);
+        for (int d = 0; d < p0.attribute(index)->num_components(); ++d) {
+          points_0.push_back(att_entry_0[d]);
+          points_1.push_back(att_entry_1[d]);
+        }
+      }
+      // To compare the point clouds we sort points components from both inputs
+      // separately, and then we compare all matching coordinates one by one.
+      // TODO(ostava): Note that this is not guaranteed to work for quantized
+      // point clouds because the order of points may actually change because
+      // of the quantization. The test should be make more robust to handle such
+      // case.
+      std::sort(points_0.begin(), points_0.end());
+      std::sort(points_1.begin(), points_1.end());
+      for (uint32_t i = 0; i < points_0.size(); ++i) {
+        ASSERT_LE(std::fabs(points_0[i] - points_1[i]), 1e-2);
+      }
+    }
+  }
+
+  void TestKdTreeEncoding(const PointCloud &pc) {
+    EncoderBuffer buffer;
+    PointCloudKdTreeEncoder encoder;
+    EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+    options.SetGlobalInt("quantization_bits", 16);
+    for (int compression_level = 0; compression_level <= 6;
+         ++compression_level) {
+      options.SetSpeed(10 - compression_level, 10 - compression_level);
+      encoder.SetPointCloud(pc);
+      ASSERT_TRUE(encoder.Encode(options, &buffer).ok());
+
+      DecoderBuffer dec_buffer;
+      dec_buffer.Init(buffer.data(), buffer.size());
+      PointCloudKdTreeDecoder decoder;
+
+      std::unique_ptr<PointCloud> out_pc(new PointCloud());
+      DecoderOptions dec_options;
+      ASSERT_TRUE(decoder.Decode(dec_options, &dec_buffer, out_pc.get()).ok());
+
+      ComparePointClouds(pc, *out_pc);
+    }
+  }
+
+  void TestFloatEncoding(const std::string &file_name) {
+    std::unique_ptr<PointCloud> pc = ReadPointCloudFromTestFile(file_name);
+    ASSERT_NE(pc, nullptr);
+
+    TestKdTreeEncoding(*pc);
+  }
+};
+
+TEST_F(PointCloudKdTreeEncodingTest, TestFloatKdTreeEncoding) {
+  TestFloatEncoding("cube_subd.obj");
+}
+
+TEST_F(PointCloudKdTreeEncodingTest, TestIntKdTreeEncoding) {
+  constexpr int num_points = 120;
+  std::vector<std::array<uint32_t, 3>> points(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127);
+    pos[1] = 13 * ((i * 3) % 321);
+    pos[2] = 29 * ((i * 19) % 450);
+    points[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id, PointIndex(i),
+                                      &(points[i.value()])[0]);
+  }
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// test higher dimensions with more attributes
+TEST_F(PointCloudKdTreeEncodingTest, TestIntKdTreeEncodingHigherDimension) {
+  constexpr int num_points = 120;
+  std::vector<std::array<uint32_t, 3>> points3(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127);
+    pos[1] = 13 * ((i * 3) % 321);
+    pos[2] = 29 * ((i * 19) % 450);
+    points3[i] = pos;
+  }
+  std::vector<std::array<uint32_t, 2>> points2(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 2> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 1;
+    pos[1] = 13 * ((i * 3) % 321) + 1;
+    points2[i] = pos;
+  }
+  std::vector<std::array<uint32_t, 1>> points1(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 1> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 11;
+    points1[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id3 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id3, PointIndex(i),
+                                      &(points3[i.value()])[0]);
+  }
+  const int att_id2 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 2, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id2, PointIndex(i),
+                                      &(points2[i.value()])[0]);
+  }
+  const int att_id1 =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id1, PointIndex(i),
+                                      &(points1[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// Test 16 and 8 bit encoding.
+TEST_F(PointCloudKdTreeEncodingTest,
+       TestIntKdTreeEncodingHigherDimensionVariedTypes) {
+  constexpr int num_points = 120;
+  std::vector<std::array<uint32_t, 3>> points3(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127);
+    pos[1] = 13 * ((i * 3) % 321);
+    pos[2] = 29 * ((i * 19) % 450);
+    points3[i] = pos;
+  }
+  std::vector<std::array<uint16_t, 2>> points2(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint16_t, 2> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 1;
+    pos[1] = 13 * ((i * 3) % 321) + 1;
+    points2[i] = pos;
+  }
+  std::vector<std::array<uint8_t, 1>> points1(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint8_t, 1> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 11;
+    points1[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id3 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id3, PointIndex(i),
+                                      &(points3[i.value()])[0]);
+  }
+  const int att_id2 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 2, DT_UINT16);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id2, PointIndex(i),
+                                      &(points2[i.value()])[0]);
+  }
+  const int att_id1 =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_UINT8);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id1, PointIndex(i),
+                                      &(points1[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// Test 16 only encoding for one attribute.
+TEST_F(PointCloudKdTreeEncodingTest, TestIntKdTreeEncoding16Bit) {
+  constexpr int num_points = 120;
+  std::vector<std::array<uint16_t, 3>> points3(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint16_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127);
+    pos[1] = 13 * ((i * 3) % 321);
+    pos[2] = 29 * ((i * 19) % 450);
+    points3[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id3 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT16);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id3, PointIndex(i),
+                                      &(points3[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// Test 16 and 8 bit encoding with size bigger than 32bit encoding.
+TEST_F(PointCloudKdTreeEncodingTest,
+       TestIntKdTreeEncodingHigherDimensionVariedTypesBig16BitEncoding) {
+  constexpr int num_points = 120;
+  std::vector<std::array<uint32_t, 3>> points3(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127);
+    pos[1] = 13 * ((i * 3) % 321);
+    pos[2] = 29 * ((i * 19) % 450);
+    points3[i] = pos;
+  }
+  // The total size of the 16bit encoding must be bigger than the total size of
+  // the 32bit encoding.
+  std::vector<std::array<uint16_t, 7>> points7(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint16_t, 7> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 1;
+    pos[1] = 13 * ((i * 3) % 321) + 1;
+    pos[2] = pos[0] + 13;
+    pos[3] = pos[2] + 13;
+    pos[4] = pos[3] + 13;
+    pos[5] = pos[4] + 13;
+    pos[6] = pos[5] + 13;
+    points7[i] = pos;
+  }
+  std::vector<std::array<uint8_t, 1>> points1(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint8_t, 1> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 11;
+    points1[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id3 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id3, PointIndex(i),
+                                      &(points3[i.value()])[0]);
+  }
+  const int att_id2 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 7, DT_UINT16);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id2, PointIndex(i),
+                                      &(points7[i.value()])[0]);
+  }
+  const int att_id1 =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_UINT8);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id1, PointIndex(i),
+                                      &(points1[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// Test encoding of quantized values.
+TEST_F(PointCloudKdTreeEncodingTest,
+       TestIntKdTreeEncodingHigherDimensionFloatTypes) {
+  constexpr int num_points = 130;
+  std::vector<std::array<uint32_t, 3>> points3(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 125);
+    pos[1] = 13 * ((i * 3) % 334);
+    pos[2] = 29 * ((i * 19) % 470);
+    points3[i] = pos;
+  }
+  std::vector<std::array<float, 2>> points_float(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<float, 2> pos;
+    // Generate some pseudo-random points.
+    pos[0] = static_cast<float>(8 * ((i * 7) % 127) + 1) / 2.5f;
+    pos[1] = static_cast<float>(13 * ((i * 3) % 321) + 1) / 3.2f;
+    points_float[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id3 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id3, PointIndex(i),
+                                      &(points3[i.value()])[0]);
+  }
+  const int att_id_float =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 2, DT_FLOAT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id_float, PointIndex(i),
+                                      &(points_float[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// Test encoding of signed integer values
+TEST_F(PointCloudKdTreeEncodingTest, TestIntKdTreeEncodingSignedTypes) {
+  constexpr int num_points = 120;
+  std::vector<std::array<uint32_t, 3>> points3(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, 3> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127);
+    pos[1] = 13 * ((i * 3) % 321);
+    pos[2] = 29 * ((i * 19) % 450);
+    points3[i] = pos;
+  }
+  std::vector<std::array<int32_t, 2>> points2(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<int32_t, 2> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 1;
+    if (i % 3 == 0) {
+      pos[0] = -pos[0];
+    }
+    pos[1] = 13 * ((i * 3) % 321) + 1;
+    points2[i] = pos;
+  }
+  std::vector<std::array<int16_t, 1>> points1(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<int16_t, 1> pos;
+    // Generate some pseudo-random points.
+    pos[0] = 8 * ((i * 7) % 127) + 11;
+    if (i % 5 == 0) {
+      pos[0] = -pos[0];
+    }
+    points1[i] = pos;
+  }
+
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id3 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id3, PointIndex(i),
+                                      &(points3[i.value()])[0]);
+  }
+  const int att_id2 =
+      builder.AddAttribute(GeometryAttribute::POSITION, 2, DT_INT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id2, PointIndex(i),
+                                      &(points2[i.value()])[0]);
+  }
+
+  const int att_id1 =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_INT16);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id1, PointIndex(i),
+                                      &(points1[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+// Test encoding of integer point clouds with > 16 dimensions.
+TEST_F(PointCloudKdTreeEncodingTest, TestIntKdTreeEncodingHighDimensional) {
+  constexpr int num_points = 120;
+  constexpr int num_dims = 42;
+  std::vector<std::array<uint32_t, num_dims>> points(num_points);
+  for (int i = 0; i < num_points; ++i) {
+    std::array<uint32_t, num_dims> pos;
+    // Generate some pseudo-random points.
+    for (int d = 0; d < num_dims; ++d) {
+      pos[d] = 8 * ((i + d) * (7 + (d % 4)) % (127 + d % 3));
+    }
+    points[i] = pos;
+  }
+  PointCloudBuilder builder;
+  builder.Start(num_points);
+  const int att_id =
+      builder.AddAttribute(GeometryAttribute::POSITION, num_dims, DT_UINT32);
+  for (PointIndex i(0); i < num_points; ++i) {
+    builder.SetAttributeValueForPoint(att_id, PointIndex(i),
+                                      &(points[i.value()])[0]);
+  }
+
+  std::unique_ptr<PointCloud> pc = builder.Finalize(false);
+  ASSERT_NE(pc, nullptr);
+
+  TestKdTreeEncoding(*pc);
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.cc b/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.cc
new file mode 100644
index 000000000..b9382d310
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.cc
@@ -0,0 +1,42 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_sequential_decoder.h"
+
+#include "draco/compression/attributes/linear_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_decoders_controller.h"
+
+namespace draco {
+
+bool PointCloudSequentialDecoder::DecodeGeometryData() {
+  int32_t num_points;
+  if (!buffer()->Decode(&num_points)) {
+    return false;
+  }
+  point_cloud()->set_num_points(num_points);
+  return true;
+}
+
+bool PointCloudSequentialDecoder::CreateAttributesDecoder(
+    int32_t att_decoder_id) {
+  // Always create the basic attribute decoder.
+  return SetAttributesDecoder(
+      att_decoder_id,
+      std::unique_ptr<AttributesDecoder>(
+          new SequentialAttributeDecodersController(
+              std::unique_ptr<PointsSequencer>(
+                  new LinearSequencer(point_cloud()->num_points())))));
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.h b/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.h
new file mode 100644
index 000000000..9968dc275
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_decoder.h
@@ -0,0 +1,33 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_DECODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_DECODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_decoder.h"
+
+namespace draco {
+
+// Point cloud decoder for data encoded by the PointCloudSequentialEncoder.
+// All attribute values are decoded using an identity mapping between point ids
+// and attribute value ids.
+class PointCloudSequentialDecoder : public PointCloudDecoder {
+ protected:
+  bool DecodeGeometryData() override;
+  bool CreateAttributesDecoder(int32_t att_decoder_id) override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_DECODER_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.cc b/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.cc
new file mode 100644
index 000000000..fa7b6fd90
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.cc
@@ -0,0 +1,49 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_sequential_encoder.h"
+
+#include "draco/compression/attributes/linear_sequencer.h"
+#include "draco/compression/attributes/sequential_attribute_encoders_controller.h"
+
+namespace draco {
+
+Status PointCloudSequentialEncoder::EncodeGeometryData() {
+  const int32_t num_points = point_cloud()->num_points();
+  buffer()->Encode(num_points);
+  return OkStatus();
+}
+
+bool PointCloudSequentialEncoder::GenerateAttributesEncoder(int32_t att_id) {
+  // Create only one attribute encoder that is going to encode all points in a
+  // linear sequence.
+  if (att_id == 0) {
+    // Create a new attribute encoder only for the first attribute.
+    AddAttributesEncoder(std::unique_ptr<AttributesEncoder>(
+        new SequentialAttributeEncodersController(
+            std::unique_ptr<PointsSequencer>(
+                new LinearSequencer(point_cloud()->num_points())),
+            att_id)));
+  } else {
+    // Reuse the existing attribute encoder for other attributes.
+    attributes_encoder(0)->AddAttributeId(att_id);
+  }
+  return true;
+}
+
+void PointCloudSequentialEncoder::ComputeNumberOfEncodedPoints() {
+  set_num_encoded_points(point_cloud()->num_points());
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.h b/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.h
new file mode 100644
index 000000000..40d8edcdb
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoder.h
@@ -0,0 +1,43 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_ENCODER_H_
+#define DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_ENCODER_H_
+
+#include "draco/compression/point_cloud/point_cloud_encoder.h"
+
+namespace draco {
+
+// A basic point cloud encoder that iterates over all points and encodes all
+// attribute values for every visited point. The attribute values encoding
+// can be controlled using provided encoding option to enable features such
+// as quantization or prediction schemes.
+// This encoder preserves the order and the number of input points, but the
+// mapping between point ids and attribute values may be different for the
+// decoded point cloud.
+class PointCloudSequentialEncoder : public PointCloudEncoder {
+ public:
+  uint8_t GetEncodingMethod() const override {
+    return POINT_CLOUD_SEQUENTIAL_ENCODING;
+  }
+
+ protected:
+  Status EncodeGeometryData() override;
+  bool GenerateAttributesEncoder(int32_t att_id) override;
+  void ComputeNumberOfEncodedPoints() override;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_COMPRESSION_POINT_CLOUD_POINT_CLOUD_SEQUENTIAL_ENCODER_H_
diff --git a/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoding_test.cc b/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoding_test.cc
new file mode 100644
index 000000000..32be120dc
--- /dev/null
+++ b/contrib/draco/src/draco/compression/point_cloud/point_cloud_sequential_encoding_test.cc
@@ -0,0 +1,92 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/compression/point_cloud/point_cloud_sequential_decoder.h"
+#include "draco/compression/point_cloud/point_cloud_sequential_encoder.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/obj_decoder.h"
+
+namespace draco {
+
+class PointCloudSequentialEncodingTest : public ::testing::Test {
+ protected:
+  std::unique_ptr<PointCloud> EncodeAndDecodePointCloud(const PointCloud *pc) {
+    EncoderBuffer buffer;
+    PointCloudSequentialEncoder encoder;
+    EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+    encoder.SetPointCloud(*pc);
+    if (!encoder.Encode(options, &buffer).ok()) {
+      return nullptr;
+    }
+
+    DecoderBuffer dec_buffer;
+    dec_buffer.Init(buffer.data(), buffer.size());
+    PointCloudSequentialDecoder decoder;
+
+    std::unique_ptr<PointCloud> out_pc(new PointCloud());
+    DecoderOptions dec_options;
+    if (!decoder.Decode(dec_options, &dec_buffer, out_pc.get()).ok()) {
+      return nullptr;
+    }
+    return out_pc;
+  }
+
+  void TestEncoding(const std::string &file_name) {
+    std::unique_ptr<PointCloud> pc = ReadPointCloudFromTestFile(file_name);
+    ASSERT_NE(pc, nullptr);
+
+    std::unique_ptr<PointCloud> decoded_pc =
+        EncodeAndDecodePointCloud(pc.get());
+    ASSERT_NE(decoded_pc.get(), nullptr);
+    ASSERT_EQ(decoded_pc->num_points(), pc->num_points());
+  }
+};
+
+TEST_F(PointCloudSequentialEncodingTest, DoesEncodeAndDecode) {
+  TestEncoding("test_nm.obj");
+}
+
+TEST_F(PointCloudSequentialEncodingTest, EncodingPointCloudWithMetadata) {
+  std::unique_ptr<PointCloud> pc = ReadPointCloudFromTestFile("test_nm.obj");
+  ASSERT_NE(pc, nullptr);
+  // Add metadata to point cloud.
+  std::unique_ptr<GeometryMetadata> metadata =
+      std::unique_ptr<GeometryMetadata>(new GeometryMetadata());
+  const uint32_t pos_att_id =
+      pc->GetNamedAttributeId(GeometryAttribute::POSITION);
+  std::unique_ptr<AttributeMetadata> pos_metadata =
+      std::unique_ptr<AttributeMetadata>(new AttributeMetadata());
+  pos_metadata->AddEntryString("name", "position");
+  pc->AddAttributeMetadata(pos_att_id, std::move(pos_metadata));
+
+  std::unique_ptr<PointCloud> decoded_pc = EncodeAndDecodePointCloud(pc.get());
+  ASSERT_NE(decoded_pc.get(), nullptr);
+
+  const GeometryMetadata *const pc_metadata = decoded_pc->GetMetadata();
+  ASSERT_NE(pc_metadata, nullptr);
+  // Test getting attribute metadata by id.
+  ASSERT_NE(pc->GetAttributeMetadataByAttributeId(pos_att_id), nullptr);
+  // Test getting attribute metadata by entry name value pair.
+  const AttributeMetadata *const requested_att_metadata =
+      pc_metadata->GetAttributeMetadataByStringEntry("name", "position");
+  ASSERT_NE(requested_att_metadata, nullptr);
+  ASSERT_EQ(requested_att_metadata->att_unique_id(),
+            pc->attribute(pos_att_id)->unique_id());
+}
+
+// TODO(ostava): Test the reusability of a single instance of the encoder and
+// decoder class.
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/bit_utils.cc b/contrib/draco/src/draco/core/bit_utils.cc
new file mode 100644
index 000000000..37119a717
--- /dev/null
+++ b/contrib/draco/src/draco/core/bit_utils.cc
@@ -0,0 +1,36 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/bit_utils.h"
+
+namespace draco {
+
+void ConvertSignedIntsToSymbols(const int32_t *in, int in_values,
+                                uint32_t *out) {
+  // Convert the quantized values into a format more suitable for entropy
+  // encoding.
+  // Put the sign bit into LSB pos and shift the rest one bit left.
+  for (int i = 0; i < in_values; ++i) {
+    out[i] = ConvertSignedIntToSymbol(in[i]);
+  }
+}
+
+void ConvertSymbolsToSignedInts(const uint32_t *in, int in_values,
+                                int32_t *out) {
+  for (int i = 0; i < in_values; ++i) {
+    out[i] = ConvertSymbolToSignedInt(in[i]);
+  }
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/bit_utils.h b/contrib/draco/src/draco/core/bit_utils.h
new file mode 100644
index 000000000..a102095c7
--- /dev/null
+++ b/contrib/draco/src/draco/core/bit_utils.h
@@ -0,0 +1,124 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File containing a basic set of bit manipulation utilities used within the
+// Draco library.
+
+#ifndef DRACO_CORE_BIT_UTILS_H_
+#define DRACO_CORE_BIT_UTILS_H_
+
+#include <inttypes.h>
+#include <stdint.h>
+
+#include <type_traits>
+
+#if defined(_MSC_VER)
+#include <intrin.h>
+#endif  // defined(_MSC_VER)
+
+namespace draco {
+
+// Returns the number of '1' bits within the input 32 bit integer.
+inline int CountOneBits32(uint32_t n) {
+  n -= ((n >> 1) & 0x55555555);
+  n = ((n >> 2) & 0x33333333) + (n & 0x33333333);
+  return (((n + (n >> 4)) & 0xF0F0F0F) * 0x1010101) >> 24;
+}
+
+inline uint32_t ReverseBits32(uint32_t n) {
+  n = ((n >> 1) & 0x55555555) | ((n & 0x55555555) << 1);
+  n = ((n >> 2) & 0x33333333) | ((n & 0x33333333) << 2);
+  n = ((n >> 4) & 0x0F0F0F0F) | ((n & 0x0F0F0F0F) << 4);
+  n = ((n >> 8) & 0x00FF00FF) | ((n & 0x00FF00FF) << 8);
+  return (n >> 16) | (n << 16);
+}
+
+// Copies the |nbits| from the src integer into the |dst| integer using the
+// provided bit offsets |dst_offset| and |src_offset|.
+inline void CopyBits32(uint32_t *dst, int dst_offset, uint32_t src,
+                       int src_offset, int nbits) {
+  const uint32_t mask = (~static_cast<uint32_t>(0)) >> (32 - nbits)
+                                                           << dst_offset;
+  *dst = (*dst & (~mask)) | (((src >> src_offset) << dst_offset) & mask);
+}
+
+// Returns the location of the most significant bit in the input integer |n|.
+// The functionality is not defined for |n == 0|.
+inline int MostSignificantBit(uint32_t n) {
+#if defined(__GNUC__)
+  return 31 ^ __builtin_clz(n);
+#elif defined(_MSC_VER)
+
+  unsigned long where;
+  _BitScanReverse(&where, n);
+  return (int)where;
+#else
+  // TODO(fgalligan): Optimize this code.
+  int msb = -1;
+  while (n != 0) {
+    msb++;
+    n >>= 1;
+  }
+  return msb;
+#endif
+}
+
+// Helper function that converts signed integer values into unsigned integer
+// symbols that can be encoded using an entropy encoder.
+void ConvertSignedIntsToSymbols(const int32_t *in, int in_values,
+                                uint32_t *out);
+
+// Converts unsigned integer symbols encoded with an entropy encoder back to
+// signed values.
+void ConvertSymbolsToSignedInts(const uint32_t *in, int in_values,
+                                int32_t *out);
+
+// Helper function that converts a single signed integer value into an unsigned
+// integer symbol that can be encoded using an entropy encoder.
+template <class IntTypeT>
+typename std::make_unsigned<IntTypeT>::type ConvertSignedIntToSymbol(
+    IntTypeT val) {
+  typedef typename std::make_unsigned<IntTypeT>::type UnsignedType;
+  static_assert(std::is_integral<IntTypeT>::value, "IntTypeT is not integral.");
+  // Early exit if val is positive.
+  if (val >= 0) {
+    return static_cast<UnsignedType>(val) << 1;
+  }
+  val = -(val + 1);  // Map -1 to 0, -2 to -1, etc..
+  UnsignedType ret = static_cast<UnsignedType>(val);
+  ret <<= 1;
+  ret |= 1;
+  return ret;
+}
+
+// Converts a single unsigned integer symbol encoded with an entropy encoder
+// back to a signed value.
+template <class IntTypeT>
+typename std::make_signed<IntTypeT>::type ConvertSymbolToSignedInt(
+    IntTypeT val) {
+  static_assert(std::is_integral<IntTypeT>::value, "IntTypeT is not integral.");
+  typedef typename std::make_signed<IntTypeT>::type SignedType;
+  const bool is_positive = !static_cast<bool>(val & 1);
+  val >>= 1;
+  if (is_positive) {
+    return static_cast<SignedType>(val);
+  }
+  SignedType ret = static_cast<SignedType>(val);
+  ret = -ret - 1;
+  return ret;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_BIT_UTILS_H_
diff --git a/contrib/draco/src/draco/core/bounding_box.cc b/contrib/draco/src/draco/core/bounding_box.cc
new file mode 100644
index 000000000..8a0709678
--- /dev/null
+++ b/contrib/draco/src/draco/core/bounding_box.cc
@@ -0,0 +1,30 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "draco/core/bounding_box.h"
+
+namespace draco {
+
+BoundingBox::BoundingBox()
+    : BoundingBox(Vector3f(std::numeric_limits<float>::max(),
+                           std::numeric_limits<float>::max(),
+                           std::numeric_limits<float>::max()),
+                  Vector3f(-std::numeric_limits<float>::max(),
+                           -std::numeric_limits<float>::max(),
+                           -std::numeric_limits<float>::max())) {}
+
+BoundingBox::BoundingBox(const Vector3f &min_point, const Vector3f &max_point)
+    : min_point_(min_point), max_point_(max_point) {}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/bounding_box.h b/contrib/draco/src/draco/core/bounding_box.h
new file mode 100644
index 000000000..31ba2d683
--- /dev/null
+++ b/contrib/draco/src/draco/core/bounding_box.h
@@ -0,0 +1,72 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_BOUNDING_BOX_H_
+#define DRACO_CORE_BOUNDING_BOX_H_
+
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+// Class for computing the bounding box of points in 3D space.
+class BoundingBox {
+ public:
+  // Creates bounding box object with minimum and maximum points initialized to
+  // the largest positive and the smallest negative values, respectively. The
+  // resulting abstract bounding box effectively has no points and can be
+  // updated by providing any point to Update() method.
+  BoundingBox();
+
+  // Creates bounding box object with minimum and maximum points initialized to
+  // |min_point| and |max_point|, respectively.
+  BoundingBox(const Vector3f &min_point, const Vector3f &max_point);
+
+  // Returns the minimum point of the bounding box.
+  inline const Vector3f &GetMinPoint() const { return min_point_; }
+
+  // Returns the maximum point of the bounding box.
+  inline const Vector3f &GetMaxPoint() const { return max_point_; }
+
+  // Conditionally updates the bounding box with a given |new_point|.
+  void Update(const Vector3f &new_point) {
+    for (int i = 0; i < 3; i++) {
+      if (new_point[i] < min_point_[i]) {
+        min_point_[i] = new_point[i];
+      }
+      if (new_point[i] > max_point_[i]) {
+        max_point_[i] = new_point[i];
+      }
+    }
+  }
+
+  // Updates bounding box with minimum and maximum points of the |other|
+  // bounding box.
+  void Update(const BoundingBox &other) {
+    Update(other.GetMinPoint());
+    Update(other.GetMaxPoint());
+  }
+
+  // Returns the size of the bounding box along each axis.
+  Vector3f Size() const { return max_point_ - min_point_; }
+
+  // Returns the center of the bounding box.
+  Vector3f Center() const { return (min_point_ + max_point_) / 2; }
+
+ private:
+  Vector3f min_point_;
+  Vector3f max_point_;
+};
+}  // namespace draco
+
+#endif  //  DRACO_CORE_BOUNDING_BOX_H_
diff --git a/contrib/draco/src/draco/core/buffer_bit_coding_test.cc b/contrib/draco/src/draco/core/buffer_bit_coding_test.cc
new file mode 100644
index 000000000..892b35b4f
--- /dev/null
+++ b/contrib/draco/src/draco/core/buffer_bit_coding_test.cc
@@ -0,0 +1,115 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+class BufferBitCodingTest : public ::testing::Test {
+ public:
+  typedef DecoderBuffer::BitDecoder BitDecoder;
+  typedef EncoderBuffer::BitEncoder BitEncoder;
+};
+
+TEST_F(BufferBitCodingTest, TestBitCodersByteAligned) {
+  constexpr int buffer_size = 32;
+  char buffer[buffer_size];
+  BitEncoder encoder(buffer);
+  const uint8_t data[] = {0x76, 0x54, 0x32, 0x10, 0x76, 0x54, 0x32, 0x10};
+  const int bytes_to_encode = sizeof(data);
+
+  for (int i = 0; i < bytes_to_encode; ++i) {
+    encoder.PutBits(data[i], sizeof(data[i]) * 8);
+    ASSERT_EQ((i + 1) * sizeof(data[i]) * 8, encoder.Bits());
+  }
+
+  BitDecoder decoder;
+  decoder.reset(static_cast<const void *>(buffer), bytes_to_encode);
+  for (int i = 0; i < bytes_to_encode; ++i) {
+    uint32_t x = 0;
+    ASSERT_TRUE(decoder.GetBits(8, &x));
+    ASSERT_EQ(x, data[i]);
+  }
+
+  ASSERT_EQ(bytes_to_encode * 8u, decoder.BitsDecoded());
+}
+
+TEST_F(BufferBitCodingTest, TestBitCodersNonByte) {
+  constexpr int buffer_size = 32;
+  char buffer[buffer_size];
+  BitEncoder encoder(buffer);
+  const uint8_t data[] = {0x76, 0x54, 0x32, 0x10, 0x76, 0x54, 0x32, 0x10};
+  const uint32_t bits_to_encode = 51;
+  const int bytes_to_encode = (bits_to_encode / 8) + 1;
+
+  for (int i = 0; i < bytes_to_encode; ++i) {
+    const int num_bits = (encoder.Bits() + 8 <= bits_to_encode)
+                             ? 8
+                             : bits_to_encode - encoder.Bits();
+    encoder.PutBits(data[i], num_bits);
+  }
+
+  BitDecoder decoder;
+  decoder.reset(static_cast<const void *>(buffer), bytes_to_encode);
+  int64_t bits_to_decode = encoder.Bits();
+  for (int i = 0; i < bytes_to_encode; ++i) {
+    uint32_t x = 0;
+    const int num_bits = (bits_to_decode > 8) ? 8 : bits_to_decode;
+    ASSERT_TRUE(decoder.GetBits(num_bits, &x));
+    const int bits_to_shift = 8 - num_bits;
+    const uint8_t test_byte =
+        ((data[i] << bits_to_shift) & 0xff) >> bits_to_shift;
+    ASSERT_EQ(x, test_byte);
+    bits_to_decode -= 8;
+  }
+
+  ASSERT_EQ(bits_to_encode, decoder.BitsDecoded());
+}
+
+TEST_F(BufferBitCodingTest, TestSingleBits) {
+  const int data = 0xaaaa;
+
+  BitDecoder decoder;
+  decoder.reset(static_cast<const void *>(&data), sizeof(data));
+
+  for (uint32_t i = 0; i < 16; ++i) {
+    uint32_t x = 0;
+    ASSERT_TRUE(decoder.GetBits(1, &x));
+    ASSERT_EQ(x, (i % 2));
+  }
+
+  ASSERT_EQ(16u, decoder.BitsDecoded());
+}
+
+TEST_F(BufferBitCodingTest, TestMultipleBits) {
+  const uint8_t data[] = {0x76, 0x54, 0x32, 0x10, 0x76, 0x54, 0x32, 0x10};
+
+  BitDecoder decoder;
+  decoder.reset(static_cast<const void *>(data), sizeof(data));
+
+  uint32_t x = 0;
+  for (uint32_t i = 0; i < 2; ++i) {
+    ASSERT_TRUE(decoder.GetBits(16, &x));
+    ASSERT_EQ(x, 0x5476u);
+    ASSERT_EQ(16 + (i * 32), decoder.BitsDecoded());
+
+    ASSERT_TRUE(decoder.GetBits(16, &x));
+    ASSERT_EQ(x, 0x1032u);
+    ASSERT_EQ(32 + (i * 32), decoder.BitsDecoded());
+  }
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/cycle_timer.cc b/contrib/draco/src/draco/core/cycle_timer.cc
new file mode 100644
index 000000000..94b4b28b2
--- /dev/null
+++ b/contrib/draco/src/draco/core/cycle_timer.cc
@@ -0,0 +1,49 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/cycle_timer.h"
+
+namespace draco {
+void DracoTimer::Start() {
+#ifdef _WIN32
+  QueryPerformanceCounter(&tv_start);
+#else
+  gettimeofday(&tv_start, nullptr);
+#endif
+}
+
+void DracoTimer::Stop() {
+#ifdef _WIN32
+  QueryPerformanceCounter(&tv_end);
+#else
+  gettimeofday(&tv_end, nullptr);
+#endif
+}
+
+int64_t DracoTimer::GetInMs() {
+#ifdef _WIN32
+  LARGE_INTEGER elapsed = {0};
+  elapsed.QuadPart = tv_end.QuadPart - tv_start.QuadPart;
+
+  LARGE_INTEGER frequency = {0};
+  QueryPerformanceFrequency(&frequency);
+  return elapsed.QuadPart * 1000 / frequency.QuadPart;
+#else
+  const int64_t seconds = (tv_end.tv_sec - tv_start.tv_sec) * 1000;
+  const int64_t milliseconds = (tv_end.tv_usec - tv_start.tv_usec) / 1000;
+  return seconds + milliseconds;
+#endif
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/cycle_timer.h b/contrib/draco/src/draco/core/cycle_timer.h
new file mode 100644
index 000000000..172f1c2e9
--- /dev/null
+++ b/contrib/draco/src/draco/core/cycle_timer.h
@@ -0,0 +1,50 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_CYCLE_TIMER_H_
+#define DRACO_CORE_CYCLE_TIMER_H_
+
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+typedef LARGE_INTEGER timeval;
+#else
+#include <sys/time.h>
+#endif
+
+#include <cinttypes>
+#include <cstddef>
+
+namespace draco {
+
+class DracoTimer {
+ public:
+  DracoTimer() {}
+  ~DracoTimer() {}
+  void Start();
+  void Stop();
+  int64_t GetInMs();
+
+ private:
+  timeval tv_start;
+  timeval tv_end;
+};
+
+typedef DracoTimer CycleTimer;
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_CYCLE_TIMER_H_
diff --git a/contrib/draco/src/draco/core/data_buffer.cc b/contrib/draco/src/draco/core/data_buffer.cc
new file mode 100644
index 000000000..f0b43d67d
--- /dev/null
+++ b/contrib/draco/src/draco/core/data_buffer.cc
@@ -0,0 +1,61 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/data_buffer.h"
+
+#include <algorithm>
+
+namespace draco {
+
+DataBuffer::DataBuffer() {}
+
+bool DataBuffer::Update(const void *data, int64_t size) {
+  const int64_t offset = 0;
+  return this->Update(data, size, offset);
+}
+
+bool DataBuffer::Update(const void *data, int64_t size, int64_t offset) {
+  if (data == nullptr) {
+    if (size + offset < 0) {
+      return false;
+    }
+    // If no data is provided, just resize the buffer.
+    data_.resize(size + offset);
+  } else {
+    if (size < 0) {
+      return false;
+    }
+    if (size + offset > static_cast<int64_t>(data_.size())) {
+      data_.resize(size + offset);
+    }
+    const uint8_t *const byte_data = static_cast<const uint8_t *>(data);
+    std::copy(byte_data, byte_data + size, data_.data() + offset);
+  }
+  descriptor_.buffer_update_count++;
+  return true;
+}
+
+void DataBuffer::Resize(int64_t size) {
+  data_.resize(size);
+  descriptor_.buffer_update_count++;
+}
+
+void DataBuffer::WriteDataToStream(std::ostream &stream) {
+  if (data_.size() == 0) {
+    return;
+  }
+  stream.write(reinterpret_cast<char *>(data_.data()), data_.size());
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/data_buffer.h b/contrib/draco/src/draco/core/data_buffer.h
new file mode 100644
index 000000000..8ee690540
--- /dev/null
+++ b/contrib/draco/src/draco/core/data_buffer.h
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DATA_BUFFER_H_
+#define DRACO_CORE_DATA_BUFFER_H_
+
+#include <cstring>
+#include <ostream>
+#include <vector>
+
+#include "draco/core/draco_types.h"
+
+namespace draco {
+
+// Buffer descriptor servers as a unique identifier of a buffer.
+struct DataBufferDescriptor {
+  DataBufferDescriptor() : buffer_id(0), buffer_update_count(0) {}
+  // Id of the data buffer.
+  int64_t buffer_id;
+  // The number of times the buffer content was updated.
+  int64_t buffer_update_count;
+};
+
+// Class used for storing raw buffer data.
+class DataBuffer {
+ public:
+  DataBuffer();
+  bool Update(const void *data, int64_t size);
+  bool Update(const void *data, int64_t size, int64_t offset);
+
+  // Reallocate the buffer storage to a new size keeping the data unchanged.
+  void Resize(int64_t new_size);
+  void WriteDataToStream(std::ostream &stream);
+  // Reads data from the buffer. Potentially unsafe, called needs to ensure
+  // the accessed memory is valid.
+  void Read(int64_t byte_pos, void *out_data, size_t data_size) const {
+    memcpy(out_data, data() + byte_pos, data_size);
+  }
+
+  // Writes data to the buffer. Unsafe, caller must ensure the accessed memory
+  // is valid.
+  void Write(int64_t byte_pos, const void *in_data, size_t data_size) {
+    memcpy(const_cast<uint8_t *>(data()) + byte_pos, in_data, data_size);
+  }
+
+  // Copies data from another buffer to this buffer.
+  void Copy(int64_t dst_offset, const DataBuffer *src_buf, int64_t src_offset,
+            int64_t size) {
+    memcpy(const_cast<uint8_t *>(data()) + dst_offset,
+           src_buf->data() + src_offset, size);
+  }
+
+  void set_update_count(int64_t buffer_update_count) {
+    descriptor_.buffer_update_count = buffer_update_count;
+  }
+  int64_t update_count() const { return descriptor_.buffer_update_count; }
+  size_t data_size() const { return data_.size(); }
+  const uint8_t *data() const { return data_.data(); }
+  uint8_t *data() { return &data_[0]; }
+  int64_t buffer_id() const { return descriptor_.buffer_id; }
+  void set_buffer_id(int64_t buffer_id) { descriptor_.buffer_id = buffer_id; }
+
+ private:
+  std::vector<uint8_t> data_;
+  // Counter incremented by Update() calls.
+  DataBufferDescriptor descriptor_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DATA_BUFFER_H_
diff --git a/contrib/draco/src/draco/core/decoder_buffer.cc b/contrib/draco/src/draco/core/decoder_buffer.cc
new file mode 100644
index 000000000..4e8ed618d
--- /dev/null
+++ b/contrib/draco/src/draco/core/decoder_buffer.cc
@@ -0,0 +1,72 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/decoder_buffer.h"
+
+#include "draco/core/macros.h"
+#include "draco/core/varint_decoding.h"
+
+namespace draco {
+
+DecoderBuffer::DecoderBuffer()
+    : data_(nullptr),
+      data_size_(0),
+      pos_(0),
+      bit_mode_(false),
+      bitstream_version_(0) {}
+
+void DecoderBuffer::Init(const char *data, size_t data_size) {
+  Init(data, data_size, bitstream_version_);
+}
+
+void DecoderBuffer::Init(const char *data, size_t data_size, uint16_t version) {
+  data_ = data;
+  data_size_ = data_size;
+  bitstream_version_ = version;
+  pos_ = 0;
+}
+
+bool DecoderBuffer::StartBitDecoding(bool decode_size, uint64_t *out_size) {
+  if (decode_size) {
+#ifdef DRACO_BACKWARDS_COMPATIBILITY_SUPPORTED
+    if (bitstream_version_ < DRACO_BITSTREAM_VERSION(2, 2)) {
+      if (!Decode(out_size)) {
+        return false;
+      }
+    } else
+#endif
+    {
+      if (!DecodeVarint(out_size, this)) {
+        return false;
+      }
+    }
+  }
+  bit_mode_ = true;
+  bit_decoder_.reset(data_head(), remaining_size());
+  return true;
+}
+
+void DecoderBuffer::EndBitDecoding() {
+  bit_mode_ = false;
+  const uint64_t bits_decoded = bit_decoder_.BitsDecoded();
+  const uint64_t bytes_decoded = (bits_decoded + 7) / 8;
+  pos_ += bytes_decoded;
+}
+
+DecoderBuffer::BitDecoder::BitDecoder()
+    : bit_buffer_(nullptr), bit_buffer_end_(nullptr), bit_offset_(0) {}
+
+DecoderBuffer::BitDecoder::~BitDecoder() {}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/decoder_buffer.h b/contrib/draco/src/draco/core/decoder_buffer.h
new file mode 100644
index 000000000..0559abbe4
--- /dev/null
+++ b/contrib/draco/src/draco/core/decoder_buffer.h
@@ -0,0 +1,216 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DECODER_BUFFER_H_
+#define DRACO_CORE_DECODER_BUFFER_H_
+
+#include <stdint.h>
+
+#include <cstring>
+#include <memory>
+
+#include "draco/core/macros.h"
+#include "draco/draco_features.h"
+
+namespace draco {
+
+// Class is a wrapper around input data used by MeshDecoder. It provides a
+// basic interface for decoding either typed or variable-bit sized data.
+class DecoderBuffer {
+ public:
+  DecoderBuffer();
+  DecoderBuffer(const DecoderBuffer &buf) = default;
+
+  DecoderBuffer &operator=(const DecoderBuffer &buf) = default;
+
+  // Sets the buffer's internal data. Note that no copy of the input data is
+  // made so the data owner needs to keep the data valid and unchanged for
+  // runtime of the decoder.
+  void Init(const char *data, size_t data_size);
+
+  // Sets the buffer's internal data. |version| is the Draco bitstream version.
+  void Init(const char *data, size_t data_size, uint16_t version);
+
+  // Starts decoding a bit sequence.
+  // decode_size must be true if the size of the encoded bit data was included,
+  // during encoding. The size is then returned to out_size.
+  // Returns false on error.
+  bool StartBitDecoding(bool decode_size, uint64_t *out_size);
+
+  // Ends the decoding of the bit sequence and return to the default
+  // byte-aligned decoding.
+  void EndBitDecoding();
+
+  // Decodes up to 32 bits into out_val. Can be called only in between
+  // StartBitDecoding and EndBitDecoding. Otherwise returns false.
+  bool DecodeLeastSignificantBits32(int nbits, uint32_t *out_value) {
+    if (!bit_decoder_active()) {
+      return false;
+    }
+    bit_decoder_.GetBits(nbits, out_value);
+    return true;
+  }
+
+  // Decodes an arbitrary data type.
+  // Can be used only when we are not decoding a bit-sequence.
+  // Returns false on error.
+  template <typename T>
+  bool Decode(T *out_val) {
+    if (!Peek(out_val)) {
+      return false;
+    }
+    pos_ += sizeof(T);
+    return true;
+  }
+
+  bool Decode(void *out_data, size_t size_to_decode) {
+    if (data_size_ < static_cast<int64_t>(pos_ + size_to_decode)) {
+      return false;  // Buffer overflow.
+    }
+    memcpy(out_data, (data_ + pos_), size_to_decode);
+    pos_ += size_to_decode;
+    return true;
+  }
+
+  // Decodes an arbitrary data, but does not advance the reading position.
+  template <typename T>
+  bool Peek(T *out_val) {
+    const size_t size_to_decode = sizeof(T);
+    if (data_size_ < static_cast<int64_t>(pos_ + size_to_decode)) {
+      return false;  // Buffer overflow.
+    }
+    memcpy(out_val, (data_ + pos_), size_to_decode);
+    return true;
+  }
+
+  bool Peek(void *out_data, size_t size_to_peek) {
+    if (data_size_ < static_cast<int64_t>(pos_ + size_to_peek)) {
+      return false;  // Buffer overflow.
+    }
+    memcpy(out_data, (data_ + pos_), size_to_peek);
+    return true;
+  }
+
+  // Discards #bytes from the input buffer.
+  void Advance(int64_t bytes) { pos_ += bytes; }
+
+  // Moves the parsing position to a specific offset from the beginning of the
+  // input data.
+  void StartDecodingFrom(int64_t offset) { pos_ = offset; }
+
+  void set_bitstream_version(uint16_t version) { bitstream_version_ = version; }
+
+  // Returns the data array at the current decoder position.
+  const char *data_head() const { return data_ + pos_; }
+  int64_t remaining_size() const { return data_size_ - pos_; }
+  int64_t decoded_size() const { return pos_; }
+  bool bit_decoder_active() const { return bit_mode_; }
+
+  // Returns the bitstream associated with the data. Returns 0 if unknown.
+  uint16_t bitstream_version() const { return bitstream_version_; }
+
+ private:
+  // Internal helper class to decode bits from a bit buffer.
+  class BitDecoder {
+   public:
+    BitDecoder();
+    ~BitDecoder();
+
+    // Sets the bit buffer to |b|. |s| is the size of |b| in bytes.
+    inline void reset(const void *b, size_t s) {
+      bit_offset_ = 0;
+      bit_buffer_ = static_cast<const uint8_t *>(b);
+      bit_buffer_end_ = bit_buffer_ + s;
+    }
+
+    // Returns number of bits decoded so far.
+    inline uint64_t BitsDecoded() const {
+      return static_cast<uint64_t>(bit_offset_);
+    }
+
+    // Return number of bits available for decoding
+    inline uint64_t AvailBits() const {
+      return ((bit_buffer_end_ - bit_buffer_) * 8) - bit_offset_;
+    }
+
+    inline uint32_t EnsureBits(int k) {
+      DRACO_DCHECK_LE(k, 24);
+      DRACO_DCHECK_LE(static_cast<uint64_t>(k), AvailBits());
+
+      uint32_t buf = 0;
+      for (int i = 0; i < k; ++i) {
+        buf |= PeekBit(i) << i;
+      }
+      return buf;  // Okay to return extra bits
+    }
+
+    inline void ConsumeBits(int k) { bit_offset_ += k; }
+
+    // Returns |nbits| bits in |x|.
+    inline bool GetBits(int32_t nbits, uint32_t *x) {
+      DRACO_DCHECK_GE(nbits, 0);
+      DRACO_DCHECK_LE(nbits, 32);
+      uint32_t value = 0;
+      for (int32_t bit = 0; bit < nbits; ++bit) {
+        value |= GetBit() << bit;
+      }
+      *x = value;
+      return true;
+    }
+
+   private:
+    // TODO(fgalligan): Add support for error reporting on range check.
+    // Returns one bit from the bit buffer.
+    inline int GetBit() {
+      const size_t off = bit_offset_;
+      const size_t byte_offset = off >> 3;
+      const int bit_shift = static_cast<int>(off & 0x7);
+      if (bit_buffer_ + byte_offset < bit_buffer_end_) {
+        const int bit = (bit_buffer_[byte_offset] >> bit_shift) & 1;
+        bit_offset_ = off + 1;
+        return bit;
+      }
+      return 0;
+    }
+
+    inline int PeekBit(int offset) {
+      const size_t off = bit_offset_ + offset;
+      const size_t byte_offset = off >> 3;
+      const int bit_shift = static_cast<int>(off & 0x7);
+      if (bit_buffer_ + byte_offset < bit_buffer_end_) {
+        const int bit = (bit_buffer_[byte_offset] >> bit_shift) & 1;
+        return bit;
+      }
+      return 0;
+    }
+
+    const uint8_t *bit_buffer_;
+    const uint8_t *bit_buffer_end_;
+    size_t bit_offset_;
+  };
+  friend class BufferBitCodingTest;
+
+  const char *data_;
+  int64_t data_size_;
+
+  // Current parsing position of the decoder.
+  int64_t pos_;
+  BitDecoder bit_decoder_;
+  bool bit_mode_;
+  uint16_t bitstream_version_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DECODER_BUFFER_H_
diff --git a/contrib/draco/src/draco/core/divide.cc b/contrib/draco/src/draco/core/divide.cc
new file mode 100644
index 000000000..6d2e57120
--- /dev/null
+++ b/contrib/draco/src/draco/core/divide.cc
@@ -0,0 +1,88 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is based off libvpx's divide.c.
+
+#include "draco/core/divide.h"
+
+namespace draco {
+
+const struct fastdiv_elem vp10_fastdiv_tab[256] = {
+    {0, 0},          {0, 0},          {0, 1},          {1431655766, 2},
+    {0, 2},          {2576980378, 3}, {1431655766, 3}, {613566757, 3},
+    {0, 3},          {3340530120, 4}, {2576980378, 4}, {1952257862, 4},
+    {1431655766, 4}, {991146300, 4},  {613566757, 4},  {286331154, 4},
+    {0, 4},          {3789677026, 5}, {3340530120, 5}, {2938661835, 5},
+    {2576980378, 5}, {2249744775, 5}, {1952257862, 5}, {1680639377, 5},
+    {1431655766, 5}, {1202590843, 5}, {991146300, 5},  {795364315, 5},
+    {613566757, 5},  {444306962, 5},  {286331154, 5},  {138547333, 5},
+    {0, 5},          {4034666248, 6}, {3789677026, 6}, {3558687189, 6},
+    {3340530120, 6}, {3134165325, 6}, {2938661835, 6}, {2753184165, 6},
+    {2576980378, 6}, {2409371898, 6}, {2249744775, 6}, {2097542168, 6},
+    {1952257862, 6}, {1813430637, 6}, {1680639377, 6}, {1553498810, 6},
+    {1431655766, 6}, {1314785907, 6}, {1202590843, 6}, {1094795586, 6},
+    {991146300, 6},  {891408307, 6},  {795364315, 6},  {702812831, 6},
+    {613566757, 6},  {527452125, 6},  {444306962, 6},  {363980280, 6},
+    {286331154, 6},  {211227900, 6},  {138547333, 6},  {68174085, 6},
+    {0, 6},          {4162814457, 7}, {4034666248, 7}, {3910343360, 7},
+    {3789677026, 7}, {3672508268, 7}, {3558687189, 7}, {3448072337, 7},
+    {3340530120, 7}, {3235934265, 7}, {3134165325, 7}, {3035110223, 7},
+    {2938661835, 7}, {2844718599, 7}, {2753184165, 7}, {2663967058, 7},
+    {2576980378, 7}, {2492141518, 7}, {2409371898, 7}, {2328596727, 7},
+    {2249744775, 7}, {2172748162, 7}, {2097542168, 7}, {2024065048, 7},
+    {1952257862, 7}, {1882064321, 7}, {1813430637, 7}, {1746305385, 7},
+    {1680639377, 7}, {1616385542, 7}, {1553498810, 7}, {1491936009, 7},
+    {1431655766, 7}, {1372618415, 7}, {1314785907, 7}, {1258121734, 7},
+    {1202590843, 7}, {1148159575, 7}, {1094795586, 7}, {1042467791, 7},
+    {991146300, 7},  {940802361, 7},  {891408307, 7},  {842937507, 7},
+    {795364315, 7},  {748664025, 7},  {702812831, 7},  {657787785, 7},
+    {613566757, 7},  {570128403, 7},  {527452125, 7},  {485518043, 7},
+    {444306962, 7},  {403800345, 7},  {363980280, 7},  {324829460, 7},
+    {286331154, 7},  {248469183, 7},  {211227900, 7},  {174592167, 7},
+    {138547333, 7},  {103079216, 7},  {68174085, 7},   {33818641, 7},
+    {0, 7},          {4228378656, 8}, {4162814457, 8}, {4098251237, 8},
+    {4034666248, 8}, {3972037425, 8}, {3910343360, 8}, {3849563281, 8},
+    {3789677026, 8}, {3730665024, 8}, {3672508268, 8}, {3615188300, 8},
+    {3558687189, 8}, {3502987511, 8}, {3448072337, 8}, {3393925206, 8},
+    {3340530120, 8}, {3287871517, 8}, {3235934265, 8}, {3184703642, 8},
+    {3134165325, 8}, {3084305374, 8}, {3035110223, 8}, {2986566663, 8},
+    {2938661835, 8}, {2891383213, 8}, {2844718599, 8}, {2798656110, 8},
+    {2753184165, 8}, {2708291480, 8}, {2663967058, 8}, {2620200175, 8},
+    {2576980378, 8}, {2534297473, 8}, {2492141518, 8}, {2450502814, 8},
+    {2409371898, 8}, {2368739540, 8}, {2328596727, 8}, {2288934667, 8},
+    {2249744775, 8}, {2211018668, 8}, {2172748162, 8}, {2134925265, 8},
+    {2097542168, 8}, {2060591247, 8}, {2024065048, 8}, {1987956292, 8},
+    {1952257862, 8}, {1916962805, 8}, {1882064321, 8}, {1847555765, 8},
+    {1813430637, 8}, {1779682582, 8}, {1746305385, 8}, {1713292966, 8},
+    {1680639377, 8}, {1648338801, 8}, {1616385542, 8}, {1584774030, 8},
+    {1553498810, 8}, {1522554545, 8}, {1491936009, 8}, {1461638086, 8},
+    {1431655766, 8}, {1401984144, 8}, {1372618415, 8}, {1343553873, 8},
+    {1314785907, 8}, {1286310003, 8}, {1258121734, 8}, {1230216764, 8},
+    {1202590843, 8}, {1175239808, 8}, {1148159575, 8}, {1121346142, 8},
+    {1094795586, 8}, {1068504060, 8}, {1042467791, 8}, {1016683080, 8},
+    {991146300, 8},  {965853890, 8},  {940802361, 8},  {915988286, 8},
+    {891408307, 8},  {867059126, 8},  {842937507, 8},  {819040276, 8},
+    {795364315, 8},  {771906565, 8},  {748664025, 8},  {725633745, 8},
+    {702812831, 8},  {680198441, 8},  {657787785, 8},  {635578121, 8},
+    {613566757, 8},  {591751050, 8},  {570128403, 8},  {548696263, 8},
+    {527452125, 8},  {506393524, 8},  {485518043, 8},  {464823301, 8},
+    {444306962, 8},  {423966729, 8},  {403800345, 8},  {383805589, 8},
+    {363980280, 8},  {344322273, 8},  {324829460, 8},  {305499766, 8},
+    {286331154, 8},  {267321616, 8},  {248469183, 8},  {229771913, 8},
+    {211227900, 8},  {192835267, 8},  {174592167, 8},  {156496785, 8},
+    {138547333, 8},  {120742053, 8},  {103079216, 8},  {85557118, 8},
+    {68174085, 8},   {50928466, 8},   {33818641, 8},   {16843010, 8},
+};
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/divide.h b/contrib/draco/src/draco/core/divide.h
new file mode 100644
index 000000000..7e3838a00
--- /dev/null
+++ b/contrib/draco/src/draco/core/divide.h
@@ -0,0 +1,42 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DIVIDE_H_
+#define DRACO_CORE_DIVIDE_H_
+// An implementation of the divide by multiply algorithm
+// https://gmplib.org/~tege/divcnst-pldi94.pdf
+// This file is based off libvpx's divide.h.
+
+#include <stdint.h>
+
+#include <climits>
+
+namespace draco {
+
+struct fastdiv_elem {
+  unsigned mult;
+  unsigned shift;
+};
+
+extern const struct fastdiv_elem vp10_fastdiv_tab[256];
+
+static inline unsigned fastdiv(unsigned x, int y) {
+  unsigned t =
+      ((uint64_t)x * vp10_fastdiv_tab[y].mult) >> (sizeof(x) * CHAR_BIT);
+  return (t + x) >> vp10_fastdiv_tab[y].shift;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DIVIDE_H_
diff --git a/contrib/draco/src/draco/core/draco_index_type.h b/contrib/draco/src/draco/core/draco_index_type.h
new file mode 100644
index 000000000..d9dd3f64f
--- /dev/null
+++ b/contrib/draco/src/draco/core/draco_index_type.h
@@ -0,0 +1,183 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This files provides a basic framework for strongly typed indices that are
+// used within the Draco library. The motivation of using strongly typed indices
+// is to prevent bugs caused by mixing up incompatible indices, such as indexing
+// mesh faces with point indices and vice versa.
+//
+// Usage:
+//      Define strongly typed index using macro:
+//
+//        DEFINE_NEW_DRACO_INDEX_TYPE(value_type, name)
+//
+//      where |value_type| is the data type of the index value (such as int32_t)
+//      and |name| is a unique typename of the new index.
+//
+//      E.g., we can define new index types as:
+//
+//        DEFINE_NEW_DRACO_INDEX_TYPE(int, PointIndex)
+//        DEFINE_NEW_DRACO_INDEX_TYPE(int, FaceIndex)
+//
+//      The new types can then be used in the similar way as the regular weakly
+//      typed indices (such as int32, int64, ...), but they cannot be
+//      accidentally misassigned. E.g.:
+//
+//        PointIndex point_index(10);
+//        FaceIndex face_index;
+//        face_index = point_index;  // Compile error!
+//
+//      One can still cast one type to another explicitly by accessing the index
+//      value directly using the .value() method:
+//
+//        face_index = FaceIndex(point_index.value());  // Compiles OK.
+//
+//      Strongly typed indices support most of the common binary and unary
+//      operators and support for additional operators can be added if
+//      necessary.
+
+#ifndef DRACO_CORE_DRACO_INDEX_TYPE_H_
+#define DRACO_CORE_DRACO_INDEX_TYPE_H_
+
+#include <ostream>
+
+#include "draco/draco_features.h"
+
+namespace draco {
+
+#define DEFINE_NEW_DRACO_INDEX_TYPE(value_type, name) \
+  struct name##_tag_type_ {};                         \
+  typedef IndexType<value_type, name##_tag_type_> name;
+
+template <class ValueTypeT, class TagT>
+class IndexType {
+ public:
+  typedef IndexType<ValueTypeT, TagT> ThisIndexType;
+  typedef ValueTypeT ValueType;
+
+  constexpr IndexType() : value_(ValueTypeT()) {}
+  constexpr explicit IndexType(ValueTypeT value) : value_(value) {}
+
+  constexpr ValueTypeT value() const { return value_; }
+
+  constexpr bool operator==(const IndexType &i) const {
+    return value_ == i.value_;
+  }
+  constexpr bool operator==(const ValueTypeT &val) const {
+    return value_ == val;
+  }
+  constexpr bool operator!=(const IndexType &i) const {
+    return value_ != i.value_;
+  }
+  constexpr bool operator!=(const ValueTypeT &val) const {
+    return value_ != val;
+  }
+  constexpr bool operator<(const IndexType &i) const {
+    return value_ < i.value_;
+  }
+  constexpr bool operator<(const ValueTypeT &val) const { return value_ < val; }
+  constexpr bool operator>(const IndexType &i) const {
+    return value_ > i.value_;
+  }
+  constexpr bool operator>(const ValueTypeT &val) const { return value_ > val; }
+  constexpr bool operator>=(const IndexType &i) const {
+    return value_ >= i.value_;
+  }
+  constexpr bool operator>=(const ValueTypeT &val) const {
+    return value_ >= val;
+  }
+
+  inline ThisIndexType &operator++() {
+    ++value_;
+    return *this;
+  }
+  inline ThisIndexType operator++(int) {
+    const ThisIndexType ret(value_);
+    ++value_;
+    return ret;
+  }
+
+  inline ThisIndexType &operator--() {
+    --value_;
+    return *this;
+  }
+  inline ThisIndexType operator--(int) {
+    const ThisIndexType ret(value_);
+    --value_;
+    return ret;
+  }
+
+  constexpr ThisIndexType operator+(const IndexType &i) const {
+    return ThisIndexType(value_ + i.value_);
+  }
+  constexpr ThisIndexType operator+(const ValueTypeT &val) const {
+    return ThisIndexType(value_ + val);
+  }
+  constexpr ThisIndexType operator-(const IndexType &i) const {
+    return ThisIndexType(value_ - i.value_);
+  }
+  constexpr ThisIndexType operator-(const ValueTypeT &val) const {
+    return ThisIndexType(value_ - val);
+  }
+
+  inline ThisIndexType &operator+=(const IndexType &i) {
+    value_ += i.value_;
+    return *this;
+  }
+  inline ThisIndexType operator+=(const ValueTypeT &val) {
+    value_ += val;
+    return *this;
+  }
+  inline ThisIndexType &operator-=(const IndexType &i) {
+    value_ -= i.value_;
+    return *this;
+  }
+  inline ThisIndexType operator-=(const ValueTypeT &val) {
+    value_ -= val;
+    return *this;
+  }
+  inline ThisIndexType &operator=(const ThisIndexType &i) {
+    value_ = i.value_;
+    return *this;
+  }
+  inline ThisIndexType &operator=(const ValueTypeT &val) {
+    value_ = val;
+    return *this;
+  }
+
+ private:
+  ValueTypeT value_;
+};
+
+// Stream operator << provided for logging purposes.
+template <class ValueTypeT, class TagT>
+std::ostream &operator<<(std::ostream &os, IndexType<ValueTypeT, TagT> index) {
+  return os << index.value();
+}
+
+}  // namespace draco
+
+// Specialize std::hash for the strongly indexed types.
+namespace std {
+
+template <class ValueTypeT, class TagT>
+struct hash<draco::IndexType<ValueTypeT, TagT>> {
+  size_t operator()(const draco::IndexType<ValueTypeT, TagT> &i) const {
+    return static_cast<size_t>(i.value());
+  }
+};
+
+}  // namespace std
+
+#endif  // DRACO_CORE_DRACO_INDEX_TYPE_H_
diff --git a/contrib/draco/src/draco/core/draco_index_type_vector.h b/contrib/draco/src/draco/core/draco_index_type_vector.h
new file mode 100644
index 000000000..aae1e7aaf
--- /dev/null
+++ b/contrib/draco/src/draco/core/draco_index_type_vector.h
@@ -0,0 +1,83 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DRACO_INDEX_TYPE_VECTOR_H_
+#define DRACO_CORE_DRACO_INDEX_TYPE_VECTOR_H_
+
+#include <cstddef>
+#include <utility>
+#include <vector>
+
+#include "draco/core/draco_index_type.h"
+
+namespace draco {
+
+// A wrapper around the standard std::vector that supports indexing of the
+// vector entries using the strongly typed indices as defined in
+// draco_index_type.h .
+// TODO(ostava): Make the interface more complete. It's currently missing
+// features such as iterators.
+// TODO(vytyaz): Add more unit tests for this class.
+template <class IndexTypeT, class ValueTypeT>
+class IndexTypeVector {
+ public:
+  typedef typename std::vector<ValueTypeT>::const_reference const_reference;
+  typedef typename std::vector<ValueTypeT>::reference reference;
+
+  IndexTypeVector() {}
+  explicit IndexTypeVector(size_t size) : vector_(size) {}
+  IndexTypeVector(size_t size, const ValueTypeT &val) : vector_(size, val) {}
+
+  void clear() { vector_.clear(); }
+  void reserve(size_t size) { vector_.reserve(size); }
+  void resize(size_t size) { vector_.resize(size); }
+  void resize(size_t size, const ValueTypeT &val) { vector_.resize(size, val); }
+  void assign(size_t size, const ValueTypeT &val) { vector_.assign(size, val); }
+
+  void swap(IndexTypeVector<IndexTypeT, ValueTypeT> &arg) {
+    vector_.swap(arg.vector_);
+  }
+
+  size_t size() const { return vector_.size(); }
+  bool empty() const { return vector_.empty(); }
+
+  void push_back(const ValueTypeT &val) { vector_.push_back(val); }
+  void push_back(ValueTypeT &&val) { vector_.push_back(std::move(val)); }
+
+  template <typename... Args>
+  void emplace_back(Args &&...args) {
+    vector_.emplace_back(std::forward<Args>(args)...);
+  }
+
+  inline reference operator[](const IndexTypeT &index) {
+    return vector_[index.value()];
+  }
+  inline const_reference operator[](const IndexTypeT &index) const {
+    return vector_[index.value()];
+  }
+  inline reference at(const IndexTypeT &index) {
+    return vector_[index.value()];
+  }
+  inline const_reference at(const IndexTypeT &index) const {
+    return vector_[index.value()];
+  }
+  const ValueTypeT *data() const { return vector_.data(); }
+
+ private:
+  std::vector<ValueTypeT> vector_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DRACO_INDEX_TYPE_VECTOR_H_
diff --git a/contrib/draco/src/draco/core/draco_test_base.h b/contrib/draco/src/draco/core/draco_test_base.h
new file mode 100644
index 000000000..f5c9d751e
--- /dev/null
+++ b/contrib/draco/src/draco/core/draco_test_base.h
@@ -0,0 +1,11 @@
+// Wrapper for including googletest indirectly. Useful when the location of the
+// googletest sources must change depending on build environment and repository
+// source location.
+#ifndef DRACO_CORE_DRACO_TEST_BASE_H_
+#define DRACO_CORE_DRACO_TEST_BASE_H_
+
+static bool FLAGS_update_golden_files;
+#include "gtest/gtest.h"
+#include "testing/draco_test_config.h"
+
+#endif  // DRACO_CORE_DRACO_TEST_BASE_H_
diff --git a/contrib/draco/src/draco/core/draco_test_utils.cc b/contrib/draco/src/draco/core/draco_test_utils.cc
new file mode 100644
index 000000000..edca9856d
--- /dev/null
+++ b/contrib/draco/src/draco/core/draco_test_utils.cc
@@ -0,0 +1,80 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/draco_test_utils.h"
+
+#include <fstream>
+
+#include "draco/core/macros.h"
+#include "draco/io/file_utils.h"
+#include "draco_test_base.h"
+
+namespace draco {
+
+namespace {
+static constexpr char kTestDataDir[] = DRACO_TEST_DATA_DIR;
+static constexpr char kTestTempDir[] = DRACO_TEST_TEMP_DIR;
+}  // namespace
+
+std::string GetTestFileFullPath(const std::string &file_name) {
+  return std::string(kTestDataDir) + std::string("/") + file_name;
+}
+
+std::string GetTestTempFileFullPath(const std::string &file_name) {
+  return std::string(kTestTempDir) + std::string("/") + file_name;
+}
+
+bool GenerateGoldenFile(const std::string &golden_file_name, const void *data,
+                        int data_size) {
+  const std::string path = GetTestFileFullPath(golden_file_name);
+  return WriteBufferToFile(data, data_size, path);
+}
+
+bool CompareGoldenFile(const std::string &golden_file_name, const void *data,
+                       int data_size) {
+  const std::string golden_path = GetTestFileFullPath(golden_file_name);
+  std::ifstream in_file(golden_path, std::ios::binary);
+  if (!in_file || data_size < 0) {
+    return false;
+  }
+  const char *const data_c8 = static_cast<const char *>(data);
+  constexpr int buffer_size = 1024;
+  char buffer[buffer_size];
+  size_t extracted_size = 0;
+  size_t remaining_data_size = data_size;
+  int offset = 0;
+  while ((extracted_size = in_file.read(buffer, buffer_size).gcount()) > 0) {
+    if (remaining_data_size <= 0)
+      break;  // Input and golden sizes are different.
+    size_t size_to_check = extracted_size;
+    if (remaining_data_size < size_to_check)
+      size_to_check = remaining_data_size;
+    for (uint32_t i = 0; i < size_to_check; ++i) {
+      if (buffer[i] != data_c8[offset++]) {
+        LOG(INFO) << "Test output differed from golden file at byte "
+                  << offset - 1;
+        return false;
+      }
+    }
+    remaining_data_size -= extracted_size;
+  }
+  if (remaining_data_size != extracted_size) {
+    // Both of these values should be 0 at the end.
+    LOG(INFO) << "Test output size differed from golden file size";
+    return false;
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/draco_test_utils.h b/contrib/draco/src/draco/core/draco_test_utils.h
new file mode 100644
index 000000000..fa548f52d
--- /dev/null
+++ b/contrib/draco/src/draco/core/draco_test_utils.h
@@ -0,0 +1,93 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DRACO_TEST_UTILS_H_
+#define DRACO_CORE_DRACO_TEST_UTILS_H_
+
+#include "draco/core/draco_test_base.h"
+#include "draco/io/mesh_io.h"
+#include "draco/io/point_cloud_io.h"
+
+namespace draco {
+
+// Returns the full path to a given file system entry, such as test file or test
+// directory.
+std::string GetTestFileFullPath(const std::string &entry_name);
+
+// Returns the full path to a given temporary file (a location where tests store
+// generated files).
+std::string GetTestTempFileFullPath(const std::string &file_name);
+
+// Generates a new golden file and saves it into the correct folder.
+// Returns false if the file couldn't be created.
+bool GenerateGoldenFile(const std::string &golden_file_name, const void *data,
+                        int data_size);
+
+// Compare a golden file content with the input data.
+// Function will log the first byte position where the data differ.
+// Returns false if there are any differences.
+bool CompareGoldenFile(const std::string &golden_file_name, const void *data,
+                       int data_size);
+
+// Loads a mesh / point cloud specified by a |file_name| that is going to be
+// automatically converted to the correct path available to the testing
+// instance.
+inline std::unique_ptr<Mesh> ReadMeshFromTestFile(
+    const std::string &file_name) {
+  const std::string path = GetTestFileFullPath(file_name);
+  return ReadMeshFromFile(path).value();
+}
+inline std::unique_ptr<Mesh> ReadMeshFromTestFile(const std::string &file_name,
+                                                  bool use_metadata) {
+  const std::string path = GetTestFileFullPath(file_name);
+  return ReadMeshFromFile(path, use_metadata).value();
+}
+inline std::unique_ptr<Mesh> ReadMeshFromTestFile(const std::string &file_name,
+                                                  const Options &options) {
+  const std::string path = GetTestFileFullPath(file_name);
+  return ReadMeshFromFile(path, options).value();
+}
+
+inline std::unique_ptr<PointCloud> ReadPointCloudFromTestFile(
+    const std::string &file_name) {
+  const std::string path = GetTestFileFullPath(file_name);
+  return ReadPointCloudFromFile(path).value();
+}
+
+// Evaluates an expression that returns draco::Status. If the status is not OK,
+// the macro asserts and logs the error message.
+#define DRACO_ASSERT_OK(expression)                                      \
+  {                                                                      \
+    const draco::Status _local_status = (expression);                    \
+    ASSERT_TRUE(_local_status.ok()) << _local_status.error_msg_string(); \
+  }
+
+// In case StatusOr<T> is ok(), this macro assigns value stored in StatusOr<T>
+// to |lhs|, otherwise it asserts and logs the error message.
+//
+//   DRACO_ASSIGN_OR_ASSERT(lhs, expression)
+//
+#define DRACO_ASSIGN_OR_ASSERT(lhs, expression)                                \
+  DRACO_ASSIGN_OR_ASSERT_IMPL_(DRACO_MACROS_IMPL_CONCAT_(_statusor, __LINE__), \
+                               lhs, expression, _status)
+
+// The actual implementation of the above macro.
+#define DRACO_ASSIGN_OR_ASSERT_IMPL_(statusor, lhs, expression, error_expr) \
+  auto statusor = (expression);                                             \
+  ASSERT_TRUE(statusor.ok()) << statusor.status().error_msg_string();       \
+  lhs = std::move(statusor).value();
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DRACO_TEST_UTILS_H_
diff --git a/contrib/draco/src/draco/core/draco_types.cc b/contrib/draco/src/draco/core/draco_types.cc
new file mode 100644
index 000000000..9bde05fda
--- /dev/null
+++ b/contrib/draco/src/draco/core/draco_types.cc
@@ -0,0 +1,61 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/draco_types.h"
+
+namespace draco {
+
+int32_t DataTypeLength(DataType dt) {
+  switch (dt) {
+    case DT_INT8:
+    case DT_UINT8:
+      return 1;
+    case DT_INT16:
+    case DT_UINT16:
+      return 2;
+    case DT_INT32:
+    case DT_UINT32:
+      return 4;
+    case DT_INT64:
+    case DT_UINT64:
+      return 8;
+    case DT_FLOAT32:
+      return 4;
+    case DT_FLOAT64:
+      return 8;
+    case DT_BOOL:
+      return 1;
+    default:
+      return -1;
+  }
+}
+
+bool IsDataTypeIntegral(DataType dt) {
+  switch (dt) {
+    case DT_INT8:
+    case DT_UINT8:
+    case DT_INT16:
+    case DT_UINT16:
+    case DT_INT32:
+    case DT_UINT32:
+    case DT_INT64:
+    case DT_UINT64:
+    case DT_BOOL:
+      return true;
+    default:
+      return false;
+  }
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/draco_types.h b/contrib/draco/src/draco/core/draco_types.h
new file mode 100644
index 000000000..d14437a02
--- /dev/null
+++ b/contrib/draco/src/draco/core/draco_types.h
@@ -0,0 +1,52 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DRACO_TYPES_H_
+#define DRACO_CORE_DRACO_TYPES_H_
+
+#include <stdint.h>
+
+#include <string>
+
+#include "draco/draco_features.h"
+
+namespace draco {
+
+enum DataType {
+  // Not a legal value for DataType. Used to indicate a field has not been set.
+  DT_INVALID = 0,
+  DT_INT8,
+  DT_UINT8,
+  DT_INT16,
+  DT_UINT16,
+  DT_INT32,
+  DT_UINT32,
+  DT_INT64,
+  DT_UINT64,
+  DT_FLOAT32,
+  DT_FLOAT64,
+  DT_BOOL,
+  DT_TYPES_COUNT
+};
+
+int32_t DataTypeLength(DataType dt);
+
+// Equivalent to std::is_integral for draco::DataType. Returns true for all
+// signed and unsigned integer types (including DT_BOOL). Returns false
+// otherwise.
+bool IsDataTypeIntegral(DataType dt);
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DRACO_TYPES_H_
diff --git a/contrib/draco/src/draco/core/draco_version.h b/contrib/draco/src/draco/core/draco_version.h
new file mode 100644
index 000000000..14a504a50
--- /dev/null
+++ b/contrib/draco/src/draco/core/draco_version.h
@@ -0,0 +1,27 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_DRACO_VERSION_H_
+#define DRACO_CORE_DRACO_VERSION_H_
+
+namespace draco {
+
+// Draco version is comprised of <major>.<minor>.<revision>.
+static const char kDracoVersion[] = "1.4.1";
+
+const char *Version() { return kDracoVersion; }
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_DRACO_VERSION_H_
diff --git a/contrib/draco/src/draco/core/encoder_buffer.cc b/contrib/draco/src/draco/core/encoder_buffer.cc
new file mode 100644
index 000000000..df98677a8
--- /dev/null
+++ b/contrib/draco/src/draco/core/encoder_buffer.cc
@@ -0,0 +1,93 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/encoder_buffer.h"
+
+#include <cstring>  // for memcpy
+
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+EncoderBuffer::EncoderBuffer()
+    : bit_encoder_reserved_bytes_(false), encode_bit_sequence_size_(false) {}
+
+void EncoderBuffer::Clear() {
+  buffer_.clear();
+  bit_encoder_reserved_bytes_ = 0;
+}
+
+void EncoderBuffer::Resize(int64_t nbytes) { buffer_.resize(nbytes); }
+
+bool EncoderBuffer::StartBitEncoding(int64_t required_bits, bool encode_size) {
+  if (bit_encoder_active()) {
+    return false;  // Bit encoding mode already active.
+  }
+  if (required_bits <= 0) {
+    return false;  // Invalid size.
+  }
+  encode_bit_sequence_size_ = encode_size;
+  const int64_t required_bytes = (required_bits + 7) / 8;
+  bit_encoder_reserved_bytes_ = required_bytes;
+  uint64_t buffer_start_size = buffer_.size();
+  if (encode_size) {
+    // Reserve memory for storing the encoded bit sequence size. It will be
+    // filled once the bit encoding ends.
+    buffer_start_size += sizeof(uint64_t);
+  }
+  // Resize buffer to fit the maximum size of encoded bit data.
+  buffer_.resize(buffer_start_size + required_bytes);
+  // Get the buffer data pointer for the bit encoder.
+  const char *const data = buffer_.data() + buffer_start_size;
+  bit_encoder_ =
+      std::unique_ptr<BitEncoder>(new BitEncoder(const_cast<char *>(data)));
+  return true;
+}
+
+void EncoderBuffer::EndBitEncoding() {
+  if (!bit_encoder_active()) {
+    return;
+  }
+  // Get the number of encoded bits and bytes (rounded up).
+  const uint64_t encoded_bits = bit_encoder_->Bits();
+  const uint64_t encoded_bytes = (encoded_bits + 7) / 8;
+  // Flush all cached bits that are not in the bit encoder's main buffer.
+  bit_encoder_->Flush(0);
+  // Encode size if needed.
+  if (encode_bit_sequence_size_) {
+    char *out_mem = const_cast<char *>(data() + size());
+    // Make the out_mem point to the memory reserved for storing the size.
+    out_mem = out_mem - (bit_encoder_reserved_bytes_ + sizeof(uint64_t));
+
+    EncoderBuffer var_size_buffer;
+    EncodeVarint(encoded_bytes, &var_size_buffer);
+    const uint32_t size_len = static_cast<uint32_t>(var_size_buffer.size());
+    char *const dst = out_mem + size_len;
+    const char *const src = out_mem + sizeof(uint64_t);
+    memmove(dst, src, encoded_bytes);
+
+    // Store the size of the encoded data.
+    memcpy(out_mem, var_size_buffer.data(), size_len);
+
+    // We need to account for the difference between the preallocated and actual
+    // storage needed for storing the encoded length. This will be used later to
+    // compute the correct size of |buffer_|.
+    bit_encoder_reserved_bytes_ += sizeof(uint64_t) - size_len;
+  }
+  // Resize the underlying buffer to match the number of encoded bits.
+  buffer_.resize(buffer_.size() - bit_encoder_reserved_bytes_ + encoded_bytes);
+  bit_encoder_reserved_bytes_ = 0;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/encoder_buffer.h b/contrib/draco/src/draco/core/encoder_buffer.h
new file mode 100644
index 000000000..b153a6297
--- /dev/null
+++ b/contrib/draco/src/draco/core/encoder_buffer.h
@@ -0,0 +1,152 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_ENCODER_BUFFER_H_
+#define DRACO_CORE_ENCODER_BUFFER_H_
+
+#include <memory>
+#include <vector>
+
+#include "draco/core/bit_utils.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// Class representing a buffer that can be used for either for byte-aligned
+// encoding of arbitrary data structures or for encoding of variable-length
+// bit data.
+class EncoderBuffer {
+ public:
+  EncoderBuffer();
+  void Clear();
+  void Resize(int64_t nbytes);
+
+  // Start encoding a bit sequence. A maximum size of the sequence needs to
+  // be known upfront.
+  // If encode_size is true, the size of encoded bit sequence is stored before
+  // the sequence. Decoder can then use this size to skip over the bit sequence
+  // if needed.
+  // Returns false on error.
+  bool StartBitEncoding(int64_t required_bits, bool encode_size);
+
+  // End the encoding of the bit sequence and return to the default byte-aligned
+  // encoding.
+  void EndBitEncoding();
+
+  // Encode up to 32 bits into the buffer. Can be called only in between
+  // StartBitEncoding and EndBitEncoding. Otherwise returns false.
+  bool EncodeLeastSignificantBits32(int nbits, uint32_t value) {
+    if (!bit_encoder_active()) {
+      return false;
+    }
+    bit_encoder_->PutBits(value, nbits);
+    return true;
+  }
+  // Encode an arbitrary data type.
+  // Can be used only when we are not encoding a bit-sequence.
+  // Returns false when the value couldn't be encoded.
+  template <typename T>
+  bool Encode(const T &data) {
+    if (bit_encoder_active()) {
+      return false;
+    }
+    const uint8_t *src_data = reinterpret_cast<const uint8_t *>(&data);
+    buffer_.insert(buffer_.end(), src_data, src_data + sizeof(T));
+    return true;
+  }
+  bool Encode(const void *data, size_t data_size) {
+    if (bit_encoder_active()) {
+      return false;
+    }
+    const uint8_t *src_data = reinterpret_cast<const uint8_t *>(data);
+    buffer_.insert(buffer_.end(), src_data, src_data + data_size);
+    return true;
+  }
+
+  bool bit_encoder_active() const { return bit_encoder_reserved_bytes_ > 0; }
+  const char *data() const { return buffer_.data(); }
+  size_t size() const { return buffer_.size(); }
+  std::vector<char> *buffer() { return &buffer_; }
+
+ private:
+  // Internal helper class to encode bits to a bit buffer.
+  class BitEncoder {
+   public:
+    // |data| is the buffer to write the bits into.
+    explicit BitEncoder(char *data) : bit_buffer_(data), bit_offset_(0) {}
+
+    // Write |nbits| of |data| into the bit buffer.
+    void PutBits(uint32_t data, int32_t nbits) {
+      DRACO_DCHECK_GE(nbits, 0);
+      DRACO_DCHECK_LE(nbits, 32);
+      for (int32_t bit = 0; bit < nbits; ++bit) {
+        PutBit((data >> bit) & 1);
+      }
+    }
+
+    // Return number of bits encoded so far.
+    uint64_t Bits() const { return static_cast<uint64_t>(bit_offset_); }
+
+    // TODO(fgalligan): Remove this function once we know we do not need the
+    // old API anymore.
+    // This is a function of an old API, that currently does nothing.
+    void Flush(int /* left_over_bit_value */) {}
+
+    // Return the number of bits required to store the given number
+    static uint32_t BitsRequired(uint32_t x) {
+      return static_cast<uint32_t>(MostSignificantBit(x));
+    }
+
+   private:
+    void PutBit(uint8_t value) {
+      const int byte_size = 8;
+      const uint64_t off = static_cast<uint64_t>(bit_offset_);
+      const uint64_t byte_offset = off / byte_size;
+      const int bit_shift = off % byte_size;
+
+      // TODO(fgalligan): Check performance if we add a branch and only do one
+      // memory write if bit_shift is 7. Also try using a temporary variable to
+      // hold the bits before writing to the buffer.
+
+      bit_buffer_[byte_offset] &= ~(1 << bit_shift);
+      bit_buffer_[byte_offset] |= value << bit_shift;
+      bit_offset_++;
+    }
+
+    char *bit_buffer_;
+    size_t bit_offset_;
+  };
+  friend class BufferBitCodingTest;
+  // All data is stored in this vector.
+  std::vector<char> buffer_;
+
+  // Bit encoder is used when encoding variable-length bit data.
+  // TODO(ostava): Currently encoder needs to be recreated each time
+  // StartBitEncoding method is called. This is not necessary if BitEncoder
+  // supported reset function which can easily added but let's leave that for
+  // later.
+  std::unique_ptr<BitEncoder> bit_encoder_;
+
+  // The number of bytes reserved for bit encoder.
+  // Values > 0 indicate we are in the bit encoding mode.
+  int64_t bit_encoder_reserved_bytes_;
+
+  // Flag used indicating that we need to store the length of the currently
+  // processed bit sequence.
+  bool encode_bit_sequence_size_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_ENCODER_BUFFER_H_
diff --git a/contrib/draco/src/draco/core/hash_utils.cc b/contrib/draco/src/draco/core/hash_utils.cc
new file mode 100644
index 000000000..fbbd653f3
--- /dev/null
+++ b/contrib/draco/src/draco/core/hash_utils.cc
@@ -0,0 +1,58 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/hash_utils.h"
+
+#include <cstddef>
+#include <functional>
+#include <limits>
+
+namespace draco {
+
+// Will never return 1 or 0.
+uint64_t FingerprintString(const char *s, size_t len) {
+  const uint64_t seed = 0x87654321;
+  const int hash_loop_count = static_cast<int>(len / 8) + 1;
+  uint64_t hash = seed;
+
+  for (int i = 0; i < hash_loop_count; ++i) {
+    const int off = i * 8;
+    const int num_chars_left = static_cast<int>(len) - off;
+    uint64_t new_hash = seed;
+
+    if (num_chars_left > 7) {
+      const int off2 = i * 8;
+      new_hash = static_cast<uint64_t>(s[off2]) << 56 |
+                 static_cast<uint64_t>(s[off2 + 1]) << 48 |
+                 static_cast<uint64_t>(s[off2 + 2]) << 40 |
+                 static_cast<uint64_t>(s[off2 + 3]) << 32 |
+                 static_cast<uint64_t>(s[off2 + 4]) << 24 |
+                 static_cast<uint64_t>(s[off2 + 5]) << 16 |
+                 static_cast<uint64_t>(s[off2 + 6]) << 8 | s[off2 + 7];
+    } else {
+      for (int j = 0; j < num_chars_left; ++j) {
+        new_hash |= static_cast<uint64_t>(s[off + j])
+                    << (64 - ((num_chars_left - j) * 8));
+      }
+    }
+
+    hash = HashCombine(new_hash, hash);
+  }
+
+  if (hash < std::numeric_limits<uint64_t>::max() - 1) {
+    hash += 2;
+  }
+  return hash;
+}
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/hash_utils.h b/contrib/draco/src/draco/core/hash_utils.h
new file mode 100644
index 000000000..aa61523e7
--- /dev/null
+++ b/contrib/draco/src/draco/core/hash_utils.h
@@ -0,0 +1,64 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_HASH_UTILS_H_
+#define DRACO_CORE_HASH_UTILS_H_
+
+#include <stdint.h>
+
+#include <cstddef>
+#include <functional>
+
+namespace draco {
+
+template <typename T1, typename T2>
+size_t HashCombine(T1 a, T2 b) {
+  const size_t hash1 = std::hash<T1>()(a);
+  const size_t hash2 = std::hash<T2>()(b);
+  return (hash1 << 2) ^ (hash2 << 1);
+}
+
+template <typename T>
+size_t HashCombine(T a, size_t hash) {
+  const size_t hasha = std::hash<T>()(a);
+  return (hash) ^ (hasha + 239);
+}
+
+inline uint64_t HashCombine(uint64_t a, uint64_t b) {
+  return (a + 1013) ^ (b + 107) << 1;
+}
+
+// Will never return 1 or 0.
+uint64_t FingerprintString(const char *s, size_t len);
+
+// Hash for std::array.
+template <typename T>
+struct HashArray {
+  size_t operator()(const T &a) const {
+    size_t hash = 79;  // Magic number.
+    for (unsigned int i = 0; i < std::tuple_size<T>::value; ++i) {
+      hash = HashCombine(hash, ValueHash(a[i]));
+    }
+    return hash;
+  }
+
+  template <typename V>
+  size_t ValueHash(const V &val) const {
+    return std::hash<V>()(val);
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_HASH_UTILS_H_
diff --git a/contrib/draco/src/draco/core/macros.h b/contrib/draco/src/draco/core/macros.h
new file mode 100644
index 000000000..147bbaafc
--- /dev/null
+++ b/contrib/draco/src/draco/core/macros.h
@@ -0,0 +1,119 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_MACROS_H_
+#define DRACO_CORE_MACROS_H_
+
+#include "assert.h"
+#include "draco/draco_features.h"
+
+#ifdef ANDROID_LOGGING
+#include <android/log.h>
+#define LOG_TAG "draco"
+#define DRACO_LOGI(...) \
+  __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define DRACO_LOGE(...) \
+  __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+#else
+#define DRACO_LOGI printf
+#define DRACO_LOGE printf
+#endif
+
+#include <iostream>
+namespace draco {
+
+#ifndef DISALLOW_COPY_AND_ASSIGN
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName &) = delete;     \
+  void operator=(const TypeName &) = delete;
+#endif
+
+#ifndef FALLTHROUGH_INTENDED
+#if defined(__clang__) && defined(__has_warning)
+#if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
+#define FALLTHROUGH_INTENDED [[clang::fallthrough]]
+#endif
+#elif defined(__GNUC__) && __GNUC__ >= 7
+#define FALLTHROUGH_INTENDED [[gnu::fallthrough]]
+#endif
+
+// If FALLTHROUGH_INTENDED is still not defined, define it.
+#ifndef FALLTHROUGH_INTENDED
+#define FALLTHROUGH_INTENDED \
+  do {                       \
+  } while (0)
+#endif
+#endif
+
+#ifndef LOG
+#define LOG(...) std::cout
+#endif
+
+#ifndef VLOG
+#define VLOG(...) std::cout
+#endif
+
+}  // namespace draco
+
+#ifdef DRACO_DEBUG
+#define DRACO_DCHECK(x) (assert(x));
+#define DRACO_DCHECK_EQ(a, b) assert((a) == (b));
+#define DRACO_DCHECK_NE(a, b) assert((a) != (b));
+#define DRACO_DCHECK_GE(a, b) assert((a) >= (b));
+#define DRACO_DCHECK_GT(a, b) assert((a) > (b));
+#define DRACO_DCHECK_LE(a, b) assert((a) <= (b));
+#define DRACO_DCHECK_LT(a, b) assert((a) < (b));
+#define DRACO_DCHECK_NOTNULL(x) assert((x) != NULL);
+#else
+#define DRACO_DCHECK(x)
+#define DRACO_DCHECK_EQ(a, b)
+#define DRACO_DCHECK_NE(a, b)
+#define DRACO_DCHECK_GE(a, b)
+#define DRACO_DCHECK_GT(a, b)
+#define DRACO_DCHECK_LE(a, b)
+#define DRACO_DCHECK_LT(a, b)
+#define DRACO_DCHECK_NOTNULL(x)
+#endif
+
+// Helper macros for concatenating macro values.
+#define DRACO_MACROS_IMPL_CONCAT_INNER_(x, y) x##y
+#define DRACO_MACROS_IMPL_CONCAT_(x, y) DRACO_MACROS_IMPL_CONCAT_INNER_(x, y)
+
+// Expand the n-th argument of the macro. Used to select an argument based on
+// the number of entries in a variadic macro argument. Example usage:
+//
+// #define FUNC_1(x) x
+// #define FUNC_2(x, y) x + y
+// #define FUNC_3(x, y, z) x + y + z
+//
+// #define VARIADIC_MACRO(...)
+//   DRACO_SELECT_NTH_FROM_3(__VA_ARGS__, FUNC_3, FUNC_2, FUNC_1) __VA_ARGS__
+//
+#define DRACO_SELECT_NTH_FROM_2(_1, _2, NAME) NAME
+#define DRACO_SELECT_NTH_FROM_3(_1, _2, _3, NAME) NAME
+#define DRACO_SELECT_NTH_FROM_4(_1, _2, _3, _4, NAME) NAME
+
+// Macro that converts the Draco bit-stream into one uint16_t number.
+// Useful mostly when checking version numbers.
+#define DRACO_BITSTREAM_VERSION(MAJOR, MINOR) \
+  ((static_cast<uint16_t>(MAJOR) << 8) | MINOR)
+
+// Macro that converts the uint16_t Draco bit-stream number into the major
+// and minor components respectively.
+#define DRACO_BISTREAM_VERSION_MAJOR(VERSION) \
+  (static_cast<uint8_t>(VERSION >> 8))
+#define DRACO_BISTREAM_VERSION_MINOR(VERSION) \
+  (static_cast<uint8_t>(VERSION & 0xFF))
+
+#endif  // DRACO_CORE_MACROS_H_
diff --git a/contrib/draco/src/draco/core/math_utils.h b/contrib/draco/src/draco/core/math_utils.h
new file mode 100644
index 000000000..7f382fa34
--- /dev/null
+++ b/contrib/draco/src/draco/core/math_utils.h
@@ -0,0 +1,55 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_MATH_UTILS_H_
+#define DRACO_CORE_MATH_UTILS_H_
+
+#include <inttypes.h>
+
+#include "draco/core/vector_d.h"
+
+#define DRACO_INCREMENT_MOD(I, M) (((I) == ((M)-1)) ? 0 : ((I) + 1))
+
+// Returns floor(sqrt(x)) where x is an integer number. The main intend of this
+// function is to provide a cross platform and deterministic implementation of
+// square root for integer numbers. This function is not intended to be a
+// replacement for std::sqrt() for general cases. IntSqrt is in fact about 3X
+// slower compared to most implementation of std::sqrt().
+inline uint64_t IntSqrt(uint64_t number) {
+  if (number == 0) {
+    return 0;
+  }
+  // First estimate good initial value of the square root as log2(number).
+  uint64_t act_number = number;
+  uint64_t square_root = 1;
+  while (act_number >= 2) {
+    // Double the square root until |square_root * square_root > number|.
+    square_root *= 2;
+    act_number /= 4;
+  }
+  // Perform Newton's (or Babylonian) method to find the true floor(sqrt()).
+  do {
+    // New |square_root| estimate is computed as the average between
+    // |square_root| and |number / square_root|.
+    square_root = (square_root + number / square_root) / 2;
+
+    // Note that after the first iteration, the estimate is always going to be
+    // larger or equal to the true square root value. Therefore to check
+    // convergence, we can simply detect condition when the square of the
+    // estimated square root is larger than the input.
+  } while (square_root * square_root > number);
+  return square_root;
+}
+
+#endif  // DRACO_CORE_MATH_UTILS_H_
diff --git a/contrib/draco/src/draco/core/math_utils_test.cc b/contrib/draco/src/draco/core/math_utils_test.cc
new file mode 100644
index 000000000..8c255d046
--- /dev/null
+++ b/contrib/draco/src/draco/core/math_utils_test.cc
@@ -0,0 +1,22 @@
+#include "draco/core/math_utils.h"
+
+#include <cmath>
+#include <random>
+
+#include "draco/core/draco_test_base.h"
+
+using draco::Vector3f;
+
+TEST(MathUtils, Mod) { EXPECT_EQ(DRACO_INCREMENT_MOD(1, 1 << 1), 0); }
+
+TEST(MathUtils, IntSqrt) {
+  ASSERT_EQ(IntSqrt(0), 0);
+  // 64-bit pseudo random number generator seeded with a predefined number.
+  std::mt19937_64 generator(109);
+  std::uniform_int_distribution<uint64_t> distribution(0, 1ull << 60);
+
+  for (int i = 0; i < 10000; ++i) {
+    const uint64_t number = distribution(generator);
+    ASSERT_EQ(IntSqrt(number), static_cast<uint64_t>(floor(std::sqrt(number))));
+  }
+}
diff --git a/contrib/draco/src/draco/core/options.cc b/contrib/draco/src/draco/core/options.cc
new file mode 100644
index 000000000..9b81db489
--- /dev/null
+++ b/contrib/draco/src/draco/core/options.cc
@@ -0,0 +1,94 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/options.h"
+
+#include <cstdlib>
+#include <string>
+#include <utility>
+
+namespace draco {
+
+Options::Options() {}
+
+void Options::MergeAndReplace(const Options &other_options) {
+  for (const auto &item : other_options.options_) {
+    options_[item.first] = item.second;
+  }
+}
+
+void Options::SetInt(const std::string &name, int val) {
+  options_[name] = std::to_string(val);
+}
+
+void Options::SetFloat(const std::string &name, float val) {
+  options_[name] = std::to_string(val);
+}
+
+void Options::SetBool(const std::string &name, bool val) {
+  options_[name] = std::to_string(val ? 1 : 0);
+}
+
+void Options::SetString(const std::string &name, const std::string &val) {
+  options_[name] = val;
+}
+
+int Options::GetInt(const std::string &name) const { return GetInt(name, -1); }
+
+int Options::GetInt(const std::string &name, int default_val) const {
+  const auto it = options_.find(name);
+  if (it == options_.end()) {
+    return default_val;
+  }
+  return std::atoi(it->second.c_str());
+}
+
+float Options::GetFloat(const std::string &name) const {
+  return GetFloat(name, -1);
+}
+
+float Options::GetFloat(const std::string &name, float default_val) const {
+  const auto it = options_.find(name);
+  if (it == options_.end()) {
+    return default_val;
+  }
+  return static_cast<float>(std::atof(it->second.c_str()));
+}
+
+bool Options::GetBool(const std::string &name) const {
+  return GetBool(name, false);
+}
+
+bool Options::GetBool(const std::string &name, bool default_val) const {
+  const int ret = GetInt(name, -1);
+  if (ret == -1) {
+    return default_val;
+  }
+  return static_cast<bool>(ret);
+}
+
+std::string Options::GetString(const std::string &name) const {
+  return GetString(name, "");
+}
+
+std::string Options::GetString(const std::string &name,
+                               const std::string &default_val) const {
+  const auto it = options_.find(name);
+  if (it == options_.end()) {
+    return default_val;
+  }
+  return it->second;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/options.h b/contrib/draco/src/draco/core/options.h
new file mode 100644
index 000000000..1bc4dc0fb
--- /dev/null
+++ b/contrib/draco/src/draco/core/options.h
@@ -0,0 +1,150 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_OPTIONS_H_
+#define DRACO_CORE_OPTIONS_H_
+
+#include <cstdlib>
+#include <map>
+#include <string>
+
+namespace draco {
+
+// Class for storing generic options as a <name, value> pair in a string map.
+// The API provides helper methods for directly storing values of various types
+// such as ints and bools. One named option should be set with only a single
+// data type.
+class Options {
+ public:
+  Options();
+
+  // Merges |other_options| on top of the existing options of this instance
+  // replacing all entries that are present in both options instances.
+  void MergeAndReplace(const Options &other_options);
+
+  void SetInt(const std::string &name, int val);
+  void SetFloat(const std::string &name, float val);
+  void SetBool(const std::string &name, bool val);
+  void SetString(const std::string &name, const std::string &val);
+  template <class VectorT>
+  void SetVector(const std::string &name, const VectorT &vec) {
+    SetVector(name, &vec[0], VectorT::dimension);
+  }
+  template <typename DataTypeT>
+  void SetVector(const std::string &name, const DataTypeT *vec, int num_dims);
+
+  // Getters will return a default value if the entry is not found. The default
+  // value can be specified in the overloaded version of each function.
+  int GetInt(const std::string &name) const;
+  int GetInt(const std::string &name, int default_val) const;
+  float GetFloat(const std::string &name) const;
+  float GetFloat(const std::string &name, float default_val) const;
+  bool GetBool(const std::string &name) const;
+  bool GetBool(const std::string &name, bool default_val) const;
+  std::string GetString(const std::string &name) const;
+  std::string GetString(const std::string &name,
+                        const std::string &default_val) const;
+  template <class VectorT>
+  VectorT GetVector(const std::string &name, const VectorT &default_val) const;
+  // Unlike other Get functions, this function returns false if the option does
+  // not exist, otherwise it fills |out_val| with the vector values. If a
+  // default value is needed, it can be set in |out_val|.
+  template <typename DataTypeT>
+  bool GetVector(const std::string &name, int num_dims,
+                 DataTypeT *out_val) const;
+
+  bool IsOptionSet(const std::string &name) const {
+    return options_.count(name) > 0;
+  }
+
+ private:
+  // All entries are internally stored as strings and converted to the desired
+  // return type based on the used Get* method.
+  // TODO(ostava): Consider adding type safety mechanism that would prevent
+  // unsafe operations such as a conversion from vector to int.
+  std::map<std::string, std::string> options_;
+};
+
+template <typename DataTypeT>
+void Options::SetVector(const std::string &name, const DataTypeT *vec,
+                        int num_dims) {
+  std::string out;
+  for (int i = 0; i < num_dims; ++i) {
+    if (i > 0) {
+      out += " ";
+    }
+
+// GNU STL on android doesn't include a proper std::to_string, but the libc++
+// version does
+#if defined(ANDROID) && !defined(_LIBCPP_VERSION)
+    out += to_string(vec[i]);
+#else
+    out += std::to_string(vec[i]);
+#endif
+  }
+  options_[name] = out;
+}
+
+template <class VectorT>
+VectorT Options::GetVector(const std::string &name,
+                           const VectorT &default_val) const {
+  VectorT ret = default_val;
+  GetVector(name, VectorT::dimension, &ret[0]);
+  return ret;
+}
+
+template <typename DataTypeT>
+bool Options::GetVector(const std::string &name, int num_dims,
+                        DataTypeT *out_val) const {
+  const auto it = options_.find(name);
+  if (it == options_.end()) {
+    return false;
+  }
+  const std::string value = it->second;
+  if (value.length() == 0) {
+    return true;  // Option set but no data is present
+  }
+  const char *act_str = value.c_str();
+  char *next_str;
+  for (int i = 0; i < num_dims; ++i) {
+    if (std::is_integral<DataTypeT>::value) {
+#ifdef ANDROID
+      const int val = strtol(act_str, &next_str, 10);
+#else
+      const int val = static_cast<int>(std::strtol(act_str, &next_str, 10));
+#endif
+      if (act_str == next_str) {
+        return true;  // End reached.
+      }
+      act_str = next_str;
+      out_val[i] = static_cast<DataTypeT>(val);
+    } else {
+#ifdef ANDROID
+      const float val = strtof(act_str, &next_str);
+#else
+      const float val = std::strtof(act_str, &next_str);
+#endif
+      if (act_str == next_str) {
+        return true;  // End reached.
+      }
+      act_str = next_str;
+      out_val[i] = static_cast<DataTypeT>(val);
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_OPTIONS_H_
diff --git a/contrib/draco/src/draco/core/quantization_utils.cc b/contrib/draco/src/draco/core/quantization_utils.cc
new file mode 100644
index 000000000..58dcf5c8c
--- /dev/null
+++ b/contrib/draco/src/draco/core/quantization_utils.cc
@@ -0,0 +1,42 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/quantization_utils.h"
+
+namespace draco {
+
+Quantizer::Quantizer() : inverse_delta_(1.f) {}
+
+void Quantizer::Init(float range, int32_t max_quantized_value) {
+  inverse_delta_ = static_cast<float>(max_quantized_value) / range;
+}
+
+void Quantizer::Init(float delta) { inverse_delta_ = 1.f / delta; }
+
+Dequantizer::Dequantizer() : delta_(1.f) {}
+
+bool Dequantizer::Init(float range, int32_t max_quantized_value) {
+  if (max_quantized_value <= 0) {
+    return false;
+  }
+  delta_ = range / static_cast<float>(max_quantized_value);
+  return true;
+}
+
+bool Dequantizer::Init(float delta) {
+  delta_ = delta;
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/quantization_utils.h b/contrib/draco/src/draco/core/quantization_utils.h
new file mode 100644
index 000000000..0f60f1e1b
--- /dev/null
+++ b/contrib/draco/src/draco/core/quantization_utils.h
@@ -0,0 +1,82 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// A set of classes for quantizing and dequantizing of floating point values
+// into integers.
+// The quantization works on all floating point numbers within (-range, +range)
+// interval producing integers in range
+// (-max_quantized_value, +max_quantized_value).
+
+#ifndef DRACO_CORE_QUANTIZATION_UTILS_H_
+#define DRACO_CORE_QUANTIZATION_UTILS_H_
+
+#include <stdint.h>
+
+#include <cmath>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// Class for quantizing single precision floating point values. The values
+// should be centered around zero and be within interval (-range, +range), where
+// the range is specified in the Init() method. Alternatively, the quantization
+// can be defined by |delta| that specifies the distance between two quantized
+// values. Note that the quantizer always snaps the values to the nearest
+// integer value. E.g. for |delta| == 1.f, values -0.4f and 0.4f would be
+// both quantized to 0 while value 0.6f would be quantized to 1. If a value
+// lies exactly between two quantized states, it is always rounded up. E.g.,
+// for |delta| == 1.f, value -0.5f would be quantized to 0 while 0.5f would be
+// quantized to 1.
+class Quantizer {
+ public:
+  Quantizer();
+  void Init(float range, int32_t max_quantized_value);
+  void Init(float delta);
+  inline int32_t QuantizeFloat(float val) const {
+    val *= inverse_delta_;
+    return static_cast<int32_t>(floor(val + 0.5f));
+  }
+  inline int32_t operator()(float val) const { return QuantizeFloat(val); }
+
+ private:
+  float inverse_delta_;
+};
+
+// Class for dequantizing values that were previously quantized using the
+// Quantizer class.
+class Dequantizer {
+ public:
+  Dequantizer();
+
+  // Initializes the dequantizer. Both parameters must correspond to the values
+  // provided to the initializer of the Quantizer class.
+  // Returns false when the initialization fails.
+  bool Init(float range, int32_t max_quantized_value);
+
+  // Initializes the dequantizer using the |delta| between two quantized values.
+  bool Init(float delta);
+
+  inline float DequantizeFloat(int32_t val) const {
+    return static_cast<float>(val) * delta_;
+  }
+  inline float operator()(int32_t val) const { return DequantizeFloat(val); }
+
+ private:
+  float delta_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_QUANTIZATION_UTILS_H_
diff --git a/contrib/draco/src/draco/core/quantization_utils_test.cc b/contrib/draco/src/draco/core/quantization_utils_test.cc
new file mode 100644
index 000000000..b4f0473f2
--- /dev/null
+++ b/contrib/draco/src/draco/core/quantization_utils_test.cc
@@ -0,0 +1,91 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/quantization_utils.h"
+
+#include "draco/core/draco_test_base.h"
+
+namespace draco {
+
+class QuantizationUtilsTest : public ::testing::Test {};
+
+TEST_F(QuantizationUtilsTest, TestQuantizer) {
+  Quantizer quantizer;
+  quantizer.Init(10.f, 255);
+  EXPECT_EQ(quantizer.QuantizeFloat(0.f), 0);
+  EXPECT_EQ(quantizer.QuantizeFloat(10.f), 255);
+  EXPECT_EQ(quantizer.QuantizeFloat(-10.f), -255);
+  EXPECT_EQ(quantizer.QuantizeFloat(4.999f), 127);
+  EXPECT_EQ(quantizer.QuantizeFloat(5.f), 128);
+  EXPECT_EQ(quantizer.QuantizeFloat(-4.9999f), -127);
+  // Note: Both -5.f and +5.f lie exactly on the boundary between two
+  // quantized values (127.5f and -127.5f). Due to rounding, both values are
+  // then converted to 128 and -127 respectively.
+  EXPECT_EQ(quantizer.QuantizeFloat(-5.f), -127);
+  EXPECT_EQ(quantizer.QuantizeFloat(-5.0001f), -128);
+
+  // Out of range quantization.
+  // The behavior is technically undefined, but both quantizer and dequantizer
+  // should still work correctly unless the quantized values overflow.
+  EXPECT_LT(quantizer.QuantizeFloat(-15.f), -255);
+  EXPECT_GT(quantizer.QuantizeFloat(15.f), 255);
+}
+
+TEST_F(QuantizationUtilsTest, TestDequantizer) {
+  Dequantizer dequantizer;
+  ASSERT_TRUE(dequantizer.Init(10.f, 255));
+  EXPECT_EQ(dequantizer.DequantizeFloat(0), 0.f);
+  EXPECT_EQ(dequantizer.DequantizeFloat(255), 10.f);
+  EXPECT_EQ(dequantizer.DequantizeFloat(-255), -10.f);
+  EXPECT_EQ(dequantizer.DequantizeFloat(128), 10.f * (128.f / 255.f));
+
+  // Test that the dequantizer fails to initialize with invalid input
+  // parameters.
+  ASSERT_FALSE(dequantizer.Init(1.f, 0));
+  ASSERT_FALSE(dequantizer.Init(1.f, -4));
+}
+
+TEST_F(QuantizationUtilsTest, TestDeltaQuantization) {
+  // Test verifies that the quantizer and dequantizer work correctly when
+  // initialized with a delta value.
+  Quantizer quantizer_delta;
+  quantizer_delta.Init(0.5f);
+
+  Quantizer quantizer_range;
+  quantizer_range.Init(50.f, 100);
+
+  EXPECT_EQ(quantizer_delta.QuantizeFloat(1.2f), 2);
+  EXPECT_EQ(quantizer_delta.QuantizeFloat(10.f),
+            quantizer_range.QuantizeFloat(10.f));
+  EXPECT_EQ(quantizer_delta.QuantizeFloat(-3.3f),
+            quantizer_range.QuantizeFloat(-3.3f));
+  EXPECT_EQ(quantizer_delta.QuantizeFloat(0.25f),
+            quantizer_range.QuantizeFloat(0.25f));
+
+  Dequantizer dequantizer_delta;
+  dequantizer_delta.Init(0.5f);
+
+  Dequantizer dequantizer_range;
+  dequantizer_range.Init(50.f, 100);
+
+  EXPECT_EQ(dequantizer_delta.DequantizeFloat(2), 1.f);
+  EXPECT_EQ(dequantizer_delta.DequantizeFloat(-4),
+            dequantizer_range.DequantizeFloat(-4));
+  EXPECT_EQ(dequantizer_delta.DequantizeFloat(9),
+            dequantizer_range.DequantizeFloat(9));
+  EXPECT_EQ(dequantizer_delta.DequantizeFloat(0),
+            dequantizer_range.DequantizeFloat(0));
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/core/status.h b/contrib/draco/src/draco/core/status.h
new file mode 100644
index 000000000..449ad8566
--- /dev/null
+++ b/contrib/draco/src/draco/core/status.h
@@ -0,0 +1,77 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_STATUS_H_
+#define DRACO_CORE_STATUS_H_
+
+#include <string>
+
+namespace draco {
+
+// Class encapsulating a return status of an operation with an optional error
+// message. Intended to be used as a return type for functions instead of bool.
+class Status {
+ public:
+  enum Code {
+    OK = 0,
+    DRACO_ERROR = -1,          // Used for general errors.
+    IO_ERROR = -2,             // Error when handling input or output stream.
+    INVALID_PARAMETER = -3,    // Invalid parameter passed to a function.
+    UNSUPPORTED_VERSION = -4,  // Input not compatible with the current version.
+    UNKNOWN_VERSION = -5,      // Input was created with an unknown version of
+                               // the library.
+    UNSUPPORTED_FEATURE = -6,  // Input contains feature that is not supported.
+  };
+
+  Status() : code_(OK) {}
+  Status(const Status &status) = default;
+  Status(Status &&status) = default;
+  explicit Status(Code code) : code_(code) {}
+  Status(Code code, const std::string &error_msg)
+      : code_(code), error_msg_(error_msg) {}
+
+  Code code() const { return code_; }
+  const std::string &error_msg_string() const { return error_msg_; }
+  const char *error_msg() const { return error_msg_.c_str(); }
+
+  bool operator==(Code code) const { return code == code_; }
+  bool ok() const { return code_ == OK; }
+
+  Status &operator=(const Status &) = default;
+
+ private:
+  Code code_;
+  std::string error_msg_;
+};
+
+inline std::ostream &operator<<(std::ostream &os, const Status &status) {
+  os << status.error_msg_string();
+  return os;
+}
+
+inline Status OkStatus() { return Status(Status::OK); }
+
+// Evaluates an expression that returns draco::Status. If the status is not OK,
+// the macro returns the status object.
+#define DRACO_RETURN_IF_ERROR(expression)             \
+  {                                                   \
+    const draco::Status _local_status = (expression); \
+    if (!_local_status.ok()) {                        \
+      return _local_status;                           \
+    }                                                 \
+  }
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_STATUS_H_
diff --git a/contrib/draco/src/draco/core/status_or.h b/contrib/draco/src/draco/core/status_or.h
new file mode 100644
index 000000000..156b9bc02
--- /dev/null
+++ b/contrib/draco/src/draco/core/status_or.h
@@ -0,0 +1,81 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_STATUS_OR_H_
+#define DRACO_CORE_STATUS_OR_H_
+
+#include "draco/core/macros.h"
+#include "draco/core/status.h"
+
+namespace draco {
+
+// Class StatusOr is used to wrap a Status along with a value of a specified
+// type |T|. StatusOr is intended to be returned from functions in situations
+// where it is desirable to carry over more information about the potential
+// errors encountered during the function execution. If there are not errors,
+// the caller can simply use the return value, otherwise the Status object
+// provides more info about the encountered problem.
+template <class T>
+class StatusOr {
+ public:
+  StatusOr() {}
+  // Note: Constructors are intentionally not explicit to allow returning
+  // Status or the return value directly from functions.
+  StatusOr(const StatusOr &) = default;
+  StatusOr(StatusOr &&) = default;
+  StatusOr(const Status &status) : status_(status) {}
+  StatusOr(const T &value) : status_(OkStatus()), value_(value) {}
+  StatusOr(T &&value) : status_(OkStatus()), value_(std::move(value)) {}
+  StatusOr(const Status &status, const T &value)
+      : status_(status), value_(value) {}
+
+  const Status &status() const { return status_; }
+  const T &value() const & { return value_; }
+  const T &&value() const && { return std::move(value_); }
+  T &&value() && { return std::move(value_); }
+
+  // For consistency with existing Google StatusOr API we also include
+  // ValueOrDie() that currently returns the value().
+  const T &ValueOrDie() const & { return value(); }
+  T &&ValueOrDie() && { return std::move(value()); }
+
+  bool ok() const { return status_.ok(); }
+
+ private:
+  Status status_;
+  T value_;
+};
+
+// In case StatusOr<T> is ok(), this macro assigns value stored in StatusOr<T>
+// to |lhs|, otherwise it returns the error Status.
+//
+//   DRACO_ASSIGN_OR_RETURN(lhs, expression)
+//
+#define DRACO_ASSIGN_OR_RETURN(lhs, expression)                                \
+  DRACO_ASSIGN_OR_RETURN_IMPL_(DRACO_MACROS_IMPL_CONCAT_(_statusor, __LINE__), \
+                               lhs, expression, _status)
+
+// The actual implementation of the above macro.
+#define DRACO_ASSIGN_OR_RETURN_IMPL_(statusor, lhs, expression, error_expr) \
+  auto statusor = (expression);                                             \
+  if (!statusor.ok()) {                                                     \
+    auto _status = std::move(statusor.status());                            \
+    (void)_status; /* error_expression may not use it */                    \
+    return error_expr;                                                      \
+  }                                                                         \
+  lhs = std::move(statusor).value();
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_STATUS_OR_H_
diff --git a/contrib/draco/src/draco/core/status_test.cc b/contrib/draco/src/draco/core/status_test.cc
new file mode 100644
index 000000000..c1ad4ab30
--- /dev/null
+++ b/contrib/draco/src/draco/core/status_test.cc
@@ -0,0 +1,38 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/status.h"
+
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+class StatusTest : public ::testing::Test {
+ protected:
+  StatusTest() {}
+};
+
+TEST_F(StatusTest, TestStatusOutput) {
+  // Tests that the Status can be stored in a provided std::ostream.
+  const draco::Status status(draco::Status::DRACO_ERROR, "Error msg.");
+  ASSERT_EQ(status.code(), draco::Status::DRACO_ERROR);
+
+  std::stringstream str;
+  str << status;
+  ASSERT_EQ(str.str(), "Error msg.");
+}
+
+}  // namespace
diff --git a/contrib/draco/src/draco/core/varint_decoding.h b/contrib/draco/src/draco/core/varint_decoding.h
new file mode 100644
index 000000000..cff47e930
--- /dev/null
+++ b/contrib/draco/src/draco/core/varint_decoding.h
@@ -0,0 +1,81 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_VARINT_DECODING_H_
+#define DRACO_CORE_VARINT_DECODING_H_
+
+#include <type_traits>
+
+#include "draco/core/bit_utils.h"
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+
+namespace {
+
+// Decodes a specified unsigned integer as varint. |depth| is the current
+// recursion call depth. The first call to the function must be 1.
+template <typename IntTypeT>
+bool DecodeVarintUnsigned(int depth, IntTypeT *out_val, DecoderBuffer *buffer) {
+  constexpr IntTypeT max_depth = sizeof(IntTypeT) + 1 + (sizeof(IntTypeT) >> 3);
+  if (depth > max_depth) {
+    return false;
+  }
+  // Coding of unsigned values.
+  // 0-6 bit - data
+  // 7 bit - next byte?
+  uint8_t in;
+  if (!buffer->Decode(&in)) {
+    return false;
+  }
+  if (in & (1 << 7)) {
+    // Next byte is available, decode it first.
+    if (!DecodeVarintUnsigned<IntTypeT>(depth + 1, out_val, buffer)) {
+      return false;
+    }
+    // Append decoded info from this byte.
+    *out_val <<= 7;
+    *out_val |= in & ((1 << 7) - 1);
+  } else {
+    // Last byte reached
+    *out_val = in;
+  }
+  return true;
+}
+
+}  // namespace
+
+// Decodes a specified integer as varint. Note that the IntTypeT must be the
+// same as the one used in the corresponding EncodeVarint() call.
+// out_val is undefined if this returns false.
+template <typename IntTypeT>
+bool DecodeVarint(IntTypeT *out_val, DecoderBuffer *buffer) {
+  if (std::is_unsigned<IntTypeT>::value) {
+    if (!DecodeVarintUnsigned<IntTypeT>(1, out_val, buffer)) {
+      return false;
+    }
+  } else {
+    // IntTypeT is a signed value. Decode the symbol and convert to signed.
+    typename std::make_unsigned<IntTypeT>::type symbol;
+    if (!DecodeVarintUnsigned(1, &symbol, buffer)) {
+      return false;
+    }
+    *out_val = ConvertSymbolToSignedInt(symbol);
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_VARINT_DECODING_H_
diff --git a/contrib/draco/src/draco/core/varint_encoding.h b/contrib/draco/src/draco/core/varint_encoding.h
new file mode 100644
index 000000000..9a8a53936
--- /dev/null
+++ b/contrib/draco/src/draco/core/varint_encoding.h
@@ -0,0 +1,61 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_VARINT_ENCODING_H_
+#define DRACO_CORE_VARINT_ENCODING_H_
+
+#include <type_traits>
+
+#include "draco/core/bit_utils.h"
+#include "draco/core/encoder_buffer.h"
+
+namespace draco {
+
+// Encodes a specified integer as varint. Note that different coding is used
+// when IntTypeT is an unsigned data type.
+template <typename IntTypeT>
+bool EncodeVarint(IntTypeT val, EncoderBuffer *out_buffer) {
+  if (std::is_unsigned<IntTypeT>::value) {
+    // Coding of unsigned values.
+    // 0-6 bit - data
+    // 7 bit - next byte?
+    uint8_t out = 0;
+    out |= val & ((1 << 7) - 1);
+    if (val >= (1 << 7)) {
+      out |= (1 << 7);
+      if (!out_buffer->Encode(out)) {
+        return false;
+      }
+      if (!EncodeVarint<IntTypeT>(val >> 7, out_buffer)) {
+        return false;
+      }
+      return true;
+    }
+    if (!out_buffer->Encode(out)) {
+      return false;
+    }
+  } else {
+    // IntTypeT is a signed value. Convert to unsigned symbol and encode.
+    const typename std::make_unsigned<IntTypeT>::type symbol =
+        ConvertSignedIntToSymbol(val);
+    if (!EncodeVarint(symbol, out_buffer)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_VARINT_ENCODING_H_
diff --git a/contrib/draco/src/draco/core/vector_d.h b/contrib/draco/src/draco/core/vector_d.h
new file mode 100644
index 000000000..a3c46a46a
--- /dev/null
+++ b/contrib/draco/src/draco/core/vector_d.h
@@ -0,0 +1,355 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_CORE_VECTOR_D_H_
+#define DRACO_CORE_VECTOR_D_H_
+
+#include <inttypes.h>
+
+#include <algorithm>
+#include <array>
+#include <cmath>
+#include <limits>
+
+#include "draco/core/macros.h"
+
+namespace draco {
+// D-dimensional vector class with basic operations.
+template <class ScalarT, int dimension_t>
+class VectorD {
+ public:
+  static constexpr int dimension = dimension_t;
+
+  typedef ScalarT Scalar;
+  typedef VectorD<Scalar, dimension_t> Self;
+
+  // TODO(hemmer): Deprecate.
+  typedef ScalarT CoefficientType;
+
+  VectorD() {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] = Scalar(0);
+    }
+  }
+
+  // The following constructor does not compile in opt mode, which for now led
+  // to the constructors further down, which is not ideal.
+  // TODO(hemmer): fix constructor below and remove others.
+  // template <typename... Args>
+  // explicit VectorD(Args... args) : v_({args...}) {}
+
+  VectorD(const Scalar &c0, const Scalar &c1) : v_({{c0, c1}}) {
+    DRACO_DCHECK_EQ(dimension, 2);
+    v_[0] = c0;
+    v_[1] = c1;
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2)
+      : v_({{c0, c1, c2}}) {
+    DRACO_DCHECK_EQ(dimension, 3);
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2,
+          const Scalar &c3)
+      : v_({{c0, c1, c2, c3}}) {
+    DRACO_DCHECK_EQ(dimension, 4);
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2,
+          const Scalar &c3, const Scalar &c4)
+      : v_({{c0, c1, c2, c3, c4}}) {
+    DRACO_DCHECK_EQ(dimension, 5);
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2,
+          const Scalar &c3, const Scalar &c4, const Scalar &c5)
+      : v_({{c0, c1, c2, c3, c4, c5}}) {
+    DRACO_DCHECK_EQ(dimension, 6);
+  }
+
+  VectorD(const Scalar &c0, const Scalar &c1, const Scalar &c2,
+          const Scalar &c3, const Scalar &c4, const Scalar &c5,
+          const Scalar &c6)
+      : v_({{c0, c1, c2, c3, c4, c5, c6}}) {
+    DRACO_DCHECK_EQ(dimension, 7);
+  }
+
+  VectorD(const Self &o) {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] = o[i];
+    }
+  }
+
+  // Constructs the vector from another vector with a different data type or a
+  // different number of components. If the |src_vector| has more components
+  // than |this| vector, the excess components are truncated. If the
+  // |src_vector| has fewer components than |this| vector, the remaining
+  // components are padded with 0.
+  // Note that the constructor is intentionally explicit to avoid accidental
+  // conversions between different vector types.
+  template <class OtherScalarT, int other_dimension_t>
+  explicit VectorD(const VectorD<OtherScalarT, other_dimension_t> &src_vector) {
+    for (int i = 0; i < dimension; ++i) {
+      if (i < other_dimension_t) {
+        v_[i] = Scalar(src_vector[i]);
+      } else {
+        v_[i] = Scalar(0);
+      }
+    }
+  }
+
+  Scalar &operator[](int i) { return v_[i]; }
+  const Scalar &operator[](int i) const { return v_[i]; }
+  // TODO(hemmer): remove.
+  // Similar to interface of Eigen library.
+  Scalar &operator()(int i) { return v_[i]; }
+  const Scalar &operator()(int i) const { return v_[i]; }
+
+  // Unary operators.
+  Self operator-() const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = -(*this)[i];
+    }
+    return ret;
+  }
+
+  // Binary operators.
+  Self operator+(const Self &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] + o[i];
+    }
+    return ret;
+  }
+
+  Self operator-(const Self &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] - o[i];
+    }
+    return ret;
+  }
+
+  Self operator*(const Self &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] * o[i];
+    }
+    return ret;
+  }
+
+  Self &operator+=(const Self &o) {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] += o[i];
+    }
+    return *this;
+  }
+
+  Self &operator-=(const Self &o) {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] -= o[i];
+    }
+    return *this;
+  }
+
+  Self &operator*=(const Self &o) {
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] *= o[i];
+    }
+    return *this;
+  }
+
+  Self operator*(const Scalar &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] * o;
+    }
+    return ret;
+  }
+
+  Self operator/(const Scalar &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] / o;
+    }
+    return ret;
+  }
+
+  Self operator+(const Scalar &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] + o;
+    }
+    return ret;
+  }
+
+  Self operator-(const Scalar &o) const {
+    Self ret;
+    for (int i = 0; i < dimension; ++i) {
+      ret[i] = (*this)[i] - o;
+    }
+    return ret;
+  }
+
+  bool operator==(const Self &o) const {
+    for (int i = 0; i < dimension; ++i) {
+      if ((*this)[i] != o[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  bool operator!=(const Self &x) const { return !((*this) == x); }
+
+  bool operator<(const Self &x) const {
+    for (int i = 0; i < dimension - 1; ++i) {
+      if (v_[i] < x.v_[i]) {
+        return true;
+      }
+      if (v_[i] > x.v_[i]) {
+        return false;
+      }
+    }
+    // Only one check needed for the last dimension.
+    if (v_[dimension - 1] < x.v_[dimension - 1]) {
+      return true;
+    }
+    return false;
+  }
+
+  // Functions.
+  Scalar SquaredNorm() const { return this->Dot(*this); }
+
+  // Computes L1, the sum of absolute values of all entries.
+  Scalar AbsSum() const {
+    Scalar result(0);
+    for (int i = 0; i < dimension; ++i) {
+      Scalar next_value = std::abs(v_[i]);
+      if (result > std::numeric_limits<Scalar>::max() - next_value) {
+        // Return the max if adding would have caused an overflow.
+        return std::numeric_limits<Scalar>::max();
+      }
+      result += next_value;
+    }
+    return result;
+  }
+
+  Scalar Dot(const Self &o) const {
+    Scalar ret(0);
+    for (int i = 0; i < dimension; ++i) {
+      ret += (*this)[i] * o[i];
+    }
+    return ret;
+  }
+
+  void Normalize() {
+    const Scalar magnitude = std::sqrt(this->SquaredNorm());
+    if (magnitude == 0) {
+      return;
+    }
+    for (int i = 0; i < dimension; ++i) {
+      (*this)[i] /= magnitude;
+    }
+  }
+
+  Self GetNormalized() const {
+    Self ret(*this);
+    ret.Normalize();
+    return ret;
+  }
+
+  const Scalar &MaxCoeff() const {
+    return *std::max_element(v_.begin(), v_.end());
+  }
+
+  const Scalar &MinCoeff() const {
+    return *std::min_element(v_.begin(), v_.end());
+  }
+
+  Scalar *data() { return &(v_[0]); }
+  const Scalar *data() const { return &(v_[0]); }
+
+ private:
+  std::array<Scalar, dimension> v_;
+};
+
+// Scalar multiplication from the other side too.
+template <class ScalarT, int dimension_t>
+VectorD<ScalarT, dimension_t> operator*(
+    const ScalarT &o, const VectorD<ScalarT, dimension_t> &v) {
+  return v * o;
+}
+
+// Calculates the squared distance between two points.
+template <class ScalarT, int dimension_t>
+ScalarT SquaredDistance(const VectorD<ScalarT, dimension_t> &v1,
+                        const VectorD<ScalarT, dimension_t> &v2) {
+  ScalarT difference;
+  ScalarT squared_distance = 0;
+  // Check each index separately so difference is never negative and underflow
+  // is avoided for unsigned types.
+  for (int i = 0; i < dimension_t; ++i) {
+    if (v1[i] >= v2[i]) {
+      difference = v1[i] - v2[i];
+    } else {
+      difference = v2[i] - v1[i];
+    }
+    squared_distance += (difference * difference);
+  }
+  return squared_distance;
+}
+
+// Global function computing the cross product of two 3D vectors.
+template <class ScalarT>
+VectorD<ScalarT, 3> CrossProduct(const VectorD<ScalarT, 3> &u,
+                                 const VectorD<ScalarT, 3> &v) {
+  // Preventing accidental use with uint32_t and the like.
+  static_assert(std::is_signed<ScalarT>::value,
+                "ScalarT must be a signed type. ");
+  VectorD<ScalarT, 3> r;
+  r[0] = (u[1] * v[2]) - (u[2] * v[1]);
+  r[1] = (u[2] * v[0]) - (u[0] * v[2]);
+  r[2] = (u[0] * v[1]) - (u[1] * v[0]);
+  return r;
+}
+
+template <class ScalarT, int dimension_t>
+inline std::ostream &operator<<(
+    std::ostream &out, const draco::VectorD<ScalarT, dimension_t> &vec) {
+  for (int i = 0; i < dimension_t - 1; ++i) {
+    out << vec[i] << " ";
+  }
+  out << vec[dimension_t - 1];
+  return out;
+}
+
+typedef VectorD<float, 2> Vector2f;
+typedef VectorD<float, 3> Vector3f;
+typedef VectorD<float, 4> Vector4f;
+typedef VectorD<float, 5> Vector5f;
+typedef VectorD<float, 6> Vector6f;
+typedef VectorD<float, 7> Vector7f;
+
+typedef VectorD<uint32_t, 2> Vector2ui;
+typedef VectorD<uint32_t, 3> Vector3ui;
+typedef VectorD<uint32_t, 4> Vector4ui;
+typedef VectorD<uint32_t, 5> Vector5ui;
+typedef VectorD<uint32_t, 6> Vector6ui;
+typedef VectorD<uint32_t, 7> Vector7ui;
+
+}  // namespace draco
+
+#endif  // DRACO_CORE_VECTOR_D_H_
diff --git a/contrib/draco/src/draco/core/vector_d_test.cc b/contrib/draco/src/draco/core/vector_d_test.cc
new file mode 100644
index 000000000..d66128fb1
--- /dev/null
+++ b/contrib/draco/src/draco/core/vector_d_test.cc
@@ -0,0 +1,306 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/core/vector_d.h"
+
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+
+namespace {
+
+typedef draco::Vector2f Vector2f;
+typedef draco::Vector3f Vector3f;
+typedef draco::Vector4f Vector4f;
+typedef draco::Vector5f Vector5f;
+typedef draco::Vector2ui Vector2ui;
+typedef draco::Vector3ui Vector3ui;
+typedef draco::Vector4ui Vector4ui;
+typedef draco::Vector5ui Vector5ui;
+
+typedef draco::VectorD<int32_t, 3> Vector3i;
+typedef draco::VectorD<int32_t, 4> Vector4i;
+
+template <class CoeffT, int dimension_t>
+void TestSquaredDistance(const draco::VectorD<CoeffT, dimension_t> v1,
+                         const draco::VectorD<CoeffT, dimension_t> v2,
+                         const CoeffT result) {
+  CoeffT squared_distance = SquaredDistance(v1, v2);
+  ASSERT_EQ(squared_distance, result);
+  squared_distance = SquaredDistance(v2, v1);
+  ASSERT_EQ(squared_distance, result);
+}
+
+TEST(VectorDTest, TestOperators) {
+  {
+    const Vector3f v;
+    ASSERT_EQ(v[0], 0);
+    ASSERT_EQ(v[1], 0);
+    ASSERT_EQ(v[2], 0);
+  }
+  Vector3f v(1, 2, 3);
+  ASSERT_EQ(v[0], 1);
+  ASSERT_EQ(v[1], 2);
+  ASSERT_EQ(v[2], 3);
+
+  Vector3f w = v;
+  ASSERT_TRUE(v == w);
+  ASSERT_FALSE(v != w);
+  ASSERT_EQ(w[0], 1);
+  ASSERT_EQ(w[1], 2);
+  ASSERT_EQ(w[2], 3);
+
+  w = -v;
+  ASSERT_EQ(w[0], -1);
+  ASSERT_EQ(w[1], -2);
+  ASSERT_EQ(w[2], -3);
+
+  w = v + v;
+  ASSERT_EQ(w[0], 2);
+  ASSERT_EQ(w[1], 4);
+  ASSERT_EQ(w[2], 6);
+
+  w = w - v;
+  ASSERT_EQ(w[0], 1);
+  ASSERT_EQ(w[1], 2);
+  ASSERT_EQ(w[2], 3);
+
+  // Scalar multiplication from left and right.
+  w = v * 2.f;
+  ASSERT_EQ(w[0], 2);
+  ASSERT_EQ(w[1], 4);
+  ASSERT_EQ(w[2], 6);
+  w = 2.f * v;
+  ASSERT_EQ(w[0], 2);
+  ASSERT_EQ(w[1], 4);
+  ASSERT_EQ(w[2], 6);
+
+  ASSERT_EQ(v.SquaredNorm(), 14);
+  ASSERT_EQ(v.Dot(v), 14);
+
+  Vector3f new_v = v;
+  new_v.Normalize();
+  const float tolerance = 1e-5;
+  const float magnitude = std::sqrt(v.SquaredNorm());
+  const float new_magnitude = std::sqrt(new_v.SquaredNorm());
+  ASSERT_NEAR(new_magnitude, 1, tolerance);
+  for (int i = 0; i < 3; ++i) {
+    new_v[i] *= magnitude;
+    ASSERT_NEAR(new_v[i], v[i], tolerance);
+  }
+
+  Vector3f x(0, 0, 0);
+  x.Normalize();
+  for (int i = 0; i < 3; ++i) {
+    ASSERT_EQ(0, x[i]);
+  }
+}
+
+TEST(VectorDTest, TestAdditionAssignmentOperator) {
+  Vector3ui v(1, 2, 3);
+  Vector3ui w(4, 5, 6);
+
+  w += v;
+  ASSERT_EQ(w[0], 5);
+  ASSERT_EQ(w[1], 7);
+  ASSERT_EQ(w[2], 9);
+
+  w += w;
+  ASSERT_EQ(w[0], 10);
+  ASSERT_EQ(w[1], 14);
+  ASSERT_EQ(w[2], 18);
+}
+
+TEST(VectorDTest, TestSubtractionAssignmentOperator) {
+  Vector3ui v(1, 2, 3);
+  Vector3ui w(4, 6, 8);
+
+  w -= v;
+  ASSERT_EQ(w[0], 3);
+  ASSERT_EQ(w[1], 4);
+  ASSERT_EQ(w[2], 5);
+
+  w -= w;
+  ASSERT_EQ(w[0], 0);
+  ASSERT_EQ(w[1], 0);
+  ASSERT_EQ(w[2], 0);
+}
+
+TEST(VectorDTest, TestMultiplicationAssignmentOperator) {
+  Vector3ui v(1, 2, 3);
+  Vector3ui w(4, 5, 6);
+
+  w *= v;
+  ASSERT_EQ(w[0], 4);
+  ASSERT_EQ(w[1], 10);
+  ASSERT_EQ(w[2], 18);
+
+  v *= v;
+  ASSERT_EQ(v[0], 1);
+  ASSERT_EQ(v[1], 4);
+  ASSERT_EQ(v[2], 9);
+}
+
+TEST(VectorTest, TestGetNormalized) {
+  const Vector3f original(2, 3, -4);
+  const Vector3f normalized = original.GetNormalized();
+  const float magnitude = sqrt(original.SquaredNorm());
+  const float tolerance = 1e-5f;
+  ASSERT_NEAR(normalized[0], original[0] / magnitude, tolerance);
+  ASSERT_NEAR(normalized[1], original[1] / magnitude, tolerance);
+  ASSERT_NEAR(normalized[2], original[2] / magnitude, tolerance);
+}
+
+TEST(VectorTest, TestGetNormalizedWithZeroLengthVector) {
+  const Vector3f original(0, 0, 0);
+  const Vector3f normalized = original.GetNormalized();
+  ASSERT_EQ(normalized[0], 0);
+  ASSERT_EQ(normalized[1], 0);
+  ASSERT_EQ(normalized[2], 0);
+}
+
+TEST(VectorDTest, TestSquaredDistance) {
+  // Test Vector2f: float, 2D.
+  Vector2f v1_2f(5.5, 10.5);
+  Vector2f v2_2f(3.5, 15.5);
+  float result_f = 29;
+  TestSquaredDistance(v1_2f, v2_2f, result_f);
+
+  // Test Vector3f: float, 3D.
+  Vector3f v1_3f(5.5, 10.5, 2.3);
+  Vector3f v2_3f(3.5, 15.5, 0);
+  result_f = 34.29;
+  TestSquaredDistance(v1_3f, v2_3f, result_f);
+
+  // Test Vector4f: float, 4D.
+  Vector4f v1_4f(5.5, 10.5, 2.3, 7.2);
+  Vector4f v2_4f(3.5, 15.5, 0, 9.9);
+  result_f = 41.58;
+  TestSquaredDistance(v1_4f, v2_4f, result_f);
+
+  // Test Vector5f: float, 5D.
+  Vector5f v1_5f(5.5, 10.5, 2.3, 7.2, 1.0);
+  Vector5f v2_5f(3.5, 15.5, 0, 9.9, 0.2);
+  result_f = 42.22;
+  TestSquaredDistance(v1_5f, v2_5f, result_f);
+
+  // Test Vector 2ui: uint32_t, 2D.
+  Vector2ui v1_2ui(5, 10);
+  Vector2ui v2_2ui(3, 15);
+  uint32_t result_ui = 29;
+  TestSquaredDistance(v1_2ui, v2_2ui, result_ui);
+
+  // Test Vector 3ui: uint32_t, 3D.
+  Vector3ui v1_3ui(5, 10, 2);
+  Vector3ui v2_3ui(3, 15, 0);
+  result_ui = 33;
+  TestSquaredDistance(v1_3ui, v2_3ui, result_ui);
+
+  // Test Vector 4ui: uint32_t, 4D.
+  Vector4ui v1_4ui(5, 10, 2, 7);
+  Vector4ui v2_4ui(3, 15, 0, 9);
+  result_ui = 37;
+  TestSquaredDistance(v1_4ui, v2_4ui, result_ui);
+
+  // Test Vector 5ui: uint32_t, 5D.
+  Vector5ui v1_5ui(5, 10, 2, 7, 1);
+  Vector5ui v2_5ui(3, 15, 0, 9, 12);
+  result_ui = 158;
+  TestSquaredDistance(v1_5ui, v2_5ui, result_ui);
+}
+
+TEST(VectorDTest, TestCrossProduct3D) {
+  const Vector3i e1(1, 0, 0);
+  const Vector3i e2(0, 1, 0);
+  const Vector3i e3(0, 0, 1);
+  const Vector3i o(0, 0, 0);
+  ASSERT_EQ(e3, draco::CrossProduct(e1, e2));
+  ASSERT_EQ(e1, draco::CrossProduct(e2, e3));
+  ASSERT_EQ(e2, draco::CrossProduct(e3, e1));
+  ASSERT_EQ(-e3, draco::CrossProduct(e2, e1));
+  ASSERT_EQ(-e1, draco::CrossProduct(e3, e2));
+  ASSERT_EQ(-e2, draco::CrossProduct(e1, e3));
+  ASSERT_EQ(o, draco::CrossProduct(e1, e1));
+  ASSERT_EQ(o, draco::CrossProduct(e2, e2));
+  ASSERT_EQ(o, draco::CrossProduct(e3, e3));
+
+  // Orthogonality of result for some general vectors.
+  const Vector3i v1(123, -62, 223);
+  const Vector3i v2(734, 244, -13);
+  const Vector3i orth = draco::CrossProduct(v1, v2);
+  ASSERT_EQ(0, v1.Dot(orth));
+  ASSERT_EQ(0, v2.Dot(orth));
+}
+
+TEST(VectorDTest, TestAbsSum) {
+  // Testing const of function and zero.
+  const Vector3i v(0, 0, 0);
+  ASSERT_EQ(v.AbsSum(), 0);
+  // Testing semantic.
+  ASSERT_EQ(Vector3i(0, 0, 0).AbsSum(), 0);
+  ASSERT_EQ(Vector3i(1, 2, 3).AbsSum(), 6);
+  ASSERT_EQ(Vector3i(-1, -2, -3).AbsSum(), 6);
+  ASSERT_EQ(Vector3i(-2, 4, -8).AbsSum(), 14);
+  // Other dimension.
+  ASSERT_EQ(Vector4i(-2, 4, -8, 3).AbsSum(), 17);
+}
+
+TEST(VectorDTest, TestMinMaxCoeff) {
+  // Test verifies that MinCoeff() and MaxCoeff() functions work as intended.
+  const Vector4i vi(-10, 5, 2, 3);
+  ASSERT_EQ(vi.MinCoeff(), -10);
+  ASSERT_EQ(vi.MaxCoeff(), 5);
+
+  const Vector3f vf(6.f, 1000.f, -101.f);
+  ASSERT_EQ(vf.MinCoeff(), -101.f);
+  ASSERT_EQ(vf.MaxCoeff(), 1000.f);
+}
+
+TEST(VectorDTest, TestOstream) {
+  // Tests that the vector can be stored in a provided std::ostream.
+  const draco::VectorD<int64_t, 3> vector(1, 2, 3);
+  std::stringstream str;
+  str << vector << " ";
+  ASSERT_EQ(str.str(), "1 2 3 ");
+}
+
+TEST(VectorDTest, TestConvertConstructor) {
+  // Tests that a vector can be constructed from another vector with a different
+  // type.
+  const draco::VectorD<int64_t, 3> vector(1, 2, 3);
+
+  const draco::VectorD<float, 3> vector3f(vector);
+  ASSERT_EQ(vector3f, draco::Vector3f(1.f, 2.f, 3.f));
+
+  const draco::VectorD<float, 2> vector2f(vector);
+  ASSERT_EQ(vector2f, draco::Vector2f(1.f, 2.f));
+
+  const draco::VectorD<float, 4> vector4f(vector3f);
+  ASSERT_EQ(vector4f, draco::Vector4f(1.f, 2.f, 3.f, 0.f));
+
+  const draco::VectorD<double, 1> vector1d(vector3f);
+  ASSERT_EQ(vector1d[0], 1.0);
+}
+
+TEST(VectorDTest, TestBinaryOps) {
+  // Tests the binary multiplication operator of the VectorD class.
+  const draco::Vector4f vector_0(1.f, 2.3f, 4.2f, -10.f);
+  ASSERT_EQ(vector_0 * draco::Vector4f(1.f, 1.f, 1.f, 1.f), vector_0);
+  ASSERT_EQ(vector_0 * draco::Vector4f(0.f, 0.f, 0.f, 0.f),
+            draco::Vector4f(0.f, 0.f, 0.f, 0.f));
+  ASSERT_EQ(vector_0 * draco::Vector4f(0.1f, 0.2f, 0.3f, 0.4f),
+            draco::Vector4f(0.1f, 0.46f, 1.26f, -4.f));
+}
+
+}  // namespace
diff --git a/contrib/draco/src/draco/io/file_reader_factory.cc b/contrib/draco/src/draco/io/file_reader_factory.cc
new file mode 100644
index 000000000..ac7b09288
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_reader_factory.cc
@@ -0,0 +1,45 @@
+#include "draco/io/file_reader_factory.h"
+
+#include <vector>
+
+namespace draco {
+namespace {
+
+#define FILEREADER_LOG_ERROR(error_string)                             \
+  do {                                                                 \
+    fprintf(stderr, "%s:%d (%s): %s.\n", __FILE__, __LINE__, __func__, \
+            error_string);                                             \
+  } while (false)
+
+std::vector<FileReaderFactory::OpenFunction> *GetFileReaderOpenFunctions() {
+  static auto open_functions =
+      new (std::nothrow) std::vector<FileReaderFactory::OpenFunction>();
+  return open_functions;
+}
+
+}  // namespace
+
+bool FileReaderFactory::RegisterReader(OpenFunction open_function) {
+  if (open_function == nullptr) {
+    return false;
+  }
+  auto open_functions = GetFileReaderOpenFunctions();
+  const size_t num_readers = open_functions->size();
+  open_functions->push_back(open_function);
+  return open_functions->size() == num_readers + 1;
+}
+
+std::unique_ptr<FileReaderInterface> FileReaderFactory::OpenReader(
+    const std::string &file_name) {
+  for (auto open_function : *GetFileReaderOpenFunctions()) {
+    auto reader = open_function(file_name);
+    if (reader == nullptr) {
+      continue;
+    }
+    return reader;
+  }
+  FILEREADER_LOG_ERROR("No file reader able to open input");
+  return nullptr;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/file_reader_factory.h b/contrib/draco/src/draco/io/file_reader_factory.h
new file mode 100644
index 000000000..12bd7a5af
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_reader_factory.h
@@ -0,0 +1,34 @@
+#ifndef DRACO_IO_FILE_READER_FACTORY_H_
+#define DRACO_IO_FILE_READER_FACTORY_H_
+
+#include <memory>
+#include <string>
+
+#include "draco/io/file_reader_interface.h"
+
+namespace draco {
+
+class FileReaderFactory {
+ public:
+  using OpenFunction =
+      std::unique_ptr<FileReaderInterface> (*)(const std::string &file_name);
+
+  FileReaderFactory() = delete;
+  FileReaderFactory(const FileReaderFactory &) = delete;
+  FileReaderFactory &operator=(const FileReaderFactory &) = delete;
+  ~FileReaderFactory() = default;
+
+  // Registers the OpenFunction for a FileReaderInterface and returns true when
+  // registration succeeds.
+  static bool RegisterReader(OpenFunction open_function);
+
+  // Passes |file_name| to each OpenFunction until one succeeds. Returns nullptr
+  // when no reader is found for |file_name|. Otherwise a FileReaderInterface is
+  // returned.
+  static std::unique_ptr<FileReaderInterface> OpenReader(
+      const std::string &file_name);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_READER_FACTORY_H_
diff --git a/contrib/draco/src/draco/io/file_reader_factory_test.cc b/contrib/draco/src/draco/io/file_reader_factory_test.cc
new file mode 100644
index 000000000..d304d6345
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_reader_factory_test.cc
@@ -0,0 +1,85 @@
+#include "draco/io/file_reader_factory.h"
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/io/file_reader_interface.h"
+
+namespace draco {
+namespace {
+
+class AlwaysFailFileReader : public FileReaderInterface {
+ public:
+  static std::unique_ptr<FileReaderInterface> Open(
+      const std::string & /*file_name*/) {
+    return nullptr;
+  }
+
+  AlwaysFailFileReader() = delete;
+  AlwaysFailFileReader(const AlwaysFailFileReader &) = delete;
+  AlwaysFailFileReader &operator=(const AlwaysFailFileReader &) = delete;
+  // Note this isn't overridden as the class can never be instantiated. This
+  // avoids an unused function warning.
+  // ~AlwaysFailFileReader() override = default;
+
+  bool ReadFileToBuffer(std::vector<char> * /*buffer*/) override {
+    return false;
+  }
+
+  bool ReadFileToBuffer(std::vector<uint8_t> * /*buffer*/) override {
+    return false;
+  }
+
+  size_t GetFileSize() override { return 0; }
+
+ private:
+  static bool is_registered_;
+};
+
+class AlwaysOkFileReader : public FileReaderInterface {
+ public:
+  static std::unique_ptr<FileReaderInterface> Open(
+      const std::string & /*file_name*/) {
+    return std::unique_ptr<AlwaysOkFileReader>(new AlwaysOkFileReader());
+  }
+
+  AlwaysOkFileReader(const AlwaysOkFileReader &) = delete;
+  AlwaysOkFileReader &operator=(const AlwaysOkFileReader &) = delete;
+  ~AlwaysOkFileReader() override = default;
+
+  bool ReadFileToBuffer(std::vector<char> * /*buffer*/) override {
+    return true;
+  }
+
+  bool ReadFileToBuffer(std::vector<uint8_t> * /*buffer*/) override {
+    return true;
+  }
+
+  size_t GetFileSize() override { return 0; }
+
+ private:
+  AlwaysOkFileReader() = default;
+  static bool is_registered_;
+};
+
+bool AlwaysFailFileReader::is_registered_ =
+    FileReaderFactory::RegisterReader(AlwaysFailFileReader::Open);
+
+bool AlwaysOkFileReader::is_registered_ =
+    FileReaderFactory::RegisterReader(AlwaysOkFileReader::Open);
+
+TEST(FileReaderFactoryTest, RegistrationFail) {
+  EXPECT_FALSE(FileReaderFactory::RegisterReader(nullptr));
+}
+
+TEST(FileReaderFactoryTest, OpenReader) {
+  auto reader = FileReaderFactory::OpenReader("fake file");
+  EXPECT_NE(reader, nullptr);
+  std::vector<char> *buffer = nullptr;
+  EXPECT_TRUE(reader->ReadFileToBuffer(buffer));
+}
+
+}  // namespace
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/file_reader_interface.h b/contrib/draco/src/draco/io/file_reader_interface.h
new file mode 100644
index 000000000..a6e6a0da0
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_reader_interface.h
@@ -0,0 +1,32 @@
+#ifndef DRACO_IO_FILE_READER_INTERFACE_H_
+#define DRACO_IO_FILE_READER_INTERFACE_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+namespace draco {
+
+class FileReaderInterface {
+ public:
+  FileReaderInterface() = default;
+  FileReaderInterface(const FileReaderInterface &) = delete;
+  FileReaderInterface &operator=(const FileReaderInterface &) = delete;
+
+  FileReaderInterface(FileReaderInterface &&) = default;
+  FileReaderInterface &operator=(FileReaderInterface &&) = default;
+
+  // Closes the file.
+  virtual ~FileReaderInterface() = default;
+
+  // Reads the entire contents of the input file into |buffer| and returns true.
+  virtual bool ReadFileToBuffer(std::vector<char> *buffer) = 0;
+  virtual bool ReadFileToBuffer(std::vector<uint8_t> *buffer) = 0;
+
+  // Returns the size of the file.
+  virtual size_t GetFileSize() = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_READER_INTERFACE_H_
diff --git a/contrib/draco/src/draco/io/file_reader_test_common.h b/contrib/draco/src/draco/io/file_reader_test_common.h
new file mode 100644
index 000000000..0d07d4a54
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_reader_test_common.h
@@ -0,0 +1,13 @@
+#ifndef DRACO_IO_FILE_READER_TEST_COMMON_H_
+#define DRACO_IO_FILE_READER_TEST_COMMON_H_
+
+#include <cstddef>
+
+namespace draco {
+
+const size_t kFileSizeCarDrc = 69892;
+const size_t kFileSizeCubePcDrc = 224;
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_READER_TEST_COMMON_H_
diff --git a/contrib/draco/src/draco/io/file_utils.cc b/contrib/draco/src/draco/io/file_utils.cc
new file mode 100644
index 000000000..f93cbd899
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_utils.cc
@@ -0,0 +1,110 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/file_utils.h"
+
+#include "draco/io/file_reader_factory.h"
+#include "draco/io/file_reader_interface.h"
+#include "draco/io/file_writer_factory.h"
+#include "draco/io/file_writer_interface.h"
+#include "draco/io/file_writer_utils.h"
+#include "draco/io/parser_utils.h"
+
+namespace draco {
+
+void SplitPath(const std::string &full_path, std::string *out_folder_path,
+               std::string *out_file_name) {
+  SplitPathPrivate(full_path, out_folder_path, out_file_name);
+}
+
+std::string ReplaceFileExtension(const std::string &in_file_name,
+                                 const std::string &new_extension) {
+  const auto pos = in_file_name.find_last_of(".");
+  if (pos == std::string::npos) {
+    // No extension found.
+    return in_file_name + "." + new_extension;
+  }
+  return in_file_name.substr(0, pos + 1) + new_extension;
+}
+
+std::string LowercaseFileExtension(const std::string &filename) {
+  const size_t pos = filename.find_last_of('.');
+  if (pos == 0 || pos == std::string::npos || pos == filename.length() - 1) {
+    return "";
+  }
+  return parser::ToLower(filename.substr(pos + 1));
+}
+
+std::string GetFullPath(const std::string &input_file_relative_path,
+                        const std::string &sibling_file_full_path) {
+  const auto pos = sibling_file_full_path.find_last_of("/\\");
+  std::string input_file_full_path;
+  if (pos != std::string::npos) {
+    input_file_full_path = sibling_file_full_path.substr(0, pos + 1);
+  }
+  input_file_full_path += input_file_relative_path;
+  return input_file_full_path;
+}
+
+bool ReadFileToBuffer(const std::string &file_name, std::vector<char> *buffer) {
+  std::unique_ptr<FileReaderInterface> file_reader =
+      FileReaderFactory::OpenReader(file_name);
+  if (file_reader == nullptr) {
+    return false;
+  }
+  return file_reader->ReadFileToBuffer(buffer);
+}
+
+bool ReadFileToBuffer(const std::string &file_name,
+                      std::vector<uint8_t> *buffer) {
+  std::unique_ptr<FileReaderInterface> file_reader =
+      FileReaderFactory::OpenReader(file_name);
+  if (file_reader == nullptr) {
+    return false;
+  }
+  return file_reader->ReadFileToBuffer(buffer);
+}
+
+bool WriteBufferToFile(const char *buffer, size_t buffer_size,
+                       const std::string &file_name) {
+  std::unique_ptr<FileWriterInterface> file_writer =
+      FileWriterFactory::OpenWriter(file_name);
+  if (file_writer == nullptr) {
+    return false;
+  }
+  return file_writer->Write(buffer, buffer_size);
+}
+
+bool WriteBufferToFile(const unsigned char *buffer, size_t buffer_size,
+                       const std::string &file_name) {
+  return WriteBufferToFile(reinterpret_cast<const char *>(buffer), buffer_size,
+                           file_name);
+}
+
+bool WriteBufferToFile(const void *buffer, size_t buffer_size,
+                       const std::string &file_name) {
+  return WriteBufferToFile(reinterpret_cast<const char *>(buffer), buffer_size,
+                           file_name);
+}
+
+size_t GetFileSize(const std::string &file_name) {
+  std::unique_ptr<FileReaderInterface> file_reader =
+      FileReaderFactory::OpenReader(file_name);
+  if (file_reader == nullptr) {
+    return 0;
+  }
+  return file_reader->GetFileSize();
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/file_utils.h b/contrib/draco/src/draco/io/file_utils.h
new file mode 100644
index 000000000..4b734e049
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_utils.h
@@ -0,0 +1,73 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_FILE_UTILS_H_
+#define DRACO_IO_FILE_UTILS_H_
+
+#include <string>
+#include <vector>
+
+namespace draco {
+
+// Splits full path to a file into a folder path + file name.
+// |out_folder_path| will contain the path to the folder containing the file
+// excluding the final slash. If no folder is specified in the |full_path|, then
+// |out_folder_path| is set to "."
+void SplitPath(const std::string &full_path, std::string *out_folder_path,
+               std::string *out_file_name);
+
+// Replaces file extension in |in_file_name| with |new_extension|.
+// If |in_file_name| does not have any extension, the extension is appended.
+std::string ReplaceFileExtension(const std::string &in_file_name,
+                                 const std::string &new_extension);
+
+// Returns the file extension in lowercase if present, else "". Extension is
+// defined as the string after the last '.' character. If the file starts with
+// '.' (e.g. Linux hidden files), the first delimiter is ignored.
+std::string LowercaseFileExtension(const std::string &filename);
+
+// Given a path of the input file |input_file_relative_path| relative to the
+// parent directory of |sibling_file_full_path|, this function returns full path
+// to the input file. If |sibling_file_full_path| has no directory, the relative
+// path itself |input_file_relative_path| is returned. A common use case is for
+// the |input_file_relative_path| to be just a file name. See usage examples in
+// the unit test.
+std::string GetFullPath(const std::string &input_file_relative_path,
+                        const std::string &sibling_file_full_path);
+
+// Convenience method. Uses draco::FileReaderFactory internally. Reads contents
+// of file referenced by |file_name| into |buffer| and returns true upon
+// success.
+bool ReadFileToBuffer(const std::string &file_name, std::vector<char> *buffer);
+bool ReadFileToBuffer(const std::string &file_name,
+                      std::vector<uint8_t> *buffer);
+
+// Convenience method. Uses draco::FileWriterFactory internally. Writes contents
+// of |buffer| to file referred to by |file_name|. File is overwritten if it
+// exists. Returns true after successful write.
+bool WriteBufferToFile(const char *buffer, size_t buffer_size,
+                       const std::string &file_name);
+bool WriteBufferToFile(const unsigned char *buffer, size_t buffer_size,
+                       const std::string &file_name);
+bool WriteBufferToFile(const void *buffer, size_t buffer_size,
+                       const std::string &file_name);
+
+// Convenience method. Uses draco::FileReaderFactory internally. Returns size of
+// file referenced by |file_name|. Returns 0 when referenced file is empty or
+// does not exist.
+size_t GetFileSize(const std::string &file_name);
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_UTILS_H_
diff --git a/contrib/draco/src/draco/io/file_utils_test.cc b/contrib/draco/src/draco/io/file_utils_test.cc
new file mode 100644
index 000000000..4085ff0cd
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_utils_test.cc
@@ -0,0 +1,69 @@
+// Copyright 2018 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/file_utils.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+
+namespace {
+
+TEST(FileUtilsTest, SplitsPath) {
+  // Tests that the function SplitPath correctly splits a set of test paths.
+  std::string folder_path, file_name;
+  draco::SplitPath("file.x", &folder_path, &file_name);
+  ASSERT_EQ(folder_path, ".");
+  ASSERT_EQ(file_name, "file.x");
+
+  draco::SplitPath("a/b/file.y", &folder_path, &file_name);
+  ASSERT_EQ(folder_path, "a/b");
+  ASSERT_EQ(file_name, "file.y");
+
+  draco::SplitPath("//a/b/c/d/file.z", &folder_path, &file_name);
+  ASSERT_EQ(folder_path, "//a/b/c/d");
+  ASSERT_EQ(file_name, "file.z");
+}
+
+TEST(FileUtilsTest, ReplaceExtension) {
+  // Tests that the function ReplaceFileExtension correctly replaces extensions
+  // of specified files.
+  ASSERT_EQ(draco::ReplaceFileExtension("a.abc", "x"), "a.x");
+  ASSERT_EQ(draco::ReplaceFileExtension("abc", "x"), "abc.x");  // No extension
+  ASSERT_EQ(draco::ReplaceFileExtension("a/b/c.d", "xyz"), "a/b/c.xyz");
+}
+
+TEST(FileUtilsTest, LowercaseFileExtension) {
+  ASSERT_EQ(draco::LowercaseFileExtension("image.jpeg"), "jpeg");
+  ASSERT_EQ(draco::LowercaseFileExtension("image.JPEG"), "jpeg");
+  ASSERT_EQ(draco::LowercaseFileExtension("image.png"), "png");
+  ASSERT_EQ(draco::LowercaseFileExtension("image.pNg"), "png");
+  ASSERT_EQ(draco::LowercaseFileExtension("FILE.glb"), "glb");
+  ASSERT_EQ(draco::LowercaseFileExtension(".file.gltf"), "gltf");
+  ASSERT_EQ(draco::LowercaseFileExtension("the.file.gltf"), "gltf");
+  ASSERT_EQ(draco::LowercaseFileExtension("FILE_glb"), "");
+  ASSERT_EQ(draco::LowercaseFileExtension(""), "");
+  ASSERT_EQ(draco::LowercaseFileExtension("image."), "");
+}
+
+TEST(FileUtilsTest, GetFullPath) {
+  // Tests that full path is returned when a sibling file has full path.
+  ASSERT_EQ(draco::GetFullPath("xo.png", "/d/i/r/xo.gltf"), "/d/i/r/xo.png");
+  ASSERT_EQ(draco::GetFullPath("buf/01.bin", "dir/xo.gltf"), "dir/buf/01.bin");
+  ASSERT_EQ(draco::GetFullPath("xo.mtl", "/xo.obj"), "/xo.mtl");
+
+  // Tests that only file name is returned when a sibling file has no full path.
+  ASSERT_EQ(draco::GetFullPath("xo.mtl", "xo.obj"), "xo.mtl");
+}
+
+}  // namespace
diff --git a/contrib/draco/src/draco/io/file_writer_factory.cc b/contrib/draco/src/draco/io/file_writer_factory.cc
new file mode 100644
index 000000000..cb6851602
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_writer_factory.cc
@@ -0,0 +1,45 @@
+#include "draco/io/file_writer_factory.h"
+
+#include <vector>
+
+namespace draco {
+namespace {
+
+#define FILEWRITER_LOG_ERROR(error_string)                             \
+  do {                                                                 \
+    fprintf(stderr, "%s:%d (%s): %s.\n", __FILE__, __LINE__, __func__, \
+            error_string);                                             \
+  } while (false)
+
+std::vector<FileWriterFactory::OpenFunction> *GetFileWriterOpenFunctions() {
+  static auto open_functions =
+      new (std::nothrow) std::vector<FileWriterFactory::OpenFunction>();
+  return open_functions;
+}
+
+}  // namespace
+
+bool FileWriterFactory::RegisterWriter(OpenFunction open_function) {
+  if (open_function == nullptr) {
+    return false;
+  }
+  auto open_functions = GetFileWriterOpenFunctions();
+  const size_t num_writers = open_functions->size();
+  open_functions->push_back(open_function);
+  return open_functions->size() == num_writers + 1;
+}
+
+std::unique_ptr<FileWriterInterface> FileWriterFactory::OpenWriter(
+    const std::string &file_name) {
+  for (auto open_function : *GetFileWriterOpenFunctions()) {
+    auto writer = open_function(file_name);
+    if (writer == nullptr) {
+      continue;
+    }
+    return writer;
+  }
+  FILEWRITER_LOG_ERROR("No file writer able to open output");
+  return nullptr;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/file_writer_factory.h b/contrib/draco/src/draco/io/file_writer_factory.h
new file mode 100644
index 000000000..ecf735d83
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_writer_factory.h
@@ -0,0 +1,34 @@
+#ifndef DRACO_IO_FILE_WRITER_FACTORY_H_
+#define DRACO_IO_FILE_WRITER_FACTORY_H_
+
+#include <memory>
+#include <string>
+
+#include "draco/io/file_writer_interface.h"
+
+namespace draco {
+
+class FileWriterFactory {
+ public:
+  using OpenFunction =
+      std::unique_ptr<FileWriterInterface> (*)(const std::string &file_name);
+
+  FileWriterFactory() = delete;
+  FileWriterFactory(const FileWriterFactory &) = delete;
+  FileWriterFactory &operator=(const FileWriterFactory &) = delete;
+  ~FileWriterFactory() = default;
+
+  // Registers the OpenFunction for a FileWriterInterface and returns true when
+  // registration succeeds.
+  static bool RegisterWriter(OpenFunction open_function);
+
+  // Passes |file_name| to each OpenFunction until one succeeds. Returns nullptr
+  // when no writer is found for |file_name|. Otherwise a FileWriterInterface is
+  // returned.
+  static std::unique_ptr<FileWriterInterface> OpenWriter(
+      const std::string &file_name);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_WRITER_FACTORY_H_
diff --git a/contrib/draco/src/draco/io/file_writer_factory_test.cc b/contrib/draco/src/draco/io/file_writer_factory_test.cc
new file mode 100644
index 000000000..fbad5cf7a
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_writer_factory_test.cc
@@ -0,0 +1,70 @@
+#include "draco/io/file_writer_factory.h"
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/io/file_writer_interface.h"
+
+namespace draco {
+namespace {
+
+class AlwaysFailFileWriter : public FileWriterInterface {
+ public:
+  static std::unique_ptr<FileWriterInterface> Open(
+      const std::string & /*file_name*/) {
+    return nullptr;
+  }
+
+  AlwaysFailFileWriter() = delete;
+  AlwaysFailFileWriter(const AlwaysFailFileWriter &) = delete;
+  AlwaysFailFileWriter &operator=(const AlwaysFailFileWriter &) = delete;
+  // Note this isn't overridden as the class can never be instantiated. This
+  // avoids an unused function warning.
+  // ~AlwaysFailFileWriter() override = default;
+
+  bool Write(const char * /*buffer*/, size_t /*size*/) override {
+    return false;
+  }
+
+ private:
+  static bool is_registered_;
+};
+
+class AlwaysOkFileWriter : public FileWriterInterface {
+ public:
+  static std::unique_ptr<FileWriterInterface> Open(
+      const std::string & /*file_name*/) {
+    return std::unique_ptr<AlwaysOkFileWriter>(new AlwaysOkFileWriter());
+  }
+
+  AlwaysOkFileWriter(const AlwaysOkFileWriter &) = delete;
+  AlwaysOkFileWriter &operator=(const AlwaysOkFileWriter &) = delete;
+  ~AlwaysOkFileWriter() override = default;
+
+  bool Write(const char * /*buffer*/, size_t /*size*/) override { return true; }
+
+ private:
+  AlwaysOkFileWriter() = default;
+  static bool is_registered_;
+};
+
+bool AlwaysFailFileWriter::is_registered_ =
+    FileWriterFactory::RegisterWriter(AlwaysFailFileWriter::Open);
+
+bool AlwaysOkFileWriter::is_registered_ =
+    FileWriterFactory::RegisterWriter(AlwaysOkFileWriter::Open);
+
+TEST(FileWriterFactoryTest, RegistrationFail) {
+  EXPECT_FALSE(FileWriterFactory::RegisterWriter(nullptr));
+}
+
+TEST(FileWriterFactoryTest, OpenWriter) {
+  auto writer = FileWriterFactory::OpenWriter("fake file");
+  EXPECT_NE(writer, nullptr);
+  EXPECT_TRUE(writer->Write(nullptr, 0u));
+}
+
+}  // namespace
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/file_writer_interface.h b/contrib/draco/src/draco/io/file_writer_interface.h
new file mode 100644
index 000000000..719f7cc8c
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_writer_interface.h
@@ -0,0 +1,26 @@
+#ifndef DRACO_IO_FILE_WRITER_INTERFACE_H_
+#define DRACO_IO_FILE_WRITER_INTERFACE_H_
+
+#include <cstddef>
+
+namespace draco {
+
+class FileWriterInterface {
+ public:
+  FileWriterInterface() = default;
+  FileWriterInterface(const FileWriterInterface &) = delete;
+  FileWriterInterface &operator=(const FileWriterInterface &) = delete;
+
+  FileWriterInterface(FileWriterInterface &&) = default;
+  FileWriterInterface &operator=(FileWriterInterface &&) = default;
+
+  // Closes the file.
+  virtual ~FileWriterInterface() = default;
+
+  // Writes |size| bytes from |buffer| to file.
+  virtual bool Write(const char *buffer, size_t size) = 0;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_WRITER_INTERFACE_H_
diff --git a/contrib/draco/src/draco/io/file_writer_utils.cc b/contrib/draco/src/draco/io/file_writer_utils.cc
new file mode 100644
index 000000000..bcadccfc6
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_writer_utils.cc
@@ -0,0 +1,57 @@
+#include "draco/io/file_writer_utils.h"
+
+#include <sys/stat.h>
+#include <sys/types.h>
+
+#include <string>
+
+#include "draco/draco_features.h"
+
+namespace draco {
+
+void SplitPathPrivate(const std::string &full_path,
+                      std::string *out_folder_path,
+                      std::string *out_file_name) {
+  const auto pos = full_path.find_last_of("/\\");
+  if (pos != std::string::npos) {
+    if (out_folder_path) {
+      *out_folder_path = full_path.substr(0, pos);
+    }
+    if (out_file_name) {
+      *out_file_name = full_path.substr(pos + 1, full_path.length());
+    }
+  } else {
+    if (out_folder_path) {
+      *out_folder_path = ".";
+    }
+    if (out_file_name) {
+      *out_file_name = full_path;
+    }
+  }
+}
+
+bool DirectoryExists(const std::string &path) {
+  struct stat path_stat;
+
+  // Check if |path| exists.
+  if (stat(path.c_str(), &path_stat) != 0) {
+    return false;
+  }
+
+  // Check if |path| is a directory.
+  if (path_stat.st_mode & S_IFDIR) {
+    return true;
+  }
+  return false;
+}
+
+bool CheckAndCreatePathForFile(const std::string &filename) {
+  std::string path;
+  std::string basename;
+  SplitPathPrivate(filename, &path, &basename);
+
+  const bool directory_exists = DirectoryExists(path);
+  return directory_exists;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/file_writer_utils.h b/contrib/draco/src/draco/io/file_writer_utils.h
new file mode 100644
index 000000000..e5ba28361
--- /dev/null
+++ b/contrib/draco/src/draco/io/file_writer_utils.h
@@ -0,0 +1,38 @@
+// Copyright 2020 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_FILE_WRITER_UTILS_H_
+#define DRACO_IO_FILE_WRITER_UTILS_H_
+
+#include <string>
+
+namespace draco {
+
+// Splits full path to a file into a folder path + file name.
+// |out_folder_path| will contain the path to the folder containing the file
+// excluding the final slash. If no folder is specified in the |full_path|, then
+// |out_folder_path| is set to "."
+void SplitPathPrivate(const std::string &full_path,
+                      std::string *out_folder_path, std::string *out_file_name);
+
+// Checks is |path| exists and if it is a directory.
+bool DirectoryExists(const std::string &path);
+
+// Checks if the path for file is valid. If not this function will try and
+// create the path. Returns false on error.
+bool CheckAndCreatePathForFile(const std::string &filename);
+
+}  // namespace draco
+
+#endif  // DRACO_IO_FILE_WRITER_UTILS_H_
diff --git a/contrib/draco/src/draco/io/mesh_io.cc b/contrib/draco/src/draco/io/mesh_io.cc
new file mode 100644
index 000000000..e0dc69c6f
--- /dev/null
+++ b/contrib/draco/src/draco/io/mesh_io.cc
@@ -0,0 +1,87 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/mesh_io.h"
+
+#include <fstream>
+#include <string>
+
+#include "draco/io/file_utils.h"
+#include "draco/io/obj_decoder.h"
+#include "draco/io/ply_decoder.h"
+
+namespace draco {
+
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name) {
+  const Options options;
+  return ReadMeshFromFile(file_name, options, nullptr);
+}
+
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name,
+                                                 bool use_metadata) {
+  Options options;
+  options.SetBool("use_metadata", use_metadata);
+  return ReadMeshFromFile(file_name, options, nullptr);
+}
+
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name,
+                                                 const Options &options) {
+  return ReadMeshFromFile(file_name, options, nullptr);
+}
+
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(
+    const std::string &file_name, const Options &options,
+    std::vector<std::string> *mesh_files) {
+  std::unique_ptr<Mesh> mesh(new Mesh());
+  // Analyze file extension.
+  const std::string extension = LowercaseFileExtension(file_name);
+  if (extension != "gltf" && mesh_files) {
+    // The GLTF decoder will fill |mesh_files|, but for other file types we set
+    // the root file here to avoid duplicating code.
+    mesh_files->push_back(file_name);
+  }
+  if (extension == "obj") {
+    // Wavefront OBJ file format.
+    ObjDecoder obj_decoder;
+    obj_decoder.set_use_metadata(options.GetBool("use_metadata", false));
+    const Status obj_status = obj_decoder.DecodeFromFile(file_name, mesh.get());
+    if (!obj_status.ok()) {
+      return obj_status;
+    }
+    return std::move(mesh);
+  }
+  if (extension == "ply") {
+    // Wavefront PLY file format.
+    PlyDecoder ply_decoder;
+    DRACO_RETURN_IF_ERROR(ply_decoder.DecodeFromFile(file_name, mesh.get()));
+    return std::move(mesh);
+  }
+
+  // Otherwise not an obj file. Assume the file was encoded with one of the
+  // draco encoding methods.
+  std::vector<char> file_data;
+  if (!ReadFileToBuffer(file_name, &file_data)) {
+    return Status(Status::DRACO_ERROR, "Unable to read input file.");
+  }
+  DecoderBuffer buffer;
+  buffer.Init(file_data.data(), file_data.size());
+  Decoder decoder;
+  auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
+  if (!statusor.ok() || statusor.value() == nullptr) {
+    return Status(Status::DRACO_ERROR, "Error decoding input.");
+  }
+  return std::move(statusor).value();
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/mesh_io.h b/contrib/draco/src/draco/io/mesh_io.h
new file mode 100644
index 000000000..9af178c73
--- /dev/null
+++ b/contrib/draco/src/draco/io/mesh_io.h
@@ -0,0 +1,107 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_MESH_IO_H_
+#define DRACO_IO_MESH_IO_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/compression/expert_encode.h"
+#include "draco/core/options.h"
+
+namespace draco {
+
+template <typename OutStreamT>
+OutStreamT WriteMeshIntoStream(const Mesh *mesh, OutStreamT &&os,
+                               MeshEncoderMethod method,
+                               const EncoderOptions &options) {
+  EncoderBuffer buffer;
+  EncoderOptions local_options = options;
+  ExpertEncoder encoder(*mesh);
+  encoder.Reset(local_options);
+  encoder.SetEncodingMethod(method);
+  if (!encoder.EncodeToBuffer(&buffer).ok()) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+
+  os.write(static_cast<const char *>(buffer.data()), buffer.size());
+
+  return os;
+}
+
+template <typename OutStreamT>
+OutStreamT WriteMeshIntoStream(const Mesh *mesh, OutStreamT &&os,
+                               MeshEncoderMethod method) {
+  const EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+  return WriteMeshIntoStream(mesh, os, method, options);
+}
+
+template <typename OutStreamT>
+OutStreamT &WriteMeshIntoStream(const Mesh *mesh, OutStreamT &&os) {
+  return WriteMeshIntoStream(mesh, os, MESH_EDGEBREAKER_ENCODING);
+}
+
+template <typename InStreamT>
+InStreamT &ReadMeshFromStream(std::unique_ptr<Mesh> *mesh, InStreamT &&is) {
+  // Determine size of stream and write into a vector
+  const auto start_pos = is.tellg();
+  is.seekg(0, std::ios::end);
+  const std::streampos is_size = is.tellg() - start_pos;
+  is.seekg(start_pos);
+  std::vector<char> data(is_size);
+  is.read(&data[0], is_size);
+
+  // Create a mesh from that data.
+  DecoderBuffer buffer;
+  buffer.Init(&data[0], data.size());
+  Decoder decoder;
+  auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
+  *mesh = std::move(statusor).value();
+  if (!statusor.ok() || *mesh == nullptr) {
+    is.setstate(std::ios_base::badbit);
+  }
+
+  return is;
+}
+
+// Reads a mesh from a file. The function automatically chooses the correct
+// decoder based on the extension of the files. Currently, .obj and .ply files
+// are supported. Other file extensions are processed by the default
+// draco::MeshDecoder.
+// Returns nullptr with an error status if the decoding failed.
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name);
+
+// Reads a mesh from a file. The function does the same thing as the previous
+// one except using metadata to encode additional information when
+// |use_metadata| is set to true.
+// Returns nullptr with an error status if the decoding failed.
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name,
+                                                 bool use_metadata);
+
+// Reads a mesh from a file. Reading is configured with |options|:
+// use_metadata  : Read obj file info like material names and object names into
+// metadata. Default is false.
+// The second form returns the files associated with the mesh via the
+// |mesh_files| argument.
+// Returns nullptr with an error status if the decoding failed.
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(const std::string &file_name,
+                                                 const Options &options);
+StatusOr<std::unique_ptr<Mesh>> ReadMeshFromFile(
+    const std::string &file_name, const Options &options,
+    std::vector<std::string> *mesh_files);
+
+}  // namespace draco
+
+#endif  // DRACO_IO_MESH_IO_H_
diff --git a/contrib/draco/src/draco/io/obj_decoder.cc b/contrib/draco/src/draco/io/obj_decoder.cc
new file mode 100644
index 000000000..9b4eab626
--- /dev/null
+++ b/contrib/draco/src/draco/io/obj_decoder.cc
@@ -0,0 +1,708 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/obj_decoder.h"
+
+#include <cctype>
+#include <cmath>
+
+#include "draco/io/file_utils.h"
+#include "draco/io/parser_utils.h"
+#include "draco/metadata/geometry_metadata.h"
+
+namespace draco {
+
+ObjDecoder::ObjDecoder()
+    : counting_mode_(true),
+      num_obj_faces_(0),
+      num_positions_(0),
+      num_tex_coords_(0),
+      num_normals_(0),
+      num_materials_(0),
+      last_sub_obj_id_(0),
+      pos_att_id_(-1),
+      tex_att_id_(-1),
+      norm_att_id_(-1),
+      material_att_id_(-1),
+      sub_obj_att_id_(-1),
+      deduplicate_input_values_(true),
+      last_material_id_(0),
+      use_metadata_(false),
+      out_mesh_(nullptr),
+      out_point_cloud_(nullptr) {}
+
+Status ObjDecoder::DecodeFromFile(const std::string &file_name,
+                                  Mesh *out_mesh) {
+  out_mesh_ = out_mesh;
+  return DecodeFromFile(file_name, static_cast<PointCloud *>(out_mesh));
+}
+
+Status ObjDecoder::DecodeFromFile(const std::string &file_name,
+                                  PointCloud *out_point_cloud) {
+  std::vector<char> buffer;
+  if (!ReadFileToBuffer(file_name, &buffer)) {
+    return Status(Status::DRACO_ERROR, "Unable to read input file.");
+  }
+  buffer_.Init(buffer.data(), buffer.size());
+
+  out_point_cloud_ = out_point_cloud;
+  input_file_name_ = file_name;
+  return DecodeInternal();
+}
+
+Status ObjDecoder::DecodeFromBuffer(DecoderBuffer *buffer, Mesh *out_mesh) {
+  out_mesh_ = out_mesh;
+  return DecodeFromBuffer(buffer, static_cast<PointCloud *>(out_mesh));
+}
+
+Status ObjDecoder::DecodeFromBuffer(DecoderBuffer *buffer,
+                                    PointCloud *out_point_cloud) {
+  out_point_cloud_ = out_point_cloud;
+  buffer_.Init(buffer->data_head(), buffer->remaining_size());
+  return DecodeInternal();
+}
+
+Status ObjDecoder::DecodeInternal() {
+  // In the first pass, count the number of different elements in the geometry.
+  // In case the desired output is just a point cloud (i.e., when
+  // out_mesh_ == nullptr) the decoder will ignore all information about the
+  // connectivity that may be included in the source data.
+  counting_mode_ = true;
+  ResetCounters();
+  material_name_to_id_.clear();
+  last_sub_obj_id_ = 0;
+  // Parse all lines.
+  Status status(Status::OK);
+  while (ParseDefinition(&status) && status.ok()) {
+  }
+  if (!status.ok()) {
+    return status;
+  }
+
+  bool use_identity_mapping = false;
+  if (num_obj_faces_ == 0) {
+    // Mesh has no faces. In this case we try to read the geometry as a point
+    // cloud where every attribute entry is a point.
+
+    // Ensure the number of all entries is same for all attributes.
+    if (num_positions_ == 0) {
+      return Status(Status::DRACO_ERROR, "No position attribute");
+    }
+    if (num_tex_coords_ > 0 && num_tex_coords_ != num_positions_) {
+      return Status(Status::DRACO_ERROR,
+                    "Invalid number of texture coordinates for a point cloud");
+    }
+    if (num_normals_ > 0 && num_normals_ != num_positions_) {
+      return Status(Status::DRACO_ERROR,
+                    "Invalid number of normals for a point cloud");
+    }
+
+    out_mesh_ = nullptr;  // Treat the output geometry as a point cloud.
+    use_identity_mapping = true;
+  }
+
+  // Initialize point cloud and mesh properties.
+  if (out_mesh_) {
+    // Start decoding a mesh with the given number of faces. For point clouds we
+    // silently ignore all data about the mesh connectivity.
+    out_mesh_->SetNumFaces(num_obj_faces_);
+  }
+  if (num_obj_faces_ > 0) {
+    out_point_cloud_->set_num_points(3 * num_obj_faces_);
+  } else {
+    out_point_cloud_->set_num_points(num_positions_);
+  }
+
+  // Add attributes if they are present in the input data.
+  if (num_positions_ > 0) {
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::POSITION, nullptr, 3, DT_FLOAT32, false,
+            sizeof(float) * 3, 0);
+    pos_att_id_ = out_point_cloud_->AddAttribute(va, use_identity_mapping,
+                                                 num_positions_);
+  }
+  if (num_tex_coords_ > 0) {
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::TEX_COORD, nullptr, 2, DT_FLOAT32, false,
+            sizeof(float) * 2, 0);
+    tex_att_id_ = out_point_cloud_->AddAttribute(va, use_identity_mapping,
+                                                 num_tex_coords_);
+  }
+  if (num_normals_ > 0) {
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::NORMAL, nullptr, 3, DT_FLOAT32, false,
+            sizeof(float) * 3, 0);
+    norm_att_id_ =
+        out_point_cloud_->AddAttribute(va, use_identity_mapping, num_normals_);
+  }
+  if (num_materials_ > 0 && num_obj_faces_ > 0) {
+    GeometryAttribute va;
+    const auto geometry_attribute_type = GeometryAttribute::GENERIC;
+    if (num_materials_ < 256) {
+      va.Init(geometry_attribute_type, nullptr, 1, DT_UINT8, false, 1, 0);
+    } else if (num_materials_ < (1 << 16)) {
+      va.Init(geometry_attribute_type, nullptr, 1, DT_UINT16, false, 2, 0);
+    } else {
+      va.Init(geometry_attribute_type, nullptr, 1, DT_UINT32, false, 4, 0);
+    }
+    material_att_id_ =
+        out_point_cloud_->AddAttribute(va, false, num_materials_);
+
+    // Fill the material entries.
+    for (int i = 0; i < num_materials_; ++i) {
+      const AttributeValueIndex avi(i);
+      out_point_cloud_->attribute(material_att_id_)->SetAttributeValue(avi, &i);
+    }
+
+    if (use_metadata_) {
+      // Use metadata to store the name of materials.
+      std::unique_ptr<AttributeMetadata> material_metadata =
+          std::unique_ptr<AttributeMetadata>(new AttributeMetadata());
+      material_metadata->AddEntryString("name", "material");
+      // Add all material names.
+      for (const auto &itr : material_name_to_id_) {
+        material_metadata->AddEntryInt(itr.first, itr.second);
+      }
+      if (!material_file_name_.empty()) {
+        material_metadata->AddEntryString("file_name", material_file_name_);
+      }
+
+      out_point_cloud_->AddAttributeMetadata(material_att_id_,
+                                             std::move(material_metadata));
+    }
+  }
+  if (!obj_name_to_id_.empty() && num_obj_faces_ > 0) {
+    GeometryAttribute va;
+    if (obj_name_to_id_.size() < 256) {
+      va.Init(GeometryAttribute::GENERIC, nullptr, 1, DT_UINT8, false, 1, 0);
+    } else if (obj_name_to_id_.size() < (1 << 16)) {
+      va.Init(GeometryAttribute::GENERIC, nullptr, 1, DT_UINT16, false, 2, 0);
+    } else {
+      va.Init(GeometryAttribute::GENERIC, nullptr, 1, DT_UINT32, false, 4, 0);
+    }
+    sub_obj_att_id_ = out_point_cloud_->AddAttribute(
+        va, false, static_cast<uint32_t>(obj_name_to_id_.size()));
+    // Fill the sub object id entries.
+    for (const auto &itr : obj_name_to_id_) {
+      const AttributeValueIndex i(itr.second);
+      out_point_cloud_->attribute(sub_obj_att_id_)->SetAttributeValue(i, &i);
+    }
+    if (use_metadata_) {
+      // Use metadata to store the name of materials.
+      std::unique_ptr<AttributeMetadata> sub_obj_metadata =
+          std::unique_ptr<AttributeMetadata>(new AttributeMetadata());
+      sub_obj_metadata->AddEntryString("name", "sub_obj");
+      // Add all sub object names.
+      for (const auto &itr : obj_name_to_id_) {
+        const AttributeValueIndex i(itr.second);
+        sub_obj_metadata->AddEntryInt(itr.first, itr.second);
+      }
+      out_point_cloud_->AddAttributeMetadata(sub_obj_att_id_,
+                                             std::move(sub_obj_metadata));
+    }
+  }
+
+  // Perform a second iteration of parsing and fill all the data.
+  counting_mode_ = false;
+  ResetCounters();
+  // Start parsing from the beginning of the buffer again.
+  buffer()->StartDecodingFrom(0);
+  while (ParseDefinition(&status) && status.ok()) {
+  }
+  if (!status.ok()) {
+    return status;
+  }
+  if (out_mesh_) {
+    // Add faces with identity mapping between vertex and corner indices.
+    // Duplicate vertices will get removed later.
+    Mesh::Face face;
+    for (FaceIndex i(0); i < num_obj_faces_; ++i) {
+      for (int c = 0; c < 3; ++c) {
+        face[c] = 3 * i.value() + c;
+      }
+      out_mesh_->SetFace(i, face);
+    }
+  }
+
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  if (deduplicate_input_values_) {
+    out_point_cloud_->DeduplicateAttributeValues();
+  }
+#endif
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  out_point_cloud_->DeduplicatePointIds();
+#endif
+  return status;
+}
+
+void ObjDecoder::ResetCounters() {
+  num_obj_faces_ = 0;
+  num_positions_ = 0;
+  num_tex_coords_ = 0;
+  num_normals_ = 0;
+  last_material_id_ = 0;
+  last_sub_obj_id_ = 0;
+}
+
+bool ObjDecoder::ParseDefinition(Status *status) {
+  char c;
+  parser::SkipWhitespace(buffer());
+  if (!buffer()->Peek(&c)) {
+    // End of file reached?.
+    return false;
+  }
+  if (c == '#') {
+    // Comment, ignore the line.
+    parser::SkipLine(buffer());
+    return true;
+  }
+  if (ParseVertexPosition(status)) {
+    return true;
+  }
+  if (ParseNormal(status)) {
+    return true;
+  }
+  if (ParseTexCoord(status)) {
+    return true;
+  }
+  if (ParseFace(status)) {
+    return true;
+  }
+  if (ParseMaterial(status)) {
+    return true;
+  }
+  if (ParseMaterialLib(status)) {
+    return true;
+  }
+  if (ParseObject(status)) {
+    return true;
+  }
+  // No known definition was found. Ignore the line.
+  parser::SkipLine(buffer());
+  return true;
+}
+
+bool ObjDecoder::ParseVertexPosition(Status *status) {
+  std::array<char, 2> c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (c[0] != 'v' || c[1] != ' ') {
+    return false;
+  }
+  // Vertex definition found!
+  buffer()->Advance(2);
+  if (!counting_mode_) {
+    // Parse three float numbers for vertex position coordinates.
+    float val[3];
+    for (int i = 0; i < 3; ++i) {
+      parser::SkipWhitespace(buffer());
+      if (!parser::ParseFloat(buffer(), val + i)) {
+        *status = Status(Status::DRACO_ERROR, "Failed to parse a float number");
+        // The definition is processed so return true.
+        return true;
+      }
+    }
+    out_point_cloud_->attribute(pos_att_id_)
+        ->SetAttributeValue(AttributeValueIndex(num_positions_), val);
+  }
+  ++num_positions_;
+  parser::SkipLine(buffer());
+  return true;
+}
+
+bool ObjDecoder::ParseNormal(Status *status) {
+  std::array<char, 2> c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (c[0] != 'v' || c[1] != 'n') {
+    return false;
+  }
+  // Normal definition found!
+  buffer()->Advance(2);
+  if (!counting_mode_) {
+    // Parse three float numbers for the normal vector.
+    float val[3];
+    for (int i = 0; i < 3; ++i) {
+      parser::SkipWhitespace(buffer());
+      if (!parser::ParseFloat(buffer(), val + i)) {
+        *status = Status(Status::DRACO_ERROR, "Failed to parse a float number");
+        // The definition is processed so return true.
+        return true;
+      }
+    }
+    out_point_cloud_->attribute(norm_att_id_)
+        ->SetAttributeValue(AttributeValueIndex(num_normals_), val);
+  }
+  ++num_normals_;
+  parser::SkipLine(buffer());
+  return true;
+}
+
+bool ObjDecoder::ParseTexCoord(Status *status) {
+  std::array<char, 2> c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (c[0] != 'v' || c[1] != 't') {
+    return false;
+  }
+  // Texture coord definition found!
+  buffer()->Advance(2);
+  if (!counting_mode_) {
+    // Parse two float numbers for the texture coordinate.
+    float val[2];
+    for (int i = 0; i < 2; ++i) {
+      parser::SkipWhitespace(buffer());
+      if (!parser::ParseFloat(buffer(), val + i)) {
+        *status = Status(Status::DRACO_ERROR, "Failed to parse a float number");
+        // The definition is processed so return true.
+        return true;
+      }
+    }
+    out_point_cloud_->attribute(tex_att_id_)
+        ->SetAttributeValue(AttributeValueIndex(num_tex_coords_), val);
+  }
+  ++num_tex_coords_;
+  parser::SkipLine(buffer());
+  return true;
+}
+
+bool ObjDecoder::ParseFace(Status *status) {
+  char c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (c != 'f') {
+    return false;
+  }
+  // Face definition found!
+  buffer()->Advance(1);
+  if (!counting_mode_) {
+    std::array<int32_t, 3> indices[4];
+    // Parse face indices (we try to look for up to four to support quads).
+    int num_valid_indices = 0;
+    for (int i = 0; i < 4; ++i) {
+      if (!ParseVertexIndices(&indices[i])) {
+        if (i == 3) {
+          break;  // It's OK if there is no fourth vertex index.
+        }
+        *status = Status(Status::DRACO_ERROR, "Failed to parse vertex indices");
+        return true;
+      }
+      ++num_valid_indices;
+    }
+    // Process the first face.
+    for (int i = 0; i < 3; ++i) {
+      const PointIndex vert_id(3 * num_obj_faces_ + i);
+      MapPointToVertexIndices(vert_id, indices[i]);
+    }
+    ++num_obj_faces_;
+    if (num_valid_indices == 4) {
+      // Add an additional triangle for the quad.
+      //
+      //   3----2
+      //   |  / |
+      //   | /  |
+      //   0----1
+      //
+      const PointIndex vert_id(3 * num_obj_faces_);
+      MapPointToVertexIndices(vert_id, indices[0]);
+      MapPointToVertexIndices(vert_id + 1, indices[2]);
+      MapPointToVertexIndices(vert_id + 2, indices[3]);
+      ++num_obj_faces_;
+    }
+  } else {
+    // We are in the counting mode.
+    // We need to determine how many triangles are in the obj face.
+    // Go over the line and check how many gaps there are between non-empty
+    // sub-strings.
+    parser::SkipWhitespace(buffer());
+    int num_indices = 0;
+    bool is_end = false;
+    while (buffer()->Peek(&c) && c != '\n') {
+      if (parser::PeekWhitespace(buffer(), &is_end)) {
+        buffer()->Advance(1);
+      } else {
+        // Non-whitespace reached.. assume it's index declaration, skip it.
+        num_indices++;
+        while (!parser::PeekWhitespace(buffer(), &is_end) && !is_end) {
+          buffer()->Advance(1);
+        }
+      }
+    }
+    if (num_indices < 3 || num_indices > 4) {
+      *status =
+          Status(Status::DRACO_ERROR, "Invalid number of indices on a face");
+      return false;
+    }
+    // Either one or two new triangles.
+    num_obj_faces_ += num_indices - 2;
+  }
+  parser::SkipLine(buffer());
+  return true;
+}
+
+bool ObjDecoder::ParseMaterialLib(Status *status) {
+  // Allow only one material library per file for now.
+  if (!material_name_to_id_.empty()) {
+    return false;
+  }
+  std::array<char, 6> c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (std::memcmp(&c[0], "mtllib", 6) != 0) {
+    return false;
+  }
+  buffer()->Advance(6);
+  DecoderBuffer line_buffer = parser::ParseLineIntoDecoderBuffer(buffer());
+  parser::SkipWhitespace(&line_buffer);
+  material_file_name_.clear();
+  if (!parser::ParseString(&line_buffer, &material_file_name_)) {
+    *status = Status(Status::DRACO_ERROR, "Failed to parse material file name");
+    return true;
+  }
+  parser::SkipLine(&line_buffer);
+
+  if (!material_file_name_.empty()) {
+    if (!ParseMaterialFile(material_file_name_, status)) {
+      // Silently ignore problems with material files for now.
+      return true;
+    }
+  }
+  return true;
+}
+
+bool ObjDecoder::ParseMaterial(Status * /* status */) {
+  // In second pass, skip when we don't use materials.
+  if (!counting_mode_ && material_att_id_ < 0) {
+    return false;
+  }
+  std::array<char, 6> c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (std::memcmp(&c[0], "usemtl", 6) != 0) {
+    return false;
+  }
+  buffer()->Advance(6);
+  DecoderBuffer line_buffer = parser::ParseLineIntoDecoderBuffer(buffer());
+  parser::SkipWhitespace(&line_buffer);
+  std::string mat_name;
+  parser::ParseLine(&line_buffer, &mat_name);
+  if (mat_name.length() == 0) {
+    return false;
+  }
+  auto it = material_name_to_id_.find(mat_name);
+  if (it == material_name_to_id_.end()) {
+    // In first pass, materials found in obj that's not in the .mtl file
+    // will be added to the list.
+    last_material_id_ = num_materials_;
+    material_name_to_id_[mat_name] = num_materials_++;
+
+    return true;
+  }
+  last_material_id_ = it->second;
+  return true;
+}
+
+bool ObjDecoder::ParseObject(Status *status) {
+  std::array<char, 2> c;
+  if (!buffer()->Peek(&c)) {
+    return false;
+  }
+  if (std::memcmp(&c[0], "o ", 2) != 0) {
+    return false;
+  }
+  buffer()->Advance(1);
+  DecoderBuffer line_buffer = parser::ParseLineIntoDecoderBuffer(buffer());
+  parser::SkipWhitespace(&line_buffer);
+  std::string obj_name;
+  if (!parser::ParseString(&line_buffer, &obj_name)) {
+    return false;
+  }
+  if (obj_name.length() == 0) {
+    return true;  // Ignore empty name entries.
+  }
+  auto it = obj_name_to_id_.find(obj_name);
+  if (it == obj_name_to_id_.end()) {
+    const int num_obj = static_cast<int>(obj_name_to_id_.size());
+    obj_name_to_id_[obj_name] = num_obj;
+    last_sub_obj_id_ = num_obj;
+  } else {
+    last_sub_obj_id_ = it->second;
+  }
+  return true;
+}
+
+bool ObjDecoder::ParseVertexIndices(std::array<int32_t, 3> *out_indices) {
+  // Parsed attribute indices can be in format:
+  // 1. POS_INDEX
+  // 2. POS_INDEX/TEX_COORD_INDEX
+  // 3. POS_INDEX/TEX_COORD_INDEX/NORMAL_INDEX
+  // 4. POS_INDEX//NORMAL_INDEX
+  parser::SkipCharacters(buffer(), " \t");
+  if (!parser::ParseSignedInt(buffer(), &(*out_indices)[0]) ||
+      (*out_indices)[0] == 0) {
+    return false;  // Position index must be present and valid.
+  }
+  (*out_indices)[1] = (*out_indices)[2] = 0;
+  char ch;
+  if (!buffer()->Peek(&ch)) {
+    return true;  // It may be OK if we cannot read any more characters.
+  }
+  if (ch != '/') {
+    return true;
+  }
+  buffer()->Advance(1);
+  // Check if we should skip texture index or not.
+  if (!buffer()->Peek(&ch)) {
+    return false;  // Here, we should be always able to read the next char.
+  }
+  if (ch != '/') {
+    // Must be texture coord index.
+    if (!parser::ParseSignedInt(buffer(), &(*out_indices)[1]) ||
+        (*out_indices)[1] == 0) {
+      return false;  // Texture index must be present and valid.
+    }
+  }
+  if (!buffer()->Peek(&ch)) {
+    return true;
+  }
+  if (ch == '/') {
+    buffer()->Advance(1);
+    // Read normal index.
+    if (!parser::ParseSignedInt(buffer(), &(*out_indices)[2]) ||
+        (*out_indices)[2] == 0) {
+      return false;  // Normal index must be present and valid.
+    }
+  }
+  return true;
+}
+
+void ObjDecoder::MapPointToVertexIndices(
+    PointIndex vert_id, const std::array<int32_t, 3> &indices) {
+  // Use face entries to store mapping between vertex and attribute indices
+  // (positions, texture coordinates and normal indices).
+  // Any given index is used when indices[x] != 0. For positive values, the
+  // point is mapped directly to the specified attribute index. Negative input
+  // indices indicate addressing from the last element (e.g. -1 is the last
+  // attribute value of a given type, -2 the second last, etc.).
+  if (indices[0] > 0) {
+    out_point_cloud_->attribute(pos_att_id_)
+        ->SetPointMapEntry(vert_id, AttributeValueIndex(indices[0] - 1));
+  } else if (indices[0] < 0) {
+    out_point_cloud_->attribute(pos_att_id_)
+        ->SetPointMapEntry(vert_id,
+                           AttributeValueIndex(num_positions_ + indices[0]));
+  }
+
+  if (tex_att_id_ >= 0) {
+    if (indices[1] > 0) {
+      out_point_cloud_->attribute(tex_att_id_)
+          ->SetPointMapEntry(vert_id, AttributeValueIndex(indices[1] - 1));
+    } else if (indices[1] < 0) {
+      out_point_cloud_->attribute(tex_att_id_)
+          ->SetPointMapEntry(vert_id,
+                             AttributeValueIndex(num_tex_coords_ + indices[1]));
+    } else {
+      // Texture index not provided but expected. Insert 0 entry as the
+      // default value.
+      out_point_cloud_->attribute(tex_att_id_)
+          ->SetPointMapEntry(vert_id, AttributeValueIndex(0));
+    }
+  }
+
+  if (norm_att_id_ >= 0) {
+    if (indices[2] > 0) {
+      out_point_cloud_->attribute(norm_att_id_)
+          ->SetPointMapEntry(vert_id, AttributeValueIndex(indices[2] - 1));
+    } else if (indices[2] < 0) {
+      out_point_cloud_->attribute(norm_att_id_)
+          ->SetPointMapEntry(vert_id,
+                             AttributeValueIndex(num_normals_ + indices[2]));
+    } else {
+      // Normal index not provided but expected. Insert 0 entry as the default
+      // value.
+      out_point_cloud_->attribute(norm_att_id_)
+          ->SetPointMapEntry(vert_id, AttributeValueIndex(0));
+    }
+  }
+
+  // Assign material index to the point if it is available.
+  if (material_att_id_ >= 0) {
+    out_point_cloud_->attribute(material_att_id_)
+        ->SetPointMapEntry(vert_id, AttributeValueIndex(last_material_id_));
+  }
+
+  // Assign sub-object index to the point if it is available.
+  if (sub_obj_att_id_ >= 0) {
+    out_point_cloud_->attribute(sub_obj_att_id_)
+        ->SetPointMapEntry(vert_id, AttributeValueIndex(last_sub_obj_id_));
+  }
+}
+
+bool ObjDecoder::ParseMaterialFile(const std::string &file_name,
+                                   Status *status) {
+  const std::string full_path = GetFullPath(file_name, input_file_name_);
+  std::vector<char> buffer;
+  if (!ReadFileToBuffer(full_path, &buffer)) {
+    return false;
+  }
+
+  // Backup the original decoder buffer.
+  DecoderBuffer old_buffer = buffer_;
+
+  buffer_.Init(buffer.data(), buffer.size());
+
+  num_materials_ = 0;
+  while (ParseMaterialFileDefinition(status)) {
+  }
+
+  // Restore the original buffer.
+  buffer_ = old_buffer;
+  return true;
+}
+
+bool ObjDecoder::ParseMaterialFileDefinition(Status * /* status */) {
+  char c;
+  parser::SkipWhitespace(buffer());
+  if (!buffer()->Peek(&c)) {
+    // End of file reached?.
+    return false;
+  }
+  if (c == '#') {
+    // Comment, ignore the line.
+    parser::SkipLine(buffer());
+    return true;
+  }
+  std::string str;
+  if (!parser::ParseString(buffer(), &str)) {
+    return false;
+  }
+  if (str == "newmtl") {
+    parser::SkipWhitespace(buffer());
+    parser::ParseLine(buffer(), &str);
+    if (str.empty()) {
+      return false;
+    }
+    // Add new material to our map.
+    material_name_to_id_[str] = num_materials_++;
+  }
+  return true;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/obj_decoder.h b/contrib/draco/src/draco/io/obj_decoder.h
new file mode 100644
index 000000000..baeab5b0c
--- /dev/null
+++ b/contrib/draco/src/draco/io/obj_decoder.h
@@ -0,0 +1,129 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_OBJ_DECODER_H_
+#define DRACO_IO_OBJ_DECODER_H_
+
+#include <string>
+#include <unordered_map>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/draco_features.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Decodes a Wavefront OBJ file into draco::Mesh (or draco::PointCloud if the
+// connectivity data is not needed).. This decoder can handle decoding of
+// positions, texture coordinates, normals and triangular faces.
+// All other geometry properties are ignored.
+class ObjDecoder {
+ public:
+  ObjDecoder();
+
+  // Decodes an obj file stored in the input file.
+  // Returns nullptr if the decoding failed.
+  Status DecodeFromFile(const std::string &file_name, Mesh *out_mesh);
+  Status DecodeFromFile(const std::string &file_name,
+                        PointCloud *out_point_cloud);
+
+  Status DecodeFromBuffer(DecoderBuffer *buffer, Mesh *out_mesh);
+  Status DecodeFromBuffer(DecoderBuffer *buffer, PointCloud *out_point_cloud);
+
+  // Flag that can be used to turn on/off deduplication of input values.
+  // This should be disabled only when we are sure that the input data does not
+  // contain any duplicate entries.
+  // Default: true
+  void set_deduplicate_input_values(bool v) { deduplicate_input_values_ = v; }
+  // Flag for whether using metadata to record other information in the obj
+  // file, e.g. material names, object names.
+  void set_use_metadata(bool flag) { use_metadata_ = flag; }
+
+ protected:
+  Status DecodeInternal();
+  DecoderBuffer *buffer() { return &buffer_; }
+
+ private:
+  // Resets internal counters for attributes and faces.
+  void ResetCounters();
+
+  // Parses the next mesh property definition (position, tex coord, normal, or
+  // face). If the parsed data is unrecognized, it will be skipped.
+  // Returns false when the end of file was reached.
+  bool ParseDefinition(Status *status);
+
+  // Attempts to parse definition of position, normal, tex coord, or face
+  // respectively.
+  // Returns false when the parsed data didn't contain the given definition.
+  bool ParseVertexPosition(Status *status);
+  bool ParseNormal(Status *status);
+  bool ParseTexCoord(Status *status);
+  bool ParseFace(Status *status);
+  bool ParseMaterialLib(Status *status);
+  bool ParseMaterial(Status *status);
+  bool ParseObject(Status *status);
+
+  // Parses triplet of position, tex coords and normal indices.
+  // Returns false on error.
+  bool ParseVertexIndices(std::array<int32_t, 3> *out_indices);
+
+  // Maps specified point index to the parsed vertex indices (triplet of
+  // position, texture coordinate, and normal indices) .
+  void MapPointToVertexIndices(PointIndex vert_id,
+                               const std::array<int32_t, 3> &indices);
+
+  // Parses material file definitions from a separate file.
+  bool ParseMaterialFile(const std::string &file_name, Status *status);
+  bool ParseMaterialFileDefinition(Status *status);
+
+  // If set to true, the parser will count the number of various definitions
+  // but it will not parse the actual data or add any new entries to the mesh.
+  bool counting_mode_;
+  int num_obj_faces_;
+  int num_positions_;
+  int num_tex_coords_;
+  int num_normals_;
+  int num_materials_;
+  int last_sub_obj_id_;
+
+  int pos_att_id_;
+  int tex_att_id_;
+  int norm_att_id_;
+  int material_att_id_;
+  int sub_obj_att_id_;  // Attribute id for storing sub-objects.
+
+  bool deduplicate_input_values_;
+
+  int last_material_id_;
+  std::string material_file_name_;
+
+  std::string input_file_name_;
+
+  std::unordered_map<std::string, int> material_name_to_id_;
+  std::unordered_map<std::string, int> obj_name_to_id_;
+
+  bool use_metadata_;
+
+  DecoderBuffer buffer_;
+
+  // Data structure that stores the decoded data. |out_point_cloud_| must be
+  // always set but |out_mesh_| is optional.
+  Mesh *out_mesh_;
+  PointCloud *out_point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_OBJ_DECODER_H_
diff --git a/contrib/draco/src/draco/io/obj_decoder_test.cc b/contrib/draco/src/draco/io/obj_decoder_test.cc
new file mode 100644
index 000000000..b19fe6e2c
--- /dev/null
+++ b/contrib/draco/src/draco/io/obj_decoder_test.cc
@@ -0,0 +1,193 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/obj_decoder.h"
+
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+
+namespace draco {
+
+class ObjDecoderTest : public ::testing::Test {
+ protected:
+  template <class Geometry>
+  std::unique_ptr<Geometry> DecodeObj(const std::string &file_name) const {
+    return DecodeObj<Geometry>(file_name, false);
+  }
+
+  template <class Geometry>
+  std::unique_ptr<Geometry> DecodeObj(const std::string &file_name,
+                                      bool deduplicate_input_values) const {
+    const std::string path = GetTestFileFullPath(file_name);
+    ObjDecoder decoder;
+    decoder.set_deduplicate_input_values(deduplicate_input_values);
+    std::unique_ptr<Geometry> geometry(new Geometry());
+    if (!decoder.DecodeFromFile(path, geometry.get()).ok()) {
+      return nullptr;
+    }
+    return geometry;
+  }
+
+  template <class Geometry>
+  std::unique_ptr<Geometry> DecodeObjWithMetadata(
+      const std::string &file_name) const {
+    const std::string path = GetTestFileFullPath(file_name);
+    ObjDecoder decoder;
+    decoder.set_use_metadata(true);
+    std::unique_ptr<Geometry> geometry(new Geometry());
+    if (!decoder.DecodeFromFile(path, geometry.get()).ok()) {
+      return nullptr;
+    }
+    return geometry;
+  }
+
+  void test_decoding(const std::string &file_name) {
+    const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name));
+    ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_GT(mesh->num_faces(), 0);
+
+    const std::unique_ptr<PointCloud> pc(DecodeObj<PointCloud>(file_name));
+    ASSERT_NE(pc, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_GT(pc->num_points(), 0);
+  }
+};
+
+TEST_F(ObjDecoderTest, ExtraVertexOBJ) {
+  const std::string file_name = "extra_vertex.obj";
+  test_decoding(file_name);
+}
+
+TEST_F(ObjDecoderTest, PartialAttributesOBJ) {
+  const std::string file_name = "cube_att_partial.obj";
+  test_decoding(file_name);
+}
+
+TEST_F(ObjDecoderTest, SubObjects) {
+  // Tests loading an Obj with sub objects.
+  const std::string file_name = "cube_att_sub_o.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+  ASSERT_GT(mesh->num_faces(), 0);
+
+  // A sub object attribute should be the fourth attribute of the mesh (in this
+  // case).
+  ASSERT_EQ(mesh->num_attributes(), 4);
+  ASSERT_EQ(mesh->attribute(3)->attribute_type(), GeometryAttribute::GENERIC);
+  // There should be 3 different sub objects used in the model.
+  ASSERT_EQ(mesh->attribute(3)->size(), 3);
+  // Verify that the sub object attribute has unique id == 3.
+  ASSERT_EQ(mesh->attribute(3)->unique_id(), 3);
+}
+
+TEST_F(ObjDecoderTest, SubObjectsWithMetadata) {
+  // Tests loading an Obj with sub objects.
+  const std::string file_name = "cube_att_sub_o.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObjWithMetadata<Mesh>(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+  ASSERT_GT(mesh->num_faces(), 0);
+
+  ASSERT_EQ(mesh->num_attributes(), 4);
+  ASSERT_EQ(mesh->attribute(3)->attribute_type(), GeometryAttribute::GENERIC);
+  // There should be 3 different sub objects used in the model.
+  ASSERT_EQ(mesh->attribute(3)->size(), 3);
+
+  // Test material names stored in metadata.
+  ASSERT_NE(mesh->GetMetadata(), nullptr);
+  ASSERT_NE(mesh->GetAttributeMetadataByAttributeId(3), nullptr);
+  int32_t sub_obj_id = 0;
+  ASSERT_TRUE(mesh->GetAttributeMetadataByAttributeId(3)->GetEntryInt(
+      "obj2", &sub_obj_id));
+  ASSERT_EQ(sub_obj_id, 2);
+}
+
+TEST_F(ObjDecoderTest, QuadOBJ) {
+  // Tests loading an Obj with quad faces.
+  const std::string file_name = "cube_quads.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+  ASSERT_EQ(mesh->num_faces(), 12);
+
+  ASSERT_EQ(mesh->num_attributes(), 3);
+  ASSERT_EQ(mesh->num_points(), 4 * 6);  // Four points per quad face.
+}
+
+TEST_F(ObjDecoderTest, ComplexPolyOBJ) {
+  // Tests that we fail to load an obj with complex polygon (expected failure).
+  const std::string file_name = "invalid/complex_poly.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name));
+  ASSERT_EQ(mesh, nullptr);
+}
+
+TEST_F(ObjDecoderTest, EmptyNameOBJ) {
+  // Tests that we load an obj file that has an sub-object defined with an empty
+  // name.
+  const std::string file_name = "empty_name.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name));
+  ASSERT_NE(mesh, nullptr);
+  ASSERT_EQ(mesh->num_attributes(), 1);
+  // Three valid entries in the attribute are expected.
+  ASSERT_EQ(mesh->attribute(0)->size(), 3);
+}
+
+TEST_F(ObjDecoderTest, PointCloudOBJ) {
+  // Tests that we load an obj file that does not contain any faces.
+  const std::string file_name = "test_lines.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name, false));
+  ASSERT_NE(mesh, nullptr);
+  ASSERT_EQ(mesh->num_faces(), 0);
+  ASSERT_EQ(mesh->num_attributes(), 1);
+  ASSERT_EQ(mesh->attribute(0)->size(), 484);
+}
+
+TEST_F(ObjDecoderTest, WrongAttributeMapping) {
+  // Tests that we load an obj file that contains invalid mapping between
+  // attribute indices and values. In such case the invalid indices should be
+  // ignored.
+  const std::string file_name = "test_wrong_attribute_mapping.obj";
+  const std::unique_ptr<Mesh> mesh(DecodeObj<Mesh>(file_name, false));
+  ASSERT_NE(mesh, nullptr);
+  ASSERT_EQ(mesh->num_faces(), 1);
+  ASSERT_EQ(mesh->num_attributes(), 1);
+  ASSERT_EQ(mesh->attribute(0)->size(), 3);
+}
+
+TEST_F(ObjDecoderTest, TestObjDecodingAll) {
+  // test if we can read all obj that are currently in test folder.
+  test_decoding("bunny_norm.obj");
+  // test_decoding("complex_poly.obj"); // not supported see test above
+  test_decoding("cube_att.obj");
+  test_decoding("cube_att_partial.obj");
+  test_decoding("cube_att_sub_o.obj");
+  test_decoding("cube_quads.obj");
+  test_decoding("cube_subd.obj");
+  test_decoding("eof_test.obj");
+  test_decoding("extra_vertex.obj");
+  test_decoding("mat_test.obj");
+  test_decoding("one_face_123.obj");
+  test_decoding("one_face_312.obj");
+  test_decoding("one_face_321.obj");
+  test_decoding("sphere.obj");
+  test_decoding("test_nm.obj");
+  test_decoding("test_nm_trans.obj");
+  test_decoding("test_sphere.obj");
+  test_decoding("three_faces_123.obj");
+  test_decoding("three_faces_312.obj");
+  test_decoding("two_faces_123.obj");
+  test_decoding("two_faces_312.obj");
+  test_decoding("inf_nan.obj");
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/obj_encoder.cc b/contrib/draco/src/draco/io/obj_encoder.cc
new file mode 100644
index 000000000..29c6ca8f0
--- /dev/null
+++ b/contrib/draco/src/draco/io/obj_encoder.cc
@@ -0,0 +1,346 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/obj_encoder.h"
+
+#include <memory>
+
+#include "draco/io/file_writer_factory.h"
+#include "draco/io/file_writer_interface.h"
+#include "draco/metadata/geometry_metadata.h"
+
+namespace draco {
+
+ObjEncoder::ObjEncoder()
+    : pos_att_(nullptr),
+      tex_coord_att_(nullptr),
+      normal_att_(nullptr),
+      material_att_(nullptr),
+      sub_obj_att_(nullptr),
+      out_buffer_(nullptr),
+      in_point_cloud_(nullptr),
+      in_mesh_(nullptr),
+      current_sub_obj_id_(-1),
+      current_material_id_(-1) {}
+
+bool ObjEncoder::EncodeToFile(const PointCloud &pc,
+                              const std::string &file_name) {
+  std::unique_ptr<FileWriterInterface> file =
+      FileWriterFactory::OpenWriter(file_name);
+  if (!file) {
+    return false;  // File could not be opened.
+  }
+  file_name_ = file_name;
+  // Encode the mesh into a buffer.
+  EncoderBuffer buffer;
+  if (!EncodeToBuffer(pc, &buffer)) {
+    return false;
+  }
+  // Write the buffer into the file.
+  file->Write(buffer.data(), buffer.size());
+  return true;
+}
+
+bool ObjEncoder::EncodeToFile(const Mesh &mesh, const std::string &file_name) {
+  in_mesh_ = &mesh;
+  return EncodeToFile(static_cast<const PointCloud &>(mesh), file_name);
+}
+
+bool ObjEncoder::EncodeToBuffer(const PointCloud &pc,
+                                EncoderBuffer *out_buffer) {
+  in_point_cloud_ = &pc;
+  out_buffer_ = out_buffer;
+  if (!EncodeInternal()) {
+    return ExitAndCleanup(false);
+  }
+  return ExitAndCleanup(true);
+}
+
+bool ObjEncoder::EncodeToBuffer(const Mesh &mesh, EncoderBuffer *out_buffer) {
+  in_mesh_ = &mesh;
+  return EncodeToBuffer(static_cast<const PointCloud &>(mesh), out_buffer);
+}
+
+bool ObjEncoder::EncodeInternal() {
+  pos_att_ = nullptr;
+  tex_coord_att_ = nullptr;
+  normal_att_ = nullptr;
+  material_att_ = nullptr;
+  sub_obj_att_ = nullptr;
+  current_sub_obj_id_ = -1;
+  current_material_id_ = -1;
+  if (!GetSubObjects()) {
+    return false;
+  }
+  if (!EncodeMaterialFileName()) {
+    return false;
+  }
+  if (!EncodePositions()) {
+    return false;
+  }
+  if (!EncodeTextureCoordinates()) {
+    return false;
+  }
+  if (!EncodeNormals()) {
+    return false;
+  }
+  if (in_mesh_ && !EncodeFaces()) {
+    return false;
+  }
+  return true;
+}
+
+bool ObjEncoder::ExitAndCleanup(bool return_value) {
+  in_mesh_ = nullptr;
+  in_point_cloud_ = nullptr;
+  out_buffer_ = nullptr;
+  pos_att_ = nullptr;
+  tex_coord_att_ = nullptr;
+  normal_att_ = nullptr;
+  material_att_ = nullptr;
+  sub_obj_att_ = nullptr;
+  current_sub_obj_id_ = -1;
+  current_material_id_ = -1;
+  file_name_.clear();
+  return return_value;
+}
+
+bool ObjEncoder::GetSubObjects() {
+  const GeometryMetadata *pc_metadata = in_point_cloud_->GetMetadata();
+  if (!pc_metadata) {
+    return true;
+  }
+  const AttributeMetadata *sub_obj_metadata =
+      pc_metadata->GetAttributeMetadataByStringEntry("name", "sub_obj");
+  if (!sub_obj_metadata) {
+    return true;
+  }
+  sub_obj_id_to_name_.clear();
+  for (const auto &entry : sub_obj_metadata->entries()) {
+    // Sub-object id must be int.
+    int value = 0;
+    if (!entry.second.GetValue(&value)) {
+      continue;
+    }
+    sub_obj_id_to_name_[value] = entry.first;
+  }
+  sub_obj_att_ = in_point_cloud_->GetAttributeByUniqueId(
+      sub_obj_metadata->att_unique_id());
+  if (sub_obj_att_ == nullptr || sub_obj_att_->size() == 0) {
+    return false;
+  }
+  return true;
+}
+
+bool ObjEncoder::EncodeMaterialFileName() {
+  const GeometryMetadata *pc_metadata = in_point_cloud_->GetMetadata();
+  const AttributeMetadata *material_metadata = nullptr;
+  if (pc_metadata) {
+    material_metadata =
+        pc_metadata->GetAttributeMetadataByStringEntry("name", "material");
+  }
+  std::string material_file_name;
+  std::string material_full_path;
+  if (!material_metadata) {
+    return true;
+  }
+  if (!material_metadata->GetEntryString("file_name", &material_file_name))
+    return false;
+  buffer()->Encode("mtllib ", 7);
+  buffer()->Encode(material_file_name.c_str(), material_file_name.size());
+  buffer()->Encode("\n", 1);
+  material_id_to_name_.clear();
+  for (const auto &entry : material_metadata->entries()) {
+    // Material id must be int.
+    int value = 0;
+    // Found entry that are not material id, e.g. file name as a string.
+    if (!entry.second.GetValue(&value)) {
+      continue;
+    }
+    material_id_to_name_[value] = entry.first;
+  }
+  material_att_ = in_point_cloud_->GetAttributeByUniqueId(
+      material_metadata->att_unique_id());
+  if (material_att_ == nullptr || material_att_->size() == 0) {
+    return false;
+  }
+  return true;
+}
+
+bool ObjEncoder::EncodePositions() {
+  const PointAttribute *const att =
+      in_point_cloud_->GetNamedAttribute(GeometryAttribute::POSITION);
+  if (att == nullptr || att->size() == 0) {
+    return false;  // Position attribute must be valid.
+  }
+  std::array<float, 3> value;
+  for (AttributeValueIndex i(0); i < static_cast<uint32_t>(att->size()); ++i) {
+    if (!att->ConvertValue<float, 3>(i, &value[0])) {
+      return false;
+    }
+    buffer()->Encode("v ", 2);
+    EncodeFloatList(&value[0], 3);
+    buffer()->Encode("\n", 1);
+  }
+  pos_att_ = att;
+  return true;
+}
+
+bool ObjEncoder::EncodeTextureCoordinates() {
+  const PointAttribute *const att =
+      in_point_cloud_->GetNamedAttribute(GeometryAttribute::TEX_COORD);
+  if (att == nullptr || att->size() == 0) {
+    return true;  // It's OK if we don't have texture coordinates.
+  }
+  std::array<float, 2> value;
+  for (AttributeValueIndex i(0); i < static_cast<uint32_t>(att->size()); ++i) {
+    if (!att->ConvertValue<float, 2>(i, &value[0])) {
+      return false;
+    }
+    buffer()->Encode("vt ", 3);
+    EncodeFloatList(&value[0], 2);
+    buffer()->Encode("\n", 1);
+  }
+  tex_coord_att_ = att;
+  return true;
+}
+
+bool ObjEncoder::EncodeNormals() {
+  const PointAttribute *const att =
+      in_point_cloud_->GetNamedAttribute(GeometryAttribute::NORMAL);
+  if (att == nullptr || att->size() == 0) {
+    return true;  // It's OK if we don't have normals.
+  }
+  std::array<float, 3> value;
+  for (AttributeValueIndex i(0); i < static_cast<uint32_t>(att->size()); ++i) {
+    if (!att->ConvertValue<float, 3>(i, &value[0])) {
+      return false;
+    }
+    buffer()->Encode("vn ", 3);
+    EncodeFloatList(&value[0], 3);
+    buffer()->Encode("\n", 1);
+  }
+  normal_att_ = att;
+  return true;
+}
+
+bool ObjEncoder::EncodeFaces() {
+  for (FaceIndex i(0); i < in_mesh_->num_faces(); ++i) {
+    if (sub_obj_att_) {
+      if (!EncodeSubObject(i)) {
+        return false;
+      }
+    }
+    if (material_att_) {
+      if (!EncodeMaterial(i)) {
+        return false;
+      }
+    }
+    buffer()->Encode('f');
+    for (int j = 0; j < 3; ++j) {
+      if (!EncodeFaceCorner(i, j)) {
+        return false;
+      }
+    }
+    buffer()->Encode("\n", 1);
+  }
+  return true;
+}
+
+bool ObjEncoder::EncodeMaterial(FaceIndex face_id) {
+  int material_id = 0;
+  // Pick the first corner, all corners of a face should have same id.
+  const PointIndex vert_index = in_mesh_->face(face_id)[0];
+  const AttributeValueIndex index_id(material_att_->mapped_index(vert_index));
+  if (!material_att_->ConvertValue<int>(index_id, &material_id)) {
+    return false;
+  }
+
+  if (material_id != current_material_id_) {
+    // Update material information.
+    buffer()->Encode("usemtl ", 7);
+    const auto mat_ptr = material_id_to_name_.find(material_id);
+    // If the material id is not found.
+    if (mat_ptr == material_id_to_name_.end()) {
+      return false;
+    }
+    buffer()->Encode(mat_ptr->second.c_str(), mat_ptr->second.size());
+    buffer()->Encode("\n", 1);
+    current_material_id_ = material_id;
+  }
+  return true;
+}
+
+bool ObjEncoder::EncodeSubObject(FaceIndex face_id) {
+  int sub_obj_id = 0;
+  // Pick the first corner, all corners of a face should have same id.
+  const PointIndex vert_index = in_mesh_->face(face_id)[0];
+  const AttributeValueIndex index_id(sub_obj_att_->mapped_index(vert_index));
+  if (!sub_obj_att_->ConvertValue<int>(index_id, &sub_obj_id)) {
+    return false;
+  }
+  if (sub_obj_id != current_sub_obj_id_) {
+    buffer()->Encode("o ", 2);
+    const auto sub_obj_ptr = sub_obj_id_to_name_.find(sub_obj_id);
+    if (sub_obj_ptr == sub_obj_id_to_name_.end()) {
+      return false;
+    }
+    buffer()->Encode(sub_obj_ptr->second.c_str(), sub_obj_ptr->second.size());
+    buffer()->Encode("\n", 1);
+    current_sub_obj_id_ = sub_obj_id;
+  }
+  return true;
+}
+
+bool ObjEncoder::EncodeFaceCorner(FaceIndex face_id, int local_corner_id) {
+  buffer()->Encode(' ');
+  const PointIndex vert_index = in_mesh_->face(face_id)[local_corner_id];
+  // Note that in the OBJ format, all indices are encoded starting from index 1.
+  // Encode position index.
+  EncodeInt(pos_att_->mapped_index(vert_index).value() + 1);
+  if (tex_coord_att_ || normal_att_) {
+    // Encoding format is pos_index/tex_coord_index/normal_index.
+    // If tex_coords are not present, we must encode pos_index//normal_index.
+    buffer()->Encode('/');
+    if (tex_coord_att_) {
+      EncodeInt(tex_coord_att_->mapped_index(vert_index).value() + 1);
+    }
+    if (normal_att_) {
+      buffer()->Encode('/');
+      EncodeInt(normal_att_->mapped_index(vert_index).value() + 1);
+    }
+  }
+  return true;
+}
+
+void ObjEncoder::EncodeFloat(float val) {
+  snprintf(num_buffer_, sizeof(num_buffer_), "%f", val);
+  buffer()->Encode(num_buffer_, strlen(num_buffer_));
+}
+
+void ObjEncoder::EncodeFloatList(float *vals, int num_vals) {
+  for (int i = 0; i < num_vals; ++i) {
+    if (i > 0) {
+      buffer()->Encode(' ');
+    }
+    EncodeFloat(vals[i]);
+  }
+}
+
+void ObjEncoder::EncodeInt(int32_t val) {
+  snprintf(num_buffer_, sizeof(num_buffer_), "%d", val);
+  buffer()->Encode(num_buffer_, strlen(num_buffer_));
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/obj_encoder.h b/contrib/draco/src/draco/io/obj_encoder.h
new file mode 100644
index 000000000..509d39baf
--- /dev/null
+++ b/contrib/draco/src/draco/io/obj_encoder.h
@@ -0,0 +1,92 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_OBJ_ENCODER_H_
+#define DRACO_IO_OBJ_ENCODER_H_
+
+#include <unordered_map>
+
+#include "draco/core/encoder_buffer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class for encoding input draco::Mesh or draco::PointCloud into the Wavefront
+// OBJ format.
+class ObjEncoder {
+ public:
+  ObjEncoder();
+
+  // Encodes the mesh or a point cloud  and saves it into a file.
+  // Returns false when either the encoding failed or when the file couldn't be
+  // opened.
+  bool EncodeToFile(const PointCloud &pc, const std::string &file_name);
+  bool EncodeToFile(const Mesh &mesh, const std::string &file_name);
+
+  // Encodes the mesh or the point cloud into a buffer.
+  bool EncodeToBuffer(const PointCloud &pc, EncoderBuffer *out_buffer);
+  bool EncodeToBuffer(const Mesh &mesh, EncoderBuffer *out_buffer);
+
+ protected:
+  bool EncodeInternal();
+  EncoderBuffer *buffer() const { return out_buffer_; }
+  bool ExitAndCleanup(bool return_value);
+
+ private:
+  bool GetSubObjects();
+  bool EncodeMaterialFileName();
+  bool EncodePositions();
+  bool EncodeTextureCoordinates();
+  bool EncodeNormals();
+  bool EncodeFaces();
+  bool EncodeSubObject(FaceIndex face_id);
+  bool EncodeMaterial(FaceIndex face_id);
+  bool EncodeFaceCorner(FaceIndex face_id, int local_corner_id);
+
+  void EncodeFloat(float val);
+  void EncodeFloatList(float *vals, int num_vals);
+  void EncodeInt(int32_t val);
+
+  // Various attributes used by the encoder. If an attribute is not used, it is
+  // set to nullptr.
+  const PointAttribute *pos_att_;
+  const PointAttribute *tex_coord_att_;
+  const PointAttribute *normal_att_;
+  const PointAttribute *material_att_;
+  const PointAttribute *sub_obj_att_;
+
+  // Buffer used for encoding float/int numbers.
+  char num_buffer_[20];
+
+  EncoderBuffer *out_buffer_;
+
+  const PointCloud *in_point_cloud_;
+  const Mesh *in_mesh_;
+
+  // Store sub object name for each value.
+  std::unordered_map<int, std::string> sub_obj_id_to_name_;
+  // Current sub object id of faces.
+  int current_sub_obj_id_;
+
+  // Store material name for each value in material attribute.
+  std::unordered_map<int, std::string> material_id_to_name_;
+  // Current material id of faces.
+  int current_material_id_;
+
+  std::string file_name_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_OBJ_ENCODER_H_
diff --git a/contrib/draco/src/draco/io/obj_encoder_test.cc b/contrib/draco/src/draco/io/obj_encoder_test.cc
new file mode 100644
index 000000000..4838e56ca
--- /dev/null
+++ b/contrib/draco/src/draco/io/obj_encoder_test.cc
@@ -0,0 +1,110 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/obj_encoder.h"
+
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/file_reader_factory.h"
+#include "draco/io/file_reader_interface.h"
+#include "draco/io/obj_decoder.h"
+
+namespace draco {
+
+class ObjEncoderTest : public ::testing::Test {
+ protected:
+  void CompareMeshes(const Mesh *mesh0, const Mesh *mesh1) {
+    ASSERT_EQ(mesh0->num_faces(), mesh1->num_faces());
+    ASSERT_EQ(mesh0->num_attributes(), mesh1->num_attributes());
+    for (size_t att_id = 0; att_id < mesh0->num_attributes(); ++att_id) {
+      ASSERT_EQ(mesh0->attribute(att_id)->size(),
+                mesh1->attribute(att_id)->size());
+    }
+  }
+
+  // Encode a mesh using the ObjEncoder and then decode to verify the encoding.
+  std::unique_ptr<Mesh> EncodeAndDecodeMesh(const Mesh *mesh) {
+    EncoderBuffer encoder_buffer;
+    ObjEncoder encoder;
+    if (!encoder.EncodeToBuffer(*mesh, &encoder_buffer)) {
+      return nullptr;
+    }
+
+    DecoderBuffer decoder_buffer;
+    decoder_buffer.Init(encoder_buffer.data(), encoder_buffer.size());
+    std::unique_ptr<Mesh> decoded_mesh(new Mesh());
+    ObjDecoder decoder;
+    decoder.set_use_metadata(true);
+    if (!decoder.DecodeFromBuffer(&decoder_buffer, decoded_mesh.get()).ok()) {
+      return nullptr;
+    }
+    return decoded_mesh;
+  }
+
+  void test_encoding(const std::string &file_name) {
+    const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name, true));
+
+    ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_GT(mesh->num_faces(), 0);
+
+    const std::unique_ptr<Mesh> decoded_mesh = EncodeAndDecodeMesh(mesh.get());
+    CompareMeshes(mesh.get(), decoded_mesh.get());
+  }
+};
+
+TEST_F(ObjEncoderTest, HasSubObject) { test_encoding("cube_att_sub_o.obj"); }
+
+TEST_F(ObjEncoderTest, HasMaterial) {
+  const std::unique_ptr<Mesh> mesh0(ReadMeshFromTestFile("mat_test.obj", true));
+  ASSERT_NE(mesh0, nullptr);
+  const std::unique_ptr<Mesh> mesh1 = EncodeAndDecodeMesh(mesh0.get());
+  ASSERT_NE(mesh1, nullptr);
+  ASSERT_EQ(mesh0->num_faces(), mesh1->num_faces());
+  ASSERT_EQ(mesh0->num_attributes(), mesh1->num_attributes());
+  // Position attribute should be the same.
+  ASSERT_EQ(mesh0->attribute(0)->size(), mesh1->attribute(0)->size());
+  // Since |mesh1| is decoded from buffer, it has not material file. So the
+  // size of material attribute is the number of materials used in the obj
+  // file which is 7. The size of material attribute of |mesh0| decoded from
+  // the obj file will be the number of materials defined in the .mtl file.
+  ASSERT_EQ(mesh0->attribute(1)->size(), 29);
+  ASSERT_EQ(mesh1->attribute(1)->size(), 7);
+}
+
+TEST_F(ObjEncoderTest, TestObjEncodingAll) {
+  // Test decoded mesh from encoded obj file stays the same.
+  test_encoding("bunny_norm.obj");
+  test_encoding("cube_att.obj");
+  test_encoding("cube_att_partial.obj");
+  test_encoding("cube_quads.obj");
+  test_encoding("cube_subd.obj");
+  test_encoding("extra_vertex.obj");
+  test_encoding("multiple_isolated_triangles.obj");
+  test_encoding("multiple_tetrahedrons.obj");
+  test_encoding("one_face_123.obj");
+  test_encoding("one_face_312.obj");
+  test_encoding("one_face_321.obj");
+  test_encoding("sphere.obj");
+  test_encoding("test_nm.obj");
+  test_encoding("test_nm_trans.obj");
+  test_encoding("test_sphere.obj");
+  test_encoding("three_faces_123.obj");
+  test_encoding("three_faces_312.obj");
+  test_encoding("two_faces_123.obj");
+  test_encoding("two_faces_312.obj");
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/parser_utils.cc b/contrib/draco/src/draco/io/parser_utils.cc
new file mode 100644
index 000000000..753a1b314
--- /dev/null
+++ b/contrib/draco/src/draco/io/parser_utils.cc
@@ -0,0 +1,260 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/parser_utils.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cmath>
+#include <iterator>
+
+namespace draco {
+namespace parser {
+
+void SkipCharacters(DecoderBuffer *buffer, const char *skip_chars) {
+  if (skip_chars == nullptr) {
+    return;
+  }
+  const int num_skip_chars = static_cast<int>(strlen(skip_chars));
+  char c;
+  while (buffer->Peek(&c)) {
+    // Check all characters in the pattern.
+    bool skip = false;
+    for (int i = 0; i < num_skip_chars; ++i) {
+      if (c == skip_chars[i]) {
+        skip = true;
+        break;
+      }
+    }
+    if (!skip) {
+      return;
+    }
+    buffer->Advance(1);
+  }
+}
+
+void SkipWhitespace(DecoderBuffer *buffer) {
+  bool end_reached = false;
+  while (PeekWhitespace(buffer, &end_reached) && !end_reached) {
+    // Skip the whitespace character
+    buffer->Advance(1);
+  }
+}
+
+bool PeekWhitespace(DecoderBuffer *buffer, bool *end_reached) {
+  uint8_t c;
+  if (!buffer->Peek(&c)) {
+    *end_reached = true;
+    return false;  // eof reached.
+  }
+  if (!isspace(c)) {
+    return false;  // Non-whitespace character reached.
+  }
+  return true;
+}
+
+void SkipLine(DecoderBuffer *buffer) { ParseLine(buffer, nullptr); }
+
+bool ParseFloat(DecoderBuffer *buffer, float *value) {
+  // Read optional sign.
+  char ch;
+  if (!buffer->Peek(&ch)) {
+    return false;
+  }
+  int sign = GetSignValue(ch);
+  if (sign != 0) {
+    buffer->Advance(1);
+  } else {
+    sign = 1;
+  }
+
+  // Parse integer component.
+  bool have_digits = false;
+  double v = 0.0;
+  while (buffer->Peek(&ch) && ch >= '0' && ch <= '9') {
+    v *= 10.0;
+    v += (ch - '0');
+    buffer->Advance(1);
+    have_digits = true;
+  }
+  if (ch == '.') {
+    // Parse fractional component.
+    buffer->Advance(1);
+    double fraction = 1.0;
+    while (buffer->Peek(&ch) && ch >= '0' && ch <= '9') {
+      fraction *= 0.1;
+      v += (ch - '0') * fraction;
+      buffer->Advance(1);
+      have_digits = true;
+    }
+  }
+
+  if (!have_digits) {
+    // Check for special constants (inf, nan, ...).
+    std::string text;
+    if (!ParseString(buffer, &text)) {
+      return false;
+    }
+    if (text == "inf" || text == "Inf") {
+      v = std::numeric_limits<double>::infinity();
+    } else if (text == "nan" || text == "NaN") {
+      v = nan("");
+    } else {
+      // Invalid string.
+      return false;
+    }
+  } else {
+    // Handle exponent if present.
+    if (ch == 'e' || ch == 'E') {
+      buffer->Advance(1);  // Skip 'e' marker.
+
+      // Parse integer exponent.
+      int32_t exponent = 0;
+      if (!ParseSignedInt(buffer, &exponent)) {
+        return false;
+      }
+
+      // Apply exponent scaling to value.
+      v *= pow(static_cast<double>(10.0), exponent);
+    }
+  }
+
+  *value = (sign < 0) ? static_cast<float>(-v) : static_cast<float>(v);
+  return true;
+}
+
+bool ParseSignedInt(DecoderBuffer *buffer, int32_t *value) {
+  // Parse any explicit sign and set the appropriate largest magnitude
+  // value that can be represented without overflow.
+  char ch;
+  if (!buffer->Peek(&ch)) {
+    return false;
+  }
+  const int sign = GetSignValue(ch);
+  if (sign != 0) {
+    buffer->Advance(1);
+  }
+
+  // Attempt to parse integer body.
+  uint32_t v;
+  if (!ParseUnsignedInt(buffer, &v)) {
+    return false;
+  }
+  *value = (sign < 0) ? -v : v;
+  return true;
+}
+
+bool ParseUnsignedInt(DecoderBuffer *buffer, uint32_t *value) {
+  // Parse the number until we run out of digits.
+  uint32_t v = 0;
+  char ch;
+  bool have_digits = false;
+  while (buffer->Peek(&ch) && ch >= '0' && ch <= '9') {
+    v *= 10;
+    v += (ch - '0');
+    buffer->Advance(1);
+    have_digits = true;
+  }
+  if (!have_digits) {
+    return false;
+  }
+  *value = v;
+  return true;
+}
+
+int GetSignValue(char c) {
+  if (c == '-') {
+    return -1;
+  }
+  if (c == '+') {
+    return 1;
+  }
+  return 0;
+}
+
+bool ParseString(DecoderBuffer *buffer, std::string *out_string) {
+  out_string->clear();
+  SkipWhitespace(buffer);
+  bool end_reached = false;
+  while (!PeekWhitespace(buffer, &end_reached) && !end_reached) {
+    char c;
+    if (!buffer->Decode(&c)) {
+      return false;
+    }
+    *out_string += c;
+  }
+  return true;
+}
+
+void ParseLine(DecoderBuffer *buffer, std::string *out_string) {
+  if (out_string) {
+    out_string->clear();
+  }
+  char c;
+  bool delim_reached = false;
+  while (buffer->Peek(&c)) {
+    // Check if |c| is a delimeter. We want to parse all delimeters until we
+    // reach a non-delimeter symbol. (E.g. we want to ignore '\r\n' at the end
+    // of the line).
+    const bool is_delim = (c == '\r' || c == '\n');
+
+    // If |c| is a delimeter or it is a non-delimeter symbol before any
+    // delimeter was found, we advance the buffer to the next character.
+    if (is_delim || !delim_reached) {
+      buffer->Advance(1);
+    }
+
+    if (is_delim) {
+      // Mark that we found a delimeter symbol.
+      delim_reached = true;
+      continue;
+    }
+    if (delim_reached) {
+      // We reached a non-delimeter symbol after a delimeter was already found.
+      // Stop the parsing.
+      return;
+    }
+    // Otherwise we put the non-delimeter symbol into the output string.
+    if (out_string) {
+      out_string->push_back(c);
+    }
+  }
+}
+
+DecoderBuffer ParseLineIntoDecoderBuffer(DecoderBuffer *buffer) {
+  const char *const head = buffer->data_head();
+  char c;
+  while (buffer->Peek(&c)) {
+    // Skip the character.
+    buffer->Advance(1);
+    if (c == '\n') {
+      break;  // End of the line reached.
+    }
+    if (c == '\r') {
+      continue;  // Ignore extra line ending characters.
+    }
+  }
+  DecoderBuffer out_buffer;
+  out_buffer.Init(head, buffer->data_head() - head);
+  return out_buffer;
+}
+
+std::string ToLower(const std::string &str) {
+  std::string out;
+  std::transform(str.begin(), str.end(), std::back_inserter(out), tolower);
+  return out;
+}
+
+}  // namespace parser
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/parser_utils.h b/contrib/draco/src/draco/io/parser_utils.h
new file mode 100644
index 000000000..b83cd9365
--- /dev/null
+++ b/contrib/draco/src/draco/io/parser_utils.h
@@ -0,0 +1,66 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PARSER_UTILS_H_
+#define DRACO_IO_PARSER_UTILS_H_
+
+#include "draco/core/decoder_buffer.h"
+
+namespace draco {
+namespace parser {
+
+// Skips to first character not included in |skip_chars|.
+void SkipCharacters(DecoderBuffer *buffer, const char *skip_chars);
+
+// Skips any whitespace until a regular character is reached.
+void SkipWhitespace(DecoderBuffer *buffer);
+
+// Returns true if the next character is a whitespace.
+// |end_reached| is set to true when the end of the stream is reached.
+bool PeekWhitespace(DecoderBuffer *buffer, bool *end_reached);
+
+// Skips all characters until the end of the line.
+void SkipLine(DecoderBuffer *buffer);
+
+// Parses signed floating point number or returns false on error.
+bool ParseFloat(DecoderBuffer *buffer, float *value);
+
+// Parses a signed integer (can be preceded by '-' or '+' characters.
+bool ParseSignedInt(DecoderBuffer *buffer, int32_t *value);
+
+// Parses an unsigned integer. It cannot be preceded by '-' or '+'
+// characters.
+bool ParseUnsignedInt(DecoderBuffer *buffer, uint32_t *value);
+
+// Returns -1 if c == '-'.
+// Returns +1 if c == '+'.
+// Returns 0 otherwise.
+int GetSignValue(char c);
+
+// Parses a string until a whitespace or end of file is reached.
+bool ParseString(DecoderBuffer *buffer, std::string *out_string);
+
+// Parses the entire line into the buffer (excluding the new line characters).
+void ParseLine(DecoderBuffer *buffer, std::string *out_string);
+
+// Parses line and stores into a new decoder buffer.
+DecoderBuffer ParseLineIntoDecoderBuffer(DecoderBuffer *buffer);
+
+// Returns a string with all characters converted to lower case.
+std::string ToLower(const std::string &str);
+
+}  // namespace parser
+}  // namespace draco
+
+#endif  // DRACO_IO_PARSER_UTILS_H_
diff --git a/contrib/draco/src/draco/io/ply_decoder.cc b/contrib/draco/src/draco/io/ply_decoder.cc
new file mode 100644
index 000000000..b78c05690
--- /dev/null
+++ b/contrib/draco/src/draco/io/ply_decoder.cc
@@ -0,0 +1,320 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/ply_decoder.h"
+
+#include "draco/core/macros.h"
+#include "draco/core/status.h"
+#include "draco/io/file_utils.h"
+#include "draco/io/ply_property_reader.h"
+
+namespace draco {
+namespace {
+int64_t CountNumTriangles(const PlyElement &face_element,
+                          const PlyProperty &vertex_indices) {
+  int64_t num_triangles = 0;
+  for (int i = 0; i < face_element.num_entries(); ++i) {
+    const int64_t list_size = vertex_indices.GetListEntryNumValues(i);
+    if (list_size < 3) {
+      // Correctly encoded ply files don't have less than three vertices.
+      continue;
+    }
+    num_triangles += list_size - 2;
+  }
+  return num_triangles;
+}
+}  // namespace
+
+PlyDecoder::PlyDecoder() : out_mesh_(nullptr), out_point_cloud_(nullptr) {}
+
+Status PlyDecoder::DecodeFromFile(const std::string &file_name,
+                                  Mesh *out_mesh) {
+  out_mesh_ = out_mesh;
+  return DecodeFromFile(file_name, static_cast<PointCloud *>(out_mesh));
+}
+
+Status PlyDecoder::DecodeFromFile(const std::string &file_name,
+                                  PointCloud *out_point_cloud) {
+  std::vector<char> data;
+  if (!ReadFileToBuffer(file_name, &data)) {
+    return Status(Status::DRACO_ERROR, "Unable to read input file.");
+  }
+  buffer_.Init(data.data(), data.size());
+  return DecodeFromBuffer(&buffer_, out_point_cloud);
+}
+
+Status PlyDecoder::DecodeFromBuffer(DecoderBuffer *buffer, Mesh *out_mesh) {
+  out_mesh_ = out_mesh;
+  return DecodeFromBuffer(buffer, static_cast<PointCloud *>(out_mesh));
+}
+
+Status PlyDecoder::DecodeFromBuffer(DecoderBuffer *buffer,
+                                    PointCloud *out_point_cloud) {
+  out_point_cloud_ = out_point_cloud;
+  buffer_.Init(buffer->data_head(), buffer->remaining_size());
+  return DecodeInternal();
+}
+
+Status PlyDecoder::DecodeInternal() {
+  PlyReader ply_reader;
+  DRACO_RETURN_IF_ERROR(ply_reader.Read(buffer()));
+  // First, decode the connectivity data.
+  if (out_mesh_)
+    DRACO_RETURN_IF_ERROR(DecodeFaceData(ply_reader.GetElementByName("face")));
+  // Decode all attributes.
+  DRACO_RETURN_IF_ERROR(
+      DecodeVertexData(ply_reader.GetElementByName("vertex")));
+  // In case there are no faces this is just a point cloud which does
+  // not require deduplication.
+  if (out_mesh_ && out_mesh_->num_faces() != 0) {
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+    if (!out_point_cloud_->DeduplicateAttributeValues()) {
+      return Status(Status::DRACO_ERROR,
+                    "Could not deduplicate attribute values");
+    }
+#endif
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+    out_point_cloud_->DeduplicatePointIds();
+#endif
+  }
+  return OkStatus();
+}
+
+Status PlyDecoder::DecodeFaceData(const PlyElement *face_element) {
+  // We accept point clouds now.
+  if (face_element == nullptr) {
+    return Status(Status::INVALID_PARAMETER, "face_element is null");
+  }
+  const PlyProperty *vertex_indices =
+      face_element->GetPropertyByName("vertex_indices");
+  if (vertex_indices == nullptr) {
+    // The property name may be named either "vertex_indices" or "vertex_index".
+    vertex_indices = face_element->GetPropertyByName("vertex_index");
+  }
+  if (vertex_indices == nullptr || !vertex_indices->is_list()) {
+    return Status(Status::DRACO_ERROR, "No faces defined");
+  }
+
+  // Allocate faces.
+  out_mesh_->SetNumFaces(CountNumTriangles(*face_element, *vertex_indices));
+  const int64_t num_polygons = face_element->num_entries();
+
+  PlyPropertyReader<PointIndex::ValueType> vertex_index_reader(vertex_indices);
+  Mesh::Face face;
+  FaceIndex face_index(0);
+  for (int i = 0; i < num_polygons; ++i) {
+    const int64_t list_offset = vertex_indices->GetListEntryOffset(i);
+    const int64_t list_size = vertex_indices->GetListEntryNumValues(i);
+    if (list_size < 3) {
+      continue;  // All invalid polygons are skipped.
+    }
+
+    // Triangulate polygon assuming the polygon is convex.
+    const int64_t num_triangles = list_size - 2;
+    face[0] = vertex_index_reader.ReadValue(static_cast<int>(list_offset));
+    for (int64_t ti = 0; ti < num_triangles; ++ti) {
+      for (int64_t c = 1; c < 3; ++c) {
+        face[c] = vertex_index_reader.ReadValue(
+            static_cast<int>(list_offset + ti + c));
+      }
+      out_mesh_->SetFace(face_index, face);
+      face_index++;
+    }
+  }
+  out_mesh_->SetNumFaces(face_index.value());
+  return OkStatus();
+}
+
+template <typename DataTypeT>
+bool PlyDecoder::ReadPropertiesToAttribute(
+    const std::vector<const PlyProperty *> &properties,
+    PointAttribute *attribute, int num_vertices) {
+  std::vector<std::unique_ptr<PlyPropertyReader<DataTypeT>>> readers;
+  readers.reserve(properties.size());
+  for (int prop = 0; prop < properties.size(); ++prop) {
+    readers.push_back(std::unique_ptr<PlyPropertyReader<DataTypeT>>(
+        new PlyPropertyReader<DataTypeT>(properties[prop])));
+  }
+  std::vector<DataTypeT> memory(properties.size());
+  for (PointIndex::ValueType i = 0; i < static_cast<uint32_t>(num_vertices);
+       ++i) {
+    for (int prop = 0; prop < properties.size(); ++prop) {
+      memory[prop] = readers[prop]->ReadValue(i);
+    }
+    attribute->SetAttributeValue(AttributeValueIndex(i), memory.data());
+  }
+  return true;
+}
+
+Status PlyDecoder::DecodeVertexData(const PlyElement *vertex_element) {
+  if (vertex_element == nullptr) {
+    return Status(Status::INVALID_PARAMETER, "vertex_element is null");
+  }
+  // TODO(b/34330853): For now, try to load x,y,z vertices, red,green,blue,alpha
+  // colors, and nx,ny,nz normals. We need to add other properties later.
+  const PlyProperty *const x_prop = vertex_element->GetPropertyByName("x");
+  const PlyProperty *const y_prop = vertex_element->GetPropertyByName("y");
+  const PlyProperty *const z_prop = vertex_element->GetPropertyByName("z");
+  if (!x_prop || !y_prop || !z_prop) {
+    // Currently, we require 3 vertex coordinates (this should be generalized
+    // later on).
+    return Status(Status::INVALID_PARAMETER, "x, y, or z property is missing");
+  }
+  const PointIndex::ValueType num_vertices = vertex_element->num_entries();
+  out_point_cloud_->set_num_points(num_vertices);
+  // Decode vertex positions.
+  {
+    // All properties must have the same type.
+    if (x_prop->data_type() != y_prop->data_type() ||
+        y_prop->data_type() != z_prop->data_type()) {
+      return Status(Status::INVALID_PARAMETER,
+                    "x, y, and z properties must have the same type");
+    }
+    // TODO(ostava): For now assume the position types are float32 or int32.
+    const DataType dt = x_prop->data_type();
+    if (dt != DT_FLOAT32 && dt != DT_INT32) {
+      return Status(Status::INVALID_PARAMETER,
+                    "x, y, and z properties must be of type float32 or int32");
+    }
+
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::POSITION, nullptr, 3, dt, false,
+            DataTypeLength(dt) * 3, 0);
+    const int att_id = out_point_cloud_->AddAttribute(va, true, num_vertices);
+    std::vector<const PlyProperty *> properties;
+    properties.push_back(x_prop);
+    properties.push_back(y_prop);
+    properties.push_back(z_prop);
+    if (dt == DT_FLOAT32) {
+      ReadPropertiesToAttribute<float>(
+          properties, out_point_cloud_->attribute(att_id), num_vertices);
+    } else if (dt == DT_INT32) {
+      ReadPropertiesToAttribute<int32_t>(
+          properties, out_point_cloud_->attribute(att_id), num_vertices);
+    }
+  }
+
+  // Decode normals if present.
+  const PlyProperty *const n_x_prop = vertex_element->GetPropertyByName("nx");
+  const PlyProperty *const n_y_prop = vertex_element->GetPropertyByName("ny");
+  const PlyProperty *const n_z_prop = vertex_element->GetPropertyByName("nz");
+  if (n_x_prop != nullptr && n_y_prop != nullptr && n_z_prop != nullptr) {
+    // For now, all normal properties must be set and of type float32
+    if (n_x_prop->data_type() == DT_FLOAT32 &&
+        n_y_prop->data_type() == DT_FLOAT32 &&
+        n_z_prop->data_type() == DT_FLOAT32) {
+      PlyPropertyReader<float> x_reader(n_x_prop);
+      PlyPropertyReader<float> y_reader(n_y_prop);
+      PlyPropertyReader<float> z_reader(n_z_prop);
+      GeometryAttribute va;
+      va.Init(GeometryAttribute::NORMAL, nullptr, 3, DT_FLOAT32, false,
+              sizeof(float) * 3, 0);
+      const int att_id = out_point_cloud_->AddAttribute(va, true, num_vertices);
+      for (PointIndex::ValueType i = 0; i < num_vertices; ++i) {
+        std::array<float, 3> val;
+        val[0] = x_reader.ReadValue(i);
+        val[1] = y_reader.ReadValue(i);
+        val[2] = z_reader.ReadValue(i);
+        out_point_cloud_->attribute(att_id)->SetAttributeValue(
+            AttributeValueIndex(i), &val[0]);
+      }
+    }
+  }
+
+  // Decode color data if present.
+  int num_colors = 0;
+  const PlyProperty *const r_prop = vertex_element->GetPropertyByName("red");
+  const PlyProperty *const g_prop = vertex_element->GetPropertyByName("green");
+  const PlyProperty *const b_prop = vertex_element->GetPropertyByName("blue");
+  const PlyProperty *const a_prop = vertex_element->GetPropertyByName("alpha");
+  if (r_prop) {
+    ++num_colors;
+  }
+  if (g_prop) {
+    ++num_colors;
+  }
+  if (b_prop) {
+    ++num_colors;
+  }
+  if (a_prop) {
+    ++num_colors;
+  }
+
+  if (num_colors) {
+    std::vector<std::unique_ptr<PlyPropertyReader<uint8_t>>> color_readers;
+    const PlyProperty *p;
+    if (r_prop) {
+      p = r_prop;
+      // TODO(ostava): For now ensure the data type of all components is uint8.
+      DRACO_DCHECK_EQ(true, p->data_type() == DT_UINT8);
+      if (p->data_type() != DT_UINT8) {
+        return Status(Status::INVALID_PARAMETER,
+                      "Type of 'red' property must be uint8");
+      }
+      color_readers.push_back(std::unique_ptr<PlyPropertyReader<uint8_t>>(
+          new PlyPropertyReader<uint8_t>(p)));
+    }
+    if (g_prop) {
+      p = g_prop;
+      // TODO(ostava): For now ensure the data type of all components is uint8.
+      DRACO_DCHECK_EQ(true, p->data_type() == DT_UINT8);
+      if (p->data_type() != DT_UINT8) {
+        return Status(Status::INVALID_PARAMETER,
+                      "Type of 'green' property must be uint8");
+      }
+      color_readers.push_back(std::unique_ptr<PlyPropertyReader<uint8_t>>(
+          new PlyPropertyReader<uint8_t>(p)));
+    }
+    if (b_prop) {
+      p = b_prop;
+      // TODO(ostava): For now ensure the data type of all components is uint8.
+      DRACO_DCHECK_EQ(true, p->data_type() == DT_UINT8);
+      if (p->data_type() != DT_UINT8) {
+        return Status(Status::INVALID_PARAMETER,
+                      "Type of 'blue' property must be uint8");
+      }
+      color_readers.push_back(std::unique_ptr<PlyPropertyReader<uint8_t>>(
+          new PlyPropertyReader<uint8_t>(p)));
+    }
+    if (a_prop) {
+      p = a_prop;
+      // TODO(ostava): For now ensure the data type of all components is uint8.
+      DRACO_DCHECK_EQ(true, p->data_type() == DT_UINT8);
+      if (p->data_type() != DT_UINT8) {
+        return Status(Status::INVALID_PARAMETER,
+                      "Type of 'alpha' property must be uint8");
+      }
+      color_readers.push_back(std::unique_ptr<PlyPropertyReader<uint8_t>>(
+          new PlyPropertyReader<uint8_t>(p)));
+    }
+
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::COLOR, nullptr, num_colors, DT_UINT8, true,
+            sizeof(uint8_t) * num_colors, 0);
+    const int32_t att_id =
+        out_point_cloud_->AddAttribute(va, true, num_vertices);
+    for (PointIndex::ValueType i = 0; i < num_vertices; ++i) {
+      std::array<uint8_t, 4> val;
+      for (int j = 0; j < num_colors; j++) {
+        val[j] = color_readers[j]->ReadValue(i);
+      }
+      out_point_cloud_->attribute(att_id)->SetAttributeValue(
+          AttributeValueIndex(i), &val[0]);
+    }
+  }
+
+  return OkStatus();
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/ply_decoder.h b/contrib/draco/src/draco/io/ply_decoder.h
new file mode 100644
index 000000000..db1e480c1
--- /dev/null
+++ b/contrib/draco/src/draco/io/ply_decoder.h
@@ -0,0 +1,69 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PLY_DECODER_H_
+#define DRACO_IO_PLY_DECODER_H_
+
+#include <string>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/status.h"
+#include "draco/draco_features.h"
+#include "draco/io/ply_reader.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Decodes a PLY file into draco::Mesh (or draco::PointCloud if the
+// connectivity data is not needed).
+// TODO(b/34330853): The current implementation assumes that the input vertices
+// are defined with x, y, z properties. The decoder also reads uint8 red, green,
+// blue, alpha color information, float32 defined as nx, ny, nz properties, but
+// all other attributes are ignored for now.
+class PlyDecoder {
+ public:
+  PlyDecoder();
+
+  // Decodes an obj file stored in the input file.
+  Status DecodeFromFile(const std::string &file_name, Mesh *out_mesh);
+  Status DecodeFromFile(const std::string &file_name,
+                        PointCloud *out_point_cloud);
+
+  Status DecodeFromBuffer(DecoderBuffer *buffer, Mesh *out_mesh);
+  Status DecodeFromBuffer(DecoderBuffer *buffer, PointCloud *out_point_cloud);
+
+ protected:
+  Status DecodeInternal();
+  DecoderBuffer *buffer() { return &buffer_; }
+
+ private:
+  Status DecodeFaceData(const PlyElement *face_element);
+  Status DecodeVertexData(const PlyElement *vertex_element);
+
+  template <typename DataTypeT>
+  bool ReadPropertiesToAttribute(
+      const std::vector<const PlyProperty *> &properties,
+      PointAttribute *attribute, int num_vertices);
+
+  DecoderBuffer buffer_;
+
+  // Data structure that stores the decoded data. |out_point_cloud_| must be
+  // always set but |out_mesh_| is optional.
+  Mesh *out_mesh_;
+  PointCloud *out_point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_DECODER_H_
diff --git a/contrib/draco/src/draco/io/ply_decoder_test.cc b/contrib/draco/src/draco/io/ply_decoder_test.cc
new file mode 100644
index 000000000..97977c8cc
--- /dev/null
+++ b/contrib/draco/src/draco/io/ply_decoder_test.cc
@@ -0,0 +1,93 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/ply_decoder.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+
+namespace draco {
+
+class PlyDecoderTest : public ::testing::Test {
+ protected:
+  template <class Geometry>
+  std::unique_ptr<Geometry> DecodePly(const std::string &file_name) const {
+    const std::string path = GetTestFileFullPath(file_name);
+    PlyDecoder decoder;
+    std::unique_ptr<Geometry> geometry(new Geometry());
+    Status status = decoder.DecodeFromFile(path, geometry.get());
+    if (!status.ok()) {
+      LOG(ERROR) << "Failed to decode " << file_name << ": " << status;
+      return nullptr;
+    }
+    return geometry;
+  }
+
+  void test_decoding(const std::string &file_name, int num_faces,
+                     uint32_t num_points, std::unique_ptr<Mesh> *out_mesh) {
+    // Don't test mesh decoding when the input is point cloud.
+    if (num_faces > 0) {
+      std::unique_ptr<Mesh> mesh(DecodePly<Mesh>(file_name));
+      ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+      ASSERT_EQ(mesh->num_faces(), num_faces);
+      if (out_mesh) {
+        *out_mesh = std::move(mesh);
+      }
+    }
+
+    const std::unique_ptr<PointCloud> pc(DecodePly<PointCloud>(file_name));
+    ASSERT_NE(pc, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_EQ(pc->num_points(), num_points);
+  }
+  void test_decoding(const std::string &file_name) {
+    const std::unique_ptr<Mesh> mesh(DecodePly<Mesh>(file_name));
+    ASSERT_NE(mesh, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_GT(mesh->num_faces(), 0);
+
+    const std::unique_ptr<PointCloud> pc(DecodePly<PointCloud>(file_name));
+    ASSERT_NE(pc, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_GT(pc->num_points(), 0);
+  }
+};
+
+TEST_F(PlyDecoderTest, TestPlyDecoding) {
+  const std::string file_name = "test_pos_color.ply";
+  test_decoding(file_name, 224, 114, nullptr);
+}
+
+TEST_F(PlyDecoderTest, TestPlyNormals) {
+  const std::string file_name = "cube_att.ply";
+  std::unique_ptr<Mesh> mesh;
+  test_decoding(file_name, 12, 3 * 8, &mesh);
+  ASSERT_NE(mesh, nullptr);
+  const int att_id = mesh->GetNamedAttributeId(GeometryAttribute::NORMAL);
+  ASSERT_GE(att_id, 0);
+  const PointAttribute *const att = mesh->attribute(att_id);
+  ASSERT_EQ(att->size(), 6);  // 6 unique normal values.
+}
+
+TEST_F(PlyDecoderTest, TestPlyDecodingAll) {
+  // test if we can read all ply that are currently in test folder.
+  test_decoding("bun_zipper.ply");
+  // test_decoding("cube_att.ply"); // tested
+  test_decoding("test_extra_whitespace.ply");
+  test_decoding("test_more_datatypes.ply");
+  test_decoding("test_pos_color_ascii.ply");
+  test_decoding("int_point_cloud.ply", 0, 16, nullptr);
+  // test_decoding("test_pos_color.ply"); // tested
+  test_decoding("cube_quads.ply");
+  test_decoding("Box.ply");
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/ply_encoder.cc b/contrib/draco/src/draco/io/ply_encoder.cc
new file mode 100644
index 000000000..2f6a1a2a8
--- /dev/null
+++ b/contrib/draco/src/draco/io/ply_encoder.cc
@@ -0,0 +1,211 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/ply_encoder.h"
+
+#include <memory>
+#include <sstream>
+
+#include "draco/io/file_writer_factory.h"
+#include "draco/io/file_writer_interface.h"
+
+namespace draco {
+
+PlyEncoder::PlyEncoder()
+    : out_buffer_(nullptr), in_point_cloud_(nullptr), in_mesh_(nullptr) {}
+
+bool PlyEncoder::EncodeToFile(const PointCloud &pc,
+                              const std::string &file_name) {
+  std::unique_ptr<FileWriterInterface> file =
+      FileWriterFactory::OpenWriter(file_name);
+  if (!file) {
+    return false;  // File couldn't be opened.
+  }
+  // Encode the mesh into a buffer.
+  EncoderBuffer buffer;
+  if (!EncodeToBuffer(pc, &buffer)) {
+    return false;
+  }
+  // Write the buffer into the file.
+  file->Write(buffer.data(), buffer.size());
+  return true;
+}
+
+bool PlyEncoder::EncodeToFile(const Mesh &mesh, const std::string &file_name) {
+  in_mesh_ = &mesh;
+  return EncodeToFile(static_cast<const PointCloud &>(mesh), file_name);
+}
+
+bool PlyEncoder::EncodeToBuffer(const PointCloud &pc,
+                                EncoderBuffer *out_buffer) {
+  in_point_cloud_ = &pc;
+  out_buffer_ = out_buffer;
+  if (!EncodeInternal()) {
+    return ExitAndCleanup(false);
+  }
+  return ExitAndCleanup(true);
+}
+
+bool PlyEncoder::EncodeToBuffer(const Mesh &mesh, EncoderBuffer *out_buffer) {
+  in_mesh_ = &mesh;
+  return EncodeToBuffer(static_cast<const PointCloud &>(mesh), out_buffer);
+}
+bool PlyEncoder::EncodeInternal() {
+  // Write PLY header.
+  // TODO(ostava): Currently works only for xyz positions and rgb(a) colors.
+  std::stringstream out;
+  out << "ply" << std::endl;
+  out << "format binary_little_endian 1.0" << std::endl;
+  out << "element vertex " << in_point_cloud_->num_points() << std::endl;
+
+  const int pos_att_id =
+      in_point_cloud_->GetNamedAttributeId(GeometryAttribute::POSITION);
+  int normal_att_id =
+      in_point_cloud_->GetNamedAttributeId(GeometryAttribute::NORMAL);
+  int tex_coord_att_id =
+      in_point_cloud_->GetNamedAttributeId(GeometryAttribute::TEX_COORD);
+  const int color_att_id =
+      in_point_cloud_->GetNamedAttributeId(GeometryAttribute::COLOR);
+
+  if (pos_att_id < 0) {
+    return false;
+  }
+
+  // Ensure normals are 3 component. Don't encode them otherwise.
+  if (normal_att_id >= 0 &&
+      in_point_cloud_->attribute(normal_att_id)->num_components() != 3) {
+    normal_att_id = -1;
+  }
+
+  // Ensure texture coordinates have only 2 components. Don't encode them
+  // otherwise. TODO(ostava): Add support for 3 component normals (uvw).
+  if (tex_coord_att_id >= 0 &&
+      in_point_cloud_->attribute(tex_coord_att_id)->num_components() != 2) {
+    tex_coord_att_id = -1;
+  }
+
+  out << "property " << GetAttributeDataType(pos_att_id) << " x" << std::endl;
+  out << "property " << GetAttributeDataType(pos_att_id) << " y" << std::endl;
+  out << "property " << GetAttributeDataType(pos_att_id) << " z" << std::endl;
+  if (normal_att_id >= 0) {
+    out << "property " << GetAttributeDataType(normal_att_id) << " nx"
+        << std::endl;
+    out << "property " << GetAttributeDataType(normal_att_id) << " ny"
+        << std::endl;
+    out << "property " << GetAttributeDataType(normal_att_id) << " nz"
+        << std::endl;
+  }
+  if (color_att_id >= 0) {
+    const auto *const attribute = in_point_cloud_->attribute(color_att_id);
+    if (attribute->num_components() > 0) {
+      out << "property " << GetAttributeDataType(color_att_id) << " red"
+          << std::endl;
+    }
+    if (attribute->num_components() > 1) {
+      out << "property " << GetAttributeDataType(color_att_id) << " green"
+          << std::endl;
+    }
+    if (attribute->num_components() > 2) {
+      out << "property " << GetAttributeDataType(color_att_id) << " blue"
+          << std::endl;
+    }
+    if (attribute->num_components() > 3) {
+      out << "property " << GetAttributeDataType(color_att_id) << " alpha"
+          << std::endl;
+    }
+  }
+  if (in_mesh_) {
+    out << "element face " << in_mesh_->num_faces() << std::endl;
+    out << "property list uchar int vertex_indices" << std::endl;
+    if (tex_coord_att_id >= 0) {
+      // Texture coordinates are usually encoded in the property list (one value
+      // per corner).
+      out << "property list uchar " << GetAttributeDataType(tex_coord_att_id)
+          << " texcoord" << std::endl;
+    }
+  }
+  out << "end_header" << std::endl;
+
+  // Not very efficient but the header should be small so just copy the stream
+  // to a string.
+  const std::string header_str = out.str();
+  buffer()->Encode(header_str.data(), header_str.length());
+
+  // Store point attributes.
+  for (PointIndex v(0); v < in_point_cloud_->num_points(); ++v) {
+    const auto *const pos_att = in_point_cloud_->attribute(pos_att_id);
+    buffer()->Encode(pos_att->GetAddress(pos_att->mapped_index(v)),
+                     pos_att->byte_stride());
+    if (normal_att_id >= 0) {
+      const auto *const normal_att = in_point_cloud_->attribute(normal_att_id);
+      buffer()->Encode(normal_att->GetAddress(normal_att->mapped_index(v)),
+                       normal_att->byte_stride());
+    }
+    if (color_att_id >= 0) {
+      const auto *const color_att = in_point_cloud_->attribute(color_att_id);
+      buffer()->Encode(color_att->GetAddress(color_att->mapped_index(v)),
+                       color_att->byte_stride());
+    }
+  }
+
+  if (in_mesh_) {
+    // Write face data.
+    for (FaceIndex i(0); i < in_mesh_->num_faces(); ++i) {
+      // Write the number of face indices (always 3).
+      buffer()->Encode(static_cast<uint8_t>(3));
+
+      const auto &f = in_mesh_->face(i);
+      buffer()->Encode(f[0]);
+      buffer()->Encode(f[1]);
+      buffer()->Encode(f[2]);
+
+      if (tex_coord_att_id >= 0) {
+        // Two coordinates for every corner -> 6.
+        buffer()->Encode(static_cast<uint8_t>(6));
+
+        const auto *const tex_att =
+            in_point_cloud_->attribute(tex_coord_att_id);
+        for (int c = 0; c < 3; ++c) {
+          buffer()->Encode(tex_att->GetAddress(tex_att->mapped_index(f[c])),
+                           tex_att->byte_stride());
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool PlyEncoder::ExitAndCleanup(bool return_value) {
+  in_mesh_ = nullptr;
+  in_point_cloud_ = nullptr;
+  out_buffer_ = nullptr;
+  return return_value;
+}
+
+const char *PlyEncoder::GetAttributeDataType(int attribute) {
+  // TODO(ostava): Add support for more types.
+  switch (in_point_cloud_->attribute(attribute)->data_type()) {
+    case DT_FLOAT32:
+      return "float";
+    case DT_UINT8:
+      return "uchar";
+    case DT_INT32:
+      return "int";
+    default:
+      break;
+  }
+  return nullptr;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/ply_encoder.h b/contrib/draco/src/draco/io/ply_encoder.h
new file mode 100644
index 000000000..242bbd6d4
--- /dev/null
+++ b/contrib/draco/src/draco/io/ply_encoder.h
@@ -0,0 +1,54 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PLY_ENCODER_H_
+#define DRACO_IO_PLY_ENCODER_H_
+
+#include "draco/core/encoder_buffer.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class for encoding draco::Mesh or draco::PointCloud into the PLY file format.
+class PlyEncoder {
+ public:
+  PlyEncoder();
+
+  // Encodes the mesh or a point cloud  and saves it into a file.
+  // Returns false when either the encoding failed or when the file couldn't be
+  // opened.
+  bool EncodeToFile(const PointCloud &pc, const std::string &file_name);
+  bool EncodeToFile(const Mesh &mesh, const std::string &file_name);
+
+  // Encodes the mesh or the point cloud into a buffer.
+  bool EncodeToBuffer(const PointCloud &pc, EncoderBuffer *out_buffer);
+  bool EncodeToBuffer(const Mesh &mesh, EncoderBuffer *out_buffer);
+
+ protected:
+  bool EncodeInternal();
+  EncoderBuffer *buffer() const { return out_buffer_; }
+  bool ExitAndCleanup(bool return_value);
+
+ private:
+  const char *GetAttributeDataType(int attribute);
+
+  EncoderBuffer *out_buffer_;
+
+  const PointCloud *in_point_cloud_;
+  const Mesh *in_mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_ENCODER_H_
diff --git a/contrib/draco/src/draco/io/ply_property_reader.h b/contrib/draco/src/draco/io/ply_property_reader.h
new file mode 100644
index 000000000..efb8a3a1f
--- /dev/null
+++ b/contrib/draco/src/draco/io/ply_property_reader.h
@@ -0,0 +1,96 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PLY_PROPERTY_READER_H_
+#define DRACO_IO_PLY_PROPERTY_READER_H_
+
+#include <functional>
+
+#include "draco/io/ply_reader.h"
+
+namespace draco {
+
+// Class for reading PlyProperty with a given type, performing data conversion
+// if necessary.
+template <typename ReadTypeT>
+class PlyPropertyReader {
+ public:
+  explicit PlyPropertyReader(const PlyProperty *property)
+      : property_(property) {
+    // Find the suitable function for converting values.
+    switch (property->data_type()) {
+      case DT_UINT8:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<uint8_t>(val_id);
+        };
+        break;
+      case DT_INT8:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<int8_t>(val_id);
+        };
+        break;
+      case DT_UINT16:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<uint16_t>(val_id);
+        };
+        break;
+      case DT_INT16:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<int16_t>(val_id);
+        };
+        break;
+      case DT_UINT32:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<uint32_t>(val_id);
+        };
+        break;
+      case DT_INT32:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<int32_t>(val_id);
+        };
+        break;
+      case DT_FLOAT32:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<float>(val_id);
+        };
+        break;
+      case DT_FLOAT64:
+        convert_value_func_ = [=](int val_id) {
+          return this->ConvertValue<double>(val_id);
+        };
+        break;
+      default:
+        break;
+    }
+  }
+
+  ReadTypeT ReadValue(int value_id) const {
+    return convert_value_func_(value_id);
+  }
+
+ private:
+  template <typename SourceTypeT>
+  ReadTypeT ConvertValue(int value_id) const {
+    const void *const address = property_->GetDataEntryAddress(value_id);
+    const SourceTypeT src_val = *reinterpret_cast<const SourceTypeT *>(address);
+    return static_cast<ReadTypeT>(src_val);
+  }
+
+  const PlyProperty *property_;
+  std::function<ReadTypeT(int)> convert_value_func_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_PROPERTY_READER_H_
diff --git a/contrib/draco/src/draco/io/ply_property_writer.h b/contrib/draco/src/draco/io/ply_property_writer.h
new file mode 100644
index 000000000..4f243b286
--- /dev/null
+++ b/contrib/draco/src/draco/io/ply_property_writer.h
@@ -0,0 +1,94 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_PLY_PROPERTY_WRITER_H_
+#define DRACO_IO_PLY_PROPERTY_WRITER_H_
+
+#include <functional>
+
+#include "draco/io/ply_reader.h"
+
+namespace draco {
+
+// Class for writing PlyProperty with a given type, performing data conversion
+// if necessary.
+template <typename WriteTypeT>
+class PlyPropertyWriter {
+ public:
+  explicit PlyPropertyWriter(PlyProperty *property) : property_(property) {
+    // Find the suitable function for converting values.
+    switch (property->data_type()) {
+      case DT_UINT8:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<uint8_t>(val);
+        };
+        break;
+      case DT_INT8:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<int8_t>(val);
+        };
+        break;
+      case DT_UINT16:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<uint16_t>(val);
+        };
+        break;
+      case DT_INT16:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<int16_t>(val);
+        };
+        break;
+      case DT_UINT32:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<uint32_t>(val);
+        };
+        break;
+      case DT_INT32:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<int32_t>(val);
+        };
+        break;
+      case DT_FLOAT32:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<float>(val);
+        };
+        break;
+      case DT_FLOAT64:
+        convert_value_func_ = [=](WriteTypeT val) {
+          return this->ConvertValue<double>(val);
+        };
+        break;
+      default:
+        break;
+    }
+  }
+
+  void PushBackValue(WriteTypeT value) const {
+    return convert_value_func_(value);
+  }
+
+ private:
+  template <typename SourceTypeT>
+  void ConvertValue(WriteTypeT value) const {
+    const SourceTypeT src_val = static_cast<SourceTypeT>(value);
+    property_->push_back_value(&src_val);
+  }
+
+  PlyProperty *property_;
+  std::function<void(WriteTypeT)> convert_value_func_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_PROPERTY_WRITER_H_
diff --git a/contrib/draco/src/draco/io/ply_reader.cc b/contrib/draco/src/draco/io/ply_reader.cc
new file mode 100644
index 000000000..ea7f2689a
--- /dev/null
+++ b/contrib/draco/src/draco/io/ply_reader.cc
@@ -0,0 +1,312 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/ply_reader.h"
+
+#include <array>
+#include <regex>
+
+#include "draco/core/status.h"
+#include "draco/io/parser_utils.h"
+#include "draco/io/ply_property_writer.h"
+
+namespace draco {
+
+PlyProperty::PlyProperty(const std::string &name, DataType data_type,
+                         DataType list_type)
+    : name_(name), data_type_(data_type), list_data_type_(list_type) {
+  data_type_num_bytes_ = DataTypeLength(data_type);
+  list_data_type_num_bytes_ = DataTypeLength(list_type);
+}
+
+PlyElement::PlyElement(const std::string &name, int64_t num_entries)
+    : name_(name), num_entries_(num_entries) {}
+
+PlyReader::PlyReader() : format_(kLittleEndian) {}
+
+Status PlyReader::Read(DecoderBuffer *buffer) {
+  std::string value;
+  // The first line needs to by "ply".
+  if (!parser::ParseString(buffer, &value) || value != "ply") {
+    return Status(Status::INVALID_PARAMETER, "Not a valid ply file");
+  }
+  parser::SkipLine(buffer);
+
+  // The second line needs to be the format of the ply file.
+  parser::ParseLine(buffer, &value);
+  std::string format, version;
+  const std::vector<std::string> words = SplitWords(value);
+  if (words.size() >= 3 && words[0] == "format") {
+    format = words[1];
+    version = words[2];
+  } else {
+    return Status(Status::INVALID_PARAMETER, "Missing or wrong format line");
+  }
+  if (version != "1.0") {
+    return Status(Status::UNSUPPORTED_VERSION, "Unsupported PLY version");
+  }
+  if (format == "binary_big_endian") {
+    return Status(Status::UNSUPPORTED_VERSION,
+                  "Unsupported format. Currently we support only ascii and"
+                  " binary_little_endian format.");
+  }
+  if (format == "ascii") {
+    format_ = kAscii;
+  } else {
+    format_ = kLittleEndian;
+  }
+  DRACO_RETURN_IF_ERROR(ParseHeader(buffer));
+  if (!ParsePropertiesData(buffer)) {
+    return Status(Status::INVALID_PARAMETER, "Couldn't parse properties");
+  }
+  return OkStatus();
+}
+
+Status PlyReader::ParseHeader(DecoderBuffer *buffer) {
+  while (true) {
+    DRACO_ASSIGN_OR_RETURN(bool end, ParseEndHeader(buffer));
+    if (end) {
+      break;
+    }
+    if (ParseElement(buffer)) {
+      continue;
+    }
+    DRACO_ASSIGN_OR_RETURN(bool property_parsed, ParseProperty(buffer));
+    if (property_parsed) {
+      continue;
+    }
+    parser::SkipLine(buffer);
+  }
+  return OkStatus();
+}
+
+StatusOr<bool> PlyReader::ParseEndHeader(DecoderBuffer *buffer) {
+  parser::SkipWhitespace(buffer);
+  std::array<char, 10> c;
+  if (!buffer->Peek(&c)) {
+    return Status(Status::INVALID_PARAMETER,
+                  "End of file reached before the end_header");
+  }
+  if (std::memcmp(&c[0], "end_header", 10) != 0) {
+    return false;
+  }
+  parser::SkipLine(buffer);
+  return true;
+}
+
+bool PlyReader::ParseElement(DecoderBuffer *buffer) {
+  DecoderBuffer line_buffer(*buffer);
+  std::string line;
+  parser::ParseLine(&line_buffer, &line);
+
+  std::string element_name;
+  int64_t count;
+  const std::vector<std::string> words = SplitWords(line);
+  if (words.size() >= 3 && words[0] == "element") {
+    element_name = words[1];
+    const std::string count_str = words[2];
+    count = strtoll(count_str.c_str(), nullptr, 10);
+  } else {
+    return false;
+  }
+  element_index_[element_name] = static_cast<uint32_t>(elements_.size());
+  elements_.emplace_back(PlyElement(element_name, count));
+  *buffer = line_buffer;
+  return true;
+}
+
+StatusOr<bool> PlyReader::ParseProperty(DecoderBuffer *buffer) {
+  if (elements_.empty()) {
+    return false;  // Ignore properties if there is no active element.
+  }
+  DecoderBuffer line_buffer(*buffer);
+  std::string line;
+  parser::ParseLine(&line_buffer, &line);
+
+  std::string data_type_str, list_type_str, property_name;
+  bool property_search = false;
+  const std::vector<std::string> words = SplitWords(line);
+  if (words.size() >= 3 && words[0] == "property" && words[1] != "list") {
+    property_search = true;
+    data_type_str = words[1];
+    property_name = words[2];
+  }
+
+  bool property_list_search = false;
+  if (words.size() >= 5 && words[0] == "property" && words[1] == "list") {
+    property_list_search = true;
+    list_type_str = words[2];
+    data_type_str = words[3];
+    property_name = words[4];
+  }
+  if (!property_search && !property_list_search) {
+    return false;
+  }
+  const DataType data_type = GetDataTypeFromString(data_type_str);
+  if (data_type == DT_INVALID) {
+    return Status(Status::INVALID_PARAMETER, "Wrong property data type");
+  }
+  DataType list_type = DT_INVALID;
+  if (property_list_search) {
+    list_type = GetDataTypeFromString(list_type_str);
+    if (list_type == DT_INVALID) {
+      return Status(Status::INVALID_PARAMETER, "Wrong property list type");
+    }
+  }
+  elements_.back().AddProperty(
+      PlyProperty(property_name, data_type, list_type));
+  *buffer = line_buffer;
+  return true;
+}
+
+bool PlyReader::ParsePropertiesData(DecoderBuffer *buffer) {
+  for (int i = 0; i < static_cast<int>(elements_.size()); ++i) {
+    if (format_ == kLittleEndian) {
+      if (!ParseElementData(buffer, i)) {
+        return false;
+      }
+    } else if (format_ == kAscii) {
+      if (!ParseElementDataAscii(buffer, i)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+bool PlyReader::ParseElementData(DecoderBuffer *buffer, int element_index) {
+  PlyElement &element = elements_[element_index];
+  for (int entry = 0; entry < element.num_entries(); ++entry) {
+    for (int i = 0; i < element.num_properties(); ++i) {
+      PlyProperty &prop = element.property(i);
+      if (prop.is_list()) {
+        // Parse the number of entries for the list element.
+        int64_t num_entries = 0;
+        buffer->Decode(&num_entries, prop.list_data_type_num_bytes());
+        // Store offset to the main data entry.
+        prop.list_data_.push_back(prop.data_.size() /
+                                  prop.data_type_num_bytes_);
+        // Store the number of entries.
+        prop.list_data_.push_back(num_entries);
+        // Read and store the actual property data
+        const int64_t num_bytes_to_read =
+            prop.data_type_num_bytes() * num_entries;
+        prop.data_.insert(prop.data_.end(), buffer->data_head(),
+                          buffer->data_head() + num_bytes_to_read);
+        buffer->Advance(num_bytes_to_read);
+      } else {
+        // Non-list property
+        prop.data_.insert(prop.data_.end(), buffer->data_head(),
+                          buffer->data_head() + prop.data_type_num_bytes());
+        buffer->Advance(prop.data_type_num_bytes());
+      }
+    }
+  }
+  return true;
+}
+
+bool PlyReader::ParseElementDataAscii(DecoderBuffer *buffer,
+                                      int element_index) {
+  PlyElement &element = elements_[element_index];
+  for (int entry = 0; entry < element.num_entries(); ++entry) {
+    for (int i = 0; i < element.num_properties(); ++i) {
+      PlyProperty &prop = element.property(i);
+      PlyPropertyWriter<double> prop_writer(&prop);
+      int32_t num_entries = 1;
+      if (prop.is_list()) {
+        parser::SkipWhitespace(buffer);
+        // Parse the number of entries for the list element.
+        if (!parser::ParseSignedInt(buffer, &num_entries)) {
+          return false;
+        }
+
+        // Store offset to the main data entry.
+        prop.list_data_.push_back(prop.data_.size() /
+                                  prop.data_type_num_bytes_);
+        // Store the number of entries.
+        prop.list_data_.push_back(num_entries);
+      }
+      // Read and store the actual property data.
+      for (int v = 0; v < num_entries; ++v) {
+        parser::SkipWhitespace(buffer);
+        if (prop.data_type() == DT_FLOAT32 || prop.data_type() == DT_FLOAT64) {
+          float val;
+          if (!parser::ParseFloat(buffer, &val)) {
+            return false;
+          }
+          prop_writer.PushBackValue(val);
+        } else {
+          int32_t val;
+          if (!parser::ParseSignedInt(buffer, &val)) {
+            return false;
+          }
+          prop_writer.PushBackValue(val);
+        }
+      }
+    }
+  }
+  return true;
+}
+
+std::vector<std::string> PlyReader::SplitWords(const std::string &line) {
+  std::vector<std::string> output;
+  std::string::size_type start = 0;
+  std::string::size_type end = 0;
+
+  // Check for isspace chars.
+  while ((end = line.find_first_of(" \t\n\v\f\r", start)) !=
+         std::string::npos) {
+    const std::string word(line.substr(start, end - start));
+    if (!std::all_of(word.begin(), word.end(), isspace)) {
+      output.push_back(word);
+    }
+    start = end + 1;
+  }
+
+  const std::string last_word(line.substr(start));
+  if (!std::all_of(last_word.begin(), last_word.end(), isspace)) {
+    output.push_back(last_word);
+  }
+  return output;
+}
+
+DataType PlyReader::GetDataTypeFromString(const std::string &name) const {
+  if (name == "char" || name == "int8") {
+    return DT_INT8;
+  }
+  if (name == "uchar" || name == "uint8") {
+    return DT_UINT8;
+  }
+  if (name == "short" || name == "int16") {
+    return DT_INT16;
+  }
+  if (name == "ushort" || name == "uint16") {
+    return DT_UINT16;
+  }
+  if (name == "int" || name == "int32") {
+    return DT_INT32;
+  }
+  if (name == "uint" || name == "uint32") {
+    return DT_UINT32;
+  }
+  if (name == "float" || name == "float32") {
+    return DT_FLOAT32;
+  }
+  if (name == "double" || name == "float64") {
+    return DT_FLOAT64;
+  }
+  return DT_INVALID;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/ply_reader.h b/contrib/draco/src/draco/io/ply_reader.h
new file mode 100644
index 000000000..e0f15a313
--- /dev/null
+++ b/contrib/draco/src/draco/io/ply_reader.h
@@ -0,0 +1,155 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// File contains helper classes used for parsing of PLY files. The classes are
+// used by the PlyDecoder (ply_decoder.h) to read a point cloud or mesh from a
+// source PLY file.
+// TODO(ostava): Currently, we support only binary PLYs encoded in the little
+// endian format ("format binary_little_endian 1.0").
+
+#ifndef DRACO_IO_PLY_READER_H_
+#define DRACO_IO_PLY_READER_H_
+
+#include <map>
+#include <vector>
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/draco_types.h"
+#include "draco/core/status.h"
+#include "draco/core/status_or.h"
+
+namespace draco {
+
+// A single PLY property of a given PLY element. For "vertex" element this can
+// contain data such as "x", "y", or "z" coordinate of the vertex, while for
+// "face" element this usually contains corner indices.
+class PlyProperty {
+ public:
+  friend class PlyReader;
+
+  PlyProperty(const std::string &name, DataType data_type, DataType list_type);
+  void ReserveData(int num_entries) {
+    data_.reserve(DataTypeLength(data_type_) * num_entries);
+  }
+
+  int64_t GetListEntryOffset(int entry_id) const {
+    return list_data_[entry_id * 2];
+  }
+  int64_t GetListEntryNumValues(int entry_id) const {
+    return list_data_[entry_id * 2 + 1];
+  }
+  const void *GetDataEntryAddress(int entry_id) const {
+    return data_.data() + entry_id * data_type_num_bytes_;
+  }
+  void push_back_value(const void *data) {
+    data_.insert(data_.end(), static_cast<const uint8_t *>(data),
+                 static_cast<const uint8_t *>(data) + data_type_num_bytes_);
+  }
+
+  const std::string &name() const { return name_; }
+  bool is_list() const { return list_data_type_ != DT_INVALID; }
+  DataType data_type() const { return data_type_; }
+  int data_type_num_bytes() const { return data_type_num_bytes_; }
+  DataType list_data_type() const { return list_data_type_; }
+  int list_data_type_num_bytes() const { return list_data_type_num_bytes_; }
+
+ private:
+  std::string name_;
+  std::vector<uint8_t> data_;
+  // List data contain pairs of <offset, number_of_values>
+  std::vector<int64_t> list_data_;
+  DataType data_type_;
+  int data_type_num_bytes_;
+  DataType list_data_type_;
+  int list_data_type_num_bytes_;
+};
+
+// A single PLY element such as "vertex" or "face". Each element can store
+// arbitrary properties such as vertex coordinates or face indices.
+class PlyElement {
+ public:
+  PlyElement(const std::string &name, int64_t num_entries);
+  void AddProperty(const PlyProperty &prop) {
+    property_index_[prop.name()] = static_cast<int>(properties_.size());
+    properties_.emplace_back(prop);
+    if (!properties_.back().is_list()) {
+      properties_.back().ReserveData(static_cast<int>(num_entries_));
+    }
+  }
+
+  const PlyProperty *GetPropertyByName(const std::string &name) const {
+    const auto it = property_index_.find(name);
+    if (it != property_index_.end()) {
+      return &properties_[it->second];
+    }
+    return nullptr;
+  }
+
+  int num_properties() const { return static_cast<int>(properties_.size()); }
+  int num_entries() const { return static_cast<int>(num_entries_); }
+  const PlyProperty &property(int prop_index) const {
+    return properties_[prop_index];
+  }
+  PlyProperty &property(int prop_index) { return properties_[prop_index]; }
+
+ private:
+  std::string name_;
+  int64_t num_entries_;
+  std::vector<PlyProperty> properties_;
+  std::map<std::string, int> property_index_;
+};
+
+// Class responsible for parsing PLY data. It produces a list of PLY elements
+// and their properties that can be used to construct a mesh or a point cloud.
+class PlyReader {
+ public:
+  PlyReader();
+  Status Read(DecoderBuffer *buffer);
+
+  const PlyElement *GetElementByName(const std::string &name) const {
+    const auto it = element_index_.find(name);
+    if (it != element_index_.end()) {
+      return &elements_[it->second];
+    }
+    return nullptr;
+  }
+
+  int num_elements() const { return static_cast<int>(elements_.size()); }
+  const PlyElement &element(int element_index) const {
+    return elements_[element_index];
+  }
+
+ private:
+  enum Format { kLittleEndian = 0, kAscii };
+
+  Status ParseHeader(DecoderBuffer *buffer);
+  StatusOr<bool> ParseEndHeader(DecoderBuffer *buffer);
+  bool ParseElement(DecoderBuffer *buffer);
+  StatusOr<bool> ParseProperty(DecoderBuffer *buffer);
+  bool ParsePropertiesData(DecoderBuffer *buffer);
+  bool ParseElementData(DecoderBuffer *buffer, int element_index);
+  bool ParseElementDataAscii(DecoderBuffer *buffer, int element_index);
+
+  // Splits |line| by whitespace characters.
+  std::vector<std::string> SplitWords(const std::string &line);
+  DataType GetDataTypeFromString(const std::string &name) const;
+
+  std::vector<PlyElement> elements_;
+  std::map<std::string, int> element_index_;
+  Format format_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_PLY_READER_H_
diff --git a/contrib/draco/src/draco/io/ply_reader_test.cc b/contrib/draco/src/draco/io/ply_reader_test.cc
new file mode 100644
index 000000000..05ff63dd4
--- /dev/null
+++ b/contrib/draco/src/draco/io/ply_reader_test.cc
@@ -0,0 +1,143 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/ply_reader.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/file_utils.h"
+#include "draco/io/ply_property_reader.h"
+
+namespace draco {
+
+class PlyReaderTest : public ::testing::Test {
+ protected:
+  std::vector<char> ReadPlyFile(const std::string &file_name) const {
+    const std::string path = GetTestFileFullPath(file_name);
+
+    std::vector<char> data;
+    EXPECT_TRUE(ReadFileToBuffer(path, &data));
+    return data;
+  }
+};
+
+TEST_F(PlyReaderTest, TestReader) {
+  const std::string file_name = "test_pos_color.ply";
+  const std::vector<char> data = ReadPlyFile(file_name);
+  DecoderBuffer buf;
+  buf.Init(data.data(), data.size());
+  PlyReader reader;
+  Status status = reader.Read(&buf);
+  ASSERT_TRUE(status.ok()) << status;
+  ASSERT_EQ(reader.num_elements(), 2);
+  ASSERT_EQ(reader.element(0).num_properties(), 7);
+  ASSERT_EQ(reader.element(1).num_properties(), 1);
+  ASSERT_TRUE(reader.element(1).property(0).is_list());
+
+  ASSERT_TRUE(reader.element(0).GetPropertyByName("red") != nullptr);
+  const PlyProperty *const prop = reader.element(0).GetPropertyByName("red");
+  PlyPropertyReader<uint8_t> reader_uint8(prop);
+  PlyPropertyReader<uint32_t> reader_uint32(prop);
+  PlyPropertyReader<float> reader_float(prop);
+  for (int i = 0; i < reader.element(0).num_entries(); ++i) {
+    ASSERT_EQ(reader_uint8.ReadValue(i), reader_uint32.ReadValue(i));
+    ASSERT_EQ(reader_uint8.ReadValue(i), reader_float.ReadValue(i));
+  }
+}
+
+TEST_F(PlyReaderTest, TestReaderAscii) {
+  const std::string file_name = "test_pos_color.ply";
+  const std::vector<char> data = ReadPlyFile(file_name);
+  ASSERT_NE(data.size(), 0u);
+  DecoderBuffer buf;
+  buf.Init(data.data(), data.size());
+  PlyReader reader;
+  Status status = reader.Read(&buf);
+  ASSERT_TRUE(status.ok()) << status;
+
+  const std::string file_name_ascii = "test_pos_color_ascii.ply";
+  const std::vector<char> data_ascii = ReadPlyFile(file_name_ascii);
+  buf.Init(data_ascii.data(), data_ascii.size());
+  PlyReader reader_ascii;
+  status = reader_ascii.Read(&buf);
+  ASSERT_TRUE(status.ok()) << status;
+  ASSERT_EQ(reader.num_elements(), reader_ascii.num_elements());
+  ASSERT_EQ(reader.element(0).num_properties(),
+            reader_ascii.element(0).num_properties());
+
+  ASSERT_TRUE(reader.element(0).GetPropertyByName("x") != nullptr);
+  const PlyProperty *const prop = reader.element(0).GetPropertyByName("x");
+  const PlyProperty *const prop_ascii =
+      reader_ascii.element(0).GetPropertyByName("x");
+  PlyPropertyReader<float> reader_float(prop);
+  PlyPropertyReader<float> reader_float_ascii(prop_ascii);
+  for (int i = 0; i < reader.element(0).num_entries(); ++i) {
+    ASSERT_NEAR(reader_float.ReadValue(i), reader_float_ascii.ReadValue(i),
+                1e-4f);
+  }
+}
+
+TEST_F(PlyReaderTest, TestReaderExtraWhitespace) {
+  const std::string file_name = "test_extra_whitespace.ply";
+  const std::vector<char> data = ReadPlyFile(file_name);
+  ASSERT_NE(data.size(), 0u);
+  DecoderBuffer buf;
+  buf.Init(data.data(), data.size());
+  PlyReader reader;
+  Status status = reader.Read(&buf);
+  ASSERT_TRUE(status.ok()) << status;
+
+  ASSERT_EQ(reader.num_elements(), 2);
+  ASSERT_EQ(reader.element(0).num_properties(), 7);
+  ASSERT_EQ(reader.element(1).num_properties(), 1);
+  ASSERT_TRUE(reader.element(1).property(0).is_list());
+
+  ASSERT_TRUE(reader.element(0).GetPropertyByName("red") != nullptr);
+  const PlyProperty *const prop = reader.element(0).GetPropertyByName("red");
+  PlyPropertyReader<uint8_t> reader_uint8(prop);
+  PlyPropertyReader<uint32_t> reader_uint32(prop);
+  PlyPropertyReader<float> reader_float(prop);
+  for (int i = 0; i < reader.element(0).num_entries(); ++i) {
+    ASSERT_EQ(reader_uint8.ReadValue(i), reader_uint32.ReadValue(i));
+    ASSERT_EQ(reader_uint8.ReadValue(i), reader_float.ReadValue(i));
+  }
+}
+
+TEST_F(PlyReaderTest, TestReaderMoreDataTypes) {
+  const std::string file_name = "test_more_datatypes.ply";
+  const std::vector<char> data = ReadPlyFile(file_name);
+  ASSERT_NE(data.size(), 0u);
+  DecoderBuffer buf;
+  buf.Init(data.data(), data.size());
+  PlyReader reader;
+  Status status = reader.Read(&buf);
+  ASSERT_TRUE(status.ok()) << status;
+
+  ASSERT_EQ(reader.num_elements(), 2);
+  ASSERT_EQ(reader.element(0).num_properties(), 7);
+  ASSERT_EQ(reader.element(1).num_properties(), 1);
+  ASSERT_TRUE(reader.element(1).property(0).is_list());
+
+  ASSERT_TRUE(reader.element(0).GetPropertyByName("red") != nullptr);
+  const PlyProperty *const prop = reader.element(0).GetPropertyByName("red");
+  PlyPropertyReader<uint8_t> reader_uint8(prop);
+  PlyPropertyReader<uint32_t> reader_uint32(prop);
+  PlyPropertyReader<float> reader_float(prop);
+  for (int i = 0; i < reader.element(0).num_entries(); ++i) {
+    ASSERT_EQ(reader_uint8.ReadValue(i), reader_uint32.ReadValue(i));
+    ASSERT_EQ(reader_uint8.ReadValue(i), reader_float.ReadValue(i));
+  }
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/point_cloud_io.cc b/contrib/draco/src/draco/io/point_cloud_io.cc
new file mode 100644
index 000000000..643820bde
--- /dev/null
+++ b/contrib/draco/src/draco/io/point_cloud_io.cc
@@ -0,0 +1,58 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/point_cloud_io.h"
+
+#include "draco/io/file_utils.h"
+#include "draco/io/obj_decoder.h"
+#include "draco/io/parser_utils.h"
+#include "draco/io/ply_decoder.h"
+
+namespace draco {
+
+StatusOr<std::unique_ptr<PointCloud>> ReadPointCloudFromFile(
+    const std::string &file_name) {
+  std::unique_ptr<PointCloud> pc(new PointCloud());
+  // Analyze file extension.
+  const std::string extension = parser::ToLower(
+      file_name.size() >= 4 ? file_name.substr(file_name.size() - 4)
+                            : file_name);
+  if (extension == ".obj") {
+    // Wavefront OBJ file format.
+    ObjDecoder obj_decoder;
+    const Status obj_status = obj_decoder.DecodeFromFile(file_name, pc.get());
+    if (!obj_status.ok()) {
+      return obj_status;
+    }
+    return std::move(pc);
+  }
+  if (extension == ".ply") {
+    // Wavefront PLY file format.
+    PlyDecoder ply_decoder;
+    DRACO_RETURN_IF_ERROR(ply_decoder.DecodeFromFile(file_name, pc.get()));
+    return std::move(pc);
+  }
+
+  std::vector<char> buffer;
+  if (!ReadFileToBuffer(file_name, &buffer)) {
+    return Status(Status::DRACO_ERROR, "Unable to read input file.");
+  }
+  DecoderBuffer decoder_buffer;
+  decoder_buffer.Init(buffer.data(), buffer.size());
+  Decoder decoder;
+  auto status_or = decoder.DecodePointCloudFromBuffer(&decoder_buffer);
+  return std::move(status_or).value();
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/point_cloud_io.h b/contrib/draco/src/draco/io/point_cloud_io.h
new file mode 100644
index 000000000..4e1eb3596
--- /dev/null
+++ b/contrib/draco/src/draco/io/point_cloud_io.h
@@ -0,0 +1,89 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_IO_POINT_CLOUD_IO_H_
+#define DRACO_IO_POINT_CLOUD_IO_H_
+
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/compression/expert_encode.h"
+
+namespace draco {
+
+template <typename OutStreamT>
+OutStreamT WritePointCloudIntoStream(const PointCloud *pc, OutStreamT &&os,
+                                     PointCloudEncodingMethod method,
+                                     const EncoderOptions &options) {
+  EncoderBuffer buffer;
+  EncoderOptions local_options = options;
+  ExpertEncoder encoder(*pc);
+  encoder.Reset(local_options);
+  encoder.SetEncodingMethod(method);
+  if (!encoder.EncodeToBuffer(&buffer).ok()) {
+    os.setstate(std::ios_base::badbit);
+    return os;
+  }
+
+  os.write(static_cast<const char *>(buffer.data()), buffer.size());
+
+  return os;
+}
+
+template <typename OutStreamT>
+OutStreamT WritePointCloudIntoStream(const PointCloud *pc, OutStreamT &&os,
+                                     PointCloudEncodingMethod method) {
+  const EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+  return WritePointCloudIntoStream(pc, os, method, options);
+}
+
+template <typename OutStreamT>
+OutStreamT &WritePointCloudIntoStream(const PointCloud *pc, OutStreamT &&os) {
+  return WritePointCloudIntoStream(pc, os, POINT_CLOUD_SEQUENTIAL_ENCODING);
+}
+
+template <typename InStreamT>
+InStreamT &ReadPointCloudFromStream(std::unique_ptr<PointCloud> *point_cloud,
+                                    InStreamT &&is) {
+  // Determine size of stream and write into a vector
+  const auto start_pos = is.tellg();
+  is.seekg(0, std::ios::end);
+  const std::streampos is_size = is.tellg() - start_pos;
+  is.seekg(start_pos);
+  std::vector<char> data(is_size);
+  is.read(&data[0], is_size);
+
+  // Create a point cloud from that data.
+  DecoderBuffer buffer;
+  buffer.Init(&data[0], data.size());
+  Decoder decoder;
+  auto statusor = decoder.DecodePointCloudFromBuffer(&buffer);
+  *point_cloud = std::move(statusor).value();
+  if (!statusor.ok() || *point_cloud == nullptr) {
+    is.setstate(std::ios_base::badbit);
+  }
+
+  return is;
+}
+
+// Reads a point cloud from a file. The function automatically chooses the
+// correct decoder based on the extension of the files. Currently, .obj and .ply
+// files are supported. Other file extensions are processed by the default
+// draco::PointCloudDecoder.
+// Returns nullptr with an error status if the decoding failed.
+StatusOr<std::unique_ptr<PointCloud>> ReadPointCloudFromFile(
+    const std::string &file_name);
+
+}  // namespace draco
+
+#endif  // DRACO_IO_POINT_CLOUD_IO_H_
diff --git a/contrib/draco/src/draco/io/point_cloud_io_test.cc b/contrib/draco/src/draco/io/point_cloud_io_test.cc
new file mode 100644
index 000000000..73674d06f
--- /dev/null
+++ b/contrib/draco/src/draco/io/point_cloud_io_test.cc
@@ -0,0 +1,115 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/io/point_cloud_io.h"
+
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/obj_decoder.h"
+
+namespace draco {
+
+class IoPointCloudIoTest : public ::testing::Test {
+ protected:
+  void test_compression_method(PointCloudEncodingMethod method,
+                               int expected_num_attributes,
+                               const std::string &file_name) {
+    const std::unique_ptr<PointCloud> encoded_pc =
+        ReadPointCloudFromTestFile(file_name);
+    ASSERT_NE(encoded_pc, nullptr) << "Failed to load test model " << file_name;
+    ASSERT_GE(encoded_pc->num_attributes(), expected_num_attributes)
+        << "Failed to load test model: " << file_name
+        << " wrong number of attributes" << std::endl;
+
+    // Set quantization.
+    EncoderOptions options = EncoderOptions::CreateDefaultOptions();
+    for (int i = 0; i <= GeometryAttribute::NAMED_ATTRIBUTES_COUNT; i++) {
+      options.SetAttributeInt(GeometryAttribute::Type(i), "quantization_bits",
+                              14);
+    }
+
+    std::stringstream ss;
+    WritePointCloudIntoStream(encoded_pc.get(), ss, method, options);
+    ASSERT_TRUE(ss.good());
+
+    std::unique_ptr<PointCloud> decoded_pc;
+    ReadPointCloudFromStream(&decoded_pc, ss);
+    ASSERT_TRUE(ss.good());
+
+    for (int i = 0; i <= GeometryAttribute::NAMED_ATTRIBUTES_COUNT; i++) {
+      ASSERT_EQ(encoded_pc->NumNamedAttributes(GeometryAttribute::Type(i)),
+                decoded_pc->NumNamedAttributes(GeometryAttribute::Type(i)));
+    }
+
+    ASSERT_EQ(encoded_pc->num_points(), decoded_pc->num_points());
+  }
+};
+
+TEST_F(IoPointCloudIoTest, EncodeSequentialPointCloudTestNmObj) {
+  test_compression_method(POINT_CLOUD_SEQUENTIAL_ENCODING, 2, "test_nm.obj");
+}
+TEST_F(IoPointCloudIoTest, EncodeSequentialPointCloudTestPosObj) {
+  test_compression_method(POINT_CLOUD_SEQUENTIAL_ENCODING, 1,
+                          "point_cloud_test_pos.obj");
+}
+TEST_F(IoPointCloudIoTest, EncodeSequentialPointCloudTestPosPly) {
+  test_compression_method(POINT_CLOUD_SEQUENTIAL_ENCODING, 1,
+                          "point_cloud_test_pos.ply");
+}
+TEST_F(IoPointCloudIoTest, EncodeSequentialPointCloudTestPosNormObj) {
+  test_compression_method(POINT_CLOUD_SEQUENTIAL_ENCODING, 2,
+                          "point_cloud_test_pos_norm.obj");
+}
+TEST_F(IoPointCloudIoTest, EncodeSequentialPointCloudTestPosNormPly) {
+  test_compression_method(POINT_CLOUD_SEQUENTIAL_ENCODING, 2,
+                          "point_cloud_test_pos_norm.ply");
+}
+
+TEST_F(IoPointCloudIoTest, EncodeKdTreePointCloudTestPosObj) {
+  test_compression_method(POINT_CLOUD_KD_TREE_ENCODING, 1,
+                          "point_cloud_test_pos.obj");
+}
+TEST_F(IoPointCloudIoTest, EncodeKdTreePointCloudTestPosPly) {
+  test_compression_method(POINT_CLOUD_KD_TREE_ENCODING, 1,
+                          "point_cloud_test_pos.ply");
+}
+
+TEST_F(IoPointCloudIoTest, ObjFileInput) {
+  // Tests whether loading obj point clouds from files works as expected.
+  const std::unique_ptr<PointCloud> pc =
+      ReadPointCloudFromTestFile("test_nm.obj");
+  ASSERT_NE(pc, nullptr) << "Failed to load the obj point cloud.";
+  EXPECT_EQ(pc->num_points(), 97) << "Obj point cloud not loaded properly.";
+}
+
+// Test if we handle wrong input for all file extensions.
+TEST_F(IoPointCloudIoTest, WrongFileObj) {
+  const std::unique_ptr<PointCloud> pc =
+      ReadPointCloudFromTestFile("wrong_file_name.obj");
+  ASSERT_EQ(pc, nullptr);
+}
+TEST_F(IoPointCloudIoTest, WrongFilePly) {
+  const std::unique_ptr<PointCloud> pc =
+      ReadPointCloudFromTestFile("wrong_file_name.ply");
+  ASSERT_EQ(pc, nullptr);
+}
+TEST_F(IoPointCloudIoTest, WrongFile) {
+  const std::unique_ptr<PointCloud> pc =
+      ReadPointCloudFromTestFile("wrong_file_name");
+  ASSERT_EQ(pc, nullptr);
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/stdio_file_reader.cc b/contrib/draco/src/draco/io/stdio_file_reader.cc
new file mode 100644
index 000000000..560c3e9e8
--- /dev/null
+++ b/contrib/draco/src/draco/io/stdio_file_reader.cc
@@ -0,0 +1,96 @@
+#include "draco/io/stdio_file_reader.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <string>
+#include <vector>
+
+#if defined(_WIN32)
+#include <fcntl.h>
+#include <io.h>
+#endif
+
+#include "draco/io/file_reader_factory.h"
+
+namespace draco {
+
+#define FILEREADER_LOG_ERROR(error_string)                             \
+  do {                                                                 \
+    fprintf(stderr, "%s:%d (%s): %s.\n", __FILE__, __LINE__, __func__, \
+            error_string);                                             \
+  } while (false)
+
+bool StdioFileReader::registered_in_factory_ =
+    FileReaderFactory::RegisterReader(StdioFileReader::Open);
+
+StdioFileReader::~StdioFileReader() { fclose(file_); }
+
+std::unique_ptr<FileReaderInterface> StdioFileReader::Open(
+    const std::string &file_name) {
+  if (file_name.empty()) {
+    return nullptr;
+  }
+
+  FILE *raw_file_ptr = fopen(file_name.c_str(), "rb");
+
+  if (raw_file_ptr == nullptr) {
+    return nullptr;
+  }
+
+  std::unique_ptr<FileReaderInterface> file(new (std::nothrow)
+                                                StdioFileReader(raw_file_ptr));
+  if (file == nullptr) {
+    FILEREADER_LOG_ERROR("Out of memory");
+    fclose(raw_file_ptr);
+    return nullptr;
+  }
+
+  return file;
+}
+
+bool StdioFileReader::ReadFileToBuffer(std::vector<char> *buffer) {
+  if (buffer == nullptr) {
+    return false;
+  }
+  buffer->clear();
+
+  const size_t file_size = GetFileSize();
+  if (file_size == 0) {
+    FILEREADER_LOG_ERROR("Unable to obtain file size or file empty");
+    return false;
+  }
+
+  buffer->resize(file_size);
+  return fread(buffer->data(), 1, file_size, file_) == file_size;
+}
+
+bool StdioFileReader::ReadFileToBuffer(std::vector<uint8_t> *buffer) {
+  if (buffer == nullptr) {
+    return false;
+  }
+  buffer->clear();
+
+  const size_t file_size = GetFileSize();
+  if (file_size == 0) {
+    FILEREADER_LOG_ERROR("Unable to obtain file size or file empty");
+    return false;
+  }
+
+  buffer->resize(file_size);
+  return fread(buffer->data(), 1, file_size, file_) == file_size;
+}
+
+size_t StdioFileReader::GetFileSize() {
+  if (fseek(file_, SEEK_SET, SEEK_END) != 0) {
+    FILEREADER_LOG_ERROR("Seek to EoF failed");
+    return false;
+  }
+
+  const size_t file_size = static_cast<size_t>(ftell(file_));
+  rewind(file_);
+
+  return file_size;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/stdio_file_reader.h b/contrib/draco/src/draco/io/stdio_file_reader.h
new file mode 100644
index 000000000..f822c891c
--- /dev/null
+++ b/contrib/draco/src/draco/io/stdio_file_reader.h
@@ -0,0 +1,48 @@
+#ifndef DRACO_IO_STDIO_FILE_READER_H_
+#define DRACO_IO_STDIO_FILE_READER_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "draco/io/file_reader_interface.h"
+
+namespace draco {
+
+class StdioFileReader : public FileReaderInterface {
+ public:
+  // Creates and returns a StdioFileReader that reads from |file_name|.
+  // Returns nullptr when the file does not exist or cannot be read.
+  static std::unique_ptr<FileReaderInterface> Open(
+      const std::string &file_name);
+
+  StdioFileReader() = delete;
+  StdioFileReader(const StdioFileReader &) = delete;
+  StdioFileReader &operator=(const StdioFileReader &) = delete;
+
+  StdioFileReader(StdioFileReader &&) = default;
+  StdioFileReader &operator=(StdioFileReader &&) = default;
+
+  // Closes |file_|.
+  ~StdioFileReader() override;
+
+  // Reads the entire contents of the input file into |buffer| and returns true.
+  bool ReadFileToBuffer(std::vector<char> *buffer) override;
+  bool ReadFileToBuffer(std::vector<uint8_t> *buffer) override;
+
+  // Returns the size of the file.
+  size_t GetFileSize() override;
+
+ private:
+  StdioFileReader(FILE *file) : file_(file) {}
+
+  FILE *file_ = nullptr;
+  static bool registered_in_factory_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_STDIO_FILE_READER_H_
diff --git a/contrib/draco/src/draco/io/stdio_file_reader_test.cc b/contrib/draco/src/draco/io/stdio_file_reader_test.cc
new file mode 100644
index 000000000..487819a02
--- /dev/null
+++ b/contrib/draco/src/draco/io/stdio_file_reader_test.cc
@@ -0,0 +1,49 @@
+#include "draco/io/stdio_file_reader.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/file_reader_test_common.h"
+
+namespace draco {
+namespace {
+
+TEST(StdioFileReaderTest, FailOpen) {
+  EXPECT_EQ(StdioFileReader::Open(""), nullptr);
+  EXPECT_EQ(StdioFileReader::Open("fake file"), nullptr);
+}
+
+TEST(StdioFileReaderTest, Open) {
+  EXPECT_NE(StdioFileReader::Open(GetTestFileFullPath("car.drc")), nullptr);
+  EXPECT_NE(StdioFileReader::Open(GetTestFileFullPath("cube_pc.drc")), nullptr);
+}
+
+TEST(StdioFileReaderTest, FailRead) {
+  auto reader = StdioFileReader::Open(GetTestFileFullPath("car.drc"));
+  ASSERT_NE(reader, nullptr);
+  std::vector<char> *buffer = nullptr;
+  EXPECT_FALSE(reader->ReadFileToBuffer(buffer));
+}
+
+TEST(StdioFileReaderTest, ReadFile) {
+  std::vector<char> buffer;
+
+  auto reader = StdioFileReader::Open(GetTestFileFullPath("car.drc"));
+  ASSERT_NE(reader, nullptr);
+  EXPECT_TRUE(reader->ReadFileToBuffer(&buffer));
+  EXPECT_EQ(buffer.size(), kFileSizeCarDrc);
+
+  reader = StdioFileReader::Open(GetTestFileFullPath("cube_pc.drc"));
+  ASSERT_NE(reader, nullptr);
+  EXPECT_TRUE(reader->ReadFileToBuffer(&buffer));
+  EXPECT_EQ(buffer.size(), kFileSizeCubePcDrc);
+}
+
+TEST(StdioFileReaderTest, GetFileSize) {
+  auto reader = StdioFileReader::Open(GetTestFileFullPath("car.drc"));
+  ASSERT_EQ(reader->GetFileSize(), kFileSizeCarDrc);
+  reader = StdioFileReader::Open(GetTestFileFullPath("cube_pc.drc"));
+  ASSERT_EQ(reader->GetFileSize(), kFileSizeCubePcDrc);
+}
+
+}  // namespace
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/stdio_file_writer.cc b/contrib/draco/src/draco/io/stdio_file_writer.cc
new file mode 100644
index 000000000..2467d070b
--- /dev/null
+++ b/contrib/draco/src/draco/io/stdio_file_writer.cc
@@ -0,0 +1,59 @@
+#include "draco/io/stdio_file_writer.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <cstdio>
+#include <memory>
+#include <string>
+
+#include "draco/draco_features.h"
+#include "draco/io/file_writer_factory.h"
+#include "draco/io/file_writer_utils.h"
+
+namespace draco {
+
+#define FILEWRITER_LOG_ERROR(error_string)                             \
+  do {                                                                 \
+    fprintf(stderr, "%s:%d (%s): %s.\n", __FILE__, __LINE__, __func__, \
+            error_string);                                             \
+  } while (false)
+
+bool StdioFileWriter::registered_in_factory_ =
+    FileWriterFactory::RegisterWriter(StdioFileWriter::Open);
+
+StdioFileWriter::~StdioFileWriter() { fclose(file_); }
+
+std::unique_ptr<FileWriterInterface> StdioFileWriter::Open(
+    const std::string &file_name) {
+  if (file_name.empty()) {
+    return nullptr;
+  }
+  if (!CheckAndCreatePathForFile(file_name)) {
+    return nullptr;
+  }
+
+  FILE *raw_file_ptr = fopen(file_name.c_str(), "wb");
+  if (raw_file_ptr == nullptr) {
+    return nullptr;
+  }
+
+  std::unique_ptr<StdioFileWriter> file(new (std::nothrow)
+                                            StdioFileWriter(raw_file_ptr));
+  if (file == nullptr) {
+    FILEWRITER_LOG_ERROR("Out of memory");
+    fclose(raw_file_ptr);
+    return nullptr;
+  }
+
+#ifndef DRACO_OLD_GCC
+  return file;
+#else
+  return std::move(file);
+#endif
+}
+
+bool StdioFileWriter::Write(const char *buffer, size_t size) {
+  return fwrite(buffer, 1, size, file_) == size;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/io/stdio_file_writer.h b/contrib/draco/src/draco/io/stdio_file_writer.h
new file mode 100644
index 000000000..4e3925562
--- /dev/null
+++ b/contrib/draco/src/draco/io/stdio_file_writer.h
@@ -0,0 +1,42 @@
+#ifndef DRACO_IO_STDIO_FILE_WRITER_H_
+#define DRACO_IO_STDIO_FILE_WRITER_H_
+
+#include <cstddef>
+#include <cstdio>
+#include <memory>
+#include <string>
+
+#include "draco/io/file_writer_interface.h"
+
+namespace draco {
+
+class StdioFileWriter : public FileWriterInterface {
+ public:
+  // Creates and returns a StdioFileWriter that writes to |file_name|.
+  // Returns nullptr when |file_name| cannot be opened for writing.
+  static std::unique_ptr<FileWriterInterface> Open(
+      const std::string &file_name);
+
+  StdioFileWriter() = delete;
+  StdioFileWriter(const StdioFileWriter &) = delete;
+  StdioFileWriter &operator=(const StdioFileWriter &) = delete;
+
+  StdioFileWriter(StdioFileWriter &&) = default;
+  StdioFileWriter &operator=(StdioFileWriter &&) = default;
+
+  // Closes |file_|.
+  ~StdioFileWriter() override;
+
+  // Writes |size| bytes to |file_| from |buffer|. Returns true for success.
+  bool Write(const char *buffer, size_t size) override;
+
+ private:
+  StdioFileWriter(FILE *file) : file_(file) {}
+
+  FILE *file_ = nullptr;
+  static bool registered_in_factory_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_IO_STDIO_FILE_WRITER_H_
diff --git a/contrib/draco/src/draco/io/stdio_file_writer_test.cc b/contrib/draco/src/draco/io/stdio_file_writer_test.cc
new file mode 100644
index 000000000..ed607d1d0
--- /dev/null
+++ b/contrib/draco/src/draco/io/stdio_file_writer_test.cc
@@ -0,0 +1,38 @@
+#include "draco/io/stdio_file_writer.h"
+
+#include <cstdio>
+#include <cstring>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+
+namespace draco {
+namespace {
+
+void CheckFileWriter(const std::string &data, const std::string &filename) {
+  auto writer = StdioFileWriter::Open(filename);
+  ASSERT_NE(writer, nullptr);
+  ASSERT_TRUE(writer->Write(data.data(), data.size()));
+  writer.reset();
+  std::unique_ptr<FILE, decltype(&fclose)> file(fopen(filename.c_str(), "r"),
+                                                fclose);
+  ASSERT_NE(file, nullptr);
+  std::string read_buffer(data.size(), ' ');
+  ASSERT_EQ(fread(reinterpret_cast<void *>(&read_buffer[0]), 1, data.size(),
+                  file.get()),
+            data.size());
+  ASSERT_EQ(read_buffer, data);
+}
+
+TEST(StdioFileWriterTest, FailOpen) {
+  EXPECT_EQ(StdioFileWriter::Open(""), nullptr);
+}
+
+TEST(StdioFileWriterTest, BasicWrite) {
+  const std::string kWriteString = "Hello";
+  const std::string kTempFilePath = GetTestTempFileFullPath("hello");
+  CheckFileWriter(kWriteString, kTempFilePath);
+}
+
+}  // namespace
+}  // namespace draco
diff --git a/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.cc b/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.cc
new file mode 100644
index 000000000..7e9e6d15d
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.cc
@@ -0,0 +1,101 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/javascript/emscripten/animation_decoder_webidl_wrapper.h"
+
+#include <vector>
+
+#include "draco/compression/decode.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/mesh_stripifier.h"
+
+using draco::DecoderBuffer;
+using draco::PointAttribute;
+using draco::Status;
+
+DracoFloat32Array::DracoFloat32Array() {}
+
+float DracoFloat32Array::GetValue(int index) const { return values_[index]; }
+
+bool DracoFloat32Array::SetValues(const float *values, int count) {
+  if (values) {
+    values_.assign(values, values + count);
+  } else {
+    values_.resize(count);
+  }
+  return true;
+}
+
+AnimationDecoder::AnimationDecoder() {}
+
+// Decodes animation data from the provided buffer.
+const draco::Status *AnimationDecoder::DecodeBufferToKeyframeAnimation(
+    draco::DecoderBuffer *in_buffer, draco::KeyframeAnimation *animation) {
+  draco::DecoderOptions dec_options;
+  last_status_ = decoder_.Decode(dec_options, in_buffer, animation);
+  return &last_status_;
+}
+
+bool AnimationDecoder::GetTimestamps(const draco::KeyframeAnimation &animation,
+                                     DracoFloat32Array *timestamp) {
+  if (!timestamp) {
+    return false;
+  }
+  const int num_frames = animation.num_frames();
+  const draco::PointAttribute *timestamp_att = animation.timestamps();
+  // Timestamp attribute has only 1 component, so the number of components is
+  // equal to the number of frames.
+  timestamp->SetValues(nullptr, num_frames);
+  int entry_id = 0;
+  float timestamp_value = -1.0;
+  for (draco::PointIndex i(0); i < num_frames; ++i) {
+    const draco::AttributeValueIndex val_index = timestamp_att->mapped_index(i);
+    if (!timestamp_att->ConvertValue<float>(val_index, &timestamp_value)) {
+      return false;
+    }
+    timestamp->SetValue(entry_id++, timestamp_value);
+  }
+  return true;
+}
+
+bool AnimationDecoder::GetKeyframes(const draco::KeyframeAnimation &animation,
+                                    int keyframes_id,
+                                    DracoFloat32Array *animation_data) {
+  const int num_frames = animation.num_frames();
+  // Get animation data.
+  const draco::PointAttribute *animation_data_att =
+      animation.keyframes(keyframes_id);
+  if (!animation_data_att) {
+    return false;
+  }
+
+  const int components = animation_data_att->num_components();
+  const int num_entries = num_frames * components;
+  const int kMaxAttributeFloatValues = 4;
+
+  std::vector<float> values(components, -1.0);
+  int entry_id = 0;
+  animation_data->SetValues(nullptr, num_entries);
+  for (draco::PointIndex i(0); i < num_frames; ++i) {
+    const draco::AttributeValueIndex val_index =
+        animation_data_att->mapped_index(i);
+    if (!animation_data_att->ConvertValue<float>(val_index, &values[0])) {
+      return false;
+    }
+    for (int j = 0; j < components; ++j) {
+      animation_data->SetValue(entry_id++, values[j]);
+    }
+  }
+  return true;
+}
diff --git a/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.h b/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.h
new file mode 100644
index 000000000..7486d1503
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/animation_decoder_webidl_wrapper.h
@@ -0,0 +1,73 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_JAVASCRIPT_EMSCRIPTEN_ANIMATION_DECODER_WEBIDL_WRAPPER_H_
+#define DRACO_JAVASCRIPT_EMSCRIPTEN_ANIMATION_DECODER_WEBIDL_WRAPPER_H_
+
+#include <vector>
+
+#include "draco/animation/keyframe_animation_decoder.h"
+#include "draco/attributes/attribute_transform_type.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/core/decoder_buffer.h"
+
+typedef draco::AttributeTransformType draco_AttributeTransformType;
+typedef draco::GeometryAttribute draco_GeometryAttribute;
+typedef draco_GeometryAttribute::Type draco_GeometryAttribute_Type;
+typedef draco::EncodedGeometryType draco_EncodedGeometryType;
+typedef draco::Status draco_Status;
+typedef draco::Status::Code draco_StatusCode;
+
+class DracoFloat32Array {
+ public:
+  DracoFloat32Array();
+  float GetValue(int index) const;
+
+  // In case |values| is nullptr, the data is allocated but not initialized.
+  bool SetValues(const float *values, int count);
+
+  // Directly sets a value for a specific index. The array has to be already
+  // allocated at this point (using SetValues() method).
+  void SetValue(int index, float val) { values_[index] = val; }
+
+  int size() const { return values_.size(); }
+
+ private:
+  std::vector<float> values_;
+};
+
+// Class used by emscripten WebIDL Binder [1] to wrap calls to decode animation
+// data.
+class AnimationDecoder {
+ public:
+  AnimationDecoder();
+
+  // Decodes animation data from the provided buffer.
+  const draco::Status *DecodeBufferToKeyframeAnimation(
+      draco::DecoderBuffer *in_buffer, draco::KeyframeAnimation *animation);
+
+  static bool GetTimestamps(const draco::KeyframeAnimation &animation,
+                            DracoFloat32Array *timestamp);
+
+  static bool GetKeyframes(const draco::KeyframeAnimation &animation,
+                           int keyframes_id, DracoFloat32Array *animation_data);
+
+ private:
+  draco::KeyframeAnimationDecoder decoder_;
+  draco::Status last_status_;
+};
+
+#endif  // DRACO_JAVASCRIPT_EMSCRIPTEN_ANIMATION_DECODER_WEBIDL_WRAPPER_H_
diff --git a/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.cc b/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.cc
new file mode 100644
index 000000000..53a10e5e4
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.cc
@@ -0,0 +1,89 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/javascript/emscripten/animation_encoder_webidl_wrapper.h"
+
+#include "draco/animation/keyframe_animation.h"
+#include "draco/animation/keyframe_animation_encoder.h"
+
+DracoInt8Array::DracoInt8Array() {}
+
+int DracoInt8Array::GetValue(int index) const { return values_[index]; }
+
+bool DracoInt8Array::SetValues(const char *values, int count) {
+  values_.assign(values, values + count);
+  return true;
+}
+
+AnimationBuilder::AnimationBuilder() {}
+
+bool AnimationBuilder::SetTimestamps(draco::KeyframeAnimation *animation,
+                                     long num_frames, const float *timestamps) {
+  if (!animation || !timestamps) {
+    return false;
+  }
+  std::vector<draco::KeyframeAnimation::TimestampType> timestamps_arr(
+      timestamps, timestamps + num_frames);
+  return animation->SetTimestamps(timestamps_arr);
+}
+
+int AnimationBuilder::AddKeyframes(draco::KeyframeAnimation *animation,
+                                   long num_frames, long num_components,
+                                   const float *animation_data) {
+  if (!animation || !animation_data) {
+    return -1;
+  }
+  std::vector<float> keyframes_arr(
+      animation_data, animation_data + num_frames * num_components);
+  return animation->AddKeyframes(draco::DT_FLOAT32, num_components,
+                                 keyframes_arr);
+}
+
+AnimationEncoder::AnimationEncoder()
+    : timestamps_quantization_bits_(-1),
+      keyframes_quantization_bits_(-1),
+      options_(draco::EncoderOptions::CreateDefaultOptions()) {}
+
+void AnimationEncoder::SetTimestampsQuantization(long quantization_bits) {
+  timestamps_quantization_bits_ = quantization_bits;
+}
+
+void AnimationEncoder::SetKeyframesQuantization(long quantization_bits) {
+  keyframes_quantization_bits_ = quantization_bits;
+}
+
+int AnimationEncoder::EncodeAnimationToDracoBuffer(
+    draco::KeyframeAnimation *animation, DracoInt8Array *draco_buffer) {
+  if (!animation) {
+    return 0;
+  }
+  draco::EncoderBuffer buffer;
+
+  if (timestamps_quantization_bits_ > 0) {
+    options_.SetAttributeInt(0, "quantization_bits",
+                             timestamps_quantization_bits_);
+  }
+  if (keyframes_quantization_bits_ > 0) {
+    for (int i = 1; i <= animation->num_animations(); ++i) {
+      options_.SetAttributeInt(i, "quantization_bits",
+                               keyframes_quantization_bits_);
+    }
+  }
+  if (!encoder_.EncodeKeyframeAnimation(*animation, options_, &buffer).ok()) {
+    return 0;
+  }
+
+  draco_buffer->SetValues(buffer.data(), buffer.size());
+  return buffer.size();
+}
diff --git a/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.h b/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.h
new file mode 100644
index 000000000..f2ac733d1
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/animation_encoder_webidl_wrapper.h
@@ -0,0 +1,66 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_JAVASCRIPT_EMSCRIPTEN_ANIMATION_ENCODER_WEBIDL_WRAPPER_H_
+#define DRACO_JAVASCRIPT_EMSCRIPTEN_ANIMATION_ENCODER_WEBIDL_WRAPPER_H_
+
+#include <vector>
+
+#include "draco/animation/keyframe_animation_encoder.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/compression/encode.h"
+
+class DracoInt8Array {
+ public:
+  DracoInt8Array();
+  int GetValue(int index) const;
+  bool SetValues(const char *values, int count);
+
+  size_t size() { return values_.size(); }
+
+ private:
+  std::vector<int> values_;
+};
+
+class AnimationBuilder {
+ public:
+  AnimationBuilder();
+
+  bool SetTimestamps(draco::KeyframeAnimation *animation, long num_frames,
+                     const float *timestamps);
+
+  int AddKeyframes(draco::KeyframeAnimation *animation, long num_frames,
+                   long num_components, const float *animation_data);
+};
+
+class AnimationEncoder {
+ public:
+  AnimationEncoder();
+
+  void SetTimestampsQuantization(long quantization_bits);
+  // TODO: Use expert encoder to set per attribute quantization.
+  void SetKeyframesQuantization(long quantization_bits);
+  int EncodeAnimationToDracoBuffer(draco::KeyframeAnimation *animation,
+                                   DracoInt8Array *draco_buffer);
+
+ private:
+  draco::KeyframeAnimationEncoder encoder_;
+  long timestamps_quantization_bits_;
+  long keyframes_quantization_bits_;
+  draco::EncoderOptions options_;
+};
+
+#endif  // DRACO_JAVASCRIPT_EMSCRIPTEN_ANIMATION_ENCODER_WEBIDL_WRAPPER_H_
diff --git a/contrib/draco/src/draco/javascript/emscripten/decoder_functions.js b/contrib/draco/src/draco/javascript/emscripten/decoder_functions.js
new file mode 100644
index 000000000..577900ff9
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/decoder_functions.js
@@ -0,0 +1,33 @@
+// Copyright 2020 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Returns encoded geometry type stored in the |array|. In general, |array|
+// should be a javascript Int8Array containing the encoded data. For backward
+// compatibility, |array| can also represent a Module.DecoderBuffer object.
+Module['Decoder'].prototype.GetEncodedGeometryType = function(array) {
+  if (array.__class__ && array.__class__ === Module.DecoderBuffer) {
+    // |array| is a DecoderBuffer. Pass it to the deprecated function.
+    return Module.Decoder.prototype.GetEncodedGeometryType_Deprecated(array);
+  }
+  if (array.byteLength < 8)
+    return Module.INVALID_GEOMETRY_TYPE;
+  switch (array[7]) {
+    case 0:
+      return Module.POINT_CLOUD;
+    case 1:
+      return Module.TRIANGULAR_MESH;
+    default:
+      return Module.INVALID_GEOMETRY_TYPE;
+  }
+};
diff --git a/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.cc b/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.cc
new file mode 100644
index 000000000..66fe77dbd
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.cc
@@ -0,0 +1,363 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/javascript/emscripten/decoder_webidl_wrapper.h"
+
+#include "draco/compression/decode.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/mesh_stripifier.h"
+
+using draco::DecoderBuffer;
+using draco::Mesh;
+using draco::Metadata;
+using draco::PointAttribute;
+using draco::PointCloud;
+using draco::Status;
+
+MetadataQuerier::MetadataQuerier() : entry_names_metadata_(nullptr) {}
+
+bool MetadataQuerier::HasEntry(const Metadata &metadata,
+                               const char *entry_name) const {
+  return metadata.entries().count(entry_name) > 0;
+}
+
+long MetadataQuerier::GetIntEntry(const Metadata &metadata,
+                                  const char *entry_name) const {
+  int32_t value = 0;
+  const std::string name(entry_name);
+  metadata.GetEntryInt(name, &value);
+  return value;
+}
+
+void MetadataQuerier::GetIntEntryArray(const draco::Metadata &metadata,
+                                       const char *entry_name,
+                                       DracoInt32Array *out_values) const {
+  const std::string name(entry_name);
+  std::vector<int32_t> values;
+  metadata.GetEntryIntArray(name, &values);
+  out_values->MoveData(std::move(values));
+}
+
+double MetadataQuerier::GetDoubleEntry(const Metadata &metadata,
+                                       const char *entry_name) const {
+  double value = 0;
+  const std::string name(entry_name);
+  metadata.GetEntryDouble(name, &value);
+  return value;
+}
+
+const char *MetadataQuerier::GetStringEntry(const Metadata &metadata,
+                                            const char *entry_name) {
+  const std::string name(entry_name);
+  if (!metadata.GetEntryString(name, &last_string_returned_)) {
+    return nullptr;
+  }
+
+  const char *value = last_string_returned_.c_str();
+  return value;
+}
+
+long MetadataQuerier::NumEntries(const Metadata &metadata) const {
+  return metadata.num_entries();
+}
+
+const char *MetadataQuerier::GetEntryName(const Metadata &metadata,
+                                          int entry_id) {
+  if (entry_names_metadata_ != &metadata) {
+    entry_names_.clear();
+    entry_names_metadata_ = &metadata;
+    // Initialize the list of entry names.
+    for (auto &&entry : metadata.entries()) {
+      entry_names_.push_back(entry.first);
+    }
+  }
+  if (entry_id < 0 || entry_id >= entry_names_.size()) {
+    return nullptr;
+  }
+  return entry_names_[entry_id].c_str();
+}
+
+Decoder::Decoder() {}
+
+draco_EncodedGeometryType Decoder::GetEncodedGeometryType_Deprecated(
+    DecoderBuffer *in_buffer) {
+  return draco::Decoder::GetEncodedGeometryType(in_buffer).value();
+}
+
+const Status *Decoder::DecodeBufferToPointCloud(DecoderBuffer *in_buffer,
+                                                PointCloud *out_point_cloud) {
+  last_status_ = decoder_.DecodeBufferToGeometry(in_buffer, out_point_cloud);
+  return &last_status_;
+}
+
+const draco::Status *Decoder::DecodeArrayToPointCloud(
+    const char *data, size_t data_size, PointCloud *out_point_cloud) {
+  DecoderBuffer buffer;
+  buffer.Init(data, data_size);
+  return DecodeBufferToPointCloud(&buffer, out_point_cloud);
+}
+
+const Status *Decoder::DecodeBufferToMesh(DecoderBuffer *in_buffer,
+                                          Mesh *out_mesh) {
+  last_status_ = decoder_.DecodeBufferToGeometry(in_buffer, out_mesh);
+  return &last_status_;
+}
+
+const draco::Status *Decoder::DecodeArrayToMesh(const char *data,
+                                                size_t data_size,
+                                                Mesh *out_mesh) {
+  DecoderBuffer buffer;
+  buffer.Init(data, data_size);
+  return DecodeBufferToMesh(&buffer, out_mesh);
+}
+
+long Decoder::GetAttributeId(const PointCloud &pc,
+                             draco_GeometryAttribute_Type type) const {
+  return pc.GetNamedAttributeId(type);
+}
+
+const PointAttribute *Decoder::GetAttribute(const PointCloud &pc, long att_id) {
+  return pc.attribute(att_id);
+}
+
+const PointAttribute *Decoder::GetAttributeByUniqueId(const PointCloud &pc,
+                                                      long unique_id) {
+  return pc.GetAttributeByUniqueId(unique_id);
+}
+
+long Decoder::GetAttributeIdByName(const PointCloud &pc,
+                                   const char *attribute_name) {
+  const std::string entry_value(attribute_name);
+  return pc.GetAttributeIdByMetadataEntry("name", entry_value);
+}
+
+long Decoder::GetAttributeIdByMetadataEntry(const PointCloud &pc,
+                                            const char *metadata_name,
+                                            const char *metadata_value) {
+  const std::string entry_name(metadata_name);
+  const std::string entry_value(metadata_value);
+  return pc.GetAttributeIdByMetadataEntry(entry_name, entry_value);
+}
+
+bool Decoder::GetFaceFromMesh(const Mesh &m,
+                              draco::FaceIndex::ValueType face_id,
+                              DracoInt32Array *out_values) {
+  const Mesh::Face &face = m.face(draco::FaceIndex(face_id));
+  const auto ptr = reinterpret_cast<const int32_t *>(face.data());
+  out_values->MoveData(std::vector<int32_t>({ptr, ptr + face.size()}));
+  return true;
+}
+
+long Decoder::GetTriangleStripsFromMesh(const Mesh &m,
+                                        DracoInt32Array *strip_values) {
+  draco::MeshStripifier stripifier;
+  std::vector<int32_t> strip_indices;
+  if (!stripifier.GenerateTriangleStripsWithDegenerateTriangles(
+          m, std::back_inserter(strip_indices))) {
+    return 0;
+  }
+  strip_values->MoveData(std::move(strip_indices));
+  return stripifier.num_strips();
+}
+
+template <typename T>
+bool GetTrianglesArray(const draco::Mesh &m, const int out_size,
+                       T *out_values) {
+  const uint32_t num_faces = m.num_faces();
+  if (num_faces * 3 * sizeof(T) != out_size) {
+    return false;
+  }
+
+  for (uint32_t face_id = 0; face_id < num_faces; ++face_id) {
+    const Mesh::Face &face = m.face(draco::FaceIndex(face_id));
+    out_values[face_id * 3 + 0] = static_cast<T>(face[0].value());
+    out_values[face_id * 3 + 1] = static_cast<T>(face[1].value());
+    out_values[face_id * 3 + 2] = static_cast<T>(face[2].value());
+  }
+  return true;
+}
+
+bool Decoder::GetTrianglesUInt16Array(const draco::Mesh &m, int out_size,
+                                      void *out_values) {
+  if (m.num_points() > std::numeric_limits<uint16_t>::max()) {
+    return false;
+  }
+  return GetTrianglesArray<uint16_t>(m, out_size,
+                                     reinterpret_cast<uint16_t *>(out_values));
+}
+
+bool Decoder::GetTrianglesUInt32Array(const draco::Mesh &m, int out_size,
+                                      void *out_values) {
+  return GetTrianglesArray<uint32_t>(m, out_size,
+                                     reinterpret_cast<uint32_t *>(out_values));
+}
+
+bool Decoder::GetAttributeFloat(const PointAttribute &pa,
+                                draco::AttributeValueIndex::ValueType val_index,
+                                DracoFloat32Array *out_values) {
+  const int kMaxAttributeFloatValues = 4;
+  const int components = pa.num_components();
+  float values[kMaxAttributeFloatValues] = {-2.0, -2.0, -2.0, -2.0};
+  if (!pa.ConvertValue<float>(draco::AttributeValueIndex(val_index), values))
+    return false;
+  out_values->MoveData({values, values + components});
+  return true;
+}
+
+bool Decoder::GetAttributeFloatForAllPoints(const PointCloud &pc,
+                                            const PointAttribute &pa,
+                                            DracoFloat32Array *out_values) {
+  const int components = pa.num_components();
+  const int num_points = pc.num_points();
+  const int num_entries = num_points * components;
+  const int kMaxAttributeFloatValues = 4;
+  float values[kMaxAttributeFloatValues] = {-2.0, -2.0, -2.0, -2.0};
+  int entry_id = 0;
+
+  out_values->Resize(num_entries);
+  for (draco::PointIndex i(0); i < num_points; ++i) {
+    const draco::AttributeValueIndex val_index = pa.mapped_index(i);
+    if (!pa.ConvertValue<float>(val_index, values)) {
+      return false;
+    }
+    for (int j = 0; j < components; ++j) {
+      out_values->SetValue(entry_id++, values[j]);
+    }
+  }
+  return true;
+}
+
+bool Decoder::GetAttributeFloatArrayForAllPoints(const PointCloud &pc,
+                                                 const PointAttribute &pa,
+                                                 int out_size,
+                                                 void *out_values) {
+  const int components = pa.num_components();
+  const int num_points = pc.num_points();
+  const int data_size = num_points * components * sizeof(float);
+  if (data_size != out_size) {
+    return false;
+  }
+  const bool requested_type_is_float = pa.data_type() == draco::DT_FLOAT32;
+  const int kMaxAttributeFloatValues = 4;
+  float values[kMaxAttributeFloatValues] = {-2.0, -2.0, -2.0, -2.0};
+  int entry_id = 0;
+  float *const floats = reinterpret_cast<float *>(out_values);
+
+  for (draco::PointIndex i(0); i < num_points; ++i) {
+    const draco::AttributeValueIndex val_index = pa.mapped_index(i);
+    if (requested_type_is_float) {
+      pa.GetValue(val_index, values);
+    } else {
+      if (!pa.ConvertValue<float>(val_index, values)) {
+        return false;
+      }
+    }
+    for (int j = 0; j < components; ++j) {
+      floats[entry_id++] = values[j];
+    }
+  }
+  return true;
+}
+
+bool Decoder::GetAttributeInt8ForAllPoints(const PointCloud &pc,
+                                           const PointAttribute &pa,
+                                           DracoInt8Array *out_values) {
+  return GetAttributeDataForAllPoints<DracoInt8Array, int8_t>(
+      pc, pa, draco::DT_INT8, draco::DT_UINT8, out_values);
+}
+
+bool Decoder::GetAttributeUInt8ForAllPoints(const PointCloud &pc,
+                                            const PointAttribute &pa,
+                                            DracoUInt8Array *out_values) {
+  return GetAttributeDataForAllPoints<DracoUInt8Array, uint8_t>(
+      pc, pa, draco::DT_INT8, draco::DT_UINT8, out_values);
+}
+
+bool Decoder::GetAttributeInt16ForAllPoints(const PointCloud &pc,
+                                            const PointAttribute &pa,
+                                            DracoInt16Array *out_values) {
+  return GetAttributeDataForAllPoints<DracoInt16Array, int16_t>(
+      pc, pa, draco::DT_INT16, draco::DT_UINT16, out_values);
+}
+
+bool Decoder::GetAttributeUInt16ForAllPoints(const PointCloud &pc,
+                                             const PointAttribute &pa,
+                                             DracoUInt16Array *out_values) {
+  return GetAttributeDataForAllPoints<DracoUInt16Array, uint16_t>(
+      pc, pa, draco::DT_INT16, draco::DT_UINT16, out_values);
+}
+
+bool Decoder::GetAttributeInt32ForAllPoints(const PointCloud &pc,
+                                            const PointAttribute &pa,
+                                            DracoInt32Array *out_values) {
+  return GetAttributeDataForAllPoints<DracoInt32Array, int32_t>(
+      pc, pa, draco::DT_INT32, draco::DT_UINT32, out_values);
+}
+
+bool Decoder::GetAttributeIntForAllPoints(const PointCloud &pc,
+                                          const PointAttribute &pa,
+                                          DracoInt32Array *out_values) {
+  return GetAttributeInt32ForAllPoints(pc, pa, out_values);
+}
+
+bool Decoder::GetAttributeUInt32ForAllPoints(const PointCloud &pc,
+                                             const PointAttribute &pa,
+                                             DracoUInt32Array *out_values) {
+  return GetAttributeDataForAllPoints<DracoUInt32Array, uint32_t>(
+      pc, pa, draco::DT_INT32, draco::DT_UINT32, out_values);
+}
+
+bool Decoder::GetAttributeDataArrayForAllPoints(const draco::PointCloud &pc,
+                                                const draco::PointAttribute &pa,
+                                                draco_DataType data_type,
+                                                int out_size,
+                                                void *out_values) {
+  switch (data_type) {
+    case draco::DT_INT8:
+      return GetAttributeDataArrayForAllPoints<int8_t>(pc, pa, draco::DT_INT8,
+                                                       out_size, out_values);
+    case draco::DT_INT16:
+      return GetAttributeDataArrayForAllPoints<int16_t>(pc, pa, draco::DT_INT16,
+                                                        out_size, out_values);
+    case draco::DT_INT32:
+      return GetAttributeDataArrayForAllPoints<int32_t>(pc, pa, draco::DT_INT32,
+                                                        out_size, out_values);
+    case draco::DT_UINT8:
+      return GetAttributeDataArrayForAllPoints<uint8_t>(pc, pa, draco::DT_UINT8,
+                                                        out_size, out_values);
+    case draco::DT_UINT16:
+      return GetAttributeDataArrayForAllPoints<uint16_t>(
+          pc, pa, draco::DT_UINT16, out_size, out_values);
+    case draco::DT_UINT32:
+      return GetAttributeDataArrayForAllPoints<uint32_t>(
+          pc, pa, draco::DT_UINT32, out_size, out_values);
+    case draco::DT_FLOAT32:
+      return GetAttributeFloatArrayForAllPoints(pc, pa, out_size, out_values);
+    default:
+      return false;
+  }
+}
+
+void Decoder::SkipAttributeTransform(draco_GeometryAttribute_Type att_type) {
+  decoder_.SetSkipAttributeTransform(att_type);
+}
+
+const Metadata *Decoder::GetMetadata(const PointCloud &pc) const {
+  return pc.GetMetadata();
+}
+
+const Metadata *Decoder::GetAttributeMetadata(const PointCloud &pc,
+                                              long att_id) const {
+  return pc.GetAttributeMetadataByAttributeId(att_id);
+}
diff --git a/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.h b/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.h
new file mode 100644
index 000000000..75ae76aa6
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/decoder_webidl_wrapper.h
@@ -0,0 +1,330 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_JAVASCRIPT_EMSCRIPTEN_DECODER_WEBIDL_WRAPPER_H_
+#define DRACO_JAVASCRIPT_EMSCRIPTEN_DECODER_WEBIDL_WRAPPER_H_
+
+#include <vector>
+
+#include "draco/attributes/attribute_transform_type.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/mesh/mesh.h"
+
+typedef draco::AttributeTransformType draco_AttributeTransformType;
+typedef draco::GeometryAttribute draco_GeometryAttribute;
+typedef draco_GeometryAttribute::Type draco_GeometryAttribute_Type;
+typedef draco::EncodedGeometryType draco_EncodedGeometryType;
+typedef draco::Status draco_Status;
+typedef draco::Status::Code draco_StatusCode;
+typedef draco::DataType draco_DataType;
+
+// To generate Draco JavaScript bindings you must have emscripten installed.
+// Then run make -f Makefile.emcc jslib.
+template <typename T>
+class DracoArray {
+ public:
+  T GetValue(int index) const { return values_[index]; }
+
+  void Resize(int size) { values_.resize(size); }
+  void MoveData(std::vector<T> &&values) { values_ = std::move(values); }
+
+  // Directly sets a value for a specific index. The array has to be already
+  // allocated at this point (using Resize() method).
+  void SetValue(int index, T val) { values_[index] = val; }
+
+  int size() const { return values_.size(); }
+
+ private:
+  std::vector<T> values_;
+};
+
+using DracoFloat32Array = DracoArray<float>;
+using DracoInt8Array = DracoArray<int8_t>;
+using DracoUInt8Array = DracoArray<uint8_t>;
+using DracoInt16Array = DracoArray<int16_t>;
+using DracoUInt16Array = DracoArray<uint16_t>;
+using DracoInt32Array = DracoArray<int32_t>;
+using DracoUInt32Array = DracoArray<uint32_t>;
+
+class MetadataQuerier {
+ public:
+  MetadataQuerier();
+
+  bool HasEntry(const draco::Metadata &metadata, const char *entry_name) const;
+
+  // This function does not guarantee that entry's type is long.
+  long GetIntEntry(const draco::Metadata &metadata,
+                   const char *entry_name) const;
+
+  // This function does not guarantee that entry types are long.
+  void GetIntEntryArray(const draco::Metadata &metadata, const char *entry_name,
+                        DracoInt32Array *out_values) const;
+
+  // This function does not guarantee that entry's type is double.
+  double GetDoubleEntry(const draco::Metadata &metadata,
+                        const char *entry_name) const;
+
+  // This function does not guarantee that entry's type is char*.
+  const char *GetStringEntry(const draco::Metadata &metadata,
+                             const char *entry_name);
+
+  long NumEntries(const draco::Metadata &metadata) const;
+  const char *GetEntryName(const draco::Metadata &metadata, int entry_id);
+
+ private:
+  // Cached values for metadata entries.
+  std::vector<std::string> entry_names_;
+  const draco::Metadata *entry_names_metadata_;
+
+  // Cached value for GetStringEntry() to avoid scoping issues.
+  std::string last_string_returned_;
+};
+
+// Class used by emscripten WebIDL Binder [1] to wrap calls to decode Draco
+// data.
+// [1]http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+class Decoder {
+ public:
+  Decoder();
+
+  // Returns the geometry type stored in the |in_buffer|. Return values can be
+  // INVALID_GEOMETRY_TYPE, POINT_CLOUD, or MESH.
+  // Deprecated: Use decoder.GetEncodedGeometryType(array), where |array| is
+  // an Int8Array containing the encoded data.
+  static draco_EncodedGeometryType GetEncodedGeometryType_Deprecated(
+      draco::DecoderBuffer *in_buffer);
+
+  // Decodes a point cloud from the provided buffer.
+  // Deprecated: Use DecodeArrayToPointCloud.
+  const draco::Status *DecodeBufferToPointCloud(
+      draco::DecoderBuffer *in_buffer, draco::PointCloud *out_point_cloud);
+
+  // Decodes a point cloud from the provided array.
+  const draco::Status *DecodeArrayToPointCloud(
+      const char *data, size_t data_size, draco::PointCloud *out_point_cloud);
+
+  // Decodes a triangular mesh from the provided buffer.
+  // Deprecated: Use DecodeArrayToMesh.
+  const draco::Status *DecodeBufferToMesh(draco::DecoderBuffer *in_buffer,
+                                          draco::Mesh *out_mesh);
+
+  // Decodes a mesh from the provided array.
+  const draco::Status *DecodeArrayToMesh(const char *data, size_t data_size,
+                                         draco::Mesh *out_mesh);
+
+  // Returns an attribute id for the first attribute of a given type.
+  long GetAttributeId(const draco::PointCloud &pc,
+                      draco_GeometryAttribute_Type type) const;
+
+  // Returns an attribute id of an attribute that contains a valid metadata
+  // entry "name" with value |attribute_name|.
+  static long GetAttributeIdByName(const draco::PointCloud &pc,
+                                   const char *attribute_name);
+
+  // Returns an attribute id of an attribute with a specified metadata pair
+  // <|metadata_name|, |metadata_value|>.
+  static long GetAttributeIdByMetadataEntry(const draco::PointCloud &pc,
+                                            const char *metadata_name,
+                                            const char *metadata_value);
+
+  // Returns an attribute id of an attribute that has the unique id.
+  static const draco::PointAttribute *GetAttributeByUniqueId(
+      const draco::PointCloud &pc, long unique_id);
+
+  // Returns a PointAttribute pointer from |att_id| index.
+  static const draco::PointAttribute *GetAttribute(const draco::PointCloud &pc,
+                                                   long att_id);
+
+  // Returns Mesh::Face values in |out_values| from |face_id| index.
+  static bool GetFaceFromMesh(const draco::Mesh &m,
+                              draco::FaceIndex::ValueType face_id,
+                              DracoInt32Array *out_values);
+
+  // Returns triangle strips for mesh |m|. If there's multiple strips,
+  // the strips will be separated by degenerate faces.
+  static long GetTriangleStripsFromMesh(const draco::Mesh &m,
+                                        DracoInt32Array *strip_values);
+
+  // Returns all faces as triangles. Fails if indices exceed the data range (in
+  // particular for uint16), or the output array size does not match.
+  // |out_size| is the size in bytes of |out_values|. |out_values| must be
+  // allocated before calling this function.
+  static bool GetTrianglesUInt16Array(const draco::Mesh &m, int out_size,
+                                      void *out_values);
+  static bool GetTrianglesUInt32Array(const draco::Mesh &m, int out_size,
+                                      void *out_values);
+
+  // Returns float attribute values in |out_values| from |entry_index| index.
+  static bool GetAttributeFloat(
+      const draco::PointAttribute &pa,
+      draco::AttributeValueIndex::ValueType entry_index,
+      DracoFloat32Array *out_values);
+
+  // Returns float attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeFloatForAllPoints(const draco::PointCloud &pc,
+                                            const draco::PointAttribute &pa,
+                                            DracoFloat32Array *out_values);
+
+  // Returns float attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeFloatArrayForAllPoints(
+      const draco::PointCloud &pc, const draco::PointAttribute &pa,
+      int out_size, void *out_values);
+
+  // Returns int8_t attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeInt8ForAllPoints(const draco::PointCloud &pc,
+                                           const draco::PointAttribute &pa,
+                                           DracoInt8Array *out_values);
+
+  // Returns uint8_t attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeUInt8ForAllPoints(const draco::PointCloud &pc,
+                                            const draco::PointAttribute &pa,
+                                            DracoUInt8Array *out_values);
+
+  // Returns int16_t attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeInt16ForAllPoints(const draco::PointCloud &pc,
+                                            const draco::PointAttribute &pa,
+                                            DracoInt16Array *out_values);
+
+  // Returns uint16_t attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeUInt16ForAllPoints(const draco::PointCloud &pc,
+                                             const draco::PointAttribute &pa,
+                                             DracoUInt16Array *out_values);
+
+  // Returns int32_t attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeInt32ForAllPoints(const draco::PointCloud &pc,
+                                            const draco::PointAttribute &pa,
+                                            DracoInt32Array *out_values);
+
+  // Deprecated: Use GetAttributeInt32ForAllPoints() instead.
+  static bool GetAttributeIntForAllPoints(const draco::PointCloud &pc,
+                                          const draco::PointAttribute &pa,
+                                          DracoInt32Array *out_values);
+
+  // Returns uint32_t attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  static bool GetAttributeUInt32ForAllPoints(const draco::PointCloud &pc,
+                                             const draco::PointAttribute &pa,
+                                             DracoUInt32Array *out_values);
+
+  // Returns |data_type| attribute values for all point ids of the point cloud.
+  // I.e., the |out_values| is going to contain m.num_points() entries.
+  // |out_size| is the size in bytes of |out_values|. |out_values| must be
+  // allocated before calling this function.
+  static bool GetAttributeDataArrayForAllPoints(const draco::PointCloud &pc,
+                                                const draco::PointAttribute &pa,
+                                                draco_DataType data_type,
+                                                int out_size, void *out_values);
+
+  // Tells the decoder to skip an attribute transform (e.g. dequantization) for
+  // an attribute of a given type.
+  void SkipAttributeTransform(draco_GeometryAttribute_Type att_type);
+
+  const draco::Metadata *GetMetadata(const draco::PointCloud &pc) const;
+  const draco::Metadata *GetAttributeMetadata(const draco::PointCloud &pc,
+                                              long att_id) const;
+
+ private:
+  template <class DracoArrayT, class ValueTypeT>
+  static bool GetAttributeDataForAllPoints(const draco::PointCloud &pc,
+                                           const draco::PointAttribute &pa,
+                                           draco::DataType draco_signed_type,
+                                           draco::DataType draco_unsigned_type,
+                                           DracoArrayT *out_values) {
+    const int components = pa.num_components();
+    const int num_points = pc.num_points();
+    const int num_entries = num_points * components;
+
+    if ((pa.data_type() == draco_signed_type ||
+         pa.data_type() == draco_unsigned_type) &&
+        pa.is_mapping_identity()) {
+      // Copy values directly to the output vector.
+      const ValueTypeT *ptr = reinterpret_cast<const ValueTypeT *>(
+          pa.GetAddress(draco::AttributeValueIndex(0)));
+      out_values->MoveData({ptr, ptr + num_entries});
+      return true;
+    }
+
+    // Copy values one by one.
+    std::vector<ValueTypeT> values(components);
+    int entry_id = 0;
+
+    out_values->Resize(num_entries);
+    for (draco::PointIndex i(0); i < num_points; ++i) {
+      const draco::AttributeValueIndex val_index = pa.mapped_index(i);
+      if (!pa.ConvertValue<ValueTypeT>(val_index, &values[0])) {
+        return false;
+      }
+      for (int j = 0; j < components; ++j) {
+        out_values->SetValue(entry_id++, values[j]);
+      }
+    }
+    return true;
+  }
+
+  template <class T>
+  static bool GetAttributeDataArrayForAllPoints(const draco::PointCloud &pc,
+                                                const draco::PointAttribute &pa,
+                                                const draco::DataType type,
+                                                int out_size,
+                                                void *out_values) {
+    const int components = pa.num_components();
+    const int num_points = pc.num_points();
+    const int data_size = num_points * components * sizeof(T);
+    if (data_size != out_size) {
+      return false;
+    }
+    const bool requested_type_matches = pa.data_type() == type;
+    if (requested_type_matches && pa.is_mapping_identity()) {
+      // Copy values directly to the output vector.
+      const auto ptr = pa.GetAddress(draco::AttributeValueIndex(0));
+      ::memcpy(out_values, ptr, data_size);
+      return true;
+    }
+
+    // Copy values one by one.
+    std::vector<T> values(components);
+    int entry_id = 0;
+
+    T *const typed_output = reinterpret_cast<T *>(out_values);
+    for (draco::PointIndex i(0); i < num_points; ++i) {
+      const draco::AttributeValueIndex val_index = pa.mapped_index(i);
+      if (requested_type_matches) {
+        pa.GetValue(val_index, values.data());
+      } else {
+        if (!pa.ConvertValue<T>(val_index, values.data())) {
+          return false;
+        }
+      }
+      for (int j = 0; j < components; ++j) {
+        typed_output[entry_id++] = values[j];
+      }
+    }
+    return true;
+  }
+
+  draco::Decoder decoder_;
+  draco::Status last_status_;
+};
+
+#endif  // DRACO_JAVASCRIPT_EMSCRIPTEN_DECODER_WEBIDL_WRAPPER_H_
diff --git a/contrib/draco/src/draco/javascript/emscripten/draco_animation_decoder_glue_wrapper.cc b/contrib/draco/src/draco/javascript/emscripten/draco_animation_decoder_glue_wrapper.cc
new file mode 100644
index 000000000..83ed98fdc
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/draco_animation_decoder_glue_wrapper.cc
@@ -0,0 +1,28 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is used by emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+#include "draco/attributes/attribute_octahedron_transform.h"
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/decode.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/javascript/emscripten/animation_decoder_webidl_wrapper.h"
+#include "draco/mesh/mesh.h"
+#include "draco/point_cloud/point_cloud.h"
+
+// glue_animation_decoder.cpp is generated by Makefile.emcc build_glue target.
+#include "glue_animation_decoder.cpp"
diff --git a/contrib/draco/src/draco/javascript/emscripten/draco_animation_encoder_glue_wrapper.cc b/contrib/draco/src/draco/javascript/emscripten/draco_animation_encoder_glue_wrapper.cc
new file mode 100644
index 000000000..29e7ed3ba
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/draco_animation_encoder_glue_wrapper.cc
@@ -0,0 +1,25 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is used by emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/encode.h"
+#include "draco/javascript/emscripten/animation_encoder_webidl_wrapper.h"
+#include "draco/mesh/mesh.h"
+#include "draco/point_cloud/point_cloud.h"
+
+// glue_animation_encoder.cpp is generated by Makefile.emcc build_glue target.
+#include "glue_animation_encoder.cpp"
diff --git a/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_decoder.idl b/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_decoder.idl
new file mode 100644
index 000000000..c9fe76b59
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_decoder.idl
@@ -0,0 +1,52 @@
+// Interface exposed to emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+[Prefix="draco::"]
+interface DecoderBuffer {
+  void DecoderBuffer();
+  void Init([Const] byte[] data, unsigned long data_size);
+};
+
+enum draco_StatusCode {
+  "draco_Status::OK",
+  "draco_Status::DRACO_ERROR",
+  "draco_Status::IO_ERROR",
+  "draco_Status::INVALID_PARAMETER",
+  "draco_Status::UNSUPPORTED_VERSION",
+  "draco_Status::UNKNOWN_VERSION",
+};
+
+[Prefix="draco::"]
+interface Status {
+  draco_StatusCode code();
+  boolean ok();
+  [Const] DOMString error_msg();
+};
+
+// Draco version of typed arrays. The memory of these arrays is allocated on the
+// emscripten heap.
+interface DracoFloat32Array {
+  void DracoFloat32Array();
+  float GetValue(long index);
+  long size();
+};
+
+[Prefix="draco::"]
+interface KeyframeAnimation {
+  void KeyframeAnimation();
+  long num_frames();
+  long num_animations();
+};
+
+interface AnimationDecoder {
+  void AnimationDecoder();
+
+  [Const] Status DecodeBufferToKeyframeAnimation(DecoderBuffer in_buffer,
+                                                 KeyframeAnimation animation);
+
+  boolean GetTimestamps([Ref, Const] KeyframeAnimation animation,
+                        DracoFloat32Array timestamp);
+
+  boolean GetKeyframes([Ref, Const] KeyframeAnimation animation,
+                        long keyframes_id,
+                        DracoFloat32Array animation_data);
+};
diff --git a/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_encoder.idl b/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_encoder.idl
new file mode 100644
index 000000000..e74a4c9e4
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/draco_animation_web_encoder.idl
@@ -0,0 +1,34 @@
+// Interface exposed to emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+// Draco version of typed arrays. The memory of these arrays is allocated on the
+// emscripten heap.
+interface DracoInt8Array {
+  void DracoInt8Array();
+  long GetValue(long index);
+  long size();
+};
+
+[Prefix="draco::"]
+interface KeyframeAnimation {
+  void KeyframeAnimation();
+  long num_frames();
+};
+
+interface AnimationBuilder {
+  void AnimationBuilder();
+  boolean SetTimestamps(KeyframeAnimation animation, long num_frames,
+                       [Const] float[] timestamps);
+
+  long AddKeyframes(KeyframeAnimation animation, long num_frames,
+                    long num_components, [Const] float[] animation_data);
+};
+
+interface AnimationEncoder {
+  void AnimationEncoder();
+
+  void SetTimestampsQuantization(long quantization_bits);
+  void SetKeyframesQuantization(long quantization_bits);
+
+  long EncodeAnimationToDracoBuffer(KeyframeAnimation animation,
+                                    DracoInt8Array encoded_data);
+};
diff --git a/contrib/draco/src/draco/javascript/emscripten/draco_decoder_glue_wrapper.cc b/contrib/draco/src/draco/javascript/emscripten/draco_decoder_glue_wrapper.cc
new file mode 100644
index 000000000..249d86a3e
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/draco_decoder_glue_wrapper.cc
@@ -0,0 +1,28 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is used by emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+#include "draco/attributes/attribute_octahedron_transform.h"
+#include "draco/attributes/attribute_quantization_transform.h"
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/decode.h"
+#include "draco/core/decoder_buffer.h"
+#include "draco/javascript/emscripten/decoder_webidl_wrapper.h"
+#include "draco/mesh/mesh.h"
+#include "draco/point_cloud/point_cloud.h"
+
+// glue.cpp is generated by Makefile.emcc build_glue target.
+#include "glue_decoder.cpp"
diff --git a/contrib/draco/src/draco/javascript/emscripten/draco_encoder_glue_wrapper.cc b/contrib/draco/src/draco/javascript/emscripten/draco_encoder_glue_wrapper.cc
new file mode 100644
index 000000000..05a0af2f1
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/draco_encoder_glue_wrapper.cc
@@ -0,0 +1,25 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is used by emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/encode.h"
+#include "draco/javascript/emscripten/encoder_webidl_wrapper.h"
+#include "draco/mesh/mesh.h"
+#include "draco/point_cloud/point_cloud.h"
+
+// glue.cpp is generated by Makefile.emcc build_glue target.
+#include "glue_encoder.cpp"
diff --git a/contrib/draco/src/draco/javascript/emscripten/draco_web_decoder.idl b/contrib/draco/src/draco/javascript/emscripten/draco_web_decoder.idl
new file mode 100644
index 000000000..366694185
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/draco_web_decoder.idl
@@ -0,0 +1,283 @@
+// Interface exposed to emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+
+// Deprecated: DecoderBuffer is no longer supported and will be removed in
+//             future releases. Please refer to Decoder declaration below for
+//             new decoding functions that do not use DecoderBuffer.
+[Prefix="draco::"]
+interface DecoderBuffer {
+  void DecoderBuffer();
+  void Init([Const] byte[] data, unsigned long data_size);
+};
+
+// TODO(fgalligan): Can we remove this?
+enum draco_AttributeTransformType {
+  "draco::ATTRIBUTE_INVALID_TRANSFORM",
+  "draco::ATTRIBUTE_NO_TRANSFORM",
+  "draco::ATTRIBUTE_QUANTIZATION_TRANSFORM",
+  "draco::ATTRIBUTE_OCTAHEDRON_TRANSFORM"
+};
+
+[Prefix="draco::"]
+interface AttributeTransformData {
+  void AttributeTransformData();
+  long transform_type();
+};
+
+enum draco_GeometryAttribute_Type {
+  "draco_GeometryAttribute::INVALID",
+  "draco_GeometryAttribute::POSITION",
+  "draco_GeometryAttribute::NORMAL",
+  "draco_GeometryAttribute::COLOR",
+  "draco_GeometryAttribute::TEX_COORD",
+  "draco_GeometryAttribute::GENERIC"
+};
+
+[Prefix="draco::"]
+interface GeometryAttribute {
+  void GeometryAttribute();
+};
+
+enum draco_EncodedGeometryType {
+  "draco::INVALID_GEOMETRY_TYPE",
+  "draco::POINT_CLOUD",
+  "draco::TRIANGULAR_MESH"
+};
+
+enum draco_DataType {
+  "draco::DT_INVALID",
+  "draco::DT_INT8",
+  "draco::DT_UINT8",
+  "draco::DT_INT16",
+  "draco::DT_UINT16",
+  "draco::DT_INT32",
+  "draco::DT_UINT32",
+  "draco::DT_INT64",
+  "draco::DT_UINT64",
+  "draco::DT_FLOAT32",
+  "draco::DT_FLOAT64",
+  "draco::DT_BOOL",
+  "draco::DT_TYPES_COUNT"
+};
+
+[Prefix="draco::"]
+interface PointAttribute {
+  void PointAttribute();
+  long size();
+  [Const] AttributeTransformData GetAttributeTransformData();
+
+  // From GeometryAttribute
+  long attribute_type();
+  long data_type();
+  byte num_components();
+  boolean normalized();
+  long byte_stride();
+  long byte_offset();
+  long unique_id();
+};
+
+[Prefix="draco::"]
+interface AttributeQuantizationTransform {
+  void AttributeQuantizationTransform();
+  boolean InitFromAttribute([Ref, Const] PointAttribute att);
+  long quantization_bits();
+  float min_value(long axis);
+  float range();
+};
+
+[Prefix="draco::"]
+interface AttributeOctahedronTransform {
+  void AttributeOctahedronTransform();
+  boolean InitFromAttribute([Ref, Const] PointAttribute att);
+  long quantization_bits();
+};
+
+
+[Prefix="draco::"]
+interface PointCloud {
+  void PointCloud();
+
+  long num_attributes();
+  long num_points();
+};
+
+[Prefix="draco::"]
+interface Mesh : PointCloud {
+  void Mesh();
+  long num_faces();
+
+  // From PointCloud
+  long num_attributes();
+  long num_points();
+};
+
+[Prefix="draco::"]
+interface Metadata {
+  void Metadata();
+};
+
+enum draco_StatusCode {
+  "draco_Status::OK",
+  "draco_Status::DRACO_ERROR",
+  "draco_Status::IO_ERROR",
+  "draco_Status::INVALID_PARAMETER",
+  "draco_Status::UNSUPPORTED_VERSION",
+  "draco_Status::UNKNOWN_VERSION",
+};
+
+[Prefix="draco::"]
+interface Status {
+  draco_StatusCode code();
+  boolean ok();
+  [Const] DOMString error_msg();
+};
+
+// Draco version of typed arrays. The memory of these arrays is allocated on the
+// emscripten heap.
+interface DracoFloat32Array {
+  void DracoFloat32Array();
+  float GetValue(long index);
+  long size();
+};
+
+interface DracoInt8Array {
+  void DracoInt8Array();
+  byte GetValue(long index);
+  long size();
+};
+
+interface DracoUInt8Array {
+  void DracoUInt8Array();
+  octet GetValue(long index);
+  long size();
+};
+
+interface DracoInt16Array {
+  void DracoInt16Array();
+  short GetValue(long index);
+  long size();
+};
+
+interface DracoUInt16Array {
+  void DracoUInt16Array();
+  unsigned short GetValue(long index);
+  long size();
+};
+
+interface DracoInt32Array {
+  void DracoInt32Array();
+  long GetValue(long index);
+  long size();
+};
+
+interface DracoUInt32Array {
+  void DracoUInt32Array();
+  unsigned long GetValue(long index);
+  long size();
+};
+
+interface MetadataQuerier {
+  void MetadataQuerier();
+
+  boolean HasEntry([Ref, Const] Metadata metadata,
+                   [Const] DOMString entry_name);
+  long GetIntEntry([Ref, Const] Metadata metadata,
+                   [Const] DOMString entry_name);
+  void GetIntEntryArray([Ref, Const] Metadata metadata,
+                        [Const] DOMString entry_name,
+                        DracoInt32Array out_values);
+  double GetDoubleEntry([Ref, Const] Metadata metadata,
+                        [Const] DOMString entry_name);
+  [Const] DOMString GetStringEntry([Ref, Const] Metadata metadata,
+                                   [Const] DOMString entry_name);
+
+  long NumEntries([Ref, Const] Metadata metadata);
+  [Const] DOMString GetEntryName([Ref, Const] Metadata metadata, long entry_id);
+};
+
+interface Decoder {
+  void Decoder();
+
+  [Const] Status DecodeArrayToPointCloud([Const] byte[] data,
+                                         unsigned long data_size,
+                                         PointCloud out_point_cloud);
+
+  [Const] Status DecodeArrayToMesh([Const] byte[] data,
+                                   unsigned long data_size,
+                                   Mesh out_mesh);
+
+  long GetAttributeId([Ref, Const] PointCloud pc,
+                      draco_GeometryAttribute_Type type);
+  long GetAttributeIdByName([Ref, Const] PointCloud pc, [Const] DOMString name);
+  long GetAttributeIdByMetadataEntry([Ref, Const] PointCloud pc,
+                                     [Const] DOMString name,
+                                     [Const] DOMString value);
+
+  [Const] PointAttribute GetAttribute([Ref, Const] PointCloud pc, long att_id);
+  [Const] PointAttribute GetAttributeByUniqueId([Ref, Const] PointCloud pc,
+                                                long unique_id);
+
+  [Const] Metadata GetMetadata([Ref, Const] PointCloud pc);
+  [Const] Metadata GetAttributeMetadata([Ref, Const] PointCloud pc,
+                                        long att_id);
+
+  boolean GetFaceFromMesh([Ref, Const] Mesh m, long face_id,
+                          DracoInt32Array out_values);
+  long GetTriangleStripsFromMesh([Ref, Const] Mesh m,
+                                 DracoInt32Array strip_values);
+
+  boolean GetTrianglesUInt16Array([Ref, Const] Mesh m,
+                                  long out_size, VoidPtr out_values);
+  boolean GetTrianglesUInt32Array([Ref, Const] Mesh m,
+                                  long out_size, VoidPtr out_values);
+
+  boolean GetAttributeFloat([Ref, Const] PointAttribute pa,
+                            long att_index,
+                            DracoFloat32Array out_values);
+
+  boolean GetAttributeFloatForAllPoints([Ref, Const] PointCloud pc,
+                                        [Ref, Const] PointAttribute pa,
+                                        DracoFloat32Array out_values);
+
+  // Deprecated, use GetAttributeInt32ForAllPoints instead.
+  boolean GetAttributeIntForAllPoints([Ref, Const] PointCloud pc,
+                                      [Ref, Const] PointAttribute pa,
+                                      DracoInt32Array out_values);
+
+  boolean GetAttributeInt8ForAllPoints([Ref, Const] PointCloud pc,
+                                       [Ref, Const] PointAttribute pa,
+                                       DracoInt8Array out_values);
+  boolean GetAttributeUInt8ForAllPoints([Ref, Const] PointCloud pc,
+                                        [Ref, Const] PointAttribute pa,
+                                        DracoUInt8Array out_values);
+  boolean GetAttributeInt16ForAllPoints([Ref, Const] PointCloud pc,
+                                        [Ref, Const] PointAttribute pa,
+                                        DracoInt16Array out_values);
+  boolean GetAttributeUInt16ForAllPoints([Ref, Const] PointCloud pc,
+                                         [Ref, Const] PointAttribute pa,
+                                         DracoUInt16Array out_values);
+  boolean GetAttributeInt32ForAllPoints([Ref, Const] PointCloud pc,
+                                        [Ref, Const] PointAttribute pa,
+                                        DracoInt32Array out_values);
+  boolean GetAttributeUInt32ForAllPoints([Ref, Const] PointCloud pc,
+                                         [Ref, Const] PointAttribute pa,
+                                         DracoUInt32Array out_values);
+
+  boolean GetAttributeDataArrayForAllPoints([Ref, Const] PointCloud pc,
+                                            [Ref, Const] PointAttribute pa,
+                                            draco_DataType data_type,
+                                            long out_size, VoidPtr out_values);
+
+  void SkipAttributeTransform(draco_GeometryAttribute_Type att_type);
+
+  // Deprecated: Use decoder.GetEncodedGeometryType(array) instead, where
+  //             |array| is an Int8Array containing the encoded data.
+  draco_EncodedGeometryType GetEncodedGeometryType_Deprecated(
+                                DecoderBuffer in_buffer);
+
+  // Deprecated: UseDecodeArrayToPointCloud instead.
+  [Const] Status DecodeBufferToPointCloud(DecoderBuffer in_buffer,
+                                          PointCloud out_point_cloud);
+  // Deprecated: UseDecodeArrayToMesh instead.
+  [Const] Status DecodeBufferToMesh(DecoderBuffer in_buffer, Mesh out_mesh);
+};
diff --git a/contrib/draco/src/draco/javascript/emscripten/draco_web_encoder.idl b/contrib/draco/src/draco/javascript/emscripten/draco_web_encoder.idl
new file mode 100644
index 000000000..d3261b18e
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/draco_web_encoder.idl
@@ -0,0 +1,208 @@
+// Interface exposed to emscripten's WebIDL Binder.
+// http://kripken.github.io/emscripten-site/docs/porting/connecting_cpp_and_javascript/WebIDL-Binder.html
+enum draco_GeometryAttribute_Type {
+  "draco_GeometryAttribute::INVALID",
+  "draco_GeometryAttribute::POSITION",
+  "draco_GeometryAttribute::NORMAL",
+  "draco_GeometryAttribute::COLOR",
+  "draco_GeometryAttribute::TEX_COORD",
+  "draco_GeometryAttribute::GENERIC"
+};
+
+[Prefix="draco::"]
+interface GeometryAttribute {
+  void GeometryAttribute();
+};
+
+enum draco_EncodedGeometryType {
+  "draco::INVALID_GEOMETRY_TYPE",
+  "draco::POINT_CLOUD",
+  "draco::TRIANGULAR_MESH"
+};
+
+enum draco_MeshEncoderMethod {
+  "draco::MESH_SEQUENTIAL_ENCODING",
+  "draco::MESH_EDGEBREAKER_ENCODING"
+};
+
+[Prefix="draco::"]
+interface PointAttribute {
+  void PointAttribute();
+  long size();
+
+  // From GeometryAttribute
+  long attribute_type();
+  long data_type();
+  byte num_components();
+  boolean normalized();
+  long byte_stride();
+  long byte_offset();
+  long unique_id();
+};
+
+[Prefix="draco::"]
+interface PointCloud {
+  void PointCloud();
+
+  long num_attributes();
+  long num_points();
+};
+
+[Prefix="draco::"]
+interface Mesh : PointCloud {
+  void Mesh();
+  long num_faces();
+
+  // From PointCloud
+  long num_attributes();
+  long num_points();
+  void set_num_points(long num_points);
+};
+
+[Prefix="draco::"]
+interface Metadata {
+  void Metadata();
+};
+
+interface DracoInt8Array {
+  void DracoInt8Array();
+  long GetValue(long index);
+  long size();
+};
+
+interface MetadataBuilder {
+  void MetadataBuilder();
+
+  boolean AddStringEntry(Metadata metadata,
+                         [Const] DOMString entry_name,
+                         [Const] DOMString entry_value);
+  boolean AddIntEntry(Metadata metadata,
+                      [Const] DOMString entry_name,
+                      long entry_value);
+  boolean AddIntEntryArray(Metadata metadata,
+                          [Const] DOMString entry_name,
+                          [Const] long[] att_values,
+                          long num_values);
+  boolean AddDoubleEntry(Metadata metadata,
+                         [Const] DOMString entry_name,
+                         double entry_value);
+};
+
+interface PointCloudBuilder {
+  void PointCloudBuilder();
+  long AddFloatAttribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] float[] att_values);
+  long AddInt8Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                        long num_vertices, long num_components,
+                        [Const] byte[] att_values);
+  long AddUInt8Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] octet[] att_values);
+  long AddInt16Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] short[] att_values);
+  long AddUInt16Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                          long num_vertices, long num_components,
+                          [Const] unsigned short[] att_values);
+  long AddInt32Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] long[] att_values);
+  long AddUInt32Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                          long num_vertices, long num_components,
+                          [Const] unsigned long[] att_values);
+
+  boolean AddMetadata(PointCloud pc, [Const] Metadata metadata);
+  boolean SetMetadataForAttribute(PointCloud pc, long attribute_id,
+                                  [Const] Metadata metadata);
+};
+
+interface MeshBuilder : PointCloudBuilder {
+  void MeshBuilder();
+
+  boolean AddFacesToMesh(Mesh mesh, long num_faces, [Const] long[] faces);
+
+  // Deprecated.
+  long AddFloatAttributeToMesh(Mesh mesh, draco_GeometryAttribute_Type type,
+                               long num_vertices, long num_components,
+                               [Const] float[] att_values);
+  // Deprecated.
+  long AddInt32AttributeToMesh(Mesh mesh, draco_GeometryAttribute_Type type,
+                               long num_vertices, long num_components,
+                               [Const] long[] att_values);
+  // Deprecated.
+  boolean AddMetadataToMesh(Mesh mesh, [Const] Metadata metadata);
+
+  // From PointCloudBuilder
+  long AddFloatAttribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] float[] att_values);
+  long AddInt8Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                        long num_vertices, long num_components,
+                        [Const] byte[] att_values);
+  long AddUInt8Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] octet[] att_values);
+  long AddInt16Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] short[] att_values);
+  long AddUInt16Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                          long num_vertices, long num_components,
+                          [Const] unsigned short[] att_values);
+  long AddInt32Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                         long num_vertices, long num_components,
+                         [Const] long[] att_values);
+  long AddUInt32Attribute(PointCloud pc, draco_GeometryAttribute_Type type,
+                          long num_vertices, long num_components,
+                          [Const] unsigned long[] att_values);
+
+  boolean AddMetadata(PointCloud pc, [Const] Metadata metadata);
+  boolean SetMetadataForAttribute(PointCloud pc, long attribute_id,
+                                  [Const] Metadata metadata);
+};
+
+interface Encoder {
+  void Encoder();
+  void SetEncodingMethod(long method);
+  void SetAttributeQuantization(draco_GeometryAttribute_Type type,
+                                long quantization_bits);
+  void SetAttributeExplicitQuantization(draco_GeometryAttribute_Type type,
+                                        long quantization_bits,
+                                        long num_components,
+                                        [Const] float[] origin,
+                                        float range);
+  void SetSpeedOptions(long encoding_speed, long decoding_speed);
+  void SetTrackEncodedProperties(boolean flag);
+
+  long EncodeMeshToDracoBuffer(Mesh mesh,
+                               DracoInt8Array encoded_data);
+  long EncodePointCloudToDracoBuffer(PointCloud pc, boolean deduplicate_values,
+                                     DracoInt8Array encoded_data);
+
+  // Returns the number of encoded points or faces from the last Encode
+  // operation. Returns 0 if SetTrackEncodedProperties was not set to true.
+  long GetNumberOfEncodedPoints();
+  long GetNumberOfEncodedFaces();
+};
+
+interface ExpertEncoder {
+  void ExpertEncoder(PointCloud pc);
+  void SetEncodingMethod(long method);
+  void SetAttributeQuantization(long att_id,
+                                long quantization_bits);
+  void SetAttributeExplicitQuantization(long att_id,
+                                        long quantization_bits,
+                                        long num_components,
+                                        [Const] float[] origin,
+                                        float range);
+  void SetSpeedOptions(long encoding_speed, long decoding_speed);
+  void SetTrackEncodedProperties(boolean flag);
+
+  long EncodeToDracoBuffer(boolean deduplicate_values,
+                           DracoInt8Array encoded_data);
+
+  // Returns the number of encoded points or faces from the last Encode
+  // operation. Returns 0 if SetTrackEncodedProperties was not set to true.
+  long GetNumberOfEncodedPoints();
+  long GetNumberOfEncodedFaces();
+};
\ No newline at end of file
diff --git a/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.cc b/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.cc
new file mode 100644
index 000000000..0a1ff7cdb
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.cc
@@ -0,0 +1,359 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/javascript/emscripten/encoder_webidl_wrapper.h"
+
+#include "draco/compression/encode.h"
+#include "draco/mesh/mesh.h"
+
+DracoInt8Array::DracoInt8Array() {}
+
+int8_t DracoInt8Array::GetValue(int index) const { return values_[index]; }
+
+bool DracoInt8Array::SetValues(const char *values, int count) {
+  values_.assign(values, values + count);
+  return true;
+}
+
+using draco::Mesh;
+using draco::Metadata;
+using draco::PointCloud;
+
+MetadataBuilder::MetadataBuilder() {}
+
+bool MetadataBuilder::AddStringEntry(Metadata *metadata, const char *entry_name,
+                                     const char *entry_value) {
+  if (!metadata) {
+    return false;
+  }
+  const std::string name{entry_name};
+  const std::string value{entry_value};
+  metadata->AddEntryString(entry_name, entry_value);
+  return true;
+}
+
+bool MetadataBuilder::AddIntEntry(Metadata *metadata, const char *entry_name,
+                                  long entry_value) {
+  if (!metadata) {
+    return false;
+  }
+  const std::string name{entry_name};
+  metadata->AddEntryInt(name, entry_value);
+  return true;
+}
+
+bool MetadataBuilder::AddIntEntryArray(draco::Metadata *metadata,
+                                       const char *entry_name,
+                                       const int32_t *entry_values,
+                                       int32_t num_values) {
+  if (!metadata) {
+    return false;
+  }
+  const std::string name{entry_name};
+  metadata->AddEntryIntArray(name, {entry_values, entry_values + num_values});
+  return true;
+}
+
+bool MetadataBuilder::AddDoubleEntry(Metadata *metadata, const char *entry_name,
+                                     double entry_value) {
+  if (!metadata) {
+    return false;
+  }
+  const std::string name{entry_name};
+  metadata->AddEntryDouble(name, entry_value);
+  return true;
+}
+
+int PointCloudBuilder::AddFloatAttribute(PointCloud *pc,
+                                         draco_GeometryAttribute_Type type,
+                                         long num_vertices, long num_components,
+                                         const float *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_FLOAT32);
+}
+
+int PointCloudBuilder::AddInt8Attribute(PointCloud *pc,
+                                        draco_GeometryAttribute_Type type,
+                                        long num_vertices, long num_components,
+                                        const char *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_INT8);
+}
+
+int PointCloudBuilder::AddUInt8Attribute(PointCloud *pc,
+                                         draco_GeometryAttribute_Type type,
+                                         long num_vertices, long num_components,
+                                         const uint8_t *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_UINT8);
+}
+
+int PointCloudBuilder::AddInt16Attribute(PointCloud *pc,
+                                         draco_GeometryAttribute_Type type,
+                                         long num_vertices, long num_components,
+                                         const int16_t *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_INT16);
+}
+
+int PointCloudBuilder::AddUInt16Attribute(PointCloud *pc,
+                                          draco_GeometryAttribute_Type type,
+                                          long num_vertices,
+                                          long num_components,
+                                          const uint16_t *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_UINT16);
+}
+
+int PointCloudBuilder::AddInt32Attribute(PointCloud *pc,
+                                         draco_GeometryAttribute_Type type,
+                                         long num_vertices, long num_components,
+                                         const int32_t *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_INT32);
+}
+
+int PointCloudBuilder::AddUInt32Attribute(PointCloud *pc,
+                                          draco_GeometryAttribute_Type type,
+                                          long num_vertices,
+                                          long num_components,
+                                          const uint32_t *att_values) {
+  return AddAttribute(pc, type, num_vertices, num_components, att_values,
+                      draco::DT_UINT32);
+}
+
+bool PointCloudBuilder::AddMetadata(PointCloud *pc, const Metadata *metadata) {
+  if (!pc) {
+    return false;
+  }
+  // Not allow write over metadata.
+  if (pc->metadata()) {
+    return false;
+  }
+  std::unique_ptr<draco::GeometryMetadata> new_metadata =
+      std::unique_ptr<draco::GeometryMetadata>(
+          new draco::GeometryMetadata(*metadata));
+  pc->AddMetadata(std::move(new_metadata));
+  return true;
+}
+
+bool PointCloudBuilder::SetMetadataForAttribute(PointCloud *pc,
+                                                long attribute_id,
+                                                const Metadata *metadata) {
+  if (!pc) {
+    return false;
+  }
+  // If empty metadata, just ignore.
+  if (!metadata) {
+    return false;
+  }
+  if (attribute_id < 0 || attribute_id >= pc->num_attributes()) {
+    return false;
+  }
+
+  if (!pc->metadata()) {
+    std::unique_ptr<draco::GeometryMetadata> geometry_metadata =
+        std::unique_ptr<draco::GeometryMetadata>(new draco::GeometryMetadata());
+    pc->AddMetadata(std::move(geometry_metadata));
+  }
+
+  // Get unique attribute id for the attribute.
+  const long unique_id = pc->attribute(attribute_id)->unique_id();
+
+  std::unique_ptr<draco::AttributeMetadata> att_metadata =
+      std::unique_ptr<draco::AttributeMetadata>(
+          new draco::AttributeMetadata(*metadata));
+  att_metadata->set_att_unique_id(unique_id);
+  pc->metadata()->AddAttributeMetadata(std::move(att_metadata));
+  return true;
+}
+
+MeshBuilder::MeshBuilder() {}
+
+bool MeshBuilder::AddFacesToMesh(Mesh *mesh, long num_faces, const int *faces) {
+  if (!mesh) {
+    return false;
+  }
+  mesh->SetNumFaces(num_faces);
+  for (draco::FaceIndex i(0); i < num_faces; ++i) {
+    draco::Mesh::Face face;
+    face[0] = faces[i.value() * 3];
+    face[1] = faces[i.value() * 3 + 1];
+    face[2] = faces[i.value() * 3 + 2];
+    mesh->SetFace(i, face);
+  }
+  return true;
+}
+
+int MeshBuilder::AddFloatAttributeToMesh(Mesh *mesh,
+                                         draco_GeometryAttribute_Type type,
+                                         long num_vertices, long num_components,
+                                         const float *att_values) {
+  return AddFloatAttribute(mesh, type, num_vertices, num_components,
+                           att_values);
+}
+
+int MeshBuilder::AddInt32AttributeToMesh(draco::Mesh *mesh,
+                                         draco_GeometryAttribute_Type type,
+                                         long num_vertices, long num_components,
+                                         const int32_t *att_values) {
+  return AddInt32Attribute(mesh, type, num_vertices, num_components,
+                           att_values);
+}
+
+bool MeshBuilder::AddMetadataToMesh(Mesh *mesh, const Metadata *metadata) {
+  return AddMetadata(mesh, metadata);
+}
+
+Encoder::Encoder() {}
+
+void Encoder::SetEncodingMethod(long method) {
+  encoder_.SetEncodingMethod(method);
+}
+
+void Encoder::SetAttributeQuantization(draco_GeometryAttribute_Type type,
+                                       long quantization_bits) {
+  encoder_.SetAttributeQuantization(type, quantization_bits);
+}
+
+void Encoder::SetAttributeExplicitQuantization(
+    draco_GeometryAttribute_Type type, long quantization_bits,
+    long num_components, const float *origin, float range) {
+  encoder_.SetAttributeExplicitQuantization(type, quantization_bits,
+                                            num_components, origin, range);
+}
+
+void Encoder::SetSpeedOptions(long encoding_speed, long decoding_speed) {
+  encoder_.SetSpeedOptions(encoding_speed, decoding_speed);
+}
+
+void Encoder::SetTrackEncodedProperties(bool flag) {
+  encoder_.SetTrackEncodedProperties(flag);
+}
+
+int Encoder::EncodeMeshToDracoBuffer(Mesh *mesh, DracoInt8Array *draco_buffer) {
+  if (!mesh) {
+    return 0;
+  }
+  draco::EncoderBuffer buffer;
+  if (mesh->GetNamedAttributeId(draco::GeometryAttribute::POSITION) == -1) {
+    return 0;
+  }
+  if (!mesh->DeduplicateAttributeValues()) {
+    return 0;
+  }
+  mesh->DeduplicatePointIds();
+  if (!encoder_.EncodeMeshToBuffer(*mesh, &buffer).ok()) {
+    return 0;
+  }
+  draco_buffer->SetValues(buffer.data(), buffer.size());
+  return buffer.size();
+}
+
+int Encoder::EncodePointCloudToDracoBuffer(draco::PointCloud *pc,
+                                           bool deduplicate_values,
+                                           DracoInt8Array *draco_buffer) {
+  // TODO(ostava): Refactor common functionality with EncodeMeshToDracoBuffer().
+  if (!pc) {
+    return 0;
+  }
+  draco::EncoderBuffer buffer;
+  if (pc->GetNamedAttributeId(draco::GeometryAttribute::POSITION) == -1) {
+    return 0;
+  }
+  if (deduplicate_values) {
+    if (!pc->DeduplicateAttributeValues()) {
+      return 0;
+    }
+    pc->DeduplicatePointIds();
+  }
+  if (!encoder_.EncodePointCloudToBuffer(*pc, &buffer).ok()) {
+    return 0;
+  }
+  draco_buffer->SetValues(buffer.data(), buffer.size());
+  return buffer.size();
+}
+
+int Encoder::GetNumberOfEncodedPoints() {
+  return encoder_.num_encoded_points();
+}
+
+int Encoder::GetNumberOfEncodedFaces() { return encoder_.num_encoded_faces(); }
+
+ExpertEncoder::ExpertEncoder(PointCloud *pc) : pc_(pc) {
+  // Web-IDL interface does not support constructor overloading so instead we
+  // use RTTI to determine whether the input is a mesh or a point cloud.
+  Mesh *mesh = dynamic_cast<Mesh *>(pc);
+  if (mesh) {
+    encoder_ =
+        std::unique_ptr<draco::ExpertEncoder>(new draco::ExpertEncoder(*mesh));
+  } else {
+    encoder_ =
+        std::unique_ptr<draco::ExpertEncoder>(new draco::ExpertEncoder(*pc));
+  }
+}
+
+void ExpertEncoder::SetEncodingMethod(long method) {
+  encoder_->SetEncodingMethod(method);
+}
+
+void ExpertEncoder::SetAttributeQuantization(long att_id,
+                                             long quantization_bits) {
+  encoder_->SetAttributeQuantization(att_id, quantization_bits);
+}
+
+void ExpertEncoder::SetAttributeExplicitQuantization(long att_id,
+                                                     long quantization_bits,
+                                                     long num_components,
+                                                     const float *origin,
+                                                     float range) {
+  encoder_->SetAttributeExplicitQuantization(att_id, quantization_bits,
+                                             num_components, origin, range);
+}
+
+void ExpertEncoder::SetSpeedOptions(long encoding_speed, long decoding_speed) {
+  encoder_->SetSpeedOptions(encoding_speed, decoding_speed);
+}
+
+void ExpertEncoder::SetTrackEncodedProperties(bool flag) {
+  encoder_->SetTrackEncodedProperties(flag);
+}
+
+int ExpertEncoder::EncodeToDracoBuffer(bool deduplicate_values,
+                                       DracoInt8Array *draco_buffer) {
+  if (!pc_) {
+    return 0;
+  }
+  if (deduplicate_values) {
+    if (!pc_->DeduplicateAttributeValues()) {
+      return 0;
+    }
+    pc_->DeduplicatePointIds();
+  }
+
+  draco::EncoderBuffer buffer;
+  if (!encoder_->EncodeToBuffer(&buffer).ok()) {
+    return 0;
+  }
+  draco_buffer->SetValues(buffer.data(), buffer.size());
+  return buffer.size();
+}
+
+int ExpertEncoder::GetNumberOfEncodedPoints() {
+  return encoder_->num_encoded_points();
+}
+
+int ExpertEncoder::GetNumberOfEncodedFaces() {
+  return encoder_->num_encoded_faces();
+}
diff --git a/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.h b/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.h
new file mode 100644
index 000000000..b1cce7997
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/encoder_webidl_wrapper.h
@@ -0,0 +1,186 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_JAVASCRIPT_EMSCRIPTEN_ENCODER_WEBIDL_WRAPPER_H_
+#define DRACO_JAVASCRIPT_EMSCRIPTEN_ENCODER_WEBIDL_WRAPPER_H_
+
+#include <vector>
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/config/encoder_options.h"
+#include "draco/compression/encode.h"
+#include "draco/compression/expert_encode.h"
+#include "draco/mesh/mesh.h"
+
+typedef draco::GeometryAttribute draco_GeometryAttribute;
+typedef draco::GeometryAttribute::Type draco_GeometryAttribute_Type;
+typedef draco::EncodedGeometryType draco_EncodedGeometryType;
+typedef draco::MeshEncoderMethod draco_MeshEncoderMethod;
+
+class DracoInt8Array {
+ public:
+  DracoInt8Array();
+  int8_t GetValue(int index) const;
+  bool SetValues(const char *values, int count);
+
+  size_t size() { return values_.size(); }
+
+ private:
+  std::vector<int8_t> values_;
+};
+
+class MetadataBuilder {
+ public:
+  MetadataBuilder();
+  bool AddStringEntry(draco::Metadata *metadata, const char *entry_name,
+                      const char *entry_value);
+  bool AddIntEntry(draco::Metadata *metadata, const char *entry_name,
+                   long entry_value);
+  bool AddIntEntryArray(draco::Metadata *metadata, const char *entry_name,
+                        const int32_t *entry_values, int32_t num_values);
+  bool AddDoubleEntry(draco::Metadata *metadata, const char *entry_name,
+                      double entry_value);
+};
+
+class PointCloudBuilder {
+ public:
+  PointCloudBuilder() {}
+  int AddFloatAttribute(draco::PointCloud *pc,
+                        draco_GeometryAttribute_Type type, long num_vertices,
+                        long num_components, const float *att_values);
+  int AddInt8Attribute(draco::PointCloud *pc, draco_GeometryAttribute_Type type,
+                       long num_vertices, long num_components,
+                       const char *att_values);
+  int AddUInt8Attribute(draco::PointCloud *pc,
+                        draco_GeometryAttribute_Type type, long num_vertices,
+                        long num_components, const uint8_t *att_values);
+  int AddInt16Attribute(draco::PointCloud *pc,
+                        draco_GeometryAttribute_Type type, long num_vertices,
+                        long num_components, const int16_t *att_values);
+  int AddUInt16Attribute(draco::PointCloud *pc,
+                         draco_GeometryAttribute_Type type, long num_vertices,
+                         long num_components, const uint16_t *att_values);
+  int AddInt32Attribute(draco::PointCloud *pc,
+                        draco_GeometryAttribute_Type type, long num_vertices,
+                        long num_components, const int32_t *att_values);
+  int AddUInt32Attribute(draco::PointCloud *pc,
+                         draco_GeometryAttribute_Type type, long num_vertices,
+                         long num_components, const uint32_t *att_values);
+  bool SetMetadataForAttribute(draco::PointCloud *pc, long attribute_id,
+                               const draco::Metadata *metadata);
+  bool AddMetadata(draco::PointCloud *pc, const draco::Metadata *metadata);
+
+ private:
+  template <typename DataTypeT>
+  int AddAttribute(draco::PointCloud *pc, draco_GeometryAttribute_Type type,
+                   long num_vertices, long num_components,
+                   const DataTypeT *att_values,
+                   draco::DataType draco_data_type) {
+    if (!pc) {
+      return -1;
+    }
+    std::unique_ptr<draco::PointAttribute> att(new draco::PointAttribute());
+    att->Init(type, num_components, draco_data_type,
+              /* normalized */ false, num_vertices);
+    const int att_id = pc->AddAttribute(std::move(att));
+    draco::PointAttribute *const att_ptr = pc->attribute(att_id);
+
+    for (draco::PointIndex i(0); i < num_vertices; ++i) {
+      att_ptr->SetAttributeValue(att_ptr->mapped_index(i),
+                                 &att_values[i.value() * num_components]);
+    }
+    if (pc->num_points() == 0) {
+      pc->set_num_points(num_vertices);
+    } else if (pc->num_points() != num_vertices) {
+      return -1;
+    }
+    return att_id;
+  }
+};
+
+// TODO(draco-eng): Regenerate wasm decoder.
+// TODO(draco-eng): Add script to generate and test all Javascipt code.
+class MeshBuilder : public PointCloudBuilder {
+ public:
+  MeshBuilder();
+
+  bool AddFacesToMesh(draco::Mesh *mesh, long num_faces, const int *faces);
+
+  // Deprecated: Use AddFloatAttribute() instead.
+  int AddFloatAttributeToMesh(draco::Mesh *mesh,
+                              draco_GeometryAttribute_Type type,
+                              long num_vertices, long num_components,
+                              const float *att_values);
+
+  // Deprecated: Use AddInt32Attribute() instead.
+  int AddInt32AttributeToMesh(draco::Mesh *mesh,
+                              draco_GeometryAttribute_Type type,
+                              long num_vertices, long num_components,
+                              const int32_t *att_values);
+
+  // Deprecated: Use AddMetadata() instead.
+  bool AddMetadataToMesh(draco::Mesh *mesh, const draco::Metadata *metadata);
+};
+
+class Encoder {
+ public:
+  Encoder();
+
+  void SetEncodingMethod(long method);
+  void SetAttributeQuantization(draco_GeometryAttribute_Type type,
+                                long quantization_bits);
+  void SetAttributeExplicitQuantization(draco_GeometryAttribute_Type type,
+                                        long quantization_bits,
+                                        long num_components,
+                                        const float *origin, float range);
+  void SetSpeedOptions(long encoding_speed, long decoding_speed);
+  void SetTrackEncodedProperties(bool flag);
+
+  int EncodeMeshToDracoBuffer(draco::Mesh *mesh, DracoInt8Array *buffer);
+
+  int EncodePointCloudToDracoBuffer(draco::PointCloud *pc,
+                                    bool deduplicate_values,
+                                    DracoInt8Array *buffer);
+  int GetNumberOfEncodedPoints();
+  int GetNumberOfEncodedFaces();
+
+ private:
+  draco::Encoder encoder_;
+};
+
+class ExpertEncoder {
+ public:
+  ExpertEncoder(draco::PointCloud *pc);
+
+  void SetEncodingMethod(long method);
+  void SetAttributeQuantization(long att_id, long quantization_bits);
+  void SetAttributeExplicitQuantization(long att_id, long quantization_bits,
+                                        long num_components,
+                                        const float *origin, float range);
+  void SetSpeedOptions(long encoding_speed, long decoding_speed);
+  void SetTrackEncodedProperties(bool flag);
+
+  int EncodeToDracoBuffer(bool deduplicate_values, DracoInt8Array *buffer);
+
+  int GetNumberOfEncodedPoints();
+  int GetNumberOfEncodedFaces();
+
+ private:
+  std::unique_ptr<draco::ExpertEncoder> encoder_;
+
+  draco::PointCloud *pc_;
+};
+
+#endif  // DRACO_JAVASCRIPT_EMSCRIPTEN_ENCODER_WEBIDL_WRAPPER_H_
diff --git a/contrib/draco/src/draco/javascript/emscripten/finalize.js b/contrib/draco/src/draco/javascript/emscripten/finalize.js
new file mode 100644
index 000000000..fe2828e58
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/finalize.js
@@ -0,0 +1,22 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Calls the 'onModuleParsed' callback if provided. This file is included as the
+// last one in the generated javascript and it gives the caller a way to check
+// that all previous content was successfully processed.
+// Note: emscripten's |onRuntimeInitialized| is called before any --post-js
+// files are included which is not equivalent to this callback.
+if (typeof Module['onModuleParsed'] === 'function') {
+  Module['onModuleParsed']();
+}
diff --git a/contrib/draco/src/draco/javascript/emscripten/prepareCallbacks.js b/contrib/draco/src/draco/javascript/emscripten/prepareCallbacks.js
new file mode 100644
index 000000000..7e150bb3e
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/prepareCallbacks.js
@@ -0,0 +1,38 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Prepares callbacks that can be used to inform the caller that the module has
+// been fully loaded.
+var isRuntimeInitialized = false;
+var isModuleParsed = false;
+
+// These two callbacks can be called in arbitrary order. We call the final
+// function |onModuleLoaded| after both of these callbacks have been called.
+Module['onRuntimeInitialized'] = function() {
+  isRuntimeInitialized = true;
+  if (isModuleParsed) {
+    if (typeof Module['onModuleLoaded'] === 'function') {
+      Module['onModuleLoaded'](Module);
+    }
+  }
+};
+
+Module['onModuleParsed'] = function() {
+  isModuleParsed = true;
+  if (isRuntimeInitialized) {
+    if (typeof Module['onModuleLoaded'] === 'function') {
+      Module['onModuleLoaded'](Module);
+    }
+  }
+};
diff --git a/contrib/draco/src/draco/javascript/emscripten/version.js b/contrib/draco/src/draco/javascript/emscripten/version.js
new file mode 100644
index 000000000..46fb25271
--- /dev/null
+++ b/contrib/draco/src/draco/javascript/emscripten/version.js
@@ -0,0 +1,29 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Returns true if the specified Draco version is supported by this decoder.
+function isVersionSupported(versionString) {
+  if (typeof versionString !== 'string')
+    return false;
+  const version = versionString.split('.');
+  if (version.length < 2 || version.length > 3)
+    return false;  // Unexpected version string.
+  if (version[0] == 1 && version[1] >= 0 && version[1] <= 4)
+    return true;
+  if (version[0] != 0 || version[1] > 10)
+    return false;
+  return true;
+}
+
+Module['isVersionSupported'] = isVersionSupported;
diff --git a/contrib/draco/src/draco/maya/draco_maya_plugin.cc b/contrib/draco/src/draco/maya/draco_maya_plugin.cc
new file mode 100644
index 000000000..25b0240b2
--- /dev/null
+++ b/contrib/draco/src/draco/maya/draco_maya_plugin.cc
@@ -0,0 +1,265 @@
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/maya/draco_maya_plugin.h"
+
+#ifdef DRACO_MAYA_PLUGIN
+
+namespace draco {
+namespace maya {
+
+static void decode_faces(std::unique_ptr<draco::Mesh> &drc_mesh,
+                         Drc2PyMesh *out_mesh) {
+  int num_faces = drc_mesh->num_faces();
+  out_mesh->faces = new int[num_faces * 3];
+  out_mesh->faces_num = num_faces;
+  for (int i = 0; i < num_faces; i++) {
+    const draco::Mesh::Face &face = drc_mesh->face(draco::FaceIndex(i));
+    out_mesh->faces[i * 3 + 0] = face[0].value();
+    out_mesh->faces[i * 3 + 1] = face[1].value();
+    out_mesh->faces[i * 3 + 2] = face[2].value();
+  }
+}
+static void decode_vertices(std::unique_ptr<draco::Mesh> &drc_mesh,
+                            Drc2PyMesh *out_mesh) {
+  const auto pos_att =
+      drc_mesh->GetNamedAttribute(draco::GeometryAttribute::POSITION);
+  if (pos_att == nullptr) {
+    out_mesh->vertices = new float[0];
+    out_mesh->vertices_num = 0;
+    return;
+  }
+
+  int num_vertices = drc_mesh->num_points();
+  out_mesh->vertices = new float[num_vertices * 3];
+  out_mesh->vertices_num = num_vertices;
+  for (int i = 0; i < num_vertices; i++) {
+    draco::PointIndex pi(i);
+    const draco::AttributeValueIndex val_index = pos_att->mapped_index(pi);
+    float out_vertex[3];
+    bool is_ok = pos_att->ConvertValue<float, 3>(val_index, out_vertex);
+    if (!is_ok) return;
+    out_mesh->vertices[i * 3 + 0] = out_vertex[0];
+    out_mesh->vertices[i * 3 + 1] = out_vertex[1];
+    out_mesh->vertices[i * 3 + 2] = out_vertex[2];
+  }
+}
+static void decode_normals(std::unique_ptr<draco::Mesh> &drc_mesh,
+                           Drc2PyMesh *out_mesh) {
+  const auto normal_att =
+      drc_mesh->GetNamedAttribute(draco::GeometryAttribute::NORMAL);
+  if (normal_att == nullptr) {
+    out_mesh->normals = new float[0];
+    out_mesh->normals_num = 0;
+    return;
+  }
+  int num_normals = drc_mesh->num_points();
+  out_mesh->normals = new float[num_normals * 3];
+  out_mesh->normals_num = num_normals;
+
+  for (int i = 0; i < num_normals; i++) {
+    draco::PointIndex pi(i);
+    const draco::AttributeValueIndex val_index = normal_att->mapped_index(pi);
+    float out_normal[3];
+    bool is_ok = normal_att->ConvertValue<float, 3>(val_index, out_normal);
+    if (!is_ok) return;
+    out_mesh->normals[i * 3 + 0] = out_normal[0];
+    out_mesh->normals[i * 3 + 1] = out_normal[1];
+    out_mesh->normals[i * 3 + 2] = out_normal[2];
+  }
+}
+static void decode_uvs(std::unique_ptr<draco::Mesh> &drc_mesh,
+                       Drc2PyMesh *out_mesh) {
+  const auto uv_att =
+      drc_mesh->GetNamedAttribute(draco::GeometryAttribute::TEX_COORD);
+  if (uv_att == nullptr) {
+    out_mesh->uvs = new float[0];
+    out_mesh->uvs_num = 0;
+    out_mesh->uvs_real_num = 0;
+    return;
+  }
+  int num_uvs = drc_mesh->num_points();
+  out_mesh->uvs = new float[num_uvs * 2];
+  out_mesh->uvs_num = num_uvs;
+  out_mesh->uvs_real_num = uv_att->size();
+
+  for (int i = 0; i < num_uvs; i++) {
+    draco::PointIndex pi(i);
+    const draco::AttributeValueIndex val_index = uv_att->mapped_index(pi);
+    float out_uv[2];
+    bool is_ok = uv_att->ConvertValue<float, 2>(val_index, out_uv);
+    if (!is_ok) return;
+    out_mesh->uvs[i * 2 + 0] = out_uv[0];
+    out_mesh->uvs[i * 2 + 1] = out_uv[1];
+  }
+}
+
+void drc2py_free(Drc2PyMesh **mesh_ptr) {
+  Drc2PyMesh *mesh = *mesh_ptr;
+  if (!mesh) return;
+  if (mesh->faces) {
+    delete[] mesh->faces;
+    mesh->faces = nullptr;
+    mesh->faces_num = 0;
+  }
+  if (mesh->vertices) {
+    delete[] mesh->vertices;
+    mesh->vertices = nullptr;
+    mesh->vertices_num = 0;
+  }
+  if (mesh->normals) {
+    delete[] mesh->normals;
+    mesh->normals = nullptr;
+    mesh->normals_num = 0;
+  }
+  if (mesh->uvs) {
+    delete[] mesh->uvs;
+    mesh->uvs = nullptr;
+    mesh->uvs_num = 0;
+  }
+  delete mesh;
+  *mesh_ptr = nullptr;
+}
+
+DecodeResult drc2py_decode(char *data, unsigned int length,
+                           Drc2PyMesh **res_mesh) {
+  draco::DecoderBuffer buffer;
+  buffer.Init(data, length);
+  auto type_statusor = draco::Decoder::GetEncodedGeometryType(&buffer);
+  if (!type_statusor.ok()) {
+    return DecodeResult::KO_GEOMETRY_TYPE_INVALID;
+  }
+  const draco::EncodedGeometryType geom_type = type_statusor.value();
+  if (geom_type != draco::TRIANGULAR_MESH) {
+    return DecodeResult::KO_TRIANGULAR_MESH_NOT_FOUND;
+  }
+
+  draco::Decoder decoder;
+  auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
+  if (!statusor.ok()) {
+    return DecodeResult::KO_MESH_DECODING;
+  }
+  std::unique_ptr<draco::Mesh> drc_mesh = std::move(statusor).value();
+
+  *res_mesh = new Drc2PyMesh();
+  decode_faces(drc_mesh, *res_mesh);
+  decode_vertices(drc_mesh, *res_mesh);
+  decode_normals(drc_mesh, *res_mesh);
+  decode_uvs(drc_mesh, *res_mesh);
+  return DecodeResult::OK;
+}
+
+// As encode references see https://github.com/google/draco/issues/116
+EncodeResult drc2py_encode(Drc2PyMesh *in_mesh, char *file_path) {
+  if (in_mesh->faces_num == 0) return EncodeResult::KO_WRONG_INPUT;
+  if (in_mesh->vertices_num == 0) return EncodeResult::KO_WRONG_INPUT;
+  // TODO: Add check to protect against quad faces. At the moment only
+  // Triangular faces are supported
+
+  std::unique_ptr<draco::Mesh> drc_mesh(new draco::Mesh());
+
+  // Marshall Faces
+  int num_faces = in_mesh->faces_num;
+  drc_mesh->SetNumFaces(num_faces);
+  for (int i = 0; i < num_faces; ++i) {
+    Mesh::Face face;
+    face[0] = in_mesh->faces[i * 3 + 0];
+    face[1] = in_mesh->faces[i * 3 + 1];
+    face[2] = in_mesh->faces[i * 3 + 2];
+    drc_mesh->SetFace(FaceIndex(i), face);
+  }
+
+  // Marshall Vertices
+  int num_points = in_mesh->vertices_num;
+  drc_mesh->set_num_points(num_points);
+  GeometryAttribute va;
+  va.Init(GeometryAttribute::POSITION, nullptr, 3, DT_FLOAT32, false,
+          sizeof(float) * 3, 0);
+  int pos_att_id = drc_mesh->AddAttribute(va, true, num_points);
+  float point[3];
+  for (int i = 0; i < num_points; ++i) {
+    point[0] = in_mesh->vertices[i * 3 + 0];
+    point[1] = in_mesh->vertices[i * 3 + 1];
+    point[2] = in_mesh->vertices[i * 3 + 2];
+    drc_mesh->attribute(pos_att_id)
+        ->SetAttributeValue(AttributeValueIndex(i), point);
+  }
+
+  // Marshall Normals
+  int num_normals = in_mesh->normals_num;
+  int norm_att_id;
+  if (num_normals > 0) {
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::NORMAL, nullptr, 3, DT_FLOAT32, false,
+            sizeof(float) * 3, 0);
+    norm_att_id = drc_mesh->AddAttribute(va, true, num_normals);
+
+    float norm[3];
+    for (int i = 0; i < num_normals; ++i) {
+      norm[0] = in_mesh->normals[i * 3 + 0];
+      norm[1] = in_mesh->normals[i * 3 + 1];
+      norm[2] = in_mesh->normals[i * 3 + 2];
+      drc_mesh->attribute(norm_att_id)
+          ->SetAttributeValue(AttributeValueIndex(i), norm);
+    }
+  }
+
+  // Marshall Uvs
+  int num_uvs = in_mesh->uvs_num;
+  int uv_att_id;
+  if (num_uvs > 0) {
+    GeometryAttribute va;
+    va.Init(GeometryAttribute::TEX_COORD, nullptr, 2, DT_FLOAT32, false,
+            sizeof(float) * 2, 0);
+    uv_att_id = drc_mesh->AddAttribute(va, true, num_uvs);
+    float uv[3];
+    for (int i = 0; i < num_uvs; ++i) {
+      uv[0] = in_mesh->uvs[i * 2 + 0];
+      uv[1] = in_mesh->uvs[i * 2 + 1];
+      drc_mesh->attribute(uv_att_id)->SetAttributeValue(AttributeValueIndex(i),
+                                                        uv);
+    }
+  }
+
+// Deduplicate Attributes and Points
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  drc_mesh->DeduplicateAttributeValues();
+#endif
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  drc_mesh->DeduplicatePointIds();
+#endif
+
+  // Encode Mesh
+  draco::Encoder encoder;  // Use default encode settings (See draco_encoder.cc
+                           // Options struct)
+  draco::EncoderBuffer buffer;
+  const draco::Status status = encoder.EncodeMeshToBuffer(*drc_mesh, &buffer);
+  if (!status.ok()) {
+    // Use status.error_msg() to check the error
+    return EncodeResult::KO_MESH_ENCODING;
+  }
+
+  // Save to file
+  std::string file = file_path;
+  std::ofstream out_file(file, std::ios::binary);
+  if (!out_file) {
+    return EncodeResult::KO_FILE_CREATION;
+  }
+  out_file.write(buffer.data(), buffer.size());
+  return EncodeResult::OK;
+}
+
+}  // namespace maya
+
+}  // namespace draco
+
+#endif  // DRACO_MAYA_PLUGIN
diff --git a/contrib/draco/src/draco/maya/draco_maya_plugin.h b/contrib/draco/src/draco/maya/draco_maya_plugin.h
new file mode 100644
index 000000000..372e25fbf
--- /dev/null
+++ b/contrib/draco/src/draco/maya/draco_maya_plugin.h
@@ -0,0 +1,81 @@
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MAYA_DRACO_MAYA_PLUGIN_H_
+#define DRACO_MAYA_DRACO_MAYA_PLUGIN_H_
+
+#include <fstream>
+
+#include "draco/compression/decode.h"
+#include "draco/compression/encode.h"
+
+#ifdef DRACO_MAYA_PLUGIN
+
+// If compiling with Visual Studio.
+#if defined(_MSC_VER)
+#define EXPORT_API __declspec(dllexport)
+#else
+// Other platforms don't need this.
+#define EXPORT_API
+#endif  // defined(_MSC_VER)
+
+namespace draco {
+namespace maya {
+
+enum class EncodeResult {
+  OK = 0,
+  KO_WRONG_INPUT = -1,
+  KO_MESH_ENCODING = -2,
+  KO_FILE_CREATION = -3
+};
+enum class DecodeResult {
+  OK = 0,
+  KO_GEOMETRY_TYPE_INVALID = -1,
+  KO_TRIANGULAR_MESH_NOT_FOUND = -2,
+  KO_MESH_DECODING = -3
+};
+
+extern "C" {
+struct EXPORT_API Drc2PyMesh {
+  Drc2PyMesh()
+      : faces_num(0),
+        faces(nullptr),
+        vertices_num(0),
+        vertices(nullptr),
+        normals_num(0),
+        normals(nullptr),
+        uvs_num(0),
+        uvs_real_num(0),
+        uvs(nullptr) {}
+  int faces_num;
+  int *faces;
+  int vertices_num;
+  float *vertices;
+  int normals_num;
+  float *normals;
+  int uvs_num;
+  int uvs_real_num;
+  float *uvs;
+};
+
+EXPORT_API DecodeResult drc2py_decode(char *data, unsigned int length,
+                                      Drc2PyMesh **res_mesh);
+EXPORT_API void drc2py_free(Drc2PyMesh **res_mesh);
+EXPORT_API EncodeResult drc2py_encode(Drc2PyMesh *in_mesh, char *file_path);
+}  // extern "C"
+
+}  // namespace maya
+}  // namespace draco
+
+#endif  // DRACO_MAYA_PLUGIN
+
+#endif  // DRACO_MAYA_DRACO_MAYA_PLUGIN_H_
diff --git a/contrib/draco/src/draco/mesh/corner_table.cc b/contrib/draco/src/draco/mesh/corner_table.cc
new file mode 100644
index 000000000..3f92f651a
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/corner_table.cc
@@ -0,0 +1,441 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/corner_table.h"
+
+#include <limits>
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/mesh/corner_table_iterators.h"
+
+namespace draco {
+
+CornerTable::CornerTable()
+    : num_original_vertices_(0),
+      num_degenerated_faces_(0),
+      num_isolated_vertices_(0),
+      valence_cache_(*this) {}
+
+std::unique_ptr<CornerTable> CornerTable::Create(
+    const IndexTypeVector<FaceIndex, FaceType> &faces) {
+  std::unique_ptr<CornerTable> ct(new CornerTable());
+  if (!ct->Init(faces)) {
+    return nullptr;
+  }
+  return ct;
+}
+
+bool CornerTable::Init(const IndexTypeVector<FaceIndex, FaceType> &faces) {
+  valence_cache_.ClearValenceCache();
+  valence_cache_.ClearValenceCacheInaccurate();
+  corner_to_vertex_map_.resize(faces.size() * 3);
+  for (FaceIndex fi(0); fi < static_cast<uint32_t>(faces.size()); ++fi) {
+    for (int i = 0; i < 3; ++i) {
+      corner_to_vertex_map_[FirstCorner(fi) + i] = faces[fi][i];
+    }
+  }
+  int num_vertices = -1;
+  if (!ComputeOppositeCorners(&num_vertices)) {
+    return false;
+  }
+  if (!BreakNonManifoldEdges()) {
+    return false;
+  }
+  if (!ComputeVertexCorners(num_vertices)) {
+    return false;
+  }
+  return true;
+}
+
+bool CornerTable::Reset(int num_faces) {
+  return Reset(num_faces, num_faces * 3);
+}
+
+bool CornerTable::Reset(int num_faces, int num_vertices) {
+  if (num_faces < 0 || num_vertices < 0) {
+    return false;
+  }
+  const unsigned int num_faces_unsigned = num_faces;
+  if (num_faces_unsigned >
+      std::numeric_limits<CornerIndex::ValueType>::max() / 3) {
+    return false;
+  }
+  corner_to_vertex_map_.assign(num_faces_unsigned * 3, kInvalidVertexIndex);
+  opposite_corners_.assign(num_faces_unsigned * 3, kInvalidCornerIndex);
+  vertex_corners_.reserve(num_vertices);
+  valence_cache_.ClearValenceCache();
+  valence_cache_.ClearValenceCacheInaccurate();
+  return true;
+}
+
+bool CornerTable::ComputeOppositeCorners(int *num_vertices) {
+  DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+  if (num_vertices == nullptr) {
+    return false;
+  }
+  opposite_corners_.resize(num_corners(), kInvalidCornerIndex);
+
+  // Out implementation for finding opposite corners is based on keeping track
+  // of outgoing half-edges for each vertex of the mesh. Half-edges (defined by
+  // their opposite corners) are processed one by one and whenever a new
+  // half-edge (corner) is processed, we check whether the sink vertex of
+  // this half-edge contains its sibling half-edge. If yes, we connect them and
+  // remove the sibling half-edge from the sink vertex, otherwise we add the new
+  // half-edge to its source vertex.
+
+  // First compute the number of outgoing half-edges (corners) attached to each
+  // vertex.
+  std::vector<int> num_corners_on_vertices;
+  num_corners_on_vertices.reserve(num_corners());
+  for (CornerIndex c(0); c < num_corners(); ++c) {
+    const VertexIndex v1 = Vertex(c);
+    if (v1.value() >= static_cast<int>(num_corners_on_vertices.size())) {
+      num_corners_on_vertices.resize(v1.value() + 1, 0);
+    }
+    // For each corner there is always exactly one outgoing half-edge attached
+    // to its vertex.
+    num_corners_on_vertices[v1.value()]++;
+  }
+
+  // Create a storage for half-edges on each vertex. We store all half-edges in
+  // one array, where each entry is identified by the half-edge's sink vertex id
+  // and the associated half-edge corner id (corner opposite to the half-edge).
+  // Each vertex will be assigned storage for up to
+  // |num_corners_on_vertices[vert_id]| half-edges. Unused half-edges are marked
+  // with |sink_vert| == kInvalidVertexIndex.
+  struct VertexEdgePair {
+    VertexEdgePair()
+        : sink_vert(kInvalidVertexIndex), edge_corner(kInvalidCornerIndex) {}
+    VertexIndex sink_vert;
+    CornerIndex edge_corner;
+  };
+  std::vector<VertexEdgePair> vertex_edges(num_corners(), VertexEdgePair());
+
+  // For each vertex compute the offset (location where the first half-edge
+  // entry of a given vertex is going to be stored). This way each vertex is
+  // guaranteed to have a non-overlapping storage with respect to the other
+  // vertices.
+  std::vector<int> vertex_offset(num_corners_on_vertices.size());
+  int offset = 0;
+  for (size_t i = 0; i < num_corners_on_vertices.size(); ++i) {
+    vertex_offset[i] = offset;
+    offset += num_corners_on_vertices[i];
+  }
+
+  // Now go over the all half-edges (using their opposite corners) and either
+  // insert them to the |vertex_edge| array or connect them with existing
+  // half-edges.
+  for (CornerIndex c(0); c < num_corners(); ++c) {
+    const VertexIndex tip_v = Vertex(c);
+    const VertexIndex source_v = Vertex(Next(c));
+    const VertexIndex sink_v = Vertex(Previous(c));
+
+    const FaceIndex face_index = Face(c);
+    if (c == FirstCorner(face_index)) {
+      // Check whether the face is degenerated, if so ignore it.
+      const VertexIndex v0 = Vertex(c);
+      if (v0 == source_v || v0 == sink_v || source_v == sink_v) {
+        ++num_degenerated_faces_;
+        c += 2;  // Ignore the next two corners of the same face.
+        continue;
+      }
+    }
+
+    CornerIndex opposite_c(kInvalidCornerIndex);
+    // The maximum number of half-edges attached to the sink vertex.
+    const int num_corners_on_vert = num_corners_on_vertices[sink_v.value()];
+    // Where to look for the first half-edge on the sink vertex.
+    offset = vertex_offset[sink_v.value()];
+    for (int i = 0; i < num_corners_on_vert; ++i, ++offset) {
+      const VertexIndex other_v = vertex_edges[offset].sink_vert;
+      if (other_v == kInvalidVertexIndex) {
+        break;  // No matching half-edge found on the sink vertex.
+      }
+      if (other_v == source_v) {
+        if (tip_v == Vertex(vertex_edges[offset].edge_corner)) {
+          continue;  // Don't connect mirrored faces.
+        }
+        // A matching half-edge was found on the sink vertex. Mark the
+        // half-edge's opposite corner.
+        opposite_c = vertex_edges[offset].edge_corner;
+        // Remove the half-edge from the sink vertex. We remap all subsequent
+        // half-edges one slot down.
+        // TODO(ostava): This can be optimized a little bit, by remapping only
+        // the half-edge on the last valid slot into the deleted half-edge's
+        // slot.
+        for (int j = i + 1; j < num_corners_on_vert; ++j, ++offset) {
+          vertex_edges[offset] = vertex_edges[offset + 1];
+          if (vertex_edges[offset].sink_vert == kInvalidVertexIndex) {
+            break;  // Unused half-edge reached.
+          }
+        }
+        // Mark the last entry as unused.
+        vertex_edges[offset].sink_vert = kInvalidVertexIndex;
+        break;
+      }
+    }
+    if (opposite_c == kInvalidCornerIndex) {
+      // No opposite corner found. Insert the new edge
+      const int num_corners_on_source_vert =
+          num_corners_on_vertices[source_v.value()];
+      offset = vertex_offset[source_v.value()];
+      for (int i = 0; i < num_corners_on_source_vert; ++i, ++offset) {
+        // Find the first unused half-edge slot on the source vertex.
+        if (vertex_edges[offset].sink_vert == kInvalidVertexIndex) {
+          vertex_edges[offset].sink_vert = sink_v;
+          vertex_edges[offset].edge_corner = c;
+          break;
+        }
+      }
+    } else {
+      // Opposite corner found.
+      opposite_corners_[c] = opposite_c;
+      opposite_corners_[opposite_c] = c;
+    }
+  }
+  *num_vertices = static_cast<int>(num_corners_on_vertices.size());
+  return true;
+}
+
+bool CornerTable::BreakNonManifoldEdges() {
+  // This function detects and breaks non-manifold edges that are caused by
+  // folds in 1-ring neighborhood around a vertex. Non-manifold edges can occur
+  // when the 1-ring surface around a vertex self-intersects in a common edge.
+  // For example imagine a surface around a pivot vertex 0, where the 1-ring
+  // is defined by vertices |1, 2, 3, 1, 4|. The surface passes edge <0, 1>
+  // twice which would result in a non-manifold edge that needs to be broken.
+  // For now all faces connected to these non-manifold edges are disconnected
+  // resulting in open boundaries on the mesh. New vertices will be created
+  // automatically for each new disjoint patch in the ComputeVertexCorners()
+  // method.
+  // Note that all other non-manifold edges are implicitly handled by the
+  // function ComputeVertexCorners() that automatically creates new vertices
+  // on disjoint 1-ring surface patches.
+
+  std::vector<bool> visited_corners(num_corners(), false);
+  std::vector<std::pair<VertexIndex, CornerIndex>> sink_vertices;
+  bool mesh_connectivity_updated = false;
+  do {
+    mesh_connectivity_updated = false;
+    for (CornerIndex c(0); c < num_corners(); ++c) {
+      if (visited_corners[c.value()]) {
+        continue;
+      }
+      sink_vertices.clear();
+
+      // First swing all the way to find the left-most corner connected to the
+      // corner's vertex.
+      CornerIndex first_c = c;
+      CornerIndex current_c = c;
+      CornerIndex next_c;
+      while (next_c = SwingLeft(current_c),
+             next_c != first_c && next_c != kInvalidCornerIndex &&
+                 !visited_corners[next_c.value()]) {
+        current_c = next_c;
+      }
+
+      first_c = current_c;
+
+      // Swing right from the first corner and check if all visited edges
+      // are unique.
+      do {
+        visited_corners[current_c.value()] = true;
+        // Each new edge is defined by the pivot vertex (that is the same for
+        // all faces) and by the sink vertex (that is the |next| vertex from the
+        // currently processed pivot corner. I.e., each edge is uniquely defined
+        // by the sink vertex index.
+        const CornerIndex sink_c = Next(current_c);
+        const VertexIndex sink_v = corner_to_vertex_map_[sink_c];
+
+        // Corner that defines the edge on the face.
+        const CornerIndex edge_corner = Previous(current_c);
+        bool vertex_connectivity_updated = false;
+        // Go over all processed edges (sink vertices). If the current sink
+        // vertex has been already encountered before it may indicate a
+        // non-manifold edge that needs to be broken.
+        for (auto &&attached_sink_vertex : sink_vertices) {
+          if (attached_sink_vertex.first == sink_v) {
+            // Sink vertex has been already processed.
+            const CornerIndex other_edge_corner = attached_sink_vertex.second;
+            const CornerIndex opp_edge_corner = Opposite(edge_corner);
+
+            if (opp_edge_corner == other_edge_corner) {
+              // We are closing the loop so no need to change the connectivity.
+              continue;
+            }
+
+            // Break the connectivity on the non-manifold edge.
+            // TODO(ostava): It may be possible to reconnect the faces in a way
+            // that the final surface would be manifold.
+            const CornerIndex opp_other_edge_corner =
+                Opposite(other_edge_corner);
+            if (opp_edge_corner != kInvalidCornerIndex) {
+              SetOppositeCorner(opp_edge_corner, kInvalidCornerIndex);
+            }
+            if (opp_other_edge_corner != kInvalidCornerIndex) {
+              SetOppositeCorner(opp_other_edge_corner, kInvalidCornerIndex);
+            }
+
+            SetOppositeCorner(edge_corner, kInvalidCornerIndex);
+            SetOppositeCorner(other_edge_corner, kInvalidCornerIndex);
+
+            vertex_connectivity_updated = true;
+            break;
+          }
+        }
+        if (vertex_connectivity_updated) {
+          // Because of the updated connectivity, not all corners connected to
+          // this vertex have been processed and we need to go over them again.
+          // TODO(ostava): This can be optimized as we don't really need to
+          // iterate over all corners.
+          mesh_connectivity_updated = true;
+          break;
+        }
+        // Insert new sink vertex information <sink vertex index, edge corner>.
+        std::pair<VertexIndex, CornerIndex> new_sink_vert;
+        new_sink_vert.first = corner_to_vertex_map_[Previous(current_c)];
+        new_sink_vert.second = sink_c;
+        sink_vertices.push_back(new_sink_vert);
+
+        current_c = SwingRight(current_c);
+      } while (current_c != first_c && current_c != kInvalidCornerIndex);
+    }
+  } while (mesh_connectivity_updated);
+  return true;
+}
+
+bool CornerTable::ComputeVertexCorners(int num_vertices) {
+  DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+  num_original_vertices_ = num_vertices;
+  vertex_corners_.resize(num_vertices, kInvalidCornerIndex);
+  // Arrays for marking visited vertices and corners that allow us to detect
+  // non-manifold vertices.
+  std::vector<bool> visited_vertices(num_vertices, false);
+  std::vector<bool> visited_corners(num_corners(), false);
+
+  for (FaceIndex f(0); f < num_faces(); ++f) {
+    const CornerIndex first_face_corner = FirstCorner(f);
+    // Check whether the face is degenerated. If so ignore it.
+    if (IsDegenerated(f)) {
+      continue;
+    }
+
+    for (int k = 0; k < 3; ++k) {
+      const CornerIndex c = first_face_corner + k;
+      if (visited_corners[c.value()]) {
+        continue;
+      }
+      VertexIndex v = corner_to_vertex_map_[c];
+      // Note that one vertex maps to many corners, but we just keep track
+      // of the vertex which has a boundary on the left if the vertex lies on
+      // the boundary. This means that all the related corners can be accessed
+      // by iterating over the SwingRight() operator.
+      // In case of a vertex inside the mesh, the choice is arbitrary.
+      bool is_non_manifold_vertex = false;
+      if (visited_vertices[v.value()]) {
+        // A visited vertex of an unvisited corner found. Must be a non-manifold
+        // vertex.
+        // Create a new vertex for it.
+        vertex_corners_.push_back(kInvalidCornerIndex);
+        non_manifold_vertex_parents_.push_back(v);
+        visited_vertices.push_back(false);
+        v = VertexIndex(num_vertices++);
+        is_non_manifold_vertex = true;
+      }
+      // Mark the vertex as visited.
+      visited_vertices[v.value()] = true;
+
+      // First swing all the way to the left and mark all corners on the way.
+      CornerIndex act_c(c);
+      while (act_c != kInvalidCornerIndex) {
+        visited_corners[act_c.value()] = true;
+        // Vertex will eventually point to the left most corner.
+        vertex_corners_[v] = act_c;
+        if (is_non_manifold_vertex) {
+          // Update vertex index in the corresponding face.
+          corner_to_vertex_map_[act_c] = v;
+        }
+        act_c = SwingLeft(act_c);
+        if (act_c == c) {
+          break;  // Full circle reached.
+        }
+      }
+      if (act_c == kInvalidCornerIndex) {
+        // If we have reached an open boundary we need to swing right from the
+        // initial corner to mark all corners in the opposite direction.
+        act_c = SwingRight(c);
+        while (act_c != kInvalidCornerIndex) {
+          visited_corners[act_c.value()] = true;
+          if (is_non_manifold_vertex) {
+            // Update vertex index in the corresponding face.
+            corner_to_vertex_map_[act_c] = v;
+          }
+          act_c = SwingRight(act_c);
+        }
+      }
+    }
+  }
+
+  // Count the number of isolated (unprocessed) vertices.
+  num_isolated_vertices_ = 0;
+  for (bool visited : visited_vertices) {
+    if (!visited) {
+      ++num_isolated_vertices_;
+    }
+  }
+  return true;
+}
+
+bool CornerTable::IsDegenerated(FaceIndex face) const {
+  if (face == kInvalidFaceIndex) {
+    return true;
+  }
+  const CornerIndex first_face_corner = FirstCorner(face);
+  const VertexIndex v0 = Vertex(first_face_corner);
+  const VertexIndex v1 = Vertex(Next(first_face_corner));
+  const VertexIndex v2 = Vertex(Previous(first_face_corner));
+  if (v0 == v1 || v0 == v2 || v1 == v2) {
+    return true;
+  }
+  return false;
+}
+
+int CornerTable::Valence(VertexIndex v) const {
+  if (v == kInvalidVertexIndex) {
+    return -1;
+  }
+  return ConfidentValence(v);
+}
+
+int CornerTable::ConfidentValence(VertexIndex v) const {
+  DRACO_DCHECK_GE(v.value(), 0);
+  DRACO_DCHECK_LT(v.value(), num_vertices());
+  VertexRingIterator<CornerTable> vi(this, v);
+  int valence = 0;
+  for (; !vi.End(); vi.Next()) {
+    ++valence;
+  }
+  return valence;
+}
+
+void CornerTable::UpdateFaceToVertexMap(const VertexIndex vertex) {
+  DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+  VertexCornersIterator<CornerTable> it(this, vertex);
+  for (; !it.End(); ++it) {
+    const CornerIndex corner = *it;
+    corner_to_vertex_map_[corner] = vertex;
+  }
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/mesh/corner_table.h b/contrib/draco/src/draco/mesh/corner_table.h
new file mode 100644
index 000000000..3aa720fde
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/corner_table.h
@@ -0,0 +1,396 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_CORNER_TABLE_H_
+#define DRACO_MESH_CORNER_TABLE_H_
+
+#include <array>
+#include <memory>
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/draco_index_type_vector.h"
+#include "draco/core/macros.h"
+#include "draco/mesh/valence_cache.h"
+
+namespace draco {
+
+// CornerTable is used to represent connectivity of triangular meshes.
+// For every corner of all faces, the corner table stores the index of the
+// opposite corner in the neighboring face (if it exists) as illustrated in the
+// figure below (see corner |c| and it's opposite corner |o|).
+//
+//     *
+//    /c\
+//   /   \
+//  /n   p\
+// *-------*
+//  \     /
+//   \   /
+//    \o/
+//     *
+//
+// All corners are defined by unique CornerIndex and each triplet of corners
+// that define a single face id always ordered consecutively as:
+//     { 3 * FaceIndex, 3 * FaceIndex + 1, 3 * FaceIndex +2 }.
+// This representation of corners allows CornerTable to easily retrieve Next and
+// Previous corners on any face (see corners |n| and |p| in the figure above).
+// Using the Next, Previous, and Opposite corners then enables traversal of any
+// 2-manifold surface.
+// If the CornerTable is constructed from a non-manifold surface, the input
+// non-manifold edges and vertices are automatically split.
+class CornerTable {
+ public:
+  // Corner table face type.
+  typedef std::array<VertexIndex, 3> FaceType;
+
+  CornerTable();
+  static std::unique_ptr<CornerTable> Create(
+      const IndexTypeVector<FaceIndex, FaceType> &faces);
+
+  // Initializes the CornerTable from provides set of indexed faces.
+  // The input faces can represent a non-manifold topology, in which case the
+  // non-manifold edges and vertices are going to be split.
+  bool Init(const IndexTypeVector<FaceIndex, FaceType> &faces);
+
+  // Resets the corner table to the given number of invalid faces.
+  bool Reset(int num_faces);
+
+  // Resets the corner table to the given number of invalid faces and vertices.
+  bool Reset(int num_faces, int num_vertices);
+
+  inline int num_vertices() const {
+    return static_cast<int>(vertex_corners_.size());
+  }
+  inline int num_corners() const {
+    return static_cast<int>(corner_to_vertex_map_.size());
+  }
+  inline int num_faces() const {
+    return static_cast<int>(corner_to_vertex_map_.size() / 3);
+  }
+
+  inline CornerIndex Opposite(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return corner;
+    }
+    return opposite_corners_[corner];
+  }
+  inline CornerIndex Next(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return corner;
+    }
+    return LocalIndex(++corner) ? corner : corner - 3;
+  }
+  inline CornerIndex Previous(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return corner;
+    }
+    return LocalIndex(corner) ? corner - 1 : corner + 2;
+  }
+  inline VertexIndex Vertex(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return kInvalidVertexIndex;
+    }
+    return ConfidentVertex(corner);
+  }
+  inline VertexIndex ConfidentVertex(CornerIndex corner) const {
+    DRACO_DCHECK_GE(corner.value(), 0);
+    DRACO_DCHECK_LT(corner.value(), num_corners());
+    return corner_to_vertex_map_[corner];
+  }
+  inline FaceIndex Face(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex) {
+      return kInvalidFaceIndex;
+    }
+    return FaceIndex(corner.value() / 3);
+  }
+  inline CornerIndex FirstCorner(FaceIndex face) const {
+    if (face == kInvalidFaceIndex) {
+      return kInvalidCornerIndex;
+    }
+    return CornerIndex(face.value() * 3);
+  }
+  inline std::array<CornerIndex, 3> AllCorners(FaceIndex face) const {
+    const CornerIndex ci = CornerIndex(face.value() * 3);
+    return {{ci, ci + 1, ci + 2}};
+  }
+  inline int LocalIndex(CornerIndex corner) const { return corner.value() % 3; }
+
+  inline FaceType FaceData(FaceIndex face) const {
+    const CornerIndex first_corner = FirstCorner(face);
+    FaceType face_data;
+    for (int i = 0; i < 3; ++i) {
+      face_data[i] = corner_to_vertex_map_[first_corner + i];
+    }
+    return face_data;
+  }
+
+  void SetFaceData(FaceIndex face, FaceType data) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    const CornerIndex first_corner = FirstCorner(face);
+    for (int i = 0; i < 3; ++i) {
+      corner_to_vertex_map_[first_corner + i] = data[i];
+    }
+  }
+
+  // Returns the left-most corner of a single vertex 1-ring. If a vertex is not
+  // on a boundary (in which case it has a full 1-ring), this function returns
+  // any of the corners mapped to the given vertex.
+  inline CornerIndex LeftMostCorner(VertexIndex v) const {
+    return vertex_corners_[v];
+  }
+
+  // Returns the parent vertex index of a given corner table vertex.
+  VertexIndex VertexParent(VertexIndex vertex) const {
+    if (vertex.value() < static_cast<uint32_t>(num_original_vertices_)) {
+      return vertex;
+    }
+    return non_manifold_vertex_parents_[vertex - num_original_vertices_];
+  }
+
+  // Returns true if the corner is valid.
+  inline bool IsValid(CornerIndex c) const {
+    return Vertex(c) != kInvalidVertexIndex;
+  }
+
+  // Returns the valence (or degree) of a vertex.
+  // Returns -1 if the given vertex index is not valid.
+  int Valence(VertexIndex v) const;
+  // Same as above but does not check for validity and does not return -1
+  int ConfidentValence(VertexIndex v) const;
+  // Returns the valence of the vertex at the given corner.
+  inline int Valence(CornerIndex c) const {
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ConfidentValence(c);
+  }
+  inline int ConfidentValence(CornerIndex c) const {
+    DRACO_DCHECK_LT(c.value(), num_corners());
+    return ConfidentValence(ConfidentVertex(c));
+  }
+
+  // Returns true if the specified vertex is on a boundary.
+  inline bool IsOnBoundary(VertexIndex vert) const {
+    const CornerIndex corner = LeftMostCorner(vert);
+    if (SwingLeft(corner) == kInvalidCornerIndex) {
+      return true;
+    }
+    return false;
+  }
+
+  //     *-------*
+  //    / \     / \
+  //   /   \   /   \
+  //  /   sl\c/sr   \
+  // *-------v-------*
+  // Returns the corner on the adjacent face on the right that maps to
+  // the same vertex as the given corner (sr in the above diagram).
+  inline CornerIndex SwingRight(CornerIndex corner) const {
+    return Previous(Opposite(Previous(corner)));
+  }
+  // Returns the corner on the left face that maps to the same vertex as the
+  // given corner (sl in the above diagram).
+  inline CornerIndex SwingLeft(CornerIndex corner) const {
+    return Next(Opposite(Next(corner)));
+  }
+
+  // Get opposite corners on the left and right faces respectively (see image
+  // below, where L and R are the left and right corners of a corner X.
+  //
+  // *-------*-------*
+  //  \L    /X\    R/
+  //   \   /   \   /
+  //    \ /     \ /
+  //     *-------*
+  inline CornerIndex GetLeftCorner(CornerIndex corner_id) const {
+    if (corner_id == kInvalidCornerIndex) {
+      return kInvalidCornerIndex;
+    }
+    return Opposite(Previous(corner_id));
+  }
+  inline CornerIndex GetRightCorner(CornerIndex corner_id) const {
+    if (corner_id == kInvalidCornerIndex) {
+      return kInvalidCornerIndex;
+    }
+    return Opposite(Next(corner_id));
+  }
+
+  // Returns the number of new vertices that were created as a result of
+  // splitting of non-manifold vertices of the input geometry.
+  int NumNewVertices() const { return num_vertices() - num_original_vertices_; }
+  int NumOriginalVertices() const { return num_original_vertices_; }
+
+  // Returns the number of faces with duplicated vertex indices.
+  int NumDegeneratedFaces() const { return num_degenerated_faces_; }
+
+  // Returns the number of isolated vertices (vertices that have
+  // vertex_corners_ mapping set to kInvalidCornerIndex.
+  int NumIsolatedVertices() const { return num_isolated_vertices_; }
+
+  bool IsDegenerated(FaceIndex face) const;
+
+  // Methods that modify an existing corner table.
+  // Sets the opposite corner mapping between two corners. Caller must ensure
+  // that the indices are valid.
+  inline void SetOppositeCorner(CornerIndex corner_id,
+                                CornerIndex opp_corner_id) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    opposite_corners_[corner_id] = opp_corner_id;
+  }
+
+  // Sets opposite corners for both input corners.
+  inline void SetOppositeCorners(CornerIndex corner_0, CornerIndex corner_1) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    if (corner_0 != kInvalidCornerIndex) {
+      SetOppositeCorner(corner_0, corner_1);
+    }
+    if (corner_1 != kInvalidCornerIndex) {
+      SetOppositeCorner(corner_1, corner_0);
+    }
+  }
+
+  // Updates mapping between a corner and a vertex.
+  inline void MapCornerToVertex(CornerIndex corner_id, VertexIndex vert_id) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    corner_to_vertex_map_[corner_id] = vert_id;
+  }
+
+  VertexIndex AddNewVertex() {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    // Add a new invalid vertex.
+    vertex_corners_.push_back(kInvalidCornerIndex);
+    return VertexIndex(static_cast<uint32_t>(vertex_corners_.size() - 1));
+  }
+
+  // Adds a new face connected to three vertices. Note that connectivity is not
+  // automatically updated and all opposite corners need to be set explicitly.
+  FaceIndex AddNewFace(const std::array<VertexIndex, 3> &vertices) {
+    // Add a new invalid face.
+    const FaceIndex new_face_index(num_faces());
+    for (int i = 0; i < 3; ++i) {
+      corner_to_vertex_map_.push_back(vertices[i]);
+      SetLeftMostCorner(vertices[i],
+                        CornerIndex(corner_to_vertex_map_.size() - 1));
+    }
+    opposite_corners_.resize(corner_to_vertex_map_.size(), kInvalidCornerIndex);
+    return new_face_index;
+  }
+
+  // Sets a new left most corner for a given vertex.
+  void SetLeftMostCorner(VertexIndex vert, CornerIndex corner) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    if (vert != kInvalidVertexIndex) {
+      vertex_corners_[vert] = corner;
+    }
+  }
+
+  // Updates the vertex to corner map on a specified vertex. This should be
+  // called in cases where the mapping may be invalid (e.g. when the corner
+  // table was constructed manually).
+  void UpdateVertexToCornerMap(VertexIndex vert) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    const CornerIndex first_c = vertex_corners_[vert];
+    if (first_c == kInvalidCornerIndex) {
+      return;  // Isolated vertex.
+    }
+    CornerIndex act_c = SwingLeft(first_c);
+    CornerIndex c = first_c;
+    while (act_c != kInvalidCornerIndex && act_c != first_c) {
+      c = act_c;
+      act_c = SwingLeft(act_c);
+    }
+    if (act_c != first_c) {
+      vertex_corners_[vert] = c;
+    }
+  }
+
+  // Sets the new number of vertices. It's a responsibility of the caller to
+  // ensure that no corner is mapped beyond the range of the new number of
+  // vertices.
+  inline void SetNumVertices(int num_vertices) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    vertex_corners_.resize(num_vertices, kInvalidCornerIndex);
+  }
+
+  // Makes a vertex isolated (not attached to any corner).
+  void MakeVertexIsolated(VertexIndex vert) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    vertex_corners_[vert] = kInvalidCornerIndex;
+  }
+
+  // Returns true if a vertex is not attached to any face.
+  inline bool IsVertexIsolated(VertexIndex v) const {
+    return LeftMostCorner(v) == kInvalidCornerIndex;
+  }
+
+  // Makes a given face invalid (all corners are marked as invalid).
+  void MakeFaceInvalid(FaceIndex face) {
+    DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+    if (face != kInvalidFaceIndex) {
+      const CornerIndex first_corner = FirstCorner(face);
+      for (int i = 0; i < 3; ++i) {
+        corner_to_vertex_map_[first_corner + i] = kInvalidVertexIndex;
+      }
+    }
+  }
+
+  // Updates mapping between faces and a vertex using the corners mapped to
+  // the provided vertex.
+  void UpdateFaceToVertexMap(const VertexIndex vertex);
+
+  // Allows access to an internal object for caching valences.  The object can
+  // be instructed to cache or uncache all valences and then its interfaces
+  // queried directly for valences with differing performance/confidence
+  // qualities.  If the mesh or table is modified the cache should be discarded
+  // and not relied on as it does not automatically update or invalidate for
+  // performance reasons.
+  const draco::ValenceCache<CornerTable> &GetValenceCache() const {
+    return valence_cache_;
+  }
+
+ private:
+  // Computes opposite corners mapping from the data stored in
+  // |corner_to_vertex_map_|.
+  bool ComputeOppositeCorners(int *num_vertices);
+
+  // Finds and breaks non-manifold edges in the 1-ring neighborhood around
+  // vertices (vertices themselves will be split in the ComputeVertexCorners()
+  // function if necessary).
+  bool BreakNonManifoldEdges();
+
+  // Computes the lookup map for going from a vertex to a corner. This method
+  // can handle non-manifold vertices by splitting them into multiple manifold
+  // vertices.
+  bool ComputeVertexCorners(int num_vertices);
+
+  // Each three consecutive corners represent one face.
+  IndexTypeVector<CornerIndex, VertexIndex> corner_to_vertex_map_;
+  IndexTypeVector<CornerIndex, CornerIndex> opposite_corners_;
+  IndexTypeVector<VertexIndex, CornerIndex> vertex_corners_;
+
+  int num_original_vertices_;
+  int num_degenerated_faces_;
+  int num_isolated_vertices_;
+  IndexTypeVector<VertexIndex, VertexIndex> non_manifold_vertex_parents_;
+
+  draco::ValenceCache<CornerTable> valence_cache_;
+};
+
+// A special case to denote an invalid corner table triangle.
+static constexpr CornerTable::FaceType kInvalidFace(
+    {{kInvalidVertexIndex, kInvalidVertexIndex, kInvalidVertexIndex}});
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_CORNER_TABLE_H_
diff --git a/contrib/draco/src/draco/mesh/corner_table_iterators.h b/contrib/draco/src/draco/mesh/corner_table_iterators.h
new file mode 100644
index 000000000..7122aa1be
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/corner_table_iterators.h
@@ -0,0 +1,289 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_CORNER_TABLE_ITERATORS_H_
+#define DRACO_MESH_CORNER_TABLE_ITERATORS_H_
+
+#include "draco/mesh/corner_table.h"
+
+namespace draco {
+
+// Class for iterating over vertices in a 1-ring around the specified vertex.
+template <class CornerTableT>
+class VertexRingIterator
+    : public std::iterator<std::forward_iterator_tag, VertexIndex> {
+ public:
+  // std::iterator interface requires a default constructor.
+  VertexRingIterator()
+      : corner_table_(nullptr),
+        start_corner_(kInvalidCornerIndex),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Create the iterator from the provided corner table and the central vertex.
+  VertexRingIterator(const CornerTableT *table, VertexIndex vert_id)
+      : corner_table_(table),
+        start_corner_(table->LeftMostCorner(vert_id)),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Gets the last visited ring vertex.
+  VertexIndex Vertex() const {
+    CornerIndex ring_corner = left_traversal_ ? corner_table_->Previous(corner_)
+                                              : corner_table_->Next(corner_);
+    return corner_table_->Vertex(ring_corner);
+  }
+
+  // Returns one of the corners opposite to the edge connecting the currently
+  // iterated ring vertex with the central vertex.
+  CornerIndex EdgeCorner() const {
+    return left_traversal_ ? corner_table_->Next(corner_)
+                           : corner_table_->Previous(corner_);
+  }
+
+  // Returns true when all ring vertices have been visited.
+  bool End() const { return corner_ == kInvalidCornerIndex; }
+
+  // Proceeds to the next ring vertex if possible.
+  void Next() {
+    if (left_traversal_) {
+      corner_ = corner_table_->SwingLeft(corner_);
+      if (corner_ == kInvalidCornerIndex) {
+        // Open boundary reached.
+        corner_ = start_corner_;
+        left_traversal_ = false;
+      } else if (corner_ == start_corner_) {
+        // End reached.
+        corner_ = kInvalidCornerIndex;
+      }
+    } else {
+      // Go to the right until we reach a boundary there (no explicit check
+      // is needed in this case).
+      corner_ = corner_table_->SwingRight(corner_);
+    }
+  }
+
+  // std::iterator interface.
+  value_type operator*() const { return Vertex(); }
+  VertexRingIterator &operator++() {
+    Next();
+    return *this;
+  }
+  VertexRingIterator operator++(int) {
+    const VertexRingIterator result = *this;
+    ++(*this);
+    return result;
+  }
+  bool operator!=(const VertexRingIterator &other) const {
+    return corner_ != other.corner_ || start_corner_ != other.start_corner_;
+  }
+  bool operator==(const VertexRingIterator &other) const {
+    return !this->operator!=(other);
+  }
+
+  // Helper function for getting a valid end iterator.
+  static VertexRingIterator EndIterator(VertexRingIterator other) {
+    VertexRingIterator ret = other;
+    ret.corner_ = kInvalidCornerIndex;
+    return ret;
+  }
+
+ private:
+  const CornerTableT *corner_table_;
+  // The first processed corner.
+  CornerIndex start_corner_;
+  // The last processed corner.
+  CornerIndex corner_;
+  // Traversal direction.
+  bool left_traversal_;
+};
+
+// Class for iterating over faces adjacent to the specified input face.
+template <class CornerTableT>
+class FaceAdjacencyIterator
+    : public std::iterator<std::forward_iterator_tag, FaceIndex> {
+ public:
+  // std::iterator interface requires a default constructor.
+  FaceAdjacencyIterator()
+      : corner_table_(nullptr),
+        start_corner_(kInvalidCornerIndex),
+        corner_(start_corner_) {}
+
+  // Create the iterator from the provided corner table and the central vertex.
+  FaceAdjacencyIterator(const CornerTableT *table, FaceIndex face_id)
+      : corner_table_(table),
+        start_corner_(table->FirstCorner(face_id)),
+        corner_(start_corner_) {
+    // We need to start with a corner that has a valid opposite face (if
+    // there is any such corner).
+    if (corner_table_->Opposite(corner_) == kInvalidCornerIndex) {
+      FindNextFaceNeighbor();
+    }
+  }
+
+  // Gets the last visited adjacent face.
+  FaceIndex Face() const {
+    return corner_table_->Face(corner_table_->Opposite(corner_));
+  }
+
+  // Returns true when all adjacent faces have been visited.
+  bool End() const { return corner_ == kInvalidCornerIndex; }
+
+  // Proceeds to the next adjacent face if possible.
+  void Next() { FindNextFaceNeighbor(); }
+
+  // std::iterator interface.
+  value_type operator*() const { return Face(); }
+  FaceAdjacencyIterator &operator++() {
+    Next();
+    return *this;
+  }
+  FaceAdjacencyIterator operator++(int) {
+    const FaceAdjacencyIterator result = *this;
+    ++(*this);
+    return result;
+  }
+  bool operator!=(const FaceAdjacencyIterator &other) const {
+    return corner_ != other.corner_ || start_corner_ != other.start_corner_;
+  }
+  bool operator==(const FaceAdjacencyIterator &other) const {
+    return !this->operator!=(other);
+  }
+
+  // Helper function for getting a valid end iterator.
+  static FaceAdjacencyIterator EndIterator(FaceAdjacencyIterator other) {
+    FaceAdjacencyIterator ret = other;
+    ret.corner_ = kInvalidCornerIndex;
+    return ret;
+  }
+
+ private:
+  // Finds the next corner with a valid opposite face.
+  void FindNextFaceNeighbor() {
+    while (corner_ != kInvalidCornerIndex) {
+      corner_ = corner_table_->Next(corner_);
+      if (corner_ == start_corner_) {
+        corner_ = kInvalidCornerIndex;
+        return;
+      }
+      if (corner_table_->Opposite(corner_) != kInvalidCornerIndex) {
+        // Valid opposite face.
+        return;
+      }
+    }
+  }
+
+  const CornerTableT *corner_table_;
+  // The first processed corner.
+  CornerIndex start_corner_;
+  // The last processed corner.
+  CornerIndex corner_;
+};
+
+// Class for iterating over corners attached to a specified vertex.
+template <class CornerTableT = CornerTable>
+class VertexCornersIterator
+    : public std::iterator<std::forward_iterator_tag, CornerIndex> {
+ public:
+  // std::iterator interface requires a default constructor.
+  VertexCornersIterator()
+      : corner_table_(nullptr),
+        start_corner_(-1),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Create the iterator from the provided corner table and the central vertex.
+  VertexCornersIterator(const CornerTableT *table, VertexIndex vert_id)
+      : corner_table_(table),
+        start_corner_(table->LeftMostCorner(vert_id)),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Create the iterator from the provided corner table and the first corner.
+  VertexCornersIterator(const CornerTableT *table, CornerIndex corner_id)
+      : corner_table_(table),
+        start_corner_(corner_id),
+        corner_(start_corner_),
+        left_traversal_(true) {}
+
+  // Gets the last visited corner.
+  CornerIndex Corner() const { return corner_; }
+
+  // Returns true when all ring vertices have been visited.
+  bool End() const { return corner_ == kInvalidCornerIndex; }
+
+  // Proceeds to the next corner if possible.
+  void Next() {
+    if (left_traversal_) {
+      corner_ = corner_table_->SwingLeft(corner_);
+      if (corner_ == kInvalidCornerIndex) {
+        // Open boundary reached.
+        corner_ = corner_table_->SwingRight(start_corner_);
+        left_traversal_ = false;
+      } else if (corner_ == start_corner_) {
+        // End reached.
+        corner_ = kInvalidCornerIndex;
+      }
+    } else {
+      // Go to the right until we reach a boundary there (no explicit check
+      // is needed in this case).
+      corner_ = corner_table_->SwingRight(corner_);
+    }
+  }
+
+  // std::iterator interface.
+  CornerIndex operator*() const { return Corner(); }
+  VertexCornersIterator &operator++() {
+    Next();
+    return *this;
+  }
+  VertexCornersIterator operator++(int) {
+    const VertexCornersIterator result = *this;
+    ++(*this);
+    return result;
+  }
+  bool operator!=(const VertexCornersIterator &other) const {
+    return corner_ != other.corner_ || start_corner_ != other.start_corner_;
+  }
+  bool operator==(const VertexCornersIterator &other) const {
+    return !this->operator!=(other);
+  }
+
+  // Helper function for getting a valid end iterator.
+  static VertexCornersIterator EndIterator(VertexCornersIterator other) {
+    VertexCornersIterator ret = other;
+    ret.corner_ = kInvalidCornerIndex;
+    return ret;
+  }
+
+ protected:
+  const CornerTableT *corner_table() const { return corner_table_; }
+  CornerIndex start_corner() const { return start_corner_; }
+  CornerIndex &corner() { return corner_; }
+  bool is_left_traversal() const { return left_traversal_; }
+  void swap_traversal() { left_traversal_ = !left_traversal_; }
+
+ private:
+  const CornerTableT *corner_table_;
+  // The first processed corner.
+  CornerIndex start_corner_;
+  // The last processed corner.
+  CornerIndex corner_;
+  // Traversal direction.
+  bool left_traversal_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_CORNER_TABLE_ITERATORS_H_
diff --git a/contrib/draco/src/draco/mesh/mesh.cc b/contrib/draco/src/draco/mesh/mesh.cc
new file mode 100644
index 000000000..3be4b1494
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh.cc
@@ -0,0 +1,40 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh.h"
+
+#include <array>
+
+namespace draco {
+
+// Shortcut for typed conditionals.
+template <bool B, class T, class F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+
+Mesh::Mesh() {}
+
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+void Mesh::ApplyPointIdDeduplication(
+    const IndexTypeVector<PointIndex, PointIndex> &id_map,
+    const std::vector<PointIndex> &unique_point_ids) {
+  PointCloud::ApplyPointIdDeduplication(id_map, unique_point_ids);
+  for (FaceIndex f(0); f < num_faces(); ++f) {
+    for (int32_t c = 0; c < 3; ++c) {
+      faces_[f][c] = id_map[faces_[f][c]];
+    }
+  }
+}
+#endif
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/mesh/mesh.h b/contrib/draco/src/draco/mesh/mesh.h
new file mode 100644
index 000000000..f4506da81
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh.h
@@ -0,0 +1,152 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_H_
+#define DRACO_MESH_MESH_H_
+
+#include <memory>
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/hash_utils.h"
+#include "draco/core/macros.h"
+#include "draco/core/status.h"
+#include "draco/draco_features.h"
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// List of different variants of mesh attributes.
+enum MeshAttributeElementType {
+  // All corners attached to a vertex share the same attribute value. A typical
+  // example are the vertex positions and often vertex colors.
+  MESH_VERTEX_ATTRIBUTE = 0,
+  // The most general attribute where every corner of the mesh can have a
+  // different attribute value. Often used for texture coordinates or normals.
+  MESH_CORNER_ATTRIBUTE,
+  // All corners of a single face share the same value.
+  MESH_FACE_ATTRIBUTE
+};
+
+// Mesh class can be used to represent general triangular meshes. Internally,
+// Mesh is just an extended PointCloud with extra connectivity data that defines
+// what points are connected together in triangles.
+class Mesh : public PointCloud {
+ public:
+  typedef std::array<PointIndex, 3> Face;
+
+  Mesh();
+
+  void AddFace(const Face &face) { faces_.push_back(face); }
+
+  void SetFace(FaceIndex face_id, const Face &face) {
+    if (face_id >= static_cast<uint32_t>(faces_.size())) {
+      faces_.resize(face_id.value() + 1, Face());
+    }
+    faces_[face_id] = face;
+  }
+
+  // Sets the total number of faces. Creates new empty faces or deletes
+  // existing ones if necessary.
+  void SetNumFaces(size_t num_faces) { faces_.resize(num_faces, Face()); }
+
+  FaceIndex::ValueType num_faces() const {
+    return static_cast<uint32_t>(faces_.size());
+  }
+  const Face &face(FaceIndex face_id) const {
+    DRACO_DCHECK_LE(0, face_id.value());
+    DRACO_DCHECK_LT(face_id.value(), static_cast<int>(faces_.size()));
+    return faces_[face_id];
+  }
+
+  void SetAttribute(int att_id, std::unique_ptr<PointAttribute> pa) override {
+    PointCloud::SetAttribute(att_id, std::move(pa));
+    if (static_cast<int>(attribute_data_.size()) <= att_id) {
+      attribute_data_.resize(att_id + 1);
+    }
+  }
+
+  void DeleteAttribute(int att_id) override {
+    PointCloud::DeleteAttribute(att_id);
+    if (att_id >= 0 && att_id < static_cast<int>(attribute_data_.size())) {
+      attribute_data_.erase(attribute_data_.begin() + att_id);
+    }
+  }
+
+  MeshAttributeElementType GetAttributeElementType(int att_id) const {
+    return attribute_data_[att_id].element_type;
+  }
+
+  void SetAttributeElementType(int att_id, MeshAttributeElementType et) {
+    attribute_data_[att_id].element_type = et;
+  }
+
+  // Returns the point id of for a corner |ci|.
+  inline PointIndex CornerToPointId(int ci) const {
+    if (ci < 0 || static_cast<uint32_t>(ci) == kInvalidCornerIndex.value()) {
+      return kInvalidPointIndex;
+    }
+    return this->face(FaceIndex(ci / 3))[ci % 3];
+  }
+
+  // Returns the point id of a corner |ci|.
+  inline PointIndex CornerToPointId(CornerIndex ci) const {
+    return this->CornerToPointId(ci.value());
+  }
+
+  struct AttributeData {
+    AttributeData() : element_type(MESH_CORNER_ATTRIBUTE) {}
+    MeshAttributeElementType element_type;
+  };
+
+ protected:
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // Extends the point deduplication to face corners. This method is called from
+  // the PointCloud::DeduplicatePointIds() and it remaps all point ids stored in
+  // |faces_| to the new deduplicated point ids using the map |id_map|.
+  void ApplyPointIdDeduplication(
+      const IndexTypeVector<PointIndex, PointIndex> &id_map,
+      const std::vector<PointIndex> &unique_point_ids) override;
+#endif
+
+ private:
+  // Mesh specific per-attribute data.
+  std::vector<AttributeData> attribute_data_;
+
+  // Vertex indices valid for all attributes. Each attribute has its own map
+  // that converts vertex indices into attribute indices.
+  IndexTypeVector<FaceIndex, Face> faces_;
+
+  friend struct MeshHasher;
+};
+
+// Functor for computing a hash from data stored within a mesh.
+// Note that this can be quite slow. Two meshes will have the same hash only
+// when they have exactly the same connectivity and attribute values.
+struct MeshHasher {
+  size_t operator()(const Mesh &mesh) const {
+    PointCloudHasher pc_hasher;
+    size_t hash = pc_hasher(mesh);
+    // Hash faces.
+    for (FaceIndex i(0); i < static_cast<uint32_t>(mesh.faces_.size()); ++i) {
+      for (int j = 0; j < 3; ++j) {
+        hash = HashCombine(mesh.faces_[i][j].value(), hash);
+      }
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_H_
diff --git a/contrib/draco/src/draco/mesh/mesh_are_equivalent.cc b/contrib/draco/src/draco/mesh/mesh_are_equivalent.cc
new file mode 100644
index 000000000..b832379af
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh_are_equivalent.cc
@@ -0,0 +1,205 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_are_equivalent.h"
+
+#include <algorithm>
+
+namespace draco {
+
+void MeshAreEquivalent::PrintPosition(const Mesh &mesh, FaceIndex f,
+                                      int32_t c) {
+  fprintf(stderr, "Printing position for (%i,%i)\n", f.value(), c);
+  const auto pos_att = mesh.GetNamedAttribute(GeometryAttribute::POSITION);
+  const PointIndex ver_index = mesh.face(f)[c];
+  const AttributeValueIndex pos_index = pos_att->mapped_index(ver_index);
+  const auto pos = pos_att->GetValue<float, 3>(pos_index);
+  fprintf(stderr, "Position (%f,%f,%f)\n", pos[0], pos[1], pos[2]);
+}
+
+Vector3f MeshAreEquivalent::GetPosition(const Mesh &mesh, FaceIndex f,
+                                        int32_t c) {
+  const auto pos_att = mesh.GetNamedAttribute(GeometryAttribute::POSITION);
+  const PointIndex ver_index = mesh.face(f)[c];
+  const AttributeValueIndex pos_index = pos_att->mapped_index(ver_index);
+  const auto pos = pos_att->GetValue<float, 3>(pos_index);
+  return Vector3f(pos[0], pos[1], pos[2]);
+}
+
+void MeshAreEquivalent::InitCornerIndexOfSmallestPointXYZ() {
+  DRACO_DCHECK_EQ(mesh_infos_[0].corner_index_of_smallest_vertex.size(), 0);
+  DRACO_DCHECK_EQ(mesh_infos_[1].corner_index_of_smallest_vertex.size(), 0);
+  for (int i = 0; i < 2; ++i) {
+    mesh_infos_[i].corner_index_of_smallest_vertex.reserve(num_faces_);
+    for (FaceIndex f(0); f < num_faces_; ++f) {
+      mesh_infos_[i].corner_index_of_smallest_vertex.push_back(
+          ComputeCornerIndexOfSmallestPointXYZ(mesh_infos_[i].mesh, f));
+    }
+  }
+  DRACO_DCHECK_EQ(mesh_infos_[0].corner_index_of_smallest_vertex.size(),
+                  num_faces_);
+  DRACO_DCHECK_EQ(mesh_infos_[1].corner_index_of_smallest_vertex.size(),
+                  num_faces_);
+}
+
+void MeshAreEquivalent::InitOrderedFaceIndex() {
+  DRACO_DCHECK_EQ(mesh_infos_[0].ordered_index_of_face.size(), 0);
+  DRACO_DCHECK_EQ(mesh_infos_[1].ordered_index_of_face.size(), 0);
+  for (int32_t i = 0; i < 2; ++i) {
+    mesh_infos_[i].ordered_index_of_face.reserve(num_faces_);
+    for (FaceIndex j(0); j < num_faces_; ++j) {
+      mesh_infos_[i].ordered_index_of_face.push_back(j);
+    }
+    const FaceIndexLess less(mesh_infos_[i]);
+    std::sort(mesh_infos_[i].ordered_index_of_face.begin(),
+              mesh_infos_[i].ordered_index_of_face.end(), less);
+
+    DRACO_DCHECK_EQ(mesh_infos_[i].ordered_index_of_face.size(), num_faces_);
+    DRACO_DCHECK(std::is_sorted(mesh_infos_[i].ordered_index_of_face.begin(),
+                                mesh_infos_[i].ordered_index_of_face.end(),
+                                less));
+  }
+}
+
+int32_t MeshAreEquivalent::ComputeCornerIndexOfSmallestPointXYZ(
+    const Mesh &mesh, FaceIndex f) {
+  Vector3f pos[3];  // For the three corners.
+  for (int32_t i = 0; i < 3; ++i) {
+    pos[i] = GetPosition(mesh, f, i);
+  }
+  const auto min_it = std::min_element(pos, pos + 3);
+  return static_cast<int32_t>(min_it - pos);
+}
+
+void MeshAreEquivalent::Init(const Mesh &mesh0, const Mesh &mesh1) {
+  mesh_infos_.clear();
+  DRACO_DCHECK_EQ(mesh_infos_.size(), 0);
+
+  num_faces_ = mesh1.num_faces();
+  mesh_infos_.push_back(MeshInfo(mesh0));
+  mesh_infos_.push_back(MeshInfo(mesh1));
+
+  DRACO_DCHECK_EQ(mesh_infos_.size(), 2);
+  DRACO_DCHECK_EQ(mesh_infos_[0].corner_index_of_smallest_vertex.size(), 0);
+  DRACO_DCHECK_EQ(mesh_infos_[1].corner_index_of_smallest_vertex.size(), 0);
+  DRACO_DCHECK_EQ(mesh_infos_[0].ordered_index_of_face.size(), 0);
+  DRACO_DCHECK_EQ(mesh_infos_[1].ordered_index_of_face.size(), 0);
+
+  InitCornerIndexOfSmallestPointXYZ();
+  InitOrderedFaceIndex();
+}
+
+bool MeshAreEquivalent::operator()(const Mesh &mesh0, const Mesh &mesh1) {
+  if (mesh0.num_faces() != mesh1.num_faces()) {
+    return false;
+  }
+  if (mesh0.num_attributes() != mesh1.num_attributes()) {
+    return false;
+  }
+
+  // The following function inits mesh info, i.e., computes the order of
+  // faces with respect to the lex order. This way one can then compare the
+  // the two meshes face by face. It also determines the first corner of each
+  // face with respect to lex order.
+  Init(mesh0, mesh1);
+
+  // Check for every attribute that is valid that every corner is identical.
+  typedef GeometryAttribute::Type AttributeType;
+  const int att_max = AttributeType::NAMED_ATTRIBUTES_COUNT;
+  for (int att_id = 0; att_id < att_max; ++att_id) {
+    // First check for existence of the attribute in both meshes.
+    const PointAttribute *const att0 =
+        mesh0.GetNamedAttribute(AttributeType(att_id));
+    const PointAttribute *const att1 =
+        mesh1.GetNamedAttribute(AttributeType(att_id));
+    if (att0 == nullptr && att1 == nullptr) {
+      continue;
+    }
+    if (att0 == nullptr) {
+      return false;
+    }
+    if (att1 == nullptr) {
+      return false;
+    }
+    if (att0->data_type() != att1->data_type()) {
+      return false;
+    }
+    if (att0->num_components() != att1->num_components()) {
+      return false;
+    }
+    if (att0->normalized() != att1->normalized()) {
+      return false;
+    }
+    if (att0->byte_stride() != att1->byte_stride()) {
+      return false;
+    }
+
+    DRACO_DCHECK(att0->IsValid());
+    DRACO_DCHECK(att1->IsValid());
+
+    // Prepare blocks of memory to hold data of corners for this attribute.
+    std::unique_ptr<uint8_t[]> data0(new uint8_t[att0->byte_stride()]);
+    std::unique_ptr<uint8_t[]> data1(new uint8_t[att0->byte_stride()]);
+
+    // Check every corner of every face.
+    for (int i = 0; i < num_faces_; ++i) {
+      const FaceIndex f0 = mesh_infos_[0].ordered_index_of_face[i];
+      const FaceIndex f1 = mesh_infos_[1].ordered_index_of_face[i];
+      const int c0_off = mesh_infos_[0].corner_index_of_smallest_vertex[f0];
+      const int c1_off = mesh_infos_[1].corner_index_of_smallest_vertex[f1];
+
+      for (int c = 0; c < 3; ++c) {
+        // Get the index of each corner.
+        const PointIndex corner0 = mesh0.face(f0)[(c0_off + c) % 3];
+        const PointIndex corner1 = mesh1.face(f1)[(c1_off + c) % 3];
+        // Map it to the right index for that attribute.
+        const AttributeValueIndex index0 = att0->mapped_index(corner0);
+        const AttributeValueIndex index1 = att1->mapped_index(corner1);
+
+        // Obtaining the data.
+        att0->GetValue(index0, data0.get());
+        att1->GetValue(index1, data1.get());
+        // Compare the data as is in memory.
+        if (memcmp(data0.get(), data1.get(), att0->byte_stride()) != 0) {
+          return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
+bool MeshAreEquivalent::FaceIndexLess::operator()(FaceIndex f0,
+                                                  FaceIndex f1) const {
+  if (f0 == f1) {
+    return false;
+  }
+  const int c0 = mesh_info.corner_index_of_smallest_vertex[f0];
+  const int c1 = mesh_info.corner_index_of_smallest_vertex[f1];
+
+  for (int i = 0; i < 3; ++i) {
+    const Vector3f vf0 = GetPosition(mesh_info.mesh, f0, (c0 + i) % 3);
+    const Vector3f vf1 = GetPosition(mesh_info.mesh, f1, (c1 + i) % 3);
+    if (vf0 < vf1) {
+      return true;
+    }
+    if (vf1 < vf0) {
+      return false;
+    }
+  }
+  // In case the two faces are equivalent.
+  return false;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/mesh/mesh_are_equivalent.h b/contrib/draco/src/draco/mesh/mesh_are_equivalent.h
new file mode 100644
index 000000000..71ef4a93c
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh_are_equivalent.h
@@ -0,0 +1,71 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_ARE_EQUIVALENT_H_
+#define DRACO_MESH_MESH_ARE_EQUIVALENT_H_
+
+#include "draco/core/vector_d.h"
+#include "draco/mesh/mesh.h"
+
+// This file defines a functor to compare two meshes for equivalency up
+// to permutation of the vertices.
+namespace draco {
+
+// A functor to compare two meshes for equivalency up to permutation of the
+// vertices.
+class MeshAreEquivalent {
+ public:
+  // Returns true if both meshes are equivalent up to permutation of
+  // the internal order of vertices. This includes all attributes.
+  bool operator()(const Mesh &mesh0, const Mesh &mesh1);
+
+ private:
+  // Internal type to keep overview.
+  struct MeshInfo {
+    explicit MeshInfo(const Mesh &in_mesh) : mesh(in_mesh) {}
+    const Mesh &mesh;
+    std::vector<FaceIndex> ordered_index_of_face;
+    IndexTypeVector<FaceIndex, int> corner_index_of_smallest_vertex;
+  };
+
+  // Prepare functor for actual comparison.
+  void Init(const Mesh &mesh0, const Mesh &mesh1);
+
+  // Get position as Vector3f of corner c of face f.
+  static Vector3f GetPosition(const Mesh &mesh, FaceIndex f, int32_t c);
+  // Internal helper function mostly for debugging.
+  void PrintPosition(const Mesh &mesh, FaceIndex f, int32_t c);
+  // Get the corner index of the lex smallest vertex of face f.
+  static int32_t ComputeCornerIndexOfSmallestPointXYZ(const Mesh &mesh,
+                                                      FaceIndex f);
+
+  // Less compare functor for two faces (represented by their indices)
+  // with respect to their lex order.
+  struct FaceIndexLess {
+    explicit FaceIndexLess(const MeshInfo &in_mesh_info)
+        : mesh_info(in_mesh_info) {}
+    bool operator()(FaceIndex f0, FaceIndex f1) const;
+    const MeshInfo &mesh_info;
+  };
+
+  void InitCornerIndexOfSmallestPointXYZ();
+  void InitOrderedFaceIndex();
+
+  std::vector<MeshInfo> mesh_infos_;
+  int32_t num_faces_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_ARE_EQUIVALENT_H_
diff --git a/contrib/draco/src/draco/mesh/mesh_are_equivalent_test.cc b/contrib/draco/src/draco/mesh/mesh_are_equivalent_test.cc
new file mode 100644
index 000000000..74db3f7de
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh_are_equivalent_test.cc
@@ -0,0 +1,98 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_are_equivalent.h"
+
+#include <sstream>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/io/mesh_io.h"
+#include "draco/io/obj_decoder.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+class MeshAreEquivalentTest : public ::testing::Test {};
+
+TEST_F(MeshAreEquivalentTest, TestOnIndenticalMesh) {
+  const std::string file_name = "test_nm.obj";
+  const std::unique_ptr<Mesh> mesh(ReadMeshFromTestFile(file_name));
+  ASSERT_NE(mesh, nullptr) << "Failed to load test model." << file_name;
+  MeshAreEquivalent equiv;
+  ASSERT_TRUE(equiv(*mesh, *mesh));
+}
+
+TEST_F(MeshAreEquivalentTest, TestPermutedOneFace) {
+  const std::string file_name_0 = "one_face_123.obj";
+  const std::string file_name_1 = "one_face_312.obj";
+  const std::string file_name_2 = "one_face_321.obj";
+  const std::unique_ptr<Mesh> mesh_0(ReadMeshFromTestFile(file_name_0));
+  const std::unique_ptr<Mesh> mesh_1(ReadMeshFromTestFile(file_name_1));
+  const std::unique_ptr<Mesh> mesh_2(ReadMeshFromTestFile(file_name_2));
+  ASSERT_NE(mesh_0, nullptr) << "Failed to load test model." << file_name_0;
+  ASSERT_NE(mesh_1, nullptr) << "Failed to load test model." << file_name_1;
+  ASSERT_NE(mesh_2, nullptr) << "Failed to load test model." << file_name_2;
+  MeshAreEquivalent equiv;
+  ASSERT_TRUE(equiv(*mesh_0, *mesh_0));
+  ASSERT_TRUE(equiv(*mesh_0, *mesh_1));   // Face rotated.
+  ASSERT_FALSE(equiv(*mesh_0, *mesh_2));  // Face inverted.
+}
+
+TEST_F(MeshAreEquivalentTest, TestPermutedTwoFaces) {
+  const std::string file_name_0 = "two_faces_123.obj";
+  const std::string file_name_1 = "two_faces_312.obj";
+  const std::unique_ptr<Mesh> mesh_0(ReadMeshFromTestFile(file_name_0));
+  const std::unique_ptr<Mesh> mesh_1(ReadMeshFromTestFile(file_name_1));
+  ASSERT_NE(mesh_0, nullptr) << "Failed to load test model." << file_name_0;
+  ASSERT_NE(mesh_1, nullptr) << "Failed to load test model." << file_name_1;
+  MeshAreEquivalent equiv;
+  ASSERT_TRUE(equiv(*mesh_0, *mesh_0));
+  ASSERT_TRUE(equiv(*mesh_1, *mesh_1));
+  ASSERT_TRUE(equiv(*mesh_0, *mesh_1));
+}
+
+TEST_F(MeshAreEquivalentTest, TestPermutedThreeFaces) {
+  const std::string file_name_0 = "three_faces_123.obj";
+  const std::string file_name_1 = "three_faces_312.obj";
+  const std::unique_ptr<Mesh> mesh_0(ReadMeshFromTestFile(file_name_0));
+  const std::unique_ptr<Mesh> mesh_1(ReadMeshFromTestFile(file_name_1));
+  ASSERT_NE(mesh_0, nullptr) << "Failed to load test model." << file_name_0;
+  ASSERT_NE(mesh_1, nullptr) << "Failed to load test model." << file_name_1;
+  MeshAreEquivalent equiv;
+  ASSERT_TRUE(equiv(*mesh_0, *mesh_0));
+  ASSERT_TRUE(equiv(*mesh_1, *mesh_1));
+  ASSERT_TRUE(equiv(*mesh_0, *mesh_1));
+}
+
+// This test checks that the edgebreaker algorithm does not change the mesh up
+// to the order of faces and vertices.
+TEST_F(MeshAreEquivalentTest, TestOnBigMesh) {
+  const std::string file_name = "test_nm.obj";
+  const std::unique_ptr<Mesh> mesh0(ReadMeshFromTestFile(file_name));
+  ASSERT_NE(mesh0, nullptr) << "Failed to load test model." << file_name;
+
+  std::unique_ptr<Mesh> mesh1;
+  std::stringstream ss;
+  WriteMeshIntoStream(mesh0.get(), ss, MESH_EDGEBREAKER_ENCODING);
+  ReadMeshFromStream(&mesh1, ss);
+  ASSERT_TRUE(ss.good()) << "Mesh IO failed.";
+
+  MeshAreEquivalent equiv;
+  ASSERT_TRUE(equiv(*mesh0, *mesh0));
+  ASSERT_TRUE(equiv(*mesh1, *mesh1));
+  ASSERT_TRUE(equiv(*mesh0, *mesh1));
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.cc b/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.cc
new file mode 100644
index 000000000..28b68d5fd
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.cc
@@ -0,0 +1,211 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_attribute_corner_table.h"
+
+#include "draco/mesh/corner_table_iterators.h"
+#include "draco/mesh/mesh_misc_functions.h"
+
+namespace draco {
+
+MeshAttributeCornerTable::MeshAttributeCornerTable()
+    : no_interior_seams_(true), corner_table_(nullptr), valence_cache_(*this) {}
+
+bool MeshAttributeCornerTable::InitEmpty(const CornerTable *table) {
+  if (table == nullptr) {
+    return false;
+  }
+  valence_cache_.ClearValenceCache();
+  valence_cache_.ClearValenceCacheInaccurate();
+  is_edge_on_seam_.assign(table->num_corners(), false);
+  is_vertex_on_seam_.assign(table->num_vertices(), false);
+  corner_to_vertex_map_.assign(table->num_corners(), kInvalidVertexIndex);
+  vertex_to_attribute_entry_id_map_.reserve(table->num_vertices());
+  vertex_to_left_most_corner_map_.reserve(table->num_vertices());
+  corner_table_ = table;
+  no_interior_seams_ = true;
+  return true;
+}
+
+bool MeshAttributeCornerTable::InitFromAttribute(const Mesh *mesh,
+                                                 const CornerTable *table,
+                                                 const PointAttribute *att) {
+  if (!InitEmpty(table)) {
+    return false;
+  }
+  valence_cache_.ClearValenceCache();
+  valence_cache_.ClearValenceCacheInaccurate();
+
+  // Find all necessary data for encoding attributes. For now we check which of
+  // the mesh vertices is part of an attribute seam, because seams require
+  // special handling.
+  for (CornerIndex c(0); c < corner_table_->num_corners(); ++c) {
+    const FaceIndex f = corner_table_->Face(c);
+    if (corner_table_->IsDegenerated(f)) {
+      continue;  // Ignore corners on degenerated faces.
+    }
+    const CornerIndex opp_corner = corner_table_->Opposite(c);
+    if (opp_corner == kInvalidCornerIndex) {
+      // Boundary. Mark it as seam edge.
+      is_edge_on_seam_[c.value()] = true;
+      // Mark seam vertices.
+      VertexIndex v;
+      v = corner_table_->Vertex(corner_table_->Next(c));
+      is_vertex_on_seam_[v.value()] = true;
+      v = corner_table_->Vertex(corner_table_->Previous(c));
+      is_vertex_on_seam_[v.value()] = true;
+      continue;
+    }
+    if (opp_corner < c) {
+      continue;  // Opposite corner was already processed.
+    }
+
+    CornerIndex act_c(c), act_sibling_c(opp_corner);
+    for (int i = 0; i < 2; ++i) {
+      // Get the sibling corners. I.e., the two corners attached to the same
+      // vertex but divided by the seam edge.
+      act_c = corner_table_->Next(act_c);
+      act_sibling_c = corner_table_->Previous(act_sibling_c);
+      const PointIndex point_id = mesh->CornerToPointId(act_c.value());
+      const PointIndex sibling_point_id =
+          mesh->CornerToPointId(act_sibling_c.value());
+      if (att->mapped_index(point_id) != att->mapped_index(sibling_point_id)) {
+        no_interior_seams_ = false;
+        is_edge_on_seam_[c.value()] = true;
+        is_edge_on_seam_[opp_corner.value()] = true;
+        // Mark seam vertices.
+        is_vertex_on_seam_[corner_table_
+                               ->Vertex(corner_table_->Next(CornerIndex(c)))
+                               .value()] = true;
+        is_vertex_on_seam_[corner_table_
+                               ->Vertex(corner_table_->Previous(CornerIndex(c)))
+                               .value()] = true;
+        is_vertex_on_seam_
+            [corner_table_->Vertex(corner_table_->Next(opp_corner)).value()] =
+                true;
+        is_vertex_on_seam_[corner_table_
+                               ->Vertex(corner_table_->Previous(opp_corner))
+                               .value()] = true;
+        break;
+      }
+    }
+  }
+  RecomputeVertices(mesh, att);
+  return true;
+}
+
+void MeshAttributeCornerTable::AddSeamEdge(CornerIndex c) {
+  DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+  is_edge_on_seam_[c.value()] = true;
+  // Mark seam vertices.
+  is_vertex_on_seam_[corner_table_->Vertex(corner_table_->Next(c)).value()] =
+      true;
+  is_vertex_on_seam_[corner_table_->Vertex(corner_table_->Previous(c))
+                         .value()] = true;
+
+  const CornerIndex opp_corner = corner_table_->Opposite(c);
+  if (opp_corner != kInvalidCornerIndex) {
+    no_interior_seams_ = false;
+    is_edge_on_seam_[opp_corner.value()] = true;
+    is_vertex_on_seam_[corner_table_->Vertex(corner_table_->Next(opp_corner))
+                           .value()] = true;
+    is_vertex_on_seam_
+        [corner_table_->Vertex(corner_table_->Previous(opp_corner)).value()] =
+            true;
+  }
+}
+
+void MeshAttributeCornerTable::RecomputeVertices(const Mesh *mesh,
+                                                 const PointAttribute *att) {
+  DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+  if (mesh != nullptr && att != nullptr) {
+    RecomputeVerticesInternal<true>(mesh, att);
+  } else {
+    RecomputeVerticesInternal<false>(nullptr, nullptr);
+  }
+}
+
+template <bool init_vertex_to_attribute_entry_map>
+void MeshAttributeCornerTable::RecomputeVerticesInternal(
+    const Mesh *mesh, const PointAttribute *att) {
+  DRACO_DCHECK(GetValenceCache().IsCacheEmpty());
+  vertex_to_attribute_entry_id_map_.clear();
+  vertex_to_left_most_corner_map_.clear();
+  int num_new_vertices = 0;
+  for (VertexIndex v(0); v < corner_table_->num_vertices(); ++v) {
+    const CornerIndex c = corner_table_->LeftMostCorner(v);
+    if (c == kInvalidCornerIndex) {
+      continue;  // Isolated vertex?
+    }
+    AttributeValueIndex first_vert_id(num_new_vertices++);
+    if (init_vertex_to_attribute_entry_map) {
+      const PointIndex point_id = mesh->CornerToPointId(c.value());
+      vertex_to_attribute_entry_id_map_.push_back(att->mapped_index(point_id));
+    } else {
+      // Identity mapping
+      vertex_to_attribute_entry_id_map_.push_back(first_vert_id);
+    }
+    CornerIndex first_c = c;
+    CornerIndex act_c;
+    // Check if the vertex is on a seam edge, if it is we need to find the first
+    // attribute entry on the seam edge when traversing in the CCW direction.
+    if (is_vertex_on_seam_[v.value()]) {
+      // Try to swing left on the modified corner table. We need to get the
+      // first corner that defines an attribute seam.
+      act_c = SwingLeft(first_c);
+      while (act_c != kInvalidCornerIndex) {
+        first_c = act_c;
+        act_c = SwingLeft(act_c);
+      }
+    }
+    corner_to_vertex_map_[first_c.value()] = VertexIndex(first_vert_id.value());
+    vertex_to_left_most_corner_map_.push_back(first_c);
+    act_c = corner_table_->SwingRight(first_c);
+    while (act_c != kInvalidCornerIndex && act_c != first_c) {
+      if (IsCornerOppositeToSeamEdge(corner_table_->Next(act_c))) {
+        first_vert_id = AttributeValueIndex(num_new_vertices++);
+        if (init_vertex_to_attribute_entry_map) {
+          const PointIndex point_id = mesh->CornerToPointId(act_c.value());
+          vertex_to_attribute_entry_id_map_.push_back(
+              att->mapped_index(point_id));
+        } else {
+          // Identity mapping.
+          vertex_to_attribute_entry_id_map_.push_back(first_vert_id);
+        }
+        vertex_to_left_most_corner_map_.push_back(act_c);
+      }
+      corner_to_vertex_map_[act_c.value()] = VertexIndex(first_vert_id.value());
+      act_c = corner_table_->SwingRight(act_c);
+    }
+  }
+}
+
+int MeshAttributeCornerTable::Valence(VertexIndex v) const {
+  if (v == kInvalidVertexIndex) {
+    return -1;
+  }
+  return ConfidentValence(v);
+}
+
+int MeshAttributeCornerTable::ConfidentValence(VertexIndex v) const {
+  DRACO_DCHECK_LT(v.value(), num_vertices());
+  draco::VertexRingIterator<MeshAttributeCornerTable> vi(this, v);
+  int valence = 0;
+  for (; !vi.End(); vi.Next()) {
+    ++valence;
+  }
+  return valence;
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.h b/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.h
new file mode 100644
index 000000000..7dad25cf1
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh_attribute_corner_table.h
@@ -0,0 +1,196 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_ATTRIBUTE_CORNER_TABLE_H_
+#define DRACO_MESH_MESH_ATTRIBUTE_CORNER_TABLE_H_
+
+#include "draco/core/macros.h"
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh.h"
+#include "draco/mesh/valence_cache.h"
+
+namespace draco {
+
+// Class for storing connectivity of mesh attributes. The connectivity is stored
+// as a difference from the base mesh's corner table, where the differences are
+// represented by attribute seam edges. This class provides a basic
+// functionality for detecting the seam edges for a given attribute and for
+// traversing the constrained corner table with the seam edges.
+class MeshAttributeCornerTable {
+ public:
+  MeshAttributeCornerTable();
+  bool InitEmpty(const CornerTable *table);
+  bool InitFromAttribute(const Mesh *mesh, const CornerTable *table,
+                         const PointAttribute *att);
+
+  void AddSeamEdge(CornerIndex opp_corner);
+
+  // Recomputes vertices using the newly added seam edges (needs to be called
+  // whenever the seam edges are updated).
+  // |mesh| and |att| can be null, in which case mapping between vertices and
+  // attribute value ids is set to identity.
+  void RecomputeVertices(const Mesh *mesh, const PointAttribute *att);
+
+  inline bool IsCornerOppositeToSeamEdge(CornerIndex corner) const {
+    return is_edge_on_seam_[corner.value()];
+  }
+
+  inline CornerIndex Opposite(CornerIndex corner) const {
+    if (corner == kInvalidCornerIndex || IsCornerOppositeToSeamEdge(corner)) {
+      return kInvalidCornerIndex;
+    }
+    return corner_table_->Opposite(corner);
+  }
+
+  inline CornerIndex Next(CornerIndex corner) const {
+    return corner_table_->Next(corner);
+  }
+
+  inline CornerIndex Previous(CornerIndex corner) const {
+    return corner_table_->Previous(corner);
+  }
+
+  // Returns true when a corner is attached to any attribute seam.
+  inline bool IsCornerOnSeam(CornerIndex corner) const {
+    return is_vertex_on_seam_[corner_table_->Vertex(corner).value()];
+  }
+
+  // Similar to CornerTable::GetLeftCorner and CornerTable::GetRightCorner, but
+  // does not go over seam edges.
+  inline CornerIndex GetLeftCorner(CornerIndex corner) const {
+    return Opposite(Previous(corner));
+  }
+  inline CornerIndex GetRightCorner(CornerIndex corner) const {
+    return Opposite(Next(corner));
+  }
+
+  // Similar to CornerTable::SwingRight, but it does not go over seam edges.
+  inline CornerIndex SwingRight(CornerIndex corner) const {
+    return Previous(Opposite(Previous(corner)));
+  }
+
+  // Similar to CornerTable::SwingLeft, but it does not go over seam edges.
+  inline CornerIndex SwingLeft(CornerIndex corner) const {
+    return Next(Opposite(Next(corner)));
+  }
+
+  int num_vertices() const {
+    return static_cast<int>(vertex_to_attribute_entry_id_map_.size());
+  }
+  int num_faces() const { return static_cast<int>(corner_table_->num_faces()); }
+  int num_corners() const { return corner_table_->num_corners(); }
+
+  VertexIndex Vertex(CornerIndex corner) const {
+    DRACO_DCHECK_LT(corner.value(), corner_to_vertex_map_.size());
+    return ConfidentVertex(corner);
+  }
+  VertexIndex ConfidentVertex(CornerIndex corner) const {
+    return corner_to_vertex_map_[corner.value()];
+  }
+  // Returns the attribute entry id associated to the given vertex.
+  VertexIndex VertexParent(VertexIndex vert) const {
+    return VertexIndex(vertex_to_attribute_entry_id_map_[vert.value()].value());
+  }
+
+  inline CornerIndex LeftMostCorner(VertexIndex v) const {
+    return vertex_to_left_most_corner_map_[v.value()];
+  }
+
+  inline FaceIndex Face(CornerIndex corner) const {
+    return corner_table_->Face(corner);
+  }
+
+  inline CornerIndex FirstCorner(FaceIndex face) const {
+    return corner_table_->FirstCorner(face);
+  }
+
+  inline std::array<CornerIndex, 3> AllCorners(FaceIndex face) const {
+    return corner_table_->AllCorners(face);
+  }
+
+  inline bool IsOnBoundary(VertexIndex vert) const {
+    const CornerIndex corner = LeftMostCorner(vert);
+    if (corner == kInvalidCornerIndex) {
+      return true;
+    }
+    if (SwingLeft(corner) == kInvalidCornerIndex) {
+      return true;
+    }
+    return false;
+  }
+
+  bool no_interior_seams() const { return no_interior_seams_; }
+  const CornerTable *corner_table() const { return corner_table_; }
+
+  // TODO(draco-eng): extract valence functions into a reusable class/object
+  // also from 'corner_table.*'
+
+  // Returns the valence (or degree) of a vertex.
+  // Returns -1 if the given vertex index is not valid.
+  int Valence(VertexIndex v) const;
+  // Same as above but does not check for validity and does not return -1
+  int ConfidentValence(VertexIndex v) const;
+  // Returns the valence of the vertex at the given corner.
+  inline int Valence(CornerIndex c) const {
+    DRACO_DCHECK_LT(c.value(), corner_table_->num_corners());
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ConfidentValence(c);
+  }
+  inline int ConfidentValence(CornerIndex c) const {
+    DRACO_DCHECK_LT(c.value(), corner_table_->num_corners());
+    return ConfidentValence(Vertex(c));
+  }
+
+  // Allows access to an internal object for caching valences.  The object can
+  // be instructed to cache or uncache all valences and then its interfaces
+  // queried directly for valences with differing performance/confidence
+  // qualities.  If the mesh or table is modified the cache should be discarded
+  // and not relied on as it does not automatically update or invalidate for
+  // performance reasons.
+  const ValenceCache<MeshAttributeCornerTable> &GetValenceCache() const {
+    return valence_cache_;
+  }
+
+ private:
+  template <bool init_vertex_to_attribute_entry_map>
+  void RecomputeVerticesInternal(const Mesh *mesh, const PointAttribute *att);
+
+  std::vector<bool> is_edge_on_seam_;
+  std::vector<bool> is_vertex_on_seam_;
+
+  // If this is set to true, it means that there are no attribute seams between
+  // two faces. This can be used to speed up some algorithms.
+  bool no_interior_seams_;
+
+  std::vector<VertexIndex> corner_to_vertex_map_;
+
+  // Map between vertices and their associated left most corners. A left most
+  // corner is a corner that is adjacent to a boundary or an attribute seam from
+  // right (i.e., SwingLeft from that corner will return an invalid corner). If
+  // no such corner exists for a given vertex, then any corner attached to the
+  // vertex can be used.
+  std::vector<CornerIndex> vertex_to_left_most_corner_map_;
+
+  // Map between vertex ids and attribute entry ids (i.e. the values stored in
+  // the attribute buffer). The attribute entry id can be retrieved using the
+  // VertexParent() method.
+  std::vector<AttributeValueIndex> vertex_to_attribute_entry_id_map_;
+  const CornerTable *corner_table_;
+  ValenceCache<MeshAttributeCornerTable> valence_cache_;
+};
+
+}  // namespace draco
+#endif  // DRACO_MESH_MESH_ATTRIBUTE_CORNER_TABLE_H_
diff --git a/contrib/draco/src/draco/mesh/mesh_cleanup.cc b/contrib/draco/src/draco/mesh/mesh_cleanup.cc
new file mode 100644
index 000000000..75b55f045
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh_cleanup.cc
@@ -0,0 +1,251 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_cleanup.h"
+
+#include <unordered_set>
+
+#include "draco/core/hash_utils.h"
+
+namespace draco {
+
+bool MeshCleanup::operator()(Mesh *mesh, const MeshCleanupOptions &options) {
+  if (!options.remove_degenerated_faces && !options.remove_unused_attributes &&
+      !options.remove_duplicate_faces && !options.make_geometry_manifold) {
+    return true;  // Nothing to cleanup.
+  }
+  const PointAttribute *const pos_att =
+      mesh->GetNamedAttribute(GeometryAttribute::POSITION);
+  if (pos_att == nullptr) {
+    return false;
+  }
+
+  if (options.remove_degenerated_faces) {
+    RemoveDegeneratedFaces(mesh);
+  }
+
+  if (options.remove_duplicate_faces) {
+    RemoveDuplicateFaces(mesh);
+  }
+
+  if (options.remove_unused_attributes) {
+    RemoveUnusedAttributes(mesh);
+  }
+
+  return true;
+}
+
+void MeshCleanup::RemoveDegeneratedFaces(Mesh *mesh) {
+  const PointAttribute *const pos_att =
+      mesh->GetNamedAttribute(GeometryAttribute::POSITION);
+  FaceIndex::ValueType num_degenerated_faces = 0;
+  // Array for storing position indices on a face.
+  std::array<AttributeValueIndex, 3> pos_indices;
+  for (FaceIndex f(0); f < mesh->num_faces(); ++f) {
+    const Mesh::Face &face = mesh->face(f);
+    for (int p = 0; p < 3; ++p) {
+      pos_indices[p] = pos_att->mapped_index(face[p]);
+    }
+    if (pos_indices[0] == pos_indices[1] || pos_indices[0] == pos_indices[2] ||
+        pos_indices[1] == pos_indices[2]) {
+      ++num_degenerated_faces;
+    } else if (num_degenerated_faces > 0) {
+      // Copy the face to its new location.
+      mesh->SetFace(f - num_degenerated_faces, face);
+    }
+  }
+  if (num_degenerated_faces > 0) {
+    mesh->SetNumFaces(mesh->num_faces() - num_degenerated_faces);
+  }
+}
+
+void MeshCleanup::RemoveDuplicateFaces(Mesh *mesh) {
+  const PointAttribute *const pos_att =
+      mesh->GetNamedAttribute(GeometryAttribute::POSITION);
+
+  typedef std::array<AttributeValueIndex::ValueType, 3> PosTriplet;
+  PosTriplet pos_indices;
+  std::unordered_set<PosTriplet, HashArray<PosTriplet>> is_face_used;
+
+  uint32_t num_duplicate_faces = 0;
+  for (FaceIndex fi(0); fi < mesh->num_faces(); ++fi) {
+    const auto f = mesh->face(fi);
+    for (int c = 0; c < 3; ++c) {
+      pos_indices[c] = pos_att->mapped_index(f[c]).value();
+    }
+    // Shift the position indices until the smallest index is the first one.
+    while (pos_indices[0] > pos_indices[1] || pos_indices[0] > pos_indices[2]) {
+      // Shift to the left.
+      std::swap(pos_indices[0], pos_indices[1]);
+      std::swap(pos_indices[1], pos_indices[2]);
+    }
+    // Check if have encountered the same position triplet on a different face.
+    if (is_face_used.find(pos_indices) != is_face_used.end()) {
+      // Duplicate face. Ignore it.
+      num_duplicate_faces++;
+    } else {
+      // Insert new face to the set.
+      is_face_used.insert(pos_indices);
+      if (num_duplicate_faces > 0) {
+        // Copy the face to its new location.
+        mesh->SetFace(fi - num_duplicate_faces, f);
+      }
+    }
+  }
+  if (num_duplicate_faces > 0) {
+    mesh->SetNumFaces(mesh->num_faces() - num_duplicate_faces);
+  }
+}
+
+void MeshCleanup::RemoveUnusedAttributes(Mesh *mesh) {
+  // Array that is going to store whether a corresponding point is used.
+  std::vector<bool> is_point_used;
+  PointIndex::ValueType num_new_points = 0;
+  is_point_used.resize(mesh->num_points(), false);
+  for (FaceIndex f(0); f < mesh->num_faces(); ++f) {
+    const Mesh::Face &face = mesh->face(f);
+    for (int p = 0; p < 3; ++p) {
+      if (!is_point_used[face[p].value()]) {
+        is_point_used[face[p].value()] = true;
+        ++num_new_points;
+      }
+    }
+  }
+
+  bool points_changed = false;
+  const PointIndex::ValueType num_original_points = mesh->num_points();
+  // Map from old points to the new ones.
+  IndexTypeVector<PointIndex, PointIndex> point_map(num_original_points);
+  if (num_new_points < static_cast<int>(mesh->num_points())) {
+    // Some of the points were removed. We need to remap the old points to the
+    // new ones.
+    num_new_points = 0;
+    for (PointIndex i(0); i < num_original_points; ++i) {
+      if (is_point_used[i.value()]) {
+        point_map[i] = num_new_points++;
+      } else {
+        point_map[i] = kInvalidPointIndex;
+      }
+    }
+    // Go over faces and update their points.
+    for (FaceIndex f(0); f < mesh->num_faces(); ++f) {
+      Mesh::Face face = mesh->face(f);
+      for (int p = 0; p < 3; ++p) {
+        face[p] = point_map[face[p]];
+      }
+      mesh->SetFace(f, face);
+    }
+    // Set the new number of points.
+    mesh->set_num_points(num_new_points);
+    points_changed = true;
+  } else {
+    // No points were removed. Initialize identity map between the old and new
+    // points.
+    for (PointIndex i(0); i < num_original_points; ++i) {
+      point_map[i] = i;
+    }
+  }
+
+  // Update index mapping for attributes.
+  IndexTypeVector<AttributeValueIndex, uint8_t> is_att_index_used;
+  IndexTypeVector<AttributeValueIndex, AttributeValueIndex> att_index_map;
+  for (int a = 0; a < mesh->num_attributes(); ++a) {
+    PointAttribute *const att = mesh->attribute(a);
+    // First detect which attribute entries are used (included in a point).
+    is_att_index_used.assign(att->size(), 0);
+    att_index_map.clear();
+    AttributeValueIndex::ValueType num_used_entries = 0;
+    for (PointIndex i(0); i < num_original_points; ++i) {
+      if (point_map[i] != kInvalidPointIndex) {
+        const AttributeValueIndex entry_id = att->mapped_index(i);
+        if (!is_att_index_used[entry_id]) {
+          is_att_index_used[entry_id] = 1;
+          ++num_used_entries;
+        }
+      }
+    }
+    bool att_indices_changed = false;
+    // If there are some unused attribute entries, remap the attribute values
+    // in the attribute buffer.
+    if (num_used_entries < static_cast<int>(att->size())) {
+      att_index_map.resize(att->size());
+      num_used_entries = 0;
+      for (AttributeValueIndex i(0); i < static_cast<uint32_t>(att->size());
+           ++i) {
+        if (is_att_index_used[i]) {
+          att_index_map[i] = num_used_entries;
+          if (i > num_used_entries) {
+            const uint8_t *const src_add = att->GetAddress(i);
+            att->buffer()->Write(
+                att->GetBytePos(AttributeValueIndex(num_used_entries)), src_add,
+                att->byte_stride());
+          }
+          ++num_used_entries;
+        }
+      }
+      // Update the number of unique entries in the vertex buffer.
+      att->Resize(num_used_entries);
+      att_indices_changed = true;
+    }
+    // If either the points or attribute indices have changed, we need to
+    // update the attribute index mapping.
+    if (points_changed || att_indices_changed) {
+      if (att->is_mapping_identity()) {
+        // The mapping was identity. It'll remain identity only if the
+        // number of point and attribute indices is still the same.
+        if (num_used_entries != static_cast<int>(mesh->num_points())) {
+          // We need to create an explicit mapping.
+          // First we need to initialize the explicit map to the original
+          // number of points to recreate the original identity map.
+          att->SetExplicitMapping(num_original_points);
+          // Set the entries of the explicit map to identity.
+          for (PointIndex::ValueType i = 0; i < num_original_points; ++i) {
+            att->SetPointMapEntry(PointIndex(i), AttributeValueIndex(i));
+          }
+        }
+      }
+      if (!att->is_mapping_identity()) {
+        // Explicit mapping between points and local attribute indices.
+        for (PointIndex i(0); i < num_original_points; ++i) {
+          // The new point id that maps to the currently processed attribute
+          // entry.
+          const PointIndex new_point_id = point_map[i];
+          if (new_point_id == kInvalidPointIndex) {
+            continue;
+          }
+          // Index of the currently processed attribute entry in the original
+          // mesh.
+          const AttributeValueIndex original_entry_index = att->mapped_index(i);
+          // New index of the same entry after unused entries were removed.
+          const AttributeValueIndex new_entry_index =
+              att_indices_changed ? att_index_map[original_entry_index]
+                                  : original_entry_index;
+
+          // Update the mapping. Note that the new point index is always smaller
+          // than the processed index |i|, making this operation safe.
+          att->SetPointMapEntry(new_point_id, new_entry_index);
+        }
+        // If the number of points changed, we need to set a new explicit map
+        // size.
+        att->SetExplicitMapping(mesh->num_points());
+      }
+    }
+  }
+}
+
+Status MeshCleanup::MakeGeometryManifold(Mesh *mesh) {
+  return Status(Status::DRACO_ERROR, "Unsupported function.");
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/mesh/mesh_cleanup.h b/contrib/draco/src/draco/mesh/mesh_cleanup.h
new file mode 100644
index 000000000..09aae2e1c
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh_cleanup.h
@@ -0,0 +1,65 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_CLEANUP_H_
+#define DRACO_MESH_MESH_CLEANUP_H_
+
+#include "draco/core/status.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Options used by the MeshCleanup class.
+struct MeshCleanupOptions {
+  MeshCleanupOptions()
+      : remove_degenerated_faces(true),
+        remove_duplicate_faces(true),
+        remove_unused_attributes(true),
+        make_geometry_manifold(false) {}
+  // If true, the cleanup tool removes any face where two or more vertices
+  // share the same position index.
+  bool remove_degenerated_faces;
+
+  // If true, the cleanup tool removes all duplicate faces. A pair of faces is
+  // duplicate if both faces share the same position indices on all vertices
+  // (that is, position values have to be duduplicated). Note that all
+  // non-position properties are currently ignored.
+  bool remove_duplicate_faces;
+
+  // If true, the cleanup tool removes any unused attribute value or unused
+  // point id. For example, it can be used to remove isolated vertices.
+  bool remove_unused_attributes;
+
+  // If true, the cleanup tool splits vertices along non-manifold edges and
+  // vertices. This ensures that the connectivity defined by position indices
+  // is manifold.
+  bool make_geometry_manifold;
+};
+
+// Tool that can be used for removing bad or unused data from draco::Meshes.
+class MeshCleanup {
+ public:
+  // Performs in-place cleanup of the input mesh according to the input options.
+  bool operator()(Mesh *mesh, const MeshCleanupOptions &options);
+
+ private:
+  static void RemoveDegeneratedFaces(Mesh *mesh);
+  static void RemoveDuplicateFaces(Mesh *mesh);
+  static void RemoveUnusedAttributes(Mesh *mesh);
+  static Status MakeGeometryManifold(Mesh *mesh);
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_CLEANUP_H_
diff --git a/contrib/draco/src/draco/mesh/mesh_cleanup_test.cc b/contrib/draco/src/draco/mesh/mesh_cleanup_test.cc
new file mode 100644
index 000000000..89c350e94
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh_cleanup_test.cc
@@ -0,0 +1,192 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_cleanup.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/vector_d.h"
+#include "draco/mesh/triangle_soup_mesh_builder.h"
+
+namespace draco {
+
+class MeshCleanupTest : public ::testing::Test {};
+
+TEST_F(MeshCleanupTest, TestDegneratedFaces) {
+  // This test verifies that the mesh cleanup tools removes degenerated faces.
+  TriangleSoupMeshBuilder mb;
+  mb.Start(2);
+  const int pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  // clang-format off
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(0),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(1),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data());
+  // clang-format on
+
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr) << "Failed to build the test mesh.";
+  ASSERT_EQ(mesh->num_faces(), 2) << "Wrong number of faces in the input mesh.";
+  MeshCleanupOptions cleanup_options;
+  MeshCleanup cleanup;
+  ASSERT_TRUE(cleanup(mesh.get(), cleanup_options))
+      << "Failed to cleanup the mesh.";
+  ASSERT_EQ(mesh->num_faces(), 1) << "Failed to remove degenerated faces.";
+}
+
+TEST_F(MeshCleanupTest, TestDegneratedFacesAndIsolatedVertices) {
+  // This test verifies that the mesh cleanup tools removes degenerated faces
+  // and isolated vertices.
+  TriangleSoupMeshBuilder mb;
+  mb.Start(2);
+  const int pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+
+  // Dummy integer attribute for which we do not expect the number of entries
+  // to change after the degnerate face and isolated vertex are removed.
+  const int int_att_id =
+      mb.AddAttribute(GeometryAttribute::GENERIC, 2, DT_INT32);
+
+  // clang-format off
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(0),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(int_att_id, FaceIndex(0),
+                               VectorD<int32_t, 2>(0, 0).data(),
+                               VectorD<int32_t, 2>(0, 1).data(),
+                               VectorD<int32_t, 2>(0, 2).data());
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(1),
+                               Vector3f(10.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(10.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(int_att_id, FaceIndex(1),
+                               VectorD<int32_t, 2>(0, 0).data(),
+                               VectorD<int32_t, 2>(0, 1).data(),
+                               VectorD<int32_t, 2>(0, 2).data());
+  // clang-format on
+
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr) << "Failed to build the test mesh.";
+  ASSERT_EQ(mesh->num_faces(), 2) << "Wrong number of faces in the input mesh.";
+  ASSERT_EQ(mesh->num_points(), 5)
+      << "Wrong number of point ids in the input mesh.";
+  ASSERT_EQ(mesh->attribute(int_att_id)->size(), 3);
+  const MeshCleanupOptions cleanup_options;
+  MeshCleanup cleanup;
+  ASSERT_TRUE(cleanup(mesh.get(), cleanup_options))
+      << "Failed to cleanup the mesh.";
+  ASSERT_EQ(mesh->num_faces(), 1) << "Failed to remove degenerated faces.";
+  ASSERT_EQ(mesh->num_points(), 3)
+      << "Failed to remove isolated attribute indices.";
+  ASSERT_EQ(mesh->attribute(int_att_id)->size(), 3);
+}
+
+TEST_F(MeshCleanupTest, TestAttributes) {
+  TriangleSoupMeshBuilder mb;
+  mb.Start(2);
+  const int pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  const int generic_att_id =
+      mb.AddAttribute(GeometryAttribute::GENERIC, 2, DT_FLOAT32);
+  // clang-format off
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(0),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(generic_att_id, FaceIndex(0),
+                               Vector2f(0.f, 0.f).data(),
+                               Vector2f(0.f, 0.f).data(),
+                               Vector2f(0.f, 0.f).data());
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(1),
+                               Vector3f(10.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(10.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(generic_att_id, FaceIndex(1),
+                               Vector2f(1.f, 0.f).data(),
+                               Vector2f(1.f, 0.f).data(),
+                               Vector2f(1.f, 0.f).data());
+  // clang-format on
+
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr) << "Failed to build the test mesh.";
+  ASSERT_EQ(mesh->num_faces(), 2) << "Wrong number of faces in the input mesh.";
+  ASSERT_EQ(mesh->num_points(), 5)
+      << "Wrong number of point ids in the input mesh.";
+  ASSERT_EQ(mesh->attribute(1)->size(), 2u)
+      << "Wrong number of generic attribute entries.";
+  const MeshCleanupOptions cleanup_options;
+  MeshCleanup cleanup;
+  ASSERT_TRUE(cleanup(mesh.get(), cleanup_options))
+      << "Failed to cleanup the mesh.";
+  ASSERT_EQ(mesh->num_faces(), 1) << "Failed to remove degenerated faces.";
+  ASSERT_EQ(mesh->num_points(), 3)
+      << "Failed to remove isolated attribute indices.";
+  ASSERT_EQ(mesh->attribute(0)->size(), 3u)
+      << "Wrong number of unique positions after cleanup.";
+  ASSERT_EQ(mesh->attribute(1)->size(), 1u)
+      << "Wrong number of generic attribute entries after cleanup.";
+}
+
+TEST_F(MeshCleanupTest, TestDuplicateFaces) {
+  TriangleSoupMeshBuilder mb;
+  mb.Start(5);
+  const int pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+
+  // Five faces where only two are unique.
+
+  // clang-format off
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(0),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(1),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(2),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 1.f).data());
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(3),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                              Vector3f(0.f, 0.f, 0.f).data());
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(4),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 1.f).data());
+  // clang-format on
+
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr);
+  ASSERT_EQ(mesh->num_faces(), 5);
+  const MeshCleanupOptions cleanup_options;
+  MeshCleanup cleanup;
+  ASSERT_TRUE(cleanup(mesh.get(), cleanup_options));
+  ASSERT_EQ(mesh->num_faces(), 2);
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/mesh/mesh_misc_functions.cc b/contrib/draco/src/draco/mesh/mesh_misc_functions.cc
new file mode 100644
index 000000000..4485b3369
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh_misc_functions.cc
@@ -0,0 +1,63 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_misc_functions.h"
+
+namespace draco {
+
+std::unique_ptr<CornerTable> CreateCornerTableFromPositionAttribute(
+    const Mesh *mesh) {
+  return CreateCornerTableFromAttribute(mesh, GeometryAttribute::POSITION);
+}
+
+std::unique_ptr<CornerTable> CreateCornerTableFromAttribute(
+    const Mesh *mesh, GeometryAttribute::Type type) {
+  typedef CornerTable::FaceType FaceType;
+
+  const PointAttribute *const att = mesh->GetNamedAttribute(type);
+  if (att == nullptr) {
+    return nullptr;
+  }
+  IndexTypeVector<FaceIndex, FaceType> faces(mesh->num_faces());
+  FaceType new_face;
+  for (FaceIndex i(0); i < mesh->num_faces(); ++i) {
+    const Mesh::Face &face = mesh->face(i);
+    for (int j = 0; j < 3; ++j) {
+      // Map general vertex indices to attribute indices.
+      new_face[j] = att->mapped_index(face[j]).value();
+    }
+    faces[FaceIndex(i)] = new_face;
+  }
+  // Build the corner table.
+  return CornerTable::Create(faces);
+}
+
+std::unique_ptr<CornerTable> CreateCornerTableFromAllAttributes(
+    const Mesh *mesh) {
+  typedef CornerTable::FaceType FaceType;
+  IndexTypeVector<FaceIndex, FaceType> faces(mesh->num_faces());
+  FaceType new_face;
+  for (FaceIndex i(0); i < mesh->num_faces(); ++i) {
+    const Mesh::Face &face = mesh->face(i);
+    // Each face is identified by point indices that automatically split the
+    // mesh along attribute seams.
+    for (int j = 0; j < 3; ++j) {
+      new_face[j] = face[j].value();
+    }
+    faces[i] = new_face;
+  }
+  // Build the corner table.
+  return CornerTable::Create(faces);
+}
+}  // namespace draco
diff --git a/contrib/draco/src/draco/mesh/mesh_misc_functions.h b/contrib/draco/src/draco/mesh/mesh_misc_functions.h
new file mode 100644
index 000000000..b450bc80c
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh_misc_functions.h
@@ -0,0 +1,98 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file contains misc functions that are needed by several mesh related
+// algorithms.
+
+#ifndef DRACO_MESH_MESH_MISC_FUNCTIONS_H_
+#define DRACO_MESH_MESH_MISC_FUNCTIONS_H_
+
+#include "draco/mesh/corner_table.h"
+#include "draco/mesh/mesh.h"
+
+// The file contains functions that use both Mesh and CornerTable as inputs.
+namespace draco {
+
+// Creates a CornerTable from the position attribute of |mesh|. Returns nullptr
+// on error.
+std::unique_ptr<CornerTable> CreateCornerTableFromPositionAttribute(
+    const Mesh *mesh);
+
+// Creates a CornerTable from the first named attribute of |mesh| with a given
+// type. Returns nullptr on error.
+std::unique_ptr<CornerTable> CreateCornerTableFromAttribute(
+    const Mesh *mesh, GeometryAttribute::Type type);
+
+// Creates a CornerTable from all attributes of |mesh|. Boundaries are
+// automatically introduced on all attribute seams. Returns nullptr on error.
+std::unique_ptr<CornerTable> CreateCornerTableFromAllAttributes(
+    const Mesh *mesh);
+
+// Returns true when the given corner lies opposite to an attribute seam.
+inline bool IsCornerOppositeToAttributeSeam(CornerIndex ci,
+                                            const PointAttribute &att,
+                                            const Mesh &mesh,
+                                            const CornerTable &ct) {
+  const CornerIndex opp_ci = ct.Opposite(ci);
+  if (opp_ci == kInvalidCornerIndex) {
+    return false;  // No opposite corner == no attribute seam.
+  }
+  // Compare attribute value indices on both ends of the opposite edge.
+  CornerIndex c0 = ct.Next(ci);
+  CornerIndex c1 = ct.Previous(opp_ci);
+  if (att.mapped_index(mesh.CornerToPointId(c0)) !=
+      att.mapped_index(mesh.CornerToPointId(c1))) {
+    return true;
+  }
+  c0 = ct.Previous(ci);
+  c1 = ct.Next(opp_ci);
+  if (att.mapped_index(mesh.CornerToPointId(c0)) !=
+      att.mapped_index(mesh.CornerToPointId(c1))) {
+    return true;
+  }
+  return false;
+}
+
+// Interpolates an attribute value on a face using given barycentric
+// coordinates. InterpolatedVectorT should be a VectorD that corresponds to the
+// values stored in the attribute.
+// TODO(ostava): Find a better place for this.
+template <typename InterpolatedVectorT>
+InterpolatedVectorT ComputeInterpolatedAttributeValueOnMeshFace(
+    const Mesh &mesh, const PointAttribute &attribute, FaceIndex fi,
+    const std::array<float, 3> &barycentric_coord) {
+  const Mesh::Face &face = mesh.face(fi);
+  // Get values for all three corners of the face.
+  InterpolatedVectorT val[3];
+  for (int c = 0; c < 3; ++c) {
+    attribute.GetMappedValue(face[c], &(val[c][0]));
+  }
+  // Return an interpolated value.
+  InterpolatedVectorT res;
+  for (int d = 0; d < InterpolatedVectorT::dimension; ++d) {
+    const float interpolated_component = barycentric_coord[0] * val[0][d] +
+                                         barycentric_coord[1] * val[1][d] +
+                                         barycentric_coord[2] * val[2][d];
+    if (std::is_integral<typename InterpolatedVectorT::Scalar>::value) {
+      res[d] = std::floor(interpolated_component + 0.5f);
+    } else {
+      res[d] = interpolated_component;
+    }
+  }
+  return res;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_MISC_FUNCTIONS_H_
diff --git a/contrib/draco/src/draco/mesh/mesh_stripifier.cc b/contrib/draco/src/draco/mesh/mesh_stripifier.cc
new file mode 100644
index 000000000..f68062eba
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh_stripifier.cc
@@ -0,0 +1,102 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/mesh_stripifier.h"
+
+namespace draco {
+
+void MeshStripifier::GenerateStripsFromCorner(int local_strip_id,
+                                              CornerIndex ci) {
+  // Clear the storage for strip faces.
+  strip_faces_[local_strip_id].clear();
+  // Start corner of the strip (where the strip starts).
+  CornerIndex start_ci = ci;
+  FaceIndex fi = corner_table_->Face(ci);
+  // We need to grow the strip both forward and backward (2 passes).
+  // Note that the backward pass can change the start corner of the strip (the
+  // start corner is going to be moved to the end of the backward strip).
+  for (int pass = 0; pass < 2; ++pass) {
+    if (pass == 1) {
+      // Backward pass.
+      // Start the traversal from the B that is the left sibling of the next
+      // corner to the start corner C = |start_ci|.
+      //
+      //      *-------*-------*-------*
+      //     / \     / \C    / \     /
+      //    /   \   /   \   /   \   /
+      //   /     \ /    B\ /     \ /
+      //  *-------*-------*-------*
+      //
+      // Perform the backward pass only when there is no attribute seam between
+      // the initial face and the first face of the backward traversal.
+      if (GetOppositeCorner(corner_table_->Previous(start_ci)) ==
+          kInvalidCornerIndex) {
+        break;  // Attribute seam or a boundary.
+      }
+
+      ci = corner_table_->Next(start_ci);
+      ci = corner_table_->SwingLeft(ci);
+      if (ci == kInvalidCornerIndex) {
+        break;
+      }
+
+      fi = corner_table_->Face(ci);
+    }
+    int num_added_faces = 0;
+    while (!is_face_visited_[fi]) {
+      is_face_visited_[fi] = true;
+      strip_faces_[local_strip_id].push_back(fi);
+      ++num_added_faces;
+      if (num_added_faces > 1) {
+        // Move to the correct source corner to traverse to the next face.
+        if (num_added_faces & 1) {
+          // Odd number of faces added.
+          ci = corner_table_->Next(ci);
+        } else {
+          // Even number of faces added.
+          if (pass == 1) {
+            // If we are processing the backward pass, update the start corner
+            // of the strip on every even face reached (we cannot use odd faces
+            // for start of the strip as the strips would start in a wrong
+            // direction).
+            start_ci = ci;
+          }
+          ci = corner_table_->Previous(ci);
+        }
+      }
+      ci = GetOppositeCorner(ci);
+      if (ci == kInvalidCornerIndex) {
+        break;
+      }
+      fi = corner_table_->Face(ci);
+    }
+    // Strip end reached.
+    if (pass == 1 && (num_added_faces & 1)) {
+      // If we processed the backward strip and we add an odd number of faces to
+      // the strip, we need to remove the last one as it cannot be used to start
+      // the strip (the strip would start in a wrong direction from that face).
+      is_face_visited_[strip_faces_[local_strip_id].back()] = false;
+      strip_faces_[local_strip_id].pop_back();
+    }
+  }
+  strip_start_corners_[local_strip_id] = start_ci;
+
+  // Reset all visited flags for all faces (we need to process other strips from
+  // the given face before we choose the final strip that we are going to use).
+  for (int i = 0; i < strip_faces_[local_strip_id].size(); ++i) {
+    is_face_visited_[strip_faces_[local_strip_id][i]] = false;
+  }
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/mesh/mesh_stripifier.h b/contrib/draco/src/draco/mesh/mesh_stripifier.h
new file mode 100644
index 000000000..262e3c792
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/mesh_stripifier.h
@@ -0,0 +1,260 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_MESH_STRIPIFIER_H_
+#define DRACO_MESH_MESH_STRIPIFIER_H_
+
+#include "draco/mesh/mesh_misc_functions.h"
+
+namespace draco {
+
+// Class that generates triangle strips from a provided draco::Mesh data
+// structure. The strips represent a more memory efficient storage of triangle
+// connectivity that can be used directly on the GPU (see
+// https://en.wikipedia.org/wiki/Triangle_strip ). In general, a mesh needs to
+// be represented by several triangle strips and it has been proven that finding
+// the optimal set of triangle strips is an NP-complete problem. The algorithm
+// implemented by this class finds this set of triangle strips based on a greedy
+// heuristic that always selects the longest available strip that covers the
+// next unprocessed face. The longest strip is found by analyzing all strips
+// that can cover the given face (three strips corresponding to three
+// directions).
+class MeshStripifier {
+ public:
+  MeshStripifier()
+      : mesh_(nullptr),
+        num_strips_(0),
+        num_encoded_faces_(0),
+        last_encoded_point_(kInvalidPointIndex) {}
+
+  // Generate triangle strips for a given mesh and output them to the output
+  // iterator |out_it|. In most cases |out_it| stores the values in a buffer
+  // that can be used directly on the GPU. Note that the algorithm can generate
+  // multiple strips to represent the whole mesh. In such cases multiple strips
+  // are separated using a so called primitive restart index that is specified
+  // by the |primitive_restart_index| (usually defined as the maximum allowed
+  // value for the given type).
+  // https://www.khronos.org/opengl/wiki/Vertex_Rendering#Primitive_Restart
+  template <typename OutputIteratorT, typename IndexTypeT>
+  bool GenerateTriangleStripsWithPrimitiveRestart(
+      const Mesh &mesh, IndexTypeT primitive_restart_index,
+      OutputIteratorT out_it);
+
+  // The same as above but disjoint triangle strips are separated by degenerate
+  // triangles instead of the primitive restart index. Degenerate triangles are
+  // zero area triangles that are automatically discarded by the GPU. Using
+  // degenerate triangles usually results in a slightly longer output indices
+  // array compared to the similar triangle strips that use primitive restart
+  // index. The advantage of this method is that it is supported by all hardware
+  // and all relevant APIs (including WebGL 1.0).
+  template <typename OutputIteratorT>
+  bool GenerateTriangleStripsWithDegenerateTriangles(const Mesh &mesh,
+                                                     OutputIteratorT out_it);
+
+  // Returns the number of strips generated by the last call of the
+  // GenerateTriangleStrips() method.
+  int num_strips() const { return num_strips_; }
+
+ private:
+  bool Prepare(const Mesh &mesh) {
+    mesh_ = &mesh;
+    num_strips_ = 0;
+    num_encoded_faces_ = 0;
+    // TODO(ostava): We may be able to avoid computing the corner table if we
+    // already have it stored somewhere.
+    corner_table_ = CreateCornerTableFromPositionAttribute(mesh_);
+    if (corner_table_ == nullptr) {
+      return false;
+    }
+
+    // Mark all faces as unvisited.
+    is_face_visited_.assign(mesh.num_faces(), false);
+    return true;
+  }
+
+  // Returns local id of the longest strip that can be created from the given
+  // face |fi|.
+  int FindLongestStripFromFace(FaceIndex fi) {
+    // There are three possible strip directions that can contain the provided
+    // input face. We try all of them and select the direction that result in
+    // the longest strip.
+    const CornerIndex first_ci = corner_table_->FirstCorner(fi);
+    int longest_strip_id = -1;
+    int longest_strip_length = 0;
+    for (int i = 0; i < 3; ++i) {
+      GenerateStripsFromCorner(i, first_ci + i);
+      if (strip_faces_[i].size() > longest_strip_length) {
+        longest_strip_length = static_cast<int>(strip_faces_[i].size());
+        longest_strip_id = i;
+      }
+    }
+    return longest_strip_id;
+  }
+
+  // Generates strip from the data stored in |strip_faces_| and
+  // |strip_start_start_corners_| and stores it to |out_it|.
+  template <typename OutputIteratorT>
+  void StoreStrip(int local_strip_id, OutputIteratorT out_it) {
+    ++num_strips_;
+
+    const int num_strip_faces = strip_faces_[local_strip_id].size();
+    CornerIndex ci = strip_start_corners_[local_strip_id];
+    for (int i = 0; i < num_strip_faces; ++i) {
+      const FaceIndex fi = corner_table_->Face(ci);
+      is_face_visited_[fi] = true;
+      ++num_encoded_faces_;
+
+      if (i == 0) {
+        // Add the start face (three indices).
+        *out_it++ = CornerToPointIndex(ci).value();
+        *out_it++ = CornerToPointIndex(corner_table_->Next(ci)).value();
+        last_encoded_point_ = CornerToPointIndex(corner_table_->Previous(ci));
+        *out_it++ = last_encoded_point_.value();
+      } else {
+        // Store the point on the newly reached corner.
+        last_encoded_point_ = CornerToPointIndex(ci);
+        *out_it++ = last_encoded_point_.value();
+
+        // Go to the correct source corner to proceed to the next face.
+        if (i & 1) {
+          ci = corner_table_->Previous(ci);
+        } else {
+          ci = corner_table_->Next(ci);
+        }
+      }
+      ci = corner_table_->Opposite(ci);
+    }
+  }
+
+  PointIndex CornerToPointIndex(CornerIndex ci) const {
+    return mesh_->CornerToPointId(ci);
+  }
+
+  // Returns the opposite corner in case the opposite triangle does not lie
+  // across an attribute seam. Otherwise return kInvalidCornerIndex.
+  CornerIndex GetOppositeCorner(CornerIndex ci) const {
+    const CornerIndex oci = corner_table_->Opposite(ci);
+    if (oci < 0) {
+      return kInvalidCornerIndex;
+    }
+    // Ensure the point ids are same on both sides of the shared edge between
+    // the triangles.
+    if (CornerToPointIndex(corner_table_->Next(ci)) !=
+        CornerToPointIndex(corner_table_->Previous(oci))) {
+      return kInvalidCornerIndex;
+    }
+    if (CornerToPointIndex(corner_table_->Previous(ci)) !=
+        CornerToPointIndex(corner_table_->Next(oci))) {
+      return kInvalidCornerIndex;
+    }
+    return oci;
+  }
+
+  void GenerateStripsFromCorner(int local_strip_id, CornerIndex ci);
+
+  const Mesh *mesh_;
+  std::unique_ptr<CornerTable> corner_table_;
+
+  // Store strip faces for each of three possible directions from a given face.
+  std::vector<FaceIndex> strip_faces_[3];
+  // Start corner for each direction of the strip containing the processed face.
+  CornerIndex strip_start_corners_[3];
+  IndexTypeVector<FaceIndex, bool> is_face_visited_;
+  // The number of strips generated by this method.
+  int num_strips_;
+  // The number of encoded triangles.
+  int num_encoded_faces_;
+  // Last encoded point.
+  PointIndex last_encoded_point_;
+};
+
+template <typename OutputIteratorT, typename IndexTypeT>
+bool MeshStripifier::GenerateTriangleStripsWithPrimitiveRestart(
+    const Mesh &mesh, IndexTypeT primitive_restart_index,
+    OutputIteratorT out_it) {
+  if (!Prepare(mesh)) {
+    return false;
+  }
+
+  // Go over all faces and generate strips from the first unvisited one.
+  for (FaceIndex fi(0); fi < mesh.num_faces(); ++fi) {
+    if (is_face_visited_[fi]) {
+      continue;
+    }
+
+    const int longest_strip_id = FindLongestStripFromFace(fi);
+
+    // Separate triangle strips with the primitive restart index.
+    if (num_strips_ > 0) {
+      *out_it++ = primitive_restart_index;
+    }
+
+    StoreStrip(longest_strip_id, out_it);
+  }
+
+  return true;
+}
+
+template <typename OutputIteratorT>
+bool MeshStripifier::GenerateTriangleStripsWithDegenerateTriangles(
+    const Mesh &mesh, OutputIteratorT out_it) {
+  if (!Prepare(mesh)) {
+    return false;
+  }
+
+  // Go over all faces and generate strips from the first unvisited one.
+  for (FaceIndex fi(0); fi < mesh.num_faces(); ++fi) {
+    if (is_face_visited_[fi]) {
+      continue;
+    }
+
+    const int longest_strip_id = FindLongestStripFromFace(fi);
+
+    // Separate triangle strips by degenerate triangles. There will be either
+    // three or four degenerate triangles inserted based on the number of
+    // triangles that are already encoded in the output strip (three degenerate
+    // triangles for even number of existing triangles, four degenerate
+    // triangles for odd number of triangles).
+    if (num_strips_ > 0) {
+      // Duplicate last encoded index (first degenerate face).
+      *out_it++ = last_encoded_point_.value();
+
+      // Connect it to the start point of the new triangle strip (second
+      // degenerate face).
+      const CornerIndex new_start_corner =
+          strip_start_corners_[longest_strip_id];
+      const PointIndex new_start_point = CornerToPointIndex(new_start_corner);
+      *out_it++ = new_start_point.value();
+      num_encoded_faces_ += 2;
+      // If we have previously encoded number of faces we need to duplicate the
+      // point one more time to preserve the correct orientation of the next
+      // strip.
+      if (num_encoded_faces_ & 1) {
+        *out_it++ = new_start_point.value();
+        num_encoded_faces_ += 1;
+      }
+      // The last degenerate face will be added implicitly in the StoreStrip()
+      // function below as the first point index is going to be encoded there
+      // again.
+    }
+
+    StoreStrip(longest_strip_id, out_it);
+  }
+
+  return true;
+}
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_MESH_STRIPIFIER_H_
diff --git a/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.cc b/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.cc
new file mode 100644
index 000000000..60b0c50b8
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.cc
@@ -0,0 +1,89 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/triangle_soup_mesh_builder.h"
+
+namespace draco {
+
+void TriangleSoupMeshBuilder::Start(int num_faces) {
+  mesh_ = std::unique_ptr<Mesh>(new Mesh());
+  mesh_->SetNumFaces(num_faces);
+  mesh_->set_num_points(num_faces * 3);
+  attribute_element_types_.clear();
+}
+
+int TriangleSoupMeshBuilder::AddAttribute(
+    GeometryAttribute::Type attribute_type, int8_t num_components,
+    DataType data_type) {
+  GeometryAttribute va;
+  va.Init(attribute_type, nullptr, num_components, data_type, false,
+          DataTypeLength(data_type) * num_components, 0);
+  attribute_element_types_.push_back(-1);
+  return mesh_->AddAttribute(va, true, mesh_->num_points());
+}
+
+void TriangleSoupMeshBuilder::SetAttributeValuesForFace(
+    int att_id, FaceIndex face_id, const void *corner_value_0,
+    const void *corner_value_1, const void *corner_value_2) {
+  const int start_index = 3 * face_id.value();
+  PointAttribute *const att = mesh_->attribute(att_id);
+  att->SetAttributeValue(AttributeValueIndex(start_index), corner_value_0);
+  att->SetAttributeValue(AttributeValueIndex(start_index + 1), corner_value_1);
+  att->SetAttributeValue(AttributeValueIndex(start_index + 2), corner_value_2);
+  // TODO(ostava): The below code should be called only for one attribute.
+  // It will work OK even for multiple attributes, but it's redundant.
+  mesh_->SetFace(face_id,
+                 {{PointIndex(start_index), PointIndex(start_index + 1),
+                   PointIndex(start_index + 2)}});
+  attribute_element_types_[att_id] = MESH_CORNER_ATTRIBUTE;
+}
+
+void TriangleSoupMeshBuilder::SetPerFaceAttributeValueForFace(
+    int att_id, FaceIndex face_id, const void *value) {
+  const int start_index = 3 * face_id.value();
+  PointAttribute *const att = mesh_->attribute(att_id);
+  att->SetAttributeValue(AttributeValueIndex(start_index), value);
+  att->SetAttributeValue(AttributeValueIndex(start_index + 1), value);
+  att->SetAttributeValue(AttributeValueIndex(start_index + 2), value);
+  mesh_->SetFace(face_id,
+                 {{PointIndex(start_index), PointIndex(start_index + 1),
+                   PointIndex(start_index + 2)}});
+  int8_t &element_type = attribute_element_types_[att_id];
+  if (element_type < 0) {
+    element_type = MESH_FACE_ATTRIBUTE;
+  }
+}
+
+std::unique_ptr<Mesh> TriangleSoupMeshBuilder::Finalize() {
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  // First deduplicate attribute values.
+  if (!mesh_->DeduplicateAttributeValues()) {
+    return nullptr;
+  }
+#endif
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // Also deduplicate vertex indices.
+  mesh_->DeduplicatePointIds();
+#endif
+  for (size_t i = 0; i < attribute_element_types_.size(); ++i) {
+    if (attribute_element_types_[i] >= 0) {
+      mesh_->SetAttributeElementType(
+          static_cast<int>(i),
+          static_cast<MeshAttributeElementType>(attribute_element_types_[i]));
+    }
+  }
+  return std::move(mesh_);
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.h b/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.h
new file mode 100644
index 000000000..89466e1d8
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder.h
@@ -0,0 +1,63 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_TRIANGLE_SOUP_MESH_BUILDER_H_
+#define DRACO_MESH_TRIANGLE_SOUP_MESH_BUILDER_H_
+
+#include "draco/draco_features.h"
+#include "draco/mesh/mesh.h"
+
+namespace draco {
+
+// Class for building meshes directly from attribute values that can be
+// specified for each face corner. All attributes are automatically
+// deduplicated.
+class TriangleSoupMeshBuilder {
+ public:
+  // Starts mesh building for a given number of faces.
+  // TODO(ostava): Currently it's necessary to select the correct number of
+  // faces upfront. This should be generalized, but it will require us to
+  // rewrite our attribute resizing functions.
+  void Start(int num_faces);
+
+  // Adds an empty attribute to the mesh. Returns the new attribute's id.
+  int AddAttribute(GeometryAttribute::Type attribute_type,
+                   int8_t num_components, DataType data_type);
+
+  // Sets values for a given attribute on all corners of a given face.
+  void SetAttributeValuesForFace(int att_id, FaceIndex face_id,
+                                 const void *corner_value_0,
+                                 const void *corner_value_1,
+                                 const void *corner_value_2);
+
+  // Sets value for a per-face attribute. If all faces of a given attribute are
+  // set with this method, the attribute will be marked as per-face, otherwise
+  // it will be marked as per-corner attribute.
+  void SetPerFaceAttributeValueForFace(int att_id, FaceIndex face_id,
+                                       const void *value);
+
+  // Finalizes the mesh or returns nullptr on error.
+  // Once this function is called, the builder becomes invalid and cannot be
+  // used until the method Start() is called again.
+  std::unique_ptr<Mesh> Finalize();
+
+ private:
+  std::vector<int8_t> attribute_element_types_;
+
+  std::unique_ptr<Mesh> mesh_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_TRIANGLE_SOUP_MESH_BUILDER_H_
diff --git a/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder_test.cc b/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder_test.cc
new file mode 100644
index 000000000..171f8fe24
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/triangle_soup_mesh_builder_test.cc
@@ -0,0 +1,197 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/mesh/triangle_soup_mesh_builder.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/vector_d.h"
+
+namespace draco {
+
+class TriangleSoupMeshBuilderTest : public ::testing::Test {};
+
+TEST_F(TriangleSoupMeshBuilderTest, CubeTest) {
+  // This tests, verifies that the mesh builder constructs a valid cube out
+  // of the provided triangle soup data.
+  TriangleSoupMeshBuilder mb;
+  mb.Start(12);
+  const int pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  // clang-format off
+  // Front face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(0),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(1),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data());
+
+  // Back face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(2),
+                               Vector3f(0.f, 1.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(3),
+                               Vector3f(1.f, 1.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 1.f, 1.f).data());
+
+  // Top face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(4),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 1.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(5),
+                               Vector3f(0.f, 1.f, 1.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 1.f, 1.f).data());
+
+  // Bottom face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(6),
+                               Vector3f(0.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 0.f, 0.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(7),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data());
+
+  // Right face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(8),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(9),
+                               Vector3f(1.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 1.f, 1.f).data());
+
+  // Left face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(10),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 0.f, 0.f).data());
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(11),
+                               Vector3f(0.f, 1.f, 1.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  // clang-format on
+
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr) << "Failed to build the cube mesh.";
+  EXPECT_EQ(mesh->num_points(), 8) << "Unexpected number of vertices.";
+  EXPECT_EQ(mesh->num_faces(), 12) << "Unexpected number of faces.";
+}
+
+TEST_F(TriangleSoupMeshBuilderTest, TestPerFaceAttribs) {
+  // This tests, verifies that the mesh builder constructs a valid cube with
+  // per face Boolean attributes.
+  TriangleSoupMeshBuilder mb;
+  mb.Start(12);
+  const int pos_att_id =
+      mb.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  const int gen_att_id =
+      mb.AddAttribute(GeometryAttribute::GENERIC, 1, DT_BOOL);
+  uint8_t bool_true = 1;
+  uint8_t bool_false = 0;
+  // clang-format off
+  // Front face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(0),
+                               Vector3f(0.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(0), &bool_false);
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(1),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(1), &bool_true);
+
+  // Back face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(2),
+                               Vector3f(0.f, 1.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(2), &bool_true);
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(3),
+                               Vector3f(1.f, 1.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 1.f, 1.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(3), &bool_true);
+
+  // Top face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(4),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data(),
+                               Vector3f(0.f, 1.f, 1.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(4), &bool_false);;
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(5),
+                               Vector3f(0.f, 1.f, 1.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 1.f, 1.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(5), &bool_false);
+
+  // Bottom face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(6),
+                               Vector3f(0.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 0.f, 0.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(6), &bool_true);
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(7),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(7), &bool_true);
+
+  // Right face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(8),
+                               Vector3f(1.f, 0.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 1.f, 0.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(8), &bool_false);
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(9),
+                               Vector3f(1.f, 1.f, 0.f).data(),
+                               Vector3f(1.f, 0.f, 1.f).data(),
+                               Vector3f(1.f, 1.f, 1.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(9), &bool_true);
+
+  // Left face.
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(10),
+                               Vector3f(0.f, 1.f, 0.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 0.f, 0.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(10), &bool_true);
+
+  mb.SetAttributeValuesForFace(pos_att_id, FaceIndex(11),
+                               Vector3f(0.f, 1.f, 1.f).data(),
+                               Vector3f(0.f, 0.f, 1.f).data(),
+                               Vector3f(0.f, 1.f, 0.f).data());
+  mb.SetPerFaceAttributeValueForFace(gen_att_id, FaceIndex(11), &bool_false);
+  // clang-format on
+
+  std::unique_ptr<Mesh> mesh = mb.Finalize();
+  ASSERT_NE(mesh, nullptr) << "Failed to build the cube mesh.";
+  EXPECT_EQ(mesh->num_faces(), 12) << "Unexpected number of faces.";
+  EXPECT_EQ(mesh->GetAttributeElementType(gen_att_id), MESH_FACE_ATTRIBUTE)
+      << "Unexpected attribute element type.";
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/mesh/valence_cache.h b/contrib/draco/src/draco/mesh/valence_cache.h
new file mode 100644
index 000000000..3540377db
--- /dev/null
+++ b/contrib/draco/src/draco/mesh/valence_cache.h
@@ -0,0 +1,142 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_MESH_VALENCE_CACHE_H_
+#define DRACO_MESH_VALENCE_CACHE_H_
+
+#include "draco/attributes/geometry_indices.h"
+#include "draco/core/draco_index_type_vector.h"
+#include "draco/core/macros.h"
+
+namespace draco {
+
+// ValenceCache provides support for the caching of valences off of some kind of
+// CornerTable 'type' of class.
+// No valences should be queried before Caching is
+// performed and values should be removed/recached when changes to the
+// underlying mesh are taking place.
+
+template <class CornerTableT>
+class ValenceCache {
+  const CornerTableT &table_;
+
+ public:
+  explicit ValenceCache(const CornerTableT &table) : table_(table) {}
+
+  // Do not call before CacheValences() / CacheValencesInaccurate().
+  inline int8_t ValenceFromCacheInaccurate(CornerIndex c) const {
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ValenceFromCacheInaccurate(table_.Vertex(c));
+  }
+  inline int32_t ValenceFromCache(CornerIndex c) const {
+    if (c == kInvalidCornerIndex) {
+      return -1;
+    }
+    return ValenceFromCache(table_.Vertex(c));
+  }
+
+  inline int32_t ConfidentValenceFromCache(VertexIndex v) const {
+    DRACO_DCHECK_LT(v.value(), table_.num_vertices());
+    DRACO_DCHECK_EQ(vertex_valence_cache_32_bit_.size(), table_.num_vertices());
+    return vertex_valence_cache_32_bit_[v];
+  }
+
+  // Collect the valence for all vertices so they can be reused later.  The
+  // 'inaccurate' versions of this family of functions clips the true valence
+  // of the vertices to 8 signed bits as a space optimization.  This clipping
+  // will lead to occasionally wrong results.  If accurate results are required
+  // under all circumstances, do not use the 'inaccurate' version or else
+  // use it and fetch the correct result in the event the value appears clipped.
+  // The topology of the mesh should be a constant when Valence Cache functions
+  // are being used.  Modification of the mesh while cache(s) are filled will
+  // not guarantee proper results on subsequent calls unless they are rebuilt.
+  void CacheValencesInaccurate() const {
+    if (vertex_valence_cache_8_bit_.size() == 0) {
+      const VertexIndex vertex_count = VertexIndex(table_.num_vertices());
+      vertex_valence_cache_8_bit_.resize(vertex_count.value());
+      for (VertexIndex v = VertexIndex(0); v < vertex_count; v += 1) {
+        vertex_valence_cache_8_bit_[v] = static_cast<int8_t>(
+            (std::min)(static_cast<int32_t>(std::numeric_limits<int8_t>::max()),
+                       table_.Valence(v)));
+      }
+    }
+  }
+  void CacheValences() const {
+    if (vertex_valence_cache_32_bit_.size() == 0) {
+      const VertexIndex vertex_count = VertexIndex(table_.num_vertices());
+      vertex_valence_cache_32_bit_.resize(vertex_count.value());
+      for (VertexIndex v = VertexIndex(0); v < vertex_count; v += 1) {
+        vertex_valence_cache_32_bit_[v] = table_.Valence(v);
+      }
+    }
+  }
+
+  inline int8_t ConfidentValenceFromCacheInaccurate(CornerIndex c) const {
+    DRACO_DCHECK_GE(c.value(), 0);
+    return ConfidentValenceFromCacheInaccurate(table_.ConfidentVertex(c));
+  }
+  inline int32_t ConfidentValenceFromCache(CornerIndex c) const {
+    DRACO_DCHECK_GE(c.value(), 0);
+    return ConfidentValenceFromCache(table_.ConfidentVertex(c));
+  }
+  inline int8_t ValenceFromCacheInaccurate(VertexIndex v) const {
+    DRACO_DCHECK_EQ(vertex_valence_cache_8_bit_.size(), table_.num_vertices());
+    if (v == kInvalidVertexIndex || v.value() >= table_.num_vertices()) {
+      return -1;
+    }
+    return ConfidentValenceFromCacheInaccurate(v);
+  }
+  inline int8_t ConfidentValenceFromCacheInaccurate(VertexIndex v) const {
+    DRACO_DCHECK_LT(v.value(), table_.num_vertices());
+    DRACO_DCHECK_EQ(vertex_valence_cache_8_bit_.size(), table_.num_vertices());
+    return vertex_valence_cache_8_bit_[v];
+  }
+
+  // TODO(draco-eng) Add unit tests for ValenceCache functions.
+  inline int32_t ValenceFromCache(VertexIndex v) const {
+    DRACO_DCHECK_EQ(vertex_valence_cache_32_bit_.size(), table_.num_vertices());
+    if (v == kInvalidVertexIndex || v.value() >= table_.num_vertices()) {
+      return -1;
+    }
+    return ConfidentValenceFromCache(v);
+  }
+
+  // Clear the cache of valences and deallocate the memory.
+  void ClearValenceCacheInaccurate() const {
+    vertex_valence_cache_8_bit_.clear();
+    // Force erasure.
+    IndexTypeVector<VertexIndex, int8_t>().swap(vertex_valence_cache_8_bit_);
+  }
+  void ClearValenceCache() const {
+    vertex_valence_cache_32_bit_.clear();
+    // Force erasure.
+    IndexTypeVector<VertexIndex, int32_t>().swap(vertex_valence_cache_32_bit_);
+  }
+
+  bool IsCacheEmpty() const {
+    return vertex_valence_cache_8_bit_.size() == 0 &&
+           vertex_valence_cache_32_bit_.size() == 0;
+  }
+
+ private:
+  // Retain valences and clip them to char size.
+  mutable IndexTypeVector<VertexIndex, int8_t> vertex_valence_cache_8_bit_;
+  mutable IndexTypeVector<VertexIndex, int32_t> vertex_valence_cache_32_bit_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_MESH_VALENCE_CACHE_H_
diff --git a/contrib/draco/src/draco/metadata/geometry_metadata.cc b/contrib/draco/src/draco/metadata/geometry_metadata.cc
new file mode 100644
index 000000000..b83898140
--- /dev/null
+++ b/contrib/draco/src/draco/metadata/geometry_metadata.cc
@@ -0,0 +1,44 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/metadata/geometry_metadata.h"
+
+#include <utility>
+
+namespace draco {
+
+const AttributeMetadata *GeometryMetadata::GetAttributeMetadataByStringEntry(
+    const std::string &entry_name, const std::string &entry_value) const {
+  for (auto &&att_metadata : att_metadatas_) {
+    std::string value;
+    if (!att_metadata->GetEntryString(entry_name, &value)) {
+      continue;
+    }
+    if (value == entry_value) {
+      return att_metadata.get();
+    }
+  }
+  // No attribute has the requested entry.
+  return nullptr;
+}
+
+bool GeometryMetadata::AddAttributeMetadata(
+    std::unique_ptr<AttributeMetadata> att_metadata) {
+  if (!att_metadata.get()) {
+    return false;
+  }
+  att_metadatas_.push_back(std::move(att_metadata));
+  return true;
+}
+}  // namespace draco
diff --git a/contrib/draco/src/draco/metadata/geometry_metadata.h b/contrib/draco/src/draco/metadata/geometry_metadata.h
new file mode 100644
index 000000000..ec7ecb9ee
--- /dev/null
+++ b/contrib/draco/src/draco/metadata/geometry_metadata.h
@@ -0,0 +1,140 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_METADATA_GEOMETRY_METADATA_H_
+#define DRACO_METADATA_GEOMETRY_METADATA_H_
+
+#include "draco/metadata/metadata.h"
+
+namespace draco {
+
+// Class for representing specifically metadata of attributes. It must have an
+// attribute id which should be identical to it's counterpart attribute in
+// the point cloud it belongs to.
+class AttributeMetadata : public Metadata {
+ public:
+  AttributeMetadata() : att_unique_id_(0) {}
+  explicit AttributeMetadata(const Metadata &metadata)
+      : Metadata(metadata), att_unique_id_(0) {}
+
+  void set_att_unique_id(uint32_t att_unique_id) {
+    att_unique_id_ = att_unique_id;
+  }
+  // The unique id of the attribute that this metadata belongs to.
+  uint32_t att_unique_id() const { return att_unique_id_; }
+
+ private:
+  uint32_t att_unique_id_;
+
+  friend struct AttributeMetadataHasher;
+  friend class PointCloud;
+};
+
+// Functor for computing a hash from data stored in a AttributeMetadata class.
+struct AttributeMetadataHasher {
+  size_t operator()(const AttributeMetadata &metadata) const {
+    size_t hash = metadata.att_unique_id_;
+    MetadataHasher metadata_hasher;
+    hash = HashCombine(metadata_hasher(static_cast<const Metadata &>(metadata)),
+                       hash);
+    return hash;
+  }
+};
+
+// Class for representing the metadata for a point cloud. It could have a list
+// of attribute metadata.
+class GeometryMetadata : public Metadata {
+ public:
+  GeometryMetadata() {}
+  explicit GeometryMetadata(const Metadata &metadata) : Metadata(metadata) {}
+
+  const AttributeMetadata *GetAttributeMetadataByStringEntry(
+      const std::string &entry_name, const std::string &entry_value) const;
+  bool AddAttributeMetadata(std::unique_ptr<AttributeMetadata> att_metadata);
+
+  void DeleteAttributeMetadataByUniqueId(int32_t att_unique_id) {
+    if (att_unique_id < 0) {
+      return;
+    }
+    for (auto itr = att_metadatas_.begin(); itr != att_metadatas_.end();
+         ++itr) {
+      if (itr->get()->att_unique_id() == static_cast<uint32_t>(att_unique_id)) {
+        att_metadatas_.erase(itr);
+        return;
+      }
+    }
+  }
+
+  const AttributeMetadata *GetAttributeMetadataByUniqueId(
+      int32_t att_unique_id) const {
+    if (att_unique_id < 0) {
+      return nullptr;
+    }
+
+    // TODO(draco-eng): Consider using unordered_map instead of vector to store
+    // attribute metadata.
+    for (auto &&att_metadata : att_metadatas_) {
+      if (att_metadata->att_unique_id() ==
+          static_cast<uint32_t>(att_unique_id)) {
+        return att_metadata.get();
+      }
+    }
+    return nullptr;
+  }
+
+  AttributeMetadata *attribute_metadata(int32_t att_unique_id) {
+    if (att_unique_id < 0) {
+      return nullptr;
+    }
+
+    // TODO(draco-eng): Consider use unordered_map instead of vector to store
+    // attribute metadata.
+    for (auto &&att_metadata : att_metadatas_) {
+      if (att_metadata->att_unique_id() ==
+          static_cast<uint32_t>(att_unique_id)) {
+        return att_metadata.get();
+      }
+    }
+    return nullptr;
+  }
+
+  const std::vector<std::unique_ptr<AttributeMetadata>> &attribute_metadatas()
+      const {
+    return att_metadatas_;
+  }
+
+ private:
+  std::vector<std::unique_ptr<AttributeMetadata>> att_metadatas_;
+
+  friend struct GeometryMetadataHasher;
+};
+
+// Functor for computing a hash from data stored in a GeometryMetadata class.
+struct GeometryMetadataHasher {
+  size_t operator()(const GeometryMetadata &metadata) const {
+    size_t hash = metadata.att_metadatas_.size();
+    AttributeMetadataHasher att_metadata_hasher;
+    for (auto &&att_metadata : metadata.att_metadatas_) {
+      hash = HashCombine(att_metadata_hasher(*att_metadata), hash);
+    }
+    MetadataHasher metadata_hasher;
+    hash = HashCombine(metadata_hasher(static_cast<const Metadata &>(metadata)),
+                       hash);
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // THIRD_PARTY_DRACO_METADATA_GEOMETRY_METADATA_H_
diff --git a/contrib/draco/src/draco/metadata/metadata.cc b/contrib/draco/src/draco/metadata/metadata.cc
new file mode 100644
index 000000000..9141907ed
--- /dev/null
+++ b/contrib/draco/src/draco/metadata/metadata.cc
@@ -0,0 +1,132 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/metadata/metadata.h"
+
+#include <utility>
+
+namespace draco {
+
+EntryValue::EntryValue(const EntryValue &value) {
+  data_.resize(value.data_.size());
+  memcpy(&data_[0], &value.data_[0], value.data_.size());
+}
+
+EntryValue::EntryValue(const std::string &value) {
+  data_.resize(value.size());
+  memcpy(&data_[0], &value[0], value.size());
+}
+
+template <>
+bool EntryValue::GetValue(std::string *value) const {
+  if (data_.empty()) {
+    return false;
+  }
+  value->resize(data_.size());
+  memcpy(&value->at(0), &data_[0], data_.size());
+  return true;
+}
+
+Metadata::Metadata(const Metadata &metadata) {
+  entries_.insert(metadata.entries_.begin(), metadata.entries_.end());
+  for (const auto &sub_metadata_entry : metadata.sub_metadatas_) {
+    std::unique_ptr<Metadata> sub_metadata =
+        std::unique_ptr<Metadata>(new Metadata(*sub_metadata_entry.second));
+    sub_metadatas_[sub_metadata_entry.first] = std::move(sub_metadata);
+  }
+}
+
+void Metadata::AddEntryInt(const std::string &name, int32_t value) {
+  AddEntry(name, value);
+}
+
+bool Metadata::GetEntryInt(const std::string &name, int32_t *value) const {
+  return GetEntry(name, value);
+}
+
+void Metadata::AddEntryIntArray(const std::string &name,
+                                const std::vector<int32_t> &value) {
+  AddEntry(name, value);
+}
+
+bool Metadata::GetEntryIntArray(const std::string &name,
+                                std::vector<int32_t> *value) const {
+  return GetEntry(name, value);
+}
+
+void Metadata::AddEntryDouble(const std::string &name, double value) {
+  AddEntry(name, value);
+}
+
+bool Metadata::GetEntryDouble(const std::string &name, double *value) const {
+  return GetEntry(name, value);
+}
+
+void Metadata::AddEntryDoubleArray(const std::string &name,
+                                   const std::vector<double> &value) {
+  AddEntry(name, value);
+}
+
+bool Metadata::GetEntryDoubleArray(const std::string &name,
+                                   std::vector<double> *value) const {
+  return GetEntry(name, value);
+}
+
+void Metadata::AddEntryString(const std::string &name,
+                              const std::string &value) {
+  AddEntry(name, value);
+}
+
+bool Metadata::GetEntryString(const std::string &name,
+                              std::string *value) const {
+  return GetEntry(name, value);
+}
+
+void Metadata::AddEntryBinary(const std::string &name,
+                              const std::vector<uint8_t> &value) {
+  AddEntry(name, value);
+}
+
+bool Metadata::GetEntryBinary(const std::string &name,
+                              std::vector<uint8_t> *value) const {
+  return GetEntry(name, value);
+}
+
+bool Metadata::AddSubMetadata(const std::string &name,
+                              std::unique_ptr<Metadata> sub_metadata) {
+  auto sub_ptr = sub_metadatas_.find(name);
+  // Avoid accidentally writing over a sub-metadata with the same name.
+  if (sub_ptr != sub_metadatas_.end()) {
+    return false;
+  }
+  sub_metadatas_[name] = std::move(sub_metadata);
+  return true;
+}
+
+const Metadata *Metadata::GetSubMetadata(const std::string &name) const {
+  auto sub_ptr = sub_metadatas_.find(name);
+  if (sub_ptr == sub_metadatas_.end()) {
+    return nullptr;
+  }
+  return sub_ptr->second.get();
+}
+
+void Metadata::RemoveEntry(const std::string &name) {
+  // Actually just remove "name", no need to check if it exists.
+  auto entry_ptr = entries_.find(name);
+  if (entry_ptr != entries_.end()) {
+    entries_.erase(entry_ptr);
+  }
+}
+}  // namespace draco
diff --git a/contrib/draco/src/draco/metadata/metadata.h b/contrib/draco/src/draco/metadata/metadata.h
new file mode 100644
index 000000000..56d05e46a
--- /dev/null
+++ b/contrib/draco/src/draco/metadata/metadata.h
@@ -0,0 +1,208 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_METADATA_METADATA_H_
+#define DRACO_METADATA_METADATA_H_
+
+#include <cstring>
+#include <map>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "draco/core/hash_utils.h"
+
+namespace draco {
+
+// Class for storing a value of an entry in Metadata. Internally it is
+// represented by a buffer of data. It can be accessed by various data types,
+// e.g. int, float, binary data or string.
+class EntryValue {
+ public:
+  template <typename DataTypeT>
+  explicit EntryValue(const DataTypeT &data) {
+    const size_t data_type_size = sizeof(DataTypeT);
+    data_.resize(data_type_size);
+    memcpy(&data_[0], &data, data_type_size);
+  }
+
+  template <typename DataTypeT>
+  explicit EntryValue(const std::vector<DataTypeT> &data) {
+    const size_t total_size = sizeof(DataTypeT) * data.size();
+    data_.resize(total_size);
+    memcpy(&data_[0], &data[0], total_size);
+  }
+
+  EntryValue(const EntryValue &value);
+  explicit EntryValue(const std::string &value);
+
+  template <typename DataTypeT>
+  bool GetValue(DataTypeT *value) const {
+    const size_t data_type_size = sizeof(DataTypeT);
+    if (data_type_size != data_.size()) {
+      return false;
+    }
+    memcpy(value, &data_[0], data_type_size);
+    return true;
+  }
+
+  template <typename DataTypeT>
+  bool GetValue(std::vector<DataTypeT> *value) const {
+    if (data_.empty()) {
+      return false;
+    }
+    const size_t data_type_size = sizeof(DataTypeT);
+    if (data_.size() % data_type_size != 0) {
+      return false;
+    }
+    value->resize(data_.size() / data_type_size);
+    memcpy(&value->at(0), &data_[0], data_.size());
+    return true;
+  }
+
+  const std::vector<uint8_t> &data() const { return data_; }
+
+ private:
+  std::vector<uint8_t> data_;
+
+  friend struct EntryValueHasher;
+};
+
+// Functor for computing a hash from data stored within an EntryValue.
+struct EntryValueHasher {
+  size_t operator()(const EntryValue &ev) const {
+    size_t hash = ev.data_.size();
+    for (size_t i = 0; i < ev.data_.size(); ++i) {
+      hash = HashCombine(ev.data_[i], hash);
+    }
+    return hash;
+  }
+};
+
+// Class for holding generic metadata. It has a list of entries which consist of
+// an entry name and an entry value. Each Metadata could also have nested
+// metadata.
+class Metadata {
+ public:
+  Metadata() {}
+  Metadata(const Metadata &metadata);
+  // In theory, we support all types of data as long as it could be serialized
+  // to binary data. We provide the following functions for inserting and
+  // accessing entries of common data types. For now, developers need to know
+  // the type of entries they are requesting.
+  void AddEntryInt(const std::string &name, int32_t value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is int32_t.
+  bool GetEntryInt(const std::string &name, int32_t *value) const;
+
+  void AddEntryIntArray(const std::string &name,
+                        const std::vector<int32_t> &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is a vector of int32_t.
+  bool GetEntryIntArray(const std::string &name,
+                        std::vector<int32_t> *value) const;
+
+  void AddEntryDouble(const std::string &name, double value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is double.
+  bool GetEntryDouble(const std::string &name, double *value) const;
+
+  void AddEntryDoubleArray(const std::string &name,
+                           const std::vector<double> &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is a vector of double.
+  bool GetEntryDoubleArray(const std::string &name,
+                           std::vector<double> *value) const;
+
+  void AddEntryString(const std::string &name, const std::string &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is std::string.
+  bool GetEntryString(const std::string &name, std::string *value) const;
+
+  // Add a blob of data as an entry.
+  void AddEntryBinary(const std::string &name,
+                      const std::vector<uint8_t> &value);
+
+  // Returns false if Metadata does not contain an entry with a key of |name|.
+  // This function does not guarantee that entry's type is a vector of uint8_t.
+  bool GetEntryBinary(const std::string &name,
+                      std::vector<uint8_t> *value) const;
+
+  bool AddSubMetadata(const std::string &name,
+                      std::unique_ptr<Metadata> sub_metadata);
+  const Metadata *GetSubMetadata(const std::string &name) const;
+
+  void RemoveEntry(const std::string &name);
+
+  int num_entries() const { return static_cast<int>(entries_.size()); }
+  const std::map<std::string, EntryValue> &entries() const { return entries_; }
+  const std::map<std::string, std::unique_ptr<Metadata>> &sub_metadatas()
+      const {
+    return sub_metadatas_;
+  }
+
+ private:
+  // Make this function private to avoid adding undefined data types.
+  template <typename DataTypeT>
+  void AddEntry(const std::string &entry_name, const DataTypeT &entry_value) {
+    const auto itr = entries_.find(entry_name);
+    if (itr != entries_.end()) {
+      entries_.erase(itr);
+    }
+    entries_.insert(std::make_pair(entry_name, EntryValue(entry_value)));
+  }
+
+  // Make this function private to avoid adding undefined data types.
+  template <typename DataTypeT>
+  bool GetEntry(const std::string &entry_name, DataTypeT *entry_value) const {
+    const auto itr = entries_.find(entry_name);
+    if (itr == entries_.end()) {
+      return false;
+    }
+    return itr->second.GetValue(entry_value);
+  }
+
+  std::map<std::string, EntryValue> entries_;
+  std::map<std::string, std::unique_ptr<Metadata>> sub_metadatas_;
+
+  friend struct MetadataHasher;
+};
+
+// Functor for computing a hash from data stored within a metadata class.
+struct MetadataHasher {
+  size_t operator()(const Metadata &metadata) const {
+    size_t hash =
+        HashCombine(metadata.entries_.size(), metadata.sub_metadatas_.size());
+    EntryValueHasher entry_value_hasher;
+    for (const auto &entry : metadata.entries_) {
+      hash = HashCombine(entry.first, hash);
+      hash = HashCombine(entry_value_hasher(entry.second), hash);
+    }
+    MetadataHasher metadata_hasher;
+    for (auto &&sub_metadata : metadata.sub_metadatas_) {
+      hash = HashCombine(sub_metadata.first, hash);
+      hash = HashCombine(metadata_hasher(*sub_metadata.second), hash);
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_METADATA_METADATA_H_
diff --git a/contrib/draco/src/draco/metadata/metadata_decoder.cc b/contrib/draco/src/draco/metadata/metadata_decoder.cc
new file mode 100644
index 000000000..a8e66f854
--- /dev/null
+++ b/contrib/draco/src/draco/metadata/metadata_decoder.cc
@@ -0,0 +1,148 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/metadata/metadata_decoder.h"
+
+#include <string>
+
+#include "draco/core/varint_decoding.h"
+
+namespace draco {
+
+MetadataDecoder::MetadataDecoder() : buffer_(nullptr) {}
+
+bool MetadataDecoder::DecodeMetadata(DecoderBuffer *in_buffer,
+                                     Metadata *metadata) {
+  if (!metadata) {
+    return false;
+  }
+  buffer_ = in_buffer;
+  return DecodeMetadata(metadata);
+}
+
+bool MetadataDecoder::DecodeGeometryMetadata(DecoderBuffer *in_buffer,
+                                             GeometryMetadata *metadata) {
+  if (!metadata) {
+    return false;
+  }
+  buffer_ = in_buffer;
+  uint32_t num_att_metadata = 0;
+  if (!DecodeVarint(&num_att_metadata, buffer_)) {
+    return false;
+  }
+  // Decode attribute metadata.
+  for (uint32_t i = 0; i < num_att_metadata; ++i) {
+    uint32_t att_unique_id;
+    if (!DecodeVarint(&att_unique_id, buffer_)) {
+      return false;
+    }
+    std::unique_ptr<AttributeMetadata> att_metadata =
+        std::unique_ptr<AttributeMetadata>(new AttributeMetadata());
+    att_metadata->set_att_unique_id(att_unique_id);
+    if (!DecodeMetadata(static_cast<Metadata *>(att_metadata.get()))) {
+      return false;
+    }
+    metadata->AddAttributeMetadata(std::move(att_metadata));
+  }
+  return DecodeMetadata(static_cast<Metadata *>(metadata));
+}
+
+bool MetadataDecoder::DecodeMetadata(Metadata *metadata) {
+  struct MetadataPair {
+    Metadata *parent_metadata;
+    Metadata *decoded_metadata;
+  };
+  std::vector<MetadataPair> metadata_stack;
+  metadata_stack.push_back({nullptr, metadata});
+  while (!metadata_stack.empty()) {
+    const MetadataPair mp = metadata_stack.back();
+    metadata_stack.pop_back();
+    metadata = mp.decoded_metadata;
+
+    if (mp.parent_metadata != nullptr) {
+      std::string sub_metadata_name;
+      if (!DecodeName(&sub_metadata_name)) {
+        return false;
+      }
+      std::unique_ptr<Metadata> sub_metadata =
+          std::unique_ptr<Metadata>(new Metadata());
+      metadata = sub_metadata.get();
+      if (!mp.parent_metadata->AddSubMetadata(sub_metadata_name,
+                                              std::move(sub_metadata))) {
+        return false;
+      }
+    }
+    if (metadata == nullptr) {
+      return false;
+    }
+
+    uint32_t num_entries = 0;
+    if (!DecodeVarint(&num_entries, buffer_)) {
+      return false;
+    }
+    for (uint32_t i = 0; i < num_entries; ++i) {
+      if (!DecodeEntry(metadata)) {
+        return false;
+      }
+    }
+    uint32_t num_sub_metadata = 0;
+    if (!DecodeVarint(&num_sub_metadata, buffer_)) {
+      return false;
+    }
+    if (num_sub_metadata > buffer_->remaining_size()) {
+      // The decoded number of metadata items is unreasonably high.
+      return false;
+    }
+    for (uint32_t i = 0; i < num_sub_metadata; ++i) {
+      metadata_stack.push_back({metadata, nullptr});
+    }
+  }
+  return true;
+}
+
+bool MetadataDecoder::DecodeEntry(Metadata *metadata) {
+  std::string entry_name;
+  if (!DecodeName(&entry_name)) {
+    return false;
+  }
+  uint32_t data_size = 0;
+  if (!DecodeVarint(&data_size, buffer_)) {
+    return false;
+  }
+  if (data_size == 0) {
+    return false;
+  }
+  std::vector<uint8_t> entry_value(data_size);
+  if (!buffer_->Decode(&entry_value[0], data_size)) {
+    return false;
+  }
+  metadata->AddEntryBinary(entry_name, entry_value);
+  return true;
+}
+
+bool MetadataDecoder::DecodeName(std::string *name) {
+  uint8_t name_len = 0;
+  if (!buffer_->Decode(&name_len)) {
+    return false;
+  }
+  name->resize(name_len);
+  if (name_len == 0) {
+    return true;
+  }
+  if (!buffer_->Decode(&name->at(0), name_len)) {
+    return false;
+  }
+  return true;
+}
+}  // namespace draco
diff --git a/contrib/draco/src/draco/metadata/metadata_decoder.h b/contrib/draco/src/draco/metadata/metadata_decoder.h
new file mode 100644
index 000000000..b4c4943fb
--- /dev/null
+++ b/contrib/draco/src/draco/metadata/metadata_decoder.h
@@ -0,0 +1,42 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_METADATA_METADATA_DECODER_H_
+#define DRACO_METADATA_METADATA_DECODER_H_
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/metadata/geometry_metadata.h"
+#include "draco/metadata/metadata.h"
+
+namespace draco {
+
+// Class for decoding the metadata.
+class MetadataDecoder {
+ public:
+  MetadataDecoder();
+  bool DecodeMetadata(DecoderBuffer *in_buffer, Metadata *metadata);
+  bool DecodeGeometryMetadata(DecoderBuffer *in_buffer,
+                              GeometryMetadata *metadata);
+
+ private:
+  bool DecodeMetadata(Metadata *metadata);
+  bool DecodeEntries(Metadata *metadata);
+  bool DecodeEntry(Metadata *metadata);
+  bool DecodeName(std::string *name);
+
+  DecoderBuffer *buffer_;
+};
+}  // namespace draco
+
+#endif  // DRACO_METADATA_METADATA_DECODER_H_
diff --git a/contrib/draco/src/draco/metadata/metadata_encoder.cc b/contrib/draco/src/draco/metadata/metadata_encoder.cc
new file mode 100644
index 000000000..168be83c6
--- /dev/null
+++ b/contrib/draco/src/draco/metadata/metadata_encoder.cc
@@ -0,0 +1,97 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/metadata/metadata_encoder.h"
+
+#include "draco/core/varint_encoding.h"
+
+namespace draco {
+
+bool MetadataEncoder::EncodeMetadata(EncoderBuffer *out_buffer,
+                                     const Metadata *metadata) {
+  const std::map<std::string, EntryValue> &entries = metadata->entries();
+  // Encode number of entries.
+  EncodeVarint(static_cast<uint32_t>(metadata->num_entries()), out_buffer);
+  // Encode all entries.
+  for (const auto &entry : entries) {
+    if (!EncodeString(out_buffer, entry.first)) {
+      return false;
+    }
+    const std::vector<uint8_t> &entry_value = entry.second.data();
+    const uint32_t data_size = static_cast<uint32_t>(entry_value.size());
+    EncodeVarint(data_size, out_buffer);
+    out_buffer->Encode(entry_value.data(), data_size);
+  }
+  const std::map<std::string, std::unique_ptr<Metadata>> &sub_metadatas =
+      metadata->sub_metadatas();
+  // Encode number of sub-metadata
+  EncodeVarint(static_cast<uint32_t>(sub_metadatas.size()), out_buffer);
+  // Encode each sub-metadata
+  for (auto &&sub_metadata_entry : sub_metadatas) {
+    if (!EncodeString(out_buffer, sub_metadata_entry.first)) {
+      return false;
+    }
+    EncodeMetadata(out_buffer, sub_metadata_entry.second.get());
+  }
+
+  return true;
+}
+
+bool MetadataEncoder::EncodeAttributeMetadata(
+    EncoderBuffer *out_buffer, const AttributeMetadata *metadata) {
+  if (!metadata) {
+    return false;
+  }
+  // Encode attribute id.
+  EncodeVarint(metadata->att_unique_id(), out_buffer);
+  EncodeMetadata(out_buffer, static_cast<const Metadata *>(metadata));
+  return true;
+}
+
+bool MetadataEncoder::EncodeGeometryMetadata(EncoderBuffer *out_buffer,
+                                             const GeometryMetadata *metadata) {
+  if (!metadata) {
+    return false;
+  }
+  // Encode number of attribute metadata.
+  const std::vector<std::unique_ptr<AttributeMetadata>> &att_metadatas =
+      metadata->attribute_metadatas();
+  // TODO(draco-eng): Limit the number of attributes.
+  EncodeVarint(static_cast<uint32_t>(att_metadatas.size()), out_buffer);
+  // Encode each attribute metadata
+  for (auto &&att_metadata : att_metadatas) {
+    EncodeAttributeMetadata(out_buffer, att_metadata.get());
+  }
+  // Encode normal metadata part.
+  EncodeMetadata(out_buffer, static_cast<const Metadata *>(metadata));
+
+  return true;
+}
+
+bool MetadataEncoder::EncodeString(EncoderBuffer *out_buffer,
+                                   const std::string &str) {
+  // We only support string of maximum length 255 which is using one byte to
+  // encode the length.
+  if (str.size() > 255) {
+    return false;
+  }
+  if (str.empty()) {
+    out_buffer->Encode(static_cast<uint8_t>(0));
+  } else {
+    out_buffer->Encode(static_cast<uint8_t>(str.size()));
+    out_buffer->Encode(str.c_str(), str.size());
+  }
+  return true;
+}
+}  // namespace draco
diff --git a/contrib/draco/src/draco/metadata/metadata_encoder.h b/contrib/draco/src/draco/metadata/metadata_encoder.h
new file mode 100644
index 000000000..5bce5d5b5
--- /dev/null
+++ b/contrib/draco/src/draco/metadata/metadata_encoder.h
@@ -0,0 +1,41 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_METADATA_METADATA_ENCODER_H_
+#define DRACO_METADATA_METADATA_ENCODER_H_
+
+#include "draco/core/encoder_buffer.h"
+#include "draco/metadata/geometry_metadata.h"
+#include "draco/metadata/metadata.h"
+
+namespace draco {
+
+// Class for encoding metadata. It could encode either base Metadata class or
+// a metadata of a geometry, e.g. a point cloud.
+class MetadataEncoder {
+ public:
+  MetadataEncoder() {}
+
+  bool EncodeGeometryMetadata(EncoderBuffer *out_buffer,
+                              const GeometryMetadata *metadata);
+  bool EncodeMetadata(EncoderBuffer *out_buffer, const Metadata *metadata);
+
+ private:
+  bool EncodeAttributeMetadata(EncoderBuffer *out_buffer,
+                               const AttributeMetadata *metadata);
+  bool EncodeString(EncoderBuffer *out_buffer, const std::string &str);
+};
+}  // namespace draco
+
+#endif  // DRACO_METADATA_METADATA_ENCODER_H_
diff --git a/contrib/draco/src/draco/metadata/metadata_encoder_test.cc b/contrib/draco/src/draco/metadata/metadata_encoder_test.cc
new file mode 100644
index 000000000..e5f14bf02
--- /dev/null
+++ b/contrib/draco/src/draco/metadata/metadata_encoder_test.cc
@@ -0,0 +1,167 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/metadata/metadata_encoder.h"
+
+#include "draco/core/decoder_buffer.h"
+#include "draco/core/draco_test_base.h"
+#include "draco/core/encoder_buffer.h"
+#include "draco/metadata/metadata.h"
+#include "draco/metadata/metadata_decoder.h"
+
+namespace {
+
+class MetadataEncoderTest : public ::testing::Test {
+ protected:
+  MetadataEncoderTest() {}
+
+  void TestEncodingMetadata() {
+    ASSERT_TRUE(encoder.EncodeMetadata(&encoder_buffer, &metadata));
+
+    draco::Metadata decoded_metadata;
+    decoder_buffer.Init(encoder_buffer.data(), encoder_buffer.size());
+    ASSERT_TRUE(decoder.DecodeMetadata(&decoder_buffer, &decoded_metadata));
+    CheckMetadatasAreEqual(metadata, decoded_metadata);
+  }
+
+  void TestEncodingGeometryMetadata() {
+    ASSERT_TRUE(
+        encoder.EncodeGeometryMetadata(&encoder_buffer, &geometry_metadata));
+
+    draco::GeometryMetadata decoded_metadata;
+    decoder_buffer.Init(encoder_buffer.data(), encoder_buffer.size());
+    ASSERT_TRUE(
+        decoder.DecodeGeometryMetadata(&decoder_buffer, &decoded_metadata));
+    CheckGeometryMetadatasAreEqual(geometry_metadata, decoded_metadata);
+  }
+
+  void CheckBlobOfDataAreEqual(const std::vector<uint8_t> &data0,
+                               const std::vector<uint8_t> &data1) {
+    ASSERT_EQ(data0.size(), data1.size());
+    for (int i = 0; i < data0.size(); ++i) {
+      ASSERT_EQ(data0[i], data1[i]);
+    }
+  }
+
+  void CheckGeometryMetadatasAreEqual(
+      const draco::GeometryMetadata &metadata0,
+      const draco::GeometryMetadata &metadata1) {
+    ASSERT_EQ(metadata0.attribute_metadatas().size(),
+              metadata1.attribute_metadatas().size());
+    const std::vector<std::unique_ptr<draco::AttributeMetadata>>
+        &att_metadatas0 = metadata0.attribute_metadatas();
+    const std::vector<std::unique_ptr<draco::AttributeMetadata>>
+        &att_metadatas1 = metadata1.attribute_metadatas();
+    // Compare each attribute metadata.
+    for (int i = 0; i < metadata0.attribute_metadatas().size(); ++i) {
+      CheckMetadatasAreEqual(
+          static_cast<const draco::Metadata &>(*att_metadatas0[i]),
+          static_cast<const draco::Metadata &>(*att_metadatas1[i]));
+    }
+    // Compare entries and sub metadata.
+    CheckMetadatasAreEqual(static_cast<const draco::Metadata &>(metadata0),
+                           static_cast<const draco::Metadata &>(metadata1));
+  }
+
+  void CheckMetadatasAreEqual(const draco::Metadata &metadata0,
+                              const draco::Metadata &metadata1) {
+    ASSERT_EQ(metadata0.num_entries(), metadata1.num_entries());
+    const std::map<std::string, draco::EntryValue> &entries0 =
+        metadata0.entries();
+    const std::map<std::string, draco::EntryValue> &entries1 =
+        metadata1.entries();
+    for (const auto &entry : entries0) {
+      const std::string &entry_name = entry.first;
+      const std::vector<uint8_t> &data0 = entry.second.data();
+      const auto entry1_ptr = entries1.find(entry_name);
+      ASSERT_NE(entry1_ptr, entries1.end());
+      const std::vector<uint8_t> &data1 = entry1_ptr->second.data();
+      CheckBlobOfDataAreEqual(data0, data1);
+    }
+    // Check nested metadata.
+    ASSERT_EQ(metadata0.sub_metadatas().size(),
+              metadata1.sub_metadatas().size());
+    const std::map<std::string, std::unique_ptr<draco::Metadata>>
+        &sub_metadatas0 = metadata0.sub_metadatas();
+    // Encode each sub-metadata
+    for (auto &&sub_metadata_entry0 : sub_metadatas0) {
+      const auto sub_metadata_ptr1 =
+          metadata1.GetSubMetadata(sub_metadata_entry0.first);
+      ASSERT_NE(sub_metadata_ptr1, nullptr);
+      CheckMetadatasAreEqual(*sub_metadata_entry0.second, *sub_metadata_ptr1);
+    }
+  }
+
+  draco::MetadataEncoder encoder;
+  draco::MetadataDecoder decoder;
+  draco::EncoderBuffer encoder_buffer;
+  draco::DecoderBuffer decoder_buffer;
+  draco::Metadata metadata;
+  draco::GeometryMetadata geometry_metadata;
+};
+
+TEST_F(MetadataEncoderTest, TestSingleEntry) {
+  metadata.AddEntryInt("int", 100);
+  ASSERT_EQ(metadata.num_entries(), 1);
+
+  TestEncodingMetadata();
+}
+
+TEST_F(MetadataEncoderTest, TestMultipleEntries) {
+  metadata.AddEntryInt("int", 100);
+  metadata.AddEntryDouble("double", 1.234);
+  const std::string entry_value = "test string entry";
+  metadata.AddEntryString("string", entry_value);
+  ASSERT_EQ(metadata.num_entries(), 3);
+
+  TestEncodingMetadata();
+}
+
+TEST_F(MetadataEncoderTest, TestEncodingArrayEntries) {
+  std::vector<int32_t> int_array({1, 2, 3});
+  metadata.AddEntryIntArray("int_array", int_array);
+  std::vector<double> double_array({0.1, 0.2, 0.3});
+  metadata.AddEntryDoubleArray("double_array", double_array);
+  ASSERT_EQ(metadata.num_entries(), 2);
+
+  TestEncodingMetadata();
+}
+
+TEST_F(MetadataEncoderTest, TestEncodingBinaryEntry) {
+  const std::vector<uint8_t> binarydata({0x1, 0x2, 0x3, 0x4});
+  metadata.AddEntryBinary("binary_data", binarydata);
+
+  TestEncodingMetadata();
+}
+
+TEST_F(MetadataEncoderTest, TestEncodingNestedMetadata) {
+  metadata.AddEntryDouble("double", 1.234);
+  std::unique_ptr<draco::Metadata> sub_metadata =
+      std::unique_ptr<draco::Metadata>(new draco::Metadata());
+  sub_metadata->AddEntryInt("int", 100);
+  metadata.AddSubMetadata("sub0", std::move(sub_metadata));
+
+  TestEncodingMetadata();
+}
+
+TEST_F(MetadataEncoderTest, TestEncodingGeometryMetadata) {
+  std::unique_ptr<draco::AttributeMetadata> att_metadata =
+      std::unique_ptr<draco::AttributeMetadata>(new draco::AttributeMetadata);
+  att_metadata->AddEntryInt("int", 100);
+  att_metadata->AddEntryString("name", "pos");
+  ASSERT_TRUE(geometry_metadata.AddAttributeMetadata(std::move(att_metadata)));
+
+  TestEncodingGeometryMetadata();
+}
+}  // namespace
diff --git a/contrib/draco/src/draco/metadata/metadata_test.cc b/contrib/draco/src/draco/metadata/metadata_test.cc
new file mode 100644
index 000000000..cf7ae6eee
--- /dev/null
+++ b/contrib/draco/src/draco/metadata/metadata_test.cc
@@ -0,0 +1,157 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/metadata/metadata.h"
+
+#include <memory>
+#include <string>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/metadata/geometry_metadata.h"
+
+namespace {
+
+class MetadataTest : public ::testing::Test {
+ protected:
+  MetadataTest() {}
+
+  draco::Metadata metadata;
+  draco::GeometryMetadata geometry_metadata;
+};
+
+TEST_F(MetadataTest, TestRemoveEntry) {
+  metadata.AddEntryInt("int", 100);
+  metadata.RemoveEntry("int");
+  int32_t int_value = 0;
+  ASSERT_FALSE(metadata.GetEntryInt("int", &int_value));
+}
+
+TEST_F(MetadataTest, TestSingleEntry) {
+  metadata.AddEntryInt("int", 100);
+  int32_t int_value = 0;
+  ASSERT_TRUE(metadata.GetEntryInt("int", &int_value));
+  ASSERT_EQ(int_value, 100);
+
+  metadata.AddEntryDouble("double", 1.234);
+  double double_value = 0.0;
+  ASSERT_TRUE(metadata.GetEntryDouble("double", &double_value));
+  ASSERT_EQ(double_value, 1.234);
+}
+
+TEST_F(MetadataTest, TestWriteOverEntry) {
+  metadata.AddEntryInt("int", 100);
+  metadata.AddEntryInt("int", 200);
+  int32_t int_value = 0;
+  ASSERT_TRUE(metadata.GetEntryInt("int", &int_value));
+  ASSERT_EQ(int_value, 200);
+}
+
+TEST_F(MetadataTest, TestArrayEntry) {
+  std::vector<int32_t> int_array({1, 2, 3});
+  metadata.AddEntryIntArray("int_array", int_array);
+  std::vector<int32_t> return_int_array;
+  ASSERT_TRUE(metadata.GetEntryIntArray("int_array", &return_int_array));
+  ASSERT_EQ(return_int_array.size(), 3);
+  ASSERT_EQ(return_int_array[0], 1);
+  ASSERT_EQ(return_int_array[1], 2);
+  ASSERT_EQ(return_int_array[2], 3);
+
+  std::vector<double> double_array({0.1, 0.2, 0.3});
+  metadata.AddEntryDoubleArray("double_array", double_array);
+  std::vector<double> return_double_array;
+  ASSERT_TRUE(
+      metadata.GetEntryDoubleArray("double_array", &return_double_array));
+  ASSERT_EQ(return_double_array.size(), 3);
+  ASSERT_EQ(return_double_array[0], 0.1);
+  ASSERT_EQ(return_double_array[1], 0.2);
+  ASSERT_EQ(return_double_array[2], 0.3);
+}
+
+TEST_F(MetadataTest, TestStringEntry) {
+  const std::string entry_value = "test string entry";
+  metadata.AddEntryString("string", entry_value);
+  std::string return_value;
+  ASSERT_TRUE(metadata.GetEntryString("string", &return_value));
+  ASSERT_EQ(entry_value.size(), return_value.size());
+  ASSERT_EQ(entry_value, return_value);
+}
+
+TEST_F(MetadataTest, TestBinaryEntry) {
+  const std::vector<uint8_t> binarydata({0x1, 0x2, 0x3, 0x4});
+  metadata.AddEntryBinary("binary_data", binarydata);
+  std::vector<uint8_t> return_binarydata;
+  ASSERT_TRUE(metadata.GetEntryBinary("binary_data", &return_binarydata));
+  ASSERT_EQ(binarydata.size(), return_binarydata.size());
+  for (int i = 0; i < binarydata.size(); ++i) {
+    ASSERT_EQ(binarydata[i], return_binarydata[i]);
+  }
+}
+
+TEST_F(MetadataTest, TestNestedMetadata) {
+  std::unique_ptr<draco::Metadata> sub_metadata =
+      std::unique_ptr<draco::Metadata>(new draco::Metadata());
+  sub_metadata->AddEntryInt("int", 100);
+
+  metadata.AddSubMetadata("sub0", std::move(sub_metadata));
+  const auto sub_metadata_ptr = metadata.GetSubMetadata("sub0");
+  ASSERT_NE(sub_metadata_ptr, nullptr);
+
+  int32_t int_value = 0;
+  ASSERT_TRUE(sub_metadata_ptr->GetEntryInt("int", &int_value));
+  ASSERT_EQ(int_value, 100);
+}
+
+TEST_F(MetadataTest, TestHardCopyMetadata) {
+  metadata.AddEntryInt("int", 100);
+  std::unique_ptr<draco::Metadata> sub_metadata =
+      std::unique_ptr<draco::Metadata>(new draco::Metadata());
+  sub_metadata->AddEntryInt("int", 200);
+  metadata.AddSubMetadata("sub0", std::move(sub_metadata));
+
+  draco::Metadata copied_metadata(metadata);
+
+  int32_t int_value = 0;
+  ASSERT_TRUE(copied_metadata.GetEntryInt("int", &int_value));
+  ASSERT_EQ(int_value, 100);
+
+  const auto sub_metadata_ptr = copied_metadata.GetSubMetadata("sub0");
+  ASSERT_NE(sub_metadata_ptr, nullptr);
+
+  int32_t sub_int_value = 0;
+  ASSERT_TRUE(sub_metadata_ptr->GetEntryInt("int", &sub_int_value));
+  ASSERT_EQ(sub_int_value, 200);
+}
+
+TEST_F(MetadataTest, TestGeometryMetadata) {
+  std::unique_ptr<draco::AttributeMetadata> att_metadata =
+      std::unique_ptr<draco::AttributeMetadata>(new draco::AttributeMetadata());
+  att_metadata->set_att_unique_id(10);
+  att_metadata->AddEntryInt("int", 100);
+  att_metadata->AddEntryString("name", "pos");
+
+  ASSERT_FALSE(geometry_metadata.AddAttributeMetadata(nullptr));
+  ASSERT_TRUE(geometry_metadata.AddAttributeMetadata(std::move(att_metadata)));
+
+  ASSERT_NE(geometry_metadata.GetAttributeMetadataByUniqueId(10), nullptr);
+  ASSERT_EQ(geometry_metadata.GetAttributeMetadataByUniqueId(1), nullptr);
+
+  const draco::AttributeMetadata *requested_att_metadata =
+      geometry_metadata.GetAttributeMetadataByStringEntry("name", "pos");
+  ASSERT_NE(requested_att_metadata, nullptr);
+  ASSERT_EQ(
+      geometry_metadata.GetAttributeMetadataByStringEntry("name", "not_exists"),
+      nullptr);
+}
+
+}  // namespace
diff --git a/contrib/draco/src/draco/point_cloud/point_cloud.cc b/contrib/draco/src/draco/point_cloud/point_cloud.cc
new file mode 100644
index 000000000..a9f9ea2af
--- /dev/null
+++ b/contrib/draco/src/draco/point_cloud/point_cloud.cc
@@ -0,0 +1,275 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/point_cloud/point_cloud.h"
+
+#include <algorithm>
+#include <unordered_map>
+
+namespace draco {
+
+PointCloud::PointCloud() : num_points_(0) {}
+
+int32_t PointCloud::NumNamedAttributes(GeometryAttribute::Type type) const {
+  if (type == GeometryAttribute::INVALID ||
+      type >= GeometryAttribute::NAMED_ATTRIBUTES_COUNT) {
+    return 0;
+  }
+  return static_cast<int32_t>(named_attribute_index_[type].size());
+}
+
+int32_t PointCloud::GetNamedAttributeId(GeometryAttribute::Type type) const {
+  return GetNamedAttributeId(type, 0);
+}
+
+int32_t PointCloud::GetNamedAttributeId(GeometryAttribute::Type type,
+                                        int i) const {
+  if (NumNamedAttributes(type) <= i) {
+    return -1;
+  }
+  return named_attribute_index_[type][i];
+}
+
+const PointAttribute *PointCloud::GetNamedAttribute(
+    GeometryAttribute::Type type) const {
+  return GetNamedAttribute(type, 0);
+}
+
+const PointAttribute *PointCloud::GetNamedAttribute(
+    GeometryAttribute::Type type, int i) const {
+  const int32_t att_id = GetNamedAttributeId(type, i);
+  if (att_id == -1) {
+    return nullptr;
+  }
+  return attributes_[att_id].get();
+}
+
+const PointAttribute *PointCloud::GetNamedAttributeByUniqueId(
+    GeometryAttribute::Type type, uint32_t unique_id) const {
+  for (size_t att_id = 0; att_id < named_attribute_index_[type].size();
+       ++att_id) {
+    if (attributes_[named_attribute_index_[type][att_id]]->unique_id() ==
+        unique_id) {
+      return attributes_[named_attribute_index_[type][att_id]].get();
+    }
+  }
+  return nullptr;
+}
+
+const PointAttribute *PointCloud::GetAttributeByUniqueId(
+    uint32_t unique_id) const {
+  const int32_t att_id = GetAttributeIdByUniqueId(unique_id);
+  if (att_id == -1) {
+    return nullptr;
+  }
+  return attributes_[att_id].get();
+}
+
+int32_t PointCloud::GetAttributeIdByUniqueId(uint32_t unique_id) const {
+  for (size_t att_id = 0; att_id < attributes_.size(); ++att_id) {
+    if (attributes_[att_id]->unique_id() == unique_id) {
+      return static_cast<int32_t>(att_id);
+    }
+  }
+  return -1;
+}
+
+int PointCloud::AddAttribute(std::unique_ptr<PointAttribute> pa) {
+  SetAttribute(static_cast<int>(attributes_.size()), std::move(pa));
+  return static_cast<int>(attributes_.size() - 1);
+}
+
+int PointCloud::AddAttribute(
+    const GeometryAttribute &att, bool identity_mapping,
+    AttributeValueIndex::ValueType num_attribute_values) {
+  auto pa = CreateAttribute(att, identity_mapping, num_attribute_values);
+  if (!pa) {
+    return -1;
+  }
+  const int32_t att_id = AddAttribute(std::move(pa));
+  return att_id;
+}
+
+std::unique_ptr<PointAttribute> PointCloud::CreateAttribute(
+    const GeometryAttribute &att, bool identity_mapping,
+    AttributeValueIndex::ValueType num_attribute_values) const {
+  if (att.attribute_type() == GeometryAttribute::INVALID) {
+    return nullptr;
+  }
+  std::unique_ptr<PointAttribute> pa =
+      std::unique_ptr<PointAttribute>(new PointAttribute(att));
+  // Initialize point cloud specific attribute data.
+  if (!identity_mapping) {
+    // First create mapping between indices.
+    pa->SetExplicitMapping(num_points_);
+  } else {
+    pa->SetIdentityMapping();
+    num_attribute_values = std::max(num_points_, num_attribute_values);
+  }
+  if (num_attribute_values > 0) {
+    pa->Reset(num_attribute_values);
+  }
+  return pa;
+}
+
+void PointCloud::SetAttribute(int att_id, std::unique_ptr<PointAttribute> pa) {
+  DRACO_DCHECK(att_id >= 0);
+  if (static_cast<int>(attributes_.size()) <= att_id) {
+    attributes_.resize(att_id + 1);
+  }
+  if (pa->attribute_type() < GeometryAttribute::NAMED_ATTRIBUTES_COUNT) {
+    named_attribute_index_[pa->attribute_type()].push_back(att_id);
+  }
+  pa->set_unique_id(att_id);
+  attributes_[att_id] = std::move(pa);
+}
+
+void PointCloud::DeleteAttribute(int att_id) {
+  if (att_id < 0 || att_id >= attributes_.size()) {
+    return;  // Attribute does not exist.
+  }
+  const GeometryAttribute::Type att_type =
+      attributes_[att_id]->attribute_type();
+  const uint32_t unique_id = attribute(att_id)->unique_id();
+  attributes_.erase(attributes_.begin() + att_id);
+  // Remove metadata if applicable.
+  if (metadata_) {
+    metadata_->DeleteAttributeMetadataByUniqueId(unique_id);
+  }
+
+  // Remove the attribute from the named attribute list if applicable.
+  if (att_type < GeometryAttribute::NAMED_ATTRIBUTES_COUNT) {
+    const auto it = std::find(named_attribute_index_[att_type].begin(),
+                              named_attribute_index_[att_type].end(), att_id);
+    if (it != named_attribute_index_[att_type].end()) {
+      named_attribute_index_[att_type].erase(it);
+    }
+  }
+
+  // Update ids of all subsequent named attributes (decrease them by one).
+  for (int i = 0; i < GeometryAttribute::NAMED_ATTRIBUTES_COUNT; ++i) {
+    for (int j = 0; j < named_attribute_index_[i].size(); ++j) {
+      if (named_attribute_index_[i][j] > att_id) {
+        named_attribute_index_[i][j]--;
+      }
+    }
+  }
+}
+
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+void PointCloud::DeduplicatePointIds() {
+  // Hashing function for a single vertex.
+  auto point_hash = [this](PointIndex p) {
+    PointIndex::ValueType hash = 0;
+    for (int32_t i = 0; i < this->num_attributes(); ++i) {
+      const AttributeValueIndex att_id = attribute(i)->mapped_index(p);
+      hash = static_cast<uint32_t>(HashCombine(att_id.value(), hash));
+    }
+    return hash;
+  };
+  // Comparison function between two vertices.
+  auto point_compare = [this](PointIndex p0, PointIndex p1) {
+    for (int32_t i = 0; i < this->num_attributes(); ++i) {
+      const AttributeValueIndex att_id0 = attribute(i)->mapped_index(p0);
+      const AttributeValueIndex att_id1 = attribute(i)->mapped_index(p1);
+      if (att_id0 != att_id1) {
+        return false;
+      }
+    }
+    return true;
+  };
+
+  std::unordered_map<PointIndex, PointIndex, decltype(point_hash),
+                     decltype(point_compare)>
+      unique_point_map(num_points_, point_hash, point_compare);
+  int32_t num_unique_points = 0;
+  IndexTypeVector<PointIndex, PointIndex> index_map(num_points_);
+  std::vector<PointIndex> unique_points;
+  // Go through all vertices and find their duplicates.
+  for (PointIndex i(0); i < num_points_; ++i) {
+    const auto it = unique_point_map.find(i);
+    if (it != unique_point_map.end()) {
+      index_map[i] = it->second;
+    } else {
+      unique_point_map.insert(std::make_pair(i, PointIndex(num_unique_points)));
+      index_map[i] = num_unique_points++;
+      unique_points.push_back(i);
+    }
+  }
+  if (num_unique_points == num_points_) {
+    return;  // All vertices are already unique.
+  }
+
+  ApplyPointIdDeduplication(index_map, unique_points);
+  set_num_points(num_unique_points);
+}
+
+void PointCloud::ApplyPointIdDeduplication(
+    const IndexTypeVector<PointIndex, PointIndex> &id_map,
+    const std::vector<PointIndex> &unique_point_ids) {
+  int32_t num_unique_points = 0;
+  for (PointIndex i : unique_point_ids) {
+    const PointIndex new_point_id = id_map[i];
+    if (new_point_id >= num_unique_points) {
+      // New unique vertex reached. Copy attribute indices to the proper
+      // position.
+      for (int32_t a = 0; a < num_attributes(); ++a) {
+        attribute(a)->SetPointMapEntry(new_point_id,
+                                       attribute(a)->mapped_index(i));
+      }
+      num_unique_points = new_point_id.value() + 1;
+    }
+  }
+  for (int32_t a = 0; a < num_attributes(); ++a) {
+    attribute(a)->SetExplicitMapping(num_unique_points);
+  }
+}
+#endif
+
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+bool PointCloud::DeduplicateAttributeValues() {
+  // Go over all attributes and create mapping between duplicate entries.
+  if (num_points() == 0) {
+    return true;  // Nothing to deduplicate.
+  }
+  // Deduplicate all attributes.
+  for (int32_t att_id = 0; att_id < num_attributes(); ++att_id) {
+    if (!attribute(att_id)->DeduplicateValues(*attribute(att_id))) {
+      return false;
+    }
+  }
+  return true;
+}
+#endif
+
+// TODO(xiaoxumeng): Consider to cash the BBox.
+BoundingBox PointCloud::ComputeBoundingBox() const {
+  BoundingBox bounding_box;
+  auto pc_att = GetNamedAttribute(GeometryAttribute::POSITION);
+  // TODO(xiaoxumeng): Make the BoundingBox a template type, it may not be easy
+  // because PointCloud is not a template.
+  // Or simply add some preconditioning here to make sure the position attribute
+  // is valid, because the current code works only if the position attribute is
+  // defined with 3 components of DT_FLOAT32.
+  // Consider using pc_att->ConvertValue<float, 3>(i, &p[0]) (Enforced
+  // transformation from Vector with any dimension to Vector3f)
+  Vector3f p;
+  for (AttributeValueIndex i(0); i < static_cast<uint32_t>(pc_att->size());
+       ++i) {
+    pc_att->GetValue(i, &p[0]);
+    bounding_box.Update(p);
+  }
+  return bounding_box;
+}
+}  // namespace draco
diff --git a/contrib/draco/src/draco/point_cloud/point_cloud.h b/contrib/draco/src/draco/point_cloud/point_cloud.h
new file mode 100644
index 000000000..d11bd47a3
--- /dev/null
+++ b/contrib/draco/src/draco/point_cloud/point_cloud.h
@@ -0,0 +1,244 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_POINT_CLOUD_POINT_CLOUD_H_
+#define DRACO_POINT_CLOUD_POINT_CLOUD_H_
+
+#include "draco/attributes/point_attribute.h"
+#include "draco/core/bounding_box.h"
+#include "draco/core/vector_d.h"
+#include "draco/draco_features.h"
+#include "draco/metadata/geometry_metadata.h"
+
+namespace draco {
+
+// PointCloud is a collection of n-dimensional points that are described by a
+// set of PointAttributes that can represent data such as positions or colors
+// of individual points (see point_attribute.h).
+class PointCloud {
+ public:
+  PointCloud();
+  virtual ~PointCloud() = default;
+
+  // Returns the number of named attributes of a given type.
+  int32_t NumNamedAttributes(GeometryAttribute::Type type) const;
+
+  // Returns attribute id of the first named attribute with a given type or -1
+  // when the attribute is not used by the point cloud.
+  int32_t GetNamedAttributeId(GeometryAttribute::Type type) const;
+
+  // Returns the id of the i-th named attribute of a given type.
+  int32_t GetNamedAttributeId(GeometryAttribute::Type type, int i) const;
+
+  // Returns the first named attribute of a given type or nullptr if the
+  // attribute is not used by the point cloud.
+  const PointAttribute *GetNamedAttribute(GeometryAttribute::Type type) const;
+
+  // Returns the i-th named attribute of a given type.
+  const PointAttribute *GetNamedAttribute(GeometryAttribute::Type type,
+                                          int i) const;
+
+  // Returns the named attribute of a given unique id.
+  const PointAttribute *GetNamedAttributeByUniqueId(
+      GeometryAttribute::Type type, uint32_t id) const;
+
+  // Returns the attribute of a given unique id.
+  const PointAttribute *GetAttributeByUniqueId(uint32_t id) const;
+  int32_t GetAttributeIdByUniqueId(uint32_t unique_id) const;
+
+  int32_t num_attributes() const {
+    return static_cast<int32_t>(attributes_.size());
+  }
+  const PointAttribute *attribute(int32_t att_id) const {
+    DRACO_DCHECK_LE(0, att_id);
+    DRACO_DCHECK_LT(att_id, static_cast<int32_t>(attributes_.size()));
+    return attributes_[att_id].get();
+  }
+
+  // Returned attribute can be modified, but it's caller's responsibility to
+  // maintain the attribute's consistency with draco::PointCloud.
+  PointAttribute *attribute(int32_t att_id) {
+    DRACO_DCHECK_LE(0, att_id);
+    DRACO_DCHECK_LT(att_id, static_cast<int32_t>(attributes_.size()));
+    return attributes_[att_id].get();
+  }
+
+  // Adds a new attribute to the point cloud.
+  // Returns the attribute id.
+  int AddAttribute(std::unique_ptr<PointAttribute> pa);
+
+  // Creates and adds a new attribute to the point cloud. The attribute has
+  // properties derived from the provided GeometryAttribute |att|.
+  // If |identity_mapping| is set to true, the attribute will use identity
+  // mapping between point indices and attribute value indices (i.e., each
+  // point has a unique attribute value). If |identity_mapping| is false, the
+  // mapping between point indices and attribute value indices is set to
+  // explicit, and it needs to be initialized manually using the
+  // PointAttribute::SetPointMapEntry() method. |num_attribute_values| can be
+  // used to specify the number of attribute values that are going to be
+  // stored in the newly created attribute. Returns attribute id of the newly
+  // created attribute or -1 in case of failure.
+  int AddAttribute(const GeometryAttribute &att, bool identity_mapping,
+                   AttributeValueIndex::ValueType num_attribute_values);
+
+  // Creates and returns a new attribute or nullptr in case of failure. This
+  // method is similar to AddAttribute(), except that it returns the new
+  // attribute instead of adding it to the point cloud.
+  std::unique_ptr<PointAttribute> CreateAttribute(
+      const GeometryAttribute &att, bool identity_mapping,
+      AttributeValueIndex::ValueType num_attribute_values) const;
+
+  // Assigns an attribute id to a given PointAttribute. If an attribute with
+  // the same attribute id already exists, it is deleted.
+  virtual void SetAttribute(int att_id, std::unique_ptr<PointAttribute> pa);
+
+  // Deletes an attribute with specified attribute id. Note that this changes
+  // attribute ids of all subsequent attributes.
+  virtual void DeleteAttribute(int att_id);
+
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+  // Deduplicates all attribute values (all attribute entries with the same
+  // value are merged into a single entry).
+  virtual bool DeduplicateAttributeValues();
+#endif
+
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // Removes duplicate point ids (two point ids are duplicate when all of their
+  // attributes are mapped to the same entry ids).
+  virtual void DeduplicatePointIds();
+#endif
+
+  // Get bounding box.
+  BoundingBox ComputeBoundingBox() const;
+
+  // Add metadata.
+  void AddMetadata(std::unique_ptr<GeometryMetadata> metadata) {
+    metadata_ = std::move(metadata);
+  }
+
+  // Add metadata for an attribute.
+  void AddAttributeMetadata(int32_t att_id,
+                            std::unique_ptr<AttributeMetadata> metadata) {
+    if (!metadata_) {
+      metadata_ = std::unique_ptr<GeometryMetadata>(new GeometryMetadata());
+    }
+    const int32_t att_unique_id = attribute(att_id)->unique_id();
+    metadata->set_att_unique_id(att_unique_id);
+    metadata_->AddAttributeMetadata(std::move(metadata));
+  }
+
+  const AttributeMetadata *GetAttributeMetadataByAttributeId(
+      int32_t att_id) const {
+    if (metadata_ == nullptr) {
+      return nullptr;
+    }
+    const uint32_t unique_id = attribute(att_id)->unique_id();
+    return metadata_->GetAttributeMetadataByUniqueId(unique_id);
+  }
+
+  // Returns the attribute metadata that has the requested metadata entry.
+  const AttributeMetadata *GetAttributeMetadataByStringEntry(
+      const std::string &name, const std::string &value) const {
+    if (metadata_ == nullptr) {
+      return nullptr;
+    }
+    return metadata_->GetAttributeMetadataByStringEntry(name, value);
+  }
+
+  // Returns the first attribute that has the requested metadata entry.
+  int GetAttributeIdByMetadataEntry(const std::string &name,
+                                    const std::string &value) const {
+    if (metadata_ == nullptr) {
+      return -1;
+    }
+    const AttributeMetadata *att_metadata =
+        metadata_->GetAttributeMetadataByStringEntry(name, value);
+    if (!att_metadata) {
+      return -1;
+    }
+    return GetAttributeIdByUniqueId(att_metadata->att_unique_id());
+  }
+
+  // Get a const pointer of the metadata of the point cloud.
+  const GeometryMetadata *GetMetadata() const { return metadata_.get(); }
+
+  // Get a pointer to the metadata of the point cloud.
+  GeometryMetadata *metadata() { return metadata_.get(); }
+
+  // Returns the number of n-dimensional points stored within the point cloud.
+  PointIndex::ValueType num_points() const { return num_points_; }
+
+  // Sets the number of points. It's the caller's responsibility to ensure the
+  // new number is valid with respect to the PointAttributes stored in the point
+  // cloud.
+  void set_num_points(PointIndex::ValueType num) { num_points_ = num; }
+
+ protected:
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // Applies id mapping of deduplicated points (called by DeduplicatePointIds).
+  virtual void ApplyPointIdDeduplication(
+      const IndexTypeVector<PointIndex, PointIndex> &id_map,
+      const std::vector<PointIndex> &unique_point_ids);
+#endif
+
+ private:
+  // Metadata for the point cloud.
+  std::unique_ptr<GeometryMetadata> metadata_;
+
+  // Attributes describing the point cloud.
+  std::vector<std::unique_ptr<PointAttribute>> attributes_;
+
+  // Ids of named attributes of the given type.
+  std::vector<int32_t>
+      named_attribute_index_[GeometryAttribute::NAMED_ATTRIBUTES_COUNT];
+
+  // The number of n-dimensional points. All point attribute values are stored
+  // in corresponding PointAttribute instances in the |attributes_| array.
+  PointIndex::ValueType num_points_;
+
+  friend struct PointCloudHasher;
+};
+
+// Functor for computing a hash from data stored within a point cloud.
+// Note that this can be quite slow. Two point clouds will have the same hash
+// only when all points have the same order and when all attribute values are
+// exactly the same.
+struct PointCloudHasher {
+  size_t operator()(const PointCloud &pc) const {
+    size_t hash = pc.num_points_;
+    hash = HashCombine(pc.attributes_.size(), hash);
+    for (int i = 0; i < GeometryAttribute::NAMED_ATTRIBUTES_COUNT; ++i) {
+      hash = HashCombine(pc.named_attribute_index_[i].size(), hash);
+      for (int j = 0; j < static_cast<int>(pc.named_attribute_index_[i].size());
+           ++j) {
+        hash = HashCombine(pc.named_attribute_index_[i][j], hash);
+      }
+    }
+    // Hash attributes.
+    for (int i = 0; i < static_cast<int>(pc.attributes_.size()); ++i) {
+      PointAttributeHasher att_hasher;
+      hash = HashCombine(att_hasher(*pc.attributes_[i]), hash);
+    }
+    // Hash metadata.
+    GeometryMetadataHasher metadata_hasher;
+    if (pc.metadata_) {
+      hash = HashCombine(metadata_hasher(*pc.metadata_), hash);
+    }
+    return hash;
+  }
+};
+
+}  // namespace draco
+
+#endif  // DRACO_POINT_CLOUD_POINT_CLOUD_H_
diff --git a/contrib/draco/src/draco/point_cloud/point_cloud_builder.cc b/contrib/draco/src/draco/point_cloud/point_cloud_builder.cc
new file mode 100644
index 000000000..431ae505f
--- /dev/null
+++ b/contrib/draco/src/draco/point_cloud/point_cloud_builder.cc
@@ -0,0 +1,76 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/point_cloud/point_cloud_builder.h"
+
+namespace draco {
+
+PointCloudBuilder::PointCloudBuilder() {}
+
+void PointCloudBuilder::Start(PointIndex::ValueType num_points) {
+  point_cloud_ = std::unique_ptr<PointCloud>(new PointCloud());
+  point_cloud_->set_num_points(num_points);
+}
+
+int PointCloudBuilder::AddAttribute(GeometryAttribute::Type attribute_type,
+                                    int8_t num_components, DataType data_type) {
+  GeometryAttribute ga;
+  ga.Init(attribute_type, nullptr, num_components, data_type, false,
+          DataTypeLength(data_type) * num_components, 0);
+  return point_cloud_->AddAttribute(ga, true, point_cloud_->num_points());
+}
+
+void PointCloudBuilder::SetAttributeValueForPoint(int att_id,
+                                                  PointIndex point_index,
+                                                  const void *attribute_value) {
+  PointAttribute *const att = point_cloud_->attribute(att_id);
+  att->SetAttributeValue(att->mapped_index(point_index), attribute_value);
+}
+
+void PointCloudBuilder::SetAttributeValuesForAllPoints(
+    int att_id, const void *attribute_values, int stride) {
+  PointAttribute *const att = point_cloud_->attribute(att_id);
+  const int data_stride =
+      DataTypeLength(att->data_type()) * att->num_components();
+  if (stride == 0) {
+    stride = data_stride;
+  }
+  if (stride == data_stride) {
+    // Fast copy path.
+    att->buffer()->Write(0, attribute_values,
+                         point_cloud_->num_points() * data_stride);
+  } else {
+    // Copy attribute entries one by one.
+    for (PointIndex i(0); i < point_cloud_->num_points(); ++i) {
+      att->SetAttributeValue(
+          att->mapped_index(i),
+          static_cast<const uint8_t *>(attribute_values) + stride * i.value());
+    }
+  }
+}
+
+std::unique_ptr<PointCloud> PointCloudBuilder::Finalize(
+    bool deduplicate_points) {
+  if (deduplicate_points) {
+#ifdef DRACO_ATTRIBUTE_VALUES_DEDUPLICATION_SUPPORTED
+    point_cloud_->DeduplicateAttributeValues();
+#endif
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+    point_cloud_->DeduplicatePointIds();
+#endif
+  }
+  return std::move(point_cloud_);
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/point_cloud/point_cloud_builder.h b/contrib/draco/src/draco/point_cloud/point_cloud_builder.h
new file mode 100644
index 000000000..cf55a728b
--- /dev/null
+++ b/contrib/draco/src/draco/point_cloud/point_cloud_builder.h
@@ -0,0 +1,80 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_POINT_CLOUD_POINT_CLOUD_BUILDER_H_
+#define DRACO_POINT_CLOUD_POINT_CLOUD_BUILDER_H_
+
+#include "draco/point_cloud/point_cloud.h"
+
+namespace draco {
+
+// A helper class for constructing PointCloud instances from other data sources.
+// Usage:
+//   PointCloudBuilder builder;
+//   // Initialize the builder for a given number of points (required).
+//   builder.Start(num_points);
+//   // Specify desired attributes.
+//   int pos_att_id =
+//       builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+//   // Add attribute values.
+//   for (PointIndex i(0); i < num_points; ++i) {
+//     builder.SetAttributeValueForPoint(pos_att_id, i, input_pos[i.value()]);
+//   }
+//   // Get the final PointCloud.
+//   constexpr bool deduplicate_points = false;
+//   std::unique_ptr<PointCloud> pc = builder.Finalize(deduplicate_points);
+
+class PointCloudBuilder {
+ public:
+  PointCloudBuilder();
+
+  // Starts collecting point cloud data.
+  // The behavior of other functions is undefined before this method is called.
+  void Start(PointIndex::ValueType num_points);
+
+  int AddAttribute(GeometryAttribute::Type attribute_type,
+                   int8_t num_components, DataType data_type);
+
+  // Sets attribute value for a specific point.
+  // |attribute_value| must contain data in the format specified by the
+  // AddAttribute method.
+  void SetAttributeValueForPoint(int att_id, PointIndex point_index,
+                                 const void *attribute_value);
+
+  // Sets attribute values for all points. All the values must be stored in the
+  // input |attribute_values| buffer. |stride| can be used to define the byte
+  // offset between two consecutive attribute values. If |stride| is set to 0,
+  // the stride is automatically computed based on the format of the given
+  // attribute.
+  void SetAttributeValuesForAllPoints(int att_id, const void *attribute_values,
+                                      int stride);
+
+  // Finalizes the PointCloud or returns nullptr on error.
+  // If |deduplicate_points| is set to true, the following happens:
+  //   1. Attribute values with duplicate entries are deduplicated.
+  //   2. Point ids that are mapped to the same attribute values are
+  //      deduplicated.
+  // Therefore, if |deduplicate_points| is true the final PointCloud can have
+  // a different number of point from the value specified in the Start method.
+  // Once this function is called, the builder becomes invalid and cannot be
+  // used until the method Start() is called again.
+  std::unique_ptr<PointCloud> Finalize(bool deduplicate_points);
+
+ private:
+  std::unique_ptr<PointCloud> point_cloud_;
+};
+
+}  // namespace draco
+
+#endif  // DRACO_POINT_CLOUD_POINT_CLOUD_BUILDER_H_
diff --git a/contrib/draco/src/draco/point_cloud/point_cloud_builder_test.cc b/contrib/draco/src/draco/point_cloud/point_cloud_builder_test.cc
new file mode 100644
index 000000000..3222a4c8d
--- /dev/null
+++ b/contrib/draco/src/draco/point_cloud/point_cloud_builder_test.cc
@@ -0,0 +1,171 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/point_cloud/point_cloud_builder.h"
+
+#include "draco/core/draco_test_base.h"
+
+namespace draco {
+
+class PointCloudBuilderTest : public ::testing::Test {
+ protected:
+  // Test data.
+  // clang-format off
+  std::vector<float> pos_data_ = {10.f, 0.f, 1.f,
+                                  11.f, 1.f, 2.f,
+                                  12.f, 2.f, 8.f,
+                                  13.f, 4.f, 7.f,
+                                  14.f, 5.f, 6.f,
+                                  15.f, 6.f, 5.f,
+                                  16.f, 1.f, 3.f,
+                                  17.f, 1.f, 2.f,
+                                  11.f, 1.f, 2.f,
+                                  10.f, 0.f, 1.f};
+  std::vector<int16_t> intensity_data_ = {100,
+                                          200,
+                                          500,
+                                          700,
+                                          400,
+                                          400,
+                                          400,
+                                          100,
+                                          100,
+                                          100};
+  // clang-format on
+};
+
+TEST_F(PointCloudBuilderTest, IndividualTest_NoDedup) {
+  // This test verifies that PointCloudBuilder can construct point cloud using
+  // SetAttributeValueForPoint API without deduplication.
+  PointCloudBuilder builder;
+  builder.Start(10);
+  const int pos_att_id =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  const int intensity_att_id =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_INT16);
+  for (PointIndex i(0); i < 10; ++i) {
+    builder.SetAttributeValueForPoint(pos_att_id, i,
+                                      pos_data_.data() + 3 * i.value());
+    builder.SetAttributeValueForPoint(intensity_att_id, i,
+                                      intensity_data_.data() + i.value());
+  }
+  std::unique_ptr<PointCloud> res = builder.Finalize(false);
+  ASSERT_TRUE(res != nullptr);
+  ASSERT_EQ(res->num_points(), 10);
+}
+
+TEST_F(PointCloudBuilderTest, IndividualTest_Dedup) {
+  // This test verifies that PointCloudBuilder can construct point cloud using
+  // SetAttributeValueForPoint API with deduplication.
+  PointCloudBuilder builder;
+  builder.Start(10);
+  const int pos_att_id =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  const int intensity_att_id =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_INT16);
+  for (PointIndex i(0); i < 10; ++i) {
+    builder.SetAttributeValueForPoint(pos_att_id, i,
+                                      pos_data_.data() + 3 * i.value());
+    builder.SetAttributeValueForPoint(intensity_att_id, i,
+                                      intensity_data_.data() + i.value());
+  }
+  std::unique_ptr<PointCloud> res = builder.Finalize(true);
+  ASSERT_TRUE(res != nullptr);
+  ASSERT_EQ(res->num_points(), 9);
+}
+
+TEST_F(PointCloudBuilderTest, BatchTest) {
+  // This test verifies that PointCloudBuilder can construct point cloud using
+  // SetAttributeValuesForAllPoints API.
+  PointCloudBuilder builder;
+  builder.Start(10);
+  const int pos_att_id =
+      builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+  const int intensity_att_id =
+      builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_INT16);
+  builder.SetAttributeValuesForAllPoints(pos_att_id, pos_data_.data(), 0);
+  builder.SetAttributeValuesForAllPoints(intensity_att_id,
+                                         intensity_data_.data(), 0);
+  std::unique_ptr<PointCloud> res = builder.Finalize(false);
+  ASSERT_TRUE(res != nullptr);
+  ASSERT_EQ(res->num_points(), 10);
+  for (PointIndex i(0); i < 10; ++i) {
+    float pos_val[3];
+    res->attribute(pos_att_id)->GetMappedValue(i, pos_val);
+    for (int c = 0; c < 3; ++c) {
+      ASSERT_EQ(pos_val[c], pos_data_[3 * i.value() + c]);
+    }
+    int16_t int_val;
+    res->attribute(intensity_att_id)->GetMappedValue(i, &int_val);
+    ASSERT_EQ(intensity_data_[i.value()], int_val);
+  }
+}
+
+TEST_F(PointCloudBuilderTest, MultiUse) {
+  // This test verifies that PointCloudBuilder can be used multiple times
+  PointCloudBuilder builder;
+  {
+    builder.Start(10);
+    const int pos_att_id =
+        builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+    const int intensity_att_id =
+        builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_INT16);
+    builder.SetAttributeValuesForAllPoints(pos_att_id, pos_data_.data(), 0);
+    builder.SetAttributeValuesForAllPoints(intensity_att_id,
+                                           intensity_data_.data(), 0);
+    std::unique_ptr<PointCloud> res = builder.Finalize(false);
+    ASSERT_TRUE(res != nullptr);
+    ASSERT_EQ(res->num_points(), 10);
+    for (PointIndex i(0); i < 10; ++i) {
+      float pos_val[3];
+      res->attribute(pos_att_id)->GetMappedValue(i, pos_val);
+      for (int c = 0; c < 3; ++c) {
+        ASSERT_EQ(pos_val[c], pos_data_[3 * i.value() + c]);
+      }
+      int16_t int_val;
+      res->attribute(intensity_att_id)->GetMappedValue(i, &int_val);
+      ASSERT_EQ(intensity_data_[i.value()], int_val);
+    }
+  }
+
+  {
+    // Use only a sub-set of data (offsetted to avoid possible reuse of old
+    // data).
+    builder.Start(4);
+    const int pos_att_id =
+        builder.AddAttribute(GeometryAttribute::POSITION, 3, DT_FLOAT32);
+    const int intensity_att_id =
+        builder.AddAttribute(GeometryAttribute::GENERIC, 1, DT_INT16);
+    constexpr int offset = 5;
+    builder.SetAttributeValuesForAllPoints(pos_att_id,
+                                           pos_data_.data() + 3 * offset, 0);
+    builder.SetAttributeValuesForAllPoints(intensity_att_id,
+                                           intensity_data_.data() + offset, 0);
+    std::unique_ptr<PointCloud> res = builder.Finalize(false);
+    ASSERT_TRUE(res != nullptr);
+    ASSERT_EQ(res->num_points(), 4);
+    for (PointIndex i(0); i < 4; ++i) {
+      float pos_val[3];
+      res->attribute(pos_att_id)->GetMappedValue(i, pos_val);
+      for (int c = 0; c < 3; ++c) {
+        ASSERT_EQ(pos_val[c], pos_data_[3 * (i.value() + offset) + c]);
+      }
+      int16_t int_val;
+      res->attribute(intensity_att_id)->GetMappedValue(i, &int_val);
+      ASSERT_EQ(intensity_data_[i.value() + offset], int_val);
+    }
+  }
+}
+
+}  // namespace draco
diff --git a/contrib/draco/src/draco/point_cloud/point_cloud_test.cc b/contrib/draco/src/draco/point_cloud/point_cloud_test.cc
new file mode 100644
index 000000000..4e9460370
--- /dev/null
+++ b/contrib/draco/src/draco/point_cloud/point_cloud_test.cc
@@ -0,0 +1,132 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/point_cloud/point_cloud.h"
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+#include "draco/metadata/geometry_metadata.h"
+
+namespace {
+
+class PointCloudTest : public ::testing::Test {
+ protected:
+  PointCloudTest() {}
+};
+
+TEST_F(PointCloudTest, TestAttributeDeletion) {
+  draco::PointCloud pc;
+  // Test whether we can correctly delete an attribute from a point cloud.
+  // Create some attributes for the point cloud.
+  draco::GeometryAttribute pos_att;
+  pos_att.Init(draco::GeometryAttribute::POSITION, nullptr, 3,
+               draco::DT_FLOAT32, false, 12, 0);
+  draco::GeometryAttribute norm_att;
+  norm_att.Init(draco::GeometryAttribute::NORMAL, nullptr, 3, draco::DT_FLOAT32,
+                false, 12, 0);
+  draco::GeometryAttribute gen_att;
+  gen_att.Init(draco::GeometryAttribute::GENERIC, nullptr, 3, draco::DT_FLOAT32,
+               false, 12, 0);
+
+  // Add one position, two normal and two generic attributes.
+  pc.AddAttribute(pos_att, false, 0);
+  pc.AddAttribute(gen_att, false, 0);
+  pc.AddAttribute(norm_att, false, 0);
+  pc.AddAttribute(gen_att, false, 0);
+  pc.AddAttribute(norm_att, false, 0);
+
+  ASSERT_EQ(pc.num_attributes(), 5);
+  ASSERT_EQ(pc.attribute(0)->attribute_type(),
+            draco::GeometryAttribute::POSITION);
+  ASSERT_EQ(pc.attribute(3)->attribute_type(),
+            draco::GeometryAttribute::GENERIC);
+
+  // Delete generic attribute.
+  pc.DeleteAttribute(1);
+  ASSERT_EQ(pc.num_attributes(), 4);
+  ASSERT_EQ(pc.attribute(1)->attribute_type(),
+            draco::GeometryAttribute::NORMAL);
+  ASSERT_EQ(pc.NumNamedAttributes(draco::GeometryAttribute::NORMAL), 2);
+  ASSERT_EQ(pc.GetNamedAttributeId(draco::GeometryAttribute::NORMAL, 1), 3);
+
+  // Delete the first normal attribute.
+  pc.DeleteAttribute(1);
+  ASSERT_EQ(pc.num_attributes(), 3);
+  ASSERT_EQ(pc.attribute(1)->attribute_type(),
+            draco::GeometryAttribute::GENERIC);
+  ASSERT_EQ(pc.NumNamedAttributes(draco::GeometryAttribute::NORMAL), 1);
+  ASSERT_EQ(pc.GetNamedAttributeId(draco::GeometryAttribute::NORMAL, 0), 2);
+}
+
+TEST_F(PointCloudTest, TestPointCloudWithMetadata) {
+  draco::PointCloud pc;
+  std::unique_ptr<draco::GeometryMetadata> metadata =
+      std::unique_ptr<draco::GeometryMetadata>(new draco::GeometryMetadata());
+
+  // Add a position attribute metadata.
+  draco::GeometryAttribute pos_att;
+  pos_att.Init(draco::GeometryAttribute::POSITION, nullptr, 3,
+               draco::DT_FLOAT32, false, 12, 0);
+  const uint32_t pos_att_id = pc.AddAttribute(pos_att, false, 0);
+  ASSERT_EQ(pos_att_id, 0);
+  std::unique_ptr<draco::AttributeMetadata> pos_metadata =
+      std::unique_ptr<draco::AttributeMetadata>(new draco::AttributeMetadata());
+  pos_metadata->AddEntryString("name", "position");
+  pc.AddAttributeMetadata(pos_att_id, std::move(pos_metadata));
+  const draco::GeometryMetadata *pc_metadata = pc.GetMetadata();
+  ASSERT_NE(pc_metadata, nullptr);
+  // Add a generic material attribute metadata.
+  draco::GeometryAttribute material_att;
+  material_att.Init(draco::GeometryAttribute::GENERIC, nullptr, 3,
+                    draco::DT_FLOAT32, false, 12, 0);
+  const uint32_t material_att_id = pc.AddAttribute(material_att, false, 0);
+  ASSERT_EQ(material_att_id, 1);
+  std::unique_ptr<draco::AttributeMetadata> material_metadata =
+      std::unique_ptr<draco::AttributeMetadata>(new draco::AttributeMetadata());
+  material_metadata->AddEntryString("name", "material");
+  // The material attribute has id of 1 now.
+  pc.AddAttributeMetadata(material_att_id, std::move(material_metadata));
+
+  // Test if the attribute metadata is correctly added.
+  const draco::AttributeMetadata *requested_pos_metadata =
+      pc.GetAttributeMetadataByStringEntry("name", "position");
+  ASSERT_NE(requested_pos_metadata, nullptr);
+  const draco::AttributeMetadata *requested_mat_metadata =
+      pc.GetAttributeMetadataByStringEntry("name", "material");
+  ASSERT_NE(requested_mat_metadata, nullptr);
+
+  // Attribute id should be preserved.
+  ASSERT_EQ(
+      pc.GetAttributeIdByUniqueId(requested_pos_metadata->att_unique_id()), 0);
+  ASSERT_EQ(
+      pc.GetAttributeIdByUniqueId(requested_mat_metadata->att_unique_id()), 1);
+
+  // Test deleting attribute with metadata.
+  pc.DeleteAttribute(pos_att_id);
+  ASSERT_EQ(pc.GetAttributeMetadataByStringEntry("name", "position"), nullptr);
+
+  requested_mat_metadata =
+      pc.GetAttributeMetadataByStringEntry("name", "material");
+  // The unique id should not be changed.
+  ASSERT_EQ(requested_mat_metadata->att_unique_id(), 1);
+  // Now position attribute is removed, material attribute should have the
+  // attribute id of 0.
+  ASSERT_EQ(
+      pc.GetAttributeIdByUniqueId(requested_mat_metadata->att_unique_id()), 0);
+  // Should be able to get metadata using the current attribute id.
+  // Attribute id of material attribute is changed from 1 to 0.
+  ASSERT_NE(pc.GetAttributeMetadataByAttributeId(0), nullptr);
+}
+
+}  // namespace
diff --git a/contrib/draco/src/draco/tools/draco_decoder.cc b/contrib/draco/src/draco/tools/draco_decoder.cc
new file mode 100644
index 000000000..610709d62
--- /dev/null
+++ b/contrib/draco/src/draco/tools/draco_decoder.cc
@@ -0,0 +1,168 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <cinttypes>
+
+#include "draco/compression/decode.h"
+#include "draco/core/cycle_timer.h"
+#include "draco/io/file_utils.h"
+#include "draco/io/obj_encoder.h"
+#include "draco/io/parser_utils.h"
+#include "draco/io/ply_encoder.h"
+
+namespace {
+
+struct Options {
+  Options();
+
+  std::string input;
+  std::string output;
+};
+
+Options::Options() {}
+
+void Usage() {
+  printf("Usage: draco_decoder [options] -i input\n");
+  printf("\n");
+  printf("Main options:\n");
+  printf("  -h | -?               show help.\n");
+  printf("  -o <output>           output file name.\n");
+}
+
+int ReturnError(const draco::Status &status) {
+  printf("Failed to decode the input file %s\n", status.error_msg());
+  return -1;
+}
+
+}  // namespace
+
+int main(int argc, char **argv) {
+  Options options;
+  const int argc_check = argc - 1;
+
+  for (int i = 1; i < argc; ++i) {
+    if (!strcmp("-h", argv[i]) || !strcmp("-?", argv[i])) {
+      Usage();
+      return 0;
+    } else if (!strcmp("-i", argv[i]) && i < argc_check) {
+      options.input = argv[++i];
+    } else if (!strcmp("-o", argv[i]) && i < argc_check) {
+      options.output = argv[++i];
+    }
+  }
+  if (argc < 3 || options.input.empty()) {
+    Usage();
+    return -1;
+  }
+
+  std::vector<char> data;
+  if (!draco::ReadFileToBuffer(options.input, &data)) {
+    printf("Failed opening the input file.\n");
+    return -1;
+  }
+
+  if (data.empty()) {
+    printf("Empty input file.\n");
+    return -1;
+  }
+
+  // Create a draco decoding buffer. Note that no data is copied in this step.
+  draco::DecoderBuffer buffer;
+  buffer.Init(data.data(), data.size());
+
+  draco::CycleTimer timer;
+  // Decode the input data into a geometry.
+  std::unique_ptr<draco::PointCloud> pc;
+  draco::Mesh *mesh = nullptr;
+  auto type_statusor = draco::Decoder::GetEncodedGeometryType(&buffer);
+  if (!type_statusor.ok()) {
+    return ReturnError(type_statusor.status());
+  }
+  const draco::EncodedGeometryType geom_type = type_statusor.value();
+  if (geom_type == draco::TRIANGULAR_MESH) {
+    timer.Start();
+    draco::Decoder decoder;
+    auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
+    if (!statusor.ok()) {
+      return ReturnError(statusor.status());
+    }
+    std::unique_ptr<draco::Mesh> in_mesh = std::move(statusor).value();
+    timer.Stop();
+    if (in_mesh) {
+      mesh = in_mesh.get();
+      pc = std::move(in_mesh);
+    }
+  } else if (geom_type == draco::POINT_CLOUD) {
+    // Failed to decode it as mesh, so let's try to decode it as a point cloud.
+    timer.Start();
+    draco::Decoder decoder;
+    auto statusor = decoder.DecodePointCloudFromBuffer(&buffer);
+    if (!statusor.ok()) {
+      return ReturnError(statusor.status());
+    }
+    pc = std::move(statusor).value();
+    timer.Stop();
+  }
+
+  if (pc == nullptr) {
+    printf("Failed to decode the input file.\n");
+    return -1;
+  }
+
+  if (options.output.empty()) {
+    // Save the output model into a ply file.
+    options.output = options.input + ".ply";
+  }
+
+  // Save the decoded geometry into a file.
+  // TODO(fgalligan): Change extension code to look for '.'.
+  const std::string extension = draco::parser::ToLower(
+      options.output.size() >= 4
+          ? options.output.substr(options.output.size() - 4)
+          : options.output);
+
+  if (extension == ".obj") {
+    draco::ObjEncoder obj_encoder;
+    if (mesh) {
+      if (!obj_encoder.EncodeToFile(*mesh, options.output)) {
+        printf("Failed to store the decoded mesh as OBJ.\n");
+        return -1;
+      }
+    } else {
+      if (!obj_encoder.EncodeToFile(*pc.get(), options.output)) {
+        printf("Failed to store the decoded point cloud as OBJ.\n");
+        return -1;
+      }
+    }
+  } else if (extension == ".ply") {
+    draco::PlyEncoder ply_encoder;
+    if (mesh) {
+      if (!ply_encoder.EncodeToFile(*mesh, options.output)) {
+        printf("Failed to store the decoded mesh as PLY.\n");
+        return -1;
+      }
+    } else {
+      if (!ply_encoder.EncodeToFile(*pc.get(), options.output)) {
+        printf("Failed to store the decoded point cloud as PLY.\n");
+        return -1;
+      }
+    }
+  } else {
+    printf("Invalid extension of the output file. Use either .ply or .obj.\n");
+    return -1;
+  }
+  printf("Decoded geometry saved to %s (%" PRId64 " ms to decode)\n",
+         options.output.c_str(), timer.GetInMs());
+  return 0;
+}
diff --git a/contrib/draco/src/draco/tools/draco_encoder.cc b/contrib/draco/src/draco/tools/draco_encoder.cc
new file mode 100644
index 000000000..7e3632d7d
--- /dev/null
+++ b/contrib/draco/src/draco/tools/draco_encoder.cc
@@ -0,0 +1,369 @@
+// Copyright 2016 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include <cinttypes>
+#include <cstdlib>
+
+#include "draco/compression/encode.h"
+#include "draco/core/cycle_timer.h"
+#include "draco/io/file_utils.h"
+#include "draco/io/mesh_io.h"
+#include "draco/io/point_cloud_io.h"
+
+namespace {
+
+struct Options {
+  Options();
+
+  bool is_point_cloud;
+  int pos_quantization_bits;
+  int tex_coords_quantization_bits;
+  bool tex_coords_deleted;
+  int normals_quantization_bits;
+  bool normals_deleted;
+  int generic_quantization_bits;
+  bool generic_deleted;
+  int compression_level;
+  bool use_metadata;
+  std::string input;
+  std::string output;
+};
+
+Options::Options()
+    : is_point_cloud(false),
+      pos_quantization_bits(11),
+      tex_coords_quantization_bits(10),
+      tex_coords_deleted(false),
+      normals_quantization_bits(8),
+      normals_deleted(false),
+      generic_quantization_bits(8),
+      generic_deleted(false),
+      compression_level(7),
+      use_metadata(false) {}
+
+void Usage() {
+  printf("Usage: draco_encoder [options] -i input\n");
+  printf("\n");
+  printf("Main options:\n");
+  printf("  -h | -?               show help.\n");
+  printf("  -i <input>            input file name.\n");
+  printf("  -o <output>           output file name.\n");
+  printf(
+      "  -point_cloud          forces the input to be encoded as a point "
+      "cloud.\n");
+  printf(
+      "  -qp <value>           quantization bits for the position "
+      "attribute, default=11.\n");
+  printf(
+      "  -qt <value>           quantization bits for the texture coordinate "
+      "attribute, default=10.\n");
+  printf(
+      "  -qn <value>           quantization bits for the normal vector "
+      "attribute, default=8.\n");
+  printf(
+      "  -qg <value>           quantization bits for any generic attribute, "
+      "default=8.\n");
+  printf(
+      "  -cl <value>           compression level [0-10], most=10, least=0, "
+      "default=7.\n");
+  printf(
+      "  --skip ATTRIBUTE_NAME skip a given attribute (NORMAL, TEX_COORD, "
+      "GENERIC)\n");
+  printf(
+      "  --metadata            use metadata to encode extra information in "
+      "mesh files.\n");
+  printf(
+      "\nUse negative quantization values to skip the specified attribute\n");
+}
+
+int StringToInt(const std::string &s) {
+  char *end;
+  return strtol(s.c_str(), &end, 10);  // NOLINT
+}
+
+void PrintOptions(const draco::PointCloud &pc, const Options &options) {
+  printf("Encoder options:\n");
+  printf("  Compression level = %d\n", options.compression_level);
+  if (options.pos_quantization_bits == 0) {
+    printf("  Positions: No quantization\n");
+  } else {
+    printf("  Positions: Quantization = %d bits\n",
+           options.pos_quantization_bits);
+  }
+
+  if (pc.GetNamedAttributeId(draco::GeometryAttribute::TEX_COORD) >= 0) {
+    if (options.tex_coords_quantization_bits == 0) {
+      printf("  Texture coordinates: No quantization\n");
+    } else {
+      printf("  Texture coordinates: Quantization = %d bits\n",
+             options.tex_coords_quantization_bits);
+    }
+  } else if (options.tex_coords_deleted) {
+    printf("  Texture coordinates: Skipped\n");
+  }
+
+  if (pc.GetNamedAttributeId(draco::GeometryAttribute::NORMAL) >= 0) {
+    if (options.normals_quantization_bits == 0) {
+      printf("  Normals: No quantization\n");
+    } else {
+      printf("  Normals: Quantization = %d bits\n",
+             options.normals_quantization_bits);
+    }
+  } else if (options.normals_deleted) {
+    printf("  Normals: Skipped\n");
+  }
+
+  if (pc.GetNamedAttributeId(draco::GeometryAttribute::GENERIC) >= 0) {
+    if (options.generic_quantization_bits == 0) {
+      printf("  Generic: No quantization\n");
+    } else {
+      printf("  Generic: Quantization = %d bits\n",
+             options.generic_quantization_bits);
+    }
+  } else if (options.generic_deleted) {
+    printf("  Generic: Skipped\n");
+  }
+  printf("\n");
+}
+
+int EncodePointCloudToFile(const draco::PointCloud &pc, const std::string &file,
+                           draco::Encoder *encoder) {
+  draco::CycleTimer timer;
+  // Encode the geometry.
+  draco::EncoderBuffer buffer;
+  timer.Start();
+  const draco::Status status = encoder->EncodePointCloudToBuffer(pc, &buffer);
+  if (!status.ok()) {
+    printf("Failed to encode the point cloud.\n");
+    printf("%s\n", status.error_msg());
+    return -1;
+  }
+  timer.Stop();
+  // Save the encoded geometry into a file.
+  if (!draco::WriteBufferToFile(buffer.data(), buffer.size(), file)) {
+    printf("Failed to write the output file.\n");
+    return -1;
+  }
+  printf("Encoded point cloud saved to %s (%" PRId64 " ms to encode).\n",
+         file.c_str(), timer.GetInMs());
+  printf("\nEncoded size = %zu bytes\n\n", buffer.size());
+  return 0;
+}
+
+int EncodeMeshToFile(const draco::Mesh &mesh, const std::string &file,
+                     draco::Encoder *encoder) {
+  draco::CycleTimer timer;
+  // Encode the geometry.
+  draco::EncoderBuffer buffer;
+  timer.Start();
+  const draco::Status status = encoder->EncodeMeshToBuffer(mesh, &buffer);
+  if (!status.ok()) {
+    printf("Failed to encode the mesh.\n");
+    printf("%s\n", status.error_msg());
+    return -1;
+  }
+  timer.Stop();
+  // Save the encoded geometry into a file.
+  if (!draco::WriteBufferToFile(buffer.data(), buffer.size(), file)) {
+    printf("Failed to create the output file.\n");
+    return -1;
+  }
+  printf("Encoded mesh saved to %s (%" PRId64 " ms to encode).\n", file.c_str(),
+         timer.GetInMs());
+  printf("\nEncoded size = %zu bytes\n\n", buffer.size());
+  return 0;
+}
+
+}  // anonymous namespace
+
+int main(int argc, char **argv) {
+  Options options;
+  const int argc_check = argc - 1;
+
+  for (int i = 1; i < argc; ++i) {
+    if (!strcmp("-h", argv[i]) || !strcmp("-?", argv[i])) {
+      Usage();
+      return 0;
+    } else if (!strcmp("-i", argv[i]) && i < argc_check) {
+      options.input = argv[++i];
+    } else if (!strcmp("-o", argv[i]) && i < argc_check) {
+      options.output = argv[++i];
+    } else if (!strcmp("-point_cloud", argv[i])) {
+      options.is_point_cloud = true;
+    } else if (!strcmp("-qp", argv[i]) && i < argc_check) {
+      options.pos_quantization_bits = StringToInt(argv[++i]);
+      if (options.pos_quantization_bits > 30) {
+        printf(
+            "Error: The maximum number of quantization bits for the position "
+            "attribute is 30.\n");
+        return -1;
+      }
+    } else if (!strcmp("-qt", argv[i]) && i < argc_check) {
+      options.tex_coords_quantization_bits = StringToInt(argv[++i]);
+      if (options.tex_coords_quantization_bits > 30) {
+        printf(
+            "Error: The maximum number of quantization bits for the texture "
+            "coordinate attribute is 30.\n");
+        return -1;
+      }
+    } else if (!strcmp("-qn", argv[i]) && i < argc_check) {
+      options.normals_quantization_bits = StringToInt(argv[++i]);
+      if (options.normals_quantization_bits > 30) {
+        printf(
+            "Error: The maximum number of quantization bits for the normal "
+            "attribute is 30.\n");
+        return -1;
+      }
+    } else if (!strcmp("-qg", argv[i]) && i < argc_check) {
+      options.generic_quantization_bits = StringToInt(argv[++i]);
+      if (options.generic_quantization_bits > 30) {
+        printf(
+            "Error: The maximum number of quantization bits for generic "
+            "attributes is 30.\n");
+        return -1;
+      }
+    } else if (!strcmp("-cl", argv[i]) && i < argc_check) {
+      options.compression_level = StringToInt(argv[++i]);
+    } else if (!strcmp("--skip", argv[i]) && i < argc_check) {
+      if (!strcmp("NORMAL", argv[i + 1])) {
+        options.normals_quantization_bits = -1;
+      } else if (!strcmp("TEX_COORD", argv[i + 1])) {
+        options.tex_coords_quantization_bits = -1;
+      } else if (!strcmp("GENERIC", argv[i + 1])) {
+        options.generic_quantization_bits = -1;
+      } else {
+        printf("Error: Invalid attribute name after --skip\n");
+        return -1;
+      }
+      ++i;
+    } else if (!strcmp("--metadata", argv[i])) {
+      options.use_metadata = true;
+    }
+  }
+  if (argc < 3 || options.input.empty()) {
+    Usage();
+    return -1;
+  }
+
+  std::unique_ptr<draco::PointCloud> pc;
+  draco::Mesh *mesh = nullptr;
+  if (!options.is_point_cloud) {
+    auto maybe_mesh =
+        draco::ReadMeshFromFile(options.input, options.use_metadata);
+    if (!maybe_mesh.ok()) {
+      printf("Failed loading the input mesh: %s.\n",
+             maybe_mesh.status().error_msg());
+      return -1;
+    }
+    mesh = maybe_mesh.value().get();
+    pc = std::move(maybe_mesh).value();
+  } else {
+    auto maybe_pc = draco::ReadPointCloudFromFile(options.input);
+    if (!maybe_pc.ok()) {
+      printf("Failed loading the input point cloud: %s.\n",
+             maybe_pc.status().error_msg());
+      return -1;
+    }
+    pc = std::move(maybe_pc).value();
+  }
+
+  if (options.pos_quantization_bits < 0) {
+    printf("Error: Position attribute cannot be skipped.\n");
+    return -1;
+  }
+
+  // Delete attributes if needed. This needs to happen before we set any
+  // quantization settings.
+  if (options.tex_coords_quantization_bits < 0) {
+    if (pc->NumNamedAttributes(draco::GeometryAttribute::TEX_COORD) > 0) {
+      options.tex_coords_deleted = true;
+    }
+    while (pc->NumNamedAttributes(draco::GeometryAttribute::TEX_COORD) > 0) {
+      pc->DeleteAttribute(
+          pc->GetNamedAttributeId(draco::GeometryAttribute::TEX_COORD, 0));
+    }
+  }
+  if (options.normals_quantization_bits < 0) {
+    if (pc->NumNamedAttributes(draco::GeometryAttribute::NORMAL) > 0) {
+      options.normals_deleted = true;
+    }
+    while (pc->NumNamedAttributes(draco::GeometryAttribute::NORMAL) > 0) {
+      pc->DeleteAttribute(
+          pc->GetNamedAttributeId(draco::GeometryAttribute::NORMAL, 0));
+    }
+  }
+  if (options.generic_quantization_bits < 0) {
+    if (pc->NumNamedAttributes(draco::GeometryAttribute::GENERIC) > 0) {
+      options.generic_deleted = true;
+    }
+    while (pc->NumNamedAttributes(draco::GeometryAttribute::GENERIC) > 0) {
+      pc->DeleteAttribute(
+          pc->GetNamedAttributeId(draco::GeometryAttribute::GENERIC, 0));
+    }
+  }
+#ifdef DRACO_ATTRIBUTE_INDICES_DEDUPLICATION_SUPPORTED
+  // If any attribute has been deleted, run deduplication of point indices again
+  // as some points can be possibly combined.
+  if (options.tex_coords_deleted || options.normals_deleted ||
+      options.generic_deleted) {
+    pc->DeduplicatePointIds();
+  }
+#endif
+
+  // Convert compression level to speed (that 0 = slowest, 10 = fastest).
+  const int speed = 10 - options.compression_level;
+
+  draco::Encoder encoder;
+
+  // Setup encoder options.
+  if (options.pos_quantization_bits > 0) {
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::POSITION,
+                                     options.pos_quantization_bits);
+  }
+  if (options.tex_coords_quantization_bits > 0) {
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::TEX_COORD,
+                                     options.tex_coords_quantization_bits);
+  }
+  if (options.normals_quantization_bits > 0) {
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::NORMAL,
+                                     options.normals_quantization_bits);
+  }
+  if (options.generic_quantization_bits > 0) {
+    encoder.SetAttributeQuantization(draco::GeometryAttribute::GENERIC,
+                                     options.generic_quantization_bits);
+  }
+  encoder.SetSpeedOptions(speed, speed);
+
+  if (options.output.empty()) {
+    // Create a default output file by attaching .drc to the input file name.
+    options.output = options.input + ".drc";
+  }
+
+  PrintOptions(*pc.get(), options);
+
+  int ret = -1;
+  const bool input_is_mesh = mesh && mesh->num_faces() > 0;
+  if (input_is_mesh)
+    ret = EncodeMeshToFile(*mesh, options.output, &encoder);
+  else
+    ret = EncodePointCloudToFile(*pc.get(), options.output, &encoder);
+
+  if (ret != -1 && options.compression_level < 10) {
+    printf(
+        "For better compression, increase the compression level up to '-cl 10' "
+        ".\n\n");
+  }
+
+  return ret;
+}
diff --git a/contrib/draco/src/draco/tools/fuzz/build.sh b/contrib/draco/src/draco/tools/fuzz/build.sh
new file mode 100644
index 000000000..bbeb10591
--- /dev/null
+++ b/contrib/draco/src/draco/tools/fuzz/build.sh
@@ -0,0 +1,35 @@
+#!/bin/bash -eu
+# Copyright 2020 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+# build project
+cmake $SRC/draco
+# The draco_decoder and draco_encoder binaries don't build nicely with OSS-Fuzz
+# options, so just build the Draco shared libraries.
+make -j$(nproc) draco
+
+# build fuzzers
+for fuzzer in $(find $SRC/draco/src/draco/tools/fuzz -name '*.cc'); do
+  fuzzer_basename=$(basename -s .cc $fuzzer)
+  $CXX $CXXFLAGS \
+    -I $SRC/ \
+    -I $SRC/draco/src \
+    -I $WORK/ \
+    $LIB_FUZZING_ENGINE \
+    $fuzzer \
+    $WORK/libdraco.a \
+    -o $OUT/$fuzzer_basename
+done
diff --git a/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_fuzzer.cc b/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_fuzzer.cc
new file mode 100644
index 000000000..9a508365d
--- /dev/null
+++ b/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_fuzzer.cc
@@ -0,0 +1,29 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <fuzzer/FuzzedDataProvider.h>
+
+#include "draco/src/draco/compression/decode.h"
+#include "draco/src/draco/core/decoder_buffer.h"
+#include "draco/src/draco/mesh/mesh.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  draco::DecoderBuffer buffer;
+  buffer.Init(reinterpret_cast<const char *>(data), size);
+
+  draco::Decoder decoder;
+  decoder.DecodeMeshFromBuffer(&buffer);
+
+  return 0;
+}
diff --git a/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_without_dequantization_fuzzer.cc b/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_without_dequantization_fuzzer.cc
new file mode 100644
index 000000000..4c612ccf6
--- /dev/null
+++ b/contrib/draco/src/draco/tools/fuzz/draco_mesh_decoder_without_dequantization_fuzzer.cc
@@ -0,0 +1,30 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <fuzzer/FuzzedDataProvider.h>
+
+#include "draco/src/draco/compression/decode.h"
+#include "draco/src/draco/core/decoder_buffer.h"
+#include "draco/src/draco/mesh/mesh.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  draco::DecoderBuffer buffer;
+  buffer.Init(reinterpret_cast<const char *>(data), size);
+
+  draco::Decoder decoder;
+  decoder.SetSkipAttributeTransform(draco::GeometryAttribute::POSITION);
+  decoder.DecodeMeshFromBuffer(&buffer);
+
+  return 0;
+}
diff --git a/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_fuzzer.cc b/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_fuzzer.cc
new file mode 100644
index 000000000..3a764f1c9
--- /dev/null
+++ b/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_fuzzer.cc
@@ -0,0 +1,29 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <fuzzer/FuzzedDataProvider.h>
+
+#include "draco/src/draco/compression/decode.h"
+#include "draco/src/draco/core/decoder_buffer.h"
+#include "draco/src/draco/point_cloud/point_cloud.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  draco::DecoderBuffer buffer;
+  buffer.Init(reinterpret_cast<const char *>(data), size);
+
+  draco::Decoder decoder;
+  decoder.DecodePointCloudFromBuffer(&buffer);
+
+  return 0;
+}
diff --git a/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_without_dequantization_fuzzer.cc b/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_without_dequantization_fuzzer.cc
new file mode 100644
index 000000000..1d0c539b4
--- /dev/null
+++ b/contrib/draco/src/draco/tools/fuzz/draco_pc_decoder_without_dequantization_fuzzer.cc
@@ -0,0 +1,30 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <fuzzer/FuzzedDataProvider.h>
+
+#include "draco/src/draco/compression/decode.h"
+#include "draco/src/draco/core/decoder_buffer.h"
+#include "draco/src/draco/point_cloud/point_cloud.h"
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
+  draco::DecoderBuffer buffer;
+  buffer.Init(reinterpret_cast<const char *>(data), size);
+
+  draco::Decoder decoder;
+  decoder.SetSkipAttributeTransform(draco::GeometryAttribute::POSITION);
+  decoder.DecodePointCloudFromBuffer(&buffer);
+
+  return 0;
+}
diff --git a/contrib/draco/src/draco/unity/draco_unity_plugin.cc b/contrib/draco/src/draco/unity/draco_unity_plugin.cc
new file mode 100644
index 000000000..e80279b89
--- /dev/null
+++ b/contrib/draco/src/draco/unity/draco_unity_plugin.cc
@@ -0,0 +1,407 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/unity/draco_unity_plugin.h"
+
+#ifdef DRACO_UNITY_PLUGIN
+
+namespace {
+// Returns a DracoAttribute from a PointAttribute.
+draco::DracoAttribute *CreateDracoAttribute(const draco::PointAttribute *attr) {
+  draco::DracoAttribute *const attribute = new draco::DracoAttribute();
+  attribute->attribute_type =
+      static_cast<draco::GeometryAttribute::Type>(attr->attribute_type());
+  attribute->data_type = static_cast<draco::DataType>(attr->data_type());
+  attribute->num_components = attr->num_components();
+  attribute->unique_id = attr->unique_id();
+  attribute->private_attribute = static_cast<const void *>(attr);
+  return attribute;
+}
+
+// Returns the attribute data in |attr| as an array of type T.
+template <typename T>
+T *CopyAttributeData(int num_points, const draco::PointAttribute *attr) {
+  const int num_components = attr->num_components();
+  T *const data = new T[num_points * num_components];
+
+  for (draco::PointIndex i(0); i < num_points; ++i) {
+    const draco::AttributeValueIndex val_index = attr->mapped_index(i);
+    bool got_data = false;
+    switch (num_components) {
+      case 1:
+        got_data = attr->ConvertValue<T, 1>(val_index,
+                                            data + i.value() * num_components);
+        break;
+      case 2:
+        got_data = attr->ConvertValue<T, 2>(val_index,
+                                            data + i.value() * num_components);
+        break;
+      case 3:
+        got_data = attr->ConvertValue<T, 3>(val_index,
+                                            data + i.value() * num_components);
+        break;
+      case 4:
+        got_data = attr->ConvertValue<T, 4>(val_index,
+                                            data + i.value() * num_components);
+        break;
+      default:
+        break;
+    }
+    if (!got_data) {
+      delete[] data;
+      return nullptr;
+    }
+  }
+
+  return data;
+}
+
+// Returns the attribute data in |attr| as an array of void*.
+void *ConvertAttributeData(int num_points, const draco::PointAttribute *attr) {
+  switch (attr->data_type()) {
+    case draco::DataType::DT_INT8:
+      return static_cast<void *>(CopyAttributeData<int8_t>(num_points, attr));
+    case draco::DataType::DT_UINT8:
+      return static_cast<void *>(CopyAttributeData<uint8_t>(num_points, attr));
+    case draco::DataType::DT_INT16:
+      return static_cast<void *>(CopyAttributeData<int16_t>(num_points, attr));
+    case draco::DataType::DT_UINT16:
+      return static_cast<void *>(CopyAttributeData<uint16_t>(num_points, attr));
+    case draco::DataType::DT_INT32:
+      return static_cast<void *>(CopyAttributeData<int32_t>(num_points, attr));
+    case draco::DataType::DT_UINT32:
+      return static_cast<void *>(CopyAttributeData<uint32_t>(num_points, attr));
+    case draco::DataType::DT_FLOAT32:
+      return static_cast<void *>(CopyAttributeData<float>(num_points, attr));
+    default:
+      return nullptr;
+  }
+}
+}  // namespace
+
+namespace draco {
+
+void EXPORT_API ReleaseDracoMesh(DracoMesh **mesh_ptr) {
+  if (!mesh_ptr) {
+    return;
+  }
+  const DracoMesh *const mesh = *mesh_ptr;
+  if (!mesh) {
+    return;
+  }
+  const Mesh *const m = static_cast<const Mesh *>(mesh->private_mesh);
+  delete m;
+  delete mesh;
+  *mesh_ptr = nullptr;
+}
+
+void EXPORT_API ReleaseDracoAttribute(DracoAttribute **attr_ptr) {
+  if (!attr_ptr) {
+    return;
+  }
+  const DracoAttribute *const attr = *attr_ptr;
+  if (!attr) {
+    return;
+  }
+  delete attr;
+  *attr_ptr = nullptr;
+}
+
+void EXPORT_API ReleaseDracoData(DracoData **data_ptr) {
+  if (!data_ptr) {
+    return;
+  }
+  const DracoData *const data = *data_ptr;
+  switch (data->data_type) {
+    case draco::DataType::DT_INT8:
+      delete[] static_cast<int8_t *>(data->data);
+      break;
+    case draco::DataType::DT_UINT8:
+      delete[] static_cast<uint8_t *>(data->data);
+      break;
+    case draco::DataType::DT_INT16:
+      delete[] static_cast<int16_t *>(data->data);
+      break;
+    case draco::DataType::DT_UINT16:
+      delete[] static_cast<uint16_t *>(data->data);
+      break;
+    case draco::DataType::DT_INT32:
+      delete[] static_cast<int32_t *>(data->data);
+      break;
+    case draco::DataType::DT_UINT32:
+      delete[] static_cast<uint32_t *>(data->data);
+      break;
+    case draco::DataType::DT_FLOAT32:
+      delete[] static_cast<float *>(data->data);
+      break;
+    default:
+      break;
+  }
+  delete data;
+  *data_ptr = nullptr;
+}
+
+int EXPORT_API DecodeDracoMesh(char *data, unsigned int length,
+                               DracoMesh **mesh) {
+  if (mesh == nullptr || *mesh != nullptr) {
+    return -1;
+  }
+  draco::DecoderBuffer buffer;
+  buffer.Init(data, length);
+  auto type_statusor = draco::Decoder::GetEncodedGeometryType(&buffer);
+  if (!type_statusor.ok()) {
+    // TODO(draco-eng): Use enum instead.
+    return -2;
+  }
+  const draco::EncodedGeometryType geom_type = type_statusor.value();
+  if (geom_type != draco::TRIANGULAR_MESH) {
+    return -3;
+  }
+
+  draco::Decoder decoder;
+  auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
+  if (!statusor.ok()) {
+    return -4;
+  }
+  std::unique_ptr<draco::Mesh> in_mesh = std::move(statusor).value();
+
+  *mesh = new DracoMesh();
+  DracoMesh *const unity_mesh = *mesh;
+  unity_mesh->num_faces = in_mesh->num_faces();
+  unity_mesh->num_vertices = in_mesh->num_points();
+  unity_mesh->num_attributes = in_mesh->num_attributes();
+  unity_mesh->private_mesh = static_cast<void *>(in_mesh.release());
+
+  return unity_mesh->num_faces;
+}
+
+bool EXPORT_API GetAttribute(const DracoMesh *mesh, int index,
+                             DracoAttribute **attribute) {
+  if (mesh == nullptr || attribute == nullptr || *attribute != nullptr) {
+    return false;
+  }
+  const Mesh *const m = static_cast<const Mesh *>(mesh->private_mesh);
+  const PointAttribute *const attr = m->attribute(index);
+  if (attr == nullptr) {
+    return false;
+  }
+
+  *attribute = CreateDracoAttribute(attr);
+  return true;
+}
+
+bool EXPORT_API GetAttributeByType(const DracoMesh *mesh,
+                                   GeometryAttribute::Type type, int index,
+                                   DracoAttribute **attribute) {
+  if (mesh == nullptr || attribute == nullptr || *attribute != nullptr) {
+    return false;
+  }
+  const Mesh *const m = static_cast<const Mesh *>(mesh->private_mesh);
+  GeometryAttribute::Type att_type = static_cast<GeometryAttribute::Type>(type);
+  const PointAttribute *const attr = m->GetNamedAttribute(att_type, index);
+  if (attr == nullptr) {
+    return false;
+  }
+  *attribute = CreateDracoAttribute(attr);
+  return true;
+}
+
+bool EXPORT_API GetAttributeByUniqueId(const DracoMesh *mesh, int unique_id,
+                                       DracoAttribute **attribute) {
+  if (mesh == nullptr || attribute == nullptr || *attribute != nullptr) {
+    return false;
+  }
+  const Mesh *const m = static_cast<const Mesh *>(mesh->private_mesh);
+  const PointAttribute *const attr = m->GetAttributeByUniqueId(unique_id);
+  if (attr == nullptr) {
+    return false;
+  }
+  *attribute = CreateDracoAttribute(attr);
+  return true;
+}
+
+bool EXPORT_API GetMeshIndices(const DracoMesh *mesh, DracoData **indices) {
+  if (mesh == nullptr || indices == nullptr || *indices != nullptr) {
+    return false;
+  }
+  const Mesh *const m = static_cast<const Mesh *>(mesh->private_mesh);
+  int *const temp_indices = new int[m->num_faces() * 3];
+  for (draco::FaceIndex face_id(0); face_id < m->num_faces(); ++face_id) {
+    const Mesh::Face &face = m->face(draco::FaceIndex(face_id));
+    memcpy(temp_indices + face_id.value() * 3,
+           reinterpret_cast<const int *>(face.data()), sizeof(int) * 3);
+  }
+  DracoData *const draco_data = new DracoData();
+  draco_data->data = temp_indices;
+  draco_data->data_type = DT_INT32;
+  *indices = draco_data;
+  return true;
+}
+
+bool EXPORT_API GetAttributeData(const DracoMesh *mesh,
+                                 const DracoAttribute *attribute,
+                                 DracoData **data) {
+  if (mesh == nullptr || data == nullptr || *data != nullptr) {
+    return false;
+  }
+  const Mesh *const m = static_cast<const Mesh *>(mesh->private_mesh);
+  const PointAttribute *const attr =
+      static_cast<const PointAttribute *>(attribute->private_attribute);
+
+  void *temp_data = ConvertAttributeData(m->num_points(), attr);
+  if (temp_data == nullptr) {
+    return false;
+  }
+  DracoData *const draco_data = new DracoData();
+  draco_data->data = temp_data;
+  draco_data->data_type = static_cast<DataType>(attr->data_type());
+  *data = draco_data;
+  return true;
+}
+
+void ReleaseUnityMesh(DracoToUnityMesh **mesh_ptr) {
+  DracoToUnityMesh *mesh = *mesh_ptr;
+  if (!mesh) {
+    return;
+  }
+  if (mesh->indices) {
+    delete[] mesh->indices;
+    mesh->indices = nullptr;
+  }
+  if (mesh->position) {
+    delete[] mesh->position;
+    mesh->position = nullptr;
+  }
+  if (mesh->has_normal && mesh->normal) {
+    delete[] mesh->normal;
+    mesh->has_normal = false;
+    mesh->normal = nullptr;
+  }
+  if (mesh->has_texcoord && mesh->texcoord) {
+    delete[] mesh->texcoord;
+    mesh->has_texcoord = false;
+    mesh->texcoord = nullptr;
+  }
+  if (mesh->has_color && mesh->color) {
+    delete[] mesh->color;
+    mesh->has_color = false;
+    mesh->color = nullptr;
+  }
+  delete mesh;
+  *mesh_ptr = nullptr;
+}
+
+int DecodeMeshForUnity(char *data, unsigned int length,
+                       DracoToUnityMesh **tmp_mesh) {
+  draco::DecoderBuffer buffer;
+  buffer.Init(data, length);
+  auto type_statusor = draco::Decoder::GetEncodedGeometryType(&buffer);
+  if (!type_statusor.ok()) {
+    // TODO(draco-eng): Use enum instead.
+    return -1;
+  }
+  const draco::EncodedGeometryType geom_type = type_statusor.value();
+  if (geom_type != draco::TRIANGULAR_MESH) {
+    return -2;
+  }
+
+  draco::Decoder decoder;
+  auto statusor = decoder.DecodeMeshFromBuffer(&buffer);
+  if (!statusor.ok()) {
+    return -3;
+  }
+  std::unique_ptr<draco::Mesh> in_mesh = std::move(statusor).value();
+
+  *tmp_mesh = new DracoToUnityMesh();
+  DracoToUnityMesh *unity_mesh = *tmp_mesh;
+  unity_mesh->num_faces = in_mesh->num_faces();
+  unity_mesh->num_vertices = in_mesh->num_points();
+
+  unity_mesh->indices = new int[in_mesh->num_faces() * 3];
+  for (draco::FaceIndex face_id(0); face_id < in_mesh->num_faces(); ++face_id) {
+    const Mesh::Face &face = in_mesh->face(draco::FaceIndex(face_id));
+    memcpy(unity_mesh->indices + face_id.value() * 3,
+           reinterpret_cast<const int *>(face.data()), sizeof(int) * 3);
+  }
+
+  // TODO(draco-eng): Add other attributes.
+  unity_mesh->position = new float[in_mesh->num_points() * 3];
+  const auto pos_att =
+      in_mesh->GetNamedAttribute(draco::GeometryAttribute::POSITION);
+  for (draco::PointIndex i(0); i < in_mesh->num_points(); ++i) {
+    const draco::AttributeValueIndex val_index = pos_att->mapped_index(i);
+    if (!pos_att->ConvertValue<float, 3>(
+            val_index, unity_mesh->position + i.value() * 3)) {
+      ReleaseUnityMesh(&unity_mesh);
+      return -8;
+    }
+  }
+  // Get normal attributes.
+  const auto normal_att =
+      in_mesh->GetNamedAttribute(draco::GeometryAttribute::NORMAL);
+  if (normal_att != nullptr) {
+    unity_mesh->normal = new float[in_mesh->num_points() * 3];
+    unity_mesh->has_normal = true;
+    for (draco::PointIndex i(0); i < in_mesh->num_points(); ++i) {
+      const draco::AttributeValueIndex val_index = normal_att->mapped_index(i);
+      if (!normal_att->ConvertValue<float, 3>(
+              val_index, unity_mesh->normal + i.value() * 3)) {
+        ReleaseUnityMesh(&unity_mesh);
+        return -8;
+      }
+    }
+  }
+  // Get color attributes.
+  const auto color_att =
+      in_mesh->GetNamedAttribute(draco::GeometryAttribute::COLOR);
+  if (color_att != nullptr) {
+    unity_mesh->color = new float[in_mesh->num_points() * 4];
+    unity_mesh->has_color = true;
+    for (draco::PointIndex i(0); i < in_mesh->num_points(); ++i) {
+      const draco::AttributeValueIndex val_index = color_att->mapped_index(i);
+      if (!color_att->ConvertValue<float, 4>(
+              val_index, unity_mesh->color + i.value() * 4)) {
+        ReleaseUnityMesh(&unity_mesh);
+        return -8;
+      }
+      if (color_att->num_components() < 4) {
+        // If the alpha component wasn't set in the input data we should set
+        // it to an opaque value.
+        unity_mesh->color[i.value() * 4 + 3] = 1.f;
+      }
+    }
+  }
+  // Get texture coordinates attributes.
+  const auto texcoord_att =
+      in_mesh->GetNamedAttribute(draco::GeometryAttribute::TEX_COORD);
+  if (texcoord_att != nullptr) {
+    unity_mesh->texcoord = new float[in_mesh->num_points() * 2];
+    unity_mesh->has_texcoord = true;
+    for (draco::PointIndex i(0); i < in_mesh->num_points(); ++i) {
+      const draco::AttributeValueIndex val_index =
+          texcoord_att->mapped_index(i);
+      if (!texcoord_att->ConvertValue<float, 2>(
+              val_index, unity_mesh->texcoord + i.value() * 2)) {
+        ReleaseUnityMesh(&unity_mesh);
+        return -8;
+      }
+    }
+  }
+
+  return in_mesh->num_faces();
+}
+
+}  // namespace draco
+
+#endif  // DRACO_UNITY_PLUGIN
diff --git a/contrib/draco/src/draco/unity/draco_unity_plugin.h b/contrib/draco/src/draco/unity/draco_unity_plugin.h
new file mode 100644
index 000000000..2f878889b
--- /dev/null
+++ b/contrib/draco/src/draco/unity/draco_unity_plugin.h
@@ -0,0 +1,154 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef DRACO_UNITY_DRACO_UNITY_PLUGIN_H_
+#define DRACO_UNITY_DRACO_UNITY_PLUGIN_H_
+
+#include "draco/attributes/geometry_attribute.h"
+#include "draco/compression/config/compression_shared.h"
+#include "draco/compression/decode.h"
+#include "draco/core/draco_types.h"
+
+#ifdef DRACO_UNITY_PLUGIN
+
+// If compiling with Visual Studio.
+#if defined(_MSC_VER)
+#define EXPORT_API __declspec(dllexport)
+#else
+// Other platforms don't need this.
+#define EXPORT_API
+#endif  // defined(_MSC_VER)
+
+namespace draco {
+
+extern "C" {
+
+// Struct representing Draco attribute data within Unity.
+struct EXPORT_API DracoData {
+  DracoData() : data_type(DT_INVALID), data(nullptr) {}
+
+  DataType data_type;
+  void *data;
+};
+
+// Struct representing a Draco attribute within Unity.
+struct EXPORT_API DracoAttribute {
+  DracoAttribute()
+      : attribute_type(GeometryAttribute::INVALID),
+        data_type(DT_INVALID),
+        num_components(0),
+        unique_id(0),
+        private_attribute(nullptr) {}
+
+  GeometryAttribute::Type attribute_type;
+  DataType data_type;
+  int num_components;
+  int unique_id;
+  const void *private_attribute;
+};
+
+// Struct representing a Draco mesh within Unity.
+struct EXPORT_API DracoMesh {
+  DracoMesh()
+      : num_faces(0),
+        num_vertices(0),
+        num_attributes(0),
+        private_mesh(nullptr) {}
+
+  int num_faces;
+  int num_vertices;
+  int num_attributes;
+  void *private_mesh;
+};
+
+// Release data associated with DracoMesh.
+void EXPORT_API ReleaseDracoMesh(DracoMesh **mesh_ptr);
+// Release data associated with DracoAttribute.
+void EXPORT_API ReleaseDracoAttribute(DracoAttribute **attr_ptr);
+// Release attribute data.
+void EXPORT_API ReleaseDracoData(DracoData **data_ptr);
+
+// Decodes compressed Draco mesh in |data| and returns |mesh|. On input, |mesh|
+// must be null. The returned |mesh| must be released with ReleaseDracoMesh.
+int EXPORT_API DecodeDracoMesh(char *data, unsigned int length,
+                               DracoMesh **mesh);
+
+// Returns |attribute| at |index| in |mesh|.  On input, |attribute| must be
+// null. The returned |attribute| must be released with ReleaseDracoAttribute.
+bool EXPORT_API GetAttribute(const DracoMesh *mesh, int index,
+                             DracoAttribute **attribute);
+// Returns |attribute| of |type| at |index| in |mesh|. E.g. If the mesh has
+// two texture coordinates then GetAttributeByType(mesh,
+// AttributeType.TEX_COORD, 1, &attr); will return the second TEX_COORD
+// attribute. On input, |attribute| must be null. The returned |attribute| must
+// be released with ReleaseDracoAttribute.
+bool EXPORT_API GetAttributeByType(const DracoMesh *mesh,
+                                   GeometryAttribute::Type type, int index,
+                                   DracoAttribute **attribute);
+// Returns |attribute| with |unique_id| in |mesh|. On input, |attribute| must be
+// null. The returned |attribute| must be released with ReleaseDracoAttribute.
+bool EXPORT_API GetAttributeByUniqueId(const DracoMesh *mesh, int unique_id,
+                                       DracoAttribute **attribute);
+// Returns the indices as well as the type of data in |indices|. On input,
+// |indices| must be null. The returned |indices| must be released with
+// ReleaseDracoData.
+bool EXPORT_API GetMeshIndices(const DracoMesh *mesh, DracoData **indices);
+// Returns the attribute data from attribute as well as the type of data in
+// |data|. On input, |data| must be null. The returned |data| must be released
+// with ReleaseDracoData.
+bool EXPORT_API GetAttributeData(const DracoMesh *mesh,
+                                 const DracoAttribute *attribute,
+                                 DracoData **data);
+
+// DracoToUnityMesh is deprecated.
+struct EXPORT_API DracoToUnityMesh {
+  DracoToUnityMesh()
+      : num_faces(0),
+        indices(nullptr),
+        num_vertices(0),
+        position(nullptr),
+        has_normal(false),
+        normal(nullptr),
+        has_texcoord(false),
+        texcoord(nullptr),
+        has_color(false),
+        color(nullptr) {}
+
+  int num_faces;
+  int *indices;
+  int num_vertices;
+  float *position;
+  bool has_normal;
+  float *normal;
+  bool has_texcoord;
+  float *texcoord;
+  bool has_color;
+  float *color;
+};
+
+// ReleaseUnityMesh is deprecated.
+void EXPORT_API ReleaseUnityMesh(DracoToUnityMesh **mesh_ptr);
+
+// To use this function, you do not allocate memory for |tmp_mesh|, just
+// define and pass a null pointer. Otherwise there will be memory leak.
+// DecodeMeshForUnity is deprecated.
+int EXPORT_API DecodeMeshForUnity(char *data, unsigned int length,
+                                  DracoToUnityMesh **tmp_mesh);
+}  // extern "C"
+
+}  // namespace draco
+
+#endif  // DRACO_UNITY_PLUGIN
+
+#endif  // DRACO_UNITY_DRACO_UNITY_PLUGIN_H_
diff --git a/contrib/draco/src/draco/unity/draco_unity_plugin_test.cc b/contrib/draco/src/draco/unity/draco_unity_plugin_test.cc
new file mode 100644
index 000000000..81be7ee57
--- /dev/null
+++ b/contrib/draco/src/draco/unity/draco_unity_plugin_test.cc
@@ -0,0 +1,243 @@
+// Copyright 2017 The Draco Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#include "draco/unity/draco_unity_plugin.h"
+
+#include <fstream>
+#include <memory>
+#include <sstream>
+#include <string>
+
+#include "draco/core/draco_test_base.h"
+#include "draco/core/draco_test_utils.h"
+
+namespace {
+
+draco::DracoMesh *DecodeToDracoMesh(const std::string &file_name) {
+  std::ifstream input_file(draco::GetTestFileFullPath(file_name),
+                           std::ios::binary);
+  if (!input_file) {
+    return nullptr;
+  }
+  // Read the file stream into a buffer.
+  std::streampos file_size = 0;
+  input_file.seekg(0, std::ios::end);
+  file_size = input_file.tellg() - file_size;
+  input_file.seekg(0, std::ios::beg);
+  std::vector<char> data(file_size);
+  input_file.read(data.data(), file_size);
+  if (data.empty()) {
+    return nullptr;
+  }
+
+  draco::DracoMesh *draco_mesh = nullptr;
+  draco::DecodeDracoMesh(data.data(), data.size(), &draco_mesh);
+  return draco_mesh;
+}
+
+TEST(DracoUnityPluginTest, TestDecode) {
+  draco::DracoMesh *draco_mesh =
+      DecodeToDracoMesh("test_nm.obj.edgebreaker.cl4.2.2.drc");
+  ASSERT_NE(draco_mesh, nullptr);
+  ASSERT_EQ(draco_mesh->num_faces, 170);
+  ASSERT_EQ(draco_mesh->num_vertices, 99);
+  ASSERT_NE(draco_mesh->private_mesh, nullptr);
+
+  draco::DracoData *indices = nullptr;
+  ASSERT_TRUE(GetMeshIndices(draco_mesh, &indices));
+  ASSERT_EQ(indices->data_type, draco::DT_INT32);
+  draco::ReleaseDracoData(&indices);
+
+  for (int i = 0; i < draco_mesh->num_attributes; ++i) {
+    draco::DracoAttribute *draco_attribute = nullptr;
+    ASSERT_TRUE(draco::GetAttribute(draco_mesh, i, &draco_attribute));
+    ASSERT_NE(draco_attribute->data_type, draco::DT_INVALID);
+    ASSERT_GT(draco_attribute->num_components, 0);
+    ASSERT_NE(draco_attribute->private_attribute, nullptr);
+
+    draco::DracoData *attribute_data = nullptr;
+    ASSERT_TRUE(
+        draco::GetAttributeData(draco_mesh, draco_attribute, &attribute_data));
+    draco::ReleaseDracoData(&attribute_data);
+    draco::ReleaseDracoAttribute(&draco_attribute);
+  }
+  draco::ReleaseDracoMesh(&draco_mesh);
+}
+
+TEST(DracoUnityPluginTest, TestAttributeTypes) {
+  draco::DracoMesh *draco_mesh = DecodeToDracoMesh("color_attr.drc");
+  ASSERT_NE(draco_mesh, nullptr);
+
+  draco::DracoAttribute *pos_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::POSITION, 0, &pos_attribute));
+  ASSERT_EQ(pos_attribute->attribute_type, draco::GeometryAttribute::POSITION);
+  ASSERT_EQ(pos_attribute->data_type, draco::DT_FLOAT32);
+  ASSERT_EQ(pos_attribute->num_components, 3);
+  ASSERT_EQ(pos_attribute->unique_id, 0);
+  ASSERT_NE(pos_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&pos_attribute);
+
+  draco::DracoAttribute *color_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::COLOR, 0, &color_attribute));
+  ASSERT_EQ(color_attribute->attribute_type, draco::GeometryAttribute::COLOR);
+  ASSERT_EQ(color_attribute->data_type, draco::DT_UINT8);
+  ASSERT_EQ(color_attribute->num_components, 4);
+  ASSERT_EQ(color_attribute->unique_id, 1);
+  ASSERT_NE(color_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&color_attribute);
+
+  draco::DracoAttribute *bad_attribute = nullptr;
+  ASSERT_FALSE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::NORMAL, 0, &bad_attribute));
+  ASSERT_FALSE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::TEX_COORD, 0, &bad_attribute));
+  ASSERT_FALSE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::GENERIC, 0, &bad_attribute));
+
+  draco::ReleaseDracoMesh(&draco_mesh);
+
+  draco_mesh = DecodeToDracoMesh("cube_att_sub_o_2.drc");
+  ASSERT_NE(draco_mesh, nullptr);
+
+  draco::DracoAttribute *norm_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::NORMAL, 0, &norm_attribute));
+  ASSERT_EQ(norm_attribute->attribute_type, draco::GeometryAttribute::NORMAL);
+  ASSERT_EQ(norm_attribute->data_type, draco::DT_FLOAT32);
+  ASSERT_EQ(norm_attribute->num_components, 3);
+  ASSERT_EQ(norm_attribute->unique_id, 2);
+  ASSERT_NE(norm_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&norm_attribute);
+
+  draco::DracoAttribute *texcoord_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::TEX_COORD, 0, &texcoord_attribute));
+  ASSERT_EQ(texcoord_attribute->attribute_type,
+            draco::GeometryAttribute::TEX_COORD);
+  ASSERT_EQ(texcoord_attribute->data_type, draco::DT_FLOAT32);
+  ASSERT_EQ(texcoord_attribute->num_components, 2);
+  ASSERT_EQ(texcoord_attribute->unique_id, 1);
+  ASSERT_NE(texcoord_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&texcoord_attribute);
+
+  draco::DracoAttribute *generic_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::GENERIC, 0, &generic_attribute));
+  ASSERT_EQ(generic_attribute->attribute_type,
+            draco::GeometryAttribute::GENERIC);
+  ASSERT_EQ(generic_attribute->data_type, draco::DT_UINT8);
+  ASSERT_EQ(generic_attribute->num_components, 1);
+  ASSERT_EQ(generic_attribute->unique_id, 3);
+  ASSERT_NE(generic_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&generic_attribute);
+
+  ASSERT_FALSE(draco::GetAttributeByType(
+      draco_mesh, draco::GeometryAttribute::TEX_COORD, 1, &bad_attribute));
+
+  draco::ReleaseDracoMesh(&draco_mesh);
+}
+
+TEST(DracoUnityPluginTest, TestAttributeUniqueId) {
+  draco::DracoMesh *draco_mesh = DecodeToDracoMesh("cube_att_sub_o_2.drc");
+  ASSERT_NE(draco_mesh, nullptr);
+
+  draco::DracoAttribute *pos_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByUniqueId(draco_mesh, 0, &pos_attribute));
+  ASSERT_EQ(pos_attribute->attribute_type, draco::GeometryAttribute::POSITION);
+  ASSERT_EQ(pos_attribute->data_type, draco::DT_FLOAT32);
+  ASSERT_EQ(pos_attribute->num_components, 3);
+  ASSERT_EQ(pos_attribute->unique_id, 0);
+  ASSERT_NE(pos_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&pos_attribute);
+
+  draco::DracoAttribute *norm_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByUniqueId(draco_mesh, 2, &norm_attribute));
+  ASSERT_EQ(norm_attribute->attribute_type, draco::GeometryAttribute::NORMAL);
+  ASSERT_EQ(norm_attribute->data_type, draco::DT_FLOAT32);
+  ASSERT_EQ(norm_attribute->num_components, 3);
+  ASSERT_EQ(norm_attribute->unique_id, 2);
+  ASSERT_NE(norm_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&norm_attribute);
+
+  draco::DracoAttribute *texcoord_attribute = nullptr;
+  ASSERT_TRUE(
+      draco::GetAttributeByUniqueId(draco_mesh, 1, &texcoord_attribute));
+  ASSERT_EQ(texcoord_attribute->attribute_type,
+            draco::GeometryAttribute::TEX_COORD);
+  ASSERT_EQ(texcoord_attribute->data_type, draco::DT_FLOAT32);
+  ASSERT_EQ(texcoord_attribute->num_components, 2);
+  ASSERT_EQ(texcoord_attribute->unique_id, 1);
+  ASSERT_NE(texcoord_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&texcoord_attribute);
+
+  draco::DracoAttribute *generic_attribute = nullptr;
+  ASSERT_TRUE(draco::GetAttributeByUniqueId(draco_mesh, 3, &generic_attribute));
+  ASSERT_EQ(generic_attribute->attribute_type,
+            draco::GeometryAttribute::GENERIC);
+  ASSERT_EQ(generic_attribute->data_type, draco::DT_UINT8);
+  ASSERT_EQ(generic_attribute->num_components, 1);
+  ASSERT_EQ(generic_attribute->unique_id, 3);
+  ASSERT_NE(generic_attribute->private_attribute, nullptr);
+  draco::ReleaseDracoAttribute(&generic_attribute);
+
+  draco::DracoAttribute *bad_attribute = nullptr;
+  ASSERT_FALSE(draco::GetAttributeByUniqueId(draco_mesh, 4, &bad_attribute));
+
+  draco::ReleaseDracoMesh(&draco_mesh);
+}
+
+class DeprecatedDracoUnityPluginTest : public ::testing::Test {
+ protected:
+  DeprecatedDracoUnityPluginTest() : unity_mesh_(nullptr) {}
+
+  void TestDecodingToDracoUnityMesh(const std::string &file_name,
+                                    int expected_num_faces,
+                                    int expected_num_vertices) {
+    // Tests that decoders can successfully skip attribute transform.
+    std::ifstream input_file(draco::GetTestFileFullPath(file_name),
+                             std::ios::binary);
+    ASSERT_TRUE(input_file);
+
+    // Read the file stream into a buffer.
+    std::streampos file_size = 0;
+    input_file.seekg(0, std::ios::end);
+    file_size = input_file.tellg() - file_size;
+    input_file.seekg(0, std::ios::beg);
+    std::vector<char> data(file_size);
+    input_file.read(data.data(), file_size);
+
+    ASSERT_FALSE(data.empty());
+
+    const int num_faces =
+        draco::DecodeMeshForUnity(data.data(), data.size(), &unity_mesh_);
+
+    ASSERT_EQ(num_faces, expected_num_faces);
+    ASSERT_EQ(unity_mesh_->num_faces, expected_num_faces);
+    ASSERT_EQ(unity_mesh_->num_vertices, expected_num_vertices);
+    ASSERT_TRUE(unity_mesh_->has_normal);
+    ASSERT_NE(unity_mesh_->normal, nullptr);
+    // TODO(fgalligan): Also test color and tex_coord attributes.
+
+    draco::ReleaseUnityMesh(&unity_mesh_);
+  }
+
+  draco::DracoToUnityMesh *unity_mesh_;
+};
+
+TEST_F(DeprecatedDracoUnityPluginTest, DeprecatedDecodingToDracoUnityMesh) {
+  TestDecodingToDracoUnityMesh("test_nm.obj.edgebreaker.1.0.0.drc", 170, 99);
+}
+}  // namespace

From 3a7d0f5656da4d802d0cde9e59da910b791dc125 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Fri, 22 Jan 2021 16:31:59 +0000
Subject: [PATCH 03/30] Add Draco to cmakelists

Initial pass. Not yet used.
Add Draco library to assimp build and link
---
 CMakeLists.txt      | 48 +++++++++++++++++++++++++++++++++++++++++++++
 code/CMakeLists.txt | 11 ++++++++++-
 test/CMakeLists.txt |  4 ++++
 3 files changed, 62 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4b553ef9e..e2e6ddb12 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -570,6 +570,54 @@ ELSE ()
   ADD_DEFINITIONS( -DASSIMP_BUILD_NO_C4D_IMPORTER )
 ENDIF ()
 
+OPTION ( ASSIMP_BUILD_DRACO "If the Draco libraries are to be built. Primarily for glTF" ON )
+IF ( ASSIMP_BUILD_DRACO )
+  # Primarily for glTF v2
+  # Enable Draco glTF feature set
+  set(DRACO_GLTF ON CACHE BOOL "" FORCE)
+  # Disable unnecessary or omitted components
+  set(DRACO_JS_GLUE OFF CACHE BOOL "" FORCE)
+  set(DRACO_WASM OFF CACHE BOOL "" FORCE)
+  set(DRACO_MAYA_PLUGIN OFF CACHE BOOL "" FORCE)
+  set(DRACO_UNITY_PLUGIN OFF CACHE BOOL "" FORCE)
+  set(DRACO_TESTS OFF CACHE BOOL "" FORCE)
+  
+  IF(ASSIMP_HUNTER_ENABLED)
+    # hunter is untested
+    hunter_add_package(draco)
+    find_package(draco CONFIG REQUIRED)
+  ELSE()
+    # Draco 1.4.1 has several nasty warnings and will not build with /WX
+    IF(MSVC)
+      set(DRACO_CXX_FLAGS "/W0")
+    ENDIF()
+    ADD_SUBDIRECTORY( "contrib/draco" )
+    
+    # Don't build the draco command-line tools by default
+    set_target_properties(draco_encoder draco_decoder PROPERTIES EXCLUDE_FROM_ALL TRUE)
+    set_target_properties(draco_encoder draco_decoder PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD TRUE)
+    
+    TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco)
+    TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_encoder)
+    TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_decoder)
+    
+    set(draco_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/contrib/draco/src")
+    
+    # This is probably wrong
+    INSTALL( TARGETS draco
+      EXPORT "${TARGETS_EXPORT_NAME}"
+      LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
+      ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
+      RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR}
+      FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
+      COMPONENT ${LIBASSIMP_COMPONENT}
+      INCLUDES DESTINATION include
+  )
+
+  ENDIF()
+ENDIF()
+
+# Main assimp code
 ADD_SUBDIRECTORY( code/ )
 IF ( ASSIMP_BUILD_ASSIMP_TOOLS )
   # The viewer for windows only
diff --git a/code/CMakeLists.txt b/code/CMakeLists.txt
index bbcad86e5..b728cda46 100644
--- a/code/CMakeLists.txt
+++ b/code/CMakeLists.txt
@@ -1117,6 +1117,11 @@ IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
   INCLUDE_DIRECTORIES(${C4D_INCLUDES})
 ENDIF ()
 
+IF (ASSIMP_BUILD_DRACO)
+  INCLUDE_DIRECTORIES(${draco_INCLUDE_DIRS})
+  ADD_DEFINITIONS( -DASSIMP_ENABLE_DRACO )
+ENDIF()
+
 ADD_LIBRARY( assimp ${assimp_src} )
 ADD_LIBRARY(assimp::assimp ALIAS assimp)
 
@@ -1149,7 +1154,7 @@ IF(ASSIMP_HUNTER_ENABLED)
       pugixml
   )
 ELSE()
-  TARGET_LINK_LIBRARIES(assimp ${ZLIB_LIBRARIES} ${OPENDDL_PARSER_LIBRARIES} )
+  TARGET_LINK_LIBRARIES(assimp ${ZLIB_LIBRARIES} ${OPENDDL_PARSER_LIBRARIES})
 ENDIF()
 
 if(ASSIMP_ANDROID_JNIIOSYSTEM)
@@ -1164,6 +1169,10 @@ IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
   TARGET_LINK_LIBRARIES(assimp ${C4D_EXTRA_LIBRARIES})
 ENDIF ()
 
+IF (ASSIMP_BUILD_DRACO)
+  target_link_libraries(assimp draco)
+ENDIF()
+
 if( MSVC )
   # in order to prevent DLL hell, each of the DLLs have to be suffixed with the major version and msvc prefix
   # CMake 3.12 added a variable for this
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 9005a5ec4..6d41ee543 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -223,6 +223,10 @@ else()
     target_sources(unit PUBLIC ${Assimp_SOURCE_DIR}/contrib/gtest/src/gtest-all.cc)
 endif()
 
+IF (ASSIMP_BUILD_DRACO)
+  ADD_DEFINITIONS( -DASSIMP_ENABLE_DRACO )
+ENDIF()
+
 TARGET_USE_COMMON_OUTPUT_DIRECTORY(unit)
 
 add_definitions(-DASSIMP_TEST_MODELS_DIR="${CMAKE_CURRENT_LIST_DIR}/models")

From dde7605158d6f375ae8ea7ab726eb15bd789549d Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Tue, 26 Jan 2021 15:56:49 +0000
Subject: [PATCH 04/30] Implement draco decoding

---
 code/AssetLib/glTF2/glTF2Asset.h   | 167 +++++++++++-----------
 code/AssetLib/glTF2/glTF2Asset.inl | 217 ++++++++++++++++++++++++++---
 test/unit/utglTF2ImportExport.cpp  |  32 +++++
 3 files changed, 319 insertions(+), 97 deletions(-)

diff --git a/code/AssetLib/glTF2/glTF2Asset.h b/code/AssetLib/glTF2/glTF2Asset.h
index 94cbef2cd..7e252ab6b 100644
--- a/code/AssetLib/glTF2/glTF2Asset.h
+++ b/code/AssetLib/glTF2/glTF2Asset.h
@@ -376,87 +376,6 @@ struct Object {
 // Classes for each glTF top-level object type
 //
 
-//! A typed view into a BufferView. A BufferView contains raw binary data.
-//! An accessor provides a typed view into a BufferView or a subset of a BufferView
-//! similar to how WebGL's vertexAttribPointer() defines an attribute in a buffer.
-struct Accessor : public Object {
-    struct Sparse;
-
-    Ref<BufferView> bufferView; //!< The ID of the bufferView. (required)
-    size_t byteOffset; //!< The offset relative to the start of the bufferView in bytes. (required)
-    ComponentType componentType; //!< The datatype of components in the attribute. (required)
-    size_t count; //!< The number of attributes referenced by this accessor. (required)
-    AttribType::Value type; //!< Specifies if the attribute is a scalar, vector, or matrix. (required)
-    std::vector<double> max; //!< Maximum value of each component in this attribute.
-    std::vector<double> min; //!< Minimum value of each component in this attribute.
-    std::unique_ptr<Sparse> sparse;
-
-    unsigned int GetNumComponents();
-    unsigned int GetBytesPerComponent();
-    unsigned int GetElementSize();
-
-    inline uint8_t *GetPointer();
-
-    template <class T>
-    void ExtractData(T *&outData);
-
-    void WriteData(size_t count, const void *src_buffer, size_t src_stride);
-    void WriteSparseValues(size_t count, const void *src_data, size_t src_dataStride);
-    void WriteSparseIndices(size_t count, const void *src_idx, size_t src_idxStride);
-
-    //! Helper class to iterate the data
-    class Indexer {
-        friend struct Accessor;
-
-        // This field is reported as not used, making it protectd is the easiest way to work around it without going to the bottom of what the problem is:
-        // ../code/glTF2/glTF2Asset.h:392:19: error: private field 'accessor' is not used [-Werror,-Wunused-private-field]
-    protected:
-        Accessor &accessor;
-
-    private:
-        uint8_t *data;
-        size_t elemSize, stride;
-
-        Indexer(Accessor &acc);
-
-    public:
-        //! Accesses the i-th value as defined by the accessor
-        template <class T>
-        T GetValue(int i);
-
-        //! Accesses the i-th value as defined by the accessor
-        inline unsigned int GetUInt(int i) {
-            return GetValue<unsigned int>(i);
-        }
-
-        inline bool IsValid() const {
-            return data != 0;
-        }
-    };
-
-    inline Indexer GetIndexer() {
-        return Indexer(*this);
-    }
-
-    Accessor() {}
-    void Read(Value &obj, Asset &r);
-
-    //sparse
-    struct Sparse {
-        size_t count;
-        ComponentType indicesType;
-        Ref<BufferView> indices;
-        size_t indicesByteOffset;
-        Ref<BufferView> values;
-        size_t valuesByteOffset;
-
-        std::vector<uint8_t> data; //!< Actual data, which may be defaulted to an array of zeros or the original data, with the sparse buffer view applied on top of it.
-
-        void PopulateData(size_t numBytes, uint8_t *bytes);
-        void PatchData(unsigned int elementSize);
-    };
-};
-
 //! A buffer points to binary geometry, animation, or skins.
 struct Buffer : public Object {
     /********************* Types *********************/
@@ -594,6 +513,91 @@ struct BufferView : public Object {
     uint8_t *GetPointer(size_t accOffset);
 };
 
+
+//! A typed view into a BufferView. A BufferView contains raw binary data.
+//! An accessor provides a typed view into a BufferView or a subset of a BufferView
+//! similar to how WebGL's vertexAttribPointer() defines an attribute in a buffer.
+struct Accessor : public Object {
+    struct Sparse;
+
+    Ref<BufferView> bufferView; //!< The ID of the bufferView. (required)
+    size_t byteOffset; //!< The offset relative to the start of the bufferView in bytes. (required)
+    ComponentType componentType; //!< The datatype of components in the attribute. (required)
+    size_t count; //!< The number of attributes referenced by this accessor. (required)
+    AttribType::Value type; //!< Specifies if the attribute is a scalar, vector, or matrix. (required)
+    std::vector<double> max; //!< Maximum value of each component in this attribute.
+    std::vector<double> min; //!< Minimum value of each component in this attribute.
+    std::unique_ptr<Sparse> sparse;
+    std::unique_ptr<Buffer> decodedBuffer; // Packed decoded data, returned instead of original bufferView if present
+
+    unsigned int GetNumComponents();
+    unsigned int GetBytesPerComponent();
+    unsigned int GetElementSize();
+
+    inline uint8_t *GetPointer();
+    inline size_t GetStride();
+    inline size_t GetMaxByteSize();
+
+    template <class T>
+    void ExtractData(T *&outData);
+
+    void WriteData(size_t count, const void *src_buffer, size_t src_stride);
+    void WriteSparseValues(size_t count, const void *src_data, size_t src_dataStride);
+    void WriteSparseIndices(size_t count, const void *src_idx, size_t src_idxStride);
+
+    //! Helper class to iterate the data
+    class Indexer {
+        friend struct Accessor;
+
+        // This field is reported as not used, making it protectd is the easiest way to work around it without going to the bottom of what the problem is:
+        // ../code/glTF2/glTF2Asset.h:392:19: error: private field 'accessor' is not used [-Werror,-Wunused-private-field]
+    protected:
+        Accessor &accessor;
+
+    private:
+        uint8_t *data;
+        size_t elemSize, stride;
+
+        Indexer(Accessor &acc);
+
+    public:
+        //! Accesses the i-th value as defined by the accessor
+        template <class T>
+        T GetValue(int i);
+
+        //! Accesses the i-th value as defined by the accessor
+        inline unsigned int GetUInt(int i) {
+            return GetValue<unsigned int>(i);
+        }
+
+        inline bool IsValid() const {
+            return data != 0;
+        }
+    };
+
+    inline Indexer GetIndexer() {
+        return Indexer(*this);
+    }
+
+    Accessor() {}
+    void Read(Value &obj, Asset &r);
+
+    //sparse
+    struct Sparse {
+        size_t count;
+        ComponentType indicesType;
+        Ref<BufferView> indices;
+        size_t indicesByteOffset;
+        Ref<BufferView> values;
+        size_t valuesByteOffset;
+
+        std::vector<uint8_t> data; //!< Actual data, which may be defaulted to an array of zeros or the original data, with the sparse buffer view applied on top of it.
+
+        void PopulateData(size_t numBytes, uint8_t *bytes);
+        void PatchData(unsigned int elementSize);
+    };
+};
+
 struct Camera : public Object {
     enum Type {
         Perspective,
@@ -1092,6 +1096,7 @@ public:
         bool KHR_materials_sheen;
         bool KHR_materials_clearcoat;
         bool KHR_materials_transmission;
+        bool KHR_draco_mesh_compression;
     } extensionsUsed;
 
     //! Keeps info about the required extensions
diff --git a/code/AssetLib/glTF2/glTF2Asset.inl b/code/AssetLib/glTF2/glTF2Asset.inl
index 0e265efef..53b49afe6 100644
--- a/code/AssetLib/glTF2/glTF2Asset.inl
+++ b/code/AssetLib/glTF2/glTF2Asset.inl
@@ -46,6 +46,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/MemoryIOWrapper.h>
 
+#ifdef ASSIMP_ENABLE_DRACO
+#include "draco/compression/decode.h"
+#include "draco/core/decoder_buffer.h"
+#endif
+
 using namespace Assimp;
 
 namespace glTF2 {
@@ -175,6 +180,102 @@ inline Value *FindObject(Value &val, const char *id) {
 }
 } // namespace
 
+#ifdef ASSIMP_ENABLE_DRACO
+// Google draco library headers spew many warnings. Bad Google, no cookie
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable: 4018)  // Signed/unsigned mismatch
+#pragma warning(disable: 4804)  // Unsafe use of type 'bool'
+#endif
+
+template <typename T>
+inline void CopyFaceIndex_Draco(Buffer &decodedIndexBuffer, const draco::Mesh &draco_mesh) {
+    const size_t faceStride = sizeof(T) * 3;
+    for (draco::FaceIndex f(0); f < draco_mesh.num_faces(); ++f) {
+        const draco::Mesh::Face &face = draco_mesh.face(f);
+        T indices[3] = { static_cast<T>(face[0].value()), static_cast<T>(face[1].value()), static_cast<T>(face[2].value()) };
+        memcpy(decodedIndexBuffer.GetPointer() + (f.value() * faceStride), &indices[0], faceStride);
+    }
+}
+
+inline void SetDecodedIndexBuffer_Draco(const draco::Mesh &dracoMesh, Mesh::Primitive &prim) {
+    if (!prim.indices || dracoMesh.num_faces() == 0)
+        return;
+
+    // Create a decoded Index buffer (if there is one)
+    size_t componentBytes = prim.indices->GetBytesPerComponent();
+
+    auto decodedIndexBuffer = std::make_unique<Buffer>();
+    decodedIndexBuffer->Grow(dracoMesh.num_faces() * 3 * componentBytes);
+
+    // If accessor uses the same size as draco implementation, copy the draco buffer directly
+
+    // Usually uint32_t but shouldn't assume
+    if (sizeof(dracoMesh.face(draco::FaceIndex(0))[0]) == componentBytes) {
+        memcpy(decodedIndexBuffer->GetPointer(), &dracoMesh.face(draco::FaceIndex(0))[0], decodedIndexBuffer->byteLength);
+        return;
+    }
+
+    // Not same size, convert
+    switch (componentBytes) {
+    case sizeof(uint32_t): CopyFaceIndex_Draco<uint32_t>(*decodedIndexBuffer, dracoMesh); break;
+    case sizeof(uint16_t): CopyFaceIndex_Draco<uint16_t>(*decodedIndexBuffer, dracoMesh); break;
+    case sizeof(uint8_t): CopyFaceIndex_Draco<uint8_t>(*decodedIndexBuffer, dracoMesh); break;
+    }
+
+    // Assign this alternate data buffer to the accessor
+    prim.indices->decodedBuffer.swap(decodedIndexBuffer);
+}
+
+template <typename T>
+static bool GetAttributeForAllPoints(const draco::Mesh &dracoMesh,
+                                     const draco::PointAttribute &dracoAttribute,
+                                     Buffer &outBuffer) {
+  size_t byteOffset = 0;
+  T values[4] = {0, 0, 0, 0};
+  for (draco::PointIndex i(0); i < dracoMesh.num_points(); ++i) {
+    const draco::AttributeValueIndex val_index = dracoAttribute.mapped_index(i);
+    if (!dracoAttribute.ConvertValue<T>(val_index, dracoAttribute.num_components(), values))
+      return false;
+
+    memcpy(outBuffer.GetPointer() + byteOffset, &values[0], sizeof(T) * dracoAttribute.num_components());
+    byteOffset += sizeof(T) * dracoAttribute.num_components();
+  }
+
+  return true;
+}
+
+inline void SetDecodedAttributeBuffer_Draco(const draco::Mesh &dracoMesh, uint32_t dracoAttribId, Accessor &accessor) {
+    // Create decoded buffer
+    const draco::PointAttribute *pDracoAttribute = dracoMesh.GetAttributeByUniqueId(dracoAttribId);
+    if (pDracoAttribute == nullptr)
+        throw DeadlyImportError("GLTF: Invalid draco attribute id: ", dracoAttribId);
+
+    size_t componentBytes = accessor.GetBytesPerComponent();
+
+    auto decodedAttribBuffer = std::make_unique<Buffer>();
+    decodedAttribBuffer->Grow(dracoMesh.num_points() * pDracoAttribute->num_components() * componentBytes);
+
+    switch(accessor.componentType)
+    {
+    case ComponentType_BYTE: GetAttributeForAllPoints<int8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    case ComponentType_UNSIGNED_BYTE: GetAttributeForAllPoints<uint8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    case ComponentType_SHORT : GetAttributeForAllPoints<int16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    case ComponentType_UNSIGNED_SHORT: GetAttributeForAllPoints<uint16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    case ComponentType_UNSIGNED_INT: GetAttributeForAllPoints<uint32_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    case ComponentType_FLOAT : GetAttributeForAllPoints<float>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    }
+
+    // Assign this alternate data buffer to the accessor
+    accessor.decodedBuffer.swap(decodedAttribBuffer);
+}
+
+#if _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif
+
 //
 // LazyDict methods
 //
@@ -709,6 +810,9 @@ inline unsigned int Accessor::GetElementSize() {
 }
 
 inline uint8_t *Accessor::GetPointer() {
+    if (decodedBuffer)
+        return decodedBuffer->GetPointer();
+
     if (sparse)
         return sparse->data.data();
 
@@ -730,6 +834,24 @@ inline uint8_t *Accessor::GetPointer() {
     return basePtr + offset;
 }
 
+inline size_t Accessor::GetStride()
+{
+  // Decoded buffer is always packed
+  if (decodedBuffer)
+    return GetElementSize();
+  
+  // Sparse and normal bufferView
+  return (bufferView && bufferView->byteStride ? bufferView->byteStride : GetElementSize());
+}
+
+inline size_t Accessor::GetMaxByteSize()
+{
+  if (decodedBuffer)
+    return decodedBuffer->byteLength;
+
+  return (bufferView ? bufferView->byteLength : sparse->data.size());
+}
+
 namespace {
 inline void CopyData(size_t count,
         const uint8_t *src, size_t src_stride,
@@ -761,7 +883,7 @@ void Accessor::ExtractData(T *&outData) {
     const size_t elemSize = GetElementSize();
     const size_t totalSize = elemSize * count;
 
-    const size_t stride = bufferView && bufferView->byteStride ? bufferView->byteStride : elemSize;
+    const size_t stride = GetStride();
 
     const size_t targetElemSize = sizeof(T);
 
@@ -769,7 +891,7 @@ void Accessor::ExtractData(T *&outData) {
         throw DeadlyImportError("GLTF: elemSize ", elemSize, " > targetElemSize ", targetElemSize, " in ", getContextForErrorMessages(id, name));
     }
 
-    const size_t maxSize = (bufferView ? bufferView->byteLength : sparse->data.size());
+    const size_t maxSize = GetMaxByteSize();
     if (count*stride > maxSize) {
         throw DeadlyImportError("GLTF: count*stride ", (count * stride), " > maxSize ", maxSize, " in ", getContextForErrorMessages(id, name));
     }
@@ -828,14 +950,14 @@ inline Accessor::Indexer::Indexer(Accessor &acc) :
         accessor(acc),
         data(acc.GetPointer()),
         elemSize(acc.GetElementSize()),
-        stride(acc.bufferView && acc.bufferView->byteStride ? acc.bufferView->byteStride : elemSize) {
+        stride(acc.GetStride()) {
 }
 
 //! Accesses the i-th value as defined by the accessor
 template <class T>
 T Accessor::Indexer::GetValue(int i) {
     ai_assert(data);
-    ai_assert(i * stride < accessor.bufferView->byteLength);
+    ai_assert(i * stride < accessor.GetMaxByteSize());
     // Ensure that the memcpy doesn't overwrite the local.
     const size_t sizeToCopy = std::min(elemSize, sizeof(T));
     T value = T();
@@ -1192,6 +1314,14 @@ inline void Mesh::Read(Value &pJSON_Object, Asset &pAsset_Root) {
             Primitive &prim = this->primitives[i];
             prim.mode = MemberOrDefault(primitive, "mode", PrimitiveMode_TRIANGLES);
 
+            if (Value *indices = FindUInt(primitive, "indices")) {
+                prim.indices = pAsset_Root.accessors.Retrieve(indices->GetUint());
+            }
+
+            if (Value *material = FindUInt(primitive, "material")) {
+                prim.material = pAsset_Root.materials.Retrieve(material->GetUint());
+            }
+
             if (Value *attrs = FindObject(primitive, "attributes")) {
                 for (Value::MemberIterator it = attrs->MemberBegin(); it != attrs->MemberEnd(); ++it) {
                     if (!it->value.IsUint()) continue;
@@ -1200,11 +1330,11 @@ inline void Mesh::Read(Value &pJSON_Object, Asset &pAsset_Root) {
                     // and WEIGHT.Attribute semantics can be of the form[semantic]_[set_index], e.g., TEXCOORD_0, TEXCOORD_1, etc.
 
                     int undPos = 0;
-                    Mesh::AccessorList *vec = 0;
+                    Mesh::AccessorList *vec = nullptr;
                     if (GetAttribVector(prim, attr, vec, undPos)) {
                         size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
                         if ((*vec).size() != idx) {
-                            throw DeadlyImportError("GLTF: Invalid attribute: ", attr, ". All indices for indexed attribute semantics must start with 0 and be continuous positive integers: TEXCOORD_0, TEXCOORD_1, etc.");
+                            throw DeadlyImportError("GLTF: Invalid attribute in mesh: ", name, " primitive: ", i,"attrib: ", attr, ". All indices for indexed attribute semantics must start with 0 and be continuous positive integers: TEXCOORD_0, TEXCOORD_1, etc.");
                         }
                         (*vec).resize(idx + 1);
                         (*vec)[idx] = pAsset_Root.accessors.Retrieve(it->value.GetUint());
@@ -1212,6 +1342,66 @@ inline void Mesh::Read(Value &pJSON_Object, Asset &pAsset_Root) {
                 }
             }
 
+#ifdef ASSIMP_ENABLE_DRACO
+            // KHR_draco_mesh_compression spec: Draco can only be used for glTF Triangles or Triangle Strips
+            if (pAsset_Root.extensionsUsed.KHR_draco_mesh_compression && (prim.mode == PrimitiveMode_TRIANGLES || prim.mode == PrimitiveMode_TRIANGLE_STRIP)) {
+                // Look for draco mesh compression extension and bufferView
+                // Skip if any missing
+                if (Value *exts = FindObject(primitive, "extensions")) {
+                    if (Value *dracoExt = FindObject(*exts, "KHR_draco_mesh_compression")) {
+                        if (Value *bufView = FindUInt(*dracoExt, "bufferView")) {
+                            // Attempt to load indices and attributes using draco compression
+                            auto bufferView = pAsset_Root.bufferViews.Retrieve(bufView->GetUint());
+                            // Attempt to perform the draco decode on the buffer data
+                            const char *bufferViewData = reinterpret_cast<const char *>(bufferView->buffer->GetPointer() + bufferView->byteOffset);
+                            draco::DecoderBuffer decoderBuffer;
+                            decoderBuffer.Init(bufferViewData, bufferView->byteLength);
+                            draco::Decoder decoder;
+                            auto decodeResult = decoder.DecodeMeshFromBuffer(&decoderBuffer);
+                            if (!decodeResult.ok()) {
+                                // A corrupt Draco isn't actually fatal if the primitive data is also provided in a standard buffer, but does anyone do that?
+                                throw DeadlyImportError("GLTF: Invalid Draco mesh compression in mesh ", name, " primitive ", i, ": ", decodeResult.status().error_msg_string());
+                            }
+
+                            // Now we have a draco mesh
+                            const std::unique_ptr<draco::Mesh> &pDracoMesh = decodeResult.value();
+
+                            // Redirect the accessors to the decoded data
+
+                            // Indices
+                            SetDecodedIndexBuffer_Draco(*pDracoMesh, prim);
+
+                            // Vertex attributes
+                            if (Value *attrs = FindObject(*dracoExt, "attributes")) {
+                                for (Value::MemberIterator it = attrs->MemberBegin(); it != attrs->MemberEnd(); ++it) {
+                                    if (!it->value.IsUint()) continue;
+                                    const char *attr = it->name.GetString();
+
+                                    int undPos = 0;
+                                    Mesh::AccessorList *vec = nullptr;
+                                    if (GetAttribVector(prim, attr, vec, undPos)) {
+                                        size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
+                                        if (idx >= (*vec).size()) {
+                                            throw DeadlyImportError("GLTF: Invalid draco attribute in mesh: ", name, " primitive: ", i, " attrib: ", attr, ". "
+                                              "All indices for indexed attribute semantics must start with 0 and be continuous positive integers: TEXCOORD_0, TEXCOORD_1, etc.");
+                                        }
+
+                                        Accessor &attribAccessor = *(*vec)[idx];
+                                        if (attribAccessor.count == 0)
+                                          throw DeadlyImportError("GLTF: Invalid draco attribute in mesh: ", name, " primitive: ", i, " attrib: ", attr);
+
+                                        // Redirect this accessor to the appropriate Draco vertex attribute data
+                                        const uint32_t dracoAttribId = it->value.GetUint();
+                                        SetDecodedAttributeBuffer_Draco(*pDracoMesh, dracoAttribId, attribAccessor);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+#endif
+
             Value *targetsArray = FindArray(primitive, "targets");
             if (nullptr != targetsArray) {
                 prim.targets.resize(targetsArray->Size());
@@ -1238,14 +1428,6 @@ inline void Mesh::Read(Value &pJSON_Object, Asset &pAsset_Root) {
                     }
                 }
             }
-
-            if (Value *indices = FindUInt(primitive, "indices")) {
-                prim.indices = pAsset_Root.accessors.Retrieve(indices->GetUint());
-            }
-
-            if (Value *material = FindUInt(primitive, "material")) {
-                prim.material = pAsset_Root.materials.Retrieve(material->GetUint());
-            }
         }
     }
 
@@ -1693,10 +1875,12 @@ inline void Asset::Load(const std::string &pFile, bool isBinary) {
     ReadExtensionsUsed(doc);
     ReadExtensionsRequired(doc);
 
-    // Currently Draco is not supported
+#ifndef ASSIMP_ENABLE_DRACO
+    // Is Draco supported?
     if (extensionsRequired.KHR_draco_mesh_compression) {
-        throw DeadlyImportError("GLTF: Draco mesh compression not currently supported.");
+        throw DeadlyImportError("GLTF: Draco mesh compression not supported.");
     }
+#endif
 
     // Prepare the dictionaries
     for (size_t i = 0; i < mDicts.size(); ++i) {
@@ -1784,6 +1968,7 @@ inline void Asset::ReadExtensionsUsed(Document &doc) {
     CHECK_EXT(KHR_materials_sheen);
     CHECK_EXT(KHR_materials_clearcoat);
     CHECK_EXT(KHR_materials_transmission);
+    CHECK_EXT(KHR_draco_mesh_compression);
 
 #undef CHECK_EXT
 }
diff --git a/test/unit/utglTF2ImportExport.cpp b/test/unit/utglTF2ImportExport.cpp
index e991b04f3..c49a96f40 100644
--- a/test/unit/utglTF2ImportExport.cpp
+++ b/test/unit/utglTF2ImportExport.cpp
@@ -574,3 +574,35 @@ TEST_F(utglTF2ImportExport, allIndicesOutOfRange) {
     std::string error = importer.GetErrorString();
     ASSERT_NE(error.find("Mesh \"Mesh\" has no faces"), std::string::npos);
 }
+
+/////////////////////////////////
+// Draco decoding
+#ifdef ASSIMP_ENABLE_DRACO
+
+TEST_F(utglTF2ImportExport, import_dracoEncoded) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/glTF2/draco/2CylinderEngine.gltf",
+            aiProcess_ValidateDataStructure);
+    ASSERT_NE(scene, nullptr);
+    ASSERT_NE(scene->mMetaData, nullptr);
+    {
+        ASSERT_TRUE(scene->mMetaData->HasKey(AI_METADATA_SOURCE_FORMAT));
+        aiString format;
+        ASSERT_TRUE(scene->mMetaData->Get(AI_METADATA_SOURCE_FORMAT, format));
+        ASSERT_EQ(strcmp(format.C_Str(), "glTF2 Importer"), 0);
+    }
+    {
+        ASSERT_TRUE(scene->mMetaData->HasKey(AI_METADATA_SOURCE_FORMAT_VERSION));
+        aiString version;
+        ASSERT_TRUE(scene->mMetaData->Get(AI_METADATA_SOURCE_FORMAT_VERSION, version));
+        ASSERT_EQ(strcmp(version.C_Str(), "2.0"), 0);
+    }
+    {
+        ASSERT_TRUE(scene->mMetaData->HasKey(AI_METADATA_SOURCE_GENERATOR));
+        aiString generator;
+        ASSERT_TRUE(scene->mMetaData->Get(AI_METADATA_SOURCE_GENERATOR, generator));
+        ASSERT_EQ(strcmp(generator.C_Str(), "COLLADA2GLTF"), 0);
+    }
+}
+
+#endif

From f39ba8ddb2fbe4344370345f237c77fc706c32b6 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Tue, 26 Jan 2021 16:24:18 +0000
Subject: [PATCH 05/30] Add compile error for bad error draco config

KHR_draco_mesh_compression requires
DRACO_MESH_COMPRESSION_SUPPORTED
---
 code/AssetLib/glTF2/glTF2Asset.inl | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/code/AssetLib/glTF2/glTF2Asset.inl b/code/AssetLib/glTF2/glTF2Asset.inl
index 53b49afe6..6b8c69296 100644
--- a/code/AssetLib/glTF2/glTF2Asset.inl
+++ b/code/AssetLib/glTF2/glTF2Asset.inl
@@ -49,6 +49,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef ASSIMP_ENABLE_DRACO
 #include "draco/compression/decode.h"
 #include "draco/core/decoder_buffer.h"
+#include "draco/draco_features.h"
+#ifndef DRACO_MESH_COMPRESSION_SUPPORTED
+#error glTF: KHR_draco_mesh_compression: draco library must have DRACO_MESH_COMPRESSION_SUPPORTED
+#endif
 #endif
 
 using namespace Assimp;

From fe97ff6474104be111ec378d6b2fbbacefc19a58 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Tue, 26 Jan 2021 17:18:15 +0000
Subject: [PATCH 06/30] Draco platform libraries have different names

On Windows it's draco.dll/lib
On Linux/macOS draco_shared.dylib & draco_static.lib
---
 CMakeLists.txt      | 16 +++++++++++++---
 code/CMakeLists.txt |  2 +-
 2 files changed, 14 insertions(+), 4 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index db72ea6ab..2eba4d9e6 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -578,7 +578,7 @@ IF ( ASSIMP_BUILD_DRACO )
   set(DRACO_MAYA_PLUGIN OFF CACHE BOOL "" FORCE)
   set(DRACO_UNITY_PLUGIN OFF CACHE BOOL "" FORCE)
   set(DRACO_TESTS OFF CACHE BOOL "" FORCE)
-  
+   
   IF(ASSIMP_HUNTER_ENABLED)
     # hunter is untested
     hunter_add_package(draco)
@@ -589,19 +589,29 @@ IF ( ASSIMP_BUILD_DRACO )
       set(DRACO_CXX_FLAGS "/W0")
     ENDIF()
     ADD_SUBDIRECTORY( "contrib/draco" )
+
+    if(MSVC OR WIN32)
+      set(draco_LIBRARIES "draco")
+    else()
+      if(BUILD_SHARED_LIBS)
+        set(draco_LIBRARIES "draco_shared")
+      else()
+        set(draco_LIBRARIES "draco_static")
+      endif()
+    endif()
     
     # Don't build the draco command-line tools by default
     set_target_properties(draco_encoder draco_decoder PROPERTIES EXCLUDE_FROM_ALL TRUE)
     set_target_properties(draco_encoder draco_decoder PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD TRUE)
     
-    TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco)
+    TARGET_USE_COMMON_OUTPUT_DIRECTORY(${draco_LIBRARIES})
     TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_encoder)
     TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_decoder)
     
     set(draco_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/contrib/draco/src")
     
     # This is probably wrong
-    INSTALL( TARGETS draco
+    INSTALL( TARGETS ${draco_LIBRARIES}
       EXPORT "${TARGETS_EXPORT_NAME}"
       LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
       ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
diff --git a/code/CMakeLists.txt b/code/CMakeLists.txt
index 3eb64de94..8bc43f015 100644
--- a/code/CMakeLists.txt
+++ b/code/CMakeLists.txt
@@ -1174,7 +1174,7 @@ IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
 ENDIF ()
 
 IF (ASSIMP_BUILD_DRACO)
-  target_link_libraries(assimp draco)
+  target_link_libraries(assimp ${draco_LIBRARIES})
 ENDIF()
 
 if( MSVC )

From d79e0c0ba990cb4193d740e08f8f68602bdd40a7 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Tue, 26 Jan 2021 17:33:10 +0000
Subject: [PATCH 07/30] Avoid std::make_unique

Assimp is still C++11
---
 code/AssetLib/glTF2/glTF2Asset.inl | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/code/AssetLib/glTF2/glTF2Asset.inl b/code/AssetLib/glTF2/glTF2Asset.inl
index 6b8c69296..b38217f83 100644
--- a/code/AssetLib/glTF2/glTF2Asset.inl
+++ b/code/AssetLib/glTF2/glTF2Asset.inl
@@ -209,7 +209,7 @@ inline void SetDecodedIndexBuffer_Draco(const draco::Mesh &dracoMesh, Mesh::Prim
     // Create a decoded Index buffer (if there is one)
     size_t componentBytes = prim.indices->GetBytesPerComponent();
 
-    auto decodedIndexBuffer = std::make_unique<Buffer>();
+    std::unique_ptr<Buffer> decodedIndexBuffer(new Buffer());
     decodedIndexBuffer->Grow(dracoMesh.num_faces() * 3 * componentBytes);
 
     // If accessor uses the same size as draco implementation, copy the draco buffer directly
@@ -257,7 +257,7 @@ inline void SetDecodedAttributeBuffer_Draco(const draco::Mesh &dracoMesh, uint32
 
     size_t componentBytes = accessor.GetBytesPerComponent();
 
-    auto decodedAttribBuffer = std::make_unique<Buffer>();
+    std::unique_ptr<Buffer> decodedAttribBuffer(new Buffer());
     decodedAttribBuffer->Grow(dracoMesh.num_points() * pDracoAttribute->num_components() * componentBytes);
 
     switch(accessor.componentType)

From 88001d1609b28adbb3039f09ca114f646fcfc3da Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Tue, 26 Jan 2021 17:56:39 +0000
Subject: [PATCH 08/30] Disable clang/gcc warnings for Draco

---
 CMakeLists.txt | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2eba4d9e6..5c94b4018 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -584,10 +584,21 @@ IF ( ASSIMP_BUILD_DRACO )
     hunter_add_package(draco)
     find_package(draco CONFIG REQUIRED)
   ELSE()
-    # Draco 1.4.1 has several nasty warnings and will not build with /WX
+    # Draco 1.4.1 has many warnings and will not build with /WX or -Werror
+    # See https://github.com/google/draco/issues/672
+    # and 
     IF(MSVC)
       set(DRACO_CXX_FLAGS "/W0")
+    ELSE()
+      list(APPEND DRACO_CXX_FLAGS
+        "-Wno-bool-compare"
+        "-Wno-comment"
+        "-Wno-maybe-uninitialized"
+        "-Wno-sign-compare"
+        "-Wno-unused-local-typedefs"
+      )
     ENDIF()
+    
     ADD_SUBDIRECTORY( "contrib/draco" )
 
     if(MSVC OR WIN32)

From 0c49cddae662be4f605600fae131227a89ce4ce9 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Tue, 26 Jan 2021 18:11:05 +0000
Subject: [PATCH 09/30] Cleanup cmakelists

Don't repeat self
Add links to google draco issues
---
 CMakeLists.txt | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5c94b4018..fc489be1a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -586,7 +586,7 @@ IF ( ASSIMP_BUILD_DRACO )
   ELSE()
     # Draco 1.4.1 has many warnings and will not build with /WX or -Werror
     # See https://github.com/google/draco/issues/672
-    # and 
+    # and https://github.com/google/draco/issues/673
     IF(MSVC)
       set(DRACO_CXX_FLAGS "/W0")
     ELSE()
@@ -612,8 +612,10 @@ IF ( ASSIMP_BUILD_DRACO )
     endif()
     
     # Don't build the draco command-line tools by default
-    set_target_properties(draco_encoder draco_decoder PROPERTIES EXCLUDE_FROM_ALL TRUE)
-    set_target_properties(draco_encoder draco_decoder PROPERTIES EXCLUDE_FROM_DEFAULT_BUILD TRUE)
+    set_target_properties(draco_encoder draco_decoder PROPERTIES
+      EXCLUDE_FROM_ALL TRUE
+      EXCLUDE_FROM_DEFAULT_BUILD TRUE
+      )
     
     TARGET_USE_COMMON_OUTPUT_DIRECTORY(${draco_LIBRARIES})
     TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_encoder)

From 5b9d06c2fca2a74736b426f572e9f8b3c5bbde66 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Wed, 27 Jan 2021 09:19:35 +0000
Subject: [PATCH 10/30] Disable draco clang/gcc warnings via pragma

draco templated functions also throw warnings
---
 code/AssetLib/glTF2/glTF2Asset.inl | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/code/AssetLib/glTF2/glTF2Asset.inl b/code/AssetLib/glTF2/glTF2Asset.inl
index b38217f83..b94301c24 100644
--- a/code/AssetLib/glTF2/glTF2Asset.inl
+++ b/code/AssetLib/glTF2/glTF2Asset.inl
@@ -47,9 +47,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/MemoryIOWrapper.h>
 
 #ifdef ASSIMP_ENABLE_DRACO
+#include "draco/draco_features.h"
 #include "draco/compression/decode.h"
 #include "draco/core/decoder_buffer.h"
-#include "draco/draco_features.h"
 #ifndef DRACO_MESH_COMPRESSION_SUPPORTED
 #error glTF: KHR_draco_mesh_compression: draco library must have DRACO_MESH_COMPRESSION_SUPPORTED
 #endif
@@ -190,6 +190,14 @@ inline Value *FindObject(Value &val, const char *id) {
 #pragma warning(push)
 #pragma warning(disable: 4018)  // Signed/unsigned mismatch
 #pragma warning(disable: 4804)  // Unsafe use of type 'bool'
+#elif defined(__clang__)
+#pragma diagnostic push
+#pragma clang diagnostic ignored "-Wbool-compare"
+#pragma clang diagnostic ignored "-Wsign-compare"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wbool-compare"
+#pragma GCC diagnostic ignored "-Wsign-compare"
 #endif
 
 template <typename T>
@@ -276,9 +284,13 @@ inline void SetDecodedAttributeBuffer_Draco(const draco::Mesh &dracoMesh, uint32
 
 #if _MSC_VER
 #pragma warning(pop)
+#elif defined(__clang__)
+#pragma diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
 #endif
 
-#endif
+#endif // ASSIMP_ENABLE_DRACO
 
 //
 // LazyDict methods

From c6fd1ce996e0aa9717ec4ae4abce95fddc0f68c3 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Wed, 27 Jan 2021 09:42:49 +0000
Subject: [PATCH 11/30] glTF2 Minor cleanup

---
 code/AssetLib/glTF2/glTF2Asset.inl | 164 +++++++++++++++--------------
 1 file changed, 87 insertions(+), 77 deletions(-)

diff --git a/code/AssetLib/glTF2/glTF2Asset.inl b/code/AssetLib/glTF2/glTF2Asset.inl
index b94301c24..acb4af0f9 100644
--- a/code/AssetLib/glTF2/glTF2Asset.inl
+++ b/code/AssetLib/glTF2/glTF2Asset.inl
@@ -155,32 +155,41 @@ inline static T MemberOrDefault(Value &obj, const char *id, T defaultValue) {
 
 inline Value *FindMember(Value &val, const char *id) {
     Value::MemberIterator it = val.FindMember(id);
-    return (it != val.MemberEnd()) ? &it->value : 0;
+    return (it != val.MemberEnd()) ? &it->value : nullptr;
 }
 
 inline Value *FindString(Value &val, const char *id) {
     Value::MemberIterator it = val.FindMember(id);
-    return (it != val.MemberEnd() && it->value.IsString()) ? &it->value : 0;
+    return (it != val.MemberEnd() && it->value.IsString()) ? &it->value : nullptr;
 }
 
 inline Value *FindNumber(Value &val, const char *id) {
     Value::MemberIterator it = val.FindMember(id);
-    return (it != val.MemberEnd() && it->value.IsNumber()) ? &it->value : 0;
+    return (it != val.MemberEnd() && it->value.IsNumber()) ? &it->value : nullptr;
 }
 
 inline Value *FindUInt(Value &val, const char *id) {
     Value::MemberIterator it = val.FindMember(id);
-    return (it != val.MemberEnd() && it->value.IsUint()) ? &it->value : 0;
+    return (it != val.MemberEnd() && it->value.IsUint()) ? &it->value : nullptr;
 }
 
 inline Value *FindArray(Value &val, const char *id) {
     Value::MemberIterator it = val.FindMember(id);
-    return (it != val.MemberEnd() && it->value.IsArray()) ? &it->value : 0;
+    return (it != val.MemberEnd() && it->value.IsArray()) ? &it->value : nullptr;
 }
 
 inline Value *FindObject(Value &val, const char *id) {
     Value::MemberIterator it = val.FindMember(id);
-    return (it != val.MemberEnd() && it->value.IsObject()) ? &it->value : 0;
+    return (it != val.MemberEnd() && it->value.IsObject()) ? &it->value : nullptr;
+}
+
+inline Value *FindExtension(Value &val, const char *extensionId) {
+  if (Value* extensionList = FindObject(val, "extensions")) {
+    if (Value* extension = FindObject(*extensionList, extensionId)) {
+      return extension;
+    }
+  }
+  return nullptr;
 }
 } // namespace
 
@@ -240,7 +249,7 @@ inline void SetDecodedIndexBuffer_Draco(const draco::Mesh &dracoMesh, Mesh::Prim
 }
 
 template <typename T>
-static bool GetAttributeForAllPoints(const draco::Mesh &dracoMesh,
+static bool GetAttributeForAllPoints_Draco(const draco::Mesh &dracoMesh,
                                      const draco::PointAttribute &dracoAttribute,
                                      Buffer &outBuffer) {
   size_t byteOffset = 0;
@@ -270,12 +279,12 @@ inline void SetDecodedAttributeBuffer_Draco(const draco::Mesh &dracoMesh, uint32
 
     switch(accessor.componentType)
     {
-    case ComponentType_BYTE: GetAttributeForAllPoints<int8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
-    case ComponentType_UNSIGNED_BYTE: GetAttributeForAllPoints<uint8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
-    case ComponentType_SHORT : GetAttributeForAllPoints<int16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
-    case ComponentType_UNSIGNED_SHORT: GetAttributeForAllPoints<uint16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
-    case ComponentType_UNSIGNED_INT: GetAttributeForAllPoints<uint32_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
-    case ComponentType_FLOAT : GetAttributeForAllPoints<float>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    case ComponentType_BYTE: GetAttributeForAllPoints_Draco<int8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    case ComponentType_UNSIGNED_BYTE: GetAttributeForAllPoints_Draco<uint8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    case ComponentType_SHORT : GetAttributeForAllPoints_Draco<int16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    case ComponentType_UNSIGNED_SHORT: GetAttributeForAllPoints_Draco<uint16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    case ComponentType_UNSIGNED_INT: GetAttributeForAllPoints_Draco<uint32_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    case ComponentType_FLOAT : GetAttributeForAllPoints_Draco<float>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
     }
 
     // Assign this alternate data buffer to the accessor
@@ -1084,28 +1093,26 @@ inline void Texture::Read(Value &obj, Asset &r) {
 namespace {
 inline void SetTextureProperties(Asset &r, Value *prop, TextureInfo &out) {
     if (r.extensionsUsed.KHR_texture_transform) {
-        if (Value *extensions = FindObject(*prop, "extensions")) {
+        if (Value *pKHR_texture_transform = FindExtension(*prop, "KHR_texture_transform")) {
             out.textureTransformSupported = true;
-            if (Value *pKHR_texture_transform = FindObject(*extensions, "KHR_texture_transform")) {
-                if (Value *array = FindArray(*pKHR_texture_transform, "offset")) {
-                    out.TextureTransformExt_t.offset[0] = (*array)[0].GetFloat();
-                    out.TextureTransformExt_t.offset[1] = (*array)[1].GetFloat();
-                } else {
-                    out.TextureTransformExt_t.offset[0] = 0;
-                    out.TextureTransformExt_t.offset[1] = 0;
-                }
+            if (Value *array = FindArray(*pKHR_texture_transform, "offset")) {
+                out.TextureTransformExt_t.offset[0] = (*array)[0].GetFloat();
+                out.TextureTransformExt_t.offset[1] = (*array)[1].GetFloat();
+            } else {
+                out.TextureTransformExt_t.offset[0] = 0;
+                out.TextureTransformExt_t.offset[1] = 0;
+            }
 
-                if (!ReadMember(*pKHR_texture_transform, "rotation", out.TextureTransformExt_t.rotation)) {
-                    out.TextureTransformExt_t.rotation = 0;
-                }
+            if (!ReadMember(*pKHR_texture_transform, "rotation", out.TextureTransformExt_t.rotation)) {
+                out.TextureTransformExt_t.rotation = 0;
+            }
 
-                if (Value *array = FindArray(*pKHR_texture_transform, "scale")) {
-                    out.TextureTransformExt_t.scale[0] = (*array)[0].GetFloat();
-                    out.TextureTransformExt_t.scale[1] = (*array)[1].GetFloat();
-                } else {
-                    out.TextureTransformExt_t.scale[0] = 1;
-                    out.TextureTransformExt_t.scale[1] = 1;
-                }
+            if (Value *array = FindArray(*pKHR_texture_transform, "scale")) {
+                out.TextureTransformExt_t.scale[0] = (*array)[0].GetFloat();
+                out.TextureTransformExt_t.scale[1] = (*array)[1].GetFloat();
+            } else {
+                out.TextureTransformExt_t.scale[0] = 1;
+                out.TextureTransformExt_t.scale[1] = 1;
             }
         }
     }
@@ -1181,8 +1188,7 @@ inline void Material::Read(Value &material, Asset &r) {
             }
         }
 
-        if (r.extensionsUsed.KHR_texture_transform) {
-        }
+        // Extension KHR_texture_transform is handled in ReadTextureProperty
 
         if (r.extensionsUsed.KHR_materials_sheen) {
             if (Value *curMaterialSheen = FindObject(*extensions, "KHR_materials_sheen")) {
@@ -1350,7 +1356,8 @@ inline void Mesh::Read(Value &pJSON_Object, Asset &pAsset_Root) {
                     if (GetAttribVector(prim, attr, vec, undPos)) {
                         size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
                         if ((*vec).size() != idx) {
-                            throw DeadlyImportError("GLTF: Invalid attribute in mesh: ", name, " primitive: ", i,"attrib: ", attr, ". All indices for indexed attribute semantics must start with 0 and be continuous positive integers: TEXCOORD_0, TEXCOORD_1, etc.");
+                            throw DeadlyImportError("GLTF: Invalid attribute in mesh: ", name, " primitive: ", i,"attrib: ", attr,
+                                    ". All indices for indexed attribute semantics must start with 0 and be continuous positive integers: TEXCOORD_0, TEXCOORD_1, etc.");
                         }
                         (*vec).resize(idx + 1);
                         (*vec)[idx] = pAsset_Root.accessors.Retrieve(it->value.GetUint());
@@ -1363,53 +1370,56 @@ inline void Mesh::Read(Value &pJSON_Object, Asset &pAsset_Root) {
             if (pAsset_Root.extensionsUsed.KHR_draco_mesh_compression && (prim.mode == PrimitiveMode_TRIANGLES || prim.mode == PrimitiveMode_TRIANGLE_STRIP)) {
                 // Look for draco mesh compression extension and bufferView
                 // Skip if any missing
-                if (Value *exts = FindObject(primitive, "extensions")) {
-                    if (Value *dracoExt = FindObject(*exts, "KHR_draco_mesh_compression")) {
-                        if (Value *bufView = FindUInt(*dracoExt, "bufferView")) {
-                            // Attempt to load indices and attributes using draco compression
-                            auto bufferView = pAsset_Root.bufferViews.Retrieve(bufView->GetUint());
-                            // Attempt to perform the draco decode on the buffer data
-                            const char *bufferViewData = reinterpret_cast<const char *>(bufferView->buffer->GetPointer() + bufferView->byteOffset);
-                            draco::DecoderBuffer decoderBuffer;
-                            decoderBuffer.Init(bufferViewData, bufferView->byteLength);
-                            draco::Decoder decoder;
-                            auto decodeResult = decoder.DecodeMeshFromBuffer(&decoderBuffer);
-                            if (!decodeResult.ok()) {
-                                // A corrupt Draco isn't actually fatal if the primitive data is also provided in a standard buffer, but does anyone do that?
-                                throw DeadlyImportError("GLTF: Invalid Draco mesh compression in mesh ", name, " primitive ", i, ": ", decodeResult.status().error_msg_string());
-                            }
+                if (Value *dracoExt = FindExtension(primitive, "KHR_draco_mesh_compression")) {
+                    if (Value *bufView = FindUInt(*dracoExt, "bufferView")) {
+                        // Attempt to load indices and attributes using draco compression
+                        auto bufferView = pAsset_Root.bufferViews.Retrieve(bufView->GetUint());
+                        // Attempt to perform the draco decode on the buffer data
+                        const char *bufferViewData = reinterpret_cast<const char *>(bufferView->buffer->GetPointer() + bufferView->byteOffset);
+                        draco::DecoderBuffer decoderBuffer;
+                        decoderBuffer.Init(bufferViewData, bufferView->byteLength);
+                        draco::Decoder decoder;
+                        auto decodeResult = decoder.DecodeMeshFromBuffer(&decoderBuffer);
+                        if (!decodeResult.ok()) {
+                            // A corrupt Draco isn't actually fatal if the primitive data is also provided in a standard buffer, but does anyone do that?
+                            throw DeadlyImportError("GLTF: Invalid Draco mesh compression in mesh: ", name, " primitive: ", i, ": ", decodeResult.status().error_msg_string());
+                        }
 
-                            // Now we have a draco mesh
-                            const std::unique_ptr<draco::Mesh> &pDracoMesh = decodeResult.value();
+                        // Now we have a draco mesh
+                        const std::unique_ptr<draco::Mesh> &pDracoMesh = decodeResult.value();
 
-                            // Redirect the accessors to the decoded data
+                        // Redirect the accessors to the decoded data
 
-                            // Indices
-                            SetDecodedIndexBuffer_Draco(*pDracoMesh, prim);
+                        // Indices
+                        SetDecodedIndexBuffer_Draco(*pDracoMesh, prim);
 
-                            // Vertex attributes
-                            if (Value *attrs = FindObject(*dracoExt, "attributes")) {
-                                for (Value::MemberIterator it = attrs->MemberBegin(); it != attrs->MemberEnd(); ++it) {
-                                    if (!it->value.IsUint()) continue;
-                                    const char *attr = it->name.GetString();
+                        // Vertex attributes
+                        if (Value *attrs = FindObject(*dracoExt, "attributes")) {
+                            for (Value::MemberIterator it = attrs->MemberBegin(); it != attrs->MemberEnd(); ++it) {
+                                if (!it->value.IsUint()) continue;
+                                const char *attr = it->name.GetString();
 
-                                    int undPos = 0;
-                                    Mesh::AccessorList *vec = nullptr;
-                                    if (GetAttribVector(prim, attr, vec, undPos)) {
-                                        size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
-                                        if (idx >= (*vec).size()) {
-                                            throw DeadlyImportError("GLTF: Invalid draco attribute in mesh: ", name, " primitive: ", i, " attrib: ", attr, ". "
-                                              "All indices for indexed attribute semantics must start with 0 and be continuous positive integers: TEXCOORD_0, TEXCOORD_1, etc.");
-                                        }
-
-                                        Accessor &attribAccessor = *(*vec)[idx];
-                                        if (attribAccessor.count == 0)
-                                          throw DeadlyImportError("GLTF: Invalid draco attribute in mesh: ", name, " primitive: ", i, " attrib: ", attr);
-
-                                        // Redirect this accessor to the appropriate Draco vertex attribute data
-                                        const uint32_t dracoAttribId = it->value.GetUint();
-                                        SetDecodedAttributeBuffer_Draco(*pDracoMesh, dracoAttribId, attribAccessor);
+                                int undPos = 0;
+                                Mesh::AccessorList *vec = nullptr;
+                                if (GetAttribVector(prim, attr, vec, undPos)) {
+                                    size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
+                                    if (idx >= (*vec).size()) {
+                                        throw DeadlyImportError("GLTF: Invalid draco attribute in mesh: ", name, " primitive: ", i, " attrib: ", attr,
+                                                ". All indices for indexed attribute semantics must start with 0 and be continuous positive integers: TEXCOORD_0, TEXCOORD_1, etc.");
                                     }
+
+                                    if (!(*vec)[idx]) {
+                                        throw DeadlyImportError("GLTF: Invalid draco attribute in mesh: ", name, " primitive: ", i, " attrib: ", attr,
+                                                ". All draco-encoded attributes must also define an accessor.");
+                                    }
+
+                                    Accessor &attribAccessor = *(*vec)[idx];
+                                    if (attribAccessor.count == 0)
+                                        throw DeadlyImportError("GLTF: Invalid draco attribute in mesh: ", name, " primitive: ", i, " attrib: ", attr);
+
+                                    // Redirect this accessor to the appropriate Draco vertex attribute data
+                                    const uint32_t dracoAttribId = it->value.GetUint();
+                                    SetDecodedAttributeBuffer_Draco(*pDracoMesh, dracoAttribId, attribAccessor);
                                 }
                             }
                         }
@@ -1892,7 +1902,7 @@ inline void Asset::Load(const std::string &pFile, bool isBinary) {
     ReadExtensionsRequired(doc);
 
 #ifndef ASSIMP_ENABLE_DRACO
-    // Is Draco supported?
+    // Is Draco required?
     if (extensionsRequired.KHR_draco_mesh_compression) {
         throw DeadlyImportError("GLTF: Draco mesh compression not supported.");
     }

From 6ec32b6b78226c2cdb00b544d27d76500d393419 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Wed, 27 Jan 2021 09:55:03 +0000
Subject: [PATCH 12/30] Apply clangformat

---
 code/AssetLib/glTF2/glTF2Asset.h   |   5 +-
 code/AssetLib/glTF2/glTF2Asset.inl | 119 +++++++++++++----------------
 2 files changed, 54 insertions(+), 70 deletions(-)

diff --git a/code/AssetLib/glTF2/glTF2Asset.h b/code/AssetLib/glTF2/glTF2Asset.h
index 7e252ab6b..75aa3b51d 100644
--- a/code/AssetLib/glTF2/glTF2Asset.h
+++ b/code/AssetLib/glTF2/glTF2Asset.h
@@ -513,7 +513,6 @@ struct BufferView : public Object {
     uint8_t *GetPointer(size_t accOffset);
 };
 
-
 //! A typed view into a BufferView. A BufferView contains raw binary data.
 //! An accessor provides a typed view into a BufferView or a subset of a BufferView
 //! similar to how WebGL's vertexAttribPointer() defines an attribute in a buffer.
@@ -850,7 +849,7 @@ struct CustomExtension : public Object {
 
     CustomExtension() = default;
 
-    CustomExtension(const CustomExtension& other)
+    CustomExtension(const CustomExtension &other)
         : Object(other)
         , mStringValue(other.mStringValue)
         , mDoubleValue(other.mDoubleValue)
@@ -1105,7 +1104,7 @@ public:
     } extensionsRequired;
 
     AssetMetadata asset;
-    Value* extras = nullptr;
+    Value *extras = nullptr;
 
     // Dictionaries for each type of object
 
diff --git a/code/AssetLib/glTF2/glTF2Asset.inl b/code/AssetLib/glTF2/glTF2Asset.inl
index acb4af0f9..90e50d733 100644
--- a/code/AssetLib/glTF2/glTF2Asset.inl
+++ b/code/AssetLib/glTF2/glTF2Asset.inl
@@ -42,12 +42,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "AssetLib/glTF/glTFCommon.h"
 
+#include <assimp/MemoryIOWrapper.h>
 #include <assimp/StringUtils.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/MemoryIOWrapper.h>
 
 #ifdef ASSIMP_ENABLE_DRACO
-#include "draco/draco_features.h"
 #include "draco/compression/decode.h"
 #include "draco/core/decoder_buffer.h"
 #ifndef DRACO_MESH_COMPRESSION_SUPPORTED
@@ -184,12 +183,12 @@ inline Value *FindObject(Value &val, const char *id) {
 }
 
 inline Value *FindExtension(Value &val, const char *extensionId) {
-  if (Value* extensionList = FindObject(val, "extensions")) {
-    if (Value* extension = FindObject(*extensionList, extensionId)) {
-      return extension;
+    if (Value *extensionList = FindObject(val, "extensions")) {
+        if (Value *extension = FindObject(*extensionList, extensionId)) {
+            return extension;
+        }
     }
-  }
-  return nullptr;
+    return nullptr;
 }
 } // namespace
 
@@ -197,8 +196,8 @@ inline Value *FindExtension(Value &val, const char *extensionId) {
 // Google draco library headers spew many warnings. Bad Google, no cookie
 #if _MSC_VER
 #pragma warning(push)
-#pragma warning(disable: 4018)  // Signed/unsigned mismatch
-#pragma warning(disable: 4804)  // Unsafe use of type 'bool'
+#pragma warning(disable : 4018) // Signed/unsigned mismatch
+#pragma warning(disable : 4804) // Unsafe use of type 'bool'
 #elif defined(__clang__)
 #pragma diagnostic push
 #pragma clang diagnostic ignored "-Wbool-compare"
@@ -250,20 +249,20 @@ inline void SetDecodedIndexBuffer_Draco(const draco::Mesh &dracoMesh, Mesh::Prim
 
 template <typename T>
 static bool GetAttributeForAllPoints_Draco(const draco::Mesh &dracoMesh,
-                                     const draco::PointAttribute &dracoAttribute,
-                                     Buffer &outBuffer) {
-  size_t byteOffset = 0;
-  T values[4] = {0, 0, 0, 0};
-  for (draco::PointIndex i(0); i < dracoMesh.num_points(); ++i) {
-    const draco::AttributeValueIndex val_index = dracoAttribute.mapped_index(i);
-    if (!dracoAttribute.ConvertValue<T>(val_index, dracoAttribute.num_components(), values))
-      return false;
+        const draco::PointAttribute &dracoAttribute,
+        Buffer &outBuffer) {
+    size_t byteOffset = 0;
+    T values[4] = { 0, 0, 0, 0 };
+    for (draco::PointIndex i(0); i < dracoMesh.num_points(); ++i) {
+        const draco::AttributeValueIndex val_index = dracoAttribute.mapped_index(i);
+        if (!dracoAttribute.ConvertValue<T>(val_index, dracoAttribute.num_components(), values))
+            return false;
 
-    memcpy(outBuffer.GetPointer() + byteOffset, &values[0], sizeof(T) * dracoAttribute.num_components());
-    byteOffset += sizeof(T) * dracoAttribute.num_components();
-  }
+        memcpy(outBuffer.GetPointer() + byteOffset, &values[0], sizeof(T) * dracoAttribute.num_components());
+        byteOffset += sizeof(T) * dracoAttribute.num_components();
+    }
 
-  return true;
+    return true;
 }
 
 inline void SetDecodedAttributeBuffer_Draco(const draco::Mesh &dracoMesh, uint32_t dracoAttribId, Accessor &accessor) {
@@ -277,14 +276,13 @@ inline void SetDecodedAttributeBuffer_Draco(const draco::Mesh &dracoMesh, uint32
     std::unique_ptr<Buffer> decodedAttribBuffer(new Buffer());
     decodedAttribBuffer->Grow(dracoMesh.num_points() * pDracoAttribute->num_components() * componentBytes);
 
-    switch(accessor.componentType)
-    {
+    switch (accessor.componentType) {
     case ComponentType_BYTE: GetAttributeForAllPoints_Draco<int8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
     case ComponentType_UNSIGNED_BYTE: GetAttributeForAllPoints_Draco<uint8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
-    case ComponentType_SHORT : GetAttributeForAllPoints_Draco<int16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    case ComponentType_SHORT: GetAttributeForAllPoints_Draco<int16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
     case ComponentType_UNSIGNED_SHORT: GetAttributeForAllPoints_Draco<uint16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
     case ComponentType_UNSIGNED_INT: GetAttributeForAllPoints_Draco<uint32_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
-    case ComponentType_FLOAT : GetAttributeForAllPoints_Draco<float>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+    case ComponentType_FLOAT: GetAttributeForAllPoints_Draco<float>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
     }
 
     // Assign this alternate data buffer to the accessor
@@ -514,12 +512,12 @@ inline void Buffer::Read(Value &obj, Asset &r) {
 
             if (statedLength > 0 && this->byteLength != statedLength) {
                 throw DeadlyImportError("GLTF: buffer \"", id, "\", expected ", to_string(statedLength),
-                                        " bytes, but found ", to_string(dataURI.dataLength));
+                        " bytes, but found ", to_string(dataURI.dataLength));
             }
         } else { // assume raw data
             if (statedLength != dataURI.dataLength) {
                 throw DeadlyImportError("GLTF: buffer \"", id, "\", expected ", to_string(statedLength),
-                                        " bytes, but found ", to_string(dataURI.dataLength));
+                        " bytes, but found ", to_string(dataURI.dataLength));
             }
 
             this->mData.reset(new uint8_t[dataURI.dataLength], std::default_delete<uint8_t[]>());
@@ -527,10 +525,7 @@ inline void Buffer::Read(Value &obj, Asset &r) {
         }
     } else { // Local file
         if (byteLength > 0) {
-            std::string dir = !r.mCurrentAssetDir.empty() ? (
-                r.mCurrentAssetDir.back() == '/' ?
-                   r.mCurrentAssetDir : r.mCurrentAssetDir + '/'
-            ) : "";
+            std::string dir = !r.mCurrentAssetDir.empty() ? (r.mCurrentAssetDir.back() == '/' ? r.mCurrentAssetDir : r.mCurrentAssetDir + '/') : "";
 
             IOStream *file = r.OpenFile(dir + uri, "rb");
             if (file) {
@@ -859,22 +854,20 @@ inline uint8_t *Accessor::GetPointer() {
     return basePtr + offset;
 }
 
-inline size_t Accessor::GetStride()
-{
-  // Decoded buffer is always packed
-  if (decodedBuffer)
-    return GetElementSize();
-  
-  // Sparse and normal bufferView
-  return (bufferView && bufferView->byteStride ? bufferView->byteStride : GetElementSize());
+inline size_t Accessor::GetStride() {
+    // Decoded buffer is always packed
+    if (decodedBuffer)
+        return GetElementSize();
+
+    // Sparse and normal bufferView
+    return (bufferView && bufferView->byteStride ? bufferView->byteStride : GetElementSize());
 }
 
-inline size_t Accessor::GetMaxByteSize()
-{
-  if (decodedBuffer)
-    return decodedBuffer->byteLength;
+inline size_t Accessor::GetMaxByteSize() {
+    if (decodedBuffer)
+        return decodedBuffer->byteLength;
 
-  return (bufferView ? bufferView->byteLength : sparse->data.size());
+    return (bufferView ? bufferView->byteLength : sparse->data.size());
 }
 
 namespace {
@@ -917,7 +910,7 @@ void Accessor::ExtractData(T *&outData) {
     }
 
     const size_t maxSize = GetMaxByteSize();
-    if (count*stride > maxSize) {
+    if (count * stride > maxSize) {
         throw DeadlyImportError("GLTF: count*stride ", (count * stride), " > maxSize ", maxSize, " in ", getContextForErrorMessages(id, name));
     }
 
@@ -1019,8 +1012,7 @@ inline void Image::Read(Value &obj, Asset &r) {
             if (Value *mtype = FindString(obj, "mimeType")) {
                 this->mimeType = mtype->GetString();
             }
-            if (!this->bufferView || this->mimeType.empty())
-            {
+            if (!this->bufferView || this->mimeType.empty()) {
                 throw DeadlyImportError("GLTF2: ", getContextForErrorMessages(id, name), " does not have a URI, so it must have a valid bufferView and mimetype");
             }
 
@@ -1031,10 +1023,8 @@ inline void Image::Read(Value &obj, Asset &r) {
 
             this->mData.reset(new uint8_t[this->mDataLength]);
             memcpy(this->mData.get(), buffer->GetPointer() + this->bufferView->byteOffset, this->mDataLength);
-        }
-        else
-        {
-            throw DeadlyImportError("GLTF2: ", getContextForErrorMessages(id, name), " should have either a URI of a bufferView and mimetype" );
+        } else {
+            throw DeadlyImportError("GLTF2: ", getContextForErrorMessages(id, name), " should have either a URI of a bufferView and mimetype");
         }
     }
 }
@@ -1356,7 +1346,7 @@ inline void Mesh::Read(Value &pJSON_Object, Asset &pAsset_Root) {
                     if (GetAttribVector(prim, attr, vec, undPos)) {
                         size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
                         if ((*vec).size() != idx) {
-                            throw DeadlyImportError("GLTF: Invalid attribute in mesh: ", name, " primitive: ", i,"attrib: ", attr,
+                            throw DeadlyImportError("GLTF: Invalid attribute in mesh: ", name, " primitive: ", i, "attrib: ", attr,
                                     ". All indices for indexed attribute semantics must start with 0 and be continuous positive integers: TEXCOORD_0, TEXCOORD_1, etc.");
                         }
                         (*vec).resize(idx + 1);
@@ -1539,25 +1529,22 @@ inline void Light::Read(Value &obj, Asset & /*r*/) {
     }
 }
 
-inline CustomExtension ReadExtensions(const char *name, Value& obj) {
+inline CustomExtension ReadExtensions(const char *name, Value &obj) {
     CustomExtension ret;
     ret.name = name;
     if (obj.IsObject()) {
         ret.mValues.isPresent = true;
         for (auto it = obj.MemberBegin(); it != obj.MemberEnd(); ++it) {
-            auto& val = it->value;
+            auto &val = it->value;
             ret.mValues.value.push_back(ReadExtensions(it->name.GetString(), val));
         }
-    }
-    else if (obj.IsArray()) {
+    } else if (obj.IsArray()) {
         ret.mValues.value.reserve(obj.Size());
         ret.mValues.isPresent = true;
-        for (unsigned int i = 0; i < obj.Size(); ++i)
-        {
+        for (unsigned int i = 0; i < obj.Size(); ++i) {
             ret.mValues.value.push_back(ReadExtensions(name, obj[i]));
         }
-    }
-    else if (obj.IsNumber()) {
+    } else if (obj.IsNumber()) {
         if (obj.IsUint64()) {
             ret.mUint64Value.value = obj.GetUint64();
             ret.mUint64Value.isPresent = true;
@@ -1568,12 +1555,10 @@ inline CustomExtension ReadExtensions(const char *name, Value& obj) {
             ret.mDoubleValue.value = obj.GetDouble();
             ret.mDoubleValue.isPresent = true;
         }
-    }
-    else if (obj.IsString()) {
+    } else if (obj.IsString()) {
         ReadValue(obj, ret.mStringValue);
         ret.mStringValue.isPresent = true;
-    }
-    else if (obj.IsBool()) {
+    } else if (obj.IsBool()) {
         ret.mBoolValue.value = obj.GetBool();
         ret.mBoolValue.isPresent = true;
     }
@@ -1619,7 +1604,7 @@ inline void Node::Read(Value &obj, Asset &r) {
         }
     }
 
-	// Do not retrieve a skin here, just take a reference, to avoid infinite recursion
+    // Do not retrieve a skin here, just take a reference, to avoid infinite recursion
     // Skins will be properly loaded later
     Value *curSkin = FindUInt(obj, "skin");
     if (nullptr != curSkin) {
@@ -1849,7 +1834,7 @@ inline void Asset::Load(const std::string &pFile, bool isBinary) {
     if (0 != strncmp(pFile.c_str(), AI_MEMORYIO_MAGIC_FILENAME, AI_MEMORYIO_MAGIC_FILENAME_LENGTH)) {
         mCurrentAssetDir = glTFCommon::getCurrentAssetDir(pFile);
     }
-    
+
     shared_ptr<IOStream> stream(OpenFile(pFile.c_str(), "rb", true));
     if (!stream) {
         throw DeadlyImportError("GLTF: Could not open file for reading");
@@ -2042,7 +2027,7 @@ inline std::string Asset::FindUniqueID(const std::string &str, const char *suffi
 }
 
 #if _MSC_VER
-#   pragma warning(pop)
+#pragma warning(pop)
 #endif // _MSC_VER
 
 } // namespace glTF2

From f6862f969778518a14a15580fe25098dcaa844e7 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Wed, 27 Jan 2021 10:18:33 +0000
Subject: [PATCH 13/30] Disable draco on cmake prior to 3.12

---
 CMakeLists.txt | 130 ++++++++++++++++++++++++++-----------------------
 1 file changed, 68 insertions(+), 62 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index fc489be1a..b989febd2 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -567,73 +567,79 @@ ELSE ()
   ADD_DEFINITIONS( -DASSIMP_BUILD_NO_C4D_IMPORTER )
 ENDIF ()
 
-OPTION ( ASSIMP_BUILD_DRACO "If the Draco libraries are to be built. Primarily for glTF" ON )
-IF ( ASSIMP_BUILD_DRACO )
-  # Primarily for glTF v2
-  # Enable Draco glTF feature set
-  set(DRACO_GLTF ON CACHE BOOL "" FORCE)
-  # Disable unnecessary or omitted components
-  set(DRACO_JS_GLUE OFF CACHE BOOL "" FORCE)
-  set(DRACO_WASM OFF CACHE BOOL "" FORCE)
-  set(DRACO_MAYA_PLUGIN OFF CACHE BOOL "" FORCE)
-  set(DRACO_UNITY_PLUGIN OFF CACHE BOOL "" FORCE)
-  set(DRACO_TESTS OFF CACHE BOOL "" FORCE)
-   
-  IF(ASSIMP_HUNTER_ENABLED)
-    # hunter is untested
-    hunter_add_package(draco)
-    find_package(draco CONFIG REQUIRED)
-  ELSE()
-    # Draco 1.4.1 has many warnings and will not build with /WX or -Werror
-    # See https://github.com/google/draco/issues/672
-    # and https://github.com/google/draco/issues/673
-    IF(MSVC)
-      set(DRACO_CXX_FLAGS "/W0")
+# Draco requires cmake 3.12
+IF (DEFINED CMAKE_VERSION AND "${CMAKE_VERSION}" VERSION_LESS "3.12")
+  message(NOTICE "draco requires cmake 3.12 or newer, cmake is ${CMAKE_VERSION} . Draco is disabled")
+  SET ( ASSIMP_BUILD_DRACO OFF CACHE BOOL "Disabled: Draco requires newer cmake" FORCE )
+ELSE()
+  OPTION ( ASSIMP_BUILD_DRACO "If the Draco libraries are to be built. Primarily for glTF" ON )
+  IF ( ASSIMP_BUILD_DRACO )
+    # Primarily for glTF v2
+    # Enable Draco glTF feature set
+    set(DRACO_GLTF ON CACHE BOOL "" FORCE)
+    # Disable unnecessary or omitted components
+    set(DRACO_JS_GLUE OFF CACHE BOOL "" FORCE)
+    set(DRACO_WASM OFF CACHE BOOL "" FORCE)
+    set(DRACO_MAYA_PLUGIN OFF CACHE BOOL "" FORCE)
+    set(DRACO_UNITY_PLUGIN OFF CACHE BOOL "" FORCE)
+    set(DRACO_TESTS OFF CACHE BOOL "" FORCE)
+     
+    IF(ASSIMP_HUNTER_ENABLED)
+      # hunter is untested
+      hunter_add_package(draco)
+      find_package(draco CONFIG REQUIRED)
     ELSE()
-      list(APPEND DRACO_CXX_FLAGS
-        "-Wno-bool-compare"
-        "-Wno-comment"
-        "-Wno-maybe-uninitialized"
-        "-Wno-sign-compare"
-        "-Wno-unused-local-typedefs"
-      )
-    ENDIF()
-    
-    ADD_SUBDIRECTORY( "contrib/draco" )
+      # Draco 1.4.1 has many warnings and will not build with /WX or -Werror
+      # See https://github.com/google/draco/issues/672
+      # and https://github.com/google/draco/issues/673
+      IF(MSVC)
+        set(DRACO_CXX_FLAGS "/W0")
+      ELSE()
+        list(APPEND DRACO_CXX_FLAGS
+          "-Wno-bool-compare"
+          "-Wno-comment"
+          "-Wno-maybe-uninitialized"
+          "-Wno-sign-compare"
+          "-Wno-unused-local-typedefs"
+        )
+      ENDIF()
+      
+      ADD_SUBDIRECTORY( "contrib/draco" )
 
-    if(MSVC OR WIN32)
-      set(draco_LIBRARIES "draco")
-    else()
-      if(BUILD_SHARED_LIBS)
-        set(draco_LIBRARIES "draco_shared")
+      if(MSVC OR WIN32)
+        set(draco_LIBRARIES "draco")
       else()
-        set(draco_LIBRARIES "draco_static")
+        if(BUILD_SHARED_LIBS)
+          set(draco_LIBRARIES "draco_shared")
+        else()
+          set(draco_LIBRARIES "draco_static")
+        endif()
       endif()
-    endif()
-    
-    # Don't build the draco command-line tools by default
-    set_target_properties(draco_encoder draco_decoder PROPERTIES
-      EXCLUDE_FROM_ALL TRUE
-      EXCLUDE_FROM_DEFAULT_BUILD TRUE
-      )
-    
-    TARGET_USE_COMMON_OUTPUT_DIRECTORY(${draco_LIBRARIES})
-    TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_encoder)
-    TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_decoder)
-    
-    set(draco_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/contrib/draco/src")
-    
-    # This is probably wrong
-    INSTALL( TARGETS ${draco_LIBRARIES}
-      EXPORT "${TARGETS_EXPORT_NAME}"
-      LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-      ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-      RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR}
-      FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
-      COMPONENT ${LIBASSIMP_COMPONENT}
-      INCLUDES DESTINATION include
-  )
+      
+      # Don't build the draco command-line tools by default
+      set_target_properties(draco_encoder draco_decoder PROPERTIES
+        EXCLUDE_FROM_ALL TRUE
+        EXCLUDE_FROM_DEFAULT_BUILD TRUE
+        )
+      
+      TARGET_USE_COMMON_OUTPUT_DIRECTORY(${draco_LIBRARIES})
+      TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_encoder)
+      TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_decoder)
+      
+      set(draco_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/contrib/draco/src")
+      
+      # This is probably wrong
+      INSTALL( TARGETS ${draco_LIBRARIES}
+        EXPORT "${TARGETS_EXPORT_NAME}"
+        LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
+        ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
+        RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR}
+        FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
+        COMPONENT ${LIBASSIMP_COMPONENT}
+        INCLUDES DESTINATION include
+    )
 
+    ENDIF()
   ENDIF()
 ENDIF()
 

From 26ce6ba4f6958a8df4d654113784854160f3c618 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Wed, 27 Jan 2021 10:25:56 +0000
Subject: [PATCH 14/30] draco unit test when draco disabled

Should not load the draco file
---
 test/unit/utglTF2ImportExport.cpp | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/test/unit/utglTF2ImportExport.cpp b/test/unit/utglTF2ImportExport.cpp
index c49a96f40..fe35c78f8 100644
--- a/test/unit/utglTF2ImportExport.cpp
+++ b/test/unit/utglTF2ImportExport.cpp
@@ -577,12 +577,15 @@ TEST_F(utglTF2ImportExport, allIndicesOutOfRange) {
 
 /////////////////////////////////
 // Draco decoding
-#ifdef ASSIMP_ENABLE_DRACO
 
 TEST_F(utglTF2ImportExport, import_dracoEncoded) {
     Assimp::Importer importer;
     const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/glTF2/draco/2CylinderEngine.gltf",
             aiProcess_ValidateDataStructure);
+#ifndef ASSIMP_ENABLE_DRACO
+    // No draco support, scene should not load
+    ASSERT_EQ(scene, nullptr);
+#else
     ASSERT_NE(scene, nullptr);
     ASSERT_NE(scene->mMetaData, nullptr);
     {
@@ -603,6 +606,6 @@ TEST_F(utglTF2ImportExport, import_dracoEncoded) {
         ASSERT_TRUE(scene->mMetaData->Get(AI_METADATA_SOURCE_GENERATOR, generator));
         ASSERT_EQ(strcmp(generator.C_Str(), "COLLADA2GLTF"), 0);
     }
+#endif
 }
 
-#endif

From 150514fc8bd5203e4bf4aef8915cec554526d97a Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Wed, 27 Jan 2021 10:42:28 +0000
Subject: [PATCH 15/30] Move draco warning suppression

Should be around the include for portability, not template instantiation
Fix clang pragma typos
---
 code/AssetLib/glTF2/glTF2Asset.inl | 45 +++++++++++++++---------------
 1 file changed, 23 insertions(+), 22 deletions(-)

diff --git a/code/AssetLib/glTF2/glTF2Asset.inl b/code/AssetLib/glTF2/glTF2Asset.inl
index 90e50d733..7ca6913c6 100644
--- a/code/AssetLib/glTF2/glTF2Asset.inl
+++ b/code/AssetLib/glTF2/glTF2Asset.inl
@@ -47,8 +47,31 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/DefaultLogger.hpp>
 
 #ifdef ASSIMP_ENABLE_DRACO
+
+// Google draco library headers spew many warnings. Bad Google, no cookie
+#if _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4018) // Signed/unsigned mismatch
+#pragma warning(disable : 4804) // Unsafe use of type 'bool'
+#elif defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wsign-compare"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wbool-compare"
+#pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
 #include "draco/compression/decode.h"
 #include "draco/core/decoder_buffer.h"
+
+#if _MSC_VER
+#pragma warning(pop)
+#elif defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#pragma GCC diagnostic pop
+#endif
 #ifndef DRACO_MESH_COMPRESSION_SUPPORTED
 #error glTF: KHR_draco_mesh_compression: draco library must have DRACO_MESH_COMPRESSION_SUPPORTED
 #endif
@@ -193,20 +216,6 @@ inline Value *FindExtension(Value &val, const char *extensionId) {
 } // namespace
 
 #ifdef ASSIMP_ENABLE_DRACO
-// Google draco library headers spew many warnings. Bad Google, no cookie
-#if _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4018) // Signed/unsigned mismatch
-#pragma warning(disable : 4804) // Unsafe use of type 'bool'
-#elif defined(__clang__)
-#pragma diagnostic push
-#pragma clang diagnostic ignored "-Wbool-compare"
-#pragma clang diagnostic ignored "-Wsign-compare"
-#elif defined(__GNUC__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wbool-compare"
-#pragma GCC diagnostic ignored "-Wsign-compare"
-#endif
 
 template <typename T>
 inline void CopyFaceIndex_Draco(Buffer &decodedIndexBuffer, const draco::Mesh &draco_mesh) {
@@ -289,14 +298,6 @@ inline void SetDecodedAttributeBuffer_Draco(const draco::Mesh &dracoMesh, uint32
     accessor.decodedBuffer.swap(decodedAttribBuffer);
 }
 
-#if _MSC_VER
-#pragma warning(pop)
-#elif defined(__clang__)
-#pragma diagnostic pop
-#elif defined(__GNUC__)
-#pragma GCC diagnostic pop
-#endif
-
 #endif // ASSIMP_ENABLE_DRACO
 
 //

From 48bcbbefdd7b4f6942fe9ca912671e5ded7531e9 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Wed, 27 Jan 2021 10:56:57 +0000
Subject: [PATCH 16/30] use nullptr and float constants

---
 code/AssetLib/glTF/glTFCommon.cpp  |  2 +-
 code/AssetLib/glTF/glTFCommon.h    |  1 -
 code/AssetLib/glTF2/glTF2Asset.h   |  4 ++--
 code/AssetLib/glTF2/glTF2Asset.inl | 28 ++++++++++++++--------------
 4 files changed, 17 insertions(+), 18 deletions(-)

diff --git a/code/AssetLib/glTF/glTFCommon.cpp b/code/AssetLib/glTF/glTFCommon.cpp
index 01ba31209..8a4b8927d 100644
--- a/code/AssetLib/glTF/glTFCommon.cpp
+++ b/code/AssetLib/glTF/glTFCommon.cpp
@@ -54,7 +54,7 @@ size_t DecodeBase64(const char *in, size_t inLength, uint8_t *&out) {
     }
 
     if (inLength < 4) {
-        out = 0;
+        out = nullptr;
         return 0;
     }
 
diff --git a/code/AssetLib/glTF/glTFCommon.h b/code/AssetLib/glTF/glTFCommon.h
index 6d402b0e3..cd5b552f5 100644
--- a/code/AssetLib/glTF/glTFCommon.h
+++ b/code/AssetLib/glTF/glTFCommon.h
@@ -107,7 +107,6 @@ public:
             f(file) {}
     ~IOStream() {
         fclose(f);
-        f = 0;
     }
 
     size_t Read(void *b, size_t sz, size_t n) { return fread(b, sz, n, f); }
diff --git a/code/AssetLib/glTF2/glTF2Asset.h b/code/AssetLib/glTF2/glTF2Asset.h
index 75aa3b51d..95bd5ad4b 100644
--- a/code/AssetLib/glTF2/glTF2Asset.h
+++ b/code/AssetLib/glTF2/glTF2Asset.h
@@ -570,7 +570,7 @@ struct Accessor : public Object {
         }
 
         inline bool IsValid() const {
-            return data != 0;
+            return data != nullptr;
         }
     };
 
@@ -1126,7 +1126,7 @@ public:
     Ref<Scene> scene;
 
 public:
-    Asset(IOSystem *io = 0) :
+    Asset(IOSystem *io = nullptr) :
             mIOSystem(io),
             asset(),
             accessors(*this, "accessors"),
diff --git a/code/AssetLib/glTF2/glTF2Asset.inl b/code/AssetLib/glTF2/glTF2Asset.inl
index 7ca6913c6..c54dc5f36 100644
--- a/code/AssetLib/glTF2/glTF2Asset.inl
+++ b/code/AssetLib/glTF2/glTF2Asset.inl
@@ -322,7 +322,7 @@ inline LazyDict<T>::~LazyDict() {
 
 template <class T>
 inline void LazyDict<T>::AttachToDocument(Document &doc) {
-    Value *container = 0;
+    Value *container = nullptr;
 
     if (mExtId) {
         if (Value *exts = FindObject(doc, "extensions")) {
@@ -339,7 +339,7 @@ inline void LazyDict<T>::AttachToDocument(Document &doc) {
 
 template <class T>
 inline void LazyDict<T>::DetachFromDocument() {
-    mDict = 0;
+    mDict = nullptr;
 }
 
 template <class T>
@@ -507,7 +507,7 @@ inline void Buffer::Read(Value &obj, Asset &r) {
     glTFCommon::Util::DataURI dataURI;
     if (ParseDataURI(uri, it->GetStringLength(), dataURI)) {
         if (dataURI.base64) {
-            uint8_t *data = 0;
+            uint8_t *data = nullptr;
             this->byteLength = glTFCommon::Util::DecodeBase64(dataURI.data, dataURI.dataLength, data);
             this->mData.reset(data, std::default_delete<uint8_t[]>());
 
@@ -697,9 +697,9 @@ inline void BufferView::Read(Value &obj, Asset &r) {
 }
 
 inline uint8_t *BufferView::GetPointer(size_t accOffset) {
-    if (!buffer) return 0;
+    if (!buffer) return nullptr;
     uint8_t *basePtr = buffer->GetPointer();
-    if (!basePtr) return 0;
+    if (!basePtr) return nullptr;
 
     size_t offset = accOffset + byteOffset;
     if (buffer->EncodedRegion_Current != nullptr) {
@@ -837,9 +837,9 @@ inline uint8_t *Accessor::GetPointer() {
     if (sparse)
         return sparse->data.data();
 
-    if (!bufferView || !bufferView->buffer) return 0;
+    if (!bufferView || !bufferView->buffer) return nullptr;
     uint8_t *basePtr = bufferView->buffer->GetPointer();
-    if (!basePtr) return 0;
+    if (!basePtr) return nullptr;
 
     size_t offset = byteOffset + bufferView->byteOffset;
 
@@ -1241,12 +1241,12 @@ void SetVector(vec3 &v, const float (&in)[3]) {
 inline void Material::SetDefaults() {
     //pbr materials
     SetVector(pbrMetallicRoughness.baseColorFactor, defaultBaseColor);
-    pbrMetallicRoughness.metallicFactor = 1.0;
-    pbrMetallicRoughness.roughnessFactor = 1.0;
+    pbrMetallicRoughness.metallicFactor = 1.0f;
+    pbrMetallicRoughness.roughnessFactor = 1.0f;
 
     SetVector(emissiveFactor, defaultEmissiveFactor);
     alphaMode = "OPAQUE";
-    alphaCutoff = 0.5;
+    alphaCutoff = 0.5f;
     doubleSided = false;
     unlit = false;
 }
@@ -1255,7 +1255,7 @@ inline void PbrSpecularGlossiness::SetDefaults() {
     //pbrSpecularGlossiness properties
     SetVector(diffuseFactor, defaultDiffuseFactor);
     SetVector(specularFactor, defaultSpecularFactor);
-    glossinessFactor = 1.0;
+    glossinessFactor = 1.0f;
 }
 
 inline void MaterialSheen::SetDefaults() {
@@ -1434,7 +1434,7 @@ inline void Mesh::Read(Value &pJSON_Object, Asset &pAsset_Root) {
                         const char *attr = it->name.GetString();
                         // Valid attribute semantics include POSITION, NORMAL, TANGENT
                         int undPos = 0;
-                        Mesh::AccessorList *vec = 0;
+                        Mesh::AccessorList *vec = nullptr;
                         if (GetAttribTargetVector(prim, j, attr, vec, undPos)) {
                             size_t idx = (attr[undPos] == '_') ? atoi(attr + undPos + 1) : 0;
                             if ((*vec).size() <= idx) {
@@ -1989,12 +1989,12 @@ inline IOStream *Asset::OpenFile(std::string path, const char *mode, bool /*abso
 #ifdef ASSIMP_API
     return mIOSystem->Open(path, mode);
 #else
-    if (path.size() < 2) return 0;
+    if (path.size() < 2) return nullptr;
     if (!absolute && path[1] != ':' && path[0] != '/') { // relative?
         path = mCurrentAssetDir + path;
     }
     FILE *f = fopen(path.c_str(), mode);
-    return f ? new IOStream(f) : 0;
+    return f ? new IOStream(f) : nullptr;
 #endif
 }
 

From efae3b83b1db7d85205fa56099487c98a2265301 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Thu, 28 Jan 2021 10:18:12 +0000
Subject: [PATCH 17/30] Draco requires default visibility on gcc/clang

---
 CMakeLists.txt | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b989febd2..d25d1d897 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -602,6 +602,10 @@ ELSE()
           "-Wno-sign-compare"
           "-Wno-unused-local-typedefs"
         )
+        # Draco 1.4.1 does not explicitly export any symbols under GCC/clang
+        list(APPEND DRACO_CXX_FLAGS
+          "-fvisibility=default"
+        )
       ENDIF()
       
       ADD_SUBDIRECTORY( "contrib/draco" )

From 62c991290b1bcd05736bc2ae39265db5a46936d4 Mon Sep 17 00:00:00 2001
From: Rahul Sheth <rahul@snap.com>
Date: Fri, 29 Jan 2021 17:10:38 -0500
Subject: [PATCH 18/30] Try adding Draco support through Hunter

---
 .github/workflows/ccpp.yml          |  8 +++++++-
 CMakeLists.txt                      | 19 +++++++++----------
 cmake/assimp-hunter-config.cmake.in |  4 ++++
 3 files changed, 20 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml
index f29e2e500..83e71b9cb 100644
--- a/.github/workflows/ccpp.yml
+++ b/.github/workflows/ccpp.yml
@@ -67,7 +67,13 @@ jobs:
       uses: actions/checkout@v2
       with:
         repository: cpp-pm/polly
-        path: cmake/polly     
+        path: cmake/polly
+
+    - name: Remove contrib directory for Hunter builds
+      if: contains(matrix.name, 'hunter')
+      uses: JesseTG/rm@v1
+      with:
+        path: contrib
 
     - name: Cache DX SDK
       id: dxcache
diff --git a/CMakeLists.txt b/CMakeLists.txt
index d25d1d897..722486b41 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -46,8 +46,8 @@ option(ASSIMP_HUNTER_ENABLED "Enable Hunter package manager support" OFF)
 IF(ASSIMP_HUNTER_ENABLED)
   include("cmake/HunterGate.cmake")
   HunterGate(
-    URL "https://github.com/cpp-pm/hunter/archive/v0.23.269.tar.gz"
-    SHA1 "64024b7b95b4c86d50ae05b926814448c93a70a0"
+    URL "https://github.com/cpp-pm/hunter/archive/v0.23.293.tar.gz"
+    SHA1 "e8e5470652db77149d9b38656db2a6c0b7642693"
   )
 
   add_definitions(-DASSIMP_USE_HUNTER)
@@ -583,9 +583,8 @@ ELSE()
     set(DRACO_MAYA_PLUGIN OFF CACHE BOOL "" FORCE)
     set(DRACO_UNITY_PLUGIN OFF CACHE BOOL "" FORCE)
     set(DRACO_TESTS OFF CACHE BOOL "" FORCE)
-     
+
     IF(ASSIMP_HUNTER_ENABLED)
-      # hunter is untested
       hunter_add_package(draco)
       find_package(draco CONFIG REQUIRED)
     ELSE()
@@ -607,7 +606,7 @@ ELSE()
           "-fvisibility=default"
         )
       ENDIF()
-      
+
       ADD_SUBDIRECTORY( "contrib/draco" )
 
       if(MSVC OR WIN32)
@@ -619,19 +618,19 @@ ELSE()
           set(draco_LIBRARIES "draco_static")
         endif()
       endif()
-      
+
       # Don't build the draco command-line tools by default
       set_target_properties(draco_encoder draco_decoder PROPERTIES
         EXCLUDE_FROM_ALL TRUE
         EXCLUDE_FROM_DEFAULT_BUILD TRUE
         )
-      
+
       TARGET_USE_COMMON_OUTPUT_DIRECTORY(${draco_LIBRARIES})
       TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_encoder)
       TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_decoder)
-      
+
       set(draco_INCLUDE_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/contrib/draco/src")
-      
+
       # This is probably wrong
       INSTALL( TARGETS ${draco_LIBRARIES}
         EXPORT "${TARGETS_EXPORT_NAME}"
@@ -661,7 +660,7 @@ IF ( ASSIMP_BUILD_ASSIMP_TOOLS )
   ADD_SUBDIRECTORY( tools/assimp_cmd/ )
 ENDIF ()
 
-IF ( ASSIMP_BUILD_SAMPLES)
+IF ( ASSIMP_BUILD_SAMPLES )
   SET( SAMPLES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/samples )
   SET( SAMPLES_SHARED_CODE_DIR ${SAMPLES_DIR}/SharedCode )
   IF ( WIN32 )
diff --git a/cmake/assimp-hunter-config.cmake.in b/cmake/assimp-hunter-config.cmake.in
index b5283f4fb..91efcbf24 100644
--- a/cmake/assimp-hunter-config.cmake.in
+++ b/cmake/assimp-hunter-config.cmake.in
@@ -10,5 +10,9 @@ find_package(polyclipping CONFIG REQUIRED)
 find_package(zip CONFIG REQUIRED)
 find_package(pugixml CONFIG REQUIRED)
 
+if(@ASSIMP_BUILD_DRACO@)
+  find_package(draco CONFIG REQUIRED)
+endif()
+
 include("${CMAKE_CURRENT_LIST_DIR}/@TARGETS_EXPORT_NAME@.cmake")
 check_required_components("@PROJECT_NAME@")

From a0116c6e01db932ed268ff07cc8cb3954e934f7f Mon Sep 17 00:00:00 2001
From: Rahul Sheth <rahul@snap.com>
Date: Fri, 29 Jan 2021 17:22:16 -0500
Subject: [PATCH 19/30] Need to link against correct target

---
 CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 722486b41..06669c4ff 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -587,6 +587,7 @@ ELSE()
     IF(ASSIMP_HUNTER_ENABLED)
       hunter_add_package(draco)
       find_package(draco CONFIG REQUIRED)
+      set(draco_LIBRARIES draco::draco)
     ELSE()
       # Draco 1.4.1 has many warnings and will not build with /WX or -Werror
       # See https://github.com/google/draco/issues/672

From 9aa6ec73ba6da0ea4bebe5671b8866d4112a6a3b Mon Sep 17 00:00:00 2001
From: Minmin Gong <gongminmin@msn.com>
Date: Thu, 28 Jan 2021 23:20:18 -0800
Subject: [PATCH 20/30] Export zlib if it's built outside

---
 CMakeLists.txt | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1a02a1bdb..270e49dd5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -452,6 +452,12 @@ IF(ASSIMP_HUNTER_ENABLED)
   set(ZLIB_LIBRARIES ZLIB::zlib)
   set(ASSIMP_BUILD_MINIZIP TRUE)
 ELSE()
+  # If the zlib is already found outside, add an export in case assimpTargets can't find it.
+  IF( ZLIB_FOUND )
+    INSTALL( TARGETS zlib
+        EXPORT "${TARGETS_EXPORT_NAME}")
+  ENDIF()
+
   IF ( NOT ASSIMP_BUILD_ZLIB )
     FIND_PACKAGE(ZLIB)
   ENDIF()

From b45723c384e23b399448b9824756c16c36f52081 Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Mon, 1 Feb 2021 13:24:27 +0000
Subject: [PATCH 21/30] Update JesseTG/rm to 1.0.2

Looks to be the current release
---
 .github/workflows/ccpp.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ccpp.yml b/.github/workflows/ccpp.yml
index 83e71b9cb..510ae8e7f 100644
--- a/.github/workflows/ccpp.yml
+++ b/.github/workflows/ccpp.yml
@@ -71,7 +71,7 @@ jobs:
 
     - name: Remove contrib directory for Hunter builds
       if: contains(matrix.name, 'hunter')
-      uses: JesseTG/rm@v1
+      uses: JesseTG/rm@v1.0.2
       with:
         path: contrib
 

From aa10b56bc2fad6ae4915e19ae226677801b9affd Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Mon, 1 Feb 2021 14:29:24 +0000
Subject: [PATCH 22/30] Fix draco linking for Hunter/Normal

---
 code/CMakeLists.txt | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/code/CMakeLists.txt b/code/CMakeLists.txt
index 7e521bf61..dc5e0523a 100644
--- a/code/CMakeLists.txt
+++ b/code/CMakeLists.txt
@@ -1157,8 +1157,15 @@ IF(ASSIMP_HUNTER_ENABLED)
       zip::zip
       pugixml
   )
+  
+  if (ASSIMP_BUILD_DRACO)
+    target_link_libraries(assimp PUBLIC ${draco_LIBRARIES})
+  endif()
 ELSE()
   TARGET_LINK_LIBRARIES(assimp ${ZLIB_LIBRARIES} ${OPENDDL_PARSER_LIBRARIES})
+  if (ASSIMP_BUILD_DRACO)
+    target_link_libraries(assimp ${draco_LIBRARIES})
+  endif()
 ENDIF()
 
 if(ASSIMP_ANDROID_JNIIOSYSTEM)
@@ -1173,10 +1180,6 @@ IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
   TARGET_LINK_LIBRARIES(assimp ${C4D_EXTRA_LIBRARIES})
 ENDIF ()
 
-IF (ASSIMP_BUILD_DRACO)
-  target_link_libraries(assimp ${draco_LIBRARIES})
-ENDIF()
-
 if( MSVC )
   # in order to prevent DLL hell, each of the DLLs have to be suffixed with the major version and msvc prefix
   # CMake 3.12 added a variable for this

From 42d47c7f0b3041d19954147f77ba101ec971510d Mon Sep 17 00:00:00 2001
From: RichardTea <31507749+RichardTea@users.noreply.github.com>
Date: Wed, 3 Feb 2021 11:38:20 +0000
Subject: [PATCH 23/30] Fixup install rules

Explicitly build and install the draco shared library _only_
---
 CMakeLists.txt | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4d1617e0c..740ef0656 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -608,7 +608,8 @@ ELSE()
         )
       ENDIF()
 
-      ADD_SUBDIRECTORY( "contrib/draco" )
+      # Don't build or install all of Draco by default
+      ADD_SUBDIRECTORY( "contrib/draco" EXCLUDE_FROM_ALL )
 
       if(MSVC OR WIN32)
         set(draco_LIBRARIES "draco")
@@ -626,6 +627,12 @@ ELSE()
         EXCLUDE_FROM_DEFAULT_BUILD TRUE
         )
 
+      # Do build the draco shared library
+      set_target_properties(${draco_LIBRARIES} PROPERTIES
+        EXCLUDE_FROM_ALL FALSE
+        EXCLUDE_FROM_DEFAULT_BUILD FALSE
+        )
+
       TARGET_USE_COMMON_OUTPUT_DIRECTORY(${draco_LIBRARIES})
       TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_encoder)
       TARGET_USE_COMMON_OUTPUT_DIRECTORY(draco_decoder)

From ba7f945f99ed33b5016f79d7bb760c838cafe3e3 Mon Sep 17 00:00:00 2001
From: Guangmo Lin <lingm@xiaopeng.com>
Date: Sun, 14 Feb 2021 10:28:14 +0800
Subject: [PATCH 24/30] Eliminate MSVC warning C4819 caused by source files
 encoded in UTF-8 without BOM

---
 code/AssetLib/AMF/AMFImporter_Geometry.cpp | 2 +-
 code/AssetLib/AMF/AMFImporter_Node.hpp     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/code/AssetLib/AMF/AMFImporter_Geometry.cpp b/code/AssetLib/AMF/AMFImporter_Geometry.cpp
index 7afe52311..51670072c 100644
--- a/code/AssetLib/AMF/AMFImporter_Geometry.cpp
+++ b/code/AssetLib/AMF/AMFImporter_Geometry.cpp
@@ -194,7 +194,7 @@ void AMFImporter::ParseNode_Coordinates(XmlNode &node) {
 
 // <volume
 // materialid="" - Which material to use.
-// type=""       - What this volume describes can be “region” or “support”. If none specified, “object” is assumed. If support, then the geometric
+// type=""       - What this volume describes can be "region" or "support". If none specified, "object" is assumed. If support, then the geometric
 //                 requirements 1-8 listed in section 5 do not need to be maintained.
 // >
 // </volume>
diff --git a/code/AssetLib/AMF/AMFImporter_Node.hpp b/code/AssetLib/AMF/AMFImporter_Node.hpp
index 81e0312b6..c757d56e0 100644
--- a/code/AssetLib/AMF/AMFImporter_Node.hpp
+++ b/code/AssetLib/AMF/AMFImporter_Node.hpp
@@ -240,7 +240,7 @@ struct AMFVertices : public AMFNodeElementBase {
 /// Structure that define volume node.
 struct AMFVolume : public AMFNodeElementBase {
 	std::string MaterialID; ///< Which material to use.
-	std::string Type; ///< What this volume describes can be “region” or “support”. If none specified, “object” is assumed.
+	std::string Type; ///< What this volume describes can be "region" or "support". If none specified, "object" is assumed.
 
 	/// Constructor.
 	/// \param [in] pParent - pointer to parent node.

From d57b78bc984446e6a8abdd95f8c7540752b324ec Mon Sep 17 00:00:00 2001
From: Minmin Gong <gongminmin@msn.com>
Date: Tue, 16 Feb 2021 20:08:22 -0800
Subject: [PATCH 25/30] Export the animation name to gltf2

---
 code/AssetLib/glTF2/glTF2Exporter.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/code/AssetLib/glTF2/glTF2Exporter.cpp b/code/AssetLib/glTF2/glTF2Exporter.cpp
index 10525e028..e34125258 100644
--- a/code/AssetLib/glTF2/glTF2Exporter.cpp
+++ b/code/AssetLib/glTF2/glTF2Exporter.cpp
@@ -1388,6 +1388,7 @@ void glTF2Exporter::ExportAnimations()
             nameAnim = anim->mName.C_Str();
         }
         Ref<Animation> animRef = mAsset->animations.Create(nameAnim);
+        animRef->name = nameAnim;
 
         for (unsigned int channelIndex = 0; channelIndex < anim->mNumChannels; ++channelIndex) {
             const aiNodeAnim* nodeChannel = anim->mChannels[channelIndex];

From 6094da349324db5b7cacc768061acaa150577585 Mon Sep 17 00:00:00 2001
From: Kim Kulling <kimkulling@users.noreply.github.com>
Date: Thu, 18 Feb 2021 09:32:37 +0100
Subject: [PATCH 26/30] Update glTF2Asset.inl

---
 code/AssetLib/glTF2/glTF2Asset.inl | 48 +++++++++++++++++++++++-------
 1 file changed, 37 insertions(+), 11 deletions(-)

diff --git a/code/AssetLib/glTF2/glTF2Asset.inl b/code/AssetLib/glTF2/glTF2Asset.inl
index c54dc5f36..b234fd0bf 100644
--- a/code/AssetLib/glTF2/glTF2Asset.inl
+++ b/code/AssetLib/glTF2/glTF2Asset.inl
@@ -247,9 +247,18 @@ inline void SetDecodedIndexBuffer_Draco(const draco::Mesh &dracoMesh, Mesh::Prim
 
     // Not same size, convert
     switch (componentBytes) {
-    case sizeof(uint32_t): CopyFaceIndex_Draco<uint32_t>(*decodedIndexBuffer, dracoMesh); break;
-    case sizeof(uint16_t): CopyFaceIndex_Draco<uint16_t>(*decodedIndexBuffer, dracoMesh); break;
-    case sizeof(uint8_t): CopyFaceIndex_Draco<uint8_t>(*decodedIndexBuffer, dracoMesh); break;
+        case sizeof(uint32_t): 
+            CopyFaceIndex_Draco<uint32_t>(*decodedIndexBuffer, dracoMesh); 
+            break;
+        case sizeof(uint16_t): 
+            CopyFaceIndex_Draco<uint16_t>(*decodedIndexBuffer, dracoMesh); 
+            break;
+        case sizeof(uint8_t): 
+            CopyFaceIndex_Draco<uint8_t>(*decodedIndexBuffer, dracoMesh); 
+            break;
+        default:
+            ai_assert(false);
+            break;
     }
 
     // Assign this alternate data buffer to the accessor
@@ -264,8 +273,9 @@ static bool GetAttributeForAllPoints_Draco(const draco::Mesh &dracoMesh,
     T values[4] = { 0, 0, 0, 0 };
     for (draco::PointIndex i(0); i < dracoMesh.num_points(); ++i) {
         const draco::AttributeValueIndex val_index = dracoAttribute.mapped_index(i);
-        if (!dracoAttribute.ConvertValue<T>(val_index, dracoAttribute.num_components(), values))
+        if (!dracoAttribute.ConvertValue<T>(val_index, dracoAttribute.num_components(), values)) {
             return false;
+        }
 
         memcpy(outBuffer.GetPointer() + byteOffset, &values[0], sizeof(T) * dracoAttribute.num_components());
         byteOffset += sizeof(T) * dracoAttribute.num_components();
@@ -277,8 +287,9 @@ static bool GetAttributeForAllPoints_Draco(const draco::Mesh &dracoMesh,
 inline void SetDecodedAttributeBuffer_Draco(const draco::Mesh &dracoMesh, uint32_t dracoAttribId, Accessor &accessor) {
     // Create decoded buffer
     const draco::PointAttribute *pDracoAttribute = dracoMesh.GetAttributeByUniqueId(dracoAttribId);
-    if (pDracoAttribute == nullptr)
+    if (pDracoAttribute == nullptr) {
         throw DeadlyImportError("GLTF: Invalid draco attribute id: ", dracoAttribId);
+    }
 
     size_t componentBytes = accessor.GetBytesPerComponent();
 
@@ -286,12 +297,27 @@ inline void SetDecodedAttributeBuffer_Draco(const draco::Mesh &dracoMesh, uint32
     decodedAttribBuffer->Grow(dracoMesh.num_points() * pDracoAttribute->num_components() * componentBytes);
 
     switch (accessor.componentType) {
-    case ComponentType_BYTE: GetAttributeForAllPoints_Draco<int8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
-    case ComponentType_UNSIGNED_BYTE: GetAttributeForAllPoints_Draco<uint8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
-    case ComponentType_SHORT: GetAttributeForAllPoints_Draco<int16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
-    case ComponentType_UNSIGNED_SHORT: GetAttributeForAllPoints_Draco<uint16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
-    case ComponentType_UNSIGNED_INT: GetAttributeForAllPoints_Draco<uint32_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
-    case ComponentType_FLOAT: GetAttributeForAllPoints_Draco<float>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); break;
+        case ComponentType_BYTE: 
+            GetAttributeForAllPoints_Draco<int8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); 
+            break;
+        case ComponentType_UNSIGNED_BYTE:
+            GetAttributeForAllPoints_Draco<uint8_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); 
+            break;
+        case ComponentType_SHORT:
+            GetAttributeForAllPoints_Draco<int16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer);
+            break;
+        case ComponentType_UNSIGNED_SHORT: 
+            GetAttributeForAllPoints_Draco<uint16_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); 
+            break;
+        case ComponentType_UNSIGNED_INT: 
+            GetAttributeForAllPoints_Draco<uint32_t>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); 
+            break;
+        case ComponentType_FLOAT: 
+            GetAttributeForAllPoints_Draco<float>(dracoMesh, *pDracoAttribute, *decodedAttribBuffer); 
+            break;
+        default:
+            ai_assert(false);
+            break;
     }
 
     // Assign this alternate data buffer to the accessor

From 3e1c785d31f6ba77599cee5e901b2668c1293120 Mon Sep 17 00:00:00 2001
From: Turo Lamminen <turol@iki.fi>
Date: Mon, 22 Feb 2021 15:16:15 +0200
Subject: [PATCH 27/30] [3MF] Silence uninitialized variable warning

This is a false positive but the compiler can't see it
---
 code/AssetLib/3MF/D3MFImporter.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/code/AssetLib/3MF/D3MFImporter.cpp b/code/AssetLib/3MF/D3MFImporter.cpp
index 66b2c965b..4ee8946f1 100644
--- a/code/AssetLib/3MF/D3MFImporter.cpp
+++ b/code/AssetLib/3MF/D3MFImporter.cpp
@@ -427,7 +427,7 @@ private:
                 aiFace face = ReadTriangle(currentNode);
                 faces.push_back(face);
 
-                int pid, p1;
+                int pid = 0, p1;
                 bool hasPid = getNodeAttribute(currentNode, D3MF::XmlTag::pid, pid);
                 bool hasP1 = getNodeAttribute(currentNode, D3MF::XmlTag::p1, p1);
 

From facb7da701e8153c8279a5ffd3b14a75d11b7501 Mon Sep 17 00:00:00 2001
From: "Max Vollmer (Microsoft Havok)"
 <60260460+ms-maxvollmer@users.noreply.github.com>
Date: Wed, 24 Feb 2021 14:19:29 +0000
Subject: [PATCH 28/30] Check that normal count and tangent count matches
 vertex count. Ignore data and warn if counts don't match.

---
 code/AssetLib/glTF2/glTF2Importer.cpp | 34 +++++++++++++++++----------
 1 file changed, 21 insertions(+), 13 deletions(-)

diff --git a/code/AssetLib/glTF2/glTF2Importer.cpp b/code/AssetLib/glTF2/glTF2Importer.cpp
index 0eba5512b..fb91d8ac3 100644
--- a/code/AssetLib/glTF2/glTF2Importer.cpp
+++ b/code/AssetLib/glTF2/glTF2Importer.cpp
@@ -452,24 +452,32 @@ void glTF2Importer::ImportMeshes(glTF2::Asset &r) {
             }
 
             if (attr.normal.size() > 0 && attr.normal[0]) {
-                attr.normal[0]->ExtractData(aim->mNormals);
+                if (attr.normal[0]->count != aim->mNumVertices) {
+                    DefaultLogger::get()->warn("Normal count in mesh \"" + mesh.name + "\" does not match the vertex count");
+                } else {
+                    attr.normal[0]->ExtractData(aim->mNormals);
 
-                // only extract tangents if normals are present
-                if (attr.tangent.size() > 0 && attr.tangent[0]) {
-                    // generate bitangents from normals and tangents according to spec
-                    Tangent *tangents = nullptr;
+                    // only extract tangents if normals are present
+                    if (attr.tangent.size() > 0 && attr.tangent[0]) {
+                        if (attr.tangent[0]->count != aim->mNumVertices) {
+                            DefaultLogger::get()->warn("Tangent count in mesh \"" + mesh.name + "\" does not match the vertex count");
+                        } else {
+                            // generate bitangents from normals and tangents according to spec
+                            Tangent *tangents = nullptr;
 
-                    attr.tangent[0]->ExtractData(tangents);
+                            attr.tangent[0]->ExtractData(tangents);
 
-                    aim->mTangents = new aiVector3D[aim->mNumVertices];
-                    aim->mBitangents = new aiVector3D[aim->mNumVertices];
+                            aim->mTangents = new aiVector3D[aim->mNumVertices];
+                            aim->mBitangents = new aiVector3D[aim->mNumVertices];
 
-                    for (unsigned int i = 0; i < aim->mNumVertices; ++i) {
-                        aim->mTangents[i] = tangents[i].xyz;
-                        aim->mBitangents[i] = (aim->mNormals[i] ^ tangents[i].xyz) * tangents[i].w;
+                            for (unsigned int i = 0; i < aim->mNumVertices; ++i) {
+                                aim->mTangents[i] = tangents[i].xyz;
+                                aim->mBitangents[i] = (aim->mNormals[i] ^ tangents[i].xyz) * tangents[i].w;
+                            }
+
+                            delete[] tangents;
+                        }
                     }
-
-                    delete[] tangents;
                 }
             }
 

From eef03c1f175e5d8e8e6a9796cd2f546a457c04be Mon Sep 17 00:00:00 2001
From: "Max Vollmer (Microsoft Havok)"
 <60260460+ms-maxvollmer@users.noreply.github.com>
Date: Wed, 24 Feb 2021 14:28:18 +0000
Subject: [PATCH 29/30] Improved warnings

---
 code/AssetLib/glTF2/glTF2Importer.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/code/AssetLib/glTF2/glTF2Importer.cpp b/code/AssetLib/glTF2/glTF2Importer.cpp
index fb91d8ac3..78ee446e2 100644
--- a/code/AssetLib/glTF2/glTF2Importer.cpp
+++ b/code/AssetLib/glTF2/glTF2Importer.cpp
@@ -453,14 +453,14 @@ void glTF2Importer::ImportMeshes(glTF2::Asset &r) {
 
             if (attr.normal.size() > 0 && attr.normal[0]) {
                 if (attr.normal[0]->count != aim->mNumVertices) {
-                    DefaultLogger::get()->warn("Normal count in mesh \"" + mesh.name + "\" does not match the vertex count");
+                    DefaultLogger::get()->warn("Normal count in mesh \"" + mesh.name + "\" does not match the vertex count, normals ignored.");
                 } else {
                     attr.normal[0]->ExtractData(aim->mNormals);
 
                     // only extract tangents if normals are present
                     if (attr.tangent.size() > 0 && attr.tangent[0]) {
                         if (attr.tangent[0]->count != aim->mNumVertices) {
-                            DefaultLogger::get()->warn("Tangent count in mesh \"" + mesh.name + "\" does not match the vertex count");
+                            DefaultLogger::get()->warn("Tangent count in mesh \"" + mesh.name + "\" does not match the vertex count, tangents ignored.");
                         } else {
                             // generate bitangents from normals and tangents according to spec
                             Tangent *tangents = nullptr;

From aa6f98392014e2e885238e321786d7fcbffe88fd Mon Sep 17 00:00:00 2001
From: Kim Kulling <kimkulling@users.noreply.github.com>
Date: Thu, 25 Feb 2021 14:01:18 +0100
Subject: [PATCH 30/30] Remove buggy assert

- Remove assertion test for empty nodestacks when no meshes are in the node. Just return from the function.
- closes https://github.com/assimp/assimp/issues/3664
---
 code/PostProcessing/ArmaturePopulate.cpp | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/code/PostProcessing/ArmaturePopulate.cpp b/code/PostProcessing/ArmaturePopulate.cpp
index 48dcecb15..fa5113a41 100644
--- a/code/PostProcessing/ArmaturePopulate.cpp
+++ b/code/PostProcessing/ArmaturePopulate.cpp
@@ -124,13 +124,13 @@ void ArmaturePopulate::BuildBoneList(aiNode *current_node,
 
             for (unsigned int boneId = 0; boneId < mesh->mNumBones; ++boneId) {
                 aiBone *bone = mesh->mBones[boneId];
-                ai_assert(bone);
+                ai_assert(nullptr != bone);
 
                 // duplicate mehes exist with the same bones sometimes :)
                 // so this must be detected
                 if (std::find(bones.begin(), bones.end(), bone) == bones.end()) {
                     // add the element once
-                    bones.push_back(bone);
+                    bones.emplace_back(bone);
                 }
             }
 
@@ -145,14 +145,14 @@ void ArmaturePopulate::BuildBoneList(aiNode *current_node,
 // Prepare flat node list which can be used for non recursive lookups later
 void ArmaturePopulate::BuildNodeList(const aiNode *current_node,
                                      std::vector<aiNode *> &nodes) {
-    ai_assert(current_node);
+    ai_assert(nullptr != current_node);
 
     for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
         aiNode *child = current_node->mChildren[nodeId];
         ai_assert(child);
 
         if (child->mNumMeshes == 0) {
-            nodes.push_back(child);
+            nodes.emplace_back(child);
         }
 
         BuildNodeList(child, nodes);
@@ -168,8 +168,10 @@ void ArmaturePopulate::BuildBoneStack(aiNode *,
                                       const std::vector<aiBone *> &bones,
                                       std::map<aiBone *, aiNode *> &bone_stack,
                                   std::vector<aiNode *> &node_stack) {
-    ai_assert(root_node);
-    ai_assert(!node_stack.empty());
+    if (node_stack.empty()) {
+        return;
+    }
+    ai_assert(nullptr != root_node);
 
     for (aiBone *bone : bones) {
         ai_assert(bone);
@@ -181,7 +183,7 @@ void ArmaturePopulate::BuildBoneStack(aiNode *,
 
             node = GetNodeFromStack(bone->mName, node_stack);
 
-            if (!node) {
+            if (nullptr == node) {
                 ASSIMP_LOG_ERROR("serious import issue node for bone was not detected");
                 continue;
             }
@@ -199,7 +201,7 @@ void ArmaturePopulate::BuildBoneStack(aiNode *,
 // points. (yet)
 aiNode *ArmaturePopulate::GetArmatureRoot(aiNode *bone_node,
                                           std::vector<aiBone *> &bone_list) {
-    while (bone_node) {
+    while (nullptr != bone_node) {
         if (!IsBoneNode(bone_node->mName, bone_list)) {
             ASSIMP_LOG_VERBOSE_DEBUG_F("GetArmatureRoot() Found valid armature: ", bone_node->mName.C_Str());
             return bone_node;
@@ -236,7 +238,7 @@ aiNode *ArmaturePopulate::GetNodeFromStack(const aiString &node_name,
     aiNode *found = nullptr;
     for (iter = nodes.begin(); iter < nodes.end(); ++iter) {
         aiNode *element = *iter;
-        ai_assert(element);
+        ai_assert(nullptr != element);
         // node valid and node name matches
         if (element->mName == node_name) {
             found = element;