Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/ode/ode-0.9/OPCODE/Ice/IceRay.h @ 216

Last change on this file since 216 was 216, checked in by mathiask, 17 years ago

[Physik] add ode-0.9

File size: 4.6 KB
Line 
1///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2/**
3 *      Contains code for rays.
4 *      \file           IceRay.h
5 *      \author         Pierre Terdiman
6 *      \date           April, 4, 2000
7 */
8///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
9
10///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
11// Include Guard
12#ifndef __ICERAY_H__
13#define __ICERAY_H__
14
15        class ICEMATHS_API Ray
16        {
17                public:
18                //! Constructor
19                inline_                                 Ray()                                                                                                                           {}
20                //! Constructor
21                inline_                                 Ray(const Point& orig, const Point& dir) : mOrig(orig), mDir(dir)       {}
22                //! Copy constructor
23                inline_                                 Ray(const Ray& ray) : mOrig(ray.mOrig), mDir(ray.mDir)                          {}
24                //! Destructor
25                inline_                                 ~Ray()                                                                                                                          {}
26
27                                                float   SquareDistance(const Point& point, float* t=null)       const;
28                inline_                 float   Distance(const Point& point, float* t=null)                     const                   { return sqrtf(SquareDistance(point, t));       }
29
30                                                Point   mOrig;          //!< Ray origin
31                                                Point   mDir;           //!< Normalized direction
32        };
33
34        inline_ void ComputeReflexionVector(Point& reflected, const Point& incoming_dir, const Point& outward_normal)
35        {
36                reflected = incoming_dir - outward_normal * 2.0f * (incoming_dir|outward_normal);
37        }
38
39        inline_ void ComputeReflexionVector(Point& reflected, const Point& source, const Point& impact, const Point& normal)
40        {
41                Point V = impact - source;
42                reflected = V - normal * 2.0f * (V|normal);
43        }
44
45        inline_ void DecomposeVector(Point& normal_compo, Point& tangent_compo, const Point& outward_dir, const Point& outward_normal)
46        {
47                normal_compo = outward_normal * (outward_dir|outward_normal);
48                tangent_compo = outward_dir - normal_compo;
49        }
50
51        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
52        /**
53         *      Transforms a direction vector from world space to local space
54         *      \param          local_dir       [out] direction vector in local space
55         *      \param          world_dir       [in] direction vector in world space
56         *      \param          world           [in] world transform
57         */
58        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
59        inline_ void ComputeLocalDirection(Point& local_dir, const Point& world_dir, const Matrix4x4& world)
60        {
61                // Get world direction back in local space
62//              Matrix3x3 InvWorld = world;
63//              local_dir = InvWorld * world_dir;
64                local_dir = Matrix3x3(world) * world_dir;
65        }
66
67        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
68        /**
69         *      Transforms a position vector from world space to local space
70         *      \param          local_pt        [out] position vector in local space
71         *      \param          world_pt        [in] position vector in world space
72         *      \param          world           [in] world transform
73         */
74        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
75        inline_ void ComputeLocalPoint(Point& local_pt, const Point& world_pt, const Matrix4x4& world)
76        {
77                // Get world vertex back in local space
78                Matrix4x4 InvWorld = world;
79                InvWorld.Invert();
80                local_pt = world_pt * InvWorld;
81        }
82
83        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
84        /**
85         *      Transforms a ray from world space to local space
86         *      \param          local_ray       [out] ray in local space
87         *      \param          world_ray       [in] ray in world space
88         *      \param          world           [in] world transform
89         */
90        ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
91        inline_ void ComputeLocalRay(Ray& local_ray, const Ray& world_ray, const Matrix4x4& world)
92        {
93                // Get world ray back in local space
94                ComputeLocalDirection(local_ray.mDir, world_ray.mDir, world);
95                ComputeLocalPoint(local_ray.mOrig, world_ray.mOrig, world);
96        }
97
98#endif // __ICERAY_H__
Note: See TracBrowser for help on using the repository browser.