StackSLGpu.kt

    override fun render(program: String, size: Int, seconds: List<Double>, each: (index: Int, raster: CpuRaster) -> Unit) {
        val renderer = rendererOf()
        val reason = when {
            renderer == null -> "no renderer: launch the window box"
            renderer.isClosed -> "the window's renderer is closed"
            Runloop.isMainThread -> "called on the main thread, which is the one that draws"
            else -> null
        }
        if (reason != null) {
            description = "CPU reference ($reason)"
            return fallback.render(program, size, seconds, each)
        }
        var done = 0
        try {
            synchronized(lock) {
                gpuRender(renderer!!, program, size, seconds) { i, raster -> each(i, raster); done = i + 1 }
            }
            description = "GPU (${renderer!!.physicalDevice.deviceName})"
        } catch (e: Unavailable) {
            description = "CPU reference (GPU: ${e.message})"
            fallback.render(program, size, seconds.drop(done)) { i, raster -> each(done + i, raster) }
        }
    }

    private fun gpuRender(renderer: Renderer, program: String, size: Int, seconds: List<Double>, each: (Int, CpuRaster) -> Unit) {
        var target: RenderToTexture? = null
        var failure: String? = null
        onMain {
            try {
                val t = targetFor(renderer, size)
                if (builtFrom[size] == program && t.modules[MODULE]?.current?.valid == true) {
                    renderer.renderList.preTargets[TARGET] = t
                    target = t
                    return@onMain
                }
                templateBox.stackAutoShaderSources["program"] = program
                val fragment = preprocess(templateBox, StackSLStudyShader.RAW_FRAGMENT, ShaderKind.FRAGMENT_SHADER)
                var error: String? = null
                val built = Module(parameters(renderer) {
                    name = MODULE
                    vertex = StackSLStudyShader.VERTEX
                    this.fragment = fragment
                    blend = false
                    depthTest = false
                    +t
                    errorHandler = { message, _ -> error = message }
                }).pointer()
                if (!built.current.valid) throw Unavailable("the GPU shader did not build: ${error ?: "unknown error"}")
                val mesh = Mesh(renderer, built)
                mesh.resize(3, 0, built)
                built.current.meshes[MESH] = mesh
                mesh.push.bind("params") { vec(time, 0f, 0f, 0f) }
                val previous = t.modules[MODULE]
                t += MODULE to built
                // A command buffer in flight may still use the old pipeline: retire it through the
                // renderer's deferred queue, which runs once those frames have completed.
                previous?.takeIf { it !== built }?.let { old -> renderer.cleanup.add(Runnable { dispose(old) }) }
                renderer.renderList.preTargets[TARGET] = t
                builtFrom[size] = program
                target = t
            } catch (e: Unavailable) {
                failure = e.message
            } catch (e: Exception) {
                failure = "the GPU shader did not build: ${e.message}"
            }
        }
        failure?.let { throw Unavailable(it) }
        val t = target!!
        try {
            seconds.forEachIndexed { i, s ->
                time = s.toFloat()
                awaitFrame(renderer)
                val bytes = try {
                    t.readPixelsAsync().get(frameTimeoutMs, TimeUnit.MILLISECONDS)
                } catch (e: java.util.concurrent.TimeoutException) {
                    throw Unavailable("the window stopped drawing (hidden or minimised?)")
                }
                each(i, toRaster(bytes, size))
            }
        } finally {
            // The module stays built (and idle) for the next request; only the drawing stops.
            onMain { renderer.renderList.preTargets.remove(TARGET) }
        }
    }

    private fun awaitFrame(renderer: Renderer) {
        val start = renderer.frameCounter
        val deadline = System.nanoTime() + frameTimeoutMs * 1_000_000
        while (renderer.frameCounter <= start) {
            if (renderer.isClosed) throw Unavailable("the window's renderer closed")
            if (System.nanoTime() > deadline) throw Unavailable("the window stopped drawing (hidden or minimised?)")
            Thread.sleep(1)
        }
    }

    private fun targetFor(renderer: Renderer, size: Int): RenderToTexture {
        if (targetsFor !== renderer) {
            targets.clear() // the old renderer's targets died with it
            builtFrom.clear()
            targetsFor = renderer
        }
        targets[size]?.let { return it }
        if (targets.size >= MAX_TARGETS) {
            val oldest = targets.keys.first()
            targets.remove(oldest)?.let { old -> renderer.cleanup.add(Runnable { disposeTarget(old) }) }
            builtFrom.remove(oldest)
        }
        val created = RenderToTexture(renderer) {
            width = size
            height = size
            format = VK_FORMAT_R32G32B32A32_SFLOAT
            useDepth = false
            colorSampled = true
            colorTransferSrc = true
            clearColor = vec(0f, 0f, 0f, 0f)
            debugName = "stacksl-study-$size"
        }
        targets[size] = created
        return created
    }

    private fun toRaster(bytes: ByteArray, size: Int): CpuRaster {
        val floats = FloatArray(size * size * 4)
        val buffer = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).asFloatBuffer()
        require(buffer.remaining() >= floats.size) { "readback held ${buffer.remaining()} floats, expected ${floats.size}" }
        buffer.get(floats)
        return CpuRaster(size, size, floats)
    }

    private fun dispose(module: ModulePointer) {
        runCatching {
            module.current.meshes.values.toSet().forEach { mesh ->
                (mesh.v.values + mesh.vn.values).toSet().forEach { it.cleanup() }
                mesh.t?.cleanup()
            }
            module.current.meshes.clear()
            module.current.cleanup()
        }
    }

    private fun disposeTarget(rtt: RenderToTexture) {
        runCatching {
            rtt.modules.values.forEach(::dispose)
            rtt.modules.clear()
            rtt.defaultSampler?.cleanup()
            rtt.imageViewArray.map { it.imageView }.distinctBy { it.vkImageView }.forEach { it.cleanup() }
            rtt.colorImageRefs.filterNotNull().distinctBy { it.vkImage }.forEach { it.cleanup() }
            rtt.commandBuffers.forEach { it.cleanup() }
            rtt.fences.forEach { it.cleanup() }
        }
    }
}