提交更新

src/SDK/include/Geometry.h

@@ -61,6 +61,12 @@ namespace OpenDrive
 		double GetCurvatureFromArc(const double &s);
 		double GetCurvatureFromSprial(const double &s);
 		double GetCurvatureFromPoly3(const double &s);
+
+		const double GetRoadGeoCoordinateHdgFromLine(const double &s)const;
+		const double GetRoadGeoCoordinateHdgFromArc(const double &s)const;
+		const double GetRoadGeoCoordinateHdgFromSpiral(const double &s)const;
+		const double GetRoadGeoCoordinateHdgFromPloy3(const double &s)const;
+
 		//const vector<TurningAttr> GetLaneTurningAttributesFromPloy3(const double & initPosition, const double &lastPosition, double &position, const int &flag)const;
 		~Geometry();
 	public:

src/SDK/include/Lane.h

@@ -28,9 +28,9 @@ namespace OpenDrive
 		void SetType(const char* type);
 		void SetLaneReferenceData(const vector<GeoCoordinatePoint>& vecLaneRefernceData);
 		void SetLaneBoundaryData(const vector<GeoCoordinatePoint>& vecLaneRefernceData);
+		const vector<GeoCoordinatePoint>* GetlaneBoundaryData() const;
 		void SetLaneWidth(LaneWidth *width);
 		const vector<LaneWidth>* GetLaneWidth() const;
-		const double GetLaneWidthValue() const;
 		void SetLink(LaneLink* link);
 		void SetRoadMark(LaneRoadMark *roadMark);
 		const LaneRoadMark* GetLaneRoadMark() const;
@@ -50,7 +50,7 @@ namespace OpenDrive
 		const UserData* GetUserData() const;
 
 		~Lane();
-	public:
+	private:
 		string _id;
 		double _s = 0.0;
 		Height *_height;

src/SDK/include/LaneSection.h

@@ -38,13 +38,14 @@ namespace OpenDrive
 		const NearestDistance GetNeartestRoadandLaneAttributes(const char* laneID, const double &s, const double &t) const;
 		const NearestRoadMark GetNeartestLaneRoadMark(const char* laneID) const;
 		void CalBoundaryData(const char* laneID);
-		const vector<GeoCoordinatePoint>* GetLaneBoundaryData(const char* laneID) const;
+		const vector<GeoCoordinatePoint>* GetlaneBoundaryData(const char* laneID) const;
 		const double GetLaneSpeed(const char* laneID) const;
 		const vector<PosXY>* GetLeftLinePosFromLane(const char* laneID) const;
 		const vector<PosXY>* GetRightLinePosFromLane(const char* laneID) const;
 
 		GeoCoordinatePoint* GetLanePositionBySectionID(const char* laneID) const;
-		
+		const char* GetLaneTypeString(const char* laneID) const;
+
 		~LaneSection();
 	private:
 		map<string, Lane*>* _mapLane;

src/SDK/include/NavinfoGISCoord.h

@@ -23,28 +23,7 @@ public:
 	glm::dvec2 MapXYToLatLon(double x, double y, double lambda0);
 	double ArcLengthOfMeridian(const double &phi);
 	double FootpointLatitude(double y);
-	//{
-	//	double y_, alpha_, beta_, gamma_, delta_, epsilon_, n;
-	//	double result;
-	//	/* Precalculate n (Eq. 10.18) */
-	//	n = (sm_a - sm_b) / (sm_a + sm_b);
-	//	/* Precalculate alpha_ (Eq. 10.22) */
-	//	 /* (Same as alpha in Eq. 10.17) */
-	//	alpha_ = ((sm_a + sm_b) / 2.0) * (1 + (pow(n, 2.0) / 4) + (pow(n, 4.0) / 64));
-	//	/* Precalculate y_ (Eq. 10.23) */
-	//	y_ = y / alpha_;
-	//	/* Precalculate beta_ (Eq. 10.22) */
-	//	beta_ = (3.0 * n / 2.0) + (-27.0 * pow(n, 3.0) / 32.0) + (269.0 * pow(n, 5.0) / 512.0);
-	//	/* Precalculate gamma_ (Eq. 10.22) */
-	//	gamma_ = (21.0 * pow(n, 2.0) / 16.0) + (-55.0 * pow(n, 4.0) / 32.0);
-	//	/* Precalculate delta_ (Eq. 10.22) */
-	//	delta_ = (151.0 * pow(n, 3.0) / 96.0) + (-417.0 * pow(n, 5.0) / 128.0);
-	//	/* Precalculate epsilon_ (Eq. 10.22) */
-	//	epsilon_ = (1097.0 * pow(n, 4.0) / 512.0);
-	//	/* Now calculate the sum of the series (Eq. 10.21) */
-	//	result = y_ + (beta_ * sin(2.0 * y_)) + (gamma_ * sin(4.0 * y_)) + (delta_ * sin(6.0 * y_)) + (epsilon_ * sin(8.0 * y_));
-	//	return result;
-	//}
+
 private:
 	NavinfoGISCoord();
 	~NavinfoGISCoord();

src/SDK/include/Object.h

@@ -13,30 +13,17 @@ namespace OpenDrive
 		Object();
 		Object(const Object & obj3d);
 		Object& operator =(const Object & obj);
-
-		void SetLocationRoadID(const char* name);
-		const char* GetLocationRoadID() const;
-
-		void SetLogicRoadID(const char* name);
-		const char* GetLogicRoadID() const;
-
-		void SetID(const char* name);
-		const char* GetID() const;
 		void SetName(const char* name);
 		const char* GetName() const;
 		void SetType(const char* type);
 		const char* GetType() const;
-		void SetSubType(const ObjSubType &subtype);
-		const ObjSubType GetSubType() const;
 		void SetSValue(double &value);
 		const double GetSValue() const;
 		void SetTValue(double &value);
 		const double GetTValue() const;
-		void PushbackData(const PosXY &vec);
-		vector<PosXY>* GetCoords();
+		void PushbackData(glm::dvec3 vec);
+		vector<glm::dvec3>* GetCoords();
 
-		void SetLengthValue(double &value);
-		const double GetLengthValue() const;
 
 		void SetWidthValue(double &value);
 		const double GetWidthValue() const;
@@ -50,20 +37,17 @@ namespace OpenDrive
 
 		~Object();
 	private:
-		string _locationRoadID;
-		string _logicRoadID;
-		string _id;
+
 		string _name;
 		string _type;
-		ObjSubType _subtype;
 		double _s;
 		double _t;
 		double _width;
 		double _height;
 		double _zOffset;
-		double _length;
-		vector<PosXY> *_vecCoords;
+		vector<glm::dvec3> *_vecCoords;
 		RepeatObj *_repeatObj;
+
 		//<repeat s = "2.73406954883456" length = "79.566455604047" distance = "15" tStart = "-13.3226013033395" tEnd = "-13.3226013033395" widthStart = "5.7990000000000004e+00" widthEnd = "5.7990000000000004e+00" heightStart = "6.6230000000000002e+00" heightEnd = "6.6230000000000002e+00" zOffsetStart = "-3.8850000000000007e-01" zOffsetEnd = "-3.8850000000000007e-01" / >
 	};
 }

src/SDK/include/Road.h

@@ -14,6 +14,7 @@
 #include"LaneOffset.h"
 #include "Object.h"
 #include <string> 
+//#include <io.h>
 #include <stdlib.h>
 #include <iostream>
 #include <fstream>
@@ -43,7 +44,7 @@ namespace OpenDrive
 		const char* GetSucRoad() const;
 		const char* GetPreRoad() const;
 		void PushbackLaneSection(LaneSection *laneSection);
-		LaneSection* GetLaneSection(const char* sectionID);
+		LaneSection* GetSection(const char* sectionID);
 		void PushbackData(Geometry *geo);
 		void PushElevation(Elevation *ele);
 		void PushLaneOffSet(LaneOffset *laneOffset);
@@ -68,7 +69,6 @@ namespace OpenDrive
 		const vector<string> GetLeftLaneIDS(const char* sectionID, const char* laneID)const;
 		const vector<string> GetRightLaneIDS(const char* sectionID, const char* laneID)const;
 		const vector<string> GetAllDrivingLaneIDS(const char* sectionID) const;
-		const vector<string> GetAllLaneIDS(const char* sectionID) const;
 		const vector<string> GetAllSectionIDS() const;
 		const vector<RoadWidth> GetSectionWidthofRoad(const char* sectionID) const;
 		const vector<Position> GetLanePosiontAndDircetions(const char* sectionID, const char* laneID) const;
@@ -76,7 +76,6 @@ namespace OpenDrive
 		const NearestDistance GetNeartestRoadandLaneAttributes(const char* sectionID, const char* laneID, const double &s, const double &t) const;
 		const NearestRoadMark GetNeartestLaneRoadMark(const char* sectionID, const char* laneID) const;
 		OdrInfo GetNearest(const double & longitude, const double &latitude,double &distance);
-		const bool GetNearestZValue(const double & longitude, const double &latitude, double &distance, double &zValue);
 		bool  IsNearestRoad(const double & x, const double &y, const double &distance);
 		vector<GeoCoordinatePoint> GetDataFromLine(const double &s, const double &sReal, const double &x, const double &y, const double &hdg, const double &length);
 		vector<GeoCoordinatePoint> GetDataFromArc(const double &s, const double &sReal, const double &x, const double &y, const double &hdg, const double &length, const double &curvature);
@@ -101,11 +100,18 @@ namespace OpenDrive
 		vector<GeoCoordinatePoint>* GetRightBoundartData();
 		vector<GeoCoordinatePoint>* GetReferenceData();
 		vector<Object*>* GetObjectData();
+		void GenerateLaneShp();
+		void GenerateObjShp();
+		void GenerateSingalObjShp();
 		void part(string _str, vector<int> &_num, vector<char> &_op);
 		GeoCoordinatePoint* GetLanePositionBySectionID(const char* sectionID, const char* laneID) const;
 		string GetJunction();
+
+		const char* GetLaneTypeString(const char* sectionID, const char* laneID) const;
+
+		double GetHdg(const double &s);
 		double GetElevation(const double &s);
-		const double GetWidthValue() const;
+		
 		~Road();
 	private:
 		vector<LaneSection*>  *_vecLanSections;

src/SDK/include/glm/CMakeLists.txt

-file(GLOB ROOT_SOURCE *.cpp)
-file(GLOB ROOT_INLINE *.inl)
-file(GLOB ROOT_HEADER *.hpp)
-file(GLOB ROOT_TEXT ../*.txt)
-file(GLOB ROOT_MD ../*.md)
-file(GLOB ROOT_NAT ../util/glm.natvis)
-
-file(GLOB_RECURSE CORE_SOURCE ./detail/*.cpp)
-file(GLOB_RECURSE CORE_INLINE ./detail/*.inl)
-file(GLOB_RECURSE CORE_HEADER ./detail/*.hpp)
-
-file(GLOB_RECURSE EXT_SOURCE ./ext/*.cpp)
-file(GLOB_RECURSE EXT_INLINE ./ext/*.inl)
-file(GLOB_RECURSE EXT_HEADER ./ext/*.hpp)
-
-file(GLOB_RECURSE GTC_SOURCE ./gtc/*.cpp)
-file(GLOB_RECURSE GTC_INLINE ./gtc/*.inl)
-file(GLOB_RECURSE GTC_HEADER ./gtc/*.hpp)
-
-file(GLOB_RECURSE GTX_SOURCE ./gtx/*.cpp)
-file(GLOB_RECURSE GTX_INLINE ./gtx/*.inl)
-file(GLOB_RECURSE GTX_HEADER ./gtx/*.hpp)
-
-file(GLOB_RECURSE SIMD_SOURCE ./simd/*.cpp)
-file(GLOB_RECURSE SIMD_INLINE ./simd/*.inl)
-file(GLOB_RECURSE SIMD_HEADER ./simd/*.h)
-
-source_group("Text Files" FILES ${ROOT_TEXT} ${ROOT_MD})
-source_group("Core Files" FILES ${CORE_SOURCE})
-source_group("Core Files" FILES ${CORE_INLINE})
-source_group("Core Files" FILES ${CORE_HEADER})
-source_group("EXT Files" FILES ${EXT_SOURCE})
-source_group("EXT Files" FILES ${EXT_INLINE})
-source_group("EXT Files" FILES ${EXT_HEADER})
-source_group("GTC Files" FILES ${GTC_SOURCE})
-source_group("GTC Files" FILES ${GTC_INLINE})
-source_group("GTC Files" FILES ${GTC_HEADER})
-source_group("GTX Files" FILES ${GTX_SOURCE})
-source_group("GTX Files" FILES ${GTX_INLINE})
-source_group("GTX Files" FILES ${GTX_HEADER})
-source_group("SIMD Files" FILES ${SIMD_SOURCE})
-source_group("SIMD Files" FILES ${SIMD_INLINE})
-source_group("SIMD Files" FILES ${SIMD_HEADER})
-
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
-
-if(GLM_STATIC_LIBRARY_ENABLE OR GLM_DYNAMIC_LIBRARY_ENABLE)
-	if(GLM_STATIC_LIBRARY_ENABLE)
-		add_library(glm_static STATIC ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT}
-			${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
-			${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
-			${EXT_SOURCE}     ${EXT_INLINE}     ${EXT_HEADER}
-			${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
-			${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER}
-			${SIMD_SOURCE}    ${SIMD_INLINE}    ${SIMD_HEADER})
-	endif(GLM_STATIC_LIBRARY_ENABLE)
-
-	if(GLM_DYNAMIC_LIBRARY_ENABLE)
-		add_library(glm_shared SHARED ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT}
-			${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
-			${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
-			${EXT_SOURCE}     ${EXT_INLINE}     ${EXT_HEADER}
-			${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
-			${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER}
-			${SIMD_SOURCE}    ${SIMD_INLINE}    ${SIMD_HEADER})
-	endif(GLM_DYNAMIC_LIBRARY_ENABLE)
-
-else(GLM_STATIC_LIBRARY_ENABLE OR GLM_DYNAMIC_LIBRARY_ENABLE)
-	add_executable(glm_dummy ${ROOT_TEXT} ${ROOT_MD} ${ROOT_NAT}
-		${ROOT_SOURCE}    ${ROOT_INLINE}    ${ROOT_HEADER}
-		${CORE_SOURCE}    ${CORE_INLINE}    ${CORE_HEADER}
-		${EXT_SOURCE}     ${EXT_INLINE}     ${EXT_HEADER}
-		${GTC_SOURCE}     ${GTC_INLINE}     ${GTC_HEADER}
-		${GTX_SOURCE}     ${GTX_INLINE}     ${GTX_HEADER}
-		${SIMD_SOURCE}    ${SIMD_INLINE}    ${SIMD_HEADER})
-
-endif(GLM_STATIC_LIBRARY_ENABLE OR GLM_DYNAMIC_LIBRARY_ENABLE)

src/SDK/include/glm/detail/_fixes.hpp

-/// @ref core
-/// @file glm/detail/_fixes.hpp
-
-#include <cmath>
-
-//! Workaround for compatibility with other libraries
-#ifdef max
-#undef max
-#endif
-
-//! Workaround for compatibility with other libraries
-#ifdef min
-#undef min
-#endif
-
-//! Workaround for Android
-#ifdef isnan
-#undef isnan
-#endif
-
-//! Workaround for Android
-#ifdef isinf
-#undef isinf
-#endif
-
-//! Workaround for Chrone Native Client
-#ifdef log2
-#undef log2
-#endif
-

src/SDK/include/glm/detail/_noise.hpp

-/// @ref core
-/// @file glm/detail/_noise.hpp
-
-#pragma once
-
-#include "../vec2.hpp"
-#include "../vec3.hpp"
-#include "../vec4.hpp"
-#include "../common.hpp"
-
-namespace glm{
-namespace detail
-{
-	template<typename T>
-	GLM_FUNC_QUALIFIER T mod289(T const& x)
-	{
-		return x - floor(x * (static_cast<T>(1.0) / static_cast<T>(289.0))) * static_cast<T>(289.0);
-	}
-
-	template<typename T>
-	GLM_FUNC_QUALIFIER T permute(T const& x)
-	{
-		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
-	}
-
-	template<typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<2, T, Q> permute(vec<2, T, Q> const& x)
-	{
-		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
-	}
-	
-	template<typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<3, T, Q> permute(vec<3, T, Q> const& x)
-	{
-		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
-	}
-	
-	template<typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<4, T, Q> permute(vec<4, T, Q> const& x)
-	{
-		return mod289(((x * static_cast<T>(34)) + static_cast<T>(1)) * x);
-	}
-
-	template<typename T>
-	GLM_FUNC_QUALIFIER T taylorInvSqrt(T const& r)
-	{
-		return T(1.79284291400159) - T(0.85373472095314) * r;
-	}
-	
-	template<typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<2, T, Q> taylorInvSqrt(vec<2, T, Q> const& r)
-	{
-		return T(1.79284291400159) - T(0.85373472095314) * r;
-	}
-	
-	template<typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<3, T, Q> taylorInvSqrt(vec<3, T, Q> const& r)
-	{
-		return T(1.79284291400159) - T(0.85373472095314) * r;
-	}
-	
-	template<typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<4, T, Q> taylorInvSqrt(vec<4, T, Q> const& r)
-	{
-		return T(1.79284291400159) - T(0.85373472095314) * r;
-	}
-
-	template<typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<2, T, Q> fade(vec<2, T, Q> const& t)
-	{
-		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
-	}
-	
-	template<typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<3, T, Q> fade(vec<3, T, Q> const& t)
-	{
-		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
-	}
-	
-	template<typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<4, T, Q> fade(vec<4, T, Q> const& t)
-	{
-		return (t * t * t) * (t * (t * T(6) - T(15)) + T(10));
-	}
-}//namespace detail
-}//namespace glm
-

src/SDK/include/glm/detail/_vectorize.hpp

-/// @ref core
-/// @file glm/detail/_vectorize.hpp
-
-#pragma once
-
-#include "type_vec1.hpp"
-#include "type_vec2.hpp"
-#include "type_vec3.hpp"
-#include "type_vec4.hpp"
-
-namespace glm{
-namespace detail
-{
-	template<length_t L, typename R, typename T, qualifier Q>
-	struct functor1{};
-
-	template<typename R, typename T, qualifier Q>
-	struct functor1<1, R, T, Q>
-	{
-		GLM_FUNC_QUALIFIER static vec<1, R, Q> call(R (*Func) (T x), vec<1, T, Q> const& v)
-		{
-			return vec<1, R, Q>(Func(v.x));
-		}
-	};
-
-	template<typename R, typename T, qualifier Q>
-	struct functor1<2, R, T, Q>
-	{
-		GLM_FUNC_QUALIFIER static vec<2, R, Q> call(R (*Func) (T x), vec<2, T, Q> const& v)
-		{
-			return vec<2, R, Q>(Func(v.x), Func(v.y));
-		}
-	};
-
-	template<typename R, typename T, qualifier Q>
-	struct functor1<3, R, T, Q>
-	{
-		GLM_FUNC_QUALIFIER static vec<3, R, Q> call(R (*Func) (T x), vec<3, T, Q> const& v)
-		{
-			return vec<3, R, Q>(Func(v.x), Func(v.y), Func(v.z));
-		}
-	};
-
-	template<typename R, typename T, qualifier Q>
-	struct functor1<4, R, T, Q>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, R, Q> call(R (*Func) (T x), vec<4, T, Q> const& v)
-		{
-			return vec<4, R, Q>(Func(v.x), Func(v.y), Func(v.z), Func(v.w));
-		}
-	};
-
-	template<length_t L, typename T, qualifier Q>
-	struct functor2{};
-
-	template<typename T, qualifier Q>
-	struct functor2<1, T, Q>
-	{
-		GLM_FUNC_QUALIFIER static vec<1, T, Q> call(T (*Func) (T x, T y), vec<1, T, Q> const& a, vec<1, T, Q> const& b)
-		{
-			return vec<1, T, Q>(Func(a.x, b.x));
-		}
-	};
-
-	template<typename T, qualifier Q>
-	struct functor2<2, T, Q>
-	{
-		GLM_FUNC_QUALIFIER static vec<2, T, Q> call(T (*Func) (T x, T y), vec<2, T, Q> const& a, vec<2, T, Q> const& b)
-		{
-			return vec<2, T, Q>(Func(a.x, b.x), Func(a.y, b.y));
-		}
-	};
-
-	template<typename T, qualifier Q>
-	struct functor2<3, T, Q>
-	{
-		GLM_FUNC_QUALIFIER static vec<3, T, Q> call(T (*Func) (T x, T y), vec<3, T, Q> const& a, vec<3, T, Q> const& b)
-		{
-			return vec<3, T, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z));
-		}
-	};
-
-	template<typename T, qualifier Q>
-	struct functor2<4, T, Q>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, T, Q> call(T (*Func) (T x, T y), vec<4, T, Q> const& a, vec<4, T, Q> const& b)
-		{
-			return vec<4, T, Q>(Func(a.x, b.x), Func(a.y, b.y), Func(a.z, b.z), Func(a.w, b.w));
-		}
-	};
-
-	template<length_t L, typename T, qualifier Q>
-	struct functor2_vec_sca{};
-
-	template<typename T, qualifier Q>
-	struct functor2_vec_sca<1, T, Q>
-	{
-		GLM_FUNC_QUALIFIER static vec<1, T, Q> call(T (*Func) (T x, T y), vec<1, T, Q> const& a, T b)
-		{
-			return vec<1, T, Q>(Func(a.x, b));
-		}
-	};
-
-	template<typename T, qualifier Q>
-	struct functor2_vec_sca<2, T, Q>
-	{
-		GLM_FUNC_QUALIFIER static vec<2, T, Q> call(T (*Func) (T x, T y), vec<2, T, Q> const& a, T b)
-		{
-			return vec<2, T, Q>(Func(a.x, b), Func(a.y, b));
-		}
-	};
-
-	template<typename T, qualifier Q>
-	struct functor2_vec_sca<3, T, Q>
-	{
-		GLM_FUNC_QUALIFIER static vec<3, T, Q> call(T (*Func) (T x, T y), vec<3, T, Q> const& a, T b)
-		{
-			return vec<3, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b));
-		}
-	};
-
-	template<typename T, qualifier Q>
-	struct functor2_vec_sca<4, T, Q>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, T, Q> call(T (*Func) (T x, T y), vec<4, T, Q> const& a, T b)
-		{
-			return vec<4, T, Q>(Func(a.x, b), Func(a.y, b), Func(a.z, b), Func(a.w, b));
-		}
-	};
-}//namespace detail
-}//namespace glm

src/SDK/include/glm/detail/compute_vector_relational.hpp

-#pragma once
-
-#include "setup.hpp"
-#include <cstring>
-#include <limits>
-
-namespace glm{
-namespace detail
-{
-	template <typename T, bool isFloat = std::numeric_limits<T>::is_iec559>
-	struct compute_equal
-	{
-		GLM_FUNC_QUALIFIER static bool call(T a, T b)
-		{
-			return a == b;
-		}
-	};
-
-	template <typename T>
-	struct compute_equal<T, true>
-	{
-		GLM_FUNC_QUALIFIER static bool call(T a, T b)
-		{
-			return std::memcmp(&a, &b, sizeof(T)) == 0;
-		}
-	};
-}//namespace detail
-}//namespace glm

src/SDK/include/glm/detail/dummy.cpp

-/// @ref core
-/// @file glm/core/dummy.cpp
-///
-/// GLM is a header only library. There is nothing to compile. 
-/// dummy.cpp exist only a wordaround for CMake file.
-
-/*
-#define GLM_MESSAGES
-#include <glm/glm.hpp>
-#include <glm/ext.hpp>
-#include <limits>
-
-struct material
-{
-	glm::vec4 emission; // Ecm
-	glm::vec4 ambient; // Acm
-	glm::vec4 diffuse; // Dcm
-	glm::vec4 specular; // Scm
-	float shininess; // Srm
-};
-
-struct light
-{
-	glm::vec4 ambient; // Acli
-	glm::vec4 diffuse; // Dcli
-	glm::vec4 specular; // Scli
-	glm::vec4 position; // Ppli
-	glm::vec4 halfVector; // Derived: Hi
-	glm::vec3 spotDirection; // Sdli
-	float spotExponent; // Srli
-	float spotCutoff; // Crli
-	// (range: [0.0,90.0], 180.0)
-	float spotCosCutoff; // Derived: cos(Crli)
-	// (range: [1.0,0.0],-1.0)
-	float constantAttenuation; // K0
-	float linearAttenuation; // K1
-	float quadraticAttenuation;// K2
-};
-
-
-// Sample 1
-#include <glm/vec3.hpp>// glm::vec3
-#include <glm/geometric.hpp>// glm::cross, glm::normalize
-
-glm::vec3 computeNormal
-(
-	glm::vec3 const& a,
-	glm::vec3 const& b,
-	glm::vec3 const& c
-)
-{
-	return glm::normalize(glm::cross(c - a, b - a));
-}
-
-typedef unsigned int GLuint;
-#define GL_FALSE 0
-void glUniformMatrix4fv(GLuint, int, int, float*){}
-
-// Sample 2
-#include <glm/vec3.hpp> // glm::vec3
-#include <glm/vec4.hpp> // glm::vec4, glm::ivec4
-#include <glm/mat4x4.hpp> // glm::mat4
-#include <glm/gtc/matrix_transform.hpp> // glm::translate, glm::rotate, glm::scale, glm::perspective
-#include <glm/gtc/type_ptr.hpp> // glm::value_ptr
-void func(GLuint LocationMVP, float Translate, glm::vec2 const& Rotate)
-{
-	glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.f);
-	glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Translate));
-	glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Rotate.y, glm::vec3(-1.0f, 0.0f, 0.0f));
-	glm::mat4 View = glm::rotate(ViewRotateX, Rotate.x, glm::vec3(0.0f, 1.0f, 0.0f));
-	glm::mat4 Model = glm::scale(glm::mat4(1.0f), glm::vec3(0.5f));
-	glm::mat4 MVP = Projection * View * Model;
-	glUniformMatrix4fv(LocationMVP, 1, GL_FALSE, glm::value_ptr(MVP));
-}
-
-// Sample 3
-#include <glm/vec2.hpp>// glm::vec2
-#include <glm/packing.hpp>// glm::packUnorm2x16
-#include <glm/integer.hpp>// glm::uint
-#include <glm/gtc/type_precision.hpp>// glm::i8vec2, glm::i32vec2
-std::size_t const VertexCount = 4;
-// Float quad geometry
-std::size_t const PositionSizeF32 = VertexCount * sizeof(glm::vec2);
-glm::vec2 const PositionDataF32[VertexCount] =
-{
-	glm::vec2(-1.0f,-1.0f),
-	glm::vec2( 1.0f,-1.0f),
-	glm::vec2( 1.0f, 1.0f),
-	glm::vec2(-1.0f, 1.0f)
-	};
-// Half-float quad geometry
-std::size_t const PositionSizeF16 = VertexCount * sizeof(glm::uint);
-glm::uint const PositionDataF16[VertexCount] =
-{
-	glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, -1.0f))),
-	glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, -1.0f))),
-	glm::uint(glm::packUnorm2x16(glm::vec2( 1.0f, 1.0f))),
-	glm::uint(glm::packUnorm2x16(glm::vec2(-1.0f, 1.0f)))
-};
-// 8 bits signed integer quad geometry
-std::size_t const PositionSizeI8 = VertexCount * sizeof(glm::i8vec2);
-glm::i8vec2 const PositionDataI8[VertexCount] =
-{
-	glm::i8vec2(-1,-1),
-	glm::i8vec2( 1,-1),
-	glm::i8vec2( 1, 1),
-	glm::i8vec2(-1, 1)
-};
-// 32 bits signed integer quad geometry
-std::size_t const PositionSizeI32 = VertexCount * sizeof(glm::i32vec2);
-glm::i32vec2 const PositionDataI32[VertexCount] =
-{
-	glm::i32vec2 (-1,-1),
-	glm::i32vec2 ( 1,-1),
-	glm::i32vec2 ( 1, 1),
-	glm::i32vec2 (-1, 1)
-};
-
-struct intersection
-{
-	glm::vec4 position;
-	glm::vec3 normal;
-};
-*/
-
-
-/*
-// Sample 4
-#include <glm/vec3.hpp>// glm::vec3
-#include <glm/geometric.hpp>// glm::normalize, glm::dot, glm::reflect
-#include <glm/exponential.hpp>// glm::pow
-#include <glm/gtc/random.hpp>// glm::vecRand3
-glm::vec3 lighting
-(
-	intersection const& Intersection,
-	material const& Material,
-	light const& Light,
-	glm::vec3 const& View
-)
-{
-	glm::vec3 Color(0.0f);
-	glm::vec3 LightVertor(glm::normalize(
-		Light.position - Intersection.position +
-		glm::vecRand3(0.0f, Light.inaccuracy));
-
-	if(!shadow(Intersection.position, Light.position, LightVertor))
-	{
-		float Diffuse = glm::dot(Intersection.normal, LightVector);
-		if(Diffuse <= 0.0f)
-			return Color;
-		if(Material.isDiffuse())
-			Color += Light.color() * Material.diffuse * Diffuse;
-		if(Material.isSpecular())
-		{
-			glm::vec3 Reflect(glm::reflect(
-				glm::normalize(-LightVector),
-				glm::normalize(Intersection.normal)));
-			float Dot = glm::dot(Reflect, View);
-			float Base = Dot > 0.0f ? Dot : 0.0f;
-			float Specular = glm::pow(Base, Material.exponent);
-			Color += Material.specular * Specular;
-		}
-	}
-	return Color;
-}
-*/
-
-int main()
-{
-/*
-	glm::vec1 o(1);
-	glm::vec2 a(1);
-	glm::vec3 b(1);
-	glm::vec4 c(1);
-
-	glm::quat q;
-	glm::dualquat p;
-
-	glm::mat4 m(1);
-
-	float a0 = normalizeDotA(a, a);
-	float b0 = normalizeDotB(b, b);
-	float c0 = normalizeDotC(c, c);
-*/
-	return 0;
-}

src/SDK/include/glm/detail/func_common_simd.inl

-/// @ref core
-/// @file glm/detail/func_common_simd.inl
-
-#if GLM_ARCH & GLM_ARCH_SSE2_BIT
-
-#include "../simd/common.h"
-
-#include <immintrin.h>
-
-namespace glm{
-namespace detail
-{
-	template<qualifier Q>
-	struct compute_abs_vector<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
-		{
-			vec<4, float, Q> result;
-			result.data = glm_vec4_abs(v.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_abs_vector<4, int, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, int, Q> call(vec<4, int, Q> const& v)
-		{
-			vec<4, int, Q> result;
-			result.data = glm_ivec4_abs(v.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_floor<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
-		{
-			vec<4, float, Q> result;
-			result.data = glm_vec4_floor(v.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_ceil<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
-		{
-			vec<4, float, Q> result;
-			result.data = glm_vec4_ceil(v.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_fract<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
-		{
-			vec<4, float, Q> result;
-			result.data = glm_vec4_fract(v.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_round<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
-		{
-			vec<4, float, Q> result;
-			result.data = glm_vec4_round(v.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_mod<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y)
-		{
-			vec<4, float, Q> result;
-			result.data = glm_vec4_mod(x.data, y.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_min_vector<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
-		{
-			vec<4, float, Q> result;
-			result.data = _mm_min_ps(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_min_vector<4, int32, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, int32, Q> call(vec<4, int32, Q> const& v1, vec<4, int32, Q> const& v2)
-		{
-			vec<4, int32, Q> result;
-			result.data = _mm_min_epi32(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_min_vector<4, uint32, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, int32, Q> call(vec<4, uint32, Q> const& v1, vec<4, uint32, Q> const& v2)
-		{
-			vec<4, uint32, Q> result;
-			result.data = _mm_min_epu32(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_max_vector<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v1, vec<4, float, Q> const& v2)
-		{
-			vec<4, float, Q> result;
-			result.data = _mm_max_ps(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_max_vector<4, int32, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, int32, Q> call(vec<4, int32, Q> const& v1, vec<4, int32, Q> const& v2)
-		{
-			vec<4, int32, Q> result;
-			result.data = _mm_max_epi32(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_max_vector<4, uint32, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, uint32, Q> call(vec<4, uint32, Q> const& v1, vec<4, uint32, Q> const& v2)
-		{
-			vec<4, uint32, Q> result;
-			result.data = _mm_max_epu32(v1.data, v2.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_clamp_vector<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& minVal, vec<4, float, Q> const& maxVal)
-		{
-			vec<4, float, Q> result;
-			result.data = _mm_min_ps(_mm_max_ps(x.data, minVal.data), maxVal.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_clamp_vector<4, int32, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, int32, Q> call(vec<4, int32, Q> const& x, vec<4, int32, Q> const& minVal, vec<4, int32, Q> const& maxVal)
-		{
-			vec<4, int32, Q> result;
-			result.data = _mm_min_epi32(_mm_max_epi32(x.data, minVal.data), maxVal.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_clamp_vector<4, uint32, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, uint32, Q> call(vec<4, uint32, Q> const& x, vec<4, uint32, Q> const& minVal, vec<4, uint32, Q> const& maxVal)
-		{
-			vec<4, uint32, Q> result;
-			result.data = _mm_min_epu32(_mm_max_epu32(x.data, minVal.data), maxVal.data);
-			return result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_mix_vector<4, float, bool, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& x, vec<4, float, Q> const& y, vec<4, bool, Q> const& a)
-		{
-			__m128i const Load = _mm_set_epi32(-static_cast<int>(a.w), -static_cast<int>(a.z), -static_cast<int>(a.y), -static_cast<int>(a.x));
-			__m128 const Mask = _mm_castsi128_ps(Load);
-
-			vec<4, float, Q> Result;
-#			if 0 && GLM_ARCH & GLM_ARCH_AVX
-				Result.data = _mm_blendv_ps(x.data, y.data, Mask);
-#			else
-				Result.data = _mm_or_ps(_mm_and_ps(Mask, y.data), _mm_andnot_ps(Mask, x.data));
-#			endif
-			return Result;
-		}
-	};
-/* FIXME
-	template<qualifier Q>
-	struct compute_step_vector<float, Q, tvec4>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge, vec<4, float, Q> const& x)
-		{
-			vec<4, float, Q> Result;
-			result.data = glm_vec4_step(edge.data, x.data);
-			return result;
-		}
-	};
-*/
-	template<qualifier Q>
-	struct compute_smoothstep_vector<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& edge0, vec<4, float, Q> const& edge1, vec<4, float, Q> const& x)
-		{
-			vec<4, float, Q> Result;
-			Result.data = glm_vec4_smoothstep(edge0.data, edge1.data, x.data);
-			return Result;
-		}
-	};
-}//namespace detail
-}//namespace glm
-
-#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

src/SDK/include/glm/detail/func_exponential.inl

-/// @ref core
-/// @file glm/detail/func_exponential.inl
-
-#include "../vector_relational.hpp"
-#include "_vectorize.hpp"
-#include <limits>
-#include <cmath>
-#include <cassert>
-
-namespace glm{
-namespace detail
-{
-#	if GLM_HAS_CXX11_STL
-		using std::log2;
-#	else
-		template<typename genType>
-		genType log2(genType Value)
-		{
-			return std::log(Value) * static_cast<genType>(1.4426950408889634073599246810019);
-		}
-#	endif
-
-	template<length_t L, typename T, qualifier Q, bool isFloat, bool Aligned>
-	struct compute_log2
-	{
-		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'log2' only accept floating-point inputs. Include <glm/gtc/integer.hpp> for integer inputs.");
-
-			return detail::functor1<L, T, T, Q>::call(log2, v);
-		}
-	};
-
-	template<length_t L, typename T, qualifier Q, bool Aligned>
-	struct compute_sqrt
-	{
-		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
-		{
-			return detail::functor1<L, T, T, Q>::call(std::sqrt, x);
-		}
-	};
-
-	template<length_t L, typename T, qualifier Q, bool Aligned>
-	struct compute_inversesqrt
-	{
-		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& x)
-		{
-			return static_cast<T>(1) / sqrt(x);
-		}
-	};
-		
-	template<length_t L, bool Aligned>
-	struct compute_inversesqrt<L, float, lowp, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static vec<L, float, lowp> call(vec<L, float, lowp> const& x)
-		{
-			vec<L, float, lowp> tmp(x);
-			vec<L, float, lowp> xhalf(tmp * 0.5f);
-			vec<L, uint, lowp>* p = reinterpret_cast<vec<L, uint, lowp>*>(const_cast<vec<L, float, lowp>*>(&x));
-			vec<L, uint, lowp> i = vec<L, uint, lowp>(0x5f375a86) - (*p >> vec<L, uint, lowp>(1));
-			vec<L, float, lowp>* ptmp = reinterpret_cast<vec<L, float, lowp>*>(&i);
-			tmp = *ptmp;
-			tmp = tmp * (1.5f - xhalf * tmp * tmp);
-			return tmp;
-		}
-	};
-}//namespace detail
-
-	// pow
-	using std::pow;
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<L, T, Q> pow(vec<L, T, Q> const& base, vec<L, T, Q> const& exponent)
-	{
-		return detail::functor2<L, T, Q>::call(pow, base, exponent);
-	}
-
-	// exp
-	using std::exp;
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<L, T, Q> exp(vec<L, T, Q> const& x)
-	{
-		return detail::functor1<L, T, T, Q>::call(exp, x);
-	}
-
-	// log
-	using std::log;
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<L, T, Q> log(vec<L, T, Q> const& x)
-	{
-		return detail::functor1<L, T, T, Q>::call(log, x);
-	}
-
-#   if GLM_HAS_CXX11_STL
-    using std::exp2;
-#   else
-	//exp2, ln2 = 0.69314718055994530941723212145818f
-	template<typename genType>
-	GLM_FUNC_QUALIFIER genType exp2(genType x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'exp2' only accept floating-point inputs");
-
-		return std::exp(static_cast<genType>(0.69314718055994530941723212145818) * x);
-	}
-#   endif
-
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<L, T, Q> exp2(vec<L, T, Q> const& x)
-	{
-		return detail::functor1<L, T, T, Q>::call(exp2, x);
-	}
-
-	// log2, ln2 = 0.69314718055994530941723212145818f
-	template<typename genType>
-	GLM_FUNC_QUALIFIER genType log2(genType x)
-	{
-		return log2(vec<1, genType>(x)).x;
-	}
-
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<L, T, Q> log2(vec<L, T, Q> const& x)
-	{
-		return detail::compute_log2<L, T, Q, std::numeric_limits<T>::is_iec559, detail::is_aligned<Q>::value>::call(x);
-	}
-
-	// sqrt
-	using std::sqrt;
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<L, T, Q> sqrt(vec<L, T, Q> const& x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'sqrt' only accept floating-point inputs");
-		return detail::compute_sqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x);
-	}
-
-	// inversesqrt
-	template<typename genType>
-	GLM_FUNC_QUALIFIER genType inversesqrt(genType x)
-	{
-		return static_cast<genType>(1) / sqrt(x);
-	}
-	
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<L, T, Q> inversesqrt(vec<L, T, Q> const& x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'inversesqrt' only accept floating-point inputs");
-		return detail::compute_inversesqrt<L, T, Q, detail::is_aligned<Q>::value>::call(x);
-	}
-}//namespace glm
-
-#if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS
-#	include "func_exponential_simd.inl"
-#endif
-

src/SDK/include/glm/detail/func_exponential_simd.inl

-/// @ref core
-/// @file glm/detail/func_exponential_simd.inl
-
-#include "../simd/exponential.h"
-
-#if GLM_ARCH & GLM_ARCH_SSE2_BIT
-
-namespace glm{
-namespace detail
-{
-	template<qualifier Q>
-	struct compute_sqrt<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
-		{
-			vec<4, float, Q> Result;
-			Result.data = _mm_sqrt_ps(v.data);
-			return Result;
-		}
-	};
-
-	template<>
-	struct compute_sqrt<4, float, aligned_lowp, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, aligned_lowp> call(vec<4, float, aligned_lowp> const& v)
-		{
-			vec<4, float, aligned_lowp> Result;
-			Result.data = glm_vec4_sqrt_lowp(v.data);
-			return Result;
-		}
-	};
-}//namespace detail
-}//namespace glm
-
-#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

src/SDK/include/glm/detail/func_geometric.inl

-/// @ref core
-/// @file glm/detail/func_geometric.inl
-
-#include "../exponential.hpp"
-#include "../common.hpp"
-#include "type_vec2.hpp"
-#include "type_vec4.hpp"
-#include "type_float.hpp"
-
-namespace glm{
-namespace detail
-{
-	template<length_t L, typename T, qualifier Q, bool Aligned>
-	struct compute_length
-	{
-		GLM_FUNC_QUALIFIER static T call(vec<L, T, Q> const& v)
-		{
-			return sqrt(dot(v, v));
-		}
-	};
-
-	template<length_t L, typename T, qualifier Q, bool Aligned>
-	struct compute_distance
-	{
-		GLM_FUNC_QUALIFIER static T call(vec<L, T, Q> const& p0, vec<L, T, Q> const& p1)
-		{
-			return length(p1 - p0);
-		}
-	};
-
-	template<typename V, typename T, bool Aligned>
-	struct compute_dot{};
-
-	template<typename T, qualifier Q, bool Aligned>
-	struct compute_dot<vec<1, T, Q>, T, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static T call(vec<1, T, Q> const& a, vec<1, T, Q> const& b)
-		{
-			return a.x * b.x;
-		}
-	};
-
-	template<typename T, qualifier Q, bool Aligned>
-	struct compute_dot<vec<2, T, Q>, T, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static T call(vec<2, T, Q> const& a, vec<2, T, Q> const& b)
-		{
-			vec<2, T, Q> tmp(a * b);
-			return tmp.x + tmp.y;
-		}
-	};
-
-	template<typename T, qualifier Q, bool Aligned>
-	struct compute_dot<vec<3, T, Q>, T, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static T call(vec<3, T, Q> const& a, vec<3, T, Q> const& b)
-		{
-			vec<3, T, Q> tmp(a * b);
-			return tmp.x + tmp.y + tmp.z;
-		}
-	};
-
-	template<typename T, qualifier Q, bool Aligned>
-	struct compute_dot<vec<4, T, Q>, T, Aligned>
-	{
-		GLM_FUNC_QUALIFIER static T call(vec<4, T, Q> const& a, vec<4, T, Q> const& b)
-		{
-			vec<4, T, Q> tmp(a * b);
-			return (tmp.x + tmp.y) + (tmp.z + tmp.w);
-		}
-	};
-
-	template<typename T, qualifier Q, bool Aligned>
-	struct compute_cross
-	{
-		GLM_FUNC_QUALIFIER static vec<3, T, Q> call(vec<3, T, Q> const& x, vec<3, T, Q> const& y)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'cross' accepts only floating-point inputs");
-
-			return vec<3, T, Q>(
-				x.y * y.z - y.y * x.z,
-				x.z * y.x - y.z * x.x,
-				x.x * y.y - y.x * x.y);
-		}
-	};
-
-	template<length_t L, typename T, qualifier Q, bool Aligned>
-	struct compute_normalize
-	{
-		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& v)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
-
-			return v * inversesqrt(dot(v, v));
-		}
-	};
-
-	template<length_t L, typename T, qualifier Q, bool Aligned>
-	struct compute_faceforward
-	{
-		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& N, vec<L, T, Q> const& I, vec<L, T, Q> const& Nref)
-		{
-			GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
-
-			return dot(Nref, I) < static_cast<T>(0) ? N : -N;
-		}
-	};
-
-	template<length_t L, typename T, qualifier Q, bool Aligned>
-	struct compute_reflect
-	{
-		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& I, vec<L, T, Q> const& N)
-		{
-			return I - N * dot(N, I) * static_cast<T>(2);
-		}
-	};
-
-	template<length_t L, typename T, qualifier Q, bool Aligned>
-	struct compute_refract
-	{
-		GLM_FUNC_QUALIFIER static vec<L, T, Q> call(vec<L, T, Q> const& I, vec<L, T, Q> const& N, T eta)
-		{
-			T const dotValue(dot(N, I));
-			T const k(static_cast<T>(1) - eta * eta * (static_cast<T>(1) - dotValue * dotValue));
-			return (eta * I - (eta * dotValue + std::sqrt(k)) * N) * static_cast<T>(k >= static_cast<T>(0));
-		}
-	};
-}//namespace detail
-
-	// length
-	template<typename genType>
-	GLM_FUNC_QUALIFIER genType length(genType x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'length' accepts only floating-point inputs");
-
-		return abs(x);
-	}
-
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER T length(vec<L, T, Q> const& v)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'length' accepts only floating-point inputs");
-
-		return detail::compute_length<L, T, Q, detail::is_aligned<Q>::value>::call(v);
-	}
-
-	// distance
-	template<typename genType>
-	GLM_FUNC_QUALIFIER genType distance(genType const& p0, genType const& p1)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'distance' accepts only floating-point inputs");
-
-		return length(p1 - p0);
-	}
-
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER T distance(vec<L, T, Q> const& p0, vec<L, T, Q> const& p1)
-	{
-		return detail::compute_distance<L, T, Q, detail::is_aligned<Q>::value>::call(p0, p1);
-	}
-
-	// dot
-	template<typename T>
-	GLM_FUNC_QUALIFIER T dot(T x, T y)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
-		return x * y;
-	}
-
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER T dot(vec<L, T, Q> const& x, vec<L, T, Q> const& y)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'dot' accepts only floating-point inputs");
-		return detail::compute_dot<vec<L, T, Q>, T, detail::is_aligned<Q>::value>::call(x, y);
-	}
-
-	// cross
-	template<typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<3, T, Q> cross(vec<3, T, Q> const& x, vec<3, T, Q> const& y)
-	{
-		return detail::compute_cross<T, Q, detail::is_aligned<Q>::value>::call(x, y);
-	}
-
-	// normalize
-	template<typename genType>
-	GLM_FUNC_QUALIFIER genType normalize(genType const& x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'normalize' accepts only floating-point inputs");
-
-		return x < genType(0) ? genType(-1) : genType(1);
-	}
-
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<L, T, Q> normalize(vec<L, T, Q> const& x)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'normalize' accepts only floating-point inputs");
-
-		return detail::compute_normalize<L, T, Q, detail::is_aligned<Q>::value>::call(x);
-	}
-
-	// faceforward
-	template<typename genType>
-	GLM_FUNC_QUALIFIER genType faceforward(genType const& N, genType const& I, genType const& Nref)
-	{
-		return dot(Nref, I) < static_cast<genType>(0) ? N : -N;
-	}
-
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<L, T, Q> faceforward(vec<L, T, Q> const& N, vec<L, T, Q> const& I, vec<L, T, Q> const& Nref)
-	{
-		return detail::compute_faceforward<L, T, Q, detail::is_aligned<Q>::value>::call(N, I, Nref);
-	}
-
-	// reflect
-	template<typename genType>
-	GLM_FUNC_QUALIFIER genType reflect(genType const& I, genType const& N)
-	{
-		return I - N * dot(N, I) * genType(2);
-	}
-
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<L, T, Q> reflect(vec<L, T, Q> const& I, vec<L, T, Q> const& N)
-	{
-		return detail::compute_reflect<L, T, Q, detail::is_aligned<Q>::value>::call(I, N);
-	}
-
-	// refract
-	template<typename genType>
-	GLM_FUNC_QUALIFIER genType refract(genType const& I, genType const& N, genType eta)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<genType>::is_iec559, "'refract' accepts only floating-point inputs");
-		genType const dotValue(dot(N, I));
-		genType const k(static_cast<genType>(1) - eta * eta * (static_cast<genType>(1) - dotValue * dotValue));
-		return (eta * I - (eta * dotValue + sqrt(k)) * N) * static_cast<genType>(k >= static_cast<genType>(0));
-	}
-
-	template<length_t L, typename T, qualifier Q>
-	GLM_FUNC_QUALIFIER vec<L, T, Q> refract(vec<L, T, Q> const& I, vec<L, T, Q> const& N, T eta)
-	{
-		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_iec559, "'refract' accepts only floating-point inputs");
-		return detail::compute_refract<L, T, Q, detail::is_aligned<Q>::value>::call(I, N, eta);
-	}
-}//namespace glm
-
-#if GLM_ARCH != GLM_ARCH_PURE && GLM_HAS_UNRESTRICTED_UNIONS
-#	include "func_geometric_simd.inl"
-#endif

src/SDK/include/glm/detail/func_geometric_simd.inl

-/// @ref core
-/// @file glm/detail/func_geometric_simd.inl
-
-#include "../simd/geometric.h"
-
-#if GLM_ARCH & GLM_ARCH_SSE2_BIT
-
-namespace glm{
-namespace detail
-{
-	template<qualifier Q>
-	struct compute_length<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& v)
-		{
-			return _mm_cvtss_f32(glm_vec4_length(v.data));
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_distance<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& p0, vec<4, float, Q> const& p1)
-		{
-			return _mm_cvtss_f32(glm_vec4_distance(p0.data, p1.data));
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_dot<vec<4, float, Q>, float, true>
-	{
-		GLM_FUNC_QUALIFIER static float call(vec<4, float, Q> const& x, vec<4, float, Q> const& y)
-		{
-			return _mm_cvtss_f32(glm_vec1_dot(x.data, y.data));
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_cross<float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<3, float, Q> call(vec<3, float, Q> const& a, vec<3, float, Q> const& b)
-		{
-			__m128 const set0 = _mm_set_ps(0.0f, a.z, a.y, a.x);
-			__m128 const set1 = _mm_set_ps(0.0f, b.z, b.y, b.x);
-			__m128 const xpd0 = glm_vec4_cross(set0, set1);
-
-			vec<4, float, Q> Result;
-			Result.data = xpd0;
-			return vec<3, float, Q>(Result);
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_normalize<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& v)
-		{
-			vec<4, float, Q> Result;
-			Result.data = glm_vec4_normalize(v.data);
-			return Result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_faceforward<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& N, vec<4, float, Q> const& I, vec<4, float, Q> const& Nref)
-		{
-			vec<4, float, Q> Result;
-			Result.data = glm_vec4_faceforward(N.data, I.data, Nref.data);
-			return Result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_reflect<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N)
-		{
-			vec<4, float, Q> Result;
-			Result.data = glm_vec4_reflect(I.data, N.data);
-			return Result;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_refract<4, float, Q, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, float, Q> call(vec<4, float, Q> const& I, vec<4, float, Q> const& N, float eta)
-		{
-			vec<4, float, Q> Result;
-			Result.data = glm_vec4_refract(I.data, N.data, _mm_set1_ps(eta));
-			return Result;
-		}
-	};
-}//namespace detail
-}//namespace glm
-
-#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

src/SDK/include/glm/detail/func_integer_simd.inl

-/// @ref core
-/// @file glm/detail/func_integer_simd.inl
-
-#include "../simd/integer.h"
-
-#if GLM_ARCH & GLM_ARCH_SSE2_BIT
-
-namespace glm{
-namespace detail
-{
-	template<qualifier Q>
-	struct compute_bitfieldReverseStep<4, uint32, Q, true, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, uint32, Q> call(vec<4, uint32, Q> const& v, uint32 Mask, uint32 Shift)
-		{
-			__m128i const set0 = v.data;
-
-			__m128i const set1 = _mm_set1_epi32(static_cast<int>(Mask));
-			__m128i const and1 = _mm_and_si128(set0, set1);
-			__m128i const sft1 = _mm_slli_epi32(and1, Shift);
-
-			__m128i const set2 = _mm_andnot_si128(set0, _mm_set1_epi32(-1));
-			__m128i const and2 = _mm_and_si128(set0, set2);
-			__m128i const sft2 = _mm_srai_epi32(and2, Shift);
-		
-			__m128i const or0 = _mm_or_si128(sft1, sft2);
-		
-			return or0;
-		}
-	};
-
-	template<qualifier Q>
-	struct compute_bitfieldBitCountStep<4, uint32, Q, true, true>
-	{
-		GLM_FUNC_QUALIFIER static vec<4, uint32, Q> call(vec<4, uint32, Q> const& v, uint32 Mask, uint32 Shift)
-		{
-			__m128i const set0 = v.data;
-
-			__m128i const set1 = _mm_set1_epi32(static_cast<int>(Mask));
-			__m128i const and0 = _mm_and_si128(set0, set1);
-			__m128i const sft0 = _mm_slli_epi32(set0, Shift);
-			__m128i const and1 = _mm_and_si128(sft0, set1);
-			__m128i const add0 = _mm_add_epi32(and0, and1);
-		
-			return add0;
-		}
-	};
-}//namespace detail
-
-#	if GLM_ARCH & GLM_ARCH_AVX_BIT
-	template<>
-	GLM_FUNC_QUALIFIER int bitCount(uint32 x)
-	{
-		return _mm_popcnt_u32(x);
-	}
-
-#	if(GLM_MODEL == GLM_MODEL_64)
-	template<>
-	GLM_FUNC_QUALIFIER int bitCount(uint64 x)
-	{
-		return static_cast<int>(_mm_popcnt_u64(x));
-	}
-#	endif//GLM_MODEL
-#	endif//GLM_ARCH
-
-}//namespace glm
-
-#endif//GLM_ARCH & GLM_ARCH_SSE2_BIT

src/SDK/include/glm/detail/func_packing_simd.inl

-/// @ref core
-/// @file glm/detail/func_packing_simd.inl
-
-namespace glm{
-namespace detail
-{
-
-}//namespace detail
-}//namespace glm

src/SDK/include/glm/detail/func_vector_relational_simd.inl

-/// @ref core
-/// @file glm/detail/func_vector_relational_simd.inl
-
-namespace glm{
-namespace detail
-{
-
-}//namespace detail
-}//namespace glm

src/SDK/include/glm/detail/type_half.hpp

-/// @ref core
-/// @file glm/detail/type_half.hpp
-
-#pragma once
-
-#include "setup.hpp"
-
-namespace glm{
-namespace detail
-{
-	typedef short hdata;
-
-	GLM_FUNC_DECL float toFloat32(hdata value);
-	GLM_FUNC_DECL hdata toFloat16(float const& value);
-
-}//namespace detail
-}//namespace glm
-
-#include "type_half.inl"

src/SDK/include/glm/detail/type_mat.inl

-/// @ref core
-/// @file glm/detail/type_mat.inl
-

src/SDK/include/glm/detail/type_vec.inl

-/// @ref core
-/// @file glm/detail/type_vec.inl