@woosh/meep-engine
Version:
Pure JavaScript game engine. Fully featured and production ready.
67 lines (47 loc) • 2.1 kB
JavaScript
const _floatView = new Float32Array(1);
const _int32View = new Int32Array(_floatView.buffer);
/**
* Converts float32 to float16 (encoded as uint16 value).
* @param {number} val
* @returns {number}
*/
export function to_half_float_uint16(val) {
let _val = val;
if (_val > 65504) {
console.warn('to_half_float_uint16(): value exceeds 65504.');
_val = 65504; // maximum representable value in float16
}
// Source: http://gamedev.stackexchange.com/questions/17326/conversion-of-a-number-from-single-precision-floating-point-representation-to-a/17410#17410
/*
This method is faster than the OpenEXR implementation (very often used, eg. in Ogre),
with the additional benefit of rounding, inspired by James Tursa's half-precision code.
*/
_floatView[0] = _val;
const x = _int32View[0];
let bits = (x >> 16) & 0x8000; /* Get the sign */
let m = (x >> 12) & 0x07ff; /* Keep one extra bit for rounding */
const e = (x >> 23) & 0xff; /* Using int is faster here */
/* If zero, or denormal, or exponent underflows too much for a denormal
* half, return signed zero. */
if (e < 103) return bits;
/* If NaN, return NaN. If Inf or exponent overflow, return Inf. */
if (e > 142) {
bits |= 0x7c00;
/* If exponent was 0xff and one mantissa bit was set, it means NaN,
* not Inf, so make sure we set one mantissa bit too. */
bits |= ((e === 255) ? 0 : 1) && (x & 0x007fffff);
return bits;
}
/* If exponent underflows but not too much, return a denormal */
if (e < 113) {
m |= 0x0800;
/* Extra rounding may overflow and set mantissa to 0 and exponent
* to 1, which is OK. */
bits |= (m >> (114 - e)) + ((m >> (113 - e)) & 1);
return bits;
}
bits |= ((e - 112) << 10) | (m >> 1);
/* Extra rounding. An overflow will set mantissa to 0 and increment the exponent, which is OK. */
bits += m & 1;
return bits;
}