railway 0.3.3

Binary file format for vector animated pictures
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use railway::{*, computing::{*, Operation::*}};
use std::env::args;
use std::fs;

fn arg(name: Option<String>, value: Couple) -> Argument<String> {
	Argument {
		name,
		value,
		range: (value, value),
	}
}

use core::f32::consts::TAU;

fn main() {
	let w = 200.0;
	let h = 200.0;

	let mut arguments = Vec::new();

	let _zero = arguments.len();
	arguments.push(arg(None, C_ZERO));

	let size = arguments.len();
	arguments.push(arg(Some("size".into()), Couple::new(w, h)));

	let top_left_f = arguments.len();
	arguments.push(arg(None, Couple::new(0.05, 0.05)));

	let bottom_right_f = arguments.len();
	arguments.push(arg(None, Couple::new(0.95, 0.95)));

	let contour_rg = arguments.len();
	arguments.push(arg(None, Couple::new(0.5, 0.1)));

	let contour_ba = arguments.len();
	arguments.push(arg(None, Couple::new(0.5, 1.0)));

	let pattern = arguments.len();
	arguments.push(arg(None, Couple::new(100.0, 0.0)));

	let width = arguments.len();
	arguments.push(arg(None, Couple::new(4.0, 0.0)));

	let inverted_rg = arguments.len();
	arguments.push(arg(None, Couple::new(0.1, 0.5)));

	let deltas = arguments.len();
	arguments.push(arg(None, Couple::new(TAU, 0.0)));

	let radius = arguments.len();
	arguments.push(arg(None, Couple::new(0.0, -40.0)));

	let center_f = arguments.len();
	arguments.push(arg(None, Couple::new(0.75, 0.25)));

	let mut instructions = Vec::new();

	let top_left = arguments.len() + instructions.len();
	instructions.push(Instruction::new(Multiply2, size, top_left_f, 0));

	let bottom_right = arguments.len() + instructions.len();
	instructions.push(Instruction::new(Multiply2, size, bottom_right_f, 0));

	let bottom_left = arguments.len() + instructions.len();
	instructions.push(Instruction::new(Select2, top_left, bottom_right, 0));

	let top_right = arguments.len() + instructions.len();
	instructions.push(Instruction::new(Select2, bottom_right, top_left, 0));

	let center = arguments.len() + instructions.len();
	instructions.push(Instruction::new(Multiply2, size, center_f, 0));

	let start_point = arguments.len() + instructions.len();
	instructions.push(Instruction::new(Add2, center, radius, 0));

	let contour = [contour_rg, contour_ba];

	let line_style = Stroker {
		pattern,
		width,
		color: contour,
	};

	let background = vec![
		Triangle {
			points: [top_left, bottom_left, bottom_right],
			colors: [contour, [inverted_rg, contour_ba], contour],
		},
		Triangle {
			points: [top_left, top_right, bottom_right],
			colors: [contour, [inverted_rg, contour_ba], contour],
		},
	];

	let slope = vec![
		PathStep::Line(Line {
			points: [bottom_left, top_left],
		}),
		PathStep::QuadraticCurve(QuadraticCurve {
			points: [top_left, bottom_left, bottom_right],
		}),
		PathStep::Line(Line {
			points: [bottom_right, bottom_left],
		}),
	];

	let disk = vec![PathStep::Arc(Arc {
		start_point,
		center,
		deltas,
	})];

	let rendering_steps = [
		RenderingStep::Clip(&slope, &background),
		RenderingStep::Stroke(&slope, line_style),
		RenderingStep::Clip(&disk, &background),
		RenderingStep::Stroke(&disk, line_style),
	];

	let buffer = serialize(&arguments, &instructions, &[], &rendering_steps);
	let file_name = args().last().unwrap();
	fs::write(file_name, &buffer).unwrap();
}