def __init__(self, extents, mouse, body, eye): self.extents = extents self.body = body self.eye = eye self.mouse = mouse self.keys = { 'w': False, 's': False, 'd': False, 'a': False, } self.drag = None self.zoomdrag = None self.moving = False self.panning = False self.accept_keyboard() self.accept('console-open', self.ignore_keyboard) self.accept('console-close', self.accept_keyboard) self.accept('mouse3', self.start_drag) self.accept('mouse3-up', self.end_drag) self.accept('mouse2', self.start_zoom) self.accept('mouse2-up', self.end_zoom) taskMgr.add(self.move_camera, "Move Camera")
def __lerp(self, functorFunc, duration, blendType, taskName=None): """ __lerp(self, functorFunc, float, string, string) Basic lerp functionality used by other lerps. Fire off a lerp. Make it a task if taskName given. """ # functorFunc is a function which can be called to create a functor. # functor creation is defered so initial state (sampled in functorFunc) # will be appropriate for the time the lerp is spawned from direct.task import Task from direct.showbase import LerpBlendHelpers from direct.task.TaskManagerGlobal import taskMgr # upon death remove the functorFunc def lerpUponDeath(task): # Try to break circular references try: del task.functorFunc except: pass try: del task.lerp except: pass # make the task function def lerpTaskFunc(task): from pandac.Lerp import Lerp from pandac.ClockObject import ClockObject from direct.task.Task import Task, cont, done if task.init == 1: # make the lerp functor = task.functorFunc() task.lerp = Lerp(functor, task.duration, task.blendType) task.init = 0 dt = globalClock.getDt() task.lerp.setStepSize(dt) task.lerp.step() if (task.lerp.isDone()): # Reset the init flag, in case the task gets re-used task.init = 1 return(done) else: return(cont) # make the lerp task lerpTask = Task.Task(lerpTaskFunc) lerpTask.init = 1 lerpTask.functorFunc = functorFunc lerpTask.duration = duration lerpTask.blendType = LerpBlendHelpers.getBlend(blendType) lerpTask.setUponDeath(lerpUponDeath) if (taskName == None): # don't spawn a task, return one instead return lerpTask else: # spawn the lerp task taskMgr.add(lerpTask, taskName) return lerpTask
def leakTask(task=None, leakTaskName=leakTaskName): base = getBase() taskMgr.add(nullTask, uniqueName(leakTaskName)) taskMgr.doMethodLater(1 << 31, nullDoLater, uniqueName(leakDoLaterName)) taskMgr.doMethodLater(10, leakTask, 'doLeakTask-%s' % serialNum()) if task: return task.done
def recoverFromPickle(self): self.initialize() if self.selected is not None: self.grabModelNP.setPos(render, self.selected.getPos(render)) self.grabModelNP.show() print "grabber sel ", self.selected, " isHidden() ", self.grabModelNP.isHidden(), '\n' taskMgr.add(self.scaleGrabber, 'scaleGrabber')
def moveToFit(self): # How big is the active widget? widgetScale = base.direct.widget.scalingNode.getScale(render) maxScale = max(widgetScale[0], widgetScale[1], widgetScale[2]) # At what distance does the widget fill 50% of the screen? camY = ((2 * base.direct.dr.near * (1.5 * maxScale)) / min(base.direct.dr.nearWidth, base.direct.dr.nearHeight)) # Find a point this distance along the Y axis # MRM: This needs to be generalized to support non uniform frusta centerVec = Y_AXIS * camY # Before moving, record the relationship between the selected nodes # and the widget, so that this can be maintained base.direct.selected.getWrtAll() # Push state onto undo stack base.direct.pushUndo(base.direct.selected) # Remove the task to keep the widget attached to the object taskMgr.remove('followSelectedNodePath') # Spawn a task to keep the selected objects with the widget taskMgr.add(self.stickToWidgetTask, 'stickToWidget') # Spawn a task to move the widget ival = base.direct.widget.posInterval(CAM_MOVE_DURATION, Point3(centerVec), other=base.direct.camera, blendType='easeInOut') ival = Sequence(ival, Func(lambda: taskMgr.remove('stickToWidget')), name='moveToFit') ival.start()
def main(): base = ShowBase() cm = CardMaker('') cm.set_frame(-.5, .5, -.5, .5) # Node which contains all the cards equally spaced apart and which is # animated to move the cards in front of the camera. cards = base.render.attach_new_node(PandaNode('')) cards.setPos(-2, 5, 0) cards.posInterval(2, Point3(-6, 5, 0)).loop() for i in range(5): card = cards.attach_new_node(cm.generate()) card.setPos(i * 2, 0, 0) def on_every_frame(task): # Time which has elapsed since the last frame measured in units of # the time quota available at 60 fps (e.g. 1/60 second). time_quota = taskMgr.globalClock.get_dt() * 60 # Print time use as percent of the 60-fps-quota. print(f'{round(time_quota * 100):4}', end='', flush=True) return Task.DSCont taskMgr.add(on_every_frame) taskMgr.run()
def enable(self): # Kill existing task self.disable() # Initialize tracker self.tracker = base.direct.deviceManager.createTracker(self.device) # Update task taskMgr.add(self.updateTask, self.name + '-updateTask')
def __init__(self): ShowBase.__init__(self) self.clock_ = ClockObject() self.setupInput() taskMgr.add(self.update,"update")
def __spawnTask(self): # Spawn task self.__removeTask() taskName = self.getName() + '-play' task = Task(self.__playTask) task.interval = self taskMgr.add(task, taskName)
def __init__(self): ShowBase.__init__(self) self.cam.setPos(0, -50, 10) self.setupCD() self.addSmiley() self.addFloor() taskMgr.add(self.updateSmiley, "UpdateSmiley")
def __lerp(self, functorFunc, duration, blendType, taskName=None): from direct.task import Task from direct.showbase import LerpBlendHelpers from direct.task.TaskManagerGlobal import taskMgr def lerpTaskFunc(task): from pandac.PandaModules import Lerp from pandac.PandaModules import ClockObject from direct.task.Task import Task, cont, done if task.init == 1: functor = task.functorFunc() task.lerp = Lerp(functor, task.duration, task.blendType) task.init = 0 dt = globalClock.getDt() task.lerp.setStepSize(dt) task.lerp.step() if task.lerp.isDone(): task.init = 1 return done else: return cont lerpTask = Task.Task(lerpTaskFunc) lerpTask.init = 1 lerpTask.functorFunc = functorFunc lerpTask.duration = duration lerpTask.blendType = LerpBlendHelpers.getBlend(blendType) if taskName == None: return lerpTask else: taskMgr.add(lerpTask, taskName) return lerpTask return
def __spawnTask(self): # Spawn task self.__removeTask() taskName = self.getName() + '-play' task = Task(self.__playTask) task.interval = self taskMgr.add(task, taskName)
def __lerp(self, functorFunc, duration, blendType, taskName = None): from direct.task import Task from direct.showbase import LerpBlendHelpers from direct.task.TaskManagerGlobal import taskMgr def lerpTaskFunc(task): from pandac.PandaModules import Lerp from pandac.PandaModules import ClockObject from direct.task.Task import Task, cont, done if task.init == 1: functor = task.functorFunc() task.lerp = Lerp(functor, task.duration, task.blendType) task.init = 0 dt = globalClock.getDt() task.lerp.setStepSize(dt) task.lerp.step() if task.lerp.isDone(): task.init = 1 return done else: return cont lerpTask = Task.Task(lerpTaskFunc) lerpTask.init = 1 lerpTask.functorFunc = functorFunc lerpTask.duration = duration lerpTask.blendType = LerpBlendHelpers.getBlend(blendType) if taskName == None: return lerpTask else: taskMgr.add(lerpTask, taskName) return lerpTask return
def createEnemy(self, x, y, z): #nodes self.enemyBulletNode = BulletRigidBodyNode('PlayerBox') self.enemyBulletNode.setMass(1.0) self.enemyNp = self.renderDummy.attachNewNode(self.enemyBulletNode) self.enemyNp.setPos(x, y, z) print(x, y, z) #shapes shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5)) model = Cube(1, 1, 1) model.reparentTo(self.enemyNp) model.setPos(-.5, -.5, -.5) #nodes self.enemyBulletNode.addShape(shape) material = Material() material.setAmbient(VBase4(random.random(), random.random(), random.random(), random.random())) material.setDiffuse(VBase4(random.random(), random.random(), random.random(), random.random()))# -*- coding: utf-8 *-* material.setEmission(VBase4(random.random(), random.random(), random.random(), random.random())) #material.setSpecular(VBase4(random.random(), random.random(), random.random(), random.random())) material.setShininess(random.random()) myTexture = loader.loadTexture("./textures/enemy.jpg") self.enemyNp.setTexture(myTexture) self.enemyNp.setMaterial(material) #bullet world self.world.attachRigidBody(self.enemyBulletNode) taskMgr.add(self.enemyUpdate, "EnemyUpdateTask#" + str(self.numNpc))
def __init__(self): ShowBase.__init__(self) self.setupInput() self.setupStates() taskMgr.add(self.update,"update")
def enableAvatarControls(self): """ Activate the arrow keys, etc. """ assert self.notify.debugStateCall(self) assert self.collisionsActive #*#if __debug__: #*# self.accept("control-f3", self.spawnTest) #*# # remove any old if self.controlsTask: self.controlsTask.remove() # spawn the new task taskName = "AvatarControls-%s"%(id(self),) self.controlsTask = taskMgr.add(self.handleAvatarControls, taskName, 25) self.isAirborne = 0 self.mayJump = 1 if self.physVelocityIndicator: if self.indicatorTask: self.indicatorTask.remove() self.indicatorTask = taskMgr.add( self.avatarPhysicsIndicator, "AvatarControlsIndicator-%s"%(id(self),), 35)
def __init__(self, extents, mouse, body, eye): self.extents = extents self.body = body self.eye = eye self.mouse = mouse self.keys = { 'w': False, 's': False, 'd': False, 'a': False, } self.drag = None self.zoomdrag = None self.moving = False self.panning = False self.accept_keyboard() self.accept('console-open', self.ignore_keyboard) self.accept('console-close', self.accept_keyboard) self.accept('mouse3', self.start_drag) self.accept('mouse3-up', self.end_drag) self.accept('mouse2', self.start_zoom) self.accept('mouse2-up', self.end_zoom) taskMgr.add(self.move_camera, "Move Camera")
def __init__(self, world, worldNP): self.diamondbackChar = None self.world = world self.worldNP = worldNP # Store which keys are being pressed self.keyPressed = {"fwd": 0, "back": 0, "left": 0, "right": 0} # Setup everything self.createCharacter() self.setupKeys() self.isMoving = False taskMgr.add(self.move, "moveTask") self.pos = OnscreenText(text="POS", style=3, fg=(1, 1, 1, 1), pos=(-0.02, 0.1), scale=.07, parent=base.a2dBottomRight, align=TextNode.ARight) self.lerpAnimation(self.diamondbackChar, "idle")
def __dispatch(self, acceptorDict, event, sentArgs, foundWatch): for id in list(acceptorDict.keys()): # We have to make this apparently redundant check, because # it is possible that one object removes its own hooks # in response to a handler called by a previous object. # # NOTE: there is no danger of skipping over objects due to # modifications to acceptorDict, since the for..in above # iterates over a list of objects that is created once at # the start callInfo = acceptorDict.get(id) if callInfo: method, extraArgs, persistent = callInfo # If this object was only accepting this event once, # remove it from the dictionary if not persistent: # This object is no longer listening for this event eventDict = self.__objectEvents.get(id) if eventDict and event in eventDict: del eventDict[event] if (len(eventDict) == 0): del self.__objectEvents[id] self._releaseObject(self._getObject(id)) del acceptorDict[id] # If the dictionary at this event is now empty, remove # the event entry from the Messenger altogether if (event in self.__callbacks \ and (len(self.__callbacks[event]) == 0)): del self.__callbacks[event] if __debug__: if foundWatch: print("Messenger: \"%s\" --> %s%s"%( event, self.__methodRepr(method), tuple(extraArgs + sentArgs))) #print "Messenger: \"%s\" --> %s%s"%( # event, # self.__methodRepr(method), # tuple(extraArgs + sentArgs)) # It is important to make the actual call here, after # we have cleaned up the accept hook, because the # method itself might call accept() or acceptOnce() # again. assert hasattr(method, '__call__') # Release the lock temporarily while we call the method. self.lock.release() try: result = method (*(extraArgs + sentArgs)) finally: self.lock.acquire() if hasattr(result, 'cr_await'): # It's a coroutine, so schedule it with the task manager. taskMgr.add(result)
def __dispatch(self, acceptorDict, event, sentArgs, foundWatch): for id in list(acceptorDict.keys()): # We have to make this apparently redundant check, because # it is possible that one object removes its own hooks # in response to a handler called by a previous object. # # NOTE: there is no danger of skipping over objects due to # modifications to acceptorDict, since the for..in above # iterates over a list of objects that is created once at # the start callInfo = acceptorDict.get(id) if callInfo: method, extraArgs, persistent = callInfo # If this object was only accepting this event once, # remove it from the dictionary if not persistent: # This object is no longer listening for this event eventDict = self.__objectEvents.get(id) if eventDict and event in eventDict: del eventDict[event] if (len(eventDict) == 0): del self.__objectEvents[id] self._releaseObject(self._getObject(id)) del acceptorDict[id] # If the dictionary at this event is now empty, remove # the event entry from the Messenger altogether if (event in self.__callbacks \ and (len(self.__callbacks[event]) == 0)): del self.__callbacks[event] if __debug__: if foundWatch: print("Messenger: \"%s\" --> %s%s"%( event, self.__methodRepr(method), tuple(extraArgs + sentArgs))) #print "Messenger: \"%s\" --> %s%s"%( # event, # self.__methodRepr(method), # tuple(extraArgs + sentArgs)) # It is important to make the actual call here, after # we have cleaned up the accept hook, because the # method itself might call accept() or acceptOnce() # again. assert hasattr(method, '__call__') # Release the lock temporarily while we call the method. self.lock.release() try: result = method (*(extraArgs + sentArgs)) finally: self.lock.acquire() if hasattr(result, 'cr_await'): # It's a coroutine, so schedule it with the task manager. taskMgr.add(result)
def initializeManipVars(self, transformDir, transformOp, mPos3D, planeNormVec=None): self.currTransformDir = transformDir self.currPlaneColNorm = planeNormVec # set the norm for the collision plane to be used in mouse1Dragging self.interFrameMousePosition = mPos3D self.currTransformOperation = transformOp self.isDragging = True taskMgr.add(self.handleDragging, 'mouse1Dragging') messenger.accept('mouse1-up', self, self.handleM1Up)
def enable(self): # Kill existing task self.disable() # Accept button events self.acceptSwitchModeEvent() self.acceptUprightCameraEvent() # Update task taskMgr.add(self.updateTask, self.name + '-updateTask')
def spawnUpdateObjectUITask(self): if self.currNodePath is None: return taskMgr.remove('_le_updateObjectUITask') t = Task.Task(self.updateObjectUITask) t.np = self.currNodePath taskMgr.add(t, '_le_updateObjectUITask')
def __init__(self): ShowBase.__init__(self) self.init_shader() self.init_light_camera() self.init_bullet_engine() self.setup() self.init_input() taskMgr.add(self.update,'updateWorld')
def __init__(self): LeakDetector.__init__(self) self._typeName2detector = {} self._createJob = None if ConfigVariableBool('leak-message-listeners', False): self._leakers = [] self._leakTaskName = uniqueName('leak-message-listeners') taskMgr.add(self._leak, self._leakTaskName)
def __spawnLocalCannonMoveTask(self): self.leftPressed = 0 self.rightPressed = 0 self.upPressed = 0 self.downPressed = 0 self.cannonMoving = 0 task = Task(self.__localCannonMoveTask) task.lastPositionBroadcastTime = 0.0 taskMgr.add(task, self.LOCAL_CANNON_MOVE_TASK)
def startReaderPollTask(self): """ Task to handle datagrams from client """ # Run this task just after the listener poll task if clusterSyncFlag: # Sync version taskMgr.add(self._syncReaderPollTask, "serverReaderPollTask", -39) else: # Asynchronous version taskMgr.add(self._readerPollTask, "serverReaderPollTask", -39)
def send(self, event, sentArgs=[], taskChain=None): """ Send this event, optionally passing in arguments event is usually a string. sentArgs is a list of any data that you want passed along to the handlers listening to this event. If taskChain is not None, it is the name of the task chain which should receive the event. If taskChain is None, the event is handled immediately. Setting a non-None taskChain will defer the event (possibly till next frame or even later) and create a new, temporary task within the named taskChain, but this is the only way to send an event across threads. """ if Messenger.notify.getDebug() and not self.quieting.get(event): assert Messenger.notify.debug( 'sent event: %s sentArgs = %s, taskChain = %s' % (event, sentArgs, taskChain)) self.lock.acquire() try: foundWatch = 0 if __debug__: if self.__isWatching: for i in self.__watching.keys(): if str(event).find(i) >= 0: foundWatch = 1 break acceptorDict = self.__callbacks.get(event) if not acceptorDict: if __debug__: if foundWatch: print( "Messenger: \"%s\" was sent, but no function in Python listened." % (event, )) return if taskChain: # Queue the event onto the indicated task chain. from direct.task.TaskManagerGlobal import taskMgr queue = self._eventQueuesByTaskChain.setdefault(taskChain, []) queue.append((acceptorDict, event, sentArgs, foundWatch)) if len(queue) == 1: # If this is the first (only) item on the queue, # spawn the task to empty it. taskMgr.add(self.__taskChainDispatch, name='Messenger-%s' % (taskChain), extraArgs=[taskChain], taskChain=taskChain, appendTask=True) else: # Handle the event immediately. self.__dispatch(acceptorDict, event, sentArgs, foundWatch) finally: self.lock.release()
def __init__(self): DirectObject.__init__(self) # 人物动作 self.walk = False self.reverse = False self.left = False self.right = False taskMgr.add(self.updateInput,"update input")
def __init__(self): DirectObject(self) #所有状态 self.__forward = False self.__back = False self.__left = False self.__right = False self.__setting = False self.__attack = False taskMgr.add(self.updateInput,"update input")
def restart(self): if self.eventQueue == None: self.eventQueue = EventQueue.getGlobalEventQueue() if self.eventHandler == None: if self.eventQueue == EventQueue.getGlobalEventQueue(): self.eventHandler = EventHandler.getGlobalEventHandler() else: self.eventHandler = EventHandler(self.eventQueue) taskMgr.add(self.eventLoopTask, 'eventManager') return
def __fireCannonTask(self, task): launchTime = task.fireTime results = self.__calcFlightResults(launchTime) startPos, startHpr, startVel, trajectory, timeOfImpact, hitWhat = results if not results: return self.notify.info('start position: ' + str(startPos)) self.notify.info('start velocity: ' + str(startVel)) self.notify.info('time of launch: ' + str(launchTime)) self.notify.info('time of impact: ' + str(timeOfImpact)) self.notify.info('location of impact: ' + str(trajectory.getPos(timeOfImpact))) self.notify.info('start hpr: ' + str(startHpr)) FlyingProp = self.gag self.generateGravity(FlyingProp) FlyingProp.reparentTo(render) FlyingProp.setPos(startPos) barrelHpr = self.barrel.getHpr(render) FlyingProp.setHpr(startHpr) #FlyingProp.setH(90) #self.gag.setPosHpr(0, 0, 100, 0, 0, 0) # this seems to be affecting the collision sphere btw info = {} info['trajectory'] = trajectory info['launchTime'] = launchTime info['timeOfImpact'] = timeOfImpact info['hitWhat'] = hitWhat info['flyingProp'] = self.gag info['hRot'] = self.cannonPosition[0] info['haveWhistled'] = 0 info['maxCamPullback'] = CAMERA_PULLBACK_MIN self.flyColSphere = CollisionSphere(0, 0, 0, 1.2) self.flyColNode = CollisionNode('flySphere') self.flyColNode.setCollideMask(BitmaskGlobals.FloorBitmask | BitmaskGlobals.WallBitmask) self.flyColNode.addSolid(self.flyColSphere) self.flyColNodePath = self.gag.attachNewNode(self.flyColNode) self.flyColNodePath.setColor(1, 0, 0, 1) # self.flyColNodePath.show() self.handler = CollisionHandlerEvent() self.handler.setInPattern('cannonHit') # uh oh no work! :( << nevermind, should work now base.cTrav.addCollider(self.flyColNodePath, self.handler) print('Cannon pos: {0}'.format(self.cannon.getPos(render))) self.accept('cannonHit', self.__handleCannonHit) base.playSfx(self.sndCannonFire) flyTask = Task(self.__flyTask, 'flyTask') flyTask.info = info taskMgr.add(flyTask, 'flyTask') self.acceptOnce('stopFlyTask', self.__stopFlyTask) self.notify.info('done with __fireCannonTask') return Task.done
def __init__(self): DirectObject.__init__(self) # 所有的状态类别 self.__new_game = False self.__load_game = False self.__description = False self.__exit = False self.__select = False taskMgr.add(self.updateInput,"update input")
def scheduleCallback(self, callback): assert self.notify.debugCall() if not self.__threaded: callback() else: taskName = ('%s-ThreadedTask-%s' % (self.__name, TaskThreaded._Serial.next())) assert taskName not in self.__taskNames self.__taskNames.add(taskName) taskMgr.add(Functor(self.__doCallback, callback, taskName), taskName)
def enterInit(self): ''' init of main/global structures ''' self.screen = Screen() if ConfigVariableBool('stats').getValue(): self.update_gaming=pstat(self.update_gaming) PStatClient.connect() taskMgr.add(self.update, 'GameClient.update') self.acceptOnce('escape',self.demand,extraArgs=['Quit']) self.demand('Intro')
def enableAvatarControls(self): """ Activate the arrow keys, etc. """ assert self.debugPrint("enableAvatarControls") assert self.collisionsActive taskName = "AvatarControls-%s" % (id(self), ) # remove any old taskMgr.remove(taskName) # spawn the new task taskMgr.add(self.handleAvatarControls, taskName)
def __init__(self): #Muestra un texto en pantalla, utilizando la interfaz 2D de Panda3D. #Posteriormente se actualizara con otros datos, por eso se mantiene la referencia self.title = OnscreenText(text="prueba 1", style=1, fg=(0,0,0,1), pos=(0.8,-0.95), scale = .07) #Lee los datos de configuracion de los clasificadores HAAR. En este caso, para deteccion de rostros en posicion frontal self.cascade = cv.Load("haarcascades\\haarcascade_frontalface_alt.xml") #Utiliza por defecto la camara para obtener las imagenes, y no guarda un archivo self.cameraHelper = CameraHelper(True, False, "d:\\face-detection.avi") #Crea una textura para utilizar como fondo, donde se mostraran las imagenes de video #CardMaker en realidad es un poligono rectangular, que es util para asociarlo al renderer2D, ya que #podremos hacer que ocupe toda la pantalla y mostrar nuestras imagenes como fondo. self.cardMaker = CardMaker("My Fullscreen Card"); self.cardMaker.setFrameFullscreenQuad() #Agrega el rectangulo al renderer render2dp. Asi como existe render2d, existe uno adicional que es utilizado #en general para casos donde necesita mostrarse un fondo, sea estatico o de video. El render2d estandar, #por el contrario, se usa para mostrar informacion al usuario que siempre debe ser visible self.card = NodePath(self.cardMaker.generate()) self.card.reparentTo(render2dp) #Le da baja prioridad para que los objetos dibujados posteriormente siempre se vean sobre ella base.cam2dp.node().getDisplayRegion(0).setSort(-20) #Crea un rectangulo que se utilizara para mostrar la imagen superpuesta sobre la cara self.faceMaker = CardMaker("Face Texture"); self.faceImage = NodePath(self.faceMaker.generate()) self.faceImage.setTexture(loader.loadTexture("margarita-glass3.png")) self.faceImage.reparentTo(aspect2d) #self.faceImage.reparentTo(render2d) self.faceImage.setTransparency(TransparencyAttrib.MAlpha) self.setup_handlers() self.setup_lights() self.count = 0 #Establece un fondo negro #base.setBackgroundColor(0, 0, 0) #Carga el objeto tetera (incluido con Panda3D), y lo ubica en el mundo #self.teapot = loader.loadModel('models/teapot') #self.teapot.reparentTo(base.render) #self.teapot.setPos(-10, -10, -10) #Coloca la camara en el origen de coordenadas, y hace que apunte hacia la tetera #camera.setPos(0, 0, 0) #camera.lookAt(-10, -10, -10) taskMgr.add(self.onFrameChanged, "frameChange")
def send(self, event, sentArgs=[], taskChain = None): """ Send this event, optionally passing in arguments event is usually a string. sentArgs is a list of any data that you want passed along to the handlers listening to this event. If taskChain is not None, it is the name of the task chain which should receive the event. If taskChain is None, the event is handled immediately. Setting a non-None taskChain will defer the event (possibly till next frame or even later) and create a new, temporary task within the named taskChain, but this is the only way to send an event across threads. """ if Messenger.notify.getDebug() and not self.quieting.get(event): assert Messenger.notify.debug( 'sent event: %s sentArgs = %s, taskChain = %s' % ( event, sentArgs, taskChain)) self.lock.acquire() try: foundWatch=0 if __debug__: if self.__isWatching: for i in self.__watching.keys(): if str(event).find(i) >= 0: foundWatch=1 break acceptorDict = self.__callbacks.get(event) if not acceptorDict: if __debug__: if foundWatch: print("Messenger: \"%s\" was sent, but no function in Python listened."%(event,)) return if taskChain: # Queue the event onto the indicated task chain. from direct.task.TaskManagerGlobal import taskMgr queue = self._eventQueuesByTaskChain.setdefault(taskChain, []) queue.append((acceptorDict, event, sentArgs, foundWatch)) if len(queue) == 1: # If this is the first (only) item on the queue, # spawn the task to empty it. taskMgr.add(self.__taskChainDispatch, name = 'Messenger-%s' % (taskChain), extraArgs = [taskChain], taskChain = taskChain, appendTask = True) else: # Handle the event immediately. self.__dispatch(acceptorDict, event, sentArgs, foundWatch) finally: self.lock.release()
def __init__(self, level, chunks): ShowBase.__init__(self) self.level = level self.disableMouse() wp = WindowProperties() #wp.setFullscreen(True) wp.setCursorHidden(True) wp.setMouseMode(WindowProperties.M_relative) #wp.setSize(800, 500) self.win.requestProperties(wp) self.camLens.setFov(VisualizerApp.FOV) self.keyMap = { 'forward': 0, 'backward': 0, 'left': 0, 'right': 0, 'shift': 0 } self.setBackgroundColor(0.53, 0.80, 0.92, 1) self.accept('escape', sys.exit) self.accept("a", self.set_key, ["left", True]) self.accept("d", self.set_key, ["right", True]) self.accept("w", self.set_key, ["forward", True]) self.accept("s", self.set_key, ["backward", True]) self.accept('lshift', self.set_key, ['shift', True]) self.accept("a-up", self.set_key, ["left", False]) self.accept("d-up", self.set_key, ["right", False]) self.accept("w-up", self.set_key, ["forward", False]) self.accept("s-up", self.set_key, ["backward", False]) self.accept('lshift-up', self.set_key, ['shift', False]) self.cameraMovementTask = taskMgr.add(self.camera_movement, "CameraMovement") self.cameraRotationTask = taskMgr.add(self.camera_rotation, 'CameraRotation') self.position_text = OnscreenText(text="Position: \nChunk: ", align=TextNode.ALeft, parent=self.pixel2d, fg=(1, 1, 1, 1), bg=(0, 0, 0, 0.7)) self.position_text.setScale(18) self.position_text.setPos(5, -20) self.taskMgr.setupTaskChain('chunk_loader_chain', numThreads=6) self.create_lights() self.taskMgr.doMethodLater(0, self.load_chunks, 'Load Chunks', extraArgs=[chunks], appendTask=True) self.camera.setPos(-64 * 5, 54 * 5, 100)
def __init__(self, dev): ShowBase.__init__(self) render.setAntialias(AntialiasAttrib.MMultisample) render.setShaderAuto() # gets us shadows self.dev = dev self.zeroing = None self.load_models() self.setup_lights() self.setup_camera() taskMgr.add(self.move_task, 'move') taskMgr.add(self.colour_change, 'col')
def __decButtonDown(self, event): assert self.notify.debugStateCall(self) task = Task(self.__scrollByTask) task.setDelay(1.0 / self.__scrollSpeed) task.prevTime = 0.0 task.delta = -1 taskName = self.taskName("scroll") #print "decButtonDown: adding ", taskName taskMgr.add(task, taskName) self.scrollBy(task.delta) messenger.send('wakeup') if self.__decButtonCallback: self.__decButtonCallback()
def setup_world(self): self.world_node = self.render.attachNewNode('World') self.world.setGravity(Vec3(0, 0, -9.81)) # Landscape model = self.loader.loadModel("mesh/models/landscape/landscape") model.reparentTo(self.render) model.setScale(100) model.flatten_light() geom_nodes = model.findAllMatches('**/+GeomNode') geom_node = geom_nodes.getPath(0).node() geom_mesh = geom_node.getGeom(0) mesh = BulletTriangleMesh() mesh.add_geom(geom_mesh) ground_shape = BulletTriangleMeshShape(mesh, dynamic=False) ground_node = self.world_node.attachNewNode( BulletRigidBodyNode('Ground')) ground_node.node().addShape(ground_shape) ''' if self.debug_mode: debug_node_path = self.world_node.attachNewNode(BulletDebugNode('Debug')) debug_node_path.show() debug_node_path.node().showNormals(True) self.world.setDebugNode(debug_node_path.node()) ''' self.debug_node_path = self.world_node.attachNewNode( BulletDebugNode('Debug')) self.debug_node_path.hide() self.world.setDebugNode(self.debug_node_path.node()) ground_node.setPos(0, 0, 0) ground_node.setCollideMask(BitMask32.allOn()) self.world.attachRigidBody(ground_node.node()) # Character player = Player() # Other models path = 'mesh/models/bullet/pyramid' self.add_model(path, pos_x=50, pos_y=15, pos_z=370, scale=5) self.add_model(path, pos_x=30, pos_y=15, pos_z=370, scale=5) self.add_model(path, pos_x=70, pos_y=15, pos_z=390, scale=5) self.add_model(path, pos_x=50, pos_y=40, pos_z=360, scale=5) path = 'mesh/models/bullet/ball' self.add_model(path, pos_x=0, pos_y=15, pos_z=400, scale=8) self.add_model(path, pos_x=30, pos_y=40, pos_z=450, scale=8) taskMgr.add(self.update, 'updateWorld')
def restart(self): if self.eventQueue is None: self.eventQueue = EventQueue.getGlobalEventQueue() if self.eventHandler is None: if self.eventQueue == EventQueue.getGlobalEventQueue(): # If we are using the global event queue, then we also # want to use the global event handler. self.eventHandler = EventHandler.getGlobalEventHandler() else: # Otherwise, we need our own event handler. self.eventHandler = EventHandler(self.eventQueue) taskMgr.add(self.eventLoopTask, 'eventManager')
def editStart(self, event): taskMgr.remove('guiEditTask') vWidget2render2d = self.getPos(ShowBaseGlobal.render2d) vMouse2render2d = Point3(event.getMouse()[0], 0, event.getMouse()[1]) editVec = Vec3(vWidget2render2d - vMouse2render2d) if base.mouseWatcherNode.getModifierButtons().isDown( KeyboardButton.control()): t = taskMgr.add(self.guiScaleTask, 'guiEditTask') t.refPos = vWidget2render2d t.editVecLen = editVec.length() t.initScale = self.getScale() else: t = taskMgr.add(self.guiDragTask, 'guiEditTask') t.editVec = editVec
def restart(self): if self.eventQueue == None: self.eventQueue = EventQueue.getGlobalEventQueue() if self.eventHandler == None: if self.eventQueue == EventQueue.getGlobalEventQueue(): # If we are using the global event queue, then we also # want to use the global event handler. self.eventHandler = EventHandler.getGlobalEventHandler() else: # Otherwise, we need our own event handler. self.eventHandler = EventHandler(self.eventQueue) taskMgr.add(self.eventLoopTask, 'eventManager')
def connect(self) -> None: # Handle connections and terminations self.manager = QueuedConnectionManager() # Wait for clients connection requests self.listener = QueuedConnectionListener(self.manager, 0) # Buffers incoming data from active connection self.reader = QueuedConnectionReader(self.manager, 0) # Transmit PyDatagrams to active connection self.writer = ConnectionWriter(self.manager, 0) # Open TCP Rendezvous to accept client connections with a limit self.socket = self.manager.openTCPServerRendezvous( self.port, self.backlog) self.listener.addConnection(self.socket) print("Server listening on port %s...." % str(self.port)) # Listen for mew incoming connections taskMgr.add(self.handle_incoming_connections, "Poll the connection listener", -39) # Listen for new datagrams taskMgr.add(self.handle_connection_data, "Poll the connection reader", -40) # Listen for dropped connections taskMgr.add(self.handle_dropped_connections, "Poll the dropped connection listener", -41) # See if game can be started taskMgr.add(self.start_game, "Start Game", -42)
def __init__(self, audio_manager, listener_target = None, root = None, taskPriority = 51): self.audio_manager = audio_manager self.listener_target = listener_target if (root==None): self.root = render else: self.root = root self.sound_dict = {} self.vel_dict = {} self.listener_vel = VBase3(0, 0, 0) taskMgr.add(self.update, "Audio3DManager-updateTask", taskPriority)
def restart(self): if None in (EventManager.EventQueue, EventManager.EventHandler): from pandac.PandaModules import EventQueue, EventHandler EventManager.EventQueue = EventQueue EventManager.EventHandler = EventHandler if self.eventQueue == None: self.eventQueue = EventManager.EventQueue.getGlobalEventQueue() if self.eventHandler == None: if self.eventQueue == EventManager.EventQueue.getGlobalEventQueue(): self.eventHandler = EventManager.EventHandler.getGlobalEventHandler() else: self.eventHandler = EventManager.EventHandler(self.eventQueue) from direct.task.TaskManagerGlobal import taskMgr taskMgr.add(self.eventLoopTask, 'eventManager') return
def __init__(self, audio_manager, listener_target = None, root = None, taskPriority = 51): self.audio_manager = audio_manager self.listener_target = listener_target if (root==None): self.root = render else: self.root = root self.sound_dict = {} self.vel_dict = {} self.listener_vel = VBase3(0, 0, 0) taskMgr.add(self.update, "Audio3DManager-updateTask", taskPriority)
def startSmooth(self): """ This function starts the task that ensures the node is positioned correctly every frame. However, while the task is running, you won't be able to lerp the node or directly position it. """ if not self.wantsSmoothing() or self.isDisabled() or self.isLocal(): return if not self.smoothStarted: taskName = self.taskName("smooth") taskMgr.remove(taskName) self.reloadPosition() taskMgr.add(self.doSmoothTask, taskName) self.smoothStarted = 1
def __init__(self, world, z): core.NodePath.__init__(self, 'slice-{}'.format(z)) if Slice.master is None: Slice.master = MasterChunk(self.chunk_size, world.forms.values()) self.world = world self.z = z self.chunks = {} self.hidden_chunks = {} self.setPos(0, 0, z) self.substances = [None] + [ loader.loadTexture('media/textures/{}.png'.format(name), anisotropicDegree=16, minfilter=core.Texture.FTLinearMipmapLinear) for name in ['dirt', 'stone'] ] self.hiddentexture = loader.loadTexture('media/textures/hidden.png', anisotropicDegree=16, minfilter=core.Texture.FTLinearMipmapLinear) self.hiddentexture.setWrapU(core.Texture.WMClamp) self.hiddentexture.setWrapV(core.Texture.WMClamp) self.show_stale_chunks = False self.updates = set() self.first_update_done = False self.task = taskMgr.add(self.perform_updates, 'Slice update') messenger.accept('console-command', self, self.command)
def shoot(self): self.ammoUsed = 0 self.ammoUsed += 1 #nodes node = BulletRigidBodyNode('Box') node.setMass(.1) ammoNode = render.attachNewNode(node) #shapes shape = BulletSphereShape(.2) model = Sphere(.2) model.reparentTo(ammoNode) model.setPos(0, 0, 0) #nodes node.addShape(shape) material = Material() material.setAmbient(VBase4(random.random(), random.random(), random.random(), random.random())) material.setDiffuse(VBase4(random.random(), random.random(), random.random(), random.random())) material.setEmission(VBase4(random.random(), random.random(), random.random(), random.random())) material.setShininess(random.random()) #myTexture = loader.loadTexture("player.png") #ammoNode.setTexture(myTexture) ammoNode.setMaterial(material) ammoNode.setX(self.enemyNp.getX()) ammoNode.setY(self.enemyNp.getY()) ammoNode.setZ(self.enemyNp.getZ() + 1) force = Vec3(0, 0, 0) force.setY(5) force.setZ(1) force*=50 force = render.getRelativeVector(self.player, force) ammoNode.node().applyCentralForce(force) print(force) #bullet world self.world.attachRigidBody(node) #taskMgr.remove('ammoDestroy') task = Task(self.destroyAmmoNode) taskMgr.add(task, 'ammoDestroy', extraArgs = [task, ammoNode, node, self.world])
def add(self, job): pri = job.getPriority() jobId = job._getJobId() self._pri2jobId2job.setdefault(pri, {}) self._pri2jobId2job[pri][jobId] = job self._jobId2pri[jobId] = pri self._pri2jobIds.setdefault(pri, []) self._pri2jobIds[pri].append(jobId) self._jobId2timeslices[jobId] = pri self._jobId2overflowTime[jobId] = 0.0 self._jobIdGenerator = None if len(self._jobId2pri) == 1: taskMgr.add(self._process, JobManager.TaskName) self._highestPriority = pri elif pri > self._highestPriority: self._highestPriority = pri self.notify.debug('added job: %s' % job.getJobName()) return
def send (self, orig_event, sent_args=[], task_chain=None): event = 'panda-' + orig_event self.lock.acquire() try: if task_chain: from direct.task.TaskManagerGlobal import taskMgr queue = self._patch_event_queues [task_chain] queue.append ((event, sent_args)) if len (queue) == 1: taskMgr.add (self._patch_task_chain_forward, name = '_patch_Messenger-%s' % (task_chain), extraArgs = [task_chain], taskChain = task_chain, appendTask = True) else: self._patch_forward (event, sent_args) finally: self.lock.release()
def enable(self, x): """Turn the buffer viewer on or off. The initial state of the buffer viewer depends on the Config variable 'show-buffers'.""" if (x != 0) and (x != 1): BufferViewer.notify.error('invalid parameter to BufferViewer.enable') return self.enabled = x self.dirty = 1 if (x and self.task == 0): self.task = taskMgr.add(self.maintainReadout, "buffer-viewer-maintain-readout", priority=1)
def restart(self): if None in (EventManager.EventQueue, EventManager.EventHandler): from pandac.PandaModules import EventQueue, EventHandler EventManager.EventQueue = EventQueue EventManager.EventHandler = EventHandler if self.eventQueue == None: self.eventQueue = EventManager.EventQueue.getGlobalEventQueue() if self.eventHandler == None: if self.eventQueue == EventManager.EventQueue.getGlobalEventQueue(): # If we are using the global event queue, then we also # want to use the global event handler. self.eventHandler = EventManager.EventHandler.getGlobalEventHandler() else: # Otherwise, we need our own event handler. self.eventHandler = EventManager.EventHandler(self.eventQueue) # Should be safe to import the global taskMgr by now. from direct.task.TaskManagerGlobal import taskMgr taskMgr.add(self.eventLoopTask, 'eventManager')
def send(self, event, sentArgs = [], taskChain = None): if Messenger.notify.getDebug() and not self.quieting.get(event): pass self.lock.acquire() try: foundWatch = 0 acceptorDict = self.__callbacks.get(event) if not acceptorDict: return if taskChain: from direct.task.TaskManagerGlobal import taskMgr queue = self._eventQueuesByTaskChain.setdefault(taskChain, []) queue.append((acceptorDict, event, sentArgs, foundWatch)) if len(queue) == 1: taskMgr.add(self.__taskChainDispatch, name='Messenger-%s' % taskChain, extraArgs=[taskChain], taskChain=taskChain, appendTask=True) else: self.__dispatch(acceptorDict, event, sentArgs, foundWatch) finally: self.lock.release()
def __prepareToStart(self): """ This is called internally when transitioning from S_ready to S_started. It sets up whatever initial values are needed. Assumes self.packageLock is held. Returns False if there were no packages to download, and the state was therefore transitioned immediately to S_done. """ if not self.needsDownload: self.state = self.S_done return False self.state = self.S_started assert not self.downloadTask self.downloadTask = taskMgr.add( self.__downloadPackageTask, 'downloadPackage', taskChain = self.taskChain) assert not self.progressTask self.progressTask = taskMgr.add( self.__progressTask, 'packageProgress') return True
def add(self, job): pri = job.getPriority() jobId = job._getJobId() # store the job in the main table self._pri2jobId2job.setdefault(pri, {}) self._pri2jobId2job[pri][jobId] = job # and also store a direct mapping from the job's ID to its priority self._jobId2pri[jobId] = pri # add the jobId onto the end of the list of jobIds for this priority self._pri2jobIds.setdefault(pri, []) self._pri2jobIds[pri].append(jobId) # record the job's relative timeslice count self._jobId2timeslices[jobId] = pri # init the overflow time tracking self._jobId2overflowTime[jobId] = 0. # reset the jobId round-robin self._jobIdGenerator = None if len(self._jobId2pri) == 1: taskMgr.add(self._process, JobManager.TaskName) self._highestPriority = pri elif pri > self._highestPriority: self._highestPriority = pri self.notify.debug('added job: %s' % job.getJobName())