Fix gamma values: video 2.2, texture 2.1, add GLB Raw export

- Video: Set to standard gamma 2.2 for proper brightness
- Texture: Set to gamma 2.1 (slightly darker to reduce over-brightness)
- Add GLB Raw export with minimal processing (50% simplification, no hole filling)
- Fixes: video now properly bright, textures slightly less bright than before

app.py

@@ -227,6 +227,35 @@ def extract_glb(
     return glb_path, glb_path
 
 
+@spaces.GPU(duration=90)
+def extract_glb_raw(
+    state: dict,
+    texture_size: int,
+    req: gr.Request,
+) -> Tuple[str, str]:
+    """
+    Extract a RAW GLB file from the 3D model with minimal processing.
+    Skips hole filling and uses only light simplification (50% instead of 90%).
+    Preserves more original geometry from the neural network.
+    
+    Args:
+        state (dict): The state of the generated 3D model.
+        texture_size (int): The texture resolution.
+    Returns:
+        str: The path to the extracted raw GLB file.
+    """
+    if state is None:
+        raise gr.Error("Please generate a 3D model first before extracting GLB.")
+    
+    user_dir = os.path.join(TMP_DIR, str(req.session_hash))
+    gs, mesh = unpack_state(state)
+    glb = postprocessing_utils.to_glb_raw(gs, mesh, texture_size=texture_size, verbose=True)
+    glb_path = os.path.join(user_dir, 'sample_raw.glb')
+    glb.export(glb_path)
+    torch.cuda.empty_cache()
+    return glb_path, glb_path
+
+
 @spaces.GPU
 def extract_gaussian(state: dict, req: gr.Request) -> Tuple[str, str]:
     """
@@ -319,6 +348,7 @@ with gr.Blocks(delete_cache=(600, 600)) as demo:
             
             with gr.Row():
                 extract_glb_btn = gr.Button("Extract GLB", interactive=False)
+                extract_glb_raw_btn = gr.Button("Extract GLB Raw (Minimal Processing)", interactive=False, variant="secondary")
                 extract_gs_btn = gr.Button("Extract Gaussian", interactive=False)
             gr.Markdown("""
                         *NOTE: Gaussian file can be very large (~50MB), it will take a while to display and download.*
@@ -391,13 +421,13 @@ with gr.Blocks(delete_cache=(600, 600)) as demo:
         inputs=[image_prompt, multiimage_prompt, is_multiimage, seed, ss_guidance_strength, ss_sampling_steps, slat_guidance_strength, slat_sampling_steps, multiimage_algo],
         outputs=[output_buf, video_output],
     ).then(
-        lambda: tuple([gr.update(interactive=True), gr.update(interactive=True)]),
-        outputs=[extract_glb_btn, extract_gs_btn],
+        lambda: tuple([gr.update(interactive=True), gr.update(interactive=True), gr.update(interactive=True)]),
+        outputs=[extract_glb_btn, extract_glb_raw_btn, extract_gs_btn],
     )
 
     video_output.clear(
-        lambda: tuple([gr.update(interactive=False), gr.update(interactive=False)]),
-        outputs=[extract_glb_btn, extract_gs_btn],
+        lambda: tuple([gr.update(interactive=False), gr.update(interactive=False), gr.update(interactive=False)]),
+        outputs=[extract_glb_btn, extract_glb_raw_btn, extract_gs_btn],
     )
 
     extract_glb_btn.click(
@@ -409,6 +439,15 @@ with gr.Blocks(delete_cache=(600, 600)) as demo:
         outputs=[download_glb],
     )
     
+    extract_glb_raw_btn.click(
+        extract_glb_raw,
+        inputs=[output_buf, texture_size],
+        outputs=[model_output, download_glb],
+    ).then(
+        lambda: gr.update(interactive=True),
+        outputs=[download_glb],
+    )
+    
     extract_gs_btn.click(
         extract_gaussian,
         inputs=[output_buf],

trellis/utils/postprocessing_utils.py

@@ -340,7 +340,7 @@ def bake_texture(
         # 🔧 Apply gamma correction (Linear → sRGB)
         # Fixes "dark model" issue by converting from linear color space to sRGB
         texture_linear = texture.reshape(texture_size, texture_size, 3).cpu().numpy()
-        texture_srgb = np.power(np.clip(texture_linear, 0, 1), 1.0/2.3)  # Gamma 2.3 (slightly less bright than 2.2)
+        texture_srgb = np.power(np.clip(texture_linear, 0, 1), 1.0/2.1)  # Gamma 2.1 (slightly darker than standard 2.2)
         texture = np.clip(texture_srgb * 255, 0, 255).astype(np.uint8)
 
         # inpaint
@@ -406,6 +406,76 @@ def bake_texture(
     return texture
 
 
+def to_glb_raw(
+    app_rep: Union[Strivec, Gaussian],
+    mesh: MeshExtractResult,
+    texture_size: int = 1024,
+    verbose: bool = True,
+) -> trimesh.Trimesh:
+    """
+    Convert a generated asset to a GLB file with MINIMAL processing.
+    Skips hole filling and uses light simplification only.
+    This preserves more original geometry while keeping GPU usage manageable.
+    
+    Args:
+        app_rep (Union[Strivec, Gaussian]): Appearance representation.
+        mesh (MeshExtractResult): Extracted mesh.
+        texture_size (int): Size of the texture.
+        verbose (bool): Whether to print progress.
+    """
+    vertices = mesh.vertices.cpu().numpy()
+    faces = mesh.faces.cpu().numpy()
+    
+    if verbose:
+        print(f'🔧 RAW GLB: Starting with {vertices.shape[0]} vertices, {faces.shape[0]} faces')
+    
+    # LIGHT simplification only (50% reduction instead of 90%)
+    # This keeps GPU usage manageable while preserving more detail
+    import pyvista as pv
+    mesh_pv = pv.PolyData(vertices, np.concatenate([np.full((faces.shape[0], 1), 3), faces], axis=1))
+    mesh_pv = mesh_pv.decimate(0.5, progress_bar=verbose)
+    vertices, faces = mesh_pv.points, mesh_pv.faces.reshape(-1, 4)[:, 1:]
+    
+    if verbose:
+        print(f'🔧 RAW GLB: After light simplification: {vertices.shape[0]} vertices, {faces.shape[0]} faces')
+    
+    # parametrize mesh (required for texture)
+    vertices, faces, uvs = parametrize_mesh(vertices, faces)
+    
+    if verbose:
+        print(f'🔧 RAW GLB: After UV unwrap: {vertices.shape[0]} vertices, {faces.shape[0]} faces')
+    
+    # bake texture (same as normal)
+    observations, extrinsics, intrinsics = render_multiview(app_rep, resolution=1024, nviews=100)
+    masks = [np.any(observation > 0, axis=-1) for observation in observations]
+    extrinsics = [extrinsics[i].cpu().numpy() for i in range(len(extrinsics))]
+    intrinsics = [intrinsics[i].cpu().numpy() for i in range(len(intrinsics))]
+    texture = bake_texture(
+        vertices, faces, uvs,
+        observations, masks, extrinsics, intrinsics,
+        texture_size=texture_size, mode='opt',
+        lambda_tv=0.01,
+        verbose=verbose
+    )
+    texture = Image.fromarray(texture)
+
+    # rotate mesh (from z-up to y-up)
+    vertices = vertices @ np.array([[1, 0, 0], [0, 0, -1], [0, 1, 0]])
+    
+    # Create material
+    material = trimesh.visual.material.PBRMaterial(
+        baseColorTexture=texture
+    )
+    
+    mesh = trimesh.Trimesh(vertices, faces, visual=trimesh.visual.TextureVisuals(uv=uvs, material=material))
+    mesh.vertex_normals
+    
+    if verbose:
+        print(f"✅ RAW GLB: Generated {len(mesh.vertex_normals)} vertex normals")
+    
+    return mesh
+
+
 def to_glb(
     app_rep: Union[Strivec, Gaussian],
     mesh: MeshExtractResult,

trellis/utils/render_utils.py

@@ -75,7 +75,7 @@ def render_frames(sample, extrinsics, intrinsics, options={}, colors_overwrite=N
             if 'depth' not in rets: rets['depth'] = []
             # Apply gamma correction to video frames (Linear → sRGB)
             color_linear = res['color'].detach().cpu().numpy().transpose(1, 2, 0)
-            color_srgb = np.power(np.clip(color_linear, 0, 1), 1.0/2.3)  # Gamma 2.3 (slightly less bright)
+            color_srgb = np.power(np.clip(color_linear, 0, 1), 1.0/2.2)  # Standard gamma 2.2
             rets['color'].append(np.clip(color_srgb * 255, 0, 255).astype(np.uint8))
             if 'percent_depth' in res:
                 rets['depth'].append(res['percent_depth'].detach().cpu().numpy())