ShaderReloadTransactionSmoke.kt

    @JvmStatic
    fun main(args: Array<String>) {
        Options.doVulkanSDK()
        Options.enableVR = false
        Options.validate = true
        val window = Window("Shader reload transaction")
        val renderer = Renderer(window)
        println("validation active: ${renderer.instance.validationActive}")

        val errors = mutableListOf<String>()
        val box = Box("shader-reload-transaction").apply {
            name = "shader-reload-transaction"
            output.errorProxy = { message, property, line ->
                if (message != null) errors += "$property:$line:$message"
            }
        }

        fun frames(n: Int) = repeat(n) {
            window.pollEvents()
            renderer.render()
        }

        val pointer = Module(parameters(renderer) {
            name = "shader-reload-transaction"
            vertex = VERTEX
            fragment = FRAGMENT_A
            textureResolver = { texture ->
                if (texture.name == "boom") throw IllegalStateException("smoke resolver refuses texture 'boom'")
                null
            }
        }).pointer()
        check(pointer.current.valid) { "initial module did not build: $errors" }
        renderer += "shader-reload-transaction" to pointer

        try {
            // attachShader reloads once, which writes the preamble for interface A.
            box.attachShader(pointer, overwriteProperties = true)
            check(errors.isEmpty()) { "attach reported errors: $errors" }
            val moduleA = pointer.current
            val preambleA = box.preamble
            check("graphics-pc-structure:tintA" in preambleA) { "preamble lacks tintA after attach:\n$preambleA" }
            val preparedA = box._fragment
            frames(4)

            // 1. compile error
            box.setPropertyRaw("fragment", FRAGMENT_COMPILE_ERROR)
            check(!reloadShader(box)) { "a compile error reported success" }
            check(pointer.current === moduleA && moduleA.valid) { "a compile error replaced or invalidated the module" }
            check(box.preamble == preambleA) { "a compile error rewrote the preamble:\n${box.preamble}" }
            check(box._fragment == preparedA) { "a compile error left the failed source as the prepared stage" }
            check(errors.any { it.startsWith("fragment:") }) { "no compile error on the fragment property: $errors" }
            println("1. compile error: kept module, kept preamble, error ${errors.first { it.startsWith("fragment:") }.lines().first()}")
            errors.clear()
            frames(4)

            // 2. compiles, but the module cannot be built
            box.setPropertyRaw("fragment", FRAGMENT_UNRESOLVABLE)
            check(!reloadShader(box)) { "a module that could not be built reported success" }
            check(pointer.current === moduleA && moduleA.valid) { "a failed module build replaced or invalidated the module" }
            check(box.preamble == preambleA) { "a failed module build rewrote the preamble:\n${box.preamble}" }
            check("tintB" !in box.preamble) { "preamble describes an interface that never went live" }
            check(box._fragment == preparedA) { "a failed module build left its source as the prepared stage" }
            val buildError = errors.firstOrNull { it.startsWith("code:") && "smoke resolver refuses texture 'boom'" in it }
            checkNotNull(buildError) { "the resolver's reason did not reach the box's code property: $errors" }
            check("previous module is still running" in buildError) { "the error does not say the reload did not happen: $buildError" }
            println("2. module build failure: kept module, kept preamble, error ${buildError.lines().first()}")
            errors.clear()
            frames(4)

            // 3. success with a changed interface
            box.setPropertyRaw("fragment", FRAGMENT_B)
            check(reloadShader(box)) { "a good reload failed: $errors" }
            val moduleB = pointer.current
            check(moduleB !== moduleA && moduleB.valid) { "a good reload did not install a new module" }
            check("graphics-pc-structure:tintB" in box.preamble) { "preamble lacks tintB:\n${box.preamble}" }
            check("graphics-pc-structure:tintA" !in box.preamble) { "preamble still describes tintA:\n${box.preamble}" }
            check(!moduleA.valid) { "the replaced module was not retired" }
            check(moduleA.pipeline != 0L) { "the replaced module's pipeline was destroyed synchronously, under frames in flight" }
            var waited = 0
            while (moduleA.pipeline != 0L && waited < 200) {
                frames(1)
                waited++
            }
            check(moduleA.pipeline == 0L) { "the replaced module's pipeline was never destroyed through the retirement queue" }
            check(errors.isEmpty()) { "a good reload reported errors: $errors" }
            println("3. interface change: new module live, preamble updated, old pipeline retired after $waited frame(s)")
        } finally {
            try {
                pointer.current.cleanup()
                renderer.cleanup()
            } finally {
                window.cleanup()
            }
        }
        println("shader reload transaction PASSED")
        exitProcess(0)
    }
}