/// <summary> /// This function will be called by a native function that is required to /// return a SharedPtr. It will process the native object and shared /// pointer and create a managed side sharedPtr and wrapper if needed. /// This sharedPtr will stay around until the collection detects that is /// has no more open handles. In order for this to happen at least one /// SharedPtr must be checked out, which will happen naturally since you /// want to return one anyway from the function that called the native /// function that called back to here. /// </summary> /// <param name="nativeObject">The object stackSharedPtr points to.</param> /// <param name="stackSharedPtr">A SharedPtr on the stack from ogre.</param> public void processWrapperObject(IntPtr nativeObject, IntPtr stackSharedPtr) { if (nativeObject != IntPtr.Zero && !ptrDictionary.ContainsKey(nativeObject)) { SharedPtrEntry <T> entry = new SharedPtrEntry <T>(createWrapper(nativeObject), nativeObject, createHeapSharedPtr(stackSharedPtr)); ptrDictionary.Add(nativeObject, entry); } }
/// <summary> /// Return a pointer to this collection. This is done in the SharedPtr /// dispose method. If all the references are returned the entry will be /// disposed and the heap allocated shared pointer will be released. /// </summary> /// <param name="sharedPtr"></param> public void returnPtr(SharedPtr <T> sharedPtr) { IntPtr key = sharedPtr.NativeObject; SharedPtrEntry <T> entry = ptrDictionary[key]; entry.removePointer(sharedPtr); if (OgreInterface.TrackMemoryLeaks) { allocationStackTraces.Remove(sharedPtr); } if (!entry.HasReferences) { ptrDictionary.Remove(key); deleteHeapSharedPtr(entry.HeapSharedPtr); entry.Dispose(); } }