def GetMeshCopy(obj, transform=False):
model = obj.model
mesh = model.AddGeometry("Cube", "MeshSurface", obj.Name + "_Copy")
XSI.FreezeObj(mesh)
datas = obj.ActivePrimitive.Geometry.Get2()
tra = obj.Kinematics.Global.Transform
# get the datas
vertices = datas[0]
polys = datas[1]
mesh.ActivePrimitive.Geometry.Set(vertices, polys)
if transform:
mesh.Kinematics.Global.Transform = tra
return mesh
def SymmetrizeWeights(weightmap, side=0, invert=False, axis=0):
if not weightmap.Type == "wtmap":
XSI.LogMessage("[Symmetrize Weights] ERROR : Input NOT a Weight Map",
constants.siError)
return
# get symmetry map
obj = weightmap.Parent3DObject
symap = GetSymmetryMap(obj)
geom = obj.ActivePrimitive.Geometry
pos = geom.Points.PositionArray
cls = weightmap.Parent
elems = cls.Elements.Array
factor = 1
if invert:
factor = -1
# Get Arrays
weights = [w for w in weightmap.Elements.Array[0]]
tmp = [w for w in weightmap.Elements.Array[0]]
sym = symap.Elements.Array
# Process
for i in range(len(weights)):
if side == 0:
if pos[axis][elems[i]] > 0:
idx = int(sym[0][elems[i]])
idx = cls.FindIndex(idx)
tmp[idx] = weights[i] * factor
elif side == 1:
if pos[axis][elems[i]] < 0:
idx = int(sym[0][elems[i]])
idx = cls.FindIndex(idx)
tmp[idx] = weights[i] * factor
else:
tmp[int(sym[0][elems[i]])] = weights[i] * factor
weightmap.Elements.Array = tmp
def BuildCurveOnSymmetrizedPositions(inPositions,
inAxis=0,
inDegree=0,
inClose=0):
if len(inPositions) < 1:
XSI.LogMessage(
"BuildCurveOnSymmetrizedPosition aborted :: Not enough input positions!!",
constants.siError)
return
axis = XSIMath.CreateVector3(-1, 1, 1)
if inAxis == 1:
axis.Set(1, -1, 1)
elif inAxis == 2:
axis.Set(1, 1, -1)
newPos = []
last = len(inPositions) - 1
for i in range(len(inPositions)):
p = inPositions[last - i]
newPos.append(p.X * axis.X)
newPos.append(p.Y * axis.Y)
newPos.append(p.Z * axis.Z)
newPos.append(1)
# middle pos
newPos.append(0)
newPos.append(inPositions[0].Y)
newPos.append(inPositions[0].Z)
newPos.append(1)
for p in inPositions:
newPos.append(p.X)
newPos.append(p.Y)
newPos.append(p.Z)
newPos.append(1)
if inDegree == 0:
outCrv = XSI.ActiveSceneRoot.AddNurbsCurve(newPos, None, inClose, 1)
else:
outCrv = XSI.ActiveSceneRoot.AddNurbsCurve(newPos, None, inClose, 3)
return outCrv
def CreateGuide(self):
builder = self.GetBuilder()
if self.CheckElementExist():
XSI.LogMessage('[CreateControlElement] : ' + self.fullname +
'_Ctrl already exist ---> aborted...!')
return False
t = XSIMath.CreateTransform()
t.SetTranslation(self.position)
self.crv = RIG_CONTROL_ICON[builder.Parameters(
"ControlIconType").Value]
self.GetControlColor()
color = [self.colorrik, self.colorgik, self.colorbik]
self.size = builder.Parameters("GlobalSize").Value
self.crv = Icon.IRIcon(self.parent, self.fullname + "_Ctrl", t, color,
self.icon, self.size, self.size, self.size)
Utils.GroupSetup(self.model, [self.crv], "Control_Curves")
return True
def Symmetrize(self):
if self.side == MIDDLE:
XSI.LogMessage(
"[CreateControlElement] : Can't symmetrize middle elements ---> aborted...!"
)
return None
axis = self.builder.Parameters("SymmetryAxis").Value
self.symparent = self.model.FindChild(
self.ctrl.Parent.Name.replace(self.prefix, self.symprefix))
if not self.symparent:
self.symparent = self.ctrl.Parent
color = [self.colorrik, self.colorgik, self.colorbik]
self.symctrl = Icon.IRIcon(self.symparent, self.symfullname + "_Ctrl",
XSIMath.CreateTransform(), color, self.icon,
self.size, self.size, self.size)
Utils.SimpleSymmetry(self.symctrl, self.ctrl, axis)
'''
def GetObjectFromSelectedUIItem(prop, name):
obj = prop.Parent3DObject
if obj.Type == '#model':
model = obj
else:
model = obj.Model
_list = prop.Parameters('{}List'.format(name)).Value
if _list == '':
return None
selected = prop.Parameters('{}Chooser'.format(name)).Value
if selected:
split = _list.split('|')
split.pop()
try:
return model.FindChild(selected)
except RuntimeError:
XSI.LogMessage('[Property] Can\'t find Object "{}" !', constants.siWarning)
return None
def Cloth_Control_ClothObjectChooser_OnChanged():
prop = PPG.Inspected(0)
items = PPG.PPGLayout.Item("ClothObjectChooser").UIItems
value = PPG.ClothObjectChooser.Value
path = prop.ClothObjectIconFolder.Value
XSI.LogMessage(path)
if value>0:
selected = items[value*2]
model = PPG.Inspected(0).Parent3DObject
cloth = model.FindChild(selected)
Cloth_Control_SyflexToProperty(prop,cloth)
path += "\\"+cloth.Name+".bmp"
else:
path += "\\All_Cloth_Objects.bmp"
PPG.ClothObjectIcon.Value = path
Cloth_Control_RebuildLayout(prop)
PPG.Refresh()
def SetOneElementMap(crv, obj, name):
weight_map = Utils.GetWeightMap(obj, name)
tree = obj.ActivePrimitive.ICETrees.Find('SetOneElement')
if not tree:
tree = ICETree.CreateIceTree(obj, 'SetOneElement', 1)
setter = XSI.AddICECompoundNode('SetOneElementMap', str(tree))
idx = tree.InputPorts.Count
XSI.AddPortToICENode('{}.port{}'.format(tree, idx),
'siNodePortDataInsertionLocationAfter')
XSI.ConnectICENodes('{}.port{}'.format(tree, idx),
'{}.execute'.format(setter))
XSI.SetValue('{}.reference'.format(setter),
'this.cls.WeightMapCls.{}'.format(name), '')
getter = XSI.AddICENode('GetDataNode', str(tree))
XSI.SetValue('{}.reference'.format(getter),
ICETree.ReplaceModelNameByThisModel(crv), '')
XSI.ConnectICENodes('{}.Guide_Curve'.format(setter),
'{}.outname'.format(getter))
return weight_map
def CollectSkeletonElements(model):
prop = model.Properties('RigBuilder')
if not prop:
return
element_names = prop.Parameters('SkeletonList').Value.split('|')
skeleton_elements = XSIFactory.CreateActiveXObject('XSI.Collection')
for element in element_names:
if element:
crv = model.FindChild('{}_Crv'.format(element))
if crv:
elem_prop = crv.Properties("RigElement")
if elem_prop:
skeleton_elements.Add(elem_prop)
else:
XSI.LogMessage(
str(crv) +
" does not have RigElement Property ---> Skipped!")
return skeleton_elements
def Cloth_GetColliderMeshes(prop):
obj = prop.Parent3DObject
model = obj.Model
colliders = []
tokens = prop.Parameters('ColliderMeshes').Value.split("|")
for token in tokens:
if token:
collide_mesh = model.FindChild(token)
if not collide_mesh:
XSI.LogMessage(
'[Cloth_Rigger] Collider named "{}" not found !'.format(
token), constants.siWarning)
continue
collider = Cloth.Collider(obj, collide_mesh, False)
collider.GetPntCluster()
collider.GetPolyCluster()
colliders.append(collider)
collider.Rig()
return colliders
def CreateEnvelopeDuplicate(model, skin):
# check ICE skeleton
skeleton = model.FindChild('ICE_Skeleton')
# check envelope group
env_grp = model.Groups('Envelope')
if not skeleton:
XSI.LogMessage(
'[CreateEnvelopeDuplicate] No ICE Skeleton or no Envelope Group!',
constants.siWarning)
return
# check nb deformers
num_points = skeleton.ActivePrimitive.Geometry.Points.Count
if not env_grp or not num_points == env_grp.Members.Count:
env_grp = Skeleton.CreateEnvelopeNullsFromSkeletonCloud(model)
# duplicate mesh
dup = Utils.GetMeshCopy(skin)
skin.Parent3DObject.AddChild(dup)
skin.Properties('Visibility').Parameters('ViewVis').Value = False
XSI.ApplyFlexEnv('{};{}'.format(dup.FullName, env_grp.Members.GetAsText()),
'', 2)
# transfer weights
tree = ICETree.CreateICETree(dup, 'TransferWeights', 0)
compound = XSI.AddICECompoundNode('TransferWeightsFromICESkeleton',
str(tree))
XSI.ConnectICENodes('{}.port1'.format(tree), '{}.execute'.format(compound))
name = ICETree.ReplaceModelNameByThisModel(skin, model)
XSI.SetValue('{}.Reference'.format(compound), name)
# deform
tree = ICETree.CreateICETree(dup, 'Deform', 2)
deform = XSI.AddICECompoundNode('ICE Envelope Skeleton', str(tree))
XSI.ConnectICENodes('{}.port1'.format(tree), '{}.execute'.format(deform))
'''
def CreateGuide(self):
if not self.root:
self.root = uti.AddNull(self.model, 0, 1, "Muscles", 0, 0, 0)
if self.CheckElementExist():
XSI.LogMessage("[BuildRigMuscle] : " + self.fullname +
self.suffix + " already exist ---> skipped...!")
return False
self.nbp = len(self.position) + 2
self.crv = uti.BuildCurveOnPositions(self.position)
self.datacls = uti.CreateAlwaysCompleteCluster(
self.crv, siConstants.siVertexCluster, "ElementData")
self.widthmap = uti.GetWeightMap(self.crv, "WidthMap", 0.01, 0, 1,
self.datacls)
self.depthmap = uti.GetWeightMap(self.crv, "DepthMap", 0.01, 0, 1,
self.datacls)
self.twistmap = uti.GetWeightMap(self.crv, "TwistMap", 0.01, -1, 1,
self.datacls)
self.collidemap = uti.GetWeightMap(self.crv, "CollideMap", 1, 0, 1,
self.datacls)
self.stickmap = uti.GetWeightMap(self.crv, "StickMap", 1, 0, 1,
self.datacls)
self.offsetshape = self.datacls.AddProperty("SimpleDeformShape", 0,
"Offset")
self.crv.Name = self.fullname + self.suffix
uti.SetWireColor(self.crv, COLOR_MUSCLE_R, COLOR_MUSCLE_G,
COLOR_MUSCLE_B)
self.root.AddChild(self.crv)
self.prop = self.crv.AddProperty(PROP_MUSCLE)
uti.GroupSetup(self.model, [self.crv], "Muscle_Curves")
return True
def AddToRig(self):
XSI.LogMessage("[RigControl] : Add to Rig called...")
def Cloth_Control_SelectWindIcon_OnClicked():
model = PPG.Inspected(0).Parent3DObject
icon = model.FindChild("Cloth_Wind")
if icon:
XSI.SelectObj(icon)
def Cloth_Control_WindFactor_OnChanged():
XSI.LogMessage("Udpdate Parameter for ScriptedOp WindIconOp")
def Cloth_Control_GravityFactor_OnChanged():
XSI.LogMessage("Udpdate Parameter for ScriptedOp GravityIconOp")
def RemoveFromRig(self):
XSI.LogMessage("[RigControl] : Remove Control Element Called...")
def Cloth_Rigger_CleanCloth_OnClicked():
for prop in PPG.Inspected:
XSI.Cloth_Clean(prop)
def Cloth_GetAir(op):
air = XSI.ApplyOperator('syAir', op)
air.Parameters('Damp').Value = 0.05
def Cloth_GetTargetMesh(prop):
mesh = prop.Parent3DObject
model = mesh.Model
dup = prop.Parameters('CreateTargetMesh').Value
target = None
if not dup:
target = Cloth_DuplicateMesh(mesh)
else:
try:
target = model.FindChild(prop.Parameters('TargetMesh').Value)
if not target:
target = Cloth_DuplicateMesh(mesh)
except RuntimeError:
target = Cloth_DuplicateMesh(mesh)
'''
if not uti.CheckGeometryMatch(mesh,target):
XSIUIToolkit.MsgBox('Target Mesh Invalid: we generate a new one',constants.siMsgExclamation,'Cloth_Tools')
target = Cloth_DuplicateMesh(mesh)
'''
#Transfer Envelope from Output mesh if not exists
if not target.ActivePrimitive.ConstructionHistory.Find('envelopop'):
out = Cloth_GetOutputMesh(prop)
if out:
envelope = out.ActivePrimitive.ConstructionHistory.Find(
'envelopop')
if envelope:
env = XSI.Dictionary.GetObject(envelope)
weights = env.PortAt(4, 0, 0).Target2
XSI.ApplyGenOp('Gator', '',
';'.join([target.FullName, out.FullName]), 3,
'siPersistentOperation', 'siKeepGenOpInputs',
'')
XSI.TransferClusterPropertiesAcrossGenOp(
'{}.polymsh.TransferAttributes'.format(target.FullName),
target.FullName, str(weights), 'Envelope_Weights', '')
XSI.FreezeModeling(target)
# Deform OutputMesh
Cloth_DeformOutputMesh(prop)
# Create Init ICE Tree
trees = target.ActivePrimitive.ICETrees
if not trees.Find('InitTarget'):
tree = ICETree.CreateICETree(target, 'InitTarget', 1)
compound = XSI.AddICECompoundNode('ClothInitTarget', str(tree))
XSI.ConnectICENodes('{}.port1'.format(tree),
'{}.Execute'.format(compound))
# Create PreRoll ICE Tree
if not trees.Find('PreRollTarget'):
tree = ICETree.CreateICETree(target, 'PreRollTarget', 3)
compound = XSI.AddICECompoundNode('ClothTargetPreRoll', str(tree))
XSI.ConnectICENodes('{}.port1'.format(tree),
'{}.Execute'.format(compound))
# Update Cloth Rigger
prop.Parameters('CreateTargetMesh').Value = 1
prop.Parameters('TargetMesh').Value = target.Name
Utils.SetVisibility([target], False, False)
Cloth_Rigger_RebuildLayout(prop)
try:
PPG.Refresh()
except RuntimeError:
pass
return target
def BuildIK2BonesRig(parent, crv, ppg):
name = crv.Name.replace("_Crv", "")
side = MIDDLE
if name.find("L_", 0, 2) > -1:
side = LEFT
elif name.find("R_", 0, 2) > -1:
side = RIGHT
prefix = "M_"
if side == LEFT:
prefix = "L_"
elif side == RIGHT:
prefix = "R_"
ppg.Parameters("GlobalSize").Value
r = ppg.Parameters(prefix + "ColorR_IK").Value
g = ppg.Parameters(prefix + "ColorG_IK").Value
b = ppg.Parameters(prefix + "ColorB_IK").Value
pnts = crv.ActivePrimitive.Geometry.Points
if pnts.Count == 3:
p0 = pnts[0].Position
p1 = pnts[1].Position
p2 = pnts[2].Position
else:
last = pnts.Count - 1
p0 = pnts[0].Position
pos = []
for i in range(1, last):
pos.append(pnts[i].Position)
p1 = Utils.GetAveragePosition(pos)
p2 = pnts[last].Position
dir1 = XSIMath.CreateVector3()
dir1.Sub(p0, p1)
dir2 = XSIMath.CreateVector3()
dir2.Sub(p1, p2)
length = dir1.Length() + dir2.Length()
plane = XSIMath.CreateVector3()
plane.Cross(dir1, dir2)
plane.NormalizeInPlace()
offset = XSIMath.CreateVector3()
offset.Normalize(dir1)
offset.ScaleInPlace(-length * 0.5)
offset.AddInPlace(p1)
l1 = dir1.Length()
l2 = dir2.Length()
transform = XSIMath.CreateTransform()
transform.SetTranslation(p0)
root = Icon.IRIcon(parent, name + "_Root_Ctrl", transform, [r, g, b],
"cube", 0.1 * length, 0.1 * length, 0.1 * length)
ik = Utils.MakeRigNull(parent, 1, name + "_IK")
transform.SetTranslation(p1)
ik.Kinematics.Global.Transform = transform
tree = ICETree.CreateICETree(ik, "IK", 2)
ik_node = XSI.AddICECompoundNode("IK2BonesKinematics", tree)
XSI.ConnectICENodes(str(tree) + ".port1", str(ik_node) + ".Execute")
# set ik values
XSI.SetValue(
str(ik_node) + ".Reference", "this_model." + name + "_Root_Ctrl", "")
XSI.SetValue(
str(ik_node) + ".Reference1", "this_model." + name + "_Eff_Ctrl", "")
XSI.SetValue(
str(ik_node) + ".Reference2", "this_model." + name + "_UpV_Ctrl", "")
XSI.SetValue(str(ik_node) + ".LengthA", l1, "")
XSI.SetValue(str(ik_node) + ".LengthB", l2, "")
knee = Icon.IRIcon(ik, name + "_Knee_Ctrl", transform, [r, g, b], "sphere",
0.1 * length, 0.1 * length, 0.1 * length)
transform.SetTranslation(offset)
upv = Icon.IRIcon(root, name + "_UpV_Ctrl", transform, [r, g, b],
"pyramid", 0.05 * length, 0.05 * length, 0.05 * length)
transform.SetTranslation(p2)
eff = Icon.IRIcon(parent, name + "_Eff_Ctrl", transform, [r, g, b],
"square", length, length, length)
Utils.ResetStaticKinematicState([root, knee, eff])
Utils.GroupSetup(parent.Model, [root, knee, eff], "IK_Rig")
XSI.SetNeutralPose([root, knee, eff, upv], "siSRT", "")
def BuildFootRollRig(parent, crv, ppg, side=MIDDLE, simple=False):
prefix = 'M_'
if side == LEFT:
prefix = 'L_'
elif side == RIGHT:
prefix = 'R_'
basename = crv.Name.replace("_Crv", "")
r = ppg.Parameters('{}ColorR_FK'.format(prefix)).Value
g = ppg.Parameters('{}ColorG_FK'.format(prefix)).Value
b = ppg.Parameters('{}ColorB_FK'.format(prefix)).Value
axis = XSIMath.CreateVector3()
d1 = XSIMath.CreateVector3()
d2 = XSIMath.CreateVector3()
points = crv.ActivePrimitive.Geometry.Points
pos = []
for point in points:
pos.append(point.Position)
last = points.Count - 1
d1.Sub(pos[1], pos[0])
d2.Sub(pos[last], pos[0])
d1.NormalizeInPlace()
d2.NormalizeInPlace()
axis.Cross(d1, d2)
# build root control
min_z = pos[0].Z
for i, point in enumerate(pos):
if i == 0:
continue
if point.Z < min_z:
min_z = point.Z
average = Utils.GetAveragePosition(pos)
average.Z = min_z
length = Utils.GetCurveLength(crv)
transform = XSIMath.CreateTransform()
transform.SetTranslation(average)
main = Icon.IRIcon(parent, '{}_MainControl'.format(basename), transform,
[r, g, b], 'circle', 0.5 * length, 0.5 * length,
0.5 * length)
parent = main
parents = []
ctrls = []
# build reverse structure
for i in range(0, last):
transform.SetTranslation(pos[last - i])
parent = Icon.IRIcon(parent, '{}{}{}_Ctrl'.format(prefix, basename, i),
transform, [r, g, b], 'bendedarrow2',
0.2 * length, 0.2 * length, 0.2 * length)
parents.append(parent)
ctrls.append(parent)
# build final control structure
fks = []
for i in range(0, last + 1):
transform.SetTranslation(pos[last - i])
if i == 0:
icon = Icon.IRIcon(main, '{}{}{}_Ctrl'.format(prefix, basename, i),
transform, [r, g, b], "sphere", 0.1 * length,
0.1 * length, 0.1 * length)
fks.append(icon)
ctrls.append(icon)
else:
icon = Icon.IRIcon(parents[i - 1],
'{}{}{}_Ctrl'.format(prefix, basename, i),
transform, [r, g, b], 'sphere', 0.1 * length,
0.1 * length, 0.1 * length)
fks.append(icon)
ctrls.append(icon)
Utils.ResetStaticKinematicState(fks)
Utils.GroupSetup(parent.Model, fks, 'IK_Rig')
XSI.SetNeutralPose(ctrls, 'siSRT', '')
Utils.GroupSetup(parent.Model, ctrls, 'Anim_Controls')
def Cloth_ApplyRestoreOp(obj, target):
tree = ICETree.CreateICETree(obj, 'ClothRestore', 2)
compound = XSI.AddICECompoundNode('ClothRestoreShape', str(tree))
XSI.ConnectICENodes('{}.port1'.format(tree), '{}.Result'.format(compound))
XSI.SetValue('{}.Target_Mesh_Reference'.format(compound),
ICETree.ReplaceModelNameByThisModel(target), '')
def Cloth_ApplyInitOp(obj, target):
tree = ICETree.CreateICETree(obj, 'ClothInit', 1)
compound = XSI.AddICECompoundNode('ClothInitShape', str(tree))
XSI.ConnectICENodes('{}.port1'.format(tree), '{}.execute'.format(compound))
XSI.SetValue('{}.Reference'.format(compound),
ICETree.ReplaceModelNameByThisModel(target, obj.Model), '')
def bbppTransformation_RebuildLayout( inPPG ):
oPlugin = XSI.Plugins("bbppTransformationPlugin");
oPluginPath = oPlugin.OriginPath;
oTrunkedPath = oPluginPath.split("Application\\");
oPicturePath = oTrunkedPath[0]+"Data\Pictures\Barbatruc.bmp";
oAnimEnum = ["Static",0,"Animated",1]
oLayout = inPPG.PPGLayout
oLayout.Clear()
oItem = oLayout.AddEnumControl( "BarbatrucPicture", null,"", constants.siControlBitmap )
oItem.SetAttribute(constants.siUINoLabel,true);
oItem.SetAttribute(constants.siUIFilePath,oPicturePath);
oLayout.AddGroup("Transformation Type")
oItem = oLayout.AddEnumControl("AnimatedTransformation",oAnimEnum,"",constants.siControlCombo)
oItem.SetAttribute(constants.siUINoLabel,1)
oLayout.EndGroup()
oLayout.AddGroup("Static Geometry")
oLayout.AddRow()
oLayout.AddItem("StartGeometryStatic","Start")
oLayout.AddButton("PickStartGeometryStatic","Pick")
oLayout.EndRow()
oLayout.AddRow()
oLayout.AddItem("EndGeometryStatic","End")
oLayout.AddButton("PickEndGeometryStatic","Pick")
oLayout.EndRow()
oLayout.EndGroup()
if inPPG.Parameters("AnimatedTransformation").Value:
oLayout.AddGroup("Animated Geometry")
oLayout.AddRow()
oLayout.AddItem("StartGeometryAnimated","Start")
oLayout.AddButton("PickStartGeometryAnimated","Pick")
oLayout.EndRow()
oLayout.AddRow()
oLayout.AddItem("EndGeometryAnimated","End")
oLayout.AddButton("PickEndGeometryAnimated","Pick")
oLayout.EndRow()
oLayout.EndGroup()
oLayout.AddGroup("Color")
oItem = oLayout.AddColor( "ColorR", "",true )
oItem.SetAttribute( "NoLabel", true )
oLayout.AddItem("ColorVariance","Variance")
oLayout.EndGroup()
oLayout.AddGroup("Time Control")
oLayout.AddItem("StartFrame","Start")
oLayout.AddItem("EndFrame","End")
oLayout.EndGroup()
oLayout.AddGroup("Correspondance Points")
oLayout.AddRow()
oItem = oLayout.AddButton("CreateCorrespondancePoints","Create Points")
oItem.SetAttribute(constants.siUICY,60)
oItem.SetAttribute(constants.siUICX,150)
oItem = oLayout.AddButton("DeleteCorrespondancePoints","Delete Points")
oItem.SetAttribute(constants.siUICY,60)
oItem.SetAttribute(constants.siUICX,150)
oLayout.EndRow()
oLayout.EndGroup()
oLayout.AddGroup("Output Mesh")
oItem = oLayout.AddButton("BuildOutputMesh","Build")
oItem.SetAttribute(constants.siUIAlignCenter,1)
oItem.SetAttribute(constants.siUICX,300)
oItem.SetAttribute(constants.siUICY,60)
oLayout.EndGroup()
def Cloth_CorrectiveSmooth_Execute(obj):
XSI.LogMessage("Cloth_CorrectiveSmooth called...")
correct.Correct(obj,"Smooth")
def GetSubdividedMesh(mesh):
op = XSI.ApplyOp("MeshSubdivide", mesh)
subd = op(0).Parent3DObject
subd.Name = mesh.name + "_Subdivided"
return subd
def Cloth_CorrectiveShape_Execute(obj):
XSI.LogMessage("Cloth_CorrectiveShape called...")
correct.Correct(obj,"Shape")
def Cloth_GetHelpPage(context):
XSI.LogMessage('Cloth_Tools Help Page not implemented !')
def Cloth_Rigger_BuildCloth_OnClicked():
for prop in PPG.Inspected:
XSI.Cloth_Rig(prop)
