Mathf.FloatToHalf

Hello!

I found these functions in Mathf struct:

Code (CSharp):

1. public static ushort FloatToHalf(float val);
2. public static float HalfToFloat(ushort val);

I would be highly interested for networking paquets compression purposes and other topics, but I literally didn't find anything on Internet about it.
I'd like to know how reliable it is, on which platforms it works, and if it will always be there in future releases. Bonus points if there is also information on performance (garbage generation?), but this I could try it myself (however on all wanted platforms, it could be long).

Also, it's totally unrelated but why is Mathf a struct and not a static class?

Thank you in advance!

 

Its because all the backend of Unity is written in c++. And unless your using Managed c++ which I doubt they are, you can't create static classes in c++. So they used a struct instead of a class with static methods in them.

 

If it's not documented, then there are no guarantees about anything and using it would be at your own risk. (Although there are no guarantees about "always there in future releases" for any function, anyway, documented or not.)

--Eric

 

If you complain about undocumented functions in the documentation forums, you usually get a reply to what they do.

 

Why not just cast the thing yourself?

Code (CSharp):

1. half myHalf = (half)myFloat;

I bet that's all Mathf does anyway.

 

Thank you all for your replies!
"half" doesn't exist natively in C#, unless I'm wrong.
I'll probably ask in the documentation forums, since from the small tests I've made, Mathf.HalfToFloat(Mathf.FloatToHalf(myFloat)) == Mathf.HalfToFloat(Mathf.FloatToHalf(Mathf.HalfToFloat(Mathf.FloatToHalf(
myFloat
)))) seems to be true, but Mathf.HalfToFloat(Mathf.FloatToHalf(10000000f)) == Float.Infinity too.

 

Graphics hardware on the other hand does support half-precision floats. I'm betting that's precisely why Mathf has it. To make life easier when communicating with graphics hardware.

https://en.wikipedia.org/wiki/Half-precision_floating-point_format

 

Looking at ILSpy, the method's extern. So I'm going to guess that FloatToHalf does a c++ downcast from float to half. The return value is an ushort, since C# doesn't have halfs, so the data's just stuck in ushort since it's 16 bits.

No clue why they'd use a ushort over a short.

If you're comfortable with the loss of precision from float to half, this seems like an ideal way to send data. It's probably a workaround specifically to handle C# not supporting halfs, to allow for sending lossy information about floating point values. Which is pretty neat!