Repository: nfrechette/acl (cpp)

Issue:
Remove range reduction from compression settings
Range reduction should be controlled by the algorithm entirely. It served only to debug by being exposed but the code is now very stable. Cleaning this up will reduce the maintenance burden and avoid potentially using an invalid setting combination by simplifying the API.

When variable bit rates are used, range reduction should always be enabled. It increases accuracy considerably and it reduces the memory footprint. It also increases the compression speed. Range reduction is only disabled if a track retains full precision in which case there is no point it applying range reduction since we retain every sample with full precision.


Discussion:

Patch:
diff --git a/docs/compressing_a_raw_clip.md b/docs/compressing_a_raw_clip.md
--- a/docs/compressing_a_raw_clip.md
+++ b/docs/compressing_a_raw_clip.md
@@ -8,10 +8,6 @@ The compression level used will dictate how much time to spend optimizing the va
 
 While we support various [rotation and vector quantization formats](rotation_and_vector_formats.md), the *variable* variants are generally the best. It is safe to use them for all your clips but if you do happen to run into issues with some exotic clips, you can easily fallback to less aggressive variants.
 
-[Segmenting](http://nfrechette.github.io/2016/11/10/anim_compression_uniform_segmenting/) ensures that large clips are split into smaller segments and compressed independently to allow a smaller memory footprint as well as faster compression and decompression.
-
-[Range reduction](range_reduction.md) is important and also something you will want to enable for all your tracks both at the clip and segment level.
-
 Selecting the right [error metric](error_metrics.md) is important and you will want to carefully pick the one that best approximates how your game engine performs skinning.
 
 The last important setting to choose is the `error_threshold`. This is used in conjunction with the error metric and the virtual vertex distance from the [skeleton](creating_a_skeleton.md) in order to guarantee that a certain quality is maintained. A default value of **0.01cm** is safe to use and it most likely should never be changed unless the units you are using differ. If you do run into issues where compression artifacts are visible, in all likelihood the virtual vertex distance used on the problematic bones is not conservative enough.
@@ -22,13 +18,10 @@ The last important setting to choose is the `error_threshold`. This is used in c
 using namespace acl;
 
 CompressionSettings settings;
-settings.level = CompressionLevel8::Medium;
-settings.rotation_format = RotationFormat8::QuatDropW_Variable;
-settings.translation_format = VectorFormat8::Vector3_Variable;
-settings.scale_format = VectorFormat8::Vector3_Variable;
-settings.range_reduction = RangeReductionFlags8::AllTracks;
-settings.segmenting.enabled = true;
-settings.segmenting.range_reduction = RangeReductionFlags8::AllTracks;
+settings.level = compression_level8::medium;
+settings.rotation_format = rotation_format8::quatf_drop_w_variable;
+settings.translation_format = vector_format8::vector3f_variable;
+settings.scale_format = vector_format8::vector3f_variable;
 
 qvvf_transform_error_metric error_metric;
 settings.error_metric = &error_metric;
diff --git a/docs/decompressing_a_clip.md b/docs/decompressing_a_clip.md
--- a/docs/decompressing_a_clip.md
+++ b/docs/decompressing_a_clip.md
@@ -11,14 +11,14 @@ using namespace acl::uniformly_sampled;
 DecompressionContext<DefaultDecompressionSettings> context;
 
 context.initialize(*compressed_clip);
-context.seek(sample_time, SampleRoundingPolicy::None);
+context.seek(sample_time, sample_rounding_policy::none);
 
 context.decompress_bone(bone_index, &rotation, &translation, &scale);
 ```
 
 As shown, a context must be initialized with a compressed clip instance. Some context objects such as the one used by uniform sampling can be re-used by any compressed clip and does not need to be re-created while others might require this. In order to detect when this might be required, the function `is_dirty(const CompressedClip& clip)` is provided. Some context objects cannot be created on the stack and must be dynamically allocated with an allocator instance. The functions `make_decompression_context(...)` are provided for this purpose.
 
-You can seek anywhere in a clip but you will need to handle looping manually in your game engine. When seeking, you must also provide a `SampleRoundingPolicy` to dictate how the interpolation is to be performed. See [here](../includes/acl/core/interpolation_utils.h) for details.
+You can seek anywhere in a clip but you will need to handle looping manually in your game engine. When seeking, you must also provide a `sample_rounding_policy` to dictate how the interpolation is to be performed. See [here](../includes/acl/core/interpolation_utils.h) for details.
 
 Every decompression function supported by the context is prefixed with `decompress_`. Uniform sampling supports decompressing a whole pose with a custom `OutputWriter` for optimized pose writing. You can implement your own and coerce to your own math types. The type is templated on the `decompress_pose` function in order to be easily inlined.
 
diff --git a/docs/decompressing_a_track_list.md b/docs/decompressing_a_track_list.md
--- a/docs/decompressing_a_track_list.md
+++ b/docs/decompressing_a_track_list.md
@@ -12,7 +12,7 @@ using namespace acl;
 decompression_context<default_decompression_settings> context;
 
 context.initialize(*tracks);
-context.seek(sample_time, SampleRoundingPolicy::None);
+context.seek(sample_time, sample_rounding_policy::none);
 
 // create an instance of 'track_writer' so we can write the output somewhere
 context.decompress_track(track_index, my_track_writer); // a single track
@@ -21,7 +21,7 @@ context.decompress_tracks(my_track_writer); // all tracks
 
 As shown, a context must be initialized with a compressed track list instance. Some context objects such as the one used by uniform sampling can be re-used by any compressed track list and does not need to be re-created while others might require this. In order to detect when this might be required, the function `is_dirty(const compressed_tracks& tracks)` is provided. Some context objects cannot be created on the stack and must be dynamically allocated with an allocator instance. The functions `make_decompression_context(...)` are provided for this purpose.
 
-You can seek anywhere in a track list but you will need to handle looping manually in your game engine. When seeking, you must also provide a `SampleRoundingPolicy` to dictate how the interpolation is to be performed. See [here](../includes/acl/core/interpolation_utils.h) for details.
+You can seek anywhere in a track list but you will need to handle looping manually in your game engine. When seeking, you must also provide a `sample_rounding_policy` to dictate how the interpolation is to be performed. See [here](../includes/acl/core/interpolation_utils.h) for details.
 
 Every decompression function supported by the context is prefixed with `decompress_*`. A `track_writer` is used for optimized output writing. You can implement your own and coerce to your own math types. The type is templated on the `decompress_*` functions in order to be easily inlined.
 
diff --git a/docs/range_reduction.md b/docs/range_reduction.md
--- a/docs/range_reduction.md
+++ b/docs/range_reduction.md
@@ -6,7 +6,7 @@ Range reduction is performed by calculating the range of possible values in a li
 
 This is an important optimization to keep the memory footprint as low as possible because it typically allows us to increase the precision retained on the normalized values.
 
-This feature can be enabled at the clip level where entire tracks are quantized over their full range as well as at the segment level where they are normalized over the segment only. Enabling the feature at the segment level requires it to also be enabled at the clip level because we store the range information in quantized form.
+This feature can be enabled at the clip level where entire tracks are quantized over their full range as well as at the segment level where they are normalized over the segment only. Enabling the feature at the segment level requires it to also be enabled at the clip level because we store the range information in quantized form. This is entirely controlled by the underlying compression algorithm.
 
 Additional reading:
 
diff --git a/docs/rotation_and_vector_formats.md b/docs/rotation_and_vector_formats.md
--- a/docs/rotation_and_vector_formats.md
+++ b/docs/rotation_and_vector_formats.md
@@ -2,20 +2,10 @@ In order to save memory, quantization is used on sampled values to reduce their
 
 # Vector formats
 
-Note that in order to be able to use some of these formats, track data needs to have [range reduction](range_reduction.md) applied at least at the clip level.
-
-### Vector3 96
+### Vector3 Full
 
 Simple full precision format. Each component `[X, Y, Z]` is stored with full floating point precision using `float32`.
 
-### Vector3 48
-
-Each component `[X, Y, Z]` is stored with `uint16_t`. This format requires range reduction to be enabled.
-
-### Vector3 32
-
-The code supports storing each component `[X, Y, Z]` on an arbitrary number of bits but we hard coded `[11, 11, 10]` for our purposes. This format requires range reduction to be enabled.
-
 ### Vector3 Variable
 
 The compression algorithm will search for the optimal bit rate among **19** possible values. An algorithm will select which bit rate to use for each track while keeping the memory footprint and error as low as possible. This format requires range reduction to be enabled.
@@ -24,7 +14,7 @@ The compression algorithm will search for the optimal bit rate among **19** poss
 
 Internally, rotation formats reuse the vector formats with some tweaks.
 
-### Quat 128
+### Quat Full
 
 A full precision quaternion format. Each component `[X, Y, Z, W]` is stored with full precision using `float32`.
 
@@ -32,18 +22,10 @@ A full precision quaternion format. Each component `[X, Y, Z, W]` is stored with
 
 Every rotation can be represented by two distinct and opposite quaternions: a quaternion and its negated opposite. This is possible because [quaternions represent a hypersphere](https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#The_hypersphere_of_rotations). As such, a component can be dropped and trivially reconstructed with a square root simply by ensuring that the component is positive and the quaternion normalized during compression.
 
-### Quat 96
+### Quat Full
 
 Same as Vector3 96 above to store `[X, Y, Z]`.
 
-### Quat 48
-
-Same as Vector3 48 above to store `[X, Y, Z]`.
-
-### Quat 32
-
-Same as Vector3 32 above to store `[X, Y, Z]`.
-
 ### Quat Variable
 
 See [Vector3 Variable](rotation_and_vector_formats.md#vector3-variable)
diff --git a/includes/acl/algorithm/uniformly_sampled/decoder.h b/includes/acl/algorithm/uniformly_sampled/decoder.h
--- a/includes/acl/algorithm/uniformly_sampled/decoder.h
+++ b/includes/acl/algorithm/uniformly_sampled/decoder.h
@@ -90,8 +90,8 @@ namespace acl
 
 				uint32_t clip_hash;								//  28 |  48
 
-				uint8_t num_rotation_components;				//  32 |  52
-				uint8_t has_mixed_packing;						//  33 |  53
+				range_reduction_flags8 range_reduction;			//  32 |  52
+				uint8_t num_rotation_components;				//  33 |  53
 
 				uint8_t padding0[2];							//  34 |  54
 
@@ -100,18 +100,17 @@ namespace acl
 				const uint8_t* segment_range_data[2];			//  44 |  72
 				const uint8_t* animated_track_data[2];			//  52 |  88
 
-				uint32_t key_frame_byte_offsets[2];				//  60 | 104	// Fixed quantization
-				uint32_t key_frame_bit_offsets[2];				//  68 | 112	// Variable quantization
+				uint32_t key_frame_bit_offsets[2];				//  60 | 104
 
-				float interpolation_alpha;						//  76 | 120
-				float sample_time;								//  80 | 124
+				float interpolation_alpha;						//  68 | 112
+				float sample_time;								//  76 | 120
 
-				uint8_t padding1[sizeof(void*) == 4 ? 44 : 64];	//  84 | 128	// 64 bit has a full cache line of padding, can't have 0 length array
+				uint8_t padding1[sizeof(void*) == 4 ? 52 : 4];	//  80 | 124
 
-				//									Total size:	   128 | 192
+				//									Total size:	   128 | 128
 			};
 
-			static_assert(sizeof(DecompressionContext) == (sizeof(void*) == 4 ? 128 : 192), "Unexpected size");
+			static_assert(sizeof(DecompressionContext) == 128, "Unexpected size");
 
 			struct alignas(k_cache_line_size) SamplingContext
 			{
@@ -153,18 +152,16 @@ namespace acl
 				uint32_t format_per_track_data_offset;					//  12 |  12
 				uint32_t segment_range_data_offset;						//  16 |  16
 
-				uint32_t key_frame_byte_offsets[2];						//  20 |  20	// Fixed quantization
-				uint32_t key_frame_bit_offsets[2];						//  28 |  28	// Variable quantization
+				uint32_t key_frame_bit_offsets[2];						//  20 |  20
 
-				uint8_t padding[28];									//  36 |  36
+				uint8_t padding[4];										//  28 |  28
 
-				rtm::vector4f vectors[k_num_samples_to_interpolate];	//  64 |  64
-				rtm::vector4f padding0[2];								//  96 |  96
+				rtm::vector4f vectors[k_num_samples_to_interpolate];	//  32 |  32
 
-				//											Total size:	   128 | 128
+				//											Total size:	    64 |  64
 			};
 
-			static_assert(sizeof(SamplingContext) == 128, "Unexpected size");
+			static_assert(sizeof(SamplingContext) == 64, "Unexpected size");
 
 			// We use adapters to wrap the DecompressionSettings
 			// This allows us to re-use the code for skipping and decompressing Vector3 samples
@@ -174,15 +171,11 @@ namespace acl
 			{
 				explicit TranslationDecompressionSettingsAdapter(const SettingsType& settings_) : settings(settings_) {}
 
-				constexpr RangeReductionFlags8 get_range_reduction_flag() const { return RangeReductionFlags8::Translations; }
-				inline rtm::vector4f RTM_SIMD_CALL get_default_value() const { return rtm::vector_zero(); }
-				constexpr VectorFormat8 get_vector_format(const ClipHeader& header) const { return settings.get_translation_format(header.translation_format); }
-				constexpr bool is_vector_format_supported(VectorFormat8 format) const { return settings.is_translation_format_supported(format); }
-
-				// Just forward the calls
-				constexpr RangeReductionFlags8 get_clip_range_reduction(RangeReductionFlags8 flags) const { return settings.get_clip_range_reduction(flags); }
-				constexpr RangeReductionFlags8 get_segment_range_reduction(RangeReductionFlags8 flags) const { return settings.get_segment_range_reduction(flags); }
-				constexpr bool supports_mixed_packing() const { return settings.supports_mixed_packing(); }
+				constexpr range_reduction_flags8 get_range_reduction_flag() const { return range_reduction_flags8::translations; }
+				rtm::vector4f RTM_SIMD_CALL get_default_value() const { return rtm::vector_zero(); }
+				vector_format8 get_vector_format(const ClipHeader& header) const { return settings.get_translation_format(header.translation_format); }
+				bool is_vector_format_supported(vector_format8 format) const { return settings.is_translation_format_supported(format); }
+				bool are_range_reduction_flags_supported(range_reduction_flags8 flags) const { return settings.are_range_reduction_flags_supported(flags); }
 
 				SettingsType settings;
 			};
@@ -195,15 +188,11 @@ namespace acl
 					, default_scale(header.default_scale ? rtm::vector_set(1.0F) : rtm::vector_zero())
 				{}
 
-				constexpr RangeReductionFlags8 get_range_reduction_flag() const { return RangeReductionFlags8::Scales; }
-				inline rtm::vector4f RTM_SIMD_CALL get_default_value() const { return default_scale; }
-				constexpr VectorFormat8 get_vector_format(const ClipHeader& header) const { return settings.get_scale_format(header.scale_format); }
-				constexpr bool is_vector_format_supported(VectorFormat8 format) const { return settings.is_scale_format_supported(format); }
-
-				// Just forward the calls
-				constexpr RangeReductionFlags8 get_clip_range_reduction(RangeReductionFlags8 flags) const { return settings.get_clip_range_reduction(flags); }
-				constexpr RangeReductionFlags8 get_segment_range_reduction(RangeReductionFlags8 flags) const { return settings.get_segment_range_reduction(flags); }
-				constexpr bool supports_mixed_packing() const { return settings.supports_mixed_packing(); }
+				constexpr range_reduction_flags8 get_range_reduction_flag() const { return range_reduction_flags8::scales; }
+				rtm::vector4f RTM_SIMD_CALL get_default_value() const { return default_scale; }
+				vector_format8 get_vector_format(const ClipHeader& header) const { return settings.get_scale_format(header.scale_format); }
+				bool is_vector_format_supported(vector_format8 format) const { return settings.is_scale_format_supported(format); }
+				bool are_range_reduction_flags_supported(range_reduction_flags8 flags) const { return settings.are_range_reduction_flags_supported(flags); }
 
 				SettingsType settings;
 				uint8_t padding[get_required_padding<SettingsType, rtm::vector4f>()];
@@ -223,20 +212,15 @@ namespace acl
 		//////////////////////////////////////////////////////////////////////////
 		struct DecompressionSettings
 		{
-			constexpr bool is_rotation_format_supported(RotationFormat8 /*format*/) const { return true; }
-			constexpr bool is_translation_format_supported(VectorFormat8 /*format*/) const { return true; }
-			constexpr bool is_scale_format_supported(VectorFormat8 /*format*/) const { return true; }
-			constexpr RotationFormat8 get_rotation_format(RotationFormat8 format) const { return format; }
-			constexpr VectorFormat8 get_translation_format(VectorFormat8 format) const { return format; }
-			constexpr VectorFormat8 get_scale_format(VectorFormat8 format) const { return format; }
+			constexpr bool is_rotation_format_supported(rotation_format8 /*format*/) const { return true; }
+			constexpr bool is_translation_format_supported(vector_format8 /*format*/) const { return true; }
+			constexpr bool is_scale_format_supported(vector_format8 /*format*/) const { return true; }
+			constexpr rotation_format8 get_rotation_format(rotation_format8 format) const { return format; }
+			constexpr vector_format8 get_translation_format(vector_format8 format) const { return format; }
+			constexpr vector_format8 get_scale_format(vector_format8 format) const { return format; }
 
-			constexpr bool are_clip_range_reduction_flags_supported(RangeReductionFlags8 /*flags*/) const { return true; }
-			constexpr bool are_segment_range_reduction_flags_supported(RangeReductionFlags8 /*flags*/) const { return true; }
-			constexpr RangeReductionFlags8 get_clip_range_reduction(RangeReductionFlags8 flags) const { return flags; }
-			constexpr RangeReductionFlags8 get_segment_range_reduction(RangeReductionFlags8 flags) const { return flags; }
-
-			// Whether tracks must all be variable or all fixed width, or if they can be mixed and require padding.
-			constexpr bool supports_mixed_packing() const { return true; }
+			constexpr bool are_range_reduction_flags_supported(range_reduction_flags8 /*flags*/) const { return true; }
+			constexpr range_reduction_flags8 get_range_reduction(range_reduction_flags8 flags) const { return flags; }
 
 			// Whether to explicitly disable floating point exceptions during decompression.
 			// This has a cost, exceptions are usually disabled globally and do not need to be
@@ -255,21 +239,19 @@ namespace acl
 		// These are the default settings. Only the generally optimal settings
 		// are enabled and will offer the overall best performance.
 		//
-		// Note: Segment range reduction supports AllTracks or None because it can
+		// Note: Segment range reduction supports all_tracks or none because it can
 		// be disabled if there is a single segment.
 		//////////////////////////////////////////////////////////////////////////
 		struct DefaultDecompressionSettings : DecompressionSettings
 		{
-			constexpr bool is_rotation_format_supported(RotationFormat8 format) const { return format == RotationFormat8::QuatDropW_Variable; }
-			constexpr bool is_translation_format_supported(VectorFormat8 format) const { return format == VectorFormat8::Vector3_Variable; }
-			constexpr bool is_scale_format_supported(VectorFormat8 format) const { return format == VectorFormat8::Vector3_Variable; }
-			constexpr RotationFormat8 get_rotation_format(RotationFormat8 /*format*/) const { return RotationFormat8::QuatDropW_Variable; }
-			constexpr VectorFormat8 get_translation_format(VectorFormat8 /*format*/) const { return VectorFormat8::Vector3_Variable; }
-			constexpr VectorFormat8 get_scale_format(VectorFormat8 /*format*/) const { return VectorFormat8::Vector3_Variable; }
-
-			constexpr RangeReductionFlags8 get_clip_range_reduction(RangeReductionFlags8 /*flags*/) const { return RangeReductionFlags8::AllTracks; }
-
-			constexpr bool supports_mixed_packing() const { return false; }
+			constexpr bool is_rotation_format_supported(rotation_format8 format) const { return format == rotation_format8::quatf_drop_w_variable; }
+			constexpr bool is_translation_format_supported(vector_format8 format) const { return format == vector_format8::vector3f_variable; }
+			constexpr bool is_scale_format_supported(vector_format8 format) const { return format == vector_format8::vector3f_variable; }
+			constexpr rotation_format8 get_rotation_format(rotation_format8 /*format*/) const { return rotation_format8::quatf_drop_w_variable; }
+			constexpr vector_format8 get_translation_format(vector_format8 /*format*/) const { return vector_format8::vector3f_variable; }
+			constexpr vector_format8 get_scale_format(vector_format8 /*format*/) const { return vector_format8::vector3f_variable; }
+
+			constexpr range_reduction_flags8 get_range_reduction(range_reduction_flags8 /*flags*/) const { return range_reduction_flags8::all_tracks; }
 		};
 
 		//////////////////////////////////////////////////////////////////////////
@@ -316,7 +298,7 @@ namespace acl
 
 			//////////////////////////////////////////////////////////////////////////
 			// Seeks within the compressed clip to a particular point in time
-			void seek(float sample_time, SampleRoundingPolicy rounding_policy);
+			void seek(float sample_time, sample_rounding_policy rounding_policy);
 
 			//////////////////////////////////////////////////////////////////////////
 			// Decompress a full pose at the current sample time.
@@ -393,17 +375,13 @@ namespace acl
 		inline void DecompressionContext<DecompressionSettingsType>::initialize(const CompressedClip& clip)
 		{
 			ACL_ASSERT(clip.is_valid(false).empty(), "CompressedClip is not valid");
-			ACL_ASSERT(clip.get_algorithm_type() == AlgorithmType8::UniformlySampled, "Invalid algorithm type [%s], expected [%s]", get_algorithm_name(clip.get_algorithm_type()), get_algorithm_name(AlgorithmType8::UniformlySampled));
+			ACL_ASSERT(clip.get_algorithm_type() == algorithm_type8::uniformly_sampled, "Invalid algorithm type [%s], expected [%s]", get_algorithm_name(clip.get_algorithm_type()), get_algorithm_name(algorithm_type8::uniformly_sampled));
 
 			const ClipHeader& header = get_clip_header(clip);
 
-			const RotationFormat8 rotation_format = m_settings.get_rotation_format(header.rotation_format);
-			const VectorFormat8 translation_format = m_settings.get_translation_format(header.translation_format);
-			const VectorFormat8 scale_format = m_settings.get_translation_format(header.scale_format);
-
-#if defined(ACL_HAS_ASSERT_CHECKS)
-			const RangeReductionFlags8 clip_range_reduction = m_settings.get_clip_range_reduction(header.clip_range_reduction);
-			const RangeReductionFlags8 segment_range_reduction = m_settings.get_segment_range_reduction(header.segment_range_reduction);
+			const rotation_format8 rotation_format = m_settings.get_rotation_format(header.rotation_format);
+			const vector_format8 translation_format = m_settings.get_translation_format(header.translation_format);
+			const vector_format8 scale_format = m_settings.get_translation_format(header.scale_format);
 
 			ACL_ASSERT(rotation_format == header.rotation_format, "Statically compiled rotation format (%s) differs from the compressed rotation format (%s)!", get_rotation_format_name(rotation_format), get_rotation_format_name(header.rotation_format));
 			ACL_ASSERT(m_settings.is_rotation_format_supported(rotation_format), "Rotation format (%s) isn't statically supported!", get_rotation_format_name(rotation_format));
@@ -411,11 +389,6 @@ namespace acl
 			ACL_ASSERT(m_settings.is_translation_format_supported(translation_format), "Translation format (%s) isn't statically supported!", get_vector_format_name(translation_format));
 			ACL_ASSERT(scale_format == header.scale_format, "Statically compiled scale format (%s) differs from the compressed scale format (%s)!", get_vector_format_name(scale_format), get_vector_format_name(header.scale_format));
 			ACL_ASSERT(m_settings.is_scale_format_supported(scale_format), "Scale format (%s) isn't statically supported!", get_vector_format_name(scale_format));
-			ACL_ASSERT((clip_range_reduction & header.clip_range_reduction) == header.clip_range_reduction, "Statically compiled clip range reduction settings (%u) differs from the compressed settings (%u)!", clip_range_reduction, header.clip_range_reduction);
-			ACL_ASSERT(m_settings.are_clip_range_reduction_flags_supported(clip_range_reduction), "Clip range reduction settings (%u) aren't statically supported!", clip_range_reduction);
-			ACL_ASSERT((segment_range_reduction & header.segment_range_reduction) == header.segment_range_reduction, "Statically compiled segment range reduction settings (%u) differs from the compressed settings (%u)!", segment_range_reduction, header.segment_range_reduction);
-			ACL_ASSERT(m_settings.are_segment_range_reduction_flags_supported(segment_range_reduction), "Segment range reduction settings (%u) aren't statically supported!", segment_range_reduction);
-#endif
 
 			m_context.clip = &clip;
 			m_context.clip_hash = clip.get_hash();
@@ -436,13 +409,21 @@ namespace acl
 
 			const uint32_t num_tracks_per_bone = header.has_scale ? 3 : 2;
 			m_context.bitset_desc = BitSetDescription::make_from_num_bits(header.num_bones * num_tracks_per_bone);
-			m_context.num_rotation_components = rotation_format == RotationFormat8::Quat_128 ? 4 : 3;
 
-			// If all tracks are variable, no need for any extra padding except at the very end of the data
-			// If our tracks are mixed variable/not variable, we need to add some padding to ensure alignment
-			const bool is_every_format_variable = is_rotation_format_variable(rotation_format) && is_vector_format_variable(translation_format) && is_vector_format_variable(scale_format);
-			const bool is_any_format_variable = is_rotation_format_variable(rotation_format) || is_vector_format_variable(translation_format) || is_vector_format_variable(scale_format);
-			m_context.has_mixed_packing = !is_every_format_variable && is_any_format_variable;
+			range_reduction_flags8 range_reduction = range_reduction_flags8::none;
+			if (is_rotation_format_variable(rotation_format))
+				range_reduction |= range_reduction_flags8::rotations;
+			if (is_vector_format_variable(translation_format))
+				range_reduction |= range_reduction_flags8::translations;
+			if (is_vector_format_variable(scale_format))
+				range_reduction |= range_reduction_flags8::scales;
+
+			m_context.range_reduction = m_settings.get_range_reduction(range_reduction);
+
+			ACL_ASSERT((m_context.range_reduction & range_reduction) == range_reduction, "Statically compiled range reduction flags (%u) differ from the compressed flags (%u)!", m_context.range_reduction, range_reduction);
+			ACL_ASSERT(m_settings.are_range_reduction_flags_supported(m_context.range_reduction), "Range reduction flags (%u) aren't statically supported!", m_context.range_reduction);
+
+			m_context.num_rotation_components = rotation_format == rotation_format8::quatf_full ? 4 : 3;
 		}
 
 		template<class DecompressionSettingsType>
@@ -458,7 +439,7 @@ namespace acl
 		}
 
 		template<class DecompressionSettingsType>
-		inline void DecompressionContext<DecompressionSettingsType>::seek(float sample_time, SampleRoundingPolicy rounding_policy)
+		inline void DecompressionContext<DecompressionSettingsType>::seek(float sample_time, sample_rounding_policy rounding_policy)
 		{
 			ACL_ASSERT(m_context.clip != nullptr, "Context is not initialized");
 
@@ -540,8 +521,6 @@ namespace acl
 			m_context.animated_track_data[0] = header.get_track_data(*segment_header0);
 			m_context.animated_track_data[1] = header.get_track_data(*segment_header1);
 
-			m_context.key_frame_byte_offsets[0] = (segment_key_frame0 * segment_header0->animated_pose_bit_size) / 8;
-			m_context.key_frame_byte_offsets[1] = (segment_key_frame1 * segment_header1->animated_pose_bit_size) / 8;
 			m_context.key_frame_bit_offsets[0] = segment_key_frame0 * segment_header0->animated_pose_bit_size;
 			m_context.key_frame_bit_offsets[1] = segment_key_frame1 * segment_header1->animated_pose_bit_size;
 		}
@@ -574,8 +553,6 @@ namespace acl
 			sampling_context.clip_range_data_offset = 0;
 			sampling_context.format_per_track_data_offset = 0;
 			sampling_context.segment_range_data_offset = 0;
-			sampling_context.key_frame_byte_offsets[0] = m_context.key_frame_byte_offsets[0];
-			sampling_context.key_frame_byte_offsets[1] = m_context.key_frame_byte_offsets[1];
 			sampling_context.key_frame_bit_offsets[0] = m_context.key_frame_bit_offsets[0];
 			sampling_context.key_frame_bit_offsets[1] = m_context.key_frame_bit_offsets[1];
 
@@ -634,18 +611,15 @@ namespace acl
 			const acl_impl::ScaleDecompressionSettingsAdapter<DecompressionSettingsType> scale_adapter(m_settings, header);
 
 			acl_impl::SamplingContext sampling_context;
-			sampling_context.key_frame_byte_offsets[0] = m_context.key_frame_byte_offsets[0];
-			sampling_context.key_frame_byte_offsets[1] = m_context.key_frame_byte_offsets[1];
 			sampling_context.key_frame_bit_offsets[0] = m_context.key_frame_bit_offsets[0];
 			sampling_context.key_frame_bit_offsets[1] = m_context.key_frame_bit_offsets[1];
 
-			const RotationFormat8 rotation_format = m_settings.get_rotation_format(header.rotation_format);
-			const VectorFormat8 translation_format = m_settings.get_translation_format(header.translation_format);
-			const VectorFormat8 scale_format = m_settings.get_translation_format(header.scale_format);
+			const rotation_format8 rotation_format = m_settings.get_rotation_format(header.rotation_format);
+			const vector_format8 translation_format = m_settings.get_translation_format(header.translation_format);
+			const vector_format8 scale_format = m_settings.get_translation_format(header.scale_format);
 
 			const bool are_all_tracks_variable = is_rotation_format_variable(rotation_format) && is_vector_format_variable(translation_format) && is_vector_format_variable(scale_format);
-			const bool has_mixed_padding_or_fixed_quantization = (m_settings.supports_mixed_packing() && m_context.has_mixed_packing) || !are_all_tracks_variable;
-			if (has_mixed_padding_or_fixed_quantization)
+			if (!are_all_tracks_variable)
 			{
 				// Slow path, not optimized yet because it's more complex and shouldn't be used in production anyway
 				sampling_context.track_index = 0;
@@ -752,28 +726,31 @@ namespace acl
 				const uint32_t num_animated_rotations = sample_bone_index - num_constant_rotations;
 				const uint32_t num_animated_translations = sample_bone_index - num_constant_translations;
 
-				const RotationFormat8 packed_rotation_format = is_rotation_format_variable(rotation_format) ? get_highest_variant_precision(get_rotation_variant(rotation_format)) : rotation_format;
+				const rotation_format8 packed_rotation_format = is_rotation_format_variable(rotation_format) ? get_highest_variant_precision(get_rotation_variant(rotation_format)) : rotation_format;
 				const uint32_t packed_rotation_size = get_packed_rotation_size(packed_rotation_format);
 
 				uint32_t constant_track_data_offset = (num_constant_rotations - num_default_rotations) * packed_rotation_size;
-				constant_track_data_offset += (num_constant_translations - num_default_translations) * get_packed_vector_size(VectorFormat8::Vector3_96);
+				constant_track_data_offset += (num_constant_translations - num_default_translations) * get_packed_vector_size(vector_format8::vector3f_full);
 
 				uint32_t clip_range_data_offset = 0;
 				uint32_t segment_range_data_offset = 0;
 
-				const RangeReductionFlags8 clip_range_reduction = m_settings.get_clip_range_reduction(header.clip_range_reduction);
-				const RangeReductionFlags8 segment_range_reduction = m_settings.get_segment_range_reduction(header.segment_range_reduction);
-				if (are_any_enum_flags_set(clip_range_reduction, RangeReductionFlags8::Rotations))
+				const range_reduction_flags8 range_reduction = m_context.range_reduction;
+				if (are_any_enum_flags_set(range_reduction, range_reduction_flags8::rotations) && m_settings.are_range_reduction_flags_supported(range_reduction_flags8::rotations))
+				{
 					clip_range_data_offset += m_context.num_rotation_components * sizeof(float) * 2 * num_animated_rotations;
 
-				if (are_any_enum_flags_set(segment_range_reduction, RangeReductionFlags8::Rotations))
-					segment_range_data_offset += m_context.num_rotation_components * k_segment_range_reduction_num_bytes_per_component * 2 * num_animated_rotations;
+					if (header.num_segments > 1)
+						segment_range_data_offset += m_context.num_rotation_components * k_segment_range_reduction_num_bytes_per_component * 2 * num_animated_rotations;
+				}
 
-				if (are_any_enum_flags_set(clip_range_reduction, RangeReductionFlags8::Translations))
+				if (are_any_enum_flags_set(range_reduction, range_reduction_flags8::translations) && m_settings.are_range_reduction_flags_supported(range_reduction_flags8::translations))
+				{
 					clip_range_data_offset += k_clip_range_reduction_vector3_range_size * num_animated_translations;
 
-				if (are_any_enum_flags_set(segment_range_reduction, RangeReductionFlags8::Translations))
-					segment_range_data_offset += 3 * k_segment_range_reduction_num_bytes_per_component * 2 * num_animated_translations;
+					if (header.num_segments > 1)
+						segment_range_data_offset += 3 * k_segment_range_reduction_num_bytes_per_component * 2 * num_animated_translations;
+				}
 
 				uint32_t num_animated_tracks = num_animated_rotations + num_animated_translations;
 				if (header.has_scale)
@@ -781,13 +758,15 @@ namespace acl
 					const uint32_t num_animated_scales = sample_bone_index - num_constant_scales;
 					num_animated_tracks += num_animated_scales;
 
-					constant_track_data_offset += (num_constant_scales - num_default_scales) * get_packed_vector_size(VectorFormat8::Vector3_96);
+					constant_track_data_offset += (num_constant_scales - num_default_scales) * get_packed_vector_size(vector_format8::vector3f_full);
 
-					if (are_any_enum_flags_set(clip_range_reduction, RangeReductionFlags8::Scales))
+					if (are_any_enum_flags_set(range_reduction, range_reduction_flags8::scales) && m_settings.are_range_reduction_flags_supported(range_reduction_flags8::scales))
+					{
 						clip_range_data_offset += k_clip_range_reduction_vector3_range_size * num_animated_scales;
 
-					if (are_any_enum_flags_set(segment_range_reduction, RangeReductionFlags8::Scales))
-						segment_range_data_offset += 3 * k_segment_range_reduction_num_bytes_per_component * 2 * num_animated_scales;
+						if (header.num_segments > 1)
+							segment_range_data_offset += 3 * k_segment_range_reduction_num_bytes_per_component * 2 * num_animated_scales;
+					}
 				}
 
 				sampling_context.track_index = track_index;
diff --git a/includes/acl/algorithm/uniformly_sampled/encoder.h b/includes/acl/algorithm/uniformly_sampled/encoder.h
--- a/includes/acl/algorithm/uniformly_sampled/encoder.h
+++ b/includes/acl/algorithm/uniformly_sampled/encoder.h
@@ -96,6 +96,24 @@ namespace acl
 
 			ScopeProfiler compression_time;
 
+			// If every track is retains full precision, we disable segmenting since it provides no benefit
+			if (!is_rotation_format_variable(settings.rotation_format) && !is_vector_format_variable(settings.translation_format) && !is_vector_format_variable(settings.scale_format))
+			{
+				settings.segmenting.ideal_num_samples = 0xFFFF;
+				settings.segmenting.max_num_samples = 0xFFFF;
+			}
+
+			// Variable bit rate tracks need range reduction
+			range_reduction_flags8 range_reduction = range_reduction_flags8::none;
+			if (is_rotation_format_variable(settings.rotation_format))
+				range_reduction |= range_reduction_flags8::rotations;
+
+			if (is_vector_format_variable(settings.translation_format))
+				range_reduction |= range_reduction_flags8::translations;
+
+			if (is_vector_format_variable(settings.scale_format))
+				range_reduction |= range_reduction_flags8::scales;
+
 			const uint32_t num_samples = clip.get_num_samples();
 			const RigidSkeleton& skeleton = clip.get_skeleton();
 
@@ -119,28 +137,20 @@ namespace acl
 			compact_constant_streams(allocator, clip_context, settings.constant_rotation_threshold_angle, settings.constant_translation_threshold, settings.constant_scale_threshold);
 
 			uint32_t clip_range_data_size = 0;
-			if (settings.range_reduction != RangeReductionFlags8::None)
+			if (range_reduction != range_reduction_flags8::none)
 			{
-				normalize_clip_streams(clip_context, settings.range_reduction);
-				clip_range_data_size = get_stream_range_data_size(clip_context, settings.range_reduction, settings.rotation_format);
+				normalize_clip_streams(clip_context, range_reduction);
+				clip_range_data_size = get_stream_range_data_size(clip_context, range_reduction, settings.rotation_format);
 			}
 
-			if (settings.segmenting.enabled)
-			{
-				segment_streams(allocator, clip_context, settings.segmenting);
-
-				// If we have a single segment, disable range reduction since it won't help
-				if (clip_context.num_segments == 1)
-					settings.segmenting.range_reduction = RangeReductionFlags8::None;
+			segment_streams(allocator, clip_context, settings.segmenting);
 
-				if (settings.segmenting.range_reduction != RangeReductionFlags8::None)
-				{
-					extract_segment_bone_ranges(allocator, clip_context);
-					normalize_segment_streams(clip_context, settings.segmenting.range_reduction);
-				}
+			// If we have a single segment, skip segment range reduction since it won't help
+			if (range_reduction != range_reduction_flags8::none && clip_context.num_segments > 1)
+			{
+				extract_segment_bone_ranges(allocator, clip_context);
+				normalize_segment_streams(clip_context, range_reduction);
 			}
-			else
-				settings.segmenting.range_reduction = RangeReductionFlags8::None;
 
 			quantize_streams(allocator, clip_context, settings, skeleton, raw_clip_context, additive_base_clip_context, out_stats);
 
@@ -149,7 +159,7 @@ namespace acl
 
 			const uint32_t constant_data_size = get_constant_data_size(clip_context, output_bone_mapping, num_output_bones);
 
-			calculate_animated_data_size(clip_context, settings.rotation_format, settings.translation_format, settings.scale_format, output_bone_mapping, num_output_bones);
+			calculate_animated_data_size(clip_context, output_bone_mapping, num_output_bones);
 
 			const uint32_t format_per_track_data_size = get_format_per_track_data_size(clip_context, settings.rotation_format, settings.translation_format, settings.scale_format);
 
@@ -219,7 +229,7 @@ namespace acl
 
 			uint8_t* buffer = allocate_type_array_aligned<uint8_t>(allocator, buffer_size, 16);
 
-			CompressedClip* compressed_clip = make_compressed_clip(buffer, buffer_size, AlgorithmType8::UniformlySampled);
+			CompressedClip* compressed_clip = make_compressed_clip(buffer, buffer_size, algorithm_type8::uniformly_sampled);
 
 			ClipHeader& header = get_clip_header(*compressed_clip);
 			header.num_bones = num_output_bones;
@@ -227,10 +237,8 @@ namespace acl
 			header.rotation_format = settings.rotation_format;
 			header.translation_format = settings.translation_format;
 			header.scale_format = settings.scale_format;
-			header.clip_range_reduction = settings.range_reduction;
-			header.segment_range_reduction = settings.segmenting.range_reduction;
 			header.has_scale = clip_context.has_scale ? 1 : 0;
-			header.default_scale = additive_base_clip == nullptr || clip.get_additive_format() != AdditiveClipFormat8::Additive1;
+			header.default_scale = additive_base_clip == nullptr || clip.get_additive_format() != additive_clip_format8::additive1;
 			header.num_samples = num_samples;
 			header.sample_rate = clip.get_sample_rate();
 			header.segment_start_indices_offset = sizeof(ClipHeader);
@@ -255,12 +263,12 @@ namespace acl
 			else
 				header.constant_track_data_offset = InvalidPtrOffset();
 
-			if (settings.range_reduction != RangeReductionFlags8::None)
-				write_clip_range_data(clip_context, settings.range_reduction, header.get_clip_range_data(), clip_range_data_size, output_bone_mapping, num_output_bones);
+			if (range_reduction != range_reduction_flags8::none)
+				write_clip_range_data(clip_context, range_reduction, header.get_clip_range_data(), clip_range_data_size, output_bone_mapping, num_output_bones);
 			else
 				header.clip_range_data_offset = InvalidPtrOffset();
 
-			write_segment_data(clip_context, settings, header, output_bone_mapping, num_output_bones);
+			write_segment_data(clip_context, settings, range_reduction, header, output_bone_mapping, num_output_bones);
 
 			finalize_compressed_clip(*compressed_clip);
 
diff --git a/includes/acl/compression/animation_clip.h b/includes/acl/compression/animation_clip.h
--- a/includes/acl/compression/animation_clip.h
+++ b/includes/acl/compression/animation_clip.h
@@ -93,7 +93,7 @@ namespace acl
 			, m_sample_rate(sample_rate)
 			, m_num_bones(skeleton.get_num_bones())
 			, m_additive_base_clip(nullptr)
-			, m_additive_format(AdditiveClipFormat8::None)
+			, m_additive_format(additive_clip_format8::none)
 			, m_name(allocator, name)
 		{
 			m_bones = allocate_type_array<AnimatedBone>(allocator, m_num_bones);
@@ -166,7 +166,7 @@ namespace acl
 		//    - rounding_policy: The rounding policy to use when sampling
 		//    - out_local_pose: An array of at least 'num_transforms' to output the data in
 		//    - num_transforms: The number of transforms in the output array
-		void sample_pose(float sample_time, SampleRoundingPolicy rounding_policy, rtm::qvvf* out_local_pose, uint16_t num_transforms) const
+		void sample_pose(float sample_time, sample_rounding_policy rounding_policy, rtm::qvvf* out_local_pose, uint16_t num_transforms) const
 		{
 			ACL_ASSERT(m_num_bones > 0, "Invalid number of bones: %u", m_num_bones);
 			ACL_ASSERT(m_num_bones == num_transforms, "Number of transforms does not match the number of bones: %u != %u", num_transforms, m_num_bones);
@@ -209,7 +209,7 @@ namespace acl
 		//    - num_transforms: The number of transforms in the output array
 		void sample_pose(float sample_time, rtm::qvvf* out_local_pose, uint16_t num_transforms) const
 		{
-			sample_pose(sample_time, SampleRoundingPolicy::None, out_local_pose, num_transforms);
+			sample_pose(sample_time, sample_rounding_policy::none, out_local_pose, num_transforms);
 		}
 
 		//////////////////////////////////////////////////////////////////////////
@@ -227,7 +227,7 @@ namespace acl
 
 		//////////////////////////////////////////////////////////////////////////
 		// Sets the base animation clip and marks this instance as an additive clip of the provided format
-		void set_additive_base(const AnimationClip* base_clip, AdditiveClipFormat8 additive_format) { m_additive_base_clip = base_clip; m_additive_format = additive_format; }
+		void set_additive_base(const AnimationClip* base_clip, additive_clip_format8 additive_format) { m_additive_base_clip = base_clip; m_additive_format = additive_format; }
 
 		//////////////////////////////////////////////////////////////////////////
 		// Returns the additive base clip, if any
@@ -235,7 +235,7 @@ namespace acl
 
 		//////////////////////////////////////////////////////////////////////////
 		// Returns the additive format of this clip, if any
-		AdditiveClipFormat8 get_additive_format() const { return m_additive_format; }
+		additive_clip_format8 get_additive_format() const { return m_additive_format; }
 
 		//////////////////////////////////////////////////////////////////////////
 		// Checks if the instance of this clip is valid and returns an error if it isn't
@@ -366,7 +366,7 @@ namespace acl
 		const AnimationClip*	m_additive_base_clip;
 
 		// If we have an additive base, this is the format we are in
-		AdditiveClipFormat8		m_additive_format;
+		additive_clip_format8		m_additive_format;
 
 		// The name of the clip
 		String					m_name;
diff --git a/includes/acl/compression/animation_track.h b/includes/acl/compression/animation_track.h
--- a/includes/acl/compression/animation_track.h
+++ b/includes/acl/compression/animation_track.h
@@ -69,7 +69,7 @@ namespace acl
 			, m_sample_data(nullptr)
 			, m_num_samples(0)
 			, m_sample_rate(0.0F)
-			, m_type(AnimationTrackType8::Rotation)
+			, m_type(animation_track_type8::rotation)
 		{}
 
 		AnimationTrack(AnimationTrack&& other)
@@ -89,7 +89,7 @@ namespace acl
 		//    - num_samples: The number of samples in this track
 		//    - sample_rate: The rate at which samples are recorded (e.g. 30 means 30 FPS)
 		//    - type: The track type
-		AnimationTrack(IAllocator& allocator, uint32_t num_samples, float sample_rate, AnimationTrackType8 type)
+		AnimationTrack(IAllocator& allocator, uint32_t num_samples, float sample_rate, animation_track_type8 type)
 			: m_allocator(&allocator)
 			, m_sample_data(allocate_type_array_aligned<double>(allocator, size_t(num_samples) * get_animation_track_sample_size(type), alignof(rtm::vector4d)))
 			, m_num_samples(num_samples)
@@ -119,14 +119,14 @@ namespace acl
 		//////////////////////////////////////////////////////////////////////////
 		// Returns the number of values per sample
 		// TODO: constexpr
-		static uint32_t get_animation_track_sample_size(AnimationTrackType8 type)
+		static uint32_t get_animation_track_sample_size(animation_track_type8 type)
 		{
 			switch (type)
 			{
 			default:
-			case AnimationTrackType8::Rotation:		return 4;
-			case AnimationTrackType8::Translation:	return 3;
-			case AnimationTrackType8::Scale:		return 3;
+			case animation_track_type8::rotation:		return 4;
+			case animation_track_type8::translation:	return 3;
+			case animation_track_type8::scale:		return 3;
 			}
 		}
 
@@ -143,7 +143,7 @@ namespace acl
 		float							m_sample_rate;
 
 		// The track type
-		AnimationTrackType8				m_type;
+		animation_track_type8				m_type;
 	};
 
 	//////////////////////////////////////////////////////////////////////////
@@ -163,7 +163,7 @@ namespace acl
 		//    - num_samples: The number of samples in this track
 		//    - sample_rate: The rate at which samples are recorded (e.g. 30 means 30 FPS)
 		AnimationRotationTrack(IAllocator& allocator, uint32_t num_samples, float sample_rate)
-			: AnimationTrack(allocator, num_samples, sample_rate, AnimationTrackType8::Rotation)
+			: AnimationTrack(allocator, num_samples, sample_rate, animation_track_type8::rotation)
 		{
 			rtm::quatd* samples = safe_ptr_cast<rtm::quatd>(&m_sample_data[0]);
 			std::fill(samples, samples + num_samples, rtm::quat_identity());
@@ -229,7 +229,7 @@ namespace acl
 		//    - num_samples: The number of samples in this track
 		//    - sample_rate: The rate at which samples are recorded (e.g. 30 means 30 FPS)
 		AnimationTranslationTrack(IAllocator& allocator, uint32_t num_samples, float sample_rate)
-			: AnimationTrack(allocator, num_samples, sample_rate, AnimationTrackType8::Translation)
+			: AnimationTrack(allocator, num_samples, sample_rate, animation_track_type8::translation)
 		{
 			std::fill(m_sample_data, m_sample_data + (num_samples * 3), 0.0);
 		}
@@ -293,7 +293,7 @@ namespace acl
 		//    - num_samples: The number of samples in this track
 		//    - sample_rate: The rate at which samples are recorded (e.g. 30 means 30 FPS)
 		AnimationScaleTrack(IAllocator& allocator, uint32_t num_samples, float sample_rate)
-			: AnimationTrack(allocator, num_samples, sample_rate, AnimationTrackType8::Scale)
+			: AnimationTrack(allocator, num_samples, sample_rate, animation_track_type8::scale)
 		{
 			rtm::vector4d defaultScale = rtm::vector_set(1.0);
 			for (uint32_t sample_index = 0; sample_index < num_samples; ++sample_index)
diff --git a/includes/acl/compression/compress.h b/includes/acl/compression/compress.h
--- a/includes/acl/compression/compress.h
+++ b/includes/acl/compression/compress.h
@@ -124,8 +124,8 @@ namespace acl
 
 		// Write our primary header
 		header->tag = k_compressed_tracks_tag;
-		header->version = get_algorithm_version(AlgorithmType8::UniformlySampled);
-		header->algorithm_type = AlgorithmType8::UniformlySampled;
+		header->version = get_algorithm_version(algorithm_type8::uniformly_sampled);
+		header->algorithm_type = algorithm_type8::uniformly_sampled;
 		header->track_type = track_list.get_track_type();
 		header->num_tracks = context.num_tracks;
 		header->num_samples = context.num_samples;
diff --git a/includes/acl/compression/compression_level.h b/includes/acl/compression/compression_level.h
--- a/includes/acl/compression/compression_level.h
+++ b/includes/acl/compression/compression_level.h
@@ -34,16 +34,18 @@ ACL_IMPL_FILE_PRAGMA_PUSH
 namespace acl
 {
 	////////////////////////////////////////////////////////////////////////////////
-	// CompressionLevel8 represents how aggressively we attempt to reduce the memory
+	// compression_level8 represents how aggressively we attempt to reduce the memory
 	// footprint. Higher levels will try more permutations and bit rates. The higher
 	// the level, the slower the compression but the smaller the memory footprint.
-	enum class CompressionLevel8 : uint8_t
+	enum class compression_level8 : uint8_t
 	{
-		Lowest		= 0,	// Same as Medium for now
-		Low			= 1,	// Same as Medium for now
-		Medium		= 2,
-		High		= 3,
-		Highest		= 4,
+		lowest		= 0,	// Same as medium for now
+		low			= 1,	// Same as medium for now
+		medium		= 2,
+		high		= 3,
+		highest		= 4,
+
+		//lossless	= 255,	// Not implemented, reserved
 	};
 
 	//////////////////////////////////////////////////////////////////////////
@@ -51,55 +53,65 @@ namespace acl
 	////////////////////////////////////////////////////////////////////////////////
 	// Returns a string representing the compression level.
 	// TODO: constexpr
-	inline const char* get_compression_level_name(CompressionLevel8 level)
+	inline const char* get_compression_level_name(compression_level8 level)
 	{
 		switch (level)
 		{
-		case CompressionLevel8::Lowest:		return "Lowest";
-		case CompressionLevel8::Low:		return "Low";
-		case CompressionLevel8::Medium:		return "Medium";
-		case CompressionLevel8::High:		return "High";
-		case CompressionLevel8::Highest:	return "Highest";
+		case compression_level8::lowest:	return "lowest";
+		case compression_level8::low:		return "low";
+		case compression_level8::medium:	return "medium";
+		case compression_level8::high:		return "high";
+		case compression_level8::highest:	return "highest";
 		default:							return "<Invalid>";
 		}
 	}
 
 	//////////////////////////////////////////////////////////////////////////
 	// Returns the compression level from its string representation.
-	inline bool get_compression_level(const char* level_name, CompressionLevel8& out_level)
+	inline bool get_compression_level(const char* level_name, compression_level8& out_level)
 	{
-		const char* level_lowest = "Lowest";
-		if (std::strncmp(level_name, level_lowest, std::strlen(level_lowest)) == 0)
+		const char* level_lowest = "Lowest";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* level_lowest_new = "lowest";
+		if (std::strncmp(level_name, level_lowest, std::strlen(level_lowest)) == 0
+			|| std::strncmp(level_name, level_lowest_new, std::strlen(level_lowest_new)) == 0)
 		{
-			out_level = CompressionLevel8::Lowest;
+			out_level = compression_level8::lowest;
 			return true;
 		}
 
-		const char* level_low = "Low";
-		if (std::strncmp(level_name, level_low, std::strlen(level_low)) == 0)
+		const char* level_low = "Low";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* level_low_new = "low";
+		if (std::strncmp(level_name, level_low, std::strlen(level_low)) == 0
+			|| std::strncmp(level_name, level_low_new, std::strlen(level_low_new)) == 0)
 		{
-			out_level = CompressionLevel8::Low;
+			out_level = compression_level8::low;
 			return true;
 		}
 
-		const char* level_medium = "Medium";
-		if (std::strncmp(level_name, level_medium, std::strlen(level_medium)) == 0)
+		const char* level_medium = "Medium";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* level_medium_new = "medium";
+		if (std::strncmp(level_name, level_medium, std::strlen(level_medium)) == 0
+			|| std::strncmp(level_name, level_medium_new, std::strlen(level_medium_new)) == 0)
 		{
-			out_level = CompressionLevel8::Medium;
+			out_level = compression_level8::medium;
 			return true;
 		}
 
-		const char* level_highest = "Highest";
-		if (std::strncmp(level_name, level_highest, std::strlen(level_highest)) == 0)
+		const char* level_highest = "Highest";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* level_highest_new = "highest";
+		if (std::strncmp(level_name, level_highest, std::strlen(level_highest)) == 0
+			|| std::strncmp(level_name, level_highest_new, std::strlen(level_highest_new)) == 0)
 		{
-			out_level = CompressionLevel8::Highest;
+			out_level = compression_level8::highest;
 			return true;
 		}
 
-		const char* level_high = "High";
-		if (std::strncmp(level_name, level_high, std::strlen(level_high)) == 0)
+		const char* level_high = "High";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* level_high_new = "high";
+		if (std::strncmp(level_name, level_high, std::strlen(level_high)) == 0
+			|| std::strncmp(level_name, level_high_new, std::strlen(level_high_new)) == 0)
 		{
-			out_level = CompressionLevel8::High;
+			out_level = compression_level8::high;
 			return true;
 		}
 
diff --git a/includes/acl/compression/compression_settings.h b/includes/acl/compression/compression_settings.h
--- a/includes/acl/compression/compression_settings.h
+++ b/includes/acl/compression/compression_settings.h
@@ -43,13 +43,12 @@ namespace acl
 {
 	//////////////////////////////////////////////////////////////////////////
 	// Encapsulates all the compression settings related to segmenting.
+	// Segmenting ensures that large clips are split into smaller segments and
+	// compressed independently to allow a smaller memory footprint as well as
+	// faster compression and decompression.
+	// See also: http://nfrechette.github.io/2016/11/10/anim_compression_uniform_segmenting/
 	struct SegmentingSettings
 	{
-		//////////////////////////////////////////////////////////////////////////
-		// Whether to enable segmenting or not
-		// Defaults to 'false'
-		bool enabled;
-
 		//////////////////////////////////////////////////////////////////////////
 		// How many samples to try and fit in our segments
 		// Defaults to '16'
@@ -60,16 +59,9 @@ namespace acl
 		// Defaults to '31'
 		uint16_t max_num_samples;
 
-		//////////////////////////////////////////////////////////////////////////
-		// Whether to use range reduction or not at the segment level
-		// Defaults to 'None'
-		RangeReductionFlags8 range_reduction;
-
 		SegmentingSettings()
-			: enabled(false)
-			, ideal_num_samples(16)
+			: ideal_num_samples(16)
 			, max_num_samples(31)
-			, range_reduction(RangeReductionFlags8::None)
 		{}
 
 		//////////////////////////////////////////////////////////////////////////
@@ -77,10 +69,8 @@ namespace acl
 		uint32_t get_hash() const
 		{
 			uint32_t hash_value = 0;
-			hash_value = hash_combine(hash_value, hash32(enabled));
 			hash_value = hash_combine(hash_value, hash32(ideal_num_samples));
 			hash_value = hash_combine(hash_value, hash32(max_num_samples));
-			hash_value = hash_combine(hash_value, hash32(range_reduction));
 			return hash_value;
 		}
 
@@ -89,9 +79,6 @@ namespace acl
 		// Returns nullptr if the settings are valid.
 		ErrorResult is_valid() const
 		{
-			if (!enabled)
-				return ErrorResult();
-
 			if (ideal_num_samples < 8)
 				return ErrorResult("ideal_num_samples must be greater or equal to 8");
 
@@ -110,19 +97,14 @@ namespace acl
 		// The compression level determines how aggressively we attempt to reduce the memory
 		// footprint. Higher levels will try more permutations and bit rates. The higher
 		// the level, the slower the compression but the smaller the memory footprint.
-		CompressionLevel8 level;
+		compression_level8 level;
 
 		//////////////////////////////////////////////////////////////////////////
 		// The rotation, translation, and scale formats to use. See functions get_rotation_format(..) and get_vector_format(..)
-		// Defaults to raw: 'Quat_128' and 'Vector3_96'
-		RotationFormat8 rotation_format;
-		VectorFormat8 translation_format;
-		VectorFormat8 scale_format;
-
-		//////////////////////////////////////////////////////////////////////////
-		// Whether to use range reduction or not at the clip level
-		// Defaults to 'None'
-		RangeReductionFlags8 range_reduction;
+		// Defaults to raw: 'quatf_full' and 'vector3f_full'
+		rotation_format8 rotation_format;
+		vector_format8 translation_format;
+		vector_format8 scale_format;
 
 		//////////////////////////////////////////////////////////////////////////
 		// Segmenting settings, if used
@@ -135,7 +117,7 @@ namespace acl
 
 		//////////////////////////////////////////////////////////////////////////
 		// Threshold angle when detecting if rotation tracks are constant or default.
-		// See the Quat_32 quat_near_identity for details about how the default threshold
+		// See the rtm::quatf quat_near_identity for details about how the default threshold
 		// was chosen. You will typically NEVER need to change this, the value has been
 		// selected to be as safe as possible and is independent of game engine units.
 		// Defaults to '0.00284714461' radians
@@ -163,11 +145,10 @@ namespace acl
 		//////////////////////////////////////////////////////////////////////////
 		// Default constructor sets things up to perform no compression and to leave things raw.
 		CompressionSettings()
-			: level(CompressionLevel8::Low)
-			, rotation_format(RotationFormat8::Quat_128)
-			, translation_format(VectorFormat8::Vector3_96)
-			, scale_format(VectorFormat8::Vector3_96)
-			, range_reduction(RangeReductionFlags8::None)
+			: level(compression_level8::low)
+			, rotation_format(rotation_format8::quatf_full)
+			, translation_format(vector_format8::vector3f_full)
+			, scale_format(vector_format8::vector3f_full)
 			, segmenting()
 			, error_metric(nullptr)
 			, constant_rotation_threshold_angle(rtm::radians(0.00284714461F))
@@ -185,10 +166,8 @@ namespace acl
 			hash_value = hash_combine(hash_value, hash32(rotation_format));
 			hash_value = hash_combine(hash_value, hash32(translation_format));
 			hash_value = hash_combine(hash_value, hash32(scale_format));
-			hash_value = hash_combine(hash_value, hash32(range_reduction));
 
-			if (segmenting.enabled)
-				hash_value = hash_combine(hash_value, segmenting.get_hash());
+			hash_value = hash_combine(hash_value, segmenting.get_hash());
 
 			if (error_metric != nullptr)
 				hash_value = hash_combine(hash_value, error_metric->get_hash());
@@ -207,28 +186,6 @@ namespace acl
 		// Returns nullptr if the settings are valid.
 		ErrorResult is_valid() const
 		{
-			if (translation_format != VectorFormat8::Vector3_96)
-			{
-				const bool has_clip_range_reduction = are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Translations);
-				const bool has_segment_range_reduction = segmenting.enabled && are_any_enum_flags_set(segmenting.range_reduction, RangeReductionFlags8::Translations);
-				if (!has_clip_range_reduction && !has_segment_range_reduction)
-					return ErrorResult("This translation format requires range reduction to be enabled at the clip or segment level");
-			}
-
-			if (scale_format != VectorFormat8::Vector3_96)
-			{
-				const bool has_clip_range_reduction = are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Scales);
-				const bool has_segment_range_reduction = segmenting.enabled && are_any_enum_flags_set(segmenting.range_reduction, RangeReductionFlags8::Scales);
-				if (!has_clip_range_reduction && !has_segment_range_reduction)
-					return ErrorResult("This scale format requires range reduction to be enabled at the clip or segment level");
-			}
-
-			if (segmenting.enabled && segmenting.range_reduction != RangeReductionFlags8::None)
-			{
-				if ((range_reduction & segmenting.range_reduction) != segmenting.range_reduction)
-					return ErrorResult("Per segment range reduction requires per clip range reduction to be enabled");
-			}
-
 			if (error_metric == nullptr)
 				return ErrorResult("error_metric cannot be NULL");
 
@@ -263,13 +220,10 @@ namespace acl
 	inline CompressionSettings get_default_compression_settings()
 	{
 		CompressionSettings settings;
-		settings.level = CompressionLevel8::Medium;
-		settings.rotation_format = RotationFormat8::QuatDropW_Variable;
-		settings.translation_format = VectorFormat8::Vector3_Variable;
-		settings.scale_format = VectorFormat8::Vector3_Variable;
-		settings.range_reduction = RangeReductionFlags8::AllTracks;
-		settings.segmenting.enabled = true;
-		settings.segmenting.range_reduction = RangeReductionFlags8::AllTracks;
+		settings.level = compression_level8::medium;
+		settings.rotation_format = rotation_format8::quatf_drop_w_variable;
+		settings.translation_format = vector_format8::vector3f_variable;
+		settings.scale_format = vector_format8::vector3f_variable;
 		return settings;
 	}
 
diff --git a/includes/acl/compression/impl/clip_context.h b/includes/acl/compression/impl/clip_context.h
--- a/includes/acl/compression/impl/clip_context.h
+++ b/includes/acl/compression/impl/clip_context.h
@@ -63,7 +63,7 @@ namespace acl
 			bool has_scale;
 			bool has_additive_base;
 
-			AdditiveClipFormat8 additive_format;
+			additive_clip_format8 additive_format;
 
 			// Stat tracking
 			uint32_t decomp_touched_bytes;
@@ -119,9 +119,9 @@ namespace acl
 				bone_stream.parent_bone_index = skel_bone.parent_index;
 				bone_stream.output_index = bone.output_index;
 
-				bone_stream.rotations = RotationTrackStream(allocator, num_samples, sizeof(rtm::quatf), sample_rate, RotationFormat8::Quat_128);
-				bone_stream.translations = TranslationTrackStream(allocator, num_samples, sizeof(rtm::vector4f), sample_rate, VectorFormat8::Vector3_96);
-				bone_stream.scales = ScaleTrackStream(allocator, num_samples, sizeof(rtm::vector4f), sample_rate, VectorFormat8::Vector3_96);
+				bone_stream.rotations = RotationTrackStream(allocator, num_samples, sizeof(rtm::quatf), sample_rate, rotation_format8::quatf_full);
+				bone_stream.translations = TranslationTrackStream(allocator, num_samples, sizeof(rtm::vector4f), sample_rate, vector_format8::vector3f_full);
+				bone_stream.scales = ScaleTrackStream(allocator, num_samples, sizeof(rtm::vector4f), sample_rate, vector_format8::vector3f_full);
 
 				for (uint32_t sample_index = 0; sample_index < num_samples; ++sample_index)
 				{
diff --git a/includes/acl/compression/impl/compact_constant_streams.h b/includes/acl/compression/impl/compact_constant_streams.h
--- a/includes/acl/compression/impl/compact_constant_streams.h
+++ b/includes/acl/compression/impl/compact_constant_streams.h
@@ -52,12 +52,10 @@ namespace acl
 
 				switch (track.get_rotation_format())
 				{
-				case RotationFormat8::Quat_128:
+				case rotation_format8::quatf_full:
 					return rtm::vector_to_quat(rotation);
-				case RotationFormat8::QuatDropW_96:
-				case RotationFormat8::QuatDropW_48:
-				case RotationFormat8::QuatDropW_32:
-				case RotationFormat8::QuatDropW_Variable:
+				case rotation_format8::quatf_drop_w_full:
+				case rotation_format8::quatf_drop_w_variable:
 					return rtm::quat_from_positive_w(rotation);
 				default:
 					ACL_ASSERT(false, "Invalid or unsupported rotation format: %s", get_rotation_format_name(track.get_rotation_format()));
diff --git a/includes/acl/compression/impl/compressed_clip_impl.h b/includes/acl/compression/impl/compressed_clip_impl.h
--- a/includes/acl/compression/impl/compressed_clip_impl.h
+++ b/includes/acl/compression/impl/compressed_clip_impl.h
@@ -33,7 +33,7 @@ namespace acl
 {
 	namespace acl_impl
 	{
-		inline CompressedClip* make_compressed_clip(void* buffer, uint32_t size, AlgorithmType8 type)
+		inline CompressedClip* make_compressed_clip(void* buffer, uint32_t size, algorithm_type8 type)
 		{
 			return new(buffer) CompressedClip(size, type);
 		}
diff --git a/includes/acl/compression/impl/convert_rotation_streams.h b/includes/acl/compression/impl/convert_rotation_streams.h
--- a/includes/acl/compression/impl/convert_rotation_streams.h
+++ b/includes/acl/compression/impl/convert_rotation_streams.h
@@ -40,18 +40,18 @@ namespace acl
 {
 	namespace acl_impl
 	{
-		inline rtm::vector4f RTM_SIMD_CALL convert_rotation(rtm::vector4f_arg0 rotation, RotationFormat8 from, RotationFormat8 to)
+		inline rtm::vector4f RTM_SIMD_CALL convert_rotation(rtm::vector4f_arg0 rotation, rotation_format8 from, rotation_format8 to)
 		{
-			ACL_ASSERT(from == RotationFormat8::Quat_128, "Source rotation format must be a full precision quaternion");
+			ACL_ASSERT(from == rotation_format8::quatf_full, "Source rotation format must be a full precision quaternion");
 			(void)from;
 
-			const RotationFormat8 high_precision_format = get_rotation_variant(to) == RotationVariant8::Quat ? RotationFormat8::Quat_128 : RotationFormat8::QuatDropW_96;
+			const rotation_format8 high_precision_format = get_rotation_variant(to) == rotation_variant8::quat ? rotation_format8::quatf_full : rotation_format8::quatf_drop_w_full;
 			switch (high_precision_format)
 			{
-			case RotationFormat8::Quat_128:
+			case rotation_format8::quatf_full:
 				// Original format, nothing to do
 				return rotation;
-			case RotationFormat8::QuatDropW_96:
+			case rotation_format8::quatf_drop_w_full:
 				// Drop W, we just ensure it is positive and write it back, the W component can be ignored afterwards
 				return rtm::quat_to_vector(rtm::quat_ensure_positive_w(rtm::vector_to_quat(rotation)));
 			default:
@@ -60,13 +60,13 @@ namespace acl
 			}
 		}
 
-		inline void convert_rotation_streams(IAllocator& allocator, SegmentContext& segment, RotationFormat8 rotation_format)
+		inline void convert_rotation_streams(IAllocator& allocator, SegmentContext& segment, rotation_format8 rotation_format)
 		{
-			const RotationFormat8 high_precision_format = get_rotation_variant(rotation_format) == RotationVariant8::Quat ? RotationFormat8::Quat_128 : RotationFormat8::QuatDropW_96;
+			const rotation_format8 high_precision_format = get_rotation_variant(rotation_format) == rotation_variant8::quat ? rotation_format8::quatf_full : rotation_format8::quatf_drop_w_full;
 
 			for (BoneStreams& bone_stream : segment.bone_iterator())
 			{
-				// We convert our rotation stream in place. We assume that the original format is Quat_128 stored as rtm::quatf
+				// We convert our rotation stream in place. We assume that the original format is quatf_full stored as rtm::quatf
 				// For all other formats, we keep the same sample size and either keep Quat_32 or use rtm::vector4f
 				ACL_ASSERT(bone_stream.rotations.get_sample_size() == sizeof(rtm::quatf), "Unexpected rotation sample size. %u != %u", bone_stream.rotations.get_sample_size(), sizeof(rtm::quatf));
 
@@ -80,10 +80,10 @@ namespace acl
 
 					switch (high_precision_format)
 					{
-					case RotationFormat8::Quat_128:
+					case rotation_format8::quatf_full:
 						// Original format, nothing to do
 						break;
-					case RotationFormat8::QuatDropW_96:
+					case rotation_format8::quatf_drop_w_full:
 						// Drop W, we just ensure it is positive and write it back, the W component can be ignored afterwards
 						rotation = rtm::quat_ensure_positive_w(rotation);
 						break;
@@ -99,7 +99,7 @@ namespace acl
 			}
 		}
 
-		inline void convert_rotation_streams(IAllocator& allocator, ClipContext& clip_context, RotationFormat8 rotation_format)
+		inline void convert_rotation_streams(IAllocator& allocator, ClipContext& clip_context, rotation_format8 rotation_format)
 		{
 			for (SegmentContext& segment : clip_context.segment_iterator())
 				convert_rotation_streams(allocator, segment, rotation_format);
diff --git a/includes/acl/compression/impl/normalize_streams.h b/includes/acl/compression/impl/normalize_streams.h
--- a/includes/acl/compression/impl/normalize_streams.h
+++ b/includes/acl/compression/impl/normalize_streams.h
@@ -210,13 +210,11 @@ namespace acl
 #if defined(ACL_HAS_ASSERT_CHECKS)
 					switch (bone_stream.rotations.get_rotation_format())
 					{
-					case RotationFormat8::Quat_128:
+					case rotation_format8::quatf_full:
 						ACL_ASSERT(rtm::vector_all_greater_equal(normalized_rotation, zero) && rtm::vector_all_less_equal(normalized_rotation, one), "Invalid normalized rotation. 0.0 <= [%f, %f, %f, %f] <= 1.0", rtm::vector_get_x(normalized_rotation), rtm::vector_get_y(normalized_rotation), rtm::vector_get_z(normalized_rotation), rtm::vector_get_w(normalized_rotation));
 						break;
-					case RotationFormat8::QuatDropW_96:
-					case RotationFormat8::QuatDropW_48:
-					case RotationFormat8::QuatDropW_32:
-					case RotationFormat8::QuatDropW_Variable:
+					case rotation_format8::quatf_drop_w_full:
+					case rotation_format8::quatf_drop_w_variable:
 						ACL_ASSERT(rtm::vector_all_greater_equal3(normalized_rotation, zero) && rtm::vector_all_less_equal3(normalized_rotation, one), "Invalid normalized rotation. 0.0 <= [%f, %f, %f] <= 1.0", rtm::vector_get_x(normalized_rotation), rtm::vector_get_y(normalized_rotation), rtm::vector_get_z(normalized_rotation));
 						break;
 					}
@@ -309,50 +307,50 @@ namespace acl
 			}
 		}
 
-		inline void normalize_clip_streams(ClipContext& clip_context, RangeReductionFlags8 range_reduction)
+		inline void normalize_clip_streams(ClipContext& clip_context, range_reduction_flags8 range_reduction)
 		{
 			ACL_ASSERT(clip_context.num_segments == 1, "ClipContext must contain a single segment!");
 			SegmentContext& segment = clip_context.segments[0];
 
 			const bool has_scale = segment_context_has_scale(segment);
 
-			if (are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Rotations))
+			if (are_any_enum_flags_set(range_reduction, range_reduction_flags8::rotations))
 			{
 				normalize_rotation_streams(segment.bone_streams, clip_context.ranges, segment.num_bones);
 				clip_context.are_rotations_normalized = true;
 			}
 
-			if (are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Translations))
+			if (are_any_enum_flags_set(range_reduction, range_reduction_flags8::translations))
 			{
 				normalize_translation_streams(segment.bone_streams, clip_context.ranges, segment.num_bones);
 				clip_context.are_translations_normalized = true;
 			}
 
-			if (has_scale && are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Scales))
+			if (has_scale && are_any_enum_flags_set(range_reduction, range_reduction_flags8::scales))
 			{
 				normalize_scale_streams(segment.bone_streams, clip_context.ranges, segment.num_bones);
 				clip_context.are_scales_normalized = true;
 			}
 		}
 
-		inline void normalize_segment_streams(ClipContext& clip_context, RangeReductionFlags8 range_reduction)
+		inline void normalize_segment_streams(ClipContext& clip_context, range_reduction_flags8 range_reduction)
 		{
 			for (SegmentContext& segment : clip_context.segment_iterator())
 			{
-				if (are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Rotations))
+				if (are_any_enum_flags_set(range_reduction, range_reduction_flags8::rotations))
 				{
 					normalize_rotation_streams(segment.bone_streams, segment.ranges, segment.num_bones);
 					segment.are_rotations_normalized = true;
 				}
 
-				if (are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Translations))
+				if (are_any_enum_flags_set(range_reduction, range_reduction_flags8::translations))
 				{
 					normalize_translation_streams(segment.bone_streams, segment.ranges, segment.num_bones);
 					segment.are_translations_normalized = true;
 				}
 
 				const bool has_scale = segment_context_has_scale(segment);
-				if (has_scale && are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Scales))
+				if (has_scale && are_any_enum_flags_set(range_reduction, range_reduction_flags8::scales))
 				{
 					normalize_scale_streams(segment.bone_streams, segment.ranges, segment.num_bones);
 					segment.are_scales_normalized = true;
@@ -364,18 +362,18 @@ namespace acl
 				{
 					const BoneStreams& bone_stream = segment.bone_streams[bone_index];
 
-					if (are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Rotations) && !bone_stream.is_rotation_constant)
+					if (are_any_enum_flags_set(range_reduction, range_reduction_flags8::rotations) && !bone_stream.is_rotation_constant)
 					{
-						if (bone_stream.rotations.get_rotation_format() == RotationFormat8::Quat_128)
+						if (bone_stream.rotations.get_rotation_format() == rotation_format8::quatf_full)
 							range_data_size += k_segment_range_reduction_num_bytes_per_component * 8;
 						else
 							range_data_size += k_segment_range_reduction_num_bytes_per_component * 6;
 					}
 
-					if (are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Translations) && !bone_stream.is_translation_constant)
+					if (are_any_enum_flags_set(range_reduction, range_reduction_flags8::translations) && !bone_stream.is_translation_constant)
 						range_data_size += k_segment_range_reduction_num_bytes_per_component * 6;
 
-					if (are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Scales) && !bone_stream.is_scale_constant)
+					if (are_any_enum_flags_set(range_reduction, range_reduction_flags8::scales) && !bone_stream.is_scale_constant)
 						range_data_size += k_segment_range_reduction_num_bytes_per_component * 6;
 				}
 
diff --git a/includes/acl/compression/impl/quantize_streams.h b/includes/acl/compression/impl/quantize_streams.h
--- a/includes/acl/compression/impl/quantize_streams.h
+++ b/includes/acl/compression/impl/quantize_streams.h
@@ -258,7 +258,7 @@ namespace acl
 			QuantizationContext& operator=(QuantizationContext&&) = delete;
 		};
 
-		inline void quantize_fixed_rotation_stream(IAllocator& allocator, const RotationTrackStream& raw_stream, RotationFormat8 rotation_format, bool are_rotations_normalized, RotationTrackStream& out_quantized_stream)
+		inline void quantize_fixed_rotation_stream(IAllocator& allocator, const RotationTrackStream& raw_stream, rotation_format8 rotation_format, RotationTrackStream& out_quantized_stream)
 		{
 			// We expect all our samples to have the same width of sizeof(rtm::vector4f)
 			ACL_ASSERT(raw_stream.get_sample_size() == sizeof(rtm::vector4f), "Unexpected rotation sample size. %u != %u", raw_stream.get_sample_size(), sizeof(rtm::vector4f));
@@ -275,22 +275,13 @@ namespace acl
 
 				switch (rotation_format)
 				{
-				case RotationFormat8::Quat_128:
+				case rotation_format8::quatf_full:
 					pack_vector4_128(rtm::quat_to_vector(rotation), quantized_ptr);
 					break;
-				case RotationFormat8::QuatDropW_96:
+				case rotation_format8::quatf_drop_w_full:
 					pack_vector3_96(rtm::quat_to_vector(rotation), quantized_ptr);
 					break;
-				case RotationFormat8::QuatDropW_48:
-					if (are_rotations_normalized)
-						pack_vector3_u48_unsafe(rtm::quat_to_vector(rotation), quantized_ptr);
-					else
-						pack_vector3_s48_unsafe(rtm::quat_to_vector(rotation), quantized_ptr);
-					break;
-				case RotationFormat8::QuatDropW_32:
-					pack_vector3_32(rtm::quat_to_vector(rotation), 11, 11, 10, are_rotations_normalized, quantized_ptr);
-					break;
-				case RotationFormat8::QuatDropW_Variable:
+				case rotation_format8::quatf_drop_w_variable:
 				default:
 					ACL_ASSERT(false, "Invalid or unsupported rotation format: %s", get_rotation_format_name(rotation_format));
 					break;
@@ -300,7 +291,7 @@ namespace acl
 			out_quantized_stream = std::move(quantized_stream);
 		}
 
-		inline void quantize_fixed_rotation_stream(QuantizationContext& context, uint16_t bone_index, RotationFormat8 rotation_format)
+		inline void quantize_fixed_rotation_stream(QuantizationContext& context, uint16_t bone_index, rotation_format8 rotation_format)
 		{
 			ACL_ASSERT(bone_index < context.num_bones, "Invalid bone index: %u", bone_index);
 
@@ -310,11 +301,10 @@ namespace acl
 			if (bone_stream.is_rotation_default)
 				return;
 
-			const bool are_rotations_normalized = context.clip.are_rotations_normalized && !bone_stream.is_rotation_constant;
-			quantize_fixed_rotation_stream(context.allocator, bone_stream.rotations, rotation_format, are_rotations_normalized, bone_stream.rotations);
+			quantize_fixed_rotation_stream(context.allocator, bone_stream.rotations, rotation_format, bone_stream.rotations);
 		}
 
-		inline void quantize_variable_rotation_stream(QuantizationContext& context, const RotationTrackStream& raw_clip_stream, const RotationTrackStream& raw_segment_stream, const TrackStreamRange& clip_range, uint8_t bit_rate, bool are_rotations_normalized, RotationTrackStream& out_quantized_stream)
+		inline void quantize_variable_rotation_stream(QuantizationContext& context, const RotationTrackStream& raw_clip_stream, const RotationTrackStream& raw_segment_stream, const TrackStreamRange& clip_range, uint8_t bit_rate, RotationTrackStream& out_quantized_stream)
 		{
 			// We expect all our samples to have the same width of sizeof(rtm::vector4f)
 			ACL_ASSERT(raw_segment_stream.get_sample_size() == sizeof(rtm::vector4f), "Unexpected rotation sample size. %u != %u", raw_segment_stream.get_sample_size(), sizeof(rtm::vector4f));
@@ -322,14 +312,12 @@ namespace acl
 			const uint32_t num_samples = is_constant_bit_rate(bit_rate) ? 1 : raw_segment_stream.get_num_samples();
 			const uint32_t sample_size = sizeof(uint64_t) * 2;
 			const float sample_rate = raw_segment_stream.get_sample_rate();
-			RotationTrackStream quantized_stream(context.allocator, num_samples, sample_size, sample_rate, RotationFormat8::QuatDropW_Variable, bit_rate);
+			RotationTrackStream quantized_stream(context.allocator, num_samples, sample_size, sample_rate, rotation_format8::quatf_drop_w_variable, bit_rate);
 
 			if (is_constant_bit_rate(bit_rate))
 			{
-				ACL_ASSERT(are_rotations_normalized, "Cannot drop a constant track if it isn't normalized");
-
 				rtm::vector4f rotation = raw_clip_stream.get_raw_sample<rtm::vector4f>(context.segment_sample_start_index);
-				rotation = convert_rotation(rotation, RotationFormat8::Quat_128, RotationFormat8::QuatDropW_Variable);
+				rotation = convert_rotation(rotation, rotation_format8::quatf_full, rotation_format8::quatf_drop_w_variable);
 
 				const rtm::vector4f normalized_rotation = normalize_sample(rotation, clip_range);
 
@@ -347,16 +335,13 @@ namespace acl
 					if (is_raw_bit_rate(bit_rate))
 					{
 						rtm::vector4f rotation = raw_clip_stream.get_raw_sample<rtm::vector4f>(context.segment_sample_start_index + sample_index);
-						rotation = convert_rotation(rotation, RotationFormat8::Quat_128, RotationFormat8::QuatDropW_Variable);
+						rotation = convert_rotation(rotation, rotation_format8::quatf_full, rotation_format8::quatf_drop_w_variable);
 						pack_vector3_96(rotation, quantized_ptr);
 					}
 					else
 					{
 						const rtm::quatf rotation = raw_segment_stream.get_raw_sample<rtm::quatf>(sample_index);
-						if (are_rotations_normalized)
-							pack_vector3_uXX_unsafe(rtm::quat_to_vector(rotation), num_bits_at_bit_rate, quantized_ptr);
-						else
-							pack_vector3_sXX_unsafe(rtm::quat_to_vector(rotation), num_bits_at_bit_rate, quantized_ptr);
+						pack_vector3_uXX_unsafe(rtm::quat_to_vector(rotation), num_bits_at_bit_rate, quantized_ptr);
 					}
 				}
 			}
@@ -375,23 +360,21 @@ namespace acl
 				return;
 
 			const BoneStreams& raw_bone_stream = context.raw_bone_streams[bone_index];
-			const RotationFormat8 highest_bit_rate = get_highest_variant_precision(RotationVariant8::QuatDropW);
-			const TrackStreamRange invalid_range;
-			const TrackStreamRange& bone_range = context.clip.are_rotations_normalized ? context.clip.ranges[bone_index].rotation : invalid_range;
-			const bool are_rotations_normalized = context.clip.are_rotations_normalized && !bone_stream.is_rotation_constant;
+			const rotation_format8 highest_bit_rate = get_highest_variant_precision(rotation_variant8::quat_drop_w);
+			const TrackStreamRange& bone_range = context.clip.ranges[bone_index].rotation;
 
 			// If our format is variable, we keep them fixed at the highest bit rate in the variant
 			if (bone_stream.is_rotation_constant)
-				quantize_fixed_rotation_stream(context.allocator, bone_stream.rotations, highest_bit_rate, are_rotations_normalized, bone_stream.rotations);
+				quantize_fixed_rotation_stream(context.allocator, bone_stream.rotations, highest_bit_rate, bone_stream.rotations);
 			else
-				quantize_variable_rotation_stream(context, raw_bone_stream.rotations, bone_stream.rotations, bone_range, bit_rate, are_rotations_normalized, bone_stream.rotations);
+				quantize_variable_rotation_stream(context, raw_bone_stream.rotations, bone_stream.rotations, bone_range, bit_rate, bone_stream.rotations);
 		}
 
-		inline void quantize_fixed_translation_stream(IAllocator& allocator, const TranslationTrackStream& raw_stream, VectorFormat8 translation_format, TranslationTrackStream& out_quantized_stream)
+		inline void quantize_fixed_translation_stream(IAllocator& allocator, const TranslationTrackStream& raw_stream, vector_format8 translation_format, TranslationTrackStream& out_quantized_stream)
 		{
 			// We expect all our samples to have the same width of sizeof(rtm::vector4f)
 			ACL_ASSERT(raw_stream.get_sample_size() == sizeof(rtm::vector4f), "Unexpected translation sample size. %u != %u", raw_stream.get_sample_size(), sizeof(rtm::vector4f));
-			ACL_ASSERT(raw_stream.get_vector_format() == VectorFormat8::Vector3_96, "Expected a Vector3_96 vector format, found: %s", get_vector_format_name(raw_stream.get_vector_format()));
+			ACL_ASSERT(raw_stream.get_vector_format() == vector_format8::vector3f_full, "Expected a vector3f_full vector format, found: %s", get_vector_format_name(raw_stream.get_vector_format()));
 
 			const uint32_t num_samples = raw_stream.get_num_samples();
 			const uint32_t sample_size = get_packed_vector_size(translation_format);
@@ -405,16 +388,10 @@ namespace acl
 
 				switch (translation_format)
 				{
-				case VectorFormat8::Vector3_96:
+				case vector_format8::vector3f_full:
 					pack_vector3_96(translation, quantized_ptr);
 					break;
-				case VectorFormat8::Vector3_48:
-					pack_vector3_u48_unsafe(translation, quantized_ptr);
-					break;
-				case VectorFormat8::Vector3_32:
-					pack_vector3_32(translation, 11, 11, 10, true, quantized_ptr);
-					break;
-				case VectorFormat8::Vector3_Variable:
+				case vector_format8::vector3f_variable:
 				default:
 					ACL_ASSERT(false, "Invalid or unsupported vector format: %s", get_vector_format_name(translation_format));
 					break;
@@ -424,7 +401,7 @@ namespace acl
 			out_quantized_stream = std::move(quantized_stream);
 		}
 
-		inline void quantize_fixed_translation_stream(QuantizationContext& context, uint16_t bone_index, VectorFormat8 translation_format)
+		inline void quantize_fixed_translation_stream(QuantizationContext& context, uint16_t bone_index, vector_format8 translation_format)
 		{
 			ACL_ASSERT(bone_index < context.num_bones, "Invalid bone index: %u", bone_index);
 
@@ -435,7 +412,7 @@ namespace acl
 				return;
 
 			// Constant translation tracks store the remaining sample with full precision
-			const VectorFormat8 format = bone_stream.is_translation_constant ? VectorFormat8::Vector3_96 : translation_format;
+			const vector_format8 format = bone_stream.is_translation_constant ? vector_format8::vector3f_full : translation_format;
 
 			quantize_fixed_translation_stream(context.allocator, bone_stream.translations, format, bone_stream.translations);
 		}
@@ -444,12 +421,12 @@ namespace acl
 		{
 			// We expect all our samples to have the same width of sizeof(rtm::vector4f)
 			ACL_ASSERT(raw_segment_stream.get_sample_size() == sizeof(rtm::vector4f), "Unexpected translation sample size. %u != %u", raw_segment_stream.get_sample_size(), sizeof(rtm::vector4f));
-			ACL_ASSERT(raw_segment_stream.get_vector_format() == VectorFormat8::Vector3_96, "Expected a Vector3_96 vector format, found: %s", get_vector_format_name(raw_segment_stream.get_vector_format()));
+			ACL_ASSERT(raw_segment_stream.get_vector_format() == vector_format8::vector3f_full, "Expected a vector3f_full vector format, found: %s", get_vector_format_name(raw_segment_stream.get_vector_format()));
 
 			const uint32_t num_samples = is_constant_bit_rate(bit_rate) ? 1 : raw_segment_stream.get_num_samples();
 			const uint32_t sample_size = sizeof(uint64_t) * 2;
 			const float sample_rate = raw_segment_stream.get_sample_rate();
-			TranslationTrackStream quantized_stream(context.allocator, num_samples, sample_size, sample_rate, VectorFormat8::Vector3_Variable, bit_rate);
+			TranslationTrackStream quantized_stream(context.allocator, num_samples, sample_size, sample_rate, vector_format8::vector3f_variable, bit_rate);
 
 			if (is_constant_bit_rate(bit_rate))
 			{
@@ -493,22 +470,21 @@ namespace acl
 			if (bone_stream.is_translation_default)
 				return;
 
-			const TrackStreamRange invalid_range;
-			const TrackStreamRange& bone_range = context.clip.are_translations_normalized ? context.clip.ranges[bone_index].translation : invalid_range;
+			const TrackStreamRange& bone_range = context.clip.ranges[bone_index].translation;
 			const BoneStreams& raw_bone_stream = context.raw_bone_streams[bone_index];
 
 			// Constant translation tracks store the remaining sample with full precision
 			if (bone_stream.is_translation_constant)
-				quantize_fixed_translation_stream(context.allocator, bone_stream.translations, VectorFormat8::Vector3_96, bone_stream.translations);
+				quantize_fixed_translation_stream(context.allocator, bone_stream.translations, vector_format8::vector3f_full, bone_stream.translations);
 			else
 				quantize_variable_translation_stream(context, raw_bone_stream.translations, bone_stream.translations, bone_range, bit_rate, bone_stream.translations);
 		}
 
-		inline void quantize_fixed_scale_stream(IAllocator& allocator, const ScaleTrackStream& raw_stream, VectorFormat8 scale_format, ScaleTrackStream& out_quantized_stream)
+		inline void quantize_fixed_scale_stream(IAllocator& allocator, const ScaleTrackStream& raw_stream, vector_format8 scale_format, ScaleTrackStream& out_quantized_stream)
 		{
 			// We expect all our samples to have the same width of sizeof(rtm::vector4f)
 			ACL_ASSERT(raw_stream.get_sample_size() == sizeof(rtm::vector4f), "Unexpected scale sample size. %u != %u", raw_stream.get_sample_size(), sizeof(rtm::vector4f));
-			ACL_ASSERT(raw_stream.get_vector_format() == VectorFormat8::Vector3_96, "Expected a Vector3_96 vector format, found: %s", get_vector_format_name(raw_stream.get_vector_format()));
+			ACL_ASSERT(raw_stream.get_vector_format() == vector_format8::vector3f_full, "Expected a vector3f_full vector format, found: %s", get_vector_format_name(raw_stream.get_vector_format()));
 
 			const uint32_t num_samples = raw_stream.get_num_samples();
 			const uint32_t sample_size = get_packed_vector_size(scale_format);
@@ -522,16 +498,10 @@ namespace acl
 
 				switch (scale_format)
 				{
-				case VectorFormat8::Vector3_96:
+				case vector_format8::vector3f_full:
 					pack_vector3_96(scale, quantized_ptr);
 					break;
-				case VectorFormat8::Vector3_48:
-					pack_vector3_u48_unsafe(scale, quantized_ptr);
-					break;
-				case VectorFormat8::Vector3_32:
-					pack_vector3_32(scale, 11, 11, 10, true, quantized_ptr);
-					break;
-				case VectorFormat8::Vector3_Variable:
+				case vector_format8::vector3f_variable:
 				default:
 					ACL_ASSERT(false, "Invalid or unsupported vector format: %s", get_vector_format_name(scale_format));
 					break;
@@ -541,7 +511,7 @@ namespace acl
 			out_quantized_stream = std::move(quantized_stream);
 		}
 
-		inline void quantize_fixed_scale_stream(QuantizationContext& context, uint16_t bone_index, VectorFormat8 scale_format)
+		inline void quantize_fixed_scale_stream(QuantizationContext& context, uint16_t bone_index, vector_format8 scale_format)
 		{
 			ACL_ASSERT(bone_index < context.num_bones, "Invalid bone index: %u", bone_index);
 
@@ -552,7 +522,7 @@ namespace acl
 				return;
 
 			// Constant scale tracks store the remaining sample with full precision
-			const VectorFormat8 format = bone_stream.is_scale_constant ? VectorFormat8::Vector3_96 : scale_format;
+			const vector_format8 format = bone_stream.is_scale_constant ? vector_format8::vector3f_full : scale_format;
 
 			quantize_fixed_scale_stream(context.allocator, bone_stream.scales, format, bone_stream.scales);
 		}
@@ -561,12 +531,12 @@ namespace acl
 		{
 			// We expect all our samples to have the same width of sizeof(rtm::vector4f)
 			ACL_ASSERT(raw_segment_stream.get_sample_size() == sizeof(rtm::vector4f), "Unexpected scale sample size. %u != %u", raw_segment_stream.get_sample_size(), sizeof(rtm::vector4f));
-			ACL_ASSERT(raw_segment_stream.get_vector_format() == VectorFormat8::Vector3_96, "Expected a Vector3_96 vector format, found: %s", get_vector_format_name(raw_segment_stream.get_vector_format()));
+			ACL_ASSERT(raw_segment_stream.get_vector_format() == vector_format8::vector3f_full, "Expected a vector3f_full vector format, found: %s", get_vector_format_name(raw_segment_stream.get_vector_format()));
 
 			const uint32_t num_samples = is_constant_bit_rate(bit_rate) ? 1 : raw_segment_stream.get_num_samples();
 			const uint32_t sample_size = sizeof(uint64_t) * 2;
 			const float sample_rate = raw_segment_stream.get_sample_rate();
-			ScaleTrackStream quantized_stream(context.allocator, num_samples, sample_size, sample_rate, VectorFormat8::Vector3_Variable, bit_rate);
+			ScaleTrackStream quantized_stream(context.allocator, num_samples, sample_size, sample_rate, vector_format8::vector3f_variable, bit_rate);
 
 			if (is_constant_bit_rate(bit_rate))
 			{
@@ -610,13 +580,12 @@ namespace acl
 			if (bone_stream.is_scale_default)
 				return;
 
-			const TrackStreamRange invalid_range;
-			const TrackStreamRange& bone_range = context.clip.are_scales_normalized ? context.clip.ranges[bone_index].scale : invalid_range;
+			const TrackStreamRange& bone_range = context.clip.ranges[bone_index].scale;
 			const BoneStreams& raw_bone_stream = context.raw_bone_streams[bone_index];
 
 			// Constant scale tracks store the remaining sample with full precision
 			if (bone_stream.is_scale_constant)
-				quantize_fixed_scale_stream(context.allocator, bone_stream.scales, VectorFormat8::Vector3_96, bone_stream.scales);
+				quantize_fixed_scale_stream(context.allocator, bone_stream.scales, vector_format8::vector3f_full, bone_stream.scales);
 			else
 				quantize_variable_scale_stream(context, raw_bone_stream.scales, bone_stream.scales, bone_range, bit_rate, bone_stream.scales);
 		}
@@ -1070,7 +1039,7 @@ namespace acl
 			return num_bones_in_chain;
 		}
 
-		inline void initialize_bone_bit_rates(const SegmentContext& segment, RotationFormat8 rotation_format, VectorFormat8 translation_format, VectorFormat8 scale_format, BoneBitRate* out_bit_rate_per_bone)
+		inline void initialize_bone_bit_rates(const SegmentContext& segment, rotation_format8 rotation_format, vector_format8 translation_format, vector_format8 scale_format, BoneBitRate* out_bit_rate_per_bone)
 		{
 			const bool is_rotation_variable = is_rotation_format_variable(rotation_format);
 			const bool is_translation_variable = is_vector_format_variable(translation_format);
@@ -1227,7 +1196,7 @@ namespace acl
 							break;
 					}
 
-					if (settings.level >= CompressionLevel8::High)
+					if (settings.level >= compression_level8::high)
 					{
 						// The second permutation increases the bit rate of 2 track/bones
 						std::fill(bone_chain_permutation, bone_chain_permutation + context.num_bones, uint8_t(0));
@@ -1259,7 +1228,7 @@ namespace acl
 						}
 					}
 
-					if (settings.level >= CompressionLevel8::Highest)
+					if (settings.level >= compression_level8::highest)
 					{
 						// The third permutation increases the bit rate of 3 track/bones
 						std::fill(bone_chain_permutation, bone_chain_permutation + context.num_bones, uint8_t(0));
@@ -1441,7 +1410,7 @@ namespace acl
 				// not, sibling bones will remain fairly close in their error. Some packed rotation formats, namely
 				// drop W component can have a high error even with raw values, it is assumed that if such a format
 				// is used then a best effort approach to reach the error threshold is entirely fine.
-				if (error >= settings.error_threshold && context.settings.rotation_format == RotationFormat8::Quat_128)
+				if (error >= settings.error_threshold && context.settings.rotation_format == rotation_format8::quatf_full)
 				{
 					// From child to parent, max out the bit rate
 					for (int16_t chain_link_index = num_bones_in_chain - 1; chain_link_index >= 0; --chain_link_index)
diff --git a/includes/acl/compression/impl/sample_streams.h b/includes/acl/compression/impl/sample_streams.h
--- a/includes/acl/compression/impl/sample_streams.h
+++ b/includes/acl/compression/impl/sample_streams.h
@@ -46,23 +46,18 @@ namespace acl
 {
 	namespace acl_impl
 	{
-		inline rtm::vector4f RTM_SIMD_CALL load_rotation_sample(const uint8_t* ptr, RotationFormat8 format, uint8_t bit_rate, bool is_normalized)
+		inline rtm::vector4f RTM_SIMD_CALL load_rotation_sample(const uint8_t* ptr, rotation_format8 format, uint8_t bit_rate)
 		{
 			switch (format)
 			{
-			case RotationFormat8::Quat_128:
+			case rotation_format8::quatf_full:
 				return unpack_vector4_128(ptr);
-			case RotationFormat8::QuatDropW_96:
+			case rotation_format8::quatf_drop_w_full:
 				return unpack_vector3_96_unsafe(ptr);
-			case RotationFormat8::QuatDropW_48:
-				return is_normalized ? unpack_vector3_u48_unsafe(ptr) : unpack_vector3_s48_unsafe(ptr);
-			case RotationFormat8::QuatDropW_32:
-				return unpack_vector3_32(11, 11, 10, is_normalized, ptr);
-			case RotationFormat8::QuatDropW_Variable:
-			{
+			case rotation_format8::quatf_drop_w_variable:
+				ACL_ASSERT(bit_rate != k_invalid_bit_rate, "Invalid bit rate!");
 				if (is_constant_bit_rate(bit_rate))
 				{
-					ACL_ASSERT(is_normalized, "Cannot drop a constant track if it isn't normalized");
 					return unpack_vector3_u48_unsafe(ptr);
 				}
 				else if (is_raw_bit_rate(bit_rate))
@@ -70,29 +65,21 @@ namespace acl
 				else
 				{
 					const uint32_t num_bits_at_bit_rate = get_num_bits_at_bit_rate(bit_rate);
-					if (is_normalized)
-						return unpack_vector3_uXX_unsafe(num_bits_at_bit_rate, ptr, 0);
-					else
-						return unpack_vector3_sXX_unsafe(num_bits_at_bit_rate, ptr, 0);
+					return unpack_vector3_uXX_unsafe(num_bits_at_bit_rate, ptr, 0);
 				}
-			}
 			default:
 				ACL_ASSERT(false, "Invalid or unsupported rotation format: %s", get_rotation_format_name(format));
 				return rtm::vector_zero();
 			}
 		}
 
-		inline rtm::vector4f RTM_SIMD_CALL load_vector_sample(const uint8_t* ptr, VectorFormat8 format, uint8_t bit_rate)
+		inline rtm::vector4f RTM_SIMD_CALL load_vector_sample(const uint8_t* ptr, vector_format8 format, uint8_t bit_rate)
 		{
 			switch (format)
 			{
-			case VectorFormat8::Vector3_96:
+			case vector_format8::vector3f_full:
 				return unpack_vector3_96_unsafe(ptr);
-			case VectorFormat8::Vector3_48:
-				return unpack_vector3_u48_unsafe(ptr);
-			case VectorFormat8::Vector3_32:
-				return unpack_vector3_32(11, 11, 10, true, ptr);
-			case VectorFormat8::Vector3_Variable:
+			case vector_format8::vector3f_variable:
 				ACL_ASSERT(bit_rate != k_invalid_bit_rate, "Invalid bit rate!");
 				if (is_constant_bit_rate(bit_rate))
 					return unpack_vector3_u48_unsafe(ptr);
@@ -109,16 +96,14 @@ namespace acl
 			}
 		}
 
-		inline rtm::quatf RTM_SIMD_CALL rotation_to_quat_32(rtm::vector4f_arg0 rotation, RotationFormat8 format)
+		inline rtm::quatf RTM_SIMD_CALL rotation_to_quat_32(rtm::vector4f_arg0 rotation, rotation_format8 format)
 		{
 			switch (format)
 			{
-			case RotationFormat8::Quat_128:
+			case rotation_format8::quatf_full:
 				return rtm::vector_to_quat(rotation);
-			case RotationFormat8::QuatDropW_96:
-			case RotationFormat8::QuatDropW_48:
-			case RotationFormat8::QuatDropW_32:
-			case RotationFormat8::QuatDropW_Variable:
+			case rotation_format8::quatf_drop_w_full:
+			case rotation_format8::quatf_drop_w_variable:
 				return rtm::quat_from_positive_w(rotation);
 			default:
 				ACL_ASSERT(false, "Invalid or unsupported rotation format: %s", get_rotation_format_name(format));
@@ -130,19 +115,18 @@ namespace acl
 		{
 			const SegmentContext* segment = bone_steams.segment;
 			const ClipContext* clip_context = segment->clip;
-			const bool are_rotations_normalized = clip_context->are_rotations_normalized;
 
-			const RotationFormat8 format = bone_steams.rotations.get_rotation_format();
+			const rotation_format8 format = bone_steams.rotations.get_rotation_format();
 			const uint8_t bit_rate = bone_steams.rotations.get_bit_rate();
 
-			if (format == RotationFormat8::QuatDropW_Variable && is_constant_bit_rate(bit_rate))
+			if (format == rotation_format8::quatf_drop_w_variable && is_constant_bit_rate(bit_rate))
 				sample_index = 0;
 
 			const uint8_t* quantized_ptr = bone_steams.rotations.get_raw_sample_ptr(sample_index);
 
-			rtm::vector4f packed_rotation = acl_impl::load_rotation_sample(quantized_ptr, format, bit_rate, are_rotations_normalized);
+			rtm::vector4f packed_rotation = acl_impl::load_rotation_sample(quantized_ptr, format, bit_rate);
 
-			if (are_rotations_normalized && !is_raw_bit_rate(bit_rate))
+			if (clip_context->are_rotations_normalized && !is_raw_bit_rate(bit_rate))
 			{
 				if (segment->are_rotations_normalized && !is_constant_bit_rate(bit_rate))
 				{
@@ -169,26 +153,25 @@ namespace acl
 		{
 			const SegmentContext* segment = bone_steams.segment;
 			const ClipContext* clip_context = segment->clip;
-			const bool are_rotations_normalized = clip_context->are_rotations_normalized;
-			const RotationFormat8 format = bone_steams.rotations.get_rotation_format();
+			const rotation_format8 format = bone_steams.rotations.get_rotation_format();
 
 			rtm::vector4f rotation;
 			if (is_constant_bit_rate(bit_rate))
 			{
 				const uint8_t* quantized_ptr = raw_bone_steams.rotations.get_raw_sample_ptr(segment->clip_sample_offset);
-				rotation = acl_impl::load_rotation_sample(quantized_ptr, RotationFormat8::Quat_128, k_invalid_bit_rate, are_rotations_normalized);
-				rotation = convert_rotation(rotation, RotationFormat8::Quat_128, format);
+				rotation = acl_impl::load_rotation_sample(quantized_ptr, rotation_format8::quatf_full, k_invalid_bit_rate);
+				rotation = convert_rotation(rotation, rotation_format8::quatf_full, format);
 			}
 			else if (is_raw_bit_rate(bit_rate))
 			{
 				const uint8_t* quantized_ptr = raw_bone_steams.rotations.get_raw_sample_ptr(segment->clip_sample_offset + sample_index);
-				rotation = acl_impl::load_rotation_sample(quantized_ptr, RotationFormat8::Quat_128, k_invalid_bit_rate, are_rotations_normalized);
-				rotation = convert_rotation(rotation, RotationFormat8::Quat_128, format);
+				rotation = acl_impl::load_rotation_sample(quantized_ptr, rotation_format8::quatf_full, k_invalid_bit_rate);
+				rotation = convert_rotation(rotation, rotation_format8::quatf_full, format);
 			}
 			else
 			{
 				const uint8_t* quantized_ptr = bone_steams.rotations.get_raw_sample_ptr(sample_index);
-				rotation = acl_impl::load_rotation_sample(quantized_ptr, format, 0, are_rotations_normalized);
+				rotation = acl_impl::load_rotation_sample(quantized_ptr, format, 0);
 			}
 
 			// Pack and unpack at our desired bit rate
@@ -197,9 +180,6 @@ namespace acl
 
 			if (is_constant_bit_rate(bit_rate))
 			{
-				ACL_ASSERT(are_rotations_normalized, "Cannot drop a constant track if it isn't normalized");
-				ACL_ASSERT(segment->are_rotations_normalized, "Cannot drop a constant track if it isn't normalized");
-
 				const BoneRanges& clip_bone_range = segment->clip->ranges[bone_steams.bone_index];
 				const rtm::vector4f normalized_rotation = normalize_sample(rotation, clip_bone_range.rotation);
 
@@ -207,12 +187,10 @@ namespace acl
 			}
 			else if (is_raw_bit_rate(bit_rate))
 				packed_rotation = rotation;
-			else if (are_rotations_normalized)
-				packed_rotation = decay_vector3_uXX(rotation, num_bits_at_bit_rate);
 			else
-				packed_rotation = decay_vector3_sXX(rotation, num_bits_at_bit_rate);
+				packed_rotation = decay_vector3_uXX(rotation, num_bits_at_bit_rate);
 
-			if (are_rotations_normalized && !is_raw_bit_rate(bit_rate))
+			if (!is_raw_bit_rate(bit_rate))
 			{
 				if (segment->are_rotations_normalized && !is_constant_bit_rate(bit_rate))
 				{
@@ -235,37 +213,32 @@ namespace acl
 			return acl_impl::rotation_to_quat_32(packed_rotation, format);
 		}
 
-		inline rtm::quatf RTM_SIMD_CALL get_rotation_sample(const BoneStreams& bone_steams, uint32_t sample_index, RotationFormat8 desired_format)
+		inline rtm::quatf RTM_SIMD_CALL get_rotation_sample(const BoneStreams& bone_steams, uint32_t sample_index, rotation_format8 desired_format)
 		{
 			const SegmentContext* segment = bone_steams.segment;
 			const ClipContext* clip_context = segment->clip;
-			const bool are_rotations_normalized = clip_context->are_rotations_normalized && !bone_steams.is_rotation_constant;
+
 			const uint8_t* quantized_ptr = bone_steams.rotations.get_raw_sample_ptr(sample_index);
-			const RotationFormat8 format = bone_steams.rotations.get_rotation_format();
+			const rotation_format8 format = bone_steams.rotations.get_rotation_format();
 
-			const rtm::vector4f rotation = acl_impl::load_rotation_sample(quantized_ptr, format, 0, are_rotations_normalized);
+			const rtm::vector4f rotation = acl_impl::load_rotation_sample(quantized_ptr, format, 0);
 
 			// Pack and unpack in our desired format
 			rtm::vector4f packed_rotation;
 
 			switch (desired_format)
 			{
-			case RotationFormat8::Quat_128:
-			case RotationFormat8::QuatDropW_96:
+			case rotation_format8::quatf_full:
+			case rotation_format8::quatf_drop_w_full:
 				packed_rotation = rotation;
 				break;
-			case RotationFormat8::QuatDropW_48:
-				packed_rotation = are_rotations_normalized ? decay_vector3_u48(rotation) : decay_vector3_s48(rotation);
-				break;
-			case RotationFormat8::QuatDropW_32:
-				packed_rotation = are_rotations_normalized ? decay_vector3_u32(rotation, 11, 11, 10) : decay_vector3_s32(rotation, 11, 11, 10);
-				break;
 			default:
 				ACL_ASSERT(false, "Invalid or unsupported rotation format: %s", get_rotation_format_name(desired_format));
 				packed_rotation = rtm::vector_zero();
 				break;
 			}
 
+			const bool are_rotations_normalized = clip_context->are_rotations_normalized && !bone_steams.is_rotation_constant;
 			if (are_rotations_normalized)
 			{
 				if (segment->are_rotations_normalized)
@@ -295,10 +268,10 @@ namespace acl
 			const ClipContext* clip_context = segment->clip;
 			const bool are_translations_normalized = clip_context->are_translations_normalized;
 
-			const VectorFormat8 format = bone_steams.translations.get_vector_format();
+			const vector_format8 format = bone_steams.translations.get_vector_format();
 			const uint8_t bit_rate = bone_steams.translations.get_bit_rate();
 
-			if (format == VectorFormat8::Vector3_Variable && is_constant_bit_rate(bit_rate))
+			if (format == vector_format8::vector3f_variable && is_constant_bit_rate(bit_rate))
 				sample_index = 0;
 
 			const uint8_t* quantized_ptr = bone_steams.translations.get_raw_sample_ptr(sample_index);
@@ -332,7 +305,7 @@ namespace acl
 		{
 			const SegmentContext* segment = bone_steams.segment;
 			const ClipContext* clip_context = segment->clip;
-			const VectorFormat8 format = bone_steams.translations.get_vector_format();
+			const vector_format8 format = bone_steams.translations.get_vector_format();
 
 			const uint8_t* quantized_ptr;
 			if (is_constant_bit_rate(bit_rate))
@@ -389,13 +362,13 @@ namespace acl
 			return packed_translation;
 		}
 
-		inline rtm::vector4f RTM_SIMD_CALL get_translation_sample(const BoneStreams& bone_steams, uint32_t sample_index, VectorFormat8 desired_format)
+		inline rtm::vector4f RTM_SIMD_CALL get_translation_sample(const BoneStreams& bone_steams, uint32_t sample_index, vector_format8 desired_format)
 		{
 			const SegmentContext* segment = bone_steams.segment;
 			const ClipContext* clip_context = segment->clip;
 			const bool are_translations_normalized = clip_context->are_translations_normalized && !bone_steams.is_translation_constant;
 			const uint8_t* quantized_ptr = bone_steams.translations.get_raw_sample_ptr(sample_index);
-			const VectorFormat8 format = bone_steams.translations.get_vector_format();
+			const vector_format8 format = bone_steams.translations.get_vector_format();
 
 			const rtm::vector4f translation = acl_impl::load_vector_sample(quantized_ptr, format, 0);
 
@@ -404,17 +377,9 @@ namespace acl
 
 			switch (desired_format)
 			{
-			case VectorFormat8::Vector3_96:
+			case vector_format8::vector3f_full:
 				packed_translation = translation;
 				break;
-			case VectorFormat8::Vector3_48:
-				ACL_ASSERT(are_translations_normalized, "Translations must be normalized to support this format");
-				packed_translation = decay_vector3_u48(translation);
-				break;
-			case VectorFormat8::Vector3_32:
-				ACL_ASSERT(are_translations_normalized, "Translations must be normalized to support this format");
-				packed_translation = decay_vector3_u32(translation, 11, 11, 10);
-				break;
 			default:
 				ACL_ASSERT(false, "Invalid or unsupported vector format: %s", get_vector_format_name(desired_format));
 				packed_translation = rtm::vector_zero();
@@ -450,10 +415,10 @@ namespace acl
 			const ClipContext* clip_context = segment->clip;
 			const bool are_scales_normalized = clip_context->are_scales_normalized;
 
-			const VectorFormat8 format = bone_steams.scales.get_vector_format();
+			const vector_format8 format = bone_steams.scales.get_vector_format();
 			const uint8_t bit_rate = bone_steams.scales.get_bit_rate();
 
-			if (format == VectorFormat8::Vector3_Variable && is_constant_bit_rate(bit_rate))
+			if (format == vector_format8::vector3f_variable && is_constant_bit_rate(bit_rate))
 				sample_index = 0;
 
 			const uint8_t* quantized_ptr = bone_steams.scales.get_raw_sample_ptr(sample_index);
@@ -487,7 +452,7 @@ namespace acl
 		{
 			const SegmentContext* segment = bone_steams.segment;
 			const ClipContext* clip_context = segment->clip;
-			const VectorFormat8 format = bone_steams.scales.get_vector_format();
+			const vector_format8 format = bone_steams.scales.get_vector_format();
 
 			const uint8_t* quantized_ptr;
 			if (is_constant_bit_rate(bit_rate))
@@ -544,13 +509,13 @@ namespace acl
 			return packed_scale;
 		}
 
-		inline rtm::vector4f RTM_SIMD_CALL get_scale_sample(const BoneStreams& bone_steams, uint32_t sample_index, VectorFormat8 desired_format)
+		inline rtm::vector4f RTM_SIMD_CALL get_scale_sample(const BoneStreams& bone_steams, uint32_t sample_index, vector_format8 desired_format)
 		{
 			const SegmentContext* segment = bone_steams.segment;
 			const ClipContext* clip_context = segment->clip;
 			const bool are_scales_normalized = clip_context->are_scales_normalized && !bone_steams.is_scale_constant;
 			const uint8_t* quantized_ptr = bone_steams.scales.get_raw_sample_ptr(sample_index);
-			const VectorFormat8 format = bone_steams.scales.get_vector_format();
+			const vector_format8 format = bone_steams.scales.get_vector_format();
 
 			const rtm::vector4f scale = acl_impl::load_vector_sample(quantized_ptr, format, 0);
 
@@ -559,17 +524,9 @@ namespace acl
 
 			switch (desired_format)
 			{
-			case VectorFormat8::Vector3_96:
+			case vector_format8::vector3f_full:
 				packed_scale = scale;
 				break;
-			case VectorFormat8::Vector3_48:
-				ACL_ASSERT(are_scales_normalized, "Scales must be normalized to support this format");
-				packed_scale = decay_vector3_u48(scale);
-				break;
-			case VectorFormat8::Vector3_32:
-				ACL_ASSERT(are_scales_normalized, "Scales must be normalized to support this format");
-				packed_scale = decay_vector3_u32(scale, 11, 11, 10);
-				break;
 			default:
 				ACL_ASSERT(false, "Invalid or unsupported vector format: %s", get_vector_format_name(desired_format));
 				packed_scale = scale;
@@ -617,7 +574,7 @@ namespace acl
 
 			// Our samples are uniform, grab the nearest samples
 			const ClipContext* clip_context = segment.clip;
-			find_linear_interpolation_samples_with_sample_rate(clip_context->num_samples, clip_context->sample_rate, sample_time, SampleRoundingPolicy::Nearest, key0, key1, interpolation_alpha);
+			find_linear_interpolation_samples_with_sample_rate(clip_context->num_samples, clip_context->sample_rate, sample_time, sample_rounding_policy::nearest, key0, key1, interpolation_alpha);
 
 			// Offset for the current segment and clamp
 			key0 = key0 - segment.clip_sample_offset;
@@ -657,7 +614,7 @@ namespace acl
 					const uint32_t num_samples = bone_stream.rotations.get_num_samples();
 					const float sample_rate = bone_stream.rotations.get_sample_rate();
 
-					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, SampleRoundingPolicy::None, key0, key1, interpolation_alpha);
+					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, sample_rounding_policy::none, key0, key1, interpolation_alpha);
 				}
 				else
 				{
@@ -681,7 +638,7 @@ namespace acl
 		}
 
 		template<SampleDistribution8 distribution>
-		ACL_FORCE_INLINE rtm::quatf RTM_SIMD_CALL sample_rotation(const sample_context& context, const BoneStreams& bone_stream, const BoneStreams& raw_bone_stream, bool is_rotation_variable, RotationFormat8 rotation_format)
+		ACL_FORCE_INLINE rtm::quatf RTM_SIMD_CALL sample_rotation(const sample_context& context, const BoneStreams& bone_stream, const BoneStreams& raw_bone_stream, bool is_rotation_variable, rotation_format8 rotation_format)
 		{
 			rtm::quatf rotation;
 			if (bone_stream.is_rotation_default)
@@ -705,7 +662,7 @@ namespace acl
 					const uint32_t num_samples = bone_stream.rotations.get_num_samples();
 					const float sample_rate = bone_stream.rotations.get_sample_rate();
 
-					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, SampleRoundingPolicy::None, key0, key1, interpolation_alpha);
+					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, sample_rounding_policy::none, key0, key1, interpolation_alpha);
 				}
 				else
 				{
@@ -758,7 +715,7 @@ namespace acl
 					const uint32_t num_samples = bone_stream.translations.get_num_samples();
 					const float sample_rate = bone_stream.translations.get_sample_rate();
 
-					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, SampleRoundingPolicy::None, key0, key1, interpolation_alpha);
+					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, sample_rounding_policy::none, key0, key1, interpolation_alpha);
 				}
 				else
 				{
@@ -782,13 +739,13 @@ namespace acl
 		}
 
 		template<SampleDistribution8 distribution>
-		ACL_FORCE_INLINE rtm::vector4f RTM_SIMD_CALL sample_translation(const sample_context& context, const BoneStreams& bone_stream, const BoneStreams& raw_bone_stream, bool is_translation_variable, VectorFormat8 translation_format)
+		ACL_FORCE_INLINE rtm::vector4f RTM_SIMD_CALL sample_translation(const sample_context& context, const BoneStreams& bone_stream, const BoneStreams& raw_bone_stream, bool is_translation_variable, vector_format8 translation_format)
 		{
 			rtm::vector4f translation;
 			if (bone_stream.is_translation_default)
 				translation = rtm::vector_zero();
 			else if (bone_stream.is_translation_constant)
-				translation = get_translation_sample(raw_bone_stream, 0, VectorFormat8::Vector3_96);
+				translation = get_translation_sample(raw_bone_stream, 0, vector_format8::vector3f_full);
 			else
 			{
 				uint32_t key0;
@@ -799,7 +756,7 @@ namespace acl
 					const uint32_t num_samples = bone_stream.translations.get_num_samples();
 					const float sample_rate = bone_stream.translations.get_sample_rate();
 
-					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, SampleRoundingPolicy::None, key0, key1, interpolation_alpha);
+					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, sample_rounding_policy::none, key0, key1, interpolation_alpha);
 				}
 				else
 				{
@@ -852,7 +809,7 @@ namespace acl
 					const uint32_t num_samples = bone_stream.scales.get_num_samples();
 					const float sample_rate = bone_stream.scales.get_sample_rate();
 
-					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, SampleRoundingPolicy::None, key0, key1, interpolation_alpha);
+					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, sample_rounding_policy::none, key0, key1, interpolation_alpha);
 				}
 				else
 				{
@@ -876,13 +833,13 @@ namespace acl
 		}
 
 		template<SampleDistribution8 distribution>
-		ACL_FORCE_INLINE rtm::vector4f RTM_SIMD_CALL sample_scale(const sample_context& context, const BoneStreams& bone_stream, const BoneStreams& raw_bone_stream, bool is_scale_variable, VectorFormat8 scale_format, rtm::vector4f_arg0 default_scale)
+		ACL_FORCE_INLINE rtm::vector4f RTM_SIMD_CALL sample_scale(const sample_context& context, const BoneStreams& bone_stream, const BoneStreams& raw_bone_stream, bool is_scale_variable, vector_format8 scale_format, rtm::vector4f_arg0 default_scale)
 		{
 			rtm::vector4f scale;
 			if (bone_stream.is_scale_default)
 				scale = default_scale;
 			else if (bone_stream.is_scale_constant)
-				scale = get_scale_sample(raw_bone_stream, 0, VectorFormat8::Vector3_96);
+				scale = get_scale_sample(raw_bone_stream, 0, vector_format8::vector3f_full);
 			else
 			{
 				uint32_t key0;
@@ -893,7 +850,7 @@ namespace acl
 					const uint32_t num_samples = bone_stream.scales.get_num_samples();
 					const float sample_rate = bone_stream.scales.get_sample_rate();
 
-					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, SampleRoundingPolicy::None, key0, key1, interpolation_alpha);
+					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, sample_rounding_policy::none, key0, key1, interpolation_alpha);
 				}
 				else
 				{
@@ -1073,7 +1030,7 @@ namespace acl
 			}
 		}
 
-		inline void sample_streams(const BoneStreams* bone_streams, const BoneStreams* raw_bone_steams, uint16_t num_bones, float sample_time, const BoneBitRate* bit_rates, RotationFormat8 rotation_format, VectorFormat8 translation_format, VectorFormat8 scale_format, rtm::qvvf* out_local_pose)
+		inline void sample_streams(const BoneStreams* bone_streams, const BoneStreams* raw_bone_steams, uint16_t num_bones, float sample_time, const BoneBitRate* bit_rates, rotation_format8 rotation_format, vector_format8 translation_format, vector_format8 scale_format, rtm::qvvf* out_local_pose)
 		{
 			const bool is_rotation_variable = is_rotation_format_variable(rotation_format);
 			const bool is_translation_variable = is_vector_format_variable(translation_format);
@@ -1130,7 +1087,7 @@ namespace acl
 			}
 		}
 
-		inline void sample_stream(const BoneStreams* bone_streams, const BoneStreams* raw_bone_steams, uint16_t num_bones, float sample_time, uint16_t bone_index, const BoneBitRate* bit_rates, RotationFormat8 rotation_format, VectorFormat8 translation_format, VectorFormat8 scale_format, rtm::qvvf* out_local_pose)
+		inline void sample_stream(const BoneStreams* bone_streams, const BoneStreams* raw_bone_steams, uint16_t num_bones, float sample_time, uint16_t bone_index, const BoneBitRate* bit_rates, rotation_format8 rotation_format, vector_format8 translation_format, vector_format8 scale_format, rtm::qvvf* out_local_pose)
 		{
 			(void)num_bones;
 
@@ -1177,7 +1134,7 @@ namespace acl
 			out_local_pose[bone_index] = rtm::qvv_set(rotation, translation, scale);
 		}
 
-		inline void sample_streams_hierarchical(const BoneStreams* bone_streams, const BoneStreams* raw_bone_steams, uint16_t num_bones, float sample_time, uint16_t bone_index, const BoneBitRate* bit_rates, RotationFormat8 rotation_format, VectorFormat8 translation_format, VectorFormat8 scale_format, rtm::qvvf* out_local_pose)
+		inline void sample_streams_hierarchical(const BoneStreams* bone_streams, const BoneStreams* raw_bone_steams, uint16_t num_bones, float sample_time, uint16_t bone_index, const BoneBitRate* bit_rates, rotation_format8 rotation_format, vector_format8 translation_format, vector_format8 scale_format, rtm::qvvf* out_local_pose)
 		{
 			(void)num_bones;
 
diff --git a/includes/acl/compression/impl/segment_streams.h b/includes/acl/compression/impl/segment_streams.h
--- a/includes/acl/compression/impl/segment_streams.h
+++ b/includes/acl/compression/impl/segment_streams.h
@@ -40,9 +40,6 @@ namespace acl
 	{
 		inline void segment_streams(IAllocator& allocator, ClipContext& clip_context, const SegmentingSettings& settings)
 		{
-			if (!settings.enabled)
-				return;
-
 			ACL_ASSERT(clip_context.num_segments == 1, "ClipContext must have a single segment.");
 			ACL_ASSERT(settings.ideal_num_samples <= settings.max_num_samples, "Invalid num samples for segmenting settings. %u > %u", settings.ideal_num_samples, settings.max_num_samples);
 
diff --git a/includes/acl/compression/impl/track_bit_rate_database.h b/includes/acl/compression/impl/track_bit_rate_database.h
--- a/includes/acl/compression/impl/track_bit_rate_database.h
+++ b/includes/acl/compression/impl/track_bit_rate_database.h
@@ -211,9 +211,9 @@ namespace acl
 
 			BitSetDescription	m_bitset_desc;
 			BitSetIndexRef		m_bitref_constant;
-			RotationFormat8		m_rotation_format;
-			VectorFormat8		m_translation_format;
-			VectorFormat8		m_scale_format;
+			rotation_format8		m_rotation_format;
+			vector_format8		m_translation_format;
+			vector_format8		m_scale_format;
 			bool				m_is_rotation_variable;
 			bool				m_is_translation_variable;
 			bool				m_is_scale_variable;
@@ -634,7 +634,7 @@ namespace acl
 					const uint32_t num_samples = bone_stream.rotations.get_num_samples();
 					const float sample_rate = bone_stream.rotations.get_sample_rate();
 
-					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, SampleRoundingPolicy::None, key0, key1, interpolation_alpha);
+					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, sample_rounding_policy::none, key0, key1, interpolation_alpha);
 				}
 				else
 				{
@@ -741,7 +741,7 @@ namespace acl
 				else
 				{
 					// Not cached
-					translation = get_translation_sample(m_raw_bone_streams[track_index], 0, VectorFormat8::Vector3_96);
+					translation = get_translation_sample(m_raw_bone_streams[track_index], 0, vector_format8::vector3f_full);
 
 					cached_samples[0] = translation;
 					bitset_set(validity_bitset, m_bitref_constant, true);
@@ -766,7 +766,7 @@ namespace acl
 					const uint32_t num_samples = bone_stream.translations.get_num_samples();
 					const float sample_rate = bone_stream.translations.get_sample_rate();
 
-					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, SampleRoundingPolicy::None, key0, key1, interpolation_alpha);
+					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, sample_rounding_policy::none, key0, key1, interpolation_alpha);
 				}
 				else
 				{
@@ -869,7 +869,7 @@ namespace acl
 				else
 				{
 					// Not cached
-					scale = get_scale_sample(m_raw_bone_streams[track_index], 0, VectorFormat8::Vector3_96);
+					scale = get_scale_sample(m_raw_bone_streams[track_index], 0, vector_format8::vector3f_full);
 
 					cached_samples[0] = scale;
 					bitset_set(validity_bitset, m_bitref_constant, true);
@@ -894,7 +894,7 @@ namespace acl
 					const uint32_t num_samples = bone_stream.scales.get_num_samples();
 					const float sample_rate = bone_stream.scales.get_sample_rate();
 
-					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, SampleRoundingPolicy::None, key0, key1, interpolation_alpha);
+					find_linear_interpolation_samples_with_sample_rate(num_samples, sample_rate, context.sample_time, sample_rounding_policy::none, key0, key1, interpolation_alpha);
 				}
 				else
 				{
diff --git a/includes/acl/compression/impl/track_stream.h b/includes/acl/compression/impl/track_stream.h
--- a/includes/acl/compression/impl/track_stream.h
+++ b/includes/acl/compression/impl/track_stream.h
@@ -83,23 +83,23 @@ namespace acl
 			uint32_t get_num_samples() const { return m_num_samples; }
 			uint32_t get_sample_size() const { return m_sample_size; }
 			float get_sample_rate() const { return m_sample_rate; }
-			AnimationTrackType8 get_track_type() const { return m_type; }
+			animation_track_type8 get_track_type() const { return m_type; }
 			uint8_t get_bit_rate() const { return m_bit_rate; }
 			bool is_bit_rate_variable() const { return m_bit_rate != k_invalid_bit_rate; }
 			float get_duration() const { return calculate_duration(m_num_samples, m_sample_rate); }
 
 			uint32_t get_packed_sample_size() const
 			{
-				if (m_type == AnimationTrackType8::Rotation)
+				if (m_type == animation_track_type8::rotation)
 					return get_packed_rotation_size(m_format.rotation);
 				else
 					return get_packed_vector_size(m_format.vector);
 			}
 
 		protected:
-			TrackStream(AnimationTrackType8 type, TrackFormat8 format) : m_allocator(nullptr), m_samples(nullptr), m_num_samples(0), m_sample_size(0), m_sample_rate(0.0F), m_type(type), m_format(format), m_bit_rate(0) {}
+			TrackStream(animation_track_type8 type, track_format8 format) : m_allocator(nullptr), m_samples(nullptr), m_num_samples(0), m_sample_size(0), m_sample_rate(0.0F), m_type(type), m_format(format), m_bit_rate(0) {}
 
-			TrackStream(IAllocator& allocator, uint32_t num_samples, uint32_t sample_size, float sample_rate, AnimationTrackType8 type, TrackFormat8 format, uint8_t bit_rate)
+			TrackStream(IAllocator& allocator, uint32_t num_samples, uint32_t sample_size, float sample_rate, animation_track_type8 type, track_format8 format, uint8_t bit_rate)
 				: m_allocator(&allocator)
 				, m_samples(reinterpret_cast<uint8_t*>(allocator.allocate(sample_size * num_samples + k_padding, 16)))
 				, m_num_samples(num_samples)
@@ -170,17 +170,17 @@ namespace acl
 			uint32_t				m_sample_size;
 			float					m_sample_rate;
 
-			AnimationTrackType8		m_type;
-			TrackFormat8			m_format;
+			animation_track_type8		m_type;
+			track_format8			m_format;
 			uint8_t					m_bit_rate;
 			};
 
 		class RotationTrackStream final : public TrackStream
 		{
 		public:
-			RotationTrackStream() : TrackStream(AnimationTrackType8::Rotation, TrackFormat8(RotationFormat8::Quat_128)) {}
-			RotationTrackStream(IAllocator& allocator, uint32_t num_samples, uint32_t sample_size, float sample_rate, RotationFormat8 format, uint8_t bit_rate = k_invalid_bit_rate)
-				: TrackStream(allocator, num_samples, sample_size, sample_rate, AnimationTrackType8::Rotation, TrackFormat8(format), bit_rate)
+			RotationTrackStream() : TrackStream(animation_track_type8::rotation, track_format8(rotation_format8::quatf_full)) {}
+			RotationTrackStream(IAllocator& allocator, uint32_t num_samples, uint32_t sample_size, float sample_rate, rotation_format8 format, uint8_t bit_rate = k_invalid_bit_rate)
+				: TrackStream(allocator, num_samples, sample_size, sample_rate, animation_track_type8::rotation, track_format8(format), bit_rate)
 			{}
 			RotationTrackStream(const RotationTrackStream&) = delete;
 			RotationTrackStream(RotationTrackStream&& other)
@@ -202,15 +202,15 @@ namespace acl
 				return copy;
 			}
 
-			RotationFormat8 get_rotation_format() const { return m_format.rotation; }
+			rotation_format8 get_rotation_format() const { return m_format.rotation; }
 		};
 
 		class TranslationTrackStream final : public TrackStream
 		{
 		public:
-			TranslationTrackStream() : TrackStream(AnimationTrackType8::Translation, TrackFormat8(VectorFormat8::Vector3_96)) {}
-			TranslationTrackStream(IAllocator& allocator, uint32_t num_samples, uint32_t sample_size, float sample_rate, VectorFormat8 format, uint8_t bit_rate = k_invalid_bit_rate)
-				: TrackStream(allocator, num_samples, sample_size, sample_rate, AnimationTrackType8::Translation, TrackFormat8(format), bit_rate)
+			TranslationTrackStream() : TrackStream(animation_track_type8::translation, track_format8(vector_format8::vector3f_full)) {}
+			TranslationTrackStream(IAllocator& allocator, uint32_t num_samples, uint32_t sample_size, float sample_rate, vector_format8 format, uint8_t bit_rate = k_invalid_bit_rate)
+				: TrackStream(allocator, num_samples, sample_size, sample_rate, animation_track_type8::translation, track_format8(format), bit_rate)
 			{}
 			TranslationTrackStream(const TranslationTrackStream&) = delete;
 			TranslationTrackStream(TranslationTrackStream&& other)
@@ -232,15 +232,15 @@ namespace acl
 				return copy;
 			}
 
-			VectorFormat8 get_vector_format() const { return m_format.vector; }
+			vector_format8 get_vector_format() const { return m_format.vector; }
 		};
 
 		class ScaleTrackStream final : public TrackStream
 		{
 		public:
-			ScaleTrackStream() : TrackStream(AnimationTrackType8::Scale, TrackFormat8(VectorFormat8::Vector3_96)) {}
-			ScaleTrackStream(IAllocator& allocator, uint32_t num_samples, uint32_t sample_size, float sample_rate, VectorFormat8 format, uint8_t bit_rate = k_invalid_bit_rate)
-				: TrackStream(allocator, num_samples, sample_size, sample_rate, AnimationTrackType8::Scale, TrackFormat8(format), bit_rate)
+			ScaleTrackStream() : TrackStream(animation_track_type8::scale, track_format8(vector_format8::vector3f_full)) {}
+			ScaleTrackStream(IAllocator& allocator, uint32_t num_samples, uint32_t sample_size, float sample_rate, vector_format8 format, uint8_t bit_rate = k_invalid_bit_rate)
+				: TrackStream(allocator, num_samples, sample_size, sample_rate, animation_track_type8::scale, track_format8(format), bit_rate)
 			{}
 			ScaleTrackStream(const ScaleTrackStream&) = delete;
 			ScaleTrackStream(ScaleTrackStream&& other)
@@ -262,7 +262,7 @@ namespace acl
 				return copy;
 			}
 
-			VectorFormat8 get_vector_format() const { return m_format.vector; }
+			vector_format8 get_vector_format() const { return m_format.vector; }
 		};
 
 		// For a rotation track, the extent only tells us if the track is constant or not
diff --git a/includes/acl/compression/impl/write_compression_stats_impl.h b/includes/acl/compression/impl/write_compression_stats_impl.h
--- a/includes/acl/compression/impl/write_compression_stats_impl.h
+++ b/includes/acl/compression/impl/write_compression_stats_impl.h
@@ -49,7 +49,7 @@ namespace acl
 			const double compression_ratio = double(raw_size) / double(compressed_size);
 
 			sjson::ObjectWriter& writer = *stats.writer;
-			writer["algorithm_name"] = get_algorithm_name(AlgorithmType8::UniformlySampled);
+			writer["algorithm_name"] = get_algorithm_name(algorithm_type8::uniformly_sampled);
 			//writer["algorithm_uid"] = settings.get_hash();
 			//writer["clip_name"] = clip.get_name().c_str();
 			writer["raw_size"] = raw_size;
diff --git a/includes/acl/compression/impl/write_decompression_stats.h b/includes/acl/compression/impl/write_decompression_stats.h
--- a/includes/acl/compression/impl/write_decompression_stats.h
+++ b/includes/acl/compression/impl/write_decompression_stats.h
@@ -139,7 +139,7 @@ namespace acl
 						{
 							// If we want the cache warm, decompress everything once to prime it
 							DecompressionContextType* context = contexts[0];
-							context->seek(sample_time, SampleRoundingPolicy::None);
+							context->seek(sample_time, sample_rounding_policy::none);
 							context->decompress_pose(pose_writer);
 						}
 
@@ -154,7 +154,7 @@ namespace acl
 							// If we measure with a cold CPU cache, we use a different context every time otherwise we use the first one
 							DecompressionContextType* context = is_cold_cache_profiling ? contexts[clip_index] : contexts[0];
 
-							context->seek(sample_time, SampleRoundingPolicy::None);
+							context->seek(sample_time, sample_rounding_policy::none);
 
 							switch (decompression_function)
 							{
@@ -304,17 +304,15 @@ namespace acl
 
 			switch (compressed_clip.get_algorithm_type())
 			{
-			case AlgorithmType8::UniformlySampled:
+			case algorithm_type8::uniformly_sampled:
 			{
 #if defined(ACL_HAS_ASSERT_CHECKS)
 				// If we can, we use a fast-path that simulates what a real game engine would use
 				// by disabling the things they normally wouldn't care about like deprecated formats
 				// and debugging features
-				const bool use_uniform_fast_path = settings.rotation_format == RotationFormat8::QuatDropW_Variable
-					&& settings.translation_format == VectorFormat8::Vector3_Variable
-					&& settings.scale_format == VectorFormat8::Vector3_Variable
-					&& are_all_enum_flags_set(settings.range_reduction, RangeReductionFlags8::AllTracks)
-					&& settings.segmenting.enabled;
+				const bool use_uniform_fast_path = settings.rotation_format == rotation_format8::quatf_drop_w_variable
+					&& settings.translation_format == vector_format8::vector3f_variable
+					&& settings.scale_format == vector_format8::vector3f_variable;
 
 				ACL_ASSERT(use_uniform_fast_path, "We do not support profiling the debug code path");
 #endif
diff --git a/includes/acl/compression/impl/write_range_data.h b/includes/acl/compression/impl/write_range_data.h
--- a/includes/acl/compression/impl/write_range_data.h
+++ b/includes/acl/compression/impl/write_range_data.h
@@ -44,11 +44,11 @@ namespace acl
 {
 	namespace acl_impl
 	{
-		inline uint32_t get_stream_range_data_size(const ClipContext& clip_context, RangeReductionFlags8 range_reduction, RotationFormat8 rotation_format)
+		inline uint32_t get_stream_range_data_size(const ClipContext& clip_context, range_reduction_flags8 range_reduction, rotation_format8 rotation_format)
 		{
-			const uint32_t rotation_size = are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Rotations) ? get_range_reduction_rotation_size(rotation_format) : 0;
-			const uint32_t translation_size = are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Translations) ? k_clip_range_reduction_vector3_range_size : 0;
-			const uint32_t scale_size = are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Scales) ? k_clip_range_reduction_vector3_range_size : 0;
+			const uint32_t rotation_size = are_any_enum_flags_set(range_reduction, range_reduction_flags8::rotations) ? get_range_reduction_rotation_size(rotation_format) : 0;
+			const uint32_t translation_size = are_any_enum_flags_set(range_reduction, range_reduction_flags8::translations) ? k_clip_range_reduction_vector3_range_size : 0;
+			const uint32_t scale_size = are_any_enum_flags_set(range_reduction, range_reduction_flags8::scales) ? k_clip_range_reduction_vector3_range_size : 0;
 			uint32_t range_data_size = 0;
 
 			// Only use the first segment, it contains the necessary information
@@ -101,7 +101,7 @@ namespace acl
 		}
 
 		inline void write_range_track_data(const BoneStreams* bone_streams, const BoneRanges* bone_ranges,
-			RangeReductionFlags8 range_reduction, bool is_clip_range_data,
+			range_reduction_flags8 range_reduction, bool is_clip_range_data,
 			uint8_t* range_data, uint32_t range_data_size,
 			const uint16_t* output_bone_mapping, uint16_t num_output_bones)
 		{
@@ -122,14 +122,14 @@ namespace acl
 				// value = (normalized value * range extent) + range min
 				// normalized value = (value - range min) / range extent
 
-				if (are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Rotations) && !bone_stream.is_rotation_constant)
+				if (are_any_enum_flags_set(range_reduction, range_reduction_flags8::rotations) && !bone_stream.is_rotation_constant)
 				{
 					const rtm::vector4f range_min = bone_range.rotation.get_min();
 					const rtm::vector4f range_extent = bone_range.rotation.get_extent();
 
 					if (is_clip_range_data)
 					{
-						const uint32_t range_member_size = bone_stream.rotations.get_rotation_format() == RotationFormat8::Quat_128 ? (sizeof(float) * 4) : (sizeof(float) * 3);
+						const uint32_t range_member_size = bone_stream.rotations.get_rotation_format() == rotation_format8::quatf_full ? (sizeof(float) * 4) : (sizeof(float) * 3);
 
 						std::memcpy(range_data, &range_min, range_member_size);
 						range_data += range_member_size;
@@ -138,7 +138,7 @@ namespace acl
 					}
 					else
 					{
-						if (bone_stream.rotations.get_rotation_format() == RotationFormat8::Quat_128)
+						if (bone_stream.rotations.get_rotation_format() == rotation_format8::quatf_full)
 						{
 							pack_vector4_32(range_min, true, range_data);
 							range_data += sizeof(uint8_t) * 4;
@@ -164,10 +164,10 @@ namespace acl
 					}
 				}
 
-				if (are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Translations) && !bone_stream.is_translation_constant)
+				if (are_any_enum_flags_set(range_reduction, range_reduction_flags8::translations) && !bone_stream.is_translation_constant)
 					write_range_track_data_impl(bone_stream.translations, bone_range.translation, is_clip_range_data, range_data);
 
-				if (are_any_enum_flags_set(range_reduction, RangeReductionFlags8::Scales) && !bone_stream.is_scale_constant)
+				if (are_any_enum_flags_set(range_reduction, range_reduction_flags8::scales) && !bone_stream.is_scale_constant)
 					write_range_track_data_impl(bone_stream.scales, bone_range.scale, is_clip_range_data, range_data);
 
 				ACL_ASSERT(range_data <= range_data_end, "Invalid range data offset. Wrote too much data.");
@@ -176,7 +176,7 @@ namespace acl
 			ACL_ASSERT(range_data == range_data_end, "Invalid range data offset. Wrote too little data.");
 		}
 
-		inline void write_clip_range_data(const ClipContext& clip_context, RangeReductionFlags8 range_reduction, uint8_t* range_data, uint32_t range_data_size, const uint16_t* output_bone_mapping, uint16_t num_output_bones)
+		inline void write_clip_range_data(const ClipContext& clip_context, range_reduction_flags8 range_reduction, uint8_t* range_data, uint32_t range_data_size, const uint16_t* output_bone_mapping, uint16_t num_output_bones)
 		{
 			// Only use the first segment, it contains the necessary information
 			const SegmentContext& segment = clip_context.segments[0];
@@ -184,7 +184,7 @@ namespace acl
 			write_range_track_data(segment.bone_streams, clip_context.ranges, range_reduction, true, range_data, range_data_size, output_bone_mapping, num_output_bones);
 		}
 
-		inline void write_segment_range_data(const SegmentContext& segment, RangeReductionFlags8 range_reduction, uint8_t* range_data, uint32_t range_data_size, const uint16_t* output_bone_mapping, uint16_t num_output_bones)
+		inline void write_segment_range_data(const SegmentContext& segment, range_reduction_flags8 range_reduction, uint8_t* range_data, uint32_t range_data_size, const uint16_t* output_bone_mapping, uint16_t num_output_bones)
 		{
 			write_range_track_data(segment.bone_streams, segment.ranges, range_reduction, false, range_data, range_data_size, output_bone_mapping, num_output_bones);
 		}
diff --git a/includes/acl/compression/impl/write_segment_data.h b/includes/acl/compression/impl/write_segment_data.h
--- a/includes/acl/compression/impl/write_segment_data.h
+++ b/includes/acl/compression/impl/write_segment_data.h
@@ -72,7 +72,7 @@ namespace acl
 			}
 		}
 
-		inline void write_segment_data(const ClipContext& clip_context, const CompressionSettings& settings, ClipHeader& header, const uint16_t* output_bone_mapping, uint16_t num_output_bones)
+		inline void write_segment_data(const ClipContext& clip_context, const CompressionSettings& settings, range_reduction_flags8 range_reduction, ClipHeader& header, const uint16_t* output_bone_mapping, uint16_t num_output_bones)
 		{
 			SegmentHeader* segment_headers = header.get_segment_headers();
 			const uint32_t format_per_track_data_size = get_format_per_track_data_size(clip_context, settings.rotation_format, settings.translation_format, settings.scale_format);
@@ -88,12 +88,12 @@ namespace acl
 					segment_header.format_per_track_data_offset = InvalidPtrOffset();
 
 				if (segment.range_data_size > 0)
-					write_segment_range_data(segment, settings.segmenting.range_reduction, header.get_segment_range_data(segment_header), segment.range_data_size, output_bone_mapping, num_output_bones);
+					write_segment_range_data(segment, range_reduction, header.get_segment_range_data(segment_header), segment.range_data_size, output_bone_mapping, num_output_bones);
 				else
 					segment_header.range_data_offset = InvalidPtrOffset();
 
 				if (segment.animated_data_size > 0)
-					write_animated_track_data(segment, settings.rotation_format, settings.translation_format, settings.scale_format, header.get_track_data(segment_header), segment.animated_data_size, output_bone_mapping, num_output_bones);
+					write_animated_track_data(segment, header.get_track_data(segment_header), segment.animated_data_size, output_bone_mapping, num_output_bones);
 				else
 					segment_header.track_data_offset = InvalidPtrOffset();
 			}
diff --git a/includes/acl/compression/impl/write_stats.h b/includes/acl/compression/impl/write_stats.h
--- a/includes/acl/compression/impl/write_stats.h
+++ b/includes/acl/compression/impl/write_stats.h
@@ -46,7 +46,7 @@ namespace acl
 {
 	namespace acl_impl
 	{
-		inline void write_summary_segment_stats(const SegmentContext& segment, RotationFormat8 rotation_format, VectorFormat8 translation_format, VectorFormat8 scale_format, sjson::ObjectWriter& writer)
+		inline void write_summary_segment_stats(const SegmentContext& segment, rotation_format8 rotation_format, vector_format8 translation_format, vector_format8 scale_format, sjson::ObjectWriter& writer)
 		{
 			writer["segment_index"] = segment.segment_index;
 			writer["num_samples"] = segment.num_samples;
@@ -228,7 +228,7 @@ namespace acl
 			const double compression_ratio = double(raw_size) / double(compressed_size);
 
 			sjson::ObjectWriter& writer = *stats.writer;
-			writer["algorithm_name"] = get_algorithm_name(AlgorithmType8::UniformlySampled);
+			writer["algorithm_name"] = get_algorithm_name(algorithm_type8::uniformly_sampled);
 			writer["algorithm_uid"] = settings.get_hash();
 			writer["clip_name"] = clip.get_name().c_str();
 			writer["raw_size"] = raw_size;
@@ -241,7 +241,6 @@ namespace acl
 			writer["rotation_format"] = get_rotation_format_name(settings.rotation_format);
 			writer["translation_format"] = get_vector_format_name(settings.translation_format);
 			writer["scale_format"] = get_vector_format_name(settings.scale_format);
-			writer["range_reduction"] = get_range_reduction_name(settings.range_reduction);
 			writer["has_scale"] = clip_context.has_scale;
 			writer["error_metric"] = settings.error_metric->get_name();
 
@@ -302,16 +301,12 @@ namespace acl
 				writer["num_animated_tracks"] = num_animated_tracks;
 			}
 
-			if (settings.segmenting.enabled)
+			writer["segmenting"] = [&](sjson::ObjectWriter& segmenting_writer)
 			{
-				writer["segmenting"] = [&](sjson::ObjectWriter& segmenting_writer)
-				{
-					segmenting_writer["num_segments"] = header.num_segments;
-					segmenting_writer["range_reduction"] = get_range_reduction_name(settings.segmenting.range_reduction);
-					segmenting_writer["ideal_num_samples"] = settings.segmenting.ideal_num_samples;
-					segmenting_writer["max_num_samples"] = settings.segmenting.max_num_samples;
-				};
-			}
+				segmenting_writer["num_segments"] = header.num_segments;
+				segmenting_writer["ideal_num_samples"] = settings.segmenting.ideal_num_samples;
+				segmenting_writer["max_num_samples"] = settings.segmenting.max_num_samples;
+			};
 
 			writer["segments"] = [&](sjson::ArrayWriter& segments_writer)
 			{
diff --git a/includes/acl/compression/impl/write_stream_data.h b/includes/acl/compression/impl/write_stream_data.h
--- a/includes/acl/compression/impl/write_stream_data.h
+++ b/includes/acl/compression/impl/write_stream_data.h
@@ -63,23 +63,21 @@ namespace acl
 			return constant_data_size;
 		}
 
-		inline void get_animated_variable_bit_rate_data_size(const TrackStream& track_stream, bool has_mixed_packing, uint32_t num_samples, uint32_t& out_num_animated_data_bits, uint32_t& out_num_animated_pose_bits)
+		inline void get_animated_variable_bit_rate_data_size(const TrackStream& track_stream, uint32_t num_samples, uint32_t& out_num_animated_data_bits, uint32_t& out_num_animated_pose_bits)
 		{
 			const uint8_t bit_rate = track_stream.get_bit_rate();
-			uint32_t num_bits_at_bit_rate = get_num_bits_at_bit_rate(bit_rate) * 3;	// 3 components
-			if (has_mixed_packing)
-				num_bits_at_bit_rate = align_to(num_bits_at_bit_rate, k_mixed_packing_alignment_num_bits);
+			const uint32_t num_bits_at_bit_rate = get_num_bits_at_bit_rate(bit_rate) * 3;	// 3 components
 			out_num_animated_data_bits += num_bits_at_bit_rate * num_samples;
 			out_num_animated_pose_bits += num_bits_at_bit_rate;
 		}
 
-		inline void calculate_animated_data_size(const TrackStream& track_stream, bool has_mixed_packing, uint32_t& num_animated_data_bits, uint32_t& num_animated_pose_bits)
+		inline void calculate_animated_data_size(const TrackStream& track_stream, uint32_t& num_animated_data_bits, uint32_t& num_animated_pose_bits)
 		{
 			const uint32_t num_samples = track_stream.get_num_samples();
 
 			if (track_stream.is_bit_rate_variable())
 			{
-				get_animated_variable_bit_rate_data_size(track_stream, has_mixed_packing, num_samples, num_animated_data_bits, num_animated_pose_bits);
+				get_animated_variable_bit_rate_data_size(track_stream, num_samples, num_animated_data_bits, num_animated_pose_bits);
 			}
 			else
 			{
@@ -89,14 +87,8 @@ namespace acl
 			}
 		}
 
-		inline void calculate_animated_data_size(ClipContext& clip_context, RotationFormat8 rotation_format, VectorFormat8 translation_format, VectorFormat8 scale_format, const uint16_t* output_bone_mapping, uint16_t num_output_bones)
+		inline void calculate_animated_data_size(ClipContext& clip_context, const uint16_t* output_bone_mapping, uint16_t num_output_bones)
 		{
-			// If all tracks are variable, no need for any extra padding except at the very end of the data
-			// If our tracks are mixed variable/not variable, we need to add some padding to ensure alignment
-			const bool is_every_format_variable = is_rotation_format_variable(rotation_format) && is_vector_format_variable(translation_format) && is_vector_format_variable(scale_format);
-			const bool is_any_format_variable = is_rotation_format_variable(rotation_format) || is_vector_format_variable(translation_format) || is_vector_format_variable(scale_format);
-			const bool has_mixed_packing = !is_every_format_variable && is_any_format_variable;
-
 			for (SegmentContext& segment : clip_context.segment_iterator())
 			{
 				uint32_t num_animated_data_bits = 0;
@@ -108,13 +100,13 @@ namespace acl
 					const BoneStreams& bone_stream = segment.bone_streams[bone_index];
 
 					if (!bone_stream.is_rotation_constant)
-						calculate_animated_data_size(bone_stream.rotations, has_mixed_packing, num_animated_data_bits, num_animated_pose_bits);
+						calculate_animated_data_size(bone_stream.rotations, num_animated_data_bits, num_animated_pose_bits);
 
 					if (!bone_stream.is_translation_constant)
-						calculate_animated_data_size(bone_stream.translations, has_mixed_packing, num_animated_data_bits, num_animated_pose_bits);
+						calculate_animated_data_size(bone_stream.translations, num_animated_data_bits, num_animated_pose_bits);
 
 					if (!bone_stream.is_scale_constant)
-						calculate_animated_data_size(bone_stream.scales, has_mixed_packing, num_animated_data_bits, num_animated_pose_bits);
+						calculate_animated_data_size(bone_stream.scales, num_animated_data_bits, num_animated_pose_bits);
 				}
 
 				segment.animated_data_size = align_to(num_animated_data_bits, 8) / 8;
@@ -122,7 +114,7 @@ namespace acl
 			}
 		}
 
-		inline uint32_t get_format_per_track_data_size(const ClipContext& clip_context, RotationFormat8 rotation_format, VectorFormat8 translation_format, VectorFormat8 scale_format)
+		inline uint32_t get_format_per_track_data_size(const ClipContext& clip_context, rotation_format8 rotation_format, vector_format8 translation_format, vector_format8 scale_format)
 		{
 			const bool is_rotation_variable = is_rotation_format_variable(rotation_format);
 			const bool is_translation_variable = is_vector_format_variable(translation_format);
@@ -198,20 +190,22 @@ namespace acl
 			ACL_ASSERT(constant_data == constant_data_end, "Invalid constant data offset. Wrote too little data.");
 		}
 
-		inline void write_animated_track_data(const TrackStream& track_stream, uint32_t sample_index, bool has_mixed_packing, uint8_t* animated_track_data_begin, uint8_t*& out_animated_track_data, uint64_t& out_bit_offset)
+		inline void write_animated_track_data(const TrackStream& track_stream, uint32_t sample_index, uint8_t* animated_track_data_begin, uint8_t*& out_animated_track_data, uint64_t& out_bit_offset)
 		{
+			const uint8_t* raw_sample_ptr = track_stream.get_raw_sample_ptr(sample_index);
+
 			if (track_stream.is_bit_rate_variable())
 			{
 				const uint8_t bit_rate = track_stream.get_bit_rate();
-				uint64_t num_bits_at_bit_rate = get_num_bits_at_bit_rate(bit_rate) * 3;	// 3 components
+				const uint64_t num_bits_at_bit_rate = get_num_bits_at_bit_rate(bit_rate) * 3;	// 3 components
 
 				// Track is constant, our constant sample is stored in the range information
 				ACL_ASSERT(!is_constant_bit_rate(bit_rate), "Cannot write constant variable track data");
-				const uint8_t* raw_sample_ptr = track_stream.get_raw_sample_ptr(sample_index);
 
 				if (is_raw_bit_rate(bit_rate))
 				{
 					const uint32_t* raw_sample_u32 = safe_ptr_cast<const uint32_t>(raw_sample_ptr);
+
 					const uint32_t x = byte_swap(raw_sample_u32[0]);
 					memcpy_bits(animated_track_data_begin, out_bit_offset + 0, &x, 0, 32);
 					const uint32_t y = byte_swap(raw_sample_u32[1]);
@@ -225,23 +219,34 @@ namespace acl
 					memcpy_bits(animated_track_data_begin, out_bit_offset, &raw_sample_u64, 0, num_bits_at_bit_rate);
 				}
 
-				if (has_mixed_packing)
-					num_bits_at_bit_rate = align_to(num_bits_at_bit_rate, k_mixed_packing_alignment_num_bits);
-
 				out_bit_offset += num_bits_at_bit_rate;
 				out_animated_track_data = animated_track_data_begin + (out_bit_offset / 8);
 			}
 			else
 			{
-				const uint8_t* raw_sample_ptr = track_stream.get_raw_sample_ptr(sample_index);
+				const uint32_t* raw_sample_u32 = safe_ptr_cast<const uint32_t>(raw_sample_ptr);
+
+				const uint32_t x = byte_swap(raw_sample_u32[0]);
+				memcpy_bits(animated_track_data_begin, out_bit_offset + 0, &x, 0, 32);
+				const uint32_t y = byte_swap(raw_sample_u32[1]);
+				memcpy_bits(animated_track_data_begin, out_bit_offset + 32, &y, 0, 32);
+				const uint32_t z = byte_swap(raw_sample_u32[2]);
+				memcpy_bits(animated_track_data_begin, out_bit_offset + 64, &z, 0, 32);
+
 				const uint32_t sample_size = track_stream.get_packed_sample_size();
-				std::memcpy(out_animated_track_data, raw_sample_ptr, sample_size);
-				out_animated_track_data += sample_size;
-				out_bit_offset = (out_animated_track_data - animated_track_data_begin) * 8;
+				const bool has_w_component = sample_size == (sizeof(float) * 4);
+				if (has_w_component)
+				{
+					const uint32_t w = byte_swap(raw_sample_u32[3]);
+					memcpy_bits(animated_track_data_begin, out_bit_offset + 96, &w, 0, 32);
+				}
+
+				out_bit_offset += has_w_component ? 128 : 96;
+				out_animated_track_data = animated_track_data_begin + (out_bit_offset / 8);
 			}
 		}
 
-		inline void write_animated_track_data(const SegmentContext& segment, RotationFormat8 rotation_format, VectorFormat8 translation_format, VectorFormat8 scale_format, uint8_t* animated_track_data, uint32_t animated_data_size, const uint16_t* output_bone_mapping, uint16_t num_output_bones)
+		inline void write_animated_track_data(const SegmentContext& segment, uint8_t* animated_track_data, uint32_t animated_data_size, const uint16_t* output_bone_mapping, uint16_t num_output_bones)
 		{
 			ACL_ASSERT(animated_track_data != nullptr, "'animated_track_data' cannot be null!");
 			(void)animated_data_size;
@@ -252,12 +257,6 @@ namespace acl
 			const uint8_t* animated_track_data_end = add_offset_to_ptr<uint8_t>(animated_track_data, animated_data_size);
 #endif
 
-			// If all tracks are variable, no need for any extra padding except at the very end of the data
-			// If our tracks are mixed variable/not variable, we need to add some padding to ensure alignment
-			const bool is_every_format_variable = is_rotation_format_variable(rotation_format) && is_vector_format_variable(translation_format) && is_vector_format_variable(scale_format);
-			const bool is_any_format_variable = is_rotation_format_variable(rotation_format) || is_vector_format_variable(translation_format) || is_vector_format_variable(scale_format);
-			const bool has_mixed_packing = !is_every_format_variable && is_any_format_variable;
-
 			uint64_t bit_offset = 0;
 
 			// Data is sorted first by time, second by bone.
@@ -270,13 +269,13 @@ namespace acl
 					const BoneStreams& bone_stream = segment.bone_streams[bone_index];
 
 					if (!bone_stream.is_rotation_constant && !is_constant_bit_rate(bone_stream.rotations.get_bit_rate()))
-						write_animated_track_data(bone_stream.rotations, sample_index, has_mixed_packing, animated_track_data_begin, animated_track_data, bit_offset);
+						write_animated_track_data(bone_stream.rotations, sample_index, animated_track_data_begin, animated_track_data, bit_offset);
 
 					if (!bone_stream.is_translation_constant && !is_constant_bit_rate(bone_stream.translations.get_bit_rate()))
-						write_animated_track_data(bone_stream.translations, sample_index, has_mixed_packing, animated_track_data_begin, animated_track_data, bit_offset);
+						write_animated_track_data(bone_stream.translations, sample_index, animated_track_data_begin, animated_track_data, bit_offset);
 
 					if (!bone_stream.is_scale_constant && !is_constant_bit_rate(bone_stream.scales.get_bit_rate()))
-						write_animated_track_data(bone_stream.scales, sample_index, has_mixed_packing, animated_track_data_begin, animated_track_data, bit_offset);
+						write_animated_track_data(bone_stream.scales, sample_index, animated_track_data_begin, animated_track_data, bit_offset);
 
 					ACL_ASSERT(animated_track_data <= animated_track_data_end, "Invalid animated track data offset. Wrote too much data.");
 				}
diff --git a/includes/acl/compression/skeleton_error_metric.h b/includes/acl/compression/skeleton_error_metric.h
--- a/includes/acl/compression/skeleton_error_metric.h
+++ b/includes/acl/compression/skeleton_error_metric.h
@@ -448,7 +448,7 @@ namespace acl
 	// This error metric should be used whenever a clip is additive or relative.
 	// Note that this can cause inaccuracy when dealing with shear/skew.
 	//////////////////////////////////////////////////////////////////////////
-	template<AdditiveClipFormat8 additive_format>
+	template<additive_clip_format8 additive_format>
 	class additive_qvvf_transform_error_metric : public qvvf_transform_error_metric
 	{
 	public:
@@ -457,10 +457,10 @@ namespace acl
 			switch (additive_format)
 			{
 			default:
-			case AdditiveClipFormat8::None:			return "additive_qvvf_transform_error_metric<None>";
-			case AdditiveClipFormat8::Relative:		return "additive_qvvf_transform_error_metric<Relative>";
-			case AdditiveClipFormat8::Additive0:	return "additive_qvvf_transform_error_metric<Additive0>";
-			case AdditiveClipFormat8::Additive1:	return "additive_qvvf_transform_error_metric<Additive1>";
+			case additive_clip_format8::none:			return "additive_qvvf_transform_error_metric<none>";
+			case additive_clip_format8::relative:		return "additive_qvvf_transform_error_metric<relative>";
+			case additive_clip_format8::additive0:	return "additive_qvvf_transform_error_metric<additive0>";
+			case additive_clip_format8::additive1:	return "additive_qvvf_transform_error_metric<additive1>";
 			}
 		}
 
diff --git a/includes/acl/compression/track_array.h b/includes/acl/compression/track_array.h
--- a/includes/acl/compression/track_array.h
+++ b/includes/acl/compression/track_array.h
@@ -174,13 +174,13 @@ namespace acl
 		// Sample all tracks within this array at the specified sample time and
 		// desired rounding policy. Track samples are written out using the `track_writer` provided.
 		template<class track_writer_type>
-		void sample_tracks(float sample_time, SampleRoundingPolicy rounding_policy, track_writer_type& writer) const;
+		void sample_tracks(float sample_time, sample_rounding_policy rounding_policy, track_writer_type& writer) const;
 
 		//////////////////////////////////////////////////////////////////////////
 		// Sample a single track within this array at the specified sample time and
 		// desired rounding policy. The track sample is written out using the `track_writer` provided.
 		template<class track_writer_type>
-		void sample_track(uint32_t track_index, float sample_time, SampleRoundingPolicy rounding_policy, track_writer_type& writer) const;
+		void sample_track(uint32_t track_index, float sample_time, sample_rounding_policy rounding_policy, track_writer_type& writer) const;
 
 		//////////////////////////////////////////////////////////////////////////
 		// Returns the raw size for this track array. Note that this differs from the actual
@@ -325,7 +325,7 @@ namespace acl
 	//////////////////////////////////////////////////////////////////////////
 
 	template<class track_writer_type>
-	inline void track_array::sample_tracks(float sample_time, SampleRoundingPolicy rounding_policy, track_writer_type& writer) const
+	inline void track_array::sample_tracks(float sample_time, sample_rounding_policy rounding_policy, track_writer_type& writer) const
 	{
 		ACL_ASSERT(is_valid().empty(), "Invalid track array");
 
@@ -334,7 +334,7 @@ namespace acl
 	}
 
 	template<class track_writer_type>
-	inline void track_array::sample_track(uint32_t track_index, float sample_time, SampleRoundingPolicy rounding_policy, track_writer_type& writer) const
+	inline void track_array::sample_track(uint32_t track_index, float sample_time, sample_rounding_policy rounding_policy, track_writer_type& writer) const
 	{
 		ACL_ASSERT(is_valid().empty(), "Invalid track array");
 		ACL_ASSERT(track_index < m_num_tracks, "Invalid track index");
diff --git a/includes/acl/compression/track_error.h b/includes/acl/compression/track_error.h
--- a/includes/acl/compression/track_error.h
+++ b/includes/acl/compression/track_error.h
@@ -93,9 +93,9 @@ namespace acl
 			const float sample_time = rtm::scalar_min(float(sample_index) / sample_rate, duration);
 
 			// We use the nearest sample to accurately measure the loss that happened, if any
-			raw_tracks.sample_tracks(sample_time, SampleRoundingPolicy::Nearest, raw_tracks_writer);
+			raw_tracks.sample_tracks(sample_time, sample_rounding_policy::nearest, raw_tracks_writer);
 
-			context.seek(sample_time, SampleRoundingPolicy::Nearest);
+			context.seek(sample_time, sample_rounding_policy::nearest);
 			context.decompress_tracks(lossy_tracks_writer);
 
 			// Validate decompress_tracks
diff --git a/includes/acl/compression/utils.h b/includes/acl/compression/utils.h
--- a/includes/acl/compression/utils.h
+++ b/includes/acl/compression/utils.h
@@ -142,9 +142,9 @@ namespace acl
 			const float sample_time = rtm::scalar_min(float(sample_index) / sample_rate, clip_duration);
 
 			// We use the nearest sample to accurately measure the loss that happened, if any
-			clip.sample_pose(sample_time, SampleRoundingPolicy::Nearest, raw_local_pose, num_bones);
+			clip.sample_pose(sample_time, sample_rounding_policy::nearest, raw_local_pose, num_bones);
 
-			context.seek(sample_time, SampleRoundingPolicy::Nearest);
+			context.seek(sample_time, sample_rounding_policy::nearest);
 			context.decompress_pose(pose_writer);
 
 			// Perform remapping by copying the raw pose first and we overwrite with the decompressed pose if
@@ -166,7 +166,7 @@ namespace acl
 			{
 				const float normalized_sample_time = additive_num_samples > 1 ? (sample_time / clip_duration) : 0.0F;
 				const float additive_sample_time = additive_num_samples > 1 ? (normalized_sample_time * additive_duration) : 0.0F;
-				additive_base_clip->sample_pose(additive_sample_time, SampleRoundingPolicy::Nearest, base_local_pose, num_bones);
+				additive_base_clip->sample_pose(additive_sample_time, sample_rounding_policy::nearest, base_local_pose, num_bones);
 
 				if (needs_conversion)
 					error_metric.convert_transforms(convert_transforms_args_base, base_local_pose_converted);
diff --git a/includes/acl/core/additive_utils.h b/includes/acl/core/additive_utils.h
--- a/includes/acl/core/additive_utils.h
+++ b/includes/acl/core/additive_utils.h
@@ -37,79 +37,87 @@ namespace acl
 {
 	//////////////////////////////////////////////////////////////////////////
 	// Describes the format used by the additive clip.
-	enum class AdditiveClipFormat8 : uint8_t
+	enum class additive_clip_format8 : uint8_t
 	{
 		//////////////////////////////////////////////////////////////////////////
 		// Clip is not additive
-		None				= 0,
+		none				= 0,
 
 		//////////////////////////////////////////////////////////////////////////
 		// Clip is in relative space, transform_mul or equivalent is used to combine them.
 		// transform = transform_mul(additive_transform, base_transform)
-		Relative			= 1,
+		relative			= 1,
 
 		//////////////////////////////////////////////////////////////////////////
 		// Clip is in additive space where scale is combined with: base_scale * additive_scale
 		// transform = transform_add0(additive_transform, base_transform)
-		Additive0			= 2,
+		additive0			= 2,
 
 		//////////////////////////////////////////////////////////////////////////
 		// Clip is in additive space where scale is combined with: base_scale * (1.0 + additive_scale)
 		// transform = transform_add1(additive_transform, base_transform)
-		Additive1			= 3,
+		additive1			= 3,
 	};
 
 	//////////////////////////////////////////////////////////////////////////
 
 	// TODO: constexpr
-	inline const char* get_additive_clip_format_name(AdditiveClipFormat8 format)
+	inline const char* get_additive_clip_format_name(additive_clip_format8 format)
 	{
 		switch (format)
 		{
-		case AdditiveClipFormat8::None:				return "None";
-		case AdditiveClipFormat8::Relative:			return "Relative";
-		case AdditiveClipFormat8::Additive0:		return "Additive0";
-		case AdditiveClipFormat8::Additive1:		return "Additive1";
+		case additive_clip_format8::none:			return "none";
+		case additive_clip_format8::relative:		return "relative";
+		case additive_clip_format8::additive0:		return "additive0";
+		case additive_clip_format8::additive1:		return "additive1";
 		default:									return "<Invalid>";
 		}
 	}
 
-	inline bool get_additive_clip_format(const char* format, AdditiveClipFormat8& out_format)
+	inline bool get_additive_clip_format(const char* format, additive_clip_format8& out_format)
 	{
-		const char* none_format = "None";
-		if (std::strncmp(format, none_format, std::strlen(none_format)) == 0)
+		const char* none_format = "None";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* none_format_new = "none";
+		if (std::strncmp(format, none_format, std::strlen(none_format)) == 0
+			|| std::strncmp(format, none_format_new, std::strlen(none_format_new)) == 0)
 		{
-			out_format = AdditiveClipFormat8::None;
+			out_format = additive_clip_format8::none;
 			return true;
 		}
 
-		const char* relative_format = "Relative";
-		if (std::strncmp(format, relative_format, std::strlen(relative_format)) == 0)
+		const char* relative_format = "Relative";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* relative_format_new = "relative";
+		if (std::strncmp(format, relative_format, std::strlen(relative_format)) == 0
+			|| std::strncmp(format, relative_format_new, std::strlen(relative_format_new)) == 0)
 		{
-			out_format = AdditiveClipFormat8::Relative;
+			out_format = additive_clip_format8::relative;
 			return true;
 		}
 
-		const char* additive0_format = "Additive0";
-		if (std::strncmp(format, additive0_format, std::strlen(additive0_format)) == 0)
+		const char* additive0_format = "Additive0";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* additive0_format_new = "additive0";
+		if (std::strncmp(format, additive0_format, std::strlen(additive0_format)) == 0
+			|| std::strncmp(format, additive0_format_new, std::strlen(additive0_format_new)) == 0)
 		{
-			out_format = AdditiveClipFormat8::Additive0;
+			out_format = additive_clip_format8::additive0;
 			return true;
 		}
 
-		const char* additive1_format = "Additive1";
-		if (std::strncmp(format, additive1_format, std::strlen(additive1_format)) == 0)
+		const char* additive1_format = "Additive1";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* additive1_format_new = "additive1";
+		if (std::strncmp(format, additive1_format, std::strlen(additive1_format)) == 0
+			|| std::strncmp(format, additive1_format_new, std::strlen(additive1_format_new)) == 0)
 		{
-			out_format = AdditiveClipFormat8::Additive1;
+			out_format = additive_clip_format8::additive1;
 			return true;
 		}
 
 		return false;
 	}
 
-	inline rtm::vector4f RTM_SIMD_CALL get_default_scale(AdditiveClipFormat8 additive_format)
+	inline rtm::vector4f RTM_SIMD_CALL get_default_scale(additive_clip_format8 additive_format)
 	{
-		return additive_format == AdditiveClipFormat8::Additive1 ? rtm::vector_zero() : rtm::vector_set(1.0F);
+		return additive_format == additive_clip_format8::additive1 ? rtm::vector_zero() : rtm::vector_set(1.0F);
 	}
 
 	inline rtm::qvvf RTM_SIMD_CALL transform_add0(rtm::qvvf_arg0 base, rtm::qvvf_arg1 additive)
@@ -135,27 +143,27 @@ namespace acl
 		return rtm::qvv_set(rotation, translation, rtm::vector_set(1.0F));
 	}
 
-	inline rtm::qvvf RTM_SIMD_CALL apply_additive_to_base(AdditiveClipFormat8 additive_format, rtm::qvvf_arg0 base, rtm::qvvf_arg1 additive)
+	inline rtm::qvvf RTM_SIMD_CALL apply_additive_to_base(additive_clip_format8 additive_format, rtm::qvvf_arg0 base, rtm::qvvf_arg1 additive)
 	{
 		switch (additive_format)
 		{
 		default:
-		case AdditiveClipFormat8::None:			return additive;
-		case AdditiveClipFormat8::Relative:		return rtm::qvv_mul(additive, base);
-		case AdditiveClipFormat8::Additive0:	return transform_add0(base, additive);
-		case AdditiveClipFormat8::Additive1:	return transform_add1(base, additive);
+		case additive_clip_format8::none:			return additive;
+		case additive_clip_format8::relative:		return rtm::qvv_mul(additive, base);
+		case additive_clip_format8::additive0:		return transform_add0(base, additive);
+		case additive_clip_format8::additive1:		return transform_add1(base, additive);
 		}
 	}
 
-	inline rtm::qvvf RTM_SIMD_CALL apply_additive_to_base_no_scale(AdditiveClipFormat8 additive_format, rtm::qvvf_arg0 base, rtm::qvvf_arg1 additive)
+	inline rtm::qvvf RTM_SIMD_CALL apply_additive_to_base_no_scale(additive_clip_format8 additive_format, rtm::qvvf_arg0 base, rtm::qvvf_arg1 additive)
 	{
 		switch (additive_format)
 		{
 		default:
-		case AdditiveClipFormat8::None:			return additive;
-		case AdditiveClipFormat8::Relative:		return rtm::qvv_mul_no_scale(additive, base);
-		case AdditiveClipFormat8::Additive0:	return transform_add_no_scale(base, additive);
-		case AdditiveClipFormat8::Additive1:	return transform_add_no_scale(base, additive);
+		case additive_clip_format8::none:			return additive;
+		case additive_clip_format8::relative:		return rtm::qvv_mul_no_scale(additive, base);
+		case additive_clip_format8::additive0:		return transform_add_no_scale(base, additive);
+		case additive_clip_format8::additive1:		return transform_add_no_scale(base, additive);
 		}
 	}
 
diff --git a/includes/acl/core/algorithm_types.h b/includes/acl/core/algorithm_types.h
--- a/includes/acl/core/algorithm_types.h
+++ b/includes/acl/core/algorithm_types.h
@@ -34,14 +34,14 @@ ACL_IMPL_FILE_PRAGMA_PUSH
 namespace acl
 {
 	////////////////////////////////////////////////////////////////////////////////
-	// AlgorithmType8 is an enum that represents every supported algorithm.
+	// algorithm_type8 is an enum that represents every supported algorithm.
 	//
 	// BE CAREFUL WHEN CHANGING VALUES IN THIS ENUM
 	// The algorithm type is serialized in the compressed data, if you change a value
 	// the compressed clips will be invalid. If you do, bump the appropriate algorithm versions.
-	enum class AlgorithmType8 : uint8_t
+	enum class algorithm_type8 : uint8_t
 	{
-		UniformlySampled			= 0,
+		uniformly_sampled				= 0,
 		//LinearKeyReduction			= 1,
 		//SplineKeyReduction			= 2,
 	};
@@ -52,13 +52,13 @@ namespace acl
 	// Returns true if the algorithm type is a valid value. Used to validate if
 	// memory has been corrupted.
 	// TODO: constexpr
-	inline bool is_valid_algorithm_type(AlgorithmType8 type)
+	inline bool is_valid_algorithm_type(algorithm_type8 type)
 	{
 		switch (type)
 		{
-			case AlgorithmType8::UniformlySampled:
-			//case AlgorithmType8::LinearKeyReduction:
-			//case AlgorithmType8::SplineKeyReduction:
+			case algorithm_type8::uniformly_sampled:
+			//case algorithm_type8::LinearKeyReduction:
+			//case algorithm_type8::SplineKeyReduction:
 				return true;
 			default:
 				return false;
@@ -68,13 +68,13 @@ namespace acl
 	////////////////////////////////////////////////////////////////////////////////
 	// Returns a string of the algorithm name suitable for display.
 	// TODO: constexpr
-	inline const char* get_algorithm_name(AlgorithmType8 type)
+	inline const char* get_algorithm_name(algorithm_type8 type)
 	{
 		switch (type)
 		{
-			case AlgorithmType8::UniformlySampled:		return "UniformlySampled";
-			//case AlgorithmType8::LinearKeyReduction:	return "LinearKeyReduction";
-			//case AlgorithmType8::SplineKeyReduction:	return "SplineKeyReduction";
+			case algorithm_type8::uniformly_sampled:	return "uniformly_sampled";
+			//case algorithm_type8::LinearKeyReduction:	return "LinearKeyReduction";
+			//case algorithm_type8::SplineKeyReduction:	return "SplineKeyReduction";
 			default:									return "<Invalid>";
 		}
 	}
@@ -84,12 +84,14 @@ namespace acl
 	//
 	// type: A string representing the algorithm name to parse. It must match the get_algorithm_name(..) output.
 	// out_type: On success, it will contain the the parsed algorithm type otherwise it is left untouched.
-	inline bool get_algorithm_type(const char* type, AlgorithmType8& out_type)
+	inline bool get_algorithm_type(const char* type, algorithm_type8& out_type)
 	{
-		const char* uniformly_sampled_name = "UniformlySampled";
-		if (std::strncmp(type, uniformly_sampled_name, std::strlen(uniformly_sampled_name)) == 0)
+		const char* uniformly_sampled_name = "UniformlySampled";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* uniformly_sampled_name_new = "uniformly_sampled";
+		if (std::strncmp(type, uniformly_sampled_name, std::strlen(uniformly_sampled_name)) == 0
+			|| std::strncmp(type, uniformly_sampled_name_new, std::strlen(uniformly_sampled_name_new)) == 0)
 		{
-			out_type = AlgorithmType8::UniformlySampled;
+			out_type = algorithm_type8::uniformly_sampled;
 			return true;
 		}
 
diff --git a/includes/acl/core/algorithm_versions.h b/includes/acl/core/algorithm_versions.h
--- a/includes/acl/core/algorithm_versions.h
+++ b/includes/acl/core/algorithm_versions.h
@@ -39,13 +39,13 @@ namespace acl
 	// still supported by the library or if it must be re-compressed. As such,
 	// changes to the binary format require incrementing the version number.
 	// TODO: constexpr
-	inline uint16_t get_algorithm_version(AlgorithmType8 type)
+	inline uint16_t get_algorithm_version(algorithm_type8 type)
 	{
 		switch (type)
 		{
-			case AlgorithmType8::UniformlySampled:		return 5;
-			//case AlgorithmType8::LinearKeyReduction:	return 0;
-			//case AlgorithmType8::SplineKeyReduction:	return 0;
+			case algorithm_type8::uniformly_sampled:	return 6;
+			//case algorithm_type8::LinearKeyReduction:	return 0;
+			//case algorithm_type8::SplineKeyReduction:	return 0;
 			default:									return 0xFFFF;
 		}
 	}
diff --git a/includes/acl/core/compressed_clip.h b/includes/acl/core/compressed_clip.h
--- a/includes/acl/core/compressed_clip.h
+++ b/includes/acl/core/compressed_clip.h
@@ -43,7 +43,7 @@ namespace acl
 
 	namespace acl_impl
 	{
-		CompressedClip* make_compressed_clip(void* buffer, uint32_t size, AlgorithmType8 type);
+		CompressedClip* make_compressed_clip(void* buffer, uint32_t size, algorithm_type8 type);
 		void finalize_compressed_clip(CompressedClip& compressed_clip);
 	}
 
@@ -56,7 +56,7 @@ namespace acl
 	public:
 		////////////////////////////////////////////////////////////////////////////////
 		// Returns the algorithm type used to compress the clip.
-		AlgorithmType8 get_algorithm_type() const { return m_type; }
+		algorithm_type8 get_algorithm_type() const { return m_type; }
 
 		////////////////////////////////////////////////////////////////////////////////
 		// Returns the size in bytes of the compressed clip.
@@ -107,7 +107,7 @@ namespace acl
 
 		////////////////////////////////////////////////////////////////////////////////
 		// Constructs a compressed clip instance
-		CompressedClip(uint32_t size, AlgorithmType8 type)
+		CompressedClip(uint32_t size, algorithm_type8 type)
 			: m_size(size)
 			, m_hash(hash32(safe_ptr_cast<const uint8_t>(this) + k_hash_skip_size, size - k_hash_skip_size))
 			, m_tag(k_compressed_clip_tag)
@@ -139,7 +139,7 @@ namespace acl
 		uint16_t		m_version;
 
 		// Algorithm type used to compress the clip.
-		AlgorithmType8	m_type;
+		algorithm_type8	m_type;
 
 		// Unused memory left as padding
 		uint8_t			m_padding;
@@ -147,7 +147,7 @@ namespace acl
 		////////////////////////////////////////////////////////////////////////////////
 		// Friend function used to construct compressed clip instances. Should only
 		// be called by encoders.
-		friend CompressedClip* acl_impl::make_compressed_clip(void* buffer, uint32_t size, AlgorithmType8 type);
+		friend CompressedClip* acl_impl::make_compressed_clip(void* buffer, uint32_t size, algorithm_type8 type);
 
 		////////////////////////////////////////////////////////////////////////////////
 		// Friend function to finalize a compressed clip once all memory has been written within.
@@ -189,13 +189,9 @@ namespace acl
 		uint16_t				num_segments;
 
 		// The rotation/translation/scale format used.
-		RotationFormat8			rotation_format;
-		VectorFormat8			translation_format;
-		VectorFormat8			scale_format;								// TODO: Make this optional?
-
-		// The clip/segment range reduction format used.
-		RangeReductionFlags8	clip_range_reduction;
-		RangeReductionFlags8	segment_range_reduction;
+		rotation_format8		rotation_format;
+		vector_format8			translation_format;
+		vector_format8			scale_format;								// TODO: Make this optional?
 
 		// Whether or not we have scale (bool).
 		uint8_t					has_scale;
@@ -203,7 +199,7 @@ namespace acl
 		// Whether the default scale is 0,0,0 or 1,1,1 (bool/bit).
 		uint8_t					default_scale;
 
-		uint8_t padding[1];
+		uint8_t padding[3];
 
 		// The total number of samples per track our clip contained.
 		uint32_t				num_samples;
diff --git a/includes/acl/core/compressed_tracks.h b/includes/acl/core/compressed_tracks.h
--- a/includes/acl/core/compressed_tracks.h
+++ b/includes/acl/core/compressed_tracks.h
@@ -59,7 +59,7 @@ namespace acl
 	public:
 		////////////////////////////////////////////////////////////////////////////////
 		// Returns the algorithm type used to compress the tracks.
-		AlgorithmType8 get_algorithm_type() const { return m_tracks_header.algorithm_type; }
+		algorithm_type8 get_algorithm_type() const { return m_tracks_header.algorithm_type; }
 
 		////////////////////////////////////////////////////////////////////////////////
 		// Returns the size in bytes of the compressed tracks.
diff --git a/includes/acl/core/impl/compressed_headers.h b/includes/acl/core/impl/compressed_headers.h
--- a/includes/acl/core/impl/compressed_headers.h
+++ b/includes/acl/core/impl/compressed_headers.h
@@ -60,7 +60,7 @@ namespace acl
 			uint16_t		version;
 
 			// Algorithm type used to compress the tracks.
-			AlgorithmType8	algorithm_type;
+			algorithm_type8	algorithm_type;
 
 			// Type of the tracks contained in this compressed stream.
 			track_type8		track_type;
diff --git a/includes/acl/core/interpolation_utils.h b/includes/acl/core/interpolation_utils.h
--- a/includes/acl/core/interpolation_utils.h
+++ b/includes/acl/core/interpolation_utils.h
@@ -38,28 +38,28 @@ namespace acl
 {
 	//////////////////////////////////////////////////////////////////////////
 	// This enum dictates how interpolation samples are calculated based on the sample time.
-	enum class SampleRoundingPolicy
+	enum class sample_rounding_policy
 	{
 		//////////////////////////////////////////////////////////////////////////
 		// If the sample time lies between two samples, both sample indices
 		// are returned and the interpolation alpha lies in between.
-		None,
+		none,
 
 		//////////////////////////////////////////////////////////////////////////
 		// If the sample time lies between two samples, both sample indices
 		// are returned and the interpolation will be 0.0.
-		Floor,
+		floor,
 
 		//////////////////////////////////////////////////////////////////////////
 		// If the sample time lies between two samples, both sample indices
 		// are returned and the interpolation will be 1.0.
-		Ceil,
+		ceil,
 
 		//////////////////////////////////////////////////////////////////////////
 		// If the sample time lies between two samples, both sample indices
 		// are returned and the interpolation will be 0.0 or 1.0 depending
 		// on which sample is nearest.
-		Nearest,
+		nearest,
 	};
 
 	//////////////////////////////////////////////////////////////////////////
@@ -68,7 +68,7 @@ namespace acl
 	// The returned sample indices are clamped and do not loop.
 	// If the sample rate is available, prefer using find_linear_interpolation_samples_with_sample_rate
 	// instead. It is faster and more accurate.
-	inline void find_linear_interpolation_samples_with_duration(uint32_t num_samples, float duration, float sample_time, SampleRoundingPolicy rounding_policy,
+	inline void find_linear_interpolation_samples_with_duration(uint32_t num_samples, float duration, float sample_time, sample_rounding_policy rounding_policy,
 		uint32_t& out_sample_index0, uint32_t& out_sample_index1, float& out_interpolation_alpha)
 	{
 		// Samples are evenly spaced, trivially calculate the indices that we need
@@ -93,16 +93,16 @@ namespace acl
 		switch (rounding_policy)
 		{
 		default:
-		case SampleRoundingPolicy::None:
+		case sample_rounding_policy::none:
 			out_interpolation_alpha = interpolation_alpha;
 			break;
-		case SampleRoundingPolicy::Floor:
+		case sample_rounding_policy::floor:
 			out_interpolation_alpha = 0.0F;
 			break;
-		case SampleRoundingPolicy::Ceil:
+		case sample_rounding_policy::ceil:
 			out_interpolation_alpha = 1.0F;
 			break;
-		case SampleRoundingPolicy::Nearest:
+		case sample_rounding_policy::nearest:
 			out_interpolation_alpha = rtm::scalar_floor(interpolation_alpha + 0.5F);
 			break;
 		}
@@ -112,7 +112,7 @@ namespace acl
 	// Calculates the sample indices and the interpolation required to linearly
 	// interpolate when the samples are uniform.
 	// The returned sample indices are clamped and do not loop.
-	inline void find_linear_interpolation_samples_with_sample_rate(uint32_t num_samples, float sample_rate, float sample_time, SampleRoundingPolicy rounding_policy,
+	inline void find_linear_interpolation_samples_with_sample_rate(uint32_t num_samples, float sample_rate, float sample_time, sample_rounding_policy rounding_policy,
 		uint32_t& out_sample_index0, uint32_t& out_sample_index1, float& out_interpolation_alpha)
 	{
 		// Samples are evenly spaced, trivially calculate the indices that we need
@@ -139,16 +139,16 @@ namespace acl
 		switch (rounding_policy)
 		{
 		default:
-		case SampleRoundingPolicy::None:
+		case sample_rounding_policy::none:
 			out_interpolation_alpha = interpolation_alpha;
 			break;
-		case SampleRoundingPolicy::Floor:
+		case sample_rounding_policy::floor:
 			out_interpolation_alpha = 0.0F;
 			break;
-		case SampleRoundingPolicy::Ceil:
+		case sample_rounding_policy::ceil:
 			out_interpolation_alpha = 1.0F;
 			break;
-		case SampleRoundingPolicy::Nearest:
+		case sample_rounding_policy::nearest:
 			out_interpolation_alpha = rtm::scalar_floor(interpolation_alpha + 0.5F);
 			break;
 		}
diff --git a/includes/acl/core/range_reduction_types.h b/includes/acl/core/range_reduction_types.h
--- a/includes/acl/core/range_reduction_types.h
+++ b/includes/acl/core/range_reduction_types.h
@@ -40,50 +40,50 @@ namespace acl
 	constexpr uint32_t k_clip_range_reduction_vector3_range_size = sizeof(float) * 6;
 
 	////////////////////////////////////////////////////////////////////////////////
-	// RangeReductionFlags8 represents the types of range reduction we support as a bit field.
+	// range_reduction_flags8 represents the types of range reduction we support as a bit field.
 	//
 	// BE CAREFUL WHEN CHANGING VALUES IN THIS ENUM
 	// The range reduction strategy is serialized in the compressed data, if you change a value
 	// the compressed clips will be invalid. If you do, bump the appropriate algorithm versions.
-	enum class RangeReductionFlags8 : uint8_t
+	enum class range_reduction_flags8 : uint8_t
 	{
-		None				= 0x00,
+		none				= 0x00,
 
 		// Flags to determine which tracks have range reduction applied
-		Rotations			= 0x01,
-		Translations		= 0x02,
-		Scales				= 0x04,
+		rotations			= 0x01,
+		translations		= 0x02,
+		scales				= 0x04,
 		//Properties		= 0x08,		// TODO: Implement this
 
-		AllTracks			= 0x07,
+		all_tracks			= 0x07,		// rotations | translations | scales
 	};
 
-	ACL_IMPL_ENUM_FLAGS_OPERATORS(RangeReductionFlags8)
+	ACL_IMPL_ENUM_FLAGS_OPERATORS(range_reduction_flags8)
 
 	//////////////////////////////////////////////////////////////////////////
 
 	////////////////////////////////////////////////////////////////////////////////
 	// Returns a string of the algorithm name suitable for display.
 	// TODO: constexpr
-	inline const char* get_range_reduction_name(RangeReductionFlags8 flags)
+	inline const char* get_range_reduction_name(range_reduction_flags8 flags)
 	{
 		// Some compilers have trouble with constexpr operator| with enums in a case switch statement
-		if (flags == RangeReductionFlags8::None)
-			return "RangeReduction::None";
-		else if (flags == RangeReductionFlags8::Rotations)
-			return "RangeReduction::Rotations";
-		else if (flags == RangeReductionFlags8::Translations)
-			return "RangeReduction::Translations";
-		else if (flags == RangeReductionFlags8::Scales)
-			return "RangeReduction::Scales";
-		else if (flags == (RangeReductionFlags8::Rotations | RangeReductionFlags8::Translations))
-			return "RangeReduction::Rotations | RangeReduction::Translations";
-		else if (flags == (RangeReductionFlags8::Rotations | RangeReductionFlags8::Scales))
-			return "RangeReduction::Rotations | RangeReduction::Scales";
-		else if (flags == (RangeReductionFlags8::Translations | RangeReductionFlags8::Scales))
-			return "RangeReduction::Translations | RangeReduction::Scales";
-		else if (flags == (RangeReductionFlags8::Rotations | RangeReductionFlags8::Translations | RangeReductionFlags8::Scales))
-			return "RangeReduction::Rotations | RangeReduction::Translations | RangeReduction::Scales";
+		if (flags == range_reduction_flags8::none)
+			return "range_reduction::none";
+		else if (flags == range_reduction_flags8::rotations)
+			return "range_reduction::rotations";
+		else if (flags == range_reduction_flags8::translations)
+			return "range_reduction::translations";
+		else if (flags == range_reduction_flags8::scales)
+			return "range_reduction::scales";
+		else if (flags == (range_reduction_flags8::rotations | range_reduction_flags8::translations))
+			return "range_reduction::rotations | range_reduction::translations";
+		else if (flags == (range_reduction_flags8::rotations | range_reduction_flags8::scales))
+			return "range_reduction::rotations | range_reduction::scales";
+		else if (flags == (range_reduction_flags8::translations | range_reduction_flags8::scales))
+			return "range_reduction::translations | range_reduction::scales";
+		else if (flags == (range_reduction_flags8::rotations | range_reduction_flags8::translations | range_reduction_flags8::scales))
+			return "range_reduction::rotations | range_reduction::translations | range_reduction::scales";
 		else
 			return "<Invalid>";
 	}
diff --git a/includes/acl/core/track_types.h b/includes/acl/core/track_types.h
--- a/includes/acl/core/track_types.h
+++ b/includes/acl/core/track_types.h
@@ -37,13 +37,17 @@ namespace acl
 	// BE CAREFUL WHEN CHANGING VALUES IN THIS ENUM
 	// The rotation format is serialized in the compressed data, if you change a value
 	// the compressed clips will be invalid. If you do, bump the appropriate algorithm versions.
-	enum class RotationFormat8 : uint8_t
+	enum class rotation_format8 : uint8_t
 	{
-		Quat_128					= 0,	// Full precision quaternion, [x,y,z,w] stored with float32
-		QuatDropW_96				= 1,	// Full precision quaternion, [x,y,z] stored with float32 (w is dropped)
-		QuatDropW_48				= 2,	// Quantized quaternion, [x,y,z] stored with [16,16,16] bits (w is dropped)
-		QuatDropW_32				= 3,	// Quantized quaternion, [x,y,z] stored with [11,11,10] bits (w is dropped)
-		QuatDropW_Variable			= 4,	// Quantized quaternion, [x,y,z] stored with [N,N,N] bits (w is dropped, same number of bits per component)
+		quatf_full					= 0,	// Full precision quaternion, [x,y,z,w] stored with float32
+		//quatf_variable			= 5,	// TODO Quantized quaternion, [x,y,z,w] stored with [N,N,N,N] bits (same number of bits per component)
+		quatf_drop_w_full			= 1,	// Full precision quaternion, [x,y,z] stored with float32 (w is dropped)
+		quatf_drop_w_variable		= 4,	// Quantized quaternion, [x,y,z] stored with [N,N,N] bits (w is dropped, same number of bits per component)
+
+		//quatf_optimal				= 100,	// Mix of quatf_variable and quatf_drop_w_variable
+
+		//reserved					= 2,	// Legacy value, no longer used
+		//reserved					= 3,	// Legacy value, no longer used
 		// TODO: Implement these
 		//Quat_32_Largest,		// Quantized quaternion, [?,?,?] stored with [10,10,10] bits (largest component is dropped, component index stored on 2 bits)
 		//QuatLog_96,			// Full precision quaternion logarithm, [x,y,z] stored with float 32
@@ -55,37 +59,38 @@ namespace acl
 	// BE CAREFUL WHEN CHANGING VALUES IN THIS ENUM
 	// The vector format is serialized in the compressed data, if you change a value
 	// the compressed clips will be invalid. If you do, bump the appropriate algorithm versions.
-	enum class VectorFormat8 : uint8_t
+	enum class vector_format8 : uint8_t
 	{
-		Vector3_96					= 0,	// Full precision vector3, [x,y,z] stored with float32
-		Vector3_48					= 1,	// Quantized vector3, [x,y,z] stored with [16,16,16] bits
-		Vector3_32					= 2,	// Quantized vector3, [x,y,z] stored with [11,11,10] bits
-		Vector3_Variable			= 3,	// Quantized vector3, [x,y,z] stored with [N,N,N] bits (same number of bits per component)
+		vector3f_full				= 0,	// Full precision vector3f, [x,y,z] stored with float32
+		vector3f_variable			= 3,	// Quantized vector3f, [x,y,z] stored with [N,N,N] bits (same number of bits per component)
+
+		//reserved					= 1,	// Legacy value, no longer used
+		//reserved					= 2,	// Legacy value, no longer used
 	};
 
-	union TrackFormat8
+	union track_format8
 	{
-		RotationFormat8 rotation;
-		VectorFormat8 vector;
+		rotation_format8 rotation;
+		vector_format8 vector;
 
-		TrackFormat8() {}
-		explicit TrackFormat8(RotationFormat8 format) : rotation(format) {}
-		explicit TrackFormat8(VectorFormat8 format) : vector(format) {}
+		track_format8() {}
+		explicit track_format8(rotation_format8 format) : rotation(format) {}
+		explicit track_format8(vector_format8 format) : vector(format) {}
 	};
 
-	enum class AnimationTrackType8 : uint8_t
+	enum class animation_track_type8 : uint8_t
 	{
-		Rotation,
-		Translation,
-		Scale,
+		rotation,
+		translation,
+		scale,
 	};
 
-	enum class RotationVariant8 : uint8_t
+	enum class rotation_variant8 : uint8_t
 	{
-		Quat,
-		QuatDropW,
-		//QuatDropLargest,
-		//QuatLog,
+		quat,
+		quat_drop_w,
+		//quat_drop_largest,
+		//quat_log,
 	};
 
 	//////////////////////////////////////////////////////////////////////////
@@ -226,10 +231,6 @@ namespace acl
 
 	static_assert(k_num_bit_rates == 19, "Expecting 19 bit rates");
 
-	// If all tracks are variable, no need for any extra padding except at the very end of the data
-	// If our tracks are mixed variable/not variable, we need to add some padding to ensure alignment
-	constexpr uint32_t k_mixed_packing_alignment_num_bits = 16;
-
 	inline uint32_t get_num_bits_at_bit_rate(uint8_t bit_rate)
 	{
 		ACL_ASSERT(bit_rate <= k_highest_bit_rate, "Invalid bit rate: %u", bit_rate);
@@ -250,53 +251,43 @@ namespace acl
 	//////////////////////////////////////////////////////////////////////////
 
 	// TODO: constexpr
-	inline const char* get_rotation_format_name(RotationFormat8 format)
+	inline const char* get_rotation_format_name(rotation_format8 format)
 	{
 		switch (format)
 		{
-		case RotationFormat8::Quat_128:				return "Quat_128";
-		case RotationFormat8::QuatDropW_96:			return "QuatDropW_96";
-		case RotationFormat8::QuatDropW_48:			return "QuatDropW_48";
-		case RotationFormat8::QuatDropW_32:			return "QuatDropW_32";
-		case RotationFormat8::QuatDropW_Variable:	return "QuatDropW_Variable";
-		default:									return "<Invalid>";
+		case rotation_format8::quatf_full:				return "quatf_full";
+		case rotation_format8::quatf_drop_w_full:		return "quatf_drop_w_full";
+		case rotation_format8::quatf_drop_w_variable:	return "quatf_drop_w_variable";
+		default:										return "<Invalid>";
 		}
 	}
 
-	inline bool get_rotation_format(const char* format, RotationFormat8& out_format)
+	inline bool get_rotation_format(const char* format, rotation_format8& out_format)
 	{
-		const char* quat_128_format = "Quat_128";
-		if (std::strncmp(format, quat_128_format, std::strlen(quat_128_format)) == 0)
+		const char* quat_128_format = "Quat_128";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* quatf_full_format = "quatf_full";
+		if (std::strncmp(format, quat_128_format, std::strlen(quat_128_format)) == 0
+			|| std::strncmp(format, quatf_full_format, std::strlen(quatf_full_format)) == 0)
 		{
-			out_format = RotationFormat8::Quat_128;
+			out_format = rotation_format8::quatf_full;
 			return true;
 		}
 
-		const char* quatdropw_96_format = "QuatDropW_96";
-		if (std::strncmp(format, quatdropw_96_format, std::strlen(quatdropw_96_format)) == 0)
+		const char* quatdropw_96_format = "QuatDropW_96";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* quatf_drop_w_full_format = "quatf_drop_w_full";
+		if (std::strncmp(format, quatdropw_96_format, std::strlen(quatdropw_96_format)) == 0
+			|| std::strncmp(format, quatf_drop_w_full_format, std::strlen(quatf_drop_w_full_format)) == 0)
 		{
-			out_format = RotationFormat8::QuatDropW_96;
+			out_format = rotation_format8::quatf_drop_w_full;
 			return true;
 		}
 
-		const char* quatdropw_48_format = "QuatDropW_48";
-		if (std::strncmp(format, quatdropw_48_format, std::strlen(quatdropw_48_format)) == 0)
+		const char* quatdropw_variable_format = "QuatDropW_Variable";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* quatf_drop_w_variable_format = "quatf_drop_w_variable";
+		if (std::strncmp(format, quatdropw_variable_format, std::strlen(quatdropw_variable_format)) == 0
+			|| std::strncmp(format, quatf_drop_w_variable_format, std::strlen(quatf_drop_w_variable_format)) == 0)
 		{
-			out_format = RotationFormat8::QuatDropW_48;
-			return true;
-		}
-
-		const char* quatdropw_32_format = "QuatDropW_32";
-		if (std::strncmp(format, quatdropw_32_format, std::strlen(quatdropw_32_format)) == 0)
-		{
-			out_format = RotationFormat8::QuatDropW_32;
-			return true;
-		}
-
-		const char* quatdropw_variable_format = "QuatDropW_Variable";
-		if (std::strncmp(format, quatdropw_variable_format, std::strlen(quatdropw_variable_format)) == 0)
-		{
-			out_format = RotationFormat8::QuatDropW_Variable;
+			out_format = rotation_format8::quatf_drop_w_variable;
 			return true;
 		}
 
@@ -304,45 +295,33 @@ namespace acl
 	}
 
 	// TODO: constexpr
-	inline const char* get_vector_format_name(VectorFormat8 format)
+	inline const char* get_vector_format_name(vector_format8 format)
 	{
 		switch (format)
 		{
-		case VectorFormat8::Vector3_96:			return "Vector3_96";
-		case VectorFormat8::Vector3_48:			return "Vector3_48";
-		case VectorFormat8::Vector3_32:			return "Vector3_32";
-		case VectorFormat8::Vector3_Variable:	return "Vector3_Variable";
-		default:								return "<Invalid>";
+		case vector_format8::vector3f_full:			return "vector3f_full";
+		case vector_format8::vector3f_variable:		return "vector3f_variable";
+		default:									return "<Invalid>";
 		}
 	}
 
-	inline bool get_vector_format(const char* format, VectorFormat8& out_format)
+	inline bool get_vector_format(const char* format, vector_format8& out_format)
 	{
-		const char* vector3_96_format = "Vector3_96";
-		if (std::strncmp(format, vector3_96_format, std::strlen(vector3_96_format)) == 0)
-		{
-			out_format = VectorFormat8::Vector3_96;
-			return true;
-		}
-
-		const char* vector3_48_format = "Vector3_48";
-		if (std::strncmp(format, vector3_48_format, std::strlen(vector3_48_format)) == 0)
-		{
-			out_format = VectorFormat8::Vector3_48;
-			return true;
-		}
-
-		const char* vector3_32_format = "Vector3_32";
-		if (std::strncmp(format, vector3_32_format, std::strlen(vector3_32_format)) == 0)
+		const char* vector3_96_format = "Vector3_96";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* vector3f_full_format = "vector3f_full";
+		if (std::strncmp(format, vector3_96_format, std::strlen(vector3_96_format)) == 0
+			|| std::strncmp(format, vector3f_full_format, std::strlen(vector3f_full_format)) == 0)
 		{
-			out_format = VectorFormat8::Vector3_32;
+			out_format = vector_format8::vector3f_full;
 			return true;
 		}
 
-		const char* vector3_variable_format = "Vector3_Variable";
-		if (std::strncmp(format, vector3_variable_format, std::strlen(vector3_variable_format)) == 0)
+		const char* vector3_variable_format = "Vector3_Variable";	// ACL_DEPRECATED Legacy name, keep for backwards compatibility, remove in 3.0
+		const char* vector3f_variable_format = "vector3f_variable";
+		if (std::strncmp(format, vector3_variable_format, std::strlen(vector3_variable_format)) == 0
+			|| std::strncmp(format, vector3f_variable_format, std::strlen(vector3f_variable_format)) == 0)
 		{
-			out_format = VectorFormat8::Vector3_Variable;
+			out_format = vector_format8::vector3f_variable;
 			return true;
 		}
 
@@ -350,70 +329,42 @@ namespace acl
 	}
 
 	// TODO: constexpr
-	inline RotationVariant8 get_rotation_variant(RotationFormat8 rotation_format)
+	inline rotation_variant8 get_rotation_variant(rotation_format8 rotation_format)
 	{
 		switch (rotation_format)
 		{
-		case RotationFormat8::Quat_128:
-			return RotationVariant8::Quat;
-		case RotationFormat8::QuatDropW_96:
-		case RotationFormat8::QuatDropW_48:
-		case RotationFormat8::QuatDropW_32:
-		case RotationFormat8::QuatDropW_Variable:
-			return RotationVariant8::QuatDropW;
+		case rotation_format8::quatf_full:
+			return rotation_variant8::quat;
+		case rotation_format8::quatf_drop_w_full:
+		case rotation_format8::quatf_drop_w_variable:
+			return rotation_variant8::quat_drop_w;
 		default:
 			ACL_ASSERT(false, "Invalid or unsupported rotation format: %s", get_rotation_format_name(rotation_format));
-			return RotationVariant8::Quat;
+			return rotation_variant8::quat;
 		}
 	}
 
 	// TODO: constexpr
-	inline RotationFormat8 get_lowest_variant_precision(RotationVariant8 variant)
+	inline rotation_format8 get_highest_variant_precision(rotation_variant8 variant)
 	{
 		switch (variant)
 		{
-		case RotationVariant8::Quat:			return RotationFormat8::Quat_128;
-		case RotationVariant8::QuatDropW:		return RotationFormat8::QuatDropW_32;
+		case rotation_variant8::quat:				return rotation_format8::quatf_full;
+		case rotation_variant8::quat_drop_w:		return rotation_format8::quatf_drop_w_full;
 		default:
 			ACL_ASSERT(false, "Invalid or unsupported rotation format: %u", (uint32_t)variant);
-			return RotationFormat8::Quat_128;
+			return rotation_format8::quatf_full;
 		}
 	}
 
-	// TODO: constexpr
-	inline RotationFormat8 get_highest_variant_precision(RotationVariant8 variant)
+	constexpr bool is_rotation_format_variable(rotation_format8 rotation_format)
 	{
-		switch (variant)
-		{
-		case RotationVariant8::Quat:			return RotationFormat8::Quat_128;
-		case RotationVariant8::QuatDropW:		return RotationFormat8::QuatDropW_96;
-		default:
-			ACL_ASSERT(false, "Invalid or unsupported rotation format: %u", (uint32_t)variant);
-			return RotationFormat8::Quat_128;
-		}
-	}
-
-	// TODO: constexpr
-	inline bool is_rotation_format_variable(RotationFormat8 rotation_format)
-	{
-		switch (rotation_format)
-		{
-		case RotationFormat8::Quat_128:
-		case RotationFormat8::QuatDropW_96:
-		case RotationFormat8::QuatDropW_48:
-		case RotationFormat8::QuatDropW_32:
-			return false;
-		case RotationFormat8::QuatDropW_Variable:
-			return true;
-		default:
-			ACL_ASSERT(false, "Invalid or unsupported rotation format: %s", get_rotation_format_name(rotation_format));
-			return false;
-		}
+		return rotation_format == rotation_format8::quatf_drop_w_variable;
 	}
 
-	constexpr bool is_vector_format_variable(VectorFormat8 format)
+	constexpr bool is_vector_format_variable(vector_format8 format)
 	{
-		return format == VectorFormat8::Vector3_Variable;
+		return format == vector_format8::vector3f_variable;
 	}
 
 	//////////////////////////////////////////////////////////////////////////
diff --git a/includes/acl/decompression/decompress.h b/includes/acl/decompression/decompress.h
--- a/includes/acl/decompression/decompress.h
+++ b/includes/acl/decompression/decompress.h
@@ -131,7 +131,7 @@ namespace acl
 		//////////////////////////////////////////////////////////////////////////
 		// Seeks within the compressed tracks to a particular point in time with the
 		// desired rounding policy.
-		void seek(float sample_time, SampleRoundingPolicy rounding_policy);
+		void seek(float sample_time, sample_rounding_policy rounding_policy);
 
 		//////////////////////////////////////////////////////////////////////////
 		// Decompress every track at the current sample time.
@@ -212,7 +212,7 @@ namespace acl
 	inline void decompression_context<decompression_settings_type>::initialize(const compressed_tracks& tracks)
 	{
 		ACL_ASSERT(tracks.is_valid(false).empty(), "Compressed tracks are not valid");
-		ACL_ASSERT(tracks.get_algorithm_type() == AlgorithmType8::UniformlySampled, "Invalid algorithm type [%s], expected [%s]", get_algorithm_name(tracks.get_algorithm_type()), get_algorithm_name(AlgorithmType8::UniformlySampled));
+		ACL_ASSERT(tracks.get_algorithm_type() == algorithm_type8::uniformly_sampled, "Invalid algorithm type [%s], expected [%s]", get_algorithm_name(tracks.get_algorithm_type()), get_algorithm_name(algorithm_type8::uniformly_sampled));
 
 		m_context.tracks = &tracks;
 		m_context.tracks_hash = tracks.get_hash();
@@ -234,7 +234,7 @@ namespace acl
 	}
 
 	template<class decompression_settings_type>
-	inline void decompression_context<decompression_settings_type>::seek(float sample_time, SampleRoundingPolicy rounding_policy)
+	inline void decompression_context<decompression_settings_type>::seek(float sample_time, sample_rounding_policy rounding_policy)
 	{
 		ACL_ASSERT(m_context.is_initialized(), "Context is not initialized");
 		ACL_ASSERT(rtm::scalar_is_finite(sample_time), "Invalid sample time");
diff --git a/includes/acl/decompression/impl/decompress_data.h b/includes/acl/decompression/impl/decompress_data.h
--- a/includes/acl/decompression/impl/decompress_data.h
+++ b/includes/acl/decompression/impl/decompress_data.h
@@ -44,12 +44,12 @@ namespace acl
 			const bool is_sample_default = bitset_test(decomp_context.default_tracks_bitset, track_index_bit_ref);
 			if (!is_sample_default)
 			{
-				const RotationFormat8 rotation_format = settings.get_rotation_format(header.rotation_format);
+				const rotation_format8 rotation_format = settings.get_rotation_format(header.rotation_format);
 
 				const bool is_sample_constant = bitset_test(decomp_context.constant_tracks_bitset, track_index_bit_ref);
 				if (is_sample_constant)
 				{
-					const RotationFormat8 packed_format = is_rotation_format_variable(rotation_format) ? get_highest_variant_precision(get_rotation_variant(rotation_format)) : rotation_format;
+					const rotation_format8 packed_format = is_rotation_format_variable(rotation_format) ? get_highest_variant_precision(get_rotation_variant(rotation_format)) : rotation_format;
 					sampling_context.constant_track_data_offset += get_packed_rotation_size(packed_format);
 				}
 				else
@@ -61,15 +61,9 @@ namespace acl
 						for (size_t i = 0; i < num_key_frames; ++i)
 						{
 							const uint8_t bit_rate = decomp_context.format_per_track_data[i][sampling_context.format_per_track_data_offset];
-							uint32_t num_bits_at_bit_rate = get_num_bits_at_bit_rate(bit_rate) * 3;	// 3 components
-
-							if (settings.supports_mixed_packing() && decomp_context.has_mixed_packing)
-								num_bits_at_bit_rate = align_to(num_bits_at_bit_rate, k_mixed_packing_alignment_num_bits);
+							const uint32_t num_bits_at_bit_rate = get_num_bits_at_bit_rate(bit_rate) * 3;	// 3 components
 
 							sampling_context.key_frame_bit_offsets[i] += num_bits_at_bit_rate;
-
-							if (settings.supports_mixed_packing() && decomp_context.has_mixed_packing)
-								sampling_context.key_frame_byte_offsets[i] = decomp_context.key_frame_bit_offsets[i] / 8;
 						}
 
 						sampling_context.format_per_track_data_offset++;
@@ -77,23 +71,19 @@ namespace acl
 					else
 					{
 						const uint32_t rotation_size = get_packed_rotation_size(rotation_format);
+						const uint32_t num_bits_at_bit_rate = rotation_size == (sizeof(float) * 4) ? 128 : 96;
 
 						for (size_t i = 0; i < num_key_frames; ++i)
-						{
-							sampling_context.key_frame_byte_offsets[i] += rotation_size;
-
-							if (settings.supports_mixed_packing() && decomp_context.has_mixed_packing)
-								sampling_context.key_frame_bit_offsets[i] = sampling_context.key_frame_byte_offsets[i] * 8;
-						}
+							sampling_context.key_frame_bit_offsets[i] += num_bits_at_bit_rate;
 					}
 
-					const RangeReductionFlags8 clip_range_reduction = settings.get_clip_range_reduction(header.clip_range_reduction);
-					if (are_any_enum_flags_set(clip_range_reduction, RangeReductionFlags8::Rotations))
+					if (are_any_enum_flags_set(decomp_context.range_reduction, range_reduction_flags8::rotations) && settings.are_range_reduction_flags_supported(range_reduction_flags8::rotations))
+					{
 						sampling_context.clip_range_data_offset += decomp_context.num_rotation_components * sizeof(float) * 2;
 
-					const RangeReductionFlags8 segment_range_reduction = settings.get_segment_range_reduction(header.segment_range_reduction);
-					if (are_any_enum_flags_set(segment_range_reduction, RangeReductionFlags8::Rotations))
-						sampling_context.segment_range_data_offset += decomp_context.num_rotation_components * k_segment_range_reduction_num_bytes_per_component * 2;
+						if (header.num_segments > 1)
+							sampling_context.segment_range_data_offset += decomp_context.num_rotation_components * k_segment_range_reduction_num_bytes_per_component * 2;
+					}
 				}
 			}
 
@@ -111,53 +101,40 @@ namespace acl
 				if (is_sample_constant)
 				{
 					// Constant Vector3 tracks store the remaining sample with full precision
-					sampling_context.constant_track_data_offset += get_packed_vector_size(VectorFormat8::Vector3_96);
+					sampling_context.constant_track_data_offset += get_packed_vector_size(vector_format8::vector3f_full);
 				}
 				else
 				{
 					constexpr size_t num_key_frames = SamplingContextType::k_num_samples_to_interpolate;
-					const VectorFormat8 format = settings.get_vector_format(header);
+					const vector_format8 format = settings.get_vector_format(header);
 
 					if (is_vector_format_variable(format))
 					{
 						for (size_t i = 0; i < num_key_frames; ++i)
 						{
 							const uint8_t bit_rate = decomp_context.format_per_track_data[i][sampling_context.format_per_track_data_offset];
-							uint32_t num_bits_at_bit_rate = get_num_bits_at_bit_rate(bit_rate) * 3;	// 3 components
-
-							if (settings.supports_mixed_packing() && decomp_context.has_mixed_packing)
-								num_bits_at_bit_rate = align_to(num_bits_at_bit_rate, k_mixed_packing_alignment_num_bits);
+							const uint32_t num_bits_at_bit_rate = get_num_bits_at_bit_rate(bit_rate) * 3;	// 3 components
 
 							sampling_context.key_frame_bit_offsets[i] += num_bits_at_bit_rate;
-
-							if (settings.supports_mixed_packing() && decomp_context.has_mixed_packing)
-								sampling_context.key_frame_byte_offsets[i] = sampling_context.key_frame_bit_offsets[i] / 8;
 						}
 
 						sampling_context.format_per_track_data_offset++;
 					}
 					else
 					{
-						const uint32_t sample_size = get_packed_vector_size(format);
-
 						for (size_t i = 0; i < num_key_frames; ++i)
-						{
-							sampling_context.key_frame_byte_offsets[i] += sample_size;
-
-							if (settings.supports_mixed_packing() && decomp_context.has_mixed_packing)
-								sampling_context.key_frame_bit_offsets[i] = sampling_context.key_frame_byte_offsets[i] * 8;
-						}
+							sampling_context.key_frame_bit_offsets[i] += 96;
 					}
 
-					const RangeReductionFlags8 range_reduction_flag = settings.get_range_reduction_flag();
+					const range_reduction_flags8 range_reduction_flag = settings.get_range_reduction_flag();
 
-					const RangeReductionFlags8 clip_range_reduction = settings.get_clip_range_reduction(header.clip_range_reduction);
-					if (are_any_enum_flags_set(clip_range_reduction, range_reduction_flag))
+					if (are_any_enum_flags_set(decomp_context.range_reduction, range_reduction_flag) && settings.are_range_reduction_flags_supported(range_reduction_flag))
+					{
 						sampling_context.clip_range_data_offset += k_clip_range_reduction_vector3_range_size;
 
-					const RangeReductionFlags8 segment_range_reduction = settings.get_segment_range_reduction(header.segment_range_reduction);
-					if (are_any_enum_flags_set(segment_range_reduction, range_reduction_flag))
-						sampling_context.segment_range_data_offset += 3 * k_segment_range_reduction_num_bytes_per_component * 2;
+						if (header.num_segments > 1)
+							sampling_context.segment_range_data_offset += 3 * k_segment_range_reduction_num_bytes_per_component * 2;
+					}
 				}
 			}
 
@@ -179,19 +156,15 @@ namespace acl
 			}
 			else
 			{
-				const RotationFormat8 rotation_format = settings.get_rotation_format(header.rotation_format);
+				const rotation_format8 rotation_format = settings.get_rotation_format(header.rotation_format);
 				const bool is_sample_constant = bitset_test(decomp_context.constant_tracks_bitset, track_index_bit_ref);
 				if (is_sample_constant)
 				{
-					if (rotation_format == RotationFormat8::Quat_128 && settings.is_rotation_format_supported(RotationFormat8::Quat_128))
+					if (rotation_format == rotation_format8::quatf_full && settings.is_rotation_format_supported(rotation_format8::quatf_full))
 						interpolated_rotation = unpack_quat_128(decomp_context.constant_track_data + sampling_context.constant_track_data_offset);
-					else if (rotation_format == RotationFormat8::QuatDropW_96 && settings.is_rotation_format_supported(RotationFormat8::QuatDropW_96))
+					else if (rotation_format == rotation_format8::quatf_drop_w_full && settings.is_rotation_format_supported(rotation_format8::quatf_drop_w_full))
 						interpolated_rotation = unpack_quat_96_unsafe(decomp_context.constant_track_data + sampling_context.constant_track_data_offset);
-					else if (rotation_format == RotationFormat8::QuatDropW_48 && settings.is_rotation_format_supported(RotationFormat8::QuatDropW_48))
-						interpolated_rotation = unpack_quat_48(decomp_context.constant_track_data + sampling_context.constant_track_data_offset);
-					else if (rotation_format == RotationFormat8::QuatDropW_32 && settings.is_rotation_format_supported(RotationFormat8::QuatDropW_32))
-						interpolated_rotation = unpack_quat_32(decomp_context.constant_track_data + sampling_context.constant_track_data_offset);
-					else if (rotation_format == RotationFormat8::QuatDropW_Variable && settings.is_rotation_format_supported(RotationFormat8::QuatDropW_Variable))
+					else if (rotation_format == rotation_format8::quatf_drop_w_variable && settings.is_rotation_format_supported(rotation_format8::quatf_drop_w_variable))
 						interpolated_rotation = unpack_quat_96_unsafe(decomp_context.constant_track_data + sampling_context.constant_track_data_offset);
 					else
 					{
@@ -202,16 +175,11 @@ namespace acl
 					ACL_ASSERT(rtm::quat_is_finite(interpolated_rotation), "Rotation is not valid!");
 					ACL_ASSERT(rtm::quat_is_normalized(interpolated_rotation), "Rotation is not normalized!");
 
-					const RotationFormat8 packed_format = is_rotation_format_variable(rotation_format) ? get_highest_variant_precision(get_rotation_variant(rotation_format)) : rotation_format;
+					const rotation_format8 packed_format = is_rotation_format_variable(rotation_format) ? get_highest_variant_precision(get_rotation_variant(rotation_format)) : rotation_format;
 					sampling_context.constant_track_data_offset += get_packed_rotation_size(packed_format);
 				}
 				else
 				{
-					const RangeReductionFlags8 clip_range_reduction = settings.get_clip_range_reduction(header.clip_range_reduction);
-					const RangeReductionFlags8 segment_range_reduction = settings.get_segment_range_reduction(header.segment_range_reduction);
-					const bool are_clip_rotations_normalized = are_any_enum_flags_set(clip_range_reduction, RangeReductionFlags8::Rotations);
-					const bool are_segment_rotations_normalized = are_any_enum_flags_set(segment_range_reduction, RangeReductionFlags8::Rotations);
-
 					constexpr size_t num_key_frames = SamplingContextType::k_num_samples_to_interpolate;
 
 					// This part is fairly complex, we'll loop and write to the stack (sampling context)
@@ -222,15 +190,13 @@ namespace acl
 					// By default, we never ignore range reduction
 					uint32_t range_ignore_flags = 0;
 
-					if (rotation_format == RotationFormat8::QuatDropW_Variable && settings.is_rotation_format_supported(RotationFormat8::QuatDropW_Variable))
+					if (rotation_format == rotation_format8::quatf_drop_w_variable && settings.is_rotation_format_supported(rotation_format8::quatf_drop_w_variable))
 					{
 						for (size_t i = 0; i < num_key_frames; ++i)
 						{
 							range_ignore_flags <<= 2;
 
 							const uint8_t bit_rate = decomp_context.format_per_track_data[i][sampling_context.format_per_track_data_offset];
-
-							// Promote to 32bit to avoid zero extending instructions on x64
 							const uint32_t num_bits_at_bit_rate = get_num_bits_at_bit_rate(bit_rate);
 
 							if (is_constant_bit_rate(bit_rate))
@@ -244,62 +210,30 @@ namespace acl
 								range_ignore_flags |= 0x00000003U;	// Skip clip and segment
 							}
 							else
-							{
-								if (are_clip_rotations_normalized)
-									rotations_as_vec[i] = unpack_vector3_uXX_unsafe(uint8_t(num_bits_at_bit_rate), decomp_context.animated_track_data[i], sampling_context.key_frame_bit_offsets[i]);
-								else
-									rotations_as_vec[i] = unpack_vector3_sXX_unsafe(uint8_t(num_bits_at_bit_rate), decomp_context.animated_track_data[i], sampling_context.key_frame_bit_offsets[i]);
-							}
-
-							uint32_t num_bits_read = num_bits_at_bit_rate * 3;
+								rotations_as_vec[i] = unpack_vector3_uXX_unsafe(uint8_t(num_bits_at_bit_rate), decomp_context.animated_track_data[i], sampling_context.key_frame_bit_offsets[i]);
 
-							if (settings.supports_mixed_packing() && decomp_context.has_mixed_packing)
-								num_bits_read = align_to(num_bits_read, k_mixed_packing_alignment_num_bits);
-
-							sampling_context.key_frame_bit_offsets[i] += num_bits_read;
-
-							if (settings.supports_mixed_packing() && decomp_context.has_mixed_packing)
-								sampling_context.key_frame_byte_offsets[i] = sampling_context.key_frame_bit_offsets[i] / 8;
+							sampling_context.key_frame_bit_offsets[i] += num_bits_at_bit_rate * 3;
 						}
 
 						sampling_context.format_per_track_data_offset++;
 					}
 					else
 					{
-						if (rotation_format == RotationFormat8::Quat_128 && settings.is_rotation_format_supported(RotationFormat8::Quat_128))
-						{
-							for (size_t i = 0; i < num_key_frames; ++i)
-								rotations_as_vec[i] = unpack_vector4_128(decomp_context.animated_track_data[i] + sampling_context.key_frame_byte_offsets[i]);
-						}
-						else if (rotation_format == RotationFormat8::QuatDropW_96 && settings.is_rotation_format_supported(RotationFormat8::QuatDropW_96))
-						{
-							for (size_t i = 0; i < num_key_frames; ++i)
-								rotations_as_vec[i] = unpack_vector3_96_unsafe(decomp_context.animated_track_data[i] + sampling_context.key_frame_byte_offsets[i]);
-						}
-						else if (rotation_format == RotationFormat8::QuatDropW_48 && settings.is_rotation_format_supported(RotationFormat8::QuatDropW_48))
+						if (rotation_format == rotation_format8::quatf_full && settings.is_rotation_format_supported(rotation_format8::quatf_full))
 						{
 							for (size_t i = 0; i < num_key_frames; ++i)
 							{
-								if (are_clip_rotations_normalized)
-									rotations_as_vec[i] = unpack_vector3_u48_unsafe(decomp_context.animated_track_data[i] + sampling_context.key_frame_byte_offsets[i]);
-								else
-									rotations_as_vec[i] = unpack_vector3_s48_unsafe(decomp_context.animated_track_data[i] + sampling_context.key_frame_byte_offsets[i]);
+								rotations_as_vec[i] = unpack_vector4_128_unsafe(decomp_context.animated_track_data[i], sampling_context.key_frame_bit_offsets[i]);
+								sampling_context.key_frame_bit_offsets[i] += 128;
 							}
 						}
-						else if (rotation_format == RotationFormat8::QuatDropW_32 && settings.is_rotation_format_supported(RotationFormat8::QuatDropW_32))
+						else if (rotation_format == rotation_format8::quatf_drop_w_full && settings.is_rotation_format_supported(rotation_format8::quatf_drop_w_full))
 						{
 							for (size_t i = 0; i < num_key_frames; ++i)
-								rotations_as_vec[i] = unpack_vector3_32(11, 11, 10, are_clip_rotations_normalized, decomp_context.animated_track_data[i] + sampling_context.key_frame_byte_offsets[i]);
-						}
-
-						const uint32_t rotation_size = get_packed_rotation_size(rotation_format);
-
-						for (size_t i = 0; i < num_key_frames; ++i)
-						{
-							sampling_context.key_frame_byte_offsets[i] += rotation_size;
-
-							if (settings.supports_mixed_packing() && decomp_context.has_mixed_packing)
-								sampling_context.key_frame_bit_offsets[i] = sampling_context.key_frame_byte_offsets[i] * 8;
+							{
+								rotations_as_vec[i] = unpack_vector3_96_unsafe(decomp_context.animated_track_data[i], sampling_context.key_frame_bit_offsets[i]);
+								sampling_context.key_frame_bit_offsets[i] += 96;
+							}
 						}
 					}
 
@@ -325,79 +259,46 @@ namespace acl
 
 					const uint32_t num_rotation_components = decomp_context.num_rotation_components;
 
-					if (are_segment_rotations_normalized)
+					if (are_any_enum_flags_set(decomp_context.range_reduction, range_reduction_flags8::rotations) && settings.are_range_reduction_flags_supported(range_reduction_flags8::rotations))
 					{
-						const uint32_t segment_range_min_offset = sampling_context.segment_range_data_offset;
-						const uint32_t segment_range_extent_offset = sampling_context.segment_range_data_offset + (num_rotation_components * sizeof(uint8_t));
-
-						if (rotation_format == RotationFormat8::QuatDropW_Variable && settings.is_rotation_format_supported(RotationFormat8::QuatDropW_Variable))
+						if (header.num_segments > 1)
 						{
-							constexpr uint32_t ignore_mask = 0x00000001U << ((num_key_frames - 1) * 2);
-							if ((range_ignore_flags & (ignore_mask >> 0)) == 0)
-							{
-								const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[0] + segment_range_min_offset);
-								const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[0] + segment_range_extent_offset);
-
-								rotation_as_vec0 = rtm::vector_mul_add(rotation_as_vec0, segment_range_extent, segment_range_min);
-							}
-
-							if ((range_ignore_flags & (ignore_mask >> 2)) == 0)
-							{
-								const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[1] + segment_range_min_offset);
-								const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[1] + segment_range_extent_offset);
-
-								rotation_as_vec1 = rtm::vector_mul_add(rotation_as_vec1, segment_range_extent, segment_range_min);
-							}
-
-							if (static_condition<num_key_frames == 4>::test())
-							{
-								if ((range_ignore_flags & (ignore_mask >> 4)) == 0)
-								{
-									const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[2] + segment_range_min_offset);
-									const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[2] + segment_range_extent_offset);
-
-									rotation_as_vec2 = rtm::vector_mul_add(rotation_as_vec2, segment_range_extent, segment_range_min);
-								}
-
-								if ((range_ignore_flags & (ignore_mask >> 8)) == 0)
-								{
-									const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[3] + segment_range_min_offset);
-									const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[3] + segment_range_extent_offset);
+							const uint32_t segment_range_min_offset = sampling_context.segment_range_data_offset;
+							const uint32_t segment_range_extent_offset = sampling_context.segment_range_data_offset + (num_rotation_components * sizeof(uint8_t));
 
-									rotation_as_vec3 = rtm::vector_mul_add(rotation_as_vec3, segment_range_extent, segment_range_min);
-								}
-							}
-						}
-						else
-						{
-							if (rotation_format == RotationFormat8::Quat_128 && settings.is_rotation_format_supported(RotationFormat8::Quat_128))
+							if (rotation_format == rotation_format8::quatf_drop_w_variable && settings.is_rotation_format_supported(rotation_format8::quatf_drop_w_variable))
 							{
+								constexpr uint32_t ignore_mask = 0x00000001U << ((num_key_frames - 1) * 2);
+								if ((range_ignore_flags & (ignore_mask >> 0)) == 0)
 								{
-									const rtm::vector4f segment_range_min = unpack_vector4_32(decomp_context.segment_range_data[0] + segment_range_min_offset, true);
-									const rtm::vector4f segment_range_extent = unpack_vector4_32(decomp_context.segment_range_data[0] + segment_range_extent_offset, true);
+									const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[0] + segment_range_min_offset);
+									const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[0] + segment_range_extent_offset);
 
 									rotation_as_vec0 = rtm::vector_mul_add(rotation_as_vec0, segment_range_extent, segment_range_min);
 								}
 
+								if ((range_ignore_flags & (ignore_mask >> 2)) == 0)
 								{
-									const rtm::vector4f segment_range_min = unpack_vector4_32(decomp_context.segment_range_data[1] + segment_range_min_offset, true);
-									const rtm::vector4f segment_range_extent = unpack_vector4_32(decomp_context.segment_range_data[1] + segment_range_extent_offset, true);
+									const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[1] + segment_range_min_offset);
+									const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[1] + segment_range_extent_offset);
 
 									rotation_as_vec1 = rtm::vector_mul_add(rotation_as_vec1, segment_range_extent, segment_range_min);
 								}
 
 								if (static_condition<num_key_frames == 4>::test())
 								{
+									if ((range_ignore_flags & (ignore_mask >> 4)) == 0)
 									{
-										const rtm::vector4f segment_range_min = unpack_vector4_32(decomp_context.segment_range_data[2] + segment_range_min_offset, true);
-										const rtm::vector4f segment_range_extent = unpack_vector4_32(decomp_context.segment_range_data[2] + segment_range_extent_offset, true);
+										const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[2] + segment_range_min_offset);
+										const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[2] + segment_range_extent_offset);
 
 										rotation_as_vec2 = rtm::vector_mul_add(rotation_as_vec2, segment_range_extent, segment_range_min);
 									}
 
+									if ((range_ignore_flags & (ignore_mask >> 8)) == 0)
 									{
-										const rtm::vector4f segment_range_min = unpack_vector4_32(decomp_context.segment_range_data[3] + segment_range_min_offset, true);
-										const rtm::vector4f segment_range_extent = unpack_vector4_32(decomp_context.segment_range_data[3] + segment_range_extent_offset, true);
+										const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[3] + segment_range_min_offset);
+										const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[3] + segment_range_extent_offset);
 
 										rotation_as_vec3 = rtm::vector_mul_add(rotation_as_vec3, segment_range_extent, segment_range_min);
 									}
@@ -405,44 +306,77 @@ namespace acl
 							}
 							else
 							{
+								if (rotation_format == rotation_format8::quatf_full && settings.is_rotation_format_supported(rotation_format8::quatf_full))
 								{
-									const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[0] + segment_range_min_offset);
-									const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[0] + segment_range_extent_offset);
+									{
+										const rtm::vector4f segment_range_min = unpack_vector4_32(decomp_context.segment_range_data[0] + segment_range_min_offset, true);
+										const rtm::vector4f segment_range_extent = unpack_vector4_32(decomp_context.segment_range_data[0] + segment_range_extent_offset, true);
 
-									rotation_as_vec0 = rtm::vector_mul_add(rotation_as_vec0, segment_range_extent, segment_range_min);
-								}
+										rotation_as_vec0 = rtm::vector_mul_add(rotation_as_vec0, segment_range_extent, segment_range_min);
+									}
 
-								{
-									const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[1] + segment_range_min_offset);
-									const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[1] + segment_range_extent_offset);
+									{
+										const rtm::vector4f segment_range_min = unpack_vector4_32(decomp_context.segment_range_data[1] + segment_range_min_offset, true);
+										const rtm::vector4f segment_range_extent = unpack_vector4_32(decomp_context.segment_range_data[1] + segment_range_extent_offset, true);
 
-									rotation_as_vec1 = rtm::vector_mul_add(rotation_as_vec1, segment_range_extent, segment_range_min);
-								}
+										rotation_as_vec1 = rtm::vector_mul_add(rotation_as_vec1, segment_range_extent, segment_range_min);
+									}
 
-								if (static_condition<num_key_frames == 4>::test())
+									if (static_condition<num_key_frames == 4>::test())
+									{
+										{
+											const rtm::vector4f segment_range_min = unpack_vector4_32(decomp_context.segment_range_data[2] + segment_range_min_offset, true);
+											const rtm::vector4f segment_range_extent = unpack_vector4_32(decomp_context.segment_range_data[2] + segment_range_extent_offset, true);
+
+											rotation_as_vec2 = rtm::vector_mul_add(rotation_as_vec2, segment_range_extent, segment_range_min);
+										}
+
+										{
+											const rtm::vector4f segment_range_min = unpack_vector4_32(decomp_context.segment_range_data[3] + segment_range_min_offset, true);
+											const rtm::vector4f segment_range_extent = unpack_vector4_32(decomp_context.segment_range_data[3] + segment_range_extent_offset, true);
+
+											rotation_as_vec3 = rtm::vector_mul_add(rotation_as_vec3, segment_range_extent, segment_range_min);
+										}
+									}
+								}
+								else
 								{
 									{
-										const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[2] + segment_range_min_offset);
-										const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[2] + segment_range_extent_offset);
+										const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[0] + segment_range_min_offset);
+										const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[0] + segment_range_extent_offset);
 
-										rotation_as_vec2 = rtm::vector_mul_add(rotation_as_vec2, segment_range_extent, segment_range_min);
+										rotation_as_vec0 = rtm::vector_mul_add(rotation_as_vec0, segment_range_extent, segment_range_min);
 									}
 
 									{
-										const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[3] + segment_range_min_offset);
-										const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[3] + segment_range_extent_offset);
+										const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[1] + segment_range_min_offset);
+										const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[1] + segment_range_extent_offset);
 
-										rotation_as_vec3 = rtm::vector_mul_add(rotation_as_vec3, segment_range_extent, segment_range_min);
+										rotation_as_vec1 = rtm::vector_mul_add(rotation_as_vec1, segment_range_extent, segment_range_min);
+									}
+
+									if (static_condition<num_key_frames == 4>::test())
+									{
+										{
+											const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[2] + segment_range_min_offset);
+											const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[2] + segment_range_extent_offset);
+
+											rotation_as_vec2 = rtm::vector_mul_add(rotation_as_vec2, segment_range_extent, segment_range_min);
+										}
+
+										{
+											const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[3] + segment_range_min_offset);
+											const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[3] + segment_range_extent_offset);
+
+											rotation_as_vec3 = rtm::vector_mul_add(rotation_as_vec3, segment_range_extent, segment_range_min);
+										}
 									}
 								}
 							}
-						}
 
-						sampling_context.segment_range_data_offset += num_rotation_components * k_segment_range_reduction_num_bytes_per_component * 2;
-					}
+							sampling_context.segment_range_data_offset += num_rotation_components * k_segment_range_reduction_num_bytes_per_component * 2;
+						}
 
-					if (are_clip_rotations_normalized)
-					{
 						const rtm::vector4f clip_range_min = rtm::vector_load(decomp_context.clip_range_data + sampling_context.clip_range_data_offset);
 						const rtm::vector4f clip_range_extent = rtm::vector_load(decomp_context.clip_range_data + sampling_context.clip_range_data_offset + (num_rotation_components * sizeof(float)));
 
@@ -471,7 +405,7 @@ namespace acl
 					rtm::quatf rotation2 = rtm::vector_to_quat(rotation_as_vec2);
 					rtm::quatf rotation3 = rtm::vector_to_quat(rotation_as_vec3);
 
-					if (rotation_format != RotationFormat8::Quat_128 || !settings.is_rotation_format_supported(RotationFormat8::Quat_128))
+					if (rotation_format != rotation_format8::quatf_full || !settings.is_rotation_format_supported(rotation_format8::quatf_full))
 					{
 						// We dropped the W component
 						rotation0 = rtm::quat_from_positive_w(rotation_as_vec0);
@@ -520,13 +454,11 @@ namespace acl
 					interpolated_vector = unpack_vector3_96_unsafe(decomp_context.constant_track_data + sampling_context.constant_track_data_offset);
 					ACL_ASSERT(rtm::vector_is_finite3(interpolated_vector), "Vector is not valid!");
 
-					sampling_context.constant_track_data_offset += get_packed_vector_size(VectorFormat8::Vector3_96);
+					sampling_context.constant_track_data_offset += get_packed_vector_size(vector_format8::vector3f_full);
 				}
 				else
 				{
-					const VectorFormat8 format = settings.get_vector_format(header);
-					const RangeReductionFlags8 clip_range_reduction = settings.get_clip_range_reduction(header.clip_range_reduction);
-					const RangeReductionFlags8 segment_range_reduction = settings.get_segment_range_reduction(header.segment_range_reduction);
+					const vector_format8 format = settings.get_vector_format(header);
 
 					constexpr size_t num_key_frames = SamplingContextType::k_num_samples_to_interpolate;
 
@@ -538,15 +470,13 @@ namespace acl
 					// By default, we never ignore range reduction
 					uint32_t range_ignore_flags = 0;
 
-					if (format == VectorFormat8::Vector3_Variable && settings.is_vector_format_supported(VectorFormat8::Vector3_Variable))
+					if (format == vector_format8::vector3f_variable && settings.is_vector_format_supported(vector_format8::vector3f_variable))
 					{
 						for (size_t i = 0; i < num_key_frames; ++i)
 						{
 							range_ignore_flags <<= 2;
 
 							const uint8_t bit_rate = decomp_context.format_per_track_data[i][sampling_context.format_per_track_data_offset];
-
-							// Promote to 32bit to avoid zero extending instructions on x64
 							const uint32_t num_bits_at_bit_rate = get_num_bits_at_bit_rate(bit_rate);
 
 							if (is_constant_bit_rate(bit_rate))
@@ -562,45 +492,20 @@ namespace acl
 							else
 								vectors[i] = unpack_vector3_uXX_unsafe(uint8_t(num_bits_at_bit_rate), decomp_context.animated_track_data[i], sampling_context.key_frame_bit_offsets[i]);
 
-							uint32_t num_bits_read = num_bits_at_bit_rate * 3;
-
-							if (settings.supports_mixed_packing() && decomp_context.has_mixed_packing)
-								num_bits_read = align_to(num_bits_read, k_mixed_packing_alignment_num_bits);
-
-							sampling_context.key_frame_bit_offsets[i] += num_bits_read;
-
-							if (settings.supports_mixed_packing() && decomp_context.has_mixed_packing)
-								sampling_context.key_frame_byte_offsets[i] = sampling_context.key_frame_bit_offsets[i] / 8;
+							sampling_context.key_frame_bit_offsets[i] += num_bits_at_bit_rate * 3;
 						}
 
 						sampling_context.format_per_track_data_offset++;
 					}
 					else
 					{
-						if (format == VectorFormat8::Vector3_96 && settings.is_vector_format_supported(VectorFormat8::Vector3_96))
-						{
-							for (size_t i = 0; i < num_key_frames; ++i)
-								vectors[i] = unpack_vector3_96_unsafe(decomp_context.animated_track_data[i] + sampling_context.key_frame_byte_offsets[i]);
-						}
-						else if (format == VectorFormat8::Vector3_48 && settings.is_vector_format_supported(VectorFormat8::Vector3_48))
+						if (format == vector_format8::vector3f_full && settings.is_vector_format_supported(vector_format8::vector3f_full))
 						{
 							for (size_t i = 0; i < num_key_frames; ++i)
-								vectors[i] = unpack_vector3_u48_unsafe(decomp_context.animated_track_data[i] + sampling_context.key_frame_byte_offsets[i]);
-						}
-						else if (format == VectorFormat8::Vector3_32 && settings.is_vector_format_supported(VectorFormat8::Vector3_32))
-						{
-							for (size_t i = 0; i < num_key_frames; ++i)
-								vectors[i] = unpack_vector3_32(11, 11, 10, true, decomp_context.animated_track_data[i] + sampling_context.key_frame_byte_offsets[i]);
-						}
-
-						const uint32_t sample_size = get_packed_vector_size(format);
-
-						for (size_t i = 0; i < num_key_frames; ++i)
-						{
-							sampling_context.key_frame_byte_offsets[i] += sample_size;
-
-							if (settings.supports_mixed_packing() && decomp_context.has_mixed_packing)
-								sampling_context.key_frame_bit_offsets[i] = sampling_context.key_frame_byte_offsets[i] * 8;
+							{
+								vectors[i] = unpack_vector3_96_unsafe(decomp_context.animated_track_data[i], sampling_context.key_frame_bit_offsets[i]);
+								sampling_context.key_frame_bit_offsets[i] += 96;
+							}
 						}
 					}
 
@@ -624,53 +529,53 @@ namespace acl
 						vector3 = vector0;
 					}
 
-					const RangeReductionFlags8 range_reduction_flag = settings.get_range_reduction_flag();
-					if (are_any_enum_flags_set(segment_range_reduction, range_reduction_flag))
+					const range_reduction_flags8 range_reduction_flag = settings.get_range_reduction_flag();
+					if (are_any_enum_flags_set(decomp_context.range_reduction, range_reduction_flag) && settings.are_range_reduction_flags_supported(range_reduction_flag))
 					{
-						const uint32_t segment_range_min_offset = sampling_context.segment_range_data_offset;
-						const uint32_t segment_range_extent_offset = sampling_context.segment_range_data_offset + (3 * sizeof(uint8_t));
-
-						constexpr uint32_t ignore_mask = 0x00000001U << ((num_key_frames - 1) * 2);
-						if ((range_ignore_flags & (ignore_mask >> 0)) == 0)
+						if (header.num_segments > 1)
 						{
-							const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[0] + segment_range_min_offset);
-							const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[0] + segment_range_extent_offset);
+							const uint32_t segment_range_min_offset = sampling_context.segment_range_data_offset;
+							const uint32_t segment_range_extent_offset = sampling_context.segment_range_data_offset + (3 * sizeof(uint8_t));
 
-							vector0 = rtm::vector_mul_add(vector0, segment_range_extent, segment_range_min);
-						}
-
-						if ((range_ignore_flags & (ignore_mask >> 2)) == 0)
-						{
-							const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[1] + segment_range_min_offset);
-							const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[1] + segment_range_extent_offset);
+							constexpr uint32_t ignore_mask = 0x00000001U << ((num_key_frames - 1) * 2);
+							if ((range_ignore_flags & (ignore_mask >> 0)) == 0)
+							{
+								const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[0] + segment_range_min_offset);
+								const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[0] + segment_range_extent_offset);
 
-							vector1 = rtm::vector_mul_add(vector1, segment_range_extent, segment_range_min);
-						}
+								vector0 = rtm::vector_mul_add(vector0, segment_range_extent, segment_range_min);
+							}
 
-						if (static_condition<num_key_frames == 4>::test())
-						{
-							if ((range_ignore_flags & (ignore_mask >> 4)) == 0)
+							if ((range_ignore_flags & (ignore_mask >> 2)) == 0)
 							{
-								const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[2] + segment_range_min_offset);
-								const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[2] + segment_range_extent_offset);
+								const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[1] + segment_range_min_offset);
+								const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[1] + segment_range_extent_offset);
 
-								vector2 = rtm::vector_mul_add(vector2, segment_range_extent, segment_range_min);
+								vector1 = rtm::vector_mul_add(vector1, segment_range_extent, segment_range_min);
 							}
 
-							if ((range_ignore_flags & (ignore_mask >> 8)) == 0)
+							if (static_condition<num_key_frames == 4>::test())
 							{
-								const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[3] + segment_range_min_offset);
-								const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[3] + segment_range_extent_offset);
+								if ((range_ignore_flags & (ignore_mask >> 4)) == 0)
+								{
+									const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[2] + segment_range_min_offset);
+									const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[2] + segment_range_extent_offset);
+
+									vector2 = rtm::vector_mul_add(vector2, segment_range_extent, segment_range_min);
+								}
 
-								vector3 = rtm::vector_mul_add(vector3, segment_range_extent, segment_range_min);
+								if ((range_ignore_flags & (ignore_mask >> 8)) == 0)
+								{
+									const rtm::vector4f segment_range_min = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[3] + segment_range_min_offset);
+									const rtm::vector4f segment_range_extent = unpack_vector3_u24_unsafe(decomp_context.segment_range_data[3] + segment_range_extent_offset);
+
+									vector3 = rtm::vector_mul_add(vector3, segment_range_extent, segment_range_min);
+								}
 							}
-						}
 
-						sampling_context.segment_range_data_offset += 3 * k_segment_range_reduction_num_bytes_per_component * 2;
-					}
+							sampling_context.segment_range_data_offset += 3 * k_segment_range_reduction_num_bytes_per_component * 2;
+						}
 
-					if (are_any_enum_flags_set(clip_range_reduction, range_reduction_flag))
-					{
 						const rtm::vector4f clip_range_min = unpack_vector3_96_unsafe(decomp_context.clip_range_data + sampling_context.clip_range_data_offset);
 						const rtm::vector4f clip_range_extent = unpack_vector3_96_unsafe(decomp_context.clip_range_data + sampling_context.clip_range_data_offset + (3 * sizeof(float)));
 
diff --git a/includes/acl/io/clip_reader.h b/includes/acl/io/clip_reader.h
--- a/includes/acl/io/clip_reader.h
+++ b/includes/acl/io/clip_reader.h
@@ -63,7 +63,7 @@ namespace acl
 		std::unique_ptr<RigidSkeleton, Deleter<RigidSkeleton>> skeleton;
 
 		bool has_settings;
-		AlgorithmType8 algorithm_type;
+		algorithm_type8 algorithm_type;
 		CompressionSettings settings;
 	};
 
@@ -142,7 +142,7 @@ namespace acl
 				return false;
 
 			bool has_settings;				// Not used
-			AlgorithmType8 algorithm_type;	// Not used
+			algorithm_type8 algorithm_type;	// Not used
 			CompressionSettings settings;	// Not used
 			if (!read_settings(&has_settings, &algorithm_type, &settings))
 				return false;
@@ -165,7 +165,7 @@ namespace acl
 		float m_sample_rate;
 		sjson::StringView m_clip_name;
 		bool m_is_binary_exact;
-		AdditiveClipFormat8 m_additive_format;
+		additive_clip_format8 m_additive_format;
 		sjson::StringView m_additive_base_name;
 		uint32_t m_additive_base_num_samples;
 		float m_additive_base_sample_rate;
@@ -184,7 +184,7 @@ namespace acl
 				return false;
 			}
 
-			if (m_version > 4)
+			if (m_version > 5)
 			{
 				set_error(ClipReaderError::UnsupportedVersion);
 				return false;
@@ -234,7 +234,7 @@ namespace acl
 			m_parser.try_read("is_binary_exact", m_is_binary_exact, false);
 
 			// Optional value
-			m_parser.try_read("additive_format", additive_format, "None");
+			m_parser.try_read("additive_format", additive_format, "none");
 			if (!get_additive_clip_format(additive_format.c_str(), m_additive_format))
 			{
 				set_error(ClipReaderError::InvalidAdditiveClipFormat);
@@ -309,7 +309,7 @@ namespace acl
 			return false;
 		}
 
-		bool read_settings(bool* out_has_settings, AlgorithmType8* out_algorithm_type, CompressionSettings* out_settings)
+		bool read_settings(bool* out_has_settings, algorithm_type8* out_algorithm_type, CompressionSettings* out_settings)
 		{
 			if (!m_parser.try_object_begins("settings"))
 			{
@@ -335,30 +335,30 @@ namespace acl
 			double constant_scale_threshold;
 			double error_threshold;
 
-			bool segmenting_enabled = default_settings.segmenting.enabled;
 			double segmenting_ideal_num_samples = double(default_settings.segmenting.ideal_num_samples);
 			double segmenting_max_num_samples = double(default_settings.segmenting.max_num_samples);
-			bool segmenting_rotation_range_reduction = are_any_enum_flags_set(default_settings.segmenting.range_reduction, RangeReductionFlags8::Rotations);
-			bool segmenting_translation_range_reduction = are_any_enum_flags_set(default_settings.segmenting.range_reduction, RangeReductionFlags8::Translations);
-			bool segmenting_scale_range_reduction = are_any_enum_flags_set(default_settings.segmenting.range_reduction, RangeReductionFlags8::Scales);
 
-			m_parser.try_read("algorithm_name", algorithm_name, get_algorithm_name(AlgorithmType8::UniformlySampled));
+			m_parser.try_read("algorithm_name", algorithm_name, get_algorithm_name(algorithm_type8::uniformly_sampled));
 			m_parser.try_read("level", compression_level, get_compression_level_name(default_settings.level));
 			m_parser.try_read("rotation_format", rotation_format, get_rotation_format_name(default_settings.rotation_format));
 			m_parser.try_read("translation_format", translation_format, get_vector_format_name(default_settings.translation_format));
 			m_parser.try_read("scale_format", scale_format, get_vector_format_name(default_settings.scale_format));
-			m_parser.try_read("rotation_range_reduction", rotation_range_reduction, are_any_enum_flags_set(default_settings.range_reduction, RangeReductionFlags8::Rotations));
-			m_parser.try_read("translation_range_reduction", translation_range_reduction, are_any_enum_flags_set(default_settings.range_reduction, RangeReductionFlags8::Translations));
-			m_parser.try_read("scale_range_reduction", scale_range_reduction, are_any_enum_flags_set(default_settings.range_reduction, RangeReductionFlags8::Scales));
+			m_parser.try_read("rotation_range_reduction", rotation_range_reduction, false);			// Legacy, no longer used
+			m_parser.try_read("translation_range_reduction", translation_range_reduction, false);	// Legacy, no longer used
+			m_parser.try_read("scale_range_reduction", scale_range_reduction, false);				// Legacy, no longer used
 
 			if (m_parser.try_object_begins("segmenting"))
 			{
-				m_parser.try_read("enabled", segmenting_enabled, default_settings.segmenting.enabled);
+				bool segmenting_enabled;
+				bool segmenting_rotation_range_reduction;
+				bool segmenting_translation_range_reduction;
+				bool segmenting_scale_range_reduction;
+				m_parser.try_read("enabled", segmenting_enabled, false);	// Legacy, no longer used
 				m_parser.try_read("ideal_num_samples", segmenting_ideal_num_samples, double(default_settings.segmenting.ideal_num_samples));
 				m_parser.try_read("max_num_samples", segmenting_max_num_samples, double(default_settings.segmenting.max_num_samples));
-				m_parser.try_read("rotation_range_reduction", segmenting_rotation_range_reduction, are_any_enum_flags_set(default_settings.segmenting.range_reduction, RangeReductionFlags8::Rotations));
-				m_parser.try_read("translation_range_reduction", segmenting_translation_range_reduction, are_any_enum_flags_set(default_settings.segmenting.range_reduction, RangeReductionFlags8::Translations));
-				m_parser.try_read("scale_range_reduction", segmenting_scale_range_reduction, are_any_enum_flags_set(default_settings.segmenting.range_reduction, RangeReductionFlags8::Scales));
+				m_parser.try_read("rotation_range_reduction", segmenting_rotation_range_reduction, false);			// Legacy, no longer used
+				m_parser.try_read("translation_range_reduction", segmenting_translation_range_reduction, false);	// Legacy, no longer used
+				m_parser.try_read("scale_range_reduction", segmenting_scale_range_reduction, false);				// Legacy, no longer used
 
 				if (!m_parser.is_valid() || !m_parser.object_ends())
 					goto parsing_error;
@@ -391,34 +391,9 @@ namespace acl
 				if (!get_vector_format(scale_format.c_str(), out_settings->scale_format))
 					goto invalid_value_error;
 
-				RangeReductionFlags8 range_reduction = RangeReductionFlags8::None;
-				if (rotation_range_reduction)
-					range_reduction |= RangeReductionFlags8::Rotations;
-
-				if (translation_range_reduction)
-					range_reduction |= RangeReductionFlags8::Translations;
-
-				if (scale_range_reduction)
-					range_reduction |= RangeReductionFlags8::Scales;
-
-				out_settings->range_reduction = range_reduction;
-
-				out_settings->segmenting.enabled = segmenting_enabled;
 				out_settings->segmenting.ideal_num_samples = uint16_t(segmenting_ideal_num_samples);
 				out_settings->segmenting.max_num_samples = uint16_t(segmenting_max_num_samples);
 
-				RangeReductionFlags8 segmenting_range_reduction = RangeReductionFlags8::None;
-				if (rotation_range_reduction)
-					segmenting_range_reduction |= RangeReductionFlags8::Rotations;
-
-				if (translation_range_reduction)
-					segmenting_range_reduction |= RangeReductionFlags8::Translations;
-
-				if (scale_range_reduction)
-					segmenting_range_reduction |= RangeReductionFlags8::Scales;
-
-				out_settings->segmenting.range_reduction = segmenting_range_reduction;
-
 				out_settings->constant_rotation_threshold_angle = rtm::radians(float(constant_rotation_threshold_angle));
 				out_settings->constant_translation_threshold = float(constant_translation_threshold);
 				out_settings->constant_scale_threshold = float(constant_scale_threshold);
diff --git a/includes/acl/io/clip_writer.h b/includes/acl/io/clip_writer.h
--- a/includes/acl/io/clip_writer.h
+++ b/includes/acl/io/clip_writer.h
@@ -98,7 +98,7 @@ namespace acl
 			writer.insert_newline();
 		}
 
-		inline void write_sjson_settings(AlgorithmType8 algorithm, const CompressionSettings& settings, sjson::Writer& writer)
+		inline void write_sjson_settings(algorithm_type8 algorithm, const CompressionSettings& settings, sjson::Writer& writer)
 		{
 			writer["settings"] = [&](sjson::ObjectWriter& settings_writer)
 			{
@@ -107,18 +107,11 @@ namespace acl
 				settings_writer["rotation_format"] = get_rotation_format_name(settings.rotation_format);
 				settings_writer["translation_format"] = get_vector_format_name(settings.translation_format);
 				settings_writer["scale_format"] = get_vector_format_name(settings.scale_format);
-				settings_writer["rotation_range_reduction"] = are_any_enum_flags_set(settings.range_reduction, RangeReductionFlags8::Rotations);
-				settings_writer["translation_range_reduction"] = are_any_enum_flags_set(settings.range_reduction, RangeReductionFlags8::Translations);
-				settings_writer["scale_range_reduction"] = are_any_enum_flags_set(settings.range_reduction, RangeReductionFlags8::Scales);
 
 				settings_writer["segmenting"] = [&](sjson::ObjectWriter& segmenting_writer)
 				{
-					segmenting_writer["enabled"] = settings.segmenting.enabled;
 					segmenting_writer["ideal_num_samples"] = settings.segmenting.ideal_num_samples;
 					segmenting_writer["max_num_samples"] = settings.segmenting.max_num_samples;
-					segmenting_writer["rotation_range_reduction"] = are_any_enum_flags_set(settings.segmenting.range_reduction, RangeReductionFlags8::Rotations);
-					segmenting_writer["translation_range_reduction"] = are_any_enum_flags_set(settings.segmenting.range_reduction, RangeReductionFlags8::Translations);
-					segmenting_writer["scale_range_reduction"] = are_any_enum_flags_set(settings.segmenting.range_reduction, RangeReductionFlags8::Scales);
 				};
 
 				settings_writer["constant_rotation_threshold_angle"] = settings.constant_rotation_threshold_angle.as_radians();
@@ -266,7 +259,7 @@ namespace acl
 			};
 		}
 
-		inline const char* write_acl_clip(const RigidSkeleton& skeleton, const AnimationClip& clip, AlgorithmType8 algorithm, const CompressionSettings* settings, const char* acl_filename)
+		inline const char* write_acl_clip(const RigidSkeleton& skeleton, const AnimationClip& clip, algorithm_type8 algorithm, const CompressionSettings* settings, const char* acl_filename)
 		{
 			if (acl_filename == nullptr)
 				return "'acl_filename' cannot be NULL!";
@@ -291,7 +284,7 @@ namespace acl
 			sjson::FileStreamWriter stream_writer(file);
 			sjson::Writer writer(stream_writer);
 
-			writer["version"] = 3;
+			writer["version"] = 5;
 			writer.insert_newline();
 
 			write_sjson_clip(clip, writer);
@@ -317,7 +310,7 @@ namespace acl
 	//////////////////////////////////////////////////////////////////////////
 	inline const char* write_acl_clip(const RigidSkeleton& skeleton, const AnimationClip& clip, const char* acl_filename)
 	{
-		return acl_impl::write_acl_clip(skeleton, clip, AlgorithmType8::UniformlySampled, nullptr, acl_filename);
+		return acl_impl::write_acl_clip(skeleton, clip, algorithm_type8::uniformly_sampled, nullptr, acl_filename);
 	}
 
 	//////////////////////////////////////////////////////////////////////////
@@ -325,7 +318,7 @@ namespace acl
 	// and compression settings.
 	// Returns an error string on failure, null on success.
 	//////////////////////////////////////////////////////////////////////////
-	inline const char* write_acl_clip(const RigidSkeleton& skeleton, const AnimationClip& clip, AlgorithmType8 algorithm, const CompressionSettings& settings, const char* acl_filename)
+	inline const char* write_acl_clip(const RigidSkeleton& skeleton, const AnimationClip& clip, algorithm_type8 algorithm, const CompressionSettings& settings, const char* acl_filename)
 	{
 		return acl_impl::write_acl_clip(skeleton, clip, algorithm, &settings, acl_filename);
 	}
@@ -361,7 +354,7 @@ namespace acl
 		sjson::FileStreamWriter stream_writer(file);
 		sjson::Writer writer(stream_writer);
 
-		writer["version"] = 4;
+		writer["version"] = 5;
 		writer.insert_newline();
 
 		writer["track_list"] = [&](sjson::ObjectWriter& header_writer)
diff --git a/includes/acl/math/quat_packing.h b/includes/acl/math/quat_packing.h
--- a/includes/acl/math/quat_packing.h
+++ b/includes/acl/math/quat_packing.h
@@ -91,31 +91,27 @@ namespace acl
 	//////////////////////////////////////////////////////////////////////////
 
 	// TODO: constexpr
-	inline uint32_t get_packed_rotation_size(RotationFormat8 format)
+	inline uint32_t get_packed_rotation_size(rotation_format8 format)
 	{
 		switch (format)
 		{
-		case RotationFormat8::Quat_128:	return sizeof(float) * 4;
-		case RotationFormat8::QuatDropW_96:	return sizeof(float) * 3;
-		case RotationFormat8::QuatDropW_48:	return sizeof(uint16_t) * 3;
-		case RotationFormat8::QuatDropW_32:	return sizeof(uint32_t);
-		case RotationFormat8::QuatDropW_Variable:
+		case rotation_format8::quatf_full:				return sizeof(float) * 4;
+		case rotation_format8::quatf_drop_w_full:		return sizeof(float) * 3;
+		case rotation_format8::quatf_drop_w_variable:
 		default:
 			ACL_ASSERT(false, "Invalid or unsupported rotation format: %s", get_rotation_format_name(format));
 			return 0;
 		}
 	}
 
-	inline uint32_t get_range_reduction_rotation_size(RotationFormat8 format)
+	inline uint32_t get_range_reduction_rotation_size(rotation_format8 format)
 	{
 		switch (format)
 		{
-		case RotationFormat8::Quat_128:
+		case rotation_format8::quatf_full:
 			return sizeof(float) * 8;
-		case RotationFormat8::QuatDropW_96:
-		case RotationFormat8::QuatDropW_48:
-		case RotationFormat8::QuatDropW_32:
-		case RotationFormat8::QuatDropW_Variable:
+		case rotation_format8::quatf_drop_w_full:
+		case rotation_format8::quatf_drop_w_variable:
 			return sizeof(float) * 6;
 		default:
 			ACL_ASSERT(false, "Invalid or unsupported rotation format: %s", get_rotation_format_name(format));
diff --git a/includes/acl/math/vector4_packing.h b/includes/acl/math/vector4_packing.h
--- a/includes/acl/math/vector4_packing.h
+++ b/includes/acl/math/vector4_packing.h
@@ -51,7 +51,7 @@ namespace acl
 		return rtm::vector_load(vector_data);
 	}
 
-	// Assumes the 'vector_data' is in big-endian order and is padded in order to load up to 16 bytes from it
+	// Assumes the 'vector_data' is in big-endian order and is padded in order to load up to 23 bytes from it
 	inline rtm::vector4f RTM_SIMD_CALL unpack_vector4_128_unsafe(const uint8_t* vector_data, uint32_t bit_offset)
 	{
 #if defined(RTM_SSE2_INTRINSICS)
@@ -445,7 +445,7 @@ namespace acl
 		return rtm::vector_load(vector_data);
 	}
 
-	// Assumes the 'vector_data' is in big-endian order and is padded in order to load up to 16 bytes from it
+	// Assumes the 'vector_data' is in big-endian order and is padded in order to load up to 19 bytes from it
 	inline rtm::vector4f RTM_SIMD_CALL unpack_vector3_96_unsafe(const uint8_t* vector_data, uint32_t bit_offset)
 	{
 #if defined(RTM_SSE2_INTRINSICS)
@@ -1081,14 +1081,12 @@ namespace acl
 	//////////////////////////////////////////////////////////////////////////
 
 	// TODO: constexpr
-	inline uint32_t get_packed_vector_size(VectorFormat8 format)
+	inline uint32_t get_packed_vector_size(vector_format8 format)
 	{
 		switch (format)
 		{
-		case VectorFormat8::Vector3_96:		return sizeof(float) * 3;
-		case VectorFormat8::Vector3_48:		return sizeof(uint16_t) * 3;
-		case VectorFormat8::Vector3_32:		return sizeof(uint32_t);
-		case VectorFormat8::Vector3_Variable:
+		case vector_format8::vector3f_full:		return sizeof(float) * 3;
+		case vector_format8::vector3f_variable:
 		default:
 			ACL_ASSERT(false, "Invalid or unsupported vector format: %s", get_vector_format_name(format));
 			return 0;
diff --git a/make.py b/make.py
--- a/make.py
+++ b/make.py
@@ -449,7 +449,7 @@ def do_prepare_decompression_test_data(test_data_dir, args):
 				if not filename.endswith('.config.sjson'):
 					continue
 
-				if not filename == 'uniformly_sampled_quant_var_2_medium.config.sjson':
+				if not filename == 'uniformly_sampled_quant_medium.config.sjson':
 					continue
 
 				config_filename = os.path.join(dirpath, filename)
diff --git a/tools/acl_compressor/acl_compressor.py b/tools/acl_compressor/acl_compressor.py
--- a/tools/acl_compressor/acl_compressor.py
+++ b/tools/acl_compressor/acl_compressor.py
@@ -393,60 +393,40 @@ def compress_clips(options):
 
 	return stat_files
 
-def shorten_range_reduction(range_reduction):
-	if range_reduction == 'RangeReduction::None':
-		return 'RR:None'
-	elif range_reduction == 'RangeReduction::Rotations':
-		return 'RR:Rot'
-	elif range_reduction == 'RangeReduction::Translations':
-		return 'RR:Trans'
-	elif range_reduction == 'RangeReduction::Scales':
-		return 'RR:Scale'
-	elif range_reduction == 'RangeReduction::Rotations | RangeReduction::Translations':
-		return 'RR:Rot|Trans'
-	elif range_reduction == 'RangeReduction::Rotations | RangeReduction::Scales':
-		return 'RR:Rot|Scale'
-	elif range_reduction == 'RangeReduction::Translations | RangeReduction::Scales':
-		return 'RR:Trans|Scale'
-	elif range_reduction == 'RangeReduction::Rotations | RangeReduction::Translations | RangeReduction::Scales':
-		return 'RR:Rot|Trans|Scale'
-	else:
-		return 'RR:???'
-
 def shorten_rotation_format(format):
-	if format == 'Quat_128':
+	if format == 'quatf_full':
 		return 'R:Quat'
-	elif format == 'QuatDropW_96':
+	elif format == 'quatf_drop_w_full':
 		return 'R:QuatNoW96'
 	elif format == 'QuatDropW_48':
 		return 'R:QuatNoW48'
 	elif format == 'QuatDropW_32':
 		return 'R:QuatNoW32'
-	elif format == 'QuatDropW_Variable':
+	elif format == 'quatf_drop_w_variable':
 		return 'R:QuatNoWVar'
 	else:
 		return 'R:???'
 
 def shorten_translation_format(format):
-	if format == 'Vector3_96':
+	if format == 'vector3f_full':
 		return 'T:Vec3_96'
 	elif format == 'Vector3_48':
 		return 'T:Vec3_48'
 	elif format == 'Vector3_32':
 		return 'T:Vec3_32'
-	elif format == 'Vector3_Variable':
+	elif format == 'vector3f_variable':
 		return 'T:Vec3Var'
 	else:
 		return 'T:???'
 
 def shorten_scale_format(format):
-	if format == 'Vector3_96':
+	if format == 'vector3f_full':
 		return 'S:Vec3_96'
 	elif format == 'Vector3_48':
 		return 'S:Vec3_48'
 	elif format == 'Vector3_32':
 		return 'S:Vec3_32'
-	elif format == 'Vector3_Variable':
+	elif format == 'vector3f_variable':
 		return 'S:Vec3Var'
 	else:
 		return 'S:???'
@@ -534,7 +514,6 @@ def run_stat_parsing(options, stat_queue, result_queue):
 						if len(run_stats) == 0:
 							continue
 
-						run_stats['range_reduction'] = shorten_range_reduction(run_stats['range_reduction'])
 						run_stats['filename'] = stat_filename.replace('\\\\?\\', '')
 						run_stats['clip_name'] = os.path.splitext(os.path.basename(stat_filename))[0]
 						run_stats['rotation_format'] = shorten_rotation_format(run_stats['rotation_format'])
@@ -545,12 +524,11 @@ def run_stat_parsing(options, stat_queue, result_queue):
 							run_stats['duration'] = 0.0
 
 						if 'segmenting' in run_stats:
-							run_stats['segmenting']['range_reduction'] = shorten_range_reduction(run_stats['segmenting']['range_reduction'])
-							run_stats['desc'] = '{}|{}|{}, Clip {}, Segment {}'.format(run_stats['rotation_format'], run_stats['translation_format'], run_stats['scale_format'], run_stats['range_reduction'], run_stats['segmenting']['range_reduction'])
-							run_stats['csv_desc'] = '{}|{}|{} Clip {} Segment {}'.format(run_stats['rotation_format'], run_stats['translation_format'], run_stats['scale_format'], run_stats['range_reduction'], run_stats['segmenting']['range_reduction'])
+							run_stats['desc'] = '{}|{}|{}'.format(run_stats['rotation_format'], run_stats['translation_format'], run_stats['scale_format'])
+							run_stats['csv_desc'] = '{}|{}|{}'.format(run_stats['rotation_format'], run_stats['translation_format'], run_stats['scale_format'])
 						else:
-							run_stats['desc'] = '{}|{}|{}, Clip {}'.format(run_stats['rotation_format'], run_stats['translation_format'], run_stats['scale_format'], run_stats['range_reduction'])
-							run_stats['csv_desc'] = '{}|{}|{} Clip {}'.format(run_stats['rotation_format'], run_stats['translation_format'], run_stats['scale_format'], run_stats['range_reduction'])
+							run_stats['desc'] = '{}|{}|{}'.format(run_stats['rotation_format'], run_stats['translation_format'], run_stats['scale_format'])
+							run_stats['csv_desc'] = '{}|{}|{}'.format(run_stats['rotation_format'], run_stats['translation_format'], run_stats['scale_format'])
 
 						aggregate_stats(agg_run_stats, run_stats)
 						track_best_runs(best_runs, run_stats)
diff --git a/tools/acl_compressor/sources/acl_compressor.cpp b/tools/acl_compressor/sources/acl_compressor.cpp
--- a/tools/acl_compressor/sources/acl_compressor.cpp
+++ b/tools/acl_compressor/sources/acl_compressor.cpp
@@ -140,7 +140,7 @@ struct Options
 
 	const char*		output_bin_filename;
 
-	CompressionLevel8	compression_level;
+	compression_level8	compression_level;
 	bool			compression_level_specified;
 
 	bool			regression_testing;
@@ -173,7 +173,7 @@ struct Options
 		, output_stats_filename(nullptr)
 		, output_stats_file(nullptr)
 		, output_bin_filename(nullptr)
-		, compression_level(CompressionLevel8::Lowest)
+		, compression_level(compression_level8::lowest)
 		, compression_level_specified(false)
 		, regression_testing(false)
 		, profile_decompression(false)
@@ -447,7 +447,7 @@ static void validate_accuracy(IAllocator& allocator, const AnimationClip& clip,
 		const float sample_time = rtm::scalar_min(float(sample_index) / sample_rate, clip_duration);
 
 		// We use the nearest sample to accurately measure the loss that happened, if any
-		context.seek(sample_time, SampleRoundingPolicy::Nearest);
+		context.seek(sample_time, sample_rounding_policy::nearest);
 		context.decompress_pose(pose_writer);
 
 		// Validate decompress_bone for rotations only
@@ -532,9 +532,9 @@ static void validate_accuracy(IAllocator& allocator, const track_array& raw_trac
 		const float sample_time = rtm::scalar_min(float(sample_index) / sample_rate, duration);
 
 		// We use the nearest sample to accurately measure the loss that happened, if any
-		raw_tracks.sample_tracks(sample_time, SampleRoundingPolicy::Nearest, raw_tracks_writer);
+		raw_tracks.sample_tracks(sample_time, sample_rounding_policy::nearest, raw_tracks_writer);
 
-		context.seek(sample_time, SampleRoundingPolicy::Nearest);
+		context.seek(sample_time, sample_rounding_policy::nearest);
 		context.decompress_tracks(lossy_tracks_writer);
 
 		// Validate decompress_tracks
@@ -605,7 +605,7 @@ static void validate_accuracy(IAllocator& allocator, const track_array& raw_trac
 				continue;	// Track is being stripped, ignore it
 
 			// We use the nearest sample to accurately measure the loss that happened, if any
-			raw_tracks.sample_track(track_index, sample_time, SampleRoundingPolicy::Nearest, raw_track_writer);
+			raw_tracks.sample_track(track_index, sample_time, sample_rounding_policy::nearest, raw_track_writer);
 			context.decompress_track(output_index, lossy_track_writer);
 
 			switch (track_type)
@@ -674,7 +674,7 @@ static void validate_accuracy(IAllocator& allocator, const track_array& raw_trac
 #endif	// defined(ACL_HAS_ASSERT_CHECKS)
 }
 
-static void try_algorithm(const Options& options, IAllocator& allocator, const AnimationClip& clip, const CompressionSettings& settings, AlgorithmType8 algorithm_type, StatLogging logging, sjson::ArrayWriter* runs_writer, double regression_error_threshold)
+static void try_algorithm(const Options& options, IAllocator& allocator, const AnimationClip& clip, const CompressionSettings& settings, algorithm_type8 algorithm_type, StatLogging logging, sjson::ArrayWriter* runs_writer, double regression_error_threshold)
 {
 	(void)runs_writer;
 
@@ -688,7 +688,7 @@ static void try_algorithm(const Options& options, IAllocator& allocator, const A
 		ErrorResult error_result; (void)error_result;
 		switch (algorithm_type)
 		{
-		case AlgorithmType8::UniformlySampled:
+		case algorithm_type8::uniformly_sampled:
 			error_result = uniformly_sampled::compress_clip(allocator, clip, settings, compressed_clip, stats);
 			break;
 		}
@@ -706,7 +706,7 @@ static void try_algorithm(const Options& options, IAllocator& allocator, const A
 			BoneError bone_error;
 			switch (algorithm_type)
 			{
-			case AlgorithmType8::UniformlySampled:
+			case algorithm_type8::uniformly_sampled:
 			{
 				uniformly_sampled::DecompressionContext<uniformly_sampled::DebugDecompressionSettings> context;
 				context.initialize(*compressed_clip);
@@ -731,7 +731,7 @@ static void try_algorithm(const Options& options, IAllocator& allocator, const A
 
 			switch (algorithm_type)
 			{
-			case AlgorithmType8::UniformlySampled:
+			case algorithm_type8::uniformly_sampled:
 			{
 				uniformly_sampled::DecompressionContext<uniformly_sampled::DebugDecompressionSettings> context;
 				context.initialize(*compressed_clip);
@@ -914,7 +914,7 @@ static bool read_acl_sjson_file(IAllocator& allocator, const Options& options,
 	return success;
 }
 
-static bool read_config(IAllocator& allocator, Options& options, AlgorithmType8& out_algorithm_type, CompressionSettings& out_settings, double& out_regression_error_threshold)
+static bool read_config(IAllocator& allocator, Options& options, algorithm_type8& out_algorithm_type, CompressionSettings& out_settings, double& out_regression_error_threshold)
 {
 #if defined(__ANDROID__)
 	sjson::Parser parser(options.config_buffer, options.config_buffer_size - 1);
@@ -938,7 +938,7 @@ static bool read_config(IAllocator& allocator, Options& options, AlgorithmType8&
 		return false;
 	}
 
-	if (version != 1.0)
+	if (version != 2.0)
 	{
 		printf("Unsupported version: %f\n", version);
 		return false;
@@ -995,56 +995,6 @@ static bool read_config(IAllocator& allocator, Options& options, AlgorithmType8&
 		return false;
 	}
 
-	RangeReductionFlags8 range_reduction = RangeReductionFlags8::None;
-
-	bool rotation_range_reduction;
-	parser.try_read("rotation_range_reduction", rotation_range_reduction, are_any_enum_flags_set(default_settings.range_reduction, RangeReductionFlags8::Rotations));
-	if (rotation_range_reduction)
-		range_reduction |= RangeReductionFlags8::Rotations;
-
-	bool translation_range_reduction;
-	parser.try_read("translation_range_reduction", translation_range_reduction, are_any_enum_flags_set(default_settings.range_reduction, RangeReductionFlags8::Translations));
-	if (translation_range_reduction)
-		range_reduction |= RangeReductionFlags8::Translations;
-
-	bool scale_range_reduction;
-	parser.try_read("scale_range_reduction", scale_range_reduction, are_any_enum_flags_set(default_settings.range_reduction, RangeReductionFlags8::Scales));
-	if (scale_range_reduction)
-		range_reduction |= RangeReductionFlags8::Scales;
-
-	out_settings.range_reduction = range_reduction;
-
-	if (parser.object_begins("segmenting"))
-	{
-		parser.try_read("enabled", out_settings.segmenting.enabled, false);
-
-		range_reduction = RangeReductionFlags8::None;
-		parser.try_read("rotation_range_reduction", rotation_range_reduction, are_any_enum_flags_set(default_settings.segmenting.range_reduction, RangeReductionFlags8::Rotations));
-		parser.try_read("translation_range_reduction", translation_range_reduction, are_any_enum_flags_set(default_settings.segmenting.range_reduction, RangeReductionFlags8::Translations));
-		parser.try_read("scale_range_reduction", scale_range_reduction, are_any_enum_flags_set(default_settings.segmenting.range_reduction, RangeReductionFlags8::Scales));
-
-		if (rotation_range_reduction)
-			range_reduction |= RangeReductionFlags8::Rotations;
-
-		if (translation_range_reduction)
-			range_reduction |= RangeReductionFlags8::Translations;
-
-		if (scale_range_reduction)
-			range_reduction |= RangeReductionFlags8::Scales;
-
-		out_settings.segmenting.range_reduction = range_reduction;
-
-		if (!parser.object_ends())
-		{
-			uint32_t line;
-			uint32_t column;
-			parser.get_position(line, column);
-
-			printf("Error on line %d column %d: Expected segmenting object to end\n", line, column);
-			return false;
-		}
-	}
-
 	double constant_rotation_threshold_angle;
 	parser.try_read("constant_rotation_threshold_angle", constant_rotation_threshold_angle, default_settings.constant_rotation_threshold_angle.as_radians());
 	out_settings.constant_rotation_threshold_angle = rtm::radians(float(constant_rotation_threshold_angle));
@@ -1076,16 +1026,16 @@ static bool read_config(IAllocator& allocator, Options& options, AlgorithmType8&
 	return true;
 }
 
-static itransform_error_metric* create_additive_error_metric(IAllocator& allocator, AdditiveClipFormat8 format)
+static itransform_error_metric* create_additive_error_metric(IAllocator& allocator, additive_clip_format8 format)
 {
 	switch (format)
 	{
-	case AdditiveClipFormat8::Relative:
-		return allocate_type<additive_qvvf_transform_error_metric<AdditiveClipFormat8::Relative>>(allocator);
-	case AdditiveClipFormat8::Additive0:
-		return allocate_type<additive_qvvf_transform_error_metric<AdditiveClipFormat8::Additive0>>(allocator);
-	case AdditiveClipFormat8::Additive1:
-		return allocate_type<additive_qvvf_transform_error_metric<AdditiveClipFormat8::Additive1>>(allocator);
+	case additive_clip_format8::relative:
+		return allocate_type<additive_qvvf_transform_error_metric<additive_clip_format8::relative>>(allocator);
+	case additive_clip_format8::additive0:
+		return allocate_type<additive_qvvf_transform_error_metric<additive_clip_format8::additive0>>(allocator);
+	case additive_clip_format8::additive1:
+		return allocate_type<additive_qvvf_transform_error_metric<additive_clip_format8::additive1>>(allocator);
 	default:
 		return nullptr;
 	}
@@ -1098,13 +1048,13 @@ static void create_additive_base_clip(const Options& options, AnimationClip& cli
 	const uint32_t num_samples = clip.get_num_samples();
 	AnimatedBone* bones = clip.get_bones();
 
-	AdditiveClipFormat8 additive_format = AdditiveClipFormat8::None;
+	additive_clip_format8 additive_format = additive_clip_format8::none;
 	if (options.is_bind_pose_relative)
-		additive_format = AdditiveClipFormat8::Relative;
+		additive_format = additive_clip_format8::relative;
 	else if (options.is_bind_pose_additive0)
-		additive_format = AdditiveClipFormat8::Additive0;
+		additive_format = additive_clip_format8::additive0;
 	else if (options.is_bind_pose_additive1)
-		additive_format = AdditiveClipFormat8::Additive1;
+		additive_format = additive_clip_format8::additive1;
 
 	for (uint16_t bone_index = 0; bone_index < num_bones; ++bone_index)
 	{
@@ -1144,17 +1094,12 @@ static void create_additive_base_clip(const Options& options, AnimationClip& cli
 	clip.set_additive_base(&out_base_clip, additive_format);
 }
 
-static CompressionSettings make_settings(RotationFormat8 rotation_format, VectorFormat8 translation_format, VectorFormat8 scale_format,
-	RangeReductionFlags8 clip_range_reduction,
-	bool use_segmenting = false, RangeReductionFlags8 segment_range_reduction = RangeReductionFlags8::None)
+static CompressionSettings make_settings(rotation_format8 rotation_format, vector_format8 translation_format, vector_format8 scale_format)
 {
 	CompressionSettings settings;
 	settings.rotation_format = rotation_format;
 	settings.translation_format = translation_format;
 	settings.scale_format = scale_format;
-	settings.range_reduction = clip_range_reduction;
-	settings.segmenting.enabled = use_segmenting;
-	settings.segmenting.range_reduction = segment_range_reduction;
 	return settings;
 }
 #endif	// defined(ACL_USE_SJSON)
@@ -1186,7 +1131,7 @@ static int safe_main_impl(int argc, char* argv[])
 #endif
 
 	bool use_external_config = false;
-	AlgorithmType8 algorithm_type = AlgorithmType8::UniformlySampled;
+	algorithm_type8 algorithm_type = algorithm_type8::uniformly_sampled;
 	CompressionSettings settings;
 
 	sjson_file_type sjson_type = sjson_file_type::unknown;
@@ -1214,7 +1159,7 @@ static int safe_main_impl(int argc, char* argv[])
 #endif
 	{
 		// Override whatever the ACL SJSON file might have contained
-		algorithm_type = AlgorithmType8::UniformlySampled;
+		algorithm_type = algorithm_type8::uniformly_sampled;
 		settings = CompressionSettings();
 
 		if (!read_config(allocator, options, algorithm_type, settings, regression_error_threshold))
@@ -1311,60 +1256,41 @@ static int safe_main_impl(int argc, char* argv[])
 		{
 			if (use_external_config)
 			{
-				ACL_ASSERT(algorithm_type == AlgorithmType8::UniformlySampled, "Only UniformlySampled is supported for now");
+				ACL_ASSERT(algorithm_type == algorithm_type8::uniformly_sampled, "Only uniformly_sampled is supported for now");
 
 				if (options.compression_level_specified)
 					settings.level = options.compression_level;
 
-				try_algorithm(options, allocator, *clip, settings, AlgorithmType8::UniformlySampled, logging, runs_writer, regression_error_threshold);
+				try_algorithm(options, allocator, *clip, settings, algorithm_type8::uniformly_sampled, logging, runs_writer, regression_error_threshold);
 			}
 			else if (options.exhaustive_compression)
 			{
-				const bool use_segmenting_options[] = { false, true };
-				for (size_t segmenting_option_index = 0; segmenting_option_index < get_array_size(use_segmenting_options); ++segmenting_option_index)
 				{
-					const bool use_segmenting = use_segmenting_options[segmenting_option_index];
-
 					CompressionSettings uniform_tests[] =
 					{
-						make_settings(RotationFormat8::Quat_128, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::None, use_segmenting),
-						make_settings(RotationFormat8::Quat_128, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::Rotations, use_segmenting),
-						make_settings(RotationFormat8::Quat_128, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::Translations, use_segmenting),
-						make_settings(RotationFormat8::Quat_128, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::Rotations | RangeReductionFlags8::Translations, use_segmenting),
-
-						make_settings(RotationFormat8::QuatDropW_96, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::None, use_segmenting),
-						make_settings(RotationFormat8::QuatDropW_96, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::Rotations, use_segmenting),
-						make_settings(RotationFormat8::QuatDropW_96, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::Translations, use_segmenting),
-						make_settings(RotationFormat8::QuatDropW_96, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::Rotations | RangeReductionFlags8::Translations, use_segmenting),
+						make_settings(rotation_format8::quatf_full, vector_format8::vector3f_full, vector_format8::vector3f_full),
+						make_settings(rotation_format8::quatf_drop_w_full, vector_format8::vector3f_full, vector_format8::vector3f_full),
 
-						make_settings(RotationFormat8::QuatDropW_Variable, VectorFormat8::Vector3_Variable, VectorFormat8::Vector3_96, RangeReductionFlags8::Translations, use_segmenting),
-						make_settings(RotationFormat8::QuatDropW_Variable, VectorFormat8::Vector3_Variable, VectorFormat8::Vector3_96, RangeReductionFlags8::Rotations | RangeReductionFlags8::Translations, use_segmenting),
-
-						make_settings(RotationFormat8::QuatDropW_Variable, VectorFormat8::Vector3_Variable, VectorFormat8::Vector3_Variable, RangeReductionFlags8::AllTracks, use_segmenting),
+						make_settings(rotation_format8::quatf_drop_w_variable, vector_format8::vector3f_variable, vector_format8::vector3f_full),
+						make_settings(rotation_format8::quatf_drop_w_variable, vector_format8::vector3f_variable, vector_format8::vector3f_variable),
 					};
 
 					for (CompressionSettings test_settings : uniform_tests)
 					{
 						test_settings.error_metric = settings.error_metric;
 
-						try_algorithm(options, allocator, *clip, test_settings, AlgorithmType8::UniformlySampled, logging, runs_writer, regression_error_threshold);
+						try_algorithm(options, allocator, *clip, test_settings, algorithm_type8::uniformly_sampled, logging, runs_writer, regression_error_threshold);
 					}
 				}
 
 				{
 					CompressionSettings uniform_tests[] =
 					{
-						make_settings(RotationFormat8::Quat_128, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::Rotations, true, RangeReductionFlags8::Rotations),
-						make_settings(RotationFormat8::Quat_128, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::Translations, true, RangeReductionFlags8::Translations),
-						make_settings(RotationFormat8::Quat_128, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::Rotations | RangeReductionFlags8::Translations, true, RangeReductionFlags8::Rotations | RangeReductionFlags8::Translations),
-
-						make_settings(RotationFormat8::QuatDropW_96, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::Rotations, true, RangeReductionFlags8::Rotations),
-						make_settings(RotationFormat8::QuatDropW_96, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::Translations, true, RangeReductionFlags8::Translations),
-						make_settings(RotationFormat8::QuatDropW_96, VectorFormat8::Vector3_96, VectorFormat8::Vector3_96, RangeReductionFlags8::Rotations | RangeReductionFlags8::Translations, true, RangeReductionFlags8::Rotations | RangeReductionFlags8::Translations),
-						make_settings(RotationFormat8::QuatDropW_Variable, VectorFormat8::Vector3_Variable, VectorFormat8::Vector3_96, RangeReductionFlags8::Translations, true, RangeReductionFlags8::Translations),
-						make_settings(RotationFormat8::QuatDropW_Variable, VectorFormat8::Vector3_Variable, VectorFormat8::Vector3_96, RangeReductionFlags8::Rotations | RangeReductionFlags8::Translations, true, RangeReductionFlags8::Rotations | RangeReductionFlags8::Translations),
+						make_settings(rotation_format8::quatf_full, vector_format8::vector3f_full, vector_format8::vector3f_full),
+						make_settings(rotation_format8::quatf_drop_w_full, vector_format8::vector3f_full, vector_format8::vector3f_full),
 
-						make_settings(RotationFormat8::QuatDropW_Variable, VectorFormat8::Vector3_Variable, VectorFormat8::Vector3_Variable, RangeReductionFlags8::AllTracks, true, RangeReductionFlags8::AllTracks),
+						make_settings(rotation_format8::quatf_drop_w_variable, vector_format8::vector3f_variable, vector_format8::vector3f_full),
+						make_settings(rotation_format8::quatf_drop_w_variable, vector_format8::vector3f_variable, vector_format8::vector3f_variable),
 					};
 
 					for (CompressionSettings test_settings : uniform_tests)
@@ -1374,7 +1300,7 @@ static int safe_main_impl(int argc, char* argv[])
 						if (options.compression_level_specified)
 							test_settings.level = options.compression_level;
 
-						try_algorithm(options, allocator, *clip, test_settings, AlgorithmType8::UniformlySampled, logging, runs_writer, regression_error_threshold);
+						try_algorithm(options, allocator, *clip, test_settings, algorithm_type8::uniformly_sampled, logging, runs_writer, regression_error_threshold);
 					}
 				}
 			}
@@ -1386,7 +1312,7 @@ static int safe_main_impl(int argc, char* argv[])
 				if (options.compression_level_specified)
 					default_settings.level = options.compression_level;
 
-				try_algorithm(options, allocator, *clip, default_settings, AlgorithmType8::UniformlySampled, logging, runs_writer, regression_error_threshold);
+				try_algorithm(options, allocator, *clip, default_settings, algorithm_type8::uniformly_sampled, logging, runs_writer, regression_error_threshold);
 			}
 		}
 		else if (sjson_type == sjson_file_type::raw_track_list)
diff --git a/tools/acl_decompressor/main_android/jni/main.cpp b/tools/acl_decompressor/main_android/jni/main.cpp
--- a/tools/acl_decompressor/main_android/jni/main.cpp
+++ b/tools/acl_decompressor/main_android/jni/main.cpp
@@ -119,7 +119,7 @@ extern "C" jint Java_com_acl_decompressor_MainActivity_nativeMain(JNIEnv* env, j
 	}
 
 	// Only decompress with a single configuration for now
-	configs.erase(std::remove_if(configs.begin(), configs.end(), [](const std::string& config_filename) { return config_filename != "uniformly_sampled_quant_var_2_medium.config.sjson"; }), configs.end());
+	configs.erase(std::remove_if(configs.begin(), configs.end(), [](const std::string& config_filename) { return config_filename != "uniformly_sampled_quant_medium.config.sjson"; }), configs.end());
 
 	const int num_configs = (int)configs.size();
 	const int num_clips = (int)clips.size();
diff --git a/tools/acl_decompressor/main_ios/main.cpp b/tools/acl_decompressor/main_ios/main.cpp
--- a/tools/acl_decompressor/main_ios/main.cpp
+++ b/tools/acl_decompressor/main_ios/main.cpp
@@ -107,7 +107,7 @@ int main(int argc, char* argv[])
 		return result;
 
 	// Only decompress with a single configuration for now
-	configs.erase(std::remove_if(configs.begin(), configs.end(), [](const std::string& config_filename) { return config_filename != "uniformly_sampled_quant_var_2_medium.config.sjson"; }), configs.end());
+	configs.erase(std::remove_if(configs.begin(), configs.end(), [](const std::string& config_filename) { return config_filename != "uniformly_sampled_quant_medium.config.sjson"; }), configs.end());
 
 	char output_directory[1024];
 	std::strcpy(output_directory, getenv("HOME"));
diff --git a/tools/format_reference.acl.sjson b/tools/format_reference.acl.sjson
--- a/tools/format_reference.acl.sjson
+++ b/tools/format_reference.acl.sjson
@@ -10,7 +10,8 @@
 // version = 1		// Initial version
 // version = 2		// Introduced clip compression settings
 //version = 3		// Introduced additive clip related data
-version = 4			// Introduced track list related data
+//version = 4		// Introduced track list related data
+version = 5			// Renamed enums for 2.0 and other related changes
 
 // BEGIN CLIP RELATED DATA
 
@@ -37,9 +38,9 @@ clip =
 	// Introduced in version 2.
 	is_binary_exact = true
 
-	// Additive format of base clip, if present. Optional, defaults to 'None'.
+	// Additive format of base clip, if present. Optional, defaults to 'none'.
 	// Introduced in version 3.
-	additive_format = "None"
+	additive_format = "none"
 
 	// The additive base clip name. Optional, defaults to empty string.
 	// Introduced in version 3.
@@ -59,28 +60,18 @@ clip =
 settings =
 {
 	// The name of the algorithm to use. See function get_algorithm_type(..)
-	// Defaults to 'UniformlySampled'
-	algorithm_name = "UniformlySampled"
+	// Defaults to 'uniformly_sampled'
+	algorithm_name = "uniformly_sampled"
 
 	// The rotation, translation, and scale formats to use. See functions get_rotation_format(..) and get_vector_format(..)
-	// Defaults to raw: 'Quat_128' and 'Vector3_96'
-	rotation_format = "Quat_128"
-	translation_format = "Vector3_96"
-	scale_format = "Vector3_96"
-
-	// Whether to use range reduction or not at the clip level
-	// Defaults to 'false'
-	rotation_range_reduction = false
-	translation_range_reduction = false
-	scale_range_reduction = false
+	// Defaults to raw: 'quatf_full' and 'vector3f_full'
+	rotation_format = "quatf_full"
+	translation_format = "vector3f_full"
+	scale_format = "vector3f_full"
 
 	// Settings used when segmenting clips
 	// Optional
 	segmenting = {
-		// Whether to enable segmenting or not
-		// Defaults to 'false'
-		enabled = false
-
 		// How many samples to try and fit in our segments
 		// Defaults to '16'
 		ideal_num_samples = 16
@@ -88,12 +79,6 @@ settings =
 		// Maximum number of samples per segment
 		// Defaults to '31'
 		max_num_samples = 31
-
-		// Whether to use range reduction or not at the segment level
-		// Defaults to 'false'
-		rotation_range_reduction = false
-		translation_range_reduction = false
-		scale_range_reduction = false
 	}
 
 	// Threshold angle value to use when detecting if a rotation track is constant


Test patch:
diff --git a/test_data/configs/uniformly_sampled_mixed_var_0.config.sjson b/test_data/configs/uniformly_sampled_mixed_var_0.config.sjson
new file mode 100644
--- /dev/null
+++ b/test_data/configs/uniformly_sampled_mixed_var_0.config.sjson
@@ -0,0 +1,11 @@
+version = 2
+
+algorithm_name = "uniformly_sampled"
+
+level = "Medium"
+
+rotation_format = "quatf_full"
+translation_format = "vector3f_variable"
+scale_format = "vector3f_variable"
+
+regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_mixed_var_1.config.sjson b/test_data/configs/uniformly_sampled_mixed_var_1.config.sjson
new file mode 100644
--- /dev/null
+++ b/test_data/configs/uniformly_sampled_mixed_var_1.config.sjson
@@ -0,0 +1,11 @@
+version = 2
+
+algorithm_name = "uniformly_sampled"
+
+level = "Medium"
+
+rotation_format = "quatf_drop_w_variable"
+translation_format = "vector3f_full"
+scale_format = "vector3f_variable"
+
+regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_quant_16_0.config.sjson b/test_data/configs/uniformly_sampled_quant_16_0.config.sjson
deleted file mode 100644
--- a/test_data/configs/uniformly_sampled_quant_16_0.config.sjson
+++ /dev/null
@@ -1,17 +0,0 @@
-version = 1
-
-algorithm_name = "UniformlySampled"
-
-rotation_format = "QuatDropW_48"
-translation_format = "Vector3_48"
-scale_format = "Vector3_48"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = false
-}
-
-regression_error_threshold = 1.0
diff --git a/test_data/configs/uniformly_sampled_quant_16_1.config.sjson b/test_data/configs/uniformly_sampled_quant_16_1.config.sjson
deleted file mode 100644
--- a/test_data/configs/uniformly_sampled_quant_16_1.config.sjson
+++ /dev/null
@@ -1,17 +0,0 @@
-version = 1
-
-algorithm_name = "UniformlySampled"
-
-rotation_format = "QuatDropW_48"
-translation_format = "Vector3_48"
-scale_format = "Vector3_48"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = true
-}
-
-regression_error_threshold = 1.0
diff --git a/test_data/configs/uniformly_sampled_quant_16_2.config.sjson b/test_data/configs/uniformly_sampled_quant_16_2.config.sjson
deleted file mode 100644
--- a/test_data/configs/uniformly_sampled_quant_16_2.config.sjson
+++ /dev/null
@@ -1,21 +0,0 @@
-version = 1
-
-algorithm_name = "UniformlySampled"
-
-rotation_format = "QuatDropW_48"
-translation_format = "Vector3_48"
-scale_format = "Vector3_48"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = true
-
-	rotation_range_reduction = true
-	translation_range_reduction = true
-	scale_range_reduction = true
-}
-
-regression_error_threshold = 1.0
diff --git a/test_data/configs/uniformly_sampled_quant_bind_relative.config.sjson b/test_data/configs/uniformly_sampled_quant_bind_relative.config.sjson
--- a/test_data/configs/uniformly_sampled_quant_bind_relative.config.sjson
+++ b/test_data/configs/uniformly_sampled_quant_bind_relative.config.sjson
@@ -1,24 +1,12 @@
-version = 1
+version = 2
 
-algorithm_name = "UniformlySampled"
+algorithm_name = "uniformly_sampled"
 
 level = "Medium"
 
-rotation_format = "QuatDropW_Variable"
-translation_format = "Vector3_Variable"
-scale_format = "Vector3_Variable"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = true
-
-	rotation_range_reduction = true
-	translation_range_reduction = true
-	scale_range_reduction = true
-}
+rotation_format = "quatf_drop_w_variable"
+translation_format = "vector3f_variable"
+scale_format = "vector3f_variable"
 
 regression_error_threshold = 0.075
 is_bind_pose_relative = true
diff --git a/test_data/configs/uniformly_sampled_quant_high.config.sjson b/test_data/configs/uniformly_sampled_quant_high.config.sjson
new file mode 100644
--- /dev/null
+++ b/test_data/configs/uniformly_sampled_quant_high.config.sjson
@@ -0,0 +1,11 @@
+version = 2
+
+algorithm_name = "uniformly_sampled"
+
+level = "High"
+
+rotation_format = "quatf_drop_w_variable"
+translation_format = "vector3f_variable"
+scale_format = "vector3f_variable"
+
+regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_quant_highest.config.sjson b/test_data/configs/uniformly_sampled_quant_highest.config.sjson
new file mode 100644
--- /dev/null
+++ b/test_data/configs/uniformly_sampled_quant_highest.config.sjson
@@ -0,0 +1,11 @@
+version = 2
+
+algorithm_name = "uniformly_sampled"
+
+level = "Highest"
+
+rotation_format = "quatf_drop_w_variable"
+translation_format = "vector3f_variable"
+scale_format = "vector3f_variable"
+
+regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_quant_medium.config.sjson b/test_data/configs/uniformly_sampled_quant_medium.config.sjson
new file mode 100644
--- /dev/null
+++ b/test_data/configs/uniformly_sampled_quant_medium.config.sjson
@@ -0,0 +1,11 @@
+version = 2
+
+algorithm_name = "uniformly_sampled"
+
+level = "Medium"
+
+rotation_format = "quatf_drop_w_variable"
+translation_format = "vector3f_variable"
+scale_format = "vector3f_variable"
+
+regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_quant_mtx_error.config.sjson b/test_data/configs/uniformly_sampled_quant_mtx_error.config.sjson
--- a/test_data/configs/uniformly_sampled_quant_mtx_error.config.sjson
+++ b/test_data/configs/uniformly_sampled_quant_mtx_error.config.sjson
@@ -1,24 +1,12 @@
-version = 1
+version = 2
 
-algorithm_name = "UniformlySampled"
+algorithm_name = "uniformly_sampled"
 
 level = "Medium"
 
-rotation_format = "QuatDropW_Variable"
-translation_format = "Vector3_Variable"
-scale_format = "Vector3_Variable"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = true
-
-	rotation_range_reduction = true
-	translation_range_reduction = true
-	scale_range_reduction = true
-}
+rotation_format = "quatf_drop_w_variable"
+translation_format = "vector3f_variable"
+scale_format = "vector3f_variable"
 
 regression_error_threshold = 0.075
 use_matrix_error_metric = true
diff --git a/test_data/configs/uniformly_sampled_quant_var_0_high.config.sjson b/test_data/configs/uniformly_sampled_quant_var_0_high.config.sjson
deleted file mode 100644
--- a/test_data/configs/uniformly_sampled_quant_var_0_high.config.sjson
+++ /dev/null
@@ -1,19 +0,0 @@
-version = 1
-
-algorithm_name = "UniformlySampled"
-
-level = "High"
-
-rotation_format = "QuatDropW_Variable"
-translation_format = "Vector3_Variable"
-scale_format = "Vector3_Variable"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = false
-}
-
-regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_quant_var_0_highest.config.sjson b/test_data/configs/uniformly_sampled_quant_var_0_highest.config.sjson
deleted file mode 100644
--- a/test_data/configs/uniformly_sampled_quant_var_0_highest.config.sjson
+++ /dev/null
@@ -1,19 +0,0 @@
-version = 1
-
-algorithm_name = "UniformlySampled"
-
-level = "Highest"
-
-rotation_format = "QuatDropW_Variable"
-translation_format = "Vector3_Variable"
-scale_format = "Vector3_Variable"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = false
-}
-
-regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_quant_var_0_medium.config.sjson b/test_data/configs/uniformly_sampled_quant_var_0_medium.config.sjson
deleted file mode 100644
--- a/test_data/configs/uniformly_sampled_quant_var_0_medium.config.sjson
+++ /dev/null
@@ -1,19 +0,0 @@
-version = 1
-
-algorithm_name = "UniformlySampled"
-
-level = "Medium"
-
-rotation_format = "QuatDropW_Variable"
-translation_format = "Vector3_Variable"
-scale_format = "Vector3_Variable"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = false
-}
-
-regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_quant_var_1_high.config.sjson b/test_data/configs/uniformly_sampled_quant_var_1_high.config.sjson
deleted file mode 100644
--- a/test_data/configs/uniformly_sampled_quant_var_1_high.config.sjson
+++ /dev/null
@@ -1,19 +0,0 @@
-version = 1
-
-algorithm_name = "UniformlySampled"
-
-level = "High"
-
-rotation_format = "QuatDropW_Variable"
-translation_format = "Vector3_Variable"
-scale_format = "Vector3_Variable"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = true
-}
-
-regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_quant_var_1_highest.config.sjson b/test_data/configs/uniformly_sampled_quant_var_1_highest.config.sjson
deleted file mode 100644
--- a/test_data/configs/uniformly_sampled_quant_var_1_highest.config.sjson
+++ /dev/null
@@ -1,19 +0,0 @@
-version = 1
-
-algorithm_name = "UniformlySampled"
-
-level = "Highest"
-
-rotation_format = "QuatDropW_Variable"
-translation_format = "Vector3_Variable"
-scale_format = "Vector3_Variable"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = true
-}
-
-regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_quant_var_1_medium.config.sjson b/test_data/configs/uniformly_sampled_quant_var_1_medium.config.sjson
deleted file mode 100644
--- a/test_data/configs/uniformly_sampled_quant_var_1_medium.config.sjson
+++ /dev/null
@@ -1,19 +0,0 @@
-version = 1
-
-algorithm_name = "UniformlySampled"
-
-level = "Medium"
-
-rotation_format = "QuatDropW_Variable"
-translation_format = "Vector3_Variable"
-scale_format = "Vector3_Variable"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = true
-}
-
-regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_quant_var_2_high.config.sjson b/test_data/configs/uniformly_sampled_quant_var_2_high.config.sjson
deleted file mode 100644
--- a/test_data/configs/uniformly_sampled_quant_var_2_high.config.sjson
+++ /dev/null
@@ -1,23 +0,0 @@
-version = 1
-
-algorithm_name = "UniformlySampled"
-
-level = "High"
-
-rotation_format = "QuatDropW_Variable"
-translation_format = "Vector3_Variable"
-scale_format = "Vector3_Variable"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = true
-
-	rotation_range_reduction = true
-	translation_range_reduction = true
-	scale_range_reduction = true
-}
-
-regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_quant_var_2_highest.config.sjson b/test_data/configs/uniformly_sampled_quant_var_2_highest.config.sjson
deleted file mode 100644
--- a/test_data/configs/uniformly_sampled_quant_var_2_highest.config.sjson
+++ /dev/null
@@ -1,23 +0,0 @@
-version = 1
-
-algorithm_name = "UniformlySampled"
-
-level = "Highest"
-
-rotation_format = "QuatDropW_Variable"
-translation_format = "Vector3_Variable"
-scale_format = "Vector3_Variable"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = true
-
-	rotation_range_reduction = true
-	translation_range_reduction = true
-	scale_range_reduction = true
-}
-
-regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_quant_var_2_medium.config.sjson b/test_data/configs/uniformly_sampled_quant_var_2_medium.config.sjson
deleted file mode 100644
--- a/test_data/configs/uniformly_sampled_quant_var_2_medium.config.sjson
+++ /dev/null
@@ -1,23 +0,0 @@
-version = 1
-
-algorithm_name = "UniformlySampled"
-
-level = "Medium"
-
-rotation_format = "QuatDropW_Variable"
-translation_format = "Vector3_Variable"
-scale_format = "Vector3_Variable"
-
-rotation_range_reduction = true
-translation_range_reduction = true
-scale_range_reduction = true
-
-segmenting = {
-	enabled = true
-
-	rotation_range_reduction = true
-	translation_range_reduction = true
-	scale_range_reduction = true
-}
-
-regression_error_threshold = 0.075
diff --git a/test_data/configs/uniformly_sampled_raw.config.sjson b/test_data/configs/uniformly_sampled_raw.config.sjson
--- a/test_data/configs/uniformly_sampled_raw.config.sjson
+++ b/test_data/configs/uniformly_sampled_raw.config.sjson
@@ -1,13 +1,9 @@
-version = 1
+version = 2
 
-algorithm_name = "UniformlySampled"
+algorithm_name = "uniformly_sampled"
 
-rotation_format = "Quat_128"
-translation_format = "Vector3_96"
-scale_format = "Vector3_96"
+rotation_format = "quatf_full"
+translation_format = "vector3f_full"
+scale_format = "vector3f_full"
 
-segmenting = {
-	enabled = false
-}
-
-regression_error_threshold = 0.01
+regression_error_threshold = 0.001
diff --git a/test_data/reference.config.sjson b/test_data/reference.config.sjson
--- a/test_data/reference.config.sjson
+++ b/test_data/reference.config.sjson
@@ -1,35 +1,16 @@
 // A version identifier, make sure to use the latest supported number
-version = 1
+//version = 1		// initial version
+version = 2		// cleanup with 2.0
 
 // The name of the algorithm to use. See function get_algorithm_type(..)
 // Required
-algorithm_name = "UniformlySampled"
+algorithm_name = "uniformly_sampled"
 
 // The rotation, translation, and scale formats to use. See functions get_rotation_format(..) and get_vector_format(..)
-// Defaults to raw: Quat_128 and Vector3_96
-rotation_format = "Quat_128"
-translation_format = "Vector3_96"
-scale_format = "Vector3_96"
-
-// Whether to use range reduction or not at the clip level
-// Defaults to 'false'
-rotation_range_reduction = false
-translation_range_reduction = false
-scale_range_reduction = false
-
-// Settings used when segmenting clips
-// Optional
-segmenting = {
-	// Whether to enable segmenting or not
-	// Defaults to 'false'
-	enabled = false
-
-	// Whether to use range reduction or not at the segment level
-	// Defaults to 'false'
-	rotation_range_reduction = false
-	translation_range_reduction = false
-	scale_range_reduction = false
-}
+// Defaults to raw: quatf_full and vector3f_full
+rotation_format = "quatf_full"
+translation_format = "vector3f_full"
+scale_format = "vector3f_full"
 
 // Threshold angle value to use when detecting if a rotation track is constant
 // Defaults to '0.00284714461' radians
diff --git a/tests/sources/core/test_ansi_allocator.cpp b/tests/sources/core/test_ansi_allocator.cpp
--- a/tests/sources/core/test_ansi_allocator.cpp
+++ b/tests/sources/core/test_ansi_allocator.cpp
@@ -36,17 +36,17 @@ using namespace acl;
 TEST_CASE("ANSI allocator", "[core][memory]")
 {
 	ANSIAllocator allocator;
-	REQUIRE(allocator.get_allocation_count() == 0);
+	CHECK(allocator.get_allocation_count() == 0);
 
 	void* ptr0 = allocator.allocate(32);
-	REQUIRE(allocator.get_allocation_count() == 1);
+	CHECK(allocator.get_allocation_count() == 1);
 
 	void* ptr1 = allocator.allocate(48, 256);
-	REQUIRE(allocator.get_allocation_count() == 2);
-	REQUIRE(is_aligned_to(ptr1, 256));
+	CHECK(allocator.get_allocation_count() == 2);
+	CHECK(is_aligned_to(ptr1, 256));
 	allocator.deallocate(ptr1, 48);
-	REQUIRE(allocator.get_allocation_count() == 1);
+	CHECK(allocator.get_allocation_count() == 1);
 
 	allocator.deallocate(ptr0, 32);
-	REQUIRE(allocator.get_allocation_count() == 0);
+	CHECK(allocator.get_allocation_count() == 0);
 }
diff --git a/tests/sources/core/test_bit_manip_utils.cpp b/tests/sources/core/test_bit_manip_utils.cpp
--- a/tests/sources/core/test_bit_manip_utils.cpp
+++ b/tests/sources/core/test_bit_manip_utils.cpp
@@ -30,34 +30,34 @@ using namespace acl;
 
 TEST_CASE("bit_manip_utils", "[core][utils]")
 {
-	REQUIRE(count_set_bits(uint8_t(0x00)) == 0);
-	REQUIRE(count_set_bits(uint8_t(0x01)) == 1);
-	REQUIRE(count_set_bits(uint8_t(0x10)) == 1);
-	REQUIRE(count_set_bits(uint8_t(0xFF)) == 8);
-
-	REQUIRE(count_set_bits(uint16_t(0x0000)) == 0);
-	REQUIRE(count_set_bits(uint16_t(0x0001)) == 1);
-	REQUIRE(count_set_bits(uint16_t(0x1000)) == 1);
-	REQUIRE(count_set_bits(uint16_t(0x1001)) == 2);
-	REQUIRE(count_set_bits(uint16_t(0xFFFF)) == 16);
-
-	REQUIRE(count_set_bits(uint32_t(0x00000000)) == 0);
-	REQUIRE(count_set_bits(uint32_t(0x00000001)) == 1);
-	REQUIRE(count_set_bits(uint32_t(0x10000000)) == 1);
-	REQUIRE(count_set_bits(uint32_t(0x10101001)) == 4);
-	REQUIRE(count_set_bits(uint32_t(0xFFFFFFFF)) == 32);
-
-	REQUIRE(count_set_bits(uint64_t(0x0000000000000000ULL)) == 0);
-	REQUIRE(count_set_bits(uint64_t(0x0000000000000001ULL)) == 1);
-	REQUIRE(count_set_bits(uint64_t(0x1000000000000000ULL)) == 1);
-	REQUIRE(count_set_bits(uint64_t(0x1000100001010101ULL)) == 6);
-	REQUIRE(count_set_bits(uint64_t(0xFFFFFFFFFFFFFFFFULL)) == 64);
-
-	REQUIRE(rotate_bits_left(0x00000010, 0) == 0x00000010);
-	REQUIRE(rotate_bits_left(0x10000010, 1) == 0x20000020);
-	REQUIRE(rotate_bits_left(0x10000010, 2) == 0x40000040);
-	REQUIRE(rotate_bits_left(0x10000010, 3) == 0x80000080);
-	REQUIRE(rotate_bits_left(0x10000010, 4) == 0x00000101);
-
-	REQUIRE(and_not(0x00000010, 0x10101011) == 0x10101001);
+	CHECK(count_set_bits(uint8_t(0x00)) == 0);
+	CHECK(count_set_bits(uint8_t(0x01)) == 1);
+	CHECK(count_set_bits(uint8_t(0x10)) == 1);
+	CHECK(count_set_bits(uint8_t(0xFF)) == 8);
+
+	CHECK(count_set_bits(uint16_t(0x0000)) == 0);
+	CHECK(count_set_bits(uint16_t(0x0001)) == 1);
+	CHECK(count_set_bits(uint16_t(0x1000)) == 1);
+	CHECK(count_set_bits(uint16_t(0x1001)) == 2);
+	CHECK(count_set_bits(uint16_t(0xFFFF)) == 16);
+
+	CHECK(count_set_bits(uint32_t(0x00000000)) == 0);
+	CHECK(count_set_bits(uint32_t(0x00000001)) == 1);
+	CHECK(count_set_bits(uint32_t(0x10000000)) == 1);
+	CHECK(count_set_bits(uint32_t(0x10101001)) == 4);
+	CHECK(count_set_bits(uint32_t(0xFFFFFFFF)) == 32);
+
+	CHECK(count_set_bits(uint64_t(0x0000000000000000ULL)) == 0);
+	CHECK(count_set_bits(uint64_t(0x0000000000000001ULL)) == 1);
+	CHECK(count_set_bits(uint64_t(0x1000000000000000ULL)) == 1);
+	CHECK(count_set_bits(uint64_t(0x1000100001010101ULL)) == 6);
+	CHECK(count_set_bits(uint64_t(0xFFFFFFFFFFFFFFFFULL)) == 64);
+
+	CHECK(rotate_bits_left(0x00000010, 0) == 0x00000010);
+	CHECK(rotate_bits_left(0x10000010, 1) == 0x20000020);
+	CHECK(rotate_bits_left(0x10000010, 2) == 0x40000040);
+	CHECK(rotate_bits_left(0x10000010, 3) == 0x80000080);
+	CHECK(rotate_bits_left(0x10000010, 4) == 0x00000101);
+
+	CHECK(and_not(0x00000010, 0x10101011) == 0x10101001);
 }
diff --git a/tests/sources/core/test_enum_utils.cpp b/tests/sources/core/test_enum_utils.cpp
--- a/tests/sources/core/test_enum_utils.cpp
+++ b/tests/sources/core/test_enum_utils.cpp
@@ -43,13 +43,13 @@ ACL_IMPL_ENUM_FLAGS_OPERATORS(TestEnum)
 
 TEST_CASE("enum utils", "[core][utils]")
 {
-	REQUIRE(are_any_enum_flags_set(TestEnum::One | TestEnum::Two, TestEnum::All) == true);
-	REQUIRE(are_any_enum_flags_set(TestEnum::One | TestEnum::Two, TestEnum::One) == true);
-	REQUIRE(are_any_enum_flags_set(TestEnum::All, TestEnum::One | TestEnum::Two) == true);
-	REQUIRE(are_any_enum_flags_set(TestEnum::One | TestEnum::Two, TestEnum::Four) == false);
-
-	REQUIRE(are_all_enum_flags_set(TestEnum::One | TestEnum::Two, TestEnum::One | TestEnum::Two) == true);
-	REQUIRE(are_all_enum_flags_set(TestEnum::One, TestEnum::One | TestEnum::Two) == false);
-	REQUIRE(are_all_enum_flags_set(TestEnum::One | TestEnum::Two, TestEnum::One) == true);
-	REQUIRE(are_all_enum_flags_set(TestEnum::One | TestEnum::Two, TestEnum::All) == false);
+	CHECK(are_any_enum_flags_set(TestEnum::One | TestEnum::Two, TestEnum::All) == true);
+	CHECK(are_any_enum_flags_set(TestEnum::One | TestEnum::Two, TestEnum::One) == true);
+	CHECK(are_any_enum_flags_set(TestEnum::All, TestEnum::One | TestEnum::Two) == true);
+	CHECK(are_any_enum_flags_set(TestEnum::One | TestEnum::Two, TestEnum::Four) == false);
+
+	CHECK(are_all_enum_flags_set(TestEnum::One | TestEnum::Two, TestEnum::One | TestEnum::Two) == true);
+	CHECK(are_all_enum_flags_set(TestEnum::One, TestEnum::One | TestEnum::Two) == false);
+	CHECK(are_all_enum_flags_set(TestEnum::One | TestEnum::Two, TestEnum::One) == true);
+	CHECK(are_all_enum_flags_set(TestEnum::One | TestEnum::Two, TestEnum::All) == false);
 }
diff --git a/tests/sources/core/test_error_result.cpp b/tests/sources/core/test_error_result.cpp
--- a/tests/sources/core/test_error_result.cpp
+++ b/tests/sources/core/test_error_result.cpp
@@ -33,18 +33,18 @@ using namespace acl;
 
 TEST_CASE("ErrorResult", "[core][error]")
 {
-	REQUIRE(ErrorResult().any() == false);
-	REQUIRE(ErrorResult().empty() == true);
-	REQUIRE(std::strlen(ErrorResult().c_str()) == 0);
+	CHECK(ErrorResult().any() == false);
+	CHECK(ErrorResult().empty() == true);
+	CHECK(std::strlen(ErrorResult().c_str()) == 0);
 
-	REQUIRE(ErrorResult("failed").any() == true);
-	REQUIRE(ErrorResult("failed").empty() == false);
-	REQUIRE(std::strcmp(ErrorResult("failed").c_str(), "failed") == 0);
+	CHECK(ErrorResult("failed").any() == true);
+	CHECK(ErrorResult("failed").empty() == false);
+	CHECK(std::strcmp(ErrorResult("failed").c_str(), "failed") == 0);
 
 	ErrorResult tmp("failed");
-	REQUIRE(tmp.any() == true);
+	CHECK(tmp.any() == true);
 	tmp.reset();
-	REQUIRE(tmp.any() == false);
-	REQUIRE(tmp.empty() == true);
-	REQUIRE(std::strlen(tmp.c_str()) == 0);
+	CHECK(tmp.any() == false);
+	CHECK(tmp.empty() == true);
+	CHECK(std::strlen(tmp.c_str()) == 0);
 }
diff --git a/tests/sources/core/test_interpolation_utils.cpp b/tests/sources/core/test_interpolation_utils.cpp
--- a/tests/sources/core/test_interpolation_utils.cpp
+++ b/tests/sources/core/test_interpolation_utils.cpp
@@ -37,101 +37,101 @@ TEST_CASE("interpolation utils", "[core][utils]")
 	uint32_t key0;
 	uint32_t key1;
 	float alpha;
-	find_linear_interpolation_samples_with_duration(31, 1.0F, 0.0F, SampleRoundingPolicy::None, key0, key1, alpha);
+	find_linear_interpolation_samples_with_duration(31, 1.0F, 0.0F, sample_rounding_policy::none, key0, key1, alpha);
 
-	REQUIRE(key0 == 0);
-	REQUIRE(key1 == 1);
-	REQUIRE(scalar_near_equal(alpha, 0.0F, error_threshold));
+	CHECK(key0 == 0);
+	CHECK(key1 == 1);
+	CHECK(scalar_near_equal(alpha, 0.0F, error_threshold));
 
-	find_linear_interpolation_samples_with_duration(31, 1.0F, 1.0F / 30.0F, SampleRoundingPolicy::None, key0, key1, alpha);
+	find_linear_interpolation_samples_with_duration(31, 1.0F, 1.0F / 30.0F, sample_rounding_policy::none, key0, key1, alpha);
 
-	REQUIRE(key0 == 1);
-	REQUIRE(key1 == 2);
-	REQUIRE(scalar_near_equal(alpha, 0.0F, error_threshold));
+	CHECK(key0 == 1);
+	CHECK(key1 == 2);
+	CHECK(scalar_near_equal(alpha, 0.0F, error_threshold));
 
-	find_linear_interpolation_samples_with_duration(31, 1.0F, 2.5F / 30.0F, SampleRoundingPolicy::None, key0, key1, alpha);
+	find_linear_interpolation_samples_with_duration(31, 1.0F, 2.5F / 30.0F, sample_rounding_policy::none, key0, key1, alpha);
 
-	REQUIRE(key0 == 2);
-	REQUIRE(key1 == 3);
-	REQUIRE(scalar_near_equal(alpha, 0.5F, error_threshold));
+	CHECK(key0 == 2);
+	CHECK(key1 == 3);
+	CHECK(scalar_near_equal(alpha, 0.5F, error_threshold));
 
-	find_linear_interpolation_samples_with_duration(31, 1.0F, 1.0F, SampleRoundingPolicy::None, key0, key1, alpha);
+	find_linear_interpolation_samples_with_duration(31, 1.0F, 1.0F, sample_rounding_policy::none, key0, key1, alpha);
 
-	REQUIRE(key0 == 30);
-	REQUIRE(key1 == 30);
-	REQUIRE(scalar_near_equal(alpha, 0.0F, error_threshold));
+	CHECK(key0 == 30);
+	CHECK(key1 == 30);
+	CHECK(scalar_near_equal(alpha, 0.0F, error_threshold));
 
-	find_linear_interpolation_samples_with_duration(31, 1.0F, 2.5F / 30.0F, SampleRoundingPolicy::Floor, key0, key1, alpha);
+	find_linear_interpolation_samples_with_duration(31, 1.0F, 2.5F / 30.0F, sample_rounding_policy::floor, key0, key1, alpha);
 
-	REQUIRE(key0 == 2);
-	REQUIRE(key1 == 3);
-	REQUIRE(scalar_near_equal(alpha, 0.0F, error_threshold));
+	CHECK(key0 == 2);
+	CHECK(key1 == 3);
+	CHECK(scalar_near_equal(alpha, 0.0F, error_threshold));
 
-	find_linear_interpolation_samples_with_duration(31, 1.0F, 2.5F / 30.0F, SampleRoundingPolicy::Ceil, key0, key1, alpha);
+	find_linear_interpolation_samples_with_duration(31, 1.0F, 2.5F / 30.0F, sample_rounding_policy::ceil, key0, key1, alpha);
 
-	REQUIRE(key0 == 2);
-	REQUIRE(key1 == 3);
-	REQUIRE(scalar_near_equal(alpha, 1.0F, error_threshold));
+	CHECK(key0 == 2);
+	CHECK(key1 == 3);
+	CHECK(scalar_near_equal(alpha, 1.0F, error_threshold));
 
-	find_linear_interpolation_samples_with_duration(31, 1.0F, 2.4F / 30.0F, SampleRoundingPolicy::Nearest, key0, key1, alpha);
+	find_linear_interpolation_samples_with_duration(31, 1.0F, 2.4F / 30.0F, sample_rounding_policy::nearest, key0, key1, alpha);
 
-	REQUIRE(key0 == 2);
-	REQUIRE(key1 == 3);
-	REQUIRE(scalar_near_equal(alpha, 0.0F, error_threshold));
+	CHECK(key0 == 2);
+	CHECK(key1 == 3);
+	CHECK(scalar_near_equal(alpha, 0.0F, error_threshold));
 
-	find_linear_interpolation_samples_with_duration(31, 1.0F, 2.6F / 30.0F, SampleRoundingPolicy::Nearest, key0, key1, alpha);
+	find_linear_interpolation_samples_with_duration(31, 1.0F, 2.6F / 30.0F, sample_rounding_policy::nearest, key0, key1, alpha);
 
-	REQUIRE(key0 == 2);
-	REQUIRE(key1 == 3);
-	REQUIRE(scalar_near_equal(alpha, 1.0F, error_threshold));
+	CHECK(key0 == 2);
+	CHECK(key1 == 3);
+	CHECK(scalar_near_equal(alpha, 1.0F, error_threshold));
 
 	//////////////////////////////////////////////////////////////////////////
 
-	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 0.0F, SampleRoundingPolicy::None, key0, key1, alpha);
+	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 0.0F, sample_rounding_policy::none, key0, key1, alpha);
 
-	REQUIRE(key0 == 0);
-	REQUIRE(key1 == 1);
-	REQUIRE(scalar_near_equal(alpha, 0.0F, error_threshold));
+	CHECK(key0 == 0);
+	CHECK(key1 == 1);
+	CHECK(scalar_near_equal(alpha, 0.0F, error_threshold));
 
-	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 1.0F / 30.0F, SampleRoundingPolicy::None, key0, key1, alpha);
+	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 1.0F / 30.0F, sample_rounding_policy::none, key0, key1, alpha);
 
-	REQUIRE(key0 == 1);
-	REQUIRE(key1 == 2);
-	REQUIRE(scalar_near_equal(alpha, 0.0F, error_threshold));
+	CHECK(key0 == 1);
+	CHECK(key1 == 2);
+	CHECK(scalar_near_equal(alpha, 0.0F, error_threshold));
 
-	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 2.5F / 30.0F, SampleRoundingPolicy::None, key0, key1, alpha);
+	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 2.5F / 30.0F, sample_rounding_policy::none, key0, key1, alpha);
 
-	REQUIRE(key0 == 2);
-	REQUIRE(key1 == 3);
-	REQUIRE(scalar_near_equal(alpha, 0.5F, error_threshold));
+	CHECK(key0 == 2);
+	CHECK(key1 == 3);
+	CHECK(scalar_near_equal(alpha, 0.5F, error_threshold));
 
-	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 1.0F, SampleRoundingPolicy::None, key0, key1, alpha);
+	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 1.0F, sample_rounding_policy::none, key0, key1, alpha);
 
-	REQUIRE(key0 == 30);
-	REQUIRE(key1 == 30);
-	REQUIRE(scalar_near_equal(alpha, 0.0F, error_threshold));
+	CHECK(key0 == 30);
+	CHECK(key1 == 30);
+	CHECK(scalar_near_equal(alpha, 0.0F, error_threshold));
 
-	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 2.5F / 30.0F, SampleRoundingPolicy::Floor, key0, key1, alpha);
+	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 2.5F / 30.0F, sample_rounding_policy::floor, key0, key1, alpha);
 
-	REQUIRE(key0 == 2);
-	REQUIRE(key1 == 3);
-	REQUIRE(scalar_near_equal(alpha, 0.0F, error_threshold));
+	CHECK(key0 == 2);
+	CHECK(key1 == 3);
+	CHECK(scalar_near_equal(alpha, 0.0F, error_threshold));
 
-	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 2.5F / 30.0F, SampleRoundingPolicy::Ceil, key0, key1, alpha);
+	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 2.5F / 30.0F, sample_rounding_policy::ceil, key0, key1, alpha);
 
-	REQUIRE(key0 == 2);
-	REQUIRE(key1 == 3);
-	REQUIRE(scalar_near_equal(alpha, 1.0F, error_threshold));
+	CHECK(key0 == 2);
+	CHECK(key1 == 3);
+	CHECK(scalar_near_equal(alpha, 1.0F, error_threshold));
 
-	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 2.4F / 30.0F, SampleRoundingPolicy::Nearest, key0, key1, alpha);
+	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 2.4F / 30.0F, sample_rounding_policy::nearest, key0, key1, alpha);
 
-	REQUIRE(key0 == 2);
-	REQUIRE(key1 == 3);
-	REQUIRE(scalar_near_equal(alpha, 0.0F, error_threshold));
+	CHECK(key0 == 2);
+	CHECK(key1 == 3);
+	CHECK(scalar_near_equal(alpha, 0.0F, error_threshold));
 
-	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 2.6F / 30.0F, SampleRoundingPolicy::Nearest, key0, key1, alpha);
+	find_linear_interpolation_samples_with_sample_rate(31, 30.0F, 2.6F / 30.0F, sample_rounding_policy::nearest, key0, key1, alpha);
 
-	REQUIRE(key0 == 2);
-	REQUIRE(key1 == 3);
-	REQUIRE(scalar_near_equal(alpha, 1.0F, error_threshold));
+	CHECK(key0 == 2);
+	CHECK(key1 == 3);
+	CHECK(scalar_near_equal(alpha, 1.0F, error_threshold));
 }
diff --git a/tests/sources/core/test_iterator.cpp b/tests/sources/core/test_iterator.cpp
--- a/tests/sources/core/test_iterator.cpp
+++ b/tests/sources/core/test_iterator.cpp
@@ -40,21 +40,21 @@ TEST_CASE("iterator", "[core][iterator]")
 
 	SECTION("mutable returns correct type")
 	{
-		REQUIRE(std::is_same<uint32_t*, decltype(i.begin())>::value);
-		REQUIRE(std::is_same<uint32_t*, decltype(i.end())>::value);
+		CHECK(std::is_same<uint32_t*, decltype(i.begin())>::value);
+		CHECK(std::is_same<uint32_t*, decltype(i.end())>::value);
 	}
 
 	SECTION("const returns correct type")
 	{
 		auto ci = ConstIterator<uint32_t>(items, num_items);
 
-		REQUIRE(std::is_same<const uint32_t*, decltype(ci.begin())>::value);
-		REQUIRE(std::is_same<const uint32_t*, decltype(ci.end())>::value);
+		CHECK(std::is_same<const uint32_t*, decltype(ci.begin())>::value);
+		CHECK(std::is_same<const uint32_t*, decltype(ci.end())>::value);
 	}
 
 	SECTION("bounds are correct")
 	{
-		REQUIRE(i.begin() == items + 0);
-		REQUIRE(i.end() == items + num_items);
+		CHECK(i.begin() == items + 0);
+		CHECK(i.end() == items + num_items);
 	}
 }
diff --git a/tests/sources/core/test_memory_utils.cpp b/tests/sources/core/test_memory_utils.cpp
--- a/tests/sources/core/test_memory_utils.cpp
+++ b/tests/sources/core/test_memory_utils.cpp
@@ -41,32 +41,32 @@ TEST_CASE("misc tests", "[core][memory]")
 			num_powers_of_two++;
 	}
 
-	REQUIRE(num_powers_of_two == 17);
-	REQUIRE(is_power_of_two(1) == true);
-	REQUIRE(is_power_of_two(2) == true);
-	REQUIRE(is_power_of_two(4) == true);
-	REQUIRE(is_power_of_two(8) == true);
-	REQUIRE(is_power_of_two(16) == true);
-	REQUIRE(is_power_of_two(32) == true);
-	REQUIRE(is_power_of_two(64) == true);
-	REQUIRE(is_power_of_two(128) == true);
-	REQUIRE(is_power_of_two(256) == true);
-	REQUIRE(is_power_of_two(512) == true);
-	REQUIRE(is_power_of_two(1024) == true);
-	REQUIRE(is_power_of_two(2048) == true);
-	REQUIRE(is_power_of_two(4096) == true);
-	REQUIRE(is_power_of_two(8192) == true);
-	REQUIRE(is_power_of_two(16384) == true);
-	REQUIRE(is_power_of_two(32768) == true);
-	REQUIRE(is_power_of_two(65536) == true);
-
-	REQUIRE(is_alignment_valid<int32_t>(0) == false);
-	REQUIRE(is_alignment_valid<int32_t>(4) == true);
-	REQUIRE(is_alignment_valid<int32_t>(8) == true);
-	REQUIRE(is_alignment_valid<int32_t>(2) == false);
-	REQUIRE(is_alignment_valid<int32_t>(5) == false);
-	REQUIRE(is_alignment_valid<int64_t>(8) == true);
-	REQUIRE(is_alignment_valid<int64_t>(16) == true);
+	CHECK(num_powers_of_two == 17);
+	CHECK(is_power_of_two(1) == true);
+	CHECK(is_power_of_two(2) == true);
+	CHECK(is_power_of_two(4) == true);
+	CHECK(is_power_of_two(8) == true);
+	CHECK(is_power_of_two(16) == true);
+	CHECK(is_power_of_two(32) == true);
+	CHECK(is_power_of_two(64) == true);
+	CHECK(is_power_of_two(128) == true);
+	CHECK(is_power_of_two(256) == true);
+	CHECK(is_power_of_two(512) == true);
+	CHECK(is_power_of_two(1024) == true);
+	CHECK(is_power_of_two(2048) == true);
+	CHECK(is_power_of_two(4096) == true);
+	CHECK(is_power_of_two(8192) == true);
+	CHECK(is_power_of_two(16384) == true);
+	CHECK(is_power_of_two(32768) == true);
+	CHECK(is_power_of_two(65536) == true);
+
+	CHECK(is_alignment_valid<int32_t>(0) == false);
+	CHECK(is_alignment_valid<int32_t>(4) == true);
+	CHECK(is_alignment_valid<int32_t>(8) == true);
+	CHECK(is_alignment_valid<int32_t>(2) == false);
+	CHECK(is_alignment_valid<int32_t>(5) == false);
+	CHECK(is_alignment_valid<int64_t>(8) == true);
+	CHECK(is_alignment_valid<int64_t>(16) == true);
 
 	struct alignas(8) Tmp
 	{
@@ -74,34 +74,34 @@ TEST_CASE("misc tests", "[core][memory]")
 		int32_t value;		// Aligned to 4 bytes
 	};
 	Tmp tmp;
-	REQUIRE(is_aligned_to(&tmp.padding, 8) == true);
-	REQUIRE(is_aligned_to(&tmp.value, 4) == true);
-	REQUIRE(is_aligned_to(&tmp.value, 2) == true);
-	REQUIRE(is_aligned_to(&tmp.value, 1) == true);
-	REQUIRE(is_aligned_to(&tmp.value, 8) == false);
-
-	REQUIRE(is_aligned_to(4, 4) == true);
-	REQUIRE(is_aligned_to(4, 2) == true);
-	REQUIRE(is_aligned_to(4, 1) == true);
-	REQUIRE(is_aligned_to(4, 8) == false);
-	REQUIRE(is_aligned_to(6, 4) == false);
-	REQUIRE(is_aligned_to(6, 2) == true);
-	REQUIRE(is_aligned_to(6, 1) == true);
-
-	REQUIRE(is_aligned_to(align_to(5, 4), 4) == true);
-	REQUIRE(align_to(5, 4) == 8);
-	REQUIRE(is_aligned_to(align_to(8, 4), 4) == true);
-	REQUIRE(align_to(8, 4) == 8);
+	CHECK(is_aligned_to(&tmp.padding, 8) == true);
+	CHECK(is_aligned_to(&tmp.value, 4) == true);
+	CHECK(is_aligned_to(&tmp.value, 2) == true);
+	CHECK(is_aligned_to(&tmp.value, 1) == true);
+	CHECK(is_aligned_to(&tmp.value, 8) == false);
+
+	CHECK(is_aligned_to(4, 4) == true);
+	CHECK(is_aligned_to(4, 2) == true);
+	CHECK(is_aligned_to(4, 1) == true);
+	CHECK(is_aligned_to(4, 8) == false);
+	CHECK(is_aligned_to(6, 4) == false);
+	CHECK(is_aligned_to(6, 2) == true);
+	CHECK(is_aligned_to(6, 1) == true);
+
+	CHECK(is_aligned_to(align_to(5, 4), 4) == true);
+	CHECK(align_to(5, 4) == 8);
+	CHECK(is_aligned_to(align_to(8, 4), 4) == true);
+	CHECK(align_to(8, 4) == 8);
 
 	void* ptr = (void*)0x00000000;
-	REQUIRE(align_to(ptr, 4) == (void*)0x00000000);
-	REQUIRE(align_to(ptr, 8) == (void*)0x00000000);
+	CHECK(align_to(ptr, 4) == (void*)0x00000000);
+	CHECK(align_to(ptr, 8) == (void*)0x00000000);
 	ptr = (void*)0x00000001;
-	REQUIRE(align_to(ptr, 4) == (void*)0x00000004);
-	REQUIRE(align_to(ptr, 8) == (void*)0x00000008);
+	CHECK(align_to(ptr, 4) == (void*)0x00000004);
+	CHECK(align_to(ptr, 8) == (void*)0x00000008);
 	ptr = (void*)0x00000004;
-	REQUIRE(align_to(ptr, 4) == (void*)0x00000004);
-	REQUIRE(align_to(ptr, 8) == (void*)0x00000008);
+	CHECK(align_to(ptr, 4) == (void*)0x00000004);
+	CHECK(align_to(ptr, 8) == (void*)0x00000008);
 
 	struct alignas(8) Align8
 	{
@@ -110,32 +110,32 @@ TEST_CASE("misc tests", "[core][memory]")
 
 	const size_t padding0 = get_required_padding<float, Align8>();
 	const size_t padding1 = get_required_padding<uint8_t, Align8>();
-	REQUIRE(padding0 == 4);
-	REQUIRE(padding1 == 7);
+	CHECK(padding0 == 4);
+	CHECK(padding1 == 7);
 
 	int32_t array[8];
-	REQUIRE(get_array_size(array) == (sizeof(array) / sizeof(array[0])));
+	CHECK(get_array_size(array) == (sizeof(array) / sizeof(array[0])));
 }
 
 TEST_CASE("raw memory support", "[core][memory]")
 {
 	uint8_t buffer[1024];
 	uint8_t* ptr = &buffer[32];
-	REQUIRE(add_offset_to_ptr<uint8_t>(ptr, 23) == ptr + 23);
-	REQUIRE(add_offset_to_ptr<uint8_t>(ptr, 64) == ptr + 64);
+	CHECK(add_offset_to_ptr<uint8_t>(ptr, 23) == ptr + 23);
+	CHECK(add_offset_to_ptr<uint8_t>(ptr, 64) == ptr + 64);
 
 	uint16_t value16 = 0x04FE;
-	REQUIRE(byte_swap(value16) == 0xFE04);
+	CHECK(byte_swap(value16) == 0xFE04);
 
 	uint32_t value32 = 0x04FE78AB;
-	REQUIRE(byte_swap(value32) == 0xAB78FE04);
+	CHECK(byte_swap(value32) == 0xAB78FE04);
 
 	uint64_t value64 = uint64_t(0x04FE78AB0098DC56ULL);
-	REQUIRE(byte_swap(value64) == uint64_t(0x56DC9800AB78FE04ULL));
+	CHECK(byte_swap(value64) == uint64_t(0x56DC9800AB78FE04ULL));
 
 	uint8_t unaligned_value_buffer[5] = { 0x00, 0x00, 0x00, 0x00, 0x00 };
 	std::memcpy(&unaligned_value_buffer[1], &value32, sizeof(uint32_t));
-	REQUIRE(unaligned_load<uint32_t>(&unaligned_value_buffer[1]) == value32);
+	CHECK(unaligned_load<uint32_t>(&unaligned_value_buffer[1]) == value32);
 }
 
 TEST_CASE("memcpy_bits", "[core][memory]")
@@ -143,28 +143,28 @@ TEST_CASE("memcpy_bits", "[core][memory]")
 	uint64_t dest = uint64_t(~0ULL);
 	uint64_t src = byte_swap(uint64_t(0x5555555555555555ULL));
 	memcpy_bits(&dest, 1, &src, 0, 64 - 3);
-	REQUIRE(dest == byte_swap(uint64_t(0xAAAAAAAAAAAAAAABULL)));
+	CHECK(dest == byte_swap(uint64_t(0xAAAAAAAAAAAAAAABULL)));
 
 	dest = byte_swap(uint64_t(0x0F00FF0000000000ULL));
 	src = byte_swap(uint64_t(0x3800000000000000ULL));
 	memcpy_bits(&dest, 0, &src, 2, 5);
-	REQUIRE(dest == byte_swap(uint64_t(0xE700FF0000000000ULL)));
+	CHECK(dest == byte_swap(uint64_t(0xE700FF0000000000ULL)));
 
 	dest = byte_swap(uint64_t(0x0F00FF0000000000ULL));
 	src = byte_swap(uint64_t(0x3800000000000000ULL));
 	memcpy_bits(&dest, 1, &src, 2, 5);
-	REQUIRE(dest == byte_swap(uint64_t(0x7300FF0000000000ULL)));
+	CHECK(dest == byte_swap(uint64_t(0x7300FF0000000000ULL)));
 
 	dest = 0;
 	src = uint64_t(~0ULL);
 	memcpy_bits(&dest, 1, &src, 0, 7);
-	REQUIRE(dest == byte_swap(uint64_t(0x7F00000000000000ULL)));
+	CHECK(dest == byte_swap(uint64_t(0x7F00000000000000ULL)));
 
 	memcpy_bits(&dest, 8, &src, 0, 8);
-	REQUIRE(dest == byte_swap(uint64_t(0x7FFF000000000000ULL)));
+	CHECK(dest == byte_swap(uint64_t(0x7FFF000000000000ULL)));
 
 	memcpy_bits(&dest, 0, &src, 0, 64);
-	REQUIRE(dest == uint64_t(~0ULL));
+	CHECK(dest == uint64_t(~0ULL));
 }
 
 enum class UnsignedEnum : uint32_t
diff --git a/tests/sources/core/test_ptr_offset.cpp b/tests/sources/core/test_ptr_offset.cpp
--- a/tests/sources/core/test_ptr_offset.cpp
+++ b/tests/sources/core/test_ptr_offset.cpp
@@ -30,13 +30,13 @@ using namespace acl;
 
 TEST_CASE("ptr_offset", "[core][memory]")
 {
-	REQUIRE(PtrOffset32<uint8_t>(InvalidPtrOffset()).is_valid() == false);
+	CHECK(PtrOffset32<uint8_t>(InvalidPtrOffset()).is_valid() == false);
 
 	PtrOffset32<uint8_t> offset(32);
-	REQUIRE(offset.is_valid() == true);
+	CHECK(offset.is_valid() == true);
 
 	uint8_t* ptr = nullptr;
-	REQUIRE(offset.add_to(ptr) == (ptr + 32));
-	REQUIRE(offset.add_to(ptr) == offset.safe_add_to(ptr));
-	REQUIRE(uint32_t(offset) == 32);
+	CHECK(offset.add_to(ptr) == (ptr + 32));
+	CHECK(offset.add_to(ptr) == offset.safe_add_to(ptr));
+	CHECK(uint32_t(offset) == 32);
 }
diff --git a/tests/sources/core/test_string.cpp b/tests/sources/core/test_string.cpp
--- a/tests/sources/core/test_string.cpp
+++ b/tests/sources/core/test_string.cpp
@@ -39,27 +39,27 @@ TEST_CASE("String", "[core][string]")
 {
 	ANSIAllocator allocator;
 
-	REQUIRE(String().size() == 0);
-	REQUIRE(String().c_str() != nullptr);
-	REQUIRE(String(allocator, "").size() == 0);
-	REQUIRE(String(allocator, "").c_str() != nullptr);
+	CHECK(String().size() == 0);
+	CHECK(String().c_str() != nullptr);
+	CHECK(String(allocator, "").size() == 0);
+	CHECK(String(allocator, "").c_str() != nullptr);
 
 	const char* str0 = "this is a test string";
 	const char* str1 = "this is not a test string";
 	const char* str2 = "this is a test asset!";
 
-	REQUIRE(String(allocator, str0) == str0);
-	REQUIRE(String(allocator, str0) != str1);
-	REQUIRE(String(allocator, str0) != str2);
-	REQUIRE(String(allocator, str0) == String(allocator, str0));
-	REQUIRE(String(allocator, str0) != String(allocator, str1));
-	REQUIRE(String(allocator, str0) != String(allocator, str2));
-	REQUIRE(String(allocator, str0).c_str() != str0);
-	REQUIRE(String(allocator, str0).size() == std::strlen(str0));
-	REQUIRE(String(allocator, str0, 4) == String(allocator, str1, 4));
-	REQUIRE(String(allocator, str0, 4) == "this");
+	CHECK(String(allocator, str0) == str0);
+	CHECK(String(allocator, str0) != str1);
+	CHECK(String(allocator, str0) != str2);
+	CHECK(String(allocator, str0) == String(allocator, str0));
+	CHECK(String(allocator, str0) != String(allocator, str1));
+	CHECK(String(allocator, str0) != String(allocator, str2));
+	CHECK(String(allocator, str0).c_str() != str0);
+	CHECK(String(allocator, str0).size() == std::strlen(str0));
+	CHECK(String(allocator, str0, 4) == String(allocator, str1, 4));
+	CHECK(String(allocator, str0, 4) == "this");
 
-	REQUIRE(String().empty() == true);
-	REQUIRE(String(allocator, "").empty() == true);
-	REQUIRE(String(allocator, str0).empty() == false);
+	CHECK(String().empty() == true);
+	CHECK(String(allocator, "").empty() == true);
+	CHECK(String(allocator, str0).empty() == false);
 }
diff --git a/tests/sources/core/test_utils.cpp b/tests/sources/core/test_utils.cpp
--- a/tests/sources/core/test_utils.cpp
+++ b/tests/sources/core/test_utils.cpp
@@ -34,15 +34,15 @@ using namespace rtm;
 
 TEST_CASE("misc utils", "[core][utils]")
 {
-	REQUIRE(calculate_num_samples(0.0F, 30.0F) == 0);
-	REQUIRE(calculate_num_samples(1.0F, 30.0F) == 31);
-	REQUIRE(calculate_num_samples(1.0F, 24.0F) == 25);
-	REQUIRE(calculate_num_samples(1.0F / 30.F, 30.0F) == 2);
-	REQUIRE(calculate_num_samples(std::numeric_limits<float>::infinity(), 30.0F) == 1);
+	CHECK(calculate_num_samples(0.0F, 30.0F) == 0);
+	CHECK(calculate_num_samples(1.0F, 30.0F) == 31);
+	CHECK(calculate_num_samples(1.0F, 24.0F) == 25);
+	CHECK(calculate_num_samples(1.0F / 30.F, 30.0F) == 2);
+	CHECK(calculate_num_samples(std::numeric_limits<float>::infinity(), 30.0F) == 1);
 
-	REQUIRE(calculate_duration(0, 30.0F) == 0.0F);
-	REQUIRE(calculate_duration(1, 30.0F) == std::numeric_limits<float>::infinity());
-	REQUIRE(calculate_duration(1, 8.0F) == std::numeric_limits<float>::infinity());
-	REQUIRE(scalar_near_equal(calculate_duration(31, 30.0F), 1.0F, 1.0E-8F));
-	REQUIRE(scalar_near_equal(calculate_duration(9, 8.0F), 1.0F, 1.0E-8F));
+	CHECK(calculate_duration(0, 30.0F) == 0.0F);
+	CHECK(calculate_duration(1, 30.0F) == std::numeric_limits<float>::infinity());
+	CHECK(calculate_duration(1, 8.0F) == std::numeric_limits<float>::infinity());
+	CHECK(scalar_near_equal(calculate_duration(31, 30.0F), 1.0F, 1.0E-8F));
+	CHECK(scalar_near_equal(calculate_duration(9, 8.0F), 1.0F, 1.0E-8F));
 }
diff --git a/tests/sources/io/test_reader_writer.cpp b/tests/sources/io/test_reader_writer.cpp
--- a/tests/sources/io/test_reader_writer.cpp
+++ b/tests/sources/io/test_reader_writer.cpp
@@ -208,15 +208,12 @@ TEST_CASE("sjson_clip_reader_writer", "[io]")
 	settings.constant_scale_threshold = 1.123F;
 	settings.constant_translation_threshold = 0.124F;
 	settings.error_threshold = 0.23F;
-	settings.level = CompressionLevel8::High;
-	settings.range_reduction = RangeReductionFlags8::Rotations | RangeReductionFlags8::Scales;
-	settings.rotation_format = RotationFormat8::QuatDropW_48;
-	settings.scale_format = VectorFormat8::Vector3_96;
-	settings.translation_format = VectorFormat8::Vector3_32;
-	settings.segmenting.enabled = false;
+	settings.level = compression_level8::high;
+	settings.rotation_format = rotation_format8::quatf_drop_w_variable;
+	settings.scale_format = vector_format8::vector3f_variable;
+	settings.translation_format = vector_format8::vector3f_variable;
 	settings.segmenting.ideal_num_samples = 23;
 	settings.segmenting.max_num_samples = 123;
-	settings.segmenting.range_reduction = RangeReductionFlags8::Translations;
 
 	const uint32_t filename_size = k_max_filename_size;
 	char filename[filename_size] = { 0 };
@@ -227,7 +224,7 @@ TEST_CASE("sjson_clip_reader_writer", "[io]")
 		get_temporary_filename(filename, filename_size, "clip_");
 
 		// Write the clip to a temporary file
-		error = write_acl_clip(skeleton, clip, AlgorithmType8::UniformlySampled, settings, filename);
+		error = write_acl_clip(skeleton, clip, algorithm_type8::uniformly_sampled, settings, filename);
 
 		if (error == nullptr)
 			break;	// Everything worked, stop trying
@@ -267,7 +264,7 @@ TEST_CASE("sjson_clip_reader_writer", "[io]")
 	const bool success = reader.read_raw_clip(file_clip);
 	REQUIRE(success);
 
-	CHECK(file_clip.algorithm_type == AlgorithmType8::UniformlySampled);
+	CHECK(file_clip.algorithm_type == algorithm_type8::uniformly_sampled);
 	CHECK(file_clip.has_settings);
 	CHECK(file_clip.settings.get_hash() == settings.get_hash());
 	CHECK(file_clip.skeleton->get_num_bones() == num_bones);
diff --git a/tests/sources/math/test_quat_packing.cpp b/tests/sources/math/test_quat_packing.cpp
--- a/tests/sources/math/test_quat_packing.cpp
+++ b/tests/sources/math/test_quat_packing.cpp
@@ -45,50 +45,46 @@ TEST_CASE("quat packing math", "[math][quat][packing]")
 		UnalignedBuffer tmp0;
 		pack_quat_128(quat0, &tmp0.buffer[0]);
 		quatf quat1 = unpack_quat_128(&tmp0.buffer[0]);
-		REQUIRE(quat_get_x(quat0) == quat_get_x(quat1));
-		REQUIRE(quat_get_y(quat0) == quat_get_y(quat1));
-		REQUIRE(quat_get_z(quat0) == quat_get_z(quat1));
-		REQUIRE(quat_get_w(quat0) == quat_get_w(quat1));
+		CHECK(quat_get_x(quat0) == quat_get_x(quat1));
+		CHECK(quat_get_y(quat0) == quat_get_y(quat1));
+		CHECK(quat_get_z(quat0) == quat_get_z(quat1));
+		CHECK(quat_get_w(quat0) == quat_get_w(quat1));
 	}
 
 	{
 		UnalignedBuffer tmp0;
 		pack_quat_96(quat0, &tmp0.buffer[0]);
 		quatf quat1 = unpack_quat_96_unsafe(&tmp0.buffer[0]);
-		REQUIRE(quat_get_x(quat0) == quat_get_x(quat1));
-		REQUIRE(quat_get_y(quat0) == quat_get_y(quat1));
-		REQUIRE(quat_get_z(quat0) == quat_get_z(quat1));
-		REQUIRE(scalar_near_equal(quat_get_w(quat0), quat_get_w(quat1), 1.0E-4F));
+		CHECK(quat_get_x(quat0) == quat_get_x(quat1));
+		CHECK(quat_get_y(quat0) == quat_get_y(quat1));
+		CHECK(quat_get_z(quat0) == quat_get_z(quat1));
+		CHECK(scalar_near_equal(quat_get_w(quat0), quat_get_w(quat1), 1.0E-4F));
 	}
 
 	{
 		UnalignedBuffer tmp0;
 		pack_quat_48(quat0, &tmp0.buffer[0]);
 		quatf quat1 = unpack_quat_48(&tmp0.buffer[0]);
-		REQUIRE(scalar_near_equal(quat_get_x(quat0), quat_get_x(quat1), 1.0E-4F));
-		REQUIRE(scalar_near_equal(quat_get_y(quat0), quat_get_y(quat1), 1.0E-4F));
-		REQUIRE(scalar_near_equal(quat_get_z(quat0), quat_get_z(quat1), 1.0E-4F));
-		REQUIRE(scalar_near_equal(quat_get_w(quat0), quat_get_w(quat1), 1.0E-4F));
+		CHECK(scalar_near_equal(quat_get_x(quat0), quat_get_x(quat1), 1.0E-4F));
+		CHECK(scalar_near_equal(quat_get_y(quat0), quat_get_y(quat1), 1.0E-4F));
+		CHECK(scalar_near_equal(quat_get_z(quat0), quat_get_z(quat1), 1.0E-4F));
+		CHECK(scalar_near_equal(quat_get_w(quat0), quat_get_w(quat1), 1.0E-4F));
 	}
 
 	{
 		UnalignedBuffer tmp0;
 		pack_quat_32(quat0, &tmp0.buffer[0]);
 		quatf quat1 = unpack_quat_32(&tmp0.buffer[0]);
-		REQUIRE(scalar_near_equal(quat_get_x(quat0), quat_get_x(quat1), 1.0E-3F));
-		REQUIRE(scalar_near_equal(quat_get_y(quat0), quat_get_y(quat1), 1.0E-3F));
-		REQUIRE(scalar_near_equal(quat_get_z(quat0), quat_get_z(quat1), 1.0E-3F));
-		REQUIRE(scalar_near_equal(quat_get_w(quat0), quat_get_w(quat1), 1.0E-3F));
+		CHECK(scalar_near_equal(quat_get_x(quat0), quat_get_x(quat1), 1.0E-3F));
+		CHECK(scalar_near_equal(quat_get_y(quat0), quat_get_y(quat1), 1.0E-3F));
+		CHECK(scalar_near_equal(quat_get_z(quat0), quat_get_z(quat1), 1.0E-3F));
+		CHECK(scalar_near_equal(quat_get_w(quat0), quat_get_w(quat1), 1.0E-3F));
 	}
 
-	REQUIRE(get_packed_rotation_size(RotationFormat8::Quat_128) == 16);
-	REQUIRE(get_packed_rotation_size(RotationFormat8::QuatDropW_96) == 12);
-	REQUIRE(get_packed_rotation_size(RotationFormat8::QuatDropW_48) == 6);
-	REQUIRE(get_packed_rotation_size(RotationFormat8::QuatDropW_32) == 4);
+	CHECK(get_packed_rotation_size(rotation_format8::quatf_full) == 16);
+	CHECK(get_packed_rotation_size(rotation_format8::quatf_drop_w_full) == 12);
 
-	REQUIRE(get_range_reduction_rotation_size(RotationFormat8::Quat_128) == 32);
-	REQUIRE(get_range_reduction_rotation_size(RotationFormat8::QuatDropW_96) == 24);
-	REQUIRE(get_range_reduction_rotation_size(RotationFormat8::QuatDropW_48) == 24);
-	REQUIRE(get_range_reduction_rotation_size(RotationFormat8::QuatDropW_32) == 24);
-	REQUIRE(get_range_reduction_rotation_size(RotationFormat8::QuatDropW_Variable) == 24);
+	CHECK(get_range_reduction_rotation_size(rotation_format8::quatf_full) == 32);
+	CHECK(get_range_reduction_rotation_size(rotation_format8::quatf_drop_w_full) == 24);
+	CHECK(get_range_reduction_rotation_size(rotation_format8::quatf_drop_w_variable) == 24);
 }
diff --git a/tests/sources/math/test_vector4_packing.cpp b/tests/sources/math/test_vector4_packing.cpp
--- a/tests/sources/math/test_vector4_packing.cpp
+++ b/tests/sources/math/test_vector4_packing.cpp
@@ -48,7 +48,7 @@ TEST_CASE("pack_vector4_128", "[math][vector4][packing]")
 		vector4f vec0 = vector_set(6123.123812F, 19237.01293127F, 1891.019231829F, 0.913912387F);
 		pack_vector4_128(vec0, &tmp.buffer[0]);
 		vector4f vec1 = unpack_vector4_128(&tmp.buffer[0]);
-		REQUIRE(std::memcmp(&vec0, &vec1, sizeof(vector4f)) == 0);
+		CHECK(std::memcmp(&vec0, &vec1, sizeof(vector4f)) == 0);
 	}
 
 	{
@@ -84,7 +84,7 @@ TEST_CASE("pack_vector4_128", "[math][vector4][packing]")
 			if (!vector_all_near_equal(vec0, vec1, 1.0E-6F))
 				num_errors++;
 		}
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
@@ -110,7 +110,7 @@ TEST_CASE("pack_vector4_64", "[math][vector4][packing]")
 			if (!vector_all_near_equal(vec0, vec1, 1.0E-6F))
 				num_errors++;
 		}
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
@@ -136,7 +136,7 @@ TEST_CASE("pack_vector4_32", "[math][vector4][packing]")
 			if (!vector_all_near_equal(vec0, vec1, 1.0E-6F))
 				num_errors++;
 		}
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
@@ -181,7 +181,7 @@ TEST_CASE("pack_vector4_XX", "[math][vector4][packing]")
 				}
 			}
 		}
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
@@ -193,7 +193,7 @@ TEST_CASE("pack_vector3_96", "[math][vector4][packing]")
 		vector4f vec0 = vector_set(6123.123812F, 19237.01293127F, 0.913912387F);
 		pack_vector3_96(vec0, &tmp0.buffer[0]);
 		vector4f vec1 = unpack_vector3_96_unsafe(&tmp0.buffer[0]);
-		REQUIRE(vector_all_near_equal3(vec0, vec1, 1.0E-6F));
+		CHECK(vector_all_near_equal3(vec0, vec1, 1.0E-6F));
 
 		uint32_t x = unaligned_load<uint32_t>(&tmp0.buffer[0]);
 		x = byte_swap(x);
@@ -218,7 +218,7 @@ TEST_CASE("pack_vector3_96", "[math][vector4][packing]")
 			if (!vector_all_near_equal3(vec0, vec1, 1.0E-6F))
 				num_errors++;
 		}
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
@@ -244,7 +244,7 @@ TEST_CASE("pack_vector3_48", "[math][vector4][packing]")
 			if (!vector_all_near_equal3(vec0, vec1, 1.0E-6F))
 				num_errors++;
 		}
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
@@ -267,7 +267,7 @@ TEST_CASE("decay_vector3_48", "[math][vector4][decay]")
 			if (!vector_all_near_equal3(vec0, vec1, 1.0E-6F))
 				num_errors++;
 		}
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
@@ -301,7 +301,7 @@ TEST_CASE("pack_vector3_32", "[math][vector4][packing]")
 			if (!vector_all_near_equal3(vec0, vec1, 1.0E-6F))
 				num_errors++;
 		}
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
@@ -332,7 +332,7 @@ TEST_CASE("decay_vector3_32", "[math][vector4][decay]")
 			if (!vector_all_near_equal3(vec0, vec1, 1.0E-6F))
 				num_errors++;
 		}
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
@@ -358,7 +358,7 @@ TEST_CASE("pack_vector3_24", "[math][vector4][packing]")
 			if (!vector_all_near_equal3(vec0, vec1, 1.0E-6F))
 				num_errors++;
 		}
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
@@ -429,7 +429,7 @@ TEST_CASE("pack_vector3_XX", "[math][vector4][packing]")
 				}
 			}
 		}
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
@@ -469,7 +469,7 @@ TEST_CASE("decay_vector3_XX", "[math][vector4][decay]")
 			}
 		}
 
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
@@ -500,7 +500,7 @@ TEST_CASE("pack_vector2_64", "[math][vector4][packing]")
 			if (!vector_all_near_equal2(vec0, vec1, 1.0E-6F))
 				num_errors++;
 		}
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
@@ -545,13 +545,11 @@ TEST_CASE("pack_vector2_XX", "[math][vector4][packing]")
 				}
 			}
 		}
-		REQUIRE(num_errors == 0);
+		CHECK(num_errors == 0);
 	}
 }
 
 TEST_CASE("misc vector4 packing", "[math][vector4][packing]")
 {
-	REQUIRE(get_packed_vector_size(VectorFormat8::Vector3_96) == 12);
-	REQUIRE(get_packed_vector_size(VectorFormat8::Vector3_48) == 6);
-	REQUIRE(get_packed_vector_size(VectorFormat8::Vector3_32) == 4);
+	CHECK(get_packed_vector_size(vector_format8::vector3f_full) == 12);
 }