audio()
	kb = midi()

	nk = "nanoKONTROL"
	nk_knobs = midi(nk, range(14,22))
	nk_sliders = midi(nk, range(2, 13))
	nk_buttons = midi(nk, range(23, 32))

	export(nk_knobs)
	export(nk_sliders)
	export(nk_buttons)

	hz = scale("pentatonic_minor", "c4", 10)

	patterns = euc([1, 7, 2, 4, 5, 9, 2, 12], 16)
	seq = seq(slider(60, 180), patterns)

	wn = sqrt(osc("saw", 100hz) + osc("square", 120hz))

	jitter_strength = slider(nk_sliders[6], "squared")
	jitter_matrix = translate(4 * jitter_strength * point(wn[0], wn[100], wn[200]))
	export(jitter_matrix)

	scene_index = calculate_scene_index(nk_knobs, jitter_strength)

	kb_amp = adsr(0.2s, 0s, 1.0, 0.5s, kb.signal)
	kb_osc = osc("sin", hz, kb_amp)

	patterns = [ euc(3, 8), euc(5, 8) ]
	signals = seq(60, patterns)

	export("kb", kb_amp)
	export("scene_index", scene_index)
	
	kb_output = sum(kb_osc)

	freq_saw_strength = slider(nk_knobs[4])
	if (freq_saw_strength <= 0.1)
		freq_saw_strength = 0.0

	freq_saw = lfo("saw", freq_saw_strength * 16)

	export(freq_saw_strength)
	export(freq_saw)

	blob_audio = blob_audio(kb, nk_sliders, nk_knobs)
	cylinder_audio = cylinder_audio(nk_sliders, nk_knobs, nk_buttons, 200hz + 800hz * freq_saw * freq_saw_strength)

	if scene_index == 0
		return compressor(mix(blob_audio, cylinder_audio, jitter_strength))

	if scene_index == 1
		return compressor(cylinder_audio)

	return compressor(cube_audio())


calculate_scene_index(notes, jitter_strength)

	if notes[-1]
		return 2

	if jitter_strength > 0.9
		return 1

	return 0
	
scene()

	amp = import("amp")
	scene_index = import("scene_index")

	nk_sliders = import("nk_sliders")
	nk_buttons = import("nk_buttons")
	nk_knobs = import("nk_knobs")

	if scene_index == 0
		blob_scene(amp, nk_sliders, nk_knobs)
	else if scene_index == 1
		cylinder_scene(nk_sliders, nk_knobs)
	else
		cube_scene()

	return


// --- blob


blob_scene(amp, nk_sliders, nk_knobs)

	camera_position = spherical_coord(50, 45.0, 45)// + 10.0*$time)
	camera_target = point(0, 0, 0)
	camera_up = point(0, 1, 0)
	//camera(camera_position, camera_target, camera_up)

	shape_xform = import("jitter_matrix") * translate_x(0)//4 * sin($time))
	shape = blob_shape(amp, shape_xform)

	x_trigger = slider(amp[2])
	y_trigger = slider(amp[3])

	x_scale = x_trigger * 2
	y_scale = y_trigger * 2

	offsets = [point(0, 1, 0), point(0, 0, 1), point(0, -1, 0), point(0, 0, -1)]
	offsets_scale = slider(amp[6], 0, 5)

	slice_width = 1.5

	draw_light(point(0, 10, 10), 40, #ffffff)
	draw_light(point(-10, -10, 10), 20, #cc4444)
	draw_light(point(10, -10, -15), 40, #7777cc) 

	cutter_palette = palette([#F9CFF2, #52154E, #111344], [5, 10, 15])

	if x_scale or y_scale

		ry = rotate_y(slider(amp[4], 0, 25deg) * random(-1, 1, 13))
		rz = rotate_z(slider(amp[5], 0, 25deg) * random(-1, 1, 13))
		r = ry * rz

		loop i from 0 to 9
			//cutter is basically just taking a slice out of the main shape blob
			cutter_position = translate((i - 5)*slice_width, 0, 0)
			cutter = cutter_position * cube(slice_width, 20, 20, sample(cutter_palette))
			slice = intersection(cutter, shape)

			//now render a pile of instances of the cutting shape
			instance_position = point(x_scale * (i - 5), y_scale * (i*0.5 - 4), 0)

			if offsets_scale
				loop k from 0 to 3

					temp = instance_position
					temp += offsets_scale * (offsets[k] + offsets[k + 1])
				
					draw(slice, r[i] * translate(temp))
			else
		
				draw(r[i] * translate(instance_position) * slice)

	else
		
		if offsets_scale
			loop k from 0 to 3
				temp = translate(offsets_scale * (offsets[k] + offsets[k + 1]))
				draw(shape, temp)

		else
			draw(shape)


blob_shape(kb, shape_xform)
	outer_xform = rotate_y(-4.0 + $time)
	outer_xform = outer_xform * translate_x(3.0)
    
	inner_xform = rotate_z(3.0 + $time)
	inner_xform = inner_xform * translate_x(6.0)

	system_xform = rotate_x(0.5 + $time)
    
	outer_object = outer_xform * cube(1)
	inner_object = inner_xform * union(outer_object, cube(2), slider(kb[0], 0, 6))
	system_object = system_xform * union(inner_object, cube(3), slider(kb[1], 0, 6))

	return shape_xform * system_object

blob_audio(kb, nk_sliders, nk_knobs)

	amp = adsr(0.4s, 0s, 1.0, 1.5s, kb)
	export(amp)

	hz = scale("pentatonic_minor", "c4", 10)

	return sum(osc("square", hz, amp))



	

// --- cube


cube_scene()

	xform = translate(slider(0, 4), 1, 1)

	rx_shift = acc($dt * 0)
	ry_shift = acc($dt * 0)
	
	loop i from 1 to 1 //this was 0->1 but it was too busy
		rx = rotate_x(rx_shift)
		ry = rotate_y(i * 180deg + ry_shift)

		draw_half(rx * ry * xform, 4)

	cube_lighting()

draw_half(xform, width)
	loop i from 0 to 3
		xform = rotate_z(xform, 90deg)
		draw_quadrant(xform, width)

draw_quadrant(xform, width)

	lfo = lfo("sin", [0.1, 0.2, 0.03, 0.4, 0.05, 0.6, 0.07, 0.8])
	scale_x = mix(2, 4, lfo[0])
	scale_y = mix(0, 4, lfo[1])

	angle_x = mix(0, 5deg, lfo[2])
	angle_y = mix(0, 5deg, lfo[3])
	angle_z = mix(0, 5deg, lfo[4])

	angle_mult_x = mix(0, 4, lfo[5])
	angle_mult_y = mix(0, 4, lfo[6])
	angle_mult_z = mix(0, 4, lfo[7])

	loop z from 0 to width - 1

		shape = cube(#006747)

		rx = rotate_x(angle_x * (1 + angle_mult_x * z))
		ry = rotate_y(angle_y * (1 + angle_mult_y * z))
		rz = rotate_z(angle_z * (1 + angle_mult_z * z))
		rotation = rz * ry * rx

		points = grid(width, width, point(0, 0), point(scale_x, scale_y))
		point_xform = xform * rotation * translate_z(2*z)

		draw(shape, point_xform * translate(points))

cube_lighting()
	heartbeat = import("heartbeat")
	
	sphere_r0 = 0.4 * heartbeat[0][0]
	sphere_r1 = 0.2 * heartbeat[1][0]
	sphere_radius = 0.1 + sphere_r0 + sphere_r1

	light_r0 = 30 * heartbeat[0][0]
	light_r1 = 10 * heartbeat[1][0]
	light_radius = 5 + light_r0 + light_r1

	light_pulse = sphere_r0 + sphere_r1
	light_pos = point(0, wrap(-$time, 10, -10), 0)
	light_shape = translate(light_pos) * sphere(sphere_radius)

	draw_light(light_shape, light_radius, #fff)
	draw_directional_light(point(0, 0, -1), #444)

cube_audio()
	heartbeat_patterns = euc(1, 6, [0, 1])
	heartbeat_seq = seq(120, heartbeat_patterns)
	heartbeat = adsr(0.1s, 0.0, 1.0, 0.5s, heartbeat_seq)
	export(heartbeat)

	//separate because the audio and video dont sync correctly. will fix.
	light_pos = point(0, wrap(-$time, 10, -10), 0)
	base_freq = mix(400hz, 600hz, (light_pos.y + 10) / 20)

	osc = lowpass(noise(), 800hz + base_freq + heartbeat[0][0] * 400hz + heartbeat[1][0] * 200hz)

	return osc

//--------------- cylinder


cylinder_scene(nk_sliders, nk_knobs)

	kb = import("kb")

	rx = 0 *acc($dt * 0.01) //too many rotation axes
	ry =0* acc($dt * 0.01) //same
	rz = acc($dt * 0.01)
	z = slider(-10, -30)
	xform = (rotate_x(rx) * rotate_y(ry) * rotate_z(rz)) * translate_z(z)

	cylinder_half(nk_sliders, nk_knobs, xform)
	cylinder_half(nk_sliders, nk_knobs, xform * rotate_z(180deg))

cylinder_half(nk_sliders, nk_knobs, xform)

	harsh_noise = import("hn_osc")
	hn_lfo = import("hn_lfo")

	y_offset = slider(nk_knobs[2], 0.1, 0.4)
	//y_offset = mix(0.1, 0.2, hn_lfo[2])

	central_xz_offset = nk_knobs[2].signal[0] * 6

//	rz_incr = slider(-25deg, 25deg)
//	rz_incr *= slider() 
	rz_incr = mix(0, 3deg, slider(nk_sliders[0], "squared"))
	rz_incr += osc("sin", 0.02)[0] *0.02 * slider(nk_knobs[1])
	rz = matrix()

	//xz_strength = slider(0, 4) + import("osc0")[0]
	xz_strength = mix(0, 10, nk_knobs[3])[0] + harsh_noise[3][0]
	xz_strength_side = slider(nk_sliders[3], 0, 128, "squared")
	xz_offsets_base = [point(-1, 0, 0), point(0, 0, -1), point(1, 0, 0), point(0, 0, 1)]
	xz_offsets = translate(xz_strength * xz_offsets_base)
	xz_offsets_side = translate(xz_strength_side * xz_offsets_base)

	side_cube_x = slider(nk_sliders[1], 1, 3)
	side_cube_z = slider(nk_sliders[2],1, 4)

	offset_count = mix(2, 8, slider(nk_sliders[1][0]))

	loop i from 0 to 100 
		hn_transform = translate(central_xz_offset*harsh_noise[0][i], 0.1*harsh_noise[1][i], central_xz_offset*harsh_noise[2][i])
		central_xform = xform * rz * translate_y(i * y_offset) * xz_offsets[i]
		draw(cube(1, 0.3, 1), central_xform * hn_transform, i%2)

		central_xform = central_xform * rotate_y(i * slider(nk_knobs[0], -10deg, 10deg))

		loop j from 1 to offset_count
			x = 1.5 * side_cube_x * j
			offsets = xz_offsets_side[j] * [ translate_x(-x), translate_x(x) ]
			draw(cube(side_cube_x, 0.1 + 0.2*(j%2), side_cube_z), central_xform * offsets, j %2)
	
		rz = rotate_z(rz_incr) * rz

//a bunch of harsh noise nonsense
cylinder_audio(nk_sliders, nk_knobs, nk_buttons_top, base_freq)

	waves = ["sin", "sin", "sin", "sin", "saw", "square", "saw", "square"]


	lfo0 = lfo(waves[0], slider(nk_sliders[0], 0.0hz, 20hz))
	lfo1 = lfo(waves[1], slider(nk_sliders[1], 0.0hz, 20hz))
	lfo2 = lfo(waves[2], slider(nk_sliders[2], 0.0hz, 20hz))
	lfo3 = lfo(waves[3], slider(nk_sliders[3], 0.0hz, 20hz))

	osc0 = osc(waves[4], base_freq + lfo0[0] * slider(nk_knobs[0], base_freq, 5000hz, "squared"))
	osc1 = osc(waves[5], base_freq + lfo1[0] * slider(nk_knobs[1],base_freq, 5000hz, "squared"))

	osc2 = osc(waves[6], base_freq + lfo2[0] * slider(nk_knobs[2], base_freq, 5000hz, "squared"))
	osc3 = osc(waves[7], base_freq + lfo3[0] * slider(nk_knobs[3], base_freq, 5000hz, "squared"))

	export("hn_lfo", [lfo0, lfo1, lfo2, lfo3])
	export("hn_osc", [osc0, osc1, osc2, osc3])

	harsh_noise_volume = 0.7
	return harsh_noise_volume * (osc0 * osc1) * (osc2 * osc3)

post()

	kb = import("kb")
	scene_index = import("scene_index")

	nk_buttons = import("nk_buttons")

	edge_channels = point(1, 1, 1)

	if scene_index == 0
		return $scene

	else if scene_index == 1
		edges = shader("edge_filter", $scene[1], edge_channels)
		
		offset_strength = 0.0
		if import("freq_saw_strength") > 0.1
			offset_strength = import("freq_saw") * 12

		blend = shader("composite", edges, offset_strength * point(0.02, 0)) 
	
		if nk_buttons[0]
			return shader("kaleidoscope", blend, 0.1)

		return blend

	else
		edges = shader("edge_filter", $scene[1], edge_channels)
		stripes = shader("stripes", edges, 0.2)

		offset_strength = kb[0][0]
		return shader("composite", stripes, offset_strength * point(0.02, 0)) 


edge_filter(source_texture, channel_strength) 

	col[0] = sample(source_texture, $uv.x - $pixel.x, $uv.y - $pixel.y)
	col[1] = sample(source_texture, $uv.x, $uv.y - $pixel.y)
	col[2] = sample(source_texture, $uv.x + $pixel.x, $uv.y - $pixel.y)

	col[3] = sample(source_texture, $uv.x - $pixel.x, $uv.y)
	col[4] = sample(source_texture, $uv.x, $uv.y)
	col[5] = sample(source_texture, $uv.x + $pixel.y, $uv.y)

	col[6] = sample(source_texture, $uv.x - $pixel.x, $uv.y + $pixel.y)
	col[7] = sample(source_texture, $uv.x, $uv.y + $pixel.y)
	col[8] = sample(source_texture, $uv.x + $pixel.x, $uv.y + $pixel.y)

	//sobel
	x = 2.0 * (col[3] - col[5]) + col[6] + col[0] - col[2] - col[8]
	y = 2.0 * (col[7] - col[1]) + col[6] + col[8] - col[2] - col[0]

	return colour(sqrt(x*x + y*y).xyz() * channel_strength, 1.0)

chromatic_shift(texture, red, green, blue)

	r = sample(texture, $uv + red).r
	g = sample($scene, $uv + green).g
	b = sample(texture, $uv + blue).b

	return colour(r, g, b, 1.0)

stripes(texture, stripe_width_uv)
	col = sample(texture, $uv)
	count = int($uv.x / stripe_width_uv)
	if count % 2
		return col

	//return colour(1.0 - col.xyz(), 1.0)

	//lum = col.r * 0.2126 + col.g * 0.7152 + col.b * 0.0722
	//return colour(lum, lum, lum, 1.0)

	return colour(col.g, 0.0, 0.0, 1.0)

kaleidoscope(texture, symmetry)
	segment = 360deg / symmetry

	dir = $uv - point(0.5, 0.5)
	angle = atan2(dir.y, dir.x)
	radius = length(dir)

	angle -= segment * floor(angle / segment)
	angle = min(angle, segment - angle) + 45deg

	pos = point(cos(angle), sin(angle)) * radius + 0.5
	pos = max(min(pos, 2.0 - pos), -pos)

	return sample(texture, pos)
	
composite(second_scene, shift_offset)
	depth0 = sample($scene_depth[0], $uv) //TODO: sampling without a location should default to $uv
	depth1 = sample($scene_depth[1], $uv)

	colour0 = sample($scene[0], $uv)
	colour1 = sample(second_scene, $uv)

	//would be nice to not shift the lights, but it would require being able to read the scene emmisivity
	shifted = sample($scene[0], $uv + shift_offset)
	shifted_depth = sample($scene_depth[0], $uv.x + shift_offset)
	combined = colour(shifted[0], colour0[1], colour0[2], 1.0)

	if (depth1 < depth0) 
		if (depth1 < shifted_depth)
			return colour1
		else
			return colour(mix(colour1.xyz(), combined.xyz(), 0.8), 1.0)

	return combined