Add project files.

Author: sneakyevil

Model Exporter.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.33529.622
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Model Exporter", "Model Exporter\Model Exporter.vcxproj", "{189124D7-B41E-43F5-BF23-1B864770ADC7}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{189124D7-B41E-43F5-BF23-1B864770ADC7}.Debug|x64.ActiveCfg = Debug|x64
+		{189124D7-B41E-43F5-BF23-1B864770ADC7}.Debug|x64.Build.0 = Debug|x64
+		{189124D7-B41E-43F5-BF23-1B864770ADC7}.Debug|x86.ActiveCfg = Debug|Win32
+		{189124D7-B41E-43F5-BF23-1B864770ADC7}.Debug|x86.Build.0 = Debug|Win32
+		{189124D7-B41E-43F5-BF23-1B864770ADC7}.Release|x64.ActiveCfg = Release|x64
+		{189124D7-B41E-43F5-BF23-1B864770ADC7}.Release|x64.Build.0 = Release|x64
+		{189124D7-B41E-43F5-BF23-1B864770ADC7}.Release|x86.ActiveCfg = Release|Win32
+		{189124D7-B41E-43F5-BF23-1B864770ADC7}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {8A8AFB53-EDCA-462D-A59B-3E447A99C690}
+	EndGlobalSection
+EndGlobal

Model Exporter/3rdParty/umHalf.h

@@ -0,0 +1,323 @@
+
+///////////////////////////////////////////////////////////////////////////////////
+/*
+Copyright (c) 2006-2008, 
+Chris "Krishty" Maiwald, Alexander "Aramis" Gessler
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms, 
+with or without modification, are permitted provided that the following 
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the class, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the Development Team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+///////////////////////////////////////////////////////////////////////////////////
+
+#ifndef UM_HALF_H_INCLUDED
+#define UM_HALF_H_INCLUDED
+
+#include <limits>
+#include <algorithm>
+
+#ifdef _MSC_VER
+#include "stdint.h"
+#else
+#include <stdint.h>
+#endif
+
+#undef min
+#undef max
+
+///////////////////////////////////////////////////////////////////////////////////
+/** 1. Represents a half-precision floating point value (16 bits) that behaves
+ *  nearly conformant to the IEE 754 standard for floating-point computations.
+ * 
+ *  Not all operators have special implementations, most perform time-consuming
+ *  conversions from half to float and back again.
+ *  Differences to IEEE 754:
+ *  - no difference between qnan and snan
+ *  - no traps
+ *  - no well-defined rounding mode
+ */
+///////////////////////////////////////////////////////////////////////////////////
+class HalfFloat
+{
+	friend HalfFloat operator+ (HalfFloat, HalfFloat);
+	friend HalfFloat operator- (HalfFloat, HalfFloat);
+	friend HalfFloat operator* (HalfFloat, HalfFloat);
+	friend HalfFloat operator/ (HalfFloat, HalfFloat);
+
+public:
+
+	enum { BITS_MANTISSA = 10 };
+	enum { BITS_EXPONENT = 5 };
+
+	enum { MAX_EXPONENT_VALUE = 31 };
+	enum { BIAS = MAX_EXPONENT_VALUE/2 };
+
+	enum { MAX_EXPONENT = BIAS };
+	enum { MIN_EXPONENT = -BIAS };
+
+	enum { MAX_EXPONENT10 = 9 };
+	enum { MIN_EXPONENT10 = -9 };
+
+public:
+
+	/** Default constructor. Unitialized by default.
+	 */
+	inline HalfFloat() {}
+
+	/** Construction from an existing half
+	 */
+	inline HalfFloat(const HalfFloat& other)
+		: bits(other.GetBits())
+	{}
+
+	/** Construction from existing values for mantissa, sign
+	 *  and exponent. No validation is performed.
+	 *  @note The exponent is unsigned and biased by #BIAS 
+	 */
+	inline HalfFloat(uint16_t _m,uint16_t _e,uint16_t _s);
+
+
+	/** Construction from a single-precision float
+	 */
+	inline HalfFloat(float other);
+
+	/** Construction from a double-precision float
+	 */
+	inline HalfFloat(const double);
+
+
+
+	/** Conversion operator to convert from half to float
+	 */
+	inline operator float() const;
+
+	/** Conversion operator to convert from half to double
+	 */
+	inline operator double() const;
+
+
+
+	/** Assignment operator to assign another half to
+	 *  *this* object.
+	 */
+	inline HalfFloat& operator= (HalfFloat other);
+	inline HalfFloat& operator= (float other);
+	inline HalfFloat& operator= (const double other);
+
+
+	/** Comparison operators
+	 */
+	inline bool operator== (HalfFloat other) const;
+	inline bool operator!= (HalfFloat other) const;
+
+
+	/** Relational comparison operators
+	 */
+	inline bool operator<  (HalfFloat other) const;
+	inline bool operator>  (HalfFloat other) const;
+	inline bool operator<= (HalfFloat other) const;
+	inline bool operator>= (HalfFloat other) const;
+
+	inline bool operator<  (float other) const;
+	inline bool operator>  (float other) const;
+	inline bool operator<= (float other) const;
+	inline bool operator>= (float other) const;
+
+
+	/** Combined assignment operators
+	 */
+	inline HalfFloat& operator += (HalfFloat other);
+	inline HalfFloat& operator -= (HalfFloat other);
+	inline HalfFloat& operator *= (HalfFloat other);
+	inline HalfFloat& operator /= (HalfFloat other);
+
+	inline HalfFloat& operator += (float other);
+	inline HalfFloat& operator -= (float other);
+	inline HalfFloat& operator *= (float other);
+	inline HalfFloat& operator /= (float other);
+
+	/** Post and prefix increment operators
+	 */
+	inline HalfFloat& operator++();
+	inline HalfFloat operator++(int);
+
+	/** Post and prefix decrement operators
+	 */
+	inline HalfFloat& operator--();
+	inline HalfFloat operator--(int);
+
+	/** Unary minus operator
+	 */
+	inline HalfFloat operator-() const;
+
+
+	/** Provides direct access to the bits of a half float
+	 */
+	inline uint16_t GetBits() const;
+	inline uint16_t& GetBits();
+
+
+	/** Classification of floating-point types
+	 */
+	inline bool IsNaN() const;
+	inline bool IsInfinity() const;
+	inline bool IsDenorm() const;
+
+	/** Returns the sign of the floating-point value -
+	 *  true stands for positive. 
+	 */
+	inline bool GetSign() const;
+
+public:
+
+	union 
+	{
+		uint16_t bits;			// All bits
+		struct 
+		{
+			uint16_t Frac : 10;	// mantissa
+			uint16_t Exp  : 5;		// exponent
+			uint16_t Sign : 1;		// sign
+		} IEEE;
+	};
+
+
+	union IEEESingle
+	{
+		float Float;
+		struct
+		{
+			uint32_t Frac : 23;
+			uint32_t Exp  : 8;
+			uint32_t Sign : 1;
+		} IEEE;
+	};
+
+	union IEEEDouble
+	{
+		double Double;
+		struct {
+			uint64_t Frac : 52;
+			uint64_t Exp  : 11;
+			uint64_t Sign : 1;
+		} IEEE;
+	};
+
+	// Enums can not store 64 bit values, so we have to use static constants.
+	static const uint64_t IEEEDouble_MaxExpontent = 0x7FF;
+	static const uint64_t IEEEDouble_ExponentBias = IEEEDouble_MaxExpontent / 2;
+};
+
+/** 2. Binary operations
+ */
+inline HalfFloat operator+ (HalfFloat one, HalfFloat two);
+inline HalfFloat operator- (HalfFloat one, HalfFloat two);
+inline HalfFloat operator* (HalfFloat one, HalfFloat two);
+inline HalfFloat operator/ (HalfFloat one, HalfFloat two);
+
+inline float operator+ (HalfFloat one, float two);
+inline float operator- (HalfFloat one, float two);
+inline float operator* (HalfFloat one, float two);
+inline float operator/ (HalfFloat one, float two);
+
+inline float operator+ (float one, HalfFloat two);
+inline float operator- (float one, HalfFloat two);
+inline float operator* (float one, HalfFloat two);
+inline float operator/ (float one, HalfFloat two);
+
+
+
+///////////////////////////////////////////////////////////////////////////////////
+/** 3. Specialization of std::numeric_limits for type half.
+ */
+///////////////////////////////////////////////////////////////////////////////////
+namespace std {
+template <>
+class numeric_limits<HalfFloat> {
+
+ public:
+
+	// General -- meaningful for all specializations.
+
+    static const bool is_specialized = true;
+    static HalfFloat min ()
+		{return HalfFloat(0,1,0);}
+    static HalfFloat max ()
+		{return HalfFloat(~0,HalfFloat::MAX_EXPONENT_VALUE-1,0);}
+    static const int radix = 2;
+    static const int digits = 10;   // conservative assumption
+    static const int digits10 = 2;  // conservative assumption
+	static const bool is_signed		= true;
+    static const bool is_integer	= true;
+    static const bool is_exact		= false;
+    static const bool traps			= false;
+    static const bool is_modulo		= false;
+    static const bool is_bounded	= true;
+
+	// Floating point specific.
+
+    static HalfFloat epsilon ()
+		{return HalfFloat(0.00097656f);} // from OpenEXR, needs to be confirmed
+    static HalfFloat round_error ()
+		{return HalfFloat(0.00097656f/2);}
+    static const int min_exponent10 = HalfFloat::MIN_EXPONENT10;
+    static const int max_exponent10 = HalfFloat::MAX_EXPONENT10;
+    static const int min_exponent   = HalfFloat::MIN_EXPONENT;
+    static const int max_exponent   = HalfFloat::MAX_EXPONENT;
+
+    static const bool has_infinity			= true;
+    static const bool has_quiet_NaN			= true;
+    static const bool has_signaling_NaN		= true;
+    static const bool is_iec559				= false;
+    static const bool has_denorm			= denorm_present;
+    static const bool tinyness_before		= false;
+    static const float_round_style round_style = round_to_nearest;
+
+    static HalfFloat denorm_min ()
+		{return HalfFloat(1,0,1);}
+    static HalfFloat infinity ()
+		{return HalfFloat(0,HalfFloat::MAX_EXPONENT_VALUE,0);}
+    static HalfFloat quiet_NaN ()
+		{return HalfFloat(1,HalfFloat::MAX_EXPONENT_VALUE,0);}
+    static HalfFloat signaling_NaN ()
+		{return HalfFloat(1,HalfFloat::MAX_EXPONENT_VALUE,0);}
+ };
+} // end namespace std
+
+
+#include "./umHalf.inl"
+
+#ifndef UM_HALF_NO_TYPEDEFS
+	typedef HalfFloat float16;
+	typedef HalfFloat half;
+#endif
+
+#endif // !! UM_HALF_H_INCLUDED