01When To Use Maya Integration
Use Maya when someone needs to inspect or adjust the result interactively. For a large unattended batch, consider the standalone workflow instead. Keep the processing logic separate from the Maya UI so both workflows can reuse it.
- Great in Maya: selected props, character pieces, material merge experiments, anything an artist wants to eyeball first.
- Wrong in Maya: big nightly batches. Unless the job genuinely needs Maya's scene evaluation, run the processing without the DCC where possible.
- Either way, keep the actual Simplygon logic DCC-agnostic and call it from a thin Maya wrapper - then the same code serves both worlds.
02Load The Plugin
First job: make sure the plugin is actually loaded, and fail loudly if it isn't. If it isn’t available, tell the user which plugin the tool expects and where to check it. Run this from the Script Editor, a shelf tool, or mayapy:
import maya.cmds as cmds
def ensure_simplygon_plugin(plugin_name="SimplygonMaya"):
try:
loaded = cmds.pluginInfo(plugin_name, query=True, loaded=True)
except RuntimeError:
loaded = False
if not loaded:
cmds.loadPlugin(plugin_name)
if not cmds.pluginInfo(plugin_name, query=True, loaded=True):
raise RuntimeError(f"Could not load Maya plugin: {plugin_name}")The reference scripts use SimplygonMaya. If your installed plugin has a versioned name, confirm it in Maya's Plug-in Manager and pass that name to the loader.
03Export Selection And Import Results
The whole Maya workflow hangs off one trick: the plugin command exports your selection to a Simplygon scene file, and imports a processed one back. Everything else on this page is just what happens between those two calls. A temp .sb file plays middleman:
import os
import tempfile
import maya.cmds as cmds
def selected_or_raise():
selection = cmds.ls(selection=True, long=True) or []
if not selection:
raise RuntimeError("Select one or more meshes before running Simplygon")
return selection
def export_selection_to_simplygon(path):
selected_or_raise()
ensure_simplygon_plugin()
cmds.Simplygon(exp=path)
def import_simplygon_scene(path, load_materials=True):
ensure_simplygon_plugin()
cmds.Simplygon(imp=path, lma=load_materials)
def temp_simplygon_path(label="maya_selection"):
return os.path.join(tempfile.gettempdir(), f"{label}.sb")04Reduce The Current Selection
Put the pieces together and you get a small selection-processing tool: select, press button, reduced copy appears. Export the selection, run a pipeline on it, import the result back - that's the whole trick:
from simplygon10 import Simplygon
from sg_samples.core.simplygon_instance import SimplygonInstance
def reduce_maya_selection(ratio=0.5):
sg = SimplygonInstance()
temp_path = temp_simplygon_path("simplygon_maya_reduce")
export_selection_to_simplygon(temp_path)
scene = sg.CreateScene()
scene.LoadFromFile(temp_path)
pipeline = sg.CreateReductionPipeline()
settings = pipeline.GetReductionSettings()
settings.SetReductionTargets(
Simplygon.EStopCondition_All,
True, False, False, False
)
settings.SetReductionTargetTriangleRatio(ratio)
pipeline.RunScene(scene, Simplygon.EPipelineRunMode_RunInThisProcess)
processed_scene = pipeline.GetProcessedScene()
processed_scene.SaveToFile(temp_path)
import_simplygon_scene(temp_path, load_materials=True)For an artist-facing shelf button, expose ratio as a slider. Keep sensible presets such as 0.75, 0.5, and 0.25, then let the artist inspect the result in Maya before saving it.
05Create An LOD Chain In Maya
The Maya LOD sample follows the same rule as the standalone chain: build each LOD from the original export, not from the previous LOD. That keeps errors from cascading.
from pathlib import Path
from simplygon10 import Simplygon
def create_maya_lod_chain(screen_sizes=(600, 300, 100)):
sg = SimplygonInstance()
source_path = temp_simplygon_path("simplygon_maya_lod_source")
export_selection_to_simplygon(source_path)
original = sg.CreateScene()
original.LoadFromFile(source_path)
imported_roots = []
for index, screen_size in enumerate(screen_sizes):
scene_copy = original.NewCopy()
pipeline = sg.CreateReductionPipeline()
settings = pipeline.GetReductionSettings()
settings.SetReductionTargets(
Simplygon.EStopCondition_Any,
False, True, False, False
)
settings.SetReductionTargetOnScreenSize(screen_size)
pipeline.RunScene(scene_copy, Simplygon.EPipelineRunMode_RunInThisProcess)
lod_path = temp_simplygon_path(f"simplygon_maya_lod{index}")
pipeline.GetProcessedScene().SaveToFile(lod_path)
before = set(cmds.ls(assemblies=True, long=True))
import_simplygon_scene(lod_path, load_materials=True)
after = set(cmds.ls(assemblies=True, long=True))
imported_roots.extend(sorted(after - before))
if imported_roots:
group = cmds.group(imported_roots, name="simplygon_LOD_chain")
return group
return NoneAfter import, check the LODs in a simple turntable camera and in engine. Screen-size targets are useful, but game cameras and material complexity still decide whether an LOD is acceptable.
06Quad Reduction
Quad reduction is useful when the result still needs to be modeller-friendly or deformation-friendly. It's usually a better fit for close-up character or subdivision-style assets than aggressive triangle reduction.
def create_quad_reduction_pipeline(sg):
if hasattr(sg, "CreateQuadReductionPipeline"):
return sg.CreateQuadReductionPipeline()
raise RuntimeError(
"This SDK build does not expose a quad reduction pipeline. "
"Use triangle reduction or update the SDK/plugin."
)If your SDK build exposes dedicated quad reduction settings, use them. If not, don't pretend triangle reduction is the same thing. Label the fallback clearly so artists know what topology to expect.
07Material Merging In Maya
Material merging is useful when a prop has more material slots than it needs. Select a representative asset, bake its materials into an atlas, then compare draw calls, texture memory, and appearance in the engine. Check shader features and material channels before replacing the original.
from simplygon10 import Simplygon
def merge_maya_selection_materials(texture_size=2048):
sg = SimplygonInstance()
temp_path = temp_simplygon_path("simplygon_maya_material_merge")
export_selection_to_simplygon(temp_path)
scene = sg.CreateScene()
scene.LoadFromFile(temp_path)
pipeline = sg.CreateAggregationPipeline()
aggregation = pipeline.GetAggregationSettings()
aggregation.SetMergeGeometries(True)
mapping = pipeline.GetMappingImageSettings()
mapping.SetGenerateMappingImage(True)
output_material = mapping.GetOutputMaterialSettings(0)
output_material.SetTextureWidth(texture_size)
output_material.SetTextureHeight(texture_size)
color = sg.CreateColorCaster()
color.GetColorCasterSettings().SetMaterialChannel("Diffuse")
pipeline.AddMaterialCaster(color, 0)
normal = sg.CreateNormalCaster()
normal.GetNormalCasterSettings().SetMaterialChannel("Normals")
normal.GetNormalCasterSettings().SetGenerateTangentSpaceNormals(True)
pipeline.AddMaterialCaster(normal, 0)
pipeline.RunScene(scene, Simplygon.EPipelineRunMode_RunInThisProcess)
pipeline.GetProcessedScene().SaveToFile(temp_path)
import_simplygon_scene(temp_path, load_materials=True)Add more casters for roughness, metallic, opacity, emissive, or studio-specific channels. Name your Maya materials predictably before export so imported results are easy to inspect.
08Artist-Facing UI Shape
A useful Maya tool should show a small set of predictable controls and hide the SDK plumbing.
| Control | Why It Exists |
|---|---|
| Mode | Reduction, LOD chain, remesh proxy, material merge, or quad reduction. |
| Target | Triangle ratio, screen size, texture size, or preset name. |
| Preserve | Options for materials, vertex colours, skin weights, seams, hard edges, or selection sets. |
| Output | Import into scene, save next to source, or export to a review folder. |
| Report | Warnings, before/after triangle counts, material count, texture sizes, and processing time. |
Artists should choose intent, not SDK terminology. Use labels like "close LOD", "far LOD", "merge kitbash prop", or "make proxy", then map those to versioned pipeline settings.
09Common Maya Pitfalls
- Selection is empty: fail with a clear message before exporting.
- Plugin isn't loaded: load it explicitly and report the expected plugin name.
- Temp files collide: include the tool name, user, process id, or timestamp if multiple tools can run at once.
- Imported nodes are hard to find: capture root assemblies before and after import, then group or rename the imported result.
- Materials look different: check channel names, texture paths, tangent-space normal settings, and whether
lma=Trueloaded material assets. - Animated meshes deform badly: test in animation, preserve skin data, and use bone reduction only with explicit review.
- Artists can't compare: keep the original visible or duplicate it into a review group before replacing anything.