diff options
Diffstat (limited to 'NvBlast/examples/UnityExample/Assets/Plugins/Blast/NvBlastWrapper.cs')
| -rw-r--r-- | NvBlast/examples/UnityExample/Assets/Plugins/Blast/NvBlastWrapper.cs | 587 |
1 files changed, 587 insertions, 0 deletions
diff --git a/NvBlast/examples/UnityExample/Assets/Plugins/Blast/NvBlastWrapper.cs b/NvBlast/examples/UnityExample/Assets/Plugins/Blast/NvBlastWrapper.cs new file mode 100644 index 0000000..ccda6c4 --- /dev/null +++ b/NvBlast/examples/UnityExample/Assets/Plugins/Blast/NvBlastWrapper.cs @@ -0,0 +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; +} + |