| /////////////////////////////////////////////////////////////////////////////////// |
| /// OpenGL Mathematics (glm.g-truc.net) |
| /// |
| /// Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net) |
| /// Permission is hereby granted, free of charge, to any person obtaining a copy |
| /// of this software and associated documentation files (the "Software"), to deal |
| /// in the Software without restriction, including without limitation the rights |
| /// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| /// copies of the Software, and to permit persons to whom the Software is |
| /// furnished to do so, subject to the following conditions: |
| /// |
| /// The above copyright notice and this permission notice shall be included in |
| /// all copies or substantial portions of the Software. |
| /// |
| /// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| /// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| /// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| /// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| /// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| /// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
| /// THE SOFTWARE. |
| /// |
| /// @ref gtc_packing |
| /// @file glm/gtc/packing.inl |
| /// @date 2013-08-08 / 2013-08-08 |
| /// @author Christophe Riccio |
| /////////////////////////////////////////////////////////////////////////////////// |
| |
| #include "../common.hpp" |
| #include "../vec2.hpp" |
| #include "../vec3.hpp" |
| #include "../vec4.hpp" |
| #include "../detail/type_half.hpp" |
| |
| namespace glm{ |
| namespace detail |
| { |
| GLM_FUNC_QUALIFIER glm::uint16 float2half(glm::uint32 const & f) |
| { |
| // 10 bits => EE EEEFFFFF |
| // 11 bits => EEE EEFFFFFF |
| // Half bits => SEEEEEFF FFFFFFFF |
| // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF |
| |
| // 0x00007c00 => 00000000 00000000 01111100 00000000 |
| // 0x000003ff => 00000000 00000000 00000011 11111111 |
| // 0x38000000 => 00111000 00000000 00000000 00000000 |
| // 0x7f800000 => 01111111 10000000 00000000 00000000 |
| // 0x00008000 => 00000000 00000000 10000000 00000000 |
| return |
| ((f >> 16) & 0x8000) | // sign |
| ((((f & 0x7f800000) - 0x38000000) >> 13) & 0x7c00) | // exponential |
| ((f >> 13) & 0x03ff); // Mantissa |
| } |
| |
| GLM_FUNC_QUALIFIER glm::uint32 float2packed11(glm::uint32 const & f) |
| { |
| // 10 bits => EE EEEFFFFF |
| // 11 bits => EEE EEFFFFFF |
| // Half bits => SEEEEEFF FFFFFFFF |
| // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF |
| |
| // 0x000007c0 => 00000000 00000000 00000111 11000000 |
| // 0x00007c00 => 00000000 00000000 01111100 00000000 |
| // 0x000003ff => 00000000 00000000 00000011 11111111 |
| // 0x38000000 => 00111000 00000000 00000000 00000000 |
| // 0x7f800000 => 01111111 10000000 00000000 00000000 |
| // 0x00008000 => 00000000 00000000 10000000 00000000 |
| return |
| ((((f & 0x7f800000) - 0x38000000) >> 17) & 0x07c0) | // exponential |
| ((f >> 17) & 0x003f); // Mantissa |
| } |
| |
| GLM_FUNC_QUALIFIER glm::uint32 packed11ToFloat(glm::uint32 const & p) |
| { |
| // 10 bits => EE EEEFFFFF |
| // 11 bits => EEE EEFFFFFF |
| // Half bits => SEEEEEFF FFFFFFFF |
| // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF |
| |
| // 0x000007c0 => 00000000 00000000 00000111 11000000 |
| // 0x00007c00 => 00000000 00000000 01111100 00000000 |
| // 0x000003ff => 00000000 00000000 00000011 11111111 |
| // 0x38000000 => 00111000 00000000 00000000 00000000 |
| // 0x7f800000 => 01111111 10000000 00000000 00000000 |
| // 0x00008000 => 00000000 00000000 10000000 00000000 |
| return |
| ((((p & 0x07c0) << 17) + 0x38000000) & 0x7f800000) | // exponential |
| ((p & 0x003f) << 17); // Mantissa |
| } |
| |
| GLM_FUNC_QUALIFIER glm::uint32 float2packed10(glm::uint32 const & f) |
| { |
| // 10 bits => EE EEEFFFFF |
| // 11 bits => EEE EEFFFFFF |
| // Half bits => SEEEEEFF FFFFFFFF |
| // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF |
| |
| // 0x0000001F => 00000000 00000000 00000000 00011111 |
| // 0x0000003F => 00000000 00000000 00000000 00111111 |
| // 0x000003E0 => 00000000 00000000 00000011 11100000 |
| // 0x000007C0 => 00000000 00000000 00000111 11000000 |
| // 0x00007C00 => 00000000 00000000 01111100 00000000 |
| // 0x000003FF => 00000000 00000000 00000011 11111111 |
| // 0x38000000 => 00111000 00000000 00000000 00000000 |
| // 0x7f800000 => 01111111 10000000 00000000 00000000 |
| // 0x00008000 => 00000000 00000000 10000000 00000000 |
| return |
| ((((f & 0x7f800000) - 0x38000000) >> 18) & 0x03E0) | // exponential |
| ((f >> 18) & 0x001f); // Mantissa |
| } |
| |
| GLM_FUNC_QUALIFIER glm::uint32 packed10ToFloat(glm::uint32 const & p) |
| { |
| // 10 bits => EE EEEFFFFF |
| // 11 bits => EEE EEFFFFFF |
| // Half bits => SEEEEEFF FFFFFFFF |
| // Float bits => SEEEEEEE EFFFFFFF FFFFFFFF FFFFFFFF |
| |
| // 0x0000001F => 00000000 00000000 00000000 00011111 |
| // 0x0000003F => 00000000 00000000 00000000 00111111 |
| // 0x000003E0 => 00000000 00000000 00000011 11100000 |
| // 0x000007C0 => 00000000 00000000 00000111 11000000 |
| // 0x00007C00 => 00000000 00000000 01111100 00000000 |
| // 0x000003FF => 00000000 00000000 00000011 11111111 |
| // 0x38000000 => 00111000 00000000 00000000 00000000 |
| // 0x7f800000 => 01111111 10000000 00000000 00000000 |
| // 0x00008000 => 00000000 00000000 10000000 00000000 |
| return |
| ((((p & 0x03E0) << 18) + 0x38000000) & 0x7f800000) | // exponential |
| ((p & 0x001f) << 18); // Mantissa |
| } |
| |
| GLM_FUNC_QUALIFIER glm::uint half2float(glm::uint const & h) |
| { |
| return ((h & 0x8000) << 16) | ((( h & 0x7c00) + 0x1C000) << 13) | ((h & 0x03FF) << 13); |
| } |
| |
| GLM_FUNC_QUALIFIER glm::uint floatTo11bit(float x) |
| { |
| if(x == 0.0f) |
| return 0; |
| else if(glm::isnan(x)) |
| return ~0; |
| else if(glm::isinf(x)) |
| return 0x1f << 6; |
| |
| return float2packed11(reinterpret_cast<uint&>(x)); |
| } |
| |
| GLM_FUNC_QUALIFIER float packed11bitToFloat(glm::uint x) |
| { |
| if(x == 0) |
| return 0.0f; |
| else if(x == ((1 << 11) - 1)) |
| return ~0;//NaN |
| else if(x == (0x1f << 6)) |
| return ~0;//Inf |
| |
| uint result = packed11ToFloat(x); |
| return reinterpret_cast<float&>(result); |
| } |
| |
| GLM_FUNC_QUALIFIER glm::uint floatTo10bit(float x) |
| { |
| if(x == 0.0f) |
| return 0; |
| else if(glm::isnan(x)) |
| return ~0; |
| else if(glm::isinf(x)) |
| return 0x1f << 5; |
| |
| return float2packed10(reinterpret_cast<uint&>(x)); |
| } |
| |
| GLM_FUNC_QUALIFIER float packed10bitToFloat(glm::uint x) |
| { |
| if(x == 0) |
| return 0.0f; |
| else if(x == ((1 << 10) - 1)) |
| return ~0;//NaN |
| else if(x == (0x1f << 5)) |
| return ~0;//Inf |
| |
| uint result = packed10ToFloat(x); |
| return reinterpret_cast<float&>(result); |
| } |
| |
| // GLM_FUNC_QUALIFIER glm::uint f11_f11_f10(float x, float y, float z) |
| // { |
| // return ((floatTo11bit(x) & ((1 << 11) - 1)) << 0) | ((floatTo11bit(y) & ((1 << 11) - 1)) << 11) | ((floatTo10bit(z) & ((1 << 10) - 1)) << 22); |
| // } |
| |
| union u10u10u10u2 |
| { |
| struct |
| { |
| uint x : 10; |
| uint y : 10; |
| uint z : 10; |
| uint w : 2; |
| } data; |
| uint32 pack; |
| }; |
| |
| union i10i10i10i2 |
| { |
| struct |
| { |
| int x : 10; |
| int y : 10; |
| int z : 10; |
| int w : 2; |
| } data; |
| uint32 pack; |
| }; |
| |
| }//namespace detail |
| |
| GLM_FUNC_QUALIFIER uint8 packUnorm1x8(float const & v) |
| { |
| return static_cast<uint8>(round(clamp(v, 0.0f, 1.0f) * 255.0f)); |
| } |
| |
| GLM_FUNC_QUALIFIER float unpackUnorm1x8(uint8 const & p) |
| { |
| float Unpack(static_cast<float>(p)); |
| return Unpack * static_cast<float>(0.0039215686274509803921568627451); // 1 / 255 |
| } |
| |
| GLM_FUNC_QUALIFIER uint16 packUnorm2x8(vec2 const & v) |
| { |
| u8vec2 Topack(round(clamp(v, 0.0f, 1.0f) * 255.0f)); |
| uint16* Packed = reinterpret_cast<uint16*>(&Topack); |
| return *Packed; |
| } |
| |
| GLM_FUNC_QUALIFIER vec2 unpackUnorm2x8(uint16 const & p) |
| { |
| u8vec2* Unpacked = reinterpret_cast<u8vec2*>(const_cast<uint16*>(&p)); |
| return vec2(*Unpacked) * float(0.0039215686274509803921568627451); // 1 / 255 |
| } |
| |
| GLM_FUNC_QUALIFIER uint8 packSnorm1x8(float const & v) |
| { |
| int8 Topack(static_cast<int8>(round(clamp(v ,-1.0f, 1.0f) * 127.0f))); |
| uint8* Packed = reinterpret_cast<uint8*>(&Topack); |
| return *Packed; |
| } |
| |
| GLM_FUNC_QUALIFIER float unpackSnorm1x8(uint8 const & p) |
| { |
| float Unpack(static_cast<float>(*const_cast<uint8*>(&p))); |
| return clamp( |
| Unpack * 0.00787401574803149606299212598425f, // 1.0f / 127.0f |
| -1.0f, 1.0f); |
| } |
| |
| GLM_FUNC_QUALIFIER uint16 packSnorm2x8(vec2 const & v) |
| { |
| i8vec2 Topack(round(clamp(v ,-1.0f, 1.0f) * 127.0f)); |
| uint16* Packed = reinterpret_cast<uint16*>(&Topack); |
| return *Packed; |
| } |
| |
| GLM_FUNC_QUALIFIER vec2 unpackSnorm2x8(uint16 const & p) |
| { |
| i8vec2* Unpack = reinterpret_cast<i8vec2*>(const_cast<uint16*>(&p)); |
| return clamp( |
| vec2(*Unpack) * 0.00787401574803149606299212598425f, // 1.0f / 127.0f |
| -1.0f, 1.0f); |
| } |
| |
| GLM_FUNC_QUALIFIER uint16 packUnorm1x16(float const & s) |
| { |
| return static_cast<uint16>(round(clamp(s, 0.0f, 1.0f) * 65535.0f)); |
| } |
| |
| GLM_FUNC_QUALIFIER float unpackUnorm1x16(uint16 const & p) |
| { |
| float Unpack = static_cast<float>(*const_cast<uint16*>(&p)); |
| return Unpack * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0 |
| } |
| |
| GLM_FUNC_QUALIFIER uint64 packUnorm4x16(vec4 const & v) |
| { |
| u16vec4 Topack(round(clamp(v , 0.0f, 1.0f) * 65535.0f)); |
| uint64* Packed = reinterpret_cast<uint64*>(&Topack); |
| return *Packed; |
| } |
| |
| GLM_FUNC_QUALIFIER vec4 unpackUnorm4x16(uint64 const & p) |
| { |
| u16vec4* Unpack = reinterpret_cast<u16vec4*>(const_cast<uint64*>(&p)); |
| return vec4(*Unpack) * 1.5259021896696421759365224689097e-5f; // 1.0 / 65535.0 |
| } |
| |
| GLM_FUNC_QUALIFIER uint16 packSnorm1x16(float const & v) |
| { |
| int16 Topack = static_cast<int16>(round(clamp(v ,-1.0f, 1.0f) * 32767.0f)); |
| uint16* Packed = reinterpret_cast<uint16*>(&Topack); |
| return *Packed; |
| } |
| |
| GLM_FUNC_QUALIFIER float unpackSnorm1x16(uint16 const & p) |
| { |
| float Unpack = static_cast<float>(*const_cast<uint16*>(&p)); |
| return clamp( |
| Unpack * 3.0518509475997192297128208258309e-5f, //1.0f / 32767.0f, |
| -1.0f, 1.0f); |
| } |
| |
| GLM_FUNC_QUALIFIER uint64 packSnorm4x16(vec4 const & v) |
| { |
| i16vec4 Topack = static_cast<i16vec4>(round(clamp(v ,-1.0f, 1.0f) * 32767.0f)); |
| uint64* Packed = reinterpret_cast<uint64*>(&Topack); |
| return *Packed; |
| } |
| |
| GLM_FUNC_QUALIFIER vec4 unpackSnorm4x16(uint64 const & p) |
| { |
| i16vec4* Unpack(reinterpret_cast<i16vec4*>(const_cast<uint64*>(&p))); |
| return clamp( |
| vec4(*Unpack) * 3.0518509475997192297128208258309e-5f, //1.0f / 32767.0f, |
| -1.0f, 1.0f); |
| } |
| |
| GLM_FUNC_QUALIFIER uint16 packHalf1x16(float const & v) |
| { |
| int16 Topack = detail::toFloat16(v); |
| uint16* Packed = reinterpret_cast<uint16*>(&Topack); |
| return *Packed; |
| } |
| |
| GLM_FUNC_QUALIFIER float unpackHalf1x16(uint16 const & v) |
| { |
| int16* Unpack = reinterpret_cast<int16*>(const_cast<uint16*>(&v)); |
| return detail::toFloat32(*Unpack); |
| } |
| |
| GLM_FUNC_QUALIFIER uint64 packHalf4x16(glm::vec4 const & v) |
| { |
| i16vec4 Unpack( |
| detail::toFloat16(v.x), |
| detail::toFloat16(v.y), |
| detail::toFloat16(v.z), |
| detail::toFloat16(v.w)); |
| |
| uint64* Packed = reinterpret_cast<uint64*>(&Unpack); |
| return *Packed; |
| } |
| |
| GLM_FUNC_QUALIFIER glm::vec4 unpackHalf4x16(uint64 const & v) |
| { |
| i16vec4* p = reinterpret_cast<i16vec4*>(const_cast<uint64*>(&v)); |
| i16vec4 Unpack(*p); |
| |
| return vec4( |
| detail::toFloat32(Unpack.x), |
| detail::toFloat32(Unpack.y), |
| detail::toFloat32(Unpack.z), |
| detail::toFloat32(Unpack.w)); |
| } |
| |
| GLM_FUNC_QUALIFIER uint32 packI3x10_1x2(ivec4 const & v) |
| { |
| detail::i10i10i10i2 Result; |
| Result.data.x = v.x; |
| Result.data.y = v.y; |
| Result.data.z = v.z; |
| Result.data.w = v.w; |
| return Result.pack; |
| } |
| |
| GLM_FUNC_QUALIFIER ivec4 unpackI3x10_1x2(uint32 const & v) |
| { |
| detail::i10i10i10i2 Unpack; |
| Unpack.pack = v; |
| return ivec4( |
| Unpack.data.x, |
| Unpack.data.y, |
| Unpack.data.z, |
| Unpack.data.w); |
| } |
| |
| GLM_FUNC_QUALIFIER uint32 packU3x10_1x2(uvec4 const & v) |
| { |
| detail::u10u10u10u2 Result; |
| Result.data.x = v.x; |
| Result.data.y = v.y; |
| Result.data.z = v.z; |
| Result.data.w = v.w; |
| return Result.pack; |
| } |
| |
| GLM_FUNC_QUALIFIER uvec4 unpackU3x10_1x2(uint32 const & v) |
| { |
| detail::u10u10u10u2 Unpack; |
| Unpack.pack = v; |
| return uvec4( |
| Unpack.data.x, |
| Unpack.data.y, |
| Unpack.data.z, |
| Unpack.data.w); |
| } |
| |
| GLM_FUNC_QUALIFIER uint32 packSnorm3x10_1x2(vec4 const & v) |
| { |
| detail::i10i10i10i2 Result; |
| Result.data.x = int(round(clamp(v.x,-1.0f, 1.0f) * 511.f)); |
| Result.data.y = int(round(clamp(v.y,-1.0f, 1.0f) * 511.f)); |
| Result.data.z = int(round(clamp(v.z,-1.0f, 1.0f) * 511.f)); |
| Result.data.w = int(round(clamp(v.w,-1.0f, 1.0f) * 1.f)); |
| return Result.pack; |
| } |
| |
| GLM_FUNC_QUALIFIER vec4 unpackSnorm3x10_1x2(uint32 const & v) |
| { |
| detail::i10i10i10i2 Unpack; |
| Unpack.pack = v; |
| vec4 Result; |
| Result.x = clamp(float(Unpack.data.x) / 511.f, -1.0f, 1.0f); |
| Result.y = clamp(float(Unpack.data.y) / 511.f, -1.0f, 1.0f); |
| Result.z = clamp(float(Unpack.data.z) / 511.f, -1.0f, 1.0f); |
| Result.w = clamp(float(Unpack.data.w) / 1.f, -1.0f, 1.0f); |
| return Result; |
| } |
| |
| GLM_FUNC_QUALIFIER uint32 packUnorm3x10_1x2(vec4 const & v) |
| { |
| detail::i10i10i10i2 Result; |
| Result.data.x = int(round(clamp(v.x, 0.0f, 1.0f) * 1023.f)); |
| Result.data.y = int(round(clamp(v.y, 0.0f, 1.0f) * 1023.f)); |
| Result.data.z = int(round(clamp(v.z, 0.0f, 1.0f) * 1023.f)); |
| Result.data.w = int(round(clamp(v.w, 0.0f, 1.0f) * 3.f)); |
| return Result.pack; |
| } |
| |
| GLM_FUNC_QUALIFIER vec4 unpackUnorm3x10_1x2(uint32 const & v) |
| { |
| detail::i10i10i10i2 Unpack; |
| Unpack.pack = v; |
| vec4 Result; |
| Result.x = float(Unpack.data.x) / 1023.f; |
| Result.y = float(Unpack.data.y) / 1023.f; |
| Result.z = float(Unpack.data.z) / 1023.f; |
| Result.w = float(Unpack.data.w) / 3.f; |
| return Result; |
| } |
| |
| GLM_FUNC_QUALIFIER uint32 packF2x11_1x10(vec3 const & v) |
| { |
| return |
| ((detail::floatTo11bit(v.x) & ((1 << 11) - 1)) << 0) | |
| ((detail::floatTo11bit(v.y) & ((1 << 11) - 1)) << 11) | |
| ((detail::floatTo10bit(v.z) & ((1 << 10) - 1)) << 22); |
| } |
| |
| GLM_FUNC_QUALIFIER vec3 unpackF2x11_1x10(uint32 const & v) |
| { |
| return vec3( |
| detail::packed11bitToFloat(v >> 0), |
| detail::packed11bitToFloat(v >> 11), |
| detail::packed10bitToFloat(v >> 22)); |
| } |
| |
| }//namespace glm |