Browse Source

Updated Code

master
Pugnacious 8 months ago
parent
commit
33ac0219e0
  1. 30
      Collatz.xml
  2. 44
      CurlerQ.xml
  3. 50
      Gloonian.xml
  4. 601
      MyStandardXforms.xml
  5. 28
      Pringle.xml
  6. 43
      Variant1.xml
  7. 31
      average_ghosts.xml
  8. 47
      average_ghosts2.xml
  9. 36
      bearhug.xml
  10. 35
      bender.xml
  11. 35
      bloomer.xml
  12. 37
      blur_x.xml
  13. 36
      catscale.xml
  14. 96
      circle_plus_fill.xml
  15. 34
      clam.xml
  16. 44
      codePoint.xml
  17. 44
      curlinder.xml
  18. 54
      curlinder_pong.xml
  19. 48
      curlinear.xml
  20. 37
      cutout.xml
  21. 42
      elliptic_container.xml
  22. 33
      epolar.xml
  23. 47
      epolar2.xml
  24. 55
      exstripeaganza.xml
  25. 29
      fibonacci.xml
  26. 30
      formant.xml
  27. 53
      fractally.xml
  28. 61
      frank_bride.xml
  29. 58
      frank_jr.xml
  30. 51
      get_hexed.xml
  31. 48
      glitcher.xml
  32. 31
      goodbyehorses.xml
  33. 39
      green.xml
  34. 25
      half_cylinder.xml
  35. 36
      half_plane_rippler.xml
  36. 28
      handgrenade.xml
  37. 33
      headsplitter.xml
  38. 51
      hyphy_tile.xml
  39. 50
      juliacrystal.xml
  40. 55
      julian_beach.xml
  41. 64
      julian_complex.xml
  42. 29
      kleinian.xml
  43. 42
      knotty.xml
  44. 30
      log_pi.xml
  45. 39
      loonish_h.xml
  46. 44
      mathplaydough.xml
  47. 35
      mathplaydough2.xml
  48. 30
      mathplaydough3.xml
  49. 39
      mathplaydough4.xml
  50. 42
      md_disc.xml
  51. 56
      minha_menina.xml
  52. 42
      mirror_maker.xml
  53. 33
      moth.xml
  54. 34
      murl3.xml
  55. 30
      new2.xml
  56. 36
      oneHandedES.xml
  57. 70
      one_man_band.xml
  58. 45
      onesided.xml
  59. 41
      pixelshimmer.xml
  60. 36
      plane2v_o_i_d.xml
  61. 37
      ponyloafer.xml
  62. 99
      pretty_plastic.xml
  63. 34
      pulsar.xml
  64. 56
      quaternion.xml
  65. 52
      quaternionOG.xml
  66. 38
      refraction_cube.xml
  67. 34
      spatial_anomaly.xml
  68. 72
      split_mirrors_xy.xml
  69. 54
      squeeze_boqs.xml
  70. 29
      taffy.xml
  71. 31
      target_practice.xml
  72. 40
      toroidal_eye.xml
  73. 33
      waves_linear.xml
  74. 88
      what_the_fill.xml

30
Collatz.xml

@ -0,0 +1,30 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="new">
<node name="input_params">
<real name="new">1</real>
</node>
<node name="internal_params">
<real name="weight" />
</node>
<string name="winter_init_function">
<![CDATA[
new_init_result(new * pi())
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
r = length(p_in)
x = truncateToInt(r * (pi()))
y1 = sinh(toReal(x))
y2 = cosh(toReal(x))
in
((p_in * (y1 / y2)) * floor(r) / 2) * (-weight / pi())
]]>
</string>
</transform_def>
</user_transforms>

44
CurlerQ.xml

@ -0,0 +1,44 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="curlerq">
<node name="input_params">
<real name="curlerq">1</real>
<real name="curlerq_c1" >0</real>
<real name="curlerq_c2" >0</real>
<real name="curlerq_rotate" >0</real>
<real name="curlerq_axisflip" >0</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="c1" />
<real name="c2" />
<real name="rotate" />
<real name="axisflip" />
</node>
<string name="winter_init_function">
<![CDATA[
curlerq_init_result(curlerq, curlerq_c1, curlerq_c2, curlerq_rotate, curlerq_axisflip)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
re = 1 + c1 * p_in.x + c2 * (p_in.x * p_in.x - p_in.y * p_in.y)
im = (c1 + 2 * c2 * p_in.x) * p_in.y
fx = if axisflip <= 0
then sinh(p_in.x * re) + sinh(p_in.y * im)
else tanh(p_in.x * re) + sinh(p_in.y * im)
fy = if fx == sinh(p_in.x * re) + sinh(p_in.y * im)
then tanh(p_in.y * re) - tanh(p_in.x * im)
else sinh(p_in.y * re) - tanh(p_in.x * im)
fr = weight / (re * re + im * im)
in
(mat2x2(cos(rotate), -sin(rotate),
sin(rotate), cos(rotate)) * vec2(fx, fy)) * fr
]]>
</string>
</transform_def>
</user_transforms>

50
Gloonian.xml

@ -0,0 +1,50 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="gloonian">
<node name="input_params">
<real name="gloonian">1</real>
<real name="gloonian_radius_mult">1</real>
<real name="gloonian_hole">0.0</real>
<real name="gloonian_expand">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="radm" />
<real name="hole" />
<real name="exp" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
gloonian_init_result(gloonian * halfsqrt2(), gloonian_radius_mult, 1.0 - gloonian_hole, gloonian_expand)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
p_len = length(p_in)
aux = if p_len*p_len > radm then 1.0 * exp else -1.0 * exp
a2 = sqrt(p_len + p_in.x)
glynnia_out =
if unit_rnd_0 < 0.5 then
vec2(aux * a2, -p_in.y / a2) * p_len/(radm*radm)
else
vec2(aux * a2, p_in.y / a2) * (1.0 / p_len)
glynnia_r2 = dot(glynnia_out, glynnia_out)
w2 = radm*radm
loonie_r =
if glynnia_r2 < w2 then
radm * sqrt(w2 / glynnia_r2 - hole)
else
radm
in
glynnia_out * loonie_r * weight
]]>
</string>
</transform_def>
</user_transforms>

601
MyStandardXforms.xml

@ -0,0 +1,601 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="hysteria">
<!-- based on a transform by dark-beam, http://jwildfire.org/forum/viewtopic.php?f=23&t=1464
Translated to winter by TataSZ. edited by Crystalize -->
<node name="input_params">
<real name="hysteria">1</real>
<real name="hysteria_alpha">0</real>
<real name="hysteria_beta">1</real>
<real name="hysteria_gamma">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="alpha" />
<real name="beta" />
<real name="gamma" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
hysteria_init_result(hysteria, hysteria_alpha, hysteria_beta, hysteria_gamma)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
xy0 = p_in * weight
r = dot(xy0, xy0)
t = r * beta / 2
XY = vec2(abs(xy0.x) - t, abs(xy0.y) - t)
r2 = length(XY)
in1 = (r < 1.0)
condition =
if in1 && (r2 < 1.0) then
unit_rnd_0 > 0.35
else
!in1
in
if condition then
xy0
else
let
cosa = cos(pi() * alpha)
sina = sin(pi() * alpha)
xx = xy0.x * cosa + xy0.y * sina
yy = xy0.x * sina + xy0.y * cosa
n = halfpi() * gamma / 2
nx = xx / sqrt(n - yy * yy) * (n - sqrt(n - (-abs(yy) + n) * (-abs(yy) + n)))
xx2 = nx * cosa + yy * sina
yy2 = -nx * sina + yy * cosa
in
vec2(xx2, yy2)
]]>
</string>
</transform_def>
<transform_def name="gaussian2">
<node name="input_params">
<real name="gaussian2">1</real>
<real name="gaussian2_x">1</real>
<real name="gaussian2_y">1</real>
<real name="gaussian2_z">1</real>
<real name="gaussian2_mod">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="ex" />
<real name="wy" />
<real name="zi" />
<real name="mod" />
</node>
<int name="num_gauss_randoms">1</int>
<int name="num_unit_randoms">2</int>
<string name="winter_init_function">
<![CDATA[
gaussian2_init_result(gaussian2, gaussian2_x, gaussian2_y, gaussian2_z, gaussian2_mod * halfsqrt2())
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
r = unit_rnd_0 * halfpi()
n = sqrt(weight) / 2 * mod
a =
if zi == 1 then
acos(r) * twopi() * zi
else
acos(n) * tanh(zi)
s = gauss_rnd_0 * weight
in
vec2(cos(a) * ex, sin(a) * wy) * s + p_in
]]>
</string>
</transform_def>
<transform_def name="flux2">
<node name="input_params">
<real name="flux2">1</real>
<real name="flux2_s">0</real>
<real name="flux2_p">1</real>
<real name="flux2_m">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="spread" />
<real name="pe" />
<real name="em" />
</node>
<string name="winter_init_function">
<![CDATA[
flux2_init_result(flux2, flux2 * (flux2_s + 2), flux2_p, flux2_m)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
x_plus_weight = p_in.x + pe
x_less_weight = p_in.x - em
num = x_plus_weight * x_plus_weight + p_in.y * p_in.y
den = x_less_weight * x_less_weight + p_in.y * p_in.y
a = (atan2(p_in.y, x_less_weight) - atan2(p_in.y, x_plus_weight)) * 0.5
r = spread * sqrt(sqrt(num / den))
in
vec2(cos(a), sin(a)) * r
]]>
</string>
</transform_def>
<transform_def name="gloonian_early">
<node name="input_params">
<real name="gloonian">1</real>
<real name="gloonian_a">1.5</real>
<real name="gloonian_b">1</real>
<real name="gloonian_c">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="ay" />
<real name="be" />
<real name="ci" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
gloonian_early_init_result(gloonian * halfsqrt2(), gloonian_a, gloonian_b, gloonian_c)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
r2 = dot(p_in, p_in) * ci
sr = sqrt(r2) / be
aux = if r2 > 1 then ay else -ay
w2 = weight * weight
r =
if r2 < w2 then
weight * sqrt(w2 / r2 - ci)
else
weight * be
in
if unit_rnd_0 < 0.5 then
vec2(aux * sqrt(sr + p_in.x) * r, -p_in.y / sqrt(sr + p_in.x)) * weight * r
else
vec2(aux * sqrt(sr + p_in.x) * r, p_in.y / sqrt(sr + p_in.x)) * (weight / sr) * r
]]>
</string>
</transform_def>
<transform_def name="moarface">
<!-- based on an Apophysis variation by Joel Faber and Michael Faber. Variables by Crystalize -->
<node name="input_params">
<real name="moarface">1</real>
<real name="moarface_x">1</real>
<real name="moarface_y">1</real>
<real name="moarface_z">1</real>
<real name="moarface_n">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="ex" />
<real name="wy" />
<real name="ze" />
<real name="en" />
</node>
<string name="winter_init_function">
<![CDATA[
moarface_init_result(moarface, moarface_x, moarface_y, moarface_z, moarface_n)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
if p_in.x > 0.0 then
let
a = atan2(p_in.y, p_in.x)
r = ex / length(p_in)
s = sin(a) * wy
c = cos(a) * ze
in
vec2(c, s) * (weight * r)
else
p_in * weight * en
]]>
</string>
</transform_def>
<transform_def name="arctanh2">
<!-- Transform by TataSZ. Variables by Crystalize -->
<node name="input_params">
<real name="arctanh2">1</real>
<real name="arctanh2_x">1</real>
<real name="arctanh2_y">1</real>
<real name="arctanh2_z">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="ex" />
<real name="wy" />
<real name="ze" />
</node>
<string name="winter_init_function">
<![CDATA[
arctanh2_init_result(arctanh2 * invpi(), arctanh2_x, arctanh2_y, arctanh2_z)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
z = complex(p_in.x, p_in.y) * ze
result = weight * log((z + ex) / (-z + wy))
in
vec2(result.re, result.im)
]]>
</string>
</transform_def>
<transform_def name="tanh2">
<!-- Complex vars by cothe. Tatasz added a pi re-scale. Variables by Crystalize -->
<node name="input_params">
<real name="tanh2">1</real>
<real name="tanh2_x">0.5</real>
<real name="tanh2_y">0.5</real>
<real name="tanh2_z">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="ex" />
<real name="wy" />
<real name="ze" />
</node>
<string name="winter_init_function">
<![CDATA[
tanh2_init_result(tanh2, tanh2_x, tanh2_y, tanh2_z)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
x = ex * pi() * p_in.x
y = wy * pi() * p_in.y
tanhsin = sin(y)
tanhcos = cos(y)
tanhsinh = sinh(x)
tanhcosh = cosh(x)
tanhden = if ze > 1 then ze / (tanhcos + tanhcosh) * log(sqrt(ex / wy)) else ze / (tanhcos + tanhcosh)
in
vec2(tanhsinh, tanhsin) * (weight * tanhden)
]]>
</string>
</transform_def>
<transform_def name="elliptix">
<node name="input_params">
<real name="elliptix">1</real>
<real name="elliptix_x">1</real>
<real name="elliptix_y">1</real>
<real name="elliptix_z">-0.05</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="ex" />
<real name="wy" />
<real name="ze" />
</node>
<string name="winter_init_function">
<![CDATA[
elliptix_init_result(elliptix * twoinvpi(), elliptix_x, elliptix_y, elliptix_z)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
tmp = dot(p_in, p_in) + 1
x2 = if ex > 0 then 2 * p_in.x else 2 * p_in.y
xmax = 0.5 * (sqrt(tmp + x2) + sqrt(tmp - x2))
a = p_in.x / xmax
#b = sqrt(max(0, 1 - a * a))
w = if p_in.y > 0 then weight else -weight
fx = asin(a) * weight / wy
#fx = atan2(a, b) * weight
fy = if ze < 0 then log(xmax + sqrt(max(0, xmax - 1))) * w else log(xmax + sqrt(max(0, xmax - 1))) * ze * wy
in
vec2(fx, fy)
]]>
</string>
</transform_def>
<transform_def name="ellipticplane">
<node name="input_params">
<real name="ellipticplane">1</real>
</node>
<node name="internal_params">
<real name="weight" />
</node>
<string name="winter_init_function">
<![CDATA[
ellipticplane_init_result(ellipticplane * twoinvpi())
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
tmp = dot(p_in, p_in) + 1
x2 = 2 * p_in.x
xmax = 0.5 * (sqrt(tmp + x2) + sqrt(tmp - x2))
a = p_in.x / xmax
#b = sqrt(max(0, 1 - a * a))
w = if p_in.y > 0 then weight else -weight
fx = atanh(a) * weight
#fx = acosh2(a, b) * weight
fy = log(xmax + sqrt(max(0, xmax - 1))) * w
in
vec2(fx, fy)
]]>
</string>
</transform_def>
<transform_def name="frank2">
<!-- Based on a transform by Tatasz and Chaosfissure Complex vars by cothe. Tatasz added a pi re-scale -->
<node name="input_params">
<real name="frank2">1</real>
<real name="mult_x">1</real>
<real name="mult_y">1</real>
<real name="sine">0</real>
<real name="sin_x_amplitude">1</real>
<real name="sin_x_freq">0.1</real>
<real name="sin_y_amplitude">2</real>
<real name="sin_y_freq">0.2</real>
<real name="mode">0</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="mult_x" />
<real name="mult_y" />
<real name="sine" />
<real name="xamp" />
<real name="xfreq" />
<real name="yamp" />
<real name="yfreq" />
<real name="mode" />
</node>
<string name="winter_init_function">
<![CDATA[
frank2_init_result(frank2, mult_x, mult_y, sine, sin_x_amplitude, sin_x_freq, sin_y_amplitude, sin_y_freq, mode)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
x = quartpi() * p_in.x
y = quartpi() * p_in.y
cschcos = cos(y)
cschsin = sin(y)
cschsinh = sinh(x)
cschcosh = cosh(x)
sechden = 2.0 / (cos(2.0 * y) + cosh(2.0 * x))
sech_output = vec2(cschcos * cschcosh, cschsin * cschsinh) * (weight * sechden)
r = weight / sqrt((sech_output.y * sech_output.y * mult_y) + (mult_x * sech_output.x * sech_output.x))
factor =
if sine <= 0.0 then
vec2(xamp, yamp)
else
let
pi_xfreq = pi() * sech_output.x
pi_yfreq = pi() * sech_output.y
tmp_vec = vec2(1.0, 2.0)
scalar_xy =
if mode <= 0.0 then
vec2(sech_output.x, sech_output.y)
else
if mode <= 1.0 then
vec2(exp(-sech_output.x), exp(-sech_output.y))
else
if mode <= 2.0 then
vec2(1.0 / sech_output.x, 1.0 / sech_output.y)
else
if mode <= 3.0 then
vec2(log(abs(sech_output.x)), yamp * log(abs(sech_output.y)))
else
vec2(atan2(sech_output.x, sech_output.y), atan2(sech_output.y, sech_output.x))
in
tmp_vec + vec2(xamp * sin(scalar_xy.x * pi_xfreq), yamp * sin(scalar_xy.y * pi_yfreq))
in
vec2(factor.x * (sech_output.x - sech_output.y) * (sech_output.x + mult_y * sech_output.y), factor.y * sech_output.x * sech_output.y) * r
]]>
</string>
</transform_def>
<transform_def name="frank">
<!-- Complex vars by cothe. Tatasz added a pi re-scale -->
<node name="input_params">
<real name="frank">1</real>
<real name="frank_power">2</real>
<real name="frank_dist">1</real>
<real name="frank_a">1</real>
<real name="frank_b">0</real>
<real name="frank_c">0</real>
<real name="frank_d">1</real>
<real name="frank_e">0</real>
<real name="frank_f">0</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="power" />
<real name="dist_power_2" />
<real name="a" />
<real name="b" />
<real name="c" />
<real name="d" />
<real name="e" />
<real name="f" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
frank_init_result(frank, frank_power, frank_dist / frank_power * 0.5, frank_a, frank_b, frank_c, frank_d, frank_e, frank_f)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
x = halfpi() * p_in.x
y = halfpi() * p_in.y
tanhsin = sin(y)
tanhcos = cos(y)
tanhsinh = sinh(x)
tanhcosh = cosh(x)
tanhden = 1.0 / (tanhcos + tanhcosh)
xh = tanhsinh * tanhden
yh = tanhsin * tanhden
xj = a * xh + b * yh + e
yj = c * xh + d * yh + f
root = truncateToInt(abs(power) * unit_rnd_0)
a = (atan2(yj, xj) + toReal(root) * twopi()) / power
r = weight * pow(xj * xj + yj * yj, dist_power_2)
in
vec2(cos(a), sin(a)) * r
]]>
</string>
</transform_def>
<transform_def name="pixel_flow">
<!-- Transform by bezo97 -->
<node name="input_params">
<real name="pixel_flow">1.0</real>
<real name="pixel_flow_angle">90.0</real>
<real name="pixel_flow_length">0.1</real>
<real name="pixel_flow_width">200.0</real>
<real name="pixel_flow_power">10.0</real>
<int name="pixel_flow_seed">42</int>
</node>
<node name="internal_params">
<real name="weight" />
<real name="dirx" />
<real name="diry" />
<real name="length" />
<real name="width" />
<real name="power" />
<int name="seed" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
let
a_rad = pixel_flow_angle * 0.0174532925
dirx = cos(a_rad)
diry = sin(a_rad)
in
pixel_flow_init_result(pixel_flow, dirx, diry, pixel_flow_length, pixel_flow_width, pixel_flow_power, pixel_flow_seed)
]]><!--angle: deg to rad-->
</string>
<string name="winter_eval_function">
<![CDATA[
let
block = floor(p_in * width)
vblock = block + vec2(2.0, 2.0) - 4.0 * vec2(hash_shadertoy(block.x * seed + 1, 0, seed), hash_shadertoy(0, block.y * seed + 1, seed))
fLen = hash_shadertoy(vblock.x, vblock.y, seed * 2)
fade = pow(unit_rnd_0, power) * fLen
in
vec2(dirx, diry) * length * fade * weight
]]>
</string>
</transform_def>
<transform_def name="hex_modulus">
<node name="input_params">
<real name="hex_modulus">1</real>
<real name="hex_modulus_size" notes="crop width">0.2</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="hsize" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
let
hsize = halfsqrt3() / hex_modulus_size
weight = hex_modulus / halfsqrt3()
in
hex_modulus_init_result(weight, hsize)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
XY0 = p_in * hsize
x = (0.57735026918962576450914878050196 * XY0.x - XY0.y / 3.0)
z = (2.0 * XY0.y / 3.0)
y = -x - z
#round
rx = floor(x + 0.5)
ry = floor(y + 0.5)
rz = floor(z + 0.5)
x_diff = abs(rx - x)
y_diff = abs(ry - y)
z_diff = abs(rz - z)
r_final =
if (x_diff > y_diff && x_diff > z_diff) then
vec3(-ry-rz, ry, rz)
else
if (y_diff > z_diff) then
vec3(rx, -rx-rz, rz)
else
vec3(rx, ry, -rx-ry)
FXY_h = vec2(sqrt3() * e0(r_final) + halfsqrt3() * e2(r_final), 1.5 * e2(r_final))
in
(XY0 - FXY_h) * weight
]]>
</string>
</transform_def>
</user_transforms>

28
Pringle.xml

@ -0,0 +1,28 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="pringle">
<node name="input_params">
<real name="pringle">1</real>
<real name="pringle_a">0.5</real>
<real name="pringle_b">-1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="a" />
<real name="b" />
</node>
<string name="winter_init_function">
<![CDATA[
pringle_init_result(pringle, pringle_a, pringle_b)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
mat2x2(sin(p_in.x), sin(p_in.y), cos(p_in.x), cos(p_in.y)) * vec2((a * p_in.x), (b * p_in.y)) * weight
]]>
</string>
</transform_def>
</user_transforms>

43
Variant1.xml

@ -0,0 +1,43 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="variant1">
<node name="input_params">
<real name="variant1">1</real>
<real name="variant1_holes">0</real>
<real name="variant1_eccentricity">0.5</real>
<real name="variant1_rotate">0</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="holes" />
<real name="ecc" />
<real name="rotate" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
variant1_init_result(variant1, variant1_holes, variant1_eccentricity, variant1_rotate)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
rotmat = mat2x2(cos(rotate), -sin(rotate),
sin(rotate), cos(rotate))
d = length(p_in)
r = weight * (unit_rnd_0 - holes) * ecc / (d + ecc * p_in.x)
conic_out = p_in * r
p = rotmat * conic_out
fx = tanh(p_in.x * p.x) + sinh(p_in.y * p.y)
fy = sinh(p_in.y * p.x) - tanh(p_in.x * p.y)
fr = weight * (p.x * p.x + p.y * p.y)
in
vec2(fx, fy) * fr
]]>
</string>
</transform_def>
</user_transforms>

31
average_ghosts.xml

@ -0,0 +1,31 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="average_ghosts">
<node name="input_params">
<real name="average_ghosts">1</real>
</node>
<node name="internal_params">
<real name="weight" />
</node>
<string name="winter_init_function">
<![CDATA[
average_ghosts_init_result(average_ghosts * pi())
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
n = complex(sin(toReal(truncateToInt(p_in.x))), cos(toReal(truncateToInt(p_in.y))))
r = length(vec2(n.im + n.re)) * twoinvpi()
x = truncateToInt(r)
y1 = log(complex(tan(toReal(x)), sin(toReal(x))))
y2 = log(complex(cos(toReal(x)), tan(toReal(x))))
in
(p_in * vec2(y1.im + y2.re).x * floor(r)) * (0.1 / weight)
]]>
</string>
</transform_def>
</user_transforms>

47
average_ghosts2.xml

@ -0,0 +1,47 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="average_ghosts2">
<!-- Transform by Crystalize -->
<node name="input_params">
<real name="average_ghosts2">1</real>
<real name="average_ghosts2_param1">1</real>
<real name="average_ghosts2_param2">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="p1" />
<real name="p2" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
average_ghosts2_init_result(average_ghosts2 * invpi(), average_ghosts2_param1, average_ghosts2_param2)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
I = truncateToInt(p_in.x * p_in.y)
II = truncateToInt(p_in.y)
n =
if p2 > 0
then
if unit_rnd_0 * (p_in.x / p_in.y) / p2 < 0.0
then complex((toReal(I)), (toReal(truncateToInt((hash_shadertoy(p_in.x, p_in.y, weight)))) * p2))
else complex((toReal(truncateToInt((hash_shadertoy(p_in.y, p_in.x, p_in.x / p_in.y))))), cos(toReal(II)) * p2)
else complex(sin(toReal(truncateToInt(p_in.x))), cos(toReal(truncateToInt(p_in.y))) * -p2)
r = length(vec2(n.im + n.re)) * twoinvpi()
x = if p1 > 0 then truncateToInt(r * p1) else (truncateToInt((r * p1) * sqrt(n.im * 100)))
y = truncateToInt((log(n).re * log(n).im) * (twoinvpi() * p1))
y1 = log(complex(tanh(toReal(x)), sinh(toReal(x))))
y2 = log(complex(cosh(toReal(y)), tanh(toReal(y))))
in
(p_in * vec2(y1.im + y2.re).x * floor(r)) * (0.1 * weight)
]]>
</string>
</transform_def>
</user_transforms>

36
bearhug.xml

@ -0,0 +1,36 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="bearhug">
<node name="input_params">
<real name="bearhug">1</real>
<real name="bearhug_x">1</real>
<real name="bearhug_y">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="ex" />
<real name="wy" />
</node>
<string name="winter_init_function">
<![CDATA[
bearhug_init_result(bearhug, bearhug_x, bearhug_y)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
m = wy * cosh(p_in.y)
n = (dot(p_in, p_in)) * ex
px = (p_in.x) * n
py = (p_in.y) * m
c = complex(px, py)
in
vec2(c.im, c.re) * weight
]]>
</string>
</transform_def>
</user_transforms>

35
bender.xml

@ -0,0 +1,35 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="bender">
<!-- made by Crystalize -->
<node name="input_params">
<real name="bender" >1</real>
<real name="bender_x" >1</real>
<real name="bender_y" >0</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="ex" />
<real name="wy" />
</node>
<string name="winter_init_function">
<![CDATA[
bender_init_result(bender, bender_x, bender_y)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
x = halfpi() * p_in.x
y = halfpi() * p_in.y
matrix = mat2x2(sinh(y) * wy, cosh(x) * ex,
-cosh(x) * ex, sinh(y) * wy)
in
(matrix * p_in) * weight
]]>
</string>
</transform_def>
</user_transforms>

35
bloomer.xml

@ -0,0 +1,35 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="bloomer">
<node name="input_params">
<real name="bloomer">1</real>
<real name="bloomer_re">1</real>
<real name="bloomer_im">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="nre" />
<real name="nim" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
bloomer_init_result(bloomer, bloomer_re, bloomer_im)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
cin = complex(dot(p_in, p_in), dot(p_in, p_in))
cxy = complex(p_in.x * nre, p_in.y * nim) * pi()
bc = (cin * cxy) - cin * 2
in
vec2(bc.re, bc.im) * weight
]]>
</string>
</transform_def>
</user_transforms>

37
blur_x.xml

@ -0,0 +1,37 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="blur_x">
<node name="input_params">
<real name="blur_x">1</real>
<real name="blur_x_a">0.5</real>
<real name="blur_x_b">-1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="a" />
<real name="b" />
</node>
<int name="num_unit_randoms">2</int>
<string name="winter_init_function">
<![CDATA[
blur_x_init_result(blur_x, blur_x_a, blur_x_b)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
t2 = (unit_rnd_0 - 0.5) * (pi() / a)
t3 = (unit_rnd_1) * (pi() / b)
aux = (cos(a * t2) + sin(t3))
x = p_in.x * ((weight / 0.5) * p_in.x)
y = p_in.y * ((weight / 1) * p_in.y)
in
vec2(sin(t2) / aux, cos(a * t2) / aux) * (sin(x) * cos(y)) * weight
]]>
</string>
</transform_def>
</user_transforms>

36
catscale.xml

@ -0,0 +1,36 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="catscale">
<node name="input_params">
<real name="catscale">1</real>
<real name="catscale_prrr">1</real>
<real name="catscale_meow">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="a" />
<real name="b" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
catscale_init_result(catscale, catscale_prrr, catscale_meow)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
r1 = (a * p_in.y)
r2 = (b * p_in.y)
x = invpi() * cosh(p_in.x) / r1
y = invpi() * sinh(p_in.y) / r2
in
vec2((x), (y)) * (p_in.y * p_in.x) * (weight * 2)
]]>
</string>
</transform_def>
</user_transforms>

96
circle_plus_fill.xml

@ -0,0 +1,96 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="circle_plus_fill">
<node name="input_params">
<real name="circle_plus_fill">1</real>
<real name="circle_plus_fill_zero" minval="0" maxval="1">0</real>
<real name="circle_plus_fill_hemi_gaussian">1</real>
<real name="circle_plus_fill_AT_rotate">1</real>
<real name="circle_plus_fill_hemi_AT_switch" minval="0" maxval="1">0</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="zero" />
<real name="g_power" />
<real name="atr" />
<real name="hatswitch" />
</node>
<int name="num_unit_randoms">3</int>
<int name="num_gauss_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
circle_plus_fill_init_result(circle_plus_fill, circle_plus_fill_zero, circle_plus_fill_hemi_gaussian, circle_plus_fill_AT_rotate * quartpi(), circle_plus_fill_hemi_AT_switch)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
cri = 1.0
cro = 10000000.0
r_min = min(cri, cro)
r_max = max(cri, cro)
rad = length(p_in)
ang = atan2(p_in.y, p_in.x)
s = sin(ang)
c = cos(ang)
crop_out = if rad > cro || rad < cri
then if zero == 0.0
then vec2(0.0, 0.0)
else vec2(c, s) * (cro * weight)
else p_in * weight
ur = unit_rnd_0 * twopi()
gr = gauss_rnd_0 * g_power
g = vec2(cos(ur), sin(ur)) * gr + p_in
hemi = g * (weight / sqrt(dot(g, g) + 1))
cri2 = 0.9
cro2 = 1.0
r_min2 = min(cri2, cro2)
r_max2 = max(cri2, cro2)
rad3 = length(hemi)
ang2 = atan2(hemi.y, hemi.x)
s3 = sin(ang2)
c3 = cos(ang2)
crop_out2 = if rad3 > cro2 || rad3 < cri2
then if zero == 0.0
then vec2(0.0, 0.0)
else vec2(c3, s3) * (cro2 * weight)
else hemi * weight
rotm = mat2x2(cos(atr), -sin(atr),
sin(atr), cos(atr))
at_in = rotm * p_in
z = complex(at_in.x, at_in.y)
result = (weight * invpi()) * log((z + 1.0) / (-z + 1.0))
cA = max(-1.0, min(0.0, 1.0))
xi = result.re
yi = result.im
w2 = weight * 0.9
rad2 = sqrt(xi * xi + yi * yi)
at_out = lerp(if rad2 > 1 then if zero == 0 then vec2(0.0, 0.0)
else let
ang2 = atan2(yi, xi)
rdc = 1 + (unit_rnd_0 * 0.5 * cA)
s2 = sin(ang2)
c2 = cos(ang2)
in
vec2(w2 * rdc * c2, w2 * rdc * s2)
else vec2(w2 * xi, w2 * yi), crop_out2, if unit_rnd_2 >= 0.9
then 1.0
else 0.0)
in
lerp(crop_out, (if hatswitch == 0.0
then at_out
else hemi), if unit_rnd_1 >= 0.75
then 1.0
else 0.0)
]]>
</string>
</transform_def>
</user_transforms>

34
clam.xml

@ -0,0 +1,34 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="clam">
<node name="input_params">
<real name="clam">1</real>
<real name="clam_x" minval = "-1.5" maxval = "1.5">1.5</real>
<real name="clam_y">0.05</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="x" />
<real name="y" />
</node>
<string name="winter_init_function">
<![CDATA[
clam_init_result(clam * pi(), clam_x, clam_y)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
a = complex(sin(p_in.x) * x, tan((p_in.x) * x))
b = complex(pow(cos(p_in.y) * y, (tan((p_in.y) * y))), pow(cos(p_in.y) * y, (tan((p_in.y) * y)))) / 2
c = tanh(b.re / a.im)
d = tanh(a.re / b.im)
in
p_in * (vec2(c).x * vec2(d).y) * (weight)
]]>
</string>
</transform_def>
</user_transforms>

44
codePoint.xml

@ -0,0 +1,44 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="codePoint_x">
<node name="input_params">
<real name="codePoint_x">1</real>
<real name="codePoint_x_x">1</real>
<real name="codePoint_x_y">1</real>
<real name="codePoint_x_r">0</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="a2" />
<real name="b2" />
<real name="r" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
codePoint_x_init_result(codePoint_x * (pi() * 10000), codePoint_x_x, codePoint_x_y, codePoint_x_r * quartpi())
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
rotmat = mat2x2(cos(r), -sin(r),
sin(r), cos(r))
x = complex(p_in.x - toReal(codePoint('\u{a2}')), p_in.y - toReal(codePoint('\u{b2}')))
y = (x / sqrt(x * (x + 1.0)))
z = vec2(y.re, y.im)
p = rotmat * z
fx = (tan(p_in.x * p.x) * cos(p_in.y * p.y)) / (toReal(codePoint('\u{a2}')))
fy = (cos(p_in.y * p.x) * tan(p_in.x * p.y)) / (toReal(codePoint('\u{b2}')))
fr = (weight) * (p.x * p.x - p.y * p.y)
in
normalise(vec2(fx, fy)) * fr
]]>
</string>
</transform_def>
</user_transforms>

44
curlinder.xml

@ -0,0 +1,44 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="curlinder">
<node name="input_params">
<real name="curlinder">1</real>
<real name="curlinder_c1" >0</real>
<real name="curlinder_c2" >0</real>
<real name="curlinder_rotate" >0</real>
<real name="curlinder_axisflip" >0</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="c1" />
<real name="c2" />
<real name="rotate" />
<real name="axisflip" />
</node>
<string name="winter_init_function">
<![CDATA[
curlinder_init_result(curlinder, curlinder_c1, curlinder_c2, curlinder_rotate, curlinder_axisflip)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
re = 1 + c1 * p_in.x + c2 * (p_in.x * p_in.x - p_in.y * p_in.y)
im = (c1 + 2 * c2 * p_in.x) * p_in.y
fx = if axisflip <= 0
then sinh(p_in.x * re) + sinh(p_in.y * im)
else tanh(p_in.x * re) + sinh(p_in.y * im)
fy = if fx == sinh(p_in.x * re) + sinh(p_in.y * im)
then tanh(p_in.y * re) - tanh(p_in.x * im)
else sinh(p_in.y * re) - tanh(p_in.x * im)
fr = weight / (re * re + im * im)
in
(mat2x2(cos(rotate), -sin(rotate),
sin(rotate), cos(rotate)) * vec2(fx, fy)) * fr
]]>
</string>
</transform_def>
</user_transforms>

54
curlinder_pong.xml

@ -0,0 +1,54 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="curlinderplus">
<node name="input_params">
<real name="curlinderplus">1</real>
<real name="curlinderplus_c1" >0</real>
<real name="curlinderplus_c2" >0</real>
<real name="curlinderplus_rotate" >0</real>
<real name="curlinderplus_axisflip" >0</real>
<real name="curlinderplus_matswitch" >0</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="c1" />
<real name="c2" />
<real name="rotate" />
<real name="axisflip" />
<real name="matswitch" />
</node>
<string name="winter_init_function">
<![CDATA[
curlinderplus_init_result(curlinderplus, curlinderplus_c1, curlinderplus_c2, curlinderplus_rotate,
curlinderplus_axisflip, curlinderplus_matswitch)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
mat1 = mat2x2(sinh(p_in.x), tanh(p_in.x),
tanh(p_in.y), sinh(p_in.y))
rotmat = mat2x2(cos(rotate), -sin(rotate),
sin(rotate), cos(rotate))
curl_out = vec2(
1 + c1 * p_in.x + c2 * (p_in.x * p_in.x - p_in.y * p_in.y),
(c1 + 2 * c2 * p_in.x) * p_in.y)
p = (if matswitch <= 0
then rotmat
else mat1) * curl_out
fx = if axisflip <= 0
then sinh(p_in.x * p.x) + sinh(p_in.y * p.y)
else tanh(p_in.x * p.x) + sinh(p_in.y * p.y)
fy = if fx == sinh(p_in.x * p.x) + sinh(p_in.y * p.y)
then tanh(p_in.y * p.x) - tanh(p_in.x * p.y)
else sinh(p_in.y * p.x) - tanh(p_in.x * p.y)
fr = weight * (p.x * p.x + p.y * p.y)
in
vec2(fx, fy) * fr
]]>
</string>
</transform_def>
</user_transforms>

48
curlinear.xml

@ -0,0 +1,48 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="curlinear">
<!-- Transform by bezo97 -->
<node name="input_params">
<real name="curlinear">1.0</real>
<real name="curlinear_c1">0.0</real>
<real name="curlinear_c2">0.0</real>
<int name="curlinear_t">0.0</int>
<int name="curlinear_r">0.0</int>
</node>
<node name="internal_params">
<real name="weight" />
<real name="c1" />
<real name="c2" />
<real name="t" />
<real name="r" />
</node>
<string name="winter_init_function">
<![CDATA[
curlinear_init_result(curlinear, curlinear_c1, curlinear_c2, curlinear_t, curlinear_r * halfpi())
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
rotm = mat2x2(cos(r), -sin(r),
sin(r), cos(r))
linear_out = rotm * p_in
re = 1 + c1 * p_in.x + c2 * (p_in.x * p_in.x - p_in.y * p_in.y)
im = (c1 + 2 * c2 * p_in.x) * p_in.y
fx = p_in.x * re + p_in.y * im
fy = p_in.y * re - p_in.x * im
fr = weight / (re * re + im * im)
curl_out = vec2(fx, fy) * fr
t2 = t * clamp(1.0 - length(p_in), 0.0, 1.0)
in
lerp(linear_out, curl_out, t2) * weight
]]>
</string>
</transform_def>
</user_transforms>

37
cutout.xml

@ -0,0 +1,37 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="cutout">
<node name="input_params">
<real name="cutout">1</real>
<real name="cutout_a">1.6180339887498</real>
<real name="cutout_b">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="a" />
<real name="b" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
cutout_init_result(cutout, cutout_a, cutout_b)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
c1 = (a * b) / log(dot(p_in, p_in))
c2 = log(dot(p_in, p_in)) * ((p_in.x / a) * (p_in.y / b))
r1 = toReal(truncateToInt(cosh(c1))) * (p_in.x / p_in.y)
r2 = toReal(truncateToInt(sinh(c2))) * (p_in.y / p_in.x)
n = tanh(r1 * r2)
in
((p_in * n) * weight) * tanh(a * b) * quartpi()
]]>
</string>
</transform_def>
</user_transforms>

42
elliptic_container.xml

@ -0,0 +1,42 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="elliptic_container">
<node name="input_params">
<real name="elliptic_container">1</real>
<real name="elliptic_container_t" minval="0" maxval="1">0</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="t" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
elliptic_container_init_result(elliptic_container, elliptic_container_t)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
tmp = dot(p_in, p_in) + 1
x2 = 2 * p_in.x
xmax = 0.5 * (sqrt(tmp + x2) + sqrt(tmp - x2))
a = p_in.x / xmax
#b = sqrt(max(0, 1 - a * a))
w = if p_in.y > 0 then weight else -weight
fx = asin(a) * (weight * twoinvpi())
#fx = atan2(a, b) * (weight * twoinvpi())
fy = log(xmax + sqrt(max(0, xmax - 1))) * w
el_out = vec2(fx, fy)
cl_out = vec2(p_in.x / sqrt(p_in.x * p_in.x + 1.0), p_in.y) * weight
in
lerp(el_out, cl_out, t)
]]>
</string>
</transform_def>
</user_transforms>

33
epolar.xml

@ -0,0 +1,33 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="epolar">
<!-- Xform by Crystalize, based on the wonderful work of Tatasz -->
<node name="input_params">
<real name="epolar">1</real>
<real name="epolar_length" minval="0" >1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="t" />
</node>
<string name="winter_init_function">
<![CDATA[
epolar_init_result(epolar * invpi(), epolar_length)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
tmp = dot(p_in, p_in) + t
z = complex(p_in.y, p_in.x)
result = weight * log((z * tmp) + (z * tmp))
in
vec2(result.im, result.re)
]]>
</string>
</transform_def>
</user_transforms>

47
epolar2.xml

@ -0,0 +1,47 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="epolar2">
<!-- Xform by Crystalize, based on the wonderful work of Tatasz -->
<node name="input_params">
<real name="epolar2">1</real>
<real name="epolar2_length" minval="0" >1</real>
<real name="epolar2_a">1</real>
<real name="epolar2_b">0</real>
<real name="epolar2_c">0</real>
<real name="epolar2_d">1</real>
<real name="epolar2_e">0</real>
<real name="epolar2_f">0</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="t" />
<real name="a" />
<real name="b" />
<real name="c" />
<real name="d" />
<real name="e" />
<real name="f" />
</node>
<string name="winter_init_function">
<![CDATA[
epolar2_init_result(epolar2 * invpi(), epolar2_length, epolar2_a, epolar2_b, epolar2_c, epolar2_d, epolar2_e, epolar2_f)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
x = a * p_in.x + b * p_in.y + e
y = c * p_in.x + d * p_in.y + f
tmp = dot(p_in, p_in) + t
z = complex(y, x)
result = weight * log((z * tmp) + (z * tmp))
in
vec2(result.im, result.re)
]]>
</string>
</transform_def>
</user_transforms>

55
exstripeaganza.xml

@ -0,0 +1,55 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="exstripeaganza">
<node name="input_params">
<real name="exstripeaganza">1</real>
<real name="exstripeaganza_up" minval="0.0" maxval="0.999999999999">0</real>
<real name="exstripeaganza_down" minval="0.0" maxval="0.999999999999">0</real>
<real name="exstripeaganza_symm">0</real>
<real name="exstripeaganza_seed">0</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="up" />
<real name="down" />
<real name="symm" />
<real name="seed" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
exstripeaganza_init_result(exstripeaganza, exstripeaganza_up ,exstripeaganza_down ,exstripeaganza_symm ,exstripeaganza_seed)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
y=
if p_in.y<0 then
pow(invpi(), 1 / log(up)) - 1 + quartpi()
else
pow(invpi(), 1 / log(down)) - 1 + quartpi()
a = toReal(truncateToInt(y * p_in.x + seed))
thing = p_in * hash_shadertoy(a * 4, a * 2, exp(seed/100000))
thing2=
if symm > 0 then
if abs(thing.x) < symm / 2 then
if unit_rnd_0 < 0.5 then
vec2(thing.x, thing.y)
else
vec2(thing.x, -thing.y)
else
thing
else
thing
in
thing2 * weight
]]>
</string>
</transform_def>
</user_transforms>

29
fibonacci.xml

@ -0,0 +1,29 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="fractally">
<node name="input_params">
<real name="fractally">1</real>
</node>
<node name="internal_params">
<real name="weight" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
fractally_init_result(fractally)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
a = vec2(cos(p_in.x) * sin(p_in.y))
in
a * weight
]]>
</string>
</transform_def>
</user_transforms>

30
formant.xml

@ -0,0 +1,30 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="formant">
<node name="input_params">
<real name="formant">1</real>
<real name="formant_operator1">1</real>
<real name="formant_operator2">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="op1" />
<real name="op2" />
</node>
<int name="num_unit_randoms">2</int>
<string name="winter_init_function">
<![CDATA[
formant_init_result(formant, formant_operator1 * twopi(), formant_operator2)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
((p_in * (vec2(op2).x)) / ((p_in.x - op1) * (p_in.y))) * weight
]]>
</string>
</transform_def>
</user_transforms>

53
fractally.xml

@ -0,0 +1,53 @@
<?xml version="1.0" encoding="utf-8"?>
<user_transforms>
<transform_def name="fractally">
<node name="input_params">
<real name="fractally">1</real>
<real name="fractally_a">1</real>
<real name="fractally_b">1</real>
<real name="fractally_c">1</real>
<real name="fractally_d">1</real>
<real name="fractally_e">1</real>
<real name="fractally_f">1</real>
</node>
<node name="internal_params">
<real name="weight" />
<real name="a" />
<real name="b" />
<real name="c" />
<real name="d" />
<real name="e" />
<real name="f" />
</node>
<int name="num_unit_randoms">1</int>
<string name="winter_init_function">
<![CDATA[
fractally_init_result(fractally, fractally_a, fractally_b, fractally_c, fractally_d, fractally_e, fractally_f)
]]>
</string>
<string name="winter_eval_function">
<![CDATA[
let
x = pi() * p_in.x
y = pi() * p_in.y
tanhsin = sin(y)
tanhcos = cos(y)
tanhsinh = sinh(x)
tanhcosh = cosh(x)
tanhden = 1.0 / (tanhcos + tanhcosh)
xh = tanhsinh * tanhden
yh = tanhsin * tanhden
xj = a * xh + b * yh + e
yj = c * xh + d * yh + f
G = atan2(xj, yj) * twoinvpi()
in
vec2(G) * weight
]]>
</string>
</transform_def>
</user_transforms>

61
frank_bride.xml