diff --git a/arts/gen/src/gen/FlowInk.kt b/arts/gen/src/gen/FlowInk.kt new file mode 100644 index 00000000..90a53605 --- /dev/null +++ b/arts/gen/src/gen/FlowInk.kt @@ -0,0 +1,71 @@ +package gen + +import dev.oblac.gart.Gart +import dev.oblac.gart.angle.Degrees +import dev.oblac.gart.flow.Flow2 +import dev.oblac.gart.flow.FlowField +import dev.oblac.gart.flow.PointTracer +import dev.oblac.gart.gfx.toPath +import dev.oblac.gart.math.* +import dev.oblac.gart.noise.OpenSimplexNoise +import dev.oblac.gart.noise.poissonDiskSampling +import org.jetbrains.skia.PaintStrokeCap +import kotlin.math.atan2 +import kotlin.random.Random + +// 16:9 — GART_SIZE sets HEIGHT; width derived. Draft: GART_SIZE=540 -> 960x540. +private val HEIGHT: Int = System.getProperty("GART_SIZE")?.toIntOrNull() ?: 1080 +private val WIDTH: Int = HEIGHT * 16 / 9 +private val SEED: Long = System.getProperty("GART_SEED")?.toLongOrNull() ?: Random.nextLong() + +/** Flow-field streamlines through a simplex-noise vector field, finished with the Ink glow. */ +private class Flo( + val tag: String, val spacing: Float, val freq: Double, val angleScale: Float, + val vortex: Float, val steps: Int, val width: Float, val alpha: Int, +) + +private val VARIANTS = listOf( + Flo("laminar", 22f, 0.0009, 1.6f, 0.0f, 1300, 2.4f, 50), + Flo("turbulent", 18f, 0.0030, 3.2f, 0.0f, 800, 2.0f, 44), + Flo("vortex", 20f, 0.0014, 1.2f, 0.85f, 1100, 2.2f, 48), +) + +fun main() { + println("seed=$SEED") + val master = Random(SEED) + val gart = Gart.of("flowInk", WIDTH, HEIGHT) + val d = gart.d + val cx = d.cx; val cy = d.cy + + VARIANTS.forEachIndexed { vi, cfg -> + val rng = Random(master.nextLong()) + val simplex = OpenSimplexNoise(rng.nextLong()) + val flowField = FlowField.of(d) { x, y -> + val raw = simplex.random2D(x * cfg.freq, y * cfg.freq).toFloat() + val n = raw * 360f * cfg.angleScale + val ang: Float = if (cfg.vortex > 0f) { + val base = Math.toDegrees(atan2((y - cy).toDouble(), (x - cx).toDouble())).toFloat() + 90f + base * cfg.vortex + n * (1f - cfg.vortex) + } else n + Flow2(Degrees.of(ang), 1f) + } + val seeds = poissonDiskSampling(d.rect, cfg.spacing, random = rng) + val buf = gart.gartvas() + seeds.forEachIndexed { i, s -> + val pts = PointTracer(d, flowField).trace(s, cfg.steps) + if (pts.size < 2) return@forEachIndexed + val color = when { + i % 6 == 0 -> Ink.WHITE + i % 2 == 0 -> Ink.TEAL + else -> Ink.PURPLE + } + val a = if (color == Ink.PURPLE) (cfg.alpha * 1.7f).toInt() else cfg.alpha + val paint = Ink.stroke(color, a, cfg.width).apply { strokeCap = PaintStrokeCap.ROUND } + buf.canvas.drawPath(pts.toPath(), paint) + } + val finalv = Ink.finish(gart, buf, 0.09f) + gart.saveImage(finalv, "flowInk${vi + 1}.png") + println(" flowInk${vi + 1}.png (${cfg.tag}, seeds=${seeds.size})") + } + println("done") +} diff --git a/arts/gen/src/gen/GrowInk.kt b/arts/gen/src/gen/GrowInk.kt new file mode 100644 index 00000000..6e38bc1f --- /dev/null +++ b/arts/gen/src/gen/GrowInk.kt @@ -0,0 +1,72 @@ +package gen + +import dev.oblac.gart.Gart +import dev.oblac.gart.grow.Growth +import org.jetbrains.skia.PaintStrokeCap +import org.jetbrains.skia.PaintStrokeJoin +import kotlin.random.Random + +// 16:9 — GART_SIZE sets HEIGHT; width derived. +private val HEIGHT: Int = System.getProperty("GART_SIZE")?.toIntOrNull() ?: 1080 +private val WIDTH: Int = HEIGHT * 16 / 9 +private val SEED: Long = System.getProperty("GART_SEED")?.toLongOrNull() ?: Random.nextLong() + +/** + * Differential growth — a closed polyline wrinkles outward, bounded by maxRadius so it + * stays in frame. Colour bands by growth time (teal core -> white -> purple rim), which + * keeps both fiuto accents spatially separated and visible. NB: Growth uses global RNG + * internally, so it is not byte-for-byte reproducible by GART_SEED. + */ +private class Gro( + val tag: String, val maxEdge: Float, val rejection: Float, val attraction: Float, + val brownian: Float, val seedR: Float, val seedN: Int, val steps: Int, val alpha: Int, +) + +private val VARIANTS = listOf( + Gro("coral", 6f, 14f, 0.15f, 0.6f, 30f, 3, 600, 14), + Gro("lobes", 7f, 18f, 0.18f, 0.5f, 40f, 4, 560, 13), + Gro("dense", 6f, 12f, 0.13f, 0.55f, 26f, 3, 520, 12), +) + +fun main() { + println("seed=$SEED") + val gart = Gart.of("growInk", WIDTH, HEIGHT) + val d = gart.d + val bound = d.h * 0.46f + + VARIANTS.forEachIndexed { vi, cfg -> + val growth = Growth( + maxEdgeLength = cfg.maxEdge, + rejectionRadius = cfg.rejection, + attractionStrength = cfg.attraction, + rejectionStrength = 0.5f, + brownianStrength = cfg.brownian, + centerX = d.cx, + centerY = d.cy, + maxRadius = bound, + ) + growth.seedCircle(d.cx, d.cy, cfg.seedR, cfg.seedN) + val buf = gart.gartvas() + val c = buf.canvas + var step = 0 + while (step < cfg.steps && !growth.done && growth.size < 60_000) { + growth.step() + val t = step.toFloat() / cfg.steps + val color = when { + t < 0.40f -> Ink.TEAL + t < 0.60f -> Ink.WHITE + else -> Ink.PURPLE + } + val a = if (color == Ink.PURPLE) (cfg.alpha * 1.7f).toInt() else cfg.alpha + c.drawPath(growth.toPath(), Ink.stroke(color, a, 0.8f).apply { + strokeCap = PaintStrokeCap.ROUND + strokeJoin = PaintStrokeJoin.ROUND + }) + step++ + } + val finalv = Ink.finish(gart, buf, 0.09f) + gart.saveImage(finalv, "growInk${vi + 1}.png") + println(" growInk${vi + 1}.png (${cfg.tag}, nodes=${growth.size}, steps=$step)") + } + println("done") +} diff --git a/arts/gen/src/gen/Ink.kt b/arts/gen/src/gen/Ink.kt new file mode 100644 index 00000000..1c55d4eb --- /dev/null +++ b/arts/gen/src/gen/Ink.kt @@ -0,0 +1,75 @@ +package gen + +import dev.oblac.gart.Gart +import dev.oblac.gart.Gartvas +import dev.oblac.gart.color.CssColors +import dev.oblac.gart.gfx.strokeOf +import dev.oblac.gart.shader.createNoiseGrainFilter +import org.jetbrains.skia.BlendMode +import org.jetbrains.skia.FilterTileMode +import org.jetbrains.skia.ImageFilter +import org.jetbrains.skia.Paint + +/** + * Shared "light in the dark" finishing pass + fiuto tones, used by every gen ink piece + * so the whole family stays consistent. Tones lifted from the fiuto repo: + * - navy ground #071426 (favicon background) + * - teal accent #00D3BB (logo fill) + * - purple accent #5E49D6 (default slides-theme accent) + */ +object Ink { + val GROUND = 0xFF071426.toInt() + val TEAL = 0xFF00D3BB.toInt() + val PURPLE = 0xFF5E49D6.toInt() + val WHITE = CssColors.white + + fun stroke(color: Int, alpha: Int, width: Float = 1f): Paint = + strokeOf(color, width).apply { this.alpha = alpha.coerceIn(0, 255); isAntiAlias = true } + + /** + * Composite a *transparent* stroke buffer over the navy ground with SCREEN-blend + * Gaussian-blur bloom (so dense areas glow), then a noise-grain texture pass. + * Returns the final gartvas, ready to saveImage. + */ + fun finish(gart: Gart, buf: Gartvas, grain: Float = 0.10f): Gartvas { + val d = gart.d + val sharp = buf.snapshot() + val out = gart.gartvas() + val oc = out.canvas + oc.clear(GROUND) + val s = d.h / 170f + for (sigma in listOf(s, s / 2.5f)) { + oc.drawImage(sharp, 0f, 0f, Paint().apply { + imageFilter = ImageFilter.makeBlur(sigma, sigma, FilterTileMode.DECAL) + blendMode = BlendMode.SCREEN + }) + } + oc.drawImage(sharp, 0f, 0f, Paint().apply { blendMode = BlendMode.SCREEN }) + val finalv = gart.gartvas() + finalv.canvas.drawImage(out.snapshot(), 0f, 0f, Paint().apply { + imageFilter = createNoiseGrainFilter(grain, d) + }) + return finalv + } + + // ---- colour helpers for per-pixel pieces (plasma) ---- + + private fun lerp(a: Int, b: Int, t: Float): Int { + val ar = (a ushr 16) and 0xFF; val ag = (a ushr 8) and 0xFF; val ab = a and 0xFF + val br = (b ushr 16) and 0xFF; val bg = (b ushr 8) and 0xFF; val bb = b and 0xFF + val r = (ar + (br - ar) * t).toInt() + val g = (ag + (bg - ag) * t).toInt() + val bl = (ab + (bb - ab) * t).toInt() + return (0xFF shl 24) or (r shl 16) or (g shl 8) or bl + } + + /** Multi-stop colour ramp; t in [0,1]. */ + fun ramp(stops: List, t: Float): Int { + val tt = t.coerceIn(0f, 1f) * (stops.size - 1) + val i = tt.toInt().coerceAtMost(stops.size - 2) + return lerp(stops[i], stops[i + 1], tt - i) + } + + /** navy→purple→teal→white→teal→purple→navy — both fiuto accents, cycles seamlessly. */ + val PLASMA_STOPS = listOf(GROUND, PURPLE, TEAL, WHITE, TEAL, PURPLE, GROUND) +} diff --git a/arts/gen/src/gen/LissaInk.kt b/arts/gen/src/gen/LissaInk.kt new file mode 100644 index 00000000..a38ab724 --- /dev/null +++ b/arts/gen/src/gen/LissaInk.kt @@ -0,0 +1,89 @@ +package gen + +import dev.oblac.gart.Gart +import dev.oblac.gart.gfx.drawLine +import dev.oblac.gart.math.* +import kotlin.math.PI +import kotlin.math.exp +import kotlin.math.sin +import kotlin.random.Random +import org.jetbrains.skia.Point + +// 16:9 — GART_SIZE sets HEIGHT; width derived. +private val HEIGHT: Int = System.getProperty("GART_SIZE")?.toIntOrNull() ?: 1080 +private val WIDTH: Int = HEIGHT * 16 / 9 +private val SEED: Long = System.getProperty("GART_SEED")?.toLongOrNull() ?: Random.nextLong() + +private val HALF_PI = (PI / 2).toFloat() + +/** + * Lissajous figures: x = sin(a·t + δ), y = sin(b·t), phase-swept into a glowing bundle. + * Colour is banded across the sweep (early copies teal, late copies purple) so the two + * fiuto accents land at different orientations and both stay visible. Some variants damp + * (exp decay) into spirals. High variance across the 10 via the a:b frequency ratio. + */ +private class Lis( + val tag: String, val a: Float, val b: Float, val phase: Float, + val decay: Float, val copies: Int, val phaseStep: Float, val alpha: Int, +) + +private val VARIANTS = listOf( + Lis("1:2", 1f, 2f, HALF_PI, 0.0f, 90, 0.040f, 16), + Lis("2:3", 2f, 3f, HALF_PI, 0.0f, 100, 0.036f, 16), + Lis("3:4", 3f, 4f, 0.4f, 0.0f, 110, 0.034f, 15), + Lis("3:5", 3f, 5f, 0.7f, 0.0f, 110, 0.032f, 15), + Lis("4:5", 4f, 5f, HALF_PI, 0.0f, 120, 0.030f, 15), + Lis("5:6", 5f, 6f, 0.3f, 0.0f, 120, 0.030f, 14), + Lis("5:7", 5f, 7f, 0.9f, 0.0f, 130, 0.028f, 14), + Lis("7:9", 7f, 9f, 0.5f, 0.0f, 130, 0.026f, 13), + Lis("damped-3:2", 3f, 2f, 0.2f, 0.012f, 150, 0.045f, 14), + Lis("damped-4:7", 4f, 7f, 0.6f, 0.015f, 150, 0.045f, 13), +) + +fun main() { + println("seed=$SEED") + val master = Random(SEED) + val gart = Gart.of("lissaInk", WIDTH, HEIGHT) + val d = gart.d + val cx = d.cx; val cy = d.cy + val amp = d.h * 0.46f + val iterations = 1400 + val tStep = 0.01f + + VARIANTS.forEachIndexed { vi, cfg -> + val rng = Random(master.nextLong()) + val p0 = rng.nextDouble(-PI, PI).toFloat() + val buf = gart.gartvas() + val c = buf.canvas + // Nested concentric Lissajous: scale grows small->full across copies, so the + // teal (inner) and purple (outer) colour bands separate radially and both read. + repeat(cfg.copies) { k -> + val frac = k.toFloat() / (cfg.copies - 1).coerceAtLeast(1) + val s = amp * (0.22f + 0.78f * frac) + val dp = p0 + k * cfg.phaseStep + val color = when { + frac < 0.42f -> Ink.TEAL + frac < 0.58f -> Ink.WHITE + else -> Ink.PURPLE + } + val al = if (color == Ink.PURPLE) (cfg.alpha * 1.8f).toInt() else cfg.alpha + val paint = Ink.stroke(color, al, 1f) + var prev: Point? = null + var t = 0f + repeat(iterations) { + val e = if (cfg.decay > 0f) exp(-cfg.decay * t) else 1f + val pt = Point( + cx + s * e * sin(cfg.a * t + cfg.phase + dp), + cy + s * e * sin(cfg.b * t), + ) + prev?.let { c.drawLine(it, pt, paint) } + prev = pt + t += tStep + } + } + val finalv = Ink.finish(gart, buf, 0.09f) + gart.saveImage(finalv, "lissaInk${vi + 1}.png") + println(" lissaInk${vi + 1}.png (${cfg.tag})") + } + println("done") +} diff --git a/arts/gen/src/gen/PackInk.kt b/arts/gen/src/gen/PackInk.kt new file mode 100644 index 00000000..c358768c --- /dev/null +++ b/arts/gen/src/gen/PackInk.kt @@ -0,0 +1,72 @@ +package gen + +import dev.oblac.gart.Gart +import org.jetbrains.skia.PaintStrokeCap +import kotlin.math.min +import kotlin.math.sqrt +import kotlin.random.Random + +// 16:9 — GART_SIZE sets HEIGHT; width derived. +private val HEIGHT: Int = System.getProperty("GART_SIZE")?.toIntOrNull() ?: 1080 +private val WIDTH: Int = HEIGHT * 16 / 9 +private val SEED: Long = System.getProperty("GART_SEED")?.toLongOrNull() ?: Random.nextLong() + +/** Circle packing — largest-fit non-overlapping circles drawn as nested glowing rings. */ +private class Pak( + val tag: String, val target: Int, val minR: Float, val maxR: Float, + val rings: Int, val width: Float, val alpha: Int, +) + +private val VARIANTS = listOf( + Pak("big", 60, 24f, 240f, 4, 2.4f, 95), + Pak("dense", 340, 7f, 130f, 2, 1.6f, 80), + Pak("nested", 150, 13f, 180f, 6, 1.9f, 78), +) + +private class C(val x: Float, val y: Float, val r: Float) + +fun main() { + println("seed=$SEED") + val master = Random(SEED) + val gart = Gart.of("packInk", WIDTH, HEIGHT) + val d = gart.d + val w = d.w.toFloat(); val h = d.h.toFloat() + val margin = h * 0.05f + + VARIANTS.forEachIndexed { vi, cfg -> + val rng = Random(master.nextLong()) + val circles = ArrayList() + var attempts = 0 + val maxAttempts = cfg.target * 500 + while (circles.size < cfg.target && attempts < maxAttempts) { + attempts++ + val x = (margin + rng.nextFloat() * (w - 2 * margin)) + val y = (margin + rng.nextFloat() * (h - 2 * margin)) + var r = min(min(x - margin, w - margin - x), min(y - margin, h - margin - y)) + for (c in circles) { + val gap = sqrt((x - c.x) * (x - c.x) + (y - c.y) * (y - c.y)) - c.r - 2f + if (gap < r) r = gap + if (r < cfg.minR) break + } + if (r >= cfg.minR) circles.add(C(x, y, min(r, cfg.maxR))) + } + val buf = gart.gartvas() + val c = buf.canvas + circles.forEachIndexed { i, circ -> + val color = when { + i % 6 == 0 -> Ink.WHITE + i % 2 == 0 -> Ink.TEAL + else -> Ink.PURPLE + } + val a = if (color == Ink.PURPLE) (cfg.alpha * 1.7f).toInt() else cfg.alpha + val paint = Ink.stroke(color, a, cfg.width).apply { strokeCap = PaintStrokeCap.ROUND } + for (k in 1..cfg.rings) { + c.drawCircle(circ.x, circ.y, circ.r * k / cfg.rings, paint) + } + } + val finalv = Ink.finish(gart, buf, 0.09f) + gart.saveImage(finalv, "packInk${vi + 1}.png") + println(" packInk${vi + 1}.png (${cfg.tag}, n=${circles.size})") + } + println("done") +} diff --git a/arts/gen/src/gen/PlasmaInk.kt b/arts/gen/src/gen/PlasmaInk.kt new file mode 100644 index 00000000..86dbe5ba --- /dev/null +++ b/arts/gen/src/gen/PlasmaInk.kt @@ -0,0 +1,70 @@ +package gen + +import dev.oblac.gart.Gart +import dev.oblac.gart.Gartmap +import dev.oblac.gart.shader.createNoiseGrainFilter +import kotlin.math.cos +import kotlin.math.sin +import kotlin.math.sqrt +import kotlin.random.Random +import org.jetbrains.skia.Paint + +// 16:9 — GART_SIZE sets HEIGHT; width derived. +private val HEIGHT: Int = System.getProperty("GART_SIZE")?.toIntOrNull() ?: 1080 +private val WIDTH: Int = HEIGHT * 16 / 9 +private val SEED: Long = System.getProperty("GART_SEED")?.toLongOrNull() ?: Random.nextLong() + +/** + * Plasma — a per-pixel sum-of-sines field mapped through a fiuto colour ramp + * (navy → purple → teal → white → …). High variance via random frequencies/phases per + * image. A light noise-grain pass adds texture. Not stroke-based, so it skips the bloom. + */ +fun main() { + println("seed=$SEED") + val master = Random(SEED) + val gart = Gart.of("plasmaInk", WIDTH, HEIGHT) + val d = gart.d + val w = d.w; val h = d.h + val cx = w / 2f; val cy = h / 2f + val scale = 1f / (h * 0.18f) + + repeat(10) { vi -> + val rng = Random(master.nextLong()) + val f1x = rng.f(0.4f, 1.6f); val f1y = rng.f(0.4f, 1.6f); val p1 = rng.f(0f, 6.28f) + val f2 = rng.f(0.6f, 2.4f); val p2 = rng.f(0f, 6.28f) + val f3 = rng.f(0.5f, 2.0f); val p3 = rng.f(0f, 6.28f) + val f4 = rng.f(0.8f, 3.0f); val p4 = rng.f(0f, 6.28f) + val warp = rng.f(0.6f, 2.6f) + val cycles = rng.f(1.0f, 2.3f) + + val gm = Gartmap(d) + val px = gm.pixels + var idx = 0 + for (y in 0 until h) { + val yy = (y - cy) * scale + for (x in 0 until w) { + val xx = (x - cx) * scale + val r = sqrt(xx * xx + yy * yy) + var v = sin(xx * f1x + p1) + sin(yy * f1y + p1) + v += sin((xx + yy) * f2 + p2) + v += sin(r * f4 * warp + p4) + v += cos((xx * cos(p3) - yy * sin(p3)) * f3 + p3) + val tt = ((v / 4f) * 0.5f + 0.5f) * cycles + px[idx++] = Ink.ramp(Ink.PLASMA_STOPS, tt - tt.toInt().toFloat()) + } + } + + val g = gart.gartvas() + gm.drawToCanvas(g) + gm.close() + val finalv = gart.gartvas() + finalv.canvas.drawImage(g.snapshot(), 0f, 0f, Paint().apply { + imageFilter = createNoiseGrainFilter(0.06f, d) + }) + gart.saveImage(finalv, "plasmaInk${vi + 1}.png") + println(" plasmaInk${vi + 1}.png") + } + println("done") +} + +private fun Random.f(a: Float, b: Float) = a + nextFloat() * (b - a) diff --git a/out/flowInk1.png b/out/flowInk1.png new file mode 100644 index 00000000..d8d5f6ee Binary files /dev/null and b/out/flowInk1.png differ diff --git a/out/flowInk2.png b/out/flowInk2.png new file mode 100644 index 00000000..c9167954 Binary files /dev/null and b/out/flowInk2.png differ diff --git a/out/flowInk3.png b/out/flowInk3.png new file mode 100644 index 00000000..b13271eb Binary files /dev/null and b/out/flowInk3.png differ diff --git a/out/growInk1.png b/out/growInk1.png new file mode 100644 index 00000000..bd911309 Binary files /dev/null and b/out/growInk1.png differ diff --git a/out/growInk2.png b/out/growInk2.png new file mode 100644 index 00000000..41ca63c9 Binary files /dev/null and b/out/growInk2.png differ diff --git a/out/growInk3.png b/out/growInk3.png new file mode 100644 index 00000000..71e404e3 Binary files /dev/null and b/out/growInk3.png differ diff --git a/out/lissaInk1.png b/out/lissaInk1.png new file mode 100644 index 00000000..de611085 Binary files /dev/null and b/out/lissaInk1.png differ diff --git a/out/lissaInk10.png b/out/lissaInk10.png new file mode 100644 index 00000000..d473a4ad Binary files /dev/null and b/out/lissaInk10.png differ diff --git a/out/lissaInk2.png b/out/lissaInk2.png new file mode 100644 index 00000000..3933916a Binary files /dev/null and b/out/lissaInk2.png differ diff --git a/out/lissaInk3.png b/out/lissaInk3.png new file mode 100644 index 00000000..3eaa9be7 Binary files /dev/null and b/out/lissaInk3.png differ diff --git a/out/lissaInk4.png b/out/lissaInk4.png new file mode 100644 index 00000000..6fd25e66 Binary files /dev/null and b/out/lissaInk4.png differ diff --git a/out/lissaInk5.png b/out/lissaInk5.png new file mode 100644 index 00000000..698fd375 Binary files /dev/null and b/out/lissaInk5.png differ diff --git a/out/lissaInk6.png b/out/lissaInk6.png new file mode 100644 index 00000000..31c9fe8e Binary files /dev/null and b/out/lissaInk6.png differ diff --git a/out/lissaInk7.png b/out/lissaInk7.png new file mode 100644 index 00000000..0e5f9799 Binary files /dev/null and b/out/lissaInk7.png differ diff --git a/out/lissaInk8.png b/out/lissaInk8.png new file mode 100644 index 00000000..08726754 Binary files /dev/null and b/out/lissaInk8.png differ diff --git a/out/lissaInk9.png b/out/lissaInk9.png new file mode 100644 index 00000000..b844f5c5 Binary files /dev/null and b/out/lissaInk9.png differ diff --git a/out/packInk1.png b/out/packInk1.png new file mode 100644 index 00000000..6288a4fa Binary files /dev/null and b/out/packInk1.png differ diff --git a/out/packInk2.png b/out/packInk2.png new file mode 100644 index 00000000..29c95962 Binary files /dev/null and b/out/packInk2.png differ diff --git a/out/packInk3.png b/out/packInk3.png new file mode 100644 index 00000000..236ae775 Binary files /dev/null and b/out/packInk3.png differ diff --git a/out/plasmaInk1.png b/out/plasmaInk1.png new file mode 100644 index 00000000..9e0a1fb7 Binary files /dev/null and b/out/plasmaInk1.png differ diff --git a/out/plasmaInk10.png b/out/plasmaInk10.png new file mode 100644 index 00000000..1d6393fd Binary files /dev/null and b/out/plasmaInk10.png differ diff --git a/out/plasmaInk2.png b/out/plasmaInk2.png new file mode 100644 index 00000000..a4156fc5 Binary files /dev/null and b/out/plasmaInk2.png differ diff --git a/out/plasmaInk3.png b/out/plasmaInk3.png new file mode 100644 index 00000000..23559dfa Binary files /dev/null and b/out/plasmaInk3.png differ diff --git a/out/plasmaInk4.png b/out/plasmaInk4.png new file mode 100644 index 00000000..56d000e2 Binary files /dev/null and b/out/plasmaInk4.png differ diff --git a/out/plasmaInk5.png b/out/plasmaInk5.png new file mode 100644 index 00000000..1c1cb733 Binary files /dev/null and b/out/plasmaInk5.png differ diff --git a/out/plasmaInk6.png b/out/plasmaInk6.png new file mode 100644 index 00000000..bca89375 Binary files /dev/null and b/out/plasmaInk6.png differ diff --git a/out/plasmaInk7.png b/out/plasmaInk7.png new file mode 100644 index 00000000..aec86e85 Binary files /dev/null and b/out/plasmaInk7.png differ diff --git a/out/plasmaInk8.png b/out/plasmaInk8.png new file mode 100644 index 00000000..b1ea9861 Binary files /dev/null and b/out/plasmaInk8.png differ diff --git a/out/plasmaInk9.png b/out/plasmaInk9.png new file mode 100644 index 00000000..3513b838 Binary files /dev/null and b/out/plasmaInk9.png differ