fixed #67

code/beginner/tutorial6-uniforms/src/challenge.rs

@@ -182,22 +182,33 @@ impl CameraController {
 
     fn update_camera(&self, camera: &mut Camera) {
         use cgmath::InnerSpace;
-        let forward = (camera.target - camera.eye).normalize();
-
-        if self.is_forward_pressed {
-            camera.eye += forward * self.speed;
+        let forward = camera.target - camera.eye;
+        let forward_norm = forward.normalize();
+        let forward_mag = forward.magnitude();
+
+        // Prevents glitching when camera gets too close to the
+        // center of the scene.
+        if self.is_forward_pressed && forward_mag > self.speed {
+            camera.eye += forward_norm * self.speed;
         }
         if self.is_backward_pressed {
-            camera.eye -= forward * self.speed;
+            camera.eye -= forward_norm * self.speed;
         }
 
-        let right = forward.cross(camera.up);
+        let right = forward_norm.cross(camera.up);
+
+        // Redo radius calc in case the up/ down is pressed.
+        let forward = camera.target - camera.eye;
+        let forward_mag = forward.magnitude();
 
         if self.is_right_pressed {
-            camera.eye += right * self.speed;
+            // Rescale the distance between the target and eye so 
+            // that it doesn't change. The eye therefore still 
+            // lies on the circle made by the target and eye.
+            camera.eye = camera.target - (forward + right * self.speed).normalize() * forward_mag;
         }
         if self.is_left_pressed {
-            camera.eye -= right * self.speed;
+            camera.eye = camera.target - (forward - right * self.speed).normalize() * forward_mag;
         }
     }
 }

code/beginner/tutorial6-uniforms/src/main.rs

@@ -168,22 +168,33 @@ impl CameraController {
 
     fn update_camera(&self, camera: &mut Camera) {
         use cgmath::InnerSpace;
-        let forward = (camera.target - camera.eye).normalize();
-
-        if self.is_forward_pressed {
-            camera.eye += forward * self.speed;
+        let forward = camera.target - camera.eye;
+        let forward_norm = forward.normalize();
+        let forward_mag = forward.magnitude();
+
+        // Prevents glitching when camera gets too close to the
+        // center of the scene.
+        if self.is_forward_pressed && forward_mag > self.speed {
+            camera.eye += forward_norm * self.speed;
         }
         if self.is_backward_pressed {
-            camera.eye -= forward * self.speed;
+            camera.eye -= forward_norm * self.speed;
         }
 
-        let right = forward.cross(camera.up);
+        let right = forward_norm.cross(camera.up);
+
+        // Redo radius calc in case the up/ down is pressed.
+        let forward = camera.target - camera.eye;
+        let forward_mag = forward.magnitude();
 
         if self.is_right_pressed {
-            camera.eye += right * self.speed;
+            // Rescale the distance between the target and eye so 
+            // that it doesn't change. The eye therefore still 
+            // lies on the circle made by the target and eye.
+            camera.eye = camera.target - (forward + right * self.speed).normalize() * forward_mag;
         }
         if self.is_left_pressed {
-            camera.eye -= right * self.speed;
+            camera.eye = camera.target - (forward - right * self.speed).normalize() * forward_mag;
         }
     }
 }

code/beginner/tutorial7-instancing/src/challenge.rs

@@ -171,22 +171,33 @@ impl CameraController {
     }
 
     fn update_camera(&self, camera: &mut Camera) {
-        let forward = (camera.target - camera.eye).normalize();
-
-        if self.is_forward_pressed {
-            camera.eye += forward * self.speed;
+        let forward = camera.target - camera.eye;
+        let forward_norm = forward.normalize();
+        let forward_mag = forward.magnitude();
+
+        // Prevents glitching when camera gets too close to the
+        // center of the scene.
+        if self.is_forward_pressed && forward_mag > self.speed {
+            camera.eye += forward_norm * self.speed;
         }
         if self.is_backward_pressed {
-            camera.eye -= forward * self.speed;
+            camera.eye -= forward_norm * self.speed;
         }
 
-        let right = forward.cross(camera.up);
+        let right = forward_norm.cross(camera.up);
+
+        // Redo radius calc in case the up/ down is pressed.
+        let forward = camera.target - camera.eye;
+        let forward_mag = forward.magnitude();
 
         if self.is_right_pressed {
-            camera.eye += right * self.speed;
+            // Rescale the distance between the target and eye so 
+            // that it doesn't change. The eye therefore still 
+            // lies on the circle made by the target and eye.
+            camera.eye = camera.target - (forward + right * self.speed).normalize() * forward_mag;
         }
         if self.is_left_pressed {
-            camera.eye -= right * self.speed;
+            camera.eye = camera.target - (forward - right * self.speed).normalize() * forward_mag;
         }
     }
 }

code/beginner/tutorial7-instancing/src/main.rs

@@ -174,23 +174,35 @@ impl CameraController {
         }
     }
 
+    
     fn update_camera(&self, camera: &mut Camera) {
-        let forward = (camera.target - camera.eye).normalize();
-
-        if self.is_forward_pressed {
-            camera.eye += forward * self.speed;
+        let forward = camera.target - camera.eye;
+        let forward_norm = forward.normalize();
+        let forward_mag = forward.magnitude();
+
+        // Prevents glitching when camera gets too close to the
+        // center of the scene.
+        if self.is_forward_pressed && forward_mag > self.speed {
+            camera.eye += forward_norm * self.speed;
         }
         if self.is_backward_pressed {
-            camera.eye -= forward * self.speed;
+            camera.eye -= forward_norm * self.speed;
         }
 
-        let right = forward.cross(camera.up);
+        let right = forward_norm.cross(camera.up);
+
+        // Redo radius calc in case the up/ down is pressed.
+        let forward = camera.target - camera.eye;
+        let forward_mag = forward.magnitude();
 
         if self.is_right_pressed {
-            camera.eye += right * self.speed;
+            // Rescale the distance between the target and eye so 
+            // that it doesn't change. The eye therefore still 
+            // lies on the circle made by the target and eye.
+            camera.eye = camera.target - (forward + right * self.speed).normalize() * forward_mag;
         }
         if self.is_left_pressed {
-            camera.eye -= right * self.speed;
+            camera.eye = camera.target - (forward - right * self.speed).normalize() * forward_mag;
         }
     }
 }

code/beginner/tutorial8-depth/src/challenge.rs

@@ -185,22 +185,33 @@ impl CameraController {
     }
 
     fn update_camera(&self, camera: &mut Camera) {
-        let forward = (camera.target - camera.eye).normalize();
-
-        if self.is_forward_pressed {
-            camera.eye += forward * self.speed;
+        let forward = camera.target - camera.eye;
+        let forward_norm = forward.normalize();
+        let forward_mag = forward.magnitude();
+
+        // Prevents glitching when camera gets too close to the
+        // center of the scene.
+        if self.is_forward_pressed && forward_mag > self.speed {
+            camera.eye += forward_norm * self.speed;
         }
         if self.is_backward_pressed {
-            camera.eye -= forward * self.speed;
+            camera.eye -= forward_norm * self.speed;
         }
 
-        let right = forward.cross(camera.up);
+        let right = forward_norm.cross(camera.up);
+
+        // Redo radius calc in case the up/ down is pressed.
+        let forward = camera.target - camera.eye;
+        let forward_mag = forward.magnitude();
 
         if self.is_right_pressed {
-            camera.eye += right * self.speed;
+            // Rescale the distance between the target and eye so 
+            // that it doesn't change. The eye therefore still 
+            // lies on the circle made by the target and eye.
+            camera.eye = camera.target - (forward + right * self.speed).normalize() * forward_mag;
         }
         if self.is_left_pressed {
-            camera.eye -= right * self.speed;
+            camera.eye = camera.target - (forward - right * self.speed).normalize() * forward_mag;
         }
     }
 }

code/beginner/tutorial8-depth/src/main.rs

@@ -173,22 +173,33 @@ impl CameraController {
     }
 
     fn update_camera(&self, camera: &mut Camera) {
-        let forward = (camera.target - camera.eye).normalize();
-
-        if self.is_forward_pressed {
-            camera.eye += forward * self.speed;
+        let forward = camera.target - camera.eye;
+        let forward_norm = forward.normalize();
+        let forward_mag = forward.magnitude();
+
+        // Prevents glitching when camera gets too close to the
+        // center of the scene.
+        if self.is_forward_pressed && forward_mag > self.speed {
+            camera.eye += forward_norm * self.speed;
         }
         if self.is_backward_pressed {
-            camera.eye -= forward * self.speed;
+            camera.eye -= forward_norm * self.speed;
         }
 
-        let right = forward.cross(camera.up);
+        let right = forward_norm.cross(camera.up);
+
+        // Redo radius calc in case the up/ down is pressed.
+        let forward = camera.target - camera.eye;
+        let forward_mag = forward.magnitude();
 
         if self.is_right_pressed {
-            camera.eye += right * self.speed;
+            // Rescale the distance between the target and eye so 
+            // that it doesn't change. The eye therefore still 
+            // lies on the circle made by the target and eye.
+            camera.eye = camera.target - (forward + right * self.speed).normalize() * forward_mag;
         }
         if self.is_left_pressed {
-            camera.eye -= right * self.speed;
+            camera.eye = camera.target - (forward - right * self.speed).normalize() * forward_mag;
         }
     }
 }

code/beginner/tutorial9-models/src/main.rs

@@ -125,22 +125,33 @@ impl CameraController {
     }
 
     fn update_camera(&self, camera: &mut Camera) {
-        let forward = (camera.target - camera.eye).normalize();
-
-        if self.is_forward_pressed {
-            camera.eye += forward * self.speed;
+        let forward = camera.target - camera.eye;
+        let forward_norm = forward.normalize();
+        let forward_mag = forward.magnitude();
+
+        // Prevents glitching when camera gets too close to the
+        // center of the scene.
+        if self.is_forward_pressed && forward_mag > self.speed {
+            camera.eye += forward_norm * self.speed;
         }
         if self.is_backward_pressed {
-            camera.eye -= forward * self.speed;
+            camera.eye -= forward_norm * self.speed;
         }
 
-        let right = forward.cross(camera.up);
+        let right = forward_norm.cross(camera.up);
+
+        // Redo radius calc in case the up/ down is pressed.
+        let forward = camera.target - camera.eye;
+        let forward_mag = forward.magnitude();
 
         if self.is_right_pressed {
-            camera.eye += right * self.speed;
+            // Rescale the distance between the target and eye so 
+            // that it doesn't change. The eye therefore still 
+            // lies on the circle made by the target and eye.
+            camera.eye = camera.target - (forward + right * self.speed).normalize() * forward_mag;
         }
         if self.is_left_pressed {
-            camera.eye -= right * self.speed;
+            camera.eye = camera.target - (forward - right * self.speed).normalize() * forward_mag;
         }
     }
 }

code/intermediate/tutorial10-lighting/src/main.rs

@@ -133,22 +133,33 @@ impl CameraController {
     }
 
     fn update_camera(&self, camera: &mut Camera) {
-        let forward = (camera.target - camera.eye).normalize();
-
-        if self.is_forward_pressed {
-            camera.eye += forward * self.speed;
+        let forward = camera.target - camera.eye;
+        let forward_norm = forward.normalize();
+        let forward_mag = forward.magnitude();
+
+        // Prevents glitching when camera gets too close to the
+        // center of the scene.
+        if self.is_forward_pressed && forward_mag > self.speed {
+            camera.eye += forward_norm * self.speed;
         }
         if self.is_backward_pressed {
-            camera.eye -= forward * self.speed;
+            camera.eye -= forward_norm * self.speed;
         }
 
-        let right = forward.cross(camera.up);
+        let right = forward_norm.cross(camera.up);
+
+        // Redo radius calc in case the up/ down is pressed.
+        let forward = camera.target - camera.eye;
+        let forward_mag = forward.magnitude();
 
         if self.is_right_pressed {
-            camera.eye += right * self.speed;
+            // Rescale the distance between the target and eye so 
+            // that it doesn't change. The eye therefore still 
+            // lies on the circle made by the target and eye.
+            camera.eye = camera.target - (forward + right * self.speed).normalize() * forward_mag;
         }
         if self.is_left_pressed {
-            camera.eye -= right * self.speed;
+            camera.eye = camera.target - (forward - right * self.speed).normalize() * forward_mag;
         }
     }
 }

code/intermediate/tutorial11-normals/src/main.rs

@@ -131,22 +131,33 @@ impl CameraController {
     }
 
     fn update_camera(&self, camera: &mut Camera) {
-        let forward = (camera.target - camera.eye).normalize();
-
-        if self.is_forward_pressed {
-            camera.eye += forward * self.speed;
+        let forward = camera.target - camera.eye;
+        let forward_norm = forward.normalize();
+        let forward_mag = forward.magnitude();
+
+        // Prevents glitching when camera gets too close to the
+        // center of the scene.
+        if self.is_forward_pressed && forward_mag > self.speed {
+            camera.eye += forward_norm * self.speed;
         }
         if self.is_backward_pressed {
-            camera.eye -= forward * self.speed;
+            camera.eye -= forward_norm * self.speed;
         }
 
-        let right = forward.cross(camera.up);
+        let right = forward_norm.cross(camera.up);
+
+        // Redo radius calc in case the up/ down is pressed.
+        let forward = camera.target - camera.eye;
+        let forward_mag = forward.magnitude();
 
         if self.is_right_pressed {
-            camera.eye += right * self.speed;
+            // Rescale the distance between the target and eye so 
+            // that it doesn't change. The eye therefore still 
+            // lies on the circle made by the target and eye.
+            camera.eye = camera.target - (forward + right * self.speed).normalize() * forward_mag;
         }
         if self.is_left_pressed {
-            camera.eye -= right * self.speed;
+            camera.eye = camera.target - (forward - right * self.speed).normalize() * forward_mag;
         }
     }
 }

code/research/performance/src/main.rs

@@ -135,22 +135,33 @@ impl CameraController {
     }
 
     fn update_camera(&self, camera: &mut Camera) {
-        let forward = (camera.target - camera.eye).normalize();
-
-        if self.is_forward_pressed {
-            camera.eye += forward * self.speed;
+        let forward = camera.target - camera.eye;
+        let forward_norm = forward.normalize();
+        let forward_mag = forward.magnitude();
+
+        // Prevents glitching when camera gets too close to the
+        // center of the scene.
+        if self.is_forward_pressed && forward_mag > self.speed {
+            camera.eye += forward_norm * self.speed;
         }
         if self.is_backward_pressed {
-            camera.eye -= forward * self.speed;
+            camera.eye -= forward_norm * self.speed;
         }
 
-        let right = forward.cross(camera.up);
+        let right = forward_norm.cross(camera.up);
+
+        // Redo radius calc in case the up/ down is pressed.
+        let forward = camera.target - camera.eye;
+        let forward_mag = forward.magnitude();
 
         if self.is_right_pressed {
-            camera.eye += right * self.speed;
+            // Rescale the distance between the target and eye so 
+            // that it doesn't change. The eye therefore still 
+            // lies on the circle made by the target and eye.
+            camera.eye = camera.target - (forward + right * self.speed).normalize() * forward_mag;
         }
         if self.is_left_pressed {
-            camera.eye -= right * self.speed;
+            camera.eye = camera.target - (forward - right * self.speed).normalize() * forward_mag;
         }
     }
 }

docs/beginner/tutorial6-uniforms/README.md

@@ -314,24 +314,36 @@ impl CameraController {
 
     fn update_camera(&self, camera: &mut Camera) {
         use cgmath::InnerSpace;
-        let forward = (camera.target - camera.eye).normalize();
-
-        if self.is_forward_pressed {
-            camera.eye += forward * self.speed;
+        let forward = camera.target - camera.eye;
+        let forward_norm = forward.normalize();
+        let forward_mag = forward.magnitude();
+
+        // Prevents glitching when camera gets too close to the
+        // center of the scene.
+        if self.is_forward_pressed && forward_mag > self.speed {
+            camera.eye += forward_norm * self.speed;
         }
         if self.is_backward_pressed {
-            camera.eye -= forward * self.speed;
+            camera.eye -= forward_norm * self.speed;
         }
 
-        let right = forward.cross(camera.up);
+        let right = forward_norm.cross(camera.up);
+
+        // Redo radius calc in case the up/ down is pressed.
+        let forward = camera.target - camera.eye;
+        let forward_mag = forward.magnitude();
 
         if self.is_right_pressed {
-            camera.eye += right * self.speed;
+            // Rescale the distance between the target and eye so 
+            // that it doesn't change. The eye therefore still 
+            // lies on the circle made by the target and eye.
+            camera.eye = camera.target - (forward + right * self.speed).normalize() * forward_mag;
         }
         if self.is_left_pressed {
-            camera.eye -= right * self.speed;
+            camera.eye = camera.target - (forward - right * self.speed).normalize() * forward_mag;
         }
     }
+    }
 }
 ```