コード例 #1
0
ファイル: dagutils.py プロジェクト: Andrej730/python-sfm
def SetTransformAtTime(dag, time, transform):
	pos = vs.Vector()
	quat = vs.Quaternion()
	vs.MatrixPosition(transform, pos)
	vs.MatrixQuaternion(transform, quat)
	SetValueAtTime(dag.FindTransformControl().GetPositionChannel(), time, pos)
	SetValueAtTime(dag.FindTransformControl().GetOrientationChannel(), time, quat)
コード例 #2
0
ファイル: dagutils.py プロジェクト: Andrej730/python-sfm
def TransformToPosQuat(transform):
	pos = vs.Vector()
	quat = vs.Quaternion()
	vs.MatrixPosition(transform, pos)
	vs.MatrixQuaternion(transform, quat)

	return pos, quat
コード例 #3
0
ファイル: dagutils.py プロジェクト: Andrej730/python-sfm
def TransformToPosEuler(transform):
	pos = vs.Vector()
	quat = vs.Quaternion()
	vs.MatrixPosition(transform, pos)
	vs.MatrixQuaternion(transform, quat)

	euler = vs.RadianEuler()
	vs.QuaternionAngles(quat, euler)

	return pos, euler
コード例 #4
0
    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)
コード例 #5
0
    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)
コード例 #6
0
def listToQuat(tup):
    return vs.Quaternion(tup[0], tup[1], tup[2], tup[3])
コード例 #7
0
 def setDefaults(self):
     self.constype = "point"
     self.pos = None
     self.quat = vs.Quaternion(0, 0, 0, 1)
     self.bodya = ""
     self.bodyb = ""
コード例 #8
0
ファイル: bullet_utils.py プロジェクト: Andrej730/python-sfm
def btToVsQuaternion(quat):
    return vs.Quaternion(quat.x(), quat.y(), quat.z(), quat.w())