public void Reset() { _sceneObject = null; _nextBinReference = null; _previousBinReference = null; _objectLink = null; }
protected void _FreeSceneBinReference(SceneContainerBinReference freeRef) { Assert.Fatal(freeRef != null, "doh"); if (UseFreeList) { freeRef.Reset(); freeRef._objectLink = _freeSceneBinReferences; _freeSceneBinReferences = freeRef; } //else, go garbage collector! }
void _GetObjectsHelper(SceneContainerBinReference bin, List<ISceneObject> list) { for (SceneContainerBinReference walk = bin; walk != null; walk = walk._nextBinReference) { if (walk._sceneObject != null && walk._sceneObject.SceneContainerData._sequenceKey != _currentSequenceKey) { list.Add(walk._sceneObject); walk._sceneObject.SceneContainerData._sequenceKey = _currentSequenceKey; } } }
protected void _FindObjectsInefficientHelper(SceneContainerQueryData query, SceneContainerBinReference bin, ref int objectsFound) { SceneContainerBinReference walk = bin; while (walk != null) { if (walk._sceneObject != null) { // Have we dealt with this object already? if (walk._sceneObject.SceneContainerData._sequenceKey == _currentSequenceKey) { // Move to next bin reference. walk = walk._nextBinReference; continue; } walk._sceneObject.SceneContainerData._sequenceKey = _currentSequenceKey; if (_IntersectsWith(walk._sceneObject, query)) objectsFound++; } walk = walk._nextBinReference; } }
protected void _FindInBin(SceneContainerBinReference bin, SceneContainerQueryData queryData) { object ignoreObject = queryData._ignoreObject; object[] ignoredObjects = queryData._ignoreObjects; ulong typebits = queryData._objectTypes._bits; // Step through Chain. while (bin != null) { // Fetch Scene Object Reference. ISceneContainerObject sceneObjectRef = bin._sceneObject; // Note: the following tries to get the object type directly from a TorqueObject rather than // going through the ISceneContainerObject interface. This ends up being a LOT (a LOT) faster // for T2DSceneObjects even though it adds a branch. It won't help when the object isn't a // TorqueObject as is the case of our T3D code, but we can consider other measures if that // becomes a problem (like making bin ref's point to SceneContainerData instead of scene object // and adding a pointer to iscene object in SceneContainerData as well as object type, but current // scheme is simpler and more effective for T2D). TorqueObject tobj = sceneObjectRef as TorqueObject; ulong ourType = tobj == null ? sceneObjectRef.ObjectType._bits : tobj._objectType; if ((ourType & typebits) == 0) { // Move to next bin reference. bin = bin._nextBinReference; continue; } // get the scene container data for the object SceneContainerData scd = sceneObjectRef.SceneContainerData; // Have we dealt with this object already? if (scd._sequenceKey == _currentSequenceKey) { // Move to next bin reference. bin = bin._nextBinReference; continue; } // Set the container sequence key to indicate that we've dealt with this object. scd._sequenceKey = _currentSequenceKey; // Check for ignored objects bool ignored = false; if (ignoreObject == sceneObjectRef) { ignored = true; } else if (ignoredObjects != null) { foreach (object o in ignoredObjects) if (o == sceneObjectRef) { ignored = true; break; } } // Is the Object Not being ignored? if (!ignored) _FoundObject(sceneObjectRef, queryData); // Move to next bin reference. bin = bin._nextBinReference; } }
protected void _CreateBins() { // Create Scene Bin Array. _sceneBinArray = new SceneContainerBinReference[_binCount * _binCount]; // if configured to do so, create individual array objects. // this can end up creating a lot of objects. if (PreAllocSceneBinArrayReferences) for (int i = 0; i < _sceneBinArray.Length; ++i) _sceneBinArray[i] = new SceneContainerBinReference(); // Initialise Scene Overflow Bin. _sceneOverflowBin = new SceneContainerBinReference(); // Reset Free Scene Bin References. _freeSceneBinReferences = null; _CreateFreeListBlock(); }
protected SceneContainerBinReference _AllocateSceneBinReference() { if (UseFreeList && _freeSceneBinReferences == null) _CreateFreeListBlock(); if (UseFreeList && _freeSceneBinReferences != null) { SceneContainerBinReference freeRef = _freeSceneBinReferences; // update free list head pointer _freeSceneBinReferences = _freeSceneBinReferences._objectLink; // unlink the freeRef freeRef._objectLink = null; // all fields should be null on free ref at this point freeRef.AssertIfNotNull(); return freeRef; } else return new SceneContainerBinReference(); }
public override void Dispose() { _IsDisposed = true; for (uint i = 0; i < _sceneBinArray.Length; i++) { if (_sceneBinArray[i] != null) _sceneBinArray[i].Reset(); // Just to make sure to not create a circular reference of disposed objects _sceneBinArray[i] = null; } _ResetRefs(); _sceneOverflowBin.Reset(); // Just to make sure to not create a circular reference of disposed objects _sceneOverflowBin = null; _sceneBinArray = null; _sg.Reset(); _sg = null; base.Dispose(); }