forked from Crystalize/crystalize_xforms
parent
acc0061163
commit
33ac0219e0
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)) |
||||
|
||||