vtfpp: maintain byte order of underlying buffers

Author: partyvan

include/vtfpp/ImageConversion.h

@@ -5,14 +5,52 @@
 #include <cstddef>
 #include <span>
 #include <vector>
+#include <type_traits>
 
 #include <BufferStream.h>
 #include <sourcepp/Templates.h>
+#include <sourcepp/Math.h>
+
+using sourcepp::math::Arithmetic;
 
 #include "ImageFormats.h"
 
 namespace vtfpp {
 
+template<Arithmetic A>
+class LERep : public std::array<std::byte, sizeof(A)> {
+	using uint_according = typename std::conditional<sizeof(A) == 8,
+		uint64_t,
+	typename std::conditional<sizeof(A) == 4,
+		uint32_t,
+	typename std::conditional<sizeof(A) == 2,
+		uint16_t,
+	uint8_t>::type>::type>::type;
+public:
+	constexpr operator A() {
+		uint_according ret = 0;
+		for (size_t offs = 0; auto &b : *this) {
+			ret |= (static_cast<uint_according>(b) << offs) & (uint_according(0xFFu) << offs);
+			offs += 8;
+		}
+		return *reinterpret_cast<A *>(&ret);
+	}
+	constexpr LERep &operator=(const A &v) {
+		auto in = *reinterpret_cast<const uint_according *>(&v);
+		for (size_t offs = 0; auto &b : *this) {
+			b = static_cast<std::byte>((in >> offs) & uint_according(0xFFu));
+			offs += 8;
+		}
+		return *this;
+	}
+	template<Arithmetic B> requires (std::convertible_to<B, A> || std::is_same_v<A, half>)
+	constexpr LERep(const B &u) { *this = static_cast<A>(u); }
+	template<Arithmetic B> requires std::convertible_to<B, A>
+	constexpr LERep(const LERep<B> &u) { *this = static_cast<A>(u); }
+	template<Arithmetic B> requires std::convertible_to<A, B>
+	constexpr operator B() const { return static_cast<B>(static_cast<A>(*this)); }
+};
+
 namespace ImagePixel {
 
 #define VTFPP_CHECK_SIZE(format) \
@@ -157,18 +195,18 @@ struct UVWQ8888 {
 
 struct RGBA16161616F {
 	static constexpr auto FORMAT = ImageFormat::RGBA16161616F;
-	half r;
-	half g;
-	half b;
-	half a;
+	LERep<half> r;
+	LERep<half> g;
+	LERep<half> b;
+	LERep<half> a;
 }; VTFPP_CHECK_SIZE(RGBA16161616F);
 
 struct RGBA16161616 {
 	static constexpr auto FORMAT = ImageFormat::RGBA16161616;
-	uint16_t r;
-	uint16_t g;
-	uint16_t b;
-	uint16_t a;
+	LERep<uint16_t> r;
+	LERep<uint16_t> g;
+	LERep<uint16_t> b;
+	LERep<uint16_t> a;
 }; VTFPP_CHECK_SIZE(RGBA16161616);
 
 struct UVLX8888 {
@@ -181,34 +219,34 @@ struct UVLX8888 {
 
 struct R32F {
 	static constexpr auto FORMAT = ImageFormat::R32F;
-	float r;
+	LERep<float> r;
 }; VTFPP_CHECK_SIZE(R32F);
 
 struct RGB323232F {
 	static constexpr auto FORMAT = ImageFormat::R32F;
-	float r;
-	float g;
-	float b;
+	LERep<float> r;
+	LERep<float> g;
+	LERep<float> b;
 }; VTFPP_CHECK_SIZE(RGB323232F);
 
 struct RGBA32323232F {
 	static constexpr auto FORMAT = ImageFormat::RGBA32323232F;
-	float r;
-	float g;
-	float b;
-	float a;
+	LERep<float> r;
+	LERep<float> g;
+	LERep<float> b;
+	LERep<float> a;
 }; VTFPP_CHECK_SIZE(RGBA32323232F);
 
 struct RG1616F {
 	static constexpr auto FORMAT = ImageFormat::RG1616F;
-	half r;
-	half g;
+	LERep<half> r;
+	LERep<half> g;
 }; VTFPP_CHECK_SIZE(RG1616F);
 
 struct RG3232F {
 	static constexpr auto FORMAT = ImageFormat::RG3232F;
-	float r;
-	float g;
+	LERep<float> r;
+	LERep<float> g;
 }; VTFPP_CHECK_SIZE(RG3232F);
 
 struct RGBX8888 {

src/vtfpp/ImageConversion.cpp

@@ -730,10 +730,10 @@ namespace {
 #endif
 			imageDataSpan.begin(), imageDataSpan.end(), newDataSpan.begin(), [](ImagePixel::RGBA32323232F pixel) -> ImagePixel::RGBA8888 {
 		return {
-			static_cast<uint8_t>(std::clamp(pixel.r, 0.f, 1.f) * ((1 << 8) - 1)),
-			static_cast<uint8_t>(std::clamp(pixel.g, 0.f, 1.f) * ((1 << 8) - 1)),
-			static_cast<uint8_t>(std::clamp(pixel.b, 0.f, 1.f) * ((1 << 8) - 1)),
-			static_cast<uint8_t>(std::clamp(pixel.a, 0.f, 1.f) * ((1 << 8) - 1)),
+			static_cast<uint8_t>(std::clamp<float>(pixel.r, 0.f, 1.f) * ((1 << 8) - 1)),
+			static_cast<uint8_t>(std::clamp<float>(pixel.g, 0.f, 1.f) * ((1 << 8) - 1)),
+			static_cast<uint8_t>(std::clamp<float>(pixel.b, 0.f, 1.f) * ((1 << 8) - 1)),
+			static_cast<uint8_t>(std::clamp<float>(pixel.a, 0.f, 1.f) * ((1 << 8) - 1)),
 		};
 	});
 
@@ -808,10 +808,10 @@ namespace {
 #endif
 			imageDataSpan.begin(), imageDataSpan.end(), newDataSpan.begin(), [](ImagePixel::RGBA32323232F pixel) -> ImagePixel::RGBA16161616 {
 		return {
-			static_cast<uint16_t>(std::clamp(pixel.r, 0.f, 1.f) * ((1 << 16) - 1)),
-			static_cast<uint16_t>(std::clamp(pixel.g, 0.f, 1.f) * ((1 << 16) - 1)),
-			static_cast<uint16_t>(std::clamp(pixel.b, 0.f, 1.f) * ((1 << 16) - 1)),
-			static_cast<uint16_t>(std::clamp(pixel.a, 0.f, 1.f) * ((1 << 16) - 1)),
+			static_cast<uint16_t>(std::clamp<float>(pixel.r, 0.f, 1.f) * ((1 << 16) - 1)),
+			static_cast<uint16_t>(std::clamp<float>(pixel.g, 0.f, 1.f) * ((1 << 16) - 1)),
+			static_cast<uint16_t>(std::clamp<float>(pixel.b, 0.f, 1.f) * ((1 << 16) - 1)),
+			static_cast<uint16_t>(std::clamp<float>(pixel.a, 0.f, 1.f) * ((1 << 16) - 1)),
 		};
 	});
 

src/vtfpp/VTF.cpp

@@ -1681,7 +1681,9 @@ std::vector<std::byte> VTF::bake() const {
 				.write(this->frameCount)
 				.write(this->startFrame)
 				.write<uint32_t>(0) // padding
-				.write(this->reflectivity)
+				.write(this->reflectivity[0])
+				.write(this->reflectivity[1])
+				.write(this->reflectivity[2])
 				.write<uint32_t>(0) // padding
 				.write(this->bumpMapScale)
 				.write(bakeFormat)