Exemple #1
0
def gear_CopyEnvWithGator_Execute():

    # Check Selection
    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    meshes = []
    for item in xsi.Selection:
        if item.Type == "#Group":
            for member in item.Members:
                if member.Type == "polymsh":
                    meshes.append(member)
                else:
                    gear.log("Invalid Selection : %s" % member.FullName,
                             gear.sev_warning)
        elif item.Type == "polymsh":
            meshes.append(item)
        else:
            gear.log("Invalid Selection : %s" % item.FullName,
                     gear.sev_warning)

    if not meshes:
        gear.log("Invalid Selection", gear.sev_error)
        return

    # Pick Session for the sources
    source_meshes = XSIFactory.CreateObject("XSI.Collection")
    while True:
        picked = uit.pickSession(c.siGenericObjectFilter, "Pick Source Mesh",
                                 False)
        if not picked:
            break

        if picked.Type in ["#Group"]:
            for member in picked.Members:
                if ope.getOperatorFromStack(member, "envelopop"):
                    source_meshes.AddItems(member)
                else:
                    gear.log("No Envelope on " + member.Name, gear.sev_warning)
        else:
            if ope.getOperatorFromStack(picked, "envelopop"):
                source_meshes.Add(picked)
            else:
                gear.log("No Envelope on " + picked.Name, gear.sev_warning)

    if not source_meshes:
        gear.log("Invalid Picking", gear.sev_error)
        return

    # Process
    for mesh in meshes:
        env.copyEnvelopeWithGator(mesh, source_meshes)
Exemple #2
0
def gear_CopyEnvWithGator_Execute():
     
    # Check Selection
    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return
    
    meshes = []
    for item in xsi.Selection:
        if item.Type == "#Group":
            for member in item.Members:
                if member.Type == "polymsh":
                    meshes.append(member)
                else:
                    gear.log("Invalid Selection : %s"%member.FullName, gear.sev_warning)
        elif item.Type == "polymsh":
            meshes.append(item)
        else:
            gear.log("Invalid Selection : %s"%item.FullName, gear.sev_warning)
        
    if not meshes:
        gear.log("Invalid Selection", gear.sev_error)
        return

    # Pick Session for the sources
    source_meshes = XSIFactory.CreateObject("XSI.Collection")
    while True:
        picked = uit.pickSession(c.siGenericObjectFilter, "Pick Source Mesh", False)
        if not picked:
            break

        if picked.Type in ["#Group"]:
            for member in picked.Members:
                if ope.getOperatorFromStack(member, "envelopop"):
                    source_meshes.AddItems(member)
                else:
                    gear.log("No Envelope on " + member.Name, gear.sev_warning)
        else:
            if ope.getOperatorFromStack(picked, "envelopop"):
                source_meshes.Add(picked)
            else:
                gear.log("No Envelope on " + picked.Name, gear.sev_warning)

    if not source_meshes:
        gear.log("Invalid Picking", gear.sev_error)
        return

    # Process
    for mesh in meshes:
        env.copyEnvelopeWithGator(mesh, source_meshes)
Exemple #3
0
def gear_SelectUnnormalizedPoints_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    mesh = xsi.Selection(0)

    # Check input
    if mesh.Type not in ["polymsh", "crvlist", "surfmsh"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Get Envelope
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There's no envelope on " + mesh.Fullname, gear.sev_error)
        return

    unNormPntId = env.getUnnormalizedPoints(envelope_op)

    # Select Pnt
    if unNormPntId:
        gear.log("There is " + str(len(unNormPntId)) +
                 " unnormalized point(s)")
        gear.log(mesh.FullName + ".pnt" + str(unNormPntId))
        xsi.SelectGeometryComponents(mesh.FullName + ".pnt" + str(unNormPntId))
    else:
        gear.log("There is no unnormalized point", gear.sev_warning)
Exemple #4
0
def gear_SelectUnnormalizedPoints_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    mesh = xsi.Selection(0)

    # Check input
    if mesh.Type not in ["polymsh", "crvlist", "surfmsh"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Get Envelope
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There's no envelope on " + mesh.Fullname, gear.sev_error)
        return

    unNormPntId = env.getUnnormalizedPoints(envelope_op)

    # Select Pnt
    if unNormPntId:
        gear.log("There is " + str(len(unNormPntId)) +" unnormalized point(s)")
        gear.log(mesh.FullName+".pnt"+str(unNormPntId))
        xsi.SelectGeometryComponents(mesh.FullName+".pnt"+str(unNormPntId))
    else:
        gear.log("There is no unnormalized point", gear.sev_warning)
Exemple #5
0
def gear_CreateSymmetryMappingTemplate_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    deformers = XSIFactory.CreateObject("XSI.Collection")
    deformers.Unique = True
    for sel in xsi.Selection:

        # Check input
        if sel.Type not in ["polymsh", "crvlist", "surfmsh"]:
            gear.log("Invalid selection", gear.sev_warning)
            continue

        # Get Envelope
        envelope_op = ope.getOperatorFromStack(sel, "envelopop")
        if not envelope_op:
            gear.log("There's no envelope on " + sel.Fullname,
                     gear.sev_warning)
            continue

        deformers.AddItems(envelope_op.Deformers)

    if deformers.Count:
        env.createSymmetryMappingTemplate(deformers)
Exemple #6
0
def gear_NormalizeWeights_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    if sel.Type in ["polymsh", "surfmsh", "crvlist"]:
        mesh = sel
        points = range(mesh.ActivePrimitive.Geometry.Points.Count)
    elif sel.Type == "pntSubComponent":
        mesh = sel.SubComponent.Parent3DObject
        points = sel.SubComponent.ElementArray
    else:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Get Envelope from object
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    # Process
    points = env.getUnnormalizedPoints(envelope_op, points)
    if not env.normalizeWeights(envelope_op, points):
        return

    env.freezeEnvelope(envelope_op)
    env.rebuiltEnvelope(envelope_op)
Exemple #7
0
def gear_NormalizeWeights_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    if sel.Type in ["polymsh", "surfmsh", "crvlist"]:
        mesh = sel
        points = range(mesh.ActivePrimitive.Geometry.Points.Count)
    elif sel.Type == "pntSubComponent":
        mesh = sel.SubComponent.Parent3DObject
        points = sel.SubComponent.ElementArray
    else:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Get Envelope from object
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    # Process
    points = env.getUnnormalizedPoints(envelope_op, points)
    if not env.normalizeWeights(envelope_op, points):
        return

    env.freezeEnvelope(envelope_op)
    env.rebuiltEnvelope(envelope_op)
Exemple #8
0
def gear_CreateSymmetryMappingTemplate_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    deformers = XSIFactory.CreateObject("XSI.Collection")
    deformers.Unique = True
    for sel in xsi.Selection:

        # Check input
        if sel.Type not in ["polymsh", "crvlist", "surfmsh"]:
            gear.log("Invalid selection", gear.sev_warning)
            continue

        # Get Envelope
        envelope_op = ope.getOperatorFromStack(sel, "envelopop")
        if not envelope_op:
            gear.log("There's no envelope on " + sel.Fullname, gear.sev_warning)
            continue

        deformers.AddItems(envelope_op.Deformers)

    if deformers.Count:
        env.createSymmetryMappingTemplate(deformers)
Exemple #9
0
def gear_MirrorObjectWeights_Execute():

    xsi.DeselectAll()

    # Get Source Mesh
    source_mesh = uit.pickSession(c.siGenericObjectFilter, "Pick Enveloped Mesh", True)
    if not source_mesh:
        return

    if source_mesh.Type not in ["polymsh", "surfmsh", "crvlist"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    envelope_op = ope.getOperatorFromStack(source_mesh, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    # Get Target Mesh
    target_mesh = uit.pickSession(c.siGenericObjectFilter, "Pick Target Mesh", True)
    if not target_mesh:
        return

    if target_mesh.Type not in ["polymsh", "surfmsh", "crvlist"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Process
    env.copyMirrorEnvelope(source_mesh, target_mesh)
Exemple #10
0
def exportSkin(path, objects, compression=False):

    xml_doc = etree.Element("skin")
    xml_doc.set("user", getpass.getuser())
    xml_doc.set("date", str(datetime.datetime.now()))
    xml_doc.set("version", str(xsixmldom.VERSION))

    # -----------------------------------------------------
    for obj in objects:

        envelope_op = ope.getOperatorFromStack(obj, "envelopop")
        if not envelope_op:
            gear.log("%s has no envelope skipped"%obj.Name, gear.sev_warning)
            continue

        xsixmldom.setOptions(X3DObject_children=False,
                                    X3DObject_primitive=False,
                                    X3DObject_kinematics=False,
                                    X3DObject_properties=[],
                                    Geometry_operators=["envelopop"],
                                    Compression=compression)
        xObject = xsixmldom.getObject(obj)
        xml_doc.append(xObject.xml)

    # -----------------------------------------------------
    # Save to file
    xmldom.indent(xml_doc)

    tree = etree.ElementTree(xml_doc)
    tree.write(path)

    return True
Exemple #11
0
def gear_MirrorObjectWeights_Execute():

    xsi.DeselectAll()

    # Get Source Mesh
    source_mesh = uit.pickSession(c.siGenericObjectFilter,
                                  "Pick Enveloped Mesh", True)
    if not source_mesh:
        return

    if source_mesh.Type not in ["polymsh", "surfmsh", "crvlist"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    envelope_op = ope.getOperatorFromStack(source_mesh, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    # Get Target Mesh
    target_mesh = uit.pickSession(c.siGenericObjectFilter, "Pick Target Mesh",
                                  True)
    if not target_mesh:
        return

    if target_mesh.Type not in ["polymsh", "surfmsh", "crvlist"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Process
    env.copyMirrorEnvelope(source_mesh, target_mesh)
Exemple #12
0
def gear_CopyWeightsAverage_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    # Check input
    if sel.Type not in ["pntSubComponent"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    target_point = sel.SubComponent.ElementArray

    obj = sel.SubComponent.Parent3DObject
    envelope_op = ope.getOperatorFromStack(obj, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    # Pick Session
    source_points = []
    while True:
        source_pnt = uit.pickSession(c.siPointFilter, "Pick Source Point",
                                     False)
        if not source_pnt:
            break

        source_points.extend(source_pnt.SubComponent.ElementArray)

    if not source_points:
        gear.log("No Points Selected", gear.sev_error)
        return

    # Get Weights
    weights_tuple = envelope_op.Weights.Array
    weights = [
        weights_tuple[j][i] for i in range(len(weights_tuple[0]))
        for j in range(len(weights_tuple))
    ]
    deformer_count = envelope_op.Deformers.Count

    # Array of average value of weights
    avr_weights = [0] * deformer_count
    for point_index in source_points:
        for deformer_index in range(deformer_count):
            avr_weights[deformer_index] += weights_tuple[deformer_index][
                point_index] / len(source_points)

    # Replace Weights in Weight Array
    for point_index in target_point:
        for deformer_index in range(deformer_count):
            weights[point_index * deformer_count +
                    deformer_index] = avr_weights[deformer_index]

    envelope_op.Weights.Array = weights

    return
Exemple #13
0
def gear_ReplaceDeformer_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    if sel.Type == "polymsh":
        mesh = sel
        points = range(mesh.ActivePrimitive.Geometry.Points.Count)
    elif sel.Type == "pntSubComponent":
        mesh = sel.SubComponent.Parent3DObject
        points = sel.SubComponent.ElementArray
    else:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Get Envelope from object
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return False

    # Source deformers
    source_deformers = XSIFactory.CreateObject("XSI.Collection")
    while True:
        picked = uit.pickSession(c.siGenericObjectFilter, "Pick Source Deformers", False)
        if not picked:
            break

        if picked.Type == "#Group":
            source_deformers.AddItems(picked.Members)
        else:
            source_deformers.Add(picked)

    if not source_deformers.Count:
        return False

    # Target deformers
    target_deformers = XSIFactory.CreateObject("XSI.Collection")
    while True:
        picked = uit.pickSession(c.siGenericObjectFilter, "Pick Target Deformers", False)
        if not picked:
            break

        if picked.Type == "#Group":
            target_deformers.AddItems(picked.Members)
        else:
            target_deformers.Add(picked)

    if not target_deformers.Count:
        return False

    # Some log to be sure of what we have selected
    gear.log("Geometry: " + mesh.FullName + "  \nSource(s): " + str(source_deformers) + "  \nTarget(s): " + str(target_deformers))

    env.replaceDeformerInEnvelope(envelope_op, source_deformers, target_deformers, points)
Exemple #14
0
def gear_CopyWeightsAverage_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    # Check input
    if sel.Type not in ["pntSubComponent"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    target_point = sel.SubComponent.ElementArray

    obj = sel.SubComponent.Parent3DObject
    envelope_op = ope.getOperatorFromStack(obj, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    # Pick Session
    source_points = []
    while True:
        source_pnt = uit.pickSession(c.siPointFilter, "Pick Source Point", False)
        if not source_pnt:
            break

        source_points.extend(source_pnt.SubComponent.ElementArray)

    if not source_points:
        gear.log("No Points Selected", gear.sev_error)
        return

    # Get Weights
    weights_tuple = envelope_op.Weights.Array
    weights = [weights_tuple[j][i] for i in range(len(weights_tuple[0])) for j in range(len(weights_tuple))]
    deformer_count = envelope_op.Deformers.Count

    # Array of average value of weights
    avr_weights = [0] * deformer_count
    for point_index in source_points:
        for deformer_index in range(deformer_count):
            avr_weights[deformer_index] += weights_tuple[deformer_index][point_index] / len(source_points)

    # Replace Weights in Weight Array
    for point_index in target_point:
        for deformer_index in range(deformer_count):
            weights[point_index*deformer_count + deformer_index] = avr_weights[deformer_index]

    envelope_op.Weights.Array = weights

    return
Exemple #15
0
def gear_CopyWeights_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    # Check input
    if sel.Type not in ["pntSubComponent"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    obj = sel.SubComponent.Parent3DObject
    envelope_op = ope.getOperatorFromStack(obj, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    cls = obj.ActivePrimitive.Geometry.AddCluster(
        c.siVertexCluster, "gear_CopyWeightsOp_Cls",
        sel.SubComponent.ElementArray)

    # Pick Session
    source_pnt = uit.pickSession(c.siPointFilter, "Pick Source Point", True)
    if not source_pnt:
        return

    points = source_pnt.SubComponent.ElementArray
    if len(points) != 1:
        gear.log("Please Select Only One Point", gear.sev_error)
        return

    # Need to find the cluster
    for port in envelope_op.InputPorts:
        if port.Target2.Type == "envweights":
            env_cls = port.Target2

    if not env_cls:
        gear.log("Invalid Envelop, no cluster was found", gear.sev_error)
        return

    # Apply Operator ----------------------
    op = XSIFactory.CreateObject("gear_CopyWeightsOp")

    op.AddIOPort(env_cls)
    op.AddInputPort(cls)
    op.Index = points[0]
    op.Connect()

    xsi.InspectObj(op)

    return op
Exemple #16
0
def gear_CopyWeights_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    # Check input
    if sel.Type not in ["pntSubComponent"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    obj = sel.SubComponent.Parent3DObject
    envelope_op = ope.getOperatorFromStack(obj, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    cls = obj.ActivePrimitive.Geometry.AddCluster(c.siVertexCluster, "gear_CopyWeightsOp_Cls", sel.SubComponent.ElementArray)

    # Pick Session
    source_pnt = uit.pickSession(c.siPointFilter, "Pick Source Point", True)
    if not source_pnt:
      return

    points = source_pnt.SubComponent.ElementArray
    if len(points) != 1:
      gear.log("Please Select Only One Point" , gear.sev_error)
      return

    # Need to find the cluster
    for port in envelope_op.InputPorts:
      if port.Target2.Type == "envweights":
            env_cls = port.Target2

    if not env_cls:
      gear.log("Invalid Envelop, no cluster was found",  gear.sev_error)
      return

    # Apply Operator ----------------------
    op = XSIFactory.CreateObject("gear_CopyWeightsOp")

    op.AddIOPort(env_cls)
    op.AddInputPort(cls)
    op.Index = points[0]
    op.Connect()

    xsi.InspectObj(op)

    return op
Exemple #17
0
def gear_PruneWeights_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    if sel.Type in ["polymsh", "surfmsh", "crvlist"]:
        mesh = sel
        points = range(mesh.ActivePrimitive.Geometry.Points.Count)
#    elif sel.Type == "pntSubComponent":
#        mesh = sel.SubComponent.Parent3DObject
#        points = sel.SubComponent.ElementArray
    else:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Get Envelope from object
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    # PPG for Options
    prop = xsi.ActiveSceneRoot.AddProperty("CustomProperty", False,
                                           "gear_PruneWeights")
    pThreshold = prop.AddParameter3("Threshold", c.siDouble, .1, 0, None,
                                    False, False)
    pRemove = prop.AddParameter3("RemoveDeformers", c.siBool, True, None, None,
                                 False, False)

    layout = prop.PPGLayout
    layout.AddGroup("Prune")
    layout.AddItem(pThreshold.ScriptName, "Weights Threshold")
    layout.AddItem(pRemove.ScriptName, "Remove Unused Deformers")
    layout.EndGroup()

    rtn = xsi.InspectObj(prop, "", "Prune Weights", c.siModal, False)

    threshold = pThreshold.Value
    remove = pRemove.Value

    xsi.DeleteObj(prop)

    if rtn:
        return

    # Process
    env.pruneWeights(envelope_op, points, threshold, remove, True)
Exemple #18
0
def gear_PruneWeights_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    if sel.Type in ["polymsh", "surfmsh", "crvlist"]:
        mesh = sel
        points = range(mesh.ActivePrimitive.Geometry.Points.Count)
#    elif sel.Type == "pntSubComponent":
#        mesh = sel.SubComponent.Parent3DObject
#        points = sel.SubComponent.ElementArray
    else:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Get Envelope from object
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    # PPG for Options
    prop = xsi.ActiveSceneRoot.AddProperty("CustomProperty", False, "gear_PruneWeights")
    pThreshold = prop.AddParameter3("Threshold", c.siDouble, .1, 0, None, False, False)
    pRemove    = prop.AddParameter3("RemoveDeformers", c.siBool, True, None, None, False, False)

    layout = prop.PPGLayout
    layout.AddGroup("Prune")
    layout.AddItem(pThreshold.ScriptName, "Weights Threshold")
    layout.AddItem(pRemove.ScriptName, "Remove Unused Deformers")
    layout.EndGroup()

    rtn = xsi.InspectObj(prop, "", "Prune Weights", c.siModal, False)

    threshold = pThreshold.Value
    remove = pRemove.Value

    xsi.DeleteObj(prop)

    if rtn:
        return

    # Process
    env.pruneWeights(envelope_op, points, threshold, remove, True)
Exemple #19
0
def gear_NormalizeToDeformer_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    if sel.Type in ["polymsh", "surfmsh", "crvlist"]:
        mesh = sel
        points = range(mesh.ActivePrimitive.Geometry.Points.Count)
    elif sel.Type == "pntSubComponent":
        mesh = sel.SubComponent.Parent3DObject
        points = sel.SubComponent.ElementArray
    else:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Get Envelope from object
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    # Get The deformers
    deformers = XSIFactory.CreateObject("XSI.Collection")
    while True:
        deformer = uit.pickSession(c.siGenericObjectFilter, "Pick Deformer",
                                   False)
        if not deformer:
            break

        if env.isDeformer(envelope_op, deformer):
            deformers.Add(deformer)
        else:
            gear.log("Picked object is not a deformer for this envelope",
                     c.siWarning)

    if not deformers.Count:
        return

    # Process
    env.normalizeToDeformer(envelope_op, deformers, points)
    env.freezeEnvelope(envelope_op)
    env.rebuiltEnvelope(envelope_op)
Exemple #20
0
def gear_NormalizeToDeformer_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    if sel.Type in ["polymsh", "surfmsh", "crvlist"]:
        mesh = sel
        points = range(mesh.ActivePrimitive.Geometry.Points.Count)
    elif sel.Type == "pntSubComponent":
        mesh = sel.SubComponent.Parent3DObject
        points = sel.SubComponent.ElementArray
    else:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Get Envelope from object
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    # Get The deformers
    deformers = XSIFactory.CreateObject("XSI.Collection")
    while True:
        deformer =  uit.pickSession(c.siGenericObjectFilter, "Pick Deformer", False)
        if not deformer:
            break

        if env.isDeformer(envelope_op, deformer):
            deformers.Add(deformer)
        else:
            gear.log("Picked object is not a deformer for this envelope", c.siWarning)

    if not deformers.Count:
        return

    # Process
    env.normalizeToDeformer(envelope_op, deformers, points)
    env.freezeEnvelope(envelope_op)
    env.rebuiltEnvelope(envelope_op)
Exemple #21
0
def gear_RebuildEnvelope_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    for mesh in xsi.Selection:

        if mesh.Type not in ["polymsh", "surfmsh", "crvlist"]:
            gear.log("Invalid selection", gear.sev_error)
            continue

        # Get Envelope from object
        envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
        if not envelope_op:
            gear.log("There is no envelope on selected mesh", c.siWarning)
            continue

        env.rebuiltEnvelope(envelope_op)
Exemple #22
0
def gear_RebuildEnvelope_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    for mesh in xsi.Selection:

        if mesh.Type not in ["polymsh", "surfmsh", "crvlist"]:
            gear.log("Invalid selection", gear.sev_error)
            continue

        # Get Envelope from object
        envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
        if not envelope_op:
            gear.log("There is no envelope on selected mesh", c.siWarning)
            continue

        env.rebuiltEnvelope(envelope_op)
Exemple #23
0
def gear_CreateSymmetryMappingTemplate_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    mesh = xsi.Selection(0)

    # Check input
    if mesh.Type not in ["polymsh", "crvlist", "surfmsh"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Get Envelope
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There's no envelope on " + mesh.Fullname, gear.sev_error)
        return

    env.createSymmetryMappingTemplate(envelope_op.Deformers)
Exemple #24
0
def gear_CreateSymmetryMappingTemplate_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    mesh = xsi.Selection(0)

    # Check input
    if mesh.Type not in ["polymsh", "crvlist", "surfmsh"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Get Envelope
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There's no envelope on " + mesh.Fullname, gear.sev_error)
        return

    env.createSymmetryMappingTemplate(envelope_op.Deformers)
Exemple #25
0
def copyMirrorEnvelope(source_mesh, target_mesh):

    sourceEnv_op = ope.getOperatorFromStack(source_mesh, "envelopop")
    if not sourceEnv_op:
        gear.log("There is no envelope on source mesh", gear.sev_error)
        return

    target_deformers = XSIFactory.CreateObject("XSI.Collection")
    for deformer in sourceEnv_op.Deformers:

        model = deformer.Model
        target_deformer = model.FindChild(uti.convertRLName(deformer.Name))
        if not target_deformer:
            gear.log("Deformer missing : " +uti.convertRLName(deformer.Name), c.siWarning)
            target_deformer = deformer

        target_deformers.Add(target_deformer)

    targetEnv_op = target_mesh.ApplyEnvelope(target_deformers)

    # Apply Weights
    targetEnv_op.Weights.Array = sourceEnv_op.Weights.Array
Exemple #26
0
def copyMirrorEnvelope(source_mesh, target_mesh):

    sourceEnv_op = ope.getOperatorFromStack(source_mesh, "envelopop")
    if not sourceEnv_op:
        gear.log("There is no envelope on source mesh", gear.sev_error)
        return

    target_deformers = XSIFactory.CreateObject("XSI.Collection")
    for deformer in sourceEnv_op.Deformers:

        model = deformer.Model
        target_deformer = model.FindChild(uti.convertRLName(deformer.Name))
        if not target_deformer:
            gear.log("Deformer missing : " + uti.convertRLName(deformer.Name),
                     c.siWarning)
            target_deformer = deformer

        target_deformers.Add(target_deformer)

    targetEnv_op = target_mesh.ApplyEnvelope(target_deformers)

    # Apply Weights
    targetEnv_op.Weights.Array = sourceEnv_op.Weights.Array
Exemple #27
0
def gear_CopyEnvWithGator_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    source_meshes = XSIFactory.CreateObject("XSI.Collection")
    while True:
        picked = uit.pickSession(c.siGeometryFilter, "Pick Source Mesh", False)
        if not picked:
            break

        if not ope.getOperatorFromStack(picked, "envelopop"):
            gear.log("No Envelope on " + picked.Name, c.siWarning)
            continue

        source_meshes.Add(picked)

    if not source_meshes:
        return

    for mesh in xsi.Selection:
        env.copyEnvelopeWithGator(mesh, source_meshes)
Exemple #28
0
def gear_CopyEnvWithGator_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    source_meshes = XSIFactory.CreateObject("XSI.Collection")
    while True:
        picked = uit.pickSession(c.siGeometryFilter, "Pick Source Mesh", False)
        if not picked:
            break

        if not ope.getOperatorFromStack(picked, "envelopop"):
            gear.log("No Envelope on " + picked.Name, c.siWarning)
            continue

        source_meshes.Add(picked)

    if not source_meshes:
        return

    for mesh in xsi.Selection:
        env.copyEnvelopeWithGator(mesh, source_meshes)
Exemple #29
0
def gear_AverageMirrorWeights_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    # Check input
    if sel.Type not in ["pntSubComponent"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    mesh = sel.SubComponent.Parent3DObject
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    points = sel.SubComponent.ElementArray

    # Process
    env.averageMirrorWeights(envelope_op, points)
Exemple #30
0
def gear_AverageMirrorWeights_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    # Check input
    if sel.Type not in ["pntSubComponent"]:
        gear.log("Invalid selection", gear.sev_error)
        return

    mesh = sel.SubComponent.Parent3DObject
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return

    points = sel.SubComponent.ElementArray

    # Process
    env.averageMirrorWeights(envelope_op, points)
Exemple #31
0
def gear_ReplaceDeformer_Execute():

    if not xsi.Selection.Count:
        gear.log("No selection", gear.sev_error)
        return

    sel = xsi.Selection(0)

    if sel.Type == "polymsh":
        mesh = sel
        points = range(mesh.ActivePrimitive.Geometry.Points.Count)
    elif sel.Type == "pntSubComponent":
        mesh = sel.SubComponent.Parent3DObject
        points = sel.SubComponent.ElementArray
    else:
        gear.log("Invalid selection", gear.sev_error)
        return

    # Get Envelope from object
    envelope_op = ope.getOperatorFromStack(mesh, "envelopop")
    if not envelope_op:
        gear.log("There is no envelope on selected mesh", gear.sev_error)
        return False

    # Source deformers
    source_deformers = XSIFactory.CreateObject("XSI.Collection")
    while True:
        picked = uit.pickSession(c.siGenericObjectFilter,
                                 "Pick Source Deformers", False)
        if not picked:
            break

        if picked.Type == "#Group":
            source_deformers.AddItems(picked.Members)
        else:
            source_deformers.Add(picked)

    if not source_deformers.Count:
        return False

    # Target deformers
    target_deformers = XSIFactory.CreateObject("XSI.Collection")
    while True:
        picked = uit.pickSession(c.siGenericObjectFilter,
                                 "Pick Target Deformers", False)
        if not picked:
            break

        if picked.Type == "#Group":
            target_deformers.AddItems(picked.Members)
        else:
            target_deformers.Add(picked)

    if not target_deformers.Count:
        return False

    # Some log to be sure of what we have selected
    gear.log("Geometry: " + mesh.FullName + "  \nSource(s): " +
             str(source_deformers) + "  \nTarget(s): " + str(target_deformers))

    env.replaceDeformerInEnvelope(envelope_op, source_deformers,
                                  target_deformers, points)