30:T78f,function Turtle() { let pos, heading, factor, down; const plot = Plot(); const { cos, sin, PI, max, abs, floor } = Math; const tau = 2 * PI; const samePos = ([x1, y1], [x2, y2]) => x1 == x2 && y1 == y2; const move = (dest, forceUp) => { if (down && !forceUp) plot.draw(...vec(pos, dest)); else plot.move(...vec(pos, dest)); pos = dest; }; const args2Pos = (x, y) => (y == undefined ? x : [x, y]); this.position = this.pos = () => pos; this.xcor = this.x = () => pos[0]; this.ycor = this.y = () => pos[1]; this.heading = this.h = () => heading; this.isdown = () => down; this.pd = this.down = this.pendown = () => (down = true); this.pu = this.up = this.penup = () => (down = false); const add = ([x1, y1], [x2, y2]) => [x1 + x2, y1 + y2]; const vec = ([x1, y1], [x2, y2]) => [x2 - x1, y2 - y1]; const forward = (d) => move(add(pos, [d * cos(heading), d * sin(heading)])); this.fd = this.forward = forward; this.bk = this.back = this.backward = (d) => this.fd(-d); this.right = this.rt = (angle) => (heading += angle * factor); this.left = this.lt = (angle) => this.rt(-angle); this.jump = this.jmp = (x, y) => move(args2Pos(x, y), true); this.goto = this.setpos = this.setposition = (x, y) => move(args2Pos(x, y)); this.setx = (x) => (pos[0] = x); this.sety = (y) => (pos[1] = y); this.seth = this.setheading = (h) => (heading = h * factor); this.home = () => ((pos = [0, 0]), (heading = 0), (down = true)); this.degrees = (full = 360) => (factor = tau / full); this.radians = () => (factor = 1); this.circle = (radius, extent, steps) => { extent = extent ? extent * factor : tau; let nb = steps || max(6, floor(((abs(radius) * extent) / tau) * 10)); const da = (radius > 0 ? extent : -extent) / nb / 2; while (nb-- > 0) (heading += da), this.fd(radius * da * 2), (heading += da); }; this.plot = plot; this.home(); this.degrees(); }31:T523,{ await visibility(); const T = new Turtle(); const order = 6; // min=4 max=10 step=1 const radius = 80; const maxDepth = 7; // min=0 max=10 step=1 const intermediary = 0; // min=0 max=1 step=1 (No, Yes) const theta = (Math.PI * (order - 2)) / order; const [cos, sin] = [Math.cos(theta), Math.sin(theta)]; const ratio = 1 / Math.sqrt(5 - 4 * cos); const angle = (Math.atan(sin / (2 - cos)) * 180) / Math.PI; const alpha = 360 / order; const size = radius * 2 * Math.sin((alpha * Math.PI) / 360); const segment = (depth, max) => { const length = size * ratio ** depth; if (depth == max) T.forward(length); else { T.left(angle); segment(depth + 1, max); T.right(alpha); segment(depth + 1, max); T.left(alpha); segment(depth + 1, max); T.right(angle); } }; // The walk function will be called until it returns false. function walk(i) { if (intermediary || i == maxDepth) { T.penup(); T.forward(radius); T.right(90 + alpha / 2); T.pendown(); for (let s = 0; s < order; s++) { segment(0, i); T.right(alpha); } T.penup(); T.left(90 + alpha / 2); T.backward(radius); T.pendown(); } return i < maxDepth; } return finalize(T, walk); }32:T1d7a,{ await visibility(); const turtle = new Turtle(); // Text utility function, based on https://turtletoy.net/turtle/1713ddbe99 const print = (() => { const raw = "br>eoj^jlbrf^fe`ukZdz`thZhw^vs^as]wtgtfsereqfph" + "nmlpjrhsdsbraq`o`makbjifjekckaj_h^f_eaecffhimporqssstrtq>eoj`i_j^k_kajcid>cqnZl\\j_hcghglhqjulxnz>c" + "qfZh\\j_lcmhmllqjuhxfz>brjdjp]wjajsfnkrjsirjqkrktiv>]wajsj>fnjqirjskrjq>_usZaz>`ti" + "^f_dbcgcjdofrisksnrpoqjqgpbn_k^i^>`tfbhak^ks>`tdcdbe`f_h^l^n_o`pbpdofmicsqs>`te^p^jfmfogphqkqmppnrk" + "shserdqco>`tm^clrl`to^e^dgefhekenfphqkqmppnrkshserdqco>`tpao_l^j^g_ebdgdlepgrjsksnrppqmqlping" + "kfjfggeidl>`tq^gs`th^e_dadceegfkgnhpjqlqopqorlshserdqcocldjfhigmfoepcpao_l^h^>`tpeohmjjkikfjd" + "hcecddaf_i^j^m_oapepjoomrjshserdp>fnjjikjlkkjjfnjjikjlkkjj^vrabjrs>]wag" + "sg^vbarjbs>asdcdbe`f_h^l^n_o`pbpdofngjijl]xofndlcicgdfeehekfmhnknmmnkasj^bs_tc^cs`urcqao_m^i^g_eadccfckdnepgrismsorqprn>_tc^cs`sd^ds`rd^ds`urcqao_m^i^g_eadccfckdnepgrismsorqprnrk_uc^cs<" + "q^qsfnj^js>brn^nnmqlrjshsfreqdndl>_tc^cs`qd^ds^vb^bs_uc^cs_uh^f_daccbfbkcndpfrhslsnrppqnrkrfqcpan_l^h^>_tc^cs_uh^f_daccbfbkcnd" + "pfrhslsnrppqnrkrfqcpan_l^h^_tc^cs`tqao_l^h^e_caccdeefggmiojpkqmqpo" + "rlshsercp>brj^js_uc^cmdpfrisksnrppqmq^>asb^js^v`^es`tc^qsasb^jhjs" + "`tq^cscqgZgzcqc^qv>cqlZlzbrj\\bjasazsz>fnkc" + "ieigjhkgjfig>atpeps`sd^dsasphnfleiegfeh" + "dkdmepgrislsnrpp>atp^psasdkpkpiognfleiegfehdkdmepgrislsnrpp>eqo^m^k_j" + "bjsatpepuoxnylzizgyate^esfni^j_k^j]i^eoj^" + "k_l^k]j^are^esfnj^js>[y_e_s<_ibfdegeifjijsateeesatiegfehdkdmepgrislsnrppqmqkphnfleie>`sdedzatpepzcpgegsbsphofleieffehfjhkmlompopporlsisfrep>eqj^jokrmsosateeeofrhsks" + "mrpobrdejs_ubefsbseepsbrdejsbspeescqlZj[" + "i\\h^h`ibjckekgiifnjZjz>cqhZj[k\\l^l`kbjci" + "eigki^vamakbhdgfghhlknlplrksibrb^bscsc^d^dsese^f^fsgsg^h^hsisi^j^jsksk^l^lsmsm^n^nsoso^p^psqsq^r^rs"; const decode = (char) => char.charCodeAt(0) - 106; const decodePos = ([x, y]) => [decode(x), decode(y)]; const decodePath = (str) => str.match(/.{2}/g).map(decodePos); const decodePaths = (str) => (str ? str.split("<").map(decodePath) : []); const decodeGlyph = ([lt, rt, ...rest], i) => [ decode(lt), decode(rt), decodePaths(rest.join("")) ]; const font = raw.split(">").map(decodeGlyph); const add = ([x1, y1], [x2, y2]) => [x1 + x2, y1 + y2]; const rot = ([x, y], [cos, sin]) => [x * cos - y * sin, y * cos + x * sin]; //console.log(font.map((g, i) => [String.fromCharCode(i+32), ...g])) return (t, str, options = {}) => { const defaults = { scale: [1, 1], italic: 0, kerning: 1, align: "left" }; const { scale, italic, kerning, align } = Object.assign( defaults, options ); const [sx, sy] = scale ? (isNaN(scale) ? scale : [scale, scale]) : [1, 1]; const strWidth = (str) => [...str].reduce((w, char) => { const code = char.charCodeAt(0) - 32; const [lt, rt] = font[code] || [0, 0]; return w + (rt - lt); }, 0); const width = Math.max(...str.split("\n").map(strWidth)) * sx * kerning; let pos = [t.x(), t.y()], o = pos; const h = t.h(), [ch, sh] = [Math.cos(h), Math.sin(h)]; const printPaths = (paths) => { const pos = [t.x(), t.y()]; paths.forEach((path) => { path.forEach(([x, y], i) => { const abs = add( pos, rot([(x - y * italic) * sx, y * sy], [ch, sh]) ); i == 0 ? t.jump(abs) : t.goto(abs); }); }); }; const start = [t.x(), t.y()]; str.split("\n").map((line) => { const start = [t.x(), t.y()]; const lineWidth = strWidth(line) * sx * kerning; const dx = { left: 0, middle: lineWidth / 2, right: lineWidth }[align]; t.up(); t.backward(dx); line.split("").forEach((char) => { const start = [t.x(), t.y()]; const code = char.charCodeAt(0) - 32; const [lt, rt, paths] = font[code] || [0, 0, []]; t.up(); t.backward(lt * sx); t.down(); printPaths(paths); t.up(); t.jump(start); t.forward((rt - lt) * sx * kerning); }); t.jump(start); t.up(); t.right(90); t.forward(38 * sy); t.left(90); }); t.jump(start); }; })(); const fit = 0.2; const round = (number, n) => { const d = Math.pow(10, n); return Math.round((number + Number.EPSILON) * d) / d; }; const roundScale = (scale, n) => { return Array.isArray(scale) ? `[${round(scale[0], n)}, ${round(scale[1], n)}]` : round(scale, n); }; const printWithOptions = (options = {}) => { const defaults = { scale: [1, 1], italic: 0, kerning: 1, align: "left" }; const { scale, italic, kerning, align } = Object.assign(defaults, options); const optStr = `scale: ${roundScale( scale, 2 )}, italic: ${italic}, kerning: ${kerning}, align: ${align}`; const str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\n0123456789 &\"'(-_)=+^$%*,?;.:/!~#{[|^@]}<>"; print(turtle, `${optStr}\n${str}`, options); }; function walk(i) { turtle.jump(0, -90); printWithOptions({ scale: fit, italic: 0.2, align: "middle" }); turtle.jump(0, -60); printWithOptions({ scale: fit, kerning: 0.95, align: "middle" }); turtle.jump(0, -30); printWithOptions({ scale: [fit * 0.9, fit], kerning: 0.95, align: "middle" }); turtle.jump(0, 0); printWithOptions({ scale: [fit * 0.8, fit], kerning: 0.95, align: "middle" }); turtle.jump(0, 30); printWithOptions({ scale: [fit * 0.7, fit], kerning: 0.95, align: "middle" }); turtle.jump(0, 55); printWithOptions({ scale: [fit * 0.6, fit * 0.6], kerning: 0.95, align: "left" }); turtle.jump(0, 85); printWithOptions({ scale: [fit * 0.6, fit * 0.6], kerning: 0.95, align: "right" }); turtle.jump(0, 70); turtle.radians(); turtle.setheading(Math.PI / 10); printWithOptions({ scale: fit * 0.6, kerning: 0.95, align: "middle" }); } return finalize(turtle, walk); }33:T106d,{ await visibility(); // Tesselation #1. Created by Reinder Nijhoff 2021 - @reindernijhoff // // https://turtletoy.net/turtle/6e4e06d42e // const seed = 1; // min=1, max=100, step=1 const segments = 70; // min=10, max=200, step=1 const innerRadius = 25; // min=10, max=100, step=0.1 const ringWidth = 3; // min=1, max=20, step=0.1 const ringWidthPow = 1.05; // min=1, max=1.5, step=0.01 const noiseAmplitude = 5; // min=0, max=20, step=0.1 const noiseFreq = 0.0175; // min=0, max=0.2, step=0.001 const noiseFallOffPow = 0.5; // min=0.1, max=2, step=0.01 const turtle = new Turtle(); const noise1 = new SimplexNoise(seed); const noise2 = new SimplexNoise(seed + 1); const lines = Math.ceil(200 / ringWidth); const da = (Math.PI * 2) / segments; function point(a, i) { const radius = Math.pow(i, ringWidthPow) * ringWidth + innerRadius; const p = [Math.cos(a) * radius, Math.sin(a) * radius]; p[0] += noise1.noise2D([p[0] * noiseFreq, p[1] * noiseFreq]) * noiseAmplitude * Math.pow(2 - Math.sqrt(p[0] ** 2 + p[1] ** 2) / 500, noiseFallOffPow); p[1] += noise2.noise2D([p[0] * noiseFreq, p[1] * noiseFreq]) * noiseAmplitude * Math.pow(2 - Math.sqrt(p[0] ** 2 + p[1] ** 2) / 500, noiseFallOffPow); return p; } function triangleLines(p0, p1, p2, p3) { turtle.jump(p2); turtle.goto(p0); turtle.goto(p1); turtle.jump(p0); turtle.goto(p3); } function walk(i) { for (let s = 0; s < segments; s++) { const a0 = (-(i / 2) * da) / 2 + da * s; const a1 = (-((i + 1) / 2) * da) / 2 + da * s; triangleLines( point(a0, i), point(a0 + da, i), point(a1, i + 1), point(a1 + da, i + 1) ); } return i < lines; } //////////////////////////////////////////////////////////////// // Simplex Noise utility code. Created by Reinder Nijhoff 2020 // https://turtletoy.net/turtle/6e4e06d42e // Based on: http://webstaff.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf //////////////////////////////////////////////////////////////// function SimplexNoise(seed = 1) { const grad = [ [1, 1, 0], [-1, 1, 0], [1, -1, 0], [-1, -1, 0], [1, 0, 1], [-1, 0, 1], [1, 0, -1], [-1, 0, -1], [0, 1, 1], [0, -1, 1], [0, 1, -1], [0, -1, -1] ]; const perm = new Uint8Array(512); const F2 = (Math.sqrt(3) - 1) / 2, F3 = 1 / 3; const G2 = (3 - Math.sqrt(3)) / 6, G3 = 1 / 6; const dot2 = (a, b) => a[0] * b[0] + a[1] * b[1]; const sub2 = (a, b) => [a[0] - b[0], a[1] - b[1]]; const dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; const sub3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; class SimplexNoise { constructor(seed = 1) { for (let i = 0; i < 512; i++) { perm[i] = i & 255; } for (let i = 0; i < 255; i++) { const r = ((seed = this.hash(i + seed)) % (256 - i)) + i; const swp = perm[i]; perm[i + 256] = perm[i] = perm[r]; perm[r + 256] = perm[r] = swp; } } noise2D(p) { const s = dot2(p, [F2, F2]); const c = [Math.floor(p[0] + s), Math.floor(p[1] + s)]; const i = c[0] & 255, j = c[1] & 255; const t = dot2(c, [G2, G2]); const p0 = sub2(p, sub2(c, [t, t])); const o = p0[0] > p0[1] ? [1, 0] : [0, 1]; const p1 = sub2(sub2(p0, o), [-G2, -G2]); const p2 = sub2(p0, [1 - 2 * G2, 1 - 2 * G2]); let n = Math.max(0, 0.5 - dot2(p0, p0)) ** 4 * dot2(grad[perm[i + perm[j]] % 12], p0); n += Math.max(0, 0.5 - dot2(p1, p1)) ** 4 * dot2(grad[perm[i + o[0] + perm[j + o[1]]] % 12], p1); n += Math.max(0, 0.5 - dot2(p2, p2)) ** 4 * dot2(grad[perm[i + 1 + perm[j + 1]] % 12], p2); return 70 * n; } hash(i) { i = 1103515245 * ((i >> 1) ^ i); const h32 = 1103515245 * (i ^ (i >> 3)); return h32 ^ (h32 >> 16); } } return new SimplexNoise(seed); } return finalize(turtle, walk); }34:T13ce,{ await visibility(); // Simplex Noise. Created by Reinder Nijhoff 2020 - @reindernijhoff // The MIT License // // https://turtletoy.net/turtle/6e4e06d42e // const turtle = new Turtle(); const frequency = 3; //min=.1, max=10, step=.01 const grid = 50; // min=10, max=100, step=1 const seed = 1; // min=1, max=100, step=1 const noise = new SimplexNoise(seed); function walk(i) { const x = ((i % grid) * 200) / grid - 100; const y = (((i / grid) | 0) * 200) / grid - 100; const r = 0.5 + 0.5 * noise.noise2D([(x * frequency) / 200, (y * frequency) / 200, 0.5]); turtle.jump(x + 100 / grid, y + (100 * (1 - r)) / grid); turtle.circle((r * 100) / grid); return i < grid * grid - 1; } return finalize(turtle, walk); //////////////////////////////////////////////////////////////// // Simplex Noise utility code. Created by Reinder Nijhoff 2020 // https://turtletoy.net/turtle/6e4e06d42e // Based on: http://webstaff.itn.liu.se/~stegu/simplexnoise/simplexnoise.pdf //////////////////////////////////////////////////////////////// function SimplexNoise(seed = 1) { const grad = [ [1, 1, 0], [-1, 1, 0], [1, -1, 0], [-1, -1, 0], [1, 0, 1], [-1, 0, 1], [1, 0, -1], [-1, 0, -1], [0, 1, 1], [0, -1, 1], [0, 1, -1], [0, -1, -1] ]; const perm = new Uint8Array(512); const F2 = (Math.sqrt(3) - 1) / 2, F3 = 1 / 3; const G2 = (3 - Math.sqrt(3)) / 6, G3 = 1 / 6; const dot2 = (a, b) => a[0] * b[0] + a[1] * b[1]; const sub2 = (a, b) => [a[0] - b[0], a[1] - b[1]]; const dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; const sub3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; class SimplexNoise { constructor(seed = 1) { for (let i = 0; i < 512; i++) { perm[i] = i & 255; } for (let i = 0; i < 255; i++) { const r = ((seed = this.hash(i + seed)) % (256 - i)) + i; const swp = perm[i]; perm[i + 256] = perm[i] = perm[r]; perm[r + 256] = perm[r] = swp; } } noise2D(p) { const s = dot2(p, [F2, F2]); const c = [Math.floor(p[0] + s), Math.floor(p[1] + s)]; const i = c[0] & 255, j = c[1] & 255; const t = dot2(c, [G2, G2]); const p0 = sub2(p, sub2(c, [t, t])); const o = p0[0] > p0[1] ? [1, 0] : [0, 1]; const p1 = sub2(sub2(p0, o), [-G2, -G2]); const p2 = sub2(p0, [1 - 2 * G2, 1 - 2 * G2]); let n = Math.max(0, 0.5 - dot2(p0, p0)) ** 4 * dot2(grad[perm[i + perm[j]] % 12], p0); n += Math.max(0, 0.5 - dot2(p1, p1)) ** 4 * dot2(grad[perm[i + o[0] + perm[j + o[1]]] % 12], p1); n += Math.max(0, 0.5 - dot2(p2, p2)) ** 4 * dot2(grad[perm[i + 1 + perm[j + 1]] % 12], p2); return 70 * n; } noise3D(p) { const s = dot3(p, [F3, F3, F3]); const c = [ Math.floor(p[0] + s), Math.floor(p[1] + s), Math.floor(p[2] + s) ]; const i = c[0] & 255, j = c[1] & 255, k = c[2] & 255; const t = dot3(c, [G3, G3, G3]); const p0 = sub3(p, sub3(c, [t, t, t])); const [o0, o1] = p0[0] >= p0[1] ? p0[1] >= p0[2] ? [ [1, 0, 0], [1, 1, 0] ] : p0[0] >= p0[2] ? [ [1, 0, 0], [1, 0, 1] ] : [ [0, 0, 1], [1, 0, 1] ] : p0[1] < p0[2] ? [ [0, 0, 1], [0, 1, 1] ] : p0[0] < p0[2] ? [ [0, 1, 0], [0, 1, 1] ] : [ [0, 1, 0], [1, 1, 0] ]; const p1 = sub3(sub3(p0, o0), [-G3, -G3, -G3]); const p2 = sub3(sub3(p0, o1), [-2 * G3, -2 * G3, -2 * G3]); const p3 = sub3(p0, [1 - 3 * G3, 1 - 3 * G3, 1 - 3 * G3]); let n = Math.max(0, 0.6 - dot3(p0, p0)) ** 4 * dot3(grad[perm[i + perm[j + perm[k]]] % 12], p0); n += Math.max(0, 0.6 - dot3(p1, p1)) ** 4 * dot3( grad[perm[i + o0[0] + perm[j + o0[1] + perm[k + o0[2]]]] % 12], p1 ); n += Math.max(0, 0.6 - dot3(p2, p2)) ** 4 * dot3( grad[perm[i + o1[0] + perm[j + o1[1] + perm[k + o1[2]]]] % 12], p2 ); n += Math.max(0, 0.6 - dot3(p3, p3)) ** 4 * dot3(grad[perm[i + 1 + perm[j + 1 + perm[k + 1]]] % 12], p3); return 32 * n; } hash(i) { i = 1103515245 * ((i >> 1) ^ i); const h32 = 1103515245 * (i ^ (i >> 3)); return h32 ^ (h32 >> 16); } } return new SimplexNoise(seed); } }35:T3248,{ await visibility(); // Voxel Ray Caster. Created by Reinder Nijhoff 2020 // @reindernijhoff // // https://turtletoy.net/turtle/d9ae1fb0bd // // A Utility class to collect and sort all (partially) visible faces of a voxel world. // In this turtle, the faces are drawn using the Polygon Clipping utility code from // https://turtletoy.net/turtle/a5befa1f8d. // // Note that the raycaster shoots rays at a fixed sample density, so small faces can be missed. // const turtle = new Turtle(); const addHatching = 1; // min=0, max=1, step=1 (No, Yes) const drawCubeEdges = 0; // min=0, max=1, step=1 (No, Yes) const ro = [43.2, 40, -41.1]; // camera origin const ta = [-4, -4.5, 2]; // camera target const voxelRayCaster = new VoxelRayCaster(ro, ta, 0.3); // The voxel caster will cast rays into a scene that is defined by a function that // returns true for all solid cells ([x,y,z]): function map(p) { const x = Math.abs(p[0]), y = Math.abs(p[1]), z = Math.abs(p[2]); return ( (x % 15 === 0 && (y % 15 === 0 || z % 15 === 0)) || (y % 15 === 0 && z % 15 === 0) || ((x % 15 < 2 || x % 15 > 13) && (y % 15 < 2 || y % 15 > 13) && (z % 15 < 2 || z % 15 > 13)) ); } function walk(i) { const tiles = 10; const x = i % tiles, y = (i / tiles) | 0; const lt = [(x * 200) / tiles - 100, (y * 200) / tiles - 100]; // Left top of tile const rb = [((x + 1) * 200) / tiles - 100, ((y + 1) * 200) / tiles - 100]; // Right bottom of tile const faces = voxelRayCaster.collectFaces(map, lt, rb, 2000, 0.3); const polys = new Polygons(); // Create a polygon for this tile to clip all faces const viewPort = polys.create(); viewPort.addPoints(lt, [lt[0], rb[1]], rb, [rb[0], lt[1]]); faces.forEach((face) => { const p = polys.create(); p.addPoints(...face.points); if (drawCubeEdges) { p.addOutline(); } else { face.edges.forEach( (e, i) => e && p.addSegments(p.cp[i], p.cp[(i + 1) % 4]) ); } if (addHatching && Math.abs(face.normal[2]) > 0.5) { p.addHatching(-Math.PI / 3, 0.5); } // Clip face against viewport of this tile p.boolean(viewPort, false); // Draw face polys.draw(turtle, p); }); return i < tiles * tiles - 1; } //////////////////////////////////////////////////////////////// // Voxel Ray Caster utility code. Created by Reinder Nijhoff 2020 // https://turtletoy.net/turtle/d9ae1fb0bd // Based on: https://turtletoy.net/turtle/d9ae1fb0bd //////////////////////////////////////////////////////////////// function VoxelRayCaster(ro, ta, cr = 0, w = 1.5) { const faceId = (p, n) => p[0].toFixed(0) + "_" + p[1].toFixed(0) + "_" + p[2].toFixed(0) + n[0].toFixed(0) + "_" + n[1].toFixed(0) + "_" + n[2].toFixed(0); const neg = (a) => [-a[0], -a[1], -a[2]]; const scale = (a, b) => [a[0] * b, a[1] * b, a[2] * b]; const len = (a) => Math.sqrt(a[0] ** 2 + a[1] ** 2 + a[2] ** 2); const norm = (a) => scale(a, 1 / len(a)); const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; const cross = (a, b) => [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0] ]; const trans = (a, b) => a.map((e, c) => b[c] * a[0] + b[c + 3] * a[1] + b[c + 6] * a[2]); const transInv = (a, b) => a.map( (e, c) => b[c * 3 + 0] * a[0] + b[c * 3 + 1] * a[1] + b[c * 3 + 2] * a[2] ); class VoxelFace { constructor(p, n, dist, map) { this.id = faceId(p, n); this.pos = p; this.normal = n; this.b = [n[1], n[2], n[0]]; this.t = cross(this.normal, this.b); this.dist = dist; this.center = add(this.pos, [0.5, 0.5, 0.5]); } projectVertex(p, ca) { const cp = transInv(p, ca), s = (w * 100) / cp[2]; return [cp[0] * s, cp[1] * -s]; } projectVertices(ro, ca) { const nh = scale(this.normal, 0.5), t = scale(this.t, 0.5), b = scale(this.b, 0.5); this.points = [ add(neg(t), neg(b)), add(t, neg(b)), add(t, b), add(neg(t), b) ].map((c) => this.projectVertex(sub(add(add(c, nh), this.center), ro), ca) ); } calculateEdges(map) { const t = this.t, b = this.b, p = this.pos, n = this.normal; this.edges = [neg(b), t, b, neg(t)].map( (o) => !map(add(p, o)) || map(add(add(p, o), n)) ); } } class VoxelRayCaster { constructor(ro, ta, cr = 0, w = 1.5) { this.ro = ro; this.ta = ta; this.w = w; this.ca = this.setupCamera(ro, ta, cr); } setupCamera(ro, ta, cr) { const cw = norm(sub(ta, ro)); const cp = [Math.sin(cr), Math.cos(cr), 0]; const cu = norm(cross(cw, cp)); const cv = cross(cu, cw); return [...cu, ...cv, ...cw]; } castRay(ro, rd, map, maxSteps) { const ps = ro.map((e) => Math.floor(e)); const ri = rd.map((e) => (Math.abs(e) > 1e-16 ? 1 / e : 1e32)); const rs = ri.map((e) => Math.sign(e)); const ra = ri.map((e) => Math.abs(e)); const ds = ps.map((p, i) => (p - ro[i] + 0.5 + 0.5 * rs[i]) * ri[i]); for (let j = 0; j < maxSteps; j++) { const i = ds[0] <= ds[1] && ds[0] <= ds[2] ? 0 : ds[1] <= ds[0] && ds[1] <= ds[2] ? 1 : 2; ds[i] += ra[i]; ps[i] += rs[i]; if (map(ps)) { const n = [0, 0, 0]; n[i] = -rs[i]; return [ps, n]; } } return false; } collectFaces( map, tl = [-100, -100], br = [100, 100], maxSteps = 200, res = 0.25 ) { const faces = []; for (let x = tl[0]; x <= br[0]; x += res) { for (let y = tl[1]; y <= br[1]; y += res) { const rd = trans(norm([x / 100, -y / 100, this.w]), this.ca); const hit = this.castRay(ro, rd, map, maxSteps); if (hit) { const id = faceId(hit[0], hit[1]); if (!faces.find((a) => a.id === id)) { const face = new VoxelFace( hit[0], hit[1], len(sub(hit[0], this.ro)) ); face.projectVertices(this.ro, this.ca); face.calculateEdges(map); faces.push(face); } } } } return faces.sort((a, b) => a.dist - b.dist); } } return new VoxelRayCaster(ro, ta, cr, w); } //////////////////////////////////////////////////////////////// // Polygon Clipping utility code - Created by Reinder Nijhoff 2019 // https://turtletoy.net/turtle/a5befa1f8d //////////////////////////////////////////////////////////////// function Polygons() { let polygonList = []; const Polygon = class { constructor() { this.cp = []; // clip path: array of [x,y] pairs this.dp = []; // 2d lines [x0,y0],[x1,y1] to draw this.aabb = []; // AABB bounding box } addPoints(...points) { // add point to clip path and update bounding box let xmin = 1e5, xmax = -1e5, ymin = 1e5, ymax = -1e5; (this.cp = [...this.cp, ...points]).forEach((p) => { (xmin = Math.min(xmin, p[0])), (xmax = Math.max(xmax, p[0])); (ymin = Math.min(ymin, p[1])), (ymax = Math.max(ymax, p[1])); }); this.aabb = [ (xmin + xmax) / 2, (ymin + ymax) / 2, (xmax - xmin) / 2, (ymax - ymin) / 2 ]; } addSegments(...points) { // add segments (each a pair of points) points.forEach((p) => this.dp.push(p)); } addOutline() { for (let i = 0, l = this.cp.length; i < l; i++) { this.dp.push(this.cp[i], this.cp[(i + 1) % l]); } } draw(t) { for (let i = 0, l = this.dp.length; i < l; i += 2) { t.jump(this.dp[i]), t.goto(this.dp[i + 1]); } } addHatching(a, d) { const tp = new Polygon(); tp.cp.push([-1e5, -1e5], [1e5, -1e5], [1e5, 1e5], [-1e5, 1e5]); const dx = Math.sin(a) * d, dy = Math.cos(a) * d; const cx = Math.sin(a) * 200, cy = Math.cos(a) * 200; for (let i = 0.5; i < 150 / d; i++) { tp.dp.push([dx * i + cy, dy * i - cx], [dx * i - cy, dy * i + cx]); tp.dp.push( [-dx * i + cy, -dy * i - cx], [-dx * i - cy, -dy * i + cx] ); } tp.boolean(this, false); this.dp = [...this.dp, ...tp.dp]; } inside(p) { let int = 0; // find number of i ntersection points from p to far away for (let i = 0, l = this.cp.length; i < l; i++) { if ( this.segment_intersect( p, [0.13, -1000], this.cp[i], this.cp[(i + 1) % l] ) ) { int++; } } return int & 1; // if even your outside } boolean(p, diff = true) { // bouding box optimization by ge1doot. if ( diff && Math.abs(this.aabb[0] - p.aabb[0]) - (p.aabb[2] + this.aabb[2]) >= 0 && Math.abs(this.aabb[1] - p.aabb[1]) - (p.aabb[3] + this.aabb[3]) >= 0 ) return this.dp.length > 0; // polygon diff algorithm (narrow phase) const ndp = []; for (let i = 0, l = this.dp.length; i < l; i += 2) { const ls0 = this.dp[i]; const ls1 = this.dp[i + 1]; // find all intersections with clip path const int = []; for (let j = 0, cl = p.cp.length; j < cl; j++) { const pint = this.segment_intersect( ls0, ls1, p.cp[j], p.cp[(j + 1) % cl] ); if (pint !== false) { int.push(pint); } } if (int.length === 0) { // 0 intersections, inside or outside? if (diff === !p.inside(ls0)) { ndp.push(ls0, ls1); } } else { int.push(ls0, ls1); // order intersection points on line ls.p1 to ls.p2 const cmpx = ls1[0] - ls0[0]; const cmpy = ls1[1] - ls0[1]; int.sort( (a, b) => (a[0] - ls0[0]) * cmpx + (a[1] - ls0[1]) * cmpy - (b[0] - ls0[0]) * cmpx - (b[1] - ls0[1]) * cmpy ); for (let j = 0; j < int.length - 1; j++) { if ( (int[j][0] - int[j + 1][0]) ** 2 + (int[j][1] - int[j + 1][1]) ** 2 >= 0.001 ) { if ( diff === !p.inside([ (int[j][0] + int[j + 1][0]) / 2, (int[j][1] + int[j + 1][1]) / 2 ]) ) { ndp.push(int[j], int[j + 1]); } } } } } return (this.dp = ndp).length > 0; } //port of http://paulbourke.net/geometry/pointlineplane/Helpers.cs segment_intersect(l1p1, l1p2, l2p1, l2p2) { const d = (l2p2[1] - l2p1[1]) * (l1p2[0] - l1p1[0]) - (l2p2[0] - l2p1[0]) * (l1p2[1] - l1p1[1]); if (d === 0) return false; const n_a = (l2p2[0] - l2p1[0]) * (l1p1[1] - l2p1[1]) - (l2p2[1] - l2p1[1]) * (l1p1[0] - l2p1[0]); const n_b = (l1p2[0] - l1p1[0]) * (l1p1[1] - l2p1[1]) - (l1p2[1] - l1p1[1]) * (l1p1[0] - l2p1[0]); const ua = n_a / d; const ub = n_b / d; if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) { return [ l1p1[0] + ua * (l1p2[0] - l1p1[0]), l1p1[1] + ua * (l1p2[1] - l1p1[1]) ]; } return false; } }; return { list: () => polygonList, create: () => new Polygon(), draw: (turtle, p, addToVisList = true) => { for ( let j = 0; j < polygonList.length && p.boolean(polygonList[j]); j++ ); p.draw(turtle); if (addToVisList) polygonList.push(p); } }; } return finalize(turtle, walk); }36:T33d6,{ await visibility(); const turtle = new Turtle(); const polygons = new Polygons(); const text = new Text(); turtle.radians(); function walk(i) { let scale = 100; let x = Math.PI / 6; let sin_x = Math.sin(x); let cos_x = Math.cos(x); let sin_2x = Math.sin(2 * x); let cos_2x = Math.cos(2 * x); let sin_squared_x = sin_x * sin_x; let cos_squared_x = cos_x * cos_x; let sin_x_cos_x = sin_x * cos_x; let half_width = (cos_squared_x * scale) / 2; let half_height = (sin_2x * scale) / 2; let hatchOne = { angle: Math.PI / -4, distance: 1.3 }; let hatchTwo = { angle: Math.PI / 4, distance: 1.5 }; //topleft drawPoints( [ [0, 0], [cos_2x, 0], [0, sin_2x] ], hatchOne, half_width, half_height, scale ); //topright drawPoints( [ [cos_2x, 0], [cos_squared_x, 0], [cos_squared_x, sin_x_cos_x] ], hatchOne, half_width, half_height, scale ); //bottomright drawPoints( [ [cos_squared_x, sin_x_cos_x], [cos_squared_x, sin_2x], [cos_2x, sin_2x], [cos_2x, (sin_2x * 2) / 3] ], hatchOne, half_width, half_height, scale ); //bottomleft drawPoints( [ [0, sin_2x], [cos_2x, (sin_2x * 2) / 3], [cos_2x, sin_2x] ], hatchTwo, half_width, half_height, scale ); //midleft drawPoints( [ [0, sin_2x], [cos_2x, (sin_2x * 2) / 3], [cos_2x, 0] ], hatchTwo, half_width, half_height, scale ); //midright drawPoints( [ [cos_2x, (sin_2x * 2) / 3], [cos_2x, 0], [cos_squared_x, sin_x_cos_x] ], hatchOne, half_width, half_height, scale ); turtle.jump(-half_width + 7, half_height); turtle.seth(Math.PI * 1.5); turtle.circle(-7, x + x); turtle.seth(0); turtle.jump(half_width, -7); turtle.circle(7, -x); turtle.seth(0); turtle.jump(cos_2x * scale - half_width + 5, half_height); turtle.seth(Math.PI * 1.5); turtle.forward(5); turtle.left(Math.PI / 2); turtle.forward(5); turtle.jump(half_width, half_height - 5); turtle.forward(5); turtle.left(Math.PI / 2); turtle.forward(5); turtle.jump(half_width - 5, -half_height); turtle.forward(5); turtle.left(Math.PI / 2); turtle.forward(5); turtle.jump(cos_squared_x * scale - half_width, 0); turtle.seth(Math.PI * 1.5 - x); turtle.up(); turtle.forward(5); turtle.down(); turtle.left(Math.PI / 2); turtle.forward(5); turtle.left(Math.PI / 2); turtle.forward(5); console.log("text"); write(-21, -half_height - 4, "cos(2x)", 0.15, 0); //write(-21, -half_height - 4, "cos(2x)", 0.15, 0); write(18, -half_height - 4, "sin (x)", 0.15, 0); write(25, -half_height - 5.5, "2", 0.075, 0); write(-half_width - 4, 8, "sin(2x)", 0.15, Math.PI * 1.5); write(half_width + 4, -7, "sin(x)cos(x)", 0.15, Math.PI * 1.5); write( half_width + 4, -7 + half_height, "sin(x)cos(x)", 0.15, Math.PI * 1.5 ); write(-3, half_height + 4, "cos (x)", 0.15, 0); write(5.5, half_height + 2.5, "2", 0.075, 0); write(-3, half_height - 24, "cos(x)", 0.15, -x); write(21, -half_height + 23, "sin(x)", 0.15, 2 * x); write(-17, 0, "1", 0.15, -2 * x); write(-half_width + 6, half_height - 7.5, "x", 0.15, 0); write(-half_width + 8, half_height - 3, "x", 0.15, 0); write(half_width - 3, -10, "x", 0.15, 0); write(-90, 70, "sin(2x) = 2sin(x)cos(x)", 0.15, 0); write(-90, 78, "cos(2x) = cos (x) - sin (x)", 0.15, 0); write(-55, 76.5, "2", 0.075, 0); write(-30.5, 76.5, "2", 0.075, 0); write(-90, 86, "1 = cos (x) + sin (x)", 0.15, 0); write(-69.5, 84.5, "2", 0.075, 0); write(-45, 84.5, "2", 0.075, 0); write(-80, -85, "Trigonometric identities", 0.44, 0); write(-40, -72, "-a visual proof- ", 0.3, 0); } function write(x, y, txt, scale, heading) { let h = turtle.h(); turtle.seth(heading); turtle.jump(x, y); text.print(turtle, txt, scale); turtle.seth(h); } function drawPoints(points, hatch, translateX, translateY, scale) { points = points.map((p) => [ p[0] * scale - translateX, p[1] * scale - translateY ]); let p = polygons.create(); p.addPoints(...points); p.addOutline(); p.addHatching(hatch.angle, hatch.distance); polygons.draw(turtle, p, true); } //////////////////////////////////////////////////////////////// // Polygon Clipping utility code - Created by Reinder Nijhoff 2019 // https://turtletoy.net/turtle/a5befa1f8d //////////////////////////////////////////////////////////////// function Polygons() { let t = []; const s = class { constructor() { (this.cp = []), (this.dp = []), (this.aabb = []); } addPoints(...t) { let s = 1e5, e = -1e5, h = 1e5, i = -1e5; (this.cp = [...this.cp, ...t]).forEach((t) => { (s = Math.min(s, t[0])), (e = Math.max(e, t[0])), (h = Math.min(h, t[1])), (i = Math.max(i, t[1])); }), (this.aabb = [(s + e) / 2, (h + i) / 2, (e - s) / 2, (i - h) / 2]); } addSegments(...t) { t.forEach((t) => this.dp.push(t)); } addOutline() { for (let t = 0, s = this.cp.length; t < s; t++) this.dp.push(this.cp[t], this.cp[(t + 1) % s]); } draw(t) { for (let s = 0, e = this.dp.length; s < e; s += 2) t.jump(this.dp[s]), t.goto(this.dp[s + 1]); } addHatching(t, e) { const h = new s(); h.cp.push([-1e5, -1e5], [1e5, -1e5], [1e5, 1e5], [-1e5, 1e5]); const i = Math.sin(t) * e, n = Math.cos(t) * e, a = 200 * Math.sin(t), p = 200 * Math.cos(t); for (let t = 0.5; t < 150 / e; t++) h.dp.push([i * t + p, n * t - a], [i * t - p, n * t + a]), h.dp.push([-i * t + p, -n * t - a], [-i * t - p, -n * t + a]); h.boolean(this, !1), (this.dp = [...this.dp, ...h.dp]); } inside(t) { let s = 0; for (let e = 0, h = this.cp.length; e < h; e++) this.segment_intersect( t, [0.13, -1e3], this.cp[e], this.cp[(e + 1) % h] ) && s++; return 1 & s; } boolean(t, s = !0) { if ( s && Math.abs(this.aabb[0] - t.aabb[0]) - (t.aabb[2] + this.aabb[2]) >= 0 && Math.abs(this.aabb[1] - t.aabb[1]) - (t.aabb[3] + this.aabb[3]) >= 0 ) return this.dp.length > 0; const e = []; for (let h = 0, i = this.dp.length; h < i; h += 2) { const i = this.dp[h], n = this.dp[h + 1], a = []; for (let s = 0, e = t.cp.length; s < e; s++) { const h = this.segment_intersect(i, n, t.cp[s], t.cp[(s + 1) % e]); !1 !== h && a.push(h); } if (0 === a.length) s === !t.inside(i) && e.push(i, n); else { a.push(i, n); const h = n[0] - i[0], p = n[1] - i[1]; a.sort( (t, s) => (t[0] - i[0]) * h + (t[1] - i[1]) * p - (s[0] - i[0]) * h - (s[1] - i[1]) * p ); for (let h = 0; h < a.length - 1; h++) (a[h][0] - a[h + 1][0]) ** 2 + (a[h][1] - a[h + 1][1]) ** 2 >= 0.001 && s === !t.inside([ (a[h][0] + a[h + 1][0]) / 2, (a[h][1] + a[h + 1][1]) / 2 ]) && e.push(a[h], a[h + 1]); } } return (this.dp = e).length > 0; } segment_intersect(t, s, e, h) { const i = (h[1] - e[1]) * (s[0] - t[0]) - (h[0] - e[0]) * (s[1] - t[1]); if (0 === i) return !1; const n = ((h[0] - e[0]) * (t[1] - e[1]) - (h[1] - e[1]) * (t[0] - e[0])) / i, a = ((s[0] - t[0]) * (t[1] - e[1]) - (s[1] - t[1]) * (t[0] - e[0])) / i; return ( n >= 0 && n <= 1 && a >= 0 && a <= 1 && [t[0] + n * (s[0] - t[0]), t[1] + n * (s[1] - t[1])] ); } }; return { list: () => t, create: () => new s(), draw: (s, e, h = !0) => { for (let s = 0; s < t.length && e.boolean(t[s]); s++); e.draw(s), h && t.push(e); } }; } //////////////////////////////////////////////////////////////// // Text utility code. Created by Reinder Nijhoff 2019 // https://turtletoy.net/turtle/1713ddbe99 //////////////////////////////////////////////////////////////// function Text() { const s = "br>eoj^jlbrf^fe`ukZdz`thZhw^vs^as]wtgtfsereqfphnmlpjrhsdsbraq`o`makbjifjekckaj_h^f_eaecffhimporqssstrtq>eoj`i_j^k_kajcid>cqnZl\\j_hcghglhqjulxnz>cqfZh\\j_lcmhmllqjuhxfz>brjdjp]wjajsfnkojpiojnkokqis>]wajsj>fnjniojpkojn>_usZaz>`ti^f_dbcgcjdofrisksnrpoqjqgpbn_k^i^>`tfbhak^ks>`tdcdbe`f_h^l^n_o`pbpdofmicsqs>`te^p^jfmfogphqkqmppnrkshserdqco>`tm^clrl`to^e^dgefhekenfphqkqmppnrkshserdqco>`tpao_l^j^g_ebdgdlepgrjsksnrppqmqlpingkfjfggeidl>`tq^gs`th^e_dadceegfkgnhpjqlqopqorlshserdqcocldjfhigmfoepcpao_l^h^>`tpeohmjjkikfjdhcecddaf_i^j^m_oapepjoomrjshserdp>fnjgihjikhjgfnjgihjikhjg^vrabjrs>]wagsg^vbarjbs>asdcdbe`f_h^l^n_o`pbpdofngjijl]xofndlcicgdfeehekfmhnknmmnkasj^bs_tc^cs`urcqao_m^i^g_eadccfckdnepgrismsorqprn>_tc^cs`sd^ds`rd^ds`urcqao_m^i^g_eadccfckdnepgrismsorqprnrk_uc^csfnj^js>brn^nnmqlrjshsfreqdndl>_tc^cs`qd^ds^vb^bs_uc^cs_uh^f_daccbfbkcndpfrhslsnrppqnrkrfqcpan_l^h^>_tc^cs_uh^f_daccbfbkcndpfrhslsnrppqnrkrfqcpan_l^h^_tc^cs`tqao_l^h^e_caccdeefggmiojpkqmqporlshsercp>brj^js_uc^cmdpfrisksnrppqmq^>asb^js^v`^es`tc^qsasb^jhjs`tq^cscqgZgzcqc^qv>cqlZlzbrj\\bjasazsz>fnkcieigjhkgjfig>atpeps`sd^dsasphnfleiegfehdkdmepgrislsnrpp>atp^psasdkpkpiognfleiegfehdkdmepgrislsnrpp>eqo^m^k_jbjsatpepuoxnylzizgyate^esfni^j_k^j]i^eoj^k_l^k]j^are^esfnj^js>[y_e_s<_ibfdegeifjijsateeesatiegfehdkdmepgrislsnrppqmqkphnfleie>`sdedzatpepzcpgegsbsphofleieffehfjhkmlompopporlsisfrep>eqj^jokrmsosateeeofrhsksmrpobrdejs_ubefsbseepsbrdejsbspeescqlZj[i\\h^h`ibjckekgiifnjZjz>cqhZj[k\\l^l`kbjcieigki^vamakbhdgfghhlknlplrksibrb^bscsc^d^dsese^f^fsgsg^h^hsisi^j^jsksk^l^lsmsm^n^nsoso^p^psqsq^r^rs" .split(">") .map((s) => [ s.charCodeAt(0) - 106, s.charCodeAt(1) - 106, s .substr(2) .split("<") .map((s) => { const e = []; for (let p = 0; p < s.length; p += 2) e.push( s .substr(p, 2) .split("") .map((s) => s.charCodeAt(0) - 106) ); return e; }) ]); return new (class { print(e, p, j = 1, h = 0, r = 1) { e.radians(); let f = [e.x(), e.y()], o = e.h(), i = f; p.split("").map((p) => { const c = p.charCodeAt(0) - 32; if (c < 0) f = i = this.rotAdd([0, 48 * j], i, o); else if (c > 96) f = this.rotAdd([16 * j, 0], i, o); else { const p = s[c], i = p[0] * j, d = p[1] * j; p[2].map((s) => { e.up(), s.map((s) => { e.goto( this.rotAdd([(s[0] - s[1] * h) * j - i, s[1] * j], f, o) ), e.down(); }); }), (f = this.rotAdd([(d - i) * r, 0], f, o)); } }); } rotAdd(s, e, p) { return [ Math.cos(p) * s[0] - Math.sin(p) * s[1] + e[0], Math.cos(p) * s[1] + Math.sin(p) * s[0] + e[1] ]; } })(); } return finalize(turtle, walk); }37:T30b9,{ await visibility(); // Cubic cityscape #1. Created by Reinder Nijhoff 2018 // @reindernijhoff // // https://turtletoy.net/turtle/789cce3829 // // Try different settings here: const useOrthoGraphicPerspective = Math.random() > 0.5; const towerness = 0.25; // [0, 1) const topDownView = Math.random() > 0.5; const addHatching = Math.random() > 0.5; // A lot of ugly code: Canvas.setpenopacity(1); const turtle = new Turtle(); let viewProjectionMatrix; let polygonList = []; const lineSegmentsDrawn = []; // keep track of all line segments. Don't draw duplicates const width = 30; const depth = 70; const camPos = [12, topDownView ? 13.5 : -10.5, -2.3]; const camLookat = [19, topDownView ? 9.5 : -6, -10]; function walk(i) { if (i == 0) { setupCamera(); } for (let j = 0; j < width; j++) { const x = ((width - j + (i + 1) / 2) | 0) - (width - 20); const z = -((j + i / 2) | 0) + (width - 20); const y = x - z - 40; // 2 drawHome(turtle, [x, y, z], true); } return i < depth; } function createWall() { return [createSquare([0, 0, 0], [1, 1, 0])]; // wall } function createWallDecoration(floorLevel) { const p = []; for (let i = 0; i < 2; i++) { const x = 0.2 + i * 0.4; if (Math.random() > 0.5) { p.push(createSquare([x, 0.3, 0], [x + 0.2, 0.7, 0])); // window } else if (floorLevel && Math.random() > 0.7) { p.push(createSquare([x, 0, 0], [x + 0.2, 0.7, 0])); // door } } return p; } function createRoof() { const p = []; let flat = false; if (Math.random() > 0.5) { p.push(createSquare([0, 1, 0], [1, 1, -1])); // roof flat = true; } else { p.push(createSquare([0, 1, 0], [1, 1.5, -0.5])); // roof p.push(createSquare([0, 1, -1], [1, 1.5, -0.5]).reverse()); // roof p.push([ [0, 1, -1], [0, 1.5, -0.5], [0, 1, 0] ]); p.push([ [1, 1, 0], [1, 1.5, -0.5], [1, 1, -1] ]); if (Math.random() > 0.5) { return { flatRoof: false, flipped: true, polygons: flipxz(p) }; } } return { flatRoof: flat, flipped: false, polygons: p }; } function drawHome(turtle, loc, floorLevel) { let p = []; const occluders = []; let roof = false; p = p.concat(center(createWall(), loc)); p = p.concat(center(flipxz(createWall()), loc)); p = p.concat(center(createWallDecoration(floorLevel), loc)); p = p.concat(center(flipxz(createWallDecoration(floorLevel)), loc)); if (Math.random() > 1 - towerness) { // extra level drawHome(turtle, add3(loc, [0, 1, 0]), false); } else { roof = createRoof(); p = p.concat(center(roof.polygons, loc)); } for (let i = 0; i < p.length; i++) { const polygon = new Polygon(); const vl = p[i]; const vd = useOrthoGraphicPerspective ? sub3(camLookat, camPos) : sub3(scale3(add3(vl[0], vl[2]), 0.5), camPos); let normal = cross3(sub3(vl[1], vl[0]), sub3(vl[2], vl[0])); if (dot3(normal, vd) < 0) { continue; } for (let j = 0; j < vl.length; j++) { const v = transform4(vl[j], viewProjectionMatrix); if (useOrthoGraphicPerspective) { polygon.cp.push([v[0] * 2.5, -(v[1] * 2.5)]); } else { polygon.cp.push([(v[0] / v[3]) * 50, -((v[1] / v[3]) * 50)]); } } let vis = false; for (let j = 0; j < polygon.cp.length; j++) { if ( Math.abs(polygon.cp[j][0]) < 100 && Math.abs(polygon.cp[j][1]) < 100 ) { vis = true; } } if (!vis) { continue; } if (i < 2) { // first two are walls polygon.dp.push(new LineSegment(polygon.cp[0], polygon.cp[1])); if (roof && !topDownView) { if ( roof.flatRoof || (roof.flipped && i == 1) || (!roof.flipped && i == 0) ) { polygon.dp.push(new LineSegment(polygon.cp[1], polygon.cp[2])); } } polygon.dp.push(new LineSegment(polygon.cp[2], polygon.cp[3])); } else if (polygon.cp.length === 3) { // roof polygon.dp.push(new LineSegment(polygon.cp[0], polygon.cp[1])); polygon.dp.push(new LineSegment(polygon.cp[1], polygon.cp[2])); } else { polygon.addOutline(); } if (addHatching) { normal = normalize3(normal); if (normal[2] < 0) { polygon.addHatching(0.85, 0.75); } } const occluder = drawPolygon(turtle, polygon); if (i < 2) { // first two are walls occluders.push(polygon); } else if (occluder) { occluders.push(occluder); } } polygonList = polygonList.concat(occluders); } function drawPolygon(turtle, p) { for (let j = 0; j < polygonList.length; j++) { if (!p.boolean(polygonList[j])) { return; } } p.draw(turtle); return p; } function setupCamera() { const viewMatrix = lookAt4m(camPos, camLookat, [0, 1, 0]); const projectionMatrix = perspective4m(0.4, 1); viewProjectionMatrix = multiply4m(projectionMatrix, viewMatrix); } // helper functions function flipxz(p) { for (let i = 0; i < p.length; i++) { const vl = p[i]; for (let j = 0; j < vl.length; j++) { p[i][j] = [-vl[j][2], vl[j][1], vl[j][0] - 1]; } } return p; } function center(p, loc) { const ret = []; for (let i = 0; i < p.length; i++) { const vl = p[i], v = []; for (let j = 0; j < vl.length; j++) { v.push(add3(vl[j], loc)); } ret.push(v); } return ret; } function createSquare(lb, rt) { return [lb, [lb[0], rt[1], rt[2]], rt, [rt[0], lb[1], lb[2]]]; } // polygon functions class LineSegment { constructor(p1, p2) { this.p1 = p1; this.p2 = p2; } unique() { for (let i = 0, l = lineSegmentsDrawn.length; i < l; i++) { const ls = lineSegmentsDrawn[i]; if ( (equal2(this.p1, ls.p1) && equal2(this.p2, ls.p2)) || (equal2(this.p1, ls.p2) && equal2(this.p2, ls.p1)) ) { return false; } } lineSegmentsDrawn.push(this); return true; } } class Polygon { constructor() { this.cp = []; // clip path: array of [x,y] pairs this.dp = []; // 2d line to draw: array of linesegments } addOutline(s = 0) { for (let i = s, l = this.cp.length; i < l; i++) { this.dp.push(new LineSegment(this.cp[i], this.cp[(i + 1) % l])); } } createPoly(x, y, c, r, a) { this.cp = []; for (let i = 0; i < c; i++) { this.cp.push([ x + Math.sin((i * Math.PI * 2) / c + a) * r, y + Math.cos((i * Math.PI * 2) / c + a) * r ]); } } addHatching(a, d) { // todo, create a tight bounding polygon, for now fill screen const tp = new Polygon(); tp.createPoly(0, 0, 4, 200, Math.PI * 0.5); const dx = Math.sin(a) * d, dy = Math.cos(a) * d; const cx = Math.sin(a) * 200, cy = Math.cos(a) * 200; for (let i = 0.5; i < 150 / d; i++) { tp.dp.push( new LineSegment( [dx * i + cy, dy * i - cx], [dx * i - cy, dy * i + cx] ) ); tp.dp.push( new LineSegment( [-dx * i + cy, -dy * i - cx], [-dx * i - cy, -dy * i + cx] ) ); } tp.boolean(this, false); this.dp = this.dp.concat(tp.dp); } draw(t) { if (this.dp.length == 0) { return; } for (let i = 0, l = this.dp.length; i < l; i++) { const d = this.dp[i]; if (d.unique()) { if (!equal2(d.p1, t.pos())) { t.penup(); t.goto(d.p1); t.pendown(); } t.goto(d.p2); } } } inside(p) { // find number of intersections from p to far away - if even you're outside const p1 = [0, -1000]; let int = 0; for (let i = 0, l = this.cp.length; i < l; i++) { if (segment_intersect2(p, p1, this.cp[i], this.cp[(i + 1) % l])) { int++; } } return int & 1; } boolean(p, diff = true) { // very naive polygon diff algorithm - made this up myself const ndp = []; for (let i = 0, l = this.dp.length; i < l; i++) { const ls = this.dp[i]; // find all intersections with clip path const int = []; for (let j = 0, cl = p.cp.length; j < cl; j++) { const pint = segment_intersect2( ls.p1, ls.p2, p.cp[j], p.cp[(j + 1) % cl] ); if (pint) { int.push(pint); } } if (int.length == 0) { // 0 intersections, inside or outside? if (diff != p.inside(ls.p1)) { ndp.push(ls); } } else { int.push(ls.p1); int.push(ls.p2); // order intersection points on line ls.p1 to ls.p2 const cmp = sub2(ls.p2, ls.p1); int.sort( (a, b) => dot2(sub2(a, ls.p1), cmp) - dot2(sub2(b, ls.p1), cmp) ); for (let j = 0; j < int.length - 1; j++) { if ( !equal2(int[j], int[j + 1]) && diff != p.inside(scale2(add2(int[j], int[j + 1]), 0.5)) ) { ndp.push(new LineSegment(int[j], int[j + 1])); } } } } this.dp = ndp; return this.dp.length > 0; } } // vec2 functions const equal2 = (a, b) => 0.001 > dist_sqr2(a, b); const scale2 = (a, b) => [a[0] * b, a[1] * b]; const add2 = (a, b) => [a[0] + b[0], a[1] + b[1]]; const sub2 = (a, b) => [a[0] - b[0], a[1] - b[1]]; const dot2 = (a, b) => a[0] * b[0] + a[1] * b[1]; const dist_sqr2 = (a, b) => (a[0] - b[0]) * (a[0] - b[0]) + (a[1] - b[1]) * (a[1] - b[1]); const segment_intersect2 = (a, b, d, c) => { const e = (c[1] - d[1]) * (b[0] - a[0]) - (c[0] - d[0]) * (b[1] - a[1]); if (0 == e) return false; c = ((c[0] - d[0]) * (a[1] - d[1]) - (c[1] - d[1]) * (a[0] - d[0])) / e; d = ((b[0] - a[0]) * (a[1] - d[1]) - (b[1] - a[1]) * (a[0] - d[0])) / e; return 0 <= c && 1 >= c && 0 <= d && 1 >= d ? [a[0] + c * (b[0] - a[0]), a[1] + c * (b[1] - a[1])] : false; }; // vec3 functions const scale3 = (a, b) => [a[0] * b, a[1] * b, a[2] * b]; const len3 = (a) => Math.sqrt(dot3(a, a)); const normalize3 = (a) => scale3(a, 1 / len3(a)); const add3 = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]]; const sub3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]]; const dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; const cross3 = (a, b) => [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0] ]; // vec4 functions const transform4 = (a, b) => { const d = new Float32Array(4); for (let c = 0; 4 > c; c++) d[c] = b[c] * a[0] + b[c + 4] * a[1] + b[c + 8] * a[2] + b[c + 12]; return d; }; // mat4 functions const lookAt4m = (a, b, d) => { // pos, lookAt, up const c = new Float32Array(16); b = normalize3(sub3(a, b)); d = normalize3(cross3(d, b)); const e = normalize3(cross3(b, d)); c[0] = d[0]; c[1] = e[0]; c[2] = b[0]; c[3] = 0; c[4] = d[1]; c[5] = e[1]; c[6] = b[1]; c[7] = 0; c[8] = d[2]; c[9] = e[2]; c[10] = b[2]; c[11] = 0; c[12] = -(d[0] * a[0] + d[1] * a[1] + d[2] * a[2]); c[13] = -(e[0] * a[0] + e[1] * a[1] + e[2] * a[2]); c[14] = -(b[0] * a[0] + b[1] * a[1] + b[2] * a[2]); c[15] = 1; return c; }; const multiply4m = (a, b) => { const d = new Float32Array(16); for (let c = 0; 16 > c; c += 4) for (let e = 0; 4 > e; e++) d[c + e] = b[c + 0] * a[0 + e] + b[c + 1] * a[4 + e] + b[c + 2] * a[8 + e] + b[c + 3] * a[12 + e]; return d; }; const perspective4m = (a, b) => { // fovy, aspect const c = new Float32Array(16).fill(0, 0); c[5] = 1 / Math.tan(a / 2); c[0] = c[5] / b; c[10] = c[11] = -1; return c; }; return finalize(turtle, walk); }38:T4cd0,{ await visibility(); // You can find the Turtle API reference here: https://turtletoy.net/syntax Canvas.setpenopacity(1); const scale = 3; //min=.5, max=3.6, step=0.1 const showHelperLines = 1; //min=0, max=1, step=1 const a = 1 * scale; const b = 3.5 * scale; const c = 4 * scale; const d = 6 * scale; const e = 11 * scale; const f = 15 * scale; const g = 21 * scale; const h = 30 * scale; // Global code will be evaluated once. const text = new Text(); const turtle = new Turtle(); turtle.radians(); // The walk function will be called until it returns false. function walk(i) { let outerAngles = getIntersectionAnglesForCircles(f, e - a + b, g / 2 - a); let halfA = outerAngles[0] / 2; let halfAOuter = outerAngles[1] / 2; //center circle outside turtle.jump(0, e - a + b); turtle.seth(Math.PI); turtle.penup(); turtle.circle(e - a + b, Math.PI - halfA); turtle.pendown(); for (let j = 0; j < 3; j++) { turtle.circle(e - a + b, 2 * halfA); turtle.penup(); turtle.circle(e - a + b, (Math.PI * 2) / 3 - 2 * halfA); turtle.pendown(); } let innerAngles = getIntersectionAnglesForCircles(f, e - a, g / 2 - a); let halfB = innerAngles[0] / 2; let halfBOuter = innerAngles[1] / 2; //center circle inside turtle.jump(0, e - a); turtle.seth(Math.PI); turtle.penup(); turtle.circle(e - a, Math.PI - halfB); turtle.pendown(); for (let j = 0; j < 3; j++) { turtle.circle(e - a, 2 * halfB); turtle.penup(); turtle.circle(e - a, (Math.PI * 2) / 3 - 2 * halfB); turtle.pendown(); } let innerCircleHooks = []; //inner circle (start down, go clockwise) turtle.jump(0, d / 2); turtle.seth(Math.PI); let dgate = 2 * Math.asin(a / d); let dcov = (2 * Math.PI) / 3 - dgate; turtle.penup(); turtle.circle(d / 2, dcov / 2); turtle.circle(d / 2, dgate); turtle.pendown(); for (let j = 0; j < 3; j++) { innerCircleHooks.push(turtle.pos()); turtle.circle(d / 2, dcov); innerCircleHooks.push(turtle.pos()); turtle.penup(); turtle.circle(d / 2, dgate); turtle.pendown(); } //turtle.circle(d / 2, 2* Math.PI); let innerThreeCircles = []; let innerThreeCirclesOut = []; let outerThreeCirclesOut = []; let dst = Math.sin(Math.PI / 3) * e * 2; //let bigOneStart = Math.acos((dst / 2) / (h / 2)); //let bigOneStart = getCircleAngle(dst, h / 2, h / 2) * 1.077; let oAngles = getIntersectionAnglesForCircles(dst, h / 2, h / 2); let bigOneStart = oAngles[0] / 5; for (let j = 0; j < 3; j++) { //big one turtle.jump( -Math.sin((j / 3) * 2 * Math.PI) * (-e + h / 2), Math.cos((j / 3) * 2 * Math.PI) * (-e + h / 2) ); let ogate = 2 * Math.asin(c / h); turtle.seth(Math.PI + (j / 3) * 2 * Math.PI); turtle.penup(); turtle.circle(h / 2, bigOneStart + Math.PI / 3); turtle.pendown(); turtle.circle(h / 2, Math.PI - ogate / 2 - (bigOneStart + Math.PI / 3)); turtle.penup(); outerThreeCirclesOut.push(turtle.pos()); turtle.circle(h / 2, ogate); outerThreeCirclesOut.push(turtle.pos()); turtle.pendown(); turtle.circle(h / 2, Math.PI - ogate / 2 - (bigOneStart + Math.PI / 3)); //small one turtle.jump( Math.sin((j / 3) * 2 * Math.PI) * (f - g / 2), -Math.cos((j / 3) * 2 * Math.PI) * (f - g / 2) ); turtle.seth(Math.PI + (j / 3) * 2 * Math.PI); let ismgate = 2 * Math.asin(a / g); let ilgate = 2 * Math.asin(c / g); let ismcov = (2 * Math.PI - ismgate - ilgate) / 2; turtle.penup(); turtle.circle(g / 2, ismgate / 2); innerThreeCircles.push(turtle.pos()); turtle.pendown(); turtle.circle(g / 2, ismcov); turtle.penup(); innerThreeCirclesOut.push(turtle.pos()); turtle.circle(g / 2, ilgate); innerThreeCirclesOut.push(turtle.pos()); turtle.pendown(); turtle.circle(g / 2, ismcov); innerThreeCircles.push(turtle.pos()); // turtle.circle(g / 2, 2 * Math.PI); turtle.jump( Math.sin((j / 3) * 2 * Math.PI) * (f - g / 2 + a), -Math.cos((j / 3) * 2 * Math.PI) * (f - g / 2 + a) ); turtle.seth(Math.PI + (j / 3) * 2 * Math.PI); turtle.penup(); turtle.circle(g / 2 - a, -halfAOuter); turtle.pendown(); turtle.circle(g / 2 - a, halfAOuter - halfBOuter); turtle.penup(); turtle.circle(g / 2 - a, 2 * halfBOuter); turtle.pendown(); turtle.circle(g / 2 - a, halfAOuter - halfBOuter); } let helperA = []; for (let j = 0; j < 6; j++) { turtle.jump(innerCircleHooks[j]); let t = turtle.pos(); turtle.goto(innerThreeCircles[(j + 5) % 6]); if (j == 3 || j == 4) { helperA.push([ (turtle.pos()[0] + t[0]) / 2, (turtle.pos()[1] + t[1]) / 2 ]); } turtle.jump(innerThreeCirclesOut[j]); turtle.goto(outerThreeCirclesOut[j]); } if (showHelperLines == 0) { turtle.jump(-35, 90); turtle.seth(0); text.print(turtle, "- Biohazard -", 0.3); } if (showHelperLines == 1) { turtle.seth(0); //Math.PI*3/2); turtle.jump(-75, 83); text.print(turtle, "Dimension A B C D E F G H", 0.25); turtle.jump(-51, 93); text.print(turtle, "Units 1 3.5 4 6 11 15 21 30", 0.2); //axis dashedLine(-95, 0, 95, 0, [1, 2, 3, 2]); dashedLine(0, -f * 1.95, 0, -f * 1.9, [1, 2, 3, 2]); dashedLine(0, -f * 1.75, 0, -f * 1.6, [1, 2, 3, 2]); dashedLine(0, -f * 1.43, 0, -d * 1.3, [1, 2, 3, 2]); dashedLine(0, -d * 1, 0, 75, [1, 2, 3, 2]); turtle.jump(d * 1.2, -e * 0.4); turtle.seth(0); text.print(turtle, "Base unit", 0.15); //a dashedLine(0, -e + a, 75, -e + a, [1, 1]); turtle.jump(e * 1.1, -e * 0.6); turtle.seth(0); text.print(turtle, "A", 0.2); lineArrow( e * 1.1 + 2.2, -e, e * 1.1 + 2.2, -e - a - a - a, 3, Math.PI / 6, 1 ); lineArrow( e * 1.1 + 2.2, -e + a, e * 1.1 + 2.2, -e + a + a + a, 3, Math.PI / 6, 1 ); turtle.seth(0); turtle.jump(d * 0.9, -e * 0.25); text.print(turtle, "A", 0.2); lineArrow( helperA[0][0] + 5.5, helperA[0][1] - 5.5 * Math.tan(Math.PI / 3), helperA[0][0], helperA[0][1], 3, Math.PI / 6, 2 ); lineArrow( helperA[1][0] - 5.5, helperA[1][1] + 5.5 * Math.tan(Math.PI / 3), helperA[1][0], helperA[1][1], 3, Math.PI / 6, 2 ); turtle.seth(0); turtle.jump(d * 1.25, e * 0.8); text.print(turtle, "A", 0.2); let rrrr = e - a + b / 2; let halfAngles = getIntersectionAnglesForCircles(f, rrrr, g / 2 - a); turtle.jump(0, -rrrr); turtle.penup(); turtle.circle(rrrr, (2 * Math.PI) / 3 + halfAngles[0] / 2); turtle.pendown(); arrowHead(turtle, 3, Math.PI / 6); turtle.circle(rrrr, -0.3); turtle.penup(); turtle.circle(rrrr, 0.3 + a / rrrr); turtle.pendown(); turtle.left(Math.PI); arrowHead(turtle, 3, Math.PI / 6); turtle.left(Math.PI); turtle.circle(rrrr, 0.25); //b dashedLine(0, -e + a - b, 75, -e + a - b, [1, 1]); turtle.jump(f * 1.2, -e * 1.05); turtle.seth(0); text.print(turtle, "B", 0.2); lineArrow( f * 1.2 + 2.2, -e + a - b, f * 1.2 + 2.2, -e + a - b - b, 3, Math.PI / 6, 1 ); lineArrow( f * 1.2 + 2.2, -e + a, f * 1.2 + 2.2, -e + a + a + a, 3, Math.PI / 6, 1 ); //c dashedLine(-c / 2, -f * 1.4, -c / 2, -f * 1.7, [1, 1]); dashedLine(c / 2, -f * 1.4, c / 2, -f * 1.7, [1, 1]); turtle.jump(-2.4, -f * 1.5); turtle.seth(0); text.print(turtle, "C", 0.2); lineArrow(-4, -f * 1.5, -c / 2, -f * 1.5, 3, Math.PI / 6, 2); lineArrow(4, -f * 1.5, c / 2, -f * 1.5, 3, Math.PI / 6, 2); //d dashedLine(-d / 2, -d * 1.3, -d / 2, 0, [1, 1]); dashedLine(d / 2, -d * 1.3, d / 2, 0, [1, 1]); turtle.jump(-2.4, -d * 1.1); turtle.seth(0); text.print(turtle, "D", 0.2); lineArrow(-4, -d * 1.1, -d / 2, -d * 1.1, 3, Math.PI / 6, 2); lineArrow(4, -d * 1.1, d / 2, -d * 1.1, 3, Math.PI / 6, 2); //e dashedLine(-5, -e, f * 1.15, -e, [3, 1, 1, 1]); dashedLine(f * 1.35, -e, 85, -e, [3, 1, 1, 1]); turtle.jump(f * 1.75, -e / 2); turtle.seth(0); text.print(turtle, "E", 0.2); lineArrow( f * 1.75 + 2.2, -e / 2 - 4, f * 1.75 + 2.2, -e, 3, Math.PI / 6, 2 ); lineArrow( f * 1.75 + 2.2, -e / 2 + 3, f * 1.75 + 2.2, 0, 3, Math.PI / 6, 2 ); //f dashedLine(-5, -f, 95, -f, [3, 1, 1, 1]); turtle.jump(f * 2, -f / 2); turtle.seth(0); text.print(turtle, "F", 0.2); lineArrow(f * 2 + 2.2, -f / 2 - 4, f * 2 + 2.2, -f, 3, Math.PI / 6, 2); lineArrow(f * 2 + 2.2, -f / 2 + 3, f * 2 + 2.2, 0, 3, Math.PI / 6, 2); //g dashedLine(-g / 2, -h / 2.5, -g / 2, -85, [1, 1]); dashedLine(g / 2, -h / 2.5, g / 2, -85, [1, 1]); turtle.jump(-2.4, -f * 1.82); turtle.seth(0); text.print(turtle, "G", 0.2); lineArrow(-4, -f * 1.82, -g / 2, -f * 1.82, 3, Math.PI / 6, 2); lineArrow(4, -f * 1.82, g / 2, -f * 1.82, 3, Math.PI / 6, 2); //h dashedLine(-h / 2, -h / 2.5, -h / 2, -95, [1, 1]); dashedLine(h / 2, -h / 2.5, h / 2, -95, [1, 1]); turtle.jump(-2.4, -f * 2.03); turtle.seth(0); text.print(turtle, "H", 0.2); lineArrow(-4, -f * 2.03, -h / 2, -f * 2.03, 3, Math.PI / 6, 2); lineArrow(4, -f * 2.03, h / 2, -f * 2.03, 3, Math.PI / 6, 2); //210 deg let rrr = (f * 1.1) / Math.cos(Math.PI / 6); turtle.seth(Math.PI / 6 + Math.PI / 2); turtle.jump(f * 1.1, Math.tan(Math.PI / 6) * f * 1.1); arrowHead(turtle, 3, Math.PI / 6); turtle.circle(rrr, -Math.PI / 12); turtle.seth(0); turtle.jump(turtle.pos()[0] - a / 2, turtle.pos()[1] + 3 * a); text.print(turtle, "210", 0.15); text.print(turtle, " o", 0.1); dashedLine(0, 0, 95, Math.tan(Math.PI / 6) * 95, [4, 2]); //330 deg turtle.seth(Math.PI / 6 + Math.PI / 2); turtle.jump(f * 1.1, Math.tan(Math.PI / 6) * f * 1.1); turtle.pu(); turtle.circle(rrr, (Math.PI / 3) * 2); turtle.pd(); arrowHead(turtle, 3, Math.PI / 6); turtle.circle(rrr, -Math.PI / 12); turtle.seth(0); turtle.jump(turtle.pos()[0] - 1.5 * a, turtle.pos()[1] - 2.5 * a); text.print(turtle, "330", 0.15); text.print(turtle, " o", 0.1); dashedLine(0, 0, -95, Math.tan(Math.PI / 6) * 95, [4, 2]); //90 deg turtle.seth(Math.PI / 6 + Math.PI / 2); turtle.jump(f * 1.1, Math.tan(Math.PI / 6) * f * 1.1); turtle.pu(); turtle.circle(rrr, (Math.PI / 3) * 4); turtle.pd(); arrowHead(turtle, 3, Math.PI / 6); turtle.circle(rrr, -Math.PI / 12); turtle.seth(0); turtle.jump(turtle.pos()[0] + a, turtle.pos()[1] + a); text.print(turtle, "90", 0.15); text.print(turtle, " o", 0.1); } return false; } function getIntersectionAnglesForCircles(d, r1, r2) { //Area of triangle using Heron's https://nl.wikipedia.org/wiki/Formule_van_Heron let s = (d + r1 + r2) / 2; let O = Math.sqrt(s * (s - d) * (s - r1) * (s - r2)); //Area of kite using https://nl.wikipedia.org/wiki/Vlieger_(meetkunde) //let A = d * BD / 2 //4 * O / d = BD; let BD = (4 * O) / d; return [Math.asin(BD / 2 / r1) * 2, Math.asin(BD / 2 / r2) * 2]; } function arrowHead(turtle, arrowSize, arrowAngle) { if (arrowSize === null) { arrowSize = 3; } if (arrowAngle === null) { arrowAngle = Math.PI / 6; } let h = turtle.heading(); let p = turtle.pos(); turtle.right(Math.PI - arrowAngle); turtle.forward(arrowSize); turtle.jump(p); turtle.right(2 * arrowAngle); turtle.forward(arrowSize); turtle.jump(p); turtle.seth(h); } function lineArrow(x1, y1, x2, y2, arrowSize, arrowAngle, heads = 3) { let heading = y2 > y1 ? Math.PI / 2 : (Math.PI / 2) * 3; if (x1 != x2) { heading = (x2 - x1 < 0 ? Math.PI : 0) + Math.atan((y2 - y1) / (x2 - x1)); } arrow( x1, y1, heading, Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2), null, null, arrowSize, arrowAngle, heads ); } function arrow( x1, y1, heading, length, radius, extent, arrowSize = 3, arrowAngle = null, heads = 3 ) { let isArc = length === null; if (arrowAngle === null) { arrowAngle = Math.PI / 6; } turtle.jump(x1, y1); turtle.setheading(heading); if ((heads & 1) == 1) { turtle.left(arrowAngle); turtle.forward(arrowSize); turtle.penup(); turtle.backward(arrowSize); turtle.pendown(); turtle.right(2 * arrowAngle); turtle.forward(arrowSize); turtle.penup(); turtle.backward(arrowSize); turtle.pendown(); turtle.setheading(heading); } if (isArc) { turtle.circle(radius, extent); } else { turtle.forward(length); } if ((heads & 2) == 2) { turtle.left(Math.PI - arrowAngle); turtle.forward(arrowSize); turtle.penup(); turtle.backward(arrowSize); turtle.pendown(); turtle.left(2 * arrowAngle); turtle.forward(arrowSize); } } function dashedLine(x1, y1, x2, y2, pattern = [500]) { turtle.jump(x1, y1); turtle.setheading(y2 > y1 ? Math.PI / 2 : (Math.PI / 2) * 3); let len = Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2); if (x1 != x2) { turtle.setheading( (x2 - x1 < 0 ? Math.PI : 0) + Math.atan((y2 - y1) / (x2 - x1)) ); } let tr = 0; let i = 0; turtle.penup(); while (tr < len) { let inc = pattern[i % pattern.length]; turtle.isdown() ? turtle.penup() : turtle.pendown(); turtle.forward(inc + tr > len ? len - tr : inc); i++; tr += inc; } } //////////////////////////////////////////////////////////////// // Text utility code. Created by Reinder Nijhoff 2019 // https://turtletoy.net/turtle/1713ddbe99 //////////////////////////////////////////////////////////////// function Text() { class Text { print(t, str, scale = 1, italic = 0, kerning = 1) { t.radians(); let pos = [t.x(), t.y()], h = t.h(), o = pos; str.split("").map((c) => { const i = c.charCodeAt(0) - 32; if (i < 0) { pos = o = this.rotAdd([0, 48 * scale], o, h); } else if (i > 96) { pos = this.rotAdd([16 * scale, 0], o, h); } else { const d = dat[i], lt = d[0] * scale, rt = d[1] * scale, paths = d[2]; paths.map((p) => { t.up(); p.map((s) => { t.goto( this.rotAdd( [(s[0] - s[1] * italic) * scale - lt, s[1] * scale], pos, h ) ); t.down(); }); }); pos = this.rotAdd([(rt - lt) * kerning, 0], pos, h); } }); } rotAdd(a, b, h) { return [ Math.cos(h) * a[0] - Math.sin(h) * a[1] + b[0], Math.cos(h) * a[1] + Math.sin(h) * a[0] + b[1] ]; } } const dat = ( "br>eoj^jlbrf^fe`ukZdz`thZhw^vs^as]wtgtfsereqfph" + "nmlpjrhsdsbraq`o`makbjifjekckaj_h^f_eaecffhimporqssstrtq>eoj`i_j^k_kajcid>cqnZl\\j_hcghglhqjulxnz>c" + "qfZh\\j_lcmhmllqjuhxfz>brjdjp]wjajsfnkojpiojnkokqis>]wajsj>fnjniojpkojn>_usZaz>`ti" + "^f_dbcgcjdofrisksnrpoqjqgpbn_k^i^>`tfbhak^ks>`tdcdbe`f_h^l^n_o`pbpdofmicsqs>`te^p^jfmfogphqkqmppnrk" + "shserdqco>`tm^clrl`to^e^dgefhekenfphqkqmppnrkshserdqco>`tpao_l^j^g_ebdgdlepgrjsksnrppqmqlping" + "kfjfggeidl>`tq^gs`th^e_dadceegfkgnhpjqlqopqorlshserdqcocldjfhigmfoepcpao_l^h^>`tpeohmjjkikfjd" + "hcecddaf_i^j^m_oapepjoomrjshserdp>fnjgihjikhjgfnjgihjikhjg^vrabjrs>]wag" + "sg^vbarjbs>asdcdbe`f_h^l^n_o`pbpdofngjijl]xofndlcicgdfeehekfmhnknmmnkasj^bs_tc^cs`urcqao_m^i^g_eadccfckdnepgrismsorqprn>_tc^cs`sd^ds`rd^ds`urcqao_m^i^g_eadccfckdnepgrismsorqprnrk_uc^cs<" + "q^qsfnj^js>brn^nnmqlrjshsfreqdndl>_tc^cs`qd^ds^vb^bs_uc^cs_uh^f_daccbfbkcndpfrhslsnrppqnrkrfqcpan_l^h^>_tc^cs_uh^f_daccbfbkcnd" + "pfrhslsnrppqnrkrfqcpan_l^h^_tc^cs`tqao_l^h^e_caccdeefggmiojpkqmqpo" + "rlshsercp>brj^js_uc^cmdpfrisksnrppqmq^>asb^js^v`^es`tc^qsasb^jhjs" + "`tq^cscqgZgzcqc^qv>cqlZlzbrj\\bjasazsz>fnkc" + "ieigjhkgjfig>atpeps`sd^dsasphnfleiegfeh" + "dkdmepgrislsnrpp>atp^psasdkpkpiognfleiegfehdkdmepgrislsnrpp>eqo^m^k_j" + "bjsatpepuoxnylzizgyate^esfni^j_k^j]i^eoj^" + "k_l^k]j^are^esfnj^js>[y_e_s<_ibfdegeifjijsateeesatiegfehdkdmepgrislsnrppqmqkphnfleie>`sdedzatpepzcpgegsbsphofleieffehfjhkmlompopporlsisfrep>eqj^jokrmsosateeeofrhsks" + "mrpobrdejs_ubefsbseepsbrdejsbspeescqlZj[" + "i\\h^h`ibjckekgiifnjZjz>cqhZj[k\\l^l`kbjci" + "eigki^vamakbhdgfghhlknlplrksibrb^bscsc^d^dsese^f^fsgsg^h^hsisi^j^jsksk^l^lsmsm^n^nsoso^p^psqsq^r^rs" ) .split(">") .map((r) => { return [ r.charCodeAt(0) - 106, r.charCodeAt(1) - 106, r .substr(2) .split("<") .map((a) => { const ret = []; for (let i = 0; i < a.length; i += 2) { ret.push( a .substr(i, 2) .split("") .map((b) => b.charCodeAt(0) - 106) ); } return ret; }) ]; }); return new Text(); } return finalize(turtle, walk); }39:[] 2e:{"title":"Hello, Turtletoy","cells":[{"id":0,"value":"# Hello, Turtletoy","pinned":false,"hidden":false,"mode":"md"},{"id":416,"value":"The [Turtletoy](https://turtletoy.net) playground is an addictive tool to generate plotter-friendly vector graphics. It provides the [Turtle API](https://turtletoy.net/syntax), which allows creating graphics using classic logo primitives, a preview window, and a way to export optimized SVG.\n\nUsers have added many useful plotter-oriented functions, among which:\n* single-line SVG text\n* surface hatching\n* voxel ray caster\n* polygon clipping\n* BSP tree\n* etc.\n\nThe dev environment lacks some features (like the ability to pan and zoom the preview, or import external resources), and the API implementation is not public (though it could be extracted from the webapp), so I decided to implement the API to allow running Turtletoy creations in the Observable environment, and see what possibilities can spring up from there.","pinned":false,"hidden":false,"mode":"md"},{"id":6,"value":"$30","pinned":true,"hidden":false,"mode":"ojs"},{"id":371,"value":"finalize = function* (turtle, walk, opts) {\n const { step = 1, height = 500 } = isNaN(opts) ? opts ?? {} : { step: opts };\n const view = viewer([width, height], true);\n const vOptions = { \"stroke-width\": 0.2, viewBox: \"-100 -100, 200, 200\" };\n view.view(turtle.plot, vOptions);\n if (walk) {\n let result;\n let i = 0;\n do {\n result = walk(i++);\n if (i % step == 0) yield view.update(turtle.plot);\n } while (result && i < 10000);\n yield view.update(turtle.plot);\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":572,"value":"The following object must also be accessible to the scripts (yet its role is not very clear to me).","pinned":false,"hidden":false,"mode":"md"},{"id":566,"value":"Canvas = ({\n setpenopacity: () => {}\n})","pinned":false,"hidden":false,"mode":"ojs"},{"id":466,"value":"The implementation is quite short, because there's nothing complicated here. Some key points:\n* It only generates SVG\n* `polyline` elements are used whenever possible, to avoid numerous `line` elements\n\nTo execute a Turtletoy script, follow these steps:\n* create a cell\n* paste the Turtletoy script in a pair of braces\n* append this line before the closing braces:\n\n `return finalize(turtle, walk, step);` (where `step` is an optional integer)\n\n This will:\n * execute the `walk` function until it returns false\n * yield the intermediary SVG every `step` iterations (no yield if `step` omitted)\n * finally yield the completed SVG, adding zoom and pan capabilities (+dbl-click to reset the viewbox)\n\nSome scripts may have to be slightly modified, as the Observable transpiler is apparently more strict than the one used by the Turtletoy environment, especially when initializing vars without a `let` or a `const` keyword.\n\nAnd now some examples:","pinned":false,"hidden":false,"mode":"md"},{"id":474,"value":"Gosper's fractals (by [ehouais](https://turtletoy.net/user/ehouais)) - ","pinned":false,"hidden":false,"mode":"md"},{"id":8,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":513,"value":"Text utility (by [ehouais](https://turtletoy.net/user/ehouais)) - ","pinned":false,"hidden":false,"mode":"md"},{"id":510,"value":"$32","pinned":false,"hidden":false,"mode":"ojs"},{"id":471,"value":"Invaders (by [ge1doot](https://turtletoy.net/user/ge1doot)) - ","pinned":false,"hidden":false,"mode":"md"},{"id":181,"value":"{\n await visibility();\n\n const turtle = new Turtle();\n\n function walk(i) {\n const x = i % 16;\n const y = (i / 16) >> 0;\n for (let i = 0; i < 8; i++) {\n let bits = Math.random().toString(2).substr(2, 4).split(\"\");\n bits = bits.concat(bits.slice().reverse());\n bits.forEach((n, j) => {\n if (n === \"1\") {\n turtle.down();\n turtle.jump(-94 + x * 12 + j, -94 + y * 12 + i);\n turtle.circle(0.3);\n turtle.jump(-94 + x * 12 + j, -94 + y * 12 + i + 0.1);\n turtle.circle(0.2);\n turtle.jump(-94 + x * 12 + j, -94 + y * 12 + i + 0.2);\n turtle.circle(0.1);\n }\n });\n }\n return i < 16 * 16 - 1;\n }\n\n return finalize(turtle, walk);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":478,"value":"Tesselation #1 (by [reinder](https://turtletoy.net/user/reinder)) - ","pinned":false,"hidden":false,"mode":"md"},{"id":281,"value":"$33","pinned":false,"hidden":false,"mode":"ojs"},{"id":482,"value":"Simplex Noise (by [reinder](https://turtletoy.net/user/reinder)) - ","pinned":false,"hidden":false,"mode":"md"},{"id":363,"value":"$34","pinned":false,"hidden":false,"mode":"ojs"},{"id":480,"value":"Voxel Ray Caster (by [reinder](https://turtletoy.net/user/reinder)) - ","pinned":false,"hidden":false,"mode":"md"},{"id":387,"value":"$35","pinned":false,"hidden":false,"mode":"ojs"},{"id":476,"value":"Trigonometric identities (by [Jurgen](https://turtletoy.net/user/Jurgen)) - ","pinned":false,"hidden":false,"mode":"md"},{"id":406,"value":"$36","pinned":false,"hidden":false,"mode":"ojs"},{"id":578,"value":"Cubic cityscape #1 (by [reinder](https://turtletoy.net/user/reinder)) - ","pinned":false,"hidden":false,"mode":"md"},{"id":559,"value":"$37","pinned":false,"hidden":false,"mode":"ojs"},{"id":590,"value":"Biohazard construction (by [Jurgen](https://turtletoy.net/user/Jurgen)) - ","pinned":false,"hidden":false,"mode":"md"},{"id":587,"value":"$38","pinned":false,"hidden":false,"mode":"ojs"},{"id":492,"value":"---","pinned":false,"hidden":false,"mode":"md"},{"id":620,"value":"import { Plot, viewer } from \"@ehouais/pivot-format-for-plotter-experiments\"","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W39","stdlib":"1","titling":"auto"}