Lazybridge Documentation

Lazybridge is a standalone, free asset bridge for 3D artists. It runs as a local web application (port 8000) and connects your asset library directly to the major 3D applications and DCC tools.

The key design goals are:

• One-click send — select an asset, click a send button, it appears in your scene immediately.
• Render-engine aware — materials are auto-wired for Octane, Redshift, Corona, Arnold, Cycles and more.
• Extensible — a plugin system lets you pull assets from any online library (PolyHaven, AmbientCG, …).
• Local-first — everything runs on your machine; no cloud dependency for core features.

Current version: 2.0.2   License: CC0 / Free   Platform: Windows

What the Importer does

The Lazybridge importer ingests assets from your local file system into the library. It can handle individual files or entire folder trees, auto-detecting asset type, collecting metadata, generating previews, and optionally packing texture sets.

Key Features

• Drag & Drop — drag files or folders directly onto the Import page.
• Batch import — processes 500+ assets in a single run.
• Auto-detection — each file is classified as a texture, model, HDRI, or material pack based on filename patterns and extension.
• Quixel / Fab JSON — reads AssetInfo.json or Fab metadata files to populate name, tags, category, and LOD info automatically.
• Normal-map conversion — optionally flips the green channel (DirectX → OpenGL) during import.
• ARM texture packing — combines separate AO, Roughness, and Metalness maps into a single packed ARM texture to optimise memory usage.
• Duplicate detection — skips assets that are already present in the library.

Category	Extensions	Notes
Textures & Images	.png .jpg .jpeg .tif .tiff .exr .hdr .tga .bmp .dds .webp	All PBR map types: BaseColor, Normal, Roughness, Metallic, AO, Displacement/Height, Opacity, Emissive, Specular, Gloss, Cavity, Translucency, Fuzz, Sheen, Coating. Packed Fab/Megascans JPEGs are extracted to grayscale PNG automatically.
3D Models	.fbx .obj .gltf .glb .abc .dae .stl .ply .blend .max .ma .mb .3ds	LODs detected automatically from filename suffixes (e.g. _LOD0)
HDRIs	.hdr .hdri .exr	Equirectangular panoramas; EXR preferred for high-dynamic-range fidelity
IES Lights	.ies	Photometric light profiles for physically accurate spot/area lights. Imported as external resource and sent directly to lights in C4D, Blender, Houdini, Maya, Unreal, Unity.
VDB Volumes	.vdb	Single-frame or animated VDB sequences. Sent as Volume Objects (Redshift RSVolume, Corona Volume, C4D Volume Loader, Blender Volume, Houdini Volume SOP, Maya FluidShape)
Light Gobos	.png .jpg .exr …	Texture images tagged as “light” type in the asset metadata. Projected onto area/spot lights via gobo slot.

The exporters send assets from the Lazybridge library directly into a live 3D application session. All exporters communicate over localhost — Lazybridge sends a JSON payload (HTTP POST) or TCP socket command to a companion script/plugin running inside the target application. The render engine is read from config.ini and controls which node graph is built.

Application	Port	Protocol	Render Engines	Asset Types
Cinema 4D	8080	Script via exe	Octane, Redshift, Corona	Materials, Models, HDRIs, IES Lights, Light Gobos, VDBs
Blender	8082	HTTP	Cycles, EEVEE	Materials, Models, HDRIs, IES Lights, VDBs
Houdini	8085	TCP Socket	Karma, Mantra, Redshift	Materials, Models, HDRIs, IES Lights, Light Gobos
Maya	8101	HTTP	Arnold	Materials, Models, HDRIs, IES Lights, Light Gobos, VDBs
Unreal Engine 5	8084	HTTP	Lumen / Path Tracing	Materials, Models, HDRIs, IES Lights
Unity	8083	HTTP	URP, HDRP, Built-in	Materials, Models, HDRIs, IES Lights, Light Gobos, VDBs
Substance Painter	9876	TCP Socket	—	Materials, Textures

Supported Render Engines

Octane Redshift Corona

Installation

How it works

When you click Send to C4D, Lazybridge launches Cinema 4D (if not already running) and passes the asset data via the script manager. The LazyToC4D.py script creates the appropriate material node graph for the active render engine, connects all texture slots, and places models or lights into the scene.

Texture Slot Mapping

PBR Map	Octane	Redshift	Corona
Base Color / Albedo	Albedo (Universal)	Diffuse Color	Diffuse Color
Roughness	Roughness	Refl Roughness	Reflection Glossiness
Metalness	Metallic	Metalness	Metalness
Normal	Normal	Bump Map (normal mode)	Bump Map (normal mode)
Displacement	Displacement (OctaneDisplacement)	Displacement	Displacement
Opacity / Alpha	Opacity	Opacity	Opacity
Emission	Emission (Blackbody)	Emission	Emission
Coating	Coating (Universal)	Coating	Coating
Sheen	Sheen (Universal)	Sheen	Sheen
Transmission	Transmission	Refraction Weight	Refraction

Additional Asset Types (C4D)

• Models — imported via C4D's native FBX/OBJ importer and placed in the active scene.
• HDRIs — applied as Octane HDRI Environment tag, Redshift Dome Light, or Corona Sky/Environment depending on the active renderer.
• IES Lights — creates a C4D Area Light with the .ies file loaded as the photometric profile (TEX_IES slot).
• Light Gobos — texture images tagged as light type are loaded into the gobo slot of a C4D Area Light.
• VDB Volumes — creates a C4D Volume Object (Ovolumeobject), Redshift RSVolume, or Corona Volume object depending on the active renderer and loads the .vdb sequence.
• C4D Scripts (.c4dscript) — assets that contain .c4dscript files in their Infos.json are copied to the C4D scripts folder and run directly (used for Octane AutoMat presets etc.).

Supported Render Engines

Cycles EEVEE

Installation

How it works

Lazybridge POSTs to http://localhost:8082/receive. The add-on handles each asset type natively:

• Materials — creates a Principled BSDF material and connects all detected PBR texture maps (Color, Roughness, Metallic, Normal, Displacement, Emission, Alpha).
• Models — imported via Blender's built-in FBX/OBJ/GLTF importers and placed at the 3D cursor.
• HDRIs — sets the World shader to an Environment Texture node and loads the .hdr / .exr file.
• IES Lights — creates a Blender Point Light, sets the light type to IES mode, and loads the .ies photometric profile file.
• VDB Volumes — imports .vdb files as Blender Volume Objects. VDB sequences (multiple numbered files) are loaded as an animated sequence.

Supported Render Engines

Karma (KarmaXPU) Mantra Redshift

Installation

How it works

Lazybridge sends a JSON command over a TCP socket to port 8085. LazyToHoudini.py inside Houdini receives it and builds the appropriate network:

• Materials — creates a Material Builder VOP network with Karma Principled Shader, Mantra Principled Shader, or Redshift Standard Material and connects all PBR texture maps.
• HDRIs — adds a Houdini Environment Light and loads the HDRI file.
• Models — imports geometry via File SOP into the current scene.
• IES Lights — creates a Houdini light and assigns the .ies file to the photometric profile parameter.
• Light Gobos — textures tagged as light (gobo) type are sent as area lights with the image file loaded into the gobo/projection slot.

See Exporter/Houdini/INSTALLATION_DE.md for a step-by-step installation guide in German.

Supported Render Engines

Arnold

Installation

How it works

Lazybridge POSTs to http://localhost:8101/import. The plugin routes the request by asset type:

• Materials — creates an aiStandardSurface shader and connects all detected PBR maps (BaseColor, Normal, Roughness, Metallic, Displacement, Opacity, Emission, Coating, Sheen, Transmission).
• Models — imported via Maya's FBX importer and placed in the scene.
• HDRIs — added to the scene as an aiSkyDomeLight.
• IES Lights — creates an aiPhotometricLight and assigns the .ies file.
• Light Gobos — texture assets marked as gobo type are loaded into an area light's gobo slot (aiAreaLight).
• VDB Volumes — imports the VDB sequence as an aiVolume node.

Render Pipelines

Lumen Path Tracing Nanite

Installation

How it works

Assets are imported into /Game/LazyBridge/ using Unreal's built-in import pipeline:

• Materials — creates M_<AssetName> with all texture parameters wired (BaseColor, Normal, ORM packed, Roughness, Metallic, Displacement/Height, Opacity, Emissive).
• Models — imported as Static Mesh assets and placed in the current level at the world origin.
• HDRIs — assigned to a Sky Light actor as a cubemap.
• IES Lights — imported as IES Texture assets and assigned to a Point Light or Spot Light actor with the IES profile applied.

Render Pipelines

URP HDRP Built-in

Installation

How it works

Lazybridge POSTs to http://localhost:8083/receive. The Unity editor script imports assets into Assets/LazyBridge/ and routes by type:

• Materials & Textures — creates a material using the active render pipeline's shader (URP Lit, HDRP Lit, or Standard) and wires all PBR texture slots.
• Models — imported as prefabs via Unity's FBX importer.
• HDRIs — imported as Cubemap texture assets.
• IES Lights — creates an IES Light Cookies asset and attaches it to a Spot or Point Light.
• Light Gobos — texture images tagged as gobo are set as the cookie texture on a Spot Light.
• VDB Volumes — imported as VDB assets and used with Unity's Visual Effect Graph volume node (HDRP).

Installation

How it works

Lazybridge communicates with Substance Painter via a TCP socket on port 9876 (not HTTP). Each message is length-prefixed using Python's struct module for reliable framing. The plugin imports material textures into the current project's shelf and creates a base fill layer per texture set with all PBR slots populated.

Plugins extend Lazybridge with additional online asset sources. Each plugin is a self-contained Python package in the Plugins/ directory and appears as a selectable source in the asset browser alongside the built-in Lazytextures library.

Plugin Directory Structure

Plugins/
└── myplugin/
    ├── plugin.py           ← main Python class (required)
    ├── plugin_info.json    ← metadata (id, name, version, …)
    ├── filter_config.json  ← filter UI definition
    ├── user_settings.json  ← per-user settings schema
    └── downloaded_registry.json  ← cached download records

Every plugin must implement a class that inherits from PluginBase. The three required methods are:

from plugin_base import PluginBase

class MyPlugin(PluginBase):

    def fetch_assets(
        self,
        asset_type: str,        # "materials" | "textures" | "hdris" | "models" | "others"
        page: int,              # 0-based page index
        page_size: int,         # number of items per page
        query: str = "",        # free-text search query
        category: str = "",     # category slug (plugin-specific)
        filters: dict = None    # key/value pairs from filter_config.json
    ) -> dict:
        """
        Returns:
        {
            "assets": [
                {
                    "id":        str,   # unique asset ID
                    "name":      str,   # display name
                    "type":      str,   # asset type
                    "preview":   str,   # URL or local path of thumbnail
                    "tags":      list,  # optional list of tag strings
                    "metadata":  dict   # arbitrary extra data
                },
                ...
            ],
            "total":        int,   # total number of matching assets
            "has_more":     bool   # whether more pages exist
        }
        """
        ...

    def download_asset(
        self,
        asset_id: str,
        asset_name: str,
        asset_type: str,
        resolution: str,              # e.g. "2K", "4K", "8K"
        progress_callback=None        # callable(percent: float) or None
    ) -> tuple[bool, str]:
        """
        Download the asset to the local library.

        Returns:
            (True,  path_to_asset_folder)  on success
            (False, error_message)         on failure
        """
        ...

    def get_categories(
        self,
        asset_type: str
    ) -> list:
        """
        Returns a list of category dicts:
        [
            {"id": "wood", "name": "Wood"},
            {"id": "metal", "name": "Metal"},
            ...
        ]
        An empty list is valid if the plugin has no categories.
        """
        ...

plugin_info.json

{
    "id":          "myplugin",
    "name":        "My Plugin",
    "version":     "1.0.0",
    "description": "Short description shown in the UI.",
    "author":      "Your Name",
    "website":     "https://example.com",
    "supported_types": ["materials", "textures", "hdris", "models"]
}

filter_config.json

Defines the filter controls shown in the sidebar for this plugin. Each entry becomes a dropdown or checkbox group.

{
    "materials": [
        {
            "id":      "sort",
            "label":   "Sort By",
            "type":    "select",
            "options": [
                {"value": "latest",     "label": "Latest"},
                {"value": "popular",    "label": "Most Popular"},
                {"value": "downloads",  "label": "Most Downloaded"}
            ],
            "default": "latest"
        }
    ]
}

user_settings.json

Stores persistent per-user settings for the plugin (e.g. API keys, preferred resolution). Schema follows the same pattern as filter_config.json.

Lazybridge exposes a local REST API on http://localhost:8000. This is the same API the browser UI uses internally, so you can drive Lazybridge from any tool, script, or pipeline that can make HTTP requests.

Fetch Assets from a Plugin

GET /api/plugins/assets
    ?type=materials
    &page=0
    &page_size=40
    &query=wood
    &category=
    &plugin_id=polyhaven

Response 200:
{
    "assets":   [ { "id": "...", "name": "...", "preview": "...", ... }, … ],
    "total":    1250,
    "has_more": true
}

Cross-Plugin Search

GET /api/plugins/search
    ?q=concrete
    &types=materials,textures
    &page=0
    &page_size=20

Response 200:
{
    "results": [
        { "plugin_id": "polyhaven", "assets": [ … ] },
        { "plugin_id": "ambientcg", "assets": [ … ] }
    ]
}

Get Categories

GET /api/plugins/categories/{asset_type}?plugin_id=polyhaven

Response 200:
[ { "id": "wood", "name": "Wood" }, … ]

Get Filter Config

GET /api/plugins/filter-config/{plugin_id}

Response 200:
{ "materials": [ { "id": "sort", "label": "Sort By", … } ] }

Download an Asset

POST /api/plugins/download
Content-Type: application/json

{
    "plugin_id":  "ambientcg",
    "asset_id":   "Concrete041",
    "asset_name": "Concrete041",
    "asset_type": "materials",
    "resolution": "4K"
}

Response 200:
{ "success": true, "path": "C:/Library/Materials/Concrete041" }

Response 500:
{ "success": false, "error": "Network timeout" }

Toggle Plugin On / Off

POST /api/plugins/toggle
Content-Type: application/json

{ "plugin_id": "ambientcg", "enabled": true }

Response 200:
{ "success": true }

Reload All Plugins

POST /api/plugins/reload

Response 200:
{ "success": true, "plugins": [ "polyhaven", "ambientcg" ] }

User Settings (Read / Write)

GET  /api/plugins/user-settings/{plugin_id}
POST /api/plugins/user-settings/{plugin_id}
     Body: { "preferred_resolution": "4K", ... }

List Downloaded Assets

GET /api/downloaded-assets

Response 200:
[
    {
        "id":         "Concrete041",
        "name":       "Concrete041",
        "type":       "materials",
        "source":     "ambientcg",
        "resolution": "4K",
        "path":       "C:/Library/Materials/Concrete041",
        "date":       "2025-03-14T10:23:00"
    },
    …
]

Get Local Asset Preview

GET /api/local-preview?type=materials&name=Concrete041

Response: image/jpeg  (returns the thumbnail directly)

All persistent settings live in config.ini in the Lazybridge folder. The Settings UI writes to this file; you can also edit it with any text editor while Lazybridge is not running.

Section	Key	Description	Default
[Paths]	download_folder	Where downloaded assets are saved	(user home)
	library_folder	Root of the local asset library	(user home)
	temp_folder	Temporary download cache	%TEMP%\Lazybridge
[Cinema4D]	render_engine	Active render engine: octane, redshift, corona, arnold	redshift
	port	C4D listener port	8080
	scale	Scale multiplier for imported models	1.0
	auto_connect	Connect to C4D on startup	true
[Blender]	port	Blender addon listener port	8082
[Houdini]	port	Houdini server port	8085
[Maya]	port	Maya plugin port	8101
[Unreal]	port	Unreal Engine listener port	8084
[Unity]	port	Unity editor listener port	8083
[Substance]	port	Substance Painter listener port	9876
[UI]	theme	UI colour theme: dark or light	dark
	background_blur	Enable blurred background image	true
	grid_size	Thumbnail grid columns	auto
[Downloads]	max_concurrent	Parallel download threads	3
	auto_import_after_download	Import to library after download finishes	true
[Textures]	normal_flip_green	Convert DX normals to OGL on import	false