def __init__(self):
super().__init__()
self.anim = Actor("my-models/anim",
{"attack": "my-models/anim-attack"})
self.anim.reparentTo(self.render)
self.anim.setPos(0, 40, 0)
self.anim.loop("attack")
self.x = 0
self.z = 0
self.taskMgr.add(self.update, "update")
def showHuman(self):
self.pandaActor = Actor(
'/home/teerawat/Documents/Work/Test PView/newMHuman/mHuman7.egg',
{'mHuman7-MhumA_test.egg': '/home/teerawat/Documents/Work/Test PView/newMHuman/mHuman7-MhumA_test.egg'})
self.pandaActor.setScale(0.085, 0.085, 0.085)
self.pandaActor.setPos(42, -39, 0.03)
self.pandaActor.reparentTo(self.scene.scene)
#print(str("test"))
# Loop its animation.
self.pandaActor.loop("mHuman7-MhumA_test.egg")
self.pandaActor.pprint()
def create_node(self):
self.model = Actor('grenade.egg')
self.shell = self.model.find('**/shell')
self.shell.set_color(*self.color)
self.inner_top = self.model.find('**/inner_top')
self.inner_bottom = self.model.find('**/inner_bottom')
self.inner_top.set_color(*random.choice(ENGINE_COLORS))
self.inner_bottom.set_color(*random.choice(ENGINE_COLORS))
self.model.set_scale(GRENADE_SCALE)
self.model.set_hpr(0, 0, 0)
self.spin_bone = self.model.controlJoint(None, 'modelRoot',
'grenade_bone')
return self.model
def getPieSplatInterval(pos, pieName):
scale, color = Splats[pieName]
splat = Actor('phase_3.5/models/props/splat-mod',
{'splat': 'phase_3.5/models/props/splat-chan'})
splat.setBillboardPointWorld(2)
splat.setScale(scale)
splat.setColor(color)
sound = loader.loadSfx('phase_4/audio/sfx/AA_wholepie_only.ogg')
return Parallel(
Func(splat.reparentTo, render), Func(splat.setPos, pos),
SoundInterval(sound, node=splat, volume=1.0),
Sequence(ActorInterval(splat, 'splat'), Func(splat.detachNode)))
def __init__(self):
self.sano = Actor("EggMod/Roblock1.egg", {
"BB1": "EggMod/Roblock1-WB1.egg",
"BB2": "EggMod/Roblock3-A2.egg"
})
self.sano.makeSubpart("LWalk",
["Bone.006", "Bone.007", "Bone.008", "Bone.009"],
["Bone.001", "Bone.002", "Bone.010", "Bone.011"])
self.sano.makeSubpart("LYou",
["Bone.001", "Bone.002", "Bone.010", "Bone.011"],
["Bone.006", "Bone.007", "Bone.008", "Bone.009"])
self.sano.reparentTo(render)
self.sano.setTexture(loader.loadTexture("tex/M6.png"))
def loadModels(self):
# Seeker
ralphStartPos = Vec3(-10, 0, 0)
self.seeker = Actor("models/ralph", {"run": "models/ralph-run"})
self.seeker.reparentTo(render)
self.seeker.setScale(0.5)
self.seeker.setPos(ralphStartPos)
# Target
self.target = loader.loadModel("models/arrow")
self.target.setColor(1, 0, 0)
self.target.setPos(10, 5, 0)
self.target.setScale(1)
self.target.reparentTo(render)
def setActor(self,
modelPath,
animDic={},
flip=False,
pos=(0, 0, 0),
scale=1.0):
self.playerModel = Actor(modelPath, animDic)
self.playerModel.reparentTo(self.np)
self.playerModel.setScale(scale) # 1ft = 0.3048m
if flip:
self.playerModel.setH(180)
self.playerModel.setPos(pos)
self.playerModel.setScale(scale)
def __init__(self, mediator, pos, model_path, anim_suff):
self.model = None
self.pos = pos
self.model_path = model_path
self.anim_suff = anim_suff
GfxColleague.__init__(self, mediator)
path = self.model_path
self.model = Actor(path, {'anim': path + '-' + self.anim_suff})
self.model.reparent_to(render)
self.model.set_pos(self.pos)
self.model.loop('anim')
self.model.setPlayRate(.5, 'anim')
self.model.set_depth_offset(1)
def __init__(self):
ShowBase.__init__(self)
# tworzymy bazowa scene
self.scena1 = self.loader.loadModel("models/environment")
self.scena1.reparentTo(self.render)
self.scena1.setScale(0.10, 0.10, 0.10)
self.scena1.setPos(-8, 42, 0)
# wstawiamy aktora 1
self.aktorPanda = Actor("models/panda-model",{"walk": "models/panda-walk4"})
self.aktorPanda.setScale(0.005, 0.005, 0.005)
self.aktorPanda.reparentTo(self.render)
# animacja chodu 1
self.aktorPanda.loop("walk")
obrot3 = self.aktorPanda.hprInterval(3, Point3(30, 0, 0), startHpr=Point3(0, 3, 0))
przemieszczenie1 = self.aktorPanda.posInterval(5, Point3(3, -3, 0), startPos=Point3(0, 3, 0))
obrot1 = self.aktorPanda.hprInterval(3, Point3(-180, 0, 0), startHpr=Point3(0, 0, 0))
przemieszczenie2 = self.aktorPanda.posInterval(5, Point3(0, 3, 0), startPos=Point3(3, -3, 0))
obrot2 = self.aktorPanda.hprInterval(3, Point3(0, 0, 0), startHpr=Point3(-180, 0, 0))
self.Idzie = Sequence(obrot3, przemieszczenie1, obrot1, przemieszczenie2, obrot2)
self.Idzie.loop()
self.aktorPanda.setPos(0, 0, 0)
# wstawiamy aktora 2
self.aktorPanda2 = Actor("models/panda-model", {"walk": "models/panda-walk4"})
self.aktorPanda2.setScale(0.01, 0.01, 0.01)
self.aktorPanda2.reparentTo(self.render)
# animacja chodu 2
self.aktorPanda2.loop("walk")
przemieszczenie1 = self.aktorPanda2.posInterval(10, Point3(-6, -6, 0), startPos=Point3(-6, 20, 0))
obrot1 = self.aktorPanda2.hprInterval(3, Point3(-180, 0, 0), startHpr=Point3(0, 0, 0))
przemieszczenie2 = self.aktorPanda2.posInterval(10, Point3(-6, 20, 0), startPos=Point3(-6, -6, 0))
obrot2 = self.aktorPanda2.hprInterval(3, Point3(0, 0, 0), startHpr=Point3(-180, 0, 0))
self.Idzie = Sequence(przemieszczenie1, obrot1, przemieszczenie2, obrot2)
self.Idzie.loop()
self.aktorPanda2.setPos(-6, 0, 0)
def __init__(self, parent):
self.parent = parent
LoadFontFace("data/fonts/Delicious-Roman.otf")
LoadFontFace("data/fonts/verdana.ttf")
self.parent.rRegion.setActive(1)
self.parent.rContext = self.parent.rRegion.getContext()
#context.LoadDocument('assets/background.rml').Show()
self.doc = self.parent.rContext.LoadDocument(
'data/rml/login_screen.rml')
self.doc.Show()
element = self.doc.GetElementById('log_in')
element.AddEventListener('click', self.loginButPressed, True)
element = self.doc.GetElementById('log_in_red')
element.AddEventListener('click', self.loginButRedPressed, True)
element = self.doc.GetElementById('log_in_blue')
element.AddEventListener('click', self.loginButBluePressed, True)
self.cuber = Actor('cuber', {'no': 'cuber-noway', 'yes': 'cuber-yay'})
self.cuber.reparentTo(render)
self.cuber.setPos(-4, 20, -2)
self.cuber.setColor(1, 0, 0)
self.cuber.loop('no')
self.cuber2 = Actor('cuber', {'no': 'cuber-noway', 'yes': 'cuber-yay'})
self.cuber2.reparentTo(render)
self.cuber2.setPos(4, 20, -2)
self.cuber2.setColor(0, 0, 1)
self.cuber2.loop('yes')
dlight1 = DirectionalLight("dlight1")
dlight1.setColor(VBase4(0.7, 0.7, 0.7, 1.0))
self.dlnp1 = render.attachNewNode(dlight1)
self.dlnp1.setHpr(0, -50, 0)
render.setLight(self.dlnp1)
alight = AmbientLight("alight")
alight.setColor(VBase4(0.4, 0.4, 0.4, 1.0))
self.alnp = render.attachNewNode(alight)
render.setLight(self.alnp)
def enterReadBook(self, ts=0, callback=None, extraArgs=[]):
self.playingAnim = 'book'
self.book2 = Actor("phase_3.5/models/props/book-mod.bam",
{"chan": "phase_3.5/models/props/book-chan.bam"})
self.book2.reparentTo(
self.getPart('torso').find('**/def_joint_right_hold'))
self.pingpong("book",
fromFrame=CIGlobals.ReadBookFromFrame,
toFrame=CIGlobals.ReadBookToFrame)
self.book2.pingpong("chan",
fromFrame=CIGlobals.ReadBookFromFrame,
toFrame=CIGlobals.ReadBookToFrame)
def load(self):
DistributedPartyActivity.load(self)
self.jukebox = Actor('phase_13/models/parties/jukebox_model', {'dance': 'phase_13/models/parties/jukebox_dance'})
self.jukebox.reparentTo(self.root)
self.jukebox.loop('dance', fromFrame=0, toFrame=48)
self.collNode = CollisionNode(self.getCollisionName())
self.collNode.setCollideMask(ToontownGlobals.CameraBitmask | ToontownGlobals.WallBitmask)
collTube = CollisionTube(0, 0, 0, 0.0, 0.0, 4.25, 2.25)
collTube.setTangible(1)
self.collNode.addSolid(collTube)
self.collNodePath = self.jukebox.attachNewNode(self.collNode)
self.sign.setPos(-5.0, 0, 0)
self.activate()
def __init__(self):
ShowBase.__init__(self)
self.pandas = []
for i in range(8):
panda = Actor("panda", {"walk": "panda-walk"})
panda.reparentTo(render)
panda.loop("walk")
panda.setX(-28 + i * 8)
self.pandas.append(panda)
self.cam.setPos(0, -40, 6)
def __init__(self):
ShowBase.__init__(self)
# Load environment model
self.scene = self.loader.loadModel("models/environment")
# Reparent the model to render.
self.scene.reparentTo(self.render)
# Apply scale and position transforms on the model
self.scene.setScale(0.25, 0.25, 0.25)
self.scene.setPos(-8, 42, 0)
# Add the spinCameraTask procedure to the task manager.
self.taskMgr.add(self.spinCameraTask, "SpinCameraTask")
# Load an transform the panda actor
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
self.pandaActor.reparentTo(self.render)
# Loop its animation
self.pandaActor.loop("walk")
# Create the four lerp intervals needed for the panda to
# walk back and forth.
pandaPosInterval1 = self.pandaActor.posInterval(13,
Point3(0, -10, 0),
startPos=Point3(
0, 10, 0))
pandaPosInterval2 = self.pandaActor.posInterval(13,
Point3(0, 10, 0),
startPos=Point3(
0, -10, 0))
pandaHprInterval1 = self.pandaActor.hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval2 = self.pandaActor.hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(
180, 0, 0))
# Create and play the sequence that coordinates the intervals
self.pandaPace = Sequence(pandaPosInterval1,
pandaHprInterval1,
pandaPosInterval2,
pandaHprInterval2,
name="pandaPace")
self.pandaPace.loop()
def __init__(self, dadosUsuario, principal=False):
self.key = dadosUsuario['key']
self.nick = dadosUsuario['nick']
self.vida_real = float(dadosUsuario['vida_real'])
self.vida_total = float(dadosUsuario['vida_total'])
self.mana_real = float(dadosUsuario['mana_real'])
self.mana_total = float(dadosUsuario['mana_total'])
self.forca = float(dadosUsuario['forca'])
self.velocidade = float(dadosUsuario['velocidade'])
self.velocidade_atack = float(dadosUsuario['velocidade_atack'])
self.estaMovendo = False
self.estaRodando = False
self.__task_name = "Task Usuario - " + self.key
self.keyMap = {
TECLA_esquerda: EVENT_up,
TECLA_direita: EVENT_up,
TECLA_frente: EVENT_up,
TECLA_traz: EVENT_up
}
pandaFileModelo = get_path_modelo("ralph")
pandaFileAnimacaoRun = get_path_animacao("ralph-run")
pandaFileAnimacaoWalk = get_path_animacao("ralph-walk")
self.modelo = Actor(pandaFileModelo, {
"run": pandaFileAnimacaoRun,
"walk": pandaFileAnimacaoWalk
})
self.modelo.reparentTo(render)
self.modelo.setScale(SCALE_MODELOS)
self.set_pos((float(dadosUsuario['x']), float(dadosUsuario['y']),
float(dadosUsuario['z'])))
self.set_h(float(dadosUsuario['h']))
if not principal:
self.text = Text(parent=self.modelo,
pos=(0, 0, 5.5),
scale=.5,
align='center',
cor=COR_VERDE,
text=self.nick)
self.text.billboardEffect()
self.__setup_collision()
taskMgr.add(self.__task_movimentacao, self.__task_name, sort=1)
def setupGagWheelBarrel(self):
self.wb = loader.loadModel('phase_5.5/models/estate/wheelbarrel.bam')
self.wb.find('**/dirt').remove_node()
self.wb.reparent_to(self)
self.wb.set_x(-3.5)
self.wb.set_h(90)
tart1 = loader.loadModel('phase_3.5/models/props/tart.bam')
tart1.reparent_to(self.wb)
tart1.set_scale(0.6)
tart1.set_pos(0, 0.65, 1)
tart1.set_p(30.26)
tart2 = loader.loadModel('phase_3.5/models/props/tart.bam')
tart2.reparent_to(self.wb)
tart2.set_scale(0.6)
tart2.set_z(1.14)
slice1 = loader.loadModel('phase_5/models/props/cream-pie-slice.bam')
slice1.reparent_to(self.wb)
slice1.set_scale(0.6)
slice1.set_pos(0, -0.56, 1.42)
slice1.set_hpr(323.97, 37.87, 0)
slice2 = loader.loadModel('phase_5/models/props/cream-pie-slice.bam')
slice2.reparent_to(self.wb)
slice2.set_scale(0.6)
slice2.set_pos(tart2.get_pos() + (0, 0, 0.35))
slice2.set_hpr(tart2.get_hpr())
cake1 = Actor('phase_5/models/props/birthday-cake-mod.bam', {'chan': 'phase_5/models/props/birthday-cake-chan.bam'})
cake1.setPlayRate(0.3, 'chan')
cake1.loop('chan')
cake1.set_scale(0.6)
cake1.reparent_to(self.wb)
cake1.set_pos(0, 0.94, 1.4)
cake2 = Actor('phase_5/models/props/birthday-cake-mod.bam', {'chan': 'phase_5/models/props/birthday-cake-chan.bam'})
cake2.setPlayRate(-0.3, 'chan')
cake2.loop('chan')
cake2.set_scale(0.5)
cake2.reparent_to(self.wb)
cake2.set_pos(0.27, -0.38, 1.7)
cake2.set_p(10)
def __init__(self):
ShowBase.__init__(self)
keyTracker.__init__(self)
# self.pandaActors = [Actor("panda", {"walk": "panda-walk"}), Actor("panda", {"walk": "panda-walk"}), Actor("panda", {"walk": "panda-walk"}), Actor("panda", {"walk": "panda-walk"})]
self.player1 = Actor("panda", {"walk": "panda-walk"})
self.player2 = Actor("panda", {"walk": "panda-walk"})
self.player3 = Actor("panda", {"walk": "panda-walk"})
self.player4 = Actor("panda", {"walk": "panda-walk"})
self.player1.reparentTo(render)
self.player2.reparentTo(render)
self.player3.reparentTo(render)
self.player4.reparentTo(render)
self.player1.setPos(-50, 5, 0)
self.player2.setPos(5, 5, 0)
self.player3.setPos(15, 5, 0)
self.player4.setPos(25, 5, 0)
self.loadModels()
self.setupCameras()
# Set up the camera
self.disableMouse()
self.isMoving = False
self.setupControls()
self.xboxKeys = XboxControllerHandler()
# Stores the time at which the next bullet may be fired.
self.nextLaser = 0.0
# This list will stored fired bullets.
self.Lasers = []
def __init__(self, actor):
a = namedtuple("actor", actor.keys(), *actor.values())
self.id = a.id
self.type = a.subtype
self.properties = a.properties
character = db.characters.find_one(
{"type": self.type}) # TODO: Add checks if the model is not found retrieve default model
self.modelpath = os.path.join("../../models/characters", character.modelname + ".egg.pz")
self.animations = dict(
[(anim, os.path.join("../../models/characters", "%s_%s.egg.pz".format(character.modelname, anim))) for anim in
character.animations])
self.model = Actor(self.modelpath, self.animations)
def __init__(self, pos, modelName, modelAnims, maxHealth, maxSpeed, colliderName):
self.actor = Actor(modelName, modelAnims)
self.actor.reparentTo(render)
self.actor.setPos(pos)
self.maxHealth = maxHealth
self.health = maxHealth
self.maxSpeed = maxSpeed
self.velocity = Vec3(0, 0, 0)
self.acceleration = 300.0
self.walking = False
colliderNode = CollisionNode(colliderName)
colliderNode.addSolid(CollisionSphere(0, 0, 0, 0.3))
self.collider = self.actor.attachNewNode(colliderNode)
self.collider.setPythonTag("owner", self)
def __init__(self, square, color, live=1):
if live == 1:
self.obj = Actor(self.model,
{"move": "models/monster1-pincer-attack-both"})
self.obj.loop("move")
self.obj.reparentTo(render)
self.obj.setColor(color)
self.obj.setScale(0.15, 0.15, 0.15)
self.obj.setHpr(180, 0, 0)
self.obj.setPos(SquarePos(square))
else:
self.delete()
def loadViewModel(self):
self.unloadViewModel()
if self.SpecialVM and self.SpecialVMActor:
modelName, anims = self.SpecialVMActor
self.specialViewModel = Actor(modelName, anims)
self.specialViewModel.setPos(self.SpecialVMOrigin)
self.specialViewModel.setHpr(self.SpecialVMAngles)
self.specialViewModel.setScale(self.SpecialVMScale)
self.specialViewModel.setBlend(
frameBlend=base.config.GetBool('interpolate-frames', False))
if not self.SpecialVMCull:
self.specialViewModel.node().setBounds(OmniBoundingVolume())
self.specialViewModel.node().setFinal(1)
def createArm(self):
self.robotarm = Actor("models/robotarm")
self.robotarm.reparentTo(render)
self.robotarm.setPos(0,0,0)
self.robotarm.setScale(.2)
self.jointForearm = self.robotarm.controlJoint(None, "modelRoot", "forearm")
self.jointBase = self.robotarm.controlJoint(None, "modelRoot", "base")
taskMgr.add(self.monitorArm, "robot arm")
inc = 15
self.accept("i", self.setForearm, [inc])
self.accept("u", self.setForearm, [-inc])
self.accept("j", self.setBase, [inc])
self.accept("k", self.setBase, [-inc])
def enterFlyAway(self):
self.fa_sfx = audio3d.loadSfx("phase_5/audio/sfx/ENC_propeller_out.ogg")
self.prop = Actor("phase_4/models/props/propeller-mod.bam",
{"chan": "phase_4/models/props/propeller-chan.bam"})
audio3d.attachSoundToObject(self.fa_sfx, self.prop)
self.fa_sfx.play()
self.prop.reparentTo(self.suit.find('**/joint_head'))
self.prop.setPlayRate(-1.0, "chan")
propTrack = Sequence(Func(self.prop.play, 'chan', fromFrame=3),
Wait(1.75),
Func(self.prop.play, 'chan', fromFrame=0, toFrame=3))
propTrack.start()
self.suit.setPlayRate(-1.0, 'land')
self.suit.play('land')
def make_actor(self):
self.pc_node = base.render.attachNewNode("pcnode")
self.pc = Actor("models/panda-model", {"walk": "models/panda-walk4"})
self.pc.setScale(0.05, 0.05, 0.05)
self.pc_node.reparentTo(self.pc)
self.pc.setPos(0, 0, 0)
self.pc_node.setCompass()
self.pc.reparentTo(base.render)
base.camera.reparentTo(self.pc_node)
base.camLens.setFar(500000000000.0)
base.camera.setPos(0, 0, 0)
self.make_actor_collisions(self.pc)
self.make_test_capsule()
def loadActor(self, modelPath, animDic={}, texturePath=None):
if self.model is not None:
self.model.remove()
self.model = Actor(modelPath, animDic)
#self.model.setTransparency(True)
if texturePath is not None:
self.tex = loader.loadTexture(texturePath)
#self.model.clearTexture(TextureStage.getDefault())
self.model.clearTexture()
self.model.setTexture(TextureStage.getDefault(), self.tex)
self.currentAnim = None
self.model.reparentTo(self)
def __init__(self, npc, modelPath, texturePath=None):
self.npc = npc
self.modelPath = modelPath
self.texturePath = texturePath
self.model = Actor(self.modelPath, self.npc.animDic)
#self.model.setTransparency(True)
self.model.reparentTo(self.npc.model)
if texturePath is not None:
self.tex = loader.loadTexture(texturePath)
self.model.clearTexture(TextureStage.getDefault())
self.model.clearTexture()
self.model.setTexture(TextureStage.getDefault(), self.tex)
def generatePropeller(self):
self.cleanupPropeller()
self.propeller = Actor(
'phase_4/models/props/propeller-mod.bam',
{'chan': 'phase_4/models/props/propeller-chan.bam'})
self.propeller.reparentTo(self.find('**/joint_head'))
self.propellerSounds['in'] = self.audio3d.loadSfx(
SuitGlobals.propellerInSfx)
self.propellerSounds['out'] = self.audio3d.loadSfx(
SuitGlobals.propellerOutSfx)
self.propellerSounds['neutral'] = self.audio3d.loadSfx(
SuitGlobals.propellerNeutSfx)
for sound in self.propellerSounds.values():
self.audio3d.attachSoundToObject(sound, self.propeller)
def __init__(self):
ShowBase.__init__(self)
#disable mouse controls
self.disableMouse()
# Load the environment model.
self.scene = self.loader.loadModel("models/environment")
# Reparent the model to render.
self.scene.reparentTo(self.render)
# Apply scale and position transforms on the model.
self.scene.setScale(0.25, 0.25, 0.25)
self.scene.setPos(-8, 42, -40)
#add spin camera task to task manager
self.taskMgr.add(self.spinCamera, "SpinCameraTask")
#add in a panda
self.pandaActor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.pandaActor.setScale(0.005, 0.005, 0.005)
self.pandaActor.reparentTo(self.render)
#loop the animation
self.pandaActor.loop("walk")
#create 4 intervals for the panda to walk back and forth
pandaPosInterval1 = self.pandaActor.posInterval(13,
Point3(0, -10, 0),
startPos=Point3(
0, -10, 0))
pandaPosInterval2 = self.pandaActor.posInterval(13,
Point3(0, 10, 0),
startPos=Point3(
0, 0, 0))
pandaHprInterval1 = self.pandaActor.hprInterval(3,
Point3(180, 0, 0),
startHpr=Point3(
0, 0, 0))
pandaHprInterval2 = self.pandaActor.hprInterval(3,
Point3(0, 0, 0),
startHpr=Point3(
180, 0, 0))
#create and play the sequence coordinating the intervals
self.pandaPace = Sequence(pandaPosInterval1,
pandaHprInterval1,
pandaPosInterval2,
pandaHprInterval2,
name="pandaPace")
self.pandaPace.loop()
def create_node(self):
self.actor = Actor('walker.egg')
if self.colordict:
self.setup_color(self.colordict)
self.actor.set_pos(*self.spawn_point.pos)
self.actor.look_at(*self.spawn_point.heading)
self.spawn_point.was_used()
self.left_barrel_joint = self.actor.exposeJoint(
None, 'modelRoot', 'left_barrel_bone')
self.right_barrel_joint = self.actor.exposeJoint(
None, 'modelRoot', 'right_barrel_bone')
return self.actor
def loadPlaneModel(self, modelname):
"""Loads models and animations from the planes directory."""
animcontrols = {}
model = loader.loadModel("planes/{0}/{0}".format(modelname))
actor = Actor(model,
setFinal=True,
mergeLODBundles=True,
allowAsyncBind=False,
okMissing=False)
#actor = Actor(model, lodNode="mid")
subparts = (
# subpart, joints, animations
("Doors", ["Windscreen*", "Door*"], ("Open", "Close")),
#("Landing Gear", ["Landing?Gear*", "LG*"], ("LG Out", "LG In")),
("Landing Gear", ["Landing?Gear*", "LG*"], ("LG Out", )),
("Ailerons", ["Aileron*"], ("Roll Left", "Roll Right")),
("Rudders", ["Rudder*"], ("Head Left", "Head Right")),
("Elevators", ["Elevator*"], ("Pitch Up", "Pitch Down")))
for line in subparts:
subpart, joints, anims = line
actor.makeSubpart(subpart, joints)
path = "planes/{0}/{0}-{{0}}".format(modelname)
d = dict((anim, path.format(anim)) for anim in anims)
#actor.loadAnims(d, subpart, "mid")
actor.loadAnims(d, subpart)
for anim in anims:
#actor.bindAnim(anim, subpart, "mid")
actor.bindAnim(anim, subpart)
#animcontrols[anim] = actor.getAnimControls(anim, subpart,
# "mid", False)[0]
animcontrols[anim] = actor.getAnimControls(
anim, subpart, None, False)[0]
actor.makeSubpart("propellers", "Propeller*")
actor.verifySubpartsComplete()
actor.setSubpartsComplete(True)
for p in actor.getJoints("propellers", "Propeller*", "lodRoot"):
self.propellers.append(
actor.controlJoint(None, "propellers", p.getName()))
#actor.pprint()
cams = model.findAllMatches("**/camera ?*")
if not cams.isEmpty():
cameras = actor.attachNewNode("cameras")
cams.reparentTo(cameras)
return actor, animcontrols
