🖼️ Artwork 01. Recursive Lines

OPENRNDR Code

import org.openrndr.application
import org.openrndr.color.ColorRGBa
import org.openrndr.math.Vector2
import kotlin.math.*
import kotlin.random.Random

data class LineSegment(
    val start: Vector2,
    val direction: Vector2,
    val length: Double,
    val birthTime: Double,
    val lifetime: Double = 2.0,
    val depth: Int = 0,
    val fadeInDuration: Double = 1.5
)

data class Branch(
    val startPoint: Vector2,
    val lines: MutableList<LineSegment> = mutableListOf(),
    val birthTime: Double,
    val fadeInDuration: Double = 1.5
)

fun getLineAlpha(age: Double, lifetime: Double, fadeInDuration: Double): Double {
    return when {
        age < fadeInDuration -> age / fadeInDuration
        age < lifetime -> 1.0
        else -> {
            val fadeOutDuration = 1.5
            val fadeOutAge = age - lifetime
            (1.0 - (fadeOutAge / fadeOutDuration)).coerceIn(0.0, 1.0)
        }
    }
}

fun main() = application {
    configure {
        width = 1000
        height = 1000
        title = "Interactive Recursive Lines"
    }

    program {
        val branches = mutableListOf<Branch>()
        var currentTime = 0.0
        val maxDepth = 2

        mouse.buttonDown.listen { event ->
            val clickPos = event.position
            val newBranch = Branch(clickPos, mutableListOf(), currentTime)

            val lineCount = Random.nextInt(13, 16)
            repeat(lineCount) {
                val angle = (it.toDouble() / lineCount) * 2 * PI + Random.nextDouble(-0.2, 0.2)
                val direction = Vector2(cos(angle), sin(angle))
                val lineLength = Random.nextDouble(40.0, 60.0)

                newBranch.lines.add(
                    LineSegment(
                        start = clickPos,
                        direction = direction,
                        length = lineLength,
                        birthTime = currentTime,
                        depth = 0
                    )
                )
            }

            branches.add(newBranch)
        }

        extend {
            drawer.clear(ColorRGBa.BLACK)

            currentTime += 0.016

            drawer.stroke = ColorRGBa.WHITE
            drawer.strokeWeight = 1.2
            drawer.fill = ColorRGBa.WHITE

            val linesToRemove = mutableListOf<Pair<Branch, LineSegment>>()
            val newLines = mutableListOf<LineSegment>()

            // 라인 그리기
            for (branch in branches) {
                for (line in branch.lines) {
                    val age = currentTime - line.birthTime

                    // 라인의 알파값 계산 (페이드 인 → 유지 → 페이드 아웃)
                    val alpha = getLineAlpha(age, line.lifetime, line.fadeInDuration)

                    if (alpha > 0.0) {
                        drawer.stroke = ColorRGBa(1.0, 1.0, 1.0, alpha)

                        val endPoint = line.start + line.direction * line.length

                        // 라인 그리기
                        drawer.lineSegment(line.start, endPoint)

                        // 끝점 점 그리기
                        drawer.fill = ColorRGBa(1.0, 1.0, 1.0, alpha)
                        drawer.circle(endPoint, 1.5)

                        // 분기 생성 조건
                        if (line.depth < maxDepth && age > line.lifetime * 0.35 && age <= line.lifetime * 0.36) {
                            val branchCount = Random.nextInt(2, 4)
                            repeat(branchCount) {
                                val childAngle = atan2(line.direction.y, line.direction.x) +
                                        Random.nextDouble(-PI / 4, PI / 4)
                                val childDirection = Vector2(cos(childAngle), sin(childAngle))
                                val childLength = line.length * Random.nextDouble(0.6, 0.75)

                                newLines.add(
                                    LineSegment(
                                        start = endPoint,
                                        direction = childDirection,
                                        length = childLength,
                                        birthTime = currentTime,
                                        depth = line.depth + 1
                                    )
                                )
                            }
                        }
                    }

                    // 라인이 완전히 사라졌을 때 제거
                    if (age > line.lifetime + 0.3) {
                        linesToRemove.add(branch to line)
                    }
                }
            }

            // 완료된 라인 제거
            for ((branch, line) in linesToRemove) {
                branch.lines.remove(line)
            }

            // 새로운 라인들 추가
            if (newLines.isNotEmpty()) {
                val existingBranches = branches.filter { it.lines.isNotEmpty() }
                if (existingBranches.isNotEmpty()) {
                    existingBranches.last().lines.addAll(newLines)
                }
            }

            // 시작점 그리기 (페이드 인/아웃)
            drawer.fill = ColorRGBa.WHITE
            drawer.stroke = null

            val branchesToRemove = mutableListOf<Branch>()

            for (branch in branches) {
                val branchAge = currentTime - branch.birthTime

                // 시작점의 알파값 계산
                val branchAlpha = if (branch.lines.isNotEmpty()) {
                    // 라인이 있으면: 페이드 인 → 유지
                    when {
                        branchAge < branch.fadeInDuration -> branchAge / branch.fadeInDuration
                        else -> 1.0
                    }
                } else {
                    // 라인이 없으면: 페이드 아웃 (라인이 모두 사라진 후 1초)
                    val fadeOutStartTime = branch.birthTime + 1.5 + 0.3  // lifetime + fadeOut
                    val fadeOutDuration = 1.0

                    if (currentTime < fadeOutStartTime + fadeOutDuration) {
                        val fadeProgress = ((currentTime - fadeOutStartTime) / fadeOutDuration).coerceIn(0.0, 1.0)
                        (1.0 - fadeProgress).coerceIn(0.0, 1.0)
                    } else {
                        0.0
                    }
                }

                if (branchAlpha > 0.0) {
                    drawer.fill = ColorRGBa(1.0, 1.0, 1.0, branchAlpha)
                    drawer.circle(branch.startPoint, 3.5)
                } else if (branchAlpha == 0.0 && branch.lines.isEmpty()) {
                    // 알파가 0이 되면 브랜치 제거
                    branchesToRemove.add(branch)
                }
            }

            branches.removeAll(branchesToRemove)
        }
    }
}