Support cylindrical and spherical !noise

Author: jonathanhogg

docs/shaders.md

@@ -554,9 +554,28 @@ with the `border` and `repeat` attributes as described above for
 
 ### `!noise`
 
-The `!noise` node is primarily an image generator that generates 2D slices
-through [OpenSimplex 2S](https://github.com/KdotJPG/OpenSimplex2) 3D ("improved
-XY") noise. It is controlled with the following attributes:
+The `!noise` node is primarily an image generator that generates slices through
+[OpenSimplex 2S](https://github.com/KdotJPG/OpenSimplex2) 3D ("improved XY")
+noise. The shape of the slice is controlled with the `shape` attribute, as
+follows:
+
+`shape=:plane` (the default)
+: The image is constructed from an XY plane of the 'ImproveXY' variant of the
+OpenSimplex 2S noise function.
+
+`shape=:cylinder`
+: The image is constructed from a cylinder aligned along the Z axis of the
+conventional OpenSimplex 2S noise function. This will result in an evenly
+distributed noise image that seamlessly wraps on the left and right edges.
+
+`shape=:sphere`
+: The image is constructed from a sphere aligned with its poles along the Z
+axis of the conventional noise function. The image will appear distorted at the
+top and bottom edges, but will seamlessly texture-map onto a shape using
+Equirectangular UV coordinates.
+
+All of these noise shapes support the following additional attributes for
+controlling the noise function:
 
 `seed=` *SEED*
 : `!noise` generates reproducible output with the same input values. Supply a
@@ -580,11 +599,15 @@ passed into the noise function, default `1`.
 
 `origin=` *X*`;`*Y*
 : Specifies an offset for the *pre-scaled* X and Y input values, default `0`.
-The pre-scaled X and Y coordinates are in pixels from the top left.
 
 `z=` *Z*
-: Specifies a *pre-scaled* Z coordinate for the plane to be calculated,
-default `0`.
+: Specifies an offset for the *pre-scaled* Z input value, default `0`.
+
+:::{note}
+The `origin` and `z` attributes are designed primarily for animating the default
+`shape=:plane` noise form. Results will be more complicated for cylindrical
+and spherical noise.
+:::
 
 `multiplier=` *MULTIPLIER*
 : Specifies a multiplier for the final noise value, default `0.5`.

src/flitter/render/window/glsl/noise.frag

@@ -25,19 +25,35 @@ uniform sampler2D ${name};
 <%include file="noise_functions.glsl"/>
 
 
+const float Pi = 3.141592653589793115997963468544185161590576171875;
+const float Tau = 6.283185307179586231995926937088370323181152343750;
+
+
 void main() {
+% if noise_shape == 'cylinder':
+    float th = Tau * coord.x;
+    float r = size.x / Tau;
+    vec3 point = vec3(vec2(cos(th), sin(th))*r, coord.y*size.y);
+% elif noise_shape == 'sphere':
+    float th = Tau * coord.x;
+    float r = size.x / Tau;
+    float lat = Pi * (coord.y - 0.5);
+    vec3 point = vec3(vec2(cos(th), sin(th))*cos(lat)*r, sin(lat)*r);
+% else:
+    vec3 point = vec3(coord*size, 0);
+% endif
+    point += vec3(origin, z);
 % if child_textures:
 %     for name in child_textures:
 %         if loop.index == 0:
-    vec4 c = texture(${name}, coord);
+    vec4 s = texture(${name}, coord);
 %         else:
-    c = composite_${composite}(texture(${name}, coord), c);
+    s = composite_${composite}(texture(${name}, coord), s);
 %         endif
 %     endfor
-% else:
-    vec4 c = vec4(0.0);
+    point += s * tscale;
 % endif
-    vec3 point = (vec3(coord*size + origin, z) + c.xyz*tscale) * scale;
+    point *= scale;
     mat4 hashes;
     hashes[0] = vec4(seed_hash);
     hashes[1] = opensimplex2s_permute(hashes[0] + 1.0);
@@ -50,7 +66,11 @@ void main() {
         vec3 p = point / k;
         vec4 c = vec4(0.0);
         for (int j = 0; j < components; j++) {
+% if noise_shape in ('cylinder', 'sphere'):
+            c[j] = opensimplex2s(hashes[j], p);
+% else:
             c[j] = opensimplex2s_improvexy(hashes[j], p);
+% endif
         }
         sum += c * k;
         weight += k;

src/flitter/render/window/shaders.py

@@ -137,7 +137,8 @@ class Noise(Shader):
     DEFAULT_FRAGMENT_SOURCE = TemplateLoader.get_template('noise.frag')
 
     def render(self, node, references, **kwargs):
+        noise_shape = node.get('shape', 1, str, 'plane').lower()
         seed_hash = hash(node['seed'] if 'seed' in node else null) / (1 << 48)
         default_values = node.get('default', 4, float, (1, 1, 1, 1))
-        super().render(node, references, seed_hash=seed_hash, components=1, octaves=1, roughness=0.5, origin=0, z=0,
+        super().render(node, references, noise_shape=noise_shape, seed_hash=seed_hash, components=1, octaves=1, roughness=0.5, origin=0, z=0,
                        scale=1, tscale=1, multiplier=0.5, offset=0.5, default_values=default_values, **kwargs)