Ejemplo n.º 1
0
        public IntersectionInfo Intersection(Ray r)
        {
            Vector3D normal = VectorOperations.VectorProduct(new Vector3D(A, B), new Vector3D(A, C));

            normal *= (1 / normal.Length);

            Vector3D V = new Vector3D(r.Origin.X - A.X, r.Origin.Y - A.Y, r.Origin.Z - A.Z);

            //определяем пересекает ли луч треугольник
            double t = -VectorOperations.ScalarProduct(V, normal) / VectorOperations.ScalarProduct(r.Direction, normal);

            if (t <= epsilon || Double.IsNaN(t) || Double.IsInfinity(t))
            {
                return(null);
            }

            Point3D crossPoint = new Point3D(r.Origin.X + r.Direction.X * t,
                                             r.Origin.Y + r.Direction.Y * t,
                                             r.Origin.Z + r.Direction.Z * t);

            Vector3D OX = new Vector3D(A, B);
            Vector3D AC = new Vector3D(A, C);
            Vector3D AD = new Vector3D(A, crossPoint);
            Vector3D OY = VectorOperations.VectorProduct(normal, OX);

            Line3D axis     = new Line3D(A, OX);
            Line3D ordinate = new Line3D(A, OY);

            double Bx = VectorOperations.Distance(ordinate, B);
            double By = 0;

            double Cx = VectorOperations.Distance(ordinate, C) * ((VectorOperations.Cos(OX, AC) < 0)? -1 : 1);
            double Cy = VectorOperations.Distance(axis, C) * ((VectorOperations.Cos(OY, AC) < 0)? -1 : 1);

            double Dx = VectorOperations.Distance(ordinate, crossPoint) * ((VectorOperations.Cos(OX, AD) < 0)? -1 : 1);
            double Dy = VectorOperations.Distance(axis, crossPoint) * ((VectorOperations.Cos(OY, AD) < 0) ? -1 : 1);

            int s1 = Math.Sign(Bx * Dy - By * Dx);
            int s2 = Math.Sign((Cx - Bx) * (Dy - By) - (Cy - By) * (Dx - Bx));
            int s3 = Math.Sign(-Cx * (Dy - Cy) + Cy * (Dx - Cx));

            if (s1 == s2 && s1 == s3 && s2 == s3)
            {
                Material m = ownerSurface.MaterialFront;
                if (VectorOperations.Cos(normal, r.Direction) >= -epsilon && (ownerSurface.MaterialBack != null))
                {
                    normal *= (-1);
                    m       = ownerSurface.MaterialBack;
                }

                return(new IntersectionInfo(crossPoint, normal, m));
            }

            return(null);
        }
Ejemplo n.º 2
0
        public IntersectionInfo Intersection(Ray r)
        {
            Vector3D N = VectorOperations.VectorProduct(new Vector3D(A, B), new Vector3D(A, C));

            //нормаль определяет внешнюю и внутреннюю сторону треугольника
            N *= (1 / N.Length);
            Vector3D V = new Vector3D(r.Origin.X - A.X,
                                      r.Origin.Y - A.Y,
                                      r.Origin.Z - A.Z);
            double t = -VectorOperations.ScalarProduct(V, N) / VectorOperations.ScalarProduct(r.Direction, N);

            if (t <= epsilon || Double.IsNaN(t) || Double.IsInfinity(t))
            {
                return(null);
            }

            Point3D crossPoint = new Point3D(r.Origin.X + r.Direction.X * t,
                                             r.Origin.Y + r.Direction.Y * t,
                                             r.Origin.Z + r.Direction.Z * t);

            Vector3D OX = new Vector3D(A, B);
            Vector3D AC = new Vector3D(A, C);
            Vector3D AD = new Vector3D(A, crossPoint);
            Vector3D OY = VectorOperations.VectorProduct(N, OX);

            Line3D axis     = new Line3D(A, OX);
            Line3D ordinate = new Line3D(A, OY);

            double Bx = VectorOperations.Distance(ordinate, B);
            double By = 0;

            double Cx = VectorOperations.Distance(ordinate, C);

            if (VectorOperations.Cos(OX, AC) < 0)
            {
                Cx *= -1;
            }

            double Cy = VectorOperations.Distance(axis, C);

            if (VectorOperations.Cos(OY, AC) < 0)
            {
                Cy *= -1;
            }

            double Dx = VectorOperations.Distance(ordinate, crossPoint);

            if (VectorOperations.Cos(OX, AD) < 0)
            {
                Dx *= -1;
            }

            double Dy = VectorOperations.Distance(axis, crossPoint);

            if (VectorOperations.Cos(OY, AD) < 0)
            {
                Dy *= -1;
            }


            int s1 = Math.Sign(Bx * Dy - By * Dx);
            int s2 = Math.Sign((Cx - Bx) * (Dy - By) - (Cy - By) * (Dx - Bx));
            int s3 = Math.Sign(-Cx * (Dy - Cy) + Cy * (Dx - Cx));

            if (s1 == s2 && s1 == s3 && s2 == s3)
            {
                Material m = material_front;
                if (VectorOperations.Cos(N, r.Direction) >= -epsilon && (material_back != null))
                {
                    N *= (-1);
                    m  = material_back;
                }

                return(new IntersectionInfo(crossPoint, N, m));
            }

            return(null);
        }
Ejemplo n.º 3
0
        internal Color RayTracing(Ray r, int depth)
        {
            if (depth > 5)
            {
                return(Color.Black);
            }

            IntersectionInfo info = GetFirstIntersection(r);

            if (info == null)   //луч не пересекает предмет
            {
                return(defaultColor);
            }

            double R = 0, G = 0, B = 0;
            //луч пересекает предмет

            double IdR = 0, IdG = 0, IdB = 0;
            double IsR = 0, IsG = 0, IsB = 0;
            double pFong = info.Material.FongCoeff;   //

            foreach (Light L in lights)
            {
                Vector3D V = new Vector3D(info.CrossPoint, L.Position); //направление на источник L
                V *= (1 / V.Length);

                if (this.IsVisible(L, info.CrossPoint))
                {
                    double distance    = VectorOperations.Distance(L.Position, info.CrossPoint);
                    double attenuation = L.Attenuation(distance);

                    if (info.Material.Diffusion > 0)    //для предмета задано свойство диффузного отражения
                    {
                        double cos = VectorOperations.Cos(info.Normal, V);
                        if (cos < 0)
                        {
                            cos = 0;
                        }

                        IdR += L.Color.R * cos / attenuation;
                        IdG += L.Color.G * cos / attenuation;
                        IdB += L.Color.B * cos / attenuation;
                    }
                    if (info.Material.Specularity > 0)  //для предмета задано свойство зеркального отражения
                    {
                        Vector3D reflected;
                        if (VectorOperations.ReflectedVector(info.Normal, r.Direction, out reflected))
                        {
                            double cos = VectorOperations.Cos(V, reflected);
                            if (cos < 0)
                            {
                                cos = 0;
                            }

                            IsR += L.Color.R * Math.Pow(cos, pFong) / attenuation;
                            IsG += L.Color.G * Math.Pow(cos, pFong) / attenuation;
                            IsB += L.Color.B * Math.Pow(cos, pFong) / attenuation;
                        }
                    }
                }
            }
            R += info.Material.Diffusion * IdR * info.Material.Color.R / 255;
            G += info.Material.Diffusion * IdG * info.Material.Color.G / 255;
            B += info.Material.Diffusion * IdB * info.Material.Color.B / 255;

            R += info.Material.Specularity * IsR;
            G += info.Material.Specularity * IsG;
            B += info.Material.Specularity * IsB;

            if (info.Material.Reflection > 0)
            {
                Vector3D reflected;
                if (VectorOperations.ReflectedVector(info.Normal, r.Direction, out reflected))
                {
                    Ray   reflectedRay   = new Ray(info.CrossPoint, reflected);
                    Color reflectedColor = this.RayTracing(reflectedRay, depth + 1);

                    R += info.Material.Reflection * reflectedColor.R;
                    G += info.Material.Reflection * reflectedColor.G;
                    B += info.Material.Reflection * reflectedColor.B;
                }
            }
            if (info.Material.Transparency > 0)
            {
                double   n12 = info.Material.RefractiveIndex;
                Vector3D refracted;

                if (VectorOperations.RefractedVector(info.Normal, r.Direction, n12, out refracted))
                {
                    Ray   refractedRay   = new Ray(info.CrossPoint, refracted);
                    Color refractedColor = this.RayTracing(refractedRay, depth + 1);

                    R += info.Material.Transparency * refractedColor.R;
                    G += info.Material.Transparency * refractedColor.G;
                    B += info.Material.Transparency * refractedColor.B;
                }
            }

            R += info.Material.Color.R * Ka;
            G += info.Material.Color.G * Ka;
            B += info.Material.Color.B * Ka;
            return(Color.FromArgb(Math.Min((int)R, 255), Math.Min((int)G, 255), Math.Min((int)B, 255)));
        }