Três dimensões

type Msg { Tick }

func view(model: Int): hive.ui.View {
	shapes := [
		hive.ui.ground([hive.ui.paint(hive.ui.Tone.HEX("#2d5c34"))], 20.0, 20.0),
		hive.ui.box(
			[
				hive.ui.at(0.0, 0.5, -3.0),
				hive.ui.paint(hive.ui.Tone.HEX("#b5651d")),
				hive.ui.surface(hive.ui.Surface.Planks()),
			],
			1.0, 1.0, 1.0,
		),
		hive.ui.sphere([hive.ui.at(2.0, 1.0, -4.0), hive.ui.paint(hive.ui.Tone.HEX("#e0c341"))], 1.0),
		// Um cone recebe os dois raios: zero no topo é o pontudo.
		hive.ui.cone(
			[
				hive.ui.at(-2.0, 0.4, -3.0),
				hive.ui.paint(hive.ui.Tone.HEX("#ff5a1f")),
				hive.ui.surface(hive.ui.Surface.Gloss()),
			],
			0.0, 0.4, 0.8,
		),
		// E uma cor com alpha é desenhada translúcida.
		hive.ui.box(
			[hive.ui.at(0.0, 1.2, -1.5), hive.ui.paint(hive.ui.Tone.RGBA(120, 200, 255, 96))],
			3.0, 2.0, 0.2,
		),
	]
	return hive.ui.scene(
		[hive.ui.grow(1), hive.ui.eye(0.0, 1.6, 4.0), hive.ui.aim(0.0, 0.0), hive.ui.lens(70), hive.ui.fog(60)],
		shapes,
	)
}

proc update(model: Int, msg: Msg, envelope: hive.syslink.Envelope): Int {
	return model
}

proc main(): void {
	hive.ui.window("Uma cena 3D", view, update, 0)
}

type Msg {
	Tick { ms: Int }
}

func view(angle: Float): hive.ui.View {
	return hive.ui.scene(
		[
			hive.ui.grow(1),
			hive.ui.eye(0.0, 1.5, 5.0),
			hive.ui.aim(0.0, 0.0),
			hive.ui.onFrame(Msg.Tick(_)),
		],
		[
			hive.ui.ground([hive.ui.paint(hive.ui.Tone.Muted())], 10.0, 10.0),
			hive.ui.box(
				[hive.ui.at(0.0, 1.0, 0.0), hive.ui.turn(0.0, angle, 0.0), hive.ui.paint(hive.ui.Tone.Good())],
				1.0, 1.0, 1.0,
			),
		],
	)
}

// O onFrame de uma scene reporta quantos milissegundos o último frame levou,
// então o giro que esta caixa faz é em segundos reais, não em frames — a
// mesma caixa gira na mesma velocidade a trinta quadros por segundo ou a sessenta.
proc spin(angle: Float, msg: Msg, envelope: hive.syslink.Envelope): Float {
	if msg is Msg.Tick(ms) {
		return angle + hive.conv.itf(ms) * 0.002
	}
	return angle
}

proc main(): void {
	hive.ui.window("Uma caixa girando", view, spin, 0.0)
}

type Msg {
	Tick { ms: Int }
	Padded { pad: Int, control: Str, at: Float }
}

type Kart {
	x:        Float
	z:        Float
	steer:    Float
	throttle: Float
}

func view(kart: Kart): hive.ui.View {
	return hive.ui.scene(
		[
			hive.ui.grow(1),
			hive.ui.eye(kart.x, 4.0, kart.z + 9.0),
			hive.ui.aim(0.0, -0.25),
			hive.ui.lens(70),
			hive.ui.onFrame(Msg.Tick(_)),
			hive.ui.onPad(Msg.Padded(_, _, _)),
		],
		[
			hive.ui.ground(
				[hive.ui.paint(hive.ui.Tone.HEX("#61686f")), hive.ui.surface(hive.ui.Surface.Tarmac())],
				120.0, 120.0,
			),
			hive.ui.box(
				[
					hive.ui.at(kart.x, 0.4, kart.z),
					hive.ui.paint(hive.ui.Tone.HEX("#00d2be")),
					hive.ui.surface(hive.ui.Surface.Gloss()),
				],
				1.6, 0.6, 3.4,
			),
		],
	)
}

// Um analógico e um gatilho chegam pelo mesmo buraco e são distinguidos pelo
// nome, porque um botão é um comando que só é 0 ou 1. Nada é guardado aqui
// que o controle não tenha dito: onPad reporta o que *mudou*, então o modelo
// lembra a última posição de cada comando que lhe interessa.
proc drive(kart: Kart, msg: Msg, envelope: hive.syslink.Envelope): Kart {
	mut Kart it = kart
	if msg is Msg.Padded(pad, control, at) {
		if control == "leftX" { it.steer = at }
		if control == "rt" { it.throttle = at }
		return it
	}
	if msg is Msg.Tick(ms) {
		step := hive.conv.itf(ms) / 1000.0
		it.x = it.x + it.steer * it.throttle * 16.0 * step
		it.z = it.z - it.throttle * 16.0 * step
	}
	return it
}

proc main(): void {
	hive.ui.window("Um controle", view, drive, Kart(0.0, 0.0, 0.0, 0.0))
}