PuppetBrowserVrPanel.kt

    fun build() {
        stereo.stereoCamera.base.at.set(0f, 0f, 0f)
        stereo.stereoCamera.base.target.set(0f, 0f, 1f)
        // Match the desktop camera to each eye layer. OpenXR supplies its own projection.
        val eyeAspect = stereo.eyeWidth.toFloat() / stereo.eyeHeight.toFloat()
        stereo.stereoCamera.base.p.auto = {
            stereo.stereoCamera.base.p.matchDepth = stereo.stereoCamera.base.p.autoMatchDistance()
            stereo.stereoCamera.base.p.setAspect(eyeAspect)
        }
        stereo.stereoCamera.base.setAspect(eyeAspect)
        placeInitialPanel(panel, stereo.stereoCamera.base.at, distanceMeters)

        val halfWidth = panel.halfWidth
        val halfHeight = panel.halfHeight
        val positions = floatArrayOf(
            -halfWidth, +halfHeight, 0f,
            -halfWidth, -halfHeight, 0f,
            +halfWidth, -halfHeight, 0f,
            +halfWidth, +halfHeight, 0f,
        )
        val uvs = floatArrayOf(0f, 0f, 0f, 1f, 1f, 1f, 1f, 0f)
        val indices = intArrayOf(0, 1, 2, 0, 2, 3)

        stereo.registerModule(name) {
            val module = Module(parameters(renderer) {
                this.name = this@PuppetBrowserVrPanel.name
                stereo.configure(this)
                color = 1
                depth = 1
                depthTest = true
                colorFormats = listOf(VK_FORMAT_B8G8R8A8_SRGB)
                vertex = vertexShader
                fragment = fragmentShader
                textureResolver = { texture ->
                    if (texture.name == "browserTexture") {
                        fromViews(listOf(browser), texture.name, sampler)
                    } else null
                }
            })

            val pointer = module.pointer()
            val mesh = Mesh(renderer, pointer)
            mesh.resize(4, 2)
            pointer.current.meshes[name] = mesh
            mesh.v[0]!!.mapAndWrite { positions.forEach(::put); rewind() }
            mesh.v[1]!!.mapAndWrite { uvs.forEach(::put); rewind() }
            mesh.t!!.mapAndWrite_ints { indices.forEach(::put); rewind() }

            // Update sequences are prefetched; input must run at an actual draw boundary instead.
            module.before["browser-input"] = afield.graphics.vulkan.Target { _, _ ->
                if (automaticInteraction) updateInteraction()
                mesh.push["model"] = Matrix4f(panel.model) // panel local-to-world transform
                val hit = lastHit
                mesh.push["pointer"] = Vector4f(
                    hit?.u?.toFloat() ?: -1f,
                    hit?.v?.toFloat() ?: -1f,
                    if (hit?.onPanel == true) 1f else 0f,
                    if (pointerPressed) 1f else 0f,
                ) // pointer UV, hover and pressed state
            }
            pointer
        }
    }

        internal fun placeInitialPanel(panel: PuppetBrowserPanel, eye: Vector3f, distanceMeters: Float) {
            // The initial camera looks along +Z, so its screen-right is -X. A +X panel basis
            // faces away from the viewer and mirrors browser text. Orient the model, not the UVs,
            // so texture sampling and raycast input continue to share the same coordinates.
            panel.faceToward(Vector3f(eye).add(0f, 0f, distanceMeters), eye)
        }

        private val vertexShader = """
            #version 460
            ${MultiviewStereoTarget.VIEWS_GLSL}
            layout(location = 0) in vec3 inPosition;
            layout(location = 1) in vec2 inUV;
            layout(location = 0) out vec2 fragUV;
            layout(push_constant) uniform Push {
                mat4 model; // panel local-to-world transform
                vec4 pointer; // cursor UV, visibility and pressed state
            } push;
            void main() {
                fragUV = inUV;
                gl_Position = stereoViewProjection() * push.model * vec4(inPosition, 1.0);
            }
        """.trimIndent()

        private val fragmentShader = """
            #version 460
            layout(location = 0) in vec2 fragUV;
            layout(location = 0) out vec4 outColor;
            layout(set = 0, binding = 0) uniform sampler2D browserTexture;
            layout(push_constant) uniform Push {
                mat4 model; // panel local-to-world transform
                vec4 pointer; // cursor UV, visibility and pressed state
            } push;
            void main() {
                vec4 browser = texture(browserTexture, fragUV);
                float edge = min(min(fragUV.x, 1.0 - fragUV.x), min(fragUV.y, 1.0 - fragUV.y));
                vec3 rgb = edge < 0.0025 ? vec3(0.18) : browser.rgb;
                vec2 texSize = vec2(textureSize(browserTexture, 0));
                vec2 delta = (fragUV - push.pointer.xy) * vec2(texSize.x / texSize.y, 1.0);
                float ringDistance = abs(length(delta) - 0.012);
                float ring = 1.0 - smoothstep(0.0015, 0.0035, ringDistance);
                vec3 pointerColor = mix(vec3(0.95), vec3(0.25, 0.65, 1.0), push.pointer.w);
                rgb = mix(rgb, pointerColor, ring * push.pointer.z);
                outColor = vec4(rgb, 1.0);
            }
        """.trimIndent()
    }
}