Remove additional function definition comments (duplicated from headers)

Include/RmlUi/Core/Colour.inl

@@ -28,46 +28,39 @@
 
 namespace Rml {
 
-// Lightweight, non-initialising constructor.
 template <typename ColourType, int AlphaDefault>
 Colour<ColourType, AlphaDefault>::Colour(ColourType rgb, ColourType alpha) : red(rgb), green(rgb), blue(rgb), alpha(alpha)
 {}
 
-// Initialising constructor.
 template <typename ColourType, int AlphaDefault>
 Colour<ColourType, AlphaDefault>::Colour(ColourType red, ColourType green, ColourType blue, ColourType alpha) :
 	red(red), green(green), blue(blue), alpha(alpha)
 {}
 
-// Returns the sum of this colour and another. This does not saturate the channels.
 template <typename ColourType, int AlphaDefault>
 Colour<ColourType, AlphaDefault> Colour<ColourType, AlphaDefault>::operator+(const Colour<ColourType, AlphaDefault> rhs) const
 {
 	return Colour<ColourType, AlphaDefault>(red + rhs.red, green + rhs.green, blue + rhs.blue, alpha + rhs.alpha);
 }
 
-// Returns the result of subtracting another colour from this colour.
 template <typename ColourType, int AlphaDefault>
 Colour<ColourType, AlphaDefault> Colour<ColourType, AlphaDefault>::operator-(const Colour<ColourType, AlphaDefault> rhs) const
 {
 	return Colour<ColourType, AlphaDefault>(red - rhs.red, green - rhs.green, blue - rhs.blue, alpha - rhs.alpha);
 }
 
-// Returns the result of multiplying this colour component-wise by a scalar.
 template <typename ColourType, int AlphaDefault>
 Colour<ColourType, AlphaDefault> Colour<ColourType, AlphaDefault>::operator*(float rhs) const
 {
 	return Colour((ColourType)(red * rhs), (ColourType)(green * rhs), (ColourType)(blue * rhs), (ColourType)(alpha * rhs));
 }
 
-// Returns the result of dividing this colour component-wise by a scalar.
 template <typename ColourType, int AlphaDefault>
 Colour<ColourType, AlphaDefault> Colour<ColourType, AlphaDefault>::operator/(float rhs) const
 {
 	return Colour((ColourType)(red / rhs), (ColourType)(green / rhs), (ColourType)(blue / rhs), (ColourType)(alpha / rhs));
 }
 
-// Adds another colour to this in-place. This does not saturate the channels.
 template <typename ColourType, int AlphaDefault>
 void Colour<ColourType, AlphaDefault>::operator+=(const Colour rhs)
 {
@@ -77,7 +70,6 @@ void Colour<ColourType, AlphaDefault>::operator+=(const Colour rhs)
 	alpha += rhs.alpha;
 }
 
-// Subtracts another colour from this in-place.
 template <typename ColourType, int AlphaDefault>
 void Colour<ColourType, AlphaDefault>::operator-=(const Colour rhs)
 {
@@ -87,7 +79,6 @@ void Colour<ColourType, AlphaDefault>::operator-=(const Colour rhs)
 	alpha -= rhs.alpha;
 }
 
-// Scales this colour component-wise in-place.
 template <typename ColourType, int AlphaDefault>
 void Colour<ColourType, AlphaDefault>::operator*=(float rhs)
 {
@@ -97,7 +88,6 @@ void Colour<ColourType, AlphaDefault>::operator*=(float rhs)
 	alpha = (ColourType)(alpha * rhs);
 }
 
-// Scales this colour component-wise in-place by the inverse of a value.
 template <typename ColourType, int AlphaDefault>
 void Colour<ColourType, AlphaDefault>::operator/=(float rhs)
 {

Include/RmlUi/Core/Element.inl

@@ -28,7 +28,6 @@
 
 namespace Rml {
 
-// Returns the values of one of this element's properties.
 template <typename T>
 T Element::GetProperty(const String& name)
 {
@@ -41,7 +40,6 @@ T Element::GetProperty(const String& name)
 	return property->Get<T>();
 }
 
-// Sets an attribute on the element.
 template <typename T>
 void Element::SetAttribute(const String& name, const T& value)
 {
@@ -52,7 +50,6 @@ void Element::SetAttribute(const String& name, const T& value)
 	OnAttributeChange(changed_attributes);
 }
 
-// Gets the specified attribute, with default value.
 template <typename T>
 T Element::GetAttribute(const String& name, const T& default_value) const
 {

Include/RmlUi/Core/Matrix4.inl

@@ -28,7 +28,6 @@
 
 namespace Rml {
 
-// Initialising constructor.
 template <typename Component, class Storage>
 Matrix4<Component, Storage>::Matrix4(const typename Matrix4<Component, Storage>::VectorType& vec0,
 	const typename Matrix4<Component, Storage>::VectorType& vec1, const typename Matrix4<Component, Storage>::VectorType& vec2,
@@ -40,12 +39,10 @@ Matrix4<Component, Storage>::Matrix4(const typename Matrix4<Component, Storage>:
 	vectors[3] = vec3;
 }
 
-// Default constructor.
 template <typename Component, class Storage>
 Matrix4<Component, Storage>::Matrix4() noexcept : vectors{VectorType{0}, VectorType{0}, VectorType{0}, VectorType{0}}
 {}
 
-// Initialising, copy constructor.
 template <typename Component, class Storage>
 Matrix4<Component, Storage>::Matrix4(const typename Matrix4<Component, Storage>::ThisType& other) noexcept
 {
@@ -66,7 +63,6 @@ Matrix4<Component, Storage>::Matrix4(const typename Matrix4<Component, Storage>:
 	}
 }
 
-// Assignment operator
 template <typename Component, class Storage>
 const typename Matrix4<Component, Storage>::ThisType& Matrix4<Component, Storage>::operator=(
 	const typename Matrix4<Component, Storage>::ThisType& other) noexcept
@@ -91,7 +87,6 @@ const typename Matrix4<Component, Storage>::ThisType& Matrix4<Component, Storage
 	return *this;
 }
 
-// Construct from row vectors.
 template <typename Component, class Storage>
 const typename Matrix4<Component, Storage>::ThisType Matrix4<Component, Storage>::FromRows(
 	const typename Matrix4<Component, Storage>::VectorType& vec0, const typename Matrix4<Component, Storage>::VectorType& vec1,
@@ -102,7 +97,6 @@ const typename Matrix4<Component, Storage>::ThisType Matrix4<Component, Storage>
 	return result;
 }
 
-// Construct from column vectors.
 template <typename Component, class Storage>
 const typename Matrix4<Component, Storage>::ThisType Matrix4<Component, Storage>::FromColumns(
 	const typename Matrix4<Component, Storage>::VectorType& vec0, const typename Matrix4<Component, Storage>::VectorType& vec1,
@@ -113,7 +107,6 @@ const typename Matrix4<Component, Storage>::ThisType Matrix4<Component, Storage>
 	return result;
 }
 
-// Construct from components
 template <typename Component, class Storage>
 const typename Matrix4<Component, Storage>::ThisType Matrix4<Component, Storage>::FromRowMajor(const Component* components) noexcept
 {
@@ -143,7 +136,6 @@ const typename Matrix4<Component, Storage>::ThisType Matrix4<Component, Storage>
 	return result;
 }
 
-// Set all rows
 template <typename Component, class Storage>
 void Matrix4<Component, Storage>::SetRows(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) noexcept
 {
@@ -154,7 +146,6 @@ void Matrix4<Component, Storage>::SetRows(const VectorType& vec0, const VectorTy
 	rows[3] = vec3;
 }
 
-// Set all columns
 template <typename Component, class Storage>
 void Matrix4<Component, Storage>::SetColumns(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) noexcept
 {
@@ -165,11 +156,10 @@ void Matrix4<Component, Storage>::SetColumns(const VectorType& vec0, const Vecto
 	columns[3] = vec3;
 }
 
-// Inverts this matrix in place.
-// This is from the MESA implementation of the GLU library.
 template <typename Component, class Storage>
 bool Matrix4<Component, Storage>::Invert() noexcept
 {
+	// This is from the MESA implementation of the GLU library.
 	Matrix4<Component, Storage>::ThisType result;
 	Component* dst = result.data();
 	const Component* src = data();
@@ -256,14 +246,12 @@ inline float Matrix4<Component, Storage>::Determinant() const noexcept
 	return det;
 }
 
-// Returns the negation of this matrix.
 template <typename Component, class Storage>
 typename Matrix4<Component, Storage>::ThisType Matrix4<Component, Storage>::operator-() const noexcept
 {
 	return typename Matrix4<Component, Storage>::ThisType(-vectors[0], -vectors[1], -vectors[2], -vectors[3]);
 }
 
-// Adds another matrix to this in-place.
 template <typename Component, class Storage>
 const typename Matrix4<Component, Storage>::ThisType& Matrix4<Component, Storage>::operator+=(
 	const typename Matrix4<Component, Storage>::ThisType& other) noexcept
@@ -287,7 +275,6 @@ const typename Matrix4<Component, Storage>::ThisType& Matrix4<Component, Storage
 	return *this;
 }
 
-// Subtracts another matrix from this in-place.
 template <typename Component, class Storage>
 const typename Matrix4<Component, Storage>::ThisType& Matrix4<Component, Storage>::operator-=(
 	const typename Matrix4<Component, Storage>::ThisType& other) noexcept
@@ -311,7 +298,6 @@ const typename Matrix4<Component, Storage>::ThisType& Matrix4<Component, Storage
 	return *this;
 }
 
-// Scales this matrix in-place.
 template <typename Component, class Storage>
 const typename Matrix4<Component, Storage>::ThisType& Matrix4<Component, Storage>::operator*=(Component s) noexcept
 {
@@ -322,7 +308,6 @@ const typename Matrix4<Component, Storage>::ThisType& Matrix4<Component, Storage
 	return *this;
 }
 
-// Scales this matrix in-place by the inverse of a value.
 template <typename Component, class Storage>
 const typename Matrix4<Component, Storage>::ThisType& Matrix4<Component, Storage>::operator/=(Component s) noexcept
 {
@@ -333,7 +318,6 @@ const typename Matrix4<Component, Storage>::ThisType& Matrix4<Component, Storage
 	return *this;
 }
 
-// Equality operator.
 template <typename Component, class Storage>
 bool Matrix4<Component, Storage>::operator==(const typename Matrix4<Component, Storage>::ThisType& other) const noexcept
 {
@@ -349,7 +333,6 @@ bool Matrix4<Component, Storage>::operator==(const typename Matrix4<Component, S
 	return rows[0] == other_rows[0] && rows[1] == other_rows[1] && rows[2] == other_rows[2] && rows[3] == other_rows[3];
 }
 
-// Inequality operator.
 template <typename Component, class Storage>
 bool Matrix4<Component, Storage>::operator!=(const typename Matrix4<Component, Storage>::ThisType& other) const noexcept
 {
@@ -363,7 +346,6 @@ bool Matrix4<Component, Storage>::operator!=(const typename Matrix4<Component, S
 	return rows[0] != other_rows[0] || rows[1] != other_rows[1] || rows[2] != other_rows[2] || rows[3] != other_rows[3];
 }
 
-// Return the identity matrix.
 template <typename Component, class Storage>
 const Matrix4<Component, Storage>& Matrix4<Component, Storage>::Identity() noexcept
 {
@@ -371,7 +353,6 @@ const Matrix4<Component, Storage>& Matrix4<Component, Storage>::Identity() noexc
 	return identity;
 }
 
-// Return a diagonal matrix.
 template <typename Component, class Storage>
 Matrix4<Component, Storage> Matrix4<Component, Storage>::Diag(Component a, Component b, Component c, Component d) noexcept
 {
@@ -380,7 +361,6 @@ Matrix4<Component, Storage> Matrix4<Component, Storage>::Diag(Component a, Compo
 		Matrix4<Component, Storage>::VectorType(0, 0, 0, d));
 }
 
-// Create an orthographic projection matrix
 template <typename Component, class Storage>
 Matrix4<Component, Storage> Matrix4<Component, Storage>::ProjectOrtho(Component l, Component r, Component b, Component t, Component n,
 	Component f) noexcept
@@ -390,7 +370,6 @@ Matrix4<Component, Storage> Matrix4<Component, Storage>::ProjectOrtho(Component
 		Matrix4<Component, Storage>::VectorType(0, 0, 2 / (f - n), -(f + n) / (f - n)), Matrix4<Component, Storage>::VectorType(0, 0, 0, 1));
 }
 
-// Create a perspective projection matrix
 template <typename Component, class Storage>
 Matrix4<Component, Storage> Matrix4<Component, Storage>::ProjectPerspective(Component l, Component r, Component b, Component t, Component n,
 	Component f) noexcept
@@ -401,7 +380,6 @@ Matrix4<Component, Storage> Matrix4<Component, Storage>::ProjectPerspective(Comp
 		Matrix4<Component, Storage>::VectorType(0, 0, -1, 0));
 }
 
-// Create a perspective projection matrix
 template <typename Component, class Storage>
 Matrix4<Component, Storage> Matrix4<Component, Storage>::Perspective(Component d) noexcept
 {
@@ -410,7 +388,6 @@ Matrix4<Component, Storage> Matrix4<Component, Storage>::Perspective(Component d
 		Matrix4<Component, Storage>::VectorType(0, 0, -static_cast<Component>(1) / d, 1));
 }
 
-// Return a translation matrix.
 template <typename Component, class Storage>
 Matrix4<Component, Storage> Matrix4<Component, Storage>::Translate(const Vector3<Component>& v) noexcept
 {
@@ -443,7 +420,6 @@ Matrix4<Component, Storage> Matrix4<Component, Storage>::TranslateZ(Component z)
 	return Translate(Vector3<Component>(0, 0, z));
 }
 
-// Return a scaling matrix.
 template <typename Component, class Storage>
 Matrix4<Component, Storage> Matrix4<Component, Storage>::Scale(Component x, Component y, Component z) noexcept
 {
@@ -468,7 +444,6 @@ Matrix4<Component, Storage> Matrix4<Component, Storage>::ScaleZ(Component z) noe
 	return Scale(1, 1, z);
 }
 
-// Return a rotation matrix.
 template <typename Component, class Storage>
 Matrix4<Component, Storage> Matrix4<Component, Storage>::Rotate(const Vector3<Component>& v, Component angle) noexcept
 {
@@ -511,8 +486,7 @@ Matrix4<Component, Storage> Matrix4<Component, Storage>::RotateZ(Component angle
 		Matrix4<Component, Storage>::VectorType(Sin, Cos, 0, 0), Matrix4<Component, Storage>::VectorType(0, 0, 1, 0),
 		Matrix4<Component, Storage>::VectorType(0, 0, 0, 1));
 }
-// Return a skew/shearing matrix.
-// @return A skew matrix.
+
 template <typename Component, class Storage>
 Matrix4<Component, Storage> Matrix4<Component, Storage>::Skew(Component angle_x, Component angle_y) noexcept
 {

Include/RmlUi/Core/Variant.inl

@@ -47,7 +47,6 @@ Variant& Variant::operator=(T&& t)
 	return *this;
 }
 
-// Templatised data accessor.
 template <typename T>
 bool Variant::GetInto(T& value) const
 {

Include/RmlUi/Core/Vector2.inl

@@ -28,22 +28,18 @@
 
 namespace Rml {
 
-// Default constructor.
 template <typename Type>
 Vector2<Type>::Vector2() : x{}, y{}
 {}
 
-// Initialising constructor.
 template <typename Type>
 Vector2<Type>::Vector2(Type v) : x(v), y(v)
 {}
 
-// Initialising constructor.
 template <typename Type>
 Vector2<Type>::Vector2(Type x, Type y) : x(x), y(y)
 {}
 
-// Returns the magnitude of the vector.
 template <typename Type>
 float Vector2<Type>::Magnitude() const
 {
@@ -54,14 +50,12 @@ float Vector2<Type>::Magnitude() const
 	return Math::SquareRoot(squared_magnitude);
 }
 
-// Returns the squared magnitude of the vector.
 template <typename Type>
 Type Vector2<Type>::SquaredMagnitude() const
 {
 	return x * x + y * y;
 }
 
-// Generates a normalised vector from this vector.
 template <typename Type>
 inline Vector2<Type> Vector2<Type>::Normalise() const
 {
@@ -79,7 +73,6 @@ inline Vector2<float> Vector2<float>::Normalise() const
 	return *this / magnitude;
 }
 
-// Generates a rounded vector from this vector.
 template <>
 inline Vector2<float> Vector2<float>::Round() const
 {
@@ -89,21 +82,18 @@ inline Vector2<float> Vector2<float>::Round() const
 	return result;
 }
 
-// Generates a rounded vector from this vector.
 template <>
 inline Vector2<int> Vector2<int>::Round() const
 {
 	return *this;
 }
 
-// Computes the dot-product between this vector and another.
 template <typename Type>
 Type Vector2<Type>::DotProduct(Vector2 rhs) const
 {
 	return x * rhs.x + y * rhs.y;
 }
 
-// Returns this vector rotated around the origin.
 template <typename Type>
 Vector2<Type> Vector2<Type>::Rotate(float theta) const
 {
@@ -113,28 +103,24 @@ Vector2<Type> Vector2<Type>::Rotate(float theta) const
 	return Vector2<Type>(((Type)(cos_theta * x - sin_theta * y)), ((Type)(sin_theta * x + cos_theta * y)));
 }
 
-// Returns the negation of this vector.
 template <typename Type>
 Vector2<Type> Vector2<Type>::operator-() const
 {
 	return Vector2(-x, -y);
 }
 
-// Returns the sum of this vector and another.
 template <typename Type>
 Vector2<Type> Vector2<Type>::operator+(Vector2 rhs) const
 {
 	return Vector2<Type>(x + rhs.x, y + rhs.y);
 }
 
-// Returns the result of subtracting another vector from this vector.
 template <typename Type>
 Vector2<Type> Vector2<Type>::operator-(Vector2 rhs) const
 {
 	return Vector2(x - rhs.x, y - rhs.y);
 }
 
-// Returns the result of multiplying this vector by a scalar.
 template <typename Type>
 Vector2<Type> Vector2<Type>::operator*(Type rhs) const
 {
@@ -147,7 +133,6 @@ Vector2<Type> Vector2<Type>::operator*(Vector2 rhs) const
 	return Vector2(x * rhs.x, y * rhs.y);
 }
 
-// Returns the result of dividing this vector by a scalar.
 template <typename Type>
 Vector2<Type> Vector2<Type>::operator/(Type rhs) const
 {
@@ -160,7 +145,6 @@ Vector2<Type> Vector2<Type>::operator/(Vector2 rhs) const
 	return Vector2(x / rhs.x, y / rhs.y);
 }
 
-// Adds another vector to this in-place.
 template <typename Type>
 Vector2<Type>& Vector2<Type>::operator+=(Vector2 rhs)
 {
@@ -170,7 +154,6 @@ Vector2<Type>& Vector2<Type>::operator+=(Vector2 rhs)
 	return *this;
 }
 
-// Subtracts another vector from this in-place.
 template <typename Type>
 Vector2<Type>& Vector2<Type>::operator-=(Vector2 rhs)
 {
@@ -180,7 +163,6 @@ Vector2<Type>& Vector2<Type>::operator-=(Vector2 rhs)
 	return *this;
 }
 
-// Scales this vector in-place.
 template <typename Type>
 Vector2<Type>& Vector2<Type>::operator*=(Type rhs)
 {
@@ -199,7 +181,6 @@ Vector2<Type>& Vector2<Type>::operator*=(Vector2 rhs)
 	return *this;
 }
 
-// Scales this vector in-place by the inverse of a value.
 template <typename Type>
 Vector2<Type>& Vector2<Type>::operator/=(Type rhs)
 {
@@ -217,35 +198,30 @@ Vector2<Type>& Vector2<Type>::operator/=(Vector2 rhs)
 	return *this;
 }
 
-// Equality operator.
 template <typename Type>
 bool Vector2<Type>::operator==(Vector2 rhs) const
 {
 	return (x == rhs.x && y == rhs.y);
 }
 
-// Inequality operator.
 template <typename Type>
 bool Vector2<Type>::operator!=(Vector2 rhs) const
 {
 	return (x != rhs.x || y != rhs.y);
 }
 
-// Auto-cast operator.
 template <typename Type>
 Vector2<Type>::operator const Type*() const
 {
 	return &x;
 }
 
-// Constant auto-cast operator.
 template <typename Type>
 Vector2<Type>::operator Type*()
 {
 	return &x;
 }
 
-// Underlying type-cast operator.
 template <typename Type>
 template <typename U>
 inline Vector2<Type>::operator Vector2<U>() const
@@ -253,7 +229,6 @@ inline Vector2<Type>::operator Vector2<U>() const
 	return Vector2<U>(static_cast<U>(x), static_cast<U>(y));
 }
 
-// Multiply by scalar operator.
 template <typename Type>
 inline Vector2<Type> operator*(Type lhs, Vector2<Type> rhs)
 {

Include/RmlUi/Core/Vector3.inl

@@ -30,22 +30,18 @@
 
 namespace Rml {
 
-// Default constructor.
 template <typename Type>
 Vector3<Type>::Vector3() : x{}, y{}, z{}
 {}
 
-// Initialising constructor.
 template <typename Type>
 Vector3<Type>::Vector3(Type v) : x(v), y(v), z(v)
 {}
 
-// Initialising constructor.
 template <typename Type>
 Vector3<Type>::Vector3(Type x, Type y, Type z) : x(x), y(y), z(z)
 {}
 
-// Returns the magnitude of the vector.
 template <typename Type>
 float Vector3<Type>::Magnitude() const
 {
@@ -56,14 +52,12 @@ float Vector3<Type>::Magnitude() const
 	return Math::SquareRoot(squared_magnitude);
 }
 
-// Returns the squared magnitude of the vector.
 template <typename Type>
 Type Vector3<Type>::SquaredMagnitude() const
 {
 	return x * x + y * y + z * z;
 }
 
-// Generates a normalised vector from this vector.
 template <typename Type>
 inline Vector3<Type> Vector3<Type>::Normalise() const
 {
@@ -81,56 +75,48 @@ inline Vector3<float> Vector3<float>::Normalise() const
 	return *this / magnitude;
 }
 
-// Computes the dot-product between this vector and another.
 template <typename Type>
 Type Vector3<Type>::DotProduct(const Vector3<Type>& rhs) const
 {
 	return x * rhs.x + y * rhs.y + z * rhs.z;
 }
 
-// Computes the cross-product between this vector and another.
 template <typename Type>
 Vector3<Type> Vector3<Type>::CrossProduct(const Vector3<Type>& rhs) const
 {
 	return Vector3<Type>(y * rhs.z - z * rhs.y, z * rhs.x - x * rhs.z, x * rhs.y - y * rhs.x);
 }
 
-// Returns the negation of this vector.
 template <typename Type>
 Vector3<Type> Vector3<Type>::operator-() const
 {
 	return Vector3(-x, -y, -z);
 }
 
-// Returns the sum of this vector and another.
 template <typename Type>
 Vector3<Type> Vector3<Type>::operator+(const Vector3<Type>& rhs) const
 {
 	return Vector3<Type>(x + rhs.x, y + rhs.y, z + rhs.z);
 }
 
-// Returns the result of subtracting another vector from this vector.
 template <typename Type>
 Vector3<Type> Vector3<Type>::operator-(const Vector3<Type>& rhs) const
 {
 	return Vector3(x - rhs.x, y - rhs.y, z - rhs.z);
 }
 
-// Returns the result of multiplying this vector by a scalar.
 template <typename Type>
 Vector3<Type> Vector3<Type>::operator*(Type rhs) const
 {
 	return Vector3(x * rhs, y * rhs, z * rhs);
 }
 
-// Returns the result of dividing this vector by a scalar.
 template <typename Type>
 Vector3<Type> Vector3<Type>::operator/(Type rhs) const
 {
 	return Vector3(x / rhs, y / rhs, z / rhs);
 }
 
-// Adds another vector to this in-place.
 template <typename Type>
 Vector3<Type>& Vector3<Type>::operator+=(const Vector3& rhs)
 {
@@ -141,7 +127,6 @@ Vector3<Type>& Vector3<Type>::operator+=(const Vector3& rhs)
 	return *this;
 }
 
-// Subtracts another vector from this in-place.
 template <typename Type>
 Vector3<Type>& Vector3<Type>::operator-=(const Vector3& rhs)
 {
@@ -152,7 +137,6 @@ Vector3<Type>& Vector3<Type>::operator-=(const Vector3& rhs)
 	return *this;
 }
 
-// Scales this vector in-place.
 template <typename Type>
 Vector3<Type>& Vector3<Type>::operator*=(const Type& rhs)
 {
@@ -163,7 +147,6 @@ Vector3<Type>& Vector3<Type>::operator*=(const Type& rhs)
 	return *this;
 }
 
-// Scales this vector in-place by the inverse of a value.
 template <typename Type>
 Vector3<Type>& Vector3<Type>::operator/=(const Type& rhs)
 {
@@ -174,35 +157,30 @@ Vector3<Type>& Vector3<Type>::operator/=(const Type& rhs)
 	return *this;
 }
 
-// Equality operator.
 template <typename Type>
 bool Vector3<Type>::operator==(const Vector3& rhs) const
 {
 	return (x == rhs.x && y == rhs.y && z == rhs.z);
 }
 
-// Inequality operator.
 template <typename Type>
 bool Vector3<Type>::operator!=(const Vector3& rhs) const
 {
 	return (x != rhs.x || y != rhs.y || z != rhs.z);
 }
 
-// Constant auto-cast operator.
 template <typename Type>
 Vector3<Type>::operator const Type*() const
 {
 	return &x;
 }
 
-// Auto-cast operator.
 template <typename Type>
 Vector3<Type>::operator Type*()
 {
 	return &x;
 }
 
-// Underlying type-cast operator.
 template <typename Type>
 template <typename U>
 inline Vector3<Type>::operator Vector3<U>() const
@@ -216,7 +194,6 @@ Vector3<Type>::operator Vector2<Type>() const
 	return Vector2<Type>(x, y);
 }
 
-// Multiply by scalar operator.
 template <typename Type>
 inline Vector3<Type> operator*(Type lhs, Vector3<Type> rhs)
 {

Include/RmlUi/Core/Vector4.inl

@@ -30,27 +30,22 @@
 
 namespace Rml {
 
-// Default constructor.
 template <typename Type>
 Vector4<Type>::Vector4() : x{}, y{}, z{}, w{}
 {}
 
-// Initialising constructor.
 template <typename Type>
 Vector4<Type>::Vector4(Type v) : x(v), y(v), z(v), w(v)
 {}
 
-// Initialising constructor.
 template <typename Type>
 Vector4<Type>::Vector4(Type x, Type y, Type z, Type w) : x(x), y(y), z(z), w(w)
 {}
 
-// Implicit conversion from a 3D Vector.
 template <typename Type>
 Vector4<Type>::Vector4(Vector3<Type> const& v, Type w) : x(v.x), y(v.y), z(v.z), w(w)
 {}
 
-// Returns the magnitude of the vector.
 template <typename Type>
 float Vector4<Type>::Magnitude() const
 {
@@ -61,14 +56,12 @@ float Vector4<Type>::Magnitude() const
 	return Math::SquareRoot(squared_magnitude);
 }
 
-// Returns the squared magnitude of the vector.
 template <typename Type>
 Type Vector4<Type>::SquaredMagnitude() const
 {
 	return x * x + y * y + z * z + w * w;
 }
 
-// Generates a normalised vector from this vector.
 template <typename Type>
 inline Vector4<Type> Vector4<Type>::Normalise() const
 {
@@ -86,7 +79,6 @@ inline Vector4<float> Vector4<float>::Normalise() const
 	return *this / magnitude;
 }
 
-// Computes the dot-product between this vector and another.
 template <typename Type>
 Type Vector4<Type>::DotProduct(const Vector4<Type>& rhs) const
 {
@@ -99,42 +91,36 @@ Vector3<Type> Vector4<Type>::PerspectiveDivide() const
 	return Vector3<Type>(x / w, y / w, z / w);
 }
 
-// Returns the negation of this vector.
 template <typename Type>
 Vector4<Type> Vector4<Type>::operator-() const
 {
 	return Vector4(-x, -y, -z, -w);
 }
 
-// Returns the sum of this vector and another.
 template <typename Type>
 Vector4<Type> Vector4<Type>::operator+(const Vector4<Type>& rhs) const
 {
 	return Vector4<Type>(x + rhs.x, y + rhs.y, z + rhs.z, w + rhs.w);
 }
 
-// Returns the result of subtracting another vector from this vector.
 template <typename Type>
 Vector4<Type> Vector4<Type>::operator-(const Vector4<Type>& rhs) const
 {
 	return Vector4(x - rhs.x, y - rhs.y, z - rhs.z, w - rhs.w);
 }
 
-// Returns the result of multiplying this vector by a scalar.
 template <typename Type>
 Vector4<Type> Vector4<Type>::operator*(Type rhs) const
 {
 	return Vector4(x * rhs, y * rhs, z * rhs, w * rhs);
 }
 
-// Returns the result of dividing this vector by a scalar.
 template <typename Type>
 Vector4<Type> Vector4<Type>::operator/(Type rhs) const
 {
 	return Vector4(x / rhs, y / rhs, z / rhs, w / rhs);
 }
 
-// Adds another vector to this in-place.
 template <typename Type>
 Vector4<Type>& Vector4<Type>::operator+=(const Vector4& rhs)
 {
@@ -146,7 +132,6 @@ Vector4<Type>& Vector4<Type>::operator+=(const Vector4& rhs)
 	return *this;
 }
 
-// Subtracts another vector from this in-place.
 template <typename Type>
 Vector4<Type>& Vector4<Type>::operator-=(const Vector4& rhs)
 {
@@ -158,7 +143,6 @@ Vector4<Type>& Vector4<Type>::operator-=(const Vector4& rhs)
 	return *this;
 }
 
-// Scales this vector in-place.
 template <typename Type>
 Vector4<Type>& Vector4<Type>::operator*=(const Type& rhs)
 {
@@ -170,7 +154,6 @@ Vector4<Type>& Vector4<Type>::operator*=(const Type& rhs)
 	return *this;
 }
 
-// Scales this vector in-place by the inverse of a value.
 template <typename Type>
 Vector4<Type>& Vector4<Type>::operator/=(const Type& rhs)
 {
@@ -182,35 +165,30 @@ Vector4<Type>& Vector4<Type>::operator/=(const Type& rhs)
 	return *this;
 }
 
-// Equality operator.
 template <typename Type>
 bool Vector4<Type>::operator==(const Vector4& rhs) const
 {
 	return (x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w);
 }
 
-// Inequality operator.
 template <typename Type>
 bool Vector4<Type>::operator!=(const Vector4& rhs) const
 {
 	return (x != rhs.x || y != rhs.y || z != rhs.z || w != rhs.w);
 }
 
-// Auto-cast operator.
 template <typename Type>
 Vector4<Type>::operator const Type*() const
 {
 	return &x;
 }
 
-// Constant auto-cast operator.
 template <typename Type>
 Vector4<Type>::operator Type*()
 {
 	return &x;
 }
 
-// Underlying type-cast operator.
 template <typename Type>
 template <typename U>
 inline Vector4<Type>::operator Vector4<U>() const
@@ -230,7 +208,6 @@ Vector4<Type>::operator Vector2<Type>() const
 	return Vector2<Type>(x, y);
 }
 
-// Multiply by scalar operator.
 template <typename Type>
 inline Vector4<Type> operator*(Type lhs, Vector4<Type> rhs)
 {