/**************************************************************************/ /* noise.h */ /**************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* https://godotengine.org */ /**************************************************************************/ /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ /* "Software"), to deal in the Software without restriction, including */ /* without limitation the rights to use, copy, modify, merge, publish, */ /* distribute, sublicense, and/or sell copies of the Software, and to */ /* permit persons to whom the Software is furnished to do so, subject to */ /* the following conditions: */ /* */ /* The above copyright notice and this permission notice shall be */ /* included in all copies or substantial portions of the Software. */ /* */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /**************************************************************************/ #ifndef NOISE_H #define NOISE_H #include "core/io/image.h" #include "core/variant/typed_array.h" class Noise : public Resource { GDCLASS(Noise, Resource); // Helper struct for get_seamless_image(). See comments in .cpp for usage. template <typename T> struct img_buff { T *img = nullptr; int width; // Array dimensions & default modulo for image. int height; int offset_x; // Offset index location on image (wrapped by specified modulo). int offset_y; int alt_width; // Alternate module for image. int alt_height; enum ALT_MODULO { DEFAULT = 0, ALT_X, ALT_Y, ALT_XY }; // Multi-dimensional array indexer (e.g. img[x][y]) that supports multiple modulos. T &operator()(int x, int y, ALT_MODULO mode = DEFAULT) { switch (mode) { case ALT_XY: return img[(x + offset_x) % alt_width + ((y + offset_y) % alt_height) * width]; case ALT_X: return img[(x + offset_x) % alt_width + ((y + offset_y) % height) * width]; case ALT_Y: return img[(x + offset_x) % width + ((y + offset_y) % alt_height) * width]; default: return img[(x + offset_x) % width + ((y + offset_y) % height) * width]; } } }; union l2c { uint32_t l; uint8_t c[4]; struct { uint8_t r; uint8_t g; uint8_t b; uint8_t a; }; }; template <typename T> Vector<Ref<Image>> _generate_seamless_image(Vector<Ref<Image>> p_src, int p_width, int p_height, int p_depth, bool p_invert, real_t p_blend_skirt) const { /* To make a seamless image, we swap the quadrants so the edges are perfect matches. We initially get a 10% larger image so we have an overlap we can use to blend over the seams. Noise::img_buff::operator() acts as a multi-dimensional array indexer. It does the array math, translates between the flipped and non-flipped quadrants, and manages offsets and modulos. Here is how the larger source image and final output image map to each other: Output size = p_width*p_height Source w/ extra 10% skirt `s` size = src_width*src_height Q1 Q2 Q4 Q3 s1 Q3 Q4 Q2 Q1 s2 s5 s4 s3 All of the loops use output coordinates, so Output:Q1 == Source:Q1 Ex: Output(half_width, half_height) [the midpoint, corner of Q1/Q4] => on Source it's translated to corner of Q1/s3 unless the ALT_XY modulo moves it to Q4 */ ERR_FAIL_COND_V(p_blend_skirt < 0, Vector<Ref<Image>>()); int skirt_width = MAX(1, p_width * p_blend_skirt); int skirt_height = MAX(1, p_height * p_blend_skirt); int src_width = p_width + skirt_width; int src_height = p_height + skirt_height; int half_width = p_width * 0.5; int half_height = p_height * 0.5; int skirt_edge_x = half_width + skirt_width; int skirt_edge_y = half_height + skirt_height; Image::Format format = p_src[0]->get_format(); int pixel_size = Image::get_format_pixel_size(format); Vector<Ref<Image>> images; images.resize(p_src.size()); // First blend across x and y for all slices. for (int d = 0; d < images.size(); d++) { Vector<uint8_t> dest; dest.resize(p_width * p_height * pixel_size); img_buff<T> rd_src = { (T *)p_src[d]->get_data().ptr(), src_width, src_height, half_width, half_height, p_width, p_height }; // `wr` is setup for straight x/y coordinate array access. img_buff<T> wr = { (T *)dest.ptrw(), p_width, p_height, 0, 0, 0, 0 }; // `rd_dest` is a readable pointer to `wr`, i.e. what has already been written to the output buffer. img_buff<T> rd_dest = { (T *)dest.ptr(), p_width, p_height, 0, 0, 0, 0 }; // Swap the quadrants to make edges seamless. for (int y = 0; y < p_height; y++) { for (int x = 0; x < p_width; x++) { // rd_src has a half offset and the shorter modulo ignores the skirt. // It reads and writes in Q1-4 order (see map above), skipping the skirt. wr(x, y) = rd_src(x, y, img_buff<T>::ALT_XY); } } // Blend the vertical skirt over the middle seam. for (int x = half_width; x < skirt_edge_x; x++) { int alpha = 255 * (1 - Math::smoothstep(0.1f, 0.9f, float(x - half_width) / float(skirt_width))); for (int y = 0; y < p_height; y++) { // Skip the center square if (y == half_height) { y = skirt_edge_y - 1; } else { // Starts reading at s2, ALT_Y skips s3, and continues with s1. wr(x, y) = _alpha_blend<T>(rd_dest(x, y), rd_src(x, y, img_buff<T>::ALT_Y), alpha); } } } // Blend the horizontal skirt over the middle seam. for (int y = half_height; y < skirt_edge_y; y++) { int alpha = 255 * (1 - Math::smoothstep(0.1f, 0.9f, float(y - half_height) / float(skirt_height))); for (int x = 0; x < p_width; x++) { // Skip the center square if (x == half_width) { x = skirt_edge_x - 1; } else { // Starts reading at s4, skips s3, continues with s5. wr(x, y) = _alpha_blend<T>(rd_dest(x, y), rd_src(x, y, img_buff<T>::ALT_X), alpha); } } } // Fill in the center square. Wr starts at the top left of Q4, which is the equivalent of the top left of s3, unless a modulo is used. for (int y = half_height; y < skirt_edge_y; y++) { for (int x = half_width; x < skirt_edge_x; x++) { int xpos = 255 * (1 - Math::smoothstep(0.1f, 0.9f, float(x - half_width) / float(skirt_width))); int ypos = 255 * (1 - Math::smoothstep(0.1f, 0.9f, float(y - half_height) / float(skirt_height))); // Blend s3(Q1) onto s5(Q2) for the top half. T top_blend = _alpha_blend<T>(rd_src(x, y, img_buff<T>::ALT_X), rd_src(x, y, img_buff<T>::DEFAULT), xpos); // Blend s1(Q3) onto Q4 for the bottom half. T bottom_blend = _alpha_blend<T>(rd_src(x, y, img_buff<T>::ALT_XY), rd_src(x, y, img_buff<T>::ALT_Y), xpos); // Blend the top half onto the bottom half. wr(x, y) = _alpha_blend<T>(bottom_blend, top_blend, ypos); } } Ref<Image> image = memnew(Image(p_width, p_height, false, format, dest)); p_src.write[d].unref(); images.write[d] = image; } // Now blend across z. if (p_depth > 1) { int skirt_depth = MAX(1, p_depth * p_blend_skirt); int half_depth = p_depth * 0.5; int skirt_edge_z = half_depth + skirt_depth; // Swap halves on depth. for (int i = 0; i < half_depth; i++) { Ref<Image> img = images[i]; images.write[i] = images[i + half_depth]; images.write[i + half_depth] = img; } Vector<Ref<Image>> new_images = images; new_images.resize(p_depth); // Scale seamless generation to third dimension. for (int z = half_depth; z < skirt_edge_z; z++) { int alpha = 255 * (1 - Math::smoothstep(0.1f, 0.9f, float(z - half_depth) / float(skirt_depth))); Vector<uint8_t> img = images[z % p_depth]->get_data(); Vector<uint8_t> skirt = images[(z - half_depth) + p_depth]->get_data(); Vector<uint8_t> dest; dest.resize(images[0]->get_width() * images[0]->get_height() * Image::get_format_pixel_size(images[0]->get_format())); for (int i = 0; i < img.size(); i++) { uint8_t fg, bg, out; fg = skirt[i]; bg = img[i]; uint16_t a = alpha + 1; uint16_t inv_a = 256 - alpha; out = (uint8_t)((a * fg + inv_a * bg) >> 8); dest.write[i] = out; } Ref<Image> new_image = memnew(Image(images[0]->get_width(), images[0]->get_height(), false, images[0]->get_format(), dest)); new_images.write[z % p_depth] = new_image; } return new_images; } return images; } template <typename T> T _alpha_blend(T p_bg, T p_fg, int p_alpha) const { l2c fg, bg, out; fg.l = p_fg; bg.l = p_bg; uint16_t alpha; uint16_t inv_alpha; // If no alpha argument specified, use the alpha channel in the color if (p_alpha == -1) { alpha = fg.c[3] + 1; inv_alpha = 256 - fg.c[3]; } else { alpha = p_alpha + 1; inv_alpha = 256 - p_alpha; } out.c[0] = (uint8_t)((alpha * fg.c[0] + inv_alpha * bg.c[0]) >> 8); out.c[1] = (uint8_t)((alpha * fg.c[1] + inv_alpha * bg.c[1]) >> 8); out.c[2] = (uint8_t)((alpha * fg.c[2] + inv_alpha * bg.c[2]) >> 8); out.c[3] = 0xFF; return out.l; } protected: static void _bind_methods(); public: // Virtual destructor so we can delete any Noise derived object when referenced as a Noise*. virtual ~Noise() {} virtual real_t get_noise_1d(real_t p_x) const = 0; virtual real_t get_noise_2dv(Vector2 p_v) const = 0; virtual real_t get_noise_2d(real_t p_x, real_t p_y) const = 0; virtual real_t get_noise_3dv(Vector3 p_v) const = 0; virtual real_t get_noise_3d(real_t p_x, real_t p_y, real_t p_z) const = 0; Vector<Ref<Image>> _get_image(int p_width, int p_height, int p_depth, bool p_invert = false, bool p_in_3d_space = false, bool p_normalize = true) const; virtual Ref<Image> get_image(int p_width, int p_height, bool p_invert = false, bool p_in_3d_space = false, bool p_normalize = true) const; virtual TypedArray<Image> get_image_3d(int p_width, int p_height, int p_depth, bool p_invert = false, bool p_normalize = true) const; Vector<Ref<Image>> _get_seamless_image(int p_width, int p_height, int p_depth, bool p_invert = false, bool p_in_3d_space = false, real_t p_blend_skirt = 0.1, bool p_normalize = true) const; virtual Ref<Image> get_seamless_image(int p_width, int p_height, bool p_invert = false, bool p_in_3d_space = false, real_t p_blend_skirt = 0.1, bool p_normalize = true) const; virtual TypedArray<Image> get_seamless_image_3d(int p_width, int p_height, int p_depth, bool p_invert = false, real_t p_blend_skirt = 0.1, bool p_normalize = true) const; }; #endif // NOISE_H