Merge remote-tracking branch 'origin/DRTVWR-600-maint-A' into project/gltf_development

17 files changed, 416 insertions, 427 deletions

diff --git a/indra/llmath/lloctree.h b/indra/llmath/lloctree.h
index 475ce20ae6..eaa2763d2d 100644
--- a/indra/llmath/lloctree.h
+++ b/indra/llmath/lloctree.h
@@ -453,7 +453,7 @@ public:
 
         S32 i = data->getBinIndex();
 
-        if (i >= 0 && i < getElementCount())
+        if (i >= 0 && i < (S32)getElementCount())
         {
             if (mData[i] == data)
             { //found it
diff --git a/indra/llmath/llsimdtypes.h b/indra/llmath/llsimdtypes.h
index 9db152adf8..11462170fb 100644
--- a/indra/llmath/llsimdtypes.h
+++ b/indra/llmath/llsimdtypes.h
@@ -60,7 +60,7 @@ public:
     inline operator bool() const { return static_cast<const bool&>(m_bool); }
 
 private:
-    int m_bool;
+    int m_bool{ 0 };
 };
 
 #if LL_WINDOWS
@@ -118,7 +118,7 @@ public:
     }
 
 private:
-    LLQuad mQ;
+    LLQuad mQ{};
 };
 
 #endif //LL_SIMD_TYPES_H
diff --git a/indra/llmath/llsphere.cpp b/indra/llmath/llsphere.cpp
index 89349af6c8..5f48764455 100644
--- a/indra/llmath/llsphere.cpp
+++ b/indra/llmath/llsphere.cpp
@@ -185,7 +185,7 @@ LLSphere LLSphere::getBoundingSphere(const std::vector<LLSphere>& sphere_list)
     // TODO -- improve the accuracy for small collections of spheres
 
     LLSphere bounding_sphere( LLVector3(0.f, 0.f, 0.f), 0.f );
-    S32 sphere_count = sphere_list.size();
+    auto sphere_count = sphere_list.size();
     if (1 == sphere_count)
     {
         // trivial case -- single sphere
diff --git a/indra/llmath/lltreenode.h b/indra/llmath/lltreenode.h
index f648a114ca..e3d30206b7 100644
--- a/indra/llmath/lltreenode.h
+++ b/indra/llmath/lltreenode.h
@@ -57,7 +57,7 @@ public:
     virtual bool remove(T* data);
     virtual void notifyRemoval(T* data);
     virtual U32 hasListeners() const { return !mListeners.empty(); }
-    virtual U32 getListenerCount() const { return mListeners.size(); }
+    virtual U32 getListenerCount() const { return static_cast<U32>(mListeners.size()); }
     virtual LLTreeListener<T>* getListener(U32 index) const
     {
         if (index < mListeners.size())
diff --git a/indra/llmath/llvector4a.h b/indra/llmath/llvector4a.h
index 1c3bc74f15..8ef560dadf 100644
--- a/indra/llmath/llvector4a.h
+++ b/indra/llmath/llvector4a.h
@@ -365,7 +365,7 @@ public:
     inline operator LLQuad() const;
 
 private:
-    LLQuad mQ;
+    LLQuad mQ{};
 };
 
 inline void update_min_max(LLVector4a& min, LLVector4a& max, const LLVector4a& p)
diff --git a/indra/llmath/llvector4logical.h b/indra/llmath/llvector4logical.h
index d08b5513d9..70759eef5c 100644
--- a/indra/llmath/llvector4logical.h
+++ b/indra/llmath/llvector4logical.h
@@ -120,7 +120,7 @@ public:
 
 private:
 
-    LLQuad mQ;
+    LLQuad mQ{};
 };
 
 #endif //LL_VECTOR4ALOGICAL_H
diff --git a/indra/llmath/llvolume.cpp b/indra/llmath/llvolume.cpp
index 96680a11d5..f3db9424d9 100644
--- a/indra/llmath/llvolume.cpp
+++ b/indra/llmath/llvolume.cpp
@@ -2320,7 +2320,7 @@ bool LLVolume::unpackVolumeFaces(U8* in_data, S32 size)
 bool LLVolume::unpackVolumeFacesInternal(const LLSD& mdl)
 {
     {
-        U32 face_count = mdl.size();
+        auto face_count = mdl.size();
 
         if (face_count == 0)
         { //no faces unpacked, treat as failed decode
@@ -2352,7 +2352,7 @@ bool LLVolume::unpackVolumeFacesInternal(const LLSD& mdl)
             LLSD::Binary idx = mdl[i]["TriangleList"];
 
             //copy out indices
-            S32 num_indices = idx.size() / 2;
+            auto num_indices = idx.size() / 2;
             const S32 indices_to_discard = num_indices % 3;
             if (indices_to_discard > 0)
             {
@@ -2360,7 +2360,7 @@ bool LLVolume::unpackVolumeFacesInternal(const LLSD& mdl)
                 LL_WARNS() << "Incomplete triangle discarded from face! Indices count " << num_indices << " was not divisible by 3. face index: " << i << " Total: " << face_count << LL_ENDL;
                 num_indices -= indices_to_discard;
             }
-            face.resizeIndices(num_indices);
+            face.resizeIndices(static_cast<S32>(num_indices));
 
             if (num_indices > 2 && !face.mIndices)
             {
@@ -2381,7 +2381,7 @@ bool LLVolume::unpackVolumeFacesInternal(const LLSD& mdl)
             }
 
             //copy out vertices
-            U32 num_verts = pos.size()/(3*2);
+            U32 num_verts = static_cast<U32>(pos.size())/(3*2);
             face.resizeVertices(num_verts);
 
             if (num_verts > 0 && !face.mPositions)
@@ -2645,7 +2645,7 @@ bool LLVolume::unpackVolumeFacesInternal(const LLSD& mdl)
 
             if (do_reverse_triangles)
             {
-                for (U32 j = 0; j < face.mNumIndices; j += 3)
+                for (S32 j = 0; j < face.mNumIndices; j += 3)
                 {
                     // swap the 2nd and 3rd index
                     S32 swap = face.mIndices[j+1];
@@ -2682,7 +2682,7 @@ bool LLVolume::unpackVolumeFacesInternal(const LLSD& mdl)
                     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]);
                     }
@@ -3778,7 +3778,7 @@ void LLVolume::generateSilhouetteVertices(std::vector<LLVector3> &vertices,
             LLVector4a* v = (LLVector4a*)face.mPositions;
             LLVector4a* n = (LLVector4a*)face.mNormals;
 
-            for (U32 j = 0; j < face.mNumIndices / 3; j++)
+            for (S32 j = 0; j < face.mNumIndices / 3; j++)
             {
                 for (S32 k = 0; k < 3; k++)
                 {
@@ -3904,7 +3904,7 @@ void LLVolume::generateSilhouetteVertices(std::vector<LLVector3> &vertices,
             LLVector4a* v = (LLVector4a*) face.mPositions;
             LLVector4a* n = (LLVector4a*) face.mNormals;
 
-            for (U32 j = 0; j < face.mNumIndices/3; j++)
+            for (S32 j = 0; j < face.mNumIndices/3; j++)
             {
                 //approximate normal
                 S32 v1 = face.mIndices[j*3+0];
@@ -3941,7 +3941,7 @@ void LLVolume::generateSilhouetteVertices(std::vector<LLVector3> &vertices,
             }
 
             //for each triangle
-            for (U32 j = 0; j < face.mNumIndices/3; j++)
+            for (S32 j = 0; j < face.mNumIndices/3; j++)
             {
                 if (fFacing[j] == (AWAY | TOWARDS))
                 { //this is a degenerate triangle
@@ -4943,13 +4943,13 @@ void LLVolumeFace::remap()
 {
     // Generate a remap buffer
     std::vector<unsigned int> remap(mNumVertices);
-    S32 remap_vertices_count = LLMeshOptimizer::generateRemapMultiU16(&remap[0],
+    S32 remap_vertices_count = static_cast<S32>(LLMeshOptimizer::generateRemapMultiU16(&remap[0],
         mIndices,
         mNumIndices,
         mPositions,
         mNormals,
         mTexCoords,
-        mNumVertices);
+        mNumVertices));
 
     // Allocate new buffers
     S32 size = ((mNumIndices * sizeof(U16)) + 0xF) & ~0xF;
@@ -4994,7 +4994,7 @@ void LLVolumeFace::optimize(F32 angle_cutoff)
     range.setSub(mExtents[1],mExtents[0]);
 
     //remove redundant vertices
-    for (U32 i = 0; i < mNumIndices; ++i)
+    for (S32 i = 0; i < mNumIndices; ++i)
     {
         U16 index = mIndices[i];
 
@@ -5380,7 +5380,7 @@ struct MikktData
         LLVector3 inv_scale(1.f / face->mNormalizedScale.mV[0], 1.f / face->mNormalizedScale.mV[1], 1.f / face->mNormalizedScale.mV[2]);
 
 
-        for (int i = 0; i < face->mNumIndices; ++i)
+        for (S32 i = 0; i < face->mNumIndices; ++i)
         {
             U32 idx = face->mIndices[i];
 
@@ -5391,17 +5391,6 @@ struct MikktData
             n[i].normalize();
             tc[i].set(face->mTexCoords[idx]);
 
-            if (idx >= face->mNumVertices)
-            {
-                // invalid index
-                // replace with a valid index to avoid crashes
-                idx = face->mNumVertices - 1;
-                face->mIndices[i] = idx;
-
-                // Needs better logging
-                LL_DEBUGS_ONCE("LLVOLUME") << "Invalid index, substituting" << LL_ENDL;
-            }
-
             if (face->mWeights)
             {
                 w[i].set(face->mWeights[idx].getF32ptr());
@@ -5473,7 +5462,7 @@ bool LLVolumeFace::cacheOptimize(bool gen_tangents)
 
         U32 stream_count = data.w.empty() ? 4 : 5;
 
-        size_t vert_count = meshopt_generateVertexRemapMulti(&remap[0], nullptr, data.p.size(), data.p.size(), mos, stream_count);
+        S32 vert_count = static_cast<S32>(meshopt_generateVertexRemapMulti(&remap[0], nullptr, data.p.size(), data.p.size(), mos, stream_count));
 
         if (vert_count < 65535 && vert_count != 0)
         {
@@ -5487,11 +5476,11 @@ bool LLVolumeFace::cacheOptimize(bool gen_tangents)
 
             allocateTangents(mNumVertices);
 
-            for (int i = 0; i < mNumIndices; ++i)
+            for (S32 i = 0; i < mNumIndices; ++i)
             {
                 U32 src_idx = i;
                 U32 dst_idx = remap[i];
-                if (dst_idx >= mNumVertices)
+                if (dst_idx >= (U32)mNumVertices)
                 {
                     dst_idx = mNumVertices - 1;
                     // Shouldn't happen, figure out what gets returned in remap and why.
@@ -5518,7 +5507,7 @@ bool LLVolumeFace::cacheOptimize(bool gen_tangents)
             scale.load3(mNormalizedScale.mV);
             scale.getF32ptr()[3] = 1.f;
 
-            for (int i = 0; i < mNumVertices; ++i)
+            for (S32 i = 0; i < mNumVertices; ++i)
             {
                 mPositions[i].mul(inv_scale);
                 mNormals[i].mul(scale);
@@ -6373,7 +6362,7 @@ void LLVolumeFace::createTangents()
         LLCalculateTangentArray(mNumVertices, mPositions, mNormals, mTexCoords, mNumIndices / 3, mIndices, mTangents);
 
         //normalize normals
-        for (U32 i = 0; i < mNumVertices; i++)
+        for (S32 i = 0; i < mNumVertices; i++)
         {
             //bump map/planar projection code requires normals to be normalized
             mNormals[i].normalize3fast();
@@ -6549,8 +6538,8 @@ void LLVolumeFace::pushIndex(const U16& idx)
 
 void LLVolumeFace::fillFromLegacyData(std::vector<LLVolumeFace::VertexData>& v, std::vector<U16>& idx)
 {
-    resizeVertices(v.size());
-    resizeIndices(idx.size());
+    resizeVertices(static_cast<S32>(v.size()));
+    resizeIndices(static_cast<S32>(idx.size()));
 
     for (U32 i = 0; i < v.size(); ++i)
     {
@@ -6645,7 +6634,7 @@ bool LLVolumeFace::createSide(LLVolume* volume, bool partial_build)
             {
                 // Get s value for tex-coord.
                 S32 index = mBeginS + s;
-                if (index >= profile.size())
+                if (index >= (S32)profile.size())
                 {
                     // edge?
                     ss = flat ? 1.f - begin_stex : 1.f;
diff --git a/indra/llmath/llvolume.h b/indra/llmath/llvolume.h
index 54d79290b2..bbb2a16b0b 100644
--- a/indra/llmath/llvolume.h
+++ b/indra/llmath/llvolume.h
@@ -1022,7 +1022,7 @@ public:
     U8 getProfileType() const                               { return mParams.getProfileParams().getCurveType(); }
     U8 getPathType() const                                  { return mParams.getPathParams().getCurveType(); }
     S32 getNumFaces() const;
-    S32 getNumVolumeFaces() const                           { return mVolumeFaces.size(); }
+    S32 getNumVolumeFaces() const                           { return static_cast<S32>(mVolumeFaces.size()); }
     F32 getDetail() const                                   { return mDetail; }
     F32 getSurfaceArea() const                              { return mSurfaceArea; }
     const LLVolumeParams& getParams() const                 { return mParams; }
diff --git a/indra/llmath/llvolumeoctree.cpp b/indra/llmath/llvolumeoctree.cpp
index faa169e295..71288daa89 100644
--- a/indra/llmath/llvolumeoctree.cpp
+++ b/indra/llmath/llvolumeoctree.cpp
@@ -113,7 +113,7 @@ void LLOctreeTriangleRayIntersect::traverse(const LLOctreeNode<LLVolumeTriangle,
     if (LLLineSegmentBoxIntersect(mStart, mEnd, vl->mBounds[0], vl->mBounds[1]))
     {
         node->accept(this);
-        for (S32 i = 0; i < node->getChildCount(); ++i)
+        for (U32 i = 0; i < node->getChildCount(); ++i)
         {
             traverse(node->getChild(i));
         }
diff --git a/indra/llmath/tests/v4color_test.cpp b/indra/llmath/tests/v4color_test.cpp
index 3b3adbda0d..e5d914a065 100644
--- a/indra/llmath/tests/v4color_test.cpp
+++ b/indra/llmath/tests/v4color_test.cpp
@@ -49,23 +49,23 @@ namespace tut
     void v4color_object::test<1>()
     {
         LLColor4 llcolor4;
-        ensure("1:LLColor4:Fail to initialize ", ((0 == llcolor4.mV[VX]) && (0 == llcolor4.mV[VY]) && (0 == llcolor4.mV[VZ])&& (1.0f == llcolor4.mV[VW])));
+        ensure("1:LLColor4:Fail to initialize ", ((0 == llcolor4.mV[VRED]) && (0 == llcolor4.mV[VGREEN]) && (0 == llcolor4.mV[VBLUE])&& (1.0f == llcolor4.mV[VALPHA])));
 
         F32 r = 0x20, g = 0xFFFF, b = 0xFF, a = 0xAF;
         LLColor4 llcolor4a(r,g,b);
-        ensure("2:LLColor4:Fail to initialize ", ((r == llcolor4a.mV[VX]) && (g == llcolor4a.mV[VY]) && (b == llcolor4a.mV[VZ])&& (1.0f == llcolor4a.mV[VW])));
+        ensure("2:LLColor4:Fail to initialize ", ((r == llcolor4a.mV[VRED]) && (g == llcolor4a.mV[VGREEN]) && (b == llcolor4a.mV[VBLUE])&& (1.0f == llcolor4a.mV[VALPHA])));
 
         LLColor4 llcolor4b(r,g,b,a);
-        ensure("3:LLColor4:Fail to initialize ", ((r == llcolor4b.mV[VX]) && (g == llcolor4b.mV[VY]) && (b == llcolor4b.mV[VZ])&& (a == llcolor4b.mV[VW])));
+        ensure("3:LLColor4:Fail to initialize ", ((r == llcolor4b.mV[VRED]) && (g == llcolor4b.mV[VGREEN]) && (b == llcolor4b.mV[VBLUE])&& (a == llcolor4b.mV[VALPHA])));
 
         const F32 vec[4] = {.112f ,23.2f, -4.2f, -.0001f};
         LLColor4 llcolor4c(vec);
-        ensure("4:LLColor4:Fail to initialize ", ((vec[0] == llcolor4c.mV[VX]) && (vec[1] == llcolor4c.mV[VY]) && (vec[2] == llcolor4c.mV[VZ])&& (vec[3] == llcolor4c.mV[VW])));
+        ensure("4:LLColor4:Fail to initialize ", ((vec[0] == llcolor4c.mV[VRED]) && (vec[1] == llcolor4c.mV[VGREEN]) && (vec[2] == llcolor4c.mV[VBLUE])&& (vec[3] == llcolor4c.mV[VALPHA])));
 
         LLColor3 llcolor3(-2.23f,1.01f,42.3f);
         F32 val = -.1f;
         LLColor4 llcolor4d(llcolor3,val);
-        ensure("5:LLColor4:Fail to initialize ", ((llcolor3.mV[VX] == llcolor4d.mV[VX]) && (llcolor3.mV[VY] == llcolor4d.mV[VY]) && (llcolor3.mV[VZ] == llcolor4d.mV[VZ])&& (val == llcolor4d.mV[VW])));
+        ensure("5:LLColor4:Fail to initialize ", ((llcolor3.mV[VRED] == llcolor4d.mV[VRED]) && (llcolor3.mV[VGREEN] == llcolor4d.mV[VGREEN]) && (llcolor3.mV[VBLUE] == llcolor4d.mV[VBLUE])&& (val == llcolor4d.mV[VALPHA])));
 
         LLSD sd = llcolor4d.getValue();
         LLColor4 llcolor4e(sd);
@@ -76,7 +76,7 @@ namespace tut
         LLColor4 llcolor4g(color4u);
         const F32 SCALE = 1.f/255.f;
         F32 r2 = r1*SCALE, g2 = g1* SCALE, b2 = b1* SCALE;
-        ensure("7:LLColor4:Fail to initialize ", ((r2 == llcolor4g.mV[VX]) && (g2 == llcolor4g.mV[VY]) && (b2 == llcolor4g.mV[VZ])));
+        ensure("7:LLColor4:Fail to initialize ", ((r2 == llcolor4g.mV[VRED]) && (g2 == llcolor4g.mV[VGREEN]) && (b2 == llcolor4g.mV[VBLUE])));
     }
 
     template<> template<>
@@ -98,10 +98,10 @@ namespace tut
         F32 r = 0x20, g = 0xFFFF, b = 0xFF,a = 0xAF;
         LLColor4 llcolor4(r,g,b,a);
         llcolor4.setToBlack();
-        ensure("setToBlack:Fail to set the black ", ((0 == llcolor4.mV[VX]) && (0 == llcolor4.mV[VY]) && (0 == llcolor4.mV[VZ])&& (1.0f == llcolor4.mV[VW])));
+        ensure("setToBlack:Fail to set the black ", ((0 == llcolor4.mV[VRED]) && (0 == llcolor4.mV[VGREEN]) && (0 == llcolor4.mV[VBLUE])&& (1.0f == llcolor4.mV[VALPHA])));
 
         llcolor4.setToWhite();
-        ensure("setToWhite:Fail to set the white ", ((1.f == llcolor4.mV[VX]) && (1.f == llcolor4.mV[VY]) && (1.f == llcolor4.mV[VZ])&& (1.0f == llcolor4.mV[VW])));
+        ensure("setToWhite:Fail to set the white ", ((1.f == llcolor4.mV[VRED]) && (1.f == llcolor4.mV[VGREEN]) && (1.f == llcolor4.mV[VBLUE])&& (1.0f == llcolor4.mV[VALPHA])));
     }
 
     template<> template<>
@@ -110,10 +110,10 @@ namespace tut
         F32 r = 0x20, g = 0xFFFF, b = 0xFF, a = 0xAF;
         LLColor4 llcolor4;
         llcolor4.setVec(r,g,b);
-        ensure("1:setVec:Fail to set the values ", ((r == llcolor4.mV[VX]) && (g == llcolor4.mV[VY]) && (b == llcolor4.mV[VZ])&& (1.f == llcolor4.mV[VW])));
+        ensure("1:setVec:Fail to set the values ", ((r == llcolor4.mV[VRED]) && (g == llcolor4.mV[VGREEN]) && (b == llcolor4.mV[VBLUE])&& (1.f == llcolor4.mV[VALPHA])));
 
         llcolor4.setVec(r,g,b,a);
-        ensure("2:setVec:Fail to set the values ", ((r == llcolor4.mV[VX]) && (g == llcolor4.mV[VY]) && (b == llcolor4.mV[VZ])&& (a == llcolor4.mV[VW])));
+        ensure("2:setVec:Fail to set the values ", ((r == llcolor4.mV[VRED]) && (g == llcolor4.mV[VGREEN]) && (b == llcolor4.mV[VBLUE])&& (a == llcolor4.mV[VALPHA])));
 
         LLColor4 llcolor4a;
         llcolor4a.setVec(llcolor4);
@@ -121,23 +121,23 @@ namespace tut
 
         LLColor3 llcolor3(-2.23f,1.01f,42.3f);
         llcolor4a.setVec(llcolor3);
-        ensure("4:setVec:Fail to set the values ", ((llcolor3.mV[VX] == llcolor4a.mV[VX]) && (llcolor3.mV[VY] == llcolor4a.mV[VY]) && (llcolor3.mV[VZ] == llcolor4a.mV[VZ])));
+        ensure("4:setVec:Fail to set the values ", ((llcolor3.mV[VRED] == llcolor4a.mV[VRED]) && (llcolor3.mV[VGREEN] == llcolor4a.mV[VGREEN]) && (llcolor3.mV[VBLUE] == llcolor4a.mV[VBLUE])));
 
         F32 val = -.33f;
         llcolor4a.setVec(llcolor3,val);
-        ensure("4:setVec:Fail to set the values ", ((llcolor3.mV[VX] == llcolor4a.mV[VX]) && (llcolor3.mV[VY] == llcolor4a.mV[VY]) && (llcolor3.mV[VZ] == llcolor4a.mV[VZ]) && (val == llcolor4a.mV[VW])));
+        ensure("4:setVec:Fail to set the values ", ((llcolor3.mV[VRED] == llcolor4a.mV[VRED]) && (llcolor3.mV[VGREEN] == llcolor4a.mV[VGREEN]) && (llcolor3.mV[VBLUE] == llcolor4a.mV[VBLUE]) && (val == llcolor4a.mV[VALPHA])));
 
         const F32 vec[4] = {.112f ,23.2f, -4.2f, -.0001f};
         LLColor4 llcolor4c;
         llcolor4c.setVec(vec);
-        ensure("5:setVec:Fail to initialize ", ((vec[0] == llcolor4c.mV[VX]) && (vec[1] == llcolor4c.mV[VY]) && (vec[2] == llcolor4c.mV[VZ])&& (vec[3] == llcolor4c.mV[VW])));
+        ensure("5:setVec:Fail to initialize ", ((vec[0] == llcolor4c.mV[VRED]) && (vec[1] == llcolor4c.mV[VGREEN]) && (vec[2] == llcolor4c.mV[VBLUE])&& (vec[3] == llcolor4c.mV[VALPHA])));
 
         U8 r1 = 0xF2, g1 = 0xFA, b1= 0xBF;
         LLColor4U color4u(r1,g1,b1);
         llcolor4.setVec(color4u);
         const F32 SCALE = 1.f/255.f;
         F32 r2 = r1*SCALE, g2 = g1* SCALE, b2 = b1* SCALE;
-        ensure("6:setVec:Fail to initialize ", ((r2 == llcolor4.mV[VX]) && (g2 == llcolor4.mV[VY]) && (b2 == llcolor4.mV[VZ])));
+        ensure("6:setVec:Fail to initialize ", ((r2 == llcolor4.mV[VRED]) && (g2 == llcolor4.mV[VGREEN]) && (b2 == llcolor4.mV[VBLUE])));
     }
 
     template<> template<>
@@ -146,7 +146,7 @@ namespace tut
         F32 alpha = 0xAF;
         LLColor4 llcolor4;
         llcolor4.setAlpha(alpha);
-        ensure("setAlpha:Fail to initialize ", (alpha == llcolor4.mV[VW]));
+        ensure("setAlpha:Fail to initialize ", (alpha == llcolor4.mV[VALPHA]));
     }
 
     template<> template<>
@@ -209,7 +209,7 @@ namespace tut
         LLColor3 llcolor3(r,g,b);
         LLColor4 llcolor4a,llcolor4b;
         llcolor4a = llcolor3;
-        ensure("Operator=:Fail to initialize ", ((llcolor3.mV[0] == llcolor4a.mV[VX]) && (llcolor3.mV[1] == llcolor4a.mV[VY]) && (llcolor3.mV[2] == llcolor4a.mV[VZ])));
+        ensure("Operator=:Fail to initialize ", ((llcolor3.mV[0] == llcolor4a.mV[VRED]) && (llcolor3.mV[1] == llcolor4a.mV[VGREEN]) && (llcolor3.mV[2] == llcolor4a.mV[VBLUE])));
         LLSD sd = llcolor4a.getValue();
         llcolor4b = LLColor4(sd);
         ensure_equals("Operator= LLSD:Fail ", llcolor4a, llcolor4b);
@@ -234,10 +234,10 @@ namespace tut
         F32 r2 = 0xABF, g2 = 0xFB, b2 = 0xFFF;
         LLColor4 llcolor4a(r1,g1,b1),llcolor4b(r2,g2,b2),llcolor4c;
         llcolor4c = llcolor4b + llcolor4a;
-        ensure("operator+:Fail to Add the values ",  (is_approx_equal(r1+r2,llcolor4c.mV[VX]) && is_approx_equal(g1+g2,llcolor4c.mV[VY]) && is_approx_equal(b1+b2,llcolor4c.mV[VZ])));
+        ensure("operator+:Fail to Add the values ",  (is_approx_equal(r1+r2,llcolor4c.mV[VRED]) && is_approx_equal(g1+g2,llcolor4c.mV[VGREEN]) && is_approx_equal(b1+b2,llcolor4c.mV[VBLUE])));
 
         llcolor4b += llcolor4a;
-        ensure("operator+=:Fail to Add the values ",  (is_approx_equal(r1+r2,llcolor4b.mV[VX]) && is_approx_equal(g1+g2,llcolor4b.mV[VY]) && is_approx_equal(b1+b2,llcolor4b.mV[VZ])));
+        ensure("operator+=:Fail to Add the values ",  (is_approx_equal(r1+r2,llcolor4b.mV[VRED]) && is_approx_equal(g1+g2,llcolor4b.mV[VGREEN]) && is_approx_equal(b1+b2,llcolor4b.mV[VBLUE])));
     }
 
     template<> template<>
@@ -247,10 +247,10 @@ namespace tut
         F32 r2 = 0xABF, g2 = 0xFB, b2 = 0xFFF;
         LLColor4 llcolor4a(r1,g1,b1),llcolor4b(r2,g2,b2),llcolor4c;
         llcolor4c = llcolor4a - llcolor4b;
-        ensure("operator-:Fail to subtract the values ",  (is_approx_equal(r1-r2,llcolor4c.mV[VX]) && is_approx_equal(g1-g2,llcolor4c.mV[VY]) && is_approx_equal(b1-b2,llcolor4c.mV[VZ])));
+        ensure("operator-:Fail to subtract the values ",  (is_approx_equal(r1-r2,llcolor4c.mV[VRED]) && is_approx_equal(g1-g2,llcolor4c.mV[VGREEN]) && is_approx_equal(b1-b2,llcolor4c.mV[VBLUE])));
 
         llcolor4a -= llcolor4b;
-        ensure("operator-=:Fail to subtract the values ",  (is_approx_equal(r1-r2,llcolor4a.mV[VX]) && is_approx_equal(g1-g2,llcolor4a.mV[VY]) && is_approx_equal(b1-b2,llcolor4a.mV[VZ])));
+        ensure("operator-=:Fail to subtract the values ",  (is_approx_equal(r1-r2,llcolor4a.mV[VRED]) && is_approx_equal(g1-g2,llcolor4a.mV[VGREEN]) && is_approx_equal(b1-b2,llcolor4a.mV[VBLUE])));
     }
 
     template<> template<>
@@ -260,20 +260,20 @@ namespace tut
         F32 r2 = 0xABF, g2 = 0xFB, b2 = 0xFFF;
         LLColor4 llcolor4a(r1,g1,b1),llcolor4b(r2,g2,b2),llcolor4c;
         llcolor4c = llcolor4a * llcolor4b;
-        ensure("1:operator*:Fail to multiply the values",  (is_approx_equal(r1*r2,llcolor4c.mV[VX]) && is_approx_equal(g1*g2,llcolor4c.mV[VY]) && is_approx_equal(b1*b2,llcolor4c.mV[VZ])));
+        ensure("1:operator*:Fail to multiply the values",  (is_approx_equal(r1*r2,llcolor4c.mV[VRED]) && is_approx_equal(g1*g2,llcolor4c.mV[VGREEN]) && is_approx_equal(b1*b2,llcolor4c.mV[VBLUE])));
 
         F32 mulVal = 3.33f;
         llcolor4c = llcolor4a * mulVal;
-        ensure("2:operator*:Fail ",  (is_approx_equal(r1*mulVal,llcolor4c.mV[VX]) && is_approx_equal(g1*mulVal,llcolor4c.mV[VY]) && is_approx_equal(b1*mulVal,llcolor4c.mV[VZ])));
+        ensure("2:operator*:Fail ",  (is_approx_equal(r1*mulVal,llcolor4c.mV[VRED]) && is_approx_equal(g1*mulVal,llcolor4c.mV[VGREEN]) && is_approx_equal(b1*mulVal,llcolor4c.mV[VBLUE])));
         llcolor4c = mulVal * llcolor4a;
-        ensure("3:operator*:Fail to multiply the values",  (is_approx_equal(r1*mulVal,llcolor4c.mV[VX]) && is_approx_equal(g1*mulVal,llcolor4c.mV[VY]) && is_approx_equal(b1*mulVal,llcolor4c.mV[VZ])));
+        ensure("3:operator*:Fail to multiply the values",  (is_approx_equal(r1*mulVal,llcolor4c.mV[VRED]) && is_approx_equal(g1*mulVal,llcolor4c.mV[VGREEN]) && is_approx_equal(b1*mulVal,llcolor4c.mV[VBLUE])));
 
         llcolor4a *= mulVal;
-        ensure("4:operator*=:Fail to multiply the values ",  (is_approx_equal(r1*mulVal,llcolor4a.mV[VX]) && is_approx_equal(g1*mulVal,llcolor4a.mV[VY]) && is_approx_equal(b1*mulVal,llcolor4a.mV[VZ])));
+        ensure("4:operator*=:Fail to multiply the values ",  (is_approx_equal(r1*mulVal,llcolor4a.mV[VRED]) && is_approx_equal(g1*mulVal,llcolor4a.mV[VGREEN]) && is_approx_equal(b1*mulVal,llcolor4a.mV[VBLUE])));
 
         LLColor4 llcolor4d(r1,g1,b1),llcolor4e(r2,g2,b2);
         llcolor4e *= llcolor4d;
-        ensure("5:operator*=:Fail to multiply the values ",  (is_approx_equal(r1*r2,llcolor4e.mV[VX]) && is_approx_equal(g1*g2,llcolor4e.mV[VY]) && is_approx_equal(b1*b2,llcolor4e.mV[VZ])));
+        ensure("5:operator*=:Fail to multiply the values ",  (is_approx_equal(r1*r2,llcolor4e.mV[VRED]) && is_approx_equal(g1*g2,llcolor4e.mV[VGREEN]) && is_approx_equal(b1*b2,llcolor4e.mV[VBLUE])));
     }
 
     template<> template<>
@@ -283,13 +283,13 @@ namespace tut
         F32 div = 12.345f;
         LLColor4 llcolor4a(r,g,b,a),llcolor4b;
         llcolor4b = llcolor4a % div;//chnage only alpha value nor r,g,b;
-        ensure("1operator%:Fail ",  (is_approx_equal(r,llcolor4b.mV[VX]) && is_approx_equal(g,llcolor4b.mV[VY]) && is_approx_equal(b,llcolor4b.mV[VZ])&& is_approx_equal(div*a,llcolor4b.mV[VW])));
+        ensure("1operator%:Fail ",  (is_approx_equal(r,llcolor4b.mV[VRED]) && is_approx_equal(g,llcolor4b.mV[VGREEN]) && is_approx_equal(b,llcolor4b.mV[VBLUE])&& is_approx_equal(div*a,llcolor4b.mV[VALPHA])));
 
         llcolor4b = div % llcolor4a;
-        ensure("2operator%:Fail ",  (is_approx_equal(r,llcolor4b.mV[VX]) && is_approx_equal(g,llcolor4b.mV[VY]) && is_approx_equal(b,llcolor4b.mV[VZ])&& is_approx_equal(div*a,llcolor4b.mV[VW])));
+        ensure("2operator%:Fail ",  (is_approx_equal(r,llcolor4b.mV[VRED]) && is_approx_equal(g,llcolor4b.mV[VGREEN]) && is_approx_equal(b,llcolor4b.mV[VBLUE])&& is_approx_equal(div*a,llcolor4b.mV[VALPHA])));
 
         llcolor4a %= div;
-        ensure("operator%=:Fail ",  (is_approx_equal(a*div,llcolor4a.mV[VW])));
+        ensure("operator%=:Fail ",  (is_approx_equal(a*div,llcolor4a.mV[VALPHA])));
     }
 
     template<> template<>
@@ -312,7 +312,7 @@ namespace tut
         F32 r = 0x20, g = 0xFFFF, b = 0xFF;
         LLColor4 llcolor4a(r,g,b),llcolor4b;
         LLColor3 llcolor3 = vec4to3(llcolor4a);
-        ensure("vec4to3:Fail to convert vec4 to vec3 ",  (is_approx_equal(llcolor3.mV[VX],llcolor4a.mV[VX]) && is_approx_equal(llcolor3.mV[VY],llcolor4a.mV[VY]) && is_approx_equal(llcolor3.mV[VZ],llcolor4a.mV[VZ])));
+        ensure("vec4to3:Fail to convert vec4 to vec3 ",  (is_approx_equal(llcolor3.mV[VRED],llcolor4a.mV[VRED]) && is_approx_equal(llcolor3.mV[VGREEN],llcolor4a.mV[VGREEN]) && is_approx_equal(llcolor3.mV[VBLUE],llcolor4a.mV[VBLUE])));
         llcolor4b = vec3to4(llcolor3);
         ensure_equals("vec3to4:Fail to convert vec3 to vec4 ",  llcolor4b, llcolor4a);
     }
@@ -324,7 +324,7 @@ namespace tut
         F32 r2 = 0xABF, g2 = 0xFB, b2 = 0xFFF;
         LLColor4 llcolor4a(r1,g1,b1),llcolor4b(r2,g2,b2),llcolor4c;
         llcolor4c = lerp(llcolor4a,llcolor4b,val);
-        ensure("lerp:Fail ",  (is_approx_equal(r1 + (r2 - r1)* val,llcolor4c.mV[VX]) && is_approx_equal(g1 + (g2 - g1)* val,llcolor4c.mV[VY]) && is_approx_equal(b1 + (b2 - b1)* val,llcolor4c.mV[VZ])));
+        ensure("lerp:Fail ",  (is_approx_equal(r1 + (r2 - r1)* val,llcolor4c.mV[VRED]) && is_approx_equal(g1 + (g2 - g1)* val,llcolor4c.mV[VGREEN]) && is_approx_equal(b1 + (b2 - b1)* val,llcolor4c.mV[VBLUE])));
     }
 
     template<> template<>
diff --git a/indra/llmath/tests/v4coloru_test.cpp b/indra/llmath/tests/v4coloru_test.cpp
index 55cef0fea1..9d707d18c5 100644
--- a/indra/llmath/tests/v4coloru_test.cpp
+++ b/indra/llmath/tests/v4coloru_test.cpp
@@ -48,18 +48,18 @@ namespace tut
     void v4coloru_object::test<1>()
     {
         LLColor4U llcolor4u;
-        ensure("1:LLColor4u:Fail to initialize ", ((0 == llcolor4u.mV[VX]) && (0 == llcolor4u.mV[VY]) && (0 == llcolor4u.mV[VZ])&& (255 == llcolor4u.mV[VW])));
+        ensure("1:LLColor4u:Fail to initialize ", ((0 == llcolor4u.mV[VRED]) && (0 == llcolor4u.mV[VGREEN]) && (0 == llcolor4u.mV[VBLUE])&& (255 == llcolor4u.mV[VALPHA])));
 
         U8 r = 0x12, g = 0xFF, b = 0xAF, a = 0x23;
         LLColor4U llcolor4u1(r,g,b);
-        ensure("2:LLColor4u:Fail to initialize ", ((r == llcolor4u1.mV[VX]) && (g == llcolor4u1.mV[VY]) && (b == llcolor4u1.mV[VZ])&& (255 == llcolor4u1.mV[VW])));
+        ensure("2:LLColor4u:Fail to initialize ", ((r == llcolor4u1.mV[VRED]) && (g == llcolor4u1.mV[VGREEN]) && (b == llcolor4u1.mV[VBLUE])&& (255 == llcolor4u1.mV[VALPHA])));
 
         LLColor4U llcolor4u2(r,g,b,a);
-        ensure("3:LLColor4u:Fail to initialize ", ((r == llcolor4u2.mV[VX]) && (g == llcolor4u2.mV[VY]) && (b == llcolor4u2.mV[VZ])&& (a == llcolor4u2.mV[VW])));
+        ensure("3:LLColor4u:Fail to initialize ", ((r == llcolor4u2.mV[VRED]) && (g == llcolor4u2.mV[VGREEN]) && (b == llcolor4u2.mV[VBLUE])&& (a == llcolor4u2.mV[VALPHA])));
 
         const U8 vec[4] = {0x12,0xFF,0xAF,0x23};
         LLColor4U llcolor4u3(vec);
-        ensure("4:LLColor4u:Fail to initialize ", ((vec[0] == llcolor4u3.mV[VX]) && (vec[1] == llcolor4u3.mV[VY]) && (vec[2] == llcolor4u3.mV[VZ])&& (vec[3] == llcolor4u3.mV[VW])));
+        ensure("4:LLColor4u:Fail to initialize ", ((vec[0] == llcolor4u3.mV[VRED]) && (vec[1] == llcolor4u3.mV[VGREEN]) && (vec[2] == llcolor4u3.mV[VBLUE])&& (vec[3] == llcolor4u3.mV[VALPHA])));
 
         LLSD sd = llcolor4u3.getValue();
         LLColor4U llcolor4u4(sd);
@@ -82,10 +82,10 @@ namespace tut
         U8 r = 0x12, g = 0xFF, b = 0xAF, a = 0x23;
         LLColor4U llcolor4u(r,g,b,a);
         llcolor4u.setToBlack();
-        ensure("setToBlack:Fail to set black ", ((0 == llcolor4u.mV[VX]) && (0 == llcolor4u.mV[VY]) && (0 == llcolor4u.mV[VZ])&& (255 == llcolor4u.mV[VW])));
+        ensure("setToBlack:Fail to set black ", ((0 == llcolor4u.mV[VRED]) && (0 == llcolor4u.mV[VGREEN]) && (0 == llcolor4u.mV[VBLUE])&& (255 == llcolor4u.mV[VALPHA])));
 
         llcolor4u.setToWhite();
-        ensure("setToWhite:Fail to white ", ((255 == llcolor4u.mV[VX]) && (255 == llcolor4u.mV[VY]) && (255 == llcolor4u.mV[VZ])&& (255 == llcolor4u.mV[VW])));
+        ensure("setToWhite:Fail to white ", ((255 == llcolor4u.mV[VRED]) && (255 == llcolor4u.mV[VGREEN]) && (255 == llcolor4u.mV[VBLUE])&& (255 == llcolor4u.mV[VALPHA])));
     }
 
     template<> template<>
@@ -104,11 +104,11 @@ namespace tut
         U8 r = 0x12, g = 0xFF, b = 0xAF, a = 0x23;
         LLColor4U llcolor4u;
         llcolor4u.setVec(r,g,b,a);
-        ensure("1:setVec:Fail to set the values ", ((r == llcolor4u.mV[VX]) && (g == llcolor4u.mV[VY]) && (b == llcolor4u.mV[VZ])&& (a == llcolor4u.mV[VW])));
+        ensure("1:setVec:Fail to set the values ", ((r == llcolor4u.mV[VRED]) && (g == llcolor4u.mV[VGREEN]) && (b == llcolor4u.mV[VBLUE])&& (a == llcolor4u.mV[VALPHA])));
 
         llcolor4u.setToBlack();
         llcolor4u.setVec(r,g,b);
-        ensure("2:setVec:Fail to set the values ", ((r == llcolor4u.mV[VX]) && (g == llcolor4u.mV[VY]) && (b == llcolor4u.mV[VZ])&& (255 == llcolor4u.mV[VW])));
+        ensure("2:setVec:Fail to set the values ", ((r == llcolor4u.mV[VRED]) && (g == llcolor4u.mV[VGREEN]) && (b == llcolor4u.mV[VBLUE])&& (255 == llcolor4u.mV[VALPHA])));
 
         LLColor4U llcolor4u1;
         llcolor4u1.setVec(llcolor4u);
@@ -117,7 +117,7 @@ namespace tut
         const U8 vec[4] = {0x12,0xFF,0xAF,0x23};
         LLColor4U llcolor4u2;
         llcolor4u2.setVec(vec);
-        ensure("4:setVec:Fail to set the values ", ((vec[0] == llcolor4u2.mV[VX]) && (vec[1] == llcolor4u2.mV[VY]) && (vec[2] == llcolor4u2.mV[VZ])&& (vec[3] == llcolor4u2.mV[VW])));
+        ensure("4:setVec:Fail to set the values ", ((vec[0] == llcolor4u2.mV[VRED]) && (vec[1] == llcolor4u2.mV[VGREEN]) && (vec[2] == llcolor4u2.mV[VBLUE])&& (vec[3] == llcolor4u2.mV[VALPHA])));
     }
 
     template<> template<>
@@ -126,7 +126,7 @@ namespace tut
         U8 alpha = 0x12;
         LLColor4U llcolor4u;
         llcolor4u.setAlpha(alpha);
-        ensure("setAlpha:Fail to set alpha value ", (alpha == llcolor4u.mV[VW]));
+        ensure("setAlpha:Fail to set alpha value ", (alpha == llcolor4u.mV[VALPHA]));
     }
 
     template<> template<>
@@ -159,29 +159,29 @@ namespace tut
         llcolor4u3 = llcolor4u1 + llcolor4u2;
         ensure_equals(
             "1a.operator+:Fail to Add the values ",
-            llcolor4u3.mV[VX],
+            llcolor4u3.mV[VRED],
             (U8)(r1+r2));
         ensure_equals(
             "1b.operator+:Fail to Add the values ",
-            llcolor4u3.mV[VY],
+            llcolor4u3.mV[VGREEN],
             (U8)(g1+g2));
         ensure_equals(
             "1c.operator+:Fail to Add the values ",
-            llcolor4u3.mV[VZ],
+            llcolor4u3.mV[VBLUE],
             (U8)(b1+b2));
 
         llcolor4u2 += llcolor4u1;
         ensure_equals(
             "2a.operator+=:Fail to Add the values ",
-            llcolor4u2.mV[VX],
+            llcolor4u2.mV[VRED],
             (U8)(r1+r2));
         ensure_equals(
             "2b.operator+=:Fail to Add the values ",
-            llcolor4u2.mV[VY],
+            llcolor4u2.mV[VGREEN],
             (U8)(g1+g2));
         ensure_equals(
             "2c.operator+=:Fail to Add the values ",
-            llcolor4u2.mV[VZ],
+            llcolor4u2.mV[VBLUE],
             (U8)(b1+b2));
     }
 
@@ -194,29 +194,29 @@ namespace tut
         llcolor4u3 = llcolor4u1 - llcolor4u2;
         ensure_equals(
             "1a. operator-:Fail to Add the values ",
-            llcolor4u3.mV[VX],
+            llcolor4u3.mV[VRED],
             (U8)(r1-r2));
         ensure_equals(
             "1b. operator-:Fail to Add the values ",
-            llcolor4u3.mV[VY],
+            llcolor4u3.mV[VGREEN],
             (U8)(g1-g2));
         ensure_equals(
             "1c. operator-:Fail to Add the values ",
-            llcolor4u3.mV[VZ],
+            llcolor4u3.mV[VBLUE],
             (U8)(b1-b2));
 
         llcolor4u1 -= llcolor4u2;
         ensure_equals(
             "2a. operator-=:Fail to Add the values ",
-            llcolor4u1.mV[VX],
+            llcolor4u1.mV[VRED],
             (U8)(r1-r2));
         ensure_equals(
             "2b. operator-=:Fail to Add the values ",
-            llcolor4u1.mV[VY],
+            llcolor4u1.mV[VGREEN],
             (U8)(g1-g2));
         ensure_equals(
             "2c. operator-=:Fail to Add the values ",
-            llcolor4u1.mV[VZ],
+            llcolor4u1.mV[VBLUE],
             (U8)(b1-b2));
     }
 
@@ -229,30 +229,30 @@ namespace tut
         llcolor4u3 = llcolor4u1 * llcolor4u2;
         ensure_equals(
             "1a. operator*:Fail to multiply the values",
-            llcolor4u3.mV[VX],
+            llcolor4u3.mV[VRED],
             (U8)(r1*r2));
         ensure_equals(
             "1b. operator*:Fail to multiply the values",
-            llcolor4u3.mV[VY],
+            llcolor4u3.mV[VGREEN],
             (U8)(g1*g2));
         ensure_equals(
             "1c. operator*:Fail to multiply the values",
-            llcolor4u3.mV[VZ],
+            llcolor4u3.mV[VBLUE],
             (U8)(b1*b2));
 
         U8 mulVal = 123;
         llcolor4u1 *= mulVal;
         ensure_equals(
             "2a. operator*=:Fail to multiply the values",
-            llcolor4u1.mV[VX],
+            llcolor4u1.mV[VRED],
             (U8)(r1*mulVal));
         ensure_equals(
             "2b. operator*=:Fail to multiply the values",
-            llcolor4u1.mV[VY],
+            llcolor4u1.mV[VGREEN],
             (U8)(g1*mulVal));
         ensure_equals(
             "2c. operator*=:Fail to multiply the values",
-            llcolor4u1.mV[VZ],
+            llcolor4u1.mV[VBLUE],
             (U8)(b1*mulVal));
     }
 
@@ -274,7 +274,7 @@ namespace tut
         LLColor4U llcolor4u(r,g,b,a);
         U8 modVal = 45;
         llcolor4u %= modVal;
-        ensure_equals("operator%=:Fail ", llcolor4u.mV[VW], (U8)(a * modVal));
+        ensure_equals("operator%=:Fail ", llcolor4u.mV[VALPHA], (U8)(a * modVal));
     }
 
     template<> template<>
@@ -284,7 +284,7 @@ namespace tut
         LLColor4U llcolor4u1(r,g,b,a);
         std::string color("12, 23, 132, 50");
         LLColor4U::parseColor4U(color, &llcolor4u1);
-        ensure("parseColor4U() failed to parse the color value ", ((12 == llcolor4u1.mV[VX]) && (23 == llcolor4u1.mV[VY]) && (132 == llcolor4u1.mV[VZ])&& (50 == llcolor4u1.mV[VW])));
+        ensure("parseColor4U() failed to parse the color value ", ((12 == llcolor4u1.mV[VRED]) && (23 == llcolor4u1.mV[VGREEN]) && (132 == llcolor4u1.mV[VBLUE])&& (50 == llcolor4u1.mV[VALPHA])));
 
         color = "12, 23, 132";
         ensure("2:parseColor4U() failed to parse the color value ",  (false == LLColor4U::parseColor4U(color, &llcolor4u1)));
@@ -300,8 +300,8 @@ namespace tut
         LLColor4U llcolor4u(r,g,b,a),llcolor4u1;
         const F32 fVal = 3.f;
         llcolor4u1 = llcolor4u.multAll(fVal);
-        ensure("multAll:Fail to multiply ", (((U8)ll_round(r * fVal) == llcolor4u1.mV[VX]) && (U8)ll_round(g * fVal) == llcolor4u1.mV[VY]
-                                            && ((U8)ll_round(b * fVal) == llcolor4u1.mV[VZ])&& ((U8)ll_round(a * fVal) == llcolor4u1.mV[VW])));
+        ensure("multAll:Fail to multiply ", (((U8)ll_round(r * fVal) == llcolor4u1.mV[VRED]) && (U8)ll_round(g * fVal) == llcolor4u1.mV[VGREEN]
+                                            && ((U8)ll_round(b * fVal) == llcolor4u1.mV[VBLUE])&& ((U8)ll_round(a * fVal) == llcolor4u1.mV[VALPHA])));
     }
 
     template<> template<>
@@ -311,13 +311,13 @@ namespace tut
         U8 r2 = 23, g2 = 230, b2 = 124, a2 = 255;
         LLColor4U llcolor4u(r1,g1,b1,a1),llcolor4u1(r2,g2,b2,a2);
         llcolor4u1 = llcolor4u1.addClampMax(llcolor4u);
-        ensure("1:addClampMax():Fail to add the value ",  ((r1+r2 == llcolor4u1.mV[VX]) && (255 == llcolor4u1.mV[VY]) && (b1+b2 == llcolor4u1.mV[VZ])&& (255 == llcolor4u1.mV[VW])));
+        ensure("1:addClampMax():Fail to add the value ",  ((r1+r2 == llcolor4u1.mV[VRED]) && (255 == llcolor4u1.mV[VGREEN]) && (b1+b2 == llcolor4u1.mV[VBLUE])&& (255 == llcolor4u1.mV[VALPHA])));
 
         r1 = 132, g1 = 3, b1 = 3, a1 = 2;
         r2 = 123, g2 = 230, b2 = 154, a2 = 25;
         LLColor4U llcolor4u2(r1,g1,b1,a1),llcolor4u3(r2,g2,b2,a2);
         llcolor4u3 = llcolor4u3.addClampMax(llcolor4u2);
-        ensure("2:addClampMax():Fail to add the value ",  ((255 == llcolor4u3.mV[VX]) && (g1+g2 == llcolor4u3.mV[VY]) && (b1+b2 == llcolor4u3.mV[VZ])&& (a1+a2 == llcolor4u3.mV[VW])));
+        ensure("2:addClampMax():Fail to add the value ",  ((255 == llcolor4u3.mV[VRED]) && (g1+g2 == llcolor4u3.mV[VGREEN]) && (b1+b2 == llcolor4u3.mV[VBLUE])&& (a1+a2 == llcolor4u3.mV[VALPHA])));
     }
 
     template<> template<>
@@ -331,6 +331,6 @@ namespace tut
         F32 color_scale_factor = MAX_COLOR/r;
         S32 r2 = ll_round(r * color_scale_factor);
         S32 g2 = ll_round(g * color_scale_factor);
-        ensure("setVecScaleClamp():Fail to add the value ",  ((r2 == llcolor4u.mV[VX]) && (g2 == llcolor4u.mV[VY]) && (0 == llcolor4u.mV[VZ])&& (255 == llcolor4u.mV[VW])));
+        ensure("setVecScaleClamp():Fail to add the value ",  ((r2 == llcolor4u.mV[VRED]) && (g2 == llcolor4u.mV[VGREEN]) && (0 == llcolor4u.mV[VBLUE])&& (255 == llcolor4u.mV[VALPHA])));
     }
 }
diff --git a/indra/llmath/v3color.cpp b/indra/llmath/v3color.cpp
index 9fe9c8d5e5..4367b993f8 100644
--- a/indra/llmath/v3color.cpp
+++ b/indra/llmath/v3color.cpp
@@ -63,7 +63,7 @@ const LLColor3& LLColor3::operator=(const LLColor4 &a)
 
 std::ostream& operator<<(std::ostream& s, const LLColor3 &a)
 {
-    s << "{ " << a.mV[VX] << ", " << a.mV[VY] << ", " << a.mV[VZ] << " }";
+    s << "{ " << a.mV[VRED] << ", " << a.mV[VGREEN] << ", " << a.mV[VBLUE] << " }";
     return s;
 }
 
diff --git a/indra/llmath/v3color.h b/indra/llmath/v3color.h
index ea26e9eb76..7b92f85a0c 100644
--- a/indra/llmath/v3color.h
+++ b/indra/llmath/v3color.h
@@ -196,17 +196,17 @@ inline LLColor3::LLColor3(void)
 
 inline LLColor3::LLColor3(F32 r, F32 g, F32 b)
 {
-    mV[VX] = r;
-    mV[VY] = g;
-    mV[VZ] = b;
+    mV[VRED] = r;
+    mV[VGREEN] = g;
+    mV[VBLUE] = b;
 }
 
 
 inline LLColor3::LLColor3(const F32 *vec)
 {
-    mV[VX] = vec[VX];
-    mV[VY] = vec[VY];
-    mV[VZ] = vec[VZ];
+    mV[VRED] = vec[VRED];
+    mV[VGREEN] = vec[VGREEN];
+    mV[VBLUE] = vec[VBLUE];
 }
 
 #if LL_WINDOWS
@@ -226,11 +226,11 @@ inline LLColor3::LLColor3(const char* color_string) // takes a string of format
     char tempstr[7];
     strncpy(tempstr,color_string,6);        /* Flawfinder: ignore */
     tempstr[6] = '\0';
-    mV[VZ] = (F32)strtol(&tempstr[4],NULL,16)/255.f;
+    mV[VBLUE] = (F32)strtol(&tempstr[4],NULL,16)/255.f;
     tempstr[4] = '\0';
-    mV[VY] = (F32)strtol(&tempstr[2],NULL,16)/255.f;
+    mV[VGREEN] = (F32)strtol(&tempstr[2],NULL,16)/255.f;
     tempstr[2] = '\0';
-    mV[VX] = (F32)strtol(&tempstr[0],NULL,16)/255.f;
+    mV[VRED] = (F32)strtol(&tempstr[0],NULL,16)/255.f;
 }
 
 inline const LLColor3&  LLColor3::setToBlack(void)
diff --git a/indra/llmath/v4color.cpp b/indra/llmath/v4color.cpp
index fd3548bc48..ad13656bbd 100644
--- a/indra/llmath/v4color.cpp
+++ b/indra/llmath/v4color.cpp
@@ -133,57 +133,57 @@ LLColor4::operator LLColor4U() const
 
 LLColor4::LLColor4(const LLColor3 &vec, F32 a)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
-    mV[VW] = a;
+    mV[VRED] = vec.mV[VRED];
+    mV[VGREEN] = vec.mV[VGREEN];
+    mV[VBLUE] = vec.mV[VBLUE];
+    mV[VALPHA] = a;
 }
 
 LLColor4::LLColor4(const LLColor4U& color4u)
 {
     const F32 SCALE = 1.f/255.f;
-    mV[VX] = color4u.mV[VX] * SCALE;
-    mV[VY] = color4u.mV[VY] * SCALE;
-    mV[VZ] = color4u.mV[VZ] * SCALE;
-    mV[VW] = color4u.mV[VW] * SCALE;
+    mV[VRED] = color4u.mV[VRED] * SCALE;
+    mV[VGREEN] = color4u.mV[VGREEN] * SCALE;
+    mV[VBLUE] = color4u.mV[VBLUE] * SCALE;
+    mV[VALPHA] = color4u.mV[VALPHA] * SCALE;
 }
 
 LLColor4::LLColor4(const LLVector4& vector4)
 {
-    mV[VX] = vector4.mV[VX];
-    mV[VY] = vector4.mV[VY];
-    mV[VZ] = vector4.mV[VZ];
-    mV[VW] = vector4.mV[VW];
+    mV[VRED] = vector4.mV[VRED];
+    mV[VGREEN] = vector4.mV[VGREEN];
+    mV[VBLUE] = vector4.mV[VBLUE];
+    mV[VALPHA] = vector4.mV[VALPHA];
 }
 
 const LLColor4& LLColor4::set(const LLColor4U& color4u)
 {
     const F32 SCALE = 1.f/255.f;
-    mV[VX] = color4u.mV[VX] * SCALE;
-    mV[VY] = color4u.mV[VY] * SCALE;
-    mV[VZ] = color4u.mV[VZ] * SCALE;
-    mV[VW] = color4u.mV[VW] * SCALE;
+    mV[VRED] = color4u.mV[VRED] * SCALE;
+    mV[VGREEN] = color4u.mV[VGREEN] * SCALE;
+    mV[VBLUE] = color4u.mV[VBLUE] * SCALE;
+    mV[VALPHA] = color4u.mV[VALPHA] * SCALE;
     return (*this);
 }
 
 const LLColor4& LLColor4::set(const LLColor3 &vec)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
+    mV[VRED] = vec.mV[VRED];
+    mV[VGREEN] = vec.mV[VGREEN];
+    mV[VBLUE] = vec.mV[VBLUE];
 
 //  no change to alpha!
-//  mV[VW] = 1.f;
+//  mV[VALPHA] = 1.f;
 
     return (*this);
 }
 
 const LLColor4& LLColor4::set(const LLColor3 &vec, F32 a)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
-    mV[VW] = a;
+    mV[VRED] = vec.mV[VRED];
+    mV[VGREEN] = vec.mV[VGREEN];
+    mV[VBLUE] = vec.mV[VBLUE];
+    mV[VALPHA] = a;
     return (*this);
 }
 
@@ -191,22 +191,22 @@ const LLColor4& LLColor4::set(const LLColor3 &vec, F32 a)
 const LLColor4& LLColor4::setVec(const LLColor4U& color4u)
 {
     const F32 SCALE = 1.f/255.f;
-    mV[VX] = color4u.mV[VX] * SCALE;
-    mV[VY] = color4u.mV[VY] * SCALE;
-    mV[VZ] = color4u.mV[VZ] * SCALE;
-    mV[VW] = color4u.mV[VW] * SCALE;
+    mV[VRED] = color4u.mV[VRED] * SCALE;
+    mV[VGREEN] = color4u.mV[VGREEN] * SCALE;
+    mV[VBLUE] = color4u.mV[VBLUE] * SCALE;
+    mV[VALPHA] = color4u.mV[VALPHA] * SCALE;
     return (*this);
 }
 
 // deprecated -- use set()
 const LLColor4& LLColor4::setVec(const LLColor3 &vec)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
+    mV[VRED] = vec.mV[VRED];
+    mV[VGREEN] = vec.mV[VGREEN];
+    mV[VBLUE] = vec.mV[VBLUE];
 
 //  no change to alpha!
-//  mV[VW] = 1.f;
+//  mV[VALPHA] = 1.f;
 
     return (*this);
 }
@@ -214,10 +214,10 @@ const LLColor4& LLColor4::setVec(const LLColor3 &vec)
 // deprecated -- use set()
 const LLColor4& LLColor4::setVec(const LLColor3 &vec, F32 a)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
-    mV[VW] = a;
+    mV[VRED] = vec.mV[VRED];
+    mV[VGREEN] = vec.mV[VGREEN];
+    mV[VBLUE] = vec.mV[VBLUE];
+    mV[VALPHA] = a;
     return (*this);
 }
 
@@ -257,45 +257,45 @@ void LLColor4::setValue(const LLSD& sd)
 
 const LLColor4& LLColor4::operator=(const LLColor3 &a)
 {
-    mV[VX] = a.mV[VX];
-    mV[VY] = a.mV[VY];
-    mV[VZ] = a.mV[VZ];
+    mV[VRED] = a.mV[VRED];
+    mV[VGREEN] = a.mV[VGREEN];
+    mV[VBLUE] = a.mV[VBLUE];
 
 // converting from an rgb sets a=1 (opaque)
-    mV[VW] = 1.f;
+    mV[VALPHA] = 1.f;
     return (*this);
 }
 
 
 std::ostream& operator<<(std::ostream& s, const LLColor4 &a)
 {
-    s << "{ " << a.mV[VX] << ", " << a.mV[VY] << ", " << a.mV[VZ] << ", " << a.mV[VW] << " }";
+    s << "{ " << a.mV[VRED] << ", " << a.mV[VGREEN] << ", " << a.mV[VBLUE] << ", " << a.mV[VALPHA] << " }";
     return s;
 }
 
 bool operator==(const LLColor4 &a, const LLColor3 &b)
 {
-    return (  (a.mV[VX] == b.mV[VX])
-            &&(a.mV[VY] == b.mV[VY])
-            &&(a.mV[VZ] == b.mV[VZ]));
+    return (  (a.mV[VRED] == b.mV[VRED])
+            &&(a.mV[VGREEN] == b.mV[VGREEN])
+            &&(a.mV[VBLUE] == b.mV[VBLUE]));
 }
 
 bool operator!=(const LLColor4 &a, const LLColor3 &b)
 {
-    return (  (a.mV[VX] != b.mV[VX])
-            ||(a.mV[VY] != b.mV[VY])
-            ||(a.mV[VZ] != b.mV[VZ]));
+    return (  (a.mV[VRED] != b.mV[VRED])
+            ||(a.mV[VGREEN] != b.mV[VGREEN])
+            ||(a.mV[VBLUE] != b.mV[VBLUE]));
 }
 
 LLColor3    vec4to3(const LLColor4 &vec)
 {
-    LLColor3    temp(vec.mV[VX], vec.mV[VY], vec.mV[VZ]);
+    LLColor3    temp(vec.mV[VRED], vec.mV[VGREEN], vec.mV[VBLUE]);
     return temp;
 }
 
 LLColor4    vec3to4(const LLColor3 &vec)
 {
-    LLColor3    temp(vec.mV[VX], vec.mV[VY], vec.mV[VZ]);
+    LLColor3    temp(vec.mV[VRED], vec.mV[VGREEN], vec.mV[VBLUE]);
     return temp;
 }
 
@@ -408,10 +408,10 @@ bool LLColor4::parseColor(const std::string& buf, LLColor4* color)
     {
         // There are more tokens to read.  This must be a vector.
         LLColor4 v;
-        LLStringUtil::convertToF32( color_name,  v.mV[VX] );
-        LLStringUtil::convertToF32( *token_iter, v.mV[VY] );
-        v.mV[VZ] = 0.0f;
-        v.mV[VW] = 1.0f;
+        LLStringUtil::convertToF32( color_name,  v.mV[VRED] );
+        LLStringUtil::convertToF32( *token_iter, v.mV[VGREEN] );
+        v.mV[VBLUE] = 0.0f;
+        v.mV[VALPHA] = 1.0f;
 
         ++token_iter;
         if (token_iter == tokens.end())
@@ -422,18 +422,18 @@ bool LLColor4::parseColor(const std::string& buf, LLColor4* color)
         else
         {
             // There is a z-component.
-            LLStringUtil::convertToF32( *token_iter, v.mV[VZ] );
+            LLStringUtil::convertToF32( *token_iter, v.mV[VBLUE] );
 
             ++token_iter;
             if (token_iter != tokens.end())
             {
                 // There is an alpha component.
-                LLStringUtil::convertToF32( *token_iter, v.mV[VW] );
+                LLStringUtil::convertToF32( *token_iter, v.mV[VALPHA] );
             }
         }
 
         //  Make sure all values are between 0 and 1.
-        if (v.mV[VX] > 1.f || v.mV[VY] > 1.f || v.mV[VZ] > 1.f || v.mV[VW] > 1.f)
+        if (v.mV[VRED] > 1.f || v.mV[VGREEN] > 1.f || v.mV[VBLUE] > 1.f || v.mV[VALPHA] > 1.f)
         {
             v = v * (1.f / 255.f);
         }
diff --git a/indra/llmath/v4color.h b/indra/llmath/v4color.h
index 1e20ab977a..e9bb6a07ba 100644
--- a/indra/llmath/v4color.h
+++ b/indra/llmath/v4color.h
@@ -242,10 +242,10 @@ LLColor4 lerp(const LLColor4 &a, const LLColor4 &b, F32 u);
 
 inline LLColor4::LLColor4(void)
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
-    mV[VZ] = 0.f;
-    mV[VW] = 1.f;
+    mV[VRED] = 0.f;
+    mV[VGREEN] = 0.f;
+    mV[VBLUE] = 0.f;
+    mV[VALPHA] = 1.f;
 }
 
 inline LLColor4::LLColor4(const LLSD& sd)
@@ -255,113 +255,113 @@ inline LLColor4::LLColor4(const LLSD& sd)
 
 inline LLColor4::LLColor4(F32 r, F32 g, F32 b)
 {
-    mV[VX] = r;
-    mV[VY] = g;
-    mV[VZ] = b;
-    mV[VW] = 1.f;
+    mV[VRED] = r;
+    mV[VGREEN] = g;
+    mV[VBLUE] = b;
+    mV[VALPHA] = 1.f;
 }
 
 inline LLColor4::LLColor4(F32 r, F32 g, F32 b, F32 a)
 {
-    mV[VX] = r;
-    mV[VY] = g;
-    mV[VZ] = b;
-    mV[VW] = a;
+    mV[VRED] = r;
+    mV[VGREEN] = g;
+    mV[VBLUE] = b;
+    mV[VALPHA] = a;
 }
 
 inline LLColor4::LLColor4(U32 clr)
 {
-    mV[VX] = (clr&0xff) * (1.0f/255.0f);
-    mV[VY] = ((clr>>8)&0xff) * (1.0f/255.0f);
-    mV[VZ] = ((clr>>16)&0xff) * (1.0f/255.0f);
-    mV[VW] = (clr>>24) * (1.0f/255.0f);
+    mV[VRED] = (clr&0xff) * (1.0f/255.0f);
+    mV[VGREEN] = ((clr>>8)&0xff) * (1.0f/255.0f);
+    mV[VBLUE] = ((clr>>16)&0xff) * (1.0f/255.0f);
+    mV[VALPHA] = (clr>>24) * (1.0f/255.0f);
 }
 
 
 inline LLColor4::LLColor4(const F32 *vec)
 {
-    mV[VX] = vec[VX];
-    mV[VY] = vec[VY];
-    mV[VZ] = vec[VZ];
-    mV[VW] = vec[VW];
+    mV[VRED] = vec[VRED];
+    mV[VGREEN] = vec[VGREEN];
+    mV[VBLUE] = vec[VBLUE];
+    mV[VALPHA] = vec[VALPHA];
 }
 
 inline const LLColor4&  LLColor4::setToBlack(void)
 {
-    mV[VX] = 0.f;
-    mV[VY] = 0.f;
-    mV[VZ] = 0.f;
-    mV[VW] = 1.f;
+    mV[VRED] = 0.f;
+    mV[VGREEN] = 0.f;
+    mV[VBLUE] = 0.f;
+    mV[VALPHA] = 1.f;
     return (*this);
 }
 
 inline const LLColor4&  LLColor4::setToWhite(void)
 {
-    mV[VX] = 1.f;
-    mV[VY] = 1.f;
-    mV[VZ] = 1.f;
-    mV[VW] = 1.f;
+    mV[VRED] = 1.f;
+    mV[VGREEN] = 1.f;
+    mV[VBLUE] = 1.f;
+    mV[VALPHA] = 1.f;
     return (*this);
 }
 
 inline const LLColor4&  LLColor4::set(F32 x, F32 y, F32 z)
 {
-    mV[VX] = x;
-    mV[VY] = y;
-    mV[VZ] = z;
+    mV[VRED] = x;
+    mV[VGREEN] = y;
+    mV[VBLUE] = z;
 
 //  no change to alpha!
-//  mV[VW] = 1.f;
+//  mV[VALPHA] = 1.f;
 
     return (*this);
 }
 
 inline const LLColor4&  LLColor4::set(F32 x, F32 y, F32 z, F32 a)
 {
-    mV[VX] = x;
-    mV[VY] = y;
-    mV[VZ] = z;
-    mV[VW] = a;
+    mV[VRED] = x;
+    mV[VGREEN] = y;
+    mV[VBLUE] = z;
+    mV[VALPHA] = a;
     return (*this);
 }
 
 inline const LLColor4&  LLColor4::set(const LLColor4 &vec)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
-    mV[VW] = vec.mV[VW];
+    mV[VRED] = vec.mV[VRED];
+    mV[VGREEN] = vec.mV[VGREEN];
+    mV[VBLUE] = vec.mV[VBLUE];
+    mV[VALPHA] = vec.mV[VALPHA];
     return (*this);
 }
 
 
 inline const LLColor4&  LLColor4::set(const F32 *vec)
 {
-    mV[VX] = vec[VX];
-    mV[VY] = vec[VY];
-    mV[VZ] = vec[VZ];
-    mV[VW] = vec[VW];
+    mV[VRED] = vec[VRED];
+    mV[VGREEN] = vec[VGREEN];
+    mV[VBLUE] = vec[VBLUE];
+    mV[VALPHA] = vec[VALPHA];
     return (*this);
 }
 
 inline const LLColor4&  LLColor4::set(const F64 *vec)
 {
-    mV[VX] = static_cast<F32>(vec[VX]);
-    mV[VY] = static_cast<F32>(vec[VY]);
-    mV[VZ] = static_cast<F32>(vec[VZ]);
-    mV[VW] = static_cast<F32>(vec[VW]);
+    mV[VRED] = static_cast<F32>(vec[VRED]);
+    mV[VGREEN] = static_cast<F32>(vec[VGREEN]);
+    mV[VBLUE] = static_cast<F32>(vec[VBLUE]);
+    mV[VALPHA] = static_cast<F32>(vec[VALPHA]);
     return (*this);
 }
 
 // deprecated
 inline const LLColor4&  LLColor4::setVec(F32 x, F32 y, F32 z)
 {
-    mV[VX] = x;
-    mV[VY] = y;
-    mV[VZ] = z;
+    mV[VRED] = x;
+    mV[VGREEN] = y;
+    mV[VBLUE] = z;
 
 //  no change to alpha!
-//  mV[VW] = 1.f;
+//  mV[VALPHA] = 1.f;
 
     return (*this);
 }
@@ -369,20 +369,20 @@ inline const LLColor4&  LLColor4::setVec(F32 x, F32 y, F32 z)
 // deprecated
 inline const LLColor4&  LLColor4::setVec(F32 x, F32 y, F32 z, F32 a)
 {
-    mV[VX] = x;
-    mV[VY] = y;
-    mV[VZ] = z;
-    mV[VW] = a;
+    mV[VRED] = x;
+    mV[VGREEN] = y;
+    mV[VBLUE] = z;
+    mV[VALPHA] = a;
     return (*this);
 }
 
 // deprecated
 inline const LLColor4&  LLColor4::setVec(const LLColor4 &vec)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
-    mV[VW] = vec.mV[VW];
+    mV[VRED] = vec.mV[VRED];
+    mV[VGREEN] = vec.mV[VGREEN];
+    mV[VBLUE] = vec.mV[VBLUE];
+    mV[VALPHA] = vec.mV[VALPHA];
     return (*this);
 }
 
@@ -390,16 +390,16 @@ inline const LLColor4&  LLColor4::setVec(const LLColor4 &vec)
 // deprecated
 inline const LLColor4&  LLColor4::setVec(const F32 *vec)
 {
-    mV[VX] = vec[VX];
-    mV[VY] = vec[VY];
-    mV[VZ] = vec[VZ];
-    mV[VW] = vec[VW];
+    mV[VRED] = vec[VRED];
+    mV[VGREEN] = vec[VGREEN];
+    mV[VBLUE] = vec[VBLUE];
+    mV[VALPHA] = vec[VALPHA];
     return (*this);
 }
 
 inline const LLColor4&  LLColor4::setAlpha(F32 a)
 {
-    mV[VW] = a;
+    mV[VALPHA] = a;
     return (*this);
 }
 
@@ -407,25 +407,25 @@ inline const LLColor4&  LLColor4::setAlpha(F32 a)
 
 inline F32      LLColor4::length(void) const
 {
-    return (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+    return (F32) sqrt(mV[VRED]*mV[VRED] + mV[VGREEN]*mV[VGREEN] + mV[VBLUE]*mV[VBLUE]);
 }
 
 inline F32      LLColor4::lengthSquared(void) const
 {
-    return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
+    return mV[VRED]*mV[VRED] + mV[VGREEN]*mV[VGREEN] + mV[VBLUE]*mV[VBLUE];
 }
 
 inline F32      LLColor4::normalize(void)
 {
-    F32 mag = (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+    F32 mag = (F32) sqrt(mV[VRED]*mV[VRED] + mV[VGREEN]*mV[VGREEN] + mV[VBLUE]*mV[VBLUE]);
     F32 oomag;
 
     if (mag)
     {
         oomag = 1.f/mag;
-        mV[VX] *= oomag;
-        mV[VY] *= oomag;
-        mV[VZ] *= oomag;
+        mV[VRED] *= oomag;
+        mV[VGREEN] *= oomag;
+        mV[VBLUE] *= oomag;
     }
     return (mag);
 }
@@ -433,27 +433,27 @@ inline F32      LLColor4::normalize(void)
 // deprecated
 inline F32      LLColor4::magVec(void) const
 {
-    return (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+    return (F32) sqrt(mV[VRED]*mV[VRED] + mV[VGREEN]*mV[VGREEN] + mV[VBLUE]*mV[VBLUE]);
 }
 
 // deprecated
 inline F32      LLColor4::magVecSquared(void) const
 {
-    return mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ];
+    return mV[VRED]*mV[VRED] + mV[VGREEN]*mV[VGREEN] + mV[VBLUE]*mV[VBLUE];
 }
 
 // deprecated
 inline F32      LLColor4::normVec(void)
 {
-    F32 mag = (F32) sqrt(mV[VX]*mV[VX] + mV[VY]*mV[VY] + mV[VZ]*mV[VZ]);
+    F32 mag = (F32) sqrt(mV[VRED]*mV[VRED] + mV[VGREEN]*mV[VGREEN] + mV[VBLUE]*mV[VBLUE]);
     F32 oomag;
 
     if (mag)
     {
         oomag = 1.f/mag;
-        mV[VX] *= oomag;
-        mV[VY] *= oomag;
-        mV[VZ] *= oomag;
+        mV[VRED] *= oomag;
+        mV[VGREEN] *= oomag;
+        mV[VBLUE] *= oomag;
     }
     return (mag);
 }
@@ -464,135 +464,135 @@ inline F32      LLColor4::normVec(void)
 inline LLColor4 operator+(const LLColor4 &a, const LLColor4 &b)
 {
     return LLColor4(
-        a.mV[VX] + b.mV[VX],
-        a.mV[VY] + b.mV[VY],
-        a.mV[VZ] + b.mV[VZ],
-        a.mV[VW] + b.mV[VW]);
+        a.mV[VRED] + b.mV[VRED],
+        a.mV[VGREEN] + b.mV[VGREEN],
+        a.mV[VBLUE] + b.mV[VBLUE],
+        a.mV[VALPHA] + b.mV[VALPHA]);
 }
 
 inline LLColor4 operator-(const LLColor4 &a, const LLColor4 &b)
 {
     return LLColor4(
-        a.mV[VX] - b.mV[VX],
-        a.mV[VY] - b.mV[VY],
-        a.mV[VZ] - b.mV[VZ],
-        a.mV[VW] - b.mV[VW]);
+        a.mV[VRED] - b.mV[VRED],
+        a.mV[VGREEN] - b.mV[VGREEN],
+        a.mV[VBLUE] - b.mV[VBLUE],
+        a.mV[VALPHA] - b.mV[VALPHA]);
 }
 
 inline LLColor4  operator*(const LLColor4 &a, const LLColor4 &b)
 {
     return LLColor4(
-        a.mV[VX] * b.mV[VX],
-        a.mV[VY] * b.mV[VY],
-        a.mV[VZ] * b.mV[VZ],
-        a.mV[VW] * b.mV[VW]);
+        a.mV[VRED] * b.mV[VRED],
+        a.mV[VGREEN] * b.mV[VGREEN],
+        a.mV[VBLUE] * b.mV[VBLUE],
+        a.mV[VALPHA] * b.mV[VALPHA]);
 }
 
 inline LLColor4 operator*(const LLColor4 &a, F32 k)
 {
     // only affects rgb (not a!)
     return LLColor4(
-        a.mV[VX] * k,
-        a.mV[VY] * k,
-        a.mV[VZ] * k,
-        a.mV[VW]);
+        a.mV[VRED] * k,
+        a.mV[VGREEN] * k,
+        a.mV[VBLUE] * k,
+        a.mV[VALPHA]);
 }
 
 inline LLColor4 operator/(const LLColor4 &a, F32 k)
 {
     return LLColor4(
-        a.mV[VX] / k,
-        a.mV[VY] / k,
-        a.mV[VZ] / k,
-        a.mV[VW]);
+        a.mV[VRED] / k,
+        a.mV[VGREEN] / k,
+        a.mV[VBLUE] / k,
+        a.mV[VALPHA]);
 }
 
 inline LLColor4 operator*(F32 k, const LLColor4 &a)
 {
     // only affects rgb (not a!)
     return LLColor4(
-        a.mV[VX] * k,
-        a.mV[VY] * k,
-        a.mV[VZ] * k,
-        a.mV[VW]);
+        a.mV[VRED] * k,
+        a.mV[VGREEN] * k,
+        a.mV[VBLUE] * k,
+        a.mV[VALPHA]);
 }
 
 inline LLColor4 operator%(F32 k, const LLColor4 &a)
 {
     // only affects alpha (not rgb!)
     return LLColor4(
-        a.mV[VX],
-        a.mV[VY],
-        a.mV[VZ],
-        a.mV[VW] * k);
+        a.mV[VRED],
+        a.mV[VGREEN],
+        a.mV[VBLUE],
+        a.mV[VALPHA] * k);
 }
 
 inline LLColor4 operator%(const LLColor4 &a, F32 k)
 {
     // only affects alpha (not rgb!)
     return LLColor4(
-        a.mV[VX],
-        a.mV[VY],
-        a.mV[VZ],
-        a.mV[VW] * k);
+        a.mV[VRED],
+        a.mV[VGREEN],
+        a.mV[VBLUE],
+        a.mV[VALPHA] * k);
 }
 
 inline bool operator==(const LLColor4 &a, const LLColor4 &b)
 {
-    return (  (a.mV[VX] == b.mV[VX])
-            &&(a.mV[VY] == b.mV[VY])
-            &&(a.mV[VZ] == b.mV[VZ])
-            &&(a.mV[VW] == b.mV[VW]));
+    return (  (a.mV[VRED] == b.mV[VRED])
+            &&(a.mV[VGREEN] == b.mV[VGREEN])
+            &&(a.mV[VBLUE] == b.mV[VBLUE])
+            &&(a.mV[VALPHA] == b.mV[VALPHA]));
 }
 
 inline bool operator!=(const LLColor4 &a, const LLColor4 &b)
 {
-    return (  (a.mV[VX] != b.mV[VX])
-            ||(a.mV[VY] != b.mV[VY])
-            ||(a.mV[VZ] != b.mV[VZ])
-            ||(a.mV[VW] != b.mV[VW]));
+    return (  (a.mV[VRED] != b.mV[VRED])
+            ||(a.mV[VGREEN] != b.mV[VGREEN])
+            ||(a.mV[VBLUE] != b.mV[VBLUE])
+            ||(a.mV[VALPHA] != b.mV[VALPHA]));
 }
 
 inline const LLColor4& operator+=(LLColor4 &a, const LLColor4 &b)
 {
-    a.mV[VX] += b.mV[VX];
-    a.mV[VY] += b.mV[VY];
-    a.mV[VZ] += b.mV[VZ];
-    a.mV[VW] += b.mV[VW];
+    a.mV[VRED] += b.mV[VRED];
+    a.mV[VGREEN] += b.mV[VGREEN];
+    a.mV[VBLUE] += b.mV[VBLUE];
+    a.mV[VALPHA] += b.mV[VALPHA];
     return a;
 }
 
 inline const LLColor4& operator-=(LLColor4 &a, const LLColor4 &b)
 {
-    a.mV[VX] -= b.mV[VX];
-    a.mV[VY] -= b.mV[VY];
-    a.mV[VZ] -= b.mV[VZ];
-    a.mV[VW] -= b.mV[VW];
+    a.mV[VRED] -= b.mV[VRED];
+    a.mV[VGREEN] -= b.mV[VGREEN];
+    a.mV[VBLUE] -= b.mV[VBLUE];
+    a.mV[VALPHA] -= b.mV[VALPHA];
     return a;
 }
 
 inline const LLColor4& operator*=(LLColor4 &a, F32 k)
 {
     // only affects rgb (not a!)
-    a.mV[VX] *= k;
-    a.mV[VY] *= k;
-    a.mV[VZ] *= k;
+    a.mV[VRED] *= k;
+    a.mV[VGREEN] *= k;
+    a.mV[VBLUE] *= k;
     return a;
 }
 
 inline const LLColor4& operator *=(LLColor4 &a, const LLColor4 &b)
 {
-    a.mV[VX] *= b.mV[VX];
-    a.mV[VY] *= b.mV[VY];
-    a.mV[VZ] *= b.mV[VZ];
-//  a.mV[VW] *= b.mV[VW];
+    a.mV[VRED] *= b.mV[VRED];
+    a.mV[VGREEN] *= b.mV[VGREEN];
+    a.mV[VBLUE] *= b.mV[VBLUE];
+//  a.mV[VALPHA] *= b.mV[VALPHA];
     return a;
 }
 
 inline const LLColor4& operator%=(LLColor4 &a, F32 k)
 {
     // only affects alpha (not rgb!)
-    a.mV[VW] *= k;
+    a.mV[VALPHA] *= k;
     return a;
 }
 
@@ -614,10 +614,10 @@ inline F32      distVec_squared(const LLColor4 &a, const LLColor4 &b)
 inline LLColor4 lerp(const LLColor4 &a, const LLColor4 &b, F32 u)
 {
     return LLColor4(
-        a.mV[VX] + (b.mV[VX] - a.mV[VX]) * u,
-        a.mV[VY] + (b.mV[VY] - a.mV[VY]) * u,
-        a.mV[VZ] + (b.mV[VZ] - a.mV[VZ]) * u,
-        a.mV[VW] + (b.mV[VW] - a.mV[VW]) * u);
+        a.mV[VRED] + (b.mV[VRED] - a.mV[VRED]) * u,
+        a.mV[VGREEN] + (b.mV[VGREEN] - a.mV[VGREEN]) * u,
+        a.mV[VBLUE] + (b.mV[VBLUE] - a.mV[VBLUE]) * u,
+        a.mV[VALPHA] + (b.mV[VALPHA] - a.mV[VALPHA]) * u);
 }
 
 inline bool LLColor4::operator<(const LLColor4& rhs) const
diff --git a/indra/llmath/v4coloru.cpp b/indra/llmath/v4coloru.cpp
index 45d310856a..acf349245a 100644
--- a/indra/llmath/v4coloru.cpp
+++ b/indra/llmath/v4coloru.cpp
@@ -53,10 +53,10 @@ LLColor4U::operator LLColor4()
 /*
 LLColor4U::LLColor4U(const LLColor3 &vec)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
-    mV[VW] = 255;
+    mV[VRED] = vec.mV[VRED];
+    mV[VGREEN] = vec.mV[VGREEN];
+    mV[VBLUE] = vec.mV[VBLUE];
+    mV[VALPHA] = 255;
 }
 */
 
@@ -70,12 +70,12 @@ LLColor4U::LLColor4U(const LLColor3 &vec)
 /*
 LLColor4U LLColor4U::operator=(const LLColor3 &a)
 {
-    mV[VX] = a.mV[VX];
-    mV[VY] = a.mV[VY];
-    mV[VZ] = a.mV[VZ];
+    mV[VRED] = a.mV[VRED];
+    mV[VGREEN] = a.mV[VGREEN];
+    mV[VBLUE] = a.mV[VBLUE];
 
 // converting from an rgb sets a=1 (opaque)
-    mV[VW] = 255;
+    mV[VALPHA] = 255;
     return (*this);
 }
 */
@@ -83,7 +83,7 @@ LLColor4U LLColor4U::operator=(const LLColor3 &a)
 
 std::ostream& operator<<(std::ostream& s, const LLColor4U &a)
 {
-    s << "{ " << (S32)a.mV[VX] << ", " << (S32)a.mV[VY] << ", " << (S32)a.mV[VZ] << ", " << (S32)a.mV[VW] << " }";
+    s << "{ " << (S32)a.mV[VRED] << ", " << (S32)a.mV[VGREEN] << ", " << (S32)a.mV[VBLUE] << ", " << (S32)a.mV[VALPHA] << " }";
     return s;
 }
 
diff --git a/indra/llmath/v4coloru.h b/indra/llmath/v4coloru.h
index 6d921d12fa..29128a08a7 100644
--- a/indra/llmath/v4coloru.h
+++ b/indra/llmath/v4coloru.h
@@ -142,34 +142,34 @@ F32     distVec_squared(const LLColor4U &a, const LLColor4U &b);    // Returns d
 
 inline LLColor4U::LLColor4U()
 {
-    mV[VX] = 0;
-    mV[VY] = 0;
-    mV[VZ] = 0;
-    mV[VW] = 255;
+    mV[VRED] = 0;
+    mV[VGREEN] = 0;
+    mV[VBLUE] = 0;
+    mV[VALPHA] = 255;
 }
 
 inline LLColor4U::LLColor4U(U8 r, U8 g, U8 b)
 {
-    mV[VX] = r;
-    mV[VY] = g;
-    mV[VZ] = b;
-    mV[VW] = 255;
+    mV[VRED] = r;
+    mV[VGREEN] = g;
+    mV[VBLUE] = b;
+    mV[VALPHA] = 255;
 }
 
 inline LLColor4U::LLColor4U(U8 r, U8 g, U8 b, U8 a)
 {
-    mV[VX] = r;
-    mV[VY] = g;
-    mV[VZ] = b;
-    mV[VW] = a;
+    mV[VRED] = r;
+    mV[VGREEN] = g;
+    mV[VBLUE] = b;
+    mV[VALPHA] = a;
 }
 
 inline LLColor4U::LLColor4U(const U8 *vec)
 {
-    mV[VX] = vec[VX];
-    mV[VY] = vec[VY];
-    mV[VZ] = vec[VZ];
-    mV[VW] = vec[VW];
+    mV[VRED] = vec[VRED];
+    mV[VGREEN] = vec[VGREEN];
+    mV[VBLUE] = vec[VBLUE];
+    mV[VALPHA] = vec[VALPHA];
 }
 
 /*
@@ -181,30 +181,30 @@ inline LLColor4U::operator LLColor4()
 
 inline const LLColor4U& LLColor4U::setToBlack(void)
 {
-    mV[VX] = 0;
-    mV[VY] = 0;
-    mV[VZ] = 0;
-    mV[VW] = 255;
+    mV[VRED] = 0;
+    mV[VGREEN] = 0;
+    mV[VBLUE] = 0;
+    mV[VALPHA] = 255;
     return (*this);
 }
 
 inline const LLColor4U& LLColor4U::setToWhite(void)
 {
-    mV[VX] = 255;
-    mV[VY] = 255;
-    mV[VZ] = 255;
-    mV[VW] = 255;
+    mV[VRED] = 255;
+    mV[VGREEN] = 255;
+    mV[VBLUE] = 255;
+    mV[VALPHA] = 255;
     return (*this);
 }
 
 inline const LLColor4U& LLColor4U::set(const U8 x, const U8 y, const U8 z)
 {
-    mV[VX] = x;
-    mV[VY] = y;
-    mV[VZ] = z;
+    mV[VRED] = x;
+    mV[VGREEN] = y;
+    mV[VBLUE] = z;
 
 //  no change to alpha!
-//  mV[VW] = 255;
+//  mV[VALPHA] = 255;
 
     return (*this);
 }
@@ -220,31 +220,31 @@ inline const LLColor4U& LLColor4U::set(const U8 r, const U8 g, const U8 b, U8 a)
 
 inline const LLColor4U& LLColor4U::set(const LLColor4U &vec)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
-    mV[VW] = vec.mV[VW];
+    mV[VRED] = vec.mV[VRED];
+    mV[VGREEN] = vec.mV[VGREEN];
+    mV[VBLUE] = vec.mV[VBLUE];
+    mV[VALPHA] = vec.mV[VALPHA];
     return (*this);
 }
 
 inline const LLColor4U& LLColor4U::set(const U8 *vec)
 {
-    mV[VX] = vec[VX];
-    mV[VY] = vec[VY];
-    mV[VZ] = vec[VZ];
-    mV[VW] = vec[VW];
+    mV[VRED] = vec[VRED];
+    mV[VGREEN] = vec[VGREEN];
+    mV[VBLUE] = vec[VBLUE];
+    mV[VALPHA] = vec[VALPHA];
     return (*this);
 }
 
 // deprecated
 inline const LLColor4U& LLColor4U::setVec(const U8 x, const U8 y, const U8 z)
 {
-    mV[VX] = x;
-    mV[VY] = y;
-    mV[VZ] = z;
+    mV[VRED] = x;
+    mV[VGREEN] = y;
+    mV[VBLUE] = z;
 
 //  no change to alpha!
-//  mV[VW] = 255;
+//  mV[VALPHA] = 255;
 
     return (*this);
 }
@@ -262,26 +262,26 @@ inline const LLColor4U& LLColor4U::setVec(const U8 r, const U8 g, const U8 b, U8
 // deprecated
 inline const LLColor4U& LLColor4U::setVec(const LLColor4U &vec)
 {
-    mV[VX] = vec.mV[VX];
-    mV[VY] = vec.mV[VY];
-    mV[VZ] = vec.mV[VZ];
-    mV[VW] = vec.mV[VW];
+    mV[VRED] = vec.mV[VRED];
+    mV[VGREEN] = vec.mV[VGREEN];
+    mV[VBLUE] = vec.mV[VBLUE];
+    mV[VALPHA] = vec.mV[VALPHA];
     return (*this);
 }
 
 // deprecated
 inline const LLColor4U& LLColor4U::setVec(const U8 *vec)
 {
-    mV[VX] = vec[VX];
-    mV[VY] = vec[VY];
-    mV[VZ] = vec[VZ];
-    mV[VW] = vec[VW];
+    mV[VRED] = vec[VRED];
+    mV[VGREEN] = vec[VGREEN];
+    mV[VBLUE] = vec[VBLUE];
+    mV[VALPHA] = vec[VALPHA];
     return (*this);
 }
 
 inline const LLColor4U& LLColor4U::setAlpha(U8 a)
 {
-    mV[VW] = a;
+    mV[VALPHA] = a;
     return (*this);
 }
 
@@ -289,159 +289,159 @@ inline const LLColor4U& LLColor4U::setAlpha(U8 a)
 
 inline F32      LLColor4U::length(void) const
 {
-    return (F32) sqrt( ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ] );
+    return (F32) sqrt( ((F32)mV[VRED]) * mV[VRED] + ((F32)mV[VGREEN]) * mV[VGREEN] + ((F32)mV[VBLUE]) * mV[VBLUE] );
 }
 
 inline F32      LLColor4U::lengthSquared(void) const
 {
-    return ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ];
+    return ((F32)mV[VRED]) * mV[VRED] + ((F32)mV[VGREEN]) * mV[VGREEN] + ((F32)mV[VBLUE]) * mV[VBLUE];
 }
 
 // deprecated
 inline F32      LLColor4U::magVec(void) const
 {
-    return (F32) sqrt( ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ] );
+    return (F32) sqrt( ((F32)mV[VRED]) * mV[VRED] + ((F32)mV[VGREEN]) * mV[VGREEN] + ((F32)mV[VBLUE]) * mV[VBLUE] );
 }
 
 // deprecated
 inline F32      LLColor4U::magVecSquared(void) const
 {
-    return ((F32)mV[VX]) * mV[VX] + ((F32)mV[VY]) * mV[VY] + ((F32)mV[VZ]) * mV[VZ];
+    return ((F32)mV[VRED]) * mV[VRED] + ((F32)mV[VGREEN]) * mV[VGREEN] + ((F32)mV[VBLUE]) * mV[VBLUE];
 }
 
 inline LLColor4U operator+(const LLColor4U &a, const LLColor4U &b)
 {
     return LLColor4U(
-        a.mV[VX] + b.mV[VX],
-        a.mV[VY] + b.mV[VY],
-        a.mV[VZ] + b.mV[VZ],
-        a.mV[VW] + b.mV[VW]);
+        a.mV[VRED] + b.mV[VRED],
+        a.mV[VGREEN] + b.mV[VGREEN],
+        a.mV[VBLUE] + b.mV[VBLUE],
+        a.mV[VALPHA] + b.mV[VALPHA]);
 }
 
 inline LLColor4U operator-(const LLColor4U &a, const LLColor4U &b)
 {
     return LLColor4U(
-        a.mV[VX] - b.mV[VX],
-        a.mV[VY] - b.mV[VY],
-        a.mV[VZ] - b.mV[VZ],
-        a.mV[VW] - b.mV[VW]);
+        a.mV[VRED] - b.mV[VRED],
+        a.mV[VGREEN] - b.mV[VGREEN],
+        a.mV[VBLUE] - b.mV[VBLUE],
+        a.mV[VALPHA] - b.mV[VALPHA]);
 }
 
 inline LLColor4U  operator*(const LLColor4U &a, const LLColor4U &b)
 {
     return LLColor4U(
-        a.mV[VX] * b.mV[VX],
-        a.mV[VY] * b.mV[VY],
-        a.mV[VZ] * b.mV[VZ],
-        a.mV[VW] * b.mV[VW]);
+        a.mV[VRED] * b.mV[VRED],
+        a.mV[VGREEN] * b.mV[VGREEN],
+        a.mV[VBLUE] * b.mV[VBLUE],
+        a.mV[VALPHA] * b.mV[VALPHA]);
 }
 
 inline LLColor4U LLColor4U::addClampMax(const LLColor4U &color)
 {
-    return LLColor4U(llmin((S32)mV[VX] + color.mV[VX], 255),
-                    llmin((S32)mV[VY] + color.mV[VY], 255),
-                    llmin((S32)mV[VZ] + color.mV[VZ], 255),
-                    llmin((S32)mV[VW] + color.mV[VW], 255));
+    return LLColor4U(llmin((S32)mV[VRED] + color.mV[VRED], 255),
+                    llmin((S32)mV[VGREEN] + color.mV[VGREEN], 255),
+                    llmin((S32)mV[VBLUE] + color.mV[VBLUE], 255),
+                    llmin((S32)mV[VALPHA] + color.mV[VALPHA], 255));
 }
 
 inline LLColor4U LLColor4U::multAll(const F32 k)
 {
     // Round to nearest
     return LLColor4U(
-        (U8)ll_round(mV[VX] * k),
-        (U8)ll_round(mV[VY] * k),
-        (U8)ll_round(mV[VZ] * k),
-        (U8)ll_round(mV[VW] * k));
+        (U8)ll_round(mV[VRED] * k),
+        (U8)ll_round(mV[VGREEN] * k),
+        (U8)ll_round(mV[VBLUE] * k),
+        (U8)ll_round(mV[VALPHA] * k));
 }
 /*
 inline LLColor4U operator*(const LLColor4U &a, U8 k)
 {
     // only affects rgb (not a!)
     return LLColor4U(
-        a.mV[VX] * k,
-        a.mV[VY] * k,
-        a.mV[VZ] * k,
-        a.mV[VW]);
+        a.mV[VRED] * k,
+        a.mV[VGREEN] * k,
+        a.mV[VBLUE] * k,
+        a.mV[VALPHA]);
 }
 
 inline LLColor4U operator*(U8 k, const LLColor4U &a)
 {
     // only affects rgb (not a!)
     return LLColor4U(
-        a.mV[VX] * k,
-        a.mV[VY] * k,
-        a.mV[VZ] * k,
-        a.mV[VW]);
+        a.mV[VRED] * k,
+        a.mV[VGREEN] * k,
+        a.mV[VBLUE] * k,
+        a.mV[VALPHA]);
 }
 
 inline LLColor4U operator%(U8 k, const LLColor4U &a)
 {
     // only affects alpha (not rgb!)
     return LLColor4U(
-        a.mV[VX],
-        a.mV[VY],
-        a.mV[VZ],
-        a.mV[VW] * k );
+        a.mV[VRED],
+        a.mV[VGREEN],
+        a.mV[VBLUE],
+        a.mV[VALPHA] * k );
 }
 
 inline LLColor4U operator%(const LLColor4U &a, U8 k)
 {
     // only affects alpha (not rgb!)
     return LLColor4U(
-        a.mV[VX],
-        a.mV[VY],
-        a.mV[VZ],
-        a.mV[VW] * k );
+        a.mV[VRED],
+        a.mV[VGREEN],
+        a.mV[VBLUE],
+        a.mV[VALPHA] * k );
 }
 */
 
 inline bool operator==(const LLColor4U &a, const LLColor4U &b)
 {
-    return (  (a.mV[VX] == b.mV[VX])
-            &&(a.mV[VY] == b.mV[VY])
-            &&(a.mV[VZ] == b.mV[VZ])
-            &&(a.mV[VW] == b.mV[VW]));
+    return (  (a.mV[VRED] == b.mV[VRED])
+            &&(a.mV[VGREEN] == b.mV[VGREEN])
+            &&(a.mV[VBLUE] == b.mV[VBLUE])
+            &&(a.mV[VALPHA] == b.mV[VALPHA]));
 }
 
 inline bool operator!=(const LLColor4U &a, const LLColor4U &b)
 {
-    return (  (a.mV[VX] != b.mV[VX])
-            ||(a.mV[VY] != b.mV[VY])
-            ||(a.mV[VZ] != b.mV[VZ])
-            ||(a.mV[VW] != b.mV[VW]));
+    return (  (a.mV[VRED] != b.mV[VRED])
+            ||(a.mV[VGREEN] != b.mV[VGREEN])
+            ||(a.mV[VBLUE] != b.mV[VBLUE])
+            ||(a.mV[VALPHA] != b.mV[VALPHA]));
 }
 
 inline const LLColor4U& operator+=(LLColor4U &a, const LLColor4U &b)
 {
-    a.mV[VX] += b.mV[VX];
-    a.mV[VY] += b.mV[VY];
-    a.mV[VZ] += b.mV[VZ];
-    a.mV[VW] += b.mV[VW];
+    a.mV[VRED] += b.mV[VRED];
+    a.mV[VGREEN] += b.mV[VGREEN];
+    a.mV[VBLUE] += b.mV[VBLUE];
+    a.mV[VALPHA] += b.mV[VALPHA];
     return a;
 }
 
 inline const LLColor4U& operator-=(LLColor4U &a, const LLColor4U &b)
 {
-    a.mV[VX] -= b.mV[VX];
-    a.mV[VY] -= b.mV[VY];
-    a.mV[VZ] -= b.mV[VZ];
-    a.mV[VW] -= b.mV[VW];
+    a.mV[VRED] -= b.mV[VRED];
+    a.mV[VGREEN] -= b.mV[VGREEN];
+    a.mV[VBLUE] -= b.mV[VBLUE];
+    a.mV[VALPHA] -= b.mV[VALPHA];
     return a;
 }
 
 inline const LLColor4U& operator*=(LLColor4U &a, U8 k)
 {
     // only affects rgb (not a!)
-    a.mV[VX] *= k;
-    a.mV[VY] *= k;
-    a.mV[VZ] *= k;
+    a.mV[VRED] *= k;
+    a.mV[VGREEN] *= k;
+    a.mV[VBLUE] *= k;
     return a;
 }
 
 inline const LLColor4U& operator%=(LLColor4U &a, U8 k)
 {
     // only affects alpha (not rgb!)
-    a.mV[VW] *= k;
+    a.mV[VALPHA] *= k;
     return a;
 }