From a655feff9ef82de6032d4d1d4e93490922edd67b Mon Sep 17 00:00:00 2001
From: Victor Giers <mail@victorgiers.com>
Date: Thu, 14 May 2026 10:23:47 +0200
Subject: [PATCH] Initial Commit

---
 CLI/3d-model-image-prompt-generator.py |  262 +++
 generate_equirect.py                   |  142 ++
 image_to_3d.py                         |  218 +++
 main.py                                | 1241 +++++++++++++
 requirements.txt                       |   12 +
 run.sh                                 |   30 +
 scene_setup.py                         |   77 +
 web/index.html                         | 2375 ++++++++++++++++++++++++
 8 files changed, 4357 insertions(+)
 create mode 100644 CLI/3d-model-image-prompt-generator.py
 create mode 100644 generate_equirect.py
 create mode 100644 image_to_3d.py
 create mode 100644 main.py
 create mode 100644 requirements.txt
 create mode 100755 run.sh
 create mode 100644 scene_setup.py
 create mode 100644 web/index.html

diff --git a/CLI/3d-model-image-prompt-generator.py b/CLI/3d-model-image-prompt-generator.py
new file mode 100644
index 0000000..e35ca7e
--- /dev/null
+++ b/CLI/3d-model-image-prompt-generator.py
@@ -0,0 +1,262 @@
+import os
+import sys
+import requests
+import time
+import json
+import re
+import subprocess
+
+from langchain_community.llms import Ollama
+
+SD_WEBUI_PATH = "/Users/giers/Tools/stable-diffusion-webui"
+
+def is_sd_webui_running():
+    try:
+        r = requests.get("http://127.0.0.1:7860/sdapi/v1/txt2img", timeout=3)
+        # Should error because POST is required, but if it responds, it's running
+        return True
+    except Exception:
+        return False
+
+def start_sd_webui_headless(webui_dir):
+    # Use --headless, disable extensions/UIs for fastest startup
+    args = [
+        "python3", "launch.py",
+        "--nowebui",         # Don't launch browser UI
+        "--headless",        # No local UI window
+        "--api",             # Enable API
+        "--skip-torch-cuda-test",
+        "--no-hashing",      # Faster startup
+        "--disable-nan-check", # Optional: faster
+        "--xformers"
+    ]
+    proc = subprocess.Popen(
+        args,
+        cwd=webui_dir,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL
+    )
+    return proc
+
+def get_output_dir():
+    out_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "output")
+    os.makedirs(out_dir, exist_ok=True)
+    return out_dir
+
+
+def get_next_available_filename(base, ext=".png"):
+    out_dir = get_output_dir()
+    i = 1
+    while True:
+        fname = f"{base}-{i}{ext}"
+        fpath = os.path.join(out_dir, fname)
+        if not os.path.exists(fpath):
+            return fpath
+        i += 1
+
+def flush_print(*args, **kwargs):
+    print(*args, **kwargs)
+    sys.stdout.flush()
+
+OLLAMA_URL = "http://localhost:11434/api/generate"
+#MODEL = "mistral-small3.1:24b"
+MODEL = "mistral:latest"
+SD_URL = "http://127.0.0.1:7860/sdapi/v1/txt2img"
+
+META_PROMPT = """
+You are an expert at writing concise, detailed Stable Diffusion prompts for 3D rendered objects as seen in professional game development. When I give you an object name, carefully follow these instructions step by step:
+
+1. Subject ({{OBJECT}}):
+- Start with the object name ({{OBJECT}}).
+- Add 2–3 specific visual or material details (for example: shape, surface texture, design features like “chrome plating,” “organic armor,” “glowing eyes”).
+
+2. Medium & Style:
+- Add keywords for a 3D render and concept art look: 
+  concept art, 3D render, game asset, professional game designer, digital sculpture, hyperrealistic, octane render, Unreal Engine 5, high poly.
+
+3. Presentation:
+- Explicitly state the object is shown fully in frame, not cropped, and completely visible from a neutral angle.
+- No background: isolated on pure white background, or transparent background.
+
+4. Lighting & Quality:
+- Use studio lighting, no dramatic shadows, no depth of field, no blur.
+- Emphasize sharp focus, ultra detailed, 8K, clean silhouette.
+
+5. Artist Influence (optional):
+- If fitting, add a well-known concept artist (example: by Beeple).
+
+6. Negative Prompt:
+- Add: Negative prompt: blurry, lowres, bad anatomy, distorted proportions, background, scenery, environment, artifacting, watermark, text, cropped, partial view, depth of field, out of frame, blur, vignette
+
+Output Format:
+- Line 1: All positive prompt keywords (subject, details, medium, style, lighting, quality, artist, presentation, background).
+- Line 2: Start with Negative prompt: and then the negative keywords above.
+
+Instructions to the LLM:
+- The first line must always start with the object and its details.
+- The object must be fully visible, not cropped, and entirely in the image frame.
+- There must be no background, and the background must be pure white or transparent.
+- Do NOT use blur, depth of field, vignette, or any visual effects that obscure details.
+- Do NOT add any scenery or environment.
+- Be concise and avoid repetition.
+
+Now, generate a Stable Diffusion prompt for the object: {{OBJECT}}.
+"""
+
+SECOND_PROMPT_TEMPLATE = """
+You are a prompt-to-JSON converter for image generation tasks.
+
+Given a Stable Diffusion prompt, extract the positive and negative prompts.  
+Also, analyze the subject:  
+- If it is a single character, creature, full object, or person standing/upright, set "dimensions" to [512,768] (vertical).
+- If it is a landscape, wide object, multi-character group, or scene, set "dimensions" to [768,512] (horizontal).
+- If it is something square or best seen as a square (e.g., shield, logo, face, emblem, single centered item), set "dimensions" to [768,768] (square).
+
+Return a JSON object with these fields:
+{
+  "positive prompt": "...",
+  "negative prompt": "...",
+  "dimensions": [W,H]
+}
+
+Respond only with the JSON.  
+Here is the Stable Diffusion prompt:
+
+{PROMPT}
+"""
+
+
+# --- streaming LLM utility ---
+def stream_ollama(prompt):
+    payload = {"model": MODEL, "prompt": prompt, "stream": True}
+    with requests.post(OLLAMA_URL, json=payload, stream=True, timeout=300) as r:
+        r.raise_for_status()
+        full_response = ""
+        for line in r.iter_lines():
+            if line:
+                try:
+                    chunk = json.loads(line.decode("utf-8"))["response"]
+                except Exception:
+                    chunk = line.decode("utf-8")
+                print(chunk, end="", flush=True)
+                full_response += chunk
+        print()
+    return full_response.strip()
+
+def get_json_from_llm(prompt):
+    ollama_chain = Ollama(model=MODEL, base_url="http://localhost:11434")
+    response_gen = ollama_chain.stream(prompt)
+    json_output = ""
+    for chunk in response_gen:
+        print(chunk, end="", flush=True)
+        json_output += chunk
+    print()
+    # Try to extract JSON from output, even if LLM includes code block markers
+    json_start = json_output.find("{")
+    json_end = json_output.rfind("}")
+    if json_start != -1 and json_end != -1:
+        json_str = json_output[json_start:json_end+1]
+        try:
+            data = json.loads(json_str)
+            return data
+        except Exception as e:
+            print("Error parsing JSON:", e)
+            return None
+    print("Failed to extract JSON!")
+    return None
+
+def sanitize_filename(s):
+    # Replace spaces with underscores, remove non-alphanum chars
+    s = s.strip().lower().replace(" ", "_")
+    return re.sub(r'[^a-z0-9_]+', '', s)
+
+def call_stable_diffusion(prompt_json, user_input):
+    from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler
+    import torch
+
+    # *** Use your diffusers-converted path! ***
+    model_path = "/Volumes/SD/ML-Models/diffusers/dreamshaper_8_diffusers"
+
+    if torch.backends.mps.is_available():
+        device = "mps"
+        print("Using Apple Silicon MPS backend")
+    else:
+        device = "cpu"
+        print("Warning: Running on CPU (slow)")
+
+    print("Loading model, this may take a while the first time...", flush=True)
+    pipe = StableDiffusionPipeline.from_pretrained(
+        model_path,
+        torch_dtype=torch.float32,
+        safety_checker=None,
+        local_files_only=True,
+    )
+    pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
+    pipe = pipe.to(device)
+    pipe.set_progress_bar_config(disable=True)
+    pipe.enable_attention_slicing()
+
+    prompt = prompt_json["positive prompt"][:75]
+    negative_prompt = prompt_json["negative prompt"][:75]
+    width, height = prompt_json["dimensions"]
+    num_images = 4
+    steps = prompt_json.get("steps", 30)
+    guidance_scale = prompt_json.get("cfg_scale", 6.5)
+
+    print(f"Generating {num_images} image(s)...", flush=True)
+    images = pipe(
+        prompt=[prompt]*num_images,
+        negative_prompt=[negative_prompt]*num_images,
+        width=width,
+        height=height,
+        num_inference_steps=steps,
+        guidance_scale=guidance_scale,
+    ).images
+
+    img_base = sanitize_filename(user_input)
+    for idx, img in enumerate(images, start=1):
+        filename = get_next_available_filename(f"{img_base}-{idx}")
+        img.save(filename)
+        print(f"Saved: {filename}")
+
+def main():
+    try:
+        if len(sys.argv) < 2:
+            print("Usage: python 3d-model-image-prompt-generator.py \"object name\"", flush=True)
+            sys.exit(1)
+
+        object_name = sys.argv[1]
+        print(f"\n--- Generating Stable Diffusion prompt for: {object_name} ---\n", flush=True)
+        prompt = META_PROMPT.replace("{{OBJECT}}", object_name)
+
+        # 1. SD Prompt Generation (streamed)
+        sd_prompt = stream_ollama(prompt)
+        print("\n--- End of Stable Diffusion prompt ---\n", flush=True)
+
+        # 2. JSON Conversion (streamed)
+        print("--- Generating JSON for image generation ---\n", flush=True)
+        second_prompt = SECOND_PROMPT_TEMPLATE.replace("{PROMPT}", sd_prompt)
+        prompt_json = get_json_from_llm(second_prompt)
+        if not prompt_json:
+            print("Failed to get valid JSON. Exiting.", flush=True)
+            sys.exit(1)
+
+        # 3. Augment JSON with hard-coded SD settings
+        prompt_json["checkpoint"] = "RealismPlus/dreamshaper_8.safetensors"
+        prompt_json["vae"] = "Automatic"
+        prompt_json["sampler"] = "DPM++ 2M Karras"
+        prompt_json["steps"] = 30
+        prompt_json["cfg_scale"] = 6.5
+
+        print("\n--- Final prompt JSON ---\n", flush=True)
+        print(json.dumps(prompt_json, indent=2, ensure_ascii=False), flush=True)
+
+        # 4. Call local Stable Diffusion via diffusers
+        call_stable_diffusion(prompt_json, object_name)
+    except Exception as e:
+        import traceback
+        print("Exception in main():", e, flush=True)
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/generate_equirect.py b/generate_equirect.py
new file mode 100644
index 0000000..9d12e60
--- /dev/null
+++ b/generate_equirect.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+import argparse
+import os
+import subprocess
+import torch
+from PIL import Image, ImageDraw
+import shutil
+import tempfile
+
+from diffusers import (
+    StableDiffusionPipeline,
+    DPMSolverMultistepScheduler,
+    StableDiffusionInpaintPipeline
+)
+
+def shift_image(img: Image.Image, shift: int) -> Image.Image:
+    w, h = img.size
+    out = Image.new("RGB", (w, h))
+    out.paste(img.crop((shift, 0, w, h)), (0, 0))
+    out.paste(img.crop((0, 0, shift, h)), (w - shift, 0))
+    return out
+
+def create_mask(width: int, height: int, mask_w: int) -> Image.Image:
+    mask = Image.new("L", (width, height), 0)
+    draw = ImageDraw.Draw(mask)
+    left = (width - mask_w) // 2
+    draw.rectangle([left, 0, left + mask_w, height], fill=255)
+    return mask
+
+def unshift_image(img: Image.Image, shift: int) -> Image.Image:
+    w, h = img.size
+    out = Image.new("RGB", (w, h))
+    out.paste(img.crop((w - shift, 0, w, h)), (0, 0))
+    out.paste(img.crop((0, 0, w - shift, h)), (shift, 0))
+    return out
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Generate an equirectangular HDRI, make it seamless, and upscale it with Topaz Photo AI CLI."
+    )
+    parser.add_argument("--prompt", required=True,
+                        help="Text prompt for generation and inpainting")
+    parser.add_argument("--output", required=True,
+                        help="Filename for the final upscaled image (e.g. seamless.png)")
+    parser.add_argument("--work-dir", default=os.path.dirname(os.path.abspath(__file__)),
+                        help="Working directory for intermediates and final outputs")
+    args = parser.parse_args()
+
+    # Output-Ordner (bleibt wie gehabt)
+    output_abs = os.path.abspath(args.output)
+
+    # Zwischenschritte landen im eigenem temp-Ordner:
+    with tempfile.TemporaryDirectory(dir=args.work_dir) as tempdir:
+        print(f"→ Using tempdir: {tempdir}")
+
+        model_path = "/Volumes/SD/ML-Models/diffusers/hdri-panorama-v1-diffusers"
+        topaz_cli = "/Applications/Topaz Photo AI.app/Contents/MacOS/Topaz Photo AI"
+        steps = 20
+        scale = 7.0
+        width, height = 1024, 512
+
+        if torch.backends.mps.is_available():
+            device = "mps"
+        elif torch.cuda.is_available():
+            device = "cuda"
+        else:
+            device = "cpu"
+
+        # 1) Generate base HDRI
+        gen_pipe = StableDiffusionPipeline.from_pretrained(
+            model_path,
+            torch_dtype=torch.float32
+        ).to(device)
+        gen_pipe.scheduler = DPMSolverMultistepScheduler.from_config(gen_pipe.scheduler.config)
+        gen_pipe.enable_attention_slicing()
+
+        print("→ Generating equirectangular HDRI…")
+        image = gen_pipe(
+            prompt=args.prompt,
+            num_inference_steps=steps,
+            guidance_scale=scale-1.5,
+            width=width,
+            height=height
+        ).images[0]
+
+        gen_path = os.path.join(tempdir, f"base_{width}x{height}.png")
+        image.save(gen_path)
+        print(f"→ Saved initial image to {gen_path}")
+
+        # 2) Make it seamless
+        shift_amt = width // 2
+        mask_w = width // 8
+
+        shifted = shift_image(image, shift_amt)
+        mask = create_mask(width, height, mask_w)
+
+        inpaint_pipe = StableDiffusionInpaintPipeline.from_pretrained(
+            "Lykon/dreamshaper-8-inpainting",
+            torch_dtype=torch.float32
+        ).to(device)
+        inpaint_pipe.enable_attention_slicing()
+
+        print("→ Inpainting seam for seamless tiling…")
+        inpainted = inpaint_pipe(
+            prompt=args.prompt,
+            image=shifted,
+            mask_image=mask,
+            num_inference_steps=steps,
+            guidance_scale=scale,
+            width=width,
+            height=height
+        ).images[0]
+
+        seamless_path = os.path.join(tempdir, os.path.basename(args.output))
+        inpainted = unshift_image(inpainted, shift_amt)
+        inpainted.save(seamless_path)
+        print(f"→ Crafted seamless image: {seamless_path}")
+
+        # 3) Upscale with Topaz Photo AI CLI
+        print("→ Upscaling with Topaz Photo AI CLI…")
+        result = subprocess.run(
+            [topaz_cli, "--cli", seamless_path, "-o", tempdir],
+            check=True
+        )
+
+        # Finde das letzte erstellte PNG im tempdir (das ist das hochskalierte!)
+        # Topaz kann einen Suffix anhängen, falls der Name schon existiert.
+        upscaled_files = sorted(
+            [os.path.join(tempdir, f) for f in os.listdir(tempdir) if f.lower().endswith(".png")],
+            key=os.path.getmtime,
+            reverse=True
+        )
+        if not upscaled_files:
+            print("→ No PNG output found in tempdir after Topaz run!")
+            return
+
+        upscaled = upscaled_files[0]
+        shutil.move(upscaled, output_abs)
+        print(f"→ Upscaled image moved to {output_abs}")
+
+if __name__ == "__main__":
+    main()
\ No newline at end of file
diff --git a/image_to_3d.py b/image_to_3d.py
new file mode 100644
index 0000000..20758e7
--- /dev/null
+++ b/image_to_3d.py
@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+import base64
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import Any
+
+import replicate
+import requests
+from PIL import Image
+
+MODEL_NAME = "tencent/hunyuan-3d-3.1"
+TIMEOUT = 900
+PREDICTION_TIMEOUT = 10 * 60
+POLL_INTERVAL = 2.0
+MAX_INPUT_BYTES = 6 * 1024 * 1024
+MAX_DATA_URI_BYTES = 1024 * 1024
+MAX_INPUT_SIDE = 2048
+SUPPORTED_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp"}
+
+
+def notify(title: str, message: str) -> None:
+    script = f"display notification {json.dumps(message)} with title {json.dumps(title)}"
+    try:
+        subprocess.run(["osascript", "-e", script], check=False)
+    except OSError:
+        pass
+
+
+def _has_alpha(img: Image.Image) -> bool:
+    return img.mode in {"RGBA", "LA"} or (
+        img.mode == "P" and "transparency" in img.info
+    )
+
+
+def _save_compact_image(img: Image.Image, output_path: str) -> None:
+    if max(img.size) > MAX_INPUT_SIDE:
+        img = img.copy()
+        img.thumbnail((MAX_INPUT_SIDE, MAX_INPUT_SIDE), Image.Resampling.LANCZOS)
+
+    if _has_alpha(img):
+        img.save(output_path, "WEBP", quality=95, method=6)
+        return
+
+    if img.mode != "RGB":
+        img = img.convert("RGB")
+    img.save(output_path, "JPEG", quality=92, optimize=True)
+
+
+def prepare_input_image(src_path: str, temp_paths: list[str]) -> str:
+    ext = Path(src_path).suffix.lower()
+    if ext in SUPPORTED_EXTENSIONS and os.path.getsize(src_path) <= MAX_DATA_URI_BYTES:
+        return src_path
+
+    img = Image.open(src_path)
+    suffix = ".webp" if _has_alpha(img) else ".jpg"
+    fd, temp_path = tempfile.mkstemp(suffix=suffix)
+    os.close(fd)
+    _save_compact_image(img, temp_path)
+    temp_paths.append(temp_path)
+
+    if os.path.getsize(temp_path) > MAX_INPUT_BYTES:
+        raise RuntimeError("Prepared image is still larger than Replicate's 6MB limit.")
+
+    return temp_path
+
+
+def run_replicate(image_path: str, api_token: str) -> Any:
+    client = replicate.Client(api_token=api_token)
+    client.poll_interval = POLL_INTERVAL
+
+    with open(image_path, "rb") as image_file:
+        prediction = client.models.predictions.create(
+            model=MODEL_NAME,
+            input={
+                "image": image_file,
+                "generate_type": "Normal",
+                "face_count": 500000,
+                "enable_pbr": False,
+            },
+            wait=False,
+            file_encoding_strategy="base64",
+        )
+
+    print(f"Replicate prediction started: {prediction.id} ({prediction.status})")
+    deadline = time.monotonic() + PREDICTION_TIMEOUT
+    last_status = prediction.status
+
+    while prediction.status not in {"succeeded", "failed", "canceled"}:
+        if time.monotonic() >= deadline:
+            raise TimeoutError(
+                f"Timed out waiting for Replicate prediction {prediction.id} "
+                f"after {PREDICTION_TIMEOUT // 60} minutes. It may still be running."
+            )
+
+        time.sleep(client.poll_interval)
+        prediction.reload()
+
+        if prediction.status != last_status:
+            print(f"Replicate prediction {prediction.id}: {prediction.status}")
+            last_status = prediction.status
+
+    if prediction.status != "succeeded":
+        detail = prediction.error or prediction.logs or f"status={prediction.status}"
+        raise RuntimeError(f"Replicate prediction {prediction.id} failed: {detail}")
+
+    return prediction.output
+
+
+def _extract_output_file(output: Any) -> Any:
+    if isinstance(output, (list, tuple)):
+        if not output:
+            raise RuntimeError("Replicate returned an empty output.")
+        return output[0]
+
+    if isinstance(output, dict):
+        for key in ("output", "model", "mesh", "glb", "url"):
+            if output.get(key):
+                return _extract_output_file(output[key])
+        raise RuntimeError(f"Replicate returned an unsupported output shape: {output}")
+
+    return output
+
+
+def _bytes_from_url(url: str) -> bytes:
+    if url.startswith("data:"):
+        _, encoded = url.split(",", 1)
+        return base64.b64decode(encoded)
+
+    response = requests.get(url, timeout=TIMEOUT)
+    response.raise_for_status()
+    return response.content
+
+
+def write_output(output: Any, output_path: str) -> None:
+    output_file = _extract_output_file(output)
+
+    if hasattr(output_file, "read"):
+        data = output_file.read()
+    elif hasattr(output_file, "url"):
+        data = _bytes_from_url(str(output_file.url))
+    elif isinstance(output_file, str):
+        data = _bytes_from_url(output_file)
+    else:
+        raise RuntimeError(f"Replicate returned an unsupported output type: {type(output_file)!r}")
+
+    with open(output_path, "wb") as f:
+        f.write(data)
+
+
+def process_image(img_path: str, api_token: str | None = None) -> str | None:
+    api_token = (api_token or os.environ.get("REPLICATE_API_TOKEN", "")).strip()
+    if not api_token:
+        msg = "Missing Replicate API token. Add it in app settings or set REPLICATE_API_TOKEN."
+        print(msg)
+        notify("3D conversion error", msg)
+        return None
+
+    img_path = os.path.abspath(img_path)
+    if not os.path.isfile(img_path):
+        msg = f"Image not found: {img_path}"
+        print(msg)
+        notify("3D conversion error", msg)
+        return None
+
+    temp_paths: list[str] = []
+    try:
+        input_path = prepare_input_image(img_path, temp_paths)
+        base_name = os.path.splitext(os.path.basename(img_path))[0]
+        output_path = os.path.join(os.path.dirname(img_path), f"{base_name}.glb")
+
+        print(f"Running {MODEL_NAME} on Replicate...")
+        output = run_replicate(input_path, api_token)
+        write_output(output, output_path)
+
+        msg = f"3D model saved: {output_path}"
+        print(msg)
+        notify("3D conversion complete", msg)
+        return output_path
+    except Exception as e:
+        msg = f"3D conversion failed for {img_path}: {e}"
+        print(msg)
+        notify("3D conversion error", msg)
+        return None
+    finally:
+        for temp_path in temp_paths:
+            try:
+                os.remove(temp_path)
+            except OSError:
+                pass
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        msg = "Usage: python image_to_3d.py <image1> [image2 ...]"
+        notify("3D conversion error", "No image files provided.")
+        print(msg)
+        sys.exit(1)
+
+    outputs = []
+    for img_path in sys.argv[1:]:
+        print(f"\nProcessing: {img_path}")
+        result = process_image(img_path)
+        if result:
+            outputs.append(result)
+
+    if not outputs:
+        sys.exit(1)
+
+    notify("3D conversion", f"Finished {len(outputs)} model(s).")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/main.py b/main.py
new file mode 100644
index 0000000..0e9d240
--- /dev/null
+++ b/main.py
@@ -0,0 +1,1241 @@
+import os
+import sys
+import json
+import re
+import requests
+import threading
+import time
+import base64
+import io
+import webview
+import random
+import subprocess
+import concurrent.futures
+from PIL import Image, PngImagePlugin
+from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler
+import torch
+import replicate
+
+# ------------- Configuration -------------
+
+OLLAMA_URL = "http://localhost:11434/api/generate"
+MODEL = "mistral:latest"  # or "mistral-small3.1:24b"
+
+# Path to your diffusers-converted model
+MODEL_PATH = "/Volumes/SD/ML-Models/diffusers/dreamshaper_8_diffusers"
+
+# Where to save generated images
+BASE_DIR   = os.path.dirname(os.path.abspath(__file__))
+# ────────────────────────────────────────────────────────────────────────────
+# Store everything under web/output instead of project_root/output
+WEB_DIR    = os.path.join(BASE_DIR, "web")
+OUTPUT_DIR = os.path.join(WEB_DIR, "output")
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+APP_SUPPORT_DIR = os.path.join(
+    os.path.expanduser("~"),
+    "Library",
+    "Application Support",
+    "3d-model-generator",
+)
+SETTINGS_PATH = os.path.join(APP_SUPPORT_DIR, "settings.json")
+# ────────────────────────────────────────────────────────────────────────────
+
+IMAGE_BACKEND_LOCAL = "local"
+IMAGE_BACKEND_REPLICATE = "replicate"
+DEFAULT_IMAGE_BACKEND = IMAGE_BACKEND_LOCAL
+DEFAULT_REPLICATE_IMAGE_MODEL = "google/imagen-4-fast"
+REPLICATE_IMAGE_TIMEOUT = 10 * 60
+REPLICATE_IMAGE_POLL_INTERVAL = 2.0
+
+REPLICATE_IMAGE_MODELS = {
+    "black-forest-labs/flux-schnell": {
+        "label": "FLUX.1 schnell",
+        "price": "$3 / 1000 output images (~$0.003/image)",
+        "aspect_ratios": ["1:1", "16:9", "21:9", "3:2", "2:3", "4:5", "5:4", "3:4", "4:3", "9:16", "9:21"],
+    },
+    "google/imagen-4-fast": {
+        "label": "Google Imagen 4 Fast",
+        "price": "$0.02 / output image",
+        "aspect_ratios": ["1:1", "9:16", "16:9", "3:4", "4:3"],
+    },
+    "bytedance/seedream-4": {
+        "label": "ByteDance Seedream 4",
+        "price": "$0.03 / output image",
+        "aspect_ratios": ["1:1", "4:3", "3:4", "16:9", "9:16", "3:2", "2:3", "21:9"],
+    },
+}
+
+
+def load_app_settings() -> dict:
+    try:
+        with open(SETTINGS_PATH, "r", encoding="utf-8") as f:
+            settings = json.load(f)
+            return settings if isinstance(settings, dict) else {}
+    except FileNotFoundError:
+        return {}
+    except Exception:
+        return {}
+
+
+def save_app_settings(settings: dict) -> None:
+    os.makedirs(APP_SUPPORT_DIR, exist_ok=True)
+    with open(SETTINGS_PATH, "w", encoding="utf-8") as f:
+        json.dump(settings, f, indent=2)
+
+# ------------- Prompt Templates -------------
+
+META_PROMPT = """
+You are an expert at writing concise, detailed Stable Diffusion prompts for 3D rendered objects, as seen in professional game development.
+
+When I give you an object name (which may already contain style or material cues, e.g. "low poly farmer" or "pixel art sword"), follow these rules:
+
+1. Parse the object name:
+- If the object name includes a style, technique, or specific look (e.g., low poly, pixel art, voxel, cartoon, realistic, hand painted, clay, wireframe, etc.), make that style the focus of the prompt.
+- Do NOT add conflicting style keywords. (E.g. do NOT add high poly if the input is low poly.)
+- If the object name is generic (like farmer or spaceship), you may suggest professional, detailed, high-quality, realistic or stylized game art (choose one style, do NOT mix).
+- Add 2–3 relevant visual or material details to the object, based on typical game art conventions.
+
+2. Medium & Style:
+- If the object name includes a medium, engine, or tool (Unreal, Octane, Unity, voxel, etc.), use it and do NOT add others.
+- Otherwise, you may choose (but do NOT mix) one or two: concept art, 3D render, game asset, professional game designer, digital sculpture, etc.
+
+3. Presentation:
+- State that the object is fully visible, not cropped, and centered from a neutral angle.
+- No background: isolated on pure white or transparent background.
+
+4. Lighting & Quality:
+- Only add studio lighting, sharp focus, clean silhouette, ultra detailed, 8K, etc. if compatible with the style.
+- Avoid depth of field, blur, or effects that obscure details, unless specifically requested.
+
+5. Negative Prompt:
+- Always add: Negative prompt: blurry, lowres, bad anatomy, distorted proportions, background, scenery, environment, artifacting, watermark, text, cropped, partial view, depth of field, out of frame, blur, vignette
+
+Output Format:
+- Line 1: All positive prompt keywords (subject, details, medium, style, lighting, quality, presentation, background).
+- Line 2: Negative prompt: then the negative keywords above.
+
+Instructions:
+- If the input object already specifies a style or technique, your prompt must reflect that and avoid all contradictory terms.
+- Always keep the style consistent.
+- Avoid unnecessary repetition.
+- Never add stylistic terms that contradict or dilute the user’s intention.
+- The positive prompt must not contain more than 300 characters. Make it just fit 300 characters, not too long, not too short but perfect for a Stable Diffusion prompt.
+- If the prompt is short, come up with creative ideas on how to make the character or object more intricate and interesting, suitable for game design. Add creative details to what the presented things might look like!
+- Use positive descriptions of what should be visible in the positive prompt, don't use negations there.
+- Most importantly, the prompts must make sure in some way that the object or character is FULLY visible (not cropped) on a blank background.
+
+Now, generate a Stable Diffusion prompt for the object: {{OBJECT}}
+"""
+
+SECOND_PROMPT_TEMPLATE = """
+You are a prompt-to-JSON converter for image generation tasks.
+
+Given a Stable Diffusion prompt, extract the positive and negative prompts.
+If the prompt is longer than 300 characters, summarize it so that it's less than 300 characters long.
+If you need to shorten your prompt, always remove less relevant visual details first.
+Never remove the presentation instructions (e.g., fully visible, isolated, centered, white background); these must always remain at the end of the positive prompt.
+Remove words that are followed by a semicolon (i.e. "Presentation:" or "Lighting & Quality:") - these things have no business in a Stable Diffusion prompt.
+
+Also, analyze the subject:
+- If it is a single character, an upright (bipedal) creature, full object, a person, or anything similar, set "dimensions" to [512,768] (vertical). (In that case of a bipedal creature / human, you might also add "A-Pose" to the prompt!)
+- If it is a landscape, wide object, multi-character group, or scene, or a creature that isn't tall (four-legged creatures for example), set "dimensions" to [768,512] (horizontal).
+- If it is something square or best seen as a square (e.g., shield, logo, face, emblem, single centered item or a box or round-shaped creature), set "dimensions" to [768,768] (square).
+
+Return a JSON object with these fields:
+{
+  "positive prompt": "...",
+  "negative prompt": "...",
+  "dimensions": [W,H]
+}
+
+Respond only with the JSON.
+Here is the Stable Diffusion prompt:
+
+{PROMPT}
+"""
+
+# ------------- Helper Functions -------------
+
+def stream_ollama(prompt: str):
+    """
+    Stream tokens from Ollama.
+    Yields the cumulative response string after each new chunk arrives.
+    """
+    payload = {"model": MODEL, "prompt": prompt, "stream": True}
+    with requests.post(OLLAMA_URL, json=payload, stream=True, timeout=600) as r:
+        r.raise_for_status()
+        full_response = ""
+        for line in r.iter_lines():
+            if line:
+                try:
+                    chunk = json.loads(line.decode("utf-8"))["response"]
+                except Exception:
+                    chunk = line.decode("utf-8")
+                full_response += chunk
+                yield full_response
+        yield full_response.strip()
+
+def get_json_from_llm(prompt: str):
+    """
+    Stream the JSON conversion call to Ollama (no LangChain).
+    Yields the cumulative response string after each chunk arrives.
+    """
+    payload = {"model": MODEL, "prompt": prompt, "stream": True}
+    with requests.post(OLLAMA_URL, json=payload, stream=True, timeout=600) as r:
+        r.raise_for_status()
+        full_response = ""
+        for line in r.iter_lines():
+            if line:
+                try:
+                    chunk = json.loads(line.decode("utf-8"))["response"]
+                except Exception:
+                    chunk = line.decode("utf-8")
+                full_response += chunk
+                yield full_response
+        yield full_response.strip()
+
+def sanitize_filename(s: str) -> str:
+    s = s.strip().lower().replace(" ", "_")
+    return re.sub(r'[^a-z0-9_]+', '', s)
+
+def get_next_available_filename(base: str, ext: str = ".png") -> str:
+    i = 1
+    while True:
+        fname = f"{base}-{i}{ext}"
+        # → hier steht noch fpath = f"output/{fname}"
+        fpath = os.path.join(OUTPUT_DIR, fname)
+        if not os.path.exists(fpath):
+            return fpath
+        i += 1
+
+def image_to_base64(path: str) -> str:
+    """
+    Read an image from disk and return a data: URI string.
+    """
+    with open(path, "rb") as f:
+        b64 = base64.b64encode(f.read()).decode("utf-8")
+    return f"data:image/png;base64,{b64}"
+
+
+def normalize_image_backend(value: str | None) -> str:
+    value = (value or DEFAULT_IMAGE_BACKEND).strip().lower()
+    if value in {IMAGE_BACKEND_LOCAL, IMAGE_BACKEND_REPLICATE}:
+        return value
+    return DEFAULT_IMAGE_BACKEND
+
+
+def normalize_replicate_image_model(value: str | None) -> str:
+    value = (value or DEFAULT_REPLICATE_IMAGE_MODEL).strip()
+    if value in REPLICATE_IMAGE_MODELS:
+        return value
+    return DEFAULT_REPLICATE_IMAGE_MODEL
+
+
+def nearest_aspect_ratio(width: int, height: int, allowed: list[str]) -> str:
+    if width <= 0 or height <= 0:
+        return "1:1" if "1:1" in allowed else allowed[0]
+
+    target = width / height
+
+    def ratio_value(value: str) -> float:
+        left, right = value.split(":", 1)
+        return float(left) / float(right)
+
+    return min(allowed, key=lambda option: abs(ratio_value(option) - target))
+
+
+def compose_replicate_prompt(prompt_json: dict) -> str:
+    positive = str(prompt_json.get("positive prompt", "")).strip()
+    negative = str(prompt_json.get("negative prompt", "")).strip()
+    if not negative:
+        return positive
+    return f"{positive}\nAvoid: {negative}"
+
+
+def extract_replicate_output_urls(output) -> list[str]:
+    if output is None:
+        return []
+    if hasattr(output, "url"):
+        return [str(output.url)]
+    if isinstance(output, str):
+        return [output]
+    if isinstance(output, (list, tuple)):
+        urls = []
+        for item in output:
+            urls.extend(extract_replicate_output_urls(item))
+        return urls
+    if isinstance(output, dict):
+        urls = []
+        for item in output.values():
+            urls.extend(extract_replicate_output_urls(item))
+        return urls
+    return []
+
+
+def load_image_from_url(url: str) -> Image.Image:
+    if url.startswith("data:"):
+        _, encoded = url.split(",", 1)
+        data = base64.b64decode(encoded)
+    else:
+        response = requests.get(url, timeout=REPLICATE_IMAGE_TIMEOUT)
+        response.raise_for_status()
+        data = response.content
+
+    img = Image.open(io.BytesIO(data))
+    if img.mode in {"RGBA", "LA"} or (img.mode == "P" and "transparency" in img.info):
+        return img.convert("RGBA")
+    return img.convert("RGB")
+
+
+def save_generated_image(img: Image.Image, prompt_json: dict, object_name: str, idx: int, batch_count: int) -> str:
+    fname = get_next_available_filename(f"{sanitize_filename(object_name)}-{idx}")
+    metadata = dict(prompt_json, created=int(time.time()), batch_count=batch_count)
+    meta = PngImagePlugin.PngInfo()
+    meta.add_text("sd_json", json.dumps(metadata))
+    img.save(fname, pnginfo=meta)
+    with open(fname + ".json", "w", encoding="utf-8") as f:
+        json.dump(metadata, f, indent=2)
+    return fname
+
+
+def call_stable_diffusion(prompt_json: dict, user_input: str) -> list[str]:
+    """
+    Generate 'n_imgs' images from diffusers, save to disk with embedded prompt JSON,
+    write sidecar .json, and return the file paths.
+    """
+    if torch.backends.mps.is_available():
+        device = "mps"
+    else:
+        device = "cpu"
+
+    # Load pipeline
+    pipe = StableDiffusionPipeline.from_pretrained(
+        MODEL_PATH,
+        torch_dtype=torch.float32,
+        safety_checker=None,
+        local_files_only=True
+    )
+    pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
+    pipe = pipe.to(device)
+    pipe.set_progress_bar_config(disable=True)
+    pipe.enable_attention_slicing()
+
+    pos_prompt = prompt_json["positive prompt"]
+    neg_prompt = prompt_json["negative prompt"]
+    width, height = prompt_json["dimensions"]
+    steps = prompt_json.get("steps", 30)
+    guidance_scale = prompt_json.get("cfg_scale", 6.5)
+    batch_count = int(prompt_json.get("batch_count", 4))  # Standard: 4
+
+    images = pipe(
+        prompt=[pos_prompt] * batch_count,
+        negative_prompt=[neg_prompt] * batch_count,
+        width=width,
+        height=height,
+        num_inference_steps=steps,
+        guidance_scale=guidance_scale
+    ).images
+
+    img_base = sanitize_filename(user_input)
+    out_files = []
+    import time
+    for idx, img in enumerate(images, start=1):
+        filename = get_next_available_filename(f"{img_base}-{idx}")
+
+        # Timestamp und batch_count speichern
+        prompt_json_with_time = dict(prompt_json)
+        prompt_json_with_time["created"] = int(time.time())
+        prompt_json_with_time["batch_count"] = batch_count
+
+        # Metadata und Sidecar wie gehabt
+        meta = PngImagePlugin.PngInfo()
+        meta.add_text("sd_json", json.dumps(prompt_json_with_time))
+        img.save(filename, pnginfo=meta)
+        sidecar_path = filename + ".json"
+        with open(sidecar_path, "w", encoding="utf-8") as f:
+            json.dump(prompt_json_with_time, f, indent=2)
+        out_files.append(filename)
+    return out_files
+
+
+# ------------- JSON “Fuzzy” Validator -------------
+
+def validate_and_fix_json(raw: str) -> tuple[dict, str] | tuple[None, None]:
+    """
+    1) Try a strict json.loads(raw).
+    2) If that fails, attempt to fix:
+       - Remove trailing commas (e.g. {"a":1,} -> {"a":1})
+       - Replace single quotes with double quotes (naïve)
+    3) If the “fixed” string parses, return (parsed_dict, fixed_string).
+    Otherwise, return (None, None).
+    """
+    try:
+        parsed = json.loads(raw)
+        return parsed, raw
+    except Exception:
+        # Attempt quick fixes:
+        s = raw
+        # 1) Remove any trailing commas before } or ]
+        s = re.sub(r",\s*([}\]])", r"\1", s)
+        # 2) Replace single quotes around keys/values with double quotes (naïve)
+        s = re.sub(r"(?P<pre>[:\s])'(?P<val>[^']*)'", r'\1"\g<val>"', s)
+        try:
+            parsed = json.loads(s)
+            return parsed, s
+        except Exception:
+            return None, None
+
+# ------------- PyWebview API -------------
+
+class Api:
+    def __init__(self):
+        self.window = None
+        self.last_object = ""
+        self.last_prompt_json = None
+        self._abort_sd = False
+        self._placeholders_ready_events = {}
+
+        # Keep track of file modification times
+        self._mtimes: dict[str, float] = {}
+        # Start folder watcher thread
+        watcher = threading.Thread(target=self._monitor_folder, daemon=True)
+        watcher.start()
+
+    def set_window(self, win):
+        self.window = win
+
+    def generate_prompt(self, object_name: str):
+        """
+        Runs only the LLM -> JSON steps (no Stable Diffusion).
+        """
+        self.last_object = object_name
+        self.last_prompt_json = None
+        threading.Thread(target=self._run_llm_to_json, args=(object_name,), daemon=True).start()
+        return {"status": "started_prompt"}
+
+    def _run_llm_to_json(self, object_name: str):
+        # 1) LLM streaming
+        llm_text = ""
+        llm_prompt = META_PROMPT.replace("{{OBJECT}}", object_name)
+        for chunk in stream_ollama(llm_prompt):
+            llm_text = chunk
+            self._js("window.on_llm_output", llm_text)
+        self._js("window.on_llm_done")
+
+        # 2) JSON streaming
+        json_text = ""
+        json_prompt = SECOND_PROMPT_TEMPLATE.replace("{PROMPT}", llm_text)
+        for chunk in get_json_from_llm(json_prompt):
+            json_text = chunk
+            self._js("window.on_json_output", json_text)
+        self._js("window.on_json_done")
+
+        # 3) Parse JSON
+        try:
+            prompt_dict = json.loads(json_text)
+        except Exception as e:
+            self._js("window.on_error", f"JSON parse error: {e}")
+            return
+
+        # 4) Augment with SD settings
+        prompt_dict["checkpoint"] = "RealismPlus/dreamshaper_8.safetensors"
+        prompt_dict["vae"] = "Automatic"
+        prompt_dict["sampler"] = "DPM++ 2M Karras"
+        prompt_dict["steps"] = 30
+        prompt_dict["cfg_scale"] = 6.5
+        prompt_dict["batch_count"] = 4
+
+        # 5) Send full JSON
+        full_json_str = json.dumps(prompt_dict, indent=2)
+        self._js("window.on_json_output", full_json_str)
+
+        # 6) Store for images
+        self.last_prompt_json = prompt_dict
+
+    def generate_images(self, json_str: str):
+        """
+        Called from JS when “Generate Images” is clicked.
+        1) Validate/fix JSON (fuzzy).
+        2) Ensure “positive prompt” is nonempty.
+        3) Auto fill missing keys (dimensions, checkpoint, etc.)
+        4) Kick off Stable Diffusion.
+        """
+        parsed, fixed = validate_and_fix_json(json_str)
+        if parsed is None:
+            self._js("window.on_error", "Cannot parse JSON (even after auto-fix).")
+            return {"status": "invalid_json"}
+
+        pos = parsed.get("positive prompt", "").strip()
+        if not pos:
+            self._js("window.on_error", "“positive prompt” must not be empty.")
+            return {"status": "empty_positive"}
+
+        # Auto-fill missing/malformed keys
+        dims = parsed.get("dimensions")
+        if not (
+            isinstance(dims, list)
+            and len(dims) == 2
+            and all(isinstance(x, int) for x in dims)
+        ):
+            parsed["dimensions"] = [768, 768]
+        parsed.setdefault("checkpoint", "RealismPlus/dreamshaper_8.safetensors")
+        parsed.setdefault("vae", "Automatic")
+        parsed.setdefault("sampler", "DPM++ 2M Karras")
+        parsed.setdefault("steps", 30)
+        parsed.setdefault("cfg_scale", 6.5)
+        parsed.setdefault("batch_count", 4)
+        
+        # If we “fixed” it, push corrected JSON back
+        full_json_str = json.dumps(parsed, indent=2)
+        if fixed is None or full_json_str != json_str:
+            self._js("window.on_json_output", full_json_str)
+
+        # Store and infer last_object if not yet set
+        self.last_prompt_json = parsed
+        if not self.last_object:
+            # Derive a base name from the positive prompt (before first comma)
+            cand = pos.split(",")[0]
+            base = re.sub(r"\s+", "_", cand.strip().lower())
+            base = re.sub(r"[^a-z0-9_]+", "", base)
+            self.last_object = base or "image"
+
+        # Launch SD thread – vorher Abort-Flag zurücksetzen
+        self._abort_sd = False
+        threading.Thread(target=self._run_sd_only, daemon=True).start()
+        return {"status": "started_images"}
+
+    def _get_image_generation_backend(self) -> str:
+        return normalize_image_backend(load_app_settings().get("image_generation_backend"))
+
+    def _get_replicate_image_model(self) -> str:
+        return normalize_replicate_image_model(load_app_settings().get("replicate_image_model"))
+
+    def _run_local_diffusion_images(self, batch_count: int) -> list[Image.Image]:
+        device = "mps" if torch.backends.mps.is_available() else "cpu"
+
+        pipe = StableDiffusionPipeline.from_pretrained(
+            MODEL_PATH, torch_dtype=torch.float32,
+            safety_checker=None, local_files_only=True
+        )
+        pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
+        pipe = pipe.to(device)
+        pipe.set_progress_bar_config(disable=True)
+        pipe.enable_attention_slicing()
+
+        pos = self.last_prompt_json["positive prompt"]
+        neg = self.last_prompt_json["negative prompt"]
+        w, h = self.last_prompt_json["dimensions"]
+        steps = self.last_prompt_json.get("steps", 30)
+        cfg = self.last_prompt_json.get("cfg_scale", 6.5)
+
+        def _check_abort(*args, **kwargs):
+            if self._abort_sd:
+                raise RuntimeError("User aborted")
+            return {}
+
+        outputs = pipe(
+            prompt=[pos] * batch_count,
+            negative_prompt=[neg] * batch_count,
+            width=w, height=h,
+            num_inference_steps=steps,
+            guidance_scale=cfg,
+            callback_on_step_end=_check_abort,
+        )
+        return outputs.images
+
+    def _build_replicate_image_input(self, model_id: str, num_outputs: int) -> dict:
+        model = REPLICATE_IMAGE_MODELS[model_id]
+        w, h = self.last_prompt_json["dimensions"]
+        ratio = nearest_aspect_ratio(w, h, model["aspect_ratios"])
+        prompt = compose_replicate_prompt(self.last_prompt_json)
+
+        if model_id == "black-forest-labs/flux-schnell":
+            steps = int(self.last_prompt_json.get("steps", 4))
+            return {
+                "prompt": prompt,
+                "aspect_ratio": ratio,
+                "num_outputs": max(1, min(int(num_outputs), 4)),
+                "num_inference_steps": max(1, min(steps, 4)),
+                "output_format": "png",
+                "go_fast": True,
+                "megapixels": "1",
+            }
+
+        if model_id == "google/imagen-4-fast":
+            return {
+                "prompt": prompt,
+                "aspect_ratio": ratio,
+                "output_format": "png",
+                "safety_filter_level": "block_only_high",
+            }
+
+        if model_id == "bytedance/seedream-4":
+            return {
+                "prompt": prompt,
+                "aspect_ratio": ratio,
+                "size": "2K",
+                "max_images": 1,
+                "enhance_prompt": False,
+                "sequential_image_generation": "disabled",
+            }
+
+        raise RuntimeError(f"Unsupported Replicate image model: {model_id}")
+
+    def _run_replicate_prediction(self, model_id: str, input_payload: dict):
+        token = self._get_replicate_api_token()
+        if not token:
+            raise RuntimeError("Replicate API token missing. Open settings and add it.")
+
+        client = replicate.Client(api_token=token)
+        client.poll_interval = REPLICATE_IMAGE_POLL_INTERVAL
+        prediction = client.models.predictions.create(
+            model=model_id,
+            input=input_payload,
+            wait=False,
+        )
+        print(f"[Replicate Image] Prediction started: {prediction.id} ({prediction.status})")
+
+        deadline = time.monotonic() + REPLICATE_IMAGE_TIMEOUT
+        last_status = prediction.status
+        while prediction.status not in {"succeeded", "failed", "canceled"}:
+            if self._abort_sd:
+                try:
+                    prediction.cancel()
+                except Exception:
+                    pass
+                raise RuntimeError("User aborted")
+
+            if time.monotonic() >= deadline:
+                raise TimeoutError(
+                    f"Timed out waiting for Replicate image prediction {prediction.id} "
+                    f"after {REPLICATE_IMAGE_TIMEOUT // 60} minutes."
+                )
+
+            time.sleep(client.poll_interval)
+            prediction.reload()
+            if prediction.status != last_status:
+                print(f"[Replicate Image] {prediction.id}: {prediction.status}")
+                last_status = prediction.status
+
+        if prediction.status != "succeeded":
+            detail = prediction.error or prediction.logs or f"status={prediction.status}"
+            raise RuntimeError(f"Replicate image prediction {prediction.id} failed: {detail}")
+
+        return prediction.output
+
+    def _run_replicate_images(self, batch_count: int) -> list[Image.Image]:
+        model_id = self._get_replicate_image_model()
+        images: list[Image.Image] = []
+
+        if model_id == "black-forest-labs/flux-schnell":
+            remaining = batch_count
+            while remaining > 0:
+                if self._abort_sd:
+                    raise RuntimeError("User aborted")
+                chunk = min(remaining, 4)
+                output = self._run_replicate_prediction(
+                    model_id,
+                    self._build_replicate_image_input(model_id, chunk),
+                )
+                urls = extract_replicate_output_urls(output)
+                if len(urls) < chunk:
+                    raise RuntimeError(f"Replicate returned {len(urls)} image(s), expected {chunk}.")
+                images.extend(load_image_from_url(url) for url in urls[:chunk])
+                remaining -= chunk
+            return images
+
+        for _ in range(batch_count):
+            if self._abort_sd:
+                raise RuntimeError("User aborted")
+            output = self._run_replicate_prediction(
+                model_id,
+                self._build_replicate_image_input(model_id, 1),
+            )
+            urls = extract_replicate_output_urls(output)
+            if not urls:
+                raise RuntimeError("Replicate did not return an image URL.")
+            images.append(load_image_from_url(urls[0]))
+
+        return images
+
+    def _run_sd_only(self):
+        if not self.last_prompt_json:
+            self._js("window.on_error", "No valid JSON prompt available.")
+            return
+
+        batch_id    = random.randint(1_000_000, 9_999_999)
+        self._last_batch_id = batch_id
+        batch_count = int(self.last_prompt_json.get("batch_count", 4))
+
+        # 1) Bail out if user already hit “Stop”
+        if self._abort_sd:
+            return
+
+        # 2) Show placeholders in the UI
+        self._js("window.show_placeholders", batch_count, batch_id)
+        event = threading.Event()
+        self._placeholders_ready_events[batch_id] = event
+
+        # 3) Wait until JS signals placeholders are in place
+        while not event.is_set():
+            time.sleep(0.02)
+        if self._abort_sd:
+            self._js("window.remove_placeholders", batch_id)
+            return
+
+        # 4) Set up and run the selected image generator.
+        try:
+            if self._get_image_generation_backend() == IMAGE_BACKEND_REPLICATE:
+                images = self._run_replicate_images(batch_count)
+            else:
+                images = self._run_local_diffusion_images(batch_count)
+
+        except RuntimeError as e:
+            # user‐initiated abort
+            if str(e) == "User aborted":
+                self._js("window.on_generation_aborted")
+                self._js("window.remove_placeholders", batch_id)
+                return
+            # or some other error
+            self._js("window.remove_placeholders", batch_id)
+            self._js("window.on_error", f"Image generation error: {e}")
+            return
+        except Exception as e:
+            self._js("window.remove_placeholders", batch_id)
+            self._js("window.on_error", f"Image generation error: {e}")
+            return
+
+        # 5) Replace placeholders one by one
+        for idx, img in enumerate(images):
+            if self._abort_sd:
+                self._js("window.remove_placeholders", batch_id)
+                return
+
+            fname = save_generated_image(
+                img,
+                self.last_prompt_json,
+                self.last_object,
+                idx + 1,
+                batch_count,
+            )
+
+            rel = os.path.relpath(fname, WEB_DIR)
+            self._js("window.replace_placeholder", idx, rel, batch_id)
+
+        # 6) Tear down
+        self._js("window.remove_placeholders", batch_id)
+        self._js("window.on_image_gen_done")
+        del self._placeholders_ready_events[batch_id]
+        
+    def stop_generation(self):
+        self._abort_sd = True
+        # Do NOT remove placeholders here—wait until the abort is processed
+        return {"status": "aborting"}
+
+    def placeholders_ready(self, batch_id):
+        if batch_id in self._placeholders_ready_events:
+            self._placeholders_ready_events[batch_id].set()
+        return {"status": "acknowledged"}
+
+    def get_settings(self):
+        settings = load_app_settings()
+        settings_token = str(settings.get("replicate_api_token", "")).strip()
+        env_token = os.environ.get("REPLICATE_API_TOKEN", "").strip()
+        source = "settings" if settings_token else "environment" if env_token else ""
+        return {
+            "has_replicate_api_token": bool(settings_token or env_token),
+            "replicate_api_token_source": source,
+            "replicate_api_token": "",
+            "image_generation_backend": normalize_image_backend(settings.get("image_generation_backend")),
+            "replicate_image_model": normalize_replicate_image_model(settings.get("replicate_image_model")),
+            "replicate_image_models": [
+                {
+                    "id": model_id,
+                    "label": model["label"],
+                    "price": model["price"],
+                }
+                for model_id, model in REPLICATE_IMAGE_MODELS.items()
+            ],
+        }
+
+    def save_settings(self, settings: dict):
+        current = load_app_settings()
+        token = str(settings.get("replicate_api_token", "")).strip()
+        if token:
+            current["replicate_api_token"] = token
+
+        current["image_generation_backend"] = normalize_image_backend(
+            settings.get("image_generation_backend")
+        )
+        current["replicate_image_model"] = normalize_replicate_image_model(
+            settings.get("replicate_image_model")
+        )
+        save_app_settings(current)
+        return {
+            "status": "saved",
+            "has_replicate_api_token": bool(self._get_replicate_api_token()),
+            "image_generation_backend": current["image_generation_backend"],
+            "replicate_image_model": current["replicate_image_model"],
+        }
+
+    def clear_replicate_api_token(self):
+        current = load_app_settings()
+        current.pop("replicate_api_token", None)
+        save_app_settings(current)
+        env_token = os.environ.get("REPLICATE_API_TOKEN", "").strip()
+        return {
+            "status": "cleared",
+            "has_replicate_api_token": bool(env_token),
+            "replicate_api_token_source": "environment" if env_token else "",
+            "image_generation_backend": normalize_image_backend(current.get("image_generation_backend")),
+            "replicate_image_model": normalize_replicate_image_model(current.get("replicate_image_model")),
+        }
+
+    def _get_replicate_api_token(self):
+        settings_token = str(load_app_settings().get("replicate_api_token", "")).strip()
+        return settings_token or os.environ.get("REPLICATE_API_TOKEN", "").strip()
+
+    def _subprocess_env(self):
+        env = os.environ.copy()
+        token = self._get_replicate_api_token()
+        if token:
+            env["REPLICATE_API_TOKEN"] = token
+        return env
+
+
+    def _open_blender_with_scene(self, glb_path, hdri_path):
+        # Kopiere ggf. vorbereitete Blender-Template-Datei, z.B. "scene_template.blend"
+        blender_path = "/Applications/Blender.app/Contents/MacOS/Blender"
+        # Template: In Blender musst du ein Skript haben, das das .glb und das hdri_path lädt
+        # oder als Startscript mitgibst!
+        cmd = [
+            "/Applications/Blender.app/Contents/MacOS/Blender",
+            "--python", "scene_setup.py",
+            "--", glb_path, hdri_path or ""
+        ]
+        try:
+            subprocess.Popen(cmd)
+            return {"status": "opened_blender"}
+        except Exception as e:
+            self._js("window.on_error", f"Failed to open in Blender: {e}")
+            return {"status": "blender_error"}
+
+
+    def edit_external(self, filepath: str):
+        # filepath kommt von 2D als "output/foo.png" oder von 3D als "output/foo.png"
+        ext = os.path.splitext(filepath)[1].lower()
+        full_path = os.path.join(BASE_DIR, "web", filepath)
+        # Ist es ein Bild oder das PNG eines 3D-Modells?
+        if ext == ".png":
+            # Prüfe, ob ein GLB daneben liegt
+            fbase = os.path.splitext(full_path)[0]
+            glb_path = fbase + ".glb"
+            # Prüfe, ob auch eine HDRI da ist (Sidecar JSON auslesen)
+            hdri_path = None
+            sidecar = full_path + ".json"
+            if os.path.isfile(sidecar):
+                with open(sidecar, "r", encoding="utf-8") as f:
+                    meta = json.load(f)
+                    if "hdri_seamless" in meta:
+                        hdri_path = os.path.join(os.path.dirname(full_path), meta["hdri_seamless"])
+            # Wenn .glb existiert → ist 3D Model: Blender öffnen!
+            if os.path.isfile(glb_path):
+                return self._open_blender_with_scene(glb_path, hdri_path)
+            # Sonst wie bisher (Photoshop)
+            try:
+                subprocess.Popen(["open", "-a", "Adobe Photoshop 2024", full_path])
+            except Exception as e:
+                self._js("window.on_error", f"Failed to open in Photoshop: {e}")
+            return {"status": "opened_external"}
+
+
+            # ------------- Generate 3D Model -------------
+    def generate_3d_model(self, filepath: str):
+        # filepath kommt aus JS als "output/flower-1.png"
+        full_path = os.path.join(BASE_DIR, "web", filepath)
+        if not os.path.isfile(full_path):
+            self._js("window.on_error", f"Image not found: {full_path}")
+            return {"status": "missing_file"}
+
+        threading.Thread(target=self._run_generate_3d, args=(full_path,), daemon=True).start()
+        return {"status": "started_3d"}
+
+    def _run_generate_3d(self, img_path: str):
+        """
+        Execute the user‐provided script `image_to_3d.py <img_path>`, wait for completion,
+        then, if a .glb was produced, call JS callback window.on_3d_generated(glb_path).
+        Otherwise, call window.on_error(…).
+        """
+        try:
+            if not self._get_replicate_api_token():
+                self._js(
+                    "window.on_error",
+                    "Replicate API token missing. Open settings and add it.",
+                )
+                return
+
+            # Construct the command: sys.executable ensures we run with same Python interpreter
+            script_path = os.path.join(BASE_DIR, "image_to_3d.py")
+            cmd = [sys.executable, script_path, img_path]
+            base, _ = os.path.splitext(img_path)
+            glb_path = base + ".glb"
+            previous_mtime = os.path.getmtime(glb_path) if os.path.isfile(glb_path) else None
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                env=self._subprocess_env(),
+            )
+
+            # Check for success: sidecar or actual .glb in same folder
+            current_mtime = os.path.getmtime(glb_path) if os.path.isfile(glb_path) else None
+
+            if current_mtime is not None and current_mtime != previous_mtime:
+                # Notify JavaScript
+                self._js("window.on_3d_generated", glb_path)
+            else:
+                # If the script failed or no .glb was produced, send an error
+                err_msg = (
+                    result.stderr.strip()
+                    or result.stdout.strip()
+                    or "3D conversion did not produce .glb"
+                )
+                self._js("window.on_error", f"3D Model failed: {err_msg}")
+        except Exception as e:
+            self._js("window.on_error", f"3D conversion exception: {e}")
+
+
+
+
+
+            # ------------- NEW: Generate 3D Model PLUS equirectangular map -------------
+
+    def generate_3d_and_hdri(self, filepath: str):
+        """
+        Called when user wants both 3D model and equirectangular HDRI for an image.
+        Kicks off both processes, waits for both, and (later) calls the next step.
+        """
+        full_path = os.path.join(BASE_DIR, "web", filepath)
+        if not os.path.isfile(full_path):
+            self._js("window.on_error", f"Image not found: {full_path}")
+            return {"status": "missing_file"}
+        # Start thread for orchestration
+        threading.Thread(target=self._run_3d_and_hdri, args=(full_path,), daemon=True).start()
+        return {"status": "started_3d_and_hdri"}
+
+    def _run_3d_and_hdri(self, img_path: str):
+        # 1. Get object info (from PNG metadata or sidecar)
+        obj_name = self._extract_object_from_json(img_path)
+        print(f"[3D+HDRI] Object name from JSON: {obj_name}")
+        if not obj_name:
+            self._js("window.on_error", "Could not determine object name for HDRI prompt.")
+            return
+
+        # 2. Generate short background prompt using Mistral (Ollama) with streaming debug
+        user_prompt = f"""Suggest a short, vivid background description for a 3D scene featuring {obj_name}. \
+    The background should be immersive and plausible, suitable as an equirectangular HDRI for 3D rendering. \
+    Do NOT mention the object itself. Describe the environment in a concise way, e.g.: "lush wheat field under a blue sky", "bustling medieval town square at dawn", "mysterious alien jungle with glowing plants", etc. Respond only with the description, no extra text. Only describe the appearance of the environment, no other attributes than what is to see. \
+    Keep it short and precise, use 2 to 5 words max! No punctuation, just commas if needed. All lowercase. As short as possible!"""
+        print(f"[HDRI LLM] Sending prompt to LLM:\n{user_prompt}\n")
+
+        pano_prompt = None
+        for chunk in stream_ollama(user_prompt):
+            print(f"[HDRI LLM] {chunk!r}")
+            pano_prompt = chunk.strip()
+        if not pano_prompt:
+            self._js("window.on_error", "Could not generate panorama prompt.")
+            return
+
+        # 3. Prepend required prefix and print
+        pano_prompt_full = "hdri panorama view, equirectangular, 3d rendering of " + pano_prompt
+        prompt_with_colons = f":{pano_prompt_full}:"
+        print(f"[HDRI PROMPT] Final panorama prompt:\n{prompt_with_colons}\n")
+
+        # 4. Prepare output path in OUTPUT_DIR
+        out_base = os.path.splitext(os.path.basename(img_path))[0]
+        hdri_filename = f"{out_base}_hdri_seamless.png"
+        hdri_output_path = os.path.join(OUTPUT_DIR, hdri_filename)
+        print(f"[HDRI PATH] Will save to: {hdri_output_path}")
+
+        # 5. Run both tasks concurrently
+        import concurrent.futures
+        with concurrent.futures.ThreadPoolExecutor() as executor:
+            fut_3d = executor.submit(self._run_generate_3d_and_return, img_path)
+            fut_hdri = executor.submit(self._run_equirect_map, prompt_with_colons, hdri_output_path)
+            done, _ = concurrent.futures.wait([fut_3d, fut_hdri], return_when=concurrent.futures.ALL_COMPLETED)
+
+        # 6. Check results
+        err3d = fut_3d.exception() if fut_3d.done() else "3D model task did not finish"
+        errhdri = fut_hdri.exception() if fut_hdri.done() else "HDRI task did not finish"
+
+        if err3d or errhdri:
+            msg = ""
+            if err3d:
+                msg += f"3D model error: {err3d}\n"
+            if errhdri:
+                msg += f"HDRI error: {errhdri}\n"
+            self._js("window.on_error", msg.strip())
+            return
+
+        glb_path = fut_3d.result()
+        hdri_path = fut_hdri.result()
+
+        # 7. Write HDRI path into the original image's JSON sidecar (absolute, relative, or both)
+        sidecar_path = img_path + ".json"
+        try:
+            if os.path.isfile(sidecar_path):
+                with open(sidecar_path, "r", encoding="utf-8") as f:
+                    meta = json.load(f)
+            else:
+                meta = {}
+
+            meta["hdri_seamless"] = os.path.relpath(hdri_path, OUTPUT_DIR)  # or just hdri_filename
+            with open(sidecar_path, "w", encoding="utf-8") as f:
+                json.dump(meta, f, indent=2)
+            print(f"[HDRI JSON] Wrote HDRI path to {sidecar_path}: {meta['hdri_seamless']}")
+        except Exception as e:
+            print(f"[HDRI JSON] ERROR writing HDRI path: {e}")
+
+        self._on_3d_and_hdri_ready(glb_path, hdri_path)
+
+    def _extract_object_from_json(self, img_path: str) -> str:
+        """
+        Helper: Tries to read the object/positive prompt from sidecar or PNG metadata.
+        """
+        try:
+            sidecar = img_path + ".json"
+            if os.path.isfile(sidecar):
+                with open(sidecar, "r", encoding="utf-8") as f:
+                    meta = json.load(f)
+                    return meta.get("positive prompt", "").split(",")[0]
+            else:
+                # Try embedded PNG metadata as fallback
+                img = Image.open(img_path)
+                info = img.info
+                if "sd_json" in info:
+                    d = json.loads(info["sd_json"])
+                    return d.get("positive prompt", "").split(",")[0]
+        except Exception:
+            pass
+        return None
+
+    def _get_panorama_prompt(self, obj_name: str) -> str:
+        """
+        Calls Mistral (Ollama) to generate a short background panorama prompt.
+        """
+        user_prompt = f"""Suggest a short, vivid background description for a 3D scene featuring {obj_name}. \
+The background should be immersive and plausible, suitable as an equirectangular HDRI for 3D rendering. \
+Do NOT mention the object itself. Describe the environment in a concise way, e.g.: "a lush wheat field under a blue sky", "a bustling medieval town square at dawn", "a mysterious alien jungle with glowing plants", etc. Respond only with the description, no extra text."""
+
+        try:
+            for response in stream_ollama(user_prompt):
+                last = response.strip()
+            return last
+        except Exception:
+            return None
+
+    def _run_generate_3d_and_return(self, img_path: str):
+        """
+        Same as _run_generate_3d, but returns the GLB path on success (or raises).
+        """
+        if not self._get_replicate_api_token():
+            raise RuntimeError("Replicate API token missing. Open settings and add it.")
+
+        script_path = os.path.join(BASE_DIR, "image_to_3d.py")
+        cmd = [sys.executable, script_path, img_path]
+        base, _ = os.path.splitext(img_path)
+        glb_path = base + ".glb"
+        previous_mtime = os.path.getmtime(glb_path) if os.path.isfile(glb_path) else None
+        result = subprocess.run(
+            cmd,
+            capture_output=True,
+            text=True,
+            env=self._subprocess_env(),
+        )
+        current_mtime = os.path.getmtime(glb_path) if os.path.isfile(glb_path) else None
+        if current_mtime is not None and current_mtime != previous_mtime:
+            self._js("window.on_3d_generated", glb_path)
+            return glb_path
+        else:
+            err_msg = (
+                result.stderr.strip()
+                or result.stdout.strip()
+                or "3D conversion did not produce .glb"
+            )
+            raise RuntimeError(err_msg)
+
+    def _run_equirect_map(self, prompt: str, output_path: str):
+        """
+        Calls your equi map generator script.
+        Logs command and full output for debugging.
+        """
+        script_path = os.path.join(BASE_DIR, "generate_equirect.py")
+        cmd = [sys.executable, script_path, "--prompt", prompt, "--output", output_path]
+        print(f"[HDRI CMD] {' '.join(cmd)}")
+        result = subprocess.run(cmd, capture_output=True, text=True)
+        print(f"[HDRI STDOUT]\n{result.stdout}")
+        print(f"[HDRI STDERR]\n{result.stderr}")
+        if result.returncode == 0 and os.path.isfile(output_path):
+            print(f"[HDRI OK] Created: {output_path}")
+            return output_path
+        else:
+            raise RuntimeError(result.stderr.strip() or f"HDRI generation failed for {output_path}")
+
+    def _on_3d_and_hdri_ready(self, glb_path: str, hdri_path: str):
+        """
+        Dummy function to handle successful completion of both tasks.
+        For now: just print/log, later: implement what you need (e.g. combine assets, notify UI, etc).
+        """
+        print(f"3D model ready: {glb_path}")
+        print(f"HDRI ready: {hdri_path}")
+        # Example: self._js("window.on_3d_and_hdri_ready", glb_path, hdri_path)
+
+
+
+
+
+
+
+
+
+
+
+
+
+    # ------------- END of Generate 3D Model & Equi methods -------------
+    def get_initial_images(self):
+        entries = []
+        for fname in os.listdir(OUTPUT_DIR):
+            if not fname.lower().endswith(".png"):
+                continue
+
+            fpath = os.path.join(OUTPUT_DIR, fname)
+            # Prüfe, ob Sidecar existiert & valides JSON ist
+            sidecar = fpath + ".json"
+            if not os.path.isfile(sidecar):
+                continue
+            try:
+                with open(sidecar, "r", encoding="utf-8") as f:
+                    meta = json.load(f)
+                    # Optional: Check ob wirklich ein Prompt drin ist
+                    if not meta.get("positive prompt"):
+                        continue
+                    created = int(meta.get("created", 0))
+            except Exception:
+                continue
+
+            rel = os.path.relpath(os.path.join(OUTPUT_DIR, fname), WEB_DIR)
+            entries.append({
+                "filepath": rel,
+                "created": created
+            })
+
+        return sorted(entries, key=lambda e: e["created"], reverse=True)
+
+    def get_3d_models(self):
+        entries = []
+        for fname in os.listdir(OUTPUT_DIR):
+            if not fname.lower().endswith(".png"):
+                continue
+            png_path = os.path.join(OUTPUT_DIR, fname)
+            fbase = os.path.splitext(fname)[0]
+            glb_path = os.path.join(OUTPUT_DIR, fbase + ".glb")
+            if os.path.isfile(glb_path):
+                # Lade "created" aus Sidecar-JSON
+                created = 0
+                sidecar = png_path + ".json"
+                if os.path.isfile(sidecar):
+                    try:
+                        with open(sidecar, "r", encoding="utf-8") as f:
+                            meta = json.load(f)
+                            created = int(meta.get("created", 0))
+                    except Exception:
+                        pass
+                rel_img = os.path.relpath(png_path, WEB_DIR)
+                rel_glb = os.path.relpath(glb_path, WEB_DIR)
+                entries.append({
+                    "img": rel_img,
+                    "glb": rel_glb,
+                    "created": created
+                })
+        # Sortiere nach created DESC
+        models = sorted(entries, key=lambda e: e["created"], reverse=True)
+        # Entferne "created" vor dem Rückgeben (falls Frontend das nicht braucht)
+        for m in models:
+            if "created" in m:
+                del m["created"]
+        return models
+        
+    def get_image_json(self, filepath: str):
+        # filepath kommt aus JS als "output/flower-1.png"
+        full_path = os.path.join(BASE_DIR, "web", filepath)
+        try:
+            # Always prefer the sidecar if available (contains most up-to-date data)
+            sidecar = full_path + ".json"
+            if os.path.isfile(sidecar):
+                with open(sidecar, "r", encoding="utf-8") as f:
+                    d = json.load(f)
+                    if "created" in d:
+                        del d["created"]
+                    return json.dumps(d, indent=2)
+            # Fallback: try embedded metadata in PNG
+            img = Image.open(full_path)
+            info = img.info
+            if "sd_json" in info:
+                d = json.loads(info["sd_json"])
+                if "created" in d:
+                    del d["created"]
+                return json.dumps(d, indent=2)
+            else:
+                return json.dumps({"error": "No embedded generation data found."})
+        except Exception as e:
+            return json.dumps({"error": f"Failed to read metadata: {e}"})
+
+    def _monitor_folder(self):
+        """
+        Every 2 seconds, scan OUTPUT_DIR for PNGs. If any file is new or its mtime changed,
+        send window.on_image_updated(filepath, dataUri) to front end.
+        """
+        while True:
+            time.sleep(2)
+            for fname in os.listdir(OUTPUT_DIR):
+                if not fname.lower().endswith(".png"):
+                    continue
+                fpath = os.path.join(OUTPUT_DIR, fname)
+                try:
+                    mtime = os.path.getmtime(fpath)
+                except FileNotFoundError:
+                    continue
+                previous = self._mtimes.get(fpath)
+                if previous is None or mtime > previous:
+                    # New or modified
+                    self._mtimes[fpath] = mtime
+                    try:
+                        data_uri = image_to_base64(fpath)
+                        rel = os.path.relpath(fpath, WEB_DIR)  # → "output/flower-2.png"
+                        self._js("window.on_image_updated", rel, data_uri)
+                    except Exception:
+                        pass
+
+    def _js(self, fn: str, *args):
+        import json
+        args_json = json.dumps(list(args))
+        code = f"{fn}.apply(null, {args_json})"
+        self.window.evaluate_js(code)
+
+
+# ------------- Launch PyWebview -------------
+
+if __name__ == "__main__":
+    api = Api()
+    window = webview.create_window(
+        "SD 3D Model Image Gen",
+        "web/index.html",
+        js_api=api,
+        width=900,
+        height=1000,
+        min_size=(650, 500),
+        resizable=True
+    )
+    api.set_window(window)
+    webview.start(debug=True)
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..c1d93db
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,12 @@
+numpy<2
+
+accelerate==0.31.0
+diffusers==0.27.2
+huggingface-hub==0.23.4
+Pillow==12.0.0
+pywebview==5.4
+replicate==1.0.7
+requests==2.32.5
+safetensors==0.7.0
+torch==2.9.1
+transformers==4.41.2
diff --git a/run.sh b/run.sh
new file mode 100755
index 0000000..10046c5
--- /dev/null
+++ b/run.sh
@@ -0,0 +1,30 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+cd "$(dirname "$0")"
+
+export HF_HOME="${HF_HOME:-$PWD/.hf_cache}"
+export HUGGINGFACE_HUB_CACHE="${HUGGINGFACE_HUB_CACHE:-$HF_HOME/hub}"
+mkdir -p "$HUGGINGFACE_HUB_CACHE"
+
+if [ -n "${PYTHON:-}" ]; then
+  python_bin="$PYTHON"
+elif command -v python3.11 >/dev/null 2>&1; then
+  python_bin="python3.11"
+elif command -v python3 >/dev/null 2>&1; then
+  python_bin="python3"
+else
+  echo "Could not find python3.11 or python3. Install Python 3.11, then run this script again." >&2
+  exit 1
+fi
+
+if [ ! -d ".venv" ]; then
+  "$python_bin" -m venv .venv
+fi
+
+source .venv/bin/activate
+
+python -m pip install --upgrade pip
+python -m pip install -r requirements.txt
+
+exec python main.py
diff --git a/scene_setup.py b/scene_setup.py
new file mode 100644
index 0000000..aa60b80
--- /dev/null
+++ b/scene_setup.py
@@ -0,0 +1,77 @@
+import bpy
+import sys
+import os
+
+argv = sys.argv
+argv = argv[argv.index("--") + 1:] if "--" in argv else []
+
+glb_path = argv[0] if len(argv) > 0 else None
+hdri_path = argv[1] if len(argv) > 1 else None
+
+#bpy.ops.wm.read_factory_settings(use_empty=True)
+if "Cube" in bpy.data.objects:
+    bpy.data.objects.remove(bpy.data.objects["Cube"], do_unlink=True)
+
+# GLB importieren
+if glb_path and os.path.isfile(glb_path):
+    bpy.ops.import_scene.gltf(filepath=glb_path)
+else:
+    print("GLB file missing:", glb_path)
+
+# HDRI oder Sonne
+hdri_loaded = False
+if hdri_path and os.path.isfile(hdri_path):
+    try:
+        world = bpy.data.worlds.new("World") if not bpy.data.worlds else bpy.data.worlds[0]
+        bpy.context.scene.world = world
+        world.use_nodes = True
+        ntree = world.node_tree
+        nodes = ntree.nodes
+        for node in nodes: nodes.remove(node)
+        node_bg = nodes.new(type='ShaderNodeBackground')
+        node_env = nodes.new(type='ShaderNodeTexEnvironment')
+        node_out = nodes.new(type='ShaderNodeOutputWorld')
+        node_env.image = bpy.data.images.load(hdri_path)
+        node_env.location = (-300, 0)
+        node_bg.location = (0, 0)
+        node_out.location = (300, 0)
+        ntree.links.new(node_env.outputs['Color'], node_bg.inputs['Color'])
+        ntree.links.new(node_bg.outputs['Background'], node_out.inputs['Surface'])
+        hdri_loaded = True
+    except Exception as e:
+        print("Failed to load HDRI:", e)
+        hdri_loaded = False
+
+if not hdri_loaded:
+    # Schöne Sonnenlampe (leicht schräg von oben)
+    light_data = bpy.data.lights.new(name="Sun", type='SUN')
+    light_data.energy = 4.5
+    light = bpy.data.objects.new(name="Sun", object_data=light_data)
+    bpy.context.collection.objects.link(light)
+    light.location = (4, 10, 10)
+    light.rotation_euler = (0.8, 0.3, 0.1)  # leicht schräg
+    # Optionale Fill-Light/Soft-Ambient
+    light_data2 = bpy.data.lights.new(name="Fill", type='SUN')
+    light_data2.energy = 1.1
+    light2 = bpy.data.objects.new(name="Fill", object_data=light_data2)
+    bpy.context.collection.objects.link(light2)
+    light2.location = (-8, -6, 4)
+    light2.rotation_euler = (1.4, -0.8, -0.2)
+
+for window in bpy.context.window_manager.windows:
+    for area in window.screen.areas:
+        if area.type == 'VIEW_3D':
+            for space in area.spaces:
+                if space.type == 'VIEW_3D':
+                    space.shading.type = 'RENDERED'
+                    
+for obj in bpy.data.objects:
+    # Entparenten, falls Parent ein Empty namens "world" ist
+    if obj.parent and obj.parent.name == "world":
+        obj.parent = None
+
+if "world" in bpy.data.objects and bpy.data.objects["world"].type == "EMPTY":
+    bpy.data.objects.remove(bpy.data.objects["world"], do_unlink=True)
+
+if "Cube" in bpy.data.objects:
+    bpy.data.objects.remove(bpy.data.objects["Cube"], do_unlink=True)
diff --git a/web/index.html b/web/index.html
new file mode 100644
index 0000000..3dfa98f
--- /dev/null
+++ b/web/index.html
@@ -0,0 +1,2375 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>3D-Modell Generator</title>
+    <meta charset="UTF-8" />
+<style>
+:root {
+    --bg-main: #fff;
+    --bg-sidebar: #fff1f2;
+    --accent: #9f1239;
+    --border: #ffe4e6;
+}
+
+body {
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+    margin: 0;
+    background: var(--bg-main);
+    color: #23262f;
+}
+
+.container {
+    max-width: 850px;
+    margin: 3em auto;
+    margin-top: 0 !important;
+    margin-bottom: 0 !important;
+    background: var(--bg-main);
+    padding: 2em 2em 2em 2em;
+    /*border-radius: 18px;*/
+    box-shadow: 0 6px 36px rgba(159,18,57,0.09), 0 2px 8px rgba(159,18,57,0.04);
+    border: 1.5px solid var(--border);
+}
+
+h2 {
+    margin: 0 0 1.2em 0;
+    font-size: 1.7em;
+    font-weight: 700;
+    color: var(--accent);
+    letter-spacing: -0.5px;
+}
+.app-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 1em;
+    margin-bottom: 1.2em;
+}
+.app-header h2 {
+    margin: 0;
+}
+.icon-button {
+    width: 40px;
+    height: 40px;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    padding: 0;
+    border-radius: 8px;
+    font-size: 1.35em;
+    line-height: 1;
+}
+.settings-overlay {
+    display: none;
+    position: fixed;
+    inset: 0;
+    z-index: 6000;
+    background: rgba(104, 17, 40, 0.34);
+    align-items: flex-start;
+    justify-content: flex-end;
+    padding: 28px;
+    box-sizing: border-box;
+}
+.settings-overlay.active {
+    display: flex;
+}
+.settings-panel {
+    width: min(360px, calc(100vw - 56px));
+    background: #fff;
+    border: 2px solid var(--border);
+    border-radius: 8px;
+    box-shadow: 0 10px 34px rgba(104,17,40,0.18);
+    padding: 1.2em;
+    box-sizing: border-box;
+}
+.settings-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 1em;
+    margin-bottom: 1em;
+}
+.settings-header h3 {
+    margin: 0;
+    color: var(--accent);
+    font-size: 1.2em;
+}
+.settings-close {
+    width: 34px;
+    height: 34px;
+    padding: 0;
+    border-radius: 8px;
+    background: #fff1f2;
+    color: var(--accent);
+}
+.settings-panel input[type="password"],
+.settings-panel input[type="text"],
+.settings-panel select {
+    width: 100%;
+    box-sizing: border-box;
+    font-size: 1.02em;
+    padding: 0.7em 1.2em;
+    border: 2px solid var(--border);
+    border-radius: 7px;
+    background: #fff1f2;
+    color: #681128;
+}
+.settings-panel label {
+    display: block;
+    color: #7b1930;
+    font-weight: 650;
+    margin-top: 0.9em;
+    margin-bottom: 0.35em;
+}
+.settings-actions {
+    display: flex;
+    justify-content: flex-end;
+    gap: 0.7em;
+    margin-top: 1em;
+}
+.settings-actions .secondary {
+    background: #fff1f2;
+    color: var(--accent);
+}
+.settings-status {
+    min-height: 1.3em;
+    color: #7b1930;
+    font-size: 0.95em;
+    margin-top: 0.75em;
+}
+.setting-check {
+    display: flex;
+    align-items: center;
+    gap: 0.5em;
+    margin-top: 0.8em;
+    color: #7b1930;
+    font-size: 0.95em;
+}
+.settings-note {
+    margin-top: 1em;
+    padding: 0.85em;
+    border: 1px solid var(--border);
+    border-radius: 7px;
+    background: #fff7f8;
+    color: #681128;
+    font-size: 0.9em;
+    line-height: 1.35;
+}
+.settings-note strong {
+    display: block;
+    margin-bottom: 0.35em;
+}
+.settings-note ul {
+    margin: 0.35em 0 0 1.15em;
+    padding: 0;
+}
+
+.section {
+    margin-bottom: 2.2em;
+}
+
+/* Eingabe- und Button-Zeile */
+.input-row {
+    display: flex;
+    align-items: center;
+    gap: 1em;
+}
+input[type="text"] {
+    flex: 1 1 210px;
+    width: auto;
+    min-width: 90px;
+    font-size: 1.07em;
+    padding: 0.7em 1.2em;
+    border: 2px solid var(--border);
+    border-radius: 7px;
+    background: #fff1f2;
+    transition: border 0.2s;
+    color: #681128;
+}
+input[type="text"]:focus {
+    outline: none;
+    border-color: var(--accent);
+}
+button {
+    font-size: 1.05em;
+    font-weight: 500;
+    padding: 0.6em 1.6em;
+    margin-left: 0;
+    background: var(--accent);
+    color: #fff;
+    border: none;
+    border-radius: 8px;
+    cursor: pointer;
+    /*box-shadow: 0 1.5px 6px rgba(159,18,57,0.09);*/
+    transition: background 0.18s, box-shadow 0.15s;
+}
+button:disabled {
+    background: #ffd5de;
+    color: #fff;
+    cursor: not-allowed;
+}
+.spinner {
+    display: none;
+    margin-left: 1em;
+    font-size: 1em;
+    color: var(--accent);
+}
+.spinner.active {
+    display: inline-block;
+}
+
+label {
+    font-weight: 600;
+    color: #7b1930;
+    margin-bottom: 0.5em;
+    display: block;
+    font-size: 1.02em;
+}
+/*
+#moreBtn {
+    display: none;
+    margin-top: 0.6em;
+    margin-bottom: 0;
+    align-self: flex-end;
+}*/
+
+/* JSON-Output + Button rechts unten */
+.json-row {
+    display: flex;
+    flex-direction: column;
+    align-items: flex-end;
+}
+.json-row-bottom {
+    display: flex;
+    width: 100%;
+    justify-content: space-between;
+    align-items: flex-end;
+    margin-bottom: 4px;
+}
+#tokenCounter {
+    font-size: 0.97em;
+    color: #7b1930;
+    margin-bottom: 6px;
+    margin-top: 0;
+    text-align: left;
+    align-self: flex-start;
+}
+#moreBtn {
+    margin-left: 1.2em;
+    margin-right: 0;
+}
+
+#json_out {
+    background: #fff1f2;
+    padding: 1em 1.1em;
+    border: 2px solid var(--border);
+    border-radius: 7px;
+    width: 100%;
+    height: 284px;
+    resize: none;
+    font-family: 'JetBrains Mono', 'Fira Mono', 'Menlo', monospace;
+    font-size: 1em;
+    margin: 0 auto 0.7em;
+    box-sizing: border-box;
+    color: #681128;
+    transition: border 0.2s;
+    
+}
+#json_out:focus {
+    outline: none;
+    border-color: var(--accent);
+}
+
+.section:has(#llm_out:empty) {
+    display: none !important;
+}
+#llm_out {
+    background: #fff1f2;
+    padding: 1em 1.1em;
+    border: 2px solid var(--border);
+    border-radius: 7px;
+    max-height: 220px;
+    overflow-y: auto;
+    white-space: pre-wrap;
+    word-wrap: break-word;
+    font-family: 'JetBrains Mono', 'Fira Mono', 'Menlo', monospace;
+    font-size: 1em;
+    margin-bottom: 1.1em;
+    margin-top: 0.2em;
+    color: #7b1930;
+}
+
+/* Gallery: immer 4 pro Zeile, keine Media-Queries! */
+.images,
+.models {
+    display: grid;
+    grid-template-columns: repeat(4, 1fr);
+    gap: 16px;
+    margin-top: 0;
+    padding: 0; /* Fix für 3D Thumbnails rechtsbündig */
+    background: var(--bg-sidebar);    /* Das gleiche Rosa wie Textbox */
+    border-radius: 0 0 7px 7px;
+    border:  2px solid var(--border);
+    border-top: 0;
+    padding: 16px;           /* Etwas Luft oben/unten */
+}
+.images img,
+.model-thumb img {
+    width: 100%;
+    aspect-ratio: 1/1;
+    object-fit: cover;
+    border: 0px;
+    /*border: 2px solid var(--border);*/
+    border-radius: 7px;
+    cursor: pointer;
+    background: var(--bg-sidebar);
+    transition: box-shadow 0.18s, border-color 0.14s;
+    box-sizing: border-box;
+}
+.images img:hover,
+.model-thumb img:hover {
+    box-shadow: 0 0 0 3px #fda4af65;
+    border-color: var(--accent);
+}
+.model-thumb img {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    margin: 0; /* Kein Offset mehr */
+}
+
+/* Kontextmenü */
+.ctxMenu, .ctx-menu, #ctxMenu {
+    position: absolute;
+    z-index: 5000;
+    background: #fff;
+    border: 2px solid var(--border);
+    border-radius: 8px;
+    box-shadow: 0 4px 24px rgba(159,18,57,0.10);
+    display: none;
+    min-width: 164px;
+    font-size: 1em;
+    overflow: hidden;
+}
+.ctxMenu div, .ctx-menu div, #ctxMenu div {
+    padding: 0.77em 1.21em;
+    cursor: pointer;
+    transition: background 0.13s;
+}
+.ctxMenu div:hover, .ctx-menu div:hover, #ctxMenu div:hover {
+    background: #fff1f2;
+    color: var(--accent);
+}
+
+/* Tabs */
+.tabs {
+    display: flex;
+    gap: 1.4em;
+    margin-bottom: 0;
+}
+.tab {
+    background: var(--border);
+    border: none;
+    padding: 0.72em 2.2em;
+    cursor: pointer;
+    border-radius: 8px 8px 0 0;
+    font-weight: 600;
+    font-size: 1.11em;
+    color: #b91c3a;
+    transition: background 0.13s, color 0.11s;
+    border: 2px solid var(--border);
+    border-bottom: 0px;
+    z-index: 0;
+    transform: translateY(2px);  /* 1px nach unten */
+}
+.tab.active {
+    background: #fff1f2;
+    color: var(--accent);
+    z-index: 2;
+}
+
+/* Lightbox & Overlays – identisch für Bilder & 3D! */
+#lightboxOverlay,
+#lightbox3DOverlay {
+    display: none;
+    position: fixed;
+    z-index: 3000;
+    top: 0; left: 0; width: 100vw; height: 100vh;
+    background: rgba(159,18,57,0.84) !important;
+    justify-content: center;
+    align-items: center;
+    transition: background 0.18s;
+}
+
+#lightboxContent,
+#lightbox3DContent {
+    position: relative;
+    max-width: 96vw;
+    max-height: 96vh;
+    margin: auto;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+}
+
+#lightboxImg,
+#lightbox3DViewport {
+    max-width: 92vw;
+    max-height: 87vh;
+    border-radius: 12px;
+    background: #fff1f2;
+    border: 2px solid var(--border);
+    box-shadow: 0 5px 34px rgba(159,18,57,0.14);
+    display: block;
+    margin-bottom: 0;
+    /* Damit Canvas & Img gleich aussehen */
+    box-sizing: border-box;
+    /* zentrieren im flex-Container */
+    align-self: center;
+}
+
+/* X-Button – immer oben rechts */
+#lightboxClose,
+#lightbox3DClose {
+    position: fixed;
+    top: 24px;
+    right: 32px;
+    z-index: 3100;
+    background: none;
+    border: none;
+    color: var(--accent);
+    font-size: 2.3em;
+    font-weight: 500;
+    padding: 0;
+    cursor: pointer;
+    box-shadow: none;
+    line-height: 1;
+    transition: color 0.18s;
+}
+#lightboxClose:hover,
+#lightbox3DClose:hover {
+    color: #fd4c77;
+}
+
+/* Pfeile – immer 7vw vom Rand, identisch in beiden Lightboxes */
+#lightboxPrev,
+#lightboxNext,
+#lightbox3DPrev,
+#lightbox3DNext {
+    position: fixed;
+    top: 50%;
+    transform: translateY(-50%);
+    z-index: 3100;
+    background: none;
+    border: none;
+    color: var(--accent);
+    font-size: 3em;
+    font-weight: 500;
+    padding: 0;
+    cursor: pointer;
+    box-shadow: none;
+    line-height: 1;
+    transition: color 0.17s;
+    pointer-events: auto;
+    user-select: none;
+}
+#lightboxPrev,
+#lightbox3DPrev { left: 7vw; }
+#lightboxNext,
+#lightbox3DNext { right: 7vw; }
+#lightboxPrev:hover,
+#lightboxNext:hover,
+#lightbox3DPrev:hover,
+#lightbox3DNext:hover { color: #fd4c77; }
+
+/* Klickbare Lightbox-Sides zum Navigieren */
+.lightbox-nav-left,
+.lightbox-nav-right {
+    position: fixed;
+    top: 0; bottom: 0;
+    width: 20vw;
+    z-index: 3099;
+    cursor: pointer;
+}
+.lightbox-nav-left  { left: 0; }
+.lightbox-nav-right { right: 0; }
+
+#lightboxClose,
+#lightbox3DClose,
+#lightboxPrev,
+#lightboxNext,
+#lightbox3DPrev,
+#lightbox3DNext {
+    color: #fd4c77 !important;
+    transition: color 0.18s;
+}
+#lightboxClose:hover,
+#lightbox3DClose:hover,
+#lightboxPrev:hover,
+#lightboxNext:hover,
+#lightbox3DPrev:hover,
+#lightbox3DNext:hover {
+    color: var(--accent) !important;
+}
+
+
+button:focus { outline: none; }
+textarea { resize: none !important; }
+
+/* ---- 3D Lightbox identisch wie Image Lightbox ---- */
+#lightbox3DOverlay {
+    display: none;
+    position: fixed;
+    z-index: 3000;
+    top: 0; left: 0; width: 100vw; height: 100vh;
+    background: rgba(255, 17, 62, 0.84);
+    justify-content: center;
+    align-items: center;
+    transition: background 0.18s;
+}
+#lightbox3DContent {
+    position: relative;
+    max-width: 96vw;
+    max-height: 96vh;
+    margin: auto;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+}
+#lightbox3DViewport {
+    max-width: 92vw;
+    max-height: 87vh;
+    border-radius: 12px;
+    background: #fff1f2;
+    border: 2px solid var(--border);
+    box-shadow: 0 5px 34px rgba(159,18,57,0.14);
+    display: block;
+    margin-bottom: 0;
+    overflow: hidden;
+}
+/* Das Canvas darin füllt den Viewport */
+#lightbox3DViewport canvas {
+    width: 100% !important;
+    height: 100% !important;
+    display: block;
+    max-width: 100%;
+    max-height: 100%;
+    margin: 0 auto;
+    background: transparent;
+}
+
+/* X-Button – immer oben rechts, wie bei Bild-Lightbox */
+#lightbox3DClose {
+    position: fixed;
+    top: 24px;
+    right: 32px;
+    z-index: 3100;
+    background: none;
+    border: none;
+    color: var(--accent);
+    font-size: 2.3em;
+    font-weight: 500;
+    padding: 0;
+    cursor: pointer;
+    box-shadow: none;
+    line-height: 1;
+    transition: color 0.18s;
+}
+#lightbox3DClose:hover {
+    color: #fd4c77;
+}
+
+/* Pfeile groß und wie bei Image-Lightbox */
+#lightbox3DPrev,
+#lightbox3DNext {
+    position: fixed;
+    top: 50%;
+    transform: translateY(-50%);
+    z-index: 3100;
+    background: none;
+    border: none;
+    color: var(--accent);
+    font-size: 3em;
+    font-weight: 500;
+    padding: 0.06em 0.28em;
+    cursor: pointer;
+    box-shadow: none;
+    line-height: 1;
+    border-radius: 50%;
+    transition: color 0.18s, background 0.13s, box-shadow 0.14s;
+    pointer-events: auto;
+    user-select: none;
+}
+#lightbox3DPrev { left: 3vw; }
+#lightbox3DNext { right: 3vw; }
+
+#lightbox3DPrev:hover,
+#lightbox3DNext:hover {
+    color: #fff;
+}
+/* ----------- Placeholder / Kachel für Bild-Generierung ----------- */
+.placeholder-tile {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    aspect-ratio: 1 / 1;
+    width: 100%;
+    background: linear-gradient(135deg, #fff1f2 60%, #ffdbe7 100%);
+    border: 2px dashed #fd4c77;
+    border-radius: 10px;
+    position: relative;
+    animation: placeholder-shimmer 1.1s linear infinite;
+    min-height: 120px;
+    min-width: 0;
+    box-sizing: border-box;
+}
+.placeholder-tile::after {
+    content: " ";
+    font-size: 2.1em;
+    color: #fda4af;
+    opacity: 0.8;
+    animation: placeholder-pulse 1.4s cubic-bezier(0.4,0,0.2,1) infinite;
+}
+
+@keyframes placeholder-shimmer {
+    0% { filter: brightness(1); }
+    50% { filter: brightness(1.07); }
+    100% { filter: brightness(1); }
+}
+@keyframes placeholder-pulse {
+    0%, 100% { opacity: 0.6; }
+    50% { opacity: 1; }
+}
+
+.images-section, .models-section {
+    display: flex;
+    flex-direction: column;
+    align-items: stretch;
+}
+
+#images-pagination, #models-pagination {
+    display: flex;
+    justify-content: center;
+    background: var(--bg-sidebar);
+    border-radius: 0 7px 0 0;
+    border: 2px solid var(--border);
+    border-bottom: none;
+    padding: 1em 0 0.2em 0;
+}
+#images-pagination .pagination,
+#models-pagination .pagination {
+    display: flex;
+    gap: 1.1em;
+    align-items: center;
+}
+
+.images-section, .models-section {
+    transition: opacity 0.3s;
+}
+.images-section[style*="none"], .models-section[style*="none"] {
+    opacity: 0;
+    pointer-events: none;
+}
+.tab.active {
+    background: linear-gradient(90deg, #fff1f2 80%, #fda4af28 100%);
+    color: var(--accent);
+    box-shadow: 0 3px 18px #fda4af18;
+}
+.images:empty,
+.models:empty {
+    display: none !important;
+}
+#gallery-wrapper,
+#images-pagination,
+#models-pagination {
+  display: none;
+}
+</style>
+        <script src="https://unpkg.com/three@0.125.2/build/three.min.js"></script>
+        <script src="https://unpkg.com/three@0.125.2/examples/js/loaders/GLTFLoader.js"></script>
+        <script src="https://unpkg.com/three@0.125.2/examples/js/loaders/DRACOLoader.js"></script>
+        <script src="https://unpkg.com/three@0.125.2/examples/js/controls/OrbitControls.js"></script>
+
+        <!--
+        <script type="module">
+          import * as THREE from 'https://unpkg.com/three@0.165.0/build/three.module.js';
+          import { OrbitControls } from 'https://unpkg.com/three@0.165.0/examples/jsm/controls/OrbitControls.js';
+          import { GLTFLoader } from 'https://unpkg.com/three@0.165.0/examples/jsm/loaders/GLTFLoader.js';
+          import { DRACOLoader } from 'https://unpkg.com/three@0.165.0/examples/jsm/loaders/DRACOLoader.js';
+
+          // ...ab hier ist dein 3D-Code!
+          // Ersetze alle Vorkommen von window.THREE, window.GLTFLoader, window.DRACOLoader usw. 
+          // durch die direkt importierten Objekte.
+        </script>-->
+
+
+
+        <script src="https://cdn.jsdelivr.net/npm/stackblur-canvas@2.2.0/dist/stackblur.min.js"></script>
+
+        <script src="https://cdn.jsdelivr.net/npm/jsonrepair@3.12.0/lib/umd/jsonrepair.min.js"></script>
+
+
+</head>
+<body>
+    <div class="container">
+        <div class="app-header">
+            <h2>3D-Model Generator</h2>
+            <button id="settingsBtn" class="icon-button" title="Settings" aria-label="Settings">&#9881;</button>
+        </div>
+
+        <!-- Input & “Generate Prompt” -->
+        <div class="section">
+            <div class="input-row">
+                <input id="obj" type="text" placeholder="Enter object name (e.g. low poly farmer)" />
+                <button id="promptBtn">Generate Prompt</button>
+                <span class="spinner" id="spin1">⏳ Generating...</span>
+            </div>
+        </div>
+
+        <!-- LLM Output -->
+        <div class="section">
+            <label>LLM Output</label>
+            <pre id="llm_out"></pre>
+        </div>
+
+        <!-- JSON Output (editable) -->
+        <div class="section">
+            <label>Diffusion Settings</label>
+            <div class="json-row">
+                <textarea id="json_out"></textarea>
+                <div class="json-row-bottom">
+                    <div id="tokenCounter"></div>
+                    <button id="moreBtn">Generate Images</button>
+                </div>
+            </div>
+        </div>
+
+        <!-- Gallery Tabs -->
+        <div id="gallery-wrapper">
+            <div class="tabs">
+                <button id="tabImages" class="tab active">Images</button>
+                <button id="tab3D" class="tab">3D Gallery</button>
+            </div>
+            <div class="section images-section" id="images-section">
+                <div id="images-pagination"></div>
+                <div class="images" id="images"></div>
+            </div>
+            <div class="section models-section" id="models-section" style="display:none;">
+                <div id="models-pagination"></div>
+                <div class="models" id="models"></div>
+            </div>
+        </div>
+    </div>
+
+    <div id="settingsOverlay" class="settings-overlay" aria-hidden="true">
+        <div class="settings-panel" role="dialog" aria-modal="true" aria-labelledby="settingsTitle">
+            <div class="settings-header">
+                <h3 id="settingsTitle">Settings</h3>
+                <button id="settingsClose" class="settings-close" aria-label="Close settings">&times;</button>
+            </div>
+            <label for="imageGenerationBackend">Image Generator</label>
+            <select id="imageGenerationBackend">
+                <option value="local">Local (Diffusers)</option>
+                <option value="replicate">Replicate API</option>
+            </select>
+            <label for="replicateImageModel">Replicate Image Model</label>
+            <select id="replicateImageModel">
+                <option value="black-forest-labs/flux-schnell">FLUX.1 schnell - cheap drafts</option>
+                <option value="google/imagen-4-fast">Google Imagen 4 Fast - balanced</option>
+                <option value="bytedance/seedream-4">ByteDance Seedream 4 - higher quality</option>
+            </select>
+            <div class="settings-note">
+                <strong>Replicate pricing</strong>
+                Local Diffusers has no Replicate image charge. Replicate image options are billed per output: FLUX.1 schnell is $3 per 1000 images, Imagen 4 Fast is $0.02 per image, and Seedream 4 is $0.03 per image. Hunyuan 3D 3.1 model conversion is $0.16 per unit. Prices are listed by Replicate and may change.
+            </div>
+            <label for="replicateToken">Replicate API Token</label>
+            <input id="replicateToken" type="password" placeholder="r8_..." autocomplete="off" />
+            <label class="setting-check" for="showReplicateToken">
+                <input id="showReplicateToken" type="checkbox" />
+                Show key
+            </label>
+            <div id="settingsStatus" class="settings-status"></div>
+            <div class="settings-actions">
+                <button id="clearSettingsBtn" class="secondary">Clear</button>
+                <button id="saveSettingsBtn">Save</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- Context Menu for right‐click on images -->
+    <div id="ctxMenu">
+        <div id="ctxEditExternal">Edit Externally</div>
+        <div id="ctxUseData">Use Generation Data</div>
+        <div id="ctxGenerate3D">Generate 3D Model</div>
+        <div id="ctxGenerate3DEqui">Generate 3D Model + HDRI</div>
+    </div>
+
+    <!-- Lightbox Overlay for 2D images -->
+    <div id="lightboxOverlay">
+        <div id="lightboxContent">
+            <button id="lightboxClose">&times;</button>
+            <button id="lightboxPrev">&#10094;</button>
+            <img id="lightboxImg" src="" alt="Full Image" />
+            <button id="lightboxNext">&#10095;</button>
+        </div>
+    </div>
+
+    <!-- Lightbox Overlay for 3D viewer -->
+    <div id="lightbox3DOverlay">
+        <div id="lightbox3DContent">
+            <button id="lightbox3DClose">&times;</button>
+            <button id="lightbox3DPrev">&#10094;</button>
+            <div id="lightbox3DViewport"></div>
+            <button id="lightbox3DNext">&#10095;</button>
+        </div>
+    </div>
+
+    <script>
+
+                // Basic references
+        const llm_out        = document.getElementById("llm_out");
+        const json_out       = document.getElementById("json_out");
+        const images         = document.getElementById("images");
+        const promptBtn      = document.getElementById("promptBtn");
+        const spinner        = document.getElementById("spin1");
+        const moreBtn        = document.getElementById("moreBtn");
+        let generateHandler, stopHandler;
+        let isGenerating = false;
+        const ctxMenu        = document.getElementById("ctxMenu");
+        const ctxEditExt     = document.getElementById("ctxEditExternal");
+        const ctxUseData     = document.getElementById("ctxUseData");
+        const ctxGen3D       = document.getElementById("ctxGenerate3D");
+        const ctxGen3DEqui   = document.getElementById("ctxGenerate3DEqui");
+        const tabImages      = document.getElementById("tabImages");
+        const tab3D          = document.getElementById("tab3D");
+        const imagesDiv      = document.getElementById("images");
+        const modelsDiv      = document.getElementById("models");
+        const tokenCounter = document.getElementById('tokenCounter');
+        const imagesSection = document.querySelector('.images-section');
+        const modelsSection = document.getElementById('models-section');
+        const settingsBtn = document.getElementById("settingsBtn");
+        const settingsOverlay = document.getElementById("settingsOverlay");
+        const settingsClose = document.getElementById("settingsClose");
+        const imageGenerationBackend = document.getElementById("imageGenerationBackend");
+        const replicateImageModel = document.getElementById("replicateImageModel");
+        const replicateToken = document.getElementById("replicateToken");
+        const showReplicateToken = document.getElementById("showReplicateToken");
+        const settingsStatus = document.getElementById("settingsStatus");
+        const saveSettingsBtn = document.getElementById("saveSettingsBtn");
+        const clearSettingsBtn = document.getElementById("clearSettingsBtn");
+        
+        let generateForeverActive = false;
+        let generateForeverAbort = false;
+        let generateForeverMenu = null;
+        let activePlaceholders = null;
+        let hasSavedReplicateToken = false;
+
+        let lastValidDiffusionSettings = null;
+
+        function syncReplicateModelState() {
+            replicateImageModel.disabled = imageGenerationBackend.value !== "replicate";
+        }
+
+        async function refreshSettingsState() {
+            try {
+                if (!window.pywebview || !window.pywebview.api || !window.pywebview.api.get_settings) {
+                    settingsStatus.textContent = "Settings are not ready yet.";
+                    return;
+                }
+                const settings = await window.pywebview.api.get_settings();
+                hasSavedReplicateToken = Boolean(settings.has_replicate_api_token);
+                imageGenerationBackend.value = settings.image_generation_backend || "local";
+                replicateImageModel.value = settings.replicate_image_model || "google/imagen-4-fast";
+                syncReplicateModelState();
+                replicateToken.value = "";
+                replicateToken.placeholder = hasSavedReplicateToken ? "Token is set" : "r8_...";
+                settingsStatus.textContent = settings.replicate_api_token_source === "environment"
+                    ? "Replicate API token available from environment."
+                    : hasSavedReplicateToken ? "Replicate API token saved." : "No Replicate API token saved.";
+            } catch (e) {
+                settingsStatus.textContent = "Could not load settings.";
+            }
+        }
+
+        async function openSettings() {
+            settingsOverlay.classList.add("active");
+            settingsOverlay.setAttribute("aria-hidden", "false");
+            await refreshSettingsState();
+            replicateToken.focus();
+        }
+
+        function closeSettings() {
+            settingsOverlay.classList.remove("active");
+            settingsOverlay.setAttribute("aria-hidden", "true");
+            replicateToken.value = "";
+            showReplicateToken.checked = false;
+            replicateToken.type = "password";
+        }
+
+        settingsBtn.addEventListener("click", openSettings);
+        settingsClose.addEventListener("click", closeSettings);
+        settingsOverlay.addEventListener("mousedown", (e) => {
+            if (e.target === settingsOverlay) closeSettings();
+        });
+        imageGenerationBackend.addEventListener("change", syncReplicateModelState);
+        showReplicateToken.addEventListener("change", () => {
+            replicateToken.type = showReplicateToken.checked ? "text" : "password";
+        });
+        saveSettingsBtn.addEventListener("click", async () => {
+            const token = replicateToken.value.trim();
+            saveSettingsBtn.disabled = true;
+            try {
+                const result = await window.pywebview.api.save_settings({
+                    replicate_api_token: token,
+                    image_generation_backend: imageGenerationBackend.value,
+                    replicate_image_model: replicateImageModel.value
+                });
+                hasSavedReplicateToken = Boolean(result.has_replicate_api_token);
+                replicateToken.value = "";
+                replicateToken.placeholder = hasSavedReplicateToken ? "Token is set" : "r8_...";
+                syncReplicateModelState();
+                settingsStatus.textContent = hasSavedReplicateToken
+                    ? "Settings saved. Replicate API token is available."
+                    : "Settings saved. Add a Replicate API token before using API generation.";
+            } catch (e) {
+                settingsStatus.textContent = "Could not save settings.";
+            } finally {
+                saveSettingsBtn.disabled = false;
+            }
+        });
+        clearSettingsBtn.addEventListener("click", async () => {
+            clearSettingsBtn.disabled = true;
+            try {
+                const result = await window.pywebview.api.clear_replicate_api_token();
+                hasSavedReplicateToken = Boolean(result.has_replicate_api_token);
+                replicateToken.value = "";
+                replicateToken.placeholder = hasSavedReplicateToken ? "Token is set" : "r8_...";
+                if (result.image_generation_backend) imageGenerationBackend.value = result.image_generation_backend;
+                if (result.replicate_image_model) replicateImageModel.value = result.replicate_image_model;
+                syncReplicateModelState();
+                settingsStatus.textContent = result.replicate_api_token_source === "environment"
+                    ? "Saved token cleared. Environment token is still active."
+                    : "Replicate API token cleared.";
+            } catch (e) {
+                settingsStatus.textContent = "Could not clear settings.";
+            } finally {
+                clearSettingsBtn.disabled = false;
+            }
+        });
+        
+        // Lightbox elements
+        const lightboxOverlay     = document.getElementById("lightboxOverlay");
+        const lightboxImg         = document.getElementById("lightboxImg");
+        const lightboxClose       = document.getElementById("lightboxClose");
+        const lightboxPrev        = document.getElementById("lightboxPrev");
+        const lightboxNext        = document.getElementById("lightboxNext");
+        const lightbox3DOverlay   = document.getElementById("lightbox3DOverlay");
+        const lightbox3DClose     = document.getElementById("lightbox3DClose");
+        const lightbox3DPrev      = document.getElementById("lightbox3DPrev");
+        const lightbox3DNext      = document.getElementById("lightbox3DNext");
+        const lightbox3DViewport  = document.getElementById("lightbox3DViewport");
+
+        let lastObject     = "";
+        let ctxTargetFile  = "";    // filepath under right-click
+        let currentIndex   = -1;    // index inside galleryFiles
+
+        let isBatchActive = false;
+        let is3DContext = false;
+
+
+        // For 3D gallery
+        let currentModelIndex = -1;
+
+        // Pagination
+        let currentPageImages = 1;
+        let imagesPerPage = 16;
+        let currentPage3D = 1;
+        let modelsPerPage = 16;
+
+        // --- Gallerie-Daten ---
+        let galleryFiles   = [];
+        let modelGallery   = [];
+
+
+        const DEFAULT_SETTINGS = {
+            "checkpoint": "RealismPlus/dreamshaper_8.safetensors",
+            "vae": "Automatic",
+            "sampler": "DPM++ 2M Karras",
+            "steps": 30,
+            "cfg_scale": 6.5,
+            "batch_count": 4
+        };
+
+        function mergeDiffusionSettings(userSettings, llmSettings) {
+            // User-Settings als Baseline!
+            let merged = { ...userSettings };
+
+            // Felder aus dem LLM überschreiben
+            ["positive prompt", "negative prompt", "dimensions"].forEach(key => {
+                if (llmSettings[key] !== undefined) merged[key] = llmSettings[key];
+            });
+
+            // Felder ergänzen, die fehlen (nur falls auch im User-JSON nicht vorhanden!)
+            for (const [key, defVal] of Object.entries(DEFAULT_SETTINGS)) {
+                if (
+                    merged[key] === undefined ||
+                    merged[key] === null ||
+                    (typeof defVal === "number" && isNaN(merged[key]))
+                ) {
+                    merged[key] = defVal;
+                }
+            }
+
+            // Dimensions prüfen
+            if (
+                !Array.isArray(merged.dimensions) ||
+                merged.dimensions.length !== 2 ||
+                merged.dimensions.some(x => typeof x !== "number" || !Number.isFinite(x))
+            ) {
+                merged.dimensions = [768, 768];
+            }
+
+            return merged;
+        }
+
+
+        function updateTokenCounter() {
+            let prompt = "";
+            let approxTokens = 0;
+
+            try {
+                // Regulärer Weg (wenn das JSON schon valid ist)
+                let json = JSON.parse(sanitizeDiffusionJSON(json_out.value));
+                prompt = (json["positive prompt"] || "");
+            } catch {
+                // "Hacky" Extraction: Fallback für invalides JSON beim Streamen
+                // Suche nach: "positive prompt": "irgendwas
+                let raw = sanitizeDiffusionJSON(json_out.value);
+                let match = raw.match(/"positive prompt"\s*:\s*"([^"]*)/s); // /s = dotall (Zeilenumbruch inkludiert)
+                if (match) {
+                    prompt = match[1];
+                }
+            }
+
+            approxTokens = Math.ceil(prompt.length / 4); // grobe Schätzung
+            tokenCounter.textContent = `Approx. ${approxTokens} / 77 Tokens used`;
+            tokenCounter.style.color = approxTokens > 77 ? "#b91c3a" : "#7b1930";
+            if (approxTokens > 77) tokenCounter.textContent += " ⚠️";
+        }
+
+        // Initialisieren bei Seite-Laden
+        window.addEventListener("DOMContentLoaded", updateTokenCounter);
+        // Bei jeder Änderung!
+        json_out.addEventListener("input", updateTokenCounter);
+        json_out.addEventListener("input", function () {
+            try {
+                // Teste, ob das Feld gerade valides JSON ist
+                JSON.parse(sanitizeDiffusionJSON(json_out.value));
+                lastValidDiffusionSettings = sanitizeDiffusionJSON(json_out.value);
+                // Optional: console.log("Valid JSON saved!");
+            } catch {
+                // Kein gültiges JSON – tue nichts
+            }
+        });
+        
+
+        function sanitizeDiffusionJSON(raw) {
+            // 1. Typografische Anführungszeichen ersetzen
+            let fixed = raw.replace(/[“”„«»]/g, '"').replace(/[‘’‚‹›]/g, "'");
+
+            // 2. JSON parsen
+            let data;
+            try {
+                data = JSON.parse(fixed);
+            } catch (e) {
+                // Wenn trotzdem kein valides JSON: original zurückgeben
+                return fixed;
+            }
+
+            // 3. Prompts als String erzwingen und Punkte als Kommas ersetzen
+            ["positive prompt", "negative prompt"].forEach(key => {
+                if (Array.isArray(data[key])) {
+                    data[key] = data[key].join(" ");
+                }
+                if (typeof data[key] === "string") {
+                    // Ersetze ". " und punktuelle Satzenden durch Kommas, aber keine Punkte in Zahlen!
+                    data[key] = data[key]
+                        .replace(/\. +/g, ", ")  // Punkt + Leerzeichen → Komma
+                        .replace(/([a-zA-Z0-9\)])\.\s*$/gm, "$1") // Entfernt Punkt am Zeilenende
+                        .replace(/([^\d])\.(?=[^,\d])/g, "$1,") // Punkte die KEINE Dezimalstellen sind → Komma
+                        .replace(/,+/g, ",") // Mehrere Kommas hintereinander zu einem Komma
+                        .replace(/^,|,$/g, ""); // Komma am Anfang/Ende entfernen
+                }
+            });
+
+            // 4. Wieder als hübsches JSON ausgeben
+            return JSON.stringify(data, null, 2);
+        }
+
+
+        // Hilfsfunktion zum Schließen aller Menüs
+        function closeAllContextMenus() {
+            ctxMenu.style.display = "none";
+            if (generateForeverMenu) generateForeverMenu.style.display = "none";
+        }
+
+        // Schließe alle Kontextmenüs bei jedem Klick außerhalb
+        document.addEventListener("mousedown", (e) => {
+            if (e.button !== 0) return; // Nur Linksklick
+            if (
+              !ctxMenu.contains(e.target) &&
+              (!generateForeverMenu || !generateForeverMenu.contains(e.target))
+            ) {
+                closeAllContextMenus();
+            }
+        });
+
+        // Auch bei jedem Rechtsklick schließen
+        document.addEventListener("contextmenu", (e) => {
+            if (
+              !ctxMenu.contains(e.target) &&
+              (!generateForeverMenu || !generateForeverMenu.contains(e.target))
+            ) {
+                closeAllContextMenus();
+            }
+        });
+
+        // Auch bei ESC-Taste schließen
+        document.addEventListener("keydown", (e) => {
+            if (e.key === "Escape") {
+                closeAllContextMenus();
+                if (settingsOverlay.classList.contains("active")) closeSettings();
+            }
+        });
+
+        lightbox3DViewport.addEventListener("contextmenu", (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            // Setzt das Kontextfile auf das aktuell angezeigte Model-Image (Preview)
+            if (currentModelIndex >= 0 && modelGallery[currentModelIndex]) {
+                ctxTargetFile = modelGallery[currentModelIndex].img; // Das PNG-Preview!
+                // Zeigt das reduzierte Kontextmenü an
+                is3DContext = true;
+                ctxEditExt.style.display = "block";
+                ctxUseData.style.display = "block";
+                ctxGen3D.style.display = "none";
+                ctxGen3DEqui.style.display = "none";
+                ctxMenu.style.top = e.pageY + "px";
+                ctxMenu.style.left = e.pageX + "px";
+                ctxMenu.style.display = "block";
+            }
+        });
+
+        // --- Pagination Helper ---
+        function getPaginated(arr, page, perPage) {
+            const start = (page - 1) * perPage;
+            return arr.slice(start, start + perPage);
+        }
+        function getTotalPages(arr, perPage) {
+            return Math.max(1, Math.ceil(arr.length / perPage));
+        }
+
+
+        stopHandler = () => {
+          moreBtn.textContent = "Stopping…";
+          moreBtn.disabled = true;
+          window.pywebview.api.stop_generation();
+          // Wait for backend to confirm before resetting button (see below)
+        };
+
+
+        generateHandler = () => {
+            // 1. Versuche das aktuelle JSON zu parsen
+            let currentJSON = sanitizeDiffusionJSON(json_out.value).trim();
+            let validJSON = null;
+            try {
+                JSON.parse(currentJSON);
+                validJSON = currentJSON;
+                // Optional: lastValidDiffusionSettings = currentJSON; // falls du hier nochmal sicherst
+            } catch {
+                // Wenn kaputt: Das letzte valide nehmen!
+                if (lastValidDiffusionSettings) {
+                    validJSON = lastValidDiffusionSettings;
+                    json_out.value = lastValidDiffusionSettings; // Zeige es dem User!
+                    updateTokenCounter();
+                    console.log("Ungültiges JSON erkannt! Die letzten gültigen Einstellungen wurden verwendet.");
+                } else {
+                    validJSON = defaultJSON;
+                    json_out.value = defaultJSON;
+                    updateTokenCounter();
+                    console.log("JSON war ungültig, Defaults werden benutzt.");
+                }
+            }
+            if (!validJSON) {
+                alert("Kann kein valides JSON finden.");
+                return;
+            }
+
+            // Button-UI usw. wie gehabt:
+            isGenerating = true;
+            moreBtn.textContent = "Generating... (Stop)";
+            moreBtn.removeEventListener("click", generateHandler);
+            moreBtn.addEventListener("click", stopHandler);
+            moreBtn.disabled = false;
+            promptBtn.disabled = true;
+
+            window.pywebview.api.generate_images(sanitizeDiffusionJSON(validJSON));
+        };
+
+        // Funktion zum Zurücksetzen der UI nach Ende / Error:
+        function endGenerateUI() {
+            isGenerating = false;
+            if(!generateForeverActive){
+                moreBtn.textContent = "Generate Images";
+                moreBtn.removeEventListener("click", stopHandler);
+                moreBtn.addEventListener("click", generateHandler); // re-attach generate
+                moreBtn.disabled = false;                          // make it clickable again
+                promptBtn.disabled = false;
+            }
+        }
+
+        // Bei Laden binde den Handler:
+        moreBtn.addEventListener("click", generateHandler);
+
+        // --- Images Gallery Rendering mit Pagination ---
+
+        function renderImagesGallery() {
+            images.innerHTML = "";
+
+            // Wenn auf Seite 1 und Placeholders aktiv, zeige sie zuerst!
+            let placeholderCount = 0;
+            if (currentPageImages === 1 && activePlaceholders && activePlaceholders.count > 0) {
+                placeholderCount = activePlaceholders.count;
+                for (let i = 0; i < placeholderCount; i++) {
+                    const placeholder = document.createElement("div");
+                    placeholder.className = "placeholder-tile";
+                    placeholder.dataset.placeholderIndex = i;
+                    placeholder.dataset.batchId = activePlaceholders.batchId;
+                    images.appendChild(placeholder);
+                }
+            }
+
+            // Dann normale Bilder, aber auf Seite 1 Platz für die Tiles abziehen!
+            const start = (currentPageImages - 1) * imagesPerPage;
+            let filesToShow = galleryFiles.slice(start, start + imagesPerPage - placeholderCount);
+
+            filesToShow.forEach(item => {
+                addImageToGallery(item.filepath);
+            });
+
+            renderImagesPagination(getTotalPages(galleryFiles, imagesPerPage));
+            updateTabsVisibility();
+        }
+
+                // Helper zum Tab-Button ein/ausblenden
+        function updateTabsVisibility() {
+            const galleryWrapper = document.getElementById('gallery-wrapper');
+            const hasImages = galleryFiles && galleryFiles.length > 0;
+            const hasPlaceholders = activePlaceholders && activePlaceholders.count > 0;
+            const hasModels = modelGallery && modelGallery.length > 0;
+
+            if (!hasImages && !hasModels && !hasPlaceholders) {
+                galleryWrapper.style.display = "none";
+                return;
+            } else {
+                galleryWrapper.style.display = "block";
+            }
+            
+            // 3D Gallery Tab Handling
+            if (hasModels) {
+                tab3D.style.display = "";
+            } else {
+                tab3D.style.display = "none";
+                // Falls aktuell 3D aktiv, wechsel auf Images
+                if (tab3D.classList.contains("active")) {
+                    tabImages.classList.add("active");
+                    tab3D.classList.remove("active");
+                    imagesSection.style.display = (hasImages || hasPlaceholders) ? "flex" : "none";
+                    modelsSection.style.display = "none";
+                }
+            }
+
+            // Images Tab Handling
+            if (hasImages || hasPlaceholders) {
+                tabImages.style.display = "";
+                imagesSection.style.display = "flex";
+            } else {
+                tabImages.style.display = "none";
+                imagesSection.style.display = "none";
+                // Falls aktuell Images aktiv, wechsel auf 3D (falls da!)
+                if (tabImages.classList.contains("active")) {
+                    if (hasModels) {
+                        tab3D.classList.add("active");
+                        tabImages.classList.remove("active");
+                        modelsSection.style.display = "flex";
+                    }
+                }
+            }
+            if (tabImages.classList.contains("active")) {
+                imagesSection.style.display = "flex";
+                modelsSection.style.display = "none";
+            } else if (tab3D.classList.contains("active")) {
+                imagesSection.style.display = "none";
+                modelsSection.style.display = "flex";
+            }  
+        }
+
+        function updateImagesSectionVisibility() {
+            const section = document.querySelector('.images-section');
+            if (galleryFiles && galleryFiles.length > 0) {
+                section.style.display = "flex";
+                tabImages.style.display = "";
+            } else {
+                section.style.display = "none";
+                tabImages.style.display = "none";
+                // Wenn gerade der Tab aktiv ist, auf 3D schalten (falls da was da ist):
+                if (tabImages.classList.contains("active")) {
+                    if (modelGallery && modelGallery.length > 0) {
+                        tab3D.classList.add("active");
+                        tabImages.classList.remove("active");
+                        document.getElementById('models-section').style.display = "flex";
+                        renderModelsGallery();
+                        updateTabsVisibility();
+                    }
+                }
+            }
+        }
+                
+        function renderImagesPagination(totalPages) {
+            const pagDiv = document.getElementById('images-pagination');
+            pagDiv.innerHTML = "";
+            if (totalPages <= 1) {
+                pagDiv.style.display = "none";
+                return;
+            }
+            let pag = document.createElement("div");
+            pag.className = "pagination";
+            pag.innerHTML = `
+                <button ${currentPageImages === 1 ? "disabled" : ""} id="imgPrevPg">&lt; Previous</button>
+                Page ${currentPageImages} / ${totalPages}
+                <button ${currentPageImages === totalPages ? "disabled" : ""} id="imgNextPg">Next &gt;</button>
+            `;
+            pagDiv.appendChild(pag);
+            if (currentPageImages > 1) {
+                pag.querySelector("#imgPrevPg").onclick = () => { currentPageImages--; renderImagesGallery(); }
+            }
+            if (currentPageImages < totalPages) {
+                pag.querySelector("#imgNextPg").onclick = () => { currentPageImages++; renderImagesGallery(); }
+            }
+            pagDiv.style.display = "flex";
+        }
+        // --- 3D Gallery Rendering mit Pagination ---
+        function renderModelsGallery() {
+            modelsDiv.innerHTML = "";
+
+            const totalPages = getTotalPages(modelGallery, modelsPerPage);
+            if (currentPage3D > totalPages) currentPage3D = totalPages;
+            const visible = getPaginated(modelGallery, currentPage3D, modelsPerPage);
+            visible.forEach((entry, i) => {
+                const thumb = document.createElement("div");
+                thumb.className = "model-thumb";
+                const img = document.createElement("img");
+                img.src = entry.img;
+                img.style.width = "100%";
+                img.style.height = "100%";
+                img.style.objectFit = "cover";
+                thumb.appendChild(img);
+                thumb.addEventListener("click", () => open3DLightbox((currentPage3D-1)*modelsPerPage + i));
+                thumb.addEventListener("contextmenu", (e) => {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    ctxTargetFile = entry.img;
+                    showContextMenu(e.pageX, e.pageY);
+                });
+                modelsDiv.appendChild(thumb);
+            });
+
+            renderModelsPagination(totalPages);
+        }
+
+        function renderModelsPagination(totalPages) {
+            const pagDiv = document.getElementById('models-pagination');
+            const modelsGrid = document.getElementById('models');
+            // Klassen für Borderradius/Styling zuerst resetten
+            modelsGrid.classList.remove("rounded", "with-pagination");
+            pagDiv.innerHTML = "";
+            if (totalPages <= 1) {
+                pagDiv.style.display = "none";
+                modelsGrid.classList.add("rounded");
+                return;
+            }
+            pagDiv.style.display = "flex";
+            modelsGrid.classList.add("with-pagination");
+
+            let pag = document.createElement("div");
+            pag.className = "pagination";
+            pag.innerHTML = `
+                <button ${currentPage3D === 1 ? "disabled" : ""} id="modPrevPg">&lt; Previous</button>
+                Page ${currentPage3D} / ${totalPages}
+                <button ${currentPage3D === totalPages ? "disabled" : ""} id="modNextPg">Next &gt;</button>
+            `;
+            pagDiv.appendChild(pag);
+            if (currentPage3D > 1) {
+                pag.querySelector("#modPrevPg").onclick = () => { currentPage3D--; renderModelsGallery(); }
+            }
+            if (currentPage3D < totalPages) {
+                pag.querySelector("#modNextPg").onclick = () => { currentPage3D++; renderModelsGallery(); }
+            }
+        }
+
+
+
+
+        // ------------- Default JSON Template -------------
+        const defaultJSON = `
+{
+  "positive prompt": "",
+  "negative prompt": "",
+  "dimensions": [768, 768],
+  "checkpoint": "RealismPlus/dreamshaper_8.safetensors",
+  "vae": "Automatic",
+  "sampler": "DPM++ 2M Karras",
+  "steps": 30,
+  "cfg_scale": 6.5,
+  "batch_count": 4
+}`;
+
+        // ------------- Reset Text Outputs -------------
+        function resetTextOutputs() {
+            llm_out.textContent = "";
+            //json_out.value = defaultJSON;
+            updateTokenCounter();
+            llm_out.style.display = "block"; 
+            moreBtn.disabled = true;
+        }
+
+        // ------------- “Generate Prompt” handler -------------
+        promptBtn.addEventListener("click", () => {
+            const objectName = document.getElementById("obj").value.trim();
+            if (!objectName) return;
+            lastObject = objectName;
+            resetTextOutputs();
+            spinner.classList.add("active");
+            promptBtn.disabled = true;
+            moreBtn.disabled = true;
+            window.pywebview.api.generate_prompt(objectName);
+        });
+        document.getElementById("obj").addEventListener("keydown", (e) => {
+            if (e.key === "Enter") {
+                promptBtn.click();
+            }
+        });
+
+        window.addEventListener('pywebviewready', function() {
+            json_out.value = defaultJSON;
+            updateTokenCounter();
+            refreshSettingsState();
+
+            window.pywebview.api.get_initial_images().then((items) => {
+                galleryFiles = items;
+                currentPageImages = 1;
+                // Setze den Images-Tab aktiv, falls noch keiner aktiv ist
+                tabImages.classList.add("active");
+                tab3D.classList.remove("active");
+                renderImagesGallery();    // <- Füllt die Gallery und setzt .images-section sichtbar wenn nötig!
+                imagesSection.style.display = "flex"; // <-- Explizit sichtbar machen!
+                modelsSection.style.display = "none";
+                updateTabsVisibility();
+                if (galleryFiles.length > 0) moreBtn.style.display = "inline-block";
+            });
+            window.pywebview.api.get_3d_models().then(list => {
+                modelGallery = list;
+                // Nur sichtbar schalten, falls der Tab aktiv ist oder gar kein Images-Content da ist
+                if (tab3D.classList.contains("active")) {
+                    modelsSection.style.display = "flex";
+                    imagesSection.style.display = "none";
+                }
+                updateTabsVisibility();
+            });
+
+            // (… der Rest: foreverMenu etc. ...)
+        });
+
+
+        // ------------- Load existing images on startup -------------
+        window.onload = () => {
+            json_out.value = defaultJSON;
+            updateTokenCounter();
+
+
+
+
+
+
+            
+
+            // ------------- Generate Forever --------------
+
+            generateForeverMenu = document.createElement("div");
+            generateForeverMenu.style.position = "absolute";
+            generateForeverMenu.style.display = "none";
+            generateForeverMenu.style.background = "#fff";
+            generateForeverMenu.style.border = "1px solid #ccc";
+            generateForeverMenu.style.borderRadius = "7px";
+            generateForeverMenu.style.zIndex = 9999;
+            generateForeverMenu.innerHTML = '<div id="toggleForeverBtn"></div>';
+            document.body.appendChild(generateForeverMenu);
+
+            let onImageGenDoneResolve = null; // Zum "Warten" auf Fertigstellung
+
+            moreBtn.addEventListener("contextmenu", function (e) {
+                e.preventDefault();
+                e.stopPropagation();
+
+                // Setze speziellen Modus für „Generate Forever“
+                is3DContext = false;
+                ctxTargetFile = null; // Nicht relevant
+
+                // Nur diesen Eintrag anzeigen
+                ctxEditExt.style.display = "none";
+                ctxUseData.style.display = "none";
+                ctxGen3D.style.display = "none";
+                ctxGen3DEqui.style.display = "none";
+
+                // Den ersten Eintrag als „Generate Forever“ benutzen!
+                let foreverBtn = ctxMenu.querySelector("#ctxGenerateForever");
+                if (!foreverBtn) {
+                    foreverBtn = document.createElement("div");
+                    foreverBtn.id = "ctxGenerateForever";
+                    ctxMenu.prepend(foreverBtn);
+                }
+                foreverBtn.textContent = generateForeverActive ? "Stop Generate Forever" : "Generate Forever";
+                foreverBtn.style.display = "block";
+
+                // Hide all others!
+                for (const div of ctxMenu.querySelectorAll("div")) {
+                    if (div !== foreverBtn &&
+                        div !== ctxEditExt &&
+                        div !== ctxUseData &&
+                        div !== ctxGen3D &&
+                        div !== ctxGen3DEqui) {
+                        div.style.display = "none";
+                    }
+                }
+
+                // Show Menü:
+                ctxMenu.style.top = e.pageY + "px";
+                ctxMenu.style.left = e.pageX + "px";
+                ctxMenu.style.display = "block";
+            });
+
+            document.addEventListener("click", function () {
+                generateForeverMenu.style.display = "none";
+            });
+
+            // Handler für Generate Forever
+            ctxMenu.addEventListener("click", function(e) {
+                if (e.target.id === "ctxGenerateForever") {
+                    ctxMenu.style.display = "none";
+                    if (generateForeverActive) {
+                        generateForeverAbort = true;
+                        generateForeverActive = false;
+                        stopHandler();
+                    } else {
+                        generateForeverActive = true;
+                        generateForeverAbort = false;
+                        generateForeverLoop();
+                    }
+                    moreBtn.textContent = generateForeverActive ? "🌀 Generating Forever... (Stop)" : "Generate Images";
+                }
+            });
+
+            // Überschreibe window.on_image_gen_done, damit es auch Promises auflösen kann:
+            const origOnImageGenDone = window.on_image_gen_done || function(){};
+            window.on_image_gen_done = function () {
+                endGenerateUI();
+                if (typeof onImageGenDoneResolve === "function") {
+                    onImageGenDoneResolve();
+                    onImageGenDoneResolve = null;
+                }
+                origOnImageGenDone();
+            };
+
+            // ... window.on_error wie gehabt
+
+            async function generateForeverLoop() {
+                while (generateForeverActive && !generateForeverAbort) {
+                    const editedJSON = sanitizeDiffusionJSON(json_out.value).trim();
+                    if (!editedJSON) {
+                        alert("JSON is empty or invalid.");
+                        break;
+                    }
+                    //moreBtn.disabled = true;
+                    promptBtn.disabled = true;
+                    let errorDetected = false;
+                    const origOnError = window.on_error;
+                    window.on_error = function(msg) {
+                        alert("Error: " + msg);
+                        errorDetected = true;
+                        if (origOnError) origOnError(msg);
+                    };
+
+                    await window.pywebview.api.generate_images(sanitizeDiffusionJSON(editedJSON));
+
+                    // Jetzt WARTEN bis das Backend das "fertig"-Signal gibt:
+                    await new Promise(resolve => { onImageGenDoneResolve = resolve; });
+
+                    // Fertig!
+
+
+                    // Wenn Error kam, abbrechen:
+                    if (errorDetected){
+                       // promptBtn.disabled = false;
+                      //  moreBtn.disabled = false;
+                        break;
+                    }
+                    // Optional Pause:
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                }
+                generateForeverActive = false;
+            }
+        };
+
+        // --- Tab Handling ---
+        tabImages.addEventListener("click", () => {
+            tabImages.classList.add("active");
+            tab3D.classList.remove("active");
+            imagesSection.style.display = "flex";
+            modelsSection.style.display = "none";
+            renderImagesGallery();
+        });
+        tab3D.addEventListener("click", () => {
+            tab3D.classList.add("active");
+            tabImages.classList.remove("active");
+            imagesSection.style.display = "none";
+            modelsSection.style.display = "flex";
+            window.pywebview.api.get_3d_models().then(list => {
+                modelGallery = list;
+                currentPage3D = 1;
+                renderModelsGallery();
+                updateTabsVisibility();
+            });
+        });
+
+        function load3DGallery() {
+            modelsDiv.innerHTML = "";
+            window.pywebview.api.get_3d_models()
+                .then(list => {
+                    modelGallery = list;
+                    list.forEach((entry, i) => {
+                        const thumb = document.createElement("div");
+                        thumb.className = "model-thumb";
+                        // Show a still image as preview (using the PNG)
+                        const img = document.createElement("img");
+                        img.src = entry.img;
+                        img.style.width = "100%";
+                        img.style.height = "100%";
+                        img.style.objectFit = "cover";
+                        thumb.appendChild(img);
+
+                        // Left-click opens 3D lightbox
+                        thumb.addEventListener("click", () => open3DLightbox(i));
+
+                        // Right-click shows same context menu
+                        thumb.addEventListener("contextmenu", (e) => {
+                            e.preventDefault();
+                            ctxTargetFile = entry.img;
+                            showContextMenu(e.pageX, e.pageY);
+                        });
+
+                        modelsDiv.appendChild(thumb);
+                    });
+                });
+        }
+
+
+
+
+        // ------------- Callbacks from Python -------------
+
+        function extractField(streamText, fieldName) {
+            // Extrahiere den Wert eines Felds wie "positive prompt": "..."
+            const regex = new RegExp(`"${fieldName.replace(/[-[\]/{}()*+?.\\^$|]/g, '\\$&')}"\\s*:\\s*"([^"]*)`, "s");
+            const match = streamText.match(regex);
+            return match ? match[1] : undefined;
+        }
+        function extractArrayField(streamText, fieldName) {
+            // Holt das Array wie [512, 768] oder [ 512,768 ] oder [512 , 768] (egal wie viele Leerzeichen)
+            const regex = new RegExp(
+              `"${fieldName.replace(/[-[\]/{}()*+?.\\^$|]/g, '\\$&')}"\\s*:\\s*\$begin:math:display$\\\\s*(\\\\d+)\\\\s*,\\\\s*(\\\\d+)\\\\s*\\$end:math:display$`
+            );
+            const match = streamText.match(regex);
+            if (match) {
+                console.log("Dimensions erkannt:", match[1], match[2]);
+                return [parseInt(match[1], 10), parseInt(match[2], 10)];
+            } else {
+                // Fallback: Finde Array irgendwo im Text (z.B. falls das Feld anders formatiert ist)
+                const anyArr = streamText.match(/\[\s*(\d+)\s*,\s*(\d+)\s*\]/);
+                if (anyArr) {
+                    console.log("Fallback-Dimensions:", anyArr[1], anyArr[2]);
+                    return [parseInt(anyArr[1], 10), parseInt(anyArr[2], 10)];
+                }
+            }
+            return undefined;
+        }
+
+        window.on_llm_output = (txt) => {
+            llm_out.textContent = txt;
+        };
+        window.on_llm_done = () => { /* no-op */ };
+
+        window.on_json_output = (jsonText) => {
+            // Nutze das letzte gültige Diffusions-JSON als Basis!
+            let base = {};
+            try { 
+                base = JSON.parse(lastValidDiffusionSettings ?? defaultJSON); 
+            } catch { 
+                base = JSON.parse(defaultJSON); 
+            }
+
+            // Prompt-Felder (aus Streaming-JSON)
+            const positive = extractField(jsonText, "positive prompt");
+            const negative = extractField(jsonText, "negative prompt");
+            const dimensions = extractArrayField(jsonText, "dimensions");
+
+            if (positive !== undefined) base["positive prompt"] = positive;
+            if (negative !== undefined) base["negative prompt"] = negative;
+            if (dimensions !== undefined) base["dimensions"] = dimensions;
+
+            json_out.value = sanitizeDiffusionJSON(JSON.stringify(base, null, 2));
+            updateTokenCounter();
+        };
+
+        window.on_json_done = () => {
+            let current;
+            try {
+                current = JSON.parse(sanitizeDiffusionJSON(json_out.value));
+            } catch {
+                // Wiederherstellen:
+                if (lastValidDiffusionSettings) {
+                    // >>> Userwerte aus dem letzten validen Zustand nehmen <<<
+                    json_out.value = lastValidDiffusionSettings;
+                    updateTokenCounter();
+                    alert("Ungültiges JSON erkannt! Die letzten gültigen Einstellungen wurden wiederhergestellt.");
+                } else {
+                    json_out.value = defaultJSON;
+                    updateTokenCounter();
+                    alert("Fehler und keine alten gültigen Einstellungen vorhanden. Defaults wurden geladen.");
+                }
+                return;
+            }
+
+            // Jetzt: Felder nur ergänzen, falls sie wirklich fehlen:
+            for (const [key, defVal] of Object.entries(DEFAULT_SETTINGS)) {
+                if (
+                    current[key] === undefined ||
+                    current[key] === null ||
+                    (typeof defVal === "number" && isNaN(current[key]))
+                ) {
+                    current[key] = defVal;
+                }
+            }
+            if (
+                !Array.isArray(current.dimensions) ||
+                current.dimensions.length !== 2 ||
+                current.dimensions.some(x => typeof x !== "number" || !Number.isFinite(x))
+            ) {
+                current.dimensions = [768, 768];
+            }
+            json_out.value = sanitizeDiffusionJSON(JSON.stringify(current, null, 2));
+            updateTokenCounter();
+            lastValidDiffusionSettings = json_out.value;
+            spinner.classList.remove("active");
+            promptBtn.disabled = false;
+            moreBtn.style.display = "inline-block";
+            moreBtn.disabled = false;
+        };
+
+        window.on_generation_aborted = () => {
+          // stop the forever loop for good:
+          generateForeverAbort = true;
+          generateForeverActive = false;
+          endGenerateUI();
+          // also remove any stale placeholders:
+          // window.pywebview.api.remove_placeholders(/* pass last batch_id if you store it */);
+        };
+
+
+        // --- Backend-Callbacks (relevanter Teil) ---
+        window.on_image_updated = function(filepath, dataUri) {
+            window.pywebview.api.get_initial_images().then((items) => {
+                galleryFiles = items;
+                renderImagesGallery();
+                updateTabsVisibility();
+                if (galleryFiles.length > 0) moreBtn.style.display = "inline-block";
+            });
+        };
+
+
+        window.on_new_image = (filepath/*, dataUri*/) => {
+            galleryFiles.unshift({ filepath });
+            currentPageImages = 1;
+            renderImagesGallery();
+            updateTabsVisibility(); // ← HIER hinzufügen!
+            moreBtn.style.display = "inline-block";
+        };
+
+
+        window.on_image_gen_done = () => {
+            if(!generateForeverActive){
+                spinner.classList.remove("active");
+                promptBtn.disabled = false;
+                moreBtn.style.display = "inline-block";
+                moreBtn.disabled = false;
+            }
+        };
+
+        window.on_error = (msg) => {
+            alert("Error: " + msg);
+            endGenerateUI();
+            spinner.classList.remove("active");
+            promptBtn.disabled = false;
+            moreBtn.disabled = false;
+        };
+
+
+        // --- 3D-Update nach Generierung ---
+        window.on_3d_generated = (glbPath) => {
+            // 3D-Liste neu laden & auf Seite 1 zurückspringen
+            window.pywebview.api.get_3d_models().then(list => {
+                modelGallery = list;
+                currentPage3D = 1;
+                renderModelsGallery();
+                updateTabsVisibility();
+            });
+            alert("3D model generated:\n" + glbPath);
+        };
+
+
+        // --- KACHELN: Backend-gesteuert ---
+        window.show_placeholders = function(count, batch_id) {
+            activePlaceholders = { batchId: batch_id, count: count };
+            isBatchActive = true;
+            // Placeholder-Tiles werden NUR noch beim Rendern erzeugt, nicht sofort ins DOM!
+            if (currentPageImages === 1) renderImagesGallery();
+            updateTabsVisibility();
+            setTimeout(() => {
+                if (window.pywebview && window.pywebview.api && window.pywebview.api.placeholders_ready) {
+                    window.pywebview.api.placeholders_ready(batch_id);
+                }
+            }, 0);
+        };
+
+        window.replace_placeholder = function(idx, filepath, batch_id) {
+            // Nur State ändern, NICHT mehr direkt im DOM
+            if (activePlaceholders && activePlaceholders.batchId === batch_id) {
+                activePlaceholders.count--;
+                if (activePlaceholders.count <= 0) activePlaceholders = null;
+            }
+            galleryFiles.unshift({ filepath });
+            // Nur Seite 1 neu rendern:
+            if (currentPageImages === 1) renderImagesGallery();
+            updateTabsVisibility();
+        };
+
+        window.remove_placeholders = function(batch_id) {
+            isBatchActive = false;
+            if (activePlaceholders && activePlaceholders.batchId === batch_id) {
+                activePlaceholders = null;
+            }
+            renderImagesGallery();
+            updateTabsVisibility();
+        };
+
+
+
+        // ------------- Gallery Helpers & Context Menu -------------
+
+        function addImageToGallery(filepath) {
+          const img = document.createElement("img");
+          img.src     = filepath;      // direkt die URL
+          img.loading = "lazy";        // lazy-load
+          img.decoding= "async";       // asynchron dekodieren
+          img.dataset.filepath = filepath;
+
+          img.addEventListener("click", () => {
+            const idx = galleryFiles.findIndex(o => o.filepath === filepath);
+            if (idx >= 0) openLightbox(idx);
+          });
+          img.addEventListener("contextmenu", e => {
+            e.preventDefault();
+            e.stopPropagation();
+            ctxTargetFile = filepath;
+            showContextMenu(e.pageX, e.pageY);
+          });
+
+          images.appendChild(img);
+        }
+
+
+        // Patch alle Context-Menu-Show-Events:
+        function showContextMenu(x, y) {
+            // Kontext: 2D/3D bestimmen
+            is3DContext = modelsDiv.style.display === "grid" || lightbox3DOverlay.style.display === "flex";
+            // Toggle Menü-Einträge:
+            ctxEditExt.style.display = "block";
+            ctxUseData.style.display = "block";
+            ctxGen3D.style.display = is3DContext ? "none" : "block";
+            ctxGen3DEqui.style.display = is3DContext ? "none" : "block";
+            // "Generate Forever"-Button ausblenden:
+            let foreverBtn = ctxMenu.querySelector("#ctxGenerateForever");
+            if (foreverBtn) foreverBtn.style.display = "none";
+            // Show:
+            ctxMenu.style.top = y + "px";
+            ctxMenu.style.left = x + "px";
+            ctxMenu.style.display = "block";
+        }
+
+        window.addEventListener("click", () => {
+            ctxMenu.style.display = "none";
+        });
+
+        // “Edit Externally”
+        ctxEditExt.addEventListener("click", () => {
+            if (!ctxTargetFile) return;
+            window.pywebview.api.edit_external(ctxTargetFile);
+        });
+
+        // “Use Generation Data”
+        ctxUseData.addEventListener("click", async () => {
+            if (!ctxTargetFile) return;
+            try {
+                const response = await window.pywebview.api.get_image_json(ctxTargetFile);
+                let parsed;
+                try {
+                    parsed = JSON.parse(sanitizeDiffusionJSON(response));   // <- SANITIZE!);
+                } catch {
+                    json_out.value = sanitizeDiffusionJSON(response);   // <- SANITIZE!
+                    updateTokenCounter();
+                    return;
+                }
+                if (parsed.error) {
+                    alert("Error reading metadata: " + parsed.error);
+                } else {
+                    // List of allowed keys for diffusion
+                    const allowed = [
+                        "positive prompt",
+                        "negative prompt",
+                        "dimensions",
+                        "checkpoint",
+                        "vae",
+                        "sampler",
+                        "steps",
+                        "cfg_scale",
+                        "batch_count"
+                    ];
+                    // Only keep allowed keys
+                    const filtered = {};
+                    for (const key of allowed) {
+                        if (parsed.hasOwnProperty(key)) filtered[key] = parsed[key];
+                    }
+                    json_out.value = sanitizeDiffusionJSON(JSON.stringify(filtered, null, 2));
+                    updateTokenCounter();
+                }
+            } catch (e) {
+                alert("Failed to retrieve generation data: " + e);
+            }
+        });
+
+        // “Generate 3D Model”
+        ctxGen3D.addEventListener("click", () => {
+            if (!ctxTargetFile) return;
+            window.pywebview.api.generate_3d_model(ctxTargetFile);
+        });
+
+        // “Generate 3D Model”
+        ctxGen3DEqui.addEventListener("click", () => {
+            if (!ctxTargetFile) return;
+            window.pywebview.api.generate_3d_and_hdri(ctxTargetFile);
+        });
+
+        // ------------- 2D Lightbox Implementation -------------
+
+        function openLightbox(idx) {
+            currentIndex = idx;
+            const item = galleryFiles[idx];
+            if (!item) return;
+            lightboxImg.src = item.filepath;
+            lightboxOverlay.style.display = "flex";
+        }
+        function closeLightbox() {
+            lightboxOverlay.style.display = "none";
+            currentIndex = -1;
+        }
+
+        function showPrev() {
+          if (galleryFiles.length === 0) return;
+          currentIndex = (currentIndex - 1 + galleryFiles.length) % galleryFiles.length;
+          lightboxImg.src = galleryFiles[currentIndex].filepath;
+        }
+
+        function showNext() {
+          if (galleryFiles.length === 0) return;
+          currentIndex = (currentIndex + 1) % galleryFiles.length;
+          lightboxImg.src = galleryFiles[currentIndex].filepath;
+        }
+
+        lightboxClose.addEventListener("mousedown", closeLightbox);
+        lightboxPrev.addEventListener("mousedown", (e) => { e.stopPropagation(); showPrev(); });
+        lightboxNext.addEventListener("mousedown", (e) => { e.stopPropagation(); showNext(); });
+        
+        lightboxOverlay.addEventListener("mousedown", (e) => {
+            const w = window.innerWidth;
+            const x = e.clientX;
+            // Pfeilbereiche (links/rechts): Navigation, Mitte: nix!
+            if (x < 0.15 * w) {
+                showPrev();
+            } else if (x > 0.85 * w) {
+                showNext();
+            }
+            // Kein else: Nicht schließen!
+        });
+
+        document.addEventListener("keydown", (e) => {
+            if (lightboxOverlay.style.display === "flex") {
+                if (e.key === "Escape") closeLightbox();
+                else if (e.key === "ArrowLeft") showPrev();
+                else if (e.key === "ArrowRight") showNext();
+            }
+        });
+        lightboxImg.addEventListener("contextmenu", (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            if (currentIndex >= 0) {
+                ctxTargetFile = galleryFiles[currentIndex].filepath;
+                showContextMenu(e.pageX, e.pageY);
+            }
+        });
+
+        // ------------- 3D Lightbox Implementation -------------
+
+        function open3DLightbox(idx) {
+            currentModelIndex = idx;
+            lightbox3DOverlay.style.display = "flex";
+            show3DModel(idx);
+        }
+
+        function close3DLightbox() {
+            lightbox3DOverlay.style.display = "none";
+            // Clear previous renderer
+            lightbox3DViewport.innerHTML = "";
+        }
+
+        function showPrev3D() {
+            if (!modelGallery.length) return;
+            currentModelIndex = (currentModelIndex - 1 + modelGallery.length) % modelGallery.length;
+            show3DModel(currentModelIndex);
+        }
+
+        function showNext3D() {
+            if (!modelGallery.length) return;
+            currentModelIndex = (currentModelIndex + 1) % modelGallery.length;
+            show3DModel(currentModelIndex);
+        }
+
+        lightbox3DClose.addEventListener("mousedown", close3DLightbox);
+        lightbox3DPrev.addEventListener("mousedown", (e) => { e.stopPropagation(); showPrev3D(); });
+        lightbox3DNext.addEventListener("mousedown", (e) => { e.stopPropagation(); showNext3D(); });
+        lightbox3DOverlay.addEventListener("mousedown", (e) => {
+            const w = window.innerWidth;
+            const x = e.clientX;
+            if (x < 0.15 * w) {
+                showPrev3D();
+            } else if (x > 0.85 * w) {
+                showNext3D();
+            }
+            // Kein else: Nicht schließen!
+        });
+
+        document.addEventListener("keydown", (e) => {
+            if (lightbox3DOverlay.style.display === "flex") {
+                if (e.key === "Escape") close3DLightbox();
+                else if (e.key === "ArrowLeft") showPrev3D();
+                else if (e.key === "ArrowRight") showNext3D();
+            }
+        });
+        
+async function show3DModel(idx) {
+  lightbox3DViewport.innerHTML = "";
+
+  const entry = modelGallery[idx];
+  if (!entry) return;
+  const url = entry.glb;
+  const imgPath = entry.img;
+
+  const scene = new THREE.Scene();
+  const camera = new THREE.PerspectiveCamera(45, 1, 0.1, 1000);
+
+  const renderer = new THREE.WebGLRenderer({ antialias: true });
+  renderer.setSize(600, 600);
+  renderer.outputEncoding = THREE.sRGBEncoding;
+  renderer.toneMapping = THREE.ACESFilmicToneMapping;
+  renderer.toneMappingExposure = 1.0;
+  renderer.physicallyCorrectLights = true;
+  lightbox3DViewport.appendChild(renderer.domElement);
+
+  // --- 1. Load HDRI path from JSON ---
+  let envMap = null;
+  let hdriUrl = null;
+  try {
+    const hdriJson = await window.pywebview.api.get_image_json(imgPath);
+    const meta = JSON.parse(sanitizeDiffusionJSON(hdriJson));
+    if (meta && meta.hdri_seamless) {
+      const baseDir = imgPath.substring(0, imgPath.lastIndexOf("/") + 1);
+      hdriUrl = baseDir + meta.hdri_seamless;
+    }
+  } catch (e) {
+    console.warn("Failed to fetch or parse HDRI JSON:", e);
+  }
+
+  // --- 2. Environment map for lighting (PMREM, not visible directly) ---
+  if (hdriUrl) {
+    const loader = new THREE.TextureLoader();
+    await new Promise((resolve) => {
+      loader.load(
+        hdriUrl,
+        (texture) => {
+          texture.mapping = THREE.EquirectangularReflectionMapping;
+          texture.colorSpace = THREE.SRGBColorSpace;
+          const pmrem = new THREE.PMREMGenerator(renderer);
+          pmrem.compileEquirectangularShader();
+          envMap = pmrem.fromEquirectangular(texture).texture;
+          scene.environment = envMap;
+          pmrem.dispose();
+          resolve();
+        },
+        undefined,
+        (err) => { console.warn("Failed to load HDRI:", err); resolve(); }
+      );
+    });
+  }
+
+  // --- 3. Background sphere: vivid, blurred, high-contrast version of HDRI ---
+  if (hdriUrl) {
+    await new Promise((resolve) => {
+      const img = new window.Image();
+      img.crossOrigin = ""; // '', or 'anonymous'
+      img.onload = function () {
+        const canvas = document.createElement('canvas');
+        canvas.width = img.width;
+        canvas.height = img.height;
+        const ctx = canvas.getContext('2d');
+        ctx.drawImage(img, 0, 0);
+
+        // ---- Pixel loop: boost contrast & saturation ----
+        const imgData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+        const data = imgData.data;
+        const contrast = 2.2;  // Try 1.6–2.2 for natural/vivid
+        const brightness = -8; // Negative to darken slightly
+        const saturation = 1.5; // >1 is more vibrant
+
+        const factor = (259 * (contrast + 255)) / (255 * (259 - contrast));
+
+        for (let i = 0; i < data.length; i += 4) {
+          // Contrast
+          let r = factor * (data[i]   - 128) + 128;
+          let g = factor * (data[i+1] - 128) + 128;
+          let b = factor * (data[i+2] - 128) + 128;
+
+          // Brightness
+          r += brightness;
+          g += brightness;
+          b += brightness;
+
+          // Saturation (HSL method)
+          let _r = r / 255, _g = g / 255, _b = b / 255;
+          let max = Math.max(_r, _g, _b), min = Math.min(_r, _g, _b);
+          let l = (max + min) / 2, s = 0, h = 0;
+          if (max !== min) {
+            let d = max - min;
+            s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+            switch(max) {
+              case _r: h = (_g - _b) / d + (_g < _b ? 6 : 0); break;
+              case _g: h = (_b - _r) / d + 2; break;
+              case _b: h = (_r - _g) / d + 4; break;
+            }
+            h /= 6;
+          }
+          s = Math.min(1, s * saturation);
+
+          // HSL back to RGB
+          function hue2rgb(p, q, t) {
+            if (t < 0) t += 1;
+            if (t > 1) t -= 1;
+            if (t < 1/6) return p + (q - p) * 6 * t;
+            if (t < 1/2) return q;
+            if (t < 2/3) return p + (q - p) * (2/3 - t) * 6;
+            return p;
+          }
+          let r2, g2, b2;
+          if (s === 0) {
+            r2 = g2 = b2 = l;
+          } else {
+            let q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+            let p = 2 * l - q;
+            r2 = hue2rgb(p, q, h + 1/3);
+            g2 = hue2rgb(p, q, h);
+            b2 = hue2rgb(p, q, h - 1/3);
+          }
+          data[i]   = Math.min(255, Math.max(0, r2 * 255));
+          data[i+1] = Math.min(255, Math.max(0, g2 * 255));
+          data[i+2] = Math.min(255, Math.max(0, b2 * 255));
+        }
+        ctx.putImageData(imgData, 0, 0);
+
+        // Convert to Three.js texture
+        const vividTexture = new THREE.CanvasTexture(canvas);
+        vividTexture.mapping = THREE.EquirectangularReflectionMapping;
+        vividTexture.colorSpace = THREE.SRGBColorSpace;
+        vividTexture.minFilter = THREE.LinearFilter;
+        vividTexture.magFilter = THREE.LinearFilter;
+        vividTexture.generateMipmaps = false;
+        vividTexture.needsUpdate = true;
+
+        // Use MeshBasicMaterial, ignore lighting/tone mapping
+        const geometry = new THREE.SphereGeometry(50, 64, 32);
+        const material = new THREE.MeshBasicMaterial({
+          map: vividTexture,
+          side: THREE.BackSide,
+          toneMapped: false,
+        });
+        const sphere = new THREE.Mesh(geometry, material);
+        sphere.renderOrder = -1;
+        scene.add(sphere);
+
+        resolve();
+      };
+      img.onerror = function (e) { resolve(); };
+      img.src = hdriUrl;
+    });
+  }
+
+  // --- 4. Load the GLTF model ---
+  const dracoLoader = new THREE.DRACOLoader();
+  dracoLoader.setDecoderPath('https://www.gstatic.com/draco/v1/decoders/');
+  const gltfLoader = new THREE.GLTFLoader();
+  gltfLoader.setDRACOLoader(dracoLoader);
+
+  gltfLoader.load(
+    url,
+    (gltf) => {
+      const obj = gltf.scene;
+      scene.add(obj);
+
+      obj.updateWorldMatrix(true, true);
+      const box = new THREE.Box3().setFromObject(obj);
+      const center = box.getCenter(new THREE.Vector3());
+      const size = box.getSize(new THREE.Vector3());
+      obj.position.sub(center);
+
+      // Camera/orbit/zoom logic
+      const maxDim = Math.max(size.x, size.y, size.z);
+      const fov = camera.fov * (Math.PI / 180);
+      const minZoom = Math.abs(maxDim / 2 / Math.tan(fov / 2)) * 1;
+      const maxZoom = minZoom * 3.5;
+      let zoomRadius = minZoom * 1.5;
+      let theta = -Math.PI / 2;
+
+      // Set initial camera position
+      camera.position.set(-zoomRadius, 0, 0);
+
+      camera.lookAt(0, 0, 0);
+
+      // Fallback lighting if no envMap
+      if (!envMap) {
+        const keyLight = new THREE.DirectionalLight(0xffffff, 4.5);
+        keyLight.position.set(3, 5, 6);
+        scene.add(keyLight);
+        const fillLight = new THREE.DirectionalLight(0xffeebb, 2.7);
+        fillLight.position.set(-4, 2, 3);
+        scene.add(fillLight);
+        const backLight = new THREE.DirectionalLight(0x88bbff, 3.2);
+        backLight.position.set(0, 6, -6);
+        scene.add(backLight);
+        scene.add(new THREE.AmbientLight(0xffffff, 3.0));
+      }
+
+      // OrbitControls + Auto-Rotate logic
+      const controls = new THREE.OrbitControls(camera, renderer.domElement);
+      controls.target.set(0, 0, 0);
+      controls.enableDamping = true;
+      controls.dampingFactor = 0.12;
+      controls.enablePan = false;
+      controls.minDistance = minZoom;
+      controls.maxDistance = maxZoom;
+      controls.autoRotate = false;
+
+      let autoRotate = true;
+      let lastInteraction = Date.now();
+      const RESUME_DELAY = 3000;
+
+      // Clamp function for zoom
+      function clamp(x, min, max) { return Math.max(min, Math.min(max, x)); }
+
+      controls.addEventListener('start', () => {
+        autoRotate = false;
+        lastInteraction = Date.now();
+      });
+
+      controls.addEventListener('change', () => {
+        // Update zoomRadius and theta based on current camera position
+        const pos = camera.position.clone().sub(controls.target);
+        zoomRadius = clamp(pos.length(), minZoom, maxZoom);
+        theta = Math.atan2(pos.x, pos.z);
+      });
+
+      function maybeResume() {
+        if (!autoRotate && Date.now() - lastInteraction > RESUME_DELAY) {
+          autoRotate = true;
+        }
+      }
+
+let phi = Math.PI / 2; // vertical angle, user-set or default 
+
+// Clamp for zoom
+function clamp(x, min, max) { return Math.max(min, Math.min(max, x)); }
+
+controls.addEventListener('change', () => {
+  const pos = camera.position.clone().sub(controls.target);
+  zoomRadius = clamp(pos.length(), minZoom, maxZoom);
+  theta = Math.atan2(pos.x, pos.z);
+  phi = controls.getPolarAngle();
+});
+
+function animate() {
+  requestAnimationFrame(animate);
+  maybeResume();
+
+  if (autoRotate) {
+    theta += 0.008;
+    // Use phi for vertical angle
+    camera.position.x = zoomRadius * Math.sin(phi) * Math.sin(theta);
+    camera.position.y = zoomRadius * Math.cos(phi);
+    camera.position.z = zoomRadius * Math.sin(phi) * Math.cos(theta);
+    camera.lookAt(0, 0, 0);
+    // No controls.update() here!
+  } else {
+    controls.update();
+  }
+
+  renderer.render(scene, camera);
+}
+      animate();
+    },
+    undefined,
+    (err) => {
+      lightbox3DViewport.innerHTML =
+        `<div style="color:white; text-align:center; padding:20px;">
+          Error loading model:<br>${err.message || err}
+        </div>`;
+    }
+  );
+}
+    </script>
+</body>
+</html>