Beispiel #1
0
        public static EnergieLumineuse CalculerAtmosphere(Univers univ, Tir tir)
        {
            Rayon            r = new Rayon(tir, 0, univ.EpsilonContact, univ.distRayonMax);
            EnergieLumineuse E = new EnergieLumineuse();
            Vector           A = tir.depart;

            while (r.Longueur < r.distMax)
            {
                Vector X = r.Position();
                foreach (SourceLumineuse sour in univ.sources)
                {
                    Vector           B          = sour.Position();
                    EnergieLumineuse recueBrute = sour.GetEnergieLumineuse(X);
                    Vector           Opacite1   = Rayon.CalculerOpacite(univ, B, X);
                    Vector           Opacite2   = Rayon.CalculerOpacite(univ, X, A);
                    Vector           Opacite    = Opacite1 + Opacite2;
                    if (double.IsInfinity(Opacite2.x) && double.IsInfinity(Opacite2.y) && double.IsInfinity(Opacite2.z))
                    {
                        return(E);
                    }
                    EnergieLumineuse Opacifiee            = recueBrute.Opacifier(Opacite, univ.facteurExtinction);
                    double           angle                = (X - B).Angle(A - X);
                    double           densite              = univ.atmosphere(X).Norme();
                    Vector           FacteurReorientation = univ.reorientationAtmosphere(angle, densite);
                    E += (Opacifiee * FacteurReorientation) * r.Pas;
                }
                r.Avancer(false, univ, new List <ObjetPhysique>());
            }
            return(E);
        }
Beispiel #2
0
        public EnergieLumineuse GetLumiere(Rayon R, int bounceLeft, List <ObjetPhysique> ExclusionContact)
        {
            EnergieLumineuse E = Rayon.CalculerAtmosphere(this, R.tir);

            if (E.isNan())
            {
                ;
            }
            EnergieLumineuse Ei      = new EnergieLumineuse();
            InfoContact      contact = R.Tirer(this, ExclusionContact);

            if (!(contact.Objet is null))
            {
                Vector   Opacite = Rayon.CalculerOpacite(this, R.tir.depart, R.Position());
                Materiau mat     = contact.Objet.getMateriau();
                if (bounceLeft > 0)
                {
                    Tir              rebond    = contact.Rebond();
                    Tir              refrac    = contact.Refraction();
                    Rayon            Rebond    = new Rayon(rebond, 0, R.Pas, R.distMax);
                    Rayon            Refrac    = new Rayon(refrac, 0, R.Pas, R.distMax);
                    EnergieLumineuse LumRebond = GetLumiere(Rebond, bounceLeft - 1, new List <ObjetPhysique>()
                    {
                        contact.Objet
                    });
                    if (!mat.Opaque)
                    {
                        EnergieLumineuse LumRefrac = GetLumiere(Refrac, bounceLeft - 1, new List <ObjetPhysique>()
                        {
                            contact.Objet
                        });
                        Ei += LumRefrac * contact.coeffRefrac(refrac.direction);
                    }
                    Vector Couleur = contact.Objet.CouleurReelle(contact, rebond.direction);
                    Ei += LumRebond * Couleur * contact.coeffRebond(refrac.direction);
                }

                foreach (SourceLumineuse lu in sources)
                {
                    Vector           OpaciteLum   = Rayon.CalculerOpacite(this, lu.Position(), contact.Position);
                    Vector           Sortant      = (lu.Position() - contact.Position).Normer();
                    EnergieLumineuse ArriveeBrute = lu.GetEnergieLumineuse(contact.Position);
                    EnergieLumineuse Attenuee     = ArriveeBrute.Opacifier(OpaciteLum, facteurExtinction);
                    Vector           Couleur      = contact.Objet.CouleurReelle(contact, Sortant);
                    EnergieLumineuse PointContact = Attenuee * Couleur;
                    Ei += PointContact;
                }
                Ei.Opacifier(Opacite, facteurExtinction);
            }
            return(E + Ei);
        }
Beispiel #3
0
        public Bitmap Rendre(Univers univ)
        {
            Bitmap ret = new Bitmap(X_ecran, Y_ecran);
            int    n   = 0;

            for (int x = 0; x < X_ecran; x++)
            {
                for (int y = 0; y < Y_ecran; y++)
                {
                    n++;
                    Tir              tir = GetTirPixel(x, y);
                    Rayon            ray = new Rayon(tir, 0, univ.EpsilonContact, univ.distRayonMax);
                    EnergieLumineuse col = univ.GetLumiere(ray, univ.bounceLimit, new List <ObjetPhysique>());
                    ret.SetPixel(x, y, col.VersRGB());
                    if (n % 100 == 0)
                    {
                        Console.WriteLine((double)n / (X_ecran * Y_ecran));
                    }
                }
            }
            return(ret);
        }
Beispiel #4
0
        public static Vector CalculerOpacite(Univers univ, Vector A, Vector B)
        {
            Rayon r = new Rayon(new Tir((B - A).Normer(), A), univ.PasVolumetrique, univ.PasVolumetrique, univ.distRayonMax);

            return(r.Opacite(univ, (B - A).Norme() - 2 * univ.PasVolumetrique));
        }