Refactoring

Include/Rocket/Core/Context.h

@@ -83,7 +83,7 @@ public:
 
 
 	/// Returns the current state of the view.
-	const ViewState& GetViewState() const throw();
+	const ViewState& GetViewState() const noexcept;
 
 	/// Changes the size ratio of 'dp' unit to 'px' unit
 	/// @param[in] dimensions The new density-independent pixel ratio of the context.

Include/Rocket/Core/Element.h

@@ -278,17 +278,17 @@ public:
 	/// Returns 'transform-origin-z' property value from element's style or local cache.
 	const Property *GetTransformOriginZ();
 	/// Returns this element's TransformState
-	const TransformState *GetTransformState() const throw();
+	const TransformState *GetTransformState() const noexcept;
 	/// Returns the TransformStates that are effective for this element.
 	void GetEffectiveTransformState(
 		const TransformState **local_perspective,
 		const TransformState **perspective,
 		const TransformState **transform
-	) throw();
+	) noexcept;
 	/// Project a 2D point in pixel coordinates onto the element's plane.
 	/// @param[in] point The point to project.
 	/// @return The projected coordinates.
-	const Vector2f Project(const Vector2f& point) throw();
+	const Vector2f Project(const Vector2f& point) noexcept;
 
 	/// Start an animation of the given property on this element.
 	/// Currently, only float and Colourb property values are supported. If an animation of the same property name exists, the target value

Include/Rocket/Core/Matrix4.h

@@ -52,11 +52,11 @@ struct MatrixStorageBase
 				int idx;
 
 			public:
-				inline StrideVector(VectorsType& vectors, int idx) throw()
+				inline StrideVector(VectorsType& vectors, int idx) noexcept
 					: vectors(vectors), idx(idx) { }
-				inline ComponentType& operator[](int i) throw()
+				inline ComponentType& operator[](int i) noexcept
 					{ return vectors[i][idx]; }
-				inline StrideVector& operator=(const VectorType& vec) throw()
+				inline StrideVector& operator=(const VectorType& vec) noexcept
 					{
 						(*this)[0] = vec[0];
 						(*this)[1] = vec[1];
@@ -64,7 +64,7 @@ struct MatrixStorageBase
 						(*this)[3] = vec[3];
 						return *this;
 					}
-				operator const VectorType() const throw()
+				operator const VectorType() const noexcept
 					{
 						return VectorType(
 							(*this)[0],
@@ -78,9 +78,9 @@ struct MatrixStorageBase
 		{
 				VectorsType& vectors;
 			public:
-				inline StrideAccess(VectorsType& vectors) throw()
+				inline StrideAccess(VectorsType& vectors) noexcept
 					: vectors(vectors) { }
-				inline StrideVector operator[](int i) throw()
+				inline StrideVector operator[](int i) noexcept
 					{ return StrideVector(vectors, i); }
 		};
 		class ConstStrideVector
@@ -88,11 +88,11 @@ struct MatrixStorageBase
 				const VectorsType& vectors;
 				int idx;
 			public:
-				inline ConstStrideVector(const VectorsType& vectors, int idx) throw()
+				inline ConstStrideVector(const VectorsType& vectors, int idx) noexcept
 					: vectors(vectors), idx(idx) { }
-				inline const ComponentType& operator[](int i) const throw()
+				inline const ComponentType& operator[](int i) const noexcept
 					{ return vectors[i][idx]; }
-				inline operator const VectorType() const throw()
+				inline operator const VectorType() const noexcept
 					{
 						return VectorType(
 							(*this)[0],
@@ -106,9 +106,9 @@ struct MatrixStorageBase
 		{
 				const VectorsType& vectors;
 			public:
-				inline ConstStrideAccess(const VectorsType& vectors) throw()
+				inline ConstStrideAccess(const VectorsType& vectors) noexcept
 					: vectors(vectors) { }
-				inline ConstStrideVector operator[](int i) throw()
+				inline ConstStrideVector operator[](int i) noexcept
 					{ return ConstStrideVector(vectors, i); }
 		};
 
@@ -116,16 +116,16 @@ struct MatrixStorageBase
 		{
 				VectorType& vector;
 			public:
-				inline PackedVector(VectorType& vector) throw()
+				inline PackedVector(VectorType& vector) noexcept
 					: vector(vector) { }
-				inline ComponentType& operator[](int i) throw()
+				inline ComponentType& operator[](int i) noexcept
 					{ return vector[i]; }
-				inline PackedVector& operator=(const VectorType& vec) throw()
+				inline PackedVector& operator=(const VectorType& vec) noexcept
 					{
 						vector = vec;
 						return *this;
 					}
-				inline PackedVector& operator=(StrideVector& vec) throw()
+				inline PackedVector& operator=(StrideVector& vec) noexcept
 					{
 						vector[0] = vec[0];
 						vector[1] = vec[1];
@@ -133,7 +133,7 @@ struct MatrixStorageBase
 						vector[3] = vec[3];
 						return *this;
 					}
-				inline PackedVector& operator=(ConstStrideVector& vec) throw()
+				inline PackedVector& operator=(ConstStrideVector& vec) noexcept
 					{
 						vector[0] = vec[0];
 						vector[1] = vec[1];
@@ -141,15 +141,15 @@ struct MatrixStorageBase
 						vector[3] = vec[3];
 						return *this;
 					}
-				inline operator VectorType&() throw() { return vector; }
+				inline operator VectorType&() noexcept { return vector; }
 		};
 		class PackedAccess
 		{
 				VectorsType& vectors;
 			public:
-				inline PackedAccess(VectorsType& vectors) throw()
+				inline PackedAccess(VectorsType& vectors) noexcept
 					: vectors(vectors) { }
-				inline PackedVector operator[](int i) throw()
+				inline PackedVector operator[](int i) noexcept
 					{ return PackedVector(vectors[i]); }
 		};
 		#if 0
@@ -157,20 +157,20 @@ struct MatrixStorageBase
 		{
 				const VectorType& vectors;
 			public:
-				inline ConstPackedVector(const VectorType& vectors) throw()
+				inline ConstPackedVector(const VectorType& vectors) noexcept
 					: vectors(vectors) { }
-				inline const ComponentType& operator[](int i) const throw()
+				inline const ComponentType& operator[](int i) const noexcept
 					{ return vectors[i]; }
-				inline operator const VectorType&() throw() { return vectors; }
+				inline operator const VectorType&() noexcept { return vectors; }
 		};
 		#endif
 		class ConstPackedAccess
 		{
 				const VectorsType& vectors;
 			public:
-				inline ConstPackedAccess(const VectorsType& vectors) throw()
+				inline ConstPackedAccess(const VectorsType& vectors) noexcept
 					: vectors(vectors) { }
-				inline const VectorType& operator[](int i) throw()
+				inline const VectorType& operator[](int i) noexcept
 					{ return vectors[i]; }
 		};
 };
@@ -256,7 +256,7 @@ class Matrix4
 		VectorType vectors[4];
 
 		/// Initialising constructor.
-		Matrix4(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) throw();
+		Matrix4(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) noexcept;
 
 		template< typename _Component, class _StorageA >
 		struct VectorMultiplier
@@ -269,7 +269,7 @@ class Matrix4
 			static const VectorType Multiply(
 				const MatrixAType& lhs,
 				const VectorType& rhs
-			) throw();
+			) noexcept;
 		};
 
 		template< typename _Component, class _StorageA, class _StorageB >
@@ -289,156 +289,156 @@ class Matrix4
 			static const MatrixAType Multiply(
 				const MatrixAType& lhs,
 				const MatrixBType& rhs
-			) throw();
+			) noexcept;
 		};
 
 	public:
 		/// Lightweight, non-initialising constructor.
-		inline Matrix4() throw();
+		inline Matrix4() noexcept;
 
 		/// Initialising, copy constructor.
-		inline Matrix4(const ThisType& other) throw();
-		Matrix4(const TransposeType& other) throw();
+		inline Matrix4(const ThisType& other) noexcept;
+		Matrix4(const TransposeType& other) noexcept;
 
 		/// Assignment operator
-		const ThisType& operator=(const ThisType& other) throw();
-		const ThisType& operator=(const TransposeType& other) throw();
+		const ThisType& operator=(const ThisType& other) noexcept;
+		const ThisType& operator=(const TransposeType& other) noexcept;
 
 		/// Construct from row vectors.
-		static const ThisType FromRows(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) throw();
+		static const ThisType FromRows(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) noexcept;
 
 		/// Construct from column vectors.
-		static const ThisType FromColumns(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) throw();
+		static const ThisType FromColumns(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) noexcept;
 
 		/// Construct from components.
-		static const ThisType FromRowMajor(const ComponentType* components) throw();
-		static const ThisType FromColumnMajor(const ComponentType* components) throw();
+		static const ThisType FromRowMajor(const ComponentType* components) noexcept;
+		static const ThisType FromColumnMajor(const ComponentType* components) noexcept;
 
 		// Convert to raw values; keep the storage mode in mind.
-		inline Component* data() throw()
+		inline Component* data() noexcept
 			{ return &vectors[0][0]; }
-		inline const Component* data() const throw()
+		inline const Component* data() const noexcept
 			{ return &vectors[0][0]; }
 
 		/// Get the i-th row
-		inline Row GetRow(int i) throw()
+		inline Row GetRow(int i) noexcept
 			{ Rows rows(vectors); return rows[i]; }
 		/// Get the i-th row
-		inline ConstRow GetRow(int i) const throw()
+		inline ConstRow GetRow(int i) const noexcept
 			{ ConstRows rows(vectors); return rows[i]; }
 		/// Set the i-th row
-		inline void SetRow(int i, const VectorType& vec) throw()
+		inline void SetRow(int i, const VectorType& vec) noexcept
 			{ Rows rows(vectors); rows[i] = vec; }
 		/// Set all rows
-		void SetRows(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) throw();
+		void SetRows(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) noexcept;
 
 		/// Get the i-th column
-		inline Column GetColumn(int i) throw()
+		inline Column GetColumn(int i) noexcept
 			{ Columns columns(vectors); return columns[i]; }
 		/// Get the i-th column
-		inline ConstColumn GetColumn(int i) const throw()
+		inline ConstColumn GetColumn(int i) const noexcept
 			{ ConstColumns columns(vectors); return columns[i]; }
 		/// Set the i-th column
-		inline void SetColumn(int i, const VectorType& vec) throw()
+		inline void SetColumn(int i, const VectorType& vec) noexcept
 			{ Columns columns(vectors); columns[i] = vec; }
 		/// Set all columns
-		void SetColumns(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) throw();
+		void SetColumns(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) noexcept;
 
 		/// Returns the transpose of this matrix.
 		/// @return The transpose matrix.
-		inline const TransposeType& Transpose() const throw()
+		inline const TransposeType& Transpose() const noexcept
 			{ return reinterpret_cast<const TransposeType&>(*this); }
 
 		/// Inverts this matrix in place, if possible.
 		/// @return true, if the inversion succeeded.
-		bool Invert() throw();
+		bool Invert() noexcept;
 
 		/// Returns the negation of this matrix.
 		/// @return The negation of this matrix.
-		ThisType operator-() const throw();
+		ThisType operator-() const noexcept;
 
 		/// Adds another matrix to this in-place.
 		/// @param[in] other The matrix to add.
 		/// @return This matrix, post-operation.
-		const ThisType& operator+=(const ThisType& other) throw();
-		const ThisType& operator+=(const TransposeType& other) throw();
+		const ThisType& operator+=(const ThisType& other) noexcept;
+		const ThisType& operator+=(const TransposeType& other) noexcept;
 		/// Subtracts another matrix from this in-place.
 		/// @param[in] other The matrix to subtract.
 		/// @return This matrix, post-operation.
-		const ThisType& operator-=(const ThisType& other) throw();
-		const ThisType& operator-=(const TransposeType& other) throw();
+		const ThisType& operator-=(const ThisType& other) noexcept;
+		const ThisType& operator-=(const TransposeType& other) noexcept;
 		/// Scales this matrix in-place.
 		/// @param[in] other The value to scale this matrix's components by.
 		/// @return This matrix, post-operation.
-		const ThisType& operator*=(Component other) throw();
+		const ThisType& operator*=(Component other) noexcept;
 		/// Scales this matrix in-place by the inverse of a value.
 		/// @param[in] other The value to divide this matrix's components by.
 		/// @return This matrix, post-operation.
-		const ThisType& operator/=(Component other) throw();
+		const ThisType& operator/=(Component other) noexcept;
 
 		/// Returns the sum of this matrix and another.
 		/// @param[in] other The matrix to add this to.
 		/// @return The sum of the two matrices.
-		inline const ThisType operator+(const ThisType& other) const throw()
+		inline const ThisType operator+(const ThisType& other) const noexcept
 			{ ThisType result(*this); result += other; return result; }
-		inline const ThisType operator+(const TransposeType& other) const throw()
+		inline const ThisType operator+(const TransposeType& other) const noexcept
 			{ ThisType result(*this); result += other; return result; }
 		/// Returns the result of subtracting another matrix from this matrix.
 		/// @param[in] other The matrix to subtract from this matrix.
 		/// @return The result of the subtraction.
-		inline const ThisType operator-(const ThisType& other) const throw()
+		inline const ThisType operator-(const ThisType& other) const noexcept
 			{ ThisType result(*this); result -= other; return result; }
-		inline const ThisType operator-(const TransposeType& other) const throw()
+		inline const ThisType operator-(const TransposeType& other) const noexcept
 			{ ThisType result(*this); result -= other; return result; }
 		/// Returns the result of multiplying this matrix by a scalar.
 		/// @param[in] other The scalar value to multiply by.
 		/// @return The result of the scale.
-		inline const ThisType operator*(Component other) const throw()
+		inline const ThisType operator*(Component other) const noexcept
 			{ ThisType result(*this); result *= other; return result; }
 		/// Returns the result of dividing this matrix by a scalar.
 		/// @param[in] other The scalar value to divide by.
 		/// @return The result of the scale.
-		inline const ThisType operator/(Component other) const throw()
+		inline const ThisType operator/(Component other) const noexcept
 			{ ThisType result(*this); result *= other; return result; }
 
 		/// Returns the result of multiplying this matrix by a vector.
 		/// @param[in] other The scalar value to multiply by.
 		/// @return The result of the scale.
-		const VectorType operator*(const VectorType& other) const throw()
+		const VectorType operator*(const VectorType& other) const noexcept
 			{ return VectorMultiplier< Component, Storage >::Multiply(*this, other); }
 
 		/// Returns the result of multiplying this matrix by another matrix.
 		/// @param[in] other The matrix value to multiply by.
 		/// @return The result of the multiplication.
 		template< class Storage2 >
-		const ThisType operator*(const Matrix4< Component, Storage2 >& other) const throw()
+		const ThisType operator*(const Matrix4< Component, Storage2 >& other) const noexcept
 			{ return MatrixMultiplier< Component, Storage, Storage2 >::Multiply(*this, other); }
 
 		/// Multiplies this matrix by another matrix in place.
 		/// @param[in] other The scalar value to multiply by.
 		/// @return The result of the scale.
-		inline const ThisType& operator*=(const ThisType& other) throw()
+		inline const ThisType& operator*=(const ThisType& other) noexcept
 			{ *this = *this * other; return *this; }
-		inline const ThisType& operator*=(const TransposeType& other) throw()
+		inline const ThisType& operator*=(const TransposeType& other) noexcept
 			{ *this = *this * other; return *this; }
 
 		/// Equality operator.
 		/// @param[in] other The matrix to compare this against.
 		/// @return True if the two matrices are equal, false otherwise.
-		bool operator==(const ThisType& other) const throw();
-		bool operator==(const TransposeType& other) const throw();
+		bool operator==(const ThisType& other) const noexcept;
+		bool operator==(const TransposeType& other) const noexcept;
 		/// Inequality operator.
 		/// @param[in] other The matrix to compare this against.
 		/// @return True if the two matrices are not equal, false otherwise.
-		bool operator!=(const ThisType& other) const throw();
-		bool operator!=(const TransposeType& other) const throw();
+		bool operator!=(const ThisType& other) const noexcept;
+		bool operator!=(const TransposeType& other) const noexcept;
 
 		/// Return the identity matrix.
 		/// @return The identity matrix.
-		inline static const ThisType& Identity() throw();
+		inline static const ThisType& Identity() noexcept;
 		/// Return a diagonal matrix.
 		/// @return A diagonal matrix.
-		static ThisType Diag(Component a, Component b, Component c, Component d = 1) throw();
+		static ThisType Diag(Component a, Component b, Component c, Component d = 1) noexcept;
 
 		/// Create an orthographic projection matrix
 		/// @param l The horizontal coordinate of the left clipping plane
@@ -448,7 +448,7 @@ class Matrix4
 		/// @param n The depth coordinate of the near clipping plane
 		/// @param f The depth coordinate of the far clipping plane
 		/// @return The specified orthographic projection matrix.
-		static ThisType ProjectOrtho(Component l, Component r, Component b, Component t, Component n, Component f) throw();
+		static ThisType ProjectOrtho(Component l, Component r, Component b, Component t, Component n, Component f) noexcept;
 		/// Create a perspective projection matrix
 		/// @param l The horizontal coordinate of the left clipping plane
 		/// @param r The horizontal coordinate of the right clipping plane
@@ -457,35 +457,35 @@ class Matrix4
 		/// @param n The depth coordinate of the near clipping plane
 		/// @param f The depth coordinate of the far clipping plane
 		/// @return The specified perspective projection matrix.
-		static ThisType ProjectPerspective(Component l, Component r, Component b, Component t, Component n, Component f) throw();
+		static ThisType ProjectPerspective(Component l, Component r, Component b, Component t, Component n, Component f) noexcept;
 
 		/// Return a translation matrix.
 		/// @return A translation matrix.
-		static ThisType Translate (const Vector3< Component >& v) throw();
-		static ThisType Translate (Component x, Component y, Component z) throw();
-		static ThisType TranslateX (Component x) throw();
-		static ThisType TranslateY (Component y) throw();
-		static ThisType TranslateZ (Component z) throw();
+		static ThisType Translate (const Vector3< Component >& v) noexcept;
+		static ThisType Translate (Component x, Component y, Component z) noexcept;
+		static ThisType TranslateX (Component x) noexcept;
+		static ThisType TranslateY (Component y) noexcept;
+		static ThisType TranslateZ (Component z) noexcept;
 
 		/// Return a scaling matrix.
 		/// @return A scaling matrix.
-		static ThisType Scale (Component x, Component y, Component z) throw();
-		static ThisType ScaleX (Component x) throw();
-		static ThisType ScaleY (Component y) throw();
-		static ThisType ScaleZ (Component z) throw();
+		static ThisType Scale (Component x, Component y, Component z) noexcept;
+		static ThisType ScaleX (Component x) noexcept;
+		static ThisType ScaleY (Component y) noexcept;
+		static ThisType ScaleZ (Component z) noexcept;
 
 		/// Return a rotation matrix.
 		/// @return A rotation matrix.
-		static ThisType Rotate (const Vector3< Component >& v, Component angle) throw();
-		static ThisType RotateX (Component angle) throw();
-		static ThisType RotateY (Component angle) throw();
-		static ThisType RotateZ (Component angle) throw();
+		static ThisType Rotate (const Vector3< Component >& v, Component angle) noexcept;
+		static ThisType RotateX (Component angle) noexcept;
+		static ThisType RotateY (Component angle) noexcept;
+		static ThisType RotateZ (Component angle) noexcept;
 
 		/// Return a skew/shearing matrix.
 		/// @return A skew matrix.
-		static ThisType Skew (Component angle_x, Component angle_y) throw();
-		static ThisType SkewX (Component angle) throw();
-		static ThisType SkewY (Component angle) throw();
+		static ThisType Skew (Component angle_x, Component angle_y) noexcept;
+		static ThisType SkewX (Component angle) noexcept;
+		static ThisType SkewY (Component angle) noexcept;
 };
 }
 }

Include/Rocket/Core/Matrix4.inl

@@ -35,7 +35,7 @@ Matrix4< Component, Storage >::Matrix4(
 	const typename Matrix4< Component, Storage >::VectorType& vec1,
 	const typename Matrix4< Component, Storage >::VectorType& vec2,
 	const typename Matrix4< Component, Storage >::VectorType& vec3
-) throw()
+) noexcept
 {
 	vectors[0] = vec0;
 	vectors[1] = vec1;
@@ -45,13 +45,13 @@ Matrix4< Component, Storage >::Matrix4(
 
 // Default constructor.
 template< typename Component, class Storage >
-Matrix4< Component, Storage >::Matrix4() throw()
+Matrix4< Component, Storage >::Matrix4() noexcept
 {
 }
 
 // Initialising, copy constructor.
 template< typename Component, class Storage >
-Matrix4< Component, Storage >::Matrix4(const typename Matrix4< Component, Storage >::ThisType& other) throw()
+Matrix4< Component, Storage >::Matrix4(const typename Matrix4< Component, Storage >::ThisType& other) noexcept
 {
 	for (int i = 0; i < 4; ++i)
 	{
@@ -60,7 +60,7 @@ Matrix4< Component, Storage >::Matrix4(const typename Matrix4< Component, Storag
 }
 
 template< typename Component, class Storage >
-Matrix4< Component, Storage >::Matrix4(const typename Matrix4< Component, Storage >::TransposeType& other) throw()
+Matrix4< Component, Storage >::Matrix4(const typename Matrix4< Component, Storage >::TransposeType& other) noexcept
 {
 	Rows rows(vectors);
 	typename Matrix4< Component, Storage >::TransposeType::ConstRows other_rows(other.vectors);
@@ -73,7 +73,7 @@ Matrix4< Component, Storage >::Matrix4(const typename Matrix4< Component, Storag
 
 // Assignment operator
 template< typename Component, class Storage >
-const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Storage >::operator=(const typename Matrix4< Component, Storage >::ThisType& other) throw()
+const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Storage >::operator=(const typename Matrix4< Component, Storage >::ThisType& other) noexcept
 {
 	for (int i = 0; i < 4; ++i)
 	{
@@ -83,7 +83,7 @@ const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Stor
 }
 
 template< typename Component, class Storage >
-const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Storage >::operator=(const typename Matrix4< Component, Storage >::TransposeType& other) throw()
+const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Storage >::operator=(const typename Matrix4< Component, Storage >::TransposeType& other) noexcept
 {
 	Rows rows(vectors);
 	typename Matrix4< Component, Storage >::TransposeType::Rows other_rows(other.vectors);
@@ -101,7 +101,7 @@ const typename Matrix4< Component, Storage >::ThisType Matrix4< Component, Stora
 	const typename Matrix4< Component, Storage >::VectorType& vec1,
 	const typename Matrix4< Component, Storage >::VectorType& vec2,
 	const typename Matrix4< Component, Storage >::VectorType& vec3
-) throw()
+) noexcept
 {
 	typename Matrix4< Component, Storage >::ThisType result;
 	result.SetRows(vec0, vec1, vec2, vec3);
@@ -115,7 +115,7 @@ const typename Matrix4< Component, Storage >::ThisType Matrix4< Component, Stora
 	const typename Matrix4< Component, Storage >::VectorType& vec1,
 	const typename Matrix4< Component, Storage >::VectorType& vec2,
 	const typename Matrix4< Component, Storage >::VectorType& vec3
-) throw()
+) noexcept
 {
 	typename Matrix4< Component, Storage >::ThisType result;
 	result.SetColumns(vec0, vec1, vec2, vec3);
@@ -124,7 +124,7 @@ const typename Matrix4< Component, Storage >::ThisType Matrix4< Component, Stora
 
 // Construct from components
 template< typename Component, class Storage >
-const typename Matrix4< Component, Storage >::ThisType Matrix4< Component, Storage >::FromRowMajor(const Component* components) throw()
+const typename Matrix4< Component, Storage >::ThisType Matrix4< Component, Storage >::FromRowMajor(const Component* components) noexcept
 {
 	Matrix4< Component, Storage >::ThisType result;
 	Matrix4< Component, Storage >::Rows rows(result.vectors);
@@ -138,7 +138,7 @@ const typename Matrix4< Component, Storage >::ThisType Matrix4< Component, Stora
 	return result;
 }
 template< typename Component, class Storage >
-const typename Matrix4< Component, Storage >::ThisType Matrix4< Component, Storage >::FromColumnMajor(const Component* components) throw()
+const typename Matrix4< Component, Storage >::ThisType Matrix4< Component, Storage >::FromColumnMajor(const Component* components) noexcept
 {
 	Matrix4< Component, Storage >::ThisType result;
 	Matrix4< Component, Storage >::Columns columns(result.vectors);
@@ -154,7 +154,7 @@ const typename Matrix4< Component, Storage >::ThisType Matrix4< Component, Stora
 
 // 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) throw()
+void Matrix4< Component, Storage >::SetRows(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) noexcept
 {
 	Rows rows(vectors);
 	rows[0] = vec0;
@@ -165,7 +165,7 @@ void Matrix4< Component, Storage >::SetRows(const VectorType& vec0, const Vector
 
 // 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) throw()
+void Matrix4< Component, Storage >::SetColumns(const VectorType& vec0, const VectorType& vec1, const VectorType& vec2, const VectorType& vec3) noexcept
 {
 	Columns columns(vectors);
 	columns[0] = vec0;
@@ -177,7 +177,7 @@ void Matrix4< Component, Storage >::SetColumns(const VectorType& vec0, const Vec
 // 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() throw()
+bool Matrix4< Component, Storage >::Invert() noexcept
 {
 	Matrix4< Component, Storage >::ThisType result;
 	Component *dst = result.data();
@@ -311,7 +311,7 @@ bool Matrix4< Component, Storage >::Invert() throw()
 
 // Returns the negation of this matrix.
 template< typename Component, class Storage >
-typename Matrix4< Component, Storage >::ThisType Matrix4< Component, Storage >::operator-() const throw()
+typename Matrix4< Component, Storage >::ThisType Matrix4< Component, Storage >::operator-() const noexcept
 {
 	return typename Matrix4< Component, Storage >::ThisType(
 		-vectors[0],
@@ -323,7 +323,7 @@ typename Matrix4< Component, Storage >::ThisType Matrix4< Component, Storage >::
 
 // 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) throw()
+const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Storage >::operator+=(const typename Matrix4< Component, Storage >::ThisType& other) noexcept
 {
 	for (int i = 0; i < 4; ++i)
 	{
@@ -332,7 +332,7 @@ const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Stor
 	return *this;
 }
 template< typename Component, class Storage>
-const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Storage >::operator+=(const typename Matrix4< Component, Storage >::TransposeType& other) throw()
+const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Storage >::operator+=(const typename Matrix4< Component, Storage >::TransposeType& other) noexcept
 {
 	Rows rows(vectors);
 	typename Matrix4< Component, Storage >::TransposeType::ConstRows other_rows(other);
@@ -345,7 +345,7 @@ const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Stor
 
 // 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) throw()
+const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Storage >::operator-=(const typename Matrix4< Component, Storage >::ThisType& other) noexcept
 {
 	for (int i = 0; i < 4; ++i)
 	{
@@ -354,7 +354,7 @@ const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Stor
 	return *this;
 }
 template< typename Component, class Storage>
-const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Storage >::operator-=(const typename Matrix4< Component, Storage >::TransposeType& other) throw()
+const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Storage >::operator-=(const typename Matrix4< Component, Storage >::TransposeType& other) noexcept
 {
 	Rows rows(vectors);
 	typename Matrix4< Component, Storage >::TransposeType::ConstRows other_rows(other);
@@ -367,7 +367,7 @@ const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Stor
 
 // Scales this matrix in-place.
 template< typename Component, class Storage>
-const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Storage >::operator*=(Component s) throw()
+const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Storage >::operator*=(Component s) noexcept
 {
 	for (int i = 0; i < 4; ++i)
 	{
@@ -378,7 +378,7 @@ const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Stor
 
 // 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) throw()
+const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Storage >::operator/=(Component s) noexcept
 {
 	for (int i = 0; i < 4; ++i)
 	{
@@ -389,7 +389,7 @@ const typename Matrix4< Component, Storage >::ThisType& Matrix4< Component, Stor
 
 // Equality operator.
 template< typename Component, class Storage>
-bool Matrix4< Component, Storage >::operator==(const typename Matrix4< Component, Storage >::ThisType& other) const throw()
+bool Matrix4< Component, Storage >::operator==(const typename Matrix4< Component, Storage >::ThisType& other) const noexcept
 {
 	typename Matrix4< Component, Storage >::ConstRows rows(vectors);
 	typename Matrix4< Component, Storage >::ConstRows other_rows(other.vectors);
@@ -399,7 +399,7 @@ bool Matrix4< Component, Storage >::operator==(const typename Matrix4< Component
 	   && vectors[3] == other.vectors[3];
 }
 template< typename Component, class Storage>
-bool Matrix4< Component, Storage >::operator==(const typename Matrix4< Component, Storage >::TransposeType& other) const throw()
+bool Matrix4< Component, Storage >::operator==(const typename Matrix4< Component, Storage >::TransposeType& other) const noexcept
 {
 	typename Matrix4< Component, Storage >::ConstRows rows(vectors);
 	typename Matrix4< Component, Storage >::ConstRows other_rows(other.vectors);
@@ -411,7 +411,7 @@ bool Matrix4< Component, Storage >::operator==(const typename Matrix4< Component
 
 // Inequality operator.
 template< typename Component, class Storage>
-bool Matrix4< Component, Storage >::operator!=(const typename Matrix4< Component, Storage >::ThisType& other) const throw()
+bool Matrix4< Component, Storage >::operator!=(const typename Matrix4< Component, Storage >::ThisType& other) const noexcept
 {
 	return vectors[0] != other.vectors[0]
 	    || vectors[1] != other.vectors[1]
@@ -419,7 +419,7 @@ bool Matrix4< Component, Storage >::operator!=(const typename Matrix4< Component
 	    || vectors[3] != other.vectors[3];
 }
 template< typename Component, class Storage>
-bool Matrix4< Component, Storage >::operator!=(const typename Matrix4< Component, Storage >::TransposeType& other) const throw()
+bool Matrix4< Component, Storage >::operator!=(const typename Matrix4< Component, Storage >::TransposeType& other) const noexcept
 {
 	typename Matrix4< Component, Storage >::ConstRows rows(vectors);
 	typename Matrix4< Component, Storage >::ConstRows other_rows(other.vectors);
@@ -431,7 +431,7 @@ bool Matrix4< Component, Storage >::operator!=(const typename Matrix4< Component
 
 // Return the identity matrix.
 template< typename Component, class Storage>
-const Matrix4< Component, Storage >& Matrix4< Component, Storage >::Identity() throw()
+const Matrix4< Component, Storage >& Matrix4< Component, Storage >::Identity() noexcept
 {
 	static Matrix4< Component, Storage > identity(Diag(1, 1, 1, 1));
 	return identity;
@@ -439,7 +439,7 @@ const Matrix4< Component, Storage >& Matrix4< Component, Storage >::Identity() t
 
 // Return a diagonal matrix.
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::Diag(Component a, Component b, Component c, Component d) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::Diag(Component a, Component b, Component c, Component d) noexcept
 {
 	return Matrix4< Component, Storage >::FromRows(
 		Matrix4< Component, Storage >::VectorType(a, 0, 0, 0),
@@ -451,7 +451,7 @@ Matrix4< Component, Storage > Matrix4< Component, Storage >::Diag(Component a, C
 
 // 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) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::ProjectOrtho(Component l, Component r, Component b, Component t, Component n, Component f) noexcept
 {
 	return Matrix4< Component, Storage >::FromRows(
 		Matrix4< Component, Storage >::VectorType(2 / (r - l), 0, 0, -(r + l)/(r - l)),
@@ -463,7 +463,7 @@ Matrix4< Component, Storage > Matrix4< Component, Storage >::ProjectOrtho(Compon
 
 // 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) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::ProjectPerspective(Component l, Component r, Component b, Component t, Component n, Component f) noexcept
 {
 	return Matrix4< Component, Storage >::FromRows(
 		Matrix4< Component, Storage >::VectorType(2 * n / (r - l), 0, (r + l)/(r - l), 0),
@@ -475,13 +475,13 @@ Matrix4< Component, Storage > Matrix4< Component, Storage >::ProjectPerspective(
 
 // Return a translation matrix.
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::Translate(const Vector3< Component >& v) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::Translate(const Vector3< Component >& v) noexcept
 {
 	return Translate(v.x, v.y, v.z);
 }
 
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::Translate(Component x, Component y, Component z) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::Translate(Component x, Component y, Component z) noexcept
 {
 	return Matrix4< Component, Storage >::FromRows(
 		Matrix4< Component, Storage >::VectorType(1, 0, 0, x),
@@ -492,51 +492,51 @@ Matrix4< Component, Storage > Matrix4< Component, Storage >::Translate(Component
 }
 
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::TranslateX(Component x) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::TranslateX(Component x) noexcept
 {
 	return Translate(Vector3< Component >(x, 0, 0));
 }
 
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::TranslateY(Component y) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::TranslateY(Component y) noexcept
 {
 	return Translate(Vector3< Component >(0, y, 0));
 }
 
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::TranslateZ(Component z) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::TranslateZ(Component z) noexcept
 {
 	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) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::Scale(Component x, Component y, Component z) noexcept
 {
 	return Matrix4::Diag(x, y, z, 1);
 }
 
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::ScaleX(Component x) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::ScaleX(Component x) noexcept
 {
 	return Scale(x, 1, 1);
 }
 
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::ScaleY(Component y) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::ScaleY(Component y) noexcept
 {
 	return Scale(1, y, 1);
 }
 
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::ScaleZ(Component z) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::ScaleZ(Component z) noexcept
 {
 	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) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::Rotate(const Vector3< Component >& v, Component angle) noexcept
 {
 	Vector3< Component > n = v.Normalise();
 	Component Sin = Math::Sin(angle);
@@ -565,7 +565,7 @@ Matrix4< Component, Storage > Matrix4< Component, Storage >::Rotate(const Vector
 }
 
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::RotateX(Component angle) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::RotateX(Component angle) noexcept
 {
 	Component Sin = Math::Sin(angle);
 	Component Cos = Math::Cos(angle);
@@ -578,7 +578,7 @@ Matrix4< Component, Storage > Matrix4< Component, Storage >::RotateX(Component a
 }
 
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::RotateY(Component angle) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::RotateY(Component angle) noexcept
 {
 	Component Sin = Math::Sin(angle);
 	Component Cos = Math::Cos(angle);
@@ -591,7 +591,7 @@ Matrix4< Component, Storage > Matrix4< Component, Storage >::RotateY(Component a
 }
 
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::RotateZ(Component angle) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::RotateZ(Component angle) noexcept
 {
 	Component Sin = Math::Sin(angle);
 	Component Cos = Math::Cos(angle);
@@ -605,7 +605,7 @@ Matrix4< Component, Storage > Matrix4< Component, Storage >::RotateZ(Component a
 // 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) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::Skew(Component angle_x, Component angle_y) noexcept
 {
 	Component SkewX = Math::Tan(angle_x);
 	Component SkewY = Math::Tan(angle_y);
@@ -618,13 +618,13 @@ Matrix4< Component, Storage > Matrix4< Component, Storage >::Skew(Component angl
 }
 
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::SkewX(Component angle) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::SkewX(Component angle) noexcept
 {
 	return Skew(angle, 0);
 }
 
 template< typename Component, class Storage>
-Matrix4< Component, Storage > Matrix4< Component, Storage >::SkewY(Component angle) throw()
+Matrix4< Component, Storage > Matrix4< Component, Storage >::SkewY(Component angle) noexcept
 {
 	return Skew(0, angle);
 }
@@ -638,7 +638,7 @@ struct Matrix4< Component, Storage >::VectorMultiplier< _Component, RowMajorStor
 	typedef Matrix4< ComponentType, StorageAType > MatrixAType;
 	typedef Vector4< ComponentType > VectorType;
 
-	static const VectorType Multiply(const MatrixAType& lhs, const VectorType& rhs) throw()
+	static const VectorType Multiply(const MatrixAType& lhs, const VectorType& rhs) noexcept
 	{
 		typename MatrixAType::ConstRows rows(lhs.vectors);
 		return VectorType(
@@ -659,7 +659,7 @@ struct Matrix4< Component, Storage >::VectorMultiplier< _Component, ColumnMajorS
 	typedef Matrix4< ComponentType, StorageAType > MatrixAType;
 	typedef Vector4< ComponentType > VectorType;
 
-	static const VectorType Multiply(const MatrixAType& lhs, const VectorType& rhs) throw()
+	static const VectorType Multiply(const MatrixAType& lhs, const VectorType& rhs) noexcept
 	{
 		typename MatrixAType::ConstRows rows(lhs.vectors);
 		return VectorType(
@@ -681,7 +681,7 @@ struct Matrix4< Component, Storage >::MatrixMultiplier< _Component, RowMajorStor
 	typedef Matrix4< ComponentType, StorageAType > MatrixAType;
 	typedef Matrix4< ComponentType, StorageBType > MatrixBType;
 
-	static const MatrixAType Multiply(const MatrixAType& lhs, const MatrixBType& rhs) throw()
+	static const MatrixAType Multiply(const MatrixAType& lhs, const MatrixBType& rhs) noexcept
 	{
 		typename MatrixAType::ThisType result;
 		typename MatrixAType::Rows result_rows(result.vectors);
@@ -708,7 +708,7 @@ struct Matrix4< Component, Storage >::MatrixMultiplier< _Component, ColumnMajorS
 	typedef Matrix4< ComponentType, StorageAType > MatrixAType;
 	typedef Matrix4< ComponentType, StorageBType > MatrixBType;
 
-	static const MatrixAType Multiply(const MatrixAType& lhs, const MatrixBType& rhs) throw()
+	static const MatrixAType Multiply(const MatrixAType& lhs, const MatrixBType& rhs) noexcept
 	{
 		typename MatrixAType::ThisType result;
 		typename MatrixAType::Rows result_rows(result.vectors);
@@ -735,7 +735,7 @@ struct Matrix4< Component, Storage >::MatrixMultiplier< _Component, ColumnMajorS
 	typedef Matrix4< ComponentType, StorageAType > MatrixAType;
 	typedef Matrix4< ComponentType, StorageBType > MatrixBType;
 
-	static const MatrixAType Multiply(const MatrixAType& lhs, const MatrixBType& rhs) throw()
+	static const MatrixAType Multiply(const MatrixAType& lhs, const MatrixBType& rhs) noexcept
 	{
 		return lhs * MatrixAType(rhs);
 	}

Include/Rocket/Core/Transform.h

@@ -75,13 +75,13 @@ public:
 	void AddPrimitive(const Transforms::Primitive& p);
 
 	/// Return the number of Primitives in this Transform
-	int GetNumPrimitives() const throw();
+	int GetNumPrimitives() const noexcept;
 
 	/// Return the i-th Primitive in this Transform
-	const Transforms::Primitive& GetPrimitive(int i) const throw();
+	const Transforms::Primitive& GetPrimitive(int i) const noexcept;
 
-	Primitives& GetPrimitives() throw() { return primitives; }
-	const Primitives& GetPrimitives() const throw() { return primitives; }
+	Primitives& GetPrimitives() noexcept { return primitives; }
+	const Primitives& GetPrimitives() const noexcept { return primitives; }
 
 protected:
 	void OnReferenceDeactivate()

Include/Rocket/Core/TransformPrimitive.h

@@ -42,21 +42,21 @@ namespace Transforms {
 struct NumericValue
 {
 	/// Non-initializing constructor.
-	NumericValue() throw();
+	NumericValue() noexcept;
 	/// Construct from a float and a Unit.
-	NumericValue(float number, Property::Unit unit) throw();
+	NumericValue(float number, Property::Unit unit) noexcept;
 
 	/// Resolve a numeric property value for an element.
-	float Resolve(Element& e, float base) const throw();
+	float Resolve(Element& e, float base) const noexcept;
 	/// Resolve a numeric property value with the element's width as relative base value.
-	float ResolveWidth(Element& e) const throw();
+	float ResolveWidth(Element& e) const noexcept;
 	/// Resolve a numeric property value with the element's height as relative base value.
-	float ResolveHeight(Element& e) const throw();
+	float ResolveHeight(Element& e) const noexcept;
 	/// Resolve a numeric property value with the element's depth as relative base value.
-	float ResolveDepth(Element& e) const throw();
+	float ResolveDepth(Element& e) const noexcept;
 	/// Returns the numeric value converted to base_unit, or 'number' if no relationship defined.
 	/// Defined for: {Number, Deg, %} -> Rad
-	float ResolveAbsoluteUnit(Property::Unit base_unit) const throw();
+	float ResolveAbsoluteUnit(Property::Unit base_unit) const noexcept;
 
 	float number;
 	Property::Unit unit;
@@ -64,19 +64,19 @@ struct NumericValue
 
 
 template< size_t N >
-struct ResolvedValuesPrimitive
+struct ResolvedPrimitive
 {
-	ResolvedValuesPrimitive(const float* values) throw()
+	ResolvedPrimitive(const float* values) noexcept
 	{
 		for (size_t i = 0; i < N; ++i)
 			this->values[i] = values[i];
 	}
-	ResolvedValuesPrimitive(const NumericValue* values) throw()
+	ResolvedPrimitive(const NumericValue* values) noexcept
 	{
 		for (size_t i = 0; i < N; ++i) 
 			this->values[i] = values[i].number;
 	}
-	ResolvedValuesPrimitive(const NumericValue* values, std::array<Property::Unit, N> base_units) throw()
+	ResolvedPrimitive(const NumericValue* values, std::array<Property::Unit, N> base_units) noexcept
 	{
 		for (size_t i = 0; i < N; ++i)
 			this->values[i] = values[i].ResolveAbsoluteUnit(base_units[i]);
@@ -86,9 +86,9 @@ struct ResolvedValuesPrimitive
 };
 
 template< size_t N >
-struct UnresolvedValuesPrimitive
+struct UnresolvedPrimitive
 {
-	UnresolvedValuesPrimitive(const NumericValue* values) throw()
+	UnresolvedPrimitive(const NumericValue* values) noexcept
 	{
 		memcpy(this->values, values, sizeof(this->values));
 	}
@@ -100,110 +100,110 @@ struct UnresolvedValuesPrimitive
 
 
 
-struct Matrix2D : public ResolvedValuesPrimitive< 6 >
+struct Matrix2D : public ResolvedPrimitive< 6 >
 {
-	Matrix2D(const NumericValue* values) throw() : ResolvedValuesPrimitive(values) { }
+	Matrix2D(const NumericValue* values) noexcept : ResolvedPrimitive(values) { }
 };
 
-struct Matrix3D : public ResolvedValuesPrimitive< 16 >
+struct Matrix3D : public ResolvedPrimitive< 16 >
 {
-	Matrix3D(const Matrix4f& matrix) throw() : ResolvedValuesPrimitive(matrix.data()) { }
-	Matrix3D(const NumericValue* values) throw() : ResolvedValuesPrimitive(values) { }
+	Matrix3D(const Matrix4f& matrix) noexcept : ResolvedPrimitive(matrix.data()) { }
+	Matrix3D(const NumericValue* values) noexcept : ResolvedPrimitive(values) { }
 };
 
-struct TranslateX : public UnresolvedValuesPrimitive< 1 >
+struct TranslateX : public UnresolvedPrimitive< 1 >
 {
-	TranslateX(const NumericValue* values) throw() : UnresolvedValuesPrimitive(values) { }
+	TranslateX(const NumericValue* values) noexcept : UnresolvedPrimitive(values) { }
 };
 
-struct TranslateY : public UnresolvedValuesPrimitive< 1 >
+struct TranslateY : public UnresolvedPrimitive< 1 >
 {
-	TranslateY(const NumericValue* values) throw() : UnresolvedValuesPrimitive(values) { }
+	TranslateY(const NumericValue* values) noexcept : UnresolvedPrimitive(values) { }
 };
 
-struct TranslateZ : public UnresolvedValuesPrimitive< 1 >
+struct TranslateZ : public UnresolvedPrimitive< 1 >
 {
-	TranslateZ(const NumericValue* values) throw() : UnresolvedValuesPrimitive(values) { }
+	TranslateZ(const NumericValue* values) noexcept : UnresolvedPrimitive(values) { }
 };
 
-struct Translate2D : public UnresolvedValuesPrimitive< 2 >
+struct Translate2D : public UnresolvedPrimitive< 2 >
 {
-	Translate2D(const NumericValue* values) throw() : UnresolvedValuesPrimitive(values) { }
+	Translate2D(const NumericValue* values) noexcept : UnresolvedPrimitive(values) { }
 };
 
-struct Translate3D : public UnresolvedValuesPrimitive< 3 >
+struct Translate3D : public UnresolvedPrimitive< 3 >
 {
-	Translate3D(const NumericValue* values) throw() : UnresolvedValuesPrimitive(values) { }
+	Translate3D(const NumericValue* values) noexcept : UnresolvedPrimitive(values) { }
 };
 
-struct ScaleX : public ResolvedValuesPrimitive< 1 >
+struct ScaleX : public ResolvedPrimitive< 1 >
 {
-	ScaleX(const NumericValue* values) throw() : ResolvedValuesPrimitive(values) { }
+	ScaleX(const NumericValue* values) noexcept : ResolvedPrimitive(values) { }
 };
 
-struct ScaleY : public ResolvedValuesPrimitive< 1 >
+struct ScaleY : public ResolvedPrimitive< 1 >
 {
-	ScaleY(const NumericValue* values) throw() : ResolvedValuesPrimitive(values) { }
+	ScaleY(const NumericValue* values) noexcept : ResolvedPrimitive(values) { }
 };
 
-struct ScaleZ : public ResolvedValuesPrimitive< 1 >
+struct ScaleZ : public ResolvedPrimitive< 1 >
 {
-	ScaleZ(const NumericValue* values) throw() : ResolvedValuesPrimitive(values) { }
+	ScaleZ(const NumericValue* values) noexcept : ResolvedPrimitive(values) { }
 };
 
-struct Scale2D : public ResolvedValuesPrimitive< 2 >
+struct Scale2D : public ResolvedPrimitive< 2 >
 {
-	Scale2D(const NumericValue* values) throw() : ResolvedValuesPrimitive(values) { }
+	Scale2D(const NumericValue* values) noexcept : ResolvedPrimitive(values) { }
 };
 
-struct Scale3D : public ResolvedValuesPrimitive< 3 >
+struct Scale3D : public ResolvedPrimitive< 3 >
 {
-	Scale3D(const NumericValue* values) throw() : ResolvedValuesPrimitive(values) { }
+	Scale3D(const NumericValue* values) noexcept : ResolvedPrimitive(values) { }
 };
 
-struct RotateX : public ResolvedValuesPrimitive< 1 >
+struct RotateX : public ResolvedPrimitive< 1 >
 {
-	RotateX(const NumericValue* values) throw() : ResolvedValuesPrimitive(values, { Property::RAD }) { }
+	RotateX(const NumericValue* values) noexcept : ResolvedPrimitive(values, { Property::RAD }) { }
 };
 
-struct RotateY : public ResolvedValuesPrimitive< 1 >
+struct RotateY : public ResolvedPrimitive< 1 >
 {
-	RotateY(const NumericValue* values) throw() : ResolvedValuesPrimitive(values, { Property::RAD }) {}
+	RotateY(const NumericValue* values) noexcept : ResolvedPrimitive(values, { Property::RAD }) {}
 };
 
-struct RotateZ : public ResolvedValuesPrimitive< 1 >
+struct RotateZ : public ResolvedPrimitive< 1 >
 {
-	RotateZ(const NumericValue* values) throw() : ResolvedValuesPrimitive(values, { Property::RAD }) { }
+	RotateZ(const NumericValue* values) noexcept : ResolvedPrimitive(values, { Property::RAD }) { }
 };
 
-struct Rotate2D : public ResolvedValuesPrimitive< 1 >
+struct Rotate2D : public ResolvedPrimitive< 1 >
 {
-	Rotate2D(const NumericValue* values) throw() : ResolvedValuesPrimitive(values, { Property::RAD }) { }
+	Rotate2D(const NumericValue* values) noexcept : ResolvedPrimitive(values, { Property::RAD }) { }
 };
 
-struct Rotate3D : public ResolvedValuesPrimitive< 4 >
+struct Rotate3D : public ResolvedPrimitive< 4 >
 {
-	Rotate3D(const NumericValue* values) throw() : ResolvedValuesPrimitive(values, { Property::NUMBER, Property::NUMBER, Property::NUMBER, Property::RAD }) { }
+	Rotate3D(const NumericValue* values) noexcept : ResolvedPrimitive(values, { Property::NUMBER, Property::NUMBER, Property::NUMBER, Property::RAD }) { }
 };
 
-struct SkewX : public ResolvedValuesPrimitive< 1 >
+struct SkewX : public ResolvedPrimitive< 1 >
 {
-	SkewX(const NumericValue* values) throw() : ResolvedValuesPrimitive(values, { Property::RAD }) { }
+	SkewX(const NumericValue* values) noexcept : ResolvedPrimitive(values, { Property::RAD }) { }
 };
 
-struct SkewY : public ResolvedValuesPrimitive< 1 >
+struct SkewY : public ResolvedPrimitive< 1 >
 {
-	SkewY(const NumericValue* values) throw() : ResolvedValuesPrimitive(values, { Property::RAD }) { }
+	SkewY(const NumericValue* values) noexcept : ResolvedPrimitive(values, { Property::RAD }) { }
 };
 
-struct Skew2D : public ResolvedValuesPrimitive< 2 >
+struct Skew2D : public ResolvedPrimitive< 2 >
 {
-	Skew2D(const NumericValue* values) throw() : ResolvedValuesPrimitive(values, { Property::RAD, Property::RAD }) { }
+	Skew2D(const NumericValue* values) noexcept : ResolvedPrimitive(values, { Property::RAD, Property::RAD }) { }
 };
 
-struct Perspective : public UnresolvedValuesPrimitive< 1 >
+struct Perspective : public UnresolvedPrimitive< 1 >
 {
-	Perspective(const NumericValue* values) throw() : UnresolvedValuesPrimitive(values) { }
+	Perspective(const NumericValue* values) noexcept : UnresolvedPrimitive(values) { }
 };
 
 
@@ -230,14 +230,14 @@ struct Primitive
 {
 	PrimitiveVariant primitive;
 
-	bool ResolveTransform(Matrix4f& m, Element& e) const throw();
-	bool ResolvePerspective(float &p, Element& e) const throw();
+	bool ResolveTransform(Matrix4f& m, Element& e) const noexcept;
+	bool ResolvePerspective(float &p, Element& e) const noexcept;
 	
 	// Promote units to basic types which can be interpolated, that is, convert 'length -> pixel' for unresolved primitives.
-	bool ResolveUnits(Element& e) throw();
+	bool ResolveUnits(Element& e) noexcept;
 
-	bool InterpolateWith(const Primitive& other, float alpha) throw();
-	void SetIdentity() throw();
+	bool InterpolateWith(const Primitive& other, float alpha) noexcept;
+	void SetIdentity() noexcept;
 };
 
 

Include/Rocket/Core/TransformState.h

@@ -46,16 +46,16 @@ public:
 	struct Perspective
 	{
 		/// Calculates the projection matrix.
-		Matrix4f GetProjection() const throw();
+		Matrix4f GetProjection() const noexcept;
 
 		/// Calculates the clip space coordinates ([-1; 1]³) of a 3D vertex in world space.
 		/// @param[in] point The point in world space coordinates.
 		/// @return The clip space coordinates of the point.
-		Vector3f Project(const Vector3f &point) const throw();
+		Vector3f Project(const Vector3f &point) const noexcept;
 		/// Calculates the world space coordinates of a 3D vertex in clip space ([-1; 1]³).
 		/// @param[in] point The point in clip space coordinates.
 		/// @return The world space coordinates of the point.
-		Vector3f Unproject(const Vector3f &point) const throw();
+		Vector3f Unproject(const Vector3f &point) const noexcept;
 	
 		float		distance;	// The CSS `perspective:' value
 		Vector2i	view_size;
@@ -65,16 +65,16 @@ public:
 	struct LocalPerspective
 	{
 		/// Calculates the projection matrix.
-		Matrix4f GetProjection() const throw();
+		Matrix4f GetProjection() const noexcept;
 
 		/// Calculates the clip space coordinates ([-1; 1]³) of a 3D vertex in world space.
 		/// @param[in] point The point in world space coordinates.
 		/// @return The clip space coordinates of the point.
-		Vector3f Project(const Vector3f &point) const throw();
+		Vector3f Project(const Vector3f &point) const noexcept;
 		/// Calculates the world space coordinates of a 3D vertex in clip space ([-1; 1]³).
 		/// @param[in] point The point in clip space coordinates.
 		/// @return The world space coordinates of the point.
-		Vector3f Unproject(const Vector3f &point) const throw();
+		Vector3f Unproject(const Vector3f &point) const noexcept;
 
 		float		distance;	// The CSS `perspective:' value
 		Vector2i	view_size;
@@ -83,36 +83,36 @@ public:
 	TransformState();
 
 	/// Stores a new perspective value
-	void SetPerspective(const Perspective *perspective) throw();
+	void SetPerspective(const Perspective *perspective) noexcept;
 	/// Returns the perspective value
-	bool GetPerspective(Perspective *perspective) const throw();
+	bool GetPerspective(Perspective *perspective) const noexcept;
 
 	/// Stores a new local perspective value
-	void SetLocalPerspective(const LocalPerspective *local_perspective) throw();
+	void SetLocalPerspective(const LocalPerspective *local_perspective) noexcept;
 	/// Returns the local perspective value
-	bool GetLocalPerspective(LocalPerspective *local_perspective) const throw();
+	bool GetLocalPerspective(LocalPerspective *local_perspective) const noexcept;
 
 	/// Stores a new transform matrix
-	void SetTransform(const Matrix4f *transform) throw();
+	void SetTransform(const Matrix4f *transform) noexcept;
 	/// Returns the stored transform matrix
-	bool GetTransform(Matrix4f *transform) const throw();
+	bool GetTransform(Matrix4f *transform) const noexcept;
 
 	/// Stores a new recursive parent transform.
-	void SetParentRecursiveTransform(const Matrix4f *parent_recursive_transform) throw();
+	void SetParentRecursiveTransform(const Matrix4f *parent_recursive_transform) noexcept;
 	/// Returns the stored recursive parent transform matrix
-	bool GetParentRecursiveTransform(Matrix4f *transform) const throw();
+	bool GetParentRecursiveTransform(Matrix4f *transform) const noexcept;
 
 	/// Transforms a 3D point by the `parent transform' and `transform' matrices stored in this TransformState.
 	/// @param[in] point The point in world space coordinates.
 	/// @return The transformed point in world space coordinates.
-	Vector3f Transform(const Vector3f &point) const throw();
+	Vector3f Transform(const Vector3f &point) const noexcept;
 	/// Transforms a 3D point by the inverse `parent transform' and `transform' matrices stored in this TransformState.
 	/// @param[in] point The point in world space coordinates.
 	/// @return The transformed point in world space coordinates.
-	Vector3f Untransform(const Vector3f &point) const throw();
+	Vector3f Untransform(const Vector3f &point) const noexcept;
 
 	/// Returns the parent's recursive transform multiplied by this transform.
-	bool GetRecursiveTransform(Matrix4f *recursive_transform) const throw();
+	bool GetRecursiveTransform(Matrix4f *recursive_transform) const noexcept;
 
 private:
 	// Flags for stored values

Include/Rocket/Core/ViewState.h

@@ -46,22 +46,22 @@ public:
 	ViewState();
 
 	/// Stores a new projection matrix
-	void SetProjection(const Matrix4f *projection) throw();
+	void SetProjection(const Matrix4f *projection) noexcept;
 
 	/// Stores a new view matrix
-	void SetView(const Matrix4f *view) throw();
+	void SetView(const Matrix4f *view) noexcept;
 
 	/// Retrieves the cancellation matrix (projection * view)⁻¹
-	bool GetProjectionViewInv(Matrix4f& projection_view_inv) const throw();
+	bool GetProjectionViewInv(Matrix4f& projection_view_inv) const noexcept;
 
 	/// Calculates the clip space coordinates ([-1; 1]³) of a 3D vertex in world space.
 	/// @param[in] point The point in world space coordinates.
 	/// @return The clip space coordinates of the point.
-	Vector3f Project(const Vector3f &point) const throw();
+	Vector3f Project(const Vector3f &point) const noexcept;
 	/// Calculates the world space coordinates of a 3D vertex in clip space ([-1; 1]³).
 	/// @param[in] point The point in clip space coordinates.
 	/// @return The world space coordinates of the point.
-	Vector3f Unproject(const Vector3f &point) const throw();
+	Vector3f Unproject(const Vector3f &point) const noexcept;
 
 private:
 	// Flags for stored values
@@ -77,7 +77,7 @@ private:
 
 	// Cached values
 	mutable Matrix4f projection_view_inv;
-	void UpdateProjectionViewInv() const throw();
+	void UpdateProjectionViewInv() const noexcept;
 };
 
 }

Source/Core/Context.cpp

@@ -141,7 +141,7 @@ const Vector2i& Context::GetDimensions() const
 
 
 // Returns the current state of the view.
-const ViewState& Context::GetViewState() const throw()
+const ViewState& Context::GetViewState() const noexcept
 {
 	return view_state;
 }

Source/Core/Element.cpp

@@ -700,7 +700,7 @@ const Property *Element::GetTransformOriginZ()
 }
 
 // Returns this element's TransformState
-const TransformState *Element::GetTransformState() const throw()
+const TransformState *Element::GetTransformState() const noexcept
 {
 	return transform_state.get();
 }
@@ -710,7 +710,7 @@ void Element::GetEffectiveTransformState(
 	const TransformState **local_perspective,
 	const TransformState **perspective,
 	const TransformState **transform
-) throw()
+) noexcept
 {
 	UpdateTransformState();
 
@@ -771,7 +771,7 @@ void Element::GetEffectiveTransformState(
 }
 
 // Project a 2D point in pixel coordinates onto the element's plane.
-const Vector2f Element::Project(const Vector2f& point) throw()
+const Vector2f Element::Project(const Vector2f& point) noexcept
 {
 	UpdateTransformState();
 

Source/Core/ElementAnimation.cpp

@@ -269,21 +269,26 @@ bool ElementAnimation::AddKey(float time, const Property & property, Element& el
 	if (property.unit != property_unit)
 		return false;
 
+	keys.push_back({ time, property.value });
+
+	bool result = true;
+
 	if (property.unit == Property::TRANSFORM)
 	{
 		for (auto& primitive : property.value.Get<TransformRef>()->GetPrimitives())
 		{
 			if (!primitive.ResolveUnits(element))
-				return false;
+				result = false;
 		}
 
-		if (!PrepareTransforms(keys, element))
-			return false;
+		if (result)
+			result = PrepareTransforms(keys, element);
 	}
 
-	keys.push_back({ time, property.value });
+	if (!result)
+		keys.pop_back();
 
-	return true;
+	return result;
 }
 
 Property ElementAnimation::UpdateAndGetProperty(float time)

Source/Core/Transform.cpp

@@ -71,12 +71,12 @@ void Transform::AddPrimitive(const Transforms::Primitive & p)
 	primitives.push_back(p);
 }
 
-int Transform::GetNumPrimitives() const throw() 
+int Transform::GetNumPrimitives() const noexcept 
 {
 	return (int)primitives.size();
 }
 
-const Transforms::Primitive & Transform::GetPrimitive(int i) const throw() 
+const Transforms::Primitive & Transform::GetPrimitive(int i) const noexcept 
 {
 	return primitives[i];
 }

Source/Core/TransformPrimitive.cpp

@@ -33,17 +33,17 @@ namespace Rocket {
 namespace Core {
 namespace Transforms {
 
-NumericValue::NumericValue() throw()
+NumericValue::NumericValue() noexcept
 	: number(), unit(Property::UNKNOWN)
 {
 }
 
-NumericValue::NumericValue(float number, Property::Unit unit) throw()
+NumericValue::NumericValue(float number, Property::Unit unit) noexcept
 	: number(number), unit(unit)
 {
 }
 
-float NumericValue::Resolve(Element& e, float base) const throw()
+float NumericValue::Resolve(Element& e, float base) const noexcept
 {
 	Property prop;
 	prop.value = Variant(number);
@@ -51,26 +51,26 @@ float NumericValue::Resolve(Element& e, float base) const throw()
 	return e.ResolveProperty(&prop, base);
 }
 
-float NumericValue::ResolveWidth(Element& e) const throw()
+float NumericValue::ResolveWidth(Element& e) const noexcept
 {
 	if(unit & (Property::PX | Property::NUMBER)) return number;
 	return Resolve(e, e.GetBox().GetSize().x);
 }
 
-float NumericValue::ResolveHeight(Element& e) const throw()
+float NumericValue::ResolveHeight(Element& e) const noexcept
 {
 	if (unit & (Property::PX | Property::NUMBER)) return number;
 	return Resolve(e, e.GetBox().GetSize().y);
 }
 
-float NumericValue::ResolveDepth(Element& e) const throw()
+float NumericValue::ResolveDepth(Element& e) const noexcept
 {
 	if (unit & (Property::PX | Property::NUMBER)) return number;
 	Vector2f size = e.GetBox().GetSize();
 	return Resolve(e, Math::Max(size.x, size.y));
 }
 
-float NumericValue::ResolveAbsoluteUnit(Property::Unit base_unit) const throw()
+float NumericValue::ResolveAbsoluteUnit(Property::Unit base_unit) const noexcept
 {
 	switch (base_unit)
 	{
@@ -256,13 +256,13 @@ struct ResolveTransformVisitor
 struct SetIdentityVisitor
 {
 	template <size_t N>
-	void operator()(ResolvedValuesPrimitive<N>& p)
+	void operator()(ResolvedPrimitive<N>& p)
 	{
 		for (auto& value : p.values)
 			value = 0.0f;
 	}
 	template <size_t N>
-	void operator()(UnresolvedValuesPrimitive<N>& p)
+	void operator()(UnresolvedPrimitive<N>& p)
 	{
 		for (auto& value : p.values)
 			value.number = 0.0f;
@@ -300,13 +300,13 @@ struct SetIdentityVisitor
 };
 
 
-void Primitive::SetIdentity() throw()
+void Primitive::SetIdentity() noexcept
 {
 	std::visit(SetIdentityVisitor{}, primitive);
 }
 
 
-bool Primitive::ResolveTransform(Matrix4f & m, Element & e) const throw()
+bool Primitive::ResolveTransform(Matrix4f & m, Element & e) const noexcept
 {
 	ResolveTransformVisitor visitor{ m, e };
 
@@ -315,7 +315,7 @@ bool Primitive::ResolveTransform(Matrix4f & m, Element & e) const throw()
 	return result;
 }
 
-bool Primitive::ResolvePerspective(float & p, Element & e) const throw()
+bool Primitive::ResolvePerspective(float & p, Element & e) const noexcept
 {
 	bool result = false;
 
@@ -336,13 +336,13 @@ struct InterpolateVisitor
 	float alpha;
 
 	template <size_t N>
-	void Interpolate(ResolvedValuesPrimitive<N>& p0, const ResolvedValuesPrimitive<N>& p1)
+	void Interpolate(ResolvedPrimitive<N>& p0, const ResolvedPrimitive<N>& p1)
 	{
 		for (size_t i = 0; i < N; i++)
 			p0.values[i] = p0.values[i] * (1.0f - alpha) + p1.values[i] * alpha;
 	}
 	template <size_t N>
-	void Interpolate(UnresolvedValuesPrimitive<N>& p0, const UnresolvedValuesPrimitive<N>& p1)
+	void Interpolate(UnresolvedPrimitive<N>& p0, const UnresolvedPrimitive<N>& p1)
 	{
 		// Assumes that the underlying units have been resolved (e.g. to pixels)
 		for (size_t i = 0; i < N; i++)
@@ -361,7 +361,7 @@ struct InterpolateVisitor
 	}
 };
 
-bool Primitive::InterpolateWith(const Primitive & other, float alpha) throw()
+bool Primitive::InterpolateWith(const Primitive & other, float alpha) noexcept
 {
 	if (primitive.index() != other.primitive.index())
 		return false;
@@ -405,7 +405,7 @@ struct ResolveUnitsVisitor
 		return true;
 	}
 	template <size_t N>
-	bool operator()(ResolvedValuesPrimitive<N>& p)
+	bool operator()(ResolvedPrimitive<N>& p)
 	{
 		// No conversion needed for resolved transforms
 		return true;
@@ -418,7 +418,7 @@ struct ResolveUnitsVisitor
 };
 
 
-bool Primitive::ResolveUnits(Element & e) throw()
+bool Primitive::ResolveUnits(Element & e) noexcept
 {
 	return std::visit(ResolveUnitsVisitor{ e }, primitive);
 }

Source/Core/TransformState.cpp

@@ -32,7 +32,7 @@
 namespace Rocket {
 namespace Core {
 
-Matrix4f TransformState::Perspective::GetProjection() const throw()
+Matrix4f TransformState::Perspective::GetProjection() const noexcept
 {
 	float depth = (float)Math::Max(view_size.x, view_size.y);
 
@@ -76,7 +76,7 @@ Matrix4f TransformState::Perspective::GetProjection() const throw()
 	}
 }
 
-Vector3f TransformState::Perspective::Project(const Vector3f &point) const throw()
+Vector3f TransformState::Perspective::Project(const Vector3f &point) const noexcept
 {
 	if (distance < 0)
 	{
@@ -88,7 +88,7 @@ Vector3f TransformState::Perspective::Project(const Vector3f &point) const throw
 	}
 }
 
-Vector3f TransformState::Perspective::Unproject(const Vector3f &point) const throw()
+Vector3f TransformState::Perspective::Unproject(const Vector3f &point) const noexcept
 {
 	if (distance < 0)
 	{
@@ -102,7 +102,7 @@ Vector3f TransformState::Perspective::Unproject(const Vector3f &point) const thr
 	}
 }
 
-Matrix4f TransformState::LocalPerspective::GetProjection() const throw()
+Matrix4f TransformState::LocalPerspective::GetProjection() const noexcept
 {
 	float depth = (float)Math::Max(view_size.x, view_size.y);
 
@@ -142,7 +142,7 @@ Matrix4f TransformState::LocalPerspective::GetProjection() const throw()
 	}
 }
 
-Vector3f TransformState::LocalPerspective::Project(const Vector3f &point) const throw()
+Vector3f TransformState::LocalPerspective::Project(const Vector3f &point) const noexcept
 {
 	if (distance < 0)
 	{
@@ -154,7 +154,7 @@ Vector3f TransformState::LocalPerspective::Project(const Vector3f &point) const
 	}
 }
 
-Vector3f TransformState::LocalPerspective::Unproject(const Vector3f &point) const throw()
+Vector3f TransformState::LocalPerspective::Unproject(const Vector3f &point) const noexcept
 {
 	if (distance < 0)
 	{
@@ -174,7 +174,7 @@ TransformState::TransformState()
 {
 }
 
-void TransformState::SetPerspective(const Perspective *perspective) throw()
+void TransformState::SetPerspective(const Perspective *perspective) noexcept
 {
 	if (perspective)
 	{
@@ -186,7 +186,7 @@ void TransformState::SetPerspective(const Perspective *perspective) throw()
 	have_perspective = perspective != 0;
 }
 
-bool TransformState::GetPerspective(Perspective *perspective) const throw()
+bool TransformState::GetPerspective(Perspective *perspective) const noexcept
 {
 	if (have_perspective && perspective)
 	{
@@ -198,7 +198,7 @@ bool TransformState::GetPerspective(Perspective *perspective) const throw()
 	return have_perspective;
 }
 
-void TransformState::SetLocalPerspective(const LocalPerspective *local_perspective) throw()
+void TransformState::SetLocalPerspective(const LocalPerspective *local_perspective) noexcept
 {
 	if (local_perspective)
 	{
@@ -209,7 +209,7 @@ void TransformState::SetLocalPerspective(const LocalPerspective *local_perspecti
 	have_local_perspective = local_perspective != 0;
 }
 
-bool TransformState::GetLocalPerspective(LocalPerspective *local_perspective) const throw()
+bool TransformState::GetLocalPerspective(LocalPerspective *local_perspective) const noexcept
 {
 	if (have_local_perspective && local_perspective)
 	{
@@ -220,7 +220,7 @@ bool TransformState::GetLocalPerspective(LocalPerspective *local_perspective) co
 	return have_local_perspective;
 }
 
-void TransformState::SetTransform(const Matrix4f *transform) throw()
+void TransformState::SetTransform(const Matrix4f *transform) noexcept
 {
 	if (transform)
 	{
@@ -230,7 +230,7 @@ void TransformState::SetTransform(const Matrix4f *transform) throw()
 	have_transform = transform != 0;
 }
 
-bool TransformState::GetTransform(Matrix4f *transform) const throw()
+bool TransformState::GetTransform(Matrix4f *transform) const noexcept
 {
 	if (have_transform)
 	{
@@ -247,7 +247,7 @@ bool TransformState::GetTransform(Matrix4f *transform) const throw()
 	}
 }
 
-void TransformState::SetParentRecursiveTransform(const Matrix4f *parent_recursive_transform) throw()
+void TransformState::SetParentRecursiveTransform(const Matrix4f *parent_recursive_transform) noexcept
 {
 	if (parent_recursive_transform)
 	{
@@ -257,7 +257,7 @@ void TransformState::SetParentRecursiveTransform(const Matrix4f *parent_recursiv
 	have_parent_recursive_transform = parent_recursive_transform != 0;
 }
 
-bool TransformState::GetParentRecursiveTransform(Matrix4f *transform) const throw()
+bool TransformState::GetParentRecursiveTransform(Matrix4f *transform) const noexcept
 {
 	if (have_parent_recursive_transform)
 	{
@@ -274,7 +274,7 @@ bool TransformState::GetParentRecursiveTransform(Matrix4f *transform) const thro
 	}
 }
 
-Vector3f TransformState::Transform(const Vector3f &point) const throw()
+Vector3f TransformState::Transform(const Vector3f &point) const noexcept
 {
 	if (have_parent_recursive_transform && have_transform)
 	{
@@ -294,7 +294,7 @@ Vector3f TransformState::Transform(const Vector3f &point) const throw()
 	}
 }
 
-Vector3f TransformState::Untransform(const Vector3f &point) const throw()
+Vector3f TransformState::Untransform(const Vector3f &point) const noexcept
 {
 	Matrix4f transform_inv;
 
@@ -321,7 +321,7 @@ Vector3f TransformState::Untransform(const Vector3f &point) const throw()
 	return transform_inv * point;
 }
 
-bool TransformState::GetRecursiveTransform(Matrix4f *recursive_transform) const throw()
+bool TransformState::GetRecursiveTransform(Matrix4f *recursive_transform) const noexcept
 {
 	if (recursive_transform)
 	{

Source/Core/ViewState.cpp

@@ -38,7 +38,7 @@ ViewState::ViewState()
 {
 }
 
-void ViewState::SetProjection(const Matrix4f *projection) throw()
+void ViewState::SetProjection(const Matrix4f *projection) noexcept
 {
 	if (projection)
 	{
@@ -49,7 +49,7 @@ void ViewState::SetProjection(const Matrix4f *projection) throw()
 	projection_view_inv_dirty = true;
 }
 
-void ViewState::SetView(const Matrix4f *view) throw()
+void ViewState::SetView(const Matrix4f *view) noexcept
 {
 	if (view)
 	{
@@ -60,7 +60,7 @@ void ViewState::SetView(const Matrix4f *view) throw()
 	projection_view_inv_dirty = true;
 }
 
-bool ViewState::GetProjectionViewInv(Matrix4f& projection_view_inv) const throw()
+bool ViewState::GetProjectionViewInv(Matrix4f& projection_view_inv) const noexcept
 {
 	if (have_projection || have_view)
 	{
@@ -79,7 +79,7 @@ bool ViewState::GetProjectionViewInv(Matrix4f& projection_view_inv) const throw(
 	}
 }
 
-Vector3f ViewState::Project(const Vector3f &point) const throw()
+Vector3f ViewState::Project(const Vector3f &point) const noexcept
 {
 	if (have_projection && have_view)
 	{
@@ -99,7 +99,7 @@ Vector3f ViewState::Project(const Vector3f &point) const throw()
 	}
 }
 
-Vector3f ViewState::Unproject(const Vector3f &point) const throw()
+Vector3f ViewState::Unproject(const Vector3f &point) const noexcept
 {
 	if (have_projection || have_view)
 	{
@@ -116,7 +116,7 @@ Vector3f ViewState::Unproject(const Vector3f &point) const throw()
 	}
 }
 
-void ViewState::UpdateProjectionViewInv() const throw()
+void ViewState::UpdateProjectionViewInv() const noexcept
 {
 	ROCKET_ASSERT(projection_view_inv_dirty);