Migrate from TRELLIS v1 to TRELLIS.2 pipeline

- Replace trellis/ with trellis2/ (3-stage: sparse structure -> shape -> texture)
- Model: microsoft/TRELLIS.2-4B (upgraded from TRELLIS-image-large)
- PyTorch 2.6.0 + CUDA 12.4, flash_attn_3, o_voxel, cumesh, flex_gemm
- GLB export via o_voxel.postprocess.to_glb with PBR materials
- Add HDRI envmaps for shaded rendering (forest, sunset, courtyard)
- Keep existing Gradio UI: LitModel3D, video preview, STL export
- Remove old extensions/, wheels/, Dockerfile (Gradio SDK space)

Co-authored-by: Cursor <cursoragent@cursor.com>

.gitattributes

@@ -35,3 +35,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 wheels/nvdiffrast-0.3.3-cp310-cp310-linux_x86_64.whl filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
+*.exr filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,2 +1,10 @@
 model_cache/
-AGENTS.md
+AGENTS.md
+__pycache__/
+*.pyc
+cache/
+tmp/
+trellis/
+extensions/
+wheels/
+TRELLIS.2/

app.py

@@ -1,502 +1,293 @@
-import sys
-import os
-print(f"[DIAG] app.py starting, __name__={__name__}, argv={sys.argv}", flush=True)
-
 import argparse
+import os
+import sys
 import time
-print("[DIAG] importing gradio...", flush=True)
+import io
+import base64
+
+os.environ["OPENCV_IO_ENABLE_OPENEXR"] = '1'
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+os.environ["ATTN_BACKEND"] = "flash_attn_3"
+os.environ["FLEX_GEMM_AUTOTUNE_CACHE_PATH"] = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'autotune_cache.json')
+os.environ["FLEX_GEMM_AUTOTUNER_VERBOSE"] = '1'
+
 import gradio as gr
-print(f"[DIAG] gradio imported, NO_RELOAD={gr.NO_RELOAD}", flush=True)
 import spaces
 from gradio_litmodel3d import LitModel3D
-print("[DIAG] all top-level UI imports done", flush=True)
 sys.path.append(os.getcwd())
-os.environ['ATTN_BACKEND'] = 'xformers'
-os.environ['SPCONV_ALGO'] = 'native'
-os.environ['TORCH_CUDA_ARCH_LIST'] = '8.9'
-import concurrent.futures
+import cv2
 from typing import *
-print("[DIAG] importing torch...", flush=True)
 import torch
-print(f"[DIAG] torch imported, cuda.is_available={torch.cuda.is_available()}", flush=True)
 import numpy as np
 import imageio
 from PIL import Image
 import trimesh
-
 from datetime import datetime
 import logging
 
+from trellis2.modules.sparse import SparseTensor
+from trellis2.pipelines import Trellis2ImageTo3DPipeline
+from trellis2.renderers import EnvMap
+from trellis2.utils import render_utils
+import o_voxel
+
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# --- Command Line Args ---
-print("[DIAG] setting up argparse...", flush=True)
 parser = argparse.ArgumentParser(description="Pocket 3D AI 2")
-parser.add_argument("--prod",
-                    action="store_true",
-                    help="Run in production mode")
-parser.add_argument("--port",
-                    type=int,
-                    help="Port to run the server on (default: 8081 for prod, 8080 for dev)")
-cmd_args, unknown_args = parser.parse_known_args()
-if unknown_args:
-    print(f"[DIAG] WARNING: unknown args ignored: {unknown_args}", flush=True)
-print(f"[DIAG] argparse done, prod={cmd_args.prod}, port={cmd_args.port}", flush=True)
+parser.add_argument("--prod", action="store_true", help="Run in production mode")
+parser.add_argument("--port", type=int, help="Port to run the server on (default: 8081 for prod, 8080 for dev)")
+cmd_args, _unknown_args = parser.parse_known_args()
 
 prod = cmd_args.prod
 port = cmd_args.port if cmd_args.port else (8081 if prod else 8080)
 show_options = not prod
 
 MAX_SEED = np.iinfo(np.int32).max
-
 TMP_DIR = os.path.join('cache')
 os.makedirs(TMP_DIR, exist_ok=True)
 
-print(f"[DIAG] entering gr.NO_RELOAD block (NO_RELOAD={gr.NO_RELOAD})...", flush=True)
 if gr.NO_RELOAD:
-    print("[DIAG] importing trellis pipeline...", flush=True)
-    from trellis.pipelines.trellis_image_to_3d import TrellisImageTo3DPipeline
-    print("[DIAG] importing trellis utils...", flush=True)
-    from trellis.utils import render_utils, postprocessing_utils
-    print("[DIAG] trellis imports done", flush=True)
     pipeline = None
+    envmap = None
 
     def initialize_pipeline():
-        global pipeline
+        global pipeline, envmap
         if pipeline is not None:
-            logger.info("Pipeline already initialized.")
             return
 
-        logger.info("Initializing pipeline...")
+        logger.info("Initializing TRELLIS.2 pipeline...")
         start_time = time.time()
-        device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        target_dtype = torch.float16 if device.type == 'cuda' else torch.float32
-        logger.info(f"Target device: {device}, Target dtype: {target_dtype}")
 
         try:
-            logger.info("Loading models from pretrained...")
-            pipeline = TrellisImageTo3DPipeline.from_pretrained("JeffreyXiang/TRELLIS-image-large")
-            
-            # Check where models landed
-            sample_model = next(iter(pipeline.models.values()))
-            current_device = next(sample_model.parameters()).device
-            logger.info(f"Models initially on: {current_device}")
-
-            # On ZeroGPU, no real GPU at init time. Ensure everything is on CPU.
-            if current_device.type != 'cpu':
-                logger.info("Moving pipeline to CPU for stable initialization...")
-                pipeline.cpu()
-            
-            if hasattr(pipeline, 'rmbg_model') and pipeline.rmbg_model is not None:
-                rmbg_device = next(pipeline.rmbg_model.parameters()).device
-                if rmbg_device.type != 'cpu':
-                    logger.info(f"Moving RMBG model from {rmbg_device} to CPU...")
-                    pipeline.rmbg_model.to('cpu')
-
-            logger.info(f"⏰ Pipeline initialized and confirmed on CPU in {time.time() - start_time:.2f} seconds.")
-
+            pipeline = Trellis2ImageTo3DPipeline.from_pretrained('microsoft/TRELLIS.2-4B')
+            pipeline.rembg_model = None
+            pipeline.low_vram = False
+            pipeline._device = 'cpu'
+
+            envmap = {}
+            for name in ['forest', 'sunset', 'courtyard']:
+                exr_path = os.path.join('assets', 'hdri', f'{name}.exr')
+                if os.path.exists(exr_path):
+                    envmap[name] = cv2.cvtColor(
+                        cv2.imread(exr_path, cv2.IMREAD_UNCHANGED),
+                        cv2.COLOR_BGR2RGB
+                    )
+
+            logger.info(f"Pipeline initialized in {time.time() - start_time:.2f} seconds.")
         except Exception as e:
             logger.error(f"Failed to initialize pipeline: {e}", exc_info=True)
-            pipeline = None # Ensure pipeline is None if initialization failed
-            raise # Re-raise the exception to stop the application if critical
-
+            pipeline = None
+            raise
 
     initialize_pipeline()
 
-# --- Helper Functions ---
+
+def pack_state(latents: Tuple[SparseTensor, SparseTensor, int]) -> dict:
+    shape_slat, tex_slat, res = latents
+    return {
+        'shape_slat_feats': shape_slat.feats.cpu().numpy(),
+        'tex_slat_feats': tex_slat.feats.cpu().numpy(),
+        'coords': shape_slat.coords.cpu().numpy(),
+        'res': res,
+    }
+
+
+def unpack_state(state: dict) -> Tuple[SparseTensor, SparseTensor, int]:
+    shape_slat = SparseTensor(
+        feats=torch.from_numpy(state['shape_slat_feats']).cuda(),
+        coords=torch.from_numpy(state['coords']).cuda(),
+    )
+    tex_slat = shape_slat.replace(torch.from_numpy(state['tex_slat_feats']).cuda())
+    return shape_slat, tex_slat, state['res']
+
 
 def start_session(req: gr.Request):
-    # user_dir = os.path.join(TMP_DIR, str(req.session_hash)) # Per-session dir if needed
     torch.cuda.empty_cache()
-    user_dir = TMP_DIR
-    os.makedirs(user_dir, exist_ok=True)
+    os.makedirs(TMP_DIR, exist_ok=True)
+
 
 def end_session(req: gr.Request):
     torch.cuda.empty_cache()
 
+
 def preprocess_image(image: Optional[Image.Image]) -> Optional[Image.Image]:
     if image is None:
-        logger.warning("Preprocess: received None image.")
         return None
-    user_dir = TMP_DIR
-    current_time = datetime.now().strftime("%Y-%m%d-%H%M%S")
-    image_path = os.path.join(user_dir, f'{current_time}.png')
-    image.save(image_path)
     try:
-        processed_image = pipeline.preprocess_image(image)
-        return processed_image
+        return pipeline.preprocess_image(image)
     except Exception as e:
         logger.error(f"Error during image preprocessing: {e}", exc_info=True)
-        return None # Return None or raise error
-    
-def preprocess_images(images: List[Tuple[Image.Image, str]]) -> List[Image.Image]:
-    images = [image[0] for image in images]
-    processed_images = pipeline.preprocess_images(images)
-    return processed_images
+        return None
+
 
 def get_seed(randomize_seed: bool, seed: int) -> int:
-    if randomize_seed:
-        new_seed = np.random.randint(0, MAX_SEED)
-        return new_seed
-    else:
-        return seed
+    return np.random.randint(0, MAX_SEED) if randomize_seed else seed
 
-# --- Core Logic Functions ---
 
-def generate_3d_data(
-    image: Image.Image,
+@spaces.GPU(duration=120)
+def process_image_yielding(
+    image: Optional[Image.Image],
     seed: int,
+    resolution: str,
     ss_guidance_strength: float,
     ss_sampling_steps: int,
-    slat_guidance_strength: float,
-    slat_sampling_steps: int,
+    shape_guidance_strength: float,
+    shape_sampling_steps: int,
+    tex_guidance_strength: float,
+    tex_sampling_steps: int,
+    mesh_simplify: int,
+    texture_size: int,
+    req: gr.Request,
     progress=gr.Progress(track_tqdm=True)
-) -> Optional[dict]:
+) -> Generator:
     if image is None or pipeline is None:
-        logger.error("Generate 3D Data: called with None image or uninitialized pipeline.")
-        return None
+        return
 
-    pipeline_start = time.time()
+    pipeline.cuda()
+    loaded_envmap = {}
+    for name, exr_data in envmap.items():
+        loaded_envmap[name] = EnvMap(torch.tensor(exr_data, dtype=torch.float32, device='cuda'))
 
-    try:
-        outputs = pipeline.run(
-            image,
-            seed=seed,
-            formats=["gaussian", "mesh"],
-            preprocess_image=False,
-            sparse_structure_sampler_params={
-                "steps": ss_sampling_steps,
-                "cfg_strength": ss_guidance_strength,
-            },
-            slat_sampler_params={
-                "steps": slat_sampling_steps,
-                "cfg_strength": slat_guidance_strength,
-            },
-        )
-        logger.info(f"⌚ Pipeline Time: {time.time() - pipeline_start:.2f} seconds")
-        return outputs
-    except Exception as e:
-        logger.error(f"Error during pipeline run: {e}", exc_info=True)
-        torch.cuda.empty_cache()
-        return None
+    yield None, None, gr.update(value=None, interactive=False), None
 
-def generate_3d_data_multi_image(
-    images: List[Image.Image],
-    seed: int,
-    ss_guidance_strength: float,
-    ss_sampling_steps: int,
-    slat_guidance_strength: float,
-    slat_sampling_steps: int,
-    multiimage_algo: Literal["multidiffusion", "stochastic"],
-    progress=gr.Progress(track_tqdm=True)
-) -> Optional[dict]:
-    if not images or pipeline is None:
-        logger.error("Generate 3D Data Multi-Image: called with empty images or uninitialized pipeline.")
-        return None
+    progress(0, desc="Removing background...")
+    image = preprocess_image(image)
+    if image is None:
+        return
 
+    progress(0.1, desc="Generating 3D structure...")
     pipeline_start = time.time()
 
     try:
-        outputs = pipeline.run_multi_image(
-            images,
+        outputs, latents = pipeline.run(
+            image,
             seed=seed,
-            formats=["gaussian", "mesh"],
             preprocess_image=False,
             sparse_structure_sampler_params={
                 "steps": ss_sampling_steps,
-                "cfg_strength": ss_guidance_strength,
+                "guidance_strength": ss_guidance_strength,
             },
-            slat_sampler_params={
-                "steps": slat_sampling_steps,
-                "cfg_strength": slat_guidance_strength,
+            shape_slat_sampler_params={
+                "steps": shape_sampling_steps,
+                "guidance_strength": shape_guidance_strength,
             },
-            mode=multiimage_algo,
+            tex_slat_sampler_params={
+                "steps": tex_sampling_steps,
+                "guidance_strength": tex_guidance_strength,
+            },
+            pipeline_type={
+                "512": "512",
+                "1024": "1024_cascade",
+                "1536": "1536_cascade",
+            }[resolution],
+            return_latent=True,
         )
-        logger.info(f"⌚ Multi-Image Pipeline Time: {time.time() - pipeline_start:.2f} seconds")
-        return outputs
     except Exception as e:
-        logger.error(f"Error during multi-image pipeline run: {e}", exc_info=True)
+        logger.error(f"Error during pipeline run: {e}", exc_info=True)
         torch.cuda.empty_cache()
-        return None
+        return
 
+    logger.info(f"Pipeline Time: {time.time() - pipeline_start:.2f} seconds")
 
-def combine_and_save_video(
-    video_color_frames: List[np.ndarray],
-    video_normal_frames: List[np.ndarray],
-    is_mobile: bool,
-    user_dir: str,
-    progress=gr.Progress(track_tqdm=True) # Keep progress for potential future use or consistency
-) -> Optional[str]:
-    """
-    Combines pre-rendered color and normal video frames and saves the result.
-    """
-    if not video_color_frames or not video_normal_frames:
-        logger.error("Combine Video: received empty frame lists.")
-        return None
+    mesh = outputs[0]
+    mesh.simplify(16777216)
+    state = pack_state(latents)
 
-    combine_start = time.time()
-    logger.info("Starting video frame combination...") # Added log
+    progress(0.5, desc="Rendering preview video...")
+    user_agent = req.headers.get("User-Agent", "").lower()
+    is_mobile = any(d in user_agent for d in ["android", "iphone", "ipad", "mobile"])
+    vid_resolution = 256 if is_mobile else 384
+    num_frames = 45
 
     try:
-        # Combine frames
-        if is_mobile:
-            # Vertical video (stacked top and bottom)
-            combined_video = [np.concatenate([color_frame, normal_frame], axis=0) for color_frame, normal_frame in zip(video_color_frames, video_normal_frames)]
-        else:
-            # Horizontal video (side by side)
-            combined_video = [np.concatenate([color_frame, normal_frame], axis=1) for color_frame, normal_frame in zip(video_color_frames, video_normal_frames)]
-
-        # Save video
-        current_time = datetime.now().strftime("%Y-%m%d-%H%M%S")
-        video_path = os.path.join(user_dir, f'{current_time}.mp4')
-        # Use a thread for saving to avoid blocking if I/O is slow
-        # Note: imageio.mimsave might release GIL for some codecs/operations
-        imageio.mimsave(video_path, combined_video, fps=15)
-
-        return video_path
+        vid_result = render_utils.render_video(mesh, resolution=vid_resolution, num_frames=num_frames, r=2, fov=36, envmap=loaded_envmap)
+        color_frames = vid_result.get('shaded', vid_result.get('color', []))
+        normal_frames = vid_result.get('normal', [])
 
+        if color_frames and normal_frames:
+            if is_mobile:
+                combined = [np.concatenate([c, n], axis=0) for c, n in zip(color_frames, normal_frames)]
+            else:
+                combined = [np.concatenate([c, n], axis=1) for c, n in zip(color_frames, normal_frames)]
+
+            current_time = datetime.now().strftime("%Y-%m%d-%H%M%S")
+            video_path = os.path.join(TMP_DIR, f'{current_time}.mp4')
+            imageio.mimsave(video_path, combined, fps=15)
+            logger.info(f"Video rendered: {video_path}")
+            yield video_path, None, gr.update(value=None, interactive=False), state
+        elif color_frames:
+            current_time = datetime.now().strftime("%Y-%m%d-%H%M%S")
+            video_path = os.path.join(TMP_DIR, f'{current_time}.mp4')
+            imageio.mimsave(video_path, color_frames, fps=15)
+            yield video_path, None, gr.update(value=None, interactive=False), state
     except Exception as e:
-        logger.error(f"Error during video combination/saving: {e}", exc_info=True)
-        return None
-
-
-def extract_glb(
-    outputs: dict,
-    mesh_simplify: float,
-    texture_size: int,
-    progress=gr.Progress(track_tqdm=True)
-) -> Optional[Tuple[str, str]]: # MODIFIED return type
-    """
-    Extract a GLB file from the 3D model outputs and convert to STL.
-    (Modified to return GLB and STL paths)
-    """
-    if outputs is None or 'gaussian' not in outputs or 'mesh' not in outputs:
-        logger.error("Extract GLB: received invalid outputs.")
-        return None, None # MODIFIED return
-
-    glb_start_time = time.time() # Renamed for clarity
-    user_dir = TMP_DIR
-    glb_path: Optional[str] = None
-    stl_path: Optional[str] = None
+        logger.error(f"Video rendering error: {e}", exc_info=True)
 
+    progress(0.7, desc="Extracting GLB model...")
     try:
-        glb_model_data = postprocessing_utils.to_glb(
-            outputs['gaussian'][0],
-            outputs['mesh'][0],
-            simplify=mesh_simplify,
-            fill_holes=False,
+        shape_slat, tex_slat, res = unpack_state(state)
+        decoded_mesh = pipeline.decode_latent(shape_slat, tex_slat, res)[0]
+        decoded_mesh.simplify(16777216)
+
+        glb = o_voxel.postprocess.to_glb(
+            vertices=decoded_mesh.vertices,
+            faces=decoded_mesh.faces,
+            attr_volume=decoded_mesh.attrs,
+            coords=decoded_mesh.coords,
+            attr_layout=pipeline.pbr_attr_layout,
+            grid_size=res,
+            aabb=[[-0.5, -0.5, -0.5], [0.5, 0.5, 0.5]],
+            decimation_target=mesh_simplify,
             texture_size=texture_size,
-            verbose=False,
-            debug=False
+            remesh=True,
+            remesh_band=1,
+            remesh_project=0,
+            use_tqdm=True,
         )
+
         current_time_glb = datetime.now().strftime("%Y-%m%d-%H%M%S")
-        glb_path = os.path.join(user_dir, f'{current_time_glb}.glb')
-        glb_model_data.export(glb_path)
-        logger.info(f"⌚ GLB Export Time: {time.time() - glb_start_time:.2f} seconds. Saved to {glb_path}")
+        glb_path = os.path.join(TMP_DIR, f'{current_time_glb}.glb')
+        glb.export(glb_path, extension_webp=True)
+        logger.info(f"GLB exported: {glb_path}")
 
-        stl_export_start_time = time.time()
+        stl_path = None
         try:
             mesh_data = trimesh.load_mesh(glb_path, force='mesh')
             mesh_to_export = None
 
             if isinstance(mesh_data, trimesh.Scene):
-                if mesh_data.geometry:
-                    geometries = [g for g in mesh_data.geometry.values() if isinstance(g, trimesh.Trimesh)]
-                    if geometries:
-                        valid_geometries = [g for g in geometries if g.vertices is not None and len(g.vertices) > 0]
-                        if valid_geometries:
-                            combined_mesh = trimesh.util.concatenate(valid_geometries)
-                            if isinstance(combined_mesh, trimesh.Trimesh) and combined_mesh.vertices is not None and len(combined_mesh.vertices) > 0:
-                                mesh_to_export = combined_mesh
-                            else:
-                                logger.warning(f"Concatenated mesh from scene in {glb_path} is not a valid Trimesh or is empty.")
-                        else:
-                            logger.warning(f"No valid (non-empty) trimesh.Trimesh geometry found in scene for {glb_path}")
-                    else:
-                        logger.warning(f"No trimesh.Trimesh geometry found in scene for {glb_path}")
-                else:
-                    logger.warning(f"Scene for {glb_path} is empty.")
-            elif isinstance(mesh_data, trimesh.Trimesh):
-                 if mesh_data.vertices is not None and len(mesh_data.vertices) > 0:
-                    mesh_to_export = mesh_data
-                 else:
-                    logger.warning(f"Loaded Trimesh from {glb_path} is empty.")
-            else:
-                logger.warning(f"Loaded object from {glb_path} of type {type(mesh_data)} is not a Trimesh or Scene.")
-
-            if mesh_to_export:
-                if not (mesh_to_export.faces is not None and len(mesh_to_export.faces) > 0):
-                    logger.warning(f"Mesh for STL export from {glb_path} has no faces. Attempting to convex hull.")
-                    if mesh_to_export.vertices is not None and len(mesh_to_export.vertices) >= 4:
-                        try:
-                            mesh_to_export = mesh_to_export.convex_hull
-                        except Exception as convex_e:
-                            logger.error(f"Failed to create convex hull for {glb_path}: {convex_e}")
-                            mesh_to_export = None
-                    else:
-                        mesh_to_export = None
-                
-                if mesh_to_export and mesh_to_export.faces is not None and len(mesh_to_export.faces) > 0:
-                    current_time_stl = datetime.now().strftime("%Y-%m%d-%H%M%S-%f")
-                    stl_path = os.path.join(user_dir, f'{current_time_stl}.stl')
-                    if mesh_to_export:
-                        mesh_to_export = mesh_to_export.copy()
-                        # Y-up to Z-up (upright, not upside down)
-                        rot_x_90 = trimesh.transformations.rotation_matrix(np.deg2rad(90), [1, 0, 0])
-                        mesh_to_export.apply_transform(rot_x_90)
-                        bbox = mesh_to_export.bounds
-                        current_size = (bbox[1] - bbox[0]).max()
-                        target_size_mm = 152.4  # 6 inches
-                        if current_size > 0:
-                            scale_factor = target_size_mm / current_size
-                            mesh_to_export.vertices *= scale_factor
-                    mesh_to_export.export(stl_path)
-                    logger.info(f"⌚ STL Export Time: {time.time() - stl_export_start_time:.2f} seconds. Saved to {stl_path}")
-                elif mesh_to_export:
-                     logger.error(f"Failed to prepare mesh with faces from {glb_path} for STL export.")
-                     stl_path = None
-            else:
-                logger.error(f"No valid mesh could be processed from {glb_path} for STL export.")
-                stl_path = None
-
+                geometries = [g for g in mesh_data.geometry.values() if isinstance(g, trimesh.Trimesh)]
+                valid = [g for g in geometries if g.vertices is not None and len(g.vertices) > 0]
+                if valid:
+                    combined_mesh = trimesh.util.concatenate(valid)
+                    if isinstance(combined_mesh, trimesh.Trimesh) and len(combined_mesh.vertices) > 0:
+                        mesh_to_export = combined_mesh
+            elif isinstance(mesh_data, trimesh.Trimesh) and len(mesh_data.vertices) > 0:
+                mesh_to_export = mesh_data
+
+            if mesh_to_export and mesh_to_export.faces is not None and len(mesh_to_export.faces) > 0:
+                mesh_to_export = mesh_to_export.copy()
+                rot_x_90 = trimesh.transformations.rotation_matrix(np.deg2rad(90), [1, 0, 0])
+                mesh_to_export.apply_transform(rot_x_90)
+                bbox = mesh_to_export.bounds
+                current_size = (bbox[1] - bbox[0]).max()
+                target_size_mm = 152.4
+                if current_size > 0:
+                    mesh_to_export.vertices *= target_size_mm / current_size
+                current_time_stl = datetime.now().strftime("%Y-%m%d-%H%M%S-%f")
+                stl_path = os.path.join(TMP_DIR, f'{current_time_stl}.stl')
+                mesh_to_export.export(stl_path)
+                logger.info(f"STL exported: {stl_path}")
         except Exception as stl_e:
-            logger.error(f"Error during STL processing for {glb_path}: {stl_e}", exc_info=True)
-            stl_path = None
-        
-        return glb_path, stl_path
-
-    except Exception as e:
-        logger.error(f"Error during GLB/STL extraction: {e}", exc_info=True)
-        return None, None
-
-
-@spaces.GPU(duration=120)
-def process_image_concurrently_yielding(
-    image: Optional[Image.Image],
-    multiimages: List[Tuple[Image.Image, str]],
-    is_multiimage: bool,
-    seed: int,
-    ss_guidance_strength: float,
-    ss_sampling_steps: int,
-    slat_guidance_strength: float,
-    slat_sampling_steps: int,
-    mesh_simplify: float,
-    texture_size: int,
-    multiimage_algo: Literal["multidiffusion", "stochastic"],
-    req: gr.Request,
-    progress=gr.Progress(track_tqdm=True)
-) -> Generator[Tuple[Optional[str], Optional[str], Dict[str, Any]], None, None]:
-    video_path: Optional[str] = None
-    glb_path: Optional[str] = None
-    stl_path: Optional[str] = None
-    color_frames: Optional[List[np.ndarray]] = None
-    normal_frames: Optional[List[np.ndarray]] = None
-
-    # Move all models to real GPU now that @spaces.GPU has allocated one
-    logger.info("Moving pipeline models to GPU...")
-    move_start = time.time()
-    pipeline.cuda()
-    if hasattr(pipeline, 'rmbg_model') and pipeline.rmbg_model is not None:
-        pipeline.rmbg_model.to('cuda')
-    logger.info(f"Models moved to GPU in {time.time() - move_start:.2f}s")
+            logger.error(f"STL export error: {stl_e}", exc_info=True)
 
-    yield None, None, gr.update(value=None, interactive=False)
+        stl_update = gr.update(value=stl_path, interactive=True) if stl_path else gr.update(value=None, interactive=False)
+        yield video_path, glb_path, stl_update, state
 
-    # --- Step 0: Preprocess image(s) inside the GPU session ---
-    if not is_multiimage:
-        if image is None:
-            logger.error("Received None image.")
-            return
-        logger.info("Preprocessing single image inside GPU session...")
-        progress(0, desc="Removing background...")
-        image = preprocess_image(image)
-        if image is None:
-            logger.error("Image preprocessing failed.")
-            return
-        logger.info("Starting Pipeline (Single Image)...")
-        outputs = generate_3d_data(
-            image, seed, ss_guidance_strength, ss_sampling_steps,
-            slat_guidance_strength, slat_sampling_steps, progress=progress
-        )
-    else:
-        if not multiimages:
-            logger.error("Received empty multiimages list.")
-            return
-        logger.info(f"Preprocessing and starting Pipeline (Multi-Image: {len(multiimages)} images)...")
-        progress(0, desc="Preprocessing images...")
-        processed_images = preprocess_images(multiimages)
-        progress(0.1, desc="Generating 3D Structure...")
-        outputs = generate_3d_data_multi_image(
-            processed_images, seed, ss_guidance_strength, ss_sampling_steps,
-            slat_guidance_strength, slat_sampling_steps, multiimage_algo, progress=progress
-        )
-
-    if outputs is None:
-        logger.error("Failed to generate 3D data. Aborting.")
-        return
+    except Exception as e:
+        logger.error(f"GLB extraction error: {e}", exc_info=True)
 
-    # --- Step 2: Determine Render Settings ---
-    user_agent = req.headers.get("User-Agent", "").lower()
-    is_mobile = any(device in user_agent for device in ["android", "iphone", "ipad", "mobile"])
-    resolution = 256 if is_mobile else 384
-    num_frames = 45 # Consistent frame count
-
-    # --- Step 3: Render Videos First ---
-    vid_time = time.time()
-    
-    progress(0.4, desc="Rendering Preview Videos...")
-    logger.info("Rendering videos: color and normal")
-    
-    try:
-        color_result = render_utils.render_video(outputs['gaussian'][0], resolution=resolution, num_frames=num_frames, mode='color', verbose=False)
-        normal_result = render_utils.render_video(outputs['mesh'][0], resolution=resolution, num_frames=num_frames, mode='normal', verbose=False)
-        
-        if color_result and 'color' in color_result:
-            color_frames = color_result['color']
-        else:
-            logger.warning("Color video rendering returned invalid data.")
-            color_frames = []
-            
-        if normal_result and 'normal' in normal_result:
-            normal_frames = normal_result['normal']
-        else:
-            logger.warning("Normal video rendering returned invalid data.")
-            normal_frames = []
-            
-    except Exception as exc:
-        logger.error(f"Video rendering generated an exception: {exc}", exc_info=True)
-        color_frames = []
-        normal_frames = []
-    
-    if color_frames and normal_frames:
-        video_path = combine_and_save_video(color_frames, normal_frames, is_mobile, TMP_DIR, progress=progress)
-        if video_path:
-            logger.info(f"✅ Video Time: {time.time() - vid_time:.2f} seconds")
-            yield video_path, None, gr.update(value=None, interactive=False)
-        else:
-            logger.warning("Video combination/saving failed.")
-    
-    # --- Step 4: Extract GLB/STL After Video ---
-    try:
-        progress(0.7, desc="Finalizing 3D Model & Textures...")
-        glb_stl_result = extract_glb(outputs, mesh_simplify, texture_size, progress=progress)
-        if glb_stl_result and isinstance(glb_stl_result, tuple) and len(glb_stl_result) == 2:
-            glb_path, stl_path = glb_stl_result
-            if not glb_path:
-                logger.warning("GLB extraction returned None.")
-            if not stl_path:
-                logger.warning("STL extraction returned None.")
-        else:
-            logger.warning(f"GLB/STL extraction returned invalid data: {glb_stl_result}")
-            glb_path, stl_path = None, None
-    except Exception as exc:
-        logger.error(f"GLB/STL extraction generated an exception: {exc}", exc_info=True)
-        glb_path, stl_path = None, None
-    
-    stl_button_update = gr.update(value=stl_path, interactive=True) if stl_path else gr.update(value=None, interactive=False)
-    yield video_path, glb_path, stl_button_update
-    
     torch.cuda.empty_cache()
 
 
@@ -504,57 +295,50 @@ css = """
 h1, h2, h3 { text-align: center; display: block; }
 footer { visibility: hidden; }
 .gradio-container { max-width: 1024px !important; }
-/* Base styles */
 .gr-image-container { display: flex !important; justify-content: center !important; align-items: center !important; width: 100%; height: 240px; }
 .gr-image-container img { width: 100%; height: 100%; object-fit: contain; object-position: center; }
-/* Desktop styles */
 @media screen and (min-width: 768px) {
     .gr-image-container { height: 360px !important; }
-    .video-container { height: 360px !important; max-width: 680px !important; margin: 0 auto !important; aspect-ratio: auto !important; /* Adjusted aspect-ratio */ }
+    .video-container { height: 360px !important; max-width: 680px !important; margin: 0 auto !important; aspect-ratio: auto !important; }
     .model-container { height: 480px !important; max-width: 680px !important; margin: 0 auto !important; }
 }
 .custom-header { display: flex; align-items: center; height: 100%; }
 """
 
 with gr.Blocks(theme='Taithrah/Minimal', css=css, title="Pocket 3D AI") as demo:
+    output_state = gr.State()
+
     with gr.Row(equal_height=True):
         gr.Image("assets/sb_pocket_logo_dark.png", show_label=False, container=False, show_download_button=False, min_width=50, interactive=False, show_fullscreen_button=False)
 
     with gr.Column():
         with gr.Row():
             with gr.Column(scale=2, min_width=100, variant="default"):
-                with gr.Tabs() as input_tabs:
-                    with gr.Tab(label="Single Image", id=0) as single_image_input_tab:
-                        image_prompt = gr.Image(label="Input",
-                                            format="png",
-                                            image_mode="RGBA",
-                                            type="pil",
-                                            sources=['upload', 'clipboard'],
-                                            container=True,
-                                            mirror_webcam=True,
-                                            visible=True,
-                                            height=240,
-                                            elem_classes="gr-image-container",
-                                            )
-                    with gr.Tab(label="Multiple Images", id=1) as multiimage_input_tab:
-                        multiimage_prompt = gr.Gallery(label="Images", format="png", type="pil", height=240, columns=3)
-                        gr.Markdown("""
-                            Input different views of the object in separate images.
-                            
-                            *NOTE: this is experimental and may not produce the best results for all images.*
-                        """)
-                        multi_image_process_Button = gr.Button(value="Process Images", visible=True, interactive=True, size="lg", variant="primary")
-
+                image_prompt = gr.Image(
+                    label="Input",
+                    format="png",
+                    image_mode="RGBA",
+                    type="pil",
+                    sources=['upload', 'clipboard'],
+                    container=True,
+                    mirror_webcam=True,
+                    visible=True,
+                    height=240,
+                    elem_classes="gr-image-container",
+                )
 
             with gr.Column(scale=5, min_width=100):
-                video_output = gr.Video(label=" ",
-                                        height=240, # Let CSS handle height
-                                        elem_classes="video-container",
-                                        visible=False,
-                                        autoplay=True,
-                                        loop=True,
-                                        show_download_button=True,
-                                        interactive=False)
+                video_output = gr.Video(
+                    label=" ",
+                    height=240,
+                    elem_classes="video-container",
+                    visible=False,
+                    autoplay=True,
+                    loop=True,
+                    show_download_button=True,
+                    interactive=False,
+                )
+
         with gr.Row(equal_height=False):
             with gr.Column(scale=2, min_width=100, variant="default"):
                 examples = gr.Examples(
@@ -562,50 +346,56 @@ with gr.Blocks(theme='Taithrah/Minimal', css=css, title="Pocket 3D AI") as demo:
                         f'./assets/example_image/{image}'
                         for image in os.listdir("./assets/example_image")
                     ],
-                    inputs=[image_prompt], 
+                    inputs=[image_prompt],
                     examples_per_page=9,
                 )
             with gr.Column(scale=5):
-                model_output = LitModel3D(label="",
-                                         container=True,
-                                         zoom_speed=0.5,
-                                         pan_speed=3.0,
-                                         exposure=10.0, # Adjusted default exposure
-                                         height=360, # Let CSS handle height
-                                         elem_classes="model-container",
-                                         visible=False)
+                model_output = LitModel3D(
+                    label="",
+                    container=True,
+                    zoom_speed=0.5,
+                    pan_speed=3.0,
+                    exposure=10.0,
+                    height=360,
+                    elem_classes="model-container",
+                    visible=False,
+                )
                 stl_download_button = gr.DownloadButton(label="Download STL", visible=False, interactive=False, size="lg", variant="primary")
 
         with gr.Accordion(label="Generation Settings", open=False, visible=not prod):
             seed_slider = gr.Slider(0, MAX_SEED, label="Seed", value=0, step=1)
             randomize_seed = gr.Checkbox(label="Randomize Seed", value=True)
+            resolution_radio = gr.Radio(["512", "1024", "1536"], label="Resolution", value="1024")
             gr.Markdown("Stage 1: Sparse Structure Generation")
             with gr.Row():
-                ss_guidance_strength = gr.Slider(0.0, 10.0, label="Guidance Strength", value=7.5, step=0.1)
+                ss_guidance_strength = gr.Slider(1.0, 10.0, label="Guidance Strength", value=7.5, step=0.1)
                 ss_sampling_steps = gr.Slider(1, 50, label="Sampling Steps", value=12, step=1)
-            gr.Markdown("Stage 2: Structured Latent Generation")
+            gr.Markdown("Stage 2: Shape Generation")
             with gr.Row():
-                slat_guidance_strength = gr.Slider(0.0, 10.0, label="Guidance Strength", value=1.5, step=0.1)
-                slat_sampling_steps = gr.Slider(1, 50, label="Sampling Steps", value=6, step=1)
-            multiimage_algo = gr.Radio(["stochastic", "multidiffusion"], label="Multi-image Algorithm", value="stochastic")
+                shape_guidance_strength = gr.Slider(1.0, 10.0, label="Guidance Strength", value=7.5, step=0.1)
+                shape_sampling_steps = gr.Slider(1, 50, label="Sampling Steps", value=12, step=1)
+            gr.Markdown("Stage 3: Texture Generation")
+            with gr.Row():
+                tex_guidance_strength = gr.Slider(1.0, 10.0, label="Guidance Strength", value=1.0, step=0.1)
+                tex_sampling_steps = gr.Slider(1, 50, label="Sampling Steps", value=12, step=1)
 
         with gr.Accordion(label="GLB Extraction Settings", open=False, visible=not prod):
-            mesh_simplify = gr.Slider(0, 0.98, label="Simplify", value=0.95, step=0.01)
-            texture_size = gr.Slider(512, 4096, label="Texture Size", value=1024, step=512)
-
-    is_multiimage = gr.State(False)
+            mesh_simplify = gr.Slider(100000, 500000, label="Decimation Target", value=300000, step=10000)
+            texture_size = gr.Slider(1024, 4096, label="Texture Size", value=2048, step=1024)
 
     demo.load(start_session)
     demo.unload(end_session)
 
-    single_image_input_tab.select(
-        lambda: False,
-        outputs=[is_multiimage]
-    )
-    multiimage_input_tab.select(
-        lambda: True,
-        outputs=[is_multiimage]
-    )
+    generation_inputs = [
+        image_prompt,
+        seed_slider,
+        resolution_radio,
+        ss_guidance_strength, ss_sampling_steps,
+        shape_guidance_strength, shape_sampling_steps,
+        tex_guidance_strength, tex_sampling_steps,
+        mesh_simplify, texture_size,
+    ]
+    generation_outputs = [video_output, model_output, stl_download_button, output_state]
 
     image_prompt.upload(
         get_seed,
@@ -614,74 +404,13 @@ with gr.Blocks(theme='Taithrah/Minimal', css=css, title="Pocket 3D AI") as demo:
         show_progress="hidden",
         trigger_mode="always_last"
     ).then(
-        fn=process_image_concurrently_yielding,
-        inputs=[
-            image_prompt,
-            multiimage_prompt,
-            is_multiimage,
-            seed_slider,
-            ss_guidance_strength, ss_sampling_steps,
-            slat_guidance_strength, slat_sampling_steps,
-            mesh_simplify, texture_size,
-            multiimage_algo
-        ],
-        outputs=[video_output, model_output, stl_download_button],
+        fn=process_image_yielding,
+        inputs=generation_inputs,
+        outputs=generation_outputs,
         show_progress="hidden",
         scroll_to_output=True,
     )
 
-    multi_image_process_Button.click(
-        get_seed,
-        inputs=[randomize_seed, seed_slider],
-        outputs=[seed_slider],
-        show_progress="hidden",
-        trigger_mode="always_last"
-    ).then(
-        fn=process_image_concurrently_yielding,
-        inputs=[
-            image_prompt,
-            multiimage_prompt,
-            is_multiimage,
-            seed_slider,
-            ss_guidance_strength, ss_sampling_steps,
-            slat_guidance_strength, slat_sampling_steps,
-            mesh_simplify, texture_size,
-            multiimage_algo
-        ],
-        outputs=[video_output, model_output, stl_download_button],
-        show_progress="hidden",
-        scroll_to_output=True,
-    )
-
-    # multiimage_prompt.upload(
-    #     preprocess_images,
-    #     inputs=[multiimage_prompt],
-    #     outputs=[multiimage_prompt],
-    #     show_progress="minimal",
-    # ).then(
-    #     get_seed,
-    #     inputs=[randomize_seed, seed_slider],
-    #     outputs=[seed_slider],
-    #     show_progress="hidden",
-    #     trigger_mode="always_last"
-    # ).then(
-    #     fn=process_image_concurrently_yielding,
-    #     inputs=[
-    #         image_prompt,
-    #         multiimage_prompt,
-    #         is_multiimage,
-    #         seed_slider,
-    #         ss_guidance_strength, ss_sampling_steps,
-    #         slat_guidance_strength, slat_sampling_steps,
-    #         mesh_simplify, texture_size,
-    #         multiimage_algo
-    #     ],
-    #     outputs=[video_output, model_output, stl_download_button],
-    #     show_progress="minimal",
-    #     scroll_to_output=True,
-    # )
-
-
     examples.dataset.select(
         fn=get_seed,
         inputs=[randomize_seed, seed_slider],
@@ -689,51 +418,37 @@ with gr.Blocks(theme='Taithrah/Minimal', css=css, title="Pocket 3D AI") as demo:
         show_progress="hidden",
         trigger_mode="always_last",
     ).then(
-        fn=process_image_concurrently_yielding,
-        inputs=[
-            image_prompt,
-            multiimage_prompt,
-            is_multiimage,
-            seed_slider,
-            ss_guidance_strength, ss_sampling_steps,
-            slat_guidance_strength, slat_sampling_steps,
-            mesh_simplify, texture_size,
-            multiimage_algo
-        ],
-        outputs=[video_output, model_output, stl_download_button],
+        fn=process_image_yielding,
+        inputs=generation_inputs,
+        outputs=generation_outputs,
         show_progress="hidden",
         scroll_to_output=True,
     )
 
-
-    # --- UI Toggling based on Outputs ---
-    @gr.on(triggers=[image_prompt.change], inputs=None, outputs=[video_output, model_output, stl_download_button], show_progress="minimal") # MODIFIED outputs
-    def toggle_outputs_on_new_image(): # RENAMED and MODIFIED
+    @gr.on(triggers=[image_prompt.change], inputs=None, outputs=[video_output, model_output, stl_download_button], show_progress="minimal")
+    def toggle_outputs_on_new_image():
         return (
             gr.update(visible=True, value=None),
-            gr.update(visible=False, value=None), 
+            gr.update(visible=False, value=None),
             gr.update(visible=False, value=None, interactive=False)
         )
-        
-    @gr.on(triggers=[video_output.change], inputs=None, outputs=[model_output, stl_download_button]) # MODIFIED outputs
-    def toggle_model_and_stl_button_visibility(): # RENAMED and MODIFIED
+
+    @gr.on(triggers=[video_output.change], inputs=None, outputs=[model_output, stl_download_button])
+    def toggle_model_and_stl_visibility():
         return (
-            gr.update(label="Interactive 3D Model", visible=True), 
+            gr.update(label="Interactive 3D Model", visible=True),
             gr.update(visible=True)
         )
-        
+
     @gr.on(triggers=[video_output.change], inputs=None, outputs=video_output, show_progress="hidden")
     def toggle_label():
         return gr.update(label="Double Tap To Play", visible=True)
 
 
-print(f"[DIAG] reached launch section, __name__={__name__}", flush=True)
 if __name__ == "__main__":
-    print("[DIAG] inside __main__ block", flush=True)
-
     if pipeline is None:
         logger.critical("Pipeline failed to initialize. Exiting.")
-        sys.exit(1) # Exit if pipeline isn't ready
+        sys.exit(1)
 
     running_on_spaces = bool(os.getenv("SPACE_ID"))
 
@@ -764,4 +479,4 @@ if __name__ == "__main__":
             debug=True,
             share=True,
             allowed_paths=["./cache", "./assets"]
-        )
+        )

assets/hdri/license.txt

@@ -0,0 +1,15 @@
+All HDRIs are licensed as CC0.
+
+These were created by Greg Zaal (Poly Haven https://polyhaven.com).
+Originals used for each HDRI:
+- City: https://polyhaven.com/a/portland_landing_pad
+- Courtyard: https://polyhaven.com/a/courtyard
+- Forest: https://polyhaven.com/a/ninomaru_teien
+- Interior: https://polyhaven.com/a/hotel_room
+- Night: Probably https://polyhaven.com/a/moonless_golf
+- Studio: Probably https://polyhaven.com/a/studio_small_01
+- Sunrise: https://polyhaven.com/a/spruit_sunrise
+- Sunset: https://polyhaven.com/a/venice_sunset
+
+1K resolution of each was taken, and compressed with oiiotool:
+oiiotool input.exr --ch R,G,B -d float --compression dwab:300 --clamp:min=0.0:max=32000.0 -o output.exr

extensions/nvdiffrast/LICENSE.txt

@@ -1,97 +0,0 @@
-Copyright (c) 2020, NVIDIA Corporation. All rights reserved.
-
-
-Nvidia Source Code License (1-Way Commercial)
-
-=======================================================================
-
-1. Definitions
-
-"Licensor" means any person or entity that distributes its Work.
-
-"Software" means the original work of authorship made available under
-this License.
-
-"Work" means the Software and any additions to or derivative works of
-the Software that are made available under this License.
-
-The terms "reproduce," "reproduction," "derivative works," and
-"distribution" have the meaning as provided under U.S. copyright law;
-provided, however, that for the purposes of this License, derivative
-works shall not include works that remain separable from, or merely
-link (or bind by name) to the interfaces of, the Work.
-
-Works, including the Software, are "made available" under this License
-by including in or with the Work either (a) a copyright notice
-referencing the applicability of this License to the Work, or (b) a
-copy of this License.
-
-2. License Grants
-
-    2.1 Copyright Grant. Subject to the terms and conditions of this
-    License, each Licensor grants to you a perpetual, worldwide,
-    non-exclusive, royalty-free, copyright license to reproduce,
-    prepare derivative works of, publicly display, publicly perform,
-    sublicense and distribute its Work and any resulting derivative
-    works in any form.
-
-3. Limitations
-
-    3.1 Redistribution. You may reproduce or distribute the Work only
-    if (a) you do so under this License, (b) you include a complete
-    copy of this License with your distribution, and (c) you retain
-    without modification any copyright, patent, trademark, or
-    attribution notices that are present in the Work.
-
-    3.2 Derivative Works. You may specify that additional or different
-    terms apply to the use, reproduction, and distribution of your
-    derivative works of the Work ("Your Terms") only if (a) Your Terms
-    provide that the use limitation in Section 3.3 applies to your
-    derivative works, and (b) you identify the specific derivative
-    works that are subject to Your Terms. Notwithstanding Your Terms,
-    this License (including the redistribution requirements in Section
-    3.1) will continue to apply to the Work itself.
-
-    3.3 Use Limitation. The Work and any derivative works thereof only
-    may be used or intended for use non-commercially. The Work or
-    derivative works thereof may be used or intended for use by Nvidia
-    or its affiliates commercially or non-commercially. As used herein,
-    "non-commercially" means for research or evaluation purposes only
-    and not for any direct or indirect monetary gain.
-
-    3.4 Patent Claims. If you bring or threaten to bring a patent claim
-    against any Licensor (including any claim, cross-claim or
-    counterclaim in a lawsuit) to enforce any patents that you allege
-    are infringed by any Work, then your rights under this License from
-    such Licensor (including the grant in Section 2.1) will terminate
-    immediately.
-
-    3.5 Trademarks. This License does not grant any rights to use any
-    Licensor's or its affiliates' names, logos, or trademarks, except
-    as necessary to reproduce the notices described in this License.
-
-    3.6 Termination. If you violate any term of this License, then your
-    rights under this License (including the grant in Section 2.1) will
-    terminate immediately.
-
-4. Disclaimer of Warranty.
-
-THE WORK IS PROVIDED "AS IS" WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OR CONDITIONS OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR
-NON-INFRINGEMENT. YOU BEAR THE RISK OF UNDERTAKING ANY ACTIVITIES UNDER
-THIS LICENSE.
-
-5. Limitation of Liability.
-
-EXCEPT AS PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL
-THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE
-SHALL ANY LICENSOR BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT,
-INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
-OR RELATED TO THIS LICENSE, THE USE OR INABILITY TO USE THE WORK
-(INCLUDING BUT NOT LIMITED TO LOSS OF GOODWILL, BUSINESS INTERRUPTION,
-LOST PROFITS OR DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY OTHER
-COMMERCIAL DAMAGES OR LOSSES), EVEN IF THE LICENSOR HAS BEEN ADVISED OF
-THE POSSIBILITY OF SUCH DAMAGES.
-
-=======================================================================

extensions/nvdiffrast/README.md

@@ -1,42 +0,0 @@
-## Nvdiffrast – Modular Primitives for High-Performance Differentiable Rendering
-
-![Teaser image](./docs/img/teaser.png)
-
-**Modular Primitives for High-Performance Differentiable Rendering**<br>
-Samuli Laine, Janne Hellsten, Tero Karras, Yeongho Seol, Jaakko Lehtinen, Timo Aila<br>
-[http://arxiv.org/abs/2011.03277](http://arxiv.org/abs/2011.03277)
-
-Nvdiffrast is a PyTorch/TensorFlow library that provides high-performance primitive operations for rasterization-based differentiable rendering.
-Please refer to &#x261E;&#x261E; [nvdiffrast documentation](https://nvlabs.github.io/nvdiffrast) &#x261C;&#x261C; for more information.
-
-## Licenses
-
-Copyright &copy; 2020&ndash;2024, NVIDIA Corporation. All rights reserved.
-
-This work is made available under the [Nvidia Source Code License](https://github.com/NVlabs/nvdiffrast/blob/main/LICENSE.txt).
-
-For business inquiries, please visit our website and submit the form: [NVIDIA Research Licensing](https://www.nvidia.com/en-us/research/inquiries/)
-
-We do not currently accept outside code contributions in the form of pull requests.
-
-Environment map stored as part of `samples/data/envphong.npz` is derived from a Wave Engine
-[sample material](https://github.com/WaveEngine/Samples-2.5/tree/master/Materials/EnvironmentMap/Content/Assets/CubeMap.cubemap)
-originally shared under 
-[MIT License](https://github.com/WaveEngine/Samples-2.5/blob/master/LICENSE.md).
-Mesh and texture stored as part of `samples/data/earth.npz` are derived from
-[3D Earth Photorealistic 2K](https://www.turbosquid.com/3d-models/3d-realistic-earth-photorealistic-2k-1279125)
-model originally made available under
-[TurboSquid 3D Model License](https://blog.turbosquid.com/turbosquid-3d-model-license/#3d-model-license).
-
-## Citation
-
-```
-@article{Laine2020diffrast,
-  title   = {Modular Primitives for High-Performance Differentiable Rendering},
-  author  = {Samuli Laine and Janne Hellsten and Tero Karras and Yeongho Seol and Jaakko Lehtinen and Timo Aila},
-  journal = {ACM Transactions on Graphics},
-  year    = {2020},
-  volume  = {39},
-  number  = {6}
-}
-```

extensions/nvdiffrast/nvdiffrast/__init__.py

@@ -1,9 +0,0 @@
-# Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-__version__ = '0.3.3'

extensions/nvdiffrast/nvdiffrast/common/antialias.cu

@@ -1,558 +0,0 @@
-// Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#include "antialias.h"
-
-//------------------------------------------------------------------------
-// Helpers.
-
-#define F32_MAX (3.402823466e+38f)
-static __forceinline__ __device__ bool same_sign(float a, float b) { return (__float_as_int(a) ^ __float_as_int(b)) >= 0; }
-static __forceinline__ __device__ bool rational_gt(float n0, float n1, float d0, float d1) { return (n0*d1 > n1*d0) == same_sign(d0, d1); }
-static __forceinline__ __device__ int max_idx3(float n0, float n1, float n2, float d0, float d1, float d2)
-{
-    bool g10 = rational_gt(n1, n0, d1, d0);
-    bool g20 = rational_gt(n2, n0, d2, d0);
-    bool g21 = rational_gt(n2, n1, d2, d1);
-    if (g20 && g21) return 2;
-    if (g10) return 1;
-    return 0;
-}
-
-//------------------------------------------------------------------------
-// Format of antialiasing work items stored in work buffer. Usually accessed directly as int4.
-
-struct AAWorkItem
-{
-    enum
-    {
-        EDGE_MASK       = 3,    // Edge index in lowest bits.
-        FLAG_DOWN_BIT   = 2,    // Down instead of right.
-        FLAG_TRI1_BIT   = 3,    // Edge is from other pixel's triangle.
-    };
-
-    int             px, py;         // Pixel x, y.
-    unsigned int    pz_flags;       // High 16 bits = pixel z, low 16 bits = edge index and flags.
-    float           alpha;          // Antialiasing alpha value. Zero if no AA.
-};
-
-//------------------------------------------------------------------------
-// Hash functions. Adapted from public-domain code at http://www.burtleburtle.net/bob/hash/doobs.html
-
-#define JENKINS_MAGIC (0x9e3779b9u)
-static __device__ __forceinline__ void jenkins_mix(unsigned int& a, unsigned int& b, unsigned int& c)
-{
-    a -= b; a -= c; a ^= (c>>13);
-    b -= c; b -= a; b ^= (a<<8);
-    c -= a; c -= b; c ^= (b>>13);
-    a -= b; a -= c; a ^= (c>>12);
-    b -= c; b -= a; b ^= (a<<16);
-    c -= a; c -= b; c ^= (b>>5);
-    a -= b; a -= c; a ^= (c>>3);
-    b -= c; b -= a; b ^= (a<<10);
-    c -= a; c -= b; c ^= (b>>15);
-}
-
-// Helper class for hash index iteration. Implements simple odd-skip linear probing with a key-dependent skip.
-class HashIndex
-{
-public:
-    __device__ __forceinline__ HashIndex(const AntialiasKernelParams& p, uint64_t key)
-    {
-        m_mask = (p.allocTriangles << AA_LOG_HASH_ELEMENTS_PER_TRIANGLE(p.allocTriangles)) - 1; // This should work until triangle count exceeds 1073741824.
-        m_idx  = (uint32_t)(key & 0xffffffffu);
-        m_skip = (uint32_t)(key >> 32);
-        uint32_t dummy = JENKINS_MAGIC;
-        jenkins_mix(m_idx, m_skip, dummy);
-        m_idx &= m_mask;
-        m_skip &= m_mask;
-        m_skip |= 1;
-    }
-    __device__ __forceinline__ int get(void) const { return m_idx; }
-    __device__ __forceinline__ void next(void) { m_idx = (m_idx + m_skip) & m_mask; }
-private:
-    uint32_t m_idx, m_skip, m_mask;
-};
-
-static __device__ __forceinline__ void hash_insert(const AntialiasKernelParams& p, uint64_t key, int v)
-{
-    HashIndex idx(p, key);
-    while(1)
-    {
-        uint64_t prev = atomicCAS((unsigned long long*)&p.evHash[idx.get()], 0, (unsigned long long)key);
-        if (prev == 0 || prev == key)
-            break;
-        idx.next();
-    }
-    int* q = (int*)&p.evHash[idx.get()];
-    int a = atomicCAS(q+2, 0, v);
-    if (a != 0 && a != v)
-        atomicCAS(q+3, 0, v);
-}
-
-static __device__ __forceinline__ int2 hash_find(const AntialiasKernelParams& p, uint64_t key)
-{
-    HashIndex idx(p, key);
-    while(1)
-    {
-        uint4 entry = p.evHash[idx.get()];
-        uint64_t k = ((uint64_t)entry.x) | (((uint64_t)entry.y) << 32);
-        if (k == key || k == 0)
-            return make_int2((int)entry.z, (int)entry.w);
-        idx.next();
-    }
-}
-
-static __device__ __forceinline__ void evhash_insert_vertex(const AntialiasKernelParams& p, int va, int vb, int vn)
-{
-    if (va == vb)
-        return;
-    
-    uint64_t v0 = (uint32_t)min(va, vb) + 1; // canonical vertex order
-    uint64_t v1 = (uint32_t)max(va, vb) + 1;
-    uint64_t vk = v0 | (v1 << 32); // hash key
-    hash_insert(p, vk, vn + 1);
-}
-
-static __forceinline__ __device__ int evhash_find_vertex(const AntialiasKernelParams& p, int va, int vb, int vr)
-{
-    if (va == vb)
-        return -1;
-
-    uint64_t v0 = (uint32_t)min(va, vb) + 1; // canonical vertex order
-    uint64_t v1 = (uint32_t)max(va, vb) + 1;
-    uint64_t vk = v0 | (v1 << 32); // hash key
-    int2 vn = hash_find(p, vk) - 1;
-    if (vn.x == vr) return vn.y;
-    if (vn.y == vr) return vn.x;
-    return -1;
-}
-
-//------------------------------------------------------------------------
-// Mesh analysis kernel.
-
-__global__ void AntialiasFwdMeshKernel(const AntialiasKernelParams p)
-{
-    int idx = threadIdx.x + blockIdx.x * blockDim.x;
-    if (idx >= p.numTriangles)
-        return;
-
-    int v0 = p.tri[idx * 3 + 0];
-    int v1 = p.tri[idx * 3 + 1];
-    int v2 = p.tri[idx * 3 + 2];
-
-    if (v0 < 0 || v0 >= p.numVertices ||
-        v1 < 0 || v1 >= p.numVertices ||
-        v2 < 0 || v2 >= p.numVertices)
-        return;
-
-    if (v0 == v1 || v1 == v2 || v2 == v0)
-        return;
-
-    evhash_insert_vertex(p, v1, v2, v0);
-    evhash_insert_vertex(p, v2, v0, v1);
-    evhash_insert_vertex(p, v0, v1, v2);
-}
-
-//------------------------------------------------------------------------
-// Discontinuity finder kernel.
-
-__global__ void AntialiasFwdDiscontinuityKernel(const AntialiasKernelParams p)
-{
-    // Calculate pixel position.
-    int px = blockIdx.x * AA_DISCONTINUITY_KERNEL_BLOCK_WIDTH + threadIdx.x;
-    int py = blockIdx.y * AA_DISCONTINUITY_KERNEL_BLOCK_HEIGHT + threadIdx.y;
-    int pz = blockIdx.z;
-    if (px >= p.width || py >= p.height || pz >= p.n)
-        return;
-
-    // Pointer to our TriIdx and fetch.
-    int pidx0 = ((px + p.width * (py + p.height * pz)) << 2) + 3;
-    float tri0 = p.rasterOut[pidx0]; // These can stay as float, as we only compare them against each other.
-
-    // Look right, clamp at edge.
-    int pidx1 = pidx0;
-    if (px < p.width - 1)
-        pidx1 += 4;
-    float tri1 = p.rasterOut[pidx1];
-
-    // Look down, clamp at edge.
-    int pidx2 = pidx0;
-    if (py < p.height - 1)
-        pidx2 += p.width << 2;
-    float tri2 = p.rasterOut[pidx2];
-
-    // Determine amount of work.
-    int count = 0;
-    if (tri1 != tri0) count  = 1;
-    if (tri2 != tri0) count += 1;
-    if (!count)
-        return; // Exit warp.
-
-    // Coalesce work counter update to once per CTA.
-    __shared__ int s_temp;
-    s_temp = 0;
-    __syncthreads();
-    int idx = atomicAdd(&s_temp, count);
-    __syncthreads();
-    if (idx == 0)
-    {
-        int base = atomicAdd(&p.workBuffer[0].x, s_temp);
-        s_temp = base + 1; // don't clobber the counters in first slot.
-    }
-    __syncthreads();
-    idx += s_temp;
-
-    // Write to memory.
-    if (tri1 != tri0) p.workBuffer[idx++] = make_int4(px, py, (pz << 16), 0);
-    if (tri2 != tri0) p.workBuffer[idx]   = make_int4(px, py, (pz << 16) + (1 << AAWorkItem::FLAG_DOWN_BIT), 0);
-}
-
-//------------------------------------------------------------------------
-// Forward analysis kernel.
-
-__global__ void AntialiasFwdAnalysisKernel(const AntialiasKernelParams p)
-{
-    __shared__ int s_base;
-    int workCount = p.workBuffer[0].x;
-    for(;;)
-    {
-        // Persistent threads work fetcher.
-        __syncthreads();
-        if (threadIdx.x == 0)
-            s_base = atomicAdd(&p.workBuffer[0].y, AA_ANALYSIS_KERNEL_THREADS_PER_BLOCK);
-        __syncthreads();
-        int thread_idx = s_base + threadIdx.x;
-        if (thread_idx >= workCount)
-            return;
-
-        int4* pItem = p.workBuffer + thread_idx + 1;
-        int4 item = *pItem;
-        int px = item.x;
-        int py = item.y;
-        int pz = (int)(((unsigned int)item.z) >> 16);
-        int d  = (item.z >> AAWorkItem::FLAG_DOWN_BIT) & 1;
-
-        int pixel0 = px + p.width * (py + p.height * pz);
-        int pixel1 = pixel0 + (d ? p.width : 1);
-        float2 zt0 = ((float2*)p.rasterOut)[(pixel0 << 1) + 1];
-        float2 zt1 = ((float2*)p.rasterOut)[(pixel1 << 1) + 1];
-        int tri0 = float_to_triidx(zt0.y) - 1;
-        int tri1 = float_to_triidx(zt1.y) - 1;
-
-        // Select triangle based on background / depth.
-        int tri = (tri0 >= 0) ? tri0 : tri1;
-        if (tri0 >= 0 && tri1 >= 0)
-            tri = (zt0.x < zt1.x) ? tri0 : tri1;
-        if (tri == tri1)
-        {
-            // Calculate with respect to neighbor pixel if chose that triangle.
-            px += 1 - d;
-            py += d;
-        }
-
-        // Bail out if triangle index is corrupt.
-        if (tri < 0 || tri >= p.numTriangles)
-            continue;
-
-        // Fetch vertex indices.
-        int vi0 = p.tri[tri * 3 + 0];
-        int vi1 = p.tri[tri * 3 + 1];
-        int vi2 = p.tri[tri * 3 + 2];
-
-        // Bail out if vertex indices are corrupt.
-        if (vi0 < 0 || vi0 >= p.numVertices ||
-            vi1 < 0 || vi1 >= p.numVertices ||
-            vi2 < 0 || vi2 >= p.numVertices)
-            continue;
-
-        // Fetch opposite vertex indices. Use vertex itself (always silhouette) if no opposite vertex exists.
-        int op0 = evhash_find_vertex(p, vi2, vi1, vi0);
-        int op1 = evhash_find_vertex(p, vi0, vi2, vi1);
-        int op2 = evhash_find_vertex(p, vi1, vi0, vi2);
-
-        // Instance mode: Adjust vertex indices based on minibatch index.
-        if (p.instance_mode)
-        {
-            int vbase = pz * p.numVertices;
-            vi0 += vbase;
-            vi1 += vbase;
-            vi2 += vbase;
-            if (op0 >= 0) op0 += vbase;
-            if (op1 >= 0) op1 += vbase;
-            if (op2 >= 0) op2 += vbase;
-        }
-
-        // Fetch vertex positions.
-        float4 p0 = ((float4*)p.pos)[vi0];
-        float4 p1 = ((float4*)p.pos)[vi1];
-        float4 p2 = ((float4*)p.pos)[vi2];
-        float4 o0 = (op0 < 0) ? p0 : ((float4*)p.pos)[op0];
-        float4 o1 = (op1 < 0) ? p1 : ((float4*)p.pos)[op1];
-        float4 o2 = (op2 < 0) ? p2 : ((float4*)p.pos)[op2];
-
-        // Project vertices to pixel space.
-        float w0  = 1.f / p0.w;
-        float w1  = 1.f / p1.w;
-        float w2  = 1.f / p2.w;
-        float ow0 = 1.f / o0.w;
-        float ow1 = 1.f / o1.w;
-        float ow2 = 1.f / o2.w;
-        float fx  = (float)px + .5f - p.xh;
-        float fy  = (float)py + .5f - p.yh;
-        float x0  = p0.x * w0 * p.xh - fx;
-        float y0  = p0.y * w0 * p.yh - fy;
-        float x1  = p1.x * w1 * p.xh - fx;
-        float y1  = p1.y * w1 * p.yh - fy;
-        float x2  = p2.x * w2 * p.xh - fx;
-        float y2  = p2.y * w2 * p.yh - fy;
-        float ox0 = o0.x * ow0 * p.xh - fx;
-        float oy0 = o0.y * ow0 * p.yh - fy;
-        float ox1 = o1.x * ow1 * p.xh - fx;
-        float oy1 = o1.y * ow1 * p.yh - fy;
-        float ox2 = o2.x * ow2 * p.xh - fx;
-        float oy2 = o2.y * ow2 * p.yh - fy;
-
-        // Signs to kill non-silhouette edges.
-        float bb = (x1-x0)*(y2-y0) - (x2-x0)*(y1-y0); // Triangle itself.
-        float a0 = (x1-ox0)*(y2-oy0) - (x2-ox0)*(y1-oy0); // Wings.
-        float a1 = (x2-ox1)*(y0-oy1) - (x0-ox1)*(y2-oy1);
-        float a2 = (x0-ox2)*(y1-oy2) - (x1-ox2)*(y0-oy2);
-
-        // If no matching signs anywhere, skip the rest.
-        if (same_sign(a0, bb) || same_sign(a1, bb) || same_sign(a2, bb))
-        {
-            // XY flip for horizontal edges.
-            if (d)
-            {
-                swap(x0, y0);
-                swap(x1, y1);
-                swap(x2, y2);
-            }
-
-            float dx0 = x2 - x1;
-            float dx1 = x0 - x2;
-            float dx2 = x1 - x0;
-            float dy0 = y2 - y1;
-            float dy1 = y0 - y2;
-            float dy2 = y1 - y0;
-
-            // Check if an edge crosses between us and the neighbor pixel.
-            float dc = -F32_MAX;
-            float ds = (tri == tri0) ? 1.f : -1.f;
-            float d0 = ds * (x1*dy0 - y1*dx0);
-            float d1 = ds * (x2*dy1 - y2*dx1);
-            float d2 = ds * (x0*dy2 - y0*dx2);
-
-            if (same_sign(y1, y2)) d0 = -F32_MAX, dy0 = 1.f;
-            if (same_sign(y2, y0)) d1 = -F32_MAX, dy1 = 1.f;
-            if (same_sign(y0, y1)) d2 = -F32_MAX, dy2 = 1.f;
-
-            int di = max_idx3(d0, d1, d2, dy0, dy1, dy2);
-            if (di == 0 && same_sign(a0, bb) && fabsf(dy0) >= fabsf(dx0)) dc = d0 / dy0;
-            if (di == 1 && same_sign(a1, bb) && fabsf(dy1) >= fabsf(dx1)) dc = d1 / dy1;
-            if (di == 2 && same_sign(a2, bb) && fabsf(dy2) >= fabsf(dx2)) dc = d2 / dy2;
-            float eps = .0625f; // Expect no more than 1/16 pixel inaccuracy.
-
-            // Adjust output image if a suitable edge was found.
-            if (dc > -eps && dc < 1.f + eps)
-            {
-                dc = fminf(fmaxf(dc, 0.f), 1.f);
-                float alpha = ds * (.5f - dc);
-                const float* pColor0 = p.color + pixel0 * p.channels;
-                const float* pColor1 = p.color + pixel1 * p.channels;
-                float* pOutput = p.output + (alpha > 0.f ? pixel0 : pixel1) * p.channels;
-                for (int i=0; i < p.channels; i++)
-                    atomicAdd(&pOutput[i], alpha * (pColor1[i] - pColor0[i]));
-
-                // Rewrite the work item's flags and alpha. Keep original px, py.
-                unsigned int flags = pz << 16;
-                flags |= di;
-                flags |= d << AAWorkItem::FLAG_DOWN_BIT;
-                flags |= (__float_as_uint(ds) >> 31) << AAWorkItem::FLAG_TRI1_BIT;
-                ((int2*)pItem)[1] = make_int2(flags, __float_as_int(alpha));
-            }
-        }
-    }
-}
-
-//------------------------------------------------------------------------
-// Gradient kernel.
-
-__global__ void AntialiasGradKernel(const AntialiasKernelParams p)
-{
-    // Temporary space for coalesced atomics.
-    CA_DECLARE_TEMP(AA_GRAD_KERNEL_THREADS_PER_BLOCK);
-    __shared__ int s_base; // Work counter communication across entire CTA.
-
-    int workCount = p.workBuffer[0].x;
-
-    for(;;)
-    {
-        // Persistent threads work fetcher.
-        __syncthreads();
-        if (threadIdx.x == 0)
-            s_base = atomicAdd(&p.workBuffer[0].y, AA_GRAD_KERNEL_THREADS_PER_BLOCK);
-        __syncthreads();
-        int thread_idx = s_base + threadIdx.x;
-        if (thread_idx >= workCount)
-            return;
-
-        // Read work item filled out by forward kernel.
-        int4 item = p.workBuffer[thread_idx + 1];
-        unsigned int amask = __ballot_sync(0xffffffffu, item.w);
-        if (item.w == 0)
-            continue; // No effect.
-
-        // Unpack work item and replicate setup from forward analysis kernel.
-        int px = item.x;
-        int py = item.y;
-        int pz = (int)(((unsigned int)item.z) >> 16);
-        int d = (item.z >> AAWorkItem::FLAG_DOWN_BIT) & 1;
-        float alpha = __int_as_float(item.w);
-        int tri1 = (item.z >> AAWorkItem::FLAG_TRI1_BIT) & 1;
-        int di = item.z & AAWorkItem::EDGE_MASK;
-        float ds = __int_as_float(__float_as_int(1.0) | (tri1 << 31));
-        int pixel0 = px + p.width * (py + p.height * pz);
-        int pixel1 = pixel0 + (d ? p.width : 1);
-        int tri = float_to_triidx(p.rasterOut[((tri1 ? pixel1 : pixel0) << 2) + 3]) - 1;
-        if (tri1)
-        {
-            px += 1 - d;
-            py += d;
-        }
-
-        // Bail out if triangle index is corrupt.
-        bool triFail = (tri < 0 || tri >= p.numTriangles);
-        amask = __ballot_sync(amask, !triFail);
-        if (triFail)
-            continue;
-
-        // Outgoing color gradients.
-        float* pGrad0 = p.gradColor + pixel0 * p.channels;
-        float* pGrad1 = p.gradColor + pixel1 * p.channels;
-
-        // Incoming color gradients.
-        const float* pDy = p.dy + (alpha > 0.f ? pixel0 : pixel1) * p.channels;
-
-        // Position gradient weight based on colors and incoming gradients.
-        float dd = 0.f;
-        const float* pColor0 = p.color + pixel0 * p.channels;
-        const float* pColor1 = p.color + pixel1 * p.channels;
-
-        // Loop over channels and accumulate.
-        for (int i=0; i < p.channels; i++)
-        {
-            float dy = pDy[i];
-            if (dy != 0.f)
-            {
-                // Update position gradient weight.
-                dd += dy * (pColor1[i] - pColor0[i]);
-
-                // Update color gradients. No coalescing because all have different targets.
-                float v = alpha * dy;
-                atomicAdd(&pGrad0[i], -v);
-                atomicAdd(&pGrad1[i], v);
-            }
-        }
-
-        // If position weight is zero, skip the rest.
-        bool noGrad = (dd == 0.f);
-        amask = __ballot_sync(amask, !noGrad);
-        if (noGrad)
-            continue;
-
-        // Fetch vertex indices of the active edge and their positions.
-        int i1 = (di < 2) ? (di + 1) : 0;
-        int i2 = (i1 < 2) ? (i1 + 1) : 0;
-        int vi1 = p.tri[3 * tri + i1];
-        int vi2 = p.tri[3 * tri + i2];
-
-        // Bail out if vertex indices are corrupt.
-        bool vtxFail = (vi1 < 0 || vi1 >= p.numVertices || vi2 < 0 || vi2 >= p.numVertices);
-        amask = __ballot_sync(amask, !vtxFail);
-        if (vtxFail)
-            continue;
-
-        // Instance mode: Adjust vertex indices based on minibatch index.
-        if (p.instance_mode)
-        {
-            vi1 += pz * p.numVertices;
-            vi2 += pz * p.numVertices;
-        }
-
-        // Fetch vertex positions.
-        float4 p1 = ((float4*)p.pos)[vi1];
-        float4 p2 = ((float4*)p.pos)[vi2];
-
-        // Project vertices to pixel space.
-        float pxh = p.xh;
-        float pyh = p.yh;
-        float fx = (float)px + .5f - pxh;
-        float fy = (float)py + .5f - pyh;
-
-        // XY flip for horizontal edges.
-        if (d)
-        {
-            swap(p1.x, p1.y);
-            swap(p2.x, p2.y);
-            swap(pxh, pyh);
-            swap(fx, fy);
-        }
-
-        // Gradient calculation setup.
-        float w1 = 1.f / p1.w;
-        float w2 = 1.f / p2.w;
-        float x1 = p1.x * w1 * pxh - fx;
-        float y1 = p1.y * w1 * pyh - fy;
-        float x2 = p2.x * w2 * pxh - fx;
-        float y2 = p2.y * w2 * pyh - fy;
-        float dx = x2 - x1;
-        float dy = y2 - y1;
-        float db = x1*dy - y1*dx;
-
-        // Compute inverse delta-y with epsilon.
-        float ep = copysignf(1e-3f, dy); // ~1/1000 pixel.
-        float iy = 1.f / (dy + ep);
-
-        // Compute position gradients.
-        float dby = db * iy;
-        float iw1 = -w1 * iy * dd;
-        float iw2 =  w2 * iy * dd;
-        float gp1x = iw1 * pxh * y2;
-        float gp2x = iw2 * pxh * y1;
-        float gp1y = iw1 * pyh * (dby - x2);
-        float gp2y = iw2 * pyh * (dby - x1);
-        float gp1w = -(p1.x * gp1x + p1.y * gp1y) * w1;
-        float gp2w = -(p2.x * gp2x + p2.y * gp2y) * w2;
-
-        // XY flip the gradients.
-        if (d)
-        {
-            swap(gp1x, gp1y);
-            swap(gp2x, gp2y);
-        }
-
-        // Kill position gradients if alpha was saturated.
-        if (fabsf(alpha) >= 0.5f)
-        {
-            gp1x = gp1y = gp1w = 0.f;
-            gp2x = gp2y = gp2w = 0.f;
-        }
-
-        // Initialize coalesced atomics. Match both triangle ID and edge index.
-        // Also note that some threads may be inactive.
-        CA_SET_GROUP_MASK(tri ^ (di << 30), amask);
-
-        // Accumulate gradients.
-        caAtomicAdd3_xyw(p.gradPos + 4 * vi1, gp1x, gp1y, gp1w);
-        caAtomicAdd3_xyw(p.gradPos + 4 * vi2, gp2x, gp2y, gp2w);
-    }
-}
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/antialias.h

@@ -1,50 +0,0 @@
-// Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#pragma once
-#include "common.h"
-
-//------------------------------------------------------------------------
-// Constants and helpers.
-
-#define AA_DISCONTINUITY_KERNEL_BLOCK_WIDTH         32
-#define AA_DISCONTINUITY_KERNEL_BLOCK_HEIGHT        8
-#define AA_ANALYSIS_KERNEL_THREADS_PER_BLOCK        256
-#define AA_MESH_KERNEL_THREADS_PER_BLOCK            256
-#define AA_HASH_ELEMENTS_PER_TRIANGLE(alloc)        ((alloc) >= (2 << 25) ? 4 : 8) // With more than 16777216 triangles (alloc >= 33554432) use smallest possible value of 4 to conserve memory, otherwise use 8 for fewer collisions.
-#define AA_LOG_HASH_ELEMENTS_PER_TRIANGLE(alloc)    ((alloc) >= (2 << 25) ? 2 : 3)
-#define AA_GRAD_KERNEL_THREADS_PER_BLOCK            256
-
-//------------------------------------------------------------------------
-// CUDA kernel params.
-
-struct AntialiasKernelParams
-{
-    const float*    color;          // Incoming color buffer.
-    const float*    rasterOut;      // Incoming rasterizer output buffer.
-    const int*      tri;            // Incoming triangle buffer.
-    const float*    pos;            // Incoming position buffer.
-    float*          output;         // Output buffer of forward kernel.
-    const float*    dy;             // Incoming gradients.
-    float*          gradColor;      // Output buffer, color gradient.
-    float*          gradPos;        // Output buffer, position gradient.
-    int4*           workBuffer;     // Buffer for storing intermediate work items. First item reserved for counters.
-    uint4*          evHash;         // Edge-vertex hash.
-    int             allocTriangles; // Number of triangles accommodated by evHash. Always power of two.
-    int             numTriangles;   // Number of triangles.
-    int             numVertices;    // Number of vertices.
-    int             width;          // Input width.
-    int             height;         // Input height.
-    int             n;              // Minibatch size.
-    int             channels;       // Channel count in color input.
-    float           xh, yh;         // Transfer to pixel space.
-    int             instance_mode;  // 0=normal, 1=instance mode.
-    int             tri_const;      // 1 if triangle array is known to be constant.
-};
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/common.cpp

@@ -1,60 +0,0 @@
-// Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#include <cuda_runtime.h>
-
-//------------------------------------------------------------------------
-// Block and grid size calculators for kernel launches.
-
-dim3 getLaunchBlockSize(int maxWidth, int maxHeight, int width, int height)
-{
-    int maxThreads = maxWidth * maxHeight;
-    if (maxThreads <= 1 || (width * height) <= 1)
-        return dim3(1, 1, 1); // Degenerate.
-
-    // Start from max size.
-    int bw = maxWidth;
-    int bh = maxHeight;
-
-    // Optimizations for weirdly sized buffers.
-    if (width < bw)
-    {
-        // Decrease block width to smallest power of two that covers the buffer width.
-        while ((bw >> 1) >= width)
-            bw >>= 1;
-
-        // Maximize height.
-        bh = maxThreads / bw;
-        if (bh > height)
-            bh = height;
-    }
-    else if (height < bh)
-    {
-        // Halve height and double width until fits completely inside buffer vertically.
-        while (bh > height)
-        {
-            bh >>= 1;
-            if (bw < width)
-                bw <<= 1;
-        }
-    }
-
-    // Done.
-    return dim3(bw, bh, 1);
-}
-
-dim3 getLaunchGridSize(dim3 blockSize, int width, int height, int depth)
-{
-    dim3 gridSize;
-    gridSize.x = (width  - 1) / blockSize.x + 1;
-    gridSize.y = (height - 1) / blockSize.y + 1;
-    gridSize.z = (depth  - 1) / blockSize.z + 1;
-    return gridSize;
-}
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/common.h

@@ -1,263 +0,0 @@
-// Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#pragma once
-#include <cuda.h>
-#include <stdint.h>
-
-//------------------------------------------------------------------------
-// C++ helper function prototypes.
-
-dim3 getLaunchBlockSize(int maxWidth, int maxHeight, int width, int height);
-dim3 getLaunchGridSize(dim3 blockSize, int width, int height, int depth);
-
-//------------------------------------------------------------------------
-// The rest is CUDA device code specific stuff.
-
-#ifdef __CUDACC__
-
-//------------------------------------------------------------------------
-// Helpers for CUDA vector types.
-
-static __device__ __forceinline__ float2&   operator*=  (float2& a, const float2& b)       { a.x *= b.x; a.y *= b.y; return a; }
-static __device__ __forceinline__ float2&   operator+=  (float2& a, const float2& b)       { a.x += b.x; a.y += b.y; return a; }
-static __device__ __forceinline__ float2&   operator-=  (float2& a, const float2& b)       { a.x -= b.x; a.y -= b.y; return a; }
-static __device__ __forceinline__ float2&   operator*=  (float2& a, float b)               { a.x *= b; a.y *= b; return a; }
-static __device__ __forceinline__ float2&   operator+=  (float2& a, float b)               { a.x += b; a.y += b; return a; }
-static __device__ __forceinline__ float2&   operator-=  (float2& a, float b)               { a.x -= b; a.y -= b; return a; }
-static __device__ __forceinline__ float2    operator*   (const float2& a, const float2& b) { return make_float2(a.x * b.x, a.y * b.y); }
-static __device__ __forceinline__ float2    operator+   (const float2& a, const float2& b) { return make_float2(a.x + b.x, a.y + b.y); }
-static __device__ __forceinline__ float2    operator-   (const float2& a, const float2& b) { return make_float2(a.x - b.x, a.y - b.y); }
-static __device__ __forceinline__ float2    operator*   (const float2& a, float b)         { return make_float2(a.x * b, a.y * b); }
-static __device__ __forceinline__ float2    operator+   (const float2& a, float b)         { return make_float2(a.x + b, a.y + b); }
-static __device__ __forceinline__ float2    operator-   (const float2& a, float b)         { return make_float2(a.x - b, a.y - b); }
-static __device__ __forceinline__ float2    operator*   (float a, const float2& b)         { return make_float2(a * b.x, a * b.y); }
-static __device__ __forceinline__ float2    operator+   (float a, const float2& b)         { return make_float2(a + b.x, a + b.y); }
-static __device__ __forceinline__ float2    operator-   (float a, const float2& b)         { return make_float2(a - b.x, a - b.y); }
-static __device__ __forceinline__ float2    operator-   (const float2& a)                  { return make_float2(-a.x, -a.y); }
-static __device__ __forceinline__ float3&   operator*=  (float3& a, const float3& b)       { a.x *= b.x; a.y *= b.y; a.z *= b.z; return a; }
-static __device__ __forceinline__ float3&   operator+=  (float3& a, const float3& b)       { a.x += b.x; a.y += b.y; a.z += b.z; return a; }
-static __device__ __forceinline__ float3&   operator-=  (float3& a, const float3& b)       { a.x -= b.x; a.y -= b.y; a.z -= b.z; return a; }
-static __device__ __forceinline__ float3&   operator*=  (float3& a, float b)               { a.x *= b; a.y *= b; a.z *= b; return a; }
-static __device__ __forceinline__ float3&   operator+=  (float3& a, float b)               { a.x += b; a.y += b; a.z += b; return a; }
-static __device__ __forceinline__ float3&   operator-=  (float3& a, float b)               { a.x -= b; a.y -= b; a.z -= b; return a; }
-static __device__ __forceinline__ float3    operator*   (const float3& a, const float3& b) { return make_float3(a.x * b.x, a.y * b.y, a.z * b.z); }
-static __device__ __forceinline__ float3    operator+   (const float3& a, const float3& b) { return make_float3(a.x + b.x, a.y + b.y, a.z + b.z); }
-static __device__ __forceinline__ float3    operator-   (const float3& a, const float3& b) { return make_float3(a.x - b.x, a.y - b.y, a.z - b.z); }
-static __device__ __forceinline__ float3    operator*   (const float3& a, float b)         { return make_float3(a.x * b, a.y * b, a.z * b); }
-static __device__ __forceinline__ float3    operator+   (const float3& a, float b)         { return make_float3(a.x + b, a.y + b, a.z + b); }
-static __device__ __forceinline__ float3    operator-   (const float3& a, float b)         { return make_float3(a.x - b, a.y - b, a.z - b); }
-static __device__ __forceinline__ float3    operator*   (float a, const float3& b)         { return make_float3(a * b.x, a * b.y, a * b.z); }
-static __device__ __forceinline__ float3    operator+   (float a, const float3& b)         { return make_float3(a + b.x, a + b.y, a + b.z); }
-static __device__ __forceinline__ float3    operator-   (float a, const float3& b)         { return make_float3(a - b.x, a - b.y, a - b.z); }
-static __device__ __forceinline__ float3    operator-   (const float3& a)                  { return make_float3(-a.x, -a.y, -a.z); }
-static __device__ __forceinline__ float4&   operator*=  (float4& a, const float4& b)       { a.x *= b.x; a.y *= b.y; a.z *= b.z; a.w *= b.w; return a; }
-static __device__ __forceinline__ float4&   operator+=  (float4& a, const float4& b)       { a.x += b.x; a.y += b.y; a.z += b.z; a.w += b.w; return a; }
-static __device__ __forceinline__ float4&   operator-=  (float4& a, const float4& b)       { a.x -= b.x; a.y -= b.y; a.z -= b.z; a.w -= b.w; return a; }
-static __device__ __forceinline__ float4&   operator*=  (float4& a, float b)               { a.x *= b; a.y *= b; a.z *= b; a.w *= b; return a; }
-static __device__ __forceinline__ float4&   operator+=  (float4& a, float b)               { a.x += b; a.y += b; a.z += b; a.w += b; return a; }
-static __device__ __forceinline__ float4&   operator-=  (float4& a, float b)               { a.x -= b; a.y -= b; a.z -= b; a.w -= b; return a; }
-static __device__ __forceinline__ float4    operator*   (const float4& a, const float4& b) { return make_float4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w); }
-static __device__ __forceinline__ float4    operator+   (const float4& a, const float4& b) { return make_float4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w); }
-static __device__ __forceinline__ float4    operator-   (const float4& a, const float4& b) { return make_float4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w); }
-static __device__ __forceinline__ float4    operator*   (const float4& a, float b)         { return make_float4(a.x * b, a.y * b, a.z * b, a.w * b); }
-static __device__ __forceinline__ float4    operator+   (const float4& a, float b)         { return make_float4(a.x + b, a.y + b, a.z + b, a.w + b); }
-static __device__ __forceinline__ float4    operator-   (const float4& a, float b)         { return make_float4(a.x - b, a.y - b, a.z - b, a.w - b); }
-static __device__ __forceinline__ float4    operator*   (float a, const float4& b)         { return make_float4(a * b.x, a * b.y, a * b.z, a * b.w); }
-static __device__ __forceinline__ float4    operator+   (float a, const float4& b)         { return make_float4(a + b.x, a + b.y, a + b.z, a + b.w); }
-static __device__ __forceinline__ float4    operator-   (float a, const float4& b)         { return make_float4(a - b.x, a - b.y, a - b.z, a - b.w); }
-static __device__ __forceinline__ float4    operator-   (const float4& a)                  { return make_float4(-a.x, -a.y, -a.z, -a.w); }
-static __device__ __forceinline__ int2&     operator*=  (int2& a, const int2& b)           { a.x *= b.x; a.y *= b.y; return a; }
-static __device__ __forceinline__ int2&     operator+=  (int2& a, const int2& b)           { a.x += b.x; a.y += b.y; return a; }
-static __device__ __forceinline__ int2&     operator-=  (int2& a, const int2& b)           { a.x -= b.x; a.y -= b.y; return a; }
-static __device__ __forceinline__ int2&     operator*=  (int2& a, int b)                   { a.x *= b; a.y *= b; return a; }
-static __device__ __forceinline__ int2&     operator+=  (int2& a, int b)                   { a.x += b; a.y += b; return a; }
-static __device__ __forceinline__ int2&     operator-=  (int2& a, int b)                   { a.x -= b; a.y -= b; return a; }
-static __device__ __forceinline__ int2      operator*   (const int2& a, const int2& b)     { return make_int2(a.x * b.x, a.y * b.y); }
-static __device__ __forceinline__ int2      operator+   (const int2& a, const int2& b)     { return make_int2(a.x + b.x, a.y + b.y); }
-static __device__ __forceinline__ int2      operator-   (const int2& a, const int2& b)     { return make_int2(a.x - b.x, a.y - b.y); }
-static __device__ __forceinline__ int2      operator*   (const int2& a, int b)             { return make_int2(a.x * b, a.y * b); }
-static __device__ __forceinline__ int2      operator+   (const int2& a, int b)             { return make_int2(a.x + b, a.y + b); }
-static __device__ __forceinline__ int2      operator-   (const int2& a, int b)             { return make_int2(a.x - b, a.y - b); }
-static __device__ __forceinline__ int2      operator*   (int a, const int2& b)             { return make_int2(a * b.x, a * b.y); }
-static __device__ __forceinline__ int2      operator+   (int a, const int2& b)             { return make_int2(a + b.x, a + b.y); }
-static __device__ __forceinline__ int2      operator-   (int a, const int2& b)             { return make_int2(a - b.x, a - b.y); }
-static __device__ __forceinline__ int2      operator-   (const int2& a)                    { return make_int2(-a.x, -a.y); }
-static __device__ __forceinline__ int3&     operator*=  (int3& a, const int3& b)           { a.x *= b.x; a.y *= b.y; a.z *= b.z; return a; }
-static __device__ __forceinline__ int3&     operator+=  (int3& a, const int3& b)           { a.x += b.x; a.y += b.y; a.z += b.z; return a; }
-static __device__ __forceinline__ int3&     operator-=  (int3& a, const int3& b)           { a.x -= b.x; a.y -= b.y; a.z -= b.z; return a; }
-static __device__ __forceinline__ int3&     operator*=  (int3& a, int b)                   { a.x *= b; a.y *= b; a.z *= b; return a; }
-static __device__ __forceinline__ int3&     operator+=  (int3& a, int b)                   { a.x += b; a.y += b; a.z += b; return a; }
-static __device__ __forceinline__ int3&     operator-=  (int3& a, int b)                   { a.x -= b; a.y -= b; a.z -= b; return a; }
-static __device__ __forceinline__ int3      operator*   (const int3& a, const int3& b)     { return make_int3(a.x * b.x, a.y * b.y, a.z * b.z); }
-static __device__ __forceinline__ int3      operator+   (const int3& a, const int3& b)     { return make_int3(a.x + b.x, a.y + b.y, a.z + b.z); }
-static __device__ __forceinline__ int3      operator-   (const int3& a, const int3& b)     { return make_int3(a.x - b.x, a.y - b.y, a.z - b.z); }
-static __device__ __forceinline__ int3      operator*   (const int3& a, int b)             { return make_int3(a.x * b, a.y * b, a.z * b); }
-static __device__ __forceinline__ int3      operator+   (const int3& a, int b)             { return make_int3(a.x + b, a.y + b, a.z + b); }
-static __device__ __forceinline__ int3      operator-   (const int3& a, int b)             { return make_int3(a.x - b, a.y - b, a.z - b); }
-static __device__ __forceinline__ int3      operator*   (int a, const int3& b)             { return make_int3(a * b.x, a * b.y, a * b.z); }
-static __device__ __forceinline__ int3      operator+   (int a, const int3& b)             { return make_int3(a + b.x, a + b.y, a + b.z); }
-static __device__ __forceinline__ int3      operator-   (int a, const int3& b)             { return make_int3(a - b.x, a - b.y, a - b.z); }
-static __device__ __forceinline__ int3      operator-   (const int3& a)                    { return make_int3(-a.x, -a.y, -a.z); }
-static __device__ __forceinline__ int4&     operator*=  (int4& a, const int4& b)           { a.x *= b.x; a.y *= b.y; a.z *= b.z; a.w *= b.w; return a; }
-static __device__ __forceinline__ int4&     operator+=  (int4& a, const int4& b)           { a.x += b.x; a.y += b.y; a.z += b.z; a.w += b.w; return a; }
-static __device__ __forceinline__ int4&     operator-=  (int4& a, const int4& b)           { a.x -= b.x; a.y -= b.y; a.z -= b.z; a.w -= b.w; return a; }
-static __device__ __forceinline__ int4&     operator*=  (int4& a, int b)                   { a.x *= b; a.y *= b; a.z *= b; a.w *= b; return a; }
-static __device__ __forceinline__ int4&     operator+=  (int4& a, int b)                   { a.x += b; a.y += b; a.z += b; a.w += b; return a; }
-static __device__ __forceinline__ int4&     operator-=  (int4& a, int b)                   { a.x -= b; a.y -= b; a.z -= b; a.w -= b; return a; }
-static __device__ __forceinline__ int4      operator*   (const int4& a, const int4& b)     { return make_int4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w); }
-static __device__ __forceinline__ int4      operator+   (const int4& a, const int4& b)     { return make_int4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w); }
-static __device__ __forceinline__ int4      operator-   (const int4& a, const int4& b)     { return make_int4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w); }
-static __device__ __forceinline__ int4      operator*   (const int4& a, int b)             { return make_int4(a.x * b, a.y * b, a.z * b, a.w * b); }
-static __device__ __forceinline__ int4      operator+   (const int4& a, int b)             { return make_int4(a.x + b, a.y + b, a.z + b, a.w + b); }
-static __device__ __forceinline__ int4      operator-   (const int4& a, int b)             { return make_int4(a.x - b, a.y - b, a.z - b, a.w - b); }
-static __device__ __forceinline__ int4      operator*   (int a, const int4& b)             { return make_int4(a * b.x, a * b.y, a * b.z, a * b.w); }
-static __device__ __forceinline__ int4      operator+   (int a, const int4& b)             { return make_int4(a + b.x, a + b.y, a + b.z, a + b.w); }
-static __device__ __forceinline__ int4      operator-   (int a, const int4& b)             { return make_int4(a - b.x, a - b.y, a - b.z, a - b.w); }
-static __device__ __forceinline__ int4      operator-   (const int4& a)                    { return make_int4(-a.x, -a.y, -a.z, -a.w); }
-static __device__ __forceinline__ uint2&    operator*=  (uint2& a, const uint2& b)         { a.x *= b.x; a.y *= b.y; return a; }
-static __device__ __forceinline__ uint2&    operator+=  (uint2& a, const uint2& b)         { a.x += b.x; a.y += b.y; return a; }
-static __device__ __forceinline__ uint2&    operator-=  (uint2& a, const uint2& b)         { a.x -= b.x; a.y -= b.y; return a; }
-static __device__ __forceinline__ uint2&    operator*=  (uint2& a, unsigned int b)         { a.x *= b; a.y *= b; return a; }
-static __device__ __forceinline__ uint2&    operator+=  (uint2& a, unsigned int b)         { a.x += b; a.y += b; return a; }
-static __device__ __forceinline__ uint2&    operator-=  (uint2& a, unsigned int b)         { a.x -= b; a.y -= b; return a; }
-static __device__ __forceinline__ uint2     operator*   (const uint2& a, const uint2& b)   { return make_uint2(a.x * b.x, a.y * b.y); }
-static __device__ __forceinline__ uint2     operator+   (const uint2& a, const uint2& b)   { return make_uint2(a.x + b.x, a.y + b.y); }
-static __device__ __forceinline__ uint2     operator-   (const uint2& a, const uint2& b)   { return make_uint2(a.x - b.x, a.y - b.y); }
-static __device__ __forceinline__ uint2     operator*   (const uint2& a, unsigned int b)   { return make_uint2(a.x * b, a.y * b); }
-static __device__ __forceinline__ uint2     operator+   (const uint2& a, unsigned int b)   { return make_uint2(a.x + b, a.y + b); }
-static __device__ __forceinline__ uint2     operator-   (const uint2& a, unsigned int b)   { return make_uint2(a.x - b, a.y - b); }
-static __device__ __forceinline__ uint2     operator*   (unsigned int a, const uint2& b)   { return make_uint2(a * b.x, a * b.y); }
-static __device__ __forceinline__ uint2     operator+   (unsigned int a, const uint2& b)   { return make_uint2(a + b.x, a + b.y); }
-static __device__ __forceinline__ uint2     operator-   (unsigned int a, const uint2& b)   { return make_uint2(a - b.x, a - b.y); }
-static __device__ __forceinline__ uint3&    operator*=  (uint3& a, const uint3& b)         { a.x *= b.x; a.y *= b.y; a.z *= b.z; return a; }
-static __device__ __forceinline__ uint3&    operator+=  (uint3& a, const uint3& b)         { a.x += b.x; a.y += b.y; a.z += b.z; return a; }
-static __device__ __forceinline__ uint3&    operator-=  (uint3& a, const uint3& b)         { a.x -= b.x; a.y -= b.y; a.z -= b.z; return a; }
-static __device__ __forceinline__ uint3&    operator*=  (uint3& a, unsigned int b)         { a.x *= b; a.y *= b; a.z *= b; return a; }
-static __device__ __forceinline__ uint3&    operator+=  (uint3& a, unsigned int b)         { a.x += b; a.y += b; a.z += b; return a; }
-static __device__ __forceinline__ uint3&    operator-=  (uint3& a, unsigned int b)         { a.x -= b; a.y -= b; a.z -= b; return a; }
-static __device__ __forceinline__ uint3     operator*   (const uint3& a, const uint3& b)   { return make_uint3(a.x * b.x, a.y * b.y, a.z * b.z); }
-static __device__ __forceinline__ uint3     operator+   (const uint3& a, const uint3& b)   { return make_uint3(a.x + b.x, a.y + b.y, a.z + b.z); }
-static __device__ __forceinline__ uint3     operator-   (const uint3& a, const uint3& b)   { return make_uint3(a.x - b.x, a.y - b.y, a.z - b.z); }
-static __device__ __forceinline__ uint3     operator*   (const uint3& a, unsigned int b)   { return make_uint3(a.x * b, a.y * b, a.z * b); }
-static __device__ __forceinline__ uint3     operator+   (const uint3& a, unsigned int b)   { return make_uint3(a.x + b, a.y + b, a.z + b); }
-static __device__ __forceinline__ uint3     operator-   (const uint3& a, unsigned int b)   { return make_uint3(a.x - b, a.y - b, a.z - b); }
-static __device__ __forceinline__ uint3     operator*   (unsigned int a, const uint3& b)   { return make_uint3(a * b.x, a * b.y, a * b.z); }
-static __device__ __forceinline__ uint3     operator+   (unsigned int a, const uint3& b)   { return make_uint3(a + b.x, a + b.y, a + b.z); }
-static __device__ __forceinline__ uint3     operator-   (unsigned int a, const uint3& b)   { return make_uint3(a - b.x, a - b.y, a - b.z); }
-static __device__ __forceinline__ uint4&    operator*=  (uint4& a, const uint4& b)         { a.x *= b.x; a.y *= b.y; a.z *= b.z; a.w *= b.w; return a; }
-static __device__ __forceinline__ uint4&    operator+=  (uint4& a, const uint4& b)         { a.x += b.x; a.y += b.y; a.z += b.z; a.w += b.w; return a; }
-static __device__ __forceinline__ uint4&    operator-=  (uint4& a, const uint4& b)         { a.x -= b.x; a.y -= b.y; a.z -= b.z; a.w -= b.w; return a; }
-static __device__ __forceinline__ uint4&    operator*=  (uint4& a, unsigned int b)         { a.x *= b; a.y *= b; a.z *= b; a.w *= b; return a; }
-static __device__ __forceinline__ uint4&    operator+=  (uint4& a, unsigned int b)         { a.x += b; a.y += b; a.z += b; a.w += b; return a; }
-static __device__ __forceinline__ uint4&    operator-=  (uint4& a, unsigned int b)         { a.x -= b; a.y -= b; a.z -= b; a.w -= b; return a; }
-static __device__ __forceinline__ uint4     operator*   (const uint4& a, const uint4& b)   { return make_uint4(a.x * b.x, a.y * b.y, a.z * b.z, a.w * b.w); }
-static __device__ __forceinline__ uint4     operator+   (const uint4& a, const uint4& b)   { return make_uint4(a.x + b.x, a.y + b.y, a.z + b.z, a.w + b.w); }
-static __device__ __forceinline__ uint4     operator-   (const uint4& a, const uint4& b)   { return make_uint4(a.x - b.x, a.y - b.y, a.z - b.z, a.w - b.w); }
-static __device__ __forceinline__ uint4     operator*   (const uint4& a, unsigned int b)   { return make_uint4(a.x * b, a.y * b, a.z * b, a.w * b); }
-static __device__ __forceinline__ uint4     operator+   (const uint4& a, unsigned int b)   { return make_uint4(a.x + b, a.y + b, a.z + b, a.w + b); }
-static __device__ __forceinline__ uint4     operator-   (const uint4& a, unsigned int b)   { return make_uint4(a.x - b, a.y - b, a.z - b, a.w - b); }
-static __device__ __forceinline__ uint4     operator*   (unsigned int a, const uint4& b)   { return make_uint4(a * b.x, a * b.y, a * b.z, a * b.w); }
-static __device__ __forceinline__ uint4     operator+   (unsigned int a, const uint4& b)   { return make_uint4(a + b.x, a + b.y, a + b.z, a + b.w); }
-static __device__ __forceinline__ uint4     operator-   (unsigned int a, const uint4& b)   { return make_uint4(a - b.x, a - b.y, a - b.z, a - b.w); }
-
-template<class T> static __device__ __forceinline__ T zero_value(void);
-template<> __device__ __forceinline__ float  zero_value<float> (void)                      { return 0.f; }
-template<> __device__ __forceinline__ float2 zero_value<float2>(void)                      { return make_float2(0.f, 0.f); }
-template<> __device__ __forceinline__ float4 zero_value<float4>(void)                      { return make_float4(0.f, 0.f, 0.f, 0.f); }
-static __device__ __forceinline__ float3 make_float3(const float2& a, float b)             { return make_float3(a.x, a.y, b); }
-static __device__ __forceinline__ float4 make_float4(const float3& a, float b)             { return make_float4(a.x, a.y, a.z, b); }
-static __device__ __forceinline__ float4 make_float4(const float2& a, const float2& b)     { return make_float4(a.x, a.y, b.x, b.y); }
-static __device__ __forceinline__ int3 make_int3(const int2& a, int b)                     { return make_int3(a.x, a.y, b); }
-static __device__ __forceinline__ int4 make_int4(const int3& a, int b)                     { return make_int4(a.x, a.y, a.z, b); }
-static __device__ __forceinline__ int4 make_int4(const int2& a, const int2& b)             { return make_int4(a.x, a.y, b.x, b.y); }
-static __device__ __forceinline__ uint3 make_uint3(const uint2& a, unsigned int b)         { return make_uint3(a.x, a.y, b); }
-static __device__ __forceinline__ uint4 make_uint4(const uint3& a, unsigned int b)         { return make_uint4(a.x, a.y, a.z, b); }
-static __device__ __forceinline__ uint4 make_uint4(const uint2& a, const uint2& b)         { return make_uint4(a.x, a.y, b.x, b.y); }
-
-template<class T> static __device__ __forceinline__ void swap(T& a, T& b)                  { T temp = a; a = b; b = temp; }
-
-//------------------------------------------------------------------------
-// Triangle ID <-> float32 conversion functions to support very large triangle IDs.
-//
-// Values up to and including 16777216 (also, negative values) are converted trivially and retain
-// compatibility with previous versions. Larger values are mapped to unique float32 that are not equal to
-// the ID. The largest value that converts to float32 and back without generating inf or nan is 889192447.
-
-static __device__ __forceinline__ int   float_to_triidx(float x) { if (x <= 16777216.f) return (int)x;   return __float_as_int(x) - 0x4a800000; }
-static __device__ __forceinline__ float triidx_to_float(int x)   { if (x <= 0x01000000) return (float)x; return __int_as_float(0x4a800000 + x); }
-
-//------------------------------------------------------------------------
-// Coalesced atomics. These are all done via macros.
-
-#if __CUDA_ARCH__ >= 700 // Warp match instruction __match_any_sync() is only available on compute capability 7.x and higher
-
-#define CA_TEMP       _ca_temp
-#define CA_TEMP_PARAM float* CA_TEMP
-#define CA_DECLARE_TEMP(threads_per_block) \
-    __shared__ float CA_TEMP[(threads_per_block)]
-
-#define CA_SET_GROUP_MASK(group, thread_mask)                   \
-    bool   _ca_leader;                                          \
-    float* _ca_ptr;                                             \
-    do {                                                        \
-        int tidx   = threadIdx.x + blockDim.x * threadIdx.y;    \
-        int lane   = tidx & 31;                                 \
-        int warp   = tidx >> 5;                                 \
-        int tmask  = __match_any_sync((thread_mask), (group));  \
-        int leader = __ffs(tmask) - 1;                          \
-        _ca_leader = (leader == lane);                          \
-        _ca_ptr    = &_ca_temp[((warp << 5) + leader)];         \
-    } while(0)
-
-#define CA_SET_GROUP(group) \
-    CA_SET_GROUP_MASK((group), 0xffffffffu)
-
-#define caAtomicAdd(ptr, value)         \
-    do {                                \
-        if (_ca_leader)                 \
-            *_ca_ptr = 0.f;             \
-        atomicAdd(_ca_ptr, (value));    \
-        if (_ca_leader)                 \
-            atomicAdd((ptr), *_ca_ptr); \
-    } while(0)
-
-#define caAtomicAdd3_xyw(ptr, x, y, w)  \
-    do {                                \
-        caAtomicAdd((ptr), (x));        \
-        caAtomicAdd((ptr)+1, (y));      \
-        caAtomicAdd((ptr)+3, (w));      \
-    } while(0)
-
-#define caAtomicAddTexture(ptr, level, idx, value)  \
-    do {                                            \
-        CA_SET_GROUP((idx) ^ ((level) << 27));      \
-        caAtomicAdd((ptr)+(idx), (value));          \
-    } while(0)
-
-//------------------------------------------------------------------------
-// Disable atomic coalescing for compute capability lower than 7.x
-
-#else // __CUDA_ARCH__ >= 700
-#define CA_TEMP _ca_temp
-#define CA_TEMP_PARAM float CA_TEMP
-#define CA_DECLARE_TEMP(threads_per_block) CA_TEMP_PARAM
-#define CA_SET_GROUP_MASK(group, thread_mask)
-#define CA_SET_GROUP(group)
-#define caAtomicAdd(ptr, value) atomicAdd((ptr), (value))
-#define caAtomicAdd3_xyw(ptr, x, y, w)  \
-    do {                                \
-        atomicAdd((ptr), (x));          \
-        atomicAdd((ptr)+1, (y));        \
-        atomicAdd((ptr)+3, (w));        \
-    } while(0)
-#define caAtomicAddTexture(ptr, level, idx, value) atomicAdd((ptr)+(idx), (value))
-#endif // __CUDA_ARCH__ >= 700
-
-//------------------------------------------------------------------------
-#endif // __CUDACC__

extensions/nvdiffrast/nvdiffrast/common/cudaraster/CudaRaster.hpp

@@ -1,63 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#pragma once
-
-//------------------------------------------------------------------------
-// This is a slimmed-down and modernized version of the original
-// CudaRaster codebase that accompanied the HPG 2011 paper
-// "High-Performance Software Rasterization on GPUs" by Laine and Karras.
-// Modifications have been made to accommodate post-Volta execution model
-// with warp divergence. Support for shading, blending, quad rendering,
-// and supersampling have been removed as unnecessary for nvdiffrast.
-//------------------------------------------------------------------------
-
-namespace CR
-{
-
-class RasterImpl;
-
-//------------------------------------------------------------------------
-// Interface class to isolate user from implementation details.
-//------------------------------------------------------------------------
-
-class CudaRaster
-{
-public:
-    enum
-    {
-        RenderModeFlag_EnableBackfaceCulling = 1 << 0,   // Enable backface culling.
-        RenderModeFlag_EnableDepthPeeling    = 1 << 1,   // Enable depth peeling. Must have a peel buffer set.
-    };
-
-public:
-					        CudaRaster				(void);
-					        ~CudaRaster				(void);
-
-    void                    setBufferSize           (int width, int height, int numImages);              // Width and height are internally rounded up to multiples of tile size (8x8) for buffer sizes.
-    void                    setViewport             (int width, int height, int offsetX, int offsetY);   // Tiled rendering viewport setup.
-    void                    setRenderModeFlags      (unsigned int renderModeFlags);                      // Affects all subsequent calls to drawTriangles(). Defaults to zero.
-    void                    deferredClear           (unsigned int clearColor);                           // Clears color and depth buffers during next call to drawTriangles().
-    void                    setVertexBuffer         (void* vertices, int numVertices);                   // GPU pointer managed by caller. Vertex positions in clip space as float4 (x, y, z, w).
-    void                    setIndexBuffer          (void* indices, int numTriangles);                   // GPU pointer managed by caller. Triangle index+color quadruplets as uint4 (idx0, idx1, idx2, color).
-    bool                    drawTriangles           (const int* ranges, bool peel, cudaStream_t stream); // Ranges (offsets and counts) as #triangles entries, not as bytes. If NULL, draw all triangles. Returns false in case of internal overflow.
-    void*                   getColorBuffer          (void);                                              // GPU pointer managed by CudaRaster.
-    void*                   getDepthBuffer          (void);                                              // GPU pointer managed by CudaRaster.
-    void                    swapDepthAndPeel        (void);                                              // Swap depth and peeling buffers.
-
-private:
-					        CudaRaster           	(const CudaRaster&); // forbidden
-	CudaRaster&             operator=           	(const CudaRaster&); // forbidden
-
-private:
-    RasterImpl*             m_impl;                 // Opaque pointer to implementation.
-};
-
-//------------------------------------------------------------------------
-} // namespace CR
-

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/BinRaster.inl

@@ -1,423 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ void binRasterImpl(const CRParams p)
-{
-    __shared__ volatile U32 s_broadcast [CR_BIN_WARPS + 16];
-    __shared__ volatile S32 s_outOfs    [CR_MAXBINS_SQR];
-    __shared__ volatile S32 s_outTotal  [CR_MAXBINS_SQR];
-    __shared__ volatile S32 s_overIndex [CR_MAXBINS_SQR];
-    __shared__ volatile S32 s_outMask   [CR_BIN_WARPS][CR_MAXBINS_SQR + 1]; // +1 to avoid bank collisions
-    __shared__ volatile S32 s_outCount  [CR_BIN_WARPS][CR_MAXBINS_SQR + 1]; // +1 to avoid bank collisions
-    __shared__ volatile S32 s_triBuf    [CR_BIN_WARPS*32*4];                // triangle ring buffer
-    __shared__ volatile U32 s_batchPos;
-    __shared__ volatile U32 s_bufCount;
-    __shared__ volatile U32 s_overTotal;
-    __shared__ volatile U32 s_allocBase;
-
-    const CRImageParams&    ip              = getImageParams(p, blockIdx.z);
-    CRAtomics&              atomics         = p.atomics[blockIdx.z];
-    const U8*               triSubtris      = (const U8*)p.triSubtris + p.maxSubtris * blockIdx.z;
-    const CRTriangleHeader* triHeader       = (const CRTriangleHeader*)p.triHeader + p.maxSubtris * blockIdx.z;
-
-    S32*                    binFirstSeg     = (S32*)p.binFirstSeg + CR_MAXBINS_SQR * CR_BIN_STREAMS_SIZE * blockIdx.z;
-    S32*                    binTotal        = (S32*)p.binTotal    + CR_MAXBINS_SQR * CR_BIN_STREAMS_SIZE * blockIdx.z;
-    S32*                    binSegData      = (S32*)p.binSegData  + p.maxBinSegs * CR_BIN_SEG_SIZE * blockIdx.z;
-    S32*                    binSegNext      = (S32*)p.binSegNext  + p.maxBinSegs * blockIdx.z;
-    S32*                    binSegCount     = (S32*)p.binSegCount + p.maxBinSegs * blockIdx.z;
-
-    if (atomics.numSubtris > p.maxSubtris)
-        return;
-
-    // per-thread state
-    int thrInBlock = threadIdx.x + threadIdx.y * 32;
-    int batchPos = 0;
-
-    // first 16 elements of s_broadcast are always zero
-    if (thrInBlock < 16)
-        s_broadcast[thrInBlock] = 0;
-
-    // initialize output linked lists and offsets
-    if (thrInBlock < p.numBins)
-    {
-        binFirstSeg[(thrInBlock << CR_BIN_STREAMS_LOG2) + blockIdx.x] = -1;
-        s_outOfs[thrInBlock] = -CR_BIN_SEG_SIZE;
-        s_outTotal[thrInBlock] = 0;
-    }
-
-    // repeat until done
-    for(;;)
-    {
-        // get batch
-        if (thrInBlock == 0)
-            s_batchPos = atomicAdd(&atomics.binCounter, ip.binBatchSize);
-        __syncthreads();
-        batchPos = s_batchPos;
-
-        // all batches done?
-        if (batchPos >= ip.triCount)
-            break;
-
-        // per-thread state
-        int bufIndex = 0;
-        int bufCount = 0;
-        int batchEnd = min(batchPos + ip.binBatchSize, ip.triCount);
-
-        // loop over batch as long as we have triangles in it
-        do
-        {
-            // read more triangles
-            while (bufCount < CR_BIN_WARPS*32 && batchPos < batchEnd)
-            {
-                // get subtriangle count
-
-                int triIdx = batchPos + thrInBlock;
-                int num = 0;
-                if (triIdx < batchEnd)
-                    num = triSubtris[triIdx];
-
-                // cumulative sum of subtriangles within each warp
-                U32 myIdx = __popc(__ballot_sync(~0u, num & 1) & getLaneMaskLt());
-                if (__any_sync(~0u, num > 1))
-                {
-                    myIdx += __popc(__ballot_sync(~0u, num & 2) & getLaneMaskLt()) * 2;
-                    myIdx += __popc(__ballot_sync(~0u, num & 4) & getLaneMaskLt()) * 4;
-                }
-                if (threadIdx.x == 31) // Do not assume that last thread in warp wins the write.
-                    s_broadcast[threadIdx.y + 16] = myIdx + num;
-                __syncthreads();
-
-                // cumulative sum of per-warp subtriangle counts
-                // Note: cannot have more than 32 warps or this needs to sync between each step.
-                bool act = (thrInBlock < CR_BIN_WARPS);
-                U32 actMask = __ballot_sync(~0u, act);
-                if (threadIdx.y == 0 && act)
-                {
-                    volatile U32* ptr = &s_broadcast[thrInBlock + 16];
-                    U32 val = *ptr;
-                    #if (CR_BIN_WARPS > 1)
-                        val += ptr[-1]; __syncwarp(actMask);
-                        *ptr = val;     __syncwarp(actMask);
-                    #endif
-                    #if (CR_BIN_WARPS > 2)
-                        val += ptr[-2]; __syncwarp(actMask);
-                        *ptr = val;     __syncwarp(actMask);
-                    #endif
-                    #if (CR_BIN_WARPS > 4)
-                        val += ptr[-4]; __syncwarp(actMask);
-                        *ptr = val;     __syncwarp(actMask);
-                    #endif
-                    #if (CR_BIN_WARPS > 8)
-                        val += ptr[-8]; __syncwarp(actMask);
-                        *ptr = val;     __syncwarp(actMask);
-                    #endif
-                    #if (CR_BIN_WARPS > 16)
-                        val += ptr[-16]; __syncwarp(actMask);
-                        *ptr = val;      __syncwarp(actMask);
-                    #endif
-
-                    // initially assume that we consume everything
-                    // only last active thread does the writes
-                    if (threadIdx.x == CR_BIN_WARPS - 1)
-                    {
-                        s_batchPos = batchPos + CR_BIN_WARPS * 32;
-                        s_bufCount = bufCount + val;
-                    }
-                }
-                __syncthreads();
-
-                // skip if no subtriangles
-                if (num)
-                {
-                    // calculate write position for first subtriangle
-                    U32 pos = bufCount + myIdx + s_broadcast[threadIdx.y + 16 - 1];
-
-                    // only write if entire triangle fits
-                    if (pos + num <= CR_ARRAY_SIZE(s_triBuf))
-                    {
-                        pos += bufIndex; // adjust for current start position
-                        pos &= CR_ARRAY_SIZE(s_triBuf)-1;
-                        if (num == 1)
-                            s_triBuf[pos] = triIdx * 8 + 7; // single triangle
-                        else
-                        {
-                            for (int i=0; i < num; i++)
-                            {
-                                s_triBuf[pos] = triIdx * 8 + i;
-                                pos++;
-                                pos &= CR_ARRAY_SIZE(s_triBuf)-1;
-                            }
-                        }
-                    } else if (pos <= CR_ARRAY_SIZE(s_triBuf))
-                    {
-                        // this triangle is the first that failed, overwrite total count and triangle count
-                        s_batchPos = batchPos + thrInBlock;
-                        s_bufCount = pos;
-                    }
-                }
-
-                // update triangle counts
-                __syncthreads();
-                batchPos = s_batchPos;
-                bufCount = s_bufCount;
-            }
-
-            // make every warp clear its output buffers
-            for (int i=threadIdx.x; i < p.numBins; i += 32)
-                s_outMask[threadIdx.y][i] = 0;
-            __syncwarp();
-
-            // choose our triangle
-            uint4 triData = make_uint4(0, 0, 0, 0);
-            if (thrInBlock < bufCount)
-            {
-                U32 triPos = bufIndex + thrInBlock;
-                triPos &= CR_ARRAY_SIZE(s_triBuf)-1;
-
-                // find triangle
-                int triIdx = s_triBuf[triPos];
-                int dataIdx = triIdx >> 3;
-                int subtriIdx = triIdx & 7;
-                if (subtriIdx != 7)
-                    dataIdx = triHeader[dataIdx].misc + subtriIdx;
-
-                // read triangle
-
-                triData = *(((const uint4*)triHeader) + dataIdx);
-            }
-
-            // setup bounding box and edge functions, and rasterize
-            S32 lox, loy, hix, hiy;
-            bool hasTri = (thrInBlock < bufCount);
-            U32 hasTriMask = __ballot_sync(~0u, hasTri);
-            if (hasTri)
-            {
-                S32 v0x = add_s16lo_s16lo(triData.x, p.widthPixelsVp  * (CR_SUBPIXEL_SIZE >> 1));
-                S32 v0y = add_s16hi_s16lo(triData.x, p.heightPixelsVp * (CR_SUBPIXEL_SIZE >> 1));
-                S32 d01x = sub_s16lo_s16lo(triData.y, triData.x);
-                S32 d01y = sub_s16hi_s16hi(triData.y, triData.x);
-                S32 d02x = sub_s16lo_s16lo(triData.z, triData.x);
-                S32 d02y = sub_s16hi_s16hi(triData.z, triData.x);
-                int binLog = CR_BIN_LOG2 + CR_TILE_LOG2 + CR_SUBPIXEL_LOG2;
-                lox = add_clamp_0_x((v0x + min_min(d01x, 0, d02x)) >> binLog, 0, p.widthBins  - 1);
-                loy = add_clamp_0_x((v0y + min_min(d01y, 0, d02y)) >> binLog, 0, p.heightBins - 1);
-                hix = add_clamp_0_x((v0x + max_max(d01x, 0, d02x)) >> binLog, 0, p.widthBins  - 1);
-                hiy = add_clamp_0_x((v0y + max_max(d01y, 0, d02y)) >> binLog, 0, p.heightBins - 1);
-
-                U32 bit = 1 << threadIdx.x;
-#if __CUDA_ARCH__ >= 700
-                bool multi = (hix != lox || hiy != loy);
-                if (!__any_sync(hasTriMask, multi))
-                {
-                    int binIdx = lox + p.widthBins * loy;
-                    U32 mask = __match_any_sync(hasTriMask, binIdx);
-                    s_outMask[threadIdx.y][binIdx] = mask;
-                    __syncwarp(hasTriMask);
-                } else
-#endif
-                {
-                    bool complex = (hix > lox+1 || hiy > loy+1);
-                    if (!__any_sync(hasTriMask, complex))
-                    {
-                        int binIdx = lox + p.widthBins * loy;
-                        atomicOr((U32*)&s_outMask[threadIdx.y][binIdx], bit);
-                        if (hix > lox) atomicOr((U32*)&s_outMask[threadIdx.y][binIdx + 1], bit);
-                        if (hiy > loy) atomicOr((U32*)&s_outMask[threadIdx.y][binIdx + p.widthBins], bit);
-                        if (hix > lox && hiy > loy) atomicOr((U32*)&s_outMask[threadIdx.y][binIdx + p.widthBins + 1], bit);
-                    } else
-                    {
-                        S32 d12x = d02x - d01x, d12y = d02y - d01y;
-                        v0x -= lox << binLog, v0y -= loy << binLog;
-
-                        S32 t01 = v0x * d01y - v0y * d01x;
-                        S32 t02 = v0y * d02x - v0x * d02y;
-                        S32 t12 = d01x * d12y - d01y * d12x - t01 - t02;
-                        S32 b01 = add_sub(t01 >> binLog, max(d01x, 0), min(d01y, 0));
-                        S32 b02 = add_sub(t02 >> binLog, max(d02y, 0), min(d02x, 0));
-                        S32 b12 = add_sub(t12 >> binLog, max(d12x, 0), min(d12y, 0));
-
-                        int width = hix - lox + 1;
-                        d01x += width * d01y;
-                        d02x += width * d02y;
-                        d12x += width * d12y;
-
-                        U8* currPtr = (U8*)&s_outMask[threadIdx.y][lox + loy * p.widthBins];
-                        U8* skipPtr = (U8*)&s_outMask[threadIdx.y][(hix + 1) + loy * p.widthBins];
-                        U8* endPtr  = (U8*)&s_outMask[threadIdx.y][lox + (hiy + 1) * p.widthBins];
-                        int stride  = p.widthBins * 4;
-                        int ptrYInc = stride - width * 4;
-
-                        do
-                        {
-                            if (b01 >= 0 && b02 >= 0 && b12 >= 0)
-                                atomicOr((U32*)currPtr, bit);
-                            currPtr += 4, b01 -= d01y, b02 += d02y, b12 -= d12y;
-                            if (currPtr == skipPtr)
-                                currPtr += ptrYInc, b01 += d01x, b02 -= d02x, b12 += d12x, skipPtr += stride;
-                        }
-                        while (currPtr != endPtr);
-                    }
-                }
-            }
-
-            // count per-bin contributions
-            if (thrInBlock == 0)
-                s_overTotal = 0; // overflow counter
-
-            // ensure that out masks are done
-            __syncthreads();
-
-            int overIndex = -1;
-            bool act = (thrInBlock < p.numBins);
-            U32 actMask = __ballot_sync(~0u, act);
-            if (act)
-            {
-                U8* srcPtr = (U8*)&s_outMask[0][thrInBlock];
-                U8* dstPtr = (U8*)&s_outCount[0][thrInBlock];
-                int total = 0;
-                for (int i = 0; i < CR_BIN_WARPS; i++)
-                {
-                    total += __popc(*(U32*)srcPtr);
-                    *(U32*)dstPtr = total;
-                    srcPtr += (CR_MAXBINS_SQR + 1) * 4;
-                    dstPtr += (CR_MAXBINS_SQR + 1) * 4;
-                }
-
-                // overflow => request a new segment
-                int ofs = s_outOfs[thrInBlock];
-                bool ovr = (((ofs - 1) >> CR_BIN_SEG_LOG2) != (((ofs - 1) + total) >> CR_BIN_SEG_LOG2));
-                U32 ovrMask = __ballot_sync(actMask, ovr);
-                if (ovr)
-                {
-                    overIndex = __popc(ovrMask & getLaneMaskLt());
-                    if (overIndex == 0)
-                        s_broadcast[threadIdx.y + 16] = atomicAdd((U32*)&s_overTotal, __popc(ovrMask));
-                    __syncwarp(ovrMask);
-                    overIndex += s_broadcast[threadIdx.y + 16];
-                    s_overIndex[thrInBlock] = overIndex;
-                }
-            }
-
-            // sync after overTotal is ready
-            __syncthreads();
-
-            // at least one segment overflowed => allocate segments
-            U32 overTotal = s_overTotal;
-            U32 allocBase = 0;
-            if (overTotal > 0)
-            {
-                // allocate memory
-                if (thrInBlock == 0)
-                {
-                    U32 allocBase = atomicAdd(&atomics.numBinSegs, overTotal);
-                    s_allocBase = (allocBase + overTotal <= p.maxBinSegs) ? allocBase : 0;
-                }
-                __syncthreads();
-                allocBase = s_allocBase;
-
-                // did my bin overflow?
-                if (overIndex != -1)
-                {
-                    // calculate new segment index
-                    int segIdx = allocBase + overIndex;
-
-                    // add to linked list
-                    if (s_outOfs[thrInBlock] < 0)
-                        binFirstSeg[(thrInBlock << CR_BIN_STREAMS_LOG2) + blockIdx.x] = segIdx;
-                    else
-                        binSegNext[(s_outOfs[thrInBlock] - 1) >> CR_BIN_SEG_LOG2] = segIdx;
-
-                    // defaults
-                    binSegNext [segIdx] = -1;
-                    binSegCount[segIdx] = CR_BIN_SEG_SIZE;
-                }
-            }
-
-            // concurrent emission -- each warp handles its own triangle
-            if (thrInBlock < bufCount)
-            {
-                int triPos  = (bufIndex + thrInBlock) & (CR_ARRAY_SIZE(s_triBuf) - 1);
-                int currBin = lox + loy * p.widthBins;
-                int skipBin = (hix + 1) + loy * p.widthBins;
-                int endBin  = lox + (hiy + 1) * p.widthBins;
-                int binYInc = p.widthBins - (hix - lox + 1);
-
-                // loop over triangle's bins
-                do
-                {
-                    U32 outMask = s_outMask[threadIdx.y][currBin];
-                    if (outMask & (1<<threadIdx.x))
-                    {
-                        int idx = __popc(outMask & getLaneMaskLt());
-                        if (threadIdx.y > 0)
-                            idx += s_outCount[threadIdx.y-1][currBin];
-
-                        int base = s_outOfs[currBin];
-                        int free = (-base) & (CR_BIN_SEG_SIZE - 1);
-                        if (idx >= free)
-                            idx += ((allocBase + s_overIndex[currBin]) << CR_BIN_SEG_LOG2) - free;
-                        else
-                            idx += base;
-
-                        binSegData[idx] = s_triBuf[triPos];
-                    }
-
-                    currBin++;
-                    if (currBin == skipBin)
-                        currBin += binYInc, skipBin += p.widthBins;
-                }
-                while (currBin != endBin);
-            }
-
-            // wait all triangles to finish, then replace overflown segment offsets
-            __syncthreads();
-            if (thrInBlock < p.numBins)
-            {
-                U32 total  = s_outCount[CR_BIN_WARPS - 1][thrInBlock];
-                U32 oldOfs = s_outOfs[thrInBlock];
-                if (overIndex == -1)
-                    s_outOfs[thrInBlock] = oldOfs + total;
-                else
-                {
-                    int addr = oldOfs + total;
-                    addr = ((addr - 1) & (CR_BIN_SEG_SIZE - 1)) + 1;
-                    addr += (allocBase + overIndex) << CR_BIN_SEG_LOG2;
-                    s_outOfs[thrInBlock] = addr;
-                }
-                s_outTotal[thrInBlock] += total;
-            }
-
-            // these triangles are now done
-            int count = ::min(bufCount, CR_BIN_WARPS * 32);
-            bufCount -= count;
-            bufIndex += count;
-            bufIndex &= CR_ARRAY_SIZE(s_triBuf)-1;
-        }
-        while (bufCount > 0 || batchPos < batchEnd);
-
-        // flush all bins
-        if (thrInBlock < p.numBins)
-        {
-            int ofs = s_outOfs[thrInBlock];
-            if (ofs & (CR_BIN_SEG_SIZE-1))
-            {
-                int seg = ofs >> CR_BIN_SEG_LOG2;
-                binSegCount[seg] = ofs & (CR_BIN_SEG_SIZE-1);
-                s_outOfs[thrInBlock] = (ofs + CR_BIN_SEG_SIZE - 1) & -CR_BIN_SEG_SIZE;
-            }
-        }
-    }
-
-    // output totals
-    if (thrInBlock < p.numBins)
-        binTotal[(thrInBlock << CR_BIN_STREAMS_LOG2) + blockIdx.x] = s_outTotal[thrInBlock];
-}
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/Buffer.cpp

@@ -1,94 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#include "../../framework.h"
-#include "Buffer.hpp"
-
-using namespace CR;
-
-//------------------------------------------------------------------------
-// GPU buffer.
-//------------------------------------------------------------------------
-
-Buffer::Buffer(void)
-:   m_gpuPtr(NULL),
-    m_bytes (0)
-{
-    // empty
-}
-
-Buffer::~Buffer(void)
-{
-    if (m_gpuPtr)
-        cudaFree(m_gpuPtr); // Don't throw an exception.
-}
-
-void Buffer::reset(size_t bytes)
-{
-    if (bytes == m_bytes)
-        return;
-
-    if (m_gpuPtr)
-    {
-        NVDR_CHECK_CUDA_ERROR(cudaFree(m_gpuPtr));
-        m_gpuPtr = NULL;
-    }
-
-    if (bytes > 0)
-        NVDR_CHECK_CUDA_ERROR(cudaMalloc(&m_gpuPtr, bytes));
-
-    m_bytes = bytes;
-}
-
-void Buffer::grow(size_t bytes)
-{
-    if (bytes > m_bytes)
-        reset(bytes);
-}
-
-//------------------------------------------------------------------------
-// Host buffer with page-locked memory.
-//------------------------------------------------------------------------
-
-HostBuffer::HostBuffer(void)
-:   m_hostPtr(NULL),
-    m_bytes  (0)
-{
-    // empty
-}
-
-HostBuffer::~HostBuffer(void)
-{
-    if (m_hostPtr)
-        cudaFreeHost(m_hostPtr); // Don't throw an exception.
-}
-
-void HostBuffer::reset(size_t bytes)
-{
-    if (bytes == m_bytes)
-        return;
-
-    if (m_hostPtr)
-    {
-        NVDR_CHECK_CUDA_ERROR(cudaFreeHost(m_hostPtr));
-        m_hostPtr = NULL;
-    }
-
-    if (bytes > 0)
-        NVDR_CHECK_CUDA_ERROR(cudaMallocHost(&m_hostPtr, bytes));
-
-    m_bytes = bytes;
-}
-
-void HostBuffer::grow(size_t bytes)
-{
-    if (bytes > m_bytes)
-        reset(bytes);
-}
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/Buffer.hpp

@@ -1,55 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#pragma once
-#include "Defs.hpp"
-
-namespace CR
-{
-//------------------------------------------------------------------------
-
-class Buffer
-{
-public:
-                    Buffer      (void);
-                    ~Buffer     (void);
-
-    void            reset       (size_t bytes);
-    void            grow        (size_t bytes);
-    void*           getPtr      (size_t offset = 0) { return (void*)(((uintptr_t)m_gpuPtr) + offset); }
-    size_t          getSize     (void) const { return m_bytes; }
-
-    void            setPtr      (void* ptr) { m_gpuPtr = ptr; }
-
-private:
-    void*           m_gpuPtr;
-    size_t          m_bytes;
-};
-
-//------------------------------------------------------------------------
-
-class HostBuffer
-{
-public:
-                    HostBuffer  (void);
-                    ~HostBuffer (void);
-
-    void            reset       (size_t bytes);
-    void            grow        (size_t bytes);
-    void*           getPtr      (void) { return m_hostPtr; }
-    size_t          getSize     (void) const { return m_bytes; }
-
-    void            setPtr      (void* ptr) { m_hostPtr = ptr; }
-
-private:
-    void*           m_hostPtr;
-    size_t          m_bytes;
-};
-
-//------------------------------------------------------------------------
-}

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/CoarseRaster.inl

@@ -1,730 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ int globalTileIdx(int tileInBin, int widthTiles)
-{
-    int tileX = tileInBin & (CR_BIN_SIZE - 1);
-    int tileY = tileInBin >> CR_BIN_LOG2;
-    return tileX + tileY * widthTiles;
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ void coarseRasterImpl(const CRParams p)
-{
-    // Common.
-
-    __shared__ volatile U32 s_workCounter;
-    __shared__ volatile U32 s_scanTemp          [CR_COARSE_WARPS][48];              // 3KB
-
-    // Input.
-
-    __shared__ volatile U32 s_binOrder          [CR_MAXBINS_SQR];                   // 1KB
-    __shared__ volatile S32 s_binStreamCurrSeg  [CR_BIN_STREAMS_SIZE];              // 0KB
-    __shared__ volatile S32 s_binStreamFirstTri [CR_BIN_STREAMS_SIZE];              // 0KB
-    __shared__ volatile S32 s_triQueue          [CR_COARSE_QUEUE_SIZE];             // 4KB
-    __shared__ volatile S32 s_triQueueWritePos;
-    __shared__ volatile U32 s_binStreamSelectedOfs;
-    __shared__ volatile U32 s_binStreamSelectedSize;
-
-    // Output.
-
-    __shared__ volatile U32 s_warpEmitMask      [CR_COARSE_WARPS][CR_BIN_SQR + 1];  // 16KB, +1 to avoid bank collisions
-    __shared__ volatile U32 s_warpEmitPrefixSum [CR_COARSE_WARPS][CR_BIN_SQR + 1];  // 16KB, +1 to avoid bank collisions
-    __shared__ volatile U32 s_tileEmitPrefixSum [CR_BIN_SQR + 1];                   // 1KB, zero at the beginning
-    __shared__ volatile U32 s_tileAllocPrefixSum[CR_BIN_SQR + 1];                   // 1KB, zero at the beginning
-    __shared__ volatile S32 s_tileStreamCurrOfs [CR_BIN_SQR];                       // 1KB
-    __shared__ volatile U32 s_firstAllocSeg;
-    __shared__ volatile U32 s_firstActiveIdx;
-
-    // Pointers and constants.
-
-    CRAtomics&              atomics         = p.atomics[blockIdx.z];
-    const CRTriangleHeader* triHeader       = (const CRTriangleHeader*)p.triHeader + p.maxSubtris * blockIdx.z;
-    const S32*              binFirstSeg     = (const S32*)p.binFirstSeg + CR_MAXBINS_SQR * CR_BIN_STREAMS_SIZE * blockIdx.z;
-    const S32*              binTotal        = (const S32*)p.binTotal    + CR_MAXBINS_SQR * CR_BIN_STREAMS_SIZE * blockIdx.z;
-    const S32*              binSegData      = (const S32*)p.binSegData  + p.maxBinSegs * CR_BIN_SEG_SIZE * blockIdx.z;
-    const S32*              binSegNext      = (const S32*)p.binSegNext  + p.maxBinSegs * blockIdx.z;
-    const S32*              binSegCount     = (const S32*)p.binSegCount + p.maxBinSegs * blockIdx.z;
-    S32*                    activeTiles     = (S32*)p.activeTiles  + CR_MAXTILES_SQR * blockIdx.z;
-    S32*                    tileFirstSeg    = (S32*)p.tileFirstSeg + CR_MAXTILES_SQR * blockIdx.z;
-    S32*                    tileSegData     = (S32*)p.tileSegData  + p.maxTileSegs * CR_TILE_SEG_SIZE * blockIdx.z;
-    S32*                    tileSegNext     = (S32*)p.tileSegNext  + p.maxTileSegs * blockIdx.z;
-    S32*                    tileSegCount    = (S32*)p.tileSegCount + p.maxTileSegs * blockIdx.z;
-
-    int tileLog     = CR_TILE_LOG2 + CR_SUBPIXEL_LOG2;
-    int thrInBlock  = threadIdx.x + threadIdx.y * 32;
-    int emitShift   = CR_BIN_LOG2 * 2 + 5; // We scan ((numEmits << emitShift) | numAllocs) over tiles.
-
-    if (atomics.numSubtris > p.maxSubtris || atomics.numBinSegs > p.maxBinSegs)
-        return;
-
-    // Initialize sharedmem arrays.
-
-    if (thrInBlock == 0)
-    {
-        s_tileEmitPrefixSum[0] = 0;
-        s_tileAllocPrefixSum[0] = 0;
-    }
-    s_scanTemp[threadIdx.y][threadIdx.x] = 0;
-
-    // Sort bins in descending order of triangle count.
-
-    for (int binIdx = thrInBlock; binIdx < p.numBins; binIdx += CR_COARSE_WARPS * 32)
-    {
-        int count = 0;
-        for (int i = 0; i < CR_BIN_STREAMS_SIZE; i++)
-            count += binTotal[(binIdx << CR_BIN_STREAMS_LOG2) + i];
-        s_binOrder[binIdx] = (~count << (CR_MAXBINS_LOG2 * 2)) | binIdx;
-    }
-
-    __syncthreads();
-    sortShared(s_binOrder, p.numBins);
-
-    // Process each bin by one block.
-
-    for (;;)
-    {
-        // Pick a bin for the block.
-
-        if (thrInBlock == 0)
-            s_workCounter = atomicAdd(&atomics.coarseCounter, 1);
-        __syncthreads();
-
-        int workCounter = s_workCounter;
-        if (workCounter >= p.numBins)
-            break;
-
-        U32 binOrder = s_binOrder[workCounter];
-        bool binEmpty = ((~binOrder >> (CR_MAXBINS_LOG2 * 2)) == 0);
-        if (binEmpty && !p.deferredClear)
-            break;
-
-        int binIdx = binOrder & (CR_MAXBINS_SQR - 1);
-
-        // Initialize input/output streams.
-
-        int triQueueWritePos = 0;
-        int triQueueReadPos = 0;
-
-        if (thrInBlock < CR_BIN_STREAMS_SIZE)
-        {
-            int segIdx = binFirstSeg[(binIdx << CR_BIN_STREAMS_LOG2) + thrInBlock];
-            s_binStreamCurrSeg[thrInBlock] = segIdx;
-            s_binStreamFirstTri[thrInBlock] = (segIdx == -1) ? ~0u : binSegData[segIdx << CR_BIN_SEG_LOG2];
-        }
-
-        for (int tileInBin = CR_COARSE_WARPS * 32 - 1 - thrInBlock; tileInBin < CR_BIN_SQR; tileInBin += CR_COARSE_WARPS * 32)
-            s_tileStreamCurrOfs[tileInBin] = -CR_TILE_SEG_SIZE;
-
-        // Initialize per-bin state.
-
-        int binY = idiv_fast(binIdx, p.widthBins);
-        int binX = binIdx - binY * p.widthBins;
-        int originX = (binX << (CR_BIN_LOG2 + tileLog)) - (p.widthPixelsVp << (CR_SUBPIXEL_LOG2 - 1));
-        int originY = (binY << (CR_BIN_LOG2 + tileLog)) - (p.heightPixelsVp << (CR_SUBPIXEL_LOG2 - 1));
-        int maxTileXInBin = ::min(p.widthTiles - (binX << CR_BIN_LOG2), CR_BIN_SIZE) - 1;
-        int maxTileYInBin = ::min(p.heightTiles - (binY << CR_BIN_LOG2), CR_BIN_SIZE) - 1;
-        int binTileIdx = (binX + binY * p.widthTiles) << CR_BIN_LOG2;
-
-        // Entire block: Merge input streams and process triangles.
-
-        if (!binEmpty)
-        do
-        {
-            //------------------------------------------------------------------------
-            // Merge.
-            //------------------------------------------------------------------------
-
-            // Entire block: Not enough triangles => merge and queue segments.
-            // NOTE: The bin exit criterion assumes that we queue more triangles than we actually need.
-
-            while (triQueueWritePos - triQueueReadPos <= CR_COARSE_WARPS * 32)
-            {
-                // First warp: Choose the segment with the lowest initial triangle index.
-
-                bool hasStream = (thrInBlock < CR_BIN_STREAMS_SIZE);
-                U32 hasStreamMask = __ballot_sync(~0u, hasStream);
-                if (hasStream)
-                {
-                    // Find the stream with the lowest triangle index.
-
-                    U32 firstTri = s_binStreamFirstTri[thrInBlock];
-                    U32 t = firstTri;
-                    volatile U32* v = &s_scanTemp[0][thrInBlock + 16];
-
-                    #if (CR_BIN_STREAMS_SIZE > 1)
-                        v[0] = t; __syncwarp(hasStreamMask); t = ::min(t, v[-1]); __syncwarp(hasStreamMask);
-                    #endif
-                    #if (CR_BIN_STREAMS_SIZE > 2)
-                        v[0] = t; __syncwarp(hasStreamMask); t = ::min(t, v[-2]); __syncwarp(hasStreamMask);
-                    #endif
-                    #if (CR_BIN_STREAMS_SIZE > 4)
-                        v[0] = t; __syncwarp(hasStreamMask); t = ::min(t, v[-4]); __syncwarp(hasStreamMask);
-                    #endif
-                    #if (CR_BIN_STREAMS_SIZE > 8)
-                        v[0] = t; __syncwarp(hasStreamMask); t = ::min(t, v[-8]); __syncwarp(hasStreamMask);
-                    #endif
-                    #if (CR_BIN_STREAMS_SIZE > 16)
-                        v[0] = t; __syncwarp(hasStreamMask); t = ::min(t, v[-16]); __syncwarp(hasStreamMask);
-                    #endif
-                    v[0] = t; __syncwarp(hasStreamMask);
-
-                    // Consume and broadcast.
-
-                    bool first = (s_scanTemp[0][CR_BIN_STREAMS_SIZE - 1 + 16] == firstTri);
-                    U32 firstMask = __ballot_sync(hasStreamMask, first);
-                    if (first && (firstMask >> threadIdx.x) == 1u)
-                    {
-                        int segIdx = s_binStreamCurrSeg[thrInBlock];
-                        s_binStreamSelectedOfs = segIdx << CR_BIN_SEG_LOG2;
-                        if (segIdx != -1)
-                        {
-                            int segSize = binSegCount[segIdx];
-                            int segNext = binSegNext[segIdx];
-                            s_binStreamSelectedSize = segSize;
-                            s_triQueueWritePos = triQueueWritePos + segSize;
-                            s_binStreamCurrSeg[thrInBlock] = segNext;
-                            s_binStreamFirstTri[thrInBlock] = (segNext == -1) ? ~0u : binSegData[segNext << CR_BIN_SEG_LOG2];
-                        }
-                    }
-                }
-
-                // No more segments => break.
-
-                __syncthreads();
-                triQueueWritePos = s_triQueueWritePos;
-                int segOfs = s_binStreamSelectedOfs;
-                if (segOfs < 0)
-                    break;
-
-                int segSize = s_binStreamSelectedSize;
-                __syncthreads();
-
-                // Fetch triangles into the queue.
-
-                for (int idxInSeg = CR_COARSE_WARPS * 32 - 1 - thrInBlock; idxInSeg < segSize; idxInSeg += CR_COARSE_WARPS * 32)
-                {
-                    S32 triIdx = binSegData[segOfs + idxInSeg];
-                    s_triQueue[(triQueueWritePos - segSize + idxInSeg) & (CR_COARSE_QUEUE_SIZE - 1)] = triIdx;
-                }
-            }
-
-            // All threads: Clear emit masks.
-
-            for (int maskIdx = thrInBlock; maskIdx < CR_COARSE_WARPS * CR_BIN_SQR; maskIdx += CR_COARSE_WARPS * 32)
-                s_warpEmitMask[maskIdx >> (CR_BIN_LOG2 * 2)][maskIdx & (CR_BIN_SQR - 1)] = 0;
-
-            __syncthreads();
-
-            //------------------------------------------------------------------------
-            // Raster.
-            //------------------------------------------------------------------------
-
-            // Triangle per thread: Read from the queue.
-
-            int triIdx = -1;
-            if (triQueueReadPos + thrInBlock < triQueueWritePos)
-                triIdx = s_triQueue[(triQueueReadPos + thrInBlock) & (CR_COARSE_QUEUE_SIZE - 1)];
-
-            uint4 triData = make_uint4(0, 0, 0, 0);
-            if (triIdx != -1)
-            {
-                int dataIdx = triIdx >> 3;
-                int subtriIdx = triIdx & 7;
-                if (subtriIdx != 7)
-                    dataIdx = triHeader[dataIdx].misc + subtriIdx;
-                triData = *((uint4*)triHeader + dataIdx);
-            }
-
-            // 32 triangles per warp: Record emits (= tile intersections).
-
-            if (__any_sync(~0u, triIdx != -1))
-            {
-                S32 v0x = sub_s16lo_s16lo(triData.x, originX);
-                S32 v0y = sub_s16hi_s16lo(triData.x, originY);
-                S32 d01x = sub_s16lo_s16lo(triData.y, triData.x);
-                S32 d01y = sub_s16hi_s16hi(triData.y, triData.x);
-                S32 d02x = sub_s16lo_s16lo(triData.z, triData.x);
-                S32 d02y = sub_s16hi_s16hi(triData.z, triData.x);
-
-                // Compute tile-based AABB.
-
-                int lox = add_clamp_0_x((v0x + min_min(d01x, 0, d02x)) >> tileLog, 0, maxTileXInBin);
-                int loy = add_clamp_0_x((v0y + min_min(d01y, 0, d02y)) >> tileLog, 0, maxTileYInBin);
-                int hix = add_clamp_0_x((v0x + max_max(d01x, 0, d02x)) >> tileLog, 0, maxTileXInBin);
-                int hiy = add_clamp_0_x((v0y + max_max(d01y, 0, d02y)) >> tileLog, 0, maxTileYInBin);
-                int sizex = add_sub(hix, 1, lox);
-                int sizey = add_sub(hiy, 1, loy);
-                int area = sizex * sizey;
-
-                // Miscellaneous init.
-
-                U8* currPtr = (U8*)&s_warpEmitMask[threadIdx.y][lox + (loy << CR_BIN_LOG2)];
-                int ptrYInc = CR_BIN_SIZE * 4 - (sizex << 2);
-                U32 maskBit = 1 << threadIdx.x;
-
-                // Case A: All AABBs are small => record the full AABB using atomics.
-
-                if (__all_sync(~0u, sizex <= 2 && sizey <= 2))
-                {
-                    if (triIdx != -1)
-                    {
-                        atomicOr((U32*)currPtr, maskBit);
-                        if (sizex == 2) atomicOr((U32*)(currPtr + 4), maskBit);
-                        if (sizey == 2) atomicOr((U32*)(currPtr + CR_BIN_SIZE * 4), maskBit);
-                        if (sizex == 2 && sizey == 2) atomicOr((U32*)(currPtr + 4 + CR_BIN_SIZE * 4), maskBit);
-                    }
-                }
-                else
-                {
-                    // Compute warp-AABB (scan-32).
-
-                    U32 aabbMask = add_sub(2 << hix, 0x20000 << hiy, 1 << lox) - (0x10000 << loy);
-                    if (triIdx == -1)
-                        aabbMask = 0;
-
-                    volatile U32* v = &s_scanTemp[threadIdx.y][threadIdx.x + 16];
-                    v[0] = aabbMask; __syncwarp(); aabbMask |= v[-1]; __syncwarp();
-                    v[0] = aabbMask; __syncwarp(); aabbMask |= v[-2]; __syncwarp();
-                    v[0] = aabbMask; __syncwarp(); aabbMask |= v[-4]; __syncwarp();
-                    v[0] = aabbMask; __syncwarp(); aabbMask |= v[-8]; __syncwarp();
-                    v[0] = aabbMask; __syncwarp(); aabbMask |= v[-16]; __syncwarp();
-                    v[0] = aabbMask; __syncwarp(); aabbMask = s_scanTemp[threadIdx.y][47];
-
-                    U32 maskX = aabbMask & 0xFFFF;
-                    U32 maskY = aabbMask >> 16;
-                    int wlox = findLeadingOne(maskX ^ (maskX - 1));
-                    int wloy = findLeadingOne(maskY ^ (maskY - 1));
-                    int whix = findLeadingOne(maskX);
-                    int whiy = findLeadingOne(maskY);
-                    int warea = (add_sub(whix, 1, wlox)) * (add_sub(whiy, 1, wloy));
-
-                    // Initialize edge functions.
-
-                    S32 d12x = d02x - d01x;
-                    S32 d12y = d02y - d01y;
-                    v0x -= lox << tileLog;
-                    v0y -= loy << tileLog;
-
-                    S32 t01 = v0x * d01y - v0y * d01x;
-                    S32 t02 = v0y * d02x - v0x * d02y;
-                    S32 t12 = d01x * d12y - d01y * d12x - t01 - t02;
-                    S32 b01 = add_sub(t01 >> tileLog, ::max(d01x, 0), ::min(d01y, 0));
-                    S32 b02 = add_sub(t02 >> tileLog, ::max(d02y, 0), ::min(d02x, 0));
-                    S32 b12 = add_sub(t12 >> tileLog, ::max(d12x, 0), ::min(d12y, 0));
-
-                    d01x += sizex * d01y;
-                    d02x += sizex * d02y;
-                    d12x += sizex * d12y;
-
-                    // Case B: Warp-AABB is not much larger than largest AABB => Check tiles in warp-AABB, record using ballots.
-                    if (__any_sync(~0u, warea * 4 <= area * 8))
-                    {
-                        // Not sure if this is any faster than Case C after all the post-Volta ballot mask tracking.
-                        bool act = (triIdx != -1);
-                        U32 actMask = __ballot_sync(~0u, act);
-                        if (act)
-                        {
-                            for (int y = wloy; y <= whiy; y++)
-                            {
-                                bool yIn = (y >= loy && y <= hiy);
-                                U32 yMask = __ballot_sync(actMask, yIn);
-                                if (yIn)
-                                {
-                                    for (int x = wlox; x <= whix; x++)
-                                    {
-                                        bool xyIn = (x >= lox && x <= hix);
-                                        U32 xyMask = __ballot_sync(yMask, xyIn);
-                                        if (xyIn)
-                                        {
-                                            U32 res = __ballot_sync(xyMask, b01 >= 0 && b02 >= 0 && b12 >= 0);
-                                            if (threadIdx.x == 31 - __clz(xyMask))
-                                                *(U32*)currPtr = res;
-                                            currPtr += 4, b01 -= d01y, b02 += d02y, b12 -= d12y;
-                                        }
-                                    }
-                                    currPtr += ptrYInc, b01 += d01x, b02 -= d02x, b12 += d12x;
-                                }
-                            }
-                        }
-                    }
-
-                    // Case C: General case => Check tiles in AABB, record using atomics.
-
-                    else
-                    {
-                        if (triIdx != -1)
-                        {
-                            U8* skipPtr = currPtr + (sizex << 2);
-                            U8* endPtr  = currPtr + (sizey << (CR_BIN_LOG2 + 2));
-                            do
-                            {
-                                if (b01 >= 0 && b02 >= 0 && b12 >= 0)
-                                    atomicOr((U32*)currPtr, maskBit);
-                                currPtr += 4, b01 -= d01y, b02 += d02y, b12 -= d12y;
-                                if (currPtr == skipPtr)
-                                    currPtr += ptrYInc, b01 += d01x, b02 -= d02x, b12 += d12x, skipPtr += CR_BIN_SIZE * 4;
-                            }
-                            while (currPtr != endPtr);
-                        }
-                    }
-                }
-            }
-
-            __syncthreads();
-
-            //------------------------------------------------------------------------
-            // Count.
-            //------------------------------------------------------------------------
-
-            // Tile per thread: Initialize prefix sums.
-
-            for (int tileInBin_base = 0; tileInBin_base < CR_BIN_SQR; tileInBin_base += CR_COARSE_WARPS * 32)
-            {
-                int tileInBin = tileInBin_base + thrInBlock;
-                bool act = (tileInBin < CR_BIN_SQR);
-                U32 actMask = __ballot_sync(~0u, act);
-                if (act)
-                {
-                    // Compute prefix sum of emits over warps.
-
-                    U8* srcPtr = (U8*)&s_warpEmitMask[0][tileInBin];
-                    U8* dstPtr = (U8*)&s_warpEmitPrefixSum[0][tileInBin];
-                    int tileEmits = 0;
-                    for (int i = 0; i < CR_COARSE_WARPS; i++)
-                    {
-                        tileEmits += __popc(*(U32*)srcPtr);
-                        *(U32*)dstPtr = tileEmits;
-                        srcPtr += (CR_BIN_SQR + 1) * 4;
-                        dstPtr += (CR_BIN_SQR + 1) * 4;
-                    }
-
-                    // Determine the number of segments to allocate.
-
-                    int spaceLeft = -s_tileStreamCurrOfs[tileInBin] & (CR_TILE_SEG_SIZE - 1);
-                    int tileAllocs = (tileEmits - spaceLeft + CR_TILE_SEG_SIZE - 1) >> CR_TILE_SEG_LOG2;
-                    volatile U32* v = &s_tileEmitPrefixSum[tileInBin + 1];
-
-                    // All counters within the warp are small => compute prefix sum using ballot.
-
-                    if (!__any_sync(actMask, tileEmits >= 2))
-                    {
-                        U32 m = getLaneMaskLe();
-                        *v = (__popc(__ballot_sync(actMask, tileEmits & 1) & m) << emitShift) | __popc(__ballot_sync(actMask, tileAllocs & 1) & m);
-                    }
-
-                    // Otherwise => scan-32 within the warp.
-
-                    else
-                    {
-                        U32 sum = (tileEmits << emitShift) | tileAllocs;
-                        *v = sum; __syncwarp(actMask); if (threadIdx.x >= 1)  sum += v[-1]; __syncwarp(actMask);
-                        *v = sum; __syncwarp(actMask); if (threadIdx.x >= 2)  sum += v[-2]; __syncwarp(actMask);
-                        *v = sum; __syncwarp(actMask); if (threadIdx.x >= 4)  sum += v[-4]; __syncwarp(actMask);
-                        *v = sum; __syncwarp(actMask); if (threadIdx.x >= 8)  sum += v[-8]; __syncwarp(actMask);
-                        *v = sum; __syncwarp(actMask); if (threadIdx.x >= 16) sum += v[-16]; __syncwarp(actMask);
-                        *v = sum; __syncwarp(actMask);
-                    }
-                }
-            }
-
-            // First warp: Scan-8.
-
-            __syncthreads();
-
-            bool scan8 = (thrInBlock < CR_BIN_SQR / 32);
-            U32 scan8Mask = __ballot_sync(~0u, scan8);
-            if (scan8)
-            {
-                int sum = s_tileEmitPrefixSum[(thrInBlock << 5) + 32];
-                volatile U32* v = &s_scanTemp[0][thrInBlock + 16];
-                v[0] = sum; __syncwarp(scan8Mask);
-                #if (CR_BIN_SQR > 1 * 32)
-                    sum += v[-1]; __syncwarp(scan8Mask); v[0] = sum; __syncwarp(scan8Mask);
-                #endif
-                #if (CR_BIN_SQR > 2 * 32)
-                    sum += v[-2]; __syncwarp(scan8Mask); v[0] = sum; __syncwarp(scan8Mask);
-                #endif
-                #if (CR_BIN_SQR > 4 * 32)
-                    sum += v[-4]; __syncwarp(scan8Mask); v[0] = sum; __syncwarp(scan8Mask);
-                #endif
-            }
-
-            __syncthreads();
-
-            // Tile per thread: Finalize prefix sums.
-            // Single thread: Allocate segments.
-
-            for (int tileInBin = thrInBlock; tileInBin < CR_BIN_SQR; tileInBin += CR_COARSE_WARPS * 32)
-            {
-                int sum = s_tileEmitPrefixSum[tileInBin + 1] + s_scanTemp[0][(tileInBin >> 5) + 15];
-                int numEmits = sum >> emitShift;
-                int numAllocs = sum & ((1 << emitShift) - 1);
-                s_tileEmitPrefixSum[tileInBin + 1] = numEmits;
-                s_tileAllocPrefixSum[tileInBin + 1] = numAllocs;
-
-                if (tileInBin == CR_BIN_SQR - 1 && numAllocs != 0)
-                {
-                    int t = atomicAdd(&atomics.numTileSegs, numAllocs);
-                    s_firstAllocSeg = (t + numAllocs <= p.maxTileSegs) ? t : 0;
-                }
-            }
-
-            __syncthreads();
-            int firstAllocSeg   = s_firstAllocSeg;
-            int totalEmits      = s_tileEmitPrefixSum[CR_BIN_SQR];
-            int totalAllocs     = s_tileAllocPrefixSum[CR_BIN_SQR];
-
-            //------------------------------------------------------------------------
-            // Emit.
-            //------------------------------------------------------------------------
-
-            // Emit per thread: Write triangle index to globalmem.
-
-            for (int emitInBin = thrInBlock; emitInBin < totalEmits; emitInBin += CR_COARSE_WARPS * 32)
-            {
-                // Find tile in bin.
-
-                U8* tileBase = (U8*)&s_tileEmitPrefixSum[0];
-                U8* tilePtr = tileBase;
-                U8* ptr;
-
-                #if (CR_BIN_SQR > 128)
-                    ptr = tilePtr + 0x80 * 4; if (emitInBin >= *(U32*)ptr) tilePtr = ptr;
-                #endif
-                #if (CR_BIN_SQR > 64)
-                    ptr = tilePtr + 0x40 * 4; if (emitInBin >= *(U32*)ptr) tilePtr = ptr;
-                #endif
-                #if (CR_BIN_SQR > 32)
-                    ptr = tilePtr + 0x20 * 4; if (emitInBin >= *(U32*)ptr) tilePtr = ptr;
-                #endif
-                #if (CR_BIN_SQR > 16)
-                    ptr = tilePtr + 0x10 * 4; if (emitInBin >= *(U32*)ptr) tilePtr = ptr;
-                #endif
-                #if (CR_BIN_SQR > 8)
-                    ptr = tilePtr + 0x08 * 4; if (emitInBin >= *(U32*)ptr) tilePtr = ptr;
-                #endif
-                #if (CR_BIN_SQR > 4)
-                    ptr = tilePtr + 0x04 * 4; if (emitInBin >= *(U32*)ptr) tilePtr = ptr;
-                #endif
-                #if (CR_BIN_SQR > 2)
-                    ptr = tilePtr + 0x02 * 4; if (emitInBin >= *(U32*)ptr) tilePtr = ptr;
-                #endif
-                #if (CR_BIN_SQR > 1)
-                    ptr = tilePtr + 0x01 * 4; if (emitInBin >= *(U32*)ptr) tilePtr = ptr;
-                #endif
-
-                int tileInBin = (tilePtr - tileBase) >> 2;
-                int emitInTile = emitInBin - *(U32*)tilePtr;
-
-                // Find warp in tile.
-
-                int warpStep = (CR_BIN_SQR + 1) * 4;
-                U8* warpBase = (U8*)&s_warpEmitPrefixSum[0][tileInBin] - warpStep;
-                U8* warpPtr = warpBase;
-
-                #if (CR_COARSE_WARPS > 8)
-                    ptr = warpPtr + 0x08 * warpStep; if (emitInTile >= *(U32*)ptr) warpPtr = ptr;
-                #endif
-                #if (CR_COARSE_WARPS > 4)
-                    ptr = warpPtr + 0x04 * warpStep; if (emitInTile >= *(U32*)ptr) warpPtr = ptr;
-                #endif
-                #if (CR_COARSE_WARPS > 2)
-                    ptr = warpPtr + 0x02 * warpStep; if (emitInTile >= *(U32*)ptr) warpPtr = ptr;
-                #endif
-                #if (CR_COARSE_WARPS > 1)
-                    ptr = warpPtr + 0x01 * warpStep; if (emitInTile >= *(U32*)ptr) warpPtr = ptr;
-                #endif
-
-                int warpInTile = (warpPtr - warpBase) >> (CR_BIN_LOG2 * 2 + 2);
-                U32 emitMask = *(U32*)(warpPtr + warpStep + ((U8*)s_warpEmitMask - (U8*)s_warpEmitPrefixSum));
-                int emitInWarp = emitInTile - *(U32*)(warpPtr + warpStep) + __popc(emitMask);
-
-                // Find thread in warp.
-
-                int threadInWarp = 0;
-                int pop = __popc(emitMask & 0xFFFF);
-                bool pred = (emitInWarp >= pop);
-                if (pred) emitInWarp -= pop;
-                if (pred) emitMask >>= 0x10;
-                if (pred) threadInWarp += 0x10;
-
-                pop = __popc(emitMask & 0xFF);
-                pred = (emitInWarp >= pop);
-                if (pred) emitInWarp -= pop;
-                if (pred) emitMask >>= 0x08;
-                if (pred) threadInWarp += 0x08;
-
-                pop = __popc(emitMask & 0xF);
-                pred = (emitInWarp >= pop);
-                if (pred) emitInWarp -= pop;
-                if (pred) emitMask >>= 0x04;
-                if (pred) threadInWarp += 0x04;
-
-                pop = __popc(emitMask & 0x3);
-                pred = (emitInWarp >= pop);
-                if (pred) emitInWarp -= pop;
-                if (pred) emitMask >>= 0x02;
-                if (pred) threadInWarp += 0x02;
-
-                if (emitInWarp >= (emitMask & 1))
-                    threadInWarp++;
-
-                // Figure out where to write.
-
-                int currOfs = s_tileStreamCurrOfs[tileInBin];
-                int spaceLeft = -currOfs & (CR_TILE_SEG_SIZE - 1);
-                int outOfs = emitInTile;
-
-                if (outOfs < spaceLeft)
-                    outOfs += currOfs;
-                else
-                {
-                    int allocLo = firstAllocSeg + s_tileAllocPrefixSum[tileInBin];
-                    outOfs += (allocLo << CR_TILE_SEG_LOG2) - spaceLeft;
-                }
-
-                // Write.
-
-                int queueIdx = warpInTile * 32 + threadInWarp;
-                int triIdx = s_triQueue[(triQueueReadPos + queueIdx) & (CR_COARSE_QUEUE_SIZE - 1)];
-
-                tileSegData[outOfs] = triIdx;
-            }
-
-            //------------------------------------------------------------------------
-            // Patch.
-            //------------------------------------------------------------------------
-
-            // Allocated segment per thread: Initialize next-pointer and count.
-
-            for (int i = CR_COARSE_WARPS * 32 - 1 - thrInBlock; i < totalAllocs; i += CR_COARSE_WARPS * 32)
-            {
-                int segIdx = firstAllocSeg + i;
-                tileSegNext[segIdx] = segIdx + 1;
-                tileSegCount[segIdx] = CR_TILE_SEG_SIZE;
-            }
-
-            // Tile per thread: Fix previous segment's next-pointer and update s_tileStreamCurrOfs.
-
-            __syncthreads();
-            for (int tileInBin = CR_COARSE_WARPS * 32 - 1 - thrInBlock; tileInBin < CR_BIN_SQR; tileInBin += CR_COARSE_WARPS * 32)
-            {
-                int oldOfs = s_tileStreamCurrOfs[tileInBin];
-                int newOfs = oldOfs + s_warpEmitPrefixSum[CR_COARSE_WARPS - 1][tileInBin];
-                int allocLo = s_tileAllocPrefixSum[tileInBin];
-                int allocHi = s_tileAllocPrefixSum[tileInBin + 1];
-
-                if (allocLo != allocHi)
-                {
-                    S32* nextPtr = &tileSegNext[(oldOfs - 1) >> CR_TILE_SEG_LOG2];
-                    if (oldOfs < 0)
-                        nextPtr = &tileFirstSeg[binTileIdx + globalTileIdx(tileInBin, p.widthTiles)];
-                    *nextPtr = firstAllocSeg + allocLo;
-
-                    newOfs--;
-                    newOfs &= CR_TILE_SEG_SIZE - 1;
-                    newOfs |= (firstAllocSeg + allocHi - 1) << CR_TILE_SEG_LOG2;
-                    newOfs++;
-                }
-                s_tileStreamCurrOfs[tileInBin] = newOfs;
-            }
-
-            // Advance queue read pointer.
-            // Queue became empty => bin done.
-
-            triQueueReadPos += CR_COARSE_WARPS * 32;
-        }
-        while (triQueueReadPos < triQueueWritePos);
-
-        // Tile per thread: Fix next-pointer and count of the last segment.
-        // 32 tiles per warp: Count active tiles.
-
-        __syncthreads();
-
-        for (int tileInBin_base = 0; tileInBin_base < CR_BIN_SQR; tileInBin_base += CR_COARSE_WARPS * 32)
-        {
-            int tileInBin = tileInBin_base + thrInBlock;
-            bool act = (tileInBin < CR_BIN_SQR);
-            U32 actMask = __ballot_sync(~0u, act);
-            if (act)
-            {
-                int tileX = tileInBin & (CR_BIN_SIZE - 1);
-                int tileY = tileInBin >> CR_BIN_LOG2;
-                bool force = (p.deferredClear & tileX <= maxTileXInBin & tileY <= maxTileYInBin);
-
-                int ofs = s_tileStreamCurrOfs[tileInBin];
-                int segIdx = (ofs - 1) >> CR_TILE_SEG_LOG2;
-                int segCount = ofs & (CR_TILE_SEG_SIZE - 1);
-
-                if (ofs >= 0)
-                    tileSegNext[segIdx] = -1;
-                else if (force)
-                {
-                    s_tileStreamCurrOfs[tileInBin] = 0;
-                    tileFirstSeg[binTileIdx + tileX + tileY * p.widthTiles] = -1;
-                }
-
-                if (segCount != 0)
-                    tileSegCount[segIdx] = segCount;
-
-                U32 res = __ballot_sync(actMask, ofs >= 0 | force);
-                if (threadIdx.x == 0)
-                    s_scanTemp[0][(tileInBin >> 5) + 16] = __popc(res);
-            }
-        }
-
-        // First warp: Scan-8.
-        // One thread: Allocate space for active tiles.
-
-        __syncthreads();
-
-        bool scan8 = (thrInBlock < CR_BIN_SQR / 32);
-        U32 scan8Mask = __ballot_sync(~0u, scan8);
-        if (scan8)
-        {
-            volatile U32* v = &s_scanTemp[0][thrInBlock + 16];
-            U32 sum = v[0];
-            #if (CR_BIN_SQR > 1 * 32)
-                sum += v[-1]; __syncwarp(scan8Mask); v[0] = sum; __syncwarp(scan8Mask);
-            #endif
-            #if (CR_BIN_SQR > 2 * 32)
-                sum += v[-2]; __syncwarp(scan8Mask); v[0] = sum; __syncwarp(scan8Mask);
-            #endif
-            #if (CR_BIN_SQR > 4 * 32)
-                sum += v[-4]; __syncwarp(scan8Mask); v[0] = sum; __syncwarp(scan8Mask);
-            #endif
-
-            if (thrInBlock == CR_BIN_SQR / 32 - 1)
-                s_firstActiveIdx = atomicAdd(&atomics.numActiveTiles, sum);
-        }
-
-        // Tile per thread: Output active tiles.
-
-        __syncthreads();
-
-        for (int tileInBin_base = 0; tileInBin_base < CR_BIN_SQR; tileInBin_base += CR_COARSE_WARPS * 32)
-        {
-            int tileInBin = tileInBin_base + thrInBlock;
-            bool act = (tileInBin < CR_BIN_SQR) && (s_tileStreamCurrOfs[tileInBin] >= 0);
-            U32 actMask = __ballot_sync(~0u, act);
-            if (act)
-            {
-                int activeIdx = s_firstActiveIdx;
-                activeIdx += s_scanTemp[0][(tileInBin >> 5) + 15];
-                activeIdx += __popc(actMask & getLaneMaskLt());
-                activeTiles[activeIdx] = binTileIdx + globalTileIdx(tileInBin, p.widthTiles);
-            }
-        }
-    }
-}
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/Constants.hpp

@@ -1,73 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#pragma once
-
-//------------------------------------------------------------------------
-
-#define CR_MAXVIEWPORT_LOG2     11      // ViewportSize / PixelSize.
-#define CR_SUBPIXEL_LOG2        4       // PixelSize / SubpixelSize.
-
-#define CR_MAXBINS_LOG2         4       // ViewportSize / BinSize.
-#define CR_BIN_LOG2             4       // BinSize / TileSize.
-#define CR_TILE_LOG2            3       // TileSize / PixelSize.
-
-#define CR_COVER8X8_LUT_SIZE    768     // 64-bit entries.
-#define CR_FLIPBIT_FLIP_Y       2
-#define CR_FLIPBIT_FLIP_X       3
-#define CR_FLIPBIT_SWAP_XY      4
-#define CR_FLIPBIT_COMPL        5
-
-#define CR_BIN_STREAMS_LOG2     4
-#define CR_BIN_SEG_LOG2         9       // 32-bit entries.
-#define CR_TILE_SEG_LOG2        5       // 32-bit entries.
-
-#define CR_MAXSUBTRIS_LOG2      24      // Triangle structs. Dictated by CoarseRaster.
-#define CR_COARSE_QUEUE_LOG2    10      // Triangles.
-
-#define CR_SETUP_WARPS          2
-#define CR_SETUP_OPT_BLOCKS     8
-#define CR_BIN_WARPS            16
-#define CR_COARSE_WARPS         16      // Must be a power of two.
-#define CR_FINE_MAX_WARPS       20
-
-#define CR_EMBED_IMAGE_PARAMS   32      // Number of per-image parameter structs embedded in kernel launch parameter block.
-
-//------------------------------------------------------------------------
-
-#define CR_MAXVIEWPORT_SIZE     (1 << CR_MAXVIEWPORT_LOG2)
-#define CR_SUBPIXEL_SIZE        (1 << CR_SUBPIXEL_LOG2)
-#define CR_SUBPIXEL_SQR         (1 << (CR_SUBPIXEL_LOG2 * 2))
-
-#define CR_MAXBINS_SIZE         (1 << CR_MAXBINS_LOG2)
-#define CR_MAXBINS_SQR          (1 << (CR_MAXBINS_LOG2 * 2))
-#define CR_BIN_SIZE             (1 << CR_BIN_LOG2)
-#define CR_BIN_SQR              (1 << (CR_BIN_LOG2 * 2))
-
-#define CR_MAXTILES_LOG2        (CR_MAXBINS_LOG2 + CR_BIN_LOG2)
-#define CR_MAXTILES_SIZE        (1 << CR_MAXTILES_LOG2)
-#define CR_MAXTILES_SQR         (1 << (CR_MAXTILES_LOG2 * 2))
-#define CR_TILE_SIZE            (1 << CR_TILE_LOG2)
-#define CR_TILE_SQR             (1 << (CR_TILE_LOG2 * 2))
-
-#define CR_BIN_STREAMS_SIZE     (1 << CR_BIN_STREAMS_LOG2)
-#define CR_BIN_SEG_SIZE         (1 << CR_BIN_SEG_LOG2)
-#define CR_TILE_SEG_SIZE        (1 << CR_TILE_SEG_LOG2)
-
-#define CR_MAXSUBTRIS_SIZE      (1 << CR_MAXSUBTRIS_LOG2)
-#define CR_COARSE_QUEUE_SIZE    (1 << CR_COARSE_QUEUE_LOG2)
-
-//------------------------------------------------------------------------
-// When evaluating interpolated Z pixel centers, we may introduce an error
-// of (+-CR_LERP_ERROR) ULPs.
-
-#define CR_LERP_ERROR(SAMPLES_LOG2) (2200u << (SAMPLES_LOG2))
-#define CR_DEPTH_MIN                CR_LERP_ERROR(3)
-#define CR_DEPTH_MAX                (CR_U32_MAX - CR_LERP_ERROR(3))
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/CudaRaster.cpp

@@ -1,79 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#include "Defs.hpp"
-#include "../CudaRaster.hpp"
-#include "RasterImpl.hpp"
-
-using namespace CR;
-
-//------------------------------------------------------------------------
-// Stub interface implementation.
-//------------------------------------------------------------------------
-
-CudaRaster::CudaRaster()
-{
-    m_impl = new RasterImpl();
-}
-
-CudaRaster::~CudaRaster()
-{
-    delete m_impl;
-}
-
-void CudaRaster::setBufferSize(int width, int height, int numImages)
-{
-    m_impl->setBufferSize(Vec3i(width, height, numImages));
-}
-
-void CudaRaster::setViewport(int width, int height, int offsetX, int offsetY)
-{
-    m_impl->setViewport(Vec2i(width, height), Vec2i(offsetX, offsetY));
-}
-
-void CudaRaster::setRenderModeFlags(U32 flags)
-{
-    m_impl->setRenderModeFlags(flags);
-}
-
-void CudaRaster::deferredClear(U32 clearColor)
-{
-    m_impl->deferredClear(clearColor);
-}
-
-void CudaRaster::setVertexBuffer(void* vertices, int numVertices)
-{
-    m_impl->setVertexBuffer(vertices, numVertices);
-}
-
-void CudaRaster::setIndexBuffer(void* indices, int numTriangles)
-{
-    m_impl->setIndexBuffer(indices, numTriangles);
-}
-
-bool CudaRaster::drawTriangles(const int* ranges, bool peel, cudaStream_t stream)
-{
-    return m_impl->drawTriangles((const Vec2i*)ranges, peel, stream);
-}
-
-void* CudaRaster::getColorBuffer(void)
-{
-    return m_impl->getColorBuffer();
-}
-
-void* CudaRaster::getDepthBuffer(void)
-{
-    return m_impl->getDepthBuffer();
-}
-
-void CudaRaster::swapDepthAndPeel(void)
-{
-    m_impl->swapDepthAndPeel();
-}
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/Defs.hpp

@@ -1,90 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#pragma once
-#include <cuda_runtime.h>
-#include <cstdint>
-
-namespace CR
-{
-//------------------------------------------------------------------------
-
-#ifndef NULL
-#   define NULL 0
-#endif
-
-#ifdef __CUDACC__
-#   define CR_CUDA 1
-#else
-#   define CR_CUDA 0
-#endif
-
-#if CR_CUDA
-#   define CR_CUDA_FUNC     __device__ __inline__
-#   define CR_CUDA_CONST    __constant__
-#else
-#   define CR_CUDA_FUNC     inline
-#   define CR_CUDA_CONST    static const
-#endif
-
-#define CR_UNREF(X)         ((void)(X))
-#define CR_ARRAY_SIZE(X)    ((int)(sizeof(X) / sizeof((X)[0])))
-
-//------------------------------------------------------------------------
-
-typedef uint8_t             U8;
-typedef uint16_t            U16;
-typedef uint32_t            U32;
-typedef uint64_t            U64;
-typedef int8_t              S8;
-typedef int16_t             S16;
-typedef int32_t             S32;
-typedef int64_t             S64;
-typedef float               F32;
-typedef double              F64;
-typedef void                (*FuncPtr)(void);
-
-//------------------------------------------------------------------------
-
-#define CR_U32_MAX          (0xFFFFFFFFu)
-#define CR_S32_MIN          (~0x7FFFFFFF)
-#define CR_S32_MAX          (0x7FFFFFFF)
-#define CR_U64_MAX          ((U64)(S64)-1)
-#define CR_S64_MIN          ((S64)-1 << 63)
-#define CR_S64_MAX          (~((S64)-1 << 63))
-#define CR_F32_MIN          (1.175494351e-38f)
-#define CR_F32_MAX          (3.402823466e+38f)
-#define CR_F64_MIN          (2.2250738585072014e-308)
-#define CR_F64_MAX          (1.7976931348623158e+308)
-
-//------------------------------------------------------------------------
-// Misc types.
-
-class Vec2i
-{
-public:
-    Vec2i(int x_, int y_) : x(x_), y(y_) {}
-    int x, y;
-};
-
-class Vec3i
-{
-public:
-    Vec3i(int x_, int y_, int z_) : x(x_), y(y_), z(z_) {}
-    int x, y, z;
-};
-
-//------------------------------------------------------------------------
-// CUDA utilities.
-
-#if CR_CUDA
-#   define globalThreadIdx (threadIdx.x + blockDim.x * (threadIdx.y + blockDim.y * (blockIdx.x + gridDim.x * blockIdx.y)))
-#endif
-
-//------------------------------------------------------------------------
-} // namespace CR

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/FineRaster.inl

@@ -1,385 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-//------------------------------------------------------------------------
-// Utility funcs.
-//------------------------------------------------------------------------
-
-__device__ __inline__ void initTileZMax(U32& tileZMax, bool& tileZUpd, volatile U32* tileDepth)
-{
-    tileZMax = CR_DEPTH_MAX;
-    tileZUpd = (::min(tileDepth[threadIdx.x], tileDepth[threadIdx.x + 32]) < tileZMax);
-}
-
-__device__ __inline__ void updateTileZMax(U32& tileZMax, bool& tileZUpd, volatile U32* tileDepth, volatile U32* temp)
-{
-    // Entry is warp-coherent.
-    if (__any_sync(~0u, tileZUpd))
-    {
-        U32 z = ::max(tileDepth[threadIdx.x], tileDepth[threadIdx.x + 32]); __syncwarp();
-        temp[threadIdx.x + 16] = z; __syncwarp();
-        z = ::max(z, temp[threadIdx.x + 16 -  1]); __syncwarp(); temp[threadIdx.x + 16] = z; __syncwarp();
-        z = ::max(z, temp[threadIdx.x + 16 -  2]); __syncwarp(); temp[threadIdx.x + 16] = z; __syncwarp();
-        z = ::max(z, temp[threadIdx.x + 16 -  4]); __syncwarp(); temp[threadIdx.x + 16] = z; __syncwarp();
-        z = ::max(z, temp[threadIdx.x + 16 -  8]); __syncwarp(); temp[threadIdx.x + 16] = z; __syncwarp();
-        z = ::max(z, temp[threadIdx.x + 16 - 16]); __syncwarp(); temp[threadIdx.x + 16] = z; __syncwarp();
-        tileZMax = temp[47];
-        tileZUpd = false;
-    }
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ void getTriangle(const CRParams& p, S32& triIdx, S32& dataIdx, uint4& triHeader, S32& segment)
-{
-    const CRTriangleHeader* triHeaderPtr    = (const CRTriangleHeader*)p.triHeader + blockIdx.z * p.maxSubtris;;
-    const S32*              tileSegData     = (const S32*)p.tileSegData  + p.maxTileSegs * CR_TILE_SEG_SIZE * blockIdx.z;
-    const S32*              tileSegNext     = (const S32*)p.tileSegNext  + p.maxTileSegs * blockIdx.z;
-    const S32*              tileSegCount    = (const S32*)p.tileSegCount + p.maxTileSegs * blockIdx.z;
-
-    if (threadIdx.x >= tileSegCount[segment])
-    {
-        triIdx = -1;
-        dataIdx = -1;
-    }
-    else
-    {
-        int subtriIdx = tileSegData[segment * CR_TILE_SEG_SIZE + threadIdx.x];
-        triIdx = subtriIdx >> 3;
-        dataIdx = triIdx;
-        subtriIdx &= 7;
-        if (subtriIdx != 7)
-            dataIdx = triHeaderPtr[triIdx].misc + subtriIdx;
-        triHeader = *((uint4*)triHeaderPtr + dataIdx);
-    }
-
-    // advance to next segment
-    segment = tileSegNext[segment];
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ bool earlyZCull(uint4 triHeader, U32 tileZMax)
-{
-    U32 zmin = triHeader.w & 0xFFFFF000;
-    return (zmin > tileZMax);
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ U64 trianglePixelCoverage(const CRParams& p, const uint4& triHeader, int tileX, int tileY, volatile U64* s_cover8x8_lut)
-{
-    int baseX = (tileX << (CR_TILE_LOG2 + CR_SUBPIXEL_LOG2)) - ((p.widthPixelsVp  - 1) << (CR_SUBPIXEL_LOG2 - 1));
-    int baseY = (tileY << (CR_TILE_LOG2 + CR_SUBPIXEL_LOG2)) - ((p.heightPixelsVp - 1) << (CR_SUBPIXEL_LOG2 - 1));
-
-    // extract S16 vertex positions while subtracting tile coordinates
-    S32 v0x  = sub_s16lo_s16lo(triHeader.x, baseX);
-    S32 v0y  = sub_s16hi_s16lo(triHeader.x, baseY);
-    S32 v01x = sub_s16lo_s16lo(triHeader.y, triHeader.x);
-    S32 v01y = sub_s16hi_s16hi(triHeader.y, triHeader.x);
-    S32 v20x = sub_s16lo_s16lo(triHeader.x, triHeader.z);
-    S32 v20y = sub_s16hi_s16hi(triHeader.x, triHeader.z);
-
-    // extract flipbits
-    U32 f01 = (triHeader.w >> 6) & 0x3C;
-    U32 f12 = (triHeader.w >> 2) & 0x3C;
-    U32 f20 = (triHeader.w << 2) & 0x3C;
-
-    // compute per-edge coverage masks
-    U64 c01, c12, c20;
-    c01 = cover8x8_exact_fast(v0x, v0y, v01x, v01y, f01, s_cover8x8_lut);
-    c12 = cover8x8_exact_fast(v0x + v01x, v0y + v01y, -v01x - v20x, -v01y - v20y, f12, s_cover8x8_lut);
-    c20 = cover8x8_exact_fast(v0x, v0y, v20x, v20y, f20, s_cover8x8_lut);
-
-    // combine masks
-    return c01 & c12 & c20;
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ U32 scan32_value(U32 value, volatile U32* temp)
-{
-    __syncwarp();
-    temp[threadIdx.x + 16] = value; __syncwarp();
-    value += temp[threadIdx.x + 16 -  1]; __syncwarp(); temp[threadIdx.x + 16] = value; __syncwarp();
-    value += temp[threadIdx.x + 16 -  2]; __syncwarp(); temp[threadIdx.x + 16] = value; __syncwarp();
-    value += temp[threadIdx.x + 16 -  4]; __syncwarp(); temp[threadIdx.x + 16] = value; __syncwarp();
-    value += temp[threadIdx.x + 16 -  8]; __syncwarp(); temp[threadIdx.x + 16] = value; __syncwarp();
-    value += temp[threadIdx.x + 16 - 16]; __syncwarp(); temp[threadIdx.x + 16] = value; __syncwarp();
-    return value;
-}
-
-__device__ __inline__ volatile const U32& scan32_total(volatile U32* temp)
-{
-    return temp[47];
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ S32 findBit(U64 mask, int idx)
-{
-    U32 x = getLo(mask);
-    int  pop = __popc(x);
-    bool p   = (pop <= idx);
-    if (p) x = getHi(mask);
-    if (p) idx -= pop;
-    int bit = p ? 32 : 0;
-
-    pop = __popc(x & 0x0000ffffu);
-    p   = (pop <= idx);
-    if (p) x >>= 16;
-    if (p) bit += 16;
-    if (p) idx -= pop;
-
-    U32 tmp = x & 0x000000ffu;
-    pop = __popc(tmp);
-    p   = (pop <= idx);
-    if (p) tmp = x & 0x0000ff00u;
-    if (p) idx -= pop;
-
-    return findLeadingOne(tmp) + bit - idx;
-}
-
-//------------------------------------------------------------------------
-// Single-sample implementation.
-//------------------------------------------------------------------------
-
-__device__ __inline__ void executeROP(U32 color, U32 depth, volatile U32* pColor, volatile U32* pDepth, U32 ropMask)
-{
-    atomicMin((U32*)pDepth, depth);
-    __syncwarp(ropMask);
-    bool act = (depth == *pDepth);
-    __syncwarp(ropMask);
-    U32 actMask = __ballot_sync(ropMask, act);
-    if (act)
-    {
-        *pDepth = 0;
-        __syncwarp(actMask);
-        atomicMax((U32*)pDepth, threadIdx.x);
-        __syncwarp(actMask);
-        if (*pDepth == threadIdx.x)
-        {
-            *pDepth = depth;
-            *pColor = color;
-        }
-        __syncwarp(actMask);
-    }
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ void fineRasterImpl(const CRParams p)
-{
-                                                                            // for 20 warps:
-    __shared__ volatile U64 s_cover8x8_lut[CR_COVER8X8_LUT_SIZE];           // 6KB
-    __shared__ volatile U32 s_tileColor   [CR_FINE_MAX_WARPS][CR_TILE_SQR]; // 5KB
-    __shared__ volatile U32 s_tileDepth   [CR_FINE_MAX_WARPS][CR_TILE_SQR]; // 5KB
-    __shared__ volatile U32 s_tilePeel    [CR_FINE_MAX_WARPS][CR_TILE_SQR]; // 5KB
-    __shared__ volatile U32 s_triDataIdx  [CR_FINE_MAX_WARPS][64];          // 5KB  CRTriangleData index
-    __shared__ volatile U64 s_triangleCov [CR_FINE_MAX_WARPS][64];          // 10KB coverage mask
-    __shared__ volatile U32 s_triangleFrag[CR_FINE_MAX_WARPS][64];          // 5KB  fragment index
-    __shared__ volatile U32 s_temp        [CR_FINE_MAX_WARPS][80];          // 6.25KB
-                                                                            // = 47.25KB total
-
-    CRAtomics&            atomics   = p.atomics[blockIdx.z];
-    const CRTriangleData* triData   = (const CRTriangleData*)p.triData + blockIdx.z * p.maxSubtris;
-
-    const S32*      activeTiles     = (const S32*)p.activeTiles  + CR_MAXTILES_SQR * blockIdx.z;
-    const S32*      tileFirstSeg    = (const S32*)p.tileFirstSeg + CR_MAXTILES_SQR * blockIdx.z;
-
-    volatile U32*   tileColor       = s_tileColor[threadIdx.y];
-    volatile U32*   tileDepth       = s_tileDepth[threadIdx.y];
-    volatile U32*   tilePeel        = s_tilePeel[threadIdx.y];
-    volatile U32*   triDataIdx      = s_triDataIdx[threadIdx.y];
-    volatile U64*   triangleCov     = s_triangleCov[threadIdx.y];
-    volatile U32*   triangleFrag    = s_triangleFrag[threadIdx.y];
-    volatile U32*   temp            = s_temp[threadIdx.y];
-
-    if (atomics.numSubtris > p.maxSubtris || atomics.numBinSegs > p.maxBinSegs || atomics.numTileSegs > p.maxTileSegs)
-        return;
-
-    temp[threadIdx.x] = 0; // first 16 elements of temp are always zero
-    cover8x8_setupLUT(s_cover8x8_lut);
-    __syncthreads();
-
-    // loop over tiles
-    for (;;)
-    {
-        // pick a tile
-        if (threadIdx.x == 0)
-            temp[16] = atomicAdd(&atomics.fineCounter, 1);
-        __syncwarp();
-        int activeIdx = temp[16];
-        if (activeIdx >= atomics.numActiveTiles)
-            break;
-
-        int tileIdx = activeTiles[activeIdx];
-        S32 segment = tileFirstSeg[tileIdx];
-        int tileY = tileIdx / p.widthTiles;
-        int tileX = tileIdx - tileY * p.widthTiles;
-        int px = (tileX << CR_TILE_LOG2) + (threadIdx.x & (CR_TILE_SIZE - 1));
-        int py = (tileY << CR_TILE_LOG2) + (threadIdx.x >> CR_TILE_LOG2);
-
-        // initialize per-tile state
-        int triRead = 0, triWrite = 0;
-        int fragRead = 0, fragWrite = 0;
-        if (threadIdx.x == 0)
-            triangleFrag[63] = 0; // "previous triangle"
-
-        // deferred clear => clear tile
-        if (p.deferredClear)
-        {
-			tileColor[threadIdx.x] = p.clearColor;
-            tileDepth[threadIdx.x] = p.clearDepth;
-            tileColor[threadIdx.x + 32] = p.clearColor;
-            tileDepth[threadIdx.x + 32] = p.clearDepth;
-        }
-        else // otherwise => read tile from framebuffer
-        {
-            U32* pColor = (U32*)p.colorBuffer + p.strideX * p.strideY * blockIdx.z;
-            U32* pDepth = (U32*)p.depthBuffer + p.strideX * p.strideY * blockIdx.z;
-			tileColor[threadIdx.x] = pColor[px + p.strideX * py];
-            tileDepth[threadIdx.x] = pDepth[px + p.strideX * py];
-            tileColor[threadIdx.x + 32] = pColor[px + p.strideX * (py + 4)];
-            tileDepth[threadIdx.x + 32] = pDepth[px + p.strideX * (py + 4)];
-        }
-
-        // read peeling inputs if enabled
-        if (p.renderModeFlags & CudaRaster::RenderModeFlag_EnableDepthPeeling)
-        {
-            U32* pPeel = (U32*)p.peelBuffer + p.strideX * p.strideY * blockIdx.z;
-            tilePeel[threadIdx.x] = pPeel[px + p.strideX * py];
-            tilePeel[threadIdx.x + 32] = pPeel[px + p.strideX * (py + 4)];
-        }
-
-        U32 tileZMax;
-        bool tileZUpd;
-        initTileZMax(tileZMax, tileZUpd, tileDepth);
-
-        // process fragments
-        for(;;)
-        {
-            // need to queue more fragments?
-            if (fragWrite - fragRead < 32 && segment >= 0)
-            {
-                // update tile z - coherent over warp
-                updateTileZMax(tileZMax, tileZUpd, tileDepth, temp);
-
-                // read triangles
-                do
-                {
-                    // read triangle index and data, advance to next segment
-                    S32 triIdx, dataIdx;
-                    uint4 triHeader;
-                    getTriangle(p, triIdx, dataIdx, triHeader, segment);
-
-                    // early z cull
-                    if (triIdx >= 0 && earlyZCull(triHeader, tileZMax))
-                        triIdx = -1;
-
-                    // determine coverage
-                    U64 coverage = trianglePixelCoverage(p, triHeader, tileX, tileY, s_cover8x8_lut);
-                    S32 pop = (triIdx == -1) ? 0 : __popcll(coverage);
-
-                    // fragment count scan
-                    U32 frag = scan32_value(pop, temp);
-                    frag += fragWrite; // frag now holds cumulative fragment count
-                    fragWrite += scan32_total(temp);
-
-                    // queue non-empty triangles
-                    U32 goodMask = __ballot_sync(~0u, pop != 0);
-                    if (pop != 0)
-                    {
-                        int idx = (triWrite + __popc(goodMask & getLaneMaskLt())) & 63;
-                        triDataIdx  [idx] = dataIdx;
-                        triangleFrag[idx] = frag;
-                        triangleCov [idx] = coverage;
-                    }
-                    triWrite += __popc(goodMask);
-                }
-                while (fragWrite - fragRead < 32 && segment >= 0);
-            }
-            __syncwarp();
-
-            // end of segment?
-            if (fragRead == fragWrite)
-                break;
-
-            // clear triangle boundaries
-            temp[threadIdx.x + 16] = 0;
-            __syncwarp();
-
-            // tag triangle boundaries
-            if (triRead + threadIdx.x < triWrite)
-            {
-                int idx = triangleFrag[(triRead + threadIdx.x) & 63] - fragRead;
-                if (idx <= 32)
-                    temp[idx + 16 - 1] = 1;
-            }
-            __syncwarp();
-
-            int ropLaneIdx = threadIdx.x;
-            U32 boundaryMask = __ballot_sync(~0u, temp[ropLaneIdx + 16]);
-
-            // distribute fragments
-            bool hasFragment = (ropLaneIdx < fragWrite - fragRead);
-            U32 fragmentMask = __ballot_sync(~0u, hasFragment);
-            if (hasFragment)
-            {
-                int triBufIdx = (triRead + __popc(boundaryMask & getLaneMaskLt())) & 63;
-                int fragIdx = add_sub(fragRead, ropLaneIdx, triangleFrag[(triBufIdx - 1) & 63]);
-                U64 coverage = triangleCov[triBufIdx];
-                int pixelInTile = findBit(coverage, fragIdx);
-                int dataIdx = triDataIdx[triBufIdx];
-
-                // determine pixel position
-                U32 pixelX = (tileX << CR_TILE_LOG2) + (pixelInTile & 7);
-                U32 pixelY = (tileY << CR_TILE_LOG2) + (pixelInTile >> 3);
-
-                // depth test
-                U32 depth = 0;
-                uint4 td = *((uint4*)triData + dataIdx * (sizeof(CRTriangleData) >> 4));
-
-                depth = td.x * pixelX + td.y * pixelY + td.z;
-                bool zkill = (p.renderModeFlags & CudaRaster::RenderModeFlag_EnableDepthPeeling) && (depth <= tilePeel[pixelInTile]);
-                if (!zkill)
-                {
-                    U32 oldDepth = tileDepth[pixelInTile];
-                    if (depth > oldDepth)
-                        zkill = true;
-                    else if (oldDepth == tileZMax)
-                        tileZUpd = true; // we are replacing previous zmax => need to update
-                }
-
-                U32 ropMask = __ballot_sync(fragmentMask, !zkill);
-                if (!zkill)
-					executeROP(td.w, depth, &tileColor[pixelInTile], &tileDepth[pixelInTile], ropMask);
-            }
-            // no need to sync, as next up is updateTileZMax that does internal warp sync
-
-            // update counters
-            fragRead = ::min(fragRead + 32, fragWrite);
-            triRead += __popc(boundaryMask);
-        }
-
-        // Write tile back to the framebuffer.
-        if (true)
-        {
-            int px = (tileX << CR_TILE_LOG2) + (threadIdx.x & (CR_TILE_SIZE - 1));
-            int py = (tileY << CR_TILE_LOG2) + (threadIdx.x >> CR_TILE_LOG2);
-            U32* pColor = (U32*)p.colorBuffer + p.strideX * p.strideY * blockIdx.z;
-            U32* pDepth = (U32*)p.depthBuffer + p.strideX * p.strideY * blockIdx.z;
-            pColor[px + p.strideX * py] = tileColor[threadIdx.x];
-            pDepth[px + p.strideX * py] = tileDepth[threadIdx.x];
-            pColor[px + p.strideX * (py + 4)] = tileColor[threadIdx.x + 32];
-            pDepth[px + p.strideX * (py + 4)] = tileDepth[threadIdx.x + 32];
-        }
-    }
-}
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/PrivateDefs.hpp

@@ -1,153 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#pragma once
-#include "Defs.hpp"
-#include "Constants.hpp"
-
-namespace CR
-{
-//------------------------------------------------------------------------
-// Projected triangle.
-//------------------------------------------------------------------------
-
-struct CRTriangleHeader
-{
-    S16 v0x;    // Subpixels relative to viewport center. Valid if triSubtris = 1.
-    S16 v0y;
-    S16 v1x;
-    S16 v1y;
-    S16 v2x;
-    S16 v2y;
-
-    U32 misc;   // triSubtris=1: (zmin:20, f01:4, f12:4, f20:4), triSubtris>=2: (subtriBase)
-};
-
-//------------------------------------------------------------------------
-
-struct CRTriangleData
-{
-    U32 zx;     // zx * sampleX + zy * sampleY + zb = lerp(CR_DEPTH_MIN, CR_DEPTH_MAX, (clipZ / clipW + 1) / 2)
-    U32 zy;
-    U32 zb;
-    U32 id;     // Triangle id.
-};
-
-//------------------------------------------------------------------------
-// Device-side structures.
-//------------------------------------------------------------------------
-
-struct CRAtomics
-{
-    // Setup.
-    S32         numSubtris;         // = numTris
-
-    // Bin.
-    S32         binCounter;         // = 0
-    S32         numBinSegs;         // = 0
-
-    // Coarse.
-    S32         coarseCounter;      // = 0
-    S32         numTileSegs;        // = 0
-    S32         numActiveTiles;     // = 0
-
-    // Fine.
-    S32         fineCounter;        // = 0
-};
-
-//------------------------------------------------------------------------
-
-struct CRImageParams
-{
-    S32         triOffset;          // First triangle index to draw.
-    S32         triCount;           // Number of triangles to draw.
-    S32         binBatchSize;       // Number of triangles per batch.
-};
-
-//------------------------------------------------------------------------
-
-struct CRParams
-{
-    // Common.
-
-    CRAtomics*  atomics;            // Work counters. Per-image.
-    S32         numImages;          // Batch size.
-    S32         totalCount;         // In range mode, total number of triangles to render.
-    S32         instanceMode;       // 0 = range mode, 1 = instance mode.
-
-    S32         numVertices;        // Number of vertices in input buffer, not counting multiples in instance mode.
-    S32         numTriangles;       // Number of triangles in input buffer.
-    void*       vertexBuffer;       // numVertices * float4(x, y, z, w)
-    void*       indexBuffer;        // numTriangles * int3(vi0, vi1, vi2)
-
-    S32         widthPixels;        // Render buffer size in pixels. Must be multiple of tile size (8x8).
-    S32         heightPixels;
-    S32         widthPixelsVp;      // Viewport size in pixels.
-    S32         heightPixelsVp;
-    S32         widthBins;          // widthPixels / CR_BIN_SIZE
-    S32         heightBins;         // heightPixels / CR_BIN_SIZE
-    S32         numBins;            // widthBins * heightBins
-
-    F32         xs;                 // Vertex position adjustments for tiled rendering.
-    F32         ys;
-    F32         xo;
-    F32         yo;
-
-    S32         widthTiles;         // widthPixels / CR_TILE_SIZE
-    S32         heightTiles;        // heightPixels / CR_TILE_SIZE
-    S32         numTiles;           // widthTiles * heightTiles
-
-    U32         renderModeFlags;
-    S32         deferredClear;      // 1 = Clear framebuffer before rendering triangles.
-    U32         clearColor;
-    U32         clearDepth;
-
-    // These are uniform across batch.
-
-    S32         maxSubtris;
-    S32         maxBinSegs;
-    S32         maxTileSegs;
-
-    // Setup output / bin input.
-
-    void*       triSubtris;         // maxSubtris * U8
-    void*       triHeader;          // maxSubtris * CRTriangleHeader
-    void*       triData;            // maxSubtris * CRTriangleData
-
-    // Bin output / coarse input.
-
-    void*       binSegData;         // maxBinSegs * CR_BIN_SEG_SIZE * S32
-    void*       binSegNext;         // maxBinSegs * S32
-    void*       binSegCount;        // maxBinSegs * S32
-    void*       binFirstSeg;        // CR_MAXBINS_SQR * CR_BIN_STREAMS_SIZE * (S32 segIdx), -1 = none
-    void*       binTotal;           // CR_MAXBINS_SQR * CR_BIN_STREAMS_SIZE * (S32 numTris)
-
-    // Coarse output / fine input.
-
-    void*       tileSegData;        // maxTileSegs * CR_TILE_SEG_SIZE * S32
-    void*       tileSegNext;        // maxTileSegs * S32
-    void*       tileSegCount;       // maxTileSegs * S32
-    void*       activeTiles;        // CR_MAXTILES_SQR * (S32 tileIdx)
-    void*       tileFirstSeg;       // CR_MAXTILES_SQR * (S32 segIdx), -1 = none
-
-    // Surface buffers. Outer tile offset is baked into pointers.
-
-    void*       colorBuffer;        // sizePixels.x * sizePixels.y * numImages * U32
-    void*       depthBuffer;        // sizePixels.x * sizePixels.y * numImages * U32
-    void*       peelBuffer;         // sizePixels.x * sizePixels.y * numImages * U32, only if peeling enabled.
-    S32         strideX;            // horizontal size in pixels
-    S32         strideY;            // vertical stride in pixels
-
-    // Per-image parameters for first images are embedded here to avoid extra memcpy for small batches.
-
-    CRImageParams imageParamsFirst[CR_EMBED_IMAGE_PARAMS];
-    const CRImageParams* imageParamsExtra; // After CR_EMBED_IMAGE_PARAMS.
-};
-
-//------------------------------------------------------------------------
-}

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/RasterImpl.cpp

@@ -1,370 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#include "../../framework.h"
-#include "PrivateDefs.hpp"
-#include "Constants.hpp"
-#include "RasterImpl.hpp"
-#include <cuda_runtime.h>
-
-using namespace CR;
-using std::min;
-using std::max;
-
-//------------------------------------------------------------------------
-// Kernel prototypes and variables.
-
-void triangleSetupKernel (const CRParams p);
-void binRasterKernel     (const CRParams p);
-void coarseRasterKernel  (const CRParams p);
-void fineRasterKernel    (const CRParams p);
-
-//------------------------------------------------------------------------
-
-RasterImpl::RasterImpl(void)
-:   m_renderModeFlags       (0),
-    m_deferredClear         (false),
-    m_clearColor            (0),
-    m_vertexPtr             (NULL),
-    m_indexPtr              (NULL),
-    m_numVertices           (0),
-    m_numTriangles          (0),
-    m_bufferSizesReported   (0),
-
-    m_numImages             (0),
-    m_bufferSizePixels      (0, 0),
-    m_bufferSizeVp          (0, 0),
-    m_sizePixels            (0, 0),
-    m_sizeVp                (0, 0),
-    m_offsetPixels          (0, 0),
-    m_sizeBins              (0, 0),
-    m_numBins               (0),
-    m_sizeTiles             (0, 0),
-    m_numTiles              (0),
-
-    m_numSMs                (1),
-    m_numCoarseBlocksPerSM  (1),
-    m_numFineBlocksPerSM    (1),
-    m_numFineWarpsPerBlock  (1),
-
-    m_maxSubtris            (1),
-    m_maxBinSegs            (1),
-    m_maxTileSegs           (1)
-{
-    // Query relevant device attributes.
-
-    int currentDevice = 0;
-    NVDR_CHECK_CUDA_ERROR(cudaGetDevice(&currentDevice));
-    NVDR_CHECK_CUDA_ERROR(cudaDeviceGetAttribute(&m_numSMs, cudaDevAttrMultiProcessorCount, currentDevice));
-    cudaFuncAttributes attr;
-    NVDR_CHECK_CUDA_ERROR(cudaFuncGetAttributes(&attr, (void*)fineRasterKernel));
-    m_numFineWarpsPerBlock = min(attr.maxThreadsPerBlock / 32, CR_FINE_MAX_WARPS);
-    NVDR_CHECK_CUDA_ERROR(cudaOccupancyMaxActiveBlocksPerMultiprocessor(&m_numCoarseBlocksPerSM, (void*)coarseRasterKernel, 32 * CR_COARSE_WARPS, 0));
-    NVDR_CHECK_CUDA_ERROR(cudaOccupancyMaxActiveBlocksPerMultiprocessor(&m_numFineBlocksPerSM, (void*)fineRasterKernel, 32 * m_numFineWarpsPerBlock, 0));
-
-    // Setup functions.
-
-    NVDR_CHECK_CUDA_ERROR(cudaFuncSetCacheConfig((void*)triangleSetupKernel, cudaFuncCachePreferShared));
-    NVDR_CHECK_CUDA_ERROR(cudaFuncSetCacheConfig((void*)binRasterKernel,     cudaFuncCachePreferShared));
-    NVDR_CHECK_CUDA_ERROR(cudaFuncSetCacheConfig((void*)coarseRasterKernel,  cudaFuncCachePreferShared));
-    NVDR_CHECK_CUDA_ERROR(cudaFuncSetCacheConfig((void*)fineRasterKernel,    cudaFuncCachePreferShared));
-}
-
-//------------------------------------------------------------------------
-
-RasterImpl::~RasterImpl(void)
-{
-    // Empty.
-}
-
-//------------------------------------------------------------------------
-
-void RasterImpl::setBufferSize(Vec3i size)
-{
-    // Internal buffer width and height must be divisible by tile size.
-    int w = (size.x + CR_TILE_SIZE - 1) & (-CR_TILE_SIZE);
-    int h = (size.y + CR_TILE_SIZE - 1) & (-CR_TILE_SIZE);
-
-    m_bufferSizePixels = Vec2i(w, h);
-    m_bufferSizeVp     = Vec2i(size.x, size.y);
-    m_numImages        = size.z;
-
-    m_colorBuffer.reset(w * h * size.z * sizeof(U32));
-    m_depthBuffer.reset(w * h * size.z * sizeof(U32));
-}
-
-//------------------------------------------------------------------------
-
-void RasterImpl::setViewport(Vec2i size, Vec2i offset)
-{
-    // Offset must be divisible by tile size.
-    NVDR_CHECK((offset.x & (CR_TILE_SIZE - 1)) == 0 && (offset.y & (CR_TILE_SIZE - 1)) == 0, "invalid viewport offset");
-
-    // Round internal viewport size to multiples of tile size.
-    int w = (size.x + CR_TILE_SIZE - 1) & (-CR_TILE_SIZE);
-    int h = (size.y + CR_TILE_SIZE - 1) & (-CR_TILE_SIZE);
-
-    m_sizePixels    = Vec2i(w, h);
-    m_offsetPixels  = offset;
-    m_sizeVp        = Vec2i(size.x, size.y);
-    m_sizeTiles.x   = m_sizePixels.x >> CR_TILE_LOG2;
-    m_sizeTiles.y   = m_sizePixels.y >> CR_TILE_LOG2;
-    m_numTiles      = m_sizeTiles.x * m_sizeTiles.y;
-    m_sizeBins.x    = (m_sizeTiles.x + CR_BIN_SIZE - 1) >> CR_BIN_LOG2;
-    m_sizeBins.y    = (m_sizeTiles.y + CR_BIN_SIZE - 1) >> CR_BIN_LOG2;
-    m_numBins       = m_sizeBins.x * m_sizeBins.y;
-}
-
-void RasterImpl::swapDepthAndPeel(void)
-{
-    m_peelBuffer.reset(m_depthBuffer.getSize()); // Ensure equal size and valid pointer.
-
-    void* tmp = m_depthBuffer.getPtr();
-    m_depthBuffer.setPtr(m_peelBuffer.getPtr());
-    m_peelBuffer.setPtr(tmp);
-}
-
-//------------------------------------------------------------------------
-
-bool RasterImpl::drawTriangles(const Vec2i* ranges, bool peel, cudaStream_t stream)
-{
-    bool instanceMode = (!ranges);
-
-    int maxSubtrisSlack     = 4096;     // x 81B    = 324KB
-    int maxBinSegsSlack     = 256;      // x 2137B  = 534KB
-    int maxTileSegsSlack    = 4096;     // x 136B   = 544KB
-
-    // Resize atomics as needed.
-    m_crAtomics    .grow(m_numImages * sizeof(CRAtomics));
-    m_crAtomicsHost.grow(m_numImages * sizeof(CRAtomics));
-
-    // Size of these buffers doesn't depend on input.
-    m_binFirstSeg  .grow(m_numImages * CR_MAXBINS_SQR * CR_BIN_STREAMS_SIZE * sizeof(S32));
-    m_binTotal     .grow(m_numImages * CR_MAXBINS_SQR * CR_BIN_STREAMS_SIZE * sizeof(S32));
-    m_activeTiles  .grow(m_numImages * CR_MAXTILES_SQR * sizeof(S32));
-    m_tileFirstSeg .grow(m_numImages * CR_MAXTILES_SQR * sizeof(S32));
-
-    // Construct per-image parameters and determine worst-case buffer sizes.
-    m_crImageParamsHost.grow(m_numImages * sizeof(CRImageParams));
-    CRImageParams* imageParams = (CRImageParams*)m_crImageParamsHost.getPtr();
-    for (int i=0; i < m_numImages; i++)
-    {
-        CRImageParams& ip = imageParams[i];
-
-        int roundSize  = CR_BIN_WARPS * 32;
-        int minBatches = CR_BIN_STREAMS_SIZE * 2;
-        int maxRounds  = 32;
-
-        ip.triOffset = instanceMode ? 0 : ranges[i].x;
-        ip.triCount  = instanceMode ? m_numTriangles : ranges[i].y;
-        ip.binBatchSize = min(max(ip.triCount / (roundSize * minBatches), 1), maxRounds) * roundSize;
-
-        m_maxSubtris  = max(m_maxSubtris,  min(ip.triCount + maxSubtrisSlack, CR_MAXSUBTRIS_SIZE));
-        m_maxBinSegs  = max(m_maxBinSegs,  max(m_numBins * CR_BIN_STREAMS_SIZE, (ip.triCount - 1) / CR_BIN_SEG_SIZE + 1) + maxBinSegsSlack);
-        m_maxTileSegs = max(m_maxTileSegs, max(m_numTiles, (ip.triCount - 1) / CR_TILE_SEG_SIZE + 1) + maxTileSegsSlack);
-    }
-
-    // Retry until successful.
-
-    for (;;)
-    {
-        // Allocate buffers.
-        m_triSubtris.reset(m_numImages * m_maxSubtris * sizeof(U8));
-        m_triHeader .reset(m_numImages * m_maxSubtris * sizeof(CRTriangleHeader));
-        m_triData   .reset(m_numImages * m_maxSubtris * sizeof(CRTriangleData));
-
-        m_binSegData .reset(m_numImages * m_maxBinSegs * CR_BIN_SEG_SIZE * sizeof(S32));
-        m_binSegNext .reset(m_numImages * m_maxBinSegs * sizeof(S32));
-        m_binSegCount.reset(m_numImages * m_maxBinSegs * sizeof(S32));
-
-        m_tileSegData .reset(m_numImages * m_maxTileSegs * CR_TILE_SEG_SIZE * sizeof(S32));
-        m_tileSegNext .reset(m_numImages * m_maxTileSegs * sizeof(S32));
-        m_tileSegCount.reset(m_numImages * m_maxTileSegs * sizeof(S32));
-
-        // Report if buffers grow from last time.
-        size_t sizesTotal = getTotalBufferSizes();
-        if (sizesTotal > m_bufferSizesReported)
-        {
-            size_t sizesMB = ((sizesTotal - 1) >> 20) + 1; // Round up.
-            sizesMB = ((sizesMB + 9) / 10) * 10; // 10MB granularity enough in this day and age.
-            LOG(INFO) << "Internal buffers grown to " << sizesMB << " MB";
-            m_bufferSizesReported = sizesMB << 20;
-        }
-
-        // Launch stages. Blocks until everything is done.
-        launchStages(instanceMode, peel, stream);
-
-        // Peeling iteration cannot fail, so no point checking things further.
-        if (peel)
-            break;
-
-        // Atomics after coarse stage are now available.
-        CRAtomics* atomics = (CRAtomics*)m_crAtomicsHost.getPtr();
-
-        // Success?
-        bool failed = false;
-        for (int i=0; i < m_numImages; i++)
-        {
-            const CRAtomics& a = atomics[i];
-            failed = failed || (a.numSubtris > m_maxSubtris) || (a.numBinSegs > m_maxBinSegs) || (a.numTileSegs > m_maxTileSegs);
-        }
-        if (!failed)
-            break; // Success!
-
-        // If we were already at maximum capacity, no can do.
-        if (m_maxSubtris == CR_MAXSUBTRIS_SIZE)
-            return false;
-
-        // Enlarge buffers and try again.
-        for (int i=0; i < m_numImages; i++)
-        {
-            const CRAtomics& a = atomics[i];
-            m_maxSubtris  = max(m_maxSubtris,  min(a.numSubtris + maxSubtrisSlack, CR_MAXSUBTRIS_SIZE));
-            m_maxBinSegs  = max(m_maxBinSegs,  a.numBinSegs + maxBinSegsSlack);
-            m_maxTileSegs = max(m_maxTileSegs, a.numTileSegs + maxTileSegsSlack);
-        }
-    }
-
-    m_deferredClear = false;
-    return true; // Success.
-}
-
-//------------------------------------------------------------------------
-
-size_t RasterImpl::getTotalBufferSizes(void) const
-{
-    return
-        m_colorBuffer.getSize() + m_depthBuffer.getSize() + // Don't include atomics and image params.
-        m_triSubtris.getSize() + m_triHeader.getSize() + m_triData.getSize() +
-        m_binFirstSeg.getSize() + m_binTotal.getSize() + m_binSegData.getSize() + m_binSegNext.getSize() + m_binSegCount.getSize() +
-        m_activeTiles.getSize() + m_tileFirstSeg.getSize() + m_tileSegData.getSize() + m_tileSegNext.getSize() + m_tileSegCount.getSize();
-}
-
-//------------------------------------------------------------------------
-
-void RasterImpl::launchStages(bool instanceMode, bool peel, cudaStream_t stream)
-{
-    CRImageParams* imageParams = (CRImageParams*)m_crImageParamsHost.getPtr();
-
-    // Unless peeling, initialize atomics to mostly zero.
-    CRAtomics* atomics = (CRAtomics*)m_crAtomicsHost.getPtr();
-    if (!peel)
-    {
-        memset(atomics, 0, m_numImages * sizeof(CRAtomics));
-        for (int i=0; i < m_numImages; i++)
-            atomics[i].numSubtris = imageParams[i].triCount;
-    }
-
-    // Copy to device. If peeling, this is the state after coarse raster launch on first iteration.
-    NVDR_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_crAtomics.getPtr(), atomics, m_numImages * sizeof(CRAtomics), cudaMemcpyHostToDevice, stream));
-
-    // Copy per-image parameters if there are more than fits in launch parameter block and we haven't done it already.
-    if (!peel && m_numImages > CR_EMBED_IMAGE_PARAMS)
-    {
-        int numImageParamsExtra = m_numImages - CR_EMBED_IMAGE_PARAMS;
-        m_crImageParamsExtra.grow(numImageParamsExtra * sizeof(CRImageParams));
-        NVDR_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_crImageParamsExtra.getPtr(), imageParams + CR_EMBED_IMAGE_PARAMS, numImageParamsExtra * sizeof(CRImageParams), cudaMemcpyHostToDevice, stream));
-    }
-
-    // Set global parameters.
-    CRParams p;
-    {
-        p.atomics           = (CRAtomics*)m_crAtomics.getPtr();
-        p.numImages         = m_numImages;
-        p.totalCount        = 0; // Only relevant in range mode.
-        p.instanceMode      = instanceMode ? 1 : 0;
-
-        p.numVertices       = m_numVertices;
-        p.numTriangles      = m_numTriangles;
-        p.vertexBuffer      = m_vertexPtr;
-        p.indexBuffer       = m_indexPtr;
-
-        p.widthPixels       = m_sizePixels.x;
-        p.heightPixels      = m_sizePixels.y;
-        p.widthPixelsVp     = m_sizeVp.x;
-        p.heightPixelsVp    = m_sizeVp.y;
-        p.widthBins         = m_sizeBins.x;
-        p.heightBins        = m_sizeBins.y;
-        p.numBins           = m_numBins;
-
-        p.xs                = (float)m_bufferSizeVp.x / (float)m_sizeVp.x;
-        p.ys                = (float)m_bufferSizeVp.y / (float)m_sizeVp.y;
-        p.xo                = (float)(m_bufferSizeVp.x - m_sizeVp.x - 2 * m_offsetPixels.x) / (float)m_sizeVp.x;
-        p.yo                = (float)(m_bufferSizeVp.y - m_sizeVp.y - 2 * m_offsetPixels.y) / (float)m_sizeVp.y;
-
-        p.widthTiles        = m_sizeTiles.x;
-        p.heightTiles       = m_sizeTiles.y;
-        p.numTiles          = m_numTiles;
-
-        p.renderModeFlags   = m_renderModeFlags;
-        p.deferredClear     = m_deferredClear ? 1 : 0;
-        p.clearColor        = m_clearColor;
-        p.clearDepth        = CR_DEPTH_MAX;
-
-        p.maxSubtris        = m_maxSubtris;
-        p.maxBinSegs        = m_maxBinSegs;
-        p.maxTileSegs       = m_maxTileSegs;
-
-        p.triSubtris        = m_triSubtris.getPtr();
-        p.triHeader         = m_triHeader.getPtr();
-        p.triData           = m_triData.getPtr();
-        p.binSegData        = m_binSegData.getPtr();
-        p.binSegNext        = m_binSegNext.getPtr();
-        p.binSegCount       = m_binSegCount.getPtr();
-        p.binFirstSeg       = m_binFirstSeg.getPtr();
-        p.binTotal          = m_binTotal.getPtr();
-        p.tileSegData       = m_tileSegData.getPtr();
-        p.tileSegNext       = m_tileSegNext.getPtr();
-        p.tileSegCount      = m_tileSegCount.getPtr();
-        p.activeTiles       = m_activeTiles.getPtr();
-        p.tileFirstSeg      = m_tileFirstSeg.getPtr();
-
-        size_t byteOffset = ((size_t)m_offsetPixels.x + (size_t)m_offsetPixels.y * (size_t)p.strideX) * sizeof(U32);
-        p.colorBuffer       = m_colorBuffer.getPtr(byteOffset);
-        p.depthBuffer       = m_depthBuffer.getPtr(byteOffset);
-        p.peelBuffer        = (m_renderModeFlags & CudaRaster::RenderModeFlag_EnableDepthPeeling) ? m_peelBuffer.getPtr(byteOffset) : 0;
-        p.strideX           = m_bufferSizePixels.x;
-        p.strideY           = m_bufferSizePixels.y;
-
-        memcpy(&p.imageParamsFirst, imageParams, min(m_numImages, CR_EMBED_IMAGE_PARAMS) * sizeof(CRImageParams));
-        p.imageParamsExtra  = (CRImageParams*)m_crImageParamsExtra.getPtr();
-    }
-
-    // Setup block sizes.
-
-    dim3 brBlock(32, CR_BIN_WARPS);
-    dim3 crBlock(32, CR_COARSE_WARPS);
-    dim3 frBlock(32, m_numFineWarpsPerBlock);
-    void* args[] = {&p};
-
-    // Launch stages from setup to coarse and copy atomics to host only if this is not a single-tile peeling iteration.
-    if (!peel)
-    {
-        if (instanceMode)
-        {
-            int setupBlocks = (m_numTriangles - 1) / (32 * CR_SETUP_WARPS) + 1;
-            NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((void*)triangleSetupKernel, dim3(setupBlocks, 1, m_numImages), dim3(32, CR_SETUP_WARPS), args, 0, stream));
-        }
-        else
-        {
-            for (int i=0; i < m_numImages; i++)
-                p.totalCount += imageParams[i].triCount;
-            int setupBlocks = (p.totalCount - 1) / (32 * CR_SETUP_WARPS) + 1;
-            NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((void*)triangleSetupKernel, dim3(setupBlocks, 1, 1), dim3(32, CR_SETUP_WARPS), args, 0, stream));
-        }
-        NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((void*)binRasterKernel, dim3(CR_BIN_STREAMS_SIZE, 1, m_numImages), brBlock, args, 0, stream));
-        NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((void*)coarseRasterKernel, dim3(m_numSMs * m_numCoarseBlocksPerSM, 1, m_numImages), crBlock, args, 0, stream));
-        NVDR_CHECK_CUDA_ERROR(cudaMemcpyAsync(m_crAtomicsHost.getPtr(), m_crAtomics.getPtr(), sizeof(CRAtomics) * m_numImages, cudaMemcpyDeviceToHost, stream));
-    }
-
-    // Fine rasterizer is launched always.
-    NVDR_CHECK_CUDA_ERROR(cudaLaunchKernel((void*)fineRasterKernel, dim3(m_numSMs * m_numFineBlocksPerSM, 1, m_numImages), frBlock, args, 0, stream));
-    NVDR_CHECK_CUDA_ERROR(cudaStreamSynchronize(stream));
-}
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/RasterImpl.hpp

@@ -1,102 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#pragma once
-#include "PrivateDefs.hpp"
-#include "Buffer.hpp"
-#include "../CudaRaster.hpp"
-
-namespace CR
-{
-//------------------------------------------------------------------------
-
-class RasterImpl
-{
-public:
-					        RasterImpl				(void);
-					        ~RasterImpl				(void);
-
-    void                    setBufferSize           (Vec3i size);
-    void                    setViewport             (Vec2i size, Vec2i offset);
-    void                    setRenderModeFlags      (U32 flags) { m_renderModeFlags = flags; }
-    void                    deferredClear           (U32 color) { m_deferredClear = true; m_clearColor = color; }
-    void                    setVertexBuffer         (void* ptr, int numVertices) { m_vertexPtr = ptr; m_numVertices = numVertices; } // GPU pointer.
-    void                    setIndexBuffer          (void* ptr, int numTriangles) { m_indexPtr = ptr; m_numTriangles = numTriangles; } // GPU pointer.
-    bool                    drawTriangles           (const Vec2i* ranges, bool peel, cudaStream_t stream);
-    void*                   getColorBuffer          (void) { return m_colorBuffer.getPtr(); } // GPU pointer.
-    void*                   getDepthBuffer          (void) { return m_depthBuffer.getPtr(); } // GPU pointer.
-    void                    swapDepthAndPeel        (void);
-    size_t                  getTotalBufferSizes     (void) const;
-
-private:
-    void                    launchStages            (bool instanceMode, bool peel, cudaStream_t stream);
-
-    // State.
-
-    unsigned int            m_renderModeFlags;
-    bool                    m_deferredClear;
-    unsigned int            m_clearColor;
-    void*                   m_vertexPtr;
-    void*                   m_indexPtr;
-    int                     m_numVertices;          // Input buffer size.
-    int                     m_numTriangles;         // Input buffer size.
-    size_t                  m_bufferSizesReported;  // Previously reported buffer sizes.
-
-    // Surfaces.
-
-    Buffer                  m_colorBuffer;
-    Buffer                  m_depthBuffer;
-    Buffer                  m_peelBuffer;
-    int                     m_numImages;
-    Vec2i                   m_bufferSizePixels;     // Internal buffer size.
-    Vec2i                   m_bufferSizeVp;         // Total viewport size.
-    Vec2i                   m_sizePixels;           // Internal size at which all computation is done, buffers reserved, etc.
-    Vec2i                   m_sizeVp;               // Size to which output will be cropped outside, determines viewport size.
-    Vec2i                   m_offsetPixels;         // Viewport offset for tiled rendering.
-    Vec2i                   m_sizeBins;
-    S32                     m_numBins;
-    Vec2i                   m_sizeTiles;
-    S32                     m_numTiles;
-
-    // Launch sizes etc.
-
-    S32                     m_numSMs;
-    S32                     m_numCoarseBlocksPerSM;
-    S32                     m_numFineBlocksPerSM;
-    S32                     m_numFineWarpsPerBlock;
-
-    // Global intermediate buffers. Individual images have offsets to these.
-
-    Buffer                  m_crAtomics;
-    HostBuffer              m_crAtomicsHost;
-    HostBuffer              m_crImageParamsHost;
-    Buffer                  m_crImageParamsExtra;
-    Buffer                  m_triSubtris;
-    Buffer                  m_triHeader;
-    Buffer                  m_triData;
-    Buffer                  m_binFirstSeg;
-    Buffer                  m_binTotal;
-    Buffer                  m_binSegData;
-    Buffer                  m_binSegNext;
-	Buffer                  m_binSegCount;
-    Buffer                  m_activeTiles;
-    Buffer                  m_tileFirstSeg;
-    Buffer                  m_tileSegData;
-    Buffer                  m_tileSegNext;
-    Buffer                  m_tileSegCount;
-
-    // Actual buffer sizes.
-
-    S32                     m_maxSubtris;
-    S32                     m_maxBinSegs;
-    S32                     m_maxTileSegs;
-};
-
-//------------------------------------------------------------------------
-} // namespace CR
-

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/RasterImpl_.cu

@@ -1,37 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#include "../CudaRaster.hpp"
-#include "PrivateDefs.hpp"
-#include "Constants.hpp"
-#include "Util.inl"
-
-namespace CR
-{
-
-//------------------------------------------------------------------------
-// Stage implementations.
-//------------------------------------------------------------------------
-
-#include "TriangleSetup.inl"
-#include "BinRaster.inl"
-#include "CoarseRaster.inl"
-#include "FineRaster.inl"
-
-}
-
-//------------------------------------------------------------------------
-// Stage entry points.
-//------------------------------------------------------------------------
-
-__global__ void __launch_bounds__(CR_SETUP_WARPS * 32, CR_SETUP_OPT_BLOCKS)  triangleSetupKernel (const CR::CRParams p)  { CR::triangleSetupImpl(p); }
-__global__ void __launch_bounds__(CR_BIN_WARPS * 32, 1)                      binRasterKernel     (const CR::CRParams p)  { CR::binRasterImpl(p); }
-__global__ void __launch_bounds__(CR_COARSE_WARPS * 32, 1)                   coarseRasterKernel  (const CR::CRParams p)  { CR::coarseRasterImpl(p); }
-__global__ void __launch_bounds__(CR_FINE_MAX_WARPS * 32, 1)                 fineRasterKernel    (const CR::CRParams p)  { CR::fineRasterImpl(p); }
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/TriangleSetup.inl

@@ -1,402 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ void snapTriangle(
-    const CRParams& p,
-    float4 v0, float4 v1, float4 v2,
-    int2& p0, int2& p1, int2& p2, float3& rcpW, int2& lo, int2& hi)
-{
-    F32 viewScaleX = (F32)(p.widthPixelsVp  << (CR_SUBPIXEL_LOG2 - 1));
-    F32 viewScaleY = (F32)(p.heightPixelsVp << (CR_SUBPIXEL_LOG2 - 1));
-    rcpW = make_float3(1.0f / v0.w, 1.0f / v1.w, 1.0f / v2.w);
-    p0 = make_int2(f32_to_s32_sat(v0.x * rcpW.x * viewScaleX), f32_to_s32_sat(v0.y * rcpW.x * viewScaleY));
-    p1 = make_int2(f32_to_s32_sat(v1.x * rcpW.y * viewScaleX), f32_to_s32_sat(v1.y * rcpW.y * viewScaleY));
-    p2 = make_int2(f32_to_s32_sat(v2.x * rcpW.z * viewScaleX), f32_to_s32_sat(v2.y * rcpW.z * viewScaleY));
-    lo = make_int2(min_min(p0.x, p1.x, p2.x), min_min(p0.y, p1.y, p2.y));
-    hi = make_int2(max_max(p0.x, p1.x, p2.x), max_max(p0.y, p1.y, p2.y));
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ U32 cover8x8_selectFlips(S32 dx, S32 dy) // 10 instr
-{
-    U32 flips = 0;
-    if (dy > 0 || (dy == 0 && dx <= 0))
-        flips ^= (1 << CR_FLIPBIT_FLIP_X) ^ (1 << CR_FLIPBIT_FLIP_Y) ^ (1 << CR_FLIPBIT_COMPL);
-    if (dx > 0)
-        flips ^= (1 << CR_FLIPBIT_FLIP_X) ^ (1 << CR_FLIPBIT_FLIP_Y);
-    if (::abs(dx) < ::abs(dy))
-        flips ^= (1 << CR_FLIPBIT_SWAP_XY) ^ (1 << CR_FLIPBIT_FLIP_Y);
-    return flips;
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ bool prepareTriangle(
-    const CRParams& p,
-    int2 p0, int2 p1, int2 p2, int2 lo, int2 hi,
-    int2& d1, int2& d2, S32& area)
-{
-    // Backfacing or degenerate => cull.
-
-    d1 = make_int2(p1.x - p0.x, p1.y - p0.y);
-    d2 = make_int2(p2.x - p0.x, p2.y - p0.y);
-    area = d1.x * d2.y - d1.y * d2.x;
-
-    if (area == 0)
-        return false; // Degenerate.
-
-    if (area < 0 && (p.renderModeFlags & CudaRaster::RenderModeFlag_EnableBackfaceCulling) != 0)
-        return false; // Backfacing.
-
-    // AABB falls between samples => cull.
-
-    int sampleSize = 1 << CR_SUBPIXEL_LOG2;
-    int biasX = (p.widthPixelsVp  << (CR_SUBPIXEL_LOG2 - 1)) - (sampleSize >> 1);
-    int biasY = (p.heightPixelsVp << (CR_SUBPIXEL_LOG2 - 1)) - (sampleSize >> 1);
-    int lox = (int)add_add(lo.x, sampleSize - 1, biasX) & -sampleSize;
-    int loy = (int)add_add(lo.y, sampleSize - 1, biasY) & -sampleSize;
-    int hix = (hi.x + biasX) & -sampleSize;
-    int hiy = (hi.y + biasY) & -sampleSize;
-
-    if (lox > hix || loy > hiy)
-        return false; // Between pixels.
-
-    // AABB covers 1 or 2 samples => cull if they are not covered.
-
-    int diff = add_sub(hix, hiy, lox) - loy;
-    if (diff <= sampleSize)
-    {
-        int2 t0 = make_int2(add_sub(p0.x, biasX, lox), add_sub(p0.y, biasY, loy));
-        int2 t1 = make_int2(add_sub(p1.x, biasX, lox), add_sub(p1.y, biasY, loy));
-        int2 t2 = make_int2(add_sub(p2.x, biasX, lox), add_sub(p2.y, biasY, loy));
-        S32 e0 = t0.x * t1.y - t0.y * t1.x;
-        S32 e1 = t1.x * t2.y - t1.y * t2.x;
-        S32 e2 = t2.x * t0.y - t2.y * t0.x;
-        if (area < 0)
-        {
-            e0 = -e0;
-            e1 = -e1;
-            e2 = -e2;
-        }
-
-        if (e0 < 0 || e1 < 0 || e2 < 0)
-        {
-            if (diff == 0)
-                return false; // Between pixels.
-
-            t0 = make_int2(add_sub(p0.x, biasX, hix), add_sub(p0.y, biasY, hiy));
-            t1 = make_int2(add_sub(p1.x, biasX, hix), add_sub(p1.y, biasY, hiy));
-            t2 = make_int2(add_sub(p2.x, biasX, hix), add_sub(p2.y, biasY, hiy));
-            e0 = t0.x * t1.y - t0.y * t1.x;
-            e1 = t1.x * t2.y - t1.y * t2.x;
-            e2 = t2.x * t0.y - t2.y * t0.x;
-            if (area < 0)
-            {
-                e0 = -e0;
-                e1 = -e1;
-                e2 = -e2;
-            }
-
-            if (e0 < 0 || e1 < 0 || e2 < 0)
-                return false; // Between pixels.
-        }
-    }
-
-    // Otherwise => proceed to output the triangle.
-
-    return true; // Visible.
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ void setupTriangle(
-    const CRParams& p,
-    CRTriangleHeader* th, CRTriangleData* td, int triId,
-    float v0z, float v1z, float v2z,
-    int2 p0, int2 p1, int2 p2, float3 rcpW,
-    int2 d1, int2 d2, S32 area)
-{
-    // Swap vertices 1 and 2 if area is negative. Only executed if backface culling is
-    // disabled (if it is enabled, we never come here with area < 0).
-
-    if (area < 0)
-    {
-        swap(d1, d2);
-        swap(p1, p2);
-        swap(v1z, v2z);
-        swap(rcpW.y, rcpW.z);
-        area = -area;
-    }
-
-    int2 wv0;
-    wv0.x = p0.x + (p.widthPixelsVp  << (CR_SUBPIXEL_LOG2 - 1));
-    wv0.y = p0.y + (p.heightPixelsVp << (CR_SUBPIXEL_LOG2 - 1));
-
-    // Setup depth plane equation.
-
-    F32 zcoef = (F32)(CR_DEPTH_MAX - CR_DEPTH_MIN) * 0.5f;
-    F32 zbias = (F32)(CR_DEPTH_MAX + CR_DEPTH_MIN) * 0.5f;
-    float3 zvert = make_float3(
-        (v0z * zcoef) * rcpW.x + zbias,
-        (v1z * zcoef) * rcpW.y + zbias,
-        (v2z * zcoef) * rcpW.z + zbias
-    );
-    int2 zv0 = make_int2(
-        wv0.x - (1 << (CR_SUBPIXEL_LOG2 - 1)),
-        wv0.y - (1 << (CR_SUBPIXEL_LOG2 - 1))
-    );
-    uint3 zpleq = setupPleq(zvert, zv0, d1, d2, 1.0f / (F32)area);
-
-    U32 zmin = f32_to_u32_sat(fminf(fminf(zvert.x, zvert.y), zvert.z) - (F32)CR_LERP_ERROR(0));
-
-    // Write CRTriangleData.
-
-    *(uint4*)td = make_uint4(zpleq.x, zpleq.y, zpleq.z, triId);
-
-    // Determine flipbits.
-
-    U32 f01 = cover8x8_selectFlips(d1.x, d1.y);
-    U32 f12 = cover8x8_selectFlips(d2.x - d1.x, d2.y - d1.y);
-    U32 f20 = cover8x8_selectFlips(-d2.x, -d2.y);
-
-    // Write CRTriangleHeader.
-
-    *(uint4*)th = make_uint4(
-        prmt(p0.x, p0.y, 0x5410),
-        prmt(p1.x, p1.y, 0x5410),
-        prmt(p2.x, p2.y, 0x5410),
-        (zmin & 0xfffff000u) | (f01 << 6) | (f12 << 2) | (f20 >> 2));
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ void triangleSetupImpl(const CRParams p)
-{
-    __shared__ F32 s_bary[CR_SETUP_WARPS * 32][18];
-    F32* bary = s_bary[threadIdx.x + threadIdx.y * 32];
-
-    // Compute task and image indices.
-
-    int taskIdx = threadIdx.x + 32 * (threadIdx.y + CR_SETUP_WARPS * blockIdx.x);
-    int imageIdx = 0;
-    if (p.instanceMode)
-    {
-        imageIdx = blockIdx.z;
-        if (taskIdx >= p.numTriangles)
-            return;
-    }
-    else
-    {
-        while (imageIdx < p.numImages)
-        {
-            int count = getImageParams(p, imageIdx).triCount;
-            if (taskIdx < count)
-                break;
-            taskIdx -= count;
-            imageIdx += 1;
-        }
-        if (imageIdx == p.numImages)
-            return;
-    }
-
-    // Per-image data structures.
-
-    const CRImageParams& ip = getImageParams(p, imageIdx);
-    CRAtomics& atomics = p.atomics[imageIdx];
-
-    const int*          indexBuffer = (const int*)p.indexBuffer;
-    U8*                 triSubtris  = (U8*)p.triSubtris               + imageIdx * p.maxSubtris;
-    CRTriangleHeader*   triHeader   = (CRTriangleHeader*)p.triHeader  + imageIdx * p.maxSubtris;
-    CRTriangleData*     triData     = (CRTriangleData*)p.triData      + imageIdx * p.maxSubtris;
-
-    // Determine triangle index.
-
-    int triIdx = taskIdx;
-    if (!p.instanceMode)
-        triIdx += ip.triOffset;
-
-    // Read vertex indices.
-
-    if ((U32)triIdx >= (U32)p.numTriangles)
-    {
-        // Bad triangle index.
-        triSubtris[taskIdx] = 0;
-        return;
-    }
-
-    uint4 vidx;
-    vidx.x = indexBuffer[triIdx * 3 + 0];
-    vidx.y = indexBuffer[triIdx * 3 + 1];
-    vidx.z = indexBuffer[triIdx * 3 + 2];
-    vidx.w = triIdx + 1; // Triangle index.
-
-    if (vidx.x >= (U32)p.numVertices ||
-        vidx.y >= (U32)p.numVertices ||
-        vidx.z >= (U32)p.numVertices)
-    {
-        // Bad vertex index.
-        triSubtris[taskIdx] = 0;
-        return;
-    }
-
-    // Read vertex positions.
-
-    const float4* vertexBuffer = (const float4*)p.vertexBuffer;
-    if (p.instanceMode)
-        vertexBuffer += p.numVertices * imageIdx; // Instance offset.
-
-    float4 v0 = vertexBuffer[vidx.x];
-    float4 v1 = vertexBuffer[vidx.y];
-    float4 v2 = vertexBuffer[vidx.z];
-
-    // Adjust vertex positions according to current viewport size and offset.
-
-    v0.x = v0.x * p.xs + v0.w * p.xo;
-    v0.y = v0.y * p.ys + v0.w * p.yo;
-    v1.x = v1.x * p.xs + v1.w * p.xo;
-    v1.y = v1.y * p.ys + v1.w * p.yo;
-    v2.x = v2.x * p.xs + v2.w * p.xo;
-    v2.y = v2.y * p.ys + v2.w * p.yo;
-
-    // Outside view frustum => cull.
-
-    if (v0.w < fabsf(v0.x) | v0.w < fabsf(v0.y) | v0.w < fabsf(v0.z))
-    {
-        if ((v0.w < +v0.x & v1.w < +v1.x & v2.w < +v2.x) |
-            (v0.w < -v0.x & v1.w < -v1.x & v2.w < -v2.x) |
-            (v0.w < +v0.y & v1.w < +v1.y & v2.w < +v2.y) |
-            (v0.w < -v0.y & v1.w < -v1.y & v2.w < -v2.y) |
-            (v0.w < +v0.z & v1.w < +v1.z & v2.w < +v2.z) |
-            (v0.w < -v0.z & v1.w < -v1.z & v2.w < -v2.z))
-        {
-            triSubtris[taskIdx] = 0;
-            return;
-        }
-    }
-
-    // Inside depth range => try to snap vertices.
-
-    if (v0.w >= fabsf(v0.z) & v1.w >= fabsf(v1.z) & v2.w >= fabsf(v2.z))
-    {
-        // Inside S16 range and small enough => fast path.
-        // Note: aabbLimit comes from the fact that cover8x8
-        // does not support guardband with maximal viewport.
-
-        int2 p0, p1, p2, lo, hi;
-        float3 rcpW;
-
-        snapTriangle(p, v0, v1, v2, p0, p1, p2, rcpW, lo, hi);
-        S32 loxy = ::min(lo.x, lo.y);
-        S32 hixy = ::max(hi.x, hi.y);
-        S32 aabbLimit = (1 << (CR_MAXVIEWPORT_LOG2 + CR_SUBPIXEL_LOG2)) - 1;
-
-        if (loxy >= -32768 && hixy <= 32767 && hixy - loxy <= aabbLimit)
-        {
-            int2 d1, d2;
-            S32 area;
-            bool res = prepareTriangle(p, p0, p1, p2, lo, hi, d1, d2, area);
-            triSubtris[taskIdx] = res ? 1 : 0;
-
-            if (res)
-                setupTriangle(
-                    p,
-                    &triHeader[taskIdx], &triData[taskIdx], vidx.w,
-                    v0.z, v1.z, v2.z,
-                    p0, p1, p2, rcpW,
-                    d1, d2, area);
-
-            return;
-        }
-    }
-
-    // Clip to view frustum.
-
-    float4 ov0 = v0;
-    float4 od1 = make_float4(v1.x - v0.x, v1.y - v0.y, v1.z - v0.z, v1.w - v0.w);
-    float4 od2 = make_float4(v2.x - v0.x, v2.y - v0.y, v2.z - v0.z, v2.w - v0.w);
-    int numVerts = clipTriangleWithFrustum(bary, &ov0.x, &v1.x, &v2.x, &od1.x, &od2.x);
-
-    // Count non-culled subtriangles.
-
-    v0.x = ov0.x + od1.x * bary[0] + od2.x * bary[1];
-    v0.y = ov0.y + od1.y * bary[0] + od2.y * bary[1];
-    v0.z = ov0.z + od1.z * bary[0] + od2.z * bary[1];
-    v0.w = ov0.w + od1.w * bary[0] + od2.w * bary[1];
-    v1.x = ov0.x + od1.x * bary[2] + od2.x * bary[3];
-    v1.y = ov0.y + od1.y * bary[2] + od2.y * bary[3];
-    v1.z = ov0.z + od1.z * bary[2] + od2.z * bary[3];
-    v1.w = ov0.w + od1.w * bary[2] + od2.w * bary[3];
-    float4 tv1 = v1;
-
-    int numSubtris = 0;
-    for (int i = 2; i < numVerts; i++)
-    {
-        v2.x = ov0.x + od1.x * bary[i * 2 + 0] + od2.x * bary[i * 2 + 1];
-        v2.y = ov0.y + od1.y * bary[i * 2 + 0] + od2.y * bary[i * 2 + 1];
-        v2.z = ov0.z + od1.z * bary[i * 2 + 0] + od2.z * bary[i * 2 + 1];
-        v2.w = ov0.w + od1.w * bary[i * 2 + 0] + od2.w * bary[i * 2 + 1];
-
-        int2 p0, p1, p2, lo, hi, d1, d2;
-        float3 rcpW;
-        S32 area;
-
-        snapTriangle(p, v0, v1, v2, p0, p1, p2, rcpW, lo, hi);
-        if (prepareTriangle(p, p0, p1, p2, lo, hi, d1, d2, area))
-            numSubtris++;
-
-        v1 = v2;
-    }
-
-    triSubtris[taskIdx] = numSubtris;
-
-    // Multiple subtriangles => allocate.
-
-    int subtriBase = taskIdx;
-    if (numSubtris > 1)
-    {
-        subtriBase = atomicAdd(&atomics.numSubtris, numSubtris);
-        triHeader[taskIdx].misc = subtriBase;
-        if (subtriBase + numSubtris > p.maxSubtris)
-            numVerts = 0;
-    }
-
-    // Setup subtriangles.
-
-    v1 = tv1;
-    for (int i = 2; i < numVerts; i++)
-    {
-        v2.x = ov0.x + od1.x * bary[i * 2 + 0] + od2.x * bary[i * 2 + 1];
-        v2.y = ov0.y + od1.y * bary[i * 2 + 0] + od2.y * bary[i * 2 + 1];
-        v2.z = ov0.z + od1.z * bary[i * 2 + 0] + od2.z * bary[i * 2 + 1];
-        v2.w = ov0.w + od1.w * bary[i * 2 + 0] + od2.w * bary[i * 2 + 1];
-
-        int2 p0, p1, p2, lo, hi, d1, d2;
-        float3 rcpW;
-        S32 area;
-
-        snapTriangle(p, v0, v1, v2, p0, p1, p2, rcpW, lo, hi);
-        if (prepareTriangle(p, p0, p1, p2, lo, hi, d1, d2, area))
-        {
-            setupTriangle(
-                p,
-                &triHeader[subtriBase], &triData[subtriBase], vidx.w,
-                v0.z, v1.z, v2.z,
-                p0, p1, p2, rcpW,
-                d1, d2, area);
-
-            subtriBase++;
-        }
-
-        v1 = v2;
-    }
-}
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/cudaraster/impl/Util.inl

@@ -1,452 +0,0 @@
-// Copyright (c) 2009-2022, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#include "PrivateDefs.hpp"
-
-namespace CR
-{
-//------------------------------------------------------------------------
-
-template<class T> __device__ __inline__ void swap(T& a, T& b)               { T t = a; a = b; b = t; }
-
-__device__ __inline__ U32   getLo                   (U64 a)                 { return __double2loint(__longlong_as_double(a)); }
-__device__ __inline__ S32   getLo                   (S64 a)                 { return __double2loint(__longlong_as_double(a)); }
-__device__ __inline__ U32   getHi                   (U64 a)                 { return __double2hiint(__longlong_as_double(a)); }
-__device__ __inline__ S32   getHi                   (S64 a)                 { return __double2hiint(__longlong_as_double(a)); }
-__device__ __inline__ U64   combineLoHi             (U32 lo, U32 hi)        { return __double_as_longlong(__hiloint2double(hi, lo)); }
-__device__ __inline__ S64   combineLoHi             (S32 lo, S32 hi)        { return __double_as_longlong(__hiloint2double(hi, lo)); }
-__device__ __inline__ U32   getLaneMaskLt           (void)                  { U32 r; asm("mov.u32 %0, %lanemask_lt;" : "=r"(r)); return r; }
-__device__ __inline__ U32   getLaneMaskLe           (void)                  { U32 r; asm("mov.u32 %0, %lanemask_le;" : "=r"(r)); return r; }
-__device__ __inline__ U32   getLaneMaskGt           (void)                  { U32 r; asm("mov.u32 %0, %lanemask_gt;" : "=r"(r)); return r; }
-__device__ __inline__ U32   getLaneMaskGe           (void)                  { U32 r; asm("mov.u32 %0, %lanemask_ge;" : "=r"(r)); return r; }
-__device__ __inline__ int   findLeadingOne          (U32 v)                 { U32 r; asm("bfind.u32 %0, %1;" : "=r"(r) : "r"(v)); return r; }
-__device__ __inline__ bool  singleLane              (void)                  { return ((::__ballot_sync(~0u, true) & getLaneMaskLt()) == 0); }
-
-__device__ __inline__ void  add_add_carry           (U32& rlo, U32 alo, U32 blo, U32& rhi, U32 ahi, U32 bhi) { U64 r = combineLoHi(alo, ahi) + combineLoHi(blo, bhi); rlo = getLo(r); rhi = getHi(r); }
-__device__ __inline__ S32   f32_to_s32_sat          (F32 a)                 { S32 v; asm("cvt.rni.sat.s32.f32 %0, %1;" : "=r"(v) : "f"(a)); return v; }
-__device__ __inline__ U32   f32_to_u32_sat          (F32 a)                 { U32 v; asm("cvt.rni.sat.u32.f32 %0, %1;" : "=r"(v) : "f"(a)); return v; }
-__device__ __inline__ U32   f32_to_u32_sat_rmi      (F32 a)                 { U32 v; asm("cvt.rmi.sat.u32.f32 %0, %1;" : "=r"(v) : "f"(a)); return v; }
-__device__ __inline__ U32   f32_to_u8_sat           (F32 a)                 { U32 v; asm("cvt.rni.sat.u8.f32 %0, %1;" : "=r"(v) : "f"(a)); return v; }
-__device__ __inline__ S64   f32_to_s64              (F32 a)                 { S64 v; asm("cvt.rni.s64.f32 %0, %1;" : "=l"(v) : "f"(a)); return v; }
-__device__ __inline__ S32   add_s16lo_s16lo			(S32 a, S32 b)			{ S32 v; asm("vadd.s32.s32.s32 %0, %1.h0, %2.h0;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ S32   add_s16hi_s16lo			(S32 a, S32 b)			{ S32 v; asm("vadd.s32.s32.s32 %0, %1.h1, %2.h0;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ S32   add_s16lo_s16hi			(S32 a, S32 b)			{ S32 v; asm("vadd.s32.s32.s32 %0, %1.h0, %2.h1;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ S32   add_s16hi_s16hi			(S32 a, S32 b)			{ S32 v; asm("vadd.s32.s32.s32 %0, %1.h1, %2.h1;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ S32   sub_s16lo_s16lo			(S32 a, S32 b)			{ S32 v; asm("vsub.s32.s32.s32 %0, %1.h0, %2.h0;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ S32   sub_s16hi_s16lo			(S32 a, S32 b)			{ S32 v; asm("vsub.s32.s32.s32 %0, %1.h1, %2.h0;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ S32   sub_s16lo_s16hi			(S32 a, S32 b)			{ S32 v; asm("vsub.s32.s32.s32 %0, %1.h0, %2.h1;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ S32   sub_s16hi_s16hi			(S32 a, S32 b)			{ S32 v; asm("vsub.s32.s32.s32 %0, %1.h1, %2.h1;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ S32   sub_u16lo_u16lo			(U32 a, U32 b)			{ S32 v; asm("vsub.s32.u32.u32 %0, %1.h0, %2.h0;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ S32   sub_u16hi_u16lo			(U32 a, U32 b)			{ S32 v; asm("vsub.s32.u32.u32 %0, %1.h1, %2.h0;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ S32   sub_u16lo_u16hi			(U32 a, U32 b)			{ S32 v; asm("vsub.s32.u32.u32 %0, %1.h0, %2.h1;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ S32   sub_u16hi_u16hi			(U32 a, U32 b)			{ S32 v; asm("vsub.s32.u32.u32 %0, %1.h1, %2.h1;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ U32   add_b0					(U32 a, U32 b)			{ U32 v; asm("vadd.u32.u32.u32 %0, %1.b0, %2;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ U32   add_b1					(U32 a, U32 b)			{ U32 v; asm("vadd.u32.u32.u32 %0, %1.b1, %2;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ U32   add_b2					(U32 a, U32 b)			{ U32 v; asm("vadd.u32.u32.u32 %0, %1.b2, %2;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ U32   add_b3					(U32 a, U32 b)			{ U32 v; asm("vadd.u32.u32.u32 %0, %1.b3, %2;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ U32   vmad_b0					(U32 a, U32 b, U32 c)	{ U32 v; asm("vmad.u32.u32.u32 %0, %1.b0, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ U32   vmad_b1					(U32 a, U32 b, U32 c)	{ U32 v; asm("vmad.u32.u32.u32 %0, %1.b1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ U32   vmad_b2					(U32 a, U32 b, U32 c)	{ U32 v; asm("vmad.u32.u32.u32 %0, %1.b2, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ U32   vmad_b3					(U32 a, U32 b, U32 c)	{ U32 v; asm("vmad.u32.u32.u32 %0, %1.b3, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ U32   vmad_b0_b3				(U32 a, U32 b, U32 c)	{ U32 v; asm("vmad.u32.u32.u32 %0, %1.b0, %2.b3, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ U32   vmad_b1_b3				(U32 a, U32 b, U32 c)	{ U32 v; asm("vmad.u32.u32.u32 %0, %1.b1, %2.b3, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ U32   vmad_b2_b3				(U32 a, U32 b, U32 c)	{ U32 v; asm("vmad.u32.u32.u32 %0, %1.b2, %2.b3, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ U32   vmad_b3_b3				(U32 a, U32 b, U32 c)	{ U32 v; asm("vmad.u32.u32.u32 %0, %1.b3, %2.b3, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ U32   add_mask8				(U32 a, U32 b)			{ U32 v; U32 z=0; asm("vadd.u32.u32.u32 %0.b0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(z)); return v; }
-__device__ __inline__ U32   sub_mask8				(U32 a, U32 b)			{ U32 v; U32 z=0; asm("vsub.u32.u32.u32 %0.b0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(z)); return v; }
-__device__ __inline__ S32   max_max					(S32 a, S32 b, S32 c)	{ S32 v; asm("vmax.s32.s32.s32.max %0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ S32   min_min					(S32 a, S32 b, S32 c)	{ S32 v; asm("vmin.s32.s32.s32.min %0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ S32   max_add					(S32 a, S32 b, S32 c)	{ S32 v; asm("vmax.s32.s32.s32.add %0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ S32   min_add					(S32 a, S32 b, S32 c)	{ S32 v; asm("vmin.s32.s32.s32.add %0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ U32   add_add					(U32 a, U32 b, U32 c)	{ U32 v; asm("vadd.u32.u32.u32.add %0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ U32   sub_add					(U32 a, U32 b, U32 c)	{ U32 v; asm("vsub.u32.u32.u32.add %0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ U32   add_sub					(U32 a, U32 b, U32 c)	{ U32 v; asm("vsub.u32.u32.u32.add %0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(c), "r"(b)); return v; }
-__device__ __inline__ S32   add_clamp_0_x			(S32 a, S32 b, S32 c)	{ S32 v; asm("vadd.u32.s32.s32.sat.min %0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ S32   add_clamp_b0			(S32 a, S32 b, S32 c)	{ S32 v; asm("vadd.u32.s32.s32.sat %0.b0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ S32   add_clamp_b2			(S32 a, S32 b, S32 c)	{ S32 v; asm("vadd.u32.s32.s32.sat %0.b2, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ U32   prmt					(U32 a, U32 b, U32 c)   { U32 v; asm("prmt.b32 %0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ S32   u32lo_sext              (U32 a)                 { U32 v; asm("cvt.s16.u32 %0, %1;" : "=r"(v) : "r"(a)); return v; }
-__device__ __inline__ U32   slct                    (U32 a, U32 b, S32 c)   { U32 v; asm("slct.u32.s32 %0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ S32   slct                    (S32 a, S32 b, S32 c)   { S32 v; asm("slct.s32.s32 %0, %1, %2, %3;" : "=r"(v) : "r"(a), "r"(b), "r"(c)); return v; }
-__device__ __inline__ F32   slct                    (F32 a, F32 b, S32 c)   { F32 v; asm("slct.f32.s32 %0, %1, %2, %3;" : "=f"(v) : "f"(a), "f"(b), "r"(c)); return v; }
-__device__ __inline__ U32   isetge                  (S32 a, S32 b)          { U32 v; asm("set.ge.u32.s32 %0, %1, %2;" : "=r"(v) : "r"(a), "r"(b)); return v; }
-__device__ __inline__ F64   rcp_approx              (F64 a)                 { F64 v; asm("rcp.approx.ftz.f64 %0, %1;" : "=d"(v) : "d"(a)); return v; }
-__device__ __inline__ F32   fma_rm                  (F32 a, F32 b, F32 c)   { F32 v; asm("fma.rm.f32 %0, %1, %2, %3;" : "=f"(v) : "f"(a), "f"(b), "f"(c)); return v; }
-__device__ __inline__ U32   idiv_fast               (U32 a, U32 b);
-
-__device__ __inline__ uint3 setupPleq               (float3 values, int2 v0, int2 d1, int2 d2, F32 areaRcp);
-
-__device__ __inline__ void  cover8x8_setupLUT           (volatile U64* lut);
-__device__ __inline__ U64   cover8x8_exact_fast         (S32 ox, S32 oy, S32 dx, S32 dy, U32 flips, volatile const U64* lut); // Assumes viewport <= 2^11, subpixels <= 2^4, no guardband.
-__device__ __inline__ U64   cover8x8_lookupMask         (S64 yinit, U32 yinc, U32 flips, volatile const U64* lut);
-
-__device__ __inline__ U64   cover8x8_exact_noLUT        (S32 ox, S32 oy, S32 dx, S32 dy); // optimized reference implementation, does not require look-up table
-__device__ __inline__ U64   cover8x8_conservative_noLUT (S32 ox, S32 oy, S32 dx, S32 dy);
-__device__ __inline__ U64   cover8x8_generateMask_noLUT (S32 curr, S32 dx, S32 dy);
-
-template <class T> __device__ __inline__ void sortShared(T* ptr, int numItems); // Assumes that numItems <= threadsInBlock. Must sync before & after the call.
-
-__device__ __inline__ const CRImageParams& getImageParams(const CRParams& p, int idx)
-{
-    return (idx < CR_EMBED_IMAGE_PARAMS) ? p.imageParamsFirst[idx] : p.imageParamsExtra[idx - CR_EMBED_IMAGE_PARAMS];
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ int clipPolygonWithPlane(F32* baryOut, const F32* baryIn, int numIn, F32 v0, F32 v1, F32 v2)
-{
-    int numOut = 0;
-    if (numIn >= 3)
-    {
-        int ai = (numIn - 1) * 2;
-        F32 av = v0 + v1 * baryIn[ai + 0] + v2 * baryIn[ai + 1];
-        for (int bi = 0; bi < numIn * 2; bi += 2)
-        {
-            F32 bv = v0 + v1 * baryIn[bi + 0] + v2 * baryIn[bi + 1];
-            if (av * bv < 0.0f)
-            {
-                F32 bc = av / (av - bv);
-                F32 ac = 1.0f - bc;
-                baryOut[numOut + 0] = baryIn[ai + 0] * ac + baryIn[bi + 0] * bc;
-                baryOut[numOut + 1] = baryIn[ai + 1] * ac + baryIn[bi + 1] * bc;
-                numOut += 2;
-            }
-            if (bv >= 0.0f)
-            {
-                baryOut[numOut + 0] = baryIn[bi + 0];
-                baryOut[numOut + 1] = baryIn[bi + 1];
-                numOut += 2;
-            }
-            ai = bi;
-            av = bv;
-        }
-    }
-    return (numOut >> 1);
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ int clipTriangleWithFrustum(F32* bary, const F32* v0, const F32* v1, const F32* v2, const F32* d1, const F32* d2)
-{
-    int num = 3;
-    bary[0] = 0.0f, bary[1] = 0.0f;
-    bary[2] = 1.0f, bary[3] = 0.0f;
-    bary[4] = 0.0f, bary[5] = 1.0f;
-
-    if ((v0[3] < fabsf(v0[0])) | (v1[3] < fabsf(v1[0])) | (v2[3] < fabsf(v2[0])))
-    {
-        F32 temp[18];
-        num = clipPolygonWithPlane(temp, bary, num, v0[3] + v0[0], d1[3] + d1[0], d2[3] + d2[0]);
-        num = clipPolygonWithPlane(bary, temp, num, v0[3] - v0[0], d1[3] - d1[0], d2[3] - d2[0]);
-    }
-    if ((v0[3] < fabsf(v0[1])) | (v1[3] < fabsf(v1[1])) | (v2[3] < fabsf(v2[1])))
-    {
-        F32 temp[18];
-        num = clipPolygonWithPlane(temp, bary, num, v0[3] + v0[1], d1[3] + d1[1], d2[3] + d2[1]);
-        num = clipPolygonWithPlane(bary, temp, num, v0[3] - v0[1], d1[3] - d1[1], d2[3] - d2[1]);
-    }
-    if ((v0[3] < fabsf(v0[2])) | (v1[3] < fabsf(v1[2])) | (v2[3] < fabsf(v2[2])))
-    {
-        F32 temp[18];
-        num = clipPolygonWithPlane(temp, bary, num, v0[3] + v0[2], d1[3] + d1[2], d2[3] + d2[2]);
-        num = clipPolygonWithPlane(bary, temp, num, v0[3] - v0[2], d1[3] - d1[2], d2[3] - d2[2]);
-    }
-    return num;
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ U32 idiv_fast(U32 a, U32 b)
-{
-    return f32_to_u32_sat_rmi(((F32)a + 0.5f) / (F32)b);
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ U32 toABGR(float4 color)
-{
-	// 11 instructions: 4*FFMA, 4*F2I, 3*PRMT
-	U32 x = f32_to_u32_sat_rmi(fma_rm(color.x, (1 << 24) * 255.0f, (1 << 24) * 0.5f));
-	U32 y = f32_to_u32_sat_rmi(fma_rm(color.y, (1 << 24) * 255.0f, (1 << 24) * 0.5f));
-	U32 z = f32_to_u32_sat_rmi(fma_rm(color.z, (1 << 24) * 255.0f, (1 << 24) * 0.5f));
-	U32 w = f32_to_u32_sat_rmi(fma_rm(color.w, (1 << 24) * 255.0f, (1 << 24) * 0.5f));
-	return prmt(prmt(x, y, 0x0073), prmt(z, w, 0x0073), 0x5410);
-}
-
-//------------------------------------------------------------------------
-// v0 = subpixels relative to the bottom-left sampling point
-
-__device__ __inline__ uint3 setupPleq(float3 values, int2 v0, int2 d1, int2 d2, F32 areaRcp)
-{
-    F32 mx = fmaxf(fmaxf(values.x, values.y), values.z);
-    int sh = ::min(::max((__float_as_int(mx) >> 23) - (127 + 22), 0), 8);
-    S32 t0 = (U32)values.x >> sh;
-    S32 t1 = ((U32)values.y >> sh) - t0;
-    S32 t2 = ((U32)values.z >> sh) - t0;
-
-    U32 rcpMant = (__float_as_int(areaRcp) & 0x007FFFFF) | 0x00800000;
-    int rcpShift = (23 + 127) - (__float_as_int(areaRcp) >> 23);
-
-    uint3 pleq;
-    S64 xc = ((S64)t1 * d2.y - (S64)t2 * d1.y) * rcpMant;
-    S64 yc = ((S64)t2 * d1.x - (S64)t1 * d2.x) * rcpMant;
-    pleq.x = (U32)(xc >> (rcpShift - (sh + CR_SUBPIXEL_LOG2)));
-    pleq.y = (U32)(yc >> (rcpShift - (sh + CR_SUBPIXEL_LOG2)));
-
-    S32 centerX = (v0.x * 2 + min_min(d1.x, d2.x, 0) + max_max(d1.x, d2.x, 0)) >> (CR_SUBPIXEL_LOG2 + 1);
-    S32 centerY = (v0.y * 2 + min_min(d1.y, d2.y, 0) + max_max(d1.y, d2.y, 0)) >> (CR_SUBPIXEL_LOG2 + 1);
-    S32 vcx = v0.x - (centerX << CR_SUBPIXEL_LOG2);
-    S32 vcy = v0.y - (centerY << CR_SUBPIXEL_LOG2);
-
-    pleq.z = t0 << sh;
-    pleq.z -= (U32)(((xc >> 13) * vcx + (yc >> 13) * vcy) >> (rcpShift - (sh + 13)));
-    pleq.z -= pleq.x * centerX + pleq.y * centerY;
-    return pleq;
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ void cover8x8_setupLUT(volatile U64* lut)
-{
-    for (S32 lutIdx = threadIdx.x + blockDim.x * threadIdx.y; lutIdx < CR_COVER8X8_LUT_SIZE; lutIdx += blockDim.x * blockDim.y)
-    {
-        int half       = (lutIdx < (12 << 5)) ? 0 : 1;
-        int yint       = (lutIdx >> 5) - half * 12 - 3;
-        U32 shape      = ((lutIdx >> 2) & 7) << (31 - 2);
-        S32 slctSwapXY = lutIdx << (31 - 1);
-        S32 slctNegX   = lutIdx << (31 - 0);
-        S32 slctCompl  = slctSwapXY ^ slctNegX;
-
-        U64 mask = 0;
-        int xlo = half * 4;
-        int xhi = xlo + 4;
-        for (int x = xlo; x < xhi; x++)
-        {
-            int ylo = slct(0, ::max(yint, 0), slctCompl);
-            int yhi = slct(::min(yint, 8), 8, slctCompl);
-            for (int y = ylo; y < yhi; y++)
-            {
-                int xx = slct(x, y, slctSwapXY);
-                int yy = slct(y, x, slctSwapXY);
-                xx = slct(xx, 7 - xx, slctNegX);
-                mask |= (U64)1 << (xx + yy * 8);
-            }
-            yint += shape >> 31;
-            shape <<= 1;
-        }
-        lut[lutIdx] = mask;
-    }
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ U64 cover8x8_exact_fast(S32 ox, S32 oy, S32 dx, S32 dy, U32 flips, volatile const U64* lut) // 52 instr
-{
-    F32  yinitBias  = (F32)(1 << (31 - CR_MAXVIEWPORT_LOG2 - CR_SUBPIXEL_LOG2 * 2));
-    F32  yinitScale = (F32)(1 << (32 - CR_SUBPIXEL_LOG2));
-    F32  yincScale  = 65536.0f * 65536.0f;
-
-    S32  slctFlipY  = flips << (31 - CR_FLIPBIT_FLIP_Y);
-    S32  slctFlipX  = flips << (31 - CR_FLIPBIT_FLIP_X);
-    S32  slctSwapXY = flips << (31 - CR_FLIPBIT_SWAP_XY);
-
-    // Evaluate cross product.
-
-    S32 t = ox * dy - oy * dx;
-    F32 det = (F32)slct(t, t - dy * (7 << CR_SUBPIXEL_LOG2), slctFlipX);
-    if (flips >= (1 << CR_FLIPBIT_COMPL))
-        det = -det;
-
-    // Represent Y as a function of X.
-
-    F32 xrcp  = 1.0f / (F32)::abs(slct(dx, dy, slctSwapXY));
-    F32 yzero = det * yinitScale * xrcp + yinitBias;
-    S64 yinit = f32_to_s64(slct(yzero, -yzero, slctFlipY));
-    U32 yinc  = f32_to_u32_sat((F32)::abs(slct(dy, dx, slctSwapXY)) * xrcp * yincScale);
-
-    // Lookup.
-
-    return cover8x8_lookupMask(yinit, yinc, flips, lut);
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ U64 cover8x8_lookupMask(S64 yinit, U32 yinc, U32 flips, volatile const U64* lut)
-{
-    // First half.
-
-    U32 yfrac = getLo(yinit);
-    U32 shape = add_clamp_0_x(getHi(yinit) + 4, 0, 11);
-    add_add_carry(yfrac, yfrac, yinc, shape, shape, shape);
-    add_add_carry(yfrac, yfrac, yinc, shape, shape, shape);
-    add_add_carry(yfrac, yfrac, yinc, shape, shape, shape);
-    int oct = flips & ((1 << CR_FLIPBIT_FLIP_X) | (1 << CR_FLIPBIT_SWAP_XY));
-    U64 mask = *(U64*)((U8*)lut + oct + (shape << 5));
-
-    // Second half.
-
-    add_add_carry(yfrac, yfrac, yinc, shape, shape, shape);
-    shape = add_clamp_0_x(getHi(yinit) + 4, __popc(shape & 15), 11);
-    add_add_carry(yfrac, yfrac, yinc, shape, shape, shape);
-    add_add_carry(yfrac, yfrac, yinc, shape, shape, shape);
-    add_add_carry(yfrac, yfrac, yinc, shape, shape, shape);
-    mask |= *(U64*)((U8*)lut + oct + (shape << 5) + (12 << 8));
-    return (flips >= (1 << CR_FLIPBIT_COMPL)) ? ~mask : mask;
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ U64 cover8x8_exact_noLUT(S32 ox, S32 oy, S32 dx, S32 dy)
-{
-    S32 curr = ox * dy - oy * dx;
-    if (dy > 0 || (dy == 0 && dx <= 0)) curr--; // exclusive
-    return cover8x8_generateMask_noLUT(curr, dx, dy);
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ U64 cover8x8_conservative_noLUT(S32 ox, S32 oy, S32 dx, S32 dy)
-{
-    S32 curr = ox * dy - oy * dx;
-    if (dy > 0 || (dy == 0 && dx <= 0)) curr--; // exclusive
-    curr += (::abs(dx) + ::abs(dy)) << (CR_SUBPIXEL_LOG2 - 1);
-    return cover8x8_generateMask_noLUT(curr, dx, dy);
-}
-
-//------------------------------------------------------------------------
-
-__device__ __inline__ U64 cover8x8_generateMask_noLUT(S32 curr, S32 dx, S32 dy)
-{
-    curr += (dx - dy) * (7 << CR_SUBPIXEL_LOG2);
-    S32 stepX = dy << (CR_SUBPIXEL_LOG2 + 1);
-    S32 stepYorig = -dx - dy * 7;
-    S32 stepY = stepYorig << (CR_SUBPIXEL_LOG2 + 1);
-
-    U32 hi = isetge(curr, 0);
-    U32 frac = curr + curr;
-    for (int i = 62; i >= 32; i--)
-        add_add_carry(frac, frac, ((i & 7) == 7) ? stepY : stepX, hi, hi, hi);
-
-	U32 lo = 0;
-    for (int i = 31; i >= 0; i--)
-        add_add_carry(frac, frac, ((i & 7) == 7) ? stepY : stepX, lo, lo, lo);
-
-	lo ^= lo >> 1,  hi ^= hi >> 1;
-	lo ^= lo >> 2,  hi ^= hi >> 2;
-	lo ^= lo >> 4,  hi ^= hi >> 4;
-	lo ^= lo >> 8,  hi ^= hi >> 8;
-	lo ^= lo >> 16, hi ^= hi >> 16;
-
-	if (dy < 0)
-    {
-        lo ^= 0x55AA55AA;
-        hi ^= 0x55AA55AA;
-    }
-	if (stepYorig < 0)
-    {
-        lo ^= 0xFF00FF00;
-        hi ^= 0x00FF00FF;
-    }
-	if ((hi & 1) != 0)
-		lo = ~lo;
-
-    return combineLoHi(lo, hi);
-}
-
-//------------------------------------------------------------------------
-
-template <class T> __device__ __inline__ void sortShared(T* ptr, int numItems)
-{
-    int thrInBlock = threadIdx.x + threadIdx.y * blockDim.x;
-    int range = 16;
-
-    // Use transposition sort within each 16-wide subrange.
-
-    int base = thrInBlock * 2;
-    bool act = (base < numItems - 1);
-    U32 actMask = __ballot_sync(~0u, act);
-    if (act)
-    {
-        bool tryOdd = (base < numItems - 2 && (~base & (range - 2)) != 0);
-        T mid = ptr[base + 1];
-
-        for (int iter = 0; iter < range; iter += 2)
-        {
-            // Evens.
-
-            T tmp = ptr[base + 0];
-            if (tmp > mid)
-            {
-                ptr[base + 0] = mid;
-                mid = tmp;
-            }
-            __syncwarp(actMask);
-
-            // Odds.
-
-            if (tryOdd)
-            {
-                tmp = ptr[base + 2];
-                if (mid > tmp)
-                {
-                    ptr[base + 2] = mid;
-                    mid = tmp;
-                }
-            }
-            __syncwarp(actMask);
-        }
-        ptr[base + 1] = mid;
-    }
-
-    // Multiple subranges => Merge hierarchically.
-
-    for (; range < numItems; range <<= 1)
-    {
-        // Assuming that we would insert the current item into the other
-        // subrange, use binary search to find the appropriate slot.
-
-        __syncthreads();
-
-        T item;
-        int slot;
-        if (thrInBlock < numItems)
-        {
-            item = ptr[thrInBlock];
-            slot = (thrInBlock & -range) ^ range;
-            if (slot < numItems)
-            {
-                T tmp = ptr[slot];
-                bool inclusive = ((thrInBlock & range) != 0);
-                if (tmp < item || (inclusive && tmp == item))
-                {
-                    for (int step = (range >> 1); step != 0; step >>= 1)
-                    {
-                        int probe = slot + step;
-                        if (probe < numItems)
-                        {
-                            tmp = ptr[probe];
-                            if (tmp < item || (inclusive && tmp == item))
-                                slot = probe;
-                        }
-                    }
-                    slot++;
-                }
-            }
-        }
-
-        // Store the item at an appropriate place.
-
-        __syncthreads();
-
-        if (thrInBlock < numItems)
-            ptr[slot + (thrInBlock & (range * 2 - 1)) - range] = item;
-    }
-}
-
-//------------------------------------------------------------------------
-}

extensions/nvdiffrast/nvdiffrast/common/framework.h

@@ -1,49 +0,0 @@
-// Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#pragma once
-
-// Framework-specific macros to enable code sharing.
-
-//------------------------------------------------------------------------
-// Tensorflow.
-
-#ifdef NVDR_TENSORFLOW
-#define EIGEN_USE_GPU
-#include "tensorflow/core/framework/op.h"
-#include "tensorflow/core/framework/op_kernel.h"
-#include "tensorflow/core/framework/shape_inference.h"
-#include "tensorflow/core/platform/default/logging.h"
-using namespace tensorflow;
-using namespace tensorflow::shape_inference;
-#define NVDR_CTX_ARGS OpKernelContext* _nvdr_ctx
-#define NVDR_CTX_PARAMS _nvdr_ctx
-#define NVDR_CHECK(COND, ERR) OP_REQUIRES(_nvdr_ctx, COND, errors::Internal(ERR))
-#define NVDR_CHECK_CUDA_ERROR(CUDA_CALL) OP_CHECK_CUDA_ERROR(_nvdr_ctx, CUDA_CALL)
-#define NVDR_CHECK_GL_ERROR(GL_CALL) OP_CHECK_GL_ERROR(_nvdr_ctx, GL_CALL)
-#endif
-
-//------------------------------------------------------------------------
-// PyTorch.
-
-#ifdef NVDR_TORCH
-#ifndef __CUDACC__
-#include <torch/extension.h>
-#include <ATen/cuda/CUDAContext.h>
-#include <ATen/cuda/CUDAUtils.h>
-#include <c10/cuda/CUDAGuard.h>
-#include <pybind11/numpy.h>
-#endif
-#define NVDR_CTX_ARGS int _nvdr_ctx_dummy
-#define NVDR_CTX_PARAMS 0
-#define NVDR_CHECK(COND, ERR) do { TORCH_CHECK(COND, ERR) } while(0)
-#define NVDR_CHECK_CUDA_ERROR(CUDA_CALL) do { cudaError_t err = CUDA_CALL; TORCH_CHECK(!err, "Cuda error: ", cudaGetLastError(), "[", #CUDA_CALL, ";]"); } while(0)
-#define NVDR_CHECK_GL_ERROR(GL_CALL) do { GL_CALL; GLenum err = glGetError(); TORCH_CHECK(err == GL_NO_ERROR, "OpenGL error: ", getGLErrorString(err), "[", #GL_CALL, ";]"); } while(0)
-#endif
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/glutil.cpp

@@ -1,403 +0,0 @@
-// Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-//------------------------------------------------------------------------
-// Common.
-//------------------------------------------------------------------------
-
-#include "framework.h"
-#include "glutil.h"
-#include <iostream>
-#include <iomanip>
-
-// Create the function pointers.
-#define GLUTIL_EXT(return_type, name, ...) return_type (GLAPIENTRY* name)(__VA_ARGS__) = 0;
-#include "glutil_extlist.h"
-#undef GLUTIL_EXT
-
-// Track initialization status.
-static volatile bool s_glExtInitialized = false;
-
-// Error strings.
-const char* getGLErrorString(GLenum err)
-{
-    switch(err)
-    {
-        case GL_NO_ERROR:                       return "GL_NO_ERROR";
-        case GL_INVALID_ENUM:                   return "GL_INVALID_ENUM";
-        case GL_INVALID_VALUE:                  return "GL_INVALID_VALUE";
-        case GL_INVALID_OPERATION:              return "GL_INVALID_OPERATION";
-        case GL_STACK_OVERFLOW:                 return "GL_STACK_OVERFLOW";
-        case GL_STACK_UNDERFLOW:                return "GL_STACK_UNDERFLOW";
-        case GL_OUT_OF_MEMORY:                  return "GL_OUT_OF_MEMORY";
-        case GL_INVALID_FRAMEBUFFER_OPERATION:  return "GL_INVALID_FRAMEBUFFER_OPERATION";
-        case GL_TABLE_TOO_LARGE:                return "GL_TABLE_TOO_LARGE";
-        case GL_CONTEXT_LOST:                   return "GL_CONTEXT_LOST";
-    }
-    return "Unknown error";
-}
-
-//------------------------------------------------------------------------
-// Windows.
-//------------------------------------------------------------------------
-
-#ifdef _WIN32
-
-static CRITICAL_SECTION getInitializedCriticalSection(void)
-{
-    CRITICAL_SECTION cs;
-    InitializeCriticalSection(&cs);
-    return cs;
-}
-
-static CRITICAL_SECTION s_getProcAddressMutex = getInitializedCriticalSection();
-
-static void safeGetProcAddress(const char* name, PROC* pfn)
-{
-    PROC result = wglGetProcAddress(name);
-    if (!result)
-    {
-        LeaveCriticalSection(&s_getProcAddressMutex); // Prepare for thread exit.
-        LOG(FATAL) << "wglGetProcAddress() failed for '" << name << "'";
-        exit(1); // Should never get here but make sure we exit.
-    }
-    *pfn = result;
-}
-
-static void initializeGLExtensions(void)
-{
-    // Use critical section for thread safety.
-    EnterCriticalSection(&s_getProcAddressMutex);
-
-    // Only dig function pointers if not done already.
-    if (!s_glExtInitialized)
-    {
-        // Generate code to populate the function pointers.
-#define GLUTIL_EXT(return_type, name, ...) safeGetProcAddress(#name, (PROC*)&name);
-#include "glutil_extlist.h"
-#undef GLUTIL_EXT
-
-        // Mark as initialized.
-        s_glExtInitialized = true;
-    }
-
-    // Done.
-    LeaveCriticalSection(&s_getProcAddressMutex);
-    return;
-}
-
-void setGLContext(GLContext& glctx)
-{
-    if (!glctx.hglrc)
-        LOG(FATAL) << "setGLContext() called with null gltcx";
-    if (!wglMakeCurrent(glctx.hdc, glctx.hglrc))
-        LOG(FATAL) << "wglMakeCurrent() failed when setting GL context";
-
-    if (glctx.extInitialized)
-        return;
-    initializeGLExtensions();
-    glctx.extInitialized = 1;
-}
-
-void releaseGLContext(void)
-{
-    if (!wglMakeCurrent(NULL, NULL))
-        LOG(FATAL) << "wglMakeCurrent() failed when releasing GL context";
-}
-
-extern "C" int set_gpu(const char*); // In setgpu.lib
-GLContext createGLContext(int cudaDeviceIdx)
-{
-    if (cudaDeviceIdx >= 0)
-    {
-        char pciBusId[256] = "";
-        LOG(INFO) << "Creating GL context for Cuda device " << cudaDeviceIdx;
-        if (cudaDeviceGetPCIBusId(pciBusId, 255, cudaDeviceIdx))
-        {
-            LOG(INFO) << "PCI bus id query failed";
-        }
-        else
-        {
-            int res = set_gpu(pciBusId);
-            LOG(INFO) << "Selecting device with PCI bus id " << pciBusId << " - " << (res ? "failed, expect crash or major slowdown" : "success");
-        }
-    }
-
-    HINSTANCE hInstance = GetModuleHandle(NULL);
-    WNDCLASS wc = {};
-    wc.style         = CS_OWNDC;
-    wc.lpfnWndProc   = DefWindowProc;
-    wc.hInstance     = hInstance;
-    wc.lpszClassName = "__DummyGLClassCPP";
-    int res = RegisterClass(&wc);
-
-    HWND hwnd = CreateWindow(
-        "__DummyGLClassCPP",        // lpClassName
-        "__DummyGLWindowCPP",       // lpWindowName
-        WS_OVERLAPPEDWINDOW,        // dwStyle
-        CW_USEDEFAULT,              // x
-        CW_USEDEFAULT,              // y
-        0, 0,                       // nWidth, nHeight
-        NULL, NULL,                 // hWndParent, hMenu
-        hInstance,                  // hInstance
-        NULL                        // lpParam
-    );
-
-    PIXELFORMATDESCRIPTOR pfd = {};
-    pfd.dwFlags      = PFD_SUPPORT_OPENGL;
-    pfd.iPixelType   = PFD_TYPE_RGBA;
-    pfd.iLayerType   = PFD_MAIN_PLANE;
-    pfd.cColorBits   = 32;
-    pfd.cDepthBits   = 24;
-    pfd.cStencilBits = 8;
-
-    HDC hdc = GetDC(hwnd);
-    int pixelformat = ChoosePixelFormat(hdc, &pfd);
-    SetPixelFormat(hdc, pixelformat, &pfd);
-
-    HGLRC hglrc = wglCreateContext(hdc);
-    LOG(INFO) << std::hex << std::setfill('0')
-              << "WGL OpenGL context created (hdc: 0x" << std::setw(8) << (uint32_t)(uintptr_t)hdc
-              << ", hglrc: 0x" << std::setw(8) << (uint32_t)(uintptr_t)hglrc << ")";
-
-    GLContext glctx = {hdc, hglrc, 0};
-    return glctx;
-}
-
-void destroyGLContext(GLContext& glctx)
-{
-    if (!glctx.hglrc)
-        LOG(FATAL) << "destroyGLContext() called with null gltcx";
-
-    // If this is the current context, release it.
-    if (wglGetCurrentContext() == glctx.hglrc)
-        releaseGLContext();
-
-    HWND hwnd = WindowFromDC(glctx.hdc);
-    if (!hwnd)
-        LOG(FATAL) << "WindowFromDC() failed";
-    if (!ReleaseDC(hwnd, glctx.hdc))
-        LOG(FATAL) << "ReleaseDC() failed";
-    if (!wglDeleteContext(glctx.hglrc))
-        LOG(FATAL) << "wglDeleteContext() failed";
-    if (!DestroyWindow(hwnd))
-        LOG(FATAL) << "DestroyWindow() failed";
-
-    LOG(INFO) << std::hex << std::setfill('0')
-              << "WGL OpenGL context destroyed (hdc: 0x" << std::setw(8) << (uint32_t)(uintptr_t)glctx.hdc
-              << ", hglrc: 0x" << std::setw(8) << (uint32_t)(uintptr_t)glctx.hglrc << ")";
-
-    memset(&glctx, 0, sizeof(GLContext));
-}
-
-#endif // _WIN32
-
-//------------------------------------------------------------------------
-// Linux.
-//------------------------------------------------------------------------
-
-#ifdef __linux__
-
-static pthread_mutex_t s_getProcAddressMutex;
-
-typedef void (*PROCFN)();
-
-static void safeGetProcAddress(const char* name, PROCFN* pfn)
-{
-    PROCFN result = eglGetProcAddress(name);
-    if (!result)
-    {
-        pthread_mutex_unlock(&s_getProcAddressMutex); // Prepare for thread exit.
-        LOG(FATAL) << "wglGetProcAddress() failed for '" << name << "'";
-        exit(1); // Should never get here but make sure we exit.
-    }
-    *pfn = result;
-}
-
-static void initializeGLExtensions(void)
-{
-    pthread_mutex_lock(&s_getProcAddressMutex);
-
-    // Only dig function pointers if not done already.
-    if (!s_glExtInitialized)
-    {
-        // Generate code to populate the function pointers.
-#define GLUTIL_EXT(return_type, name, ...) safeGetProcAddress(#name, (PROCFN*)&name);
-#include "glutil_extlist.h"
-#undef GLUTIL_EXT
-
-        // Mark as initialized.
-        s_glExtInitialized = true;
-    }
-
-    pthread_mutex_unlock(&s_getProcAddressMutex);
-    return;
-}
-
-void setGLContext(GLContext& glctx)
-{
-    if (!glctx.context)
-        LOG(FATAL) << "setGLContext() called with null gltcx";
-
-    if (!eglMakeCurrent(glctx.display, EGL_NO_SURFACE, EGL_NO_SURFACE, glctx.context))
-        LOG(ERROR) << "eglMakeCurrent() failed when setting GL context";
-
-    if (glctx.extInitialized)
-        return;
-    initializeGLExtensions();
-    glctx.extInitialized = 1;
-}
-
-void releaseGLContext(void)
-{
-    EGLDisplay display = eglGetCurrentDisplay();
-    if (display == EGL_NO_DISPLAY)
-        LOG(WARNING) << "releaseGLContext() called with no active display";
-    if (!eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT))
-        LOG(FATAL) << "eglMakeCurrent() failed when releasing GL context";
-}
-
-static EGLDisplay getCudaDisplay(int cudaDeviceIdx)
-{
-    typedef EGLBoolean (*eglQueryDevicesEXT_t)(EGLint, EGLDeviceEXT, EGLint*);
-    typedef EGLBoolean (*eglQueryDeviceAttribEXT_t)(EGLDeviceEXT, EGLint, EGLAttrib*);
-    typedef EGLDisplay (*eglGetPlatformDisplayEXT_t)(EGLenum, void*, const EGLint*);
-
-    eglQueryDevicesEXT_t eglQueryDevicesEXT = (eglQueryDevicesEXT_t)eglGetProcAddress("eglQueryDevicesEXT");
-    if (!eglQueryDevicesEXT)
-    {
-        LOG(INFO) << "eglGetProcAddress(\"eglQueryDevicesEXT\") failed";
-        return 0;
-    }
-
-    eglQueryDeviceAttribEXT_t eglQueryDeviceAttribEXT = (eglQueryDeviceAttribEXT_t)eglGetProcAddress("eglQueryDeviceAttribEXT");
-    if (!eglQueryDeviceAttribEXT)
-    {
-        LOG(INFO) << "eglGetProcAddress(\"eglQueryDeviceAttribEXT\") failed";
-        return 0;
-    }
-
-    eglGetPlatformDisplayEXT_t eglGetPlatformDisplayEXT = (eglGetPlatformDisplayEXT_t)eglGetProcAddress("eglGetPlatformDisplayEXT");
-    if (!eglGetPlatformDisplayEXT)
-    {
-        LOG(INFO) << "eglGetProcAddress(\"eglGetPlatformDisplayEXT\") failed";
-        return 0;
-    }
-
-    int num_devices = 0;
-    eglQueryDevicesEXT(0, 0, &num_devices);
-    if (!num_devices)
-        return 0;
-
-    EGLDisplay display = 0;
-    EGLDeviceEXT* devices = (EGLDeviceEXT*)malloc(num_devices * sizeof(void*));
-    eglQueryDevicesEXT(num_devices, devices, &num_devices);
-    for (int i=0; i < num_devices; i++)
-    {
-        EGLDeviceEXT device = devices[i];
-        intptr_t value = -1;
-        if (eglQueryDeviceAttribEXT(device, EGL_CUDA_DEVICE_NV, &value) && value == cudaDeviceIdx)
-        {
-            display = eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, device, 0);
-            break;
-        }
-    }
-
-    free(devices);
-    return display;
-}
-
-GLContext createGLContext(int cudaDeviceIdx)
-{
-    EGLDisplay display = 0;
-
-    if (cudaDeviceIdx >= 0)
-    {
-        char pciBusId[256] = "";
-        LOG(INFO) << "Creating GL context for Cuda device " << cudaDeviceIdx;
-        display = getCudaDisplay(cudaDeviceIdx);
-        if (!display)
-            LOG(INFO) << "Failed, falling back to default display";
-    }
-
-    if (!display)
-    {
-        display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
-        if (display == EGL_NO_DISPLAY)
-            LOG(FATAL) << "eglGetDisplay() failed";
-    }
-
-    EGLint major;
-    EGLint minor;
-    if (!eglInitialize(display, &major, &minor))
-        LOG(FATAL) << "eglInitialize() failed";
-
-    // Choose configuration.
-
-    const EGLint context_attribs[] = {
-        EGL_RED_SIZE,           8,
-        EGL_GREEN_SIZE,         8,
-        EGL_BLUE_SIZE,          8,
-        EGL_ALPHA_SIZE,         8,
-        EGL_DEPTH_SIZE,         24,
-        EGL_STENCIL_SIZE,       8,
-        EGL_RENDERABLE_TYPE,    EGL_OPENGL_BIT,
-        EGL_SURFACE_TYPE,       EGL_PBUFFER_BIT,
-        EGL_NONE
-    };
-
-    EGLConfig config;
-    EGLint num_config;
-    if (!eglChooseConfig(display, context_attribs, &config, 1, &num_config))
-        LOG(FATAL) << "eglChooseConfig() failed";
-
-    // Create GL context.
-
-    if (!eglBindAPI(EGL_OPENGL_API))
-        LOG(FATAL) << "eglBindAPI() failed";
-
-    EGLContext context = eglCreateContext(display, config, EGL_NO_CONTEXT, NULL);
-    if (context == EGL_NO_CONTEXT)
-        LOG(FATAL) << "eglCreateContext() failed";
-
-    // Done.
-
-    LOG(INFO) << "EGL " << (int)minor << "." << (int)major << " OpenGL context created (disp: 0x"
-              << std::hex << std::setfill('0')
-              << std::setw(16) << (uintptr_t)display
-              << ", ctx: 0x" << std::setw(16) << (uintptr_t)context << ")";
-
-    GLContext glctx = {display, context, 0};
-    return glctx;
-}
-
-void destroyGLContext(GLContext& glctx)
-{
-    if (!glctx.context)
-        LOG(FATAL) << "destroyGLContext() called with null gltcx";
-
-    // If this is the current context, release it.
-    if (eglGetCurrentContext() == glctx.context)
-        releaseGLContext();
-
-    if (!eglDestroyContext(glctx.display, glctx.context))
-        LOG(ERROR) << "eglDestroyContext() failed";
-
-    LOG(INFO) << "EGL OpenGL context destroyed (disp: 0x"
-              << std::hex << std::setfill('0')
-              << std::setw(16) << (uintptr_t)glctx.display
-              << ", ctx: 0x" << std::setw(16) << (uintptr_t)glctx.context << ")";
-
-    memset(&glctx, 0, sizeof(GLContext));
-}
-
-//------------------------------------------------------------------------
-
-#endif // __linux__
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/glutil.h

@@ -1,113 +0,0 @@
-// Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#pragma once
-
-//------------------------------------------------------------------------
-// Windows-specific headers and types.
-//------------------------------------------------------------------------
-
-#ifdef _WIN32
-#define NOMINMAX
-#include <windows.h> // Required by gl.h in Windows.
-#define GLAPIENTRY APIENTRY
-
-struct GLContext
-{
-    HDC     hdc;
-    HGLRC   hglrc;
-    int     extInitialized;
-};
-
-#endif // _WIN32
-
-//------------------------------------------------------------------------
-// Linux-specific headers and types.
-//------------------------------------------------------------------------
-
-#ifdef __linux__
-#define EGL_NO_X11 // X11/Xlib.h has "#define Status int" which breaks Tensorflow. Avoid it.
-#define MESA_EGL_NO_X11_HEADERS
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#define GLAPIENTRY
-
-struct GLContext
-{
-    EGLDisplay  display;
-    EGLContext  context;
-    int         extInitialized;
-};
-
-#endif // __linux__
-
-//------------------------------------------------------------------------
-// OpenGL, CUDA interop, GL extensions.
-//------------------------------------------------------------------------
-#define GL_GLEXT_LEGACY
-#include <GL/gl.h>
-#include <cuda_gl_interop.h>
-
-// Constants.
-#ifndef GL_VERSION_1_2
-#define GL_CLAMP_TO_EDGE                 0x812F
-#define GL_TEXTURE_3D                    0x806F
-#endif
-#ifndef GL_VERSION_1_5
-#define GL_ARRAY_BUFFER                  0x8892
-#define GL_DYNAMIC_DRAW                  0x88E8
-#define GL_ELEMENT_ARRAY_BUFFER          0x8893
-#endif
-#ifndef GL_VERSION_2_0
-#define GL_FRAGMENT_SHADER               0x8B30
-#define GL_INFO_LOG_LENGTH               0x8B84
-#define GL_LINK_STATUS                   0x8B82
-#define GL_VERTEX_SHADER                 0x8B31
-#endif
-#ifndef GL_VERSION_3_0
-#define GL_MAJOR_VERSION                 0x821B
-#define GL_MINOR_VERSION                 0x821C
-#define GL_RGBA32F                       0x8814
-#define GL_TEXTURE_2D_ARRAY              0x8C1A
-#endif
-#ifndef GL_VERSION_3_2
-#define GL_GEOMETRY_SHADER               0x8DD9
-#endif
-#ifndef GL_ARB_framebuffer_object
-#define GL_COLOR_ATTACHMENT0             0x8CE0
-#define GL_COLOR_ATTACHMENT1             0x8CE1
-#define GL_DEPTH_STENCIL                 0x84F9
-#define GL_DEPTH_STENCIL_ATTACHMENT      0x821A
-#define GL_DEPTH24_STENCIL8              0x88F0
-#define GL_FRAMEBUFFER                   0x8D40
-#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506
-#define GL_UNSIGNED_INT_24_8             0x84FA
-#endif
-#ifndef GL_ARB_imaging
-#define GL_TABLE_TOO_LARGE               0x8031
-#endif
-#ifndef GL_KHR_robustness
-#define GL_CONTEXT_LOST                  0x0507
-#endif
-
-// Declare function pointers to OpenGL extension functions.
-#define GLUTIL_EXT(return_type, name, ...) extern return_type (GLAPIENTRY* name)(__VA_ARGS__);
-#include "glutil_extlist.h"
-#undef GLUTIL_EXT
-
-//------------------------------------------------------------------------
-// Common functions.
-//------------------------------------------------------------------------
-
-void        setGLContext            (GLContext& glctx);
-void        releaseGLContext        (void);
-GLContext   createGLContext         (int cudaDeviceIdx);
-void        destroyGLContext        (GLContext& glctx);
-const char* getGLErrorString        (GLenum err);
-
-//------------------------------------------------------------------------

extensions/nvdiffrast/nvdiffrast/common/glutil_extlist.h

@@ -1,48 +0,0 @@
-// Copyright (c) 2020, NVIDIA CORPORATION.  All rights reserved.
-//
-// NVIDIA CORPORATION and its licensors retain all intellectual property
-// and proprietary rights in and to this software, related documentation
-// and any modifications thereto.  Any use, reproduction, disclosure or
-// distribution of this software and related documentation without an express
-// license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-#ifndef GL_VERSION_1_2
-GLUTIL_EXT(void,   glTexImage3D,                GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
-#endif
-#ifndef GL_VERSION_1_5
-GLUTIL_EXT(void,   glBindBuffer,                GLenum target, GLuint buffer);
-GLUTIL_EXT(void,   glBufferData,                GLenum target, ptrdiff_t size, const void* data, GLenum usage);
-GLUTIL_EXT(void,   glGenBuffers,                GLsizei n, GLuint* buffers);
-#endif
-#ifndef GL_VERSION_2_0
-GLUTIL_EXT(void,   glAttachShader,              GLuint program, GLuint shader);
-GLUTIL_EXT(void,   glCompileShader,             GLuint shader);
-GLUTIL_EXT(GLuint, glCreateProgram,             void);
-GLUTIL_EXT(GLuint, glCreateShader,              GLenum type);
-GLUTIL_EXT(void,   glDrawBuffers,               GLsizei n, const GLenum* bufs);
-GLUTIL_EXT(void,   glEnableVertexAttribArray,   GLuint index);
-GLUTIL_EXT(void,   glGetProgramInfoLog,         GLuint program, GLsizei bufSize, GLsizei* length, char* infoLog);
-GLUTIL_EXT(void,   glGetProgramiv,              GLuint program, GLenum pname, GLint* param);
-GLUTIL_EXT(void,   glLinkProgram,               GLuint program);
-GLUTIL_EXT(void,   glShaderSource,              GLuint shader, GLsizei count, const char *const* string, const GLint* length);
-GLUTIL_EXT(void,   glUniform1f,                 GLint location, GLfloat v0);
-GLUTIL_EXT(void,   glUniform2f,                 GLint location, GLfloat v0, GLfloat v1);
-GLUTIL_EXT(void,   glUseProgram,                GLuint program);
-GLUTIL_EXT(void,   glVertexAttribPointer,       GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer);
-#endif
-#ifndef GL_VERSION_3_2
-GLUTIL_EXT(void,   glFramebufferTexture,        GLenum target, GLenum attachment, GLuint texture, GLint level);
-#endif
-#ifndef GL_ARB_framebuffer_object
-GLUTIL_EXT(void,   glBindFramebuffer,           GLenum target, GLuint framebuffer);
-GLUTIL_EXT(void,   glGenFramebuffers,           GLsizei n, GLuint* framebuffers);
-#endif
-#ifndef GL_ARB_vertex_array_object
-GLUTIL_EXT(void,   glBindVertexArray,           GLuint array);
-GLUTIL_EXT(void,   glGenVertexArrays,           GLsizei n, GLuint* arrays);
-#endif
-#ifndef GL_ARB_multi_draw_indirect
-GLUTIL_EXT(void,   glMultiDrawElementsIndirect, GLenum mode, GLenum type, const void *indirect, GLsizei primcount, GLsizei stride);
-#endif
-
-//------------------------------------------------------------------------