miscellaneous: BOOL (int) to real bool

18 files changed, 281 insertions, 281 deletions

diff --git a/indra/llappearance/llavatarappearance.cpp b/indra/llappearance/llavatarappearance.cpp
index 18b03c1f89..1dbca29a86 100644
--- a/indra/llappearance/llavatarappearance.cpp
+++ b/indra/llappearance/llavatarappearance.cpp
@@ -84,13 +84,13 @@ public:
 		std::for_each(mChildren.begin(), mChildren.end(), DeletePointer());
 		mChildren.clear();
 	}
-	BOOL parseXml(LLXmlTreeNode* node);
+	bool parseXml(LLXmlTreeNode* node);
 	
 private:
 	std::string mName;
     std::string mSupport;
     std::string mAliases;
-	BOOL mIsJoint;
+	bool mIsJoint;
 	LLVector3 mPos;
     LLVector3 mEnd;
 	LLVector3 mRot;
@@ -115,7 +115,7 @@ public:
 		std::for_each(mBoneInfoList.begin(), mBoneInfoList.end(), DeletePointer());
 		mBoneInfoList.clear();
 	}
-	BOOL parseXml(LLXmlTreeNode* node);
+	bool parseXml(LLXmlTreeNode* node);
 	S32 getNumBones() const { return mNumBones; }
 	S32 getNumCollisionVolumes() const { return mNumCollisionVolumes; }
 	
@@ -345,7 +345,7 @@ void LLAvatarAppearance::initClass(const std::string& avatar_file_name_arg, cons
         avatar_file_name = gDirUtilp->getExpandedFilename(LL_PATH_CHARACTER,AVATAR_DEFAULT_CHAR + "_lad.xml");
     }
 	LLXmlTree xml_tree;
-	BOOL success = xml_tree.parseFile( avatar_file_name, FALSE );
+	bool success = xml_tree.parseFile( avatar_file_name, FALSE );
 	if (!success)
 	{
 		LL_ERRS() << "Problem reading avatar configuration file:" << avatar_file_name << LL_ENDL;
@@ -575,17 +575,17 @@ void LLAvatarAppearance::computeBodySize()
 //-----------------------------------------------------------------------------
 // parseSkeletonFile()
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::parseSkeletonFile(const std::string& filename, LLXmlTree& skeleton_xml_tree)
+bool LLAvatarAppearance::parseSkeletonFile(const std::string& filename, LLXmlTree& skeleton_xml_tree)
 {
 	//-------------------------------------------------------------------------
 	// parse the file
 	//-------------------------------------------------------------------------
-	BOOL parsesuccess = skeleton_xml_tree.parseFile( filename, FALSE );
+	bool parsesuccess = skeleton_xml_tree.parseFile( filename, FALSE );
 
 	if (!parsesuccess)
 	{
 		LL_ERRS() << "Can't parse skeleton file: " << filename << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	// now sanity check xml file
@@ -593,13 +593,13 @@ BOOL LLAvatarAppearance::parseSkeletonFile(const std::string& filename, LLXmlTre
 	if (!root) 
 	{
 		LL_ERRS() << "No root node found in avatar skeleton file: " << filename << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	if( !root->hasName( "linden_skeleton" ) )
 	{
 		LL_ERRS() << "Invalid avatar skeleton file header: " << filename << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	std::string version;
@@ -607,16 +607,16 @@ BOOL LLAvatarAppearance::parseSkeletonFile(const std::string& filename, LLXmlTre
 	if( !root->getFastAttributeString( version_string, version ) || ((version != "1.0") && (version != "2.0")))
 	{
 		LL_ERRS() << "Invalid avatar skeleton file version: " << version << " in file: " << filename << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
 // setupBone()
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::setupBone(const LLAvatarBoneInfo* info, LLJoint* parent, S32 &volume_num, S32 &joint_num)
+bool LLAvatarAppearance::setupBone(const LLAvatarBoneInfo* info, LLJoint* parent, S32 &volume_num, S32 &joint_num)
 {
 	LLJoint* joint = NULL;
 
@@ -632,7 +632,7 @@ BOOL LLAvatarAppearance::setupBone(const LLAvatarBoneInfo* info, LLJoint* parent
 		if (!joint)
 		{
 			LL_WARNS() << "Too many bones" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 		joint->setName( info->mName );
 	}
@@ -641,7 +641,7 @@ BOOL LLAvatarAppearance::setupBone(const LLAvatarBoneInfo* info, LLJoint* parent
 		if (volume_num >= (S32)mNumCollisionVolumes)
 		{
 			LL_WARNS() << "Too many collision volumes" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 		joint = (&mCollisionVolumes[volume_num]);
 		joint->setName( info->mName );
@@ -681,17 +681,17 @@ BOOL LLAvatarAppearance::setupBone(const LLAvatarBoneInfo* info, LLJoint* parent
 	{
 		if (!setupBone(child_info, joint, volume_num, joint_num))
 		{
-			return FALSE;
+			return false;
 		}
 	}
 
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
 // allocateCharacterJoints()
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::allocateCharacterJoints( U32 num )
+bool LLAvatarAppearance::allocateCharacterJoints( U32 num )
 {
     if (mSkeleton.size() != num)
     {
@@ -700,14 +700,14 @@ BOOL LLAvatarAppearance::allocateCharacterJoints( U32 num )
         mNumBones = num;
     }
 
-	return TRUE;
+	return true;
 }
 
 
 //-----------------------------------------------------------------------------
 // buildSkeleton()
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::buildSkeleton(const LLAvatarSkeletonInfo *info)
+bool LLAvatarAppearance::buildSkeleton(const LLAvatarSkeletonInfo *info)
 {
     LL_DEBUGS("BVH") << "numBones " << info->mNumBones << " numCollisionVolumes " << info->mNumCollisionVolumes << LL_ENDL;
 
@@ -715,7 +715,7 @@ BOOL LLAvatarAppearance::buildSkeleton(const LLAvatarSkeletonInfo *info)
 	if (!allocateCharacterJoints(info->mNumBones))
 	{
 		LL_ERRS() << "Can't allocate " << info->mNumBones << " joints" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 	
 	// allocate volumes
@@ -724,7 +724,7 @@ BOOL LLAvatarAppearance::buildSkeleton(const LLAvatarSkeletonInfo *info)
 		if (!allocateCollisionVolumes(info->mNumCollisionVolumes))
 		{
 			LL_ERRS() << "Can't allocate " << info->mNumCollisionVolumes << " collision volumes" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 	}
 
@@ -735,11 +735,11 @@ BOOL LLAvatarAppearance::buildSkeleton(const LLAvatarSkeletonInfo *info)
 		if (!setupBone(bone_info, NULL, current_volume_num, current_joint_num))
 		{
 			LL_ERRS() << "Error parsing bone in skeleton file" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 	}
 
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
@@ -822,7 +822,7 @@ void LLAvatarAppearance::buildCharacter()
 	//-------------------------------------------------------------------------
 	LLTimer timer;
 
-	BOOL status = loadAvatar();
+	bool status = loadAvatar();
 	stop_glerror();
 
 // 	gPrintMessagesThisFrame = TRUE;
@@ -900,7 +900,7 @@ void LLAvatarAppearance::buildCharacter()
 
 }
 
-BOOL LLAvatarAppearance::loadAvatar()
+bool LLAvatarAppearance::loadAvatar()
 {
 // 	LL_RECORD_BLOCK_TIME(FTM_LOAD_AVATAR);
 	
@@ -908,7 +908,7 @@ BOOL LLAvatarAppearance::loadAvatar()
 	if( !buildSkeleton(sAvatarSkeletonInfo) )
 	{
 		LL_ERRS() << "avatar file: buildSkeleton() failed" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	// initialize mJointAliasMap
@@ -918,14 +918,14 @@ BOOL LLAvatarAppearance::loadAvatar()
 	if( !loadSkeletonNode() )
 	{
 		LL_ERRS() << "avatar file: loadNodeSkeleton() failed" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 	
 	// avatar_lad.xml : <mesh>
 	if( !loadMeshNodes() )
 	{
 		LL_ERRS() << "avatar file: loadNodeMesh() failed" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 	
 	// avatar_lad.xml : <global_color>
@@ -935,13 +935,13 @@ BOOL LLAvatarAppearance::loadAvatar()
 		if( !mTexSkinColor->setInfo( sAvatarXmlInfo->mTexSkinColorInfo ) )
 		{
 			LL_ERRS() << "avatar file: mTexSkinColor->setInfo() failed" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 	}
 	else
 	{
 		LL_ERRS() << "<global_color> name=\"skin_color\" not found" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 	if( sAvatarXmlInfo->mTexHairColorInfo )
 	{
@@ -949,13 +949,13 @@ BOOL LLAvatarAppearance::loadAvatar()
 		if( !mTexHairColor->setInfo( sAvatarXmlInfo->mTexHairColorInfo ) )
 		{
 			LL_ERRS() << "avatar file: mTexHairColor->setInfo() failed" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 	}
 	else
 	{
 		LL_ERRS() << "<global_color> name=\"hair_color\" not found" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 	if( sAvatarXmlInfo->mTexEyeColorInfo )
 	{
@@ -963,26 +963,26 @@ BOOL LLAvatarAppearance::loadAvatar()
 		if( !mTexEyeColor->setInfo( sAvatarXmlInfo->mTexEyeColorInfo ) )
 		{
 			LL_ERRS() << "avatar file: mTexEyeColor->setInfo() failed" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 	}
 	else
 	{
 		LL_ERRS() << "<global_color> name=\"eye_color\" not found" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 	
 	// avatar_lad.xml : <layer_set>
 	if (sAvatarXmlInfo->mLayerInfoList.empty())
 	{
 		LL_ERRS() << "avatar file: missing <layer_set> node" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	if (sAvatarXmlInfo->mMorphMaskInfoList.empty())
 	{
 		LL_ERRS() << "avatar file: missing <morph_masks> node" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	// avatar_lad.xml : <morph_masks>
@@ -996,7 +996,7 @@ BOOL LLAvatarAppearance::loadAvatar()
 			morph_param = getVisualParam(name->c_str());
 			if (morph_param)
 			{
-				BOOL invert = info->mInvert;
+				bool invert = info->mInvert;
 				addMaskedMorph(baked, morph_param, invert, info->mLayer);
 			}
 		}
@@ -1024,17 +1024,17 @@ BOOL LLAvatarAppearance::loadAvatar()
 		{
 			delete driver_param;
 			LL_WARNS() << "avatar file: driver_param->parseData() failed" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 	}
 	
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
 // loadSkeletonNode(): loads <skeleton> node from XML tree
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::loadSkeletonNode ()
+bool LLAvatarAppearance::loadSkeletonNode ()
 {
 	mRoot->addChild( mSkeleton[0] );
 
@@ -1078,7 +1078,7 @@ BOOL LLAvatarAppearance::loadSkeletonNode ()
 			if (!param->setInfo(info))
 			{
 				delete param;
-				return FALSE;
+				return false;
 			}
 			else
 			{
@@ -1089,13 +1089,13 @@ BOOL LLAvatarAppearance::loadSkeletonNode ()
 	}
 
 
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
 // loadMeshNodes(): loads <mesh> nodes from XML tree
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::loadMeshNodes()
+bool LLAvatarAppearance::loadMeshNodes()
 {
 	for (const LLAvatarXmlInfo::LLAvatarMeshInfo* info : sAvatarXmlInfo->mMeshInfoList)
 	{
@@ -1104,7 +1104,7 @@ BOOL LLAvatarAppearance::loadMeshNodes()
 
 		LLAvatarJointMesh* mesh = NULL;
 		U8 mesh_id = 0;
-		BOOL found_mesh_id = FALSE;
+		bool found_mesh_id = FALSE;
 
 		/* if (type == "hairMesh")
 			switch(lod)
@@ -1131,13 +1131,13 @@ BOOL LLAvatarAppearance::loadMeshNodes()
 			else
 			{
 				LL_WARNS() << "Avatar file: <mesh> has invalid lod setting " << lod << LL_ENDL;
-				return FALSE;
+				return false;
 			}
 		}
 		else 
 		{
 			LL_WARNS() << "Ignoring unrecognized mesh type: " << type << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 
 		//	LL_INFOS() << "Parsing mesh data for " << type << "..." << LL_ENDL;
@@ -1160,7 +1160,7 @@ BOOL LLAvatarAppearance::loadMeshNodes()
 			{
 				// This should never happen
 				LL_WARNS("Avatar") << "Could not find avatar mesh: " << info->mReferenceMeshName << LL_ENDL;
-                return FALSE;
+                return false;
 			}
 		}
 		else
@@ -1172,7 +1172,7 @@ BOOL LLAvatarAppearance::loadMeshNodes()
 		if( !poly_mesh )
 		{
 			LL_WARNS() << "Failed to load mesh of type " << type << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 
 		// Multimap insert
@@ -1187,7 +1187,7 @@ BOOL LLAvatarAppearance::loadMeshNodes()
 			if (!param->setInfo((LLPolyMorphTargetInfo*)info_pair.first))
 			{
 				delete param;
-				return FALSE;
+				return false;
 			}
 			else
 			{
@@ -1205,15 +1205,15 @@ BOOL LLAvatarAppearance::loadMeshNodes()
 		}
 	}
 
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
 // loadLayerSets()
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::loadLayersets()
+bool LLAvatarAppearance::loadLayersets()
 {
-	BOOL success = TRUE;
+	bool success = true;
 	for (LLTexLayerSetInfo* layerset_info : sAvatarXmlInfo->mLayerInfoList)
 	{
 		if (isSelf())
@@ -1226,7 +1226,7 @@ BOOL LLAvatarAppearance::loadLayersets()
 				stop_glerror();
 				delete layer_set;
 				LL_WARNS() << "avatar file: layer_set->setInfo() failed" << LL_ENDL;
-				return FALSE;
+				return false;
 			}
 
 			// scan baked textures and associate the layerset with the appropriate one
@@ -1248,7 +1248,7 @@ BOOL LLAvatarAppearance::loadLayersets()
 			{
 				LL_WARNS() << "<layer_set> has invalid body_region attribute" << LL_ENDL;
 				delete layer_set;
-				return FALSE;
+				return false;
 			}
 
 			// scan morph masks and let any affected layers know they have an associated morph
@@ -1355,19 +1355,19 @@ LLPolyMesh*	LLAvatarAppearance::getUpperBodyMesh()
 
 
 // virtual
-BOOL LLAvatarAppearance::isValid() const
+bool LLAvatarAppearance::isValid() const
 {
 	// This should only be called on ourself.
 	if (!isSelf())
 	{
 		LL_ERRS() << "Called LLAvatarAppearance::isValid() on when isSelf() == false" << LL_ENDL;
 	}
-	return TRUE;
+	return true;
 }
 
 
 // adds a morph mask to the appropriate baked texture structure
-void LLAvatarAppearance::addMaskedMorph(EBakedTextureIndex index, LLVisualParam* morph_target, BOOL invert, std::string layer)
+void LLAvatarAppearance::addMaskedMorph(EBakedTextureIndex index, LLVisualParam* morph_target, bool invert, std::string layer)
 {
 	if (index < BAKED_NUM_INDICES)
 	{
@@ -1378,7 +1378,7 @@ void LLAvatarAppearance::addMaskedMorph(EBakedTextureIndex index, LLVisualParam*
 
 
 //static
-BOOL LLAvatarAppearance::teToColorParams( ETextureIndex te, U32 *param_name )
+bool LLAvatarAppearance::teToColorParams( ETextureIndex te, U32 *param_name )
 {
 	switch( te )
 	{
@@ -1462,10 +1462,10 @@ BOOL LLAvatarAppearance::teToColorParams( ETextureIndex te, U32 *param_name )
 
 		default:
 			llassert(0);
-			return FALSE;
+			return false;
 	}
 
-	return TRUE;
+	return true;
 }
 
 void LLAvatarAppearance::setClothesColor( ETextureIndex te, const LLColor4& new_color)
@@ -1521,7 +1521,7 @@ LLColor4 LLAvatarAppearance::getGlobalColor( const std::string& color_name ) con
 
 // Unlike most wearable functions, this works for both self and other.
 // virtual
-BOOL LLAvatarAppearance::isWearingWearableType(LLWearableType::EType type) const
+bool LLAvatarAppearance::isWearingWearableType(LLWearableType::EType type) const
 {
 	return mWearableData->getWearableCount(type) > 0;
 }
@@ -1538,7 +1538,7 @@ LLTexLayerSet* LLAvatarAppearance::getAvatarLayerSet(EBakedTextureIndex baked_in
 //-----------------------------------------------------------------------------
 // allocateCollisionVolumes()
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::allocateCollisionVolumes( U32 num )
+bool LLAvatarAppearance::allocateCollisionVolumes( U32 num )
 {
     if (mNumCollisionVolumes !=num)
     {
@@ -1549,18 +1549,18 @@ BOOL LLAvatarAppearance::allocateCollisionVolumes( U32 num )
         if (!mCollisionVolumes)
         {
             LL_WARNS() << "Failed to allocate collision volumes" << LL_ENDL;
-            return FALSE;
+            return false;
         }
         
         mNumCollisionVolumes = num;
     }
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
 // LLAvatarBoneInfo::parseXml()
 //-----------------------------------------------------------------------------
-BOOL LLAvatarBoneInfo::parseXml(LLXmlTreeNode* node)
+bool LLAvatarBoneInfo::parseXml(LLXmlTreeNode* node)
 {
 	if (node->hasName("bone"))
 	{
@@ -1569,7 +1569,7 @@ BOOL LLAvatarBoneInfo::parseXml(LLXmlTreeNode* node)
 		if (!node->getFastAttributeString(name_string, mName))
 		{
 			LL_WARNS() << "Bone without name" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
         
         static LLStdStringHandle aliases_string = LLXmlTree::addAttributeString("aliases");
@@ -1587,28 +1587,28 @@ BOOL LLAvatarBoneInfo::parseXml(LLXmlTreeNode* node)
 	else
 	{
 		LL_WARNS() << "Invalid node " << node->getName() << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	static LLStdStringHandle pos_string = LLXmlTree::addAttributeString("pos");
 	if (!node->getFastAttributeVector3(pos_string, mPos))
 	{
 		LL_WARNS() << "Bone without position" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	static LLStdStringHandle rot_string = LLXmlTree::addAttributeString("rot");
 	if (!node->getFastAttributeVector3(rot_string, mRot))
 	{
 		LL_WARNS() << "Bone without rotation" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 	
 	static LLStdStringHandle scale_string = LLXmlTree::addAttributeString("scale");
 	if (!node->getFastAttributeVector3(scale_string, mScale))
 	{
 		LL_WARNS() << "Bone without scale" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	static LLStdStringHandle end_string = LLXmlTree::addAttributeString("end");
@@ -1631,7 +1631,7 @@ BOOL LLAvatarBoneInfo::parseXml(LLXmlTreeNode* node)
 		if (!node->getFastAttributeVector3(pivot_string, mPivot))
 		{
 			LL_WARNS() << "Bone without pivot" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 	}
 
@@ -1643,23 +1643,23 @@ BOOL LLAvatarBoneInfo::parseXml(LLXmlTreeNode* node)
 		if (!child_info->parseXml(child))
 		{
 			delete child_info;
-			return FALSE;
+			return false;
 		}
 		mChildren.push_back(child_info);
 	}
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
 // LLAvatarSkeletonInfo::parseXml()
 //-----------------------------------------------------------------------------
-BOOL LLAvatarSkeletonInfo::parseXml(LLXmlTreeNode* node)
+bool LLAvatarSkeletonInfo::parseXml(LLXmlTreeNode* node)
 {
 	static LLStdStringHandle num_bones_string = LLXmlTree::addAttributeString("num_bones");
 	if (!node->getFastAttributeS32(num_bones_string, mNumBones))
 	{
 		LL_WARNS() << "Couldn't find number of bones." << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	static LLStdStringHandle num_collision_volumes_string = LLXmlTree::addAttributeString("num_collision_volumes");
@@ -1673,11 +1673,11 @@ BOOL LLAvatarSkeletonInfo::parseXml(LLXmlTreeNode* node)
 		{
 			delete info;
 			LL_WARNS() << "Error parsing bone in skeleton file" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 		mBoneInfoList.push_back(info);
 	}
-	return TRUE;
+	return true;
 }
 
 //Make aliases for joint and push to map.
@@ -1745,13 +1745,13 @@ const LLAvatarAppearance::joint_alias_map_t& LLAvatarAppearance::getJointAliases
 //-----------------------------------------------------------------------------
 // parseXmlSkeletonNode(): parses <skeleton> nodes from XML tree
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlSkeletonNode(LLXmlTreeNode* root)
+bool LLAvatarAppearance::LLAvatarXmlInfo::parseXmlSkeletonNode(LLXmlTreeNode* root)
 {
 	LLXmlTreeNode* node = root->getChildByName( "skeleton" );
 	if( !node )
 	{
 		LL_WARNS() << "avatar file: missing <skeleton>" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	LLXmlTreeNode* child;
@@ -1771,14 +1771,14 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlSkeletonNode(LLXmlTreeNode* ro
 			{
 				LL_WARNS() << "Unknown param type." << LL_ENDL;
 			}
-            return FALSE;
+            return false;
 		}
 		
 		LLPolySkeletalDistortionInfo *info = new LLPolySkeletalDistortionInfo;
 		if (!info->parseXml(child))
 		{
 			delete info;
-			return FALSE;
+			return false;
 		}
 
 		mSkeletalDistortionInfoList.push_back(info);
@@ -1796,7 +1796,7 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlSkeletonNode(LLXmlTreeNode* ro
 		{
 			LL_WARNS() << "No name supplied for attachment point." << LL_ENDL;
 			delete info;
-            return FALSE;
+            return false;
 		}
 
 		static LLStdStringHandle joint_string = LLXmlTree::addAttributeString("joint");
@@ -1804,7 +1804,7 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlSkeletonNode(LLXmlTreeNode* ro
 		{
 			LL_WARNS() << "No bone declared in attachment point " << info->mName << LL_ENDL;
 			delete info;
-            return FALSE;
+            return false;
 		}
 
 		static LLStdStringHandle position_string = LLXmlTree::addAttributeString("position");
@@ -1830,7 +1830,7 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlSkeletonNode(LLXmlTreeNode* ro
 		{
 			LL_WARNS() << "No id supplied for attachment point " << info->mName << LL_ENDL;
 			delete info;
-            return FALSE;
+            return false;
 		}
 
 		static LLStdStringHandle slot_string = LLXmlTree::addAttributeString("pie_slice");
@@ -1845,13 +1845,13 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlSkeletonNode(LLXmlTreeNode* ro
 		mAttachmentInfoList.push_back(info);
 	}
 
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
 // parseXmlMeshNodes(): parses <mesh> nodes from XML tree
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMeshNodes(LLXmlTreeNode* root)
+bool LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMeshNodes(LLXmlTreeNode* root)
 {
 	for (LLXmlTreeNode* node = root->getChildByName( "mesh" );
 		 node;
@@ -1865,7 +1865,7 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMeshNodes(LLXmlTreeNode* root)
 		{
 			LL_WARNS() << "Avatar file: <mesh> is missing type attribute.  Ignoring element. " << LL_ENDL;
 			delete info;
-			return FALSE;  // Ignore this element
+			return false;  // Ignore this element
 		}
 		
 		static LLStdStringHandle lod_string = LLXmlTree::addAttributeString("lod");
@@ -1873,7 +1873,7 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMeshNodes(LLXmlTreeNode* root)
 		{
 			LL_WARNS() << "Avatar file: <mesh> is missing lod attribute.  Ignoring element. " << LL_ENDL;
 			delete info;
-			return FALSE;  // Ignore this element
+			return false;  // Ignore this element
 		}
 
 		static LLStdStringHandle file_name_string = LLXmlTree::addAttributeString("file_name");
@@ -1881,7 +1881,7 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMeshNodes(LLXmlTreeNode* root)
 		{
 			LL_WARNS() << "Avatar file: <mesh> is missing file_name attribute.  Ignoring: " << info->mType << LL_ENDL;
 			delete info;
-			return FALSE;  // Ignore this element
+			return false;  // Ignore this element
 		}
 
 		static LLStdStringHandle reference_string = LLXmlTree::addAttributeString("reference");
@@ -1916,7 +1916,7 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMeshNodes(LLXmlTreeNode* root)
 				{
 					LL_WARNS() << "Unknown param type." << LL_ENDL;
 				}
-                return FALSE;
+                return false;
 			}
 
 			LLPolyMorphTargetInfo *morphinfo = new LLPolyMorphTargetInfo();
@@ -1926,7 +1926,7 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMeshNodes(LLXmlTreeNode* root)
 				delete info;
 				return -1;
 			}
-			BOOL shared = FALSE;
+			BOOL shared = false;
 			static LLStdStringHandle shared_string = LLXmlTree::addAttributeString("shared");
 			child->getFastAttributeBOOL(shared_string, shared);
 
@@ -1935,13 +1935,13 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMeshNodes(LLXmlTreeNode* root)
 
 		mMeshInfoList.push_back(info);
 	}
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
 // parseXmlColorNodes(): parses <global_color> nodes from XML tree
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlColorNodes(LLXmlTreeNode* root)
+bool LLAvatarAppearance::LLAvatarXmlInfo::parseXmlColorNodes(LLXmlTreeNode* root)
 {
 	for (LLXmlTreeNode* color_node = root->getChildByName( "global_color" );
 		 color_node;
@@ -1956,14 +1956,14 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlColorNodes(LLXmlTreeNode* root
 				if (mTexSkinColorInfo)
 				{
 					LL_WARNS() << "avatar file: multiple instances of skin_color" << LL_ENDL;
-					return FALSE;
+					return false;
 				}
 				mTexSkinColorInfo = new LLTexGlobalColorInfo;
 				if( !mTexSkinColorInfo->parseXml( color_node ) )
 				{
 					delete_and_clear(mTexSkinColorInfo);
 					LL_WARNS() << "avatar file: mTexSkinColor->parseXml() failed" << LL_ENDL;
-					return FALSE;
+					return false;
 				}
 			}
 			else if( global_color_name == "hair_color" )
@@ -1971,14 +1971,14 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlColorNodes(LLXmlTreeNode* root
 				if (mTexHairColorInfo)
 				{
 					LL_WARNS() << "avatar file: multiple instances of hair_color" << LL_ENDL;
-					return FALSE;
+					return false;
 				}
 				mTexHairColorInfo = new LLTexGlobalColorInfo;
 				if( !mTexHairColorInfo->parseXml( color_node ) )
 				{
 					delete_and_clear(mTexHairColorInfo);
 					LL_WARNS() << "avatar file: mTexHairColor->parseXml() failed" << LL_ENDL;
-					return FALSE;
+					return false;
 				}
 			}
 			else if( global_color_name == "eye_color" )
@@ -1986,24 +1986,24 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlColorNodes(LLXmlTreeNode* root
 				if (mTexEyeColorInfo)
 				{
 					LL_WARNS() << "avatar file: multiple instances of eye_color" << LL_ENDL;
-					return FALSE;
+					return false;
 				}
 				mTexEyeColorInfo = new LLTexGlobalColorInfo;
 				if( !mTexEyeColorInfo->parseXml( color_node ) )
 				{
 					LL_WARNS() << "avatar file: mTexEyeColor->parseXml() failed" << LL_ENDL;
-					return FALSE;
+					return false;
 				}
 			}
 		}
 	}
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
 // parseXmlLayerNodes(): parses <layer_set> nodes from XML tree
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlLayerNodes(LLXmlTreeNode* root)
+bool LLAvatarAppearance::LLAvatarXmlInfo::parseXmlLayerNodes(LLXmlTreeNode* root)
 {
 	for (LLXmlTreeNode* layer_node = root->getChildByName( "layer_set" );
 		 layer_node;
@@ -2018,16 +2018,16 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlLayerNodes(LLXmlTreeNode* root
 		{
 			delete layer_info;
 			LL_WARNS() << "avatar file: layer_set->parseXml() failed" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 	}
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
 // parseXmlDriverNodes(): parses <driver_parameters> nodes from XML tree
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlDriverNodes(LLXmlTreeNode* root)
+bool LLAvatarAppearance::LLAvatarXmlInfo::parseXmlDriverNodes(LLXmlTreeNode* root)
 {
 	LLXmlTreeNode* driver = root->getChildByName( "driver_parameters" );
 	if( driver )
@@ -2047,23 +2047,23 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlDriverNodes(LLXmlTreeNode* roo
 				{
 					delete driver_info;
 					LL_WARNS() << "avatar file: driver_param->parseXml() failed" << LL_ENDL;
-					return FALSE;
+					return false;
 				}
 			}
 		}
 	}
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
 // parseXmlDriverNodes(): parses <driver_parameters> nodes from XML tree
 //-----------------------------------------------------------------------------
-BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMorphNodes(LLXmlTreeNode* root)
+bool LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMorphNodes(LLXmlTreeNode* root)
 {
 	LLXmlTreeNode* masks = root->getChildByName( "morph_masks" );
 	if( !masks )
 	{
-		return FALSE;
+		return false;
 	}
 
 	for (LLXmlTreeNode* grand_child = masks->getChildByName( "mask" );
@@ -2077,7 +2077,7 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMorphNodes(LLXmlTreeNode* root
 		{
 			LL_WARNS() << "No name supplied for morph mask." << LL_ENDL;
 			delete info;
-            return FALSE;
+            return false;
 		}
 
 		static LLStdStringHandle region_string = LLXmlTree::addAttributeString("body_region");
@@ -2085,7 +2085,7 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMorphNodes(LLXmlTreeNode* root
 		{
 			LL_WARNS() << "No region supplied for morph mask." << LL_ENDL;
 			delete info;
-            return FALSE;
+            return false;
 		}
 
 		static LLStdStringHandle layer_string = LLXmlTree::addAttributeString("layer");
@@ -2093,7 +2093,7 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMorphNodes(LLXmlTreeNode* root
 		{
 			LL_WARNS() << "No layer supplied for morph mask." << LL_ENDL;
 			delete info;
-            return FALSE;
+            return false;
 		}
 
 		// optional parameter. don't throw a warning if not present.
@@ -2103,12 +2103,12 @@ BOOL LLAvatarAppearance::LLAvatarXmlInfo::parseXmlMorphNodes(LLXmlTreeNode* root
 		mMorphMaskInfoList.push_back(info);
 	}
 
-	return TRUE;
+	return true;
 }
 
 //virtual 
 LLAvatarAppearance::LLMaskedMorph::LLMaskedMorph(LLVisualParam *morph_target, BOOL invert, std::string layer) :
-			mMorphTarget(morph_target), 
+			mMorphTarget(morph_target),
 			mInvert(invert),
 			mLayer(layer)
 {
diff --git a/indra/llappearance/llavatarappearance.h b/indra/llappearance/llavatarappearance.h
index 787235b235..f3c74c052f 100644
--- a/indra/llappearance/llavatarappearance.h
+++ b/indra/llappearance/llavatarappearance.h
@@ -71,9 +71,9 @@ public:
 	static void			cleanupClass();	// Cleanup data that's only init'd once per class.
 	virtual void 		initInstance(); // Called after construction to initialize the instance.
     S32					mInitFlags;
-	virtual BOOL		loadSkeletonNode();
-	BOOL				loadMeshNodes();
-	BOOL				loadLayersets();
+	virtual bool		loadSkeletonNode();
+	bool				loadMeshNodes();
+	bool				loadLayersets();
 
 
 /**                    Initialization
@@ -108,9 +108,9 @@ public:
  **/
 public:
 	virtual bool 	isSelf() const { return false; } // True if this avatar is for this viewer's agent
-	virtual BOOL	isValid() const;
-	virtual BOOL	isUsingLocalAppearance() const = 0;
-	virtual BOOL	isEditingAppearance() const = 0;
+	virtual bool	isValid() const;
+	virtual bool	isUsingLocalAppearance() const = 0;
+	virtual bool	isEditingAppearance() const = 0;
 
 	bool isBuilt() const { return mIsBuilt; }
 
@@ -156,16 +156,16 @@ public:
 
 
 protected:
-	static BOOL			parseSkeletonFile(const std::string& filename, LLXmlTree& skeleton_xml_tree);
+	static bool			parseSkeletonFile(const std::string& filename, LLXmlTree& skeleton_xml_tree);
 	virtual void		buildCharacter();
-	virtual BOOL		loadAvatar();
+	virtual bool		loadAvatar();
 
-	BOOL				setupBone(const LLAvatarBoneInfo* info, LLJoint* parent, S32 &current_volume_num, S32 &current_joint_num);
-	BOOL				allocateCharacterJoints(U32 num);
-	BOOL				buildSkeleton(const LLAvatarSkeletonInfo *info);
+	bool				setupBone(const LLAvatarBoneInfo* info, LLJoint* parent, S32 &current_volume_num, S32 &current_joint_num);
+	bool				allocateCharacterJoints(U32 num);
+	bool				buildSkeleton(const LLAvatarSkeletonInfo *info);
 
 	void				clearSkeleton();
-	BOOL				mIsBuilt; // state of deferred character building
+	bool				mIsBuilt; // state of deferred character building
 	avatar_joint_list_t	mSkeleton;
 	LLVector3OverrideMap	mPelvisFixups;
     joint_alias_map_t   mJointAliasMap;
@@ -225,13 +225,13 @@ protected:
  **                    RENDERING
  **/
 public:
-	BOOL		mIsDummy; // for special views and animated object controllers; local to viewer
+	bool		mIsDummy; // for special views and animated object controllers; local to viewer
 
 	//--------------------------------------------------------------------
 	// Morph masks
 	//--------------------------------------------------------------------
 public:
-	void 	addMaskedMorph(LLAvatarAppearanceDefines::EBakedTextureIndex index, LLVisualParam* morph_target, BOOL invert, std::string layer);
+	void 	addMaskedMorph(LLAvatarAppearanceDefines::EBakedTextureIndex index, LLVisualParam* morph_target, bool invert, std::string layer);
 	virtual void	applyMorphMask(const U8* tex_data, S32 width, S32 height, S32 num_components, LLAvatarAppearanceDefines::EBakedTextureIndex index = LLAvatarAppearanceDefines::BAKED_NUM_INDICES) = 0;
 
 /**                    Rendering
@@ -279,7 +279,7 @@ protected:
 public:
 	void			setClothesColor(LLAvatarAppearanceDefines::ETextureIndex te, const LLColor4& new_color);
 	LLColor4		getClothesColor(LLAvatarAppearanceDefines::ETextureIndex te);
-	static BOOL		teToColorParams(LLAvatarAppearanceDefines::ETextureIndex te, U32 *param_name);
+	static bool		teToColorParams(LLAvatarAppearanceDefines::ETextureIndex te, U32 *param_name);
 
 	//--------------------------------------------------------------------
 	// Global colors
@@ -309,8 +309,8 @@ public:
 public:
 	LLWearableData*			getWearableData() { return mWearableData; }
 	const LLWearableData*	getWearableData() const { return mWearableData; }
-	virtual BOOL isTextureDefined(LLAvatarAppearanceDefines::ETextureIndex te, U32 index = 0 ) const = 0;
-	virtual BOOL			isWearingWearableType(LLWearableType::EType type ) const;
+	virtual bool isTextureDefined(LLAvatarAppearanceDefines::ETextureIndex te, U32 index = 0 ) const = 0;
+	virtual bool			isWearingWearableType(LLWearableType::EType type ) const;
 
 private:
 	LLWearableData* mWearableData;
@@ -356,7 +356,7 @@ public:
   	S32			mNumCollisionVolumes;
 	LLAvatarJointCollisionVolume* mCollisionVolumes;
 protected:
-	BOOL		allocateCollisionVolumes(U32 num);
+	bool		allocateCollisionVolumes(U32 num);
 
 /**                    Physics
  **                                                                            **
@@ -372,12 +372,12 @@ protected:
 		LLAvatarXmlInfo();
 		~LLAvatarXmlInfo();
 
-		BOOL 	parseXmlSkeletonNode(LLXmlTreeNode* root);
-		BOOL 	parseXmlMeshNodes(LLXmlTreeNode* root);
-		BOOL 	parseXmlColorNodes(LLXmlTreeNode* root);
-		BOOL 	parseXmlLayerNodes(LLXmlTreeNode* root);
-		BOOL 	parseXmlDriverNodes(LLXmlTreeNode* root);
-		BOOL	parseXmlMorphNodes(LLXmlTreeNode* root);
+		bool 	parseXmlSkeletonNode(LLXmlTreeNode* root);
+		bool 	parseXmlMeshNodes(LLXmlTreeNode* root);
+		bool 	parseXmlColorNodes(LLXmlTreeNode* root);
+		bool 	parseXmlLayerNodes(LLXmlTreeNode* root);
+		bool 	parseXmlDriverNodes(LLXmlTreeNode* root);
+		bool	parseXmlMorphNodes(LLXmlTreeNode* root);
 
 		struct LLAvatarMeshInfo
 		{
@@ -421,8 +421,8 @@ protected:
 			S32 mPieMenuSlice;
 			BOOL mVisibleFirstPerson;
 			BOOL mIsHUDAttachment;
-			BOOL mHasPosition;
-			BOOL mHasRotation;
+			bool mHasPosition;
+			bool mHasRotation;
 		};
 		typedef std::vector<LLAvatarAttachmentInfo*> attachment_info_list_t;
 		attachment_info_list_t mAttachmentInfoList;
@@ -458,7 +458,7 @@ protected:
 		LLMaskedMorph(LLVisualParam *morph_target, BOOL invert, std::string layer);
 
 		LLVisualParam	*mMorphTarget;
-		BOOL				mInvert;
+		bool				mInvert;
 		std::string			mLayer;
 	};
 /**                    Support Classes
diff --git a/indra/llappearance/llavatarappearancedefines.cpp b/indra/llappearance/llavatarappearancedefines.cpp
index 8759c387e8..f3f26be4b9 100644
--- a/indra/llappearance/llavatarappearancedefines.cpp
+++ b/indra/llappearance/llavatarappearancedefines.cpp
@@ -303,15 +303,15 @@ LLWearableType::EType LLAvatarAppearanceDictionary::getTEWearableType(ETextureIn
 }
 
 // static
-BOOL LLAvatarAppearanceDictionary::isBakedImageId(const LLUUID& id)
+bool LLAvatarAppearanceDictionary::isBakedImageId(const LLUUID& id)
 {
 	if ((id == IMG_USE_BAKED_EYES) || (id == IMG_USE_BAKED_HAIR) || (id == IMG_USE_BAKED_HEAD) || (id == IMG_USE_BAKED_LOWER) || (id == IMG_USE_BAKED_SKIRT) || (id == IMG_USE_BAKED_UPPER) 
 		|| (id == IMG_USE_BAKED_LEFTARM) || (id == IMG_USE_BAKED_LEFTLEG) || (id == IMG_USE_BAKED_AUX1) || (id == IMG_USE_BAKED_AUX2) || (id == IMG_USE_BAKED_AUX3) )
 	{
-		return TRUE;
+		return true;
 	}
 
-	return FALSE;
+	return false;
 }
 
 // static 
diff --git a/indra/llappearance/llavatarappearancedefines.h b/indra/llappearance/llavatarappearancedefines.h
index 49dfbebeea..b90c6664cc 100644
--- a/indra/llappearance/llavatarappearancedefines.h
+++ b/indra/llappearance/llavatarappearancedefines.h
@@ -244,7 +244,7 @@ public:
 	// Given a texture entry, determine which wearable type owns it.
 	LLWearableType::EType 		getTEWearableType(ETextureIndex index) const;
 
-	static BOOL							isBakedImageId(const LLUUID& id);
+	static bool							isBakedImageId(const LLUUID& id);
 	static EBakedTextureIndex			assetIdToBakedTextureIndex(const LLUUID& id);
 	static LLUUID						localTextureIndexToMagicId(ETextureIndex t);
 
diff --git a/indra/llappearance/llavatarjoint.h b/indra/llappearance/llavatarjoint.h
index fec91503c7..61b4e2b0a1 100644
--- a/indra/llappearance/llavatarjoint.h
+++ b/indra/llappearance/llavatarjoint.h
@@ -62,7 +62,7 @@ public:
 	virtual BOOL isTransparent() { return mIsTransparent; }
 
 	// Returns true if this object should inherit scale modifiers from its immediate parent
-	virtual BOOL inheritScale() { return FALSE; }
+	virtual BOOL inheritScale() { return false; }
 
 	enum Components
 	{
@@ -127,7 +127,7 @@ public:
 	LLAvatarJointCollisionVolume();
 	virtual ~LLAvatarJointCollisionVolume() {};
 
-	/*virtual*/ BOOL inheritScale() { return TRUE; }
+	/*virtual*/ BOOL inheritScale() { return true; }
 	/*virtual*/ U32 render( F32 pixelArea, BOOL first_pass = TRUE, BOOL is_dummy = FALSE );
 
 	void renderCollision();
diff --git a/indra/llappearance/llavatarjointmesh.cpp b/indra/llappearance/llavatarjointmesh.cpp
index ed39f78d28..7a6da9d33f 100644
--- a/indra/llappearance/llavatarjointmesh.cpp
+++ b/indra/llappearance/llavatarjointmesh.cpp
@@ -119,7 +119,7 @@ BOOL LLSkinJoint::setupSkinJoint( LLAvatarJoint *joint)
 	mRootToParentJointSkinOffset = totalSkinOffset(getBaseSkeletonAncestor(joint));
 	mRootToParentJointSkinOffset = -mRootToParentJointSkinOffset;
 
-	return TRUE;
+	return true;
 }
 
 
@@ -186,7 +186,7 @@ BOOL LLAvatarJointMesh::allocateSkinData( U32 numSkinJoints )
 {
 	mSkinJoints = new LLSkinJoint[ numSkinJoints ];
 	mNumSkinJoints = numSkinJoints;
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
diff --git a/indra/llappearance/lldriverparam.cpp b/indra/llappearance/lldriverparam.cpp
index f46d0324a5..52d060571e 100644
--- a/indra/llappearance/lldriverparam.cpp
+++ b/indra/llappearance/lldriverparam.cpp
@@ -46,11 +46,11 @@ BOOL LLDriverParamInfo::parseXml(LLXmlTreeNode* node)
 	llassert( node->hasName( "param" ) && node->getChildByName( "param_driver" ) );
 
 	if( !LLViewerVisualParamInfo::parseXml( node ))
-		return FALSE;
+		return false;
 
 	LLXmlTreeNode* param_driver_node = node->getChildByName( "param_driver" );
 	if( !param_driver_node )
-		return FALSE;
+		return false;
 
 	for (LLXmlTreeNode* child = param_driver_node->getChildByName( "driven" );
 		 child;
@@ -90,10 +90,10 @@ BOOL LLDriverParamInfo::parseXml(LLXmlTreeNode* node)
 		else
 		{
 			LL_ERRS() << "<driven> Unable to resolve driven parameter: " << driven_id << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 	}
-	return TRUE;
+	return true;
 }
 
 //virtual 
@@ -191,14 +191,14 @@ BOOL LLDriverParam::setInfo(LLDriverParamInfo *info)
 {
 	llassert(mInfo == NULL);
 	if (info->mID < 0)
-		return FALSE;
+		return false;
 	mInfo = info;
 	mID = info->mID;
 	info->mDriverParam = this;
 
 	setWeight(getDefaultWeight());
 
-	return TRUE;
+	return true;
 }
 
 /*virtual*/ LLViewerVisualParam* LLDriverParam::cloneParam(LLWearable* wearable) const
diff --git a/indra/llappearance/lllocaltextureobject.cpp b/indra/llappearance/lllocaltextureobject.cpp
index ab50db3a5a..7c17942c56 100644
--- a/indra/llappearance/lllocaltextureobject.cpp
+++ b/indra/llappearance/lllocaltextureobject.cpp
@@ -136,7 +136,7 @@ BOOL LLLocalTextureObject::setTexLayer(LLTexLayer *new_tex_layer, U32 index)
 {
 	if (index >= getNumTexLayers() )
 	{
-		return FALSE;
+		return false;
 	}
 
 	if (new_tex_layer == NULL)
@@ -153,47 +153,47 @@ BOOL LLLocalTextureObject::setTexLayer(LLTexLayer *new_tex_layer, U32 index)
 	}
 	mTexLayers[index] = layer;
 
-	return TRUE;
+	return true;
 }
 
 BOOL LLLocalTextureObject::addTexLayer(LLTexLayer *new_tex_layer, LLWearable *wearable)
 {
 	if (new_tex_layer == NULL)
 	{
-		return FALSE;
+		return false;
 	}
 
 	LLTexLayer *layer = new LLTexLayer(*new_tex_layer, wearable);
 	layer->setLTO(this);
 	mTexLayers.push_back(layer);
-	return TRUE;
+	return true;
 }
 
 BOOL LLLocalTextureObject::addTexLayer(LLTexLayerTemplate *new_tex_layer, LLWearable *wearable)
 {
 	if (new_tex_layer == NULL)
 	{
-		return FALSE;
+		return false;
 	}
 
 	LLTexLayer *layer = new LLTexLayer(*new_tex_layer, this, wearable);
 	layer->setLTO(this);
 	mTexLayers.push_back(layer);
-	return TRUE;
+	return true;
 }
 
 BOOL LLLocalTextureObject::removeTexLayer(U32 index)
 {
 	if (index >= getNumTexLayers())
 	{
-		return FALSE;
+		return false;
 	}
 	tex_layer_vec_t::iterator iter = mTexLayers.begin();
 	iter += index;
 
 	delete *iter;
 	mTexLayers.erase(iter);
-	return TRUE;
+	return true;
 }
 
 void LLLocalTextureObject::setID(LLUUID new_id)
diff --git a/indra/llappearance/llpolymesh.cpp b/indra/llappearance/llpolymesh.cpp
index dab14851c8..8bfc6572d7 100644
--- a/indra/llappearance/llpolymesh.cpp
+++ b/indra/llappearance/llpolymesh.cpp
@@ -243,7 +243,7 @@ BOOL LLPolyMeshSharedData::allocateVertexData( U32 numVertices )
             mWeights[i] = 0.f;
         }
         mNumVertices = numVertices;
-        return TRUE;
+        return true;
 }
 
 //-----------------------------------------------------------------------------
@@ -254,7 +254,7 @@ BOOL LLPolyMeshSharedData::allocateFaceData( U32 numFaces )
         mFaces = new LLPolyFace[ numFaces ];
         mNumFaces = numFaces;
         mNumTriangleIndices = mNumFaces * 3;
-        return TRUE;
+        return true;
 }
 
 //-----------------------------------------------------------------------------
@@ -264,7 +264,7 @@ BOOL LLPolyMeshSharedData::allocateJointNames( U32 numJointNames )
 {
         mJointNames = new std::string[ numJointNames ];
         mNumJointNames = numJointNames;
-        return TRUE;
+        return true;
 }
 
 //--------------------------------------------------------------------
@@ -278,13 +278,13 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
         if(fileName.empty())
         {
                 LL_ERRS() << "Filename is Empty!" << LL_ENDL;
-                return FALSE;
+                return false;
         }
         LLFILE* fp = LLFile::fopen(fileName, "rb");                     /*Flawfinder: ignore*/
         if (!fp)
         {
                 LL_ERRS() << "can't open: " << fileName << LL_ENDL;
-                return FALSE;
+                return false;
         }
 
         //-------------------------------------------------------------------------
@@ -317,7 +317,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                 if (numRead != 1)
                 {
                         LL_ERRS() << "can't read HasWeights flag from " << fileName << LL_ENDL;
-                        return FALSE;
+                        return false;
                 }
                 if (!isLOD())
                 {
@@ -332,7 +332,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                 if (numRead != 1)
                 {
                         LL_ERRS() << "can't read HasDetailTexCoords flag from " << fileName << LL_ENDL;
-                        return FALSE;
+                        return false;
                 }
 
                 //----------------------------------------------------------------
@@ -344,7 +344,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                 if (numRead != 3)
                 {
                         LL_ERRS() << "can't read Position from " << fileName << LL_ENDL;
-                        return FALSE;
+                        return false;
                 }
                 setPosition( position );
 
@@ -357,7 +357,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                 if (numRead != 3)
                 {
                         LL_ERRS() << "can't read RotationAngles from " << fileName << LL_ENDL;
-                        return FALSE;
+                        return false;
                 }
 
                 U8 rotationOrder;
@@ -366,7 +366,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                 if (numRead != 1)
                 {
                         LL_ERRS() << "can't read RotationOrder from " << fileName << LL_ENDL;
-                        return FALSE;
+                        return false;
                 }
 
                 rotationOrder = 0;
@@ -385,7 +385,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                 if (numRead != 3)
                 {
                         LL_ERRS() << "can't read Scale from " << fileName << LL_ENDL;
-                        return FALSE;
+                        return false;
                 }
                 setScale( scale );
 
@@ -406,7 +406,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                         if (numRead != 1)
                         {
                                 LL_ERRS() << "can't read NumVertices from " << fileName << LL_ENDL;
-                                return FALSE;
+                                return false;
                         }
 
                         allocateVertexData( numVertices );      
@@ -421,7 +421,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
 							if (numRead != 3)
 							{
 									LL_ERRS() << "can't read Coordinates from " << fileName << LL_ENDL;
-									return FALSE;
+									return false;
 							}
 						}
 
@@ -435,7 +435,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
 							if (numRead != 3)
 							{
 									LL_ERRS() << " can't read Normals from " << fileName << LL_ENDL;
-									return FALSE;
+									return false;
 							}
 						}
 
@@ -449,7 +449,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
 							if (numRead != 3)
 							{
 									LL_ERRS() << " can't read Binormals from " << fileName << LL_ENDL;
-									return FALSE;
+									return false;
 							}
 						}
 
@@ -461,7 +461,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                         if (numRead != numVertices)
                         {
                                 LL_ERRS() << "can't read TexCoords from " << fileName << LL_ENDL;
-                                return FALSE;
+                                return false;
                         }
 
                         //----------------------------------------------------------------
@@ -474,7 +474,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                                 if (numRead != numVertices)
                                 {
                                         LL_ERRS() << "can't read DetailTexCoords from " << fileName << LL_ENDL;
-                                        return FALSE;
+                                        return false;
                                 }
                         }
 
@@ -488,7 +488,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                                 if (numRead != numVertices)
                                 {
                                         LL_ERRS() << "can't read Weights from " << fileName << LL_ENDL;
-                                        return FALSE;
+                                        return false;
                                 }
                         }
                 }
@@ -502,7 +502,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                 if (numRead != 1)
                 {
                         LL_ERRS() << "can't read NumFaces from " << fileName << LL_ENDL;
-                        return FALSE;
+                        return false;
                 }
                 allocateFaceData( numFaces );
 
@@ -520,7 +520,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                         if (numRead != 3)
                         {
                                 LL_ERRS() << "can't read Face[" << i << "] from " << fileName << LL_ENDL;
-                                return FALSE;
+                                return false;
                         }
                         if (mReferenceData)
                         {
@@ -577,7 +577,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                                 if (numRead != 1)
                                 {
                                         LL_ERRS() << "can't read NumSkinJoints from " << fileName << LL_ENDL;
-                                        return FALSE;
+                                        return false;
                                 }
                                 allocateJointNames( numSkinJoints );
                         }
@@ -593,7 +593,7 @@ BOOL LLPolyMeshSharedData::loadMesh( const std::string& fileName )
                                 if (numRead != 1)
                                 {
                                         LL_ERRS() << "can't read Skin[" << i << "].Name from " << fileName << LL_ENDL;
-                                        return FALSE;
+                                        return false;
                                 }
 
                                 std::string *jn = &mJointNames[i];
diff --git a/indra/llappearance/llpolymorph.cpp b/indra/llappearance/llpolymorph.cpp
index 223b2b7f1c..c2f0289432 100644
--- a/indra/llappearance/llpolymorph.cpp
+++ b/indra/llappearance/llpolymorph.cpp
@@ -114,7 +114,7 @@ BOOL LLPolyMorphData::loadBinary(LLFILE *fp, LLPolyMeshSharedData *mesh)
 	if (numRead != 1)
 	{
 		LL_WARNS() << "Can't read number of morph target vertices" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	//-------------------------------------------------------------------------
@@ -151,14 +151,14 @@ BOOL LLPolyMorphData::loadBinary(LLFILE *fp, LLPolyMeshSharedData *mesh)
 		if (numRead != 1)
 		{
 			LL_WARNS() << "Can't read morph target vertex number" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 
 		if (mVertexIndices[v] > 10000)
 		{
             // Bad install? These are usually .llm files from 'character' fodler
 			LL_WARNS() << "Bad morph index " << v << ": " << mVertexIndices[v] << LL_ENDL;
-            return FALSE;
+            return false;
 		}
 
 
@@ -167,7 +167,7 @@ BOOL LLPolyMorphData::loadBinary(LLFILE *fp, LLPolyMeshSharedData *mesh)
 		if (numRead != 3)
 		{
 			LL_WARNS() << "Can't read morph target vertex coordinates" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 
 		F32 magnitude = mCoords[v].getLength3().getF32();
@@ -187,7 +187,7 @@ BOOL LLPolyMorphData::loadBinary(LLFILE *fp, LLPolyMeshSharedData *mesh)
 		if (numRead != 3)
 		{
 			LL_WARNS() << "Can't read morph target normal" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 
 		numRead = fread(&mBinormals[v], sizeof(F32), 3, fp);
@@ -195,7 +195,7 @@ BOOL LLPolyMorphData::loadBinary(LLFILE *fp, LLPolyMeshSharedData *mesh)
 		if (numRead != 3)
 		{
 			LL_WARNS() << "Can't read morph target binormal" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 
 
@@ -204,7 +204,7 @@ BOOL LLPolyMorphData::loadBinary(LLFILE *fp, LLPolyMeshSharedData *mesh)
 		if (numRead != 2)
 		{
 			LL_WARNS() << "Can't read morph target uv" << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 
 		mNumIndices++;
@@ -213,7 +213,7 @@ BOOL LLPolyMorphData::loadBinary(LLFILE *fp, LLPolyMeshSharedData *mesh)
 	mAvgDistortion.mul(1.f/(F32)mNumIndices);
 	mAvgDistortion.normalize3fast();
 
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
@@ -265,14 +265,14 @@ BOOL LLPolyMorphTargetInfo::parseXml(LLXmlTreeNode* node)
 	llassert( node->hasName( "param" ) && node->getChildByName( "param_morph" ) );
 
 	if (!LLViewerVisualParamInfo::parseXml(node))
-		return FALSE;
+		return false;
 
 	// Get mixed-case name
 	static LLStdStringHandle name_string = LLXmlTree::addAttributeString("name");
 	if( !node->getFastAttributeString( name_string, mMorphName ) )
 	{
 		LL_WARNS() << "Avatar file: <param> is missing name attribute" << LL_ENDL;
-		return FALSE;  // Continue, ignoring this tag
+		return false;  // Continue, ignoring this tag
 	}
 
 	static LLStdStringHandle clothing_morph_string = LLXmlTree::addAttributeString("clothing_morph");
@@ -284,7 +284,7 @@ BOOL LLPolyMorphTargetInfo::parseXml(LLXmlTreeNode* node)
         {
                 LL_WARNS() << "Failed to getChildByName(\"param_morph\")"
                         << LL_ENDL;
-                return FALSE;
+                return false;
         }
 
 	for (LLXmlTreeNode* child_node = paramNode->getFirstChild();
@@ -310,7 +310,7 @@ BOOL LLPolyMorphTargetInfo::parseXml(LLXmlTreeNode* node)
 		}
 	}
 	
-	return TRUE;
+	return true;
 }
 
 //-----------------------------------------------------------------------------
@@ -357,7 +357,7 @@ BOOL LLPolyMorphTarget::setInfo(LLPolyMorphTargetInfo* info)
 {
 	llassert(mInfo == NULL);
 	if (info->mID < 0)
-		return FALSE;
+		return false;
 	mInfo = info;
 	mID = info->mID;
 	setWeight(getDefaultWeight());
@@ -394,9 +394,9 @@ BOOL LLPolyMorphTarget::setInfo(LLPolyMorphTargetInfo* info)
 	if (!mMorphData)
 	{
 		LL_WARNS() << "No morph target named " << morph_param_name << " found in mesh." << LL_ENDL;
-		return FALSE;  // Continue, ignoring this tag
+		return false;  // Continue, ignoring this tag
 	}
-	return TRUE;
+	return true;
 }
 
 /*virtual*/ LLViewerVisualParam* LLPolyMorphTarget::cloneParam(LLWearable* wearable) const
@@ -416,9 +416,9 @@ BOOL LLPolyMorphTarget::parseData(LLXmlTreeNode* node)
 	if (!setInfo(info))
 	{
 		delete info;
-		return FALSE;
+		return false;
 	}
-	return TRUE;
+	return true;
 }
 #endif
 
diff --git a/indra/llappearance/llpolyskeletaldistortion.cpp b/indra/llappearance/llpolyskeletaldistortion.cpp
index 586e631ded..d3401cb08f 100644
--- a/indra/llappearance/llpolyskeletaldistortion.cpp
+++ b/indra/llappearance/llpolyskeletaldistortion.cpp
@@ -50,7 +50,7 @@ BOOL LLPolySkeletalDistortionInfo::parseXml(LLXmlTreeNode* node)
         llassert( node->hasName( "param" ) && node->getChildByName( "param_skeleton" ) );
         
         if (!LLViewerVisualParamInfo::parseXml(node))
-                return FALSE;
+                return false;
 
         LLXmlTreeNode* skeletalParam = node->getChildByName("param_skeleton");
 
@@ -58,7 +58,7 @@ BOOL LLPolySkeletalDistortionInfo::parseXml(LLXmlTreeNode* node)
         {
                 LL_WARNS() << "Failed to getChildByName(\"param_skeleton\")"
                         << LL_ENDL;
-                return FALSE;
+                return false;
         }
 
         for( LLXmlTreeNode* bone = skeletalParam->getFirstChild(); bone; bone = skeletalParam->getNextChild() )
@@ -98,7 +98,7 @@ BOOL LLPolySkeletalDistortionInfo::parseXml(LLXmlTreeNode* node)
                         continue;
                 }
         }
-        return TRUE;
+        return true;
 }
 
 //-----------------------------------------------------------------------------
@@ -137,7 +137,7 @@ BOOL LLPolySkeletalDistortion::setInfo(LLPolySkeletalDistortionInfo *info)
 {
     if (info->mID < 0)
     {
-        return FALSE;
+        return false;
     }
     mInfo = info;
     mID = info->mID;
@@ -151,7 +151,7 @@ BOOL LLPolySkeletalDistortion::setInfo(LLPolySkeletalDistortionInfo *info)
             // There's no point continuing after this error - means
             // that either the skeleton or lad file is broken.
             LL_WARNS() << "Joint " << bone_info.mBoneName << " not found." << LL_ENDL;
-			return FALSE;
+			return false;
         }
 
         // store it
@@ -174,7 +174,7 @@ BOOL LLPolySkeletalDistortion::setInfo(LLPolySkeletalDistortionInfo *info)
             mJointOffsets[joint] = bone_info.mPositionDeformation;
         }
     }
-    return TRUE;
+    return true;
 }
 
 /*virtual*/ LLViewerVisualParam* LLPolySkeletalDistortion::cloneParam(LLWearable* wearable) const
diff --git a/indra/llappearance/lltexglobalcolor.cpp b/indra/llappearance/lltexglobalcolor.cpp
index 75815482c9..9017067f98 100644
--- a/indra/llappearance/lltexglobalcolor.cpp
+++ b/indra/llappearance/lltexglobalcolor.cpp
@@ -61,12 +61,12 @@ BOOL LLTexGlobalColor::setInfo(LLTexGlobalColorInfo *info)
 		if (!param_color->setInfo(color_info, TRUE))
 		{
 			mInfo = NULL;
-			return FALSE;
+			return false;
 		}
 		mParamGlobalColorList.push_back(param_color);
 	}
 	
-	return TRUE;
+	return true;
 }
 
 LLColor4 LLTexGlobalColor::getColor() const
@@ -142,7 +142,7 @@ BOOL LLTexGlobalColorInfo::parseXml(LLXmlTreeNode* node)
 	if (!node->getFastAttributeString(name_string, mName))
 	{
 		LL_WARNS() << "<global_color> element is missing name attribute." << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 	// <param> sub-element
 	for (LLXmlTreeNode* child = node->getChildByName("param");
@@ -156,10 +156,10 @@ BOOL LLTexGlobalColorInfo::parseXml(LLXmlTreeNode* node)
 			if (!info->parseXml(child))
 			{
 				delete info;
-				return FALSE;
+				return false;
 			}
 			mParamColorInfoList.push_back(info);
 		}
 	}
-	return TRUE;
+	return true;
 }
diff --git a/indra/llappearance/lltexlayer.cpp b/indra/llappearance/lltexlayer.cpp
index e426615f1c..91f5ba1996 100644
--- a/indra/llappearance/lltexlayer.cpp
+++ b/indra/llappearance/lltexlayer.cpp
@@ -190,7 +190,7 @@ BOOL LLTexLayerSetInfo::parseXml(LLXmlTreeNode* node)
 	llassert( node->hasName( "layer_set" ) );
 	if( !node->hasName( "layer_set" ) )
 	{
-		return FALSE;
+		return false;
 	}
 
 	// body_region
@@ -198,20 +198,20 @@ BOOL LLTexLayerSetInfo::parseXml(LLXmlTreeNode* node)
 	if( !node->getFastAttributeString( body_region_string, mBodyRegion ) )
 	{
 		LL_WARNS() << "<layer_set> is missing body_region attribute" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	// width, height
 	static LLStdStringHandle width_string = LLXmlTree::addAttributeString("width");
 	if( !node->getFastAttributeS32( width_string, mWidth ) )
 	{
-		return FALSE;
+		return false;
 	}
 
 	static LLStdStringHandle height_string = LLXmlTree::addAttributeString("height");
 	if( !node->getFastAttributeS32( height_string, mHeight ) )
 	{
-		return FALSE;
+		return false;
 	}
 
 	// Optional alpha component to apply after all compositing is complete.
@@ -230,11 +230,11 @@ BOOL LLTexLayerSetInfo::parseXml(LLXmlTreeNode* node)
 		if( !info->parseXml( child ))
 		{
 			delete info;
-			return FALSE;
+			return false;
 		}
 		mLayerInfoList.push_back( info );		
 	}
-	return TRUE;
+	return true;
 }
 
 // creates visual params without generating layersets or layers
@@ -299,7 +299,7 @@ BOOL LLTexLayerSet::setInfo(const LLTexLayerSetInfo *info)
 		if (!layer->setInfo(layer_info, NULL))
 		{
 			mInfo = NULL;
-			return FALSE;
+			return false;
 		}
 		if (!layer->isVisibilityMask())
 		{
@@ -315,7 +315,7 @@ BOOL LLTexLayerSet::setInfo(const LLTexLayerSetInfo *info)
 
 	stop_glerror();
 
-	return TRUE;
+	return true;
 }
 
 #if 0 // obsolete
@@ -330,14 +330,14 @@ BOOL LLTexLayerSet::parseData(LLXmlTreeNode* node)
 	if (!info->parseXml(node))
 	{
 		delete info;
-		return FALSE;
+		return false;
 	}
 	if (!setInfo(info))
 	{
 		delete info;
-		return FALSE;
+		return false;
 	}
-	return TRUE;
+	return true;
 }
 #endif
 
@@ -539,10 +539,10 @@ BOOL LLTexLayerSet::isMorphValid() const
 	{
 		if (layer && !layer->isMorphValid())
 		{
-			return FALSE;
+			return false;
 		}
 	}
-	return TRUE;
+	return true;
 }
 
 void LLTexLayerSet::invalidateMorphMasks()
@@ -587,7 +587,7 @@ BOOL LLTexLayerInfo::parseXml(LLXmlTreeNode* node)
 	static LLStdStringHandle name_string = LLXmlTree::addAttributeString("name");
 	if( !node->getFastAttributeString( name_string, mName ) )
 	{
-		return FALSE;
+		return false;
 	}
 	
 	static LLStdStringHandle write_all_channels_string = LLXmlTree::addAttributeString("write_all_channels");
@@ -657,13 +657,13 @@ BOOL LLTexLayerInfo::parseXml(LLXmlTreeNode* node)
 			if (mLocalTexture == TEX_NUM_INDICES)
 			{
 				LL_WARNS() << "<texture> element has invalid local_texture attribute: " << mName << " " << local_texture_name << LL_ENDL;
-				return FALSE;
+				return false;
 			}
 		}
 		else	
 		{
 			LL_WARNS() << "<texture> element is missing a required attribute. " << mName << LL_ENDL;
-			return FALSE;
+			return false;
 		}
 	}
 
@@ -694,7 +694,7 @@ BOOL LLTexLayerInfo::parseXml(LLXmlTreeNode* node)
 			if (!info->parseXml(child))
 			{
 				delete info;
-				return FALSE;
+				return false;
 			}
 			mParamColorInfoList.push_back(info);
 		}
@@ -705,18 +705,18 @@ BOOL LLTexLayerInfo::parseXml(LLXmlTreeNode* node)
 			if (!info->parseXml(child))
 			{
 				delete info;
-				return FALSE;
+				return false;
 			}
  			mParamAlphaInfoList.push_back(info);
 		}
 	}
 	
-	return TRUE;
+	return true;
 }
 
 BOOL LLTexLayerInfo::createVisualParams(LLAvatarAppearance *appearance)
 {
-	BOOL success = TRUE;
+	BOOL success = true;
 	for (LLTexLayerParamColorInfo* color_info : mParamColorInfoList)
 	{
 		LLTexLayerParamColor* param_color = new LLTexLayerParamColor(appearance);
@@ -781,7 +781,7 @@ BOOL LLTexLayerInterface::setInfo(const LLTexLayerInfo *info, LLWearable* wearab
 				if (!param_color->setInfo(color_info, TRUE))
 				{
 					mInfo = NULL;
-					return FALSE;
+					return false;
 				}
 			}
 			else
@@ -790,7 +790,7 @@ BOOL LLTexLayerInterface::setInfo(const LLTexLayerInfo *info, LLWearable* wearab
 				if (!param_color)
 				{
 					mInfo = NULL;
-					return FALSE;
+					return false;
 				}
 			}
 			mParamColorList.push_back( param_color );
@@ -806,7 +806,7 @@ BOOL LLTexLayerInterface::setInfo(const LLTexLayerInfo *info, LLWearable* wearab
 				if (!param_alpha->setInfo(alpha_info, TRUE))
 				{
 					mInfo = NULL;
-					return FALSE;
+					return false;
 				}
 			}
 			else
@@ -815,13 +815,13 @@ BOOL LLTexLayerInterface::setInfo(const LLTexLayerInfo *info, LLWearable* wearab
 				if (!param_alpha)
 				{
 					mInfo = NULL;
-					return FALSE;
+					return false;
 				}
 			}
 			mParamAlphaList.push_back( param_alpha );
 		}
 
-	return TRUE;
+	return true;
 }
 
 /*virtual*/ void LLTexLayerInterface::requestUpdate()
@@ -1223,29 +1223,29 @@ BOOL LLTexLayer::findNetColor(LLColor4* net_color) const
 		}
 		
 		calculateTexLayerColor(mParamColorList, *net_color);
-		return TRUE;
+		return true;
 	}
 
 	if( !getGlobalColor().empty() )
 	{
 		net_color->setVec( mTexLayerSet->getAvatarAppearance()->getGlobalColor( getGlobalColor() ) );
-		return TRUE;
+		return true;
 	}
 
 	if( getInfo()->mFixedColor.mV[VW] )
 	{
 		net_color->setVec( getInfo()->mFixedColor );
-		return TRUE;
+		return true;
 	}
 
 	net_color->setToWhite();
 
-	return FALSE; // No need to draw a separate colored polygon
+	return false; // No need to draw a separate colored polygon
 }
 
 BOOL LLTexLayer::blendAlphaTexture(S32 x, S32 y, S32 width, S32 height)
 {
-	BOOL success = TRUE;
+	BOOL success = true;
 
 	gGL.flush();
 	
@@ -1519,11 +1519,11 @@ void LLTexLayer::addAlphaMask(U8 *data, S32 originX, S32 originY, S32 width, S32
 	{
 		if (mLocalTextureObject->getID() == IMG_INVISIBLE)
 		{
-			return TRUE;
+			return true;
 		}
 	}
 
-	return FALSE;
+	return false;
 }
 
 LLUUID LLTexLayer::getUUID() const
@@ -1726,12 +1726,12 @@ LLTexLayer* LLTexLayerTemplate::getLayer(U32 i) const
 		{
 			 if (layer->isInvisibleAlphaMask())
 			 {
-				 return TRUE;
+				 return true;
 			 }
 		}
 	}
 
-	return FALSE;
+	return false;
 }
 
 
diff --git a/indra/llappearance/lltexlayerparams.cpp b/indra/llappearance/lltexlayerparams.cpp
index 604e0124cb..16369533ca 100644
--- a/indra/llappearance/lltexlayerparams.cpp
+++ b/indra/llappearance/lltexlayerparams.cpp
@@ -79,7 +79,7 @@ BOOL LLTexLayerParam::setInfo(LLViewerVisualParamInfo *info, BOOL add_to_appeara
 		this->setParamLocation(mAvatarAppearance->isSelf() ? LOC_AV_SELF : LOC_AV_OTHER);
 	}
 
-	return TRUE;
+	return true;
 }
 
 
@@ -235,7 +235,7 @@ BOOL LLTexLayerParamAlpha::getSkip() const
 {
 	if (!mTexLayer)
 	{
-		return TRUE;
+		return true;
 	}
 
 	const LLAvatarAppearance *appearance = mTexLayer->getTexLayerSet()->getAvatarAppearance();
@@ -245,24 +245,24 @@ BOOL LLTexLayerParamAlpha::getSkip() const
 		F32 effective_weight = (appearance->getSex() & getSex()) ? mCurWeight : getDefaultWeight();
 		if (is_approx_zero(effective_weight)) 
 		{
-			return TRUE;
+			return true;
 		}
 	}
 
 	LLWearableType::EType type = (LLWearableType::EType)getWearableType();
 	if ((type != LLWearableType::WT_INVALID) && !appearance->isWearingWearableType(type))
 	{
-		return TRUE;
+		return true;
 	}
 
-	return FALSE;
+	return false;
 }
 
 
 BOOL LLTexLayerParamAlpha::render(S32 x, S32 y, S32 width, S32 height)
 {
     LL_PROFILE_ZONE_SCOPED;
-	BOOL success = TRUE;
+	BOOL success = true;
 
 	if (!mTexLayer)
 	{
@@ -300,7 +300,7 @@ BOOL LLTexLayerParamAlpha::render(S32 x, S32 y, S32 width, S32 height)
 			{
 				LL_WARNS() << "Unable to load static file: " << info->mStaticImageFileName << LL_ENDL;
 				mStaticImageInvalid = TRUE; // don't try again.
-				return FALSE;
+				return false;
 			}
 		}
 
@@ -383,12 +383,12 @@ BOOL LLTexLayerParamAlphaInfo::parseXml(LLXmlTreeNode* node)
 	llassert(node->hasName("param") && node->getChildByName("param_alpha"));
 
 	if (!LLViewerVisualParamInfo::parseXml(node))
-		return FALSE;
+		return false;
 
 	LLXmlTreeNode* param_alpha_node = node->getChildByName("param_alpha");
 	if (!param_alpha_node)
 	{
-		return FALSE;
+		return false;
 	}
 
 	static LLStdStringHandle tga_file_string = LLXmlTree::addAttributeString("tga_file");
@@ -410,7 +410,7 @@ BOOL LLTexLayerParamAlphaInfo::parseXml(LLXmlTreeNode* node)
 	static LLStdStringHandle domain_string = LLXmlTree::addAttributeString("domain");
 	param_alpha_node->getFastAttributeF32(domain_string, mDomain);
 
-	return TRUE;
+	return true;
 }
 
 
@@ -543,12 +543,12 @@ BOOL LLTexLayerParamColorInfo::parseXml(LLXmlTreeNode *node)
 	llassert(node->hasName("param") && node->getChildByName("param_color"));
 
 	if (!LLViewerVisualParamInfo::parseXml(node))
-		return FALSE;
+		return false;
 
 	LLXmlTreeNode* param_color_node = node->getChildByName("param_color");
 	if (!param_color_node)
 	{
-		return FALSE;
+		return false;
 	}
 
 	std::string op_string;
@@ -581,14 +581,14 @@ BOOL LLTexLayerParamColorInfo::parseXml(LLXmlTreeNode *node)
 	if (!mNumColors)
 	{
 		LL_WARNS() << "<param_color> is missing <value> sub-elements" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
 	if ((mOperation == LLTexLayerParamColor::OP_BLEND) && (mNumColors != 1))
 	{
 		LL_WARNS() << "<param_color> with operation\"blend\" must have exactly one <value>" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 	
-	return TRUE;
+	return true;
 }
diff --git a/indra/llappearance/llviewervisualparam.cpp b/indra/llappearance/llviewervisualparam.cpp
index fb0d12f0af..07786e3c0c 100644
--- a/indra/llappearance/llviewervisualparam.cpp
+++ b/indra/llappearance/llviewervisualparam.cpp
@@ -62,7 +62,7 @@ BOOL LLViewerVisualParamInfo::parseXml(LLXmlTreeNode *node)
 	llassert( node->hasName( "param" ) );
 
 	if (!LLVisualParamInfo::parseXml(node))
-		return FALSE;
+		return false;
 	
 	// VIEWER SPECIFIC PARAMS
 	
@@ -107,7 +107,7 @@ BOOL LLViewerVisualParamInfo::parseXml(LLXmlTreeNode *node)
 
 	params_loaded++;
 	
-	return TRUE;
+	return true;
 }
 
 /*virtual*/ void LLViewerVisualParamInfo::toStream(std::ostream &out)
@@ -150,11 +150,11 @@ BOOL LLViewerVisualParam::setInfo(LLViewerVisualParamInfo *info)
 {
 	llassert(mInfo == NULL);
 	if (info->mID < 0)
-		return FALSE;
+		return false;
 	mInfo = info;
 	mID = info->mID;
 	setWeight(getDefaultWeight());
-	return TRUE;
+	return true;
 }
 
 /*
@@ -166,14 +166,14 @@ BOOL LLViewerVisualParam::setInfo(LLViewerVisualParamInfo *info)
 //-----------------------------------------------------------------------------
 // parseData()
 //-----------------------------------------------------------------------------
-BOOL LLViewerVisualParam::parseData(LLXmlTreeNode *node)
+bool LLViewerVisualParam::parseData(LLXmlTreeNode *node)
 {
 	LLViewerVisualParamInfo* info = new LLViewerVisualParamInfo;
 
 	info->parseXml(node);
 	if (!setInfo(info))
-		return FALSE;
+		return false;
 	
-	return TRUE;
+	return true;
 }
 */
diff --git a/indra/llappearance/llwearable.cpp b/indra/llappearance/llwearable.cpp
index fdf167aa94..db7db32b3e 100644
--- a/indra/llappearance/llwearable.cpp
+++ b/indra/llappearance/llwearable.cpp
@@ -95,7 +95,7 @@ BOOL LLWearable::exportFile(const std::string& filename) const
 // virtual
 BOOL LLWearable::exportStream( std::ostream& output_stream ) const
 {
-	if (!output_stream.good()) return FALSE;
+	if (!output_stream.good()) return false;
 
 	// header and version
 	output_stream << "LLWearable version " << mDefinitionVersion  << "\n";
@@ -107,13 +107,13 @@ BOOL LLWearable::exportStream( std::ostream& output_stream ) const
 	// permissions
 	if( !mPermissions.exportLegacyStream( output_stream ) )
 	{
-		return FALSE;
+		return false;
 	}
 
 	// sale info
 	if( !mSaleInfo.exportLegacyStream( output_stream ) )
 	{
-		return FALSE;
+		return false;
 	}
 
 	// wearable type
@@ -139,7 +139,7 @@ BOOL LLWearable::exportStream( std::ostream& output_stream ) const
 		const LLUUID& image_id = te_pair.second->getID();
 		output_stream << te << " " << image_id << "\n";
 	}
-	return TRUE;
+	return true;
 }
 
 void LLWearable::createVisualParams(LLAvatarAppearance *avatarp)
@@ -473,7 +473,7 @@ BOOL LLWearable::getNextPopulatedLine(std::istream& input_stream, char* buffer,
 {
 	if (!input_stream.good())
 	{
-		return FALSE;
+		return false;
 	}
 
 	do 
diff --git a/indra/llappearance/llwearabledata.cpp b/indra/llappearance/llwearabledata.cpp
index 9fbbc57c87..2a0b77ee39 100644
--- a/indra/llappearance/llwearabledata.cpp
+++ b/indra/llappearance/llwearabledata.cpp
@@ -204,7 +204,7 @@ BOOL LLWearableData::getWearableIndex(const LLWearable *wearable, U32& index_fou
 {
 	if (wearable == NULL)
 	{
-		return FALSE;
+		return false;
 	}
 
 	const LLWearableType::EType type = wearable->getType();
@@ -212,7 +212,7 @@ BOOL LLWearableData::getWearableIndex(const LLWearable *wearable, U32& index_fou
 	if (wearable_iter == mWearableDatas.end())
 	{
 		LL_WARNS() << "tried to get wearable index with an invalid type!" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 	const wearableentry_vec_t& wearable_vec = wearable_iter->second;
 	for(U32 index = 0; index < wearable_vec.size(); index++)
@@ -220,11 +220,11 @@ BOOL LLWearableData::getWearableIndex(const LLWearable *wearable, U32& index_fou
 		if (wearable_vec[index] == wearable)
 		{
 			index_found = index;
-			return TRUE;
+			return true;
 		}
 	}
 
-	return FALSE;
+	return false;
 }
 
 U32 LLWearableData::getClothingLayerCount() const
@@ -255,13 +255,13 @@ BOOL LLWearableData::canAddWearable(const LLWearableType::EType type) const
 	}
 	else
 	{
-		return FALSE;
+		return false;
 	}
 }
 
 BOOL LLWearableData::isOnTop(LLWearable* wearable) const
 {
-	if (!wearable) return FALSE;
+	if (!wearable) return false;
 	const LLWearableType::EType type = wearable->getType();
 	return ( getTopWearable(type) == wearable );
 }
diff --git a/indra/llappearance/llwearabletype.cpp b/indra/llappearance/llwearabletype.cpp
index 4ac611b1de..056f7cf888 100644
--- a/indra/llappearance/llwearabletype.cpp
+++ b/indra/llappearance/llwearabletype.cpp
@@ -115,14 +115,14 @@ LLInventoryType::EIconName LLWearableType::getIconName(LLWearableType::EType typ
 BOOL LLWearableType::getDisableCameraSwitch(LLWearableType::EType type)
 {
 	const WearableEntry *entry = mDictionary.lookup(type);
-	if (!entry) return FALSE;
+	if (!entry) return false;
 	return entry->mDisableCameraSwitch;
 }
 
 BOOL LLWearableType::getAllowMultiwear(LLWearableType::EType type)
 {
 	const WearableEntry *entry = mDictionary.lookup(type);
-	if (!entry) return FALSE;
+	if (!entry) return false;
 	return entry->mAllowMultiwear;
 }