\section{Ray Tracing Support} This section implements functions that could form the basis of a ray tracer. \begin{code}
module RSAGL.RayTrace.RayTrace
(Geometry(..),
Plane,
plane,
plane3,
UnitSphere(..), Sphere,
sphere,
testRay1st,
shadowDeform)
where

import RSAGL.Scene.CoordinateSystems
import RSAGL.Math.Affine
import RSAGL.Math.WrappedAffine
import RSAGL.Math.Vector
import RSAGL.Math.Ray
import Data.Ord
import Data.List
import Data.Maybe
import RSAGL.Types

\end{code} \subsection{Geometry} \texttt{Geometry} supports testing ray-object intersections. \texttt{traceRay} takes an incomming ray of unit length and the \texttt{Geometry} and yields both a \texttt{SurfaceVertex3D} for the point of intersection and the distance between the point of origin and all points of intersection. A negative distance is valid and optional if the point of intersection is behind the ray. \begin{code}
class Geometry g where
testRay :: Ray3D -> g -> [(RSdouble,SurfaceVertex3D)]

instance (Geometry g) => Geometry [g] where
testRay ray gs = concatMap (testRay ray) gs

\end{code} \subsection{Planes} \begin{code}
data Plane = Plane Point3D Vector3D

instance Geometry Plane where
testRay (ray@(Ray3D r r')) (Plane p n) = case t of
_ | t > 0.0 -> [(t,SurfaceVertex3D (projectRay t ray) n)]
_           -> []
where k = dotProduct n $vectorToFrom p r a = dotProduct n r' t = k/a instance AffineTransformable Plane where transform m (Plane p v) = Plane (transform m p) (transform m v) plane :: Point3D -> Vector3D -> Plane plane p v = Plane p$ vectorNormalize v

plane3 :: Point3D -> Point3D -> Point3D -> Plane
plane3 p1 p2 p3 = plane p1 $fromMaybe (error$ "plane3: " ++ show (p1,p2,p3) ++ " don't uniquely define a plane.") $newell [p1,p2,p3]  \end{code} \subsection{Spheres} \begin{code} data UnitSphere = UnitSphere type Sphere = WrappedAffine UnitSphere instance Geometry UnitSphere where testRay (ray@(Ray3D (Point3D kx ky kz) (Vector3D vx vy vz))) UnitSphere = let a = vx^2 + vy^2 + vz^2 b = 2 * (vx*kx + vy*ky + vz*kz) c = kx^2 + ky^2 + kz^2 - 1 p2s (Point3D x y z) = SurfaceVertex3D (Point3D x y z) (Vector3D x y z) in case highSchoolAlgebra a b c of Just (Right (x,y)) -> [(x,p2s$ projectRay x ray),(y,p2s $projectRay y ray)] _ -> [] highSchoolAlgebra :: RSdouble -> RSdouble -> RSdouble -> Maybe (Either RSdouble (RSdouble,RSdouble)) highSchoolAlgebra a b c = let d = b*b - 4*a*c sqrtd = sqrt d ta = 2*a in case () of () | d == 0 -> Just$ Left $negate b / ta () | d > 0 -> Just$ Right ((negate b + sqrtd) / ta,(negate b - sqrtd) / ta)
() -> Nothing

sphere :: Point3D -> RSdouble -> Sphere
sphere p r = translateToFrom p origin_point_3d $scale' r$ wrapAffine UnitSphere

\end{code} \subsection{Instances} \begin{code}
instance Geometry g => Geometry (WrappedAffine g) where
testRay r (WrappedAffine m g) = map (\(_,sv3d) -> let SurfaceVertex3D p v = migrateToFrom m root_coordinate_system sv3d
in (distanceAlong r p,SurfaceVertex3D p v)) $testRay (normalizeRay$ migrateToFrom root_coordinate_system m r) g

\end{code} \subsection{Algorithms} \texttt{testRay1st} is the special case of testRay that returns only the nearest point of intersection, if any. \begin{code}
testRay1st :: (Geometry g) => Ray3D -> g -> Maybe (RSdouble,SurfaceVertex3D)
testRay1st r g = listToMaybe $sortBy (comparing fst)$ filter ((>0) . fst) $testRay r g  \end{code} \texttt{shadowDeform} constructs a deformation function using a geometry. An existing surface is mapped to the surface of the geometry by casting the surface along parallel rays, as happens when a shadow is cast by rays of sunlight. \begin{code} shadowDeform :: (Geometry g) => Vector3D -> g -> SurfaceVertex3D -> SurfaceVertex3D shadowDeform sunlight g (sv3d) = maybe sv3d snd$ testRay1st r g
where r = Ray3D (sv3d_position sv3d) sunlight

\end{code}