# Complete LAMA Materials Guide for Houdini Solaris & RenderMan ## Table of Contents - [Introduction to LAMA](#introduction-to-lama) - [LAMA vs PxrSurface](#lama-vs-pxrsurface) - [Essential LAMA Nodes](#essential-lama-nodes) - [Setting Up Your First LAMA Material](#setting-up-your-first-lama-material) - [Core LAMA Nodes Explained](#core-lama-nodes-explained) - [Material Layering Techniques](#material-layering-techniques) - [Advanced LAMA Workflows](#advanced-lama-workflows) - [Glass Materials with LAMA](#glass-materials-with-lama) - [Subsurface Scattering in LAMA](#subsurface-scattering-in-lama) - [LAMA Optimization Techniques](#lama-optimization-techniques) - [LPE (Light Path Expressions) for LAMA](#lpe-light-path-expressions-for-lama) - [LAMA Limitations and Workarounds](#lama-limitations-and-workarounds) - [Production Tips and Best Practices](#production-tips-and-best-practices) --- ## Introduction to LAMA ### What is LAMA? **LAMA (Layered Materials)** is a state-of-the-art material layering system developed by Industrial Light & Magic (ILM) for RenderMan[315][324][332]. It's been production-proven on major films including: - Solo: A Star Wars Story (first implementation) - The Rise of Skywalker - Terminator: Dark Fate - The Irishman - Jurassic World Dominion ### Key Benefits of LAMA 1. **Modular Approach**: Each lobe (diffuse, specular, etc.) is a separate node[315][324] 2. **Flexibility**: Build only what you need - no unused parameters[315][324] 3. **Energy Conservation**: Perfect energy conservation with fast multiple scattering[348] 4. **Performance**: Only compute what's necessary for your material[315] 5. **MaterialX Standard**: Future-proof, cross-DCC compatibility[321][332] --- ## LAMA vs PxrSurface ### Traditional Approach (PxrSurface) ``` Single Node = All Parameters ├── Diffuse (unused? still computed) ├── Specular (unused? still computed) ├── Subsurface (unused? still computed) ├── Glass (unused? still computed) └── All other lobes (computed regardless) ``` ### LAMA Approach ``` Modular System = Build What You Need ├── LamaDiffuse (only when needed) ├── LamaDielectric (only when needed) ├── LamaConductor (only when needed) ├── LamaSSS (only when needed) └── Custom combinations via layering ``` ### Performance Comparison - **PxrSurface**: Computes all lobes even if unused - **LAMA**: Only computes connected nodes, saving render time[315][324] --- ## Essential LAMA Nodes ### Core Surface Node - **LamaSurface**: The main "brain" that controls all other LAMA nodes[325][348] ### Primary BSDF Nodes - **LamaDiffuse**: Diffuse scattering (matte surfaces)[349][362] - **LamaConductor**: Metallic surfaces[351][356] - **LamaDielectric**: Glass, liquids, and specular layers[354] - **LamaSSS**: Subsurface scattering[319] - **LamaTranslucent**: Thin translucent materials - **LamaHair**: Hair and fur shading (Chang model) - **LamaFuzz**: Cloth and fabric surfaces - **LamaEmission**: Light-emitting surfaces ### Layering Nodes - **LamaLayer**: Vertical layering (layer on top of base)[317][348] - **LamaMix**: Horizontal blending (mix two materials)[317][348] --- ## Setting Up Your First LAMA Material ### 1. Create the Basic Setup in Solaris ```python # Node Network Structure: Material Library LOP └── Material Builder (RenderMan) ├── LamaSurface (output) ├── LamaDiffuse └── Connect: LamaDiffuse.out_color → LamaSurface.material_front ``` ### 2. Enable Required Features In **LamaSurface** node, enable what you need: ```yaml Number of Sides: 1 (for single-sided materials) Compute Interior: Enable if using glass/transmission Compute Subsurface: Enable if using LamaSSS Compute Opacity: Enable for transparent materials Two-Sided: Enable for double-sided shading ``` ### 3. Basic Diffuse Material ```python # Simple plastic material: LamaDiffuse → LamaSurface.material_front ``` **LamaDiffuse Parameters:** - **Color**: Diffuse albedo (connect PxrTexture here) - **Roughness**: Surface microsurface roughness (0.0 = smooth) - **Normal**: Connect PxrBump or PxrNormalMap - **Shadow Color**: Artistic control over shadow tinting --- ## Core LAMA Nodes Explained ### LamaDiffuse [349][362] **Purpose**: Creates matte, non-reflective surfaces ```yaml Key Parameters: Color: [0.8, 0.8, 0.8] # Base diffuse color Roughness: 0.0 # Microsurface roughness Normal: [0.0, 0.0, 0.0] # Normal mapping input Shadow Color: [1.0, 1.0, 1.0] # Shadow tinting control Advanced: Energy Compensation: 1.0 # Leave at 1.0 for energy conservation Shadow Terminator Fix: On # Reduces shadow terminator artifacts LPE Lobe Name: "diffuse" # Custom AOV naming ``` **Use Cases**: Paper, concrete, fabric base, skin base layer ### LamaConductor [351][356] **Purpose**: Metallic surfaces with complex fresnel behavior ```yaml Fresnel Mode: "artistic" or "scientific" # Artistic Mode (Recommended for artists): Reflectivity: [0.95, 0.64, 0.54] # Face color (copper example) Edge Color: [0.98, 0.82, 0.76] # Edge color (brighter) Tint: [1.0, 1.0, 1.0] # Overall color tint # Scientific Mode (Physically accurate): IOR: [0.27, 0.67, 1.32] # Index of refraction Extinction: [3.61, 2.63, 2.29] # Extinction coefficient Common Settings: Roughness: [0.1, 0.1] # [U, V] roughness Anisotropy: 0.0 # Anisotropic highlights ``` **Real-World Metal Values** (Scientific Mode): ```yaml Gold: IOR: [0.47, 0.37, 1.44], Extinction: [2.13, 1.46, 1.79] Silver: IOR: [2.93, 3.12, 2.14], Extinction: [3.58, 3.21, 2.22] Copper: IOR: [0.27, 0.67, 1.32], Extinction: [3.61, 2.63, 2.29] Iron: IOR: [1.51, 1.45, 1.24], Extinction: [1.71, 1.92, 1.77] ``` ### LamaDielectric [354] **Purpose**: Glass, liquids, and transparent/specular layers ```yaml # Glass Configuration: Fresnel Mode: "scientific" IOR: 1.5 # Glass IOR Roughness: [0.0, 0.0] # Smooth glass Transmission Color: [1.0, 1.0, 1.0] # Clear glass Absorption: [0.0, 0.0, 0.0] # No absorption # Specular Layer Configuration: Reflectivity: 0.04 # 4% reflection (plastic) Roughness: [0.2, 0.2] # Slight roughness ``` **Common IOR Values**: ```yaml Air: 1.0 Water: 1.33 Glass: 1.5-1.9 Diamond: 2.42 Ice: 1.31 ``` ### LamaSSS [319] **Purpose**: Subsurface scattering for skin, wax, marble ```yaml Essential Parameters: Color: [0.8, 0.4, 0.3] # Subsurface color Scale: 1.0 # Overall SSS scale Radius: [4.0, 2.0, 1.0] # RGB scattering radii Anisotropy: 0.0 # Forward/backward scattering Bleed: 0.0 # Preserve surface details SSS Modes: Diffusion: "jensen_dipole" # Production standard Mode: "diffusion" # vs "path_traced_exponential" ``` **Important**: Must enable `Compute Subsurface` in LamaSurface[319][386] --- ## Material Layering Techniques ### LamaLayer (Vertical Layering) [317][348][358] **Concept**: Places one material **on top** of another ```python # Plastic with specular layer: Base Material (LamaDiffuse) → LamaLayer.material_base Top Material (LamaDielectric) → LamaLayer.material_top LamaLayer.out_color → LamaSurface.material_front ``` **Layer Types**: - **Opaque Layer**: Completely covers base material - **Transparent Layer**: Allows base to show through - **Volumetric Layer**: Computes absorption through thickness ### LamaMix (Horizontal Mixing) [317][348] **Concept**: Blends two materials **side by side** ```python # Metal and plastic regions: Material 1 (Metal) → LamaMix.material_1 Material 2 (Plastic) → LamaMix.material_2 Mask Texture → LamaMix.mix LamaMix.out_color → LamaSurface.material_front ``` **Mix Modes**: - **Normalized**: Energy conserving blend - **Additive**: Non-physical but creative control --- ## Advanced LAMA Workflows ### Complex Car Paint Material [354][359] ```python # Layer Structure (bottom to top): 1. Metal Base (LamaConductor) 2. Colored Paint (LamaDiffuse) 3. Clear Coat (LamaDielectric) 4. Dust/Dirt Layer (LamaDiffuse) # Implementation: Metal Base → LamaLayer.material_base Paint Layer → LamaLayer.material_top ↓ Clear Coat Base → LamaLayer.material_base Clear Coat → LamaLayer.material_top ↓ Clean Paint → LamaMix.material_1 Dirt Layer → LamaMix.material_2 Dirt Mask → LamaMix.mix ``` ### Skin Material [361] ```python # Multi-layer skin approach: Deep SSS (LamaSSS) → LamaLayer.material_base Shallow SSS (LamaSSS) → LamaLayer.material_top ↓ Combined SSS → LamaLayer.material_base Specular Layer (LamaDielectric) → LamaLayer.material_top ``` **Skin SSS Parameters**: ```yaml Deep Layer: Color: [0.7, 0.3, 0.2] Radius: [8.0, 4.0, 2.0] Shallow Layer: Color: [0.9, 0.6, 0.5] Radius: [2.0, 1.0, 0.5] ``` ### Worn Metal Material [354] ```python # Weathered metal with paint chips: Clean Metal (LamaConductor) → LamaMix.material_2 Painted Metal → LamaMix.material_1 where Painted Metal = Metal Base + Paint Layer Wear Mask → LamaMix.mix ``` --- ## Glass Materials with LAMA ### Basic Glass Setup ```python # Simple clear glass: LamaDielectric → LamaSurface.material_front # Enable in LamaSurface: Compute Interior: On Compute Opacity: On ``` ### Advanced Glass Types #### Colored Glass ```yaml LamaDielectric Parameters: IOR: 1.5 Transmission Color: [0.8, 0.9, 1.0] # Blue tint Absorption: [0.1, 0.05, 0.0] # Absorb red/green ``` #### Frosted Glass ```yaml LamaDielectric Parameters: IOR: 1.5 Roughness: [0.3, 0.3] # Surface roughness Normal: connect PxrBump # Micro-surface detail ``` #### Layered Glass (Car Windshield) ```python # Structure: Glass Base (LamaDielectric) → LamaLayer.material_base Coating (LamaDielectric) → LamaLayer.material_top ``` ### Glass Optimization Tips 1. **Disable unnecessary caustics**: Set Allow Caustics = 0 in render settings 2. **Ray depth management**: Ensure sufficient Max Specular Depth (minimum 6 for glass) 3. **Interior medium**: Use Compute Interior for colored glass absorption --- ## Subsurface Scattering in LAMA ### Types of SSS Nodes #### LamaSSS [319] - **Primary SSS node** with full control - **Best for**: Skin, marble, wax, translucent materials #### LamaTriColor - **Simplified SSS** with three color channels - **Best for**: Quick setups, less control needed ### SSS Configuration Workflow 1. **Enable in LamaSurface**: ```yaml Compute Subsurface: On ``` 2. **Choose SSS Mode**: ```yaml # Production Standard: Mode: "diffusion" Diffusion: "jensen_dipole" # Physically Accurate: Mode: "path_traced_exponential" ``` 3. **Tune Parameters**: ```yaml Color: [0.8, 0.4, 0.2] # Subsurface color Scale: 1.0 # Overall SSS amount Radius: [6.0, 3.0, 1.5] # RGB penetration depth Anisotropy: 0.0 # Forward scattering Bleed: 0.5 # Detail preservation ``` ### Material-Specific SSS Settings #### Human Skin ```yaml Caucasian Skin: Color: [0.78, 0.55, 0.45] Radius: [4.82, 3.62, 2.52] Asian Skin: Color: [0.83, 0.63, 0.51] Radius: [4.12, 3.15, 2.29] Dark Skin: Color: [0.60, 0.44, 0.37] Radius: [3.67, 2.80, 2.12] ``` #### Other Materials ```yaml Marble: Color: [0.95, 0.95, 0.92] Radius: [8.0, 8.0, 8.0] Candle Wax: Color: [0.95, 0.88, 0.70] Radius: [12.0, 8.0, 4.0] ``` --- ## LAMA Optimization Techniques ### Render Performance Tips [173][392] #### 1. Node-Level Optimization ```python # Only use what you need: ✓ LamaDiffuse + LamaDielectric (plastic) ✗ Full PxrSurface (computes unused lobes) # Savings: 20-40% render time reduction ``` #### 2. LamaSurface Optimization ```yaml # Disable unused features: Compute Interior: Off # Unless using glass/transmission Compute Subsurface: Off # Unless using SSS Compute Opacity: Off # Unless using transparency Two-Sided: Off # Unless actually double-sided ``` #### 3. Material-Specific Optimizations **Diffuse Materials**: ```yaml # For distant/background objects: LamaDiffuse.Roughness: 0.5 # Reduce energy compensation cost Energy Compensation: 0.8 # Slight performance gain ``` **Conductor Materials**: ```yaml # For small/distant metals: Roughness: [0.1, 0.1] # Avoid mirror-smooth (costly) Anisotropy: 0.0 # Disable unless needed ``` ### Memory Optimization #### Texture Management ```python # Use proper texture formats: *.tx files # RenderMan optimized UDIM workflows: <UDIM> tokens # Memory streaming Proper mip-mapping # Level-of-detail ``` #### Instance-Friendly Materials ```python # Create reusable material templates: Base_Metal → Custom variations via tinting Base_Plastic → Color variations via parameters Base_Glass → IOR variations for different glass types ``` --- ## LPE (Light Path Expressions) for LAMA ### Understanding LAMA LPE Structure [350][355][357] LAMA materials generate specific lobe names for AOV separation: #### Basic LPE Setup ```python # Beauty pass (all light paths): lpe:C.* # Direct diffuse from LAMA diffuse lobes: lpe:C<RD>[<L.>] # Indirect diffuse: lpe:C<RD>[DS]+[<L.>] # Direct specular (conductors + dielectrics): lpe:C<RS>[<L.>] ``` #### LAMA-Specific LPE ```python # LAMA materials support custom lobe naming: LamaDiffuse.Lobe Name: "hero_diffuse" LamaConductor.Lobe Name: "metal_spec" # Custom AOVs: lpe:C<RD'hero_diffuse'>[<L.>] # Only this diffuse lobe lpe:C<RS'metal_spec'>[<L.>] # Only this specular lobe ``` ### Production LPE Templates #### Standard Beauty Breakdown ```python # Core AOVs for compositing: beauty: lpe:C.* diffuse_direct: lpe:C<RD>[<L.>] diffuse_indirect: lpe:C<RD>[DS]+[<L.>] specular_direct: lpe:C<RS>[<L.>] specular_indirect: lpe:C<RS>[DS]+[<L.>] sss_direct: lpe:C<TD>[<L.>] sss_indirect: lpe:C<TD>[DS]+[<L.>] transmission: lpe:C<TS>[<L.>] emission: lpe:C<LE> ``` #### Advanced LAMA LPE [350] ```python # Transmission-aware diffuse (for glass compositing): diffuse_with_transmission: lpe:C<TS>*<RD>[<L.>] # Refraction-only paths: pure_refraction: lpe:C<TS>+[<L.>] # Multiple bounce specular: specular_multi: lpe:C<RS><RS>+[<L.>] ``` ### Custom LPE for Complex Materials #### Car Paint Example ```python # Layer-specific AOVs: LamaDiffuse.Lobe Name: "base_paint" LamaConductor.Lobe Name: "metal_flakes" LamaDielectric.Lobe Name: "clear_coat" # Separate AOVs: base_paint_direct: lpe:C<RD'base_paint'>[<L.>] metal_flakes: lpe:C<RS'metal_flakes'>[<L.>] clear_coat: lpe:C<RS'clear_coat'>[<L.>] ``` --- ## LAMA Limitations and Workarounds ### Current Limitations [316][387][391] #### 1. MaterialX Compatibility Issues **Problem**: Not all MaterialX features fully supported across all DCCs **Workaround**: ```python # Use RenderMan-native LAMA nodes in Solaris # Avoid mixing MaterialX Standard Surface with LAMA # Stick to pure LAMA workflows for consistency ``` #### 2. Volume Integration [387] **Problem**: Limited VDF (Volume Distribution Function) support **Current State**: No LAMA equivalent for volume materials **Workaround**: ```python # Use traditional PxrVolume for volumes # Layer LAMA surface materials separately # Composite in post when needed ``` #### 3. Displacement Integration **Problem**: No integrated displacement layering **Limitation**: Displacement handled at geometry level, not material level[348] **Workaround**: ```python # Apply displacement in geometry processing # Use material layering for surface properties only ``` #### 4. Performance in XPU Mode [321] **Issue**: Some LAMA features limited in XPU vs RIS **Status**: Ongoing development for full XPU support **Recommendation**: Use RIS for final quality, XPU for preview ### Known Issues and Solutions #### MaterialX Nodes Not Rendering [389] **Symptoms**: Black renders, missing parameters **Diagnosis**: ```python # Check material assignments: USD Render Settings → Delegate: RenderMan (not Karma) Material Builder → Type: RenderMan ``` **Solution**: ```python # Proper Solaris workflow: 1. Material Library LOP 2. Material Builder (RenderMan type) 3. Use LAMA nodes (not MaterialX Standard Surface) 4. Assign Material LOP or Material Linker LOP ``` #### UDIM Textures Issues [389] **Problem**: Textures not loading correctly **Solution**: ```python # Proper UDIM setup: PxrTexture.Filename: "/path/to/texture.<UDIM>.exr" # Note: <UDIM> must be UPPERCASE ``` #### Energy Conservation Issues **Symptom**: Materials too bright/dark **Fix**: ```python LamaDiffuse.Energy Compensation: 1.0 # Always keep at 1.0 LamaConductor.Energy Conservation: On # Enable for all metals ``` --- ## Production Tips and Best Practices ### Material Organization #### Naming Conventions ```python # Consistent naming scheme: MAT_hero_skin_v01 MAT_prop_metal_rusty_v02 MAT_env_concrete_weathered_v01 # Node naming: hero_diffuse (LamaDiffuse) hero_specular (LamaDielectric) hero_layer (LamaLayer) ``` #### Material Libraries ```python # Create reusable material templates: Template_Metal_Base ├── LamaConductor (parametric metal) ├── Tint controls └── Roughness variations Template_Skin_Base ├── Deep SSS layer ├── Shallow SSS layer └── Specular layer ``` ### Workflow Optimization #### Look Development Pipeline ```python 1. Block out with simple LamaDiffuse 2. Add primary specular layer (LamaDielectric/LamaConductor) 3. Iterate on layering complexity 4. Optimize for performance 5. Set up custom AOVs/LPE ``` #### Testing and Validation ```python # Material validation checklist: ✓ Energy conservation check (no >1.0 values) ✓ Physical plausibility (reasonable IOR values) ✓ Performance impact (render time comparison) ✓ AOV separation (clean composite elements) ✓ Animation continuity (no flickering) ``` ### Troubleshooting Workflow #### Common Issues Checklist **Material Not Showing**: ```python 1. Check LamaSurface connections 2. Verify material assignment in LOPs 3. Ensure correct render delegate (RenderMan) 4. Check compute flags in LamaSurface ``` **Performance Issues**: ```python 1. Profile render with statistics 2. Simplify layering complexity 3. Disable unused compute flags 4. Use LOD for distant materials ``` **Unexpected Results**: ```python 1. Check energy compensation settings 2. Verify physical parameters (IOR, roughness ranges) 3. Test individual layers in isolation 4. Compare against reference materials ``` ### Advanced Production Techniques #### Dynamic Material Selection ```python # Use expressions for material variations: Parameter_IOR = fit01(random(@ptnum), 1.3, 1.9) # Glass variation Parameter_Roughness = noise(@P) * 0.1 # Roughness variation ``` #### Automated Material Assignment ```python # Group-based material workflow: SOP Groups → USD Subsets → Material Assignment 1. Create groups in modeling 2. Import as USD subsets in SOPs 3. Assign materials via Material Linker ``` #### Cross-Project Compatibility ```python # MaterialX export for other renderers: 1. Build in LAMA for RenderMan quality 2. Create MaterialX Standard Surface equivalents 3. Document parameter mappings 4. Test in target renderers ``` --- ## Conclusion LAMA represents the future of material authoring in production pipelines, offering unparalleled flexibility and performance through its modular approach. By understanding the core concepts of layering, proper node usage, and optimization techniques, you can create sophisticated materials that render efficiently while maintaining the highest quality standards. ### Key Takeaways 1. **Start Simple**: Begin with basic diffuse materials, add complexity gradually 2. **Understand Layering**: Master LamaLayer vs LamaMix concepts early 3. **Optimize Actively**: Use only necessary nodes, disable unused features 4. **Plan for Pipeline**: Consider LPE setup and AOV requirements from the start 5. **Test Thoroughly**: Validate energy conservation and physical plausibility ### Further Learning Resources - [RenderMan LAMA Documentation](https://rmanwiki.pixar.com/display/REN26/MaterialX+Lama) - [MaterialX Specification](https://materialx.org/) - [Pixar RenderMan Fundamentals](https://renderman.pixar.com/fundamentals-materials) Remember: LAMA's power lies in its modularity. Build only what you need, layer thoughtfully, and optimize continuously for the best balance of quality and performance in your production workflow.