C# INode.GetBounds方法代码示例

    private void ProcessTerminal(INode node, float tx0, float ty0, float tz0)
    {
        var entryDistance = Mathf.Max(tx0, ty0, tz0);

        var entryPlane = GetEntryPlane(tx0, ty0, tz0);

        var normal = GetNormal(entryPlane);
        if (_debug) {
            const float normalSize = 1f;
            Debug.DrawLine(_ray.origin, _ray.GetPoint(entryDistance), Color.white, 0, false);

            Debug.DrawLine(_ray.GetPoint(entryDistance),
                _ray.GetPoint(entryDistance) + _transform.TransformDirection(normal) * normalSize, Color.green, 0, false);

            var bounds = node.GetBounds();
            DrawBounds(bounds, Color.cyan, true);
        }

        var result = new RayIntersectionResult(_tree, node, node.GetCoords(), entryDistance, _ray.GetPoint(entryDistance),
            normal, GetNeighbourSide(entryPlane));

        if (_filter == null || _filter(result)) {
            results.Add(result);
        }
    }

    private void ProcSubtree(float tx0, float ty0, float tz0, float tx1, float ty1, float tz1, INode node,
		bool insideSolidNode, int currentDepth, int? wantedDepth,
		Coords nodeCoords)
    {
        if (!_intersectMultiple && results.Count > 0) {
            return;
        }

        if (tx1 < 0.0 || ty1 < 0.0 || tz1 < 0.0) {
            return;
        }

        if (_debug) {
            var entryDistance = Mathf.Max(tx0, ty0, tz0);

            Debug.DrawLine(_ray.origin, _ray.GetPoint(entryDistance), Color.red, 0, false);
        }

        if (wantedDepth == null) {
            if (node == null) {
                return;
            }

            if (node.IsSolid()) {
                ProcessTerminal(node, tx0, ty0, tz0);
                if (results.Count > 0) {
                    return;
                }
            }
        } else {
            if (!insideSolidNode) {
                //didn't manage to get into a solid node
                if (node == null) {
                    return;
                }

                insideSolidNode = node.IsSolid();
            }

            if (insideSolidNode && currentDepth >= wantedDepth) {
                if (currentDepth == wantedDepth) {
                    ProcessTerminal(nodeCoords, tx0, ty0, tz0);
                } else {
                    //oops, went too deep!!!
                    //trace back to wanted depth

                    var newCoords = new OctreeChildCoords[wantedDepth.Value];

                    for (var i = 0; i < newCoords.Length; ++i) {
                        newCoords[i] = nodeCoords.GetCoord(i);
                    }

                    ProcessTerminal(new Coords(newCoords), tx0, ty0,
                        tz0);
                }

                if (results.Count > 0) {
                    return;
                }
            }
        }

        if (_debug) {
            if (node != null) {
                var bounds = node.GetBounds();
                DrawBounds(bounds, Color.white);
            } else {
                //inside solid node and still going strong baby!
                var bounds = _rootNode.GetChildBounds(nodeCoords);
                DrawBounds(bounds, Color.cyan);
            }
        }

        var txm = 0.5f * (tx0 + tx1);
        var tym = 0.5f * (ty0 + ty1);
        var tzm = 0.5f * (tz0 + tz1);

        var currNode = FirstNode(tx0, ty0, tz0, txm, tym, tzm);

        while (currNode < 8) {
            var childIndex = (OctreeNode.ChildIndex) (currNode ^ _dimensionFlipFlags);
            if (!_intersectMultiple && results.Count > 0) {
                return;
            }

            var nextDepth = currentDepth + 1;
            var childCoords = new Coords(nodeCoords,
                OctreeChildCoords.FromIndex(childIndex));

            INode childNode;

            if (insideSolidNode) {
                childNode = null;
            } else {
                childNode = node.GetChild(childIndex);
            }

            switch (currNode) {
                //0= none
                //1 = only x
//.........这里部分代码省略.........

    public RayIntersection(Transform transform, IOctree octree, Ray r, bool intersectMultiple, int? wantedDepth,
		Filter filter, bool debug = false)
    {
        _filter = filter;

        _debug = debug;
        _tree = octree;
        _rootNode = octree.GetRoot();
        if (_rootNode == null) {
            //we had a good run guys, time to call it a day
            return;
        }

        _transform = transform;
        _ray = r;
        _intersectMultiple = intersectMultiple;
        _dimensionFlipFlags = 0;

        var rootBounds = _rootNode.GetBounds();
        if (_debug) {
            DrawBounds(rootBounds, Color.gray);
        }

        var rootCenter = rootBounds.center;

        var ro = transform.InverseTransformPoint(r.origin) - rootCenter;
        var rd = transform.InverseTransformDirection(r.direction);

        var rox = ro.x;
        var roy = ro.y;
        var roz = ro.z;

        var rdx = rd.x;
        var rdy = rd.y;
        var rdz = rd.z;

        var ocMin = rootBounds.min - rootCenter;
        var ocMax = rootBounds.max - rootCenter;

        if (rdx < 0.0f) {
            rox = -rox;
            rdx = -rdx;
            _dimensionFlipFlags |= 1;
        }

        if (rdy < 0.0f) {
            roy = -roy;
            rdy = -rdy;
            _dimensionFlipFlags |= 2;
        }

        if (rdz < 0.0f) {
            roz = -roz;
            rdz = -rdz;
            _dimensionFlipFlags |= 4;
        }

        float tx0, tx1, ty0, ty1, tz0, tz1;

        if (!Mathf.Approximately(rdx, 0.0f)) {
            tx0 = (ocMin.x - rox) / rdx;
            tx1 = (ocMax.x - rox) / rdx;
        } else {
            tx0 = 99999.9f;
            tx1 = 99999.9f;
        }

        if (!Mathf.Approximately(rdy, 0.0f)) {
            ty0 = (ocMin.y - roy) / rdy;
            ty1 = (ocMax.y - roy) / rdy;
        } else {
            ty0 = 99999.9f;
            ty1 = 99999.9f;
        }

        if (!Mathf.Approximately(rdz, 0.0f)) {
            tz0 = (ocMin.z - roz) / rdz;
            tz1 = (ocMax.z - roz) / rdz;
        } else {
            tz0 = 99999.9f;
            tz1 = 99999.9f;
        }

        if (_debug) {
            Debug.DrawLine(_ray.origin, _ray.GetPoint(5000), Color.yellow);
        }

        if (Mathf.Max(tx0, ty0, tz0) < Mathf.Min(tx1, ty1, tz1)) {
            ProcSubtree(tx0, ty0, tz0, tx1, ty1, tz1, _rootNode, _rootNode.IsSolid(), 0, wantedDepth,
                _rootNode.GetCoords());
        }
    }