public LightRay( Color3 RadiantIntensity, Ray GeneratedRay, Vector Normal, float Pdf )
 {
     this.RadiantIntensity = RadiantIntensity;
     this.GeneratedRay = GeneratedRay;
     this.Normal = Normal;
     this.Pdf = Pdf;
 }
Exemple #2
0
        protected override void Trace( Ray ModelRay, ref ShapeHitList Hits )
        {
            Vector oc = Center - ModelRay.Origin;
            float l2oc = Vector.DotProduct( oc, oc );
            float dp = Vector.DotProduct( ModelRay.Direction, ModelRay.Direction );

            if ( l2oc <= RadiusSquared ) // Inside the sphere
            {
                float tca = Vector.DotProduct( oc, ModelRay.Direction );
                float l2hc = ( RadiusSquared - l2oc ) / dp + tca * tca;

                float t = tca + (float)Math.Sqrt( l2hc );
                Hits.Add( t, SphereInsideFaceIndex );
            }
            else
            {
                float tca = Vector.DotProduct( oc, ModelRay.Direction ) / dp;

                if ( tca >= 0.0f )
                {
                    float l2hc = ( RadiusSquared - l2oc ) / dp + tca * tca;
                    float t = tca - (float)Math.Sqrt( l2hc );

                    if ( l2hc > 0.0f ) // Hits Sphere
                    {
                        Hits.Add( t, SphereOutsideFaceIndex );
                    }
                }
            }
        }
Exemple #3
0
        internal override sealed void Trace( Ray ModelRay, ShapeHitCollection ShapeHits )
        {
            Debug.Assert( ShapeHits != null );

            ShapeHitList Hits = new ShapeHitList( ShapeHits );
            Trace( ModelRay, ref Hits );
        }
Exemple #4
0
        internal void Trace( Ray WorldRay, ShapeHitCollection ShapeHits, SimpleGeometryHitCollection GeometryHits, List<ObjectHit> ObjectHits )
        {
            Debug.Assert( ShapeHits != null );
            Debug.Assert( GeometryHits != null );
            Debug.Assert( ObjectHits != null );

            Trace( WorldRay, new GeometryTracer( ShapeHits, GeometryHits ), new ObjectHitCollection( ObjectHits ) );
        }
        public SimpleGeometryHit( Matrix ModelToWorld, Ray ModelRay )
        {
            Debug.Assert( ModelToWorld != null );

            this.Type = GeometryType.Model;
            this.ModelToWorld = ModelToWorld;
            this.ModelRay = ModelRay;
        }
Exemple #6
0
            public void Trace( SceneObjects Objects, Ray WorldRay )
            {
                if ( Objects == null )
                {
                    throw new ArgumentNullException( "Objects" );
                }

                Objects.Trace( WorldRay, ShapeHits, GeometryHits, ObjectHits );
            }
Exemple #7
0
        internal override sealed SimpleGeometryHit Trace( Ray WorldRay, ShapeHitCollection Hits, SimpleGeometryHitCollection GeometryHits )
        {
            Debug.Assert( Hits != null );
            Debug.Assert( GeometryHits != null );

            Hits.AdvanceBaseIndex();
            Trace( WorldRay, Hits );
            return ( Hits.Count == Hits.Base ) ? null : GeometryHits.Next();
        }
        internal override SimpleGeometryHit Trace( Ray WorldRay, ShapeHitCollection Hits, SimpleGeometryHitCollection GeometryHits )
        {
            Debug.Assert( Hits != null );
            Debug.Assert( GeometryHits != null );

            Hits.AdvanceBaseIndex();
            Ray ModelRay = WorldToModel *  WorldRay;
            Shape.Trace( ModelRay, Hits );
            return ( Hits.Count == Hits.Base ) ? null : GeometryHits.Next( ModelToWorld, ModelRay );
        }
Exemple #9
0
        protected override Color3 ShadeHits( Ray WorldRay, IReadOnlyList<ObjectHit> Hits )
        {
            Color4 total = Color4.Transparent;

            for ( int i = 0; i < Hits.Count && total.A != 1.0f; i++ )
            {
                ObjectHit hit = Hits[i];
                IShadableObject Obj = hit.Object as IShadableObject;

                if ( hit.Distance < Epsilon || Obj == null )
                {
                    continue;
                }

                Color3 term = Color3.Black;
                float alpha;

                Point worldHit = WorldRay.Endpoint( hit.Distance );
                Vector worldViewer = WorldRay.Direction;
                Point modelHit = hit.ModelHit( worldHit );
                Vector modelViewer = hit.ModelViewer( worldViewer );

                Shaders Shades = Obj.Shaders( hit.FaceHit );

                if ( Shades.Translucent != null )
                {
                    alpha = Shades.Translucent.Alpha( worldHit, modelHit, hit.AdditionalData );
                }
                else
                {
                    alpha = 1.0f;
                }

                if ( Shades.Emissive != null )
                {
                    term = Shades.Emissive.Emissive( worldHit, modelHit, hit.AdditionalData );
                }

                if ( Shades.Indirect != null )
                {
                    Normal.Set( Shades.Normal, worldHit, modelHit, hit.ModelToWorld, hit.AdditionalData );

                    term += Shades.Indirect.Indirect( worldHit, modelHit,
                                                      hit.AdditionalData,
                                                      worldViewer, modelViewer,
                                                      Normal, Rng, NextTracer );
                }

                Color4 termWithAlpha = new Color4( term, alpha );

                total = Color4.Over( total, termWithAlpha );
            }

            return total.Reduce();
        }
Exemple #10
0
        internal void Trace( Ray WorldRay, ShapeHitCollection ShapeHits, SimpleGeometryHitCollection GeometryHits, List<ObjectHit> ObjectHits )
        {
            Debug.Assert( ShapeHits != null );
            Debug.Assert( GeometryHits != null );
            Debug.Assert( ObjectHits != null );

            ObjectHits.Clear();
            GeometryHits.Clear();
            ShapeHits.Clear();

            SceneTracer Tracer = new SceneTracer( ShapeHits, GeometryHits, ObjectHits );
            Trace( WorldRay, Tracer );
        }
        public SimpleGeometryHit Next( Matrix ModelToWorld, Ray ModelRay )
        {
            Debug.Assert( ModelToWorld != null );

            if ( Count == Hits.Count )
            {
                Hits.Add( new SimpleGeometryHit( ModelToWorld, ModelRay ) );
                return Hits[Count++];
            }

            Hits[Count].Set( ModelToWorld, ModelRay );
            return Hits[Count++];
        }
Exemple #12
0
        public IReadOnlyList<ObjectHit> Trace( SceneBase Scene, Ray WorldRay, bool SortHits )
        {
            if ( Scene == null )
            {
                throw new ArgumentNullException( "Scene" );
            }

            Scene.Trace( WorldRay, ShapeHits, GeometryHits, ObjectHits );

            if ( SortHits )
            {
                ObjectHits.Sort();
            }

            return ObjectHits;
        }
        public bool Visible( Ray WorldRay, float DistanceToLight )
        {
            IReadOnlyList<ObjectHit> Hits = Tracer.Trace( Scene, WorldRay, false );

            float DistanceToClosestObject = float.PositiveInfinity;

            for ( int i = 0; i < Hits.Count && DistanceToLight < DistanceToClosestObject; i++ )
            {
                if ( Hits[i].Distance < Epsilon )
                {
                    continue;
                }

                DistanceToClosestObject = Math.Min( Hits[i].Distance, DistanceToClosestObject );
            }

            return DistanceToLight < DistanceToClosestObject;
        }
        protected override void Trace( Ray ModelRay, ref ShapeHitList Hits )
        {
            float dp = Vector.DotProduct( ModelRay.Direction, Normal );
            float distance = -Vector.DotProduct( ModelRay.Origin - P0, Normal ) / dp;

            // If the distnace traveled is less than zero, misses the plane
            if ( distance <= 0.0f )
            {
                return;
            }

            if ( dp > 0.0f ) // Hits front
            {
                Hits.Add( distance, PlaneFrontFaceIndex );
            }
            else // Hits back
            {
                Hits.Add( distance, PlaneBackFaceIndex );
            }
        }
        public Color3 Trace( Ray WorldRay, float PreferredContinueProbability = 1.0f )
        {
            if ( DoRussianRouletteTermination )
            {
                PreferredContinueProbability = Math.Max( Math.Min( MaximumTerminationProbability, PreferredContinueProbability ), MinimumTerminationProbability );

                if ( PreferredContinueProbability == 0.0f || PreferredContinueProbability < Rng.NextDouble() )
                {
                    return Color3.Black;
                }
            }

            WorldRay = new Ray( WorldRay.Origin, WorldRay.Direction.Normalize() );

            IReadOnlyList<ObjectHit> Hits = Tracer.Trace( Scene, WorldRay, true );

            if ( Hits.Count == 0 )
            {
                return Color3.Black;
            }

            return ( !DoRussianRouletteTermination ) ? ShadeHits( WorldRay, Hits ) : ShadeHits( WorldRay, Hits ) / PreferredContinueProbability;
        }
Exemple #16
0
 protected abstract void Trace( Ray WorldRay, GeometryTracer Tracer, ObjectHitCollection ObjectHits );
Exemple #17
0
            public GeometryHitCollection Trace( GeometryBase Geometry, Ray WorldRay )
            {
                if ( Geometry == null )
                {
                    throw new ArgumentNullException( "Geometry" );
                }

                SimpleGeometryHit GeomHit = Geometry.Trace( WorldRay, ShapeHits, GeometryHits );
                return new GeometryHitCollection( ShapeHits, GeomHit );
            }
Exemple #18
0
 internal abstract void Trace( Ray ModelRay, ShapeHitCollection ShapeHits );
 internal abstract SimpleGeometryHit Trace( Ray WorldRay, ShapeHitCollection Hits, SimpleGeometryHitCollection GeometryHits );
Exemple #20
0
 protected abstract void Trace( Ray ModelRay, ref ShapeHitList Hits );
        protected override void Trace( Ray WorldRay, GeometryTracer Tracer, ObjectHitCollection ObjectHits )
        {
            GeometryHitCollection GeometryHits = Tracer.Trace( Geometry, WorldRay );

            for ( int i = 0; i < GeometryHits.Count; i++ )
            {
                ObjectHits.Add( CreateObjectHit( GeometryHits[i] ) );
            }
        }
Exemple #22
0
 protected override void Trace( Ray WorldRay, SceneTracer Tracer )
 {
     Tracer.Trace( Objects, WorldRay );
 }
Exemple #23
0
 protected abstract void Trace( Ray WorldRay, SceneTracer Tracer );
 protected abstract Color3 ShadeHits( Ray WorldRay, IReadOnlyList<ObjectHit> Hits );
Exemple #25
0
            internal void Trace( Ray WorldRay, ShapeHitCollection ShapeHits, SimpleGeometryHitCollection GeometryHits, List<ObjectHit> ObjectHits )
            {
                Debug.Assert( ShapeHits != null );
                Debug.Assert( GeometryHits != null );
                Debug.Assert( ObjectHits != null );

                for ( int i = 0; i < Objects.Count; i++ )
                {
                    Objects[i].Trace( WorldRay, ShapeHits, GeometryHits, ObjectHits );
                }
            }