Substance 3d Texturing

Substance 3D Texturing

Overview

Master PBR (Physically Based Rendering) texture creation and export workflows for web and real-time engines. This skill covers Substance 3D Painter workflows from material creation through web-optimized texture export, with Python automation for batch processing and integration with WebGL/WebGPU engines.

Key capabilities:

• PBR material authoring (metallic/roughness workflow)
• Web-optimized texture export (glTF, Three.js, Babylon.js)
• Python API automation for batch export
• Texture compression and optimization for real-time rendering

Core Concepts

PBR Workflow

Substance 3D Painter uses the metallic/roughness PBR workflow with these core channels:

Base Texture Maps:

• baseColor (Albedo) - RGB diffuse color, no lighting information
• normal - RGB normal map (tangent space)
• metallic - Grayscale metalness (0 = dielectric, 1 = metal)
• roughness - Grayscale surface roughness (0 = smooth/glossy, 1 = rough/matte)

Additional Maps:

• ambientOcclusion (AO) - Grayscale cavity/occlusion
• height - Grayscale displacement/height
• emissive - RGB self-illumination
• opacity - Grayscale transparency

Export Presets

Substance 3D Painter includes built-in export presets for common engines:

• PBR Metallic Roughness - Standard glTF/WebGL format
• Unity HDRP/URP - Unity pipelines
• Unreal Engine - UE4/UE5 format
• Arnold (AiStandard) - Renderer-specific

For web engines, PBR Metallic Roughness is the universal standard.

Texture Resolution

Common resolutions for web (powers of 2):

• 512×512 - Low detail props, mobile
• 1024×1024 - Standard props, characters
• 2048×2048 - Hero assets, close-ups
• 4096×4096 - Showcase quality (use sparingly)

Web optimization rule: Start at 1024×1024, scale up only when texture detail is visible.

Common Patterns

1. Basic Web Export (Three.js/Babylon.js)

Manual export workflow for single texture set:

Steps: 1. File → Export Textures 2. Select preset: "PBR Metallic Roughness" 3. Configure export:

• Output directory: Choose target folder
• File format: PNG (8-bit) for web
• Padding: "Infinite" (prevents seams)
• Resolution: 1024×1024 (adjust per asset)

4. Export

Result files:

MyAsset_baseColor.png
MyAsset_normal.png
MyAsset_metallicRoughness.png  // Packed: R=nothing, G=roughness, B=metallic
MyAsset_emissive.png           // Optional

Three.js usage:

import * as THREE from 'three';

const textureLoader = new THREE.TextureLoader();

const material = new THREE.MeshStandardMaterial({
  map: textureLoader.load('MyAsset_baseColor.png'),
  normalMap: textureLoader.load('MyAsset_normal.png'),
  metalnessMap: textureLoader.load('MyAsset_metallicRoughness.png'),
  roughnessMap: textureLoader.load('MyAsset_metallicRoughness.png'),
  aoMap: textureLoader.load('MyAsset_ambientOcclusion.png'),
});

2. Batch Export with Python API

Automate export for multiple texture sets:

import substance_painter.export
import substance_painter.resource
import substance_painter.textureset

# Define export preset
export_preset = substance_painter.resource.ResourceID(
    context="starter_assets",
    name="PBR Metallic Roughness"
)

# Configure export for all texture sets
config = {
    "exportShaderParams": False,
    "exportPath": "C:/export/web_textures",
    "defaultExportPreset": export_preset.url(),
    "exportList": [],
    "exportParameters": [{
        "parameters": {
            "fileFormat": "png",
            "bitDepth": "8",
            "dithering": True,
            "paddingAlgorithm": "infinite",
            "sizeLog2": 10  // 1024×1024
        }
    }]
}

# Add all texture sets to export list
for texture_set in substance_painter.textureset.all_texture_sets():
    config["exportList"].append({
        "rootPath": texture_set.name()
    })

# Execute export
result = substance_painter.export.export_project_textures(config)

if result.status == substance_painter.export.ExportStatus.Success:
    for stack, files in result.textures.items():
        print(f"Exported {stack}: {len(files)} textures")
else:
    print(f"Export failed: {result.message}")

3. Resolution Override per Asset

Export different resolutions for different assets (e.g., hero vs. background):

config = {
    "exportPath": "C:/export",
    "defaultExportPreset": export_preset.url(),
    "exportList": [
        {"rootPath": "HeroCharacter"},   # Will use 2048 (override below)
        {"rootPath": "BackgroundProp"}   # Will use 512 (override below)
    ],
    "exportParameters": [
        {
            "filter": {"dataPaths": ["HeroCharacter"]},
            "parameters": {"sizeLog2": 11}  # 2048×2048
        },
        {
            "filter": {"dataPaths": ["BackgroundProp"]},
            "parameters": {"sizeLog2": 9}   # 512×512
        }
    ]
}

4. Custom Export Preset (Separate Channels)

Create custom preset to export metallic and roughness as separate files:

custom_preset = {
    "exportPresets": [{
        "name": "WebGL_Separated",
        "maps": [
            {
                "fileName": "$textureSet_baseColor",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "baseColor"}
                ]
            },
            {
                "fileName": "$textureSet_normal",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "normal"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "normal"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "normal"}
                ]
            },
            {
                "fileName": "$textureSet_metallic",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "metallic"}
                ],
                "parameters": {"fileFormat": "png", "bitDepth": "8"}
            },
            {
                "fileName": "$textureSet_roughness",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "roughness"}
                ],
                "parameters": {"fileFormat": "png", "bitDepth": "8"}
            }
        ]
    }]
}

config = {
    "exportPath": "C:/export",
    "exportPresets": custom_preset["exportPresets"],
    "exportList": [{"rootPath": "MyAsset", "exportPreset": "WebGL_Separated"}]
}

5. Mobile-Optimized Export

Aggressive compression for mobile WebGL:

mobile_config = {
    "exportPath": "C:/export/mobile",
    "defaultExportPreset": export_preset.url(),
    "exportList": [{"rootPath": texture_set.name()}],
    "exportParameters": [{
        "parameters": {
            "fileFormat": "jpeg",        # JPEG for baseColor (lossy but smaller)
            "bitDepth": "8",
            "sizeLog2": 9,               # 512×512 maximum
            "paddingAlgorithm": "infinite"
        }
    }, {
        "filter": {"outputMaps": ["$textureSet_normal", "$textureSet_metallicRoughness"]},
        "parameters": {
            "fileFormat": "png"          # PNG for data maps (need lossless)
        }
    }]
}

Post-export: Use tools like pngquant or tinypng for further compression.

6. glTF/GLB Integration

Export textures for glTF 2.0 format:

gltf_config = {
    "exportPath": "C:/export/gltf",
    "defaultExportPreset": substance_painter.resource.ResourceID(
        context="starter_assets",
        name="PBR Metallic Roughness"
    ).url(),
    "exportList": [{"rootPath": texture_set.name()}],
    "exportParameters": [{
        "parameters": {
            "fileFormat": "png",
            "bitDepth": "8",
            "sizeLog2": 10,              # 1024×1024
            "paddingAlgorithm": "infinite"
        }
    }]
}

# After export, reference in glTF:
# {
#   "materials": [{
#     "name": "Material",
#     "pbrMetallicRoughness": {
#       "baseColorTexture": {"index": 0},
#       "metallicRoughnessTexture": {"index": 1}
#     },
#     "normalTexture": {"index": 2}
#   }]
# }

7. Event-Driven Export Plugin

Auto-export on save using Python plugin:

import substance_painter.event
import substance_painter.export
import substance_painter.project

def auto_export(e):
    if not substance_painter.project.is_open():
        return

    config = {
        "exportPath": substance_painter.project.file_path().replace('.spp', '_textures'),
        "defaultExportPreset": substance_painter.resource.ResourceID(
            context="starter_assets", name="PBR Metallic Roughness"
        ).url(),
        "exportList": [{"rootPath": ts.name()} for ts in substance_painter.textureset.all_texture_sets()],
        "exportParameters": [{
            "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 10}
        }]
    }

    substance_painter.export.export_project_textures(config)
    print("Auto-export completed")

# Register event
substance_painter.event.DISPATCHER.connect(
    substance_painter.event.ProjectSaved,
    auto_export
)

Integration Patterns

Three.js + React Three Fiber

Use exported textures in R3F:

import { useTexture } from '@react-three/drei';

function TexturedMesh() {
  const [baseColor, normal, metallicRoughness, ao] = useTexture([
    '/textures/Asset_baseColor.png',
    '/textures/Asset_normal.png',
    '/textures/Asset_metallicRoughness.png',
    '/textures/Asset_ambientOcclusion.png',
  ]);

  return (
    <mesh>
      <boxGeometry />
      <meshStandardMaterial
        map={baseColor}
        normalMap={normal}
        metalnessMap={metallicRoughness}
        roughnessMap={metallicRoughness}
        aoMap={ao}
      />
    </mesh>
  );
}

See react-three-fiber skill for advanced R3F material workflows.

Babylon.js PBR Materials

import { PBRMaterial, Texture } from '@babylonjs/core';

const pbr = new PBRMaterial("pbr", scene);
pbr.albedoTexture = new Texture("/textures/Asset_baseColor.png", scene);
pbr.bumpTexture = new Texture("/textures/Asset_normal.png", scene);
pbr.metallicTexture = new Texture("/textures/Asset_metallicRoughness.png", scene);
pbr.useRoughnessFromMetallicTextureAlpha = false;
pbr.useRoughnessFromMetallicTextureGreen = true;
pbr.useMetallnessFromMetallicTextureBlue = true;

See babylonjs-engine skill for advanced PBR workflows.

GLTF Export Pipeline

1. Export textures from Substance (as above) 2. Export model from Blender with glTF exporter 3. Reference Substance textures in .gltf JSON 4. Use gltf-pipeline for Draco compression:

gltf-pipeline -i model.gltf -o model.glb -d

See blender-web-pipeline skill for complete 3D asset pipeline.

Performance Optimization

Texture Size Budget

Desktop WebGL: ~100-150MB total texture memory Mobile WebGL: ~30-50MB total texture memory

Budget per asset:

• Background/props: 512×512 (1MB per texture × 4 maps = 4MB)
• Standard assets: 1024×1024 (4MB per texture × 4 maps = 16MB)
• Hero assets: 2048×2048 (16MB per texture × 4 maps = 64MB)

Compression Strategies

1. JPEG for baseColor (70-80% quality) - 10× smaller than PNG 2. PNG-8 for data maps (normal, metallic, roughness) - lossless required 3. Basis Universal (.basis) - GPU texture compression (90% smaller) 4. Texture atlasing - Combine multiple assets into single texture

Channel Packing

Pack grayscale maps into RGB channels to reduce texture count:

Packed ORM (Occlusion-Roughness-Metallic):

• Red: Ambient Occlusion
• Green: Roughness
• Blue: Metallic

Export in Substance:

orm_map = {
    "fileName": "$textureSet_ORM",
    "channels": [
        {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "ambientOcclusion"},
        {"destChannel": "G", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "roughness"},
        {"destChannel": "B", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "metallic"}
    ]
}

Mipmaps

Always enable mipmaps in engine for textures viewed at distance:

// Three.js (automatic)
texture.generateMipmaps = true;

// Babylon.js
texture.updateSamplingMode(Texture.TRILINEAR_SAMPLINGMODE);

Common Pitfalls

1. Wrong Color Space for BaseColor

Problem: BaseColor exported in linear space looks washed out.

Solution: Substance exports baseColor in sRGB by default (correct). Ensure engine uses sRGB:

// Three.js
baseColorTexture.colorSpace = THREE.SRGBColorSpace;

// Babylon.js (automatic for albedoTexture)

2. Normal Map Baking Issues

Problem: Normal maps show inverted or incorrect shading.

Solution:

• Verify tangent space normal format (DirectX vs. OpenGL Y-flip)
• Substance uses OpenGL (Y+), same as glTF standard
• If using DirectX engine, flip green channel in export

3. Metallic/Roughness Channel Order

Problem: Metallic/roughness texture has swapped channels.

Solution: Default Substance export:

• Blue channel = Metallic
• Green channel = Roughness
• Matches glTF 2.0 specification

4. Padding Artifacts at UV Seams

Problem: Black or colored lines appear at UV seams.

Solution: Set padding algorithm to "infinite" in export settings:

"paddingAlgorithm": "infinite"

5. Oversized Textures for Web

Problem: 4K textures cause long load times and memory issues on web.

Solution:

• Default to 1024×1024 for web
• Use 2048×2048 only for hero assets viewed close-up
• Implement LOD system with multiple resolution sets

6. Missing AO Map in Engine

Problem: AO map exported but not visible in engine.

Solution:

• Three.js: Requires second UV channel (geometry.attributes.uv2)
• Babylon.js: Set material.useAmbientOcclusionFromMetallicTextureRed = true
• Alternative: Bake AO into baseColor in Substance

Resources

See bundled resources for complete workflows:

• references/python_api_reference.md - Complete Substance Painter Python API
• references/export_presets.md - Built-in and custom export preset catalog
• references/pbr_channel_guide.md - Deep dive into PBR texture channels
• scripts/batch_export.py - Batch export all texture sets
• scripts/web_optimizer.py - Post-process textures for web (resize, compress)
• scripts/generate_export_preset.py - Create custom export preset JSON
• assets/export_templates/ - Pre-configured export presets for Three.js, Babylon.js, Unity

Related Skills

• blender-web-pipeline - Complete 3D model → texture → web pipeline
• threejs-webgl - Loading and using PBR textures in Three.js
• react-three-fiber - R3F material workflows with Substance textures
• babylonjs-engine - Babylon.js PBR material system integration

Substance 3D Texturing Assets

Pre-configured export preset templates for various web engines and platforms.

Directory Structure

assets/
└── export_templates/
    ├── gltf_standard.json          # glTF 2.0 compliant preset
    ├── threejs_optimized.json      # Three.js with separate channels
    ├── babylonjs_pbr.json          # Babylon.js PBR format
    ├── web_orm_packed.json         # ORM channel packing
    └── mobile_webgl.json           # Mobile-optimized preset

Usage

Method 1: Copy Preset Configuration

Copy the JSON content from any template file and use directly in your Python script:

import json
import substance_painter.export

# Load preset from file
with open('assets/export_templates/gltf_standard.json', 'r') as f:
    custom_preset = json.load(f)

config = {
    "exportPath": "C:/export",
    "exportPresets": custom_preset["exportPresets"],
    "exportList": [{"rootPath": "MyAsset", "exportPreset": "glTF_Standard"}],
    "exportParameters": [{
        "parameters": {"paddingAlgorithm": "infinite"}
    }]
}

result = substance_painter.export.export_project_textures(config)

Method 2: Use Preset Generator Script

Generate presets programmatically:

# Generate glTF preset
.claude/skills/substance-3d-texturing/scripts/generate_export_preset.py --preset gltf --output my_preset.json

# Interactive mode
.claude/skills/substance-3d-texturing/scripts/generate_export_preset.py

Preset Descriptions

gltf_standard.json

Format: glTF 2.0 compliant Resolution: 1024×1024 Outputs:

• baseColor.png - RGB base color (sRGB)
• normal.png - RGB normal map (OpenGL format)
• metallicRoughness.png - Packed: G=Roughness, B=Metallic

Best for:

• glTF/GLB export
• Generic WebGL applications
• Three.js, Babylon.js (standard workflow)

---

threejs_optimized.json

Format: Three.js MeshStandardMaterial Resolution: 1024×1024 Outputs:

• color.jpg - JPEG base color (smaller file size)
• normal.png - RGB normal map
• ao.png - Ambient occlusion
• metalness.png - Metallic channel
• roughness.png - Roughness channel

Best for:

• Three.js projects requiring separate channels
• Maximum flexibility (individual map control)
• When file size is less critical than editability

---

babylonjs_pbr.json

Format: Babylon.js PBRMaterial Resolution: 1024×1024 Outputs:

• albedo.png - Base color
• normal.png - Normal map
• metallicRoughness.png - Packed: G=Roughness, B=Metallic

Best for:

• Babylon.js PBR workflows
• Similar to glTF but with Babylon naming conventions

---

web_orm_packed.json

Format: ORM (Occlusion-Roughness-Metallic) Packed Resolution: 1024×1024 Outputs:

• baseColor.png - RGB base color
• normal.png - RGB normal map
• ORM.png - Packed: R=AO, G=Roughness, B=Metallic

Best for:

• Maximum efficiency (3 textures instead of 6)
• Production web applications
• When texture count matters more than editability

Texture memory savings: ~50% reduction

---

mobile_webgl.json

Format: Mobile-optimized Resolution: 512×512 Outputs:

• color.jpg - JPEG base color (aggressive compression)
• normal.png - RG normal map (reconstruct Z in shader)
• packed.png - R=AO, G=Roughness, B=Metallic

Best for:

• Mobile web applications
• Low-end devices
• When load time and memory are critical

File size: ~3MB total vs. ~16MB standard

Customization

All presets can be customized by modifying the JSON files:

Change Resolution

Modify the sizeLog2 parameter:

• 9 = 512×512
• 10 = 1024×1024 (default)
• 11 = 2048×2048
• 12 = 4096×4096

{
  "parameters": {
    "sizeLog2": 11  // Change to 2048×2048
  }
}

Change File Format

Modify the fileFormat parameter:

• "png" - Lossless (recommended for data maps)
• "jpeg" - Lossy compression (good for baseColor)
• "tga" - Targa format
• "exr" - HDR format (32-bit)

{
  "parameters": {
    "fileFormat": "jpeg"  // Change to JPEG
  }
}

Add Custom Channels

Add new map entries to pack additional channels:

{
  "fileName": "$textureSet_emissive",
  "channels": [
    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "emissive"},
    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "emissive"},
    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "emissive"}
  ],
  "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 10}
}

Integration Examples

Three.js with glTF Preset

import * as THREE from 'three';
import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader.js';

const loader = new GLTFLoader();

loader.load('model.glb', (gltf) => {
  // Textures automatically loaded from glTF
  scene.add(gltf.scene);
});

Three.js with Separate Textures

import * as THREE from 'three';

const textureLoader = new THREE.TextureLoader();

const material = new THREE.MeshStandardMaterial({
  map: textureLoader.load('Asset_color.jpg'),
  normalMap: textureLoader.load('Asset_normal.png'),
  aoMap: textureLoader.load('Asset_ao.png'),
  metalnessMap: textureLoader.load('Asset_metalness.png'),
  roughnessMap: textureLoader.load('Asset_roughness.png'),
});

// Set color space for baseColor
material.map.colorSpace = THREE.SRGBColorSpace;

Babylon.js with PBR Preset

import { PBRMaterial, Texture } from '@babylonjs/core';

const pbr = new PBRMaterial("pbr", scene);
pbr.albedoTexture = new Texture("Asset_albedo.png", scene);
pbr.bumpTexture = new Texture("Asset_normal.png", scene);
pbr.metallicTexture = new Texture("Asset_metallicRoughness.png", scene);

// Configure channel reading
pbr.useRoughnessFromMetallicTextureGreen = true;
pbr.useMetallnessFromMetallicTextureBlue = true;

ORM Packed Workflow

// Three.js with ORM texture
const ormTexture = textureLoader.load('Asset_ORM.png');

material.aoMap = ormTexture;        // Reads from Red channel
material.roughnessMap = ormTexture; // Reads from Green channel
material.metalnessMap = ormTexture; // Reads from Blue channel

Troubleshooting

Preset not found in Substance:

• Presets are for custom export via Python API only
• Not visible in Substance UI preset dropdown
• Use via Python scripts or plugins

Wrong channel order:

• Verify glTF spec: G=Roughness, B=Metallic
• Unreal uses different packing: R=AO, G=Roughness, B=Metallic
• Check engine documentation for channel expectations

Textures too large:

• Reduce sizeLog2 (e.g., 10 → 9 for 512px)
• Use mobile preset for aggressive optimization
• Convert baseColor to JPEG post-export

Normal map inverted:

• Substance uses OpenGL format (Y+)
• If using DirectX engine, flip green channel
• Or use engine setting to flip normal Y

Additional Resources

• Substance Python API: https://helpx.adobe.com/substance-3d-painter-python/api/
• glTF 2.0 Spec: https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html
• Three.js Materials: https://threejs.org/docs/#api/en/materials/MeshStandardMaterial
• Babylon.js PBR: https://doc.babylonjs.com/features/featuresDeepDive/materials/using/introToPBR

License

These preset templates are provided as examples and can be freely modified for your projects.

Substance 3D Painter Export Presets

Complete catalog of built-in and custom export presets for various game engines and web platforms.

Table of Contents

• Built-in Presets
• Web/glTF Presets
• Custom Preset Examples
• Channel Packing Strategies

Built-in Presets

Substance 3D Painter ships with presets for major engines and renderers.

PBR Metallic Roughness

Context: starter_assets Name: PBR Metallic Roughness Use for: glTF, Three.js, Babylon.js, generic PBR engines

Output textures:

• $textureSet_baseColor.png - Base color (RGB)
• $textureSet_normal.png - Normal map (RGB, OpenGL format)
• $textureSet_metallicRoughness.png - Packed texture:
• Red: Unused
• Green: Roughness
• Blue: Metallic
• $textureSet_emissive.png - Emissive (RGB) if present

Usage:

preset = substance_painter.resource.ResourceID(
    context="starter_assets",
    name="PBR Metallic Roughness"
)

Best for:

• Web applications (Three.js, Babylon.js)
• glTF/GLB export
• Generic PBR workflows

---

Unity HDRP (Lit)

Context: starter_assets Name: Unity HDRP (Lit) Use for: Unity High Definition Render Pipeline

Output textures:

• $textureSet_BaseMap.png - Base color + alpha
• $textureSet_Normal.png - Normal map (DirectX format)
• $textureSet_MaskMap.png - Packed texture:
• Red: Metallic
• Green: Ambient Occlusion
• Blue: Detail Mask
• Alpha: Smoothness (1 - roughness)

Differences from standard PBR:

• DirectX normal format (Y-flipped)
• Smoothness instead of roughness (inverted)
• Different channel packing

---

Unity URP (Lit)

Context: starter_assets Name: Unity URP (Lit) Use for: Unity Universal Render Pipeline

Output textures:

• $textureSet_BaseMap.png - Base color + alpha
• $textureSet_Normal.png - Normal map
• $textureSet_MetallicSmoothness.png - Packed:
• RGB: Metallic
• Alpha: Smoothness

---

Unreal Engine

Context: starter_assets Name: Unreal Engine 4/5 (Packed) Use for: Unreal Engine 4 and 5

Output textures:

• $textureSet_BaseColor.png - Base color
• $textureSet_Normal.png - Normal map (DirectX)
• $textureSet_OcclusionRoughnessMetallic.png - Packed:
• Red: Ambient Occlusion
• Green: Roughness
• Blue: Metallic
• $textureSet_Emissive.png - Emissive

Note: Unreal's packed ORM format is widely used and efficient.

---

Arnold (AiStandard)

Context: starter_assets Name: Arnold (AiStandard) Use for: Arnold renderer (Maya, Cinema 4D, Houdini)

Output textures:

• $textureSet_baseColor.exr - Base color (EXR 32-bit)
• $textureSet_normal.exr - Normal map
• $textureSet_specularRoughness.exr - Roughness
• $textureSet_metalness.exr - Metallic

Note: Uses EXR format for high dynamic range.

---

V-Ray

Context: starter_assets Name: V-Ray Use for: V-Ray renderer

Output textures:

• Separate files for each channel
• High bit-depth support (16/32-bit)

Web/glTF Presets

Optimized presets for web and real-time rendering.

glTF 2.0 Standard

Custom preset for glTF 2.0 compliance:

{
    "exportPresets": [{
        "name": "glTF_Standard",
        "maps": [
            {
                "fileName": "$textureSet_baseColor",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "baseColor"}
                ],
                "parameters": {
                    "fileFormat": "png",
                    "bitDepth": "8",
                    "sizeLog2": 10  # 1024×1024
                }
            },
            {
                "fileName": "$textureSet_normal",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "normal"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "normal"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "normal"}
                ],
                "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 10}
            },
            {
                "fileName": "$textureSet_metallicRoughness",
                "channels": [
                    {"destChannel": "G", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "roughness"},
                    {"destChannel": "B", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "metallic"}
                ],
                "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 10}
            }
        ]
    }]
}

Matches glTF 2.0 specification:

• BaseColor in sRGB color space
• MetallicRoughness: Green = Roughness, Blue = Metallic
• Normal in OpenGL format (Y+)

---

Three.js Optimized

Preset optimized for Three.js MeshStandardMaterial:

{
    "exportPresets": [{
        "name": "ThreeJS_Standard",
        "maps": [
            {
                "fileName": "$textureSet_color",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "baseColor"}
                ],
                "parameters": {"fileFormat": "jpeg", "bitDepth": "8", "sizeLog2": 10}  # JPEG for smaller size
            },
            {
                "fileName": "$textureSet_normal",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "normal"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "normal"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "normal"}
                ],
                "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 10}
            },
            {
                "fileName": "$textureSet_ao",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "ambientOcclusion"}
                ],
                "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 10}
            },
            {
                "fileName": "$textureSet_metalness",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "metallic"}
                ],
                "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 10}
            },
            {
                "fileName": "$textureSet_roughness",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "roughness"}
                ],
                "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 10}
            }
        ]
    }]
}

Features:

• JPEG for baseColor (70-80% quality, 10× smaller)
• PNG for data textures (lossless required)
• Separate metalness and roughness for flexibility
• Separate AO map

Three.js usage:

const material = new THREE.MeshStandardMaterial({
  map: new THREE.TextureLoader().load('Asset_color.jpg'),
  normalMap: new THREE.TextureLoader().load('Asset_normal.png'),
  aoMap: new THREE.TextureLoader().load('Asset_ao.png'),
  metalnessMap: new THREE.TextureLoader().load('Asset_metalness.png'),
  roughnessMap: new THREE.TextureLoader().load('Asset_roughness.png'),
});

---

Babylon.js PBR

Preset for Babylon.js PBRMaterial:

{
    "exportPresets": [{
        "name": "BabylonJS_PBR",
        "maps": [
            {
                "fileName": "$textureSet_albedo",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "baseColor"}
                ],
                "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 10}
            },
            {
                "fileName": "$textureSet_normal",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "normal"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "normal"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "normal"}
                ],
                "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 10}
            },
            {
                "fileName": "$textureSet_metallicRoughness",
                "channels": [
                    {"destChannel": "G", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "roughness"},
                    {"destChannel": "B", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "metallic"}
                ],
                "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 10}
            }
        ]
    }]
}

Babylon.js usage:

const pbr = new BABYLON.PBRMaterial("pbr", scene);
pbr.albedoTexture = new BABYLON.Texture("Asset_albedo.png", scene);
pbr.bumpTexture = new BABYLON.Texture("Asset_normal.png", scene);
pbr.metallicTexture = new BABYLON.Texture("Asset_metallicRoughness.png", scene);
pbr.useRoughnessFromMetallicTextureGreen = true;
pbr.useMetallnessFromMetallicTextureBlue = true;

---

Mobile WebGL (Low Spec)

Aggressive compression for mobile:

{
    "exportPresets": [{
        "name": "Mobile_WebGL",
        "maps": [
            {
                "fileName": "$textureSet_color",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "baseColor"}
                ],
                "parameters": {"fileFormat": "jpeg", "bitDepth": "8", "sizeLog2": 9}  # 512×512
            },
            {
                "fileName": "$textureSet_normal",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "normal"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "normal"}
                ],
                "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 9}  # Skip blue channel
            },
            {
                "fileName": "$textureSet_packed",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "ambientOcclusion"},
                    {"destChannel": "G", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "roughness"},
                    {"destChannel": "B", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "metallic"}
                ],
                "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 9}
            }
        ]
    }]
}

Optimizations:

• 512×512 maximum resolution
• JPEG for color (lossy but small)
• RG normal map only (reconstruct Z in shader)
• ORM packing (3 maps → 1 texture)

Total texture budget: ~3MB (vs. ~16MB standard)

Custom Preset Examples

ORM Packing (Occlusion-Roughness-Metallic)

Most efficient packing for web:

orm_preset = {
    "exportPresets": [{
        "name": "Web_ORM",
        "maps": [
            {
                "fileName": "$textureSet_baseColor",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "baseColor"}
                ]
            },
            {
                "fileName": "$textureSet_normal",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "normal"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "normal"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "normal"}
                ]
            },
            {
                "fileName": "$textureSet_ORM",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "ambientOcclusion"},
                    {"destChannel": "G", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "roughness"},
                    {"destChannel": "B", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "metallic"}
                ]
            }
        ]
    }]
}

Reduces texture count: 6 textures → 3 textures Shader setup (Three.js):

material.aoMap = ormTexture;
material.roughnessMap = ormTexture;
material.metalnessMap = ormTexture;
// Three.js automatically reads from R/G/B channels

---

Height + Normal Combined

Pack height into normal alpha channel:

{
    "fileName": "$textureSet_normalHeight",
    "channels": [
        {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "normal"},
        {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "normal"},
        {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "normal"},
        {"destChannel": "A", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "height"}
    ]
}

Use case: Parallax occlusion mapping (height from alpha)

---

Emissive + Alpha

Pack emissive RGB + opacity:

{
    "fileName": "$textureSet_emissiveAlpha",
    "channels": [
        {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "emissive"},
        {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "emissive"},
        {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "emissive"},
        {"destChannel": "A", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "opacity"}
    ]
}

---

Stylized/NPR Export

Non-photorealistic rendering (toon shading):

{
    "exportPresets": [{
        "name": "Stylized_Toon",
        "maps": [
            {
                "fileName": "$textureSet_diffuse",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "baseColor"}
                ]
            },
            {
                "fileName": "$textureSet_shadowMask",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "ambientOcclusion"}
                ]
            },
            # No metallic/roughness for toon shaders
        ]
    }]
}

Channel Packing Strategies

Standard PBR Packing

glTF 2.0 / Khronos Standard:

• BaseColor: RGB (sRGB)
• Normal: RGB (OpenGL, linear)
• MetallicRoughness:
• R: Unused
• G: Roughness (linear)
• B: Metallic (linear)

Advantages:

• Industry standard
• Maximum compatibility
• glTF compliance

---

Unreal Engine Packing

Unreal's ORM format:

• BaseColor: RGB
• Normal: RGB (DirectX)
• ORM:
• R: Ambient Occlusion
• G: Roughness
• B: Metallic

Advantages:

• Includes AO without extra texture
• Widely used format
• Efficient for complex materials

---

Mobile Optimized Packing

Aggressive compression:

• BaseColor: JPEG (lossy)
• Normal: RG only (reconstruct Z)
• ORM: RGB (AO + Roughness + Metallic)

Advantages:

• Smallest file size
• Reduced texture memory
• Faster loading on mobile

Disadvantages:

• Lossy baseColor (visual artifacts)
• RG normal requires shader modification

---

High Quality / Archival

Separate channels, high bit depth:

• BaseColor: PNG-16 or EXR-32
• Normal: PNG-16
• Metallic: PNG-16 (separate)
• Roughness: PNG-16 (separate)
• AO: PNG-16 (separate)
• Height: PNG-16 (separate)

Advantages:

• Maximum quality
• Per-channel editability
• HDR support (EXR)

Disadvantages:

• Large file sizes
• More texture slots
• Overkill for real-time

Preset Selection Guide

By Platform

By Use Case

By Texture Count

Best Practices

For Web Platforms

1. Use ORM packing - 3 textures instead of 6 2. JPEG for baseColor - 70-80% quality, 10× smaller 3. PNG for data maps - Normal, ORM require lossless 4. Start at 1024×1024 - Scale up only when needed 5. Test file sizes - Aim for <5MB total per asset

For Game Engines

1. Use engine-specific presets - Proper channel order/format 2. Match color space - sRGB for color, linear for data 3. Check normal format - DirectX vs. OpenGL (Y-flip) 4. Consider UDIM - For large characters (multiple tiles)

For glTF/GLB

1. Use "PBR Metallic Roughness" - Official standard 2. OpenGL normal maps - Y+ (green up) 3. Keep within spec - Avoid custom channels 4. Compress with Draco - gltf-pipeline for final export

Troubleshooting

Textures look washed out:

• BaseColor in wrong color space (should be sRGB)
• Check engine texture settings

Metallic looks rough / rough looks metallic:

• Channels swapped (check Green/Blue order)
• Verify MetallicRoughness packing: G=Roughness, B=Metallic

Normal map inverted:

• DirectX vs. OpenGL format
• Flip green channel in export or engine

Seams at UV borders:

• Use "paddingAlgorithm": "infinite" in export parameters
• Increase dilation distance

File sizes too large:

• Use JPEG for baseColor
• Reduce resolution (sizeLog2)
• Pack channels (ORM)
• Compress with external tools (pngquant, tinypng)

PBR Texture Channel Guide

Deep dive into Physically Based Rendering (PBR) texture channels, their purpose, authoring best practices, and technical specifications.

Table of Contents

• PBR Fundamentals
• Core Channels
• Additional Channels
• Channel Best Practices
• Common Material Types

PBR Fundamentals

What is PBR?

Physically Based Rendering (PBR) is a shading model that aims to accurately simulate how light interacts with surfaces in the real world. PBR workflows ensure materials look consistent under different lighting conditions.

Key principles: 1. Energy conservation - Reflected light never exceeds incoming light 2. Fresnel reflectance - Reflection intensity varies with viewing angle 3. Microsurface detail - Surface roughness affects light scattering

Metallic/Roughness vs. Specular/Glossiness

Substance 3D Painter uses the metallic/roughness workflow (also called metal/rough or met/rough).

Metallic/Roughness:

• baseColor = Albedo color for dielectrics, reflectance tint for metals
• metallic = 0 for non-metals, 1 for metals
• roughness = Surface roughness (0 = glossy, 1 = rough)

Advantages:

• Simpler (fewer maps)
• More physically accurate
• Industry standard (glTF, PBR games)

Alternative (Specular/Glossiness):

• diffuse = Albedo color
• specular = RGB specular reflectance
• glossiness = Surface smoothness (1 - roughness)

Note: Substance supports both, but metallic/roughness is recommended for web.

Core Channels

Base Color (Albedo)

What it is: The intrinsic color of the surface, without any lighting information.

Technical specs:

• Format: RGB, 8-bit per channel (24-bit total)
• Color space: sRGB (gamma ~2.2)
• Value range: 0-255 per channel
• File format: PNG or JPEG

Authoring guidelines:

For non-metals (dielectrics):

• Typical value range: sRGB 50-240 (linear 0.02-0.8)
• Dark materials: Charcoal ~50, Rubber ~60
• Mid-tone materials: Wood ~120, Leather ~100
• Light materials: Snow ~240, Paper ~200
• Never pure black (30 minimum for black materials)
• Never pure white (240 maximum for white materials)

For metals:

• Use actual metal reflectance values:
• Iron: sRGB(196, 198, 200)
• Gold: sRGB(255, 195, 86)
• Copper: sRGB(250, 155, 110)
• Aluminum: sRGB(245, 246, 246)
• Silver: sRGB(252, 250, 245)
• Bright, saturated colors for colored metals (gold, copper)

Common mistakes:

• ❌ Lighting baked in - Shadows or highlights in albedo
• ❌ Too dark - Black baseColor = no light reflection
• ❌ Too bright - Unrealistic energy conservation
• ❌ Specular details - Reflections should come from roughness, not albedo

Validation: Use the "no lighting" shader in Substance to check:

• Does the material look correct without lights?
• Are there any baked shadows or highlights?
• Are values within physically plausible ranges?

---

Normal Map

What it is: Encodes surface detail by perturbing surface normals, creating the illusion of depth without additional geometry.

Technical specs:

• Format: RGB, 8-bit per channel
• Color space: Linear (not sRGB!)
• Value range: 0-255 → maps to -1 to +1 normals
• File format: PNG (lossless required)
• Coordinate system: Tangent space

Normal format standards:

OpenGL (Y+) - Used by:

• glTF/GLB
• Three.js
• Babylon.js
• Substance 3D Painter (default export)
• WebGL/WebGPU

DirectX (Y-) - Used by:

• Unity
• Unreal Engine
• Direct3D engines

Visual difference:

• OpenGL: Green channel points "up" on the texture
• DirectX: Green channel points "down" (inverted Y)

Converting between formats:

• OpenGL → DirectX: Invert green channel (255 - G)
• DirectX → OpenGL: Invert green channel (255 - G)

Authoring guidelines:

Do:

• ✅ Bake high-poly details to normal map
• ✅ Use for micro-surface detail (scratches, dents, pores)
• ✅ Keep intensity realistic (don't over-exaggerate)
• ✅ Use 8-bit PNG (16-bit unnecessary for real-time)

Don't:

• ❌ Use JPEG (compression artifacts create shading errors)
• ❌ Apply to low-poly silhouettes (causes artifacts)
• ❌ Extreme details (creates aliasing/shimmering)

Validation:

• Flat surface = RGB(128, 128, 255) or #8080FF
• No black or white pixels (except extreme cases)
• Blue channel dominant (~255) for most pixels

---

Metallic

What it is: Defines whether a surface is metallic (conductor) or non-metallic (dielectric/insulator).

Technical specs:

• Format: Grayscale, 8-bit
• Color space: Linear
• Value range: 0-255 (0 = non-metal, 255 = metal)
• File format: PNG

Physical meaning:

• 0 (black) - Dielectric materials:
• Wood, plastic, fabric, skin, ceramic, stone
• Specular reflection ~4% (Fresnel F0 ≈ 0.04)
• BaseColor = diffuse color
• 255 (white) - Metallic materials:
• Iron, gold, copper, aluminum, silver, chrome
• Specular reflection ~60-100% (Fresnel F0 ≈ 0.6-1.0)
• BaseColor = specular tint (no diffuse)

Authoring guidelines:

Binary choice:

• Use only 0 or 255 (fully non-metal or fully metal)
• Avoid gray values (0-254) - not physically accurate
• Exception: Corroded/oxidized metals can have transition zones

Material examples:

• Metallic = 0: Wood, leather, cloth, rubber, plastic, glass, skin, concrete
• Metallic = 255: Iron, steel, aluminum, gold, silver, copper, brass, chrome

Common mistakes:

• ❌ Gradient metallic (0-255) - Not realistic
• ❌ Metallic = 255 with dark baseColor - Metals are reflective
• ❌ Metallic = 0 with bright baseColor + low roughness - Creates plastic look

Special cases:

Painted metal:

• Metallic = 0 (paint is dielectric)
• Only exposed metal areas = 255

Rusty metal:

• Clean metal = 255
• Rust (iron oxide) = 0 (rust is dielectric)

Validation:

• Histogram should show two spikes: at 0 and 255
• Very few pixels in 1-254 range

---

Roughness

What it is: Defines the microsurface roughness, controlling how light scatters when reflected.

Technical specs:

• Format: Grayscale, 8-bit
• Color space: Linear
• Value range: 0-255 (0 = smooth/glossy, 255 = rough/matte)
• File format: PNG

Physical meaning:

• 0 (black) - Mirror smooth:
• Perfect specular reflections
• Sharp, focused highlights
• Examples: Polished chrome, water, glass
• 255 (white) - Completely rough:
• Diffuse specular reflections
• Large, blurred highlights
• Examples: Concrete, fabric, unfinished wood

Authoring guidelines:

Typical value ranges:

• Mirror/chrome: 0-20
• Polished metal: 20-50
• Glossy plastic: 30-70
• Painted surfaces: 50-100
• Unfinished wood: 150-200
• Concrete/fabric: 200-255

Do:

• ✅ Use full range (0-255) across different materials
• ✅ Add variation (dirt, fingerprints, wear in crevices)
• ✅ Consider surface finish (polished vs. brushed vs. rough)

Don't:

• ❌ Uniform roughness across entire surface (boring, unrealistic)
• ❌ Pure white (255) for hard surfaces (leaves no specular)
• ❌ Pure black (0) for organic materials (too perfect)

Roughness variation examples:

Metal object:

• Base roughness: 40 (semi-polished)
• Scratches: 80 (exposed rough metal)
• Fingerprints: 30 (oil reduces roughness)
• Edges: 60 (worn from handling)

Wooden table:

• Base roughness: 100 (sanded wood)
• Glossy finish: 40 (varnish/polish)
• Worn areas: 150 (exposed grain)

Validation:

• Histogram should show variation (not single spike)
• Check for breakup in specular highlights (not uniform)
• Test under different lighting (rotating HDRI)

---

Additional Channels

Ambient Occlusion (AO)

What it is: Approximates how ambient light reaches each point on the surface. Darkens crevices and contact areas.

Technical specs:

• Format: Grayscale, 8-bit
• Color space: Linear
• Value range: 0-255 (0 = fully occluded, 255 = fully lit)
• File format: PNG

Purpose:

• Enhance depth perception
• Darken crevices, corners, contact points
• Fake indirect lighting occlusion

Authoring guidelines:

Do:

• ✅ Bake from high-poly mesh
• ✅ Subtle intensity (avoid pure black)
• ✅ Use for cavity detail (screws, seams, panel gaps)

Don't:

• ❌ Bake directional lighting (AO should be omnidirectional)
• ❌ Over-darken (reduces albedo contrast)

Web implementation:

Three.js:

material.aoMap = aoTexture;
material.aoMapIntensity = 1.0; // Adjust strength
geometry.attributes.uv2 = geometry.attributes.uv; // AO requires second UV channel

Note: Many engines require a second UV channel for AO. Consider baking AO into baseColor as an alternative for simpler setups.

---

Height (Displacement)

What it is: Grayscale map encoding surface height, used for displacement mapping or parallax effects.

Technical specs:

• Format: Grayscale, 8-16 bit
• Color space: Linear
• Value range: 0-255 (0 = low, 255 = high)
• File format: PNG

Use cases: 1. Displacement mapping - Actual geometry modification (not common in real-time) 2. Parallax occlusion mapping (POM) - Shader-based fake depth 3. Normal map generation - Convert height → normal in Substance

Authoring guidelines:

• Smooth gradients (avoid sharp steps)
• Sufficient contrast for visible effect
• Usually lower resolution than other maps (512-1024)

Web usage: Limited support in real-time engines. Height is usually converted to normal maps in Substance before export.

---

Emissive (Self-Illumination)

What it is: RGB map defining areas that emit light (glow).

Technical specs:

• Format: RGB, 8-bit or 16-bit
• Color space: Linear (for HDR) or sRGB (for LDR)
• Value range: 0-255 (8-bit) or 0-65535 (16-bit)
• File format: PNG or EXR

Use cases:

• Glowing screens, LEDs, neon signs
• Bioluminescence
• Hot metal/lava
• Energy effects

Authoring guidelines:

LDR emissive (8-bit):

• Black (0,0,0) = no emission
• White (255,255,255) = full brightness
• Use emissiveIntensity in engine to control brightness

HDR emissive (16/32-bit EXR):

• Values can exceed 1.0 for bloom effects
• Physically accurate for bright lights

Web implementation:

Three.js:

material.emissive = new THREE.Color(0xffffff);
material.emissiveMap = emissiveTexture;
material.emissiveIntensity = 2.0; // Boost for bloom

Common mistake: ❌ Using emissive for ambient occlusion (emissive should glow, not darken)

---

Opacity (Alpha)

What it is: Grayscale map controlling surface transparency.

Technical specs:

• Format: Grayscale, 8-bit
• Color space: Linear
• Value range: 0-255 (0 = transparent, 255 = opaque)
• File format: PNG (with alpha channel support)

Use cases:

• Glass, water, smoke
• Vegetation (leaves, grass)
• Decals, stickers
• Fading effects

Authoring guidelines:

Binary alpha (cutout):

• Use only 0 or 255 (fully transparent or opaque)
• Efficient for vegetation (no alpha blending)
• Set alphaTest threshold in engine

Gradient alpha (blended):

• Full 0-255 range for smooth transparency
• More expensive (requires alpha blending, sorting)

Web implementation:

Three.js:

material.transparent = true;
material.alphaMap = opacityTexture;
material.alphaTest = 0.5; // For binary alpha (cutout)
material.opacity = 1.0; // Overall opacity multiplier

Performance notes:

• Alpha blending is expensive (disable backface culling, requires sorting)
• Use alphaTest (cutout) instead of transparent when possible

Channel Best Practices

Color Space Management

sRGB (Gamma ~2.2):

• BaseColor
• Emissive (8-bit)

Linear (No Gamma):

• Normal
• Metallic
• Roughness
• AO
• Height
• Opacity

Why it matters: Incorrect color space causes incorrect lighting calculations. Always ensure:

• BaseColor textures have sRGB flag in engine
• Data textures (normal, roughness, etc.) use linear

Three.js example:

baseColorTexture.colorSpace = THREE.SRGBColorSpace; // ✅ Correct
normalTexture.colorSpace = THREE.NoColorSpace;     // ✅ Correct (linear)

---

Resolution Guidelines

By channel importance:

Highest detail (1024-2048):

• BaseColor (most visible)
• Normal (defines micro-detail)

Medium detail (512-1024):

• Roughness (specular breakup)
• Metallic (usually binary, less detail)

Lower detail (512-1024):

• AO (subtle effect)
• Emissive (often solid colors)

Lowest detail (256-512):

• Height (usually converted to normal)

Web optimization: All channels can share the same resolution (1024×1024) for simplicity, but consider per-channel resizing for advanced optimization.

---

File Format Selection

---

Texture Streaming & LOD

Mipmaps: Always generate mipmaps for all textures. Engines generate automatically, but you can bake custom mipmaps in Substance for specific filtering.

LOD strategy: Export multiple resolution sets:

• LOD0 (close-up): 2048×2048
• LOD1 (medium): 1024×1024
• LOD2 (distant): 512×512

Implementation (Three.js):

const lod = new THREE.LOD();
lod.addLevel(mesh_high_res, 0);    // 0-10 units
lod.addLevel(mesh_med_res, 10);    // 10-30 units
lod.addLevel(mesh_low_res, 30);    // 30+ units

Common Material Types

Plastic

BaseColor:

• Saturated colors (RGB 180, 60, 40 for red plastic)
• Consistent across surface

Metallic: 0 (non-metal)

Roughness:

• Glossy plastic: 30-50
• Matte plastic: 150-200

Example (Three.js):

material.color = new THREE.Color(0xb43c28); // Orange plastic
material.metalness = 0.0;
material.roughness = 0.3; // Glossy

---

Brushed Metal

BaseColor:

• Metal reflectance value (e.g., Aluminum: #F5F6F6)

Metallic: 255 (full metal)

Roughness:

• Directional variation (brush lines)
• 40-80 depending on finish

Special: Add anisotropic roughness for realistic brushed look (advanced shaders)

---

Wood

BaseColor:

• Natural wood colors (browns, tans)
• Wood grain texture
• RGB 90-150 range

Metallic: 0 (non-metal)

Roughness:

• Unfinished: 150-200
• Varnished: 40-80
• Add variation (grain roughness differs)

AO: Cavity detail in grain

---

Glass

BaseColor:

• Slight tint (RGB 245, 245, 245 for clear)

Metallic: 0

Roughness:

• Clean glass: 0-10
• Frosted glass: 100-200

Opacity: 20-50 (mostly transparent)

Special: Use refraction in engine (transmission in Three.js)

---

Fabric

BaseColor:

• Fabric color with weave detail
• Medium values (RGB 80-180)

Metallic: 0

Roughness: 180-220 (very rough)

Normal: Weave/fiber details

Special: Consider subsurface scattering for translucent fabrics

---

Rusty Metal

BaseColor:

• Clean metal: Metal reflectance
• Rust: Orange-brown (RGB 150, 80, 40)
• Use mask to blend

Metallic:

• Clean metal: 255
• Rust (iron oxide): 0
• Use same mask as baseColor

Roughness:

• Clean metal: 30-50
• Rust: 180-220

Example mask-based blend:

# In Substance, use rust mask to drive:
# - BaseColor: Metal color → Rust color
# - Metallic: 255 → 0
# - Roughness: 40 → 200

Validation Checklist

Before exporting, verify:

BaseColor:

• [ ] No baked lighting/shadows
• [ ] Values within plausible range (30-240 for most materials)
• [ ] Metals use actual metal reflectance colors

Normal:

• [ ] Correct format (OpenGL vs. DirectX)
• [ ] No compression artifacts (PNG only)
• [ ] Blue channel dominant

Metallic:

• [ ] Binary values (0 or 255 only)
• [ ] Matches material type (0 for dielectrics)

Roughness:

• [ ] Has surface variation (not uniform)
• [ ] Within realistic range for material

All Maps:

• [ ] Correct color space (sRGB vs. linear)
• [ ] Appropriate resolution (not oversized)
• [ ] Proper file format (lossless for data, JPEG for color)
• [ ] Padding set to "infinite" (no seams)

Resources

• PBR Guide: https://academy.substance3d.com/courses/the-pbr-guide-part-1
• Material Values: https://docs.unrealengine.com/en-US/Resources/ContentExamples/MaterialProperties/
• Texture Naming: glTF 2.0 specification

Substance 3D Painter Python API Reference

Complete reference for automating Substance 3D Painter workflows with Python.

API Overview

The Substance 3D Painter Python API provides programmatic access to:

• Export System - Texture export configuration and execution
• Project Management - Open, save, close projects
• Texture Sets - Access and modify texture sets
• Resource Management - Access materials, brushes, presets
• Event System - React to application events
• UI System - Add custom menu items and dialogs

Core Modules

substance_painter.export

Texture export functionality.

Functions

export_project_textures(json_config: dict) → ExportResult

Exports project textures according to JSON configuration.

Parameters:

• json_config (dict) - Export configuration object

Returns:

• ExportResult with status, message, and list of exported files

Raises:

• ProjectError - No project is open
• ValueError - Invalid configuration

Example:

import substance_painter.export

config = {
    "exportPath": "C:/export",
    "defaultExportPreset": "starter_assets://PBR Metallic Roughness",
    "exportList": [{"rootPath": "TextureSetName"}],
    "exportParameters": [{
        "parameters": {
            "fileFormat": "png",
            "bitDepth": "8",
            "sizeLog2": 10
        }
    }]
}

result = substance_painter.export.export_project_textures(config)

if result.status == substance_painter.export.ExportStatus.Success:
    print(f"Exported {len(result.textures)} texture sets")

---

list_project_textures(json_config: dict) → Dict[Tuple[str, str], List[str]]

Lists textures that would be exported without actually exporting.

Parameters:

• json_config (dict) - Export configuration

Returns:

• Dictionary mapping (texture_set, stack) to list of file paths

Example:

texture_list = substance_painter.export.list_project_textures(config)

for stack, files in texture_list.items():
    print(f"Stack {stack}:")
    for file in files:
        print(f"  - {file}")

Classes

ExportStatus (Enum)

Export operation status codes:

• Success - Export completed successfully
• Error - Export failed

ExportResult

Result object returned by export_project_textures().

Attributes:

• status (ExportStatus) - Status code
• message (str) - Human-readable status message
• textures (Dict[Tuple[str, str], List[str]]) - Exported files grouped by stack

Events

ExportTexturesAboutToStart

Triggered before export begins.

Attributes:

• textures (Dict[Tuple[str, str], List[str]]) - Files to be exported

Example:

import substance_painter.event

def on_export_start(event):
    print(f"Exporting {len(event.textures)} texture sets")

substance_painter.event.DISPATCHER.connect(
    substance_painter.event.ExportTexturesAboutToStart,
    on_export_start
)

ExportTexturesEnded

Triggered after export completes.

Attributes:

• status (ExportStatus) - Export status
• message (str) - Status message
• textures (Dict[Tuple[str, str], List[str]]) - Exported files

substance_painter.project

Project management operations.

Functions

is_open() → bool

Check if a project is currently open.

Example:

if substance_painter.project.is_open():
    print("Project is open")

---

open(file_path: str) → None

Open an existing Substance project (.spp).

Parameters:

• file_path (str) - Absolute path to .spp file

Example:

substance_painter.project.open("C:/projects/MyProject.spp")

---

save() → None

Save the current project.

---

save_as(file_path: str) → None

Save project to a new file path.

---

close() → None

Close the current project.

---

file_path() → str

Get the current project's file path.

Returns:

• Absolute path to .spp file, or empty string if no project open

Example:

project_path = substance_painter.project.file_path()
export_path = project_path.replace('.spp', '_textures')

---

name() → str

Get the current project's name (filename without extension).

Events

ProjectOpened

Triggered when a project is opened.

ProjectAboutToClose

Triggered before project closes.

ProjectAboutToSave

Triggered before project saves.

ProjectSaved

Triggered after project saves.

Example: Auto-export on save

import substance_painter.event
import substance_painter.project
import substance_painter.export

def auto_export(event):
    if not substance_painter.project.is_open():
        return

    # Export textures when project saves
    config = {
        "exportPath": substance_painter.project.file_path().replace('.spp', '_export'),
        # ... rest of config
    }
    substance_painter.export.export_project_textures(config)

substance_painter.event.DISPATCHER.connect(
    substance_painter.event.ProjectSaved,
    auto_export
)

substance_painter.textureset

Access texture sets and UV tiles.

Functions

all_texture_sets() → List[TextureSet]

Get all texture sets in the project.

Returns:

• List of TextureSet objects

Example:

import substance_painter.textureset

for ts in substance_painter.textureset.all_texture_sets():
    print(f"Texture Set: {ts.name()}")
    print(f"  Layered: {ts.is_layered_material()}")
    print(f"  Resolution: {ts.get_resolution()}")

---

all_uv_tiles() → List[UVTile]

Get all UV tiles in the project (for UDIM workflows).

Returns:

• List of UVTile objects

Example:

for tile in substance_painter.textureset.all_uv_tiles():
    print(f"Tile ({tile.u}, {tile.v}): {tile.get_resolution()}")

---

set_uvtiles_resolution(resolutions: Dict[UVTile, Resolution]) → None

Set resolution for multiple UV tiles.

Parameters:

• resolutions (dict) - Mapping of UVTile to Resolution

Example:

from substance_painter.textureset import Resolution

# Set all tiles in first row to 2K
row0 = [tile for tile in all_uv_tiles() if tile.v == 0]
resolution_2k = Resolution(2048, 2048)
substance_painter.textureset.set_uvtiles_resolution({
    tile: resolution_2k for tile in row0
})

Classes

TextureSet

Represents a texture set (material slot).

Methods:

• name() → str - Get texture set name
• is_layered_material() → bool - Check if uses layer stacks
• get_resolution() → Resolution - Get texture resolution
• get_stack() → Stack - Get layer stack (if layered)

Stack

Represents a layer stack in a texture set.

Methods:

• material() → TextureSet - Get parent texture set
• get_channel(channel_type: ChannelType) → Channel - Get specific channel

Channel

Represents a texture channel (baseColor, normal, etc.).

Methods:

• is_color() → bool - Check if channel contains color data

ChannelType (Enum)

Available texture channels:

• BaseColor
• Normal
• Metallic
• Roughness
• Height
• Opacity
• Emissive
• AmbientOcclusion

Resolution

Texture resolution container.

Attributes:

• width (int) - Width in pixels
• height (int) - Height in pixels

Constructor:

from substance_painter.textureset import Resolution

res = Resolution(2048, 2048)  # 2K

UVTile

Represents a UV tile in UDIM workflow.

Attributes:

• u (int) - U coordinate (0-based)
• v (int) - V coordinate (0-based)

Methods:

• get_resolution() → Resolution - Get tile resolution
• set_resolution(resolution: Resolution) → None - Set tile resolution

substance_painter.resource

Access and manage resources (materials, brushes, presets).

Classes

ResourceID

Identifier for a resource.

Constructor:

resource = substance_painter.resource.ResourceID(
    context="starter_assets",  # Library name
    name="PBR Metallic Roughness"  # Resource name
)

Methods:

• url() → str - Get resource URL (e.g., "starter_assets://PBR Metallic Roughness")

Example: Use export preset

export_preset = substance_painter.resource.ResourceID(
    context="starter_assets",
    name="Unity HDRP (Lit)"
)

config = {
    "defaultExportPreset": export_preset.url(),
    # ...
}

substance_painter.ui

UI customization and menu integration.

Enums

ApplicationMenu

Available application menus:

• File
• Edit
• Mode
• View
• Viewport
• Shader
• Window
• Help

Functions

add_action(menu: ApplicationMenu, action: QtWidgets.QAction) → None

Add menu item to application menu.

Parameters:

• menu (ApplicationMenu) - Target menu
• action (QAction) - Qt action to add

Example:

from PySide2 import QtWidgets
import substance_painter.ui

def my_function():
    print("Menu item clicked!")

action = QtWidgets.QAction("My Custom Command", triggered=my_function)
substance_painter.ui.add_action(substance_painter.ui.ApplicationMenu.File, action)

---

delete_ui_element(element) → None

Remove UI element (cleanup when plugin closes).

---

get_main_window() → QtWidgets.QMainWindow

Get main application window (for parenting dialogs).

Example: File dialog

from PySide2 import QtWidgets

export_path = QtWidgets.QFileDialog.getExistingDirectory(
    substance_painter.ui.get_main_window(),
    "Choose export directory"
)

substance_painter.event

Event system for reacting to application events.

Event Dispatcher

DISPATCHER

Global event dispatcher object.

Methods:

• connect(event_type, callback) - Register event handler
• disconnect(event_type, callback) - Unregister event handler

Example:

import substance_painter.event

def on_project_opened(event):
    print("Project opened!")

substance_painter.event.DISPATCHER.connect(
    substance_painter.event.ProjectOpened,
    on_project_opened
)

Available Events

Project Events:

• ProjectOpened
• ProjectAboutToClose
• ProjectAboutToSave
• ProjectSaved

Export Events:

• ExportTexturesAboutToStart
• ExportTexturesEnded

Shader Events:

• ShaderAdded
• ShaderRemoved

Texture Set Events:

• TextureSetAdded
• TextureSetRemoved

Export Configuration Schema

Complete JSON schema for export_project_textures() config parameter.

Root Configuration Object

{
    "exportPath": str,              # Required: Output directory path
    "exportShaderParams": bool,     # Optional: Export shader params to JSON (default: false)
    "defaultExportPreset": str,     # Optional: Default preset URL
    "exportPresets": list,          # Optional: Custom export presets
    "exportList": list,             # Required: Texture sets to export
    "exportParameters": list        # Optional: Export parameter overrides
}

Export List Item

{
    "rootPath": str,                # Required: Texture set name (or "TextureSet/Stack" for layered)
    "exportPreset": str,            # Optional: Override preset for this item
    "filter": {                     # Optional: Filter which maps/tiles to export
        "outputMaps": list,         # List of map names (e.g., ["$textureSet_baseColor"])
        "uvTiles": list             # List of [u, v] tile coordinates (e.g., [[1,1], [1,2]])
    }
}

Export Parameters Item

{
    "filter": {                     # Optional: Match specific files
        "dataPaths": list,          # Texture set/stack names
        "outputMaps": list,         # Map name patterns
        "uvTiles": list             # UV tile coordinates
    },
    "parameters": {                 # Optional: Override export settings
        "fileFormat": str,          # "png", "jpeg", "tga", "exr", etc.
        "bitDepth": str,            # "8", "16", "32"
        "dithering": bool,          # Enable dithering
        "sizeLog2": int,            # Texture size: 9=512, 10=1024, 11=2048, 12=4096
        "paddingAlgorithm": str,    # "passthrough", "color", "transparent", "diffusion", "infinite"
        "dilationDistance": int     # Padding distance in pixels (required for some padding modes)
    }
}

Custom Export Preset

{
    "name": str,                    # Preset name
    "maps": [                       # List of texture maps to export
        {
            "fileName": str,        # Output filename pattern (e.g., "$textureSet_baseColor")
            "channels": [           # Channel mapping
                {
                    "destChannel": str,      # "R", "G", "B", "A"
                    "srcChannel": str,       # "R", "G", "B", "A"
                    "srcMapType": str,       # "documentMap"
                    "srcMapName": str        # "baseColor", "normal", "metallic", etc.
                }
            ],
            "parameters": {         # Optional: Per-map export parameters
                "fileFormat": str,
                "bitDepth": str,
                "sizeLog2": int
            }
        }
    ]
}

Filename Patterns

Variables available in fileName patterns:

• $textureSet - Texture set name
• $project - Project name
• $mesh - Mesh name
• $udim - UDIM tile number (e.g., 1001)

Examples:

• $textureSet_baseColor → "MyAsset_baseColor.png"
• $project_$textureSet_color → "MyProject_MyAsset_color.png"

Complete Examples

Example 1: Basic Batch Export

Export all texture sets with standard settings:

import substance_painter.export
import substance_painter.resource
import substance_painter.textureset

# Define preset
preset = substance_painter.resource.ResourceID(
    context="starter_assets",
    name="PBR Metallic Roughness"
)

# Build config
config = {
    "exportPath": "C:/export",
    "defaultExportPreset": preset.url(),
    "exportList": [
        {"rootPath": ts.name()}
        for ts in substance_painter.textureset.all_texture_sets()
    ],
    "exportParameters": [{
        "parameters": {
            "fileFormat": "png",
            "bitDepth": "8",
            "sizeLog2": 10,
            "paddingAlgorithm": "infinite"
        }
    }]
}

# Export
result = substance_painter.export.export_project_textures(config)
print(f"Status: {result.status}")

Example 2: Selective Export with Filters

Export only baseColor at high resolution, other maps at lower resolution:

config = {
    "exportPath": "C:/export",
    "defaultExportPreset": preset.url(),
    "exportList": [{"rootPath": "CharacterBody"}],
    "exportParameters": [
        {
            "filter": {"outputMaps": ["$textureSet_baseColor"]},
            "parameters": {"sizeLog2": 12}  # 4096 for baseColor
        },
        {
            "filter": {"outputMaps": ["$textureSet_normal", "$textureSet_metallicRoughness"]},
            "parameters": {"sizeLog2": 11}  # 2048 for other maps
        }
    ]
}

Example 3: Custom Preset with Channel Packing

Create ORM (Occlusion-Roughness-Metallic) packed texture:

custom_preset = {
    "exportPresets": [{
        "name": "WebGL_ORM",
        "maps": [
            {
                "fileName": "$textureSet_baseColor",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "baseColor"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "baseColor"}
                ]
            },
            {
                "fileName": "$textureSet_normal",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "normal"},
                    {"destChannel": "G", "srcChannel": "G", "srcMapType": "documentMap", "srcMapName": "normal"},
                    {"destChannel": "B", "srcChannel": "B", "srcMapType": "documentMap", "srcMapName": "normal"}
                ]
            },
            {
                "fileName": "$textureSet_ORM",
                "channels": [
                    {"destChannel": "R", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "ambientOcclusion"},
                    {"destChannel": "G", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "roughness"},
                    {"destChannel": "B", "srcChannel": "R", "srcMapType": "documentMap", "srcMapName": "metallic"}
                ]
            }
        ]
    }]
}

config = {
    "exportPath": "C:/export",
    "exportPresets": custom_preset["exportPresets"],
    "exportList": [{"rootPath": "MyAsset", "exportPreset": "WebGL_ORM"}],
    "exportParameters": [{
        "parameters": {"fileFormat": "png", "bitDepth": "8", "sizeLog2": 10}
    }]
}

Example 4: UDIM Export

Export specific UV tiles with different resolutions:

from substance_painter.textureset import Resolution

# Set tile 1001 to 4K, others to 2K
tile_1001 = next((t for t in all_uv_tiles() if t.u == 0 and t.v == 0), None)
if tile_1001:
    tile_1001.set_resolution(Resolution(4096, 4096))

config = {
    "exportPath": "C:/export",
    "defaultExportPreset": preset.url(),
    "exportList": [
        {
            "rootPath": "UDIMAsset",
            "filter": {"uvTiles": [[0, 0], [1, 0], [2, 0]]}  # Export first row
        }
    ]
}

Plugin Development

Creating a Plugin

Directory structure:

plugins/
└── my_plugin/
    ├── __init__.py
    └── plugin.py

plugin.py:

import substance_painter.ui
from PySide2 import QtWidgets

plugin_widgets = []

def my_command():
    print("Plugin command executed!")

def start_plugin():
    """Called when plugin loads"""
    action = QtWidgets.QAction("My Command", triggered=my_command)
    substance_painter.ui.add_action(substance_painter.ui.ApplicationMenu.File, action)
    plugin_widgets.append(action)

def close_plugin():
    """Called when plugin unloads"""
    for widget in plugin_widgets:
        substance_painter.ui.delete_ui_element(widget)
    plugin_widgets.clear()

if __name__ == "__main__":
    start_plugin()

Plugin Best Practices

1. Store UI elements in module-level list for cleanup 2. Check project state before operations:

   if not substance_painter.project.is_open():
       return

3. Handle errors gracefully:

   try:
       result = substance_painter.export.export_project_textures(config)
   except ValueError as e:
       print(f"Export failed: {e}")

4. Use absolute paths for file operations 5. Clean up resources in close_plugin()

Troubleshooting

Common Issues

Import Error: No module named 'substance_painter'

• API only available when running inside Substance 3D Painter
• Use File → Scripts → Run Script to execute Python code

ProjectError: No project is open

• Check substance_painter.project.is_open() before API calls

ValueError: Invalid export configuration

• Verify all required fields in export config
• Check exportPath exists and is writable
• Ensure exportList is not empty

ResourceID not found

• Verify context (library name) is correct
• Check resource name matches exactly (case-sensitive)
• Use Substance UI to find resource names

Debugging Tips

Print configuration:

import json
print(json.dumps(config, indent=2))

List available texture sets:

for ts in substance_painter.textureset.all_texture_sets():
    print(f"Texture Set: {ts.name()}")

Preview export list without exporting:

preview = substance_painter.export.list_project_textures(config)
for stack, files in preview.items():
    print(f"{stack}: {files}")

Resources

• Official Python API Docs: https://helpx.adobe.com/substance-3d-painter-python/api/
• Substance 3D Community: https://community.adobe.com/t5/substance-3d-painter/ct-p/ct-substance-3d-painter
• Python Plugin Examples: Included in Substance installation under python/examples/