Added docs and project management tool update

doc/cw/gethingesolvelimit.txt

@@ -0,0 +1,6 @@
+#title getHingeSolveLimit [RCBasic Doc]
+#header function  getHingeSolveLimit( constraint_id)
+
+Checks whether the hinge has reached or exceeded its angular limit during the simulation. It returns a boolean or an integer value that indicates whether the current angular position is within the constraint's angular limits or if corrective forces need to be applied.
+
+The "solve limit" refers to whether the current angular position is close to or outside the defined angular limits. If the constraint detects that the hinge is at the limit, it enters a solving state, where it applies corrective forces to keep the rotation within the allowed range.

doc/cw/getslidelindepth.txt

@@ -0,0 +1,6 @@
+#title getSlideLinDepth [RCBasic Doc]
+#header function  getSlideLinDepth( constraint_id)
+
+Returns the linear depth of the slider constraint. This value indicates how much the actors connected by the slider constraint are overlapping or penetrating each other in the linear (translational) direction.
+
+The linear depth is a measure of how far the actors are penetrating each other along the linear axis defined by the slider constraint. A positive value indicates that the actors are overlapping, while a value of zero means they are in contact but not penetrating. Negative values typically imply that the actors are separated.

doc/cw/getslidelinearpos.txt

@@ -0,0 +1,6 @@
+#title getSlideLinearPos [RCBasic Doc]
+#header function  getSlideLinearPos( constraint_id)
+
+Returns the current linear position of the slider constraint along its defined axis. This position reflects how far the connected actors have moved along the slider's linear axis since the constraint was created or last reset.
+
+This value can be positive or negative, depending on the relative positions of the two bodies connected by the slider.

doc/cw/getslideloweranglimit.txt

@@ -0,0 +1,8 @@
+#title getSlideLowerAngLimit [RCBasic Doc]
+#header function  getSlideLowerAngLimit( constraint_id)
+
+Returns the lower angular limit of the constraint. This value specifies the minimum angle allowed for the rotation of the connected actors around the axis perpendicular to the sliding direction defined by the slider constraint.
+
+The lower angular limit indicates the smallest angle that the actors can rotate about the axis perpendicular to the sliding direction. If the rotation tries to exceed this limit, the physics engine will apply corrective forces to maintain the bodies within the allowed range.
+
+#ref GetSlideLowerLinLimit

doc/cw/getslidelowerlinlimit.txt

@@ -0,0 +1,8 @@
+#title getSlideLowerLinLimit [RCBasic Doc]
+#header function  getSlideLowerLinLimit( constraint_id)
+
+Returns the lower linear limit for the translational (sliding) motion along the slider's axis. This value specifies the minimum allowable position for the connected actors along the defined axis of the slider constraint.
+
+This defines the minimum translation distance along the slider’s axis that the connected actors are allowed to reach. If the actors' relative position along the axis goes below this limit, the constraint will prevent further movement.
+
+#ref SetSlideLowerLinLimit

doc/cw/getsliderestitutiondirang.txt

@@ -0,0 +1,8 @@
+#title getSlideRestitutionDirAng [RCBasic Doc]
+#header function  getSlideRestitutionDirAng( constraint_id)
+
+Returns the restitution value for angular motion. The restitution coefficient is a measure of how much energy is conserved in a collision or constraint interaction, specifically for angular movements.
+
+When actors collide or interact, their angular momentum and position can change, and the restitution value governs how much of that energy is retained after the interaction.
+
+#ref SetSlideRestitutionDirAng

doc/cw/getsliderestitutiondirlin.txt

@@ -0,0 +1,8 @@
+#title getSlideRestitutionDirLin [RCBasic Doc]
+#header function  getSlideRestitutionDirLin( constraint_id)
+
+Returns the restitution value for linear motion. This value determines how much energy is conserved in a collision or interaction involving linear movements of the connected actors.
+
+When the actors collide or interact, the restitution value dictates how much of their energy is retained after the interaction.
+
+#ref SetSlideRestitutionDirLin

doc/cw/getsliderestitutionlimang.txt

@@ -0,0 +1,8 @@
+#title getSlideRestitutionLimAng [RCBasic Doc]
+#header function  getSlideRestitutionLimAng( constraint_id)
+
+Returns the restitution value for angular limit. This value determines how much energy is conserved when the angular motion of the connected actors reaches the angular limits of the slider constraint. Essentially, it controls how "bouncy" the rotation is when it hits the angular limit of the constraint.
+
+A value of 0.0 means no bounce (perfectly inelastic), while a value of 1.0 allows maximum bounce (perfectly elastic).
+
+#ref SetSlideRestitutionLimAng

doc/cw/getsliderestitutionlimlin.txt

@@ -0,0 +1,8 @@
+#title getSlideRestitutionLimLin [RCBasic Doc]
+#header function  getSlideRestitutionLimLin( constraint_id)
+
+Returns the restitution value for the linear limit of the constraint. This value controls how much energy is conserved (or how "bouncy" the interaction is) when the connected actors reach the linear limits of the slider constraint, which restricts the movement along the sliding axis.
+
+Restitution is a measure of how much energy is retained after a collision or interaction. In this context, when the linear movement reaches the limits, restitution controls how much the actors "bounce" back. A restitution value of 0.0 means no bounce (the collision is perfectly inelastic), and 1.0 allows maximum bounce (the collision is perfectly elastic).
+
+#ref SetSlideRestitutionLimLin

doc/cw/getsliderestitutionorthoang.txt

@@ -0,0 +1,10 @@
+#title getSlideRestitutionOrthoAng [RCBasic Doc]
+#header function  getSlideRestitutionOrthoAng( constraint_id)
+
+Returns the restitution value for orthogonal angular motion. This value determines how much energy is conserved (or how "bouncy" the interaction is) when rotational movement occurs in a direction orthogonal (perpendicular) to the slider's primary axis of movement.
+
+Orthogonal Angular Motion: In the context of a slider constraint, orthogonal angular motion refers to rotational movement around axes that are perpendicular to the slider's main movement axis.
+
+Restitution: Restitution is a measure of how much energy is retained in a collision or interaction. A restitution value of 0.0 means no bounce (inelastic collision), and 1.0 means maximum bounce (elastic collision). For orthogonal angular motion, this describes how much bounce occurs after the rotational motion hits the constraints or limits in a perpendicular direction to the slider axis.
+
+#ref SetSlideRestitutionOrthoAng

doc/cw/getsliderestitutionortholin.txt

@@ -0,0 +1,10 @@
+#title getSlideRestitutionOrthoLin [RCBasic Doc]
+#header function  getSlideRestitutionOrthoLin( constraint_id)
+
+Returns the restitution value for orthogonal linear motion. This value determines how much energy is conserved (or how "bouncy" the interaction is) when linear motion occurs in a direction orthogonal (perpendicular) to the primary sliding axis of the constraint.
+
+Orthogonal Linear Motion: In the context of a slider constraint, orthogonal linear motion refers to translational movement along axes that are perpendicular to the main sliding axis of the constraint.
+
+Restitution: Restitution is a measure of how much energy is retained or conserved during a collision or interaction. A restitution value of 0.0 indicates no bounce (perfectly inelastic), while 1.0 indicates maximum bounce (perfectly elastic). For orthogonal linear motion, this value describes how much the actors bounce or retain energy when they hit limits or experience movement perpendicular to the slider’s main axis.
+
+#ref SetSlideRestitutionOrthoLin

doc/cw/getslidesoftnessdirang.txt

@@ -0,0 +1,7 @@
+#title getSlideSoftnessDirAng [RCBasic Doc]
+#header function  getSlideSoftnessDirAng( constraint_id)
+
+Returns the softness parameter for the angular motion of the constraint. This parameter is used to define how "soft" or "rigid" the limits of angular motion are, particularly when the angular limits are reached.
+
+The softness parameter defines how smoothly the constraint responds to limit violations. A higher softness value allows for more gradual movements when limits are approached, while a lower value creates a more rigid response. Softness is particularly useful in simulations to avoid harsh impacts or stiff movements when limits are reached.
+

doc/cw/getslidesoftnessdirlin.txt

@@ -0,0 +1,6 @@
+#title getSlideSoftnessDirLin [RCBasic Doc]
+#header function  getSlideSoftnessDirLin( constraint_id)
+
+Returns the softness parameter for the linear motion of the constraint. This parameter influences how the constraint responds when the linear limits of movement are reached along the sliding axis, determining whether the response is soft and gradual or more rigid.
+
+In the context of constraints, softness defines how "compliant" or "stiff" the constraint behaves when the limits are approached. A higher softness value makes the constraint respond more softly and gradually as the limit is approached, while a lower value makes the response stiffer and more rigid.

doc/cw/getslidesoftnesslimang.txt

@@ -0,0 +1,6 @@
+#title getSlideSoftnessLimAng [RCBasic Doc]
+#header function  getSlideSoftnessLimAng( constraint_id)
+
+Returns the softness parameter for the angular limits of the constraint. This parameter affects how "soft" or "rigid" the constraint behaves when the connected actors reach their angular rotational limits around the slider's axis of rotation.
+
+The softness parameter defines how compliant or stiff the constraint behaves when the motion approaches a limit. A higher softness makes the constraint more flexible, allowing for smoother motion near the limit. A lower softness makes the limit response more rigid and immediate.

doc/cw/getslidesoftnesslimlin.txt

@@ -0,0 +1,6 @@
+#title getSlideSoftnessLimLin [RCBasic Doc]
+#header function  getSlideSoftnessLimLin( constraint_id)
+
+Returns the softness parameter for the linear limits of the constraint. This parameter influences how "soft" or "rigid" the constraint behaves when the connected actors reach their linear (sliding) limits along the constraint's axis of motion.
+
+The softness parameter defines how compliant or stiff the constraint behaves when limits are approached. A higher softness value allows for a more gradual and flexible response as the limit is reached, while a lower softness value results in a stiffer and more rigid response.

doc/cw/getslidesoftnessorthoang.txt

@@ -0,0 +1,6 @@
+#title getSlideSoftnessOrthoAng [RCBasic Doc]
+#header function  getSlideSoftnessOrthoAng( constraint_id)
+
+Returns the softness parameter for the orthogonal angular limits of the constraint. This parameter controls how "soft" or "rigid" the constraint behaves when angular rotation is limited along directions orthogonal (perpendicular) to the primary axis of motion.
+
+The softness parameter defines how compliant (soft) or stiff (rigid) the constraint behaves when the bodies approach their angular or linear limits. A higher softness value makes the limit more flexible, allowing for gradual motion, while a lower value makes the limit more rigid and restrictive.

doc/cw/getslidesoftnessortholin.txt

@@ -0,0 +1,6 @@
+#title getConstraintSoftnessOrthoLin [RCBasic Doc]
+#header function  getConstraintSoftnessOrthoLin( constraint_id)
+
+Returns the softness parameter for the orthogonal linear limits of the constraint. This parameter affects how "soft" or "rigid" the constraint behaves when the connected actors approach their linear movement limits in directions that are orthogonal (perpendicular) to the primary sliding axis.
+
+The softness parameter determines how rigid or compliant the constraint is when the actors approach their movement limits. A higher softness value allows for smoother, more flexible movement near the limit, while a lower value results in a more rigid, immediate response.

doc/cw/getslidesolveanglimit.txt

@@ -0,0 +1,4 @@
+#title getSlideSolveAngLimit [RCBasic Doc]
+#header function  getSlideSolveAngLimit( constraint_id)
+
+Checks whether the angular position of the constraint has reached or exceeded its defined angular limits. It returns a value indicating if the constraint is at or beyond its lower or upper angular limit around the slider’s axis of rotation.

doc/cw/getslidesolvelinlimit.txt

@@ -0,0 +1,4 @@
+#title getSlideSolveLinLimit [RCBasic Doc]
+#header function  getSlideSolveLinLimit( constraint_id)
+
+Checks whether the linear position of the constraint has reached or exceeded its defined linear limits. It returns a value indicating if the constraint is at or beyond its lower or upper linear limit along the sliding axis.

doc/cw/getslideupperanglimit.txt

@@ -0,0 +1,6 @@
+#title getSlideUpperAngLimit [RCBasic Doc]
+#header function  getSlideUpperAngLimit( constraint_id)
+
+Returns the upper limit of the angular movement allowed for the constraint. This function is crucial for determining how much rotational freedom is allowed around the axis of rotation defined by the slider constraint.
+
+The upper angular limit specifies the maximum allowed rotation around the rotational axis for the slider constraint. If the relative rotation between the two actors exceeds this angle, corrective forces are applied to maintain the constraint and prevent further rotation.

doc/cw/getslideupperlinlimit.txt

@@ -0,0 +1,6 @@
+#title getSlideUpperLinLimit [RCBasic Doc]
+#header function  getSlideUpperLinLimit( constraint_id)
+
+Returns the upper limit for linear movement along the constraint's axis. This is a crucial function for controlling how far the connected actors can slide along that axis before the constraint enforces limits.
+
+The upper linear limit specifies the maximum distance that the connected actors can move away from each other along the slider's axis. If the relative movement exceeds this limit, the constraint will apply corrective forces to stop further movement.

doc/cw/getslideuseframeoffset.txt

@@ -0,0 +1,4 @@
+#title getSlideUseFrameOffset [RCBasic Doc]
+#header function  getSlideUseFrameOffset( constraint_id)
+
+Returns a boolean value indicating whether the constraint is using frame offsets for its linear and angular limits.