/// <summary>Set the drive angular velocity goal when it is being driven. </summary>
/// <param name="angVel">The goal angular velocity if NX_D6JOINT_DRIVE_VELOCITY is set for swingDrive or twistDrive. Range: angular velocity vector</param>
public virtual void setDriveAngularVelocity(ref NxVec3 angVel)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
NxD6Joint_setDriveAngularVelocity_INVOKE(ClassPointer, doSetFunctionPointers, ref angVel);
}
/// <summary>Set the drive position goal position when it is being driven. </summary>
/// <param name="position">The goal position if NX_D6JOINT_DRIVE_POSITION is set for xDrive,yDrive or zDrive. Range: position vector</param>
public virtual void setDrivePosition(ref NxVec3 position)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
NxD6Joint_setDrivePosition_INVOKE(ClassPointer, doSetFunctionPointers, ref position);
}
/// <summary>For internal use only. </summary>
public virtual bool evaluate(ref NxVec3 force, ref NxVec3 torque, ref NxVec3 position, ref NxVec3 velocity)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
return(NxForceFieldKernel_evaluate_INVOKE(ClassPointer, doSetFunctionPointers, ref force, ref torque, ref position, ref velocity));
}
/// <summary>Sets the two bodies which are connected by the element. </summary>
/// <param name="body1">First Body. </param>
/// <param name="global1">Attachment point for spring in the global frame. Range: position vector </param>
/// <param name="body2">Second Body </param>
/// <param name="global2">Attachment point for spring in the global frame. Range: position vector</param>
public virtual void setBodies(NxActor body1, ref NxVec3 global1, NxActor body2, ref NxVec3 global2)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
NxSpringAndDamperEffector_setBodies_INVOKE(ClassPointer, doSetFunctionPointers, (body1 != null ? body1.ClassPointer : NullRef), ref global1, (body2 != null ? body2.ClassPointer : NullRef), ref global2);
}
/// <summary>Retrieves the global space limit point. </summary>
/// <param name="worldLimitPoint">Used to store the global frame limit point. </param>
public virtual bool getLimitPoint(ref NxVec3 worldLimitPoint)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
return(NxJoint_getLimitPoint_INVOKE(ClassPointer, doSetFunctionPointers, ref worldLimitPoint));
}
/// <summary>Adds a limit plane. </summary>
/// <param name="normal">Normal for the limit plane in global coordinates. Range: direction vector </param>
/// <param name="pointInPlane">Point in the limit plane in global coordinates. Range: position vector </param>
/// <param name="restitution">Restitution of the limit plane. Range: [0.0, 1.0] Default: 0.0 </param>
public virtual bool addLimitPlane(ref NxVec3 normal, ref NxVec3 pointInPlane, float restitution)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
return(NxJoint_addLimitPlane_INVOKE(ClassPointer, doSetFunctionPointers, ref normal, ref pointInPlane, restitution));
}
/// <summary>Sets the direction of the joint's primary axis, specified in global coordinates. </summary>
/// <param name="vec">Direction of primary axis in the global frame. Range: direction vector</param>
public virtual void setGlobalAxis(ref NxVec3 vec)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
NxJoint_setGlobalAxis_INVOKE(ClassPointer, doSetFunctionPointers, ref vec);
}
/// <summary>sets the plane equation. </summary>
/// <param name="normal">Normal for the plane, in the global frame. Range: direction vector </param>
/// <param name="d">'d' coefficient of the plane equation. Range: (-inf,inf)</param>
public virtual void setPlane(ref NxVec3 normal, float d)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
NxPlaneShape_setPlane_INVOKE(ClassPointer, doSetFunctionPointers, ref normal, d);
}
/// <summary>Sets the maximal random displacement in every dimension. </summary>
/// <param name="disp">The maximal random displacment of particles.</param>
public virtual void setRandomPos(NxVec3 disp)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
NxFluidEmitter_setRandomPos_INVOKE(ClassPointer, doSetFunctionPointers, disp);
}
/// <summary>Returns the next element pointed to by the limit plane iterator, and increments the iterator. </summary>
/// <param name="planeNormal">Used to store the plane normal. </param>
/// <param name="planeD">Used to store the plane 'D'. </param>
/// <param name="restitution">Optional, used to store restitution of the limit plane. </param>
public virtual bool getNextLimitPlane(ref NxVec3 planeNormal, ref float planeD)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
return(NxJoint_getNextLimitPlane_1_INVOKE(ClassPointer, doSetFunctionPointers, ref planeNormal, ref planeD));
}
/// <summary>Sets the position of the emitter relative to the frameShape. </summary>
/// <param name="vec">The new local position of the emitter.</param>
public virtual void setLocalPosition(ref NxVec3 vec)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
NxFluidEmitter_setLocalPosition_INVOKE(ClassPointer, doSetFunctionPointers, ref vec);
}
/// <summary>This callback is called once for each wheel and sub step before the wheel constraints are setup and fed to the SDK. The values passed in the parameters can be adjusted to affect the vehicle simulation. The most interesting values are contactPosition, contactPoint, and contactNormal. The contactPosition value specifies how far on the travel distance the contactPoint was found. If you want to simulate a bumpy road, then this is the main parameter to change. It is also good to adjust the contactPoint variable, so that the wheel forces are applied in the correct position. </summary>
/// <param name="wheelShape">The WheelShape that is being processed. </param>
/// <param name="contactPoint">The contact point (in world coordinates) that is being used for the wheel. </param>
/// <param name="contactNormal">The normal of the geometry at the contact point. </param>
/// <param name="contactPosition">The distance on the spring travel distance where the wheel would end up if it was resting on the contact point. </param>
/// <param name="normalForce">The normal force on the wheel from the last simulation step. </param>
/// <param name="otherShape">The shape with which the wheel is in contact. </param>
/// <param name="otherShapeMaterialIndex">The material on the other shape in the position where the wheel is in contact. Currently has no effect on the simulation. </param>
/// <param name="otherShapeFeatureIndex">The feature on the other shape in the position where the wheel is in contact.</param>
public virtual bool onWheelContact(NxWheelShape wheelShape, ref NxVec3 contactPoint, ref NxVec3 contactNormal, ref float contactPosition, ref float normalForce, NxShape otherShape, ref ushort otherShapeMaterialIndex, uint otherShapeFeatureIndex)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
return NxUserWheelContactModify_onWheelContact_INVOKE(ClassPointer, doSetFunctionPointers, (wheelShape!=null ? wheelShape.ClassPointer : NullRef), ref contactPoint, ref contactNormal, ref contactPosition, ref normalForce, (otherShape!=null ? otherShape.ClassPointer : NullRef), ref otherShapeMaterialIndex, otherShapeFeatureIndex);
}
/// <summary>Resets controller's extents. </summary>
/// <param name="extents">The new extents for the controller. </param>
public virtual bool setExtents(ref NxVec3 extents)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
return(NxBoxController_setExtents_INVOKE(ClassPointer, doSetFunctionPointers, ref extents));
}
/// <summary>Moves the character using a "collide-and-slide" algorithm. </summary>
/// <param name="disp">a displacement vector </param>
/// <param name="activeGroups">a filtering mask for collision groups. If a bit is set, corresponding group is active. </param>
/// <param name="minDist">the minimum travelled distance to consider. If travelled distance is smaller, the character doesn't move. This is used to stop the recursive motion algorithm when remaining distance to travel is small. </param>
/// <param name="collisionFlags">returned collision flags, collection of NxControllerFlag</param>
/// <param name="sharpness">to prevent sudden height changes due to the autostep feature, the motion can be smoothed using a feedback filter. This coefficient defines the amount of smoothing. The smaller, the smoother. (1.0 means no smoothing). </param>
/// <param name="groupsMask">Alternative mask used to filter shapes, see NxScene::overlapAABBShapes(). </param>
public virtual void move(ref NxVec3 disp, uint activeGroups, float minDist, ref uint collisionFlags, float sharpness)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
NxController_move_1_INVOKE(ClassPointer, doSetFunctionPointers, ref disp, activeGroups, minDist, ref collisionFlags, sharpness);
}
/// <summary>Sets the limit point. </summary>
/// <param name="point">The limit reference point defined in the global frame. Range: position vector </param>
/// <param name="pointIsOnActor2">if true the point is attached to the second actor. Otherwise it is attached to the first.</param>
public virtual void setLimitPoint(ref NxVec3 point)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
NxJoint_setLimitPoint_1_INVOKE(ClassPointer, doSetFunctionPointers, ref point);
}
/// <summary></summary>
/// <param name="parameter">The value to write. </param>
/// <param name="object">The object to write a parameter to. </param>
/// <param name="create">Must be true at parameter creation, and should be false for all consecutive writes of the same parameter for optimal stream size. </param>
/// <param name="name">Name of the parameter. </param>
/// <param name="mask">Event group mask that this event is contained in, e.g. NX_DBG_EVENTGROUP_JOINTS. </param>
public virtual void writeParameter(ref NxVec3 parameter, System.IntPtr _object, bool create, string name, uint mask)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
NxRemoteDebugger_writeParameter_2_INVOKE(ClassPointer, doSetFunctionPointers, ref parameter, _object, create, name, mask);
}
/// <summary>Sets the constant part of force field function. </summary>
public virtual void setConstant(ref NxVec3 unknown11)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
NxForceFieldLinearKernel_setConstant_INVOKE(ClassPointer, doSetFunctionPointers, ref unknown11);
}
/// <summary>Sets the shape space direction (unit vector) of anisotropy. </summary>
/// <param name="vec">Shape space direction of anisotropy. Range: direction vector</param>
public virtual void setDirOfAnisotropy(ref NxVec3 vec)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
NxMaterial_setDirOfAnisotropy_INVOKE(ClassPointer, doSetFunctionPointers, ref vec);
}
/// <summary>Sets the box dimensions. </summary>
/// <param name="vec">The new 'radii' of the box. Range: direction vector</param>
public virtual void setDimensions(ref NxVec3 vec)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
NxBoxForceFieldShape_setDimensions_INVOKE(ClassPointer, doSetFunctionPointers, ref vec);
}
private extern static void set_NxExtendedPlane_normal_INVOKE(HandleRef classPointer, NxVec3 newvalue);
private extern static void set_NxIntegrals_COM_INVOKE(HandleRef classPointer, NxVec3 newvalue);
/// <summary></summary>
public void computeDirection(ref NxVec3 dir)
{
NxExtendedSegment_computeDirection_INVOKE(ClassPointer, doSetFunctionPointers, ref dir);
}
private extern static void NxExtendedSegment_computeDirection_INVOKE(HandleRef classPointer, System.Boolean call_explicit, [In()][Out()] ref NxVec3 dir);
private extern static void NxBoxForceFieldShape_setDimensions_INVOKE(HandleRef classPointer, System.Boolean call_explicit, [In()] ref NxVec3 vec);
private void setDimensions_virtual([In()] ref NxVec3 vec)
{
setDimensions(ref vec);
}
private extern static void set_NxRaycastHit_worldNormal_INVOKE(HandleRef classPointer, NxVec3 newvalue);
private extern static void set_NxBoxShapeDesc_dimensions_INVOKE(HandleRef classPointer, NxVec3 newvalue);
private extern static IntPtr new_NxRay_1_INVOKE(System.Boolean do_override, NxVec3 _orig, NxVec3 _dir);
private extern static void set_NxRay_dir_INVOKE(HandleRef classPointer, NxVec3 newvalue);
/// <summary></summary>
public NxRay(ref NxVec3 _orig, ref NxVec3 _dir) :
base(new_NxRay_1_INVOKE(false, _orig, _dir))
{
GC.ReRegisterForFinalize(this);
}
