workaround.hpp

#pragma once

// Removed after upgrading to GLM 0.9.8
namespace gli{
namespace workaround{
namespace detail
{
        union u3u3u2
        {
                struct
                {
                        uint x : 3;
                        uint y : 3;
                        uint z : 2;
                } data;
                uint8 pack;
        };

        union u4u4
        {
                struct
                {
                        uint x : 4;
                        uint y : 4;
                } data;
                uint8 pack;
        };

        union u4u4u4u4
        {
                struct
                {
                        uint x : 4;
                        uint y : 4;
                        uint z : 4;
                        uint w : 4;
                } data;
                uint16 pack;
        };

        union u5u6u5
        {
                struct
                {
                        uint x : 5;
                        uint y : 6;
                        uint z : 5;
                } data;
                uint16 pack;
        };

        union u5u5u5u1
        {
                struct
                {
                        uint x : 5;
                        uint y : 5;
                        uint z : 5;
                        uint w : 1;
                } data;
                uint16 pack;
        };

        union u9u9u9e5
        {
                struct
                {
                        uint x : 9;
                        uint y : 9;
                        uint z : 9;
                        uint w : 5;
                } data;
                uint32 pack;
        };

        template <typename T, typename floatType, precision P, template <typename, precision> class vecType, bool isInteger, bool signedType>
        struct compute_compNormalize
        {};

        template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
        struct compute_compNormalize<T, floatType, P, vecType, true, true>
        {
                GLM_FUNC_QUALIFIER static vecType<floatType, P> call(vecType<T, P> const & v)
                {
                        floatType const Min = static_cast<floatType>(std::numeric_limits<T>::min());
                        floatType const Max = static_cast<floatType>(std::numeric_limits<T>::max());
                        return (vecType<floatType, P>(v) - Min) / (Max - Min) * static_cast<floatType>(2) - static_cast<floatType>(1);
                }
        };

        template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
        struct compute_compNormalize<T, floatType, P, vecType, true, false>
        {
                GLM_FUNC_QUALIFIER static vecType<floatType, P> call(vecType<T, P> const & v)
                {
                        return vecType<floatType, P>(v) / static_cast<floatType>(std::numeric_limits<T>::max());
                }
        };

        template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
        struct compute_compNormalize<T, floatType, P, vecType, false, true>
        {
                GLM_FUNC_QUALIFIER static vecType<floatType, P> call(vecType<T, P> const & v)
                {
                        return v;
                }
        };

        template <typename T, typename floatType, precision P, template <typename, precision> class vecType, bool isInteger, bool signedType>
        struct compute_compScale
        {};

        template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
        struct compute_compScale<T, floatType, P, vecType, true, true>
        {
                GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<floatType, P> const & v)
                {
                        floatType const Max = static_cast<floatType>(std::numeric_limits<T>::max()) + static_cast<floatType>(0.5);
                        vecType<floatType, P> const Scaled(v * Max);
                        vecType<T, P> const Result(Scaled - static_cast<floatType>(0.5));
                        return Result;
                }
        };

        template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
        struct compute_compScale<T, floatType, P, vecType, true, false>
        {
                GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<floatType, P> const & v)
                {
                        return vecType<T, P>(vecType<floatType, P>(v) * static_cast<floatType>(std::numeric_limits<T>::max()));
                }
        };

        template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
        struct compute_compScale<T, floatType, P, vecType, false, true>
        {
                GLM_FUNC_QUALIFIER static vecType<T, P> call(vecType<floatType, P> const & v)
                {
                        return v;
                }
        };

        template <precision P, template <typename, precision> class vecType>
        struct compute_half
        {};

        template <precision P>
        struct compute_half<P, tvec1>
        {
                GLM_FUNC_QUALIFIER static tvec1<uint16, P> pack(tvec1<float, P> const & v)
                {
                        int16 const Unpacked(glm::detail::toFloat16(v.x));
                        return tvec1<uint16, P>(reinterpret_cast<uint16 const &>(Unpacked));
                }

                GLM_FUNC_QUALIFIER static tvec1<float, P> unpack(tvec1<uint16, P> const & v)
                {
                        return tvec1<float, P>(glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.x)));
                }
        };

        template <precision P>
        struct compute_half<P, tvec2>
        {
                GLM_FUNC_QUALIFIER static tvec2<uint16, P> pack(tvec2<float, P> const & v)
                {
                        tvec2<int16, P> const Unpacked(glm::detail::toFloat16(v.x), glm::detail::toFloat16(v.y));
                        return tvec2<uint16, P>(
                                reinterpret_cast<uint16 const &>(Unpacked.x),
                                reinterpret_cast<uint16 const &>(Unpacked.y));
                }

                GLM_FUNC_QUALIFIER static tvec2<float, P> unpack(tvec2<uint16, P> const & v)
                {
                        return tvec2<float, P>(
                                glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.x)),
                                glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.y)));
                }
        };

        template <precision P>
        struct compute_half<P, tvec3>
        {
                GLM_FUNC_QUALIFIER static tvec3<uint16, P> pack(tvec3<float, P> const & v)
                {
                        tvec3<int16, P> const Unpacked(glm::detail::toFloat16(v.x), glm::detail::toFloat16(v.y), glm::detail::toFloat16(v.z));
                        return tvec3<uint16, P>(
                                reinterpret_cast<uint16 const &>(Unpacked.x),
                                reinterpret_cast<uint16 const &>(Unpacked.y),
                                reinterpret_cast<uint16 const &>(Unpacked.z));
                }

                GLM_FUNC_QUALIFIER static tvec3<float, P> unpack(tvec3<uint16, P> const & v)
                {
                        return tvec3<float, P>(
                                glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.x)),
                                glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.y)),
                                glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.z)));
                }
        };

        template <precision P>
        struct compute_half<P, tvec4>
        {
                GLM_FUNC_QUALIFIER static tvec4<uint16, P> pack(tvec4<float, P> const & v)
                {
                        tvec4<int16, P> const Unpacked(glm::detail::toFloat16(v.x), glm::detail::toFloat16(v.y), glm::detail::toFloat16(v.z), glm::detail::toFloat16(v.w));
                        return tvec4<uint16, P>(
                                reinterpret_cast<uint16 const &>(Unpacked.x),
                                reinterpret_cast<uint16 const &>(Unpacked.y),
                                reinterpret_cast<uint16 const &>(Unpacked.z),
                                reinterpret_cast<uint16 const &>(Unpacked.w));
                }

                GLM_FUNC_QUALIFIER static tvec4<float, P> unpack(tvec4<uint16, P> const & v)
                {
                        return tvec4<float, P>(
                                glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.x)),
                                glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.y)),
                                glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.z)),
                                glm::detail::toFloat32(reinterpret_cast<int16 const &>(v.w)));
                }
        };
}//namespace detail

        template <typename floatType, typename T, precision P, template <typename, precision> class vecType>
        GLM_FUNC_QUALIFIER vecType<floatType, P> compNormalize(vecType<T, P> const & v)
        {
                GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "'compNormalize' accepts only floating-point types for 'floatType' template parameter");

                return detail::compute_compNormalize<T, floatType, P, vecType, std::numeric_limits<T>::is_integer, std::numeric_limits<T>::is_signed>::call(v);
        }

        template <typename T, typename floatType, precision P, template <typename, precision> class vecType>
        GLM_FUNC_QUALIFIER vecType<T, P> compScale(vecType<floatType, P> const & v)
        {
                GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "'compScale' accepts only floating-point types for 'floatType' template parameter");

                return detail::compute_compScale<T, floatType, P, vecType, std::numeric_limits<T>::is_integer, std::numeric_limits<T>::is_signed>::call(v);
        }

        template <typename uintType, typename floatType, precision P, template <typename, precision> class vecType>
        GLM_FUNC_QUALIFIER vecType<uintType, P> packUnorm(vecType<floatType, P> const & v)
        {
                GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
                GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");

                return vecType<uintType, P>(round(clamp(v, static_cast<floatType>(0), static_cast<floatType>(1)) * static_cast<floatType>(std::numeric_limits<uintType>::max())));
        }

        template <typename uintType, typename floatType, precision P, template <typename, precision> class vecType>
        GLM_FUNC_QUALIFIER vecType<floatType, P> unpackUnorm(vecType<uintType, P> const & v)
        {
                GLM_STATIC_ASSERT(std::numeric_limits<uintType>::is_integer, "uintType must be an integer type");
                GLM_STATIC_ASSERT(std::numeric_limits<floatType>::is_iec559, "floatType must be a floating point type");

                return vecType<float, P>(v) * (static_cast<floatType>(1) / static_cast<floatType>(std::numeric_limits<uintType>::max()));
        }

        GLM_FUNC_QUALIFIER uint8 packUnorm2x3_1x2(vec3 const & v)
        {
                u32vec3 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec3(7.f, 7.f, 3.f)));
                detail::u3u3u2 Result;
                Result.data.x = Unpack.x;
                Result.data.y = Unpack.y;
                Result.data.z = Unpack.z;
                return Result.pack;
        }

        GLM_FUNC_QUALIFIER vec3 unpackUnorm2x3_1x2(uint8 v)
        {
                vec3 const ScaleFactor(1.f / 7.f, 1.f / 7.f, 1.f / 3.f);
                detail::u3u3u2 Unpack;
                Unpack.pack = v;
                return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * ScaleFactor;
        }

        GLM_FUNC_QUALIFIER uint8 packUnorm2x4(vec2 const & v)
        {
                u32vec2 const Unpack(round(clamp(v, 0.0f, 1.0f) * 15.0f));
                detail::u4u4 Result;
                Result.data.x = Unpack.x;
                Result.data.y = Unpack.y;
                return Result.pack;
        }

        GLM_FUNC_QUALIFIER vec2 unpackUnorm2x4(uint8 v)
        {
                float const ScaleFactor(1.f / 15.f);
                detail::u4u4 Unpack;
                Unpack.pack = v;
                return vec2(Unpack.data.x, Unpack.data.y) * ScaleFactor;
        }

        GLM_FUNC_QUALIFIER uint16 packUnorm4x4(vec4 const & v)
        {
                u32vec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * 15.0f));
                detail::u4u4u4u4 Result;
                Result.data.x = Unpack.x;
                Result.data.y = Unpack.y;
                Result.data.z = Unpack.z;
                Result.data.w = Unpack.w;
                return Result.pack;
        }

        GLM_FUNC_QUALIFIER vec4 unpackUnorm4x4(uint16 v)
        {
                float const ScaleFactor(1.f / 15.f);
                detail::u4u4u4u4 Unpack;
                Unpack.pack = v;
                return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactor;
        }

        GLM_FUNC_QUALIFIER uint16 packUnorm3x5_1x1(vec4 const & v)
        {
                u32vec4 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec4(15.f, 15.f, 15.f, 1.f)));
                detail::u5u5u5u1 Result;
                Result.data.x = Unpack.x;
                Result.data.y = Unpack.y;
                Result.data.z = Unpack.z;
                Result.data.w = Unpack.w;
                return Result.pack;
        }

        GLM_FUNC_QUALIFIER vec4 unpackUnorm3x5_1x1(uint16 v)
        {
                vec4 const ScaleFactor(1.f / 15.f, 1.f / 15.f, 1.f / 15.f, 1.f);
                detail::u5u5u5u1 Unpack;
                Unpack.pack = v;
                return vec4(Unpack.data.x, Unpack.data.y, Unpack.data.z, Unpack.data.w) * ScaleFactor;
        }

        GLM_FUNC_QUALIFIER uint16 packUnorm1x5_1x6_1x5(vec3 const & v)
        {
                u32vec3 const Unpack(round(clamp(v, 0.0f, 1.0f) * vec3(15.f, 31.f, 15.f)));
                detail::u5u6u5 Result;
                Result.data.x = Unpack.x;
                Result.data.y = Unpack.y;
                Result.data.z = Unpack.z;
                return Result.pack;
        }

        GLM_FUNC_QUALIFIER vec3 unpackUnorm1x5_1x6_1x5(uint16 v)
        {
                vec3 const ScaleFactor(1.f / 15.f, 1.f / 31.f, 1.f / 15.f);
                detail::u5u6u5 Unpack;
                Unpack.pack = v;
                return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * ScaleFactor;
        }

        GLM_FUNC_QUALIFIER uint32 packF3x9_E1x5(vec3 const & v)
        {
                float const SharedExpMax = (pow(2.0f, 9.0f - 1.0f) / pow(2.0f, 9.0f)) * pow(2.0f, 31.f - 15.f);
                vec3 const Color = clamp(v, 0.0f, SharedExpMax);
                float const MaxColor = max(Color.x, max(Color.y, Color.z));

                float const ExpSharedP = max(-15.f - 1.f, floor(log2(MaxColor))) + 1.0f + 15.f;
                float const MaxShared = floor(MaxColor / pow(2.0f, (ExpSharedP - 16.f - 9.f)) + 0.5f);
                float const ExpShared = MaxShared == pow(2.0f, 9.0f) ? ExpSharedP + 1.0f : ExpSharedP;

                uvec3 const ColorComp(floor(Color / pow(2.f, (ExpShared - 15.f - 9.f)) + 0.5f));

                detail::u9u9u9e5 Unpack;
                Unpack.data.x = ColorComp.x;
                Unpack.data.y = ColorComp.y;
                Unpack.data.z = ColorComp.z;
                Unpack.data.w = uint(ExpShared);
                return Unpack.pack;
        }

        GLM_FUNC_QUALIFIER vec3 unpackF3x9_E1x5(uint32 v)
        {
                detail::u9u9u9e5 Unpack;
                Unpack.pack = v;

                return vec3(Unpack.data.x, Unpack.data.y, Unpack.data.z) * pow(2.0f, Unpack.data.w - 15.f - 9.f);
        }

        template <precision P, template <typename, precision> class vecType>
        GLM_FUNC_QUALIFIER vecType<uint16, P> packHalf(vecType<float, P> const & v)
        {
                return detail::compute_half<P, vecType>::pack(v);
        }

        template <precision P, template <typename, precision> class vecType>
        GLM_FUNC_QUALIFIER vecType<float, P> unpackHalf(vecType<uint16, P> const & v)
        {
                return detail::compute_half<P, vecType>::unpack(v);
        }
}//namespace workaround
}//namespace gli