Merge branch 'develop' into nat/edu-channel

26 files changed, 596 insertions, 429 deletions

diff --git a/indra/llprimitive/CMakeLists.txt b/indra/llprimitive/CMakeLists.txt
index 2bd1edaacc..19a43839af 100644
--- a/indra/llprimitive/CMakeLists.txt
+++ b/indra/llprimitive/CMakeLists.txt
@@ -8,6 +8,7 @@ include(LLCoreHttp)
 include(LLPhysicsExtensions)
 include(LLPrimitive)
 include(GLH)
+include(GLM)
 include(TinyGLTF)
 
 set(llprimitive_SOURCE_FILES
@@ -69,7 +70,6 @@ target_link_libraries(llprimitive
         llrender
         llphysicsextensions_impl
         ll::colladadom
-        ll::pcre
         ll::glh_linear
         )
 
diff --git a/indra/llprimitive/lldaeloader.cpp b/indra/llprimitive/lldaeloader.cpp
index e8b586fdf1..3e84eeffc2 100644
--- a/indra/llprimitive/lldaeloader.cpp
+++ b/indra/llprimitive/lldaeloader.cpp
@@ -107,7 +107,7 @@ bool get_dom_sources(const domInputLocalOffset_Array& inputs, S32& pos_offset, S
             {
                 if (strcmp(COMMON_PROFILE_INPUT_POSITION, v_inp[k]->getSemantic()) == 0)
                 {
-                    pos_offset = inputs[j]->getOffset();
+                    pos_offset = (S32)inputs[j]->getOffset();
 
                     const domURIFragmentType& uri = v_inp[k]->getSource();
                     daeElementRef elem = uri.getElement();
@@ -116,7 +116,7 @@ bool get_dom_sources(const domInputLocalOffset_Array& inputs, S32& pos_offset, S
 
                 if (strcmp(COMMON_PROFILE_INPUT_NORMAL, v_inp[k]->getSemantic()) == 0)
                 {
-                    norm_offset = inputs[j]->getOffset();
+                    norm_offset = (S32)inputs[j]->getOffset();
 
                     const domURIFragmentType& uri = v_inp[k]->getSource();
                     daeElementRef elem = uri.getElement();
@@ -128,14 +128,14 @@ bool get_dom_sources(const domInputLocalOffset_Array& inputs, S32& pos_offset, S
         if (strcmp(COMMON_PROFILE_INPUT_NORMAL, inputs[j]->getSemantic()) == 0)
         {
             //found normal array for this triangle list
-            norm_offset = inputs[j]->getOffset();
+            norm_offset = (S32)inputs[j]->getOffset();
             const domURIFragmentType& uri = inputs[j]->getSource();
             daeElementRef elem = uri.getElement();
             norm_source = (domSource*) elem.cast();
         }
         else if (strcmp(COMMON_PROFILE_INPUT_TEXCOORD, inputs[j]->getSemantic()) == 0)
         { //found texCoords
-            tc_offset = inputs[j]->getOffset();
+            tc_offset = (S32)inputs[j]->getOffset();
             const domURIFragmentType& uri = inputs[j]->getSource();
             daeElementRef elem = uri.getElement();
             tc_source = (domSource*) elem.cast();
@@ -201,8 +201,8 @@ LLModel::EModelStatus load_face_from_dom_triangles(
             return LLModel::BAD_ELEMENT;
         }
         // VFExtents change
-        face.mExtents[0].set(v[0], v[1], v[2]);
-        face.mExtents[1].set(v[0], v[1], v[2]);
+        face.mExtents[0].set((F32)v[0], (F32)v[1], (F32)v[2]);
+        face.mExtents[1].set((F32)v[0], (F32)v[1], (F32)v[2]);
     }
 
     LLVolumeFace::VertexMapData::PointMap point_map;
@@ -223,25 +223,25 @@ LLModel::EModelStatus load_face_from_dom_triangles(
         LLVolumeFace::VertexData cv;
         if (pos_source)
         {
-            cv.setPosition(LLVector4a(v[idx[i+pos_offset]*3+0],
-                                v[idx[i+pos_offset]*3+1],
-                                v[idx[i+pos_offset]*3+2]));
+            cv.setPosition(LLVector4a((F32)v[idx[i+pos_offset]*3+0],
+                                (F32)v[idx[i+pos_offset]*3+1],
+                                (F32)v[idx[i+pos_offset]*3+2]));
         }
 
         if (tc_source)
         {
-            cv.mTexCoord.setVec(tc[idx[i+tc_offset]*2+0],
-                                tc[idx[i+tc_offset]*2+1]);
+            cv.mTexCoord.setVec((F32)tc[idx[i+tc_offset]*2+0],
+                                (F32)tc[idx[i+tc_offset]*2+1]);
         }
 
         if (norm_source)
         {
-            cv.setNormal(LLVector4a(n[idx[i+norm_offset]*3+0],
-                                n[idx[i+norm_offset]*3+1],
-                                n[idx[i+norm_offset]*3+2]));
+            cv.setNormal(LLVector4a((F32)n[idx[i+norm_offset]*3+0],
+                                (F32)n[idx[i+norm_offset]*3+1],
+                                (F32)n[idx[i+norm_offset]*3+2]));
         }
 
-        BOOL found = FALSE;
+        bool found = false;
 
         LLVolumeFace::VertexMapData::PointMap::iterator point_iter;
         point_iter = point_map.find(LLVector3(cv.getPosition().getF32ptr()));
@@ -258,7 +258,7 @@ LLModel::EModelStatus load_face_from_dom_triangles(
 
                     // Don't share verts within the same tri, degenerate
                     //
-                    U32 indx_size = indices.size();
+                    U32 indx_size = static_cast<U32>(indices.size());
                     U32 verts_new_tri = indx_size % 3;
                     if ((verts_new_tri < 1 || indices[indx_size - 1] != shared_index)
                         && (verts_new_tri < 2 || indices[indx_size - 2] != shared_index))
@@ -326,8 +326,8 @@ LLModel::EModelStatus load_face_from_dom_triangles(
 
             face = LLVolumeFace();
             // VFExtents change
-            face.mExtents[0].set(v[0], v[1], v[2]);
-            face.mExtents[1].set(v[0], v[1], v[2]);
+            face.mExtents[0].set((F32)v[0], (F32)v[1], (F32)v[2]);
+            face.mExtents[1].set((F32)v[0], (F32)v[1], (F32)v[2]);
 
             verts.clear();
             indices.clear();
@@ -416,8 +416,8 @@ LLModel::EModelStatus load_face_from_dom_polylist(
     {
         v = pos_source->getFloat_array()->getValue();
         // VFExtents change
-        face.mExtents[0].set(v[0], v[1], v[2]);
-        face.mExtents[1].set(v[0], v[1], v[2]);
+        face.mExtents[0].set((F32)v[0], (F32)v[1], (F32)v[2]);
+        face.mExtents[1].set((F32)v[0], (F32)v[1], (F32)v[2]);
     }
 
     if (tc_source)
@@ -445,9 +445,9 @@ LLModel::EModelStatus load_face_from_dom_polylist(
 
             if (pos_source)
             {
-                cv.getPosition().set(v[idx[cur_idx+pos_offset]*3+0],
-                                    v[idx[cur_idx+pos_offset]*3+1],
-                                    v[idx[cur_idx+pos_offset]*3+2]);
+                cv.getPosition().set((F32)v[idx[cur_idx+pos_offset]*3+0],
+                                    (F32)v[idx[cur_idx+pos_offset]*3+1],
+                                    (F32)v[idx[cur_idx+pos_offset]*3+2]);
                 if (!cv.getPosition().isFinite3())
                 {
                     LL_WARNS() << "Found NaN while loading position data from DAE-Model, invalid model." << LL_ENDL;
@@ -465,7 +465,7 @@ LLModel::EModelStatus load_face_from_dom_polylist(
 
                 if (idx_y < tc.getCount())
                 {
-                    cv.mTexCoord.setVec(tc[idx_x], tc[idx_y]);
+                    cv.mTexCoord.setVec((F32)tc[idx_x], (F32)tc[idx_y]);
                 }
                 else if (log_tc_msg)
                 {
@@ -479,9 +479,9 @@ LLModel::EModelStatus load_face_from_dom_polylist(
 
             if (norm_source)
             {
-                cv.getNormal().set(n[idx[cur_idx+norm_offset]*3+0],
-                                    n[idx[cur_idx+norm_offset]*3+1],
-                                    n[idx[cur_idx+norm_offset]*3+2]);
+                cv.getNormal().set((F32)n[idx[cur_idx+norm_offset]*3+0],
+                                    (F32)n[idx[cur_idx+norm_offset]*3+1],
+                                    (F32)n[idx[cur_idx+norm_offset]*3+2]);
 
                 if (!cv.getNormal().isFinite3())
                 {
@@ -496,7 +496,7 @@ LLModel::EModelStatus load_face_from_dom_polylist(
 
             cur_idx += idx_stride;
 
-            BOOL found = FALSE;
+            bool found = false;
 
             LLVolumeFace::VertexMapData::PointMap::iterator point_iter;
             LLVector3 pos3(cv.getPosition().getF32ptr());
@@ -508,7 +508,7 @@ LLModel::EModelStatus load_face_from_dom_polylist(
                 {
                     if ((point_iter->second)[k] == cv)
                     {
-                        found = TRUE;
+                        found = true;
                         U32 index = (point_iter->second)[k].mIndex;
                         if (j == 0)
                         {
@@ -607,8 +607,8 @@ LLModel::EModelStatus load_face_from_dom_polylist(
 
                 face = LLVolumeFace();
                 // VFExtents change
-                face.mExtents[0].set(v[0], v[1], v[2]);
-                face.mExtents[1].set(v[0], v[1], v[2]);
+                face.mExtents[0].set((F32)v[0], (F32)v[1], (F32)v[2]);
+                face.mExtents[1].set((F32)v[0], (F32)v[1], (F32)v[2]);
                 verts.clear();
                 indices.clear();
                 point_map.clear();
@@ -669,7 +669,7 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector<LLVolumeFace>& fac
 
         if (strcmp(COMMON_PROFILE_INPUT_VERTEX, inputs[i]->getSemantic()) == 0)
         { //found vertex array
-            v_offset = inputs[i]->getOffset();
+            v_offset = (S32)inputs[i]->getOffset();
 
             const domURIFragmentType& uri = inputs[i]->getSource();
             daeElementRef elem = uri.getElement();
@@ -697,7 +697,7 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector<LLVolumeFace>& fac
         }
         else if (strcmp(COMMON_PROFILE_INPUT_NORMAL, inputs[i]->getSemantic()) == 0)
         {
-            n_offset = inputs[i]->getOffset();
+            n_offset = (S32)inputs[i]->getOffset();
             //found normal array for this triangle list
             const domURIFragmentType& uri = inputs[i]->getSource();
             daeElementRef elem = uri.getElement();
@@ -710,7 +710,7 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector<LLVolumeFace>& fac
         }
         else if (strcmp(COMMON_PROFILE_INPUT_TEXCOORD, inputs[i]->getSemantic()) == 0 && inputs[i]->getSet() == 0)
         { //found texCoords
-            t_offset = inputs[i]->getOffset();
+            t_offset = (S32)inputs[i]->getOffset();
             const domURIFragmentType& uri = inputs[i]->getSource();
             daeElementRef elem = uri.getElement();
             domSource* src = (domSource*) elem.cast();
@@ -732,7 +732,7 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector<LLVolumeFace>& fac
         { //for each vertex
             if (j > 2)
             {
-                U32 size = verts.size();
+                auto size = verts.size();
                 LLVolumeFace::VertexData v0 = verts[size-3];
                 LLVolumeFace::VertexData v1 = verts[size-1];
 
@@ -745,11 +745,11 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector<LLVolumeFace>& fac
 
             if (v)
             {
-                U32 v_idx = idx[j*stride+v_offset]*3;
+                U32 v_idx = (U32)idx[j*stride+v_offset]*3;
                 v_idx = llclamp(v_idx, (U32) 0, (U32) v->getCount());
-                vert.getPosition().set(v->get(v_idx),
-                                v->get(v_idx+1),
-                                v->get(v_idx+2));
+                vert.getPosition().set((F32)v->get(v_idx),
+                                (F32)v->get(v_idx+1),
+                                (F32)v->get(v_idx+2));
             }
 
             //bounds check n and t lookups because some FBX to DAE converters
@@ -757,11 +757,11 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector<LLVolumeFace>& fac
             //for a particular channel
             if (n && n->getCount() > 0)
             {
-                U32 n_idx = idx[j*stride+n_offset]*3;
+                U32 n_idx = (U32)idx[j*stride+n_offset]*3;
                 n_idx = llclamp(n_idx, (U32) 0, (U32) n->getCount());
-                vert.getNormal().set(n->get(n_idx),
-                                n->get(n_idx+1),
-                                n->get(n_idx+2));
+                vert.getNormal().set((F32)n->get(n_idx),
+                                (F32)n->get(n_idx+1),
+                                (F32)n->get(n_idx+2));
             }
             else
             {
@@ -771,10 +771,10 @@ LLModel::EModelStatus load_face_from_dom_polygons(std::vector<LLVolumeFace>& fac
 
             if (t && t->getCount() > 0)
             {
-                U32 t_idx = idx[j*stride+t_offset]*2;
+                U32 t_idx = (U32)idx[j*stride+t_offset]*2;
                 t_idx = llclamp(t_idx, (U32) 0, (U32) t->getCount());
-                vert.mTexCoord.setVec(t->get(t_idx),
-                                t->get(t_idx+1));
+                vert.mTexCoord.setVec((F32)t->get(t_idx),
+                                (F32)t->get(t_idx+1));
             }
             else
             {
@@ -1000,9 +1000,9 @@ bool LLDAELoader::OpenFile(const std::string& filename)
 
     //Verify some basic properties of the dae
     //1. Basic validity check on controller
-    U32 controllerCount = (int) db->getElementCount( NULL, "controller" );
+    U32 controllerCount = db->getElementCount(NULL, "controller");
     bool result = false;
-    for ( int i=0; i<controllerCount; ++i )
+    for (U32 i = 0; i < controllerCount; ++i)
     {
         domController* pController = NULL;
         db->getElement( (daeElement**) &pController, i , NULL, "controller" );
@@ -1026,7 +1026,7 @@ bool LLDAELoader::OpenFile(const std::string& filename)
 
     if (unit)
     {
-        F32 meter = unit->getMeter();
+        F32 meter = (F32)unit->getMeter();
         mTransform.mMatrix[0][0] = meter;
         mTransform.mMatrix[1][1] = meter;
         mTransform.mMatrix[2][2] = meter;
@@ -1098,7 +1098,7 @@ bool LLDAELoader::OpenFile(const std::string& filename)
     while (model_iter != mModelList.end())
     {
         LLModel* mdl = *model_iter;
-        U32 material_count = mdl->mMaterialList.size();
+        U32 material_count = static_cast<U32>(mdl->mMaterialList.size());
         LL_INFOS() << "Importing " << mdl->mLabel << " model with " << material_count << " material references" << LL_ENDL;
         std::vector<std::string>::iterator mat_iter = mdl->mMaterialList.begin();
         std::vector<std::string>::iterator end_iter = material_count > LIMIT_MATERIALS_OUTPUT
@@ -1241,7 +1241,7 @@ void LLDAELoader::processDomModel(LLModel* model, DAE* dae, daeElement* root, do
             {
                 for(int j = 0; j < 4; j++)
                 {
-                    mat.mMatrix[i][j] = dom_value[i + j*4];
+                    mat.mMatrix[i][j] = (F32)dom_value[i + j*4];
                 }
             }
 
@@ -1255,7 +1255,7 @@ void LLDAELoader::processDomModel(LLModel* model, DAE* dae, daeElement* root, do
         //Some collada setup for accessing the skeleton
         U32 skeleton_count = dae->getDatabase()->getElementCount( NULL, "skeleton" );
         std::vector<domInstance_controller::domSkeleton*> skeletons;
-        for (S32 i=0; i<skeleton_count; i++)
+        for (U32 i = 0; i < skeleton_count; i++)
         {
             daeElement* pElement = 0;
             dae->getDatabase()->getElement( &pElement, i, 0, "skeleton" );
@@ -1287,11 +1287,11 @@ void LLDAELoader::processDomModel(LLModel* model, DAE* dae, daeElement* root, do
             {
                 //Get the children at this level
                 daeTArray< daeSmartRef<daeElement> > children = pScene->getChildren();
-                S32 childCount = children.getCount();
+                auto childCount = children.getCount();
 
                 //Process any children that are joints
                 //Not all children are joints, some could be ambient lights, cameras, geometry etc..
-                for (S32 i = 0; i < childCount; ++i)
+                for (size_t i = 0; i < childCount; ++i)
                 {
                     domNode* pNode = daeSafeCast<domNode>(children[i]);
                     if (pNode)
@@ -1312,7 +1312,7 @@ void LLDAELoader::processDomModel(LLModel* model, DAE* dae, daeElement* root, do
                 if ( pSkeletonRootNode )
                 {
                     //Once we have the root node - start acccessing it's joint components
-                    const int jointCnt = mJointMap.size();
+                    const int jointCnt = static_cast<int>(mJointMap.size());
                     JointMap :: const_iterator jointIt = mJointMap.begin();
 
                     //Loop over all the possible joints within the .dae - using the allowed joint list in the ctor.
@@ -1453,9 +1453,9 @@ void LLDAELoader::processDomModel(LLModel* model, DAE* dae, daeElement* root, do
                     if (t)
                     {
                         domListOfFloats& transform = t->getValue();
-                        S32 count = transform.getCount()/16;
+                        auto count = transform.getCount()/16;
 
-                        for (S32 k = 0; k < count; ++k)
+                        for (size_t k = 0; k < count; ++k)
                         {
                             LLMatrix4 mat;
 
@@ -1463,7 +1463,7 @@ void LLDAELoader::processDomModel(LLModel* model, DAE* dae, daeElement* root, do
                             {
                                 for(int j = 0; j < 4; j++)
                                 {
-                                    mat.mMatrix[i][j] = transform[k*16 + i + j*4];
+                                    mat.mMatrix[i][j] = (F32)transform[k*16 + i + j*4];
                                 }
                             }
                             model->mSkinInfo.mInvBindMatrix.push_back(LLMatrix4a(mat));
@@ -1531,7 +1531,7 @@ void LLDAELoader::processDomModel(LLModel* model, DAE* dae, daeElement* root, do
         //with the skeleton are not stored in the same order as they are in the exported joint buffer.
         //This remaps the skeletal joints to be in the same order as the joints stored in the model.
         std::vector<std::string> :: const_iterator jointIt  = model->mSkinInfo.mJointNames.begin();
-        const int jointCnt = model->mSkinInfo.mJointNames.size();
+        const int jointCnt = static_cast<int>(model->mSkinInfo.mJointNames.size());
         for ( int i=0; i<jointCnt; ++i, ++jointIt )
         {
             std::string lookingForJoint = (*jointIt).c_str();
@@ -1550,7 +1550,7 @@ void LLDAELoader::processDomModel(LLModel* model, DAE* dae, daeElement* root, do
             }
         }
 
-        U32 bind_count = model->mSkinInfo.mAlternateBindMatrix.size();
+        auto bind_count = model->mSkinInfo.mAlternateBindMatrix.size();
         if (bind_count > 0 && bind_count != jointCnt)
         {
             LL_WARNS("Mesh") << "Model " << model->mLabel << " has invalid joint bind matrix list." << LL_ENDL;
@@ -1581,7 +1581,7 @@ void LLDAELoader::processDomModel(LLModel* model, DAE* dae, daeElement* root, do
                                     LL_ERRS() << "Invalid position array size." << LL_ENDL;
                                 }
 
-                                LLVector3 v(pos[j], pos[j+1], pos[j+2]);
+                                LLVector3 v((F32)pos[j], (F32)pos[j+1], (F32)pos[j+2]);
 
                                 //transform from COLLADA space to volume space
                                 v = v * inverse_normalized_transformation;
@@ -1621,15 +1621,15 @@ void LLDAELoader::processDomModel(LLModel* model, DAE* dae, daeElement* root, do
                 U32 c_idx = 0;
                 for (size_t vc_idx = 0; vc_idx < vcount.getCount(); ++vc_idx)
                 { //for each vertex
-                    daeUInt count = vcount[vc_idx];
+                    daeUInt count = (daeUInt)vcount[vc_idx];
 
                     //create list of weights that influence this vertex
                     LLModel::weight_list weight_list;
 
                     for (daeUInt i = 0; i < count; ++i)
                     { //for each weight
-                        daeInt joint_idx = v[c_idx++];
-                        daeInt weight_idx = v[c_idx++];
+                        daeInt joint_idx = (daeInt)v[c_idx++];
+                        daeInt weight_idx = (daeInt)v[c_idx++];
 
                         if (joint_idx == -1)
                         {
@@ -1637,7 +1637,7 @@ void LLDAELoader::processDomModel(LLModel* model, DAE* dae, daeElement* root, do
                             continue;
                         }
 
-                        F32 weight_value = w[weight_idx];
+                        F32 weight_value = (F32)w[weight_idx];
 
                         weight_list.push_back(LLModel::JointWeight(joint_idx, weight_value));
                     }
@@ -1699,8 +1699,8 @@ void LLDAELoader::buildJointToNodeMappingFromScene( daeElement* pRoot )
     if ( pScene )
     {
         daeTArray< daeSmartRef<daeElement> > children = pScene->getChildren();
-        S32 childCount = children.getCount();
-        for (S32 i = 0; i < childCount; ++i)
+        auto childCount = children.getCount();
+        for (size_t i = 0; i < childCount; ++i)
         {
             domNode* pNode = daeSafeCast<domNode>(children[i]);
             processJointToNodeMapping( pNode );
@@ -1745,8 +1745,8 @@ void LLDAELoader::processJointToNodeMapping( domNode* pNode )
 void LLDAELoader::processChildJoints( domNode* pParentNode )
 {
     daeTArray< daeSmartRef<daeElement> > childOfChild = pParentNode->getChildren();
-    S32 childOfChildCount = childOfChild.getCount();
-    for (S32 i = 0; i < childOfChildCount; ++i)
+    auto childOfChildCount = childOfChild.getCount();
+    for (size_t i = 0; i < childOfChildCount; ++i)
     {
         domNode* pChildNode = daeSafeCast<domNode>( childOfChild[i] );
         if ( pChildNode )
@@ -1807,7 +1807,7 @@ bool LLDAELoader::verifyController( domController* pController )
         {
             //Skin is reference directly by geometry and get the vertex count from skin
             domSkin::domVertex_weights* pVertexWeights = pSkin->getVertex_weights();
-            U32 vertexWeightsCount = pVertexWeights->getCount();
+            U32 vertexWeightsCount = (U32)pVertexWeights->getCount();
             domGeometry* pGeometry = (domGeometry*) (domElement*) uri.getElement();
             domMesh* pMesh = pGeometry->getMesh();
 
@@ -1825,7 +1825,7 @@ bool LLDAELoader::verifyController( domController* pController )
                 {
                     xsAnyURI src = pVertices->getInput_array()[0]->getSource();
                     domSource* pSource = (domSource*) (domElement*) src.getElement();
-                    U32 verticesCount = pSource->getTechnique_common()->getAccessor()->getCount();
+                    U32 verticesCount = (U32)pSource->getTechnique_common()->getAccessor()->getCount();
                     result = verifyCount( verticesCount, vertexWeightsCount );
                     if ( !result )
                     {
@@ -1845,9 +1845,9 @@ bool LLDAELoader::verifyController( domController* pController )
             U32 sum = 0;
             for (size_t i=0; i<vcountCount; i++)
             {
-                sum += pVertexWeights->getVcount()->getValue()[i];
+                sum += (U32)pVertexWeights->getVcount()->getValue()[i];
             }
-            result = verifyCount( sum * inputs.getCount(), (domInt) pVertexWeights->getV()->getValue().getCount() );
+            result = verifyCount( sum * static_cast<U32>(inputs.getCount()), (domInt) static_cast<int>(pVertexWeights->getV()->getValue().getCount()) );
         }
     }
 
@@ -1860,7 +1860,7 @@ bool LLDAELoader::verifyController( domController* pController )
 void LLDAELoader::extractTranslation( domTranslate* pTranslate, LLMatrix4& transform )
 {
     domFloat3 jointTrans = pTranslate->getValue();
-    LLVector3 singleJointTranslation( jointTrans[0], jointTrans[1], jointTrans[2] );
+    LLVector3 singleJointTranslation((F32)jointTrans[0], (F32)jointTrans[1], (F32)jointTrans[2]);
     transform.setTranslation( singleJointTranslation );
 }
 //-----------------------------------------------------------------------------
@@ -1872,7 +1872,7 @@ void LLDAELoader::extractTranslationViaElement( daeElement* pTranslateElement, L
     {
         domTranslate* pTranslateChild = static_cast<domTranslate*>( pTranslateElement );
         domFloat3 translateChild = pTranslateChild->getValue();
-        LLVector3 singleJointTranslation( translateChild[0], translateChild[1], translateChild[2] );
+        LLVector3 singleJointTranslation((F32)translateChild[0], (F32)translateChild[1], (F32)translateChild[2]);
         transform.setTranslation( singleJointTranslation );
     }
 }
@@ -1894,7 +1894,7 @@ void LLDAELoader::extractTranslationViaSID( daeElement* pElement, LLMatrix4& tra
             {
                 for( int j = 0; j < 4; j++ )
                 {
-                    workingTransform.mMatrix[i][j] = domArray[i + j*4];
+                    workingTransform.mMatrix[i][j] = (F32)domArray[i + j*4];
                 }
             }
             LLVector3 trans = workingTransform.getTranslation();
@@ -1957,7 +1957,7 @@ void LLDAELoader::processJointNode( domNode* pNode, JointTransformMap& jointTran
                         {
                             for (int j = 0; j < 4; j++)
                             {
-                                workingTransform.mMatrix[i][j] = domArray[i + j * 4];
+                                workingTransform.mMatrix[i][j] = (F32)domArray[i + j * 4];
                             }
                         }
                     }
@@ -1980,9 +1980,9 @@ void LLDAELoader::processJointNode( domNode* pNode, JointTransformMap& jointTran
 
     //Gather and handle the incoming nodes children
     daeTArray< daeSmartRef<daeElement> > childOfChild = pNode->getChildren();
-    S32 childOfChildCount = childOfChild.getCount();
+    auto childOfChildCount = childOfChild.getCount();
 
-    for (S32 i = 0; i < childOfChildCount; ++i)
+    for (size_t i = 0; i < childOfChildCount; ++i)
     {
         domNode* pChildNode = daeSafeCast<domNode>( childOfChild[i] );
         if ( pChildNode )
@@ -2023,7 +2023,7 @@ void LLDAELoader::processElement( daeElement* element, bool& badElement, DAE* da
         domFloat3 dom_value = translate->getValue();
 
         LLMatrix4 translation;
-        translation.setTranslation(LLVector3(dom_value[0], dom_value[1], dom_value[2]));
+        translation.setTranslation(LLVector3((F32)dom_value[0], (F32)dom_value[1], (F32)dom_value[2]));
 
         translation *= mTransform;
         mTransform = translation;
@@ -2036,7 +2036,7 @@ void LLDAELoader::processElement( daeElement* element, bool& badElement, DAE* da
         domFloat4 dom_value = rotate->getValue();
 
         LLMatrix4 rotation;
-        rotation.initRotTrans(dom_value[3] * DEG_TO_RAD, LLVector3(dom_value[0], dom_value[1], dom_value[2]), LLVector3(0, 0, 0));
+        rotation.initRotTrans((F32)dom_value[3] * DEG_TO_RAD, LLVector3((F32)dom_value[0], (F32)dom_value[1], (F32)dom_value[2]), LLVector3(0, 0, 0));
 
         rotation *= mTransform;
         mTransform = rotation;
@@ -2049,7 +2049,7 @@ void LLDAELoader::processElement( daeElement* element, bool& badElement, DAE* da
         domFloat3 dom_value = scale->getValue();
 
 
-        LLVector3 scale_vector = LLVector3(dom_value[0], dom_value[1], dom_value[2]);
+        LLVector3 scale_vector = LLVector3((F32)dom_value[0], (F32)dom_value[1], (F32)dom_value[2]);
         scale_vector.abs(); // Set all values positive, since we don't currently support mirrored meshes
         LLMatrix4 scaling;
         scaling.initScale(scale_vector);
@@ -2070,7 +2070,7 @@ void LLDAELoader::processElement( daeElement* element, bool& badElement, DAE* da
         {
             for(int j = 0; j < 4; j++)
             {
-                matrix_transform.mMatrix[i][j] = dom_value[i + j*4];
+                matrix_transform.mMatrix[i][j] = (F32)dom_value[i + j*4];
             }
         }
 
@@ -2192,8 +2192,8 @@ void LLDAELoader::processElement( daeElement* element, bool& badElement, DAE* da
 
     //process children
     daeTArray< daeSmartRef<daeElement> > children = element->getChildren();
-    int childCount = children.getCount();
-    for (S32 i = 0; i < childCount; i++)
+    auto childCount = children.getCount();
+    for (size_t i = 0; i < childCount; i++)
     {
         processElement(children[i],badElement, dae);
     }
@@ -2264,7 +2264,7 @@ std::map<std::string, LLImportMaterial> LLDAELoader::getMaterials(LLModel* model
 LLImportMaterial LLDAELoader::profileToMaterial(domProfile_COMMON* material, DAE* dae)
 {
     LLImportMaterial mat;
-    mat.mFullbright = FALSE;
+    mat.mFullbright = false;
 
     daeElement* diffuse = material->getDescendant("diffuse");
     if (diffuse)
@@ -2338,7 +2338,7 @@ LLImportMaterial LLDAELoader::profileToMaterial(domProfile_COMMON* material, DAE
         if (color)
         {
             domFx_color_common domfx_color = color->getValue();
-            LLColor4 value = LLColor4(domfx_color[0], domfx_color[1], domfx_color[2], domfx_color[3]);
+            LLColor4 value = LLColor4((F32)domfx_color[0], (F32)domfx_color[1], (F32)domfx_color[2], (F32)domfx_color[3]);
             mat.mDiffuseColor = value;
         }
     }
@@ -2349,7 +2349,7 @@ LLImportMaterial LLDAELoader::profileToMaterial(domProfile_COMMON* material, DAE
         LLColor4 emission_color = getDaeColor(emission);
         if (((emission_color[0] + emission_color[1] + emission_color[2]) / 3.0) > 0.25)
         {
-            mat.mFullbright = TRUE;
+            mat.mFullbright = true;
         }
     }
 
@@ -2450,7 +2450,7 @@ LLColor4 LLDAELoader::getDaeColor(daeElement* element)
     if (color)
     {
         domFx_color_common domfx_color = color->getValue();
-        value = LLColor4(domfx_color[0], domfx_color[1], domfx_color[2], domfx_color[3]);
+        value = LLColor4((F32)domfx_color[0], (F32)domfx_color[1], (F32)domfx_color[2], (F32)domfx_color[3]);
     }
 
     return value;
@@ -2568,7 +2568,7 @@ bool LLDAELoader::loadModelsFromDomMesh(domMesh* mesh, std::vector<LLModel*>& mo
             ret->remapVolumeFaces();
         }
 
-        volume_faces = remainder.size();
+        volume_faces = static_cast<U32>(remainder.size());
 
         models_out.push_back(ret);
 
diff --git a/indra/llprimitive/llgltfloader.cpp b/indra/llprimitive/llgltfloader.cpp
index 810b648f17..776f81cc01 100644
--- a/indra/llprimitive/llgltfloader.cpp
+++ b/indra/llprimitive/llgltfloader.cpp
@@ -231,7 +231,7 @@ bool LLGLTFLoader::parseMaterials()
         image.numChannels     = in_image.component;
         image.bytesPerChannel = in_image.bits >> 3;     // Convert bits to bytes
         image.pixelType       = in_image.pixel_type;    // Maps exactly, i.e. TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE == GL_UNSIGNED_BYTE, etc
-        image.size            = in_image.image.size();
+        image.size            = static_cast<U32>(in_image.image.size());
         image.height          = in_image.height;
         image.width           = in_image.width;
         image.data            = in_image.image.data();
diff --git a/indra/llprimitive/llgltfmaterial.cpp b/indra/llprimitive/llgltfmaterial.cpp
index 034017e3f3..cc4921416f 100644
--- a/indra/llprimitive/llgltfmaterial.cpp
+++ b/indra/llprimitive/llgltfmaterial.cpp
@@ -47,16 +47,58 @@ const char* const LLGLTFMaterial::GLTF_FILE_EXTENSION_TRANSFORM_ROTATION = "rota
 // special UUID that indicates a null UUID in override data
 const LLUUID LLGLTFMaterial::GLTF_OVERRIDE_NULL_UUID = LLUUID("ffffffff-ffff-ffff-ffff-ffffffffffff");
 
-void LLGLTFMaterial::TextureTransform::getPacked(F32 (&packed)[8]) const
+LLGLTFMaterial::LLGLTFMaterial()
+{
+    // IMPORTANT: since we use the hash of the member variables memory block of
+    // this class to detect changes, we must ensure that all its padding bytes
+    // have been zeroed out. But of course, we must leave the LLRefCount member
+    // variable untouched (and skip it when hashing), and we cannot either
+    // touch the local texture overrides map (else we destroy pointers, and
+    // sundry private data, which would lead to a crash when using that map).
+    // The variable members have therefore been arranged so that anything,
+    // starting at mLocalTexDataDigest and up to the end of the members, can be
+    // safely zeroed. HB
+    const size_t offset = intptr_t(&mLocalTexDataDigest) - intptr_t(this);
+    memset((void*)((const char*)this + offset), 0, sizeof(*this) - offset);
+
+    // Now that we zeroed out our member variables, we can set the ones that
+    // should not be zero to their default value. HB
+    mBaseColor.set(1.f, 1.f, 1.f, 1.f);
+    mMetallicFactor = mRoughnessFactor = 1.f;
+    mAlphaCutoff = 0.5f;
+    for (U32 i = 0; i < GLTF_TEXTURE_INFO_COUNT; ++i)
+    {
+        mTextureTransform[i].mScale.set(1.f, 1.f);
+#if 0
+        mTextureTransform[i].mOffset.clear();
+        mTextureTransform[i].mRotation = 0.f;
+#endif
+    }
+#if 0
+    mLocalTexDataDigest = 0;
+    mAlphaMode = ALPHA_MODE_OPAQUE;    // This is 0
+    mOverrideDoubleSided = mOverrideAlphaMode = false;
+#endif
+}
+
+void LLGLTFMaterial::TextureTransform::getPacked(Pack& packed) const
 {
     packed[0] = mScale.mV[VX];
     packed[1] = mScale.mV[VY];
     packed[2] = mRotation;
-    // packed[3] = unused
     packed[4] = mOffset.mV[VX];
     packed[5] = mOffset.mV[VY];
-    // packed[6] = unused
-    // packed[7] = unused
+    // Not used but nonetheless zeroed for proper hashing. HB
+    packed[3] = packed[6] = packed[7] = 0.f;
+}
+
+void LLGLTFMaterial::TextureTransform::getPackedTight(PackTight& packed) const
+{
+    packed[0] = mScale.mV[VX];
+    packed[1] = mScale.mV[VY];
+    packed[2] = mRotation;
+    packed[3] = mOffset.mV[VX];
+    packed[4] = mOffset.mV[VY];
 }
 
 bool LLGLTFMaterial::TextureTransform::operator==(const TextureTransform& other) const
@@ -89,13 +131,37 @@ LLGLTFMaterial& LLGLTFMaterial::operator=(const LLGLTFMaterial& rhs)
     mOverrideDoubleSided = rhs.mOverrideDoubleSided;
     mOverrideAlphaMode = rhs.mOverrideAlphaMode;
 
-    mTrackingIdToLocalTexture = rhs.mTrackingIdToLocalTexture;
-
-    updateTextureTracking();
+    if (rhs.mTrackingIdToLocalTexture.empty())
+    {
+        mTrackingIdToLocalTexture.clear();
+        mLocalTexDataDigest = 0;
+    }
+    else
+    {
+        mTrackingIdToLocalTexture = rhs.mTrackingIdToLocalTexture;
+        updateLocalTexDataDigest();
+        updateTextureTracking();
+    }
 
     return *this;
 }
 
+void LLGLTFMaterial::updateLocalTexDataDigest()
+{
+    mLocalTexDataDigest = 0;
+    if (!mTrackingIdToLocalTexture.empty())
+    {
+        for (local_tex_map_t::const_iterator
+                it = mTrackingIdToLocalTexture.begin(),
+                end = mTrackingIdToLocalTexture.end();
+             it != end; ++it)
+        {
+            mLocalTexDataDigest ^= it->first.getDigest64() ^
+                                   it->second.getDigest64();
+        }
+    }
+}
+
 bool LLGLTFMaterial::operator==(const LLGLTFMaterial& rhs) const
 {
     return mTextureId == rhs.mTextureId &&
@@ -123,7 +189,7 @@ bool LLGLTFMaterial::fromJSON(const std::string& json, std::string& warn_msg, st
 
     tinygltf::Model model_in;
 
-    if (gltf.LoadASCIIFromString(&model_in, &error_msg, &warn_msg, json.c_str(), json.length(), ""))
+    if (gltf.LoadASCIIFromString(&model_in, &error_msg, &warn_msg, json.c_str(), static_cast<unsigned int>(json.length()), ""))
     {
         setFromModel(model_in, 0);
 
@@ -547,7 +613,7 @@ void LLGLTFMaterial::applyOverride(const LLGLTFMaterial& override_mat)
 {
     LL_PROFILE_ZONE_SCOPED;
 
-    for (int i = 0; i < GLTF_TEXTURE_INFO_COUNT; ++i)
+    for (U32 i = 0; i < GLTF_TEXTURE_INFO_COUNT; ++i)
     {
         LLUUID& texture_id = mTextureId[i];
         const LLUUID& override_texture_id = override_mat.mTextureId[i];
@@ -588,7 +654,7 @@ void LLGLTFMaterial::applyOverride(const LLGLTFMaterial& override_mat)
         mDoubleSided = override_mat.mDoubleSided;
     }
 
-    for (int i = 0; i < GLTF_TEXTURE_INFO_COUNT; ++i)
+    for (U32 i = 0; i < GLTF_TEXTURE_INFO_COUNT; ++i)
     {
         if (override_mat.mTextureTransform[i].mOffset != getDefaultTextureOffset())
         {
@@ -606,21 +672,25 @@ void LLGLTFMaterial::applyOverride(const LLGLTFMaterial& override_mat)
         }
     }
 
-    mTrackingIdToLocalTexture.insert(override_mat.mTrackingIdToLocalTexture.begin(), override_mat.mTrackingIdToLocalTexture.begin());
-
-    updateTextureTracking();
+    if (!override_mat.mTrackingIdToLocalTexture.empty())
+    {
+        auto it = override_mat.mTrackingIdToLocalTexture.begin();
+        mTrackingIdToLocalTexture.insert(it, it);
+        updateLocalTexDataDigest();
+        updateTextureTracking();
+    }
 }
 
-void LLGLTFMaterial::getOverrideLLSD(const LLGLTFMaterial& override_mat, LLSD& data)
+void LLGLTFMaterial::getOverrideLLSD(const LLGLTFMaterial& override_mat, LLSD& data) const
 {
     LL_PROFILE_ZONE_SCOPED;
     llassert(data.isUndefined());
 
     // make every effort to shave bytes here
 
-    for (int i = 0; i < GLTF_TEXTURE_INFO_COUNT; ++i)
+    for (U32 i = 0; i < GLTF_TEXTURE_INFO_COUNT; ++i)
     {
-        LLUUID& texture_id = mTextureId[i];
+        const LLUUID& texture_id = mTextureId[i];
         const LLUUID& override_texture_id = override_mat.mTextureId[i];
         if (override_texture_id.notNull() && override_texture_id != texture_id)
         {
@@ -663,7 +733,7 @@ void LLGLTFMaterial::getOverrideLLSD(const LLGLTFMaterial& override_mat, LLSD& d
         data["ds"] = override_mat.mDoubleSided;
     }
 
-    for (int i = 0; i < GLTF_TEXTURE_INFO_COUNT; ++i)
+    for (U32 i = 0; i < GLTF_TEXTURE_INFO_COUNT; ++i)
     {
         if (override_mat.mTextureTransform[i].mOffset != getDefaultTextureOffset())
         {
@@ -720,7 +790,7 @@ void LLGLTFMaterial::applyOverrideLLSD(const LLSD& data)
     const LLSD& mf = data["mf"];
     if (mf.isReal())
     {
-        mMetallicFactor = mf.asReal();
+        mMetallicFactor = (F32)mf.asReal();
         if (mMetallicFactor == getDefaultMetallicFactor())
         {
             // HACK -- nudge by epsilon if we receive a default value (indicates override to default)
@@ -731,7 +801,7 @@ void LLGLTFMaterial::applyOverrideLLSD(const LLSD& data)
     const LLSD& rf = data["rf"];
     if (rf.isReal())
     {
-        mRoughnessFactor = rf.asReal();
+        mRoughnessFactor = (F32)rf.asReal();
         if (mRoughnessFactor == getDefaultRoughnessFactor())
         {
             // HACK -- nudge by epsilon if we receive a default value (indicates override to default)
@@ -749,7 +819,7 @@ void LLGLTFMaterial::applyOverrideLLSD(const LLSD& data)
     const LLSD& ac = data["ac"];
     if (ac.isReal())
     {
-        mAlphaCutoff = ac.asReal();
+        mAlphaCutoff = (F32)ac.asReal();
         if (mAlphaCutoff == getDefaultAlphaCutoff())
         {
             // HACK -- nudge by epsilon if we receive a default value (indicates override to default)
@@ -767,7 +837,7 @@ void LLGLTFMaterial::applyOverrideLLSD(const LLSD& data)
     const LLSD& ti = data["ti"];
     if (ti.isArray())
     {
-        for (int i = 0; i < GLTF_TEXTURE_INFO_COUNT; ++i)
+        for (U32 i = 0; i < GLTF_TEXTURE_INFO_COUNT; ++i)
         {
             const LLSD& o = ti[i]["o"];
             if (o.isDefined())
@@ -784,7 +854,7 @@ void LLGLTFMaterial::applyOverrideLLSD(const LLSD& data)
             const LLSD& r = ti[i]["r"];
             if (r.isReal())
             {
-                mTextureTransform[i].mRotation = r.asReal();
+                mTextureTransform[i].mRotation = (F32)r.asReal();
             }
         }
     }
@@ -793,27 +863,36 @@ void LLGLTFMaterial::applyOverrideLLSD(const LLSD& data)
 LLUUID LLGLTFMaterial::getHash() const
 {
     LL_PROFILE_ZONE_SCOPED_CATEGORY_TEXTURE;
-    // HACK - hash the bytes of this object but don't include the ref count
-    LLUUID hash;
-    HBXXH128::digest(hash, (unsigned char*)this + sizeof(LLRefCount), sizeof(*this) - sizeof(LLRefCount));
-    return hash;
+    // *HACK: hash the bytes of this object but do not include the ref count
+    // neither the local texture overrides (which is a map, with pointers to
+    // key/value pairs that would change from one LLGLTFMaterial instance to
+    // the other, even though the key/value pairs could be the same, and stored
+    // elsewhere in the memory heap or on the stack).
+    // Note: this does work properly to compare two LLGLTFMaterial instances
+    // only because the padding bytes between their member variables have been
+    // dutifully zeroed in the constructor. HB
+    const size_t offset = intptr_t(&mLocalTexDataDigest) - intptr_t(this);
+    return HBXXH128::digest((const void*)((const char*)this + offset),
+                            sizeof(*this) - offset);
 }
 
 void LLGLTFMaterial::addLocalTextureTracking(const LLUUID& tracking_id, const LLUUID& tex_id)
 {
     mTrackingIdToLocalTexture[tracking_id] = tex_id;
+    updateLocalTexDataDigest();
 }
 
 void LLGLTFMaterial::removeLocalTextureTracking(const LLUUID& tracking_id)
 {
     mTrackingIdToLocalTexture.erase(tracking_id);
+    updateLocalTexDataDigest();
 }
 
 bool LLGLTFMaterial::replaceLocalTexture(const LLUUID& tracking_id, const LLUUID& old_id, const LLUUID& new_id)
 {
     bool res = false;
 
-    for (int i = 0; i < GLTF_TEXTURE_INFO_COUNT; ++i)
+    for (U32 i = 0; i < GLTF_TEXTURE_INFO_COUNT; ++i)
     {
         if (mTextureId[i] == old_id)
         {
@@ -834,6 +913,7 @@ bool LLGLTFMaterial::replaceLocalTexture(const LLUUID& tracking_id, const LLUUID
     {
         mTrackingIdToLocalTexture.erase(tracking_id);
     }
+    updateLocalTexDataDigest();
 
     return res;
 }
diff --git a/indra/llprimitive/llgltfmaterial.h b/indra/llprimitive/llgltfmaterial.h
index 855cb58832..10df4c8ee1 100644
--- a/indra/llprimitive/llgltfmaterial.h
+++ b/indra/llprimitive/llgltfmaterial.h
@@ -5,21 +5,21 @@
  * $LicenseInfo:firstyear=2022&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2022, 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$
  */
@@ -68,7 +68,12 @@ public:
         LLVector2 mScale = { 1.f, 1.f };
         F32 mRotation = 0.f;
 
-        void getPacked(F32 (&packed)[8]) const;
+        static const size_t PACK_SIZE = 8;
+        static const size_t PACK_TIGHT_SIZE = 5;
+        using Pack = F32[PACK_SIZE];
+        using PackTight = F32[PACK_TIGHT_SIZE];
+        void getPacked(Pack& packed) const;
+        void getPackedTight(PackTight& packed) const;
 
         bool operator==(const TextureTransform& other) const;
         bool operator!=(const TextureTransform& other) const { return !(*this == other); }
@@ -81,7 +86,7 @@ public:
         ALPHA_MODE_MASK
     };
 
-    LLGLTFMaterial() {}
+    LLGLTFMaterial();
     LLGLTFMaterial(const LLGLTFMaterial& rhs);
 
     LLGLTFMaterial& operator=(const LLGLTFMaterial& rhs);
@@ -110,42 +115,6 @@ public:
     static const char* const GLTF_FILE_EXTENSION_TRANSFORM_ROTATION;
     static const LLUUID GLTF_OVERRIDE_NULL_UUID;
 
-    std::array<LLUUID, GLTF_TEXTURE_INFO_COUNT> mTextureId;
-    std::array<TextureTransform, GLTF_TEXTURE_INFO_COUNT> mTextureTransform;
-
-    // NOTE: initialize values to defaults according to the GLTF spec
-    // NOTE: these values should be in linear color space
-    LLColor4 mBaseColor = LLColor4(1, 1, 1, 1);
-    LLColor3 mEmissiveColor = LLColor3(0, 0, 0);
-
-    F32 mMetallicFactor = 1.f;
-    F32 mRoughnessFactor = 1.f;
-    F32 mAlphaCutoff = 0.5f;
-
-    AlphaMode mAlphaMode = ALPHA_MODE_OPAQUE;
-
-    bool mDoubleSided = false;
-
-    // override specific flags for state that can't use off-by-epsilon or UUID hack
-    bool mOverrideDoubleSided = false;
-    bool mOverrideAlphaMode = false;
-
-    // *TODO: If/when we implement additional GLTF extensions, they may not be
-    // compatible with our GLTF terrain implementation. We may want to disallow
-    // materials with some features from being set on terrain, if their
-    // implementation on terrain is not compliant with the spec:
-    //     - KHR_materials_transmission: Probably OK?
-    //     - KHR_materials_ior: Probably OK?
-    //     - KHR_materials_volume: Likely incompatible, as our terrain
-    //       heightmaps cannot currently be described as finite enclosed
-    //       volumes.
-    // See also LLPanelRegionTerrainInfo::validateMaterials
-    // These fields are local to viewer and are a part of local bitmap support
-    typedef std::map<LLUUID, LLUUID> local_tex_map_t;
-    local_tex_map_t                  mTrackingIdToLocalTexture;
-
-public:
-
     // get a UUID based on a hash of this LLGLTFMaterial
     LLUUID getHash() const;
 
@@ -214,14 +183,14 @@ public:
     void writeToModel(tinygltf::Model& model, S32 mat_index) const;
 
     virtual void applyOverride(const LLGLTFMaterial& override_mat);
-    
+
     // apply the given LLSD override data
     void applyOverrideLLSD(const LLSD& data);
 
     // Get the given override on this LLGLTFMaterial as LLSD
     // override_mat -- the override source data
     // data -- output LLSD object (should be passed in empty)
-    void getOverrideLLSD(const LLGLTFMaterial& override_mat, LLSD& data);
+    void getOverrideLLSD(const LLGLTFMaterial& override_mat, LLSD& data) const;
 
     // For base materials only (i.e. assets). Clears transforms to
     // default since they're not supported in assets yet.
@@ -245,7 +214,6 @@ public:
     bool hasLocalTextures() { return !mTrackingIdToLocalTexture.empty(); }
     virtual bool replaceLocalTexture(const LLUUID& tracking_id, const LLUUID &old_id, const LLUUID& new_id);
     virtual void updateTextureTracking();
-
 protected:
     static LLVector2 vec2FromJson(const std::map<std::string, tinygltf::Value>& object, const char* key, const LLVector2& default_value);
     static F32 floatFromJson(const std::map<std::string, tinygltf::Value>& object, const char* key, const F32 default_value);
@@ -262,4 +230,49 @@ protected:
     void writeToTexture(tinygltf::Model& model, T& texture_info, TextureInfo texture_info_id, bool force_write = false) const;
     template<typename T>
     static void writeToTexture(tinygltf::Model& model, T& texture_info, const LLUUID& texture_id, const TextureTransform& transform, bool force_write = false);
+
+    // Used to update the digest of the mTrackingIdToLocalTexture map each time
+    // it is changed; this way, that digest can be used by the fast getHash()
+    // method intsead of having to hash all individual keys and values. HB
+    void updateLocalTexDataDigest();
+
+public:
+    // *TODO: If/when we implement additional GLTF extensions, they may not be
+    // compatible with our GLTF terrain implementation. We may want to disallow
+    // materials with some features from being set on terrain, if their
+    // implementation on terrain is not compliant with the spec:
+    //     - KHR_materials_transmission: Probably OK?
+    //     - KHR_materials_ior: Probably OK?
+    //     - KHR_materials_volume: Likely incompatible, as our terrain
+    //       heightmaps cannot currently be described as finite enclosed
+    //       volumes.
+    // See also LLPanelRegionTerrainInfo::validateMaterials
+    // These fields are local to viewer and are a part of local bitmap support
+    typedef std::map<LLUUID, LLUUID> local_tex_map_t;
+    local_tex_map_t mTrackingIdToLocalTexture;
+
+    // Used to store a digest of mTrackingIdToLocalTexture when the latter is
+    // not empty, or zero otherwise. HB
+    U64 mLocalTexDataDigest;
+
+    std::array<LLUUID, GLTF_TEXTURE_INFO_COUNT> mTextureId;
+    std::array<TextureTransform, GLTF_TEXTURE_INFO_COUNT> mTextureTransform;
+
+    // NOTE: initialize values to defaults according to the GLTF spec
+    // NOTE: these values should be in linear color space
+    LLColor4 mBaseColor;
+    LLColor3 mEmissiveColor;
+
+    F32 mMetallicFactor;
+    F32 mRoughnessFactor;
+    F32 mAlphaCutoff;
+
+    AlphaMode mAlphaMode;
+
+    bool mDoubleSided = false;
+
+    // Override specific flags for state that can't use off-by-epsilon or UUID
+    // hack
+    bool mOverrideDoubleSided = false;
+    bool mOverrideAlphaMode = false;
 };
diff --git a/indra/llprimitive/llgltfmaterial_templates.h b/indra/llprimitive/llgltfmaterial_templates.h
index 276cc71b19..4ec7f312af 100644
--- a/indra/llprimitive/llgltfmaterial_templates.h
+++ b/indra/llprimitive/llgltfmaterial_templates.h
@@ -87,12 +87,12 @@ void LLGLTFMaterial::setFromTexture(const tinygltf::Model& model, const T& textu
 template<typename T>
 void LLGLTFMaterial::allocateTextureImage(tinygltf::Model& model, T& texture_info, const std::string& uri)
 {
-    const S32 image_idx = model.images.size();
+    const S32 image_idx = static_cast<S32>(model.images.size());
     model.images.emplace_back();
     model.images[image_idx].uri = uri;
 
     // The texture, not to be confused with the texture info
-    const S32 texture_idx = model.textures.size();
+    const S32 texture_idx = static_cast<S32>(model.textures.size());
     model.textures.emplace_back();
     tinygltf::Texture& texture = model.textures[texture_idx];
     texture.source = image_idx;
diff --git a/indra/llprimitive/llmaterial.cpp b/indra/llprimitive/llmaterial.cpp
index 0453a8f469..fe1587d197 100644
--- a/indra/llprimitive/llmaterial.cpp
+++ b/indra/llprimitive/llmaterial.cpp
@@ -427,7 +427,7 @@ bool LLMaterial::operator != (const LLMaterial& rhs) const
 }
 
 
-U32 LLMaterial::getShaderMask(U32 alpha_mode, BOOL is_alpha)
+U32 LLMaterial::getShaderMask(U32 alpha_mode, bool is_alpha)
 { //NEVER incorporate this value into the message system -- this function will vary depending on viewer implementation
 
     //two least significant bits are "diffuse alpha mode"
diff --git a/indra/llprimitive/llmaterial.h b/indra/llprimitive/llmaterial.h
index c6bd5a94ce..a7719c1475 100644
--- a/indra/llprimitive/llmaterial.h
+++ b/indra/llprimitive/llmaterial.h
@@ -122,7 +122,7 @@ public:
     bool        operator == (const LLMaterial& rhs) const;
     bool        operator != (const LLMaterial& rhs) const;
 
-    U32         getShaderMask(U32 alpha_mode, BOOL is_alpha);
+    U32         getShaderMask(U32 alpha_mode, bool is_alpha);
     LLUUID      getHash() const;
 
 protected:
diff --git a/indra/llprimitive/llmaterialid.cpp b/indra/llprimitive/llmaterialid.cpp
index 847824d770..4992b282f3 100644
--- a/indra/llprimitive/llmaterialid.cpp
+++ b/indra/llprimitive/llmaterialid.cpp
@@ -136,7 +136,7 @@ LLSD LLMaterialID::asLLSD() const
     materialIDBinary.resize(MATERIAL_ID_SIZE * sizeof(U8));
     memcpy(materialIDBinary.data(), mID, MATERIAL_ID_SIZE * sizeof(U8));
 
-    LLSD materialID = materialIDBinary;
+    LLSD materialID = std::move(materialIDBinary);
     return materialID;
 }
 
diff --git a/indra/llprimitive/llmaterialtable.cpp b/indra/llprimitive/llmaterialtable.cpp
index 344bd49e6d..44c97d63e7 100644
--- a/indra/llprimitive/llmaterialtable.cpp
+++ b/indra/llprimitive/llmaterialtable.cpp
@@ -341,21 +341,21 @@ void LLMaterialTable::initBasicTable()
     }
 }
 
-BOOL LLMaterialTable::add(U8 mcode, const std::string& name, const LLUUID &uuid)
+bool LLMaterialTable::add(U8 mcode, const std::string& name, const LLUUID &uuid)
 {
     LLMaterialInfo *infop;
 
     infop = new LLMaterialInfo(mcode,name,uuid);
-    if (!infop) return FALSE;
+    if (!infop) return false;
 
     // Add at the end so the order in menus matches the order in this
     // file.  JNC 11.30.01
     mMaterialInfoList.push_back(infop);
 
-    return TRUE;
+    return true;
 }
 
-BOOL LLMaterialTable::addCollisionSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
+bool LLMaterialTable::addCollisionSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
 {
     if (mCollisionSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
     {
@@ -365,10 +365,10 @@ BOOL LLMaterialTable::addCollisionSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
             mCollisionSoundMatrix[mcode2 * LL_MCODE_END + mcode] = uuid;
         }
     }
-    return TRUE;
+    return true;
 }
 
-BOOL LLMaterialTable::addSlidingSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
+bool LLMaterialTable::addSlidingSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
 {
     if (mSlidingSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
     {
@@ -378,10 +378,10 @@ BOOL LLMaterialTable::addSlidingSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
             mSlidingSoundMatrix[mcode2 * LL_MCODE_END + mcode] = uuid;
         }
     }
-    return TRUE;
+    return true;
 }
 
-BOOL LLMaterialTable::addRollingSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
+bool LLMaterialTable::addRollingSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
 {
     if (mRollingSoundMatrix && (mcode < LL_MCODE_END) && (mcode2 < LL_MCODE_END))
     {
@@ -391,10 +391,10 @@ BOOL LLMaterialTable::addRollingSound(U8 mcode, U8 mcode2, const LLUUID &uuid)
             mRollingSoundMatrix[mcode2 * LL_MCODE_END + mcode] = uuid;
         }
     }
-    return TRUE;
+    return true;
 }
 
-BOOL LLMaterialTable::addShatterSound(U8 mcode, const LLUUID &uuid)
+bool LLMaterialTable::addShatterSound(U8 mcode, const LLUUID &uuid)
 {
     for (info_list_t::iterator iter = mMaterialInfoList.begin();
          iter != mMaterialInfoList.end(); ++iter)
@@ -403,14 +403,14 @@ BOOL LLMaterialTable::addShatterSound(U8 mcode, const LLUUID &uuid)
         if (mcode == infop->mMCode)
         {
             infop->mShatterSoundID = uuid;
-            return TRUE;
+            return true;
         }
     }
 
-    return FALSE;
+    return false;
 }
 
-BOOL LLMaterialTable::addDensity(U8 mcode, const F32 &density)
+bool LLMaterialTable::addDensity(U8 mcode, const F32 &density)
 {
     for (info_list_t::iterator iter = mMaterialInfoList.begin();
          iter != mMaterialInfoList.end(); ++iter)
@@ -419,14 +419,14 @@ BOOL LLMaterialTable::addDensity(U8 mcode, const F32 &density)
         if (mcode == infop->mMCode)
         {
             infop->mDensity = density;
-            return TRUE;
+            return true;
         }
     }
 
-    return FALSE;
+    return false;
 }
 
-BOOL LLMaterialTable::addRestitution(U8 mcode, const F32 &restitution)
+bool LLMaterialTable::addRestitution(U8 mcode, const F32 &restitution)
 {
     for (info_list_t::iterator iter = mMaterialInfoList.begin();
          iter != mMaterialInfoList.end(); ++iter)
@@ -435,14 +435,14 @@ BOOL LLMaterialTable::addRestitution(U8 mcode, const F32 &restitution)
         if (mcode == infop->mMCode)
         {
             infop->mRestitution = restitution;
-            return TRUE;
+            return true;
         }
     }
 
-    return FALSE;
+    return false;
 }
 
-BOOL LLMaterialTable::addFriction(U8 mcode, const F32 &friction)
+bool LLMaterialTable::addFriction(U8 mcode, const F32 &friction)
 {
     for (info_list_t::iterator iter = mMaterialInfoList.begin();
          iter != mMaterialInfoList.end(); ++iter)
@@ -451,14 +451,14 @@ BOOL LLMaterialTable::addFriction(U8 mcode, const F32 &friction)
         if (mcode == infop->mMCode)
         {
             infop->mFriction = friction;
-            return TRUE;
+            return true;
         }
     }
 
-    return FALSE;
+    return false;
 }
 
-BOOL LLMaterialTable::addDamageAndEnergy(U8 mcode, const F32 &hp_mod, const F32 &damage_mod, const F32 &ep_mod)
+bool LLMaterialTable::addDamageAndEnergy(U8 mcode, const F32 &hp_mod, const F32 &damage_mod, const F32 &ep_mod)
 {
     for (info_list_t::iterator iter = mMaterialInfoList.begin();
          iter != mMaterialInfoList.end(); ++iter)
@@ -469,11 +469,11 @@ BOOL LLMaterialTable::addDamageAndEnergy(U8 mcode, const F32 &hp_mod, const F32
             infop->mHPModifier = hp_mod;
             infop->mDamageModifier = damage_mod;
             infop->mEPModifier = ep_mod;
-            return TRUE;
+            return true;
         }
     }
 
-    return FALSE;
+    return false;
 }
 
 LLUUID LLMaterialTable::getDefaultTextureID(const std::string& name)
diff --git a/indra/llprimitive/llmaterialtable.h b/indra/llprimitive/llmaterialtable.h
index d612361041..7d1d5c7d34 100644
--- a/indra/llprimitive/llmaterialtable.h
+++ b/indra/llprimitive/llmaterialtable.h
@@ -106,15 +106,15 @@ public:
 
     void initTableTransNames(std::map<std::string, std::string> namemap);
 
-    BOOL add(U8 mcode, const std::string& name, const LLUUID &uuid);
-    BOOL addCollisionSound(U8 mcode, U8 mcode2, const LLUUID &uuid);
-    BOOL addSlidingSound(U8 mcode, U8 mcode2, const LLUUID &uuid);
-    BOOL addRollingSound(U8 mcode, U8 mcode2, const LLUUID &uuid);
-    BOOL addShatterSound(U8 mcode, const LLUUID &uuid);
-    BOOL addDensity(U8 mcode, const F32 &density);
-    BOOL addFriction(U8 mcode, const F32 &friction);
-    BOOL addRestitution(U8 mcode, const F32 &restitution);
-    BOOL addDamageAndEnergy(U8 mcode, const F32 &hp_mod, const F32 &damage_mod, const F32 &ep_mod);
+    bool add(U8 mcode, const std::string& name, const LLUUID &uuid);
+    bool addCollisionSound(U8 mcode, U8 mcode2, const LLUUID &uuid);
+    bool addSlidingSound(U8 mcode, U8 mcode2, const LLUUID &uuid);
+    bool addRollingSound(U8 mcode, U8 mcode2, const LLUUID &uuid);
+    bool addShatterSound(U8 mcode, const LLUUID &uuid);
+    bool addDensity(U8 mcode, const F32 &density);
+    bool addFriction(U8 mcode, const F32 &friction);
+    bool addRestitution(U8 mcode, const F32 &restitution);
+    bool addDamageAndEnergy(U8 mcode, const F32 &hp_mod, const F32 &damage_mod, const F32 &ep_mod);
 
     LLUUID getDefaultTextureID(const std::string& name);                    // LLUUID::null if not found
     LLUUID getDefaultTextureID(U8 mcode);                   // LLUUID::null if not found
diff --git a/indra/llprimitive/llmediaentry.cpp b/indra/llprimitive/llmediaentry.cpp
index e626a989f6..b5b17c53aa 100644
--- a/indra/llprimitive/llmediaentry.cpp
+++ b/indra/llprimitive/llmediaentry.cpp
@@ -353,7 +353,7 @@ U32 LLMediaEntry::setWhiteList( const std::vector<std::string> &whitelist )
 {
     // *NOTE: This code is VERY similar to the setWhitelist below.
     // IF YOU CHANGE THIS IMPLEMENTATION, BE SURE TO CHANGE THE OTHER!
-    U32 size = 0;
+    size_t size = 0;
     U32 count = 0;
     // First count to make sure the size constraint is not violated
     std::vector<std::string>::const_iterator iter = whitelist.begin();
@@ -394,7 +394,7 @@ U32 LLMediaEntry::setWhiteList( const LLSD &whitelist )
     {
         // *NOTE: This code is VERY similar to the setWhitelist above.
         // IF YOU CHANGE THIS IMPLEMENTATION, BE SURE TO CHANGE THE OTHER!
-        U32 size = 0;
+        size_t size = 0;
         U32 count = 0;
         // First check to make sure the size and count constraints are not violated
         LLSD::array_const_iterator iter = whitelist.beginArray();
diff --git a/indra/llprimitive/llmodel.cpp b/indra/llprimitive/llmodel.cpp
index 236cef9c3f..15087a7255 100644
--- a/indra/llprimitive/llmodel.cpp
+++ b/indra/llprimitive/llmodel.cpp
@@ -50,7 +50,7 @@ std::string model_names[] =
 
 const int MODEL_NAMES_LENGTH = sizeof(model_names) / sizeof(std::string);
 
-LLModel::LLModel(LLVolumeParams& params, F32 detail)
+LLModel::LLModel(const LLVolumeParams& params, F32 detail)
     : LLVolume(params, detail),
       mNormalizedScale(1,1,1),
       mNormalizedTranslation(0, 0, 0),
@@ -101,7 +101,7 @@ void LLModel::offsetMesh( const LLVector3& pivotPoint )
         LLVolumeFace& face = *currentFaceIt;
         LLVector4a *pos = (LLVector4a*) face.mPositions;
 
-        for (U32 i=0; i<face.mNumVertices; ++i )
+        for (S32 i=0; i<face.mNumVertices; ++i )
         {
             pos[i].add( pivot );
         }
@@ -110,7 +110,7 @@ void LLModel::offsetMesh( const LLVector3& pivotPoint )
 
 void LLModel::remapVolumeFaces()
 {
-    for (U32 i = 0; i < getNumVolumeFaces(); ++i)
+    for (S32 i = 0; i < getNumVolumeFaces(); ++i)
     {
         mVolumeFaces[i].remap();
     }
@@ -118,7 +118,7 @@ void LLModel::remapVolumeFaces()
 
 void LLModel::optimizeVolumeFaces()
 {
-    for (U32 i = 0; i < getNumVolumeFaces(); ++i)
+    for (S32 i = 0; i < getNumVolumeFaces(); ++i)
     {
         mVolumeFaces[i].optimize();
     }
@@ -173,7 +173,7 @@ void LLModel::trimVolumeFacesToSize(U32 new_count, LLVolume::face_list_t* remain
 {
     llassert(new_count <= LL_SCULPT_MESH_MAX_FACES);
 
-    if (new_count && (getNumVolumeFaces() > new_count))
+    if (new_count > 0 && ((U32)getNumVolumeFaces() > new_count))
     {
         // Copy out remaining volume faces for alternative handling, if provided
         //
@@ -224,7 +224,7 @@ void LLModel::normalizeVolumeFaces()
                 min_tc = face.mTexCoords[0];
                 max_tc = face.mTexCoords[0];
 
-                for (U32 j = 1; j < face.mNumVertices; ++j)
+                for (S32 j = 1; j < face.mNumVertices; ++j)
                 {
                     update_min_max(min_tc, max_tc, face.mTexCoords[j]);
                 }
@@ -299,7 +299,7 @@ void LLModel::normalizeVolumeFaces()
             LLVector4a* norm = (LLVector4a*) face.mNormals;
             LLVector4a* t = (LLVector4a*)face.mTangents;
 
-            for (U32 j = 0; j < face.mNumVertices; ++j)
+            for (S32 j = 0; j < face.mNumVertices; ++j)
             {
                 pos[j].add(trans);
                 pos[j].mul(scale);
@@ -363,7 +363,7 @@ LLVector3 LLModel::getTransformedCenter(const LLMatrix4& mat)
         {
             LLVolumeFace& face = mVolumeFaces[i];
 
-            for (U32 j = 0; j < face.mNumVertices; ++j)
+            for (S32 j = 0; j < face.mNumVertices; ++j)
             {
                 m.affineTransform(face.mPositions[j],t);
                 update_min_max(minv, maxv, t);
@@ -475,7 +475,7 @@ void LLModel::generateNormals(F32 angle_cutoff)
         faceted.resizeVertices(vol_face.mNumIndices);
         faceted.resizeIndices(vol_face.mNumIndices);
         //bake out triangles into temporary face, clearing texture coordinates
-        for (U32 i = 0; i < vol_face.mNumIndices; ++i)
+        for (S32 i = 0; i < vol_face.mNumIndices; ++i)
         {
             U32 idx = vol_face.mIndices[i];
 
@@ -485,7 +485,7 @@ void LLModel::generateNormals(F32 angle_cutoff)
         }
 
         //generate normals for temporary face
-        for (U32 i = 0; i < faceted.mNumIndices; i += 3)
+        for (S32 i = 0; i < faceted.mNumIndices; i += 3)
         { //for each triangle
             U16 i0 = faceted.mIndices[i+0];
             U16 i1 = faceted.mIndices[i+1];
@@ -514,12 +514,12 @@ void LLModel::generateNormals(F32 angle_cutoff)
 
         //generate normals for welded face based on new topology (step 3)
 
-        for (U32 i = 0; i < faceted.mNumVertices; i++)
+        for (S32 i = 0; i < faceted.mNumVertices; i++)
         {
             faceted.mNormals[i].clear();
         }
 
-        for (U32 i = 0; i < faceted.mNumIndices; i += 3)
+        for (S32 i = 0; i < faceted.mNumIndices; i += 3)
         { //for each triangle
             U16 i0 = faceted.mIndices[i+0];
             U16 i1 = faceted.mIndices[i+1];
@@ -548,7 +548,7 @@ void LLModel::generateNormals(F32 angle_cutoff)
         //normalize normals and build point map
         LLVolumeFace::VertexMapData::PointMap point_map;
 
-        for (U32 i = 0; i < faceted.mNumVertices; ++i)
+        for (S32 i = 0; i < faceted.mNumVertices; ++i)
         {
             faceted.mNormals[i].normalize3();
 
@@ -566,7 +566,7 @@ void LLModel::generateNormals(F32 angle_cutoff)
         new_face.resizeIndices(vol_face.mNumIndices);
         new_face.resizeVertices(vol_face.mNumIndices);
 
-        for (U32 i = 0; i < vol_face.mNumIndices; ++i)
+        for (S32 i = 0; i < vol_face.mNumIndices; ++i)
         {
             U32 idx = vol_face.mIndices[i];
             LLVolumeFace::VertexData v;
@@ -577,7 +577,7 @@ void LLModel::generateNormals(F32 angle_cutoff)
 
         if (vol_face.mTexCoords)
         {
-            for (U32 i = 0; i < vol_face.mNumIndices; i++)
+            for (S32 i = 0; i < vol_face.mNumIndices; i++)
             {
                 U32 idx = vol_face.mIndices[i];
                 new_face.mTexCoords[i] = vol_face.mTexCoords[idx];
@@ -590,7 +590,7 @@ void LLModel::generateNormals(F32 angle_cutoff)
         }
 
         //generate normals for new face
-        for (U32 i = 0; i < new_face.mNumIndices; i += 3)
+        for (S32 i = 0; i < new_face.mNumIndices; i += 3)
         { //for each triangle
             U16 i0 = new_face.mIndices[i+0];
             U16 i1 = new_face.mIndices[i+1];
@@ -615,7 +615,7 @@ void LLModel::generateNormals(F32 angle_cutoff)
         }
 
         //swap out normals in new_face with best match from point map (step 5)
-        for (U32 i = 0; i < new_face.mNumVertices; ++i)
+        for (S32 i = 0; i < new_face.mNumVertices; ++i)
         {
             //LLVolumeFace::VertexData v = new_face.mVertices[i];
 
@@ -663,11 +663,11 @@ LLSD LLModel::writeModel(
     LLModel* low,
     LLModel* impostor,
     const LLModel::Decomposition& decomp,
-    BOOL upload_skin,
-    BOOL upload_joints,
-    BOOL lock_scale_if_joint_position,
-    BOOL nowrite,
-    BOOL as_slm,
+    bool upload_skin,
+    bool upload_joints,
+    bool lock_scale_if_joint_position,
+    bool nowrite,
+    bool as_slm,
     int submodel_id)
 {
     LLSD mdl;
@@ -725,7 +725,7 @@ LLSD LLModel::writeModel(
             for (S32 i = 0; i < model[idx]->getNumVolumeFaces(); ++i)
             { //for each face
                 const LLVolumeFace& face = model[idx]->getVolumeFace(i);
-                for (U32 j = 0; j < face.mNumVertices; ++j)
+                for (S32 j = 0; j < face.mNumVertices; ++j)
                 {
                     update_min_max(min_pos, max_pos, face.mPositions[j].getF32ptr());
                 }
@@ -762,7 +762,7 @@ LLSD LLModel::writeModel(
                     max_tc = min_tc;
 
                     //get texture coordinate domain
-                    for (U32 j = 0; j < face.mNumVertices; ++j)
+                    for (S32 j = 0; j < face.mNumVertices; ++j)
                     {
                         update_min_max(min_tc, max_tc, ftc[j]);
                     }
@@ -770,7 +770,7 @@ LLSD LLModel::writeModel(
 
                 LLVector2 tc_range = max_tc - min_tc;
 
-                for (U32 j = 0; j < face.mNumVertices; ++j)
+                for (S32 j = 0; j < face.mNumVertices; ++j)
                 { //for each vert
 
                     F32* pos = face.mPositions[j].getF32ptr();
@@ -840,7 +840,7 @@ LLSD LLModel::writeModel(
                 }
 
                 U32 idx_idx = 0;
-                for (U32 j = 0; j < face.mNumIndices; ++j)
+                for (S32 j = 0; j < face.mNumIndices; ++j)
                 {
                     U8* buff = (U8*) &(face.mIndices[j]);
                     indices[idx_idx++] = buff[0];
@@ -887,7 +887,7 @@ LLSD LLModel::writeModel(
                         // a bone index of 0xFF signifies no more influences for this vertex
 
                         std::stringstream ostr;
-                        for (U32 j = 0; j < face.mNumVertices; ++j)
+                        for (S32 j = 0; j < face.mNumVertices; ++j)
                         {
                             LLVector3 pos(face.mPositions[j].getF32ptr());
 
@@ -918,7 +918,7 @@ LLSD LLModel::writeModel(
                         //copy ostr to binary buffer
                         std::string data = ostr.str();
                         const U8* buff = (U8*)data.data();
-                        U32 bytes = data.size();
+                        U32 bytes = static_cast<U32>(data.size());
 
                         LLSD::Binary w(bytes);
                         for (U32 j = 0; j < bytes; ++j)
@@ -948,7 +948,7 @@ LLSD LLModel::writeModel(
     return writeModelToStream(ostr, mdl, nowrite, as_slm);
 }
 
-LLSD LLModel::writeModelToStream(std::ostream& ostr, LLSD& mdl, BOOL nowrite, BOOL as_slm)
+LLSD LLModel::writeModelToStream(std::ostream& ostr, LLSD& mdl, bool nowrite, bool as_slm)
 {
     std::string::size_type cur_offset = 0;
 
@@ -965,7 +965,7 @@ LLSD LLModel::writeModelToStream(std::ostream& ostr, LLSD& mdl, BOOL nowrite, BO
     { //write out skin block
         skin = zip_llsd(mdl["skin"]);
 
-        U32 size = skin.size();
+        U32 size = static_cast<U32>(skin.size());
         if (size > 0)
         {
             header["skin"]["offset"] = (LLSD::Integer) cur_offset;
@@ -980,7 +980,7 @@ LLSD LLModel::writeModelToStream(std::ostream& ostr, LLSD& mdl, BOOL nowrite, BO
     { //write out convex decomposition
         decomposition = zip_llsd(mdl["physics_convex"]);
 
-        U32 size = decomposition.size();
+        U32 size = static_cast<U32>(decomposition.size());
         if (size > 0)
         {
             header["physics_convex"]["offset"] = (LLSD::Integer) cur_offset;
@@ -1002,7 +1002,7 @@ LLSD LLModel::writeModelToStream(std::ostream& ostr, LLSD& mdl, BOOL nowrite, BO
         {
             out[i] = zip_llsd(mdl[model_names[i]]);
 
-            U32 size = out[i].size();
+            U32 size = static_cast<U32>(out[i].size());
 
             header[model_names[i]]["offset"] = (LLSD::Integer) cur_offset;
             header[model_names[i]]["size"] = (LLSD::Integer) size;
@@ -1159,7 +1159,7 @@ void LLModel::updateHullCenters()
         mCenterOfHullCenters += cur_center;
         cur_center *= 1.f/mPhysics.mHull[i].size();
         mHullCenter[i] = cur_center;
-        mHullPoints += mPhysics.mHull[i].size();
+        mHullPoints += static_cast<U32>(mPhysics.mHull[i].size());
     }
 
     if (mHullPoints > 0)
@@ -1280,14 +1280,14 @@ bool LLModel::loadModel(std::istream& is)
 
 bool LLModel::isMaterialListSubset( LLModel* ref )
 {
-    int refCnt = ref->mMaterialList.size();
-    int modelCnt = mMaterialList.size();
+    auto refCnt = ref->mMaterialList.size();
+    auto modelCnt = mMaterialList.size();
 
-    for (U32 src = 0; src < modelCnt; ++src)
+    for (size_t src = 0; src < modelCnt; ++src)
     {
         bool foundRef = false;
 
-        for (U32 dst = 0; dst < refCnt; ++dst)
+        for (size_t dst = 0; dst < refCnt; ++dst)
         {
             //LL_INFOS()<<mMaterialList[src]<<" "<<ref->mMaterialList[dst]<<LL_ENDL;
             foundRef = mMaterialList[src] == ref->mMaterialList[dst];
@@ -1487,7 +1487,7 @@ void LLMeshSkinInfo::fromLLSD(LLSD& skin)
             {
                 for (U32 k = 0; k < 4; k++)
                 {
-                    mat.mMatrix[j][k] = skin["inverse_bind_matrix"][i][j*4+k].asReal();
+                    mat.mMatrix[j][k] = (F32)skin["inverse_bind_matrix"][i][j*4+k].asReal();
                 }
             }
 
@@ -1510,7 +1510,7 @@ void LLMeshSkinInfo::fromLLSD(LLSD& skin)
         {
             for (U32 k = 0; k < 4; k++)
             {
-                mat.mMatrix[j][k] = skin["bind_shape_matrix"][j*4+k].asReal();
+                mat.mMatrix[j][k] = (F32)skin["bind_shape_matrix"][j*4+k].asReal();
             }
         }
         mBindShapeMatrix.loadu(mat);
@@ -1525,7 +1525,7 @@ void LLMeshSkinInfo::fromLLSD(LLSD& skin)
             {
                 for (U32 k = 0; k < 4; k++)
                 {
-                    mat.mMatrix[j][k] = skin["alt_inverse_bind_matrix"][i][j*4+k].asReal();
+                    mat.mMatrix[j][k] = (F32)skin["alt_inverse_bind_matrix"][i][j*4+k].asReal();
                 }
             }
 
@@ -1535,7 +1535,7 @@ void LLMeshSkinInfo::fromLLSD(LLSD& skin)
 
     if (skin.has("pelvis_offset"))
     {
-        mPelvisOffset = skin["pelvis_offset"].asReal();
+        mPelvisOffset = (F32)skin["pelvis_offset"].asReal();
     }
 
     if (skin.has("lock_scale_if_joint_position"))
@@ -1618,7 +1618,7 @@ void LLMeshSkinInfo::updateHash()
 
     for (size_t i = 0, count = mInvBindMatrix.size() * 16; i < count; ++i)
     {
-        S32 t = llround(src[i] * 10000.f);
+        S32 t = ll_round(src[i] * 10000.f);
         hash.update((const void*)&t, sizeof(S32));
     }
     //hash.update((const void*)mInvBindMatrix.data(), sizeof(LLMatrix4a) * mInvBindMatrix.size());
@@ -1630,15 +1630,15 @@ U32 LLMeshSkinInfo::sizeBytes() const
 {
     U32 res = sizeof(LLUUID); // mMeshID
 
-    res += sizeof(std::vector<std::string>) + sizeof(std::string) * mJointNames.size();
+    res += sizeof(std::vector<std::string>) + sizeof(std::string) * static_cast<U32>(mJointNames.size());
     for (U32 i = 0; i < mJointNames.size(); ++i)
     {
-        res += mJointNames[i].size(); // actual size, not capacity
+        res += static_cast<U32>(mJointNames[i].size()); // actual size, not capacity
     }
 
-    res += sizeof(std::vector<S32>) + sizeof(S32) * mJointNums.size();
-    res += sizeof(std::vector<LLMatrix4>) + 16 * sizeof(float) * mInvBindMatrix.size();
-    res += sizeof(std::vector<LLMatrix4>) + 16 * sizeof(float) * mAlternateBindMatrix.size();
+    res += sizeof(std::vector<S32>) + sizeof(S32) * static_cast<U32>(mJointNums.size());
+    res += sizeof(std::vector<LLMatrix4>) + 16 * sizeof(float) * static_cast<U32>(mInvBindMatrix.size());
+    res += sizeof(std::vector<LLMatrix4>) + 16 * sizeof(float) * static_cast<U32>(mAlternateBindMatrix.size());
     res += 16 * sizeof(float); //mBindShapeMatrix
     res += sizeof(float) + 3 * sizeof(bool);
 
@@ -1755,15 +1755,15 @@ U32 LLModel::Decomposition::sizeBytes() const
 {
     U32 res = sizeof(LLUUID); // mMeshID
 
-    res += sizeof(LLModel::convex_hull_decomposition) + sizeof(std::vector<LLVector3>) * mHull.size();
+    res += sizeof(LLModel::convex_hull_decomposition) + sizeof(std::vector<LLVector3>) * static_cast<U32>(mHull.size());
     for (U32 i = 0; i < mHull.size(); ++i)
     {
-        res += mHull[i].size() * sizeof(LLVector3);
+        res += static_cast<U32>(mHull[i].size()) * sizeof(LLVector3);
     }
 
-    res += sizeof(LLModel::hull) + sizeof(LLVector3) * mBaseHull.size();
+    res += sizeof(LLModel::hull) + sizeof(LLVector3) * static_cast<U32>(mBaseHull.size());
 
-    res += sizeof(std::vector<LLModel::PhysicsMesh>) + sizeof(std::vector<LLModel::PhysicsMesh>) * mMesh.size();
+    res += sizeof(std::vector<LLModel::PhysicsMesh>) + sizeof(std::vector<LLModel::PhysicsMesh>) * static_cast<U32>(mMesh.size());
     for (U32 i = 0; i < mMesh.size(); ++i)
     {
         res += mMesh[i].sizeBytes();
@@ -1814,7 +1814,7 @@ LLSD LLModel::Decomposition::asLLSD() const
 
     for (U32 i = 0; i < mHull.size(); ++i)
     {
-        U32 size = mHull[i].size();
+        U32 size = static_cast<U32>(mHull[i].size());
         total += size;
         hulls[i] = (U8) (size);
 
@@ -2015,7 +2015,7 @@ bool ll_is_degenerate(const LLVector4a& a, const LLVector4a& b, const LLVector4a
 
 bool validate_face(const LLVolumeFace& face)
 {
-    for (U32 i = 0; i < face.mNumIndices; ++i)
+    for (S32 i = 0; i < face.mNumIndices; ++i)
     {
         if (face.mIndices[i] >= face.mNumVertices)
         {
diff --git a/indra/llprimitive/llmodel.h b/indra/llprimitive/llmodel.h
index 657dc31fd2..b0cba2d655 100644
--- a/indra/llprimitive/llmodel.h
+++ b/indra/llprimitive/llmodel.h
@@ -122,8 +122,8 @@ public:
         U32 sizeBytes() const
         {
             U32 res = sizeof(std::vector<LLVector3>) * 2;
-            res += sizeof(LLVector3) * mPositions.size();
-            res += sizeof(LLVector3) * mNormals.size();
+            res += sizeof(LLVector3) * static_cast<U32>(mPositions.size());
+            res += sizeof(LLVector3) * static_cast<U32>(mNormals.size());
             return res;
         }
     };
@@ -150,7 +150,7 @@ public:
         LLModel::PhysicsMesh mPhysicsShapeMesh;
     };
 
-    LLModel(LLVolumeParams& params, F32 detail);
+    LLModel(const LLVolumeParams& params, F32 detail);
     ~LLModel();
 
     bool loadModel(std::istream& is);
@@ -165,17 +165,17 @@ public:
         LLModel* low,
         LLModel* imposotr,
         const LLModel::Decomposition& decomp,
-        BOOL upload_skin,
-        BOOL upload_joints,
-        BOOL lock_scale_if_joint_position,
-        BOOL nowrite = FALSE,
-        BOOL as_slm = FALSE,
+        bool upload_skin,
+        bool upload_joints,
+        bool lock_scale_if_joint_position,
+        bool nowrite = false,
+        bool as_slm = false,
         int submodel_id = 0);
 
     static LLSD writeModelToStream(
         std::ostream& ostr,
         LLSD& mdl,
-        BOOL nowrite = FALSE, BOOL as_slm = FALSE);
+        bool nowrite = false, bool as_slm = false);
 
     void ClearFacesAndMaterials() { mVolumeFaces.clear(); mMaterialList.clear(); }
 
@@ -256,17 +256,18 @@ public:
         }
     };
 
-
     //Are the doubles the same w/in epsilon specified tolerance
     bool areEqual( double a, double b )
     {
         const float epsilon = 1e-5f;
-        return (fabs((a - b)) < epsilon) ? true : false ;
+        return fabs(a - b) < epsilon;
     }
+
     //Make sure that we return false for any values that are within the tolerance for equivalence
     bool jointPositionalLookup( const LLVector3& a, const LLVector3& b )
     {
-         return ( areEqual( a[0],b[0]) && areEqual( a[1],b[1] ) && areEqual( a[2],b[2]) ) ? true : false;
+        const float epsilon = 1e-5f;
+        return (a - b).length() < epsilon;
     }
 
     //copy of position array for this model -- mPosition[idx].mV[X,Y,Z]
@@ -356,7 +357,7 @@ public:
 protected:
 
     LLUUID      mDiffuseMapID;
-    void*           mOpaqueData;    // allow refs to viewer/platform-specific structs for each material
+    void*       mOpaqueData{ nullptr };    // allow refs to viewer/platform-specific structs for each material
     // currently only stores an LLPointer< LLViewerFetchedTexture > > to
     // maintain refs to textures associated with each material for free
     // ref counting.
@@ -374,7 +375,7 @@ public:
     LLMatrix4 mTransform;
     material_map mMaterial;
 
-    LLModelInstanceBase(LLModel* model, LLMatrix4& transform, material_map& materials)
+    LLModelInstanceBase(LLModel* model, const LLMatrix4& transform, const material_map& materials)
         : mModel(model), mTransform(transform), mMaterial(materials)
     {
     }
@@ -403,7 +404,7 @@ public:
     LLUUID mMeshID;
     S32 mLocalMeshID;
 
-    LLModelInstance(LLModel* model, const std::string& label, LLMatrix4& transform, material_map& materials)
+    LLModelInstance(LLModel* model, const std::string& label, const LLMatrix4& transform, const material_map& materials)
         : LLModelInstanceBase(model, transform, materials), mLabel(label)
     {
         mLocalMeshID = -1;
diff --git a/indra/llprimitive/llmodelloader.cpp b/indra/llprimitive/llmodelloader.cpp
index 4120352b40..9a194567d2 100644
--- a/indra/llprimitive/llmodelloader.cpp
+++ b/indra/llprimitive/llmodelloader.cpp
@@ -37,7 +37,7 @@
 
 std::list<LLModelLoader*> LLModelLoader::sActiveLoaderList;
 
-void stretch_extents(LLModel* model, LLMatrix4a& mat, LLVector4a& min, LLVector4a& max, BOOL& first_transform)
+void stretch_extents(LLModel* model, LLMatrix4a& mat, LLVector4a& min, LLVector4a& max, bool& first_transform)
 {
     LLVector4a box[] =
     {
@@ -74,7 +74,7 @@ void stretch_extents(LLModel* model, LLMatrix4a& mat, LLVector4a& min, LLVector4
 
             if (first_transform)
             {
-                first_transform = FALSE;
+                first_transform = false;
                 min = max = v;
             }
             else
@@ -85,7 +85,7 @@ void stretch_extents(LLModel* model, LLMatrix4a& mat, LLVector4a& min, LLVector4
     }
 }
 
-void stretch_extents(LLModel* model, LLMatrix4& mat, LLVector3& min, LLVector3& max, BOOL& first_transform)
+void stretch_extents(LLModel* model, LLMatrix4& mat, LLVector3& min, LLVector3& max, bool& first_transform)
 {
     LLVector4a mina, maxa;
     LLMatrix4a mata;
@@ -121,7 +121,7 @@ LLModelLoader::LLModelLoader(
 , mFilename(filename)
 , mLod(lod)
 , mTrySLM(false)
-, mFirstTransform(TRUE)
+, mFirstTransform(true)
 , mNumOfFetchingTextures(0)
 , mLoadCallback(load_cb)
 , mJointLookupFunc(joint_lookup_func)
@@ -337,7 +337,7 @@ bool LLModelLoader::loadFromSLM(const std::string& filename)
 
 
     //convert instance_list to mScene
-    mFirstTransform = TRUE;
+    mFirstTransform = true;
     for (U32 i = 0; i < instance_list.size(); ++i)
     {
         LLModelInstance& cur_instance = instance_list[i];
@@ -478,7 +478,7 @@ bool LLModelLoader::isRigSuitableForJointPositionUpload( const std::vector<std::
 //called in the main thread
 void LLModelLoader::loadTextures()
 {
-    BOOL is_paused = isPaused() ;
+    bool is_paused = isPaused() ;
     pause() ; //pause the loader
 
     for(scene::iterator iter = mScene.begin(); iter != mScene.end(); ++iter)
diff --git a/indra/llprimitive/llmodelloader.h b/indra/llprimitive/llmodelloader.h
index 402c29c260..83bd2f5bbd 100644
--- a/indra/llprimitive/llmodelloader.h
+++ b/indra/llprimitive/llmodelloader.h
@@ -104,7 +104,7 @@ public:
     S32 mLod;
 
     LLMatrix4 mTransform;
-    BOOL mFirstTransform;
+    bool mFirstTransform;
     LLVector3 mExtents[2];
 
     bool mTrySLM;
@@ -215,7 +215,7 @@ protected:
     static bool isAlive(LLModelLoader* loader) ;
 };
 class LLMatrix4a;
-void stretch_extents(LLModel* model, LLMatrix4a& mat, LLVector4a& min, LLVector4a& max, BOOL& first_transform);
-void stretch_extents(LLModel* model, LLMatrix4& mat, LLVector3& min, LLVector3& max, BOOL& first_transform);
+void stretch_extents(LLModel* model, LLMatrix4a& mat, LLVector4a& min, LLVector4a& max, bool& first_transform);
+void stretch_extents(LLModel* model, LLMatrix4& mat, LLVector3& min, LLVector3& max, bool& first_transform);
 
 #endif  // LL_LLMODELLOADER_H
diff --git a/indra/llprimitive/llprimitive.cpp b/indra/llprimitive/llprimitive.cpp
index 1657e9324e..644476460c 100644
--- a/indra/llprimitive/llprimitive.cpp
+++ b/indra/llprimitive/llprimitive.cpp
@@ -115,8 +115,8 @@ const F32 FLEXIBLE_OBJECT_MAX_WIND_SENSITIVITY = 10.0f;
 const F32 FLEXIBLE_OBJECT_MAX_INTERNAL_TENSION_FORCE = 0.99f;
 
 const F32 FLEXIBLE_OBJECT_DEFAULT_LENGTH = 1.0f;
-const BOOL FLEXIBLE_OBJECT_DEFAULT_USING_COLLISION_SPHERE = FALSE;
-const BOOL FLEXIBLE_OBJECT_DEFAULT_RENDERING_COLLISION_SPHERE = FALSE;
+const bool FLEXIBLE_OBJECT_DEFAULT_USING_COLLISION_SPHERE = false;
+const bool FLEXIBLE_OBJECT_DEFAULT_RENDERING_COLLISION_SPHERE = false;
 
 const LLUUID SCULPT_DEFAULT_TEXTURE("be293869-d0d9-0a69-5989-ad27f1946fd4"); // old inverted texture: "7595d345-a24c-e7ef-f0bd-78793792133e";
 
@@ -172,7 +172,7 @@ void LLPrimitive::setVolumeManager( LLVolumeMgr* volume_manager )
 // static
 bool LLPrimitive::cleanupVolumeManager()
 {
-    BOOL res = FALSE;
+    bool res = false;
     if (sVolumeManager)
     {
         res = sVolumeManager->cleanup();
@@ -770,16 +770,16 @@ S32 face_index_from_id(LLFaceID face_ID, const std::vector<LLProfile::Face>& fac
     return -1;
 }
 
-BOOL LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume)
+bool LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume)
 {
     if (NO_LOD == detail)
     {
         // build the new object
         setChanged(GEOMETRY);
         sVolumeManager->unrefVolume(mVolumep);
-        mVolumep = new LLVolume(volume_params, 1, TRUE, TRUE);
+        mVolumep = new LLVolume(volume_params, 1, true, true);
         setNumTEs(mVolumep->getNumFaces());
-        return FALSE;
+        return false;
     }
 
     LLVolume *volumep;
@@ -788,9 +788,9 @@ BOOL LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detai
         F32 volume_detail = LLVolumeLODGroup::getVolumeScaleFromDetail(detail);
         if (mVolumep.notNull() && volume_params == mVolumep->getParams() && (volume_detail == mVolumep->getDetail()))
         {
-            return FALSE;
+            return false;
         }
-        volumep = new LLVolume(volume_params, volume_detail, FALSE, TRUE);
+        volumep = new LLVolume(volume_params, volume_detail, false, true);
     }
     else
     {
@@ -799,7 +799,7 @@ BOOL LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detai
             F32 volume_detail = LLVolumeLODGroup::getVolumeScaleFromDetail(detail);
             if (volume_params == mVolumep->getParams() && (volume_detail == mVolumep->getDetail()))
             {
-                return FALSE;
+                return false;
             }
         }
 
@@ -807,7 +807,7 @@ BOOL LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detai
         if (volumep == mVolumep)
         {
             sVolumeManager->unrefVolume( volumep );  // LLVolumeMgr::refVolume() creates a reference, but we don't need a second one.
-            return TRUE;
+            return true;
         }
     }
 
@@ -819,7 +819,7 @@ BOOL LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detai
         mVolumep = volumep;
         //mFaceMask = mVolumep->generateFaceMask();
         setNumTEs(mVolumep->getNumFaces());
-        return TRUE;
+        return true;
     }
 
 #if 0
@@ -871,14 +871,14 @@ BOOL LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detai
     if (old_face_mask == new_face_mask)
     {
         // nothing to do
-        return TRUE;
+        return true;
     }
 
     if (mVolumep->getNumFaces() == 0 && new_face_mask != 0)
     {
         LL_WARNS() << "Object with 0 faces found...INCORRECT!" << LL_ENDL;
         setNumTEs(mVolumep->getNumFaces());
-        return TRUE;
+        return true;
     }
 
     // initialize face_mapping
@@ -1030,19 +1030,19 @@ BOOL LLPrimitive::setVolume(const LLVolumeParams &volume_params, const S32 detai
 
     setNumTEs(mVolumep->getNumFaces());
 #endif
-    return TRUE;
+    return true;
 }
 
-BOOL LLPrimitive::setMaterial(U8 material)
+bool LLPrimitive::setMaterial(U8 material)
 {
     if (material != mMaterial)
     {
         mMaterial = material;
-        return TRUE;
+        return true;
     }
     else
     {
-        return FALSE;
+        return false;
     }
 }
 
@@ -1058,12 +1058,12 @@ S32 LLPrimitive::packTEField(U8 *cur_ptr, U8 *data_ptr, U8 data_size, U8 last_fa
 
     for (face_index = last_face_index-1; face_index >= 0; face_index--)
     {
-        BOOL already_sent = FALSE;
+        bool already_sent = false;
         for (i = face_index+1; i <= last_face_index; i++)
         {
             if (!memcmp(data_ptr+(data_size *face_index), data_ptr+(data_size *i), data_size))
             {
-                already_sent = TRUE;
+                already_sent = true;
                 break;
             }
         }
@@ -1201,7 +1201,7 @@ namespace
 // Pack information about all texture entries into container:
 // { TextureEntry Variable 2 }
 // Includes information about image ID, color, scale S,T, offset S,T and rotation
-BOOL LLPrimitive::packTEMessage(LLMessageSystem *mesgsys) const
+bool LLPrimitive::packTEMessage(LLMessageSystem *mesgsys) const
 {
     const U32 MAX_TES = 45;
 
@@ -1282,11 +1282,11 @@ BOOL LLPrimitive::packTEMessage(LLMessageSystem *mesgsys) const
     }
     mesgsys->addBinaryDataFast(_PREHASH_TextureEntry, packed_buffer, (S32)(cur_ptr - packed_buffer));
 
-    return FALSE;
+    return true;
 }
 
 
-BOOL LLPrimitive::packTEMessage(LLDataPacker &dp) const
+bool LLPrimitive::packTEMessage(LLDataPacker &dp) const
 {
     const U32 MAX_TES = 45;
 
@@ -1367,7 +1367,7 @@ BOOL LLPrimitive::packTEMessage(LLDataPacker &dp) const
     }
 
     dp.packBinaryData(packed_buffer, (S32)(cur_ptr - packed_buffer), "TextureEntry");
-    return FALSE;
+    return true;
 }
 
 S32 LLPrimitive::parseTEMessage(LLMessageSystem* mesgsys, char const* block_name, const S32 block_num, LLTEContents& tec)
@@ -1484,12 +1484,12 @@ S32 LLPrimitive::unpackTEMessage(LLDataPacker &dp)
 {
     // use a negative block_num to indicate a single-block read (a non-variable block)
     S32 retval = 0;
-    const U32 MAX_TES = 45;
+    constexpr U32 MAX_TES = 45;
 
     // Avoid construction of 32 UUIDs per call
     static LLMaterialID material_ids[MAX_TES];
 
-    const U32 MAX_TE_BUFFER = 4096;
+    constexpr U32 MAX_TE_BUFFER = 4096;
     U8 packed_buffer[MAX_TE_BUFFER];
     memset((void*)packed_buffer, 0, MAX_TE_BUFFER);
 
@@ -1685,7 +1685,7 @@ bool LLPrimitive::getTESTAxes(const U8 face, U32* s_axis, U32* t_axis)
 //============================================================================
 
 //static
-BOOL LLNetworkData::isValid(U16 param_type, U32 size)
+bool LLNetworkData::isValid(U16 param_type, U32 size)
 {
     // ew - better mechanism needed
 
@@ -1707,7 +1707,7 @@ BOOL LLNetworkData::isValid(U16 param_type, U32 size)
         return (size == 9);
     }
 
-    return FALSE;
+    return false;
 }
 
 //============================================================================
@@ -1722,17 +1722,17 @@ LLLightParams::LLLightParams()
     mType = PARAMS_LIGHT;
 }
 
-BOOL LLLightParams::pack(LLDataPacker &dp) const
+bool LLLightParams::pack(LLDataPacker &dp) const
 {
     LLColor4U color4u(mColor);
     dp.packColor4U(color4u, "color");
     dp.packF32(mRadius, "radius");
     dp.packF32(mCutoff, "cutoff");
     dp.packF32(mFalloff, "falloff");
-    return TRUE;
+    return true;
 }
 
-BOOL LLLightParams::unpack(LLDataPacker &dp)
+bool LLLightParams::unpack(LLDataPacker &dp)
 {
     LLColor4U color;
     dp.unpackColor4U(color, "color");
@@ -1750,7 +1750,7 @@ BOOL LLLightParams::unpack(LLDataPacker &dp)
     dp.unpackF32(falloff, "falloff");
     setFalloff(falloff);
 
-    return TRUE;
+    return true;
 }
 
 bool LLLightParams::operator==(const LLNetworkData& data) const
@@ -1830,15 +1830,15 @@ LLReflectionProbeParams::LLReflectionProbeParams()
     mType = PARAMS_REFLECTION_PROBE;
 }
 
-BOOL LLReflectionProbeParams::pack(LLDataPacker &dp) const
+bool LLReflectionProbeParams::pack(LLDataPacker &dp) const
 {
     dp.packF32(mAmbiance, "ambiance");
     dp.packF32(mClipDistance, "clip_distance");
     dp.packU8(mFlags, "flags");
-    return TRUE;
+    return true;
 }
 
-BOOL LLReflectionProbeParams::unpack(LLDataPacker &dp)
+bool LLReflectionProbeParams::unpack(LLDataPacker &dp)
 {
     F32 ambiance;
     F32 clip_distance;
@@ -1851,7 +1851,7 @@ BOOL LLReflectionProbeParams::unpack(LLDataPacker &dp)
 
     dp.unpackU8(mFlags, "flags");
 
-    return TRUE;
+    return true;
 }
 
 bool LLReflectionProbeParams::operator==(const LLNetworkData& data) const
@@ -1962,7 +1962,7 @@ LLFlexibleObjectData::LLFlexibleObjectData()
     mType = PARAMS_FLEXIBLE;
 }
 
-BOOL LLFlexibleObjectData::pack(LLDataPacker &dp) const
+bool LLFlexibleObjectData::pack(LLDataPacker &dp) const
 {
     // Custom, uber-svelte pack "softness" in upper bits of tension & drag
     U8 bit1 = (mSimulateLOD & 2) << 6;
@@ -1972,10 +1972,10 @@ BOOL LLFlexibleObjectData::pack(LLDataPacker &dp) const
     dp.packU8((U8)((mGravity+10.f)*10.01f), "gravity");
     dp.packU8((U8)(mWindSensitivity*10.01f), "wind");
     dp.packVector3(mUserForce, "userforce");
-    return TRUE;
+    return true;
 }
 
-BOOL LLFlexibleObjectData::unpack(LLDataPacker &dp)
+bool LLFlexibleObjectData::unpack(LLDataPacker &dp)
 {
     U8 tension, friction, gravity, wind;
     U8 bit1, bit2;
@@ -1994,7 +1994,7 @@ BOOL LLFlexibleObjectData::unpack(LLDataPacker &dp)
     {
         mUserForce.setVec(0.f, 0.f, 0.f);
     }
-    return TRUE;
+    return true;
 }
 
 bool LLFlexibleObjectData::operator==(const LLNetworkData& data) const
@@ -2090,15 +2090,15 @@ LLSculptParams::LLSculptParams()
     mSculptType = LL_SCULPT_TYPE_SPHERE;
 }
 
-BOOL LLSculptParams::pack(LLDataPacker &dp) const
+bool LLSculptParams::pack(LLDataPacker &dp) const
 {
     dp.packUUID(mSculptTexture, "texture");
     dp.packU8(mSculptType, "type");
 
-    return TRUE;
+    return true;
 }
 
-BOOL LLSculptParams::unpack(LLDataPacker &dp)
+bool LLSculptParams::unpack(LLDataPacker &dp)
 {
     U8 type;
     LLUUID id;
@@ -2106,7 +2106,7 @@ BOOL LLSculptParams::unpack(LLDataPacker &dp)
     dp.unpackU8(type, "type");
 
     setSculptTexture(id, type);
-    return TRUE;
+    return true;
 }
 
 bool LLSculptParams::operator==(const LLNetworkData& data) const
@@ -2190,20 +2190,20 @@ LLLightImageParams::LLLightImageParams()
     mParams.setVec(F_PI*0.5f, 0.f, 0.f);
 }
 
-BOOL LLLightImageParams::pack(LLDataPacker &dp) const
+bool LLLightImageParams::pack(LLDataPacker &dp) const
 {
     dp.packUUID(mLightTexture, "texture");
     dp.packVector3(mParams, "params");
 
-    return TRUE;
+    return true;
 }
 
-BOOL LLLightImageParams::unpack(LLDataPacker &dp)
+bool LLLightImageParams::unpack(LLDataPacker &dp)
 {
     dp.unpackUUID(mLightTexture, "texture");
     dp.unpackVector3(mParams, "params");
 
-    return TRUE;
+    return true;
 }
 
 bool LLLightImageParams::operator==(const LLNetworkData& data) const
@@ -2266,18 +2266,18 @@ LLExtendedMeshParams::LLExtendedMeshParams()
     mFlags = 0;
 }
 
-BOOL LLExtendedMeshParams::pack(LLDataPacker &dp) const
+bool LLExtendedMeshParams::pack(LLDataPacker &dp) const
 {
     dp.packU32(mFlags, "flags");
 
-    return TRUE;
+    return true;
 }
 
-BOOL LLExtendedMeshParams::unpack(LLDataPacker &dp)
+bool LLExtendedMeshParams::unpack(LLDataPacker &dp)
 {
     dp.unpackU32(mFlags, "flags");
 
-    return TRUE;
+    return true;
 }
 
 bool LLExtendedMeshParams::operator==(const LLNetworkData& data) const
@@ -2329,7 +2329,7 @@ LLRenderMaterialParams::LLRenderMaterialParams()
     mType = PARAMS_RENDER_MATERIAL;
 }
 
-BOOL LLRenderMaterialParams::pack(LLDataPacker& dp) const
+bool LLRenderMaterialParams::pack(LLDataPacker& dp) const
 {
     U8 count = (U8)llmin((S32)mEntries.size(), 14); //limited to 255 bytes, no more than 14 material ids
 
@@ -2340,10 +2340,10 @@ BOOL LLRenderMaterialParams::pack(LLDataPacker& dp) const
         dp.packUUID(entry.id, "id");
     }
 
-    return TRUE;
+    return true;
 }
 
-BOOL LLRenderMaterialParams::unpack(LLDataPacker& dp)
+bool LLRenderMaterialParams::unpack(LLDataPacker& dp)
 {
     U8 count;
     dp.unpackU8(count, "count");
@@ -2354,7 +2354,7 @@ BOOL LLRenderMaterialParams::unpack(LLDataPacker& dp)
         dp.unpackUUID(entry.id, "te_id");
     }
 
-    return TRUE;
+    return true;
 }
 
 bool LLRenderMaterialParams::operator==(const LLNetworkData& data) const
diff --git a/indra/llprimitive/llprimitive.h b/indra/llprimitive/llprimitive.h
index 82881dce4e..31bc76344c 100644
--- a/indra/llprimitive/llprimitive.h
+++ b/indra/llprimitive/llprimitive.h
@@ -114,11 +114,11 @@ public:
 public:
     U16 mType;
     virtual ~LLNetworkData() {};
-    virtual BOOL pack(LLDataPacker &dp) const = 0;
-    virtual BOOL unpack(LLDataPacker &dp) = 0;
+    virtual bool pack(LLDataPacker &dp) const = 0;
+    virtual bool unpack(LLDataPacker &dp) = 0;
     virtual bool operator==(const LLNetworkData& data) const = 0;
     virtual void copy(const LLNetworkData& data) = 0;
-    static BOOL isValid(U16 param_type, U32 size);
+    static bool isValid(U16 param_type, U32 size);
 };
 
 extern const F32 LIGHT_MIN_RADIUS;
@@ -141,8 +141,8 @@ private:
 
 public:
     LLLightParams();
-    /*virtual*/ BOOL pack(LLDataPacker &dp) const;
-    /*virtual*/ BOOL unpack(LLDataPacker &dp);
+    /*virtual*/ bool pack(LLDataPacker &dp) const;
+    /*virtual*/ bool unpack(LLDataPacker &dp);
     /*virtual*/ bool operator==(const LLNetworkData& data) const;
     /*virtual*/ void copy(const LLNetworkData& data);
     // LLSD implementations here are provided by Eddy Stryker.
@@ -196,8 +196,8 @@ protected:
 
 public:
     LLReflectionProbeParams();
-    /*virtual*/ BOOL pack(LLDataPacker& dp) const;
-    /*virtual*/ BOOL unpack(LLDataPacker& dp);
+    /*virtual*/ bool pack(LLDataPacker& dp) const;
+    /*virtual*/ bool unpack(LLDataPacker& dp);
     /*virtual*/ bool operator==(const LLNetworkData& data) const;
     /*virtual*/ void copy(const LLNetworkData& data);
     // LLSD implementations here are provided by Eddy Stryker.
@@ -258,8 +258,8 @@ extern const F32 FLEXIBLE_OBJECT_MAX_WIND_SENSITIVITY;
 extern const F32 FLEXIBLE_OBJECT_MAX_INTERNAL_TENSION_FORCE;
 
 extern const F32 FLEXIBLE_OBJECT_DEFAULT_LENGTH;
-extern const BOOL FLEXIBLE_OBJECT_DEFAULT_USING_COLLISION_SPHERE;
-extern const BOOL FLEXIBLE_OBJECT_DEFAULT_RENDERING_COLLISION_SPHERE;
+extern const bool FLEXIBLE_OBJECT_DEFAULT_USING_COLLISION_SPHERE;
+extern const bool FLEXIBLE_OBJECT_DEFAULT_RENDERING_COLLISION_SPHERE;
 
 
 class LLFlexibleObjectData : public LLNetworkData
@@ -271,8 +271,8 @@ protected:
     F32         mWindSensitivity;   // interacts with tension, air friction, and gravity
     F32         mTension;           //interacts in complex ways with other parameters
     LLVector3   mUserForce;         // custom user-defined force vector
-    //BOOL      mUsingCollisionSphere;
-    //BOOL      mRenderingCollisionSphere;
+    //bool      mUsingCollisionSphere;
+    //bool      mRenderingCollisionSphere;
 
 public:
     void        setSimulateLOD(S32 lod)         { mSimulateLOD = llclamp(lod, (S32)FLEXIBLE_OBJECT_MIN_SECTIONS, (S32)FLEXIBLE_OBJECT_MAX_SECTIONS); }
@@ -291,8 +291,8 @@ public:
 
     //------ the constructor for the structure ------------
     LLFlexibleObjectData();
-    BOOL pack(LLDataPacker &dp) const;
-    BOOL unpack(LLDataPacker &dp);
+    bool pack(LLDataPacker &dp) const;
+    bool unpack(LLDataPacker &dp);
     bool operator==(const LLNetworkData& data) const;
     void copy(const LLNetworkData& data);
     LLSD asLLSD() const;
@@ -310,8 +310,8 @@ protected:
 
 public:
     LLSculptParams();
-    /*virtual*/ BOOL pack(LLDataPacker &dp) const;
-    /*virtual*/ BOOL unpack(LLDataPacker &dp);
+    /*virtual*/ bool pack(LLDataPacker &dp) const;
+    /*virtual*/ bool unpack(LLDataPacker &dp);
     /*virtual*/ bool operator==(const LLNetworkData& data) const;
     /*virtual*/ void copy(const LLNetworkData& data);
     LLSD asLLSD() const;
@@ -331,8 +331,8 @@ protected:
 
 public:
     LLLightImageParams();
-    /*virtual*/ BOOL pack(LLDataPacker &dp) const;
-    /*virtual*/ BOOL unpack(LLDataPacker &dp);
+    /*virtual*/ bool pack(LLDataPacker &dp) const;
+    /*virtual*/ bool unpack(LLDataPacker &dp);
     /*virtual*/ bool operator==(const LLNetworkData& data) const;
     /*virtual*/ void copy(const LLNetworkData& data);
     LLSD asLLSD() const;
@@ -356,8 +356,8 @@ public:
     static const U32 ANIMATED_MESH_ENABLED_FLAG = 0x1 << 0;
 
     LLExtendedMeshParams();
-    /*virtual*/ BOOL pack(LLDataPacker &dp) const;
-    /*virtual*/ BOOL unpack(LLDataPacker &dp);
+    /*virtual*/ bool pack(LLDataPacker &dp) const;
+    /*virtual*/ bool unpack(LLDataPacker &dp);
     /*virtual*/ bool operator==(const LLNetworkData& data) const;
     /*virtual*/ void copy(const LLNetworkData& data);
     LLSD asLLSD() const;
@@ -381,8 +381,8 @@ private:
 
 public:
     LLRenderMaterialParams();
-    BOOL pack(LLDataPacker& dp) const override;
-    BOOL unpack(LLDataPacker& dp) override;
+    bool pack(LLDataPacker& dp) const override;
+    bool unpack(LLDataPacker& dp) override;
     bool operator==(const LLNetworkData& data) const override;
     void copy(const LLNetworkData& data) override;
 
@@ -395,7 +395,7 @@ public:
 
 // This code is not naming-standards compliant. Leaving it like this for
 // now to make the connection to code in
-//  BOOL packTEMessage(LLDataPacker &dp) const;
+//  bool packTEMessage(LLDataPacker &dp) const;
 // more obvious. This should be refactored to remove the duplication, at which
 // point we can fix the names as well.
 // - Vir
@@ -457,10 +457,10 @@ public:
     void setPCode(const LLPCode pcode);
     const LLVolume *getVolumeConst() const { return mVolumep; }     // HACK for Windoze confusion about ostream operator in LLVolume
     LLVolume *getVolume() const { return mVolumep; }
-    virtual BOOL setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume = false);
+    virtual bool setVolume(const LLVolumeParams &volume_params, const S32 detail, bool unique_volume = false);
 
     // Modify texture entry properties
-    inline BOOL validTE(const U8 te_num) const;
+    inline bool validTE(const U8 te_num) const;
     LLTextureEntry* getTE(const U8 te_num) const;
 
     virtual void setNumTEs(const U8 num_tes);
@@ -489,17 +489,17 @@ public:
     virtual S32 setTEGlow(const U8 te, const F32 glow);
     virtual S32 setTEMaterialID(const U8 te, const LLMaterialID& pMaterialID);
     virtual S32 setTEMaterialParams(const U8 index, const LLMaterialPtr pMaterialParams);
-    virtual BOOL setMaterial(const U8 material); // returns TRUE if material changed
+    virtual bool setMaterial(const U8 material); // returns true if material changed
     virtual void setTESelected(const U8 te, bool sel);
 
     LLMaterialPtr getTEMaterialParams(const U8 index);
 
     void copyTEs(const LLPrimitive *primitive);
     S32 packTEField(U8 *cur_ptr, U8 *data_ptr, U8 data_size, U8 last_face_index, EMsgVariableType type) const;
-    BOOL packTEMessage(LLMessageSystem *mesgsys) const;
-    BOOL packTEMessage(LLDataPacker &dp) const;
+    bool packTEMessage(LLMessageSystem *mesgsys) const;
+    bool packTEMessage(LLDataPacker &dp) const;
     S32 unpackTEMessage(LLMessageSystem* mesgsys, char const* block_name, const S32 block_num); // Variable num of blocks
-    BOOL unpackTEMessage(LLDataPacker &dp);
+    S32 unpackTEMessage(LLDataPacker &dp);
     S32 parseTEMessage(LLMessageSystem* mesgsys, char const* block_name, const S32 block_num, LLTEContents& tec);
     S32 applyParsedTEMessage(LLTEContents& tec);
 
@@ -557,25 +557,26 @@ public:
     // takes the contents of other_list and clears other_list
     void takeTextureList(LLPrimTextureList& other_list);
 
-    inline BOOL isAvatar() const;
-    inline BOOL isSittingAvatar() const;
-    inline BOOL isSittingAvatarOnGround() const;
+    inline bool isAvatar() const;
+    inline bool isSittingAvatar() const;
+    inline bool isSittingAvatarOnGround() const;
     inline bool hasBumpmap() const  { return mNumBumpmapTEs > 0;}
 
     void setFlags(U32 flags) { mMiscFlags = flags; }
     void addFlags(U32 flags) { mMiscFlags |= flags; }
     void removeFlags(U32 flags) { mMiscFlags &= ~flags; }
     U32 getFlags() const { return mMiscFlags; }
+    bool checkFlags(U32 flags) const { return (mMiscFlags & flags) != 0; }
 
     static std::string pCodeToString(const LLPCode pcode);
     static LLPCode legacyToPCode(const U8 legacy);
     static U8 pCodeToLegacy(const LLPCode pcode);
     static bool getTESTAxes(const U8 face, U32* s_axis, U32* t_axis);
 
-    BOOL hasRenderMaterialParams() const;
+    bool hasRenderMaterialParams() const;
 
-    inline static BOOL isPrimitive(const LLPCode pcode);
-    inline static BOOL isApp(const LLPCode pcode);
+    inline static bool isPrimitive(const LLPCode pcode);
+    inline static bool isApp(const LLPCode pcode);
 
 private:
     void updateNumBumpmap(const U8 index, const U8 bump);
@@ -601,39 +602,37 @@ public:
     };
 };
 
-inline BOOL LLPrimitive::isAvatar() const
+inline bool LLPrimitive::isAvatar() const
 {
-    return ( LL_PCODE_LEGACY_AVATAR == mPrimitiveCode ) ? TRUE : FALSE;
+    return LL_PCODE_LEGACY_AVATAR == mPrimitiveCode;
 }
 
-inline BOOL LLPrimitive::isSittingAvatar() const
+inline bool LLPrimitive::isSittingAvatar() const
 {
     // this is only used server-side
-    return ( LL_PCODE_LEGACY_AVATAR == mPrimitiveCode
-             &&  ((getFlags() & (PRIM_FLAG_SITTING | PRIM_FLAG_SITTING_ON_GROUND)) != 0) ) ? TRUE : FALSE;
+    return isAvatar() && checkFlags(PRIM_FLAG_SITTING | PRIM_FLAG_SITTING_ON_GROUND);
 }
 
-inline BOOL LLPrimitive::isSittingAvatarOnGround() const
+inline bool LLPrimitive::isSittingAvatarOnGround() const
 {
     // this is only used server-side
-    return ( LL_PCODE_LEGACY_AVATAR == mPrimitiveCode
-             &&  ((getFlags() & PRIM_FLAG_SITTING_ON_GROUND) != 0) ) ? TRUE : FALSE;
+    return isAvatar() && checkFlags(PRIM_FLAG_SITTING_ON_GROUND);
 }
 
 // static
-inline BOOL LLPrimitive::isPrimitive(const LLPCode pcode)
+inline bool LLPrimitive::isPrimitive(const LLPCode pcode)
 {
     LLPCode base_type = pcode & LL_PCODE_BASE_MASK;
 
     if (base_type && (base_type < LL_PCODE_APP))
     {
-        return TRUE;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 
 // static
-inline BOOL LLPrimitive::isApp(const LLPCode pcode)
+inline bool LLPrimitive::isApp(const LLPCode pcode)
 {
     LLPCode base_type = pcode & LL_PCODE_BASE_MASK;
 
@@ -789,7 +788,7 @@ void LLPrimitive::setAcceleration(const F32 x, const F32 y, const F32 z)
 }
 #endif // CHECK_FOR_FINITE
 
-inline BOOL LLPrimitive::validTE(const U8 te_num) const
+inline bool LLPrimitive::validTE(const U8 te_num) const
 {
     return (mNumTEs && te_num < mNumTEs);
 }
diff --git a/indra/llprimitive/llprimtexturelist.cpp b/indra/llprimitive/llprimtexturelist.cpp
index ce4df843ea..68f3f5ffac 100644
--- a/indra/llprimitive/llprimtexturelist.cpp
+++ b/indra/llprimitive/llprimtexturelist.cpp
@@ -83,13 +83,13 @@ void LLPrimTextureList::clear()
 void LLPrimTextureList::copy(const LLPrimTextureList& other_list)
 {
     // compare the sizes
-    S32 this_size = mEntryList.size();
-    S32 other_size = other_list.mEntryList.size();
+    auto this_size = mEntryList.size();
+    auto other_size = other_list.mEntryList.size();
 
     if (this_size > other_size)
     {
         // remove the extra entries
-        for (S32 index = this_size; index > other_size; --index)
+        for (size_t index = this_size; index > other_size; --index)
         {
             delete mEntryList[index-1];
         }
@@ -97,18 +97,18 @@ void LLPrimTextureList::copy(const LLPrimTextureList& other_list)
         this_size = other_size;
     }
 
-    S32 index = 0;
+    size_t index = 0;
     // copy for the entries that already exist
     for ( ; index < this_size; ++index)
     {
         delete mEntryList[index];
-        mEntryList[index] = other_list.getTexture(index)->newCopy();
+        mEntryList[index] = other_list.getTexture(static_cast<U8>(index))->newCopy();
     }
 
     // add new entires if needed
     for ( ; index < other_size; ++index)
     {
-        mEntryList.push_back( other_list.getTexture(index)->newCopy() );
+        mEntryList.push_back( other_list.getTexture(static_cast<U8>(index))->newCopy());
     }
 }
 
@@ -127,9 +127,9 @@ void LLPrimTextureList::take(LLPrimTextureList& other_list)
 // returns TEM_CHANGE_TEXTURE if successful, otherwise TEM_CHANGE_NONE
 S32 LLPrimTextureList::copyTexture(const U8 index, const LLTextureEntry& te)
 {
-    if (S32(index) >= mEntryList.size())
+    if (size_t(index) >= mEntryList.size())
     {
-        S32 current_size = mEntryList.size();
+        auto current_size = mEntryList.size();
         LL_WARNS() << "ignore copy of index = " << S32(index) << " into texture entry list of size = " << current_size << LL_ENDL;
         return TEM_CHANGE_NONE;
     }
@@ -389,7 +389,7 @@ LLMaterialPtr LLPrimTextureList::getMaterialParams(const U8 index)
 
 S32 LLPrimTextureList::size() const
 {
-    return mEntryList.size();
+    return static_cast<S32>(mEntryList.size());
 }
 
 // sets the size of the mEntryList container
@@ -400,12 +400,12 @@ void LLPrimTextureList::setSize(S32 new_size)
         new_size = 0;
     }
 
-    S32 current_size = mEntryList.size();
+    auto current_size = mEntryList.size();
 
     if (new_size > current_size)
     {
         mEntryList.resize(new_size);
-        for (S32 index = current_size; index < new_size; ++index)
+        for (size_t index = current_size; index < new_size; ++index)
         {
             if (current_size > 0
                 && mEntryList[current_size - 1])
@@ -423,7 +423,7 @@ void LLPrimTextureList::setSize(S32 new_size)
     }
     else if (new_size < current_size)
     {
-        for (S32 index = current_size-1; index >= new_size; --index)
+        for (size_t index = current_size-1; index >= new_size; --index)
         {
             delete mEntryList[index];
         }
diff --git a/indra/llprimitive/lltextureanim.cpp b/indra/llprimitive/lltextureanim.cpp
index cc156722f4..579538075a 100644
--- a/indra/llprimitive/lltextureanim.cpp
+++ b/indra/llprimitive/lltextureanim.cpp
@@ -54,38 +54,38 @@ void LLTextureAnim::reset()
     mRate = 1.f;
 }
 
-BOOL LLTextureAnim::equals(const LLTextureAnim &other) const
+bool LLTextureAnim::equals(const LLTextureAnim &other) const
 {
     if (mMode != other.mMode)
     {
-        return FALSE;
+        return false;
     }
     if (mFace != other.mFace)
     {
-        return FALSE;
+        return false;
     }
     if (mSizeX != other.mSizeX)
     {
-        return FALSE;
+        return false;
     }
     if (mSizeY != other.mSizeY)
     {
-        return FALSE;
+        return false;
     }
     if (mStart != other.mStart)
     {
-        return FALSE;
+        return false;
     }
     if (mLength != other.mLength)
     {
-        return FALSE;
+        return false;
     }
     if (mRate != other.mRate)
     {
-        return FALSE;
+        return false;
     }
 
-    return TRUE;
+    return true;
 }
 void LLTextureAnim::packTAMessage(LLMessageSystem *mesgsys) const
 {
diff --git a/indra/llprimitive/lltextureanim.h b/indra/llprimitive/lltextureanim.h
index ef76549903..2d10153043 100644
--- a/indra/llprimitive/lltextureanim.h
+++ b/indra/llprimitive/lltextureanim.h
@@ -44,7 +44,7 @@ public:
     void packTAMessage(LLDataPacker &dp) const;
     void unpackTAMessage(LLMessageSystem *mesgsys, const S32 block_num);
     void unpackTAMessage(LLDataPacker &dp);
-    BOOL equals(const LLTextureAnim &other) const;
+    bool equals(const LLTextureAnim &other) const;
     LLSD asLLSD() const;
     operator LLSD() const { return asLLSD(); }
     bool fromLLSD(LLSD& sd);
diff --git a/indra/llprimitive/lltextureentry.cpp b/indra/llprimitive/lltextureentry.cpp
index 2ed8f8c044..ac482ffbf9 100644
--- a/indra/llprimitive/lltextureentry.cpp
+++ b/indra/llprimitive/lltextureentry.cpp
@@ -407,9 +407,9 @@ S32 LLTextureEntry::setColor(const LLColor3 &color)
 
 S32 LLTextureEntry::setAlpha(const F32 alpha)
 {
-    if (mColor.mV[VW] != alpha)
+    if (mColor.mV[VALPHA] != alpha)
     {
-        mColor.mV[VW] = alpha;
+        mColor.mV[VALPHA] = alpha;
         return TEM_CHANGE_COLOR;
     }
     return TEM_CHANGE_NONE;
diff --git a/indra/llprimitive/lltreeparams.cpp b/indra/llprimitive/lltreeparams.cpp
index b85aa3acf2..b6216c022b 100644
--- a/indra/llprimitive/lltreeparams.cpp
+++ b/indra/llprimitive/lltreeparams.cpp
@@ -178,7 +178,7 @@ F32 LLTreeParams::ShapeRatio(EShapeRatio shape, F32 ratio)
         case (SR_SPHERICAL):
             return (.2f + .8f * sinf(F_PI*ratio));
         case (SR_HEMISPHERICAL):
-            return (.2f + .8f * sinf(.5*F_PI*ratio));
+            return (.2f + .8f * sinf(.5f*F_PI*ratio));
         case (SR_CYLINDRICAL):
             return (1);
         case (SR_TAPERED_CYLINDRICAL):
diff --git a/indra/llprimitive/llvolumemessage.cpp b/indra/llprimitive/llvolumemessage.cpp
index 804b208e3a..aa4bd711ab 100644
--- a/indra/llprimitive/llvolumemessage.cpp
+++ b/indra/llprimitive/llvolumemessage.cpp
@@ -478,13 +478,15 @@ bool LLVolumeMessage::constrainVolumeParams(LLVolumeParams& params)
     bad |= params.setRevolutions(params.getPathParams().getRevolutions()) ? 0 : 0x200;
     bad |= params.setRadiusOffset(params.getPathParams().getRadiusOffset()) ? 0 : 0x400;
     bad |= params.setSkew(params.getPathParams().getSkew()) ? 0 : 0x800;
-    if(bad)
+
+    if (bad)
     {
         LL_WARNS() << "LLVolumeMessage::constrainVolumeParams() - "
                 << "forced to constrain incoming volume params: "
-                << llformat("0x%04x",bad) << LL_ENDL;
+                << llformat("0x%04x", bad) << LL_ENDL;
     }
-    return bad ? false : true;
+
+    return bad == 0;
 }
 
 bool LLVolumeMessage::packVolumeParams(const LLVolumeParams* params, LLMessageSystem *mesgsys)
diff --git a/indra/llprimitive/tests/llgltfmaterial_test.cpp b/indra/llprimitive/tests/llgltfmaterial_test.cpp
index b56c9ab4f5..4f2de82386 100644
--- a/indra/llprimitive/tests/llgltfmaterial_test.cpp
+++ b/indra/llprimitive/tests/llgltfmaterial_test.cpp
@@ -1,31 +1,33 @@
-/** 
+/**
  * @file llgltfmaterial_test.cpp
  *
- * $LicenseInfo:firstyear=2023&license=viewerlgpl$                               
+ * $LicenseInfo:firstyear=2023&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2023, 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$                                                               
+ * $/LicenseInfo$
  */
 
 #include "linden_common.h"
 #include "lltut.h"
 
+#include <set>
+
 #include "../llgltfmaterial.h"
 #include "lluuid.cpp"
 
@@ -108,9 +110,9 @@ namespace tut
 
         material.setAlphaCutoff(test_fraction);
         // Because this is the default value, it should append to the extras field to mark it as an override
-        material.setAlphaMode(LLGLTFMaterial::ALPHA_MODE_OPAQUE);
+        material.setAlphaMode(LLGLTFMaterial::ALPHA_MODE_OPAQUE, true);
         // Because this is the default value, it should append to the extras field to mark it as an override
-        material.setDoubleSided(false);
+        material.setDoubleSided(false, true);
 
         return material;
     }
@@ -143,7 +145,7 @@ namespace tut
 #if LL_WINDOWS
         // If any fields are added/changed, these tests should be updated (consider also updating ASSET_VERSION in LLGLTFMaterial)
         // This test result will vary between compilers, so only test a single platform
-        ensure_equals("fields supported for GLTF (sizeof check)", sizeof(LLGLTFMaterial), 224);
+        ensure_equals("fields supported for GLTF (sizeof check)", sizeof(LLGLTFMaterial), 232);
 #endif
 #endif
         ensure_equals("LLGLTFMaterial texture info count", (U32)LLGLTFMaterial::GLTF_TEXTURE_INFO_COUNT, 4);
@@ -366,4 +368,74 @@ namespace tut
             ensure_equals("LLGLTFMaterial: double sided override flag unset", material.mOverrideDoubleSided, false);
         }
     }
+
+    template<typename T>
+    void ensure_material_hash_pre(LLGLTFMaterial& material, T& material_field, const T new_value, const std::string& field_name)
+    {
+        ensure("LLGLTFMaterial: Hash: Test field " + field_name + " is part of the test material object", (
+                    size_t(&material_field) >= size_t(&material) &&
+                    (size_t(&material_field) + sizeof(material_field)) <= (size_t(&material) + sizeof(material))
+                    ));
+        ensure("LLGLTFMaterial: Hash: " + field_name + " differs and will cause a perturbation worth hashing", material_field != new_value);
+    }
+
+    template<typename T>
+    void ensure_material_hash_not_changed(LLGLTFMaterial& material, T& material_field, const T new_value, const std::string& field_name)
+    {
+        ensure_material_hash_pre(material, material_field, new_value, field_name);
+
+        const LLGLTFMaterial old_material = material;
+        material_field = new_value;
+        // If this test fails, consult LLGLTFMaterial::getHash, and optionally consult http://www.catb.org/esr/structure-packing/ for guidance on optimal memory packing (effectiveness is platform-dependent)
+        ensure_equals(("LLGLTFMaterial: Hash: Perturbing " + field_name + " to new value does NOT change the hash").c_str(), material.getHash(), old_material.getHash());
+    }
+
+    template<typename T>
+    void ensure_material_hash_changed(LLGLTFMaterial& material, T& material_field, const T new_value, const std::string& field_name)
+    {
+        ensure_material_hash_pre(material, material_field, new_value, field_name);
+
+        const LLGLTFMaterial old_material = material;
+        material_field = new_value;
+        // If this test fails, consult LLGLTFMaterial::getHash, and optionally consult http://www.catb.org/esr/structure-packing/ for guidance on optimal memory packing (effectiveness is platform-dependent)
+        ensure_not_equals(("LLGLTFMaterial: Hash: Perturbing " + field_name + " to new value changes the hash").c_str(), material.getHash(), old_material.getHash());
+    }
+
+#define ENSURE_HASH_NOT_CHANGED(HASH_MAT, SOURCE_MAT, FIELD) ensure_material_hash_not_changed(HASH_MAT, HASH_MAT.FIELD, SOURCE_MAT.FIELD, #FIELD)
+#define ENSURE_HASH_CHANGED(HASH_MAT, SOURCE_MAT, FIELD) ensure_material_hash_changed(HASH_MAT, HASH_MAT.FIELD, SOURCE_MAT.FIELD, #FIELD)
+
+    // Test LLGLTFMaterial::getHash, which is very sensitive to the ordering of fields
+    template<> template<>
+    void llgltfmaterial_object_t::test<12>()
+    {
+        // *NOTE: Due to direct manipulation of the fields of materials
+        // throughout this test, the resulting modified materials may not be
+        // compliant or properly serializable.
+
+        // Ensure all fields of source_mat are set to values that differ from
+        // LLGLTFMaterial::sDefault, even if that would result in an invalid
+        // material object.
+        LLGLTFMaterial source_mat = create_test_material();
+        source_mat.mTrackingIdToLocalTexture[LLUUID::generateNewID()] = LLUUID::generateNewID();
+        source_mat.mLocalTexDataDigest = 1;
+        source_mat.mAlphaMode = LLGLTFMaterial::ALPHA_MODE_MASK;
+        source_mat.mDoubleSided = true;
+
+        LLGLTFMaterial hash_mat;
+
+        ENSURE_HASH_NOT_CHANGED(hash_mat, source_mat, mTrackingIdToLocalTexture);
+        ENSURE_HASH_CHANGED(hash_mat, source_mat, mLocalTexDataDigest);
+
+        ENSURE_HASH_CHANGED(hash_mat, source_mat, mTextureId);
+        ENSURE_HASH_CHANGED(hash_mat, source_mat, mTextureTransform);
+        ENSURE_HASH_CHANGED(hash_mat, source_mat, mBaseColor);
+        ENSURE_HASH_CHANGED(hash_mat, source_mat, mEmissiveColor);
+        ENSURE_HASH_CHANGED(hash_mat, source_mat, mMetallicFactor);
+        ENSURE_HASH_CHANGED(hash_mat, source_mat, mRoughnessFactor);
+        ENSURE_HASH_CHANGED(hash_mat, source_mat, mAlphaCutoff);
+        ENSURE_HASH_CHANGED(hash_mat, source_mat, mAlphaMode);
+        ENSURE_HASH_CHANGED(hash_mat, source_mat, mDoubleSided);
+        ENSURE_HASH_CHANGED(hash_mat, source_mat, mOverrideDoubleSided);
+        ENSURE_HASH_CHANGED(hash_mat, source_mat, mOverrideAlphaMode);
+    }
 }
diff --git a/indra/llprimitive/tests/llprimitive_test.cpp b/indra/llprimitive/tests/llprimitive_test.cpp
index 1b47182c28..0213a3e8b6 100644
--- a/indra/llprimitive/tests/llprimitive_test.cpp
+++ b/indra/llprimitive/tests/llprimitive_test.cpp
@@ -46,7 +46,7 @@ public:
         if (mVolumeTest.isNull() || volume_params != mCurrParamsTest || detail != mCurrDetailTest)
         {
             F32 volume_detail = LLVolumeLODGroup::getVolumeScaleFromDetail(detail);
-            mVolumeTest = new LLVolume(volume_params, volume_detail, FALSE, FALSE);
+            mVolumeTest = new LLVolume(volume_params, volume_detail, false, false);
             mCurrParamsTest = volume_params;
             mCurrDetailTest = detail;
             return mVolumeTest;
@@ -109,7 +109,7 @@ void LLPrimTextureList::take(LLPrimTextureList &other_list) { }
 void LLPrimTextureList::setSize(S32 new_size) { mEntryList.resize(new_size); }
 void LLPrimTextureList::setAllIDs(const LLUUID &id) { }
 LLTextureEntry * LLPrimTextureList::getTexture(const U8 index) const { return nullptr; }
-S32 LLPrimTextureList::size() const { return mEntryList.size(); }
+S32 LLPrimTextureList::size() const { return static_cast<S32>(mEntryList.size()); }
 
 class PRIMITIVE_TEST_SETUP
 {
@@ -193,7 +193,7 @@ namespace tut
         ensure(!primitive.isChanged(LLXform::GEOMETRY));
 
         // Make sure setVolume returns true
-        ensure(primitive.setVolume(params, 0, true) == TRUE);
+        ensure(primitive.setVolume(params, 0, true) == true);
         LLVolume* new_volume = primitive.getVolume();
 
         // make sure new volume was actually created
@@ -210,12 +210,12 @@ namespace tut
         ensure(primitive.isChanged(LLXform::GEOMETRY));
 
         // Run it twice to make sure it doesn't create a different one if params are the same
-        ensure(primitive.setVolume(params, 0, true) == FALSE);
+        ensure(primitive.setVolume(params, 0, true) == false);
         ensure(new_volume == primitive.getVolume());
 
         // Change the param definition and try setting it again.
         params.setRevolutions(4);
-        ensure(primitive.setVolume(params, 0, true) == TRUE);
+        ensure(primitive.setVolume(params, 0, true) == true);
 
         // Ensure that we now have a different volume
         ensure(new_volume != primitive.getVolume());
@@ -238,7 +238,7 @@ namespace tut
         ensure(!primitive.isChanged(LLXform::GEOMETRY));
 
         // Make sure setVolume returns true
-        ensure(primitive.setVolume(params, 0, false) == TRUE);
+        ensure(primitive.setVolume(params, 0, false) == true);
 
         LLVolume* new_volume = primitive.getVolume();
 
@@ -256,12 +256,12 @@ namespace tut
         ensure(primitive.isChanged(LLXform::GEOMETRY));
 
         // Run it twice to make sure it doesn't create a different one if params are the same
-        ensure(primitive.setVolume(params, 0, false) == FALSE);
+        ensure(primitive.setVolume(params, 0, false) == false);
         ensure(new_volume == primitive.getVolume());
 
         // Change the param definition and try setting it again.
         params.setRevolutions(4);
-        ensure(primitive.setVolume(params, 0, false) == TRUE);
+        ensure(primitive.setVolume(params, 0, false) == true);
 
         // Ensure that we now have a different volume
         ensure(new_volume != primitive.getVolume());