class Cursor(DirectObject): """Cursor object for the UI.""" parent: NodePath mouse_np: NodePath actor: Actor last_position: Point moved: bool pointed_at: Optional[NodePath] def __init__(self, parent: NodePath): super().__init__() self.parent = parent self.mouse_np = p3d.camera.attach_new_node(PandaNode('mouse')) self.mouse_np.set_y(p3d.lens.get_near()) picker_node = CollisionNode('mouse_ray') picker_np = p3d.camera.attach_new_node(picker_node) self._picker_ray = CollisionRay() picker_node.add_solid(self._picker_ray) self._collision_handler = CollisionHandlerQueue() self._traverser = CollisionTraverser('mouse_traverser') self._traverser.add_collider(picker_np, self._collision_handler) self.actor = Actor( resource_filename('tsim', 'data/models/cursor'), {'spin': resource_filename('tsim', 'data/models/cursor-spin')}) self.actor.loop('spin') self.actor.reparent_to(parent) self.actor.set_pos(0.0, 0.0, 0.0) self.actor.set_shader_off() self._position = Point(0.0, 0.0) self.last_position = self._position self.moved = False self.pointed_at = None self._tool: Optional[Tool] = None self._register_events() @property def position(self) -> Point: """Get the cursor position.""" return self._position @position.setter def position(self, value: Union[Point, Iterable]): if not isinstance(value, Point): value = Point(*islice(value, 2)) self.actor.set_x(value.x) self.actor.set_y(value.y) self._position = value @property def tool(self) -> Optional[Tool]: """Get current tool.""" return self._tool @tool.setter def tool(self, value: Tool): if self._tool is not None: self._tool.cleanup() self.ignore_all() self._register_events() self._tool = value if value is not None: for key in INPUT.keys_for('tool_1'): self.accept(key, self._tool.on_button1_press) self.accept(f'{key}-up', self._tool.on_button1_release) for key in INPUT.keys_for('tool_2'): self.accept(key, self._tool.on_button2_press) self.accept(f'{key}-up', self._tool.on_button2_release) for key in INPUT.keys_for('tool_3'): self.accept(key, self._tool.on_button3_press) self.accept(f'{key}-up', self._tool.on_button3_release) self.accept('cursor_move', self._tool.on_cursor_move) def update(self): """Update callback.""" self.actor.set_scale(p3d.camera.get_z()**0.6 / 10) self.moved = False if p3d.mouse_watcher.has_mouse(): mouse_x, mouse_y = p3d.mouse_watcher.get_mouse() self._picker_ray.set_from_lens(p3d.cam_node, mouse_x, mouse_y) self._traverser.traverse(p3d.render) if self._collision_handler.get_num_entries(): self._collision_handler.sort_entries() node_path = ( self._collision_handler.get_entry(0).get_into_node_path()) self.position = node_path.get_pos(p3d.render) self.actor.set_z(2.0) self.pointed_at = node_path else: self.pointed_at = None film = p3d.lens.get_film_size() * 0.5 self.mouse_np.set_x(mouse_x * film.x) self.mouse_np.set_y(p3d.lens.get_focal_length()) self.mouse_np.set_z(mouse_y * film.y) self.last_position = self._position mouse_pos = self.mouse_np.get_pos(self.parent) cam_pos = p3d.camera.get_pos(self.parent) mouse_vec = mouse_pos - cam_pos if mouse_vec.z < 0.0: scale = -mouse_pos.z / mouse_vec.z self.actor.set_pos(mouse_pos + mouse_vec * scale) self.position = self.actor.get_pos() if self._position != self.last_position: self.moved = True p3d.messenger.send('cursor_move') if self._tool is not None: self._tool.on_update() def _on_simulation_step(self, dt: Duration): if self._tool is not None: self._tool.on_simulation_step(dt) def _register_events(self): def set_tool(tool: Type[Tool]): self.tool = tool(self) log.info('[%s] Changing tool to %s', __name__, tool.__name__) for tool in TOOLS: try: self.accept(tool.KEY, partial(set_tool, tool)) except AttributeError: log.warning('[%s] No KEY set for tool %s', __name__, tool.__name__) self.accept('simulation_step', self._on_simulation_step)
class Picker(object): ''' A class for picking (Panda3d) objects. ''' def __init__(self, app, render, camera, mouseWatcher, pickKeyOn, pickKeyOff, collideMask, pickableTag="pickable"): self.render = render self.mouseWatcher = mouseWatcher.node() self.camera = camera self.camLens = camera.node().get_lens() self.collideMask = collideMask self.pickableTag = pickableTag self.taskMgr = app.task_mgr # setup event callback for picking body self.pickKeyOn = pickKeyOn self.pickKeyOff = pickKeyOff app.accept(self.pickKeyOn, self._pickBody, [self.pickKeyOn]) app.accept(self.pickKeyOff, self._pickBody, [self.pickKeyOff]) # collision data self.collideMask = collideMask self.cTrav = CollisionTraverser() self.collisionHandler = CollisionHandlerQueue() self.pickerRay = CollisionRay() pickerNode = CollisionNode("Utilities.pickerNode") node = NodePath("PhysicsNode") node.reparentTo(render) anp = node.attachNewNode(pickerNode) base.physicsMgr.attachPhysicalNode(pickerNode) pickerNode.add_solid(self.pickerRay) pickerNode.set_from_collide_mask(self.collideMask) pickerNode.set_into_collide_mask(BitMask32.all_off()) #pickerNode.node().getPhysicsObject().setMass(10) self.cTrav.add_collider(self.render.attach_new_node(pickerNode), self.collisionHandler) # service data self.pickedBody = None self.oldPickingDist = 0.0 self.deltaDist = 0.0 self.dragging = False self.updateTask = None def _pickBody(self, event): # handle body picking if event == self.pickKeyOn: # check mouse position if self.mouseWatcher.has_mouse(): # Get to and from pos in camera coordinates pMouse = self.mouseWatcher.get_mouse() # pFrom = LPoint3f() pTo = LPoint3f() if self.camLens.extrude(pMouse, pFrom, pTo): # Transform to global coordinates rayFromWorld = self.render.get_relative_point( self.camera, pFrom) rayToWorld = self.render.get_relative_point( self.camera, pTo) # cast a ray to detect a body # traverse downward starting at rayOrigin self.pickerRay.set_direction(rayToWorld - rayFromWorld) self.pickerRay.set_origin(rayFromWorld) self.cTrav.traverse(self.render) if self.collisionHandler.get_num_entries() > 0: self.collisionHandler.sort_entries() entry0 = self.collisionHandler.get_entry(0) hitPos = entry0.get_surface_point(self.render) # get the first parent with name pickedObject = entry0.get_into_node_path() while not pickedObject.has_tag(self.pickableTag): pickedObject = pickedObject.getParent() if not pickedObject: return if pickedObject == self.render: return # self.pickedBody = pickedObject self.oldPickingDist = (hitPos - rayFromWorld).length() self.deltaDist = ( self.pickedBody.get_pos(self.render) - hitPos) print(self.pickedBody.get_name(), hitPos) if not self.dragging: self.dragging = True # create the task for updating picked body motion self.updateTask = self.taskMgr.add( self._movePickedBody, "_movePickedBody") # set sort/priority self.updateTask.set_sort(0) self.updateTask.set_priority(0) else: if self.dragging: # remove pick body motion update task self.taskMgr.remove("_movePickedBody") self.updateTask = None self.dragging = False self.pickedBody = None def _movePickedBody(self, task): # handle picked body if any if self.pickedBody and self.dragging: # check mouse position if self.mouseWatcher.has_mouse(): # Get to and from pos in camera coordinates pMouse = self.mouseWatcher.get_mouse() # pFrom = LPoint3f() pTo = LPoint3f() if self.camLens.extrude(pMouse, pFrom, pTo): # Transform to global coordinates rayFromWorld = self.render.get_relative_point( self.camera, pFrom) rayToWorld = self.render.get_relative_point( self.camera, pTo) # keep it at the same picking distance direction = (rayToWorld - rayFromWorld).normalized() direction *= self.oldPickingDist self.pickedBody.set_pos( self.render, rayFromWorld + direction + self.deltaDist) #self.pickedBody.reparentTo(np) #self.pickedBody.setMass(10.0) # return task.cont
class MouseOverOnEntity(System): entity_filters = { 'mouseoverable': [Proxy('model'), MouseOverable], 'mouseoverable_geometry': [Proxy('geometry'), MouseOverableGeometry], 'camera': [Camera, Input, MouseOveringCamera], } proxies = { 'model': ProxyType(Model, 'node'), 'geometry': ProxyType(Geometry, 'node'), } def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.traverser = CollisionTraverser() self.queue = CollisionHandlerQueue() self.picker_ray = CollisionRay() self.picker_node = CollisionNode('mouse ray') self.picker_node.add_solid(self.picker_ray) self.picker_node.set_from_collide_mask(MOUSEOVER_MASK) self.picker_node.set_into_collide_mask(0x0) self.picker_node_path = NodePath(self.picker_node) self.traverser.add_collider(self.picker_node_path, self.queue) def enter_filter_mouseoverable(self, entity): model_proxy = self.proxies['model'] model_node = model_proxy.field(entity) mouseoverable = entity[MouseOverable] into_node = CollisionNode('wecs_mouseoverable') into_node.add_solid(mouseoverable.solid) into_node.set_from_collide_mask(0x0) into_node.set_into_collide_mask(mouseoverable.mask) into_node_path = model_node.attach_new_node(into_node) into_node_path.set_python_tag('wecs_mouseoverable', entity._uid) def exit_filter_mouseoverable(self, entity): # FIXME: Undo all the other stuff that accumulated! entity[MouseOverable].solid.detach_node() def enter_filter_mouseoverable_geometry(self, entity): into_node = self.proxies['geometry'].field(entity) old_mask = into_node.get_collide_mask() new_mask = old_mask | entity[MouseOverableGeometry].mask into_node.set_collide_mask(new_mask) into_node.find('**/+GeomNode').set_python_tag('wecs_mouseoverable', entity._uid) def update(self, entities_by_filter): for entity in entities_by_filter['camera']: mouse_overing = entity[MouseOveringCamera] camera = entity[Camera] input = entity[Input] # Reset overed entity to None mouse_overing.entity = None mouse_overing.collision_entry = None requested = 'mouse_over' in input.contexts has_mouse = base.mouseWatcherNode.has_mouse() if requested and has_mouse: # Attach and align testing ray, and run collisions self.picker_node_path.reparent_to(camera.camera) mpos = base.mouseWatcherNode.get_mouse() self.picker_ray.set_from_lens( base.camNode, mpos.getX(), mpos.getY(), ) self.traverser.traverse(camera.camera.get_top()) # Remember reference to mouseovered entity, if any if self.queue.get_num_entries() > 0: self.queue.sort_entries() entry = self.queue.get_entry(0) picked_node = entry.get_into_node_path() picked_uid = picked_node.get_python_tag( 'wecs_mouseoverable') mouse_overing.entity = picked_uid mouse_overing.collision_entry = entry
class MapPicker(): __name: Final[str] __base: Final[ShowBase] __data: Final[NDArray[(Any, Any, Any), np.uint8]] # collision data __ctrav: Final[CollisionTraverser] __cqueue: Final[CollisionHandlerQueue] __cn: Final[CollisionNode] __cnp: Final[NodePath] # picker data __pn: Final[CollisionNode] __pnp: Final[NodePath] __pray: Final[CollisionRay] # constants COLLIDE_MASK: Final[BitMask32] = BitMask32.bit(1) def __init__(self, services: Services, base: ShowBase, map_data: MapData, name: Optional[str] = None): self.__services = services self.__services.ev_manager.register_listener(self) self.__base = base self.__name = name if name is not None else (map_data.name + "_picker") self.__map = map_data self.__data = map_data.data # collision traverser & queue self.__ctrav = CollisionTraverser(self.name + '_ctrav') self.__cqueue = CollisionHandlerQueue() # collision boxes self.__cn = CollisionNode(self.name + '_cn') self.__cn.set_collide_mask(MapPicker.COLLIDE_MASK) self.__cnp = self.__map.root.attach_new_node(self.__cn) self.__ctrav.add_collider(self.__cnp, self.__cqueue) self.__points = [] z_offset = 1 if self.__map.dim == 3 else self.__map.depth for idx in np.ndindex(self.__data.shape): if bool(self.__data[idx] & MapData.TRAVERSABLE_MASK): p = Point(*idx) self.__points.append(p) idx = self.__cn.add_solid(CollisionBox(idx, Point3(p.x+1, p.y+1, p.z-z_offset))) assert idx == (len(self.__points) - 1) # mouse picker self.__pn = CollisionNode(self.name + '_pray') self.__pnp = self.__base.cam.attach_new_node(self.__pn) self.__pn.set_from_collide_mask(MapPicker.COLLIDE_MASK) self.__pray = CollisionRay() self.__pn.add_solid(self.__pray) self.__ctrav.add_collider(self.__pnp, self.__cqueue) # debug -> shows collision ray / impact point # self.__ctrav.show_collisions(self.__map.root) @property def name(self) -> str: return self.__name @property def pos(self): # check if we have access to the mouse if not self.__base.mouseWatcherNode.hasMouse(): return None # get the mouse position mpos = self.__base.mouseWatcherNode.get_mouse() # set the position of the ray based on the mouse position self.__pray.set_from_lens(self.__base.camNode, mpos.getX(), mpos.getY()) # find collisions self.__ctrav.traverse(self.__map.root) # if we have hit something sort the hits so that the closest is first if self.__cqueue.get_num_entries() == 0: return None self.__cqueue.sort_entries() # compute & return logical cube position x, y, z = self.__cqueue.get_entry(0).getSurfacePoint(self.__map.root) x, y, z = [max(math.floor(x), 0), max(math.floor(y), 0), max(math.ceil(z), 0)] if x == len(self.__data): x -= 1 if y == len(self.__data[x]): y -= 1 if z == len(self.__data[x][y]): z -= 1 return Point(x, y, z) def notify(self, event: Event) -> None: if isinstance(event, MapUpdateEvent): z_offset = 1 if self.__map.dim == 3 else self.__map.depth for p in event.updated_cells: if p.n_dim == 2: p = Point(*p, 0) if bool(self.__data[p.values] & MapData.TRAVERSABLE_MASK): self.__points.append(p) idx = self.__cn.add_solid(CollisionBox(p.values, Point3(p.x+1, p.y+1, p.z-z_offset))) assert idx == (len(self.__points) - 1) else: try: i = self.__points.index(p) except ValueError: continue self.__cn.remove_solid(i) self.__points.pop(i) def destroy(self) -> None: self.__cqueue.clearEntries() self.__ctrav.clear_colliders() self.__cnp.remove_node() self.__pnp.remove_node()