IceRay.h

Go to the documentation of this file.

// Include Guard
#ifndef __ICERAY_H__
#define __ICERAY_H__

        class ICEMATHS_API Ray
        {
                public:
                inline_                                 Ray()                                                                                                                           {}
                inline_                                 Ray(const Point& orig, const Point& dir) : mOrig(orig), mDir(dir)       {}
                inline_                                 Ray(const Ray& ray) : mOrig(ray.mOrig), mDir(ray.mDir)                          {}
                inline_                                 ~Ray()                                                                                                                          {}

                                                float   SquareDistance(const Point& point, float* t=null)       const;
                inline_                 float   Distance(const Point& point, float* t=null)                     const                   { return sqrtf(SquareDistance(point, t));       }

                                                Point   mOrig;          
                                                Point   mDir;           
        };

        inline_ void ComputeReflexionVector(Point& reflected, const Point& incoming_dir, const Point& outward_normal)
        {
                reflected = incoming_dir - outward_normal * 2.0f * (incoming_dir|outward_normal);
        }

        inline_ void ComputeReflexionVector(Point& reflected, const Point& source, const Point& impact, const Point& normal)
        {
                Point V = impact - source;
                reflected = V - normal * 2.0f * (V|normal);
        }

        inline_ void DecomposeVector(Point& normal_compo, Point& tangent_compo, const Point& outward_dir, const Point& outward_normal)
        {
                normal_compo = outward_normal * (outward_dir|outward_normal);
                tangent_compo = outward_dir - normal_compo;
        }


        inline_ void ComputeLocalDirection(Point& local_dir, const Point& world_dir, const Matrix4x4& world)
        {
                // Get world direction back in local space
//              Matrix3x3 InvWorld = world;
//              local_dir = InvWorld * world_dir;
                local_dir = Matrix3x3(world) * world_dir;
        }


        inline_ void ComputeLocalPoint(Point& local_pt, const Point& world_pt, const Matrix4x4& world)
        {
                // Get world vertex back in local space
                Matrix4x4 InvWorld = world;
                InvWorld.Invert();
                local_pt = world_pt * InvWorld;
        }


        inline_ void ComputeLocalRay(Ray& local_ray, const Ray& world_ray, const Matrix4x4& world)
        {
                // Get world ray back in local space
                ComputeLocalDirection(local_ray.mDir, world_ray.mDir, world);
                ComputeLocalPoint(local_ray.mOrig, world_ray.mOrig, world);
        }

#endif // __ICERAY_H__