text: // Copyright 2016 The SwiftShader Authors. 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 sw_Half_hpp
  #define sw_Half_hpp
  
  #include "Math.hpp"
  
  #include <algorithm>
  #include <cmath>
  
  namespace sw {
  
  class half
  {
  public:
  	half() = default;
  	explicit half(float f);
  
  	operator float() const;
  
  	half &operator=(float f);
  
  private:
  	unsigned short fp16i;
  };
  
  inline half shortAsHalf(short s)
  {
  	union
  	{
  		half h;
  		short s;
  	} hs;
  
  	hs.s = s;
  
  	return hs.h;
  }
  
  class RGB9E5
  {
  	unsigned int R : 9;
  	unsigned int G : 9;
  	unsigned int B : 9;
  	unsigned int E : 5;
  
  public:
  	RGB9E5(const float rgb[3])
  	    : RGB9E5(rgb[0], rgb[1], rgb[2])
  	{
  	}
  
  	RGB9E5(float r, float g, float b)
  	{
  		// Vulkan 1.1.117 section 15.2.1 RGB to Shared Exponent Conversion
  
  		// B is the exponent bias (15)
  		constexpr int g_sharedexp_bias = 15;
  
  		// N is the number of mantissa bits per component (9)
  		constexpr int g_sharedexp_mantissabits = 9;
  
  		// Emax is the maximum allowed biased exponent value (31)
  		constexpr int g_sharedexp_maxexponent = 31;
  
  		constexpr float g_sharedexp_max =
  		    ((static_cast<float>(1 << g_sharedexp_mantissabits) - 1) /
  		     static_cast<float>(1 << g_sharedexp_mantissabits)) *
  		    static_cast<float>(1 << (g_sharedexp_maxexponent - g_sharedexp_bias));
  
  		// Clamp components to valid range. NaN becomes 0.
  		const float red_c = std::min(!(r > 0) ? 0 : r, g_sharedexp_max);
  		const float green_c = std::min(!(g > 0) ? 0 : g, g_sharedexp_max);
  		const float blue_c = std::min(!(b > 0) ? 0 : b, g_sharedexp_max);
  
  		// We're reducing the mantissa to 9 bits, so we must round up if the next
  		// bit is 1. In other words add 0.5 to the new mantissa's position and
  		// allow overflow into the exponent so we can scale correctly.
  		constexpr int half = 1 << (23 - g_sharedexp_mantissabits);
  		const float red_r = bit_cast<float>(bit_cast<int>(red_c) + half);
  		const float green_r = bit_cast<float>(bit_cast<int>(green_c) + half);
  		const float blue_r = bit_cast<float>(bit_cast<int>(blue_c) + half);
  
  		// The largest component determines the shared exponent. It can't be lower
  		// than 0 (after bias subtraction) so also limit to the mimimum representable.
  		constexpr float min_s = 0.5f / (1 << g_sharedexp_bias);
  		float max_s = std::max(std::max(red_r, green_r), std::max(blue_r, min_s));
  
  		// Obtain the reciprocal of the shared exponent by inverting the bits,
  		// and scale by the new mantissa's size. Note that the IEEE-754 single-precision
  		// format has an implicit leading 1, but this shared component format does not.
  		float scale = bit_cast<float>((bit_cast<int>(max_s) & 0x7F800000) ^ 0x7F800000) * (1 << (g_sharedexp_mantissabits - 2));
  
  		R = static_cast<unsigned int>(round(red_c * scale));
  		G = static_cast<unsigned int>(round(green_c * scale));
  		B = static_cast<unsigned int>(round(blue_c * scale));
  		E = (bit_cast<unsigned int>(max_s) >> 23) - 127 + 15 + 1;
  	}
  
  	operator unsigned int() const
  	{
  		return *reinterpret_cast<const unsigned int *>(this);
  	}
  
  	void toRGB16F(half rgb[3]) const
  	{
  		constexpr int offset = 24;  // Exponent bias (15) + number of mantissa bits per component (9) = 24
  
  		const float factor = (1u << E) * (1.0f / (1 << offset));
  		rgb[0] = half(R * factor);
  		rgb[1] = half(G * factor);
  		rgb[2] = half(B * factor);
  	}
  };
  
  class R11G11B10F
  {
  public:
  	R11G11B10F(const float rgb[3])
  	{
  		R = float32ToFloat11(rgb[0]);
  		G = float32ToFloat11(rgb[1]);
  		B = float32ToFloat10(rgb[2]);
  	}
  
  	operator unsigned int() const
  	{
  		return *reinterpret_cast<const unsigned int *>(this);
  	}
  
  	void toRGB16F(half rgb[3]) const
  	{
  		rgb[0] = float11ToFloat16(R);
  		rgb[1] = float11ToFloat16(G);
  		rgb[2] = float10ToFloat16(B);
  	}
  
  	static inline half float11ToFloat16(unsigned short fp11)
  	{
  		return shortAsHalf(fp11 << 4);  // Sign bit 0
  	}
  
  	static inline half float10ToFloat16(unsigned short fp10)
  	{
  		return shortAsHalf(fp10 << 5);  // Sign bit 0
  	}
  
  	static inline unsigned short float32ToFloat11(float fp32)
  	{
  		const unsigned int float32MantissaMask = 0x7FFFFF;
  		const unsigned int float32ExponentMask = 0x7F800000;
  		const unsigned int float32SignMask = 0x80000000;
  		const unsigned int float32ValueMask = ~float32SignMask;
  		const unsigned int float32ExponentFirstBit = 23;
  		const unsigned int float32ExponentBias = 127;
  
  		const unsigned short float11Max = 0x7BF;
  		const unsigned short float11MantissaMask = 0x3F;
  		const unsigned short float11ExponentMask = 0x7C0;
  		const unsigned short float11BitMask = 0x7FF;
  		const unsigned int float11ExponentBias = 14;
  
  		const unsigned int float32Maxfloat11 = 0x477E0000;
  		const unsigned int float32MinNormfloat11 = 0x38800000;
  		const unsigned int float32MinDenormfloat11 = 0x35000080;
  
  		const unsigned int float32Bits = *reinterpret_cast<unsigned int *>(&fp32);
  		const bool float32Sign = (float32Bits & float32SignMask) == float32SignMask;
  
  		unsigned int float32Val = float32Bits & float32ValueMask;
  
  		if((float32Val & float32ExponentMask) == float32ExponentMask)
  		{
  			// INF or NAN
  			if((float32Val & float32MantissaMask) != 0)
  			{
  				return float11ExponentMask |
  				       (((float32Val >> 17) | (float32Val >> 11) | (float32Val >> 6) | (float32Val)) &
  				        float11MantissaMask);
  			}
  			else if(float32Sign)
  			{
  				// -INF is clamped to 0 since float11 is positive only
  				return 0;
  			}
  			else
  			{
  				return float11ExponentMask;
  			}
  		}
  		else if(float32Sign)
  		{
  			// float11 is positive only, so clamp to zero
  			return 0;
  		}
  		else if(float32Val > float32Maxfloat11)
  		{
  			// The number is too large to be represented as a float11, set to max
  			return float11Max;
  		}
  		else if(float32Val < float32MinDenormfloat11)
  		{
  			// The number is too small to be represented as a denormalized float11, set to 0
  			return 0;
  		}
  		else
  		{
  			if(float32Val < float32MinNormfloat11)
  			{
  				// The number is too small to be represented as a normalized float11
  				// Convert it to a denormalized value.
  				const unsigned int shift = (float32ExponentBias - float11ExponentBias) -
  				                           (float32Val >> float32ExponentFirstBit);
  				float32Val =
  				    ((1 << float32ExponentFirstBit) | (float32Val & float32MantissaMask)) >> shift;
  			}
  			else
  			{
  				// Rebias the exponent to represent the value as a normalized float11
  				float32Val += 0xC8000000;
  			}
  
  			return ((float32Val + 0xFFFF + ((float32Val >> 17) & 1)) >> 17) & float11BitMask;
  		}
  	}
  
  	static inline unsigned short float32ToFloat10(float fp32)
  	{
  		const unsigned int float32MantissaMask = 0x7FFFFF;
  		const unsigned int float32ExponentMask = 0x7F800000;
  		const unsigned int float32SignMask = 0x80000000;
  		const unsigned int float32ValueMask = ~float32SignMask;
  		const unsigned int float32ExponentFirstBit = 23;
  		const unsigned int float32ExponentBias = 127;
  
  		const unsigned short float10Max = 0x3DF;
  		const unsigned short float10MantissaMask = 0x1F;
  		const unsigned short float10ExponentMask = 0x3E0;
  		const unsigned short float10BitMask = 0x3FF;
  		const unsigned int float10ExponentBias = 14;
  
  		const unsigned int float32Maxfloat10 = 0x477C0000;
  		const unsigned int float32MinNormfloat10 = 0x38800000;
  		const unsigned int float32MinDenormfloat10 = 0x35800040;
  
  		const unsigned int float32Bits = *reinterpret_cast<unsigned int *>(&fp32);
  		const bool float32Sign = (float32Bits & float32SignMask) == float32SignMask;
  
  		unsigned int float32Val = float32Bits & float32ValueMask;
  
  		if((float32Val & float32ExponentMask) == float32ExponentMask)
  		{
  			// INF or NAN
  			if((float32Val & float32MantissaMask) != 0)
  			{
  				return float10ExponentMask |
  				       (((float32Val >> 18) | (float32Val >> 13) | (float32Val >> 3) | (float32Val)) &
  				        float10MantissaMask);
  			}
  			else if(float32Sign)
  			{
  				// -INF is clamped to 0 since float10 is positive only
  				return 0;
  			}
  			else
  			{
  				return float10ExponentMask;
  			}
  		}
  		else if(float32Sign)
  		{
  			// float10 is positive only, so clamp to zero
  			return 0;
  		}
  		else if(float32Val > float32Maxfloat10)
  		{
  			// The number is too large to be represented as a float10, set to max
  			return float10Max;
  		}
  		else if(float32Val < float32MinDenormfloat10)
  		{
  			// The number is too small to be represented as a denormalized float10, set to 0
  			return 0;
  		}
  		else
  		{
  			if(float32Val < float32MinNormfloat10)
  			{
  				// The number is too small to be represented as a normalized float10
  				// Convert it to a denormalized value.
  				const unsigned int shift = (float32ExponentBias - float10ExponentBias) -
  				                           (float32Val >> float32ExponentFirstBit);
  				float32Val =
  				    ((1 << float32ExponentFirstBit) | (float32Val & float32MantissaMask)) >> shift;
  			}
  			else
  			{
  				// Rebias the exponent to represent the value as a normalized float10
  				float32Val += 0xC8000000;
  			}
  
  			return ((float32Val + 0x1FFFF + ((float32Val >> 18) & 1)) >> 18) & float10BitMask;
  		}
  	}
  
  private:
  	unsigned int R : 11;
  	unsigned int G : 11;
  	unsigned int B : 10;
  };
  
  }  // namespace sw
  
  #endif  // sw_Half_hpp
  