def __init__(self, render, camera):
#Since we are using collision detection to do picking, we set it up like any other collision detection system with a traverser and a handler
self.picker = CollisionTraverser() #Make a traverser
self.pq = CollisionHandlerQueue() #Make a handler
#Make a collision node for our picker ray
self.pickerNode = CollisionNode('mouseRay')
#Attach that node to the camera since the ray will need to be positioned relative to it
self.pickerNP = camera.attachNewNode(self.pickerNode)
#Everything to be picked will use bit 1. This way if we were doing other collision we could seperate it
self.pickerNode.setFromCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay() #Make our ray
self.pickerNode.addSolid(self.pickerRay) #Add it to the collision node
#Register the ray as something that can cause collisions
self.picker.addCollider(self.pickerNP, self.pq)
#self.picker.showCollisions(render)
self.pst = CollisionTraverser() #Make a traverser
self.hqp = CollisionHandlerQueue() #Make a handler
#Make a collision node for our picker ray
self.pstNode = CollisionNode('mouseRaytoObj')
#Attach that node to the camera since the ray will need to be positioned relative to it
self.pstNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pstNode2 = camera.attachNewNode(self.pstNode)
self.pickerRayObj = CollisionRay()
#Everything to be picked will use bit 1. This way if we were doing other collision we could seperate it
#self.pstNode.setFromCollideMask(BitMask32.bit(1))
self.pstNode.addSolid(self.pickerRayObj) #Add it to the collision node
#Register the ray as something that can cause collisions
self.pst.addCollider(self.pstNode2, self.hqp)
#self.pst.showCollisions(render)
def __init__(self,gmap,gaming_zone):
DirectObject.__init__(self)
#gaming zone (used for mouse movement), as a tools.Rectangle
self.gaming_zone=gaming_zone
#actual camera node
self.p3dcam=base.camera
#what the cam is oriented to
self._target=base.render.attachNewNode('GaminCam.target')
#range=[0,1] between min and max closeness to ground
self.level=.7
#
#keys_down acts as a pool containing keys (+mouse buttons) currently down
self.keys_down=[]
update_list.append(self.update)
#setup for mouse picking
picker_node=CollisionNode('gcam_to_mouse_ray')#general collision node
picker_node.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.picker_ray=CollisionRay()#solid ray to attach to coll node
picker_node.addSolid(self.picker_ray)
self.picker_np=self.p3dcam.attachNewNode(picker_node)#attach this node to gcam
self.collision_queue=CollisionHandlerQueue()#stores collisions
self.collision_traverser=CollisionTraverser('gcam_traverser')#actual computer
self.collision_traverser.addCollider(self.picker_np,self.collision_queue)
base.cTrav=self.collision_traverser
self.gmap=gmap
#stack of states (state=pos+zoom)
self.states_stack=[]
#enable the cam to move according to keyboard and mouse
self.move_enabled=True
def collideWithGeom(self):
# The into collide mask is the bit pattern colliders look at
# when deciding whether or not to test for a collision "into"
# this collision solid. Set to all Off so this collision solid
# will not be considered in any collision tests
self.collisionNode.setIntoCollideMask(BitMask32().allOff())
# The from collide mask is the bit pattern *this* collision solid
# compares against the into collide mask of candidate collision solids
# Turn this mask all off since we're not testing for collisions against
# collision solids, but we do want to test against geometry
self.collisionNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
def init_collide(self):
from pandac.PandaModules import CollisionTraverser, CollisionNode
from pandac.PandaModules import CollisionHandlerQueue, CollisionRay
self.cTrav = CollisionTraverser('MousePointer')
self.cQueue = CollisionHandlerQueue()
self.cNode = CollisionNode('MousePointer')
self.cNodePath = base.camera.attachNewNode(self.cNode)
self.cNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.cRay = CollisionRay()
self.cNode.addSolid(self.cRay)
self.cTrav.addCollider(self.cNodePath, self.cQueue)
def create_ray(self, object, entity, name, show = False, x = 0, y = 0, z = 0,
dx = 0, dy = 0, dz = -1):
# create queue
object.queue = CollisionHandlerQueue()
# create ray
object.rayNP = entity.attachNewNode(CollisionNode(name))
object.ray = CollisionRay(x, y, 1, dx, dy, dz)
object.rayNP.node().addSolid(object.ray)
object.rayNP.node().setFromCollideMask(GeomNode.getDefaultCollideMask())
base.cTrav.addCollider(object.rayNP, object.queue)
if show:
object.rayNP.show()
def init_collide(self):
# why the heck he import within method
from pandac.PandaModules import CollisionTraverser, CollisionNode
from pandac.PandaModules import CollisionHandlerQueue, CollisionRay
# init and import collision for object
self.cTrav = CollisionTraverser('MousePointer')
self.cQueue = CollisionHandlerQueue()
self.cNode = CollisionNode('MousePointer')
self.cNodePath = base.camera.attachNewNode(self.cNode)
self.cNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.cRay = CollisionRay()
self.cNode.addSolid(self.cRay)
self.cTrav.addCollider(self.cNodePath, self.cQueue)
def createRay(
self, obj, ent, name, show=False, x=0, y=0, z=0, dx=0, dy=0, dz=-1
):
#create queue
obj.queue = CollisionHandlerQueue()
#create ray
obj.rayNP = ent.attachNewNode(CollisionNode(name))
obj.ray = CollisionRay(x, y, z, dx, dy, dz)
obj.rayNP.node().addSolid(obj.ray)
obj.rayNP.node().setFromCollideMask(GeomNode.getDefaultCollideMask())
sandbox.pickTrav.addCollider(obj.rayNP, obj.queue)
if show:
obj.rayNP.show()
def createRay(self,
obj,
ent,
name,
show=False,
x=0,
y=0,
z=0,
dx=0,
dy=0,
dz=-1):
#create queue
obj.queue = CollisionHandlerQueue()
#create ray
obj.rayNP = ent.attachNewNode(CollisionNode(name))
obj.ray = CollisionRay(x, y, z, dx, dy, dz)
obj.rayNP.node().addSolid(obj.ray)
obj.rayNP.node().setFromCollideMask(GeomNode.getDefaultCollideMask())
sandbox.pickTrav.addCollider(obj.rayNP, obj.queue)
if show:
obj.rayNP.show()
def __init__(self):
''' Should the traverser be shared? '''
LOG.debug("[Selector] Initializing")
# The collision traverser does the checking of solids for collisions
self.cTrav = CollisionTraverser()
# The collision handler queue is a simple handler that records all
# detected collisions during traversal
self.cHandler = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.cTrav.addCollider(self.pickerNP, self.cHandler)
# Start listening to clicks
self.resume()
def init_ui(self):
self.cTrav = CollisionTraverser('ui_collision_traverser')
self.collision_handler = CollisionHandlerQueue()
picker_node = CollisionNode('mouse_click_ray')
self.picker_node_path = self.camera.attachNewNode(picker_node)
picker_node.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.picker_ray = CollisionRay()
picker_node.addSolid(self.picker_ray)
self.cTrav.addCollider(self.picker_node_path, self.collision_handler)
'''
#debug: make a visible line segment
from pandac.PandaModules import LineSegs, LVecBase4f, NodePath
seg_drawer = LineSegs()
seg_drawer.setColor(LVecBase4f(1, 0, 0, 1)) #red
seg_drawer.moveTo(0,0,0)
seg_drawer.drawTo(0,100,0)
NodePath(seg_drawer.create()).reparentTo(self.picker_node_path)
'''
self.accept('a', self.mouse_ray)
def __init__(self):
''' Should the traverser be shared? '''
LOG.debug("[Selector] Initializing")
# The collision traverser does the checking of solids for collisions
self.cTrav = CollisionTraverser()
# The collision handler queue is a simple handler that records all
# detected collisions during traversal
self.cHandler = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.cTrav.addCollider(self.pickerNP, self.cHandler)
# Start listening to clicks
self.resume()
def __setupCollisionHandling(self, collisionHandler, collisionTraverser):
if not collisionTraverser.getRespectPrevTransform():
collisionTraverser.setRespectPrevTransform(True)
# We do this so we don't take into account the actual model, but the collision sphere
self.actor.setCollideMask(BitMask32.allOff())
self.node().getPhysicsObject().setMass(self.massKg)
base.physicsMgr.attachPhysicalNode(self.node())
fromObject = self.attachNewNode(CollisionNode(self.name + " collision node"))
fromObject.node().setIntoCollideMask(fromObject.node().getIntoCollideMask() & ~GeomNode.getDefaultCollideMask())
fromObject.node().setFromCollideMask(self.collisionMask)
fromObject.node().addSolid(CollisionSphere(0, 0, 2.5, 2.5))
collisionHandler.addCollider(fromObject, self)
collisionTraverser.addCollider(fromObject, collisionHandler)
from pandac.PandaModules import CollisionRay
from pandac.PandaModules import CollisionHandlerQueue
from pandac.PandaModules import CollisionTraverser
from pandac.PandaModules import GeomNode
from pandac.PandaModules import LineSegs
from pandac.PandaModules import NodePath
from pandac.PandaModules import Point3
from pandac.PandaModules import Vec3
import math
from math import sqrt
wallRayNP = render.attachNewNode(CollisionNode("wall ray collision node"))
wallRayNP.node().addSolid(CollisionRay(0,0,0,0,1,0))
wallRayNP.node().setIntoCollideMask(BitMask32.allOff())
wallRayNP.node().setFromCollideMask(BitMask32.allOn() & ~GeomNode.getDefaultCollideMask())
wallRayNP.node().setFromCollideMask(wallRayNP.node().getFromCollideMask() & ~BitMask32.bit(1))
#wallRayNP.show()
collisionHandler = CollisionHandlerQueue()
collisionTraverser = CollisionTraverser("pathfinder's collisionTraverser")
collisionTraverser.addCollider(wallRayNP, collisionHandler)
collisionTraverser.setRespectPrevTransform(True)
class PathFinder():
## def __init__(self, position, ID = -1):
## NodePath.__init__(self, "Waypoint")
## self.position = position
## self.texture = loader.loadTexture("textures/blue.jpg")
## self.costToThisNode = 0
def __init__( self, _base, state):
self.base = _base
self.state = state
# Create mouse
base.disableMouse()
self.mouse = gizmo_core.Mouse()
self.mouse.Start()
# Create camera
self.camera = gizmo_core.Camera( pos=(-250, -250, 200), style=
gizmo_core.CAM_USE_DEFAULT |
gizmo_core.CAM_VIEWPORT_AXES )
self.camera.Start()
# Create grid
grid = DirectGrid( parent=render, planeColor=(0.5, 0.5, 0.5, 0.5) )
# Create scene root node
self.rootNp = render.attachNewNode( 'rootNode' )
# Create node picker
self.nodePicker = gizmo_core.MousePicker( 'mouse', self.camera, self.rootNp, fromCollideMask=GeomNode.getDefaultCollideMask(), pickTag=PICK_TAG )
self.nodePicker.Start()
# Bind node picker events
self.accept( 'mouse1', self.StartSelection )
#self.accept( 'control-mouse1', self.StartSelection, [False] ) # Can't seem to get this to prioritise properly
self.accept( 'mouse1-up', self.StopSelection )
# Create gizmo manager
self.gizmoMgr = gizmos.Manager()
self.gizmoMgr.AddGizmo( gizmos.Translation( 'pos', self.camera ) )
self.gizmoMgr.AddGizmo( gizmos.Rotation( 'rot', self.camera ) )
self.gizmoMgr.AddGizmo( gizmos.Scale( 'scl', self.camera ) )
# Bind gizmo manager events
self.accept( 'q', self.gizmoMgr.SetActiveGizmo, [None] )
self.accept( 'w', self.gizmoMgr.SetActiveGizmo, ['pos'] )
self.accept( 'e', self.gizmoMgr.SetActiveGizmo, ['rot'] )
self.accept( 'r', self.gizmoMgr.SetActiveGizmo, ['scl'] )
self.accept( 'space', self.ToggleAllGizmoLocalMode )
self.accept( '+', self.gizmoMgr.SetSize, [2] )
self.accept( '-', self.gizmoMgr.SetSize, [0.5] )
# Create gizmo manager mouse picker
self.gizmoPicker = gizmo_core.MousePicker( 'mouse', self.camera )
self.gizmoPicker.Start()
'''# Create some objects
for i in range( 20 ):
ball = loader.loadModel( 'smiley' )
ball.setTag( PICK_TAG, '1' )
ball.reparentTo( self.rootNp )
ball.setPos( random.randint( -30, 30 ) * 2, random.randint( -30, 30 ) * 2, random.randint( -30, 30 ) * 2 )
ball.setScale( 10, 10, 10 )'''
'''
# Create a light
dlight = DirectionalLight('dlight')
dlight.setColor( ( 1, 1, 1, 1 ) )
dlnp = render.attachNewNode(dlight)
dlnp.setHpr(0, 0, 0)
render.setLight(dlnp)
dlnp.reparentTo( self.camera )'''
# Create tasks
taskMgr.add( self.MouseTask, 'mouseTask' )
def __setupCollisionHandling(self, collisionHandler, collisionTraverser):
if not collisionTraverser.getRespectPrevTransform():
collisionTraverser.setRespectPrevTransform(True)
# We do this so we don't take into account the actual model, but the collision sphere
self.actor.setCollideMask(BitMask32.allOff())
self.node().getPhysicsObject().setMass(self.massKg)
base.physicsMgr.attachPhysicalNode(self.node())
fromObject = self.attachNewNode(CollisionNode(self.name + " collision node"))
fromObject.node().setIntoCollideMask(fromObject.node().getIntoCollideMask() & ~GeomNode.getDefaultCollideMask())
fromObject.node().setFromCollideMask(self.collisionMask)
fromObject.node().addSolid(CollisionSphere(0, 0, 2.5, 2.5))
collisionHandler.addCollider(fromObject, self)
collisionTraverser.addCollider(fromObject, collisionHandler)