Added documentation for many of the modules

7 files changed, 81 insertions, 10 deletions

diff --git a/src/core/bound.rs b/src/core/bound.rs
index ea9d990..635218a 100644
--- a/src/core/bound.rs
+++ b/src/core/bound.rs
@@ -1,7 +1,9 @@
+//! Implements a 2d region
 use crate::{Number, Float};
 use super::vector2::Vector2;
 use crate::core;
 
+/// Implements a region between min and max
 #[derive(Clone)]
 pub struct Bound2<T: Number> {
     pub min: Vector2<T>,
@@ -26,6 +28,9 @@ fn max<T: Number> (a: T, b: T) -> T {
 }
 
 impl<T: Number> Bound2<T> {
+    /// Creates a new bound from two points
+    ///
+    /// p0 does not have to be smaller than p1
     pub fn new(p0: &Vector2<T>, p1: &Vector2<T>) -> Self {
         let min = Vector2::new_xy(min(p0.x, p1.x), min(p0.y, p1.y));
         let max = Vector2::new_xy(max(p0.x, p1.x), max(p0.y, p1.y));
@@ -40,18 +45,37 @@ impl<T: Number> Bound2<T> {
             )
     }
 
+    /// Calculates the diagonal vector
+    ///
+    /// Can be used to calculate the size of the bound
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use pathtrace::core::Bound2i;
+    /// let b = Bound2i::new_xyxy(2, 2, 6, 7);
+    /// let diag = b.diagonal();
+    ///
+    /// assert!(diag.x == 4 && diag.y == 5);
+    /// ```
     pub fn diagonal(&self) -> Vector2<T> {
         self.max - self.min
     }
 
+    /// Calculates the area of of the bounded region
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use pathtrace::core::Bound2i;
+    /// let b = Bound2i::new_xyxy(10, 10, 20, 20);
+    /// 
+    /// assert!(b.area() == 100);
+    /// ```
     pub fn area(&self) -> T {
         let diag = self.diagonal();
         return diag.x * diag.y;
     }
-
-    pub fn width(&self) -> T {
-        self.diagonal().x
-    }
 }
 
 impl From<&Bound2i> for Bound2f {
@@ -72,6 +96,7 @@ impl From<&Bound2f> for Bound2i {
     }
 }
 
+/// Finds the intersected area between two bounds
 pub fn intersect<T: Number>(a: &Bound2<T>, b: &Bound2<T>) -> Bound2<T> {
     Bound2::new(
         &Vector2::new_xy(max(a.min.x, b.min.x), max(a.min.y, b.min.y)),
diff --git a/src/core/mod.rs b/src/core/mod.rs
index 7885b9e..aed10d5 100644
--- a/src/core/mod.rs
+++ b/src/core/mod.rs
@@ -1,3 +1,7 @@
+//! Contains a collection of core modules used by other modules
+//!
+//! Also creates a shortcut for some common types
+
 pub mod vector2;
 pub mod vector3;
 pub mod bound;
@@ -11,3 +15,4 @@ pub use vector3::Vector3f;
 pub use bound::{Bound2i, Bound2f};
 pub use spectrum::Spectrum;
 pub use ray::Ray;
+pub use transform::Transform;
diff --git a/src/core/ray.rs b/src/core/ray.rs
index 54af639..2368315 100644
--- a/src/core/ray.rs
+++ b/src/core/ray.rs
@@ -1,3 +1,4 @@
+//! The ray class used when probing the 3d scene
 use crate::core::Vector3f;
 
 pub struct Ray {
diff --git a/src/core/spectrum.rs b/src/core/spectrum.rs
index 604c8c0..c72a251 100644
--- a/src/core/spectrum.rs
+++ b/src/core/spectrum.rs
@@ -1,3 +1,6 @@
+//! Used to represent color
+//!
+//! Currently only implements RGB colors
 use crate::Float;
 use std::ops;
 
diff --git a/src/core/transform.rs b/src/core/transform.rs
index 2c2c123..f64710c 100644
--- a/src/core/transform.rs
+++ b/src/core/transform.rs
@@ -1,7 +1,22 @@
+//! Implements matrix tranformations
+//!
+//! Used for placing shapes and camera into the scene.
+//! Provides some common initializations methods for transforms like rotation, translate and camera
+//! placement.
+//!
+//! # Examples
+//!
+//! ```
+//! use pathtrace::core::{Vector3f, Transform};
+//!
+//! let t = Transform::new_translate(3.0, 5.0, 6.0);
+//! let v = t.eval_point(&Vector3f::new_xyz(1.0, 1.0, 1.0));
+//!
+//! assert!(v.x == 4.0 && v.y == 6.0 && v.z == 7.0);
+//! ```
 use super::matrix4x4::Matrix4x4f;
 use crate::Float;
 use crate::core::Vector3f;
-use std::ops;
 
 pub struct Transform {
     m: Matrix4x4f,
@@ -14,6 +29,7 @@ impl Transform {
         }
     }
 
+    /// Evaluation a point through the matrix
     pub fn eval_point(&self, p: &Vector3f) -> Vector3f {
         let m = &self.m.m;
         let x = m[0][0]*p.x + m[0][1]*p.y + m[0][2]*p.z + m[0][3];
@@ -29,7 +45,9 @@ impl Transform {
         out
     }
 
-    // Take care when transforming surface normal vector, TODO implement method for this
+    /// Evaluation of a vector
+    ///
+    /// This will not work for normal vectors as they become distorted
     pub fn eval_vector(&self, v: &Vector3f) -> Vector3f {
         let m = &self.m.m;
         let x = m[0][0]*v.x + m[0][1]*v.y + m[0][2]*v.z;
@@ -42,11 +60,11 @@ impl Transform {
 
 // Creation of different transformations
 impl Transform {
-    pub fn new_translate(delta: &Vector3f) -> Self {
+    pub fn new_translate(x: Float, y: Float, z: Float) -> Self {
         Transform { m: Matrix4x4f::new(
-                1.0, 0.0, 0.0, delta.x,
-                0.0, 1.0, 0.0, delta.y,
-                0.0, 0.0, 1.0, delta.z,
+                1.0, 0.0, 0.0, x,
+                0.0, 1.0, 0.0, y,
+                0.0, 0.0, 1.0, z,
                 0.0, 0.0, 0.0, 1.0)
         }
     }
diff --git a/src/core/vector2.rs b/src/core/vector2.rs
index ac70947..5afa0f2 100644
--- a/src/core/vector2.rs
+++ b/src/core/vector2.rs
@@ -1,3 +1,6 @@
+//! Implements 2d vectors
+//!
+//! This is implemented generictly with types that fit in the Number trait
 use crate::{Float, Number};
 use std::ops::{Sub, Add};
 
diff --git a/src/core/vector3.rs b/src/core/vector3.rs
index 05bd977..48025ed 100644
--- a/src/core/vector3.rs
+++ b/src/core/vector3.rs
@@ -1,3 +1,6 @@
+//! Implements 3d vectors
+//!
+//! Also add more 3d math things needed for shading and 3d calculations.
 use crate::{Float, Number};
 use std::ops::{Sub, Add, DivAssign};
 
@@ -55,6 +58,9 @@ impl<T: Number> DivAssign<T> for Vector3<T> {
 }
 
 impl Vector3f {
+    /// Calculates the length times itself
+    ///
+    /// This is faster than using len * len as the square is ommited
     pub fn len_squared(&self) -> Float {
         self.x * self.x + self.y * self.y + self.z * self.z
     }
@@ -67,6 +73,16 @@ impl Vector3f {
         self.x * op.x + self.y * op.y + self.z * op.z
     }
 
+    /// Inplace normal instead of creating a new vector
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use pathtrace::core::Vector3f;
+    /// let mut v = Vector3f::new_xyz(10.0, 0.0, 0.0);
+    /// v.norm_in();
+    /// assert!(v.x == 1.0);
+    /// ```
     pub fn norm_in(&mut self) {
         let len = self.len();
         if len == 0.0 {