sceneview-mcp 3.3.0 → 3.4.1

package/dist/index.js

@@ -195,6 +195,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                 required: ["type"],
             },
         },
+        {
+            name: "get_web_setup",
+            description: "Returns the complete Web setup guide for SceneView Web — npm install, Kotlin/JS Gradle config, HTML canvas setup, and basic Filament.js integration code. SceneView Web uses the same Filament rendering engine as Android, compiled to WebAssembly. Use this when a user wants to set up SceneView for browsers.",
+            inputSchema: {
+                type: "object",
+                properties: {},
+            },
+        },
     ],
 }));
 // ─── Tool handlers ────────────────────────────────────────────────────────────
@@ -594,6 +602,97 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 isError: true,
             };
         }
+        // ── get_web_setup ────────────────────────────────────────────────────────
+        case "get_web_setup": {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            `## SceneView Web — Browser 3D Setup`,
+                            ``,
+                            `SceneView Web uses **Filament.js** — the same rendering engine as Android, compiled to WebAssembly (WebGL2).`,
+                            ``,
+                            `### 1. Install`,
+                            ``,
+                            `\`\`\`bash`,
+                            `npm install @sceneview/sceneview-web`,
+                            `\`\`\``,
+                            ``,
+                            `Or in a Kotlin/JS Gradle project:`,
+                            `\`\`\`kotlin`,
+                            `// build.gradle.kts`,
+                            `kotlin {`,
+                            `    js(IR) { browser(); binaries.executable() }`,
+                            `    sourceSets {`,
+                            `        jsMain.dependencies {`,
+                            `            implementation("@sceneview/sceneview-web")`,
+                            `            // or: implementation(project(":sceneview-web"))`,
+                            `        }`,
+                            `    }`,
+                            `}`,
+                            `\`\`\``,
+                            ``,
+                            `### 2. HTML`,
+                            ``,
+                            `\`\`\`html`,
+                            `<canvas id="scene-canvas" style="width:100%;height:100vh"></canvas>`,
+                            `<script src="your-app.js"></script>`,
+                            `\`\`\``,
+                            ``,
+                            `### 3. Kotlin/JS Code`,
+                            ``,
+                            `\`\`\`kotlin`,
+                            `import io.github.sceneview.web.SceneView`,
+                            `import kotlinx.browser.document`,
+                            `import org.w3c.dom.HTMLCanvasElement`,
+                            ``,
+                            `fun main() {`,
+                            `    val canvas = document.getElementById("scene-canvas") as HTMLCanvasElement`,
+                            `    canvas.width = canvas.clientWidth`,
+                            `    canvas.height = canvas.clientHeight`,
+                            ``,
+                            `    SceneView.create(`,
+                            `        canvas = canvas,`,
+                            `        configure = {`,
+                            `            camera {`,
+                            `                eye(0.0, 1.5, 5.0)`,
+                            `                target(0.0, 0.0, 0.0)`,
+                            `                fov(45.0)`,
+                            `            }`,
+                            `            light {`,
+                            `                directional()`,
+                            `                intensity(100_000.0)`,
+                            `            }`,
+                            `            model("models/DamagedHelmet.glb")`,
+                            `            autoRotate()`,
+                            `        },`,
+                            `        onReady = { sceneView ->`,
+                            `            sceneView.startRendering()`,
+                            `        }`,
+                            `    )`,
+                            `}`,
+                            `\`\`\``,
+                            ``,
+                            `### 4. Features`,
+                            ``,
+                            `- Same Filament PBR renderer as Android (WASM)`,
+                            `- glTF 2.0 / GLB model loading`,
+                            `- IBL environment lighting (KTX)`,
+                            `- Orbit camera with mouse/touch/pinch controls`,
+                            `- Auto-rotation`,
+                            `- Directional, point, and spot lights`,
+                            ``,
+                            `### 5. Limitations`,
+                            ``,
+                            `- No AR (requires native sensors)`,
+                            `- WebGL2 required (~95% of browsers)`,
+                            `- glTF/GLB format only (same as Android)`,
+                        ].join("\n"),
+                    },
+                ],
+            };
+        }
         default:
             return {
                 content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],

package/dist/samples.js

@@ -884,6 +884,90 @@ struct VideoPlayerScreen: View {
             }
         }
     }
+}`,
+    },
+    // ── Web Samples (Kotlin/JS + Filament.js) ──────────────────────────────
+    "web-model-viewer": {
+        id: "web-model-viewer",
+        title: "Web 3D Model Viewer",
+        description: "Browser-based 3D model viewer using Filament.js (WebGL2/WASM) — same engine as SceneView Android",
+        tags: ["3d", "model", "web", "filament-js"],
+        dependency: "@sceneview/sceneview-web",
+        language: "kotlin-js",
+        prompt: "Create a browser-based 3D model viewer using SceneView Web (Kotlin/JS + Filament.js). Load a GLB model with camera and lighting.",
+        code: `import io.github.sceneview.web.SceneView
+import kotlinx.browser.document
+import kotlinx.browser.window
+import org.w3c.dom.HTMLCanvasElement
+
+fun main() {
+    val canvas = document.getElementById("scene-canvas") as HTMLCanvasElement
+    canvas.width = canvas.clientWidth
+    canvas.height = canvas.clientHeight
+
+    SceneView.create(
+        canvas = canvas,
+        configure = {
+            camera {
+                eye(0.0, 1.5, 5.0)
+                target(0.0, 0.0, 0.0)
+                fov(45.0)
+            }
+            light {
+                directional()
+                intensity(100_000.0)
+                direction(0.0f, -1.0f, -0.5f)
+            }
+            model("models/DamagedHelmet.glb")
+        },
+        onReady = { sceneView ->
+            sceneView.startRendering()
+
+            window.addEventListener("resize", {
+                canvas.width = canvas.clientWidth
+                canvas.height = canvas.clientHeight
+            })
+        }
+    )
+}`,
+    },
+    "web-environment": {
+        id: "web-environment",
+        title: "Web Environment Lighting",
+        description: "Browser 3D scene with IBL environment lighting and skybox from KTX files",
+        tags: ["3d", "environment", "web", "filament-js", "lighting"],
+        dependency: "@sceneview/sceneview-web",
+        language: "kotlin-js",
+        prompt: "Create a browser 3D viewer with HDR environment lighting (IBL + skybox) using SceneView Web and Filament.js.",
+        code: `import io.github.sceneview.web.SceneView
+import kotlinx.browser.document
+import org.w3c.dom.HTMLCanvasElement
+
+fun main() {
+    val canvas = document.getElementById("scene-canvas") as HTMLCanvasElement
+    canvas.width = canvas.clientWidth
+    canvas.height = canvas.clientHeight
+
+    SceneView.create(
+        canvas = canvas,
+        configure = {
+            camera {
+                eye(0.0, 1.0, 4.0)
+                target(0.0, 0.0, 0.0)
+                fov(50.0)
+                exposure(16.0, 1.0 / 125.0, 100.0)
+            }
+            // Environment from KTX IBL + skybox files
+            environment(
+                iblUrl = "environments/pillars_2k_ibl.ktx",
+                skyboxUrl = "environments/pillars_2k_skybox.ktx"
+            )
+            model("models/DamagedHelmet.glb")
+        },
+        onReady = { sceneView ->
+            sceneView.startRendering()
+        }
+    )
 }`,
     },
 };

package/dist/validator.js

@@ -489,6 +489,13 @@ const SWIFT_RULES = [
     },
 ];
 function detectLanguage(code) {
+    // Heuristic: detect web/Kotlin-JS code
+    if (code.includes("io.github.sceneview.web") ||
+        code.includes("kotlinx.browser") ||
+        code.includes("HTMLCanvasElement") ||
+        code.includes("SceneView.create(")) {
+        return "kotlin-js";
+    }
     // Heuristic: if the code has Swift markers, validate as Swift
     if (code.includes("import SwiftUI") ||
         code.includes("import RealityKit") ||
@@ -500,12 +507,80 @@ function detectLanguage(code) {
     }
     return "kotlin";
 }
+// ─── Web (Kotlin/JS) validation rules ────────────────────────────────────────
+const WEB_RULES = [
+    {
+        id: "web/missing-canvas-null-check",
+        severity: "warning",
+        check(code, lines) {
+            const issues = [];
+            if (code.includes("getElementById") && !code.includes("as?") && !code.includes("?: ") && !code.includes("== null")) {
+                findLines(lines, /getElementById/).forEach((line) => issues.push({
+                    severity: "warning",
+                    rule: "web/missing-canvas-null-check",
+                    message: "Canvas element lookup should include a null check. Use `as? HTMLCanvasElement` with a null guard.",
+                    line,
+                }));
+            }
+            return issues;
+        },
+    },
+    {
+        id: "web/missing-canvas-resize",
+        severity: "info",
+        check(code, lines) {
+            const issues = [];
+            if (code.includes("SceneView.create(") && !code.includes("clientWidth") && !code.includes("resize")) {
+                issues.push({
+                    severity: "info",
+                    rule: "web/missing-canvas-resize",
+                    message: "Canvas should be sized before creating SceneView. Set `canvas.width = canvas.clientWidth` and `canvas.height = canvas.clientHeight` before `SceneView.create()`. Or enable `autoResize` (on by default).",
+                });
+            }
+            return issues;
+        },
+    },
+    {
+        id: "web/ar-not-supported",
+        severity: "error",
+        check(code, lines) {
+            const issues = [];
+            if (code.includes("ARScene") || code.includes("ARSceneView")) {
+                findLines(lines, /ARScene|ARSceneView/).forEach((line) => issues.push({
+                    severity: "error",
+                    rule: "web/ar-not-supported",
+                    message: "AR is not supported on the web platform. SceneView Web only supports 3D scenes (no camera/sensor access in browsers). Use `SceneView.create()` for 3D-only web rendering.",
+                    line,
+                }));
+            }
+            return issues;
+        },
+    },
+    {
+        id: "web/missing-start-rendering",
+        severity: "warning",
+        check(code, lines) {
+            const issues = [];
+            if (code.includes("SceneView.create(") && !code.includes("startRendering")) {
+                issues.push({
+                    severity: "warning",
+                    rule: "web/missing-start-rendering",
+                    message: "Don't forget to call `sceneView.startRendering()` in the `onReady` callback to start the render loop.",
+                });
+            }
+            return issues;
+        },
+    },
+];
 export function validateCode(code) {
     const lines = code.split("\n");
     const lang = detectLanguage(code);
     if (lang === "swift") {
         return SWIFT_RULES.flatMap((rule) => rule.check(code, lines));
     }
+    if (lang === "kotlin-js") {
+        return WEB_RULES.flatMap((rule) => rule.check(code, lines));
+    }
     return RULES.flatMap((rule) => rule.check(code, lines));
 }
 export function formatValidationReport(issues) {

package/llms.txt

@@ -2154,3 +2154,109 @@ Pure Kotlin logic shared between Android and Apple platforms:
 - **Animation**: Easing, lerp/slerp, spring, smooth transform interpolation
 - **Physics**: Euler integration, floor bounce, restitution, sleep detection
 - **Triangulation**: Earcut (polygon), Delaunator (Delaunay)
+
+---
+
+## Web Platform (Alpha)
+
+SceneView for Web uses **Filament.js** — the same Filament rendering engine as Android, compiled to WebAssembly for browsers (WebGL2).
+
+### npm package
+```
+npm install @sceneview/sceneview-web
+```
+
+### Kotlin/JS API
+```kotlin
+import io.github.sceneview.web.SceneView
+import kotlinx.browser.document
+import org.w3c.dom.HTMLCanvasElement
+
+fun main() {
+    val canvas = document.getElementById("scene-canvas") as HTMLCanvasElement
+
+    SceneView.create(
+        canvas = canvas,
+        configure = {
+            camera {
+                eye(0.0, 1.5, 5.0)
+                target(0.0, 0.0, 0.0)
+                fov(45.0)
+            }
+            model("models/DamagedHelmet.glb")
+            environment("environments/sky_ibl.ktx", "environments/sky_skybox.ktx")
+        },
+        onReady = { sceneView ->
+            sceneView.startRendering()
+        }
+    )
+}
+```
+
+### HTML
+```html
+<canvas id="scene-canvas"></canvas>
+<script src="sceneview-web.js"></script>
+```
+
+### SceneView Web API
+
+| Class | Purpose |
+|---|---|
+| `SceneView` | Main entry — `create(canvas, configure, onReady)` |
+| `SceneViewBuilder` | DSL: `camera {}`, `light {}`, `model()`, `environment()` |
+| `CameraConfig` | `eye()`, `target()`, `up()`, `fov()`, `near()`, `far()`, `exposure()` |
+| `LightConfig` | `directional()`, `point()`, `spot()`, `intensity()`, `color()`, `direction()` |
+| `ModelConfig` | `url`, `scale()`, `autoAnimate()`, `onLoaded {}` |
+
+### SceneView instance methods
+
+| Method | Description |
+|---|---|
+| `startRendering()` | Begin render loop (requestAnimationFrame) |
+| `stopRendering()` | Stop render loop |
+| `loadModel(url, onLoaded?)` | Load glTF/GLB from URL |
+| `loadEnvironment(iblUrl, skyboxUrl?)` | Load IBL + skybox KTX files |
+| `destroy()` | Clean up all Filament resources |
+
+### Web AR (WebXR)
+
+SceneView Web supports augmented reality via the **WebXR Device API** on supported browsers:
+
+```kotlin
+ARSceneView.checkSupport { supported ->
+    if (supported) {
+        ARSceneView.create(canvas) { arView ->
+            arView.onHitTest = { pose ->
+                // Place model at hit position
+            }
+            arView.start()
+        }
+    }
+}
+```
+
+**Supported browsers:** Chrome Android 79+, Safari iOS 18+, Quest Browser, Edge
+**Features:** Hit-test (tap-to-place), light estimation, DOM overlay
+
+### Web constraints
+- AR requires WebXR-capable browser (not all browsers — check with `ARSceneView.checkSupport`)
+- WebGL2 required for 3D (~95% of browsers)
+- glTF 2.0 / GLB format only (same as Android)
+- Cross-origin asset loading requires CORS headers
+
+---
+
+## Platform Coverage Summary
+
+| Platform | Renderer | Framework | Sample | Status |
+|---|---|---|---|---|
+| Android | Filament | Jetpack Compose | `samples/android-demo` | Stable |
+| Android TV | Filament | Compose TV | `samples/android-tv-demo` | Alpha |
+| iOS | RealityKit | SwiftUI | `samples/ios-demo` | Alpha |
+| macOS | RealityKit | SwiftUI | via SceneViewSwift | Alpha |
+| visionOS | RealityKit | SwiftUI | via SceneViewSwift | Alpha |
+| Web | Filament.js + WebXR | Kotlin/JS | `samples/web-demo` | Alpha |
+| Desktop | Software renderer | Compose Desktop | `samples/desktop-demo` | Alpha |
+| Flutter | Filament/RealityKit | PlatformView | `samples/flutter-demo` | Alpha |
+| React Native | Filament/RealityKit | Fabric | `samples/react-native-demo` | Alpha |

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "sceneview-mcp",
-  "version": "3.3.0",
+  "version": "3.4.1",
+  "mcpName": "io.github.sceneview/mcp",
   "description": "MCP server for SceneView — cross-platform 3D & AR SDK for Android and iOS. Give Claude the full SceneView SDK so it writes correct, compilable code.",
   "keywords": [
     "mcp",