package afield.graphics.render

import afield.app.diagnostics.LatencySpans
import afield.graphics.vulkan.targets.HasRenderToTexture
import afield.graphics.scene.main

import afield.document.context.fromContext
import afield.document.context.fromContextWithNameOrNull
import afield.graphics.shader.CompilerError
import afield.graphics.shader.Introspected
import afield.graphics.shader.Introspection
import afield.graphics.shader.ShaderIncludeResolver
import afield.graphics.shader.ShaderKind
import afield.graphics.shader.graphicsShaderInterfaceTransition

import afield.graphics.vulkan.device.vkLayout
import afield.app.diagnostics.Named
import afield.app.protocol.Rect
import afield.graphics.vulkan.Renderer
import afield.graphics.vulkan.Target
import afield.graphics.vulkan.buffers.*
import afield.graphics.vulkan.device.*
import afield.graphics.vulkan.device.DescriptorSetLayout.SimpleDescriptorSetLayout
import afield.graphics.shader.Introspected.Bindable
import afield.graphics.vulkan.targets.MultiPingPongRenderToTexture
import afield.graphics.vulkan.targets.RenderToTexture
import afield.graphics.texture.HasDefaultTextureSampler
import afield.graphics.texture.HasImageView
import afield.graphics.texture.HasImageViewArray
import afield.graphics.texture.ImageView
import afield.graphics.texture.PreparesSampledImages
import afield.graphics.texture.TextureSampler
import afield.graphics.vulkan.util.AutoDisposer
import afield.graphics.vulkan.util.FIELD_PROBE_BUFFER_NAME
import afield.graphics.vulkan.util.Options
import afield.graphics.vulkan.util.ShaderFieldStatsBinding
import afield.graphics.vulkan.util.ShaderFieldProbe
import afield.graphics.vulkan.util.vkCheck
import afield.app.diagnostics.logging.lprintln
import afield.math.linalg.Vec4
import afield.math.linalg.f
import afield.math.linalg.Rectanglef
import org.lwjgl.system.MemoryStack
import org.lwjgl.system.MemoryUtil
import org.lwjgl.vulkan.*
import org.lwjgl.vulkan.KHRPushDescriptor.vkCmdPushDescriptorSetKHR
import org.lwjgl.vulkan.VK13.*
import java.nio.ByteBuffer
import kotlin.reflect.KProperty

data class Parameters(
    val renderer: Renderer,
    var vertex: String = "",
    var fragment: String = "",
    var compute: String = "",
    var mesh: String = "",
    var task: String = "",
    var raygen: String = "",
    var miss: String = "",
    var closesthit: String = "",
    var anyhit: String = "",
    var intersection: String = "",
    var callable: String = "",
    var vertexIntrospection: Introspection? = null,
    var fragmentIntrospection: Introspection? = null,
    var computeIntrospection: Introspection? = null,
    var meshIntrospection: Introspection? = null,
    var taskIntrospection: Introspection? = null,
    var raygenIntrospection: Introspection? = null,
    var missIntrospection: Introspection? = null,
    var closesthitIntrospection: Introspection? = null,
    var anyhitIntrospection: Introspection? = null,
    var intersectionIntrospection: Introspection? = null,
    var callableIntrospection: Introspection? = null,
    var vertexSourceName: String = "vertex.glsl",
    var fragmentSourceName: String = "fragment.glsl",
    var computeSourceName: String = "compute.glsl",
    var meshSourceName: String = "mesh.glsl",
    var taskSourceName: String = "task.glsl",
    var raygenSourceName: String = "raygen.rgen",
    var missSourceName: String = "miss.rmiss",
    var closesthitSourceName: String = "closesthit.rchit",
    var anyhitSourceName: String = "anyhit.rahit",
    var intersectionSourceName: String = "intersection.rint",
    var callableSourceName: String = "callable.rcall",
    var vertexIncludeResolver: ShaderIncludeResolver? = null,
    var fragmentIncludeResolver: ShaderIncludeResolver? = null,
    var computeIncludeResolver: ShaderIncludeResolver? = null,
    var meshIncludeResolver: ShaderIncludeResolver? = null,
    var taskIncludeResolver: ShaderIncludeResolver? = null,
    var raygenIncludeResolver: ShaderIncludeResolver? = null,
    var missIncludeResolver: ShaderIncludeResolver? = null,
    var closesthitIncludeResolver: ShaderIncludeResolver? = null,
    var anyhitIncludeResolver: ShaderIncludeResolver? = null,
    var intersectionIncludeResolver: ShaderIncludeResolver? = null,
    var callableIncludeResolver: ShaderIncludeResolver? = null,
    var color: Int = 1,
    var colorFormats: List<Int> = emptyList(),
    var depth: Int = 1,
    var depthFormat: Int = Options.defaultDepthFormat,
    var primitiveType: Int = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
    var textureResolver: (Introspected.Texture) -> Pair<HasImageViewArray, TextureSampler>? = {
        lprintln("warning,graphics", "Cannot resolve texture ${it.name}")
        null
    },
    var uboResolver: (BufferParameters) -> BufferParameters? = {
        val lb = linkBuffer(it.name, it)
        lb.second
    },
    var ssboResolver: (BufferParameters) -> BufferParameters? = {
        val lb = linkBuffer(it.name, it)
        lb.second
    },
    var ssboSizer: (Introspected.UBO) -> Int? = { 0 },
    var imageResolver: (Introspected.Image) -> ImageView? = {
        lprintln("warning,graphics", "Cannot resolve image ${it.name}")
//        throw Exception("Cannot resolve image ${it.name}")
        null
    },
    var accelerationStructureResolver: (Introspected.AccelerationStructure) -> HasAccelerationStructure? = {
        val found = fromContextWithNameOrNull<HasAccelerationStructure>(it.name)
        if (found == null) lprintln("warning,graphics", "Cannot resolve acceleration structure ${it.name}")
        found
    },
    var rayTracingGroups: RayTracingGroups? = null,
    var maxRayRecursionDepth: Int = 1,
    var rayTracingPipelineFlags: Int = 0,
    /** Explicit pipeline opt-in for NV cluster geometry. Baseline pipelines need no extension. */
    var allowClusterAccelerationStructure: Boolean = false,
    var name: String = "unnamed module",
    var errorHandler: (String, Throwable?) -> Unit = { desc, it ->
        lprintln("error,graphics", "error $desc while creating Module: $it")
        it?.let { ex -> lprintln("error,graphics", ex.stackTraceToString()) }
    },
    var colorMask: Array<Boolean> = arrayOf(true, true, true, true),
    var blend: Boolean = true,
    var srcColor: Int = VK_BLEND_FACTOR_SRC_ALPHA,
    var dstColor: Int = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
    var colorBlendOp: Int = VK_BLEND_OP_ADD,
    var srcAlpha: Int = VK_BLEND_FACTOR_SRC_ALPHA,
    var dstAlpha: Int = VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA,
    var alphaBlendOp: Int = VK_BLEND_OP_ADD,
    var depthTest: Boolean = true,
    var depthWrite: Boolean = true,
    var depthCompareOp: Int = VK_COMPARE_OP_LESS_OR_EQUAL,
    var viewport: Rect? = null,
    var viewportCount: Int = 1,
    var viewMask: Int = 0,
    var fillMode: Int = VK_POLYGON_MODE_FILL,
    var imageFormat: Int = renderer.swapChain.surfaceFormat.imageFormat,
    val labelColor: Vec4 = Vec4(0.15f, 0.45f, 0.85f, 1f),
    var fieldProbe: ShaderFieldProbe? = null,
    var fieldStats: ShaderFieldStatsBinding? = null

) {

    fun reload(
        p: Parameters, forceReresolve: Boolean = true, onError: (String, Throwable?) -> Unit = p.errorHandler
    ): Boolean {
        if (current.valid && p == current.parameters && !forceReresolve) return false
        p.errorHandler = onError

        // Known before the build when the caller introspected (every box reload does), so a renamed block
        // can keep its buffer; otherwise worked out from the built module below.
        val nv = p.vertexIntrospection
        val nf = p.fragmentIntrospection
        val before = if (nv != null && nf != null) runCatching {
            graphicsShaderInterfaceTransition(current.vi, current.fi, nv, nf)
        }.getOrNull() else null

        p.uboResolver = reloadWrap(p.uboResolver) { oUboResolver, it ->
            ReloadCarryOver.ubo(current.uniforms, before, it, oUboResolver)
        }

        p.ssboResolver = reloadWrap(p.ssboResolver) { oSsboResolver, it ->
            val prev = current.uniforms[it.name]
            if (prev == null) oSsboResolver(it) else {
                val prevSrc = prev.source
                if (prevSrc == null) oSsboResolver(it)
                else if (prevSrc.checkCompatibility(it) == false) oSsboResolver(it)
                else oSsboResolver(prevSrc)
            }
        }

        p.textureResolver = reloadWrap(p.textureResolver) { oTextureResolver, it ->
            if (forceReresolve) {
                val oo = oTextureResolver(it)
                if (oo != null) oo
                else when (val uniform = current.uniforms[it.name]) {
                    is Module.TexturePointer -> uniform.texture to uniform.sampler
                    is Module.TextureArrayPointer -> uniform.texture to uniform.sampler
                    else -> {
                        lprintln("warning,graphics", "couldn't transfer over texture ${it.name}, falling back to originating resolution")
                        oTextureResolver(it)
                    }
                }
            } else try {
                when (val uniform = current.uniforms[it.name]) {
                    is Module.TexturePointer -> uniform.texture to uniform.sampler
                    is Module.TextureArrayPointer -> uniform.texture to uniform.sampler
                    else -> throw IllegalStateException("unsupported texture uniform type ${uniform?.javaClass}")
                }
            } catch (_: Exception) {
                lprintln("warning,graphics", "couldn't transfer over texture ${it.name}, falling back to originating resolution")
                oTextureResolver(it)
            }
        }

        val m = Module(p)
        if (m.valid) {
            val previous = current
            m.copyMeshesFrom(previous)
            m.enabled = previous.enabled
            val transition = before ?: runCatching { graphicsShaderInterfaceTransition(previous.vi, previous.fi, m.vi, m.fi) }.getOrNull()
            lastReloadReport = ModuleReloadReport(
                transition,
                ReloadCarryOver.finishAndNotify(this, transition, previous.uniforms.values, m.uniforms, previous.liveUniformStructures, m.liveUniformStructures)
            )
            current = m
            // Retire the module this one replaced now rather than when the GC finds it. cleanup() stops it
            // rendering at once and defers the handle destruction through the renderer's retirement queue,
            // so a frame still recording or executing the old pipeline is not pulled out from under.
            previous.cleanup()
            return true
        }
        // A module that failed part-way may already hold a shader module or descriptor layout.
        m.cleanup()
        return false
    }

    init {
        try {
            if (!vi.valid || !fi.valid) throw IllegalStateException("Can't make a module without valid programs")

            vsm = createShaderModule(vi.code.bytecode()!!)
            fsm = createShaderModule(fi.code.bytecode()!!)

            // Name objects for tooling (if EXT_debug_utils is present)
            parameters.renderer.device.nameObject(vsm, VK10.VK_OBJECT_TYPE_SHADER_MODULE, "${parameters.name} VS")
            parameters.renderer.device.nameObject(fsm, VK10.VK_OBJECT_TYPE_SHADER_MODULE, "${parameters.name} FS")

            val setsNeeded = mutableMapOf<Int, MutableList<Int>>()

            // Build per-module sets for all sets used (including set 0)
            vi.ubos.forEach { setsNeeded.computeIfAbsent(it.set) { mutableListOf() }.add(it.binding) }
            fi.ubos.forEach { setsNeeded.computeIfAbsent(it.set) { mutableListOf() }.add(it.binding) }
            vi.ssbo.forEach { setsNeeded.computeIfAbsent(it.set) { mutableListOf() }.add(it.binding) }
            fi.ssbo.forEach { setsNeeded.computeIfAbsent(it.set) { mutableListOf() }.add(it.binding) }
            vi.textures.forEach { setsNeeded.computeIfAbsent(it.set) { mutableListOf() }.add(it.binding) }
            fi.textures.forEach { setsNeeded.computeIfAbsent(it.set) { mutableListOf() }.add(it.binding) }
            vi.images.forEach { setsNeeded.computeIfAbsent(it.set) { mutableListOf() }.add(it.binding) }
            fi.images.forEach { setsNeeded.computeIfAbsent(it.set) { mutableListOf() }.add(it.binding) }

            // --- Dedup and sort per-set bindings (fix #2)
            if (setsNeeded.isNotEmpty()) {
                val keys = setsNeeded.keys.toList()
                for (k in keys) {
                    setsNeeded[k] = setsNeeded.getValue(k).distinct().sorted().toMutableList()
                }
            }

            uniforms = mutableMapOf()
            liveUniformStructures = mutableMapOf()

            vi.ubos.forEach { liveUniformStructures[it.name] = Structure().setMembers(it.members).reportingTo(parameters) }
            fi.ubos.forEach { liveUniformStructures[it.name] = Structure().setMembers(it.members).reportingTo(parameters) }
            vi.ssbo.forEach { liveUniformStructures[it.name] = Structure().setMembers(it.members).reportingTo(parameters) }
            fi.ssbo.forEach { liveUniformStructures[it.name] = Structure().setMembers(it.members).reportingTo(parameters) }
            ModuleRebuild.created(liveUniformStructures)

            val layouts = mutableMapOf<Int, SimpleDescriptorSetLayout>()

            // Create layouts/sets for each set >= 1
            setsNeeded.entries.forEach { (set, bindingList) ->
                var where = 0
                val kinds = mutableListOf<Int>()
                val lens = mutableListOf<Int>()

                bindingList.forEach { bind ->
                    var kind = 0
                    var descriptorCount = 1

                    fun noteBinding(stageFlag: Int, descriptorType: Int, count: Int = 1) {
                        where = where or stageFlag
                        if (kind == 0) kind = descriptorType
                        else require(kind == descriptorType) {
                            "binding $bind in set $set resolves to multiple descriptor types"
                        }
                        descriptorCount = maxOf(descriptorCount, count)
                    }

                    vi.ubos.forEach {
                        if (it.set == set && it.binding == bind) {
                            noteBinding(VK_SHADER_STAGE_VERTEX_BIT, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)
                        }
                    }
                    fi.ubos.forEach {
                        if (it.set == set && it.binding == bind) {
                            noteBinding(VK_SHADER_STAGE_FRAGMENT_BIT, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER)
                        }
                    }

                    vi.ssbo.forEach {
                        if (it.set == set && it.binding == bind) {
                            noteBinding(VK_SHADER_STAGE_VERTEX_BIT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
                        }
                    }
                    fi.ssbo.forEach {
                        if (it.set == set && it.binding == bind) {
                            noteBinding(VK_SHADER_STAGE_FRAGMENT_BIT, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
                        }
                    }

                    vi.textures.forEach {
                        if (it.set == set && it.binding == bind) {
                            noteBinding(
                                VK_SHADER_STAGE_VERTEX_BIT,
                                VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
                                maxOf(1, it.arrayCount)
                            )
                        }
                    }
                    fi.textures.forEach {                      // fix #1
                        if (it.set == set && it.binding == bind) {
                            noteBinding(
                                VK_SHADER_STAGE_FRAGMENT_BIT,
                                VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
                                maxOf(1, it.arrayCount)
                            )
                        }
                    }

                    vi.images.forEach {                        // fix #1
                        if (it.set == set && it.binding == bind) {
                            noteBinding(VK_SHADER_STAGE_VERTEX_BIT, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
                        }
                    }
                    fi.images.forEach {                        // fix #1
                        if (it.set == set && it.binding == bind) {
                            noteBinding(VK_SHADER_STAGE_FRAGMENT_BIT, VK_DESCRIPTOR_TYPE_STORAGE_IMAGE)
                        }
                    }

                    if (kind == 0) throw IllegalArgumentException(" couldn't find binding $bind for set $set in $bindingList")
                    kinds.add(kind)
                    lens.add(descriptorCount)
                }

                val layout = DescriptorSetLayout.SimpleDescriptorSetLayout(
                    parameters.renderer.device, kinds, set, bindingList, where, lens, pushDescriptor = true
                )
                layouts[set] = layout
                ownedDescriptorLayouts += layout
            }

            // UBOs (sets >= 1)
            setsNeeded.entries.forEach { (set, _) ->
                var kind = 0
                val tag = mutableListOf<Introspected.Bindable>()
                vi.ubos.forEach {
                    if (it.set == set) {
                        kind = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; tag.add(it)
                    }
                }
                fi.ubos.forEach {
                    if (it.set == set) {
                        kind = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER; tag.add(it)
                    }
                }
                if (kind == 0) return@forEach

                tag.forEach {
                    var sz = (it as Introspected.UBO).size.toLong()
                    val bp = buffer(it, it.name) {
                        size = sz; source = it; uniform(); hosted()
                    }
                    val buf = ReloadCarryOver.resolve(bp, parameters.uboResolver) ?: throw IllegalArgumentException("can't link UBO ${it.name}")
                    try {
                        uniforms[it.name] = Uniform(it.name, it, source = buf, buf.toBuffer(parameters.renderer), kind)
                    } catch (_: NullPointerException) {
                        throw IllegalArgumentException("UBO ${it.name}, no longer resolves")
                    }
                }
            }

            // SSBOs (sets >= 1)
            setsNeeded.entries.forEach { (set, _) ->
                var kind = 0
                val tag = mutableListOf<Introspected.Bindable>()
                vi.ssbo.forEach {
                    if (it.set == set) {
                        kind = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; tag.add(it)
                    }
                }
                fi.ssbo.forEach {
                    if (it.set == set) {
                        kind = VK_DESCRIPTOR_TYPE_STORAGE_BUFFER; tag.add(it)
                    }
                }
                if (kind == 0) return@forEach

                tag.forEach {
                    var sz = (it as Introspected.UBO).size.toLong()
                    if (sz == 0L) sz = parameters.ssboSizer(it)?.toLong() ?: 0L
                    val bp = buffer(it, it.name) {
                        size = sz; source = it; storage(); hosted()
                    }
                    val buf = ReloadCarryOver.resolve(bp, parameters.ssboResolver)
                        ?: throw IllegalArgumentException("can't link SSBO buffer ${it.name}, resolver returned null")
                    try {
                        uniforms[it.name] = Uniform(it.name, it, source = buf, buf.toBuffer(parameters.renderer), kind)
                    } catch (_: NullPointerException) {
                        throw IllegalArgumentException("buffer ${it.name} resolved to null")
                    }
                }
            }

            // Sampled textures (sets >= 1, combined image sampler is fine for local sets)
            setsNeeded.entries.forEach { (set, _) ->
                var kind = 0
                val tag = mutableListOf<Introspected.Bindable>()
                vi.textures.forEach {
                    if (it.set == set) {
                        kind = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; tag.add(it)
                    }
                }
                fi.textures.forEach {
                    if (it.set == set) {
                        kind = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER; tag.add(it)
                    }
                }
                if (kind == 0) return@forEach

                tag.forEach {
                    val (texture, sampler) = parameters.textureResolver(it as Introspected.Texture)!!
                    val views = texture.imageViewArray
                    require(views.isNotEmpty()) { "Texture ${it.name} resolved to empty image view array" }

                    if (it.arrayCount == 0) {
                        uniforms[it.name] = TexturePointer(it.name, it, source = null, texture, sampler)
                    } else {
                        require(views.size == it.arrayCount) {
                            "can't link texture resource ${it.name} of length ${views.size} but the shader expects ${it.arrayCount}"
                        }
                        uniforms[it.name] = TextureArrayPointer(it.name, it, source = null, texture, sampler)
                    }
                }
            }

            // Storage images (sets >= 1)
            setsNeeded.entries.forEach { (set, _) ->
                var kind = 0
                val tag = mutableListOf<Introspected.Bindable>()
                vi.images.forEach {
                    if (it.set == set) {
                        kind = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; tag.add(it)
                    }
                }
                fi.images.forEach {
                    if (it.set == set) {
                        kind = VK_DESCRIPTOR_TYPE_STORAGE_IMAGE; tag.add(it)
                    }
                }
                if (kind == 0) return@forEach

                tag.forEach {
                    val image = parameters.imageResolver(it as Introspected.Image)!!
                    uniforms[it.name] = ImagePointer(it.name, it, source = null, image)
                }
            }

            // --- Vertex input (unchanged)
            vertexInputAttributes = VkVertexInputAttributeDescription.calloc(vi.inputs.size)
            vertexInputBindings = VkVertexInputBindingDescription.calloc(vi.inputs.size)

            vi.inputs.forEachIndexed { index, input ->
                vertexInputAttributes[index].binding(index).location(input.location)
                    .format(vi.inputs[index].type.leftOrNull()!!.bufferFormat).offset(0)
                vertexInputBindings[index].binding(index).stride(vi.inputs[index].sizeInBytes.toInt())
                    .inputRate(VK_VERTEX_INPUT_RATE_VERTEX)
            }

            vertexInputState = VkPipelineVertexInputStateCreateInfo.calloc()
                .sType(VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO)
                .pVertexBindingDescriptions(vertexInputBindings).pVertexAttributeDescriptions(vertexInputAttributes)

            MemoryStack.stackPush().use { stack ->
                val shaderStages = VkPipelineShaderStageCreateInfo.calloc(2, stack)
                shaderStages[0].sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO)
                    .stage(VK_SHADER_STAGE_VERTEX_BIT).pName(stack.UTF8("main")).module(vsm)
                shaderStages[1].sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO)
                    .stage(VK_SHADER_STAGE_FRAGMENT_BIT).pName(stack.UTF8("main")).module(fsm)

                val ia = VkPipelineInputAssemblyStateCreateInfo.calloc(stack)
                    .sType(VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO)
                    .topology(parameters.primitiveType)
                when (parameters.primitiveType) {
                    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP, VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY -> ia.primitiveRestartEnable(
                        true
                    )
                }

                val dynamicViewportCount = parameters.viewportCount.coerceAtLeast(1)
                val vp = VkPipelineViewportStateCreateInfo.calloc(stack)
                    .sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO)
                    .viewportCount(dynamicViewportCount)
                    .scissorCount(dynamicViewportCount)

                val rs = VkPipelineRasterizationStateCreateInfo.calloc(stack)
                    .sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO).polygonMode(parameters.fillMode)
                    .cullMode(VK_CULL_MODE_NONE).frontFace(VK_FRONT_FACE_CLOCKWISE).lineWidth(1.0f)

                val ms = VkPipelineMultisampleStateCreateInfo.calloc(stack)
                    .sType(VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO)
                    .rasterizationSamples(VK_SAMPLE_COUNT_1_BIT)

                var ds: VkPipelineDepthStencilStateCreateInfo? = null
                if (parameters.depth > 0) {
                    ds = VkPipelineDepthStencilStateCreateInfo.calloc(stack)
                        .sType(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO).depthTestEnable(true)
                        .depthWriteEnable(parameters.depthWrite).depthCompareOp(parameters.depthCompareOp).depthBoundsTestEnable(false)
                        .stencilTestEnable(false)
                }

                val colorFormats = if (parameters.colorFormats.isNotEmpty()) parameters.colorFormats
                else List(parameters.color) { parameters.imageFormat }
                require(colorFormats.isNotEmpty()) { "Must specify at least one color attachment" }
                val colorCount = colorFormats.size

                val blendAtt = VkPipelineColorBlendAttachmentState.calloc(colorCount, stack)
                for (i in 0 until colorCount) {
                    val attachmentBlend = parameters.blend &&
                            parameters.renderer.formatSupportsColorAttachmentBlend(colorFormats[i])
                    blendAtt[i].colorWriteMask(
                            (if (parameters.colorMask[0]) VK_COLOR_COMPONENT_R_BIT else 0) or (if (parameters.colorMask[1]) VK_COLOR_COMPONENT_G_BIT else 0) or (if (parameters.colorMask[2]) VK_COLOR_COMPONENT_B_BIT else 0) or (if (parameters.colorMask[3]) VK_COLOR_COMPONENT_A_BIT else 0)
                        ).blendEnable(attachmentBlend).srcColorBlendFactor(parameters.srcColor)
                        .dstColorBlendFactor(parameters.dstColor).colorBlendOp(parameters.colorBlendOp)
                        .srcAlphaBlendFactor(parameters.srcAlpha).dstAlphaBlendFactor(parameters.dstAlpha)   // fix #3
                        .alphaBlendOp(parameters.alphaBlendOp)
                }
                val cb = VkPipelineColorBlendStateCreateInfo.calloc(stack)
                    .sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO).pAttachments(blendAtt)

                val dynList = mutableListOf(
                    VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE
                )
                if (parameters.renderer.device.supportsExtendedDynamicState) {
                    dynList += listOf(
                        VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, VK_DYNAMIC_STATE_CULL_MODE, VK_DYNAMIC_STATE_FRONT_FACE
                    )
                }
                if (parameters.renderer.device.supportsExtendedDynamicState3) {
                    dynList += EXTExtendedDynamicState3.VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT
                }
                val dynStates = stack.ints(*dynList.toIntArray())

                val dyn = VkPipelineDynamicStateCreateInfo.calloc(stack)
                    .sType(VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO).pDynamicStates(dynStates)

                var vpcr: VkPushConstantRange.Buffer? = null
                if (pushConstantSize > 0) {
                    vpcr = VkPushConstantRange.calloc(1, stack)
                        .stageFlags(VK_SHADER_STAGE_VERTEX_BIT or VK_SHADER_STAGE_FRAGMENT_BIT).offset(0)
                        .size(pushConstantSize)
                }

                // ---- Build pipeline layout for module-owned sets (starting at 0)
                val highestSet = layouts.keys.maxOrNull() ?: -1
                val ppLayout = if (highestSet >= 0) stack.callocLong(highestSet + 1) else null
                if (highestSet >= 0) {
                    ppLayout?.let { buf ->
                        for (s in 0..highestSet) {
                            val layout = layouts[s] ?: throw IllegalArgumentException(
                                "Pipeline layout is missing descriptor set $s. Make sets contiguous starting at set=0."
                            )
                            buf.put(s, layout.vkDescriptorLayout)
                        }
                    }
                }

                val pli = VkPipelineLayoutCreateInfo.calloc(stack).sType(VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO)
                ppLayout?.let { pli.pSetLayouts(it) }
                vpcr?.let { pli.pPushConstantRanges(it) }

                val lp = stack.mallocLong(1)
                vkCheck(
                    vkCreatePipelineLayout(parameters.renderer.device.vkDevice, pli, null, lp),
                    "Failed to create pipeline layout"
                )
                pipelineLayout = lp[0]
                parameters.renderer.device.nameObject(
                    pipelineLayout, VK10.VK_OBJECT_TYPE_PIPELINE_LAYOUT, "${parameters.name} PipelineLayout"
                )

                val renderInfo = VkPipelineRenderingCreateInfoKHR.calloc(1, stack)
                    .sType(KHRDynamicRendering.VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR)

                val colorAttachmentFormats = stack.callocInt(colorCount)
                colorFormats.forEach { colorAttachmentFormats.put(it) }
                colorAttachmentFormats.flip()

                renderInfo.colorAttachmentCount(colorCount).pColorAttachmentFormats(colorAttachmentFormats)
                    .depthAttachmentFormat(parameters.pipelineDepthFormat)
                    .stencilAttachmentFormat(0)
                    .viewMask(parameters.viewMask)

                val gp =
                    VkGraphicsPipelineCreateInfo.calloc(1, stack).sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO)
                        .pStages(shaderStages).pVertexInputState(vertexInputState).pInputAssemblyState(ia)
                        .pViewportState(vp).pRasterizationState(rs).pMultisampleState(ms).pColorBlendState(cb)
                        .pDynamicState(dyn).layout(pipelineLayout).renderPass(0).pNext(renderInfo.address())

                ds?.let { gp.pDepthStencilState(it) }

                LatencySpans.time("pipeline.create", detail = "graphics") {
                    vkCheck(
                        vkCreateGraphicsPipelines(
                            parameters.renderer.device.vkDevice,
                            parameters.renderer.pipelineCache.vkPipelineCache,
                            gp,
                            null,
                            lp
                        ), "Error creating graphics pipeline"
                    )
                }
                this.pipeline = lp[0]
                pipelineDisposeToken.updateCleanup(snapshotPipelineCleanup())

                parameters.renderer.device.nameObject(
                    pipeline, VK10.VK_OBJECT_TYPE_PIPELINE, "${parameters.name} Pipeline"
                )

                liveUniformStructures.forEach { (name, structure) ->
                    val target = (uniforms[name] as Uniform).buffer
                    structure.proxying = target
                }
            }

            valid = true
        } catch (e: Exception) {
            // A Metal compile failure just before this is the real reason; say it here, where the box reads it.
            parameters.errorHandler("Module error: ${e.message}" + (afield.graphics.shader.MetalShaderErrors.recent()?.let { "\n$it" } ?: ""), e)
        }
    }

    fun buildPipelineUpdate(
        newVertex: Introspection,
        newFragment: Introspection
    ): PipelineUpdate {
        var newVsm = 0L
        var newFsm = 0L
        var newPipeline = 0L
        try {
            newVsm = createShaderModule(newVertex.code.bytecode()!!)
            newFsm = createShaderModule(newFragment.code.bytecode()!!)

            parameters.renderer.device.nameObject(newVsm, VK10.VK_OBJECT_TYPE_SHADER_MODULE, "${parameters.name} VS update")
            parameters.renderer.device.nameObject(newFsm, VK10.VK_OBJECT_TYPE_SHADER_MODULE, "${parameters.name} FS update")

            MemoryStack.stackPush().use { stack ->
                val shaderStages = VkPipelineShaderStageCreateInfo.calloc(2, stack)
                shaderStages[0].sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO)
                    .stage(VK_SHADER_STAGE_VERTEX_BIT).pName(stack.UTF8("main")).module(newVsm)
                shaderStages[1].sType(VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO)
                    .stage(VK_SHADER_STAGE_FRAGMENT_BIT).pName(stack.UTF8("main")).module(newFsm)

                val ia = VkPipelineInputAssemblyStateCreateInfo.calloc(stack)
                    .sType(VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO)
                    .topology(parameters.primitiveType)
                when (parameters.primitiveType) {
                    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN,
                    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP,
                    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP,
                    VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY,
                    VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY -> ia.primitiveRestartEnable(true)
                }

                val dynamicViewportCount = parameters.viewportCount.coerceAtLeast(1)
                val vp = VkPipelineViewportStateCreateInfo.calloc(stack)
                    .sType(VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO)
                    .viewportCount(dynamicViewportCount)
                    .scissorCount(dynamicViewportCount)

                val rs = VkPipelineRasterizationStateCreateInfo.calloc(stack)
                    .sType(VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO).polygonMode(parameters.fillMode)
                    .cullMode(VK_CULL_MODE_NONE).frontFace(VK_FRONT_FACE_CLOCKWISE).lineWidth(1.0f)

                val ms = VkPipelineMultisampleStateCreateInfo.calloc(stack)
                    .sType(VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO)
                    .rasterizationSamples(VK_SAMPLE_COUNT_1_BIT)

                var ds: VkPipelineDepthStencilStateCreateInfo? = null
                if (parameters.depth > 0) {
                    ds = VkPipelineDepthStencilStateCreateInfo.calloc(stack)
                        .sType(VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO).depthTestEnable(true)
                        .depthWriteEnable(parameters.depthWrite).depthCompareOp(parameters.depthCompareOp).depthBoundsTestEnable(false)
                        .stencilTestEnable(false)
                }

                val colorFormats = if (parameters.colorFormats.isNotEmpty()) parameters.colorFormats
                else List(parameters.color) { parameters.imageFormat }
                require(colorFormats.isNotEmpty()) { "Must specify at least one color attachment" }
                val colorCount = colorFormats.size

                val blendAtt = VkPipelineColorBlendAttachmentState.calloc(colorCount, stack)
                for (i in 0 until colorCount) {
                    val attachmentBlend = parameters.blend &&
                        parameters.renderer.formatSupportsColorAttachmentBlend(colorFormats[i])
                    blendAtt[i].colorWriteMask(
                        (if (parameters.colorMask[0]) VK_COLOR_COMPONENT_R_BIT else 0) or
                            (if (parameters.colorMask[1]) VK_COLOR_COMPONENT_G_BIT else 0) or
                            (if (parameters.colorMask[2]) VK_COLOR_COMPONENT_B_BIT else 0) or
                            (if (parameters.colorMask[3]) VK_COLOR_COMPONENT_A_BIT else 0)
                    ).blendEnable(attachmentBlend).srcColorBlendFactor(parameters.srcColor)
                        .dstColorBlendFactor(parameters.dstColor).colorBlendOp(parameters.colorBlendOp)
                        .srcAlphaBlendFactor(parameters.srcAlpha).dstAlphaBlendFactor(parameters.dstAlpha)
                        .alphaBlendOp(parameters.alphaBlendOp)
                }
                val cb = VkPipelineColorBlendStateCreateInfo.calloc(stack)
                    .sType(VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO).pAttachments(blendAtt)

                val dynList = mutableListOf(
                    VK_DYNAMIC_STATE_VIEWPORT, VK_DYNAMIC_STATE_SCISSOR, VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE
                )
                if (parameters.renderer.device.supportsExtendedDynamicState) {
                    dynList += listOf(
                        VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, VK_DYNAMIC_STATE_CULL_MODE, VK_DYNAMIC_STATE_FRONT_FACE
                    )
                }
                if (parameters.renderer.device.supportsExtendedDynamicState3) {
                    dynList += EXTExtendedDynamicState3.VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT
                }
                val dynStates = stack.ints(*dynList.toIntArray())

                val dyn = VkPipelineDynamicStateCreateInfo.calloc(stack)
                    .sType(VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO).pDynamicStates(dynStates)

                val renderInfo = VkPipelineRenderingCreateInfoKHR.calloc(1, stack)
                    .sType(KHRDynamicRendering.VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR)

                val colorAttachmentFormats = stack.callocInt(colorCount)
                colorFormats.forEach { colorAttachmentFormats.put(it) }
                colorAttachmentFormats.flip()

                renderInfo.colorAttachmentCount(colorCount).pColorAttachmentFormats(colorAttachmentFormats)
                    .depthAttachmentFormat(parameters.pipelineDepthFormat)
                    .stencilAttachmentFormat(0)
                    .viewMask(parameters.viewMask)

                val gp =
                    VkGraphicsPipelineCreateInfo.calloc(1, stack).sType(VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO)
                        .pStages(shaderStages).pVertexInputState(vertexInputState).pInputAssemblyState(ia)
                        .pViewportState(vp).pRasterizationState(rs).pMultisampleState(ms).pColorBlendState(cb)
                        .pDynamicState(dyn).layout(pipelineLayout).renderPass(0).pNext(renderInfo.address())

                ds?.let { gp.pDepthStencilState(it) }

                val lp = stack.mallocLong(1)
                synchronized(parameters.renderer.pipelineCache) {
                    LatencySpans.time("pipeline.update", detail = "graphics") {
                        vkCheck(
                            vkCreateGraphicsPipelines(
                                parameters.renderer.device.vkDevice,
                                parameters.renderer.pipelineCache.vkPipelineCache,
                                gp,
                                null,
                                lp
                            ), "Error creating graphics pipeline update"
                        )
                    }
                }
                newPipeline = lp[0]
                parameters.renderer.device.nameObject(
                    newPipeline, VK10.VK_OBJECT_TYPE_PIPELINE, "${parameters.name} Pipeline update"
                )
            }

            return PipelineUpdate(newVertex, newFragment, newVsm, newFsm, newPipeline)
        } catch (t: Throwable) {
            destroyPipelineHandles(newPipeline, 0L, newVsm, newFsm)
            throw t
        }
    }

    override fun render(command: CommandBuffer, bounds: Rectanglef) {
        if (!valid || !enabled) return
        MemoryStack.stackPush().use { stack ->
            val cmd = command.vkCommandBuffer
            val renderer = parameters.renderer
            val frameIndex = renderer.currentImage
            val profiler = renderer.getProfiler()
            val fieldProbe = parameters.fieldProbe?.takeIf { FIELD_PROBE_BUFFER_NAME in uniforms }

            fieldProbe?.beforeShaderUse(renderer, frameIndex)

            // Begin label for the whole module render (if EXT_debug_utils is available)
            val labelColor = stack.floats(
                parameters.labelColor.x.f,
                parameters.labelColor.y.f,
                parameters.labelColor.z.f,
                parameters.labelColor.w.f
            )
            command.beginLabel(parameters.name, labelColor)

            try {
                val marks = if (profiler != null) Renderer.ModuleMarks(parameters.name) else null
                var psScope: GpuProfiler.PipeStatScope? = null
                var perfScope: GpuProfiler.PerfScope? = null

                if (profiler != null) {
                    marks!!.tsBegin = profiler.writeTimestamp2(cmd, frameIndex, VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT)
                    psScope = profiler.beginPipelineStats(cmd, frameIndex)
                    perfScope = profiler.beginPerfCounters(cmd, frameIndex)
                }

                VK10.vkCmdBindPipeline(cmd, VK10.VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline)

                VK13.vkCmdSetDepthTestEnable(cmd, if (parameters.depth == 0) false else parameters.depthTest)
                if (renderer.device.supportsExtendedDynamicState) {
                    VK13.vkCmdSetPrimitiveTopology(cmd, parameters.primitiveType)
                    VK13.vkCmdSetCullMode(cmd, VK_CULL_MODE_NONE)
                    VK13.vkCmdSetFrontFace(cmd, VK_FRONT_FACE_CLOCKWISE)
                }
                if (renderer.device.supportsExtendedDynamicState3) {
                    EXTExtendedDynamicState3.vkCmdSetDepthClampEnableEXT(cmd, false)
                }

                val pushConstantBuffer = if (pushConstantSize > 0) stack.calloc(pushConstantSize) else stack.malloc(0)

                uniforms.values.forEach { upd ->
                    upd.pushDescriptorSet(command, pipelineLayout, VK_PIPELINE_BIND_POINT_GRAPHICS)
                }

                liveUniformStructures.forEach { (name, structure) ->
                    val target = (uniforms[name] as Uniform).buffer
                    structure.proxying = target
                    structure.writeIfStale(target, command) {
                        throw MissingRefException(afield.graphics.vulkan.buffers.unassignedMemberMessage(it))
                    }
                    target.clean(false, command)
                }

                meshes.forEach { (_, mesh) ->
                    mesh.draw(this, command, pushConstantBuffer)
                }

                after.forEach { (_, target) ->
                    target.render(command, renderer.currentImage)
                }

                fieldProbe?.let {
                    graphicsHostReadBarrier(command, it.bufferForImage(renderer, frameIndex))
                    it.afterShaderUse(renderer, frameIndex)
                }

                if (profiler != null) {
                    profiler.endPipelineStats(cmd, psScope)
                    profiler.endPerfCounters(cmd, frameIndex, perfScope)
                    marks!!.tsEnd = profiler.writeTimestamp2(cmd, frameIndex, VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT)
                    psScope?.let { marks.pipeStatsIndex = it.index }
                    perfScope?.let { marks.perfIndex = it.index }
                    renderer.registerModuleMarks(frameIndex, marks)
                }
            } finally {
                command.endLabel() // close the module render region
            }
        }
    }