/// <summary>Scales an existing cooked convex mesh and outputs it into another stream. </summary>
/// <param name="source">The source cooked convex mesh to scale. </param>
/// <param name="scale">The uniform scale factor to apply to the convex mesh. </param>
/// <param name="dest">User stream to output the cooked data. </param>
public virtual bool NxScaleCookedConvexMesh(NxStream source, float scale, NxStream dest)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
return(NxCookingInterface_NxScaleCookedConvexMesh_INVOKE(ClassPointer, doSetFunctionPointers, (source != null ? source.ClassPointer : NullRef), scale, (dest != null ? dest.ClassPointer : NullRef)));
}
/// <summary>Cooks a tetrahedral mesh to a SoftBodyMesh. </summary>
/// <param name="desc">The soft body mesh descriptor on which the generation of the cooked mesh depends. </param>
/// <param name="stream">The stream the cooked mesh is written to. </param>
public virtual bool NxCookSoftBodyMesh(NxSoftBodyMeshDesc desc, NxStream stream)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
return(NxCookingInterface_NxCookSoftBodyMesh_INVOKE(ClassPointer, doSetFunctionPointers, (desc != null ? desc.ClassPointer : NullRef), (stream != null ? stream.ClassPointer : NullRef)));
}
/// <summary>Called to write an array of bytes to the stream. </summary>
/// <param name="buffer">Array of bytes, size bytes in size. </param>
/// <param name="size">Size, in bytes of buffer. </param>
public virtual NxStream storeBuffer(System.IntPtr buffer, uint size)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
return(NxStream.GetClass(NxStream_storeBuffer_INVOKE(ClassPointer, doSetFunctionPointers, buffer, size)));
}
/// <summary>Load the triangle mesh from a stream. </summary>
/// <param name="stream">Stream to load triangle mesh from. </param>
public virtual bool load(NxStream stream)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
return(NxTriangleMesh_load_INVOKE(ClassPointer, doSetFunctionPointers, (stream != null ? stream.ClassPointer : NullRef)));
}
/// <summary>Called to write a double precision floating point value to the stream(64 bits). </summary>
/// <param name="f">floating point value to store. </param>
public virtual NxStream storeDouble(double f)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
return(NxStream.GetClass(NxStream_storeDouble_INVOKE(ClassPointer, doSetFunctionPointers, f)));
}
/// <summary>Creates a soft body mesh from a cooked soft body mesh stored in a stream. </summary>
public virtual NxSoftBodyMesh createSoftBodyMesh(NxStream stream)
{
if (doSetFunctionPointers)
{
throw new System.NotSupportedException("Cannot call abstract base member");
}
return(NxSoftBodyMesh.GetClass(NxPhysicsSDK_createSoftBodyMesh_INVOKE(ClassPointer, doSetFunctionPointers, (stream != null ? stream.ClassPointer : NullRef))));
}
private bool NxScaleCookedConvexMesh_virtual(IntPtr source, float scale, IntPtr dest)
{
return(NxScaleCookedConvexMesh(NxStream.GetClass(source), scale, NxStream.GetClass(dest)));
}
private bool NxCookSoftBodyMesh_virtual(IntPtr desc, IntPtr stream)
{
return(NxCookSoftBodyMesh(NxSoftBodyMeshDesc.GetClass(desc), NxStream.GetClass(stream)));
}
private bool NxCookTriangleMesh_virtual(IntPtr desc, IntPtr stream)
{
return(NxCookTriangleMesh(NxTriangleMeshDesc.GetClass(desc), NxStream.GetClass(stream)));
}
private bool load_virtual(IntPtr stream)
{
return(load(NxStream.GetClass(stream)));
}
/// <summary>Store a signed dword(wrapper for the unsigned version). </summary>
/// <param name="d">DWord to store. </param>
public NxStream storeDword(int d)
{
return(NxStream.GetClass(NxStream_storeDword_1_INVOKE(ClassPointer, doSetFunctionPointers, d)));
}
/// <summary>Store a signed word(wrapper for the unsigned version). </summary>
/// <param name="w">Word to store. </param>
public NxStream storeWord(short w)
{
return(NxStream.GetClass(NxStream_storeWord_1_INVOKE(ClassPointer, doSetFunctionPointers, w)));
}
/// <summary>Store a signed byte(wrapper for the unsigned version). </summary>
/// <param name="b">Byte to store. </param>
public NxStream storeByte(sbyte b)
{
return(NxStream.GetClass(NxStream_storeByte_1_INVOKE(ClassPointer, doSetFunctionPointers, b)));
}
private IntPtr createSoftBodyMesh_virtual(IntPtr stream)
{
return(createSoftBodyMesh(NxStream.GetClass(stream)).ClassPointer.Handle);
}
private IntPtr createConvexMesh_virtual(IntPtr mesh)
{
return(createConvexMesh(NxStream.GetClass(mesh)).ClassPointer.Handle);
}
