def setupCollHandlers(self):
###### Collisions ######
base.cTrav = CollisionTraverser()
self.collisionHandler = CollisionHandlerEvent()
self.wallHandler = CollisionHandlerPusher()
self.collisionHandler.addInPattern('%fn-into-%in')
# this is on the other hand the relative call for the OUT event, as is when the FROM object (heart) goes OUT the INTO oject (heart).
self.collisionHandler.addOutPattern('%fn-out-%in')
def setupWallSphere(self, bitmask, avatarRadius):
self.avatarRadius = avatarRadius
cSphere = CollisionSphere(0.0, 0.0, self.avatarRadius + 0.75,
self.avatarRadius)
cSphereNode = CollisionNode('Flyer.cWallSphereNode')
cSphereNode.addSolid(cSphere)
cSphereNodePath = self.avatarNodePath.attachNewNode(cSphereNode)
cSphereNode.setFromCollideMask(bitmask)
cSphereNode.setIntoCollideMask(BitMask32.allOff())
if config.GetBool('want-fluid-pusher', 0):
self.pusher = CollisionHandlerFluidPusher()
else:
self.pusher = CollisionHandlerPusher()
self.pusher.addCollider(cSphereNodePath, self.avatarNodePath)
self.cWallSphereNodePath = cSphereNodePath
def createCollisionHandlers(self):
# Create a new collision traverser instance. We will use this to determine
# if any collisions occurred after performing movement.
self.cTrav = CollisionTraverser()
camGroundRay = CollisionRay()
camGroundRay.setOrigin(0, 0, 1000)
camGroundRay.setDirection(0, 0, -1)
camGroundCol = CollisionNode('camRay')
camGroundCol.addSolid(camGroundRay)
camGroundCol.setFromCollideMask(BitMask32.bit(0))
camGroundCol.setIntoCollideMask(BitMask32.allOff())
camGroundColNp = base.camera.attachNewNode(camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(camGroundColNp, self.camGroundHandler)
# register the collision pusher
self.pusher = CollisionHandlerPusher()
# register collision event pattern names
self.pusher.addInPattern('col-%fn-into')
#=========================================================================
# Main
""" As suggested above, we're going to use what we learned so far to make collide 2d and 3d objects. By the way there is nothing special to do from 3d-3d collisions cos the colliders and handlers used are exactly the same as you'll see.
"""
#=========================================================================
#** Collision system ignition
base.cTrav = CollisionTraverser()
#** This is the known collision handler we use for floor collisions. We'll keep going with the usual settings here as well.
avatarFloorHandler = CollisionHandlerGravity()
avatarFloorHandler.setGravity(9.81 + 25)
avatarFloorHandler.setMaxVelocity(100)
#** the walls collider
wallHandler = CollisionHandlerPusher()
#** we'll use this to 'sense' the fallout impact velocity and also to 'read' various triggers we've put around the map for several purposes.
collisionEvent = CollisionHandlerEvent()
#** Collision masks - this time there is a new one: the TRIGGER_MASK is used to detect certain collision geometry to act as a trigger, therefore we need to distinguish'em from floor and walls.
FLOOR_MASK = BitMask32.bit(1)
WALL_MASK = BitMask32.bit(2)
TRIGGER_MASK = BitMask32.bit(3)
#** Our steering avatar
avatarNP = base.render.attachNewNode(ActorNode('yolkyNP'))
avatarNP.reparentTo(base.render)
# by the way: this time we wont use the same old smiley but a 2d guy for this snippet purposes only - it is just a plane with a texture glued on, a so 2d object then.
avatar = loader.loadModel('yolky')
avatar.reparentTo(avatarNP)
def __init__(self):
from pandac.PandaModules import CollisionHandlerFloor, CollisionHandlerPusher, CollisionHandlerEvent, CollisionTraverser
from pandac.PandaModules import DirectionalLight, AmbientLight, VBase4
ShowBase.__init__(self)
self.sky = self.loader.loadModel('models/sky-sphere')
self.sky.reparentTo(self.render)
self.stage = self.loader.loadModel('models/test-collide')
self.stage.reparentTo(self.render)
self.floor = self.stage.findAllMatches('**/=CollideType=floor')
self.floor.setCollideMask(FLOOR_MASK)
self.obstacles = self.stage.findAllMatches('**/=CollideType=obstacle')
if self.obstacles:
self.obstacles.setCollideMask(OBSTACLE_MASK)
self.zones = self.stage.findAllMatches('**/=CollideType=zone')
if self.zones:
self.zones.setCollideMask(ZONE_MASK)
self.create_stanchions()
# Character rig, which allows camera to follow character
self.char_rig = self.stage.attachNewNode('char_rig')
self.active_char = Character('mainchar', self.char_rig)
self.cam.reparentTo(self.char_rig)
self.cam.setPos(0.5, -3, 1.5)
self.cam.lookAt(0.5, 0, 1.5)
self.light = DirectionalLight('dlight')
self.light.setColor(VBase4(0.3, 0.28, 0.26, 1.0))
self.lightNP = self.stage.attachNewNode(self.light)
self.lightNP.setHpr(-75, -45, 0)
self.stage.setLight(self.lightNP)
self.amblight = AmbientLight('amblight')
self.amblight.setColor(VBase4(0.7, 0.68, 0.66, 1.0))
self.amblightNP = self.stage.attachNewNode(self.amblight)
self.stage.setLight(self.amblightNP)
self.accept('w', self.active_char.begin_forward)
self.accept('a', self.active_char.begin_left)
self.accept('s', self.active_char.begin_backward)
self.accept('d', self.active_char.begin_right)
self.accept('w-up', self.active_char.end_forward)
self.accept('a-up', self.active_char.end_left)
self.accept('s-up', self.active_char.end_backward)
self.accept('d-up', self.active_char.end_right)
self.taskMgr.add(self.active_char.MoveTask, 'MoveTask')
self.look = False
self.prev_pos = None
self.accept('mouse2', self.begin_look)
self.accept('mouse2-up', self.end_look)
self.accept('mouse3', self.active_char.begin_spin)
self.accept('mouse3-up', self.active_char.end_spin)
self.taskMgr.add(self.MouseTask, 'MouseTask')
self.floor_handler = CollisionHandlerFloor()
self.floor_handler.addCollider(self.active_char.actor_from_floor,
self.char_rig)
self.wall_handler = CollisionHandlerPusher()
self.wall_handler.addCollider(self.active_char.actor_from_obstacle,
self.char_rig)
self.zone_handler = CollisionHandlerEvent()
self.zone_handler.addInPattern('%fn-into')
self.zone_handler.addOutPattern('%fn-out')
def foo(entry):
print 'You are in the zone'
def bar(entry):
print 'You are not in the zone'
self.accept('blockchar_zone-into', foo)
self.accept('blockchar_zone-out', bar)
self.cTrav = CollisionTraverser('main traverser')
self.cTrav.setRespectPrevTransform(True)
self.cTrav.addCollider(self.active_char.actor_from_floor,
self.floor_handler)
self.cTrav.addCollider(self.active_char.actor_from_obstacle,
self.wall_handler)
self.cTrav.addCollider(self.active_char.actor_from_zone,
self.zone_handler)
from direct.showbase.DirectObject import DirectObject
from pandac.PandaModules import CollisionHandlerEvent, CollisionHandlerQueue, CollisionHandlerFloor, CollisionHandlerPusher, CollisionNode, CollisionTube, CollisionSphere, CollisionRay, CollisionTraverser, BitMask32
from doomsday.base import Globals, SoundBank
from doomsday.world.Splat import Splat
from panda3d.core import Vec4, Vec3
import math
collHdl = CollisionHandlerEvent()
collHdlF = CollisionHandlerFloor()
collHdlF.setMaxVelocity(8)
collHdlPush = CollisionHandlerPusher()
class WorldCollisions(DirectObject):
def __init__(self):
base.cTrav = CollisionTraverser()
self.called = False
def handleInCollisions(self, entry):
cogCollNames = ['coll_body', 'coll_crit']
intoNode = entry.getIntoNodePath()
fromNode = entry.getFromNodePath()
if (self.called):
return
self.called = True
splatColor = Vec4(0.7, 0.7, 0.8, 1.0)
splatScale = 0.7
if (intoNode.getName() in cogCollNames):
cog = intoNode.getParent().getPythonTag('Cog')
gag = fromNode.getParent().getPythonTag('Stats')
splatColor = gag.getSplatColor()
def __init__(self):
# Load the environment model.
environ = loader.loadModel("zebrafishEnviron17_100contrast")
environ.reparentTo(render)
environ.setScale(1, 1, 1)
environ.setPos(0, 0, 0)
# Load AVI texture
self.tex1 = loader.loadTexture("VRE_autoPA_bigFish.avi")
self.tex2 = loader.loadTexture("VRE_autoPA_hE.avi")
self.tex3 = loader.loadTexture("VRE_autoPA_vE.avi")
self.tex4 = loader.loadTexture("VRE_autoPA_bigFeeding.avi")
self.texBG = loader.loadTexture("VRE_autoPA_realFishBG.jpg")
self.texBG4 = loader.loadTexture("VRE_autoPA_feedingBG.jpg")
self.sound1 = loader.loadSfx("VRE_autoPA_realFish.avi")
self.sound2 = loader.loadSfx("VRE_autoPA_hE.avi")
self.sound3 = loader.loadSfx("VRE_autoPA_vE.avi")
self.sound4 = loader.loadSfx("VRE_autoPA_feeding.avi")
self.tex1.synchronizeTo(self.sound1)
self.tex2.synchronizeTo(self.sound2)
self.tex3.synchronizeTo(self.sound3)
self.tex4.synchronizeTo(self.sound4)
# Load TV model and apply baseline texture
self.TV1 = loader.loadModel("zebrafishEnviron4TV3")
self.TV2 = loader.loadModel("zebrafishEnviron4TV3")
self.TV1.reparentTo(render)
self.TV2.reparentTo(render)
self.TV1.setTexture(self.tex1, 1)
self.TV2.setTexture(self.tex1, 1)
self.TV1.setPos(0, -20.3, 0)
self.TV2.setPos(0, 20.3, 0)
self.TV2.setH(180)
# Add the spinCameraTask procedure to the task manager.
taskMgr.add(self.spinCameraTask, "SpinCameraTask")
# KH: taskMgr is an attribute of class ShowBase. It keeps a list of currently-running taks. ".add()" is a method of taskMgr.
# self.spinCameraTask is a function defined below. "SpinCameraTask" can be an arbitrary name.
base.disableMouse()
base.camera.setPos(0, 0, 5)
base.camLens.setFov(
40
) # Necessary to set bot horizontal and vertical FOV. If only set horizontal, vertical FOV will be calculated using the aspect ratio of the window.
base.setAspectRatio(
1.33
) # Override window's aspect ratio, which is 3X wider, as specified in the beginning
# Turn off the default camera and replace it with 3 cameras, with side-by-side displayRegions.
base.camNode.setActive(0)
base.makeCamera(base.win,
displayRegion=(0.33, 0.66, 0, 1),
lens=base.camLens) # central camera
base.makeCamera(base.win,
displayRegion=(0, 0.33, 0, 1),
lens=base.camLens) # left camera
base.makeCamera(base.win,
displayRegion=(0.66, 0.99, 0, 1),
lens=base.camLens) # right camera
base.camList[1].setH(0)
base.camList[2].setH(40)
base.camList[3].setH(-40)
# Set collision rules
base.cTrav = CollisionTraverser()
environ_mask = BitMask32.bit(2)
camera.setCollideMask(
BitMask32.allOff()
) # KH: visible geometry nodes also have an "into" mask. Collision should not act on these nodes. Turn the mask off.
cameraCN = CollisionNode('eye') # KH: collision node
cameraCN.addSolid(CollisionSphere(0, 0, 0, 1))
cameraCN.setFromCollideMask(environ_mask)
cameraCN.setIntoCollideMask(BitMask32.allOff())
cameraCNP = camera.attachNewNode(cameraCN) # KH: collision node path
environ.setCollideMask(BitMask32.allOff())
environ.setScale(1)
wallCNP = environ.find(
"**/wall_collide"
) # KH: CNP for environ, you manually set the <Collide> tag in egg file
wallCNP.node().setIntoCollideMask(environ_mask)
eHandler = CollisionHandlerPusher()
eHandler.addCollider(cameraCNP, camera)
base.cTrav.addCollider(cameraCNP, eHandler)
# communicate with LabView using ActiveX
LabVIEW = win32com.client.Dispatch("Labview.Application")
self.VI = LabVIEW.getvireference(
'C:\\Friedrich KH\\LabviewPython_reset.vi') # Path to LabVIEW VI
self.VI._FlagAsMethod("Call") # Flag "Call" as Method
