private void DestroyTimerQueue() { lock (_timerSyncRoot) _timerCompletionQueue.Clear(); Debug.Assert(TimerQueue != null); TimerQueue.Dispose(); TimerQueue = null; }
public void Dispose() { GC.SuppressFinalize(this); LinkedListEntry <KMemoryBlock> e = Blocks.HeadEntry; while (e != null) { Partition.Free(e.Value); e = e.Next; } Blocks.Clear(); }
public void Clear() { List <int> textureIds = new List <int>(); LinkedListEntry <MGLTexture> e = _values.HeadEntry; while (e != null) { textureIds.Add(e.Value.TextureID); e = e.Next; } _values.Clear(); Gl.glDeleteTextures(textureIds.Count, textureIds.ToArray()); }
public override void Stop() { if ((_timer != null) && (_kernel.TimerQueue != null)) { _kernel.TimerQueue.StopTimer(_timer); } _timer = null; if (_buffer != null) { _buffer.Clear(); } }
/// <summary> /// 清空缓存 /// </summary> public void ClearCache() { _noRef.Clear(); }
/** * Recursive version of ClipOutTriangles. This method partitions the triangles * in @triangles using @node's split plane, and then recursively calls itself * with the resulting greater-than and less-than lists. If the recursion reaches a * point where triangles in @triangles are on the back side of @node's split plane, * but this instance of BSPTree contains no geometry on that side (node.LessThan == null), * then the triangles placed in @lessThan are deleted from @triangles. This removes * the portions of triangles in @triangles that lie inside the geometry of this BSPTree * instance. * * If @clippLessThan is false, then we perform the reverse of the above oepration. * Triangles placed in @greaterThan than are removed when node.GreaterThan == null. * In that case the portions of triangles in @triangles that lie outside the geometry * of this BSPTree instance are removed. */ private void ClipOutTriangles(Node node, FastLinkedList<Triangle> triangles, bool clipLessThan = true, IList<Triangle> discarded = null) { if (triangles == null || triangles.First == null)return; if(node == null)return; FastLinkedList<Triangle> lessThan = new FastLinkedList<Triangle>(); FastLinkedList<Triangle> greaterThan = new FastLinkedList<Triangle>(); // iterate through each triangle in @triangles and classify/partition each according // @node's split plane. triangles on the front side go into @greaterThan, triangles // on the back side go into @lessThan. co-planar triangles whose normal matches that of // @node's split plane go into @greaterThan; the rest go into @lessThan. triangles.Iterate((Triangle tri) => { Partitioner.Orientation orient = Partitioner.SliceTriangle(tri, node.SplitPlane, lessThan, greaterThan, lessThan, greaterThan); }); // release memory used by @triangles triangles.Clear(); // recurse on the back side of @node's split plane if this BSPTree contains // geometry on that side. if it does not, and we want to clip out triangles // inside this BSPTree's geometry (@clipLessThan == true), then we clear out @lessThan. if(node.LessThan != null) ClipOutTriangles (node.LessThan, lessThan, clipLessThan, discarded); else if(clipLessThan) { if(discarded != null)lessThan.CopyInto(discarded); lessThan.Clear(); } // recurse on the front side of @node's split plane if this BSPTree contains // geometry on that side. if it does not, and we want to clip out triangles // outside this BSPTree's geometry (@clipLessThan == false), then we clear out @greaterThan. if(node.GreaterThan != null) ClipOutTriangles (node.GreaterThan, greaterThan, clipLessThan, discarded); else if(!clipLessThan) { if(discarded != null)greaterThan.CopyInto(discarded); greaterThan.Clear(); } // rebuild @triangles with the properly clipped triangles triangles.AppendIntoList(lessThan); triangles.AppendIntoList(greaterThan); }
/** * Rescursive version of AddTriangles. This method partitions the triangles * in @triangles using @node's split plane, and then recursively calls itself * with the resulting greater-than and less-than lists. */ private void AddTriangles(Node node, FastLinkedList<Triangle> triangles) { if (triangles == null)return; if(node == null)return; // get a reference to the list of triangles that are co-planar with // @node's split plane FastLinkedList<Triangle> nodeTriangles = node.GetTriangleList(); FastLinkedList<Triangle> lessThan = new FastLinkedList<Triangle> (); FastLinkedList<Triangle> greaterThan = new FastLinkedList<Triangle> (); // iterate through each triangle in @triangles and classify/partition each according // @node's split plane. co-planar triangles go into @nodeTriangles, triangles on the front // side go into @greaterThan, traingles on the back side go into @lessThan. triangles.Iterate((Triangle tri) => { Partitioner.Orientation orient = Partitioner.SliceTriangle(tri, node.SplitPlane, lessThan, greaterThan, nodeTriangles, nodeTriangles); }); // release clear memory occupied by @triangles triangles.Clear(); // recurse on the back side of @node's split plane if(lessThan.First != null) { if(node.LessThan == null) node.LessThan = Node.Create(lessThan.First.Value.OrientationPlane); AddTriangles(node.LessThan, lessThan); } // recurse on the front side of @node's split plane if(greaterThan.First != null) { if( node.GreaterThan == null) node.GreaterThan = Node.Create(greaterThan.First.Value.OrientationPlane); AddTriangles(node.GreaterThan, greaterThan); } }