Convert remaining cases of BOOL to bool in llmath and llprimitive

Changed the return values for LLPrimitive::packTEMessage methods from FALSE to true - these seemed to be strange and wrong, especially considering the following statement in LLVOAvatarSelf:
bool success = packTEMessage(mesgsys);

1 files changed, 123 insertions, 123 deletions

diff --git a/indra/llmath/llvolume.h b/indra/llmath/llvolume.h
index 4ea0604f26..0df46da9d0 100644
--- a/indra/llmath/llvolume.h
+++ b/indra/llmath/llvolume.h
@@ -62,144 +62,144 @@ class LLVolumeTriangle;
 
 //============================================================================
 
-const S32 MIN_DETAIL_FACES = 6;
-const S32 MIN_LOD = 0;
-const S32 MAX_LOD = 3;
+constexpr S32 MIN_DETAIL_FACES = 6;
+constexpr S32 MIN_LOD = 0;
+constexpr S32 MAX_LOD = 3;
 
 // These are defined here but are not enforced at this level,
 // rather they are here for the convenience of code that uses
 // the LLVolume class.
-const F32 MIN_VOLUME_PROFILE_WIDTH 	= 0.05f;
-const F32 MIN_VOLUME_PATH_WIDTH 	= 0.05f;
+constexpr F32 MIN_VOLUME_PROFILE_WIDTH 	= 0.05f;
+constexpr F32 MIN_VOLUME_PATH_WIDTH 	= 0.05f;
 
-const F32 CUT_QUANTA    = 0.00002f;
-const F32 SCALE_QUANTA  = 0.01f;
-const F32 SHEAR_QUANTA  = 0.01f;
-const F32 TAPER_QUANTA  = 0.01f;
-const F32 REV_QUANTA    = 0.015f;
-const F32 HOLLOW_QUANTA = 0.00002f;
+constexpr F32 CUT_QUANTA    = 0.00002f;
+constexpr F32 SCALE_QUANTA  = 0.01f;
+constexpr F32 SHEAR_QUANTA  = 0.01f;
+constexpr F32 TAPER_QUANTA  = 0.01f;
+constexpr F32 REV_QUANTA    = 0.015f;
+constexpr F32 HOLLOW_QUANTA = 0.00002f;
 
-const S32 MAX_VOLUME_TRIANGLE_INDICES = 10000;
+constexpr S32 MAX_VOLUME_TRIANGLE_INDICES = 10000;
 
 //============================================================================
 
 // useful masks
-const LLPCode LL_PCODE_HOLLOW_MASK 	= 0x80;		// has a thickness
-const LLPCode LL_PCODE_SEGMENT_MASK = 0x40;		// segments (1 angle)
-const LLPCode LL_PCODE_PATCH_MASK 	= 0x20;		// segmented segments (2 angles)
-const LLPCode LL_PCODE_HEMI_MASK 	= 0x10;		// half-primitives get their own type per PR's dictum
-const LLPCode LL_PCODE_BASE_MASK 	= 0x0F;
+constexpr LLPCode LL_PCODE_HOLLOW_MASK 	= 0x80;		// has a thickness
+constexpr LLPCode LL_PCODE_SEGMENT_MASK = 0x40;		// segments (1 angle)
+constexpr LLPCode LL_PCODE_PATCH_MASK 	= 0x20;		// segmented segments (2 angles)
+constexpr LLPCode LL_PCODE_HEMI_MASK 	= 0x10;		// half-primitives get their own type per PR's dictum
+constexpr LLPCode LL_PCODE_BASE_MASK 	= 0x0F;
 
 	// primitive shapes
-const LLPCode	LL_PCODE_CUBE 			= 1;
-const LLPCode	LL_PCODE_PRISM 			= 2;
-const LLPCode	LL_PCODE_TETRAHEDRON 	= 3;
-const LLPCode	LL_PCODE_PYRAMID 		= 4;
-const LLPCode	LL_PCODE_CYLINDER 		= 5;
-const LLPCode	LL_PCODE_CONE 			= 6;
-const LLPCode	LL_PCODE_SPHERE 		= 7;
-const LLPCode	LL_PCODE_TORUS 			= 8;
-const LLPCode	LL_PCODE_VOLUME			= 9;
+constexpr LLPCode	LL_PCODE_CUBE 			= 1;
+constexpr LLPCode	LL_PCODE_PRISM 			= 2;
+constexpr LLPCode	LL_PCODE_TETRAHEDRON 	= 3;
+constexpr LLPCode	LL_PCODE_PYRAMID 		= 4;
+constexpr LLPCode	LL_PCODE_CYLINDER 		= 5;
+constexpr LLPCode	LL_PCODE_CONE 			= 6;
+constexpr LLPCode	LL_PCODE_SPHERE 		= 7;
+constexpr LLPCode	LL_PCODE_TORUS 			= 8;
+constexpr LLPCode	LL_PCODE_VOLUME			= 9;
 
 	// surfaces
-//const LLPCode	LL_PCODE_SURFACE_TRIANGLE 	= 10;
-//const LLPCode	LL_PCODE_SURFACE_SQUARE 	= 11;
-//const LLPCode	LL_PCODE_SURFACE_DISC 		= 12;
+//constexpr LLPCode	LL_PCODE_SURFACE_TRIANGLE 	= 10;
+//constexpr LLPCode	LL_PCODE_SURFACE_SQUARE 	= 11;
+//constexpr LLPCode	LL_PCODE_SURFACE_DISC 		= 12;
 
-const LLPCode	LL_PCODE_APP				= 14; // App specific pcode (for viewer/sim side only objects)
-const LLPCode	LL_PCODE_LEGACY				= 15;
+constexpr LLPCode	LL_PCODE_APP				= 14; // App specific pcode (for viewer/sim side only objects)
+constexpr LLPCode	LL_PCODE_LEGACY				= 15;
 
 // Pcodes for legacy objects
-//const LLPCode	LL_PCODE_LEGACY_ATOR =				0x10 | LL_PCODE_LEGACY; // ATOR
-const LLPCode	LL_PCODE_LEGACY_AVATAR =			0x20 | LL_PCODE_LEGACY; // PLAYER
-//const LLPCode	LL_PCODE_LEGACY_BIRD =				0x30 | LL_PCODE_LEGACY; // BIRD
-//const LLPCode	LL_PCODE_LEGACY_DEMON =				0x40 | LL_PCODE_LEGACY; // DEMON
-const LLPCode	LL_PCODE_LEGACY_GRASS =				0x50 | LL_PCODE_LEGACY; // GRASS
-const LLPCode	LL_PCODE_TREE_NEW =					0x60 | LL_PCODE_LEGACY; // new trees
-//const LLPCode	LL_PCODE_LEGACY_ORACLE =			0x70 | LL_PCODE_LEGACY; // ORACLE
-const LLPCode	LL_PCODE_LEGACY_PART_SYS =			0x80 | LL_PCODE_LEGACY; // PART_SYS
-const LLPCode	LL_PCODE_LEGACY_ROCK =				0x90 | LL_PCODE_LEGACY; // ROCK
-//const LLPCode	LL_PCODE_LEGACY_SHOT =				0xA0 | LL_PCODE_LEGACY; // BASIC_SHOT
-//const LLPCode	LL_PCODE_LEGACY_SHOT_BIG =			0xB0 | LL_PCODE_LEGACY;
-//const LLPCode	LL_PCODE_LEGACY_SMOKE =				0xC0 | LL_PCODE_LEGACY; // SMOKE
-//const LLPCode	LL_PCODE_LEGACY_SPARK =				0xD0 | LL_PCODE_LEGACY;// SPARK
-const LLPCode	LL_PCODE_LEGACY_TEXT_BUBBLE =		0xE0 | LL_PCODE_LEGACY; // TEXTBUBBLE
-const LLPCode	LL_PCODE_LEGACY_TREE =				0xF0 | LL_PCODE_LEGACY; // TREE
+//constexpr LLPCode	LL_PCODE_LEGACY_ATOR =				0x10 | LL_PCODE_LEGACY; // ATOR
+constexpr LLPCode	LL_PCODE_LEGACY_AVATAR =			0x20 | LL_PCODE_LEGACY; // PLAYER
+//constexpr LLPCode	LL_PCODE_LEGACY_BIRD =				0x30 | LL_PCODE_LEGACY; // BIRD
+//constexpr LLPCode	LL_PCODE_LEGACY_DEMON =				0x40 | LL_PCODE_LEGACY; // DEMON
+constexpr LLPCode	LL_PCODE_LEGACY_GRASS =				0x50 | LL_PCODE_LEGACY; // GRASS
+constexpr LLPCode	LL_PCODE_TREE_NEW =					0x60 | LL_PCODE_LEGACY; // new trees
+//constexpr LLPCode	LL_PCODE_LEGACY_ORACLE =			0x70 | LL_PCODE_LEGACY; // ORACLE
+constexpr LLPCode	LL_PCODE_LEGACY_PART_SYS =			0x80 | LL_PCODE_LEGACY; // PART_SYS
+constexpr LLPCode	LL_PCODE_LEGACY_ROCK =				0x90 | LL_PCODE_LEGACY; // ROCK
+//constexpr LLPCode	LL_PCODE_LEGACY_SHOT =				0xA0 | LL_PCODE_LEGACY; // BASIC_SHOT
+//constexpr LLPCode	LL_PCODE_LEGACY_SHOT_BIG =			0xB0 | LL_PCODE_LEGACY;
+//constexpr LLPCode	LL_PCODE_LEGACY_SMOKE =				0xC0 | LL_PCODE_LEGACY; // SMOKE
+//constexpr LLPCode	LL_PCODE_LEGACY_SPARK =				0xD0 | LL_PCODE_LEGACY;// SPARK
+constexpr LLPCode	LL_PCODE_LEGACY_TEXT_BUBBLE =		0xE0 | LL_PCODE_LEGACY; // TEXTBUBBLE
+constexpr LLPCode	LL_PCODE_LEGACY_TREE =				0xF0 | LL_PCODE_LEGACY; // TREE
 
 	// hemis
-const LLPCode	LL_PCODE_CYLINDER_HEMI =		LL_PCODE_CYLINDER	| LL_PCODE_HEMI_MASK;
-const LLPCode	LL_PCODE_CONE_HEMI =			LL_PCODE_CONE		| LL_PCODE_HEMI_MASK;
-const LLPCode	LL_PCODE_SPHERE_HEMI =			LL_PCODE_SPHERE		| LL_PCODE_HEMI_MASK;
-const LLPCode	LL_PCODE_TORUS_HEMI =			LL_PCODE_TORUS		| LL_PCODE_HEMI_MASK;
+constexpr LLPCode	LL_PCODE_CYLINDER_HEMI =		LL_PCODE_CYLINDER	| LL_PCODE_HEMI_MASK;
+constexpr LLPCode	LL_PCODE_CONE_HEMI =			LL_PCODE_CONE		| LL_PCODE_HEMI_MASK;
+constexpr LLPCode	LL_PCODE_SPHERE_HEMI =			LL_PCODE_SPHERE		| LL_PCODE_HEMI_MASK;
+constexpr LLPCode	LL_PCODE_TORUS_HEMI =			LL_PCODE_TORUS		| LL_PCODE_HEMI_MASK;
 
 
 // Volumes consist of a profile at the base that is swept around
 // a path to make a volume.
 // The profile code
-const U8	LL_PCODE_PROFILE_MASK		= 0x0f;
-const U8	LL_PCODE_PROFILE_MIN		= 0x00;
-const U8    LL_PCODE_PROFILE_CIRCLE		= 0x00;
-const U8    LL_PCODE_PROFILE_SQUARE		= 0x01;
-const U8	LL_PCODE_PROFILE_ISOTRI		= 0x02;
-const U8    LL_PCODE_PROFILE_EQUALTRI	= 0x03;
-const U8    LL_PCODE_PROFILE_RIGHTTRI	= 0x04;
-const U8	LL_PCODE_PROFILE_CIRCLE_HALF = 0x05;
-const U8	LL_PCODE_PROFILE_MAX		= 0x05;
+constexpr U8	LL_PCODE_PROFILE_MASK		= 0x0f;
+constexpr U8	LL_PCODE_PROFILE_MIN		= 0x00;
+constexpr U8    LL_PCODE_PROFILE_CIRCLE		= 0x00;
+constexpr U8    LL_PCODE_PROFILE_SQUARE		= 0x01;
+constexpr U8	LL_PCODE_PROFILE_ISOTRI		= 0x02;
+constexpr U8    LL_PCODE_PROFILE_EQUALTRI	= 0x03;
+constexpr U8    LL_PCODE_PROFILE_RIGHTTRI	= 0x04;
+constexpr U8	LL_PCODE_PROFILE_CIRCLE_HALF = 0x05;
+constexpr U8	LL_PCODE_PROFILE_MAX		= 0x05;
 
 // Stored in the profile byte
-const U8	LL_PCODE_HOLE_MASK		= 0xf0;
-const U8	LL_PCODE_HOLE_MIN		= 0x00;	  
-const U8	LL_PCODE_HOLE_SAME		= 0x00;		// same as outside profile
-const U8	LL_PCODE_HOLE_CIRCLE	= 0x10;
-const U8	LL_PCODE_HOLE_SQUARE	= 0x20;
-const U8	LL_PCODE_HOLE_TRIANGLE	= 0x30;
-const U8	LL_PCODE_HOLE_MAX		= 0x03;		// min/max needs to be >> 4 of real min/max
-
-const U8    LL_PCODE_PATH_IGNORE    = 0x00;
-const U8	LL_PCODE_PATH_MIN		= 0x01;		// min/max needs to be >> 4 of real min/max
-const U8    LL_PCODE_PATH_LINE      = 0x10;
-const U8    LL_PCODE_PATH_CIRCLE    = 0x20;
-const U8    LL_PCODE_PATH_CIRCLE2   = 0x30;
-const U8    LL_PCODE_PATH_TEST      = 0x40;
-const U8    LL_PCODE_PATH_FLEXIBLE  = 0x80;
-const U8	LL_PCODE_PATH_MAX		= 0x08;
+constexpr U8	LL_PCODE_HOLE_MASK		= 0xf0;
+constexpr U8	LL_PCODE_HOLE_MIN		= 0x00;
+constexpr U8	LL_PCODE_HOLE_SAME		= 0x00;		// same as outside profile
+constexpr U8	LL_PCODE_HOLE_CIRCLE	= 0x10;
+constexpr U8	LL_PCODE_HOLE_SQUARE	= 0x20;
+constexpr U8	LL_PCODE_HOLE_TRIANGLE	= 0x30;
+constexpr U8	LL_PCODE_HOLE_MAX		= 0x03;		// min/max needs to be >> 4 of real min/max
+
+constexpr U8    LL_PCODE_PATH_IGNORE    = 0x00;
+constexpr U8	LL_PCODE_PATH_MIN		= 0x01;		// min/max needs to be >> 4 of real min/max
+constexpr U8    LL_PCODE_PATH_LINE      = 0x10;
+constexpr U8    LL_PCODE_PATH_CIRCLE    = 0x20;
+constexpr U8    LL_PCODE_PATH_CIRCLE2   = 0x30;
+constexpr U8    LL_PCODE_PATH_TEST      = 0x40;
+constexpr U8    LL_PCODE_PATH_FLEXIBLE  = 0x80;
+constexpr U8	LL_PCODE_PATH_MAX		= 0x08;
 
 //============================================================================
 
 // face identifiers
 typedef U16 LLFaceID;
 
-const LLFaceID	LL_FACE_PATH_BEGIN		= 0x1 << 0;
-const LLFaceID	LL_FACE_PATH_END		= 0x1 << 1;
-const LLFaceID	LL_FACE_INNER_SIDE		= 0x1 << 2;
-const LLFaceID	LL_FACE_PROFILE_BEGIN	= 0x1 << 3;
-const LLFaceID	LL_FACE_PROFILE_END		= 0x1 << 4;
-const LLFaceID	LL_FACE_OUTER_SIDE_0	= 0x1 << 5;
-const LLFaceID	LL_FACE_OUTER_SIDE_1	= 0x1 << 6;
-const LLFaceID	LL_FACE_OUTER_SIDE_2	= 0x1 << 7;
-const LLFaceID	LL_FACE_OUTER_SIDE_3	= 0x1 << 8;
+constexpr LLFaceID	LL_FACE_PATH_BEGIN		= 0x1 << 0;
+constexpr LLFaceID	LL_FACE_PATH_END		= 0x1 << 1;
+constexpr LLFaceID	LL_FACE_INNER_SIDE		= 0x1 << 2;
+constexpr LLFaceID	LL_FACE_PROFILE_BEGIN	= 0x1 << 3;
+constexpr LLFaceID	LL_FACE_PROFILE_END		= 0x1 << 4;
+constexpr LLFaceID	LL_FACE_OUTER_SIDE_0	= 0x1 << 5;
+constexpr LLFaceID	LL_FACE_OUTER_SIDE_1	= 0x1 << 6;
+constexpr LLFaceID	LL_FACE_OUTER_SIDE_2	= 0x1 << 7;
+constexpr LLFaceID	LL_FACE_OUTER_SIDE_3	= 0x1 << 8;
 
 //============================================================================
 
 // sculpt types + flags
 
-const U8 LL_SCULPT_TYPE_NONE      = 0;
-const U8 LL_SCULPT_TYPE_SPHERE    = 1;
-const U8 LL_SCULPT_TYPE_TORUS     = 2;
-const U8 LL_SCULPT_TYPE_PLANE     = 3;
-const U8 LL_SCULPT_TYPE_CYLINDER  = 4;
-const U8 LL_SCULPT_TYPE_MESH      = 5;
-const U8 LL_SCULPT_TYPE_MASK      = LL_SCULPT_TYPE_SPHERE | LL_SCULPT_TYPE_TORUS | LL_SCULPT_TYPE_PLANE |
+constexpr U8 LL_SCULPT_TYPE_NONE      = 0;
+constexpr U8 LL_SCULPT_TYPE_SPHERE    = 1;
+constexpr U8 LL_SCULPT_TYPE_TORUS     = 2;
+constexpr U8 LL_SCULPT_TYPE_PLANE     = 3;
+constexpr U8 LL_SCULPT_TYPE_CYLINDER  = 4;
+constexpr U8 LL_SCULPT_TYPE_MESH      = 5;
+constexpr U8 LL_SCULPT_TYPE_MASK      = LL_SCULPT_TYPE_SPHERE | LL_SCULPT_TYPE_TORUS | LL_SCULPT_TYPE_PLANE |
 	LL_SCULPT_TYPE_CYLINDER | LL_SCULPT_TYPE_MESH;
 
 // for value checks, assign new value after adding new types
-const U8 LL_SCULPT_TYPE_MAX = LL_SCULPT_TYPE_MESH;
+constexpr U8 LL_SCULPT_TYPE_MAX = LL_SCULPT_TYPE_MESH;
 
-const U8 LL_SCULPT_FLAG_INVERT    = 64;
-const U8 LL_SCULPT_FLAG_MIRROR    = 128;
-const U8 LL_SCULPT_FLAG_MASK = LL_SCULPT_FLAG_INVERT | LL_SCULPT_FLAG_MIRROR;
+constexpr U8 LL_SCULPT_FLAG_INVERT    = 64;
+constexpr U8 LL_SCULPT_FLAG_MIRROR    = 128;
+constexpr U8 LL_SCULPT_FLAG_MASK = LL_SCULPT_FLAG_INVERT | LL_SCULPT_FLAG_MIRROR;
 
-const S32 LL_SCULPT_MESH_MAX_FACES = 8;
+constexpr S32 LL_SCULPT_MESH_MAX_FACES = 8;
 
 extern bool gDebugGL;
 
@@ -620,7 +620,7 @@ public:
 	bool setRevolutions(const F32 revolutions);	// 1 to 4
 	bool setRadiusOffset(const F32 radius_offset);
 	bool setSkew(const F32 skew);
-	bool setSculptID(const LLUUID sculpt_id, U8 sculpt_type);
+	bool setSculptID(const LLUUID& sculpt_id, U8 sculpt_type);
 
 	static bool validate(U8 prof_curve, F32 prof_begin, F32 prof_end, F32 hollow,
 		U8 path_curve, F32 path_begin, F32 path_end,
@@ -697,12 +697,12 @@ public:
 
 	S32	 getTotal() const								{ return mTotal; }
 	S32	 getTotalOut() const							{ return mTotalOut; }	// Total number of outside points
-	BOOL isFlat(S32 face) const							{ return (mFaces[face].mCount == 2); }
-	BOOL isOpen() const									{ return mOpen; }
-	void setDirty()										{ mDirty     = TRUE; }
+	bool isFlat(S32 face) const							{ return (mFaces[face].mCount == 2); }
+	bool isOpen() const									{ return mOpen; }
+	void setDirty()										{ mDirty = true; }
 
-	static S32 getNumPoints(const LLProfileParams& params, BOOL path_open, F32 detail = 1.0f, S32 split = 0,
-				  BOOL is_sculpted = FALSE, S32 sculpt_size = 0);
+	static S32 getNumPoints(const LLProfileParams& params, bool path_open, F32 detail = 1.0f, S32 split = 0,
+				  bool is_sculpted = false, S32 sculpt_size = 0);
 	bool generate(const LLProfileParams& params, bool path_open, F32 detail = 1.0f, S32 split = 0,
 				  bool is_sculpted = false, S32 sculpt_size = 0);
 	bool isConcave() const								{ return mConcave; }
@@ -712,8 +712,8 @@ public:
 		S32       mIndex;
 		S32       mCount;
 		F32       mScaleU;
-		BOOL      mCap;
-		BOOL      mFlat;
+		bool      mCap;
+		bool      mFlat;
 		LLFaceID  mFaceID;
 	};
 	
@@ -732,14 +732,14 @@ protected:
 	static S32 getNumNGonPoints(const LLProfileParams& params, S32 sides, F32 offset=0.0f, F32 bevel = 0.0f, F32 ang_scale = 1.f, S32 split = 0);
 	void genNGon(const LLProfileParams& params, S32 sides, F32 offset=0.0f, F32 bevel = 0.0f, F32 ang_scale = 1.f, S32 split = 0);
 
-	Face* addHole(const LLProfileParams& params, BOOL flat, F32 sides, F32 offset, F32 box_hollow, F32 ang_scale, S32 split = 0);
+	Face* addHole(const LLProfileParams& params, bool flat, F32 sides, F32 offset, F32 box_hollow, F32 ang_scale, S32 split = 0);
 	Face* addCap (S16 faceID);
-	Face* addFace(S32 index, S32 count, F32 scaleU, S16 faceID, BOOL flat);
+	Face* addFace(S32 index, S32 count, F32 scaleU, S16 faceID, bool flat);
 
 protected:
-	BOOL		  mOpen;
-	BOOL		  mConcave;
-	BOOL          mDirty;
+	bool		  mOpen;
+	bool		  mConcave;
+	bool          mDirty;
 
 	S32			  mTotalOut;
 	S32			  mTotal;
@@ -795,9 +795,9 @@ public:
 	virtual bool generate(const LLPathParams& params, F32 detail=1.0f, S32 split = 0,
 						  bool is_sculpted = false, S32 sculpt_size = 0);
 
-	BOOL isOpen() const						{ return mOpen; }
+	bool isOpen() const						{ return mOpen; }
 	F32 getStep() const						{ return mStep; }
-	void setDirty()							{ mDirty     = TRUE; }
+	void setDirty()							{ mDirty = true; }
 
 	S32 getPathLength() const				{ return (S32)mPath.size(); }
 
@@ -809,9 +809,9 @@ public:
 	LLAlignedArray<PathPt, 64> mPath;
 
 protected:
-	BOOL		  mOpen;
+	bool		  mOpen;
 	S32			  mTotal;
-	BOOL          mDirty;
+	bool          mDirty;
 	F32           mStep;
 };
 
@@ -870,7 +870,7 @@ private:
 	void freeData();
 public:
 
-	bool create(LLVolume* volume, BOOL partial_build = FALSE);
+	bool create(LLVolume* volume, bool partial_build = false);
 	void createTangents();
 	
 	void resizeVertices(S32 num_verts);
@@ -972,14 +972,14 @@ public:
     U8* mJointIndices;
 #endif
 
-    mutable BOOL mWeightsScrubbed;
+    mutable bool mWeightsScrubbed;
 
     // Which joints are rigged to, and the bounding box of any rigged
     // vertices per joint.
     LLJointRiggingInfoTab mJointRiggingInfoTab;
 
 	//whether or not face has been cache optimized
-	BOOL mOptimized;
+	bool mOptimized;
 
     // if this is a mesh asset, scale and translation that were applied
     // when encoding the source mesh into a unit cube
@@ -1014,7 +1014,7 @@ public:
 		S32 mCountT;
 	};
 
-	LLVolume(const LLVolumeParams &params, const F32 detail, const BOOL generate_single_face = FALSE, const BOOL is_unique = FALSE);
+	LLVolume(const LLVolumeParams &params, const F32 detail, const bool generate_single_face = false, const bool is_unique = false);
 	
 	U8 getProfileType()	const								{ return mParams.getProfileParams().getCurveType(); }
 	U8 getPathType() const									{ return mParams.getPathParams().getCurveType(); }
@@ -1047,7 +1047,7 @@ public:
 	
 	static void getLoDTriangleCounts(const LLVolumeParams& params, S32* counts);
 
-	S32 getNumTriangles(S32* vcount = NULL) const;
+	S32 getNumTriangles(S32* vcount = nullptr) const;
 
 	void generateSilhouetteVertices(std::vector<LLVector3> &vertices, 
 									std::vector<LLVector3> &normals, 
@@ -1061,10 +1061,10 @@ public:
 	//Line segment must be in volume space.
 	S32 lineSegmentIntersect(const LLVector4a& start, const LLVector4a& end,
 							 S32 face = -1,                          // which face to check, -1 = ALL_SIDES
-							 LLVector4a* intersection = NULL,         // return the intersection point
-							 LLVector2* tex_coord = NULL,            // return the texture coordinates of the intersection point
-							 LLVector4a* normal = NULL,               // return the surface normal at the intersection point
-							 LLVector4a* tangent = NULL             // return the surface tangent at the intersection point
+							 LLVector4a* intersection = nullptr,     // return the intersection point
+							 LLVector2* tex_coord = nullptr,         // return the texture coordinates of the intersection point
+							 LLVector4a* normal = nullptr,           // return the surface normal at the intersection point
+							 LLVector4a* tangent = nullptr           // return the surface tangent at the intersection point
 		);
 
 	LLFaceID generateFaceMask();
@@ -1115,7 +1115,7 @@ public:
     virtual bool isMeshAssetUnavaliable();
 
  protected:
-	BOOL mUnique;
+	bool mUnique;
 	F32 mDetail;
 	S32 mSculptLevel;
 	F32 mSurfaceArea; //unscaled surface area