def calc_look_at(self, target, rel=True, position=None):
if not rel:
if position is None:
position = self.get_camera_pos()
direction = LVector3d(target - position)
else:
direction = LVector3d(target)
direction.normalize()
local_direction = self.get_camera_rot().conjugate().xform(direction)
angle = LVector3d.forward().angleRad(local_direction)
axis = LVector3d.forward().cross(local_direction)
if axis.length() > 0.0:
new_rot = utils.relative_rotation(self.get_camera_rot(), axis,
angle)
# new_rot=LQuaterniond()
# lookAt(new_rot, direction, LVector3d.up())
else:
new_rot = self.get_camera_rot()
return new_rot, angle
def get_normals_under(self, position):
if self.surface is not None:
(x, y, distance) = self.spherical_to_longlat(self.cartesian_to_spherical(position))
vectors = self.surface.get_normals_at(x, y)
else:
vectors = (LVector3d.up(), LVector3d.forward(), LVector3d.left())
sync_frame = SynchroneReferenceFrame(self)
return (sync_frame.get_orientation().xform(vectors[0]),
sync_frame.get_orientation().xform(vectors[1]),
sync_frame.get_orientation().xform(vectors[2]))
def update(self, dt):
if self.keyMap['up']:
self.step(self.speed * self.speed_factor * dt)
if self.keyMap['down']:
self.step(-self.speed * self.speed_factor * dt)
if self.keyMap['left']:
self.turn(LVector3d.up(), self.rot_step_per_sec * dt)
if self.keyMap['right']:
self.turn(LVector3d.up(), -self.rot_step_per_sec * dt)
if self.keyMap['shift-up']:
self.turn(LVector3d.right(), self.rot_step_per_sec * dt)
if self.keyMap['shift-down']:
self.turn(LVector3d.right(), -self.rot_step_per_sec * dt)
if self.keyMap['shift-left']:
self.turn(LVector3d.up(), self.rot_step_per_sec * dt)
if self.keyMap['shift-right']:
self.turn(LVector3d.up(), -self.rot_step_per_sec * dt)
if self.keyMap['control-left']:
self.turn(LVector3d.forward(), self.rot_step_per_sec * dt)
if self.keyMap['control-right']:
self.turn(LVector3d.forward(), -self.rot_step_per_sec * dt)
if self.keyMap['home']:
self.change_altitude(self.distance_speed * dt)
if self.keyMap['end']:
self.change_altitude(-self.distance_speed * dt)
if self.wheel_event_time + self.wheel_event_duration > globalClock.getRealTime(
):
distance = self.wheel_direction
self.change_altitude(distance * self.distance_speed * dt)
def __init__(self, cam, lens):
CameraBase.__init__(self, cam, lens)
#Global position of the camera, i.e. the center of the current system
self.camera_global_pos = LPoint3d()
#Local position of the camera within the system in the current camera reference frame
#Initialize not at zero to avoid null vector when starting to move
self.camera_pos = LPoint3d(0, -1, 0)
#Camera orientation in the current camera reference frame
self.camera_rot = LQuaterniond()
#Camera reference frame
self.camera_frame = AbsoluteReferenceFrame()
#Direction of sight of the camera
self.camera_vector = LVector3d.forward()
def update_instance(self, camera_pos, camera_rot):
position = self.parent.project(0, self.context.observer.camera_global_pos, self.context.observer.infinity)
if position != None:
self.instance.setPos(*position)
scale = abs(self.context.observer.pixel_size * self.parent.get_label_size() * self.context.observer.infinity)
else:
scale = 0.0
if scale < 1e-7:
print("Label too far", self.get_name())
scale = 1e-7
self.instance.setScale(scale)
self.look_at.set_pos(LVector3(*(camera_rot.xform(LVector3d.forward()))))
self.label_instance.look_at(self.look_at, LVector3(), LVector3(*(camera_rot.xform(LVector3d.up()))))
def update(self, dt):
if self.keyMap['up']:
self.step(self.speed * self.speed_factor * dt)
if self.keyMap['down']:
self.step(-self.speed * self.speed_factor * dt)
if self.keyMap['left']:
self.turn(LVector3d.up(), self.rot_step_per_sec * dt)
if self.keyMap['right']:
self.turn(LVector3d.up(), -self.rot_step_per_sec * dt)
if self.keyMap['shift-up']:
self.turn(LVector3d.right(), self.rot_step_per_sec * dt)
if self.keyMap['shift-down']:
self.turn(LVector3d.right(), -self.rot_step_per_sec * dt)
if self.keyMap['shift-left']:
self.turn(LVector3d.up(), self.rot_step_per_sec * dt)
if self.keyMap['shift-right']:
self.turn(LVector3d.up(), -self.rot_step_per_sec * dt)
if self.keyMap['control-left']:
self.turn(LVector3d.forward(), self.rot_step_per_sec * dt)
if self.keyMap['control-right']:
self.turn(LVector3d.forward(), -self.rot_step_per_sec * dt)
if self.keyMap['home']:
self.onChangeAltitude(0.1)
if self.keyMap['end']:
self.onChangeAltitude(-0.1)
def update_instance(self, camera_pos, camera_rot):
body = self.parent
if body.is_emissive() and (not body.resolved or body.background):
if body.scene_position != None:
self.instance.setPos(*body.scene_position)
scale = abs(self.context.observer.pixel_size * body.get_label_size() * body.scene_distance)
else:
scale = 0.0
else:
offset = body.get_apparent_radius() * 1.01
rel_front_pos = body.rel_position - camera_rot.xform(LPoint3d(0, offset, 0))
vector_to_obs = LVector3d(-rel_front_pos)
distance_to_obs = vector_to_obs.length()
vector_to_obs /= distance_to_obs
position, distance, scale_factor = self.calc_scene_params(rel_front_pos, rel_front_pos, distance_to_obs, vector_to_obs)
self.instance.setPos(*position)
scale = abs(self.context.observer.pixel_size * body.get_label_size() * distance)
self.look_at.set_pos(LVector3(*(camera_rot.xform(LVector3d.forward()))))
self.label_instance.look_at(self.look_at, LVector3(), LVector3(*(camera_rot.xform(LVector3d.up()))))
self.instance.set_color_scale(LColor(self.fade, self.fade, self.fade, 1.0))
if scale < 1e-7:
print("Label too far", self.get_name())
scale = 1e-7
self.instance.setScale(scale)
def get_camera_vector(self):
return self.get_camera_rot().xform(LVector3d.forward())
def update(self, dt):
rot_x = 0.0
rot_y = 0.0
rot_z = 0.0
distance = 0.0
if self.mouseTrackClick and self.base.mouseWatcherNode.hasMouse():
mpos = self.base.mouseWatcherNode.getMouse()
deltaX = mpos.getX() - self.startX
deltaY = mpos.getY() - self.startY
z_angle = -deltaX * self.dragAngleX
x_angle = deltaY * self.dragAngleY
self.do_drag(z_angle, x_angle, True)
if self.mouseSelectClick and self.base.mouseWatcherNode.hasMouse():
mpos = self.base.mouseWatcherNode.getMouse()
deltaX = mpos.getX() - self.startX
deltaY = mpos.getY() - self.startY
z_angle = deltaX * self.observer.realCamLens.getHfov(
) / 180 * pi / 2
x_angle = -deltaY * self.observer.realCamLens.getVfov(
) / 180 * pi / 2
self.do_drag(z_angle, x_angle)
if settings.celestia_nav:
if self.keyMap['up']:
rot_x = -1
if self.keyMap['down']:
rot_x = 1
else:
if self.keyMap['up']:
rot_x = 1
if self.keyMap['down']:
rot_x = -1
if self.keyMap['left']:
rot_y = 1
if self.keyMap['right']:
rot_y = -1
if self.keyMap['control-left']:
rot_z = 1
if self.keyMap['control-right']:
rot_z = -1
if self.keyMap['home']:
distance = 1
if self.keyMap['end']:
distance = -1
if self.wheel_event_time + self.wheel_event_duration > globalClock.getRealTime(
):
distance = self.wheel_direction
if not self.keyboardTrack and (self.keyMap['shift-left']
or self.keyMap['shift-right']
or self.keyMap['shift-up']
or self.keyMap['shift-down']):
target = self.select_target()
if target is not None:
self.keyboardTrack = True
arc_length = pi * target.get_apparent_radius()
apparent_size = arc_length / (target.distance_to_obs -
target.height_under)
if apparent_size != 0:
self.drag_coef = min(pi, pi / 2 / apparent_size)
else:
self.drag_coef = pi
self.drag_x = 0.0
self.drag_z = 0.0
self.create_drag_params(target)
if self.keyboardTrack:
if not (self.keyMap['shift-left'] or self.keyMap['shift-right']
or self.keyMap['shift-up'] or self.keyMap['shift-down']):
self.keyboardTrack = False
if self.keyMap['shift-left']:
self.drag_z += self.drag_coef * dt
self.do_drag(self.drag_z, self.drag_x, True)
if self.keyMap['shift-right']:
self.drag_z -= self.drag_coef * dt
self.do_drag(self.drag_z, self.drag_x, True)
if self.keyMap['shift-up']:
self.drag_x += self.drag_coef * dt
self.do_drag(self.drag_z, self.drag_x, True)
if self.keyMap['shift-down']:
self.drag_x -= self.drag_coef * dt
self.do_drag(self.drag_z, self.drag_x, True)
if self.keyMap['a']:
if self.speed == 0:
self.speed = 0.1
else:
self.speed *= exp(dt * 3)
if self.keyMap['z']:
if self.speed < 1e-5:
self.speed = 0
else:
self.speed /= exp(dt * 3)
y = self.speed * dt
self.stepRelative(0, y, 0)
if settings.damped_nav:
#TODO: Refactor this wall of code...
if rot_x > 0:
self.current_rot_x_speed += self.incr_speed_rot_step_per_sec * dt
self.current_rot_x_speed = min(self.current_rot_x_speed,
self.rot_step_per_sec)
elif rot_x < 0:
self.current_rot_x_speed -= self.incr_speed_rot_step_per_sec * dt
self.current_rot_x_speed = max(self.current_rot_x_speed,
-self.rot_step_per_sec)
elif self.current_rot_x_speed > 0.0:
self.current_rot_x_speed -= self.decr_speed_rot_step_per_sec * dt
self.current_rot_x_speed = max(0.0, self.current_rot_x_speed)
elif self.current_rot_x_speed < 0.0:
self.current_rot_x_speed += self.decr_speed_rot_step_per_sec * dt
self.current_rot_x_speed = min(0.0, self.current_rot_x_speed)
if rot_y > 0:
self.current_rot_y_speed += self.incr_speed_rot_step_per_sec * dt
self.current_rot_y_speed = min(self.current_rot_y_speed,
self.rot_step_per_sec)
elif rot_y < 0:
self.current_rot_y_speed -= self.incr_speed_rot_step_per_sec * dt
self.current_rot_y_speed = max(self.current_rot_y_speed,
-self.rot_step_per_sec)
elif self.current_rot_y_speed > 0.0:
self.current_rot_y_speed -= self.decr_speed_rot_step_per_sec * dt
self.current_rot_y_speed = max(0.0, self.current_rot_y_speed)
elif self.current_rot_y_speed < 0.0:
self.current_rot_y_speed += self.decr_speed_rot_step_per_sec * dt
self.current_rot_y_speed = min(0.0, self.current_rot_y_speed)
if rot_z > 0:
self.current_rot_z_speed += self.incr_speed_rot_step_per_sec * dt
self.current_rot_z_speed = min(self.current_rot_z_speed,
self.rot_step_per_sec)
elif rot_z < 0:
self.current_rot_z_speed -= self.incr_speed_rot_step_per_sec * dt
self.current_rot_z_speed = max(self.current_rot_z_speed,
-self.rot_step_per_sec)
elif self.current_rot_z_speed > 0.0:
self.current_rot_z_speed -= self.decr_speed_rot_step_per_sec * dt
self.current_rot_z_speed = max(0.0, self.current_rot_z_speed)
elif self.current_rot_z_speed < 0.0:
self.current_rot_z_speed += self.decr_speed_rot_step_per_sec * dt
self.current_rot_z_speed = min(0.0, self.current_rot_z_speed)
else:
self.current_rot_x_speed = rot_x * self.rot_step_per_sec
self.current_rot_y_speed = rot_y * self.rot_step_per_sec
self.current_rot_z_speed = rot_z * self.rot_step_per_sec
self.turn(LVector3d.right(), self.current_rot_x_speed * dt)
self.turn(LVector3d.forward(), self.current_rot_y_speed * dt)
self.turn(LVector3d.up(), self.current_rot_z_speed * dt)
self.change_altitude(distance * self.distance_speed * dt)
def get_normals_at(self, coord):
vectors = (LVector3d.up(), LVector3d.forward(), LVector3d.left())
return vectors
def step_relative(self, distance):
rotation = self.body._frame_rotation
direction = rotation.xform(LVector3d.forward())
self.step(direction, distance)
def step_relative(self, distance):
rotation = self.body.rotation.get_frame_rotation_at(
0) #TODO: retrieve simulation time
direction = rotation.xform(LVector3d.forward())
self.step(direction, distance)
def get_normals_under_xy(self, x, y):
if self.surface is not None:
vectors = self.surface.get_normals_at(x, y)
else:
vectors = (LVector3d.up(), LVector3d.forward(), LVector3d.left())
return vectors
