Blast 1.1.3. See docs/release_notes.txt.v1.1.3_rc1

1 files changed, 587 insertions, 587 deletions

diff --git a/examples/UnityExample/Assets/Plugins/Blast/NvBlastWrapper.cs b/examples/UnityExample/Assets/Plugins/Blast/NvBlastWrapper.cs
index ccda6c4..13822f8 100644..100755
--- a/examples/UnityExample/Assets/Plugins/Blast/NvBlastWrapper.cs
+++ b/examples/UnityExample/Assets/Plugins/Blast/NvBlastWrapper.cs
@@ -1,587 +1,587 @@
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Runtime.InteropServices;
-using UnityEngine;
-using UnityEngine.Assertions;
-
-public struct NvBlastChunkDesc
-{
-    public enum Flags
-    {
-        NoFlags = 0,
-        SupportFlag = (1 << 0)
-    };
-
-    /** Central position in chunk. */
-    public Single c0;
-    public Single c1;
-    public Single c2;
-
-
-    /** Volume of chunk. */
-    public Single volume;
-
-    /** Index of this chunk's parent.  If this is a root chunk, then this value must be UINT32_MAX. */
-    public UInt32 parentChunkIndex;
-
-    /** See Flags enum for possible flags. */
-    public UInt32 flags;
-
-    /** User-supplied data which will be accessible to the user in chunk fracture events. */
-    public UInt32 userData;
-}
-
-public struct NvBlastBond
-{
-    public Single n0;
-    public Single n1;
-    public Single n2;
-
-    public Single area;
-
-    public Single c0;
-    public Single c1;
-    public Single c2;
-
-    UInt32 userData;
-};
-
-public struct NvBlastBondDesc
-{
-    /** The indices of the chunks linked by this bond.  They must be different support chunk indices. */
-    public UInt32 chunk0;
-    public UInt32 chunk1;
-
-    /** Bond data (see NvBlastBond). */
-    public NvBlastBond bond;
-}
-
-[StructLayout(LayoutKind.Sequential)]
-public class NvBlastAssetDesc
-{
-    public UInt32 chunkCount;
-    public NvBlastChunkDesc[] chunkDescs;
-    public UInt32 bondCount;
-    public NvBlastBondDesc[] bondDescs;
-}
-
-/**
-Actor descriptor, used to create an instance of an NvBlastAsset with NvBlastActorCreate
-    6
-See NvBlastActorCreate.
-*/
-[StructLayout(LayoutKind.Sequential)]
-public class NvBlastActorDesc
-{
-    /**
-	Initial health of all bonds, if initialBondHealths is NULL (see initialBondHealths).
-	*/
-    public Single uniformInitialBondHealth;
-
-    /**
-	Initial bond healths.  If not NULL, this array must be of length NvBlastAssetGetChunkCount(asset, ... ).
-	If NULL, uniformInitialBondHealth must be set.
-	*/
-    public Single[] initialBondHealths = null;
-
-    /**
-	Initial health of all lower-support chunks, if initialSupportChunkHealths is NULL (see initialSupportChunkHealths).
-	*/
-    public Single uniformInitialLowerSupportChunkHealth;
-
-    /**
-	Initial health of all support chunks.  If not NULL, this must be of length
-	NvBlastAssetGetSupportGraph(asset, ... ).nodeCount. The elements in the initialSupportChunkHealth
-	array will correspond to the chunk indices in the NvBlastAssetGetSupportGraph(asset, ... ).chunkIndices
-	array.  Every descendent of a support chunk will have its health initialized to its ancestor support
-	chunk's health, so this initializes all lower-support chunk healths.
-	If NULL, uniformInitialLowerSupportChunkHealth must be set.
-	*/
-    public Single[] initialSupportChunkHealths = null;
-};
-
-
-public struct NvBlastChunk
-{
-    /**
-	Central position for the chunk's volume
-	*/
-    public Single c0;
-    public Single c1;
-    public Single c2;
-
-    /**
-	Volume of the chunk
-	*/
-    public Single volume;
-
-    /**
-	Index of parent (UINT32_MAX denotes no parent)
-	*/
-    public UInt32 parentChunkIndex;
-
-    /**
-	Index of first child
-	*/
-    public UInt32 firstChildIndex;
-
-    /**
-	Stop for child indices
-	*/
-    public UInt32 childIndexStop;
-
-    /**
-	Field for user to associate with external data
-	*/
-    public UInt32 userData;
-};
-
-public struct NvBlastChunkGraph
-{
-    UInt32 nodeCount;
-    public IntPtr chunkIndices;
-    public IntPtr adjacencyPartition;
-    public IntPtr adjacentNodeIndices;
-    public IntPtr adjacentBondIndices;
-};
-
-[StructLayout(LayoutKind.Sequential)]
-public class NvBlastTimers
-{
-    public Int64 material;       //!< Time spent in material function
-    public Int64 fracture;       //!< Time spent applying damage
-    public Int64 island;     //!< Time spent discovering islands
-    public Int64 partition;      //!< Time spent partitioning the graph
-    public Int64 visibility;	//!< Time spent updating visibility
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-//	Types used for damage and fracturing
-///////////////////////////////////////////////////////////////////////////////
-
-public struct NvBlastChunkFractureData
-{
-    public UInt32 userdata;  //!<	chunk's user data
-    public UInt32 chunkIndex;    //!<	asset chunk index
-    public Single health;		//!<	health value (damage or remains)
-};
-
-public struct NvBlastBondFractureData
-{
-    public UInt32 userdata;  //!<	bond's user data
-    public UInt32 nodeIndex0;    //!<	graph node index of bond
-    public UInt32 nodeIndex1;    //!<	pair graph node index of bond
-    public Single health;		//!<	health value (damage or remains)
-};
-
-[StructLayout(LayoutKind.Sequential)]
-public class NvBlastFractureBuffers
-{
-    public UInt32 bondFractureCount;
-    public UInt32 chunkFractureCount;
-    public IntPtr bondFractures;        // NvBlastBondFractureData[]
-    public IntPtr chunkFractures;       // NvBlastChunkFractureData[]
-};
-
-[StructLayout(LayoutKind.Sequential)]
-public class NvBlastActorSplitEvent
-{
-    public IntPtr deletedActor; //!<	deleted actor or nullptr if actor has not changed
-    public IntPtr newActors;		//!<	list of created actors
-};
-
-[StructLayout(LayoutKind.Sequential)]
-public class NvBlastGraphShaderActor
-{
-    UInt32 firstGraphNodeIndex;   //<!	Entry index for graphNodeIndexLinks
-    public UInt32[] graphNodeIndexLinks;    //<!	Linked index list of connected nodes.  Traversable with nextIndex = graphNodeIndexLinks[currentIndex], terminates with 0xFFFFFFFF.
-    public UInt32[] chunkIndices;           //<!	Graph's map from node index to support chunk index.
-    public UInt32[] adjacencyPartition;     //<!	See NvBlastChunkGraph::adjacencyPartition.
-    public UInt32[] adjacentNodeIndices;    //<!	See NvBlastChunkGraph::adjacentNodeIndices.
-    public UInt32[] adjacentBondIndices;    //<!	See NvBlastChunkGraph::adjacentBondIndices.
-    public NvBlastBond[] assetBonds;              //<!	NvBlastBonds geometry in the NvBlastAsset.
-    public Single[] familyBondHealths;	//<!	Actual bond health values for broken bond detection.
-};
-
-[StructLayout(LayoutKind.Sequential)]
-public class NvBlastProgramParams
-{
-    public IntPtr damageDescBuffer;   //!<	array of damage descriptions
-    public UInt32 damageDescCount; //!<	number of damage descriptions in array
-    public IntPtr material;			//!<	pointer to material
-};
-
-[StructLayout(LayoutKind.Sequential)]
-public class NvBlastSubgraphShaderActor
-{
-    public UInt32 chunkIndex;        //<!	Index of chunk represented by this actor.
-    public NvBlastChunk[] assetChunks;	//<!	NvBlastChunks geometry in the NvBlastAsset.
-};
-
-public struct NvBlastDamageProgram
-{
-    public delegate void NvBlastGraphShaderFunction(System.IntPtr commandBuffers, System.IntPtr actor, System.IntPtr p);
-    public delegate void NvBlastSubgraphShaderFunction(NvBlastFractureBuffers commandBuffers, NvBlastSubgraphShaderActor actor, NvBlastProgramParams p);
-
-    public NvBlastGraphShaderFunction graphShaderFunction;
-    public NvBlastSubgraphShaderFunction subgraphShaderFunction;
-};
-
-
-public class NvBlastWrapper
-{
-    //////// DLL ////////
-
-    public const string DLL_POSTFIX = "DEBUG"; //DEBUG
-    public const string DLL_PLATFORM = "x64";
-    public const string DLL_NAME = "NvBlast" + DLL_POSTFIX + "_" + DLL_PLATFORM;
-
-
-    //////// Internal Types ////////
-
-    public delegate IntPtr NvBlastAlloc(Int64 size);
-    public delegate void NvBlastFree(IntPtr ptr);
-    public delegate void NvBlastLog(Int32 type, string msg, string file, Int32 line);
-
-
-    //////// Public Types ////////
-
-
-
-    //////// Helpers ////////
-
-    public static IntPtr Alloc(Int64 size)
-    {
-        return Marshal.AllocHGlobal((Int32)size);
-    }
-
-    public static void Free(IntPtr ptr)
-    {
-        Marshal.FreeHGlobal(ptr);
-    }
-
-    public static void Log(Int32 type, string msg, string file, Int32 line)
-    {
-        Debug.Log(DLL_NAME + ": [" + type + "] " + msg + "(" + file + ":" + line + ")");
-    }
-
-    public static IntPtr GetScratch(int size)
-    {
-        return _greedyScratch.GetScratch(size);
-    }
-
-    private static GreedyScratch _greedyScratch = new GreedyScratch();
-}
-
-
-public class GreedyScratch : IDisposable
-{
-    public IntPtr GetScratch(int size)
-    {
-        if (_size < size)
-        {
-            releaseScratch();
-            _scratch = Marshal.AllocHGlobal(size);
-            _size = size;
-        }
-
-        return _scratch;
-    }
-
-    private void releaseScratch()
-    {
-        if (_size > 0)
-        {
-            Marshal.FreeHGlobal(_scratch);
-            _scratch = IntPtr.Zero;
-        }
-    }
-
-    public void Dispose()
-    {
-        Dispose(true);
-    }
-
-    protected virtual void Dispose(bool bDisposing)
-    {
-        releaseScratch();
-
-        if (bDisposing)
-        {
-            GC.SuppressFinalize(this);
-        }
-    }
-
-    ~GreedyScratch()
-    {
-        Dispose(false);
-    }
-
-    private int _size = 0;
-    private IntPtr _scratch = IntPtr.Zero;
-}
-
-
-public abstract class DisposablePtr : IDisposable
-{
-    protected void Initialize(IntPtr ptr)
-    {
-        Assert.IsTrue(this._ptr == IntPtr.Zero);
-        this._ptr = ptr;
-    }
-
-    protected void ResetPtr()
-    {
-        this._ptr = IntPtr.Zero;
-    }
-
-    protected abstract void Release();
-
-    public IntPtr ptr
-    {
-        get { return _ptr; }
-    }
-
-
-    public void Dispose()
-    {
-        Dispose(true);
-    }
-
-    protected virtual void Dispose(bool bDisposing)
-    {
-        if (_ptr != IntPtr.Zero)
-        {
-            Release();
-            _ptr = IntPtr.Zero;
-        }
-
-        if (bDisposing)
-        {
-            GC.SuppressFinalize(this);
-        }
-    }
-
-    ~DisposablePtr()
-    {
-        Dispose(false);
-    }
-
-    private IntPtr _ptr = IntPtr.Zero;
-}
-
-
-public class NvBlastAsset : DisposablePtr
-{
-    #region Dll
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern UInt64 NvBlastAssetCreateRequiredScratch(NvBlastAssetDesc desc);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern IntPtr NvBlastAssetCreate(NvBlastAssetDesc desc, NvBlastWrapper.NvBlastAlloc allocFn, IntPtr scratch, NvBlastWrapper.NvBlastLog logFn);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern void NvBlastAssetRelease(IntPtr asset, NvBlastWrapper.NvBlastFree freeFn, NvBlastWrapper.NvBlastLog logFn);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern UInt32 NvBlastAssetGetLeafChunkCount(IntPtr asset, NvBlastWrapper.NvBlastLog logFn);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern NvBlastChunkGraph NvBlastAssetGetSupportGraph(IntPtr asset, NvBlastWrapper.NvBlastLog logFn);
-    #endregion
-
-    public NvBlastAsset(NvBlastAssetDesc desc)
-    {
-        var scratchSize = NvBlastAssetCreateRequiredScratch(desc);
-        var asset = NvBlastAssetCreate(desc, NvBlastWrapper.Alloc, NvBlastWrapper.GetScratch((int)scratchSize), NvBlastWrapper.Log);
-        Initialize(asset);
-    }
-
-    protected override void Release()
-    {
-        NvBlastAssetRelease(ptr, NvBlastWrapper.Free, NvBlastWrapper.Log);
-    }
-
-    public UInt32 leafChunkCount 
-    {
-        get 
-        {
-            return NvBlastAssetGetLeafChunkCount(ptr, NvBlastWrapper.Log);
-        }
-    }
-
-    public NvBlastChunkGraph chunkGraph
-    {
-        get
-        {
-            if (!_graph.HasValue)
-            {
-                _graph = NvBlastAssetGetSupportGraph(ptr, NvBlastWrapper.Log);
-            }
-            return _graph.Value;
-        }
-    }
-
-    private NvBlastChunkGraph? _graph = null;
-}
-
-
-public class NvBlastFamily : DisposablePtr
-{
-    #region Dll
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern IntPtr NvBlastFamilyCreate(IntPtr asset, NvBlastWrapper.NvBlastAlloc allocFn, NvBlastWrapper.NvBlastLog logFn);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern void NvBlastFamilyRelease(IntPtr family, NvBlastWrapper.NvBlastFree freeFn, NvBlastWrapper.NvBlastLog logFn);
-    #endregion
-
-    public NvBlastAsset asset
-    {
-        get;
-        private set;
-    }
-
-    public NvBlastFamily(NvBlastAsset asset_)
-    {
-        asset = asset_;
-        var family = NvBlastFamilyCreate(asset.ptr, NvBlastWrapper.Alloc, NvBlastWrapper.Log);
-        Initialize(family);
-    }
-
-    protected override void Release()
-    {
-        NvBlastFamilyRelease(ptr, NvBlastWrapper.Free, NvBlastWrapper.Log);
-    }
-}
-
-
-public class NvBlastActor : DisposablePtr
-{
-    #region Dll
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern UInt64 NvBlastActorCreateRequiredScratch(IntPtr asset);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern IntPtr NvBlastActorCreate(IntPtr family, NvBlastActorDesc desc, IntPtr scratch, NvBlastWrapper.NvBlastLog logFn);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern void NvBlastActorRelease(IntPtr actor);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern UInt32 NvBlastActorGetVisibleChunkCount(IntPtr actor, NvBlastWrapper.NvBlastLog logFn);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern UInt32 NvBlastActorGetVisibleChunkIndices([In, Out] UInt32[] visibleChunkIndices, UInt32 visibleChunkIndicesSize, IntPtr actor, NvBlastWrapper.NvBlastLog logFn);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern UInt32 NvBlastActorGetGraphNodeCount(IntPtr actor, NvBlastWrapper.NvBlastLog logFn);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern UInt32 NvBlastActorGetGraphNodeIndices([In, Out] UInt32[] graphNodeIndices, UInt32 graphNodeIndicesSize, IntPtr actor, NvBlastWrapper.NvBlastLog logFn);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern void NvBlastActorGenerateFracture(NvBlastFractureBuffers commandBuffers, IntPtr actor, NvBlastDamageProgram program, NvBlastProgramParams programParams, NvBlastWrapper.NvBlastLog logFn, NvBlastTimers timers);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern void NvBlastActorApplyFracture(IntPtr eventBuffers, IntPtr actor, NvBlastFractureBuffers commands, NvBlastWrapper.NvBlastLog logFn, NvBlastTimers timers);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern UInt64 NvBlastActorSplitRequiredScratch(IntPtr actor);
-
-    [DllImport(NvBlastWrapper.DLL_NAME)]
-    static extern UInt32 NvBlastActorSplit([In, Out] NvBlastActorSplitEvent result, UInt32 newActorsMaxCount, IntPtr actor, IntPtr scratch, NvBlastWrapper.NvBlastLog logFn, NvBlastTimers timers);
-    #endregion
-
-    public NvBlastFamily family
-    {
-        get;
-        private set;
-    }
-
-    public object userData = null;
-
-    public NvBlastActor(NvBlastFamily family_, NvBlastActorDesc desc)
-    {
-        family = family_;
-
-        var scratchSize = NvBlastActorCreateRequiredScratch(family_.asset.ptr);
-        var actor = NvBlastActorCreate(family.ptr, desc, NvBlastWrapper.GetScratch((int)scratchSize), NvBlastWrapper.Log);
-        Initialize(actor);
-    }
-
-    public NvBlastActor(NvBlastFamily family_, IntPtr ptr)
-    {
-        family = family_;
-
-        Initialize(ptr);
-    }
-
-    protected override void Release()
-    {
-        NvBlastActorRelease(ptr);
-    }
-
-    public UInt32 visibleChunkCount
-    {
-        get { return NvBlastActorGetVisibleChunkCount(ptr, NvBlastWrapper.Log); }
-    }
-
-    public UInt32[] visibleChunkIndices
-    {
-        get
-        {
-            if(_visibleChunkIndices == null)
-            {
-                _visibleChunkIndices = new UInt32[visibleChunkCount];
-                NvBlastActorGetVisibleChunkIndices(_visibleChunkIndices, visibleChunkCount, ptr, NvBlastWrapper.Log);
-            }
-            return _visibleChunkIndices;
-        }
-    }
-
-    public UInt32 graphNodeCount
-    {
-        get { return NvBlastActorGetGraphNodeCount(ptr, NvBlastWrapper.Log); }
-    }
-
-    public UInt32[] graphNodeIndices
-    {
-        get
-        {
-            if (_graphNodeIndices == null)
-            {
-                _graphNodeIndices = new UInt32[graphNodeCount];
-                NvBlastActorGetGraphNodeIndices(_graphNodeIndices, graphNodeCount, ptr, NvBlastWrapper.Log);
-            }
-            return _graphNodeIndices;
-        }
-    }
-
-    public void GenerateFracture(NvBlastFractureBuffers buffers, NvBlastDamageProgram program, NvBlastProgramParams programParams)
-    {
-        NvBlastActorGenerateFracture(buffers, ptr, program, programParams, NvBlastWrapper.Log, null);
-    }
-
-    public void ApplyFracture(NvBlastFractureBuffers commands)
-    {
-        NvBlastActorApplyFracture(IntPtr.Zero, ptr, commands, NvBlastWrapper.Log, null);
-    }
-
-    public UInt32 Split(NvBlastActorSplitEvent result, UInt32 newActorsMaxCount)
-    {
-        var scratchSize = NvBlastActorSplitRequiredScratch(ptr);
-        UInt32 newActorsCount = NvBlastActorSplit(result, newActorsMaxCount, ptr, NvBlastWrapper.GetScratch((int)scratchSize), NvBlastWrapper.Log, null);
-        if(result.deletedActor != IntPtr.Zero)
-        {
-            ResetPtr();
-        }
-        return newActorsCount;
-    }
-
-    private UInt32[] _visibleChunkIndices = null;
-    private UInt32[] _graphNodeIndices = null;
-}
-
+using System;

+using System.Collections;

+using System.Collections.Generic;

+using System.Runtime.InteropServices;

+using UnityEngine;

+using UnityEngine.Assertions;

+

+public struct NvBlastChunkDesc

+{

+    public enum Flags

+    {

+        NoFlags = 0,

+        SupportFlag = (1 << 0)

+    };

+

+    /** Central position in chunk. */

+    public Single c0;

+    public Single c1;

+    public Single c2;

+

+

+    /** Volume of chunk. */

+    public Single volume;

+

+    /** Index of this chunk's parent.  If this is a root chunk, then this value must be UINT32_MAX. */

+    public UInt32 parentChunkIndex;

+

+    /** See Flags enum for possible flags. */

+    public UInt32 flags;

+

+    /** User-supplied data which will be accessible to the user in chunk fracture events. */

+    public UInt32 userData;

+}

+

+public struct NvBlastBond

+{

+    public Single n0;

+    public Single n1;

+    public Single n2;

+

+    public Single area;

+

+    public Single c0;

+    public Single c1;

+    public Single c2;

+

+    UInt32 userData;

+};

+

+public struct NvBlastBondDesc

+{

+    /** The indices of the chunks linked by this bond.  They must be different support chunk indices. */

+    public UInt32 chunk0;

+    public UInt32 chunk1;

+

+    /** Bond data (see NvBlastBond). */

+    public NvBlastBond bond;

+}

+

+[StructLayout(LayoutKind.Sequential)]

+public class NvBlastAssetDesc

+{

+    public UInt32 chunkCount;

+    public NvBlastChunkDesc[] chunkDescs;

+    public UInt32 bondCount;

+    public NvBlastBondDesc[] bondDescs;

+}

+

+/**

+Actor descriptor, used to create an instance of an NvBlastAsset with NvBlastActorCreate

+    6

+See NvBlastActorCreate.

+*/

+[StructLayout(LayoutKind.Sequential)]

+public class NvBlastActorDesc

+{

+    /**

+	Initial health of all bonds, if initialBondHealths is NULL (see initialBondHealths).

+	*/

+    public Single uniformInitialBondHealth;

+

+    /**

+	Initial bond healths.  If not NULL, this array must be of length NvBlastAssetGetChunkCount(asset, ... ).

+	If NULL, uniformInitialBondHealth must be set.

+	*/

+    public Single[] initialBondHealths = null;

+

+    /**

+	Initial health of all lower-support chunks, if initialSupportChunkHealths is NULL (see initialSupportChunkHealths).

+	*/

+    public Single uniformInitialLowerSupportChunkHealth;

+

+    /**

+	Initial health of all support chunks.  If not NULL, this must be of length

+	NvBlastAssetGetSupportGraph(asset, ... ).nodeCount. The elements in the initialSupportChunkHealth

+	array will correspond to the chunk indices in the NvBlastAssetGetSupportGraph(asset, ... ).chunkIndices

+	array.  Every descendent of a support chunk will have its health initialized to its ancestor support

+	chunk's health, so this initializes all lower-support chunk healths.

+	If NULL, uniformInitialLowerSupportChunkHealth must be set.

+	*/

+    public Single[] initialSupportChunkHealths = null;

+};

+

+

+public struct NvBlastChunk

+{

+    /**

+	Central position for the chunk's volume

+	*/

+    public Single c0;

+    public Single c1;

+    public Single c2;

+

+    /**

+	Volume of the chunk

+	*/

+    public Single volume;

+

+    /**

+	Index of parent (UINT32_MAX denotes no parent)

+	*/

+    public UInt32 parentChunkIndex;

+

+    /**

+	Index of first child

+	*/

+    public UInt32 firstChildIndex;

+

+    /**

+	Stop for child indices

+	*/

+    public UInt32 childIndexStop;

+

+    /**

+	Field for user to associate with external data

+	*/

+    public UInt32 userData;

+};

+

+public struct NvBlastChunkGraph

+{

+    UInt32 nodeCount;

+    public IntPtr chunkIndices;

+    public IntPtr adjacencyPartition;

+    public IntPtr adjacentNodeIndices;

+    public IntPtr adjacentBondIndices;

+};

+

+[StructLayout(LayoutKind.Sequential)]

+public class NvBlastTimers

+{

+    public Int64 material;       //!< Time spent in material function

+    public Int64 fracture;       //!< Time spent applying damage

+    public Int64 island;     //!< Time spent discovering islands

+    public Int64 partition;      //!< Time spent partitioning the graph

+    public Int64 visibility;	//!< Time spent updating visibility

+};

+

+

+///////////////////////////////////////////////////////////////////////////////

+//	Types used for damage and fracturing

+///////////////////////////////////////////////////////////////////////////////

+

+public struct NvBlastChunkFractureData

+{

+    public UInt32 userdata;  //!<	chunk's user data

+    public UInt32 chunkIndex;    //!<	asset chunk index

+    public Single health;		//!<	health value (damage or remains)

+};

+

+public struct NvBlastBondFractureData

+{

+    public UInt32 userdata;  //!<	bond's user data

+    public UInt32 nodeIndex0;    //!<	graph node index of bond

+    public UInt32 nodeIndex1;    //!<	pair graph node index of bond

+    public Single health;		//!<	health value (damage or remains)

+};

+

+[StructLayout(LayoutKind.Sequential)]

+public class NvBlastFractureBuffers

+{

+    public UInt32 bondFractureCount;

+    public UInt32 chunkFractureCount;

+    public IntPtr bondFractures;        // NvBlastBondFractureData[]

+    public IntPtr chunkFractures;       // NvBlastChunkFractureData[]

+};

+

+[StructLayout(LayoutKind.Sequential)]

+public class NvBlastActorSplitEvent

+{

+    public IntPtr deletedActor; //!<	deleted actor or nullptr if actor has not changed

+    public IntPtr newActors;		//!<	list of created actors

+};

+

+[StructLayout(LayoutKind.Sequential)]

+public class NvBlastGraphShaderActor

+{

+    UInt32 firstGraphNodeIndex;   //<!	Entry index for graphNodeIndexLinks

+    public UInt32[] graphNodeIndexLinks;    //<!	Linked index list of connected nodes.  Traversable with nextIndex = graphNodeIndexLinks[currentIndex], terminates with 0xFFFFFFFF.

+    public UInt32[] chunkIndices;           //<!	Graph's map from node index to support chunk index.

+    public UInt32[] adjacencyPartition;     //<!	See NvBlastChunkGraph::adjacencyPartition.

+    public UInt32[] adjacentNodeIndices;    //<!	See NvBlastChunkGraph::adjacentNodeIndices.

+    public UInt32[] adjacentBondIndices;    //<!	See NvBlastChunkGraph::adjacentBondIndices.

+    public NvBlastBond[] assetBonds;              //<!	NvBlastBonds geometry in the NvBlastAsset.

+    public Single[] familyBondHealths;	//<!	Actual bond health values for broken bond detection.

+};

+

+[StructLayout(LayoutKind.Sequential)]

+public class NvBlastProgramParams

+{

+    public IntPtr damageDescBuffer;   //!<	array of damage descriptions

+    public UInt32 damageDescCount; //!<	number of damage descriptions in array

+    public IntPtr material;			//!<	pointer to material

+};

+

+[StructLayout(LayoutKind.Sequential)]

+public class NvBlastSubgraphShaderActor

+{

+    public UInt32 chunkIndex;        //<!	Index of chunk represented by this actor.

+    public NvBlastChunk[] assetChunks;	//<!	NvBlastChunks geometry in the NvBlastAsset.

+};

+

+public struct NvBlastDamageProgram

+{

+    public delegate void NvBlastGraphShaderFunction(System.IntPtr commandBuffers, System.IntPtr actor, System.IntPtr p);

+    public delegate void NvBlastSubgraphShaderFunction(NvBlastFractureBuffers commandBuffers, NvBlastSubgraphShaderActor actor, NvBlastProgramParams p);

+

+    public NvBlastGraphShaderFunction graphShaderFunction;

+    public NvBlastSubgraphShaderFunction subgraphShaderFunction;

+};

+

+

+public class NvBlastWrapper

+{

+    //////// DLL ////////

+

+    public const string DLL_POSTFIX = "DEBUG"; //DEBUG

+    public const string DLL_PLATFORM = "x64";

+    public const string DLL_NAME = "NvBlast" + DLL_POSTFIX + "_" + DLL_PLATFORM;

+

+

+    //////// Internal Types ////////

+

+    public delegate IntPtr NvBlastAlloc(Int64 size);

+    public delegate void NvBlastFree(IntPtr ptr);

+    public delegate void NvBlastLog(Int32 type, string msg, string file, Int32 line);

+

+

+    //////// Public Types ////////

+

+

+

+    //////// Helpers ////////

+

+    public static IntPtr Alloc(Int64 size)

+    {

+        return Marshal.AllocHGlobal((Int32)size);

+    }

+

+    public static void Free(IntPtr ptr)

+    {

+        Marshal.FreeHGlobal(ptr);

+    }

+

+    public static void Log(Int32 type, string msg, string file, Int32 line)

+    {

+        Debug.Log(DLL_NAME + ": [" + type + "] " + msg + "(" + file + ":" + line + ")");

+    }

+

+    public static IntPtr GetScratch(int size)

+    {

+        return _greedyScratch.GetScratch(size);

+    }

+

+    private static GreedyScratch _greedyScratch = new GreedyScratch();

+}

+

+

+public class GreedyScratch : IDisposable

+{

+    public IntPtr GetScratch(int size)

+    {

+        if (_size < size)

+        {

+            releaseScratch();

+            _scratch = Marshal.AllocHGlobal(size);

+            _size = size;

+        }

+

+        return _scratch;

+    }

+

+    private void releaseScratch()

+    {

+        if (_size > 0)

+        {

+            Marshal.FreeHGlobal(_scratch);

+            _scratch = IntPtr.Zero;

+        }

+    }

+

+    public void Dispose()

+    {

+        Dispose(true);

+    }

+

+    protected virtual void Dispose(bool bDisposing)

+    {

+        releaseScratch();

+

+        if (bDisposing)

+        {

+            GC.SuppressFinalize(this);

+        }

+    }

+

+    ~GreedyScratch()

+    {

+        Dispose(false);

+    }

+

+    private int _size = 0;

+    private IntPtr _scratch = IntPtr.Zero;

+}

+

+

+public abstract class DisposablePtr : IDisposable

+{

+    protected void Initialize(IntPtr ptr)

+    {

+        Assert.IsTrue(this._ptr == IntPtr.Zero);

+        this._ptr = ptr;

+    }

+

+    protected void ResetPtr()

+    {

+        this._ptr = IntPtr.Zero;

+    }

+

+    protected abstract void Release();

+

+    public IntPtr ptr

+    {

+        get { return _ptr; }

+    }

+

+

+    public void Dispose()

+    {

+        Dispose(true);

+    }

+

+    protected virtual void Dispose(bool bDisposing)

+    {

+        if (_ptr != IntPtr.Zero)

+        {

+            Release();

+            _ptr = IntPtr.Zero;

+        }

+

+        if (bDisposing)

+        {

+            GC.SuppressFinalize(this);

+        }

+    }

+

+    ~DisposablePtr()

+    {

+        Dispose(false);

+    }

+

+    private IntPtr _ptr = IntPtr.Zero;

+}

+

+

+public class NvBlastAsset : DisposablePtr

+{

+    #region Dll

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern UInt64 NvBlastAssetCreateRequiredScratch(NvBlastAssetDesc desc);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern IntPtr NvBlastAssetCreate(NvBlastAssetDesc desc, NvBlastWrapper.NvBlastAlloc allocFn, IntPtr scratch, NvBlastWrapper.NvBlastLog logFn);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern void NvBlastAssetRelease(IntPtr asset, NvBlastWrapper.NvBlastFree freeFn, NvBlastWrapper.NvBlastLog logFn);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern UInt32 NvBlastAssetGetLeafChunkCount(IntPtr asset, NvBlastWrapper.NvBlastLog logFn);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern NvBlastChunkGraph NvBlastAssetGetSupportGraph(IntPtr asset, NvBlastWrapper.NvBlastLog logFn);

+    #endregion

+

+    public NvBlastAsset(NvBlastAssetDesc desc)

+    {

+        var scratchSize = NvBlastAssetCreateRequiredScratch(desc);

+        var asset = NvBlastAssetCreate(desc, NvBlastWrapper.Alloc, NvBlastWrapper.GetScratch((int)scratchSize), NvBlastWrapper.Log);

+        Initialize(asset);

+    }

+

+    protected override void Release()

+    {

+        NvBlastAssetRelease(ptr, NvBlastWrapper.Free, NvBlastWrapper.Log);

+    }

+

+    public UInt32 leafChunkCount 

+    {

+        get 

+        {

+            return NvBlastAssetGetLeafChunkCount(ptr, NvBlastWrapper.Log);

+        }

+    }

+

+    public NvBlastChunkGraph chunkGraph

+    {

+        get

+        {

+            if (!_graph.HasValue)

+            {

+                _graph = NvBlastAssetGetSupportGraph(ptr, NvBlastWrapper.Log);

+            }

+            return _graph.Value;

+        }

+    }

+

+    private NvBlastChunkGraph? _graph = null;

+}

+

+

+public class NvBlastFamily : DisposablePtr

+{

+    #region Dll

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern IntPtr NvBlastFamilyCreate(IntPtr asset, NvBlastWrapper.NvBlastAlloc allocFn, NvBlastWrapper.NvBlastLog logFn);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern void NvBlastFamilyRelease(IntPtr family, NvBlastWrapper.NvBlastFree freeFn, NvBlastWrapper.NvBlastLog logFn);

+    #endregion

+

+    public NvBlastAsset asset

+    {

+        get;

+        private set;

+    }

+

+    public NvBlastFamily(NvBlastAsset asset_)

+    {

+        asset = asset_;

+        var family = NvBlastFamilyCreate(asset.ptr, NvBlastWrapper.Alloc, NvBlastWrapper.Log);

+        Initialize(family);

+    }

+

+    protected override void Release()

+    {

+        NvBlastFamilyRelease(ptr, NvBlastWrapper.Free, NvBlastWrapper.Log);

+    }

+}

+

+

+public class NvBlastActor : DisposablePtr

+{

+    #region Dll

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern UInt64 NvBlastActorCreateRequiredScratch(IntPtr asset);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern IntPtr NvBlastActorCreate(IntPtr family, NvBlastActorDesc desc, IntPtr scratch, NvBlastWrapper.NvBlastLog logFn);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern void NvBlastActorRelease(IntPtr actor);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern UInt32 NvBlastActorGetVisibleChunkCount(IntPtr actor, NvBlastWrapper.NvBlastLog logFn);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern UInt32 NvBlastActorGetVisibleChunkIndices([In, Out] UInt32[] visibleChunkIndices, UInt32 visibleChunkIndicesSize, IntPtr actor, NvBlastWrapper.NvBlastLog logFn);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern UInt32 NvBlastActorGetGraphNodeCount(IntPtr actor, NvBlastWrapper.NvBlastLog logFn);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern UInt32 NvBlastActorGetGraphNodeIndices([In, Out] UInt32[] graphNodeIndices, UInt32 graphNodeIndicesSize, IntPtr actor, NvBlastWrapper.NvBlastLog logFn);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern void NvBlastActorGenerateFracture(NvBlastFractureBuffers commandBuffers, IntPtr actor, NvBlastDamageProgram program, NvBlastProgramParams programParams, NvBlastWrapper.NvBlastLog logFn, NvBlastTimers timers);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern void NvBlastActorApplyFracture(IntPtr eventBuffers, IntPtr actor, NvBlastFractureBuffers commands, NvBlastWrapper.NvBlastLog logFn, NvBlastTimers timers);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern UInt64 NvBlastActorSplitRequiredScratch(IntPtr actor);

+

+    [DllImport(NvBlastWrapper.DLL_NAME)]

+    static extern UInt32 NvBlastActorSplit([In, Out] NvBlastActorSplitEvent result, UInt32 newActorsMaxCount, IntPtr actor, IntPtr scratch, NvBlastWrapper.NvBlastLog logFn, NvBlastTimers timers);

+    #endregion

+

+    public NvBlastFamily family

+    {

+        get;

+        private set;

+    }

+

+    public object userData = null;

+

+    public NvBlastActor(NvBlastFamily family_, NvBlastActorDesc desc)

+    {

+        family = family_;

+

+        var scratchSize = NvBlastActorCreateRequiredScratch(family_.asset.ptr);

+        var actor = NvBlastActorCreate(family.ptr, desc, NvBlastWrapper.GetScratch((int)scratchSize), NvBlastWrapper.Log);

+        Initialize(actor);

+    }

+

+    public NvBlastActor(NvBlastFamily family_, IntPtr ptr)

+    {

+        family = family_;

+

+        Initialize(ptr);

+    }

+

+    protected override void Release()

+    {

+        NvBlastActorRelease(ptr);

+    }

+

+    public UInt32 visibleChunkCount

+    {

+        get { return NvBlastActorGetVisibleChunkCount(ptr, NvBlastWrapper.Log); }

+    }

+

+    public UInt32[] visibleChunkIndices

+    {

+        get

+        {

+            if(_visibleChunkIndices == null)

+            {

+                _visibleChunkIndices = new UInt32[visibleChunkCount];

+                NvBlastActorGetVisibleChunkIndices(_visibleChunkIndices, visibleChunkCount, ptr, NvBlastWrapper.Log);

+            }

+            return _visibleChunkIndices;

+        }

+    }

+

+    public UInt32 graphNodeCount

+    {

+        get { return NvBlastActorGetGraphNodeCount(ptr, NvBlastWrapper.Log); }

+    }

+

+    public UInt32[] graphNodeIndices

+    {

+        get

+        {

+            if (_graphNodeIndices == null)

+            {

+                _graphNodeIndices = new UInt32[graphNodeCount];

+                NvBlastActorGetGraphNodeIndices(_graphNodeIndices, graphNodeCount, ptr, NvBlastWrapper.Log);

+            }

+            return _graphNodeIndices;

+        }

+    }

+

+    public void GenerateFracture(NvBlastFractureBuffers buffers, NvBlastDamageProgram program, NvBlastProgramParams programParams)

+    {

+        NvBlastActorGenerateFracture(buffers, ptr, program, programParams, NvBlastWrapper.Log, null);

+    }

+

+    public void ApplyFracture(NvBlastFractureBuffers commands)

+    {

+        NvBlastActorApplyFracture(IntPtr.Zero, ptr, commands, NvBlastWrapper.Log, null);

+    }

+

+    public UInt32 Split(NvBlastActorSplitEvent result, UInt32 newActorsMaxCount)

+    {

+        var scratchSize = NvBlastActorSplitRequiredScratch(ptr);

+        UInt32 newActorsCount = NvBlastActorSplit(result, newActorsMaxCount, ptr, NvBlastWrapper.GetScratch((int)scratchSize), NvBlastWrapper.Log, null);

+        if(result.deletedActor != IntPtr.Zero)

+        {

+            ResetPtr();

+        }

+        return newActorsCount;

+    }

+

+    private UInt32[] _visibleChunkIndices = null;

+    private UInt32[] _graphNodeIndices = null;

+}

+