diff --git a/SimpleRayTracer.jl b/SimpleRayTracer.jl
index ef168e1..1aef867 100644
--- a/SimpleRayTracer.jl
+++ b/SimpleRayTracer.jl
@@ -18,17 +18,14 @@ struct OrthogonalCamera{T<:AbstractFloat} <: AbstractCamera
     origin::Vec3{T}
     size::Tuple{T, T}
     rotation::RotXYZ{T}
-    # function OrthogonalCamera(o, θ, s)
-    #     new(o, RotXYZ(0.0, 0.0, 0.0), s)
-    # end
 end
 
 function get_rays(camera::OrthogonalCamera, resolution::Tuple{I, I}) where {I<:Integer}
     R = camera.rotation
     X, Y = camera.size
     Nx, Ny = resolution
-    screen_pixel_position = [Vec3(x, y, 0.0) + camera.origin for y = LinRange(Y/2, -Y/2, Ny), x = LinRange(-X/2,  X/2, Nx)]
-    [Ray(p, Vec3(0.0, 0.0, 1.0)) for p in screen_pixel_position]
+    screen_pixel_position = [R*Vec3(x, y, 0.0) + camera.origin for y = LinRange(Y/2, -Y/2, Ny), x = LinRange(-X/2,  X/2, Nx)]
+    [Ray(p, R*Vec3(0.0, 0.0, 1.0)) for p in screen_pixel_position]
 end
 
 struct PinHoleCamera{T<:AbstractFloat} <: AbstractCamera
@@ -40,8 +37,8 @@ end
 
 function PinHoleCamera(origin, lookAt, up, distance, size)
     w = origin - lookAt |> normalize 
-    u = cross(up, w) |> normalize
-    v = cross(w, u)
+    u = up × w |> normalize
+    v = w × u
     B = [u  v  w]
     PinHoleCamera(origin, distance, B, size)
 end
@@ -52,17 +49,15 @@ function get_rays(camera::PinHoleCamera, resolution::Tuple{I, I}) where {I<:Inte
     X, Y = camera.size
     B = camera.base
     Nx, Ny = resolution
-    [Ray(origin, normalize(B*Vec3(x, y, -d))) for y = LinRange(Y/2, -Y/2, Ny), x = LinRange(-X/2,  X/2, Nx)]
+    [Ray(origin, B*Vec3(x, y, -d)) for y = LinRange(Y/2, -Y/2, Ny), x = LinRange(-X/2,  X/2, Nx)]
 end
 
-
-
 struct Ray{T<:AbstractFloat}
     origin::Vec3{T}
     direction::Vec3{T}
-    # function Ray{T}(o, d) where {T<:AbstractFloat}
-    #     new(o, d |> normalize)
-    # end
+    function Ray(o::Vec3{T}, d::Vec3{T}) where {T<:AbstractFloat}
+        new{T}(o, d |> normalize)
+    end
 end
 
 struct HitInfo
@@ -88,9 +83,9 @@ end
 
 function check_hit(ray::Ray{T}, sphere::Sphere{T})::Tuple{Bool, T} where {T <: AbstractFloat}
     p = ray.origin - sphere.origin
-    a = dot(ray.direction, ray.direction)
-    b = 2 * dot(p, ray.direction)
-    c = dot(p, p) - sphere.radius^2
+    a = ray.direction ⋅ ray.direction
+    b = 2 * (p ⋅ ray.direction)
+    c = p ⋅ p - sphere.radius^2
     Δ = b^2 - 4a*c
     Δ < 0.0 && return false, -1.0
     x, z = -b/(2a), √Δ/(2a)