vtfpp: byte order portability

CMakeLists.txt

@@ -6,6 +6,10 @@ project(sourcepp
         DESCRIPTION "Several modern C++20 libraries for sanely parsing Valve formats."
         HOMEPAGE_URL "https://craftablescience.info/sourcepp")
 set(CMAKE_CXX_STANDARD 20)
+if(MSVC)
+	# secret second flag to *actually* make msvc a c++20-compilant compiler
+	add_compile_options($<$<COMPILE_LANGUAGE:CXX>:/Zc:preprocessor>)
+endif()
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 

Doxyfile

@@ -2471,6 +2471,10 @@ PREDEFINED             =
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
 EXPAND_AS_DEFINED      =
+EXPAND_AS_DEFINED += SOURCEPP_LEREP_DEFINE
+EXPAND_AS_DEFINED += SOURCEPP_LEREP_DEFINE_P
+EXPAND_AS_DEFINED += SOURCEPP_MAT_DEFINE
+EXPAND_AS_DEFINED += SOURCEPP_VEC_DEFINE
 
 # If the SKIP_FUNCTION_MACROS tag is set to YES then doxygen's preprocessor will
 # remove all references to function-like macros that are alone on a line, have

bench/vtfpp.cpp

@@ -21,7 +21,7 @@ namespace {
 		VTFLib::CVTFFile vtf; \
 		vtf.Load(ASSET_ROOT "vtfpp/fmt/" #Format ".vtf"); \
 		for ([[maybe_unused]] auto _: state) { \
-			std::vector<std::byte> data(vtf.GetWidth() * vtf.GetHeight() * sizeof(ImagePixel::RGBA8888)); \
+			std::vector<std::byte> data(vtf.GetWidth() * vtf.GetHeight() * sizeof(ImagePixelV2::RGBA8888)); \
 			benchmark::DoNotOptimize(VTFLib::CVTFFile::ConvertToRGBA8888(vtf.GetData(0, 0, 0, 0), reinterpret_cast<vlByte*>(data.data()), vtf.GetWidth(), vtf.GetHeight(), IMAGE_FORMAT_##VTFLibFormat)); \
 		} \
 	} \

ext/compressonator/CMakeLists.txt

@@ -26,11 +26,14 @@ function(target_link_compressonator TARGET)
                 "${COMPRESSONATOR_DIR}/lib/macOS_arm64/libCMP_Core$<$<CONFIG:Debug>:d>.a")
     elseif(UNIX)
         target_link_libraries(${TARGET} PRIVATE
-                "${COMPRESSONATOR_DIR}/lib/linux_x86_64/libCompressonator$<$<CONFIG:Debug>:d>.a"
-                "${COMPRESSONATOR_DIR}/lib/linux_x86_64/libCMP_Core$<$<CONFIG:Debug>:d>.a"
-                "${COMPRESSONATOR_DIR}/lib/linux_x86_64/libCMP_Core_AVX$<$<CONFIG:Debug>:d>.a"
-                "${COMPRESSONATOR_DIR}/lib/linux_x86_64/libCMP_Core_AVX512$<$<CONFIG:Debug>:d>.a"
-                "${COMPRESSONATOR_DIR}/lib/linux_x86_64/libCMP_Core_SSE$<$<CONFIG:Debug>:d>.a")
+                "${COMPRESSONATOR_DIR}/lib/linux_${CMAKE_SYSTEM_PROCESSOR}/libCompressonator$<$<CONFIG:Debug>:d>.a"
+                "${COMPRESSONATOR_DIR}/lib/linux_${CMAKE_SYSTEM_PROCESSOR}/libCMP_Core$<$<CONFIG:Debug>:d>.a")
+        if(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64")
+            target_link_libraries(${TARGET} PRIVATE
+                    "${COMPRESSONATOR_DIR}/lib/linux_${CMAKE_SYSTEM_PROCESSOR}/libCMP_Core_AVX$<$<CONFIG:Debug>:d>.a"
+                    "${COMPRESSONATOR_DIR}/lib/linux_${CMAKE_SYSTEM_PROCESSOR}/libCMP_Core_AVX512$<$<CONFIG:Debug>:d>.a"
+                    "${COMPRESSONATOR_DIR}/lib/linux_${CMAKE_SYSTEM_PROCESSOR}/libCMP_Core_SSE$<$<CONFIG:Debug>:d>.a")
+        endif()
     else()
         message(FATAL_ERROR "Unable to link to Compressonator library!")
     endif()

include/sourcepp/Bits.h

@@ -0,0 +1,102 @@
+#pragma once
+
+#include <type_traits>
+
+#include <sourcepp/Math.h>
+
+namespace sourcepp::bits {
+
+/// A view of a given numeric type `A` that is always little-endian in memory.
+/// Typically becomes no-op at `-O2` on LE targets.
+///
+/// Any instance of `*reinterpret_cast<NUMERIC_TYPE *>` etc., or use of numeric types
+/// in structures destined for I/O buffers is suspect, and, in either case, should likely
+/// be replaced by some invocation of this class. This can be syntactically cumbersome,
+/// so convenient aliases are provided with f32le, etc.
+///
+/// Special provisions for arithmetic outside possible implicit conversions are intentionally omitted.
+template<sourcepp::math::Arithmetic A>
+class LERep : private 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:
+
+	/// Conversion to native byte order.
+	/// `LERep<A>` ⇒ `A`.
+	constexpr operator A() const {
+		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);
+	}
+
+	/// Conversion from native byte order.
+	/// `A` ⇒ `LERep<A>`.
+	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;
+	}
+
+	/// Convenience for arithmetic conversion from some B.
+	/// (`B` ⇒ `A`) ⇒ (`B` ⇒ `LERep<A>`).
+	template<sourcepp::math::Arithmetic B> requires (std::convertible_to<B, A> || std::is_same_v<A, half>)
+	constexpr LERep(const B &u) { this->operator=(static_cast<A>(u)); }
+
+	/// Convenience for arithmetic conversion between LERep of distinct but arithmetically convertible types.
+	/// (`B` ⇒ `A`) ⇒ (`LERep<B>` ⇒ `LERep<A>`).
+	template<sourcepp::math::Arithmetic B> requires std::convertible_to<B, A>
+	constexpr LERep(const LERep<B> &u) { this->operator=(u.operator A()); }
+
+	/// Convenience for arithmetic conversion to some B.
+	/// (`LERep<A>` ⇒ `A`) ∧ (`A` ⇒ `B`) ⇒ (`LERep<A>` ⇒ `B`).
+	template<sourcepp::math::Arithmetic B> requires std::convertible_to<A, B>
+	constexpr operator B() const { return static_cast<B>(this->operator A()); }
+
+	/// Permits uninitialized LERep, for parity with the associated A.
+	constexpr LERep() {}
+
+	/// Construct a value from a byte buffer.
+	constexpr explicit LERep(std::span<const std::byte, sizeof(A)> arr) {
+		std::memcpy(this, arr.data(), sizeof(A));
+	}
+};
+
+/// Read a given value of type A from a pointer into arbitrary data presumed to hold a little-endian representation of A.
+/// Subject to the usual litany of cautions about
+///
+///     *reinterpret_cast<T *>(p)
+///
+/// , such invocations, where spuriously dependent upon host byte order, may be replaced with:
+///
+///     deref_as_le<T>(p)
+template<sourcepp::math::Arithmetic A>
+[[nodiscard]] constexpr A deref_as_le(const void *p) {
+	return LERep<A>(std::span<const std::byte, sizeof(A)>(static_cast<const std::byte *>(p), sizeof(A))).operator A();
+}
+
+#define SOURCEPP_LEREP_DEFINE(N, V)\
+	using N##le = LERep<V>
+#define SOURCEPP_LEREP_DEFINE_P(PFX, N16, N32, N64) \
+	SOURCEPP_LEREP_DEFINE(PFX##16, N16); \
+	SOURCEPP_LEREP_DEFINE(PFX##32, N32); \
+	SOURCEPP_LEREP_DEFINE(PFX##64, N64)
+
+SOURCEPP_LEREP_DEFINE_P(i,  int16_t,  int32_t,  int64_t);
+SOURCEPP_LEREP_DEFINE_P(ui, uint16_t, uint32_t, uint64_t);
+SOURCEPP_LEREP_DEFINE_P(f,  half,     float,    double);
+
+#undef SOURCEPP_LEREP_DEFINE_P
+#undef SOURCEPP_LEREP_DEFINE
+
+} // namespace sourcepp::bits

include/sourcepp/Macros.h

@@ -4,6 +4,7 @@
 
 // Helpers
 #define SOURCEPP_CONCAT_DETAIL(a, b) a##b
+/// Token pasting outside a macro context.
 #define SOURCEPP_CONCAT(a, b) SOURCEPP_CONCAT_DETAIL(a, b)
 
 /// Create a breakpoint in debug
@@ -70,3 +71,80 @@
 			static_cast<std::underlying_type_t<Enum>>(lhs) ^  \
 			static_cast<std::underlying_type_t<Enum>>(rhs));  \
     }
+
+/// Indirected `()`.
+#define SOURCEPP_UNIT ()
+
+#define SOURCEPP_EXPAND8(...) SOURCEPP_EXPAND7(SOURCEPP_EXPAND7(SOURCEPP_EXPAND7(SOURCEPP_EXPAND7(__VA_ARGS__))))
+#define SOURCEPP_EXPAND7(...) SOURCEPP_EXPAND6(SOURCEPP_EXPAND6(SOURCEPP_EXPAND6(SOURCEPP_EXPAND6(__VA_ARGS__))))
+#define SOURCEPP_EXPAND6(...) SOURCEPP_EXPAND5(SOURCEPP_EXPAND5(SOURCEPP_EXPAND5(SOURCEPP_EXPAND5(__VA_ARGS__))))
+#define SOURCEPP_EXPAND5(...) SOURCEPP_EXPAND4(SOURCEPP_EXPAND4(SOURCEPP_EXPAND4(SOURCEPP_EXPAND4(__VA_ARGS__))))
+#define SOURCEPP_EXPAND4(...) SOURCEPP_EXPAND3(SOURCEPP_EXPAND3(SOURCEPP_EXPAND3(SOURCEPP_EXPAND3(__VA_ARGS__))))
+#define SOURCEPP_EXPAND3(...) SOURCEPP_EXPAND2(SOURCEPP_EXPAND2(SOURCEPP_EXPAND2(SOURCEPP_EXPAND2(__VA_ARGS__))))
+#define SOURCEPP_EXPAND2(...) SOURCEPP_EXPAND1(SOURCEPP_EXPAND1(SOURCEPP_EXPAND1(SOURCEPP_EXPAND1(__VA_ARGS__))))
+#define SOURCEPP_EXPAND1(...) __VA_ARGS__
+
+#define SOURCEPP_ID(...) __VA_ARGS__
+
+/// Apply a unary macro to each of `__VA_ARGS__`.
+/// \param sep Nullary function-like macro expected to expand to a separator. For rationale, see \ref SOURCEPP_THUNK_COMMA.
+/// \param macro Unary macro.
+/// \param ... List of first arguments per call to `macro`.
+#define SOURCEPP_FOREACH0_SEP(sep, macro, ...) \
+	__VA_OPT__(SOURCEPP_EXPAND5(SOURCEPP_FOREACH0_SEP_HELPER(sep, macro, __VA_ARGS__)))
+#define SOURCEPP_FOREACH0_SEP_HELPER(sep, macro, x, ...) \
+	macro(x) \
+	__VA_OPT__(sep SOURCEPP_UNIT SOURCEPP_FOREACH0_SEP_HELPER_THUNK SOURCEPP_UNIT (sep, macro, __VA_ARGS__))
+#define SOURCEPP_FOREACH0_SEP_HELPER_THUNK() SOURCEPP_FOREACH0_SEP_HELPER
+
+/// Apply a binary macro to each of `__VA_ARGS__` with a set first argument.
+/// \param sep Nullary function-like macro expected to expand to a separator. For rationale, see \ref SOURCEPP_THUNK_COMMA.
+/// \param macro Binary macro.
+/// \param a Always the first argument to `macro`.
+/// \param ... List of second arguments per call to `macro`
+#define SOURCEPP_FOREACH1_SEP(sep, macro, a, ...) \
+	__VA_OPT__(SOURCEPP_EXPAND5(SOURCEPP_FOREACH1_SEP_HELPER(sep, macro, a, __VA_ARGS__)))
+#define SOURCEPP_FOREACH1_SEP_HELPER(sep, macro, a, x, ...) \
+	macro(a, x) \
+	__VA_OPT__(sep SOURCEPP_UNIT SOURCEPP_FOREACH1_SEP_HELPER_THUNK SOURCEPP_UNIT (sep, macro, a, __VA_ARGS__))
+#define SOURCEPP_FOREACH1_SEP_HELPER_THUNK() SOURCEPP_FOREACH1_SEP_HELPER
+
+/// Reverse an argument list; evaluates comma-separated but unparenthesized.
+#define SOURCEPP_REVERSE(...) \
+	__VA_OPT__(SOURCEPP_EXPAND5(SOURCEPP_REVERSE_HELPER(__VA_ARGS__)))
+#define SOURCEPP_REVERSE_HELPER(a, ...) \
+        __VA_OPT__(SOURCEPP_REVERSE_HELPER_THUNK SOURCEPP_UNIT (__VA_ARGS__),) a
+#define SOURCEPP_REVERSE_HELPER_THUNK() SOURCEPP_REVERSE_HELPER
+
+/// Nullary macro that expands to nothing.
+#define SOURCEPP_THUNK_NOTHING()
+
+/// Turn its operand into (effectively) a nullary function-like macro that expands to it.
+#define SOURCEPP_THUNK(id) id SOURCEPP_THUNK_NOTHING
+/// Nullary macro that expands to a comma. It is necessary to defer expansion to any commas in the
+/// desired output of complex macro expansions, to prevent the preprocessor from interpreting such a comma itself.
+#define SOURCEPP_THUNK_COMMA() ,
+
+/// Convenience variant of SOURCEPP_FOREACH0_SEP with no separator.
+#define SOURCEPP_FOREACH0(macro, ...) SOURCEPP_FOREACH0_SEP(SOURCEPP_THUNK_NOTHING, macro, __VA_ARGS__)
+/// Convenience variant of SOURCEPP_FOREACH1_SEP with no separator.
+#define SOURCEPP_FOREACH1(macro, a, ...) SOURCEPP_FOREACH1_SEP(SOURCEPP_THUNK_NOTHING, macro, a, __VA_ARGS__)
+
+/// Callable parenthesization; identity function for 2-tuples when used bare as in:
+///
+///     SOURCEPP_CONS TUPLE
+#define SOURCEPP_CONS(a, d) (a, d)
+/// Called bare to destructure the first of a 2-tuple.
+#define SOURCEPP_CAR(a, d) a
+/// Called bare to destructure the second of a 2-tuple.
+#define SOURCEPP_CDR(a, d) d
+
+#define SOURCEPP_CALL_WITH_POLICY_IF_TBB(ident, policy, ...) ident(__VA_ARGS__)
+#ifdef SOURCEPP_BUILD_WITH_TBB
+#	undef SOURCEPP_CALL_WITH_POLICY_IF_TBB
+#	if __has_include(<execution>)
+#		define SOURCEPP_CALL_WITH_POLICY_IF_TBB(ident, policy, ...) ident(policy __VA_OPT__(,) __VA_ARGS__)
+#	else
+#		define SOURCEPP_CALL_WITH_POLICY_IF_TBB(...) static_assert(false, "This macro needs <execution> present.")
+#	endif
+#endif