Igor Elovikov
249 lines
8.3 KiB
Plaintext
249 lines
8.3 KiB
Plaintext
:: import "macros.sex" as macros
|
|
|
|
:: if grayscale
|
|
declare_inputs("curve_polar_splatter")
|
|
:: else
|
|
declare_inputs("curve_polar_splatter_color")
|
|
:: endif
|
|
|
|
|
|
:: for i in range(16)
|
|
pt{{ i }} = get_float2("pt{{ i }}")
|
|
spt{{ i }} = get_float2("spt{{ i }}")
|
|
:: endfor
|
|
|
|
current_index = get_int("current_index")
|
|
even_index = get_int("even_index")
|
|
alpha = get_float("alpha")
|
|
tension = get_float("tension")
|
|
npoints = get_int("npoints")
|
|
is_closed = get_bool("is_closed")
|
|
alpha_src = get_float("alpha_src")
|
|
tension_src = get_float("tension_src")
|
|
npoints_src = get_int("npoints_src")
|
|
is_closed_src = get_bool("is_closed_src")
|
|
|
|
prev_point = get_float2("prev_point")
|
|
acc_dist = get_float("acc_dist")
|
|
total_dist = get_float("total_dist")
|
|
|
|
n = get_float("$number")
|
|
iters = get_int("total_samples")
|
|
|
|
bridge_current_distance = get_float("bridge_current_distance")
|
|
|
|
|
|
iters_m1 = iters - 1 if iters > 1 else iters
|
|
iters_m1 = iters if is_closed and not is_resample else iters_m1
|
|
fiters = tofloat(iters_m1)
|
|
|
|
norm_iter = n / fiters
|
|
bridge_n = norm_iter
|
|
norm_iter = (norm_iter * spins) % 1.0
|
|
norm_iter_src = norm_iter
|
|
|
|
frag_size = 1.0 / get_float2("$size").x
|
|
carved_niter = n / fiters
|
|
|
|
|
|
mod_sample_non_carved = frag_size / 2.0 + norm_iter * (1.0 - frag_size)
|
|
mod_sample_carved = frag_size / 2.0 + carved_niter * (1.0 - frag_size)
|
|
|
|
:: for i in range(1, 9)
|
|
|
|
modifier_op = modifier_{{ i }}_addmult
|
|
|
|
mod_sample = mod_sample_carved if modifier{{ i }}_carve else mod_sample_non_carved
|
|
|
|
modifier{{ i }} = samplelum(vector2(mod_sample, 0.5), {{ i + 9 }}, 0)
|
|
modifier{{ i }} = modifier{{ i }} * modifier_op.x + modifier_op.y
|
|
|
|
:: endfor
|
|
|
|
c_sample = {{ macros.sample_curve("norm_iter", "npoints", "is_closed", "alpha", "tension", "pt") }}
|
|
point = c_sample.xy
|
|
|
|
sample_dist = get_float("min_dist")
|
|
prev_point = point if n < 1.0 else prev_point
|
|
|
|
segment_vector = point - prev_point
|
|
segment_dist = length_vec2(segment_vector)
|
|
|
|
segment_dir = normalize_vec2(segment_vector) if segment_dist > 0.0000001 else float2(0.0, 1.0)
|
|
acc_dist = acc_dist + segment_dist
|
|
|
|
overshoot = (acc_dist > sample_dist)
|
|
overshoot_dist = acc_dist - sample_dist
|
|
acc_dist = acc_dist if not overshoot else 0.0
|
|
p_dst = segment_dist - overshoot_dist
|
|
|
|
out_point = prev_point + segment_dir @ p_dst if overshoot else float2(0.0, 0.0)
|
|
out_point = point if n < 1.0 or not is_resample else out_point
|
|
|
|
#################################################
|
|
|
|
## Calculate src curve
|
|
|
|
c_sample = {{ macros.sample_curve("norm_iter_src", "npoints_src", "is_closed_src", "alpha_src", "tension_src", "spt") }}
|
|
src_point = c_sample.xy
|
|
src_point = center_pos if center_mode == 1 else src_point
|
|
|
|
##############
|
|
|
|
:: if grayscale
|
|
{{ macros.get_modifier("color_mod_m", "color_modifier_idx") }}
|
|
{{ macros.get_modifier("color_var_mod_m", "color_var_modifier_idx") }}
|
|
:: endif
|
|
{{ macros.get_modifier("offset_mod", "offset_modifier_idx") }}
|
|
{{ macros.get_modifier("offset_var_mod", "offset_var_modifier_idx") }}
|
|
{{ macros.get_modifier("rot_mod", "rotation_modifier_idx") }}
|
|
{{ macros.get_modifier("rot_var_mod", "rotation_var_modifier_idx") }}
|
|
{{ macros.get_modifier("size_mod", "size_modifier_idx") }}
|
|
{{ macros.get_modifier("size_mod_height", "size_modifier_idx_height") }}
|
|
{{ macros.get_modifier("size_mod_width", "size_modifier_idx_width") }}
|
|
{{ macros.get_modifier("size_var_mod", "size_var_modifier_idx") }}
|
|
{{ macros.get_modifier("src_offset_mod", "src_offset_modifier_idx") }}
|
|
{{ macros.get_modifier("src_offset_var_mod", "src_offset_var_modifier_idx") }}
|
|
{{ macros.get_modifier("dst_offset_mod", "dst_offset_modifier_idx") }}
|
|
{{ macros.get_modifier("dst_offset_var_mod", "dst_offset_var_modifier_idx") }}
|
|
{{ macros.get_modifier("mask_mod", "mask_modifier_idx") }}
|
|
|
|
# pattern offser calculation
|
|
|
|
|
|
offset_rand = uniform_f2_ab(-offset_var, offset_var) @ offset_var_mod
|
|
pat_offset = pattern_offset @ offset_mod + offset_rand @ offset_var_mod
|
|
pat_offset = pat_offset * vector2(1.0, -1.0)
|
|
pat_offset_for_color = pat_offset
|
|
|
|
######################
|
|
|
|
rot = rotation
|
|
rot_var = rotation_var
|
|
|
|
src_offset_v = src_offset @ src_offset_mod + uniform_f2_ab(-src_offset_var, src_offset_var) @ src_offset_var_mod
|
|
dst_offset_v = dst_offset @ dst_offset_mod + uniform_f2_ab(-dst_offset_var, dst_offset_var) @ dst_offset_var_mod
|
|
|
|
################
|
|
|
|
pattern_direction = out_point - src_point
|
|
norm_dir = normalize_vec2(pattern_direction)
|
|
dir_x_axis = rotate_vec2(norm_dir, -0.25, float2(0.0, 0.0))
|
|
|
|
direction_dist = distance_vec2(float2(0.0, 0.0), pattern_direction)
|
|
mapping_scale = 1.0 if offset_absolute_mode else direction_dist
|
|
|
|
src_point = src_point + norm_dir @ (src_offset_v.y * mapping_scale)
|
|
src_point = src_point + dir_x_axis @ (src_offset_v.x * mapping_scale)
|
|
|
|
out_point = out_point + norm_dir @ (dst_offset_v.y * mapping_scale)
|
|
out_point = out_point + dir_x_axis @ (dst_offset_v.x * mapping_scale)
|
|
|
|
dst_point = out_point
|
|
|
|
pattern_direction = out_point - src_point
|
|
|
|
direction_angle = atan2(pattern_direction) / _2pi() + 0.25
|
|
direction_dist = distance_vec2(float2(0.0, 0.0), pattern_direction)
|
|
|
|
source_offset = norm_dir @ (-pat_offset.y * direction_dist) + dir_x_axis @ (pat_offset.x * direction_dist)
|
|
|
|
add_rot = rot * rot_mod + uniform_ab(-rot_var, rot_var) * rot_var_mod
|
|
rot_calc = add_rot + direction_angle if is_orient else add_rot
|
|
|
|
# pattern size
|
|
|
|
size_var = uniform_f2_ab(-pattern_size_var, pattern_size_var)
|
|
size_var_u = uniform_ab(-size_uniform_var, size_uniform_var)
|
|
|
|
size_var = vector2(size_var_u, size_var_u) if is_size_var_uniform else size_var
|
|
pattern_size = pattern_size if not is_size_var_uniform else vector2(pattern_size_uniform, pattern_size_uniform)
|
|
|
|
size_mod_m = vector2(size_mod, size_mod) if is_size_var_uniform else vector2(size_mod_width, size_mod_height)
|
|
|
|
pattern_size_calc = pattern_size * size_mod_m + size_var @ size_var_mod
|
|
|
|
|
|
# Color
|
|
:: if grayscale
|
|
{{ macros.calculate_grayscale(false) }}
|
|
:: else
|
|
{{ macros.calculate_color(false) }}
|
|
:: endif
|
|
|
|
|
|
prev_point = prev_point + point - prev_point
|
|
total_dist = total_dist + segment_dist
|
|
|
|
## calculate bridge sample
|
|
|
|
{{ macros.get_modifier("remap", "bridge_remapping_mod") }}
|
|
|
|
bridge_n = remap if bridge_remapping_mod > 0 and bridge_type == 0 else bridge_n
|
|
bridge_n = bridge_current_distance / direction_dist if bridge_type == 1 else bridge_n
|
|
|
|
|
|
point_calc = lerp(src_point, dst_point, bridge_n) + source_offset
|
|
|
|
pivot_pos = pivot_pos * pattern_size_calc
|
|
pivot_rot_offset = rotate_vec2(pivot_pos, -rot_calc, float2(0.0, 0.0))
|
|
|
|
point_calc = point_calc - pivot_rot_offset
|
|
|
|
# symmetry
|
|
|
|
{{ macros.get_modifier("sym_mod", "symmetry_modifier_idx", "1.0") }}
|
|
{{ macros.symmetry_calculation() }}
|
|
|
|
bridge_pattern_size = pattern_size_calc * sym_mult
|
|
bridge_pattern_rotation = rot_calc
|
|
|
|
col_range = 1.0
|
|
col_range = 0.0 if bridge_n > 1.0 and bridge_type == 1 else col_range
|
|
|
|
_OUT_ = out_color @ col_range
|
|
|
|
bridge_current_distance = bridge_current_distance + bridge_distance if not is_resample else bridge_current_distance
|
|
bridge_current_distance = bridge_current_distance + bridge_distance if overshoot and is_resample else bridge_current_distance
|
|
|
|
# Calculate pattern index
|
|
|
|
{{ macros.get_modifier("idx_mod", "idx_distr_mod", "0.0") }}
|
|
|
|
ping_pong = 2 * inputs_num - 2
|
|
ping_pong_loop = current_index % ping_pong
|
|
pattern_ping_pong = ping_pong_loop if ping_pong_loop < inputs_num else ping_pong - ping_pong_loop
|
|
pattern_ping_pong = 0 if inputs_num == 1 else pattern_ping_pong
|
|
|
|
pattern_random = uniform_ab(0.0, tofloat(inputs_num))
|
|
pattern_random = toint(pattern_random)
|
|
|
|
pattern_mod = idx_mod * tofloat(inputs_num)
|
|
pattern_mod = toint(pattern_mod)
|
|
pattern_mod = 0 if pattern_mod < 0 else pattern_mod
|
|
pattern_mod = (inputs_num - 1) if pattern_mod > (inputs_num - 1) else pattern_mod
|
|
|
|
pattern_index = pattern_random
|
|
pattern_index = current_index % inputs_num if pattern_distr_mode == 1 else pattern_index
|
|
pattern_index = pattern_ping_pong if pattern_distr_mode == 2 else pattern_index
|
|
pattern_index = pattern_mod if pattern_distr_mode == 3 else pattern_index
|
|
|
|
pattern_index = pattern_index + 2
|
|
|
|
even_index = -even_index if overshoot and is_resample else even_index
|
|
even_index = -even_index if not is_resample else even_index
|
|
|
|
current_index = current_index + 1 if overshoot and is_resample else current_index
|
|
current_index = current_index + 1 if not is_resample else current_index
|
|
|
|
export(pattern_index)
|
|
export(bridge_current_distance)
|
|
export(prev_point)
|
|
export(acc_dist)
|
|
export(current_index)
|
|
export(even_index)
|
|
export(total_dist)
|
|
|
|
export(point_calc)
|
|
export(bridge_pattern_size)
|
|
export(bridge_pattern_rotation) |