Changeset 2583

Show
Ignore:
Timestamp:
06/30/11 18:59:29 (3 years ago)
Author:
usulthemouse
Message:

Various Changes and code cleanup. ~theMouse

Location:
branches/v0.8.0.0/Projects/Axiom
Files:
13 modified

Legend:

Unmodified
Added
Removed
  • branches/v0.8.0.0/Projects/Axiom/Plugins/OctreeZone/TerrainZoneRenderable.cs

    r2573 r2583  
    7474    public static int MORPH_CUSTOM_PARAM_ID = 77; 
    7575 
     76 
     77    public enum StitchShift 
     78    { 
     79        North = 0, 
     80        South = 8, 
     81        East = 16, 
     82        West = 24 
     83    } 
     84 
     85    [Flags] 
     86    public enum StitchDirection 
     87    { 
     88        North = 128 << StitchShift.North, 
     89        South = 128 << StitchShift.South, 
     90        East = 128 << StitchShift.East, 
     91        West = 128 << StitchShift.West 
     92    } 
    7693 
    7794    /// Parent Zone 
  • branches/v0.8.0.0/Projects/Axiom/SceneManagers/PCZ/Capsule.cs

    r2573 r2583  
    3838{ 
    3939 
    40         public class Capsule 
    41         { 
    42                 // defining members 
    43                 public Segment Segment = new Segment(); 
    44                 public Real Radius = 0; 
    45                          
    46                 // construction 
    47                 public Capsule() 
    48                 { 
    49                         // uninitialized 
    50                 } 
    51                 //---------------------------------------------------------------------------- 
    52                 public Capsule(Segment segment, Real radius) 
    53                 { 
    54                         Segment = segment; 
    55                         Radius = radius; 
    56                 } 
     40    public class Capsule 
     41    { 
     42        // defining members 
     43        private Segment segment = new Segment(); 
     44        private Real radius = 0; 
     45 
     46        public Segment Segment 
     47        { 
     48            get { return segment; } 
     49            set { segment = value; } 
     50        } 
     51 
     52        public Real Radius 
     53        { 
     54            get { return radius; } 
     55            set { radius = value; } 
     56        } 
     57 
     58        // construction 
     59        public Capsule() 
     60        { 
     61            // uninitialized 
     62        } 
     63        //---------------------------------------------------------------------------- 
     64        public Capsule(Segment segment, Real radius) 
     65        { 
     66            Segment = segment; 
     67            Radius = radius; 
     68        } 
    5769 
    5870        public void Set(Vector3 newOrigin, Vector3 newEnd, Real newRadius) 
     
    6476        //// set values 
    6577        //void @set(Vector3 newOrigin, Vector3 newEnd, float newRadius); 
    66                 //---------------------------------------------------------------------------- 
    67                 public void SetOrigin(Vector3 newOrigin) 
    68                 { 
    69                         Segment.Origin = newOrigin; 
    70                 } 
     78        //---------------------------------------------------------------------------- 
     79        public Vector3 Origin 
     80        { 
     81            get { return Segment.Origin; } 
     82 
     83            set 
     84            { 
     85                Segment.Origin = value; 
     86            } 
     87        } 
    7188 
    7289        /// <summary> 
     
    8198        } 
    8299 
    83                 //---------------------------------------------------------------------------- 
    84                 public void SetRadius(Real newRadius) 
    85                 { 
    86                         Radius = newRadius; 
    87                 } 
     100        // Intersection tests 
     101        //---------------------------------------------------------------------------- 
     102        //ORIGINAL LINE: bool Intersects(const Capsule& otherCapsule) const 
     103        public bool Intersects(Capsule otherCapsule) 
     104        { 
     105            Real fDistance = Segment.Distance(otherCapsule.Segment); 
     106            Real fRSum = Radius + otherCapsule.Radius; 
     107            return fDistance <= fRSum; 
     108        } 
    88109 
    89                 // Intersection tests 
    90                 //---------------------------------------------------------------------------- 
    91         //ORIGINAL LINE: bool Intersects(const Capsule& otherCapsule) const 
    92                 public bool Intersects(Capsule otherCapsule) 
    93                 { 
    94                         Real fDistance = Segment.Distance(otherCapsule.Segment); 
    95                         Real fRSum = Radius + otherCapsule.Radius; 
    96                         return fDistance <= fRSum; 
    97                 } 
     110        //---------------------------------------------------------------------------- 
     111        //ORIGINAL LINE: bool Intersects(const Segment& segment) const 
     112        public bool Intersects(Segment segment) 
     113        { 
     114            Real fDist = segment.Distance(Segment); 
     115            return fDist <= Radius; 
     116        } 
    98117 
    99                 //---------------------------------------------------------------------------- 
    100         //ORIGINAL LINE: bool Intersects(const Segment& segment) const 
    101                 public bool Intersects(Segment segment) 
    102                 { 
    103                         Real fDist = segment.Distance(Segment); 
    104                         return fDist <= Radius; 
    105                 } 
    106  
    107         } 
     118    } 
    108119} 
  • branches/v0.8.0.0/Projects/Axiom/SceneManagers/PCZ/PCPlane.cs

    r2573 r2583  
    4141    public class PCPlane 
    4242    { 
    43         protected Plane _plane = new Plane(); 
    44         protected Portal _portal = null; 
     43        protected Plane Plane = new Plane(); 
     44        private Portal portal = null; 
    4545 
    4646        public PCPlane() 
    4747        { 
    48             _portal = null; 
     48            portal = null; 
    4949        } 
    5050 
    5151        public PCPlane(Plane plane) 
    5252        { 
    53             this._plane = new Plane(plane); 
    54             _portal = null; 
     53            this.Plane = new Plane(plane); 
     54            portal = null; 
    5555        } 
    5656 
    5757        public PCPlane(Vector3 rkNormal, Vector3 rkPoint) 
    5858        { 
    59             this._plane = new Plane(rkNormal, rkPoint); 
    60             _portal = null; 
     59            this.Plane = new Plane(rkNormal, rkPoint); 
     60            portal = null; 
    6161        } 
    6262 
    6363        public PCPlane(Vector3 rkPoint0, Vector3 rkPoint1, Vector3 rkPoint2) 
    6464        { 
    65             this._plane = new Plane(rkPoint0, rkPoint1, rkPoint2); 
    66             _portal = null; 
     65            this.Plane = new Plane(rkPoint0, rkPoint1, rkPoint2); 
     66            portal = null; 
    6767        } 
    6868 
    6969        public PlaneSide GetSide(AxisAlignedBox box) 
    7070        { 
    71             return this._plane.GetSide(box); 
     71            return this.Plane.GetSide(box); 
    7272        } 
    7373 
    7474        public PlaneSide GetSide(Vector3 centre, Vector3 halfSize) 
    7575        { 
    76             return this._plane.GetSide(centre, halfSize); 
     76            return this.Plane.GetSide(centre, halfSize); 
    7777        } 
    7878 
    7979        public PlaneSide GetSide(Vector3 point) 
    8080        { 
    81             return this._plane.GetSide(point); 
     81            return this.Plane.GetSide(point); 
    8282        } 
    8383 
    8484        public void Redefine(Vector3 point0, Vector3 point1, Vector3 point2) 
    8585        { 
    86             this._plane.Redefine(point0, point1, point2); 
     86            this.Plane.Redefine(point0, point1, point2); 
    8787        } 
    8888 
    8989        public void Redefine(Vector3 rkNormal, Vector3 rkPoint) 
    9090        { 
    91             this._plane.Redefine(rkNormal, rkPoint); 
     91            this.Plane.Redefine(rkNormal, rkPoint); 
    9292        } 
    9393 
    9494        public void SetFromAxiomPlane(Plane axiomPlane) 
    9595        { 
    96             this._plane = new Plane(_plane); 
    97             _portal = null; 
     96            this.Plane = new Plane(Plane); 
     97            portal = null; 
    9898        } 
    9999 
     
    102102            get 
    103103            { 
    104                 return _portal; 
     104                return portal; 
    105105            } 
    106106            set 
    107107            { 
    108                 _portal = value; 
     108                portal = value; 
    109109            } 
    110110        } 
     
    112112        ~PCPlane() 
    113113        { 
    114             _portal = null; 
     114            portal = null; 
    115115        } 
    116116 
  • branches/v0.8.0.0/Projects/Axiom/SceneManagers/PCZ/PCZCamera.cs

    r2573 r2583  
    4343    public class PCZCamera : Camera 
    4444    { 
    45         private PCZFrustum _extraCullingFrustum = new PCZFrustum(); 
    46         private static NameGenerator<PCZCamera> _nameGenerator = new NameGenerator<PCZCamera>("PCZCamera"); 
     45        private PCZFrustum extraCullingFrustum = new PCZFrustum(); 
     46        private static NameGenerator<PCZCamera> nameGenerator = new NameGenerator<PCZCamera>("PCZCamera"); 
    4747 
    4848        public PCZCamera(SceneManager sceneManager) 
    49             : this(_nameGenerator.GetNextUniqueName(), sceneManager) 
     49            : this(nameGenerator.GetNextUniqueName(), sceneManager) 
    5050        { 
    5151        } 
     
    5555        { 
    5656            base._boundingBox = new AxisAlignedBox(new Vector3(-0.1f, -0.1f, -0.1f), new Vector3(0.1f, 0.1f, 0.1f)); 
    57             _extraCullingFrustum = new PCZFrustum(); 
    58             _extraCullingFrustum.SetUseOriginPlane(true); 
     57            extraCullingFrustum = new PCZFrustum(); 
     58            extraCullingFrustum.SetUseOriginPlane(true); 
    5959        } 
    6060 
     
    7777            // check extra culling planes 
    7878            bool extraResults; 
    79             extraResults = _extraCullingFrustum.IsObjectVisible(bound); 
     79            extraResults = extraCullingFrustum.IsObjectVisible(bound); 
    8080            if (!extraResults) 
    8181            { 
     
    123123 
    124124            // check the extra frustum first 
    125             if (!_extraCullingFrustum.IsObjectVisible(portal)) 
     125            if (!extraCullingFrustum.IsObjectVisible(portal)) 
    126126            { 
    127127                return false; 
     
    268268            } 
    269269 
    270             switch (_extraCullingFrustum.GetVisibility(bound)) 
     270            switch (extraCullingFrustum.GetVisibility(bound)) 
    271271            { 
    272272                case PCZFrustum.Visibility.None: 
     
    294294            { 
    295295                base.ProjectionType = value; 
    296                 _extraCullingFrustum.ProjectionType = value; 
     296                extraCullingFrustum.ProjectionType = value; 
    297297            } 
    298298        } 
     
    305305        { 
    306306            // add the extra culling planes from the portal 
    307             return _extraCullingFrustum.AddPortalCullingPlanes(portal); 
     307            return extraCullingFrustum.AddPortalCullingPlanes(portal); 
    308308        } 
    309309 
     
    312312        public void RemovePortalCullingPlanes(Portal portal) 
    313313        { 
    314             _extraCullingFrustum.RemovePortalCullingPlanes(portal); 
     314            extraCullingFrustum.RemovePortalCullingPlanes(portal); 
    315315        } 
    316316 
     
    318318        public void RemoveAllExtraCullingPlanes() 
    319319        { 
    320             _extraCullingFrustum.RemoveAllCullingPlanes(); 
     320            extraCullingFrustum.RemoveAllCullingPlanes(); 
    321321        } 
    322322 
     
    324324        { 
    325325            // make sure the extra culling frustum origin stuff is up to date 
    326             if (_extraCullingFrustum.ProjectionType == Projection.Perspective) 
     326            if (extraCullingFrustum.ProjectionType == Projection.Perspective) 
    327327            //if (!mCustomViewMatrix) 
    328328            { 
    329                 _extraCullingFrustum.SetUseOriginPlane(true); 
    330                 _extraCullingFrustum.SetOrigin(DerivedPosition); 
    331                 _extraCullingFrustum.SetOriginPlane(DerivedDirection, DerivedPosition); 
     329                extraCullingFrustum.SetUseOriginPlane(true); 
     330                extraCullingFrustum.Origin = DerivedPosition; 
     331                extraCullingFrustum.SetOriginPlane(DerivedDirection, DerivedPosition); 
    332332            } 
    333333            else 
     
    335335                // In ortho mode, we don't want to cull things behind camera. 
    336336                // This helps for back casting which is useful for texture shadow projection on directional light. 
    337                 _extraCullingFrustum.SetUseOriginPlane(false); 
     337                extraCullingFrustum.SetUseOriginPlane(false); 
    338338            } 
    339339 
  • branches/v0.8.0.0/Projects/Axiom/SceneManagers/PCZ/PCZFrustum.cs

    r2573 r2583  
    3939namespace Axiom.SceneManagers.PortalConnected 
    4040{ 
    41     public class PCZFrustum 
     41    public class PCZFrustum : DisposableObject  
    4242    { 
    4343        public enum Visibility 
     
    4848        } 
    4949 
    50         private Vector3 _origin = Vector3.Zero; 
    51         private Plane _originPlane = new Plane(); 
    52         private bool _useOriginPlane = false; 
    53         private List<PCPlane> _activeCullingPlanes = new List<PCPlane>(); 
    54         private List<PCPlane> _cullingPlaneReservoir = new List<PCPlane>(); 
    55         private Projection _projection = Projection.Perspective; 
     50        private Vector3 origin = Vector3.Zero; 
     51        private Plane originPlane = new Plane(); 
     52        private bool useOriginPlane = false; 
     53        private List<PCPlane> activeCullingPlanes = new List<PCPlane>(); 
     54        private List<PCPlane> cullingPlaneReservoir = new List<PCPlane>(); 
     55        private Projection projection = Projection.Perspective; 
    5656 
    5757        public PCZFrustum() 
    5858        { 
    59             _projection = Projection.Perspective; 
    60             _useOriginPlane = false; 
     59            projection = Projection.Perspective; 
     60            useOriginPlane = false; 
    6161        } 
    6262 
     
    6666 
    6767            // clear out the culling plane reservoir 
    68             _cullingPlaneReservoir.Clear(); 
    69         } 
    70  
    71         // set the origin value 
    72         public void SetOrigin(Vector3 newOrigin) 
    73         { 
    74             _origin = newOrigin; 
     68            cullingPlaneReservoir.Clear(); 
     69        } 
     70 
     71        public Vector3 Origin 
     72        { 
     73            get { return origin; } 
     74            set { origin = value; } 
    7575        } 
    7676 
     
    7878        public void SetUseOriginPlane(bool yesno) 
    7979        { 
    80             _useOriginPlane = yesno; 
     80            useOriginPlane = yesno; 
    8181        } 
    8282 
     
    9797 
    9898            // Check origin plane if told to 
    99             if (_useOriginPlane) 
    100             { 
    101                 PlaneSide side = _originPlane.GetSide(centre, halfSize); 
     99            if (useOriginPlane) 
     100            { 
     101                PlaneSide side = originPlane.GetSide(centre, halfSize); 
    102102                if (side == PlaneSide.Negative) 
    103103                { 
     
    108108            // For each extra active culling plane, see if the entire aabb is on the negative side 
    109109            // If so, object is not visible 
    110             foreach (PCPlane plane in _activeCullingPlanes) 
     110            foreach (PCPlane plane in activeCullingPlanes) 
    111111            { 
    112112                PlaneSide xside = plane.GetSide(centre, halfSize); 
     
    122122        { 
    123123            // Check origin plane if told to 
    124             if (_useOriginPlane) 
    125             { 
    126                 PlaneSide side = _originPlane.GetSide(bound.Center); 
     124            if (useOriginPlane) 
     125            { 
     126                PlaneSide side = originPlane.GetSide(bound.Center); 
    127127                if (side == PlaneSide.Negative) 
    128128                { 
    129                     Real dist = _originPlane.GetDistance(bound.Center); 
     129                    Real dist = originPlane.GetDistance(bound.Center); 
    130130                    if (dist > bound.Radius) 
    131131                    { 
     
    137137            // For each extra active culling plane, see if the entire sphere is on the negative side 
    138138            // If so, object is not visible 
    139             foreach (PCPlane plane in _activeCullingPlanes) 
     139            foreach (PCPlane plane in activeCullingPlanes) 
    140140            { 
    141141                PlaneSide xside = plane.GetSide(bound.Center); 
    142142                if (xside == PlaneSide.Negative) 
    143143                { 
    144                     float dist = _originPlane.GetDistance(bound.Center); 
     144                    float dist = originPlane.GetDistance(bound.Center); 
    145145                    if (dist > bound.Radius) 
    146146                    { 
     
    176176 
    177177            // if the frustum has no planes, just return true 
    178             if (_activeCullingPlanes.Count == 0) 
     178            if (activeCullingPlanes.Count == 0) 
    179179            { 
    180180                return true; 
     
    182182            // check if this portal is already in the list of active culling planes (avoid 
    183183            // infinite recursion case) 
    184             foreach (PCPlane plane in _activeCullingPlanes) 
     184            foreach (PCPlane plane in activeCullingPlanes) 
    185185            { 
    186186                if (plane.Portal == portal) 
     
    203203 
    204204            // check if the portal norm is facing the frustum 
    205             Vector3 frustumToPortal = portal.DerivedCP - _origin; 
     205            Vector3 frustumToPortal = portal.DerivedCP - origin; 
    206206            Vector3 portalDirection = portal.DerivedDirection; 
    207207            Real dotProduct = frustumToPortal.Dot(portalDirection); 
     
    216216 
    217217            // Check originPlane if told to 
    218             if (_useOriginPlane) 
     218            if (useOriginPlane) 
    219219            { 
    220220                // set the visible flag to false 
     
    223223                for (int corner = 0; corner < 4; corner++) 
    224224                { 
    225                     PlaneSide side = _originPlane.GetSide(portal.DerivedCorners[corner]); 
     225                    PlaneSide side = originPlane.GetSide(portal.DerivedCorners[corner]); 
    226226                    if (side != PlaneSide.Negative) 
    227227                    { 
     
    240240            // For each active culling plane, see if all portal points are on the negative 
    241241            // side. If so, the portal is not visible 
    242             foreach (PCPlane plane in _activeCullingPlanes) 
     242            foreach (PCPlane plane in activeCullingPlanes) 
    243243            { 
    244244                visible_flag = false; 
     
    292292 
    293293            // Check origin plane if told to 
    294             if (_useOriginPlane) 
    295             { 
    296                 PlaneSide side = _originPlane.GetSide(centre, halfSize); 
     294            if (useOriginPlane) 
     295            { 
     296                PlaneSide side = originPlane.GetSide(centre, halfSize); 
    297297                if (side == PlaneSide.Negative) 
    298298                { 
     
    308308            // For each active culling plane, see if the entire aabb is on the negative side 
    309309            // If so, object is not visible 
    310             foreach (PCPlane plane in _activeCullingPlanes) 
     310            foreach (PCPlane plane in activeCullingPlanes) 
    311311            { 
    312312                PlaneSide xside = plane.GetSide(centre, halfSize); 
     
    344344            { 
    345345                PCPlane newPlane = GetUnusedCullingPlane(); 
    346                 newPlane.SetFromAxiomPlane(_originPlane); 
     346                newPlane.SetFromAxiomPlane(originPlane); 
    347347                newPlane.Portal = portal; 
    348                 _activeCullingPlanes.Add(newPlane); 
     348                activeCullingPlanes.Add(newPlane); 
    349349                addedcullingplanes++; 
    350350                return addedcullingplanes; 
     
    367367                visible = true; 
    368368 
    369                 foreach (PCPlane plane in _activeCullingPlanes) 
     369                foreach (PCPlane plane in activeCullingPlanes) 
    370370                { 
    371371                    pt0_side = plane.GetSide(portal.DerivedCorners[i]); 
     
    383383                    // to the  culling plane 
    384384                    PCPlane newPlane = GetUnusedCullingPlane(); 
    385                     if (_projection == Projection.Orthographic) // use camera direction if projection is orthographic. 
    386                     { 
    387                         newPlane.Redefine(portal.DerivedCorners[j] + _originPlane.Normal, 
     385                    if (projection == Projection.Orthographic) // use camera direction if projection is orthographic. 
     386                    { 
     387                        newPlane.Redefine(portal.DerivedCorners[j] + originPlane.Normal, 
    388388                            portal.DerivedCorners[j], portal.DerivedCorners[i]); 
    389389                    } 
    390390                    else 
    391391                    { 
    392                         newPlane.Redefine(_origin, portal.DerivedCorners[j], portal.DerivedCorners[i]); 
     392                        newPlane.Redefine(origin, portal.DerivedCorners[j], portal.DerivedCorners[i]); 
    393393                    } 
    394394                    newPlane.Portal = portal; 
    395                     _activeCullingPlanes.Add(newPlane); 
     395                    activeCullingPlanes.Add(newPlane); 
    396396                    addedcullingplanes++; 
    397397                } 
     
    404404                newPlane.Redefine(portal.DerivedCorners[2], portal.DerivedCorners[1], portal.DerivedCorners[0]); 
    405405                newPlane.Portal = portal; 
    406                 _activeCullingPlanes.Add(newPlane); 
     406                activeCullingPlanes.Add(newPlane); 
    407407                addedcullingplanes++; 
    408408            } 
     
    413413        public void RemovePortalCullingPlanes(Portal portal) 
    414414        { 
    415             for (int i = 0; i < _activeCullingPlanes.Count; i++) 
    416             { 
    417                 PCPlane plane = _activeCullingPlanes[i]; 
     415            for (int i = 0; i < activeCullingPlanes.Count; i++) 
     416            { 
     417                PCPlane plane = activeCullingPlanes[i]; 
    418418                if (plane.Portal == portal) 
    419419                { 
    420                     _cullingPlaneReservoir.Add(plane); 
    421                     _activeCullingPlanes.Remove(plane); 
     420                    cullingPlaneReservoir.Add(plane); 
     421                    activeCullingPlanes.Remove(plane); 
    422422                } 
    423423            } 
     
    428428        public void RemoveAllCullingPlanes() 
    429429        { 
    430             foreach (PCPlane plane in _activeCullingPlanes) 
     430            foreach (PCPlane plane in activeCullingPlanes) 
    431431            { 
    432432                // put the plane back in the reservoir 
    433                 _cullingPlaneReservoir.Add(plane); 
    434             } 
    435  
    436             _activeCullingPlanes.Clear(); 
     433                cullingPlaneReservoir.Add(plane); 
     434            } 
     435 
     436            activeCullingPlanes.Clear(); 
    437437        } 
    438438 
     
    440440        public void SetOriginPlane(Vector3 rkNormal, Vector3 rkPoint) 
    441441        { 
    442             _originPlane.Redefine(rkNormal, rkPoint); 
     442            originPlane.Redefine(rkNormal, rkPoint); 
    443443        } 
    444444 
     
    448448        { 
    449449            PCPlane plane = null; 
    450             if (_cullingPlaneReservoir.Count > 0) 
    451             { 
    452                 plane = _cullingPlaneReservoir[0]; 
    453                 _cullingPlaneReservoir.RemoveAt(0); 
     450            if (cullingPlaneReservoir.Count > 0) 
     451            { 
     452                plane = cullingPlaneReservoir[0]; 
     453                cullingPlaneReservoir.RemoveAt(0); 
    454454                return plane; 
    455455            } 
     
    463463            get 
    464464            { 
    465                 return _projection; 
     465                return projection; 
    466466            } 
    467467            set 
    468468            { 
    469                 _projection = value; 
    470             } 
    471         } 
     469                projection = value; 
     470            } 
     471        } 
     472 
     473 
     474        #region IDisposable Implementation 
     475 
     476        /// <summary> 
     477        /// Class level dispose method 
     478        /// </summary> 
     479        /// <remarks> 
     480        /// When implementing this method in an inherited class the following template should be used; 
     481        /// protected override void dispose( bool disposeManagedResources ) 
     482        /// { 
     483        ///     if ( !isDisposed ) 
     484        ///     { 
     485        ///             if ( disposeManagedResources ) 
     486        ///             { 
     487        ///                     // Dispose managed resources. 
     488        ///             } 
     489        /// 
     490        ///             // There are no unmanaged resources to release, but 
     491        ///             // if we add them, they need to be released here. 
     492        ///     } 
     493        /// 
     494        ///     // If it is available, make the call to the 
     495        ///     // base class's Dispose(Boolean) method 
     496        ///     base.dispose( disposeManagedResources ); 
     497        /// } 
     498        /// </remarks> 
     499        /// <param name="disposeManagedResources">True if Unmanaged resources should be released.</param> 
     500        protected override void dispose(bool disposeManagedResources) 
     501        { 
     502            if (!this.IsDisposed) 
     503            { 
     504                if (disposeManagedResources) 
     505                { 
     506                    activeCullingPlanes.Clear(); 
     507                    cullingPlaneReservoir.Clear(); 
     508                    this.activeCullingPlanes = null; 
     509                    this.cullingPlaneReservoir = null; 
     510                } 
     511 
     512                // There are no unmanaged resources to release, but 
     513                // if we add them, they need to be released here. 
     514            } 
     515 
     516            base.dispose(disposeManagedResources); 
     517        } 
     518 
     519        #endregion IDisposable Implementation 
    472520 
    473521    } 
  • branches/v0.8.0.0/Projects/Axiom/SceneManagers/PCZ/PCZLight.cs

    r2573 r2583  
    5050        /// name generator 
    5151        /// </summary> 
    52         private static NameGenerator<PCZLight> _nameGenerator = new NameGenerator<PCZLight>("PCZLight"); 
     52        private static NameGenerator<PCZLight> nameGenerator = new NameGenerator<PCZLight>("PCZLight"); 
    5353 
    5454        /// <summary> 
     
    5656        /// visible in the current frame 
    5757        /// </summary> 
    58         private bool _affectsVisibleZone; 
     58        private bool affectsVisibleZone = false; 
    5959 
    6060        /// <summary> 
    6161        ///  
    6262        /// </summary> 
    63         private List<PCZone> _affectedZonesList; 
     63        private List<PCZone> affectedZonesList = new List<PCZone>(); 
    6464 
    6565        /// <summary> 
     
    6868        protected List<PCZone> AffectedZonesList 
    6969        { 
    70             get { return _affectedZonesList; } 
    71             set { _affectedZonesList = value; } 
     70            get { return affectedZonesList; } 
     71            set { affectedZonesList = value; } 
    7272        } 
    7373 
     
    7575        /// flag recording if light has moved, therefore affected list needs updating  
    7676        /// </summary> 
    77         private bool _needsUpdate; 
     77        private bool needsUpdate = true; 
    7878 
    7979        /// <summary> 
    8080        /// Update the list of zones the light affects  
    8181        /// </summary> 
    82         private PCZFrustum _portalFrustum = new PCZFrustum(); 
     82        private PCZFrustum portalFrustum = new PCZFrustum(); 
    8383 
    8484        /// <summary> 
     
    8686        /// </summary> 
    8787        public PCZLight() 
    88             : this(_nameGenerator.GetNextUniqueName()) 
     88            : this(nameGenerator.GetNextUniqueName()) 
    8989        { 
    9090        } 
     
    9797            : base(name) 
    9898        { 
    99             _needsUpdate = true; // need to update the first time, regardless of attachment or movement 
    10099        } 
    101100 
     
    142141        public bool AffectsVisibleZone 
    143142        { 
    144             get { return _affectsVisibleZone; } 
    145             set { _affectsVisibleZone = value; } 
     143            get { return affectsVisibleZone; } 
     144            set { affectsVisibleZone = value; } 
    146145        } 
    147146 
     
    156155            PCZone homeZone; 
    157156            AffectedZonesList.Clear(); 
    158             _affectsVisibleZone = false; 
     157            affectsVisibleZone = false; 
    159158            PCZSceneNode sn = (PCZSceneNode)(this.ParentSceneNode); 
    160159            if (sn != null) 
     
    167166                    if (homeZone.LastVisibleFrame == frameCount) 
    168167                    { 
    169                         _affectsVisibleZone = true; 
     168                        affectsVisibleZone = true; 
    170169                    } 
    171170                } 
     
    177176                    if (defaultZone.LastVisibleFrame == frameCount) 
    178177                    { 
    179                         _affectsVisibleZone = true; 
     178                        affectsVisibleZone = true; 
    180179                    } 
    181180                    return; 
     
    189188                if (defaultZone.LastVisibleFrame == frameCount) 
    190189                { 
    191                     _affectsVisibleZone = true; 
     190                    affectsVisibleZone = true; 
    192191                } 
    193192                return; 
     
    199198            //C++ TO C# CONVERTER NOTE: This static local variable declaration (not allowed in C#) has been moved just prior to the method: 
    200199            //                  static PCZFrustum portalFrustum; 
    201             Vector3 v = base.DerivedPosition; 
    202             _portalFrustum.SetOrigin(v); 
    203             homeZone.CheckLightAgainstPortals( this, frameCount, _portalFrustum, null); 
     200            portalFrustum.Origin = base.DerivedPosition; 
     201            homeZone.CheckLightAgainstPortals( this, frameCount, portalFrustum, null); 
    204202        } 
    205203 
     
    219217        { 
    220218            base.localTransformDirty = true; 
    221             _needsUpdate = true; // set need update flag 
     219            needsUpdate = true; // set need update flag 
    222220        } 
    223221 
     
    227225        public void ClearNeedsUpdate() 
    228226        { 
    229             _needsUpdate = false; 
     227            needsUpdate = false; 
    230228        } 
    231229 
     
    238236            get 
    239237            { 
    240                 if (_needsUpdate) // if this light has moved, return true immediately 
     238                if (needsUpdate) // if this light has moved, return true immediately 
    241239                    return true; 
    242240 
     
    251249                return false; // light hasn't moved, and no zones have updated portals. no light update. 
    252250            } 
    253             set { _needsUpdate = value; } 
     251            set { needsUpdate = value; } 
    254252        } 
    255253    } 
     
    265263        /// TypeName 
    266264        /// </summary> 
    267         public new const string TypeName = "PCZLight"; 
     265        public new const string TypeName = "Light"; 
    268266 
    269267        /// <summary> 
  • branches/v0.8.0.0/Projects/Axiom/SceneManagers/PCZ/PCZPlugin.cs

    r2574 r2583  
    3838#endregion Namespace Declarations 
    3939 
    40  
    4140namespace Axiom.SceneManagers.PortalConnected 
    4241{ 
    4342 
    44     //* Plugin instance for PCZ Manager  
     43    /// <summary> 
     44    /// Plugin instance for PCZ Scene Manager  
     45    /// </summary> 
    4546    public class PCZPlugin : IPlugin 
    4647    { 
    4748 
    48         private PCZSceneManagerFactory _pCZSMFactory; 
    49         private PCZLightFactory _pCZLightFactory; 
    50         private PortalFactory _portalFactory; 
    51         private AntiPortalFactory _antiPortalFactory; 
     49        private PCZSceneManagerFactory pCZSMFactory; 
     50        private PCZLightFactory pCZLightFactory; 
     51        private PortalFactory portalFactory; 
     52        private AntiPortalFactory antiPortalFactory; 
    5253 
     54        /// <summary> 
     55        /// Initialize the Plugin 
     56        /// </summary> 
    5357        public void Initialize() 
    5458        { 
    55             _pCZSMFactory = new PCZSceneManagerFactory(); 
    56             Root.Instance.AddSceneManagerFactory(_pCZSMFactory); 
     59            pCZSMFactory = new PCZSceneManagerFactory(); 
     60            Root.Instance.AddSceneManagerFactory(pCZSMFactory); 
    5761 
    58             _pCZLightFactory = new PCZLightFactory(); 
    59             Root.Instance.AddMovableObjectFactory(_pCZLightFactory, true); 
     62            pCZLightFactory = new PCZLightFactory(); 
     63            Root.Instance.AddMovableObjectFactory(pCZLightFactory, true); 
    6064 
    61             _portalFactory = new PortalFactory(); 
    62             Root.Instance.AddMovableObjectFactory(_portalFactory, true); 
     65            portalFactory = new PortalFactory(); 
     66            Root.Instance.AddMovableObjectFactory(portalFactory, true); 
    6367 
    64             _antiPortalFactory = new AntiPortalFactory(); 
    65             Root.Instance.AddMovableObjectFactory(_antiPortalFactory, true); 
     68            antiPortalFactory = new AntiPortalFactory(); 
     69            Root.Instance.AddMovableObjectFactory(antiPortalFactory, true); 
    6670 
    6771        } 
    6872 
     73        /// <summary> 
     74        /// Shutdown the plugin 
     75        /// </summary> 
    6976        public void Shutdown() 
    7077        { 
    71             Root.Instance.RemoveSceneManagerFactory(_pCZSMFactory); 
    72             Root.Instance.RemoveMovableObjectFactory(_pCZLightFactory); 
    73             Root.Instance.RemoveMovableObjectFactory(_portalFactory); 
    74             Root.Instance.RemoveMovableObjectFactory(_antiPortalFactory); 
     78            Root.Instance.RemoveSceneManagerFactory(pCZSMFactory); 
     79            Root.Instance.RemoveMovableObjectFactory(pCZLightFactory); 
     80            Root.Instance.RemoveMovableObjectFactory(portalFactory); 
     81            Root.Instance.RemoveMovableObjectFactory(antiPortalFactory); 
    7582        } 
    7683    } 
  • branches/v0.8.0.0/Projects/Axiom/SceneManagers/PCZ/PCZSceneManager.cs

    r2573 r2583  
    111111        /// name generator 
    112112        /// </summary> 
    113         private static NameGenerator<PCZSceneManager> _nameGenerator = new NameGenerator<PCZSceneManager>("PCZSceneManager"); 
     113        private static NameGenerator<PCZSceneManager> nameGenerator = new NameGenerator<PCZSceneManager>("PCZSceneManager"); 
    114114 
    115115        /// <summary> 
    116116        /// type of default zone to be used 
    117117        /// </summary> 
    118         private string _defaultZoneTypeName = "ZoneType_Default"; 
     118        private string defaultZoneTypeName = "ZoneType_Default"; 
    119119 
    120120        /// <summary> 
    121121        /// name of data file for default zone 
    122122        /// </summary> 
    123         private string _defaultZoneFileName = "none"; 
     123        private string defaultZoneFileName = "none"; 
    124124 
    125125        /// <summary> 
    126126        /// list of visible nodes 
    127127        /// </summary> 
    128         private List<PCZSceneNode> _visibleNodes = new List<PCZSceneNode>(); 
     128        private List<PCZSceneNode> visibleNodes = new List<PCZSceneNode>(); 
    129129 
    130130        /// <summary> 
    131131        /// The root PCZone 
    132132        /// </summary> 
    133         private PCZone _defaultZone = null; 
     133        private PCZone defaultZone = null; 
    134134 
    135135        /// <summary> 
    136136        /// The list of all PCZones 
    137137        /// </summary> 
    138         private readonly List<PCZone> _zones = new List<PCZone>(); 
     138        private readonly List<PCZone> zones = new List<PCZone>(); 
    139139 
    140140        /// <summary> 
    141141        /// Master list of Portals in the world (includes all portals) 
    142142        /// </summary> 
    143         private readonly List<Portal> _portals = new List<Portal>(); 
     143        private readonly List<Portal> portals = new List<Portal>(); 
    144144 
    145145        /// <summary> 
    146146        /// Portals visibility flag 
    147147        /// </summary> 
    148         private bool _showPortals = false; 
     148        private bool showPortals = false; 
    149149 
    150150        /// <summary> 
    151151        /// frame counter used in visibility determination 
    152152        /// </summary> 
    153         private ulong _frameCount = 0; 
     153        private ulong frameCount = 0; 
    154154 
    155155        /// <summary> 
    156156        /// ZoneFactoryManager instance 
    157157        /// </summary> 
    158         private PCZoneFactoryManager _zoneFactoryManager = null; 
     158        private PCZoneFactoryManager zoneFactoryManager = null; 
    159159 
    160160        /// <summary> 
    161161        /// The zone of the active camera (for shadow texture casting use) 
    162162        /// </summary> 
    163         private PCZone _activeCameraZone = null; 
     163        private PCZone activeCameraZone = null; 
    164164 
    165165        /// <summary> 
    166166        /// Test LightInfo List  (private) 
    167167        /// </summary> 
    168         private List<LightInfo> _testLightInfos = new List<LightInfo>(); 
     168        private List<LightInfo> testLightInfos = new List<LightInfo>(); 
    169169 
    170170        /// <summary> 
     
    173173        protected List<LightInfo> TestLightInfos 
    174174        { 
    175             get { return _testLightInfos; } 
    176             set { _testLightInfos = value; } 
     175            get { return testLightInfos; } 
     176            set { testLightInfos = value; } 
    177177        } 
    178178 
     
    180180        /// CachedLightInfos List (private) 
    181181        /// </summary> 
    182         protected List<LightInfo> _cachedLightInfos = new List<LightInfo>(); 
     182        private List<LightInfo> cachedLightInfos = new List<LightInfo>(); 
    183183 
    184184        /// <summary> 
     
    188188        { 
    189189 
    190             get { return _cachedLightInfos; } 
    191             set { _cachedLightInfos = value; } 
     190            get { return cachedLightInfos; } 
     191            set { cachedLightInfos = value; } 
    192192        } 
    193193 
     
    196196        /// </summary> 
    197197        public PCZSceneManager() 
    198             : this(_nameGenerator.GetNextUniqueName()) 
     198            : this(nameGenerator.GetNextUniqueName()) 
    199199        { 
    200200        } 
     
    245245 
    246246                    // delete ALL portals 
    247                     _portals.Clear(); 
     247                    portals.Clear(); 
    248248 
    249249                    // delete all the zones 
    250                     _zones.Clear(); 
    251                     _defaultZone = null; 
     250                    zones.Clear(); 
     251                    defaultZone = null; 
    252252                } 
    253253            } 
     
    263263            get 
    264264            { 
    265                 return _defaultZone; 
     265                return defaultZone; 
    266266            } 
    267267        } 
     
    275275        { 
    276276            // delete ALL portals 
    277             _portals.Clear(); 
     277            portals.Clear(); 
    278278 
    279279            // delete all the zones 
    280             _zones.Clear(); 
    281  
    282             _frameCount = 0; 
    283  
    284             this._defaultZoneTypeName = defaultZoneTypeName; 
    285             _defaultZoneFileName = filename; 
     280            zones.Clear(); 
     281 
     282            frameCount = 0; 
     283 
     284            this.defaultZoneTypeName = defaultZoneTypeName; 
     285            defaultZoneFileName = filename; 
    286286 
    287287            // create a new default zone 
    288             _zoneFactoryManager = PCZoneFactoryManager.Instance; 
    289             _defaultZone = CreateZoneFromFile(this._defaultZoneTypeName, "Default_Zone", RootSceneNode as PCZSceneNode, _defaultZoneFileName); 
     288            zoneFactoryManager = PCZoneFactoryManager.Instance; 
     289            defaultZone = CreateZoneFromFile(this.defaultZoneTypeName, "Default_Zone", RootSceneNode as PCZSceneNode, defaultZoneFileName); 
    290290        } 
    291291 
     
    299299        { 
    300300            Portal newPortal = new Portal(name, type); 
    301             _portals.Add(newPortal); 
     301            portals.Add(newPortal); 
    302302            return newPortal; 
    303303        } 
     
    325325 
    326326            // remove the portal from the master portal list 
    327             _portals.Remove(portal); 
     327            portals.Remove(portal); 
    328328        } 
    329329 
     
    336336            // find the portal from the master portal list 
    337337            Portal thePortal = null; 
    338             foreach (Portal portal in _portals) 
     338            foreach (Portal portal in portals) 
    339339            { 
    340340                if (portal.Name == name) 
    341341                { 
    342342                    thePortal = portal; 
    343                     _portals.Remove(portal); 
     343                    portals.Remove(portal); 
    344344                    break; 
    345345                } 
     
    386386 
    387387            // create a new default zone 
    388             newZone = _zoneFactoryManager.CreatePCZone(this, zoneTypeName, zoneName); 
     388            newZone = zoneFactoryManager.CreatePCZone(this, zoneTypeName, zoneName); 
    389389            // add to the global list of zones 
    390             _zones.Add(newZone); 
     390            zones.Add(newZone); 
    391391            if (filename != "none") 
    392392            { 
     
    405405        public PCZone GetZoneByName(string name) 
    406406        { 
    407             foreach (PCZone zone in _zones) 
     407            foreach (PCZone zone in zones) 
    408408            { 
    409409                if (zone.Name == name) 
     
    426426                                     string filename) 
    427427        { 
    428             foreach (PCZone zone in _zones) 
     428            foreach (PCZone zone in zones) 
    429429            { 
    430430                if (zone.Name == name) 
     
    510510 
    511511            // tell all the zones about the new camera 
    512             foreach (PCZone zone in _zones) 
     512            foreach (PCZone zone in zones) 
    513513            { 
    514514                zone.NotifyCameraCreated(c); 
     
    544544 
    545545            // delete all the zones 
    546             _zones.Clear(); 
    547             _defaultZone = null; 
     546            zones.Clear(); 
     547            defaultZone = null; 
    548548 
    549549            // re-initialize 
    550             Init(_defaultZoneTypeName, _defaultZoneFileName); 
     550            Init(defaultZoneTypeName, defaultZoneFileName); 
    551551        } 
    552552 
     
    557557        { 
    558558            // notify all the zones that a scene render is starting 
    559             foreach (PCZone zone in _zones) 
     559            foreach (PCZone zone in zones) 
    560560            { 
    561561                zone.NotifyBeginRenderScene(); 
     
    572572            { 
    573573                // if no zone specified, use default zone 
    574                 zone = _defaultZone; 
     574                zone = defaultZone; 
    575575            } 
    576576            if (null != skyBoxNode) 
     
    641641        public void UpdatePortalZoneData() 
    642642        { 
    643             foreach (PCZone zone in _zones) 
     643            foreach (PCZone zone in zones) 
    644644            { 
    645645                // this call checks for portal zone changes & applies zone data changes as necessary 
     
    671671                    if (l.NeedsUpdate) 
    672672                    { 
    673                         l.UpdateZones(((PCZSceneNode)(cam.ParentSceneNode)).HomeZone, _frameCount); 
     673                        l.UpdateZones(((PCZSceneNode)(cam.ParentSceneNode)).HomeZone, frameCount); 
    674674                    } 
    675675                    l.NeedsUpdate = false; 
     
    687687        { 
    688688            // Skip if root Zone has been destroyed (shutdown conditions) 
    689             if (null == _defaultZone) 
     689            if (null == defaultZone) 
    690690            { 
    691691                return; 
     
    724724        { 
    725725            // Skip if mDefaultZone has been destroyed (shutdown conditions) 
    726             if (null == _defaultZone) 
     726            if (null == defaultZone) 
    727727            { 
    728728                return; 
     
    751751        public PCZone CreateZone(string zoneType, string instanceName) 
    752752        { 
    753             foreach (PCZone zone in _zones) 
     753            foreach (PCZone zone in zones) 
    754754            { 
    755755                if (zone.Name == instanceName) 
     
    759759            } 
    760760 
    761             PCZone newZone = _zoneFactoryManager.CreatePCZone(this, zoneType, instanceName); 
     761            PCZone newZone = zoneFactoryManager.CreatePCZone(this, zoneType, instanceName); 
    762762            if (null != newZone) 
    763763            { 
    764764                // add to the global list of zones 
    765                 _zones.Add(newZone); 
     765                zones.Add(newZone); 
    766766                if (newZone.RequiresZoneSpecificNodeData) 
    767767                { 
     
    815815            } 
    816816 
    817             _zones.Remove(zone); 
     817            zones.Remove(zone); 
    818818        } 
    819819 
     
    836836        { 
    837837            // Skip if root PCZoneTree has been destroyed (shutdown conditions) 
    838             if (null == _defaultZone) 
     838            if (null == defaultZone) 
    839839            { 
    840840                return; 
     
    882882        public PCZone FindZoneForPoint(Vector3 point) 
    883883        { 
    884             PCZone bestZone = _defaultZone; 
     884            PCZone bestZone = defaultZone; 
    885885            Real bestVolume = Real.PositiveInfinity; 
    886886 
    887             foreach (PCZone zone in _zones) 
     887            foreach (PCZone zone in zones) 
    888888            { 
    889889                AxisAlignedBox aabb = new AxisAlignedBox(); 
     
    914914        public void CreateZoneSpecificNodeData(PCZSceneNode node) 
    915915        { 
    916             foreach (PCZone zone in _zones) 
     916            foreach (PCZone zone in zones) 
    917917            { 
    918918                if (zone.RequiresZoneSpecificNodeData) 
     
    10181018                            lightInfo.Position = Vector3.Zero; 
    10191019                            lightInfo.Range = 0; 
    1020                             _testLightInfos.Add(lightInfo); 
     1020                            testLightInfos.Add(lightInfo); 
    10211021                        } 
    10221022                        else 
     
    10291029                            if (camera.IsObjectVisible(sphere)) 
    10301030                            { 
    1031                                 _testLightInfos.Add(lightInfo); 
     1031                                testLightInfos.Add(lightInfo); 
    10321032                            } 
    10331033                        } 
     
    10411041 
    10421042            // Update lights affecting frustum if changed 
    1043             if (_cachedLightInfos != _testLightInfos) 
     1043            if (cachedLightInfos != testLightInfos) 
    10441044            { 
    10451045                //mLightsAffectingFrustum.resize(mTestLightInfos.size()); 
     
    10571057                //} 
    10581058 
    1059                 foreach (LightInfo i in _testLightInfos) 
     1059                foreach (LightInfo i in testLightInfos) 
    10601060                { 
    10611061                    if (IsShadowTechniqueTextureBased) 
     
    10961096                // Use swap instead of copy operator for efficiently 
    10971097                //mCachedLightInfos.swap(mTestLightInfos); 
    1098                 _cachedLightInfos = _testLightInfos; 
     1098                cachedLightInfos = testLightInfos; 
    10991099 
    11001100                // notify light dirty, so all movable objects will re-populate 
     
    11221122                PCZSceneNode node = (PCZSceneNode)rootSceneNode.CreateChildSceneNode(shadowTextureCameras[i].Name); 
    11231123                node.AttachObject(shadowTextureCameras[i]); 
    1124                 AddPCZSceneNode(node, _defaultZone); 
     1124                AddPCZSceneNode(node, defaultZone); 
    11251125            } 
    11261126        } 
     
    11431143            if (((PCZSceneNode)cam.ParentSceneNode) != null) 
    11441144            { 
    1145                 _activeCameraZone = ((PCZSceneNode)cam.ParentSceneNode).HomeZone; 
     1145                activeCameraZone = ((PCZSceneNode)cam.ParentSceneNode).HomeZone; 
    11461146            } 
    11471147            base.PrepareShadowTextures(cam, vp); 
     
    11551155            if (light.Type == LightType.Directional) 
    11561156            { 
    1157                 if (camNode.HomeZone != _activeCameraZone) 
    1158                 { 
    1159                     AddPCZSceneNode(camNode, _activeCameraZone); 
     1157                if (camNode.HomeZone != activeCameraZone) 
     1158                { 
     1159                    AddPCZSceneNode(camNode, activeCameraZone); 
    11601160                } 
    11611161            } 
     
    11811181            // go through every zone to find portals 
    11821182            bool foundMatch; 
    1183             foreach (PCZone zone in _zones) 
     1183            foreach (PCZone zone in zones) 
    11841184            { 
    11851185                // go through all the portals in the zone 
     
    11941194                        foundMatch = false; 
    11951195                        int j = 0; 
    1196                         while (!foundMatch && j != _zones.Count) 
     1196                        while (!foundMatch && j != zones.Count) 
    11971197                        { 
    1198                             zone2 = _zones[j++]; 
     1198                            zone2 = zones[j++]; 
    11991199                            if (zone2 != zone) // make sure we don't look in the same zone 
    12001200                            { 
     
    12311231            renderQueue.Clear(); 
    12321232            // clear the list of visible nodes 
    1233             _visibleNodes.Clear(); 
     1233            visibleNodes.Clear(); 
    12341234 
    12351235            // turn off sky 
     
    12411241            // increment the visibility frame counter 
    12421242            //mFrameCount++; 
    1243             _frameCount = Root.Instance.CurrentFrameCount; 
     1243            frameCount = Root.Instance.CurrentFrameCount; 
    12441244 
    12451245            // update the camera 
     
    12511251            // walk the zones, starting from the camera home zone, 
    12521252            // adding all visible scene nodes to the mVisibles list 
    1253             cameraHomeZone.LastVisibleFrame = _frameCount; 
     1253            cameraHomeZone.LastVisibleFrame = frameCount; 
    12541254            cameraHomeZone.FindVisibleNodes((PCZCamera)cam, 
    1255                                              ref _visibleNodes, 
     1255                                             ref visibleNodes, 
    12561256                                             renderQueue, 
    12571257                                             visibleBounds, 
     
    12751275            { 
    12761276                // no start zone specified, so check all zones 
    1277                 foreach (PCZone zone in _zones) 
     1277                foreach (PCZone zone in zones) 
    12781278                { 
    12791279                    zone.FindNodes(box, ref list, visitedPortals, false, false, exclude); 
     
    12961296            { 
    12971297                // no start zone specified, so check all zones 
    1298                 foreach (PCZone zone in _zones) 
     1298                foreach (PCZone zone in zones) 
    12991299                { 
    13001300                    zone.FindNodes(sphere, ref list, visitedPortals, false, false, exclude); 
     
    13171317            { 
    13181318                // no start zone specified, so check all zones 
    1319                 foreach (PCZone zone in _zones) 
     1319                foreach (PCZone zone in zones) 
    13201320                { 
    13211321                    zone.FindNodes(volumes, ref list, visitedPortals, false, false, exclude); 
     
    13371337            else 
    13381338            { 
    1339                 foreach (PCZone zone in _zones) 
     1339                foreach (PCZone zone in zones) 
    13401340                { 
    13411341                    zone.FindNodes(r, ref list, visitedPortals, false, false, exclude); 
     
    13741374            else if (key == "ShowPortals") 
    13751375            { 
    1376                 _showPortals = Convert.ToBoolean(val); 
     1376                showPortals = Convert.ToBoolean(val); 
    13771377                return true; 
    13781378            } 
    13791379            // send option to each zone 
    1380             foreach (PCZone zone in _zones) 
     1380            foreach (PCZone zone in zones) 
    13811381            { 
    13821382                if (zone.SetOption(key, val) == true) 
     
    14081408            if (key == "ShowPortals") 
    14091409            { 
    1410                 val = _showPortals; 
     1410                val = showPortals; 
    14111411                return true; 
    14121412            } 
     
    14701470        public void ClearAllZonesPortalUpdateFlag() 
    14711471        { 
    1472             foreach (PCZone zone in _zones) 
     1472            foreach (PCZone zone in zones) 
    14731473            { 
    14741474                zone.PortalsUpdated = true; 
     
    14911491            get 
    14921492            { 
    1493                 return _showPortals; 
     1493                return showPortals; 
    14941494            } 
    14951495            set 
    14961496            { 
    1497                 _showPortals = value; 
     1497                showPortals = value; 
    14981498            } 
    14991499        } 
     
    15081508            { 
    15091509                // notify zones of new value 
    1510                 foreach (PCZone pcZone in _zones) 
     1510                foreach (PCZone pcZone in zones) 
    15111511                { 
    15121512                    pcZone.WorldGeometryRenderQueueId = value; 
  • branches/v0.8.0.0/Projects/Axiom/SceneManagers/PCZ/PCZSceneNode.cs

    r2573 r2583  
    5151        private static NameGenerator<PCZSceneNode> _nameGenerator = new NameGenerator<PCZSceneNode>("PCZSceneNode"); 
    5252 
     53        /// <summary> 
     54        /// NewPosition 
     55        /// </summary> 
    5356        protected Vector3 NewPosition = Vector3.Zero; 
    54         protected PCZone mHomeZone = null; 
    55         public bool Anchored = false; 
    56         public bool AllowToVisit = true; 
    57         public bool AllowedToVisit = true; 
     57 
     58        private PCZone homeZone = null; 
     59 
     60        private bool anchored = false; 
     61        /// <summary> 
     62        /// Anchored 
     63        /// </summary> 
     64        public bool Anchored 
     65        { 
     66            get { return anchored; } 
     67            set { anchored = value; } 
     68        } 
     69 
     70        private bool allowToVisit = true; 
     71        /// <summary> 
     72        /// AllowToVisit 
     73        /// </summary> 
     74        public bool AllowToVisit 
     75        { 
     76            get { return allowToVisit; } 
     77            set { allowToVisit = value; } 
     78        } 
     79 
     80        private bool allowedToVisit = true; 
     81        /// <summary> 
     82        /// AllowedToVisit 
     83        /// </summary> 
     84        public bool AllowedToVisit 
     85        { 
     86            get { return allowedToVisit; } 
     87            set { allowedToVisit = value; } 
     88        } 
     89 
     90        /// <summary> 
     91        /// VisitingZones 
     92        /// </summary> 
    5893        protected Dictionary<string, PCZone> VisitingZones = new Dictionary<string, PCZone>(); 
    59         public Vector3 PrevPosition = Vector3.Zero; 
    60         public ulong LastVisibleFrame = 0; 
    61         public PCZCamera LastVisibleFromCamera; 
     94 
     95        private Vector3 prevPosition = Vector3.Zero; 
     96        /// <summary> 
     97        /// PrevPosition 
     98        /// </summary> 
     99        public Vector3 PrevPosition 
     100        { 
     101            get { return prevPosition; } 
     102            set { prevPosition = value; } 
     103        } 
     104 
     105        private ulong lastVisibleFrame = 0; 
     106        /// <summary> 
     107        /// LastVisibleFrame 
     108        /// </summary> 
     109        public ulong LastVisibleFrame 
     110        { 
     111            get { return lastVisibleFrame; } 
     112            set { lastVisibleFrame = value; } 
     113        } 
     114 
     115        private PCZCamera lastVisibleFromCamera = null; 
     116        /// <summary> 
     117        /// LastVisibleFromCamera 
     118        /// </summary> 
     119        public PCZCamera LastVisibleFromCamera 
     120        { 
     121            get { return lastVisibleFromCamera; } 
     122            set { lastVisibleFromCamera = value; } 
     123        } 
     124 
     125        /// <summary> 
     126        /// ZoneData 
     127        /// </summary> 
    62128        protected Dictionary<string, ZoneData> ZoneData = new Dictionary<string, ZoneData>(); 
    63         public bool Enabled = true; 
    64         public bool Moved = false; 
     129 
     130 
     131        private bool enabled = true; 
     132        /// <summary> 
     133        /// Enabled 
     134        /// </summary> 
     135        public bool Enabled 
     136        { 
     137            get { return enabled; } 
     138            set { enabled = value; } 
     139        } 
     140 
     141        private bool moved = false; 
     142        /// <summary> 
     143        /// Moved 
     144        /// </summary> 
     145        public bool Moved 
     146        { 
     147            get { return moved; } 
     148            set { moved = value; } 
     149        } 
    65150 
    66151        //* Standard constructor  
     
    91176                UpdateBounds(); 
    92177 
    93             PrevPosition = NewPosition; 
     178            prevPosition = NewPosition; 
    94179            NewPosition = DerivedPosition; 
    95180        } 
     
    99184        { 
    100185            base.UpdateFromParent(); 
    101             Moved = true; 
     186            moved = true; 
    102187        } 
    103188 
     
    158243            get 
    159244            { 
    160                 return mHomeZone; 
     245                return homeZone; 
    161246            } 
    162247            set 
     
    164249                // if the new home zone is different than the current, remove 
    165250                // the node from the current home zone's list of home nodes first 
    166                 if (value != mHomeZone && mHomeZone != null) 
     251                if (value != homeZone && homeZone != null) 
    167252                { 
    168                     mHomeZone.RemoveNode(this); 
     253                    homeZone.RemoveNode(this); 
    169254                } 
    170                 mHomeZone = value; 
     255                homeZone = value; 
    171256            } 
    172257        } 
     
    174259        public void AnchorToHomeZone(PCZone zone) 
    175260        { 
    176             mHomeZone = zone; 
     261            homeZone = zone; 
    177262            if (zone != null) 
    178263            { 
     
    313398 
    314399        } 
    315         public void Enable(bool yesno) 
    316         { 
    317             Enabled = yesno; 
    318         } 
    319         public bool IsEnabled() 
    320         { 
    321             return Enabled; 
    322         } 
    323400 
    324401    } 
  • branches/v0.8.0.0/Projects/Axiom/SceneManagers/PCZ/PCZone.cs

    r2573 r2583  
    4848    public abstract class PCZone : DisposableObject 
    4949    { 
    50  
     50        /// <summary> 
     51        /// Node List Type 
     52        /// </summary> 
    5153        public enum NodeListType : int 
    5254        { 
     
    6062        private static NameGenerator<PCZone> _nameGenerator = new NameGenerator<PCZone>("PCZone"); 
    6163 
    62         // name of the zone (must be unique) 
    63         public string Name = ""; 
     64        private string name = ""; 
     65        /// <summary> 
     66        /// name of the zone (must be unique) 
     67        /// </summary> 
     68        public string Name 
     69        { 
     70            get { return name; } 
     71            set { name = value; } 
     72 
     73        } 
     74 
     75        private string zoneTypeName = "ZoneType_Undefined"; 
     76        /// <summary> 
    6477        /// Zone type name 
    65         public string ZoneTypeName = "ZoneType_Undefined"; 
    66         // frame counter for visibility 
    67         public ulong LastVisibleFrame = 0; 
    68         // last camera which this zone was visible to 
    69         public PCZCamera LastVisibleFromCamera = null; 
     78        /// </summary> 
     79        public string ZoneTypeName 
     80        { 
     81            get { return zoneTypeName; } 
     82            set { zoneTypeName = value; } 
     83        } 
     84 
     85        private ulong lastVisibleFrame = 0; 
     86        /// <summary> 
     87        /// frame counter for visibility 
     88        /// </summary> 
     89        public ulong LastVisibleFrame 
     90        { 
     91            get { return lastVisibleFrame; } 
     92            set { lastVisibleFrame = value; } 
     93        } 
     94 
     95        private PCZCamera lastVisibleFromCamera = null; 
     96        /// <summary> 
     97        /// last camera which this zone was visible to 
     98        /// </summary> 
     99        public PCZCamera LastVisibleFromCamera 
     100        { 
     101            get { return lastVisibleFromCamera; } 
     102            set { lastVisibleFromCamera = value; } 
     103        } 
     104 
    70105        // flag determining whether or not this zone has sky in it. 
    71         public bool HasSky = false; 
     106        private bool hasSky = false; 
     107        public bool HasSky 
     108        { 
     109            get { return hasSky; } 
     110            set { hasSky = value; } 
     111        } 
     112 
    72113        //SceneNode which corresponds to the enclosure for this zone 
    73114        private PCZSceneNode _enclosureNode = null; 
     
    77118            set { _enclosureNode = value; } 
    78119        } 
    79  
    80         // list of SceneNodes contained in this particular PCZone 
    81         public List<PCZSceneNode> HomeNodeList = new List<PCZSceneNode>(); 
     120         
     121        private List<PCZSceneNode> homeNodeList = new List<PCZSceneNode>(); 
     122        /// <summary> 
     123        /// list of SceneNodes contained in this particular PCZone 
     124        /// </summary> 
     125        public List<PCZSceneNode> HomeNodeList 
     126        { 
     127            get { return homeNodeList; } 
     128            set { homeNodeList = value; } 
     129        } 
     130 
    82131        // list of SceneNodes visiting this particular PCZone 
    83         public List<PCZSceneNode> VisitorNodeList = new List<PCZSceneNode>(); 
    84         // flag recording whether any portals in this zone have moved  
    85         private bool mPortalsUpdated = false; 
    86         //* list of Portals which this zone contains (each portal leads to another zone) 
    87         public List<Portal> Portals = new List<Portal>(); 
    88         public List<AntiPortal> AntiPortals = new List<AntiPortal>(); 
    89         // pointer to the pcz scene manager that created this zone 
    90         public PCZSceneManager PCZSM = new PCZSceneManager(""); 
     132        private List<PCZSceneNode> visitorNodeList = new List<PCZSceneNode>(); 
     133        public List<PCZSceneNode> VisitorNodeList 
     134        { 
     135            get { return visitorNodeList; } 
     136            set { visitorNodeList = value; } 
     137        } 
     138 
     139        private bool portalsUpdated = false; 
     140        /// <summary> 
     141        /// flag recording whether any portals in this zone have moved  
     142        /// </summary> 
     143        public bool PortalsUpdated 
     144        { 
     145            get { return portalsUpdated; } 
     146            set { portalsUpdated = value; } 
     147        } 
     148        private List<Portal> portals = new List<Portal>(); 
     149        /// <summary> 
     150        /// list of Portals which this zone contains (each portal leads to another zone) 
     151        /// </summary> 
     152        public List<Portal> Portals 
     153        { 
     154            get { return portals; } 
     155            set { portals = value; } 
     156        } 
     157 
     158        private List<AntiPortal> antiPortals = new List<AntiPortal>(); 
     159        public List<AntiPortal> AntiPortals 
     160        { 
     161            get { return antiPortals; } 
     162            set { antiPortals = value; } 
     163        } 
     164 
     165        private PCZSceneManager pCZSM = new PCZSceneManager(""); 
     166        /// <summary> 
     167        /// pointer to the pcz scene manager that created this zone 
     168        /// </summary> 
     169        public PCZSceneManager PCZSM 
     170        { 
     171            get { return pCZSM; } 
     172            set { pCZSM = value; } 
     173        } 
     174 
    91175        // user defined data pointer - NOT allocated or deallocated by the zone!   
    92176        // you must clean it up yourself! 
    93         protected object mUserData = null; 
     177        private object userData = null; 
    94178 
    95179        /// <summary> 
     
    101185        } 
    102186 
     187        /// <summary> 
     188        /// Constructor 
     189        /// </summary> 
     190        /// <param name="creator">PCZSceneManager</param> 
     191        /// <param name="name">string</param> 
    103192        public PCZone(PCZSceneManager creator, string name) 
    104193        { 
    105194            Name = name; 
    106             PCZSM = creator; 
    107             HasSky = false; 
    108         } 
    109         public void Dispose() 
    110         { 
    111         } 
    112  
    113  
    114         public abstract void AddNode(PCZSceneNode NamelessParameter); 
    115  
    116         //    * Removes all references to a SceneNode from this PCZone.         
    117         public abstract void RemoveNode(PCZSceneNode NamelessParameter); 
    118  
    119         //    * Remove all nodes from the node reference list and clear it 
    120         public void ClearNodeLists(short type) 
    121         { 
    122             HomeNodeList.Clear(); 
    123             VisitorNodeList.Clear(); 
    124  
    125         } 
    126  
    127         //    * Indicates whether or not this zone requires zone-specific data for  
    128         //               *  each scene node 
    129         //                
     195            pCZSM = creator; 
     196            hasSky = false; 
     197        } 
     198 
     199        #region IDisposable Implementation 
     200 
     201        /// <summary> 
     202        /// Class level dispose method 
     203        /// </summary> 
     204        /// <remarks> 
     205        /// When implementing this method in an inherited class the following template should be used; 
     206        /// protected override void dispose( bool disposeManagedResources ) 
     207        /// { 
     208        ///     if ( !isDisposed ) 
     209        ///     { 
     210        ///             if ( disposeManagedResources ) 
     211        ///             { 
     212        ///                     // Dispose managed resources. 
     213        ///             } 
     214        /// 
     215        ///             // There are no unmanaged resources to release, but 
     216        ///             // if we add them, they need to be released here. 
     217        ///     } 
     218        /// 
     219        ///     // If it is available, make the call to the 
     220        ///     // base class's Dispose(Boolean) method 
     221        ///     base.dispose( disposeManagedResources ); 
     222        /// } 
     223        /// </remarks> 
     224        /// <param name="disposeManagedResources">True if Unmanaged resources should be released.</param> 
     225        protected override void dispose(bool disposeManagedResources) 
     226        { 
     227            if (!this.IsDisposed) 
     228            { 
     229                if (disposeManagedResources) 
     230                { 
     231                    ClearNodeLists(); 
     232                    this.homeNodeList = null; 
     233                    this.visitorNodeList = null; 
     234                } 
     235 
     236                // There are no unmanaged resources to release, but 
     237                // if we add them, they need to be released here. 
     238            } 
     239 
     240            base.dispose(disposeManagedResources); 
     241        } 
     242 
     243        #endregion IDisposable Implementation 
     244 
     245        /// <summary> 
     246        /// AddNode 
     247        /// </summary> 
     248        /// <param name="node">PCZSceneNode</param> 
     249        public abstract void AddNode(PCZSceneNode node); 
     250 
     251        /// <summary> 
     252        /// Removes all references to a SceneNode from this PCZone.    
     253        /// </summary> 
     254        /// <param name="node">PCZSceneNode</param> 
     255        public abstract void RemoveNode(PCZSceneNode node); 
     256 
     257        /// <summary> 
     258        /// Remove all nodes from the node reference list and clear it 
     259        /// </summary> 
     260        /// <param name="type">ClearNodeLists</param> 
     261        public void ClearNodeLists() 
     262        { 
     263            homeNodeList.Clear(); 
     264            visitorNodeList.Clear(); 
     265 
     266        } 
     267 
     268        /// <summary> 
     269        /// Indicates whether or not this zone requires zone-specific data for each scene node 
     270        /// </summary> 
    130271        private bool _RequiresZoneSpecificNodeData = false; 
    131272        public virtual bool RequiresZoneSpecificNodeData 
     
    135276        } 
    136277 
    137         //    * create zone specific data for a node 
    138         // create node specific zone data if necessary 
    139         public void CreateNodeZoneData(PCZSceneNode UnnamedParameter1) 
    140         { 
    141         } 
    142  
    143         //    * find a matching portal (for connecting portals) 
    144         //               
     278        /// <summary> 
     279        /// create zone specific data for a node 
     280        /// create node specific zone data if necessary 
     281        /// </summary> 
     282        /// <param name="node">PCZSceneNode</param> 
     283        public void CreateNodeZoneData(PCZSceneNode node) 
     284        { 
     285        } 
     286 
     287 
     288        /// <summary> 
     289        /// find a matching portal (for connecting portals) 
     290        /// </summary> 
     291        /// <param name="portal">Portal</param> 
     292        /// <returns>Portal</returns> 
    145293        public Portal FindMatchingPortal(Portal portal) 
    146294        { 
     
    160308        } 
    161309 
    162         // Add a portal to the zone  
     310        /// <summary> 
     311        /// Add a portal to the zone  
     312        /// </summary> 
     313        /// <param name="newPortal">Portal</param> 
    163314        public void AddPortal(Portal newPortal) 
    164315        { 
     
    182333        } 
    183334 
    184         // Remove a portal from the zone  
    185  
    186         // Remove a portal from the zone (does not erase the portal object, just removes reference)  
     335        /// <summary> 
     336        /// Remove a portal from the zone (does not erase the portal object, just removes reference)  
     337        /// </summary> 
     338        /// <param name="removePortal">Portal</param> 
    187339        public void RemovePortal(Portal removePortal) 
    188340        { 
     
    193345        } 
    194346 
    195         // Add an anti portal to the zone  
    196  
    197         // Add an anti portal to the zone  
     347        /// <summary> 
     348        /// Add an anti portal to the zone  
     349        /// </summary> 
     350        /// <param name="newAntiPortal"></param> 
    198351        public void AddAntiPortal(AntiPortal newAntiPortal) 
    199352        { 
     
    216369        } 
    217370 
    218         // Remove an anti portal from the zone  
    219  
    220         // Remove an anti portal from the zone  
     371        /// <summary> 
     372        /// Remove an anti portal from the zone  
     373        /// </summary> 
     374        /// <param name="removeAntiPortal">AntiPortal</param> 
    221375        public void _removeAntiPortal(AntiPortal removeAntiPortal) 
    222376        { 
     
    227381        } 
    228382 
    229         //    * (recursive) check the given node against all portals in the zone 
    230         //               
    231         public abstract void CheckNodeAgainstPortals(PCZSceneNode NamelessParameter1, Portal NamelessParameter2); 
    232  
    233         //    * (recursive) check the given light against all portals in the zone 
    234         //     
     383        /// <summary> 
     384        /// (recursive) check the given node against all portals in the zone 
     385        /// </summary> 
     386        /// <param name="node">PCZSceneNode</param> 
     387        /// <param name="portal">portal</param> 
     388        public abstract void CheckNodeAgainstPortals(PCZSceneNode node, Portal portal); 
     389 
     390        /// <summary> 
     391        /// (recursive) check the given light against all portals in the zone 
     392        /// </summary> 
     393        /// <param name="light">light</param> 
     394        /// <param name="frameCount">frameCount</param> 
     395        /// <param name="portalFrustum">PCZFrustum</param> 
     396        /// <param name="ignorePortal">Portal</param> 
    235397        public abstract void CheckLightAgainstPortals(PCZLight light, 
    236398                                               ulong frameCount, 
     
    238400                                               Portal ignorePortal); 
    239401 
    240         //     Update the zone data for each portal  
    241         //               
     402        /// <summary> 
     403        /// Update the zone data for each portal  
     404        /// </summary> 
    242405        public abstract void UpdatePortalsZoneData(); 
    243406 
    244         //* Mark nodes dirty base on moving portals.  
     407        /// <summary> 
     408        /// Mark nodes dirty base on moving portals.  
     409        /// </summary> 
    245410        public abstract void DirtyNodeByMovingPortals(); 
    246411 
    247         // Update a node's home zone  
     412        /// <summary> 
     413        /// Update a node's home zone  
     414        /// </summary> 
     415        /// <param name="pczsn">PCZSceneNode/param> 
     416        /// <param name="allowBackTouces">bool</param> 
     417        /// <returns>PCZSceneNode</returns> 
    248418        public abstract PCZone UpdateNodeHomeZone(PCZSceneNode pczsn, bool allowBackTouces); 
    249419 
    250         //    * Find and add visible objects to the render queue. 
    251         //    @remarks 
    252         //    Starts with objects in the zone and proceeds through visible portals    
    253         //    This is a recursive call (the main call should be to _findVisibleObjects) 
    254         //     
    255         /** Find and add visible objects to the render queue. 
    256         @remarks 
    257         Starts with objects in the zone and proceeds through visible portals 
    258         This is a recursive call (the main call should be to _findVisibleObjects) 
    259         */ 
     420        /// <summary> 
     421        ///  Find and add visible objects to the render queue. 
     422        ///    @remarks 
     423        ///    Starts with objects in the zone and proceeds through visible portals    
     424        ///    This is a recursive call (the main call should be to _findVisibleObjects) 
     425        ///     
     426        /// Find and add visible objects to the render queue. 
     427        /// @remarks 
     428        ///     Starts with objects in the zone and proceeds through visible portals 
     429        ///     This is a recursive call (the main call should be to _findVisibleObjects) 
     430        /// </summary> 
     431        /// <param name="camera">PCZCamera</param> 
     432        /// <param name="visibleNodeList">List<PCZSceneNode></param> 
     433        /// <param name="queue">RenderQueue</param> 
     434        /// <param name="visibleBounds">VisibleObjectsBoundsInfo</param> 
     435        /// <param name="onlyShadowCasters">bool</param> 
     436        /// <param name="displayNodes">bool</param> 
     437        /// <param name="showBoundingBoxes">bool</param> 
    260438        public abstract void FindVisibleNodes(PCZCamera camera, 
    261439                                      ref List<PCZSceneNode> visibleNodeList, 
     
    266444                                      bool showBoundingBoxes); 
    267445 
    268         /* Functions for finding Nodes that intersect various shapes */ 
     446        /// <summary> 
     447        /// Function for finding Nodes that intersect an AxisAlignedBox 
     448        /// </summary> 
     449        /// <param name="t">AxisAlignedBox</param> 
     450        /// <param name="nodes">List<PCZSceneNode></param> 
     451        /// <param name="visitedPortals">List<Portal></param> 
     452        /// <param name="includeVisitors">bool</param> 
     453        /// <param name="recurseThruPortals">bool</param> 
     454        /// <param name="exclude">PCZSceneNode</param> 
    269455        public abstract void FindNodes(AxisAlignedBox t, 
    270                                  ref List<PCZSceneNode> list, 
     456                                 ref List<PCZSceneNode> nodes, 
    271457                                 List<Portal> visitedPortals, 
    272458                                 bool includeVisitors, 
    273459                                 bool recurseThruPortals, 
    274460                                 PCZSceneNode exclude); 
     461 
     462        /// <summary> 
     463        /// Function for finding Nodes that intersect a Sphere 
     464        /// </summary> 
     465        /// <param name="t">Sphere</param> 
     466        /// <param name="nodes">List<PCZSceneNode> </param> 
     467        /// <param name="portals">List<Portal> portals</param> 
     468        /// <param name="includeVisitors">bool</param> 
     469        /// <param name="recurseThruPortals">bool</param> 
     470        /// <param name="exclude">PCZSceneNode</param> 
    275471        public abstract void FindNodes(Sphere t, 
    276472                                 ref List<PCZSceneNode> nodes, 
     
    279475                                 bool recurseThruPortals, 
    280476                                 PCZSceneNode exclude); 
     477 
     478        /// <summary> 
     479        /// Function for finding Nodes that intersect a PlaneBoundedVolume 
     480        /// </summary> 
     481        /// <param name="t">PlaneBoundedVolume</param> 
     482        /// <param name="nodes">List<PCZSceneNode></param> 
     483        /// <param name="portals">List<Portal> portals</param> 
     484        /// <param name="includeVisitors">bool</param> 
     485        /// <param name="recurseThruPortals">bool</param> 
     486        /// <param name="exclude">PCZSceneNode</param> 
    281487        public abstract void FindNodes(PlaneBoundedVolume t, 
    282488                                 ref List<PCZSceneNode> list, 
     
    285491                                 bool recurseThruPortals, 
    286492                                 PCZSceneNode exclude); 
     493 
     494        /// <summary> 
     495        /// Function for finding Nodes that intersect a ray 
     496        /// </summary> 
     497        /// <param name="t"></param> 
     498        /// <param name="nodes">List<PCZSceneNode> </param> 
     499        /// <param name="portals">List<Portal> portals</param> 
     500        /// <param name="includeVisitors">bool</param> 
     501        /// <param name="recurseThruPortals">bool</param> 
     502        /// <param name="exclude">PCZSceneNode</param> 
    287503        public abstract void FindNodes(Ray t, 
    288                                  ref List<PCZSceneNode> list, 
     504                                 ref List<PCZSceneNode> nodes, 
    289505                                 List<Portal> visitedPortals, 
    290506                                 bool includeVisitors, 
     
    292508                                 PCZSceneNode exclude); 
    293509 
    294         //* Sets the options for the Zone  
     510        /// <summary> 
     511        /// Sets the options for the Zone  
     512        /// </summary> 
     513        /// <param name="NamelessParameter1">string</param> 
     514        /// <param name="NamelessParameter2">object</param> 
     515        /// <returns></returns> 
    295516        public abstract bool SetOption(string NamelessParameter1, object NamelessParameter2); 
    296         //    * called when the scene manager creates a camera in order to store the first camera created as the primary 
    297         //                      one, for determining error metrics and the 'home' terrain page. 
    298         //               
     517 
     518        /// <summary> 
     519        /// called when the scene manager creates a camera in order to store the first camera created as the primary 
     520        /// one, for determining error metrics and the 'home' terrain page.      
     521        /// </summary> 
     522        /// <param name="c">Camera</param> 
    299523        public abstract void NotifyCameraCreated(Camera c); 
    300524 
    301         protected RenderQueueGroupID worldGeometryRenderQueueId = RenderQueueGroupID.WorldGeometryOne; 
    302  
     525        private RenderQueueGroupID worldGeometryRenderQueueId = RenderQueueGroupID.WorldGeometryOne; 
     526        /// <summary> 
     527        ///  worldGeometryRenderQueueId 
     528        /// </summary> 
     529        public virtual RenderQueueGroupID WorldGeometryRenderQueueId 
     530        { 
     531            get 
     532            { 
     533                return this.worldGeometryRenderQueueId; 
     534            } 
     535 
     536            set 
     537            { 
     538                this.worldGeometryRenderQueueId = value; 
     539            } 
     540        } 
     541 
     542        /// <summary> 
     543        /// NotifyWorldGeometryRenderQueue 
     544        /// </summary> 
     545        /// <param name="renderQueueGroupID">RenderQueueGroupID</param> 
    303546        public abstract void NotifyWorldGeometryRenderQueue(RenderQueueGroupID renderQueueGroupID); 
    304547 
    305         public virtual RenderQueueGroupID WorldGeometryRenderQueueId 
    306         { 
    307             get 
    308             { 
    309                 return this.worldGeometryRenderQueueId; 
    310             } 
    311  
    312             set 
    313             { 
    314                 this.worldGeometryRenderQueueId = value; 
    315             } 
    316         } 
    317  
    318         // Called when a _renderScene is called in the SceneManager  
     548        /// <summary> 
     549        /// Called when a _renderScene is called in the SceneManager  
     550        /// </summary> 
    319551        public abstract void NotifyBeginRenderScene(); 
    320552 
    321         // called by PCZSM during setZoneGeometry()  
     553        /// <summary> 
     554        /// called by PCZSM during setZoneGeometry()  
     555        /// </summary> 
     556        /// <param name="filename">string</param> 
     557        /// <param name="parentNode">PCZSceneNode</param> 
    322558        public abstract void SetZoneGeometry(string filename, PCZSceneNode parentNode); 
    323         // get the world coordinate aabb of the zone  
    324  
    325         // get the aabb of the zone - default implementation 
    326         //   uses the enclosure node, but there are other perhaps 
    327         //   better ways 
    328         //       
     559 
     560 
     561        /// <summary> 
     562        /// get the world coordinate aabb of the zone  
     563        /// 
     564        /// get the aabb of the zone - default implementation 
     565        ///   uses the enclosure node, but there are other perhaps 
     566        ///   better ways 
     567        /// </summary> 
     568        /// <param name="aabb"></param> 
    329569        public void GetAABB(ref AxisAlignedBox aabb) 
    330570        { 
     
    344584        } 
    345585 
    346         public bool PortalsUpdated 
    347         { 
    348             get { return mPortalsUpdated; } 
    349             set { mPortalsUpdated = value ; } 
    350         } 
    351  
     586        /// <summary> 
     587        /// UserData 
     588        /// </summary> 
    352589        public object UserData 
    353590        { 
    354             get { return mUserData; } 
    355             set { mUserData = value; } 
    356         } 
    357  
    358         //* Binary predicate for portal <-> camera distance sorting.  
     591            get { return userData; } 
     592            set { userData = value; } 
     593        } 
     594         
     595        /// <summary> 
     596        /// Binary predicate for portal <-> camera distance sorting.  
     597        /// </summary> 
    359598        protected class PortalSortDistance 
    360599        { 
  • branches/v0.8.0.0/Projects/Axiom/SceneManagers/PCZ/Portal.cs

    r2573 r2583  
    122122                if (param.ContainsKey("Type")) 
    123123                { 
    124                     switch (param["type"].ToString()) 
     124                    switch (param["Type"].ToString()) 
    125125                    { 
    126126                        case "Quad": 
  • branches/v0.8.0.0/Projects/Axiom/SceneManagers/PCZ/PortalBase.cs

    r2574 r2583  
    115115        public bool Enabled = true; 
    116116        // cache of portal's capsule. 
    117         protected Capsule Capsule = new Capsule(); 
     117        protected Capsule capsule = new Capsule(); 
    118118        // cache of portal's AAB that contains the bound of portal movement. 
    119119        protected AxisAlignedBox AAB = new AxisAlignedBox(); 
     
    537537                        PrevPortalAAB = base.worldAABB; 
    538538                 
    539                         Capsule.Set(PrevDerivedCP, DerivedCP, Radius); 
     539                        capsule.Set(PrevDerivedCP, DerivedCP, Radius); 
    540540                        DerivedUpToDate = true; 
    541541                } 
     
    965965                // BUGBUG! If one (or both) portals are aabb's this is REALLY not accurate. 
    966966                Capsule otherPortalCapsule = new Capsule(); 
    967                 otherPortalCapsule = otherPortal.Capsule; 
     967                otherPortalCapsule = otherPortal.capsule; 
    968968 
    969969                if (getCapsule().Intersects(otherPortalCapsule)) 
     
    11771177                Moved = false; 
    11781178            } 
    1179             return Capsule; 
     1179            return capsule; 
    11801180        } 
    11811181 
  • branches/v0.8.0.0/Projects/Axiom/SceneManagers/PCZ/VisibleObjectsBoundsInfo.cs

    r2573 r2583  
    3939namespace Axiom.Core 
    4040{ 
    41     /** Structure collecting together information about the visible objects 
    42     that have been discovered in a scene. 
    43     */ 
    44     public struct VisibleObjectsBoundsInfo 
     41 
     42    /// <summary> 
     43    ///     Structure collecting together information about the visible objects 
     44    ///     that have been discovered in a scene. 
     45    /// </summary> 
     46    public class VisibleObjectsBoundsInfo 
    4547    { 
     48        private AxisAlignedBox aabb = new AxisAlignedBox(); 
     49 
     50        /// <summary> 
    4651        /// The axis-aligned bounds of the visible objects 
    47         public AxisAlignedBox aabb; 
     52        /// </summary> 
     53        public AxisAlignedBox AABB 
     54        { 
     55            get { return aabb; } 
     56            set { aabb = value; } 
     57        } 
     58 
     59        private AxisAlignedBox receiverAabb = new AxisAlignedBox(); 
     60 
     61        /// <summary> 
    4862        /// The axis-aligned bounds of the visible shadow receiver objects 
    49         public AxisAlignedBox receiverAabb; 
     63        /// </summary> 
     64        public AxisAlignedBox ReceiverAABB 
     65        { 
     66            get { return receiverAabb; } 
     67            set { receiverAabb = value; } 
     68        } 
     69         
     70        private Real minDistance = float.NegativeInfinity; 
     71 
     72        /// <summary> 
    5073        /// The closest a visible object is to the camera 
    51         public Real minDistance; 
     74        /// </summary> 
     75        public Real MinDistance 
     76        { 
     77            get { return minDistance; } 
     78            set { minDistance = value; } 
     79        } 
     80         
     81        private Real maxDistance = 0; 
     82 
     83        /// <summary> 
    5284        /// The farthest a visible objects is from the camera 
    53         public Real maxDistance; 
     85        /// </summary> 
     86        public Real MaxDistance 
     87        { 
     88            get { return maxDistance; } 
     89            set { maxDistance = value; } 
     90        } 
    5491 
     92        /// <summary> 
     93        /// Reset 
     94        /// </summary> 
    5595        public void Reset() 
    5696        { 
    57             aabb.IsNull = true; 
     97            AABB.IsNull = true; 
    5898            receiverAabb.IsNull = true; 
    59             minDistance = float.NegativeInfinity; 
    60             maxDistance = 0; 
     99            MinDistance = float.NegativeInfinity; 
     100            MaxDistance = 0; 
    61101        } 
    62102 
     103        /// <summary> 
     104        /// Merge 
     105        /// </summary> 
     106        /// <param name="boxBounds">AxisAlignedBox</param> 
     107        /// <param name="sphereBounds">Sphere</param> 
     108        /// <param name="cam">Camera</param> 
    63109        public void Merge(AxisAlignedBox boxBounds, Sphere sphereBounds, Camera cam) 
    64110        { 
     
    66112        } 
    67113 
     114        /// <summary> 
     115        /// Merge 
     116        /// </summary> 
     117        /// <param name="boxBounds">AxisAlignedBox</param> 
     118        /// <param name="sphereBounds">Sphere</param> 
     119        /// <param name="cam">Camera</param> 
     120        /// <param name="receiver">bool</param> 
    68121        public void Merge(AxisAlignedBox boxBounds, Sphere sphereBounds, Camera cam, bool receiver) 
    69122        { 
    70             aabb.Merge(boxBounds); 
     123            AABB.Merge(boxBounds); 
    71124            if (receiver) 
    72125                receiverAabb.Merge(boxBounds); 
    73126            Real camDistToCenter = (cam.DerivedPosition - sphereBounds.Center).Length; 
    74             minDistance = System.Math.Min(minDistance, System.Math.Max((Real)0, camDistToCenter - sphereBounds.Radius)); 
    75             maxDistance = System.Math.Max(maxDistance, camDistToCenter + sphereBounds.Radius); 
     127            MinDistance = System.Math.Min(MinDistance, System.Math.Max((Real)0, camDistToCenter - sphereBounds.Radius)); 
     128            MaxDistance = System.Math.Max(MaxDistance, camDistToCenter + sphereBounds.Radius); 
    76129        } 
    77130