Comments on: Encoding floats to RGBA, again

By: Faustyvat

Faustyvat — Mon, 18 Jan 2010 11:29:29 +0000

Rural pharmacy. Small prices a month.Buy Viagra $0.87

By: Lost in the Triangles » Blog Archive » Encoding floats to RGBA – the final?

Thu, 30 Jul 2009 12:58:20 +0000

[...] right there on my previous blog post [...]

By: Salvatore Previti

Salvatore Previti — Tue, 03 Feb 2009 07:17:13 +0000

Use these two :)

inline float4 FloatToRGBA(float value)
{
float4 packedValue = frac(value * float4(16777216, 65536, 256, 1));
return packedValue – packedValue.xxyz * float4(0, 1.0 / 256, 1.0 / 256, 1.0 / 256);
}

inline float RGBAToFloat(float4 packedValue)
{
return dot(packedValue, float4( 1.0 / 16777216, 1.0 / 65536, 1.0 / 256, 1.0));
}

This works quite well for all values from 0.0 (included) to 1.0 (excluded).
If you need to store value 1.0 too, you can simply divide the input of FloatToRGBA and multiply the output of RGBAToFloat by 0.9999991 loosing only a small amount of precision.
It seems to work quite well also with bilinear interpolation of textures.

By: Aras Pranckevičius

Aras Pranckevičius — Tue, 01 Jul 2008 10:50:49 +0000

@Pat: I think the difference is caused by the texture sampler differences. Even if GPUs do have floating point precision internally, regular 8 bit/channel textures are still sampled (and filtered!) at 8 bit precision, I guess for backwards compatibility reasons. Now, if there’s a very slight change in how the sampling and filtering works, then differences like we have here might surface. That’s my theory at least :)

@Alex: not sure, I haven’t actually tried that approach.

By: Alex Lindsay

Alex Lindsay — Tue, 01 Jul 2008 10:22:30 +0000

Hi, I had a go at this problem in my own special way. I’d be very interested in your opinions and results with the following (my post):
http://www.gamedev.net/community/forums/topic.asp?topic_id=485186
It’s certainly less elegant than the frac encode!

By: Pat Wilson

Pat Wilson — Tue, 24 Jun 2008 16:49:52 +0000

Hmm, come to think of it, I don’t think you could get enough texture addressing with FP16, so scratch that theory.

By: Pat Wilson

Pat Wilson — Tue, 24 Jun 2008 16:49:05 +0000

This looks like it’s related to the internal float representation of the card. I’m pulling numbers out of air, but I would guess that the early Radeons used FP16, x13-x19 used FP24, and HD series finally went to FP32. That would explain the large discrepancies between the early Radeons and the HD/GeForce/Intel cards.