fix: ZeroGPU spaces decorator + force rebuild

.gitattributes

@@ -1,35 +1,4 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+* text=auto eol=lf
+*.py text eol=lf
+*.txt text eol=lf
+*.md text eol=lf

app.py

@@ -1,24 +1,33 @@
+import sys
+print("=== TextureForge: Python started ===", flush=True)
+print(f"Python version: {sys.version}", flush=True)
+
 import gradio as gr
+print(f"Gradio version: {gr.__version__}", flush=True)
+
 import numpy as np
 from PIL import Image
 import cv2
 import torch
-from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler
 import zipfile
 import io
 import tempfile
-import spaces  # Required for HF ZeroGPU
 
-# ─── Model Loading ────────────────────────────────────────────────────────────
-# On ZeroGPU, CUDA is allocated per-request via @spaces.GPU
-# Do NOT call torch.cuda.is_available() or .to("cuda") at module import time
+print("Core imports OK", flush=True)
+
+import spaces
+print("spaces import OK", flush=True)
+
+from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler
+print("diffusers import OK", flush=True)
 
+# ─── Model (lazy, loaded only inside @spaces.GPU context) ────────────────────
 pipe = None
 
 def load_model():
     global pipe
     if pipe is None:
-        print("Loading Stable Diffusion model...")
+        print("Loading SD model...", flush=True)
         pipe = StableDiffusionPipeline.from_pretrained(
             "runwayml/stable-diffusion-v1-5",
             torch_dtype=torch.float16,
@@ -27,67 +36,63 @@ def load_model():
         pipe.scheduler = DPMSolverMultistepScheduler.from_config(pipe.scheduler.config)
         pipe = pipe.to("cuda")
         pipe.enable_attention_slicing()
-        print("Model loaded.")
+        print("SD model loaded.", flush=True)
     return pipe
 
-# ─── PBR Map Generation (CPU — no GPU needed) ─────────────────────────────────
+# ─── PBR Map Generation (pure CPU / OpenCV) ──────────────────────────────────
 
 def make_seamless(img: Image.Image) -> Image.Image:
     arr = np.array(img)
     h, w = arr.shape[:2]
     result = arr.copy()
-    blend_size = min(h, w) // 4
-    for x in range(blend_size):
-        alpha = x / blend_size
-        result[:, x] = (arr[:, x] * alpha + arr[:, w - blend_size + x] * (1 - alpha)).astype(np.uint8)
-    for y in range(blend_size):
-        alpha = y / blend_size
-        result[y, :] = (result[y, :] * alpha + result[h - blend_size + y, :] * (1 - alpha)).astype(np.uint8)
+    blend = min(h, w) // 4
+    for x in range(blend):
+        a = x / blend
+        result[:, x] = (arr[:, x] * a + arr[:, w - blend + x] * (1 - a)).astype(np.uint8)
+    for y in range(blend):
+        a = y / blend
+        result[y, :] = (result[y, :] * a + result[h - blend + y, :] * (1 - a)).astype(np.uint8)
     return Image.fromarray(result)
 
-def generate_normal_map(albedo: Image.Image) -> Image.Image:
-    gray = cv2.GaussianBlur(np.array(albedo.convert("L")).astype(np.float32) / 255.0, (3, 3), 0)
-    strength = 4.0
-    dx = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3) * strength
-    dy = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3) * strength
+def gen_normal(img: Image.Image) -> Image.Image:
+    gray = cv2.GaussianBlur(np.array(img.convert("L")).astype(np.float32) / 255.0, (3, 3), 0)
+    dx = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3) * 4.0
+    dy = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3) * 4.0
     dz = np.ones_like(dx)
-    length = np.sqrt(dx**2 + dy**2 + dz**2)
-    normal = np.stack([
-        ((-dx / length + 1) / 2 * 255).astype(np.uint8),
-        ((-dy / length + 1) / 2 * 255).astype(np.uint8),
-        ((dz / length) * 255).astype(np.uint8),
-    ], axis=-1)
-    return Image.fromarray(normal, mode="RGB")
-
-def generate_roughness_map(albedo: Image.Image) -> Image.Image:
-    gray = np.array(albedo.convert("L")).astype(np.float32) / 255.0
-    roughness = (np.abs(gray - cv2.GaussianBlur(gray, (5, 5), 0)) * 8).clip(0.2, 1.0)
-    return Image.fromarray((roughness * 255).astype(np.uint8), mode="L")
-
-def generate_metallic_map(albedo: Image.Image) -> Image.Image:
-    rgb = np.array(albedo).astype(np.float32) / 255.0
-    hsv = cv2.cvtColor(rgb, cv2.COLOR_RGB2HSV)
-    metallic = (hsv[:, :, 2] * (1.0 - hsv[:, :, 1]) * 0.6).clip(0, 1)
-    return Image.fromarray((metallic * 255).astype(np.uint8), mode="L")
-
-def generate_ao_map(albedo: Image.Image) -> Image.Image:
-    gray = np.array(albedo.convert("L")).astype(np.float32) / 255.0
-    ao = (gray / (cv2.GaussianBlur(gray, (31, 31), 0) + 0.01)).clip(0, 1)
+    L = np.sqrt(dx**2 + dy**2 + dz**2)
+    return Image.fromarray(np.stack([
+        ((-dx/L + 1)/2*255).astype(np.uint8),
+        ((-dy/L + 1)/2*255).astype(np.uint8),
+        ((dz/L)*255).astype(np.uint8),
+    ], axis=-1), mode="RGB")
+
+def gen_roughness(img: Image.Image) -> Image.Image:
+    g = np.array(img.convert("L")).astype(np.float32) / 255.0
+    r = (np.abs(g - cv2.GaussianBlur(g, (5,5), 0)) * 8).clip(0.2, 1.0)
+    return Image.fromarray((r * 255).astype(np.uint8), mode="L")
+
+def gen_metallic(img: Image.Image) -> Image.Image:
+    hsv = cv2.cvtColor(np.array(img).astype(np.float32) / 255.0, cv2.COLOR_RGB2HSV)
+    m = (hsv[:,:,2] * (1.0 - hsv[:,:,1]) * 0.6).clip(0, 1)
+    return Image.fromarray((m * 255).astype(np.uint8), mode="L")
+
+def gen_ao(img: Image.Image) -> Image.Image:
+    g = np.array(img.convert("L")).astype(np.float32) / 255.0
+    ao = (g / (cv2.GaussianBlur(g, (31,31), 0) + 0.01)).clip(0, 1)
     ao = cv2.normalize(ao, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
     return Image.fromarray((ao.astype(np.float32) * 0.85 + 20).clip(0, 255).astype(np.uint8), mode="L")
 
-def generate_height_map(albedo: Image.Image) -> Image.Image:
-    gray = cv2.GaussianBlur(np.array(albedo.convert("L")), (3, 3), 0)
-    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
-    return Image.fromarray(clahe.apply(gray), mode="L")
+def gen_height(img: Image.Image) -> Image.Image:
+    g = cv2.GaussianBlur(np.array(img.convert("L")), (3,3), 0)
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
+    return Image.fromarray(clahe.apply(g), mode="L")
 
-def build_pbr_maps(albedo: Image.Image, seamless: bool):
+def all_maps(albedo: Image.Image, seamless: bool):
     if seamless:
         albedo = make_seamless(albedo)
-    return albedo, generate_normal_map(albedo), generate_roughness_map(albedo), \
-           generate_metallic_map(albedo), generate_ao_map(albedo), generate_height_map(albedo)
+    return albedo, gen_normal(albedo), gen_roughness(albedo), gen_metallic(albedo), gen_ao(albedo), gen_height(albedo)
 
-def pack_zip(maps: dict) -> str:
+def to_zip(maps: dict) -> str:
     tmp = tempfile.NamedTemporaryFile(suffix=".zip", delete=False)
     with zipfile.ZipFile(tmp.name, "w", zipfile.ZIP_DEFLATED) as zf:
         for name, img in maps.items():
@@ -96,145 +101,144 @@ def pack_zip(maps: dict) -> str:
             zf.writestr(f"{name}.png", buf.getvalue())
     return tmp.name
 
-# ─── Generation Pipelines ─────────────────────────────────────────────────────
+# ─── Gradio Functions ─────────────────────────────────────────────────────────
+
+STYLE_MAP = {
+    "None": "",
+    "Stone / Rock": "stone texture, rocky surface, seamless",
+    "Wood": "wood grain texture, natural planks, seamless",
+    "Metal": "brushed metal surface, industrial, seamless",
+    "Fabric / Cloth": "woven fabric texture, textile, seamless",
+    "Concrete": "concrete cement surface, seamless",
+    "Brick": "brick wall, masonry, seamless",
+    "Ground / Dirt": "dirt soil ground, natural, seamless",
+    "Sci-Fi / Tech": "sci-fi futuristic panel texture, seamless",
+}
 
 @spaces.GPU(duration=120)
-def generate_from_prompt(prompt, negative_prompt, style_preset, resolution, steps, guidance, seamless, seed):
-    style_map = {
-        "None": "", "Stone / Rock": "stone texture, rocky surface, seamless",
-        "Wood": "wood grain texture, natural planks, seamless",
-        "Metal": "brushed metal surface, industrial, seamless",
-        "Fabric / Cloth": "woven fabric texture, textile, seamless",
-        "Concrete": "concrete cement surface, urban, seamless",
-        "Brick": "brick wall texture, masonry, seamless",
-        "Ground / Dirt": "dirt soil ground texture, natural, seamless",
-        "Sci-Fi / Tech": "sci-fi futuristic panel texture, seamless",
-    }
-    full_prompt = f"{prompt}, {style_map.get(style_preset,'')}, seamless texture, top-down, PBR material, flat lighting, photorealistic".strip(", ")
+def from_prompt(prompt, negative_prompt, style_preset, resolution, steps, guidance, seamless, seed):
+    full_prompt = f"{prompt}, {STYLE_MAP.get(style_preset,'')}, seamless texture, top-down, PBR, flat lighting, photorealistic".strip(", ")
     neg = f"{negative_prompt}, shadows, 3d render, person, face, vignette"
-    generator = torch.Generator(device="cuda").manual_seed(int(seed)) if seed >= 0 else None
-
-    model = load_model()
-    albedo = model(
+    gen = torch.Generator(device="cuda").manual_seed(int(seed)) if seed >= 0 else None
+    albedo = load_model()(
         prompt=full_prompt, negative_prompt=neg,
         width=int(resolution), height=int(resolution),
-        num_inference_steps=int(steps), guidance_scale=guidance,
-        generator=generator,
+        num_inference_steps=int(steps), guidance_scale=guidance, generator=gen,
     ).images[0]
+    a, n, r, m, ao, h = all_maps(albedo, seamless)
+    return a, n, r, m, ao, h, to_zip({"T_Albedo":a,"T_Normal":n,"T_Roughness":r,"T_Metallic":m,"T_AO":ao,"T_Height":h})
 
-    a, n, r, m, ao, h = build_pbr_maps(albedo, seamless)
-    zip_path = pack_zip({"T_Albedo": a, "T_Normal": n, "T_Roughness": r, "T_Metallic": m, "T_AO": ao, "T_Height": h})
-    return a, n, r, m, ao, h, zip_path
-
-def generate_from_image(uploaded_img, seamless):
-    if uploaded_img is None:
-        raise gr.Error("Please upload an image first.")
-    a, n, r, m, ao, h = build_pbr_maps(uploaded_img, seamless)
-    zip_path = pack_zip({"T_Albedo": a, "T_Normal": n, "T_Roughness": r, "T_Metallic": m, "T_AO": ao, "T_Height": h})
-    return a, n, r, m, ao, h, zip_path
+def from_image(img, seamless):
+    if img is None:
+        raise gr.Error("Please upload an image.")
+    a, n, r, m, ao, h = all_maps(img, seamless)
+    return a, n, r, m, ao, h, to_zip({"T_Albedo":a,"T_Normal":n,"T_Roughness":r,"T_Metallic":m,"T_AO":ao,"T_Height":h})
 
-# ─── Gradio UI ────────────────────────────────────────────────────────────────
+# ─── UI ───────────────────────────────────────────────────────────────────────
 
-STYLE_CHOICES = ["None","Stone / Rock","Wood","Metal","Fabric / Cloth","Concrete","Brick","Ground / Dirt","Sci-Fi / Tech"]
-RES_CHOICES = [256, 512, 768, 1024]
+STYLES = list(STYLE_MAP.keys())
+RES    = [256, 512, 768, 1024]
 
 css = """
 @import url('https://fonts.googleapis.com/css2?family=Space+Mono:wght@400;700&family=Syne:wght@400;700;800&display=swap');
-:root { --bg:#0a0a0f; --surface:#12121a; --border:#2a2a3a; --accent:#7c6af7; --accent2:#f7a26a; --text:#e8e8f0; --muted:#6a6a8a; }
-body, .gradio-container { background:var(--bg) !important; font-family:'Syne',sans-serif !important; color:var(--text) !important; }
-h1,h2,h3 { font-family:'Syne',sans-serif !important; }
-code { font-family:'Space Mono',monospace !important; }
-.gr-button-primary { background:linear-gradient(135deg,var(--accent),#a56bf7) !important; border:none !important; font-family:'Syne',sans-serif !important; font-weight:700 !important; border-radius:8px !important; }
-label { color:var(--muted) !important; font-size:0.8rem !important; letter-spacing:0.08em !important; text-transform:uppercase !important; }
+:root{--bg:#0a0a0f;--surface:#12121a;--border:#2a2a3a;--accent:#7c6af7;--text:#e8e8f0;--muted:#6a6a8a}
+body,.gradio-container{background:var(--bg)!important;font-family:'Syne',sans-serif!important;color:var(--text)!important}
+h1,h2,h3{font-family:'Syne',sans-serif!important}
+code{font-family:'Space Mono',monospace!important}
+.gr-button-primary{background:linear-gradient(135deg,var(--accent),#a56bf7)!important;border:none!important;font-family:'Syne',sans-serif!important;font-weight:700!important;border-radius:8px!important}
+label{color:var(--muted)!important;font-size:.8rem!important;letter-spacing:.08em!important;text-transform:uppercase!important}
 """
 
-with gr.Blocks(css=css, theme=gr.themes.Base(), title="TextureForge — PBR Texture Generator") as demo:
-
+with gr.Blocks(css=css, theme=gr.themes.Base(), title="TextureForge") as demo:
     gr.HTML("""
-    <div style="text-align:center;padding:2rem 0 1rem;">
-        <p style="font-family:'Syne',sans-serif;font-size:0.75rem;letter-spacing:0.3em;color:#7c6af7;text-transform:uppercase;margin-bottom:0.5rem;">PBR MATERIAL SYSTEM</p>
-        <h1 style="font-family:'Syne',sans-serif;font-size:3rem;font-weight:800;margin:0;background:linear-gradient(135deg,#e8e8f0,#7c6af7);-webkit-background-clip:text;-webkit-text-fill-color:transparent;">TextureForge</h1>
-        <p style="color:#6a6a8a;font-family:'Space Mono',monospace;font-size:0.8rem;margin-top:0.5rem;">Generate full PBR map sets · Ready for Unity3D</p>
-    </div>
-    """)
+    <div style="text-align:center;padding:2rem 0 1rem">
+      <p style="font-size:.75rem;letter-spacing:.3em;color:#7c6af7;text-transform:uppercase;margin-bottom:.5rem">PBR MATERIAL SYSTEM</p>
+      <h1 style="font-size:3rem;font-weight:800;margin:0;background:linear-gradient(135deg,#e8e8f0,#7c6af7);-webkit-background-clip:text;-webkit-text-fill-color:transparent">TextureForge</h1>
+      <p style="color:#6a6a8a;font-family:'Space Mono',monospace;font-size:.8rem;margin-top:.5rem">Generate full PBR map sets · Ready for Unity3D</p>
+    </div>""")
 
     with gr.Tabs():
+        # Tab 1
         with gr.Tab("Text to Texture"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    prompt_in    = gr.Textbox(label="Texture Description", placeholder="weathered oak floorboards with visible grain and knots...", lines=3)
-                    neg_in       = gr.Textbox(label="Negative Prompt", lines=2, value="blurry, low quality, watermark, text, 3d render")
-                    style_in     = gr.Dropdown(label="Style Preset", choices=STYLE_CHOICES, value="None")
+                    t_prompt  = gr.Textbox(label="Texture Description", placeholder="weathered oak floorboards with knots...", lines=3)
+                    t_neg     = gr.Textbox(label="Negative Prompt", value="blurry, low quality, watermark, 3d render", lines=2)
+                    t_style   = gr.Dropdown(label="Style Preset", choices=STYLES, value="None")
                     with gr.Row():
-                        res_in   = gr.Dropdown(label="Resolution", choices=RES_CHOICES, value=512)
-                        steps_in = gr.Slider(label="Steps", minimum=15, maximum=50, step=1, value=25)
+                        t_res   = gr.Dropdown(label="Resolution", choices=RES, value=512)
+                        t_steps = gr.Slider(label="Steps", minimum=15, maximum=50, step=1, value=25)
                     with gr.Row():
-                        guidance_in = gr.Slider(label="Guidance Scale", minimum=3.0, maximum=15.0, step=0.5, value=7.5)
-                        seed_in     = gr.Number(label="Seed (-1 = random)", value=-1)
-                    seamless_in = gr.Checkbox(label="Make Seamless / Tileable", value=True)
-                    gen_btn     = gr.Button("Generate PBR Maps", variant="primary", size="lg")
+                        t_guid  = gr.Slider(label="Guidance Scale", minimum=3.0, maximum=15.0, step=0.5, value=7.5)
+                        t_seed  = gr.Number(label="Seed (-1=random)", value=-1)
+                    t_seam  = gr.Checkbox(label="Make Seamless / Tileable", value=True)
+                    t_btn   = gr.Button("Generate PBR Maps", variant="primary", size="lg")
                 with gr.Column(scale=2):
                     with gr.Row():
-                        out_albedo    = gr.Image(label="Albedo (T_Albedo)", type="pil")
-                        out_normal    = gr.Image(label="Normal (T_Normal)", type="pil")
-                        out_roughness = gr.Image(label="Roughness (T_Roughness)", type="pil")
+                        o_alb = gr.Image(label="Albedo · T_Albedo", type="pil")
+                        o_nrm = gr.Image(label="Normal · T_Normal", type="pil")
+                        o_rgh = gr.Image(label="Roughness · T_Roughness", type="pil")
                     with gr.Row():
-                        out_metallic  = gr.Image(label="Metallic (T_Metallic)", type="pil")
-                        out_ao        = gr.Image(label="AO (T_AO)", type="pil")
-                        out_height    = gr.Image(label="Height (T_Height)", type="pil")
-                    dl_zip = gr.File(label="Download All Maps (ZIP — Unity-ready)", file_types=[".zip"])
-            gen_btn.click(fn=generate_from_prompt,
-                inputs=[prompt_in,neg_in,style_in,res_in,steps_in,guidance_in,seamless_in,seed_in],
-                outputs=[out_albedo,out_normal,out_roughness,out_metallic,out_ao,out_height,dl_zip])
-
+                        o_met = gr.Image(label="Metallic · T_Metallic", type="pil")
+                        o_ao  = gr.Image(label="AO · T_AO", type="pil")
+                        o_hgt = gr.Image(label="Height · T_Height", type="pil")
+                    o_zip = gr.File(label="Download All Maps (ZIP)", file_types=[".zip"])
+            t_btn.click(fn=from_prompt,
+                inputs=[t_prompt,t_neg,t_style,t_res,t_steps,t_guid,t_seam,t_seed],
+                outputs=[o_alb,o_nrm,o_rgh,o_met,o_ao,o_hgt,o_zip])
+
+        # Tab 2
         with gr.Tab("Image to PBR Maps"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    img_in       = gr.Image(label="Upload Albedo / Base Texture", type="pil")
-                    seamless_img = gr.Checkbox(label="Make Seamless / Tileable", value=True)
-                    img_btn      = gr.Button("Extract PBR Maps", variant="primary", size="lg")
-                    gr.HTML("""<div style="margin-top:1rem;padding:1rem;background:#0d0d14;border:1px solid #2a2a3a;border-radius:8px;">
-                        <p style="color:#6a6a8a;font-family:'Space Mono',monospace;font-size:0.7rem;line-height:1.7;margin:0;">
-                        <span style="color:#f7a26a;">TIP:</span> Upload any real-world surface photo. Works best with flat, evenly-lit top-down shots.<br><br>
-                        <span style="color:#7c6af7;">Unity naming:</span> T_Albedo · T_Normal · T_Roughness · T_Metallic · T_AO · T_Height</p></div>""")
+                    i_img  = gr.Image(label="Upload Base Texture", type="pil")
+                    i_seam = gr.Checkbox(label="Make Seamless / Tileable", value=True)
+                    i_btn  = gr.Button("Extract PBR Maps", variant="primary", size="lg")
+                    gr.HTML("""<div style="margin-top:1rem;padding:1rem;background:#0d0d14;border:1px solid #2a2a3a;border-radius:8px">
+                      <p style="color:#6a6a8a;font-family:'Space Mono',monospace;font-size:.7rem;line-height:1.7;margin:0">
+                        <span style="color:#f7a26a">TIP:</span> Upload any real surface photo — works best flat-lit and top-down.<br><br>
+                        <span style="color:#7c6af7">Unity files:</span> T_Albedo · T_Normal · T_Roughness · T_Metallic · T_AO · T_Height
+                      </p></div>""")
                 with gr.Column(scale=2):
                     with gr.Row():
-                        out2_albedo    = gr.Image(label="Albedo (T_Albedo)", type="pil")
-                        out2_normal    = gr.Image(label="Normal (T_Normal)", type="pil")
-                        out2_roughness = gr.Image(label="Roughness (T_Roughness)", type="pil")
+                        i_alb = gr.Image(label="Albedo · T_Albedo", type="pil")
+                        i_nrm = gr.Image(label="Normal · T_Normal", type="pil")
+                        i_rgh = gr.Image(label="Roughness · T_Roughness", type="pil")
                     with gr.Row():
-                        out2_metallic  = gr.Image(label="Metallic (T_Metallic)", type="pil")
-                        out2_ao        = gr.Image(label="AO (T_AO)", type="pil")
-                        out2_height    = gr.Image(label="Height (T_Height)", type="pil")
-                    dl_zip2 = gr.File(label="Download All Maps (ZIP — Unity-ready)", file_types=[".zip"])
-            img_btn.click(fn=generate_from_image, inputs=[img_in,seamless_img],
-                outputs=[out2_albedo,out2_normal,out2_roughness,out2_metallic,out2_ao,out2_height,dl_zip2])
-
+                        i_met = gr.Image(label="Metallic · T_Metallic", type="pil")
+                        i_ao  = gr.Image(label="AO · T_AO", type="pil")
+                        i_hgt = gr.Image(label="Height · T_Height", type="pil")
+                    i_zip = gr.File(label="Download All Maps (ZIP)", file_types=[".zip"])
+            i_btn.click(fn=from_image, inputs=[i_img,i_seam],
+                outputs=[i_alb,i_nrm,i_rgh,i_met,i_ao,i_hgt,i_zip])
+
+        # Tab 3 — Unity Guide
         with gr.Tab("Unity3D Setup Guide"):
             gr.HTML("""
-            <div style="max-width:780px;margin:0 auto;padding:1.5rem;font-family:'Space Mono',monospace;font-size:0.78rem;line-height:1.9;color:#c0c0d8;">
-                <h2 style="font-family:'Syne',sans-serif;color:#7c6af7;font-size:1.4rem;">Using Generated Textures in Unity3D</h2>
-                <h3 style="color:#f7a26a;">1. Extract the ZIP</h3>
-                <p>Unzip into <code style="background:#1a1a2e;padding:2px 6px;border-radius:4px;">Assets/Textures/MaterialName/</code></p>
-                <h3 style="color:#f7a26a;">2. Import Settings per map</h3>
-                <table style="width:100%;border-collapse:collapse;margin-bottom:1rem;">
-                    <tr style="border-bottom:1px solid #2a2a3a;"><th style="text-align:left;padding:6px;color:#7c6af7;">File</th><th style="padding:6px;color:#7c6af7;">Texture Type</th><th style="padding:6px;color:#7c6af7;">sRGB</th></tr>
-                    <tr style="border-bottom:1px solid #1a1a2a;"><td style="padding:5px;">T_Albedo</td><td style="padding:5px;">Default</td><td style="padding:5px;">ON</td></tr>
-                    <tr style="border-bottom:1px solid #1a1a2a;"><td style="padding:5px;">T_Normal</td><td style="padding:5px;">Normal Map</td><td style="padding:5px;">OFF</td></tr>
-                    <tr><td style="padding:5px;">T_Roughness, T_Metallic, T_AO, T_Height</td><td style="padding:5px;">Default</td><td style="padding:5px;">OFF</td></tr>
-                </table>
-                <h3 style="color:#f7a26a;">3. URP/Lit Material</h3>
-                <p>Shader: <code style="background:#1a1a2e;padding:2px 6px;border-radius:4px;">Universal Render Pipeline/Lit</code><br>
-                Base Map=T_Albedo | Normal=T_Normal | Metallic=T_Metallic | Occlusion=T_AO</p>
-                <h3 style="color:#f7a26a;">4. Roughness → Smoothness</h3>
-                <p>Unity uses Smoothness (= 1 - Roughness). Use the included <b>TextureForgeHDRPPacker</b> Unity Editor script to pack all channels into a Mask Map automatically.</p>
-                <div style="margin-top:1.5rem;padding:1rem;background:#0d0d14;border-left:3px solid #7c6af7;border-radius:0 8px 8px 0;">
-                    <p style="margin:0;color:#7c6af7;">Pro Tip — HDRP Mask Map</p>
-                    <p style="margin:0.4rem 0 0;color:#a0a0c0;">Pack R=Metallic, G=AO, B=0, A=Smoothness using <b>Tools > TextureForge > Pack HDRP Mask Map</b> in the Unity Editor.</p>
-                </div>
+            <div style="max-width:780px;margin:0 auto;padding:1.5rem;font-family:'Space Mono',monospace;font-size:.78rem;line-height:1.9;color:#c0c0d8">
+              <h2 style="font-family:'Syne',sans-serif;color:#7c6af7;font-size:1.4rem">Using TextureForge Maps in Unity3D</h2>
+              <h3 style="color:#f7a26a">1. Extract the ZIP</h3>
+              <p>Place into <code style="background:#1a1a2e;padding:2px 6px;border-radius:4px">Assets/Textures/MaterialName/</code></p>
+              <h3 style="color:#f7a26a">2. Texture Import Settings</h3>
+              <table style="width:100%;border-collapse:collapse;margin-bottom:1rem">
+                <tr style="border-bottom:1px solid #2a2a3a"><th style="text-align:left;padding:6px;color:#7c6af7">File</th><th style="padding:6px;color:#7c6af7">Type</th><th style="padding:6px;color:#7c6af7">sRGB</th></tr>
+                <tr style="border-bottom:1px solid #1a1a2a"><td style="padding:5px">T_Albedo</td><td style="padding:5px">Default</td><td style="padding:5px">ON</td></tr>
+                <tr style="border-bottom:1px solid #1a1a2a"><td style="padding:5px">T_Normal</td><td style="padding:5px">Normal Map</td><td style="padding:5px">OFF</td></tr>
+                <tr><td style="padding:5px">T_Roughness, T_Metallic, T_AO, T_Height</td><td style="padding:5px">Default</td><td style="padding:5px">OFF</td></tr>
+              </table>
+              <h3 style="color:#f7a26a">3. Create URP/Lit Material</h3>
+              <p>Shader: <code style="background:#1a1a2e;padding:2px 6px;border-radius:4px">Universal Render Pipeline/Lit</code><br>
+              Base Map=T_Albedo | Normal Map=T_Normal | Metallic=T_Metallic | Occlusion=T_AO</p>
+              <h3 style="color:#f7a26a">4. Roughness to Smoothness</h3>
+              <p>Unity uses Smoothness (= 1 minus Roughness). Use <b>Tools > TextureForge > Pack HDRP Mask Map</b> in the Unity Editor to auto-pack channels.</p>
+              <div style="margin-top:1.5rem;padding:1rem;background:#0d0d14;border-left:3px solid #7c6af7;border-radius:0 8px 8px 0">
+                <p style="margin:0;color:#7c6af7">HDRP Mask Map</p>
+                <p style="margin:.4rem 0 0;color:#a0a0c0">Pack R=Metallic, G=AO, B=0, A=Smoothness using the included Unity Editor script (TextureForgeHDRPPacker).</p>
+              </div>
             </div>""")
 
-    gr.HTML("""<div style="text-align:center;padding:1.5rem;color:#3a3a5a;font-family:'Space Mono',monospace;font-size:0.65rem;">
-        TextureForge · Built for Unity3D · Powered by Stable Diffusion + OpenCV</div>""")
+    gr.HTML("""<div style="text-align:center;padding:1.5rem;color:#3a3a5a;font-family:'Space Mono',monospace;font-size:.65rem">
+      TextureForge · Unity3D · Stable Diffusion + OpenCV PBR</div>""")
 
+print("=== Launching Gradio demo ===", flush=True)
 demo.launch()

requirements.txt

@@ -8,3 +8,4 @@ opencv-python-headless>=4.8.0
 Pillow>=10.0.0
 numpy>=1.24.0
 safetensors>=0.4.0
+# rebuild-1772183179