class Raycaster(Entity):
line_model = Mesh(vertices=[Vec3(0, 0, 0), Vec3(0, 0, 1)], mode='line')
_boxcast_box = Entity(model='cube',
origin_z=-.5,
collider='box',
color=color.white33,
enabled=False)
def __init__(self):
super().__init__(name='raycaster', eternal=True)
self._picker = CollisionTraverser() # Make a traverser
self._pq = CollisionHandlerQueue() # Make a handler
self._pickerNode = CollisionNode('raycaster')
self._pickerNode.set_into_collide_mask(0)
self._pickerNP = self.attach_new_node(self._pickerNode)
self._picker.addCollider(self._pickerNP, self._pq)
def distance(self, a, b):
return sqrt(sum((a - b)**2 for a, b in zip(a, b)))
def raycast(self,
origin,
direction=(0, 0, 1),
distance=inf,
traverse_target=scene,
ignore=list(),
debug=False):
self.position = origin
self.look_at(self.position + direction)
self._pickerNode.clearSolids()
ray = CollisionRay()
ray.setOrigin(Vec3(0, 0, 0))
ray.setDirection(Vec3(0, 0, 1))
self._pickerNode.addSolid(ray)
if debug:
temp = Entity(position=origin,
model=Raycaster.line_model,
scale=Vec3(1, 1, min(distance, 9999)),
add_to_scene_entities=False)
temp.look_at(self.position + direction)
destroy(temp, 1 / 30)
self._picker.traverse(traverse_target)
if self._pq.get_num_entries() == 0:
self.hit = HitInfo(hit=False, distance=distance)
return self.hit
ignore += tuple([e for e in scene.entities if not e.collision])
self._pq.sort_entries()
self.entries = [ # filter out ignored entities
e for e in self._pq.getEntries()
if e.get_into_node_path().parent not in ignore and self.distance(
self.world_position, Vec3(
*e.get_surface_point(render))) <= distance
]
if len(self.entries) == 0:
self.hit = HitInfo(hit=False, distance=distance)
return self.hit
self.collision = self.entries[0]
nP = self.collision.get_into_node_path().parent
point = Vec3(*self.collision.get_surface_point(nP))
world_point = Vec3(*self.collision.get_surface_point(render))
hit_dist = self.distance(self.world_position, world_point)
self.hit = HitInfo(hit=True, distance=distance)
for e in scene.entities:
if e == nP:
self.hit.entity = e
nPs = [e.get_into_node_path().parent for e in self.entries]
self.hit.entities = [e for e in scene.entities if e in nPs]
self.hit.point = point
self.hit.world_point = world_point
self.hit.distance = hit_dist
self.hit.normal = Vec3(*self.collision.get_surface_normal(
self.collision.get_into_node_path().parent).normalized())
self.hit.world_normal = Vec3(
*self.collision.get_surface_normal(render).normalized())
return self.hit
self.hit = HitInfo(hit=False, distance=distance)
return self.hit
def boxcast(self,
origin,
direction=(0, 0, 1),
distance=9999,
thickness=(1, 1),
traverse_target=scene,
ignore=list(),
debug=False): # similar to raycast, but with width and height
if isinstance(thickness, (int, float, complex)):
thickness = (thickness, thickness)
Raycaster._boxcast_box.enabled = True
Raycaster._boxcast_box.collision = True
Raycaster._boxcast_box.position = origin
Raycaster._boxcast_box.scale = Vec3(abs(thickness[0]),
abs(thickness[1]), abs(distance))
Raycaster._boxcast_box.always_on_top = debug
Raycaster._boxcast_box.visible = debug
Raycaster._boxcast_box.look_at(origin + direction)
hit_info = Raycaster._boxcast_box.intersects(
traverse_target=traverse_target, ignore=ignore)
if hit_info.world_point:
hit_info.distance = ursinamath.distance(origin,
hit_info.world_point)
else:
hit_info.distance = distance
if debug:
Raycaster._boxcast_box.collision = False
Raycaster._boxcast_box.scale_z = hit_info.distance
invoke(setattr, Raycaster._boxcast_box, 'enabled', False, delay=.2)
else:
Raycaster._boxcast_box.enabled = False
return hit_info
class Mouse():
def __init__(self):
self.enabled = False
self.locked = False
self.position = Vec3(0, 0, 0)
self.delta = Vec3(0, 0, 0)
self.prev_x = 0
self.prev_y = 0
self.start_x = 0
self.start_y = 0
self.velocity = Vec3(0, 0, 0)
self.prev_click_time = time.time()
self.double_click_distance = .5
self.hovered_entity = None # returns the closest hovered entity with a collider.
self.left = False
self.right = False
self.middle = False
self.delta_drag = Vec3(0, 0, 0)
self.update_step = 1
self.traverse_target = scene
self._i = 0
self._mouse_watcher = None
self._picker = CollisionTraverser() # Make a traverser
self._pq = CollisionHandlerQueue() # Make a handler
self._pickerNode = CollisionNode('mouseRay')
self._pickerNP = camera.attach_new_node(self._pickerNode)
self._pickerRay = CollisionRay() # Make our ray
self._pickerNode.addSolid(self._pickerRay)
self._picker.addCollider(self._pickerNP, self._pq)
self._pickerNode.set_into_collide_mask(0)
self.raycast = True
self.collision = None
self.collisions = list()
self.enabled = True
@property
def x(self):
if not self._mouse_watcher.has_mouse():
return 0
return self._mouse_watcher.getMouseX(
) / 2 * window.aspect_ratio # same space as ui stuff
@x.setter
def x(self, value):
self.position = (value, self.y)
@property
def y(self):
if not self._mouse_watcher.has_mouse():
return 0
return self._mouse_watcher.getMouseY() / 2
@y.setter
def y(self, value):
self.position = (self.x, value)
@property
def position(self):
return Vec3(self.x, self.y, 0)
@position.setter
def position(self, value):
base.win.move_pointer(
0,
round(value[0] + (window.size[0] / 2) +
(value[0] / 2 * window.size[0]) *
1.124), # no idea why I have * with 1.124
round(value[1] + (window.size[1] / 2) -
(value[1] * window.size[1])),
)
def __setattr__(self, name, value):
if name == 'visible':
window.set_cursor_hidden(not value)
application.base.win.requestProperties(window)
if name == 'locked':
try:
object.__setattr__(self, name, value)
window.set_cursor_hidden(value)
if value:
window.set_mouse_mode(window.M_relative)
else:
window.set_mouse_mode(window.M_absolute)
application.base.win.requestProperties(window)
except:
pass
try:
super().__setattr__(name, value)
# return
except:
pass
def input(self, key):
if not self.enabled:
return
if key.endswith('mouse down'):
self.start_x = self.x
self.start_y = self.y
elif key.endswith('mouse up'):
self.delta_drag = Vec3(self.x - self.start_x,
self.y - self.start_y, 0)
if key == 'left mouse down':
self.left = True
if self.hovered_entity:
if hasattr(self.hovered_entity, 'on_click'):
self.hovered_entity.on_click()
for s in self.hovered_entity.scripts:
if hasattr(s, 'on_click'):
s.on_click()
# double click
if time.time(
) - self.prev_click_time <= self.double_click_distance:
base.input('double click')
if self.hovered_entity:
if hasattr(self.hovered_entity, 'on_double_click'):
self.hovered_entity.on_double_click()
for s in self.hovered_entity.scripts:
if hasattr(s, 'on_double_click'):
s.on_double_click()
self.prev_click_time = time.time()
if key == 'left mouse up':
self.left = False
if key == 'right mouse down':
self.right = True
if key == 'right mouse up':
self.right = False
if key == 'middle mouse down':
self.middle = True
if key == 'middle mouse up':
self.middle = False
def update(self):
if not self.enabled or not self._mouse_watcher.has_mouse():
self.velocity = Vec3(0, 0, 0)
return
self.moving = self.x + self.y != self.prev_x + self.prev_y
if self.moving:
if self.locked:
self.velocity = self.position
self.position = (0, 0)
else:
self.velocity = Vec3(self.x - self.prev_x,
(self.y - self.prev_y) /
window.aspect_ratio, 0)
else:
self.velocity = Vec3(0, 0, 0)
if self.left or self.right or self.middle:
self.delta = Vec3(self.x - self.start_x, self.y - self.start_y, 0)
self.prev_x = self.x
self.prev_y = self.y
self._i += 1
if self._i < self.update_step:
return
# collide with ui
self._pickerNP.reparent_to(scene.ui_camera)
self._pickerRay.set_from_lens(camera._ui_lens_node,
self.x * 2 / window.aspect_ratio,
self.y * 2)
self._picker.traverse(camera.ui)
if self._pq.get_num_entries() > 0:
# print('collided with ui', self._pq.getNumEntries())
self.find_collision()
return
# collide with world
self._pickerNP.reparent_to(camera)
self._pickerRay.set_from_lens(scene.camera.lens_node,
self.x * 2 / window.aspect_ratio,
self.y * 2)
try:
self._picker.traverse(self.traverse_target)
except:
# print('error: mouse._picker could not traverse', self.traverse_target)
return
if self._pq.get_num_entries() > 0:
self.find_collision()
else:
# print('mouse miss', base.render)
# unhover all if it didn't hit anything
for entity in scene.entities:
if hasattr(entity, 'hovered') and entity.hovered:
entity.hovered = False
self.hovered_entity = None
if hasattr(entity, 'on_mouse_exit'):
entity.on_mouse_exit()
for s in entity.scripts:
if hasattr(s, 'on_mouse_exit'):
s.on_mouse_exit()
@property
def normal(self):
if not self.collision:
return None
return self.collision.normal
@property
def world_normal(self):
if not self.collision:
return None
return self.collision.world_normal
@property
def point(self): # returns the point hit in local space
if self.collision:
return self.collision.point
return None
@property
def world_point(self):
if self.collision:
return self.collision.world_point
return None
def find_collision(self):
self.collisions = list()
self.collision = None
if not self.raycast or self._pq.get_num_entries() == 0:
self.unhover_everything_not_hit()
return False
self._pq.sortEntries()
for entry in self._pq.getEntries():
for entity in scene.entities:
if entry.getIntoNodePath(
).parent == entity and entity.collision:
if entity.collision:
hit = HitInfo(
hit=entry.collided(),
entity=entity,
distance=distance(entry.getSurfacePoint(scene),
camera.getPos()),
point=entry.getSurfacePoint(entity),
world_point=entry.getSurfacePoint(scene),
normal=entry.getSurfaceNormal(entity),
world_normal=entry.getSurfaceNormal(scene),
)
self.collisions.append(hit)
break
if self.collisions:
self.collision = self.collisions[0]
self.hovered_entity = self.collision.entity
if not self.hovered_entity.hovered:
self.hovered_entity.hovered = True
if hasattr(self.hovered_entity, 'on_mouse_enter'):
self.hovered_entity.on_mouse_enter()
for s in self.hovered_entity.scripts:
if hasattr(s, 'on_mouse_enter'):
s.on_mouse_enter()
self.unhover_everything_not_hit()
def unhover_everything_not_hit(self):
for e in scene.entities:
if e == self.hovered_entity:
continue
if e.hovered:
e.hovered = False
if hasattr(e, 'on_mouse_exit'):
e.on_mouse_exit()
for s in e.scripts:
if hasattr(s, 'on_mouse_exit'):
s.on_mouse_exit()
class Raycaster(Entity):
def __init__(self):
super().__init__(name='raycaster', eternal=True)
self._picker = CollisionTraverser() # Make a traverser
self._pq = CollisionHandlerQueue() # Make a handler
self._pickerNode = CollisionNode('raycaster')
self._pickerNode.set_into_collide_mask(0)
self._pickerNP = self.attach_new_node(self._pickerNode)
self._picker.addCollider(self._pickerNP, self._pq)
self._pickerNP.show()
def distance(self, a, b):
return math.sqrt(sum((a - b)**2 for a, b in zip(a, b)))
def raycast(self,
origin,
direction=(0, 0, 1),
distance=math.inf,
traverse_target=scene,
ignore=list(),
debug=False):
self.position = origin
self.look_at(self.position + direction)
self._pickerNode.clearSolids()
# if thickness == (0,0):
if distance == math.inf:
ray = CollisionRay()
ray.setOrigin(Vec3(0, 0, 0))
ray.setDirection(Vec3(0, 1, 0))
else:
ray = CollisionSegment(Vec3(0, 0, 0), Vec3(0, distance, 0))
self._pickerNode.addSolid(ray)
if debug:
self._pickerNP.show()
else:
self._pickerNP.hide()
self._picker.traverse(traverse_target)
if self._pq.get_num_entries() == 0:
self.hit = Hit(hit=False)
return self.hit
ignore += tuple([e for e in scene.entities if not e.collision])
self._pq.sort_entries()
self.entries = [ # filter out ignored entities
e for e in self._pq.getEntries()
if e.get_into_node_path().parent not in ignore
]
if len(self.entries) == 0:
self.hit = Hit(hit=False)
return self.hit
self.collision = self.entries[0]
nP = self.collision.get_into_node_path().parent
point = self.collision.get_surface_point(nP)
point = Vec3(point[0], point[2], point[1])
world_point = self.collision.get_surface_point(render)
world_point = Vec3(world_point[0], world_point[2], world_point[1])
hit_dist = self.distance(self.world_position, world_point)
if nP.name.endswith('.egg'):
nP = nP.parent
self.hit = Hit(hit=True)
for e in scene.entities:
if e == nP:
# print('cast nP to Entity')
self.hit.entity = e
self.hit.point = point
self.hit.world_point = world_point
self.hit.distance = hit_dist
normal = self.collision.get_surface_normal(
self.collision.get_into_node_path().parent)
self.hit.normal = (normal[0], normal[2], normal[1])
normal = self.collision.get_surface_normal(render)
self.hit.world_normal = (normal[0], normal[2], normal[1])
return self.hit
self.hit = Hit(hit=False)
return self.hit
def boxcast(self,
origin,
direction=(0, 0, 1),
distance=math.inf,
thickness=(1, 1),
traverse_target=scene,
ignore=list(),
debug=False):
if isinstance(thickness, (int, float, complex)):
thickness = (thickness, thickness)
resolution = 3
rays = list()
debugs = list()
for y in range(3):
for x in range(3):
pos = origin + Vec3(
lerp(-(thickness[0] / 2), thickness[0] / 2, x / (3 - 1)),
lerp(-(thickness[1] / 2), thickness[1] / 2, y /
(3 - 1)), 0)
ray = self.raycast(pos, direction, distance, traverse_target,
ignore, False)
rays.append(ray)
if debug and ray.hit:
d = Entity(model='cube',
origin_z=-.5,
position=pos,
scale=(.02, .02, distance),
ignore=True)
d.look_at(pos + Vec3(direction))
debugs.append(d)
# print(pos, hit.point)
if ray.hit and ray.distance > 0:
d.scale_z = ray.distance
d.color = color.green
from ursina import destroy
# [destroy(e, 1/60) for e in debugs]
rays.sort(key=lambda x: x.distance)
closest = rays[0]
return Hit(
hit=sum([int(e.hit) for e in rays]) > 0,
entity=closest.entity,
point=closest.point,
world_point=closest.world_point,
distance=closest.distance,
normal=closest.normal,
world_normal=closest.world_normal,
hits=[e.hit for e in rays],
entities=list(set([e.entity
for e in rays])), # get unique entities hit
)
class Entity(NodePath):
rotation_directions = (-1,-1,1)
default_shader = None
def __init__(self, add_to_scene_entities=True, **kwargs):
super().__init__(self.__class__.__name__)
self.name = camel_to_snake(self.type)
self.enabled = True # disabled entities wil not be visible nor run code
self.visible = True
self.ignore = False # if True, will not try to run code
self.eternal = False # eternal entities does not get destroyed on scene.clear()
self.ignore_paused = False
self.ignore_input = False
self.parent = scene
self.add_to_scene_entities = add_to_scene_entities # set to False to be ignored by the engine, but still get rendered.
if add_to_scene_entities:
scene.entities.append(self)
self.model = None # set model with model='model_name' (without file type extention)
self.color = color.white
self.texture = None # set model with texture='texture_name'. requires a model to be set beforehand.
self.reflection_map = scene.reflection_map
self.reflectivity = 0
self.render_queue = 0
self.double_sided = False
self.shader = Entity.default_shader
# self.always_on_top = False
self.collision = False # toggle collision without changing collider.
self.collider = None # set to 'box'/'sphere'/'mesh' for auto fitted collider.
self.scripts = list() # add with add_script(class_instance). will assign an 'entity' variable to the script.
self.animations = list()
self.hovered = False # will return True if mouse hovers entity.
self.origin = Vec3(0,0,0)
self.position = Vec3(0,0,0) # right, up, forward. can also set self.x, self.y, self.z
self.rotation = Vec3(0,0,0) # can also set self.rotation_x, self.rotation_y, self.rotation_z
self.scale = Vec3(1,1,1) # can also set self.scale_x, self.scale_y, self.scale_z
self.line_definition = None # returns a Traceback(filename, lineno, function, code_context, index).
if application.trace_entity_definition and add_to_scene_entities:
from inspect import getframeinfo, stack
_stack = stack()
caller = getframeinfo(_stack[1][0])
if len(_stack) > 2 and _stack[1].code_context and 'super().__init__()' in _stack[1].code_context[0]:
caller = getframeinfo(_stack[2][0])
self.line_definition = caller
if caller.code_context:
self.code_context = caller.code_context[0]
if (self.code_context.count('(') == self.code_context.count(')') and
' = ' in self.code_context and not 'name=' in self.code_context
and not 'Ursina()' in self.code_context):
self.name = self.code_context.split(' = ')[0].strip().replace('self.', '')
# print('set name to:', self.code_context.split(' = ')[0].strip().replace('self.', ''))
if application.print_entity_definition:
print(f'{Path(caller.filename).name} -> {caller.lineno} -> {caller.code_context}')
for key, value in kwargs.items():
setattr(self, key, value)
def _list_to_vec(self, value):
if isinstance(value, (int, float, complex)):
return Vec3(value, value, value)
if len(value) % 2 == 0:
new_value = Vec2()
for i in range(0, len(value), 2):
new_value.add_x(value[i])
new_value.add_y(value[i+1])
if len(value) % 3 == 0:
new_value = Vec3()
for i in range(0, len(value), 3):
new_value.add_x(value[i])
new_value.add_y(value[i+1])
new_value.add_z(value[i+2])
return new_value
def enable(self):
self.enabled = True
def disable(self):
self.enabled = False
def __setattr__(self, name, value):
if name == 'enabled':
try:
# try calling on_enable() on classes inheriting from Entity
if value == True:
self.on_enable()
else:
self.on_disable()
except:
pass
if value == True:
if hasattr(self, 'is_singleton') and not self.is_singleton():
self.unstash()
else:
if hasattr(self, 'is_singleton') and not self.is_singleton():
self.stash()
if name == 'eternal':
for c in self.children:
c.eternal = value
if name == 'world_parent':
self.reparent_to(value)
if name == 'model':
if value is None:
if hasattr(self, 'model') and self.model:
self.model.removeNode()
# print('removed model')
object.__setattr__(self, name, value)
return None
if isinstance(value, NodePath): # pass procedural model
if self.model is not None and value != self.model:
self.model.removeNode()
object.__setattr__(self, name, value)
elif isinstance(value, str): # pass model asset name
m = load_model(value, application.asset_folder)
if not m:
m = load_model(value, application.internal_models_compressed_folder)
if m:
if self.model is not None:
self.model.removeNode()
object.__setattr__(self, name, m)
# if isinstance(m, Mesh):
# m.recipe = value
# print('loaded model successively')
else:
# if '.' in value:
# print(f'''trying to load model with specific filename extention. please omit it. '{value}' -> '{value.split('.')[0]}' ''')
print('missing model:', value)
return
if self.model:
self.model.reparentTo(self)
self.model.setTransparency(TransparencyAttrib.M_dual)
self.color = self.color # reapply color after changing model
self.texture = self.texture # reapply texture after changing model
self._vert_cache = None
if isinstance(value, Mesh):
if hasattr(value, 'on_assign'):
value.on_assign(assigned_to=self)
return
if name == 'color' and value is not None:
if isinstance(value, str):
value = color.hex(value)
if not isinstance(value, Vec4):
value = Vec4(value[0], value[1], value[2], value[3])
if self.model:
self.model.setColorScaleOff() # prevent inheriting color from parent
self.model.setColorScale(value)
object.__setattr__(self, name, value)
if name == 'collision' and hasattr(self, 'collider') and self.collider:
if value:
self.collider.node_path.unstash()
else:
self.collider.node_path.stash()
object.__setattr__(self, name, value)
return
if name == 'render_queue':
if self.model:
self.model.setBin('fixed', value)
if name == 'double_sided':
self.setTwoSided(value)
try:
super().__setattr__(name, value)
except:
pass
# print('failed to set attribiute:', name)
@property
def parent(self):
try:
return self._parent
except:
return None
@parent.setter
def parent(self, value):
self._parent = value
if value is None:
destroy(self)
else:
try:
self.reparentTo(value)
except:
print('invalid parent:', value)
@property
def type(self): # get class name.
return self.__class__.__name__
@property
def types(self): # get all class names including those this inhertits from.
from inspect import getmro
return [c.__name__ for c in getmro(self.__class__)]
@property
def visible(self):
return self._visible
@visible.setter
def visible(self, value):
self._visible = value
if value:
self.show()
else:
self.hide()
@property
def visible_self(self): # set visibility of self, without affecting children.
if not hasattr(self, '_visible_self'):
return True
return self._visible_self
@visible_self.setter
def visible_self(self, value):
self._visible_self = value
if not self.model:
return
if value:
self.model.show()
else:
self.model.hide()
@property
def collider(self):
return self._collider
@collider.setter
def collider(self, value):
# destroy existing collider
if value and hasattr(self, 'collider') and self._collider:
self._collider.remove()
self._collider = value
if value == 'box':
if self.model:
self._collider = BoxCollider(entity=self, center=-self.origin, size=self.model_bounds)
else:
self._collider = BoxCollider(entity=self)
self._collider.name = value
elif value == 'sphere':
self._collider = SphereCollider(entity=self, center=-self.origin)
self._collider.name = value
elif value == 'mesh' and self.model:
self._collider = MeshCollider(entity=self, mesh=None, center=-self.origin)
self._collider.name = value
elif isinstance(value, Mesh):
self._collider = MeshCollider(entity=self, mesh=value, center=-self.origin)
elif isinstance(value, str):
m = load_model(value)
if not m:
return
self._collider = MeshCollider(entity=self, mesh=m, center=-self.origin)
self._collider.name = value
self.collision = bool(self.collider)
return
@property
def origin(self):
return self._origin
@origin.setter
def origin(self, value):
if not self.model:
self._origin = Vec3(0,0,0)
return
if not isinstance(value, (Vec2, Vec3)):
value = self._list_to_vec(value)
if isinstance(value, Vec2):
value = Vec3(*value, self.origin_z)
self._origin = value
self.model.setPos(-value[0], -value[1], -value[2])
@property
def origin_x(self):
return self.origin[0]
@origin_x.setter
def origin_x(self, value):
self.origin = (value, self.origin_y, self.origin_z)
@property
def origin_y(self):
return self.origin[1]
@origin_y.setter
def origin_y(self, value):
self.origin = (self.origin_x, value, self.origin_z)
@property
def origin_z(self):
return self.origin[2]
@origin_z.setter
def origin_z(self, value):
self.origin = (self.origin_x, self.origin_y, value)
@property
def world_position(self):
return Vec3(self.get_position(render))
@world_position.setter
def world_position(self, value):
if not isinstance(value, (Vec2, Vec3)):
value = self._list_to_vec(value)
if isinstance(value, Vec2):
value = Vec3(*value, self.z)
self.setPos(render, Vec3(value[0], value[1], value[2]))
@property
def world_x(self):
return self.getX(render)
@property
def world_y(self):
return self.getY(render)
@property
def world_z(self):
return self.getZ(render)
@world_x.setter
def world_x(self, value):
self.setX(render, value)
@world_y.setter
def world_y(self, value):
self.setY(render, value)
@world_z.setter
def world_z(self, value):
self.setZ(render, value)
@property
def position(self):
return Vec3(*self.getPos())
@position.setter
def position(self, value):
if not isinstance(value, (Vec2, Vec3)):
value = self._list_to_vec(value)
if isinstance(value, Vec2):
value = Vec3(*value, self.z)
self.setPos(value[0], value[1], value[2])
@property
def x(self):
return self.getX()
@x.setter
def x(self, value):
self.setX(value)
@property
def y(self):
return self.getY()
@y.setter
def y(self, value):
self.setY(value)
@property
def z(self):
return self.getZ()
@z.setter
def z(self, value):
self.setZ(value)
@property
def world_rotation(self):
rotation = self.getHpr(base.render)
return Vec3(rotation[1], rotation[0], rotation[2]) * Entity.rotation_directions
@world_rotation.setter
def world_rotation(self, value):
rotation = self.setHpr(Vec3(value[1], value[0], value[2]) * Entity.rotation_directions, base.render)
@property
def world_rotation_x(self):
return self.world_rotation[0]
@world_rotation_x.setter
def world_rotation_x(self, value):
self.world_rotation = Vec3(value, self.world_rotation[1], self.world_rotation[2])
@property
def world_rotation_y(self):
return self.world_rotation[1]
@world_rotation_y.setter
def world_rotation_y(self, value):
self.world_rotation = Vec3(self.world_rotation[0], value, self.world_rotation[2])
@property
def world_rotation_z(self):
return self.world_rotation[2]
@world_rotation_z.setter
def world_rotation_z(self, value):
self.world_rotation = Vec3(self.world_rotation[0], self.world_rotation[1], value)
@property
def rotation(self):
rotation = self.getHpr()
return Vec3(rotation[1], rotation[0], rotation[2]) * Entity.rotation_directions
@rotation.setter
def rotation(self, value):
if not isinstance(value, (Vec2, Vec3)):
value = self._list_to_vec(value)
if isinstance(value, Vec2):
value = Vec3(*value, self.rotation_z)
self.setHpr(Vec3(value[1], value[0], value[2]) * Entity.rotation_directions)
@property
def rotation_x(self):
return self.rotation.x
@rotation_x.setter
def rotation_x(self, value):
self.rotation = Vec3(value, self.rotation[1], self.rotation[2])
@property
def rotation_y(self):
return self.rotation.y
@rotation_y.setter
def rotation_y(self, value):
self.rotation = Vec3(self.rotation[0], value, self.rotation[2])
@property
def rotation_z(self):
return self.rotation.z
@rotation_z.setter
def rotation_z(self, value):
self.rotation = Vec3(self.rotation[0], self.rotation[1], value)
@property
def world_scale(self):
return Vec3(*self.getScale(base.render))
@world_scale.setter
def world_scale(self, value):
if isinstance(value, (int, float, complex)):
value = Vec3(value, value, value)
self.setScale(base.render, value)
@property
def world_scale_x(self):
return self.getScale(base.render)[0]
@world_scale_x.setter
def world_scale_x(self, value):
self.setScale(base.render, Vec3(value, self.world_scale_y, self.world_scale_z))
@property
def world_scale_y(self):
return self.getScale(base.render)[1]
@world_scale_y.setter
def world_scale_y(self, value):
self.setScale(base.render, Vec3(self.world_scale_x, value, self.world_scale_z))
@property
def world_scale_z(self):
return self.getScale(base.render)[2]
@world_scale_z.setter
def world_scale_z(self, value):
self.setScale(base.render, Vec3(self.world_scale_x, value, self.world_scale_z))
@property
def scale(self):
scale = self.getScale()
return Vec3(scale[0], scale[1], scale[2])
@scale.setter
def scale(self, value):
if not isinstance(value, (Vec2, Vec3)):
value = self._list_to_vec(value)
if isinstance(value, Vec2):
value = Vec3(*value, self.scale_z)
value = [e if e!=0 else .001 for e in value]
self.setScale(value[0], value[1], value[2])
@property
def scale_x(self):
return self.scale[0]
@scale_x.setter
def scale_x(self, value):
self.setScale(value, self.scale_y, self.scale_z)
@property
def scale_y(self):
return self.scale[1]
@scale_y.setter
def scale_y(self, value):
self.setScale(self.scale_x, value, self.scale_z)
@property
def scale_z(self):
return self.scale[2]
@scale_z.setter
def scale_z(self, value):
self.setScale(self.scale_x, self.scale_y, value)
@property
def forward(self): # get forward direction.
return render.getRelativeVector(self, (0, 0, 1))
@property
def back(self): # get backwards direction.
return -self.forward
@property
def right(self): # get right direction.
return render.getRelativeVector(self, (1, 0, 0))
@property
def left(self): # get left direction.
return -self.right
@property
def up(self): # get up direction.
return render.getRelativeVector(self, (0, 1, 0))
@property
def down(self): # get down direction.
return -self.up
@property
def screen_position(self): # get screen position(ui space) from world space.
from ursina import camera
p3 = camera.getRelativePoint(self, Vec3.zero())
full = camera.lens.getProjectionMat().xform(Vec4(*p3, 1))
recip_full3 = 1 / full[3]
p2 = Vec3(full[0], full[1], full[2]) * recip_full3
screen_pos = Vec3(p2[0]*camera.aspect_ratio/2, p2[1]/2, 0)
return screen_pos
@property
def shader(self):
return self._shader
@shader.setter
def shader(self, value):
self._shader = value
if value is None:
self.setShaderAuto()
return
if isinstance(value, Panda3dShader): #panda3d shader
self.setShader(value)
return
if isinstance(value, Shader):
if not value.compiled:
value.compile()
self.setShader(value._shader)
value.entity = self
for key, value in value.default_input.items():
self.set_shader_input(key, value)
def set_shader_input(self, name, value):
if isinstance(value, Texture):
value = value._texture # make sure to send the panda3d texture to the shader
super().set_shader_input(name, value)
@property
def texture(self):
if not hasattr(self, '_texture'):
return None
return self._texture
@texture.setter
def texture(self, value):
if value is None and self._texture:
# print('remove texture')
self._texture = None
self.setTextureOff(True)
return
if value.__class__ is Texture:
texture = value
elif isinstance(value, str):
texture = load_texture(value)
# print('loaded texture:', texture)
if texture is None:
print('no texture:', value)
return
if texture.__class__ is MovieTexture:
self._texture = texture
self.model.setTexture(texture, 1)
return
self._texture = texture
if self.model:
self.model.setTexture(texture._texture, 1)
@property
def texture_scale(self):
if not hasattr(self, '_texture_scale'):
return Vec2(1,1)
return self._texture_scale
@texture_scale.setter
def texture_scale(self, value):
self._texture_scale = value
if self.model and self.texture:
self.model.setTexScale(TextureStage.getDefault(), value[0], value[1])
@property
def texture_offset(self):
return self._texture_offset
@texture_offset.setter
def texture_offset(self, value):
if self.model and self.texture:
self.model.setTexOffset(TextureStage.getDefault(), value[0], value[1])
self.texture = self.texture
self._texture_offset = value
@property
def alpha(self):
return self.color[3]
@alpha.setter
def alpha(self, value):
if value > 1:
value = value / 255
self.color = color.color(self.color.h, self.color.s, self.color.v, value)
@property
def always_on_top(self):
return self._always_on_top
@always_on_top.setter
def always_on_top(self, value):
self._always_on_top = value
self.set_bin("fixed", 0)
self.set_depth_write(not value)
self.set_depth_test(not value)
@property
def billboard(self): # set to True to make this Entity always face the camera.
return self._billboard
@billboard.setter
def billboard(self, value):
self._billboard = value
if value:
self.setBillboardPointEye(value)
@property
def reflection_map(self):
return self._reflection_map
@reflection_map.setter
def reflection_map(self, value):
if value.__class__ is Texture:
texture = value
elif isinstance(value, str):
texture = load_texture(value)
self._reflection_map = texture
@property
def reflectivity(self):
return self._reflectivity
@reflectivity.setter
def reflectivity(self, value):
self._reflectivity = value
if value == 0:
self.texture = None
if value > 0:
# if self.reflection_map == None:
# self.reflection_map = scene.reflection_map
#
# if not self.reflection_map:
# print('error setting reflectivity. no reflection map')
# return
if not self.normals:
self.model.generate_normals()
# ts = TextureStage('env')
# ts.setMode(TextureStage.MAdd)
# self.model.setTexGen(ts, TexGenAttrib.MEyeSphereMap)
# print('---------------set reflectivity', self.reflection_map)
# self.model.setTexture(ts, self.reflection_map)
self.texture = self._reflection_map
# print('set reflectivity')
def generate_sphere_map(self, size=512, name=f'sphere_map_{len(scene.entities)}'):
from ursina import camera
_name = 'textures/' + name + '.jpg'
org_pos = camera.position
camera.position = self.position
base.saveSphereMap(_name, size=size)
camera.position = org_pos
print('saved sphere map:', name)
self.model.setTexGen(TextureStage.getDefault(), TexGenAttrib.MEyeSphereMap)
self.reflection_map = name
def generate_cube_map(self, size=512, name=f'cube_map_{len(scene.entities)}'):
from ursina import camera
_name = 'textures/' + name
org_pos = camera.position
camera.position = self.position
base.saveCubeMap(_name+'.jpg', size=size)
camera.position = org_pos
print('saved cube map:', name + '.jpg')
self.model.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldCubeMap)
self.reflection_map = _name + '#.jpg'
self.model.setTexture(loader.loadCubeMap(_name + '#.jpg'), 1)
@property
def model_bounds(self):
if self.model:
bounds = self.model.getTightBounds()
bounds = Vec3(
Vec3(bounds[1][0], bounds[1][1], bounds[1][2]) # max point
- Vec3(bounds[0][0], bounds[0][1], bounds[0][2]) # min point
)
return bounds
return (0,0,0)
@property
def bounds(self):
return Vec3(
self.model_bounds[0] * self.scale_x,
self.model_bounds[1] * self.scale_y,
self.model_bounds[2] * self.scale_z
)
def reparent_to(self, entity):
if entity is not None:
self.wrtReparentTo(entity)
self._parent = entity
def get_position(self, relative_to=scene):
return self.getPos(relative_to)
def set_position(self, value, relative_to=scene):
self.setPos(relative_to, Vec3(value[0], value[1], value[2]))
def add_script(self, class_instance):
if isinstance(class_instance, object) and type(class_instance) is not str:
class_instance.entity = self
class_instance.enabled = True
setattr(self, camel_to_snake(class_instance.__class__.__name__), class_instance)
self.scripts.append(class_instance)
# print('added script:', camel_to_snake(name.__class__.__name__))
return class_instance
def combine(self, analyze=False, auto_destroy=True, ignore=[]):
from ursina.scripts.combine import combine
self.model = combine(self, analyze, auto_destroy, ignore)
return self.model
def flip_faces(self):
if not hasattr(self, '_vertex_order'):
self._vertex_order = True
self._vertex_order = not self._vertex_order
if self._vertex_order:
self.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullClockwise))
else:
self.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise))
def look_at(self, target, axis='forward'):
from panda3d.core import Quat
if not isinstance(target, Entity):
target = Vec3(*target)
self.lookAt(target)
if axis == 'forward':
return
rotation_offset = {
'back' : Quat(0,0,1,0),
'down' : Quat(-.707,.707,0,0),
'up' : Quat(-.707,-.707,0,0),
'right' : Quat(-.707,0,.707,0),
'left' : Quat(-.707,0,-.707,0),
}[axis]
self.setQuat(rotation_offset * self.getQuat())
def look_at_2d(self, target, axis='z'):
from math import degrees, atan2
if isinstance(target, Entity):
target = Vec3(target.world_position)
pos = target - self.world_position
if axis == 'z':
self.rotation_z = degrees(atan2(pos[0], pos[1]))
def has_ancestor(self, possible_ancestor):
p = self
if isinstance(possible_ancestor, Entity):
# print('ENTITY')
for i in range(100):
if p.parent:
if p.parent == possible_ancestor:
return True
p = p.parent
if isinstance(possible_ancestor, list) or isinstance(possible_ancestor, tuple):
# print('LIST OR TUPLE')
for e in possible_ancestor:
for i in range(100):
if p.parent:
if p.parent == e:
return True
break
p = p.parent
elif isinstance(possible_ancestor, str):
print('CLASS NAME', possible_ancestor)
for i in range(100):
if p.parent:
if p.parent.__class__.__name__ == possible_ancestor:
return True
break
p = p.parent
return False
@property
def children(self):
return [e for e in scene.entities if e.parent == self]
@property
def attributes(self): # attribute names. used by duplicate() for instance.
return ('name', 'enabled', 'eternal', 'visible', 'parent',
'origin', 'position', 'rotation', 'scale',
'model', 'color', 'texture', 'texture_scale', 'texture_offset',
# 'world_position', 'world_x', 'world_y', 'world_z',
# 'world_rotation', 'world_rotation_x', 'world_rotation_y', 'world_rotation_z',
# 'world_scale', 'world_scale_x', 'world_scale_y', 'world_scale_z',
# 'x', 'y', 'z',
# 'origin_x', 'origin_y', 'origin_z',
# 'rotation_x', 'rotation_y', 'rotation_z',
# 'scale_x', 'scale_y', 'scale_z',
'render_queue', 'always_on_top', 'collision', 'collider', 'scripts')
#------------
# ANIMATIONS
#------------
def animate(self, name, value, duration=.1, delay=0, curve=curve.in_expo, loop=False, resolution=None, interrupt='kill', time_step=None, auto_destroy=True):
animator_name = name + '_animator'
# print('start animating value:', name, animator_name )
if interrupt and hasattr(self, animator_name):
getattr(getattr(self, animator_name), interrupt)() # call kill() or finish() depending on what the interrupt value is.
# print('interrupt', interrupt, animator_name)
sequence = Sequence(loop=loop, time_step=time_step, auto_destroy=auto_destroy)
setattr(self, animator_name, sequence)
self.animations.append(sequence)
sequence.append(Wait(delay))
if not resolution:
resolution = max(int(duration * 60), 1)
for i in range(resolution+1):
t = i / resolution
t = curve(t)
sequence.append(Wait(duration / resolution))
sequence.append(Func(setattr, self, name, lerp(getattr(self, name), value, t)))
sequence.start()
return sequence
def animate_position(self, value, duration=.1, **kwargs):
x = self.animate('x', value[0], duration, **kwargs)
y = self.animate('y', value[1], duration, **kwargs)
z = None
if len(value) > 2:
z = self.animate('z', value[2], duration, **kwargs)
return x, y, z
def animate_rotation(self, value, duration=.1, **kwargs):
x = self.animate('rotation_x', value[0], duration, **kwargs)
y = self.animate('rotation_y', value[1], duration, **kwargs)
z = self.animate('rotation_z', value[2], duration, **kwargs)
return x, y, z
def animate_scale(self, value, duration=.1, **kwargs):
if isinstance(value, (int, float, complex)):
value = Vec3(value, value, value)
return self.animate('scale', value, duration, **kwargs)
# generate animation functions
for e in ('x', 'y', 'z', 'rotation_x', 'rotation_y', 'rotation_z', 'scale_x', 'scale_y', 'scale_z'):
exec(dedent(f'''
def animate_{e}(self, value, duration=.1, delay=0, **kwargs):
return self.animate('{e}', value, duration=duration, delay=delay, **kwargs)
'''))
def shake(self, duration=.2, magnitude=1, speed=.05, direction=(1,1)):
import random
s = Sequence()
original_position = self.position
for i in range(int(duration / speed)):
s.append(Func(self.set_position,
Vec3(
original_position[0] + (random.uniform(-.1, .1) * magnitude * direction[0]),
original_position[1] + (random.uniform(-.1, .1) * magnitude * direction[1]),
original_position[2],
)))
s.append(Wait(speed))
s.append(Func(self.set_position, original_position))
s.start()
return s
def animate_color(self, value, duration=.1, interrupt='finish', **kwargs):
return self.animate('color', value, duration, interrupt=interrupt, **kwargs)
def fade_out(self, value=0, duration=.5, **kwargs):
return self.animate('color', Vec4(self.color[0], self.color[1], self.color[2], value), duration, **kwargs)
def fade_in(self, value=1, duration=.5, **kwargs):
return self.animate('color', Vec4(self.color[0], self.color[1], self.color[2], value), duration, **kwargs)
def blink(self, value=color.clear, duration=.1, delay=0, curve=curve.in_expo_boomerang, interrupt='finish', **kwargs):
return self.animate_color(value, duration=duration, delay=delay, curve=curve, interrupt=interrupt, **kwargs)
def intersects(self, traverse_target=scene, ignore=(), debug=False):
from ursina.hit_info import HitInfo
if not self.collision or not self.collider:
self.hit = HitInfo(hit=False)
return self.hit
from ursina import distance
if not hasattr(self, '_picker'):
from panda3d.core import CollisionTraverser, CollisionNode, CollisionHandlerQueue
from panda3d.core import CollisionRay, CollisionSegment, CollisionBox
self._picker = CollisionTraverser() # Make a traverser
self._pq = CollisionHandlerQueue() # Make a handler
self._pickerNode = CollisionNode('raycaster')
self._pickerNode.set_into_collide_mask(0)
self._pickerNP = self.attach_new_node(self._pickerNode)
self._picker.addCollider(self._pickerNP, self._pq)
self._pickerNP.show()
self._pickerNode.addSolid(self._collider.shape)
if debug:
self._pickerNP.show()
else:
self._pickerNP.hide()
self._picker.traverse(traverse_target)
if self._pq.get_num_entries() == 0:
self.hit = HitInfo(hit=False)
return self.hit
ignore += (self, )
ignore += tuple([e for e in scene.entities if not e.collision])
self._pq.sort_entries()
self.entries = [ # filter out ignored entities
e for e in self._pq.getEntries()
if e.get_into_node_path().parent not in ignore
]
if len(self.entries) == 0:
self.hit = HitInfo(hit=False, distance=0)
return self.hit
collision = self.entries[0]
nP = collision.get_into_node_path().parent
point = collision.get_surface_point(nP)
point = Vec3(*point)
world_point = collision.get_surface_point(render)
world_point = Vec3(*world_point)
hit_dist = distance(self.world_position, world_point)
self.hit = HitInfo(hit=True)
self.hit.entity = next(e for e in scene.entities if e == nP)
self.hit.point = point
self.hit.world_point = world_point
self.hit.distance = hit_dist
normal = collision.get_surface_normal(collision.get_into_node_path().parent).normalized()
self.hit.normal = Vec3(*normal)
normal = collision.get_surface_normal(render).normalized()
self.hit.world_normal = Vec3(*normal)
self.hit.entities = []
for collision in self.entries:
self.hit.entities.append(next(e for e in scene.entities if e == collision.get_into_node_path().parent))
return self.hit
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 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 Raycaster(Entity):
def __init__(self):
super().__init__(name='raycaster', eternal=True)
self._picker = CollisionTraverser() # Make a traverser
self._pq = CollisionHandlerQueue() # Make a handler
self._pickerNode = CollisionNode('raycaster')
self._pickerNode.set_into_collide_mask(0)
self._pickerNP = self.attach_new_node(self._pickerNode)
self._picker.addCollider(self._pickerNP, self._pq)
self._pickerNP.show()
def distance(self, a, b):
return sqrt(sum((a - b)**2 for a, b in zip(a, b)))
def raycast(self,
origin,
direction=(0, 0, 1),
distance=inf,
traverse_target=scene,
ignore=list(),
debug=False):
self.position = origin
self.look_at(self.position + direction)
self._pickerNode.clearSolids()
# if thickness == (0,0):
if distance == inf:
ray = CollisionRay()
ray.setOrigin(Vec3(0, 0, 0))
# ray.setDirection(Vec3(0,1,0))
ray.setDirection(Vec3(0, 0, 1))
else:
# ray = CollisionSegment(Vec3(0,0,0), Vec3(0,distance,0))
ray = CollisionSegment(Vec3(0, 0, 0), Vec3(0, 0, distance))
self._pickerNode.addSolid(ray)
if debug:
self._pickerNP.show()
else:
self._pickerNP.hide()
self._picker.traverse(traverse_target)
if self._pq.get_num_entries() == 0:
self.hit = HitInfo(hit=False)
return self.hit
ignore += tuple([e for e in scene.entities if not e.collision])
self._pq.sort_entries()
self.entries = [ # filter out ignored entities
e for e in self._pq.getEntries()
if e.get_into_node_path().parent not in ignore
]
if len(self.entries) == 0:
self.hit = HitInfo(hit=False)
return self.hit
self.collision = self.entries[0]
nP = self.collision.get_into_node_path().parent
point = self.collision.get_surface_point(nP)
# point = Vec3(point[0], point[2], point[1])
point = Vec3(point[0], point[1], point[2])
world_point = self.collision.get_surface_point(render)
# world_point = Vec3(world_point[0], world_point[2], world_point[1])
world_point = Vec3(world_point[0], world_point[1], world_point[2])
hit_dist = self.distance(self.world_position, world_point)
if nP.name.endswith('.egg'):
nP = nP.parent
self.hit = HitInfo(hit=True)
for e in scene.entities:
if e == nP:
# print('cast nP to Entity')
self.hit.entity = e
self.hit.point = point
self.hit.world_point = world_point
self.hit.distance = hit_dist
self.hit.normal = Vec3(*self.collision.get_surface_normal(
self.collision.get_into_node_path().parent).normalized())
self.hit.world_normal = Vec3(
*self.collision.get_surface_normal(render).normalized())
return self.hit
self.hit = HitInfo(hit=False)
return self.hit
def boxcast(self,
origin,
direction=(0, 0, 1),
distance=9999,
thickness=(1, 1),
traverse_target=scene,
ignore=list(),
debug=False):
if isinstance(thickness, (int, float, complex)):
thickness = (thickness, thickness)
temp = Entity(position=origin,
model='cube',
origin_z=-.5,
scale=Vec3(abs(thickness[0]), abs(thickness[1]),
abs(distance)),
collider='box',
color=color.white33,
always_on_top=debug,
visible=debug)
temp.look_at(origin + direction)
hit_info = temp.intersects(traverse_target=traverse_target,
ignore=ignore)
if debug:
temp.collision = False
destroy(temp, delay=.1)
else:
destroy(temp)
return hit_info
class Mouse():
def __init__(self):
self.enabled = False
self.locked = False
self.position = Vec3(0, 0, 0)
self.delta = Vec3(0, 0, 0)
self.prev_x = 0
self.prev_y = 0
self.velocity = Vec3(0, 0, 0)
self.prev_click_time = time.time()
self.double_click_distance = .5
self.hovered_entity = None
self.left = False
self.right = False
self.middle = False
self.delta_drag = Vec3(0, 0, 0)
self.i = 0
self.update_rate = 10
self._mouse_watcher = None
self._picker = CollisionTraverser() # Make a traverser
self._pq = CollisionHandlerQueue() # Make a handler
self._pickerNode = CollisionNode('mouseRay')
self._pickerNP = camera.attach_new_node(self._pickerNode)
self._pickerRay = CollisionRay() # Make our ray
self._pickerNode.addSolid(self._pickerRay)
self._picker.addCollider(self._pickerNP, self._pq)
self.raycast = True
self.collision = None
self.enabled = True
@property
def x(self):
if not self._mouse_watcher.has_mouse():
return 0
return self._mouse_watcher.getMouseX(
) / 2 * window.aspect_ratio # same space as ui stuff
@property
def y(self):
if not self._mouse_watcher.has_mouse():
return 0
return self._mouse_watcher.getMouseY() / 2
def __setattr__(self, name, value):
if name == 'visible':
window.set_cursor_hidden(not value)
application.base.win.requestProperties(window)
if name == 'locked':
try:
object.__setattr__(self, name, value)
window.set_cursor_hidden(value)
application.base.win.requestProperties(window)
except:
pass
try:
super().__setattr__(name, value)
# return
except:
pass
def input(self, key):
if not self.enabled:
return
if key.endswith('mouse down'):
self.start_x = self.x
self.start_y = self.y
elif key.endswith('mouse up'):
self.delta_drag = Vec3(self.x - self.start_x,
self.y - self.start_y, 0)
if key == 'left mouse down':
self.left = True
if self.hovered_entity:
if hasattr(self.hovered_entity, 'on_click'):
self.hovered_entity.on_click()
for s in self.hovered_entity.scripts:
if hasattr(s, 'on_click'):
s.on_click()
# double click
if time.time(
) - self.prev_click_time <= self.double_click_distance:
base.input('double click')
if self.hovered_entity:
if hasattr(self.hovered_entity, 'on_double_click'):
self.hovered_entity.on_double_click()
for s in self.hovered_entity.scripts:
if hasattr(s, 'on_double_click'):
s.on_double_click()
self.prev_click_time = time.time()
if key == 'left mouse up':
self.left = False
if key == 'right mouse down':
self.right = True
if key == 'right mouse up':
self.right = False
if key == 'middle mouse down':
self.middle = True
if key == 'middle mouse up':
self.middle = False
def update(self):
if not self.enabled or not self._mouse_watcher.has_mouse():
self.velocity = Vec3(0, 0, 0)
return
self.position = Vec3(self.x, self.y, 0)
self.moving = self.x + self.y != self.prev_x + self.prev_y
if self.moving:
if self.locked:
self.velocity = self.position
application.base.win.move_pointer(0, int(window.size[0] / 2),
int(window.size[1] / 2))
else:
self.velocity = Vec3(self.x - self.prev_x,
(self.y - self.prev_y) /
window.aspect_ratio, 0)
else:
self.velocity = Vec3(0, 0, 0)
if self.left or self.right or self.middle:
self.delta = Vec3(self.x - self.start_x, self.y - self.start_y, 0)
self.prev_x = self.x
self.prev_y = self.y
self.i += 1
if self.i < self.update_rate:
return
# collide with ui
self._pickerNP.reparent_to(scene.ui_camera)
self._pickerRay.set_from_lens(camera._ui_lens_node,
self.x * 2 / window.aspect_ratio,
self.y * 2)
self._picker.traverse(camera.ui)
if self._pq.get_num_entries() > 0:
# print('collided with ui', self._pq.getNumEntries())
self.find_collision()
return
# collide with world
self._pickerNP.reparent_to(camera)
self._pickerRay.set_from_lens(scene.camera.lens_node,
self.x * 2 / window.aspect_ratio,
self.y * 2)
self._picker.traverse(base.render)
if self._pq.get_num_entries() > 0:
# print('collided with world', self._pq.getNumEntries())
self.find_collision()
return
# else:
# print('mouse miss', base.render)
# unhover all if it didn't hit anything
for entity in scene.entities:
if hasattr(entity, 'hovered') and entity.hovered:
entity.hovered = False
self.hovered_entity = None
if hasattr(entity, 'on_mouse_exit'):
entity.on_mouse_exit()
for s in entity.scripts:
if hasattr(s, 'on_mouse_exit'):
s.on_mouse_exit()
@property
def normal(self):
if not self.collision:
return None
if not self.collision.has_surface_normal():
print('no surface normal')
return None
n = self.collision.get_surface_normal(
self.collision.get_into_node_path().parent)
return (n[0], n[2], n[1])
@property
def world_normal(self):
if not self.collision:
return None
if not self.collision.has_surface_normal():
print('no surface normal')
return None
n = self.collision.get_surface_normal(render)
return (n[0], n[2], n[1])
@property
def point(self):
if self.hovered_entity:
p = self.collision.getSurfacePoint(self.hovered_entity)
return Point3(p[0], p[2], p[1])
else:
return None
@property
def world_point(self):
if self.hovered_entity:
p = self.collision.getSurfacePoint(render)
return Point3(p[0], p[2], p[1])
else:
return None
def find_collision(self):
if not self.raycast:
return
self._pq.sortEntries()
if len(self._pq.get_entries()) == 0:
self.collision = None
return
self.collisions = list()
for entry in self._pq.getEntries():
# print(entry.getIntoNodePath().parent)
for entity in scene.entities:
if entry.getIntoNodePath().parent == entity:
if entity.collision:
self.collisions.append(
Hit(
hit=entry.collided(),
entity=entity,
distance=0,
point=entry.getSurfacePoint(entity),
world_point=entry.getSurfacePoint(scene),
normal=entry.getSurfaceNormal(entity),
world_normal=entry.getSurfaceNormal(scene),
))
break
self.collision = self._pq.getEntry(0)
nP = self.collision.getIntoNodePath().parent
for entity in scene.entities:
if not hasattr(entity, 'collision'
) or not entity.collision or not entity.collider:
continue
# if hit entity is not hovered, call on_mouse_enter()
if entity == nP:
if not entity.hovered:
entity.hovered = True
self.hovered_entity = entity
# print(entity.name)
if hasattr(entity, 'on_mouse_enter'):
entity.on_mouse_enter()
for s in entity.scripts:
if hasattr(s, 'on_mouse_enter'):
s.on_mouse_enter()
# unhover the rest
else:
if entity.hovered:
entity.hovered = False
if hasattr(entity, 'on_mouse_exit'):
entity.on_mouse_exit()
for s in entity.scripts:
if hasattr(s, 'on_mouse_exit'):
s.on_mouse_exit()
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 Raycaster(Entity):
def __init__(self):
super().__init__(
name = 'raycaster',
eternal = True
)
self._picker = CollisionTraverser() # Make a traverser
self._pq = CollisionHandlerQueue() # Make a handler
self._pickerNode = CollisionNode('raycaster')
self._pickerNP = self.attach_new_node(self._pickerNode)
self._collision_ray = CollisionRay() # Make our ray
self._pickerNode.addSolid(self._collision_ray)
self._picker.addCollider(self._pickerNP, self._pq)
self._pickerNP.show()
def distance(self, a, b):
return math.sqrt(sum( (a - b)**2 for a, b in zip(a, b)))
def raycast(self, origin, direction=(0,0,1), dist=math.inf, traverse_target=scene, ignore=list(), debug=False):
self.position = origin
self.look_at(self.position + direction)
# need to do this for it to work for some reason
self._collision_ray.set_origin(Vec3(0,0,0))
self._collision_ray.set_direction(Vec3(0,1,0))
if debug:
self._pickerNP.show()
else:
self._pickerNP.hide()
self._picker.traverse(traverse_target)
if self._pq.get_num_entries() == 0:
self.hit = Hit(hit=False)
return self.hit
self._pq.sort_entries()
self.entries = [ # filter out ignored entities
e for e in self._pq.getEntries()
if e.get_into_node_path().parent not in ignore
]
if len(self.entries) == 0:
self.hit = Hit(hit=False)
return self.hit
self.collision = self.entries[0]
nP = self.collision.get_into_node_path().parent
point = self.collision.get_surface_point(nP)
point = Vec3(point[0], point[2], point[1])
world_point = self.collision.get_surface_point(render)
world_point = Vec3(world_point[0], world_point[2], world_point[1])
hit_dist = self.distance(self.world_position, world_point)
if hit_dist <= dist:
if nP.name.endswith('.egg'):
nP = nP.parent
self.hit = Hit(hit=True)
for e in scene.entities:
if e == nP:
# print('cast nP to Entity')
self.hit.entity = e
self.hit.point = point
self.hit.world_point = world_point
self.hit.distance = hit_dist
normal = self.collision.get_surface_normal(self.collision.get_into_node_path().parent)
self.hit.normal = (normal[0], normal[2], normal[1])
normal = self.collision.get_surface_normal(render)
self.hit.world_normal = (normal[0], normal[2], normal[1])
return self.hit
self.hit = Hit(hit=False)
return self.hit
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()
