Ejemplo n.º 1
0
    def expMap(self, p):
        theta = p.mag()

        if (fabs(theta) < 0.00001):
            convFactor = 0.0
        else:
            convFactor = sin(theta) / theta
        p1 = Piavca.Quat()
        p2 = Piavca.Quat()
        p1[0] = cos(theta)
        p1[1] = p[0] * convFactor
        p1[2] = p[1] * convFactor
        p1[3] = p[2] * convFactor

        p2[0] = p1[0] * self.coordAxes[0][0] + p1[1] * self.coordAxes[1][0]
        p2[0] += p1[2] * self.coordAxes[2][0] + p1[3] * self.coordAxes[3][0]

        p2[1] = p1[0] * self.coordAxes[0][1] + p1[1] * self.coordAxes[1][1]
        p2[1] += p1[2] * self.coordAxes[2][1] + p1[3] * self.coordAxes[3][1]

        p2[2] = p1[0] * self.coordAxes[0][2] + p1[1] * self.coordAxes[1][2]
        p2[2] += p1[2] * self.coordAxes[2][2] + p1[3] * self.coordAxes[3][2]

        p2[3] = p1[0] * self.coordAxes[0][3] + p1[1] * self.coordAxes[1][3]
        p2[3] += p1[2] * self.coordAxes[2][3] + p1[3] * self.coordAxes[3][3]

        return p2
Ejemplo n.º 2
0
	def getValue(self):
		try:
			val = [float(self.texts[i].GetValue()) for i in range(self.dim)]
			val = Piavca.Quat(Piavca.degToRad(val[0]), Piavca.Vec(val[1], val[2], val[3]))
			return val
		except ValueError:
			return None
Ejemplo n.º 3
0
	def getTrackValue(self, trackid, time):
		i = self.jointmap[trackid]
		if i != None :
			v = Piavca.Vec(self.vecs[3*i], self.vecs[3*i+1], self.vecs[3*i+2])
			return  self.expmaps[i].expMap(v)
		else:
			return Piavca.Quat()
Ejemplo n.º 4
0
    def logMap(self, q):
        p1 = q
        if (p1[0] < 0.0):
            p1 = Piavca.Quat(-p1[0], -p1[1], -p1[2], -p1[3])

        p2 = Piavca.Quat(self._dot(p1, self.coordAxes[0]),
                         self._dot(p1, self.coordAxes[1]),
                         self._dot(p1, self.coordAxes[2]),
                         self._dot(p1, self.coordAxes[3]))
        p2.normalise()

        theta = acos(p2[0])
        if (fabs(theta) < 0.0001):
            convFactor = 0.0
        else:
            convFactor = theta / sin(theta)
        return Piavca.Vec(p2[1] * convFactor, p2[2] * convFactor,
                          p2[3] * convFactor)
Ejemplo n.º 5
0
    def __init__(self,
                 parent,
                 initial_position=Piavca.Vec(),
                 initial_rotation=Piavca.Quat()):
        PiavcaWXCanvas.PiavcaWXCanvasBase.__init__(self, parent)
        self.cameraPos = initial_position
        self.cameraRot = initial_rotation
        self.cameraPitch = 0.0
        self.cameraYaw = 0.0

        self.positionCallbacks = []
Ejemplo n.º 6
0
    def __init__(self, p):
        self.coordAxes = 4 * [Piavca.Quat()]
        if type(p) == type(Piavca.Quat()):
            self._calcCoordAxes(p)
            return
        q = Piavca.Quat(0.0, 0.0, 0.0, 0.0)
        for val in p:
            if (val[0] < 0.0):
                val = Piavca.Quat(-val[0], -val[1], -val[2], -val[3])
            q[0] += val[0] / len(p)
            q[1] += val[1] / len(p)
            q[2] += val[2] / len(p)
            q[3] += val[3] / len(p)
        q.normalise()

        u = Piavca.Vec(0.0, 0.0, 0.0)
        count = 0
        while 1:
            if count > 500:
                print "error", u, u.mag()
                if u.mag() < 0.001:
                    break
                raise "exceeded maximum iterations"
            count += 1

            self._calcCoordAxes(q)
            u = Piavca.Vec()
            for val in p:
                val = self.logMap(val)
                u += val / len(p)
            q = self.expMap(u)
            #print "curent iter",  u, q

            if u.mag() < 0.0005:
                break
        self._calcCoordAxes(q)
Ejemplo n.º 7
0
	def getParameterVal(self, name):
		if hasattr(self.motion, "get" + name):
			# print name, "set" + name
			if hasattr(self.motion, "set" + name):
				# print name
				if name[:len("Motion")] == "Motion":
					# print "found Motion in paramname"
					return None
				if name[:len("Weight")] == "Weight":
					weights = [0 for i in range(self.motion.getNumMotions())]
					for i in range(self.motion.getNumMotions()):
						motName = self.motion.getMotion(i).getName()
						weights[i] = (i, motName, self.motion.getWeight(i))
					return weights
				else:
					method = getattr(self.motion, "get" + name)
					# print "got method"
					value = method()
					# print "got value"
					# print name, value
					return value
		if name == "FloatValue" or name == "QuatValue" or name == "VecValue":
			core = Piavca.Core.getCore()
			indices = [i for i in range(core.getMinTrackId(), core.getMaxTrackId()+1)]
			names = [core.getTrackName(i) for i in indices]
			if name == "FloatValue":
				vals = [0.0 for i in indices]
				for i, track in enumerate(indices):
					if (not self.motion.isNull(track)) and self.motion.getTrackType(track) & Piavca.FLOAT_TYPE:
						vals[i] = self.motion.getFloatValueAtTime(track,0)
			if name == "VecValue":
				vals = [Piavca.Vec() for i in indices]
				for i, track in enumerate(indices):
					if (not self.motion.isNull(track)) and self.motion.getTrackType(track) & Piavca.VEC_TYPE:
						vals[i] = self.motion.getVecValueAtTime(track,0)
			if name == "QuatValue":
				vals = [Piavca.Quat() for i in indices]
				for i, track in enumerate(indices):
					if (not self.motion.isNull(track)) and self.motion.getTrackType(track) & Piavca.QUAT_TYPE:
						vals[i] = self.motion.getQuattValueAtTime(track,0)
		
			return zip(indices, names, vals)
		
		else:
			return None
Ejemplo n.º 8
0
    def _cross(self, q1, q2, q3):
        q = Piavca.Quat()
        q[0] = q1[1] * (q2[2] * q3[3] - q2[3] * q3[2])
        q[0] -= q1[2] * (q2[1] * q3[3] - q2[3] * q3[1])
        q[0] += q1[3] * (q2[1] * q3[2] - q2[2] * q3[1])

        q[1] = -q1[0] * (q2[2] * q3[3] - q2[3] * q3[2])
        q[1] += q1[2] * (q2[0] * q3[3] - q2[3] * q3[0])
        q[1] -= q1[3] * (q2[0] * q3[2] - q2[2] * q3[0])

        q[2] = q1[0] * (q2[1] * q3[3] - q2[3] * q3[1])
        q[2] -= q1[1] * (q2[0] * q3[3] - q2[3] * q3[0])
        q[2] += q1[3] * (q2[1] * q3[0] - q2[0] * q3[1])

        q[3] = -q1[0] * (q2[1] * q3[2] - q2[2] * q3[1])
        q[3] += q1[1] * (q2[0] * q3[2] - q2[2] * q3[0])
        q[3] -= q1[2] * (q2[0] * q3[1] - q2[1] * q3[0])
        return q
Ejemplo n.º 9
0
    def _calcCoordAxes(self, q):
        self.coordAxes[0] = q
        if (fabs(q[0]) < 0.0001 and fabs(q[1]) < 0.0001):
            self.coordAxes[1] = Piavca.Quat(1.0, 0.0, 0.0, 0.0)
            self.coordAxes[2] = Piavca.Quat(0.0, 1.0, 0.0, 0.0)
            self.coordAxes[3] = Piavca.Quat(0.0, 0.0, q[3], -q[2])
            self.coordAxes[3].normalise()
            return
        if (fabs(q[2]) < 0.0001 and fabs(q[3]) < 0.0001):
            self.coordAxes[1] = Piavca.Quat(q[1], -q[0], 0.0, 0.0)
            self.coordAxes[1].normalise()
            self.coordAxes[2] = Piavca.Quat(0.0, 0.0, 1.0, 0.0)
            self.coordAxes[3] = Piavca.Quat(0.0, 0.0, 0.0, 1.0)
            return

        self.coordAxes[1] = Piavca.Quat(q[1], -q[0], 0.0, 0.0)
        self.coordAxes[1].normalise()
        self.coordAxes[2] = Piavca.Quat(0.0, 0.0, q[3], -q[2])
        self.coordAxes[2].normalise()
        self.coordAxes[3] = self._cross(self.coordAxes[0], self.coordAxes[1],
                                        self.coordAxes[2])
        self.coordAxes[3].normalise()
Ejemplo n.º 10
0
    def preFrame(self, time):
        if self.noChanges:
            return
        #print "Footplants, preFrame"
        Piavca.MotionFilter.preFrame(self, time)
        #print "Footplants, preFrame"
        if self.plantedFoot == None:
            #print "no planted foot"
            return
        av = self.getAvatar()
        ori = av.getRootOrientation()
        pos = av.getRootPosition()
        #print "old ori", ori, "old pos", pos
        pos = av.getJointBasePosition(self.plantedFoot, Piavca.WORLD_COORD)
        #print time, "old foot pos", pos, self.plantPos, self
        self.noChanges = True
        #print "no changes", self.noChanges
        #print "self", self
        av.showMotionAtTime(time, None, 0)
        #av.showMotionAtTime(time, self.getMotion(),0)
        ori = av.getJointOrientation(self.plantedFoot, Piavca.WORLD_COORD)
        pos = av.getJointBasePosition(self.plantedFoot, Piavca.WORLD_COORD)
        self.noChanges = False
        #print "rootpos", av.getRootPosition()
        #print "current pos, ori", pos, ori
        #print "jointlocal", av.getJointOrientation(self.plantedFoot, Piavca.JOINTLOCAL_COORD), av.getJointOrientation(self.plantedFoot, Piavca.JOINTLOCAL_COORD)
        #print "world", av.getJointOrientation(self.plantedFoot, Piavca.WORLD_COORD), av.getJointOrientation(self.plantedFoot, Piavca.WORLD_COORD)
        #if abs(ori[0]+ori[1]+ori[2]+ori[3]) < 0.0001:
        #	asdf

        #self.rootOri = self.plantOri * ori.inverse()
        self.rootOri = Piavca.Quat()  #self.plantOri * ori.inverse()
        #print "plant ori", self.plantOri, "current ori", ori
        #print "plant pos", self.plantPos, " current pos ", self.rootOri.transform(pos)
        #self.rootPos = self.plantPos - self.rootOri.transform(pos)
        self.rootPos = self.plantPos - pos
Ejemplo n.º 11
0
def ValueListToQuat(valuelist):
    quat = [float(x) for x in valuelist]
    quat = Piavca.Quat(Piavca.degToRad(quat[0]),
                       Piavca.Vec(quat[1], quat[2], quat[3]))
    return quat
Ejemplo n.º 12
0
def readMotions(motions):
    mots = []
    element_list = []
    child_motion_list = []
    for motion in motions:
        if motion.nodeType == minidom.Node.ELEMENT_NODE:
            #print "current node", motion.nodeName
            if motion.nodeName == "Avatar":
                name = str(motion.getAttribute("name"))
                if name == "":
                    name = str(motion.getAttribute("Name"))
                if name == "":
                    print "Avatar statement without a name"

                position = str(motion.getAttribute("position"))
                if position == "":
                    position = str(motion.getAttribute("Position"))
                if position != "":
                    position = str(position).strip()
                    position = stringToValueList(position)
                    position = ValueListToVec(position)
                else:
                    position = Piavca.Vec()

                rotation = str(motion.getAttribute("rotation"))
                if rotation == "":
                    rotation = str(motion.getAttribute("Rotation"))
                if rotation != "":
                    rotation = str(rotation).strip()
                    rotation = stringToValueList(rotation)
                    rotation = ValueListToQuat(rotation)
                else:
                    rotation = Piavca.Quat()

                avatar = Piavca.Avatar(name)
                #print "loaded avatar", name, position, rotation
                avatar.setRootPosition(position)
                avatar.setRootOrientation(rotation)
                for child in motion.childNodes:
                    if child.nodeType != minidom.Node.ELEMENT_NODE:
                        continue
                    if child.nodeName != "Event":
                        #print "expected a Event statement as a child of an avatar but got", child.nodeName
                        continue
                    name = str(child.getAttribute("name"))
                    if name == "":
                        name = str(child.getAttribute("Name"))
                    if name == "":
                        print "Event statement without a name"
                    Piavca.addEvent(avatar, name)

            elif motion.nodeName == "Motion":
                #print "found a motion statement", motion
                for i in range(motion.attributes.length):
                    #print motion.attributes.item(i).name, motion.attributes.item(i).nodeValue
                    unknownAttrs = []
                    if motion.attributes.item(i).name != "name":
                        unknownAttrs.append(
                            (motion.attributes.item(i).name,
                             motion.attributes.item(i).nodeValue))
                name = str(motion.getAttribute("name"))
                if name == "":
                    name = str(motion.getAttribute("Name"))
                if name == "":
                    print "Motion statement without a name"
                else:
                    #print "*"+name+"*"
                    mot = Piavca.getMotion(name)
                    #print mot
                    if mot == None:
                        print "could not find motion", name
                    else:
                        mots.append((mot, str(motion.nodeName), unknownAttrs))
                        #print "mots", mots

            elif motion.nodeName == "File":
                name = str(motion.getAttribute("name"))
                filename = str(motion.getAttribute("filename"))
                Paivca.loadMotion(name, filename)

            elif motion.nodeName == "Keyframes":
                for i in range(motion.attributes.length):
                    #print motion.attributes.item(i).name, motion.attributes.item(i).nodeValue
                    unknownAttrs = []
                    if motion.attributes.item(i).name != "name":
                        unknownAttrs.append(
                            (motion.attributes.item(i).name,
                             motion.attributes.item(i).nodeValue))
                name = str(motion.getAttribute("name"))
                mot = Piavca.KeyframeMotion()
                mot.thisown = False
                for child in motion.childNodes:
                    if child.nodeType != minidom.Node.ELEMENT_NODE:
                        continue
                    if child.nodeName != "Key":
                        print "expected a key statement as a child of a keyframe motion but got", child.nodeName
                        continue
                    key_type = str(child.getAttribute("type"))
                    key_value = str(child.getAttribute("value"))
                    key_time = float(child.getAttribute("time"))
                    key_joint = str(child.getAttribute("joint"))
                    if key_type == "FLOAT" or key_type == "Float" or key_type == "float":
                        key_joint = Piavca.Core.getCore().getExpressionId(
                            key_joint)
                    else:
                        key_joint = Piavca.Core.getCore().getJointId(key_joint)
                    if key_joint == Piavca.Core.getCore().nullId:
                        raise ValueError("Unknown Joint Id " +
                                         str(child.getAttribute("joint")))
                        Piavca.Core.getCore().addJointNameSet([key_joint])
                    if key_type == "FLOAT" or key_type == "Float" or key_type == "float":
                        if mot.isNull(key_joint):
                            mot.addFloatTrack(key_joint, 0.0)
                        key_value = float(key_value)
                        mot.setFloatKeyframe(key_joint, float(key_time),
                                             key_value)
                    if key_type == "VEC" or key_type == "Vec" or key_type == "vec":
                        if mot.isNull(key_joint):
                            mot.addVecTrack(key_joint, Piavca.Vec())
                        valuelist = stringToValueList(key_value)
                        key_value = ValueListToVec(valuelist)
                        mot.setVecKeyframe(key_joint, float(key_time),
                                           key_value)
                    if key_type == "QUAT" or key_type == "Quat" or key_type == "quat":
                        if mot.isNull(key_joint):
                            mot.addQuatTrack(key_joint, Piavca.Quat())
                        valuelist = stringToValueList(key_value)
                        key_value = ValueListToQuat(valuelist)
                        mot.setQuatKeyframe(key_joint, float(key_time),
                                            key_value)
                if name != "":
                    Piavca.loadMotion(name, mot)

            else:
                try:
                    #print "other motion types", motion.nodeName
                    cl = getattr(Piavca, motion.nodeName)
                    if type(cl) == types.TypeType and issubclass(
                            cl, Piavca.Motion):
                        #print "found motion type", motion.nodeName
                        mot = cl()

                        storedMotName = mot.getName()
                        storedMotStr = str(mot)
                        if mot == None:
                            raise "could not create motion " + motion.nodeName
                            continue
                        mot.thisown = False
                        unknownAttrs = []
                        for i in range(motion.attributes.length):
                            if str(
                                    motion.attributes.item(i).name
                            ) == "name" or str(
                                    motion.attributes.item(i).name) == "Name":
                                name = str(motion.attributes.item(i).nodeValue)
                                #print "========================motion name", name
                                if name != "":
                                    Piavca.loadMotion(name, mot)
                                continue
                            attrName = motion.attributes.item(i).name
                            attrValue = motion.attributes.item(i).nodeValue
                            #print attrName, attrValue
                            if not setAttribute(mot, attrName, attrValue):
                                unknownAttrs.append((attrName, attrValue))
                        child_motion_list.append((mot, motion.childNodes))

                        mot.create()
                        mots.append((mot, str(motion.nodeName), unknownAttrs))
                    else:
                        raise str(
                            motion.nodeName
                        ) + " is not a motion type, its type is: " + str(
                            type(cl))
                        # add to a "add list" instead, parse attributes into a dictionary
                except AttributeError, e:
                    print "Attribute Error:", e

                    elementName = motion.nodeName
                    attrList = []
                    for i in range(motion.attributes.length):

                        attrName = motion.attributes.item(i).name
                        attrValue = motion.attributes.item(i).nodeValue
                        attrList.append((attrName, attrValue))
                    element_list.append((elementName, attrList))
Ejemplo n.º 13
0
	def load_FileObject(self, f):
		lines = f.readlines()
		data_portion = 0
		i = 0
		pcs = None
		for line in lines :
			if not data_portion :
				contents = string.split(line, ":")
				#print contents
				if contents[0] == "Num Pcs":
					self.num_pcs = int(contents[1])
					#print self.num_pcs
				if contents[0] == "Use Vels":
					self.use_vels = bool(contents[1])
					#print self.use_vels
				#if contents[0] == "Using Splits":
				#	self.using_splits = int(contents[1])
				#	print self.using_splits
				if contents[0] == "Exp Maps":
					#print "expmaps"
					self.expmaps = []
					#print "expmaps"
					number_pattern = re.compile("-?((([0-9]+)|([0-9]*\.[0-9]+))([eE][-+]?[0-9]+)?)")
					#print "expmaps"
					quat_pattern = re.compile("\[[^\]]*\]")
					#print "created regexp"
					matches = quat_pattern.findall(contents[1])
					#print "got matches"
					for match in matches :
						#print "match"
						numbers = string.split(match[1:-1])
						#print numbers
						q = Piavca.Quat(float(numbers[0]), float(numbers[1]), float(numbers[2]), float(numbers[3]))
						#print q
						self.expmaps.append(Piavca.ExpMap.TangentSpace(q))
					#print matches
				if contents[0] == "Joint Types":
					self.joint_types = []
					numbers = string.split(contents[1])
					for number in numbers:
						self.joint_types.append(int(number))
				if contents[0] == "Joint Map":
					self.jointmap = []
					numbers = string.split(contents[1])
					for number in numbers:
						if number == "None":
							self.jointmap.append(None)
						else:
							self.jointmap.append(int(number))
				if contents[0] == "Quants":
					self.quants = []
					quants = string.split(contents[1], ";")
					for quant in quants: 
						if quant == "":
							continue
						if quant == "\n":
							continue
						q = []
						numbers = string.split(quant)
						for number in numbers:
							if number == "":
								continue
							q.append(float(number))
						if q != []:
							self.quants.append(q)
					#print self.quants
					self.quants = scipy.array(self.quants)
				if contents[0] == "length":
					pcs = scipy.zeros((int(contents[1]), self.num_pcs),'d')
				if(contents[0] == "data"):
					data_portion = 1
			else:
				numbers = string.split(line)
				if numbers == [] :
					continue
				#print len(numbers)
				for j in range(len(numbers)):
					pcs[j][i] = float(numbers[j])
				i += 1
			#print self.pcs
		if pcs == None:
			return
		else:
			self.pcs = pcs
		self.weights = scipy.zeros((self.num_pcs,),'d')
		self.generateMotion()
Ejemplo n.º 14
0
    def setFilename(self, filename):
        print "#########################################################"
        print "set filename", filename
        self.filename = filename
        if self.filename == "":
            return

        dom = minidom.parse(filename)

        #mot = Piavca.KeyframeMotion()

        print "reading", filename

        for topLevel in dom.childNodes:
            for mainelement in topLevel.childNodes:
                if mainelement.nodeName == "SceneInfo":
                    startTick = mainelement.getAttribute("startTick")
                    try:
                        self.startTick = float(startTick)
                    except ValueError:
                        pass
                    fps = 30.0
                    try:
                        fps = float(mainelement.getAttribute("frameRate"))
                    except ValueError:
                        pass
                    ticksPerFrame = 160.0
                    try:
                        ticksPerFrame = float(
                            mainelement.getAttribute("ticksPerFrame"))
                    except ValueError:
                        pass
                    self.tickrate = fps * ticksPerFrame
                if mainelement.nodeName == "Node":
                    for nodechild in mainelement.childNodes:
                        print nodechild.nodeName
                        if nodechild.nodeName == "Controller":
                            nm = nodechild.getAttribute("name")
                            print nm
                            nm_elements = nm.split()
                            track = Piavca.Core.getCore().nullId
                            for el in nm_elements:
                                print el, Piavca.Core.getCore().getTrackId(el)
                                track = Piavca.Core.getCore().getTrackId(el)
                                if track != Piavca.Core.getCore().nullId:
                                    break
                            if track != Piavca.Core.getCore().nullId:
                                print "found track", el, track
                                keyframes = []
                                for keyset in nodechild.childNodes:
                                    print keyset.nodeName
                                    if keyset.nodeName == "Keys" or keyset.nodeName == "Samples":
                                        for key in keyset.childNodes:
                                            if key.nodeName == "Key":
                                                t = key.getAttribute("t")
                                                try:
                                                    t = float(t)
                                                except ValueError:
                                                    continue

                                                v = key.getAttribute("v")
                                                #try:
                                                #	v = float(t)
                                                #except ValueError:
                                                #	continue
                                                keyframes.append((t, v))
                                        print keyframes
                                        v = keyframes[0][1]
                                        v = str(v)
                                        v = v.strip()
                                        v = v.split()
                                        print v
                                        if len(v) == 1:
                                            print "scalar", v
                                            try:
                                                v = float(v[0])
                                                print "float", v
                                                self.addFloatTrack(track, v)
                                                for t, v in keyframes:
                                                    print t, v
                                                    v = str(v)
                                                    v = v.strip()
                                                    v = float(v)
                                                    v = v / 100.0
                                                    t = t / self.tickrate
                                                    print track, t, v
                                                    self.setFloatKeyframe(
                                                        track, t, v)
                                            except ValueError:
                                                continue
                                        elif len(v) == 3:
                                            try:
                                                print "vector", v
                                                v = Piavca.Vec(
                                                    float(v[0]), float(v[1]),
                                                    float(v[2]))
                                                self.addVecTrack(track, v)
                                                for t, v in keyframes:
                                                    t = t / self.tickrate
                                                    v = Piavca.Vec(
                                                        float(v[0]),
                                                        float(v[1]),
                                                        float(v[2]))
                                                    self.setVecKeyframe(
                                                        track, t, v)
                                            except:
                                                continue
                                        elif len(v) == 4:
                                            try:
                                                print "quat", v
                                                v = Piavca.Quat(
                                                    float(v[0]), float(v[1]),
                                                    float(v[2]))
                                                self.addQuatTrack(track, v)
                                                for t, v in keyframes:
                                                    t = t / self.tickrate
                                                    v = Piavca.Quat(
                                                        float(v[3]),
                                                        float(v[0]),
                                                        float(v[1]),
                                                        float(v[2]))
                                                    self.setQuattKeyframe(
                                                        track, t, v)
                                            except:
                                                continue
        #Piavca.loadMotion(name, mot)

        #impl = minidom.getDOMImplementation()
        #doc = impl.createDocument("", "PiavcaMotions", None)
        #f = open(filename, "w")
        #dom.writexml(f, "", "\t", "\n")
        dom.unlink
Ejemplo n.º 15
0
    def __init__(self, name, filename, app=None, gui_thread=False):
        Piavca.TimeCallback.__init__(self, name)
        self.app = app
        self.gui_thread = gui_thread
        self.frame = None

        self.camera_pos = Piavca.Vec()
        self.camera_pitch = 0.0
        self.camera_yaw = 0.0

        loadDefaults()

        self.scripts = {}
        self.currentscript = {}
        self.starttimes = {}

        if pymediapresent or pyaudiopresent:
            self.soundEngine = SoundEngine()
        else:
            self.soundEngine = None

        inputfile = open(filename, "r")
        lines = inputfile.readlines()
        inputfile.close()
        gui_list = []
        for line in lines:
            line = line.strip()
            commentpos = line.find("#")
            if commentpos >= 0:
                line = line[:commentpos]
            line = line.split()
            print line
            if len(line) <= 0:
                continue
            if line[0] == "soundpack":
                if len(line) == 2:
                    spackname = line[1]
                else:
                    spackname = line[2]
                if self.soundEngine != None:
                    self.soundEngine.loadSounds(spackname)
                else:
                    print "could not load sound packs as audio playback is not supported, please install pyaudio or pymedia"
            elif line[0] == "expressions":
                importExpressionNames(line[1])
            elif line[0] == "joints":
                importJointNames(line[1])
            elif line[0] == "avatar":
                print "avatar", line[1]
                print "start loading avatar"
                avatar = Piavca.Avatar(line[1])
                print "finished loading avatar"
                i = 2
                while i < len(line):
                    if line[i] == "position" or line[i] == "pos":
                        pos = Piavca.Vec(float(line[i + 1]),
                                         float(line[i + 2]),
                                         float(line[i + 3]))
                        avatar.setRootPosition(pos)
                        i = i + 3
                    elif line[i] == "rotation" or line[i] == "rot":
                        angle = Piavca.degToRad(float(line[i + 1]))
                        axis = Piavca.Vec(float(line[i + 2]),
                                          float(line[i + 3]),
                                          float(line[i + 4]))
                        avatar.setRootOrientation(Piavca.Quat(angle, axis))
                        i = i + 4
                    i += 1
            elif line[0] == "motionpack":
                if len(line) == 2:
                    mpackname = line[1]
                else:
                    mpackname = line[2]
                print "motionpack", mpackname
                MotionFile.readMotionFile(mpackname)
            elif line[0] == "script":
                if len(line) == 2:
                    spackname = line[1]
                else:
                    spackname = line[2]
                print "script pack", spackname
                self.loadScripts(spackname)
            elif line[0] == "camera":
                if line[1] == "position":
                    self.camera_pos = Piavca.Vec(float(line[2]),
                                                 float(line[3]),
                                                 float(line[4]))
                elif line[1] == "vert_angle":
                    self.camera_pitch = Piavca.degToRad(float(line[2]))
                elif line[1] == "horiz_angle":
                    self.camera_yaw = Piavca.degToRad(float(line[2]))
                #elif line[1] == "rotation":
                #       s            	self.camera_ori = Piavca.Quat(float(line[2]), Piavca.Vec(float(line[3], float(line[4], lfloat(ine[5]))
            elif line[0] == "GUI":
                print "gui"
                gui_list.append(line[1])
            elif line[0] == "gui":
                print "gui"
                gui_list.append(line[1])

        for gui_name in gui_list:
            self.GUI(gui_name)

        self.thisown = 0
        Piavca.Core.getCore().registerCallback(self)
Ejemplo n.º 16
0
 def calcRotation(self):
     self.cameraRot = Piavca.Quat(self.cameraPitch, Piavca.Vec_XAxis())
     self.cameraRot = Piavca.Quat(self.cameraYaw,
                                  Piavca.Vec_YAxis()) * self.cameraRot