do ws2submission-w2.0

1 files changed, 161 insertions, 156 deletions

diff --git a/worksheets/a2_carsoccer.md b/worksheets/a2_carsoccer.md
index 95170c4..da09ad0 100644
--- a/worksheets/a2_carsoccer.md
+++ b/worksheets/a2_carsoccer.md
@@ -1,156 +1,161 @@
-# Assignment 2 (Car Soccer) Worksheet
-
-## Definitions
-
-Use the following C++ style pseudocode definitions for Q1 and Q2:
-
-```
-/* Use this Point3 class to store x,y,z values that define a mathematical
- * point (i.e., a position) in 3-space.
- */
-class Point3 {
-    float x;
-    float y;
-    float z;
-};
-
-/* Use this Vector3 class to store x,y,z values that define a vector in
- * 3-space.  Remember, mathematically, a vector is quite different than
- * a point.  It has a direction and a magnitude but no position!
- * For vectors it is often useful to be able to compute the length,
- * also known as the magnitude, of the vector.
- */
-class Vector3  {
-    float x;
-    float y;
-    float z;
-    
-    // returns the length (i.e., magnitude) of the vector
-    float Length() {
-        return sqrt(x*x + y*y + z*z);
-    }
-};
-
-
-/* In C++ and other languages we can define operators so we can use
- * the +, -, =, *, / operations on custom classes.  Like many graphics
- * libraries, this is what MinGfx does to make it easy to work with
- * points and vectors in code.  For example, recall from class that
- * if we have a point A (Coffman Union) and we add a vector (direction
- * and magnitude) to this, we arrive at a new point B (e.g., Murphy Hall).
- * Conceptually, a point + a vector = a new point.  Mathematically, it
- * does not make sense to add two points, but it does make sense to 
- * subtract two points.  The "difference" between the Murphy and Coffman 
- * points is a vector that tells us the direction and magnitude we would
- * need to walk from Coffman to get to Murphy.  Here's how we can write
- * that in code using Point3, Vector3, and operators like + and -.
- *
- *   Point3 murphy = Point3(5, 8, 0);
- *   Point3 coffman = Point3(4, 6, 0);
- *   Vector3 toMurphy = murphy - coffman; 
- *
- *   // or, if we were given coffman and toMurphy we could find
- *   // the point "murphy" by starting at point "coffman" and adding
- *   // the vector "toMurphy".
- *   Point3 murphy2 = coffman + toMurhpy; 
- *
- * The code that defines these opertors looks something like this:
-*/
-
-// a point + a vector = a new point
-Point3 operator+(Point3 p, Vector3 v) { 
-   return Point3(p.x + v.x, p.y + v.y, p.z + v.z); 
-}
-
-// a point - a point = a vector 
-// the dir and magnitude needed to go from point point B to point A
-Vector3 operator-(Point3 A, Point3 B) {
-    return Vector3(A.x - B.x, A.y - B.y, A.z - B.z);
-}
-
-// a vector * a scalar = a new vector with scaled magnitude
-Vector3 operator*(Vector3 v, float s) {
-    return Vector3(v.x * s, v.y * s, v.z * s);
-}
-
-
-
-/* Given all these tools, we can define additional classes for geometries
- * that are useful in graphics.  For example, we can represent a sphere
- * using a Point3 for the position of the center point of the sphere and
- * a float for the sphere's radius.
- */
-class Sphere {
-    Point3 position;
-    float radius;
-};
-```
-
-## Q1: Eulerian Integration
-
-In computer graphics and animation, there are many forms of integration that
-are used. For simple physics models like we have in Car Soccer, Eulerian
-Integration is good enough. Eulerian Integration uses velocity and position
-information from the current frame, and the elapsed time to produce a position
-for the next frame. Write pseudocode for determining the position of the sphere in the
-next frame:
-
-*Hint: think back to the motion equations from introductory physics. Or, look
-around in the assignment handout.*
-
-```
-Vector3 velocity = Vector3(1.0, 1.0, 1.0);
-float dt = 20; // milliseconds
-
-Sphere s = Sphere {
-    position: Point3(0.0, 0.0, 0.0),
-    radius: 5.0,
-};
-
-s.position = /* --- Fill in the next frame position computation here --- */
-```
-
-
-
-## Q2: Sphere Intersection
-
-In this assignment, you will need to test intersections between spheres and
-other objects. Using the information contained within each sphere class,
-write pseudocode to determine whether or not two spheres are intersecting
-(which you can use for car/ball intersections):
-
-```
-bool sphereIntersection(Sphere s1, Sphere s2) {
-    /* --- Fill in your sphere intersection code here --- */
-    
-
-}
-```
-
-To check that your intersections work, try working through the math by hand for the
-following two cases.  You can write out the math on a scrap piece of paper.   You do
-not need to include that detail in this worksheet.  But, do change the lines below where
-it says "Fill in expected output" to indicate whether True or False would be returned:
-
-```
-Sphere s1 = Sphere {
-    position: Point3(0.0, 1.0, 0.0),
-    radius: 1.0,
-};
-
-Sphere s2 = Sphere {
-    position: Point3(3.0, 0.0, 0.0),
-    radius: 1.0,
-};
-
-Sphere s3 = Sphere {
-    position: Point3(1.0, 1.0, 0.0),
-    radius: 2.0,
-};
-
-print(sphereIntersection(s1, s2));
-/* --- Fill in expected output (True or False) --- */
-
-print(sphereIntersection(s1, s3));
-/* --- Fill in expected output (True or False) --- */
-```
+# Assignment 2 (Car Soccer) Worksheet

+

+## Definitions

+

+Use the following C++ style pseudocode definitions for Q1 and Q2:

+

+```cpp

+/* Use this Point3 class to store x,y,z values that define a mathematical

+ * point (i.e., a position) in 3-space.

+ */

+class Point3 {

+    float x;

+    float y;

+    float z;

+};

+

+/* Use this Vector3 class to store x,y,z values that define a vector in

+ * 3-space.  Remember, mathematically, a vector is quite different than

+ * a point.  It has a direction and a magnitude but no position!

+ * For vectors it is often useful to be able to compute the length,

+ * also known as the magnitude, of the vector.

+ */

+class Vector3  {

+    float x;

+    float y;

+    float z;

+    

+    // returns the length (i.e., magnitude) of the vector

+    float Length() {

+        return sqrt(x*x + y*y + z*z);

+    }

+};

+

+

+/* In C++ and other languages we can define operators so we can use

+ * the +, -, =, *, / operations on custom classes.  Like many graphics

+ * libraries, this is what MinGfx does to make it easy to work with

+ * points and vectors in code.  For example, recall from class that

+ * if we have a point A (Coffman Union) and we add a vector (direction

+ * and magnitude) to this, we arrive at a new point B (e.g., Murphy Hall).

+ * Conceptually, a point + a vector = a new point.  Mathematically, it

+ * does not make sense to add two points, but it does make sense to 

+ * subtract two points.  The "difference" between the Murphy and Coffman 

+ * points is a vector that tells us the direction and magnitude we would

+ * need to walk from Coffman to get to Murphy.  Here's how we can write

+ * that in code using Point3, Vector3, and operators like + and -.

+ *

+ *   Point3 murphy = Point3(5, 8, 0);

+ *   Point3 coffman = Point3(4, 6, 0);

+ *   Vector3 toMurphy = murphy - coffman; 

+ *

+ *   // or, if we were given coffman and toMurphy we could find

+ *   // the point "murphy" by starting at point "coffman" and adding

+ *   // the vector "toMurphy".

+ *   Point3 murphy2 = coffman + toMurhpy; 

+ *

+ * The code that defines these opertors looks something like this:

+*/

+

+// a point + a vector = a new point

+Point3 operator+(Point3 p, Vector3 v) { 

+   return Point3(p.x + v.x, p.y + v.y, p.z + v.z); 

+}

+

+// a point - a point = a vector 

+// the dir and magnitude needed to go from point point B to point A

+Vector3 operator-(Point3 A, Point3 B) {

+    return Vector3(A.x - B.x, A.y - B.y, A.z - B.z);

+}

+

+// a vector * a scalar = a new vector with scaled magnitude

+Vector3 operator*(Vector3 v, float s) {

+    return Vector3(v.x * s, v.y * s, v.z * s);

+}

+

+

+

+/* Given all these tools, we can define additional classes for geometries

+ * that are useful in graphics.  For example, we can represent a sphere

+ * using a Point3 for the position of the center point of the sphere and

+ * a float for the sphere's radius.

+ */

+class Sphere {

+    Point3 position;

+    float radius;

+};

+```

+

+## Q1: Eulerian Integration

+

+In computer graphics and animation, there are many forms of integration that

+are used. For simple physics models like we have in Car Soccer, Eulerian

+Integration is good enough. Eulerian Integration uses velocity and position

+information from the current frame, and the elapsed time to produce a position

+for the next frame. Write pseudocode for determining the position of the sphere in the

+next frame:

+

+*Hint: think back to the motion equations from introductory physics. Or, look

+around in the assignment handout.*

+

+```cpp

+Vector3 velocity = Vector3(1.0, 1.0, 1.0);

+float dt = 20; // milliseconds

+

+Sphere s = Sphere {

+    position: Point3(0.0, 0.0, 0.0),

+    radius: 5.0,

+};

+

+s.position = operator+(s.position, operator*(velocity,t/1000));

+//That's wrong if the velocity is per ms.

+```

+

+

+

+## Q2: Sphere Intersection

+

+In this assignment, you will need to test intersections between spheres and

+other objects. Using the information contained within each sphere class,

+write pseudocode to determine whether or not two spheres are intersecting

+(which you can use for car/ball intersections):

+

+```cpp

+bool sphereIntersection(Sphere s1, Sphere s2) {

+    /* --- Fill in your sphere intersection code here --- */

+    Vector3 toSphere1 = abs(operator-(s1.position, s2.position));

+    //abs is the absolute value of a vector components

+    float distance = toSphere1.Length();

+    return distance < (s1.radius + s2.radius);

+}

+```

+

+To check that your intersections work, try working through the math by hand for the

+following two cases.  You can write out the math on a scrap piece of paper.   You do

+not need to include that detail in this worksheet.  But, do change the lines below where

+it says "Fill in expected output" to indicate whether True or False would be returned:

+

+```cpp

+Sphere s1 = Sphere {

+    position: Point3(0.0, 1.0, 0.0),

+    radius: 1.0,

+};

+

+Sphere s2 = Sphere {

+    position: Point3(3.0, 0.0, 0.0),

+    radius: 1.0,

+};

+

+Sphere s3 = Sphere {

+    position: Point3(1.0, 1.0, 0.0),

+    radius: 2.0,

+};

+

+print(sphereIntersection(s1, s2));

+/* --- Fill in expected output (True or False) --- */

+false

+

+print(sphereIntersection(s1, s3));

+/* --- Fill in expected output (True or False) --- */

+true

+```