#1126 gltf scene import prototype (#1172)

* #1126 GLTF Scene import initial prototype (working geometry import for some assets)

* #1126 WIP -- Expand support for more vertex formats, PoC material import, shadow support, scale support

* #1126 move GLTF implementation to newview/gltf

* #1126 Refactor attribute loading to be less copy/pasta for each combination of types

* #1126 Partially working object selection.  Ability to have multiple scenes at once.  Helpful message on how to use the preview button.

* #1126 Add bounding box debug display and untangle GLTF raycast from LLVOVolume raycast

* #1126 Working raycast on GLTF scenes.

* #1126 Remove some #pragma optimize offs

1 files changed, 140 insertions, 0 deletions

diff --git a/indra/newview/gltf/primitive.h b/indra/newview/gltf/primitive.h
new file mode 100644
index 0000000000..7c47d9dac5
--- /dev/null
+++ b/indra/newview/gltf/primitive.h
@@ -0,0 +1,140 @@
+#pragma once
+
+/**
+ * @file primitive.h
+ * @brief LL GLTF Implementation
+ *
+ * $LicenseInfo:firstyear=2024&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2024, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#include "llvertexbuffer.h"
+#include "llvolumeoctree.h"
+
+// LL GLTF Implementation
+namespace LL
+{
+    namespace GLTF
+    {
+        class Asset;
+
+        constexpr U32 ATTRIBUTE_MASK =
+            LLVertexBuffer::MAP_VERTEX |
+            LLVertexBuffer::MAP_NORMAL |
+            LLVertexBuffer::MAP_TEXCOORD0 |
+            LLVertexBuffer::MAP_TANGENT |
+            LLVertexBuffer::MAP_COLOR;
+
+        class Primitive
+        {
+        public:
+            ~Primitive();
+
+            // GPU copy of mesh data
+            LLPointer<LLVertexBuffer> mVertexBuffer;
+
+            // CPU copy of mesh data
+            std::vector<LLVector2> mTexCoords;
+            std::vector<LLVector4a> mNormals;
+            std::vector<LLVector4a> mTangents;
+            std::vector<LLVector4a> mPositions;
+            std::vector<U16> mIndexArray;
+
+            // raycast acceleration structure
+            LLPointer<LLVolumeOctree> mOctree;
+            std::vector<LLVolumeTriangle> mOctreeTriangles;
+            
+            S32 mMaterial = -1;
+            U32 mMode = TINYGLTF_MODE_TRIANGLES; // default to triangles
+            U32 mGLMode = LLRender::TRIANGLES;
+            S32 mIndices = -1;
+            std::unordered_map<std::string, int> mAttributes;
+
+            // copy the attribute in the given BufferView to the given destination
+            // assumes destination has enough storage for the attribute
+            template<class T>
+            void copyAttribute(Asset& asset, S32 bufferViewIdx, LLStrider<T>& dst);
+            
+            // create octree based on vertex buffer
+            // must be called before buffer is unmapped and after buffer is populated with good data
+            void createOctree();
+
+            //get the LLVolumeTriangle that intersects with the given line segment at the point 
+            //closest to start.  Moves end to the point of intersection.  Returns nullptr if no intersection.
+            //Line segment must be in the same coordinate frame as this Primitive
+            const LLVolumeTriangle* lineSegmentIntersect(const LLVector4a& start, const LLVector4a& end,
+                LLVector4a* intersection = NULL,         // return the intersection point
+                LLVector2* tex_coord = NULL,            // return the texture coordinates of the intersection point
+                LLVector4a* normal = NULL,               // return the surface normal at the intersection point
+                LLVector4a* tangent = NULL             // return the surface tangent at the intersection point
+            );
+            
+            const Primitive& operator=(const tinygltf::Primitive& src)
+            {
+                // load material
+                mMaterial = src.material;
+
+                // load mode
+                mMode = src.mode;
+
+                // load indices
+                mIndices = src.indices;
+
+                // load attributes
+                for (auto& it : src.attributes)
+                {
+                    mAttributes[it.first] = it.second;
+                }
+
+                switch (mMode)
+                {
+                case TINYGLTF_MODE_POINTS:
+                    mGLMode = LLRender::POINTS;
+                    break;
+                case TINYGLTF_MODE_LINE:
+                    mGLMode = LLRender::LINES;
+                    break;
+                case TINYGLTF_MODE_LINE_LOOP:
+                    mGLMode = LLRender::LINE_LOOP;
+                    break;
+                case TINYGLTF_MODE_LINE_STRIP:
+                    mGLMode = LLRender::LINE_STRIP;
+                    break;
+                case TINYGLTF_MODE_TRIANGLES:
+                    mGLMode = LLRender::TRIANGLES;
+                    break;
+                case TINYGLTF_MODE_TRIANGLE_STRIP:
+                    mGLMode = LLRender::TRIANGLE_STRIP;
+                    break;
+                case TINYGLTF_MODE_TRIANGLE_FAN:
+                    mGLMode = LLRender::TRIANGLE_FAN;
+                    break;
+                default:
+                    mGLMode = GL_TRIANGLES;
+                }
+
+                return *this;
+            }
+
+            void allocateGLResources(Asset& asset);
+        };
+    }
+}