def writeToGroup(self, group):
animset = sfm.GetCurrentAnimationSet()
shot = sfm.GetCurrentShot()
rootDag = sfmUtils.FindFirstDag([
"RootTransform", "rootTransform", "roottransform", "Roottransform"
])
suffix = self.createSuffix(self.target)
groupAddStringAttribute(group, name_targetname, self.target)
group.SetValue(name_boxsize, self.boxsize)
group.SetValue(name_boxcenter, self.boxcenter)
group.SetValue(name_margin, float(self.margin))
group.SetValue(name_mass, float(self.mass))
self.handle = sfm.CreateRigHandle(name_handle + suffix,
group=group.GetName())
#position the handle at the box center
bonedag = sfm.FindDag(self.target)
CenterTransform = PosQuatToTransform(self.boxcenter,
vs.Quaternion(0, 0, 0, 1))
ResultTransform = vs.matrix3x4_t()
vs.ConcatTransforms(bonedag.GetAbsTransform(), CenterTransform,
ResultTransform)
self.handle.SetAbsTransform(ResultTransform)
sfmUtils.Parent(self.handle, rootDag)
sfm.ParentConstraint(name_handle + suffix, self.target, mo=True)
self.force = sfm.CreateRigHandle(name_force + suffix,
group=group.GetName())
self.force.SetAbsTransform(self.handle.GetAbsTransform())
sfmUtils.Parent(self.force, self.handle)
shapeval = 0
if self.shape == "sphere":
shapeval = 1
groupCreateControlledValue(group, name_shape + suffix, shapeval,
animset, shot)
kineval = 0
if self.mass == 0:
kineval = 1
groupCreateControlledValue(group, name_kinematic + suffix, kineval,
animset, shot)
groupCreateControlledValue(group, name_bounce + suffix, self.bounce,
animset, shot)
groupCreateControlledValue(group, name_friction + suffix,
self.friction, animset, shot)
groupCreateControlledValue(group, name_lindamp + suffix, self.lindamp,
animset, shot)
groupCreateControlledValue(group, name_rotdamp + suffix, self.rotdamp,
animset, shot)
def writeToGroup(self, group):
animset = sfm.GetCurrentAnimationSet()
shot = sfm.GetCurrentShot()
rootDag = sfmUtils.FindFirstDag([
"RootTransform", "rootTransform", "roottransform", "Roottransform"
])
suffix = self.createSuffix(self.constype, self.bodya, self.bodyb)
groupAddStringAttribute(group, name_typename, self.constype)
groupAddStringAttribute(group, name_bodya, self.bodya)
groupAddStringAttribute(group, name_bodyb, self.bodyb)
self.handle = sfm.CreateRigHandle(name_handle + suffix,
group=group.GetName())
#position the handle at bodya plus some offset
daga = sfm.FindDag(self.bodya)
dagb = sfm.FindDag(self.bodyb)
ResultTransform = vs.matrix3x4_t()
if (self.pos is None):
#placing pos at the same spot as bodyb is usually a good guess
ResultTransform = PosQuatToTransform(dagb.GetAbsPosition(),
daga.GetAbsOrientation())
else:
OffsetTransform = PosQuatToTransform(self.pos,
vs.Quaternion(0, 0, 0, 1))
vs.ConcatTransforms(daga.GetAbsTransform(), OffsetTransform,
ResultTransform)
#end
self.handle.SetAbsTransform(ResultTransform)
sfmUtils.Parent(self.handle, daga)
if (self.constype == "cone"):
groupCreateControlledValue(group, name_rotx + suffix,
self.rotx / 180.0, animset, shot)
groupCreateControlledValue(group, name_roty + suffix,
self.roty / 180.0, animset, shot)
groupCreateControlledValue(group, name_twist + suffix,
self.twist / 180.0, animset, shot)
def readFromGroup(self, group, time):
animset = group.FindAnimationSet(True)
shot = sfm.GetCurrentShot()
self.boneprefix = group.GetValue(name_boneprefix)
suffix = self.createSuffix(animset.GetName(), self.boneprefix)
self.daglist = list()
for bone in group.GetValue(name_nodelist):
dag = sfm.FindDag(animset.GetName() + ":" +
bone.GetValue(name_nodename))
pos, quat = TransformToPosQuat(GetAbsTransformAtTime(dag, time))
self.nodelist.append((bone.GetValue(name_nodename),
bone.GetValue(name_nodemass), pos))
self.daglist.append(dag)
#end
for link in group.GetValue(name_linklist):
self.linklist.append((link.GetValue("a"), link.GetValue("b")))
#end
for face in group.GetValue(name_facelist):
self.facelist.append((face.GetValue("a"), face.GetValue("b"),
face.GetValue("c"), face.GetValue("d")))
#end
self.margin = group.GetValue(name_margin)
self.mass = group.GetValue(name_mass)
self.stretch = groupGetControlledValueAtTime(group,
name_stretch + suffix,
time)
self.shear = groupGetControlledValueAtTime(group, name_shear + suffix,
time)
self.bend = groupGetControlledValueAtTime(group, name_bend + suffix,
time)
self.damp = groupGetControlledValueAtTime(group, name_lindamp + suffix,
time)
self.friction = groupGetControlledValueAtTime(group,
name_friction + suffix,
time)
#end
#end
def WriteFile(fileName, scale):
shot = sfm.GetCurrentShot()
animSet = sfm.GetCurrentAnimationSet()
dag = sfm.FindDag("transform")
if dag == None:
SetError("Selected animation set does not have transform DAG node.")
return False
curFrame = 0
fps = sfmApp.GetFramesPerSecond()
frameTime = fps
if not 0 == frameTime:
frameTime = 1.0 / float(frameTime)
frameCount = shot.GetDuration().CurrentFrame(vs.DmeFramerate_t(fps))
file = open(fileName, 'wb')
if not file:
SetError('Could not open file ' + fileName + ' for writing')
return False
oldFrame = sfm.GetCurrentFrame()
try:
WriteHeader(file, frameCount, frameTime)
while curFrame < frameCount:
sfm.SetCurrentFrame(curFrame)
loc = sfm.GetPosition("transform", space="World")
rot = sfm.GetRotation("transform", space="World")
X = -loc[1] * scale
Y = loc[2] * scale
Z = -loc[0] * scale
ZR = -rot[0] #*RAD2DEG
XR = -rot[1] #*RAD2DEG
YR = rot[2] #*RAD2DEG
ZR = LimDeg(ZR)
XR = LimDeg(XR)
YR = LimDeg(YR)
S = "" + FloatToBvhString(X) + " " + FloatToBvhString(
Y) + " " + FloatToBvhString(Z) + " " + FloatToBvhString(
ZR) + " " + FloatToBvhString(XR) + " " + FloatToBvhString(
YR) + "\n"
file.write(S)
curFrame += 1
finally:
file.close()
sfm.SetCurrentFrame(oldFrame)
if not curFrame == frameCount:
SetError("Could not write all frames.")
return False
return True