Jean-Marie 'Histausse' Mineau
926acf8fdb
All checks were successful
/ test_checkout (push) Successful in 1m56s
1026 lines
22 KiB
Typst
1026 lines
22 KiB
Typst
|
|
#let mark(x, y) = {
|
|
place(line(start: (x - 5pt, y - 5pt), end: (x + 5pt, y + 5pt)))
|
|
place(line(start: (x + 5pt, y - 5pt), end: (x - 5pt, y + 5pt)))
|
|
}
|
|
|
|
#let polar(
|
|
x0: 0pt, y0: 0pt,
|
|
r: 0pt,
|
|
th: 0deg,
|
|
) = {
|
|
(
|
|
x0 + r * calc.cos(th),
|
|
y0 + r * calc.sin(th),
|
|
)
|
|
}
|
|
|
|
#let arc(
|
|
center: (0pt, 0pt),
|
|
r: 0pt,
|
|
th0: 0deg,
|
|
th1: 0deg,
|
|
) = {
|
|
let (x0, y0) = center
|
|
let (x1, y1) = polar(x0: x0, y0: y0, r: r, th: th0)
|
|
let (x2, y2) = polar(x0: x0, y0: y0, r: r, th: th1)
|
|
let (x_u1, y_u1) = polar(x0: 0pt, y0: 0pt, r: 1pt, th: th0 + 90deg)
|
|
let (x_u2, y_u2) = polar(x0: 0pt, y0: 0pt, r: 1pt, th: th1 + 90deg)
|
|
let th = th1 - th0
|
|
let l = 4 * r / 3 * calc.tan(th / 4) / 1pt
|
|
|
|
let x_q1 = x1 + l * x_u1
|
|
let y_q1 = y1 + l * y_u1
|
|
let x_q2 = x2 - l * x_u2
|
|
let y_q2 = y2 - l * y_u2
|
|
|
|
((x1, y1), (x_q1, y_q1), (x_q2, y_q2), (x2, y2))
|
|
}
|
|
|
|
#let circle_path(
|
|
center: (0pt, 0pt),
|
|
r: 0pt,
|
|
) = {
|
|
(
|
|
curve.move(
|
|
polar(x0: center.at(0), y0: center.at(1), r: r, th: 0deg)
|
|
),
|
|
..for i in range(4) {
|
|
let (p0, q0, q1, p1) = arc(center: center, r: r, th0: i*90deg, th1: (i+1)*90deg)
|
|
(curve.cubic(q0, q1, p1),)
|
|
},
|
|
curve.close()
|
|
)
|
|
}
|
|
|
|
|
|
#let phone(
|
|
width: 200pt,
|
|
height: 400pt,
|
|
stroke: 3pt+black,
|
|
body: [],
|
|
) = {
|
|
|
|
let h_screen = height*12/15
|
|
let w_screen = width*8/10
|
|
let r = (height/15)
|
|
|
|
let h_button = (height - h_screen) / 6
|
|
let w_button = w_screen / 3
|
|
let dy_button = -((height - h_screen) / 2 - h_button) / 2
|
|
|
|
let h-top-line = ((height - h_screen) / 2) / 6
|
|
let w-top-line-bar = w_screen / 2
|
|
let dy-top-line = (((height - h_screen) / 2) - h-top-line) / 3
|
|
|
|
let r-cam = ((height - h_screen) / 2) / 5
|
|
let dx-cam = -r-cam*2
|
|
let dy-cam = ((height - h_screen) / 2 / 2) - r-cam
|
|
|
|
let top-line = stack(
|
|
dir: ltr,
|
|
circle(radius: h-top-line/2, stroke: stroke),
|
|
h(h-top-line),
|
|
rect(
|
|
width: w-top-line-bar,
|
|
height: h-top-line,
|
|
radius: h-top-line/2,
|
|
stroke: stroke,
|
|
),
|
|
h(h-top-line),
|
|
circle(radius: h-top-line/2, stroke: stroke),
|
|
h(h-top-line),
|
|
circle(radius: h-top-line/2, stroke: stroke)
|
|
)
|
|
|
|
rect(
|
|
width: width,
|
|
height: height,
|
|
inset: 0pt,
|
|
stroke: stroke,
|
|
radius: r,
|
|
{
|
|
place(center+horizon,
|
|
rect(
|
|
width: w_screen,
|
|
height: h_screen,
|
|
stroke: stroke,
|
|
body,
|
|
)
|
|
)
|
|
place(center+bottom,
|
|
dy: dy_button,
|
|
rect(
|
|
width: w_button,
|
|
height: h_button,
|
|
stroke: stroke,
|
|
radius: h_screen / 2,
|
|
)
|
|
)
|
|
place(center+top,
|
|
dy: dy-top-line,
|
|
top-line
|
|
)
|
|
place(right+top,
|
|
dx: dx-cam,
|
|
dy: dy-cam,
|
|
circle(radius: r-cam, stroke: stroke)
|
|
)
|
|
}
|
|
)
|
|
}
|
|
|
|
#let gear(
|
|
//x0: 0pt, y0: 0pt,
|
|
out-rad: 100pt,
|
|
in-rad: none,
|
|
center-rad: none,
|
|
nb-teeth: 6,
|
|
teeth-angle: none,
|
|
stroke: black + 3pt,
|
|
fill: luma(70%),
|
|
) = {
|
|
let x0 = out-rad
|
|
let y0 = out-rad
|
|
let teeth-angle = if teeth-angle == none { 360deg / nb-teeth / 2 } else { teeth-angle }
|
|
let inter-teeth-angle = (360deg / nb-teeth) - teeth-angle
|
|
let in-rad = if in-rad == none { out-rad * 0.75 } else { in-rad }
|
|
let center-rad = if center-rad == none { in-rad / 2 } else { center-rad }
|
|
box(width: 2*out-rad, height: 2*out-rad, {
|
|
//place(left+bottom, line(start: (0%, -50%), end: (100%, -50%)))
|
|
//place(left+bottom, line(start: (50%, 0%), end: (50%, -100%)))
|
|
curve(
|
|
stroke: stroke,
|
|
fill: fill,
|
|
fill-rule: "even-odd",
|
|
..for i in range(nb-teeth) {
|
|
let angle = i * 360deg / nb-teeth
|
|
let center_off = calc.sin(teeth-angle/2) * in-rad
|
|
let (x0_1, y0_1) = polar(x0: x0, y0: y0, r: center_off, th: angle - 90deg)
|
|
let (x0_2, y0_2) = polar(x0: x0, y0: y0, r: center_off, th: angle + 90deg)
|
|
|
|
let p0 = polar(x0: x0_1, y0: y0_1, r: out-rad, th: angle)
|
|
let p1 = polar(x0: x0_2, y0: y0_2, r: out-rad, th: angle)
|
|
let p2 = polar(x0: x0, y0: y0, r: in-rad, th: angle + inter-teeth-angle/2)
|
|
let p3 = polar(x0: x0, y0: y0, r: in-rad, th: angle + 3*inter-teeth-angle/2)
|
|
|
|
let u2 = polar(x0: 0pt, y0: 0pt, r: 1pt, th: angle + inter-teeth-angle/2 + 90deg)
|
|
let u3 = polar(x0: 0pt, y0: 0pt, r: 1pt, th: angle + 3*inter-teeth-angle/2 + 90deg)
|
|
let l2 = 4 * in-rad / 3 * calc.tan(inter-teeth-angle / 4) / 1pt
|
|
let l3 = -l2
|
|
//let l2 = 1
|
|
let q2 = (p2.at(0) + l2 * u2.at(0), p2.at(1) + l2 * u2.at(1))
|
|
let q3 = (p3.at(0) + l3 * u3.at(0), p3.at(1) + l3 * u3.at(1))
|
|
|
|
let result = (
|
|
curve.line(p0),
|
|
curve.line(p1),
|
|
curve.line(p2),
|
|
|
|
/*
|
|
curve.line(q2),
|
|
curve.line(p2),
|
|
curve.line(p3),
|
|
curve.line(q3),
|
|
curve.line(p3),
|
|
*/
|
|
|
|
|
|
curve.cubic(q2, q3, p3)
|
|
)
|
|
if i == 0 {
|
|
result.insert(0, curve.move(p0))
|
|
}
|
|
result
|
|
|
|
},
|
|
curve.close(mode: "straight"),
|
|
..for i in range(4) {
|
|
let angle = i * 360deg / 4
|
|
let p0 = polar(x0: x0, y0: y0, r: center-rad, th: angle)
|
|
let u0 = polar(x0: 0pt, y0: 0pt, r: 1pt, th: angle + 90deg)
|
|
let p1 = polar(x0: x0, y0: y0, r: center-rad, th: angle+90deg)
|
|
let u1 = polar(x0: 0pt, y0: 0pt, r: 1pt, th: angle + 180deg)
|
|
let l0 = 4 * center-rad / 3 * calc.tan(90deg / 4) / 1pt
|
|
let l1 = -l0
|
|
let q0 = (p0.at(0) + l0 * u0.at(0), p0.at(1) + l0 * u0.at(1))
|
|
let q1 = (p1.at(0) + l1 * u1.at(0), p1.at(1) + l1 * u1.at(1))
|
|
let result = (
|
|
curve.cubic(q0, q1, p1),
|
|
)
|
|
if i == 0 {
|
|
result.insert(0, curve.move(p0))
|
|
}
|
|
result
|
|
},
|
|
curve.close()
|
|
)
|
|
/*place(left+bottom,
|
|
// wtf?
|
|
dx: out-rad - center-rad,
|
|
dy: -out-rad + center-rad,
|
|
circle(
|
|
radius: center-rad,
|
|
stroke: stroke,
|
|
fill: fill-center,
|
|
)
|
|
)*/
|
|
})
|
|
}
|
|
|
|
#let wrench(
|
|
length: 200pt,
|
|
hex_side: none,
|
|
handle_width: none,
|
|
head_rad: none,
|
|
stroke: 3pt+black,
|
|
fill: luma(70%),
|
|
) = {
|
|
let handle_width = if handle_width == none { length * 0.15 } else { handle_width }
|
|
let handle_rad = handle_width / 2
|
|
let head_rad = if head_rad == none { handle_rad * 2.2 } else { head_rad }
|
|
let hex_side = if hex_side == none { head_rad * 0.6 } else { hex_side }
|
|
let hex_angle = 360deg / 6
|
|
let head_width = hex_side * 0.2
|
|
let hex_h = hex_side * calc.cos(hex_angle * 2 - 90deg)
|
|
let pommel_center = (handle_rad, 0pt)
|
|
let head_neck_half_angle = calc.asin(handle_rad / head_rad)
|
|
let head_face_half_angle = calc.asin((hex_h + head_width) / head_rad)
|
|
let head_center = (length - calc.sqrt(
|
|
head_rad / 1pt * head_rad / 1pt -
|
|
(hex_h + head_width) / 1pt * (hex_h + head_width) / 1pt
|
|
) * 1pt , 0pt)
|
|
let handle_length = head_center.at(0) - calc.sqrt(
|
|
head_rad/1pt*head_rad/1pt - handle_rad/1pt*handle_rad/1pt
|
|
) * 1pt
|
|
let (
|
|
pommel_p0,
|
|
pommel_q0,
|
|
pommel_q1,
|
|
pommel_p1
|
|
) = arc(
|
|
center: pommel_center,
|
|
r: handle_rad,
|
|
th0: 90deg,
|
|
th1: 180deg
|
|
)
|
|
let (
|
|
_,
|
|
pommel_q2,
|
|
pommel_q3,
|
|
pommel_p3
|
|
) = arc(
|
|
center: pommel_center,
|
|
r: handle_rad,
|
|
th0: 180deg,
|
|
th1: 270deg
|
|
)
|
|
let neck_dw = (handle_length, handle_rad)
|
|
let neck_up = (handle_length, -handle_rad)
|
|
|
|
let (
|
|
head_neck_up_p0,
|
|
head_neck_up_q0,
|
|
head_neck_up_q1,
|
|
head_neck_up_p1
|
|
) = arc(
|
|
center: head_center,
|
|
r: head_rad,
|
|
th0: -90deg + head_neck_half_angle - 90deg,
|
|
th1: - 90deg
|
|
)
|
|
let (
|
|
head_fup_p0,
|
|
head_fup_q0,
|
|
head_fup_q1,
|
|
head_fup_p1
|
|
) = arc(
|
|
center: head_center,
|
|
r: head_rad,
|
|
th0: - 90deg,
|
|
th1: - head_face_half_angle,
|
|
)
|
|
let (
|
|
head_fdw_p0,
|
|
head_fdw_q0,
|
|
head_fdw_q1,
|
|
head_fdw_p1,
|
|
) = arc(
|
|
center: head_center,
|
|
r: head_rad,
|
|
th0: head_face_half_angle,
|
|
th1: 90deg,
|
|
)
|
|
let (
|
|
head_neck_dw_p0,
|
|
head_neck_dw_q0,
|
|
neck_dw_q1,
|
|
_
|
|
) = arc(
|
|
center: head_center,
|
|
r: head_rad,
|
|
th0: 90deg,
|
|
th1: 180deg - head_neck_half_angle
|
|
)
|
|
|
|
let hex_thi = -hex_angle
|
|
let hex_pi = (length - (1 + calc.cos(hex_angle)) * hex_side - head_width, 0pt)
|
|
let hex = (
|
|
..for i in range(6) {
|
|
let last_hex_p = hex_pi
|
|
hex_pi = polar(
|
|
x0: hex_pi.at(0),
|
|
y0: hex_pi.at(1),
|
|
r: hex_side,
|
|
th: hex_thi,
|
|
)
|
|
hex_thi = hex_thi + hex_angle
|
|
(last_hex_p,)
|
|
}
|
|
)
|
|
|
|
let head_fup_in = head_fup_p1
|
|
head_fup_in.at(1) += head_width
|
|
let head_fdw_in = head_fdw_p0
|
|
head_fdw_in.at(1) -= head_width
|
|
|
|
box(
|
|
width: 200pt,
|
|
height: 200pt,
|
|
//stroke: black,
|
|
place(left+horizon, {
|
|
|
|
place(curve(
|
|
stroke: stroke,
|
|
fill: fill,
|
|
curve.move(neck_dw),
|
|
curve.line(pommel_p0),
|
|
curve.cubic(pommel_q0, pommel_q1, pommel_p1),
|
|
curve.cubic(pommel_q2, pommel_q3, pommel_p3),
|
|
curve.line(neck_up),
|
|
//curve.line(head_neck_up_p0),
|
|
curve.cubic(head_neck_up_q0, head_neck_up_q1, head_neck_up_p1),
|
|
curve.cubic(head_fup_q0, head_fup_q1, head_fup_p1),
|
|
|
|
curve.line(head_fup_in),
|
|
..for i in (1, 0, 5) { //(2, 1, 0, 5, 4) {
|
|
(curve.line(hex.at(i)),)
|
|
},
|
|
curve.line(head_fdw_in),
|
|
|
|
curve.line(head_fdw_p0),
|
|
curve.cubic(head_fdw_q0, head_fdw_q1, head_fdw_p1),
|
|
//curve.line(head_neck_dw_p0),
|
|
curve.cubic(head_neck_dw_q0, neck_dw_q1, neck_dw),
|
|
|
|
curve.close(mode: "straight")
|
|
))
|
|
|
|
/*
|
|
mark(..pommel_center)
|
|
mark(..pommel_p0)
|
|
mark(..pommel_p1)
|
|
mark(..pommel_p3)
|
|
mark(..neck_up)
|
|
mark(..neck_dw)
|
|
|
|
mark(..head_fdw_p0)
|
|
mark(..head_fdw_p1)
|
|
for p in hex {
|
|
mark(..p)
|
|
}
|
|
mark(..head_center)
|
|
*/
|
|
|
|
}))
|
|
}
|
|
|
|
#let apk(height: 100pt) = image("imgs/ico/apk.svg", height: height)
|
|
#let apks(height: 100pt) = {
|
|
place(apk(height: height))
|
|
place(dx: height * 4 / 10, dy: -height * 3 / 10, apk(height: height))
|
|
place(dx: height * 6 / 10, dy: height / 10, apk(height: height))
|
|
}
|
|
|
|
#let transfo(height: 200pt) = {
|
|
box(width: height, height: height, {
|
|
place(
|
|
left+bottom,
|
|
dx: height / 12,
|
|
dy: - height * 3 / 12,
|
|
gear(out-rad: height/3)
|
|
)
|
|
place(
|
|
left+bottom,
|
|
dx: height * 2 / 5,
|
|
dy: 0pt,
|
|
wrench(length: height*7/8)
|
|
)
|
|
})
|
|
}
|
|
|
|
#let loop(height: 100pt) = image("imgs/ico/loop.svg", height: height)
|
|
|
|
#let analyse(height: 200pt) = {
|
|
box(width: height, stroke: black, {
|
|
apk(height: height)
|
|
place(
|
|
left+top,
|
|
dx: - height * 3/10,
|
|
dy: - height * 1 / 10,
|
|
loop(height: height/2)
|
|
)
|
|
})
|
|
}
|
|
|
|
#let report(height: 100pt) = image("imgs/ico/report.svg", height: height)
|
|
|
|
#let th-outline(height: 600pt, width: 900pt, hide-static: false) = {
|
|
let small-ico-h = height / 16
|
|
let big-ico-h = height / 6
|
|
|
|
let static = stack(dir: ltr,
|
|
apks(height: small-ico-h),
|
|
h(big-ico-h),
|
|
$ -> $,
|
|
h(big-ico-h),
|
|
analyse(height: big-ico-h),
|
|
h(big-ico-h),
|
|
$ -> $,
|
|
h(big-ico-h),
|
|
report(height: small-ico-h),
|
|
)
|
|
|
|
let th = stack(dir: ltr,
|
|
apks(height: small-ico-h),
|
|
h(big-ico-h*2/3),
|
|
$->$,
|
|
h(big-ico-h/4),
|
|
phone(height: height/4, width: height/8),
|
|
h(big-ico-h/4),
|
|
$->$,
|
|
h(big-ico-h/4),
|
|
transfo(height: big-ico-h),
|
|
h(big-ico-h/4),
|
|
$->$,
|
|
h(big-ico-h/4),
|
|
apk(height: small-ico-h),
|
|
h(big-ico-h/4),
|
|
$->$,
|
|
h(big-ico-h/4),
|
|
analyse(height: big-ico-h),
|
|
h(big-ico-h/4),
|
|
$->$,
|
|
h(big-ico-h/4),
|
|
report(height: small-ico-h),
|
|
)
|
|
|
|
box(height: 600pt, width: 900pt,
|
|
stack(
|
|
if hide-static { hide(static)} else { static },
|
|
v(big-ico-h),
|
|
th,
|
|
)
|
|
)
|
|
}
|
|
|
|
#let file(
|
|
height: 200pt,
|
|
stroke: black + 3pt,
|
|
fill: white,
|
|
fill_back: none,
|
|
type: "cornered",
|
|
body: [],
|
|
) = {
|
|
let width = height / 1.414
|
|
let fill_back = if fill_back == none { fill.lighten(30%) } else { fill_back }
|
|
|
|
let types = (
|
|
"cornered",
|
|
"plain",
|
|
"clip",
|
|
)
|
|
assert(
|
|
type in types,
|
|
message: "type for file must be in " + repr(types)
|
|
)
|
|
|
|
let corner = (
|
|
width - height / 5,
|
|
height / 5,
|
|
)
|
|
let corner_up = (
|
|
corner.at(0),
|
|
0pt,
|
|
)
|
|
let corner_dw = (
|
|
width,
|
|
corner.at(1)
|
|
)
|
|
/*
|
|
let corner_up_q = (
|
|
(corner_up.at(0) + width) / 2,
|
|
corner_up.at(1)
|
|
)
|
|
let corner_q0 = (
|
|
corner.at(0),
|
|
corner.at(1)
|
|
)
|
|
let corner_q1 = (
|
|
corner.at(0),
|
|
corner.at(1)
|
|
)
|
|
let corner_dw_q = (
|
|
corner_dw.at(0),
|
|
corner_dw.at(1) / 3
|
|
)*/
|
|
|
|
let corner_pth = if type == "cornered" {
|
|
(
|
|
curve.line(corner_up),
|
|
curve.line(corner),
|
|
//curve.cubic(
|
|
// corner_up_q,
|
|
// corner_q0,
|
|
// corner
|
|
//),
|
|
curve.line(corner_dw)
|
|
//curve.cubic(
|
|
// corner_q1,
|
|
// corner_dw_q,
|
|
// corner_dw,
|
|
//),
|
|
)
|
|
} else {
|
|
(curve.line((width, 0pt)),)
|
|
}
|
|
|
|
box(
|
|
width: width,
|
|
height: height,
|
|
//stroke: black,
|
|
{
|
|
if type == "cornered" {
|
|
let stroke = std.stroke(
|
|
join: "round",
|
|
paint: stroke.paint,
|
|
thickness: stroke.thickness,
|
|
)
|
|
place(top+left, {
|
|
curve(
|
|
fill: fill_back,
|
|
stroke: stroke,
|
|
curve.move(corner_up),
|
|
curve.line(corner),
|
|
curve.line(corner_dw),
|
|
curve.close()
|
|
)
|
|
})
|
|
}
|
|
place(top+left, {
|
|
curve(
|
|
fill: fill,
|
|
stroke: stroke,
|
|
curve.move((0pt, 0pt)),
|
|
..corner_pth,
|
|
curve.line((width, height)),
|
|
curve.line((0pt, height)),
|
|
curve.close(),
|
|
)
|
|
})
|
|
}
|
|
)
|
|
}
|
|
|
|
#let android(
|
|
height: 200pt,
|
|
stroke: black + 3pt,
|
|
stroke_eye: none,
|
|
fill: green,
|
|
fill_eye: white,
|
|
) = {
|
|
let width = height * 0.78
|
|
|
|
let body_height = height * 0.47
|
|
let body_width = body_height * 1
|
|
|
|
let leg_height = body_height / 2
|
|
let leg_width = body_width / 4
|
|
let leg_gap = body_width / 4
|
|
|
|
let arm_width = leg_width
|
|
let arm_length = body_height * 0.8
|
|
let arm_gap = arm_width / 4
|
|
let arm_offset_to_body = 0pt
|
|
|
|
let head_gap = body_height * 0.1
|
|
|
|
let antenna_angle = 45deg
|
|
let antenna_width = body_width * 0.07
|
|
let antenna_width_angle = calc.asin(2*antenna_width/body_width)
|
|
let antenna_length = body_width * 0.2
|
|
|
|
let eye_rad = body_width * 0.05
|
|
let rad_eye_in_head = body_width * 0.35
|
|
let angle_eye = 45deg
|
|
|
|
let leg_r_1 = (
|
|
width / 2 + leg_gap / 2,
|
|
height - leg_height
|
|
)
|
|
let leg_r_c = (
|
|
width / 2 + leg_gap / 2 + leg_width / 2,
|
|
height - leg_width / 2
|
|
)
|
|
let (
|
|
leg_r_2,
|
|
leg_r_2_q,
|
|
leg_r_3_q0,
|
|
leg_r_3,
|
|
) = arc(
|
|
center: leg_r_c,
|
|
r: leg_width / 2,
|
|
th0: 180deg,
|
|
th1: 90deg,
|
|
)
|
|
let (
|
|
_,
|
|
leg_r_3_q1,
|
|
leg_r_4_q,
|
|
leg_r_4,
|
|
) = arc(
|
|
center: leg_r_c,
|
|
r: leg_width / 2,
|
|
th0: 90deg,
|
|
th1: 0deg,
|
|
)
|
|
let leg_r_5 = (
|
|
width / 2 + leg_gap / 2 + leg_width,
|
|
height - leg_height
|
|
)
|
|
let body_dr = (
|
|
width / 2 + body_width / 2,
|
|
height - leg_height
|
|
)
|
|
let body_ur = (
|
|
width / 2 + body_width / 2,
|
|
height - body_height - leg_height
|
|
)
|
|
let body_ul = (
|
|
width / 2 - body_width / 2,
|
|
height - body_height - leg_height
|
|
)
|
|
let body_dl = (
|
|
width / 2 - body_width / 2,
|
|
height - leg_height
|
|
)
|
|
let leg_l_1 = (
|
|
width / 2 - leg_gap / 2 - leg_width,
|
|
height - leg_height
|
|
)
|
|
let leg_l_c = (
|
|
width / 2 - leg_gap / 2 - leg_width / 2,
|
|
height - leg_width / 2
|
|
)
|
|
let (
|
|
leg_l_2,
|
|
leg_l_2_q,
|
|
leg_l_3_q0,
|
|
leg_l_3,
|
|
) = arc(
|
|
center: leg_l_c,
|
|
r: leg_width / 2,
|
|
th0: 180deg,
|
|
th1: 90deg,
|
|
)
|
|
let (
|
|
_,
|
|
leg_l_3_q1,
|
|
leg_l_4_q,
|
|
leg_l_4,
|
|
) = arc(
|
|
center: leg_l_c,
|
|
r: leg_width / 2,
|
|
th0: 90deg,
|
|
th1: 0deg,
|
|
)
|
|
let leg_l_5 = (
|
|
width / 2 - leg_gap / 2,
|
|
height - leg_height
|
|
)
|
|
|
|
let head_center = (
|
|
width / 2,
|
|
height - leg_height - body_height - head_gap,
|
|
)
|
|
let (
|
|
head_r,
|
|
head_r_q,
|
|
head_ra1_q,
|
|
head_ra1
|
|
) = arc(
|
|
center: head_center,
|
|
r: body_width / 2,
|
|
th0: 0deg,
|
|
th1: - antenna_angle + antenna_width_angle/2,
|
|
)
|
|
let antenna_r_c = polar(
|
|
x0: head_center.at(0),
|
|
y0: head_center.at(1),
|
|
r: body_width / 2 + antenna_length - antenna_width/2,
|
|
th: - antenna_angle
|
|
)
|
|
let (
|
|
antenna_r_0,
|
|
antenna_r_0_q,
|
|
antenna_r_1_q0,
|
|
antenna_r_1
|
|
) = arc(
|
|
center: antenna_r_c,
|
|
r: antenna_width/2,
|
|
th0: - antenna_angle + 90deg,
|
|
th1: - antenna_angle,
|
|
)
|
|
let (
|
|
_,
|
|
antenna_r_1_q1,
|
|
antenna_r_2_q,
|
|
antenna_r_2
|
|
) = arc(
|
|
center: antenna_r_c,
|
|
r: antenna_width/2,
|
|
th0: - antenna_angle,
|
|
th1: - antenna_angle - 90deg,
|
|
)
|
|
let (
|
|
head_ra2,
|
|
head_ra2_q,
|
|
head_t_q0,
|
|
head_t
|
|
) = arc(
|
|
center: head_center,
|
|
r: body_width / 2,
|
|
th0: - antenna_angle - antenna_width_angle/2,
|
|
th1: -90deg,
|
|
)
|
|
let (
|
|
head_la1,
|
|
head_la1_q,
|
|
head_t_q1,
|
|
_,
|
|
) = arc(
|
|
center: head_center,
|
|
r: body_width / 2,
|
|
th0: 180deg + antenna_angle + antenna_width_angle/2,
|
|
th1: 270deg,
|
|
)
|
|
|
|
let antenna_l_c = polar(
|
|
x0: head_center.at(0),
|
|
y0: head_center.at(1),
|
|
r: body_width / 2 + antenna_length - antenna_width/2,
|
|
th: 180deg + antenna_angle
|
|
)
|
|
let (
|
|
antenna_l_0,
|
|
antenna_l_0_q,
|
|
antenna_l_1_q0,
|
|
antenna_l_1
|
|
) = arc(
|
|
center: antenna_l_c,
|
|
r: antenna_width/2,
|
|
th0: 180deg + antenna_angle + 90deg,
|
|
th1: 180deg + antenna_angle,
|
|
)
|
|
let (
|
|
_,
|
|
antenna_l_1_q1,
|
|
antenna_l_2_q,
|
|
antenna_l_2
|
|
) = arc(
|
|
center: antenna_l_c,
|
|
r: antenna_width/2,
|
|
th0: 180deg + antenna_angle,
|
|
th1: 180deg + antenna_angle -90deg,
|
|
)
|
|
let (
|
|
head_la2,
|
|
head_la2_q,
|
|
head_l_q,
|
|
head_l
|
|
) = arc(
|
|
center: head_center,
|
|
r: body_width / 2,
|
|
th0: 180deg + antenna_angle - antenna_width_angle/2,
|
|
th1: 180deg,
|
|
)
|
|
|
|
let eye_l = circle_path(
|
|
center: polar(
|
|
x0: head_center.at(0),
|
|
y0: head_center.at(1),
|
|
r: rad_eye_in_head,
|
|
th: 180deg + angle_eye,
|
|
),
|
|
r: eye_rad
|
|
)
|
|
let eye_r = circle_path(
|
|
center: polar(
|
|
x0: head_center.at(0),
|
|
y0: head_center.at(1),
|
|
r: rad_eye_in_head,
|
|
th: - angle_eye,
|
|
),
|
|
r: eye_rad
|
|
)
|
|
|
|
let arm_lup_c = (
|
|
width/2 - body_width/2 - arm_gap - arm_width/2,
|
|
height - leg_height - body_height + arm_width/2 - arm_offset_to_body,
|
|
)
|
|
let arm_ldw_c = (
|
|
width/2 - body_width/2 - arm_gap - arm_width/2,
|
|
height - leg_height - body_height - arm_width/2 - arm_offset_to_body + arm_length
|
|
)
|
|
let arm_rup_c = (
|
|
width/2 + body_width/2 + arm_gap + arm_width/2,
|
|
height - leg_height - body_height + arm_width/2 - arm_offset_to_body
|
|
)
|
|
let arm_rdw_c = (
|
|
width/2 + body_width/2 + arm_gap + arm_width/2,
|
|
height - leg_height - body_height - arm_width/2 - arm_offset_to_body + arm_length
|
|
)
|
|
|
|
let (
|
|
arm_lup_0,
|
|
arm_lup_0_q,
|
|
arm_lup_1_q0,
|
|
arm_lup_1,
|
|
) = arc(
|
|
center: arm_lup_c,
|
|
r: arm_width/2,
|
|
th0: 0deg,
|
|
th1: -90deg,
|
|
)
|
|
let (
|
|
_,
|
|
arm_lup_1_q1,
|
|
arm_lup_2_q,
|
|
arm_lup_2,
|
|
) = arc(
|
|
center: arm_lup_c,
|
|
r: arm_width/2,
|
|
th0: -90deg,
|
|
th1: -180deg,
|
|
)
|
|
let (
|
|
arm_ldw_0,
|
|
arm_ldw_0_q,
|
|
arm_ldw_1_q0,
|
|
arm_ldw_1,
|
|
) = arc(
|
|
center: arm_ldw_c,
|
|
r: arm_width/2,
|
|
th0: -180deg,
|
|
th1: -270deg,
|
|
)
|
|
let (
|
|
_,
|
|
arm_ldw_1_q1,
|
|
arm_ldw_2_q,
|
|
arm_ldw_2,
|
|
) = arc(
|
|
center: arm_ldw_c,
|
|
r: arm_width/2,
|
|
th0: -270deg,
|
|
th1: -360deg,
|
|
)
|
|
|
|
let (
|
|
arm_rup_0,
|
|
arm_rup_0_q,
|
|
arm_rup_1_q0,
|
|
arm_rup_1,
|
|
) = arc(
|
|
center: arm_rup_c,
|
|
r: arm_width/2,
|
|
th0: 0deg,
|
|
th1: -90deg,
|
|
)
|
|
let (
|
|
_,
|
|
arm_rup_1_q1,
|
|
arm_rup_2_q,
|
|
arm_rup_2,
|
|
) = arc(
|
|
center: arm_rup_c,
|
|
r: arm_width/2,
|
|
th0: -90deg,
|
|
th1: -180deg,
|
|
)
|
|
let (
|
|
arm_rdw_0,
|
|
arm_rdw_0_q,
|
|
arm_rdw_1_q0,
|
|
arm_rdw_1,
|
|
) = arc(
|
|
center: arm_rdw_c,
|
|
r: arm_width/2,
|
|
th0: -180deg,
|
|
th1: -270deg,
|
|
)
|
|
let (
|
|
_,
|
|
arm_rdw_1_q1,
|
|
arm_rdw_2_q,
|
|
arm_rdw_2,
|
|
) = arc(
|
|
center: arm_rdw_c,
|
|
r: arm_width/2,
|
|
th0: -270deg,
|
|
th1: -360deg,
|
|
)
|
|
|
|
|
|
box(
|
|
width: width,
|
|
height: height,
|
|
//stroke: black,
|
|
{
|
|
place(left+top, curve(
|
|
stroke: stroke,
|
|
fill: fill,
|
|
curve.move(leg_r_1),
|
|
curve.line(leg_r_2),
|
|
curve.cubic(leg_r_2_q, leg_r_3_q0, leg_r_3),
|
|
curve.cubic(leg_r_3_q1, leg_r_4_q, leg_r_4),
|
|
curve.line(leg_r_5),
|
|
curve.line(body_dr),
|
|
curve.line(body_ur),
|
|
curve.line(body_ul),
|
|
curve.line(body_dl),
|
|
curve.line(leg_l_1),
|
|
curve.line(leg_l_2),
|
|
curve.cubic(leg_l_2_q, leg_l_3_q0, leg_l_3),
|
|
curve.cubic(leg_l_3_q1, leg_l_4_q, leg_l_4),
|
|
curve.line(leg_l_5),
|
|
curve.close(),
|
|
|
|
curve.move(head_r),
|
|
curve.cubic(head_r_q, head_ra1_q, head_ra1),
|
|
curve.line(antenna_r_0),
|
|
curve.cubic(antenna_r_0_q, antenna_r_1_q0, antenna_r_1),
|
|
curve.cubic(antenna_r_1_q1, antenna_r_2_q, antenna_r_2),
|
|
curve.line(head_ra2),
|
|
curve.cubic(head_ra2_q, head_t_q0, head_t),
|
|
curve.cubic(head_t_q1, head_la1_q, head_la1),
|
|
curve.line(antenna_l_0),
|
|
curve.cubic(antenna_l_0_q, antenna_l_1_q0, antenna_l_1),
|
|
curve.cubic(antenna_l_1_q1, antenna_l_2_q, antenna_l_2),
|
|
curve.line(head_la2),
|
|
curve.cubic(head_la2_q, head_l_q, head_l),
|
|
curve.close(mode: "straight"),
|
|
|
|
curve.move(arm_lup_0),
|
|
curve.cubic(arm_lup_0_q, arm_lup_1_q0, arm_lup_1),
|
|
curve.cubic(arm_lup_1_q1, arm_lup_2_q, arm_lup_2),
|
|
curve.line(arm_ldw_0),
|
|
curve.cubic(arm_ldw_0_q, arm_ldw_1_q0, arm_ldw_1),
|
|
curve.cubic(arm_ldw_1_q1, arm_ldw_2_q, arm_ldw_2),
|
|
curve.close(mode: "straight"),
|
|
|
|
curve.move(arm_rup_0),
|
|
curve.cubic(arm_rup_0_q, arm_rup_1_q0, arm_rup_1),
|
|
curve.cubic(arm_rup_1_q1, arm_rup_2_q, arm_rup_2),
|
|
curve.line(arm_rdw_0),
|
|
curve.cubic(arm_rdw_0_q, arm_rdw_1_q0, arm_rdw_1),
|
|
curve.cubic(arm_rdw_1_q1, arm_rdw_2_q, arm_rdw_2),
|
|
curve.close(mode: "straight"),
|
|
))
|
|
place(left+top, curve(
|
|
stroke: stroke_eye,
|
|
fill: fill_eye,
|
|
..eye_l,
|
|
..eye_r
|
|
))
|
|
}
|
|
)
|
|
}
|
|
|
|
//#gear()
|
|
//#phone(body: [Hello World!])
|
|
//#wrench()
|
|
|
|
#file(fill: green)
|
|
#h(2em)
|
|
#android(height: 200pt)
|
|
|
|
/*
|
|
#apk()
|
|
#v(4em)
|
|
#apks()
|
|
#v(12em)
|
|
#transfo()
|
|
#analyse()
|
|
#report()
|
|
*/
|