package time

import java.time.LocalTime
import org.openrndr.application
import org.openrndr.color.*
import org.openrndr.draw.*
import org.openrndr.extra.noise.filters.SimplexNoise3D
import org.openrndr.math.*
import phenax.utils.*

fun main() = application {
  recordDuration(5.seconds())

  if (recordingEnabled || screenshotEnabled) {
    configure {
      width = 1920
      height = 1080
      windowResizable = false
    }
  } else {
    configure {
      width = 640
      height = 360
      windowResizable = false
    }
  }

  oliveProgram {
    val char_size = 200.0
    val font = program.loadFont("data/fonts/default.otf", char_size)
    val cs by liveComputeShader("time")

    val outputBuffer = colorBuffer(width, height, type = ColorType.UINT8)

    val size = Math.max(width, height) * 4
    val noiseBuffer = colorBuffer(size, size, type = ColorType.UINT8)
    val noiseFilter = SimplexNoise3D()
    noiseFilter.scale = Vector3.ONE * 2.4
    noiseFilter.octaves = 8
    noiseFilter.premultipliedAlpha = true
    noiseFilter.seed = Vector3(0.01, 0.01, 0.001)
    noiseFilter.apply(emptyArray(), noiseBuffer)

    val characters = 0..9
    val textTarget =
            renderTarget(char_size.toInt() * characters.count(), char_size.toInt()) {
              colorBuffer(type = ColorType.UINT8)
            }

    extend {
      cs.image("noise_texture", 1, noiseBuffer.imageBinding(0, ImageAccess.READ))

      drawer.isolatedWithTarget(textTarget) {
        drawer.clear(ColorRGBa.TRANSPARENT)
        drawer.ortho(textTarget)
        drawer.fontMap = font
        drawer.fill = ColorRGBa.WHITE
        for (char in characters) {
          drawer.text(char.toString(), Vector2(char * char_size.toDouble(), char_size / 2.0 + 5))
        }
      }

      val textBuffer = textTarget.colorBuffer(0)

      cs.image("text_texture", 2, textBuffer.imageBinding(0, ImageAccess.READ))

      val time = LocalTime.now()
      cs.uniform("hours", time.getHour().toFloat())
      cs.uniform("minutes", time.getMinute().toFloat())
      cs.uniform("seconds", time.getSecond().toFloat())

      cs.uniform("time", seconds)
      cs.image("output_image", 0, outputBuffer.imageBinding(0, ImageAccess.WRITE))
      cs.execute(outputBuffer.width, outputBuffer.height, 1)
      drawer.image(outputBuffer)
    }
  }
}