third_party/mathfu-1.1.0/include/mathfu/internal/vector_3_simd.h - external/github.com/GPUOpen-LibrariesAndSDKs/VulkanMemoryAllocator - Git at Google

 /*
 * Copyright 2014 Google Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 #ifndef MATHFU_VECTOR_3_SIMD_H_
 #define MATHFU_VECTOR_3_SIMD_H_

 #include "mathfu/internal/vector_3.h"
 #include "mathfu/utilities.h"

 #include <math.h>

 #ifdef MATHFU_COMPILE_WITH_SIMD
 #include "vectorial/simd4f.h"
 #endif

 /// @file mathfu/internal/vector_3_simd.h MathFu Vector<T, 3> Specialization
 /// @brief 3-dimensional specialization of mathfu::Vector for SIMD optimized
 /// builds.
 /// @see mathfu::Vector

 /// @cond MATHFU_INTERNAL
 /// Add macros to account for both the case where the vector is stored as a
 /// simd intrinsic using 4 elements or as 3 values of type T.
 /// MATHFU_VECTOR3_STORE3/MATHFU_VECTOR3_LOAD3 are additional operations used
 /// to load/store the non simd values from and to simd datatypes. If intrinsics
 /// are used these amount to essentially noops. MATHFU_VECTOR3_INIT3 either
 /// creates a simd datatype if the intrinsic is used or sets the T values if
 /// not.
 #ifdef MATHFU_COMPILE_WITH_PADDING
 #define MATHFU_VECTOR3_STORE3(simd_to_store, data) \
   { (data).simd = simd_to_store; }
 #define MATHFU_VECTOR3_LOAD3(data) (data).simd
 #define MATHFU_VECTOR3_INIT3(data, v1, v2, v3) \
   { (data).simd = simd4f_create(v1, v2, v3, 0); }
 #else
 #define MATHFU_VECTOR3_STORE3(simd_to_store, data) \
   { simd4f_ustore3(simd_to_store, (data).data_); }
 #define MATHFU_VECTOR3_LOAD3(data) simd4f_uload3((data).data_)
 #define MATHFU_VECTOR3_INIT3(data, v1, v2, v3) \
   {                                            \
     (data).data_[0] = v1;                      \
     (data).data_[1] = v2;                      \
     (data).data_[2] = v3;                      \
   }
 #endif  // MATHFU_COMPILE_WITH_PADDING
 /// @endcond

 namespace mathfu {

 #ifdef MATHFU_COMPILE_WITH_SIMD
 /// @cond MATHFU_INTERNAL
 // This class should remain plain old data.
 template <>
 class Vector<float, 3> {
  public:
   typedef float Scalar;

   inline Vector() {}

   inline Vector(const Vector<float, 3>& v) {
 #ifdef MATHFU_COMPILE_WITH_PADDING
     simd = v.simd;
 #else
     MATHFU_VECTOR3_INIT3(*this, v[0], v[1], v[2]);
 #endif  // MATHFU_COMPILE_WITH_PADDING
   }

   explicit inline Vector(const Vector<int, 3>& v) {
     MATHFU_VECTOR3_INIT3(*this, static_cast<float>(v[0]),
                          static_cast<float>(v[1]), static_cast<float>(v[2]));
   }

   inline Vector(const simd4f& v) { MATHFU_VECTOR3_STORE3(v, *this); }

   explicit inline Vector(const float& s) {
     MATHFU_VECTOR3_INIT3(*this, s, s, s);
   }

   inline Vector(const float& v1, const float& v2, const float& v3) {
     MATHFU_VECTOR3_INIT3(*this, v1, v2, v3);
   }

   inline Vector(const Vector<float, 2>& v12, const float& v3) {
     MATHFU_VECTOR3_INIT3(*this, v12[0], v12[1], v3);
   }

   explicit inline Vector(const float* v) {
 #ifdef MATHFU_COMPILE_WITH_PADDING
     simd = simd4f_uload3(v);
 #else
     MATHFU_VECTOR3_INIT3(*this, v[0], v[1], v[2]);
 #endif  // MATHFU_COMPILE_WITH_PADDING
   }

   explicit inline Vector(const VectorPacked<float, 3>& vector) {
 #ifdef MATHFU_COMPILE_WITH_PADDING
     simd = simd4f_uload3(vector.data);
 #else
     MATHFU_VECTOR3_INIT3(*this, vector.data[0], vector.data[1], vector.data[2]);
 #endif  // MATHFU_COMPILE_WITH_PADDING
   }

   inline float& operator()(const int i) { return data_[i]; }

   inline const float& operator()(const int i) const { return data_[i]; }

   inline float& operator[](const int i) { return data_[i]; }

   inline const float& operator[](const int i) const { return data_[i]; }

   /// GLSL style multi-component accessors.
   inline Vector<float, 2> xy() { return Vector<float, 2>(x, y); }
   inline const Vector<float, 2> xy() const { return Vector<float, 2>(x, y); }

   inline void Pack(VectorPacked<float, 3>* const vector) const {
 #ifdef MATHFU_COMPILE_WITH_PADDING
     simd4f_ustore3(simd, vector->data);
 #else
     vector->data[0] = data_[0];
     vector->data[1] = data_[1];
     vector->data[2] = data_[2];
 #endif  // MATHFU_COMPILE_WITH_PADDING
   }

   inline Vector<float, 3> operator-() const {
     return Vector<float, 3>(
         simd4f_sub(simd4f_zero(), MATHFU_VECTOR3_LOAD3(*this)));
   }

   inline Vector<float, 3> operator*(const Vector<float, 3>& v) const {
     return Vector<float, 3>(
         simd4f_mul(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v)));
   }

   inline Vector<float, 3> operator/(const Vector<float, 3>& v) const {
     return Vector<float, 3>(
         simd4f_div(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v)));
   }

   inline Vector<float, 3> operator+(const Vector<float, 3>& v) const {
     return Vector<float, 3>(
         simd4f_add(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v)));
   }

   inline Vector<float, 3> operator-(const Vector<float, 3>& v) const {
     return Vector<float, 3>(
         simd4f_sub(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v)));
   }

   inline Vector<float, 3> operator*(const float& s) const {
     return Vector<float, 3>(
         simd4f_mul(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s)));
   }

   inline Vector<float, 3> operator/(const float& s) const {
     return Vector<float, 3>(
         simd4f_div(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s)));
   }

   inline Vector<float, 3> operator+(const float& s) const {
     return Vector<float, 3>(
         simd4f_add(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s)));
   }

   inline Vector<float, 3> operator-(const float& s) const {
     return Vector<float, 3>(
         simd4f_sub(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s)));
   }

   inline Vector<float, 3>& operator*=(const Vector<float, 3>& v) {
     *this = simd4f_mul(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v));
     return *this;
   }

   inline Vector<float, 3>& operator/=(const Vector<float, 3>& v) {
     *this = simd4f_div(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v));
     return *this;
   }

   inline Vector<float, 3>& operator+=(const Vector<float, 3>& v) {
     *this = simd4f_add(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v));
     return *this;
   }

   inline Vector<float, 3>& operator-=(const Vector<float, 3>& v) {
     *this = simd4f_sub(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v));
     return *this;
   }

   inline Vector<float, 3>& operator*=(const float& s) {
     *this = simd4f_mul(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s));
     return *this;
   }

   inline Vector<float, 3>& operator/=(const float& s) {
     *this = simd4f_div(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s));
     return *this;
   }

   inline Vector<float, 3>& operator+=(const float& s) {
     *this = simd4f_add(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s));
     return *this;
   }

   inline Vector<float, 3>& operator-=(const float& s) {
     *this = simd4f_sub(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s));
     return *this;
   }

   inline bool operator==(const Vector<float, 3>& v) const {
     for (int i = 0; i < 3; ++i) {
       if ((*this)[i] != v[i]) return false;
     }
     return true;
   }

   inline bool operator!=(const Vector<float, 3>& v) const {
     return !operator==(v);
   }

   inline float LengthSquared() const {
     return simd4f_dot3_scalar(MATHFU_VECTOR3_LOAD3(*this),
                               MATHFU_VECTOR3_LOAD3(*this));
   }

   inline float Length() const {
     return simd4f_get_x(simd4f_length3(MATHFU_VECTOR3_LOAD3(*this)));
   }

   inline float Normalize() {
     const float length = Length();
     *this = simd4f_mul(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(1 / length));
     return length;
   }

   inline Vector<float, 3> Normalized() const {
     return Vector<float, 3>(simd4f_normalize3(MATHFU_VECTOR3_LOAD3(*this)));
   }

   template <typename CompatibleT>
   static inline Vector<float, 3> FromType(const CompatibleT& compatible) {
     return FromTypeHelper<float, 3, CompatibleT>(compatible);
   }

   template <typename CompatibleT>
   static inline CompatibleT ToType(const Vector<float, 3>& v) {
     return ToTypeHelper<float, 3, CompatibleT>(v);
   }

   static inline float DotProduct(const Vector<float, 3>& v1,
                                  const Vector<float, 3>& v2) {
     return simd4f_dot3_scalar(MATHFU_VECTOR3_LOAD3(v1),
                               MATHFU_VECTOR3_LOAD3(v2));
   }

   static inline Vector<float, 3> CrossProduct(const Vector<float, 3>& v1,
                                               const Vector<float, 3>& v2) {
     return Vector<float, 3>(
         simd4f_cross3(MATHFU_VECTOR3_LOAD3(v1), MATHFU_VECTOR3_LOAD3(v2)));
   }

   static inline Vector<float, 3> HadamardProduct(const Vector<float, 3>& v1,
                                                  const Vector<float, 3>& v2) {
     return Vector<float, 3>(
         simd4f_mul(MATHFU_VECTOR3_LOAD3(v1), MATHFU_VECTOR3_LOAD3(v2)));
   }

   static inline Vector<float, 3> Lerp(const Vector<float, 3>& v1,
                                       const Vector<float, 3>& v2,
                                       float percent) {
     const Vector<float, 3> percentv(percent);
     const Vector<float, 3> one(1.0f);
     const Vector<float, 3> one_minus_percent = one - percentv;
     return Vector<float, 3>(simd4f_add(
         simd4f_mul(MATHFU_VECTOR3_LOAD3(one_minus_percent),
                    MATHFU_VECTOR3_LOAD3(v1)),
         simd4f_mul(MATHFU_VECTOR3_LOAD3(percentv), MATHFU_VECTOR3_LOAD3(v2))));
   }

   /// Generates a random vector, where the range for each component is
   /// bounded by min and max.
   static inline Vector<float, 3> RandomInRange(const Vector<float, 3>& min,
                                                const Vector<float, 3>& max) {
     return Vector<float, 3>(mathfu::RandomInRange<float>(min[0], max[0]),
                             mathfu::RandomInRange<float>(min[1], max[1]),
                             mathfu::RandomInRange<float>(min[2], max[2]));
   }

   static inline Vector<float, 3> Max(const Vector<float, 3>& v1,
                                      const Vector<float, 3>& v2) {
 #ifdef MATHFU_COMPILE_WITH_PADDING
     return Vector<float, 3>(
         simd4f_max(MATHFU_VECTOR3_LOAD3(v1), MATHFU_VECTOR3_LOAD3(v2)));
 #else
     return Vector<float, 3>(std::max(v1[0], v2[0]), std::max(v1[1], v2[1]),
                             std::max(v1[2], v2[2]));
 #endif  // MATHFU_COMPILE_WITH_PADDING
   }

   static inline Vector<float, 3> Min(const Vector<float, 3>& v1,
                                      const Vector<float, 3>& v2) {
 #ifdef MATHFU_COMPILE_WITH_PADDING
     return Vector<float, 3>(
         simd4f_min(MATHFU_VECTOR3_LOAD3(v1), MATHFU_VECTOR3_LOAD3(v2)));
 #else
     return Vector<float, 3>(std::min(v1[0], v2[0]), std::min(v1[1], v2[1]),
                             std::min(v1[2], v2[2]));
 #endif  // MATHFU_COMPILE_WITH_PADDING
   }

   template <class T, int rows, int cols>
   friend class Matrix;
   template <class T, int d>
   friend class Vector;

   MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE

 #include "mathfu/internal/disable_warnings_begin.h"
   union {
 #ifdef MATHFU_COMPILE_WITH_PADDING
     simd4f simd;
     float data_[4];
 #else
     float data_[3];
 #endif  // MATHFU_COMPILE_WITH_PADDING

     struct {
       float x;
       float y;
       float z;
     };
   };
 #include "mathfu/internal/disable_warnings_end.h"
 };
 /// @endcond
 #endif  // MATHFU_COMPILE_WITH_SIMD

 }  // namespace mathfu

 #endif  // MATHFU_VECTOR_3_SIMD_H_
	/*
	* Copyright 2014 Google Inc. All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	#ifndef MATHFU_VECTOR_3_SIMD_H_
	#define MATHFU_VECTOR_3_SIMD_H_

	#include "mathfu/internal/vector_3.h"
	#include "mathfu/utilities.h"

	#include <math.h>

	#ifdef MATHFU_COMPILE_WITH_SIMD
	#include "vectorial/simd4f.h"
	#endif

	/// @file mathfu/internal/vector_3_simd.h MathFu Vector<T, 3> Specialization
	/// @brief 3-dimensional specialization of mathfu::Vector for SIMD optimized
	/// builds.
	/// @see mathfu::Vector

	/// @cond MATHFU_INTERNAL
	/// Add macros to account for both the case where the vector is stored as a
	/// simd intrinsic using 4 elements or as 3 values of type T.
	/// MATHFU_VECTOR3_STORE3/MATHFU_VECTOR3_LOAD3 are additional operations used
	/// to load/store the non simd values from and to simd datatypes. If intrinsics
	/// are used these amount to essentially noops. MATHFU_VECTOR3_INIT3 either
	/// creates a simd datatype if the intrinsic is used or sets the T values if
	/// not.
	#ifdef MATHFU_COMPILE_WITH_PADDING
	#define MATHFU_VECTOR3_STORE3(simd_to_store, data) \
	{ (data).simd = simd_to_store; }
	#define MATHFU_VECTOR3_LOAD3(data) (data).simd
	#define MATHFU_VECTOR3_INIT3(data, v1, v2, v3) \
	{ (data).simd = simd4f_create(v1, v2, v3, 0); }
	#else
	#define MATHFU_VECTOR3_STORE3(simd_to_store, data) \
	{ simd4f_ustore3(simd_to_store, (data).data_); }
	#define MATHFU_VECTOR3_LOAD3(data) simd4f_uload3((data).data_)
	#define MATHFU_VECTOR3_INIT3(data, v1, v2, v3) \
	{ \
	(data).data_[0] = v1; \
	(data).data_[1] = v2; \
	(data).data_[2] = v3; \
	}
	#endif // MATHFU_COMPILE_WITH_PADDING
	/// @endcond

	namespace mathfu {

	#ifdef MATHFU_COMPILE_WITH_SIMD
	/// @cond MATHFU_INTERNAL
	// This class should remain plain old data.
	template <>
	class Vector<float, 3> {
	public:
	typedef float Scalar;

	inline Vector() {}

	inline Vector(const Vector<float, 3>& v) {
	#ifdef MATHFU_COMPILE_WITH_PADDING
	simd = v.simd;
	#else
	MATHFU_VECTOR3_INIT3(*this, v[0], v[1], v[2]);
	#endif // MATHFU_COMPILE_WITH_PADDING
	}

	explicit inline Vector(const Vector<int, 3>& v) {
	MATHFU_VECTOR3_INIT3(*this, static_cast<float>(v[0]),
	static_cast<float>(v[1]), static_cast<float>(v[2]));
	}

	inline Vector(const simd4f& v) { MATHFU_VECTOR3_STORE3(v, *this); }

	explicit inline Vector(const float& s) {
	MATHFU_VECTOR3_INIT3(*this, s, s, s);
	}

	inline Vector(const float& v1, const float& v2, const float& v3) {
	MATHFU_VECTOR3_INIT3(*this, v1, v2, v3);
	}

	inline Vector(const Vector<float, 2>& v12, const float& v3) {
	MATHFU_VECTOR3_INIT3(*this, v12[0], v12[1], v3);
	}

	explicit inline Vector(const float* v) {
	#ifdef MATHFU_COMPILE_WITH_PADDING
	simd = simd4f_uload3(v);
	#else
	MATHFU_VECTOR3_INIT3(*this, v[0], v[1], v[2]);
	#endif // MATHFU_COMPILE_WITH_PADDING
	}

	explicit inline Vector(const VectorPacked<float, 3>& vector) {
	#ifdef MATHFU_COMPILE_WITH_PADDING
	simd = simd4f_uload3(vector.data);
	#else
	MATHFU_VECTOR3_INIT3(*this, vector.data[0], vector.data[1], vector.data[2]);
	#endif // MATHFU_COMPILE_WITH_PADDING
	}

	inline float& operator()(const int i) { return data_[i]; }

	inline const float& operator()(const int i) const { return data_[i]; }

	inline float& operator[](const int i) { return data_[i]; }

	inline const float& operator[](const int i) const { return data_[i]; }

	/// GLSL style multi-component accessors.
	inline Vector<float, 2> xy() { return Vector<float, 2>(x, y); }
	inline const Vector<float, 2> xy() const { return Vector<float, 2>(x, y); }

	inline void Pack(VectorPacked<float, 3>* const vector) const {
	#ifdef MATHFU_COMPILE_WITH_PADDING
	simd4f_ustore3(simd, vector->data);
	#else
	vector->data[0] = data_[0];
	vector->data[1] = data_[1];
	vector->data[2] = data_[2];
	#endif // MATHFU_COMPILE_WITH_PADDING
	}

	inline Vector<float, 3> operator-() const {
	return Vector<float, 3>(
	simd4f_sub(simd4f_zero(), MATHFU_VECTOR3_LOAD3(*this)));
	}

	inline Vector<float, 3> operator*(const Vector<float, 3>& v) const {
	return Vector<float, 3>(
	simd4f_mul(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v)));
	}

	inline Vector<float, 3> operator/(const Vector<float, 3>& v) const {
	return Vector<float, 3>(
	simd4f_div(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v)));
	}

	inline Vector<float, 3> operator+(const Vector<float, 3>& v) const {
	return Vector<float, 3>(
	simd4f_add(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v)));
	}

	inline Vector<float, 3> operator-(const Vector<float, 3>& v) const {
	return Vector<float, 3>(
	simd4f_sub(MATHFU_VECTOR3_LOAD3(*this), MATHFU_VECTOR3_LOAD3(v)));
	}

	inline Vector<float, 3> operator*(const float& s) const {
	return Vector<float, 3>(
	simd4f_mul(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s)));
	}

	inline Vector<float, 3> operator/(const float& s) const {
	return Vector<float, 3>(
	simd4f_div(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s)));
	}

	inline Vector<float, 3> operator+(const float& s) const {
	return Vector<float, 3>(
	simd4f_add(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s)));
	}

	inline Vector<float, 3> operator-(const float& s) const {
	return Vector<float, 3>(
	simd4f_sub(MATHFU_VECTOR3_LOAD3(*this), simd4f_splat(s)));
	}

	inline Vector<float, 3>& operator*=(const Vector<float, 3>& v) {
	this = simd4f_mul(MATHFU_VECTOR3_LOAD3(this), MATHFU_VECTOR3_LOAD3(v));
	return *this;
	}

	inline Vector<float, 3>& operator/=(const Vector<float, 3>& v) {
	this = simd4f_div(MATHFU_VECTOR3_LOAD3(this), MATHFU_VECTOR3_LOAD3(v));
	return *this;
	}

	inline Vector<float, 3>& operator+=(const Vector<float, 3>& v) {
	this = simd4f_add(MATHFU_VECTOR3_LOAD3(this), MATHFU_VECTOR3_LOAD3(v));
	return *this;
	}

	inline Vector<float, 3>& operator-=(const Vector<float, 3>& v) {
	this = simd4f_sub(MATHFU_VECTOR3_LOAD3(this), MATHFU_VECTOR3_LOAD3(v));
	return *this;
	}

	inline Vector<float, 3>& operator*=(const float& s) {
	this = simd4f_mul(MATHFU_VECTOR3_LOAD3(this), simd4f_splat(s));
	return *this;
	}

	inline Vector<float, 3>& operator/=(const float& s) {
	this = simd4f_div(MATHFU_VECTOR3_LOAD3(this), simd4f_splat(s));
	return *this;
	}

	inline Vector<float, 3>& operator+=(const float& s) {
	this = simd4f_add(MATHFU_VECTOR3_LOAD3(this), simd4f_splat(s));
	return *this;
	}

	inline Vector<float, 3>& operator-=(const float& s) {
	this = simd4f_sub(MATHFU_VECTOR3_LOAD3(this), simd4f_splat(s));
	return *this;
	}

	inline bool operator==(const Vector<float, 3>& v) const {
	for (int i = 0; i < 3; ++i) {
	if ((*this)[i] != v[i]) return false;
	}
	return true;
	}

	inline bool operator!=(const Vector<float, 3>& v) const {
	return !operator==(v);
	}

	inline float LengthSquared() const {
	return simd4f_dot3_scalar(MATHFU_VECTOR3_LOAD3(*this),
	MATHFU_VECTOR3_LOAD3(*this));
	}

	inline float Length() const {
	return simd4f_get_x(simd4f_length3(MATHFU_VECTOR3_LOAD3(*this)));
	}

	inline float Normalize() {
	const float length = Length();
	this = simd4f_mul(MATHFU_VECTOR3_LOAD3(this), simd4f_splat(1 / length));
	return length;
	}

	inline Vector<float, 3> Normalized() const {
	return Vector<float, 3>(simd4f_normalize3(MATHFU_VECTOR3_LOAD3(*this)));
	}

	template <typename CompatibleT>
	static inline Vector<float, 3> FromType(const CompatibleT& compatible) {
	return FromTypeHelper<float, 3, CompatibleT>(compatible);
	}

	template <typename CompatibleT>
	static inline CompatibleT ToType(const Vector<float, 3>& v) {
	return ToTypeHelper<float, 3, CompatibleT>(v);
	}

	static inline float DotProduct(const Vector<float, 3>& v1,
	const Vector<float, 3>& v2) {
	return simd4f_dot3_scalar(MATHFU_VECTOR3_LOAD3(v1),
	MATHFU_VECTOR3_LOAD3(v2));
	}

	static inline Vector<float, 3> CrossProduct(const Vector<float, 3>& v1,
	const Vector<float, 3>& v2) {
	return Vector<float, 3>(
	simd4f_cross3(MATHFU_VECTOR3_LOAD3(v1), MATHFU_VECTOR3_LOAD3(v2)));
	}

	static inline Vector<float, 3> HadamardProduct(const Vector<float, 3>& v1,
	const Vector<float, 3>& v2) {
	return Vector<float, 3>(
	simd4f_mul(MATHFU_VECTOR3_LOAD3(v1), MATHFU_VECTOR3_LOAD3(v2)));
	}

	static inline Vector<float, 3> Lerp(const Vector<float, 3>& v1,
	const Vector<float, 3>& v2,
	float percent) {
	const Vector<float, 3> percentv(percent);
	const Vector<float, 3> one(1.0f);
	const Vector<float, 3> one_minus_percent = one - percentv;
	return Vector<float, 3>(simd4f_add(
	simd4f_mul(MATHFU_VECTOR3_LOAD3(one_minus_percent),
	MATHFU_VECTOR3_LOAD3(v1)),
	simd4f_mul(MATHFU_VECTOR3_LOAD3(percentv), MATHFU_VECTOR3_LOAD3(v2))));
	}

	/// Generates a random vector, where the range for each component is
	/// bounded by min and max.
	static inline Vector<float, 3> RandomInRange(const Vector<float, 3>& min,
	const Vector<float, 3>& max) {
	return Vector<float, 3>(mathfu::RandomInRange<float>(min[0], max[0]),
	mathfu::RandomInRange<float>(min[1], max[1]),
	mathfu::RandomInRange<float>(min[2], max[2]));
	}

	static inline Vector<float, 3> Max(const Vector<float, 3>& v1,
	const Vector<float, 3>& v2) {
	#ifdef MATHFU_COMPILE_WITH_PADDING
	return Vector<float, 3>(
	simd4f_max(MATHFU_VECTOR3_LOAD3(v1), MATHFU_VECTOR3_LOAD3(v2)));
	#else
	return Vector<float, 3>(std::max(v1[0], v2[0]), std::max(v1[1], v2[1]),
	std::max(v1[2], v2[2]));
	#endif // MATHFU_COMPILE_WITH_PADDING
	}

	static inline Vector<float, 3> Min(const Vector<float, 3>& v1,
	const Vector<float, 3>& v2) {
	#ifdef MATHFU_COMPILE_WITH_PADDING
	return Vector<float, 3>(
	simd4f_min(MATHFU_VECTOR3_LOAD3(v1), MATHFU_VECTOR3_LOAD3(v2)));
	#else
	return Vector<float, 3>(std::min(v1[0], v2[0]), std::min(v1[1], v2[1]),
	std::min(v1[2], v2[2]));
	#endif // MATHFU_COMPILE_WITH_PADDING
	}

	template <class T, int rows, int cols>
	friend class Matrix;
	template <class T, int d>
	friend class Vector;

	MATHFU_DEFINE_CLASS_SIMD_AWARE_NEW_DELETE

	#include "mathfu/internal/disable_warnings_begin.h"
	union {
	#ifdef MATHFU_COMPILE_WITH_PADDING
	simd4f simd;
	float data_[4];
	#else
	float data_[3];
	#endif // MATHFU_COMPILE_WITH_PADDING

	struct {
	float x;
	float y;
	float z;
	};
	};
	#include "mathfu/internal/disable_warnings_end.h"
	};
	/// @endcond
	#endif // MATHFU_COMPILE_WITH_SIMD

	} // namespace mathfu

	#endif // MATHFU_VECTOR_3_SIMD_H_