def create_instance(self):
#print("Create label for", self.get_name())
self.label = TextNode(self.parent.get_ascii_name() + '-label')
if not self.font_init:
self.load_font()
if self.font is not None:
self.label.set_font(self.font)
name = bayer.decode_name(self.parent.get_label_text())
self.label.setText(name)
self.label.setTextColor(*self.parent.get_label_color())
#node=label.generate()
#self.instance = self.context.annotation.attachNewNode(node)
#self.instance.setBillboardPointEye()
#node.setIntoCollideMask(GeomNode.getDefaultCollideMask())
#node.setPythonTag('owner', self.parent)
cardMaker = CardMaker(self.get_ascii_name() + '-labelcard')
cardMaker.setFrame(self.label.getFrameActual())
cardMaker.setColor(0, 0, 0, 0)
card_node = cardMaker.generate()
self.label_instance = NodePath(card_node)
tnp = self.label_instance.attachNewNode(self.label)
self.label_instance.setTransparency(TransparencyAttrib.MAlpha)
#card.setEffect(DecalEffect.make())
#Using look_at() instead of billboard effect to also rotate the collision solid
#card.setBillboardPointEye()
#Using a card holder as look_at() is changing the hpr parameters
self.instance = NodePath('label-holder')
self.label_instance.reparentTo(self.instance)
self.instance.reparentTo(self.context.annotation_shader)
self.instance.setCollideMask(GeomNode.getDefaultCollideMask())
self.instance.set_depth_write(False)
card_node.setPythonTag('owner', self.parent)
self.look_at = self.instance.attachNewNode("dummy")
def setupMouseCollision(self):
""" """
#Since we are using collision detection to do picking, we set it up
#any other collision detection system with a traverser and a handler
self.mPickerTraverser = CollisionTraverser() #Make a traverser
self.mCollisionQueue = CollisionHandlerQueue()
#create a collision solid ray to detect against
self.mPickRay = CollisionRay()
#self.mPickRay.setOrigin(base.camera.getPos(render))
#self.mPickRay.setDirection(render.getRelativeVector(base.camera, Vec3(0,1,0)))
#create our collison Node to hold the ray
self.mPickNode = CollisionNode('pickRay')
self.mPickNode.addSolid(self.mPickRay)
#Attach that node to the camera since the ray will need to be positioned
#relative to it, returns a new nodepath
#well use the default geometry mask
#this is inefficent but its for mouse picking only
self.mPickNP = base.camera.attachNewNode(self.mPickNode)
#well use what panda calls the "from" node. This is reall a silly convention
#but from nodes are nodes that are active, while into nodes are usually passive environments
#this isnt a hard rule, but following it usually reduces processing
#Everything to be picked will use bit 1. This way if we were doing other
#collision we could seperate it, we use bitmasks to determine what we check other objects against
#if they dont have a bitmask for bit 1 well skip them!
self.mPickNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
#Register the ray as something that can cause collisions
self.mPickerTraverser.addCollider(self.mPickNP, self.mCollisionQueue)
def __init__(self):
self.accept('mouse1', self.onMouse1Down, []) # Left click
self.accept('mouse1-up', self.onMouse1Up, [])
self.accept('mouse3', self.onMouse3Down, []) # Right click
self.showCollisions = False
pickerNode = CollisionNode('mouseRay')
pickerNP = camera.attachNewNode(pickerNode)
pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
pickerNode.addSolid(self.pickerRay)
base.cTrav.addCollider(pickerNP, base.handler)
if self.showCollisions:
base.cTrav.showCollisions(render)
base.disableMouse()
self.activeCard = None
self._targeting = False
self._dragging = None
# Counts down between clicks to detect double click
self.doubleClickTimer = -1.0
self.doubleClickInterval = 1.0
self.line = attackLine.Line()
def setupMouseCollision(self):
""" """
#Since we are using collision detection to do picking, we set it up
#any other collision detection system with a traverser and a handler
self.mPickerTraverser = CollisionTraverser() #Make a traverser
self.mCollisionQueue = CollisionHandlerQueue()
#create a collision solid ray to detect against
self.mPickRay = CollisionRay()
#self.mPickRay.setOrigin(base.camera.getPos(render))
#self.mPickRay.setDirection(render.getRelativeVector(base.camera, Vec3(0,1,0)))
#create our collison Node to hold the ray
self.mPickNode = CollisionNode('pickRay')
self.mPickNode.addSolid(self.mPickRay)
#Attach that node to the camera since the ray will need to be positioned
#relative to it, returns a new nodepath
#well use the default geometry mask
#this is inefficent but its for mouse picking only
self.mPickNP = base.camera.attachNewNode(self.mPickNode)
#well use what panda calls the "from" node. This is reall a silly convention
#but from nodes are nodes that are active, while into nodes are usually passive environments
#this isnt a hard rule, but following it usually reduces processing
#Everything to be picked will use bit 1. This way if we were doing other
#collision we could seperate it, we use bitmasks to determine what we check other objects against
#if they dont have a bitmask for bit 1 well skip them!
self.mPickNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
#Register the ray as something that can cause collisions
self.mPickerTraverser.addCollider(self.mPickNP, self.mCollisionQueue)
def __init__(self, nick):
self.player = player.Player(nick=nick)
self.controller = controller.ClientController(self.player)
self.handgui = hand.HandGUI(self.player.hand)
camera.setPos(0, -20, 0)
self.accept("turn_time_changed", self.update_turn_time)
self.turn_timer = TurnTimer()
# Mouse detection:
base.cTrav = CollisionTraverser()
self.mouse_ray_handler = CollisionHandlerQueue()
mouse_ray_node = CollisionNode('mouse_ray')
mouse_ray_np = camera.attachNewNode(mouse_ray_node)
mouse_ray_node.setFromCollideMask(GeomNode.getDefaultCollideMask())
mouse_ray_node.setIntoCollideMask(0)
self.mouse_ray = CollisionRay()
mouse_ray_node.addSolid(self.mouse_ray)
base.cTrav.addCollider(mouse_ray_np, self.mouse_ray_handler)
self.mouse_overed_entry = None
self.accept("mouse_enter", self.enlarge_entry)
self.accept("mouse_leave", self.shrink_entry)
self.accept("p-up", self.change_card_picture)
taskMgr.doMethodLater(0.1, self.check_mouse_over, "check_mouse_over")
def setupClickCollision(self):
self.clickHandler = CollisionHandlerQueue()
self.traverser = CollisionTraverser('ClickTraverser')
base.cTrave = self.traverser
self.clickerNode = CollisionNode('mouseClick')
self.clickerNodePoint = self.camera.attachNewNode(self.clickerNode)
self.clickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.clickerRay = CollisionRay()
self.clickerNode.addSolid(self.clickerRay)
self.traverser.addCollider(self.clickerNodePoint,self.clickHandler)
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 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())
#base.cTrav.addCollider(obj.rayNP, obj.queue)
self.cTrav.addCollider(obj.rayNP, obj.queue)
if show: obj.rayNP.show()
def setupMouseCollision(self):
self.mouseTraverser = CollisionTraverser()
self.mouseCollisionQueue = CollisionHandlerQueue()
self.mouseRay = CollisionRay()
self.mouseRay.setOrigin(self.pandaScene.camera.getPos(self.pandaScene.render))
self.mouseRay.setDirection(self.pandaScene.render.getRelativeVector(self.pandaScene.camera, Vec3(0,1,0)))
self.mouseNode = CollisionNode('mouseRay')
self.mouseNode.addSolid(self.mouseRay)
self.mouseNodePath = self.pandaScene.camera.attachNewNode(self.mouseNode)
self.mouseNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.mouseTraverser.addCollider(self.mouseNodePath, self.mouseCollisionQueue)
def __init__(self, camera, level):
self.camera = camera
self.level = level
self.handler = CollisionHandlerQueue()
self.traverser = CollisionTraverser('traverser')
pickerNode = CollisionNode('mouseRay')
pickerNP = self.camera.attachNewNode(pickerNode)
pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
pickerNode.addSolid(self.pickerRay)
self.traverser.addCollider(pickerNP, self.handler)
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 mouseDown(self):
vp = base.viewportMgr.activeViewport
if not vp:
return
if vp.is3D():
# If we clicked in the 3D viewport, try to intersect with an existing MapObject
# and immediately place the entity at the intersection point. If we didn't click on any
# MapObject, place the entity on the grid where we clicked.
entries = vp.click(GeomNode.getDefaultCollideMask())
if entries and len(entries) > 0:
for i in range(len(entries)):
entry = entries[i]
# Don't backface cull if there is a billboard effect on or above this node
if not LEUtils.hasNetBillboard(entry.getIntoNodePath()):
surfNorm = entry.getSurfaceNormal(vp.cam).normalized()
rayDir = entry.getFrom().getDirection().normalized()
if surfNorm.dot(rayDir) >= 0:
# Backface cull
continue
# We clicked on an object, use the contact point as the
# location of our new entity.
self.pos = entry.getSurfacePoint(self.doc.render)
self.hasPlaced = True
# Create it!
self.confirm()
break
else:
# Didn't click on an object, intersect our mouse ray with the grid plane.
plane = LPlane(0, 0, 1, 0)
worldMouse = vp.viewportToWorld(vp.getMouse())
theCamera = vp.cam.getPos(render)
# Ensure that the camera and mouse positions are on opposite
# sides of the plane, or else the entity would place behind us.
sign1 = plane.distToPlane(worldMouse) >= 0
sign2 = plane.distToPlane(theCamera) >= 0
if sign1 != sign2:
pointOnPlane = Point3()
ret = plane.intersectsLine(pointOnPlane, theCamera,
worldMouse)
if ret:
# Our mouse intersected the grid plane. Place an entity at the plane intersection point.
self.pos = pointOnPlane
self.hasPlaced = True
self.confirm()
return
# The user clicked in the 2D viewport, draw the visualization where they clicked.
self.showVis()
self.updatePosFromViewport(vp)
self.mouseIsDown = True
self.hasPlaced = True
def __init__(self, camera_gear, tq_render, mousewatchernode,
dragAndDropObjectsManager):
""" """
self.dragAndDropObjectsManager = dragAndDropObjectsManager
# -- things that are needed to do picking from different camera orientations
self.camera_gear = camera_gear # e.g. the orbiter class is a camera_gear
self.tq_render = tq_render
self.mouse_watcher_node = mousewatchernode
# -- things that are needed for collision detection by picking a 3d object
self.pick_traverser = CollisionTraverser()
self.collision_queue = CollisionHandlerQueue()
# ---- build the CollisionRay
self.pick_collision_ray = CollisionRay(
) # the pick ray is apparently a 'Solid'
# -- a ray is a half-inifinite straight line
# it is supposed to shoot out orthogonally to the view plane and hit an object
self.pick_collision_ray.setOrigin(
self.camera_gear.p3d_camera.getPos(
self.tq_render.get_p3d_nodepath()))
# -- TODO: update this every time the orbiter camera position changes
# first, transform the (0,1,0) vector into render's coordinate system
self.pick_collision_ray.setDirection(
engine.tq_graphics_basics.tq_render.getRelativeVector(
camera, Vec3(0, 1, 0)))
# ---- build the CollisionNode
self.pick_collision_node = CollisionNode('pick_collision_ray')
self.pick_collision_node.addSolid(
self.pick_collision_ray) # the pick ray is actually a 3d object
# attach the CollisionNode to the camera (not the CollisionRay)
self.pick_collision_node_nodepath = self.camera_gear.p3d_camera.attachNewNode(
self.pick_collision_node)
# set a collide mask to the pick_collision_node, 2 objects that should be able to collide must have the same collide mask!
self.pick_collision_node.setFromCollideMask(
GeomNode.getDefaultCollideMask()
# DragDropObject.dragMask
) # set bit 20 (Default) to the ray
# add the ray as sth. that can cause collisions, and tell it to fill up our collision queue object when traversing and detecting
self.pick_traverser.addCollider(self.pick_collision_node_nodepath,
self.collision_queue)
def init_picker(self):
# Collision traverser
self.traverser = CollisionTraverser("traverser")
# Collision handler
self.handler = CollisionHandlerQueue()
# Initialize and set up picker ray node and NodePath
self.picker = CollisionNode("mouse_ray")
self.pickerNP = self.camera.attachNewNode(self.picker)
self.picker.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.picker_ray = CollisionRay()
self.picker.addSolid(self.picker_ray)
self.traverser.addCollider(self.pickerNP, self.handler)
mark_color = (1, 1, 1, 0.3)
self.base_mark = self.create_mark(color=mark_color)
connector_color = (1, 1, 1, 1)
self.base_connector = self.create_connector(color=connector_color)
def init_picker(self):
# Collision traverser
self.traverser = CollisionTraverser("traverser")
# Collision handler
self.handler = CollisionHandlerQueue()
# Initialize and set up picker ray node and NodePath
self.picker = CollisionNode("mouse_ray")
self.pickerNP = self.camera.attachNewNode(self.picker)
self.picker.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.picker_ray = CollisionRay()
self.picker.addSolid(self.picker_ray)
self.traverser.addCollider(self.pickerNP, self.handler)
mark_color = (1, 1, 1, 0.3)
self.base_mark = self.create_mark(color=mark_color)
connector_color = (1, 1, 1, 1)
self.base_connector = self.create_connector(color=connector_color)
def __init__(self, base):
self.base = base
if settings.mouse_over:
taskMgr.add(self.mouse_task, 'mouse-task')
self.picker = CollisionTraverser()
self.pq = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = self.base.cam.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(
CollisionNode.getDefaultCollideMask()
| GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.picker.addCollider(self.pickerNP, self.pq)
#self.picker.showCollisions(render)
self.over = None
def set_clickable(self, clickable):
self.clickable = clickable
if self.use_collision_solid and self.collision_solid is not None:
if clickable:
self.collision_solid.node().setIntoCollideMask(
CollisionNode.getDefaultCollideMask())
else:
self.collision_solid.node().setIntoCollideMask(
BitMask32.all_off())
#The instance itself is not clickable
self.instance.setCollideMask(BitMask32.all_off())
else:
if clickable:
self.instance.setCollideMask(GeomNode.getDefaultCollideMask())
else:
self.instance.setCollideMask(BitMask32.all_off())
def setupMouseCollision(self):
self.mClicker = CollisionTraverser()
self.mCollisionQue = CollisionHandlerQueue()
self.mClickRay = CollisionRay()
self.mClickRay.setOrigin(self.camera.getPos(self.render))
self.mClickRay.setDirection(render.getRelativeVector(camera, Vec3(0,1,0)))
self.mClickNode = CollisionNode('clickRay')
self.mClickNode.addSolid(self.mClickRay)
self.mClickNP = self.camera.attachNewNode(self.mClickNode)
self.mClickNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.mClicker.addCollider(self.mClickNP, self.mCollisionQue)
def create_instance(self):
if not self.orbit:
return
self.vertexData = GeomVertexData('vertexData',
GeomVertexFormat.getV3(),
Geom.UHStatic)
self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex')
delta = self.body.parent.get_local_position()
for i in range(self.nbOfPoints):
time = self.orbit.period / self.nbOfPoints * i
pos = self.orbit.get_position_at(time)
rot = self.orbit.get_rotation_at(time)
pos = self.orbit.frame.get_local_position(rot.xform(pos)) - delta
self.vertexWriter.addData3f(*pos)
self.lines = GeomLines(Geom.UHStatic)
for i in range(self.nbOfPoints - 1):
self.lines.addVertex(i)
self.lines.addVertex(i + 1)
self.lines.closePrimitive()
self.lines.addVertex(self.nbOfPoints - 1)
self.lines.addVertex(0)
self.lines.closePrimitive()
self.geom = Geom(self.vertexData)
self.geom.addPrimitive(self.lines)
self.node = GeomNode(self.body.get_ascii_name() + '-orbit')
self.node.addGeom(self.geom)
self.instance = NodePath(self.node)
self.instance.setRenderModeThickness(settings.orbit_thickness)
self.instance.setCollideMask(GeomNode.getDefaultCollideMask())
self.instance.node().setPythonTag('owner', self)
self.instance.reparentTo(self.context.annotation_shader)
if self.color is None:
self.color = self.parent.get_orbit_color()
self.instance.setColor(self.color * self.fade)
self.instance.setAntialias(AntialiasAttrib.MMultisample)
self.appearance = ModelAppearance(attribute_color=True)
if settings.use_inv_scaling:
vertex_control = LargeObjectVertexControl()
else:
vertex_control = None
self.instance_ready = True
self.shader = BasicShader(lighting_model=FlatLightingModel(),
vertex_control=vertex_control)
self.shader.apply(self, self.appearance)
self.shader.update(self, self.appearance)
def setupMouseCollision(self):
self.mClicker = CollisionTraverser()
self.mCollisionQue = CollisionHandlerQueue()
self.mClickRay = CollisionRay()
self.mClickRay.setOrigin(self.camera.getPos(self.render))
self.mClickRay.setDirection(
render.getRelativeVector(camera, Vec3(0, 1, 0)))
self.mClickNode = CollisionNode('clickRay')
self.mClickNode.addSolid(self.mClickRay)
self.mClickNP = self.camera.attachNewNode(self.mClickNode)
self.mClickNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.mClicker.addCollider(self.mClickNP, self.mCollisionQue)
def __init__(self,
use_sprites=True,
use_sizes=True,
points_size=2,
sprite=None,
background=None,
shader=None):
self.gnode = GeomNode('starfield')
self.use_sprites = use_sprites
self.use_sizes = use_sizes
self.background = background
if shader is None:
shader = BasicShader(lighting_model=FlatLightingModel(),
point_shader=False)
self.shader = shader
self.reset()
self.geom = self.makeGeom([], [], [])
self.gnode.addGeom(self.geom)
self.instance = NodePath(self.gnode)
if self.use_sprites:
if sprite is None:
sprite = RoundDiskPointSprite()
self.sprite = sprite
else:
self.sprite = SimplePoint(points_size)
self.min_size = self.sprite.get_min_size()
self.sprite.apply(self.instance)
self.instance.setCollideMask(GeomNode.getDefaultCollideMask())
self.instance.node().setPythonTag('owner', self)
#TODO: Should not use ModelAppearance !
self.appearance = ModelAppearance(vertex_color=True)
if self.appearance is not None:
self.appearance.bake()
self.appearance.apply(self, self)
if self.shader is not None:
self.shader.apply(self, self.appearance)
if self.use_sprites:
self.instance.node().setBounds(OmniBoundingVolume())
self.instance.node().setFinal(True)
if self.background is not None:
self.instance.setBin('background', self.background)
self.instance.set_depth_write(False)
def __init__(self, topNode, cameraObject = None):
self.traverser = CollisionTraverser()
self.handler = CollisionHandlerQueue()
self.topNode = topNode
self.cam = cameraObject
pickerNode = CollisionNode('MouseRay')
#NEEDS to be set to global camera. boo hoo
self.pickerNP = base.camera.attachNewNode(pickerNode)
# this seems to enter the bowels of the node graph, making it
# difficult to perform logic on
pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickRay = CollisionRay()
#pickerNode.setCollideMask(BitMask32.allOff())
pickerNode.addSolid(self.pickRay)
self.traverser.addCollider(self.pickerNP, self.handler)
def setUpMouseCollider(self):
# clicking on objects stuff came from here:
# https://www.panda3d.org/manual/index.php/Collision_Traversers
# https://www.panda3d.org/manual/index.php/Collision_Handlers
# will not use the traverser set up by car because slow
# instead we will render each time clicked
self.mouseCollideTrav = CollisionTraverser("mouseTraverse")
self.mousehandler = CollisionHandlerQueue()
# edit this so that from Object is the camera
# self.mouseCollideTrav.addCollider(fromObject, queue)
# self.mouseCollideTrav.traverse(render)
# this next part came from:
# https://www.panda3d.org/manual/index.php/Clicking_on_3D_Objects
pickerNode = CollisionNode("mouseRay")
pickerNp = camera.attachNewNode(pickerNode)
pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
pickerNode.addSolid(self.pickerRay)
self.mouseCollideTrav.addCollider(pickerNp, self.mousehandler)
def create_instance(self):
self.vertexData = GeomVertexData('vertexData', GeomVertexFormat.getV3(), Geom.UHStatic)
self.vertexWriter = GeomVertexWriter(self.vertexData, 'vertex')
delta = self.body.parent.get_local_position()
if self.orbit.is_periodic():
epoch = self.context.time.time_full - self.orbit.period / 2
step = self.orbit.period / (self.nbOfPoints - 1)
else:
#TODO: Properly calculate orbit start and end time
epoch = self.orbit.get_time_of_perihelion() - self.orbit.period * 5.0
step = self.orbit.period * 10.0 / (self.nbOfPoints - 1)
for i in range(self.nbOfPoints):
time = epoch + step * i
pos = self.orbit.get_position_at(time) - delta
self.vertexWriter.addData3f(*pos)
self.lines = GeomLines(Geom.UHStatic)
for i in range(self.nbOfPoints-1):
self.lines.addVertex(i)
self.lines.addVertex(i+1)
if self.orbit.is_periodic() and self.orbit.is_closed():
self.lines.addVertex(self.nbOfPoints-1)
self.lines.addVertex(0)
self.geom = Geom(self.vertexData)
self.geom.addPrimitive(self.lines)
self.node = GeomNode(self.body.get_ascii_name() + '-orbit')
self.node.addGeom(self.geom)
self.instance = NodePath(self.node)
self.instance.setRenderModeThickness(settings.orbit_thickness)
self.instance.setCollideMask(GeomNode.getDefaultCollideMask())
self.instance.node().setPythonTag('owner', self)
self.instance.reparentTo(self.context.annotation)
if self.color is None:
self.color = self.parent.get_orbit_color()
self.instance.setColor(srgb_to_linear(self.color * self.fade))
self.instance_ready = True
if self.shader is None:
self.create_shader()
self.shader.apply(self, self.appearance)
self.shader.update(self, self.appearance)
def cameraview(self):
"""
Cameraview
"""
# Create picker Node and CollisionRay
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
# Create Collision Traverser and Queue
self.cameraPickingTraverser = CollisionTraverser('Camera Picking Traverser')
self.cameraPickingQueue = CollisionHandlerQueue()
# Link Picker Node to Traverser and Queue
self.cameraPickingTraverser.addCollider(self.pickerNP, self.cameraPickingQueue)
# Set tags on Earth and Moon to be pickable
# Add text to display the camera position
self.text = OnscreenText(text = "Help: h", pos = (-1.3, .95-.05), fg=(1,1,1,1),align = TextNode.ALeft, scale = .05, mayChange = 1)
""" self.displayCameraDistanceText = self.genLabelText("Camera distance : " + str(self.cameraDistance * self.planeten[0][1]) + " m", 0)
def __init__(self):
ShowBase.__init__(self);
# setup the environment or model
self.model = \
self.loader.loadModel("/Developer/Panda3D/models/box.egg.pz");
self.model.reparentTo(self.render);
self.model.setTag('Model', '1');
self.model.setScale(1.5, 1.5, 1.5);
# setup camera
self.camera.setPos(5,5,5)
self.camera.lookAt(0,0,0)
# Disable mouse control
self.disableMouse();
# Handle mouse events.
self.accept('mouse1', self.mouse_down);
# convert image from opencv to panda3d texture
# self.taskMgr.add(self.read_image_cv, "cvImageTask");
# Setup collision handler
self.handler = CollisionHandlerQueue()
self.traverser = CollisionTraverser('ColTraverser')
self.traverser.traverse(self.model)
self.ray = CollisionRay()
pickerNode = CollisionNode('MouseRay')
pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
pickerNP = self.camera.attachNewNode(pickerNode)
pickerNode.addSolid(self.ray)
self.traverser.addCollider(pickerNP, self.handler)
self.load_shader();
self.first_frame_loaded = False;
def __init__(self):
ShowBase.__init__(self);
# setup the environment or model
self.model = \
self.loader.loadModel("/usr/share/panda3d/models/box");
self.model.reparentTo(self.render);
self.model.setTag('Model', '1');
self.model.setScale(1.5, 1.5, 1.5);
# setup camera
self.camera.setPos(5,5,5)
self.camera.lookAt(0,0,0)
# Disable mouse control
self.disableMouse();
# Handle mouse events.
self.accept('mouse1', self.mouse_down);
# convert image from opencv to panda3d texture
# self.taskMgr.add(self.read_image_cv, "cvImageTask");
# Setup collision handler
self.handler = CollisionHandlerQueue()
self.traverser = CollisionTraverser('ColTraverser')
self.traverser.traverse(self.model)
self.ray = CollisionRay()
pickerNode = CollisionNode('MouseRay')
pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
pickerNP = self.camera.attachNewNode(pickerNode)
pickerNode.addSolid(self.ray)
self.traverser.addCollider(pickerNP, self.handler)
self.load_shader();
self.first_frame_loaded = False;
def __init__(self):
ShowBase.__init__(self)
self.scene = self.loader.loadModel("models/test.egg")
self.scene.reparentTo(self.render)
self.scene.setScale(1, 3, 1)
# self.scene.setPos(0, 1000, 0)
sphere = CollisionSphere(0, 0, 0, 50)
cnode = self.scene.attachNewNode(CollisionNode('cnode_scene'))
cnode.node().addSolid(sphere)
# cnode.show()
base.setBackgroundColor(0, 0.0, 0)
base.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
OnscreenText(text='.', pos=(0, 0, 0))
plight = PointLight('plight')
plight.setColor(VBase4(2, 2, 2, 1))
plnp = self.render.attachNewNode(plight)
plnp.setPos(0, 0, 100)
self.render.setLight(plnp)
# dummy node for camera, attach player to it
self.camparent = self.render.attachNewNode('camparent')
self.camparent.reparentTo(self.render) # inherit transforms
self.camparent.setEffect(CompassEffect.make(
self.render)) # NOT inherit rotation
self.camparent.setY(-1000)
self.camparent.setZ(200)
# the camera
base.camera.reparentTo(self.camparent)
base.camera.lookAt(self.camparent)
base.camera.setY(0) # camera distance from model
self.heading = 0
self.pitch = 0
self.taskMgr.add(self.cameraTask, 'cameraTask')
self.keyMap = {"left": 0, "right": 0, "forward": 0, "reverse": 0}
self.accept("escape", sys.exit)
self.accept("arrow_left", self.setKey, ["left", True])
self.accept("arrow_right", self.setKey, ["right", True])
self.accept("arrow_up", self.setKey, ["forward", True])
self.accept("arrow_down", self.setKey, ["reverse", True])
self.accept("w", self.setKey, ["forward", True])
self.accept("a", self.setKey, ["left", True])
self.accept("s", self.setKey, ["reverse", True])
self.accept("d", self.setKey, ["right", True])
self.accept("arrow_left-up", self.setKey, ["left", False])
self.accept("arrow_right-up", self.setKey, ["right", False])
self.accept("arrow_up-up", self.setKey, ["forward", False])
self.accept("arrow_down-up", self.setKey, ["reverse", False])
self.accept("w-up", self.setKey, ["forward", False])
self.accept("a-up", self.setKey, ["left", False])
self.accept("s-up", self.setKey, ["reverse", False])
self.accept("d-up", self.setKey, ["right", False])
self.accept('mouse1', self.myFunction)
self.textObject = None
db = TinyDB('paintings/db.json')
self.descriptions = dict()
base.cTrav = CollisionTraverser()
pickerNode = CollisionNode('mouseRay')
pickerNP = self.camera.attachNewNode(pickerNode)
pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
pickerNode.addSolid(self.pickerRay)
self.queue = CollisionHandlerQueue()
base.cTrav.addCollider(pickerNP, self.queue)
id = 0
for item in db.all():
self.addImage('paintings/' + item['img'], id=id)
self.descriptions[id] = item['name']
id += 1
def entity_select(self):
if self.panda3d.mouseWatcherNode.hasMouse():
"""traverser = CollisionTraverser("")
#traverser.show_collisions(render)
picker_ray = CollisionRay()
handler = CollisionHandlerQueue()
picker_node = CollisionNode('mouseRay')
picker_np = self.panda3d.camera.attachNewNode(picker_node)
picker_node.setFromCollideMask(GeomNode.getDefaultCollideMask())
picker_ray = CollisionRay()
picker_node.addSolid(picker_ray)
traverser.addCollider(picker_np, handler)
picker_node.setFromCollideMask(GeomNode.getDefaultCollideMask())
mpos = self.panda3d.mouseWatcherNode.getMouse()
picker_ray.setFromLens(self.panda3d.camNode, mpos.getX(), mpos.getY())
traverser.traverse(self.panda3d.render)"""
self.picker_node.setFromCollideMask(GeomNode.getDefaultCollideMask())
mpos = self.panda3d.mouseWatcherNode.getMouse()
self.picker_ray.setFromLens(self.panda3d.camNode, mpos.getX(), mpos.getY())
self.traverser.traverse(self.panda3d.render)
handler = self.handler
# Assume for simplicity's sake that myHandler is a CollisionHandlerQueue.
btn = self.panda3d.mouseWatcherNode
if handler.getNumEntries() > 0:
# This is so we get the closest object.
handler.sortEntries()
entity = handler.getEntry(0).getIntoNodePath()
entity = entity.findNetTag('entity_id')
if not entity.isEmpty():
#print("entity selected: {}".format(entity.getTag("entity_id")))
entity_id = entity.getTag("entity_id")
entity_type = entity.getTag("entity_type")
#print(entity_type)
model = app.model_reg
category_type = model.get(entity_type, dict())
entity = category_type.get(entity_id, None)
#print(entity)
if btn.isButtonDown("mouse1"):
entity.on_click()
if entity.is_editable:
prop_editor = app.main_ui.prop_editor
prop_editor.entity_read(entity)
elif entity.is_selectable:
status_bar = app.main_ui.status_bar
status_bar.entity_read(entity)
else:
print("Hay {} entidades bajo el mouse".format(handler.getNumEntries()))
else:
if btn.isButtonDown("mouse1"):
entities = app.model_reg.get("View", {})
if entities is None or len(entities) is 0:
View()
entities = app.model_reg.get("View")
entity = list(entities.values())[0]
prop_editor = app.main_ui.prop_editor
prop_editor.entity_read(entity)
else:
status_bar = app.main_ui.status_bar
status_bar.entity_read()
def __init__(self, panda3d):
# Inicialización de variables
self.winsize = [0, 0]
self.panda3d = panda3d
self.panda3d.mouse_on_workspace = False
# Desabilita el comportamiento por defecto de la camara
self.panda3d.disable_mouse()
# Llama a la función self.window_rezise_event cuando la ventana cambia de tamaño
self.accept('window-event', self.window_rezise_event)
# self.panda3d.accept('aspectRatioChanged', lambda: print("ss"))
# Creamos el punto donde se centrará la cámara
target_pos = Point3(0., 0., 0.)
self.panda3d.cam_target = self.panda3d.render.attach_new_node("camera_target")
self.panda3d.cam_target.set_pos(target_pos)
self.panda3d.camera.reparent_to(self.panda3d.cam_target)
self.panda3d.camera.set_y(-50.)
# Definimos la cambinación de teclas para el control de la camara
self.camera_active = False
self.orbit_mouse_btn = "mouse2"
self.orbit_keyboard_btn = "shift"
self.orbit_mouse_reference = None
self.orbit_camera_reference = None
self.pan_mouse_btn = "mouse2"
self.pan_keyboard_btn = "mouse2"
self.pan_mouse_reference = None
self.pan_camera_reference = None
self.zoom_mouse_btn = "mouse2"
self.zoom_keyboard_btn = "control"
self.zoom_mouse_reference = None
self.zoom_camera_reference = None
# Establecemos los valores máximos y minimos para el zoom
self.max_zoom = 10
self.min_zoom = 0.1
# Creamos la tarea de control de la camara
self.panda3d.task_mgr.add(self.camera_control_task, "camera_control")
# El movimiento de la rueda del mouse controla el zoom
self.panda3d.accept("wheel_up", self.zoom_in)
self.panda3d.accept("wheel_down", self.zoom_out)
# Una fución de prueba para comprobar la posición del mouse en el modelo 3d
# self.panda3d.accept("mouse1", self.entity_select)
# Se establece la lente ortografica en lugar de la perspectiva
self.lens_type = "OrthographicLens"
self.set_lens(self.lens_type)
# Agrega un indicador de ejes en la esquina inferior izquierda
self.corner = self.panda3d.camera.attachNewNode("corner of screen")
# self.axis = self.panda3d.loader.loadModel("data/geom/custom-axis")
# self.axis = self.panda3d.loader.loadModel("data/geom/view_gizmo_F")
self.view_gizmo = list()
self.view_gizmo.append(self.panda3d.loader.loadModel("data/geom/view_gizmo_compass"))
# self.view_gizmo.append(self.panda3d.loader.loadModel("data/geom/view_gizmo_L"))
# self.view_cube = ViewGizmoZone()
# self.view_cube.set_geom(self.axis)
for gizmo_geom in self.view_gizmo:
gizmo_geom.setLightOff(1)
# gizmo_geom.setColorScale(1,1,1,1)
gizmo_geom.setShaderInput("colorborders", LVecBase4(0, 0, 0, 0.25))
gizmo = ViewGizmoZone()
gizmo.set_geom(gizmo_geom)
gizmo_geom.node().setBounds(BoundingSphere(Point3(0, 0, 0), 10))
gizmo_geom.node().setFinal(True)
#gizmo_geom.showTightBounds()
# gizmo_geom.showBounds()
self.show_view_gizmo()
# Agregamos una luz puntual en la ubicación de la camara
plight = DirectionalLight("camera_light")
plight.setColor((1, 1, 1, 1))
#plight.setAttenuation((1, 0, 0))
#print("getMaxDistance {}".format(plight.getMaxDistance()))
self.panda3d.plight_node = self.panda3d.render.attach_new_node(plight)
self.panda3d.plight_node.setPos(0, -50, 0)
self.panda3d.render.setLight(self.panda3d.plight_node)
self.panda3d.plight_node.reparentTo(self.panda3d.camera)
# Agregamos luz ambiental que disminuya las zonas oscuras
alight = AmbientLight('alight')
alight.setColor((0.3, 0.3, 0.3, 1))
alnp = self.panda3d.render.attachNewNode(alight)
self.panda3d.render.setLight(alnp)
#def init_select_detection(self):
self.traverser = CollisionTraverser("")
# self.traverser.show_collisions(self.panda3d.render)
self.picker_ray = CollisionRay()
self.handler = CollisionHandlerQueue()
self.picker_node = CollisionNode('mouseRay')
self.picker_np = self.panda3d.camera.attachNewNode(self.picker_node)
self.picker_node.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.picker_ray = CollisionRay()
self.picker_node.addSolid(self.picker_ray)
self.traverser.addCollider(self.picker_np, self.handler)
class Game(ShowBase):
def __init__(self, level, controls):
super().__init__()
self.set_background_color(33/255, 46/255, 56/255)
# set up timing system
self.timeline = Timeline()
self.last_time = 0.0
def extract_tile_id(filename, flags, tileset):
def inner(rect, flags):
x, y, w, h = rect
return x // w + y // h * tileset.columns
return inner
tile_list = tiles(self)
tiled_map = TiledMap(level, image_loader=extract_tile_id)
level = self.render.attach_new_node("level")
width = tiled_map.width
height = tiled_map.height * 3**0.5 / 2
level.set_pos(width / 2, -height / 2, 0)
def get_track(x, y):
for i, layer in enumerate(tiled_map):
tile = tile_list.get(tiled_map.get_tile_image(x, y, i))
if isinstance(tile, Track):
return tile
return None
z = {}
for layer in tiled_map:
for x, y, tile_id in layer.tiles():
if (tile_type := tile_list.get(tile_id)) is not None:
tile = level.attach_new_node("tile")
tile.set_pos(*from_hex(x, y), z.get((x, y), 0))
z[(x, y)] = z.get((x, y), 0) + tile_type.height
tile_type.instance_to(tile)
tile_type.register(tile, self.timeline, x, y, get_track)
# use antialiasing
self.render.set_antialias(AntialiasAttrib.MMultisample)
# position camera
self.camera.set_pos(0, 8, 8)
self.camera.look_at(0, 0, 0)
self.disable_mouse()
# create a light
ambient = ambient_light(colour=(.3, .3, .3, 1))
ambient = self.render.attach_new_node(ambient)
self.render.set_light(ambient)
# create another light
directional = directional_light(
colour=(1, 1, 1, 1), direction=(-1, -2, -3))
directional = self.render.attach_new_node(directional)
self.render.set_light(directional)
# load control scheme from file
self.load_controls(controls)
self.task_mgr.add(self.loop, 'loop')
# create a ui
tile_tray = OnscreenImage(image='data/black.png',
pos=(0, 0, -1.66), color=(0, 0, 0, .3), parent=self.render2d)
tile_tray.setTransparency(TransparencyAttrib.MAlpha)
thumbs = ['straight_thumb.png',
'straight_thumb.png',
'curved_thumb.png']
for n, thumb in enumerate(thumbs):
_thumb = OnscreenImage(image='data/' + thumb,
pos=((n+1)*2/(len(thumbs) + 1) - 1, 0, -.82),
scale=.15, parent=self.aspect2d)
_thumb.setTransparency(TransparencyAttrib.MAlpha)
selected_track = None
myHandler = CollisionHandlerQueue()
myTraverser = CollisionTraverser('traverser')
pickerNode = CollisionNode('mouseRay')
pickerNP = self.camera.attachNewNode(pickerNode)
pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
pickerRay = CollisionRay()
pickerNode.addSolid(pickerRay)
myTraverser.addCollider(pickerNP, myHandler)
def handle_mouse_move():
mpos = self.mouseWatcherNode.getMouse()
pickerRay.setFromLens(self.camNode, mpos.getX(), mpos.getY())
myTraverser.traverse(self.render)
if myHandler.getNumEntries() > 0:
myHandler.sortEntries()
pickedObj = myHandler.getEntry(0).getIntoNodePath()
if not pickedObj.isEmpty():
tile = pickedObj.parent.parent.parent
x, y, z = tile.get_pos()
print(to_hex(x, y))
def handle_mouse_click():
mpos = self.mouseWatcherNode.getMouse()
if mpos.y < -2/3:
for n, thumb in enumerate(thumbs):
scale, aspect_ratio = .15, 16/9
x, y = (n+1)*2/(len(thumbs) + 1) - 1, -.82
if -scale < x - mpos.x*aspect_ratio < scale:
if thumbs[n] == 'straight_thumb.png':
tile_id = 0
elif thumbs[n] == 'curved_thumb.png':
tile_id = 1
tile_type = tile_list.get(tile_id))
tile = level.attach_new_node("tile")
tile.set_pos(*from_hex(x, y), z.get((x, y), 0))
z[(x, y)] = z.get((x, y), 0) + tile_type.height
tile_type.instance_to(tile)
tile_type.register(tile, self.timeline, x, y, get_track)
self.handle_mouse_move = handle_mouse_move
self.handle_mouse_click = handle_mouse_click
# -*- coding: utf-8 -*-
from panda3d.core import BitMask32, GeomNode
LEVELMODEL = 'models/room1'
AZERTY = True
JUMP_FORCE = 25
GRAVITY = 15
RUN_SPEED = 25
PLAYER_TO_FLOOR_TOLERANCE = .3
PLAYER_TO_FLOOR_TOLERANCE_FOR_REJUMP = 1
ORANGE = (242/255., 181/255., 75/255.,1)
BLUE = (89/255.,100/255.,122/255.,1)
COLLISIONMASKS = {
'player': BitMask32.bit(1),
'portals': BitMask32.bit(2),
'mouseRay': BitMask32.bit(3),
'exit': BitMask32.bit(4),
'lava': BitMask32.bit(5),
'geometry': GeomNode.getDefaultCollideMask(),
}
TEXTURES = {}
__author__ = 'Lab Hatter'
from panda3d.core import BitMask32, GeomNode
COLLISIONMASKS = {'grabber': BitMask32(1<<31), 'default': GeomNode.getDefaultCollideMask()}
def __init__(self):
# The standard camera, light and background initialization
base.setBackgroundColor(0, 0, 0)
base.disableMouse()
self.cam_ctrl = CameraController()
self.cam_ctrl.reset()
alight = AmbientLight('alight')
alight.setColor((0.2, 0.2, 0.2, 1))
alnp = render.attachNewNode(alight)
render.setLight(alnp)
# The global variables we use to control the speed and size of objects
self.yearscale = 900
self.dayscale = self.yearscale / 365.0 * 30
self.yearCounter = 0
self.dayCounter = 0
self.money = 2000
self.system_population = 0
self.orbitscale = 10
self.sizescale = 0.6
# Global game balance variables
self.population_time_delta = 3
self.tax_factor = 0.1
self.salvage_factor = 0.75
self.food_consuming_factor = 0.75
self.goods_cap = 1000
self.PlanetInfoModeOn = False
self.capitalPlanet = None
self.galaxy_objects = []
self.BuildingsDB = {} # Will contain all buildable structures
# Everything that's needed to detect selecting objects with mouse
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.collQueue = CollisionHandlerQueue()
base.cTrav = CollisionTraverser('myTraverser')
base.cTrav.addCollider(self.pickerNP, self.collQueue)
# Set up the start screen
self.create_gui()
self.NewPlanetInfoView = PlanetInfoView(self)
self.NewPlanetBuildView = PlanetBuildView(self)
self.load_planets()
self.rotate_planets()
self.BuildingsDB = buildingsDB.loadDB()
self.set_capital_planet()
# Add all constantly running checks to the taskmanager
taskMgr.add(self.redraw_head_gui, "redrawHeadGUITask")
taskMgr.doMethodLater(self.population_time_delta,
self.populate_planet_task,
'populatePlanetTask',
extraArgs=[self.Earth],
appendTask=True)
taskMgr.doMethodLater(2, self.generate_money_task, 'generateMoneyTask')
# Open up all listeners for varous mouse and keyboard inputs
self.accept("escape", sys.exit)
self.accept('mouse1', self.handle_mouse_click)
def initialize(self):
"""Reset everything except LevitorNP and selected, also called inside __init__"""
self.notify = DirectNotify().newCategory('grabberErr')
self.currPlaneColNorm = Vec3(0.0)
self.isCameraControlOn = False
self.isDragging = False
self.isMultiselect = False
self.grabScaleFactor = .075
self.currTransformDir = Point3(0.0)
self.interFrameMousePosition = Point3(0.0)
self.init3DemVal = Point3(0.0)
# initCommVal holds the value before a command operation has taken place
self.initialCommandTrgVal = None
# To load the grabber model, this climbs up the absolute path to /barebones/ to gain access to the model folder
self.grabModelNP = loader.loadModel(Filename.fromOsSpecific(
ntpath.split( ntpath.split(inspect.stack()[0][1])[0] )[0])
+ '/EditorModels/widget')
self.grabModelNP.setPos(0.0, 0.0, 0.0)
self.grabModelNP.setBin("fixed", 40)
self.grabModelNP.setDepthTest(False)
self.grabModelNP.setDepthWrite(False)
self.transformOpEnum = Enum('rot, scale, trans')
self.currTransformOperation = None
# TODO For readability, use this enum in the nested if/else as was the original intent.
self.grabInd = Enum('xRot, yRot, zRot, xScaler, yScaler, zScaler, xTrans, yTrans, zTrans, xyTrans, xzTrans, zyTrans, grabCore')
grbrNodLst = [self.grabModelNP.find("**/XRotator;+h-s-i"), # 0
self.grabModelNP.find("**/YRotator;+h-s-i"), # 1
self.grabModelNP.find("**/ZRotator;+h-s-i"), # 2 end rotate
self.grabModelNP.find("**/XScaler;+h-s-i"), # 3
self.grabModelNP.find("**/YScaler;+h-s-i"), # 4
self.grabModelNP.find("**/ZScaler;+h-s-i"), # 5 end scale
self.grabModelNP.find("**/XTranslator;+h-s-i"), # 6
self.grabModelNP.find("**/YTranslator;+h-s-i"), # 7
self.grabModelNP.find("**/ZTranslator;+h-s-i"), # 8 end translate / end single dir operations
self.grabModelNP.find("**/XYTranslator;+h-s-i"), # 9
self.grabModelNP.find("**/XZTranslator;+h-s-i"), # 10
self.grabModelNP.find("**/ZYTranslator;+h-s-i"), # 11 end bi-directional operations
self.grabModelNP.find("**/WidgetCore;+h-s-i")] # 12
#Mat4.yToZUpMat() # change coordinate to z up
grbrNodLst[12].getParent().setHprScale(0, 0, 0, 1, 1, -1)
self.grabModelNP.setPythonTag('grabberRoot', grbrNodLst)
self.grabModelNP.reparentTo(BBGlobalVars.bareBonesObj.levitorNP)
self.grabModelNP.hide()
#self.grabIntoBitMask = COLLISIONMASKS
self.grabModelNP.setCollideMask(COLLISIONMASKS['default'])
self.grabModelNP.setPythonTag('grabber', self)
##############################################################################
# This whole section is the basics for setting up mouse selection
# --The mouse events are added in the events section (next)
# Create the collision node for the picker ray to add traverser as a 'from' collider
self.grabberColNode = CollisionNode('grabberMouseRay')
# Set the collision bitmask
# TODO: define collision bitmask (let user define thiers? likely not)
self.defaultBitMask = GeomNode.getDefaultCollideMask()
self.grabberColNode.setFromCollideMask(self.defaultBitMask)
self.grabberRayColNP = camera.attachNewNode(self.grabberColNode)
# Create the grabberRay and add it to the picker CollisionNode
self.grabberRay = CollisionRay(0.0, 0.0, 0.0,
0.0, 1.0, 0.0)
self.grabberRayNP = self.grabberColNode.addSolid(self.grabberRay)
# create a collision queue for the traverser
self.colHandlerQueue = CollisionHandlerQueue()
# Create collision traverser
self.colTraverser = CollisionTraverser('grabberTraverser')
# Set the collision traverser's 'fromObj' and handler
# e.g. trav.addCollider( fromObj, handler )
self.colTraverser.addCollider(self.grabberRayColNP, self.colHandlerQueue)
############################################################
# setup event handling with the messenger
# URGENT remove all of this messenger code throughout Grabber, especially the camera control
# disable the mouse when the ~ is pressed (w/o shift)
self.disableCamera() # disable camera control by the mouse
messenger.accept('`', self, self.enableCamera) # enable camera control when the ~ key is pressed w/o shift
messenger.accept('`-up', self, self.disableCamera) # disable camera control when the ~ key is released
# handle mouse selection/deselection & manipulating the scene
messenger.accept('mouse1', self, self.handleM1, persistent=1) # deselect in event handler
taskMgr.add(self.scaleGrabber, 'scaleGrabber')
def __init__(self, _main):
self.main = _main
# Stats
self.moveSpeed = 8
self.inventory = []
self.maxCarryWeight = 20.0 #kg ?
self.currentInventoryWeight = 0.0
# Inventory GUI
self.inventoryGui = Inventory()
self.inventoryGui.hide()
self.inventoryActive = False
self.craftInventory = CraftInventory()
self.craftInventory.hide()
# enable movements through the level
self.keyMap = {"left":0, "right":0, "forward":0, "backward":0}
self.player = NodePath("Player")#loader.loadModel("smiley")
self.player.setPos(149.032, 329.324, 11.3384)
self.player.setH(180)
self.player.reparentTo(render)
self.accept("w", self.setKey, ["forward",1])
self.accept("w-up", self.setKey, ["forward",0])
self.accept("a", self.setKey, ["left",1])
self.accept("a-up", self.setKey, ["left",0])
self.accept("s", self.setKey, ["backward",1])
self.accept("s-up", self.setKey, ["backward",0])
self.accept("d", self.setKey, ["right",1])
self.accept("d-up", self.setKey, ["right",0])
self.accept("mouse1", self.handleLeftMouse)
self.accept("i", self.toggleInventory)
self.accept("c", self.toggleCraftInventory)
# screen sizes
self.winXhalf = base.win.getXSize() / 2
self.winYhalf = base.win.getYSize() / 2
self.mouseSpeedX = 0.1
self.mouseSpeedY = 0.1
camera.setH(180)
camera.reparentTo(self.player)
camera.setZ(self.player, 2)
base.camLens.setFov(75)
base.camLens.setNear(0.8)
# Mouse controls
self.mouseNode = CollisionNode('mouseRay')
self.mouseNodeNP = camera.attachNewNode(self.mouseNode)
self.mouseNode.setFromCollideMask(GeomNode.getDefaultCollideMask())
self.mouseRay = CollisionRay()
self.mouseNode.addSolid(self.mouseRay)
self.mouseRayHandler = CollisionHandlerQueue()
# Collision Traverser
self.traverser = CollisionTraverser("Player Traverser")
base.cTrav = self.traverser
self.traverser.addCollider(self.mouseNodeNP, self.mouseRayHandler)