Chat Interface mit Glass Theme - fullscreen render background, glassmorphism overlay

app.py

@@ -1,12 +1,11 @@
 """
-BPY MCP Server - Blender Python API with OpenVINO SmolVLM/SmolLM3
-CPU-only 3D generation
+BPY MCP Server - Blender Chat Interface with Glass Theme
+CPU-only 3D generation with SmolLM3
 """
 import os
 import tempfile
 import uuid
 from pathlib import Path
-from typing import Optional
 
 import gradio as gr
 import numpy as np
@@ -18,23 +17,104 @@ import openvino_genai as ov_genai
 # Blender Python API
 import bpy
 
-# Global models
-SMOLVLM_PIPE = None
+# Global model
 SMOLLM3_PIPE = None
 
-
-def load_smolvlm():
-    """Load SmolVLM OpenVINO model for image understanding"""
-    global SMOLVLM_PIPE
-
-    if SMOLVLM_PIPE is not None:
-        return SMOLVLM_PIPE
-
-    print("Loading SmolVLM INT4 OpenVINO...")
-    model_path = snapshot_download("dev-bjoern/smolvlm-int4-ov")
-    SMOLVLM_PIPE = ov_genai.VLMPipeline(model_path, device="CPU")
-    print("SmolVLM loaded")
-    return SMOLVLM_PIPE
+# Glassmorphism CSS
+GLASS_CSS = """
+/* Fullscreen Render als Background */
+#render-bg {
+    position: fixed !important;
+    top: 0 !important;
+    left: 0 !important;
+    width: 100vw !important;
+    height: 100vh !important;
+    z-index: 0 !important;
+    object-fit: cover !important;
+    pointer-events: none !important;
+}
+
+#render-bg img {
+    width: 100% !important;
+    height: 100% !important;
+    object-fit: cover !important;
+}
+
+/* Container transparent */
+.gradio-container {
+    background: transparent !important;
+    position: relative;
+    z-index: 1;
+}
+
+/* Chat Overlay mit Glass-Effekt */
+.glass-chat {
+    position: relative !important;
+    z-index: 10 !important;
+    background: rgba(0, 0, 0, 0.3) !important;
+    backdrop-filter: blur(20px) !important;
+    -webkit-backdrop-filter: blur(20px) !important;
+    border-radius: 20px !important;
+    border: 1px solid rgba(255, 255, 255, 0.1) !important;
+}
+
+.glass-chat .bubble-wrap {
+    background: transparent !important;
+}
+
+.glass-chat .message {
+    background: rgba(255, 255, 255, 0.1) !important;
+    backdrop-filter: blur(10px) !important;
+    -webkit-backdrop-filter: blur(10px) !important;
+    border: 1px solid rgba(255, 255, 255, 0.15) !important;
+    border-radius: 16px !important;
+}
+
+/* User message */
+.glass-chat .message.user {
+    background: rgba(100, 150, 255, 0.2) !important;
+}
+
+/* Bot message */
+.glass-chat .message.bot {
+    background: rgba(255, 255, 255, 0.1) !important;
+}
+
+/* Input textbox glass */
+.glass-input textarea {
+    background: rgba(255, 255, 255, 0.1) !important;
+    backdrop-filter: blur(10px) !important;
+    border: 1px solid rgba(255, 255, 255, 0.2) !important;
+    border-radius: 12px !important;
+    color: white !important;
+}
+
+/* Buttons glass */
+button.primary {
+    background: rgba(100, 150, 255, 0.3) !important;
+    backdrop-filter: blur(10px) !important;
+    border: 1px solid rgba(255, 255, 255, 0.2) !important;
+}
+
+/* Header transparent */
+.app-header, header {
+    background: transparent !important;
+}
+
+/* Dark text on glass */
+.glass-chat .message p, .glass-chat .message code {
+    color: white !important;
+}
+
+/* Hide default background */
+.main, .contain, .wrap {
+    background: transparent !important;
+}
+
+body {
+    background: #1a1a2e !important;
+}
+"""
 
 
 def load_smollm3():
@@ -51,220 +131,170 @@ def load_smollm3():
     return SMOLLM3_PIPE
 
 
-def analyze_image(image: np.ndarray, prompt: str = "Describe this image for 3D scene creation") -> str:
-    """Analyze image with SmolVLM"""
-    if image is None:
-        return "No image provided"
-
-    try:
-        pipe = load_smolvlm()
-
-        # Save image temporarily using bpy
-        temp_path = f"{tempfile.mkdtemp()}/input_{uuid.uuid4().hex[:8]}.png"
-
-        # Use bpy to save image
-        img = bpy.data.images.new("temp_input", width=image.shape[1], height=image.shape[0])
-        img.pixels = (image / 255.0).flatten().tolist()
-        img.filepath_raw = temp_path
-        img.file_format = 'PNG'
-        img.save()
-        bpy.data.images.remove(img)
-
-        # Generate description
-        result = pipe.generate(
-            prompt,
-            image=temp_path,
-            max_new_tokens=256
-        )
-
-        return result
-    except Exception as e:
-        return f"Error: {e}"
+def render_scene() -> str:
+    """Render current Blender scene to image"""
+    output_dir = tempfile.mkdtemp()
+    render_path = f"{output_dir}/render_{uuid.uuid4().hex[:8]}.png"
 
+    # Setup render settings
+    bpy.context.scene.render.filepath = render_path
+    bpy.context.scene.render.image_settings.file_format = 'PNG'
+    bpy.context.scene.render.resolution_x = 1920
+    bpy.context.scene.render.resolution_y = 1080
+    bpy.context.scene.render.resolution_percentage = 50
 
-def generate_bpy_script(scene_type: str, style: str = "realistic") -> str:
-    """Generate a bpy Python script with SmolLM3"""
-    try:
-        pipe = load_smollm3()
+    # Render
+    bpy.ops.render.render(write_still=True)
 
-        prompt = f"""Write a Python script using bpy (Blender Python API) to create a {style} {scene_type} 3D scene.
+    return render_path
 
-The script must:
-1. Clear existing objects with bpy.ops.object.select_all(action='SELECT') and bpy.ops.object.delete()
-2. Create mesh objects using bpy.ops.mesh.primitive_* functions
-3. Position objects with location parameter
-4. Add a camera with bpy.ops.object.camera_add()
-5. Add lighting with bpy.ops.object.light_add()
-6. Set materials using bpy.data.materials.new()
 
-Only output valid Python code, no explanations. Start with import bpy."""
+def execute_bpy_code(code: str) -> bool:
+    """Execute bpy Python code"""
+    try:
+        # Clean code
+        if "```python" in code:
+            code = code.split("```python")[1].split("```")[0]
+        elif "```" in code:
+            parts = code.split("```")
+            if len(parts) > 1:
+                code = parts[1]
 
-        result = pipe.generate(
-            prompt,
-            max_new_tokens=1024
-        )
+        code = code.replace("import bpy", "# import bpy (already loaded)")
 
-        return result
+        # Execute
+        exec(code, {"bpy": bpy, "math": __import__("math")})
+        return True
     except Exception as e:
-        return f"# Error: {e}"
+        print(f"Exec error: {e}")
+        return False
 
 
-def create_primitive(primitive_type: str, name: str = "Object", location: tuple = (0, 0, 0)) -> str:
-    """Create a Blender primitive object"""
+def chat_with_blender(message: str, history: list):
+    """
+    Chat mit SmolLM3 - generiert bpy Script und fuehrt aus
+    """
     try:
-        # Clear existing objects
-        bpy.ops.object.select_all(action='SELECT')
-        bpy.ops.object.delete()
+        pipe = load_smollm3()
 
-        # Create primitive
-        if primitive_type == "cube":
-            bpy.ops.mesh.primitive_cube_add(location=location)
-        elif primitive_type == "sphere":
-            bpy.ops.mesh.primitive_uv_sphere_add(location=location)
-        elif primitive_type == "cylinder":
-            bpy.ops.mesh.primitive_cylinder_add(location=location)
-        elif primitive_type == "cone":
-            bpy.ops.mesh.primitive_cone_add(location=location)
-        elif primitive_type == "torus":
-            bpy.ops.mesh.primitive_torus_add(location=location)
-        elif primitive_type == "plane":
-            bpy.ops.mesh.primitive_plane_add(location=location)
-        elif primitive_type == "monkey":
-            bpy.ops.mesh.primitive_monkey_add(location=location)
-        else:
-            return f"Unknown primitive: {primitive_type}"
+        # Prompt fuer bpy Script Generierung
+        prompt = f"""Du bist ein Blender Python (bpy) Experte. Schreibe ein kurzes bpy Script fuer: {message}
 
-        # Rename object
-        obj = bpy.context.active_object
-        obj.name = name
+Regeln:
+1. Starte mit: bpy.ops.object.select_all(action='SELECT'); bpy.ops.object.delete()
+2. Nutze bpy.ops.mesh.primitive_* fuer Objekte
+3. Fuege Kamera hinzu: bpy.ops.object.camera_add(location=(x,y,z))
+4. Fuege Licht hinzu: bpy.ops.object.light_add(type='SUN')
+5. Setze einfache Materialien mit bpy.data.materials.new()
 
-        # Export to GLB
-        output_dir = tempfile.mkdtemp()
-        glb_path = f"{output_dir}/{name}_{uuid.uuid4().hex[:8]}.glb"
+Nur Python Code, keine Erklaerungen. Starte mit import bpy."""
 
-        bpy.ops.export_scene.gltf(
-            filepath=glb_path,
-            export_format='GLB'
-        )
+        # Generate script
+        result = pipe.generate(prompt, max_new_tokens=512)
+
+        # Execute the script
+        success = execute_bpy_code(result)
+
+        if success:
+            # Render scene
+            render_path = render_scene()
+            response = f"Scene erstellt!\n\n```python\n{result}\n```"
+            return response, render_path
+        else:
+            return f"Fehler beim Ausfuehren:\n```python\n{result}\n```", None
 
-        return glb_path
     except Exception as e:
-        return f"Error: {e}"
+        return f"Error: {e}", None
 
 
-def execute_bpy_script(script: str) -> str:
-    """Execute a bpy script and export to GLB"""
+def create_initial_scene():
+    """Create a default scene for startup"""
     try:
-        # Extract just the Python code (remove markdown if present)
-        code = script
-        if "```python" in code:
-            code = code.split("```python")[1].split("```")[0]
-        elif "```" in code:
-            parts = code.split("```")
-            if len(parts) > 1:
-                code = parts[1]
+        # Clear
+        bpy.ops.object.select_all(action='SELECT')
+        bpy.ops.object.delete()
 
-        # Remove import bpy if present (already imported)
-        code = code.replace("import bpy", "# import bpy (already loaded)")
+        # Add cube
+        bpy.ops.mesh.primitive_cube_add(location=(0, 0, 0))
+        cube = bpy.context.active_object
 
-        # Execute the script
-        exec(code, {"bpy": bpy, "math": __import__("math")})
+        # Material
+        mat = bpy.data.materials.new(name="BlueMat")
+        mat.diffuse_color = (0.2, 0.4, 0.8, 1.0)
+        cube.data.materials.append(mat)
 
-        # Export to GLB
-        output_dir = tempfile.mkdtemp()
-        glb_path = f"{output_dir}/scene_{uuid.uuid4().hex[:8]}.glb"
+        # Camera
+        bpy.ops.object.camera_add(location=(5, -5, 4))
+        cam = bpy.context.active_object
+        cam.rotation_euler = (1.1, 0, 0.8)
+        bpy.context.scene.camera = cam
 
-        bpy.ops.export_scene.gltf(
-            filepath=glb_path,
-            export_format='GLB'
-        )
+        # Light
+        bpy.ops.object.light_add(type='SUN', location=(5, 5, 10))
 
-        return glb_path
+        return render_scene()
     except Exception as e:
-        return f"Error executing script: {e}"
+        print(f"Initial scene error: {e}")
+        return None
 
 
 # Gradio Interface
-with gr.Blocks(title="BPY MCP") as demo:
-    gr.Markdown("""
-    # 🎨 BPY MCP Server
-    **Blender Python API + OpenVINO AI** - CPU-only
-
-    Using SmolVLM for image understanding and SmolLM3 for text generation
-    """)
+with gr.Blocks(css=GLASS_CSS, theme=gr.themes.Glass(), title="BPY Chat") as demo:
+
+    # State fuer Render
+    render_state = gr.State(value=None)
+
+    # Fullscreen Render Background
+    with gr.Column(elem_id="render-bg"):
+        render_output = gr.Image(
+            value=create_initial_scene,
+            label="",
+            show_label=False,
+            interactive=False,
+            show_download_button=False
+        )
 
-    with gr.Tab("Image Analysis (SmolVLM)"):
-        with gr.Row():
-            with gr.Column():
-                img_input = gr.Image(label="Input Image", type="numpy")
-                img_prompt = gr.Textbox(
-                    label="Prompt",
-                    value="Describe this image for 3D scene creation"
-                )
-                img_btn = gr.Button("🔍 Analyze", variant="primary")
-            with gr.Column():
-                img_output = gr.Textbox(label="Description", lines=10)
-
-        img_btn.click(analyze_image, [img_input, img_prompt], img_output)
-
-    with gr.Tab("Scene Generator (SmolLM3)"):
-        with gr.Row():
-            with gr.Column():
-                scene_type = gr.Dropdown(
-                    ["forest", "desert", "city", "interior", "space", "underwater"],
-                    label="Scene Type",
-                    value="forest"
-                )
-                scene_style = gr.Dropdown(
-                    ["realistic", "stylized", "low-poly", "fantasy"],
-                    label="Style",
-                    value="realistic"
-                )
-                scene_btn = gr.Button("📝 Generate BPY Script", variant="primary")
-            with gr.Column():
-                scene_desc = gr.Textbox(label="Generated BPY Script", lines=10)
-
-        scene_btn.click(generate_bpy_script, [scene_type, scene_style], scene_desc)
-
-        with gr.Row():
-            create_btn = gr.Button("🎬 Execute Script & Create 3D", variant="secondary")
-            scene_model = gr.Model3D(label="3D Scene")
-
-        create_btn.click(execute_bpy_script, scene_desc, scene_model)
-
-    with gr.Tab("Primitives"):
-        with gr.Row():
-            with gr.Column():
-                prim_type = gr.Dropdown(
-                    ["cube", "sphere", "cylinder", "cone", "torus", "plane", "monkey"],
-                    label="Primitive Type",
-                    value="cube"
-                )
-                prim_name = gr.Textbox(label="Name", value="MyObject")
-                prim_btn = gr.Button("🔲 Create Primitive", variant="primary")
-            with gr.Column():
-                prim_model = gr.Model3D(label="3D Preview")
-                prim_file = gr.File(label="Download GLB")
-
-        prim_btn.click(create_primitive, [prim_type, prim_name], prim_model)
-        prim_model.change(lambda x: x, inputs=[prim_model], outputs=[prim_file])
+    # Chat Interface Overlay
+    gr.Markdown("## Blender Chat", elem_classes="glass-title")
+
+    chatbot = gr.Chatbot(
+        elem_classes="glass-chat",
+        height=400,
+        placeholder="Beschreibe eine 3D Szene..."
+    )
+
+    with gr.Row():
+        msg = gr.Textbox(
+            placeholder="z.B. 'Erstelle eine Pyramide mit rotem Material'",
+            show_label=False,
+            elem_classes="glass-input",
+            scale=9
+        )
+        submit_btn = gr.Button("Senden", variant="primary", scale=1)
+
+    # Chat logic
+    def respond(message, chat_history):
+        if not message.strip():
+            return "", chat_history, None
+
+        response, render_path = chat_with_blender(message, chat_history)
+        chat_history.append((message, response))
+        return "", chat_history, render_path
+
+    submit_btn.click(
+        respond,
+        [msg, chatbot],
+        [msg, chatbot, render_output]
+    )
+    msg.submit(
+        respond,
+        [msg, chatbot],
+        [msg, chatbot, render_output]
+    )
 
     gr.Markdown("""
     ---
-    ### MCP Server
-    ```json
-    {
-      "mcpServers": {
-        "bpy-mcp": {
-          "url": "https://dev-bjoern-bpy-mcp.hf.space/gradio_api/mcp/sse"
-        }
-      }
-    }
-    ```
-
-    ### Models
-    - **SmolVLM**: `dev-bjoern/smolvlm-int4-ov` (Image-to-Text)
-    - **SmolLM3**: `dev-bjoern/smollm3-int4-ov` (Text Generation)
+    **MCP Server:** `https://dev-bjoern-bpy-mcp.hf.space/gradio_api/mcp/sse`
     """)