### Subdivision Grid ➖➗

Draw randomized grid, split cells into multiple rectangles and recurse.

#kdtree

```const turtle = new Turtle();

const seed = 50; /// min=1, max=100, step=1
const baseShape = 0; // min=0, max=1, step=1 (Square, Hexagon)
const grid = 7; // min=3, max=21, step=2
const maxDepth = 4; // min=1, max=10, step=1
const directionMode = 0; // min=0, max=1, step=1 (Random, Modulo)
const splitMode = 0; // min=0, max=1, step=1 (Scattered, Ordered)
const splitChance = 0.84; // min=0, max=1, step=0.01
const splitMin = 2; // min=1, max=8, step=1
const splitMax = 3; // min=1, max=8, step=1
const randomDistortion1 = .4; // min=0, max=1, step=0.01
const randomDistortion2 = .03; // min=0, max=0.25, step=0.001
const shapeScaleMode = 0//min=0, max=2, step=1 (Both, On Outer Shape, On Splitted Shapes)
const shapeScale = 0.98; // min=0.75, max=1.25, step=0.001
const scale = 220 / grid;

let mod = 0;

function walk(i) {
const x = (i % grid) - (grid/2|0);
const y = (i/grid|0) - (grid/2|0);
if (baseShape == 0) {
const square = randomizePoints(createSquare(x, y), randomDistortion1);
recurse(square, splitChance);
} else if (baseShape == 1) {
const hexagon = randomizePoints(createHexagon(x, y), randomDistortion1);
const square1 = [hexagon[0],hexagon[1],hexagon[2],hexagon[3]];
const square2 = [hexagon[3],hexagon[4],hexagon[5],hexagon[0]];
recurse( square1, splitChance);
recurse( square2, splitChance);
}

return i < grid * grid - 1;
}

function recurse(points, chance = 0.5, depth = 0) {
const doRecurse = depth < maxDepth && chance > 0;
const totalSplits = Math.round(lrp(splitMin,splitMax, rand()));
const direction = directionMode == 0 ? rand() > 0.5 : mod++ % 3 == 0;
const splittedShapeScale = (shapeScaleMode == 0 || shapeScaleMode == 2) ? shapeScale : 1.0;
const shape = split(points, totalSplits, direction, splittedShapeScale);

if (splitMode == 0) {
if (doRecurse && rand() < chance) {
shape.forEach(points => recurse(points, chance, depth + 1));
} else {
if (shapeScaleMode <= 1) {
shape.forEach((points,i,l) => l[i] = randomizePoints(points, randomDistortion2));
shape.forEach((points,i,l) => l[i] = scl4(points, shapeScale));
}
shape.forEach(points => drawPoints(points.map(point => scl2(point, scale)), turtle));
}
} else {
shape.forEach(points => {
if (doRecurse && rand() < chance) {
recurse(points, chance, depth + 1);
} else {
if (shapeScaleMode <= 1) {
shape.forEach((points,i,l) => l[i] = randomizePoints(points, randomDistortion2));
shape.forEach((points,i,l) => l[i] = scl4(points, shapeScale));
}
drawPoints(points.map(point => scl2(point, scale)), turtle);
}
});
}
}

function createSquare(x,y) {
return [[x-.5,y-.5], [x+.5,y-.5], [x+.5,y+.5], [x-.5,y+.5]];
}

function createHexagon(x,y) {
const h = .75, w = 3/8 * (h/(Math.sqrt(3)/4)), center = [x*2*w + (y%2)*w, y*3/2*h];
}

function randomizePoints(points, scale = 1) {
return points.map( point => add2(point, scl2( add2( [hash(dot2(point, [11, 13])), hash(dot2(point, [17, 19]))], [-.5,-.5]), scale)));
}

function drawPoints(points, turtle) {
if (points.length > 0) turtle.jump(points[points.length-1]);
points.forEach(point => turtle.goto(point));
}

function split(points, total = 5, vertical = true, scale = 1.0) {
const [tl,tr,br,bl] = points;
const shapes = [];
for(let i=0;i<total;i++) {
const t1 = (i + (1 - scale)) / total;
const t2 = (i + scale) / total;

if (vertical) {
shapes.push([
[lrp(tl[0], tr[0], t1), lrp(tl[1], tr[1], t1) ],
[lrp(tl[0], tr[0], t2), lrp(tl[1], tr[1], t2) ],
[lrp(bl[0], br[0], t2), lrp(bl[1], br[1], t2) ],
[lrp(bl[0], br[0], t1), lrp(bl[1], br[1], t1) ],
]);
} else {
shapes.push([
[lrp(tl[0], bl[0], t1), lrp(tl[1], bl[1], t1) ],
[lrp(tl[0], bl[0], t2), lrp(tl[1], bl[1], t2) ],
[lrp(tr[0], br[0], t2), lrp(tr[1], br[1], t2) ],
[lrp(tr[0], br[0], t1), lrp(tr[1], br[1], t1) ],
]);
}
}
return shapes;
}

// vec2 functions
function scl2(a,b)   { return [a[0]*b, a[1]*b]; }
function add2(a,b)   { return [a[0]+b[0], a[1]+b[1]]; }
function sub2(a,b)   { return [a[0]-b[0], a[1]-b[1]]; }
function dot2(a,b)   { return a[0]*b[0] + a[1]*b[1]; }
function len2(a)     { return Math.sqrt(a[0]**2 + a[1]**2); }
function nrm2(a)     { return scl(a, 1/len(a)); }
function lrp2(a,b,f) { return [a[0]*f+b[0]*(1-f), a[1]*f+b[1]*(1-f)]; }
function lrp(a,b,f) { return a*f + b*(1-f); }
function scl4(shape, scale=0.9) {
const t1 = 1-scale;
const t2 = scale;
const [tl,tr,br,bl] = shape;
return [
[lrp(tl[0], br[0], t1), lrp(tl[1], br[1], t1) ],
[lrp(tr[0], bl[0], t1), lrp(tr[1], bl[1], t1) ],
[lrp(br[0], tl[0], t1), lrp(br[1], tl[1], t1) ],
[lrp(bl[0], tr[0], t1), lrp(bl[1], tr[1], t1) ],
];
}
function add4(shape, val = 0) {
const [tl,tr,br,bl] = shape;
return [
];
}

// pseudo random methods
function hash(p) {
p += seed;
p = 1103515245 * (((p) >> 1) ^ (p));
p = 1103515245 * (p ^ (p>>3));
p = p ^ (p >> 16);
return p / 1103515245 % 1;
}

let rseed = seed;
function rand() {
let r = 1103515245 * (((rseed) >> 1) ^ (rseed++));
r = 1103515245 * (r ^ (r>>3));
r = r ^ (r >> 16);
return r / 1103515245 % 1;
}```