forked from Crystalize/crystalize_xforms
74 changed files with 3779 additions and 0 deletions
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
|
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
|
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||
@ -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> |
|||