#!/usr/local/bin/cz --
use b

struct segment:
	segment *before
	segment *after
	int x, w
	byte r, g, b
	byte dr, dg, db

#	segment *segs = Nalloc(segment, h)

long fruit[256]
long background[256]

Main:
	int n = 256
	framebuffer_init()
#	space()
	fb_rainbow_init()
	for(i, 0, 256):
		num p = sin((i/256.0-0.5)*pi)*0.4+0.4
		fruit[i] = fb_rainbow(p * 120 - 120)
		background[i] = i<<16|i/3<<8|i/2 # grey(i/256.0)
	bm_start()
	for(r, 0, n):
		with_pixel_type(simple_render_circle)
#		framebuffer_sync()
#		wait_for_vsync()
#		asleep(1.0/240)
#		Paint()
	bm("poked", n)
	getchar()
	framebuffer_final()

def simple_render_circle(pixel_type):
	pixel_type *px = pixel()
	int r2 = r*r
	for(y, -h_2, h_2):
		long bg = background[(y+h_2) * r * 256 / n / 2 / h]
		int y2 = y*y
		if y2 <= r2:
			int x = sqrt(r2-y2)
			HLINE(-w_2, y, -x, bg)
			HLINE(x, y, w_2, bg)
#			HLINE_GRAD(-w_2, y, -x, background, (w_2 - x) * 256 / w)
#			HLINE_GRAD(x, y, w_2, background + ((w_2 + x) * 256 / w), (w_2 - x) * 256 / w)

			HLINE_GRAD(-x, y, x, fruit, 256 * x/r)
#			HLINE(-x, y, x, 0) #fruit, 256 * x/r)

#			POINT(-x, y, black)
#			POINT(x, y, black)
		 else:
#			HLINE_GRAD(-w_2, y, w_2, background, 256)
			HLINE(-w_2, y, w_2, bg)

def HLINE(x0, y0, x1, col):
	fill(px + w*(y0+h_2) + (x0+w_2), x1-x0, col)

def HLINE_GRAD(x0, y0, x1, grad, grad_n):
	fill_grad(px + w*(y0+h_2) + (x0+w_2), x1-x0, grad, grad_n)

#def fill(p, count, val):
#	for(i, 0, count):
#		p[i] = val

def fill(p, count, val):
	for(q, p, p+count):
		*q = val

def fill_grad(p, count, grad, grad_n):
	fill_grad(p, count, grad, grad_n, my(i), my(j), my(g))
def fill_grad(p, count, grad, grad_n, i, j, g):
	int i = 0
	long *g = grad
	for(q, p, p+count):
		*q = *g
		i += grad_n
		while i >= count:
			i -= count
			++g

def POINT(x, y, col):
	*(px + w*(y+h_2) + x+w_2) = col

fb_rainbow_init():
	rb_red_angle = deg2rad(-120)
	rb_green_angle = 0
	rb_blue_angle = deg2rad(120)

	rb_red_power = 1
#	rb_green_power = 0.8
	rb_green_power = 0.9
	rb_blue_power = 1

def fb_rainbow(a) _fb_rainbow(angle2rad(a))
pix_t _fb_rainbow(num a)
	num r = rb_red_power * (cos(a-rb_red_angle)+1)/2
	num g = rb_green_power * (cos(a-rb_green_angle)+1)/2
	num b = rb_blue_power * (cos(a-rb_blue_angle)+1)/2
	return pixn_rgb_safe(r, g, b)