GPU Instancing Experiment

indra/llappearance/llavatarappearance.cpp

@@ -797,9 +797,8 @@ void LLAvatarAppearance::buildCharacter()
     LLTimer timer;
 
     bool status = loadAvatar();
-    stop_glerror();
 
-//  gPrintMessagesThisFrame = true;
+    //  gPrintMessagesThisFrame = true;
     LL_DEBUGS() << "Avatar load took " << timer.getElapsedTimeF32() << " seconds." << LL_ENDL;
 
     if (!status)
@@ -870,8 +869,6 @@ void LLAvatarAppearance::buildCharacter()
     mPelvisp->setPosition( LLVector3(0.0f, 0.0f, 0.0f) );
 
     mIsBuilt = true;
-    stop_glerror();
-
 }
 
 bool LLAvatarAppearance::loadAvatar()

indra/llappearance/lllocaltextureobject.cpp

@@ -47,7 +47,6 @@ LLLocalTextureObject::LLLocalTextureObject(LLGLTexture* image, const LLUUID& id)
     mDiscard(MAX_DISCARD_LEVEL+1)
 {
     mImage = image;
-    gGL.getTexUnit(0)->bind(mImage);
     mID = id;
 }
 

indra/llaudio/llaudioengine.cpp

@@ -195,6 +195,7 @@ LLAudioEngine::LLAudioPlayState LLAudioEngine::isInternetStreamPlaying()
 // virtual
 void LLAudioEngine::setInternetStreamGain(F32 vol)
 {
+    LL_PROFILE_ZONE_SCOPED;
     if (mStreamingAudioImpl)
         mStreamingAudioImpl->setGain(vol);
 }
@@ -211,6 +212,7 @@ std::string LLAudioEngine::getInternetStreamURL()
 
 void LLAudioEngine::updateChannels()
 {
+    LL_PROFILE_ZONE_SCOPED;
     S32 i;
     for (i = 0; i < LL_MAX_AUDIO_CHANNELS; i++)
     {
@@ -225,6 +227,7 @@ void LLAudioEngine::updateChannels()
 
 void LLAudioEngine::idle()
 {
+    LL_PROFILE_ZONE_SCOPED;
     // "Update" all of our audio sources, clean up dead ones.
     // Primarily does position updating, cleanup of unused audio sources.
     // Also does regeneration of the current priority of each audio source.
@@ -666,6 +669,7 @@ bool LLAudioEngine::isWindEnabled()
 
 void LLAudioEngine::setMuted(bool muted)
 {
+    LL_PROFILE_ZONE_SCOPED;
     if (muted != mMuted)
     {
         mMuted = muted;
@@ -676,6 +680,7 @@ void LLAudioEngine::setMuted(bool muted)
 
 void LLAudioEngine::setMasterGain(const F32 gain)
 {
+    LL_PROFILE_ZONE_SCOPED;
     mMasterGain = gain;
     F32 internal_gain = getMuted() ? 0.f : gain;
     if (internal_gain != mInternalGain)
@@ -859,6 +864,7 @@ void LLAudioEngine::setListener(LLVector3 pos, LLVector3 vel, LLVector3 up, LLVe
 
 void LLAudioEngine::setDopplerFactor(F32 factor)
 {
+    LL_PROFILE_ZONE_SCOPED;
     if (mListenerp)
     {
         mListenerp->setDopplerFactor(factor);
@@ -881,6 +887,7 @@ F32 LLAudioEngine::getDopplerFactor()
 
 void LLAudioEngine::setRolloffFactor(F32 factor)
 {
+    LL_PROFILE_ZONE_SCOPED;
     if (mListenerp)
     {
         mListenerp->setRolloffFactor(factor);

indra/llcommon/llsafehandle.h

@@ -170,6 +170,7 @@ class LLSafeHandle
         }
     }
 
+ public:
     // Define an LLSingleton whose sole purpose is to hold a "null instance"
     // of the subject Type: the canonical instance to dereference if this
     // LLSafeHandle actually holds a null pointer. We use LLSingleton
@@ -178,11 +179,10 @@ class LLSafeHandle
     // Of course, as with any LLSingleton, the "null instance" is only
     // instantiated on demand -- in this case, if you actually try to
     // dereference an LLSafeHandle containing null.
-    class NullInstanceHolder: public LLSingleton<NullInstanceHolder>
+    class NullInstanceHolder: public LLSimpleton<NullInstanceHolder>
     {
-        LLSINGLETON_EMPTY_CTOR(NullInstanceHolder);
-        ~NullInstanceHolder() {}
     public:
+        ~NullInstanceHolder() {}
         Type mNullInstance;
     };
 

indra/llcommon/lltraceaccumulators.cpp

@@ -214,7 +214,7 @@ void SampleAccumulator::reset(const SampleAccumulator* other)
     mMin = mLastValue;
     mMax = mLastValue;
     mMean = mLastValue;
-    llassert(!mHasValue || mMean < 0 || mMean >= 0);
+    //llassert(!mHasValue || mMean < 0 || mMean >= 0);
     mSumOfSquares = 0;
     mLastSampleTimeStamp = LLTimer::getTotalSeconds();
     mTotalSamplingTime = 0;

indra/llmath/llmatrix4a.h

@@ -34,13 +34,26 @@
 class LLMatrix4a
 {
 public:
-    LL_ALIGN_16(LLVector4a mMatrix[4]);
+    union
+    {
+        LLVector4a mMatrix[4];
+        LLMatrix4 mMatrix4;
+    };
 
     LLMatrix4a()
     {
 
     }
 
+    ~LLMatrix4a()
+    {
+    }
+
+    LLMatrix4a(const LLMatrix4a& rhs)
+    {
+        *this = rhs;
+    }
+
     explicit LLMatrix4a(const LLMatrix4& val)
     {
         loadu(val);
@@ -51,6 +64,16 @@ class LLMatrix4a
         loadu(val);
     }
 
+    inline const LLMatrix4a& operator=(const LLMatrix4a& rhs)
+    {
+        mMatrix[0] = rhs.mMatrix[0];
+        mMatrix[1] = rhs.mMatrix[1];
+        mMatrix[2] = rhs.mMatrix[2];
+        mMatrix[3] = rhs.mMatrix[3];
+
+        return *this;
+    }
+
     static const LLMatrix4a& identity()
     {
         static const F32 v[] =

indra/llmath/llvolume.cpp

@@ -2320,6 +2320,7 @@ bool LLVolume::unpackVolumeFaces(U8* in_data, S32 size)
 bool LLVolume::unpackVolumeFacesInternal(const LLSD& mdl)
 {
     {
+        mVertexBuffer = nullptr;
         auto face_count = mdl.size();
 
         if (face_count == 0)
@@ -2764,9 +2765,103 @@ bool LLVolume::cacheOptimize(bool gen_tangents)
             return false;
         }
     }
+
     return true;
 }
 
+extern U32 ll_gl_gen_arrays();
+
+static bool validate_vertex_buffer(LLVolume* volume)
+{
+    if (volume->mVertexBuffer.isNull())
+    {
+        // allowed to be null
+        return true;
+    }
+
+    U32 num_verts = 0;
+    U32 num_indices = 0;
+    for (auto& face: volume->getVolumeFaces())
+    {
+        num_verts += face.mNumVertices;
+        num_indices += face.mNumIndices;
+    }
+
+    bool same_verts = num_verts == volume->mVertexBuffer->getNumVerts();
+    bool same_indices = num_indices == volume->mVertexBuffer->getNumIndices();
+
+    return same_verts && same_indices;
+}
+
+void LLVolume::createVertexBuffer()
+{
+    if (getNumFaces() && (mVertexBuffer.isNull() || !validate_vertex_buffer(this)))
+    {
+        LL_PROFILE_ZONE_SCOPED;
+
+        U32 mask = LLVertexBuffer::MAP_VERTEX | LLVertexBuffer::MAP_NORMAL | LLVertexBuffer::MAP_TEXCOORD0 | LLVertexBuffer::MAP_TANGENT;
+        U32 vert_count = 0;
+        U32 index_count = 0;
+        for (auto& face : mVolumeFaces)
+        {
+            face.mVBGeomOffset = vert_count;
+            face.mVBIndexOffset = index_count;
+
+            vert_count += face.mNumVertices;
+            index_count += face.mNumIndices;
+
+            if (face.mWeights)
+            {
+                mask |= LLVertexBuffer::MAP_WEIGHT4;
+            }
+        }
+
+        bool large_indices = vert_count >= 65536;
+
+        mVertexBuffer = new LLVertexBuffer(mask);
+        if (large_indices)
+        {
+            mVertexBuffer->setIndicesType(GL_UNSIGNED_INT);
+        }
+        mVertexBuffer->allocateBuffer(vert_count, index_count);
+
+        mVertexBuffer->bindBuffer();
+
+        for (auto& face : mVolumeFaces)
+        {
+            face.mVertexBuffer = mVertexBuffer;
+            // ensure tangents have been created
+            face.createTangents();
+            mVertexBuffer->setPositionData(face.mPositions, face.mVBGeomOffset, face.mNumVertices);
+            mVertexBuffer->setNormalData(face.mNormals, face.mVBGeomOffset, face.mNumVertices);
+            mVertexBuffer->setTexCoord0Data(face.mTexCoords, face.mVBGeomOffset, face.mNumVertices);
+            mVertexBuffer->setTangentData(face.mTangents, face.mVBGeomOffset, face.mNumVertices);
+            if (face.mWeights)
+            {
+                mVertexBuffer->setWeight4Data(face.mWeights, face.mVBGeomOffset, face.mNumVertices);
+            }
+
+            if (face.mVBGeomOffset > 0)
+            {
+                static std::vector<U16> indices;
+                indices.resize(0);
+                for (S32 i = 0; i < face.mNumIndices; ++i)
+                {
+                    indices.push_back(face.mIndices[i] + face.mVBGeomOffset);
+                }
+                mVertexBuffer->setIndexData(&indices[0], face.mVBIndexOffset, face.mNumIndices);
+            }
+            else
+            {
+                mVertexBuffer->setIndexData(face.mIndices, face.mVBIndexOffset, face.mNumIndices);
+            }
+        }
+
+#if LL_DARWIN
+        mVertexBuffer->unmapBuffer();
+#endif
+    }
+}
 
 S32 LLVolume::getNumFaces() const
 {

indra/llmath/llvolume.h

@@ -59,6 +59,7 @@ class LLVolumeOctree;
 #include "llfile.h"
 #include "llalignedarray.h"
 #include "llrigginginfo.h"
+#include "../llrender/llvertexbuffer.h"
 
 //============================================================================
 
@@ -976,6 +977,13 @@ class LLVolumeFace
     // mWeights.size() should be empty or match mVertices.size()
     LLVector4a* mWeights;
 
+    // vertex buffer that contains this face's geometry (may be null)
+    LLPointer<LLVertexBuffer> mVertexBuffer;
+    // offset into mVertexBuffer where this face's geometry starts
+    U32 mVBGeomOffset = 0;
+    // offset into mVertexBuffe where this face's indices start
+    U32 mVBIndexOffset = 0;
+
 #if USE_SEPARATE_JOINT_INDICES_AND_WEIGHTS
     LLVector4a* mJustWeights;
     U8* mJointIndices;
@@ -1102,6 +1110,8 @@ class LLVolume : public LLRefCount
     //  gen_tangents - if true, generate MikkTSpace tangents if needed before optimizing index buffer
     bool cacheOptimize(bool gen_tangents = false);
 
+    void createVertexBuffer();
+
 private:
     void sculptGenerateMapVertices(U16 sculpt_width, U16 sculpt_height, S8 sculpt_components, const U8* sculpt_data, U8 sculpt_type);
     F32 sculptGetSurfaceArea();
@@ -1141,6 +1151,8 @@ class LLVolume : public LLRefCount
     face_list_t mVolumeFaces;
 
 public:
+    LLPointer<LLVertexBuffer> mVertexBuffer;
+
     LLVector4a* mHullPoints;
     U16* mHullIndices;
     S32 mNumHullPoints;

indra/llmath/v2math.h

@@ -437,4 +437,11 @@ inline std::ostream& operator<<(std::ostream& s, const LLVector2& a)
     return s;
 }
 
+// For use with boost containers.
+inline size_t hash_value(const LLVector2& v) noexcept
+{
+    return boost::hash_range(v.mV, v.mV + 1);
+}
+
+
 #endif

indra/llmath/v3color.h

@@ -507,4 +507,11 @@ void LLColor3::write(std::vector<T>& v) const
     }
 }
 
+inline size_t hash_value(const LLColor3& c) noexcept
+{
+    size_t hash = 0;
+    boost::hash_range(hash, (F32*) c.mV, (F32*) c.mV + 2);
+    return hash;
+}
+
 #endif

indra/llmath/v4color.h

@@ -674,4 +674,11 @@ void LLColor4::write(std::vector<T>& v) const
     }
 }
 
+inline size_t hash_value(const LLColor4& c) noexcept
+{
+    size_t hash = 0;
+    boost::hash_range(hash, (F32*)c.mV, (F32*)c.mV + 3);
+    return hash;
+}
+
 #endif

indra/llmath/v4coloru.h

@@ -495,4 +495,10 @@ inline void LLColor4U::fromRGBA(U32 aVal)
     mV[3] = aVal & 0xFF;
 }
 
+// For use with boost containers.
+inline size_t hash_value(const LLColor4U& c) noexcept
+{
+    return (size_t) *((U32*)c.mV);
+}
+
 #endif

indra/llprimitive/CMakeLists.txt

@@ -73,14 +73,14 @@ target_link_libraries(llprimitive
         )
 
 #add unit tests
-if (LL_TESTS)
-    INCLUDE(LLAddBuildTest)
-    SET(llprimitive_TEST_SOURCE_FILES
-      llmediaentry.cpp
-      llprimitive.cpp
-      llgltfmaterial.cpp
-      )
-
-    set_property(SOURCE llprimitive.cpp PROPERTY LL_TEST_ADDITIONAL_LIBRARIES llmessage)
-    LL_ADD_PROJECT_UNIT_TESTS(llprimitive "${llprimitive_TEST_SOURCE_FILES}")
-endif (LL_TESTS)
+#if (LL_TESTS)
+#    INCLUDE(LLAddBuildTest)
+#    SET(llprimitive_TEST_SOURCE_FILES
+#      llmediaentry.cpp
+#      llprimitive.cpp
+#      llgltfmaterial.cpp
+#      )
+#
+#    set_property(SOURCE llprimitive.cpp PROPERTY LL_TEST_ADDITIONAL_LIBRARIES llmessage)
+#    LL_ADD_PROJECT_UNIT_TESTS(llprimitive "${llprimitive_TEST_SOURCE_FILES}")
+#endif (LL_TESTS)