More documentation for physics

BansheeCore/Include/BsDistanceJoint.h

@@ -7,36 +7,89 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/** A joint that maintains an upper or lower (or both) bound on the distance between two bodies. */
 	class BS_CORE_EXPORT DistanceJoint : public Joint
 	{
 	public:
+		/** Controls distance joint options. */
 		enum class Flag
 		{
-			MinDistance = 0x1,
-			MaxDistance = 0x2,
-			Spring = 0x4
+			MinDistance = 0x1, /** Enables minimum distance limit. */
+			MaxDistance = 0x2, /** Enables maximum distance limit. */
+			Spring = 0x4 /** Enables spring when maintaining limits. */
 		};
 
 	public:
 		virtual ~DistanceJoint() { }
 
+		/** Returns the current distance between the two joint bodies. */
 		virtual float getDistance() const = 0;
 
+		/**
+		 * Returns the minimum distance the bodies are allowed to be at, they will get no closer. You must enable min
+		 * distance flag in order for this limit to be applied.
+		 */
 		virtual float getMinDistance() const = 0;
+
+		/**
+		 * Sets the minimum distance the bodies are allowed to be at, they will get no closer. You must enable min
+		 * distance flag in order for this limit to be applied.
+		 */
 		virtual void setMinDistance(float value) = 0;
 
+		/**
+		 * Returns the maximum distance the bodies are allowed to be at, they will get no further. You must enable max
+		 * distance flag in order for this limit to be applied.
+		 */
 		virtual float getMaxDistance() const = 0;
+
+		/**
+		 * Sets the maximum distance the bodies are allowed to be at, they will get no further. You must enable max
+		 * distance flag in order for this limit to be applied.
+		 */
 		virtual void setMaxDistance(float value) = 0;
 
+		/**
+		 * Returns the error tolerance of the joint at which the joint becomes active. This value slightly extends the
+		 * lower and upper limit. 
+		 */
 		virtual float getTolerance() const = 0;
+
+		/**
+		 * Sets the error tolerance of the joint at which the joint becomes active. This value slightly extends the
+		 * lower and upper limit. 
+		 */
 		virtual void setTolerance(float value) = 0;
 
+		/**
+		 * Returns a spring that controls how the joint responds when a limit is reached. You must enable the spring flag
+		 * on the joint in order for this to be recognized. 
+		 * 
+		 * @see	Spring
+		 */
 		virtual Spring getSpring() const = 0;
+
+		/**
+		 * Sets a spring that controls how the joint responds when a limit is reached. You must enable the spring flag on
+		 * the joint in order for this to be recognized. 
+		 * 
+		 * @see	Spring
+		 */
 		virtual void setSpring(const Spring& value) = 0;
 
+		/** Enables or disables a flag that controls joint behaviour. */
 		virtual void setFlag(Flag flag, bool enabled) = 0;
+
+		/** Checks whether a certain joint flag is enabled. */
 		virtual bool hasFlag(Flag flag) const = 0;
 
+		/** Creates a new distance joint. */
 		static SPtr<DistanceJoint> create();
 	};
+
+	/** @} */
 }

BansheeCore/Include/BsFixedJoint.h

@@ -7,11 +7,19 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/** Physics joint that will maintain a fixed distance and orientation between its two attached bodies. */
 	class BS_CORE_EXPORT FixedJoint : public Joint
 	{
 	public:
 		virtual ~FixedJoint() { }
 
+		/** Creates a new fixed joint. */
 		static SPtr<FixedJoint> create();
 	};
+
+	/** @} */
 }

BansheeCore/Include/BsHingeJoint.h

@@ -7,20 +7,37 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/** Hinge joint removes all but a single rotation degree of freedom from its two attached bodies (e.g. a door hinge). */
 	class BS_CORE_EXPORT HingeJoint : public Joint
 	{
 	public:
+		/** Flags that control hinge joint options. */
 		enum class Flag
 		{
-			Limit = 0x1,
-			Drive = 0x2
+			Limit = 0x1, /** Joint limit is enabled. */
+			Drive = 0x2 /** Joint drive is enabled. */
 		};
 
+		/** Properties of a drive that drives the joint's angular velocity towards a paricular value. */
 		struct Drive
 		{
+			/** Target speed of the joint. */
 			float speed = 0.0f;
+
+			/** Maximum torque the drive is allowed to apply .*/
 			float forceLimit = FLT_MAX;
+
+			/** Scales the velocity of the first body, and its response to drive torque is scaled down. */
 			float gearRatio = 1.0f;
+
+			/** 
+			 * If the joint is moving faster than the drive's target speed, the drive will try to break. If you don't want
+			 * the breaking to happen set this to true.
+			 */
 			bool freeSpin = false;
 
 			bool operator==(const Drive& other) const
@@ -33,18 +50,53 @@ namespace BansheeEngine
 	public:
 		virtual ~HingeJoint() { }
 
+		/** Returns the current angle between the two attached bodes. */
 		virtual Radian getAngle() const = 0;
+
+		/** Returns the current angular speed of the joint. */
 		virtual float getSpeed() const = 0;
 
+		/** 
+		 * Returns the limit of the joint. Limit constrains the motion to the specified angle range. You must enable the
+		 * limit flag on the joint in order for this to be recognized. 
+		 *
+		 * @see LimitAngularRange
+		 */
 		virtual LimitAngularRange getLimit() const = 0;
+
+		/**
+		 * Sets the limit of the joint. Limit constrains the motion to the specified angle range. You must enable the limit
+		 * flag on the joint in order for this to be recognized. 
+		 *
+		 * @see LimitAngularRange
+		 */
 		virtual void setLimit(const LimitAngularRange& limit) = 0;
 
+		/** 
+		 * Returns the drive of the joint. It drives the joint's angular velocity towards a particular value. You must
+		 * enable the drive flag on the joint in order for this to be recognized. 
+		 *
+		 * @see HingeJoint::Drive
+		 */
 		virtual Drive getDrive() const = 0;
+
+		/** 
+		 * Sets the drive of the joint. It drives the joint's angular velocity towards a particular value. You must enable
+		 * the drive flag on the joint in order for this to be recognized. 
+		 *
+		 * @see HingeJoint::Drive
+		 */
 		virtual void setDrive(const Drive& drive) = 0;
 
+		/** Enables or disables a flag that controls joint behaviour. */
 		virtual void setFlag(Flag flag, bool enabled) = 0;
+
+		/** Checks is the specified option enabled. */
 		virtual bool hasFlag(Flag flag) const = 0;
 
+		/** Creates a new hinge joint. */
 		static SPtr<HingeJoint> create();
 	};
+
+	/** @} */
 }

BansheeCore/Include/BsSliderJoint.h

@@ -7,9 +7,17 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/** 
+	 * Joint that removes all but a single translational degree of freedom. Bodies are allowed to move along a single axis. 
+	 */
 	class BS_CORE_EXPORT SliderJoint : public Joint
 	{
 	public:
+		/** Flag that controls slider joint's behaviour. */
 		enum class Flag
 		{
 			Limit = 0x1,
@@ -18,15 +26,37 @@ namespace BansheeEngine
 	public:
 		virtual ~SliderJoint() { }
 
+		/** Returns the current position of the slider. */
 		virtual float getPosition() const = 0;
+
+		/** Returns the current speed of the slider. */
 		virtual float getSpeed() const = 0;
 
+		/** 
+		 * Returns a limit that allows you to constrain the movement of the joint to a specific minimum and maximum 
+		 * distance. You must enable the limit flag on the joint in order for this to be recognized. 
+		 *
+		 * @see LimitLinearRange
+		 */
 		virtual LimitLinearRange getLimit() const = 0;
+
+		/** 
+		 * Sets a limit that allows you to constrain the movement of the joint to a specific minimum and maximum 
+		 * distance. You must enable the limit flag on the joint in order for this to be recognized. 
+		 *
+		 * @see LimitLinearRange
+		 */
 		virtual void setLimit(const LimitLinearRange& limit) = 0;
 
+		/** Enables or disables a flag that controls the joint's behaviour. */
 		virtual void setFlag(Flag flag, bool enabled) = 0;
+
+		/** Checks is the specified flag enabled. */
 		virtual bool hasFlag(Flag flag) const = 0;
 
+		/** Creates a new spherical joint. */
 		static SPtr<SliderJoint> create();
 	};
+
+	/** @} */
 }

BansheeCore/Include/BsSphericalJoint.h

@@ -7,9 +7,19 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup Physics
+	 *  @{
+	 */
+
+	/** 
+	 * A spherical joint removes all translational degrees of freedom but allows all rotational degrees of freedom. 
+	 * Essentially this ensures that the anchor points of the two bodies are always coincident. Bodies are allowed to
+	 * rotate around the anchor points, and their rotatation can be limited by an elliptical cone.
+	 */
 	class BS_CORE_EXPORT SphericalJoint : public Joint
 	{
 	public:
+		/** Flags that control options for the spherical joint */
 		enum class Flag
 		{
 			Limit = 0x1
@@ -18,12 +28,27 @@ namespace BansheeEngine
 	public:
 		virtual ~SphericalJoint() { }
 
+		/** 
+		 * Returns the limit of the joint. This clamps the rotation inside an eliptical angular cone. You must enable limit
+		 * flag on the joint in order for this to be recognized. 
+		 */
 		virtual LimitConeRange getLimit() const = 0;
+
+		/** 
+		 * Sets the limit of the joint. This clamps the rotation inside an eliptical angular cone. You must enable limit
+		 * flag on the joint in order for this to be recognized. 
+		 */
 		virtual void setLimit(const LimitConeRange& limit) = 0;
 
+		/** Enables or disables a flag that controls the joint's behaviour. */
 		virtual void setFlag(Flag flag, bool enabled) = 0;
+
+		/** Checks is the specified flag enabled. */
 		virtual bool hasFlag(Flag flag) const = 0;
 
+		/** Creates a new spherical joint. */
 		static SPtr<SphericalJoint> create();
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsFPhysXCollider.h

@@ -9,31 +9,57 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of FCollider. */
 	class FPhysXCollider : public FCollider
 	{
 	public:
 		explicit FPhysXCollider(physx::PxShape* shape);
 		~FPhysXCollider();
 
+		/** @copydoc FCollider::getPosition */
 		Vector3 getPosition() const override;
+
+		/** @copydoc FCollider::getRotation */
 		Quaternion getRotation() const override;
+
+		/** @copydoc FCollider::setTransform */
 		void setTransform(const Vector3& pos, const Quaternion& rotation) override;
 
+		/** @copydoc FCollider::setIsTrigger */
 		void setIsTrigger(bool value) override;
+
+		/** @copydoc FCollider::getIsTrigger */
 		bool getIsTrigger() const override;
 
+		/** @copydoc FCollider::setIsStatic */
 		void setIsStatic(bool value) override;
+
+		/** @copydoc FCollider::getIsStatic */
 		bool getIsStatic() const override;
 
+		/** @copydoc FCollider::setContactOffset */
 		void setContactOffset(float value) override;
+
+		/** @copydoc FCollider::getContactOffset */
 		float getContactOffset() const override;
 
+		/** @copydoc FCollider::setRestOffset */
 		void setRestOffset(float value) override;
+
+		/** @copydoc FCollider::getRestOffset */
 		float getRestOffset() const override;
 
+		/** @copydoc FCollider::setMaterial */
 		void setMaterial(const HPhysicsMaterial& material) override;
+
+		/** @copydoc FCollider::setLayer */
 		void setLayer(UINT64 layer) override;
 
+		/** Gets the internal PhysX shape that represents the collider. */
 		physx::PxShape* _getShape() const { return mShape; }
 	protected:
 		physx::PxShape* mShape;
@@ -41,4 +67,6 @@ namespace BansheeEngine
 		bool mIsTrigger;
 		bool mIsStatic;
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsFPhysXJoint.h

@@ -8,30 +8,55 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of an FJoint. */
 	class BS_PHYSX_EXPORT FPhysXJoint : public FJoint
 	{
 	public:
 		FPhysXJoint(physx::PxJoint* joint);
 		~FPhysXJoint();
 
+		/** @copydoc FJoint::getBody */
 		Rigidbody* getBody(JointBody body) const override;
+
+		/** @copydoc FJoint::setBody */
 		void setBody(JointBody body, Rigidbody* value) override;
 
+		/** @copydoc FJoint::getPosition */
 		Vector3 getPosition(JointBody body) const override;
+
+		/** @copydoc FJoint::getRotation */
 		Quaternion getRotation(JointBody body) const override;
+
+		/** @copydoc FJoint::setTransform */
 		void setTransform(JointBody body, const Vector3& position, const Quaternion& rotation) override;
 
+		/** @copydoc FJoint::getBreakForce */
 		float getBreakForce() const override;
+
+		/** @copydoc FJoint::setBreakForce */
 		void setBreakForce(float force) override;
 
+		/** @copydoc FJoint::getBreakTorque */
 		float getBreakTorque() const override;
+
+		/** @copydoc FJoint::setBreakTorque */
 		void setBreakTorque(float torque) override;
 
+		/** @copydoc FJoint::getEnableCollision */
 		bool getEnableCollision() const override;
+
+		/** @copydoc FJoint::setEnableCollision */
 		void setEnableCollision(bool value) override;
 
+		/** Gets the internal PhysX joint object. */
 		physx::PxJoint* _getInternal() const { return mJoint; }
 	protected:
 		physx::PxJoint* mJoint;
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsPhysXBoxCollider.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of a BoxCollider. */
 	class PhysXBoxCollider : public BoxCollider
 	{
 	public:
@@ -15,15 +20,24 @@ namespace BansheeEngine
 			const Vector3& extents);
 		~PhysXBoxCollider();
 
+		/** @copydoc BoxCollider::setScale */
 		void setScale(const Vector3& scale) override;
 
+		/** @copydoc BoxCollider::setExtents */
 		void setExtents(const Vector3& extents) override;
+
+		/** @copydoc BoxCollider::getExtents */
 		Vector3 getExtents() const override;
 
 	private:
+		/** Returns the PhysX collider implementation common to all colliders. */
 		FPhysXCollider* getInternal() const;
+
+		/** Applies the sphere geometry to the internal object based on set extents and scale. */
 		void applyGeometry();
 
 		Vector3 mExtents;
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsPhysXCapsuleCollider.h

@@ -8,6 +8,10 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
 	class PhysXCapsuleCollider : public CapsuleCollider
 	{
 	public:
@@ -31,10 +35,15 @@ namespace BansheeEngine
 		float getRadius() const override;
 
 	private:
+		/** Returns the PhysX collider implementation common to all colliders. */
 		FPhysXCollider* getInternal() const;
+
+		/** Applies the capsule geometry to the internal object based on set radius, height and scale. */
 		void applyGeometry();
 
 		float mRadius;
 		float mHalfHeight;
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsPhysXD6Joint.h

@@ -9,40 +9,78 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of a D6 joint. */
 	class BS_PHYSX_EXPORT PhysXD6Joint : public D6Joint
 	{
 	public:
 		PhysXD6Joint(physx::PxPhysics* physx);
 		~PhysXD6Joint();
 
+		/** @copydoc D6Joint::getMotion */
 		Motion getMotion(Axis axis) const override;
+
+		/** @copydoc D6Joint::setMotion */
 		void setMotion(Axis axis, Motion motion) override;
 
+		/** @copydoc D6Joint::getTwist */
 		Radian getTwist() const override;
+
+		/** @copydoc D6Joint::getSwingY */
 		Radian getSwingY() const override;
+
+		/** @copydoc D6Joint::getSwingZ */
 		Radian getSwingZ() const override;
 
+		/** @copydoc D6Joint::getLimitLinear */
 		LimitLinear getLimitLinear() const override;
+
+		/** @copydoc D6Joint::setLimitLinear */
 		void setLimitLinear(const LimitLinear& limit) override;
 
+		/** @copydoc D6Joint::getLimitTwist */
 		LimitAngularRange getLimitTwist() const override;
+
+		/** @copydoc D6Joint::setLimitTwist */
 		void setLimitTwist(const LimitAngularRange& limit) override;
 
+		/** @copydoc D6Joint::getLimitSwing */
 		LimitConeRange getLimitSwing() const override;
+
+		/** @copydoc D6Joint::setLimitSwing */
 		void setLimitSwing(const LimitConeRange& limit) override;
 
+		/** @copydoc D6Joint::getDrive */
 		Drive getDrive(DriveType type) const override;
+
+		/** @copydoc D6Joint::setDrive */
 		void setDrive(DriveType type, const Drive& drive) override;
 
+		/** @copydoc D6Joint::getDrivePosition */
 		Vector3 getDrivePosition() const override;
+
+		/** @copydoc D6Joint::getDriveRotation */
 		Quaternion getDriveRotation() const override;
+
+		/** @copydoc D6Joint::setDriveTransform */
 		void setDriveTransform(const Vector3& position, const Quaternion& rotation) override;
 
+		/** @copydoc D6Joint::getDriveLinearVelocity */
 		Vector3 getDriveLinearVelocity() const override;
+
+		/** @copydoc D6Joint::getDriveAngularVelocity */
 		Vector3 getDriveAngularVelocity() const override;
+
+		/** @copydoc D6Joint::setDriveVelocity */
 		void setDriveVelocity(const Vector3& linear, const Vector3& angular) override;
 
 	private:
+		/** Returns the internal PhysX representation of the D6 joint. */
 		inline physx::PxD6Joint* getInternal() const;
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsPhysXDistanceJoint.h

@@ -9,30 +9,54 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of a DistanceJoint */
 	class BS_PHYSX_EXPORT PhysXDistanceJoint : public DistanceJoint
 	{
 	public:
 		PhysXDistanceJoint(physx::PxPhysics* physx);
 		~PhysXDistanceJoint();
 
+		/** @copydoc DistanceJoint::getDistance */
 		float getDistance() const override;
 
+		/** @copydoc DistanceJoint::getMinDistance */
 		float getMinDistance() const override;
+
+		/** @copydoc DistanceJoint::setMinDistance */
 		void setMinDistance(float value) override;
 
+		/** @copydoc DistanceJoint::getMaxDistance */
 		float getMaxDistance() const override;
+
+		/** @copydoc DistanceJoint::setMaxDistance */
 		void setMaxDistance(float value) override;
 
+		/** @copydoc DistanceJoint::getTolerance */
 		float getTolerance() const override;
+
+		/** @copydoc DistanceJoint::setTolerance */
 		void setTolerance(float value) override;
 
+		/** @copydoc DistanceJoint::getSpring */
 		Spring getSpring() const override;
+
+		/** @copydoc DistanceJoint::setSpring */
 		void setSpring(const Spring& value) override;
 
+		/** @copydoc DistanceJoint::setFlag */
 		void setFlag(Flag flag, bool enabled) override;
+
+		/** @copydoc DistanceJoint::hasFlag */
 		bool hasFlag(Flag flag) const override;
 
 	private:
+		/** Returns the internal PhysX representation of the distance joint. */
 		inline physx::PxDistanceJoint* getInternal() const;
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsPhysXFixedJoint.h

@@ -8,10 +8,17 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of a FixedJoint. */
 	class BS_PHYSX_EXPORT PhysXFixedJoint : public FixedJoint
 	{
 	public:
 		PhysXFixedJoint(physx::PxPhysics* physx);
 		~PhysXFixedJoint();
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsPhysXHingeJoint.h

@@ -9,25 +9,45 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of a HingeJoint. */
 	class BS_PHYSX_EXPORT PhysXHingeJoint : public HingeJoint
 	{
 	public:
 		PhysXHingeJoint(physx::PxPhysics* physx);
 		~PhysXHingeJoint();
 
+		/** @copydoc HingeJoint::getAngle */
 		Radian getAngle() const override;
+
+		/** @copydoc HingeJoint::getSpeed */
 		float getSpeed() const override;
 
+		/** @copydoc HingeJoint::getLimit */
 		LimitAngularRange getLimit() const override;
+
+		/** @copydoc HingeJoint::setLimit */
 		void setLimit(const LimitAngularRange& limit) override;
 
+		/** @copydoc HingeJoint::getDrive */
 		Drive getDrive() const override;
+
+		/** @copydoc HingeJoint::setDrive */
 		void setDrive(const Drive& drive) override;
 
+		/** @copydoc HingeJoint::setFlag */
 		void setFlag(Flag flag, bool enabled) override;
+
+		/** @copydoc HingeJoint::hasFlag */
 		bool hasFlag(Flag flag) const override;
 
 	private:
+		/** Returns the internal PhysX representation of the hinge (i.e. revolute) joint. */
 		inline physx::PxRevoluteJoint* getInternal() const;
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsPhysXMaterial.h

@@ -8,24 +8,41 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of a PhysicsMesh. */
 	class PhysXMaterial : public PhysicsMaterial
 	{
 	public:
 		PhysXMaterial(physx::PxPhysics* physx, float staFric, float dynFriction, float restitution);
 		~PhysXMaterial();
 
+		/** @copydoc PhysicsMaterial::setStaticFriction */
 		void setStaticFriction(float value) override;
+
+		/** @copydoc PhysicsMaterial::getStaticFriction */
 		float getStaticFriction() const override;
 
+		/** @copydoc PhysicsMaterial::setDynamicFriction */
 		void setDynamicFriction(float value) override;
+
+		/** @copydoc PhysicsMaterial::getDynamicFriction */
 		float getDynamicFriction() const override;
 
+		/** @copydoc PhysicsMaterial::setRestitutionCoefficient */
 		void setRestitutionCoefficient(float value) override;
+
+		/** @copydoc PhysicsMaterial::getRestitutionCoefficient */
 		float getRestitutionCoefficient() const override;
 
+		/** Returns the internal PhysX material. */
 		physx::PxMaterial* _getInternal() const { return mInternal; }
 
 	private:
 		physx::PxMaterial* mInternal;
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsPhysXMesh.h

@@ -8,14 +8,29 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of a PhysicsMesh. */
 	class PhysXMesh : public PhysicsMesh
 	{
 	public:
 		PhysXMesh(const MeshDataPtr& meshData, PhysicsMeshType type);
 
+		/** @copydoc PhysicsMesh::getMeshData */
 		MeshDataPtr getMeshData() const override;
 
+		/** 
+		 * Returns the internal PhysX representation of a triangle mesh. Caller must ensure the physics mesh type is 
+		 * triangle. 
+		 */
 		physx::PxTriangleMesh* _getTriangle() const { assert(mType == PhysicsMeshType::Triangle); return mTriangleMesh; }
+
+		/** 
+		 * Returns the internal PhysX representation of a convex mesh. Caller must ensure the physics mesh type is 
+		 * convex. 
+		 */
 		physx::PxConvexMesh* _getConvex() const { assert(mType == PhysicsMeshType::Convex); return mConvexMesh; }
 
 	private:
@@ -39,4 +54,6 @@ namespace BansheeEngine
 		static RTTITypeBase* getRTTIStatic();
 		RTTITypeBase* getRTTI() const override;
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsPhysXMeshCollider.h

@@ -8,18 +8,30 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of a MeshCollider. */
 	class PhysXMeshCollider : public MeshCollider
 	{
 	public:
 		PhysXMeshCollider(physx::PxPhysics* physx, const Vector3& position, const Quaternion& rotation);
 		~PhysXMeshCollider();
 
+		/** @copydoc MeshCollider::setScale */
 		void setScale(const Vector3& scale) override;
 
 	private:
+		/** Returns the PhysX collider implementation common to all colliders. */
 		FPhysXCollider* getInternal() const;
 
+		/** @copydoc MeshCollider::onMeshChanged */
 		void onMeshChanged() override;
+
+		/** Applies mesh geometry using the set mesh and scale. */
 		void applyGeometry();
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsPhysXMeshRTTI.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @cond RTTI */
+	/** @addtogroup RTTI-Impl-PhysX
+	 *  @{
+	 */
+
 	class BS_PHYSX_EXPORT PhysXMeshRTTI : public RTTIType<PhysXMesh, PhysicsMesh, PhysXMeshRTTI>
 	{
 	private:
@@ -59,4 +64,7 @@ namespace BansheeEngine
 			return PhysicsMesh::_createPtr(nullptr, PhysicsMeshType::Convex);
 		}
 	};
+
+	/** @} */
+	/** @endcond */
 }

BansheePhysX/Include/BsPhysXPlaneCollider.h

@@ -8,6 +8,11 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of the PlaneCollider. */
 	class PhysXPlaneCollider : public PlaneCollider
 	{
 	public:
@@ -15,6 +20,9 @@ namespace BansheeEngine
 		~PhysXPlaneCollider();
 
 	private:
+		/** Returns the PhysX collider implementation common to all colliders. */
 		FPhysXCollider* getInternal() const;
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsPhysXPrerequisites.h

@@ -24,6 +24,18 @@ namespace BansheeEngine
 #	define BS_PHYSX_EXPORT
 #endif
 
+/** @addtogroup Plugins/
+
+/** @defgroup PhysX PhysX
+ *	NVIDIA PhysX implementation of Banshee's physics.
+ */
+
+/** @defgroup RTTI-Impl-PhysX RTTI types
+ *  Types containing RTTI for specific classes.
+ */
+
+/** @} */
+
 	class PhysXRigidbody;
 	class PhsyXMaterial;
 	class FPhysXCollider;

BansheePhysX/Include/BsPhysXSliderJoint.h

@@ -9,22 +9,39 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of a SliderJoint. */
 	class BS_PHYSX_EXPORT PhysXSliderJoint : public SliderJoint
 	{
 	public:
 		PhysXSliderJoint(physx::PxPhysics* physx);
 		~PhysXSliderJoint();
 
+		/** @copydoc SliderJoint::getPosition */
 		float getPosition() const override;
+
+		/** @copydoc SliderJoint::getSpeed */
 		float getSpeed() const override;
 
+		/** @copydoc SliderJoint::getLimit */
 		LimitLinearRange getLimit() const override;
+
+		/** @copydoc SliderJoint::setLimit */
 		void setLimit(const LimitLinearRange& limit) override;
 
+		/** @copydoc SliderJoint::setFlag */
 		void setFlag(Flag flag, bool enabled) override;
+
+		/** @copydoc SliderJoint::hasFlag */
 		bool hasFlag(Flag flag) const override;
 
 	private:
+		/** Returns the internal PhysX representation of the slider (i.e. prismatic) joint. */
 		inline physx::PxPrismaticJoint* getInternal() const;
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsPhysXSphereCollider.h

@@ -8,21 +8,35 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of a SphereCollider. */
 	class PhysXSphereCollider : public SphereCollider
 	{
 	public:
 		PhysXSphereCollider(physx::PxPhysics* physx, const Vector3& position, const Quaternion& rotation, float radius);
 		~PhysXSphereCollider();
 
+		/** @copydoc SphereCollider::setScale */
 		void setScale(const Vector3& scale) override;
 
+		/** @copydoc SphereCollider::setRadius */
 		void setRadius(float radius) override;
+
+		/** @copydoc SphereCollider::getRadius */
 		float getRadius() const override;
 
 	private:
+		/** Returns the PhysX collider implementation common to all colliders. */
 		FPhysXCollider* getInternal() const;
+
+		/** Applies the sphere geometry to the internal object based on set radius and scale. */
 		void applyGeometry();
 
 		float mRadius;
 	};
+
+	/** @} */
 }

BansheePhysX/Include/BsPhysXSphericalJoint.h

@@ -9,19 +9,33 @@
 
 namespace BansheeEngine
 {
+	/** @addtogroup PhysX
+	 *  @{
+	 */
+
+	/** PhysX implementation of a SphericalJoint. */
 	class BS_PHYSX_EXPORT PhysXSphericalJoint : public SphericalJoint
 	{
 	public:
 		PhysXSphericalJoint(physx::PxPhysics* physx);
 		~PhysXSphericalJoint();
 
+		/** @copydoc SphericalJoint::getLimit */
 		LimitConeRange getLimit() const override;
+
+		/** @copydoc SphericalJoint::setLimit */
 		void setLimit(const LimitConeRange& limit) override;
 
+		/** @copydoc SphericalJoint::setFlag */
 		void setFlag(Flag flag, bool enabled) override;
+
+		/** @copydoc SphericalJoint::hasFlag */
 		bool hasFlag(Flag flag) const override;
 
 	private:
+		/** Returns the internal PhysX representation of the spherical joint. */
 		inline physx::PxSphericalJoint* getInternal() const;
 	};
+
+	/** @} */
 }

BansheeUtility/Include/BsPrerequisitesUtil.h

@@ -72,6 +72,10 @@
 
 /** @} */
 
+/** @defgroup Plugins Plugins
+ *	Contains all the interchangeable high level systems that are built upon abstractions provided by the engine core.
+ */
+
 /** @defgroup Implementation Implementation
  *	Contains various base and helper types that used by an implementation of some other type. These shouldn't even be part
  *  of the class list but due to limitations in the documentation generation system they need to be somewhere. All elements