diff options
Diffstat (limited to 'game/addons/zylann.hterrain/native/src/image_utils.cpp')
| -rw-r--r-- | game/addons/zylann.hterrain/native/src/image_utils.cpp | 364 |
1 files changed, 364 insertions, 0 deletions
diff --git a/game/addons/zylann.hterrain/native/src/image_utils.cpp b/game/addons/zylann.hterrain/native/src/image_utils.cpp new file mode 100644 index 0000000..9131307 --- /dev/null +++ b/game/addons/zylann.hterrain/native/src/image_utils.cpp @@ -0,0 +1,364 @@ +#include "image_utils.h" +#include "int_range_2d.h" +#include "math_funcs.h" + +namespace godot { + +template <typename F> +inline void generic_brush_op(Image &image, Image &brush, Vector2 p_pos, float factor, F op) { + IntRange2D range = IntRange2D::from_min_max(p_pos, brush.get_size()); + int min_x_noclamp = range.min_x; + int min_y_noclamp = range.min_y; + range.clip(Vector2i(image.get_size())); + + image.lock(); + brush.lock(); + + for (int y = range.min_y; y < range.max_y; ++y) { + int by = y - min_y_noclamp; + + for (int x = range.min_x; x < range.max_x; ++x) { + int bx = x - min_x_noclamp; + + float b = brush.get_pixel(bx, by).r * factor; + op(image, x, y, b); + } + } + + image.unlock(); + brush.unlock(); +} + +ImageUtils::ImageUtils() { +#ifdef _DEBUG + Godot::print("Constructing ImageUtils"); +#endif +} + +ImageUtils::~ImageUtils() { +#ifdef _DEBUG + // TODO Cannot print shit here, see https://github.com/godotengine/godot/issues/37417 + // Means only the console will print this + //Godot::print("Destructing ImageUtils"); + printf("Destructing ImageUtils\n"); +#endif +} + +void ImageUtils::_init() { +} + +Vector2 ImageUtils::get_red_range(Ref<Image> image_ref, Rect2 rect) const { + ERR_FAIL_COND_V(image_ref.is_null(), Vector2()); + Image &image = **image_ref; + + IntRange2D range(rect); + range.clip(Vector2i(image.get_size())); + + image.lock(); + + float min_value = image.get_pixel(range.min_x, range.min_y).r; + float max_value = min_value; + + for (int y = range.min_y; y < range.max_y; ++y) { + for (int x = range.min_x; x < range.max_x; ++x) { + float v = image.get_pixel(x, y).r; + + if (v > max_value) { + max_value = v; + } else if (v < min_value) { + min_value = v; + } + } + } + + image.unlock(); + + return Vector2(min_value, max_value); +} + +float ImageUtils::get_red_sum(Ref<Image> image_ref, Rect2 rect) const { + ERR_FAIL_COND_V(image_ref.is_null(), 0.f); + Image &image = **image_ref; + + IntRange2D range(rect); + range.clip(Vector2i(image.get_size())); + + image.lock(); + + float sum = 0.f; + + for (int y = range.min_y; y < range.max_y; ++y) { + for (int x = range.min_x; x < range.max_x; ++x) { + sum += image.get_pixel(x, y).r; + } + } + + image.unlock(); + + return sum; +} + +float ImageUtils::get_red_sum_weighted(Ref<Image> image_ref, Ref<Image> brush_ref, Vector2 p_pos, float factor) const { + ERR_FAIL_COND_V(image_ref.is_null(), 0.f); + ERR_FAIL_COND_V(brush_ref.is_null(), 0.f); + Image &image = **image_ref; + Image &brush = **brush_ref; + + float sum = 0.f; + generic_brush_op(image, brush, p_pos, factor, [&sum](Image &image, int x, int y, float b) { + sum += image.get_pixel(x, y).r * b; + }); + + return sum; +} + +void ImageUtils::add_red_brush(Ref<Image> image_ref, Ref<Image> brush_ref, Vector2 p_pos, float factor) const { + ERR_FAIL_COND(image_ref.is_null()); + ERR_FAIL_COND(brush_ref.is_null()); + Image &image = **image_ref; + Image &brush = **brush_ref; + + generic_brush_op(image, brush, p_pos, factor, [](Image &image, int x, int y, float b) { + float r = image.get_pixel(x, y).r + b; + image.set_pixel(x, y, Color(r, r, r)); + }); +} + +void ImageUtils::lerp_channel_brush(Ref<Image> image_ref, Ref<Image> brush_ref, Vector2 p_pos, float factor, float target_value, int channel) const { + ERR_FAIL_COND(image_ref.is_null()); + ERR_FAIL_COND(brush_ref.is_null()); + Image &image = **image_ref; + Image &brush = **brush_ref; + + generic_brush_op(image, brush, p_pos, factor, [target_value, channel](Image &image, int x, int y, float b) { + Color c = image.get_pixel(x, y); + c[channel] = Math::lerp(c[channel], target_value, b); + image.set_pixel(x, y, c); + }); +} + +void ImageUtils::lerp_color_brush(Ref<Image> image_ref, Ref<Image> brush_ref, Vector2 p_pos, float factor, Color target_value) const { + ERR_FAIL_COND(image_ref.is_null()); + ERR_FAIL_COND(brush_ref.is_null()); + Image &image = **image_ref; + Image &brush = **brush_ref; + + generic_brush_op(image, brush, p_pos, factor, [target_value](Image &image, int x, int y, float b) { + const Color c = image.get_pixel(x, y).linear_interpolate(target_value, b); + image.set_pixel(x, y, c); + }); +} + +// TODO Smooth (each pixel being box-filtered, contrary to the existing smooth) + +float ImageUtils::generate_gaussian_brush(Ref<Image> image_ref) const { + ERR_FAIL_COND_V(image_ref.is_null(), 0.f); + Image &image = **image_ref; + + int w = static_cast<int>(image.get_width()); + int h = static_cast<int>(image.get_height()); + Vector2 center(w / 2, h / 2); + float radius = Math::min(w, h) / 2; + + ERR_FAIL_COND_V(radius <= 0.1f, 0.f); + + float sum = 0.f; + image.lock(); + + for (int y = 0; y < h; ++y) { + for (int x = 0; x < w; ++x) { + float d = Vector2(x, y).distance_to(center) / radius; + float v = Math::clamp(1.f - d * d * d, 0.f, 1.f); + image.set_pixel(x, y, Color(v, v, v)); + sum += v; + } + } + + image.unlock(); + return sum; +} + +void ImageUtils::blur_red_brush(Ref<Image> image_ref, Ref<Image> brush_ref, Vector2 p_pos, float factor) { + ERR_FAIL_COND(image_ref.is_null()); + ERR_FAIL_COND(brush_ref.is_null()); + Image &image = **image_ref; + Image &brush = **brush_ref; + + factor = Math::clamp(factor, 0.f, 1.f); + + // Relative to the image + IntRange2D buffer_range = IntRange2D::from_pos_size(p_pos, brush.get_size()); + buffer_range.pad(1); + + const int image_width = static_cast<int>(image.get_width()); + const int image_height = static_cast<int>(image.get_height()); + + const int buffer_width = static_cast<int>(buffer_range.get_width()); + const int buffer_height = static_cast<int>(buffer_range.get_height()); + _blur_buffer.resize(buffer_width * buffer_height); + + image.lock(); + + // Cache pixels, because they will be queried more than once and written to later + int buffer_i = 0; + for (int y = buffer_range.min_y; y < buffer_range.max_y; ++y) { + for (int x = buffer_range.min_x; x < buffer_range.max_x; ++x) { + const int ix = Math::clamp(x, 0, image_width - 1); + const int iy = Math::clamp(y, 0, image_height - 1); + _blur_buffer[buffer_i] = image.get_pixel(ix, iy).r; + ++buffer_i; + } + } + + IntRange2D range = IntRange2D::from_min_max(p_pos, brush.get_size()); + const int min_x_noclamp = range.min_x; + const int min_y_noclamp = range.min_y; + range.clip(Vector2i(image.get_size())); + + const int buffer_offset_left = -1; + const int buffer_offset_right = 1; + const int buffer_offset_top = -buffer_width; + const int buffer_offset_bottom = buffer_width; + + brush.lock(); + + // Apply blur + for (int y = range.min_y; y < range.max_y; ++y) { + const int brush_y = y - min_y_noclamp; + + for (int x = range.min_x; x < range.max_x; ++x) { + const int brush_x = x - min_x_noclamp; + + const float brush_value = brush.get_pixel(brush_x, brush_y).r * factor; + + buffer_i = (brush_x + 1) + (brush_y + 1) * buffer_width; + + const float p10 = _blur_buffer[buffer_i + buffer_offset_top]; + const float p01 = _blur_buffer[buffer_i + buffer_offset_left]; + const float p11 = _blur_buffer[buffer_i]; + const float p21 = _blur_buffer[buffer_i + buffer_offset_right]; + const float p12 = _blur_buffer[buffer_i + buffer_offset_bottom]; + + // Average + float m = (p10 + p01 + p11 + p21 + p12) * 0.2f; + float p = Math::lerp(p11, m, brush_value); + + image.set_pixel(x, y, Color(p, p, p)); + } + } + + image.unlock(); + brush.unlock(); +} + +void ImageUtils::paint_indexed_splat(Ref<Image> index_map_ref, Ref<Image> weight_map_ref, + Ref<Image> brush_ref, Vector2 p_pos, int texture_index, float factor) { + + ERR_FAIL_COND(index_map_ref.is_null()); + ERR_FAIL_COND(weight_map_ref.is_null()); + ERR_FAIL_COND(brush_ref.is_null()); + Image &index_map = **index_map_ref; + Image &weight_map = **weight_map_ref; + Image &brush = **brush_ref; + + ERR_FAIL_COND(index_map.get_size() != weight_map.get_size()); + + factor = Math::clamp(factor, 0.f, 1.f); + + IntRange2D range = IntRange2D::from_min_max(p_pos, brush.get_size()); + const int min_x_noclamp = range.min_x; + const int min_y_noclamp = range.min_y; + range.clip(Vector2i(index_map.get_size())); + + const float texture_index_f = float(texture_index) / 255.f; + const Color all_texture_index_f(texture_index_f, texture_index_f, texture_index_f); + const int ci = texture_index % 3; + Color cm(-1, -1, -1); + cm[ci] = 1; + + brush.lock(); + index_map.lock(); + weight_map.lock(); + + for (int y = range.min_y; y < range.max_y; ++y) { + const int brush_y = y - min_y_noclamp; + + for (int x = range.min_x; x < range.max_x; ++x) { + const int brush_x = x - min_x_noclamp; + + const float brush_value = brush.get_pixel(brush_x, brush_y).r * factor; + + if (brush_value == 0.f) { + continue; + } + + Color i = index_map.get_pixel(x, y); + Color w = weight_map.get_pixel(x, y); + + // Decompress third weight to make computations easier + w[2] = 1.f - w[0] - w[1]; + + if (std::abs(i[ci] - texture_index_f) > 0.001f) { + // Pixel does not have our texture index, + // transfer its weight to other components first + if (w[ci] > brush_value) { + w[0] -= cm[0] * brush_value; + w[1] -= cm[1] * brush_value; + w[2] -= cm[2] * brush_value; + + } else if (w[ci] >= 0.f) { + w[ci] = 0.f; + i[ci] = texture_index_f; + } + + } else { + // Pixel has our texture index, increase its weight + if (w[ci] + brush_value < 1.f) { + w[0] += cm[0] * brush_value; + w[1] += cm[1] * brush_value; + w[2] += cm[2] * brush_value; + + } else { + // Pixel weight is full, we can set all components to the same index. + // Need to nullify other weights because they would otherwise never reach + // zero due to normalization + w = Color(0, 0, 0); + w[ci] = 1.0; + i = all_texture_index_f; + } + } + + // No `saturate` function in Color?? + w[0] = Math::clamp(w[0], 0.f, 1.f); + w[1] = Math::clamp(w[1], 0.f, 1.f); + w[2] = Math::clamp(w[2], 0.f, 1.f); + + // Renormalize + const float sum = w[0] + w[1] + w[2]; + w[0] /= sum; + w[1] /= sum; + w[2] /= sum; + + index_map.set_pixel(x, y, i); + weight_map.set_pixel(x, y, w); + } + } + + brush.lock(); + index_map.unlock(); + weight_map.unlock(); +} + +void ImageUtils::_register_methods() { + register_method("get_red_range", &ImageUtils::get_red_range); + register_method("get_red_sum", &ImageUtils::get_red_sum); + register_method("get_red_sum_weighted", &ImageUtils::get_red_sum_weighted); + register_method("add_red_brush", &ImageUtils::add_red_brush); + register_method("lerp_channel_brush", &ImageUtils::lerp_channel_brush); + register_method("lerp_color_brush", &ImageUtils::lerp_color_brush); + register_method("generate_gaussian_brush", &ImageUtils::generate_gaussian_brush); + register_method("blur_red_brush", &ImageUtils::blur_red_brush); + register_method("paint_indexed_splat", &ImageUtils::paint_indexed_splat); +} + +} // namespace godot |