diff --git a/src/terrain_3d_collision.cpp b/src/terrain_3d_collision.cpp
index 005808331..abea96d03 100644
--- a/src/terrain_3d_collision.cpp
+++ b/src/terrain_3d_collision.cpp
@@ -57,8 +57,8 @@ Dictionary Terrain3DCollision::_get_shape_data(const Vector2i &p_position, const
 
 		real_t blend_factor = 2.0f + 126.0f * (1.0f - region_blend);
 		Vector2 f = Vector2(uv2.x - Math::floor(uv2.x), uv2.y - Math::floor(uv2.y));
-		f.x = Math::clamp(f.x, 1e-8f, 1.f - 1e-8f);
-		f.y = Math::clamp(f.y, 1e-8f, 1.f - 1e-8f);
+		f.x = Math::clamp(f.x, real_t(1e-8), real_t(1.0 - 1e-8));
+		f.y = Math::clamp(f.y, real_t(1e-8), real_t(1.0 - 1e-8));
 		Vector2 w = Vector2(1.f / (1.f + Math::exp(blend_factor * Math::log((1.f - f.x) / f.x))),
 				1.f / (1.f + Math::exp(blend_factor * Math::log((1.f - f.y) / f.y))));
 		real_t blend = Math::lerp(Math::lerp(d, c, w.x), Math::lerp(a, b, w.x), w.y);
diff --git a/src/terrain_3d_util.h b/src/terrain_3d_util.h
index df75abf34..049e0ec02 100644
--- a/src/terrain_3d_util.h
+++ b/src/terrain_3d_util.h
@@ -7,6 +7,7 @@
 #include <godot_cpp/classes/node.hpp>
 #include <godot_cpp/classes/resource_loader.hpp>
 #include <godot_cpp/variant/utility_functions.hpp>
+#include <type_traits>
 
 #include "constants.h"
 #include "generated_texture.h"
@@ -231,46 +232,54 @@ inline uint32_t as_uint(const float p_value) { return *(uint32_t *)&p_value; }
 
 inline uint8_t get_base(const uint32_t p_pixel) { return p_pixel >> 27 & 0x1F; }
 inline uint8_t get_base(const float p_pixel) { return get_base(as_uint(p_pixel)); }
+inline uint8_t get_base(const double p_pixel) { return get_base(static_cast<float>(p_pixel)); }
 inline uint32_t enc_base(const uint8_t p_base) { return (p_base & 0x1F) << 27; }
 inline uint32_t gd_get_base(const uint32_t p_pixel) { return get_base(p_pixel); }
 inline uint32_t gd_enc_base(const uint32_t p_base) { return enc_base(p_base); }
 
 inline uint8_t get_overlay(const uint32_t p_pixel) { return p_pixel >> 22 & 0x1F; }
 inline uint8_t get_overlay(const float p_pixel) { return get_overlay(as_uint(p_pixel)); }
+inline uint8_t get_overlay(const double p_pixel) { return get_overlay(static_cast<float>(p_pixel)); }
 inline uint32_t enc_overlay(const uint8_t p_over) { return (p_over & 0x1F) << 22; }
 inline uint32_t gd_get_overlay(const uint32_t p_pixel) { return get_overlay(p_pixel); }
 inline uint32_t gd_enc_overlay(const uint32_t p_over) { return enc_overlay(p_over); }
 
 inline uint8_t get_blend(const uint32_t p_pixel) { return p_pixel >> 14 & 0xFF; }
 inline uint8_t get_blend(const float p_pixel) { return get_blend(as_uint(p_pixel)); }
+inline uint8_t get_blend(const double p_pixel) { return get_blend(static_cast<float>(p_pixel)); }
 inline uint32_t enc_blend(const uint8_t p_blend) { return (p_blend & 0xFF) << 14; }
 inline uint32_t gd_get_blend(const uint32_t p_pixel) { return get_blend(p_pixel); }
 inline uint32_t gd_enc_blend(const uint32_t p_blend) { return enc_blend(p_blend); }
 
 inline uint8_t get_uv_rotation(const uint32_t p_pixel) { return p_pixel >> 10 & 0xF; }
 inline uint8_t get_uv_rotation(const float p_pixel) { return get_uv_rotation(as_uint(p_pixel)); }
+inline uint8_t get_uv_rotation(const double p_pixel) { return get_uv_rotation(static_cast<float>(p_pixel)); }
 inline uint32_t enc_uv_rotation(const uint8_t p_rotation) { return (p_rotation & 0xF) << 10; }
 inline uint32_t gd_get_uv_rotation(const uint32_t p_pixel) { return get_uv_rotation(p_pixel); }
 inline uint32_t gd_enc_uv_rotation(const uint32_t p_rotation) { return enc_uv_rotation(p_rotation); }
 
 inline uint8_t get_uv_scale(const uint32_t p_pixel) { return p_pixel >> 7 & 0x7; }
 inline uint8_t get_uv_scale(const float p_pixel) { return get_uv_scale(as_uint(p_pixel)); }
+inline uint8_t get_uv_scale(const double p_pixel) { return get_uv_scale(static_cast<float>(p_pixel)); }
 inline uint32_t enc_uv_scale(const uint8_t p_scale) { return (p_scale & 0x7) << 7; }
 inline uint32_t gd_get_uv_scale(const uint32_t p_pixel) { return get_uv_scale(p_pixel); }
 inline uint32_t gd_enc_uv_scale(const uint32_t p_scale) { return enc_uv_scale(p_scale); }
 
 inline bool is_hole(const uint32_t p_pixel) { return (p_pixel >> 2 & 0x1) == 1; }
 inline bool is_hole(const float p_pixel) { return is_hole(as_uint(p_pixel)); }
+inline bool is_hole(const double p_pixel) { return is_hole(static_cast<float>(p_pixel)); }
 inline uint32_t enc_hole(const bool p_hole) { return (p_hole & 0x1) << 2; }
 inline bool gd_is_hole(const uint32_t p_pixel) { return is_hole(p_pixel); }
 
 inline bool is_nav(const uint32_t p_pixel) { return (p_pixel >> 1 & 0x1) == 1; }
 inline bool is_nav(const float p_pixel) { return is_nav(as_uint(p_pixel)); }
+inline bool is_nav(const double p_pixel) { return is_nav(static_cast<float>(p_pixel)); }
 inline uint32_t enc_nav(const bool p_nav) { return (p_nav & 0x1) << 1; }
 inline bool gd_is_nav(const uint32_t p_pixel) { return is_nav(p_pixel); }
 
 inline bool is_auto(const uint32_t p_pixel) { return (p_pixel & 0x1) == 1; }
 inline bool is_auto(const float p_pixel) { return is_auto(as_uint(p_pixel)); }
+inline bool is_auto(const double p_pixel) { return is_auto(static_cast<float>(p_pixel)); }
 inline uint32_t enc_auto(const bool p_auto) { return p_auto & 0x1; }
 inline bool gd_is_auto(const uint32_t p_pixel) { return is_auto(p_pixel); }
 
@@ -336,9 +345,10 @@ _FORCE_INLINE_ bool differs(const T &a, const T &b) {
 }
 
 // Sets A if different from B, otherwise returns
+// Cast b to a's type for precision=double builds.
 #define SET_IF_DIFF(a, b) \
-	if (differs(a, b)) {  \
-		a = b;            \
+	if (differs(a, static_cast<std::remove_reference_t<decltype(a)>>(b))) {  \
+		a = static_cast<std::remove_reference_t<decltype(a)>>(b);            \
 	} else {              \
 		return;           \
 	}