Added docs and project management tool update

doc/nw/out/setconedamping.txt

@@ -0,0 +1,4 @@
+#title setConeDamping [RCBasic Doc]
+#header sub  setConeDamping( constraint_id,  damping)
+
+Returns the damping factor applied to the constraint. Damping is used to reduce the amount of oscillation or unwanted movement (such as excessive rotation or swinging) around the constrained actor's axes.

doc/nw/out/setconefixthresh.txt

@@ -0,0 +1,9 @@
+#title setConeFixThresh [RCBasic Doc]
+#header sub  setConeFixThresh( constraint_id,  fixThresh)
+
+Sets the fix threshold value associated with that constraint. This threshold is used to control how the constraint behaves when the angle of the rotation between the actors approaches the limits defined by the cone twist constraint.
+
+The fix threshold defines a limit or tolerance for how closely the angle between the two actors can approach the constraint's limits before corrective actions are taken. When the angular motion exceeds this threshold, the constraint applies corrective forces to bring the motion back within the allowed range.
+
+#ref GetConeFixThresh
+

doc/nw/out/setconstraintbreakingimpulsethreshold.txt

@@ -0,0 +1,7 @@
+#title setConstraintBreakingImpulseThreshold [RCBasic Doc]
+#header sub  setConstraintBreakingImpulseThreshold( constraint_id,  threshold)
+
+Sets the breaking impulse threshold for a given constraint. The breaking impulse threshold defines the maximum force (impulse) a constraint can withstand before it "breaks," meaning that the constraint will be deactivated and no longer enforce its rules.
+
+#ref GetConstraintBreakingImpulseThreshold
+

doc/nw/out/setconstraintframes.txt

@@ -0,0 +1,6 @@
+#title setConstraintFrames [RCBasic Doc]
+#header sub  setConstraintFrames( constraint_id,  frameA_matrix,  frameB_matrix)
+
+Defines the reference frames for the constraint. This function establishes how the constraint is oriented in the local coordinate systems of the connected actors.
+
+The reference frames define the orientation and position of the constraint relative to each of the connected actors. Each actor can have its own local coordinate system, and the frames help establish how the constraint interacts with these systems.

doc/nw/out/setconstraintsolveriterations.txt

@@ -0,0 +1,4 @@
+#title setConstraintSolverIterations [RCBasic Doc]
+#header sub  setConstraintSolverIterations( constraint_id,  num)
+
+Sets the value for the number of solver iterations that have been overridden for a specific constraint or actor. Solver iterations refer to the number of times the physics engine solves for constraint forces during each simulation step.

doc/nw/out/sethingeaxis.txt

@@ -0,0 +1,7 @@
+#title setHingeAxis [RCBasic Doc]
+#header sub  setHingeAxis( constraint_id,  x,  y,  z)
+
+Defines the axis of rotation around which the hinge constraint allows the connected actors to rotate. This function is essential for establishing how the two actors will interact in terms of rotational motion.
+
+The axis of rotation defines the direction in which the hinge can rotate. For example, if you want a door to swing open, you would set the axis to be perpendicular to the plane of the door and aligned with the hinge line.
+

doc/nw/out/setpointpivota.txt

@@ -0,0 +1,6 @@
+#title setPointPivotA [RCBasic Doc]
+#header sub  setPointPivotA( constraint_id,  x,  y,  z)
+
+Sets the pivot point on the first actor (Body A) of the constraint. This pivot point defines the specific location in the local space of Body A where the point-to-point constraint is anchored.
+
+#ref GetPointPivotA SetPointPivotB

doc/nw/out/setpointpivotb.txt

@@ -0,0 +1,7 @@
+#title setPointPivotB [RCBasic Doc]
+#header sub  setPointPivotB( constraint_id,  x,  y,  z)
+
+Sets the pivot point on the second actor (Body B) of the constraint. This pivot point defines the specific location in the local space of Body B where the point-to-point constraint is anchored.
+
+#ref GetPointPivotA SetPointPivotB
+

doc/nw/out/setslidedampingdirang.txt

@@ -0,0 +1,6 @@
+#title setSlideDampingDirAng [RCBasic Doc]
+#header sub  setSlideDampingDirAng( constraint_id,  n)
+
+Sets the angular directional damping value. This damping factor specifically affects angular motion in the direction of movement along the constraint's axes.
+
+

doc/nw/out/setslidedampingdirlin.txt

@@ -0,0 +1,5 @@
+#title setSlideDampingDirLin [RCBasic Doc]
+#header sub  setSlideDampingDirLin( constraint_id,  n)
+
+Sets the linear directional damping value for a constraint. This value applies to the linear (translational) motion of an object along the constraint's axis of movement.
+

doc/nw/out/setslidedampinglimang.txt

@@ -0,0 +1,8 @@
+#title setSlideDampingLimAng [RCBasic Doc]
+#header sub  setSlideDampingLimAng( constraint_id,  n)
+
+Sets the angular limit damping factor for a constraint. This damping applies specifically to the angular motion of an object when it reaches the limit of its allowed rotational range.
+
+
+#ref GetSlideDampingLimAng
+

doc/nw/out/setslidedampinglimlin.txt

@@ -0,0 +1,7 @@
+#title setSlideDampingLimLin [RCBasic Doc]
+#header sub  setSlideDampingLimLin( constraint_id,  n)
+
+Sets the linear limit damping factor for a constraint. This damping applies specifically to the linear (translational) motion of an object when it reaches the limit of its allowed range of movement along a specific axis.
+
+#ref GetSlideDampingLimLin
+

doc/nw/out/setslidedampingorthoang.txt

@@ -0,0 +1,6 @@
+#title setSlideDampingOrthoAng [RCBasic Doc]
+#header sub  setSlideDampingOrthoAng( constraint_id,  n)
+
+Sets the orthogonal angular damping factor applied to a constraint. This damping affects angular (rotational) motion that occurs perpendicular to the primary axis of movement defined by the constraint.
+
+#ref GetSlideDampingOrthoAng

doc/nw/out/setslidedampingortholin.txt

@@ -0,0 +1,6 @@
+#title setSlideDampingOrthoLin [RCBasic Doc]
+#header sub  setSlideDampingOrthoLin( constraint_id,  n)
+
+Sets the orthogonal linear damping factor for a constraint. This damping affects the linear (translational) motion of an object that occurs perpendicular to the primary direction of movement defined by the constraint.
+
+#ref GetSlideDampingOrthoLin

doc/nw/out/setslideloweranglimit.txt

@@ -0,0 +1,8 @@
+#title SetSlideLowerAngLimit [RCBasic Doc]
+#header sub  SetSlideLowerAngLimit( constraint_id,  n)
+
+Sets 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 GetSlideLowerAngLimit

doc/nw/out/setslidelowerlinlimit.txt

@@ -0,0 +1,8 @@
+#title setSlideLowerLinLimit [RCBasic Doc]
+#header sub  setSlideLowerLinLimit( constraint_id,  n)
+
+Sets 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 GetSlideLowerLinLimit

doc/nw/out/setsliderestitutiondirang.txt

@@ -0,0 +1,8 @@
+#title setSlideRestitutionDirAng [RCBasic Doc]
+#header sub  setSlideRestitutionDirAng( constraint_id,  n)
+
+Sets 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 GetSlideRestitutionDirAng

doc/nw/out/setsliderestitutiondirlin.txt

@@ -0,0 +1,8 @@
+#title setSlideRestitutionDirLin [RCBasic Doc]
+#header sub  setSlideRestitutionDirLin( constraint_id,  n)
+
+Sets 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/nw/out/setsliderestitutionlimang.txt

@@ -0,0 +1,8 @@
+#title setSlideRestitutionLimAng [RCBasic Doc]
+#header sub  setSlideRestitutionLimAng( constraint_id,  n)
+
+Sets 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 GetSlideRestitutionLimAng

doc/nw/out/setsliderestitutionlimlin.txt

@@ -0,0 +1,8 @@
+#title setSlideRestitutionLimLin [RCBasic Doc]
+#header sub  setSlideRestitutionLimLin( constraint_id,  n)
+
+Sets 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 GetSlideRestitutionLimLin

doc/nw/out/setsliderestitutionorthoang.txt

@@ -0,0 +1,10 @@
+#title setSlideRestitutionOrthoAng [RCBasic Doc]
+#header sub  setSlideRestitutionOrthoAng( constraint_id,  n)
+
+Sets 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 GetSlideRestitutionOrthoAng

doc/nw/out/setsliderestitutionortholin.txt

@@ -0,0 +1,10 @@
+#title setSlideRestitutionOrthoLin [RCBasic Doc]
+#header sub  setSlideRestitutionOrthoLin( constraint_id,  n)
+
+Sets 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 GetSlideRestitutionOrthoLin

doc/nw/out/setslidesoftnessdirang.txt

@@ -0,0 +1,8 @@
+#title setSlideSoftnessDirAng [RCBasic Doc]
+#header sub  setSlideSoftnessDirAng( constraint_id,  n)
+
+Sets 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.
+
+#ref GetSlideSoftnessDirAng

doc/nw/out/setslidesoftnessdirlin.txt

@@ -0,0 +1,8 @@
+#title setConstraintSoftnessDirLin [RCBasic Doc]
+#header sub  setConstraintSoftnessDirLin( constraint_id,  n)
+
+Sets 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.
+
+#ref GetSlideSoftnessDirLin

doc/nw/out/setslidesoftnesslimang.txt

@@ -0,0 +1,8 @@
+#title setSlideSoftnessLimAng [RCBasic Doc]
+#header sub  setSlideSoftnessLimAng( constraint_id,  n)
+
+Sets 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.
+
+#ref GetSlideSoftnessLimAng

doc/nw/out/setslidesoftnesslimlin.txt

@@ -0,0 +1,8 @@
+#title setSlideSoftnessLimLin [RCBasic Doc]
+#header sub  setSlideSoftnessLimLin( constraint_id,  n)
+
+Sets 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.
+
+#ref GetSlideSoftnessLimLin

doc/nw/out/setslidesoftnessorthoang.txt

@@ -0,0 +1,8 @@
+#title setSlideSoftnessOrthoAng [RCBasic Doc]
+#header sub  setSlideSoftnessOrthoAng( constraint_id,  n)
+
+Sets 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.
+
+#ref GetSlideSoftnessOrthoAng

doc/nw/out/setslidesoftnessortholin.txt

@@ -0,0 +1,8 @@
+#title setConstraintSoftnessOrthoLin [RCBasic Doc]
+#header sub  setSlideSoftnessOrthoLin( constraint_id,  n)
+
+Sets 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.
+
+#ref GetSlideSoftnessOrthoLin

doc/nw/out/setslideupperanglimit.txt

@@ -0,0 +1,6 @@
+#title setSlideUpperAngLimit [RCBasic Doc]
+#header sub  setSlideUpperAngLimit( constraint_id,  n)
+
+Sets 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/nw/out/setslideupperlinlimit.txt

@@ -0,0 +1,6 @@
+#title setSlideUpperLinLimit [RCBasic Doc]
+#header sub  setSlideUpperLinLimit( constraint_id,  n)
+
+Sets 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/nw/setconstraintaxis.txt

@@ -0,0 +1,4 @@
+#title setConstraintAxis [RCBasic Doc]
+#header sub  setConstraintAxis( constraint_id,  x,  y,  z)
+
+

doc/nw/setconstraintbreakingimpulsethreshold.txt

@@ -0,0 +1,7 @@
+#title setConstraintBreakingImpulseThreshold [RCBasic Doc]
+#header sub  setConstraintBreakingImpulseThreshold( constraint_id,  threshold)
+
+Sets the breaking impulse threshold for a given constraint. The breaking impulse threshold defines the maximum force (impulse) a constraint can withstand before it "breaks," meaning that the constraint will be deactivated and no longer enforce its rules.
+
+#ref GetConstraintBreakingImpulseThreshold
+

doc/nw/setconstraintdamping.txt

@@ -0,0 +1,8 @@
+#title setConstraintDamping [RCBasic Doc]
+#header sub  setConstraintDamping( constraint_id,  damping)
+
+Returns the damping factor applied to the constraint. Damping is used to reduce the amount of oscillation or unwanted movement (such as excessive rotation or swinging) around the constrained actor's axes.
+
+Note: Only applies to cone constraint
+
+# SetConstraintDamping

doc/nw/setconstraintdampingdirang.txt

@@ -0,0 +1,8 @@
+#title setConstraintDampingDirAng [RCBasic Doc]
+#header sub  setConstraintDampingDirAng( constraint_id,  n)
+
+Returns the angular directional damping value. This damping factor specifically affects angular motion in the direction of movement along the constraint's axes.
+
+Note: Only applies to slider constraint
+
+#ref SetConstraintDampingDirAng

doc/nw/setconstraintdampingdirlin.txt

@@ -0,0 +1,8 @@
+#title setConstraintDampingDirLin [RCBasic Doc]
+#header sub  setConstraintDampingDirLin( constraint_id,  n)
+
+Sets the linear directional damping value for a constraint. This value applies to the linear (translational) motion of an object along the constraint's axis of movement.
+
+Note: Only applies to slide constraints
+
+#ref SetConstraintDampingDirLin

doc/nw/setconstraintdampinglimang.txt

@@ -0,0 +1,9 @@
+#title setConstraintDampingLimAng [RCBasic Doc]
+#header sub  setConstraintDampingLimAng( constraint_id,  n)
+
+Sets the angular limit damping factor for a constraint. This damping applies specifically to the angular motion of an object when it reaches the limit of its allowed rotational range.
+
+Note: Only applies to slide constraint
+
+#ref GetConstraintDampingLimAng
+

doc/nw/setconstraintdampinglimlin.txt

@@ -0,0 +1,9 @@
+#title setConstraintDampingLimLin [RCBasic Doc]
+#header sub  setConstraintDampingLimLin( constraint_id,  n)
+
+Sets the linear limit damping factor for a constraint. This damping applies specifically to the linear (translational) motion of an object when it reaches the limit of its allowed range of movement along a specific axis.
+
+Note: Only applies to slide constraint
+
+#ref GetConstraintDampingLimLin
+

doc/nw/setconstraintdampingorthoang.txt

@@ -0,0 +1,8 @@
+#title setConstraintDampingOrthoAng [RCBasic Doc]
+#header sub  setConstraintDampingOrthoAng( constraint_id,  n)
+
+Sets the orthogonal angular damping factor applied to a constraint. This damping affects angular (rotational) motion that occurs perpendicular to the primary axis of movement defined by the constraint.
+
+Note: Only applies to slide constraint
+
+#ref GetConstraintDampingOrthoAng

doc/nw/setconstraintdampingortholin.txt

@@ -0,0 +1,8 @@
+#title setConstraintDampingOrthoLin [RCBasic Doc]
+#header sub  setConstraintDampingOrthoLin( constraint_id,  n)
+
+Sets the orthogonal linear damping factor for a constraint. This damping affects the linear (translational) motion of an object that occurs perpendicular to the primary direction of movement defined by the constraint.
+
+Note: Only applies to slide constraint
+
+#ref SetConstraintDampingOrthoLin

doc/nw/setconstraintfixthresh.txt

@@ -0,0 +1,9 @@
+#title setConstraintFixThresh [RCBasic Doc]
+#header sub  setConstraintFixThresh( constraint_id,  fixThresh)
+
+Sets the fix threshold value associated with that constraint. This threshold is used to control how the constraint behaves when the angle of the rotation between the actors approaches the limits defined by the cone twist constraint.
+
+The fix threshold defines a limit or tolerance for how closely the angle between the two actors can approach the constraint's limits before corrective actions are taken. When the angular motion exceeds this threshold, the constraint applies corrective forces to bring the motion back within the allowed range.
+
+#ref GetConstraintFixThresh
+

doc/nw/setconstraintframes.txt

@@ -0,0 +1,4 @@
+#title setConstraintFrames [RCBasic Doc]
+#header sub  setConstraintFrames( constraint_id,  frameA_matrix,  frameB_matrix)
+
+

doc/nw/setconstraintloweranglimit.txt

@@ -0,0 +1,4 @@
+#title setConstraintLowerAngLimit [RCBasic Doc]
+#header sub  setConstraintLowerAngLimit( constraint_id,  n)
+
+

doc/nw/setconstraintlowerlinlimit.txt

@@ -0,0 +1,4 @@
+#title setConstraintLowerLinLimit [RCBasic Doc]
+#header sub  setConstraintLowerLinLimit( constraint_id,  n)
+
+

doc/nw/setconstraintpivota.txt

@@ -0,0 +1,4 @@
+#title setConstraintPivotA [RCBasic Doc]
+#header sub  setConstraintPivotA( constraint_id,  x,  y,  z)
+
+

doc/nw/setconstraintpivotb.txt

@@ -0,0 +1,4 @@
+#title setConstraintPivotB [RCBasic Doc]
+#header sub  setConstraintPivotB( constraint_id,  x,  y,  z)
+
+

doc/nw/setconstraintrestitutiondirang.txt

@@ -0,0 +1,4 @@
+#title setConstraintRestitutionDirAng [RCBasic Doc]
+#header sub  setConstraintRestitutionDirAng( constraint_id,  n)
+
+

doc/nw/setconstraintrestitutiondirlin.txt

@@ -0,0 +1,4 @@
+#title setConstraintRestitutionDirLin [RCBasic Doc]
+#header sub  setConstraintRestitutionDirLin( constraint_id,  n)
+
+

doc/nw/setconstraintrestitutionlimang.txt

@@ -0,0 +1,4 @@
+#title setConstraintRestitutionLimAng [RCBasic Doc]
+#header sub  setConstraintRestitutionLimAng( constraint_id,  n)
+
+

doc/nw/setconstraintrestitutionlimlin.txt

@@ -0,0 +1,4 @@
+#title setConstraintRestitutionLimLin [RCBasic Doc]
+#header sub  setConstraintRestitutionLimLin( constraint_id,  n)
+
+

doc/nw/setconstraintrestitutionorthoang.txt

@@ -0,0 +1,4 @@
+#title setConstraintRestitutionOrthoAng [RCBasic Doc]
+#header sub  setConstraintRestitutionOrthoAng( constraint_id,  n)
+
+

doc/nw/setconstraintrestitutionortholin.txt

@@ -0,0 +1,4 @@
+#title setConstraintRestitutionOrthoLin [RCBasic Doc]
+#header sub  setConstraintRestitutionOrthoLin( constraint_id,  n)
+
+

doc/nw/setconstraintsoftnessdirang.txt

@@ -0,0 +1,4 @@
+#title setConstraintSoftnessDirAng [RCBasic Doc]
+#header sub  setConstraintSoftnessDirAng( constraint_id,  n)
+
+

doc/nw/setconstraintsoftnessdirlin.txt

@@ -0,0 +1,4 @@
+#title setConstraintSoftnessDirLin [RCBasic Doc]
+#header sub  setConstraintSoftnessDirLin( constraint_id,  n)
+
+

doc/nw/setconstraintsoftnesslimang.txt

@@ -0,0 +1,4 @@
+#title setConstraintSoftnessLimAng [RCBasic Doc]
+#header sub  setConstraintSoftnessLimAng( constraint_id,  n)
+
+

doc/nw/setconstraintsoftnesslimlin.txt

@@ -0,0 +1,4 @@
+#title setConstraintSoftnessLimLin [RCBasic Doc]
+#header sub  setConstraintSoftnessLimLin( constraint_id,  n)
+
+

doc/nw/setconstraintsoftnessorthoang.txt

@@ -0,0 +1,4 @@
+#title setConstraintSoftnessOrthoAng [RCBasic Doc]
+#header sub  setConstraintSoftnessOrthoAng( constraint_id,  n)
+
+

doc/nw/setconstraintsoftnessortholin.txt

@@ -0,0 +1,4 @@
+#title setConstraintSoftnessOrthoLin [RCBasic Doc]
+#header sub  setConstraintSoftnessOrthoLin( constraint_id,  n)
+
+

doc/nw/setconstraintsolveriterations.txt

@@ -0,0 +1,4 @@
+#title setConstraintSolverIterations [RCBasic Doc]
+#header sub  setConstraintSolverIterations( constraint_id,  num)
+
+

doc/nw/setconstraintupperanglimit.txt

@@ -0,0 +1,4 @@
+#title setConstraintUpperAngLimit [RCBasic Doc]
+#header sub  setConstraintUpperAngLimit( constraint_id,  n)
+
+

doc/nw/setconstraintupperlinlimit.txt

@@ -0,0 +1,4 @@
+#title setConstraintUpperLinLimit [RCBasic Doc]
+#header sub  setConstraintUpperLinLimit( constraint_id,  n)
+
+

doc/nw/setsliderestitutionortholin.txt

@@ -0,0 +1,10 @@
+#title setSlideRestitutionOrthoLin [RCBasic Doc]
+#header sub  setSlideRestitutionOrthoLin( constraint_id,  n)
+
+Sets 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 GetSlideRestitutionOrthoLin