示例#1
0
文件: Texture.cs 项目: Tilps/Stash
 public SolidTexture(ColorIntensity color)
 {
     this.color = color;
 }
示例#2
0
文件: ToyTracer.cs 项目: Tilps/Stash
        private void PhotonShade(HitInfo hit, Line ray, int threadId, int depth, bool inside, ColorIntensity lightCol, Random rnd, double distance, double area)
        {
            if (depth > maxrecurse)
                return;
            if (lightCol.GreyScale() < minratio)
                return;
            RealHitInfo realHit = hit.GetReal(ray);
            Material surf = realHit.HitStuff;
            ColorIntensity pigment = realHit.Pigment.GetTexture(realHit.Normal, 0);
            double dist = realHit.Normal.Start.LineTo(ray.Start).Length;
            distance += dist;
            if (surf.Attenutive && inside)
            {
                lightCol.R *= Math.Exp(-(1.0 - surf.Attenuation[0]) * dist / surf.AttenuationDistance);
                lightCol.G *= Math.Exp(-(1.0 - surf.Attenuation[1]) * dist / surf.AttenuationDistance);
                lightCol.B *= Math.Exp(-(1.0 - surf.Attenuation[2]) * dist / surf.AttenuationDistance);
            }
            #if DEBUG
            Photon currentParent = PhotonParents[threadId];
            #endif
            if ((depth > 0 || allLightsArePhotons))
            {
                Photon photon = new Photon();
                photon.HitPos.X = (float)realHit.Normal.Start.X;
                photon.HitPos.Y = (float)realHit.Normal.Start.Y;
                photon.HitPos.Z = (float)realHit.Normal.Start.Z;
                photon.TravelDir.Dx = (float)ray.Direct.Dx;
                photon.TravelDir.Dy = (float)ray.Direct.Dy;
                photon.TravelDir.Dz = (float)ray.Direct.Dz;
                ColorIntensity photonColor = lightCol;
                if (realLighting || distance == double.PositiveInfinity)
                {
                    photonColor.R *= area / PhotonCount;
                    photonColor.G *= area / PhotonCount;
                    photonColor.B *= area / PhotonCount;
                }
                else
                {
                    photonColor.R *= distance * distance * area / PhotonCount;
                    photonColor.G *= distance * distance * area / PhotonCount;
                    photonColor.B *= distance * distance * area / PhotonCount;
                }
                photon.PhotonColorPower.R = (float)photonColor.R;
                photon.PhotonColorPower.G = (float)photonColor.G;
                photon.PhotonColorPower.B = (float)photonColor.B;
            #if DEBUG
                photon.parent = currentParent;
                PhotonParents[threadId] = photon;
            #endif
                Map.AddPhoton(photon, threadId);
            }
            ColorIntensity reflectance = new ColorIntensity();
            ColorIntensity transmitance = new ColorIntensity();
            Line refractRay = new Line();
            Line reflectRay = new Line();
            if (surf.Refractive || surf.Reflective)
            {
                ray.Direct = ray.Direct.Scale(1 / ray.Direct.Length);
                reflectance.R = surf.Reflective ? surf.Reflectance[0] : 0.0;
                reflectance.G = surf.Reflective ? surf.Reflectance[1] : 0.0;
                reflectance.B = surf.Reflective ? surf.Reflectance[2] : 0.0;
                if (surf.Refractive)
                {
                    double ni = inside ? surf.RefractIndex : 1.0;
                    double nt = (!inside) ? surf.RefractIndex : 1.0;
                    double cratio = ni / nt;
                    double ct1 = -ray.Direct.Dot(realHit.Normal.Direct);
                    double ct2sqrd = 1 - cratio * cratio * (1 - ct1 * ct1);
                    if (ct2sqrd <= 0)
                    {
                        reflectance.R = 1;
                        reflectance.G = 1;
                        reflectance.B = 1;
                    }
                    else
                    {
                        double ct2 = Math.Sqrt(ct2sqrd);
                        // fresnel equations for reflectance perp and parallel.
                        double rperp = (ni * ct1 - nt * ct2) / (ni * ct1 + nt * ct2);
                        double rpll = (nt * ct1 - ni * ct2) / (ni * ct2 + nt + ct1);
                        // assume unpolarised light always - better then tracing 2
                        // rays for both sides of every interface.
                        double reflectanceval = (rperp * rperp + rpll * rpll) / 2;
                        reflectance.R = Math.Min(1.0, reflectance.R + reflectanceval);
                        reflectance.G = Math.Min(1.0, reflectance.G + reflectanceval);
                        reflectance.B = Math.Min(1.0, reflectance.B + reflectanceval);
                        transmitance.R = 1 - reflectance.R;
                        transmitance.G = 1 - reflectance.G;
                        transmitance.B = 1 - reflectance.B;
                        refractRay.Direct = ray.Direct.Scale(cratio);
                        refractRay.Direct.Add(realHit.Normal.Direct.Scale(cratio * (ct1) - ct2));
                        refractRay.Start = realHit.Normal.Start.MoveBy(refractRay.Direct.Scale(EPSILON * 10));
                    }
                }
                reflectRay.Direct = new Vector(ray.Direct.Dx, ray.Direct.Dy, ray.Direct.Dz);
                reflectRay.Direct.Add(realHit.Normal.Direct.Scale(-2 * ray.Direct.Dot(realHit.Normal.Direct)));
                reflectRay.Start = realHit.Normal.Start.MoveBy(reflectRay.Direct.Scale(EPSILON * 10));
            }
            bool doReflect = false;
            bool doRefract = false;
            bool doDifuse = false;
            double avr = reflectance.R + reflectance.G + reflectance.B;
            avr /= 3;
            double avt = transmitance.R + transmitance.G + transmitance.B;
            avt /= 3;
            double reflectWeight = Math.Max(avr, 0.0);
            double refractWeight = Math.Max(avt, 0.0);
            double diffuseWeight = Math.Max(pigment.GreyScale() * surf.Diffuse, 0.0);
            double specularity = 1.0;
            double diffusivity = 1.0;
            if (surf.Refractive)
            {
                specularity = surf.Specularity;
                diffusivity = 1.0 - specularity;
                reflectWeight *= surf.Specularity;
                refractWeight *= surf.Specularity;
                diffuseWeight *= 1.0-surf.Specularity;
            }
            double choice = rnd.NextDouble();
            if (choice < diffuseWeight)
                doDifuse = true;
            else if (choice < diffuseWeight+reflectWeight)
                doReflect = true;
            else if (choice < diffuseWeight+reflectWeight+refractWeight)
                doRefract = true;
            if (doRefract && avt > minratio)
            {
                SetIn(ref refractRay.Start, threadId);
                HitInfo hitnew = scene.Intersect(refractRay, threadId);
                if (!(hitnew.HitDist == -1))
                {
                    ColorIntensity lightCol2 = new ColorIntensity();
                    lightCol2.R = lightCol.R * transmitance.R *specularity/ refractWeight;
                    lightCol2.G = lightCol.G * transmitance.G * specularity / refractWeight;
                    lightCol2.B = lightCol.B * transmitance.B * specularity / refractWeight;
                    PhotonShade(hitnew, refractRay, threadId, depth + 1, !inside, lightCol2, rnd, distance, area);
                }
            }
            if (doReflect && avr > minratio)
            {
                SetIn(ref reflectRay.Start, threadId);
                HitInfo hitnew2 = scene.Intersect(reflectRay, threadId);
                if (!(hitnew2.HitDist == -1))
                {
                    ColorIntensity lightCol2 = new ColorIntensity();
                    lightCol2.R = lightCol.R * reflectance.R * specularity / reflectWeight;
                    lightCol2.G = lightCol.G * reflectance.G * specularity / reflectWeight;
                    lightCol2.B = lightCol.B * reflectance.B * specularity / reflectWeight;
                    PhotonShade(hitnew2, reflectRay, threadId, depth + 1, inside, lightCol2, rnd, distance, area);
                }
            }
            if (doDifuse)
            {
                double z = rnd.NextDouble();
                double theta = rnd.NextDouble() * 2.0 * Math.PI;
                double r = Math.Sqrt(1 - z * z);
                double x = Math.Cos(theta) * r;
                double y = Math.Sin(theta) * r;

                Line diffuseRay = new Line();
                Vector a;
                Vector b;
                Vector basis = realHit.Normal.Direct.Scale(1.0/realHit.Normal.Direct.Length);
                GetPerp(basis, out a, out b);
                diffuseRay.Direct = basis.Scale(z);
                diffuseRay.Direct.Add(a.Scale(x/a.Length));
                diffuseRay.Direct.Add(b.Scale(y/b.Length));
                diffuseRay.Start = realHit.Normal.Start.MoveBy(diffuseRay.Direct.Scale(EPSILON * 10));
                SetIn(ref diffuseRay.Start, threadId);
                HitInfo hitnew2 = scene.Intersect(diffuseRay, threadId);
                if (!(hitnew2.HitDist == -1))
                {
                    ColorIntensity lightCol2 = new ColorIntensity();
                    lightCol2.R = lightCol.R * surf.Diffuse * pigment.R *diffusivity/ diffuseWeight;
                    lightCol2.G = lightCol.G * surf.Diffuse * pigment.G * diffusivity / diffuseWeight;
                    lightCol2.B = lightCol.B * surf.Diffuse * pigment.B * diffusivity / diffuseWeight;
                    PhotonShade(hitnew2, diffuseRay, threadId, depth + 1, inside, lightCol2, rnd, distance, area);
                }
            }
            #if DEBUG
            PhotonParents[threadId] = currentParent;
            #endif
        }
示例#3
0
文件: ToyTracer.cs 项目: Tilps/Stash
        private ColorIntensity Shade(RealHitInfo hit, Line by, int recurse, double ratio, bool inside, int threadId)
        {
            #if DEBUG
            if (Gathering)
            {
                CurrentGather.Weight = ratio;
                CurrentGather.RealInfo = hit;
            }
            #endif
            ColorIntensity colors, shadowcolors;
            Material surf = hit.HitStuff;
            ColorIntensity pigment = hit.Pigment.GetTexture(hit.Normal, 0);
            ColorIntensity atten = new ColorIntensity();
            if (surf.Attenutive && inside)
            {
                double dist = hit.Normal.Start.LineTo(by.Start).Length;
                atten.R = Math.Exp(-(1.0 - surf.Attenuation[0]) * dist / surf.AttenuationDistance);
                atten.G = Math.Exp(-(1.0 - surf.Attenuation[1]) * dist / surf.AttenuationDistance);
                atten.B = Math.Exp(-(1.0 - surf.Attenuation[2]) * dist / surf.AttenuationDistance);
                ratio = ratio * (atten.R + atten.G + atten.B) / 3;
            }
            double rI = 0;
            double gI = 0;
            double bI = 0;
            Vector lightdir;
            Line newray = new Line();
            HitInfo hitnewray = new HitInfo();
            hit.Normal.Direct = hit.Normal.Direct.Scale(1 / hit.Normal.Direct.Length);
            Vector eye = by.Direct.Scale(-1 / by.Direct.Length);

            int lightCount = (allLightsArePhotons && photons) ? 0 : lights.Count;
            //lightCount = 0;
            for (int i = 0; i < lightCount; i++)
            {
                double lightdist = double.PositiveInfinity;
                switch (lights[i].LightType)
                {
                    case LightType.Ambient:
                        rI += lights[i].Color.R * surf.Ambient[0];
                        gI += lights[i].Color.G * surf.Ambient[1];
                        bI += lights[i].Color.B * surf.Ambient[2];
                        continue;
                    case LightType.Directional:
                        lightdir = lights[i].Direction.Direct.Scale(-1);
                        break;
                    case LightType.Point:
                        lightdir = hit.Normal.Start.LineTo(lights[i].Direction.Start);
                        lightdist = lightdir.Length;
                        break;
                    default:
                        continue;
                }
                // Add double illuminate flag or something to turn this off.
                if (true)
                {
                    if (lightdir.Dot(hit.Normal.Direct) <= 0.0)
                        continue;
                }
                newray.Direct = lightdir.Scale(1.0/lightdir.Length);
                if (newray.Direct.Dot(hit.Normal.Direct) >= 0)
                    newray.Start = hit.Normal.Start.MoveBy(newray.Direct.Scale(EPSILON * 10));
                else
                    newray.Start = hit.Normal.Start.MoveBy(newray.Direct.Scale(-EPSILON * 10));
                SetIn(ref newray.Start, threadId);
                HitInfo info = scene.Intersect(newray, false, threadId);
                if (!(info.HitDist == -1 || info.HitDist > lightdist))
                    continue;
                shadowcolors.R = 1.0;
                shadowcolors.G = 1.0;
                shadowcolors.B = 1.0;
                // Don't need to setIn again, seperate intersect cache for shadow vs non-shadow rays.
                hitnewray = scene.Intersect(newray, threadId);
                if (!photons)
                {
                    if (!(hitnewray.HitDist == -1 || hitnewray.HitDist > lightdist))
                    {
            #if DEBUG
                        GatherInfo last = null;
                        if (Gathering)
                        {
                            last = CurrentGather;
                            CurrentGather = new GatherInfo();
                        }
            #endif
                        shadowcolors = ShadowShade(hitnewray.GetReal(newray), newray, recurse + 1, ratio, inside, threadId, lightdist);
            #if DEBUG
                        if (Gathering)
                        {
                            last.LightChildren.Add(CurrentGather);
                            CurrentGather = last;
                        }
            #endif
                    }
                }
                else
                {
                    if (!(hitnewray.HitDist == -1 || hitnewray.HitDist > lightdist))
                        continue;
                }
                shadowcolors.R *= lights[i].Color.R;
                shadowcolors.G *= lights[i].Color.G;
                shadowcolors.B *= lights[i].Color.B;
                if (realLighting && lightdist < double.PositiveInfinity)
                {
                    double lightdistSq = lightdist * lightdist;
                    shadowcolors.R /= lightdistSq;
                    shadowcolors.G /= lightdistSq;
                    shadowcolors.B /= lightdistSq;
                }
                CalculateLightContrib(hit.Normal.Direct, shadowcolors, surf, pigment, ref rI, ref gI, ref bI, lightdir, eye);
            }
            if (photons)
            {
                double scaleRadSq;
                List<Photon> closePhotons = Map.GetClosest(hit.Normal.Start, hit.Normal.Direct, out scaleRadSq, threadId);
                double photoR = 0.0;
                double photoG = 0.0;
                double photoB = 0.0;
                foreach (Photon photon in closePhotons)
                {
                    lightdir.Dx = -photon.TravelDir.Dx;
                    lightdir.Dy = -photon.TravelDir.Dy;
                    lightdir.Dz = -photon.TravelDir.Dz;
                    if (true)
                    {
                        if (lightdir.Dot(hit.Normal.Direct) <= 0.0)
                            continue;
                    }
                    ColorIntensity photonColor;
                    photonColor.R = photon.PhotonColorPower.R;
                    photonColor.G = photon.PhotonColorPower.G;
                    photonColor.B = photon.PhotonColorPower.B;
                    CalculateLightContrib(hit.Normal.Direct, photonColor, surf, pigment, ref photoR, ref photoG, ref photoB, lightdir, eye);
            #if DEBUG
                    if (Gathering)
                    {
                        CurrentGather.GatheredPhotons.Add(photon);
                    }
            #endif
                }
                if (closePhotons.Count > 0)
                {
                    rI += photoR / Math.PI / scaleRadSq;
                    if (rI > 3)
                    {
                        int breakpoint = 3;
                        breakpoint *= 34;
                    }
                    gI += photoG / Math.PI / scaleRadSq;
                    if (gI > 3)
                    {
                        int breakpoint = 3;
                        breakpoint *= 34;
                    }
                    bI += photoB / Math.PI / scaleRadSq;
                    if (bI > 3)
                    {
                        int breakpoint = 3;
                        breakpoint *= 34;
                    }
                }
            }
            if ((surf.Refractive || surf.Reflective) && recurse < maxrecurse)
            {
                by.Direct = by.Direct.Scale(1 / by.Direct.Length);
                ColorIntensity reflectance = new ColorIntensity();
                reflectance.R = surf.Reflective ? surf.Reflectance[0] : 0.0;
                reflectance.G = surf.Reflective ? surf.Reflectance[1] : 0.0;
                reflectance.B = surf.Reflective ? surf.Reflectance[2] : 0.0;
                if (surf.Refractive)
                {
                    double ni = inside ? surf.RefractIndex : 1.0;
                    double nt = (!inside) ? surf.RefractIndex : 1.0;
                    double cratio = ni / nt;
                    double ct1 = -by.Direct.Dot(hit.Normal.Direct);
                    double ct2sqrd = 1 - cratio * cratio * (1 - ct1 * ct1);
                    if (ct2sqrd <= 0)
                    {
                        reflectance.R = 1;
                        reflectance.G = 1;
                        reflectance.B = 1;
                    }
                    else
                    {
                        double ct2 = Math.Sqrt(ct2sqrd);
                        // fresnel equations for reflectance perp and parallel.
                        double rperp = (ni * ct1 - nt * ct2) / (ni * ct1 + nt * ct2);
                        double rpll = (nt * ct1 - ni * ct2) / (ni * ct2 + nt + ct1);
                        // assume unpolarised light always - better then tracing 2
                        // rays for both sides of every interface.
                        double reflectanceval = (rperp * rperp + rpll * rpll) / 2;
                        reflectance.R = Math.Min(1.0, reflectance.R + reflectanceval);
                        reflectance.G = Math.Min(1.0, reflectance.G + reflectanceval);
                        reflectance.B = Math.Min(1.0, reflectance.B + reflectanceval);
                        ColorIntensity transmitance = new ColorIntensity();
                        transmitance.R = 1 - reflectance.R;
                        transmitance.G = 1 - reflectance.G;
                        transmitance.B = 1 - reflectance.B;
                        double avt = transmitance.R + transmitance.G + transmitance.B;
                        avt /= 3;
                        if (avt * ratio*surf.Specularity > minratio)
                        {
                            Line newray2 = new Line();
                            newray2.Direct = by.Direct.Scale(cratio);
                            newray2.Direct.Add(hit.Normal.Direct.Scale(cratio * (ct1) - ct2));
                            newray2.Start = hit.Normal.Start.MoveBy(newray2.Direct.Scale(EPSILON * 10));
                            SetIn(ref newray2.Start, threadId);
                            HitInfo hitnew = scene.Intersect(newray2, threadId);
                            if (!(hitnew.HitDist == -1))
                            {
            #if DEBUG
                                GatherInfo last2 = null;
                                if (Gathering)
                                {
                                    last2 = CurrentGather;
                                    CurrentGather = new GatherInfo();
                                }
            #endif
                                ColorIntensity cl = Shade(hitnew.GetReal(newray2), newray2, recurse + 1, avt * ratio * surf.Specularity, !inside, threadId);
            #if DEBUG
                                if (Gathering)
                                {
                                    last2.Children.Add(CurrentGather);
                                    CurrentGather = last2;
                                }
            #endif
                                rI = rI + ((double)transmitance.R * cl.R) * surf.Specularity;
                                gI = gI + ((double)transmitance.G * cl.G) * surf.Specularity;
                                bI = bI + ((double)transmitance.B * cl.B) * surf.Specularity;
                            }
                        }
                    }
                }
                double avr = reflectance.R + reflectance.G + reflectance.B;
                avr /= 3;
                double specularity = surf.Refractive ? surf.Specularity : 1.0;
                if (avr * ratio*specularity > minratio)
                {
                    Line newray2 = new Line();
                    newray2.Direct = new Vector(by.Direct.Dx, by.Direct.Dy, by.Direct.Dz);
                    newray2.Direct.Add(hit.Normal.Direct.Scale(-2 * by.Direct.Dot(hit.Normal.Direct)));
                    newray2.Start = hit.Normal.Start.MoveBy(newray2.Direct.Scale(EPSILON * 10));
                    SetIn(ref newray2.Start, threadId);
                    HitInfo hitnew2 = scene.Intersect(newray2, threadId);
                    if (!(hitnew2.HitDist == -1))
                    {
            #if DEBUG
                        GatherInfo last3 = null;
                        if (Gathering)
                        {
                            last3 = CurrentGather;
                            CurrentGather = new GatherInfo();
                        }
            #endif
                        ColorIntensity cl2 = Shade(hitnew2.GetReal(newray2), newray2, recurse + 1, avr * ratio * specularity, inside, threadId);
            #if DEBUG
                        if (Gathering)
                        {
                            last3.Children.Add(CurrentGather);
                            CurrentGather = last3;
                        }
            #endif
                        rI = rI + ((double)reflectance.R * cl2.R) * specularity;
                        gI = gI + ((double)reflectance.G * cl2.G) * specularity;
                        bI = bI + ((double)reflectance.B * cl2.B) * specularity;
                    }
                }
            }
            else
            {
                if (recurse >= maxrecurse)
                {
                    // Recurse limit reached.
                    int i = 0;
                    i = i * 3;
                }
            }
            if (surf.Attenutive && inside)
            {
                rI *= atten.R;
                gI *= atten.G;
                bI *= atten.B;
            }
            colors.R = rI;
            colors.G = gI;
            colors.B = bI;
            return colors;
        }
示例#4
0
文件: ToyTracer.cs 项目: Tilps/Stash
 private void PhotonShade(HitInfo hit, Line ray, int threadId, ColorIntensity lightCol, Random rnd, double distance, double area)
 {
     PhotonShade(hit, ray, threadId, 0, false, lightCol, rnd, distance, area);
 }
示例#5
0
文件: ToyTracer.cs 项目: Tilps/Stash
 private void GeneratePhotons(int threadId, int threadCount)
 {
     Random rnd = new Random();
     if (!photons)
         return;
     foreach (Light light in Lights)
     {
         if (light.LightType == LightType.Point)
         {
             for (int i = 0; i < PhotonCount/threadCount; i++)
             {
                 double z = rnd.NextDouble()*2-1;
                 double theta = rnd.NextDouble()*2.0*Math.PI;
                 double r = Math.Sqrt(1-z*z);
                 double x = Math.Cos(theta)*r;
                 double y = Math.Sin(theta)*r;
                 Line ray = new Line();
                 ray.Direct = new Vector(x, y, z);
                 ray.Start = light.Direction.Start;
                 SetIn(ref ray.Start, threadId);
                 HitInfo hit = scene.Intersect(ray, threadId);
                 ColorIntensity lightCol = new ColorIntensity();
                 lightCol.R = light.Color.R;
                 lightCol.G = light.Color.G;
                 lightCol.B = light.Color.B;
                 if (hit.HitDist != -1)
                 {
                     PhotonShade(hit, ray, threadId, lightCol, rnd, 0.0, Math.PI*4);
                 }
                 if (i % 100000 == 0)
                     GC.Collect();
             }
         }
         else if (light.LightType == LightType.Directional)
         {
             Point centre;
             double radius;
             scene.Bounds.GetSphere(out centre, out radius);
             Point eye = centre.MoveBy(light.Direction.Direct.Scale(-radius * 2));
             Vector a;
             Vector b;
             GetPerp(light.Direction.Direct.Scale(1.0/light.Direction.Direct.Length), out a, out b);
             for (int i = 0; i < PhotonCount/threadCount; i++)
             {
                 double x = 0.0;
                 double y= 0.0;
                 do
                 {
                     x = rnd.NextDouble() * 2 - 1;
                     y = rnd.NextDouble() * 2 - 1;
                 } while (x * x + y * y > 1.0);
                 x = x * radius;
                 y = y * radius;
                 Line ray = new Line();
                 ray.Direct = light.Direction.Direct;
                 ray.Start = eye.MoveBy(a.Scale(x/a.Length)).MoveBy(b.Scale(y/b.Length));
                 SetIn(ref ray.Start, threadId);
                 HitInfo hit = scene.Intersect(ray, threadId);
                 ColorIntensity lightCol = new ColorIntensity();
                 lightCol.R = light.Color.R;
                 lightCol.G = light.Color.G;
                 lightCol.B = light.Color.B;
                 if (hit.HitDist != -1)
                 {
                     PhotonShade(hit, ray, threadId, lightCol, rnd, double.PositiveInfinity, Math.PI*radius*radius);
                 }
                 if (i % 100000 == 0)
                     GC.Collect();
             }
         }
     }
 }
示例#6
0
文件: ToyTracer.cs 项目: Tilps/Stash
 private bool Decide(byte[] screen, int screenwidth, ColorIntensity current)
 {
     // Todo: new decide function.
     return false;
 }
示例#7
0
文件: ToyTracer.cs 项目: Tilps/Stash
        private void CalculateLightContrib(Vector normal, ColorIntensity lightColor, Material surf, ColorIntensity pigment, ref double rI, ref double gI, ref double bI, Vector lightdir, Vector eye)
        {
            double diffusivity = 1.0-surf.Specularity;
            if (surf.Phong > 0.0)
            {
                Vector reflection = eye;
                reflection.Add(normal.Scale(-2.0 * eye.Dot(normal)));
                double phong = -lightdir.Scale(1.0 / lightdir.Length).Dot(reflection);
                if (phong > 0.0)
                {
                    double phongpowd = Math.Pow(phong, surf.Exponent);
                    rI += surf.Phong * phongpowd * lightColor.R*diffusivity;
                    gI += surf.Phong * phongpowd * lightColor.G * diffusivity;
                    bI += surf.Phong * phongpowd * lightColor.B * diffusivity;
                }
            }
            if (surf.Specular > 0.0)
            {
                Vector half = lightdir.Scale(1.0 / lightdir.Length);
                half.Add(eye);
                half.ScaleSelf(0.5);
                double spec = half.Dot(normal) / half.Length;

                if (spec > 0.0)
                {
                    double specpowd = Math.Pow(spec, 1.0 / surf.Roughness);
                    rI += surf.Specular * specpowd * lightColor.R * diffusivity;
                    gI += surf.Specular * specpowd * lightColor.G * diffusivity;
                    bI += surf.Specular * specpowd * lightColor.B * diffusivity;
                }
            }
            if (surf.Iridescence > 0.0)
            {
                double cosaoi = lightdir.Dot(normal)/lightdir.Length;
                double interference = 4.0 * Math.PI * surf.FilmThickness * cosaoi;

                double intensity = cosaoi * surf.Iridescence;
                double rwl = 0.25;
                double gwl = 0.18;
                double bwl = 0.14;
                /* Modify color by phase offset for each wavelength. */

                rI += surf.Iridescence * (intensity * (1.0 - 0.5 * Math.Cos(interference / rwl))) * diffusivity;
                gI += surf.Iridescence * (intensity * (1.0 - 0.5 * Math.Cos(interference / gwl))) * diffusivity;
                bI += surf.Iridescence * (intensity * (1.0 - 0.5 * Math.Cos(interference / bwl))) * diffusivity;

            }
            double lam = lambert2(lightdir, normal, surf.Brilliance);
            rI += surf.Diffuse * pigment.R * lam * lightColor.R * diffusivity;
            gI += surf.Diffuse * pigment.G * lam * lightColor.G * diffusivity;
            bI += surf.Diffuse * pigment.B * lam * lightColor.B * diffusivity;
        }
示例#8
0
 public IntensityMap(int width, int height) {
     this.width = width;
     this.height = height;
     pix = new ColorIntensity[width * height];
 }