def CreateSkeletonCloud(model):
cloud = model.FindChild('ICE_Skeleton')
if cloud:
XSI.DeleteObj(cloud)
cloud = model.AddPrimitive('PointCloud', 'ICE_Skeleton')
tree = ICETree.CreateICETree(cloud, 'Emit', 0)
emit = XSI.AddICECompoundNode('IRBuildSkeleton', tree)
XSI.ConnectICENodes('{}.port1'.format(tree), '{}.Execute'.format(emit))
tree = ICETree.CreateICETree(cloud, 'Deform', 2)
deform = XSI.AddICECompoundNode('IRDeformSkeleton', tree)
XSI.ConnectICENodes('{}.port1'.format(tree), '{}.Execute'.format(deform))
return cloud
def Symmetrize(self):
if self.side == MIDDLE:
XSI.LogMessage(
'[BuildRigElement] : Can\'t symmetrize middle elements !')
return None
sibling = IRSkeleton(None, self.GetSymParent(self.parent), self.name,
self.mode, self.GetOppositeSide(), self.divisions,
self.mirror, self.suffix)
sibling.position = self.position
sibling.rotation = self.rotation
sibling.sibling = self
self.sibling = sibling
sibling.CreateGuide()
# add symmetrize element data ICE Tree
tree = ICETree.CreateICETree(sibling.crv, 'SymmetyrizeDatas', 2)
node = XSI.AddICECompoundNode('IRSymetrizeSkeletonDatas', str(tree))
XSI.ConnectICENodes('{}.port1'.format(tree), '{}.Execute'.format(node))
name = ICETree.ReplaceModelNameByThisModel(self.crv, self.model)
XSI.SetValue('{}.Reference'.format(node), name, '')
return sibling
def CreateMuscleMesh(model, deform=True):
root = model.FindChild("Muscles")
if not root:
root = model.AddNull("Muscles")
static = model.FindChild("Muscle_Static")
if not static:
static = root.AddPrimitive("EmptyPolygonMesh")
static.Name = "Muscle_Static"
tree = tre.CreateICETree(static, "Init", 0)
build = XSI.AddICECompoundNode("IRBuildMuscles", str(tree))
XSI.ConnectICENodes(str(tree) + ".port1", str(build) + ".Execute")
deform = model.FindChild("Muscle_Deform")
if not deform:
deform = root.AddPrimitive("EmptyPolygonMesh")
deform.Name = "Muscle_Deform"
'''
mesh = model.AddPolymesh("PointCloud","ICE_Muscles")
tree = tre.CreateICETree(cloud,"Emit",0)
muscle = xsi.AddICECompoundNode("MusclesFromNull", str(tree))
xsi.ConnectICENodes(str(tree)+".port1",str(muscle)+".Execute")
tree = tre.CreateICETree(cloud,"Deform",2)
bind = xsi.AddICECompoundNode("BindMusclesToSkeleton", str(tree))
xsi.ConnectICENodes(str(tree)+".port1", str(bind)+".Execute")
'''
return None
def Symmetrize(self):
if self.side == MIDDLE:
XSI.LogMessage(
"[ICERig] : Can't symmetrize middle elements ---> aborted...!")
return None
sibling = IRMuscle(None, self.GetSymParent(self.parent), self.name,
self.GetOppositeSide(), self.mirror, self.suffix)
sibling.position = self.position
sibling.rotation = self.rotation
sibling.sibling = self
self.sibling = sibling
sibling.CreateGuide()
# add symmetrize element data ICE Tree
t = tre.CreateICETree(sibling.crv, "SymmetrizeMuscleGuide", 2)
n = XSI.AddICECompoundNode("IRSymetrizeMuscleDatas", str(t))
XSI.ConnectICENodes(str(t) + ".port1", str(n) + ".Execute")
name = tre.ReplaceModelNameByThisModel(self.crv, self.model)
XSI.SetValue(str(n) + ".Reference", name, "")
return sibling
def applyColorizePointTree(model,obj,id):
oIceTree = XSI.ApplyOp("ICETree", obj, "siNode", "", "", 0)
oColorize = XSI.AddICECompoundNode("bbpp Colorize Point", oIceTree)
XSI.ConnectICENodes(str(oIceTree) + ".port1", str(oColorize) + ".Execute")
oGet1 = XSI.AddICENode("GetDataNode", oIceTree)
XSI.SetValue(str(oGet1) + ".reference", model.FullName)
XSI.ConnectICENodes(str(oColorize) + ".TransformationModel", str(oGet1) + ".outname")
XSI.SetValue(str(oColorize) + ".PointID", id, "")
def ReorderCurveGroup(model, _type):
""" Reorder curve group
:param Model model: SDK Model object
:param int _type: rig element type
"""
if _type not in [ID_SKELETON, ID_MUSCLE]:
return
if _type == ID_SKELETON:
emit_ref = 'this_model.Guide_Curves'
prop_name = 'RigElement'
grp_name = 'Guide_Curves'
elif _type == ID_MUSCLE:
emit_ref = 'this_model.Muscle_Curves'
prop_name = 'MuscleElement'
grp_name = 'Muscle_Curves'
# get all guide curves
guides = [
g for g in model.FindChildren2('*_Crv', '', constants.siCurveFamily,
True) if g.Properties(prop_name)
]
if guides and len(guides) > 1:
# get guide curve group
grp = model.Groups(grp_name)
cloud = model.AddPrimitive('PointCloud', 'ICE_Correct')
tree = ICETree.CreateICETree(cloud, 'Emit', 0)
emit = XSI.AddICECompoundNode('IRCorrectEmit', tree)
XSI.ConnectICENodes('{}.port1'.format(tree), '{}.Execute'.format(emit))
XSI.SetValue('{}.Reference'.format(emit), emit_ref, None)
# get point cloud data
cloud_geom = cloud.ActivePrimitive.Geometry
positions_attr = cloud_geom.GetICEAttributeFromName('PointPosition')
positions = positions_attr.DataArray
indices_attr = cloud_geom.GetICEAttributeFromName('ShowGuideID')
indices = indices_attr.DataArray
sorted_guides = [g for g in guides]
for guide in guides:
geom = guide.ActivePrimitive.Geometry
closest_indices = [
FindClosestIndex(p.Position, positions, indices)
for p in geom.Points
]
r = max(set(closest_indices), key=closest_indices.count)
sorted_guides[r] = guide
if grp:
XSI.DeleteObj(grp)
Utils.GroupSetup(model, sorted_guides, grp_name)
XSI.DeleteObj(cloud)
def CreateMuscleCloud(model, deform=False):
cloud = model.FindChild("ICE_Muscles")
if cloud:
XSI.LogMessage(
"[CreateMuscleCloud] Muscle Cloud already exists : skipped....")
return cloud
cloud = model.AddPrimitive("PointCloud", "ICE_Muscles")
tree = tre.CreateICETree(cloud, "Emit", 0)
muscle = XSI.AddICECompoundNode("IRMuscleCloudInit", str(tree))
XSI.ConnectICENodes(str(tree) + ".port1", str(muscle) + ".Execute")
tree = tre.CreateICETree(cloud, "Deform", 2)
bind = XSI.AddICECompoundNode("BindMusclesToSkeleton", str(tree))
XSI.ConnectICENodes(str(tree) + ".port1", str(bind) + ".Execute")
return cloud
def Rig(self):
cloth_op = GetClothOperator(self.object)
if not cloth_op:
XSIUIToolKit.MsgBox(
'No Syflex Operator on "{}"+"'.format(self.object),
constants.siMsgCritical, 'ClothBuilder')
return
collide_op = XSI.ApplyOperator(
'syCollide', ';'.join([
cloth_op.FullName, self.pntCluster.FullName,
self.collider.ActivePrimitive.FullName,
self.collider.Kinematics.FullName, self.polyCluster.FullName,
self.object.Kinematics.FullName
]))
collide_op.Parameters('Reset').Value = True
collide_op.Parameters('ExtEnvelope').Value = 0.05
collide_op.Parameters('IntEnvelope').Value = -0.05
collide_op.Parameters('Friction').Value = 0.2
collide_op.Parameters('Damp').Value = 0.01
# if this collider isn't a cloth object
# nor extra collider object we add pre roll setup
if not self.collider.Properties('Cloth_Rigger') and not self.extra:
# create init ICE tree
trees = self.collider.ActivePrimitive.ICETrees
if not trees.Find('InitCollide'):
tree = ICETree.CreateIceTree(self.collider, 'InitCollide', 1)
compound = XSI.AddICECompoundNode('ClothInitTarget', str(tree))
XSI.ConnectICENodes('{}.port1'.format(tree),
'{}.Execute'.format(compound))
# create pre-roll ICE tree
if not trees.Find('PreRollCollide'):
tree = ICETree.CreateIceTree(self.collider, 'PreRollCollide',
3)
compound = XSI.AddICECompoundNode('ClothTargetPreRoll',
str(tree))
XSI.ConnectICENodes('{}.port1'.format(tree),
'{}.Execute'.format(compound))
def Cloth_ApplyStiffnessOp(obj, target):
tree = ICETree.CreateICETree(obj, 'ClothStiffness', 1)
compound = XSI.AddICECompoundNode('ClothSetMimicStiffness', str(tree))
XSI.ConnectICENodes('{}.port1'.format(tree), '{}.execute'.format(compound))
if obj.Model.FullName == target.Model.FullName:
XSI.SetValue('{}.Velocity_Driver_Reference'.format(compound),
ICETree.ReplaceModelNameByThisModel(target), '')
else:
XSI.SetValue('{}.Velocity_Driver_Reference'.format(compound),
target.FullName, '')
def CreateFitter(ppg, obj, mesh):
tree = ICETree.CreateICETree(obj, 'Fitter', 2)
node = XSI.AddICECompoundNode('IRFitSkeleton', str(tree))
XSI.ConnectICENodes('{}.port1'.format(tree), '{}.Execute'.format(node))
if obj and mesh:
name = ICETree.ReplaceModelNameByThisModel(mesh, obj.Model)
XSI.SetValue('{}.Reference'.format(node), name, '')
else:
XSI.LogMessage('No geometry set, Fitter may be invalid',
constants.siWarningMsg)
return tree
def MergeRigCloud(model, clouds, name):
cloud = model.AddPrimitive("PointCloud", name)
tree = XSI.ApplyOp("ICETree", cloud, "siNode", "", "", 2)
idx = 1
for c in clouds:
merge = XSI.AddICECompoundNode("MergeRigPointCloud", str(tree))
XSI.AddPortToICENode(str(tree) + ".port" + str(idx), "siNodePortDataInsertionLocationAfter")
XSI.ConnectICENodes(str(tree) + ".port" + str(idx), str(merge) + ".execute")
get = XSI.AddICENode("GetDataNode", str(tree))
XSI.SetValue(str(get) + ".reference", ReplaceModelNameByThisModel(c), "")
XSI.ConnectICENodes(str(merge) + ".Cloud", str(get) + ".outname")
idx += 1
def bbppTransformation_CreateCorrespondanceIceTree(obj,group,map):
oModel = PPG.Inspected(0).Parent3DObject
oIceTree = XSI.ApplyOp("ICETree", obj, "siNode", "", "", 0)
oCorrespondance = XSI.AddICECompoundNode("bbpp Correspondance Map", oIceTree)
XSI.ConnectICENodes(str(oIceTree) + ".port1", str(oCorrespondance) + ".Execute")
oGet1 = XSI.AddICENode("GetDataNode", oIceTree)
oGet2 = XSI.AddICENode("GetDataNode", oIceTree)
#sGroupName = replaceModelNameByThisModel(oModel,group.FullName)
XSI.SetValue(str(oGet1) + ".reference", group.FullName)
XSI.ConnectICENodes(str(oCorrespondance) + ".PointsGroup", str(oGet1) + ".outname")
sMapName = replaceObjectNameBySelf(obj,map.FullName)
XSI.SetValue(str(oGet2) + ".reference", sMapName + ".Colors")
XSI.ConnectICENodes(str(oCorrespondance) + ".ColorMap", str(oGet2) + ".outname")
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 BindSkinToSkeleton(model, skin):
# prepare mesh
Utils.GetWeightMap(skin, 'SmoothWeightMap', 1, 0, 1)
Utils.GetWeightMap(skin, 'SearchMap', 1, 0, 1)
Utils.GetWeightMap(skin, 'StretchMap', 1, 0, 1)
Utils.GetWeightMap(skin, 'BulgeMap', 1, 0, 1)
Utils.GetWeightMap(skin, 'RaycastMap', 0, 0, 1)
Utils.GetWeightMap(skin, 'MuscleMap', 0, 0, 1)
# get weights
tree = ICETree.CreateICETree(skin, 'GetWeights', 0)
compound = XSI.AddICECompoundNode('IRGetSkeletonWeights', str(tree))
XSI.ConnectICENodes('{}.port1'.format(tree), '{}.execute'.format(compound))
# no deform
'''
def CreateGuide(self):
if self.CheckElementExist():
XSI.LogMessage(
'[CreateSkeletonElement] {}_Crv already exist !'.format(
self.fullname), constants.siWarning)
return False
if self.mirror:
self.crv = Utils.BuildCurveOnSymmetrizedPositions(self.position)
else:
self.crv = Utils.BuildCurveOnPositions(self.position)
self.cluster = Utils.CreateAlwaysCompleteCluster(
self.crv, constants.siVertexCluster, 'ElementData')
Utils.GetWeightMap(self.crv, 'WidthMap', 0.01, 0, 1.0, self.cluster)
Utils.GetWeightMap(self.crv, 'DepthMap', 0.01, 0, 1.0, self.cluster)
Utils.GetWeightMap(self.crv, 'CollideMap', 1.0, 0.0, 1.0, self.cluster)
Utils.GetWeightMap(self.crv, 'StickMap', 1.0, 0.0, 1.0, self.cluster)
self.cluster.AddProperty('SimpleDeformShape', 0, 'Offset')
# freeze curve
XSI.FreezeObj(self.crv)
# create self-symmetrize node
if self.mirror:
tree = ICETree.CreateICETree(self.crv, 'SelfSymmetrize', 2)
node = XSI.AddICECompoundNode('IRSelfSymmetrizeSkeletonDatas',
str(tree))
XSI.AddPortToICENode('{}.port1'.format(tree),
'siNodePortDataInsertionLocationAfter')
XSI.ConnectICENodes('{}.port2'.format(tree),
'{}.Execute'.format(node))
self.root.AddChild(self.crv)
Utils.SetWireColor(self.crv, COLOR_SKELETON_R, COLOR_SKELETON_G,
COLOR_SKELETON_B)
self.crv.Name = self.fullname + self.suffix
# add rig element property
self.prop = self.crv.AddProperty('RigElement')
self.prop.Parameters('ElementType').Value = self.mode
self.prop.Parameters('ElementName').Value = self.name
self.prop.Parameters('Divisions').Value = self.divisions
self.prop.Parameters('Side').Value = self.side
Utils.GroupSetup(self.model, [self.crv], 'Guide_Curves')
return True
def Cloth_GetExtraCollider(prop):
obj = prop.Parent3DObject
parent = obj.Parent3DObject
model = obj.Model
collide_mesh = model.FindChild('ExtraCollider')
if not collide_mesh:
collide_mesh = parent.AddPrimitive('EmptyPolygonMesh', 'ExtraCollider')
tree = ICETree.CreateICETree(collide_mesh, 'ClothExtraCollider', 0)
compound = XSI.AddICECompoundNode('ClothExtraCollider', str(tree))
XSI.ConnectICENodes('{}.port1'.format(tree),
'{}.execute'.format(compound))
extra = Cloth.Collider(obj, collide_mesh, True)
extra.GetPntCluster()
extra.GetPolyCluster()
extra.Rig()
return extra
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 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 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 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 bbppTransformation_BuildOutputMesh_OnClicked( ):
oPPG = PPG.Inspected(0)
oModel = oPPG.Parent3DObject
oStartCloud = oModel.FindChild("StartCloud")
oEndCloud = oModel.FindChild("EndCloud")
oStartGrp = oModel.Groups("Start");
oEndGrp = oModel.Groups("End");
# does geometry exists?
oStartGeomStatic = bbppTransformation_StartGeometryStaticExist(oPPG)
oEndGeomStatic = bbppTransformation_EndGeometryStaticExist(oPPG)
if not oStartGeomStatic or not oEndGeomStatic:
XSI.LogMessage("bbppTransformation Geometry Does not exist ---> Can't build Output Mesh!", constants.siError)
return
if oPPG.AnimatedTransformation.Value:
oStartGeomAnimated = bbppTransformation_StartGeometryAnimatedExist(oPPG)
oEndGeomAnimated = bbppTransformation_EndGeometryAnimatedExist(oPPG)
if not oStartGeomAnimated or not oEndGeomAnimated:
XSI.LogMessage("bbppTransformation Geometry Does not exist ---> Can't build Output Mesh!", constants.siError)
return
# create start geometry point cloud
if not oStartCloud:
# create emission node
oStartCloud = XSI.GetPrim("PointCloud", "StartCloud", oModel)
oIceTree = XSI.ApplyOp("ICETree", oStartCloud, "siNode", "", "", 0)
oEmit = XSI.AddICECompoundNode("bbpp Emit From Points", oIceTree)
XSI.ConnectICENodes(str(oIceTree) + ".port1", str(oEmit) + ".add")
oGet1 = XSI.AddICENode("GetDataNode", oIceTree)
XSI.SetValue(str(oGet1) + ".reference", oStartGeomStatic.FullName)
XSI.ConnectICENodes(str(oEmit) + ".Emiter", str(oGet1) + ".outname")
XSI.SetValue(str(oEmit) + ".Color_red", 0.9)
XSI.SetValue(str(oEmit) + ".Color_green", 0.4)
XSI.SetValue(str(oEmit) + ".Color_blue", 0.1)
# create blend node
oBlend = XSI.AddICECompoundNode("bbpp Blend Cloud", oIceTree)
XSI.AddPortToICENode(str(oIceTree) + ".port1", "siNodePortDataInsertionLocationAfter")
XSI.ConnectICENodes(str(oIceTree) + ".port2", str(oBlend) + ".Execute")
oGet2 = XSI.AddICENode("GetDataNode", oIceTree)
XSI.SetValue(str(oGet2) + ".reference", str(oStartGrp))
XSI.ConnectICENodes(str(oBlend) + ".Start_Cloud", str(oGet2) + ".outname")
oGet3 = XSI.AddICENode("GetDataNode", oIceTree)
XSI.SetValue(str(oGet3) + ".reference", str(oEndGrp))
XSI.ConnectICENodes(str(oBlend) + ".End_Cloud", str(oGet3) + ".outname")
oGet4 = XSI.AddICENode("GetDataNode", oIceTree)
XSI.SetValue(str(oGet4) + ".reference", oEndGeomStatic.FullName)
XSI.ConnectICENodes(str(oBlend) + ".Target_Geometry", str(oGet4) + ".value")
# connect timer
oTimer = XSI.AddICECompoundNode("bbpp Transformation Timer", oIceTree)
XSI.ConnectICENodes(str(oBlend) + ".Blend", str(oTimer) + ".Blend")
oGet5 = XSI.AddICENode("GetDataNode", oIceTree)
XSI.SetValue(str(oGet5) + ".reference", oPPG.StartFrame.FullName)
oGet6 = XSI.AddICENode("GetDataNode", oIceTree)
XSI.SetValue(str(oGet6) + ".reference", oPPG.EndFrame.FullName)
XSI.ConnectICENodes(str(oTimer) + ".Start_Frame", str(oGet5) + ".value")
XSI.ConnectICENodes(str(oTimer) + ".End_Frame", str(oGet6) + ".value")
# create end geometry point cloud
if not oEndCloud:
# create emission node
oEndCloud = XSI.GetPrim("PointCloud", "EndCloud", oModel)
oIceTree = XSI.ApplyOp("ICETree", oEndCloud, "siNode", "", "", 0)
oEmit = XSI.AddICECompoundNode("bbpp Emit From Points", oIceTree)
XSI.ConnectICENodes(str(oIceTree) + ".port1", str(oEmit) + ".add")
oGet1 = XSI.AddICENode("GetDataNode", oIceTree)
XSI.SetValue(str(oGet1) + ".reference", oEndGeomStatic.FullName)
XSI.ConnectICENodes(str(oEmit) + ".Emiter", str(oGet1) + ".outname")
XSI.SetValue(str(oEmit) + ".Color_red", 0.1)
XSI.SetValue(str(oEmit) + ".Color_green", 0.9)
XSI.SetValue(str(oEmit) + ".Color_blue", 0.4)
# create blend node
oBlend = XSI.AddICECompoundNode("bbpp Blend Cloud", oIceTree)
XSI.AddPortToICENode(str(oIceTree) + ".port1", "siNodePortDataInsertionLocationAfter")
XSI.ConnectICENodes(str(oIceTree) + ".port2", str(oBlend) + ".Execute")
oGet2 = XSI.AddICENode("GetDataNode", oIceTree)
XSI.SetValue(str(oGet2) + ".reference", str(oEndGrp))
XSI.ConnectICENodes(str(oBlend) + ".Start_Cloud", str(oGet2) + ".outname")
oGet3 = XSI.AddICENode("GetDataNode", oIceTree)
XSI.SetValue(str(oGet3) + ".reference", str(oStartGrp))
XSI.ConnectICENodes(str(oBlend) + ".End_Cloud", str(oGet3) + ".outname")
oGet4 = XSI.AddICENode("GetDataNode", oIceTree)
XSI.SetValue(str(oGet4) + ".reference", oStartGeomStatic.FullName)
XSI.ConnectICENodes(str(oBlend) + ".Target_Geometry", str(oGet4) + ".value")
# connect timer
oTimer = XSI.AddICECompoundNode("bbpp Transformation Timer", oIceTree)
XSI.ConnectICENodes(str(oBlend) + ".Blend", str(oTimer) + ".Blend")
oGet5 = XSI.AddICENode("GetDataNode", oIceTree)
XSI.SetValue(str(oGet5) + ".reference", oPPG.StartFrame.FullName)
oGet6 = XSI.AddICENode("GetDataNode", oIceTree)
XSI.SetValue(str(oGet6) + ".reference", oPPG.EndFrame.FullName)
XSI.ConnectICENodes(str(oTimer) + ".Start_Frame", str(oGet5) + ".value")
XSI.ConnectICENodes(str(oTimer) + ".End_Frame", str(oGet6) + ".value")
XSI.SetValue(str(oTimer) + ".Revert", True)
# create Blob Mesh
# delete it if already exists
bbppTransformation_BlobGeometryExist(oPPG)
XSI.SelectObj(str(oStartCloud) + "," + str(oEndCloud))
XSI.Create_Polygonizer_Polymesh()
oBlob = XSI.Selection(0)
oBlob.Name = "OutputMesh"
oModel.AddChild(oBlob)
oBlobOp = oBlob.ActivePrimitive.ConstructionHistory.Find("Polygonizer")
# create expression for in-between
#--------------------------------------
# detail
sStartFrame = oPPG.StartFrame.FullName
sEndFrame = oPPG.EndFrame.FullName
sTimelapse = sEndFrame+" - "+sStartFrame
oExpr = "(1 - sin(cond(FC>"+sStartFrame+",cond(Fc<"+sEndFrame+",(Fc - "+sStartFrame+")/("+sTimelapse+"),1),0)*180)) *2 + 2"
oBlobOp.Parameters("Detail").AddExpression(oExpr)
# blur isofield
oExpr = "sin(cond(FC>"+sStartFrame+",cond(Fc<"+sEndFrame+",(Fc - "+sStartFrame+")/("+sTimelapse+"),1),0)*180)/2"
oBlobOp.Parameters("BlurIsofieldStrength").AddExpression(oExpr)
# smooth mesh
oExpr = "sin(cond(FC>"+sStartFrame+",cond(Fc<"+sEndFrame+",(Fc - "+sStartFrame+")/("+sTimelapse+"),1),0)*180)*4+2"
oBlobOp.Parameters("SmoothMeshStrength").AddExpression(oExpr)
# isolevel
oBlobOp.Parameters("Isolevel").Value = 1
def GatherSkinDataOnSelf(skin):
all_clusters = []
model = skin.Model
elements = CollectSkeletonElements(model)
for element in elements:
# check cluster and weight map existence
cluster_name = '{}_Cls'.format(element.ElementName.Value)
cluster = skin.ActivePrimitive.Geometry.Clusters(cluster_name)
if not cluster:
cluster = Utils.CreateCompleteButNotAlwaysCluster(
skin, constants.siVertexCluster, cluster_name)
all_clusters.append(cluster)
wm = Utils.GetWeightMap(skin, 'WeightMap', 1, 0, 1, cluster)
# create build array and set data nodes
tree = ICETree.CreateRigIceTree(skin, 'GatherDatas', 1)
setter = XSI.AddICECompoundNode('Set Data', tree)
XSI.SetValue(
'{}.Reference'.format(setter),
'Self.__ElementWeights',
)
build = XSI.AddICENode('BuildArrayNode', tree)
XSI.ConnectICENodes('{}.value'.format(setter), '{}.array'.format(build))
XSI.ConnectICENodes('{}.port1'.format(tree), '{}.execute'.format(setter))
idx = 1
# connect each element map
for cluster in all_clusters:
getter = XSI.AddICECompoundNode('GetRigElementWeight', tree)
if idx > 1:
XSI.AddPortToICENode('{}.value{}'.format(build, idx - 1),
'siNodePortDataInsertionLocationAfter')
XSI.SetValue('{}.reference'.format(getter),
'Self.cls.{}'.format(cluster.Name), "")
XSI.ConnectICENodes('{}.value{}'.format(build, idx),
'{}.Weight'.format(getter))
idx += 1
# check for weight maps
Utils.GetWeightMap(skin, 'SmoothWeightMap', 1, 0, 1)
Utils.GetWeightMap(skin, 'SearchMap', 1, 0, 1)
Utils.GetWeightMap(skin, 'BulgeMap', 1, 0, 1)
Utils.GetWeightMap(skin, 'StretchMap', 1, 0, 1)
# get smooth weight map
getter = XSI.AddICENode('GetDataNode', tree)
XSI.SetValue('{}.reference'.format(getter),
'Self.cls.WeightMapCls.SmoothWeightMap.Weights', '')
XSI.AddPortToICENode('{}.Value'.format(setter),
'siNodePortDataInsertionLocationAfter')
XSI.SetValue('{}.Reference1'.format(setter), 'Self.__SmoothWeights', '')
XSI.ConnectICENodes('{}.value1'.format(setter), '{}.value'.format(getter))
# get search map
getter = XSI.AddICENode('GetDataNode', tree)
XSI.SetValue('{}.reference'.format(getter),
'Self.cls.WeightMapCls.SearchMap.Weights', '')
XSI.AddPortToICENode('{}.Value1'.format(setter),
'siNodePortDataInsertionLocationAfter')
XSI.SetValue('{}.Reference2'.format(setter), 'Self.__PerPointSearch', '')
XSI.ConnectICENodes('{}.value2'.format(setter), '{}.value'.format(getter))
# get stretch map
getter = XSI.AddICENode('GetDataNode', tree)
XSI.SetValue('{}.reference'.format(getter),
'Self.cls.WeightMapCls.StretchMap.Weights', '')
XSI.AddPortToICENode('{}.Value2'.format(setter),
'siNodePortDataInsertionLocationAfter')
XSI.SetValue('{}.Reference3'.format(setter), 'Self.__PerPointStretch', '')
XSI.ConnectICENodes('{}.value3'.format(setter), '{}.value'.format(getter))
# get bulge map
getter = XSI.AddICENode('GetDataNode', tree)
XSI.SetValue('{}.reference'.format(getter),
'Self.cls.WeightMapCls.BulgeMap.Weights', '')
XSI.AddPortToICENode('{}.Value3'.format(setter),
'siNodePortDataInsertionLocationAfter')
XSI.SetValue('{}.Reference4'.format(setter), 'Self.__PerPointBulge', '')
XSI.ConnectICENodes('{}.value4'.format(setter), '{}.value'.format(getter))
# show affected points
affected = XSI.AddICECompoundNode('ShowRigAffectedPoints', tree)
XSI.AddPortToICENode('{}.port1'.format(tree),
'siNodePortDataInsertionLocationAfter')
XSI.ConnectICENodes('{}.port2'.format(tree), '{}.Execute'.format(affected))
