Fix orbiting camera mode along minor fixes

Author: arda-guler

atmospheric_drag.py

@@ -42,8 +42,8 @@ def update_mass(self, maneuvers, sim_time, dt):
                 if m.type == "const_thrust" and m.t_start <= sim_time <= m.t_start + m.duration:
                     self.mass = m.mass
                 # maneuver finish update
-                elif m.type == "const_thrust" and m.t_start + m.duration >= sim_time and m.t_start + m.duration <= sim_time + dt:
-                    self.mass = m.mass_init - mass_flow * duration
+                elif m.type == "const_thrust" and sim_time <= m.t_start + m.duration <= sim_time + dt:
+                    self.mass = m.mass_init - m.mass_flow * m.duration
 
             # in case of a const-accel maneuver the user will have to update manaully
             # if siginificant propellant mass was spent

barycenter_class.py

@@ -72,7 +72,7 @@ def get_vel(self):
         return [sum_x/self.get_mass(), sum_y/self.get_mass(), sum_z/self.get_mass()]
 
     def get_vel_mag(self):
-        return mag(self.vel)
+        return self.vel.mag()
 
     def get_draw_pos(self):
         return self.get_pos() * visual_scaling_factor

body_class.py

@@ -79,7 +79,7 @@ def get_vel_rel_to(self, obj):
         return self.vel - obj.vel
 
     def get_vel_mag(self):
-        return mag(self.vel)
+        return self.vel.mag()
 
     def get_vel_mag_rel_to(self, obj):
         return (self.vel - obj.vel).mag()

camera_class.py

@@ -11,7 +11,7 @@ def __init__(self, name, pos, orient, active, lock=None):
         self.orient = orient
         self.active = active
         self.lock = lock
-        self.offset = vec3()
+        self.offset_amount = 100
 
     def get_name(self):
         return self.name
@@ -25,20 +25,20 @@ def set_pos(self, new_pos):
         self.pos = new_pos
 
     def move(self, movement):
-        
-        glTranslate((movement.x * self.orient.m11) + (movement.y * self.orient.m21) + (movement.z * self.orient.m31),
-                    (movement.x * self.orient.m12) + (movement.y * self.orient.m22) + (movement.z * self.orient.m32),
-                    (movement.x * self.orient.m13) + (movement.y * self.orient.m23) + (movement.z * self.orient.m33))
-        
         if not self.lock:
+            glTranslate((movement.x * self.orient.m11) + (movement.y * self.orient.m21) + (movement.z * self.orient.m31),
+                        (movement.x * self.orient.m12) + (movement.y * self.orient.m22) + (movement.z * self.orient.m32),
+                        (movement.x * self.orient.m13) + (movement.y * self.orient.m23) + (movement.z * self.orient.m33))
+
             self.pos = vec3(lst=[self.pos.x + (movement.x * self.orient.m11) + (movement.y * self.orient.m21) + (movement.z * self.orient.m31),
                                  self.pos.y + (movement.x * self.orient.m12) + (movement.y * self.orient.m22) + (movement.z * self.orient.m32),
                                  self.pos.z + (movement.x * self.orient.m13) + (movement.y * self.orient.m23) + (movement.z * self.orient.m33)])
 
         else:
-            self.offset = vec3(lst=[self.offset.x + (movement.x * self.orient.m11) + (movement.y * self.orient.m21) + (movement.z * self.orient.m31),
-                                    self.offset.y + (movement.x * self.orient.m12) + (movement.y * self.orient.m22) + (movement.z * self.orient.m32),
-                                    self.offset.z + (movement.x * self.orient.m13) + (movement.y * self.orient.m23) + (movement.z * self.orient.m33)])
+            # this handles zooming in and out
+            self.offset_amount += movement.z
+            if self.offset_amount <= 0:
+                self.offset_amount -= movement.z
 
     def get_orient(self):
         return self.orient
@@ -56,10 +56,7 @@ def get_lock(self):
         return self.lock
 
     def rotate(self, rotation):
-        if not self.lock:
-            about_pos = self.pos
-        else:
-            about_pos = self.pos - self.offset
+        about_pos = self.pos
 
         glTranslate(-about_pos.x, -about_pos.y, -about_pos.z)
         glRotate(-rotation[0], self.orient.m11, self.orient.m12, self.orient.m13)
@@ -78,15 +75,15 @@ def rotate(self, rotation):
     def lock_to_target(self, target):
         self.lock = target
         if type(target).__name__ == "body":
-            offset_amount = target.get_radius() * 2 * visual_scaling_factor
-            self.offset = self.orient.vz() * -offset_amount
+            self.offset_amount = target.get_radius() * 3 * visual_scaling_factor
         else:
-            self.offset = vec3(0,0,-100)
+            self.offset_amount = 100
+
+        self.set_pos(-self.lock.get_draw_pos() - self.orient.vz() * self.offset_amount)
 
     def unlock(self):
         self.lock = None
-        self.offset = vec3()
 
     def move_with_lock(self):
         if self.lock:
-            self.set_pos(self.lock.get_pos() - self.offset * visual_scaling_factor)
+            self.set_pos(-self.lock.get_draw_pos() - self.orient.vz() * self.offset_amount)

graphics.py

@@ -314,7 +314,6 @@ def drawVesselLabels(vs, cam, offset=0.05):
 def drawProjectionLabels(ps, cam, offset=0.05, size=0.05):
 
     for p in ps:
-        center = p.body.get_draw_pos()
         pe_adjusted = p.draw_pe + p.get_body().get_draw_pos()
         ap_adjusted = p.draw_ap + p.get_body().get_draw_pos()
         an_adjusted = p.draw_an + p.get_body().get_draw_pos()
@@ -369,22 +368,20 @@ def drawScene(bodies, vessels, surface_points, barycenters, projections, maneuve
     drawSurfacePoints(surface_points, active_cam)
     drawVessels(vessels, active_cam, draw_mode)
 
-    if not active_cam.get_lock() and labels_visible:
+    if labels_visible:
         glEnable(GL_LINE_SMOOTH)
         drawBarycenterLabels(barycenters, active_cam)
         drawBodyLabels(bodies, active_cam)
         drawSurfacePointLabels(surface_points, active_cam)
         drawVesselLabels(vessels, active_cam)
         glDisable(GL_LINE_SMOOTH)
 
+    drawProjections(projections)
+    if labels_visible:
+        drawProjectionLabels(projections, active_cam)
     # draw trajectory and predictions
     if show_trajectories:
-        
-        drawProjections(projections)
         glEnable(GL_LINE_SMOOTH)
-        if not active_cam.get_lock() and labels_visible:
-            drawProjectionLabels(projections, active_cam)
-            
         drawTrajectories(vessels, scene_lock)
         drawManeuvers(maneuvers, point_size, active_cam)
         glDisable(GL_LINE_SMOOTH)

radiation_pressure.py

@@ -91,7 +91,7 @@ def update_mass(self, maneuvers, sim_time, dt):
                     self.mass = m.mass
                 # maneuver finish update
                 elif m.type == "const_thrust" and sim_time <= m.t_start + m.duration <= sim_time + dt:
-                    self.mass = m.mass_init - mass_flow * duration
+                    self.mass = m.mass_init - m.mass_flow * m.duration
 
             # in case of a const-accel maneuver the user will have to update manaully
             # if siginificant propellant mass was spent

solver.py

@@ -133,7 +133,7 @@ def VelocityVerlet(bodies, vessels, surface_points, maneuvers, atmospheric_drags
 
     # calculate vessel accelerations due to atmospheric drag
     for ad in atmospheric_drags:
-        if ad.vessels in vessels:
+        if ad.vessel in vessels:
             v_idx = vessels.index(ad.vessel)
             accel_vec = ad.calc_accel()
             vessel_accels_2[v_idx] = vessel_accels_2[v_idx] + accel_vec