source: trunk/src/half.h @ 882

Last change on this file since 882 was 882, checked in by sam, 9 years ago

core: reactivate half denormals for the PS3.

We know we will not have denormal floats on the PS3, but we should still
create denormal halves in case the other end (maybe the GPU?) knows how
to handle them.

  • Property svn:keywords set to Id
File size: 3.6 KB
Line 
1//
2// Lol Engine
3//
4// Copyright: (c) 2010-2011 Sam Hocevar <sam@hocevar.net>
5//   This program is free software; you can redistribute it and/or
6//   modify it under the terms of the Do What The Fuck You Want To
7//   Public License, Version 2, as published by Sam Hocevar. See
8//   http://sam.zoy.org/projects/COPYING.WTFPL for more details.
9//
10
11//
12// The Half class
13// --------------
14//
15
16#if !defined __LOL_HALF_H__
17#define __LOL_HALF_H__
18
19#include <cstdio>
20#include <stdint.h>
21
22namespace lol
23{
24
25class half
26{
27public:
28    /* Constructors. Always inline so that the code can work in registers
29     * instead of calling routines with the hidden "this" parameter. */
30    inline half() { }
31    inline half(float f) { *this = makefast(f); }
32
33    inline int is_nan() const
34    {
35        return ((bits & 0x7c00u) == 0x7c00u) && (bits & 0x03ffu);
36    }
37
38    inline int is_finite() const
39    {
40        return (bits & 0x7c00u) != 0x7c00u;
41    }
42
43    inline int is_inf() const
44    {
45        return (uint16_t)(bits << 1) == (0x7c00u << 1);
46    }
47
48    inline int is_normal() const
49    {
50        return (is_finite() && (bits & 0x7c00u)) || ((bits & 0x7fffu) == 0);
51    }
52
53    /* Cast to other types */
54    inline operator float() const { return tofloat(*this); }
55    inline operator int() const { return (int)tofloat(*this); }
56
57    static float tofloat(half h);
58
59    /* Array conversions */
60    static size_t convert(half *dst, float const *src, size_t nelem);
61    static size_t convert(float *dst, half const *src, size_t nelem);
62
63    /* Operations */
64    inline half operator -() { return makebits(bits ^ 0x8000u); }
65    inline half &operator +=(float f) { return (*this = (half)(*this + f)); }
66    inline half &operator -=(float f) { return (*this = (half)(*this - f)); }
67    inline half &operator *=(float f) { return (*this = (half)(*this * f)); }
68    inline half &operator /=(float f) { return (*this = (half)(*this / f)); }
69    inline half &operator +=(half h) { return (*this = (half)(*this + h)); }
70    inline half &operator -=(half h) { return (*this = (half)(*this - h)); }
71    inline half &operator *=(half h) { return (*this = (half)(*this * h)); }
72    inline half &operator /=(half h) { return (*this = (half)(*this / h)); }
73
74    inline float operator +(float f) const { return (float)*this + f; }
75    inline float operator -(float f) const { return (float)*this - f; }
76    inline float operator *(float f) const { return (float)*this * f; }
77    inline float operator /(float f) const { return (float)*this / f; }
78    inline float operator +(half h) const { return (float)*this + (float)h; }
79    inline float operator -(half h) const { return (float)*this - (float)h; }
80    inline float operator *(half h) const { return (float)*this * (float)h; }
81    inline float operator /(half h) const { return (float)*this / (float)h; }
82
83    /* Factories */
84    static half makefast(float f);
85    static half makeaccurate(float f);
86    static inline half makebits(uint16_t x)
87    {
88        half ret;
89        ret.bits = x;
90        return ret;
91    }
92
93    /* Internal representation */
94    uint16_t bits;
95};
96
97inline float &operator +=(float &f, half h) { return f += (float)h; }
98inline float &operator -=(float &f, half h) { return f -= (float)h; }
99inline float &operator *=(float &f, half h) { return f *= (float)h; }
100inline float &operator /=(float &f, half h) { return f /= (float)h; }
101
102inline float operator +(float f, half h) { return f + (float)h; }
103inline float operator -(float f, half h) { return f - (float)h; }
104inline float operator *(float f, half h) { return f * (float)h; }
105inline float operator /(float f, half h) { return f / (float)h; }
106
107} /* namespace lol */
108
109#endif // __LOL_HALF_H__
110
Note: See TracBrowser for help on using the repository browser.