Source files

source/ie_pcloud/pcloud_mindist.sex

@@ -0,0 +1,49 @@
+:: import "point_cloud.sex" as pc
+
+pc_index = get_int("pc_index")
+min_distance = get_float("min_distance")
+
+n = toint(get_float("$number"))
+
+{{ pc.init_pcloud("pcloud") }}
+
+last_iteration = (n == toint(pcloud_meta.x))
+self_check = (n == pc_index)
+
+sample_idx = n
+
+{{ pc.get_pcloud_point_noattr("pcloud", "sample_idx", "sample_cloud") }}
+{{ pc.get_pcloud_point_noattr("pcloud", "pc_index", "sample_origin") }}
+
+pos_origin = sample_origin.xy
+
+:: if tiled
+pos_origin = pos_origin % float2(1.0, 1.0)
+:: endif
+
+skip_iteration = self_check or last_iteration
+
+:: set checks = 9 if tiled else 1
+
+:: for i in range(checks)
+
+pos_comp = sample_cloud.xy + vector2({{ pc.tile_offset[i] }})
+
+dist_vec = pos_origin - pos_comp
+dist = length_vec2(dist_vec)
+mdist = dist if dist < min_distance and not skip_iteration else min_distance
+
+min_distance = mdist 
+
+:: endfor
+
+color_out = merge_float4(pos_origin.x, pos_origin.y, min_distance , 1.0)
+pos_out = sample_uv
+size_out = pcloud_frag_size
+
+_OUT_ = last_iteration
+
+export(color_out)
+export(pos_out)
+export(size_out)
+export(min_distance)

source/ie_pcloud/pcloud_relax_check.sex

@@ -0,0 +1,37 @@
+:: import "point_cloud.sex" as pc
+
+pc_index = get_int("pc_index")
+max_dist = get_float("#max_dist")
+
+pcloud_meta = get_float3("#pcloud_meta")
+pcloud_frag_size = get_float2("pcloud_frag_size")
+pcloud_size_half = get_float2("pcloud_size_half")
+sample_origin = get_float4("sample_origin")
+
+n = toint(get_float("$number"))
+
+last_iteration = (n == toint(pcloud_meta.x))
+self_check = (n == pc_index)
+
+{{ pc.get_pcloud_point_noattr("pcloud", "n", "sample_cloud") }}
+
+pos_origin = sample_origin.xy
+
+:: if tiled
+pos_origin = pos_origin % float2(1.0, 1.0)
+:: endif
+
+need_check = False
+
+:: set checks = 9 if tiled else 1
+:: for i in range(checks)
+pos_comp = sample_cloud.xy + vector2({{ pc.tile_offset[i] }})
+need_check = need_check or abs(pos_comp.x - pos_origin.x) < max_dist and abs(pos_comp.y - pos_origin.y) < max_dist
+:: endfor
+
+need_check = need_check or last_iteration
+need_check = need_check and not self_check
+
+_OUT_ = need_check
+
+export(sample_cloud)

source/ie_pcloud/pcloud_relax_iter.sex

@@ -0,0 +1,65 @@
+:: import "point_cloud.sex" as pc
+
+pc_index = get_int("pc_index")
+total_distance = get_float2("total_distance")
+total_overlap = get_int("total_overlap")
+n = toint(get_float("$number"))
+
+pcloud_meta = get_float3("#pcloud_meta")
+pcloud_frag_size = get_float2("pcloud_frag_size")
+sample_origin = get_float4("sample_origin")
+sample_cloud = get_float4("sample_cloud")
+origin_uv = get_float2("origin_uv")
+gap = get_float("gap")
+
+last_iteration = (n == toint(pcloud_meta.x))
+self_check = (n == pc_index)
+
+sample_idx = n
+
+
+
+pos_origin = sample_origin.xy
+:: if tiled
+pos_origin = pos_origin % float2(1.0, 1.0)
+:: endif
+size_origin = sample_origin.z
+size_comp = sample_cloud.z
+size_sum = 0.5 * (size_comp + size_origin) + gap
+size_ratio = size_comp / (size_comp + size_origin)
+
+:: set checks = 9 if tiled else 1
+
+:: for i in range(checks)
+pos_comp = sample_cloud.xy + vector2({{ pc.tile_offset[i] }})
+
+dist_vec = pos_origin - pos_comp
+dist = length_vec2(dist_vec) 
+
+is_overlapped = (dist < size_sum)
+overlapping_length = size_sum - dist
+
+push_vec = normalize_vec2(dist_vec)
+push_vec = push_vec @ (overlapping_length * size_ratio)
+
+is_overlapped = is_overlapped and not self_check
+total_distance = total_distance + push_vec if is_overlapped and not last_iteration else total_distance
+total_overlap = total_overlap + 1 if is_overlapped and not last_iteration else total_overlap
+:: endfor
+
+new_pos = pos_origin + total_distance @ (1.0 / tofloat(total_overlap)) if total_overlap > 0 else pos_origin
+:: if tiled
+new_pos = new_pos % float2(1.0, 1.0)
+:: endif
+
+color_out = merge_float4(new_pos.x, new_pos.y, size_origin, 1.0)
+pos_out = origin_uv
+size_out = pcloud_frag_size
+
+_OUT_ = last_iteration
+
+export(color_out)
+export(pos_out)
+export(size_out)
+export(total_distance)
+export(total_overlap)

source/ie_pcloud/point_cloud.sex

@@ -0,0 +1,71 @@
+:: macro init_pcloud(cloud_name)
+{{ cloud_name }}_meta = get_float3("#{{ cloud_name }}_meta")
+
+{{ cloud_name }}_frag_size = float2(1.0, 1.0) / {{ cloud_name }}_meta.yz
+{{ cloud_name }}_size_half = {{ cloud_name }}_frag_size / float2(2.0, 2.0)
+:: endmacro
+
+:: macro get_pcloud_point(cloud_name, sample_idx, sample_name, cloud_input = 0)
+row = ({{ sample_idx }} * 2) / toint({{ cloud_name }}_meta.y)
+column = ({{ sample_idx }} * 2) % toint({{ cloud_name }}_meta.y)
+
+rc = vector2(tofloat(column), tofloat(row)) 
+sample_uv = {{ cloud_name }}_size_half + rc *  {{ cloud_name }}_frag_size
+
+{{ sample_name }} = samplecol(sample_uv, {{ cloud_input }}, 0)
+{{ sample_name }}_attrib = samplecol(sample_uv + vector2({{ cloud_name }}_frag_size.x, 0.0), {{ cloud_input }}, 0)
+:: endmacro
+
+:: macro get_pcloud_point_noattr(cloud_name, sample_idx, sample_name, cloud_input = 0)
+row = ({{ sample_idx }} * 2) / toint({{ cloud_name }}_meta.y)
+column = ({{ sample_idx }} * 2) % toint({{ cloud_name }}_meta.y)
+
+rc = vector2(tofloat(column), tofloat(row)) 
+sample_uv = {{ cloud_name }}_size_half + rc *  {{ cloud_name }}_frag_size
+
+{{ sample_name }} = samplecol(sample_uv, {{ cloud_input }}, 0)
+:: endmacro
+
+:: macro pcloud_index_uv(uv_name, cloud_name, index)
+
+pc_row = ({{ index }} * 2) / toint({{ cloud_name }}_meta.y)
+pc_column = ({{ index }} * 2) % toint({{ cloud_name }}_meta.y)
+pc_rc = vector2(tofloat(pc_column), tofloat(pc_row))
+f2_one = float2(1.0, 1.0)
+
+{{ uv_name }} = {{ cloud_name }}_size_half + pc_rc / ( {{ cloud_name }}_meta.yz - f2_one ) * (f2_one - {{ cloud_name }}_frag_size )
+
+:: endmacro
+
+:: macro pp_init()
+size = get_float2("$size")
+pos = get_float2("$pos")
+frag_size = float2(1.0, 1.0) / size
+frag_size_half = frag_size / float2(2.0, 2.0)
+pixel_coord = size * (pos - frag_size_half)
+pixel_index = pixel_coord.y * size.x + pixel_coord.x
+pixel_index = toint(pixel_index)
+is_attrib = pixel_index % 2 > 0
+
+sample = samplecol(pos, 0, 0)
+attr_offset = vector2(-frag_size.x, 0.0) if is_attrib else vector2(frag_size.x, 0.0)
+neigh_sample = samplecol(pos + attr_offset, 0, 0)
+
+point = neigh_sample if is_attrib else sample
+point_attrib = sample if is_attrib else neigh_sample
+:: endmacro
+
+:: macro sample_curve(factor, npoints, is_closed, alpha, tension, point_prefix, start_index = 0):
+catmull_rom_16({{ factor }},
+    {{ npoints }},
+    {{ is_closed }},
+    {{ alpha }},
+    {{ tension }},
+:: for p_i in range(start_index, start_index + 16):
+    {{ point_prefix }}{{ p_i }},
+:: endfor 
+)
+:: endmacro
+
+:: set attrib_map = {1:"point.z", 2:"point_attrib.x", 3:"point_attrib.y", 4:"point_attrib.z"}
+:: set tile_offset = ["0.0, 0.0", "0.0, -1.0", "0.0, 1.0", "-1.0, 0.0", "1.0, 0.0", "1.0, -1.0", "1.0, 1.0", "-1.0, -1.0", "-1.0, 1.0"]