#1392 GLTF Upload (#1394)

* #1392 WIP -- Functional texture upload, stubbed out .bin upload.

* #1392 GLTF Upload WIP -- Emulates successful upload

Successfully uploads texture
Emulates successful .gltf and .bin upload by injecting into local asset cache.
Emulates rez from inventory by setting sculpt ID of selected object
Currently fails in tinygltf parsing due to missing .bin

* Add missing notification

* Build fix

* #1392 Add boost::json .gltf reading support.

* #1392 boost::json GLTF writing prototype

* Create gltf/README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* Update README.md

* #1392 Add ability to render directly from LL::GLTF::Material

* Fix for mac build

* Mac build fix

* #1392 AssetType and Inventory Type plumbing

* #1392 More sane error handling and scheduling of uploads.

* #1392 Actually attempt to upload glbin

* Mac build fix, upload nudge

* Mac build fix

* Fix glTF asset uploads to server

* Mac build fix (inline not static)

* More consistent inline

* Add glm, mac nudge.

* #1392 For consistency with spec, start using glm over glh:: and LLFoo

* Another attempt at placating Mac builds

* Another Mac nudge

* Mac build take 23

* #1392 Prune LLMatrix4a from GLTF namespace.

* #1392 Fix for orientation being off (glm::quat is wxyz, not xyzw)

* #1392 WIP -- Actually send the sculpt type and id, nudge readme and alpha rendering

* #1392 Working download!

* #1394 Add support for GLTFEnabled SimulatorFeature

* #1392 Review feedback

---------

Co-authored-by: Pepper Linden <3782201+rohvani@users.noreply.github.com>

1 files changed, 174 insertions, 1 deletions

diff --git a/indra/newview/gltf/accessor.cpp b/indra/newview/gltf/accessor.cpp
index 9bfdc2afa6..369ff4f240 100644
--- a/indra/newview/gltf/accessor.cpp
+++ b/indra/newview/gltf/accessor.cpp
@@ -27,8 +27,79 @@
 #include "../llviewerprecompiledheaders.h"
 
 #include "asset.h"
+#include "buffer_util.h"
 
 using namespace LL::GLTF;
+using namespace boost::json;
+
+namespace LL
+{
+    namespace GLTF
+    {
+        Accessor::Type gltf_type_to_enum(const std::string& type)
+        {
+            if (type == "SCALAR")
+            {
+                return Accessor::Type::SCALAR;
+            }
+            else if (type == "VEC2")
+            {
+                return Accessor::Type::VEC2;
+            }
+            else if (type == "VEC3")
+            {
+                return Accessor::Type::VEC3;
+            }
+            else if (type == "VEC4")
+            {
+                return Accessor::Type::VEC4;
+            }
+            else if (type == "MAT2")
+            {
+                return Accessor::Type::MAT2;
+            }
+            else if (type == "MAT3")
+            {
+                return Accessor::Type::MAT3;
+            }
+            else if (type == "MAT4")
+            {
+                return Accessor::Type::MAT4;
+            }
+
+            LL_WARNS("GLTF") << "Unknown accessor type: " << type << LL_ENDL;
+            llassert(false);
+
+            return Accessor::Type::SCALAR;
+        }
+
+        std::string enum_to_gltf_type(Accessor::Type type)
+        {
+            switch (type)
+            {
+            case Accessor::Type::SCALAR:
+                return "SCALAR";
+            case Accessor::Type::VEC2:
+                return "VEC2";
+            case Accessor::Type::VEC3:
+                return "VEC3";
+            case Accessor::Type::VEC4:
+                return "VEC4";
+            case Accessor::Type::MAT2:
+                return "MAT2";
+            case Accessor::Type::MAT3:
+                return "MAT3";
+            case Accessor::Type::MAT4:
+                return "MAT4";
+            }
+
+            LL_WARNS("GLTF") << "Unknown accessor type: " << (S32)type << LL_ENDL;
+            llassert(false);
+
+            return "SCALAR";
+        }
+    }
+}
 
 void Buffer::erase(Asset& asset, S32 offset, S32 length)
 {
@@ -48,6 +119,27 @@ void Buffer::erase(Asset& asset, S32 offset, S32 length)
     }
 }
 
+void Buffer::serialize(object& dst) const
+{
+    write(mName, "name", dst);
+    write(mUri, "uri", dst);
+    write_always(mByteLength, "byteLength", dst);
+};
+
+const Buffer& Buffer::operator=(const Value& src)
+{
+    if (src.is_object())
+    {
+        copy(src, "name", mName);
+        copy(src, "uri", mUri);
+        
+        // NOTE: DO NOT attempt to handle the uri here. 
+        // The uri is a reference to a file that is not loaded until
+        // after the json document is parsed
+    }
+    return *this;
+}
+
 const Buffer& Buffer::operator=(const tinygltf::Buffer& src)
 {
     mData = src.data;
@@ -56,6 +148,31 @@ const Buffer& Buffer::operator=(const tinygltf::Buffer& src)
     return *this;
 }
 
+
+void BufferView::serialize(object& dst) const
+{
+    write_always(mBuffer, "buffer", dst);
+    write_always(mByteLength, "byteLength", dst);
+    write(mByteOffset, "byteOffset", dst, 0);
+    write(mByteStride, "byteStride", dst, 0);
+    write(mTarget, "target", dst, -1);
+    write(mName, "name", dst);
+}
+
+const BufferView& BufferView::operator=(const Value& src)
+{
+    if (src.is_object())
+    {
+        copy(src, "buffer", mBuffer);
+        copy(src, "byteLength", mByteLength);
+        copy(src, "byteOffset", mByteOffset);
+        copy(src, "byteStride", mByteStride);
+        copy(src, "target", mTarget);
+        copy(src, "name", mName);
+    }
+    return *this;
+}
+
 const BufferView& BufferView::operator=(const tinygltf::BufferView& src)
 {
     mBuffer = src.buffer;
@@ -67,13 +184,69 @@ const BufferView& BufferView::operator=(const tinygltf::BufferView& src)
     return *this;
 }
 
+Accessor::Type tinygltf_type_to_enum(S32 type)
+{
+    switch (type)
+    {
+    case TINYGLTF_TYPE_SCALAR:
+        return Accessor::Type::SCALAR;
+    case TINYGLTF_TYPE_VEC2:
+        return Accessor::Type::VEC2;
+    case TINYGLTF_TYPE_VEC3:
+        return Accessor::Type::VEC3;
+    case TINYGLTF_TYPE_VEC4:
+        return Accessor::Type::VEC4;
+    case TINYGLTF_TYPE_MAT2:
+        return Accessor::Type::MAT2;
+    case TINYGLTF_TYPE_MAT3:
+        return Accessor::Type::MAT3;
+    case TINYGLTF_TYPE_MAT4:
+        return Accessor::Type::MAT4;
+    }
+
+    LL_WARNS("GLTF") << "Unknown tinygltf accessor type: " << type << LL_ENDL;
+    llassert(false);
+
+    return Accessor::Type::SCALAR;
+}
+
+void Accessor::serialize(object& dst) const
+{
+    write(mName, "name", dst);
+    write(mBufferView, "bufferView", dst, INVALID_INDEX);
+    write(mByteOffset, "byteOffset", dst, 0);
+    write_always(mComponentType, "componentType", dst);
+    write_always(mCount, "count", dst);
+    write_always(enum_to_gltf_type(mType), "type", dst);
+    write(mNormalized, "normalized", dst, false);
+    write(mMax, "max", dst);
+    write(mMin, "min", dst);
+}
+
+const Accessor& Accessor::operator=(const Value& src)
+{
+    if (src.is_object())
+    {
+        copy(src, "name", mName);
+        copy(src, "bufferView", mBufferView);
+        copy(src, "byteOffset", mByteOffset);
+        copy(src, "componentType", mComponentType);
+        copy(src, "count", mCount);
+        copy(src, "type", mType);
+        copy(src, "normalized", mNormalized);
+        copy(src, "max", mMax);
+        copy(src, "min", mMin);
+    }
+    return *this;
+}
+
 const Accessor& Accessor::operator=(const tinygltf::Accessor& src)
 {
     mBufferView = src.bufferView;
     mByteOffset = src.byteOffset;
     mComponentType = src.componentType;
     mCount = src.count;
-    mType = src.type;
+    mType = tinygltf_type_to_enum(src.type);
     mNormalized = src.normalized;
     mName = src.name;
     mMax = src.maxValues;