ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/Plugins/PCZSceneManager/OgrePCZoneFactory.h

@@ -0,0 +1,126 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+OgrePCZoneFactory.h  -  PCZone Factory & Factory Manager
+
+-----------------------------------------------------------------------------
+begin                : Mon Apr 16 2007
+author               : Eric Cha
+email                : ericc@xenopi.com
+Code Style Update	 :
+-----------------------------------------------------------------------------
+*/
+
+#ifndef PCZONE_FACTORY_H
+#define PCZONE_FACTORY_H
+
+#include <OgreSingleton.h>
+#include "OgrePCZone.h"
+
+namespace Ogre
+{
+	class PCZSceneManager;
+
+	/// Factory for PCZones
+	class _OgrePCZPluginExport PCZoneFactory : public SceneCtlAllocatedObject
+    {
+	public:
+		PCZoneFactory(const String & typeName);
+		virtual ~PCZoneFactory();
+		virtual bool supportsPCZoneType(const String& zoneType) = 0;
+		virtual PCZone* createPCZone(PCZSceneManager * pczsm, const String& zoneName) = 0;
+		const String& getFactoryTypeName() const { return mFactoryTypeName; }
+		/// Factory type name
+		String mFactoryTypeName;
+    };
+
+	// Factory for default zone
+	class _OgrePCZPluginExport DefaultZoneFactory : public PCZoneFactory
+	{
+	public:
+		DefaultZoneFactory();
+		virtual ~DefaultZoneFactory();
+		bool supportsPCZoneType(const String& zoneType);
+		PCZone* createPCZone(PCZSceneManager * pczsm, const String& zoneName);
+	};
+
+	// PCZoneFactory manager class
+	class _OgrePCZPluginExport PCZoneFactoryManager : public Singleton<PCZoneFactoryManager>, public SceneCtlAllocatedObject
+	{
+	public:
+		PCZoneFactoryManager();	
+		~PCZoneFactoryManager();
+		void registerPCZoneFactory(PCZoneFactory* factory);
+		void unregisterPCZoneFactory(PCZoneFactory* factory);
+		PCZone* createPCZone(PCZSceneManager * pczsm,
+							 const String& zoneType, 
+							 const String& zoneName);
+        /** Override standard Singleton retrieval.
+        @remarks
+        Why do we do this? Well, it's because the Singleton
+        implementation is in a .h file, which means it gets compiled
+        into anybody who includes it. This is needed for the
+        Singleton template to work, but we actually only want it
+        compiled into the implementation of the class based on the
+        Singleton, not all of them. If we don't change this, we get
+        link errors when trying to use the Singleton-based class from
+        an outside dll.
+        @par
+        This method just delegates to the template version anyway,
+        but the implementation stays in this single compilation unit,
+        preventing link errors.
+        */
+        static PCZoneFactoryManager& getSingleton(void);
+        /** Override standard Singleton retrieval.
+        @remarks
+        Why do we do this? Well, it's because the Singleton
+        implementation is in a .h file, which means it gets compiled
+        into anybody who includes it. This is needed for the
+        Singleton template to work, but we actually only want it
+        compiled into the implementation of the class based on the
+        Singleton, not all of them. If we don't change this, we get
+        link errors when trying to use the Singleton-based class from
+        an outside dll.
+        @par
+        This method just delegates to the template version anyway,
+        but the implementation stays in this single compilation unit,
+        preventing link errors.
+        */
+        static PCZoneFactoryManager* getSingletonPtr(void);
+		/* PCZoneFactory Iterator - for querying what types of PCZone
+		factories are available */
+		typedef map<String, PCZoneFactory*>::type PCZoneFactoryMap;
+		typedef MapIterator<PCZoneFactoryMap> PCZoneFactoryIterator;
+		/** Return an iterator over the PCZone factories currently registered */
+		PCZoneFactoryIterator getPCZoneFactoryIterator(void);
+
+	protected:
+		PCZoneFactoryMap mPCZoneFactories;
+		DefaultZoneFactory mDefaultFactory;
+	};
+}
+
+#endif

data/deps/include/OGRE/Plugins/PCZSceneManager/OgrePortal.h

@@ -0,0 +1,106 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+Portal.h  -  Portals are special constructs which which are used to connect 
+			 two Zones in a PCZScene.  Portals are defined by 4 coplanr 
+             corners and a direction.  Portals are contained within Zones and 
+             are essentially "one way" connectors.  Objects and entities can
+			 use them to travel to other Zones, but to return, there must be
+			 a corresponding Portal which connects back to the original zone
+			 from the new zone.
+
+-----------------------------------------------------------------------------
+begin                : Thu Feb 22 2007
+author               : Eric Cha
+email                : ericc@xenopi.com
+Code Style Update	 : Apr 5, 2007
+-----------------------------------------------------------------------------
+*/
+
+#ifndef PORTAL_H
+#define PORTAL_H
+
+#include "OgrePortalBase.h"
+
+namespace Ogre
+{
+	/** Portal datastructure for connecting zones. */
+	class _OgrePCZPluginExport Portal : public PortalBase
+	{
+	public:
+		Portal(const String &name, const PORTAL_TYPE type = PORTAL_TYPE_QUAD);
+		virtual ~Portal();
+
+		void setTargetZone(PCZone* zone);
+		/** Set the target portal pointer */
+		void setTargetPortal(Portal* portal);
+
+		/** Get the Zone the Portal connects to */
+		PCZone* getTargetZone() {return mTargetZone;}
+		/** Get the connected portal (if any) */
+		Portal* getTargetPortal() {return mTargetPortal;}
+
+		/** @copydoc MovableObject::getMovableType. */
+		const String& getMovableType() const;
+
+	protected:
+		///connected Zone
+		PCZone* mTargetZone;
+		/** Matching Portal in the target zone (usually in same world space 
+			as this portal, but pointing the opposite direction)
+		*/
+		Portal* mTargetPortal;
+	};
+
+	/** Factory object for creating Portal instances */
+	class _OgrePCZPluginExport PortalFactory : public PortalBaseFactory
+	{
+	protected:
+		MovableObject* createInstanceImpl(const String& name, const NameValuePairList* params);
+	public:
+		PortalFactory() {}
+		~PortalFactory() {}
+
+		static String FACTORY_TYPE_NAME;
+		static unsigned long FACTORY_TYPE_FLAG;
+
+		const String& getType() const
+		{ return FACTORY_TYPE_NAME; }
+
+		void destroyInstance(MovableObject* obj);
+
+		/** Return true here as we want to get a unique type flag. */
+		bool requestTypeFlags() const
+		{ return true; }
+
+	};
+
+}
+
+#endif
+
+
+

data/deps/include/OGRE/Plugins/PCZSceneManager/OgrePortalBase.h

@@ -0,0 +1,303 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+PortalBase.h  -  PortalBase is the base class for Portal and AntiPortal.
+
+*/
+
+#ifndef PORTALBASE_H
+#define PORTALBASE_H
+
+#include "OgrePCZPrerequisites.h"
+#include "OgrePCZSceneNode.h"
+#include "OgreMovableObject.h"
+#include "OgreAxisAlignedBox.h"
+#include "OgreCapsule.h"
+#include "OgreSphere.h"
+
+namespace Ogre
+{
+	class PCZSceneNode;
+
+	/** PortalBase - Base class to Portal and AntiPortal classes. */
+	class _OgrePCZPluginExport PortalBase : public MovableObject
+	{
+	public:
+		enum PORTAL_TYPE
+		{
+			PORTAL_TYPE_QUAD,
+			PORTAL_TYPE_AABB,
+			PORTAL_TYPE_SPHERE
+		};
+
+		/** Constructor. */
+		PortalBase(const String& name, const PORTAL_TYPE type = PORTAL_TYPE_QUAD);
+
+		/** Destructor. */
+		virtual ~PortalBase();
+
+		/** Retrieves the axis-aligned bounding box for this object in world coordinates. */
+		virtual const AxisAlignedBox& getWorldBoundingBox(bool derive = false) const;
+		/** Retrieves the worldspace bounding sphere for this object. */
+		virtual const Sphere& getWorldBoundingSphere(bool derive = false) const;
+
+		/** Set the SceneNode the Portal is associated with */
+		void setNode(SceneNode* sn);
+		/** Set the current home zone of the portal */
+		void setCurrentHomeZone(PCZone* zone);
+		/** Set the zone this portal should be moved to */
+		void setNewHomeZone(PCZone* zone);
+
+		/** Set the local coordinates of one of the portal corners */
+		void setCorner(int index, const Vector3& point);
+		/** Set the local coordinates of all of the portal corners */
+		void setCorners(const Vector3* corners);
+		/** Set the "inward/outward norm" direction of AAB or SPHERE portals
+			NOTE: UNIT_Z = "outward" norm, NEGATIVE_UNIT_Z = "inward" norm
+			NOTE: Remember, Portal norms always point towards the zone they are "in".
+		*/
+		void setDirection(const Vector3 &d)
+		{
+			switch (mType)
+			{
+			default:
+			case PORTAL_TYPE_QUAD:
+				OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
+					"Cannot setDirection on a Quad type portal", 
+					"Portal::setDirection");
+				break;
+			case PORTAL_TYPE_AABB:
+			case PORTAL_TYPE_SPHERE:
+				if (d != Vector3::UNIT_Z &&
+					d != Vector3::NEGATIVE_UNIT_Z)
+				{
+					OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
+						"Valid parameters are Vector3::UNIT_Z or Vector3::NEGATIVE_UNIT_Z", 
+						"Portal::setDirection");
+					return;
+				}
+				mDirection = d;
+				break;
+			}
+		}
+		/** Calculate the local direction and radius of the portal */
+		void calcDirectionAndRadius() const;
+
+		/** get the type of portal */
+		PORTAL_TYPE getType() const {return mType;}
+		/** Retrieve the radius of the portal (calculates if necessary for quad portals) */
+		Real getRadius() const;
+
+		/** Get the Zone the Portal is currently "in" */
+		PCZone* getCurrentHomeZone()
+		{ return mCurrentHomeZone; }
+		/** Get the Zone the Portal should be moved to */
+		PCZone* getNewHomeZone()
+		{ return mNewHomeZone; }
+
+		/** Get the coordinates of one of the portal corners in local space */
+		const Vector3& getCorner(int index) const
+		{ return mCorners[index]; }
+		/** Get the direction vector of the portal in local space */
+		const Vector3& getDirection() const
+		{ return mDirection; }
+
+		/** Get the derived (world) coordinates of one of the portal corners */
+		const Vector3& getDerivedCorner(int index) const
+		{ return mDerivedCorners[index]; }
+		/** Get the direction of the portal in world coordinates */
+		const Vector3& getDerivedDirection() const
+		{ return mDerivedDirection; }
+		/** Get the position (centerpoint) of the portal in world coordinates */
+		const Vector3& getDerivedCP() const
+		{ return mDerivedCP; }
+		/** Get the sphere centered on the derived CP of the portal in world coordinates */
+		const Sphere& getDerivedSphere() const
+		{ return mDerivedSphere; }
+		/** Get the portal plane in world coordinates */
+		const Plane& getDerivedPlane() const
+		{ return mDerivedPlane; }
+
+		/** Get the previous position (centerpoint) of the portal in world coordinates */
+		const Vector3& getPrevDerivedCP() const
+		{ return mPrevDerivedCP; }
+		/** Get the previous portal plane in world coordinates */
+		const Plane& getPrevDerivedPlane() const
+		{ return mPrevDerivedPlane; }
+
+		/** Update the derived values */
+		void updateDerivedValues() const;
+		/** Adjust the portal so that it is centered and oriented on the given node */
+		void adjustNodeToMatch(SceneNode* node);
+		/** enable the portal */
+		void setEnabled(bool value)
+		{ mEnabled = value; }
+		/** check if portal is enabled */
+		bool getEnabled() const {return mEnabled;}
+		
+
+		enum PortalIntersectResult
+		{
+			NO_INTERSECT,
+			INTERSECT_NO_CROSS,
+			INTERSECT_BACK_NO_CROSS,
+			INTERSECT_CROSS
+		};
+		/** check if portal intersects an aab */
+		bool intersects(const AxisAlignedBox& aab);
+
+		/** check if portal intersects an sphere */
+		bool intersects(const Sphere& sphere);
+
+		/** check if portal intersects a plane bounded volume */
+		bool intersects(const PlaneBoundedVolume& pbv);
+
+		/** check if portal intersects a ray */
+		bool intersects(const Ray& ray);
+
+		/** check for intersection between portal & scenenode (also determines
+		 * if scenenode crosses over portal
+		 */
+		PortalIntersectResult intersects(PCZSceneNode* sn);
+
+		/** check if portal crossed over portal */
+		bool crossedPortal(const PortalBase* otherPortal);
+		/** check if portal touches another portal */
+		bool closeTo(const PortalBase* otherPortal);
+
+		/** @copydoc MovableObject::getBoundingBox. */
+		const AxisAlignedBox& getBoundingBox() const;
+
+		/** @copydoc MovableObject::getBoundingRadius. */
+		Real getBoundingRadius() const
+		{ return getRadius(); }
+
+		/** @copydoc MovableObject::_updateRenderQueue. */
+		void _updateRenderQueue(RenderQueue* queue)
+		{ /* Draw debug info if needed? */ }
+
+		/** @copydoc MovableObject::visitRenderables. */
+		void visitRenderables(Renderable::Visitor* visitor, bool debugRenderables = false)
+		{ }
+
+		/** Called when scene node moved. */
+		void _notifyMoved()
+		{
+			updateDerivedValues();
+			mWasMoved = true;
+		}
+
+		/** Called when attached to a scene node. */
+		void _notifyAttached(Node* parent, bool isTagPoint = false)
+		{
+			MovableObject::_notifyAttached(parent, isTagPoint);
+			mDerivedUpToDate = false;
+		}
+
+		/** Returns true if portal needs update. */
+		bool needUpdate();
+
+		/** Returns an updated capsule of the portal for intersection test. */
+		const Capsule& getCapsule() const;
+
+		/** Returns an updated AAB of the portal for intersection test. */
+		const AxisAlignedBox& getAAB();
+
+	protected:
+		// Type of portal (quad, aabb, or sphere)
+		PORTAL_TYPE mType;
+		/// Zone this portal is currently owned by (in)
+		PCZone * mCurrentHomeZone;
+		///zone to transfer this portal to
+		PCZone * mNewHomeZone;
+		/// Corners of the portal - coordinates are relative to the sceneNode
+		// NOTE: there are 4 corners if the portal is a quad type
+		//       there are 2 corners if the portal is an AABB type
+		//       there are 2 corners if the portal is a sphere type (center and point on sphere)
+		Vector3 * mCorners;
+		/// Direction ("Norm") of the portal - 
+		// NOTE: For a Quad portal, determined by the 1st 3 corners.
+		// NOTE: For AABB & SPHERE portals, we only have "inward" or "outward" cases.
+		//       To indicate "outward", the Direction is UNIT_Z
+		//       to indicate "inward", the Direction is NEGATIVE_UNIT_Z
+		mutable Vector3 mDirection;
+		/// Radius of the sphere enclosing the portal 
+		// NOTE: For aabb portals, this value is the distance from the center of the aab to a corner
+		mutable Real mRadius;
+		// Local Centerpoint of the portal
+		mutable Vector3 mLocalCP;
+		/// Derived (world coordinates) Corners of the portal
+		// NOTE: there are 4 corners if the portal is a quad type
+		//       there are 2 corners if the portal is an AABB type (min corner & max corner)
+		//       there are 2 corners if the portal is a sphere type (center and point on sphere)
+		Vector3 * mDerivedCorners;
+		/// Derived (world coordinates) direction of the portal
+		// NOTE: Only applicable for a Quad portal
+		mutable Vector3 mDerivedDirection;
+		/// Derived (world coordinates) of portal (center point)
+		mutable Vector3 mDerivedCP;
+		/// Sphere of the portal centered on the derived CP
+		mutable Sphere mDerivedSphere;
+		/// Derived (world coordinates) Plane of the portal
+		// NOTE: Only applicable for a Quad portal
+		mutable Plane mDerivedPlane;
+		/// Previous frame portal cp (in world coordinates)
+		mutable Vector3 mPrevDerivedCP;
+		/// Previous frame derived plane 
+		// NOTE: Only applicable for a Quad portal
+		mutable Plane mPrevDerivedPlane;
+		/// flag indicating whether or not local values are up-to-date
+		mutable bool mLocalsUpToDate;
+		/// flag indicating whether or not derived values are up-to-date
+		mutable bool mDerivedUpToDate;
+		// previous world transform
+		mutable Matrix4 mPrevWorldTransform;
+		// flag defining if portal is enabled or disabled.
+		bool mEnabled;
+		// cache of portal's capsule.
+		mutable Capsule mPortalCapsule;
+		// cache of portal's AAB that contains the bound of portal movement.
+		mutable AxisAlignedBox mPortalAAB;
+		// cache of portal's previous AAB.
+		mutable AxisAlignedBox mPrevPortalAAB;
+		// cache of portal's local AAB.
+		mutable AxisAlignedBox mLocalPortalAAB;
+		// defined if portal was moved previously.
+		mutable bool mWasMoved;
+	};
+
+	/** Factory object for creating Portal instances */
+	class _OgrePCZPluginExport PortalBaseFactory : public MovableObjectFactory
+	{
+	protected:
+		/** get the portal type from name value pair. */
+		PortalBase::PORTAL_TYPE getPortalType(const NameValuePairList* params);
+
+	};
+
+}
+
+#endif

data/deps/include/OGRE/Plugins/PCZSceneManager/OgreSegment.h

@@ -0,0 +1,81 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+OgreSegment.h  -  3D Line Segment class for intersection testing in Ogre3D
+Some algorithms based off code from the Wild Magic library by Dave Eberly
+-----------------------------------------------------------------------------
+begin                : Mon Apr 02 2007
+author               : Eric Cha
+email                : ericc@xenopi.com
+Code Style Update	 : Apr 5, 2007
+-----------------------------------------------------------------------------
+*/
+
+#ifndef SEGMENT_H
+#define SEGMENT_H
+
+#include "OgreVector3.h"
+
+namespace Ogre
+{
+	class Capsule;
+
+	class Segment
+	{
+	public:
+		// The segment is represented as P+t*D, where P is the segment origin,
+		// D is a unit-length direction vector and |t| <= e.  The value e is
+		// referred to as the extent of the segment.  The end points of the
+		// segment are P-e*D and P+e*D.  The user must ensure that the direction
+		// vector is unit-length.  The representation for a segment is analogous
+		// to that for an oriented bounding box.  P is the center, D is the
+		// axis direction, and e is the extent.
+
+
+		// construction
+		Segment ();  // uninitialized
+		Segment (const Vector3&, const Vector3&, Real);
+
+		// set values
+		void set(const Vector3& newOrigin, const Vector3& newEnd);
+		void setOrigin(const Vector3& newOrigin);
+		void setEndPoint(const Vector3& newEndpoint);
+
+		// functions to calculate distance to another segment
+		Real distance(const Segment& otherSegment) const;
+		Real squaredDistance(const Segment& otherSegment) const;
+
+		// intersect check between segment & capsule 
+		bool intersects(const Capsule&) const;
+
+		// defining variables
+		Vector3 mOrigin;
+		Vector3 mDirection;
+		Real	mExtent;
+	};
+}
+
+#endif //SEGMENT_H