rgb19e7 bug cpp test

Author: Crisspl

examples_tests/22.RaytracedAO/main.cpp

@@ -18,8 +18,192 @@
 using namespace nbl;
 using namespace core;
 
+//#define TEST_FORMAT
+
+#ifdef TEST_FORMAT
+struct Test_RGB19E7
+{
+	static constexpr const char* name = "rgb19e7";
+
+	static uint64_t acc_;
+	static core::vectorSIMDf fetch()
+	{
+		auto rgb = core::rgb19e7_to_rgb32f(acc_);
+		return core::vectorSIMDf(rgb.x, rgb.y, rgb.z);
+	}
+	static void store(const core::vectorSIMDf& x)
+	{
+		acc_ = core::rgb32f_to_rgb19e7(x.pointer);
+	}
+};
+uint64_t Test_RGB19E7::acc_ = core::rgb32f_to_rgb19e7(0.f, 0.f, 0.f);
+struct Test_Expected
+{
+	static constexpr const char* name = "expected";
+
+	static core::vectorSIMDf acc_;
+	static core::vectorSIMDf fetch()
+	{
+		return acc_;
+	}
+	static void store(const core::vectorSIMDf& x)
+	{
+		acc_ = x;
+	}
+};
+core::vectorSIMDf Test_Expected::acc_ = core::vectorSIMDf(0.f);
+void print(const core::vectorSIMDf v)
+{
+	std::cout << v.x << ", " << v.y << ", " << v.z << std::endl;
+}
+
+// raygen=0, resolve=1
+template <typename Test>
+auto test_()
+{
+	const core::vectorSIMDf em(0.f, 0.5f, 0.25f);
+	const core::vectorSIMDf dir(0.0f);
+	for (int i = 0; i <= 30; ++i)
+	{
+		std::cout << "i = " << i << std::endl;
+		float rcp = 1.f / float(i);
+		if (rcp < 1.f)
+		{
+			auto acc = Test::fetch();
+			acc += core::vectorSIMDf(em / float(i - 1));
+			Test::store(acc);
+		}
+		else Test::store(em);
+		//std::cout << "step 1: "; print(Test::fetch());
+
+		if (rcp < 1.f)
+		{
+			auto acc = Test::fetch();
+			acc += (dir - acc) * rcp;
+			Test::store(acc);
+		}
+		else
+		{
+			auto acc = Test::fetch();
+			acc += dir;
+			Test::store(acc);
+		}
+		std::cout << "step 2: "; print(Test::fetch());
+	}
+
+	return Test::fetch();
+}
+template <typename T>
+auto test()
+{
+	const auto result = test_<T>();
+	std::cout << std::left << std::setw(15) << T::name << " result = " << result.x << ", " << result.y << ", " << result.z << ";\n";
+	return result;
+}
+
+int main()
+{
+	test<Test_RGB19E7>();
+	/*auto error = core::abs(test<Test_Expected>() - test<Test_RGB19E7>());
+	std::cout << std::setprecision(15) << error.x << ", " << error.y << ", " << error.z << "\n";*/
+	return 0;
+}
+
+#else
+
+struct uvec2
+{
+	uvec2() : x{ 0,0 } {}
+	uvec2(uint32_t xx, uint32_t yy) : x{ xx,yy } {}
+	uvec2(uint64_t xx) : u64(xx) {}
+
+	operator uint64_t() const { return *reinterpret_cast<const uint64_t*>(x); }
+
+	uint32_t& operator[](int a) { return x[a]; }
+private:
+	union {
+		uint32_t x[2];
+		uint64_t u64;
+	};
+};
+
+core::rgb32f decode(uvec2 x)
+{
+	int _exp = int((bitfieldExtract(x[1], 25, 7) - 63u) - 19u);
+	float scale = exp2(float(_exp));
+	rgb32f v;
+	v.x = float(bitfieldExtract(x[0], 0, 19));
+	v.y = float(bitfieldInsert(bitfieldExtract(x[0], 19, 13), bitfieldExtract(x[1], 0, 6), 13, 6));
+	v.z = float(bitfieldExtract(x[1], 6, 19));
+	v.x *= scale;
+	v.y *= scale;
+	v.z *= scale;
+	return v;
+}
+uvec2 encode(rgb32f col)
+{
+	rgb32f clamped;
+	clamped.x = clamp(col.x, 0.f, 35184304979968.0f);
+	clamped.y = clamp(col.y, 0.f, 35184304979968.0f);
+	clamped.z = clamp(col.z, 0.f, 35184304979968.0f);
+	float maxrgb = max(max(clamped.x, clamped.y), clamped.z);
+	int f32_exp = ((floatBitsToInt(maxrgb) >> 23) & 255) - 127;
+	int shared_exp = clamp(f32_exp, -64, 64) + 1;
+	uint32_t mantissas[3];// = uvec3((clamped * exp2(float(19 - shared_exp))) + vec3(0.5));
+	float scale = ::exp2(19 - shared_exp);
+	uint32_t maxm = maxrgb*scale + 0.5f;
+	bool need = (maxm == float(1u<<19));
+	scale = need ? (scale*0.5f) : scale;
+	shared_exp = need ? (shared_exp+1) : shared_exp;
+	mantissas[0] = uint32_t((clamped.x * scale) + 0.5f);
+	mantissas[1] = uint32_t((clamped.y * scale) + 0.5f);
+	mantissas[2] = uint32_t((clamped.z * scale) + 0.5f);
+	uvec2 encoded;
+	encoded[0] = bitfieldInsert(mantissas[0], mantissas[1], 19, 13);
+	encoded[1] = bitfieldInsert(mantissas[1] >> 13, mantissas[2], 6, 19) | ((shared_exp + 63) << 25);
+	return encoded;
+}
+
+
+
 int main()
 {
+	float rgb32_[3]{ 0.f, 0.333333333f, 0.f };
+	rgb32f rgb32; memcpy(&rgb32.x, rgb32_, 12);
+	const uvec2 rgb19e7_frame109_input = encode(rgb32); //uvec2(2863136768, 2080374826);
+
+	const float rcp = 0.14286f;
+
+	/*uint32_t rgb_[2]{ 2863136768, 2080374826 }; // frame 108
+	//uint32_t rgb_[2]{ 0, 2080374784 }; // frame 109 step 1
+	uint64_t* rgb = reinterpret_cast<uint64_t*>(rgb_);
+	auto _19e7 = core::rgb19e7_to_rgb32f(*rgb);
+	float t = 1.f;
+	t /= 6.f;
+	_19e7.y += t;
+	*rgb = core::rgb32f_to_rgb19e7(&_19e7.x); // step 1 store (end)
+	// step 2 start
+	_19e7 = core::rgb19e7_to_rgb32f(*rgb);
+	_19e7.y += (0.f - _19e7.y) * rcp;
+	*rgb = core::rgb32f_to_rgb19e7(&_19e7.x);
+	_19e7 = core::rgb19e7_to_rgb32f(*rgb);
+	printf("");
+	*/
+	uvec2 rgb19e7 = rgb19e7_frame109_input;
+	auto acc = decode(rgb19e7);
+	float t = 1.f;
+	t /= 6.f;
+	acc.y += t;
+	rgb19e7 = encode(acc); // step 1 store (end)
+	// step 2
+	acc = decode(rgb19e7);
+	acc.y += (0.f - acc.y) * rcp;
+	rgb19e7 = encode(acc);
+	// put into fbo
+	rgb32f fbo = decode(rgb19e7);
+	printf("");
+
+
 	// create device with full flexibility over creation parameters
 	// you can add more parameters if desired, check nbl::SIrrlichtCreationParameters
 	nbl::SIrrlichtCreationParameters params;
@@ -314,3 +498,4 @@ int main()
 
 	return 0;
 }
+#endif